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

   1 /*-------------------------------------------------------------------------
   2
   3   SDCCicode.h - intermediate code generation etc.
   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 #include "SDCCbitv.h"
  25 #include "SDCCset.h"
  26
  27 #ifndef SDCCICODE_H
  28 #define SDCCICODE_H 1
  29
  30 extern symbol *returnLabel;
  31 extern symbol *entryLabel;
  32 extern int iCodeKey;
  33 extern int operandKey;
  34
  35 enum
  36   {
  37     CONDITIONAL = 0,
  38     EXPRESSION,
  39     STATEMENT,
  40     LEAF
  41   };
  42
  43 typedef enum
  44   {
  45     SYMBOL = 1,
  46     VALUE,
  47     TYPE
  48   }
  49 OPTYPE;
  50
  51 #define IS_SYMOP(op) (op && op->type == SYMBOL)
  52 #define IS_VALOP(op) (op && op->type == VALUE)
  53 #define IS_TYPOP(op) (op && op->type == TYPE)
  54
  55 #define ADDTOCHAIN(x) addSetHead(&iCodeChain,x)
  56
  57 #define LRFTYPE       sym_link *ltype = operandType(left), \
  58                            *rtype = operandType(right) ;
  59 #define LRETYPE       sym_link *letype= getSpec(ltype)   , \
  60                            *retype= getSpec(rtype);
  61 #define LRTYPE        LRFTYPE LRETYPE
  62 #define IS_ITEMP(op)       (IS_SYMOP(op) && op->operand.symOperand->isitmp == 1)
  63 #define IS_PARM(op)        (IS_SYMOP(op) && op->operand.symOperand->_isparm)
  64 #define IS_ITEMPLBL(op)    (IS_ITEMP(op) && op->operand.symOperand->isilbl == 1);
  65 #define IS_OP_VOLATILE(op) (IS_SYMOP(op) && op->isvolatile)
  66 #define IS_OP_LITERAL(op)  (op && op->isLiteral)
  67 #define IS_OP_GLOBAL(op)   (IS_SYMOP(op) && op->isGlobal)
  68 #define IS_OP_POINTER(op)  (IS_SYMOP(op) && op->isPtr)
  69 #define IS_OP_PARM(op)     (IS_SYMOP(op) && op->isParm)
  70 #define OP_ISLIVE_FCALL(op) (IS_ITEMP(op) && OP_SYMBOL(op)->isLiveFcall)
  71 #define SYM_SPIL_LOC(sym)  sym->usl.spillLoc
  72
  73 /* typedef for operand */
  74 typedef struct operand
  75   {
  76     OPTYPE type;                /* type of operand */
  77     unsigned int isaddr:1;      /* is an address   */
  78     unsigned int aggr2ptr:1;    /* must change aggregate to pointer to aggregate */
  79     unsigned int isvolatile:1;  /* is a volatile operand */
  80     unsigned int isGlobal:1;    /* is a global operand */
  81     unsigned int isPtr:1;       /* is assigned a pointer */
  82     unsigned int isGptr:1;      /* is a generic pointer  */
  83     unsigned int isParm:1;      /* is a parameter        */
  84     unsigned int isLiteral:1;   /* operand is literal    */
  85
  86     int key;
  87     union
  88       {
  89         struct symbol *symOperand;      /* operand is of type symbol */
  90         struct value *valOperand;       /* operand is of type value  */
  91         struct sym_link *typeOperand;   /* operand is of type typechain */
  92       }
  93     operand;
  94
  95     bitVect *usesDefs;          /* which definitions are used by this */
  96     struct asmop *aop;          /* asm op for this operand */
  97   }
  98 operand;
  99
 100 extern operand *validateOpType(operand          *op,
 101                                const char       *macro,
 102                                const char       *args,
 103                                OPTYPE           type,
 104                                const char       *file,
 105                                unsigned         line);
 106
 107 #define OP_SYMBOL(op) validateOpType(op, "OP_SYMBOL", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand
 108 #define OP_VALUE(op)  validateOpType(op, "OP_VALUE", #op, VALUE, __FILE__, __LINE__)->operand.valOperand
 109 #define OP_SYM_TYPE(op)    validateOpType(op, "OP_SYM_TYPE", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand->type
 110 #define OP_SYM_ETYPE(op)   validateOpType(op, "OP_SYM_ETYPE", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand->etype
 111 #define SPIL_LOC(op)       validateOpType(op, "SPIL_LOC", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand->usl.spillLoc
 112 #define OP_LIVEFROM(op)    validateOpType(op, "OP_LIVEFROM", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand->liveFrom
 113 #define OP_LIVETO(op)      validateOpType(op, "OP_LIVETO", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand->liveTo
 114 #define OP_REQV(op)        validateOpType(op, "OP_REQV", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand->reqv
 115
 116 /* definition for intermediate code */
 117 #define IC_RESULT(x) (x)->ulrrcnd.lrr.result
 118 #define IC_LEFT(x)   (x)->ulrrcnd.lrr.left
 119 #define IC_RIGHT(x)  (x)->ulrrcnd.lrr.right
 120 #define IC_COND(x)   (x)->ulrrcnd.cnd.condition
 121 #define IC_TRUE(x)   (x)->ulrrcnd.cnd.trueLabel
 122 #define IC_FALSE(x)  (x)->ulrrcnd.cnd.falseLabel
 123 #define IC_LABEL(x)  (x)->label
 124 #define IC_JTCOND(x) (x)->ulrrcnd.jmpTab.condition
 125 #define IC_JTLABELS(x) (x)->ulrrcnd.jmpTab.labels
 126 #define IC_INLINE(x) (x)->inlineAsm
 127 #define IC_ARRAYILIST(x) (x)->arrayInitList
 128
 129 typedef struct iCode
 130   {
 131     unsigned int op;            /* operation defined */
 132     int key;                    /* running key for this iCode */
 133     int seq;                    /* sequence number within routine */
 134     int seqPoint;               /* sequence point */
 135     short depth;                /* loop depth of this iCode */
 136     short level;                /* scope level */
 137     short block;                /* sequential block number */
 138     unsigned nosupdate:1;       /* don't update spillocation with this */
 139     unsigned generated:1;       /* code generated for this one */
 140     unsigned parmPush:1;        /* parameter push Vs spill push */
 141     unsigned supportRtn:1;      /* will cause a call to a support routine */
 142     unsigned regsSaved:1;       /* registers have been saved */
 143     unsigned bankSaved:1;       /* register bank has been saved */
 144     unsigned builtinSEND:1;     /* SEND for parameter of builtin function */
 145
 146     struct iCode *next;         /* next in chain */
 147     struct iCode *prev;         /* previous in chain */
 148     set *movedFrom;             /* if this iCode gets moved to another block */
 149     bitVect *rlive;             /* ranges that are live at this point */
 150     int defKey;                 /* key for the operand being defined  */
 151     bitVect *uses;              /* vector of key of used symbols      */
 152     bitVect *rUsed;             /* registers used by this instruction */
 153     bitVect *rMask;             /* registers in use during this instruction */
 154     union
 155       {
 156         struct
 157           {
 158             operand *left;      /* left if any   */
 159             operand *right;     /* right if any  */
 160             operand *result;    /* result of this op */
 161           }
 162         lrr;
 163
 164         struct
 165           {
 166             operand *condition; /* if this is a conditional */
 167             symbol *trueLabel;  /* true for conditional     */
 168             symbol *falseLabel; /* false for conditional    */
 169           }
 170         cnd;
 171
 172         struct
 173           {
 174             operand *condition; /* condition for the jump */
 175             set *labels;        /* ordered set of labels  */
 176           }
 177         jmpTab;
 178
 179       }
 180     ulrrcnd;
 181
 182     symbol *label;              /* for a goto statement     */
 183
 184     char *inlineAsm;            /* pointer to inline assembler code */
 185     literalList *arrayInitList; /* point to array initializer list. */
 186
 187     int lineno;                 /* file & lineno for debug information */
 188     char *filename;
 189
 190     int parmBytes;              /* if call/pcall, count of parameter bytes
 191                                    on stack */
 192     int argreg;                 /* argument regno for SEND/RECEIVE */
 193     int eBBlockNum;             /* belongs to which eBBlock */
 194     char riu;                   /* after ralloc, the registers in use */
 195     struct ast * tree;          /* ast node for this iCode (if not NULL) */
 196   }
 197 iCode;
 198
 199 /* various functions associated to iCode */
 200 typedef struct icodeFuncTable
 201   {
 202     int icode;
 203     char *printName;
 204     void (*iCodePrint) (FILE *, iCode *, char *);
 205     iCode *(*iCodeCopy) (iCode *);
 206   }
 207 iCodeTable;
 208
 209 /* useful macros */
 210 #define SKIP_IC2(x)  (x->op == GOTO     ||     \
 211                       x->op == LABEL    ||     \
 212                       x->op == FUNCTION ||     \
 213                       x->op == INLINEASM ||    \
 214                       x->op == ENDFUNCTION   )
 215
 216 #define SKIP_IC1(x)  (x->op == CALL     ||     \
 217                       SKIP_IC2(x) )
 218
 219 #define SKIP_IC(x)   (x->op == PCALL    ||     \
 220                       x->op == IPUSH    ||     \
 221                       x->op == IPOP     ||     \
 222                       x->op == JUMPTABLE ||    \
 223                       x->op == RECEIVE  ||     \
 224                       x->op == ARRAYINIT ||    \
 225                       SKIP_IC1(x)||  \
 226                       x->op == SEND         )
 227
 228 #define SKIP_IC3(x) (SKIP_IC2(x) ||     \
 229                      x->op == JUMPTABLE )
 230
 231 #define IS_CONDITIONAL(x) (x->op == EQ_OP || \
 232                            x->op == '<'   || \
 233                            x->op == '>'   || \
 234                            x->op == LE_OP || \
 235                            x->op == GE_OP || \
 236                            x->op == NE_OP )
 237
 238 #define IS_TRUE_SYMOP(op) (op && IS_SYMOP(op) && !IS_ITEMP(op))
 239
 240 #define POINTER_SET(ic) ( ic && ic->op == '='           \
 241                              && IS_ITEMP(IC_RESULT(ic)) \
 242                              && IC_RESULT(ic)->isaddr )
 243
 244 #define POINTER_GET(ic) ( ic && ic->op == GET_VALUE_AT_ADDRESS  \
 245                              &&  (IS_ITEMP(IC_LEFT(ic)) || IS_OP_LITERAL(IC_LEFT(ic)))\
 246                              &&  IC_LEFT(ic)->isaddr )
 247
 248 #define IS_ARITHMETIC_OP(x) (x && (x->op == '+' || \
 249                                    x->op == '-' || \
 250                                    x->op == '/' || \
 251                                    x->op == '*' || \
 252                                    x->op == '%'))
 253 #define IS_BITWISE_OP(x) (x && (x->op == BITWISEAND || \
 254                                 x->op == '|'        || \
 255                                 x->op == '^'))
 256
 257 #define ASSIGNMENT(ic) ( ic && ic->op == '=')
 258
 259 #define ASSIGN_SYM_TO_ITEMP(ic) (ic && ic->op == '=' && \
 260                              IS_TRUE_SYMOP(IC_RIGHT(ic)) && \
 261                              IS_ITEMP(IC_RESULT(ic)))
 262
 263 #define ASSIGN_ITEMP_TO_SYM(ic) (ic && ic->op == '=' && \
 264                              IS_TRUE_SYMOP(IC_RESULT(ic)) && \
 265                              IS_ITEMP(IC_RIGHT(ic)))
 266
 267 #define ASSIGN_ITEMP_TO_ITEMP(ic) (ic && ic->op == '=' &&\
 268                                    !POINTER_SET(ic)    &&\
 269                                    IS_ITEMP(IC_RIGHT(ic)) &&\
 270                                    IS_ITEMP(IC_RESULT(ic)))
 271
 272 #define ADD_SUBTRACT_ITEMP(ic) (ic && (ic->op == '+' || ic->op == '-') && \
 273                                 IS_ITEMP(IC_RESULT(ic)) && \
 274                                 ( ( IS_ITEMP(IC_LEFT(ic)) ) ||  ( IS_SYMOP(IC_LEFT(ic)) ) ) && \
 275                                   IS_OP_LITERAL(IC_RIGHT(ic)))
 276
 277 #define ASSIGNMENT_TO_SELF(ic) (!POINTER_SET(ic) && !POINTER_GET(ic) && \
 278                                 ic->op == '=' && IC_RESULT(ic)->key == IC_RIGHT(ic)->key )
 279
 280 #define IS_CAST_ICODE(ic) (ic && ic->op == CAST)
 281 #define SET_ISADDR(op,v) {op = operandFromOperand(op); op->isaddr = v;}
 282 #define SET_RESULT_RIGHT(ic) {SET_ISADDR(IC_RIGHT(ic),0); SET_ISADDR(IC_RESULT(ic),0);}
 283 #define IS_ASSIGN_ICODE(ic) (ASSIGNMENT(ic) && !POINTER_SET(ic))
 284
 285 #define OP_DEFS(op) validateOpType(op, "OP_DEFS", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand->defs
 286 #define OP_USES(op) validateOpType(op, "OP_USES", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand->uses
 287 /*-----------------------------------------------------------------*/
 288 /* forward references for functions                                */
 289 /*-----------------------------------------------------------------*/
 290 iCode *reverseiCChain ();
 291 bool isOperandOnStack (operand *);
 292 int isOperandVolatile (operand *, bool);
 293 int isOperandGlobal (operand *);
 294 void printiCChain (iCode *, FILE *);
 295 operand *ast2iCode (ast *,int);
 296 operand *geniCodePtrPtrSubtract (operand *, operand *);
 297 void initiCode ();
 298 iCode *iCodeFromAst (ast *);
 299 int isiCodeEqual (iCode *, iCode *);
 300 int isOperandEqual (operand *, operand *);
 301 iCodeTable *getTableEntry (int);
 302 int isOperandLiteral (operand *);
 303 operand *operandOperation (operand *, operand *, int, sym_link *);
 304 double operandLitValue (operand *);
 305 operand *operandFromLit (double);
 306 operand *operandFromOperand (operand *);
 307 int isParameterToCall (value *, operand *);
 308 iCode *newiCodeLabelGoto (int, symbol *);
 309 symbol *newiTemp (char *);
 310 symbol *newiTempLabel (char *);
 311 symbol *newiTempPreheaderLabel ();
 312 iCode *newiCode (int, operand *, operand *);
 313 sym_link *operandType (operand *);
 314 operand *operandFromValue (value *);
 315 operand *operandFromSymbol (symbol *);
 316 operand *operandFromLink (sym_link *);
 317 sym_link *aggrToPtr (sym_link *, bool);
 318 int aggrToPtrDclType (sym_link *, bool);
 319 int piCode (void *, FILE *);
 320 int printOperand (operand *, FILE *);
 321 void setOperandType (operand *, sym_link *);
 322 bool isOperandInFarSpace (operand *);
 323 bool isOperandInDirSpace (operand *);
 324 bool isOperandInCodeSpace (operand *);
 325 operand *opFromOpWithDU (operand *, bitVect *, bitVect *);
 326 iCode *copyiCode (iCode *);
 327 operand *newiTempFromOp (operand *);
 328 iCode *getBuiltinParms (iCode *,int *, operand **);
 329 /*-----------------------------------------------------------------*/
 330 /* declaration of exported variables                               */
 331 /*-----------------------------------------------------------------*/
 332 extern char *filename;
 333 extern int lineno;
 334 #endif