src/constraintExpr.c

   1 /*
   2 ** Splint - annotation-assisted static program checker
   3 ** Copyright (C) 1994-2003 University of Virginia,
   4 **         Massachusetts Institute of Technology
   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 of the License, or (at your
   9 ** option) any later version.
  10 **
  11 ** This program is distributed in the hope that it will be useful, but
  12 ** WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 ** General Public License for more details.
  15 **
  16 ** The GNU General Public License is available from http://www.gnu.org/ or
  17 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18 ** MA 02111-1307, USA.
  19 **
  20 ** For information on splint: info@splint.org
  21 ** To report a bug: splint-bug@splint.org
  22 ** For more information: http://www.splint.org
  23 */
  24
  25 /*
  26 ** constraintExpr.c
  27 */
  28
  29 # include "splintMacros.nf"
  30 # include "basic.h"
  31 # include "cgrammar.h"
  32
  33
  34 static ctype constraintExpr_getOrigType (constraintExpr p_e);
  35 static bool constraintExpr_hasTypeChange(constraintExpr p_e) /*@*/;
  36
  37 static /*@only@*/ constraintExpr constraintExpr_makeBinaryOpConstraintExprIntLiteral (/*@only@*/constraintExpr p_expr, int p_literal);
  38
  39
  40 #if 0
  41 /*@only@*/ static constraintExpr
  42 doSRefFixInvarConstraintTerm (/*@only@*/ constraintExpr p_e,
  43                               sRef p_s, ctype p_ct);
  44 #endif
  45
  46 /*@only@*/ static constraintExpr
  47 doSRefFixConstraintParamTerm (/*@only@*/ constraintExpr p_e, /*@temp@*/ /*@observer@*/ exprNodeList p_arglist) /*@modifies p_e@*/;
  48
  49 static /*@only@*/ constraintExpr
  50 doFixResultTerm (/*@only@*/ constraintExpr p_e, /*@exposed@*/ exprNode p_fcnCall)
  51      /*@modifies p_e@*/;
  52
  53 static bool constraintExpr_canGetCType (constraintExpr p_e) /*@*/;
  54
  55 static ctype constraintExpr_getCType (constraintExpr p_e);
  56
  57 static /*@only@*/ constraintExpr constraintExpr_adjustMaxSetForCast (/*@only@*/ constraintExpr p_e,
  58                                                                      ctype p_tfrom, ctype p_tto,
  59                                                                      fileloc p_loc);
  60
  61 /*@special@*/ /*@notnull@*/ static constraintExpr constraintExpr_makeBinaryOp (void)
  62      /* @allocates result->data @ @sets result->kind @ */ ;
  63
  64 void constraintExpr_free (/*@only@*/ constraintExpr expr)
  65 {
  66   if (constraintExpr_isDefined(expr) )
  67     {
  68       switch (expr->kind)
  69         {
  70         case unaryExpr:
  71           constraintExprData_freeUnaryExpr(expr->data);
  72           break;
  73         case binaryexpr:
  74           constraintExprData_freeBinaryExpr(expr->data);
  75           break;
  76         case term:
  77           constraintExprData_freeTerm(expr->data);
  78           break;
  79         BADDEFAULT;
  80         }
  81
  82       expr->data = NULL;
  83       free (expr);
  84     }
  85   else
  86     {
  87       llcontbug(message("attempted to free null pointer in constraintExpr_free"));
  88     }
  89 }
  90
  91 bool constraintExpr_isLit (constraintExpr expr)
  92 {
  93   llassert (expr != NULL);
  94
  95   if (expr->kind == term)
  96     {
  97       constraintTerm term = constraintExprData_termGetTerm (expr->data);
  98       if (constraintTerm_isIntLiteral (term) )
  99         {
 100           return TRUE;
 101         }
 102
 103     }
 104   return FALSE;
 105 }
 106
 107 static bool isZeroBinaryOp (constraintExpr expr)
 108 {
 109   constraintExpr e2;
 110
 111   llassert (expr != NULL); /* evans 2001-07-18 */
 112
 113   if (!constraintExpr_isBinaryExpr (expr) )
 114     {
 115       return FALSE;
 116     }
 117
 118
 119   e2 = constraintExprData_binaryExprGetExpr2(expr->data);
 120
 121   llassert (e2 != NULL); /* evans 2001-07-18 */
 122
 123   if (constraintExpr_isBinaryExpr (e2) )
 124     {
 125       constraintExpr e1;
 126
 127       e1 = constraintExprData_binaryExprGetExpr1(e2->data);
 128
 129         if (constraintExpr_isLit(e1) )
 130           {
 131             if (constraintExpr_getValue(e1) == 0 )
 132               {
 133                 return TRUE;
 134               }
 135           }
 136     }
 137   return FALSE;
 138 }
 139
 140 /* change expr + (o - expr) to (expr -expr) */
 141
 142 /*@only@*/ /*@notnull@*/ static constraintExpr removeZero (/*@only@*/ /*@returned@*/ constraintExpr expr)
 143 {
 144   constraintExpr expr2;
 145   constraintExpr temp;
 146
 147   constraintExprBinaryOpKind  op;
 148   constraintExprBinaryOpKind  tempOp;
 149
 150   llassert (expr != NULL); /* evans 2001-07-18 */
 151
 152   if (!isZeroBinaryOp(expr) )
 153     return expr;
 154
 155   expr2 = constraintExprData_binaryExprGetExpr2(expr->data);
 156   op = constraintExprData_binaryExprGetOp(expr->data);
 157
 158   llassert( constraintExpr_isBinaryExpr(expr2) );
 159
 160   temp = constraintExprData_binaryExprGetExpr2 (expr2->data);
 161   temp = constraintExpr_copy (temp);
 162
 163   tempOp = constraintExprData_binaryExprGetOp (expr2->data);
 164
 165   if (op == BINARYOP_PLUS)
 166     op = tempOp;
 167   else if (op == BINARYOP_MINUS)
 168     {
 169       if (tempOp == BINARYOP_PLUS)
 170         op = BINARYOP_MINUS;
 171       else if (tempOp == BINARYOP_MINUS)
 172         op = BINARYOP_PLUS;
 173       else
 174         BADEXIT;
 175     }
 176   else
 177     BADEXIT;
 178
 179   expr->data = constraintExprData_binaryExprSetExpr2(expr->data, temp);
 180   expr->data = constraintExprData_binaryExprSetOp(expr->data, op);
 181
 182   return expr;
 183 }
 184
 185
 186 /*@only@*//*@notnull@*/  constraintExpr constraintExpr_propagateConstants (/*@only@*/ constraintExpr expr,
 187                                                 /*@out@*/ bool * propagate,
 188                                                   /*@out@*/ int *literal)
 189 {
 190   constraintExpr expr1;
 191   constraintExpr expr2;
 192   bool propagate1, propagate2;
 193   int literal1, literal2;
 194   constraintExprBinaryOpKind  op;
 195
 196   propagate1 = FALSE;
 197   propagate2 = FALSE;
 198
 199   literal1 = 0;
 200   literal2 = 0;
 201
 202   *propagate = FALSE;
 203   *literal = 0;
 204
 205
 206   llassert (expr != NULL);
 207
 208   /* we simplify unaryExpr elsewhere */
 209   if (expr->kind != binaryexpr)
 210     return expr;
 211
 212   op = constraintExprData_binaryExprGetOp (expr->data);
 213
 214   DPRINTF((message("constraintExpr_propagateConstants: binaryexpr: %s", constraintExpr_unparse(expr) ) ) );
 215
 216   expr = removeZero(expr);
 217
 218   expr1 = constraintExprData_binaryExprGetExpr1(expr->data);
 219   expr2 = constraintExprData_binaryExprGetExpr2(expr->data);
 220
 221   expr1 = constraintExpr_copy(expr1);
 222   expr2 = constraintExpr_copy(expr2);
 223
 224   expr1 = constraintExpr_propagateConstants (expr1, &propagate1, &literal1);
 225   expr2 = constraintExpr_propagateConstants (expr2, &propagate2, &literal2);
 226
 227   expr1 = removeZero(expr1);
 228   expr2 = removeZero(expr2);
 229
 230
 231   *propagate = propagate1 || propagate2;
 232
 233   if (op == BINARYOP_PLUS)
 234     *literal    = literal1 +  literal2;
 235   else   if (op == BINARYOP_MINUS)
 236     *literal    = literal1 -  literal2;
 237   else
 238     BADEXIT;
 239
 240   if ( constraintExpr_isLit (expr1) && constraintExpr_isLit (expr2) )
 241     {
 242       long t1, t2;
 243       t1 = constraintExpr_getValue (expr1);
 244       t2 = constraintExpr_getValue (expr2);
 245       llassert(*propagate == FALSE);
 246       *propagate = FALSE;
 247
 248       constraintExpr_free (expr);
 249       constraintExpr_free (expr1);
 250       constraintExpr_free (expr2);
 251
 252       if (op == BINARYOP_PLUS )
 253         return (constraintExpr_makeIntLiteral ((t1+t2) ));
 254       else if (op ==  BINARYOP_MINUS)
 255         return (constraintExpr_makeIntLiteral ((t1-t2) ));
 256       else
 257         BADEXIT;
 258     }
 259
 260
 261   if (constraintExpr_isLit (expr1) )
 262     {
 263       *propagate = TRUE;
 264
 265       *literal += constraintExpr_getValue (expr1);
 266
 267       if (op == BINARYOP_PLUS)
 268         {
 269           constraintExpr_free(expr1);
 270           constraintExpr_free(expr);
 271           return expr2;
 272         }
 273       else if (op == BINARYOP_MINUS)
 274         {
 275
 276           constraintExpr temp;
 277
 278           /* this is an ugly kludge to deal with not
 279              having a unary minus operation...*/
 280
 281           temp = constraintExpr_makeIntLiteral (0);
 282           temp = constraintExpr_makeSubtractExpr (temp, expr2);
 283
 284           constraintExpr_free(expr1);
 285           constraintExpr_free(expr);
 286
 287           llassert (constraintExpr_isDefined(temp) );
 288           return temp;
 289         }
 290       else
 291         {
 292           BADBRANCH; /* evans 2001-07-18 */
 293         }
 294     }
 295
 296   if (constraintExpr_isLit (expr2) )
 297     {
 298       *propagate = TRUE;
 299
 300       if ( op == BINARYOP_PLUS )
 301         *literal += constraintExpr_getValue (expr2);
 302       else if (op ==  BINARYOP_MINUS)
 303         *literal -= constraintExpr_getValue (expr2);
 304       else
 305         BADEXIT;
 306
 307       constraintExpr_free(expr2);
 308       constraintExpr_free(expr);
 309       return expr1;
 310     }
 311
 312   DPRINTF((message("constraintExpr_propagateConstants returning: %s", constraintExpr_unparse(expr) ) ) );
 313
 314   expr->data = constraintExprData_binaryExprSetExpr1 (expr->data, expr1);
 315   expr->data = constraintExprData_binaryExprSetExpr2 (expr->data, expr2);
 316
 317   expr = removeZero(expr);
 318   return expr;
 319 }
 320
 321 /*@notnull@*/ /*@only@*/ static constraintExpr constraintExpr_combineConstants (/*@only@*/ constraintExpr expr ) /*@modifies expr@*/
 322 {
 323   bool propagate;
 324   int literal;
 325
 326   DPRINTF ((message ("Before combine %s", constraintExpr_unparse(expr) ) ) );
 327   expr = constraintExpr_propagateConstants (expr, &propagate, &literal);
 328
 329
 330   if (propagate)
 331     {
 332       constraintExpr ret;
 333
 334       if (literal != 0)
 335         {
 336           ret = constraintExpr_makeBinaryOpConstraintExprIntLiteral (expr, literal);
 337           expr = ret;
 338         }
 339     }
 340    DPRINTF ((message ("After combine %s", constraintExpr_unparse(expr) ) ) );
 341
 342    llassert(constraintExpr_isDefined(expr) );
 343    return expr;
 344 }
 345
 346 /*@special@*/
 347 static /*@notnull@*/ constraintExpr constraintExpr_alloc (void) /*@post:isnull result->data@*/
 348 {
 349   constraintExpr ret;
 350   ret = dmalloc (sizeof (*ret) );
 351   ret->kind = term;
 352   ret->data = NULL;
 353   ret->ct = FALSE;
 354   ret->origType = ctype_undefined;
 355   return ret;
 356 }
 357
 358 /*@only@*/ static constraintExprData copyExprData (/*@observer@*/ constraintExprData data, constraintExprKind kind)
 359 {
 360   constraintExprData ret;
 361   llassert(constraintExprData_isDefined(data));
 362
 363   switch (kind)
 364     {
 365     case binaryexpr:
 366       ret = constraintExprData_copyBinaryExpr(data);
 367       break;
 368     case unaryExpr:
 369       ret = constraintExprData_copyUnaryExpr(data);
 370       break;
 371     case term:
 372       ret = constraintExprData_copyTerm(data);
 373       break;
 374     BADDEFAULT;
 375     }
 376   return ret;
 377 }
 378
 379 constraintExpr constraintExpr_copy (constraintExpr expr)
 380 {
 381   constraintExpr ret;
 382   ret = constraintExpr_alloc ();
 383
 384
 385   /*drl 03/02/2003 this shouldn't be used to copy a null
 386     expression but handle things cleanly if it is*/
 387   llassert (!constraintExpr_isUndefined(expr) );
 388
 389   if (constraintExpr_isUndefined(expr) )
 390     {
 391       return constraintExpr_undefined;
 392     }
 393
 394   ret->kind = expr->kind;
 395
 396   ret->data = copyExprData (expr->data, expr->kind);
 397   ret->ct = expr->ct;
 398   ret->origType = expr->origType;
 399   return ret;
 400 }
 401
 402
 403 /*@only@*/ static constraintExpr oldconstraintExpr_makeTermExprNode ( /*@dependent@*/ exprNode e)
 404 {
 405   constraintExpr ret;
 406   constraintTerm t;
 407   ret = constraintExpr_alloc();
 408   ret->kind = term;
 409   ret->data = dmalloc (sizeof *(ret->data) );
 410   t = constraintTerm_makeExprNode (e);
 411   ret->data = constraintExprData_termSetTerm (ret->data, t);
 412   ret->ct = FALSE;
 413   ret->origType = ctype_undefined;
 414
 415   return ret;
 416 }
 417
 418 /*@access exprNode@*/
 419 constraintExpr constraintExpr_makeExprNode (exprNode e)
 420 {
 421  sRef s;
 422  constraintExpr ret, ce1, ce2;
 423  exprData data;
 424  exprNode t, t1, t2;
 425  lltok tok;
 426
 427  if (exprNode_isUndefined (e))
 428    {
 429      return constraintExpr_undefined;
 430    }
 431
 432  data = e->edata;
 433
 434  switch (e->kind)
 435    {
 436    case XPR_SIZEOF:
 437      t = exprData_getSingle (data);
 438      while (exprNode_isInParens (t) )
 439        {
 440          t = exprData_getUopNode (t->edata);
 441        }
 442      s = exprNode_getSref (t);
 443      if (sRef_isFixedArray(s) )
 444       {
 445         int size;
 446
 447         size = (int) sRef_getArraySize(s);
 448         ret = constraintExpr_makeIntLiteral (size);
 449       }
 450      else if (exprNode_isStringLiteral (t))
 451       {
 452         cstring str = multiVal_forceString (exprNode_getValue(t));
 453         ret = constraintExpr_makeIntLiteral (size_toLong (cstring_length (str) + 1));
 454       }
 455      else
 456        {
 457          DPRINTF ((message ("could not determine the size of %s", exprNode_unparse (e) ) ) );
 458          ret = oldconstraintExpr_makeTermExprNode (e);
 459        }
 460      break;
 461
 462    case XPR_OP:
 463       DPRINTF ((message ("Examining operation %s", exprNode_unparse (e) ) ) );
 464      t1 = exprData_getOpA (data);
 465      t2 = exprData_getOpB (data);
 466      tok = exprData_getOpTok (data);
 467
 468      if (lltok_isPlus_Op (tok) || lltok_isMinus_Op (tok) )
 469        {
 470          ce1 = constraintExpr_makeExprNode (t1);
 471          ce2 = constraintExpr_makeExprNode (t2);
 472          ret = constraintExpr_parseMakeBinaryOp (ce1, tok, ce2);
 473        }
 474
 475
 476         /* define this block to activate the cheesy heuristic
 477         for handling sizeof expressions*/
 478 #if 0
 479
 480
 481      /*
 482        drl 8-11-001
 483
 484        We handle expressions containing sizeof with the rule
 485        (sizeof type ) * Expr = Expr
 486
 487        This is the total wronge way to do this but...
 488        it may be better than nothing
 489      */
 490
 491
 492
 493      else if (lltok_isMult(tok) )
 494        {
 495          if  ((t1->kind == XPR_SIZEOF) || (t1->kind == XPR_SIZEOFT) )
 496            {
 497              ret = constraintExpr_makeExprNode(t2);
 498            }
 499          else if  ((t2->kind == XPR_SIZEOF) || (t2->kind == XPR_SIZEOFT) )
 500            {
 501              ret = constraintExpr_makeExprNode(t1);
 502              }
 503          else
 504            {
 505            ret =  oldconstraintExpr_makeTermExprNode (e);
 506            }
 507        }
 508 #endif
 509
 510      else
 511         ret = oldconstraintExpr_makeTermExprNode (e);
 512
 513      break;
 514    case XPR_PARENS:
 515      t = exprData_getUopNode (data);
 516      ret = constraintExpr_makeExprNode (t);
 517      break;
 518
 519    case XPR_PREOP:
 520       t = exprData_getUopNode (data);
 521       tok =  exprData_getUopTok (data);
 522       if (lltok_isIncOp (tok))
 523         {
 524           constraintExpr temp;
 525           temp = constraintExpr_makeExprNode(t);
 526           ret = constraintExpr_makeIncConstraintExpr(temp);
 527         }
 528       else if (lltok_isDecOp (tok))
 529         {
 530           constraintExpr temp;
 531           temp = constraintExpr_makeExprNode(t);
 532           ret = constraintExpr_makeDecConstraintExpr(temp);
 533         }
 534       else
 535         ret =  oldconstraintExpr_makeTermExprNode (e);
 536       break;
 537
 538    case XPR_POSTOP:
 539      t = exprData_getUopNode (data);
 540           ret = constraintExpr_makeExprNode (t);
 541      break;
 542    case XPR_CAST:
 543      t = exprData_getCastNode (data);
 544      ret = constraintExpr_makeExprNode (t);
 545      break;
 546    case XPR_COMMA:
 547      t = exprData_getPairA (data);
 548      ret = constraintExpr_makeExprNode(t);
 549      break;
 550    default:
 551      ret = oldconstraintExpr_makeTermExprNode (e);
 552
 553    }
 554   return ret;
 555 }
 556
 557 /*@noaccess exprNode@*/
 558
 559
 560
 561
 562 #if 0
 563 static /*@only@*/ constraintExpr constraintExpr_makeTermExprNode (/*@exposed@*/ exprNode e)
 564 {
 565   return  oldconstraintExpr_makeTermExprNode(e);
 566 }
 567 #endif
 568
 569 static constraintExpr constraintExpr_makeTerm (/*@only@*/  constraintTerm t)
 570 {
 571   constraintExpr ret;
 572
 573   ret = constraintExpr_alloc();
 574   ret->kind = term;
 575   ret->data = dmalloc (sizeof *(ret->data) );
 576   ret->data->term = NULL;
 577   ret->data = constraintExprData_termSetTerm (ret->data, t);
 578   ret->ct = FALSE;
 579   ret->origType = ctype_undefined;
 580
 581   return ret;
 582 }
 583
 584 constraintExpr constraintExpr_makeTermsRef (/*@temp@*/ sRef s)
 585 {
 586   constraintExpr ret;
 587   constraintTerm t;
 588   ret = constraintExpr_alloc();
 589   ret->kind = term;
 590   ret->data = dmalloc (sizeof *(ret->data) );
 591   t = constraintTerm_makesRef (s);
 592   ret->data = constraintExprData_termSetTerm (ret->data, t);
 593
 594   ret->ct = FALSE;
 595   ret->origType = ctype_undefined;
 596
 597   return ret;
 598 }
 599
 600 /*@special@*/ /*@notnull@*/ static constraintExpr makeUnaryOpGeneric (void) /*@allocates result->data@*/ /*@defines result->kind@*/
 601 {
 602   constraintExpr ret;
 603   ret = constraintExpr_alloc();
 604   ret->kind = unaryExpr;
 605   ret->data = dmalloc (sizeof *(ret->data));
 606   ret->data->unaryOp.expr = constraintExpr_undefined;
 607   return ret;
 608 }
 609
 610 /*@notnull@*/ /*@only@*/ static constraintExpr constraintExpr_makeUnaryOpConstraintExpr (/*@only@*/ constraintExpr cexpr)
 611 {
 612   constraintExpr ret;
 613   ret = makeUnaryOpGeneric();
 614
 615   /*@-uniondef@*/
 616   /*@-compdef@*/
 617   ret->data = constraintExprData_unaryExprSetExpr (ret->data, cexpr);
 618   ret->data = constraintExprData_unaryExprSetOp (ret->data, UNARYOP_UNDEFINED);
 619
 620   return ret;
 621
 622   /*@=compdef@*/
 623   /*@=uniondef@*/
 624 }
 625
 626
 627 /*@only@*/ /*@notnull@*/ static constraintExpr
 628 constraintExpr_makeUnaryOp (/*@only@*/ constraintExpr cexpr, constraintExprUnaryOpKind Op)
 629 {
 630   constraintExpr ret;
 631   ret = makeUnaryOpGeneric();
 632
 633   ret->data = constraintExprData_unaryExprSetExpr (ret->data, cexpr);
 634   ret->data = constraintExprData_unaryExprSetOp (ret->data, Op);
 635
 636   ret->ct = FALSE;
 637   ret->origType = ctype_undefined;
 638
 639   return ret;
 640 }
 641
 642 /*@only@*/ /*@notnull@*/
 643 static constraintExpr constraintExpr_makeUnaryOpExprNode (/*@exposed@*/ exprNode expr)
 644 {
 645   constraintExpr ret;
 646   constraintExpr sub;
 647   sub = constraintExpr_makeExprNode (expr);
 648   ret = constraintExpr_makeUnaryOpConstraintExpr(sub);
 649
 650   return ret;
 651 }
 652
 653 /*@only@*/ /*@notnull@*/
 654 static constraintExpr constraintExpr_makeMaxSetConstraintExpr (/*@only@*/ constraintExpr c)
 655 {
 656   constraintExpr ret;
 657   ret = constraintExpr_makeUnaryOp (c, MAXSET);
 658   return ret;
 659 }
 660
 661
 662 /*@only@*/ /*@notnull@*/
 663 static constraintExpr constraintExpr_makeSRefUnaryOp (/*@temp@*/ /*@observer@*/ sRef s,  constraintExprUnaryOpKind op)
 664 {
 665   constraintExpr ret;
 666   constraintExpr t;
 667
 668   t = constraintExpr_makeTermsRef (s);
 669   ret = constraintExpr_makeUnaryOpConstraintExpr (t);
 670   ret->data = constraintExprData_unaryExprSetOp (ret->data, op);
 671
 672   return ret;
 673 }
 674
 675 /*@only@*/
 676 constraintExpr constraintExpr_makeSRefMaxRead( sRef s)
 677 {
 678   return (constraintExpr_makeSRefUnaryOp (s, MAXREAD) );
 679 }
 680
 681 /*@only@*/
 682 constraintExpr constraintExpr_makeSRefMaxset ( sRef s)
 683 {
 684   return (constraintExpr_makeSRefUnaryOp (s, MAXSET) );
 685 }
 686
 687 /*@only@*/
 688 constraintExpr constraintExpr_parseMakeUnaryOp (lltok op, constraintExpr cexpr)
 689 {
 690   constraintExpr ret;
 691   ret = constraintExpr_makeUnaryOpConstraintExpr ( cexpr);
 692
 693   switch (lltok_getTok (op))
 694     {
 695     case QMAXSET:
 696       ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXSET);
 697       break;
 698     case QMAXREAD:
 699       ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXREAD);
 700       break;
 701     default:
 702       llfatalbug (message ("Unhandled operation in constraint: %s", lltok_unparse (op)));
 703     }
 704   return ret;
 705 }
 706
 707 /*@only@*/
 708 constraintExpr constraintExpr_makeMaxSetExpr (/*@exposed@*/ exprNode expr)
 709 {
 710   constraintExpr ret;
 711   ret = constraintExpr_makeExprNode (expr);
 712
 713   ret = constraintExpr_makeMaxSetConstraintExpr (ret);
 714
 715   llassert (ret != NULL);
 716   return ret;
 717 }
 718
 719 /*@only@*/
 720 constraintExpr  constraintExpr_makeMaxReadExpr (exprNode expr)
 721 {
 722   constraintExpr ret;
 723   ret = constraintExpr_makeUnaryOpExprNode(expr);
 724   ret->data      = constraintExprData_unaryExprSetOp (ret->data, MAXREAD);
 725   return ret;
 726 }
 727
 728 # if 0
 729 /*@only@*/
 730 /*@unused@*/ static constraintExpr  constraintExpr_makeMinSetExpr (/*@exposed@*/ exprNode expr)
 731 {
 732   constraintExpr ret;
 733   ret = constraintExpr_makeUnaryOpExprNode(expr);
 734   ret->data      = constraintExprData_unaryExprSetOp (ret->data, MINSET);
 735   return ret;
 736 }
 737
 738 /*@only@*/
 739 /*@unused@*/ static constraintExpr constraintExpr_makeMinReadExpr (/*@exposed@*/ exprNode expr)
 740 {
 741   constraintExpr ret;
 742   ret = constraintExpr_makeUnaryOpExprNode(expr);
 743   ret->data      = constraintExprData_unaryExprSetOp (ret->data, MINREAD);
 744   return ret;
 745 }
 746 # endif
 747
 748 /*@only@*/
 749 constraintExpr constraintExpr_makeValueExpr (/*@exposed@*/ exprNode expr)
 750 {
 751   constraintExpr ret;
 752   ret = constraintExpr_makeExprNode (expr);
 753   return ret;
 754 }
 755
 756 /*@only@*/ /*@notnull@*/
 757 constraintExpr constraintExpr_makeIntLiteral (long i)
 758 {
 759   constraintExpr ret;
 760   constraintTerm t;
 761   ret = constraintExpr_alloc();
 762   ret->kind = term;
 763   ret->data = dmalloc (sizeof *(ret->data) );
 764   t = constraintTerm_makeIntLiteral (i);
 765   ret->data = constraintExprData_termSetTerm (ret->data, t);
 766
 767   ret->ct = FALSE;
 768   ret->origType = ctype_undefined;
 769
 770   return ret;
 771 }
 772
 773 /*
 774 constraintExpr constraintExpr_makeValueInt (int i)
 775 {
 776   return constraintExpr_makeIntLiteral (i);
 777 }
 778 */
 779
 780 /*@only@*/ /*@notnull@*/
 781  /*@special@*/ static constraintExpr constraintExpr_makeBinaryOp (void)
 782       /*@allocates result->data @*/ /*@sets result->kind @*/
 783 {
 784   constraintExpr ret;
 785   ret = constraintExpr_alloc();
 786   ret->kind = binaryexpr;
 787   ret->data = dmalloc ( sizeof *(ret->data) );
 788
 789   ret->data->binaryOp.expr1 = constraintExpr_undefined;
 790   ret->data->binaryOp.expr2 = constraintExpr_undefined;
 791
 792   return ret;
 793 }
 794
 795
 796 static /*@notnull@*/ /*@only@*/ constraintExpr constraintExpr_makeBinaryOpConstraintExpr (/*@only@*/constraintExpr expr1, /*@only@*/ constraintExpr expr2)
 797
 798 {
 799   constraintExpr ret;
 800
 801   ret = constraintExpr_makeBinaryOp();
 802   ret->data = constraintExprData_binaryExprSetExpr1 (ret->data, expr1);
 803   ret->data = constraintExprData_binaryExprSetExpr2 (ret->data, expr2);
 804   ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_UNDEFINED);
 805
 806   ret->ct = FALSE;
 807   ret->origType = ctype_undefined;
 808
 809   return ret;
 810 }
 811
 812 /*@only@*/
 813 constraintExpr constraintExpr_parseMakeBinaryOp (/*@only@*/ constraintExpr expr1, lltok op,/*@only@*/ constraintExpr expr2)
 814 {
 815   constraintExpr ret;
 816   ret = constraintExpr_makeBinaryOpConstraintExpr (expr1, expr2);
 817
 818   if (lltok_getTok (op) == TPLUS)
 819     {
 820       ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_PLUS);
 821     }
 822   else if (lltok_getTok (op) == TMINUS)
 823     {
 824       ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_MINUS);
 825     }
 826   else
 827     {
 828       llassert (FALSE);
 829     }
 830
 831   return ret;
 832 }
 833
 834 # if 0
 835 /*@only@*/
 836 /*@unused@*/ static constraintExpr constraintExpr_makeBinaryOpExprNode (/*@exposed@*/ exprNode expr1, /*@exposed@*/ exprNode expr2)
 837 {
 838   constraintExpr ret;
 839   constraintExpr sub1, sub2;
 840   sub1 = constraintExpr_makeTermExprNode (expr1);
 841   sub2 = constraintExpr_makeTermExprNode (expr2);
 842   ret = constraintExpr_makeBinaryOpConstraintExpr(sub1, sub2);
 843   return ret;
 844 }
 845 # endif
 846
 847 static /*@notnull@*/ /*@only@*/
 848 constraintExpr constraintExpr_makeBinaryOpConstraintExprIntLiteral (/*@only@*/ constraintExpr expr, int literal)
 849 {
 850   constraintExpr ret;
 851   constraintExpr constExpr;
 852
 853   constExpr = constraintExpr_makeIntLiteral (literal);
 854   ret = constraintExpr_makeBinaryOpConstraintExpr (expr, constExpr);
 855   ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_PLUS);
 856   return ret;
 857 }
 858
 859 /*@only@*/
 860 constraintExpr constraintExpr_makeDecConstraintExpr (/*@only@*/constraintExpr expr)
 861 {
 862   constraintExpr ret;
 863   constraintExpr inc;
 864
 865   inc = constraintExpr_makeIntLiteral (1);
 866   ret = constraintExpr_makeBinaryOpConstraintExpr (expr, inc);
 867   ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_MINUS);
 868   return ret;
 869 }
 870
 871
 872 /*@only@*/  constraintExpr constraintExpr_makeSubtractExpr (/*@only@*/ constraintExpr expr, /*@only@*/ constraintExpr addent)
 873 {
 874   constraintExpr  ret;
 875
 876   DPRINTF ((message ("Making  subtract expression") ) );
 877
 878   ret = constraintExpr_makeBinaryOpConstraintExpr (expr, addent);
 879   ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_MINUS);
 880   return ret;
 881 }
 882
 883 /*@only@*/
 884 constraintExpr constraintExpr_makeAddExpr (/*@only@*/
 885 constraintExpr expr, /*@only@*/
 886 constraintExpr addent)
 887 {
 888   constraintExpr  ret;
 889
 890   DPRINTF ((message ("Doing addTerm simplification") ) );
 891
 892   ret = constraintExpr_makeBinaryOpConstraintExpr (expr, addent);
 893   ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_PLUS);
 894   return ret;
 895 }
 896
 897
 898 /*@only@*/
 899 constraintExpr constraintExpr_makeIncConstraintExpr (/*@only@*/ constraintExpr expr)
 900 {
 901   constraintExpr ret;
 902   constraintExpr inc;
 903
 904   inc = constraintExpr_makeIntLiteral (1);
 905   ret = constraintExpr_makeBinaryOpConstraintExpr (expr, inc);
 906   ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_PLUS);
 907   return ret;
 908 }
 909
 910 /*@only@*/
 911 static cstring constraintExprUnaryOpKind_print (constraintExprUnaryOpKind op)
 912 {
 913   switch (op)
 914     {
 915     case MAXSET:
 916       return message("maxSet");
 917     case MINSET:
 918       return message("minSet");
 919     case MAXREAD:
 920       return message("maxRead");
 921     case MINREAD:
 922       return message("minRead");
 923     default:
 924       llassert(FALSE);
 925       return message ("<(Unary OP OTHER>");
 926     }
 927 }
 928
 929
 930 /*@only@*/
 931 static cstring constraintExprBinaryOpKind_print (constraintExprBinaryOpKind op)
 932 {
 933
 934   switch (op)
 935     {
 936     case BINARYOP_PLUS:
 937       return message("+");
 938     case BINARYOP_MINUS:
 939       return message("-");
 940
 941     default:
 942       llassert(FALSE);
 943       return message ("<binary OP Unknown>");
 944     }
 945 }
 946
 947 bool constraintExpr_similar (constraintExpr expr1, constraintExpr expr2)
 948 {
 949   constraintExprKind kind;
 950
 951   llassert (expr1 != NULL);
 952   llassert (expr2 != NULL);
 953   if (expr1->kind != expr2->kind)
 954     return FALSE;
 955
 956   kind = expr1->kind;
 957
 958   switch (kind)
 959     {
 960     case term:
 961       return constraintTerm_similar (constraintExprData_termGetTerm(expr1->data),
 962                                   constraintExprData_termGetTerm(expr2->data) );
 963       /*@notreached@*/ break;
 964
 965     case unaryExpr:
 966       if (constraintExprData_unaryExprGetOp (expr1->data) != constraintExprData_unaryExprGetOp (expr2->data) )
 967         return FALSE;
 968
 969       return (constraintExpr_similar (
 970               constraintExprData_unaryExprGetExpr (expr1->data),
 971               constraintExprData_unaryExprGetExpr (expr2->data)
 972               ));
 973
 974     case binaryexpr:
 975       if (constraintExprData_binaryExprGetOp (expr1->data) != constraintExprData_binaryExprGetOp (expr2->data) )
 976         return FALSE;
 977
 978       if (! constraintExpr_similar (constraintExprData_binaryExprGetExpr1 (expr1->data),
 979                                  constraintExprData_binaryExprGetExpr1 (expr2->data)) )
 980         return FALSE;
 981
 982       if (! constraintExpr_similar (constraintExprData_binaryExprGetExpr2 (expr1->data),
 983                                  constraintExprData_binaryExprGetExpr2 (expr2->data)) )
 984         return FALSE;
 985       else
 986         return TRUE;
 987       /*@notreached@*/
 988       break;
 989
 990     default:
 991       llassert(FALSE);
 992       return FALSE;
 993     }
 994   /*@notreached@*/
 995   return FALSE;
 996 }
 997
 998 bool constraintExpr_same (constraintExpr expr1, constraintExpr expr2)
 999 {
1000   constraintExprKind kind;
1001
1002   llassert (expr1 != NULL);
1003   llassert (expr2 != NULL);
1004   if (expr1->kind != expr2->kind)
1005     return FALSE;
1006
1007   kind = expr1->kind;
1008
1009   switch (kind)
1010     {
1011     case term:
1012       return constraintTerm_similar (constraintExprData_termGetTerm(expr1->data),
1013                                   constraintExprData_termGetTerm(expr2->data) );
1014
1015     case unaryExpr:
1016       if (constraintExprData_unaryExprGetOp (expr1->data) != constraintExprData_unaryExprGetOp (expr2->data) )
1017         return FALSE;
1018
1019       return (constraintExpr_same (
1020               constraintExprData_unaryExprGetExpr (expr1->data),
1021               constraintExprData_unaryExprGetExpr (expr2->data)
1022               ));
1023
1024     case binaryexpr:
1025       if (constraintExprData_binaryExprGetOp (expr1->data) != constraintExprData_binaryExprGetOp (expr2->data) )
1026         return FALSE;
1027
1028       if (! constraintExpr_same (constraintExprData_binaryExprGetExpr1 (expr1->data),
1029                                  constraintExprData_binaryExprGetExpr1 (expr2->data)) )
1030         return FALSE;
1031
1032       if (! constraintExpr_same (constraintExprData_binaryExprGetExpr2 (expr1->data),
1033                                  constraintExprData_binaryExprGetExpr2 (expr2->data)) )
1034         return FALSE;
1035       else
1036         return TRUE;
1037
1038     BADDEFAULT;
1039     }
1040 }
1041
1042 bool
1043 constraintExpr_search (/*@observer@*/ constraintExpr c,
1044                        /*@observer@*/ constraintExpr old)
1045 {
1046   bool ret = FALSE;
1047   constraintExprKind kind;
1048   constraintExpr temp;
1049
1050   if (constraintExpr_similar (c, old))
1051     {
1052       DPRINTF (("Found  %q", constraintExpr_unparse (old)));
1053       return TRUE;
1054     }
1055
1056   llassert (constraintExpr_isDefined (c) && constraintExpr_isDefined(old) );
1057
1058   if ( !(constraintExpr_isDefined (c) && constraintExpr_isDefined(old) ) )
1059     return FALSE;
1060
1061   kind = c->kind;
1062
1063   switch (kind)
1064     {
1065     case term:
1066       break;
1067     case unaryExpr:
1068       temp = constraintExprData_unaryExprGetExpr (c->data);
1069       ret = ret || constraintExpr_search (temp, old);
1070       break;
1071     case binaryexpr:
1072
1073       temp = constraintExprData_binaryExprGetExpr1 (c->data);
1074       ret = ret || constraintExpr_search(temp, old);
1075
1076       temp = constraintExprData_binaryExprGetExpr2 (c->data);
1077       ret = ret || constraintExpr_search(temp, old);
1078       break;
1079     default:
1080       llassert(FALSE);
1081     }
1082   return ret;
1083
1084 }
1085
1086
1087 /*@only@*/ constraintExpr
1088 constraintExpr_searchandreplace (/*@only@*/ /*@unique@*/ constraintExpr c, /*@temp@*/ constraintExpr old,
1089                                  /*@temp@*/ constraintExpr newExpr )
1090 {
1091   constraintExprKind kind;
1092   constraintExpr temp;
1093   constraintExpr ret;
1094
1095   llassert (constraintExpr_isDefined (newExpr) && (constraintExpr_isDefined (old) && constraintExpr_isDefined(c) ) );
1096
1097   if (constraintExpr_similar (c, old))
1098     {
1099       ctype newType = ctype_unknown;
1100       ctype cType = ctype_unknown;
1101
1102       ret = constraintExpr_copy (newExpr);
1103       llassert(constraintExpr_isDefined(ret) );
1104       /*drl if newExpr != NULL then ret will != NULL*/
1105
1106       DPRINTF (("Replacing %s with %s in %s",
1107                 constraintExpr_unparse (old), constraintExpr_unparse (newExpr),
1108                 constraintExpr_unparse (c)));
1109
1110       if (constraintExpr_canGetCType (c) && constraintExpr_canGetCType (newExpr))
1111         {
1112           cType = constraintExpr_getCType(c);
1113           newType =  constraintExpr_getCType (newExpr);
1114
1115           if (ctype_match (cType,newType))
1116             {
1117               DPRINTF (("constraintExpr_searchandreplace: replacing "
1118                         " %s with type %s with %s with type %s",
1119                         constraintExpr_unparse (c), ctype_unparse(cType),
1120                         constraintExpr_unparse (newExpr), ctype_unparse(newType)));
1121
1122               ret->ct = TRUE;
1123               ret->origType = cType;
1124               DPRINTF (("Type: %s", ctype_unparse (constraintExpr_getCType (ret))));
1125             }
1126         }
1127
1128       if (constraintExpr_hasMaxSet (c))
1129         {
1130           if (constraintExpr_hasTypeChange (c))
1131             {
1132               fileloc loc = constraintExpr_loc (c);
1133               DPRINTF (("constraintExpr_searchandreplace: encountered "
1134                         "MaxSet with changed type %s ",
1135                         constraintExpr_unparse (c)));
1136
1137               if (c->kind == unaryExpr)
1138                 {
1139                   constraintExpr ce = constraintExprData_unaryExprGetExpr (c->data);
1140                   DPRINTF (("Its a unary! %s / %s",
1141                             ctype_unparse (constraintExpr_getCType (ce)),
1142                             ctype_unparse (constraintExpr_getOrigType (ce))));
1143                   ret = constraintExpr_adjustMaxSetForCast (ret, constraintExpr_getCType (ce),
1144                                                             constraintExpr_getOrigType (ce),
1145                                                             loc);
1146                 }
1147               else
1148                 {
1149                   /* fix this with a conversation */
1150                   DPRINTF (("Types: %s / %s", ctype_unparse (newType), ctype_unparse (cType)));
1151                   ret = constraintExpr_adjustMaxSetForCast (ret, constraintExpr_getCType (c),
1152                                                             constraintExpr_getOrigType(c),
1153                                                             loc);
1154                 }
1155             }
1156         }
1157
1158       constraintExpr_free (c);
1159       DPRINTF (("ret: %s", constraintExpr_unparse (ret)));
1160       return ret;
1161     }
1162
1163   kind = c->kind;
1164
1165   switch (kind)
1166     {
1167     case term:
1168       break;
1169     case unaryExpr:
1170       DPRINTF (("Making unary expression!"));
1171       temp = constraintExprData_unaryExprGetExpr (c->data);
1172       temp = constraintExpr_copy (temp);
1173       temp = constraintExpr_searchandreplace (temp, old, newExpr);
1174       c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
1175       break;
1176     case binaryexpr:
1177       DPRINTF (("Making binary expression!"));
1178       temp = constraintExprData_binaryExprGetExpr1 (c->data);
1179       temp = constraintExpr_copy (temp);
1180       temp = constraintExpr_searchandreplace (temp, old, newExpr);
1181       c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
1182
1183       temp = constraintExprData_binaryExprGetExpr2 (c->data);
1184       temp = constraintExpr_copy (temp);
1185       temp = constraintExpr_searchandreplace (temp, old, newExpr);
1186       c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
1187       break;
1188     default:
1189       llassert (FALSE);
1190     }
1191
1192   DPRINTF (("ret: %s", constraintExpr_unparse (c)));
1193   return c;
1194 }
1195
1196 /*@notnull@*/ static constraintExpr constraintExpr_simplifyChildren (/*@returned@*/ /*@notnull@*/ constraintExpr c)
1197 {
1198   constraintExprKind kind;
1199   constraintExpr temp;
1200
1201   kind = c->kind;
1202
1203   switch (kind)
1204     {
1205     case term:
1206       break;
1207     case unaryExpr:
1208       temp = constraintExprData_unaryExprGetExpr (c->data);
1209       temp = constraintExpr_copy(temp);
1210       temp = constraintExpr_simplify (temp);
1211       c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
1212       break;
1213     case binaryexpr:
1214       DPRINTF((message("constraintExpr_simplfiyChildren: simplify binary expression: %s",constraintExpr_unparse(c) ) ) );
1215       temp = constraintExprData_binaryExprGetExpr1 (c->data);
1216       temp = constraintExpr_copy(temp);
1217       temp = constraintExpr_simplify (temp);
1218
1219       c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
1220
1221       temp = constraintExprData_binaryExprGetExpr2 (c->data);
1222       temp = constraintExpr_copy(temp);
1223       temp = constraintExpr_simplify (temp);
1224
1225       c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
1226       break;
1227     default:
1228       llassert(FALSE);
1229     }
1230   return c;
1231
1232 }
1233
1234
1235 constraintExpr constraintExpr_setFileloc (/*@returned@*/ constraintExpr c, fileloc loc) /*@modifies c @*/
1236 {
1237   constraintTerm t;
1238   constraintExpr temp;
1239
1240   llassert(c != NULL);
1241
1242   switch (c->kind)
1243     {
1244     case term:
1245       t = constraintExprData_termGetTerm (c->data);
1246       t = constraintTerm_copy(t);
1247       t = constraintTerm_setFileloc (t, loc);
1248       c->data = constraintExprData_termSetTerm (c->data, t);
1249       break;
1250     case binaryexpr:
1251
1252       temp = constraintExprData_binaryExprGetExpr1 (c->data);
1253       temp = constraintExpr_copy(temp);
1254       temp = constraintExpr_setFileloc (temp, loc);
1255       c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
1256
1257       temp = constraintExprData_binaryExprGetExpr2 (c->data);
1258       temp = constraintExpr_copy(temp);
1259       temp = constraintExpr_setFileloc (temp, loc);
1260       c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
1261       break;
1262     case unaryExpr:
1263       temp = constraintExprData_unaryExprGetExpr (c->data);
1264       temp = constraintExpr_copy(temp);
1265       temp = constraintExpr_setFileloc (temp, loc);
1266       c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
1267       break;
1268     }
1269   return c;
1270 }
1271
1272 static /*@only@*/ constraintExpr constraintExpr_simplifybinaryExpr (/*@only@*/ /*@notnull@*/ constraintExpr c)
1273 {
1274   constraintExpr e1, e2;
1275   constraintExprBinaryOpKind  op;
1276
1277   e1 = constraintExprData_binaryExprGetExpr1 (c->data);
1278   e2 = constraintExprData_binaryExprGetExpr2 (c->data);
1279
1280   if (constraintExpr_canGetValue (e1) && constraintExpr_canGetValue(e2) )
1281     {
1282       long i;
1283
1284       i = constraintExpr_getValue(e1) + constraintExpr_getValue (e2);
1285       constraintExpr_free(c);
1286       c = constraintExpr_makeIntLiteral (i);
1287     }
1288   else
1289     {
1290       op = constraintExprData_binaryExprGetOp (c->data);
1291       if (op == BINARYOP_MINUS)
1292         if (constraintExpr_similar(e1, e2) )
1293           {
1294             constraintExpr_free(c);
1295             c =  constraintExpr_makeIntLiteral (0);
1296           }
1297     }
1298
1299   return c;
1300 }
1301
1302 /*
1303   this thing takes the lexpr and expr of a constraint and modifies lexpr
1304   and returns a (possiblly new) value for expr
1305 */
1306 /* if lexpr is a binary express say x + y, we set lexpr to x and return a value for expr such as expr_old - y */
1307
1308 /* the approach is a little Kludgy but seems to work.  I should probably use something cleaner at some point ... */
1309
1310
1311 /*@only@*/ constraintExpr constraintExpr_solveBinaryExpr (constraintExpr lexpr, /*@only@*/ constraintExpr expr)
1312 {
1313   constraintExpr expr1, expr2;
1314   constraintExprBinaryOpKind op;
1315
1316   llassert(constraintExpr_isDefined (lexpr)  && constraintExpr_isDefined (expr)  );
1317
1318   if (lexpr->kind != binaryexpr)
1319     return expr;
1320
1321   expr2 = constraintExprData_binaryExprGetExpr2 (lexpr->data);
1322   expr1 = constraintExprData_binaryExprGetExpr1 (lexpr->data);
1323
1324   op    = constraintExprData_binaryExprGetOp (lexpr->data);
1325
1326   expr1 = constraintExpr_copy(expr1);
1327   expr2 = constraintExpr_copy(expr2);
1328
1329   llassert(constraintExpr_isDefined (expr1)  && constraintExpr_isDefined (expr2)  );
1330
1331   /* drl possible problem : warning make sure this works */
1332
1333   lexpr->kind = expr1->kind;
1334   sfree (lexpr->data);
1335
1336   lexpr->data = copyExprData (expr1->data, expr1->kind);
1337   constraintExpr_free(expr1);
1338
1339   if (op == BINARYOP_PLUS)
1340     expr = constraintExpr_makeSubtractExpr (expr, expr2);
1341   else if (op == BINARYOP_MINUS)
1342     expr = constraintExpr_makeAddExpr (expr, expr2);
1343   else
1344     BADEXIT;
1345
1346   return expr;
1347
1348   /*
1349     #warning this needs to be checked
1350     expr = constraintExpr_solveBinaryExpr (expr1, expr);
1351
1352     expr = constraintExpr_solveBinaryExpr (expr2, expr);
1353     return expr;
1354   */
1355 }
1356
1357 static /*@only@*/ constraintExpr constraintExpr_simplifyunaryExpr (/*@only@*/ constraintExpr c)
1358 {
1359   constraintExpr exp;
1360
1361   llassert(constraintExpr_isDefined (c) );
1362   llassert (c->kind == unaryExpr);
1363
1364   DPRINTF ((message ("Doing constraintExpr_simplifyunaryExpr:%s", constraintExpr_unparse (c) ) ) );
1365
1366   if ((constraintExprData_unaryExprGetOp (c->data) != MAXSET) &&
1367        (constraintExprData_unaryExprGetOp (c->data) != MAXREAD) )
1368     {
1369       return c;
1370     }
1371
1372   exp = constraintExprData_unaryExprGetExpr (c->data);
1373   exp = constraintExpr_copy(exp);
1374
1375   llassert(constraintExpr_isDefined (exp)  );
1376
1377   if (exp->kind == term)
1378     {
1379       constraintTerm cterm;
1380
1381       cterm = constraintExprData_termGetTerm (exp->data);
1382
1383       if (constraintTerm_isStringLiteral(cterm) )
1384         {
1385           cstring val;
1386           val = constraintTerm_getStringLiteral (cterm);
1387           if (constraintExprData_unaryExprGetOp (c->data) == MAXSET)
1388             {
1389               constraintExpr temp;
1390
1391               temp = constraintExpr_makeIntLiteral ((int)strlen (cstring_toCharsSafe(val) ) );
1392               cstring_free(val);
1393               constraintExpr_free(c);
1394               constraintExpr_free(exp);
1395
1396               return temp;
1397
1398             }
1399           if (constraintExprData_unaryExprGetOp (c->data) == MAXREAD)
1400             {
1401               constraintExpr temp;
1402
1403               temp = constraintExpr_makeIntLiteral ((int)strlen (cstring_toCharsSafe(val) ) );
1404               cstring_free(val);
1405               constraintExpr_free(c);
1406               constraintExpr_free(exp);
1407
1408               return temp;
1409             }
1410           BADEXIT;
1411         }
1412
1413       /* slight Kludge to handle var [] = { , , };
1414       ** type syntax  I don't think this is sound but it should be good
1415       ** enough.  The C standard is very confusing about initialization
1416       ** -- DRL 7/25/01
1417       */
1418
1419       if (constraintTerm_isInitBlock(cterm) )
1420         {
1421           constraintExpr temp;
1422           int len;
1423
1424           len = constraintTerm_getInitBlockLength(cterm);
1425
1426           /* -- drl 12/08/2003 : decrementing to fix off by one error */
1427
1428           len--;
1429
1430           temp = constraintExpr_makeIntLiteral (len );
1431
1432           constraintExpr_free(c);
1433           DPRINTF(( message("Changed to %q", constraintExpr_print(temp)
1434                             ) ));
1435           constraintExpr_free(exp);
1436           return temp;
1437         }
1438
1439       constraintExpr_free(exp);
1440       return c;
1441     }
1442
1443   if (exp->kind != binaryexpr)
1444     {
1445       constraintExpr_free(exp);
1446       return c;
1447     }
1448
1449   if (constraintExprData_binaryExprGetOp (exp->data) == BINARYOP_PLUS  )
1450     {
1451
1452       /* if (constraintExpr_canGetValue (constraintExprData_binaryExprGetExpr2 (exp->data) ) ) */
1453         {
1454
1455           constraintExpr  temp, temp2;
1456
1457           DPRINTF ((message ("Doing fancy simplification") ) );
1458
1459           temp = constraintExprData_binaryExprGetExpr2 (exp->data);
1460
1461           temp2 = constraintExprData_binaryExprGetExpr1 (exp->data);
1462
1463           temp2 = constraintExpr_copy(temp2);
1464           c->data = constraintExprData_unaryExprSetExpr (c->data, temp2);
1465
1466
1467           temp = constraintExpr_copy (temp);
1468
1469           c = constraintExpr_makeSubtractExpr (c, temp);
1470
1471           DPRINTF ((message ("Done fancy simplification:%s", constraintExpr_unparse (c) ) ) );
1472         }
1473     }
1474
1475   DPRINTF ((message ("constraintExpr_simplifyUnaryExpr: Done simplification:%s", constraintExpr_unparse (c) ) ) );
1476
1477   constraintExpr_free(exp);
1478   return c;
1479 }
1480
1481
1482 /*@only@*/ constraintExpr constraintExpr_simplify (/*@only@*/ constraintExpr c)
1483 {
1484   constraintExprKind kind;
1485   constraintExpr ret;
1486   constraintTerm t;
1487
1488   DPRINTF ((message ("Doing constraintExpr_simplify:%s", constraintExpr_unparse (c) ) ) );
1489
1490
1491
1492   llassert ( constraintExpr_isDefined (c) );
1493   if (constraintExpr_isUndefined (c) )
1494     {
1495       return constraintExpr_undefined;
1496     }
1497
1498   ret =  constraintExpr_copy(c);
1499   llassert(constraintExpr_isDefined (ret) );
1500
1501   constraintExpr_free(c);
1502
1503   ret = constraintExpr_simplifyChildren (ret);
1504
1505   ret = constraintExpr_combineConstants (ret);
1506
1507   ret = constraintExpr_simplifyChildren (ret);
1508
1509
1510   kind = ret->kind;
1511
1512   switch (kind)
1513     {
1514     case term:
1515       t = constraintExprData_termGetTerm (ret->data);
1516       t = constraintTerm_copy(t);
1517       t = constraintTerm_simplify (t);
1518       ret->data = constraintExprData_termSetTerm (ret->data, t);
1519       break;
1520     case unaryExpr:
1521       ret = constraintExpr_simplifyunaryExpr (ret);
1522       break;
1523     case binaryexpr:
1524       ret = constraintExpr_simplifybinaryExpr (ret);
1525       break;
1526     default:
1527       llassert(FALSE);
1528     }
1529
1530   DPRINTF ((message ("constraintExpr_simplify returning :%s", constraintExpr_unparse (ret) ) ) );
1531   return ret;
1532
1533 }
1534
1535 /*@only@*/
1536 cstring constraintExpr_unparse (/*@temp@*/ constraintExpr ex) /*@*/
1537 {
1538   cstring st;
1539   constraintExprKind kind;
1540
1541   llassert (ex != NULL);
1542
1543   kind = ex->kind;
1544
1545   switch (kind)
1546     {
1547     case term:
1548       if (context_getFlag (FLG_PARENCONSTRAINT) )
1549         {
1550           st = message ("(%q) ", constraintTerm_unparse (constraintExprData_termGetTerm (ex->data)));
1551         }
1552       else
1553         {
1554           st = message ("%q", constraintTerm_unparse (constraintExprData_termGetTerm (ex->data)));
1555         }
1556       break;
1557     case unaryExpr:
1558       st = message ("%q(%q)",
1559                     constraintExprUnaryOpKind_print (constraintExprData_unaryExprGetOp (ex->data) ),
1560                     constraintExpr_unparse (constraintExprData_unaryExprGetExpr (ex->data) )
1561                     );
1562       break;
1563     case binaryexpr:
1564       if (context_getFlag (FLG_PARENCONSTRAINT) )
1565         {
1566           st = message ("(%q) %q (%q)",
1567                         constraintExpr_unparse (constraintExprData_binaryExprGetExpr1 (ex->data) ),
1568                         constraintExprBinaryOpKind_print (constraintExprData_binaryExprGetOp (ex->data)),
1569                         constraintExpr_unparse (constraintExprData_binaryExprGetExpr2 (ex->data) )
1570                         );
1571         }
1572       else
1573         {
1574           st = message ("%q %q %q",
1575                         constraintExpr_unparse (constraintExprData_binaryExprGetExpr1 (ex->data)),
1576                         constraintExprBinaryOpKind_print (constraintExprData_binaryExprGetOp (ex->data)),
1577                         constraintExpr_unparse (constraintExprData_binaryExprGetExpr2 (ex->data))
1578                         );
1579         }
1580
1581       break;
1582     default:
1583       llassert(FALSE);
1584       st = message ("error");
1585
1586     }
1587
1588   DPRINTF((message ("constraintExpr_unparse: '%s'",st) ) );
1589   return st;
1590 }
1591
1592 # ifdef DEADCODE
1593 constraintExpr constraintExpr_doSRefFixBaseParam (/*@returned@*/  constraintExpr expr, exprNodeList arglist)
1594 {
1595   constraintTerm Term;
1596   constraintExprKind kind;
1597   constraintExpr expr1, expr2;
1598   constraintExprData data;
1599   llassert (expr != NULL);
1600
1601   data = expr->data;
1602
1603   kind = expr->kind;
1604
1605   switch (kind)
1606     {
1607     case term:
1608       Term = constraintExprData_termGetTerm(data);
1609       Term = constraintTerm_copy(Term);
1610
1611       Term = constraintTerm_doSRefFixBaseParam (Term, arglist);
1612       data = constraintExprData_termSetTerm(data, Term);
1613       break;
1614     case unaryExpr:
1615       expr1 = constraintExprData_unaryExprGetExpr (data);
1616       expr1 = constraintExpr_copy(expr1);
1617
1618       expr1 = constraintExpr_doSRefFixBaseParam (expr1, arglist);
1619       data = constraintExprData_unaryExprSetExpr (data, expr1);
1620       break;
1621     case binaryexpr:
1622       expr1 = constraintExprData_binaryExprGetExpr1 (data);
1623       expr2 = constraintExprData_binaryExprGetExpr2 (data);
1624
1625       expr1 = constraintExpr_copy(expr1);
1626       expr2 = constraintExpr_copy(expr2);
1627
1628       expr1 = constraintExpr_doSRefFixBaseParam (expr1, arglist);
1629       data = constraintExprData_binaryExprSetExpr1 (data, expr1);
1630       expr2 = constraintExpr_doSRefFixBaseParam (expr2, arglist);
1631       data = constraintExprData_binaryExprSetExpr2 (data, expr2);
1632
1633       break;
1634     default:
1635       llassert(FALSE);
1636       data = NULL;
1637     }
1638   return expr;
1639 }
1640 # endif /* DEADCODE */
1641
1642 #if 0
1643 /*@only@*/ constraintExpr constraintExpr_doSRefFixInvarConstraint (/ *@only@* / constraintExpr expr, sRef s, ctype ct)
1644 {
1645   constraintExprKind kind;
1646   constraintExpr expr1, expr2;
1647   constraintExprData data;
1648   llassert (expr != NULL);
1649
1650   data = expr->data;
1651
1652   kind = expr->kind;
1653
1654   switch (kind)
1655     {
1656     case term:
1657       expr = doSRefFixInvarConstraintTerm (expr, s, ct);
1658       break;
1659     case unaryExpr:
1660       expr1 = constraintExprData_unaryExprGetExpr (data);
1661       expr1 = constraintExpr_copy(expr1);
1662       expr1 = constraintExpr_doSRefFixInvarConstraint (expr1, s, ct);
1663       data = constraintExprData_unaryExprSetExpr (data, expr1);
1664       break;
1665     case binaryexpr:
1666       expr1 = constraintExprData_binaryExprGetExpr1 (data);
1667       expr2 = constraintExprData_binaryExprGetExpr2 (data);
1668
1669       expr1 = constraintExpr_copy(expr1);
1670       expr2 = constraintExpr_copy(expr2);
1671
1672       expr1 = constraintExpr_doSRefFixInvarConstraint (expr1, s, ct);
1673       data = constraintExprData_binaryExprSetExpr1 (data, expr1);
1674       expr2 = constraintExpr_doSRefFixInvarConstraint (expr2, s, ct);
1675       data = constraintExprData_binaryExprSetExpr2 (data, expr2);
1676
1677       break;
1678     default:
1679       llassert(FALSE);
1680       data = NULL;
1681     }
1682   return expr;
1683 }
1684 #endif
1685
1686 /*@only@*/ constraintExpr constraintExpr_doSRefFixConstraintParam (/*@only@*/ constraintExpr expr, exprNodeList arglist) /*@modifies expr@*/
1687 {
1688   constraintExprKind kind;
1689   constraintExpr expr1, expr2;
1690   constraintExprData data;
1691   llassert (expr != NULL);
1692
1693   data = expr->data;
1694
1695   kind = expr->kind;
1696
1697   switch (kind)
1698     {
1699     case term:
1700       expr = doSRefFixConstraintParamTerm (expr, arglist);
1701       break;
1702     case unaryExpr:
1703       expr1 = constraintExprData_unaryExprGetExpr (data);
1704       expr1 = constraintExpr_copy(expr1);
1705       expr1 = constraintExpr_doSRefFixConstraintParam (expr1, arglist);
1706       data = constraintExprData_unaryExprSetExpr (data, expr1);
1707       break;
1708     case binaryexpr:
1709       expr1 = constraintExprData_binaryExprGetExpr1 (data);
1710       expr2 = constraintExprData_binaryExprGetExpr2 (data);
1711
1712       expr1 = constraintExpr_copy(expr1);
1713       expr2 = constraintExpr_copy(expr2);
1714
1715       expr1 = constraintExpr_doSRefFixConstraintParam (expr1, arglist);
1716       data = constraintExprData_binaryExprSetExpr1 (data, expr1);
1717       expr2 = constraintExpr_doSRefFixConstraintParam (expr2, arglist);
1718       data = constraintExprData_binaryExprSetExpr2 (data, expr2);
1719
1720       break;
1721     default:
1722       llassert(FALSE);
1723       data = NULL;
1724     }
1725   return expr;
1726 }
1727
1728 /*@only@*/ constraintExpr constraintExpr_doFixResult (/*@only@*/  constraintExpr expr, /*@observer@*/ exprNode fcnCall)
1729 {
1730   constraintExprKind kind;
1731   constraintExpr expr1, expr2;
1732   constraintExprData data;
1733   llassert (expr != NULL);
1734
1735   data = expr->data;
1736
1737   kind = expr->kind;
1738
1739   switch (kind)
1740     {
1741     case term:
1742       expr = doFixResultTerm (expr, fcnCall);
1743       break;
1744     case unaryExpr:
1745       expr1 = constraintExprData_unaryExprGetExpr (data);
1746       expr1 = constraintExpr_copy(expr1);
1747
1748       expr1 = constraintExpr_doFixResult (expr1, fcnCall);
1749       data = constraintExprData_unaryExprSetExpr (data, expr1);
1750       break;
1751     case binaryexpr:
1752       expr1 = constraintExprData_binaryExprGetExpr1 (data);
1753       expr2 = constraintExprData_binaryExprGetExpr2 (data);
1754
1755       expr1 = constraintExpr_copy(expr1);
1756       expr2 = constraintExpr_copy(expr2);
1757
1758       expr1 = constraintExpr_doFixResult (expr1, fcnCall);
1759       data = constraintExprData_binaryExprSetExpr1 (data, expr1);
1760       expr2 = constraintExpr_doFixResult (expr2, fcnCall);
1761       data = constraintExprData_binaryExprSetExpr2 (data, expr2);
1762       break;
1763     default:
1764       llassert(FALSE);
1765       data = NULL;
1766     }
1767   return expr;
1768 }
1769
1770 cstring constraintExpr_print (constraintExpr expr) /*@*/
1771 {
1772   return constraintExpr_unparse (expr);
1773 }
1774
1775 bool constraintExpr_hasMaxSet (constraintExpr expr) /*@*/
1776 {
1777   cstring t;
1778   bool ret;
1779
1780   t = constraintExpr_unparse(expr);
1781
1782   ret = cstring_containsLit(t, "maxSet");
1783   cstring_free(t);
1784
1785   return ret;
1786 }
1787
1788
1789
1790       /*returns 1 0 -1 like strcmp
1791         1 => expr1 > expr2
1792         0 => expr1 == expr2
1793         -1 => expr1 < expr2
1794        */
1795
1796 int constraintExpr_compare (constraintExpr expr1, constraintExpr expr2)
1797 {
1798   long value1, value2;
1799
1800   if (constraintExpr_similar (expr1, expr2) )
1801     {
1802       return 0;
1803     }
1804
1805   value1 = constraintExpr_getValue(expr1);
1806   value2 = constraintExpr_getValue(expr2);
1807
1808   if (value1 > value2)
1809     return 1;
1810
1811   if (value1 == value2)
1812     return 0;
1813
1814   else
1815     return -1;
1816 }
1817
1818 long constraintExpr_getValue (constraintExpr expr)
1819 {
1820   llassert (constraintExpr_isDefined(expr) );
1821   llassert (expr->kind == term);
1822
1823   return (constraintTerm_getValue (constraintExprData_termGetTerm (expr->data)));
1824 }
1825
1826 bool constraintExpr_canGetValue (constraintExpr expr)
1827 {
1828   llassert ( constraintExpr_isDefined (expr));
1829   if (constraintExpr_isUndefined (expr))
1830     {
1831       return FALSE;
1832     }
1833
1834   switch (expr->kind)
1835     {
1836     case term:
1837       return constraintTerm_canGetValue (constraintExprData_termGetTerm (expr->data) );
1838     default:
1839       return FALSE;
1840     }
1841 }
1842
1843 fileloc constraintExpr_loc (constraintExpr expr)
1844 {
1845   constraintExpr e;
1846 constraintTerm t;
1847   constraintExprKind kind;
1848
1849   llassert ( constraintExpr_isDefined (expr) );
1850   if (constraintExpr_isUndefined (expr) )
1851     {
1852       return fileloc_undefined;
1853     }
1854
1855
1856  kind = expr->kind;
1857
1858   switch (kind)
1859     {
1860     case term:
1861       t = constraintExprData_termGetTerm (expr->data);
1862       return (constraintTerm_getFileloc (t) );
1863       /*@notreached@*/
1864       break;
1865     case unaryExpr:
1866       e = constraintExprData_unaryExprGetExpr (expr->data);
1867       return (constraintExpr_loc (e) );
1868       /*@notreached@*/
1869       break;
1870     case binaryexpr:
1871       e = constraintExprData_binaryExprGetExpr1 (expr->data);
1872       return (constraintExpr_loc (e) );
1873       /*@notreached@*/
1874       break;
1875     }
1876   llassert (FALSE);
1877   return (fileloc_undefined);
1878 }
1879
1880 /*drl moved from constriantTerm.c 5/20/001*/
1881 static /*@only@*/ constraintExpr
1882 doFixResultTerm (/*@only@*/ constraintExpr e, /*@exposed@*/ exprNode fcnCall)
1883 {
1884   constraintTerm t;
1885   sRef s;
1886   constraintExprData data;
1887   constraintExprKind kind;
1888   constraintExpr ret;
1889
1890   llassert (constraintExpr_isDefined (e) );
1891
1892   data = e->data;
1893   kind = e->kind;
1894
1895   llassert (kind == term);
1896
1897   t = constraintExprData_termGetTerm (data);
1898   llassert (constraintTerm_isDefined (t));
1899
1900   ret = e;
1901
1902   switch (constraintTerm_getKind (t))
1903     {
1904     case CTT_EXPR:
1905     case CTT_INTLITERAL:
1906       break;
1907
1908     case CTT_SREF:
1909       s = constraintTerm_getSRef(t);
1910       if (sRef_isResult (s))
1911         {
1912           ret = constraintExpr_makeExprNode(fcnCall);
1913           constraintExpr_free(e);
1914         }
1915       break;
1916
1917     BADDEFAULT;
1918     }
1919
1920   return ret;
1921
1922 }
1923
1924 #if 0
1925
1926 /*to be used for structure checking */
1927
1928 / *@only@* / static constraintExpr
1929 doSRefFixInvarConstraintTerm (/ *@only@* / constraintExpr e, sRef s, ctype ct)
1930 {
1931   constraintTerm t;
1932
1933   constraintExprData data = e->data;
1934
1935   constraintExprKind kind = e->kind;
1936
1937   constraintExpr ret;
1938
1939   llassert(kind == term);
1940
1941   t = constraintExprData_termGetTerm (data);
1942   llassert (constraintTerm_isDefined(t) );
1943
1944   ret = e;
1945
1946   DPRINTF (("Fixing: %s", constraintExpr_print (e)));
1947
1948   switch (constraintTerm_getKind(t))
1949     {
1950     case CTT_EXPR:
1951       DPRINTF((message ("%q @ %q ", constraintTerm_unparse(t),
1952                         fileloc_unparse (constraintTerm_getFileloc(t) ) ) ));
1953       break;
1954     case CTT_INTLITERAL:
1955       DPRINTF((message (" %q ", constraintTerm_unparse (t)) ));
1956       break;
1957
1958     case CTT_SREF:
1959       / * evans 2001-07-24: constants should use the original term * /
1960       if (!constraintTerm_canGetValue (t))
1961         {
1962           sRef snew;
1963           DPRINTF ((message("Doing sRef_fixInvarConstraint for %q ",
1964                              constraintTerm_unparse (t) ) ));
1965
1966           snew = fixSref (ct, s, constraintTerm_getSRef(t));
1967
1968           ret = constraintExpr_makeTermsRef(snew);
1969
1970           constraintExpr_free (e);
1971
1972           DPRINTF (( message("After Doing sRef_fixConstraintParam constraintExpr is %q ",
1973                              constraintExpr_print (ret) ) ));
1974           / *@-branchstate@* /
1975         } / *@=branchstate@* /
1976
1977       break;
1978     BADDEFAULT;
1979     }
1980
1981   return ret;
1982
1983 }
1984 #endif
1985
1986 /*drl moved from constriantTerm.c 5/20/001*/
1987 /*@only@*/ static constraintExpr
1988 doSRefFixConstraintParamTerm (/*@only@*/ constraintExpr e, /*@observer@*/ /*@temp@*/ exprNodeList arglist)
1989 {
1990   constraintTerm t;
1991
1992   constraintExprData data;
1993
1994   constraintExprKind kind;
1995
1996   constraintExpr ret;
1997
1998
1999   llassert(constraintExpr_isDefined (e) );
2000
2001   data = e->data;
2002
2003   kind = e->kind;
2004
2005
2006
2007   llassert(kind == term);
2008
2009   t = constraintExprData_termGetTerm (data);
2010   llassert (constraintTerm_isDefined(t) );
2011
2012   ret = e;
2013
2014   DPRINTF (("Fixing: %s", constraintExpr_print (e)));
2015
2016   switch (constraintTerm_getKind(t))
2017     {
2018     case CTT_EXPR:
2019       DPRINTF((message ("%q @ %q ", constraintTerm_unparse(t),
2020                         fileloc_unparse (constraintTerm_getFileloc(t) ) ) ));
2021       break;
2022     case CTT_INTLITERAL:
2023       DPRINTF((message (" %q ", constraintTerm_unparse (t)) ));
2024       break;
2025     case CTT_SREF:
2026       /* evans 2001-07-24: constants should use the original term */
2027       if (!constraintTerm_canGetValue (t))
2028         {
2029           DPRINTF ((message("Doing sRef_fixConstraintParam for %q ",
2030                              constraintTerm_unparse (t) ) ));
2031           ret = sRef_fixConstraintParam (constraintTerm_getSRef(t), arglist);
2032
2033           constraintExpr_free (e);
2034
2035           DPRINTF (( message("After Doing sRef_fixConstraintParam constraintExpr is %q ",
2036                              constraintExpr_print (ret) ) ));
2037           /*@-branchstate@*/
2038         } /*@=branchstate@*/
2039
2040       break;
2041     BADDEFAULT;
2042     }
2043
2044   return ret;
2045
2046 }
2047
2048
2049 #if 0
2050 bool constraintExpr_includesTerm (constraintExpr expr, constraintTerm term)
2051 {
2052   if (constraintTerm_hasTerm (expr->term, term) )
2053     return TRUE;
2054
2055   if ((expr->expr) != NULL)
2056     {
2057       return ( constraintExpr_includesTerm (expr->expr, term) );
2058     }
2059   return FALSE;
2060
2061 }
2062 #endif
2063
2064 /*drl added 6/11/01 */
2065 bool constraintExpr_isBinaryExpr (/*@observer@*/ constraintExpr c)
2066 {
2067
2068   llassert(constraintExpr_isDefined (c) );
2069
2070   if ( ! (constraintExpr_isDefined (c) ) )
2071     return FALSE;
2072
2073   if (c->kind == binaryexpr)
2074     return TRUE;
2075
2076   else
2077     return FALSE;
2078 }
2079
2080 /*drl added 8/08/001 */
2081 bool constraintExpr_isTerm (/*@observer@*/ constraintExpr c) /*@*/
2082 {
2083   llassert(constraintExpr_isDefined (c) );
2084
2085   if (c->kind == term)
2086     return TRUE;
2087
2088   else
2089     return FALSE;
2090 }
2091
2092 /*@observer@*/ /*@temp@*/ constraintTerm constraintExpr_getTerm ( /*@temp@*/ /*@observer@*/ constraintExpr c) /*@*/
2093 {
2094   constraintTerm term;
2095
2096   llassert(constraintExpr_isDefined (c) );
2097
2098   llassert(constraintExpr_isTerm(c) );
2099
2100   term = constraintExprData_termGetTerm(c->data);
2101
2102   return term;
2103 }
2104
2105 static void  binaryExpr_dump (/*@observer@*/ constraintExprData data,  FILE *f)
2106 {
2107   constraintExpr expr1;
2108   constraintExprBinaryOpKind binaryOp;
2109   constraintExpr expr2;
2110
2111
2112   binaryOp = constraintExprData_binaryExprGetOp (data);
2113
2114   fprintf(f, "%d\n", (int) binaryOp);
2115
2116   expr1 = constraintExprData_binaryExprGetExpr1 (data);
2117   expr2 = constraintExprData_binaryExprGetExpr2 (data);
2118
2119   fprintf(f, "e1\n");
2120
2121   constraintExpr_dump(expr1, f);
2122
2123   fprintf(f, "e2\n");
2124   constraintExpr_dump(expr2, f);
2125 }
2126
2127
2128 static constraintExpr  binaryExpr_undump (FILE *f)
2129 {
2130   constraintExpr expr1;
2131   constraintExprBinaryOpKind binaryOp;
2132   constraintExpr expr2;
2133
2134   constraintExpr ret;
2135
2136
2137
2138   char * str;
2139   char * os;
2140
2141   os = mstring_create (MAX_DUMP_LINE_LENGTH);
2142
2143   str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
2144
2145   if (! mstring_isDefined(str) )
2146     {
2147       llfatalbug(message("Library file is corrupted") );
2148     }
2149
2150   binaryOp = (constraintExprBinaryOpKind) reader_getInt(&str);
2151
2152   str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
2153
2154   if (! mstring_isDefined(str) )
2155     {
2156       llfatalbug(message("Library file is corrupted") );
2157     }
2158
2159   reader_checkChar (&str, 'e');
2160   reader_checkChar (&str, '1');
2161
2162   expr1 = constraintExpr_undump (f);
2163
2164   str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
2165
2166   reader_checkChar (&str, 'e');
2167   reader_checkChar (&str, '2');
2168
2169   expr2 = constraintExpr_undump (f);
2170
2171   ret = constraintExpr_makeBinaryOpConstraintExpr (expr1, expr2);
2172   ret->data = constraintExprData_binaryExprSetOp(ret->data, binaryOp);
2173
2174   free(os);
2175   return ret;
2176 }
2177
2178
2179
2180 static void  unaryExpr_dump (/*@observer@*/ constraintExprData data,  FILE *f)
2181 {
2182
2183   constraintExpr expr;
2184   constraintExprUnaryOpKind unaryOp;
2185
2186   unaryOp = constraintExprData_unaryExprGetOp (data);
2187
2188   fprintf(f, "%d\n", (int) unaryOp);
2189
2190   expr = constraintExprData_unaryExprGetExpr (data);
2191
2192   constraintExpr_dump(expr, f);
2193 }
2194
2195 static  constraintExpr  unaryExpr_undump ( FILE *f)
2196 {
2197
2198   constraintExpr expr;
2199   constraintExprUnaryOpKind unaryOp;
2200   constraintExpr ret;
2201
2202   char * str;
2203   char * os;
2204
2205   str = mstring_create (MAX_DUMP_LINE_LENGTH);
2206   os = str;
2207   str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
2208
2209   if (! mstring_isDefined(str) )
2210     {
2211       llfatalbug(message("Library file is corrupted") );
2212     }
2213
2214   unaryOp = (constraintExprUnaryOpKind) reader_getInt(&str);
2215
2216   expr = constraintExpr_undump (f);
2217
2218   ret = constraintExpr_makeUnaryOp (expr, unaryOp);
2219
2220   free(os);
2221
2222   return ret;
2223 }
2224
2225 void  constraintExpr_dump (/*@observer@*/ constraintExpr expr,  FILE *f)
2226 {
2227   constraintExprKind kind;
2228   constraintTerm t;
2229
2230
2231   llassert(constraintExpr_isDefined(expr) );
2232
2233   DPRINTF((message("constraintExpr_dump:: dumping constraintExpr %s",
2234                    constraintExpr_unparse(expr)
2235                    ) ));
2236
2237   kind = expr->kind;
2238
2239   fprintf(f,"%d\n", (int) kind);
2240
2241   switch (kind)
2242     {
2243     case term:
2244       t = constraintExprData_termGetTerm (expr->data);
2245       constraintTerm_dump (t, f);
2246       break;
2247     case unaryExpr:
2248       unaryExpr_dump (expr->data, f);
2249       break;
2250     case binaryexpr:
2251       binaryExpr_dump  (expr->data, f);
2252       break;
2253     }
2254 }
2255
2256 /*@only@*/ constraintExpr  constraintExpr_undump (FILE *f)
2257 {
2258   constraintExprKind kind;
2259   constraintTerm t;
2260   constraintExpr ret;
2261
2262   char * s;
2263   char * os;
2264
2265   os = mstring_create (MAX_DUMP_LINE_LENGTH);
2266   s = fgets(os, MAX_DUMP_LINE_LENGTH, f);
2267   if (! mstring_isDefined(s))
2268     {
2269       llfatalbug(message("Library file is corrupted") );
2270     }
2271
2272   kind = (constraintExprKind) reader_getInt(&s);
2273
2274   free (os);
2275
2276   switch (kind)
2277     {
2278     case term:
2279       t = constraintTerm_undump (f);
2280       ret = constraintExpr_makeTerm(t);
2281       break;
2282     case unaryExpr:
2283       ret = unaryExpr_undump (f);
2284       break;
2285     case binaryexpr:
2286       ret = binaryExpr_undump  (f);
2287       break;
2288     BADDEFAULT;
2289     }
2290
2291   return ret;
2292 }
2293
2294 int constraintExpr_getDepth (constraintExpr ex)
2295 {
2296   int ret;
2297
2298   constraintExprKind kind;
2299
2300   llassert (ex != NULL);
2301
2302   kind = ex->kind;
2303
2304   switch (kind)
2305     {
2306     case term:
2307       ret = 1;
2308       break;
2309     case unaryExpr:
2310       ret =  constraintExpr_getDepth (constraintExprData_unaryExprGetExpr (ex->data) );
2311       ret++;
2312       break;
2313     case binaryexpr:
2314       ret = constraintExpr_getDepth (constraintExprData_binaryExprGetExpr1 (ex->data) );
2315       ret++;
2316       ret += constraintExpr_getDepth (constraintExprData_binaryExprGetExpr2 (ex->data) );
2317       break;
2318     BADDEFAULT;
2319     }
2320
2321   return ret;
2322 }
2323
2324
2325 bool constraintExpr_canGetCType (constraintExpr e) /*@*/
2326 {
2327   if (constraintExpr_isUndefined(e))
2328     return FALSE;
2329
2330   if (e->kind == term)
2331     {
2332       return TRUE;
2333     }
2334   else
2335     {
2336       DPRINTF (("constraintExpr_canGetCType: can't get type for %s", constraintExpr_unparse (e)));
2337       return FALSE;
2338     }
2339 }
2340
2341 ctype constraintExpr_getCType (constraintExpr e) /*@*/
2342 {
2343   constraintTerm t;
2344
2345   llassert (constraintExpr_isDefined (e));
2346   llassert (constraintExpr_canGetCType (e));
2347
2348   switch (e->kind)
2349     {
2350     case term:
2351       t = constraintExprData_termGetTerm (e->data);
2352       return (constraintTerm_getCType(t) );
2353       /* assume that a unary expression will be an int ... */
2354     case unaryExpr:
2355       return ctype_unknown; /* was ctype_signedintegral; */
2356       /* drl for just return type of first operand */
2357     case binaryexpr:
2358       return (constraintExpr_getCType (constraintExprData_binaryExprGetExpr1 (e->data)));
2359     BADDEFAULT;
2360     }
2361 }
2362
2363 /* drl add 10-5-001 */
2364
2365 static bool constraintExpr_hasTypeChange (constraintExpr e)
2366 {
2367   llassert(constraintExpr_isDefined(e));
2368
2369   if (constraintExpr_isDefined((e)) && (e->ct == TRUE))
2370     {
2371       return TRUE;
2372     }
2373
2374   if (e->kind == unaryExpr)
2375     {
2376       if (constraintExprData_unaryExprGetOp (e->data) == MAXSET)
2377         {
2378           constraintExpr ce = constraintExprData_unaryExprGetExpr(e->data);
2379           DPRINTF (("Unary type change: [%x] %s", ce, constraintExpr_unparse (ce)));
2380           DPRINTF (("Types: %s / %s", ctype_unparse (constraintExpr_getCType (ce)),
2381                     ctype_unparse (constraintExpr_getOrigType (ce))));
2382           return (constraintExpr_hasTypeChange(ce));
2383         }
2384     }
2385
2386   return FALSE;
2387 }
2388
2389 /* drl add 10-5-001 */
2390
2391 static ctype constraintExpr_getOrigType (constraintExpr e)
2392 {
2393   llassert (constraintExpr_isDefined (e));
2394   llassert (constraintExpr_hasTypeChange (e));
2395
2396   if (e->ct == TRUE)
2397     {
2398       return e->origType;
2399     }
2400
2401   if (e->kind == unaryExpr)
2402     {
2403       if (constraintExprData_unaryExprGetOp (e->data) == MAXSET)
2404         {
2405           constraintExpr ce = constraintExprData_unaryExprGetExpr (e->data);
2406           return (constraintExpr_getOrigType(ce));
2407         }
2408
2409     }
2410
2411   BADEXIT;
2412 }
2413
2414 /*drl added these around 10/18/001*/
2415
2416 static /*@only@*/ constraintExpr
2417 constraintExpr_div (/*@only@*/ constraintExpr e, ctype tfrom, ctype tto, fileloc loc)
2418 {
2419   int sizefrom = ctype_getSize (tfrom);
2420   int sizeto = ctype_getSize (tto);
2421
2422   DPRINTF (("%s: %s", __func__, constraintExpr_unparse (e)));
2423   DPRINTF (("Types: %s / %s",
2424               ctype_unparse (tfrom),
2425               ctype_unparse (tto)));
2426
2427   if (sizefrom == -1) {
2428     llbug (message ("constraintExpr_div: type size unknown: %s", ctype_unparse (tfrom)));
2429   }
2430
2431   if (sizeto == -1) {
2432     llbug (message ("constraintExpr_div: type size unknown: %s", ctype_unparse (tto)));
2433   }
2434
2435   if (sizeto == sizefrom)
2436     {
2437       DPRINTF (("Sizes match: %d / %d", sizeto, sizefrom));
2438       ; /* Sizes match, a-ok */
2439     }
2440   else
2441     {
2442       constraintTerm ct;
2443
2444       llassert (e != NULL);
2445       llassert (e->kind == term);
2446       ct = constraintExprData_termGetTerm (e->data);
2447       if (!constraintTerm_canGetValue (ct))
2448         {
2449           DPRINTF (("%s: can't get constraint term value: %s", __func__,
2450                       constraintTerm_unparse (ct)));
2451         }
2452       else
2453         {
2454           long val;
2455
2456           DPRINTF (("constraint: %s / %s", constraintExpr_unparse (e),
2457                       constraintTerm_unparse (ct)));
2458
2459           val = constraintTerm_getValue (ct);
2460           if ((val * sizefrom) % sizeto != 0)
2461             {
2462               voptgenerror (FLG_ALLOCMISMATCH,
2463                             message ("Allocated memory is converted to type %s of (size %d), "
2464                                      "which is not divisible into original allocation of space "
2465                                      "for %d elements of type %s (size %d)",
2466                                      ctype_unparse (tto), sizeto,
2467                                      long_toInt (val), ctype_unparse (tfrom), sizefrom),
2468                             loc);
2469             }
2470           constraintTerm_setValue (ct, (val * sizefrom) / sizeto);
2471         }
2472     }
2473
2474   DPRINTF (("After div: %s", constraintExpr_unparse (e)));
2475   return e;
2476 }
2477
2478
2479 /*@access exprNode@*/
2480 static /*@only@*/ constraintExpr
2481 constraintTerm_simpleDivTypeExprNode (/*@only@*/ constraintExpr e, ctype tfrom, ctype tto, fileloc loc)
2482 {
2483   exprData data;
2484   exprNode t1, t2, expr;
2485   lltok tok;
2486   constraintTerm t;
2487
2488   llassert (constraintExpr_isDefined(e) );
2489
2490   DPRINTF (("constraintTerm_simpleDivTypeExprNode e=%s [%s => %s]", constraintExpr_print(e),
2491             ctype_unparse(tfrom), ctype_unparse (tto)));
2492
2493   t = constraintExprData_termGetTerm (e->data);
2494
2495   expr = constraintTerm_getExprNode (t);
2496
2497   llassert (constraintExpr_isDefined(e));
2498   llassert (exprNode_isDefined(expr));
2499
2500   if (expr->kind == XPR_OP)
2501     {
2502       data = expr->edata;
2503
2504       t1 = exprData_getOpA (data);
2505       t2 = exprData_getOpB (data);
2506       tok = exprData_getOpTok (data);
2507
2508       if (lltok_isMult (tok))
2509         {
2510           /*
2511           ** If the sizeof is first, flip them.
2512           */
2513
2514           llassert (exprNode_isDefined(t1) && exprNode_isDefined(t2));
2515
2516           if (t2->kind == XPR_SIZEOF || t2->kind == XPR_SIZEOFT)
2517             {
2518               exprNode tmp = t1;
2519               t1 = t2;
2520               t2 = tmp;
2521             }
2522
2523           /*drl 3/2/2003 we know this from the fact that it's a
2524             multiplication operation...*/
2525
2526           if (t1->kind == XPR_SIZEOF || t1->kind == XPR_SIZEOFT)
2527             {
2528               ctype multype;
2529
2530               if (t1->kind == XPR_SIZEOFT)
2531                 {
2532                   multype = qtype_getType (exprData_getType (t1->edata));
2533                 }
2534               else
2535                 {
2536                   exprNode tempE = exprData_getSingle (t1->edata);
2537                   multype = exprNode_getType (tempE);
2538                 }
2539
2540               DPRINTF (("Here we go sizeof: %s / %s / %s",
2541                         ctype_unparse (multype), ctype_unparse (tfrom), ctype_unparse (tto)));
2542               llassert (ctype_isPointer (tfrom));
2543
2544               if (ctype_almostEqual (ctype_makePointer (multype), tto))
2545                 {
2546                   /* this is a bit sloopy but ... */
2547                   constraintExpr_free (e);
2548                   DPRINTF (("Sizeof types match okay!"));
2549                   return constraintExpr_makeExprNode (t2);
2550                 }
2551               else
2552                 {
2553                   int sizemul = ctype_getSize (multype);
2554                   ctype tobase = ctype_baseArrayPtr (tto);
2555                   int sizeto = ctype_getSize (tobase);
2556
2557                   DPRINTF (("Types: %s / %s / %s",
2558                             ctype_unparse (tfrom), ctype_unparse (tto), ctype_unparse (multype)));
2559
2560                   voptgenerror (FLG_ALLOCMISMATCH,
2561                                 message ("Allocated memory is used as a different type (%s) from the sizeof type (%s)",
2562                                          ctype_unparse (tobase), ctype_unparse (multype)),
2563                                 loc);
2564
2565                   if (sizemul == sizeto)
2566                     {
2567                       constraintExpr_free (e);
2568                       DPRINTF (("Sizeof types match okay!"));
2569                       return constraintExpr_makeExprNode (t2);
2570                     }
2571                   else
2572                     {
2573                       /* nothing was here */
2574                       DPRINTF (("MISMATCHING TYPES!"));
2575                       return (constraintExpr_div (constraintExpr_makeExprNode (t2), multype, tto, loc));
2576                     }
2577                 }
2578             }
2579           else
2580             {
2581               DPRINTF (("NOT A SIZEOF!"));
2582               /* empty */
2583             }
2584         }
2585       else
2586         {
2587           DPRINTF (("Not a mult: %s", constraintExpr_unparse (e)));
2588         }
2589     }
2590
2591   return (constraintExpr_div (e, tfrom, tto, loc));
2592 }
2593 /*@noaccess exprNode@*/
2594
2595 static /*@only@*/ constraintExpr simpleDivType (/*@only@*/ constraintExpr e, ctype tfrom, ctype tto, fileloc loc)
2596 {
2597   DPRINTF (("simpleDiv got %s", constraintExpr_unparse(e)));
2598   DPRINTF (("Types: %s / %s",
2599             ctype_unparse (tfrom),
2600             ctype_unparse (tto)));
2601
2602   llassert (constraintExpr_isDefined(e));
2603
2604   switch (e->kind)
2605     {
2606     case term:
2607       {
2608         constraintTerm t = constraintExprData_termGetTerm (e->data);
2609
2610         DPRINTF (("Term: %s", constraintTerm_unparse (t)));
2611
2612         if (constraintTerm_isExprNode (t))
2613           {
2614             return constraintTerm_simpleDivTypeExprNode (e, tfrom, tto, loc);
2615
2616             /* search for * size of ct and remove */
2617           }
2618         DPRINTF (("Here: %s / %s -> %s", constraintExpr_unparse (e), ctype_unparse (tfrom), ctype_unparse (tto)));
2619         return constraintExpr_div (e, tfrom, tto, loc);
2620       }
2621
2622     case binaryexpr:
2623       {
2624         constraintExpr temp;
2625
2626         temp = constraintExprData_binaryExprGetExpr1 (e->data);
2627         temp = constraintExpr_copy(temp);
2628         temp = simpleDivType (temp, tfrom, tto, loc);
2629
2630         e->data = constraintExprData_binaryExprSetExpr1 (e->data, temp);
2631
2632         temp = constraintExprData_binaryExprGetExpr2 (e->data);
2633         temp = constraintExpr_copy(temp);
2634         temp = simpleDivType (temp, tfrom, tto, loc);
2635         e->data = constraintExprData_binaryExprSetExpr2 (e->data, temp);
2636
2637         DPRINTF (("simpleDiv binaryexpr returning %s ", constraintExpr_unparse(e)));
2638         return e;
2639       }
2640     case unaryExpr:
2641       {
2642         return constraintExpr_div (e, tfrom, tto, loc);
2643       }
2644
2645     BADDEFAULT;
2646     }
2647 }
2648
2649 static /*@only@*/ constraintExpr constraintExpr_adjustMaxSetForCast (/*@only@*/ constraintExpr e, ctype tfrom,
2650                                                                      ctype tto, fileloc loc)
2651 {
2652   DPRINTF (("constraintExpr_adjustMaxSetForCast got %s [%s => %s]", constraintExpr_unparse(e),
2653             ctype_unparse (tfrom), ctype_unparse (tto)));
2654
2655   e = constraintExpr_makeIncConstraintExpr (e);
2656   e = constraintExpr_simplify (e);
2657   e = simpleDivType (e, tfrom, tto, loc);
2658   e = constraintExpr_makeDecConstraintExpr (e);
2659   e = constraintExpr_simplify (e);
2660
2661   DPRINTF (("constraintExpr_adjustMaxSetForCast returning %s ", constraintExpr_unparse(e)));
2662   return e;
2663 }
2664
2665
2666 bool constraintExpr_isConstantOnly (constraintExpr e)
2667 {
2668   DPRINTF (("constraintExpr_isConstantOnly %s ", constraintExpr_unparse(e)));
2669   llassert (constraintExpr_isDefined(e));
2670
2671   switch (e->kind)
2672     {
2673     case term:
2674       {
2675         constraintTerm t = constraintExprData_termGetTerm(e->data);
2676
2677         if (constraintTerm_isConstantOnly (t))
2678           {
2679             return TRUE;
2680           }
2681         else
2682           {
2683             return FALSE;
2684           }
2685       }
2686
2687     case binaryexpr:
2688       {
2689         constraintExpr temp1 = constraintExprData_binaryExprGetExpr1 (e->data);
2690         constraintExpr temp2 = constraintExprData_binaryExprGetExpr2 (e->data);
2691
2692         if (constraintExpr_isConstantOnly(temp1) &&
2693             constraintExpr_isConstantOnly(temp2) )
2694           {
2695             return TRUE;
2696           }
2697         else
2698           {
2699             return FALSE;
2700           }
2701       }
2702
2703     case unaryExpr:
2704       {
2705         constraintExpr temp;
2706
2707         temp = constraintExprData_unaryExprGetExpr (e->data );
2708
2709         if (constraintExpr_isConstantOnly(temp) )
2710           {
2711             return TRUE;
2712           }
2713         else
2714           {
2715             return FALSE;
2716           }
2717       }
2718
2719     BADDEFAULT;
2720     }
2721 }
2722