#include "config.h"#include "system.h"#include "coretypes.h"#include "tm.h"#include "target.h"#include "tree.h"#include "ggc.h"#include "hard-reg-set.h"#include "basic-block.h"#include "gimple.h"#include "diagnostic.h"#include "value-prof.h"#include "flags.h"#include "alias.h"#include "demangle.h"#include "langhooks.h"#include "bitmap.h"#include "gsstruct.def"#include "gimple.def"#include "all-tree.def"
Macros | |
| #define | DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0), |
| #define | DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT), |
| #define | DEFGSCODE(SYM, NAME, GSSCODE) NAME, |
| #define | DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE, |
| #define | gimple_build_with_ops(c, s, n) gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO) |
| #define | DEFTREECODE(SYM, STRING, TYPE, NARGS) |
| #define | END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS, |
| #define | GIMPLE_FIXED_TYPES(NAME) |
| #define | GIMPLE_FIXED_MODE_TYPES(NAME) |
| #define | GIMPLE_FIXED_TYPES_SAT(NAME) |
| #define | GIMPLE_FIXED_MODE_TYPES_SAT(NAME) |
| #define | TYPE_OK(node) |
Variables | |
| EXPORTED_CONST size_t | gimple_ops_offset_ [] |
| static const size_t | gsstruct_code_size [] |
| const char *const | gimple_code_name [] |
| EXPORTED_CONST enum gimple_statement_structure_enum | gss_for_code_ [] |
| int | gimple_alloc_counts [(int) gimple_alloc_kind_all] |
| int | gimple_alloc_sizes [(int) gimple_alloc_kind_all] |
| static const char *const | gimple_alloc_kind_names [] |
| const unsigned char | gimple_rhs_class_table [] |
Macro Definition Documentation
| #define DEFGSCODE | ( | SYM, | |
| NAME, | |||
| GSSCODE | |||
| ) | GSSCODE, |
| #define DEFGSSTRUCT | ( | SYM, | |
| STRUCT, | |||
| HAS_TREE_OP | |||
| ) | (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0), |
Gimple IR support functions.
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/. All the tuples have their operand vector (if present) at the very bottom of the structure. Therefore, the offset required to find the operands vector the size of the structure minus the size of the 1 element tree array at the end (see gimple_ops).
| #define DEFGSSTRUCT | ( | SYM, | |
| STRUCT, | |||
| HAS_TREE_OP | |||
| ) | sizeof (struct STRUCT), |
Gimple IR support functions.
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/. All the tuples have their operand vector (if present) at the very bottom of the structure. Therefore, the offset required to find the operands vector the size of the structure minus the size of the 1 element tree array at the end (see gimple_ops).
| #define DEFTREECODE | ( | SYM, | |
| STRING, | |||
| TYPE, | |||
| NARGS | |||
| ) |
| #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS, |
| #define gimple_build_with_ops | ( | c, | |
| s, | |||
| n | |||
| ) | gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO) |
Build a tuple with operands. CODE is the statement to build (which must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode for the new tuple. NUM_OPS is the number of operands to allocate.
Referenced by gimple_build_assign_with_ops(), gimple_build_call_valist(), gimple_build_cond_from_tree(), gimple_build_eh_else(), gimple_build_resx(), gimple_build_try(), gimple_build_with_ops_stat(), and gimple_call_reset_alias_info().
| #define GIMPLE_FIXED_MODE_TYPES | ( | NAME | ) |
Referenced by gimple_call_copy_skip_args().
| #define GIMPLE_FIXED_MODE_TYPES_SAT | ( | NAME | ) |
Referenced by gimple_call_copy_skip_args().
| #define GIMPLE_FIXED_TYPES | ( | NAME | ) |
Referenced by gimple_call_copy_skip_args().
| #define GIMPLE_FIXED_TYPES_SAT | ( | NAME | ) |
Referenced by gimple_call_copy_skip_args().
| #define TYPE_OK | ( | node | ) |
Function Documentation
| tree canonicalize_cond_expr_cond | ( | ) |
Canonicalize a tree T for use in a COND_EXPR as conditional. Returns a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if we failed to create one.
Strip conversions around boolean operations.
For !x use x == 0.
For cmp ? 1 : 0 use cmp.
For x ^ y use x != y.
Referenced by ifcombine_ifandif().
| tree copy_var_decl | ( | ) |
Create a new VAR_DECL and copy information from VAR to it.
| void dump_decl_set | ( | ) |
Dump bitmap SET (assumed to contain VAR_DECLs) to FILE.
Referenced by prepare_block_for_update().
| 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 | ( | ) |
Return true if BODY contains nothing but empty statements.
Referenced by gimple_build_transaction().
|
static |
Helper function of empty_body_p. Return true if STMT is an empty statement.
Referenced by gimple_build_predict().
| 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 get_base_address | ( | ) |
Given a memory reference expression T, return its base address. The base address of a memory reference expression is the main object being referenced. For instance, the base address for 'array[i].fld[j]' is 'array'. You can think of this as stripping away the offset part from a memory address.
This function calls handled_component_p to strip away all the inner parts of the memory reference until it reaches the base object.
??? Either the alias oracle or all callers need to properly deal with WITH_SIZE_EXPRs before we can look through those.
Referenced by add_stack_var_conflict(), build_access_from_expr(), execute_sm_if_changed_flag_set(), expand_builtin_prefetch(), get_address_description(), gimple_redirect_edge_and_branch(), gimple_stmt_nonnegative_warnv_p(), initialize_argument_information(), ipa_analyze_virtual_call_uses(), make_constraint_from(), maybe_optimize_var(), refs_independent_p(), tree_nrv(), unmodified_parm(), unmodified_parm_or_parm_agg_item(), and warn_uninitialized_vars().
|
static |
From a tree operand OP return the base of a load or store operation or NULL_TREE if OP is not a load or a store.
| unsigned get_gimple_rhs_num_ops | ( | ) |
Return the number of operands needed on the RHS of a GIMPLE assignment for an expression with tree code CODE.
Referenced by gimple_assign_copy_p().
| gimple gimple_alloc_stat | ( | ) |
Allocate memory for a GIMPLE statement with code CODE and NUM_OPS operands.
Do not call gimple_set_modified here as it has other side effects and this tuple is still not completely built.
References gimple_alloc_counts, and gimple_alloc_sizes.
Referenced by gimple_set_subcode().
| bool gimple_asm_clobbers_memory_p | ( | ) |
Return true if STMT clobbers memory. STMT is required to be a GIMPLE_ASM.
References prototype_p(), TREE_CHAIN, TREE_CODE, TREE_TYPE, TREE_VALUE, TYPE_ARG_TYPES, TYPE_MAIN_VARIANT, TYPE_METHOD_BASETYPE, and useless_type_conversion_p().
Referenced by check_stmt().
| bool gimple_assign_copy_p | ( | ) |
Return true if GS is a copy assignment.
References get_gimple_rhs_num_ops(), gimple_assign_lhs(), and gsi_stmt().
Referenced by live_track_init(), and tree_nrv().
| bool gimple_assign_rhs_could_trap_p | ( | ) |
Return true if RHS of a GIMPLE_ASSIGN S can trap.
| void gimple_assign_set_rhs_from_tree | ( | ) |
Modify the RHS of the assignment pointed-to by GSI using the operands in the expression tree EXPR.
NOTE: The statement pointed-to by GSI may be reallocated if it did not have enough operand slots.
This function is useful to convert an existing tree expression into the flat representation used for the RHS of a GIMPLE assignment. It will reallocate memory as needed to expand or shrink the number of operand slots needed to represent EXPR.
NOTE: If you find yourself building a tree and then calling this function, you are most certainly doing it the slow way. It is much better to build a new assignment or to use the function gimple_assign_set_rhs_with_ops, which does not require an expression tree to be built.
Referenced by combine_cond_exprs(), forward_propagate_addr_expr(), may_propagate_copy_into_asm(), may_reassociate_p(), simplify_conversion_from_bitmask(), and test_for_singularity().
| 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().
| bool gimple_assign_ssa_name_copy_p | ( | ) |
Return true if GS is a SSA_NAME copy assignment.
Referenced by create_outofssa_var_map(), get_prop_dest_stmt(), and recognize_single_bit_test().
| bool gimple_assign_unary_nop_p | ( | ) |
Return true if GS is an assignment with a unary RHS, but the operator has no effect on the assigned value. The logic is adapted from STRIP_NOPS. This predicate is intended to be used in tuplifying instances in which STRIP_NOPS was previously applied to the RHS of an assignment.
NOTE: In the use cases that led to the creation of this function and of gimple_assign_single_p, it is typical to test for either condition and to proceed in the same manner. In each case, the assigned value is represented by the single RHS operand of the assignment. I suspect there may be cases where gimple_assign_copy_p, gimple_assign_single_p, or equivalent logic is used where a similar treatment of unary NOPs is appropriate.
References gimple_assign_lhs(), gimple_call_lhs(), and NULL_TREE.
Referenced by check_for_plus_in_loops_1().
| gimple_seq gimple_body | ( | ) |
Return the body of GIMPLE statements for function FN. After the CFG pass, the function body doesn't exist anymore because it has been split up into basic blocks. In this case, it returns NULL.
References ECF_MALLOC, ERF_NOALIAS, and gimple_call_flags().
Referenced by finalize_nesting_tree_1(), move_sese_region_to_fn(), and remap_vla_decls().
|
inlinestatic |
Helper function to set the simple fields of a asm stmt.
STRING is a pointer to a string that is the asm blocks assembly code. NINPUT is the number of register inputs. NOUTPUT is the number of register outputs. NCLOBBERS is the number of clobbered registers.
ASMs with labels cannot have outputs. This should have been enforced by the front end.
References gimple_asm_set_clobber_op(), gimple_asm_set_input_op(), gimple_asm_set_label_op(), gimple_asm_set_output_op(), and vec_safe_length().
| 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_assign_stat | ( | ) |
Build a GIMPLE_ASSIGN statement.
LHS of the assignment. RHS of the assignment which can be unary or binary.
| gimple gimple_build_assign_with_ops | ( | enum tree_code | subcode, |
| tree | lhs, | ||
| tree | op1, | ||
| tree | op2, | ||
| tree op3 | MEM_STAT_DECL | ||
| ) |
Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands OP1 and OP2. If OP2 is NULL then SUBCODE must be of class GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS.
Need 1 operand for LHS and 1 or 2 for the RHS (depending on the code).
References NULL_TREE, and PASS_MEM_STAT.
Referenced by attempt_builtin_powi(), check_bool_pattern(), create_iv(), expand_transaction(), gimple_expand_builtin_powi(), instrument_builtin_call(), is_phi_for_stmt(), rewrite_to_defined_overflow(), simplify_bitwise_binary_boolean(), swap_ops_for_binary_stmt(), vect_init_vector_1(), vect_permute_store_chain(), and vect_recog_pow_pattern().
| gimple gimple_build_bind | ( | ) |
Build a GIMPLE_BIND statement. VARS are the variables in BODY. BLOCK is the containing block.
Referenced by lower_omp_sections(), and maybe_add_implicit_barrier_cancel().
| gimple gimple_build_call | ( | ) |
Build a GIMPLE_CALL statement to function FN. NARGS is the number of arguments. The ... are the arguments.
References gcc_assert, gimple_build_call_1(), gimple_call_set_arg(), is_gimple_call_addr(), and TREE_CODE.
Referenced by get_tm_region_blocks(), gimple_gen_pow2_profiler(), instrument_memory_accesses(), ipa_tm_diagnose_tm_safe(), lower_gimple_return(), lower_omp_sections(), maybe_add_implicit_barrier_cancel(), set_strinfo(), and split_critical_edges().
|
inlinestatic |
Helper for gimple_build_call, gimple_build_call_valist, gimple_build_call_vec and gimple_build_call_from_tree. Build the basic components of a GIMPLE_CALL statement to function FN with NARGS arguments.
References gimple_call_set_arg().
Referenced by gimple_build_call(), and gimple_build_call_vec().
| gimple gimple_build_call_from_tree | ( | ) |
Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is assumed to be in GIMPLE form already. Minimal checking is done of this fact.
Carry all the CALL_EXPR flags to the new GIMPLE_CALL.
| gimple gimple_build_call_internal | ( | ) |
Build a GIMPLE_CALL statement to internal function FN. NARGS is the number of arguments. The ... are the arguments.
References gimple_build_call_internal_1(), and gimple_call_set_arg().
|
inlinestatic |
Helper for gimple_build_call_internal and gimple_build_call_internal_vec. Build the basic components of a GIMPLE_CALL statement to internal function FN with NARGS arguments.
Referenced by gimple_build_call_internal().
| gimple gimple_build_call_internal_vec | ( | ) |
Build a GIMPLE_CALL statement to internal function FN with the arguments specified in vector ARGS.
| gimple gimple_build_call_valist | ( | ) |
Build a GIMPLE_CALL statement to function FN. NARGS is the number of arguments. AP contains the arguments.
References GF_CALL_INTERNAL, gimple_build_with_ops, gimple_call_reset_alias_info(), gimple_call_set_internal_fn(), and gimple_statement_base::subcode.
| gimple gimple_build_call_vec | ( | ) |
Build a GIMPLE_CALL statement to function FN with the arguments specified in vector ARGS.
References gcc_assert, gimple_build_call_1(), gimple_call_set_arg(), is_gimple_call_addr(), and TREE_CODE.
Referenced by finish_update_gimple_call().
| gimple gimple_build_catch | ( | ) |
Build a GIMPLE_CATCH statement.
TYPES are the catch types. HANDLER is the exception handler.
References gimple_alloc, gimple_eh_else_set_e_body(), and gimple_eh_else_set_n_body().
| 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_cond_from_tree | ( | ) |
Build a GIMPLE_COND statement from the conditional expression tree COND. T_LABEL and F_LABEL are as in gimple_build_cond.
References gimple_build_with_ops, and gimple_goto_set_dest().
Referenced by update_dominators_in_loop().
| gimple gimple_build_debug_bind_stat | ( | ) |
Build a new GIMPLE_DEBUG_BIND statement.
VAR is bound to VALUE; block and location are taken from STMT.
References gimple_statement_omp_for::collapse, ggc_internal_cleared_vec_alloc_stat(), gimple_alloc, gimple_omp_for_set_clauses(), gimple_omp_for_set_kind(), gimple_omp_set_body(), gimple_statement_omp_for::iter, and MEM_STAT_INFO.
Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
VAR is bound to VALUE; block and location are taken from STMT.
| gimple gimple_build_eh_dispatch | ( | ) |
Build a GIMPLE_EH_DISPATCH statement.
References gimple_alloc, gimple_omp_critical_set_name(), and gimple_omp_set_body().
| gimple gimple_build_eh_else | ( | ) |
Build a GIMPLE_EH_ELSE statement.
References gimple_build_with_ops, and gimple_statement_eh_ctrl::region.
| gimple gimple_build_eh_filter | ( | ) |
Build a GIMPLE_EH_FILTER statement.
TYPES are the filter's types. FAILURE is the filter's failure action.
References gcc_assert, gimple_alloc, gimple_set_subcode(), GIMPLE_TRY_CATCH, GIMPLE_TRY_FINALLY, gimple_try_set_cleanup(), and gimple_try_set_eval().
| gimple gimple_build_eh_must_not_throw | ( | ) |
Build a GIMPLE_EH_MUST_NOT_THROW statement.
References gimple_alloc, and gimple_wce_set_cleanup().
| gimple gimple_build_goto | ( | ) |
Build a GIMPLE_GOTO statement to label DEST.
Referenced by factor_computed_gotos(), gimplify_vla_decl(), honor_protect_cleanup_actions(), and lower_gimple_return().
| gimple gimple_build_label | ( | ) |
Build a GIMPLE_LABEL statement for LABEL.
Referenced by do_return_redirection(), examine_assign_tm(), factor_computed_gotos(), find_goto_replacement(), gimplify_vla_decl(), honor_protect_cleanup_actions(), and lower_gimple_return().
| gimple gimple_build_nop | ( | void | ) |
Build a GIMPLE_NOP statement.
Referenced by fold_gimple_cond().
| gimple gimple_build_omp_atomic_load | ( | ) |
Build a GIMPLE_OMP_ATOMIC_LOAD statement.
Referenced by create_phi_for_local_result().
| gimple gimple_build_omp_atomic_store | ( | ) |
Build a GIMPLE_OMP_ATOMIC_STORE statement.
VAL is the value we are storing.
| gimple gimple_build_omp_continue | ( | ) |
Build a GIMPLE_OMP_CONTINUE statement.
CONTROL_DEF is the definition of the control variable. CONTROL_USE is the use of the control variable.
References gimple_alloc, gimple_omp_set_body(), and gimple_omp_single_set_clauses().
| gimple gimple_build_omp_critical | ( | ) |
Build a GIMPLE_OMP_CRITICAL statement.
BODY is the sequence of statements for which only one thread can execute. NAME is optional identifier for this critical block.
| 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 | ( | ) |
Build a GIMPLE_OMP_MASTER statement.
BODY is the sequence of statements to be executed by just the master.
| gimple gimple_build_omp_ordered | ( | ) |
Build a GIMPLE_OMP_ORDERED statement.
BODY is the sequence of statements inside a loop that will executed in sequence.
| 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_return | ( | ) |
Build a GIMPLE_OMP_RETURN statement. WAIT_P is true if this is a non-waiting return.
Referenced by lower_omp_sections(), and maybe_add_implicit_barrier_cancel().
| gimple gimple_build_omp_section | ( | ) |
Build a GIMPLE_OMP_SECTION statement for a sections statement.
BODY is the sequence of statements in the section.
References gimple_alloc, and gimple_omp_set_body().
| gimple gimple_build_omp_sections | ( | ) |
Build a GIMPLE_OMP_SECTIONS statement.
BODY is a sequence of section statements. CLAUSES are any of the OMP sections contsruct's clauses: private, firstprivate, lastprivate, reduction, and nowait.
| 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 | ( | ) |
Build a GIMPLE_OMP_SINGLE statement.
BODY is the sequence of statements that will be executed once. CLAUSES are any of the OMP single construct's clauses: private, firstprivate, copyprivate, nowait.
References gimple_alloc, gimple_transaction_set_body(), and gimple_transaction_set_label().
| gimple gimple_build_omp_target | ( | ) |
Build a GIMPLE_OMP_TARGET statement.
BODY is the sequence of statements that will be executed. CLAUSES are any of the OMP target construct's clauses.
| 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 | ( | ) |
Build a GIMPLE_OMP_TASKGROUP statement.
BODY is the sequence of statements to be executed by the taskgroup construct.
| gimple gimple_build_omp_teams | ( | ) |
Build a GIMPLE_OMP_TEAMS statement.
BODY is the sequence of statements that will be executed. CLAUSES are any of the OMP teams construct's clauses.
| gimple gimple_build_predict | ( | ) |
Build a GIMPLE_PREDICT statement. PREDICT is one of the predictors from predict.def, OUTCOME is NOT_TAKEN or TAKEN.
Ensure all the predictors fit into the lower bits of the subcode.
References empty_stmt_p(), gimple_seq_empty_p(), gsi_end_p(), gsi_next(), gsi_start, gsi_stmt(), and is_gimple_debug().
Referenced by estimate_num_insns_fn().
| gimple gimple_build_resx | ( | ) |
Build a GIMPLE_RESX statement.
References gimple_build_with_ops, and gimple_statement_eh_ctrl::region.
| gimple gimple_build_return | ( | ) |
Build a GIMPLE_RETURN statement returning RETVAL.
Referenced by split_function().
| gimple gimple_build_switch | ( | ) |
Build a GIMPLE_SWITCH statement.
INDEX is the switch's index. DEFAULT_LABEL is the default label ARGS is a vector of labels excluding the default.
Copy the labels from the vector to the switch statement.
| gimple gimple_build_switch_nlabels | ( | ) |
The helper for constructing a gimple switch statement. INDEX is the switch's index. NLABELS is the number of labels in the switch excluding the default. DEFAULT_LABEL is the default label for the switch statement.
nlabels + 1 default label + 1 index.
| gimple gimple_build_transaction | ( | ) |
Build a GIMPLE_TRANSACTION statement.
References empty_body_p(), and gimple_bind_body().
| 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 | ( | ) |
Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
CLEANUP is the cleanup expression.
|
static |
References gimple_build_with_ops, and gimple_return_set_retval().
| int gimple_call_arg_flags | ( | ) |
Detects argument flags for argument number ARG on call STMT.
References gimple_statement_base::bb, cfun, gimple_label_label(), LABEL_DECL_UID, label_to_block_map, vec_safe_grow_cleared(), and vec_safe_length().
| bool gimple_call_builtin_p | ( | ) |
Return true when STMT is builtins call to CLASS.
Return true when STMT is builtins call to CODE of CLASS.
Referenced by get_mem_ref_of_assignment(), and phi_result_unknown_predicate().
| gimple gimple_call_copy_skip_args | ( | ) |
Build a GIMPLE_CALL identical to STMT but skipping the arguments in the positions marked by the set ARGS_TO_SKIP.
References GIMPLE_FIXED_MODE_TYPES, GIMPLE_FIXED_MODE_TYPES_SAT, GIMPLE_FIXED_TYPES, and GIMPLE_FIXED_TYPES_SAT.
| int gimple_call_flags | ( | ) |
Detect flags from a GIMPLE_CALL. This is just like call_expr_flags, but for gimple tuples.
References gimple_assign_single_p(), gimple_op(), and is_gimple_val().
Referenced by build_cgraph_edges(), do_partial_partial_insertion(), dump_function_to_file(), find_case_label_for_value(), gimple_body(), handle_lhs_call(), replace_phi_args_in(), special_builtin_state(), and vect_get_vec_defs_for_stmt_copy().
|
static |
Return the "fn spec" string for call STMT.
References CONVERT_EXPR_CODE_P, error_mark_node, gimple_assign_lhs(), gimple_assign_rhs1(), gimple_assign_rhs_code(), is_gimple_assign(), TREE_TYPE, and TYPE_MODE.
| unsigned gimple_call_get_nobnd_arg_index | ( | ) |
Return index of INDEX's non bound argument of the call.
| void gimple_call_reset_alias_info | ( | ) |
Reset alias information on call S.
References build_fold_addr_expr, gimple_build_with_ops, gimple_call_set_fntype(), gimple_set_op(), TREE_CODE, and TREE_TYPE.
Referenced by gimple_build_call_valist().
| int gimple_call_return_flags | ( | ) |
Detects return flags for the call STMT.
References extract_ops_from_tree_1(), and gimple_assign_set_rhs_with_ops_1().
| bool gimple_call_same_target_p | ( | ) |
Return true if calls C1 and C2 are known to go to the same function.
Referenced by same_succ_def::equal().
| bool gimple_can_coalesce_p | ( | ) |
Given SSA_NAMEs NAME1 and NAME2, return true if they are candidates for coalescing together, false otherwise.
This must stay consistent with var_map_base_init in tree-ssa-live.c.
First check the SSA_NAME's associated DECL. We only want to coalesce if they have the same DECL or both have no associated DECL.
Now check the types. If the types are the same, then we should try to coalesce V1 and V2.
If the types are not the same, check for a canonical type match. This (for example) allows coalescing when the types are fundamentally the same, but just have different names. Note pointer types with different address spaces may have the same canonical type. Those are rejected for coalescing by the types_compatible_p check.
Referenced by create_outofssa_var_map(), and uncprop_into_successor_phis().
| bool gimple_compare_field_offset | ( | ) |
Return true if the field decls F1 and F2 are at the same offset.
This is intended to be used on GIMPLE types only.
Once gimplification is done, self-referential offsets are
instantiated as operand #2 of the COMPONENT_REF built for
each access and reset. Therefore, they are not relevant
anymore and fields are interchangeable provided that they
represent the same access.
Fortran and C do not always agree on what DECL_OFFSET_ALIGN should be, so handle differing ones specially by decomposing the offset into a byte and bit offset manually.
| 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().
| void gimple_cond_set_condition_from_tree | ( | ) |
Set code, lhs, and rhs of a GIMPLE_COND from a suitable boolean expression tree COND.
Referenced by ifcombine_ifandif(), and tree_unswitch_single_loop().
| gimple gimple_copy | ( | ) |
Return a deep copy of statement STMT. All the operands from STMT are reallocated and copied using unshare_expr. The DEF, USE, VDEF and VUSE operand arrays are set to empty in the new copy. The new copy isn't part of any sequence.
Shallow copy all the fields from STMT.
If STMT has sub-statements, deep-copy them as well.
FALLTHRU
Make copy of operands.
Clear out SSA operand vectors on COPY.
SSA operands need to be updated.
Referenced by gimple_redirect_edge_and_branch().
| bool gimple_could_trap_p_1 | ( | ) |
Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p. Return true if S can trap. When INCLUDE_MEM is true, check whether the memory operations could trap. When INCLUDE_STORES is true and S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked.
Assume that calls to weak functions may trap.
| const char* gimple_decl_printable_name | ( | ) |
Return a printable name for symbol DECL.
| alias_set_type gimple_get_alias_set | ( | ) |
Return the typed-based alias set for T, which may be an expression or a type. Return -1 if we don't do anything special.
Permit type-punning when accessing a union, provided the access is directly through the union. For example, this code does not permit taking the address of a union member and then storing through it. Even the type-punning allowed here is a GCC extension, albeit a common and useful one; the C standard says that such accesses have implementation-defined behavior.
That's all the expressions we handle specially.
For convenience, follow the C standard when dealing with character types. Any object may be accessed via an lvalue that has character type.
Allow aliasing between signed and unsigned variants of the same type. We treat the signed variant as canonical.
t1 == t can happen for boolean nodes which are always unsigned.
| tree gimple_get_lhs | ( | ) |
Return the LHS of a statement that performs an assignment, either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE for a call to a function that returns no value, or for a statement other than an assignment or a call.
Referenced by check_array_ref(), dse_optimize_stmt(), execute_sm_if_changed_flag_set(), extract_component(), gimple_redirect_edge_and_branch(), gsi_split_seq_before(), inhibit_phi_insertion(), make_blocks(), maybe_optimize_var(), ref_may_be_aliased(), tree_nrv(), and vect_build_slp_tree_1().
| bool gimple_has_body_p | ( | ) |
Return true when FNDECL has Gimple body either in unlowered or CFG form.
Referenced by cgraph_edge_cannot_lead_to_return(), cgraph_materialize_clone(), comp_type_attributes(), and gcc::pass_manager::pass_manager().
| bool gimple_has_side_effects | ( | ) |
Return true if statement S has side-effects. We consider a statement to have side effects if:
- It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
- Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS.
We don't have to scan the arguments to check for volatile arguments, though, at present, we still do a scan to check for TREE_SIDE_EFFECTS.
An infinite loop is considered a side effect.
References gcc_unreachable, get_gimple_rhs_class(), GIMPLE_BINARY_RHS, GIMPLE_SINGLE_RHS, GIMPLE_TERNARY_RHS, and GIMPLE_UNARY_RHS.
Referenced by do_partial_partial_insertion(), find_case_label_for_value(), mark_stmt_if_obviously_necessary(), and tree_bb_level_predictions().
| bool gimple_ior_addresses_taken | ( | ) |
Set the bit for the uid of all decls that have their address taken in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there were any in this stmt.
Helper for gimple_ior_addresses_taken_1.
References TYPE_PRECISION, and TYPE_UNSIGNED.
| void gimple_seq_add_seq | ( | ) |
Append sequence SRC to the end of sequence *DST_P. If *DST_P is NULL, a new sequence is allocated.
References walk_stmt_info::callback_result, gcc_assert, gsi_next(), gsi_stmt(), NULL, walk_stmt_info::removed_stmt, and walk_gimple_stmt().
Referenced by finalize_nesting_tree_1(), gimplify_expr(), honor_protect_cleanup_actions(), and vect_create_cond_for_alias_checks().
| void gimple_seq_add_stmt | ( | ) |
Link gimple statement GS to the end of the sequence *SEQ_P. If *SEQ_P is NULL, a new sequence is allocated.
References gsi_end_p(), and gsi_start.
Referenced by do_return_redirection(), gsi_move_after(), honor_protect_cleanup_actions(), and remap_vla_decls().
| gimple_seq gimple_seq_copy | ( | ) |
Perform a deep copy of sequence SRC and return the result.
Referenced by find_goto_replacement(), and replace_goto_queue_cond_clause().
| void gimple_set_bb | ( | ) |
Set BB to be the basic block holding G.
If the statement is a label, add the label to block-to-labels map so that we can speed up edge creation for GIMPLE_GOTOs.
References gcc_unreachable, gimple_assign_set_lhs(), and gimple_call_set_lhs().
Referenced by gsi_split_seq_before(), and update_bb_for_stmts().
| void gimple_set_body | ( | ) |
Set sequence SEQ to be the GIMPLE body for function FN.
If FNDECL still does not have a function structure associated with it, then it does not make sense for it to receive a GIMPLE body.
References EAF_DIRECT, EAF_NOCLOBBER, EAF_NOESCAPE, and EAF_UNUSED.
|
inlinestatic |
Gimple tuple constructors. Note: Any constructor taking a ``gimple_seq'' as a parameter, can be passed a NULL to start with an empty sequence. Set the code for statement G to CODE.
References gss_for_code(), and gsstruct_code_size.
| void gimple_set_lhs | ( | ) |
Set the LHS of a statement that performs an assignment, either a GIMPLE_ASSIGN or a GIMPLE_CALL.
Referenced by make_blocks().
| void gimple_set_loaded_syms | ( | gimple | , |
| bitmap | , | ||
| bitmap_obstack * | |||
| ) |
| void gimple_set_stored_syms | ( | gimple | , |
| bitmap | , | ||
| bitmap_obstack * | |||
| ) |
Private API manipulation functions shared only with some other files.
|
inlinestatic |
Set SUBCODE to be the code of the expression computed by statement G.
We only have 16 bits for the RHS code. Assert that we are not overflowing it.
References gimple_alloc_stat(), and PASS_MEM_STAT.
Referenced by gimple_build_eh_filter().
|
static |
Return a type the same as TYPE except unsigned or signed according to UNSIGNEDP.
For ENUMERAL_TYPEs in C++, must check the mode of the types, not the precision; they have precision set to match their range, but may use a wider mode to match an ABI. If we change modes, we may wind up with bad conversions. For INTEGER_TYPEs in C, must check the precision as well, so as to yield correct results for bit-field types. C++ does not have these separate bit-field types, and producing a signed or unsigned variant of an ENUMERAL_TYPE may cause other problems as well.
| tree gimple_signed_type | ( | ) |
Return a signed type the same as TYPE in other respects.
|
inlinestatic |
Return the number of bytes needed to hold a GIMPLE statement with code CODE.
| tree gimple_unsigned_type | ( | ) |
Return an unsigned type the same as TYPE in other respects.
| gimple gimplify_assign | ( | ) |
Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
DST/SRC are the destination and source respectively. You can pass ungimplified trees in DST or SRC, in which case they will be converted to a gimple operand if necessary.
This function returns the newly created GIMPLE_ASSIGN tuple.
References extract_ops_from_tree(), gcc_assert, is_gimple_min_invariant(), SSA_VAR_P, tcc_comparison, TREE_CODE, and TREE_CODE_CLASS.
Referenced by assign_parms(), and lower_reduction_clauses().
| bool is_gimple_address | ( | ) |
Return true if T is a gimple address.
| bool is_gimple_addressable | ( | ) |
Return true if T is something whose address can be taken.
References TREE_CODE.
| bool is_gimple_asm_val | ( | ) |
Similarly, but accept hard registers as inputs to asm statements.
References gimple_call_num_args().
| bool is_gimple_builtin_call | ( | ) |
Return TRUE iff stmt is a call to a built-in function.
| bool is_gimple_call_addr | ( | ) |
Return true if T is a valid function operand of a CALL_EXPR.
Referenced by gimple_build_call(), and gimple_build_call_vec().
| bool is_gimple_condexpr | ( | ) |
Return true if T is a GIMPLE condition.
References is_gimple_constant(), is_gimple_ip_invariant_address(), and TREE_CODE.
Referenced by add_to_predicate_list(), bb_predicate(), if_convertible_loop_p(), insert_gimplified_predicates(), and vect_create_cond_for_alias_checks().
| bool is_gimple_constant | ( | ) |
Return true if T is a valid gimple constant.
References is_gimple_variable(), and TREE_CODE.
Referenced by find_matching_predicate_in_rest_chains(), instrument_derefs(), is_gimple_condexpr(), and is_gimple_lvalue().
| bool is_gimple_id | ( | ) |
Return true if T is a GIMPLE identifier (something with an address).
Allow string constants, since they are addressable.
| bool is_gimple_invariant_address | ( | ) |
Return true if T is a gimple invariant address.
Referenced by is_gimple_lvalue().
| bool is_gimple_ip_invariant | ( | ) |
Return true if T is a GIMPLE interprocedural invariant. It's a restricted form of gimple minimal invariant.
References CONSTANT_CLASS_P, decl_address_invariant_p(), is_gimple_reg(), TREE_CODE, and TREE_OPERAND.
Referenced by ipa_load_from_parm_agg(), and ipa_prop_write_all_agg_replacement().
| bool is_gimple_ip_invariant_address | ( | ) |
Return true if T is a gimple invariant address at IPA level (so addresses of variables on stack are not allowed).
Referenced by is_gimple_condexpr().
| bool is_gimple_lvalue | ( | ) |
For the definitive definition of GIMPLE, see doc/tree-ssa.texi. Validation of GIMPLE expressions. Return true if T is a valid LHS for a GIMPLE assignment expression.
These are complex lvalues, but don't have addresses, so they go here.
References is_gimple_constant(), is_gimple_invariant_address(), and TREE_CODE.
| bool is_gimple_mem_ref_addr | ( | ) |
Return true if T is a valid address operand of a MEM_REF.
Referenced by create_mem_ref(), expand_builtin_prefetch(), and last_stmt().
| bool is_gimple_min_invariant | ( | ) |
Return true if T is a GIMPLE minimal invariant. It's a restricted form of function invariant.
References is_gimple_val(), and TREE_CODE.
Referenced by analyze_evolution_in_loop(), associate_equivalences_with_edges(), bit_value_binop(), build1_stat(), copy_debug_stmts(), DFS(), eliminate_local_variables(), extract_range_from_comparison(), extract_range_from_cond_expr(), find_loop_niter(), find_operand_rank(), fold_builtin_logarithm(), get_asm_expr_operands(), get_or_alloc_expr_for(), get_or_alloc_expr_for_constant(), get_value_from_alignment(), gimple_assign_nonzero_warnv_p(), gimplify_assign(), interpret_loop_phi(), lower_omp_master(), phi_translate_1(), scev_reset(), simplify_binary_expression(), simplify_cond_using_ranges(), ssa_prop_fini(), verify_gimple_label(), vn_reference_maybe_forwprop_address(), vrp_intersect_ranges_1(), and vrp_meet_1().
| bool is_gimple_min_lval | ( | ) |
Return true if T is a GIMPLE minimal lvalue.
| bool is_gimple_reg | ( | ) |
Return true if T is a non-aggregate register variable.
A volatile decl is not acceptable because we can't reuse it as needed. We need to copy it into a temp first.
We define "registers" as things that can be renamed as needed, which with our infrastructure does not apply to memory.
Hard register variables are an interesting case. For those that are call-clobbered, we don't know where all the calls are, since we don't (want to) take into account which operations will turn into libcalls at the rtl level. For those that are call-saved, we don't currently model the fact that calls may in fact change global hard registers, nor do we examine ASM_CLOBBERS at the tree level, and so miss variable changes that might imply. All around, it seems safest to not do too much optimization with these at the tree level at all. We'll have to rely on the rtl optimizers to clean this up, as there we've got all the appropriate bits exposed.
Complex and vector values must have been put into SSA-like form. That is, no assignments to the individual components.
Referenced by adjust_return_value(), build1_stat(), generic_expr_could_trap_p(), initialize_parameter_reductions(), is_gimple_ip_invariant(), non_rewritable_mem_ref_base(), num_imm_uses(), op_iter_init_phidef(), op_iter_next_def(), remap_vla_decls(), rewrite_dom_walker::rewrite_dom_walker(), update_complex_components_on_edge(), vect_get_vec_defs_for_stmt_copy(), and walk_gimple_asm().
| bool is_gimple_val | ( | ) |
Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant.
Make loads from volatiles and memory vars explicit.
References build2, TREE_CODE, TREE_OPERAND, and TREE_TYPE.
Referenced by dump_gimple_statistics(), find_loop_location(), gimple_call_flags(), is_gimple_min_invariant(), and ssa_prop_fini().
| bool is_gimple_variable | ( | ) |
Return true if T is a variable.
References handled_component_p(), and TREE_OPERAND.
Referenced by is_gimple_constant().
| bool nonfreeing_call_p | ( | ) |
Return true when CALL is a call stmt that definitely doesn't free any memory or makes it unavailable otherwise.
Just in case these become ECF_LEAF in the future.
| void recalculate_side_effects | ( | ) |
All of these have side-effects, no matter what their operands are.
Fall through.
No side-effects.
References BITS_PER_UNIT, DECL_FIELD_BIT_OFFSET, DECL_FIELD_OFFSET, HOST_WIDE_INT, and TREE_INT_CST_LOW.
| bool types_compatible_p | ( | ) |
Return true if a conversion from either type of TYPE1 and TYPE2 to the other is not required. Otherwise return false.
Referenced by gimplify_omp_task(), propagate_with_phi(), and vect_init_vector_1().
| bool useless_type_conversion_p | ( | ) |
Return true if the conversion from INNER_TYPE to OUTER_TYPE is a useless type conversion, otherwise return false.
This function implicitly defines the middle-end type system. With the notion of 'a < b' meaning that useless_type_conversion_p (a, b) holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds, the following invariants shall be fulfilled:
1) useless_type_conversion_p is transitive. If a < b and b < c then a < c.
2) useless_type_conversion_p is not symmetric. From a < b does not follow a > b.
3) Types define the available set of operations applicable to values. A type conversion is useless if the operations for the target type is a subset of the operations for the source type. For example casts to void* are useless, casts from void* are not (void* can't be dereferenced or offsetted, but copied, hence its set of operations is a strict subset of that of all other data pointer types). Casts to const T* are useless (can't be written to), casts from const T* to T* are not.
Do the following before stripping toplevel qualifiers.
Do not lose casts between pointers to different address spaces.
From now on qualifiers on value types do not matter.
If we know the canonical types, compare them.
Changes in machine mode are never useless conversions unless we deal with aggregate types in which case we defer to later checks.
If both the inner and outer types are integral types, then the conversion is not necessary if they have the same mode and signedness and precision, and both or neither are boolean.
Preserve changes in signedness or precision.
Preserve conversions to/from BOOLEAN_TYPE if types are not
of precision one. We don't need to preserve changes in the types minimum or
maximum value in general as these do not generate code
unless the types precisions are different. Scalar floating point types with the same mode are compatible.
Fixed point types with the same mode are compatible.
We need to take special care recursing to pointed-to types.
Do not lose casts to function pointer types.
We do not care for const qualification of the pointed-to types
as const qualification has no semantic value to the middle-end. Otherwise pointers/references are equivalent.
Recurse for complex types.
Recurse for vector types with the same number of subparts.
Preserve string attributes.
Conversions from array types with unknown extent to
array types with known extent are not useless. Nor are conversions from array types with non-constant size to
array types with constant size or to different size. Check conversions between arrays with partially known extents.
If the array min/max values are constant they have to match.
Otherwise allow conversions to unknown and variable extents.
In particular this declares conversions that may change the
mode to BLKmode as useless. After gimplification a variable min/max value carries no
additional information compared to a NULL value. All that
matters has been lowered to be part of the IL. Conversions NULL / variable <- cst are useless, but not
the other way around. Recurse on the element check.
If the return types are not compatible bail out.
Method types should belong to a compatible base class.
A conversion to an unprototyped argument list is ok.
If the unqualified argument types are compatible the conversion
is useless. If there is a mismatch in the number of arguments the functions
are not compatible. Defer to the target if necessary.
For aggregates we rely on TYPE_CANONICAL exclusively and require explicit conversions for types involving to be structurally compared types.
Referenced by build_access_from_expr_1(), copy_debug_stmts(), create_mem_ref(), expand_omp_sections(), generate_subtree_copies(), gimple_asm_clobbers_memory_p(), gimple_get_virt_method_for_binfo(), gimplify_init_ctor_eval(), gimplify_modify_expr_complex_part(), gimplify_switch_expr(), instrument_builtin_call(), ipa_load_from_parm_agg(), ipa_modify_call_arguments(), replace_ref(), sra_modify_expr(), and tree_nrv().
|
static |
Return true when STMTs arguments match those of FNDECL.
Variadic args follow.
References TYPE_DOMAIN, TYPE_MAX_VALUE, and TYPE_MIN_VALUE.
| bool virtual_operand_p | ( | ) |
Return true if OP, an SSA name or a DECL is a virtual operand.
References tcc_expression, TREE_CODE, TREE_CODE_CLASS, and TREE_OPERAND_LENGTH.
Referenced by build_new_reduction(), calculate_live_on_exit(), create_loop_fn(), deps_ok_for_redirect(), do_partial_partial_insertion(), find_givs_in_bb(), find_uses_to_rename_stmt(), group_case_labels(), maybe_register_def(), process_assert_insertions(), pt_solution_includes_1(), register_edge_assert_for(), replace_phi_args_in(), scev_finalize(), scev_reset(), and vect_can_advance_ivs_p().
|
static |
Helper function for walk_gimple_stmt. Walk operands of a GIMPLE_ASM.
Although input "m" is not really a LHS, we need a lvalue.
References gimple_assign_lhs(), gimple_assign_rhs1(), gimple_assign_rhs_class(), gimple_call_arg(), gimple_call_arg_ptr(), gimple_call_chain_ptr(), gimple_call_fn_ptr(), gimple_call_lhs(), gimple_call_lhs_ptr(), gimple_call_num_args(), gimple_num_ops(), gimple_op_ptr(), GIMPLE_SINGLE_RHS, is_gimple_reg(), is_gimple_reg_type(), walk_stmt_info::is_lhs, TREE_TYPE, walk_stmt_info::val_only, and walk_tree.
| 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
| int gimple_alloc_counts[(int) gimple_alloc_kind_all] |
Gimple stats.
Referenced by gimple_alloc_stat().
|
static |
Keep in sync with gimple.h:enum gimple_alloc_kind.
| int gimple_alloc_sizes[(int) gimple_alloc_kind_all] |
Referenced by gimple_alloc_stat().
| const char* const gimple_code_name[] |
Referenced by dump_gimple_fmt().
| EXPORTED_CONST size_t 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[] |
| EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] |
Map GIMPLE codes to GSS codes.
|
static |
Referenced by gimple_set_code().
