|
111
|
1 /* IPA predicates.
|
|
131
|
2 Copyright (C) 2003-2018 Free Software Foundation, Inc.
|
|
111
|
3 Contributed by Jan Hubicka
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it under
|
|
|
8 the terms of the GNU General Public License as published by the Free
|
|
|
9 Software Foundation; either version 3, or (at your option) any later
|
|
|
10 version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21 #include "config.h"
|
|
|
22 #include "system.h"
|
|
|
23 #include "coretypes.h"
|
|
|
24 #include "backend.h"
|
|
|
25 #include "tree.h"
|
|
|
26 #include "cgraph.h"
|
|
|
27 #include "tree-vrp.h"
|
|
|
28 #include "symbol-summary.h"
|
|
|
29 #include "alloc-pool.h"
|
|
|
30 #include "ipa-prop.h"
|
|
|
31 #include "ipa-fnsummary.h"
|
|
|
32 #include "real.h"
|
|
|
33 #include "fold-const.h"
|
|
|
34 #include "tree-pretty-print.h"
|
|
|
35 #include "gimple.h"
|
|
|
36 #include "data-streamer.h"
|
|
|
37
|
|
|
38
|
|
|
39 /* Add clause CLAUSE into the predicate P.
|
|
|
40 When CONDITIONS is NULL do not perform checking whether NEW_CLAUSE
|
|
|
41 is obviously true. This is useful only when NEW_CLAUSE is known to be
|
|
|
42 sane. */
|
|
|
43
|
|
|
44 void
|
|
|
45 predicate::add_clause (conditions conditions, clause_t new_clause)
|
|
|
46 {
|
|
|
47 int i;
|
|
|
48 int i2;
|
|
|
49 int insert_here = -1;
|
|
|
50 int c1, c2;
|
|
|
51
|
|
|
52 /* True clause. */
|
|
|
53 if (!new_clause)
|
|
|
54 return;
|
|
|
55
|
|
|
56 /* False clause makes the whole predicate false. Kill the other variants. */
|
|
|
57 if (new_clause == (1 << predicate::false_condition))
|
|
|
58 {
|
|
|
59 *this = false;
|
|
|
60 return;
|
|
|
61 }
|
|
|
62 if (*this == false)
|
|
|
63 return;
|
|
|
64
|
|
|
65 /* No one should be silly enough to add false into nontrivial clauses. */
|
|
|
66 gcc_checking_assert (!(new_clause & (1 << predicate::false_condition)));
|
|
|
67
|
|
|
68 /* Look where to insert the new_clause. At the same time prune out
|
|
|
69 new_clauses of P that are implied by the new new_clause and thus
|
|
|
70 redundant. */
|
|
|
71 for (i = 0, i2 = 0; i <= max_clauses; i++)
|
|
|
72 {
|
|
|
73 m_clause[i2] = m_clause[i];
|
|
|
74
|
|
|
75 if (!m_clause[i])
|
|
|
76 break;
|
|
|
77
|
|
|
78 /* If m_clause[i] implies new_clause, there is nothing to add. */
|
|
|
79 if ((m_clause[i] & new_clause) == m_clause[i])
|
|
|
80 {
|
|
|
81 /* We had nothing to add, none of clauses should've become
|
|
|
82 redundant. */
|
|
|
83 gcc_checking_assert (i == i2);
|
|
|
84 return;
|
|
|
85 }
|
|
|
86
|
|
|
87 if (m_clause[i] < new_clause && insert_here < 0)
|
|
|
88 insert_here = i2;
|
|
|
89
|
|
|
90 /* If new_clause implies clause[i], then clause[i] becomes redundant.
|
|
|
91 Otherwise the clause[i] has to stay. */
|
|
|
92 if ((m_clause[i] & new_clause) != new_clause)
|
|
|
93 i2++;
|
|
|
94 }
|
|
|
95
|
|
|
96 /* Look for clauses that are obviously true. I.e.
|
|
|
97 op0 == 5 || op0 != 5. */
|
|
|
98 if (conditions)
|
|
|
99 for (c1 = predicate::first_dynamic_condition;
|
|
|
100 c1 < num_conditions; c1++)
|
|
|
101 {
|
|
|
102 condition *cc1;
|
|
|
103 if (!(new_clause & (1 << c1)))
|
|
|
104 continue;
|
|
|
105 cc1 = &(*conditions)[c1 - predicate::first_dynamic_condition];
|
|
|
106 /* We have no way to represent !changed and !is_not_constant
|
|
|
107 and thus there is no point for looking for them. */
|
|
|
108 if (cc1->code == changed || cc1->code == is_not_constant)
|
|
|
109 continue;
|
|
|
110 for (c2 = c1 + 1; c2 < num_conditions; c2++)
|
|
|
111 if (new_clause & (1 << c2))
|
|
|
112 {
|
|
|
113 condition *cc1 =
|
|
|
114 &(*conditions)[c1 - predicate::first_dynamic_condition];
|
|
|
115 condition *cc2 =
|
|
|
116 &(*conditions)[c2 - predicate::first_dynamic_condition];
|
|
|
117 if (cc1->operand_num == cc2->operand_num
|
|
|
118 && cc1->val == cc2->val
|
|
|
119 && cc2->code != is_not_constant
|
|
|
120 && cc2->code != predicate::changed
|
|
|
121 && cc1->code == invert_tree_comparison (cc2->code,
|
|
|
122 HONOR_NANS (cc1->val)))
|
|
|
123 return;
|
|
|
124 }
|
|
|
125 }
|
|
|
126
|
|
|
127
|
|
|
128 /* We run out of variants. Be conservative in positive direction. */
|
|
|
129 if (i2 == max_clauses)
|
|
|
130 return;
|
|
|
131 /* Keep clauses in decreasing order. This makes equivalence testing easy. */
|
|
|
132 m_clause[i2 + 1] = 0;
|
|
|
133 if (insert_here >= 0)
|
|
|
134 for (; i2 > insert_here; i2--)
|
|
|
135 m_clause[i2] = m_clause[i2 - 1];
|
|
|
136 else
|
|
|
137 insert_here = i2;
|
|
|
138 m_clause[insert_here] = new_clause;
|
|
|
139 }
|
|
|
140
|
|
|
141
|
|
|
142 /* Do THIS &= P. */
|
|
|
143
|
|
|
144 predicate &
|
|
|
145 predicate::operator &= (const predicate &p)
|
|
|
146 {
|
|
|
147 /* Avoid busy work. */
|
|
|
148 if (p == false || *this == true)
|
|
|
149 {
|
|
|
150 *this = p;
|
|
|
151 return *this;
|
|
|
152 }
|
|
|
153 if (*this == false || p == true || this == &p)
|
|
|
154 return *this;
|
|
|
155
|
|
|
156 int i;
|
|
|
157
|
|
|
158 /* See how far predicates match. */
|
|
|
159 for (i = 0; m_clause[i] && m_clause[i] == p.m_clause[i]; i++)
|
|
|
160 {
|
|
|
161 gcc_checking_assert (i < max_clauses);
|
|
|
162 }
|
|
|
163
|
|
|
164 /* Combine the predicates rest. */
|
|
|
165 for (; p.m_clause[i]; i++)
|
|
|
166 {
|
|
|
167 gcc_checking_assert (i < max_clauses);
|
|
|
168 add_clause (NULL, p.m_clause[i]);
|
|
|
169 }
|
|
|
170 return *this;
|
|
|
171 }
|
|
|
172
|
|
|
173
|
|
|
174
|
|
|
175 /* Return THIS | P2. */
|
|
|
176
|
|
|
177 predicate
|
|
|
178 predicate::or_with (conditions conditions,
|
|
|
179 const predicate &p) const
|
|
|
180 {
|
|
|
181 /* Avoid busy work. */
|
|
|
182 if (p == false || *this == true || *this == p)
|
|
|
183 return *this;
|
|
|
184 if (*this == false || p == true)
|
|
|
185 return p;
|
|
|
186
|
|
|
187 /* OK, combine the predicates. */
|
|
|
188 predicate out = true;
|
|
|
189
|
|
|
190 for (int i = 0; m_clause[i]; i++)
|
|
|
191 for (int j = 0; p.m_clause[j]; j++)
|
|
|
192 {
|
|
|
193 gcc_checking_assert (i < max_clauses && j < max_clauses);
|
|
|
194 out.add_clause (conditions, m_clause[i] | p.m_clause[j]);
|
|
|
195 }
|
|
|
196 return out;
|
|
|
197 }
|
|
|
198
|
|
|
199
|
|
|
200 /* Having partial truth assignment in POSSIBLE_TRUTHS, return false
|
|
|
201 if predicate P is known to be false. */
|
|
|
202
|
|
|
203 bool
|
|
|
204 predicate::evaluate (clause_t possible_truths) const
|
|
|
205 {
|
|
|
206 int i;
|
|
|
207
|
|
|
208 /* True remains true. */
|
|
|
209 if (*this == true)
|
|
|
210 return true;
|
|
|
211
|
|
|
212 gcc_assert (!(possible_truths & (1 << predicate::false_condition)));
|
|
|
213
|
|
|
214 /* See if we can find clause we can disprove. */
|
|
|
215 for (i = 0; m_clause[i]; i++)
|
|
|
216 {
|
|
|
217 gcc_checking_assert (i < max_clauses);
|
|
|
218 if (!(m_clause[i] & possible_truths))
|
|
|
219 return false;
|
|
|
220 }
|
|
|
221 return true;
|
|
|
222 }
|
|
|
223
|
|
|
224 /* Return the probability in range 0...REG_BR_PROB_BASE that the predicated
|
|
|
225 instruction will be recomputed per invocation of the inlined call. */
|
|
|
226
|
|
|
227 int
|
|
|
228 predicate::probability (conditions conds,
|
|
|
229 clause_t possible_truths,
|
|
|
230 vec<inline_param_summary> inline_param_summary) const
|
|
|
231 {
|
|
|
232 int i;
|
|
|
233 int combined_prob = REG_BR_PROB_BASE;
|
|
|
234
|
|
|
235 /* True remains true. */
|
|
|
236 if (*this == true)
|
|
|
237 return REG_BR_PROB_BASE;
|
|
|
238
|
|
|
239 if (*this == false)
|
|
|
240 return 0;
|
|
|
241
|
|
|
242 gcc_assert (!(possible_truths & (1 << predicate::false_condition)));
|
|
|
243
|
|
|
244 /* See if we can find clause we can disprove. */
|
|
|
245 for (i = 0; m_clause[i]; i++)
|
|
|
246 {
|
|
|
247 gcc_checking_assert (i < max_clauses);
|
|
|
248 if (!(m_clause[i] & possible_truths))
|
|
|
249 return 0;
|
|
|
250 else
|
|
|
251 {
|
|
|
252 int this_prob = 0;
|
|
|
253 int i2;
|
|
|
254 if (!inline_param_summary.exists ())
|
|
|
255 return REG_BR_PROB_BASE;
|
|
|
256 for (i2 = 0; i2 < num_conditions; i2++)
|
|
|
257 if ((m_clause[i] & possible_truths) & (1 << i2))
|
|
|
258 {
|
|
|
259 if (i2 >= predicate::first_dynamic_condition)
|
|
|
260 {
|
|
|
261 condition *c =
|
|
|
262 &(*conds)[i2 - predicate::first_dynamic_condition];
|
|
|
263 if (c->code == predicate::changed
|
|
|
264 && (c->operand_num <
|
|
|
265 (int) inline_param_summary.length ()))
|
|
|
266 {
|
|
|
267 int iprob =
|
|
|
268 inline_param_summary[c->operand_num].change_prob;
|
|
|
269 this_prob = MAX (this_prob, iprob);
|
|
|
270 }
|
|
|
271 else
|
|
|
272 this_prob = REG_BR_PROB_BASE;
|
|
|
273 }
|
|
|
274 else
|
|
|
275 this_prob = REG_BR_PROB_BASE;
|
|
|
276 }
|
|
|
277 combined_prob = MIN (this_prob, combined_prob);
|
|
|
278 if (!combined_prob)
|
|
|
279 return 0;
|
|
|
280 }
|
|
|
281 }
|
|
|
282 return combined_prob;
|
|
|
283 }
|
|
|
284
|
|
|
285
|
|
|
286 /* Dump conditional COND. */
|
|
|
287
|
|
|
288 void
|
|
|
289 dump_condition (FILE *f, conditions conditions, int cond)
|
|
|
290 {
|
|
|
291 condition *c;
|
|
|
292 if (cond == predicate::false_condition)
|
|
|
293 fprintf (f, "false");
|
|
|
294 else if (cond == predicate::not_inlined_condition)
|
|
|
295 fprintf (f, "not inlined");
|
|
|
296 else
|
|
|
297 {
|
|
|
298 c = &(*conditions)[cond - predicate::first_dynamic_condition];
|
|
|
299 fprintf (f, "op%i", c->operand_num);
|
|
|
300 if (c->agg_contents)
|
|
|
301 fprintf (f, "[%soffset: " HOST_WIDE_INT_PRINT_DEC "]",
|
|
|
302 c->by_ref ? "ref " : "", c->offset);
|
|
|
303 if (c->code == predicate::is_not_constant)
|
|
|
304 {
|
|
|
305 fprintf (f, " not constant");
|
|
|
306 return;
|
|
|
307 }
|
|
|
308 if (c->code == predicate::changed)
|
|
|
309 {
|
|
|
310 fprintf (f, " changed");
|
|
|
311 return;
|
|
|
312 }
|
|
|
313 fprintf (f, " %s ", op_symbol_code (c->code));
|
|
|
314 print_generic_expr (f, c->val);
|
|
|
315 }
|
|
|
316 }
|
|
|
317
|
|
|
318
|
|
|
319 /* Dump clause CLAUSE. */
|
|
|
320
|
|
|
321 static void
|
|
|
322 dump_clause (FILE *f, conditions conds, clause_t clause)
|
|
|
323 {
|
|
|
324 int i;
|
|
|
325 bool found = false;
|
|
|
326 fprintf (f, "(");
|
|
|
327 if (!clause)
|
|
|
328 fprintf (f, "true");
|
|
|
329 for (i = 0; i < predicate::num_conditions; i++)
|
|
|
330 if (clause & (1 << i))
|
|
|
331 {
|
|
|
332 if (found)
|
|
|
333 fprintf (f, " || ");
|
|
|
334 found = true;
|
|
|
335 dump_condition (f, conds, i);
|
|
|
336 }
|
|
|
337 fprintf (f, ")");
|
|
|
338 }
|
|
|
339
|
|
|
340
|
|
|
341 /* Dump THIS to F. CONDS a vector of conditions used when evauating
|
|
|
342 predicats. When NL is true new line is output at the end of dump. */
|
|
|
343
|
|
|
344 void
|
|
|
345 predicate::dump (FILE *f, conditions conds, bool nl) const
|
|
|
346 {
|
|
|
347 int i;
|
|
|
348 if (*this == true)
|
|
|
349 dump_clause (f, conds, 0);
|
|
|
350 else
|
|
|
351 for (i = 0; m_clause[i]; i++)
|
|
|
352 {
|
|
|
353 if (i)
|
|
|
354 fprintf (f, " && ");
|
|
|
355 dump_clause (f, conds, m_clause[i]);
|
|
|
356 }
|
|
|
357 if (nl)
|
|
|
358 fprintf (f, "\n");
|
|
|
359 }
|
|
|
360
|
|
|
361
|
|
|
362 void
|
|
|
363 predicate::debug (conditions conds) const
|
|
|
364 {
|
|
|
365 dump (stderr, conds);
|
|
|
366 }
|
|
|
367
|
|
|
368
|
|
|
369 /* Remap predicate THIS of former function to be predicate of duplicated function.
|
|
|
370 POSSIBLE_TRUTHS is clause of possible truths in the duplicated node,
|
|
|
371 INFO is inline summary of the duplicated node. */
|
|
|
372
|
|
|
373 predicate
|
|
|
374 predicate::remap_after_duplication (clause_t possible_truths)
|
|
|
375 {
|
|
|
376 int j;
|
|
|
377 predicate out = true;
|
|
|
378 for (j = 0; m_clause[j]; j++)
|
|
|
379 if (!(possible_truths & m_clause[j]))
|
|
|
380 return false;
|
|
|
381 else
|
|
|
382 out.add_clause (NULL, possible_truths & m_clause[j]);
|
|
|
383 return out;
|
|
|
384 }
|
|
|
385
|
|
|
386
|
|
|
387 /* Translate all conditions from callee representation into caller
|
|
|
388 representation and symbolically evaluate predicate THIS into new predicate.
|
|
|
389
|
|
|
390 INFO is ipa_fn_summary of function we are adding predicate into, CALLEE_INFO
|
|
|
391 is summary of function predicate P is from. OPERAND_MAP is array giving
|
|
|
392 callee formal IDs the caller formal IDs. POSSSIBLE_TRUTHS is clausule of all
|
|
|
393 callee conditions that may be true in caller context. TOPLEV_PREDICATE is
|
|
|
394 predicate under which callee is executed. OFFSET_MAP is an array of of
|
|
|
395 offsets that need to be added to conditions, negative offset means that
|
|
|
396 conditions relying on values passed by reference have to be discarded
|
|
|
397 because they might not be preserved (and should be considered offset zero
|
|
|
398 for other purposes). */
|
|
|
399
|
|
|
400 predicate
|
|
|
401 predicate::remap_after_inlining (struct ipa_fn_summary *info,
|
|
|
402 struct ipa_fn_summary *callee_info,
|
|
|
403 vec<int> operand_map,
|
|
|
404 vec<int> offset_map,
|
|
|
405 clause_t possible_truths,
|
|
|
406 const predicate &toplev_predicate)
|
|
|
407 {
|
|
|
408 int i;
|
|
|
409 predicate out = true;
|
|
|
410
|
|
|
411 /* True predicate is easy. */
|
|
|
412 if (*this == true)
|
|
|
413 return toplev_predicate;
|
|
|
414 for (i = 0; m_clause[i]; i++)
|
|
|
415 {
|
|
|
416 clause_t clause = m_clause[i];
|
|
|
417 int cond;
|
|
|
418 predicate clause_predicate = false;
|
|
|
419
|
|
|
420 gcc_assert (i < max_clauses);
|
|
|
421
|
|
|
422 for (cond = 0; cond < num_conditions; cond++)
|
|
|
423 /* Do we have condition we can't disprove? */
|
|
|
424 if (clause & possible_truths & (1 << cond))
|
|
|
425 {
|
|
|
426 predicate cond_predicate;
|
|
|
427 /* Work out if the condition can translate to predicate in the
|
|
|
428 inlined function. */
|
|
|
429 if (cond >= predicate::first_dynamic_condition)
|
|
|
430 {
|
|
|
431 struct condition *c;
|
|
|
432
|
|
|
433 c = &(*callee_info->conds)[cond
|
|
|
434 -
|
|
|
435 predicate::first_dynamic_condition];
|
|
|
436 /* See if we can remap condition operand to caller's operand.
|
|
|
437 Otherwise give up. */
|
|
|
438 if (!operand_map.exists ()
|
|
|
439 || (int) operand_map.length () <= c->operand_num
|
|
|
440 || operand_map[c->operand_num] == -1
|
|
|
441 /* TODO: For non-aggregate conditions, adding an offset is
|
|
|
442 basically an arithmetic jump function processing which
|
|
|
443 we should support in future. */
|
|
|
444 || ((!c->agg_contents || !c->by_ref)
|
|
|
445 && offset_map[c->operand_num] > 0)
|
|
|
446 || (c->agg_contents && c->by_ref
|
|
|
447 && offset_map[c->operand_num] < 0))
|
|
|
448 cond_predicate = true;
|
|
|
449 else
|
|
|
450 {
|
|
|
451 struct agg_position_info ap;
|
|
|
452 HOST_WIDE_INT offset_delta = offset_map[c->operand_num];
|
|
|
453 if (offset_delta < 0)
|
|
|
454 {
|
|
|
455 gcc_checking_assert (!c->agg_contents || !c->by_ref);
|
|
|
456 offset_delta = 0;
|
|
|
457 }
|
|
|
458 gcc_assert (!c->agg_contents
|
|
|
459 || c->by_ref || offset_delta == 0);
|
|
|
460 ap.offset = c->offset + offset_delta;
|
|
|
461 ap.agg_contents = c->agg_contents;
|
|
|
462 ap.by_ref = c->by_ref;
|
|
|
463 cond_predicate = add_condition (info,
|
|
|
464 operand_map[c->operand_num],
|
|
|
465 c->size, &ap, c->code,
|
|
|
466 c->val);
|
|
|
467 }
|
|
|
468 }
|
|
|
469 /* Fixed conditions remains same, construct single
|
|
|
470 condition predicate. */
|
|
|
471 else
|
|
|
472 cond_predicate = predicate::predicate_testing_cond (cond);
|
|
|
473 clause_predicate = clause_predicate.or_with (info->conds,
|
|
|
474 cond_predicate);
|
|
|
475 }
|
|
|
476 out &= clause_predicate;
|
|
|
477 }
|
|
|
478 out &= toplev_predicate;
|
|
|
479 return out;
|
|
|
480 }
|
|
|
481
|
|
|
482
|
|
|
483 /* Read predicate from IB. */
|
|
|
484
|
|
|
485 void
|
|
|
486 predicate::stream_in (struct lto_input_block *ib)
|
|
|
487 {
|
|
|
488 clause_t clause;
|
|
|
489 int k = 0;
|
|
|
490
|
|
|
491 do
|
|
|
492 {
|
|
|
493 gcc_assert (k <= max_clauses);
|
|
|
494 clause = m_clause[k++] = streamer_read_uhwi (ib);
|
|
|
495 }
|
|
|
496 while (clause);
|
|
|
497
|
|
|
498 /* Zero-initialize the remaining clauses in OUT. */
|
|
|
499 while (k <= max_clauses)
|
|
|
500 m_clause[k++] = 0;
|
|
|
501 }
|
|
|
502
|
|
|
503
|
|
|
504 /* Write predicate P to OB. */
|
|
|
505
|
|
|
506 void
|
|
|
507 predicate::stream_out (struct output_block *ob)
|
|
|
508 {
|
|
|
509 int j;
|
|
|
510 for (j = 0; m_clause[j]; j++)
|
|
|
511 {
|
|
|
512 gcc_assert (j < max_clauses);
|
|
|
513 streamer_write_uhwi (ob, m_clause[j]);
|
|
|
514 }
|
|
|
515 streamer_write_uhwi (ob, 0);
|
|
|
516 }
|
|
|
517
|
|
|
518
|
|
|
519 /* Add condition to condition list SUMMARY. OPERAND_NUM, SIZE, CODE and VAL
|
|
|
520 correspond to fields of condition structure. AGGPOS describes whether the
|
|
|
521 used operand is loaded from an aggregate and where in the aggregate it is.
|
|
|
522 It can be NULL, which means this not a load from an aggregate. */
|
|
|
523
|
|
|
524 predicate
|
|
|
525 add_condition (struct ipa_fn_summary *summary, int operand_num,
|
|
|
526 HOST_WIDE_INT size, struct agg_position_info *aggpos,
|
|
|
527 enum tree_code code, tree val)
|
|
|
528 {
|
|
|
529 int i;
|
|
|
530 struct condition *c;
|
|
|
531 struct condition new_cond;
|
|
|
532 HOST_WIDE_INT offset;
|
|
|
533 bool agg_contents, by_ref;
|
|
|
534
|
|
|
535 if (aggpos)
|
|
|
536 {
|
|
|
537 offset = aggpos->offset;
|
|
|
538 agg_contents = aggpos->agg_contents;
|
|
|
539 by_ref = aggpos->by_ref;
|
|
|
540 }
|
|
|
541 else
|
|
|
542 {
|
|
|
543 offset = 0;
|
|
|
544 agg_contents = false;
|
|
|
545 by_ref = false;
|
|
|
546 }
|
|
|
547
|
|
|
548 gcc_checking_assert (operand_num >= 0);
|
|
|
549 for (i = 0; vec_safe_iterate (summary->conds, i, &c); i++)
|
|
|
550 {
|
|
|
551 if (c->operand_num == operand_num
|
|
|
552 && c->size == size
|
|
|
553 && c->code == code
|
|
|
554 && c->val == val
|
|
|
555 && c->agg_contents == agg_contents
|
|
|
556 && (!agg_contents || (c->offset == offset && c->by_ref == by_ref)))
|
|
|
557 return predicate::predicate_testing_cond (i);
|
|
|
558 }
|
|
|
559 /* Too many conditions. Give up and return constant true. */
|
|
|
560 if (i == predicate::num_conditions - predicate::first_dynamic_condition)
|
|
|
561 return true;
|
|
|
562
|
|
|
563 new_cond.operand_num = operand_num;
|
|
|
564 new_cond.code = code;
|
|
|
565 new_cond.val = val;
|
|
|
566 new_cond.agg_contents = agg_contents;
|
|
|
567 new_cond.by_ref = by_ref;
|
|
|
568 new_cond.offset = offset;
|
|
|
569 new_cond.size = size;
|
|
|
570 vec_safe_push (summary->conds, new_cond);
|
|
|
571
|
|
|
572 return predicate::predicate_testing_cond (i);
|
|
|
573 }
|
