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