← Back to branch summary

~ubuntu-branches/ubuntu/quantal/enigmail/quantal-security

« back to all changes in this revision

Viewing changes to build/unix/build-toolchain/pr49911.diff

  • Committer: Package Import Robot
  • Author(s): Chris Coulson
  • Date: 2013-09-13 16:02:15 UTC
  • mfrom: (0.12.16)
  • Revision ID: package-import@ubuntu.com-20130913160215-u3g8nmwa0pdwagwc
Tags: 2:1.5.2-0ubuntu0.12.10.1
* New upstream release v1.5.2 for Thunderbird 24

* Build enigmail using a stripped down Thunderbird 17 build system, as it's
  now quite difficult to build the way we were doing previously, with the
  latest Firefox build system
* Add debian/patches/no_libxpcom.patch - Don't link against libxpcom, as it
  doesn't exist anymore (but exists in the build system)
* Add debian/patches/use_sdk.patch - Use the SDK version of xpt.py and
  friends
* Drop debian/patches/ipc-pipe_rename.diff (not needed anymore)
* Drop debian/patches/makefile_depth.diff (not needed anymore)

Show diffs side-by-side

added added

removed removed

Lines of Context:
build/unix/build-toolchain/pr49911.diff
1
 
diff -ru gcc-4.5.2/gcc/double-int.c gcc-4.5.2-new/gcc/double-int.c
2
 
--- gcc-4.5.2/gcc/double-int.c  2009-11-25 05:55:54.000000000 -0500
3
 
+++ gcc-4.5.2-new/gcc/double-int.c      2011-11-29 10:20:27.625583810 -0500
4
 
@@ -296,7 +296,12 @@
5
 
 tree
6
 
 double_int_to_tree (tree type, double_int cst)
7
 
 {
8
 
-  cst = double_int_ext (cst, TYPE_PRECISION (type), TYPE_UNSIGNED (type));
9
 
+  /* Size types *are* sign extended.  */
10
 
+  bool sign_extended_type = (!TYPE_UNSIGNED (type)
11
 
+                            || (TREE_CODE (type) == INTEGER_TYPE
12
 
+                                && TYPE_IS_SIZETYPE (type)));
13
 
+
14
 
+  cst = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
15
 
 
16
 
   return build_int_cst_wide (type, cst.low, cst.high);
17
 
 }
18
 
diff -ru gcc-4.5.2/gcc/tree.c gcc-4.5.2-new/gcc/tree.c
19
 
--- gcc-4.5.2/gcc/tree.c        2010-07-07 11:24:27.000000000 -0400
20
 
+++ gcc-4.5.2-new/gcc/tree.c    2011-11-29 10:20:27.626583813 -0500
21
 
@@ -9750,7 +9750,7 @@
22
 
 tree
23
 
 upper_bound_in_type (tree outer, tree inner)
24
 
 {
25
 
-  unsigned HOST_WIDE_INT lo, hi;
26
 
+  double_int high;
27
 
   unsigned int det = 0;
28
 
   unsigned oprec = TYPE_PRECISION (outer);
29
 
   unsigned iprec = TYPE_PRECISION (inner);
30
 
@@ -9797,18 +9797,18 @@
31
 
   /* Compute 2^^prec - 1.  */
32
 
   if (prec <= HOST_BITS_PER_WIDE_INT)
33
 
     {
34
 
-      hi = 0;
35
 
-      lo = ((~(unsigned HOST_WIDE_INT) 0)
36
 
+      high.high = 0;
37
 
+      high.low = ((~(unsigned HOST_WIDE_INT) 0)
38
 
            >> (HOST_BITS_PER_WIDE_INT - prec));
39
 
     }
40
 
   else
41
 
     {
42
 
-      hi = ((~(unsigned HOST_WIDE_INT) 0)
43
 
+      high.high = ((~(unsigned HOST_WIDE_INT) 0)
44
 
            >> (2 * HOST_BITS_PER_WIDE_INT - prec));
45
 
-      lo = ~(unsigned HOST_WIDE_INT) 0;
46
 
+      high.low = ~(unsigned HOST_WIDE_INT) 0;
47
 
     }
48
 
 
49
 
-  return build_int_cst_wide (outer, lo, hi);
50
 
+  return double_int_to_tree (outer, high);
51
 
 }
52
 
 
53
 
 /* Returns the smallest value obtainable by casting something in INNER type to
54
 
diff -ru gcc-4.5.2/gcc/tree-vrp.c gcc-4.5.2-new/gcc/tree-vrp.c
55
 
--- gcc-4.5.2/gcc/tree-vrp.c    2010-06-14 11:23:31.000000000 -0400
56
 
+++ gcc-4.5.2-new/gcc/tree-vrp.c        2011-11-29 10:20:27.628583820 -0500
57
 
@@ -127,10 +127,10 @@
58
 
 static inline tree
59
 
 vrp_val_max (const_tree type)
60
 
 {
61
 
-  if (!INTEGRAL_TYPE_P (type))
62
 
-    return NULL_TREE;
63
 
+  if (INTEGRAL_TYPE_P (type))
64
 
+    return upper_bound_in_type (CONST_CAST_TREE (type), CONST_CAST_TREE (type));
65
 
 
66
 
-  return TYPE_MAX_VALUE (type);
67
 
+  return NULL_TREE;
68
 
 }
69
 
 
70
 
 /* Return the minimum value for TYPE.  */
71
 
@@ -138,10 +138,10 @@
72
 
 static inline tree
73
 
 vrp_val_min (const_tree type)
74
 
 {
75
 
-  if (!INTEGRAL_TYPE_P (type))
76
 
-    return NULL_TREE;
77
 
+  if (INTEGRAL_TYPE_P (type))
78
 
+    return lower_bound_in_type (CONST_CAST_TREE (type), CONST_CAST_TREE (type));
79
 
 
80
 
-  return TYPE_MIN_VALUE (type);
81
 
+  return NULL_TREE;
82
 
 }
83
 
 
84
 
 /* Return whether VAL is equal to the maximum value of its type.  This
85
 
@@ -539,7 +539,7 @@
86
 
   set_value_range (vr, VR_RANGE, zero,
87
 
                   (overflow_infinity
88
 
                    ? positive_overflow_infinity (type)
89
 
-                   : TYPE_MAX_VALUE (type)),
90
 
+                   : vrp_val_max (type)),
91
 
                   vr->equiv);
92
 
 }
93
 
 
94
 
@@ -1595,7 +1595,7 @@
95
 
     }
96
 
   else if (cond_code == LE_EXPR || cond_code == LT_EXPR)
97
 
     {
98
 
-      min = TYPE_MIN_VALUE (type);
99
 
+      min = vrp_val_min (type);
100
 
 
101
 
       if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE)
102
 
        max = limit;
103
 
@@ -1630,7 +1630,7 @@
104
 
     }
105
 
   else if (cond_code == GE_EXPR || cond_code == GT_EXPR)
106
 
     {
107
 
-      max = TYPE_MAX_VALUE (type);
108
 
+      max = vrp_val_max (type);
109
 
 
110
 
       if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE)
111
 
        min = limit;
112
 
@@ -2047,11 +2047,11 @@
113
 
          || code == ROUND_DIV_EXPR)
114
 
        return (needs_overflow_infinity (TREE_TYPE (res))
115
 
                ? positive_overflow_infinity (TREE_TYPE (res))
116
 
-               : TYPE_MAX_VALUE (TREE_TYPE (res)));
117
 
+               : vrp_val_max (TREE_TYPE (res)));
118
 
       else
119
 
        return (needs_overflow_infinity (TREE_TYPE (res))
120
 
                ? negative_overflow_infinity (TREE_TYPE (res))
121
 
-               : TYPE_MIN_VALUE (TREE_TYPE (res)));
122
 
+               : vrp_val_min (TREE_TYPE (res)));
123
 
     }
124
 
 
125
 
   return res;
126
 
@@ -2750,8 +2750,8 @@
127
 
          && TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type))
128
 
        {
129
 
          vr0.type = VR_RANGE;
130
 
-         vr0.min = TYPE_MIN_VALUE (inner_type);
131
 
-         vr0.max = TYPE_MAX_VALUE (inner_type);
132
 
+         vr0.min = vrp_val_min (inner_type);
133
 
+         vr0.max = vrp_val_max (inner_type);
134
 
        }
135
 
 
136
 
       /* If VR0 is a constant range or anti-range and the conversion is
137
 
@@ -2836,7 +2836,7 @@
138
 
            }
139
 
        }
140
 
       else
141
 
-       min = TYPE_MIN_VALUE (type);
142
 
+       min = vrp_val_min (type);
143
 
 
144
 
       if (is_positive_overflow_infinity (vr0.min))
145
 
        max = negative_overflow_infinity (type);
146
 
@@ -2855,7 +2855,7 @@
147
 
            }
148
 
        }
149
 
       else
150
 
-       max = TYPE_MIN_VALUE (type);
151
 
+       max = vrp_val_min (type);
152
 
     }
153
 
   else if (code == NEGATE_EXPR
154
 
           && TYPE_UNSIGNED (type))
155
 
@@ -2897,7 +2897,7 @@
156
 
       else if (!vrp_val_is_min (vr0.min))
157
 
        min = fold_unary_to_constant (code, type, vr0.min);
158
 
       else if (!needs_overflow_infinity (type))
159
 
-       min = TYPE_MAX_VALUE (type);
160
 
+       min = vrp_val_max (type);
161
 
       else if (supports_overflow_infinity (type))
162
 
        min = positive_overflow_infinity (type);
163
 
       else
164
 
@@ -2911,7 +2911,7 @@
165
 
       else if (!vrp_val_is_min (vr0.max))
166
 
        max = fold_unary_to_constant (code, type, vr0.max);
167
 
       else if (!needs_overflow_infinity (type))
168
 
-       max = TYPE_MAX_VALUE (type);
169
 
+       max = vrp_val_max (type);
170
 
       else if (supports_overflow_infinity (type)
171
 
               /* We shouldn't generate [+INF, +INF] as set_value_range
172
 
                  doesn't like this and ICEs.  */
173
 
@@ -2941,7 +2941,7 @@
174
 
                 TYPE_MIN_VALUE, remember -TYPE_MIN_VALUE = TYPE_MIN_VALUE.  */
175
 
              if (TYPE_OVERFLOW_WRAPS (type))
176
 
                {
177
 
-                 tree type_min_value = TYPE_MIN_VALUE (type);
178
 
+                 tree type_min_value = vrp_val_min (type);
179
 
 
180
 
                  min = (vr0.min != type_min_value
181
 
                         ? int_const_binop (PLUS_EXPR, type_min_value,
182
 
@@ -2953,7 +2953,7 @@
183
 
                  if (overflow_infinity_range_p (&vr0))
184
 
                    min = negative_overflow_infinity (type);
185
 
                  else
186
 
-                   min = TYPE_MIN_VALUE (type);
187
 
+                   min = vrp_val_min (type);
188
 
                }
189
 
            }
190
 
          else
191
 
@@ -2974,7 +2974,7 @@
192
 
                    }
193
 
                }
194
 
              else
195
 
-               max = TYPE_MAX_VALUE (type);
196
 
+               max = vrp_val_max (type);
197
 
            }
198
 
        }
199
 
 
200
 
@@ -3258,11 +3258,11 @@
201
 
   if (POINTER_TYPE_P (type) || !TYPE_MIN_VALUE (type))
202
 
     tmin = lower_bound_in_type (type, type);
203
 
   else
204
 
-    tmin = TYPE_MIN_VALUE (type);
205
 
+    tmin = vrp_val_min (type);
206
 
   if (POINTER_TYPE_P (type) || !TYPE_MAX_VALUE (type))
207
 
     tmax = upper_bound_in_type (type, type);
208
 
   else
209
 
-    tmax = TYPE_MAX_VALUE (type);
210
 
+    tmax = vrp_val_max (type);
211
 
 
212
 
   if (vr->type == VR_VARYING || vr->type == VR_UNDEFINED)
213
 
     {
214
 
@@ -4146,8 +4146,8 @@
215
 
   if ((comp_code == GT_EXPR || comp_code == LT_EXPR)
216
 
       && INTEGRAL_TYPE_P (TREE_TYPE (val)))
217
 
     {
218
 
-      tree min = TYPE_MIN_VALUE (TREE_TYPE (val));
219
 
-      tree max = TYPE_MAX_VALUE (TREE_TYPE (val));
220
 
+      tree min = vrp_val_min (TREE_TYPE (val));
221
 
+      tree max = vrp_val_max (TREE_TYPE (val));
222
 
 
223
 
       if (comp_code == GT_EXPR
224
 
          && (!max
225
 
@@ -6426,13 +6426,13 @@
226
 
                 VARYING.  Same if the previous max value was invalid for
227
 
                 the type and we'd end up with vr_result.min > vr_result.max.  */
228
 
              if (vrp_val_is_max (vr_result.max)
229
 
-                 || compare_values (TYPE_MIN_VALUE (TREE_TYPE (vr_result.min)),
230
 
+                 || compare_values (vrp_val_min (TREE_TYPE (vr_result.min)),
231
 
                                     vr_result.max) > 0)
232
 
                goto varying;
233
 
 
234
 
              if (!needs_overflow_infinity (TREE_TYPE (vr_result.min))
235
 
                  || !vrp_var_may_overflow (lhs, phi))
236
 
-               vr_result.min = TYPE_MIN_VALUE (TREE_TYPE (vr_result.min));
237
 
+               vr_result.min = vrp_val_min (TREE_TYPE (vr_result.min));
238
 
              else if (supports_overflow_infinity (TREE_TYPE (vr_result.min)))
239
 
                vr_result.min =
240
 
                  negative_overflow_infinity (TREE_TYPE (vr_result.min));
241
 
@@ -6448,13 +6448,13 @@
242
 
                 VARYING.  Same if the previous min value was invalid for
243
 
                 the type and we'd end up with vr_result.max < vr_result.min.  */
244
 
              if (vrp_val_is_min (vr_result.min)
245
 
-                 || compare_values (TYPE_MAX_VALUE (TREE_TYPE (vr_result.max)),
246
 
+                 || compare_values (vrp_val_max (TREE_TYPE (vr_result.max)),
247
 
                                     vr_result.min) < 0)
248
 
                goto varying;
249
 
 
250
 
              if (!needs_overflow_infinity (TREE_TYPE (vr_result.max))
251
 
                  || !vrp_var_may_overflow (lhs, phi))
252
 
-               vr_result.max = TYPE_MAX_VALUE (TREE_TYPE (vr_result.max));
253
 
+               vr_result.max = vrp_val_max (TREE_TYPE (vr_result.max));
254
 
              else if (supports_overflow_infinity (TREE_TYPE (vr_result.max)))
255
 
                vr_result.max =
256
 
                  positive_overflow_infinity (TREE_TYPE (vr_result.max));
257
 
@@ -6782,7 +6782,7 @@
258
 
     {
259
 
       /* This should not be negative infinity; there is no overflow
260
 
         here.  */
261
 
-      min = TYPE_MIN_VALUE (TREE_TYPE (op0));
262
 
+      min = vrp_val_min (TREE_TYPE (op0));
263
 
 
264
 
       max = op1;
265
 
       if (cond_code == LT_EXPR && !is_overflow_infinity (max))
266
 
@@ -6797,7 +6797,7 @@
267
 
     {
268
 
       /* This should not be positive infinity; there is no overflow
269
 
         here.  */
270
 
-      max = TYPE_MAX_VALUE (TREE_TYPE (op0));
271
 
+      max = vrp_val_max (TREE_TYPE (op0));
272
 
 
273
 
       min = op1;
274
 
       if (cond_code == GT_EXPR && !is_overflow_infinity (min))