| /haiku-buildtools/gcc/gcc/ |
| H A D | tree-ssa-pre.c | 1196 /* Return the folded version of T if T, when folded, is a gimple
1283 tree folded; local
1284 if ((folded = fully_constant_vn_reference_p (ref)))
1285 return get_or_alloc_expr_for_constant (folded);
2515 tree folded, sc = NULL_TREE; local
2539 folded = build_call_array (currop->type,
2544 CALL_WITH_BOUNDS_P (folded) = true;
2547 CALL_EXPR_STATIC_CHAIN (folded) = sc;
2548 return folded;
2821 tree folded; local
[all...] |
| H A D | tree-ssa-sccvn.c | 1338 tree folded = build_call_expr (TREE_OPERAND (op->op0, 0), local
1342 if (folded
1343 && TREE_CODE (folded) == NOP_EXPR)
1344 folded = TREE_OPERAND (folded, 0);
1345 if (folded
1346 && is_gimple_min_invariant (folded))
1347 return folded;
|
| H A D | tree-ssa-reassoc.c | 1811 tree folded = fold_binary (opcode, TREE_TYPE (oelm1->op), local
1814 if (folded && is_gimple_min_invariant (folded))
1822 add_to_ops_vec (ops, folded);
|
| /haiku-buildtools/gcc/gcc/cp/ |
| H A D | cvt.c | 653 tree folded = maybe_constant_value (expr);
654 tree stripped = folded;
656 = folded != expr ? cp_convert (type, folded, complain) : result;
664 warnings_for_convert_and_check (input_location, type, folded,
651 tree folded = maybe_constant_value (expr); local
|
| H A D | pt.c | 5921 tree folded = maybe_constant_value (expr); local
5922 if (TYPE_PTR_P (type) ? integer_zerop (folded)
5923 : null_member_pointer_value_p (folded))
5924 expr = folded;
5946 and this is not folded by convert_from_reference. */
18775 folded into its (constant) value. So we should not be getting
|
| /haiku-buildtools/binutils/gold/ |
| H A D | object.cc | 1335 // will be folded and hence the assignment must wait.
1717 Section_id folded = local
1720 reinterpret_cast<Relobj*>(folded.first);
1725 folded_obj->section_name(folded.second).c_str(),
2362 // Get the os of the section it is folded onto.
2363 Section_id folded = symtab->icf()->get_folded_section(this, local
2365 gold_assert(folded.first != NULL);
2367 <Sized_relobj_file<size, big_endian>*>(folded.first);
2368 os = folded_obj->output_section(folded.second);
2370 secoffset = folded_obj->get_output_section_offset(folded
[all...] |
| H A D | symtab.cc | 2783 // Get the os of the section it is folded onto.
2784 Section_id folded = this->icf_->get_folded_section(relobj, local
2786 gold_assert(folded.first != NULL);
2787 Relobj* folded_obj = reinterpret_cast<Relobj*>(folded.first);
2788 unsigned folded_shndx = folded.second;
3105 // it is folded.
3106 // Get the os of the section it is folded onto.
3107 Section_id folded = local
3109 gold_assert(folded.first !=NULL);
3111 reinterpret_cast<Relobj*>(folded
[all...] |
| H A D | powerpc.cc | 1117 // PowerPC64 .opd is not folded, so any identical function text
1118 // may be folded and we'll still keep function addresses distinct.
7704 Section_id folded local
7706 symobj = static_cast<Powerpc_relobj<size, big_endian>*>(folded.first);
7707 *dest_shndx = folded.second;
|
| /haiku-buildtools/legacy/gcc/gcc/ |
| H A D | c-typeck.c | 2628 register tree folded;
2630 folded = fold (result);
2631 if (folded == result)
2632 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2634 return convert (final_type, folded);
2635 return folded;
2651 register tree folded;
2723 folded = fold (result);
2724 if (folded == result) local
2725 TREE_CONSTANT (folded)
2617 register tree folded; local
2639 register tree folded; local
[all...] |
| H A D | cse.c | 2878 rtx folded = fold_rtx (copy_rtx (addr), NULL_RTX);
2882 && (CSE_ADDRESS_COST (folded) < CSE_ADDRESS_COST (addr)
2883 || (CSE_ADDRESS_COST (folded) == CSE_ADDRESS_COST (addr)
2884 && rtx_cost (folded, MEM) > rtx_cost (addr, MEM)))
2886 && rtx_cost (folded, MEM) < rtx_cost (addr, MEM)
2888 && validate_change (insn, loc, folded, 0))
2889 addr = folded;
5550 /* Pick the least expensive of the folded argument and an
6822 We have the following types of equivalents: SRC itself, a folded
2864 rtx folded = fold_rtx (copy_rtx (addr), NULL_RTX); local
|
| /haiku-buildtools/legacy/gcc/gcc/cp/ |
| H A D | typeck.c | 4093 register tree folded;
4095 folded = fold (result);
4096 if (folded == result)
4097 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
4099 return cp_convert (final_type, folded);
4100 return folded;
4116 register tree folded = fold (intop);
4153 intop = folded;
4195 folded = fold (result);
4196 if (folded
4083 register tree folded; local
4105 register tree folded = fold (intop); local
4198 register tree result, folded; local
[all...] |
| /haiku-buildtools/legacy/gcc/gcc/ch/ |
| H A D | expr.c | 3744 tree folded;
3921 folded = convert_to_class (class, fold (node));
3924 folded = fold (node);
3926 if (folded == node)
3927 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
3945 folded = check_expression (folded, test,
3950 return folded;
4152 * COUNT is required to be constant, positive and folded.
4490 * return a folded tre
3726 tree folded; local
[all...] |
| /haiku-buildtools/gcc/gmp/mpn/x86_64/ |
| H A D | mul_basecase.asm | 36 C * Can the top of each L(addmul_outer_n) prologue be folded into the
|
| /haiku-buildtools/gcc/gcc/fortran/ |
| H A D | trans-expr.c | 3326 tree folded = fold_convert (gfc_get_pchar_type (kind), str); local
3327 folded = build_fold_indirect_ref_loc (input_location, folded);
3328 if (TREE_CODE (folded) == INTEGER_CST)
|