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 #define SPEC_BNKF(x) x->select.s._rbank
 306 #define SPEC_INTRTN(x) x->select.s._intrtn
 307 #define SPEC_CRTCL(x) x->select.s._critical
 308 #define SPEC_VOLATILE(x) x->select.s._volatile
 309 #define SPEC_CONST(x) x->select.s._const
 310 #define SPEC_STRUCT(x) x->select.s.v_struct
 311 #define SPEC_TYPEDEF(x) x->select.s._typedef
 312 #define SPEC_REGPARM(x) x->select.s._isregparm
 313 #define SPEC_NONBANKED(x) x->select.s.nonbanked
 314 #define SPEC_BANKED(x) x->select.s.banked
 315
 316 /* type check macros */
 317 #define IS_DECL(x)   ( x && x->class == DECLARATOR      )
 318 #define IS_SPEC(x)   ( x && x->class == SPECIFIER  )
 319 #define IS_ARRAY(x)  (IS_DECL(x) && DCL_TYPE(x) == ARRAY)
 320 #define IS_DATA_PTR(x) (IS_DECL(x) && DCL_TYPE(x) == POINTER)
 321 #define IS_PTR(x)    (IS_DECL(x) && (DCL_TYPE(x) == POINTER    ||    \
 322                                      DCL_TYPE(x) == FPOINTER   ||    \
 323                                      DCL_TYPE(x) == GPOINTER   ||    \
 324                                      DCL_TYPE(x) == IPOINTER   ||    \
 325                                      DCL_TYPE(x) == PPOINTER   ||    \
 326                                      DCL_TYPE(x) == EEPPOINTER ||    \
 327                                      DCL_TYPE(x) == CPOINTER   ||    \
 328                                      DCL_TYPE(x) == UPOINTER  ))
 329 #define IS_PTR_CONST(x) (IS_PTR(x) && DCL_PTR_CONST(x))
 330 #define IS_FARPTR(x) (IS_DECL(x) && DCL_TYPE(x) == FPOINTER)
 331 #define IS_GENPTR(x) (IS_DECL(x) && DCL_TYPE(x) == GPOINTER)
 332 #define IS_FUNC(x)   (IS_DECL(x) && DCL_TYPE(x) == FUNCTION)
 333 #define IS_LONG(x)   (IS_SPEC(x) && x->select.s._long)
 334 #define IS_SHORT(x)   (IS_SPEC(x) && x->select.s._short)
 335 #define IS_TYPEDEF(x)(IS_SPEC(x) && x->select.s._typedef)
 336 #define IS_CONSTANT(x)  (IS_SPEC(x) && ( x->select.s._const == 1))
 337 #define IS_STRUCT(x) (IS_SPEC(x) && x->select.s.noun == V_STRUCT)
 338 #define IS_ABSOLUTE(x)  (IS_SPEC(x) && x->select.s._absadr )
 339 #define IS_REGISTER(x)  (IS_SPEC(x) && SPEC_SCLS(x) == S_REGISTER)
 340 #define IS_RENT(x)   (IS_SPEC(x) && x->select.s._reent )
 341 #define IS_STATIC(x) (IS_SPEC(x) && SPEC_STAT(x))
 342 #define IS_INT(x)    (IS_SPEC(x) && x->select.s.noun == V_INT)
 343 #define IS_VOID(x)   (IS_SPEC(x) && x->select.s.noun == V_VOID)
 344 #define IS_CHAR(x)   (IS_SPEC(x) && x->select.s.noun == V_CHAR)
 345 #define IS_EXTERN(x)    (IS_SPEC(x) && x->select.s._extern)
 346 #define IS_VOLATILE(x)  (IS_SPEC(x) && x->select.s._volatile )
 347 #define IS_INTEGRAL(x) (IS_SPEC(x) && (x->select.s.noun == V_INT ||  \
 348                                        x->select.s.noun == V_CHAR || \
 349                                        x->select.s.noun == V_BIT ||  \
 350                                        x->select.s.noun == V_SBIT ))
 351 #define IS_BITFIELD(x) (IS_SPEC(x) && (x->select.s.noun == V_BIT))
 352 #define IS_BITVAR(x) (IS_SPEC(x) && (x->select.s.noun  == V_BIT ||   \
 353                                      x->select.s.noun == V_SBIT ))
 354 #define IS_FLOAT(x)  (IS_SPEC(x) && x->select.s.noun == V_FLOAT)
 355 #define IS_ARITHMETIC(x) (IS_INTEGRAL(x) || IS_FLOAT(x))
 356 #define IS_AGGREGATE(x) (IS_ARRAY(x) || IS_STRUCT(x))
 357 #define IS_LITERAL(x)   (IS_SPEC(x)  && x->select.s.sclass == S_LITERAL)
 358 #define IS_ISR(x)       (IS_SPEC(x)  && SPEC_INTRTN(x))
 359 #define IS_REGPARM(x)   (IS_SPEC(x) && SPEC_REGPARM(x))
 360 #define IS_NONBANKED(x) (IS_SPEC(x) && SPEC_NONBANKED(x))
 361 #define IS_BANKED(x)    (IS_SPEC(x) && SPEC_BANKED(x))
 362 #define IS_BANKEDCALL(x) (IS_SPEC(x) && !SPEC_NONBANKED(x) && !SPEC_STAT(x) && (options.model == MODEL_LARGE || options.model == MODEL_MEDIUM || SPEC_BANKED(x)))
 363
 364 /* forward declaration for the global vars */
 365 extern bucket *SymbolTab[];
 366 extern bucket *StructTab[];
 367 extern bucket *TypedefTab[];
 368 extern bucket *LabelTab[];
 369 extern bucket *enumTab[];
 370 extern symbol *__fsadd;
 371 extern symbol *__fssub;
 372 extern symbol *__fsmul;
 373 extern symbol *__fsdiv;
 374 extern symbol *__fseq;
 375 extern symbol *__fsneq;
 376 extern symbol *__fslt;
 377 extern symbol *__fslteq;
 378 extern symbol *__fsgt;
 379 extern symbol *__fsgteq;
 380
 381 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
 382 extern symbol *__muldiv[3][3][2];
 383 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
 384 extern sym_link *__multypes[3][2];
 385 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
 386 extern symbol *__conv[2][3][2];
 387
 388 #define CHARTYPE        __multypes[0][0]
 389 #define UCHARTYPE       __multypes[0][1]
 390 #define INTTYPE         __multypes[1][0]
 391 #define UINTTYPE        __multypes[1][1]
 392 #define LONGTYPE        __multypes[2][0]
 393 #define ULONGTYPE       __multypes[2][1]
 394
 395
 396 extern sym_link *floatType;
 397
 398 #include "SDCCval.h"
 399
 400 /* forward definitions for the symbol table related functions */
 401 void initSymt ();
 402 symbol *newSymbol (char *, int);
 403 sym_link *newLink ();
 404 sym_link *newFloatLink ();
 405 structdef *newStruct (char *);
 406 void addDecl (symbol *, int, sym_link *);
 407 sym_link *mergeSpec (sym_link *, sym_link *);
 408 sym_link *cloneSpec (sym_link *);
 409 symbol *reverseSyms (symbol *);
 410 sym_link *reverseLink (sym_link *);
 411 symbol *copySymbol (symbol *);
 412 symbol *copySymbolChain (symbol *);
 413 void printSymChain (symbol *, int);
 414 void printStruct (structdef *, int);
 415 char *genSymName (int);
 416 sym_link *getSpec (sym_link *);
 417 char *genSymName (int);
 418 int compStructSize (int, structdef *);
 419 sym_link *copyLinkChain (sym_link *);
 420 int checkDecl (symbol *);
 421 void checkBasic (sym_link *, sym_link *);
 422 value *checkPointerIval (sym_link *, value *);
 423 value *checkStructIval (symbol *, value *);
 424 value *checkArrayIval (sym_link *, value *);
 425 value *checkIval (sym_link *, value *);
 426 unsigned int getSize (sym_link *);
 427 unsigned int bitsForType (sym_link *);
 428 sym_link *newIntLink ();
 429 sym_link *newCharLink ();
 430 sym_link *newLongLink ();
 431 int checkType (sym_link *, sym_link *);
 432 int checkFunction (symbol *);
 433 void cleanUpLevel (bucket **, int);
 434 void cleanUpBlock (bucket **, int);
 435 int funcInChain (sym_link *);
 436 void addSymChain (symbol *);
 437 sym_link *structElemType (sym_link *, value *, value **);
 438 symbol *getStructElement (structdef *, symbol *);
 439 sym_link *computeType (sym_link *, sym_link *);
 440 void processFuncArgs (symbol *, int);
 441 int isSymbolEqual (symbol *, symbol *);
 442 int powof2 (unsigned long);
 443 void printTypeChain (sym_link *, FILE *);
 444 void initCSupport ();
 445 void pointerTypes (sym_link *, sym_link *);
 446 void cdbTypeInfo (sym_link *, FILE *);
 447 void cdbSymbol (symbol *, FILE *, int, int);
 448 void cdbStructBlock (int, FILE *);
 449 void initHashT ();
 450 bucket *newBucket ();
 451 void addSym (bucket **, void *, char *, int, int);
 452 void deleteSym (bucket **, void *, char *);
 453 void *findSym (bucket **, void *, const char *);
 454 void *findSymWithLevel (bucket **, struct symbol *);
 455 void *findSymWithBlock (bucket **, struct symbol *, int);
 456 void changePointer (symbol * sym);
 457
 458 #include "SDCCmem.h"
 459
 460 #endif