git.gag.com Git - fw/sdcc/blob - src/ds390/main.c

   1 /** @file main.c
   2     ds390 specific general functions.
   3
   4     Note that mlh prepended _ds390_ on the static functions.  Makes
   5     it easier to set a breakpoint using the debugger.
   6 */
   7 #include "common.h"
   8 #include "main.h"
   9 #include "ralloc.h"
  10 #include "gen.h"
  11 #include "BuildCmd.h"
  12 #include "MySystem.h"
  13 #include "../SDCCutil.h"
  14 #include "../SDCCglobl.h"
  15 static char _defaultRules[] =
  16 {
  17 #include "peeph.rul"
  18 };
  19
  20 /* list of key words used by msc51 */
  21 static char *_ds390_keywords[] =
  22 {
  23   "at",
  24   "bit",
  25   "code",
  26   "critical",
  27   "data",
  28   "far",
  29   "idata",
  30   "interrupt",
  31   "near",
  32   "pdata",
  33   "reentrant",
  34   "sfr",
  35   "sbit",
  36   "using",
  37   "xdata",
  38   "_data",
  39   "_code",
  40   "_generic",
  41   "_near",
  42   "_xdata",
  43   "_pdata",
  44   "_idata",
  45   "_naked",
  46   NULL
  47 };
  48
  49 static builtins __ds390_builtins[] = {
  50     { "__builtin_memcpy_x2x","v",3,{"cx*","cx*","i"}}, /* void __builtin_memcpy_x2x (xdata char *,xdata char *,int) */
  51     { "__builtin_memcpy_c2x","v",3,{"cx*","cp*","i"}}, /* void __builtin_memcpy_c2x (xdata char *,code  char *,int) */
  52     { "__builtin_memset_x","v",3,{"cx*","c","i"}},     /* void __builtin_memset     (xdata char *,char,int)         */
  53     /* __builtin_inp - used to read from a memory mapped port, increment first pointer */
  54     { "__builtin_inp","v",3,{"cx*","cx*","i"}},        /* void __builtin_inp        (xdata char *,xdata char *,int) */
  55     /* __builtin_inp - used to write to a memory mapped port, increment first pointer */
  56     { "__builtin_outp","v",3,{"cx*","cx*","i"}},       /* void __builtin_outp       (xdata char *,xdata char *,int) */
  57     { "__builtin_swapw","us",1,{"us"}},                /* unsigned short __builtin_swapw (unsigned short) */
  58     { "__builtin_memcmp_x2x","c",3,{"cx*","cx*","i"}}, /* void __builtin_memcmp_x2x (xdata char *,xdata char *,int) */
  59     { "__builtin_memcmp_c2x","c",3,{"cx*","cp*","i"}}, /* void __builtin_memcmp_c2x (xdata char *,code  char *,int) */
  60     { NULL , NULL,0, {NULL}}                       /* mark end of table */
  61 };
  62 void ds390_assignRegisters (eBBlock ** ebbs, int count);
  63
  64 static int regParmFlg = 0;      /* determine if we can register a parameter */
  65
  66 static void
  67 _ds390_init (void)
  68 {
  69   asm_addTree (&asm_asxxxx_mapping);
  70 }
  71
  72 static void
  73 _ds390_reset_regparm ()
  74 {
  75   regParmFlg = 0;
  76 }
  77
  78 static int
  79 _ds390_regparm (sym_link * l)
  80 {
  81
  82     if (options.parms_in_bank1 == 0) {
  83         /* simple can pass only the first parameter in a register */
  84         if (regParmFlg)
  85             return 0;
  86
  87         regParmFlg = 1;
  88         return 1;
  89     } else {
  90         int size = getSize(l);
  91         int remain ;
  92
  93         /* first one goes the usual way to DPTR */
  94         if (regParmFlg == 0) {
  95             regParmFlg += 4 ;
  96             return 1;
  97         }
  98         /* second one onwards goes to RB1_0 thru RB1_7 */
  99         remain = regParmFlg - 4;
 100         if (size > (8 - remain)) {
 101             regParmFlg = 12 ;
 102             return 0;
 103         }
 104         regParmFlg += size ;
 105         return regParmFlg - size + 1;
 106     }
 107 }
 108
 109 static bool
 110 _ds390_parseOptions (int *pargc, char **argv, int *i)
 111 {
 112   /* TODO: allow port-specific command line options to specify
 113    * segment names here.
 114    */
 115   return FALSE;
 116 }
 117
 118 static void
 119 _ds390_finaliseOptions (void)
 120 {
 121   if (options.noXinitOpt) {
 122     port->genXINIT=0;
 123   }
 124
 125   /* Hack-o-matic: if we are using the flat24 model,
 126    * adjust pointer sizes.
 127    */
 128   if (options.model != MODEL_FLAT24)  {
 129       fprintf (stderr,
 130                "*** warning: ds390 port small and large model experimental.\n");
 131       if (options.model == MODEL_LARGE)
 132       {
 133         port->mem.default_local_map = xdata;
 134         port->mem.default_globl_map = xdata;
 135       }
 136       else
 137       {
 138         port->mem.default_local_map = data;
 139         port->mem.default_globl_map = data;
 140       }
 141   }
 142   else {
 143     port->s.fptr_size = 3;
 144     port->s.gptr_size = 4;
 145
 146     port->stack.isr_overhead += 2;      /* Will save dpx on ISR entry. */
 147
 148     port->stack.call_overhead += 2;     /* This acounts for the extra byte
 149                                  * of return addres on the stack.
 150                                  * but is ugly. There must be a
 151                                  * better way.
 152                                  */
 153
 154     port->mem.default_local_map = xdata;
 155     port->mem.default_globl_map = xdata;
 156
 157     if (!options.stack10bit)
 158     {
 159     fprintf (stderr,
 160              "*** error: ds390 port only supports the 10 bit stack mode.\n");
 161     } else {
 162         if (!options.stack_loc) options.stack_loc = 0x400008;
 163     }
 164
 165     /* generate native code 16*16 mul/div */
 166     if (options.useAccelerator)
 167             port->support.muldiv=2;
 168     else
 169             port->support.muldiv=1;
 170
 171      /* Fixup the memory map for the stack; it is now in
 172      * far space and requires a FPOINTER to access it.
 173      */
 174     istack->fmap = 1;
 175     istack->ptrType = FPOINTER;
 176
 177     if (options.parms_in_bank1) {
 178         addSet(&preArgvSet, Safe_strdup("-DSDCC_PARMS_IN_BANK1"));
 179     }
 180   }  /* MODEL_FLAT24 */
 181 }
 182
 183 static void
 184 _ds390_setDefaultOptions (void)
 185 {
 186   options.model=MODEL_FLAT24;
 187   options.stack10bit=1;
 188 }
 189
 190 static const char *
 191 _ds390_getRegName (struct regs *reg)
 192 {
 193   if (reg)
 194     return reg->name;
 195   return "err";
 196 }
 197
 198 static void
 199 _ds390_genAssemblerPreamble (FILE * of)
 200 {
 201       if (options.model == MODEL_FLAT24)
 202         fputs (".flat24 on\t\t; 24 bit flat addressing\n", of);
 203
 204       fputs ("dpx = 0x93\t\t; dpx register unknown to assembler\n", of);
 205       fputs ("dps = 0x86\t\t; dps register unknown to assembler\n", of);
 206       fputs ("dpl1 = 0x84\t\t; dpl1 register unknown to assembler\n", of);
 207       fputs ("dph1 = 0x85\t\t; dph1 register unknown to assembler\n", of);
 208       fputs ("dpx1 = 0x95\t\t; dpx1 register unknown to assembler\n", of);
 209       fputs ("ap = 0x9C\t\t; ap register unknown to assembler\n", of);
 210       fputs ("_ap = 0x9C\t\t; _ap register unknown to assembler\n", of);
 211       fputs ("mcnt0 = 0xD1\t\t; mcnt0 register unknown to assembler\n", of);
 212       fputs ("mcnt1 = 0xD2\t\t; mcnt1 register unknown to assembler\n", of);
 213       fputs ("ma = 0xD3\t\t; ma register unknown to assembler\n", of);
 214       fputs ("mb = 0xD4\t\t; mb register unknown to assembler\n", of);
 215       fputs ("mc = 0xD5\t\t; mc register unknown to assembler\n", of);
 216       fputs ("F1 = 0xD1\t\t; F1 user flag unknown to assembler\n", of);
 217       fputs ("esp = 0x9B\t\t; ESP user flag unknown to assembler\n", of);
 218       if (options.parms_in_bank1) {
 219           int i ;
 220           for (i=0; i < 8 ; i++ )
 221               fprintf (of,"b1_%d = 0x%x \n",i,8+i);
 222       }
 223 }
 224
 225 /* Generate interrupt vector table. */
 226 static int
 227 _ds390_genIVT (FILE * of, symbol ** interrupts, int maxInterrupts)
 228 {
 229   int i;
 230
 231   if (options.model != MODEL_FLAT24)
 232     {
 233       /* Let the default code handle it. */
 234       return FALSE;
 235     }
 236
 237   fprintf (of, "\tajmp\t__reset_vect\n");
 238
 239   /* now for the other interrupts */
 240   for (i = 0; i < maxInterrupts; i++)
 241     {
 242       if (interrupts[i])
 243         {
 244           fprintf (of, "\tljmp\t%s\n\t.ds\t4\n", interrupts[i]->rname);
 245         }
 246       else
 247         {
 248           fprintf (of, "\treti\n\t.ds\t7\n");
 249         }
 250     }
 251
 252   fprintf (of, "__reset_vect:\n\tljmp\t__sdcc_gsinit_startup\n");
 253
 254   return TRUE;
 255 }
 256
 257 /* Generate code to copy XINIT to XISEG */
 258 static void _ds390_genXINIT (FILE * of) {
 259   fprintf (of, ";       _ds390_genXINIT() start\n");
 260   fprintf (of, "        mov     a,#l_XINIT\n");
 261   fprintf (of, "        orl     a,#l_XINIT>>8\n");
 262   fprintf (of, "        jz      00003$\n");
 263   fprintf (of, "        mov     a,#s_XINIT\n");
 264   fprintf (of, "        add     a,#l_XINIT\n");
 265   fprintf (of, "        mov     r1,a\n");
 266   fprintf (of, "        mov     a,#s_XINIT>>8\n");
 267   fprintf (of, "        addc    a,#l_XINIT>>8\n");
 268   fprintf (of, "        mov     r2,a\n");
 269   fprintf (of, "        mov     dptr,#s_XINIT\n");
 270   fprintf (of, "        mov     dps,#0x21\n");
 271   fprintf (of, "        mov     dptr,#s_XISEG\n");
 272   fprintf (of, "00001$: clr     a\n");
 273   fprintf (of, "        movc    a,@a+dptr\n");
 274   fprintf (of, "        movx    @dptr,a\n");
 275   fprintf (of, "        inc     dptr\n");
 276   fprintf (of, "        inc     dptr\n");
 277   fprintf (of, "00002$: mov     a,dpl\n");
 278   fprintf (of, "        cjne    a,ar1,00001$\n");
 279   fprintf (of, "        mov     a,dph\n");
 280   fprintf (of, "        cjne    a,ar2,00001$\n");
 281   fprintf (of, "        mov     dps,#0\n");
 282   fprintf (of, "00003$:\n");
 283   fprintf (of, ";       _ds390_genXINIT() end\n");
 284 }
 285
 286 /* Do CSE estimation */
 287 static bool cseCostEstimation (iCode *ic, iCode *pdic)
 288 {
 289     operand *result = IC_RESULT(ic);
 290     //operand *right  = IC_RIGHT(ic);
 291     //operand *left   = IC_LEFT(ic);
 292     sym_link *result_type = operandType(result);
 293     //sym_link *right_type  = (right ? operandType(right) : 0);
 294     //sym_link *left_type   = (left  ? operandType(left)  : 0);
 295
 296     /* if it is a pointer then return ok for now */
 297     if (IC_RESULT(ic) && IS_PTR(result_type)) return 1;
 298
 299     /* if bitwise | add & subtract then no since mcs51 is pretty good at it
 300        so we will cse only if they are local (i.e. both ic & pdic belong to
 301        the same basic block */
 302     if (IS_BITWISE_OP(ic) || ic->op == '+' || ic->op == '-') {
 303         /* then if they are the same Basic block then ok */
 304         if (ic->eBBlockNum == pdic->eBBlockNum) return 1;
 305         else return 0;
 306     }
 307
 308     /* for others it is cheaper to do the cse */
 309     return 1;
 310 }
 311
 312 bool _ds390_nativeMulCheck(iCode *ic, sym_link *left, sym_link *right)
 313 {
 314     return FALSE; // #STUB
 315 }
 316
 317 /* Indicate which extended bit operations this port supports */
 318 static bool
 319 hasExtBitOp (int op, int size)
 320 {
 321   if (op == RRC
 322       || op == RLC
 323       || op == GETHBIT
 324       || (op == SWAP && size <= 2)
 325      )
 326     return TRUE;
 327   else
 328     return FALSE;
 329 }
 330
 331 /* Indicate the expense of an access to an output storage class */
 332 static int
 333 oclsExpense (struct memmap *oclass)
 334 {
 335   if (IN_FARSPACE(oclass))
 336     return 1;
 337
 338   return 0;
 339 }
 340
 341
 342 /** $1 is always the basename.
 343     $2 is always the output file.
 344     $3 varies
 345     $l is the list of extra options that should be there somewhere...
 346     MUST be terminated with a NULL.
 347 */
 348 static const char *_linkCmd[] =
 349 {
 350   "aslink", "-nf", "\"$1\"", NULL
 351 };
 352
 353 /* $3 is replaced by assembler.debug_opts resp. port->assembler.plain_opts */   static const char *_asmCmd[] =
 354 {
 355   "asx8051", "$l", "$3", "\"$1.asm\"", NULL
 356 };
 357
 358 /* Globals */
 359 PORT ds390_port =
 360 {
 361   TARGET_ID_DS390,
 362   "ds390",
 363   "DS80C390",                   /* Target name */
 364   NULL,
 365   {
 366     glue,
 367     TRUE,                       /* Emit glue around main */
 368     MODEL_SMALL | MODEL_LARGE | MODEL_FLAT24,
 369     MODEL_SMALL
 370   },
 371   {
 372     _asmCmd,
 373     NULL,
 374     "-plosgffc",                /* Options with debug */
 375     "-plosgff",                 /* Options without debug */
 376     0,
 377     ".asm",
 378     NULL                        /* no do_assemble function */
 379   },
 380   {
 381     _linkCmd,
 382     NULL,
 383     NULL,
 384     ".rel",
 385     1
 386   },
 387   {
 388     _defaultRules
 389   },
 390   {
 391         /* Sizes: char, short, int, long, ptr, fptr, gptr, bit, float, max */
 392     1, 2, 2, 4, 1, 2, 3, 1, 4, 4
 393   },
 394   {
 395     "XSEG    (XDATA)",
 396     "STACK   (DATA)",
 397     "CSEG    (CODE)",
 398     "DSEG    (DATA)",
 399     "ISEG    (DATA)",
 400     "XSEG    (XDATA)",
 401     "BSEG    (BIT)",
 402     "RSEG    (DATA)",
 403     "GSINIT  (CODE)",
 404     "OSEG    (OVR,DATA)",
 405     "GSFINAL (CODE)",
 406     "HOME    (CODE)",
 407     "XISEG   (XDATA)", // initialized xdata
 408     "XINIT   (CODE)", // a code copy of xiseg
 409     NULL,
 410     NULL,
 411     1
 412   },
 413   { NULL, NULL },
 414   {
 415     +1, 1, 4, 1, 1, 0
 416   },
 417     /* ds390 has an 16 bit mul & div */
 418   {
 419     2, -1
 420   },
 421   "_",
 422   _ds390_init,
 423   _ds390_parseOptions,
 424   NULL,
 425   _ds390_finaliseOptions,
 426   _ds390_setDefaultOptions,
 427   ds390_assignRegisters,
 428   _ds390_getRegName,
 429   _ds390_keywords,
 430   _ds390_genAssemblerPreamble,
 431   NULL,                         /* no genAssemblerEnd */
 432   _ds390_genIVT,
 433   _ds390_genXINIT,
 434   _ds390_reset_regparm,
 435   _ds390_regparm,
 436   NULL,
 437   NULL,
 438   _ds390_nativeMulCheck,
 439   hasExtBitOp,                  /* hasExtBitOp */
 440   oclsExpense,                  /* oclsExpense */
 441   FALSE,
 442   TRUE,                         /* little endian */
 443   0,                            /* leave lt */
 444   0,                            /* leave gt */
 445   1,                            /* transform <= to ! > */
 446   1,                            /* transform >= to ! < */
 447   1,                            /* transform != to !(a == b) */
 448   0,                            /* leave == */
 449 #if 0 // obsolete, and buggy for != xdata
 450   TRUE,                         /* we support array initializers. */
 451 #else
 452   FALSE,                        /* No array initializer support. */
 453 #endif
 454   cseCostEstimation,
 455   __ds390_builtins,             /* table of builtin functions */
 456   GPOINTER,                     /* treat unqualified pointers as "generic" pointers */
 457   1,                            /* reset labelKey to 1 */
 458   1,                            /* globals & local static allowed */
 459   PORT_MAGIC
 460 };
 461
 462 /*---------------------------------------------------------------------------------*/
 463 /*                               TININative specific                               */
 464 /*---------------------------------------------------------------------------------*/
 465 /* Globals */
 466 static void _tininative_init (void)
 467 {
 468     asm_addTree (&asm_a390_mapping);
 469 }
 470
 471 static void _tininative_setDefaultOptions (void)
 472 {
 473     options.model=MODEL_FLAT24;
 474     options.stack10bit=1;
 475     options.stackAuto = 1;
 476 }
 477
 478 static void _tininative_finaliseOptions (void)
 479 {
 480     /* Hack-o-matic: if we are using the flat24 model,
 481      * adjust pointer sizes.
 482      */
 483     if (options.model != MODEL_FLAT24)  {
 484         options.model = MODEL_FLAT24 ;
 485         fprintf(stderr,"TININative supports only MODEL FLAT24\n");
 486     }
 487     port->s.fptr_size = 3;
 488     port->s.gptr_size = 4;
 489
 490     port->stack.isr_overhead += 2;      /* Will save dpx on ISR entry. */
 491
 492     port->stack.call_overhead += 2;     /* This acounts for the extra byte
 493                                          * of return addres on the stack.
 494                                          * but is ugly. There must be a
 495                                          * better way.
 496                                          */
 497
 498     port->mem.default_local_map = xdata;
 499     port->mem.default_globl_map = xdata;
 500
 501     if (!options.stack10bit) {
 502         options.stack10bit = 1;
 503         fprintf(stderr,"TININative supports only stack10bit \n");
 504     }
 505
 506     if (!options.stack_loc) options.stack_loc = 0x400008;
 507
 508     /* generate native code 16*16 mul/div */
 509     if (options.useAccelerator)
 510         port->support.muldiv=2;
 511     else
 512         port->support.muldiv=1;
 513
 514     /* Fixup the memory map for the stack; it is now in
 515      * far space and requires a FPOINTER to access it.
 516      */
 517     istack->fmap = 1;
 518     istack->ptrType = FPOINTER;
 519     options.cc_only =1;
 520 }
 521
 522 static int _tininative_genIVT (FILE * of, symbol ** interrupts, int maxInterrupts)
 523 {
 524     return 1;
 525 }
 526 static void _tininative_genAssemblerPreamble (FILE * of)
 527 {
 528     fputs("$include(tini.inc)\n", of);
 529     fputs("$include(ds80c390.inc)\n", of);
 530     fputs("$include(tinimacro.inc)\n", of);
 531     fputs("$include(apiequ.inc)\n", of);
 532     fputs("_bpx EQU 01Eh \t\t; _bpx (frame pointer) mapped to R8_B3:R7_B3\n", of);
 533     fputs("_ap  EQU 01Dh \t\t; _ap mapped to R6_B3\n", of);
 534     /* Must be first and return 0 */
 535     fputs("Lib_Native_Init:\n",of);
 536     fputs("\tclr\ta\n",of);
 537     fputs("\tret\n",of);
 538     fputs("LibraryID:\n",of);
 539     fputs("\tdb \"DS\"\n",of);
 540     if (options.tini_libid) {
 541         fprintf(of,"\tdb 0,0,0%02xh,0%02xh,0%02xh,0%02xh\n",
 542                 (options.tini_libid>>24 & 0xff),
 543                 (options.tini_libid>>16 & 0xff),
 544                 (options.tini_libid>>8 & 0xff),
 545                 (options.tini_libid  & 0xff));
 546     } else {
 547         fprintf(of,"\tdb 0,0,0,0,0,1\n");
 548     }
 549
 550 }
 551 static void _tininative_genAssemblerEnd (FILE * of)
 552 {
 553     fputs("\tend\n",of);
 554 }
 555 /* tininative assembler , calls "macro", if it succeeds calls "a390" */
 556 static void _tininative_do_assemble (set *asmOptions)
 557 {
 558     static const char *macroCmd[] = {
 559         "macro","$1.a51",NULL
 560     };
 561     static const char *a390Cmd[] = {
 562         "a390","$1.mpp",NULL
 563     };
 564     char buffer[100];
 565
 566     buildCmdLine(buffer,macroCmd,dstFileName,NULL,NULL,NULL);
 567     if (my_system(buffer)) {
 568         exit(1);
 569     }
 570     buildCmdLine(buffer,a390Cmd,dstFileName,NULL,NULL,asmOptions);
 571     if (my_system(buffer)) {
 572         exit(1);
 573     }
 574 }
 575
 576 /* list of key words used by TININative */
 577 static char *_tininative_keywords[] =
 578 {
 579   "at",
 580   "bit",
 581   "code",
 582   "critical",
 583   "data",
 584   "far",
 585   "idata",
 586   "interrupt",
 587   "near",
 588   "pdata",
 589   "reentrant",
 590   "sfr",
 591   "sbit",
 592   "using",
 593   "xdata",
 594   "_data",
 595   "_code",
 596   "_generic",
 597   "_near",
 598   "_xdata",
 599   "_pdata",
 600   "_idata",
 601   "_naked",
 602   "_JavaNative",
 603   NULL
 604 };
 605
 606 static builtins __tininative_builtins[] = {
 607     { "__builtin_memcpy_x2x","v",3,{"cx*","cx*","i"}}, /* void __builtin_memcpy_x2x (xdata char *,xdata char *,int) */
 608     { "__builtin_memcpy_c2x","v",3,{"cx*","cp*","i"}}, /* void __builtin_memcpy_c2x (xdata char *,code  char *,int) */
 609     { "__builtin_memset_x","v",3,{"cx*","c","i"}},     /* void __builtin_memset     (xdata char *,char,int)         */
 610     /* TINI NatLib */
 611     { "NatLib_LoadByte","c",1,{"c"}},                  /* char  Natlib_LoadByte  (0 based parameter number)         */
 612     { "NatLib_LoadShort","s",1,{"c"}},                 /* short Natlib_LoadShort (0 based parameter number)         */
 613     { "NatLib_LoadInt","l",1,{"c"}},                   /* long  Natlib_LoadLong  (0 based parameter number)         */
 614     { "NatLib_LoadPointer","cx*",1,{"c"}},             /* long  Natlib_LoadPointer  (0 based parameter number)      */
 615     /* TINI StateBlock related */
 616     { "NatLib_InstallImmutableStateBlock","c",2,{"vx*","us"}},/* char NatLib_InstallImmutableStateBlock(state block *,int handle) */
 617     { "NatLib_InstallEphemeralStateBlock","c",2,{"vx*","us"}},/* char NatLib_InstallEphemeralStateBlock(state block *,int handle) */
 618     { "NatLib_RemoveImmutableStateBlock","v",0,{NULL}},/* void NatLib_RemoveImmutableStateBlock() */
 619     { "NatLib_RemoveEphemeralStateBlock","v",0,{NULL}},/* void NatLib_RemoveEphemeralStateBlock() */
 620     { "NatLib_GetImmutableStateBlock","i",0,{NULL}},   /* int  NatLib_GetImmutableStateBlock () */
 621     { "NatLib_GetEphemeralStateBlock","i",0,{NULL}},   /* int  NatLib_GetEphemeralStateBlock () */
 622     /* Memory manager */
 623     { "MM_XMalloc","i",1,{"l"}},                       /* int  MM_XMalloc (long)                */
 624     { "MM_Malloc","i",1,{"i"}},                        /* int  MM_Malloc  (int)                 */
 625     { "MM_ApplicationMalloc","i",1,{"i"}},             /* int  MM_ApplicationMalloc  (int)      */
 626     { "MM_Free","i",1,{"i"}},                          /* int  MM_Free  (int)                   */
 627     { "MM_Deref","cx*",1,{"i"}},                       /* char *MM_Free  (int)                  */
 628     { "MM_UnrestrictedPersist","c",1,{"i"}},           /* char  MM_UnrestrictedPersist  (int)   */
 629     /* System functions */
 630     { "System_ExecJavaProcess","c",2,{"cx*","i"}},     /* char System_ExecJavaProcess (char *,int) */
 631     { "System_GetRTCRegisters","v",1,{"cx*"}},         /* void System_GetRTCRegisters (char *) */
 632     { "System_SetRTCRegisters","v",1,{"cx*"}},         /* void System_SetRTCRegisters (char *) */
 633     { "System_ThreadSleep","v",2,{"l","c"}},           /* void System_ThreadSleep (long,char)  */
 634     { "System_ThreadSleep_ExitCriticalSection","v",2,{"l","c"}},/* void System_ThreadSleep_ExitCriticalSection (long,char)  */
 635     { "System_ProcessSleep","v",2,{"l","c"}},           /* void System_ProcessSleep (long,char)  */
 636     { "System_ProcessSleep_ExitCriticalSection","v",2,{"l","c"}},/* void System_ProcessSleep_ExitCriticalSection (long,char)  */
 637     { "System_ThreadResume","c",2,{"c","c"}},          /* char System_ThreadResume(char,char)  */
 638     { "System_SaveJavaThreadState","v",0,{NULL}},      /* void System_SaveJavaThreadState()    */
 639     { "System_RestoreJavaThreadState","v",0,{NULL}},   /* void System_RestoreJavaThreadState() */
 640     { "System_ProcessYield","v",0,{NULL}},             /* void System_ProcessYield() */
 641     { "System_ProcessSuspend","v",0,{NULL}},           /* void System_ProcessSuspend() */
 642     { "System_ProcessResume","v",1,{"c"}},             /* void System_ProcessResume(char) */
 643     { "System_RegisterPoll","c",1,{"vF*"}},            /* char System_RegisterPoll ((void *func pointer)()) */
 644     { "System_RemovePoll","c",1,{"vF*"}},              /* char System_RemovePoll ((void *func pointer)()) */
 645     { "System_GetCurrentProcessId","c",0,{NULL}},      /* char System_GetCurrentProcessId() */
 646     { "System_GetCurrentThreadId","c",0,{NULL}},       /* char System_GetCurrentThreadId() */
 647     { NULL , NULL,0, {NULL}}                       /* mark end of table */
 648 };
 649
 650 static const char *_a390Cmd[] =
 651 {
 652   "macro", "$l", "$3", "$1.a51", NULL
 653 };
 654 PORT tininative_port =
 655 {
 656   TARGET_ID_DS390,
 657   "TININative",
 658   "DS80C390",                   /* Target name */
 659         NULL,                   /* processor */
 660   {
 661     glue,
 662     FALSE,                      /* Emit glue around main */
 663     MODEL_FLAT24,
 664     MODEL_FLAT24
 665   },
 666   {
 667     _a390Cmd,
 668     NULL,
 669     "-l",               /* Options with debug */
 670     "-l",               /* Options without debug */
 671     0,
 672     ".a51",
 673     _tininative_do_assemble
 674   },
 675   {
 676     NULL,
 677     NULL,
 678     NULL,
 679     ".tlib",
 680     1
 681   },
 682   {
 683     _defaultRules
 684   },
 685   {
 686         /* Sizes: char, short, int, long, ptr, fptr, gptr, bit, float, max */
 687     1, 2, 2, 4, 1, 3, 3, 1, 4, 4
 688   },
 689   {
 690     "XSEG    (XDATA)",
 691     "STACK   (DATA)",
 692     "CSEG    (CODE)",
 693     "DSEG    (DATA)",
 694     "ISEG    (DATA)",
 695     "XSEG    (XDATA)",
 696     "BSEG    (BIT)",
 697     "RSEG    (DATA)",
 698     "GSINIT  (CODE)",
 699     "OSEG    (OVR,DATA)",
 700     "GSFINAL (CODE)",
 701     "HOME        (CODE)",
 702     NULL,
 703     NULL,
 704     NULL,
 705     NULL,
 706     1
 707   },
 708   { NULL, NULL },
 709   {
 710     +1, 1, 4, 1, 1, 0
 711   },
 712     /* ds390 has an 16 bit mul & div */
 713   {
 714     2, -1
 715   },
 716   "",
 717   _tininative_init,
 718   _ds390_parseOptions,
 719   NULL,
 720   _tininative_finaliseOptions,
 721   _tininative_setDefaultOptions,
 722   ds390_assignRegisters,
 723   _ds390_getRegName,
 724   _tininative_keywords,
 725   _tininative_genAssemblerPreamble,
 726   _tininative_genAssemblerEnd,
 727   _tininative_genIVT,
 728   NULL,
 729   _ds390_reset_regparm,
 730   _ds390_regparm,
 731   NULL,
 732   NULL,
 733   NULL,
 734   hasExtBitOp,                  /* hasExtBitOp */
 735   oclsExpense,                  /* oclsExpense */
 736   FALSE,
 737   TRUE,                         /* little endian */
 738   0,                            /* leave lt */
 739   0,                            /* leave gt */
 740   1,                            /* transform <= to ! > */
 741   1,                            /* transform >= to ! < */
 742   1,                            /* transform != to !(a == b) */
 743   0,                            /* leave == */
 744   TRUE,                         /* we support array initializers. */
 745   cseCostEstimation,
 746   __tininative_builtins,        /* table of builtin functions */
 747   FPOINTER,                     /* treat unqualified pointers as far pointers */
 748   0,                            /* DONOT reset labelKey */
 749   0,                            /* globals & local static NOT allowed */
 750   PORT_MAGIC
 751 };
 752
 753 static int
 754 _ds400_genIVT (FILE * of, symbol ** interrupts, int maxInterrupts)
 755 {
 756     /* We can't generate a static IVT, since the boot rom creates one
 757      * for us in rom_init.
 758      *
 759      * we must patch it as part of the C startup.
 760      */
 761      fprintf (of, ";\tDS80C400 IVT must be generated at runtime.\n");
 762     fprintf (of, "\tsjmp\t__sdcc_400boot\n");
 763     fprintf (of, "\t.ascii\t'TINI'\t; required signature for 400 boot loader.\n");
 764     fprintf (of, "\t.db\t0\t; selected bank: zero *should* work...\n");
 765     fprintf (of, "\t__sdcc_400boot:\tljmp\t__sdcc_gsinit_startup\n");
 766      return TRUE;
 767 }
 768
 769
 770
 771 static void
 772 _ds400_finaliseOptions (void)
 773 {
 774   if (options.noXinitOpt) {
 775     port->genXINIT=0;
 776   }
 777
 778   // hackhack: we're a superset of the 390.
 779   addSet(&preArgvSet, Safe_strdup("-DSDCC_ds390"));
 780   addSet(&preArgvSet, Safe_strdup("-D__ds390"));
 781
 782   /* Hack-o-matic: if we are using the flat24 model,
 783    * adjust pointer sizes.
 784    */
 785   if (options.model != MODEL_FLAT24)  {
 786       fprintf (stderr,
 787                "*** warning: ds400 port small and large model experimental.\n");
 788       if (options.model == MODEL_LARGE)
 789       {
 790         port->mem.default_local_map = xdata;
 791         port->mem.default_globl_map = xdata;
 792       }
 793       else
 794       {
 795         port->mem.default_local_map = data;
 796         port->mem.default_globl_map = data;
 797       }
 798   }
 799   else {
 800     port->s.fptr_size = 3;
 801     port->s.gptr_size = 4;
 802
 803     port->stack.isr_overhead += 2;      /* Will save dpx on ISR entry. */
 804
 805     port->stack.call_overhead += 2;     /* This acounts for the extra byte
 806                                  * of return addres on the stack.
 807                                  * but is ugly. There must be a
 808                                  * better way.
 809                                  */
 810
 811     port->mem.default_local_map = xdata;
 812     port->mem.default_globl_map = xdata;
 813
 814     if (!options.stack10bit)
 815     {
 816     fprintf (stderr,
 817              "*** error: ds400 port only supports the 10 bit stack mode.\n");
 818     } else {
 819         if (!options.stack_loc) options.stack_loc = 0xffdc00;
 820         // assumes IDM1:0 = 1:0, CMA = 1.
 821     }
 822
 823     /* generate native code 16*16 mul/div */
 824     if (options.useAccelerator)
 825             port->support.muldiv=2;
 826     else
 827             port->support.muldiv=1;
 828
 829      /* Fixup the memory map for the stack; it is now in
 830      * far space and requires a FPOINTER to access it.
 831      */
 832     istack->fmap = 1;
 833     istack->ptrType = FPOINTER;
 834
 835     if (options.parms_in_bank1) {
 836         addSet(&preArgvSet, Safe_strdup("-DSDCC_PARMS_IN_BANK1"));
 837     }
 838
 839     // the DS400 rom calling interface uses register bank 3.
 840     RegBankUsed[3] = 1;
 841
 842   }  /* MODEL_FLAT24 */
 843 }
 844
 845 extern char * iComments2;
 846
 847 static void _ds400_generateRomDataArea(FILE *fp, bool isMain)
 848 {
 849     /* Only do this for the file containing main() */
 850     if (isMain)
 851     {
 852         fprintf(fp, "%s", iComments2);
 853         fprintf(fp, "; the direct data area used by the DS80c400 ROM code.\n");
 854         fprintf(fp, "%s", iComments2);
 855         fprintf(fp, ".area ROMSEG (ABS,CON,DATA)\n\n");
 856         fprintf(fp, ".ds 24 ; 24 bytes of directs used starting at 0x68\n\n");
 857     }
 858 }
 859
 860 static void _ds400_linkRomDataArea(FILE *fp)
 861 {
 862     fprintf(fp, "-b ROMSEG = 0x0068\n");
 863 }
 864
 865
 866 PORT ds400_port =
 867 {
 868   TARGET_ID_DS400,
 869   "ds400",
 870   "DS80C400",                   /* Target name */
 871   NULL,
 872   {
 873     glue,
 874     TRUE,                       /* Emit glue around main */
 875     MODEL_SMALL | MODEL_LARGE | MODEL_FLAT24,
 876     MODEL_SMALL
 877   },
 878   {
 879     _asmCmd,
 880     NULL,
 881     "-plosgffc",                /* Options with debug */
 882     "-plosgff",                 /* Options without debug */
 883     0,
 884     ".asm",
 885     NULL                        /* no do_assemble function */
 886   },
 887   {
 888     _linkCmd,
 889     NULL,
 890     NULL,
 891     ".rel",
 892     1
 893   },
 894   {
 895     _defaultRules
 896   },
 897   {
 898         /* Sizes: char, short, int, long, ptr, fptr, gptr, bit, float, max */
 899     1, 2, 2, 4, 1, 2, 3, 1, 4, 4
 900   },
 901   {
 902     "XSEG    (XDATA)",
 903     "STACK   (DATA)",
 904     "CSEG    (CODE)",
 905     "DSEG    (DATA)",
 906     "ISEG    (DATA)",
 907     "XSEG    (XDATA)",
 908     "BSEG    (BIT)",
 909     "RSEG    (DATA)",
 910     "GSINIT  (CODE)",
 911     "OSEG    (OVR,DATA)",
 912     "GSFINAL (CODE)",
 913     "HOME    (CODE)",
 914     "XISEG   (XDATA)", // initialized xdata
 915     "XINIT   (CODE)", // a code copy of xiseg
 916     NULL,
 917     NULL,
 918     1
 919   },
 920   { _ds400_generateRomDataArea, _ds400_linkRomDataArea },
 921   {
 922     +1, 1, 4, 1, 1, 0
 923   },
 924     /* ds390 has an 16 bit mul & div */
 925   {
 926     2, -1
 927   },
 928   "_",
 929   _ds390_init,
 930   _ds390_parseOptions,
 931   NULL,
 932   _ds400_finaliseOptions,
 933   _ds390_setDefaultOptions,
 934   ds390_assignRegisters,
 935   _ds390_getRegName,
 936   _ds390_keywords,
 937   _ds390_genAssemblerPreamble,
 938   NULL,                         /* no genAssemblerEnd */
 939   _ds400_genIVT,
 940   _ds390_genXINIT,
 941   _ds390_reset_regparm,
 942   _ds390_regparm,
 943   NULL,
 944   NULL,
 945   _ds390_nativeMulCheck,
 946   hasExtBitOp,                  /* hasExtBitOp */
 947   oclsExpense,                  /* oclsExpense */
 948   FALSE,
 949   TRUE,                         /* little endian */
 950   0,                            /* leave lt */
 951   0,                            /* leave gt */
 952   1,                            /* transform <= to ! > */
 953   1,                            /* transform >= to ! < */
 954   1,                            /* transform != to !(a == b) */
 955   0,                            /* leave == */
 956   TRUE,                         /* we support array initializers. */
 957   cseCostEstimation,
 958   __ds390_builtins,             /* table of builtin functions */
 959   GPOINTER,                     /* treat unqualified pointers as "generic" pointers */
 960   1,                            /* reset labelKey to 1 */
 961   1,                            /* globals & local static allowed */
 962   PORT_MAGIC
 963 };