1#--------------------------------------------------------------------------- 2# Project: TwlSDK - include 3# File: ARM9-TS.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:: 2009-02-25#$ 14# $Rev: 10083 $ 15# $Author: yada $ 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 dummy.MAIN_EX.NITRO (RW) : ORIGIN = 0x023e0000, LENGTH = 0x0 34 arena.MAIN.NITRO (RW) : ORIGIN = AFTER(<STATIC.NAME><FOREACH.OVERLAYS=MAIN>,<OVERLAY.NAME><END.OVERLAYS>), LENGTH = 0x0 35 arena.MAIN_EX.NITRO (RW) : ORIGIN = AFTER(dummy.MAIN_EX.NITRO<FOREACH.OVERLAYS=MAINEX>,<OVERLAY.NAME><END.OVERLAYS>), LENGTH = 0x0 36 arena.ITCM (RW) : ORIGIN = AFTER(ITCM<FOREACH.OVERLAYS=ITCM>,<OVERLAY.NAME><END.OVERLAYS>), LENGTH = 0x0 37 arena.DTCM (RW) : ORIGIN = AFTER(DTCM<FOREACH.OVERLAYS=DTCM>,<OVERLAY.NAME><END.OVERLAYS>), LENGTH = 0x0 38 39 check.ITCM (RW) : ORIGIN = 0x0, LENGTH = 0x08000 > itcm.check 40 check.DTCM (RW) : ORIGIN = 0x0, LENGTH = 0x04000 > dtcm.check 41 42 binary.LTDAUTOLOAD_TOP (RW) : ORIGIN = 0, LENGTH = 0x0 > <STATIC.NAME><PROPERTY.LTDSUFFIX> 43 <FOREACH.LTDAUTOLOADS> 44 <LTDAUTOLOAD.NAME> (RWX) : ORIGIN = <LTDAUTOLOAD.ADDRESS>, LENGTH = 0x0 >> <STATIC.NAME><PROPERTY.LTDSUFFIX> 45 <END.LTDAUTOLOADS> 46 binary.LTDAUTOLOAD_INFO (RWX) : ORIGIN = 0, LENGTH = 0x0 >> <STATIC.NAME><PROPERTY.LTDSUFFIX> 47 48 <PROPERTY.LTDOVERLAYDEFS>L (RW) : ORIGIN = 0, LENGTH = 0x0 > <PROPERTY.LTDOVERLAYDEFS><PROPERTY.LTDSUFFIX> 49 <PROPERTY.LTDOVERLAYTABLE>L (RW) : ORIGIN = 0, LENGTH = 0x0 > <PROPERTY.LTDOVERLAYTABLE><PROPERTY.LTDSUFFIX> 50 <FOREACH.LTDOVERLAYS> 51 <LTDOVERLAY.NAME> (RWXO): ORIGIN = <LTDOVERLAY.ADDRESS>, LENGTH = 0x0 > <LTDOVERLAY.NAME><PROPERTY.LTDSUFFIX> 52 <END.LTDOVERLAYS> 53 54 dummy.MAIN_EX.TWL (RW) : ORIGIN = 0x0d000000, LENGTH = 0x0 55 arena.MAIN.TWL (RW) : ORIGIN = AFTER(<STATIC.NAME><FOREACH.OVERLAYS=MAIN>,<OVERLAY.NAME><END.OVERLAYS>,LTDMAIN<FOREACH.LTDOVERLAYS=MAIN>,<LTDOVERLAY.NAME><END.LTDOVERLAYS>), LENGTH = 0x0 56 arena.MAIN_EX.TWL (RW) : ORIGIN = AFTER(dummy.MAIN_EX.TWL,<STATIC.NAME><FOREACH.OVERLAYS=MAIN>,<OVERLAY.NAME><END.OVERLAYS>,LTDMAIN<FOREACH.LTDOVERLAYS=MAIN>,<LTDOVERLAY.NAME><END.LTDOVERLAYS><FOREACH.AUTOLOADS>,<AUTOLOAD.NAME><END.AUTOLOADS>), LENGTH = 0x0 57 58 binary.MODULE_FILES (RW) : ORIGIN = 0, LENGTH = 0x0 > component.files 59 COMMON__ (RW) : ORIGIN = 0x0, LENGTH = 0x01400 > common.check 60 PARENT__ (RW) : ORIGIN = 0x0, LENGTH = 0x02000 > parent.check 61} 62 63FORCE_ACTIVE 64{ 65 SVC_SoftReset 66} 67 68KEEP_SECTION 69{ 70 .sinit 71} 72 73SECTIONS 74{ 75 ############################ STATIC ################################# 76 .<STATIC.NAME>: 77 { 78 ALIGNALL(4); 79 . = ALIGN(32); # Fit to cache line 80 81 # 82 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 83 # 84 <FOREACH.STATIC.SEARCHSYMBOLS> 85 SEARCH_SYMBOL <STATIC.SEARCHSYMBOL>; 86 <END.STATIC.SEARCHSYMBOLS> 87 88 # 89 # TEXT BLOCK: READ ONLY 90 # 91 SDK_STATIC_START =.; 92 SDK_STATIC_TEXT_START =.; 93 #:::::::::: text/rodata 94 95 #:: Common A ----- 5KB 96 SDK_STATIC_TEXT_COMMON_START =.; 97 libsyscall.a (.text) 98 OBJECT(_start,*) 99 crt0.FLX.TWL.o (.text) 100 crt0.FLX.TWL.o (.rodata) 101 # 102 # Added .version section. 103 # The information included in this section will be needed for Lotcheck purposes. Be sure to leave it in this position. 104 # 105 # 106 * (.version) 107 SDK_STATIC_TEXT_COMMON_END =.; 108 .= SDK_STATIC_START + 5 * 1024; 109 110 #:: Parent Only -- 8KB 111 SDK_STATIC_TEXT_PARENT_START =.; 112 # 113 # Collected .parent section code 114 # Notice that .bss, .data section code is not included! 115 * (.parent) 116 # 117 SDK_STATIC_TEXT_PARENT_END =.; 118 .= SDK_STATIC_START + 13 * 1024; 119 120 #:: Common B ----- 3KB + ... 121 OBJECT(TwlMain,*) 122 <FOREACH.STATIC.OBJECTS=.text> 123 <STATIC.OBJECT=.text:t> 124 <END.STATIC.OBJECTS> 125 <FOREACH.STATIC.LIBRARIES=.text> 126 <STATIC.LIBRARY=.text:t> 127 <END.STATIC.LIBRARIES> 128 * (.exception) 129 . = ALIGN(4); 130 SDK_STATIC_ETABLE_START =.; 131 __exception_table_start__ =.; 132 EXCEPTION 133 __exception_table_end__ =.; 134 SDK_STATIC_ETABLE_END =.; 135 <FOREACH.STATIC.OBJECTS=.rodata> 136 <STATIC.OBJECT=.rodata:t> 137 <END.STATIC.OBJECTS> 138 <FOREACH.STATIC.LIBRARIES=.rodata> 139 <STATIC.LIBRARY=.rodata:t> 140 <END.STATIC.LIBRARIES> 141 <FOREACH.STATIC.OBJECTS=.init> 142 <STATIC.OBJECT=.init:t> 143 <END.STATIC.OBJECTS> 144 <FOREACH.STATIC.LIBRARIES=.init> 145 <STATIC.LIBRARY=.init:t> 146 <END.STATIC.LIBRARIES> 147 . = ALIGN(4); 148 SDK_STATIC_SINIT_START =.; 149 #:::::::::: ctor 150 <FOREACH.STATIC.OBJECTS=.ctor> 151 <STATIC.OBJECT=.ctor:t> 152 <END.STATIC.OBJECTS> 153 <FOREACH.STATIC.LIBRARIES=.ctor> 154 <STATIC.LIBRARY=.ctor:t> 155 <END.STATIC.LIBRARIES> 156 <FOREACH.STATIC.OBJECTS=.sinit> 157 <STATIC.OBJECT=.sinit:t> 158 <END.STATIC.OBJECTS> 159 <FOREACH.STATIC.LIBRARIES=.sinit> 160 <STATIC.LIBRARY=.sinit:t> 161 <END.STATIC.LIBRARIES> 162 WRITEW 0; 163 #:::::::::: ctor 164 SDK_STATIC_SINIT_END =.; 165 #:::::::::: text/rodata 166 SDK_STATIC_TEXT_END =.; 167 168 # 169 # DATA BLOCK: READ WRITE 170 # 171 . = ALIGN(32); # Fit to cache line 172 SDK_STATIC_DATA_START =.; 173 #:::::::::: Data 174 <FOREACH.STATIC.OBJECTS=.sdata> 175 <STATIC.OBJECT=.sdata:t> 176 <END.STATIC.OBJECTS> 177 <FOREACH.STATIC.LIBRARIES=.sdata> 178 <STATIC.LIBRARY=.sdata:t> 179 <END.STATIC.LIBRARIES> 180 <FOREACH.STATIC.OBJECTS=.data> 181 <STATIC.OBJECT=.data:t> 182 <END.STATIC.OBJECTS> 183 <FOREACH.STATIC.LIBRARIES=.data> 184 <STATIC.LIBRARY=.data:t> 185 <END.STATIC.LIBRARIES> 186 . = ALIGN(4); 187 188 SDK_LTDOVERLAYTABLE_DIGEST =.; 189 . = . + 20; 190 SDK_LTDOVERLAYTABLE_DIGEST_END =.; 191 SDK_OVERLAYTABLE_DIGEST =.; 192 . = . + 20; 193 SDK_OVERLAYTABLE_DIGEST_END =.; 194 SDK_OVERLAY_DIGEST =.; 195 . = . + <NUMBER.OVERLAYS> * 20; 196 . = . + <NUMBER.LTDOVERLAYS> * 20; 197 SDK_OVERLAY_DIGEST_END =.; 198 #:::::::::: Data 199 . = ALIGN(32); 200 SDK_STATIC_DATA_END =.; 201 SDK_STATIC_END =.; 202 203 SDK_STATIC_TEXT_SIZE = SDK_STATIC_TEXT_END - SDK_STATIC_TEXT_START; 204 SDK_STATIC_DATA_SIZE = SDK_STATIC_DATA_END - SDK_STATIC_DATA_START; 205 SDK_STATIC_SIZE = SDK_STATIC_END - SDK_STATIC_START; 206 __sinit__ = SDK_STATIC_SINIT_START; # For static initializer 207 208 } > <STATIC.NAME> 209 210 .<STATIC.NAME>.bss: 211 { 212 ALIGNALL(4); 213 . = ALIGN(32); # Fit to cache line 214 215 # 216 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 217 # 218 <FOREACH.STATIC.SEARCHSYMBOLS> 219 SEARCH_SYMBOL <STATIC.SEARCHSYMBOL>; 220 <END.STATIC.SEARCHSYMBOLS> 221 222 # 223 # BSS BLOCK 224 # 225 SDK_STATIC_BSS_START =.; 226 #:::::::::: bss 227 <FOREACH.STATIC.OBJECTS=.sbss> 228 <STATIC.OBJECT=.sbss:t> 229 <END.STATIC.OBJECTS> 230 <FOREACH.STATIC.LIBRARIES=.sbss> 231 <STATIC.LIBRARY=.sbss:t> 232 <END.STATIC.LIBRARIES> 233 <FOREACH.STATIC.OBJECTS=.bss> 234 <STATIC.OBJECT=.bss:t> 235 <END.STATIC.OBJECTS> 236 <FOREACH.STATIC.LIBRARIES=.bss> 237 <STATIC.LIBRARY=.bss:t> 238 <END.STATIC.LIBRARIES> 239 #:::::::::: bss 240 . = ALIGN(32); 241 SDK_STATIC_BSS_END = .; 242 243 SDK_STATIC_BSS_SIZE = SDK_STATIC_BSS_END - SDK_STATIC_BSS_START; 244 245 } >> <STATIC.NAME> 246 247 248 ############################ AUTOLOADS ############################## 249 SDK_AUTOLOAD.ITCM.START = 0x01ff8000; 250 SDK_AUTOLOAD.ITCM.END = SDK_AUTOLOAD.ITCM.START; 251 SDK_AUTOLOAD.ITCM.BSS_END = SDK_AUTOLOAD.ITCM.START; 252 SDK_AUTOLOAD.ITCM.SIZE = 0; 253 SDK_AUTOLOAD.ITCM.BSS_SIZE = 0; 254 SDK_AUTOLOAD.DTCM.START = 0x02fe0000; 255 SDK_AUTOLOAD.DTCM.END = SDK_AUTOLOAD.DTCM.START; 256 SDK_AUTOLOAD.DTCM.BSS_END = SDK_AUTOLOAD.DTCM.START; 257 SDK_AUTOLOAD.DTCM.SIZE = 0; 258 SDK_AUTOLOAD.DTCM.BSS_SIZE = 0; 259 SDK_AUTOLOAD_START = SDK_STATIC_END; 260 SDK_AUTOLOAD_SIZE = 0; 261 SDK_AUTOLOAD_NUMBER = <NUMBER.AUTOLOADS>; 262 263<FOREACH.AUTOLOADS> 264 .<AUTOLOAD.NAME>: 265 { 266 ALIGNALL(4); 267 . = ALIGN(32); 268 269 # 270 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 271 # 272 <FOREACH.AUTOLOAD.SEARCHSYMBOLS> 273 SEARCH_SYMBOL <AUTOLOAD.SEARCHSYMBOL>; 274 <END.AUTOLOAD.SEARCHSYMBOLS> 275 276 # 277 # TEXT BLOCK: READ ONLY 278 # 279 SDK_AUTOLOAD_<AUTOLOAD.NAME>_ID =<AUTOLOAD.ID>; 280 SDK_AUTOLOAD.<AUTOLOAD.NAME>.ID =<AUTOLOAD.ID>; 281 SDK_AUTOLOAD.<AUTOLOAD.NAME>.START =.; 282 SDK_AUTOLOAD.<AUTOLOAD.NAME>.TEXT_START =.; 283 #:::::::::: text/rodata 284 <FOREACH.AUTOLOAD.OBJECTS=.text> 285 <AUTOLOAD.OBJECT=.text:t> 286 <END.AUTOLOAD.OBJECTS> 287 <FOREACH.AUTOLOAD.LIBRARIES=.text> 288 <AUTOLOAD.LIBRARY=.text:t> 289 <END.AUTOLOAD.LIBRARIES> 290 <FOREACH.AUTOLOAD.OBJECTS=.rodata> 291 <AUTOLOAD.OBJECT=.rodata:t> 292 <END.AUTOLOAD.OBJECTS> 293 <FOREACH.AUTOLOAD.LIBRARIES=.rodata> 294 <AUTOLOAD.LIBRARY=.rodata:t> 295 <END.AUTOLOAD.LIBRARIES> 296 <FOREACH.AUTOLOAD.OBJECTS=.init> 297 <AUTOLOAD.OBJECT=.init:t> 298 <END.AUTOLOAD.OBJECTS> 299 <FOREACH.AUTOLOAD.LIBRARIES=.init> 300 <AUTOLOAD.LIBRARY=.init:t> 301 <END.AUTOLOAD.LIBRARIES> 302 . = ALIGN(4); 303 SDK_AUTOLOAD.<AUTOLOAD.NAME>.SINIT_START = .; 304 #:::::::::: ctor 305 <FOREACH.AUTOLOAD.OBJECTS=.ctor> 306 <AUTOLOAD.OBJECT=.ctor:t> 307 <END.AUTOLOAD.OBJECTS> 308 <FOREACH.AUTOLOAD.LIBRARIES=.ctor> 309 <AUTOLOAD.LIBRARY=.ctor:t> 310 <END.AUTOLOAD.LIBRARIES> 311 <FOREACH.AUTOLOAD.OBJECTS=.sinit> 312 <AUTOLOAD.OBJECT=.sinit:t> 313 <END.AUTOLOAD.OBJECTS> 314 <FOREACH.AUTOLOAD.LIBRARIES=.sinit> 315 <AUTOLOAD.LIBRARY=.sinit:t> 316 <END.AUTOLOAD.LIBRARIES> 317 WRITEW 0; 318 #:::::::::: ctor 319 SDK_AUTOLOAD.<AUTOLOAD.NAME>.SINIT_END = .; 320 #:::::::::: text/rodata 321 SDK_AUTOLOAD.<AUTOLOAD.NAME>.TEXT_END =.; 322 323 # 324 # DATA BLOCK: READ WRITE BLOCK 325 # 326 . = ALIGN(32); 327 SDK_AUTOLOAD.<AUTOLOAD.NAME>.DATA_START =.; 328 #:::::::::: Data 329 <FOREACH.AUTOLOAD.OBJECTS=.itcm> 330 <AUTOLOAD.OBJECT=.itcm:t> 331 <END.AUTOLOAD.OBJECTS> 332 <FOREACH.AUTOLOAD.LIBRARIES=.itcm> 333 <AUTOLOAD.LIBRARY=.itcm:t> 334 <END.AUTOLOAD.LIBRARIES> 335 <FOREACH.AUTOLOAD.OBJECTS=.dtcm> 336 <AUTOLOAD.OBJECT=.dtcm:t> 337 <END.AUTOLOAD.OBJECTS> 338 <FOREACH.AUTOLOAD.LIBRARIES=.dtcm> 339 <AUTOLOAD.LIBRARY=.dtcm:t> 340 <END.AUTOLOAD.LIBRARIES> 341 <FOREACH.AUTOLOAD.OBJECTS=.sdata> 342 <AUTOLOAD.OBJECT=.sdata:t> 343 <END.AUTOLOAD.OBJECTS> 344 <FOREACH.AUTOLOAD.LIBRARIES=.sdata> 345 <AUTOLOAD.LIBRARY=.sdata:t> 346 <END.AUTOLOAD.LIBRARIES> 347 <FOREACH.AUTOLOAD.OBJECTS=.data> 348 <AUTOLOAD.OBJECT=.data:t> 349 <END.AUTOLOAD.OBJECTS> 350 <FOREACH.AUTOLOAD.LIBRARIES=.data> 351 <AUTOLOAD.LIBRARY=.data:t> 352 <END.AUTOLOAD.LIBRARIES> 353 #:::::::::: Data 354 SDK_AUTOLOAD.<AUTOLOAD.NAME>.DATA_END =.; 355 . = ALIGN(32); 356 SDK_AUTOLOAD.<AUTOLOAD.NAME>.END =.; 357 358 SDK_AUTOLOAD.<AUTOLOAD.NAME>.TEXT_SIZE = SDK_AUTOLOAD.<AUTOLOAD.NAME>.TEXT_END - SDK_AUTOLOAD.<AUTOLOAD.NAME>.TEXT_START; 359 SDK_AUTOLOAD.<AUTOLOAD.NAME>.DATA_SIZE = SDK_AUTOLOAD.<AUTOLOAD.NAME>.DATA_END - SDK_AUTOLOAD.<AUTOLOAD.NAME>.DATA_START; 360 SDK_AUTOLOAD.<AUTOLOAD.NAME>.SIZE = SDK_AUTOLOAD.<AUTOLOAD.NAME>.END - SDK_AUTOLOAD.<AUTOLOAD.NAME>.START; 361 SDK_AUTOLOAD_SIZE = SDK_AUTOLOAD_SIZE + SDK_AUTOLOAD.<AUTOLOAD.NAME>.SIZE; 362 363 } > <AUTOLOAD.NAME> 364 365 .<AUTOLOAD.NAME>.bss: 366 { 367 ALIGNALL(4); 368 . = ALIGN(32); 369 370 # 371 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 372 # 373 <FOREACH.AUTOLOAD.SEARCHSYMBOLS> 374 SEARCH_SYMBOL <AUTOLOAD.SEARCHSYMBOL> 375 <END.AUTOLOAD.SEARCHSYMBOLS> 376 377 # 378 # BSS BLOCK 379 # 380 SDK_AUTOLOAD.<AUTOLOAD.NAME>.BSS_START = .; 381 #:::::::::: bss 382 <FOREACH.AUTOLOAD.OBJECTS=.itcm> 383 <AUTOLOAD.OBJECT=.itcm.bss:t> 384 <END.AUTOLOAD.OBJECTS> 385 <FOREACH.AUTOLOAD.LIBRARIES=.itcm> 386 <AUTOLOAD.LIBRARY=.itcm.bss:t> 387 <END.AUTOLOAD.LIBRARIES> 388 <FOREACH.AUTOLOAD.OBJECTS=.dtcm> 389 <AUTOLOAD.OBJECT=.dtcm.bss:t> 390 <END.AUTOLOAD.OBJECTS> 391 <FOREACH.AUTOLOAD.LIBRARIES=.dtcm> 392 <AUTOLOAD.LIBRARY=.dtcm.bss:t> 393 <END.AUTOLOAD.LIBRARIES> 394 <FOREACH.AUTOLOAD.OBJECTS=.sbss> 395 <AUTOLOAD.OBJECT=.sbss:t> 396 <END.AUTOLOAD.OBJECTS> 397 <FOREACH.AUTOLOAD.LIBRARIES=.sbss> 398 <AUTOLOAD.LIBRARY=.sbss:t> 399 <END.AUTOLOAD.LIBRARIES> 400 <FOREACH.AUTOLOAD.OBJECTS=.bss> 401 <AUTOLOAD.OBJECT=.bss:t> 402 <END.AUTOLOAD.OBJECTS> 403 <FOREACH.AUTOLOAD.LIBRARIES=.bss> 404 <AUTOLOAD.LIBRARY=.bss:t> 405 <END.AUTOLOAD.LIBRARIES> 406 #:::::::::: bss 407 . = ALIGN(32); 408 SDK_AUTOLOAD.<AUTOLOAD.NAME>.BSS_END = .; 409 410 SDK_AUTOLOAD.<AUTOLOAD.NAME>.BSS_SIZE = SDK_AUTOLOAD.<AUTOLOAD.NAME>.BSS_END - SDK_AUTOLOAD.<AUTOLOAD.NAME>.BSS_START; 411 412 } >> <AUTOLOAD.NAME> 413 414<END.AUTOLOADS> 415 416 SDK_AUTOLOAD_ITCM_START = SDK_AUTOLOAD.ITCM.START; 417 SDK_AUTOLOAD_ITCM_END = SDK_AUTOLOAD.ITCM.END; 418 SDK_AUTOLOAD_ITCM_BSS_END = SDK_AUTOLOAD.ITCM.BSS_END; 419 SDK_AUTOLOAD_ITCM_SIZE = SDK_AUTOLOAD.ITCM.SIZE; 420 SDK_AUTOLOAD_ITCM_BSS_SIZE = SDK_AUTOLOAD.ITCM.BSS_SIZE; 421 SDK_AUTOLOAD_DTCM_START = SDK_AUTOLOAD.DTCM.START; 422 SDK_AUTOLOAD_DTCM_END = SDK_AUTOLOAD.DTCM.END; 423 SDK_AUTOLOAD_DTCM_BSS_END = SDK_AUTOLOAD.DTCM.BSS_END; 424 SDK_AUTOLOAD_DTCM_SIZE = SDK_AUTOLOAD.DTCM.SIZE; 425 SDK_AUTOLOAD_DTCM_BSS_SIZE = SDK_AUTOLOAD.DTCM.BSS_SIZE; 426 427 ############################ AUTOLOAD_INFO ########################## 428 .binary.AUTOLOAD_INFO: 429 { 430 <FOREACH.AUTOLOADS> 431 WRITEW ADDR(.<AUTOLOAD.NAME>); 432 WRITEW SDK_AUTOLOAD.<AUTOLOAD.NAME>.SIZE; 433 WRITEW SDK_AUTOLOAD.<AUTOLOAD.NAME>.SINIT_START; 434 WRITEW SDK_AUTOLOAD.<AUTOLOAD.NAME>.BSS_SIZE; 435 <END.AUTOLOADS> 436 437 } > binary.AUTOLOAD_INFO 438 439 SDK_AUTOLOAD_LIST = SDK_AUTOLOAD_START + SDK_AUTOLOAD_SIZE; 440 SDK_AUTOLOAD_LIST_END = SDK_AUTOLOAD_START + SDK_AUTOLOAD_SIZE + SIZEOF(.binary.AUTOLOAD_INFO); 441 SDK_AUTOLOAD_SIZE = SDK_AUTOLOAD_SIZE + SIZEOF(.binary.AUTOLOAD_INFO); 442 443 ############################ STATIC_FOOTER ########################## 444 .binary.STATIC_FOOTER: 445 { 446 WRITEW 0xdec00621; # LE(0x2106C0DE) = NITRO CODE 447 WRITEW _start_ModuleParams - ADDR(.<STATIC.NAME>); 448 WRITEW SDK_OVERLAY_DIGEST - ADDR(.<STATIC.NAME>); 449 WRITEW _start_LtdModuleParams - ADDR(.<STATIC.NAME>); 450 } > binary.STATIC_FOOTER 451 452 ############################ OVERLAYS ############################### 453 SDK_OVERLAY_NUMBER = <NUMBER.OVERLAYS>; 454 455<FOREACH.OVERLAYS> 456 .<OVERLAY.NAME>:<OVERLAY.NAME> 457 { 458 ALIGNALL(4); 459 . = ALIGN(32); # Fit to cache line 460 461 # 462 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 463 # 464 <FOREACH.OVERLAY.SEARCHSYMBOLS> 465 SEARCH_SYMBOL <OVERLAY.SEARCHSYMBOL>; 466 <END.OVERLAY.SEARCHSYMBOLS> 467 468 # 469 # TEXT BLOCK: READ ONLY 470 # 471 SDK_OVERLAY_<OVERLAY.NAME>_ID =<OVERLAY.ID>; ### SEGMENT <OVERLAY.NAME> OVERLAY ID 472 SDK_OVERLAY.<OVERLAY.NAME>.ID =<OVERLAY.ID>; 473 SDK_OVERLAY.<OVERLAY.NAME>.START =.; 474 SDK_OVERLAY.<OVERLAY.NAME>.TEXT_START =.; 475 #:::::::::: text/rodata 476 <FOREACH.OVERLAY.OBJECTS=.text> 477 <OVERLAY.OBJECT=.text:t> 478 <END.OVERLAY.OBJECTS> 479 <FOREACH.OVERLAY.LIBRARIES=.text> 480 <OVERLAY.LIBRARY=.text:t> 481 <END.OVERLAY.LIBRARIES> 482 <FOREACH.OVERLAY.OBJECTS=.rodata> 483 <OVERLAY.OBJECT=.rodata:t> 484 <END.OVERLAY.OBJECTS> 485 <FOREACH.OVERLAY.LIBRARIES=.rodata> 486 <OVERLAY.LIBRARY=.rodata:t> 487 <END.OVERLAY.LIBRARIES> 488 <FOREACH.OVERLAY.OBJECTS=.init> 489 <OVERLAY.OBJECT=.init:t> 490 <END.OVERLAY.OBJECTS> 491 <FOREACH.OVERLAY.LIBRARIES=.init> 492 <OVERLAY.LIBRARY=.init:t> 493 <END.OVERLAY.LIBRARIES> 494 . = ALIGN(4); 495 SDK_OVERLAY.<OVERLAY.NAME>.SINIT_START =.; 496 #:::::::::: ctor 497 <FOREACH.OVERLAY.OBJECTS=.ctor> 498 <OVERLAY.OBJECT=.ctor:t> 499 <END.OVERLAY.OBJECTS> 500 <FOREACH.OVERLAY.LIBRARIES=.ctor> 501 <OVERLAY.LIBRARY=.ctor:t> 502 <END.OVERLAY.LIBRARIES> 503 <FOREACH.OVERLAY.OBJECTS=.sinit> 504 <OVERLAY.OBJECT=.sinit:t> 505 <END.OVERLAY.OBJECTS> 506 <FOREACH.OVERLAY.LIBRARIES=.sinit> 507 <OVERLAY.LIBRARY=.sinit:t> 508 <END.OVERLAY.LIBRARIES> 509 WRITEW 0; 510 #:::::::::: ctor 511 SDK_OVERLAY.<OVERLAY.NAME>.SINIT_END =.; 512 #:::::::::: text/rodata 513 SDK_OVERLAY.<OVERLAY.NAME>.TEXT_END =.; 514 515 # 516 # DATA BLOCK: READ WRITE 517 # 518 . = ALIGN(32); 519 SDK_OVERLAY.<OVERLAY.NAME>.DATA_START =.; 520 #:::::::::: Data 521 <FOREACH.OVERLAY.OBJECTS=.sdata> 522 <OVERLAY.OBJECT=.sdata:t> 523 <END.OVERLAY.OBJECTS> 524 <FOREACH.OVERLAY.LIBRARIES=.sdata> 525 <OVERLAY.LIBRARY=.sdata:t> 526 <END.OVERLAY.LIBRARIES> 527 <FOREACH.OVERLAY.OBJECTS=.data> 528 <OVERLAY.OBJECT=.data:t> 529 <END.OVERLAY.OBJECTS> 530 <FOREACH.OVERLAY.LIBRARIES=.data> 531 <OVERLAY.LIBRARY=.data:t> 532 <END.OVERLAY.LIBRARIES> 533 #:::::::::: Data 534 SDK_OVERLAY.<OVERLAY.NAME>.DATA_END =.; 535 . = ALIGN(32); 536 SDK_OVERLAY.<OVERLAY.NAME>.END =.; 537 538 SDK_OVERLAY.<OVERLAY.NAME>.TEXT_SIZE = SDK_OVERLAY.<OVERLAY.NAME>.TEXT_END - SDK_OVERLAY.<OVERLAY.NAME>.TEXT_START; 539 SDK_OVERLAY.<OVERLAY.NAME>.DATA_SIZE = SDK_OVERLAY.<OVERLAY.NAME>.DATA_END - SDK_OVERLAY.<OVERLAY.NAME>.DATA_START; 540 SDK_OVERLAY.<OVERLAY.NAME>.SIZE = SDK_OVERLAY.<OVERLAY.NAME>.END - SDK_OVERLAY.<OVERLAY.NAME>.START; 541 542 } > <OVERLAY.NAME> 543 544 .<OVERLAY.NAME>.bss:<OVERLAY.NAME> 545 { 546 ALIGNALL(4); 547 . = ALIGN(32); 548 549 # 550 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 551 # 552 <FOREACH.OVERLAY.SEARCHSYMBOLS> 553 SEARCH_SYMBOL <OVERLAY.SEARCHSYMBOL>; 554 <END.OVERLAY.SEARCHSYMBOLS> 555 556 # 557 # BSS BLOCK 558 # 559 SDK_OVERLAY.<OVERLAY.NAME>.BSS_START = .; 560 #:::::::::: bss 561 <FOREACH.OVERLAY.OBJECTS=.bss> 562 <OVERLAY.OBJECT=.bss:t> 563 <END.OVERLAY.OBJECTS> 564 <FOREACH.OVERLAY.LIBRARIES=.bss> 565 <OVERLAY.LIBRARY=.bss:t> 566 <END.OVERLAY.LIBRARIES> 567 <FOREACH.OVERLAY.OBJECTS=.sbss> 568 <OVERLAY.OBJECT=.sbss:t> 569 <END.OVERLAY.OBJECTS> 570 <FOREACH.OVERLAY.LIBRARIES=.sbss> 571 <OVERLAY.LIBRARY=.sbss:t> 572 <END.OVERLAY.LIBRARIES> 573 #:::::::::: bss 574 . = ALIGN(32); 575 SDK_OVERLAY.<OVERLAY.NAME>.BSS_END = .; 576 577 SDK_OVERLAY.<OVERLAY.NAME>.BSS_SIZE = SDK_OVERLAY.<OVERLAY.NAME>.BSS_END - SDK_OVERLAY.<OVERLAY.NAME>.BSS_START; 578 579 } >> <OVERLAY.NAME> 580 581<END.OVERLAYS> 582 583 ############################ OVERLAYDEFS ############################ 584 .<PROPERTY.OVERLAYDEFS>F: 585 { 586 ### <STATIC.NAME> module information 587 WRITEW ADDR(.<STATIC.NAME>); # Load address 588 WRITEW _start; # Entry address 589 WRITEW SDK_STATIC_SIZE + SDK_AUTOLOAD_SIZE; # Size of module 590 WRITEW _start_AutoloadDoneCallback; # Callback autoload done 591 592 ### overlay filename 593 <FOREACH.OVERLAYS> 594 WRITES ("<OVERLAY.NAME><PROPERTY.FLXSUFFIX>"); # Overlay <OVERLAY.ID> 595 <END.OVERLAYS> 596 597 } > <PROPERTY.OVERLAYDEFS>F 598 599 ############################ OVERLAYTABLE ########################### 600 .<PROPERTY.OVERLAYTABLE>F: 601 { 602 <FOREACH.OVERLAYS> 603 WRITEW <OVERLAY.ID>; # Overlay ID 604 WRITEW ADDR(.<OVERLAY.NAME>); # Load address 605 WRITEW SDK_OVERLAY.<OVERLAY.NAME>.SIZE; # Size of module 606 WRITEW SDK_OVERLAY.<OVERLAY.NAME>.BSS_SIZE; # Size of bss 607 WRITEW SDK_OVERLAY.<OVERLAY.NAME>.SINIT_START; # Start address of static init 608 WRITEW SDK_OVERLAY.<OVERLAY.NAME>.SINIT_END; # End address of static init 609 WRITEW <OVERLAY.ID>; # ROM file ID 610 WRITEW 0; # compressed state 611 <END.OVERLAYS> 612 613 } > <PROPERTY.OVERLAYTABLE>F 614 615 ############################ ARENA ################################## 616 .dummy.MAIN_EX.NITRO: 617 { 618 . = ALIGN(32); 619 620 } > dummy.MAIN_EX.NITRO 621 622 .arena.MAIN.NITRO: 623 { 624 . = ALIGN(32); 625 SDK_SECTION_ARENA_START =.; 626 627 } > arena.MAIN.NITRO 628 629 .arena.MAIN_EX.NITRO: 630 { 631 . = ALIGN(32); 632 SDK_SECTION_ARENA_EX_START =.; 633 634 } > arena.MAIN_EX.NITRO 635 636 .arena.ITCM: 637 { 638 . = ALIGN(32); 639 SDK_SECTION_ARENA_ITCM_START =.; 640 641 } > arena.ITCM 642 643 .arena.DTCM: 644 { 645 . = ALIGN(32); 646 SDK_SECTION_ARENA_DTCM_START =.; 647 648 } > arena.DTCM 649 650 ############################ OTHERS ################################# 651 SDK_MAIN_ARENA_LO = SDK_SECTION_ARENA_START; 652 SDK_IRQ_STACKSIZE = <STATIC.IRQSTACKSIZE>; # Allocated in DTCM 653 SDK_SYS_STACKSIZE = <STATIC.STACKSIZE>; # When 0 means all remains of DTCM 654 SDK_SYS_STACKSIZE_SIGN = (SDK_SYS_STACKSIZE < 0x80000000) * 2 - 1; 655 656 .check.ITCM: 657 { 658 . = . + SDK_AUTOLOAD_ITCM_SIZE + SDK_AUTOLOAD_ITCM_BSS_SIZE; 659 <FOREACH.OVERLAYS=ITCM> 660 . = . + SDK_OVERLAY.<OVERLAY.NAME>.SIZE + SDK_OVERLAY.<OVERLAY.NAME>.BSS_SIZE; 661 <END.OVERLAYS> 662 663 } > check.ITCM 664 665 .check.DTCM: 666 { 667 . = . + SDK_AUTOLOAD_DTCM_SIZE + SDK_AUTOLOAD_DTCM_BSS_SIZE; 668 <FOREACH.OVERLAYS=DTCM> 669 . = . + SDK_OVERLAY.<OVERLAY.NAME>.SIZE + SDK_OVERLAY.<OVERLAY.NAME>.BSS_SIZE; 670 <END.OVERLAYS> 671 . = . + 0x080 + SDK_IRQ_STACKSIZE + SDK_SYS_STACKSIZE * SDK_SYS_STACKSIZE_SIGN; 672 } > check.DTCM 673 674 .COMMON__: 675 { 676 . = . + SDK_STATIC_TEXT_COMMON_END - SDK_STATIC_TEXT_COMMON_START; 677 } > COMMON__ 678 679 .PARENT__: 680 { 681 . = . + SDK_STATIC_TEXT_PARENT_END - SDK_STATIC_TEXT_PARENT_START; 682 } > PARENT__ 683 684 ########################### LTDAUTOLOADS ############################ 685 SDK_LTDAUTOLOAD.LTDMAIN.START = SDK_STATIC_BSS_END; 686 SDK_LTDAUTOLOAD.LTDMAIN.END = SDK_LTDAUTOLOAD.LTDMAIN.START; 687 SDK_LTDAUTOLOAD.LTDMAIN.BSS_END = SDK_LTDAUTOLOAD.LTDMAIN.START; 688 SDK_LTDAUTOLOAD.LTDMAIN.SIZE = 0; 689 SDK_LTDAUTOLOAD.LTDMAIN.BSS_SIZE = 0; 690 SDK_LTDAUTOLOAD_TOP_START = 0x02400000; 691 SDK_LTDAUTOLOAD_TOP_SIZE = 4; # While there is no STATIC region, a 4-byte dummy is at the top of the binary file 692 SDK_LTDAUTOLOAD_START = SDK_LTDAUTOLOAD_TOP_START + SDK_LTDAUTOLOAD_TOP_SIZE; 693 SDK_LTDAUTOLOAD_SIZE = 0; 694 SDK_LTDAUTOLOAD_NUMBER = <NUMBER.LTDAUTOLOADS>; 695 696 .binary.LTDAUTOLOAD_TOP: 697 { 698 WRITEW 0; 699 700 } > binary.LTDAUTOLOAD_TOP 701 702<FOREACH.LTDAUTOLOADS> 703 .<LTDAUTOLOAD.NAME>: 704 { 705 ALIGNALL(4); 706 . = ALIGN(32); # Fit to cache line 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 SDK_LTDAUTOLOAD_<LTDAUTOLOAD.NAME>_ID =<LTDAUTOLOAD.ID>; 716 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.ID =<LTDAUTOLOAD.ID>; 717 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.START =.; 718 # 719 # TEXT BLOCK: READ ONLY 720 # 721 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_START =.; 722 #:::::::::: text/rodata 723 <FOREACH.LTDAUTOLOAD.OBJECTS=.text> 724 <LTDAUTOLOAD.OBJECT=.text:t> 725 <END.LTDAUTOLOAD.OBJECTS> 726 <FOREACH.LTDAUTOLOAD.LIBRARIES=.text> 727 <LTDAUTOLOAD.LIBRARY=.text:t> 728 <END.LTDAUTOLOAD.LIBRARIES> 729 <FOREACH.LTDAUTOLOAD.OBJECTS=.rodata> 730 <LTDAUTOLOAD.OBJECT=.rodata:t> 731 <END.LTDAUTOLOAD.OBJECTS> 732 <FOREACH.LTDAUTOLOAD.LIBRARIES=.rodata> 733 <LTDAUTOLOAD.LIBRARY=.rodata:t> 734 <END.LTDAUTOLOAD.LIBRARIES> 735 <FOREACH.LTDAUTOLOAD.OBJECTS=.init> 736 <LTDAUTOLOAD.OBJECT=.init:t> 737 <END.LTDAUTOLOAD.OBJECTS> 738 <FOREACH.LTDAUTOLOAD.LIBRARIES=.init> 739 <LTDAUTOLOAD.LIBRARY=.init:t> 740 <END.LTDAUTOLOAD.LIBRARIES> 741 . = ALIGN(4); 742 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SINIT_START = .; 743 #:::::::::: ctor 744 <FOREACH.LTDAUTOLOAD.OBJECTS=.ctor> 745 <LTDAUTOLOAD.OBJECT=.ctor:t> 746 <END.LTDAUTOLOAD.OBJECTS> 747 <FOREACH.LTDAUTOLOAD.LIBRARIES=.ctor> 748 <LTDAUTOLOAD.LIBRARY=.ctor:t> 749 <END.LTDAUTOLOAD.LIBRARIES> 750 <FOREACH.LTDAUTOLOAD.OBJECTS=.sinit> 751 <LTDAUTOLOAD.OBJECT=.sinit:t> 752 <END.LTDAUTOLOAD.OBJECTS> 753 <FOREACH.LTDAUTOLOAD.LIBRARIES=.sinit> 754 <LTDAUTOLOAD.LIBRARY=.sinit:t> 755 <END.LTDAUTOLOAD.LIBRARIES> 756 WRITEW 0; 757 #:::::::::: ctor 758 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SINIT_END = .; 759 #:::::::::: text/rodata 760 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_END =.; 761 762 # 763 # DATA BLOCK: READ WRITE 764 # 765 . = ALIGN(32); 766 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_START =.; 767 #:::::::::: Data 768 <FOREACH.LTDAUTOLOAD.OBJECTS=.ltdmain> 769 <LTDAUTOLOAD.OBJECT=.ltdmain:t> 770 <END.LTDAUTOLOAD.OBJECTS> 771 <FOREACH.LTDAUTOLOAD.LIBRARIES=.ltdmain> 772 <LTDAUTOLOAD.LIBRARY=.ltdmain:t> 773 <END.LTDAUTOLOAD.LIBRARIES> 774 <FOREACH.LTDAUTOLOAD.OBJECTS=.sdata> 775 <LTDAUTOLOAD.OBJECT=.sdata:t> 776 <END.LTDAUTOLOAD.OBJECTS> 777 <FOREACH.LTDAUTOLOAD.LIBRARIES=.sdata> 778 <LTDAUTOLOAD.LIBRARY=.sdata:t> 779 <END.LTDAUTOLOAD.LIBRARIES> 780 <FOREACH.LTDAUTOLOAD.OBJECTS=.data> 781 <LTDAUTOLOAD.OBJECT=.data:t> 782 <END.LTDAUTOLOAD.OBJECTS> 783 <FOREACH.LTDAUTOLOAD.LIBRARIES=.data> 784 <LTDAUTOLOAD.LIBRARY=.data:t> 785 <END.LTDAUTOLOAD.LIBRARIES> 786 #:::::::::: Data 787 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_END =.; 788 . = ALIGN(32); 789 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.END =.; 790 791 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_SIZE = SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_END - SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_START; 792 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_SIZE = SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_END - SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_START; 793 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SIZE = SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.END - SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.START; 794 SDK_LTDAUTOLOAD_SIZE = SDK_LTDAUTOLOAD_SIZE + SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SIZE; 795 796 } > <LTDAUTOLOAD.NAME> 797 798 .<LTDAUTOLOAD.NAME>.bss: 799 { 800 ALIGNALL(4); 801 . = ALIGN(32); 802 803 # 804 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 805 # 806 <FOREACH.LTDAUTOLOAD.SEARCHSYMBOLS> 807 SEARCH_SYMBOL <LTDAUTOLOAD.SEARCHSYMBOL>; 808 <END.LTDAUTOLOAD.SEARCHSYMBOLS> 809 810 # 811 # BSS BLOCK 812 # 813 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_START =.; 814 #:::::::::: bss 815 <FOREACH.LTDAUTOLOAD.OBJECTS=.ltdmain> 816 <LTDAUTOLOAD.OBJECT=.ltdmain.bss:t> 817 <END.LTDAUTOLOAD.OBJECTS> 818 <FOREACH.LTDAUTOLOAD.LIBRARIES=.ltdmain> 819 <LTDAUTOLOAD.LIBRARY=.ltdmain.bss:t> 820 <END.LTDAUTOLOAD.LIBRARIES> 821 <FOREACH.LTDAUTOLOAD.OBJECTS=.sbss> 822 <LTDAUTOLOAD.OBJECT=.sbss:t> 823 <END.LTDAUTOLOAD.OBJECTS> 824 <FOREACH.LTDAUTOLOAD.LIBRARIES=.sbss> 825 <LTDAUTOLOAD.LIBRARY=.sbss:t> 826 <END.LTDAUTOLOAD.LIBRARIES> 827 <FOREACH.LTDAUTOLOAD.OBJECTS=.bss> 828 <LTDAUTOLOAD.OBJECT=.bss:t> 829 <END.LTDAUTOLOAD.OBJECTS> 830 <FOREACH.LTDAUTOLOAD.LIBRARIES=.bss> 831 <LTDAUTOLOAD.LIBRARY=.bss:t> 832 <END.LTDAUTOLOAD.LIBRARIES> 833 #:::::::::: bss 834 . = ALIGN(32); 835 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_END =.; 836 837 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_SIZE = SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_END - SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_START; 838 839 } >> <LTDAUTOLOAD.NAME> 840 841<END.LTDAUTOLOADS> 842 843 SDK_LTDAUTOLOAD_LTDMAIN_START = SDK_LTDAUTOLOAD.LTDMAIN.START; 844 SDK_LTDAUTOLOAD_LTDMAIN_END = SDK_LTDAUTOLOAD.LTDMAIN.END; 845 SDK_LTDAUTOLOAD_LTDMAIN_BSS_END = SDK_LTDAUTOLOAD.LTDMAIN.BSS_END; 846 SDK_LTDAUTOLOAD_LTDMAIN_SIZE = SDK_LTDAUTOLOAD.LTDMAIN.SIZE; 847 SDK_LTDAUTOLOAD_LTDMAIN_BSS_SIZE = SDK_LTDAUTOLOAD.LTDMAIN.BSS_SIZE; 848 849 ######################### LTDAUTOLOAD_INFO ########################## 850 .binary.LTDAUTOLOAD_INFO: 851 { 852 <FOREACH.LTDAUTOLOADS> 853 WRITEW ADDR(.<LTDAUTOLOAD.NAME>); 854 WRITEW SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SIZE; 855 WRITEW SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SINIT_START; 856 WRITEW SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_SIZE; 857 <END.LTDAUTOLOADS> 858 859 } > binary.LTDAUTOLOAD_INFO 860 861 SDK_LTDAUTOLOAD_LIST = SDK_LTDAUTOLOAD_START + SDK_LTDAUTOLOAD_SIZE; 862 SDK_LTDAUTOLOAD_LIST_END = SDK_LTDAUTOLOAD_LIST + SIZEOF(.binary.LTDAUTOLOAD_INFO); 863 SDK_LTDAUTOLOAD_SIZE = SDK_LTDAUTOLOAD_SIZE + SIZEOF(.binary.LTDAUTOLOAD_INFO); 864 865 ########################### LTDOVERLAYS ############################# 866 SDK_LTDOVERLAY_NUMBER = <NUMBER.LTDOVERLAYS>; 867 868<FOREACH.LTDOVERLAYS> 869 .<LTDOVERLAY.NAME>:<LTDOVERLAY.NAME> 870 { 871 ALIGNALL(4); 872 . = ALIGN(32); 873 874 # 875 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 876 # 877 <FOREACH.LTDOVERLAY.SEARCHSYMBOLS> 878 SEARCH_SYMBOL <LTDOVERLAY.SEARCHSYMBOL>; 879 <END.LTDOVERLAY.SEARCHSYMBOLS> 880 881 SDK_LTDOVERLAY_<LTDOVERLAY.NAME>_ID =<LTDOVERLAY.ID>; 882 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.ID =<LTDOVERLAY.ID>; 883 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.START =.; 884 # 885 # TEXT BLOCK: READ ONLY 886 # 887 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_START =.; 888 #:::::::::: text/rodata 889 <FOREACH.LTDOVERLAY.OBJECTS=.text> 890 <LTDOVERLAY.OBJECT=.text:t> 891 <END.LTDOVERLAY.OBJECTS> 892 <FOREACH.LTDOVERLAY.LIBRARIES=.text> 893 <LTDOVERLAY.LIBRARY=.text:t> 894 <END.LTDOVERLAY.LIBRARIES> 895 <FOREACH.LTDOVERLAY.OBJECTS=.rodata> 896 <LTDOVERLAY.OBJECT=.rodata:t> 897 <END.LTDOVERLAY.OBJECTS> 898 <FOREACH.LTDOVERLAY.LIBRARIES=.rodata> 899 <LTDOVERLAY.LIBRARY=.rodata:t> 900 <END.LTDOVERLAY.LIBRARIES> 901 <FOREACH.LTDOVERLAY.OBJECTS=.init> 902 <LTDOVERLAY.OBJECT=.init:t> 903 <END.LTDOVERLAY.OBJECTS> 904 <FOREACH.LTDOVERLAY.LIBRARIES=.init> 905 <LTDOVERLAY.LIBRARY=.init:t> 906 <END.LTDOVERLAY.LIBRARIES> 907 . = ALIGN(4); 908 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SINIT_START =.; 909 #:::::::::: ctor 910 <FOREACH.LTDOVERLAY.OBJECTS=.ctor> 911 <LTDOVERLAY.OBJECT=.ctor:t> 912 <END.LTDOVERLAY.OBJECTS> 913 <FOREACH.LTDOVERLAY.LIBRARIES=.ctor> 914 <LTDOVERLAY.LIBRARY=.ctor:t> 915 <END.LTDOVERLAY.LIBRARIES> 916 <FOREACH.LTDOVERLAY.OBJECTS=.sinit> 917 <LTDOVERLAY.OBJECT=.sinit:t> 918 <END.LTDOVERLAY.OBJECTS> 919 <FOREACH.LTDOVERLAY.LIBRARIES=.sinit> 920 <LTDOVERLAY.LIBRARY=.sinit:t> 921 <END.LTDOVERLAY.LIBRARIES> 922 WRITEW 0; 923 #:::::::::: ctor 924 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SINIT_END =.; 925 #:::::::::: text/rodata 926 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_END =.; 927 928 # 929 # DATA BLOCK: READ WRITE 930 # 931 . = ALIGN(32); 932 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_START =.; 933 #:::::::::: Data 934 <FOREACH.LTDOVERLAY.OBJECTS=.sdata> 935 <LTDOVERLAY.OBJECT=.sdata:t> 936 <END.LTDOVERLAY.OBJECTS> 937 <FOREACH.LTDOVERLAY.LIBRARIES=.sdata> 938 <LTDOVERLAY.LIBRARY=.sdata:t> 939 <END.LTDOVERLAY.LIBRARIES> 940 <FOREACH.LTDOVERLAY.OBJECTS=.data> 941 <LTDOVERLAY.OBJECT=.data:t> 942 <END.LTDOVERLAY.OBJECTS> 943 <FOREACH.LTDOVERLAY.LIBRARIES=.data> 944 <LTDOVERLAY.LIBRARY=.data:t> 945 <END.LTDOVERLAY.LIBRARIES> 946 #:::::::::: Data 947 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_END =.; 948 . = ALIGN(32); 949 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.END =.; 950 951 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_SIZE = SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_END - SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_START; 952 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_SIZE = SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_END - SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_START; 953 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SIZE = SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.END - SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.START; 954 955 } > <LTDOVERLAY.NAME> 956 957 .<LTDOVERLAY.NAME>.bss:<LTDOVERLAY.NAME> 958 { 959 ALIGNALL(4); 960 . = ALIGN(32); 961 962 # 963 # Definition to refer overlay segment, when same name symbols exist in multiple overlays 964 # 965 <FOREACH.LTDOVERLAY.SEARCHSYMBOLS> 966 SEARCH_SYMBOL <LTDOVERLAY.SEARCHSYMBOL>; 967 <END.LTDOVERLAY.SEARCHSYMBOLS> 968 969 # 970 # BSS BLOCK 971 # 972 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_START =.; 973 #:::::::::: bss 974 <FOREACH.LTDOVERLAY.OBJECTS=.bss> 975 <LTDOVERLAY.OBJECT=.bss:t> 976 <END.LTDOVERLAY.OBJECTS> 977 <FOREACH.LTDOVERLAY.LIBRARIES=.bss> 978 <LTDOVERLAY.LIBRARY=.bss:t> 979 <END.LTDOVERLAY.LIBRARIES> 980 <FOREACH.LTDOVERLAY.OBJECTS=.sbss> 981 <LTDOVERLAY.OBJECT=.sbss:t> 982 <END.LTDOVERLAY.OBJECTS> 983 <FOREACH.LTDOVERLAY.LIBRARIES=.sbss> 984 <LTDOVERLAY.LIBRARY=.sbss:t> 985 <END.LTDOVERLAY.LIBRARIES> 986 #:::::::::: bss 987 . = ALIGN(32); 988 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_END =.; 989 990 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_SIZE = SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_END - SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_START; 991 992 } >> <LTDOVERLAY.NAME> 993 994<END.LTDOVERLAYS> 995 996 ########################## LTDOVERLAYDEFS ########################### 997 .<PROPERTY.LTDOVERLAYDEFS>L: 998 { 999 ### TWL limited extended static module information 1000 WRITEW SDK_LTDAUTOLOAD_TOP_START; # Load address 1001 WRITEW 0; # Padding 1002 WRITEW SDK_LTDAUTOLOAD_SIZE + SDK_LTDAUTOLOAD_TOP_SIZE; # Size of module 1003 WRITEW 0; # Padding 1004 1005 ### TWL limited overlay filename 1006 <FOREACH.LTDOVERLAYS> 1007 WRITES ("<LTDOVERLAY.NAME><PROPERTY.LTDSUFFIX>"); 1008 <END.LTDOVERLAYS> 1009 1010 } > <PROPERTY.LTDOVERLAYDEFS>L 1011 1012 ######################### LTDOVERLAYTABLE ########################### 1013 .<PROPERTY.LTDOVERLAYTABLE>L: 1014 { 1015 <FOREACH.LTDOVERLAYS> 1016 WRITEW <LTDOVERLAY.ID>; # Overlay ID 1017 WRITEW ADDR(.<LTDOVERLAY.NAME>); # Load address 1018 WRITEW SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SIZE; # Size of module 1019 WRITEW SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_SIZE; # Size of bss 1020 WRITEW SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SINIT_START; # Start address of static init 1021 WRITEW SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SINIT_END; # End address of static init 1022 WRITEW <LTDOVERLAY.ID>; # ROM file ID 1023 WRITEW 0; # Compressed state 1024 <END.LTDOVERLAYS> 1025 1026 } > <PROPERTY.LTDOVERLAYTABLE>L 1027 1028 ############################ ARENA ################################## 1029 .dummy.MAIN_EX.TWL: 1030 { 1031 . = ALIGN(32); 1032 1033 } > dummy.MAIN_EX.TWL 1034 1035 .arena.MAIN.TWL: 1036 { 1037 . = ALIGN(32); 1038 SDK_LTDMAIN_ARENA_LO =.; 1039 1040 } > arena.MAIN.TWL 1041 1042 .arena.MAIN_EX.TWL: 1043 { 1044 . = ALIGN(32); 1045 SDK_LTDMAIN_EX_ARENA_LO =.; 1046 1047 } > arena.MAIN_EX.TWL 1048 1049 ############################ OTHERS ################################# 1050 # Module filelist 1051 .binary.MODULE_FILES: 1052 { 1053 WRITES ("<STATIC.NAME><PROPERTY.FLXSUFFIX>"); 1054 WRITES ("<PROPERTY.OVERLAYDEFS><PROPERTY.FLXSUFFIX>"); 1055 WRITES ("<PROPERTY.OVERLAYTABLE><PROPERTY.FLXSUFFIX>"); 1056 WRITES ("<STATIC.NAME><PROPERTY.LTDSUFFIX>"); 1057 WRITES ("<PROPERTY.LTDOVERLAYDEFS><PROPERTY.LTDSUFFIX>"); 1058 WRITES ("<PROPERTY.LTDOVERLAYTABLE><PROPERTY.LTDSUFFIX>"); 1059 1060 } > binary.MODULE_FILES 1061 1062} 1063