home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #19 / NN_1992_19.iso / spool / gnu / gcc / bug / 2247 < prev    next >
Encoding:
Text File  |  1992-09-02  |  24.5 KB  |  914 lines
  1. Newsgroups: gnu.gcc.bug
  2. Path: sparky!uunet!cis.ohio-state.edu!twinsun.COM!eggert
  3. From: eggert@twinsun.COM (Paul Eggert)
  4. Subject: GCC 2.2.2 patches for overflow detection in constant expressions
  5. Message-ID: <9209030412.AA26982@farside.twinsun.com>
  6. Sender: gnulists@ai.mit.edu
  7. Organization: GNUs Not Usenet
  8. Distribution: gnu
  9. Date: Thu, 3 Sep 1992 04:12:21 GMT
  10. Approved: bug-gcc@prep.ai.mit.edu
  11. Lines: 901
  12.  
  13. GCC 2.2.2 doesn't check for overflow in constant expressions, even though it
  14. really should -- not only because ANSI says so, but because it catches several
  15. all-too-common coding errors.  Here is a patch.
  16.  
  17. Thu Sep  3 02:33:55 1992  Paul Eggert  (eggert@twinsun.com)
  18.  
  19.     * c-typeck.c (constant_expression_warning): Now works;
  20.     it reports signed integer overflow in constant expressions,
  21.     and uncasted negative constants that appear in unsigned contexts.
  22.     (build_c_cast, convert_for_assignment, parser_build_binary_op,
  23.     store_init_value) Check for overflow.
  24.     * c-parse.y (unary_expr): Likewise.
  25.     * c-tree.h (constant_expression_warning): Now exported.
  26.  
  27.     * fold-const.c (left_shift_overflows, possible_sum_sign) New macros.
  28.     (force_fit_type): Mark overflowed or truncated INTEGER_CSTs.
  29.     (add_double, div_and_round_double, lshift_double, mul_double,
  30.     neg_double, const_binop, fold): Check for signed integer overflow.
  31.     (const_binop, fold_convert): Use pedwarn for overflow warnings.
  32.     Say `constant expression', not `constant folding', for user's sake.
  33.  
  34. ===================================================================
  35. RCS file: c-parse.y,v
  36. retrieving revision 2.2.2.3
  37. diff -c2 -r2.2.2.3 c-parse.y
  38. *** c-parse.y    1992/08/13 23:59:47    2.2.2.3
  39. --- c-parse.y    1992/09/02 19:17:38
  40. ***************
  41. *** 331,335 ****
  42.             pedantic = $<itype>1; }
  43.       | unop cast_expr  %prec UNARY
  44. !         { $$ = build_unary_op ($1, $2, 0); }
  45.       /* Refer to the address of a label as a pointer.  */
  46.       | ANDAND identifier
  47. --- 331,336 ----
  48.             pedantic = $<itype>1; }
  49.       | unop cast_expr  %prec UNARY
  50. !         { $$ = build_unary_op ($1, $2, 0);
  51. !           constant_expression_warning ($$, 0); }
  52.       /* Refer to the address of a label as a pointer.  */
  53.       | ANDAND identifier
  54. ===================================================================
  55. RCS file: c-tree.h,v
  56. retrieving revision 2.2
  57. diff -c2 -r2.2 c-tree.h
  58. *** c-tree.h    1992/03/14 20:55:54    2.2
  59. --- c-tree.h    1992/09/02 19:15:57
  60. ***************
  61. *** 108,111 ****
  62. --- 108,112 ----
  63.   extern tree c_expand_start_case ();
  64.   extern tree default_conversion ();
  65. + extern void constant_expression_warning ();
  66.   
  67.   /* Given two integer or real types, return the type for their sum.
  68. ===================================================================
  69. RCS file: c-typeck.c,v
  70. retrieving revision 2.2.2.7
  71. diff -c2 -r2.2.2.7 c-typeck.c
  72. *** c-typeck.c    1992/08/29 23:55:12    2.2.2.7
  73. --- c-typeck.c    1992/09/03 02:27:45
  74. ***************
  75. *** 785,796 ****
  76.   
  77.   /* Print a warning if a constant expression had overflow in folding.
  78. !    This doesn't really work--it is waiting for changes in fold.  */
  79.   
  80.   void
  81. ! constant_expression_warning (value)
  82.        tree value;
  83.   {
  84. !   if (TREE_CODE (value) == NON_LVALUE_EXPR && TREE_CONSTANT_OVERFLOW (value))
  85. !     pedwarn ("overflow in constant expression");
  86.   }
  87.   
  88. --- 785,804 ----
  89.   
  90.   /* Print a warning if a constant expression had overflow in folding.
  91. !    If EVEN_IF_UNSIGNED is nonzero, warn even if the expression is unsigned.  */
  92.   
  93.   void
  94. ! constant_expression_warning (value, even_if_unsigned)
  95.        tree value;
  96. +      int even_if_unsigned;
  97.   {
  98. !   if (TREE_CODE (value) == INTEGER_CST
  99. !       && TREE_CONSTANT_OVERFLOW (value)
  100. !       && (! TREE_UNSIGNED (TREE_TYPE (value)) || even_if_unsigned))
  101. !     {
  102. !       TREE_CONSTANT_OVERFLOW (value) = 0;
  103. !       pedwarn (TREE_UNSIGNED (TREE_TYPE (value))
  104. !            ? "constant expression out of range for unsigned type"
  105. !            : "signed integer overflow in constant expression");
  106. !     }
  107.   }
  108.   
  109. ***************
  110. *** 2135,2138 ****
  111. --- 2143,2148 ----
  112.       warning ("comparisons like X<=Y<=Z do not have the usual meaning");
  113.   
  114. +   constant_expression_warning (result, 0);
  115. + 
  116.     class = TREE_CODE_CLASS (TREE_CODE (result));
  117.   
  118. ***************
  119. *** 3728,3731 ****
  120. --- 3738,3742 ----
  121.   
  122.         value = convert (type, value);
  123. +       constant_expression_warning (value, 0);
  124.       }
  125.   
  126. ***************
  127. *** 3946,3950 ****
  128.         (coder == INTEGER_TYPE || coder == REAL_TYPE || coder == ENUMERAL_TYPE))
  129.       {
  130. !       return convert (type, rhs);
  131.       }
  132.     /* Conversions among pointers */
  133. --- 3957,3963 ----
  134.         (coder == INTEGER_TYPE || coder == REAL_TYPE || coder == ENUMERAL_TYPE))
  135.       {
  136. !       tree t = convert (type, rhs);
  137. !       constant_expression_warning (t, 1);
  138. !       return t;
  139.       }
  140.     /* Conversions among pointers */
  141. ***************
  142. *** 4233,4237 ****
  143.   
  144.     /* ANSI wants warnings about out-of-range constant initializers.  */
  145. !   constant_expression_warning (value);
  146.   
  147.     DECL_INITIAL (decl) = value;
  148. --- 4246,4250 ----
  149.   
  150.     /* ANSI wants warnings about out-of-range constant initializers.  */
  151. !   constant_expression_warning (value, 1);
  152.   
  153.     DECL_INITIAL (decl) = value;
  154. ===================================================================
  155. RCS file: fold-const.c,v
  156. retrieving revision 2.2.2.4
  157. diff -c2 -r2.2.2.4 fold-const.c
  158. *** fold-const.c    1992/08/29 08:21:30    2.2.2.4
  159. --- fold-const.c    1992/09/03 02:33:55
  160. ***************
  161. *** 49,53 ****
  162.   static jmp_buf float_error;
  163.   
  164. ! void lshift_double ();
  165.   void rshift_double ();
  166.   void lrotate_double ();
  167. --- 49,53 ----
  168.   static jmp_buf float_error;
  169.   
  170. ! int lshift_double ();
  171.   void rshift_double ();
  172.   void lrotate_double ();
  173. ***************
  174. *** 54,57 ****
  175. --- 54,65 ----
  176.   void rrotate_double ();
  177.   static tree const_binop ();
  178. + 
  179. + /* Yield nonzero if a signed left shift of A by B bits overflows.
  180. +    A is a C int; B is nonnegative.  */
  181. + #define left_shift_overflows(a, b)  ((a)  ^  ((a) << (b)) >> (b))
  182. + 
  183. + /* Yield nonzero if adding two numbers with A's and B's signs can yield a
  184. +    number with SUM's sign, where A, B, and SUM are all C ints.  */
  185. + #define possible_sum_sign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0)
  186.   
  187.   /* To do constant folding on INTEGER_CST nodes requires 64-bit arithmetic.
  188. ***************
  189. *** 97,106 ****
  190.   /* Make the integer constant T valid for its type
  191.      by setting to 0 or 1 all the bits in the constant
  192. !    that don't belong in the type.  */
  193.   
  194.   static void
  195. ! force_fit_type (t)
  196.        tree t;
  197.   {
  198.     register int prec = TYPE_PRECISION (TREE_TYPE (t));
  199.   
  200. --- 105,119 ----
  201.   /* Make the integer constant T valid for its type
  202.      by setting to 0 or 1 all the bits in the constant
  203. !    that don't belong in the type.
  204. !    Mark the constant if it has overflowed.
  205. !    If OVERFLOW is nonzero and the result is signed,
  206. !    the calculation has already overflowed.  */
  207.   
  208.   static void
  209. ! force_fit_type (t, overflow)
  210.        tree t;
  211. +      int overflow;
  212.   {
  213. +   int low = TREE_INT_CST_LOW (t), high = TREE_INT_CST_HIGH (t);
  214.     register int prec = TYPE_PRECISION (TREE_TYPE (t));
  215.   
  216. ***************
  217. *** 148,154 ****
  218. --- 161,174 ----
  219.       }
  220.       }
  221. + 
  222. +   /* In C, by definition, unsigned arithmetic does not overflow.
  223. +      But sometimes we want to warn about unsigned truncation.  */
  224. +   if ((low ^ TREE_INT_CST_LOW (t)) | (high ^ TREE_INT_CST_HIGH (t))
  225. +       || overflow && ! TREE_UNSIGNED (TREE_TYPE (t)))
  226. +     TREE_CONSTANT_OVERFLOW (t) = 1;
  227.   }
  228.   
  229.   /* Add two 64-bit integers with 64-bit result.
  230. +    Yield nonzero if the (signed) operation overflows.
  231.      Each argument is given as two `int' pieces.
  232.      One argument is L1 and H1; the other, L2 and H2.
  233. ***************
  234. *** 156,160 ****
  235.      We use the 8-shorts representation internally.  */
  236.   
  237. ! void
  238.   add_double (l1, h1, l2, h2, lv, hv)
  239.        int l1, h1, l2, h2;
  240. --- 176,180 ----
  241.      We use the 8-shorts representation internally.  */
  242.   
  243. ! int
  244.   add_double (l1, h1, l2, h2, lv, hv)
  245.        int l1, h1, l2, h2;
  246. ***************
  247. *** 177,183 ****
  248. --- 197,205 ----
  249.   
  250.     decode (arg1, lv, hv);
  251. +   return !possible_sum_sign (h1, h2, *hv);
  252.   }
  253.   
  254.   /* Negate a 64-bit integers with 64-bit result.
  255. +    Yield nonzero if the (signed) operation overflows.
  256.      The argument is given as two `int' pieces in L1 and H1.
  257.      The value is stored as two `int' pieces in *LV and *HV.
  258. ***************
  259. *** 184,188 ****
  260.      We use the 8-shorts representation internally.  */
  261.   
  262. ! void
  263.   neg_double (l1, h1, lv, hv)
  264.        int l1, h1;
  265. --- 206,210 ----
  266.      We use the 8-shorts representation internally.  */
  267.   
  268. ! int
  269.   neg_double (l1, h1, lv, hv)
  270.        int l1, h1;
  271. ***************
  272. *** 199,205 ****
  273. --- 221,229 ----
  274.         *hv = ~ h1;
  275.       }
  276. +   return (h1 & *hv) < 0;
  277.   }
  278.   
  279.   /* Multiply two 64-bit integers with 64-bit result.
  280. +    Yield nonzero if the (signed) operation overflows.
  281.      Each argument is given as two `int' pieces.
  282.      One argument is L1 and H1; the other, L2 and H2.
  283. ***************
  284. *** 207,211 ****
  285.      We use the 8-shorts representation internally.  */
  286.   
  287. ! void
  288.   mul_double (l1, h1, l2, h2, lv, hv)
  289.        int l1, h1, l2, h2;
  290. --- 231,235 ----
  291.      We use the 8-shorts representation internally.  */
  292.   
  293. ! int
  294.   mul_double (l1, h1, l2, h2, lv, hv)
  295.        int l1, h1, l2, h2;
  296. ***************
  297. *** 217,223 ****
  298.     register int carry = 0;
  299.     register int i, j, k;
  300.   
  301. !   /* These two cases are used extensively, arising from pointer
  302. !      combinations.  */
  303.     if (h2 == 0)
  304.       {
  305. --- 241,247 ----
  306.     register int carry = 0;
  307.     register int i, j, k;
  308. +   int toplow, tophigh, neglow, neghigh;
  309.   
  310. !   /* These cases are used extensively, arising from pointer combinations.  */
  311.     if (h2 == 0)
  312.       {
  313. ***************
  314. *** 224,236 ****
  315.         if (l2 == 2)
  316.       {
  317.         unsigned temp = l1 + l1;
  318. !       *hv = h1 * 2 + (temp < l1);
  319.         *lv = temp;
  320. !       return;
  321.       }
  322.         if (l2 == 4)
  323.       {
  324.         unsigned temp = l1 + l1;
  325. !       h1 = h1 * 4 + ((temp < l1) << 1);
  326.         l1 = temp;
  327.         temp += temp;
  328. --- 248,262 ----
  329.         if (l2 == 2)
  330.       {
  331. +       int overflow = left_shift_overflows (h1, 1);
  332.         unsigned temp = l1 + l1;
  333. !       *hv = (h1 << 1) + (temp < l1);
  334.         *lv = temp;
  335. !       return overflow;
  336.       }
  337.         if (l2 == 4)
  338.       {
  339. +       int overflow = left_shift_overflows (h1, 2);
  340.         unsigned temp = l1 + l1;
  341. !       h1 = (h1 << 2) + ((temp < l1) << 1);
  342.         l1 = temp;
  343.         temp += temp;
  344. ***************
  345. *** 238,247 ****
  346.         *lv = temp;
  347.         *hv = h1;
  348. !       return;
  349.       }
  350.         if (l2 == 8)
  351.       {
  352.         unsigned temp = l1 + l1;
  353. !       h1 = h1 * 8 + ((temp < l1) << 2);
  354.         l1 = temp;
  355.         temp += temp;
  356. --- 264,274 ----
  357.         *lv = temp;
  358.         *hv = h1;
  359. !       return overflow;
  360.       }
  361.         if (l2 == 8)
  362.       {
  363. +       int overflow = left_shift_overflows (h1, 3);
  364.         unsigned temp = l1 + l1;
  365. !       h1 = (h1 << 3) + ((temp < l1) << 2);
  366.         l1 = temp;
  367.         temp += temp;
  368. ***************
  369. *** 252,256 ****
  370.         *lv = temp;
  371.         *hv = h1;
  372. !       return;
  373.       }
  374.       }
  375. --- 279,283 ----
  376.         *lv = temp;
  377.         *hv = h1;
  378. !       return overflow;
  379.       }
  380.       }
  381. ***************
  382. *** 276,279 ****
  383. --- 303,321 ----
  384.   
  385.     decode (prod, lv, hv);    /* @@decode ignores prod[8] -> prod[15] */
  386. + 
  387. +   /* Check for overflow by calculating the top half of the answer in full;
  388. +      it should agree with the low half's sign bit.  */
  389. +   decode (prod+8, &toplow, &tophigh);
  390. +   if (h1 < 0)
  391. +     {
  392. +       neg_double (l2, h2, &neglow, &neghigh);
  393. +       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
  394. +     }
  395. +   if (h2 < 0)
  396. +     {
  397. +       neg_double (l1, h1, &neglow, &neghigh);
  398. +       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
  399. +     }
  400. +   return *hv < 0 ? ~(toplow & tophigh) : (toplow | tophigh);
  401.   }
  402.   
  403. ***************
  404. *** 282,288 ****
  405.      Shift right if COUNT is negative.
  406.      ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
  407.      Store the value as two `int' pieces in *LV and *HV.  */
  408.   
  409. ! void
  410.   lshift_double (l1, h1, count, prec, lv, hv, arith)
  411.        int l1, h1, count, prec;
  412. --- 324,331 ----
  413.      Shift right if COUNT is negative.
  414.      ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
  415. +    Yield nonzero if the arithmetic shift overflows.
  416.      Store the value as two `int' pieces in *LV and *HV.  */
  417.   
  418. ! int
  419.   lshift_double (l1, h1, count, prec, lv, hv, arith)
  420.        int l1, h1, count, prec;
  421. ***************
  422. *** 292,296 ****
  423.     short arg1[8];
  424.     register int i;
  425. !   register int carry;
  426.   
  427.     if (count < 0)
  428. --- 335,339 ----
  429.     short arg1[8];
  430.     register int i;
  431. !   register int carry, overflow;
  432.   
  433.     if (count < 0)
  434. ***************
  435. *** 297,301 ****
  436.       {
  437.         rshift_double (l1, h1, - count, prec, lv, hv, arith);
  438. !       return;
  439.       }
  440.   
  441. --- 340,344 ----
  442.       {
  443.         rshift_double (l1, h1, - count, prec, lv, hv, arith);
  444. !       return 0;
  445.       }
  446.   
  447. ***************
  448. *** 305,308 ****
  449. --- 348,352 ----
  450.       count = prec;
  451.   
  452. +   overflow = 0;
  453.     while (count > 0)
  454.       {
  455. ***************
  456. *** 315,325 ****
  457.       }
  458.         count--;
  459.       }
  460.   
  461.     decode (arg1, lv, hv);
  462.   }
  463.   
  464.   /* Shift the 64-bit integer in L1, H1 right by COUNT places
  465. !    keeping only PREC bits of result.  COUNT must be positive.
  466.      ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
  467.      Store the value as two `int' pieces in *LV and *HV.  */
  468. --- 359,371 ----
  469.       }
  470.         count--;
  471. +       overflow |= carry ^ (arg1[7] >> 7);
  472.       }
  473.   
  474.     decode (arg1, lv, hv);
  475. +   return overflow;
  476.   }
  477.   
  478.   /* Shift the 64-bit integer in L1, H1 right by COUNT places
  479. !    keeping only PREC bits of result.  COUNT must be nonnegative.
  480.      ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
  481.      Store the value as two `int' pieces in *LV and *HV.  */
  482. ***************
  483. *** 434,440 ****
  484.      or EXACT_DIV_EXPR
  485.      It controls how the quotient is rounded to a integer.
  486.      UNS nonzero says do unsigned division.  */
  487.   
  488. ! static void
  489.   div_and_round_double (code, uns,
  490.                 lnum_orig, hnum_orig, lden_orig, hden_orig,
  491. --- 480,487 ----
  492.      or EXACT_DIV_EXPR
  493.      It controls how the quotient is rounded to a integer.
  494. +    Yield nonzero if the operation overflows.
  495.      UNS nonzero says do unsigned division.  */
  496.   
  497. ! static int
  498.   div_and_round_double (code, uns,
  499.                 lnum_orig, hnum_orig, lden_orig, hden_orig,
  500. ***************
  501. *** 454,457 ****
  502. --- 501,505 ----
  503.     unsigned int lden = lden_orig;
  504.     int hden = hden_orig;
  505. +   int overflow = 0;
  506.   
  507.     if ((hden == 0) && (lden == 0))
  508. ***************
  509. *** 461,473 ****
  510.     if (!uns) 
  511.       {
  512. !       if (hden < 0) 
  513.       {
  514.         quo_neg = ~ quo_neg;
  515. !       neg_double (lden, hden, &lden, &hden);
  516.       }
  517. !       if (hnum < 0)
  518.       {
  519.         quo_neg = ~ quo_neg;
  520. !       neg_double (lnum, hnum, &lnum, &hnum);
  521.       }
  522.       }
  523. --- 509,523 ----
  524.     if (!uns) 
  525.       {
  526. !       if (hnum < 0)
  527.       {
  528.         quo_neg = ~ quo_neg;
  529. !       /* (minimum integer) / (-1) is the only overflow case.  */
  530. !       if (neg_double (lnum, hnum, &lnum, &hnum))
  531. !         overflow = ~(hden & lden);
  532.       }
  533. !       if (hden < 0) 
  534.       {
  535.         quo_neg = ~ quo_neg;
  536. !       neg_double (lden, hden, &lden, &hden);
  537.       }
  538.       }
  539. ***************
  540. *** 642,646 ****
  541.       case TRUNC_MOD_EXPR:    /* round toward zero */
  542.       case EXACT_DIV_EXPR:    /* for this one, it shouldn't matter */
  543. !       return;
  544.   
  545.       case FLOOR_DIV_EXPR:
  546. --- 692,696 ----
  547.       case TRUNC_MOD_EXPR:    /* round toward zero */
  548.       case EXACT_DIV_EXPR:    /* for this one, it shouldn't matter */
  549. !       return overflow;
  550.   
  551.       case FLOOR_DIV_EXPR:
  552. ***************
  553. *** 651,655 ****
  554.         add_double (*lquo, *hquo, -1, -1, lquo, hquo);
  555.       }
  556. !       else return;
  557.         break;
  558.   
  559. --- 701,705 ----
  560.         add_double (*lquo, *hquo, -1, -1, lquo, hquo);
  561.       }
  562. !       else return overflow;
  563.         break;
  564.   
  565. ***************
  566. *** 660,664 ****
  567.         add_double (*lquo, *hquo, 1, 0, lquo, hquo);
  568.       }
  569. !       else return;
  570.         break;
  571.       
  572. --- 710,714 ----
  573.         add_double (*lquo, *hquo, 1, 0, lquo, hquo);
  574.       }
  575. !       else return overflow;
  576.         break;
  577.       
  578. ***************
  579. *** 686,690 ****
  580.             add_double (*lquo, *hquo, 1, 0, lquo, hquo);
  581.         }
  582. !     else return;
  583.         }
  584.         break;
  585. --- 736,740 ----
  586.             add_double (*lquo, *hquo, 1, 0, lquo, hquo);
  587.         }
  588. !     else return overflow;
  589.         }
  590.         break;
  591. ***************
  592. *** 698,701 ****
  593. --- 748,752 ----
  594.     neg_double (*lrem, *hrem, lrem, hrem);
  595.     add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
  596. +   return overflow;
  597.   }
  598.   
  599. ***************
  600. *** 957,960 ****
  601. --- 1008,1012 ----
  602.         register tree t;
  603.         int uns = TREE_UNSIGNED (TREE_TYPE (arg1));
  604. +       int overflow = 0;
  605.   
  606.         switch (code)
  607. ***************
  608. *** 979,986 ****
  609.         int2l = - int2l;
  610.       case LSHIFT_EXPR:
  611. !       lshift_double (int1l, int1h, int2l,
  612. !              TYPE_PRECISION (TREE_TYPE (arg1)),
  613. !              &low, &hi,
  614. !              !uns);
  615.         t = build_int_2 (low, hi);
  616.         break;
  617. --- 1031,1038 ----
  618.         int2l = - int2l;
  619.       case LSHIFT_EXPR:
  620. !       overflow = lshift_double (int1l, int1h, int2l,
  621. !                     TYPE_PRECISION (TREE_TYPE (arg1)),
  622. !                     &low, &hi,
  623. !                     !uns);
  624.         t = build_int_2 (low, hi);
  625.         break;
  626. ***************
  627. *** 1000,1004 ****
  628.             int2l += int1l;
  629.             if ((unsigned) int2l < int1l)
  630. !         int2h += 1;
  631.             t = build_int_2 (int2l, int2h);
  632.             break;
  633. --- 1052,1056 ----
  634.             int2l += int1l;
  635.             if ((unsigned) int2l < int1l)
  636. !         overflow = int2h++ >= 0 && int2h < 0;
  637.             t = build_int_2 (int2l, int2h);
  638.             break;
  639. ***************
  640. *** 1008,1016 ****
  641.             int1l += int2l;
  642.             if ((unsigned) int1l < int2l)
  643. !         int1h += 1;
  644.             t = build_int_2 (int1l, int1h);
  645.             break;
  646.           }
  647. !       add_double (int1l, int1h, int2l, int2h, &low, &hi);
  648.         t = build_int_2 (low, hi);
  649.         break;
  650. --- 1060,1068 ----
  651.             int1l += int2l;
  652.             if ((unsigned) int1l < int2l)
  653. !         overflow = int1h++ >= 0 && int1h < 0;
  654.             t = build_int_2 (int1l, int1h);
  655.             break;
  656.           }
  657. !       overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
  658.         t = build_int_2 (low, hi);
  659.         break;
  660. ***************
  661. *** 1022,1027 ****
  662.             break;
  663.           }
  664. !       neg_double (int2l, int2h, &int2l, &int2h);
  665. !       add_double (int1l, int1h, int2l, int2h, &low, &hi);
  666.         t = build_int_2 (low, hi);
  667.         break;
  668. --- 1074,1080 ----
  669.             break;
  670.           }
  671. !       neg_double (int2l, int2h, &low, &hi);
  672. !       add_double (int1l, int1h, low, hi, &low, &hi);
  673. !       overflow = !possible_sum_sign (hi, int2h, int1h);
  674.         t = build_int_2 (low, hi);
  675.         break;
  676. ***************
  677. *** 1042,1052 ****
  678.             goto got_it;
  679.           case 2:
  680.             temp = int2l + int2l;
  681. !           int2h = int2h * 2 + (temp < int2l);
  682.             t = build_int_2 (temp, int2h);
  683.             goto got_it;
  684.           case 4:
  685.             temp = int2l + int2l;
  686. !           int2h = int2h * 4 + ((temp < int2l) << 1);
  687.             int2l = temp;
  688.             temp += temp;
  689. --- 1095,1107 ----
  690.             goto got_it;
  691.           case 2:
  692. +           overflow = left_shift_overflows (int2h, 1);
  693.             temp = int2l + int2l;
  694. !           int2h = (int2h << 1) + (temp < int2l);
  695.             t = build_int_2 (temp, int2h);
  696.             goto got_it;
  697.           case 4:
  698. +           overflow = left_shift_overflows (int2h, 2);
  699.             temp = int2l + int2l;
  700. !           int2h = (int2h << 2) + ((temp < int2l) << 1);
  701.             int2l = temp;
  702.             temp += temp;
  703. ***************
  704. *** 1055,1060 ****
  705.             goto got_it;
  706.           case 8:
  707.             temp = int2l + int2l;
  708. !           int2h = int2h * 8 + ((temp < int2l) << 2);
  709.             int2l = temp;
  710.             temp += temp;
  711. --- 1110,1116 ----
  712.             goto got_it;
  713.           case 8:
  714. +           overflow = left_shift_overflows (int2h, 3);
  715.             temp = int2l + int2l;
  716. !           int2h = (int2h << 3) + ((temp < int2l) << 2);
  717.             int2l = temp;
  718.             temp += temp;
  719. ***************
  720. *** 1084,1088 ****
  721.           }
  722.   
  723. !       mul_double (int1l, int1h, int2l, int2h, &low, &hi);
  724.         t = build_int_2 (low, hi);
  725.         break;
  726. --- 1140,1144 ----
  727.           }
  728.   
  729. !       overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
  730.         t = build_int_2 (low, hi);
  731.         break;
  732. ***************
  733. *** 1115,1120 ****
  734.             break;
  735.           }
  736. !       div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
  737. !                 &low, &hi, &garbagel, &garbageh);
  738.         t = build_int_2 (low, hi);
  739.         break;
  740. --- 1171,1177 ----
  741.             break;
  742.           }
  743. !       overflow = div_and_round_double (code, uns,
  744. !                        int1l, int1h, int2l, int2h,
  745. !                        &low, &hi, &garbagel, &garbageh);
  746.         t = build_int_2 (low, hi);
  747.         break;
  748. ***************
  749. *** 1122,1127 ****
  750.       case TRUNC_MOD_EXPR: case ROUND_MOD_EXPR: 
  751.       case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
  752. !       div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
  753. !                 &garbagel, &garbageh, &low, &hi);
  754.         t = build_int_2 (low, hi);
  755.         break;
  756. --- 1179,1185 ----
  757.       case TRUNC_MOD_EXPR: case ROUND_MOD_EXPR: 
  758.       case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
  759. !       overflow = div_and_round_double (code, uns,
  760. !                        int1l, int1h, int2l, int2h,
  761. !                        &garbagel, &garbageh, &low, &hi);
  762.         t = build_int_2 (low, hi);
  763.         break;
  764. ***************
  765. *** 1152,1156 ****
  766.       got_it:
  767.         TREE_TYPE (t) = TREE_TYPE (arg1);
  768. !       force_fit_type (t);
  769.         return t;
  770.       }
  771. --- 1210,1214 ----
  772.       got_it:
  773.         TREE_TYPE (t) = TREE_TYPE (arg1);
  774. !       force_fit_type (t, overflow);
  775.         return t;
  776.       }
  777. ***************
  778. *** 1167,1171 ****
  779.         if (setjmp (float_error))
  780.       {
  781. !       warning ("floating overflow in constant folding");
  782.         return build (code, TREE_TYPE (arg1), arg1, arg2);
  783.       }
  784. --- 1225,1229 ----
  785.         if (setjmp (float_error))
  786.       {
  787. !       pedwarn ("floating overflow in constant expression");
  788.         return build (code, TREE_TYPE (arg1), arg1, arg2);
  789.       }
  790. ***************
  791. *** 1359,1363 ****
  792.                  TREE_INT_CST_HIGH (arg1));
  793.         TREE_TYPE (t) = type;
  794. !       force_fit_type (t);
  795.       }
  796.   #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
  797. --- 1417,1421 ----
  798.                  TREE_INT_CST_HIGH (arg1));
  799.         TREE_TYPE (t) = type;
  800. !       force_fit_type (t, 0);
  801.       }
  802.   #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
  803. ***************
  804. *** 1377,1381 ****
  805.         if (! (REAL_VALUES_LESS (l, x) && REAL_VALUES_LESS (x, u)))
  806.           {
  807. !           warning ("real constant out of range for integer conversion");
  808.             return t;
  809.           }
  810. --- 1435,1439 ----
  811.         if (! (REAL_VALUES_LESS (l, x) && REAL_VALUES_LESS (x, u)))
  812.           {
  813. !           pedwarn ("real constant out of range for integer conversion");
  814.             return t;
  815.           }
  816. ***************
  817. *** 1405,1409 ****
  818.   #endif
  819.         TREE_TYPE (t) = type;
  820. !       force_fit_type (t);
  821.       }
  822.   #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
  823. --- 1463,1467 ----
  824.   #endif
  825.         TREE_TYPE (t) = type;
  826. !       force_fit_type (t, 0);
  827.       }
  828.   #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
  829. ***************
  830. *** 1420,1424 ****
  831.         if (setjmp (float_error))
  832.           {
  833. !           warning ("floating overflow in constant folding");
  834.             return t;
  835.           }
  836. --- 1478,1482 ----
  837.         if (setjmp (float_error))
  838.           {
  839. !           pedwarn ("floating overflow in constant expression");
  840.             return t;
  841.           }
  842. ***************
  843. *** 2805,2809 ****
  844.             t = build_int_2 (TREE_STRING_POINTER (arg0)[i], 0);
  845.             TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
  846. !           force_fit_type (t);
  847.           }
  848.       }
  849. --- 2863,2867 ----
  850.             t = build_int_2 (TREE_STRING_POINTER (arg0)[i], 0);
  851.             TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
  852. !           force_fit_type (t, 0);
  853.           }
  854.       }
  855. ***************
  856. *** 2820,2830 ****
  857.         if (TREE_CODE (arg0) == INTEGER_CST)
  858.           {
  859. !           if (TREE_INT_CST_LOW (arg0) == 0)
  860. !         t = build_int_2 (0, - TREE_INT_CST_HIGH (arg0));
  861. !           else
  862. !         t = build_int_2 (- TREE_INT_CST_LOW (arg0),
  863. !                  ~ TREE_INT_CST_HIGH (arg0));
  864.             TREE_TYPE (t) = type;
  865. !           force_fit_type (t);
  866.           }
  867.         else if (TREE_CODE (arg0) == REAL_CST)
  868. --- 2878,2888 ----
  869.         if (TREE_CODE (arg0) == INTEGER_CST)
  870.           {
  871. !           int low, high;
  872. !           int overflow = neg_double (TREE_INT_CST_LOW (arg0),
  873. !                      TREE_INT_CST_HIGH (arg0),
  874. !                      &low, &high);
  875. !           t = build_int_2 (low, high);
  876.             TREE_TYPE (t) = type;
  877. !           force_fit_type (t, overflow);
  878.           }
  879.         else if (TREE_CODE (arg0) == REAL_CST)
  880. ***************
  881. *** 2876,2880 ****
  882.                    ~ TREE_INT_CST_HIGH (arg0));
  883.         TREE_TYPE (t) = type;
  884. !       force_fit_type (t);
  885.       }
  886.         else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
  887. --- 2934,2938 ----
  888.                    ~ TREE_INT_CST_HIGH (arg0));
  889.         TREE_TYPE (t) = type;
  890. !       force_fit_type (t, 0);
  891.       }
  892.         else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
  893. ===================================================================
  894. RCS file: tree.h,v
  895. retrieving revision 2.2.2.1
  896. diff -c2 -r2.2.2.1 tree.h
  897. *** tree.h    1992/06/21 05:34:02    2.2.2.1
  898. --- tree.h    1992/09/03 02:15:57
  899. ***************
  900. *** 219,224 ****
  901.   #define TREE_NO_UNUSED_WARNING(NODE) ((NODE)->common.static_flag)
  902.   
  903. ! /* In a NON_LVALUE_EXPR, this means there was overflow in folding.
  904. !    The folded constant is inside the NON_LVALUE_EXPR.  */
  905.   #define TREE_CONSTANT_OVERFLOW(NODE) ((NODE)->common.static_flag)
  906.   
  907. --- 219,223 ----
  908.   #define TREE_NO_UNUSED_WARNING(NODE) ((NODE)->common.static_flag)
  909.   
  910. ! /* In an INTEGER_CST, this means there was overflow in folding.  */
  911.   #define TREE_CONSTANT_OVERFLOW(NODE) ((NODE)->common.static_flag)
  912.   
  913.  
  914.