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