sdcc/src/cdbFile.c

   1 #include "common.h"
   2
   3
   4 /*************************************************************
   5  *
   6  *
   7  *
   8  *
   9  *************************************************************/
  10
  11 int cdbOpenFile (const char *file);
  12 int cdbCloseFile (void);
  13 int cdbWriteFunction (symbol *pSym, iCode *ic);
  14 int cdbWriteEndFunction (symbol *pSym, iCode *ic, int offset);
  15 int cdbWriteLabel (symbol *pSym, const iCode *ic);
  16 int cdbWriteScope (iCode *ic);
  17 int cdbWriteSymbol (symbol *pSym);
  18 int cdbWriteType (structdef *sdef, int block, int inStruct, const char *tag);
  19 int cdbWriteModule (const char *name);
  20 int cdbWriteCLine (iCode *ic);
  21 int cdbWriteALine (const char *module, int Line);
  22 int cdbWriteFrameAddress (const char *variable, struct reg_info *reg, int offset);
  23 int cdbWriteBasicSymbol (symbol *sym, int isStructSym, int isFunc);
  24 void cdbTypeInfo (sym_link * type);
  25
  26
  27 DEBUGFILE cdbDebugFile =
  28   {
  29     &cdbOpenFile,
  30     &cdbCloseFile,
  31     &cdbWriteModule,
  32     &cdbWriteFunction,
  33     &cdbWriteEndFunction,
  34     &cdbWriteLabel,
  35     &cdbWriteScope,
  36     &cdbWriteSymbol,
  37     &cdbWriteType,
  38     &cdbWriteCLine,
  39     &cdbWriteALine,
  40     &cdbWriteFrameAddress
  41   };
  42
  43 FILE *cdbFilePtr = NULL;
  44 const char *cdbModuleName = NULL;
  45
  46 /******************************************************************
  47  * spacesToUnderscores - replace all non alpha-numerics with
  48  * underscores
  49  *
  50  *
  51  *****************************************************************/
  52
  53 static char *
  54 spacesToUnderscores (char *dest, const char *src, size_t len)
  55 {
  56   unsigned int i;
  57   char *p;
  58
  59   assert (dest != NULL);
  60   assert (src != NULL);
  61   assert (len > 0);
  62
  63   --len;
  64   for (p = dest, i = 0; *src != '\0' && i < len; ++src, ++i) {
  65     *p++ = (isspace ((unsigned char)*src) || (*src == '-')) ? '_' : *src;
  66   }
  67   *p = '\0';
  68
  69   return dest;
  70 }
  71
  72
  73 /******************************************************************
  74  *
  75  *
  76  *
  77  *
  78  *****************************************************************/
  79
  80 int
  81 cdbOpenFile (const char *file)
  82 {
  83   if (getenv ("SDCC_DEBUG_FUNCTION_POINTERS"))
  84     fprintf (stderr, "cdbFile.c:cdbOpenFile (%s)\n", file);
  85
  86   return (cdbFilePtr = fopen(file, "w")) ? 1 : 0;
  87 }
  88
  89 /******************************************************************
  90  *
  91  *
  92  *
  93  *
  94  *****************************************************************/
  95 int
  96 cdbCloseFile (void)
  97 {
  98   if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
  99     fprintf (stderr, "cdbFile.c:cdbCloseFile()\n");
 100
 101   if(!cdbFilePtr) return 0;
 102
 103   fclose(cdbFilePtr);
 104   cdbFilePtr = NULL;
 105   cdbModuleName = NULL;
 106
 107   return 1;
 108 }
 109
 110 /******************************************************************
 111  *
 112  *
 113  *
 114  *
 115  *****************************************************************/
 116
 117 int
 118 cdbWriteFunction (symbol *pSym, iCode *ic)
 119 {
 120   char debugSym[INITIAL_INLINEASM];
 121
 122   if (getenv ("SDCC_DEBUG_FUNCTION_POINTERS"))
 123     fprintf (stderr, "cdbFile.c:cdbWriteFunction()\n");
 124
 125   if (!cdbFilePtr) return 0;
 126
 127   if (IS_STATIC (pSym->etype))
 128     sprintf (debugSym, "F%s$%s$0$0", moduleName, pSym->name);
 129   else
 130     sprintf (debugSym, "G$%s$0$0", pSym->name);
 131   emitDebuggerSymbol (debugSym);
 132
 133   return cdbWriteBasicSymbol (pSym, FALSE, TRUE);
 134 }
 135
 136 /******************************************************************
 137  *
 138  *
 139  *
 140  *
 141  *****************************************************************/
 142
 143 int
 144 cdbWriteEndFunction (symbol *pSym, iCode *ic, int offset)
 145 {
 146   char debugSym[INITIAL_INLINEASM];
 147
 148   if (getenv ("SDCC_DEBUG_FUNCTION_POINTERS"))
 149     fprintf (stderr, "cdbFile.c:cdbWriteEndFunction()\n");
 150
 151   if (!cdbFilePtr) return 0;
 152
 153   if (ic)
 154     {
 155       sprintf (debugSym, "C$%s$%d$%ld_%ld$%d",
 156                FileBaseName (ic->filename), pSym->lastLine,
 157                ic->level / LEVEL_UNIT, ic->level % LEVEL_UNIT, ic->block);
 158       spacesToUnderscores (debugSym, debugSym, sizeof (debugSym));
 159       emitDebuggerSymbol (debugSym);
 160     }
 161
 162   if (IS_STATIC (pSym->etype))
 163     sprintf (debugSym, "XF%s$%s$0$0", moduleName, pSym->name);
 164   else
 165     sprintf (debugSym, "XG$%s$0$0", pSym->name);
 166   emitDebuggerSymbol (debugSym);
 167
 168   return 1;
 169 }
 170
 171 /******************************************************************
 172  *
 173  *
 174  *
 175  *
 176  *****************************************************************/
 177
 178 int
 179 cdbWriteLabel (symbol *pSym, const iCode *ic)
 180 {
 181   if (getenv ("SDCC_DEBUG_FUNCTION_POINTERS"))
 182     fprintf (stderr, "cdbFile.c:cdbWriteLabel()\n");
 183
 184   if (!cdbFilePtr) return 0;
 185
 186   return 1;
 187 }
 188
 189 /******************************************************************
 190  *
 191  *
 192  *
 193  *
 194  *****************************************************************/
 195
 196 int
 197 cdbWriteScope (iCode *ic)
 198 {
 199   if (getenv ("SDCC_DEBUG_FUNCTION_POINTERS"))
 200     fprintf (stderr, "cdbFile.c:cdbWriteScope()\n");
 201
 202   if (!cdbFilePtr) return 0;
 203
 204   return 1;
 205 }
 206
 207 /******************************************************************
 208  *
 209  *
 210  *
 211  *
 212  *****************************************************************/
 213
 214 int
 215 cdbWriteSymbol(symbol *pSym)
 216 {
 217   if (getenv ("SDCC_DEBUG_FUNCTION_POINTERS"))
 218     fprintf (stderr, "cdbFile.c:cdbWriteSymbol()\n");
 219
 220   if (!cdbFilePtr) return 0;
 221
 222   return cdbWriteBasicSymbol(pSym, FALSE, FALSE);
 223 }
 224
 225 /******************************************************************
 226  *
 227  *
 228  *
 229  *
 230  *****************************************************************/
 231
 232 int
 233 cdbWriteType (structdef *sdef, int block, int inStruct, const char *tag)
 234 {
 235   symbol *sym;
 236
 237   if (getenv ("SDCC_DEBUG_FUNCTION_POINTERS"))
 238     fprintf (stderr, "cdbFile.c:cdbWriteType()\n");
 239
 240   if (!cdbFilePtr) return 0;
 241
 242   fprintf (cdbFilePtr, "T:");
 243
 244   /* if block # then must have function scope */
 245   fprintf (cdbFilePtr, "F%s$", moduleName);
 246
 247   fprintf (cdbFilePtr, "%s[", (tag ? tag : sdef->tag));
 248
 249   for (sym = sdef->fields; sym; sym = sym->next)
 250     {
 251       fprintf (cdbFilePtr, "({%d}", sym->offset);
 252       cdbWriteBasicSymbol (sym, TRUE, FALSE);
 253       fprintf (cdbFilePtr, ")");
 254     }
 255
 256   fprintf (cdbFilePtr, "]");
 257
 258   if (!inStruct)
 259     fprintf (cdbFilePtr, "\n");
 260
 261   return 1;
 262 }
 263
 264 /******************************************************************
 265  *
 266  *
 267  *
 268  *
 269  *****************************************************************/
 270
 271 int
 272 cdbWriteModule(const char *name)
 273 {
 274   if (getenv ("SDCC_DEBUG_FUNCTION_POINTERS"))
 275     fprintf (stderr, "cdbFile.c:cdbWriteModule()\n");
 276
 277   if (!cdbFilePtr) return 0;
 278   cdbModuleName = name;
 279
 280   fprintf(cdbFilePtr, "M:%s\n", cdbModuleName);
 281
 282   return 1;
 283 }
 284
 285 /******************************************************************
 286  *
 287  *
 288  *
 289  *
 290  *****************************************************************/
 291 int
 292 cdbWriteCLine (iCode *ic)
 293 {
 294   char debugSym[INITIAL_INLINEASM];
 295
 296   if (!cdbFilePtr) return 0;
 297
 298   if (ic->inlined)
 299     return 0;
 300
 301   sprintf (debugSym, "C$%s$%d$%ld_%ld$%d",
 302            FileBaseName (ic->filename), ic->lineno,
 303            ic->level / LEVEL_UNIT, ic->level % LEVEL_UNIT, ic->block);
 304   spacesToUnderscores (debugSym, debugSym, sizeof (debugSym));
 305   emitDebuggerSymbol (debugSym);
 306
 307   return 1;
 308 }
 309
 310 /******************************************************************
 311  *
 312  *
 313  *
 314  *
 315  *****************************************************************/
 316
 317 int
 318 cdbWriteALine (const char *module, int Line)
 319 {
 320   if (!cdbFilePtr) return 0;
 321
 322   return 1;
 323 }
 324
 325 /******************************************************************
 326  *
 327  *
 328  *
 329  *
 330  *****************************************************************/
 331
 332 int
 333 cdbWriteFrameAddress (const char *variable, struct reg_info *reg, int offset)
 334 {
 335   if (getenv ("SDCC_DEBUG_FUNCTION_POINTERS"))
 336     fprintf (stderr, "cdbFile.c:cdbWriteFrameAddress()\n");
 337
 338   if (!cdbFilePtr) return 0;
 339
 340   return 1;
 341 }
 342
 343 /******************************************************************
 344  *
 345  *
 346  *
 347  *
 348  *****************************************************************/
 349
 350 int
 351 cdbWriteBasicSymbol (symbol *sym, int isStructSym, int isFunc)
 352 {
 353   memmap *map;
 354   symbol *sym2;
 355
 356   if (getenv ("SDCC_DEBUG_FUNCTION_POINTERS"))
 357     fprintf (stderr, "cdbFile.c:cdbWriteBasicSymbol()\n");
 358
 359   if (!cdbFilePtr) return 0;
 360
 361   if (!sym) return 0;
 362
 363   /* WRITE HEADER, Function or Symbol */
 364   if (isFunc)
 365     fprintf (cdbFilePtr, "F:");
 366   else
 367     fprintf (cdbFilePtr, "S:");
 368
 369   /* STRUCTS do not have scope info.. */
 370
 371   if (!isStructSym)
 372     {
 373       if (sym->level && sym->localof)   /* symbol is local */
 374         {
 375           fprintf (cdbFilePtr, "L%s.%s$", moduleName, sym->localof->name);
 376         }
 377       else if (IS_STATIC (sym->etype))  /* scope is file */
 378         {
 379           fprintf (cdbFilePtr, "F%s$", moduleName);
 380         }
 381       else                              /* scope is global */
 382         {
 383           fprintf (cdbFilePtr, "G$");
 384         }
 385     }
 386   else
 387     {
 388       fprintf (cdbFilePtr, "S$");       /* scope is structure */
 389     }
 390
 391   /* print the name, & mangled name */
 392   fprintf (cdbFilePtr, "%s$%ld_%ld$%d(", sym->name, sym->level / LEVEL_UNIT, sym->level % LEVEL_UNIT, sym->block);
 393
 394   cdbTypeInfo (sym->type);
 395
 396   fprintf (cdbFilePtr, "),");
 397
 398   /* CHECK FOR REGISTER SYMBOL... */
 399   if (!sym->allocreq && sym->reqv)
 400     {
 401       int a;
 402       symbol *TempSym = OP_SYMBOL (sym->reqv);
 403
 404       if (!TempSym->isspilt || TempSym->remat)
 405         {
 406           fprintf (cdbFilePtr, "R,0,0,[");
 407
 408           for (a = 0; a < 4; a++)
 409             {
 410               if (TempSym->regs[a])
 411                 {
 412                   fprintf (cdbFilePtr, "%s%s", port->getRegName(TempSym->regs[a]),
 413                            ((a < 3) && (TempSym->regs[a+1])) ? "," : "");
 414                 }
 415             }
 416
 417           fprintf (cdbFilePtr, "]");
 418           sym2 = NULL;
 419         }
 420       else
 421         {
 422           sym2 = TempSym->usl.spillLoc;
 423         }
 424     }
 425   else
 426     {
 427       sym2 = sym;
 428     }
 429
 430   if (sym2)
 431     {
 432       /* print the address space */
 433       map = SPEC_OCLS (sym2->etype);
 434
 435       fprintf (cdbFilePtr, "%c,%d,%d",
 436                (map ? map->dbName : 'Z'), sym2->onStack, SPEC_STAK (sym2->etype));
 437     }
 438
 439   /* if assigned to registers then output register names */
 440   /* if this is a function then print
 441      if is it an interrupt routine & interrupt number
 442      and the register bank it is using */
 443   if (isFunc)
 444     fprintf (cdbFilePtr, ",%d,%d,%d", FUNC_ISISR (sym->type),
 445              FUNC_INTNO (sym->type), FUNC_REGBANK (sym->type));
 446
 447 /* alternate location to find this symbol @ : eg registers
 448      or spillocation */
 449
 450   if (!isStructSym)
 451     fprintf (cdbFilePtr, "\n");
 452
 453   return 1;
 454 }
 455
 456 /******************************************************************
 457  *
 458  *
 459  *
 460  *
 461  *****************************************************************/
 462
 463 /*-----------------------------------------------------------------*/
 464 /* cdbTypeInfo - print the type information for debugger           */
 465 /*-----------------------------------------------------------------*/
 466 void
 467 cdbTypeInfo (sym_link * type)
 468 {
 469   fprintf (cdbFilePtr, "{%d}", getSize (type));
 470
 471   while (type)
 472     {
 473       if (IS_DECL (type))
 474         {
 475           switch (DCL_TYPE (type))
 476             {
 477             case FUNCTION: fprintf (cdbFilePtr, "DF,"); break;
 478             case GPOINTER: fprintf (cdbFilePtr, "DG,"); break;
 479             case CPOINTER: fprintf (cdbFilePtr, "DC,"); break;
 480             case FPOINTER: fprintf (cdbFilePtr, "DX,"); break;
 481             case POINTER:  fprintf (cdbFilePtr, "DD,"); break;
 482             case IPOINTER: fprintf (cdbFilePtr, "DI,"); break;
 483             case PPOINTER: fprintf (cdbFilePtr, "DP,"); break;
 484             case EEPPOINTER: fprintf (cdbFilePtr, "DA,"); break;
 485             case ARRAY: fprintf (cdbFilePtr, "DA%ud,", (unsigned int) DCL_ELEM (type)); break;
 486             default: break;
 487             }
 488         }
 489       else
 490         {
 491           switch (SPEC_NOUN (type))
 492             {
 493             case V_INT:
 494               if (IS_LONG (type))
 495                 fprintf (cdbFilePtr, "SL");
 496               else
 497                 fprintf (cdbFilePtr, "SI");
 498               break;
 499
 500             case V_CHAR: fprintf (cdbFilePtr, "SC"); break;
 501             case V_VOID: fprintf (cdbFilePtr, "SV"); break;
 502             case V_FLOAT: fprintf (cdbFilePtr, "SF"); break;
 503             case V_FIXED16X16: fprintf(cdbFilePtr, "SQ"); break;
 504             case V_STRUCT:
 505               fprintf (cdbFilePtr, "ST%s", SPEC_STRUCT (type)->tag);
 506               break;
 507
 508             case V_SBIT: fprintf (cdbFilePtr, "SX"); break;
 509             case V_BIT:
 510             case V_BITFIELD:
 511               fprintf (cdbFilePtr, "SB%d$%d", SPEC_BSTR (type),
 512                        SPEC_BLEN (type));
 513               break;
 514
 515             default:
 516               break;
 517             }
 518           fputs (":", cdbFilePtr);
 519           if (SPEC_USIGN (type))
 520             fputs ("U", cdbFilePtr);
 521           else
 522             fputs ("S", cdbFilePtr);
 523         }
 524       type = type->next;
 525     }
 526 }