#include "pointer-set.h"#include "hash-table.h"#include "vec.h"#include "ggc.h"#include "basic-block.h"#include "tree-ssa-alias.h"#include "internal-fn.h"#include "gimple-fold.h"#include "tree-eh.h"#include "is-a.h"#include "gimple.def"#include "gsstruct.def"
Go to the source code of this file.
Macros | |
| #define | DEFGSCODE(SYM, STRING, STRUCT) SYM, |
| #define | gcc_gimple_checking_assert(EXPR) ((void)(0 && (EXPR))) |
| #define | GIMPLE_CHECK(GS, CODE) (void)0 |
| #define | GTMA_IS_OUTER (1u << 0) |
| #define | GTMA_IS_RELAXED (1u << 1) |
| #define | GTMA_DECLARATION_MASK (GTMA_IS_OUTER | GTMA_IS_RELAXED) |
| #define | GTMA_HAVE_ABORT (1u << 2) |
| #define | GTMA_HAVE_LOAD (1u << 3) |
| #define | GTMA_HAVE_STORE (1u << 4) |
| #define | GTMA_MAY_ENTER_IRREVOCABLE (1u << 5) |
| #define | GTMA_DOES_GO_IRREVOCABLE (1u << 6) |
| #define | GTMA_HAS_NO_INSTRUMENTATION (1u << 7) |
| #define | DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM, |
| #define | gimple_build_assign(l, r) gimple_build_assign_stat (l, r MEM_STAT_INFO) |
| #define | gimple_build_debug_bind(var, val, stmt) gimple_build_debug_bind_stat ((var), (val), (stmt) MEM_STAT_INFO) |
| #define | gimple_build_debug_source_bind(var, val, stmt) gimple_build_debug_source_bind_stat ((var), (val), (stmt) MEM_STAT_INFO) |
| #define | gimple_alloc(c, n) gimple_alloc_stat (c, n MEM_STAT_INFO) |
| #define | GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */ |
| #define | CASE_GIMPLE_OMP |
| #define | gsi_start(x) gsi_start_1 (&(x)) |
| #define | gsi_last(x) gsi_last_1 (&(x)) |
| #define | SCALE(x) |
| #define | LABEL(x) ((x) < 1024*10 ? 'b' : ((x) < 1024*1024*10 ? 'k' : 'M')) |
| #define | PERCENT(x, y) ((float)(x) * 100.0 / (float)(y)) |
Typedefs | |
| typedef gimple | gimple_seq_node |
| typedef vec< gimple > | gimple_vec |
| typedef bool(* | gimple_predicate )(tree) |
| typedef int | fallback_t |
| typedef struct gimple_temp_hash_elt | elt_t |
| typedef tree(* | walk_stmt_fn )(gimple_stmt_iterator *, bool *, struct walk_stmt_info *) |
Variables | |
| const char *const | gimple_code_name [] |
| const unsigned char | gimple_rhs_class_table [] |
| size_t const | gimple_ops_offset_ [] |
| enum gimple_statement_structure_enum const | gss_for_code_ [] |
| gimple | currently_expanding_gimple_stmt |
| int | gimple_alloc_counts [] |
| int | gimple_alloc_sizes [] |
Macro Definition Documentation
| #define CASE_GIMPLE_OMP |
Returns true when the gimple statement STMT is any of the OpenMP types.
| #define DEFGSCODE | ( | SYM, | |
| STRING, | |||
| STRUCT | |||
| ) | SYM, |
| #define DEFGSSTRUCT | ( | SYM, | |
| STRUCT, | |||
| HAS_TREE_OP | |||
| ) | SYM, |
| #define gcc_gimple_checking_assert | ( | EXPR | ) | ((void)(0 && (EXPR))) |
Error out if a gimple tuple is addressed incorrectly.
| #define gimple_alloc | ( | c, | |
| n | |||
| ) | gimple_alloc_stat (c, n MEM_STAT_INFO) |
Referenced by gimple_build_asm_vec(), gimple_build_catch(), gimple_build_debug_bind_stat(), gimple_build_eh_dispatch(), gimple_build_eh_filter(), gimple_build_eh_must_not_throw(), gimple_build_omp_continue(), gimple_build_omp_parallel(), gimple_build_omp_section(), gimple_build_omp_sections_switch(), and gimple_build_omp_single().
| #define gimple_build_assign | ( | l, | |
| r | |||
| ) | gimple_build_assign_stat (l, r MEM_STAT_INFO) |
Referenced by build_one_array(), build_stack_save_restore(), build_tm_store(), create_call_for_reduction(), expand_omp_atomic_load(), generate_subtree_copies(), gimple_gen_one_value_profiler(), instrument_builtin_call(), lower_gimple_return(), make_blocks(), remap_vla_decls(), replace_phi_args_in(), sra_modify_expr(), thunk_adjust(), tm_log_emit(), tm_mangle(), trivially_conflicts_p(), and vect_permute_store_chain().
| #define gimple_build_debug_bind | ( | var, | |
| val, | |||
| stmt | |||
| ) | gimple_build_debug_bind_stat ((var), (val), (stmt) MEM_STAT_INFO) |
| #define gimple_build_debug_source_bind | ( | var, | |
| val, | |||
| stmt | |||
| ) | gimple_build_debug_source_bind_stat ((var), (val), (stmt) MEM_STAT_INFO) |
Referenced by remap_ssa_name().
| #define GIMPLE_CHECK | ( | GS, | |
| CODE | |||
| ) | (void)0 |
| #define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */ |
The second operand of a GIMPLE_DEBUG_BIND, when the value was optimized away.
| #define gsi_last | ( | x | ) | gsi_last_1 (&(x)) |
Referenced by delete_omp_context(), gsi_replace(), and remap_vla_decls().
| #define gsi_start | ( | x | ) | gsi_start_1 (&(x)) |
| #define GTMA_DECLARATION_MASK (GTMA_IS_OUTER | GTMA_IS_RELAXED) |
Referenced by dump_gimple_omp_return().
| #define GTMA_DOES_GO_IRREVOCABLE (1u << 6) |
The transaction WILL enter serial irrevocable mode. An irrevocable block post-dominates the entire transaction, such that all invocations of the transaction will go serial-irrevocable. In such case, we don't bother instrumenting the transaction, and tell the runtime that it should begin the transaction in serial-irrevocable mode.
Referenced by get_tm_region_blocks().
| #define GTMA_HAS_NO_INSTRUMENTATION (1u << 7) |
The transaction contains no instrumentation code whatsover, most likely because it is guaranteed to go irrevocable upon entry.
Referenced by get_tm_region_blocks().
| #define GTMA_HAVE_ABORT (1u << 2) |
The transaction is seen to not have an abort.
Referenced by dump_gimple_omp_return().
| #define GTMA_HAVE_LOAD (1u << 3) |
The transaction is seen to have loads or stores.
Referenced by dump_gimple_omp_return().
| #define GTMA_HAVE_STORE (1u << 4) |
Referenced by get_tm_region_blocks().
| #define GTMA_IS_OUTER (1u << 0) |
GIMPLE_TRANSACTION. Bits to be stored in the GIMPLE_TRANSACTION subcode. The __transaction_atomic was declared [[outer]] or it is __transaction_relaxed.
Referenced by dump_gimple_omp_return().
| #define GTMA_IS_RELAXED (1u << 1) |
Referenced by dump_gimple_omp_return().
| #define GTMA_MAY_ENTER_IRREVOCABLE (1u << 5) |
The transaction MAY enter serial irrevocable mode in its dynamic scope.
Referenced by get_tm_region_blocks().
| #define LABEL | ( | x | ) | ((x) < 1024*10 ? 'b' : ((x) < 1024*1024*10 ? 'k' : 'M')) |
| #define PERCENT | ( | x, | |
| y | |||
| ) | ((float)(x) * 100.0 / (float)(y)) |
| #define SCALE | ( | x | ) |
Macros for showing usage statistics.
Typedef Documentation
| typedef struct gimple_temp_hash_elt elt_t |
Formal (expression) temporary table handling: multiple occurrences of the same scalar expression are evaluated into the same temporary.
| typedef int fallback_t |
Validation of GIMPLE expressions. Note that these predicates only check the basic form of the expression, they don't recurse to make sure that underlying nodes are also of the right form.
| typedef gimple gimple_seq_node |
Gimple IR definitions.
Copyright (C) 2007-2013 Free Software Foundation, Inc. Contributed by Aldy Hernandez aldyh@redhat.com
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see http://www.gnu.org/licenses/.
| typedef vec<gimple> gimple_vec |
For each block, the PHI nodes that need to be rewritten are stored into these vectors.
| typedef tree(* walk_stmt_fn)(gimple_stmt_iterator *, bool *, struct walk_stmt_info *) |
Callback for walk_gimple_stmt. Called for every statement found during traversal. The first argument points to the statement to walk. The second argument is a flag that the callback sets to 'true' if it the callback handled all the operands and sub-statements of the statement (the default value of this flag is 'false'). The third argument is an anonymous pointer to data to be used by the callback.
Enumeration Type Documentation
| enum fallback |
| enum gf_mask |
Specific flags for individual GIMPLE statements. These flags are always stored in gimple_statement_base.subcode and they may only be defined for statement codes that do not use subcodes.
Values for the masks can overlap as long as the overlapping values are never used in the same statement class.
The maximum mask value that can be defined is 1 << 15 (i.e., each statement code can hold up to 16 bitflags).
Keep this list sorted.
- Enumerator:
| enum gimple_alloc_kind |
Enum and arrays used for allocation stats. Keep in sync with gimple.c:gimple_alloc_kind_names.
| enum gimple_code |
- Enumerator:
DEFGSCODE This file contains the definitions of the GIMPLE IR tuples used in GCC.
Copyright (C) 2007-2013 Free Software Foundation, Inc. Contributed by Aldy Hernandez aldyh@redhat.com
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see http://www.gnu.org/licenses/. The format of this file is DEFGSCODE(GIMPLE_symbol, printable name, GSS_symbol). Error marker. This is used in similar ways as ERROR_MARK in tree.def.
DEFGSCODE This file contains the definitions of the GIMPLE IR tuples used in GCC.
Copyright (C) 2007-2013 Free Software Foundation, Inc. Contributed by Aldy Hernandez aldyh@redhat.com
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see http://www.gnu.org/licenses/. The format of this file is DEFGSCODE(GIMPLE_symbol, printable name, GSS_symbol). Error marker. This is used in similar ways as ERROR_MARK in tree.def.
| enum gimple_debug_subcode |
| enum gimple_rhs_class |
- Enumerator:
LAST_GSS_ENUM This file contains the definitions for the gimple IR structure enumeration used in GCC.
Copyright (C) 2007-2013 Free Software Foundation, Inc. Contributed by Aldy Hernandez aldyh@redhat.com
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see http://www.gnu.org/licenses/. The format of this file is DEFGSSTRUCT(GSS enumeration value, structure name, has-tree-operands). Each enum value should correspond with a single member of the union gimple_statement_d.
| enum gimple_try_flags |
| enum gimplify_status |
| enum gsi_iterator_update |
| enum plf_mask |
Function Documentation
| void annotate_all_with_location | ( | gimple_seq | , |
| location_t | |||
| ) |
Referenced by finalize_nesting_tree_1().
|
inlinestatic |
Returns the sequence of statements in BB.
|
inlinestatic |
|
inlinestatic |
Return true if BB is in a transaction.
| void compute_transaction_bits | ( | void | ) |
Set the IN_TRANSACTION for all gimple statements that appear in a transaction.
?? Perhaps we need to abstract gate_tm_init further, because we certainly don't need it to calculate CDI_DOMINATOR info.
Referenced by assign_parms(), expand_omp_atomic_load(), expand_transaction(), thunk_adjust(), and tm_mangle().
| tree create_tmp_var_name | ( | const char * | ) |
Referenced by create_tmp_var_name().
In gimplify.c
Referenced by create_tmp_var_raw().
Referenced by remap_vla_decls().
| void diagnose_tm_safe_errors | ( | tree | ) |
In trans-mem.c.
| void dump_decl_set | ( | FILE * | , |
| bitmap | |||
| ) |
| void dump_gimple_statistics | ( | void | ) |
Print debugging information for gimple stmts generated.
References CONSTANT_CLASS_P, handled_component_p(), is_gimple_val(), TREE_CODE, and TREE_OPERAND.
| bool empty_body_p | ( | gimple_seq | ) |
|
inlinestatic |
A wrapper around extract_ops_from_tree_1, for callers which expect to see only a maximum of two operands.
Referenced by gimplify_assign().
| void extract_ops_from_tree_1 | ( | tree | expr, |
| enum tree_code * | subcode_p, | ||
| tree * | op1_p, | ||
| tree * | op2_p, | ||
| tree * | op3_p | ||
| ) |
Extract the operands and code for expression EXPR into *SUBCODE_P, *OP1_P, *OP2_P and *OP3_P respectively.
References NULL_TREE.
Referenced by gimple_call_return_flags().
| tree force_gimple_operand | ( | tree | , |
| gimple_seq * | , | ||
| bool | , | ||
| tree | |||
| ) |
Referenced by copy_edges_for_bb(), create_iv(), and vect_do_peeling_for_loop_bound().
| tree force_gimple_operand_1 | ( | tree | expr, |
| gimple_seq * | stmts, | ||
| gimple_predicate | gimple_test_f, | ||
| tree | var | ||
| ) |
In gimplify.c.
Expand EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies the predicate that will hold for the result. If VAR is not NULL, make the base variable of the final destination be VAR if suitable.
gimple_test_f might be more strict than is_gimple_val, make sure we pass both. Just checking gimple_test_f doesn't work because most gimple predicates do not work recursively.
Referenced by add_to_predicate_list(), and vect_create_cond_for_alias_checks().
| tree force_gimple_operand_gsi | ( | gimple_stmt_iterator * | gsi, |
| tree | expr, | ||
| bool | simple_p, | ||
| tree | var, | ||
| bool | before, | ||
| enum gsi_iterator_update | m | ||
| ) |
Invoke force_gimple_operand_1 for EXPR with parameter VAR. If SIMPLE is true, force the result to be either ssa_name or an invariant, otherwise just force it to be a rhs expression. If some statements are produced, emits them at GSI. If BEFORE is true, the statements are appended before GSI, otherwise they are appended after it. M specifies the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values).
Referenced by build_one_array(), contains_vce_or_bfcref_p(), expand_omp_atomic_load(), expand_omp_sections(), generate_subtree_copies(), gimple_gen_one_value_profiler(), gimple_gen_pow2_profiler(), gimplify_mem_ref_parts(), ifcombine_ifandif(), nothing_to_prefetch_p(), sra_modify_expr(), update_dominators_in_loop(), and vect_can_advance_ivs_p().
| tree force_gimple_operand_gsi_1 | ( | gimple_stmt_iterator * | gsi, |
| tree | expr, | ||
| gimple_predicate | gimple_test_f, | ||
| tree | var, | ||
| bool | before, | ||
| enum gsi_iterator_update | m | ||
| ) |
Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F and VAR. If some statements are produced, emits them at GSI. If BEFORE is true. the statements are appended before GSI, otherwise they are appended after it. M specifies the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values).
Referenced by create_mem_ref(), if_convertible_loop_p(), and insert_gimplified_predicates().
Referenced by gimplify_init_ctor_eval().
| tree get_formal_tmp_var | ( | tree | , |
| gimple_seq * | |||
| ) |
Referenced by lower_omp_master().
|
inlinestatic |
Determine if expression CODE is one of the valid expressions that can be used on the RHS of GIMPLE assignments.
Referenced by extract_range_from_cond_expr(), get_initial_def_for_reduction(), gimple_has_side_effects(), is_negative_overflow_infinity(), and range_is_null().
| unsigned get_gimple_rhs_num_ops | ( | enum | tree_code | ) |
| tree get_initialized_tmp_var | ( | tree | , |
| gimple_seq * | , | ||
| gimple_seq * | |||
| ) |
Referenced by generic_expr_could_trap_p(), and gimplify_omp_workshare().
|
inlinestatic |
Return the line number for EXPR, or return -1 if we have no line number information for it.
| void gimple_add_tmp_var | ( | tree | ) |
Miscellaneous helpers.
Referenced by create_tmp_var_raw().
|
inlinestatic |
Return the allocation kind for a given stmt CODE.
| gimple gimple_alloc_stat | ( | enum | gimple_code, |
| unsigned | MEM_STAT_DECL | ||
| ) |
|
inlinestatic |
Return clobber operand INDEX of GIMPLE_ASM GS.
| bool gimple_asm_clobbers_memory_p | ( | const_gimple | ) |
|
inlinestatic |
Return input operand INDEX of GIMPLE_ASM GS.
Referenced by create_outofssa_var_map().
|
inlinestatic |
Return a pointer to input operand INDEX of GIMPLE_ASM GS.
|
inlinestatic |
Return true if asm GS is an ASM_INPUT.
Referenced by dump_function_to_file().
|
inlinestatic |
Return label operand INDEX of GIMPLE_ASM GS.
Referenced by cleanup_dead_labels().
|
inlinestatic |
Return the number of clobber operands for GIMPLE_ASM GS.
|
inlinestatic |
Return the number of input operands for GIMPLE_ASM GS.
Referenced by create_outofssa_var_map().
|
inlinestatic |
Return the number of label operands for GIMPLE_ASM GS.
|
inlinestatic |
Return the number of output operands for GIMPLE_ASM GS.
Referenced by create_outofssa_var_map(), and op_iter_next_tree().
|
inlinestatic |
Return output operand INDEX of GIMPLE_ASM GS.
Referenced by create_outofssa_var_map(), and fold_stmt_1().
|
inlinestatic |
Return a pointer to output operand INDEX of GIMPLE_ASM GS.
|
inlinestatic |
Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM GS.
Referenced by gimple_build_asm_1().
|
inlinestatic |
If INPUT_P is true, mark asm GS as an ASM_INPUT.
|
inlinestatic |
Set IN_OP to be input operand INDEX in GIMPLE_ASM GS.
Referenced by gimple_build_asm_1().
|
inlinestatic |
Set LABEL_OP to be label operand INDEX in GIMPLE_ASM GS.
Referenced by gimple_build_asm_1().
|
inlinestatic |
Set OUT_OP to be output operand INDEX in GIMPLE_ASM GS.
Referenced by gimple_build_asm_1().
|
inlinestatic |
If VOLATLE_P is true, mark asm statement GS as volatile.
|
inlinestatic |
Return the string representing the assembly instruction in GIMPLE_ASM GS.
|
inlinestatic |
Return true if GS is an asm statement marked volatile.
Referenced by check_stmt(), dump_function_to_file(), and tree_could_trap_p().
|
inlinestatic |
Return true if S is a type-cast assignment.
Referenced by infer_value_range().
|
inlinestatic |
Return the LHS of assignment statement GS.
Referenced by build_access_from_expr_1(), constant_pointer_difference(), convert_plusminus_to_widen(), create_outofssa_var_map(), dse_optimize_stmt(), eliminate_temp_copies(), evaluate_stmt(), final_range_test_p(), find_use_stmt(), forward_propagate_addr_expr(), get_param_index(), get_prop_dest_stmt(), gimple_assign_copy_p(), gimple_assign_unary_nop_p(), gimple_call_fnspec(), insert_gimplified_predicates(), instrument_builtin_call(), instrument_gimple(), ipa_load_from_parm_agg(), lhs_of_dominating_assert(), live_track_init(), mark_aliased_reaching_defs_necessary(), mark_stmt_if_obviously_necessary(), operand_equal_for_value_replacement(), process_assert_insertions_for(), range_fits_type_p(), recognize_single_bit_test(), ref_may_alias_global_p(), replace_ref(), replace_rhs_if_not_dup(), same_bool_result_p(), simplify_binary_expression(), stmt_is_power_of_op(), try_improve_iv_set(), unmodified_parm(), vect_create_vectorized_demotion_stmts(), vect_get_loop_based_defs(), vect_get_vec_defs_for_stmt_copy(), vect_grouped_store_supported(), vect_mark_relevant(), vect_permute_store_chain(), vn_reference_lookup_1(), vn_reference_lookup_3(), and walk_gimple_asm().
|
inlinestatic |
Return a pointer to the LHS of assignment statement GS.
|
inlinestatic |
Return true if GS is an assignment that loads from its rhs1.
Referenced by instrument_gimple(), and ipa_prop_write_all_agg_replacement().
|
inlinestatic |
Returns true if GS is a nontemporal move.
|
inlinestatic |
Return the first operand on the RHS of assignment statement GS.
Referenced by add_repeat_to_ops_vec(), adjust_related_strinfos(), ao_ref_base_alias_set(), build_access_from_expr_1(), can_propagate_from(), check_bool_pattern(), check_for_plus_in_loops_1(), constant_pointer_difference(), contains_vce_or_bfcref_p(), convert_plusminus_to_widen(), create_outofssa_var_map(), decrement_power(), expr_has_constants(), extract_range_from_cond_expr(), find_loop_niter(), find_use_stmt(), forward_propagate_addr_expr(), forward_propagate_into_cond(), gen_conditions_for_pow_cst_base(), get_initial_def_for_reduction(), get_name_for_bit_test(), get_prop_dest_stmt(), get_rank(), gimple_call_fnspec(), gimple_stmt_nonnegative_warnv_p(), handle_pointer_plus(), infer_value_range(), insert_gimplified_predicates(), instrument_gimple(), ipa_load_from_parm_agg(), ipa_prop_write_all_agg_replacement(), is_negative_overflow_infinity(), is_true_predicate(), is_vptr_store(), jump_function_from_stmt(), linearize_expr(), live_track_init(), mark_modified(), mark_stmt_if_obviously_necessary(), may_propagate_copy_into_asm(), may_reassociate_p(), maybe_dump_rtl_for_gimple_stmt(), optimize_omp_library_calls(), phi_result_unknown_predicate(), process_assert_insertions_for(), propagate_with_phi(), range_is_null(), recognize_single_bit_test(), register_edge_assert_for_1(), remove_dead_stmt(), rewrite_reciprocal(), same_bool_result_p(), simplify_binary_expression(), simplify_bitwise_binary_1(), simplify_conversion_from_bitmask(), simplify_gimple_switch_label_vec(), tm_log_emit_restores(), tree_nrv(), type_for_widest_vector_mode(), unmodified_parm(), vect_build_slp_tree_1(), vect_create_vectorized_demotion_stmts(), vn_reference_lookup_3(), vrp_intersect_ranges_1(), walk_gimple_asm(), and warn_uninitialized_vars().
|
inlinestatic |
Return a pointer to the first operand on the RHS of assignment statement GS.
Referenced by record_use().
|
inlinestatic |
Return the second operand on the RHS of assignment statement GS. If GS does not have two operands, NULL is returned instead.
Referenced by alloc_cand_and_find_basis(), ao_ref_base_alias_set(), check_bool_pattern(), check_for_plus_in_loops_1(), decrement_power(), evaluate_stmt(), extract_range_from_cond_expr(), forward_propagate_addr_expr(), get_initial_def_for_reduction(), infer_value_range(), ipa_load_from_parm_agg(), jump_function_from_stmt(), linearize_expr(), may_reassociate_p(), maybe_dump_rtl_for_gimple_stmt(), recognize_single_bit_test(), same_bool_result_p(), tm_log_emit_restores(), vect_build_slp_tree_1(), and vrp_intersect_ranges_1().
|
inlinestatic |
Return a pointer to the second operand on the RHS of assignment statement GS.
Referenced by record_use().
|
inlinestatic |
Return the third operand on the RHS of assignment statement GS. If GS does not have two operands, NULL is returned instead.
Referenced by tm_log_emit_restores().
|
inlinestatic |
Return a pointer to the third operand on the RHS of assignment statement GS.
|
inlinestatic |
Return the gimple rhs class of the code of the expression computed on the rhs of assignment statement GS. This will never return GIMPLE_INVALID_RHS.
Referenced by walk_gimple_asm().
|
inlinestatic |
Return the code of the expression computed on the rhs of assignment statement GS. In case that the RHS is a single object, returns the tree code of the object.
While we initially set subcode to the TREE_CODE of the rhs for GIMPLE_SINGLE_RHS assigns we do not update that subcode to stay in sync when we rewrite stmts into SSA form or do SSA propagations.
Referenced by add_dependency(), add_repeat_to_ops_vec(), adjust_related_strinfos(), ao_ref_base_alias_set(), build_and_add_sum(), check_bool_pattern(), check_for_plus_in_loops_1(), convert_mult_to_widen(), decrement_power(), eliminate_temp_copies(), extract_range_from_cond_expr(), find_loop_niter(), find_use_stmt(), fold_stmt_inplace(), forward_propagate_addr_expr(), get_initial_def_for_reduction(), gimple_call_fnspec(), infer_value_range(), ipa_load_from_parm_agg(), is_negative_overflow_infinity(), is_phi_for_stmt(), is_true_predicate(), jump_function_from_stmt(), ncd_for_two_cands(), phi_result_unknown_predicate(), process_assert_insertions_for(), range_is_null(), recognize_single_bit_test(), register_edge_assert_for_1(), replace_phi_args_in(), replace_ref(), same_bool_result_p(), simplify_binary_expression(), simplify_bitwise_binary_1(), simplify_gimple_switch_label_vec(), swap_ops_for_binary_stmt(), tm_log_emit_restores(), type_for_widest_vector_mode(), unmodified_parm_1(), vect_build_slp_tree_1(), vect_create_vectorized_demotion_stmts(), and vrp_intersect_ranges_1().
In cfgexpand.c.
|
inlinestatic |
Set LHS to be the LHS operand of assignment statement GS.
Referenced by gimple_set_bb(), sra_modify_constructor_assign(), and vect_permute_store_chain().
|
inlinestatic |
Sets nontemporal move flag of GS to NONTEMPORAL.
|
inlinestatic |
Set RHS to be the first operand on the RHS of assignment statement GS.
Referenced by associate_pointerplus(), combine_conversions(), insert_gimplified_predicates(), remap_vla_decls(), remove_visited_stmt_chain(), simplify_bitwise_binary_1(), and simplify_bitwise_binary_boolean().
|
inlinestatic |
Set RHS to be the second operand on the RHS of assignment statement GS.
Referenced by remove_visited_stmt_chain(), simplify_bitwise_binary_1(), and simplify_bitwise_binary_boolean().
|
inlinestatic |
Set RHS to be the third operand on the RHS of assignment statement GS.
|
inlinestatic |
Set CODE to be the code for the expression computed on the RHS of assignment S.
Referenced by combine_conversions(), simplify_bitwise_binary_1(), and simplify_bitwise_binary_boolean().
| void gimple_assign_set_rhs_from_tree | ( | gimple_stmt_iterator * | , |
| tree | |||
| ) |
|
inlinestatic |
A wrapper around gimple_assign_set_rhs_with_ops_1, for callers which expect to see only a maximum of two operands.
Referenced by linearize_expr(), and replace_phi_args_in().
| void gimple_assign_set_rhs_with_ops_1 | ( | gimple_stmt_iterator * | gsi, |
| enum tree_code | code, | ||
| tree | op1, | ||
| tree | op2, | ||
| tree | op3 | ||
| ) |
Set the RHS of assignment statement pointed-to by GSI to CODE with operands OP1, OP2 and OP3.
NOTE: The statement pointed-to by GSI may be reallocated if it did not have enough operand slots.
If the new CODE needs more operands, allocate a new statement.
The LHS needs to be reset as this also changes the SSA name
on the LHS.
Referenced by gimple_call_return_flags().
|
inlinestatic |
Return true if GS is an assignment with a singleton RHS, i.e., there is no operator associated with the assignment itself. Unlike gimple_assign_copy_p, this predicate returns true for any RHS operand, including those that perform an operation and do not have the semantics of a copy, such as COND_EXPR.
Referenced by ao_ref_base_alias_set(), build_access_from_expr_1(), build_rdg_partition_for_vertex(), check_for_plus_in_loops_1(), constant_pointer_difference(), examine_call_tm(), get_rank(), gimple_call_flags(), initialize_inline_failed(), insert_gimplified_predicates(), ipa_load_from_parm_agg(), mark_modified(), may_propagate_copy_into_asm(), propagate_with_phi(), replace_phi_args_in(), and warn_uninitialized_vars().
|
inlinestatic |
Return the basic block holding statement G.
Referenced by bb_in_sese_p(), mark_def_dom_walker::before_dom_children(), case_bit_test_cmp(), check_forbidden_calls(), copy_static_chain(), create_expression_by_pieces(), determine_base_object(), dse_optimize_stmt(), dump_function_to_file(), dump_live_info(), eliminate_local_variables(), find_basis_for_base_expr(), find_givs_in_bb(), find_loop_niter(), find_subloop_latch_edge_by_profile(), fixup_noreturn_call(), get_ancestor_addr_info(), get_iv(), get_loops_exits(), get_rank(), get_tm_region_blocks(), gimple_value_profile_transformations(), independent_of_stmt_p(), is_use_properly_guarded(), loe_visit_block(), make_pass_build_ssa(), outermost_invariant_loop(), simple_mem_ref_in_stmt(), simulate_stmt(), stmt_kills_ref_p_1(), strlen_optimize_stmt(), tm_memopt_clear_visited(), try_improve_iv_set(), vect_get_new_vect_var(), vect_grouped_store_supported(), vect_slp_analyze_bb(), vn_nary_op_insert_into(), zero_one_operation(), and instantiate_cache_type::~instantiate_cache_type().
|
inlinestatic |
Append a sequence of statements to the end of a GIMPLE_BIND's body.
Referenced by lower_omp_sections(), and maybe_add_implicit_barrier_cancel().
|
inlinestatic |
Append a statement to the end of a GIMPLE_BIND's body.
Referenced by lower_omp_sections(), and maybe_add_implicit_barrier_cancel().
|
inlinestatic |
Append VARS to the set of variables declared in the GIMPLE_BIND statement GS.
Referenced by lower_omp_sections(), and maybe_add_implicit_barrier_cancel().
|
inlinestatic |
Return the TREE_BLOCK node associated with GIMPLE_BIND statement GS. This is analogous to the BIND_EXPR_BLOCK field in trees.
|
inlinestatic |
Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS.
Referenced by finalize_nesting_tree_1(), gimple_build_transaction(), and gimple_purge_all_dead_abnormal_call_edges().
|
inlinestatic |
Return the stack of bindings created during gimplification.
References gimplify_ctx::conditional_cleanups, gimplify_ctx::conditions, gcc_assert, and gimple_seq_empty_p().
|
inlinestatic |
Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND statement GS.
|
inlinestatic |
Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND statement GS.
Referenced by finalize_nesting_tree_1().
|
inlinestatic |
Set VARS to be the set of variables declared in the GIMPLE_BIND statement GS.
Referenced by get_formal_tmp_var().
|
inlinestatic |
Return the variables declared in the GIMPLE_BIND statement GS.
Referenced by get_formal_tmp_var(), and lower_omp_sections().
|
inlinestatic |
Return the lexical scope block holding statement G.
Referenced by expand_task_call(), lower_gimple_return(), make_blocks(), and valid_gimple_call_p().
| gimple_seq gimple_body | ( | tree | ) |
Referenced by lower_send_clauses(), and shortcut_cond_expr().
| gimple gimple_build_asm_vec | ( | const char * | string, |
| vec< tree, va_gc > * | inputs, | ||
| vec< tree, va_gc > * | outputs, | ||
| vec< tree, va_gc > * | clobbers, | ||
| vec< tree, va_gc > * | labels | ||
| ) |
Build a GIMPLE_ASM statement.
STRING is the assembly code. NINPUT is the number of register inputs. NOUTPUT is the number of register outputs. NCLOBBERS is the number of clobbered registers. INPUTS is a vector of the input register parameters. OUTPUTS is a vector of the output register parameters. CLOBBERS is a vector of the clobbered register parameters. LABELS is a vector of destination labels.
References gimple_alloc, gimple_eh_filter_set_failure(), and gimple_eh_filter_set_types().
| gimple gimple_build_bind | ( | tree | , |
| gimple_seq | , | ||
| tree | |||
| ) |
| gimple gimple_build_call_internal | ( | enum | internal_fn, |
| unsigned | , | ||
| ... | |||
| ) |
| gimple gimple_build_catch | ( | tree | , |
| gimple_seq | |||
| ) |
| gimple gimple_build_cond | ( | enum tree_code | pred_code, |
| tree | lhs, | ||
| tree | rhs, | ||
| tree | t_label, | ||
| tree | f_label | ||
| ) |
Build a GIMPLE_COND statement.
PRED is the condition used to compare LHS and the RHS. T_LABEL is the label to jump to if the condition is true. F_LABEL is the label to jump to otherwise.
Referenced by expand_transaction(), gimple_cond_get_ops_from_tree(), instrument_derefs(), and restore_vars_to_original_value().
| gimple gimple_build_eh_dispatch | ( | int | ) |
| gimple gimple_build_eh_else | ( | gimple_seq | , |
| gimple_seq | |||
| ) |
| gimple gimple_build_eh_filter | ( | tree | , |
| gimple_seq | |||
| ) |
| gimple gimple_build_nop | ( | void | ) |
Build a GIMPLE_NOP statement.
Referenced by fold_gimple_cond().
| gimple gimple_build_omp_critical | ( | gimple_seq | , |
| tree | |||
| ) |
| gimple gimple_build_omp_for | ( | gimple_seq | body, |
| int | kind, | ||
| tree | clauses, | ||
| size_t | collapse, | ||
| gimple_seq | pre_body | ||
| ) |
Build a GIMPLE_OMP_FOR statement.
BODY is sequence of statements inside the for loop. KIND is the `for' variant. CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate, lastprivate, reductions, ordered, schedule, and nowait. COLLAPSE is the collapse count. PRE_BODY is the sequence of statements that are loop invariant.
| gimple gimple_build_omp_master | ( | gimple_seq | ) |
| gimple gimple_build_omp_ordered | ( | gimple_seq | ) |
| gimple gimple_build_omp_parallel | ( | gimple_seq | body, |
| tree | clauses, | ||
| tree | child_fn, | ||
| tree | data_arg | ||
| ) |
Build a GIMPLE_OMP_PARALLEL statement.
BODY is sequence of statements which are executed in parallel. CLAUSES, are the OMP parallel construct's clauses. CHILD_FN is the function created for the parallel threads to execute. DATA_ARG are the shared data argument(s).
References gimple_alloc, and gimple_omp_set_body().
| gimple gimple_build_omp_section | ( | gimple_seq | ) |
| gimple gimple_build_omp_sections | ( | gimple_seq | , |
| tree | |||
| ) |
| gimple gimple_build_omp_sections_switch | ( | void | ) |
Build a GIMPLE_OMP_SECTIONS_SWITCH.
References gimple_alloc, and gimple_omp_atomic_store_set_val().
| gimple gimple_build_omp_single | ( | gimple_seq | , |
| tree | |||
| ) |
| gimple gimple_build_omp_target | ( | gimple_seq | , |
| int | , | ||
| tree | |||
| ) |
| gimple gimple_build_omp_task | ( | gimple_seq | body, |
| tree | clauses, | ||
| tree | child_fn, | ||
| tree | data_arg, | ||
| tree | copy_fn, | ||
| tree | arg_size, | ||
| tree | arg_align | ||
| ) |
Build a GIMPLE_OMP_TASK statement.
BODY is sequence of statements which are executed by the explicit task. CLAUSES, are the OMP parallel construct's clauses. CHILD_FN is the function created for the parallel threads to execute. DATA_ARG are the shared data argument(s). COPY_FN is the optional function for firstprivate initialization. ARG_SIZE and ARG_ALIGN are size and alignment of the data block.
| gimple gimple_build_omp_taskgroup | ( | gimple_seq | ) |
| gimple gimple_build_omp_teams | ( | gimple_seq | , |
| tree | |||
| ) |
| gimple gimple_build_predict | ( | enum | br_predictor, |
| enum | prediction | ||
| ) |
| gimple gimple_build_resx | ( | int | ) |
| gimple gimple_build_transaction | ( | gimple_seq | , |
| tree | |||
| ) |
| gimple_statement_try* gimple_build_try | ( | gimple_seq | eval, |
| gimple_seq | cleanup, | ||
| enum gimple_try_flags | kind | ||
| ) |
Build a GIMPLE_TRY statement.
EVAL is the expression to evaluate. CLEANUP is the cleanup expression. KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on whether this is a try/catch or a try/finally respectively.
References gcc_checking_assert, gimple_build_with_ops, gimple_switch_set_default_label(), and gimple_switch_set_index().
Referenced by gimplify_expr().
| gimple gimple_build_wce | ( | gimple_seq | ) |
|
inlinestatic |
Given a valid GIMPLE_CALL function address return the FUNCTION_DECL associated with the callee if known. Otherwise return NULL_TREE.
|
inlinestatic |
Return true of S is a call to builtin_alloca emitted for VLA objects.
|
inlinestatic |
Return the argument at position INDEX for call statement GS.
Referenced by adjust_simduid_builtins(), bit_value_unop(), call_may_clobber_ref_p_1(), constant_pointer_difference(), oecount_hasher::equal(), estimate_move_cost(), handle_lhs_call(), handle_pure_call(), handle_rhs_call(), instrument_builtin_call(), ipa_modify_call_arguments(), lower_gimple_return(), make_heapvar(), note_simd_array_uses(), phi_result_unknown_predicate(), refs_may_alias_p(), refs_output_dependent_p(), set_strinfo(), symbolic_range_p(), and walk_gimple_asm().
| int gimple_call_arg_flags | ( | const_gimple | , |
| unsigned | |||
| ) |
|
inlinestatic |
Return a pointer to the argument at position INDEX for call statement GS.
Referenced by walk_gimple_asm().
|
inlinestatic |
Return the static chain for call statement GS.
Referenced by vect_build_slp_tree_1().
|
inlinestatic |
Return a pointer to the static chain for call statement GS.
Referenced by walk_gimple_asm().
|
staticread |
Return a pointer to the points-to solution for the set of call-used variables of the call CALL.
|
inlinestatic |
Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL.
| int gimple_call_flags | ( | const_gimple | ) |
|
inlinestatic |
Return the tree node representing the function called by call statement GS.
Referenced by diagnose_tm_1_op(), print_expr_hash_elt(), and vect_build_slp_tree_1().
|
inlinestatic |
Return a pointer to the tree node representing the function called by call statement GS.
Referenced by walk_gimple_asm().
|
inlinestatic |
If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it. Otherwise return NULL. This function is analogous to get_callee_fndecl in tree land.
Referenced by add_dependency(), build_cgraph_edges(), cgraph_clone_edge(), check_builtin_call(), constant_pointer_difference(), dest_safe_for_nrv_p(), dump_function_to_file(), oecount_hasher::equal(), get_mem_ref_of_assignment(), init_object_sizes(), is_tm_load(), is_tm_store(), mark_stmt_if_obviously_necessary(), maybe_catch_exception(), record_temporary_equivalences_from_stmts_at_dest(), scan_omp_target(), special_builtin_state(), and symbolic_range_p().
|
inlinestatic |
Return the function type of the function called by GS.
Referenced by vect_build_slp_tree_1().
|
inlinestatic |
Return true if GIMPLE_CALL S is a jump from a thunk.
| unsigned gimple_call_get_nobnd_arg_index | ( | const_gimple | , |
| unsigned | |||
| ) |
|
inlinestatic |
Return the target of internal call GS.
Referenced by adjust_simduid_builtins(), note_simd_array_uses(), print_expr_hash_elt(), and vect_finish_stmt_generation().
|
inlinestatic |
Return true if call GS calls an internal-only function, as enumerated by internal_fn.
Referenced by adjust_simduid_builtins(), insert_aux(), note_simd_array_uses(), print_expr_hash_elt(), vect_build_slp_tree_1(), and vect_finish_stmt_generation().
|
inlinestatic |
Return the LHS of call statement GS.
Referenced by check_builtin_call(), constant_pointer_difference(), dest_safe_for_nrv_p(), find_tail_calls(), fold_gimple_cond(), get_param_index(), gimple_assign_unary_nop_p(), gimple_stringop_fixed_value(), handle_lhs_call(), handle_rhs_call(), instrument_builtin_call(), lower_gimple_return(), make_constraints_to(), mark_stmt_if_obviously_necessary(), movement_possibility(), note_simd_array_uses(), phi_result_unknown_predicate(), stmt_is_power_of_op(), valid_gimple_call_p(), vect_finish_stmt_generation(), vect_get_loop_based_defs(), vect_mark_relevant(), and walk_gimple_asm().
|
inlinestatic |
Return a pointer to the LHS of call statement GS.
Referenced by walk_gimple_asm().
|
inlinestatic |
Return INDEX's call argument ignoring bound ones.
No bound args may exist if pointers checker is off.
|
inlinestatic |
Return true if S is a noreturn call.
Referenced by fixup_noreturn_call(), and vect_build_slp_tree_1().
|
inlinestatic |
Return true if S is a nothrow call.
Referenced by tree_could_trap_p(), and vect_build_slp_tree_1().
|
inlinestatic |
Return the number of arguments used by call statement GS.
Referenced by constant_pointer_difference(), is_gimple_asm_val(), make_heapvar(), refs_may_alias_p(), refs_output_dependent_p(), symbolic_range_p(), vect_build_slp_tree_1(), vect_finish_stmt_generation(), and walk_gimple_asm().
|
inlinestatic |
Return the number of arguments used by call statement GS ignoring bound ones.
| void gimple_call_reset_alias_info | ( | gimple | ) |
| int gimple_call_return_flags | ( | const_gimple | ) |
|
inlinestatic |
Return true if S is marked for return slot optimization.
Referenced by dest_safe_for_nrv_p().
|
inlinestatic |
Return the type returned by call statement GS.
The type returned by a function is the type of its function type.
| bool gimple_call_same_target_p | ( | const_gimple | , |
| const_gimple | |||
| ) |
|
inlinestatic |
If FOR_VAR is true, GIMPLE_CALL S is a call to builtin_alloca that is known to be emitted for VLA objects. Those are wrapped by stack_save/stack_restore calls and hence can't lead to unbounded stack growth even when they occur in loops.
|
inlinestatic |
Set ARG to be the argument at position INDEX for call statement GS.
Referenced by gimple_build_call(), gimple_build_call_1(), gimple_build_call_internal(), and gimple_build_call_vec().
|
inlinestatic |
Set CHAIN to be the static chain for call statement GS.
|
inlinestatic |
Set FN to be the function called by call statement GS.
|
inlinestatic |
Set FNDECL to be the function called by call statement GS.
Referenced by expand_assign_tm(), and instrument_builtin_call().
|
inlinestatic |
Set the type of the function called by GS to FNTYPE.
Referenced by gimple_call_reset_alias_info().
|
inlinestatic |
If FROM_THUNK_P is true, mark GIMPLE_CALL S as being the jump from a thunk to the thunked-to function.
|
inlinestatic |
Set internal function FN to be the function called by call statement GS.
Referenced by gimple_build_call_valist().
|
inlinestatic |
Set LHS to be the LHS operand of call statement GS.
Referenced by gimple_set_bb(), gimple_stringop_fixed_value(), instrument_builtin_call(), instrument_memory_accesses(), set_strinfo(), tm_mangle(), and valid_gimple_call_p().
|
inlinestatic |
If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw even if the called function can throw in other cases.
|
inlinestatic |
If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return slot optimization. This transformation uses the target of the call expansion as the return slot for calls that return in memory.
Referenced by dest_safe_for_nrv_p().
|
inlinestatic |
If TAIL_P is true, mark call statement S as being a tail call (i.e., a call just before the exit of a function). These calls are candidate for tail call optimization.
|
inlinestatic |
If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the argument pack in its argument list.
|
inlinestatic |
Return true if GIMPLE_CALL S is marked as a tail call.
Referenced by vect_build_slp_tree_1().
|
staticread |
Return a pointer to the points-to solution for the set of call-used variables of the call CALL.
|
inlinestatic |
Return true if GIMPLE_CALL S is a stdarg call that needs the argument pack in its argument list.
|
inlinestatic |
Return the GIMPLE sequence representing the body of the handler of GIMPLE_CATCH statement GS.
Referenced by gimple_purge_all_dead_abnormal_call_edges().
|
inlinestatic |
Return a pointer to the GIMPLE sequence representing the body of the handler of GIMPLE_CATCH statement GS.
Referenced by replace_goto_queue_cond_clause().
|
inlinestatic |
Set HANDLER to be the body of GIMPLE_CATCH GS.
|
inlinestatic |
Set T to be the set of types handled by GIMPLE_CATCH GS.
|
inlinestatic |
Return the types handled by GIMPLE_CATCH statement GS.
|
inlinestatic |
Return a pointer to the types handled by GIMPLE_CATCH statement GS.
|
inlinestatic |
Return true if S is a clobber statement.
Referenced by build_access_from_expr_1(), and dse_optimize_stmt().
|
inlinestatic |
Return the code for GIMPLE statement G.
|
inlinestatic |
Return the code of the predicate computed by conditional statement GS.
Referenced by associate_equivalences_with_edges(), check_forbidden_calls(), create_bb(), get_ancestor_addr_info(), is_norm_cond_subset_of(), operand_equal_for_value_replacement(), optimize_stmt(), and simplify_using_outer_evolutions().
|
inlinestatic |
Return the label used by conditional statement GS when its predicate evaluates to false.
Referenced by record_in_goto_queue_label().
|
inlinestatic |
Check if conditional statement GS is of the form 'if (1 != 1)', 'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)'
| void gimple_cond_get_ops_from_tree | ( | tree | cond, |
| enum tree_code * | code_p, | ||
| tree * | lhs_p, | ||
| tree * | rhs_p | ||
| ) |
Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND.
Canonicalize conditionals of the form 'if (!VAL)'.
Canonicalize conditionals of the form 'if (VAL)'
References gimple_build_cond(), and gimple_cond_get_ops_from_tree().
Referenced by gimple_cond_get_ops_from_tree().
|
inlinestatic |
Return the LHS of the predicate computed by conditional statement GS.
Referenced by associate_equivalences_with_edges(), create_bb(), create_loop_fn(), get_ancestor_addr_info(), is_norm_cond_subset_of(), optimize_stmt(), simplify_cond_using_ranges(), and simplify_using_outer_evolutions().
|
inlinestatic |
Return the pointer to the LHS of the predicate computed by conditional statement GS.
Referenced by record_use().
|
inlinestatic |
Set the conditional COND_STMT to be of the form 'if (1 == 0)'.
Referenced by create_bb(), and test_for_singularity().
|
inlinestatic |
Set the conditional COND_STMT to be of the form 'if (1 == 1)'.
Referenced by create_bb(), and test_for_singularity().
|
inlinestatic |
Return the RHS operand of the predicate computed by conditional GS.
Referenced by associate_equivalences_with_edges(), check_forbidden_calls(), create_bb(), create_loop_fn(), get_ancestor_addr_info(), is_norm_cond_subset_of(), optimize_stmt(), simplify_cond_using_ranges(), and simplify_using_outer_evolutions().
|
inlinestatic |
Return the pointer to the RHS operand of the predicate computed by conditional GS.
Referenced by record_use().
|
inlinestatic |
Set CODE to be the predicate code for the conditional statement GS.
|
inlinestatic |
Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS.
|
inlinestatic |
Set LABEL to be the label used by conditional statement GS when its predicate evaluates to false.
Referenced by gimple_build_assign_with_ops().
|
inlinestatic |
Set LHS to be the LHS operand of the predicate computed by conditional statement GS.
Referenced by create_loop_fn(), and gimple_build_assign_with_ops().
|
inlinestatic |
Set RHS to be the RHS operand of the predicate computed by conditional statement GS.
Referenced by gimple_build_assign_with_ops().
|
inlinestatic |
Set LABEL to be the label used by conditional statement GS when its predicate evaluates to true.
Referenced by gimple_build_assign_with_ops().
|
inlinestatic |
Return the label used by conditional statement GS when its predicate evaluates to true.
Referenced by record_in_goto_queue_label().
|
inlinestatic |
Check if conditional statemente GS is of the form 'if (1 == 1)', 'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)'
| gimple gimple_current_bind_expr | ( | void | ) |
Return the first element of the stack of bindings.
References gimplify_ctx::conditions.
|
inlinestatic |
Return the value bound to the variable in a GIMPLE_DEBUG bind statement.
Referenced by rewrite_use_nonlinear_expr().
|
inlinestatic |
Return a pointer to the value bound to the variable in a GIMPLE_DEBUG bind statement.
|
inlinestatic |
Return the variable bound in a GIMPLE_DEBUG bind statement.
Referenced by gimple_redirect_edge_and_branch(), mark_stmt_if_obviously_necessary(), and separate_decls_in_region_stmt().
|
inlinestatic |
Return true if the GIMPLE_DEBUG bind statement is bound to a value.
Referenced by mark_stmt_if_obviously_necessary().
|
inlinestatic |
Return true if S is a GIMPLE_DEBUG BIND statement.
Referenced by avoid_complex_debug_insns(), gather_scalar_reductions(), get_asm_expr_operands(), gimple_redirect_edge_and_branch(), insert_debug_temps_for_defs(), lookup_avail_expr(), mark_stmt_if_obviously_necessary(), rewrite_use_nonlinear_expr(), separate_decls_in_region_stmt(), set_rename(), and vect_min_worthwhile_factor().
|
inlinestatic |
Remove the value bound to the variable in a GIMPLE_DEBUG bind statement.
Referenced by insert_debug_temps_for_defs(), separate_decls_in_region_stmt(), set_rename(), and vect_min_worthwhile_factor().
|
inlinestatic |
Set the value bound to the variable in a GIMPLE_DEBUG bind statement.
|
inlinestatic |
Set the variable bound in a GIMPLE_DEBUG bind statement.
Referenced by separate_decls_in_region_stmt().
|
inlinestatic |
Return the value bound to the variable in a GIMPLE_DEBUG source bind statement.
Referenced by register_new_def().
|
inlinestatic |
Return a pointer to the value bound to the variable in a GIMPLE_DEBUG source bind statement.
|
inlinestatic |
Return the variable bound in a GIMPLE_DEBUG source bind statement.
Referenced by register_new_def(), and separate_decls_in_region_stmt().
|
inlinestatic |
Return true if S is a GIMPLE_DEBUG SOURCE BIND statement.
Referenced by register_new_def(), separate_decls_in_region_stmt(), and set_rename().
|
inlinestatic |
Set the value bound to the variable in a GIMPLE_DEBUG source bind statement.
|
inlinestatic |
Set the variable bound in a GIMPLE_DEBUG source bind statement.
Referenced by separate_decls_in_region_stmt().
| const char* gimple_decl_printable_name | ( | tree | , |
| int | |||
| ) |
|
inlinestatic |
Return the region number for GIMPLE_EH_DISPATCH GS.
Referenced by dump_gimple_eh_else().
|
inlinestatic |
Set REGION to be the region number for GIMPLE_EH_DISPATCH GS.
|
inlinestatic |
Referenced by dump_gimple_eh_filter(), and honor_protect_cleanup_actions().
|
inlinestatic |
Referenced by replace_goto_queue_cond_clause().
|
inlinestatic |
Referenced by dump_gimple_eh_filter(), and honor_protect_cleanup_actions().
|
inlinestatic |
GIMPLE_EH_ELSE accessors.
Referenced by replace_goto_queue_cond_clause().
|
inlinestatic |
Referenced by gimple_build_catch().
|
inlinestatic |
Referenced by gimple_build_catch().
|
inlinestatic |
Return the sequence of statement to execute when GIMPLE_EH_FILTER statement fails.
Referenced by gimple_purge_all_dead_abnormal_call_edges().
|
inlinestatic |
Return a pointer to the sequence of statement to execute when GIMPLE_EH_FILTER statement fails.
Referenced by replace_goto_queue_cond_clause().
|
inlinestatic |
Set FAILURE to be the sequence of statements to execute on failure for GIMPLE_EH_FILTER GS.
Referenced by gimple_build_asm_vec().
|
inlinestatic |
Set TYPES to be the set of types handled by GIMPLE_EH_FILTER GS.
Referenced by gimple_build_asm_vec().
|
inlinestatic |
Return the types handled by GIMPLE_EH_FILTER statement GS.
|
inlinestatic |
Return a pointer to the types handled by GIMPLE_EH_FILTER statement GS.
|
inlinestatic |
Get the function decl to be called by the MUST_NOT_THROW region.
Referenced by dump_gimple_catch().
|
inlinestatic |
Set the function decl to be called by GS to DECL.
|
inlinestatic |
Return the tree code for the expression computed by STMT. This is only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN. For GIMPLE_CALL, return CALL_EXPR as the expression code for consistency. This is useful when the caller needs to deal with the three kinds of computation that GIMPLE supports.
Referenced by ipa_load_from_parm_agg().
|
inlinestatic |
Return the type of the main expression computed by STMT. Return void_type_node if the statement computes nothing.
In general we want to pass out a type that can be substituted for both the RHS and the LHS types if there is a possibly useless conversion involved. That means returning the original RHS type as far as we can reconstruct it.
As fallback use the type of the LHS.
Referenced by extract_range_from_cond_expr(), gate_cse_sincos(), infer_value_range(), insert_aux(), range_is_null(), symbolic_range_p(), and test_for_singularity().
|
inlinestatic |
Return the file name of the location of STMT.
| alias_set_type gimple_get_alias_set | ( | tree | ) |
| tree gimple_get_lhs | ( | const_gimple | ) |
|
inlinestatic |
Return the destination of the unconditional jump GS.
Referenced by find_goto_replacement(), note_nonlocal_vla_type(), and record_in_goto_queue_label().
|
inlinestatic |
Set DEST to be the destination of the unconditonal jump GS.
Referenced by gimple_build_cond_from_tree().
|
inlinestatic |
Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a non-NULL lhs.
Referenced by dse_optimize_stmt(), gsi_split_seq_before(), ref_may_be_aliased(), and tree_nrv().
|
inlinestatic |
Return true if G contains location information.
Referenced by branch_prob(), and vrp_initialize().
|
inlinestatic |
Return true if GIMPLE statement G has memory operands.
|
inlinestatic |
Return true if GIMPLE statement G has register or memory operands.
| bool gimple_has_side_effects | ( | const_gimple | ) |
|
inlinestatic |
Return true if statement G has sub-statements. This is only true for High GIMPLE statements.
|
inlinestatic |
Return true if statement STMT contains volatile operands.
Referenced by build_access_from_expr_1(), generate_code_for_partition(), and get_value_for_expr().
|
inlinestatic |
Return true if STMT is in a transaction.
|
inlinestatic |
Make statement G a singleton sequence.
|
inlinestatic |
Return the LABEL_DECL node used by GIMPLE_LABEL statement GS.
Referenced by apply_return_prediction(), check_stmt(), debug_cfg_stats(), gimple_call_arg_flags(), mark_reachable_handlers(), phi_alternatives_equal(), replace_ssa_name(), and verify_expr_location_1().
|
inlinestatic |
Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement GS.
|
inlinestatic |
Return the line number of the location of STMT.
|
inlinestatic |
Return location information for statement G.
Referenced by attempt_builtin_powi(), avoid_complex_debug_insns(), build_one_array(), check_bool_pattern(), convert_tramp_reference_stmt(), create_bb(), diagnose_tm_1_op(), do_ssa_ccp(), expand_omp_sections(), find_goto_replacement(), free_histograms(), frob_into_branch_around(), generate_subtree_copies(), gimple_execute_on_shrinking_pred(), gimple_purge_dead_eh_edges(), gsi_split_seq_before(), honor_protect_cleanup_actions(), ipa_modify_call_arguments(), is_task_ctx(), lower_gimple_return(), lower_send_clauses(), make_blocks(), maybe_register_def(), note_nonlocal_vla_type(), number_of_iterations_exit(), optimize_stmt(), process_switch(), record_in_goto_queue_label(), replace_rhs_if_not_dup(), rhs_to_tree(), scan_omp_sections(), scan_omp_target(), simplify_bitwise_binary_boolean(), valid_gimple_call_p(), vrp_initialize(), and workshare_safe_to_combine_p().
|
inlinestatic |
Return pointer to location information for statement G.
|
inlinestatic |
Return true if statement G has operands and the modified field has been set.
|
inlinestatic |
Return true if no warnings should be emitted for statement STMT.
Referenced by gimple_purge_dead_eh_edges().
|
inlinestatic |
Returns TRUE if statement G is a GIMPLE_NOP.
Referenced by debug_lattice_value(), dump_live_info(), get_continuation_for_phi(), replace_phi_args_in(), stmt_kills_ref_p_1(), and vect_create_cond_for_alias_checks().
|
inlinestatic |
Return the number of operands for statement GS.
Referenced by get_rank(), special_builtin_state(), unmodified_parm_1(), and walk_gimple_asm().
|
inlinestatic |
Get the LHS of an atomic load.
|
inlinestatic |
Return a pointer to the LHS of an atomic load.
|
inlinestatic |
Get the RHS of an atomic load.
|
inlinestatic |
Return a pointer to the RHS of an atomic load.
|
inlinestatic |
Set the LHS of an atomic load.
|
inlinestatic |
Set the RHS of an atomic load.
|
inlinestatic |
Return true if OMP atomic load/store statement G has the GF_OMP_ATOMIC_NEED_VALUE flag set.
|
inlinestatic |
Return true if OMP atomic load/store statement G has the GF_OMP_ATOMIC_SEQ_CST flag set.
Referenced by expand_omp_sections().
|
inlinestatic |
Set the GF_OMP_ATOMIC_NEED_VALUE flag on G.
|
inlinestatic |
Set the GF_OMP_ATOMIC_SEQ_CST flag on G.
|
inlinestatic |
Set the value being stored in an atomic store.
Referenced by gimple_build_omp_sections_switch().
|
inlinestatic |
Return the value being stored in an atomic store.
|
inlinestatic |
Return a pointer to the value being stored in an atomic store.
|
inlinestatic |
Return the body for the OMP statement GS.
Referenced by dump_gimple_debug(), dump_gimple_omp_block(), dump_gimple_omp_parallel(), dump_gimple_omp_target(), dump_gimple_omp_teams(), lower_omp_sections(), and maybe_add_implicit_barrier_cancel().
|
inlinestatic |
Return a pointer to the body for the OMP statement GS.
Referenced by lower_omp_sections(), maybe_add_implicit_barrier_cancel(), and scan_omp_for().
|
inlinestatic |
Get the definition of the control variable in a GIMPLE_OMP_CONTINUE.
|
inlinestatic |
The same as above, but return the address.
|
inlinestatic |
Get the use of the control variable in a GIMPLE_OMP_CONTINUE.
|
inlinestatic |
The same as above, but return the address.
|
inlinestatic |
Set the definition of the control variable in a GIMPLE_OMP_CONTINUE.
|
inlinestatic |
Set the use of the control variable in a GIMPLE_OMP_CONTINUE.
|
inlinestatic |
Return the name associated with OMP_CRITICAL statement GS.
Referenced by dump_gimple_omp_block().
|
inlinestatic |
Return a pointer to the name associated with OMP critical statement GS.
|
inlinestatic |
Set NAME to be the name associated with OMP critical statement GS.
Referenced by gimple_build_eh_dispatch().
|
inlinestatic |
Return the clauses associated with OMP_FOR GS.
Referenced by dump_gimple_debug().
|
inlinestatic |
Return a pointer to the OMP_FOR GS.
|
inlinestatic |
Get the collapse count of OMP_FOR GS.
Referenced by dump_gimple_debug().
|
inlinestatic |
Return true if OMP for statement G has the GF_OMP_FOR_COMBINED_INTO flag set.
Referenced by create_omp_child_function(), and workshare_safe_to_combine_p().
|
inlinestatic |
Return true if OMP for statement G has the GF_OMP_FOR_COMBINED flag set.
|
inlinestatic |
Return the condition code associated with OMP_FOR GS.
Referenced by dump_gimple_debug().
|
inlinestatic |
Return the final value for OMP_FOR GS.
Referenced by dump_gimple_debug().
|
inlinestatic |
Return a pointer to the final value for OMP_FOR GS.
Referenced by lower_omp_master().
|
inlinestatic |
Return the increment value for OMP_FOR GS.
Referenced by dump_gimple_debug(), and lower_omp_master().
|
inlinestatic |
Return a pointer to the increment value for OMP_FOR GS.
|
inlinestatic |
Return the index variable for OMP_FOR GS.
Referenced by dump_gimple_debug().
|
inlinestatic |
Return a pointer to the index variable for OMP_FOR GS.
|
inlinestatic |
Return the initial value for OMP_FOR GS.
Referenced by dump_gimple_debug().
|
inlinestatic |
Return a pointer to the initial value for OMP_FOR GS.
Referenced by lower_omp_master().
|
inlinestatic |
Return the kind of OMP for statemement.
Referenced by create_omp_child_function(), dump_gimple_debug(), is_task_ctx(), and scan_omp_sections().
|
inlinestatic |
Return the sequence of statements to execute before the OMP_FOR statement GS starts.
|
inlinestatic |
Return a pointer to the sequence of statements to execute before the OMP_FOR statement GS starts.
|
inlinestatic |
Set CLAUSES to be the list of clauses associated with OMP_FOR GS.
Referenced by gimple_build_debug_bind_stat().
|
inlinestatic |
Set the GF_OMP_FOR_COMBINED_INTO field in G depending on the boolean value of COMBINED_P.
|
inlinestatic |
Set the GF_OMP_FOR_COMBINED field in G depending on the boolean value of COMBINED_P.
|
inlinestatic |
Set COND to be the condition code for OMP_FOR GS.
|
inlinestatic |
Set FINAL to be the final value for OMP_FOR GS.
|
inlinestatic |
Set INCR to be the increment value for OMP_FOR GS.
|
inlinestatic |
Set INDEX to be the index variable for OMP_FOR GS.
|
inlinestatic |
Set INITIAL to be the initial value for OMP_FOR GS.
|
inlinestatic |
Set the OMP for kind.
Referenced by gimple_build_debug_bind_stat().
|
inlinestatic |
Set PRE_BODY to be the sequence of statements to execute before the OMP_FOR statement GS starts.
|
inlinestatic |
Return the child function used to hold the body of OMP_PARALLEL GS.
|
inlinestatic |
Return a pointer to the child function used to hold the body of OMP_PARALLEL GS.
|
inlinestatic |
Return the clauses associated with OMP_PARALLEL GS.
Referenced by lower_send_clauses(), and workshare_safe_to_combine_p().
|
inlinestatic |
Return a pointer to the clauses associated with OMP_PARALLEL GS.
|
inlinestatic |
Return true if OMP parallel statement G has the GF_OMP_PARALLEL_COMBINED flag set.
|
inlinestatic |
Return the artificial argument used to send variables and values from the parent to the children threads in OMP_PARALLEL GS.
|
inlinestatic |
Return a pointer to the data argument for OMP_PARALLEL GS.
|
inlinestatic |
Set CHILD_FN to be the child function for OMP_PARALLEL GS.
|
inlinestatic |
Set CLAUSES to be the list of clauses associated with OMP_PARALLEL GS.
|
inlinestatic |
Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean value of COMBINED_P.
|
inlinestatic |
Set DATA_ARG to be the data argument for OMP_PARALLEL GS.
|
inlinestatic |
Get the LHS of OMP return.
|
inlinestatic |
Return a pointer to the LHS of OMP return.
|
inlinestatic |
Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT flag set.
|
inlinestatic |
Set the LHS of OMP return.
|
inlinestatic |
Set the nowait flag on OMP_RETURN statement S.
|
inlinestatic |
Return true if OMP section statement G has the GF_OMP_SECTION_LAST flag set.
|
inlinestatic |
Set the GF_OMP_SECTION_LAST flag on G.
|
inlinestatic |
Return the clauses associated with OMP_SECTIONS GS.
Referenced by dump_gimple_omp_teams(), and scan_omp_teams().
|
inlinestatic |
Return a pointer to the clauses associated with OMP_SECTIONS GS.
|
inlinestatic |
Return the control variable associated with the GIMPLE_OMP_SECTIONS in GS.
Referenced by dump_gimple_omp_teams().
|
inlinestatic |
Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS GS.
|
inlinestatic |
Set CLAUSES to be the set of clauses associated with OMP_SECTIONS GS.
|
inlinestatic |
Set CONTROL to be the set of clauses associated with the GIMPLE_OMP_SECTIONS in GS.
|
inlinestatic |
Set BODY to be the body for the OMP statement GS.
Referenced by gimple_build_debug_bind_stat(), gimple_build_eh_dispatch(), gimple_build_omp_continue(), gimple_build_omp_parallel(), gimple_build_omp_section(), lower_omp_sections(), and maybe_add_implicit_barrier_cancel().
|
inlinestatic |
Set the subcode for OMP statement S to SUBCODE.
We only have 16 bits for the subcode. Assert that we are not overflowing it.
|
inlinestatic |
Return the clauses associated with OMP_SINGLE GS.
|
inlinestatic |
Return a pointer to the clauses associated with OMP_SINGLE GS.
|
inlinestatic |
Set CLAUSES to be the clauses associated with OMP_SINGLE GS.
Referenced by gimple_build_omp_continue().
|
inlinestatic |
Return the subcode for OMP statement S.
|
inlinestatic |
Return the child function used to hold the body of OMP_TARGET GS.
|
inlinestatic |
Return a pointer to the child function used to hold the body of OMP_TARGET GS.
|
inlinestatic |
Return the clauses associated with OMP_TARGET GS.
|
inlinestatic |
Return a pointer to the clauses associated with OMP_TARGET GS.
|
inlinestatic |
Return the artificial argument used to send variables and values from the parent to the children threads in OMP_TARGET GS.
|
inlinestatic |
Return a pointer to the data argument for OMP_TARGET GS.
|
inlinestatic |
Return the kind of OMP target statemement.
|
inlinestatic |
Set CHILD_FN to be the child function for OMP_TARGET GS.
|
inlinestatic |
Set CLAUSES to be the clauses associated with OMP_TARGET GS.
|
inlinestatic |
Set DATA_ARG to be the data argument for OMP_TARGET GS.
|
inlinestatic |
Set the OMP target kind.
|
inlinestatic |
Return align of the data block in bytes in OMP_TASK GS.
|
inlinestatic |
Return a pointer to the data block align for OMP_TASK GS.
|
inlinestatic |
Return size of the data block in bytes in OMP_TASK GS.
Referenced by dump_gimple_omp_parallel().
|
inlinestatic |
Return a pointer to the data block size for OMP_TASK GS.
|
inlinestatic |
Return the child function used to hold the body of OMP_TASK GS.
Referenced by dump_gimple_omp_parallel().
|
inlinestatic |
Return a pointer to the child function used to hold the body of OMP_TASK GS.
|
inlinestatic |
Return the clauses associated with OMP_TASK GS.
Referenced by dump_gimple_omp_parallel().
|
inlinestatic |
Return a pointer to the clauses associated with OMP_TASK GS.
|
inlinestatic |
Return the copy function used to hold the body of OMP_TASK GS.
Referenced by dump_gimple_omp_parallel().
|
inlinestatic |
Return a pointer to the copy function used to hold the body of OMP_TASK GS.
|
inlinestatic |
Return the artificial argument used to send variables and values from the parent to the children threads in OMP_TASK GS.
Referenced by dump_gimple_omp_parallel().
|
inlinestatic |
Return a pointer to the data argument for OMP_TASK GS.
|
inlinestatic |
Set ARG_SIZE to be the data block align for OMP_TASK GS.
|
inlinestatic |
Set ARG_SIZE to be the data block size for OMP_TASK GS.
|
inlinestatic |
Set CHILD_FN to be the child function for OMP_TASK GS.
|
inlinestatic |
Set CLAUSES to be the list of clauses associated with OMP_TASK GS.
|
inlinestatic |
Set CHILD_FN to be the copy function for OMP_TASK GS.
|
inlinestatic |
Set DATA_ARG to be the data argument for OMP_TASK GS.
|
inlinestatic |
Return the child function used to hold the body of OMP_TASK GS.
|
inlinestatic |
Return a pointer to the child function used to hold the body of OMP_TASK GS.
|
inlinestatic |
Return the clauses associated with OMP_TASK GS.
Referenced by convert_tramp_reference_stmt(), note_nonlocal_vla_type(), and use_pointer_for_field().
|
inlinestatic |
Return a pointer to the clauses associated with OMP_TASK GS.
Referenced by note_nonlocal_vla_type().
|
inlinestatic |
Return the artificial argument used to send variables and values from the parent to the children threads in OMP_TASK GS.
Referenced by optimize_omp_library_calls().
|
inlinestatic |
Return a pointer to the data argument for OMP_TASK GS.
|
inlinestatic |
Set CHILD_FN to be the child function for OMP_TASK GS.
|
inlinestatic |
Set CLAUSES to be the list of clauses associated with OMP_TASK GS.
Referenced by convert_tramp_reference_stmt(), and note_nonlocal_vla_type().
|
inlinestatic |
Set DATA_ARG to be the data argument for OMP_TASK GS.
|
inlinestatic |
Return the clauses associated with OMP_TEAMS GS.
Referenced by scan_omp_for().
|
inlinestatic |
Return a pointer to the clauses associated with OMP_TEAMS GS.
|
inlinestatic |
Set CLAUSES to be the clauses associated with OMP_TEAMS GS.
|
inlinestatic |
Return operand I for statement GS.
Referenced by get_initial_def_for_reduction(), get_rank(), gimple_call_flags(), op_iter_next_use(), special_builtin_state(), vect_analyze_slp(), and vect_slp_analyze_bb().
|
inlinestatic |
Return a pointer to operand I for statement GS.
Referenced by num_imm_uses(), record_in_goto_queue_label(), replace_goto_queue_cond_clause(), and walk_gimple_asm().
|
inlinestatic |
Return the array of operands for statement GS.
All the tuples have their operand vector at the very bottom of the structure. Note that those structures that do not have an operand vector have a zero offset.
|
staticread |
Return the PHI argument corresponding to incoming edge INDEX for GIMPLE_PHI GS.
Referenced by check_for_plus_in_loops_1().
|
inlinestatic |
Return the tree operand for argument I of PHI node GS.
Referenced by analyze_increments(), dump_live_info(), dump_ssaname_info(), final_range_test_p(), find_matching_predicate_in_rest_chains(), get_continuation_for_phi(), ncd_of_cand_and_phis(), record_temporary_equivalences(), remove_phi_node(), strlen_optimize_stmt(), trivially_conflicts_p(), and walk_stmt_load_store_addr_ops().
|
inlinestatic |
Return a pointer to the tree operand for argument I of PHI node GS.
Referenced by add_tree_to_fld_list().
|
inlinestatic |
Return the edge associated with argument I of phi node GS.
Referenced by analyze_evolution_in_loop(), dump_ssaname_info(), group_case_labels(), is_use_properly_guarded(), loe_visit_block(), set_var_live_on_entry(), and trivially_conflicts_p().
|
inlinestatic |
Return TRUE if argument I of phi node GS has a location record.
Referenced by dump_ssaname_info(), and trivially_conflicts_p().
|
inlinestatic |
Return the source location of gimple argument I of phi node GS.
Referenced by dump_ssaname_info(), maybe_register_def(), and trivially_conflicts_p().
|
inlinestatic |
Return the source location of the argument on edge E of phi node GS.
Referenced by create_parallel_loop(), vect_create_cond_for_alias_checks(), and verify_loop_closed_ssa().
|
inlinestatic |
Set the source location of gimple argument I of phi node GS to LOC.
Referenced by maybe_register_def().
|
inlinestatic |
Return the maximum number of arguments supported by GIMPLE_PHI GS.
|
inlinestatic |
Return the number of arguments in GIMPLE_PHI GS. This must always be exactly the number of incoming edges for the basic block holding GS.
Referenced by add_tree_to_fld_list(), analyze_evolution_in_loop(), analyze_increments(), backedge_phi_arg_p(), check_for_plus_in_loops_1(), dump_live_info(), dump_ssaname_info(), eliminate_useless_phis(), find_matching_predicate_in_rest_chains(), get_ancestor_addr_info(), get_continuation_for_phi(), maybe_register_def(), record_temporary_equivalences(), remove_phi_node(), set_var_live_on_entry(), strlen_optimize_stmt(), vn_nary_op_insert_into(), and walk_stmt_load_store_addr_ops().
|
inlinestatic |
Return the SSA name created by GIMPLE_PHI GS.
Referenced by analyze_increments(), deps_ok_for_redirect(), do_partial_partial_insertion(), dump_ssaname_info(), eliminate_useless_phis(), find_basis_for_base_expr(), find_clusters_1(), find_matching_predicate_in_rest_chains(), find_uses_to_rename_stmt(), get_param_index(), gimple_redirect_edge_and_branch(), init_parameter_lattice_values(), maybe_register_def(), process_assert_insertions(), propagate_rhs_into_lhs(), pt_solution_includes_1(), record_phi_increments(), record_temporary_equivalences(), register_edge_assert_for(), remove_phi_node(), rewrite_to_defined_overflow(), update_complex_assignment(), value_replacement(), vect_can_advance_ivs_p(), and vn_nary_op_insert_into().
|
inlinestatic |
Return a pointer to the SSA name created by GIMPLE_PHI GS.
Referenced by gimple_redirect_edge_and_branch().
|
inlinestatic |
Set PHIARG to be the argument corresponding to incoming edge INDEX for GIMPLE_PHI GS.
|
inlinestatic |
Set RESULT to be the SSA name created by GIMPLE_PHI GS.
|
inlinestatic |
Return the value of pass local flag PLF on statement STMT.
Referenced by mark_for_renaming().
|
inlinestatic |
Return the outcome of GIMPLE_PREDICT statement GS.
|
inlinestatic |
Return the predictor of GIMPLE_PREDICT statement GS.
|
inlinestatic |
Set the outcome of GIMPLE_PREDICT statement GS to OUTCOME.
|
inlinestatic |
Set the predictor of GIMPLE_PREDICT statement GS to PREDICT.
|
inlinestatic |
Return true if statement STMT may access memory.
Referenced by add_dependency(), and find_loop_niter().
| void gimple_regimplify_operands | ( | gimple | , |
| gimple_stmt_iterator * | |||
| ) |
|
inlinestatic |
Return the region number for GIMPLE_RESX GS.
Referenced by dump_gimple_eh_must_not_throw().
|
inlinestatic |
Set REGION to be the region number for GIMPLE_RESX GS.
|
inlinestatic |
Return the return bounds for GIMPLE_RETURN GS.
|
inlinestatic |
Return the return value for GIMPLE_RETURN GS.
Referenced by disqualify_ops_if_throwing_stmt(), gimple_purge_dead_eh_edges(), and tree_nrv().
|
inlinestatic |
Return a pointer to the return value for GIMPLE_RETURN GS.
|
inlinestatic |
Set RETVAL to be the return bounds for GIMPLE_RETURN GS.
|
inlinestatic |
Set RETVAL to be the return value for GIMPLE_RETURN GS.
Referenced by gimple_build_with_ops_stat().
| void gimple_seq_add_seq | ( | gimple_seq * | , |
| gimple_seq | |||
| ) |
| void gimple_seq_add_stmt | ( | gimple_seq * | , |
| gimple | |||
| ) |
| void gimple_seq_add_stmt_without_update | ( | gimple_seq * | , |
| gimple | |||
| ) |
Link gimple statement GS to the end of the sequence *SEQ_P. If *SEQ_P is NULL, a new sequence is allocated. This function is similar to gimple_seq_add_stmt, but does not scan the operands. During gimplification, we need to manipulate statement sequences before the def/use vectors have been constructed.
| gimple_seq gimple_seq_alloc | ( | void | ) |
|
inlinestatic |
Allocate a new sequence and initialize its first element with STMT.
| gimple_seq gimple_seq_copy | ( | gimple_seq | ) |
|
inlinestatic |
Return true if GIMPLE sequence S is empty.
Referenced by dump_gimple_omp_block(), dump_gimple_omp_teams(), fold_gimple_cond(), gimple_bind_expr_stack(), gimple_build_predict(), gimplify_expr(), gsi_replace(), and lower_emutls_phi_arg().
|
inlinestatic |
Return the first node in GIMPLE sequence S.
Referenced by gsi_insert_on_edge_immediate().
|
inlinestatic |
Return the first statement in GIMPLE sequence S.
Referenced by dump_gimple_omp_parallel(), finalize_nesting_tree_1(), find_goto_replacement(), move_sese_region_to_fn(), and remap_vla_decls().
| void gimple_seq_free | ( | gimple_seq | ) |
|
inlinestatic |
Return the last node in GIMPLE sequence S.
Referenced by gsi_set_stmt().
|
inlinestatic |
Return the last statement in GIMPLE sequence S.
Referenced by move_sese_region_to_fn().
|
inlinestatic |
Set the first node in GIMPLE sequence *PS to FIRST.
Referenced by gsi_set_stmt(), and gsi_split_seq_after().
|
inlinestatic |
Set the last node in GIMPLE sequence *PS to LAST.
Referenced by gsi_insert_seq_nodes_after(), gsi_set_stmt(), and gsi_split_seq_after().
|
inlinestatic |
Set the location of all statements in SEQ to LOC.
|
inlinestatic |
Determine whether SEQ is a singleton.
Referenced by find_goto_replacement().
| void gimple_set_bb | ( | gimple | , |
| basic_block | |||
| ) |
|
inlinestatic |
Set BLOCK to be the lexical scope block holding statement G.
Referenced by lower_gimple_return(), lower_omp_directive(), make_blocks(), and valid_gimple_call_p().
| void gimple_set_body | ( | tree | , |
| gimple_seq | |||
| ) |
|
inlinestatic |
Set the HAS_VOLATILE_OPS flag to VOLATILEP.
Referenced by get_expr_operands(), and mark_address_taken().
|
inlinestatic |
Set location information for statement G.
Referenced by attempt_builtin_powi(), generate_subtree_copies(), gimple_expand_builtin_powi(), gimplify_expr(), gsi_split_seq_before(), honor_protect_cleanup_actions(), instrument_derefs(), instrument_memory_accesses(), lower_gimple_return(), make_blocks(), simplify_bitwise_binary_boolean(), sra_modify_expr(), trivially_conflicts_p(), and valid_gimple_call_p().
|
inlinestatic |
Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has a MODIFIED field.
Referenced by gsi_split_seq_before().
|
inlinestatic |
Set the no_warning flag of STMT to NO_WARNING.
|
inlinestatic |
Set the number of operands for statement GS.
|
inlinestatic |
Set operand I of statement GS to OP.
Note. It may be tempting to assert that OP matches is_gimple_operand, but that would be wrong. Different tuples accept slightly different sets of tree operands. Each caller should perform its own validation.
Referenced by gimple_call_reset_alias_info().
|
inlinestatic |
Set pass local flag PLF on statement STMT to VAL_P.
Referenced by inhibit_phi_insertion(), and marked_for_renaming().
|
inlinestatic |
Set the UID of statement.
Referenced by create_rdg_cd_edges(), gimple_redirect_edge_and_branch(), is_phi_for_stmt(), renumber_gimple_stmt_uids(), renumber_gimple_stmt_uids_in_blocks(), stmts_from_loop(), swap_ops_for_binary_stmt(), and vect_make_slp_decision().
|
inlinestatic |
Set USE to be the set of USE operands for statement G.
|
inlinestatic |
Set the single VDEF operand of the statement G.
Referenced by valid_gimple_call_p(), and vect_get_vec_defs_for_stmt_copy().
|
inlinestatic |
Set the visited status on statement STMT to VISITED_P.
Referenced by acceptable_pow_call(), attempt_builtin_powi(), is_phi_for_stmt(), and swap_ops_for_binary_stmt().
|
inlinestatic |
Set the single VUSE operand of the statement G.
Referenced by valid_gimple_call_p(), vect_create_cond_for_alias_checks(), and vect_get_vec_defs_for_stmt_copy().
|
inlinestatic |
Return which GSS code is used by GS.
|
inlinestatic |
Get the number of the next statement uid to be allocated.
Referenced by input_ssa_names().
|
inlinestatic |
Return true if GS performs a store to its lhs.
Referenced by instrument_gimple().
|
inlinestatic |
Return the default label for a switch statement.
|
inlinestatic |
Return the index variable used by the switch statement GS.
Referenced by associate_equivalences_with_edges(), and optimize_stmt().
|
inlinestatic |
Return a pointer to the index variable for the switch statement GS.
|
inlinestatic |
Return the label numbered INDEX. The default label is 0, followed by any labels in a switch statement.
Referenced by associate_equivalences_with_edges(), compare_names(), create_temp_arrays(), get_vr_for_comparison(), and maybe_record_in_goto_queue().
|
inlinestatic |
Return the number of labels associated with the switch statement GS.
Referenced by associate_equivalences_with_edges(), compare_names(), create_temp_arrays(), and get_vr_for_comparison().
|
inlinestatic |
Set the default label for a switch statement.
Referenced by gimple_build_try().
|
inlinestatic |
Set INDEX to be the index variable for switch statement GS.
Referenced by gimple_build_try(), and simplify_gimple_switch_label_vec().
|
inlinestatic |
Set the label number INDEX to LABEL. 0 is always the default label.
|
inlinestatic |
Set NLABELS to be the number of labels for the switch statement GS.
|
inlinestatic |
Return the body for the GIMPLE_TRANSACTION statement GS.
|
inlinestatic |
Return a pointer to the body for the GIMPLE_TRANSACTION statement GS.
|
inlinestatic |
Return the label associated with a GIMPLE_TRANSACTION.
Referenced by dump_gimple_omp_return().
|
inlinestatic |
|
inlinestatic |
Set BODY to be the body for the GIMPLE_TRANSACTION statement GS.
Referenced by gimple_build_omp_single().
|
inlinestatic |
Set the label associated with a GIMPLE_TRANSACTION.
Referenced by examine_assign_tm(), and gimple_build_omp_single().
|
inlinestatic |
Set the subcode associated with a GIMPLE_TRANSACTION.
|
inlinestatic |
Return the subcode associated with a GIMPLE_TRANSACTION.
Referenced by get_tm_region_blocks().
|
inlinestatic |
Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag.
|
inlinestatic |
Return the sequence of statements used as the cleanup body for GIMPLE_TRY GS.
Referenced by gimple_purge_all_dead_abnormal_call_edges(), and honor_protect_cleanup_actions().
|
inlinestatic |
Return a pointer to the sequence of statements used as the cleanup body for GIMPLE_TRY GS.
Referenced by replace_goto_queue_cond_clause().
|
inlinestatic |
Return the sequence of statements used as the body for GIMPLE_TRY GS.
Referenced by gimple_purge_all_dead_abnormal_call_edges(), and honor_protect_cleanup_actions().
|
inlinestatic |
Return a pointer to the sequence of statements used as the body for GIMPLE_TRY GS.
Referenced by replace_goto_queue_cond_clause().
|
inlinestatic |
GIMPLE_TRY accessors. Return the kind of try block represented by GIMPLE_TRY GS. This is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.
|
inlinestatic |
Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag.
Referenced by gimplify_expr().
|
inlinestatic |
Set CLEANUP to be the sequence of statements to use as the cleanup body for GIMPLE_TRY GS.
Referenced by gimple_build_eh_filter().
|
inlinestatic |
Set EVAL to be the sequence of statements to use as the body for GIMPLE_TRY GS.
Referenced by gimple_build_eh_filter().
|
inlinestatic |
Set the kind of try block represented by GIMPLE_TRY GS.
|
inlinestatic |
Return the UID of statement.
Referenced by dot_rdg(), gimple_redirect_edge_and_branch(), is_phi_for_stmt(), remove_ssa_form(), swap_ops_for_binary_stmt(), and zero_one_operation().
|
staticread |
Return the set of USE operands for statement G.
Referenced by op_iter_next_tree().
|
inlinestatic |
Return the single VDEF operand of the statement G.
Referenced by delete_worklist(), gate_lower_resx(), get_rank(), insert_gimplified_predicates(), op_iter_next_use(), phi_translate(), valid_gimple_call_p(), vect_get_vec_defs_for_stmt_copy(), and warn_uninitialized_vars().
|
inlinestatic |
Return the single VDEF operand of the statement G.
Referenced by num_imm_uses().
|
inlinestatic |
Return the visited status for statement STMT.
|
inlinestatic |
Return the single VUSE operand of the statement G.
Referenced by build_rdg_partition_for_vertex(), constant_pointer_difference(), expr_elt_hasher::equal(), find_equal_ptrs(), get_continuation_for_phi(), insert_aux(), load_from_unmodified_param(), op_iter_next_tree(), phi_translate(), stmt_kills_ref_p_1(), strlen_optimize_stmt(), valid_gimple_call_p(), vect_get_vec_defs_for_stmt_copy(), and warn_uninitialized_vars().
|
inlinestatic |
Return the single VUSE operand of the statement G.
|
inlinestatic |
Return the cleanup sequence for cleanup statement GS.
|
inlinestatic |
Return the CLEANUP_EH_ONLY flag for a WCE tuple.
|
inlinestatic |
Return a pointer to the cleanup sequence for cleanup statement GS.
|
inlinestatic |
Set CLEANUP to be the cleanup sequence for GS.
Referenced by gimple_build_eh_must_not_throw().
|
inlinestatic |
Set the CLEANUP_EH_ONLY flag for a WCE tuple.
| void gimplify_and_add | ( | tree | , |
| gimple_seq * | |||
| ) |
| gimple gimplify_assign | ( | tree | , |
| tree | , | ||
| gimple_seq * | |||
| ) |
| enum gimplify_status gimplify_expr | ( | tree * | expr_p, |
| gimple_seq * | pre_p, | ||
| gimple_seq * | post_p, | ||
| bool(*)(tree) | gimple_test_f, | ||
| fallback_t | fallback | ||
| ) |
Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the expression produces a value to be used as an operand inside a GIMPLE statement, the value will be stored back in *EXPR_P. This value will be a tree of class tcc_declaration, tcc_constant, tcc_reference or an SSA_NAME. The corresponding sequence of GIMPLE statements is emitted in PRE_P and POST_P.
Additionally, this process may overwrite parts of the input expression during gimplification. Ideally, it should be possible to do non-destructive gimplification.
EXPR_P points to the GENERIC expression to convert to GIMPLE. If the expression needs to evaluate to a value to be used as an operand in a GIMPLE statement, this value will be stored in *EXPR_P on exit. This happens when the caller specifies one of fb_lvalue or fb_rvalue fallback flags.
PRE_P will contain the sequence of GIMPLE statements corresponding to the evaluation of EXPR and all the side-effects that must be executed before the main expression. On exit, the last statement of PRE_P is the core statement being gimplified. For instance, when gimplifying 'if (++a)' the last statement in PRE_P will be 'if (t.1)' where t.1 is the result of pre-incrementing 'a'.
POST_P will contain the sequence of GIMPLE statements corresponding to the evaluation of all the side-effects that must be executed after the main expression. If this is NULL, the post side-effects are stored at the end of PRE_P.
The reason why the output is split in two is to handle post side-effects explicitly. In some cases, an expression may have inner and outer post side-effects which need to be emitted in an order different from the one given by the recursive traversal. For instance, for the expression (p–)++ the post side-effects of '–' must actually occur *after the post side-effects of '++'. However, gimplification will first visit the inner expression, so if a separate POST sequence was not used, the resulting sequence would be:
1 t.1 = *p 2 p = p - 1 3 t.2 = t.1 + 1 4 *p = t.2
However, the post-decrement operation in line #2 must not be evaluated until after the store to *p at line #4, so the correct sequence should be:
1 t.1 = *p 2 t.2 = t.1 + 1 3 *p = t.2 4 p = p - 1
So, by specifying a separate post queue, it is possible to emit the post side-effects in the correct order. If POST_P is NULL, an internal queue will be used. Before returning to the caller, the sequence POST_P is appended to the main output sequence PRE_P.
GIMPLE_TEST_F points to a function that takes a tree T and returns nonzero if T is in the GIMPLE form requested by the caller. The GIMPLE predicates are in gimple.c.
FALLBACK tells the function what sort of a temporary we want if gimplification cannot produce an expression that complies with GIMPLE_TEST_F.
fb_none means that no temporary should be generated fb_rvalue means that an rvalue is OK to generate fb_lvalue means that an lvalue is OK to generate fb_either means that either is OK, but an lvalue is preferable. fb_mayfail means that gimplification may fail (in which case GS_ERROR will be returned)
The return value is either GS_ERROR or GS_ALL_DONE, since this function iterates until EXPR is completely gimplified or an error occurs.
If we are gimplifying a top-level statement, PRE_P must be valid.
Consistency checks.
We should have recognized the GIMPLE_TEST_F predicate to
know what kind of fallback to use in case a temporary is
needed to hold the value or address of *EXPR_P. We used to check the predicate here and return immediately if it succeeds. This is wrong; the design is for gimplification to be idempotent, and for the predicates to only test for valid forms, not whether they are fully simplified.
Remember the last statements added to PRE_P and POST_P. Every new statement added by the gimplification helpers needs to be annotated with location information. To centralize the responsibility, we remember the last statement that had been added to both queues before gimplifying *EXPR_P. If gimplification produces new statements in PRE_P and POST_P, those statements will be annotated with the same location information as *EXPR_P.
Loop over the specific gimplifiers until the toplevel node remains the same.
Strip away as many useless type conversions as possible
at the toplevel. Remember the expr.
Die, die, die, my darling.
Do any language-specific gimplification.
Make sure that all the cases set 'ret' appropriately.
First deal with the special cases.
C99 code may assign to an array in a structure value of a
conditional expression, and this has undefined behavior
only on execution, so create a temporary if an lvalue is
required. If errors are seen, then just process it as a CALL_EXPR.
C99 code may assign to an array in a structure returned
from a function, and this has undefined behavior only on
execution, so create a temporary if an lvalue is
required. Preserve the original type of the expression and the
source location of the outer expression. The parsers are careful to generate TRUTH_NOT_EXPR
only with operands that are always zero or one.
We do not fold here but handle the only interesting case
manually, as fold may re-introduce the TRUTH_NOT_EXPR. Just strip a conversion to void (or in void context) and
try again. FALLTHRU
unary_expr: ... | '(' cast ')' val | ... We arrive here through the various re-gimplifcation paths.
First try re-folding the whole thing.
Avoid re-gimplifying the address operand if it is already
in suitable form. Re-gimplifying would mark the address
operand addressable. Always gimplify when not in SSA form
as we still may have to gimplify decls with value-exprs. Constants need not be gimplified.
If we require an lvalue, such as for ADDR_EXPR, retain the
CONST_DECL node. Otherwise the decl is replaceable by its
value. ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either.
If the target is not LABEL, then it is a computed jump
and the target needs to be gimplified. Don't reduce this in place; let gimplify_init_constructor work its
magic. Buf if we're just elaborating this for side effects, just
gimplify any element that has side-effects. C99 code may assign to an array in a constructed
structure or union, and this has undefined behavior only
on execution, so create a temporary if an lvalue is
required. The following are special cases that are not handled by the
original GIMPLE grammar. SAVE_EXPR nodes are converted into a GIMPLE identifier and
eliminated. TMR_STEP and TMR_OFFSET are always integer constants.
This should have been stripped above.
Calls to destructors are generated automatically in FINALLY/CATCH
block. They should have location as UNKNOWN_LOCATION. However,
gimplify_call_expr will reset these call stmts to input_location
if it finds stmt's location is unknown. To prevent resetting for
destructors, we set the input_location to unknown.
Note that this only affects the destructor calls in FINALLY/CATCH
block, and will automatically reset to its original value by the
end of gimplify_expr. Don't create bogus GIMPLE_TRY with empty cleanup.
We get here when taking the address of a label. We mark
the label as "forced"; meaning it can never be removed and
it is a potential target for any computed goto. When within an OpenMP context, notice uses of variables.
Allow callbacks into the gimplifier during optimization.
Boolified binary truth expressions are semantically equivalent
to bitwise binary expressions. Canonicalize them to the
bitwise variant. Now make sure that operands have compatible type to
expression's new_type. Continue classified as tcc_binary.
Classified as tcc_expression.
Convert &X + CST to invariant &MEM[&X, CST]. Do this
after gimplifying operands - this is similar to how
it would be folding all gimplified stmts on creation
to have them canonicalized, which is what we eventually
should do anyway. Handle comparison of objects of non scalar mode aggregates
with a call to memcmp. It would be nice to only have to do
this for variable-sized objects, but then we'd have to allow
the same nest of reference nodes we allow for MODIFY_EXPR and
that's too complex.
Compare scalar mode aggregates as scalar mode values. Using
memcmp for them would be very inefficient at best, and is
plain wrong if bitfields are involved. Vector comparisons need no boolification.
If *EXPR_P does not need to be special-cased, handle it
according to its class. If we encountered an error_mark somewhere nested inside, either stub out the statement or propagate the error back out.
This was only valid as a return value from the langhook, which we handled. Make sure it doesn't escape from any other context.
We aren't looking for a value, and we don't have a valid
statement. If it doesn't have side-effects, throw it away. This is probably a _REF that contains something nested that
has side effects. Recurse through the operands to find it. Anything else with side-effects must be converted to
a valid statement before we get here. Historically, the compiler has treated a bare reference
to a non-BLKmode volatile lvalue as forcing a load. Normally, we do not want to create a temporary for a
TREE_ADDRESSABLE type because such a type should not be
copied by bitwise-assignment. However, we make an
exception here, as all we are doing here is ensuring that
we read the bytes that make up the type. We use
create_tmp_var_raw because create_tmp_var will abort when
given a TREE_ADDRESSABLE type. We can't do anything useful with a volatile reference to
an incomplete type, so just throw it away. Likewise for
a BLKmode type, since any implicit inner load should
already have been turned into an explicit one by the
gimplification process. If we are gimplifying at the statement level, we're done. Tack everything together and return.
Since *EXPR_P has been converted into a GIMPLE tuple, clear
it out for GC to reclaim it. The result of gimplifying *EXPR_P is going to be the last few
statements in *PRE_P and *POST_P. Add location information
to all the statements that were added by the gimplification
helpers. Otherwise we're gimplifying a subexpression, so the resulting value is interesting. If it's a valid operand that matches GIMPLE_TEST_F, we're done. Unless we are handling some post-effects internally; if that's the case, we need to copy into a temporary before adding the post-effects to POST_P.
Otherwise, we need to create a new temporary for the gimplified expression.
We can't return an lvalue if we have an internal postqueue. The object the lvalue refers to would (probably) be modified by the postqueue; we need to copy the value out first, which means an rvalue.
An lvalue will do. Take the address of the expression, store it
in a temporary, and replace the expression with an INDIRECT_REF of
that temporary. An rvalue will do. Assign the gimplified expression into a
new temporary TMP and replace the original expression with
TMP. First, make sure that the expression has a type so that
it can be assigned into a temporary. If this is an asm statement, and the user asked for the
impossible, don't die. Fail and let gimplify_asm_expr
issue an error. Make sure the temporary matches our predicate.
References eval(), EXPR_LOCATION, gimple_build_try(), gimple_seq_add_seq(), gimple_seq_empty_p(), gimple_set_location(), GIMPLE_TRY_CATCH, GIMPLE_TRY_FINALLY, gimple_try_set_catch_is_cleanup(), gimplify_and_add(), gimplify_seq_add_stmt(), GS_ALL_DONE, input_location, LOCATION_LOCUS, NULL, TREE_CODE, TREE_OPERAND, TRY_CATCH_IS_CLEANUP, and UNKNOWN_LOCATION.
Referenced by lookup_tmp_var().
| void gimplify_function_tree | ( | tree | ) |
In gimplify.c.
| void gimplify_one_sizepos | ( | tree * | , |
| gimple_seq * | |||
| ) |
Referenced by assign_parms(), and gimplify_return_expr().
| enum gimplify_status gimplify_self_mod_expr | ( | tree * | expr_p, |
| gimple_seq * | pre_p, | ||
| gimple_seq * | post_p, | ||
| bool | want_value, | ||
| tree | arith_type | ||
| ) |
Gimplify the self modifying expression pointed to by EXPR_P (++, –, +=, -=).
PRE_P points to the list where side effects that must happen before *EXPR_P should be stored.
POST_P points to the list where side effects that must happen after *EXPR_P should be stored.
WANT_VALUE is nonzero iff we want to use the value of this expression in another expression.
ARITH_TYPE is the type the computation should be performed in.
Prefix or postfix?
Faster to treat as prefix if result is not used.
For postfix, make sure the inner expression's post side effects are executed after side effects from this expression.
Add or subtract?
Gimplify the LHS into a GIMPLE lvalue.
Extract the operands to the arithmetic operation.
For postfix operator, we evaluate the LHS to an rvalue and then use that as the result value and in the postqueue operation.
For POINTERs increment, use POINTER_PLUS_EXPR.
Referenced by gimplify_omp_workshare().
| bool gimplify_stmt | ( | tree * | , |
| gimple_seq * | |||
| ) |
| void gimplify_type_sizes | ( | tree | , |
| gimple_seq * | |||
| ) |
| enum gimplify_status gimplify_va_arg_expr | ( | tree * | , |
| gimple_seq * | , | ||
| gimple_seq * | |||
| ) |
|
inlinestatic |
Return a block statement iterator that points to the first non-label statement in block BB.
Referenced by create_call_for_reduction(), insert_reciprocals(), instrument_memory_accesses(), ipa_tm_diagnose_tm_safe(), mark_phi_for_rewrite(), operand_equal_for_value_replacement(), remap_ssa_name(), replace_phi_args_in(), rewrite_use_nonlinear_expr(), and unsplit_all_eh().
|
inlinestatic |
Return the basic block associated with this iterator.
Referenced by debug_var_infos_r(), gsi_for_stmt(), gsi_insert_seq_before(), and gsi_split_seq_before().
| void gsi_commit_edge_inserts | ( | void | ) |
This routine will commit all pending edge insertions, creating any new basic blocks which are necessary.
Referenced by find_switch_asserts().
| void gsi_commit_one_edge_insert | ( | edge | , |
| basic_block * | |||
| ) |
|
inlinestatic |
Return true if I is at the end of its sequence.
Referenced by add_tree_to_fld_list(), associate_equivalences_with_edges(), attempt_coalesce(), build_new_reduction(), build_one_array(), create_loads_and_stores_for_name(), create_loop_fn(), delete_omp_context(), delete_worklist(), deps_ok_for_redirect(), dest_safe_for_nrv_p(), disqualify_ops_if_throwing_stmt(), do_partial_partial_insertion(), dump_live_info(), eliminate_useless_phis(), simd_array_to_simduid::equal(), find_refs_for_sm(), find_subloop_latch_edge_by_profile(), function_attribute_inlinable_p(), get_iv(), gimple_build_predict(), gimple_make_forwarder_block(), gimple_purge_all_dead_abnormal_call_edges(), gimple_redirect_edge_and_branch(), gimple_seq_add_stmt(), gsi_for_stmt(), gsi_insert_on_edge(), gsi_move_to_bb_end(), independent_of_stmt_p(), inhibit_phi_insertion(), init_object_sizes(), init_parameter_lattice_values(), insert_gimplified_predicates(), ipa_record_stmt_references(), is_ctrl_stmt(), move_stmt_op(), new_loop_vec_info(), operand_equal_for_value_replacement(), output_location(), phi_result_unknown_predicate(), phi_translate(), process_assert_insertions_for(), pt_solution_includes_1(), record_in_finally_tree(), record_temporary_equivalences(), redirect_edge_var_map_destroy(), register_edge_assert_for_1(), remove_exit_barriers(), remove_phi_args(), renumber_gimple_stmt_uids(), renumber_gimple_stmt_uids_in_blocks(), replace_locals_op(), scev_reset(), set_var_live_on_entry(), stmt_can_make_abnormal_goto(), surely_varying_stmt_p(), tree_bb_level_predictions(), tree_nrv(), trivially_conflicts_p(), try_improve_iv_set(), unsplit_all_eh(), update_complex_assignment(), update_dep_bb(), vect_can_advance_ivs_p(), vect_create_cond_for_alias_checks(), vect_loop_kill_debug_uses(), vect_make_slp_decision(), vect_pattern_recog_1(), vect_transform_loop(), verify_expr_location_1(), verify_loop_closed_ssa(), visit_hist(), and zero_one_operation().
| gimple_stmt_iterator gsi_for_stmt | ( | gimple | ) |
| void gsi_insert_after | ( | gimple_stmt_iterator * | i, |
| gimple | stmt, | ||
| enum gsi_iterator_update | m | ||
| ) |
Insert statement STMT after the statement pointed-to by iterator I. Update STMT's basic block and scan it for new operands. M specifies how to update iterator I after insertion (see enum gsi_iterator_update).
Referenced by create_iv(), create_phi_for_local_result(), estimate_num_insns_fn(), examine_assign_tm(), expand_transaction(), factor_computed_gotos(), find_goto_replacement(), generate_subtree_copies(), gimple_redirect_edge_and_branch(), instrument_builtin_call(), make_blocks(), remove_dead_stmt(), split_critical_edges(), split_function(), sra_modify_expr(), thunk_adjust(), tm_log_emit(), tm_mangle(), trivially_conflicts_p(), and update_dominators_in_loop().
| void gsi_insert_after_without_update | ( | gimple_stmt_iterator * | i, |
| gimple | stmt, | ||
| enum gsi_iterator_update | m | ||
| ) |
Insert statement STMT after the statement pointed-to by iterator I. M specifies how to update iterator I after insertion (see enum gsi_iterator_update).
This function does not scan for new operands. It is provided for the use of the gimplifier, which manipulates statements for which def/use information has not yet been constructed. Most callers should use gsi_insert_after.
Referenced by gsi_insert_before_without_update().
| void gsi_insert_before | ( | gimple_stmt_iterator * | i, |
| gimple | stmt, | ||
| enum gsi_iterator_update | m | ||
| ) |
Insert statement STMT before the statement pointed-to by iterator I. Update STMT's basic block and scan it for new operands. M specifies how to update iterator I after insertion (see enum gsi_iterator_update).
Referenced by attempt_builtin_powi(), build_one_array(), build_tm_store(), create_call_for_reduction(), create_iv(), expand_omp_atomic_load(), generate_subtree_copies(), gimple_expand_builtin_powi(), gimple_gen_pow2_profiler(), insert_reciprocals(), instrument_builtin_call(), instrument_memory_accesses(), ipa_modify_call_arguments(), ipa_tm_diagnose_tm_safe(), is_phi_for_stmt(), lower_gimple_return(), mark_phi_for_rewrite(), remap_ssa_name(), replace_phi_args_in(), rewrite_use_nonlinear_expr(), shrink_wrap_one_built_in_call(), simplify_bitwise_binary_boolean(), swap_ops_for_binary_stmt(), trivially_conflicts_p(), and vect_permute_store_chain().
| void gsi_insert_before_without_update | ( | gimple_stmt_iterator * | i, |
| gimple | stmt, | ||
| enum gsi_iterator_update | m | ||
| ) |
Insert statement STMT before the statement pointed-to by iterator I. M specifies how to update iterator I after insertion (see enum gsi_iterator_update).
This function does not scan for new operands. It is provided for the use of the gimplifier, which manipulates statements for which def/use information has not yet been constructed. Most callers should use gsi_insert_before.
References gsi_insert_after_without_update(), and update_modified_stmt().
Referenced by gsi_replace_with_seq().
| basic_block gsi_insert_on_edge_immediate | ( | edge | , |
| gimple | |||
| ) |
| void gsi_insert_seq_after | ( | gimple_stmt_iterator * | i, |
| gimple_seq | seq, | ||
| enum gsi_iterator_update | mode | ||
| ) |
Links sequence SEQ after the statement pointed-to by iterator I. MODE is as in gsi_insert_after. Scan the statements in SEQ for new operands.
Referenced by expand_complex_conjugate(), extract_component(), find_goto_replacement(), and gsi_insert_on_edge_immediate().
| void gsi_insert_seq_after_without_update | ( | gimple_stmt_iterator * | i, |
| gimple_seq | seq, | ||
| enum gsi_iterator_update | mode | ||
| ) |
Links sequence SEQ after the statement pointed-to by iterator I. MODE is as in gsi_insert_after.
This function does not scan for new operands. It is provided for the use of the gimplifier, which manipulates statements for which def/use information has not yet been constructed. Most callers should use gsi_insert_seq_after.
Don't allow inserting a sequence into itself.
Empty sequences need no work.
| void gsi_insert_seq_before | ( | gimple_stmt_iterator * | i, |
| gimple_seq | seq, | ||
| enum gsi_iterator_update | mode | ||
| ) |
Inserts the sequence of statements SEQ before the statement pointed by iterator I. MODE indicates what to do with the iterator after insertion (see enum gsi_iterator_update). Scan the statements in SEQ for new operands.
References gcc_assert, gsi_bb(), NULL, gimple_statement_base::prev, gimple_stmt_iterator_d::ptr, and update_bb_for_stmts().
Referenced by gsi_insert_on_edge_immediate(), gsi_replace(), and replace_goto_queue_cond_clause().
| void gsi_insert_seq_before_without_update | ( | gimple_stmt_iterator * | i, |
| gimple_seq | seq, | ||
| enum gsi_iterator_update | mode | ||
| ) |
Inserts the sequence of statements SEQ before the statement pointed by iterator I. MODE indicates what to do with the iterator after insertion (see enum gsi_iterator_update).
This function does not scan for new operands. It is provided for the use of the gimplifier, which manipulates statements for which def/use information has not yet been constructed. Most callers should use gsi_insert_seq_before.
Don't allow inserting a sequence into itself.
Empty sequences need no work.
| void gsi_insert_seq_on_edge | ( | edge | , |
| gimple_seq | |||
| ) |
| basic_block gsi_insert_seq_on_edge_immediate | ( | edge | , |
| gimple_seq | |||
| ) |
|
inlinestatic |
Return a new iterator initially pointing to GIMPLE_SEQ's last statement.
|
inlinestatic |
Return a new iterator pointing to the last statement in basic block BB.
Referenced by associate_equivalences_with_edges(), delete_worklist(), estimate_num_insns_fn(), expand_omp_atomic_load(), expand_omp_sections(), expand_transaction(), gsi_for_stmt(), instrument_derefs(), ip_end_pos(), ip_normal_pos(), make_pass_build_cfg(), register_edge_assert_for_1(), simplify_cond_using_ranges(), split_critical_edges(), trivially_conflicts_p(), update_dominators_in_loop(), and vect_can_advance_ivs_p().
|
inlinestatic |
Return a new iterator pointing to the last non-debug statement in basic block BB.
Referenced by output_location(), and try_improve_iv_set().
| void gsi_move_after | ( | gimple_stmt_iterator * | , |
| gimple_stmt_iterator * | |||
| ) |
| void gsi_move_before | ( | gimple_stmt_iterator * | , |
| gimple_stmt_iterator * | |||
| ) |
| void gsi_move_to_bb_end | ( | gimple_stmt_iterator * | , |
| basic_block | |||
| ) |
|
inlinestatic |
Advance the iterator to the next gimple statement.
Referenced by add_tree_to_fld_list(), arith_code_with_undefined_signed_overflow(), attempt_coalesce(), build_new_reduction(), build_one_array(), create_loads_and_stores_for_name(), create_loop_fn(), delete_omp_context(), deps_ok_for_redirect(), dest_safe_for_nrv_p(), disqualify_ops_if_throwing_stmt(), do_partial_partial_insertion(), dump_live_info(), eliminate_useless_phis(), simd_array_to_simduid::equal(), expression_expensive_p(), find_refs_for_sm(), find_subloop_latch_edge_by_profile(), function_attribute_inlinable_p(), get_iv(), gimple_build_predict(), gimple_make_forwarder_block(), gimple_purge_all_dead_abnormal_call_edges(), gimple_redirect_edge_and_branch(), gimple_seq_add_seq(), gsi_insert_on_edge(), handle_char_store(), handle_pointer_plus(), independent_of_stmt_p(), inhibit_phi_insertion(), init_object_sizes(), init_parameter_lattice_values(), insert_gimplified_predicates(), ipa_record_stmt_references(), is_ctrl_stmt(), lower_omp_directive(), move_stmt_op(), new_loop_vec_info(), phi_result_unknown_predicate(), phi_translate(), process_assert_insertions_for(), pt_solution_includes_1(), record_in_finally_tree(), record_temporary_equivalences(), redirect_edge_var_map_destroy(), remove_exit_barriers(), renumber_gimple_stmt_uids(), renumber_gimple_stmt_uids_in_blocks(), replace_locals_op(), scev_finalize(), scev_reset(), set_var_live_on_entry(), stmt_can_make_abnormal_goto(), surely_varying_stmt_p(), transform_to_exit_first_loop(), tree_bb_level_predictions(), tree_nrv(), update_complex_assignment(), vect_can_advance_ivs_p(), vect_create_cond_for_alias_checks(), vect_loop_kill_debug_uses(), vect_make_slp_decision(), vect_pattern_recog_1(), vect_transform_loop(), verify_expr_location_1(), verify_loop_closed_ssa(), visit_hist(), and zero_one_operation().
|
inlinestatic |
Advance the iterator to the next non-debug gimple statement.
Referenced by same_succ_def::equal(), operand_equal_for_value_replacement(), unsplit_all_eh(), and update_dep_bb().
|
inlinestatic |
Referenced by vect_loop_kill_debug_uses().
|
inlinestatic |
Return true if I is one statement before the end of its sequence.
|
inlinestatic |
Advance the iterator to the previous gimple statement.
Referenced by register_edge_assert_for_1().
|
inlinestatic |
Advance the iterator to the next non-debug gimple statement.
Referenced by delete_worklist(), output_location(), and try_improve_iv_set().
| bool gsi_remove | ( | gimple_stmt_iterator * | , |
| bool | |||
| ) |
| void gsi_replace | ( | gimple_stmt_iterator * | , |
| gimple | , | ||
| bool | |||
| ) |
| void gsi_replace_with_seq | ( | gimple_stmt_iterator * | gsi, |
| gimple_seq | seq, | ||
| bool | update_eh_info | ||
| ) |
Replace the statement pointed-to by GSI with the sequence SEQ. If UPDATE_EH_INFO is true, the exception handling information of the original statement is moved to the last statement of the new sequence. If the old statement is an assignment, then so must be the last statement of the new sequence, and they must have the same LHS.
References gsi_insert_before_without_update(), and update_modified_stmt().
|
inlinestatic |
Return the sequence associated with this iterator.
| void gsi_set_stmt | ( | gimple_stmt_iterator * | , |
| gimple | |||
| ) |
| gimple_seq gsi_split_seq_after | ( | gimple_stmt_iterator | ) |
| void gsi_split_seq_before | ( | gimple_stmt_iterator * | , |
| gimple_seq * | |||
| ) |
|
inlinestatic |
Return a new iterator pointing to GIMPLE_SEQ's first statement.
|
inlinestatic |
Return a new iterator pointing to the first statement in basic block BB.
Referenced by add_tree_to_fld_list(), create_loads_and_stores_for_name(), create_phi_for_local_result(), dest_safe_for_nrv_p(), disqualify_ops_if_throwing_stmt(), do_partial_partial_insertion(), simd_array_to_simduid::equal(), factor_computed_gotos(), find_refs_for_sm(), gimple_make_forwarder_block(), gimple_redirect_edge_and_branch(), gsi_move_to_bb_end(), init_object_sizes(), insert_gimplified_predicates(), ipa_record_stmt_references(), is_ctrl_stmt(), move_stmt_op(), new_loop_vec_info(), phi_result_unknown_predicate(), phi_translate(), process_assert_insertions_for(), pt_solution_includes_1(), remove_exit_barriers(), renumber_gimple_stmt_uids(), renumber_gimple_stmt_uids_in_blocks(), replace_locals_op(), split_function(), stmt_can_make_abnormal_goto(), surely_varying_stmt_p(), tm_log_emit(), tree_bb_level_predictions(), tree_nrv(), vect_create_cond_for_alias_checks(), vect_make_slp_decision(), vect_pattern_recog_1(), verify_expr_location_1(), and visit_hist().
|
inlinestatic |
Return a new iterator pointing to the first non-debug non-label statement in basic block BB.
|
inlinestatic |
Return a new iterator pointing to the first non-debug statement in basic block BB.
Referenced by update_dep_bb().
| gimple_stmt_iterator gsi_start_phis | ( | basic_block | ) |
|
inlinestatic |
Return the current stmt.
Referenced by add_tree_to_fld_list(), adjust_simduid_builtins(), alloc_iv(), apply_return_prediction(), associate_equivalences_with_edges(), attempt_coalesce(), branch_prob(), build_new_reduction(), build_one_array(), combine_cond_exprs(), constant_pointer_difference(), count_insns(), create_loads_and_stores_for_name(), create_loop_fn(), create_omp_child_function(), create_parallel_loop(), delete_omp_context(), delete_worklist(), deps_ok_for_redirect(), dest_safe_for_nrv_p(), disqualify_ops_if_throwing_stmt(), do_partial_partial_insertion(), dse_optimize_stmt(), dump_live_info(), eliminate_useless_phis(), same_succ_def::equal(), examine_call_tm(), expand_omp_atomic_load(), expand_omp_sections(), final_range_test_p(), find_goto_replacement(), find_refs_for_sm(), find_subloop_latch_edge_by_profile(), find_uses_to_rename_stmt(), flush_pending_stmts(), fold_gimple_cond(), forward_propagate_addr_expr(), function_attribute_inlinable_p(), generate_subtree_copies(), get_iv(), gimple_assign_copy_p(), gimple_build_predict(), gimple_make_forwarder_block(), gimple_purge_all_dead_abnormal_call_edges(), gimple_redirect_edge_and_branch(), gimple_seq_add_seq(), gimple_value_profile_transformations(), gsi_for_stmt(), gsi_insert_on_edge(), gsi_move_to_bb_end(), gsi_replace(), gsi_split_seq_after(), gsi_split_seq_before(), independent_of_stmt_p(), inhibit_phi_insertion(), init_object_sizes(), init_parameter_lattice_values(), insert_gimplified_predicates(), instrument_builtin_call(), ipa_prop_write_all_agg_replacement(), ipa_record_stmt_references(), is_ctrl_stmt(), is_phi_for_stmt(), live_track_clear_base_vars(), lower_gimple_return(), lower_omp_directive(), lower_omp_sections(), make_pass_lower_cf(), mark_reachable_handlers(), maybe_add_implicit_barrier_cancel(), maybe_catch_exception(), move_stmt_op(), new_loop_vec_info(), note_nonlocal_vla_type(), note_simd_array_uses(), operand_equal_for_value_replacement(), phi_result_unknown_predicate(), phi_translate(), process_assert_insertions_for(), propagate_rhs_into_lhs(), pt_solution_includes_1(), record_in_finally_tree(), record_temporary_equivalences(), register_edge_assert_for(), register_edge_assert_for_1(), register_new_def(), remove_exit_barriers(), renumber_gimple_stmt_uids(), renumber_gimple_stmt_uids_in_blocks(), replace_locals_op(), replace_phi_args_in(), same_phi_args_p(), scev_finalize(), scev_reset(), set_var_live_on_entry(), simplify_bitwise_binary_1(), simplify_cond_using_ranges(), simplify_conversion_from_bitmask(), stmt_can_make_abnormal_goto(), surely_varying_stmt_p(), swap_ops_for_binary_stmt(), tree_bb_level_predictions(), tree_nrv(), trivially_conflicts_p(), try_improve_iv_set(), unsplit_all_eh(), update_complex_assignment(), update_dep_bb(), vect_analyze_stmt(), vect_can_advance_ivs_p(), vect_create_cond_for_alias_checks(), vect_get_vec_defs_for_stmt_copy(), vect_loop_kill_debug_uses(), vect_make_slp_decision(), vect_pattern_recog_1(), verify_expr_location_1(), verify_loop_closed_ssa(), visit_hist(), volatile_var_p(), warn_uninitialized_vars(), and zero_one_operation().
| enum gimple_statement_structure_enum gss_for_assign | ( | enum | tree_code | ) |
|
inlinestatic |
Return the GSS code used by a GIMPLE code.
Referenced by gimple_set_code().
|
inlinestatic |
Set the number of the next statement uid to be allocated.
Referenced by renumber_gimple_stmt_uids(), and renumber_gimple_stmt_uids_in_blocks().
| bool is_gimple_address | ( | const_tree | ) |
Returns true iff T is a GIMPLE address.
|
inlinestatic |
Return true if GS is a GIMPLE_ASSIGN.
Referenced by add_repeat_to_ops_vec(), adjust_related_strinfos(), ao_ref_base_alias_set(), build_and_add_sum(), convert_mult_to_widen(), dump_all_asserts(), find_induction_variables(), fold_stmt_inplace(), forward_propagate_addr_expr(), get_param_index(), get_rank(), gimple_call_fnspec(), infer_value_range(), is_negative_overflow_infinity(), is_true_predicate(), jump_function_from_stmt(), may_reassociate_p(), operand_equal_for_value_replacement(), phi_result_unknown_predicate(), process_assert_insertions_for(), recognize_single_bit_test(), register_edge_assert_for_1(), replace_phi_args_in(), simplify_bitwise_binary_1(), simplify_gimple_switch_label_vec(), test_for_singularity(), tm_log_emit_restores(), type_for_widest_vector_mode(), vect_build_slp_tree_1(), vect_create_cond_for_alias_checks(), vect_create_vectorized_demotion_stmts(), vect_get_vec_defs_for_stmt_copy(), vect_mark_relevant(), and vn_reference_lookup_1().
|
inlinestatic |
Return true if GS is a GIMPLE_CALL.
Referenced by add_dependency(), adjust_simduid_builtins(), constant_pointer_difference(), dest_safe_for_nrv_p(), do_partial_partial_insertion(), dump_function_to_file(), eliminate_avail(), same_succ_def::equal(), fold_gimple_cond(), get_param_index(), ipa_analyze_call_uses(), maybe_catch_exception(), note_simd_array_uses(), propagate_dereference_distances(), replace_phi_args_in(), stmt_is_power_of_op(), tree_bb_level_predictions(), vect_build_slp_tree_1(), vect_finish_stmt_generation(), vect_get_loop_based_defs(), and vect_get_vec_defs_for_stmt_copy().
| bool is_gimple_constant | ( | const_tree | ) |
Returns true iff T is a valid GIMPLE constant.
|
inlinestatic |
Return true if GS is a GIMPLE_DEBUG statement.
Referenced by all_immediate_uses_same_place(), create_loads_and_stores_for_name(), do_partial_partial_insertion(), dump_immediate_uses_for(), get_asm_expr_operands(), gimple_build_predict(), has_zero_uses(), initialize_root_vars_lm(), is_use_properly_guarded(), next_readonly_imm_use(), note_simd_array_uses(), operand_equal_for_value_replacement(), register_edge_assert_for_1(), remove_ssa_form(), reset_debug_uses(), rewrite_debug_stmt_uses(), set_rename(), stmt_can_make_abnormal_goto(), unsplit_all_eh(), vect_mark_relevant(), and warn_uninitialized_vars().
| bool is_gimple_invariant_address | ( | const_tree | ) |
Returns true iff T is a GIMPLE invariant address.
| bool is_gimple_ip_invariant | ( | const_tree | ) |
Returns true iff T is a GIMPLE restricted interprecodural invariant.
| bool is_gimple_ip_invariant_address | ( | const_tree | ) |
Returns true iff T is a GIMPLE invariant address at interprocedural level.
| bool is_gimple_min_invariant | ( | const_tree | ) |
Returns true iff T is a GIMPLE restricted function invariant.
Returns true iff T is a variable or an INDIRECT_REF (of a variable).
|
inlinestatic |
|
inlinestatic |
Return true if TYPE is a suitable type for a scalar register variable.
Referenced by build_access_from_expr_1(), component_of(), gate_intra_sra(), ipa_prop_write_all_agg_replacement(), is_gimple_reg_rhs(), lookup_tmp_var(), non_rewritable_mem_ref_base(), refs_independent_p(), reject(), remap_vla_decls(), and walk_gimple_asm().
|
inlinestatic |
Return true if GS is a GIMPLE_RESX.
|
inlinestatic |
Return true if gimplify_one_sizepos doesn't need to gimplify expr (when in TYPE_SIZE{,_UNIT} and similar type/decl size/bitsize fields).
gimplify_one_sizepos doesn't need to do anything if the value isn't there, is constant, or contains A PLACEHOLDER_EXPR. We also don't want to do anything if it's already a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier will want to replace it with a new variable, but that will cause problems if this type is from outside the function. It's OK to have that here.
| void lower_nested_functions | ( | tree | ) |
In tree-nested.c.
| void omp_firstprivatize_variable | ( | struct gimplify_omp_ctx * | , |
| tree | |||
| ) |
|
inlinestatic |
Return the PHI nodes for basic block BB, or NULL if there are no PHI nodes.
Referenced by gimple_redirect_edge_and_branch(), lower_emutls_phi_arg(), and value_replacement().
|
inlinestatic |
Return a pointer to the PHI nodes for basic block BB.
|
inlinestatic |
PHI nodes should contain only ssa_names and invariants. A test for ssa_name is definitely simpler; don't let invalid contents slip in in the meantime.
| void pop_gimplify_context | ( | gimple | ) |
Referenced by fold_gimple_cond(), and lower_omp_sections().
| void preprocess_case_label_vec_for_gimple | ( | vec< tree > | labels, |
| tree | index_type, | ||
| tree * | default_casep | ||
| ) |
Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
LABELS is a vector that contains all case labels to look at.
INDEX_TYPE is the type of the switch index expression. Case labels in LABELS are discarded if their values are not in the value range covered by INDEX_TYPE. The remaining case label values are folded to INDEX_TYPE.
If a default case exists in LABELS, it is removed from LABELS and returned in DEFAULT_CASEP. If no default case exists, but the case labels already cover the whole range of INDEX_TYPE, a default case is returned pointing to one of the existing case labels. Otherwise DEFAULT_CASEP is set to NULL_TREE.
DEFAULT_CASEP may be NULL, in which case the above comment doesn't apply and no action is taken regardless of whether a default case is found or not.
This is a non-default case label, i.e. it has a value.
See if the case label is reachable within the range of
the index type. Remove out-of-range case values. Turn
case ranges into a canonical form (high > low strictly)
and convert the case label values to the index type.
NB: The type of gimple_switch_index() may be the promoted
type, but the case labels retain the original type.
This is a case range. Discard empty ranges.
If the bounds or the range are equal, turn this
into a simple (one-value) case. If the simple case value is unreachable, ignore it.
If the entire case range is unreachable, ignore it.
If the lower bound is less than the index type's
minimum value, truncate the range bounds. If the upper bound is greater than the index type's
maximum value, truncate the range bounds. We may have folded a case range to a one-value case.
The default case must be passed separately to the
gimple_build_switch routine. But if DEFAULT_CASEP
is NULL, we do not remove the default case (it would
be completely lost). If the switch has no default label, add one, so that we jump
around the switch body. If the labels already cover the whole
range of the switch index_type, add the default label pointing
to one of the existing labels.
References build_case_label(), CASE_HIGH, CASE_LABEL, CASE_LOW, NULL_TREE, tree_int_cst_equal(), TREE_INT_CST_HIGH, TREE_INT_CST_LOW, and TYPE_MAX_VALUE.
| void push_gimplify_context | ( | struct gimplify_ctx * | ) |
Referenced by fold_gimple_cond(), and lower_omp_sections().
| void recalculate_side_effects | ( | tree | ) |
| gimple_predicate rhs_predicate_for | ( | tree | ) |
|
inlinestatic |
Sets the sequence of statements in BB to SEQ.
|
inlinestatic |
Set the number of the next statement uid to be allocated.
| bool validate_gimple_arglist | ( | const_gimple | , |
| ... | |||
| ) |
In builtins.c
| tree walk_gimple_op | ( | gimple | stmt, |
| walk_tree_fn | callback_op, | ||
| struct walk_stmt_info * | wi | ||
| ) |
Helper function of WALK_GIMPLE_STMT. Walk every tree operand in STMT. CALLBACK_OP and WI are as in WALK_GIMPLE_STMT.
CALLBACK_OP is called on each operand of STMT via walk_tree. Additional parameters to walk_tree must be stored in WI. For each operand OP, walk_tree is called as:
walk_tree (&OP, CALLBACK_OP, WI, WI->PSET)
If CALLBACK_OP returns non-NULL for an operand, the remaining operands are not scanned.
The return value is that returned by the last call to walk_tree, or NULL_TREE if no CALLBACK_OP is specified.
Walk the RHS operands. If the LHS is of a non-renamable type or
is a register variable, we may use a COMPONENT_REF on the RHS.
Walk the LHS. If the RHS is appropriate for a memory, we
may use a COMPONENT_REF on the LHS. If the RHS is of a non-renamable type or is a register variable,
we may use a COMPONENT_REF on the LHS. Tuples that do not have operands.
Referenced by count_uses_and_derefs(), and note_simd_array_uses().
| gimple walk_gimple_seq | ( | gimple_seq | seq, |
| walk_stmt_fn | callback_stmt, | ||
| walk_tree_fn | callback_op, | ||
| struct walk_stmt_info * | wi | ||
| ) |
Like walk_gimple_seq_mod, but ensure that the head of SEQ isn't changed by the callbacks.
References NULL, and walk_stmt_info::pset.
| gimple walk_gimple_seq_mod | ( | gimple_seq * | pseq, |
| walk_stmt_fn | callback_stmt, | ||
| walk_tree_fn | callback_op, | ||
| struct walk_stmt_info * | wi | ||
| ) |
Walk all the statements in the sequence *PSEQ calling walk_gimple_stmt on each one. WI is as in walk_gimple_stmt.
If walk_gimple_stmt returns non-NULL, the walk is stopped, and the value is stored in WI->CALLBACK_RESULT. Also, the statement that produced the value is returned if this statement has not been removed by a callback (wi->removed_stmt). If the statement has been removed, NULL is returned.
Otherwise, all the statements are walked and NULL returned.
If CALLBACK_STMT or CALLBACK_OP return a value, WI must exist to hold it.
References walk_stmt_info::is_lhs, and walk_stmt_info::val_only.
| tree walk_gimple_stmt | ( | gimple_stmt_iterator * | gsi, |
| walk_stmt_fn | callback_stmt, | ||
| walk_tree_fn | callback_op, | ||
| struct walk_stmt_info * | wi | ||
| ) |
Walk the current statement in GSI (optionally using traversal state stored in WI). If WI is NULL, no state is kept during traversal. The callback CALLBACK_STMT is called. If CALLBACK_STMT indicates that it has handled all the operands of the statement, its return value is returned. Otherwise, the return value from CALLBACK_STMT is discarded and its operands are scanned.
If CALLBACK_STMT is NULL or it didn't handle the operands, CALLBACK_OP is called on each operand of the statement via walk_gimple_op. If walk_gimple_op returns non-NULL for any operand, the remaining operands are not scanned. In this case, the return value from CALLBACK_OP is returned.
In any other case, NULL_TREE is returned.
Invoke the statement callback. Return if the callback handled all of STMT operands by itself.
If CALLBACK_STMT did not handle operands, it should not have
a value to return. Re-read stmt in case the callback changed it.
If CALLBACK_OP is defined, invoke it on every operand of STMT.
If STMT can have statements inside (e.g. GIMPLE_BIND), walk them.
FALL THROUGH.
Referenced by gimple_seq_add_seq().
| bool walk_stmt_load_store_addr_ops | ( | gimple | stmt, |
| void * | data, | ||
| bool(*)(gimple, tree, void *) | visit_load, | ||
| bool(*)(gimple, tree, void *) | visit_store, | ||
| bool(*)(gimple, tree, void *) | visit_addr | ||
| ) |
For the statement STMT call the callbacks VISIT_LOAD, VISIT_STORE and VISIT_ADDR if non-NULL on loads, store and address-taken operands passing the STMT, the base of the operand and DATA to it. The base will be either a decl, an indirect reference (including TARGET_MEM_REF) or the argument of an address expression. Returns the results of these callbacks or'ed.
COND_EXPR and VCOND_EXPR rhs1 argument is a comparison tree with two operands.
References gimple_phi_arg_def(), gimple_phi_num_args(), TREE_CODE, and TREE_OPERAND.
Referenced by mark_store().
| bool walk_stmt_load_store_ops | ( | gimple | stmt, |
| void * | data, | ||
| bool(*)(gimple, tree, void *) | visit_load, | ||
| bool(*)(gimple, tree, void *) | visit_store | ||
| ) |
Like walk_stmt_load_store_addr_ops but with NULL visit_addr. IPA-CP should make a faster clone for this case.
Variable Documentation
| gimple currently_expanding_gimple_stmt |
This variable holds the currently expanded gimple statement for purposes of comminucating the profile info to the builtin expanders.
| int gimple_alloc_counts[] |
Gimple stats.
Referenced by gimple_alloc_stat().
| int gimple_alloc_sizes[] |
Referenced by gimple_alloc_stat().
| const char* const gimple_code_name[] |
Referenced by dump_gimple_fmt().
| size_t const gimple_ops_offset_[] |
Offset in bytes to the location of the operand vector. Zero if there is no operand vector for this tuple structure.
| const unsigned char gimple_rhs_class_table[] |
| enum gimple_statement_structure_enum const gss_for_code_[] |
Map GIMPLE codes to GSS codes.
