git.gag.com Git - fw/sdcc/blob - src/SDCCsymt.h

   1 /*-------------------------------------------------------------------------
   2   SDCCsymt.h - Header file for Symbols table related structures and MACRO's.
   3               Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
   4
   5    This program is free software; you can redistribute it and/or modify it
   6    under the terms of the GNU General Public License as published by the
   7    Free Software Foundation; either version 2, or (at your option) any
   8    later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19    In other words, you are welcome to use, share and improve this program.
  20    You are forbidden to forbid anyone else to use, share and improve
  21    what you give them.   Help stamp out software-hoarding!
  22 -------------------------------------------------------------------------*/
  23
  24 #ifndef  SDCCSYMT_H
  25 #define  SDCCSYMT_H
  26
  27 #define MAX_NEST_LEVEL  256
  28 #define SDCC_NAME_MAX    64
  29 #include "SDCChasht.h"
  30
  31
  32 #define HASHTAB_SIZE 256
  33
  34 /* hash table bucket */
  35 typedef struct bucket
  36   {
  37     void *sym;                  /* pointer to the object   */
  38     char name[SDCC_NAME_MAX + 1];       /* name of this symbol          */
  39     int level;                  /* nest level for this symbol   */
  40     int block;                  /* belongs to which block */
  41     struct bucket *prev;        /* ptr 2 previous bucket   */
  42     struct bucket *next;        /* ptr 2 next bucket       */
  43   }
  44 bucket;
  45
  46 typedef struct structdef
  47   {
  48     char tag[SDCC_NAME_MAX + 1];        /* tag part of structure      */
  49     unsigned char level;        /* Nesting level         */
  50     struct symbol *fields;      /* pointer to fields     */
  51     unsigned size;              /* sizeof the table in bytes  */
  52   }
  53 structdef;
  54
  55 /* noun definitions */
  56 typedef enum
  57   {
  58     V_INT = 0,
  59     V_FLOAT,
  60     V_CHAR,
  61     V_VOID,
  62     V_STRUCT,
  63     V_LABEL,
  64     V_BIT,
  65     V_SBIT
  66   }
  67 NOUN;
  68
  69 /* storage class    */
  70 typedef enum
  71   {
  72     S_FIXED = 0,
  73     S_AUTO,
  74     S_REGISTER,
  75     S_CONSTANT,
  76     S_SFR,
  77     S_SBIT,
  78     S_CODE,
  79     S_XDATA,
  80     S_DATA,
  81     S_IDATA,
  82     S_PDATA,
  83     S_LITERAL,
  84     S_STACK,
  85     S_XSTACK,
  86     S_BIT,
  87     S_EEPROM
  88   }
  89 STORAGE_CLASS;
  90
  91 #define TF_LONG     0x00000001             /* type long int */
  92 #define TF_SHORT    0x00000002             /* type short    */
  93 #define TF_UNSIGNED 0x00000004             /* type is unsigned */
  94 #define TF_STATIC   0x00000008             /* type is static   */
  95 #define TF_EXTERN   0x00000010             /* type is extern   */
  96 #define TF_ABSADDR  0x00000020             /* type has absolute address */
  97 #define TF_REENT    0x00000040             /* type of func is reentrant func */
  98 #define TF_INTRRNT  0x00000080             /* is an interrupt routine */
  99
 100 /* specifier is the last in the type-chain */
 101 typedef struct specifier
 102   {
 103     NOUN noun;                  /* CHAR INT STRUCTURE LABEL   */
 104     STORAGE_CLASS sclass;       /* REGISTER,AUTO,FIX,CONSTANT */
 105     struct memmap *oclass;      /* output storage class       */
 106     unsigned _long:1;           /* 1=long            */
 107     unsigned _short:1;          /* 1=short int    */
 108     unsigned _unsigned:1;       /* 1=unsigned, 0=signed       */
 109     unsigned _static:1;         /* 1=static keyword found     */
 110     unsigned _extern:1;         /* 1=extern found             */
 111     unsigned _absadr:1;         /* absolute address specfied  */
 112     unsigned _reent:1;          /* function is reentrant      */
 113     unsigned _intrtn:1;         /* this is an interrupt routin */
 114     unsigned _rbank:1;          /* seperate register bank     */
 115     unsigned _volatile:1;       /* is marked as volatile      */
 116     unsigned _const:1;          /* is a constant              */
 117     unsigned _critical:1;       /* critical function          */
 118     unsigned _typedef:1;        /* is typedefed               */
 119     unsigned _isregparm:1;      /* is the first parameter     */
 120     unsigned _isenum:1;         /* is an enumerated type      */
 121     unsigned nonbanked:1;       /* function has the nonbanked attribute */
 122     unsigned banked:1;          /* function has the banked attribute */
 123     unsigned _IntNo;            /* 1=Interrupt svc routine    */
 124     short _regbank;             /* register bank 2b used      */
 125     unsigned _addr;             /* address of symbol          */
 126     unsigned _stack;            /* stack offset for stacked v */
 127     unsigned _bitStart;         /* bit start position         */
 128     int _bitLength;             /* bit length                 */
 129
 130     union
 131       {                         /* Values if constant or enum */
 132         int v_int;              /* int and char values        */
 133         char *v_char;           /* character string           */
 134         unsigned v_uint;        /* unsigned int const value   */
 135         long v_long;            /* long constant value        */
 136         unsigned long v_ulong;  /* unsigned long constant val */
 137         double v_float;         /* floating point constant value */
 138         struct symbol *v_enum;  /* ptr 2 enum_list if enum==1 */
 139       }
 140     const_val;
 141     struct structdef *v_struct; /* structure pointer      */
 142   }
 143 specifier;
 144
 145 /* types of declarators */
 146 typedef enum
 147   {
 148     POINTER = 0,                /* pointer to near data */
 149     FPOINTER,                   /* pointer to far data  */
 150     CPOINTER,                   /* pointer to code space */
 151     GPOINTER,                   /* _generic pointer     */
 152     PPOINTER,                   /* paged area pointer   */
 153     IPOINTER,                   /* pointer to upper 128 bytes */
 154     UPOINTER,                   /* unknown pointer used only when parsing */
 155     EEPPOINTER,                 /* pointer to eeprom     */
 156     ARRAY,
 157     FUNCTION
 158   }
 159 DECLARATOR_TYPE;
 160
 161 typedef struct declarator
 162   {
 163     DECLARATOR_TYPE dcl_type;   /* POINTER,ARRAY or FUNCTION  */
 164     unsigned int num_elem;      /* # of elems if type==array  */
 165     short ptr_const:1;          /* pointer is constant        */
 166     short ptr_volatile:1;       /* pointer is volatile        */
 167     struct sym_link *tspec;     /* pointer type specifier      */
 168   }
 169 declarator;
 170
 171 #define DECLARATOR   0
 172 #define SPECIFIER    1
 173
 174 typedef struct sym_link
 175   {
 176     unsigned class:1;           /* DECLARATOR or SPECIFIER    */
 177     unsigned tdef:1;            /* current link created by    */
 178     /* typedef if this flag is set */
 179     union
 180       {
 181         specifier s;            /* if CLASS == SPECIFIER      */
 182         declarator d;           /* if CLASS == DECLARATOR     */
 183       }
 184     select;
 185
 186     struct sym_link *next;      /* next element on the chain  */
 187   }
 188 sym_link;
 189
 190 typedef struct symbol
 191   {
 192     char name[SDCC_NAME_MAX + 1];       /* Input Variable Name     */
 193     char rname[SDCC_NAME_MAX + 1];      /* internal name           */
 194
 195     short level;                /* declration lev,fld offset */
 196     short block;                /* sequential block # of defintion */
 197     int key;
 198     unsigned fbody:1;           /* function body defined             */
 199     unsigned implicit:1;        /* implicit flag                     */
 200     unsigned undefined:1;       /* undefined variable                */
 201     unsigned ret:1;             /* return statement for a function   */
 202     unsigned hasVargs:1;        /* has a variable argument list      */
 203     unsigned _isparm:1;         /* is a parameter          */
 204     unsigned ismyparm:1;        /* is parameter of the function being generated */
 205     unsigned isitmp:1;          /* is an intermediate temp */
 206     unsigned islbl:1;           /* is a temporary label */
 207     unsigned isref:1;           /* has been referenced  */
 208     unsigned isind:1;           /* is a induction variable */
 209     unsigned isinvariant:1;     /* is a loop invariant  */
 210     unsigned isstrlit:1;        /* is a string literal  */
 211     unsigned cdef:1;            /* compiler defined symbol */
 212     unsigned allocreq:1;        /* allocation is required for this variable */
 213     unsigned addrtaken:1;       /* address of the symbol was taken */
 214     unsigned isreqv:1;          /* is the register quivalent of a symbol */
 215     unsigned hasFcall:1;        /* for functions does it call other functions */
 216     unsigned calleeSave:1;      /* for functions uses callee save paradigm */
 217     unsigned udChked:1;         /* use def checking has been already done */
 218
 219     /* following flags are used by the backend
 220        for code generation and can be changed
 221        if a better scheme for backend is thought of */
 222     unsigned isLiveFcall:1;     /* is live at or across a function call */
 223     unsigned isspilt:1;         /* has to be spilt */
 224     unsigned remat:1;           /* can be remateriazed */
 225     unsigned isptr:1;           /* is a pointer */
 226     unsigned uptr:1;            /* used as a pointer */
 227     unsigned isFree:1;          /* used by register allocator */
 228     unsigned islocal:1;         /* is a local variable        */
 229     unsigned blockSpil:1;       /* spilt at block level       */
 230     unsigned remainSpil:1;      /* spilt because not used in remainder */
 231     unsigned stackSpil:1;       /* has been spilt on temp stack location */
 232     unsigned onStack:1;         /* this symbol allocated on the stack */
 233     unsigned iaccess:1;         /* indirect access      */
 234     unsigned ruonly:1;          /* used in return statement only */
 235     unsigned spildir:1;         /* spilt in direct space */
 236     unsigned ptrreg:1;          /* this symbol assigned to a ptr reg */
 237     unsigned accuse;            /* can be left in the accumulator
 238                                    On the Z80 accuse is devided into
 239                                    ACCUSE_A and ACCUSE_HL as the idea
 240                                    is quite similar.
 241                                  */
 242
 243     int stack;                  /* offset on stack      */
 244     int xstack;                 /* offset on xternal stack */
 245     short nRegs;                /* number of registers required */
 246     short regType;              /* type of register required    */
 247
 248     struct regs *regs[4];       /* can have at the most 4 registers */
 249     struct asmop *aop;          /* asmoperand for this symbol */
 250     struct iCode *fuse;         /* furthest use */
 251     struct iCode *rematiCode;   /* rematerialse with which instruction */
 252     struct operand *reqv;       /* register equivalent of a local variable */
 253     union
 254       {
 255         struct symbol *spillLoc;        /* register spil location */
 256         struct set *itmpStack;  /* symbols spilt @ this stack location */
 257       }
 258     usl;
 259     short bitVar;               /* this is a bit variable    */
 260     unsigned offset;            /* offset from top if struct */
 261
 262     int lineDef;                /* defined line number        */
 263     int lastLine;               /* for functions the last line */
 264     struct sym_link *type;      /* 1st link to declator chain */
 265     struct sym_link *etype;     /* last link to declarator chn */
 266     struct value *args;         /* arguments if function      */
 267     struct symbol *next;        /* crosslink to next symbol   */
 268     struct symbol *localof;     /* local variable of which function */
 269     struct initList *ival;      /* ptr to initializer if any  */
 270     struct bitVect *defs;       /* bit vector for definitions */
 271     struct bitVect *uses;       /* bit vector for uses        */
 272     struct bitVect *regsUsed;   /* for functions registers used */
 273     int liveFrom;               /* live from iCode sequence number */
 274     int liveTo;                 /* live to sequence number */
 275     int used;                   /* no. of times this was used */
 276     int recvSize;               /* size of first argument  */
 277   }
 278 symbol;
 279
 280 /* Easy Access Macros */
 281 #define DCL_TYPE(l)  l->select.d.dcl_type
 282 #define DCL_ELEM(l)  l->select.d.num_elem
 283 #define DCL_PTR_CONST(l) l->select.d.ptr_const
 284 #define DCL_PTR_VOLATILE(l) l->select.d.ptr_volatile
 285 #define DCL_TSPEC(l) l->select.d.tspec
 286 #define SPEC_NOUN(x) x->select.s.noun
 287 #define SPEC_LONG(x) x->select.s._long
 288 #define SPEC_SHORT(x) x->select.s._short
 289 #define SPEC_USIGN(x) x->select.s._unsigned
 290 #define SPEC_SCLS(x) x->select.s.sclass
 291 #define SPEC_ENUM(x) x->select.s._isenum
 292 #define SPEC_OCLS(x) x->select.s.oclass
 293 #define SPEC_STAT(x) x->select.s._static
 294 #define SPEC_EXTR(x) x->select.s._extern
 295 #define SPEC_CODE(x) x->select.s._codesg
 296 #define SPEC_RENT(x) x->select.s._reent
 297 #define SPEC_INTN(x) x->select.s._IntNo
 298 #define SPEC_ABSA(x) x->select.s._absadr
 299 #define SPEC_BANK(x) x->select.s._regbank
 300 #define SPEC_ADDR(x) x->select.s._addr
 301 #define SPEC_STAK(x) x->select.s._stack
 302 #define SPEC_CVAL(x) x->select.s.const_val
 303 #define SPEC_BSTR(x) x->select.s._bitStart
 304 #define SPEC_BLEN(x) x->select.s._bitLength
 305
 306 /* Sleaze: SPEC_ISR_SAVED_BANKS is only used on
 307  * function type symbols, which obviously cannot
 308  * be of BIT type. Therefore, we recycle the
 309  * _bitStart field instead of defining a new field.
 310  */
 311 #define SPEC_ISR_SAVED_BANKS(x) x->select.s._bitStart
 312 #define SPEC_BNKF(x) x->select.s._rbank
 313 #define SPEC_INTRTN(x) x->select.s._intrtn
 314 #define SPEC_CRTCL(x) x->select.s._critical
 315 #define SPEC_VOLATILE(x) x->select.s._volatile
 316 #define SPEC_CONST(x) x->select.s._const
 317 #define SPEC_STRUCT(x) x->select.s.v_struct
 318 #define SPEC_TYPEDEF(x) x->select.s._typedef
 319 #define SPEC_REGPARM(x) x->select.s._isregparm
 320 #define SPEC_NONBANKED(x) x->select.s.nonbanked
 321 #define SPEC_BANKED(x) x->select.s.banked
 322
 323 /* type check macros */
 324 #define IS_DECL(x)   ( x && x->class == DECLARATOR      )
 325 #define IS_SPEC(x)   ( x && x->class == SPECIFIER  )
 326 #define IS_ARRAY(x)  (IS_DECL(x) && DCL_TYPE(x) == ARRAY)
 327 #define IS_DATA_PTR(x) (IS_DECL(x) && DCL_TYPE(x) == POINTER)
 328 #define IS_PTR(x)    (IS_DECL(x) && (DCL_TYPE(x) == POINTER    ||    \
 329                                      DCL_TYPE(x) == FPOINTER   ||    \
 330                                      DCL_TYPE(x) == GPOINTER   ||    \
 331                                      DCL_TYPE(x) == IPOINTER   ||    \
 332                                      DCL_TYPE(x) == PPOINTER   ||    \
 333                                      DCL_TYPE(x) == EEPPOINTER ||    \
 334                                      DCL_TYPE(x) == CPOINTER   ||    \
 335                                      DCL_TYPE(x) == UPOINTER  ))
 336 #define IS_PTR_CONST(x) (IS_PTR(x) && DCL_PTR_CONST(x))
 337 #define IS_FARPTR(x) (IS_DECL(x) && DCL_TYPE(x) == FPOINTER)
 338 #define IS_GENPTR(x) (IS_DECL(x) && DCL_TYPE(x) == GPOINTER)
 339 #define IS_FUNC(x)   (IS_DECL(x) && DCL_TYPE(x) == FUNCTION)
 340 #define IS_LONG(x)   (IS_SPEC(x) && x->select.s._long)
 341 #define IS_SHORT(x)   (IS_SPEC(x) && x->select.s._short)
 342 #define IS_TYPEDEF(x)(IS_SPEC(x) && x->select.s._typedef)
 343 #define IS_CONSTANT(x)  (IS_SPEC(x) && ( x->select.s._const == 1))
 344 #define IS_STRUCT(x) (IS_SPEC(x) && x->select.s.noun == V_STRUCT)
 345 #define IS_ABSOLUTE(x)  (IS_SPEC(x) && x->select.s._absadr )
 346 #define IS_REGISTER(x)  (IS_SPEC(x) && SPEC_SCLS(x) == S_REGISTER)
 347 #define IS_RENT(x)   (IS_SPEC(x) && x->select.s._reent )
 348 #define IS_STATIC(x) (IS_SPEC(x) && SPEC_STAT(x))
 349 #define IS_INT(x)    (IS_SPEC(x) && x->select.s.noun == V_INT)
 350 #define IS_VOID(x)   (IS_SPEC(x) && x->select.s.noun == V_VOID)
 351 #define IS_CHAR(x)   (IS_SPEC(x) && x->select.s.noun == V_CHAR)
 352 #define IS_EXTERN(x)    (IS_SPEC(x) && x->select.s._extern)
 353 #define IS_VOLATILE(x)  (IS_SPEC(x) && x->select.s._volatile )
 354 #define IS_INTEGRAL(x) (IS_SPEC(x) && (x->select.s.noun == V_INT ||  \
 355                                        x->select.s.noun == V_CHAR || \
 356                                        x->select.s.noun == V_BIT ||  \
 357                                        x->select.s.noun == V_SBIT ))
 358 #define IS_BITFIELD(x) (IS_SPEC(x) && (x->select.s.noun == V_BIT))
 359 #define IS_BITVAR(x) (IS_SPEC(x) && (x->select.s.noun  == V_BIT ||   \
 360                                      x->select.s.noun == V_SBIT ))
 361 #define IS_FLOAT(x)  (IS_SPEC(x) && x->select.s.noun == V_FLOAT)
 362 #define IS_ARITHMETIC(x) (IS_INTEGRAL(x) || IS_FLOAT(x))
 363 #define IS_AGGREGATE(x) (IS_ARRAY(x) || IS_STRUCT(x))
 364 #define IS_LITERAL(x)   (IS_SPEC(x)  && x->select.s.sclass == S_LITERAL)
 365 #define IS_ISR(x)       (IS_SPEC(x)  && SPEC_INTRTN(x))
 366 #define IS_REGPARM(x)   (IS_SPEC(x) && SPEC_REGPARM(x))
 367 #define IS_NONBANKED(x) (IS_SPEC(x) && SPEC_NONBANKED(x))
 368 #define IS_BANKED(x)    (IS_SPEC(x) && SPEC_BANKED(x))
 369 #define IS_BANKEDCALL(x) (IS_SPEC(x) && !SPEC_NONBANKED(x) && !SPEC_STAT(x) && (options.model == MODEL_LARGE || options.model == MODEL_MEDIUM || SPEC_BANKED(x)))
 370
 371 /* forward declaration for the global vars */
 372 extern bucket *SymbolTab[];
 373 extern bucket *StructTab[];
 374 extern bucket *TypedefTab[];
 375 extern bucket *LabelTab[];
 376 extern bucket *enumTab[];
 377 extern symbol *__fsadd;
 378 extern symbol *__fssub;
 379 extern symbol *__fsmul;
 380 extern symbol *__fsdiv;
 381 extern symbol *__fseq;
 382 extern symbol *__fsneq;
 383 extern symbol *__fslt;
 384 extern symbol *__fslteq;
 385 extern symbol *__fsgt;
 386 extern symbol *__fsgteq;
 387
 388 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
 389 extern symbol *__muldiv[3][3][2];
 390 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
 391 extern sym_link *__multypes[3][2];
 392 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
 393 extern symbol *__conv[2][3][2];
 394
 395 #define CHARTYPE        __multypes[0][0]
 396 #define UCHARTYPE       __multypes[0][1]
 397 #define INTTYPE         __multypes[1][0]
 398 #define UINTTYPE        __multypes[1][1]
 399 #define LONGTYPE        __multypes[2][0]
 400 #define ULONGTYPE       __multypes[2][1]
 401
 402
 403 extern sym_link *floatType;
 404
 405 #include "SDCCval.h"
 406
 407 /* forward definitions for the symbol table related functions */
 408 void initSymt ();
 409 symbol *newSymbol (char *, int);
 410 sym_link *newLink ();
 411 sym_link *newFloatLink ();
 412 structdef *newStruct (char *);
 413 void addDecl (symbol *, int, sym_link *);
 414 sym_link *mergeSpec (sym_link *, sym_link *);
 415 sym_link *cloneSpec (sym_link *);
 416 symbol *reverseSyms (symbol *);
 417 sym_link *reverseLink (sym_link *);
 418 symbol *copySymbol (symbol *);
 419 symbol *copySymbolChain (symbol *);
 420 void printSymChain (symbol *, int);
 421 void printStruct (structdef *, int);
 422 char *genSymName (int);
 423 sym_link *getSpec (sym_link *);
 424 char *genSymName (int);
 425 int compStructSize (int, structdef *);
 426 sym_link *copyLinkChain (sym_link *);
 427 int checkDecl (symbol *);
 428 void checkBasic (sym_link *, sym_link *);
 429 value *checkPointerIval (sym_link *, value *);
 430 value *checkStructIval (symbol *, value *);
 431 value *checkArrayIval (sym_link *, value *);
 432 value *checkIval (sym_link *, value *);
 433 unsigned int getSize (sym_link *);
 434 unsigned int bitsForType (sym_link *);
 435 sym_link *newIntLink ();
 436 sym_link *newCharLink ();
 437 sym_link *newLongLink ();
 438 int checkType (sym_link *, sym_link *);
 439 int checkFunction (symbol *);
 440 void cleanUpLevel (bucket **, int);
 441 void cleanUpBlock (bucket **, int);
 442 int funcInChain (sym_link *);
 443 void addSymChain (symbol *);
 444 sym_link *structElemType (sym_link *, value *, value **);
 445 symbol *getStructElement (structdef *, symbol *);
 446 sym_link *computeType (sym_link *, sym_link *);
 447 void processFuncArgs (symbol *, int);
 448 int isSymbolEqual (symbol *, symbol *);
 449 int powof2 (unsigned long);
 450 void printTypeChain (sym_link *, FILE *);
 451 void initCSupport ();
 452 void pointerTypes (sym_link *, sym_link *);
 453 void cdbTypeInfo (sym_link *, FILE *);
 454 void cdbSymbol (symbol *, FILE *, int, int);
 455 void cdbStructBlock (int, FILE *);
 456 void initHashT ();
 457 bucket *newBucket ();
 458 void addSym (bucket **, void *, char *, int, int);
 459 void deleteSym (bucket **, void *, char *);
 460 void *findSym (bucket **, void *, const char *);
 461 void *findSymWithLevel (bucket **, struct symbol *);
 462 void *findSymWithBlock (bucket **, struct symbol *, int);
 463 void changePointer (symbol * sym);
 464
 465 #include "SDCCmem.h"
 466
 467 #endif