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:: 2009-11-11#$ 14# $Rev: 11140 $ 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 = 0x0, LENGTH = 0x08000 > itcm.check 40 check.DTCM (RW) : ORIGIN = 0x0, 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_AUTOLOAD_ITCM_SIZE + SDK_AUTOLOAD_ITCM_BSS_SIZE; 653 <FOREACH.OVERLAYS=ITCM> 654 . = . + SDK_OVERLAY.<OVERLAY.NAME>.SIZE + SDK_OVERLAY.<OVERLAY.NAME>.BSS_SIZE; 655 <END.OVERLAYS> 656 657 } > check.ITCM 658 659 .check.DTCM: 660 { 661 . = . + SDK_AUTOLOAD_DTCM_SIZE + SDK_AUTOLOAD_DTCM_BSS_SIZE; 662 <FOREACH.OVERLAYS=DTCM> 663 . = . + SDK_OVERLAY.<OVERLAY.NAME>.SIZE + SDK_OVERLAY.<OVERLAY.NAME>.BSS_SIZE; 664 <END.OVERLAYS> 665 . = . + 0x080 + SDK_IRQ_STACKSIZE + SDK_SYS_STACKSIZE * SDK_SYS_STACKSIZE_SIGN; 666 } > check.DTCM 667 668 .check.MAIN.NITRO: 669 { 670 . = SDK_SECTION_ARENA_START; 671 672 } > check.MAIN.NITRO 673 674 ########################### LTDAUTOLOADS ############################ 675 SDK_LTDAUTOLOAD.LTDMAIN.START = SDK_STATIC_BSS_END; 676 SDK_LTDAUTOLOAD.LTDMAIN.END = SDK_LTDAUTOLOAD.LTDMAIN.START; 677 SDK_LTDAUTOLOAD.LTDMAIN.BSS_END = SDK_LTDAUTOLOAD.LTDMAIN.START; 678 SDK_LTDAUTOLOAD.LTDMAIN.SIZE = 0; 679 SDK_LTDAUTOLOAD.LTDMAIN.BSS_SIZE = 0; 680 SDK_LTDAUTOLOAD_TOP_START = 0x02400000; 681 SDK_LTDAUTOLOAD_TOP_SIZE = 4; # While there is no STATIC region, a 4-byte dummy is at the top of the binary file 682 SDK_LTDAUTOLOAD_START = SDK_LTDAUTOLOAD_TOP_START + SDK_LTDAUTOLOAD_TOP_SIZE; 683 SDK_LTDAUTOLOAD_SIZE = 0; 684 SDK_LTDAUTOLOAD_NUMBER = <NUMBER.LTDAUTOLOADS>; 685 686 .binary.LTDAUTOLOAD_TOP: 687 { 688 WRITEW 0; 689 690 } > binary.LTDAUTOLOAD_TOP 691 692<FOREACH.LTDAUTOLOADS> 693 .<LTDAUTOLOAD.NAME>: 694 { 695 ALIGNALL(4); 696 . = ALIGN(32); # Fit to cache line 697 698 # 699 # Definition to refer overlay segment, when same name symbols exist in multiple overlays. 700 # 701 <FOREACH.LTDAUTOLOAD.SEARCHSYMBOLS> 702 SEARCH_SYMBOL <LTDAUTOLOAD.SEARCHSYMBOL>; 703 <END.LTDAUTOLOAD.SEARCHSYMBOLS> 704 705 SDK_LTDAUTOLOAD_<LTDAUTOLOAD.NAME>_ID =<LTDAUTOLOAD.ID>; 706 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.ID =<LTDAUTOLOAD.ID>; 707 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.START =.; 708 # 709 # TEXT BLOCK: READ ONLY 710 # 711 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_START =.; 712 #:::::::::: text/rodata 713 <FOREACH.LTDAUTOLOAD.FORCES> 714 FORCE_OBJECT<LTDAUTOLOAD.FORCE> 715 <END.LTDAUTOLOAD.FORCES> 716 <FOREACH.LTDAUTOLOAD.OBJECTS=.text> 717 <LTDAUTOLOAD.OBJECT=.text:t> 718 <END.LTDAUTOLOAD.OBJECTS> 719 <FOREACH.LTDAUTOLOAD.LIBRARIES=.text> 720 <LTDAUTOLOAD.LIBRARY=.text:t> 721 <END.LTDAUTOLOAD.LIBRARIES> 722 <FOREACH.LTDAUTOLOAD.OBJECTS=.rodata> 723 <LTDAUTOLOAD.OBJECT=.rodata:t> 724 <END.LTDAUTOLOAD.OBJECTS> 725 <FOREACH.LTDAUTOLOAD.LIBRARIES=.rodata> 726 <LTDAUTOLOAD.LIBRARY=.rodata:t> 727 <END.LTDAUTOLOAD.LIBRARIES> 728 <FOREACH.LTDAUTOLOAD.OBJECTS=.init> 729 <LTDAUTOLOAD.OBJECT=.init:t> 730 <END.LTDAUTOLOAD.OBJECTS> 731 <FOREACH.LTDAUTOLOAD.LIBRARIES=.init> 732 <LTDAUTOLOAD.LIBRARY=.init:t> 733 <END.LTDAUTOLOAD.LIBRARIES> 734 . = ALIGN(4); 735 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SINIT_START = .; 736 #:::::::::: ctor 737 <FOREACH.LTDAUTOLOAD.OBJECTS=.ctor> 738 <LTDAUTOLOAD.OBJECT=.ctor:t> 739 <END.LTDAUTOLOAD.OBJECTS> 740 <FOREACH.LTDAUTOLOAD.LIBRARIES=.ctor> 741 <LTDAUTOLOAD.LIBRARY=.ctor:t> 742 <END.LTDAUTOLOAD.LIBRARIES> 743 <FOREACH.LTDAUTOLOAD.OBJECTS=.sinit> 744 <LTDAUTOLOAD.OBJECT=.sinit:t> 745 <END.LTDAUTOLOAD.OBJECTS> 746 <FOREACH.LTDAUTOLOAD.LIBRARIES=.sinit> 747 <LTDAUTOLOAD.LIBRARY=.sinit:t> 748 <END.LTDAUTOLOAD.LIBRARIES> 749 WRITEW 0; 750 #:::::::::: ctor 751 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SINIT_END = .; 752 #:::::::::: text/rodata 753 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_END =.; 754 755 # 756 # DATA BLOCK: READ WRITE 757 # 758 . = ALIGN(32); 759 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_START =.; 760 #:::::::::: data 761 <FOREACH.LTDAUTOLOAD.OBJECTS=.ltdmain> 762 <LTDAUTOLOAD.OBJECT=.ltdmain:t> 763 <END.LTDAUTOLOAD.OBJECTS> 764 <FOREACH.LTDAUTOLOAD.LIBRARIES=.ltdmain> 765 <LTDAUTOLOAD.LIBRARY=.ltdmain:t> 766 <END.LTDAUTOLOAD.LIBRARIES> 767 <FOREACH.LTDAUTOLOAD.OBJECTS=.sdata> 768 <LTDAUTOLOAD.OBJECT=.sdata:t> 769 <END.LTDAUTOLOAD.OBJECTS> 770 <FOREACH.LTDAUTOLOAD.LIBRARIES=.sdata> 771 <LTDAUTOLOAD.LIBRARY=.sdata:t> 772 <END.LTDAUTOLOAD.LIBRARIES> 773 <FOREACH.LTDAUTOLOAD.OBJECTS=.data> 774 <LTDAUTOLOAD.OBJECT=.data:t> 775 <END.LTDAUTOLOAD.OBJECTS> 776 <FOREACH.LTDAUTOLOAD.LIBRARIES=.data> 777 <LTDAUTOLOAD.LIBRARY=.data:t> 778 <END.LTDAUTOLOAD.LIBRARIES> 779 #:::::::::: data 780 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_END =.; 781 . = ALIGN(32); 782 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.END =.; 783 784 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_SIZE = SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_END - SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.TEXT_START; 785 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_SIZE = SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_END - SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.DATA_START; 786 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SIZE = SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.END - SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.START; 787 SDK_LTDAUTOLOAD_SIZE = SDK_LTDAUTOLOAD_SIZE + SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SIZE; 788 789 } > <LTDAUTOLOAD.NAME> 790 791 .<LTDAUTOLOAD.NAME>.bss: 792 { 793 ALIGNALL(4); 794 . = ALIGN(32); 795 796 # 797 # Definition to refer overlay segment, when same name symbols exist in multiple overlays. 798 # 799 <FOREACH.LTDAUTOLOAD.SEARCHSYMBOLS> 800 SEARCH_SYMBOL <LTDAUTOLOAD.SEARCHSYMBOL>; 801 <END.LTDAUTOLOAD.SEARCHSYMBOLS> 802 803 # 804 # BSS BLOCK 805 # 806 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_START =.; 807 #:::::::::: bss 808 <FOREACH.LTDAUTOLOAD.OBJECTS=.ltdmain> 809 <LTDAUTOLOAD.OBJECT=.ltdmain.bss:t> 810 <END.LTDAUTOLOAD.OBJECTS> 811 <FOREACH.LTDAUTOLOAD.LIBRARIES=.ltdmain> 812 <LTDAUTOLOAD.LIBRARY=.ltdmain.bss:t> 813 <END.LTDAUTOLOAD.LIBRARIES> 814 <FOREACH.LTDAUTOLOAD.OBJECTS=.sbss> 815 <LTDAUTOLOAD.OBJECT=.sbss:t> 816 <END.LTDAUTOLOAD.OBJECTS> 817 <FOREACH.LTDAUTOLOAD.LIBRARIES=.sbss> 818 <LTDAUTOLOAD.LIBRARY=.sbss:t> 819 <END.LTDAUTOLOAD.LIBRARIES> 820 <FOREACH.LTDAUTOLOAD.OBJECTS=.bss> 821 <LTDAUTOLOAD.OBJECT=.bss:t> 822 <END.LTDAUTOLOAD.OBJECTS> 823 <FOREACH.LTDAUTOLOAD.LIBRARIES=.bss> 824 <LTDAUTOLOAD.LIBRARY=.bss:t> 825 <END.LTDAUTOLOAD.LIBRARIES> 826 #:::::::::: bss 827 . = ALIGN(32); 828 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_END =.; 829 830 SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_SIZE = SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_END - SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_START; 831 832 } >> <LTDAUTOLOAD.NAME> 833 834<END.LTDAUTOLOADS> 835 836 SDK_LTDAUTOLOAD_LTDMAIN_START = SDK_LTDAUTOLOAD.LTDMAIN.START; 837 SDK_LTDAUTOLOAD_LTDMAIN_END = SDK_LTDAUTOLOAD.LTDMAIN.END; 838 SDK_LTDAUTOLOAD_LTDMAIN_BSS_END = SDK_LTDAUTOLOAD.LTDMAIN.BSS_END; 839 SDK_LTDAUTOLOAD_LTDMAIN_SIZE = SDK_LTDAUTOLOAD.LTDMAIN.SIZE; 840 SDK_LTDAUTOLOAD_LTDMAIN_BSS_SIZE = SDK_LTDAUTOLOAD.LTDMAIN.BSS_SIZE; 841 842 ######################### LTDAUTOLOAD_INFO ########################## 843 .binary.LTDAUTOLOAD_INFO: 844 { 845 <FOREACH.LTDAUTOLOADS> 846 WRITEW ADDR(.<LTDAUTOLOAD.NAME>); 847 WRITEW SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SIZE; 848 WRITEW SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.SINIT_START; 849 WRITEW SDK_LTDAUTOLOAD.<LTDAUTOLOAD.NAME>.BSS_SIZE; 850 <END.LTDAUTOLOADS> 851 852 } > binary.LTDAUTOLOAD_INFO 853 854 SDK_LTDAUTOLOAD_LIST = SDK_LTDAUTOLOAD_START + SDK_LTDAUTOLOAD_SIZE; 855 SDK_LTDAUTOLOAD_LIST_END = SDK_LTDAUTOLOAD_LIST + SIZEOF(.binary.LTDAUTOLOAD_INFO); 856 SDK_LTDAUTOLOAD_SIZE = SDK_LTDAUTOLOAD_SIZE + SIZEOF(.binary.LTDAUTOLOAD_INFO); 857 858 ########################### LTDOVERLAYS ############################# 859 SDK_LTDOVERLAY_NUMBER = <NUMBER.LTDOVERLAYS>; 860 861<FOREACH.LTDOVERLAYS> 862 .<LTDOVERLAY.NAME>:<LTDOVERLAY.NAME> 863 { 864 ALIGNALL(4); 865 . = ALIGN(32); 866 867 # 868 # Definition to refer overlay segment, when same name symbols exist in multiple overlays. 869 # 870 <FOREACH.LTDOVERLAY.SEARCHSYMBOLS> 871 SEARCH_SYMBOL <LTDOVERLAY.SEARCHSYMBOL>; 872 <END.LTDOVERLAY.SEARCHSYMBOLS> 873 874 SDK_LTDOVERLAY_<LTDOVERLAY.NAME>_ID =<LTDOVERLAY.ID>; 875 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.ID =<LTDOVERLAY.ID>; 876 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.START =.; 877 # 878 # TEXT BLOCK: READ ONLY 879 # 880 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_START =.; 881 #:::::::::: text/rodata 882 <FOREACH.LTDOVERLAY.FORCES> 883 FORCE_OBJECT<LTDOVERLAY.FORCE> 884 <END.LTDOVERLAY.FORCES> 885 <FOREACH.LTDOVERLAY.OBJECTS=.text> 886 <LTDOVERLAY.OBJECT=.text:t> 887 <END.LTDOVERLAY.OBJECTS> 888 <FOREACH.LTDOVERLAY.LIBRARIES=.text> 889 <LTDOVERLAY.LIBRARY=.text:t> 890 <END.LTDOVERLAY.LIBRARIES> 891 <FOREACH.LTDOVERLAY.OBJECTS=.rodata> 892 <LTDOVERLAY.OBJECT=.rodata:t> 893 <END.LTDOVERLAY.OBJECTS> 894 <FOREACH.LTDOVERLAY.LIBRARIES=.rodata> 895 <LTDOVERLAY.LIBRARY=.rodata:t> 896 <END.LTDOVERLAY.LIBRARIES> 897 <FOREACH.LTDOVERLAY.OBJECTS=.init> 898 <LTDOVERLAY.OBJECT=.init:t> 899 <END.LTDOVERLAY.OBJECTS> 900 <FOREACH.LTDOVERLAY.LIBRARIES=.init> 901 <LTDOVERLAY.LIBRARY=.init:t> 902 <END.LTDOVERLAY.LIBRARIES> 903 . = ALIGN(4); 904 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SINIT_START =.; 905 #:::::::::: ctor 906 <FOREACH.LTDOVERLAY.OBJECTS=.ctor> 907 <LTDOVERLAY.OBJECT=.ctor:t> 908 <END.LTDOVERLAY.OBJECTS> 909 <FOREACH.LTDOVERLAY.LIBRARIES=.ctor> 910 <LTDOVERLAY.LIBRARY=.ctor:t> 911 <END.LTDOVERLAY.LIBRARIES> 912 <FOREACH.LTDOVERLAY.OBJECTS=.sinit> 913 <LTDOVERLAY.OBJECT=.sinit:t> 914 <END.LTDOVERLAY.OBJECTS> 915 <FOREACH.LTDOVERLAY.LIBRARIES=.sinit> 916 <LTDOVERLAY.LIBRARY=.sinit:t> 917 <END.LTDOVERLAY.LIBRARIES> 918 WRITEW 0; 919 #:::::::::: ctor 920 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SINIT_END =.; 921 #:::::::::: text/rodata 922 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_END =.; 923 924 # 925 # DATA BLOCK: READ WRITE 926 # 927 . = ALIGN(32); 928 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_START =.; 929 #:::::::::: data 930 <FOREACH.LTDOVERLAY.OBJECTS=.sdata> 931 <LTDOVERLAY.OBJECT=.sdata:t> 932 <END.LTDOVERLAY.OBJECTS> 933 <FOREACH.LTDOVERLAY.LIBRARIES=.sdata> 934 <LTDOVERLAY.LIBRARY=.sdata:t> 935 <END.LTDOVERLAY.LIBRARIES> 936 <FOREACH.LTDOVERLAY.OBJECTS=.data> 937 <LTDOVERLAY.OBJECT=.data:t> 938 <END.LTDOVERLAY.OBJECTS> 939 <FOREACH.LTDOVERLAY.LIBRARIES=.data> 940 <LTDOVERLAY.LIBRARY=.data:t> 941 <END.LTDOVERLAY.LIBRARIES> 942 #:::::::::: data 943 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_END =.; 944 . = ALIGN(32); 945 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.END =.; 946 947 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_SIZE = SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_END - SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.TEXT_START; 948 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_SIZE = SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_END - SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.DATA_START; 949 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SIZE = SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.END - SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.START; 950 951 } > <LTDOVERLAY.NAME> 952 953 .<LTDOVERLAY.NAME>.bss:<LTDOVERLAY.NAME> 954 { 955 ALIGNALL(4); 956 . = ALIGN(32); 957 958 # 959 # Definition to refer overlay segment, when same name symbols exist in multiple overlays. 960 # 961 <FOREACH.LTDOVERLAY.SEARCHSYMBOLS> 962 SEARCH_SYMBOL <LTDOVERLAY.SEARCHSYMBOL>; 963 <END.LTDOVERLAY.SEARCHSYMBOLS> 964 965 # 966 # BSS BLOCK 967 # 968 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_START =.; 969 #:::::::::: bss 970 <FOREACH.LTDOVERLAY.OBJECTS=.bss> 971 <LTDOVERLAY.OBJECT=.bss:t> 972 <END.LTDOVERLAY.OBJECTS> 973 <FOREACH.LTDOVERLAY.LIBRARIES=.bss> 974 <LTDOVERLAY.LIBRARY=.bss:t> 975 <END.LTDOVERLAY.LIBRARIES> 976 <FOREACH.LTDOVERLAY.OBJECTS=.sbss> 977 <LTDOVERLAY.OBJECT=.sbss:t> 978 <END.LTDOVERLAY.OBJECTS> 979 <FOREACH.LTDOVERLAY.LIBRARIES=.sbss> 980 <LTDOVERLAY.LIBRARY=.sbss:t> 981 <END.LTDOVERLAY.LIBRARIES> 982 #:::::::::: bss 983 . = ALIGN(32); 984 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_END =.; 985 986 SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_SIZE = SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_END - SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_START; 987 988 } >> <LTDOVERLAY.NAME> 989 990<END.LTDOVERLAYS> 991 992 ########################## LTDOVERLAYDEFS ########################### 993 .<PROPERTY.LTDOVERLAYDEFS>L: 994 { 995 ### TWL limited extended static module information 996 WRITEW SDK_LTDAUTOLOAD_TOP_START; # load address 997 WRITEW 0; # padding 998 WRITEW SDK_LTDAUTOLOAD_SIZE + SDK_LTDAUTOLOAD_TOP_SIZE; # size of module 999 WRITEW 0; # padding 1000 1001 ### TWL limited overlay filename 1002 <FOREACH.LTDOVERLAYS> 1003 WRITES ("<LTDOVERLAY.NAME><PROPERTY.LTDSUFFIX>"); 1004 <END.LTDOVERLAYS> 1005 1006 } > <PROPERTY.LTDOVERLAYDEFS>L 1007 1008 ######################### LTDOVERLAYTABLE ########################### 1009 .<PROPERTY.LTDOVERLAYTABLE>L: 1010 { 1011 <FOREACH.LTDOVERLAYS> 1012 WRITEW <LTDOVERLAY.ID>; # overlay ID 1013 WRITEW ADDR(.<LTDOVERLAY.NAME>); # load address 1014 WRITEW SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SIZE; # size of module 1015 WRITEW SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.BSS_SIZE; # size of bss 1016 WRITEW SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SINIT_START; # start address of static init 1017 WRITEW SDK_LTDOVERLAY.<LTDOVERLAY.NAME>.SINIT_END; # end address of static init 1018 WRITEW <LTDOVERLAY.ID>; # ROM file ID 1019 WRITEW 0; # compressed state 1020 <END.LTDOVERLAYS> 1021 1022 } > <PROPERTY.LTDOVERLAYTABLE>L 1023 1024 ############################ ARENA ################################## 1025 .dummy.MAIN_EX.TWL: 1026 { 1027 . = ALIGN(32); 1028 1029 } > dummy.MAIN_EX.TWL 1030 1031 .arena.MAIN.TWL: 1032 { 1033 . = ALIGN(32); 1034 SDK_LTDMAIN_ARENA_LO =.; 1035 1036 } > arena.MAIN.TWL 1037 1038 .arena.MAIN_EX.TWL: 1039 { 1040 . = ALIGN(32); 1041 SDK_LTDMAIN_EX_ARENA_LO =.; 1042 1043 } > arena.MAIN_EX.TWL 1044 1045 .check.MAIN.TWL: 1046 { 1047 . = SDK_LTDMAIN_ARENA_LO; 1048 1049 } > check.MAIN.TWL 1050 1051 ############################ OTHERS ################################# 1052 # Module filelist 1053 .binary.MODULE_FILES: 1054 { 1055 WRITES ("<STATIC.NAME><PROPERTY.FLXSUFFIX>"); 1056 WRITES ("<PROPERTY.OVERLAYDEFS><PROPERTY.FLXSUFFIX>"); 1057 WRITES ("<PROPERTY.OVERLAYTABLE><PROPERTY.FLXSUFFIX>"); 1058 WRITES ("<STATIC.NAME><PROPERTY.LTDSUFFIX>"); 1059 WRITES ("<PROPERTY.LTDOVERLAYDEFS><PROPERTY.LTDSUFFIX>"); 1060 WRITES ("<PROPERTY.LTDOVERLAYTABLE><PROPERTY.LTDSUFFIX>"); 1061 1062 } > binary.MODULE_FILES 1063 1064 # Compression Spec List 1065 .binary.COMP_SPEC_LIST: 1066 { 1067 <FOREACH.OVERLAYS> 1068 WRITES ("<OVERLAY.NAME><PROPERTY.FLXSUFFIX>,<OVERLAY.COMPRESS>"); # Overlay <OVERLAY.ID> 1069 <END.OVERLAYS> 1070 <FOREACH.LTDOVERLAYS> 1071 WRITES ("<LTDOVERLAY.NAME><PROPERTY.LTDSUFFIX>,<LTDOVERLAY.COMPRESS>"); # Overlay <LTDOVERLAY.ID> 1072 <END.LTDOVERLAYS> 1073 } > binary.COMP_SPEC_LIST 1074 1075} 1076