Go to the source code of this file.
Data Structures | |
| struct | tm_restart_node |
| struct | gimple_df |
| struct | htab_iterator |
| struct | ptr_info_def |
| struct | immediate_use_iterator_d |
| struct | int_tree_map |
| struct | omp_region |
| struct | _edge_var_map |
| struct | affine_iv |
| struct | tree_niter_desc |
| struct | mem_address |
Typedefs | |
| typedef struct immediate_use_iterator_d | imm_use_iterator |
| typedef struct _edge_var_map | edge_var_map |
| typedef vec< edge_var_map, va_heap, vl_embed > | edge_var_map_vector |
| typedef bool(* | walk_use_def_chains_fn )(tree, gimple, void *) |
| typedef void(* | transform_callback )(struct loop *, void *) |
Enumerations | |
| enum | need_phi_state { NEED_PHI_STATE_UNKNOWN, NEED_PHI_STATE_NO, NEED_PHI_STATE_MAYBE } |
| enum | ev_direction { EV_DIR_GROWS, EV_DIR_DECREASES, EV_DIR_UNKNOWN } |
| enum | move_pos { MOVE_IMPOSSIBLE, MOVE_PRESERVE_EXECUTION, MOVE_POSSIBLE } |
Variables | |
| struct omp_region * | root_omp_region |
| bitmap | cfgcleanup_altered_bbs |
| vec< tree > | ssa_name_values |
Typedef Documentation
| typedef struct _edge_var_map edge_var_map |
| typedef vec<edge_var_map, va_heap, vl_embed> edge_var_map_vector |
A vector of var maps.
| typedef struct immediate_use_iterator_d imm_use_iterator |
Immediate use lists are used to directly access all uses for an SSA name and get pointers to the statement for each use. The structure ssa_use_operand_d consists of PREV and NEXT pointers to maintain the list. A USE pointer, which points to address where the use is located and a LOC pointer which can point to the statement where the use is located, or, in the case of the root node, it points to the SSA name itself. The list is anchored by an occurrence of ssa_operand_d *in* the ssa_name node itself (named 'imm_uses'). This node is uniquely identified by having a NULL USE pointer. and the LOC pointer pointing back to the ssa_name node itself. This node forms the base for a circular list, and initially this is the only node in the list. Fast iteration allows each use to be examined, but does not allow any modifications to the uses or stmts. Normal iteration allows insertion, deletion, and modification. the iterator manages this by inserting a marker node into the list immediately before the node currently being examined in the list. this marker node is uniquely identified by having null stmt *and* a null use pointer. When iterating to the next use, the iteration routines check to see if the node after the marker has changed. if it has, then the node following the marker is now the next one to be visited. if not, the marker node is moved past that node in the list (visualize it as bumping the marker node through the list). this continues until the marker node is moved to the original anchor position. the marker node is then removed from the list. If iteration is halted early, the marker node must be removed from the list before continuing.
| typedef void(* transform_callback)(struct loop *, void *) |
Call-back function for walk_use_def_chains(). At each reaching definition, a function with this prototype is called.
Enumeration Type Documentation
| enum ev_direction |
| enum move_pos |
| enum need_phi_state |
Function Documentation
Referenced by add_exit_phi(), add_phi_args_after_copy_edge(), add_successor_phi_arg(), canonicalize_loop_closed_ssa(), cond_if_else_store_replacement_1(), cond_store_replacement(), copy_phi_args(), copy_phis_for_bb(), create_iv(), create_parallel_loop(), create_phi_basis(), create_phi_for_local_result(), create_tailcall_accumulator(), eliminate_tail_call(), execute_sm_if_changed(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_parallel_call(), fix_phi_nodes(), flush_pending_stmts(), forward_edge_to_pdom(), get_initial_def_for_induction(), gimple_duplicate_sese_tail(), gimple_ic(), gimple_lv_adjust_loop_header_phi(), gimple_make_forwarder_block(), gimple_stringop_fixed_value(), initialize_root_vars(), initialize_root_vars_lm(), input_phi(), insert_into_preds_of_block(), insert_phi_nodes_for(), phiprop_insert_phi(), reinstall_phi_args(), remove_forwarder_block(), remove_forwarder_block_with_phi(), replace_block_by(), rewrite_add_phi_arguments(), sese_add_exit_phis_edge(), set_prologue_iterations(), slpeel_tree_peel_loop_to_edge(), slpeel_update_phi_nodes_for_guard1(), slpeel_update_phi_nodes_for_guard2(), split_function(), split_loop_exit_edge(), transform_to_exit_first_loop(), tree_optimize_tail_calls_1(), tree_transform_and_unroll_loop(), vect_create_epilog_for_reduction(), vect_loop_versioning(), vect_setup_realignment(), and vectorizable_load().
| void add_phi_args_after_copy | ( | basic_block * | region_copy, |
| unsigned | n_region, | ||
| edge | e_copy | ||
| ) |
Blocks in REGION_COPY array of length N_REGION were created by duplication of basic blocks. Add phi node arguments for edges going from these blocks. If E_COPY is not NULL, also add phi node arguments for its destination.
References add_phi_args_after_copy_bb(), and add_phi_args_after_copy_edge().
Referenced by gimple_duplicate_sese_region(), gimple_duplicate_sese_tail(), ipa_uninstrument_transaction(), slpeel_tree_duplicate_loop_to_edge_cfg(), and tail_duplicate().
| void add_phi_args_after_copy_bb | ( | basic_block | ) |
| void add_phi_node_to_bb | ( | gimple | phi, |
| basic_block | bb | ||
| ) |
Referenced by create_phi_node().
| void add_stmt_to_eh_lp | ( | gimple | , |
| int | |||
| ) |
| rtx addr_for_mem_ref | ( | struct mem_address * | addr, |
| addr_space_t | as, | ||
| bool | really_expand | ||
| ) |
Returns address for TARGET_MEM_REF with parameters given by ADDR in address space AS. If REALLY_EXPAND is false, just make fake registers instead of really expanding the operands, and perform the expansion in-place by using one of the "templates".
References mem_address::base, expand_expr(), EXPAND_NORMAL, gen_addr_rtx(), gen_raw_REG(), immed_double_int_const(), mem_address::index, integer_onep(), integer_zerop(), mem_addr_template::off_p, mem_address::offset, mem_addr_template::ref, double_int::sext(), mem_address::step, mem_addr_template::step_p, mem_address::symbol, targetm, tree_to_double_int(), vec_safe_grow_cleared(), and vec_safe_length().
Referenced by expand_expr_real_1(), and valid_mem_ref_p().
| void adjust_ptr_info_misalignment | ( | struct ptr_info_def * | pi, |
| unsigned int | increment | ||
| ) |
If pointer described by PI has known alignment, increase its known misalignment by INCREMENT modulo its current alignment.
References ptr_info_def::align, and ptr_info_def::misalign.
Referenced by copy_ref_info().
| basic_block* blocks_in_phiopt_order | ( | void | ) |
Returns the list of basic blocks in the function in an order that guarantees that if a block X has just a single predecessor Y, then Y is after X in the ordering.
References bitmap_clear(), order, sbitmap_alloc(), sbitmap_free(), single_pred(), single_pred_p(), and visited.
Referenced by tree_ssa_ifcombine(), and tree_ssa_phiopt_worker().
| bool can_unroll_loop_p | ( | struct loop * | loop, |
| unsigned | factor, | ||
| struct tree_niter_desc * | niter | ||
| ) |
Returns true if we can unroll LOOP FACTOR times. Number of iterations of the loop is returned in NITER.
References affine_iv::base, tree_niter_desc::bound, can_duplicate_loop_p(), tree_niter_desc::cmp, contains_abnormal_ssa_name_p(), tree_niter_desc::control, eni_size_weights, tree_niter_desc::may_be_zero, number_of_iterations_exit(), single_dom_exit(), affine_iv::step, and tree_num_loop_insns().
Referenced by should_unroll_loop_p(), and tree_predictive_commoning_loop().
| unsigned int canonicalize_induction_variables | ( | void | ) |
The main entry point of the pass. Adds canonical induction variables to the suitable loops.
References bitmap_empty_p(), canonicalize_loop_induction_variables(), cfun, changed, estimate_numbers_of_iterations(), free_numbers_of_iterations_estimates(), LI_FROM_INNERMOST, LOOP_CLOSED_SSA, LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS, loops_state_satisfies_p(), mark_irreducible_loops(), need_ssa_update_p(), rewrite_into_loop_closed_ssa(), scev_reset(), UL_SINGLE_ITER, and unloop_loops().
Referenced by tree_ssa_loop_ivcanon().
Referenced by gen_parallel_loop().
| void cleanup_dead_labels | ( | void | ) |
Cleanup redundant labels. This is a three-step process:
1) Find the leading label for each block.
2) Redirect all references to labels to the leading labels.
3) Cleanup all useless labels.
References cleanup_dead_labels_eh(), computed_goto_p(), free(), gimple_asm_label_op(), gimple_asm_nlabels(), gimple_cond_false_label(), gimple_cond_set_false_label(), gimple_cond_set_true_label(), gimple_cond_true_label(), gimple_goto_dest(), gimple_goto_set_dest(), gimple_label_label(), gimple_switch_label(), gimple_switch_num_labels(), gimple_transaction_label(), gimple_transaction_set_label(), gsi_end_p(), gsi_next(), gsi_remove(), gsi_start_bb(), gsi_stmt(), basic_block_def::index, label_record::label, label_for_bb, last_stmt(), main_block_label(), and label_record::used.
Referenced by build_gimple_cfg(), and execute_cleanup_cfg_post_optimizing().
| bool cleanup_tree_cfg | ( | void | ) |
Cleanup cfg and repair loop structures.
References changed, cleanup_tree_cfg_noloop(), LOOPS_NEED_FIXUP, loops_state_satisfies_p(), and repair_loop_structures().
Referenced by execute_build_cfg(), execute_cleanup_cfg_post_optimizing(), execute_expand_omp(), execute_function_todo(), expand_omp_taskreg(), graphite_finalize(), tree_profiling(), tree_ssa_dse(), and tree_unroll_loops_completely().
| void clear_special_calls | ( | void | ) |
Clear flags set by notice_special_calls. Used by dead code removal to update the flags.
References function::calls_alloca, function::calls_setjmp, and cfun.
Referenced by eliminate_unnecessary_stmts().
| bool contains_abnormal_ssa_name_p | ( | tree | ) |
| bool convert_affine_scev | ( | struct loop * | loop, |
| tree | type, | ||
| tree * | base, | ||
| tree * | step, | ||
| gimple | at_stmt, | ||
| bool | use_overflow_semantics | ||
| ) |
Converts BASE and STEP of affine scev to TYPE. LOOP is the loop whose iv the scev corresponds to. AT_STMT is the statement at that the scev is evaluated. USE_OVERFLOW_SEMANTICS is true if this function should assume that the rules for overflow of the given language apply (e.g., that signed arithmetics in C does not overflow) -- i.e., to use them to avoid unnecessary tests, but also to enforce that the result follows them. Returns true if the conversion succeeded, false otherwise.
References automatically_generated_chrec_p(), build_nonstandard_integer_type(), chrec_convert_1(), nowrap_type_p(), scev_probably_wraps_p(), and type().
Referenced by chrec_convert_1(), and idx_find_step().
Referenced by copy_ssa_name(), duplicate_ssa_name_fn(), and replace_ssa_name().
| void create_iv | ( | tree | base, |
| tree | step, | ||
| tree | var, | ||
| struct loop * | loop, | ||
| gimple_stmt_iterator * | incr_pos, | ||
| bool | after, | ||
| tree * | var_before, | ||
| tree * | var_after | ||
| ) |
Creates an induction variable with value BASE + STEP * iteration in LOOP. It is expected that neither BASE nor STEP are shared with other expressions (unless the sharing rules allow this). Use VAR as a base var_decl for it (if NULL, a new temporary will be created). The increment will occur at INCR_POS (after it if AFTER is true, before it otherwise). INCR_POS and AFTER can be computed using standard_iv_increment_position. The ssa versions of the variable before and after increment will be stored in VAR_BEFORE and VAR_AFTER (unless they are NULL).
References add_phi_arg(), create_phi_node(), force_gimple_operand(), gimple_build_assign_with_ops(), gsi_insert_after(), gsi_insert_before(), gsi_insert_seq_on_edge_immediate(), GSI_NEW_STMT, loop::header, loop_latch_edge(), loop_preheader_edge(), make_ssa_name(), make_temp_ssa_name(), mark_addressable(), may_negate_without_overflow_p(), tree_expr_nonnegative_warnv_p(), and tree_int_cst_lt().
Referenced by canonicalize_loop_ivs(), create_canonical_iv(), create_empty_loop_on_edge(), create_new_iv(), slpeel_make_loop_iterate_ntimes(), tree_transform_and_unroll_loop(), vect_create_data_ref_ptr(), and vectorizable_load().
| tree create_mem_ref | ( | gimple_stmt_iterator * | gsi, |
| tree | type, | ||
| aff_tree * | addr, | ||
| tree | alias_ptr_type, | ||
| tree | iv_cand, | ||
| tree | base_hint, | ||
| bool | speed | ||
| ) |
Creates and returns a TARGET_MEM_REF for address ADDR. If necessary computations are emitted in front of GSI. TYPE is the mode of created memory reference. IV_CAND is the selected iv candidate in ADDR, and BASE_HINT is non NULL if IV_CAND comes from a base address object.
References addr_to_parts(), mem_address::base, create_mem_ref_raw(), force_gimple_operand_gsi(), force_gimple_operand_gsi_1(), gimplify_mem_ref_parts(), GSI_SAME_STMT, mem_address::index, integer_onep(), integer_zerop(), is_gimple_mem_ref_addr(), is_gimple_val(), mem_address::offset, mem_address::step, mem_address::symbol, and useless_type_conversion_p().
Referenced by rewrite_use_address().
| tree create_new_def_for | ( | tree | , |
| gimple | , | ||
| def_operand_p | |||
| ) |
| gimple create_phi_node | ( | tree | , |
| basic_block | |||
| ) |
Referenced by add_exit_phi(), canonicalize_loop_closed_ssa(), cond_if_else_store_replacement_1(), cond_store_replacement(), copy_phis_for_bb(), create_iv(), create_phi_basis(), create_phi_for_local_result(), create_tailcall_accumulator(), expand_omp_atomic_pipeline(), expand_omp_for_static_chunk(), expand_parallel_call(), get_initial_def_for_induction(), gimple_duplicate_bb(), gimple_ic(), gimple_make_forwarder_block(), gimple_stringop_fixed_value(), initialize_root_vars(), initialize_root_vars_lm(), input_phi(), insert_into_preds_of_block(), insert_phi_nodes_for(), phiprop_insert_phi(), sese_add_exit_phis_edge(), set_prologue_iterations(), slpeel_tree_peel_loop_to_edge(), slpeel_update_phi_nodes_for_guard1(), slpeel_update_phi_nodes_for_guard2(), split_loop_exit_edge(), transform_to_exit_first_loop(), tree_optimize_tail_calls_1(), tree_transform_and_unroll_loop(), update_phi_components(), vect_create_epilog_for_reduction(), vect_loop_versioning(), vect_setup_realignment(), and vectorizable_reduction().
| void debug | ( | struct loop & | ref | ) |
| void debug | ( | struct loop * | ptr | ) |
| void debug_cfg_stats | ( | void | ) |
Dump CFG statistics on stderr. Keep extern so that it's always linked in the final executable.
References dump_cfg_stats().
| void debug_dfa_stats | ( | void | ) |
Dump DFA statistics on stderr.
References dump_dfa_stats().
| void debug_dominator_optimization_stats | ( | void | ) |
Dump SSA statistics on stderr.
References dump_dominator_optimization_stats().
| void debug_loop | ( | struct loop * | , |
| int | |||
| ) |
| void debug_loop_num | ( | unsigned | , |
| int | |||
| ) |
| void debug_loops | ( | int | ) |
| void debug_scope_block | ( | tree | , |
| int | |||
| ) |
| void debug_scope_blocks | ( | int | ) |
| void debug_value_expressions | ( | unsigned | int | ) |
In tree-ssa-pre.c
| void debug_variable | ( | tree | ) |
| void debug_verbose | ( | struct loop & | ref | ) |
| void debug_verbose | ( | struct loop * | ptr | ) |
| void delete_tree_cfg_annotations | ( | void | ) |
Remove block annotations and other data structures.
References vec_free().
Referenced by gimple_expand_cfg(), and release_function_body().
| void delete_tree_ssa | ( | void | ) |
Deallocate memory associated with SSA data structures for FNDECL.
References cfun, gimple_df::decls_to_pointers, gimple_df::default_defs, gimple_df::escaped, fini_ssa_operands(), fini_ssanames(), function::gimple_df, gimple_df::modified_noreturn_calls, pointer_map_destroy(), pt_solution_reset(), redirect_edge_var_map_destroy(), and ssa_operands_active().
Referenced by release_function_body(), and rest_of_clean_state().
| void delete_update_ssa | ( | void | ) |
Deallocate data structures used for incremental SSA updates.
References clear_ssa_name_info(), fini_ssa_renamer(), phis, release_ssa_name(), and sbitmap_free().
Referenced by copy_loop_before(), slpeel_tree_peel_loop_to_edge(), and update_ssa().
| bool do_while_loop_p | ( | struct loop * | ) |
In tree-ssa-loop-ch.c
Referenced by copy_loop_headers().
| void dot_cfg | ( | void | ) |
| void dump_cfg_stats | ( | FILE * | ) |
| void dump_dfa_stats | ( | FILE * | ) |
| void dump_dominator_optimization_stats | ( | FILE * | ) |
In tree-ssa-dom.c
Referenced by debug_dominator_optimization_stats(), and tree_ssa_dominator_optimize().
| void dump_enumerated_decls | ( | FILE * | , |
| int | |||
| ) |
| void dump_generic_bb | ( | FILE * | , |
| basic_block | , | ||
| int | , | ||
| int | |||
| ) |
In tree-pretty-print.c.
| void dump_scope_blocks | ( | FILE * | , |
| int | |||
| ) |
Referenced by debug_scope_blocks(), execute_build_cfg(), and remove_unused_locals().
| void dump_variable | ( | FILE * | , |
| tree | |||
| ) |
Referenced by duplicate_ssa_name().
| void duplicate_ssa_name_ptr_info | ( | tree | , |
| struct ptr_info_def * | |||
| ) |
| bool empty_block_p | ( | basic_block | ) |
In tree-ssa-phiopt.c
| void end_recording_case_labels | ( | void | ) |
Stop recording information mapping edges to case labels and remove any information we have recorded.
References edge_to_cases_cleanup(), group_case_labels_stmt(), last_stmt(), pointer_map_destroy(), and pointer_map_traverse().
Referenced by cleanup_tree_cfg_1(), and split_critical_edges().
| void estimate_numbers_of_iterations | ( | void | ) |
Records estimates on numbers of iterations of loops.
References estimate_numbers_of_iterations_loop(), fold_defer_overflow_warnings(), and fold_undefer_and_ignore_overflow_warnings().
Referenced by canonicalize_induction_variables(), tree_ssa_loop_bounds(), and tree_unroll_loops_completely().
| unsigned int execute_fixup_cfg | ( | void | ) |
IPA passes, compilation of earlier functions or inlining might have changed some properties, such as marked functions nothrow, pure, const or noreturn. Remove redundant edges and basic blocks, and create new ones if necessary. This pass can't be executed as stand alone pass from pass manager, because in between inlining and this fixup the verify_flow_info would fail.
References apply_scale(), builtin_decl_implicit(), cfun, cgraph_get_node(), compute_function_frequency(), count, edge_def::count, basic_block_def::count, cgraph_node::count, current_function_decl, dump_file, dump_flags, fixup_noreturn_call(), gimple_build_call(), gimple_call_flags(), gimple_call_fndecl(), function::gimple_df, gimple_dump_cfg(), gimple_in_ssa_p(), gimple_purge_dead_abnormal_call_edges(), gimple_purge_dead_eh_edges(), gsi_end_p(), gsi_insert_after(), gsi_last_bb(), GSI_NEW_STMT, gsi_next(), gsi_start_bb(), gsi_stmt(), is_ctrl_stmt(), is_gimple_call(), last_stmt(), LOOPS_NEED_FIXUP, loops_state_set(), maybe_clean_eh_stmt(), basic_block_def::succs, update_stmt(), and vec_free().
Referenced by inline_transform(), local_pure_const(), and tree_profiling().
| void execute_update_addresses_taken | ( | void | ) |
Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables.
References bitmap_bit_p(), bitmap_empty_p(), bitmap_set_bit(), cfun, function::decl, get_base_address(), gimple_asm_input_op(), gimple_asm_ninputs(), gimple_asm_noutputs(), gimple_asm_output_op(), gimple_assign_lhs(), gimple_assign_rhs1(), gimple_assign_rhs1_ptr(), gimple_assign_set_lhs(), gimple_assign_set_rhs_from_tree(), gimple_assign_single_p(), gimple_call_arg(), gimple_call_arg_ptr(), gimple_call_num_args(), gimple_debug_bind_get_value_ptr(), gimple_debug_bind_has_value_p(), gimple_debug_bind_p(), gimple_debug_bind_reset_value(), gimple_get_lhs(), gimple_ior_addresses_taken(), gimple_phi_num_args(), gimple_references_memory_p(), gsi_end_p(), gsi_for_stmt(), gsi_next(), gsi_remove(), gsi_start_bb(), gsi_start_phis(), gsi_stmt(), integer_zerop(), is_gimple_debug(), function::local_decls, LOOP_CLOSED_SSA, loops_state_satisfies_p(), maybe_optimize_var(), maybe_rewrite_mem_ref_base(), non_rewritable_lvalue_p(), non_rewritable_mem_ref_base(), number_of_loops(), release_defs(), rewrite_into_loop_closed_ssa(), timevar_pop(), timevar_push(), unlink_stmt_vdef(), update_ssa(), update_stmt(), and useless_type_conversion_p().
Referenced by execute_function_todo().
In tree-ssa-loop-ivopts.c
Referenced by evolution_function_is_invariant_rec_p(), expr_invariant_in_loop_p(), gather_memory_references_ref(), idx_find_step(), infer_loop_bounds_from_pointer_arith(), ref_at_iteration(), rewrite_use_nonlinear_expr(), stmt_invariant_in_loop_p(), vect_analyze_loop_form(), and vect_check_gather().
| void extract_true_false_edges_from_block | ( | basic_block | b, |
| edge * | true_edge, | ||
| edge * | false_edge | ||
| ) |
Given a basic block B which ends with a conditional and has precisely two successors, determine which of the edges is taken if the conditional is true and which is taken if the conditional is false. Set TRUE_EDGE and FALSE_EDGE appropriately.
References edge_def::flags.
Referenced by abs_replacement(), associate_equivalences_with_edges(), canonicalize_loop_ivs(), check_forbidden_calls(), conditional_replacement(), create_parallel_loop(), dom_opt_leave_block(), dump_implicit_edges(), expand_gimple_cond(), extract_true_false_args_from_phi(), find_taken_edge_cond_expr(), gimple_verify_flow_info(), minmax_replacement(), predicate_bbs(), record_edge_info(), tree_unswitch_loop(), and value_replacement().
Referenced by canonicalize_loop_induction_variables().
Referenced by canonicalize_loop_induction_variables().
| edge find_taken_edge | ( | basic_block | , |
| tree | |||
| ) |
| void fini_ssanames | ( | void | ) |
| gimple first_stmt | ( | basic_block | ) |
| bool fixup_noreturn_call | ( | gimple | stmt | ) |
| void flush_pending_stmts | ( | edge | ) |
| void fold_cond_expr_cond | ( | void | ) |
Fold COND_EXPR_COND of each COND_EXPR.
References fold_binary_loc(), fold_defer_overflow_warnings(), fold_undefer_overflow_warnings(), gimple_cond_code(), gimple_cond_lhs(), gimple_cond_make_false(), gimple_cond_make_true(), gimple_cond_rhs(), gimple_location(), integer_onep(), integer_zerop(), last_stmt(), and WARN_STRICT_OVERFLOW_CONDITIONAL.
Referenced by make_edges(), and tree_function_versioning().
Calls CBCK for each index in memory reference ADDR_P. There are two
kinds situations handled; in each of these cases, the memory reference
and DATA are passed to the callback:
Access to an array: ARRAY_{RANGE_}REF (base, index). In this case we also
pass the pointer to the index to the callback.
Pointer dereference: INDIRECT_REF (addr). In this case we also pass the
pointer to addr to the callback.
If the callback returns false, the whole search stops and false is returned.
Otherwise the function returns true after traversing through the whole
reference *ADDR_P.
References is_gimple_min_invariant().
Referenced by analyze_ref(), can_sm_ref_p(), close_phi_written_to_memory(), contains_abnormal_ssa_name_p(), execute_sm(), find_interesting_uses_address(), and infer_loop_bounds_from_ref().
| tree force_gimple_operand | ( | tree | , |
| gimple_seq * | , | ||
| bool | , | ||
| tree | |||
| ) |
| 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.
References gimplify_ctx::allow_rhs_cond_expr, cfun, fb_rvalue, gimple_in_ssa_p(), gimplify_and_add(), gimplify_expr(), GS_ERROR, input_location, gimplify_ctx::into_ssa, is_gimple_reg(), is_gimple_val(), make_ssa_name(), pop_gimplify_context(), and push_gimplify_context().
Referenced by add_to_predicate_list(), force_gimple_operand(), force_gimple_operand_gsi_1(), slpeel_add_loop_guard(), and vect_loop_versioning().
| 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).
References force_gimple_operand_gsi_1(), is_gimple_reg_rhs(), and is_gimple_val().
Referenced by adjust_accumulator_values(), adjust_return_value_with_ops(), build_arrays(), build_one_array(), combine_conversions(), conditional_replacement(), convert_mult_to_fma(), copy_bb(), create_call_for_reduction_1(), create_empty_if_region_on_edge(), create_empty_loop_on_edge(), create_mem_ref(), emit_case_bit_tests(), expand_omp_atomic_fetch_op(), expand_omp_atomic_load(), expand_omp_atomic_mutex(), expand_omp_atomic_pipeline(), expand_omp_atomic_store(), expand_omp_build_assign(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_for_init_vars(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_simd(), expand_omp_single(), expand_parallel_call(), expand_task_call(), expand_vector_parallel(), extract_component(), extract_omp_for_update_vars(), generate_memcpy_builtin(), generate_memset_builtin(), generate_subtree_copies(), get_string_length(), gimple_gen_average_profiler(), gimple_gen_ic_func_profiler(), gimple_gen_ic_profiler(), gimple_gen_interval_profiler(), gimple_gen_ior_profiler(), gimple_gen_one_value_profiler(), gimple_gen_pow2_profiler(), gimplify_addr(), gimplify_build1(), gimplify_build2(), gimplify_build3(), gimplify_mem_ref_parts(), handle_builtin_strcat(), handle_builtin_strcpy(), hoist_edge_and_branch_if_true(), ifcombine_ifandif(), insert_init_stmt(), ipa_modify_call_arguments(), issue_prefetch_ref(), load_assign_lhs_subreplacements(), lower_vec_perm(), negate_value(), prepare_instrumented_value(), replace_ref(), rewrite_phi_with_iv(), rewrite_use_compare(), rewrite_use_nonlinear_expr(), scev_const_prop(), set_ifsese_condition(), simplify_builtin_call(), slpeel_make_loop_iterate_ntimes(), split_function(), sra_ipa_modify_assign(), sra_modify_assign(), sra_modify_expr(), thunk_adjust(), transform_to_exit_first_loop(), update_accumulator_with_ops(), update_range_test(), vect_update_ivs_after_vectorizer(), and vectorizable_load().
| 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).
References force_gimple_operand_1(), gimple_seq_empty_p(), gsi_insert_seq_after(), and gsi_insert_seq_before().
Referenced by create_mem_ref(), find_phi_replacement_condition(), force_gimple_operand_gsi(), gimplify_mem_ref_parts(), predicate_mem_writes(), and set_prologue_iterations().
| void free_numbers_of_iterations_estimates | ( | void | ) |
Frees the information on upper bounds on numbers of iterations of loops.
References free_numbers_of_iterations_estimates_loop().
Referenced by canonicalize_induction_variables(), execute_vrp(), loop_optimizer_finalize(), tree_complete_unroll_inner(), tree_ssa_dce_loop(), tree_ssa_loop_done(), and tree_unroll_loops_completely().
| void free_numbers_of_iterations_estimates_loop | ( | struct loop * | ) |
Referenced by free_numbers_of_iterations_estimates(), gen_parallel_loop(), and remove_bb().
| void free_omp_regions | ( | void | ) |
Release the memory for the entire omp region tree.
References free_omp_region_1(), and omp_region::next.
Referenced by execute_expand_omp(), make_edges(), and omp_expand_local().
| void gather_blocks_in_sese_region | ( | basic_block | entry, |
| basic_block | exit, | ||
| vec< basic_block > * | bbs_p | ||
| ) |
Add all the blocks dominated by ENTRY to the array BBS_P. Stop adding blocks when the dominator traversal reaches EXIT. This function silently assumes that ENTRY strictly dominates EXIT.
References CDI_DOMINATORS, first_dom_son(), gather_blocks_in_sese_region(), and next_dom_son().
Referenced by eliminate_local_variables(), gather_blocks_in_sese_region(), move_sese_region_to_fn(), and separate_decls_in_region().
| tree get_addr_base_and_unit_offset | ( | tree | , |
| HOST_WIDE_INT * | |||
| ) |
| void get_address_description | ( | tree | , |
| struct mem_address * | |||
| ) |
Referenced by expand_expr_real_1(), and maybe_fold_tmr().
Referenced by rename_use_op(), slpeel_update_phi_nodes_for_guard1(), and slpeel_update_phi_nodes_for_guard2().
|
inlinestatic |
| char* get_lsm_tmp_name | ( | tree | , |
| unsigned | |||
| ) |
Referenced by execute_sm(), execute_sm_if_changed_flag_set(), and predcom_tmp_var().
| bool get_ptr_info_alignment | ( | struct ptr_info_def * | pi, |
| unsigned int * | alignp, | ||
| unsigned int * | misalignp | ||
| ) |
If the alignment of the pointer described by PI is known, return true and store the alignment and the deviation from it into *ALIGNP and *MISALIGNP respectively. Otherwise return false.
References ptr_info_def::align, and ptr_info_def::misalign.
Referenced by copy_ref_info(), dump_gimple_phi(), get_pointer_alignment_1(), and pp_gimple_stmt_1().
| tree gimple_block_label | ( | basic_block | ) |
Verify if the type of the argument and lhs of CALL_STMT matches that of the function declaration CALLEE. If ARGS_COUNT_MATCH is true, the arg count needs to be the same. If we cannot verify this or there is a mismatch, return false.
References fold_convertible_p(), gimple_call_lhs(), gimple_check_call_args(), and useless_type_conversion_p().
Referenced by cgraph_create_edge_1(), cgraph_make_edge_direct(), cgraph_redirect_edge_call_stmt_to_callee(), check_ic_target(), early_inliner(), and update_indirect_edges_after_inlining().
| void gimple_debug_bb | ( | basic_block | ) |
| basic_block gimple_debug_bb_n | ( | int | ) |
| void gimple_debug_cfg | ( | int | ) |
| void gimple_dump_bb | ( | FILE * | , |
| basic_block | , | ||
| int | , | ||
| int | |||
| ) |
| void gimple_dump_cfg | ( | FILE * | , |
| int | |||
| ) |
| bool gimple_duplicate_loop_to_header_edge | ( | struct loop * | loop, |
| edge | e, | ||
| unsigned int | ndupl, | ||
| sbitmap | wont_exit, | ||
| edge | orig, | ||
| vec< edge > * | to_remove, | ||
| int | flags | ||
| ) |
The same as cfgloopmanip.c:duplicate_loop_to_header_edge, but also updates the PHI nodes at start of the copied region. In order to achieve this, only loops whose exits all lead to the same location are handled. Notice that we do not completely update the SSA web after duplication. The caller is responsible for calling update_ssa after the loop has been duplicated.
References cfun, copy_phi_node_args(), duplicate_loop_to_header_edge(), flush_pending_stmts(), LOOP_CLOSED_SSA, LOOPS_HAVE_PREHEADERS, LOOPS_HAVE_SIMPLE_LATCHES, loops_state_satisfies_p(), need_ssa_update_p(), scev_reset(), and verify_loop_closed_ssa().
Referenced by tree_transform_and_unroll_loop(), and try_unroll_loop_completely().
| bool gimple_duplicate_sese_region | ( | edge | entry, |
| edge | exit, | ||
| basic_block * | region, | ||
| unsigned | n_region, | ||
| basic_block * | region_copy, | ||
| bool | update_dominance | ||
| ) |
Duplicates a REGION (set of N_REGION basic blocks) with just a single important exit edge EXIT. By important we mean that no SSA name defined inside region is live over the other exit edges of the region. All entry edges to the region must go to ENTRY->dest. The edge ENTRY is redirected to the duplicate of the region. Dominance and loop information is updated if UPDATE_DOMINANCE is true, but not the SSA web. If UPDATE_DOMINANCE is false then we assume that the caller will update the dominance information after calling this function. The new basic blocks are stored to REGION_COPY in the same order as they had in REGION, provided that REGION_COPY is not NULL. The function returns false if it is unable to copy the region, true otherwise.
References add_phi_args_after_copy(), can_copy_bbs_p(), CDI_DOMINATORS, copy_bbs(), edge_def::count, basic_block_def::count, edge_def::dest, dominated_by_p(), flush_pending_stmts(), free(), free_original_copy_tables(), basic_block_def::frequency, get_bb_copy(), get_bb_original(), get_dominated_by_region(), loop::header, initialize_original_copy_tables(), iterate_fix_dominators(), loop::latch, basic_block_def::loop_father, loop_outer(), redirect_edge_and_branch(), scale_bbs_frequencies_gcov_type(), scale_bbs_frequencies_int(), set_immediate_dominator(), set_loop_copy(), split_edge_bb_loc(), and edge_def::src.
Referenced by copy_loop_headers().
| bool gimple_duplicate_sese_tail | ( | edge | entry, |
| edge | exit, | ||
| basic_block * | region, | ||
| unsigned | n_region, | ||
| basic_block * | region_copy | ||
| ) |
Duplicates REGION consisting of N_REGION blocks. The new blocks
are stored to REGION_COPY in the same order in that they appear
in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
the region, EXIT an exit from it. The condition guarding EXIT
is moved to ENTRY. Returns true if duplication succeeds, false
otherwise.
For example,
some_code;
if (cond)
A;
else
B;
is transformed to
if (cond)
{
some_code;
A;
}
else
{
some_code;
B;
}
References add_phi_arg(), add_phi_args_after_copy(), bb_part_of_region_p(), can_copy_bbs_p(), CDI_DOMINATORS, cfun, copy_bbs(), duplicate_loop(), duplicate_subloops(), loop::exits, edge_def::flags, free(), free_original_copy_tables(), get_bb_copy(), get_bb_original(), get_dominated_by_region(), gimple_copy(), gimple_phi_arg_location_from_edge(), gsi_end_p(), gsi_insert_after(), gsi_last_bb(), GSI_NEW_STMT, gsi_next(), gsi_start_phis(), gsi_stmt(), loop::header, initialize_original_copy_tables(), loop::inner, iterate_fix_dominators(), last_stmt(), loop::latch, make_edge(), need_ssa_update_p(), loop::next, redirect_edge_and_branch(), rescan_loop_exit(), scale_bbs_frequencies_gcov_type(), scale_bbs_frequencies_int(), set_immediate_dominator(), set_loop_copy(), single_succ_edge(), split_edge(), split_edge_bb_loc(), stmt_ends_bb_p(), and update_ssa().
Referenced by transform_to_exit_first_loop().
Fold STMT to a constant using VALUEIZE to valueize SSA names. Returns NULL_TREE if folding to a constant is not possible, otherwise returns a constant according to is_gimple_min_invariant.
References gimple_fold_stmt_to_constant_1(), and is_gimple_min_invariant().
Referenced by vrp_visit_assignment_or_call().
| bool gimple_purge_all_dead_abnormal_call_edges | ( | const_bitmap | ) |
| bool gimple_purge_all_dead_eh_edges | ( | const_bitmap | ) |
| bool gimple_purge_dead_abnormal_call_edges | ( | basic_block | ) |
| bool gimple_purge_dead_eh_edges | ( | basic_block | ) |
| bool gimple_seq_may_fallthru | ( | gimple_seq | ) |
| bool gimple_stmt_may_fallthru | ( | gimple | ) |
| tree gimplify_build1 | ( | gimple_stmt_iterator * | gsi, |
| enum tree_code | code, | ||
| tree | type, | ||
| tree | a | ||
| ) |
Build a unary operation and gimplify it. Emit code before GSI. Return the gimple_val holding the result.
References force_gimple_operand_gsi(), gimple_location(), GSI_SAME_STMT, and gsi_stmt().
Referenced by do_negate(), do_plus_minus(), do_unop(), expand_complex_conjugate(), expand_complex_div_wide(), expand_complex_division(), expand_complex_multiplication(), expand_complex_negation(), expand_vector_divmod(), expand_vector_operations_1(), and tree_vec_extract().
Build a binary operation and gimplify it. Emit code before GSI. Return the gimple_val holding the result.
References force_gimple_operand_gsi(), gimple_location(), GSI_SAME_STMT, and gsi_stmt().
Referenced by add_rshift(), do_binop(), do_negate(), do_plus_minus(), expand_complex_addition(), expand_complex_comparison(), expand_complex_div_straight(), expand_complex_div_wide(), expand_complex_division(), expand_complex_multiplication(), and expand_vector_divmod().
| tree gimplify_build3 | ( | gimple_stmt_iterator * | gsi, |
| enum tree_code | code, | ||
| tree | type, | ||
| tree | a, | ||
| tree | b, | ||
| tree | c | ||
| ) |
Build a ternary operation and gimplify it. Emit code before GSI. Return the gimple_val holding the result.
References force_gimple_operand_gsi(), gimple_location(), GSI_SAME_STMT, and gsi_stmt().
Referenced by do_compare(), expand_vector_condition(), and tree_vec_extract().
| void graphite_transform_loops | ( | void | ) |
In graphite.c
Perform a set of linear transforms on the loops of the current function.
References apply_poly_transforms(), build_poly_scop(), build_scops(), cfun, hash_table< Descriptor, Allocator >::create(), scop::ctx, dbg_cnt(), function::decl, hash_table< Descriptor, Allocator >::dispose(), dump_file, dump_flags, free_scops(), gloog(), graphite_finalize(), graphite_initialize(), parallelized_function_p(), print_global_statistics(), print_graphite_statistics(), the_isl_ctx, and vNULL.
Referenced by graphite_transforms().
| void group_case_labels | ( | void | ) |
Look for blocks ending in a multiway branch (a GIMPLE_SWITCH), and scan the sorted vector of cases. Combine the ones jumping to the same label.
References group_case_labels_stmt(), and last_stmt().
Referenced by build_gimple_cfg(), and execute_cleanup_cfg_post_optimizing().
| void group_case_labels_stmt | ( | gimple | ) |
| void init_empty_tree_cfg | ( | void | ) |
References cfun, and init_empty_tree_cfg_for_function().
Referenced by build_gimple_cfg(), init_lowered_empty_function(), initialize_cfun(), and move_sese_region_to_fn().
| void init_empty_tree_cfg_for_function | ( | struct function * | ) |
| void init_ssanames | ( | struct function * | , |
| int | |||
| ) |
In tree-ssanames.c
Referenced by init_tree_ssa(), and input_ssa_names().
| void init_tree_ssa | ( | struct function * | ) |
| void insert_debug_temp_for_var_def | ( | gimple_stmt_iterator * | , |
| tree | |||
| ) |
Referenced by gimple_replace_lhs(), insert_debug_temps_for_defs(), and release_ssa_name().
| void insert_debug_temps_for_defs | ( | gimple_stmt_iterator * | ) |
Referenced by gsi_remove(), and remove_phi_node().
| basic_block ip_end_pos | ( | struct loop * | ) |
Referenced by add_candidate(), allow_ip_end_pos_p(), create_new_iv(), determine_iv_cost(), and standard_iv_increment_position().
| basic_block ip_normal_pos | ( | struct loop * | ) |
Referenced by add_candidate(), allow_ip_end_pos_p(), create_new_iv(), standard_iv_increment_position(), and stmt_after_ip_normal_pos().
| bool is_ctrl_altering_stmt | ( | gimple | ) |
| bool is_ctrl_stmt | ( | gimple | ) |
| basic_block label_to_block_fn | ( | struct function * | , |
| tree | |||
| ) |
| gimple last_and_only_stmt | ( | basic_block | ) |
| gimple last_stmt | ( | basic_block | ) |
| void linear_transform_loops | ( | void | ) |
In tree-loop-linear.c
| int lookup_stmt_eh_lp | ( | gimple | ) |
| int loop_depth_of_name | ( | tree | ) |
Referenced by copy_prop_visit_phi_node(), cprop_operand(), init_copy_prop(), propagate_rhs_into_lhs(), and record_equality().
Referenced by find_loop_niter_by_eval(), and predict_loops().
| bool loop_only_exit_p | ( | const struct loop * | , |
| const_edge | |||
| ) |
Referenced by number_of_iterations_exit(), and tree_ssa_iv_optimize_loop().
| void make_abnormal_goto_edges | ( | basic_block | , |
| bool | |||
| ) |
| bool make_eh_dispatch_edges | ( | gimple | ) |
| void make_eh_edges | ( | gimple | ) |
In tree-eh.c
| void mark_ptr_info_alignment_unknown | ( | struct ptr_info_def * | ) |
| void mark_virtual_operand_for_renaming | ( | tree | ) |
In tree-ssa-dce.c
Referenced by destroy_loop(), mark_virtual_phi_result_for_renaming(), and release_last_vdef().
| void mark_virtual_operands_for_renaming | ( | struct function * | ) |
| void mark_virtual_phi_result_for_renaming | ( | gimple | ) |
| bool may_be_nonaddressable_p | ( | tree | expr | ) |
Referenced by find_interesting_uses_address(), gather_memory_references_ref(), and may_be_nonaddressable_p().
Referenced by copy_prop_visit_assignment(), copy_prop_visit_phi_node(), cprop_into_successor_phis(), cprop_operand(), eliminate(), eliminate_bb(), gimple_merge_blocks(), may_propagate_copy_into_stmt(), propagate_rhs_into_lhs(), propagate_tree_value(), record_equivalences_from_phis(), replace_exp_1(), replace_phi_args_in(), replace_uses_in(), scev_const_prop(), and substitute_and_fold().
| bool may_propagate_copy_into_asm | ( | tree | ) |
Referenced by cprop_operand(), propagate_rhs_into_lhs(), and replace_uses_in().
Referenced by eliminate_redundant_computations().
| bool maybe_clean_eh_stmt | ( | gimple | ) |
| bool maybe_duplicate_eh_stmt_fn | ( | struct function * | new_fun, |
| gimple | new_stmt, | ||
| struct function * | old_fun, | ||
| gimple | old_stmt, | ||
| struct pointer_map_t * | map, | ||
| int | default_lp_nr | ||
| ) |
Given a statement OLD_STMT in OLD_FUN and a duplicate statement NEW_STMT in NEW_FUN, copy the EH table data from OLD_STMT to NEW_STMT. The MAP operand is the return value of duplicate_eh_regions.
References add_stmt_to_eh_lp_fn(), eh_landing_pad_d::index, eh_region_d::index, lookup_stmt_eh_lp_fn(), pointer_map_contains(), and stmt_could_throw_p().
Referenced by copy_bb(), and move_block_to_fn().
Referenced by maybe_fold_reference().
| void maybe_remove_unreachable_handlers | ( | void | ) |
Remove unreachable handlers if any landing pads have been removed after last ehcleanup pass (due to gimple_purge_dead_eh_edges).
References cfun, function::eh, eh_status::lp_array, eh_landing_pad_d::post_landing_pad, and remove_unreachable_handlers().
Referenced by execute_cleanup_cfg_post_optimizing().
| basic_block move_sese_region_to_fn | ( | struct function * | dest_cfun, |
| basic_block | entry_bb, | ||
| basic_block | exit_bb, | ||
| tree | orig_block | ||
| ) |
Move a single-entry, single-exit region delimited by ENTRY_BB and EXIT_BB to function DEST_CFUN. The whole region is replaced by a single basic block in the original CFG and the new basic block is returned. DEST_CFUN must not have a CFG yet. Note that the region need not be a pure SESE region. Blocks inside the region may contain calls to abort/exit. The only restriction is that ENTRY_BB should be the only entry point and it must dominate EXIT_BB. Change TREE_BLOCK of all statements in ORIG_BLOCK to the new functions outermost BLOCK, move all subblocks of ORIG_BLOCK to the new function. All local variables referenced in the region are assumed to be in the corresponding BLOCK_VARS and unexpanded variable lists associated with DEST_CFUN.
References add_bb_to_loop(), loop::aux, CDI_DOMINATORS, cfun, create_empty_bb(), function::decl, edge_def::dest, dominated_by_p(), duplicate_eh_regions(), function::eh, move_stmt_d::eh_map, ei_safe_edge(), loop::exits, find_outermost_region_in_block(), fixup_loop_arrays_after_move(), edge_def::flags, flow_loop_tree_node_add(), flow_loop_tree_node_remove(), free(), move_stmt_d::from_context, gather_blocks_in_sese_region(), get_dominated_by_region(), get_immediate_dominator(), get_loop(), loop::header, init_eh_for_function(), init_empty_tree_cfg(), init_loops_structure(), basic_block_def::loop_father, loop_outer(), loops_for_fn(), LOOPS_MAY_HAVE_MULTIPLE_LATCHES, make_edge(), memset(), move_block_to_fn(), move_stmt_d::new_block, move_stmt_d::new_label_map, new_label_mapper(), loop::num_nodes, move_stmt_d::orig_block, pointer_map_create(), pointer_map_destroy(), pop_cfun(), basic_block_def::preds, edge_def::probability, push_cfun(), move_stmt_d::remap_decls_p, remove_edge(), replace_block_vars_by_duplicates(), set_immediate_dominator(), set_loops_for_fn(), edge_def::src, loops::state, basic_block_def::succs, move_stmt_d::to_context, tree_map_hash(), and move_stmt_d::vars_map.
Referenced by expand_omp_taskreg().
Referenced by determine_invariantness_stmt().
| bool multiplier_allowed_in_address_p | ( | HOST_WIDE_INT | ratio, |
| enum machine_mode | mode, | ||
| addr_space_t | as | ||
| ) |
Returns true if multiplying by RATIO is allowed in an address. Test the validity for a memory reference accessing memory of mode MODE in address space AS.
References bitmap_bit_p(), bitmap_clear(), bitmap_set_bit(), dump_file, dump_flags, gen_int_mode(), gen_raw_REG(), HOST_WIDE_INT, memory_address_addr_space_p(), sbitmap_alloc(), and targetm.
Referenced by get_address_cost(), get_computation_cost_at(), and most_expensive_mult_to_index().
| bool name_registered_for_update_p | ( | tree | ) |
Referenced by get_maxval_strlen(), gimple_can_merge_blocks_p(), insert_debug_temp_for_var_def(), and release_ssa_name().
| bool need_ssa_update_p | ( | struct function * | ) |
|
read |
Create a new parallel region starting at STMT inside region PARENT.
References omp_region::entry, omp_region::inner, omp_region::next, omp_region::outer, root_omp_region, omp_region::type, and type().
Referenced by build_omp_regions_1(), and make_edges().
| bool nonfreeing_call_p | ( | gimple | ) |
Referenced by nt_init_block(), and transform_statements().
| void notice_special_calls | ( | gimple | ) |
| bool nowrap_type_p | ( | tree | ) |
Referenced by bound_difference_of_offsetted_base(), convert_affine_scev(), determine_value_range(), difference_cannot_overflow_p(), infer_loop_bounds_from_pointer_arith(), iv_elimination_compare_lt(), refine_bounds_using_guard(), scev_probably_wraps_p(), and strip_wrap_conserving_type_conversions().
| bool number_of_iterations_exit | ( | struct loop * | loop, |
| edge | exit, | ||
| struct tree_niter_desc * | niter, | ||
| bool | warn, | ||
| bool | every_iteration | ||
| ) |
Stores description of number of iterations of LOOP derived from EXIT (an exit edge of the LOOP) in NITER. Returns true if some useful information could be derived (and fields of NITER has meaning described in comments at struct tree_niter_desc declaration), false otherwise. If WARN is true and -Wunsafe-loop-optimizations was given, warn if the optimizer is going to use potentially unsafe assumptions. When EVERY_ITERATION is true, only tests that are known to be executed every iteration are considered (i.e. only test that alone bounds the loop).
References tree_niter_desc::assumptions, affine_iv::base, CDI_DOMINATORS, dominated_by_p(), expand_simple_operations(), edge_def::flags, fold_defer_overflow_warnings(), fold_undefer_and_ignore_overflow_warnings(), gimple_cond_code(), gimple_cond_lhs(), gimple_cond_rhs(), gimple_location(), input_location, integer_all_onesp(), integer_onep(), integer_zerop(), invert_tree_comparison(), last_stmt(), loop::latch, loop_containing_stmt(), loop_only_exit_p(), tree_niter_desc::max, tree_niter_desc::may_be_zero, tree_niter_desc::niter, number_of_iterations_cond(), simple_iv(), simplify_using_initial_conditions(), simplify_using_outer_evolutions(), single_exit(), edge_def::src, affine_iv::step, tree_to_double_int(), type(), and warning_at().
Referenced by can_unroll_loop_p(), estimate_function_body_sizes(), estimate_numbers_of_iterations_loop(), find_loop_niter(), graphite_can_represent_loop(), niter_for_exit(), number_of_latch_executions(), predict_loops(), remove_redundant_iv_tests(), and try_get_loop_niter().
| void omp_expand_local | ( | basic_block | ) |
| int op_code_prio | ( | enum | tree_code | ) |
Referenced by dump_binary_rhs(), dump_unary_rhs(), and op_prio().
| int op_prio | ( | const_tree | ) |
Referenced by dump_binary_rhs(), dump_generic_node(), dump_unary_rhs(), and op_prio().
| const char* op_symbol_code | ( | enum | tree_code | ) |
Referenced by dump_binary_rhs(), dump_chain(), dump_condition(), dump_gimple_cond(), dump_omp_clause(), eliminate_redundant_comparison(), and op_symbol().
Referenced by outermost_invariant_loop_for_expr(), and vect_enhance_data_refs_alignment().
| bool parallelize_loops | ( | void | ) |
Detect parallel loops and generate parallel code using libgomp primitives. Returns true if some loop was parallelized, false otherwise.
References loop::can_be_parallel, can_duplicate_loop_p(), cfun, changed, hash_table< Descriptor, Allocator >::create(), function::decl, hash_table< Descriptor, Allocator >::dispose(), dump_file, dump_flags, hash_table< Descriptor, Allocator >::empty(), gimple_df::escaped, estimated_stmt_executions_int(), find_loop_location(), edge_def::flags, free_stmt_vec_info_vec(), gen_parallel_loop(), function::gimple_df, function::has_nonlocal_label, loop::header, HOST_WIDE_INT, basic_block_def::index, init_stmt_vec_info_vec(), loop::inner, loop_has_blocks_with_irreducible_flag(), loop_has_vector_phi_nodes(), loop_parallel_p(), loop_preheader_edge(), max_stmt_executions_int(), loop::num, obstack, optimize_loop_nest_for_size_p(), parallelized_function_p(), pt_solution_reset(), single_dom_exit(), try_create_reduction_list(), and try_get_loop_niter().
Referenced by tree_parallelize_loops().
| bool parallelized_function_p | ( | tree | ) |
In tree-parloops.c
Referenced by graphite_transform_loops(), and parallelize_loops().
| unsigned perfect_loop_nest_depth | ( | struct loop * | ) |
|
inlinestatic |
Accessors for basic block annotations.
| void phinodes_print_statistics | ( | void | ) |
Dump some simple statistics regarding the re-use of PHI nodes.
Referenced by dump_tree_statistics().
| bool potentially_threadable_block | ( | basic_block | ) |
Referenced by dom_opt_leave_block(), and identify_jump_threads().
| void print_loops | ( | FILE * | , |
| int | |||
| ) |
| void print_loops_bb | ( | FILE * | , |
| basic_block | , | ||
| int | , | ||
| int | |||
| ) |
| void propagate_threaded_block_debug_into | ( | basic_block | , |
| basic_block | |||
| ) |
Referenced by copy_loop_headers(), and thread_across_edge().
Referenced by propagate_tree_value_into_stmt().
| void propagate_tree_value_into_stmt | ( | gimple_stmt_iterator * | , |
| tree | |||
| ) |
Referenced by eliminate_bb(), eliminate_redundant_computations(), and optimize_stmt().
| void propagate_value | ( | use_operand_p | , |
| tree | |||
| ) |
In tree-ssa-copy.c
Referenced by cprop_into_successor_phis(), cprop_operand(), propagate_rhs_into_lhs(), replace_phi_args_in(), and replace_uses_in().
| void record_vars | ( | tree | ) |
Referenced by cleanup_empty_eh_merge_phis(), and ssa_redirect_edge().
| void redirect_edge_var_map_clear | ( | edge | ) |
| void redirect_edge_var_map_destroy | ( | void | ) |
Clear the edge variable mappings.
References free_var_map_entry(), pointer_map_destroy(), and pointer_map_traverse().
Referenced by delete_tree_ssa().
Referenced by redirect_edge_succ_nodup().
| edge_var_map_vector* redirect_edge_var_map_vector | ( | edge | ) |
| void redirect_eh_dispatch_edge | ( | gimple | , |
| edge | , | ||
| basic_block | |||
| ) |
| edge redirect_eh_edge | ( | edge | , |
| basic_block | |||
| ) |
|
inlinestatic |
Referenced by thread_across_edge().
| void release_defs | ( | gimple | ) |
Referenced by adjust_last_stmt(), cond_if_else_store_replacement_1(), cond_store_replacement(), convert_mult_to_fma(), dse_optimize_stmt(), eliminate(), eliminate_tail_call(), execute_fold_all_builtins(), execute_optimize_widening_mul(), execute_update_addresses_taken(), forward_propagate_addr_expr(), generate_loops_for_partition(), gimplify_and_update_call_from_tree(), handle_char_store(), optimize_clobbers(), optimize_stmt(), propagate_op_to_single_use(), reassociate_bb(), release_defs_bitset(), remove_bb(), remove_dead_inserted_code(), remove_dead_stmt(), remove_prop_source_from_use(), remove_range_assertions(), remove_stmt(), remove_stmt_or_phi(), remove_unused_locals(), remove_visited_stmt_chain(), simplify_builtin_call(), simplify_conversion_from_bitmask(), sink_clobbers(), sra_ipa_reset_debug_stmts(), sra_modify_assign(), sra_modify_constructor_assign(), ssa_forward_propagate_and_combine(), substitute_and_fold(), tree_nrv(), update_call_from_tree(), vect_remove_stores(), vect_schedule_slp(), and vect_transform_loop().
| void release_defs_bitset | ( | bitmap | toremove | ) |
Referenced by remove_unused_ivs().
| void release_phi_node | ( | gimple | ) |
Referenced by predicate_all_scalar_phis(), remove_phi_node(), and reserve_phi_args_for_new_edge().
| void release_ssa_name | ( | tree | ) |
Referenced by delete_update_ssa(), eliminate_unnecessary_stmts(), execute_cse_sincos(), finalize_ssa_defs(), fixup_noreturn_call(), free_scc_vn(), gimplify_and_update_call_from_tree(), propagate_constants_for_unrolling(), release_defs(), remove_phi_node(), remove_unused_locals(), replace_removed_params_ssa_names(), and simplify_builtin_call().
| void release_ssa_name_after_update_ssa | ( | tree | ) |
Referenced by release_ssa_name().
| void remove_edge_and_dominated_blocks | ( | edge | ) |
| void remove_phi_args | ( | edge | ) |
Referenced by gimple_execute_on_shrinking_pred().
| void remove_phi_node | ( | gimple_stmt_iterator * | , |
| bool | |||
| ) |
Referenced by create_loads_for_reductions(), eliminate_bb(), eliminate_useless_phis(), expand_omp_for_static_chunk(), forward_edge_to_pdom(), generate_loops_for_partition(), gimple_merge_blocks(), move_block_to_fn(), move_computations_stmt(), release_defs_bitset(), remove_dead_inserted_code(), remove_dead_phis(), remove_duplicate_close_phi(), remove_gimple_phi_args(), remove_invariant_phi(), remove_phi(), remove_phi_nodes(), remove_simple_copy_phi(), remove_stmt(), remove_stmt_or_phi(), replace_ref_with(), rewrite_close_phi_out_of_ssa(), rewrite_degenerate_phi(), rewrite_phi_out_of_ssa(), rewrite_phi_with_iv(), rewrite_use_nonlinear_expr(), scev_const_prop(), split_function(), substitute_and_fold(), transform_to_exit_first_loop(), and unsplit_eh().
| void remove_phi_nodes | ( | basic_block | ) |
Referenced by copy_bb_and_scalar_dependences(), and remove_phi_nodes_and_edges_for_unreachable_block().
| bool remove_stmt_from_eh_lp | ( | gimple | ) |
| void remove_unused_locals | ( | void | ) |
In tree-ssa-live.c
Remove local variables that are not referenced in the IL.
References tree_int_map::base, cfun, clear_unused_block_pointer(), current_function_decl, dump_file, dump_flags, dump_scope_blocks(), get_base_address(), gimple_assign_lhs(), gimple_block(), gimple_clobber_p(), gimple_num_ops(), gimple_op_ptr(), gimple_phi_arg_location(), gimple_phi_result(), edge_def::goto_locus, gsi_end_p(), gsi_next(), gsi_remove(), gsi_start_bb(), gsi_start_phis(), gsi_stmt(), function::has_local_explicit_reg_vars, is_gimple_debug(), is_global_var(), is_used_p(), function::local_decls, mark_all_vars_used(), mark_scope_block_unused(), function::nonlocal_goto_save_area, release_defs(), release_ssa_name(), remove_unused_scope_block_p(), set_ssa_default_def(), ssa_default_def(), statistics_counter_event(), basic_block_def::succs, timevar_pop(), timevar_push(), unlink_stmt_vdef(), vec_safe_length(), and virtual_operand_p().
Referenced by execute_function_todo().
| void renumber_gimple_stmt_uids | ( | void | ) |
In tree-dfa.c
Renumber all of the gimple stmt uids.
References cfun, gimple_set_uid(), gsi_end_p(), gsi_next(), gsi_start_bb(), gsi_start_phis(), gsi_stmt(), inc_gimple_stmt_max_uid(), and set_gimple_stmt_max_uid().
Referenced by do_reassoc(), init_scc_vn(), ipa_write_optimization_summaries(), ipa_write_summaries(), and tree_ssa_dse().
| void renumber_gimple_stmt_uids_in_blocks | ( | basic_block * | , |
| int | |||
| ) |
| void replace_exp | ( | use_operand_p | , |
| tree | |||
| ) |
| void reserve_phi_args_for_new_edge | ( | basic_block | ) |
In tree-phinodes.c
Referenced by gimple_execute_on_growing_pred().
| void reset_debug_uses | ( | gimple | ) |
Referenced by generate_loops_for_partition(), and remove_stmt().
| void rewrite_into_loop_closed_ssa | ( | bitmap | , |
| unsigned | |||
| ) |
| enum ev_direction scev_direction | ( | const_tree | ) |
| bool scev_probably_wraps_p | ( | tree | base, |
| tree | step, | ||
| gimple | at_stmt, | ||
| struct loop * | loop, | ||
| bool | use_overflow_semantics | ||
| ) |
Return false only when the induction variable BASE + STEP * I is known to not overflow: i.e. when the number of iterations is small enough with respect to the step and initial condition in order to keep the evolution confined in TYPEs bounds. Return true when the iv is known to overflow or when the property is not computable. USE_OVERFLOW_SEMANTICS is true if this function should assume that the rules for overflow of the given language apply (e.g., that signed arithmetics in C does not overflow).
References nb_iter_bound::bound, loop::bounds, chrec_contains_undetermined(), double_int_fits_to_tree_p(), double_int_to_tree(), estimate_numbers_of_iterations_loop(), fold_defer_overflow_warnings(), fold_undefer_and_ignore_overflow_warnings(), integer_nonzerop(), integer_zerop(), lower_bound_in_type(), max_loop_iterations(), n_of_executions_at_most(), nb_iter_bound::next, nowrap_type_p(), tree_int_cst_sign_bit(), unsigned_type_for(), and upper_bound_in_type().
Referenced by adjust_range_with_scev(), convert_affine_scev(), idx_infer_loop_bounds(), and vrp_var_may_overflow().
Referenced by slpeel_update_phi_nodes_for_guard1().
|
inlinestatic |
| void set_ptr_info_alignment | ( | struct ptr_info_def * | pi, |
| unsigned int | align, | ||
| unsigned int | misalign | ||
| ) |
Store the the power-of-two byte alignment and the deviation from that alignment of pointer described by PI to ALIOGN and MISALIGN respectively.
References ptr_info_def::align, and ptr_info_def::misalign.
Referenced by ccp_finalize(), create_array_ref(), vectorizable_load(), and vectorizable_store().
| bool simple_goto_p | ( | gimple | ) |
| bool simple_iv_increment_p | ( | gimple | ) |
Referenced by cprop_operand(), eliminate_redundant_computations(), and ssa_forward_propagate_and_combine().
Referenced by can_unroll_loop_p(), canonicalize_loop_ivs(), create_parallel_loop(), gen_parallel_loop(), loop_prefetch_arrays(), niter_for_single_dom_exit(), parallelize_loops(), transform_to_exit_first_loop(), tree_predictive_commoning_loop(), tree_ssa_iv_optimize_loop(), try_create_reduction_list(), and try_get_loop_niter().
| basic_block single_noncomplex_succ | ( | basic_block | bb | ) |
Referenced by copy_loop_before(), and slpeel_tree_peel_loop_to_edge().
| basic_block split_loop_exit_edge | ( | edge | ) |
Referenced by create_parallel_loop(), emit_mfence_after_loop(), scev_const_prop(), and vect_analyze_loop_form().
| edge ssa_redirect_edge | ( | edge | , |
| basic_block | |||
| ) |
Referenced by gimple_redirect_edge_and_branch(), gimple_try_redirect_by_replacing_jump(), and redirect_eh_edge().
| bool ssa_undefined_value_p | ( | tree | ) |
Referenced by compute_avail(), init_dont_simulate_again(), uninit_undefined_value_p(), and warn_uninit().
| void ssanames_print_statistics | ( | void | ) |
Dump some simple statistics regarding the re-use of SSA_NAME nodes.
References ssa_name_nodes_created, and ssa_name_nodes_reused.
Referenced by dump_tree_statistics().
| void standard_iv_increment_position | ( | struct loop * | loop, |
| gimple_stmt_iterator * | bsi, | ||
| bool * | insert_after | ||
| ) |
Stores the standard position for induction variable increment in LOOP (just before the exit condition if it is available and latch block is empty, end of the latch block otherwise) to BSI. INSERT_AFTER is set to true if the increment should be inserted after *BSI.
References gsi_last_bb(), ip_end_pos(), ip_normal_pos(), last, last_stmt(), and loop::latch.
Referenced by slpeel_make_loop_iterate_ntimes(), vect_create_data_ref_ptr(), and vectorizable_load().
| void start_recording_case_labels | ( | void | ) |
Start recording information mapping edges to case labels.
References pointer_map_create().
Referenced by cleanup_tree_cfg_1(), and split_critical_edges().
| bool stmt_can_make_abnormal_goto | ( | gimple | ) |
| bool stmt_can_throw_external | ( | gimple | ) |
| bool stmt_can_throw_internal | ( | gimple | ) |
| bool stmt_could_throw_p | ( | gimple | ) |
Referenced by build_and_add_sum(), combine_chains(), and n_of_executions_at_most().
| bool stmt_ends_bb_p | ( | gimple | ) |
| bool stmt_is_replaceable_p | ( | gimple | ) |
In tree-ssa-ter.c
Referenced by expand_expr_real_1().
| bool stmt_references_abnormal_ssa_name | ( | gimple | ) |
Referenced by replace_uses_by().
| void thread_across_edge | ( | gimple | dummy_cond, |
| edge | e, | ||
| bool | handle_dominating_asserts, | ||
| vec< tree > * | stack, | ||
| tree(*)(gimple, gimple) | simplify | ||
| ) |
We are exiting E->src, see if E->dest ends with a conditional jump which has a known value when reached via E. Special care is necessary if E is a back edge in the CFG as we may have already recorded equivalences for E->dest into our various tables, including the result of the conditional at the end of E->dest. Threading opportunities are severely limited in that case to avoid short-circuiting the loop incorrectly. Note it is quite common for the first block inside a loop to end with a conditional which is either always true or always false when reached via the loop backedge. Thus we do not want to blindly disable threading across a loop backedge. DUMMY_COND is a shared cond_expr used by condition simplification as scratch, to avoid allocating memory. HANDLE_DOMINATING_ASSERTS is true if we should try to replace operands of the simplified condition with left-hand sides of ASSERT_EXPRs they are used in. STACK is used to undo temporary equivalences created during the walk of E->dest. SIMPLIFY is a pass-specific function used to simplify statements.
References bitmap_clear(), bitmap_set_bit(), cond_arg_set_in_bb(), edge_def::dest, find_edge(), find_taken_edge(), edge_def::flags, basic_block_def::index, is_gimple_min_invariant(), path, phi_args_equal_on_edges(), propagate_threaded_block_debug_into(), record_temporary_equivalences_from_phis(), record_temporary_equivalences_from_stmts_at_dest(), register_jump_thread(), remove_temporary_equivalences(), simplify_control_stmt_condition(), edge_def::src, stmt_count, basic_block_def::succs, thread_around_empty_block(), visited, and vNULL.
Referenced by dom_thread_across_edge(), and identify_jump_threads().
| bool thread_through_all_blocks | ( | bool | ) |
In tree-ssa-threadupdate.c.
Referenced by finalize_jump_threads(), and tree_ssa_dominator_optimize().
| void threadedge_finalize_values | ( | void | ) |
Free the per SSA_NAME value-handle array.
Referenced by execute_vrp(), and tree_ssa_dominator_optimize().
| void threadedge_initialize_values | ( | void | ) |
In tree-ssa-threadedge.c
Initialize the per SSA_NAME value-handles array. Returns it.
Referenced by execute_vrp(), and tree_ssa_dominator_optimize().
| void tree_check_data_deps | ( | void | ) |
In tree-data-ref.c
Computes all the data dependences and check that the results of several analyzers are the same.
References analyze_all_data_dependences().
Referenced by check_data_deps().
| bool tree_node_can_be_shared | ( | tree | ) |
| unsigned tree_predictive_commoning | ( | void | ) |
Runs predictive commoning.
References free_original_copy_tables(), initialize_original_copy_tables(), LI_ONLY_INNERMOST, optimize_loop_for_speed_p(), scev_reset(), and tree_predictive_commoning_loop().
Referenced by run_tree_predictive_commoning().
| void tree_ssa_iv_optimize | ( | void | ) |
Main entry point. Optimizes induction variables in loops.
References dump_file, dump_flags, flow_loop_dump(), LI_FROM_INNERMOST, tree_ssa_iv_optimize_finalize(), tree_ssa_iv_optimize_init(), and tree_ssa_iv_optimize_loop().
Referenced by tree_ssa_loop_ivopts().
| unsigned int tree_ssa_lim | ( | void | ) |
In tree-ssa-loop*.c
Moves invariants from loops. Only "expensive" invariants are moved out -- i.e. those that are likely to be win regardless of the register pressure.
References analyze_memory_references(), determine_invariantness(), fill_always_executed_in(), move_computations(), store_motion(), tree_ssa_lim_finalize(), and tree_ssa_lim_initialize().
Referenced by tree_ssa_loop_im().
| unsigned int tree_ssa_prefetch_arrays | ( | void | ) |
Issue prefetch instructions for array references in loops.
References add_builtin_function(), build_function_type_list(), BUILT_IN_NORMAL, builtin_decl_explicit_p(), dump_file, dump_flags, free_original_copy_tables(), initialize_original_copy_tables(), LI_FROM_INNERMOST, loop_prefetch_arrays(), loop::num, scev_reset(), and set_builtin_decl().
Referenced by tree_ssa_loop_prefetch().
| unsigned int tree_ssa_unswitch_loops | ( | void | ) |
Main entry point. Perform loop unswitching on all suitable loops.
References changed, dump_file, dump_flags, eni_size_weights, estimated_loop_iterations_int(), HOST_WIDE_INT, LI_ONLY_INNERMOST, loop::num, optimize_loop_for_size_p(), tree_num_loop_insns(), and tree_unswitch_single_loop().
Referenced by tree_ssa_loop_unswitch().
| void tree_transform_and_unroll_loop | ( | struct loop * | , |
| unsigned | , | ||
| edge | , | ||
| struct tree_niter_desc * | , | ||
| transform_callback | , | ||
| void * | |||
| ) |
References add_phi_arg(), bitmap_clear_bit(), bitmap_ones(), copy_ssa_name(), edge_def::count, basic_block_def::count, create_iv(), create_phi_node(), determine_exit_conditions(), expected_loop_iterations(), find_edge(), edge_def::flags, free(), basic_block_def::frequency, gimple_build_cond(), gimple_cond_set_code(), gimple_cond_set_lhs(), gimple_cond_set_rhs(), gimple_duplicate_loop_to_header_edge(), gsi_end_p(), gsi_insert_after(), gsi_last_bb(), gsi_last_nondebug_bb(), GSI_NEW_STMT, gsi_next(), gsi_start_phis(), gsi_stmt(), loop::header, integer_nonzerop(), loop::latch, loop_latch_edge(), loop_preheader_edge(), loop_version(), make_edge(), make_temp_ssa_name(), loop::next, operand_equal_for_phi_arg_p(), prob, edge_def::probability, remove_path(), rescan_loop_exit(), sbitmap_alloc(), scale_bbs_frequencies_int(), scale_dominated_blocks_in_loop(), scale_loop_frequencies(), single_pred(), single_pred_edge(), split_edge(), edge_def::src, update_ssa(), update_stmt(), useless_type_conversion_p(), verify_flow_info(), verify_loop_closed_ssa(), verify_loop_structure(), and vNULL.
Referenced by tree_predictive_commoning_loop(), and tree_unroll_loop().
| void tree_unroll_loop | ( | struct loop * | loop, |
| unsigned | factor, | ||
| edge | exit, | ||
| struct tree_niter_desc * | desc | ||
| ) |
Wrapper over tree_transform_and_unroll_loop for case we do not want to transform the loop before unrolling. The meaning of the arguments is the same as for tree_transform_and_unroll_loop.
References tree_transform_and_unroll_loop().
Referenced by loop_prefetch_arrays().
| unsigned int tree_unroll_loops_completely | ( | bool | , |
| bool | |||
| ) |
Referenced by tree_complete_unroll(), and tree_complete_unroll_inner().
|
inlinestatic |
In tree-flow-inline.h
| void update_ssa | ( | unsigned | ) |
In tree-into-ssa.c
Referenced by canonicalize_loop_closed_ssa_form(), copy_loop_headers(), do_pre(), emit_mfence_after_loop(), execute_function_todo(), execute_pred_commoning(), execute_update_addresses_taken(), execute_vrp(), expand_omp_atomic_fetch_op(), expand_omp_atomic_load(), expand_omp_atomic_mutex(), expand_omp_atomic_pipeline(), expand_omp_atomic_store(), expand_omp_for(), expand_omp_taskreg(), expand_thunk(), gen_parallel_loop(), gimple_duplicate_sese_tail(), input_function(), insert_range_assertions(), ipa_modify_call_arguments(), ipa_tm_scan_calls_transaction(), ipa_tm_transform_clone(), ipa_tm_transform_transaction(), rewrite_commutative_reductions_out_of_ssa(), rewrite_cross_bb_scalar_deps_out_of_ssa(), rewrite_into_loop_closed_ssa(), rewrite_reductions_out_of_ssa(), sese_insert_phis_for_liveouts(), slpeel_tree_peel_loop_to_edge(), translate_clast_user(), tree_function_versioning(), tree_predictive_commoning_loop(), tree_profiling(), tree_ssa_dominator_optimize(), tree_transform_and_unroll_loop(), tree_unroll_loops_completely(), tree_unswitch_single_loop(), and vect_loop_versioning().
|
inlinestatic |
| bool verify_eh_dispatch_edge | ( | gimple | ) |
| bool verify_eh_edges | ( | gimple | ) |
| void verify_gimple_in_cfg | ( | struct function * | ) |
| void verify_gimple_in_seq | ( | gimple_seq | ) |
| void verify_loop_closed_ssa | ( | bool | ) |
Referenced by canonicalize_loop_closed_ssa_form(), execute_function_todo(), gimple_duplicate_loop_to_header_edge(), graphite_verify(), rewrite_commutative_reductions_out_of_ssa(), rewrite_cross_bb_scalar_deps_out_of_ssa(), rewrite_reductions_out_of_ssa(), tree_transform_and_unroll_loop(), and tree_unroll_loops_completely().
| void verify_ssa | ( | bool | ) |
Referenced by create_sese_edges(), execute_function_todo(), and verify_loop_closed_ssa().
| void walk_use_def_chains | ( | tree | var, |
| walk_use_def_chains_fn | fn, | ||
| void * | data, | ||
| bool | is_dfs | ||
| ) |
Walk use-def chains starting at the SSA variable VAR. Call
function FN at each reaching definition found. FN takes three
arguments: VAR, its defining statement (DEF_STMT) and a generic
pointer to whatever state information that FN may want to maintain
(DATA). FN is able to stop the walk by returning true, otherwise
in order to continue the walk, FN should return false.
Note, that if DEF_STMT is a PHI node, the semantics are slightly
different. The first argument to FN is no longer the original
variable VAR, but the PHI argument currently being examined. If FN
wants to get at VAR, it should call PHI_RESULT (PHI).
If IS_DFS is true, this function will:
1- walk the use-def chains for all the PHI arguments, and,
2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
If IS_DFS is false, the two steps above are done in reverse order
(i.e., a breadth-first search).
References pointer_set_create(), pointer_set_destroy(), visited, and walk_use_def_chains_1().
| void warn_function_noreturn | ( | tree | ) |
In ipa-pure-const.c
| void warn_uninit | ( | enum opt_code | wc, |
| tree | t, | ||
| tree | expr, | ||
| tree | var, | ||
| const char * | gmsgid, | ||
| void * | data | ||
| ) |
Emit warnings for uninitialized variables. This is done in two passes. The first pass notices real uses of SSA names with undefined values. Such uses are unconditionally uninitialized, and we can be certain that such a use is a mistake. This pass is run before most optimizations, so that we catch as many as we can. The second pass follows PHI nodes to find uses that are potentially uninitialized. In this case we can't necessarily prove that the use is really uninitialized. This pass is run after most optimizations, so that we thread as many jumps and possible, and delete as much dead code as possible, in order to reduce false positives. We also look again for plain uninitialized variables, since optimization may have changed conditionally uninitialized to unconditionally uninitialized.
Emit a warning for EXPR based on variable VAR at the point in the program T, an SSA_NAME, is used being uninitialized. The exact warning text is in MSGID and LOCUS may contain a location or be null. WC is the warning code.
References cfun, function::decl, expand_location(), function::function_end_locus, gimple_assign_rhs1(), gimple_assign_single_p(), gimple_has_location(), gimple_location(), gimple_no_warning_p(), inform(), line_table, ssa_undefined_value_p(), and warning_at().
Referenced by warn_uninitialized_phi(), and warn_uninitialized_vars().
| unsigned int warn_uninitialized_vars | ( | bool | ) |
Referenced by execute_early_warn_uninitialized(), and execute_late_warn_uninitialized().
Variable Documentation
| bitmap cfgcleanup_altered_bbs |
In tree-cfgcleanup.c
@verbatim CFG cleanup for trees.
Copyright (C) 2001-2013 Free Software Foundation, Inc.
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 set of blocks in that at least one of the following changes happened:
-- the statement at the end of the block was changed
-- the block was newly created
-- the set of the predecessors of the block changed
-- the set of the successors of the block changed
??? Maybe we could track these changes separately, since they determine
what cleanups it makes sense to try on the block.
Referenced by gimple_merge_blocks(), remove_edge_and_dominated_blocks(), and replace_uses_by().
| struct omp_region* root_omp_region |
Referenced by make_edges(), and new_omp_region().
Array to record value-handles per SSA_NAME.
Referenced by tree_ssa_dominator_optimize().
