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