virtualization of glue() function: each port has it's own glue function,
[fw/sdcc] / 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
318 /** $1 is always the basename.
319     $2 is always the output file.
320     $3 varies
321     $l is the list of extra options that should be there somewhere...
322     MUST be terminated with a NULL.
323 */
324 static const char *_linkCmd[] =
325 {
326   "aslink", "-nf", "\"$1\"", NULL
327 };
328
329 /* $3 is replaced by assembler.debug_opts resp. port->assembler.plain_opts */   static const char *_asmCmd[] =
330 {
331   "asx8051", "$l", "$3", "\"$1.asm\"", NULL
332 };
333
334 /* Globals */
335 PORT ds390_port =
336 {
337   TARGET_ID_DS390,
338   "ds390",
339   "DS80C390",                   /* Target name */
340   NULL,
341   {
342     glue,
343     TRUE,                       /* Emit glue around main */
344     MODEL_SMALL | MODEL_LARGE | MODEL_FLAT24,
345     MODEL_SMALL
346   },
347   {
348     _asmCmd,
349     NULL,
350     "-plosgffc",                /* Options with debug */
351     "-plosgff",                 /* Options without debug */
352     0,
353     ".asm",
354     NULL                        /* no do_assemble function */
355   },
356   {
357     _linkCmd,
358     NULL,
359     NULL,
360     ".rel"
361   },
362   {
363     _defaultRules
364   },
365   {
366         /* Sizes: char, short, int, long, ptr, fptr, gptr, bit, float, max */
367     1, 2, 2, 4, 1, 2, 3, 1, 4, 4
368   },
369   {
370     "XSEG    (XDATA)",
371     "STACK   (DATA)",
372     "CSEG    (CODE)",
373     "DSEG    (DATA)",
374     "ISEG    (DATA)",
375     "XSEG    (XDATA)",
376     "BSEG    (BIT)",
377     "RSEG    (DATA)",
378     "GSINIT  (CODE)",
379     "OSEG    (OVR,DATA)",
380     "GSFINAL (CODE)",
381     "HOME    (CODE)",
382     "XISEG   (XDATA)", // initialized xdata
383     "XINIT   (CODE)", // a code copy of xiseg
384     NULL,
385     NULL,
386     1
387   },
388   { NULL, NULL },
389   {
390     +1, 1, 4, 1, 1, 0
391   },
392     /* ds390 has an 16 bit mul & div */
393   {
394     2, -1
395   },
396   "_",
397   _ds390_init,
398   _ds390_parseOptions,
399   NULL,
400   _ds390_finaliseOptions,
401   _ds390_setDefaultOptions,
402   ds390_assignRegisters,
403   _ds390_getRegName,
404   _ds390_keywords,
405   _ds390_genAssemblerPreamble,
406   NULL,                         /* no genAssemblerEnd */
407   _ds390_genIVT,
408   _ds390_genXINIT,
409   _ds390_reset_regparm,
410   _ds390_regparm,
411   NULL,
412   NULL,
413   _ds390_nativeMulCheck,
414   FALSE,
415   0,                            /* leave lt */
416   0,                            /* leave gt */
417   1,                            /* transform <= to ! > */
418   1,                            /* transform >= to ! < */
419   1,                            /* transform != to !(a == b) */
420   0,                            /* leave == */
421 #if 0 // obsolete, and buggy for != xdata
422   TRUE,                         /* we support array initializers. */
423 #else
424   FALSE,                        /* No array initializer support. */
425 #endif
426   cseCostEstimation,
427   __ds390_builtins,             /* table of builtin functions */
428   GPOINTER,                     /* treat unqualified pointers as "generic" pointers */
429   1,                            /* reset labelKey to 1 */
430   1,                            /* globals & local static allowed */
431   PORT_MAGIC
432 };
433
434 /*---------------------------------------------------------------------------------*/
435 /*                               TININative specific                               */
436 /*---------------------------------------------------------------------------------*/
437 /* Globals */
438 static void _tininative_init (void)
439 {
440     asm_addTree (&asm_a390_mapping);
441 }
442
443 static void _tininative_setDefaultOptions (void)
444 {
445     options.model=MODEL_FLAT24;
446     options.stack10bit=1;
447     options.stackAuto = 1;
448 }
449
450 static void _tininative_finaliseOptions (void)
451 {
452     /* Hack-o-matic: if we are using the flat24 model,
453      * adjust pointer sizes.
454      */
455     if (options.model != MODEL_FLAT24)  {
456         options.model = MODEL_FLAT24 ;
457         fprintf(stderr,"TININative supports only MODEL FLAT24\n");
458     }
459     port->s.fptr_size = 3;
460     port->s.gptr_size = 4;
461     
462     port->stack.isr_overhead += 2;      /* Will save dpx on ISR entry. */
463     
464     port->stack.call_overhead += 2;     /* This acounts for the extra byte 
465                                          * of return addres on the stack.
466                                          * but is ugly. There must be a 
467                                          * better way.
468                                          */
469     
470     port->mem.default_local_map = xdata;
471     port->mem.default_globl_map = xdata;
472     
473     if (!options.stack10bit) {
474         options.stack10bit = 1;
475         fprintf(stderr,"TININative supports only stack10bit \n");
476     }
477     
478     if (!options.stack_loc) options.stack_loc = 0x400008;
479     
480     /* generate native code 16*16 mul/div */
481     if (options.useAccelerator) 
482         port->support.muldiv=2;
483     else 
484         port->support.muldiv=1;
485     
486     /* Fixup the memory map for the stack; it is now in
487      * far space and requires a FPOINTER to access it.
488      */
489     istack->fmap = 1;
490     istack->ptrType = FPOINTER;
491     options.cc_only =1;
492 }
493
494 static int _tininative_genIVT (FILE * of, symbol ** interrupts, int maxInterrupts) 
495 {
496     return 1;
497 }
498 static void _tininative_genAssemblerPreamble (FILE * of)
499 {
500     fputs("$include(tini.inc)\n", of);
501     fputs("$include(ds80c390.inc)\n", of);
502     fputs("$include(tinimacro.inc)\n", of);
503     fputs("$include(apiequ.inc)\n", of);
504     fputs("_bpx EQU 01Eh \t\t; _bpx (frame pointer) mapped to R8_B3:R7_B3\n", of);
505     fputs("_ap  EQU 01Dh \t\t; _ap mapped to R6_B3\n", of);
506     /* Must be first and return 0 */
507     fputs("Lib_Native_Init:\n",of);
508     fputs("\tclr\ta\n",of);
509     fputs("\tret\n",of);
510     fputs("LibraryID:\n",of);
511     fputs("\tdb \"DS\"\n",of);
512     if (options.tini_libid) {
513         fprintf(of,"\tdb 0,0,0%02xh,0%02xh,0%02xh,0%02xh\n",
514                 (options.tini_libid>>24 & 0xff),
515                 (options.tini_libid>>16 & 0xff),
516                 (options.tini_libid>>8 & 0xff),
517                 (options.tini_libid  & 0xff));
518     } else {
519         fprintf(of,"\tdb 0,0,0,0,0,1\n");
520     }
521
522 }
523 static void _tininative_genAssemblerEnd (FILE * of)
524 {
525     fputs("\tend\n",of);
526 }
527 /* tininative assembler , calls "macro", if it succeeds calls "a390" */
528 static void _tininative_do_assemble (set *asmOptions)
529 {
530     static const char *macroCmd[] = {
531         "macro","$1.a51",NULL
532     };
533     static const char *a390Cmd[] = {
534         "a390","$1.mpp",NULL
535     };
536     char buffer[100];
537
538     buildCmdLine(buffer,macroCmd,dstFileName,NULL,NULL,NULL);
539     if (my_system(buffer)) {
540         exit(1);
541     }
542     buildCmdLine(buffer,a390Cmd,dstFileName,NULL,NULL,asmOptions);
543     if (my_system(buffer)) {
544         exit(1);
545     }    
546 }
547
548 /* list of key words used by TININative */
549 static char *_tininative_keywords[] =
550 {
551   "at",
552   "bit",
553   "code",
554   "critical",
555   "data",
556   "far",
557   "idata",
558   "interrupt",
559   "near",
560   "pdata",
561   "reentrant",
562   "sfr",
563   "sbit",
564   "using",
565   "xdata",
566   "_data",
567   "_code",
568   "_generic",
569   "_near",
570   "_xdata",
571   "_pdata",
572   "_idata",
573   "_naked",
574   "_JavaNative",
575   NULL
576 };
577
578 static builtins __tininative_builtins[] = {
579     { "__builtin_memcpy_x2x","v",3,{"cx*","cx*","i"}}, /* void __builtin_memcpy_x2x (xdata char *,xdata char *,int) */
580     { "__builtin_memcpy_c2x","v",3,{"cx*","cp*","i"}}, /* void __builtin_memcpy_c2x (xdata char *,code  char *,int) */
581     { "__builtin_memset_x","v",3,{"cx*","c","i"}},     /* void __builtin_memset     (xdata char *,char,int)         */
582     /* TINI NatLib */
583     { "NatLib_LoadByte","c",1,{"c"}},                  /* char  Natlib_LoadByte  (0 based parameter number)         */
584     { "NatLib_LoadShort","s",1,{"c"}},                 /* short Natlib_LoadShort (0 based parameter number)         */
585     { "NatLib_LoadInt","l",1,{"c"}},                   /* long  Natlib_LoadLong  (0 based parameter number)         */
586     { "NatLib_LoadPointer","cx*",1,{"c"}},             /* long  Natlib_LoadPointer  (0 based parameter number)      */
587     /* TINI StateBlock related */
588     { "NatLib_InstallImmutableStateBlock","c",2,{"vx*","us"}},/* char NatLib_InstallImmutableStateBlock(state block *,int handle) */
589     { "NatLib_InstallEphemeralStateBlock","c",2,{"vx*","us"}},/* char NatLib_InstallEphemeralStateBlock(state block *,int handle) */
590     { "NatLib_RemoveImmutableStateBlock","v",0,{NULL}},/* void NatLib_RemoveImmutableStateBlock() */
591     { "NatLib_RemoveEphemeralStateBlock","v",0,{NULL}},/* void NatLib_RemoveEphemeralStateBlock() */
592     { "NatLib_GetImmutableStateBlock","i",0,{NULL}},   /* int  NatLib_GetImmutableStateBlock () */
593     { "NatLib_GetEphemeralStateBlock","i",0,{NULL}},   /* int  NatLib_GetEphemeralStateBlock () */
594     /* Memory manager */
595     { "MM_XMalloc","i",1,{"l"}},                       /* int  MM_XMalloc (long)                */
596     { "MM_Malloc","i",1,{"i"}},                        /* int  MM_Malloc  (int)                 */
597     { "MM_ApplicationMalloc","i",1,{"i"}},             /* int  MM_ApplicationMalloc  (int)      */
598     { "MM_Free","i",1,{"i"}},                          /* int  MM_Free  (int)                   */
599     { "MM_Deref","cx*",1,{"i"}},                       /* char *MM_Free  (int)                  */
600     { "MM_UnrestrictedPersist","c",1,{"i"}},           /* char  MM_UnrestrictedPersist  (int)   */
601     /* System functions */
602     { "System_ExecJavaProcess","c",2,{"cx*","i"}},     /* char System_ExecJavaProcess (char *,int) */
603     { "System_GetRTCRegisters","v",1,{"cx*"}},         /* void System_GetRTCRegisters (char *) */
604     { "System_SetRTCRegisters","v",1,{"cx*"}},         /* void System_SetRTCRegisters (char *) */
605     { "System_ThreadSleep","v",2,{"l","c"}},           /* void System_ThreadSleep (long,char)  */
606     { "System_ThreadSleep_ExitCriticalSection","v",2,{"l","c"}},/* void System_ThreadSleep_ExitCriticalSection (long,char)  */
607     { "System_ProcessSleep","v",2,{"l","c"}},           /* void System_ProcessSleep (long,char)  */
608     { "System_ProcessSleep_ExitCriticalSection","v",2,{"l","c"}},/* void System_ProcessSleep_ExitCriticalSection (long,char)  */
609     { "System_ThreadResume","c",2,{"c","c"}},          /* char System_ThreadResume(char,char)  */
610     { "System_SaveJavaThreadState","v",0,{NULL}},      /* void System_SaveJavaThreadState()    */
611     { "System_RestoreJavaThreadState","v",0,{NULL}},   /* void System_RestoreJavaThreadState() */
612     { "System_ProcessYield","v",0,{NULL}},             /* void System_ProcessYield() */
613     { "System_ProcessSuspend","v",0,{NULL}},           /* void System_ProcessSuspend() */
614     { "System_ProcessResume","v",1,{"c"}},             /* void System_ProcessResume(char) */
615     { "System_RegisterPoll","c",1,{"vF*"}},            /* char System_RegisterPoll ((void *func pointer)()) */
616     { "System_RemovePoll","c",1,{"vF*"}},              /* char System_RemovePoll ((void *func pointer)()) */
617     { "System_GetCurrentProcessId","c",0,{NULL}},      /* char System_GetCurrentProcessId() */
618     { "System_GetCurrentThreadId","c",0,{NULL}},       /* char System_GetCurrentThreadId() */
619     { NULL , NULL,0, {NULL}}                       /* mark end of table */
620 };    
621
622 static const char *_a390Cmd[] =
623 {
624   "macro", "$l", "$3", "$1.a51", NULL
625 };
626 PORT tininative_port =
627 {
628   TARGET_ID_DS390,
629   "TININative",
630   "DS80C390",                   /* Target name */
631         NULL,                   /* processor */
632   {
633     FALSE,                      /* Emit glue around main */
634     MODEL_FLAT24,
635     MODEL_FLAT24
636   },
637   {
638     _a390Cmd,
639     NULL,
640     "-l",               /* Options with debug */
641     "-l",               /* Options without debug */
642     0,
643     ".a51",
644     _tininative_do_assemble
645   },
646   {
647     NULL,
648     NULL,
649     NULL,
650     ".tlib",
651   },
652   {
653     _defaultRules
654   },
655   {
656         /* Sizes: char, short, int, long, ptr, fptr, gptr, bit, float, max */
657     1, 2, 2, 4, 1, 3, 3, 1, 4, 4
658   },
659   {
660     "XSEG    (XDATA)",
661     "STACK   (DATA)",
662     "CSEG    (CODE)",
663     "DSEG    (DATA)",
664     "ISEG    (DATA)",
665     "XSEG    (XDATA)",
666     "BSEG    (BIT)",
667     "RSEG    (DATA)",
668     "GSINIT  (CODE)",
669     "OSEG    (OVR,DATA)",
670     "GSFINAL (CODE)",
671     "HOME        (CODE)",
672     NULL,
673     NULL,
674     NULL,
675     NULL,
676     1
677   },
678   { NULL, NULL },
679   {
680     +1, 1, 4, 1, 1, 0
681   },
682     /* ds390 has an 16 bit mul & div */
683   {
684     2, -1
685   },
686   "",
687   _tininative_init,
688   _ds390_parseOptions,
689   NULL,
690   _tininative_finaliseOptions,
691   _tininative_setDefaultOptions,
692   ds390_assignRegisters,
693   _ds390_getRegName,
694   _tininative_keywords,
695   _tininative_genAssemblerPreamble,
696   _tininative_genAssemblerEnd,
697   _tininative_genIVT,
698   NULL,
699   _ds390_reset_regparm,
700   _ds390_regparm,
701   NULL,
702   NULL,
703   NULL,
704   FALSE,
705   0,                            /* leave lt */
706   0,                            /* leave gt */
707   1,                            /* transform <= to ! > */
708   1,                            /* transform >= to ! < */
709   1,                            /* transform != to !(a == b) */
710   0,                            /* leave == */
711   TRUE,                         /* we support array initializers. */
712   cseCostEstimation,
713   __tininative_builtins,        /* table of builtin functions */
714   FPOINTER,                     /* treat unqualified pointers as far pointers */
715   0,                            /* DONOT reset labelKey */
716   0,                            /* globals & local static NOT allowed */
717   PORT_MAGIC
718 };
719
720 static int
721 _ds400_genIVT (FILE * of, symbol ** interrupts, int maxInterrupts)
722 {
723     /* We can't generate a static IVT, since the boot rom creates one
724      * for us in rom_init.
725      * 
726      * we must patch it as part of the C startup.
727      */
728      fprintf (of, ";\tDS80C400 IVT must be generated at runtime.\n");
729     fprintf (of, "\tsjmp\t__sdcc_400boot\n");
730     fprintf (of, "\t.ascii\t'TINI'\t; required signature for 400 boot loader.\n");
731     fprintf (of, "\t.db\t0\t; selected bank: zero *should* work...\n");
732     fprintf (of, "\t__sdcc_400boot:\tljmp\t__sdcc_gsinit_startup\n");
733      return TRUE;
734 }
735
736     
737
738 static void
739 _ds400_finaliseOptions (void)
740 {
741   if (options.noXinitOpt) {
742     port->genXINIT=0;
743   }
744
745   // hackhack: we're a superset of the 390.
746   addSet(&preArgvSet, Safe_strdup("-DSDCC_ds390"));
747   addSet(&preArgvSet, Safe_strdup("-D__ds390"));
748     
749   /* Hack-o-matic: if we are using the flat24 model,
750    * adjust pointer sizes.
751    */
752   if (options.model != MODEL_FLAT24)  {
753       fprintf (stderr,
754                "*** warning: ds400 port small and large model experimental.\n");
755       if (options.model == MODEL_LARGE)
756       {
757         port->mem.default_local_map = xdata;
758         port->mem.default_globl_map = xdata;
759       }
760       else
761       {
762         port->mem.default_local_map = data;
763         port->mem.default_globl_map = data;
764       }
765   }
766   else {
767     port->s.fptr_size = 3;
768     port->s.gptr_size = 4;
769
770     port->stack.isr_overhead += 2;      /* Will save dpx on ISR entry. */
771
772     port->stack.call_overhead += 2;     /* This acounts for the extra byte 
773                                  * of return addres on the stack.
774                                  * but is ugly. There must be a 
775                                  * better way.
776                                  */
777
778     port->mem.default_local_map = xdata;
779     port->mem.default_globl_map = xdata;
780
781     if (!options.stack10bit)
782     {
783     fprintf (stderr,
784              "*** error: ds400 port only supports the 10 bit stack mode.\n");
785     } else {
786         if (!options.stack_loc) options.stack_loc = 0xffdc00;
787         // assumes IDM1:0 = 1:0, CMA = 1.
788     }
789     
790     /* generate native code 16*16 mul/div */
791     if (options.useAccelerator) 
792             port->support.muldiv=2;
793     else 
794             port->support.muldiv=1;
795
796      /* Fixup the memory map for the stack; it is now in
797      * far space and requires a FPOINTER to access it.
798      */
799     istack->fmap = 1;
800     istack->ptrType = FPOINTER;
801
802     if (options.parms_in_bank1) {
803         addSet(&preArgvSet, Safe_strdup("-DSDCC_PARMS_IN_BANK1"));
804     }
805      
806     // the DS400 rom calling interface uses register bank 3.
807     RegBankUsed[3] = 1;
808       
809   }  /* MODEL_FLAT24 */
810 }
811
812 extern char * iComments2;
813
814 static void _ds400_generateRomDataArea(FILE *fp, bool isMain)
815 {
816     /* Only do this for the file containing main() */
817     if (isMain)
818     {
819         fprintf(fp, "%s", iComments2);
820         fprintf(fp, "; the direct data area used by the DS80c400 ROM code.\n");
821         fprintf(fp, "%s", iComments2);
822         fprintf(fp, ".area ROMSEG (ABS,CON,DATA)\n\n");
823         fprintf(fp, ".ds 24 ; 24 bytes of directs used starting at 0x68\n\n");
824     }
825 }
826
827 static void _ds400_linkRomDataArea(FILE *fp)
828 {
829     fprintf(fp, "-b ROMSEG = 0x0068\n");
830 }
831
832
833 PORT ds400_port =
834 {
835   TARGET_ID_DS400,
836   "ds400",
837   "DS80C400",                   /* Target name */
838   NULL,
839   {
840     glue,
841     TRUE,                       /* Emit glue around main */
842     MODEL_SMALL | MODEL_LARGE | MODEL_FLAT24,
843     MODEL_SMALL
844   },
845   {
846     _asmCmd,
847     NULL,
848     "-plosgffc",                /* Options with debug */
849     "-plosgff",                 /* Options without debug */
850     0,
851     ".asm",
852     NULL                        /* no do_assemble function */
853   },
854   {
855     _linkCmd,
856     NULL,
857     NULL,
858     ".rel"
859   },
860   {
861     _defaultRules
862   },
863   {
864         /* Sizes: char, short, int, long, ptr, fptr, gptr, bit, float, max */
865     1, 2, 2, 4, 1, 2, 3, 1, 4, 4
866   },
867   {
868     "XSEG    (XDATA)",
869     "STACK   (DATA)",
870     "CSEG    (CODE)",
871     "DSEG    (DATA)",
872     "ISEG    (DATA)",
873     "XSEG    (XDATA)",
874     "BSEG    (BIT)",
875     "RSEG    (DATA)",
876     "GSINIT  (CODE)",
877     "OSEG    (OVR,DATA)",
878     "GSFINAL (CODE)",
879     "HOME    (CODE)",
880     "XISEG   (XDATA)", // initialized xdata
881     "XINIT   (CODE)", // a code copy of xiseg
882     NULL,
883     NULL,
884     1
885   },
886   { _ds400_generateRomDataArea, _ds400_linkRomDataArea },
887   {
888     +1, 1, 4, 1, 1, 0
889   },
890     /* ds390 has an 16 bit mul & div */
891   {
892     2, -1
893   },
894   "_",
895   _ds390_init,
896   _ds390_parseOptions,
897   NULL,
898   _ds400_finaliseOptions,
899   _ds390_setDefaultOptions,
900   ds390_assignRegisters,
901   _ds390_getRegName,
902   _ds390_keywords,
903   _ds390_genAssemblerPreamble,
904   NULL,                         /* no genAssemblerEnd */
905   _ds400_genIVT,
906   _ds390_genXINIT,
907   _ds390_reset_regparm,
908   _ds390_regparm,
909   NULL,
910   NULL,
911   _ds390_nativeMulCheck,
912   FALSE,
913   0,                            /* leave lt */
914   0,                            /* leave gt */
915   1,                            /* transform <= to ! > */
916   1,                            /* transform >= to ! < */
917   1,                            /* transform != to !(a == b) */
918   0,                            /* leave == */
919   TRUE,                         /* we support array initializers. */
920   cseCostEstimation,
921   __ds390_builtins,             /* table of builtin functions */
922   GPOINTER,                     /* treat unqualified pointers as "generic" pointers */
923   1,                            /* reset labelKey to 1 */
924   1,                            /* globals & local static allowed */
925   PORT_MAGIC
926 };