git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/NEC_78K0R_IAR/cstartup.s26

   1 ;\r
   2 ; This file should only be included in the 78K0R_Kx3L demo.  The 78K0R_Kx3 demo\r
   3 ; uses the standard startup file.  This is work around a bug in the startup\r
   4 ; file provided with the IAR tools.\r
   5 ;\r
   6 \r
   7 \r
   8 ;------------------------------------------------------------------------------\r
   9 ;       CSTARTUP source for 78K\r
  10 ;\r
  11 ;       This module contains the code executed before the C/C++ "main"\r
  12 ;       function is called.\r
  13 ;\r
  14 ;       The code usually must be tailored to suit a specific hardware\r
  15 ;       configuration.\r
  16 ;\r
  17 ;       Assembler options:\r
  18 ;\r
  19 ;       -D__STANDARD_MODEL__    To assemble for use with compiler standard\r
  20 ;                               code model.\r
  21 ;\r
  22 ;       -D__BANKED_MODEL__      To assemble for use with compiler banked\r
  23 ;                               code model.\r
  24 ;\r
  25 ;       -D__NEAR_MODEL__        To assemble for use with compiler near\r
  26 ;                               code model.\r
  27 ;\r
  28 ;       -D__FAR_MODEL__         To assemble for use with compiler far\r
  29 ;                               code model.\r
  30 ;\r
  31 ;       Linker options:\r
  32 ;\r
  33 ;       -D_CODEBANK_REG=0       To link for use with "standard" code model,\r
  34 ;                               no banked functions.\r
  35 ;\r
  36 ;       -D_CODEBANK_REG='addr'  To link for use with "banked" code model or\r
  37 ;                               "standard" code model with banked functions.\r
  38 ;                               'addr' = bank switch register address.\r
  39 ;\r
  40 ;------------------------------------------------------------------------------\r
  41 ;       Copyright (c) 2003-2008 IAR Systems AB.\r
  42 ;       $Revision: 3577 $\r
  43 ;------------------------------------------------------------------------------\r
  44 \r
  45 #if !defined(__STANDARD_MODEL__) && !defined(__BANKED_MODEL__) && !defined(__NEAR_MODEL__) && !defined(__FAR_MODEL__)\r
  46   #error One of the macros __STANDARD_MODEL__, __BANKED_MODEL__, __NEAR_MODEL__ or __FAR_MODEL__ must be defined !\r
  47 #endif\r
  48 \r
  49 ;------------------------------------------------------------------------------\r
  50 ;       The stack segment.\r
  51 ;       The stack size is defined in the linker command file\r
  52 ;------------------------------------------------------------------------------\r
  53 \r
  54         MODULE  ?CSTARTUP\r
  55 \r
  56         RSEG    CSTACK:DATA:ROOT(1)\r
  57 \r
  58 \r
  59 ;------------------------------------------------------------------------------\r
  60 ;       The interrupt vector segment.\r
  61 ;       Interrupt functions with defined vectors will reserve\r
  62 ;       space in this area as well as conformingly written assembly\r
  63 ;       language interrupt handlers\r
  64 ;------------------------------------------------------------------------------\r
  65 \r
  66         COMMON  INTVEC:CODE:ROOT(1)\r
  67 \r
  68         DC16    __program_start_fr                 ; Reset vector\r
  69 \r
  70 \r
  71 ;------------------------------------------------------------------------------\r
  72 ;       The actual startup code\r
  73 ;\r
  74 ;       Entry:  __program_start\r
  75 ;------------------------------------------------------------------------------\r
  76 \r
  77         RSEG    RCODE:CODE:ROOT(0)\r
  78 \r
  79         PUBLIC  ?C_STARTUP\r
  80         PUBLIC  `@cstart`             ; NEC debugger specific\r
  81         PUBLIC  __program_start_fr\r
  82 \r
  83         EXTERN  __low_level_init\r
  84         EXTERN  __MAIN_CALL\r
  85 \r
  86 #if defined(__STANDARD_MODEL__) || defined(__BANKED_MODEL__)\r
  87         EXTERN  _CODEBANK_REG\r
  88 #else\r
  89         EXTERN  _NEAR_CONST_LOCATION\r
  90 PMC     DEFINE  0xFFFFE\r
  91 #endif\r
  92 #if defined(__BANKED_MODEL__)\r
  93         EXTERN  ?FAR_CALL_L07\r
  94 \r
  95         SFRTYPE BANK_REG BYTE, READ, WRITE = _CODEBANK_REG\r
  96 #endif\r
  97 \r
  98         REQUIRE __MAIN_CALL\r
  99 \r
 100 \r
 101 ;------------------------------------------------------------------------------\r
 102 ;       Perform the run-time initialization.\r
 103 ;------------------------------------------------------------------------------\r
 104 \r
 105 ?C_STARTUP:\r
 106 `@cstart`:\r
 107 __program_start_fr:\r
 108         DI\r
 109 \r
 110 #if defined(__BANKED_MODEL__)\r
 111         MOV     BANK_REG, #0                    ; Banked, clear bank register\r
 112 #elif defined(__STANDARD_MODEL__)\r
 113         MOVW    AX, #_CODEBANK_REG\r
 114         OR      A, X\r
 115         BZ      nobank                          ; Standard, no banked functions, no bank register (=0)\r
 116         MOVW    HL, #_CODEBANK_REG\r
 117         XOR     A, A\r
 118         MOV     [HL], A                         ; Standard with banked functions, clear bank register\r
 119 nobank:\r
 120 #else\r
 121         MOV     A, #(_NEAR_CONST_LOCATION & 1)  ; Near/Far, set mirror area\r
 122         MOV1    CY, A.0\r
 123         MOV1    PMC.0, CY\r
 124 #endif\r
 125 \r
 126 #if __CORE__ != __78K0S__\r
 127         MOVW    SP, #sfe(CSTACK)\r
 128 #else\r
 129         MOVW    AX, #sfe(CSTACK)\r
 130         MOVW    SP, AX\r
 131 #endif\r
 132 \r
 133 \r
 134         ; Init stack segment for 78K0R, as the generated code may sometimes\r
 135         ; access the 4th byte of a return address before it is initialized\r
 136 #if __CORE__ == __78K0R__\r
 137         MOVW    HL, #sfb(CSTACK)\r
 138         MOVW    BC, #LWRD(sizeof(CSTACK))\r
 139         CMP0    C\r
 140         SKZ\r
 141         INC     B\r
 142         MOV     A, #0xCD\r
 143 loop_s:\r
 144         MOV     [HL], A\r
 145         INCW    HL\r
 146         DEC     C\r
 147         BNZ     loop_s\r
 148         DEC     B\r
 149         BNZ     loop_s\r
 150 #endif\r
 151 \r
 152 #if __CORE__ == __78K0R__\r
 153         MOV     CS, #0\r
 154 #endif\r
 155 \r
 156 ;------------------------------------------------------------------------------\r
 157 ;       Here is the place to put user initializations.\r
 158 ;------------------------------------------------------------------------------\r
 159 \r
 160 ;       User initialization code\r
 161 \r
 162 ;------------------------------------------------------------------------------\r
 163 ;       Call __low_level_init to perform initialization before initializing\r
 164 ;       segments and calling main.\r
 165 ;       If the function returns 0, no segment initialization should take place.\r
 166 ;\r
 167 ;       Link with your own version of __low_level_init to override the\r
 168 ;       default action: to do nothing but return 1.\r
 169 ;------------------------------------------------------------------------------\r
 170 \r
 171 #if defined(__FAR_MODEL__)\r
 172         CALL    F:__low_level_init\r
 173 #elif defined(__BANKED_MODEL__)\r
 174         MOV     E,  #byte3(__low_level_init)\r
 175         MOVW    HL, #lwrd(__low_level_init)\r
 176         CALL    ?FAR_CALL_L07\r
 177 #else\r
 178         CALL    __low_level_init\r
 179 #endif\r
 180         OR      A, X\r
 181 #if __CORE__ == __78K0R__\r
 182         SKNZ\r
 183         BR      N:__MAIN_CALL\r
 184 #else\r
 185         BZ      __MAIN_CALL\r
 186 #endif\r
 187         ENDMOD\r
 188 \r
 189 #if defined(__NEAR_MODEL__) || defined(__FAR_MODEL__)\r
 190 ;------------------------------------------------------------------------------\r
 191 ;       Segment initialization\r
 192 ;\r
 193 ;       FAR_Z  "uninitialized far data" are filled with zero\r
 194 ;------------------------------------------------------------------------------\r
 195 \r
 196         MODULE  ?__INIT_FAR_Z\r
 197 \r
 198         RSEG    FAR_Z:DATA(0)\r
 199         RSEG    RCODE:CODE:NOROOT(0)\r
 200 \r
 201         PUBLIC  __INIT_FAR_Z\r
 202 \r
 203 __INIT_FAR_Z:\r
 204         MOV     ES, #BYTE3(sfb(FAR_Z))\r
 205         MOVW    HL, #LWRD(sfb(FAR_Z))\r
 206         MOV     D, #BYTE3(sizeof(FAR_Z))\r
 207         MOVW    BC, #LWRD(sizeof(FAR_Z))\r
 208         CMP0    C\r
 209         SKZ\r
 210         INC     B\r
 211         CMP0    B\r
 212         SKZ\r
 213         INC     D\r
 214         CLRB    A\r
 215 loop:\r
 216         MOV     ES:[HL], A\r
 217         INCW    HL\r
 218         MOV     A, H\r
 219         OR      A, L\r
 220         CLRB    A\r
 221         SKNZ\r
 222         INC     ES\r
 223         DEC     C\r
 224         BNZ     loop\r
 225         DEC     B\r
 226         BNZ     loop\r
 227         DEC     D\r
 228         BNZ     loop\r
 229 \r
 230         ENDMOD\r
 231 #endif\r
 232 \r
 233 \r
 234 ;------------------------------------------------------------------------------\r
 235 ;       Segment initialization\r
 236 ;\r
 237 ;       NEAR_Z  "uninitialized near data" are filled with zero\r
 238 ;------------------------------------------------------------------------------\r
 239 \r
 240         MODULE  ?__INIT_NEAR_Z\r
 241 \r
 242         RSEG    NEAR_Z:DATA(0)\r
 243         RSEG    RCODE:CODE:NOROOT(0)\r
 244 \r
 245         PUBLIC  __INIT_NEAR_Z\r
 246 \r
 247 __INIT_NEAR_Z:\r
 248 #if __CORE__ == __78K0R__\r
 249         LIMIT   sfb(NEAR_Z)>=0xF0000,1,1,"NEAR_I not placed in near memory"\r
 250 #endif\r
 251         MOVW    HL, #sfb(NEAR_Z)\r
 252         MOVW    BC, #sizeof(NEAR_Z)\r
 253 #if __CORE__ == __78K0R__\r
 254         CMP0    C\r
 255         SKZ\r
 256         INC     B\r
 257         CLRB    A\r
 258 #else\r
 259         MOV     A, C\r
 260         OR      A, A\r
 261         BZ      cont\r
 262         INC     B\r
 263         XOR     A, A\r
 264 cont:\r
 265 #endif\r
 266 loop:\r
 267         MOV     [HL], A\r
 268         INCW    HL\r
 269 #if __CORE__ == __78K0R__\r
 270         DEC     C\r
 271         BNZ     loop\r
 272         DEC     B\r
 273         BNZ     loop\r
 274 #else\r
 275         DBNZ    C, loop\r
 276         DBNZ    B, loop\r
 277 #endif\r
 278 \r
 279         ENDMOD\r
 280 \r
 281 \r
 282 ;------------------------------------------------------------------------------\r
 283 ;       Segment initialization\r
 284 ;\r
 285 ;       SADDR_Z "uninitialized saddr data" are filled with zero\r
 286 ;------------------------------------------------------------------------------\r
 287 \r
 288         MODULE  ?__INIT_SADDR_Z\r
 289 \r
 290         RSEG    SADDR_Z:DATA(0)\r
 291         RSEG    RCODE:CODE:NOROOT(0)\r
 292 \r
 293         PUBLIC  __INIT_SADDR_Z\r
 294 \r
 295 __INIT_SADDR_Z:\r
 296 #if __CORE__ == __78K0R__\r
 297         LIMIT   sfb(SADDR_Z),0xFFE20,0xFFF1F,"SADDR_Z not within saddr memory range"\r
 298         LIMIT   sfe(SADDR_Z),0xFFE20,0xFFF1F,"SADDR_Z not within saddr memory range"\r
 299 #else\r
 300         LIMIT   sfb(SADDR_Z),0xFE20,0xFF1F,"SADDR_Z not within saddr memory range"\r
 301         LIMIT   sfe(SADDR_Z),0xFE20,0xFF1F,"SADDR_Z not within saddr memory range"\r
 302 #endif\r
 303         MOVW    HL, #sfb(SADDR_Z)\r
 304         MOV     B, #sizeof(SADDR_Z)\r
 305 #if __CORE__ == __78K0R__\r
 306         CLRB    A\r
 307 #else\r
 308         XOR     A, A\r
 309 #endif\r
 310 loop:\r
 311         MOV     [HL], A\r
 312         INCW    HL\r
 313 #if __CORE__ == __78K0R__\r
 314         DEC     B\r
 315         BNZ     loop\r
 316 #else\r
 317         DBNZ    B, loop\r
 318 #endif\r
 319 \r
 320         ENDMOD\r
 321 \r
 322 \r
 323 ;------------------------------------------------------------------------------\r
 324 ;       Segment initialization\r
 325 ;\r
 326 ;       WRKSEG short address work area is filled with zero\r
 327 ;------------------------------------------------------------------------------\r
 328 \r
 329         MODULE  ?__INIT_WRKSEG\r
 330 \r
 331         RSEG    WRKSEG:DATA(0)\r
 332         RSEG    RCODE:CODE:NOROOT(0)\r
 333 \r
 334         PUBLIC  __INIT_WRKSEG\r
 335 \r
 336 __INIT_WRKSEG:\r
 337 #if __CORE__ == __78K0R__\r
 338         LIMIT   sfb(WRKSEG),0xFFE20,0xFFF1F,"WRKSEG not within saddr memory range"\r
 339         LIMIT   sfe(WRKSEG),0xFFE20,0xFFF1F,"WRKSEG not within saddr memory range"\r
 340 #else\r
 341         LIMIT   sfb(WRKSEG),0xFE20,0xFF1F,"WRKSEG not within saddr memory range"\r
 342         LIMIT   sfe(WRKSEG),0xFE20,0xFF1F,"WRKSEG not within saddr memory range"\r
 343 #endif\r
 344         MOVW    HL, #sfb(WRKSEG)\r
 345         MOV     B, #sizeof(WRKSEG)\r
 346 #if __CORE__ == __78K0R__\r
 347         CLRB    A\r
 348 #else\r
 349         XOR     A, A\r
 350 #endif\r
 351 loop:\r
 352         MOV     [HL], A\r
 353         INCW    HL\r
 354 #if __CORE__ == __78K0R__\r
 355         DEC     B\r
 356         BNZ     loop\r
 357 #else\r
 358         DBNZ    B, loop\r
 359 #endif\r
 360 \r
 361         ENDMOD\r
 362 \r
 363 \r
 364 #if defined(__NEAR_MODEL__) || defined(__FAR_MODEL__)\r
 365 ;------------------------------------------------------------------------------\r
 366 ;       Segment initialization\r
 367 ;\r
 368 ;       FAR_ID is copied to FAR_I    "initialized far data"\r
 369 ;------------------------------------------------------------------------------\r
 370 \r
 371         MODULE  ?__INIT_FAR_I\r
 372 \r
 373         RSEG    FAR_I:DATA(0)\r
 374         RSEG    FAR_ID:DATA(0)\r
 375         RSEG    RCODE:CODE:NOROOT(0)\r
 376 \r
 377         PUBLIC  __INIT_FAR_I\r
 378 \r
 379 __INIT_FAR_I:\r
 380         ; First make sure FAR_I and FAR_ID have the same size\r
 381         LIMIT   sizeof(FAR_I)-sizeof(FAR_ID),0,0,"FAR_I and FAR_ID not same size"\r
 382 \r
 383         ; Sanity check\r
 384         LIMIT   (sfb(FAR_I)-sfb(FAR_ID))==0,0,0,"FAR_I and FAR_ID have same start address"\r
 385 \r
 386         ; FAR_I and FAR_ID must start at the same offset in a 64k page, unless sizeof\r
 387         ; FAR_I is less than 64k, then it's enugh if both segments reside within a 64k\r
 388         ; boundary\r
 389         LIMIT   (((sfb(FAR_I)^sfb(FAR_ID)) & 0xFFFF) == 0) || ( (sizeof(FAR_I)< 0x10000) && (((sfb(FAR_I)^sfe(FAR_I)) & 0xF0000) == 0) && (((sfb(FAR_I)^sfe(FAR_I)) & 0xF0000) == 0) ),1,1,"FAR_I and FAR_ID have same start address"\r
 390 \r
 391 \r
 392 \r
 393         ;         LIMIT   (sfb(FAR_I)^sfb(FAR_ID)) & 0xFFFF,0,0,"FAR_I and FAR_ID must start at the same offset into a 64k page"\r
 394         MOV     ES, #BYTE3(sfb(FAR_ID))\r
 395         MOVW    HL, #LWRD(sfb(FAR_ID))\r
 396         MOV     CS, #BYTE3(sizeof(FAR_ID))    ; CS is used as counter\r
 397         MOVW    AX, #LWRD(sizeof(FAR_ID))\r
 398         MOVW    BC, AX\r
 399         CMP0    C\r
 400         SKZ\r
 401         INC     B\r
 402         CMP0    B\r
 403         SKZ\r
 404         INC     CS                            ; counter\r
 405         MOV     A, #BYTE3(sfb(FAR_I))\r
 406         MOVW    DE, #LWRD(sfb(FAR_I))\r
 407         MOV     X, A\r
 408 loop:\r
 409         MOV     A, ES:[HL]\r
 410         XCH     A, X\r
 411         XCH     A, ES\r
 412         XCH     A, X\r
 413         MOV     ES:[DE], A\r
 414         XCH     A, X\r
 415         XCH     A, ES\r
 416         XCH     A, X\r
 417         INCW    HL\r
 418         MOV     A, H\r
 419         OR      A, L\r
 420         SKNZ\r
 421         INC     ES\r
 422         INCW    DE\r
 423         MOV     A, D\r
 424         OR      A, E\r
 425         SKNZ\r
 426         INC     X\r
 427         DEC     C\r
 428         BNZ     loop\r
 429         DEC     B\r
 430         BNZ     loop\r
 431         DEC     CS                            ; counter\r
 432         BNZ     loop\r
 433 \r
 434         ENDMOD\r
 435 #endif\r
 436 \r
 437 \r
 438 ;------------------------------------------------------------------------------\r
 439 ;       Segment initialization\r
 440 ;\r
 441 ;       NEAR_ID is copied to NEAR_I    "initialized near data"\r
 442 ;------------------------------------------------------------------------------\r
 443 \r
 444         MODULE  ?__INIT_NEAR_I\r
 445 \r
 446         RSEG    NEAR_I:DATA(0)\r
 447         RSEG    NEAR_ID:DATA(0)\r
 448         RSEG    RCODE:CODE:NOROOT(0)\r
 449 \r
 450         PUBLIC  __INIT_NEAR_I\r
 451 \r
 452 __INIT_NEAR_I:\r
 453 #if __CORE__ == __78K0R__\r
 454         LIMIT   sfb(NEAR_I)>=0xF0000,1,1,"NEAR_I not placed in near memory"\r
 455 #endif\r
 456         LIMIT   sizeof(NEAR_I)-sizeof(NEAR_ID),0,0,"NEAR_I and NEAR_ID not same size"\r
 457 #if __CORE__ == __78K0R__\r
 458         MOV     ES, #BYTE3(sfb(NEAR_ID))\r
 459 #endif\r
 460         MOVW    HL, #sfb(NEAR_ID)\r
 461         MOVW    BC, #sizeof(NEAR_ID)\r
 462 #if __CORE__ == __78K0R__\r
 463         CMP0    C\r
 464         SKZ\r
 465         INC     B\r
 466 #else\r
 467         MOV     A, C\r
 468         OR      A, A\r
 469         BZ      cont\r
 470         INC     B\r
 471 cont:\r
 472 #endif\r
 473         MOVW    DE, #sfb(NEAR_I)\r
 474 loop:\r
 475 #if __CORE__ != __78K0R__\r
 476         MOV     A, [HL]\r
 477 #else\r
 478         MOV     A, ES:[HL]\r
 479 #endif\r
 480         MOV     [DE], A\r
 481         INCW    HL\r
 482         INCW    DE\r
 483 #if __CORE__ == __78K0R__\r
 484         DEC     C\r
 485         BNZ     loop\r
 486         DEC     B\r
 487         BNZ     loop\r
 488 #else\r
 489         DBNZ    C, loop\r
 490         DBNZ    B, loop\r
 491 #endif\r
 492 \r
 493         ENDMOD\r
 494 \r
 495 \r
 496 ;------------------------------------------------------------------------------\r
 497 ;       Segment initialization\r
 498 ;\r
 499 ;       SADDR_ID is copied to SADDR_I  "initialized saddr data"\r
 500 ;------------------------------------------------------------------------------\r
 501 \r
 502         MODULE  ?__INIT_SADDR_I\r
 503 \r
 504         RSEG    SADDR_I:DATA(0)\r
 505         RSEG    SADDR_ID:DATA(0)\r
 506         RSEG    RCODE:CODE:NOROOT(0)\r
 507 \r
 508         PUBLIC  __INIT_SADDR_I\r
 509 \r
 510 __INIT_SADDR_I:\r
 511 #if __CORE__ == __78K0R__\r
 512         LIMIT   sfb(SADDR_I),0xFFE20,0xFFF1F,"SADDR_I not within saddr memory range"\r
 513         LIMIT   sfe(SADDR_I),0xFFE20,0xFFF1F,"SADDR_I not within saddr memory range"\r
 514 #else\r
 515         LIMIT   sfb(SADDR_I),0xFE20,0xFF1F,"SADDR_I not within saddr memory range"\r
 516         LIMIT   sfe(SADDR_I),0xFE20,0xFF1F,"SADDR_I not within saddr memory range"\r
 517 #endif\r
 518         LIMIT   sizeof(SADDR_I)-sizeof(SADDR_ID),0,0,"SADDR_I and SADDR_ID not same size"\r
 519 #if __CORE__ == __78K0R__\r
 520         MOV     ES, #BYTE3(sfb(SADDR_ID))\r
 521 #endif\r
 522         MOVW    HL, #sfb(SADDR_ID)\r
 523         MOV     B, #sizeof(SADDR_ID)\r
 524         MOVW    DE, #sfb(SADDR_I)\r
 525 loop:\r
 526 #if __CORE__ != __78K0R__\r
 527         MOV     A, [HL]\r
 528 #else\r
 529         MOV     A, ES:[HL]\r
 530 #endif\r
 531         MOV     [DE], A\r
 532         INCW    HL\r
 533         INCW    DE\r
 534 #if __CORE__ == __78K0R__\r
 535         DEC     B\r
 536         BNZ     loop\r
 537 #else\r
 538         DBNZ    B, loop\r
 539 #endif\r
 540 \r
 541         ENDMOD\r
 542 \r
 543 \r
 544 ;------------------------------------------------------------------------------\r
 545 ;       Initialize constructors\r
 546 ;\r
 547 ;       This segment part is required by the compiler when it is\r
 548 ;       necessary to call constructors of global objects.\r
 549 ;------------------------------------------------------------------------------\r
 550 \r
 551         MODULE  ?__INIT_CTORS\r
 552 \r
 553         RSEG    DIFUNCT(0)\r
 554         RSEG    RCODE:CODE:NOROOT(0)\r
 555 \r
 556         PUBLIC  __INIT_CTORS\r
 557 \r
 558         EXTERN  __call_ctors\r
 559 #if defined(__BANKED_MODEL__)\r
 560         EXTERN  ?FAR_CALL_L07\r
 561 #endif\r
 562 \r
 563 __INIT_CTORS:\r
 564 #if __CORE__ == __78K0R__\r
 565         MOV     X,  #byte3(sfe(DIFUNCT))\r
 566         PUSH    AX\r
 567         MOVW    AX, #lwrd(sfe(DIFUNCT))\r
 568         PUSH    AX\r
 569         MOV     X,  #byte3(sfb(DIFUNCT))\r
 570         PUSH    AX\r
 571         MOVW    AX, #lwrd(sfb(DIFUNCT))\r
 572         PUSH    AX\r
 573         CALL    F:__call_ctors\r
 574 #elif defined(__BANKED_MODEL__)\r
 575         MOVW    AX, #sfb(DIFUNCT)\r
 576         MOVW    BC, #sfe(DIFUNCT)\r
 577         MOV     E,  #byte3(__call_ctors)\r
 578         MOVW    HL, #lwrd(__call_ctors)\r
 579         CALL    ?FAR_CALL_L07\r
 580 #else\r
 581         MOVW    AX, #sfb(DIFUNCT)\r
 582         MOVW    BC, #sfe(DIFUNCT)\r
 583         CALL    __call_ctors\r
 584 #endif\r
 585 \r
 586         ENDMOD\r
 587 \r
 588 \r
 589 ;------------------------------------------------------------------------------\r
 590 ;       Enter main\r
 591 ;\r
 592 ;       Call the actual "main" function\r
 593 ;------------------------------------------------------------------------------\r
 594 \r
 595         MODULE  ?__MAIN_CALL\r
 596 \r
 597         RSEG    RCODE:CODE:NOROOT(0)\r
 598 \r
 599         PUBLIC  __MAIN_CALL\r
 600         PUBLIC  `@cend`             ; NEC debugger specific\r
 601 \r
 602         EXTERN  main\r
 603         EXTERN  exit\r
 604 #if defined(__BANKED_MODEL__)\r
 605         EXTERN  ?FAR_CALL_L07\r
 606 #endif\r
 607 \r
 608 __MAIN_CALL:\r
 609 #if defined(__FAR_MODEL__)\r
 610         CALL    F:main\r
 611         CALL    F:exit\r
 612 #elif defined(__BANKED_MODEL__)\r
 613         MOV     E,  #byte3(main)\r
 614         MOVW    HL, #lwrd(main)\r
 615         CALL    ?FAR_CALL_L07\r
 616 \r
 617         MOV     E,  #byte3(exit)\r
 618         MOVW    HL, #lwrd(exit)\r
 619         CALL    ?FAR_CALL_L07\r
 620 #else\r
 621         CALL    main\r
 622         CALL    exit\r
 623 #endif\r
 624 \r
 625 `@cend`:\r
 626 \r
 627 ;       STOP                            ; Should not return\r
 628 \r
 629         ENDMOD\r
 630 \r
 631 \r
 632 ;------------------------------------------------------------------------------\r
 633 ;       Low level initialization function\r
 634 ;\r
 635 ;       Entry:  __low_level_init\r
 636 ;\r
 637 ;       The only action of this default version of '__low_level_init' is to\r
 638 ;       return 1. By doing so it signals that normal initialization of data\r
 639 ;       segments should be done.\r
 640 ;\r
 641 ;       A customized version of '__low_level_init' may be created in order to\r
 642 ;       perform initialization before initializing segments and calling main\r
 643 ;       and/or to skip initialization of data segments under certain\r
 644 ;       circumstances.\r
 645 ;------------------------------------------------------------------------------\r
 646 \r
 647         MODULE  ?__low_level_init_stub\r
 648 \r
 649         RSEG    RCODE:CODE:NOROOT(0)\r
 650 \r
 651         PUBLIC  __low_level_init\r
 652 \r
 653 __low_level_init:                       ; By returning 1 this function\r
 654         MOVW    AX, #1                  ; indicates that the normal\r
 655         RET                             ; initialization should take place\r
 656 \r
 657         ENDMOD\r
 658 \r
 659         END\r