projects / fw / sdcc / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
some small fixes
[fw/sdcc] / src / SDCCast.c
diff --git a/src/SDCCast.c b/src/SDCCast.c
index cd93f35b4f4173b883b0006b587c5d19843a4fe7..15f59285a84add354e7611937d698e1eadc1f75c 100644 (file)
--- a/src/SDCCast.c
+++ b/src/SDCCast.c
@@ -50,6 +50,7 @@ int noAlloc = 0;
 symbol *currFunc;
 static ast *createIval (ast *, sym_link *, initList *, ast *);
 static ast *createIvalCharPtr (ast *, sym_link *, ast *);
+static ast *optimizeCompare (ast *);
 ast *optimizeRRCRLC (ast *);
 ast *optimizeGetHbit (ast *);
 ast *backPatchLabels (ast *, symbol *, symbol *);
@@ -1146,6 +1147,66 @@ processBlockVars (ast * tree, int *stack, int action)
   return tree;
 }
 
+/*-------------------------------------------------------------*/
+/* constExprTree - returns TRUE if this tree is a constant     */
+/*                 expression                                  */
+/*-------------------------------------------------------------*/
+bool constExprTree (ast *cexpr) {
+
+  if (!cexpr) {
+    return TRUE;
+  }
+
+  cexpr = decorateType (resolveSymbols (cexpr));
+  
+  switch (cexpr->type) 
+    {
+    case EX_VALUE:
+      if (IS_AST_LIT_VALUE(cexpr)) {
+       // this is a literal
+       return TRUE;
+      }
+      if (IS_AST_SYM_VALUE(cexpr) && IS_FUNC(AST_SYMBOL(cexpr)->type)) {
+       // a function's address will never change
+       return TRUE;
+      }
+      if (IS_AST_SYM_VALUE(cexpr) && 
+         IN_CODESPACE(SPEC_OCLS(AST_SYMBOL(cexpr)->etype))) {
+       // a symbol in code space will never change
+       // This is only for the 'char *s="hallo"' case and will have to leave
+       return TRUE;
+      }
+      return FALSE;
+    case EX_LINK:
+      werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+             "unexpected link in expression tree\n");
+      return FALSE;
+    case EX_OP:
+      if (cexpr->opval.op==ARRAYINIT) {
+       fprintf (stderr, "skipping arrayinit\n");
+       // this is a list of literals
+       return TRUE;
+      }
+      if (cexpr->opval.op=='=') {
+       return constExprTree(cexpr->right);
+      }
+      if (cexpr->opval.op==CAST) {
+       // jwk: cast ignored, maybe we should throw a warning here
+       return constExprTree(cexpr->right);
+      }
+      if (cexpr->opval.op=='&') { 
+       return TRUE;
+      }
+      if (cexpr->opval.op==CALL || cexpr->opval.op==PCALL) {
+       return FALSE;
+      }
+      if (constExprTree(cexpr->left) && constExprTree(cexpr->right)) {
+       return TRUE;
+      }
+    }
+  return FALSE;
+}  
+    
 /*-----------------------------------------------------------------*/
 /* constExprValue - returns the value of a constant expression     */
 /*                  or NULL if it is not a constant expression     */
@@ -1841,10 +1902,10 @@ decorateType (ast * tree)
 
   switch (tree->opval.op)
     {
-           /*------------------------------------------------------------------*/
-           /*----------------------------*/
-           /*        array node          */
-           /*----------------------------*/
+       /*------------------------------------------------------------------*/
+       /*----------------------------*/
+       /*        array node          */
+       /*----------------------------*/
     case '[':
 
       /* determine which is the array & which the index */
@@ -1951,10 +2012,10 @@ decorateType (ast * tree)
 
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*  ++/-- operation           */
-/*----------------------------*/
+      /*----------------------------*/
     case INC_OP:               /* incerement operator unary so left only */
     case DEC_OP:
       {
@@ -1970,10 +2031,10 @@ decorateType (ast * tree)
        return tree;
       }
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*  bitwise and               */
-/*----------------------------*/
+      /*----------------------------*/
     case '&':                  /* can be unary   */
       /* if right is NULL then unary operation  */
       if (tree->right)         /* not an unary operation */
@@ -2020,10 +2081,10 @@ decorateType (ast * tree)
          return tree;
        }
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*  address of                */
-/*----------------------------*/
+      /*----------------------------*/
       p = newLink ();
       p->class = DECLARATOR;
       /* if bit field then error */
@@ -2089,10 +2150,10 @@ decorateType (ast * tree)
       TLVAL (tree) = 1;
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*  bitwise or                */
-/*----------------------------*/
+      /*----------------------------*/
     case '|':
       /* if the rewrite succeeds then don't go any furthur */
       {
@@ -2100,10 +2161,10 @@ decorateType (ast * tree)
        if (wtree != tree)
          return decorateType (wtree);
       }
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*  bitwise xor               */
-/*----------------------------*/
+      /*----------------------------*/
     case '^':
       if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
        {
@@ -2134,10 +2195,10 @@ decorateType (ast * tree)
                               computeType (LTYPE (tree),
                                            RTYPE (tree)));
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*  division                  */
-/*----------------------------*/
+      /*----------------------------*/
     case '/':
       if (!IS_ARITHMETIC (LTYPE (tree)) || !IS_ARITHMETIC (RTYPE (tree)))
        {
@@ -2162,10 +2223,10 @@ decorateType (ast * tree)
                                            RTYPE (tree)));
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*            modulus         */
-/*----------------------------*/
+      /*----------------------------*/
     case '%':
       if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
        {
@@ -2195,10 +2256,10 @@ decorateType (ast * tree)
                                            RTYPE (tree)));
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
-/*  address dereference       */
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
+      /*  address dereference       */
+      /*----------------------------*/
     case '*':                  /* can be unary  : if right is null then unary operation */
       if (!tree->right)
        {
@@ -2220,10 +2281,10 @@ decorateType (ast * tree)
          return tree;
        }
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      multiplication        */
-/*----------------------------*/
+      /*----------------------------*/
       if (!IS_ARITHMETIC (LTYPE (tree)) || !IS_ARITHMETIC (RTYPE (tree)))
        {
          werror (E_INVALID_OP, "multiplication");
@@ -2266,10 +2327,10 @@ decorateType (ast * tree)
       }
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*    unary '+' operator      */
-/*----------------------------*/
+      /*----------------------------*/
     case '+':
       /* if unary plus */
       if (!tree->right)
@@ -2294,10 +2355,10 @@ decorateType (ast * tree)
          return tree;
        }
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      addition              */
-/*----------------------------*/
+      /*----------------------------*/
 
       /* this is not a unary operation */
       /* if both pointers then problem */
@@ -2356,10 +2417,10 @@ decorateType (ast * tree)
                                              RTYPE (tree)));
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      unary '-'             */
-/*----------------------------*/
+      /*----------------------------*/
     case '-':                  /* can be unary   */
       /* if right is null then unary */
       if (!tree->right)
@@ -2386,10 +2447,10 @@ decorateType (ast * tree)
          return tree;
        }
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*    subtraction             */
-/*----------------------------*/
+      /*----------------------------*/
 
       if (!(IS_PTR (LTYPE (tree)) ||
            IS_ARRAY (LTYPE (tree)) ||
@@ -2456,10 +2517,10 @@ decorateType (ast * tree)
       LRVAL (tree) = RRVAL (tree) = 1;
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*    compliment              */
-/*----------------------------*/
+      /*----------------------------*/
     case '~':
       /* can be only integral type */
       if (!IS_INTEGRAL (LTYPE (tree)))
@@ -2481,10 +2542,10 @@ decorateType (ast * tree)
       COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree));
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*           not              */
-/*----------------------------*/
+      /*----------------------------*/
     case '!':
       /* can be pointer */
       if (!IS_ARITHMETIC (LTYPE (tree)) &&
@@ -2508,10 +2569,10 @@ decorateType (ast * tree)
       TTYPE (tree) = TETYPE (tree) = newCharLink ();
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*           shift            */
-/*----------------------------*/
+      /*----------------------------*/
     case RRC:
     case RLC:
       TTYPE (tree) = LTYPE (tree);
@@ -2643,10 +2704,10 @@ decorateType (ast * tree)
 
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*       logical &&, ||       */
-/*----------------------------*/
+      /*----------------------------*/
     case AND_OP:
     case OR_OP:
       /* each must me arithmetic type or be a pointer */
@@ -2683,10 +2744,10 @@ decorateType (ast * tree)
       TTYPE (tree) = TETYPE (tree) = newCharLink ();
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*     comparison operators   */
-/*----------------------------*/
+      /*----------------------------*/
     case '>':
     case '<':
     case LE_OP:
@@ -2731,7 +2792,18 @@ decorateType (ast * tree)
                goto errorTreeReturn;
              }
        }
+      /* if unsigned value < 0  then always false */
+      /* if (unsigned value) > 0 then (unsigned value) */
+      if (SPEC_USIGN(LETYPE(tree)) && IS_LITERAL(RTYPE(tree)) && 
+         ((int) floatFromVal (valFromType (RETYPE (tree)))) == 0) {
 
+         if (tree->opval.op == '<') {
+             return tree->right;
+         }
+         if (tree->opval.op == '>') {
+             return tree->left;
+         }
+      }
       /* if they are both literal then */
       /* rewrite the tree */
       if (IS_LITERAL (RTYPE (tree)) &&
@@ -2750,10 +2822,10 @@ decorateType (ast * tree)
       TTYPE (tree) = TETYPE (tree) = newCharLink ();
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*             sizeof         */
-/*----------------------------*/
+      /*----------------------------*/
     case SIZEOF:               /* evaluate wihout code generation */
       /* change the type to a integer */
       tree->type = EX_VALUE;
@@ -2872,10 +2944,10 @@ decorateType (ast * tree)
       return tree;
 
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*    assignment operators    */
-/*----------------------------*/
+      /*----------------------------*/
     case MUL_ASSIGN:
     case DIV_ASSIGN:
       /* for these it must be both must be integral */
@@ -2927,10 +2999,10 @@ decorateType (ast * tree)
 
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*    -= operator             */
-/*----------------------------*/
+      /*----------------------------*/
     case SUB_ASSIGN:
       if (!(IS_PTR (LTYPE (tree)) ||
            IS_ARITHMETIC (LTYPE (tree))))
@@ -2962,10 +3034,10 @@ decorateType (ast * tree)
 
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*          += operator       */
-/*----------------------------*/
+      /*----------------------------*/
     case ADD_ASSIGN:
       /* this is not a unary operation */
       /* if both pointers then problem */
@@ -3005,10 +3077,10 @@ decorateType (ast * tree)
 
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      straight assignemnt   */
-/*----------------------------*/
+      /*----------------------------*/
     case '=':
       /* cannot be an aggregate */
       if (IS_AGGREGATE (LTYPE (tree)))
@@ -3054,18 +3126,18 @@ decorateType (ast * tree)
 
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      comma operator        */
-/*----------------------------*/
+      /*----------------------------*/
     case ',':
       TETYPE (tree) = getSpec (TTYPE (tree) = RTYPE (tree));
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*       function call        */
-/*----------------------------*/
+      /*----------------------------*/
     case CALL:
       parmNumber = 1;
 
@@ -3086,10 +3158,10 @@ decorateType (ast * tree)
       TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree)->next);
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*     return statement       */
-/*----------------------------*/
+      /*----------------------------*/
     case RETURN:
       if (!tree->right)
        goto voidcheck;
@@ -3132,10 +3204,10 @@ decorateType (ast * tree)
       TTYPE (tree) = TETYPE (tree) = NULL;
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*     switch statement       */
-/*----------------------------*/
+      /*----------------------------*/
     case SWITCH:
       /* the switch value must be an integer */
       if (!IS_INTEGRAL (LTYPE (tree)))
@@ -3147,10 +3219,10 @@ decorateType (ast * tree)
       TTYPE (tree) = TETYPE (tree) = NULL;
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /* ifx Statement              */
-/*----------------------------*/
+      /*----------------------------*/
     case IFX:
       tree->left = backPatchLabels (tree->left,
                                    tree->trueLabel,
@@ -3158,10 +3230,10 @@ decorateType (ast * tree)
       TTYPE (tree) = TETYPE (tree) = NULL;
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /* for Statement              */
-/*----------------------------*/
+      /*----------------------------*/
     case FOR:
 
       decorateType (resolveSymbols (AST_FOR (tree, initExpr)));
@@ -3893,7 +3965,7 @@ tryNext2:
 /*-----------------------------------------------------------------*/
 /* optimizeCompare - otimizes compares for bit variables     */
 /*-----------------------------------------------------------------*/
-ast *
+static ast *
 optimizeCompare (ast * root)
 {
   ast *optExpr = NULL;
@@ -3940,63 +4012,6 @@ optimizeCompare (ast * root)
   vright = (root->right->type == EX_VALUE ?
            root->right->opval.val : NULL);
 
-  //#define EXPERIMENTAL
-#ifdef EXPERIMENTAL
-  /* if left is unsigned and right is literal */
-  if (vleft && vright && 
-      IS_UNSIGNED(vleft->etype) &&
-      IS_LITERAL(vright->etype)) {
-    double dval=floatFromVal(vright);
-    int op=root->opval.op;
-
-    fprintf (stderr,"op: '");
-    switch (op) {
-    case LE_OP: fprintf (stderr, "<= '"); break;
-    case EQ_OP: fprintf (stderr, "== '"); break;
-    case GE_OP: fprintf (stderr, ">= '"); break;
-    default: fprintf (stderr, "%c '", op); break;
-    }
-    fprintf (stderr, "%f\n", dval);
-
-    switch (op)
-      {
-      case EQ_OP:
-      case LE_OP:
-      case '<':
-       if (dval<0 || (op=='<' && dval==0)) {
-         // unsigned is never < 0
-         werror (W_IF_NEVER_TRUE);
-         optExpr = newAst_VALUE (constVal("0"));
-         return decorateType (optExpr);
-       }
-       if (dval==0) {
-         if (op==LE_OP) {
-           // change this into a cheaper EQ_OP
-           fprintf (stderr, "warning *** changed '<=' to '==' because of unsigned\n");
-           root->opval.op=EQ_OP;
-           return root;
-         }
-       }
-       break;
-      case GE_OP:
-      case '>':
-       if (dval>0 || (op==GE_OP && dval==0)) {
-         // unsigned is never < 0
-         werror (W_IF_ALWAYS_TRUE);
-         optExpr = newAst_VALUE (constVal("1"));
-         return decorateType (optExpr);
-       }
-       if (dval==0) {
-         if (op=='>') {
-           // change this into a cheaper reversed EQ_OP
-           fprintf (stderr, "warning *** changed '>' to '!=' because of unsigned\n");
-           root->opval.op=EQ_OP;
-         }
-       }
-      }
-  }
-#endif
-
   /* if left is a BITVAR in BITSPACE */
   /* and right is a LITERAL then opt- */
   /* imize else do nothing       */
SDCC with magic sdcdb for TeleMetrum