1#--------------------------------------------------------------------------- 2# Project: TwlSDK - include 3# File: ARM7-BB.lcf.template 4# 5# Copyright 2007-2008 Nintendo. All rights reserved. 6# 7# These coded instructions, statements, and computer programs contain 8# proprietary information of Nintendo of America Inc. and/or Nintendo 9# Company Ltd., and are protected by Federal copyright law. They may 10# not be disclosed to third parties or copied or duplicated in any form, 11# in whole or in part, without the prior written consent of Nintendo. 12# 13# $Date:: 2008-09-18#$ 14# $Rev: 8573 $ 15# $Author: okubata_ryoma $ 16#--------------------------------------------------------------------------- 17MEMORY 18{ 19 <STATIC.NAME> (RWX) : ORIGIN = <STATIC.ADDRESS>, LENGTH = 0x0 > <STATIC.NAME><PROPERTY.FLXSUFFIX> 20 21 <FOREACH.AUTOLOADS> 22 <AUTOLOAD.NAME> (RWX) : ORIGIN = <AUTOLOAD.ADDRESS>, LENGTH = 0x0 >> <STATIC.NAME><PROPERTY.FLXSUFFIX> 23 <END.AUTOLOADS> 24 binary.AUTOLOAD_INFO (RWX) : ORIGIN = 0, LENGTH = 0x0 >> <STATIC.NAME><PROPERTY.FLXSUFFIX> 25 binary.STATIC_FOOTER (RWX) : ORIGIN = 0, LENGTH = 0x0 >> <STATIC.NAME><PROPERTY.FLXSUFFIX> 26 27 <PROPERTY.OVERLAYDEFS>F (RW) : ORIGIN = 0, LENGTH = 0x0 > <PROPERTY.OVERLAYDEFS><PROPERTY.FLXSUFFIX> 28 <PROPERTY.OVERLAYTABLE>F (RW) : ORIGIN = 0, LENGTH = 0x0 > <PROPERTY.OVERLAYTABLE><PROPERTY.FLXSUFFIX> 29 <FOREACH.OVERLAYS> 30 <OVERLAY.NAME> (RWXO): ORIGIN = <OVERLAY.ADDRESS>, LENGTH = 0x0 > <OVERLAY.NAME><PROPERTY.FLXSUFFIX> 31 <END.OVERLAYS> 32 33 arena.MAIN (RW) : ORIGIN = AFTER(<STATIC.NAME><FOREACH.OVERLAYS>,<OVERLAY.NAME><END.OVERLAYS>), LENGTH = 0x0 34 check.WORKRAM (RWX) : ORIGIN = 0x037f8000, LENGTH = 0x18000 > workram.check 35 check.MAINMEM (RWX) : ORIGIN = 0x02fe0000, LENGTH = 0x1c000 > mainmem.check 36 37 binary.LTDAUTOLOAD_TOP (RW) : ORIGIN = 0, LENGTH = 0x0 > <STATIC.NAME><PROPERTY.LTDSUFFIX> 38 <FOREACH.LTDAUTOLOADS> 39 <LTDAUTOLOAD.NAME> (RWX) : ORIGIN = <LTDAUTOLOAD.ADDRESS>, LENGTH = 0x0 >> <STATIC.NAME><PROPERTY.LTDSUFFIX> 40 <END.LTDAUTOLOADS> 41 binary.LTDAUTOLOAD_INFO (RWX) : ORIGIN = 0, LENGTH = 0x0 >> <STATIC.NAME><PROPERTY.LTDSUFFIX> 42 43 <PROPERTY.LTDOVERLAYDEFS>L (RW) : ORIGIN = 0, LENGTH = 0x0 > <PROPERTY.LTDOVERLAYDEFS><PROPERTY.LTDSUFFIX> 44 <PROPERTY.LTDOVERLAYTABLE>L (RW) : ORIGIN = 0, LENGTH = 0x0 > <PROPERTY.LTDOVERLAYTABLE><PROPERTY.LTDSUFFIX> 45 <FOREACH.LTDOVERLAYS> 46 <LTDOVERLAY.NAME> (RWXO): ORIGIN = <LTDOVERLAY.ADDRESS>, LENGTH = 0x0 > <LTDOVERLAY.NAME><PROPERTY.LTDSUFFIX> 47 <END.LTDOVERLAYS> 48 49 check.LTDWRAM (RWX) : ORIGIN = 0x03000000, LENGTH = 0x40000 > ltdwram.check 50 check.LTDMAIN (RWX) : ORIGIN = 0x02f88000, LENGTH = 0x58000 > ltdmain.check 51} 52 53KEEP_SECTION 54{ 55 .sinit 56} 57 58SECTIONS 59{ 60 ############################ STATIC ################################# 61 .<STATIC.NAME>: 62 { 63 ALIGNALL(4); 64 . = ALIGN(4); 65 66 # 67 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 68 # 69 <FOREACH.STATIC.SEARCHSYMBOLS> 70 SEARCH_SYMBOL <STATIC.SEARCHSYMBOL>; 71 <END.STATIC.SEARCHSYMBOLS> 72 73 # 74 # TEXT BLOCK: READ ONLY 75 # 76 SDK_STATIC_START =.; 77 SDK_STATIC_TEXT_START =.; 78 #:::::::::: text/rodata 79 OBJECT(_start,*) 80 <FOREACH.STATIC.OBJECTS=.text> 81 <STATIC.OBJECT=.text:t> 82 <END.STATIC.OBJECTS> 83 <FOREACH.STATIC.LIBRARIES=.text> 84 <STATIC.LIBRARY=.text:t> 85 <END.STATIC.LIBRARIES> 86 <FOREACH.STATIC.OBJECTS=.rodata> 87 <STATIC.OBJECT=.rodata:t> 88 <END.STATIC.OBJECTS> 89 <FOREACH.STATIC.LIBRARIES=.rodata> 90 <STATIC.LIBRARY=.rodata:t> 91 <END.STATIC.LIBRARIES> 92 <FOREACH.STATIC.OBJECTS=.init> 93 <STATIC.OBJECT=.init:t> 94 <END.STATIC.OBJECTS> 95 <FOREACH.STATIC.LIBRARIES=.init> 96 <STATIC.LIBRARY=.init:t> 97 <END.STATIC.LIBRARIES> 98 . = ALIGN(4); 99 SDK_STATIC_SINIT_START =.; 100 #:::::::::: ctor 101 <FOREACH.STATIC.OBJECTS=.ctor> 102 <STATIC.OBJECT=.ctor:t> 103 <END.STATIC.OBJECTS> 104 <FOREACH.STATIC.LIBRARIES=.ctor> 105 <STATIC.LIBRARY=.ctor:t> 106 <END.STATIC.LIBRARIES> 107 <FOREACH.STATIC.OBJECTS=.sinit> 108 <STATIC.OBJECT=.sinit:t> 109 <END.STATIC.OBJECTS> 110 <FOREACH.STATIC.LIBRARIES=.sinit> 111 <STATIC.LIBRARY=.sinit:t> 112 <END.STATIC.LIBRARIES> 113 WRITEW 0; 114 #:::::::::: ctor 115 SDK_STATIC_SINIT_END =.; 116 #:::::::::: text/rodata 117 SDK_STATIC_TEXT_END =.; 118 119 # 120 # DATA BLOCK: READ WRITE 121 # 122 . = ALIGN(4); 123 SDK_STATIC_DATA_START =.; 124 #:::::::::: Data 125 <FOREACH.STATIC.OBJECTS=.sdata> 126 <STATIC.OBJECT=.sdata:t> 127 <END.STATIC.OBJECTS> 128 <FOREACH.STATIC.LIBRARIES=.sdata> 129 <STATIC.LIBRARY=.sdata:t> 130 <END.STATIC.LIBRARIES> 131 <FOREACH.STATIC.OBJECTS=.data> 132 <STATIC.OBJECT=.data:t> 133 <END.STATIC.OBJECTS> 134 <FOREACH.STATIC.LIBRARIES=.data> 135 <STATIC.LIBRARY=.data:t> 136 <END.STATIC.LIBRARIES> 137 #:::::::::: Data 138 SDK_STATIC_DATA_END =.; 139 . = ALIGN(4); 140 SDK_STATIC_END =.; 141 142 SDK_STATIC_TEXT_SIZE = SDK_STATIC_TEXT_END - SDK_STATIC_TEXT_START; 143 SDK_STATIC_DATA_SIZE = SDK_STATIC_DATA_END - SDK_STATIC_DATA_START; 144 SDK_STATIC_SIZE = SDK_STATIC_END - SDK_STATIC_START; 145 __sinit__ = SDK_STATIC_SINIT_START; # For static initializer 146 147 } > <STATIC.NAME> 148 149 .<STATIC.NAME>.bss: 150 { 151 ALIGNALL(4); 152 . = ALIGN(4); 153 154 # 155 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 156 # 157 <FOREACH.STATIC.SEARCHSYMBOLS> 158 SEARCH_SYMBOL <STATIC.SEARCHSYMBOL>; 159 <END.STATIC.SEARCHSYMBOLS> 160 161 # 162 # BSS BLOCK 163 # 164 SDK_STATIC_BSS_START =.; 165 #:::::::::: bss 166 <FOREACH.STATIC.OBJECTS=.sbss> 167 <STATIC.OBJECT=.sbss:t> 168 <END.STATIC.OBJECTS> 169 <FOREACH.STATIC.LIBRARIES=.sbss> 170 <STATIC.LIBRARY=.sbss:t> 171 <END.STATIC.LIBRARIES> 172 <FOREACH.STATIC.OBJECTS=.bss> 173 <STATIC.OBJECT=.bss:t> 174 <END.STATIC.OBJECTS> 175 <FOREACH.STATIC.LIBRARIES=.bss> 176 <STATIC.LIBRARY=.bss:t> 177 <END.STATIC.LIBRARIES> 178 #:::::::::: bss 179 . = ALIGN(4); 180 SDK_STATIC_BSS_END = .; 181 182 SDK_STATIC_BSS_SIZE = SDK_STATIC_BSS_END - SDK_STATIC_BSS_START; 183 184 } >> <STATIC.NAME> 185 186 187 ############################ AUTOLOADS ############################## 188 SDK_AUTOLOAD.MAIN.START = 0x02fe0000; 189 SDK_AUTOLOAD.MAIN.END = SDK_AUTOLOAD.MAIN.START; 190 SDK_AUTOLOAD.MAIN.BSS_END = SDK_AUTOLOAD.MAIN.START; 191 SDK_AUTOLOAD.MAIN.SIZE = 0; 192 SDK_AUTOLOAD.MAIN.BSS_SIZE = 0; 193 SDK_AUTOLOAD.WRAM.START = 0x037f8000; 194 SDK_AUTOLOAD.WRAM.END = SDK_AUTOLOAD.WRAM.START; 195 SDK_AUTOLOAD.WRAM.BSS_END = SDK_AUTOLOAD.WRAM.START; 196 SDK_AUTOLOAD.WRAM.SIZE = 0; 197 SDK_AUTOLOAD.WRAM.BSS_SIZE = 0; 198 SDK_AUTOLOAD_START = SDK_STATIC_END; 199 SDK_AUTOLOAD_SIZE = 0; 200 SDK_AUTOLOAD_NUMBER = <NUMBER.AUTOLOADS>; 201 202<FOREACH.AUTOLOADS> 203 .<AUTOLOAD.NAME>: 204 { 205 ALIGNALL(4); 206 . = ALIGN(4); 207 208 # 209 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 210 # 211 <FOREACH.AUTOLOAD.SEARCHSYMBOLS> 212 SEARCH_SYMBOL <AUTOLOAD.SEARCHSYMBOL>; 213 <END.AUTOLOAD.SEARCHSYMBOLS> 214 215 # 216 # TEXT BLOCK: READ ONLY 217 # 218 SDK_AUTOLOAD_<AUTOLOAD.NAME>_ID =<AUTOLOAD.ID>; 219 SDK_AUTOLOAD.<AUTOLOAD.NAME>.ID =<AUTOLOAD.ID>; 220 SDK_AUTOLOAD.<AUTOLOAD.NAME>.START =.; 221 SDK_AUTOLOAD.<AUTOLOAD.NAME>.TEXT_START =.; 222 #:::::::::: text/rodata 223 <FOREACH.AUTOLOAD.OBJECTS=.text> 224 <AUTOLOAD.OBJECT=.text:t> 225 <END.AUTOLOAD.OBJECTS> 226 <FOREACH.AUTOLOAD.LIBRARIES=.text> 227 <AUTOLOAD.LIBRARY=.text:t> 228 <END.AUTOLOAD.LIBRARIES> 229 <FOREACH.AUTOLOAD.OBJECTS=.etable> 230 <AUTOLOAD.OBJECT=.exception:t> 231 . = ALIGN(4); 232 SDK_STATIC_ETABLE_START =.; 233 __exception_table_start__ =.; 234 EXCEPTION 235 __exception_table_end__ =.; 236 SDK_STATIC_ETABLE_END =.; 237 <END.AUTOLOAD.OBJECTS> 238 <FOREACH.AUTOLOAD.OBJECTS=.rodata> 239 <AUTOLOAD.OBJECT=.rodata:t> 240 <END.AUTOLOAD.OBJECTS> 241 <FOREACH.AUTOLOAD.LIBRARIES=.rodata> 242 <AUTOLOAD.LIBRARY=.rodata:t> 243 <END.AUTOLOAD.LIBRARIES> 244 <FOREACH.AUTOLOAD.OBJECTS=.init> 245 <AUTOLOAD.OBJECT=.init:t> 246 <END.AUTOLOAD.OBJECTS> 247 <FOREACH.AUTOLOAD.LIBRARIES=.init> 248 <AUTOLOAD.LIBRARY=.init:t> 249 <END.AUTOLOAD.LIBRARIES> 250 . = ALIGN(4); 251 SDK_AUTOLOAD.<AUTOLOAD.NAME>.SINIT_START =.; 252 #:::::::::: ctor 253 <FOREACH.AUTOLOAD.OBJECTS=.ctor> 254 <AUTOLOAD.OBJECT=.ctor:t> 255 <END.AUTOLOAD.OBJECTS> 256 <FOREACH.AUTOLOAD.LIBRARIES=.ctor> 257 <AUTOLOAD.LIBRARY=.ctor:t> 258 <END.AUTOLOAD.LIBRARIES> 259 <FOREACH.AUTOLOAD.OBJECTS=.sinit> 260 <AUTOLOAD.OBJECT=.sinit:t> 261 <END.AUTOLOAD.OBJECTS> 262 <FOREACH.AUTOLOAD.LIBRARIES=.sinit> 263 <AUTOLOAD.LIBRARY=.sinit:t> 264 <END.AUTOLOAD.LIBRARIES> 265 WRITEW 0; 266 #:::::::::: ctor 267 SDK_AUTOLOAD.<AUTOLOAD.NAME>.SINIT_END =.; 268 #:::::::::: text/rodata 269 SDK_AUTOLOAD.<AUTOLOAD.NAME>.TEXT_END =.; 270 271 # 272 # DATA BLOCK: READ WRITE BLOCK 273 # 274 . = ALIGN(4); 275 SDK_AUTOLOAD.<AUTOLOAD.NAME>.DATA_START =.; 276 #:::::::::: Data 277 <FOREACH.AUTOLOAD.OBJECTS=.wram> 278 <AUTOLOAD.OBJECT=.wram:t> 279 <END.AUTOLOAD.OBJECTS> 280 <FOREACH.AUTOLOAD.LIBRARIES=.wram> 281 <AUTOLOAD.LIBRARY=.wram:t> 282 <END.AUTOLOAD.LIBRARIES> 283 <FOREACH.AUTOLOAD.OBJECTS=.sdata> 284 <AUTOLOAD.OBJECT=.sdata:t> 285 <END.AUTOLOAD.OBJECTS> 286 <FOREACH.AUTOLOAD.LIBRARIES=.sdata> 287 <AUTOLOAD.LIBRARY=.sdata:t> 288 <END.AUTOLOAD.LIBRARIES> 289 <FOREACH.AUTOLOAD.OBJECTS=.data> 290 <AUTOLOAD.OBJECT=.data:t> 291 <END.AUTOLOAD.OBJECTS> 292 <FOREACH.AUTOLOAD.LIBRARIES=.data> 293 <AUTOLOAD.LIBRARY=.data:t> 294 <END.AUTOLOAD.LIBRARIES> 295 #:::::::::: Data 296 SDK_AUTOLOAD.<AUTOLOAD.NAME>.DATA_END =.; 297 . = ALIGN(4); 298 SDK_AUTOLOAD.<AUTOLOAD.NAME>.END =.; 299 300 SDK_AUTOLOAD.<AUTOLOAD.NAME>.TEXT_SIZE = SDK_AUTOLOAD.<AUTOLOAD.NAME>.TEXT_END - SDK_AUTOLOAD.<AUTOLOAD.NAME>.TEXT_START; 301 SDK_AUTOLOAD.<AUTOLOAD.NAME>.DATA_SIZE = SDK_AUTOLOAD.<AUTOLOAD.NAME>.DATA_END - SDK_AUTOLOAD.<AUTOLOAD.NAME>.DATA_START; 302 SDK_AUTOLOAD.<AUTOLOAD.NAME>.SIZE = SDK_AUTOLOAD.<AUTOLOAD.NAME>.END - SDK_AUTOLOAD.<AUTOLOAD.NAME>.START; 303 SDK_AUTOLOAD_SIZE = SDK_AUTOLOAD_SIZE + SDK_AUTOLOAD.<AUTOLOAD.NAME>.SIZE; 304 305 } > <AUTOLOAD.NAME> 306 307 .<AUTOLOAD.NAME>.bss: 308 { 309 ALIGNALL(4); 310 . = ALIGN(4); 311 312 # 313 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 314 # 315 <FOREACH.AUTOLOAD.SEARCHSYMBOLS> 316 SEARCH_SYMBOL <AUTOLOAD.SEARCHSYMBOL>; 317 <END.AUTOLOAD.SEARCHSYMBOLS> 318 319 # 320 # BSS BLOCK 321 # 322 SDK_AUTOLOAD.<AUTOLOAD.NAME>.BSS_START = .; 323 #:::::::::: bss 324 <FOREACH.AUTOLOAD.OBJECTS=.wram> 325 <AUTOLOAD.OBJECT=.wram.bss:t> 326 <END.AUTOLOAD.OBJECTS> 327 <FOREACH.AUTOLOAD.LIBRARIES=.wram> 328 <AUTOLOAD.LIBRARY=.wram.bss:t> 329 <END.AUTOLOAD.LIBRARIES> 330 <FOREACH.AUTOLOAD.OBJECTS=.sbss> 331 <AUTOLOAD.OBJECT=.sbss:t> 332 <END.AUTOLOAD.OBJECTS> 333 <FOREACH.AUTOLOAD.LIBRARIES=.sbss> 334 <AUTOLOAD.LIBRARY=.sbss:t> 335 <END.AUTOLOAD.LIBRARIES> 336 <FOREACH.AUTOLOAD.OBJECTS=.bss> 337 <AUTOLOAD.OBJECT=.bss:t> 338 <END.AUTOLOAD.OBJECTS> 339 <FOREACH.AUTOLOAD.LIBRARIES=.bss> 340 <AUTOLOAD.LIBRARY=.bss:t> 341 <END.AUTOLOAD.LIBRARIES> 342 #:::::::::: bss 343 . = ALIGN(4); 344 SDK_AUTOLOAD.<AUTOLOAD.NAME>.BSS_END = .; 345 346 SDK_AUTOLOAD.<AUTOLOAD.NAME>.BSS_SIZE = SDK_AUTOLOAD.<AUTOLOAD.NAME>.BSS_END - SDK_AUTOLOAD.<AUTOLOAD.NAME>.BSS_START; 347 348 } >> <AUTOLOAD.NAME> 349 350<END.AUTOLOADS> 351 352 SDK_AUTOLOAD_MAIN_START = SDK_AUTOLOAD.MAIN.START; 353 SDK_AUTOLOAD_MAIN_END = SDK_AUTOLOAD.MAIN.END; 354 SDK_AUTOLOAD_MAIN_BSS_END = SDK_AUTOLOAD.MAIN.BSS_END; 355 SDK_AUTOLOAD_MAIN_SIZE = SDK_AUTOLOAD.MAIN.SIZE; 356 SDK_AUTOLOAD_MAIN_BSS_SIZE = SDK_AUTOLOAD.MAIN.BSS_SIZE; 357 SDK_AUTOLOAD_WRAM_START = SDK_AUTOLOAD.WRAM.START; 358 SDK_AUTOLOAD_WRAM_END = SDK_AUTOLOAD.WRAM.END; 359 SDK_AUTOLOAD_WRAM_BSS_END = SDK_AUTOLOAD.WRAM.BSS_END; 360 SDK_AUTOLOAD_WRAM_SIZE = SDK_AUTOLOAD.WRAM.SIZE; 361 SDK_AUTOLOAD_WRAM_BSS_SIZE = SDK_AUTOLOAD.WRAM.BSS_SIZE; 362 363 ############################ AUTOLOAD_INFO ########################## 364 .binary.AUTOLOAD_INFO: 365 { 366 <FOREACH.AUTOLOADS> 367 WRITEW ADDR(.<AUTOLOAD.NAME>); 368 WRITEW SDK_AUTOLOAD.<AUTOLOAD.NAME>.SIZE; 369 WRITEW SDK_AUTOLOAD.<AUTOLOAD.NAME>.SINIT_START; 370 WRITEW SDK_AUTOLOAD.<AUTOLOAD.NAME>.BSS_SIZE; 371 <END.AUTOLOADS> 372 373 } > binary.AUTOLOAD_INFO 374 375 SDK_AUTOLOAD_LIST = SDK_AUTOLOAD_START + SDK_AUTOLOAD_SIZE; 376 SDK_AUTOLOAD_LIST_END = SDK_AUTOLOAD_START + SDK_AUTOLOAD_SIZE + SIZEOF(.binary.AUTOLOAD_INFO); 377 SDK_AUTOLOAD_SIZE = SDK_AUTOLOAD_SIZE + SIZEOF(.binary.AUTOLOAD_INFO); 378 379 ############################ STATIC_FOOTER ########################## 380 .binary.STATIC_FOOTER: 381 { 382 WRITEW 0xdec00621; # LE(0x2106C0DE) = NITRO CODE 383 WRITEW _start_ModuleParams - ADDR(.<STATIC.NAME>); 384 WRITEW 0; # NO DIGEST 385 WRITEW _start_LtdModuleParams - ADDR(.<STATIC.NAME>); 386 } > binary.STATIC_FOOTER 387 388 ############################ OVERLAYS ############################### 389 SDK_OVERLAY_NUMBER = <NUMBER.OVERLAYS>; 390 391<FOREACH.OVERLAYS> 392 .<OVERLAY.NAME>:<OVERLAY.NAME> 393 { 394 ALIGNALL(4); 395 . = ALIGN(4); 396 397 # 398 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 399 # 400 <FOREACH.OVERLAY.SEARCHSYMBOLS> 401 SEARCH_SYMBOL <OVERLAY.SEARCHSYMBOL>; 402 <END.OVERLAY.SEARCHSYMBOLS> 403 404 # 405 # TEXT BLOCK: READ ONLY 406 # 407 SDK_OVERLAY_<OVERLAY.NAME>_ID =<OVERLAY.ID>; ### SEGMENT <OVERLAY.NAME> OVERLAY ID 408 SDK_OVERLAY.<OVERLAY.NAME>.ID =<OVERLAY.ID>; 409 SDK_OVERLAY.<OVERLAY.NAME>.START =.; 410 SDK_OVERLAY.<OVERLAY.NAME>.TEXT_START =.; 411 #:::::::::: text/rodata 412 <FOREACH.OVERLAY.OBJECTS=.text> 413 <OVERLAY.OBJECT=.text:t> 414 <END.OVERLAY.OBJECTS> 415 <FOREACH.OVERLAY.LIBRARIES=.text> 416 <OVERLAY.LIBRARY=.text:t> 417 <END.OVERLAY.LIBRARIES> 418 <FOREACH.OVERLAY.OBJECTS=.rodata> 419 <OVERLAY.OBJECT=.rodata:t> 420 <END.OVERLAY.OBJECTS> 421 <FOREACH.OVERLAY.LIBRARIES=.rodata> 422 <OVERLAY.LIBRARY=.rodata:t> 423 <END.OVERLAY.LIBRARIES> 424 <FOREACH.OVERLAY.OBJECTS=.init> 425 <OVERLAY.OBJECT=.init:t> 426 <END.OVERLAY.OBJECTS> 427 <FOREACH.OVERLAY.LIBRARIES=.init> 428 <OVERLAY.LIBRARY=.init:t> 429 <END.OVERLAY.LIBRARIES> 430 . = ALIGN(4); 431 SDK_OVERLAY.<OVERLAY.NAME>.SINIT_START =.; 432 #:::::::::: ctor 433 <FOREACH.OVERLAY.OBJECTS=.ctor> 434 <OVERLAY.OBJECT=.ctor:t> 435 <END.OVERLAY.OBJECTS> 436 <FOREACH.OVERLAY.LIBRARIES=.ctor> 437 <OVERLAY.LIBRARY=.ctor:t> 438 <END.OVERLAY.LIBRARIES> 439 <FOREACH.OVERLAY.OBJECTS=.sinit> 440 <OVERLAY.OBJECT=.sinit:t> 441 <END.OVERLAY.OBJECTS> 442 <FOREACH.OVERLAY.LIBRARIES=.sinit> 443 <OVERLAY.LIBRARY=.sinit:t> 444 <END.OVERLAY.LIBRARIES> 445 WRITEW 0; 446 #:::::::::: ctor 447 SDK_OVERLAY.<OVERLAY.NAME>.SINIT_END =.; 448 #:::::::::: text/rodata 449 SDK_OVERLAY.<OVERLAY.NAME>.TEXT_END =.; 450 451 # 452 # DATA BLOCK: READ WRITE 453 # 454 . = ALIGN(4); 455 SDK_OVERLAY.<OVERLAY.NAME>.DATA_START =.; 456 #:::::::::: Data 457 <FOREACH.OVERLAY.OBJECTS=.sdata> 458 <OVERLAY.OBJECT=.sdata:t> 459 <END.OVERLAY.OBJECTS> 460 <FOREACH.OVERLAY.LIBRARIES=.sdata> 461 <OVERLAY.LIBRARY=.sdata:t> 462 <END.OVERLAY.LIBRARIES> 463 <FOREACH.OVERLAY.OBJECTS=.data> 464 <OVERLAY.OBJECT=.data:t> 465 <END.OVERLAY.OBJECTS> 466 <FOREACH.OVERLAY.LIBRARIES=.data> 467 <OVERLAY.LIBRARY=.data:t> 468 <END.OVERLAY.LIBRARIES> 469 #:::::::::: Data 470 SDK_OVERLAY.<OVERLAY.NAME>.DATA_END =.; 471 . = ALIGN(4); 472 SDK_OVERLAY.<OVERLAY.NAME>.END =.; 473 474 SDK_OVERLAY.<OVERLAY.NAME>.TEXT_SIZE = SDK_OVERLAY.<OVERLAY.NAME>.TEXT_END - SDK_OVERLAY.<OVERLAY.NAME>.TEXT_START; 475 SDK_OVERLAY.<OVERLAY.NAME>.DATA_SIZE = SDK_OVERLAY.<OVERLAY.NAME>.DATA_END - SDK_OVERLAY.<OVERLAY.NAME>.DATA_START; 476 SDK_OVERLAY.<OVERLAY.NAME>.SIZE = SDK_OVERLAY.<OVERLAY.NAME>.END - SDK_OVERLAY.<OVERLAY.NAME>.START; 477 478 } > <OVERLAY.NAME> 479 480 .<OVERLAY.NAME>.bss:<OVERLAY.NAME> 481 { 482 ALIGNALL(4); 483 . = ALIGN(4); 484 485 # 486 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 487 # 488 <FOREACH.OVERLAY.SEARCHSYMBOLS> 489 SEARCH_SYMBOL <OVERLAY.SEARCHSYMBOL>; 490 <END.OVERLAY.SEARCHSYMBOLS> 491 492 # 493 # BSS BLOCK 494 # 495 SDK_OVERLAY.<OVERLAY.NAME>.BSS_START = .; 496 #:::::::::: bss 497 <FOREACH.OVERLAY.OBJECTS=.bss> 498 <OVERLAY.OBJECT=.bss:t> 499 <END.OVERLAY.OBJECTS> 500 <FOREACH.OVERLAY.LIBRARIES=.bss> 501 <OVERLAY.LIBRARY=.bss:t> 502 <END.OVERLAY.LIBRARIES> 503 <FOREACH.OVERLAY.OBJECTS=.sbss> 504 <OVERLAY.OBJECT=.sbss:t> 505 <END.OVERLAY.OBJECTS> 506 <FOREACH.OVERLAY.LIBRARIES=.sbss> 507 <OVERLAY.LIBRARY=.sbss:t> 508 <END.OVERLAY.LIBRARIES> 509 #:::::::::: bss 510 . = ALIGN(4); 511 SDK_OVERLAY.<OVERLAY.NAME>.BSS_END = .; 512 513 SDK_OVERLAY.<OVERLAY.NAME>.BSS_SIZE = SDK_OVERLAY.<OVERLAY.NAME>.BSS_END - SDK_OVERLAY.<OVERLAY.NAME>.BSS_START; 514 515 } >> <OVERLAY.NAME> 516 517<END.OVERLAYS> 518 519 ############################ ARENA ################################## 520 .arena.MAIN: 521 { 522 . = ALIGN(4); 523 SDK_SECTION_ARENA_START =.; 524 525 } > arena.MAIN 526 527 ############################ OVERLAYDEFS ############################ 528 .<PROPERTY.OVERLAYDEFS>F: 529 { 530 ### <STATIC.NAME> module information 531 WRITEW ADDR(.<STATIC.NAME>); # Load address 532 WRITEW _start; # Entry address 533 WRITEW SDK_STATIC_SIZE + SDK_AUTOLOAD_SIZE; # Size of module 534 WRITEW _start_AutoloadDoneCallback; # Callback autoload done 535 536 ### overlay filename 537 <FOREACH.OVERLAYS> 538 WRITES ("<OVERLAY.NAME><PROPERTY.FLXSUFFIX>"); # Overlay <OVERLAY.ID> 539 <END.OVERLAYS> 540 541 } > <PROPERTY.OVERLAYDEFS>F 542 543 ############################ OVERLAYTABLE ########################### 544 .<PROPERTY.OVERLAYTABLE>F: 545 { 546 <FOREACH.OVERLAYS> 547 WRITEW <OVERLAY.ID>; # Overlay ID 548 WRITEW ADDR(.<OVERLAY.NAME>); # Load address 549 WRITEW SDK_OVERLAY.<OVERLAY.NAME>.SIZE; # Size of module 550 WRITEW SDK_OVERLAY.<OVERLAY.NAME>.BSS_SIZE; # Size of bss 551 WRITEW SDK_OVERLAY.<OVERLAY.NAME>.SINIT_START; # Start address of static init 552 WRITEW SDK_OVERLAY.<OVERLAY.NAME>.SINIT_END; # End address of static init 553 WRITEW <OVERLAY.ID>; # ROM file ID 554 WRITEW 0; # Reserved 555 <END.OVERLAYS> 556 557 } > <PROPERTY.OVERLAYTABLE>F 558 559 ############################ OTHERS ################################# 560 SDK_WRAM_ARENA_LO = SDK_AUTOLOAD.WRAM.BSS_END; 561 SDK_SUBPRIV_ARENA_LO = SDK_AUTOLOAD.MAIN.BSS_END; 562 SDK_IRQ_STACKSIZE = <STATIC.IRQSTACKSIZE>; # Allocated in WRAM 563 SDK_SYS_STACKSIZE = <STATIC.STACKSIZE>; # Allocated in WRAM 564 SDK_SYS_STACKSIZE_SIGN = (SDK_SYS_STACKSIZE < 0x80000000) * 2 - 1; 565 566 .check.WORKRAM: 567 { 568 . = . + SDK_AUTOLOAD.WRAM.BSS_END - SDK_AUTOLOAD.WRAM.START + 0x080 + SDK_IRQ_STACKSIZE + SDK_SYS_STACKSIZE * SDK_SYS_STACKSIZE_SIGN; 569 570 } > check.WORKRAM 571 572 .check.MAINMEM: 573 { 574 . = SDK_SUBPRIV_ARENA_LO; 575 576 } > check.MAINMEM 577 578 ########################### LTDAUTOLOADS ############################ 579 SDK_LTDAUTOLOAD.LTDMAIN.START = SDK_STATIC_BSS_END; 580 SDK_LTDAUTOLOAD.LTDMAIN.END = SDK_LTDAUTOLOAD.LTDMAIN.START; 581 SDK_LTDAUTOLOAD.LTDMAIN.BSS_END = SDK_LTDAUTOLOAD.LTDMAIN.START; 582 SDK_LTDAUTOLOAD.LTDMAIN.SIZE = 0; 583 SDK_LTDAUTOLOAD.LTDMAIN.BSS_SIZE = 0; 584 SDK_LTDAUTOLOAD.LTDWRAM.START = 0x03000000; 585 SDK_LTDAUTOLOAD.LTDWRAM.END = SDK_LTDAUTOLOAD.LTDWRAM.START; 586 SDK_LTDAUTOLOAD.LTDWRAM.BSS_END = SDK_LTDAUTOLOAD.LTDWRAM.START; 587 SDK_LTDAUTOLOAD.LTDWRAM.SIZE = 0; 588 SDK_LTDAUTOLOAD.LTDWRAM.BSS_SIZE = 0; 589 SDK_LTDAUTOLOAD_TOP_START = 0x02e80000; 590 SDK_LTDAUTOLOAD_TOP_SIZE = 4; # While there is no STATIC region, a 4-byte dummy is at the top of the binary file 591 SDK_LTDAUTOLOAD_START = SDK_LTDAUTOLOAD_TOP_START + SDK_LTDAUTOLOAD_TOP_SIZE; 592 SDK_LTDAUTOLOAD_SIZE = 0; 593 SDK_LTDAUTOLOAD_NUMBER = <NUMBER.LTDAUTOLOADS>; 594 595 .binary.LTDAUTOLOAD_TOP: 596 { 597 WRITEW 0xdeadbeef; 598 599 } > binary.LTDAUTOLOAD_TOP 600 601<FOREACH.LTDAUTOLOADS> 602 .<LTDAUTOLOAD.NAME>: 603 { 604 ALIGNALL(4); 605 . = ALIGN(4); 606 607 # 608 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 609 # 610 <FOREACH.LTDAUTOLOAD.SEARCHSYMBOLS> 611 SEARCH_SYMBOL <LTDAUTOLOAD.SEARCHSYMBOL>; 612 <END.LTDAUTOLOAD.SEARCHSYMBOLS> 613 614 SDK_LTDAUTOLOAD_<LTDAUTOLOAD.NAME>_ID =<LTDAUTOLOAD.ID>; 615 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.ID =<LTDAUTOLOAD.ID>; 616 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.START =.; 617 # 618 # TEXT BLOCK: READ ONLY 619 # 620 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_START =.; 621 #:::::::::: text/rodata 622 <FOREACH.LTDAUTOLOAD.OBJECTS=.text> 623 <LTDAUTOLOAD.OBJECT=.text:t> 624 <END.LTDAUTOLOAD.OBJECTS> 625 <FOREACH.LTDAUTOLOAD.LIBRARIES=.text> 626 <LTDAUTOLOAD.LIBRARY=.text:t> 627 <END.LTDAUTOLOAD.LIBRARIES> 628 <FOREACH.LTDAUTOLOAD.OBJECTS=.rodata> 629 <LTDAUTOLOAD.OBJECT=.rodata:t> 630 <END.LTDAUTOLOAD.OBJECTS> 631 <FOREACH.LTDAUTOLOAD.LIBRARIES=.rodata> 632 <LTDAUTOLOAD.LIBRARY=.rodata:t> 633 <END.LTDAUTOLOAD.LIBRARIES> 634 <FOREACH.LTDAUTOLOAD.OBJECTS=.init> 635 <LTDAUTOLOAD.OBJECT=.init:t> 636 <END.LTDAUTOLOAD.OBJECTS> 637 <FOREACH.LTDAUTOLOAD.LIBRARIES=.init> 638 <LTDAUTOLOAD.LIBRARY=.init:t> 639 <END.LTDAUTOLOAD.LIBRARIES> 640 . = ALIGN(4); 641 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SINIT_START =.; 642 #:::::::::: ctor 643 <FOREACH.LTDAUTOLOAD.OBJECTS=.ctor> 644 <LTDAUTOLOAD.OBJECT=.ctor:t> 645 <END.LTDAUTOLOAD.OBJECTS> 646 <FOREACH.LTDAUTOLOAD.LIBRARIES=.ctor> 647 <LTDAUTOLOAD.LIBRARY=.ctor:t> 648 <END.LTDAUTOLOAD.LIBRARIES> 649 <FOREACH.LTDAUTOLOAD.OBJECTS=.sinit> 650 <LTDAUTOLOAD.OBJECT=.sinit:t> 651 <END.LTDAUTOLOAD.OBJECTS> 652 <FOREACH.LTDAUTOLOAD.LIBRARIES=.sinit> 653 <LTDAUTOLOAD.LIBRARY=.sinit:t> 654 <END.LTDAUTOLOAD.LIBRARIES> 655 WRITEW 0; 656 #:::::::::: ctor 657 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SINIT_END =.; 658 #:::::::::: text/rodata 659 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_END =.; 660 661 # 662 # DATA BLOCK: READ WRITE BLOCK 663 # 664 . = ALIGN(4); 665 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_START =.; 666 #:::::::::: Data 667 <FOREACH.LTDAUTOLOAD.OBJECTS=.sdata> 668 <LTDAUTOLOAD.OBJECT=.sdata:t> 669 <END.LTDAUTOLOAD.OBJECTS> 670 <FOREACH.LTDAUTOLOAD.LIBRARIES=.sdata> 671 <LTDAUTOLOAD.LIBRARY=.sdata:t> 672 <END.LTDAUTOLOAD.LIBRARIES> 673 <FOREACH.LTDAUTOLOAD.OBJECTS=.data> 674 <LTDAUTOLOAD.OBJECT=.data:t> 675 <END.LTDAUTOLOAD.OBJECTS> 676 <FOREACH.LTDAUTOLOAD.LIBRARIES=.data> 677 <LTDAUTOLOAD.LIBRARY=.data:t> 678 <END.LTDAUTOLOAD.LIBRARIES> 679 <FOREACH.LTDAUTOLOAD.OBJECTS=.ltdwram> 680 <LTDAUTOLOAD.OBJECT=.ltdwram:t> 681 <END.LTDAUTOLOAD.OBJECTS> 682 <FOREACH.LTDAUTOLOAD.LIBRARIES=.ltdwram> 683 <LTDAUTOLOAD.LIBRARY=.ltdwram:t> 684 <END.LTDAUTOLOAD.LIBRARIES> 685 <FOREACH.LTDAUTOLOAD.OBJECTS=.ltdmain> 686 <LTDAUTOLOAD.OBJECT=.ltdmain:t> 687 <END.LTDAUTOLOAD.OBJECTS> 688 <FOREACH.LTDAUTOLOAD.LIBRARIES=.ltdmain> 689 <LTDAUTOLOAD.LIBRARY=.ltdmain:t> 690 <END.LTDAUTOLOAD.LIBRARIES> 691 #:::::::::: Data 692 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_END =.; 693 . = ALIGN(4); 694 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.END =.; 695 696 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_SIZE = SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_END - SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_START; 697 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_SIZE = SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_END - SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_START; 698 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SIZE = SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.END - SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.START; 699 SDK_LTDAUTOLOAD_SIZE = SDK_LTDAUTOLOAD_SIZE + SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SIZE; 700 701 } > <LTDAUTOLOAD.NAME> 702 703 .<LTDAUTOLOAD.NAME>.bss: 704 { 705 ALIGNALL(4); 706 . = ALIGN(4); 707 708 # 709 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 710 # 711 <FOREACH.LTDAUTOLOAD.SEARCHSYMBOLS> 712 SEARCH_SYMBOL <LTDAUTOLOAD.SEARCHSYMBOL>; 713 <END.LTDAUTOLOAD.SEARCHSYMBOLS> 714 715 # 716 # BSS BLOCK 717 # 718 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_START =.; 719 #:::::::::: bss 720 <FOREACH.LTDAUTOLOAD.OBJECTS=.sbss> 721 <LTDAUTOLOAD.OBJECT=.sbss:t> 722 <END.LTDAUTOLOAD.OBJECTS> 723 <FOREACH.LTDAUTOLOAD.LIBRARIES=.sbss> 724 <LTDAUTOLOAD.LIBRARY=.sbss:t> 725 <END.LTDAUTOLOAD.LIBRARIES> 726 <FOREACH.LTDAUTOLOAD.OBJECTS=.bss> 727 <LTDAUTOLOAD.OBJECT=.bss:t> 728 <END.LTDAUTOLOAD.OBJECTS> 729 <FOREACH.LTDAUTOLOAD.LIBRARIES=.bss> 730 <LTDAUTOLOAD.LIBRARY=.bss:t> 731 <END.LTDAUTOLOAD.LIBRARIES> 732 <FOREACH.LTDAUTOLOAD.OBJECTS=.ltdwram> 733 <LTDAUTOLOAD.OBJECT=.ltdwram.bss:t> 734 <END.LTDAUTOLOAD.OBJECTS> 735 <FOREACH.LTDAUTOLOAD.LIBRARIES=.ltdwram> 736 <LTDAUTOLOAD.LIBRARY=.ltdwram.bss:t> 737 <END.LTDAUTOLOAD.LIBRARIES> 738 <FOREACH.LTDAUTOLOAD.OBJECTS=.ltdmain> 739 <LTDAUTOLOAD.OBJECT=.ltdmain.bss:t> 740 <END.LTDAUTOLOAD.OBJECTS> 741 <FOREACH.LTDAUTOLOAD.LIBRARIES=.ltdmain> 742 <LTDAUTOLOAD.LIBRARY=.ltdmain.bss:t> 743 <END.LTDAUTOLOAD.LIBRARIES> 744 #:::::::::: bss 745 . = ALIGN(4); 746 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_END =.; 747 748 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_SIZE = SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_END - SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_START; 749 750 } >> <LTDAUTOLOAD.NAME> 751 752<END.LTDAUTOLOADS> 753 754 SDK_LTDAUTOLOAD_LTDMAIN_START = SDK_LTDAUTOLOAD.LTDMAIN.START; 755 SDK_LTDAUTOLOAD_LTDMAIN_END = SDK_LTDAUTOLOAD.LTDMAIN.END; 756 SDK_LTDAUTOLOAD_LTDMAIN_BSS_END = SDK_LTDAUTOLOAD.LTDMAIN.BSS_END; 757 SDK_LTDAUTOLOAD_LTDMAIN_SIZE = SDK_LTDAUTOLOAD.LTDMAIN.SIZE; 758 SDK_LTDAUTOLOAD_LTDMAIN_BSS_SIZE = SDK_LTDAUTOLOAD.LTDMAIN.BSS_SIZE; 759 SDK_LTDAUTOLOAD_LTDWRAM_START = SDK_LTDAUTOLOAD.LTDWRAM.START; 760 SDK_LTDAUTOLOAD_LTDWRAM_END = SDK_LTDAUTOLOAD.LTDWRAM.END; 761 SDK_MOUNT_INFO_TABLE = SDK_LTDAUTOLOAD.LTDWRAM.BSS_END; 762 SDK_LTDAUTOLOAD_LTDWRAM_BSS_END = SDK_MOUNT_INFO_TABLE + 0x400; 763 SDK_LTDAUTOLOAD_LTDWRAM_SIZE = SDK_LTDAUTOLOAD.LTDWRAM.SIZE; 764 SDK_LTDAUTOLOAD_LTDWRAM_BSS_SIZE = SDK_LTDAUTOLOAD.LTDWRAM.BSS_SIZE; 765 766 ######################### LTDAUTOLOAD_INFO ########################## 767 .binary.LTDAUTOLOAD_INFO: 768 { 769 <FOREACH.LTDAUTOLOADS> 770 WRITEW ADDR(.<LTDAUTOLOAD.NAME>); 771 WRITEW SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SIZE; 772 WRITEW SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SINIT_START; 773 WRITEW SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_SIZE; 774 <END.LTDAUTOLOADS> 775 776 } > binary.LTDAUTOLOAD_INFO 777 778 SDK_LTDAUTOLOAD_LIST = SDK_LTDAUTOLOAD_START + SDK_LTDAUTOLOAD_SIZE; 779 SDK_LTDAUTOLOAD_LIST_END = SDK_LTDAUTOLOAD_LIST + SIZEOF(.binary.LTDAUTOLOAD_INFO); 780 SDK_LTDAUTOLOAD_SIZE = SDK_LTDAUTOLOAD_SIZE + SIZEOF(.binary.LTDAUTOLOAD_INFO); 781 782 ########################### LTDOVERLAYS ############################# 783 SDK_LTDOVERLAY_NUMBER = <NUMBER.LTDOVERLAYS>; 784 785<FOREACH.LTDOVERLAYS> 786 .<LTDOVERLAY.NAME>:<LTDOVERLAY.NAME> 787 { 788 ALIGNALL(4); 789 . = ALIGN(4); 790 791 # 792 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 793 # 794 <FOREACH.LTDOVERLAY.SEARCHSYMBOLS> 795 SEARCH_SYMBOL <LTDOVERLAY.SEARCHSYMBOL>; 796 <END.LTDOVERLAY.SEARCHSYMBOLS> 797 798 SDK_LTDOVERLAY_<LTDOVERLAY.NAME>_ID =<LTDOVERLAY.ID>; 799 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.ID =<LTDOVERLAY.ID>; 800 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.START =.; 801 # 802 # TEXT BLOCK: READ ONLY 803 # 804 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_START =.; 805 #:::::::::: text/rodata 806 <FOREACH.LTDOVERLAY.OBJECTS=.text> 807 <LTDOVERLAY.OBJECT=.text:t> 808 <END.LTDOVERLAY.OBJECTS> 809 <FOREACH.LTDOVERLAY.LIBRARIES=.text> 810 <LTDOVERLAY.LIBRARY=.text:t> 811 <END.LTDOVERLAY.LIBRARIES> 812 <FOREACH.LTDOVERLAY.OBJECTS=.rodata> 813 <LTDOVERLAY.OBJECT=.rodata:t> 814 <END.LTDOVERLAY.OBJECTS> 815 <FOREACH.LTDOVERLAY.LIBRARIES=.rodata> 816 <LTDOVERLAY.LIBRARY=.rodata:t> 817 <END.LTDOVERLAY.LIBRARIES> 818 <FOREACH.LTDOVERLAY.OBJECTS=.init> 819 <LTDOVERLAY.OBJECT=.init:t> 820 <END.LTDOVERLAY.OBJECTS> 821 <FOREACH.LTDOVERLAY.LIBRARIES=.init> 822 <LTDOVERLAY.LIBRARY=.init:t> 823 <END.LTDOVERLAY.LIBRARIES> 824 . = ALIGN(4); 825 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SINIT_START =.; 826 #:::::::::: ctor 827 <FOREACH.LTDOVERLAY.OBJECTS=.ctor> 828 <LTDOVERLAY.OBJECT=.ctor:t> 829 <END.LTDOVERLAY.OBJECTS> 830 <FOREACH.LTDOVERLAY.LIBRARIES=.ctor> 831 <LTDOVERLAY.LIBRARY=.ctor:t> 832 <END.LTDOVERLAY.LIBRARIES> 833 <FOREACH.LTDOVERLAY.OBJECTS=.sinit> 834 <LTDOVERLAY.OBJECT=.sinit:t> 835 <END.LTDOVERLAY.OBJECTS> 836 <FOREACH.LTDOVERLAY.LIBRARIES=.sinit> 837 <LTDOVERLAY.LIBRARY=.sinit:t> 838 <END.LTDOVERLAY.LIBRARIES> 839 WRITEW 0; 840 #:::::::::: ctor 841 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SINIT_END =.; 842 #:::::::::: text/rodata 843 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_END =.; 844 845 # 846 # DATA BLOCK: READ WRITE 847 # 848 . = ALIGN(4); 849 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_START =.; 850 #:::::::::: Data 851 <FOREACH.LTDOVERLAY.OBJECTS=.sdata> 852 <LTDOVERLAY.OBJECT=.sdata:t> 853 <END.LTDOVERLAY.OBJECTS> 854 <FOREACH.LTDOVERLAY.LIBRARIES=.sdata> 855 <LTDOVERLAY.LIBRARY=.sdata:t> 856 <END.LTDOVERLAY.LIBRARIES> 857 <FOREACH.LTDOVERLAY.OBJECTS=.data> 858 <LTDOVERLAY.OBJECT=.data:t> 859 <END.LTDOVERLAY.OBJECTS> 860 <FOREACH.LTDOVERLAY.LIBRARIES=.data> 861 <LTDOVERLAY.LIBRARY=.data:t> 862 <END.LTDOVERLAY.LIBRARIES> 863 #:::::::::: Data 864 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_END =.; 865 . = ALIGN(4); 866 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.END =.; 867 868 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_SIZE = SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_END - SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_START; 869 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_SIZE = SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_END - SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_START; 870 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SIZE = SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.END - SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.START; 871 872 } > <LTDOVERLAY.NAME> 873 874 .<LTDOVERLAY.NAME>.bss:<LTDOVERLAY.NAME> 875 { 876 ALIGNALL(4); 877 . = ALIGN(4); 878 879 # 880 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 881 # 882 <FOREACH.LTDOVERLAY.SEARCHSYMBOLS> 883 SEARCH_SYMBOL <LTDOVERLAY.SEARCHSYMBOL>; 884 <END.LTDOVERLAY.SEARCHSYMBOLS> 885 886 # 887 # BSS BLOCK 888 # 889 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_START =.; 890 #:::::::::: bss 891 <FOREACH.LTDOVERLAY.OBJECTS=.bss> 892 <LTDOVERLAY.OBJECT=.bss:t> 893 <END.LTDOVERLAY.OBJECTS> 894 <FOREACH.LTDOVERLAY.LIBRARIES=.bss> 895 <LTDOVERLAY.LIBRARY=.bss:t> 896 <END.LTDOVERLAY.LIBRARIES> 897 <FOREACH.LTDOVERLAY.OBJECTS=.sbss> 898 <LTDOVERLAY.OBJECT=.sbss:t> 899 <END.LTDOVERLAY.OBJECTS> 900 <FOREACH.LTDOVERLAY.LIBRARIES=.sbss> 901 <LTDOVERLAY.LIBRARY=.sbss:t> 902 <END.LTDOVERLAY.LIBRARIES> 903 #:::::::::: bss 904 . = ALIGN(4); 905 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_END =.; 906 907 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_SIZE = SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_END - SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_START; 908 909 } >> <LTDOVERLAY.NAME> 910 911<END.LTDOVERLAYS> 912 913 ########################## LTDOVERLAYDEFS ########################### 914 .<PROPERTY.LTDOVERLAYDEFS>L: 915 { 916 ### TWL limited extended static module information 917 WRITEW SDK_LTDAUTOLOAD_TOP_START; # Load address 918 WRITEW SDK_MOUNT_INFO_TABLE; # Address of the FS mount information table 919 # Padding 920 WRITEW SDK_LTDAUTOLOAD_SIZE + SDK_LTDAUTOLOAD_TOP_SIZE; # Size of module 921 WRITEW 0; # Padding 922 923 ### TWL limited overlay filename 924 <FOREACH.LTDOVERLAYS> 925 WRITES ("<LTDOVERLAY.NAME><PROPERTY.LTDSUFFIX>"); 926 <END.LTDOVERLAYS> 927 928 } > <PROPERTY.LTDOVERLAYDEFS>L 929 930 ######################### LTDOVERLAYTABLE ########################### 931 .<PROPERTY.LTDOVERLAYTABLE>L: 932 { 933 <FOREACH.LTDOVERLAYS> 934 WRITES <LTDOVERLAY.ID> # Overlay ID 935 WRITEW ADDR(.<LTDOVERLAY.NAME>); # Load address 936 WRITEW SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SIZE; # Size of module 937 WRITEW SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_SIZE; # Size of bss 938 WRITEW SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SINIT_START; # Start address of static init 939 WRITEW SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SINIT_END; # End address of static init 940 WRITEW <LTDOVERLAY.ID> # ROM file ID 941 WRITEW 0; # Reserved 942 <END.LTDOVERLAYS> 943 944 } > <PROPERTY.LTDOVERLAYTABLE>L 945 946 ############################ OTHERS ################################# 947 .check.LTDWRAM: 948 { 949 . = SDK_LTDAUTOLOAD.LTDWRAM.BSS_END; 950 951 } > check.LTDWRAM 952 953 .check.LTDMAIN: 954 { 955 . = SDK_LTDAUTOLOAD.LTDMAIN.BSS_END; 956 957 } > check.LTDMAIN 958 959} 960