git.gag.com Git - fw/sdcc/blob - src/pic/glue.c

   1 /*-------------------------------------------------------------------------
   2
   3   SDCCglue.c - glues everything we have done together into one file.
   4                 Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 2, or (at your option) any
   9    later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19
  20    In other words, you are welcome to use, share and improve this program.
  21    You are forbidden to forbid anyone else to use, share and improve
  22    what you give them.   Help stamp out software-hoarding!
  23 -------------------------------------------------------------------------*/
  24
  25 #include "../common.h"
  26 #include <time.h>
  27 #include "ralloc.h"
  28 #include "pcode.h"
  29 #include "newalloc.h"
  30
  31
  32 #ifdef WORDS_BIGENDIAN
  33 #define _ENDIAN(x)  (3-x)
  34 #else
  35 #define _ENDIAN(x)  (x)
  36 #endif
  37
  38 #define BYTE_IN_LONG(x,b) ((x>>(8*_ENDIAN(b)))&0xff)
  39
  40 extern symbol *interrupts[256];
  41 static void printIval (symbol * sym, sym_link * type, initList * ilist, pBlock *pb);
  42 extern int noAlloc;
  43 extern set *publics;
  44 extern set *externs;
  45 extern unsigned maxInterrupts;
  46 extern int maxRegBank;
  47 extern symbol *mainf;
  48 extern char *VersionString;
  49 extern FILE *codeOutFile;
  50 extern set *tmpfileSet;
  51 extern set *tmpfileNameSet;
  52 extern char *iComments1;
  53 extern char *iComments2;
  54 //extern void emitStaticSeg (memmap * map);
  55
  56 extern DEFSETFUNC (closeTmpFiles);
  57 extern DEFSETFUNC (rmTmpFiles);
  58
  59 extern void AnalyzeBanking (void);
  60 extern void copyFile (FILE * dest, FILE * src);
  61 extern void ReuseReg(void);
  62 extern void InlinepCode(void);
  63 extern void writeUsedRegs(FILE *);
  64
  65 extern void initialComments (FILE * afile);
  66 extern void printPublics (FILE * afile);
  67
  68 extern void printChar (FILE * ofile, char *s, int plen);
  69 void  pCodeInitRegisters(void);
  70 int getConfigWord(int address);
  71
  72 char *udata_section_name=0;             // FIXME Temporary fix to change udata section name -- VR
  73
  74 /*-----------------------------------------------------------------*/
  75 /* aopLiteral - string from a literal value                        */
  76 /*-----------------------------------------------------------------*/
  77 int pic14aopLiteral (value *val, int offset)
  78 {
  79         union {
  80                 float f;
  81                 unsigned char c[4];
  82         } fl;
  83
  84         /* if it is a float then it gets tricky */
  85         /* otherwise it is fairly simple */
  86         if (!IS_FLOAT(val->type)) {
  87                 unsigned long v = (unsigned long) floatFromVal(val);
  88
  89                 return ( (v >> (offset * 8)) & 0xff);
  90         }
  91
  92         /* it is type float */
  93         fl.f = (float) floatFromVal(val);
  94 #ifdef WORDS_BIGENDIAN
  95         return fl.c[3-offset];
  96 #else
  97         return fl.c[offset];
  98 #endif
  99
 100 }
 101
 102
 103 /*-----------------------------------------------------------------*/
 104 /* emitRegularMap - emit code for maps with no special cases       */
 105 /*-----------------------------------------------------------------*/
 106 static void
 107 pic14emitRegularMap (memmap * map, bool addPublics, bool arFlag)
 108 {
 109         symbol *sym;
 110         int bitvars = 0;;
 111
 112         /* print the area name */
 113         if (addPublics)
 114                 fprintf (map->oFile, ";\t.area\t%s\n", map->sname);
 115
 116         for (sym = setFirstItem (map->syms); sym;
 117         sym = setNextItem (map->syms)) {
 118
 119                 //printf("%s\n",sym->name);
 120
 121                 /* if extern then add it into the extern list */
 122                 if (IS_EXTERN (sym->etype)) {
 123                         addSetHead (&externs, sym);
 124                         continue;
 125                 }
 126
 127                 /* if allocation required check is needed
 128                 then check if the symbol really requires
 129                 allocation only for local variables */
 130                 if (arFlag && !IS_AGGREGATE (sym->type) &&
 131                         !(sym->_isparm && !IS_REGPARM (sym->etype)) &&
 132                         !sym->allocreq && sym->level)
 133                         continue;
 134
 135                         /* if global variable & not static or extern
 136                 and addPublics allowed then add it to the public set */
 137                 if ((sym->level == 0 ||
 138                         (sym->_isparm && !IS_REGPARM (sym->etype))) &&
 139                         addPublics &&
 140                         !IS_STATIC (sym->etype))
 141                         addSetHead (&publics, sym);
 142
 143                 // PIC code allocates its own registers - so ignore parameter variable generated by processFuncArgs()
 144                 if (sym->_isparm)
 145                         continue;
 146                         /* if extern then do nothing or is a function
 147                 then do nothing */
 148                 if (IS_FUNC (sym->type))
 149                         continue;
 150 #if 0
 151                 /* print extra debug info if required */
 152                 if (options.debug || sym->level == 0)
 153                 {
 154                         if (!sym->level)        /* global */
 155                                 if (IS_STATIC (sym->etype))
 156                                         fprintf (map->oFile, "F%s_", moduleName);               /* scope is file */
 157                                 else
 158                                         fprintf (map->oFile, "G_");     /* scope is global */
 159                                 else
 160                                         /* symbol is local */
 161                                         fprintf (map->oFile, "L%s_", (sym->localof ? sym->localof->name : "-null-"));
 162                                 fprintf (map->oFile, "%s_%d_%d", sym->name, sym->level, sym->block);
 163                 }
 164 #endif
 165
 166                 /* if it has an absolute address then generate
 167                 an equate for this no need to allocate space */
 168                 if (SPEC_ABSA (sym->etype))
 169                 {
 170                         //if (options.debug || sym->level == 0)
 171                         //fprintf (map->oFile,"; == 0x%04x\n",SPEC_ADDR (sym->etype));
 172
 173                         fprintf (map->oFile, "%s\tEQU\t0x%04x\n",
 174                                 sym->rname,
 175                                 SPEC_ADDR (sym->etype));
 176                 }
 177                 else
 178                 {
 179                         /* allocate space */
 180
 181                         /* If this is a bit variable, then allocate storage after 8 bits have been declared */
 182                         /* unlike the 8051, the pic does not have a separate bit area. So we emulate bit ram */
 183                         /* by grouping the bits together into groups of 8 and storing them in the normal ram. */
 184                         if (IS_BITVAR (sym->etype))
 185                         {
 186                                 bitvars++;
 187                         }
 188                         else
 189                         {
 190                                 fprintf (map->oFile, "%s\tres\t%d\n", sym->rname,getSize (sym->type) & 0xffff);
 191                                 /*
 192                                 {
 193                                 int i, size;
 194
 195                                   if ((size = (unsigned int) getSize (sym->type) & 0xffff) > 1)
 196                                   {
 197                                   for (i = 1; i < size; i++)
 198                                   fprintf (map->oFile, "\t%s_%d\n", sym->rname, i);
 199                                   }
 200                                   }
 201                                 */
 202                         }
 203                         //fprintf (map->oFile, "\t.ds\t0x%04x\n", (unsigned int)getSize (sym->type) & 0xffff);
 204                 }
 205
 206                 /* if it has a initial value then do it only if
 207                 it is a global variable */
 208                 if (sym->ival && sym->level == 0) {
 209                         ast *ival = NULL;
 210
 211                         if (IS_AGGREGATE (sym->type))
 212                                 ival = initAggregates (sym, sym->ival, NULL);
 213                         else
 214                                 ival = newNode ('=', newAst_VALUE(symbolVal (sym)),
 215                                 decorateType (resolveSymbols (list2expr (sym->ival)), RESULT_CHECK));
 216                         codeOutFile = statsg->oFile;
 217                         GcurMemmap = statsg;
 218                         eBBlockFromiCode (iCodeFromAst (ival));
 219                         sym->ival = NULL;
 220                 }
 221         }
 222 }
 223
 224
 225 /*-----------------------------------------------------------------*/
 226 /* printIvalType - generates ival for int/char                     */
 227 /*-----------------------------------------------------------------*/
 228 static void
 229 printIvalType (symbol *sym, sym_link * type, initList * ilist, pBlock *pb)
 230 {
 231         value *val;
 232         unsigned long ulval;
 233
 234         //fprintf(stderr, "%s\n",__FUNCTION__);
 235
 236         /* if initList is deep */
 237         if (ilist->type == INIT_DEEP)
 238                 ilist = ilist->init.deep;
 239
 240         if (!IS_AGGREGATE(sym->type) && getNelements(type, ilist)>1) {
 241                 werror (W_EXCESS_INITIALIZERS, "scalar", sym->name, sym->lineDef);
 242         }
 243
 244         if (!(val = list2val (ilist))) {
 245                 // assuming a warning has been thrown
 246                 val=constVal("0");
 247         }
 248
 249         if (val->type != type) {
 250                 val = valCastLiteral(type, floatFromVal(val));
 251         }
 252
 253         if(val)
 254                 ulval = (unsigned long) floatFromVal (val);
 255         else
 256                 ulval =0;
 257
 258         switch (getSize (type)) {
 259         case 1:
 260                 addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,0))));
 261                 break;
 262
 263         case 2:
 264                 addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,0))));
 265                 addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,1))));
 266                 break;
 267
 268         case 4:
 269                 addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,0))));
 270                 addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,1))));
 271                 addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,2))));
 272                 addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,3))));
 273                 break;
 274         }
 275 }
 276
 277 /*-----------------------------------------------------------------*/
 278 /* printIvalChar - generates initital value for character array    */
 279 /*-----------------------------------------------------------------*/
 280 static int
 281 printIvalChar (sym_link * type, initList * ilist, pBlock *pb, char *s)
 282 {
 283         value *val;
 284         int remain;
 285
 286         if(!pb)
 287                 return 0;
 288
 289         //fprintf(stderr, "%s\n",__FUNCTION__);
 290         if (!s)
 291         {
 292
 293                 val = list2val (ilist);
 294                 /* if the value is a character string  */
 295                 if (IS_ARRAY (val->type) && IS_CHAR (val->etype))
 296                 {
 297                         if (!DCL_ELEM (type))
 298                                 DCL_ELEM (type) = strlen (SPEC_CVAL (val->etype).v_char) + 1;
 299
 300                         //printChar (oFile, SPEC_CVAL (val->etype).v_char, DCL_ELEM (type));
 301                         //fprintf(stderr, "%s omitting call to printChar\n",__FUNCTION__);
 302                         addpCode2pBlock(pb,newpCodeCharP(";omitting call to printChar"));
 303
 304                         if ((remain = (DCL_ELEM (type) - strlen (SPEC_CVAL (val->etype).v_char) - 1)) > 0)
 305                                 while (remain--)
 306                                         //tfprintf (oFile, "\t!db !constbyte\n", 0);
 307                                         addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(0)));
 308                                 return 1;
 309                 }
 310                 else
 311                         return 0;
 312         }
 313         else {
 314                 //printChar (oFile, s, strlen (s) + 1);
 315
 316                 for(remain=0; remain<(int)strlen(s); remain++) {
 317                         addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(s[remain])));
 318                         //fprintf(stderr,"0x%02x ",s[remain]);
 319                 }
 320                 //fprintf(stderr,"\n");
 321         }
 322         return 1;
 323 }
 324
 325 /*-----------------------------------------------------------------*/
 326 /* printIvalArray - generates code for array initialization        */
 327 /*-----------------------------------------------------------------*/
 328 static void
 329 printIvalArray (symbol * sym, sym_link * type, initList * ilist,
 330                                 pBlock *pb)
 331 {
 332         initList *iloop;
 333         int lcnt = 0, size = 0;
 334
 335         if(!pb)
 336                 return;
 337
 338         /* take care of the special   case  */
 339         /* array of characters can be init  */
 340         /* by a string                      */
 341         if (IS_CHAR (type->next)) {
 342                 //fprintf(stderr,"%s:%d - is_char\n",__FUNCTION__,__LINE__);
 343                 if (!IS_LITERAL(list2val(ilist)->etype)) {
 344                         werror (W_INIT_WRONG);
 345                         return;
 346                 }
 347                 if (printIvalChar (type,
 348                         (ilist->type == INIT_DEEP ? ilist->init.deep : ilist),
 349                         pb, SPEC_CVAL (sym->etype).v_char))
 350                         return;
 351         }
 352         /* not the special case             */
 353         if (ilist->type != INIT_DEEP)
 354         {
 355                 werror (E_INIT_STRUCT, sym->name);
 356                 return;
 357         }
 358
 359         iloop = ilist->init.deep;
 360         lcnt = DCL_ELEM (type);
 361
 362         for (;;)
 363         {
 364                 //fprintf(stderr,"%s:%d - is_char\n",__FUNCTION__,__LINE__);
 365                 size++;
 366                 printIval (sym, type->next, iloop, pb);
 367                 iloop = (iloop ? iloop->next : NULL);
 368
 369
 370                 /* if not array limits given & we */
 371                 /* are out of initialisers then   */
 372                 if (!DCL_ELEM (type) && !iloop)
 373                         break;
 374
 375                 /* no of elements given and we    */
 376                 /* have generated for all of them */
 377                 if (!--lcnt) {
 378                         /* if initializers left */
 379                         if (iloop) {
 380                                 werror (W_EXCESS_INITIALIZERS, "array", sym->name, sym->lineDef);
 381                         }
 382                         break;
 383                 }
 384         }
 385
 386         /* if we have not been given a size  */
 387         if (!DCL_ELEM (type))
 388                 DCL_ELEM (type) = size;
 389
 390         return;
 391 }
 392
 393 /*-----------------------------------------------------------------*/
 394 /* printIval - generates code for initial value                    */
 395 /*-----------------------------------------------------------------*/
 396 static void
 397 printIval (symbol * sym, sym_link * type, initList * ilist, pBlock *pb)
 398 {
 399         if (!ilist || !pb)
 400                 return;
 401
 402         /* if structure then    */
 403         if (IS_STRUCT (type))
 404         {
 405                 //fprintf(stderr,"%s struct\n",__FUNCTION__);
 406                 //printIvalStruct (sym, type, ilist, oFile);
 407                 return;
 408         }
 409
 410         /* if this is a pointer */
 411         if (IS_PTR (type))
 412         {
 413                 //fprintf(stderr,"%s pointer\n",__FUNCTION__);
 414                 //printIvalPtr (sym, type, ilist, oFile);
 415                 return;
 416         }
 417
 418         /* if this is an array   */
 419         if (IS_ARRAY (type))
 420         {
 421                 //fprintf(stderr,"%s array\n",__FUNCTION__);
 422                 printIvalArray (sym, type, ilist, pb);
 423                 return;
 424         }
 425
 426         /* if type is SPECIFIER */
 427         if (IS_SPEC (type))
 428         {
 429                 //fprintf(stderr,"%s spec\n",__FUNCTION__);
 430                 printIvalType (sym, type, ilist, pb);
 431                 return;
 432         }
 433 }
 434
 435 extern void pCodeConstString(char *name, char *value);
 436 /*-----------------------------------------------------------------*/
 437 /* emitStaticSeg - emitcode for the static segment                 */
 438 /*-----------------------------------------------------------------*/
 439 static void
 440 pic14emitStaticSeg (memmap * map)
 441 {
 442         symbol *sym;
 443
 444         fprintf (map->oFile, ";\t.area\t%s\n", map->sname);
 445
 446         //fprintf(stderr, "%s\n",__FUNCTION__);
 447
 448         /* for all variables in this segment do */
 449         for (sym = setFirstItem (map->syms); sym;
 450         sym = setNextItem (map->syms))
 451         {
 452                 /* if extern then add it into the extern list */
 453                 if (IS_EXTERN (sym->etype)) {
 454                         addSetHead (&externs, sym);
 455                         continue;
 456                 }
 457
 458                 /* if it is not static add it to the public
 459                 table */
 460                 if (!IS_STATIC (sym->etype))
 461                         addSetHead (&publics, sym);
 462
 463                 /* print extra debug info if required */
 464                 if (options.debug || sym->level == 0)
 465                 {
 466                         if (!sym->level)
 467                         {                       /* global */
 468                                 if (IS_STATIC (sym->etype))
 469                                         fprintf (code->oFile, "F%s_", moduleName);      /* scope is file */
 470                                 else
 471                                         fprintf (code->oFile, "G_");    /* scope is global */
 472                         }
 473                         else
 474                                 /* symbol is local */
 475                                 fprintf (code->oFile, "L%s_",
 476                                 (sym->localof ? sym->localof->name : "-null-"));
 477                         fprintf (code->oFile, "%s_%d_%d", sym->name, sym->level, sym->block);
 478
 479                 }
 480
 481                 /* if it has an absolute address */
 482                 if (SPEC_ABSA (sym->etype))
 483                 {
 484                         if (options.debug || sym->level == 0)
 485                                 fprintf (code->oFile, " == 0x%04x\n", SPEC_ADDR (sym->etype));
 486
 487                         fprintf (code->oFile, "%s\t=\t0x%04x\n",
 488                                 sym->rname,
 489                                 SPEC_ADDR (sym->etype));
 490                 }
 491                 else
 492                 {
 493                         if (options.debug || sym->level == 0)
 494                                 fprintf (code->oFile, " == .\n");
 495
 496                         /* if it has an initial value */
 497                         if (sym->ival)
 498                         {
 499                                 pBlock *pb;
 500
 501                                 fprintf (code->oFile, "%s:\n", sym->rname);
 502                                 noAlloc++;
 503                                 resolveIvalSym (sym->ival, sym->type);
 504                                 //printIval (sym, sym->type, sym->ival, code->oFile);
 505                                 pb = newpCodeChain(NULL, 'P',newpCodeCharP("; Starting pCode block for Ival"));
 506                                 addpBlock(pb);
 507                                 addpCode2pBlock(pb,newpCodeLabel(sym->rname,-1));
 508
 509                                 printIval (sym, sym->type, sym->ival, pb);
 510                                 noAlloc--;
 511                         }
 512                         else
 513                         {
 514
 515                                 /* allocate space */
 516                                 fprintf (code->oFile, "%s:\n", sym->rname);
 517                                 /* special case for character strings */
 518                                 if (IS_ARRAY (sym->type) && IS_CHAR (sym->type->next) &&
 519                                         SPEC_CVAL (sym->etype).v_char)
 520                                         pCodeConstString(sym->rname , SPEC_CVAL (sym->etype).v_char);
 521                                         /*printChar (code->oFile,
 522                                         SPEC_CVAL (sym->etype).v_char,
 523                                 strlen (SPEC_CVAL (sym->etype).v_char) + 1);*/
 524                                 else
 525                                         fprintf (code->oFile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff);
 526                         }
 527                 }
 528         }
 529
 530 }
 531
 532
 533 /*-----------------------------------------------------------------*/
 534 /* emitMaps - emits the code for the data portion the code         */
 535 /*-----------------------------------------------------------------*/
 536 static void
 537 pic14emitMaps ()
 538 {
 539 /* no special considerations for the following
 540         data, idata & bit & xdata */
 541         pic14emitRegularMap (data, TRUE, TRUE);
 542         pic14emitRegularMap (idata, TRUE, TRUE);
 543         pic14emitRegularMap (bit, TRUE, FALSE);
 544         pic14emitRegularMap (xdata, TRUE, TRUE);
 545         pic14emitRegularMap (sfr, FALSE, FALSE);
 546         pic14emitRegularMap (sfrbit, FALSE, FALSE);
 547         pic14emitRegularMap (code, TRUE, FALSE);
 548         pic14emitStaticSeg (statsg);
 549 }
 550
 551 /*-----------------------------------------------------------------*/
 552 /* createInterruptVect - creates the interrupt vector              */
 553 /*-----------------------------------------------------------------*/
 554 static void
 555 pic14createInterruptVect (FILE * vFile)
 556 {
 557         mainf = newSymbol ("main", 0);
 558         mainf->block = 0;
 559
 560         /* only if the main function exists */
 561         if (!(mainf = findSymWithLevel (SymbolTab, mainf)))
 562         {
 563                 if (!options.cc_only)
 564                         //      werror (E_NO_MAIN);
 565                         fprintf(stderr,"WARNING: function 'main' undefined\n");
 566                 return;
 567         }
 568
 569         /* if the main is only a prototype ie. no body then do nothing */
 570         if (!IFFUNC_HASBODY(mainf->type))
 571         {
 572                 /* if ! compile only then main function should be present */
 573                 if (!options.cc_only)
 574                         //      werror (E_NO_MAIN);
 575                         fprintf(stderr,"WARNING: function 'main' undefined\n");
 576                 return;
 577         }
 578
 579         fprintf (vFile, "%s", iComments2);
 580         fprintf (vFile, "; config word \n");
 581         fprintf (vFile, "%s", iComments2);
 582         fprintf (vFile, "\t__config 0x%x\n", getConfigWord(0x2007));
 583
 584         fprintf (vFile, "%s", iComments2);
 585         fprintf (vFile, "; reset vector \n");
 586         fprintf (vFile, "%s", iComments2);
 587         fprintf (vFile, "STARTUP\t%s\n", CODE_NAME); // Lkr file should place section STARTUP at address 0x0
 588         fprintf (vFile, "\tnop\n"); /* first location for used by incircuit debugger */
 589         fprintf (vFile, "\tgoto\t__sdcc_gsinit_startup\n");
 590 }
 591
 592
 593 /*-----------------------------------------------------------------*/
 594 /* initialComments - puts in some initial comments                 */
 595 /*-----------------------------------------------------------------*/
 596 static void
 597 pic14initialComments (FILE * afile)
 598 {
 599         initialComments (afile);
 600         fprintf (afile, "; PIC port for the 14-bit core\n");
 601         fprintf (afile, iComments2);
 602
 603 }
 604
 605 /*-----------------------------------------------------------------*/
 606 /* printExterns - generates extern for external variables          */
 607 /*-----------------------------------------------------------------*/
 608 static void
 609 pic14printExterns (FILE * afile)
 610 {
 611         symbol *sym;
 612
 613         fprintf (afile, "%s", iComments2);
 614         fprintf (afile, "; extern variables in this module\n");
 615         fprintf (afile, "%s", iComments2);
 616
 617         for (sym = setFirstItem (externs); sym;
 618         sym = setNextItem (externs))
 619                 fprintf (afile, "\textern %s\n", sym->rname);
 620 }
 621
 622 /*-----------------------------------------------------------------*/
 623 /* printPublics - generates .global for publics                    */
 624 /*-----------------------------------------------------------------*/
 625 static void
 626 pic14printPublics (FILE * afile)
 627 {
 628         symbol *sym;
 629
 630         fprintf (afile, "%s", iComments2);
 631         fprintf (afile, "; publics variables in this module\n");
 632         fprintf (afile, "%s", iComments2);
 633
 634         for (sym = setFirstItem (publics); sym;
 635         sym = setNextItem (publics)) {
 636
 637                 if(!IS_BITFIELD(sym->type) && ((IS_FUNC(sym->type) || sym->allocreq))) {
 638                         if (!IS_BITVAR(sym->type))
 639                                 fprintf (afile, "\tglobal %s\n", sym->rname);
 640                 } else {
 641                         /* Absolute variables are defines in the asm file as equates and thus can not be made global. */
 642                         if (!SPEC_ABSA (sym->etype))
 643                                 fprintf (afile, "\tglobal %s\n", sym->rname);
 644                 }
 645         }
 646 }
 647
 648 /*-----------------------------------------------------------------*/
 649 /* emitOverlay - will emit code for the overlay stuff              */
 650 /*-----------------------------------------------------------------*/
 651 static void
 652 pic14emitOverlay (FILE * afile)
 653 {
 654         set *ovrset;
 655
 656         /*  if (!elementsInSet (ovrSetSets))*/
 657
 658         /* the hack below, fixes translates for devices which
 659         * only have udata_shr memory */
 660         fprintf (afile, "%s\t%s\n",
 661                 (elementsInSet(ovrSetSets)?"":";"),
 662                 port->mem.overlay_name);
 663
 664         /* for each of the sets in the overlay segment do */
 665         for (ovrset = setFirstItem (ovrSetSets); ovrset;
 666         ovrset = setNextItem (ovrSetSets))
 667         {
 668
 669                 symbol *sym;
 670
 671                 if (elementsInSet (ovrset))
 672                 {
 673                 /* this dummy area is used to fool the assembler
 674                 otherwise the assembler will append each of these
 675                 declarations into one chunk and will not overlay
 676                         sad but true */
 677
 678                         /* I don't think this applies to us. We are using gpasm.  CRF */
 679
 680                         fprintf (afile, ";\t.area _DUMMY\n");
 681                         /* output the area informtion */
 682                         fprintf (afile, ";\t.area\t%s\n", port->mem.overlay_name);      /* MOF */
 683                 }
 684
 685                 for (sym = setFirstItem (ovrset); sym;
 686                 sym = setNextItem (ovrset))
 687                 {
 688
 689                         /* if extern then do nothing */
 690                         if (IS_EXTERN (sym->etype))
 691                                 continue;
 692
 693                                 /* if allocation required check is needed
 694                                 then check if the symbol really requires
 695                         allocation only for local variables */
 696                         if (!IS_AGGREGATE (sym->type) &&
 697                                 !(sym->_isparm && !IS_REGPARM (sym->etype))
 698                                 && !sym->allocreq && sym->level)
 699                                 continue;
 700
 701                                 /* if global variable & not static or extern
 702                         and addPublics allowed then add it to the public set */
 703                         if ((sym->_isparm && !IS_REGPARM (sym->etype))
 704                                 && !IS_STATIC (sym->etype))
 705                                 addSetHead (&publics, sym);
 706
 707                                 /* if extern then do nothing or is a function
 708                         then do nothing */
 709                         if (IS_FUNC (sym->type))
 710                                 continue;
 711
 712                         /* print extra debug info if required */
 713                         if (options.debug || sym->level == 0)
 714                         {
 715                                 if (!sym->level)
 716                                 {               /* global */
 717                                         if (IS_STATIC (sym->etype))
 718                                                 fprintf (afile, "F%s_", moduleName);    /* scope is file */
 719                                         else
 720                                                 fprintf (afile, "G_");  /* scope is global */
 721                                 }
 722                                 else
 723                                         /* symbol is local */
 724                                         fprintf (afile, "L%s_",
 725                                         (sym->localof ? sym->localof->name : "-null-"));
 726                                 fprintf (afile, "%s_%d_%d", sym->name, sym->level, sym->block);
 727                         }
 728
 729                         /* if is has an absolute address then generate
 730                         an equate for this no need to allocate space */
 731                         if (SPEC_ABSA (sym->etype))
 732                         {
 733
 734                                 if (options.debug || sym->level == 0)
 735                                         fprintf (afile, " == 0x%04x\n", SPEC_ADDR (sym->etype));
 736
 737                                 fprintf (afile, "%s\t=\t0x%04x\n",
 738                                         sym->rname,
 739                                         SPEC_ADDR (sym->etype));
 740                         }
 741                         else
 742                         {
 743                                 if (options.debug || sym->level == 0)
 744                                         fprintf (afile, "==.\n");
 745
 746                                 /* allocate space */
 747                                 fprintf (afile, "%s:\n", sym->rname);
 748                                 fprintf (afile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff);
 749                         }
 750
 751                 }
 752         }
 753 }
 754
 755
 756 /*-----------------------------------------------------------------*/
 757 /* glue - the final glue that hold the whole thing together        */
 758 /*-----------------------------------------------------------------*/
 759 void
 760 picglue ()
 761 {
 762         char udata_name[80];
 763         FILE *vFile;
 764         FILE *asmFile;
 765         FILE *ovrFile = tempfile();
 766
 767         addSetHead(&tmpfileSet,ovrFile);
 768         pCodeInitRegisters();
 769
 770         if (mainf && IFFUNC_HASBODY(mainf->type)) {
 771
 772                 pBlock *pb = newpCodeChain(NULL,'X',newpCodeCharP("; Starting pCode block"));
 773                 addpBlock(pb);
 774
 775                 /* entry point @ start of CSEG */
 776                 addpCode2pBlock(pb,newpCodeLabel("__sdcc_program_startup",-1));
 777                 /* put in the call to main */
 778                 addpCode2pBlock(pb,newpCode(POC_CALL,newpCodeOp("_main",PO_STR)));
 779
 780                 if (options.mainreturn) {
 781
 782                         addpCode2pBlock(pb,newpCodeCharP(";\treturn from main will return to caller\n"));
 783                         addpCode2pBlock(pb,newpCode(POC_RETURN,NULL));
 784
 785                 } else {
 786
 787                         addpCode2pBlock(pb,newpCodeCharP(";\treturn from main will lock up\n"));
 788                         addpCode2pBlock(pb,newpCode(POC_GOTO,newpCodeOp("$",PO_STR)));
 789
 790                 }
 791         }
 792
 793
 794         /* At this point we've got all the code in the form of pCode structures */
 795         /* Now it needs to be rearranged into the order it should be placed in the */
 796         /* code space */
 797
 798         movepBlock2Head('P');              // Last
 799         movepBlock2Head(code->dbName);
 800         movepBlock2Head('X');
 801         movepBlock2Head(statsg->dbName);   // First
 802
 803
 804         /* print the global struct definitions */
 805         if (options.debug)
 806                 cdbStructBlock (0);
 807
 808         vFile = tempfile();
 809
 810         addSetHead(&tmpfileSet,vFile);
 811
 812         /* emit code for the all the variables declared */
 813         pic14emitMaps ();
 814         /* do the overlay segments */
 815         pic14emitOverlay(ovrFile);
 816
 817         /* PENDING: this isnt the best place but it will do */
 818         if (port->general.glue_up_main) {
 819                 /* create the interrupt vector table */
 820                 pic14createInterruptVect (vFile);
 821         }
 822
 823         AnalyzepCode('*');
 824
 825         ReuseReg(); // ReuseReg where call tree permits
 826
 827         InlinepCode();
 828
 829         AnalyzepCode('*');
 830
 831         pcode_test();
 832
 833
 834         /* now put it all together into the assembler file */
 835         /* create the assembler file name */
 836
 837         if ((noAssemble || options.c1mode) && fullDstFileName)
 838         {
 839                 sprintf (buffer, fullDstFileName);
 840         }
 841         else
 842         {
 843                 sprintf (buffer, dstFileName);
 844                 strcat (buffer, ".asm");
 845         }
 846
 847         if (!(asmFile = fopen (buffer, "w"))) {
 848                 werror (E_FILE_OPEN_ERR, buffer);
 849                 exit (1);
 850         }
 851
 852         /* initial comments */
 853         pic14initialComments (asmFile);
 854
 855         /* print module name */
 856         fprintf (asmFile, ";\t.module %s\n", moduleName);
 857
 858         /* Let the port generate any global directives, etc. */
 859         if (port->genAssemblerPreamble)
 860         {
 861                 port->genAssemblerPreamble(asmFile);
 862         }
 863
 864         /* print the extern variables in this module */
 865         pic14printExterns (asmFile);
 866
 867         /* print the global variables in this module */
 868         pic14printPublics (asmFile);
 869
 870         /* copy the sfr segment */
 871         fprintf (asmFile, "%s", iComments2);
 872         fprintf (asmFile, "; special function registers\n");
 873         fprintf (asmFile, "%s", iComments2);
 874         copyFile (asmFile, sfr->oFile);
 875
 876
 877         if (udata_section_name) {
 878                 sprintf(udata_name,"%s",udata_section_name);
 879         } else {
 880                 sprintf(udata_name,"data_%s",moduleName);
 881         }
 882         fprintf (asmFile, "%s", iComments2);
 883         fprintf (asmFile, "; udata\n");
 884         fprintf (asmFile, "%s", iComments2);
 885         fprintf (asmFile, "%s\tudata\n", udata_name);
 886         copyFile (asmFile, data->oFile);
 887
 888         /* Put all variables into a cblock */
 889         AnalyzeBanking();
 890         writeUsedRegs(asmFile);
 891
 892         /* create the overlay segments */
 893         fprintf (asmFile, "%s", iComments2);
 894         fprintf (asmFile, "; overlayable items in internal ram \n");
 895         fprintf (asmFile, "%s", iComments2);
 896         copyFile (asmFile, ovrFile);
 897
 898 #if 0
 899
 900         /* create the stack segment MOF */
 901         if (mainf && IFFUNC_HASBODY(mainf->type)) {
 902                 fprintf (asmFile, "%s", iComments2);
 903                 fprintf (asmFile, "; Stack segment in internal ram \n");
 904                 fprintf (asmFile, "%s", iComments2);
 905                 fprintf (asmFile, ";\t.area\tSSEG\t(DATA)\n"
 906                         ";__start__stack:\n;\t.ds\t1\n\n");
 907         }
 908
 909         /* create the idata segment */
 910         fprintf (asmFile, "%s", iComments2);
 911         fprintf (asmFile, "; indirectly addressable internal ram data\n");
 912         fprintf (asmFile, "%s", iComments2);
 913         copyFile (asmFile, idata->oFile);
 914
 915         /* if external stack then reserve space of it */
 916         if (mainf && IFFUNC_HASBODY(mainf->type) && options.useXstack ) {
 917                 fprintf (asmFile, "%s", iComments2);
 918                 fprintf (asmFile, "; external stack \n");
 919                 fprintf (asmFile, "%s", iComments2);
 920                 fprintf (asmFile,";\t.area XSEG (XDATA)\n"); /* MOF */
 921                 fprintf (asmFile,";\t.ds 256\n");
 922         }
 923
 924         /* copy xtern ram data */
 925         fprintf (asmFile, "%s", iComments2);
 926         fprintf (asmFile, "; external ram data\n");
 927         fprintf (asmFile, "%s", iComments2);
 928         copyFile (asmFile, xdata->oFile);
 929
 930 #endif
 931
 932         /* copy the bit segment */
 933         fprintf (asmFile, "%s", iComments2);
 934         fprintf (asmFile, "; bit data\n");
 935         fprintf (asmFile, "%s", iComments2);
 936         copyFile (asmFile, bit->oFile);
 937
 938         /* copy the interrupt vector table */
 939         if (mainf && IFFUNC_HASBODY(mainf->type)) {
 940                 copyFile (asmFile, vFile);
 941
 942                 fprintf (asmFile, "%s", iComments2);
 943                 fprintf (asmFile, "; interrupt and initialization code\n");
 944                 fprintf (asmFile, "%s", iComments2);
 945                 fprintf (asmFile, "code_init\t%s\t0x4\n", CODE_NAME); // Note - for mplink may have to enlarge section vectors in .lnk file
 946
 947                 /* interrupt service routine */
 948                 fprintf (asmFile, "__sdcc_interrupt:\n");
 949                 copypCode(asmFile, 'I');
 950
 951                 /* initialize data memory */
 952                 fprintf (asmFile,"__sdcc_gsinit_startup:\n");
 953                 /* FIXME: This is temporary.  The idata section should be used.  If
 954                 not, we could add a special feature to the linker.  This will
 955                 work in the mean time.  Put all initalized data in main.c */
 956                 copypCode(asmFile, statsg->dbName);
 957                 fprintf (asmFile,"\tpagesel _main\n");
 958                 fprintf (asmFile,"\tgoto _main\n");
 959         }
 960
 961 #if 0
 962
 963         /* copy global & static initialisations */
 964         fprintf (asmFile, "%s", iComments2);
 965         fprintf (asmFile, "; global & static initialisations\n");
 966         fprintf (asmFile, "%s", iComments2);
 967         copypCode(asmFile, statsg->dbName);
 968
 969 #endif
 970
 971         /* copy over code */
 972         fprintf (asmFile, "%s", iComments2);
 973         fprintf (asmFile, "; code\n");
 974         fprintf (asmFile, "%s", iComments2);
 975         fprintf (asmFile, "code_%s\t%s\n", moduleName, port->mem.code_name);
 976
 977         /* unknown */
 978         copypCode(asmFile, 'X');
 979
 980         /* _main function */
 981         copypCode(asmFile, 'M');
 982
 983         /* other functions */
 984         copypCode(asmFile, code->dbName);
 985
 986         /* unknown */
 987         copypCode(asmFile, 'P');
 988
 989         fprintf (asmFile,"\tend\n");
 990
 991         fclose (asmFile);
 992
 993         rm_tmpfiles();
 994 }