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