Go to the source code of this file.
Typedefs | |
| typedef struct alias_pair | alias_pair |
| typedef struct constructor_elt_d | constructor_elt |
| typedef struct ssa_use_operand_d | ssa_use_operand_t |
| typedef unsigned short | priority_type |
| typedef enum integer_type_kind | integer_type_kind |
| typedef struct record_layout_info_s * | record_layout_info |
| typedef tree(* | walk_tree_fn )(tree *, int *, void *) |
| typedef tree(* | walk_tree_lh )(tree *, int *, tree(*)(tree *, int *, void *), void *, struct pointer_set_t *) |
| typedef struct call_expr_arg_iterator_d | call_expr_arg_iterator |
| typedef struct const_call_expr_arg_iterator_d | const_call_expr_arg_iterator |
| typedef struct builtin_info_type_d | builtin_info_type |
Variables | |
| unsigned char | tree_contains_struct [MAX_TREE_CODES][64] |
| const char *const | tree_code_class_strings [] |
| enum tree_code_class | tree_code_type [] |
| const unsigned char | tree_code_length [] |
| const char *const | tree_code_name [] |
| vec< alias_pair, va_gc > * | alias_pairs |
| const char *const | built_in_class_names [4] |
| const char * | built_in_names [(int) END_BUILTINS] |
| unsigned const char | omp_clause_num_ops [] |
| const char *const | omp_clause_code_name [] |
| vec< tree, va_gc > * | all_translation_units |
| tree | global_trees [TI_MAX] |
| tree | integer_types [itk_none] |
| tree | sizetype_tab [(int) stk_type_kind_last] |
| unsigned int | maximum_field_alignment |
| int | pedantic_lvalues |
| tree | current_function_decl |
| const char * | current_function_func_begin_label |
| int | folding_initializer |
| bool | force_folding_builtin_constant_p |
| int | tree_node_counts [] |
| int | tree_node_sizes [] |
| bool | in_gimple_form |
| builtin_info_type | builtin_info |
Typedef Documentation
| typedef struct alias_pair alias_pair |
When procesing aliases on symtab level, we need the declaration of target. For this reason we need to queue aliases and process them after all declarations has been produced.
| typedef struct builtin_info_type_d builtin_info_type |
Functional interface to the builtin functions.
The builtin_info structure holds the FUNCTION_DECL of the standard builtin function, and a flag that says if the function is available implicitly, or whether the user has to code explicit calls to __builtin_<xxx>.
| typedef struct call_expr_arg_iterator_d call_expr_arg_iterator |
Abstract iterators for CALL_EXPRs. These static inline definitions have to go towards the end of tree.h so that union tree_node is fully defined by this point.
Structure containing iterator state.
| typedef struct const_call_expr_arg_iterator_d const_call_expr_arg_iterator |
| typedef struct constructor_elt_d constructor_elt |
A single element of a CONSTRUCTOR. VALUE holds the actual value of the element. INDEX can optionally design the position of VALUE: in arrays, it is the index where VALUE has to be placed; in structures, it is the FIELD_DECL of the member.
| typedef enum integer_type_kind integer_type_kind |
| typedef unsigned short priority_type |
An initialization priority.
| typedef struct record_layout_info_s * record_layout_info |
These functions allow a front-end to perform a manual layout of a RECORD_TYPE. (For instance, if the placement of subsequent fields depends on the placement of fields so far.) Begin by calling start_record_layout. Then, call place_field for each of the fields. Then, call finish_record_layout. See layout_type for the default way in which these functions are used.
| typedef struct ssa_use_operand_d ssa_use_operand_t |
Immediate use linking structure. This structure is used for maintaining a doubly linked list of uses of an SSA_NAME.
The type of a callback function for walking over tree structure.
| typedef tree(* walk_tree_lh)(tree *, int *, tree(*)(tree *, int *, void *), void *, struct pointer_set_t *) |
The type of a callback function that represents a custom walk_tree.
Enumeration Type Documentation
| enum attribute_flags |
| enum built_in_class |
| enum built_in_function |
| enum cv_qualifier |
| enum integer_type_kind |
An enumeration of the standard C integer types. These must be ordered so that shorter types appear before longer ones, and so that signed types appear before unsigned ones, for the correct functioning of interpret_integer() in c-lex.c.
| enum omp_clause_code |
Clause codes. Do not reorder, as this is used to index into the tables omp_clause_num_ops and omp_clause_code_name.
- Enumerator:
| enum operand_equal_flag |
A pointer-to-function member type looks like:
struct {
__P __pfn;
ptrdiff_t __delta;
};
If __pfn is NULL, it is a NULL pointer-to-member-function.
(Because the vtable is always the first thing in the object, we
don't need its offset.) If the function is virtual, then PFN is
one plus twice the index into the vtable; otherwise, it is just a
pointer to the function.
Unfortunately, using the lowest bit of PFN doesn't work in
architectures that don't impose alignment requirements on function
addresses, or that use the lowest bit to tell one ISA from another,
for example. For such architectures, we use the lowest bit of
DELTA instead of the lowest bit of the PFN, and DELTA will be
multiplied by 2.
| enum size_type_kind |
| enum symbol_visibility |
| enum tree_code |
| enum tree_code_class |
| enum tree_index |
Standard named or nameless data types of the C compiler.
- Enumerator:
| enum tree_node_kind |
Function Documentation
|
inline |
| bool addr_expr_of_non_mem_decl_p | ( | tree | ) |
Is it an ADDR_EXPR of a DECL that's not in memory?
| int aggregate_value_p | ( | const_tree | , |
| const_tree | |||
| ) |
| bool alloca_call_p | ( | const_tree | ) |
| int allocate_decl_uid | ( | void | ) |
Allocate and return a new UID from the DECL_UID namespace.
References next_decl_uid.
Referenced by build_fake_var_decl(), copy_node_stat(), and make_node_stat().
| void allocate_struct_function | ( | tree | , |
| bool | |||
| ) |
| bool array_at_struct_end_p | ( | tree | ) |
Return a tree of sizetype representing the size, in bytes, of the element of EXP, an ARRAY_REF or an ARRAY_RANGE_REF.
Return a tree representing the lower bound of the array mentioned in EXP, an ARRAY_REF or an ARRAY_RANGE_REF.
Return a tree representing the upper bound of the array mentioned in EXP, an ARRAY_REF or an ARRAY_RANGE_REF.
| tree array_type_nelts | ( | const_tree | ) |
Make one symbol an alias for another.
Referenced by asan_add_global(), and rest_of_decl_compilation().
| void assign_assembler_name_if_neeeded | ( | tree | ) |
| bool associative_tree_code | ( | enum | tree_code | ) |
| int attribute_list_contained | ( | const_tree | , |
| const_tree | |||
| ) |
| int attribute_list_equal | ( | const_tree | , |
| const_tree | |||
| ) |
| bool auto_var_in_fn_p | ( | const_tree | , |
| const_tree | |||
| ) |
| bool avoid_folding_inline_builtin | ( | tree | ) |
| tree bit_position | ( | const_tree | ) |
| bool block_may_fallthru | ( | const_tree | ) |
In gimple-low.c.
| location_t* block_nonartificial_location | ( | tree | ) |
| tree block_ultimate_origin | ( | const_tree | ) |
|
inlinestatic |
_loc versions of build[1-5].
Referenced by fold_build1_stat_loc().
|
inlinestatic |
Referenced by fold_build2_stat_loc().
|
inlinestatic |
Referenced by fold_build3_stat_loc().
|
inlinestatic |
|
inlinestatic |
| tree build_call_array_loc | ( | location_t | loc, |
| tree | return_type, | ||
| tree | fn, | ||
| int | nargs, | ||
| const tree * | args | ||
| ) |
Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and FN and a null static chain slot. NARGS is the number of call arguments which are specified as a tree array ARGS.
References build_call_1(), and process_call_operands().
Referenced by fold_builtin_call_array(), gimple_fold_stmt_to_constant_1(), and gimplify_call_expr().
| tree build_call_expr_loc | ( | location_t | , |
| tree | , | ||
| int | , | ||
| ... | |||
| ) |
| tree build_call_expr_loc_array | ( | location_t | , |
| tree | , | ||
| int | , | ||
| tree * | |||
| ) |
| void build_common_builtin_nodes | ( | void | ) |
Call this function after instantiating all builtins that the language front end cares about. This will build the rest of the builtins that are relied upon by the tree optimizers and the middle-end.
References build_function_type(), build_function_type_list(), BUILT_IN_COMPLEX_DIV_MIN, BUILT_IN_COMPLEX_MUL_MIN, built_in_names, builtin_decl_explicit(), builtin_decl_explicit_p(), local_define_builtin(), targetm, type(), lang_hooks_for_types::type_for_mode, lang_hooks::types, and UI_SJLJ.
| void build_common_tree_nodes | ( | bool | , |
| bool | |||
| ) |
| tree build_constructor | ( | tree | , |
| vec< constructor_elt, va_gc > * | |||
| ) |
| tree build_decl_stat | ( | location_t | , |
| enum | tree_code, | ||
| tree | , | ||
| tree | MEM_STAT_DECL | ||
| ) |
This is in tree-inline.c since the routine uses data structures from the inliner.
| tree build_empty_stmt | ( | location_t | ) |
| tree build_fold_addr_expr_loc | ( | location_t | , |
| tree | |||
| ) |
| tree build_fold_addr_expr_with_type_loc | ( | location_t | , |
| tree | , | ||
| tree | |||
| ) |
| tree build_fold_indirect_ref_loc | ( | location_t | , |
| tree | |||
| ) |
Build variant of function decl ORIG_DECL skipping ARGS_TO_SKIP and the return value if SKIP_RETURN is true. Arguments from DECL_ARGUMENTS list can't be removed now, since they are linked by TREE_CHAIN directly. The caller is responsible for eliminating them when they are being duplicated (i.e. copy_arguments_for_versioning).
References bitmap_bit_p(), bitmap_empty_p(), build_function_type_skip_args(), copy_node(), NOT_BUILT_IN, and prototype_p().
Referenced by cgraph_create_virtual_clone(), and cgraph_function_versioning().
| tree build_int_cst | ( | tree | , |
| HOST_WIDE_INT | |||
| ) |
| tree build_int_cst_type | ( | tree | , |
| HOST_WIDE_INT | |||
| ) |
| tree build_int_cst_wide | ( | tree | , |
| unsigned | HOST_WIDE_INT, | ||
| HOST_WIDE_INT | |||
| ) |
|
inlinestatic |
Create an INT_CST node with a CST value zero extended.
Referenced by build_fn_info(), build_info(), do_jump(), fold_builtin_object_size(), fold_builtin_sprintf_chk_1(), infer_loop_bounds_from_pointer_arith(), and maybe_emit_sprintf_chk_warning().
| tree build_invariant_address | ( | tree | , |
| tree | , | ||
| HOST_WIDE_INT | |||
| ) |
Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE) and ARGTYPES (a TREE_LIST) are the return type and arguments types for the method. An implicit additional parameter (of type pointer-to-BASETYPE) is added to the ARGTYPES.
References build_method_type_directly(), build_pointer_type(), layout_type(), maybe_canonicalize_argtypes(), type_hash_canon(), and type_hash_list().
Referenced by build_method_type(), build_method_type_directly(), and reconstruct_complex_type().
| tree build_nonstandard_integer_type | ( | unsigned HOST_WIDE_INT | precision, |
| int | unsignedp | ||
| ) |
Builds a signed or unsigned integer type of precision PRECISION. Used for C bitfields whose precision does not match that of built-in target types.
References fixup_signed_type(), fixup_unsigned_type(), host_integerp(), nonstandard_integer_type_cache, tree_low_cst(), and type_hash_canon().
Referenced by adjust_bool_pattern(), analyze_access_subtree(), asan_finish_file(), asan_global_struct(), build_check_stmt(), build_common_tree_nodes(), build_range_check(), canonicalize_loop_ivs(), check_bool_pattern(), convert_affine_scev(), convert_mult_to_widen(), convert_plusminus_to_widen(), do_compare(), expand_vector_divmod(), extract_omp_for_data(), fold_builtin_alloca_with_align(), get_vectype_for_scalar_type_and_size(), gimple_signed_or_unsigned_type(), initialize_sanitizer_builtins(), make_bit_field_ref(), max_precision_type(), output_constructor(), prepare_instrumented_value(), register_edge_assert_for_2(), signed_or_unsigned_type_for(), simplify_float_conversion_using_ranges(), simplify_vector_constructor(), type_for_interval(), vect_handle_widen_op_by_const(), vect_operation_fits_smaller_type(), vect_recog_divmod_pattern(), vect_recog_mixed_size_cond_pattern(), vectorizable_condition(), and vectorizable_conversion().
| tree build_nt | ( | enum | tree_code, |
| ... | |||
| ) |
Construct various types of nodes.
| tree build_omp_clause | ( | location_t | , |
| enum | omp_clause_code | ||
| ) |
| tree build_optimization_node | ( | void | ) |
Return a tree node that encapsulates the current optimization options.
Build an OPTIMIZATION_NODE based on the current options.
References cl_optimization_node, and cl_option_hash_table.
Referenced by process_options().
| tree build_personality_function | ( | const char * | ) |
Constructors for pointer, array and function types. (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are constructed by language-dependent code, not here.)
Construct, lay out and return the type of pointers to TO_TYPE with mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can reference all of memory. If such a type has already been constructed, reuse it.
References build_pointer_type_for_mode(), layout_type(), and lookup_attribute().
Referenced by build_pointer_type(), build_pointer_type_for_mode(), build_type_no_quals(), expand_builtin_sincos(), expand_omp_atomic_pipeline(), fold_builtin_memcmp(), fold_builtin_memory_op(), fold_builtin_strcmp(), fold_builtin_strncmp(), reconstruct_complex_type(), remap_type_1(), and vect_create_data_ref_ptr().
Like get_qualified_type, but creates the type if it does not exist. This function never returns NULL_TREE.
Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result type, TYPE, return an expression to test if EXP is in (or out of, depending on IN_P) the range. Return 0 if the test couldn't be created.
References build_int_cst(), build_nonstandard_integer_type(), build_range_check(), const_binop(), fold_build_pointer_plus_loc(), fold_convert_loc(), HOST_BITS_PER_WIDE_INT, HOST_WIDE_INT, HOST_WIDE_INT_M1U, integer_onep(), integer_zerop(), invert_truthvalue_loc(), operand_equal_p(), range_binop(), signed_type_for(), lang_hooks_for_types::type_for_size, lang_hooks::types, and unsigned_type_for().
Referenced by build_range_check(), fold_div_compare(), fold_range_test(), and update_range_test().
| tree build_real_from_int_cst | ( | tree | , |
| const_tree | |||
| ) |
Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.
References build_reference_type_for_mode(), layout_type(), and lookup_attribute().
Referenced by build_reference_type(), build_reference_type_for_mode(), build_type_no_quals(), reconstruct_complex_type(), and remap_type_1().
| tree build_simple_mem_ref_loc | ( | location_t | , |
| tree | |||
| ) |
| tree build_string | ( | int | , |
| const char * | |||
| ) |
| tree build_string_literal | ( | int | , |
| const char * | |||
| ) |
| tree build_target_option_node | ( | void | ) |
Return a tree node that encapsulates the current target options.
Build a TARGET_OPTION_NODE based on the current options.
References cl_option_hash_table, and cl_target_option_node.
| tree build_tm_abort_call | ( | location_t | , |
| bool | |||
| ) |
In trans-mem.c.
Return a type like TTYPE except that its TYPE_ATTRIBUTES is ATTRIBUTE. Such modified types already made are recorded so that duplicates are not made.
| tree build_vector_from_ctor | ( | tree | , |
| vec< constructor_elt, va_gc > * | |||
| ) |
| tree build_vl_exp_stat | ( | enum | tree_code, |
| int | MEM_STAT_DECL | ||
| ) |
|
inlinestatic |
Return the tree node for an explicit standard builtin function or NULL.
Referenced by build_builtin_expect_predicate(), build_common_builtin_nodes(), build_omp_barrier(), build_tm_abort_call(), build_tm_load(), build_tm_store(), emit_call_1(), emutls_common_1(), execute_optimize_bswap(), expand_assign_tm(), expand_builtin_atomic_fetch_op(), expand_builtin_cexpi(), expand_builtin_memory_chk(), expand_call_tm(), expand_complex_libcall(), expand_omp_atomic_fetch_op(), expand_omp_atomic_load(), expand_omp_atomic_mutex(), expand_omp_atomic_pipeline(), expand_omp_atomic_store(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_sections(), expand_parallel_call(), expand_task_call(), expand_transaction(), find_tm_replacement_function(), fold_builtin_classify(), fold_builtin_fprintf(), fold_builtin_fputs(), fold_builtin_interclass_mathfn(), fold_builtin_memory_chk(), fold_builtin_printf(), fold_builtin_snprintf(), fold_builtin_snprintf_chk_1(), fold_builtin_sprintf_chk_1(), fold_builtin_strcat_chk(), fold_builtin_strncat_chk(), fold_builtin_stxcpy_chk(), fold_builtin_stxncpy_chk(), generate_tm_state(), get_string_length(), gimplify_parameters(), gimplify_vla_decl(), handle_builtin_strcat(), handle_builtin_strcpy(), ipa_tm_insert_gettmclone_call(), ipa_tm_insert_irr_call(), issue_prefetch_ref(), iterative_hash_expr(), lower_emutls_function_body(), lower_omp_critical(), lower_omp_master(), lower_omp_ordered(), lower_omp_single_copy(), lower_omp_single_simple(), lower_rec_input_clauses(), lower_reduction_clauses(), lower_transaction(), mathfn_built_in_1(), maybe_catch_exception(), optimize_omp_library_calls(), optimize_stdarg_builtin(), set_builtin_user_assembler_name(), simplify_builtin_call(), streamer_get_builtin_tree(), tm_log_emit_stmt(), tm_malloc_replacement(), and tm_memopt_transform_stmt().
|
inlinestatic |
Return whether the standard builtin function can be used as an explicit function.
Referenced by build_common_builtin_nodes(), execute_optimize_bswap(), iterative_hash_expr(), optimize_stdarg_builtin(), and tree_ssa_prefetch_arrays().
|
inlinestatic |
Return the tree node for an implicit builtin function or NULL.
Referenced by asan_finish_file(), build_stack_save_restore(), convert_nl_goto_reference(), convert_tramp_reference_op(), execute_fixup_cfg(), expand_builtin_mempcpy_args(), expand_builtin_stpcpy(), expand_builtin_sync_operation(), finalize_nesting_tree_1(), fold_builtin_2(), fold_builtin_fprintf(), fold_builtin_fputs(), fold_builtin_memory_op(), fold_builtin_printf(), fold_builtin_snprintf(), fold_builtin_sprintf(), fold_builtin_stpcpy(), fold_builtin_strcat(), fold_builtin_strcpy(), fold_builtin_strcspn(), fold_builtin_strncat(), fold_builtin_strncpy(), fold_builtin_strpbrk(), fold_builtin_strrchr(), fold_builtin_strstr(), generate_memcpy_builtin(), generate_memset_builtin(), get_memory_access_decl(), get_string_length(), gimplify_function_tree(), gimplify_modify_expr_to_memcpy(), gimplify_modify_expr_to_memset(), gimplify_va_arg_expr(), gimplify_variable_sized_compare(), handle_builtin_strcat(), handle_builtin_strcpy(), instrument_builtin_call(), instrument_expr(), instrument_func_entry(), instrument_func_exit(), instrument_gimple(), ipa_make_edge_direct_to_target(), lower_builtin_setjmp(), lower_eh_dispatch(), lower_function_body(), lower_resx(), maybe_instrument_call(), remove_exits_and_undefined_stmts(), report_error_func(), tsan_finish_file(), and unloop_loops().
|
inlinestatic |
Return whether the standard builtin function can be used implicitly.
Referenced by expand_builtin_mempcpy_args(), get_string_length(), handle_builtin_strcat(), handle_builtin_strcpy(), initialize_sanitizer_builtins(), and mathfn_built_in_1().
| enum built_in_function builtin_mathfn_code | ( | const_tree | ) |
| rtx builtin_memset_read_str | ( | void * | data, |
| HOST_WIDE_INT | offset, | ||
| enum machine_mode | mode | ||
| ) |
Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE) bytes from constant string DATA + OFFSET and return it as target constant.
References c_readstr(), and memset().
Referenced by expand_builtin_memset_args(), and gimple_stringops_transform().
| tree byte_position | ( | const_tree | ) |
| void cache_integer_cst | ( | tree | ) |
| int call_expr_flags | ( | const_tree | ) |
| int can_move_by_pieces | ( | unsigned HOST_WIDE_INT | len, |
| unsigned int | align | ||
| ) |
In expr.c.
Determine whether the LEN bytes can be moved by using several move instructions. Return nonzero if a call to move_by_pieces should succeed.
Determine whether the LEN bytes can be moved by using several move instructions. Return nonzero if a call to move_by_pieces should succeed.
References len.
Referenced by expand_builtin_mempcpy_args(), gimple_stringops_transform(), and gimplify_init_constructor().
| bool categorize_ctor_elements | ( | const_tree | ctor, |
| HOST_WIDE_INT * | p_nz_elts, | ||
| HOST_WIDE_INT * | p_init_elts, | ||
| bool * | p_complete | ||
| ) |
Examine CTOR to discover:
* how many scalar fields are set to nonzero values,
and place it in *P_NZ_ELTS;
* how many scalar fields in total are in CTOR,
and place it in *P_ELT_COUNT.
* whether the constructor is complete -- in the sense that every
meaningful byte is explicitly given a value --
and place it in *P_COMPLETE.
Return whether or not CTOR is a valid static constant initializer, the same
as "initializer_constant_valid_p (CTOR, TREE_TYPE (CTOR)) != 0".
References categorize_ctor_elements_1().
Referenced by all_zeros_p(), gimplify_init_constructor(), and mostly_zeros_p().
| int chain_member | ( | const_tree | , |
| const_tree | |||
| ) |
Concatenate two lists (chains of TREE_LIST nodes) X and Y by making the last node in X point to Y. Returns X, except if X is 0 returns Y.
| bool check_qualified_type | ( | const_tree | , |
| const_tree | , | ||
| int | |||
| ) |
Check whether CAND is suitable to be returned from get_qualified_type (BASE, TYPE_QUALS).
| void clean_symbol_name | ( | char * | ) |
| tree combine_comparisons | ( | location_t | loc, |
| enum tree_code | code, | ||
| enum tree_code | lcode, | ||
| enum tree_code | rcode, | ||
| tree | truth_type, | ||
| tree | ll_arg, | ||
| tree | lr_arg | ||
| ) |
Return a tree for the comparison which is the combination of doing the AND or OR (depending on CODE) of the two operations LCODE and RCODE on the identical operands LL_ARG and LR_ARG. Take into account the possibility of trapping if the mode has NaNs, and return NULL_TREE if this makes the transformation invalid.
References comparison_to_compcode(), COMPCODE_EQ, COMPCODE_FALSE, COMPCODE_LTGT, COMPCODE_NE, COMPCODE_ORD, compcode_to_comparison(), COMPCODE_TRUE, COMPCODE_UNORD, and constant_boolean_node().
Referenced by and_comparisons_1(), fold_truth_andor_1(), and or_comparisons_1().
| bool commutative_ternary_tree_code | ( | enum | tree_code | ) |
| bool commutative_tree_code | ( | enum | tree_code | ) |
| int comp_type_attributes | ( | const_tree | , |
| const_tree | |||
| ) |
Return 0 if the attributes for two types are incompatible, 1 if they are compatible, and 2 if they are nearly compatible (which causes a warning to be generated).
| int compare_tree_int | ( | const_tree | , |
| unsigned | HOST_WIDE_INT | ||
| ) |
| bool complete_ctor_at_level_p | ( | const_tree | type, |
| HOST_WIDE_INT | num_elts, | ||
| const_tree | last_type | ||
| ) |
TYPE is initialized by a constructor with NUM_ELTS elements, the last of which had type LAST_TYPE. Each element was itself a complete initializer, in the sense that every meaningful byte was explicitly given a value. Return true if the same is true for the constructor as a whole.
References count_type_elements(), and simple_cst_equal().
Referenced by categorize_ctor_elements_1().
Return a tree representing the offset, in bytes, of the field referenced by EXP. This does not include any offset in DECL_FIELD_BIT_OFFSET.
| unsigned HOST_WIDE_INT compute_builtin_object_size | ( | tree | , |
| int | |||
| ) |
| void compute_record_mode | ( | tree | ) |
| bool constructor_static_from_elts_p | ( | const_tree | ) |
Whether a constructor CTOR is a valid static constant initializer if all its elements are. This used to be internal to initializer_constant_valid_p and has been exposed to let other functions like categorize_ctor_elements evaluate the property while walking a constructor for other purposes.
Referenced by categorize_ctor_elements_1(), and initializer_constant_valid_p_1().
| bool contains_bitfld_component_ref_p | ( | const_tree | ) |
| bool contains_placeholder_p | ( | const_tree | ) |
Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a size or offset that depends on a field within a record.
|
inline |
Referenced by convert_to_complex(), convert_to_fixed(), convert_to_integer(), and convert_to_real().
|
inlinestatic |
Return OFF converted to a pointer offset type suitable as offset for POINTER_PLUS_EXPR. Use location LOC for this conversion.
Referenced by gimplify_self_mod_expr().
| unsigned crc32_byte | ( | unsigned | , |
| char | |||
| ) |
| unsigned crc32_string | ( | unsigned | , |
| const char * | |||
| ) |
In tree.c
| unsigned crc32_unsigned | ( | unsigned | , |
| unsigned | |||
| ) |
| tree create_artificial_label | ( | location_t | ) |
| bool cst_and_fits_in_hwi | ( | const_tree | ) |
Given a CONSTRUCTOR CTOR, return the element values as a vector.
| bool cxx11_attribute_p | ( | const_tree | ) |
| void debug | ( | const tree_node & | ref | ) |
| void debug | ( | const tree_node * | ptr | ) |
| void debug_body | ( | const tree_node & | ref | ) |
| void debug_body | ( | const tree_node * | ptr | ) |
| void debug_fold_checksum | ( | const_tree | ) |
| void debug_head | ( | const tree_node & | ref | ) |
| void debug_head | ( | const tree_node * | ptr | ) |
| void debug_raw | ( | const tree_node & | ref | ) |
| void debug_raw | ( | const tree_node * | ptr | ) |
| void debug_tree | ( | tree | ) |
In print-tree.c
| void debug_verbose | ( | const tree_node & | ref | ) |
| void debug_verbose | ( | const tree_node * | ptr | ) |
| bool decl_address_invariant_p | ( | const_tree | ) |
| bool decl_address_ip_invariant_p | ( | const_tree | ) |
| bool decl_assembler_name_equal | ( | tree | decl, |
| const_tree | asmname | ||
| ) |
| hashval_t decl_assembler_name_hash | ( | const_tree | asmname | ) |
Process the attributes listed in ATTRIBUTES and install them in *NODE, which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL, it should be modified in place; if a TYPE, a copy should be created unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further information, in the form of a bitwise OR of flags in enum attribute_flags from tree.h. Depending on these flags, some attributes may be returned to be applied at a later stage (for example, to apply a decl attribute to the declaration rather than to its type).
| bool decl_binds_to_current_def_p | ( | tree | ) |
| enum tls_model decl_default_tls_model | ( | const_tree | ) |
Referenced by init_ic_make_global_vars().
| void decl_fini_priority_insert | ( | tree | , |
| priority_type | |||
| ) |
| priority_type decl_fini_priority_lookup | ( | tree | ) |
| tree decl_function_context | ( | const_tree | ) |
Return the FUNCTION_DECL which provides this _DECL with its context, or zero if none.
| void decl_init_priority_insert | ( | tree | , |
| priority_type | |||
| ) |
| priority_type decl_init_priority_lookup | ( | tree | ) |
| bool decl_replaceable_p | ( | tree | ) |
| tree decl_type_context | ( | const_tree | ) |
Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides this _DECL with its context, or zero if none.
| void declare_weak | ( | tree | ) |
Declare DECL to be a weak symbol.
| tree div_if_zero_remainder | ( | enum | tree_code, |
| const_tree | , | ||
| const_tree | |||
| ) |
| bool double_int_fits_to_tree_p | ( | const_tree | , |
| double_int | |||
| ) |
| tree double_int_to_tree | ( | tree | , |
| double_int | |||
| ) |
| void dump_addr | ( | FILE * | , |
| const char * | , | ||
| const void * | |||
| ) |
| void dump_tree_statistics | ( | void | ) |
Print debugging information about tree nodes generated during the compile, and any language-specific information.
References all_kinds, MAX_TREE_CODES, phinodes_print_statistics(), print_debug_expr_statistics(), lang_hooks::print_statistics, print_type_hash_statistics(), print_value_expr_statistics(), ssanames_print_statistics(), tree_code_counts, tree_code_name, tree_node_counts, tree_node_kind_names, and tree_node_sizes.
Referenced by dump_memory_report().
| unsigned int element_precision | ( | const_tree | ) |
| void expand_asm_stmt | ( | gimple | ) |
| void expand_computed_goto | ( | tree | ) |
In stmt.c
| void expand_dummy_function_end | ( | void | ) |
Undo the effects of init_dummy_function_start.
References cfun, end_sequence(), free_after_compilation(), free_after_parsing(), in_dummy_function, in_sequence_p(), and pop_cfun().
Referenced by backend_init_target(), and lang_dependent_init_target().
| void expand_function_end | ( | void | ) |
Generate RTL for the end of the current function.
References anti_adjust_stack_and_probe(), build_pointer_type(), function::calls_alloca, function::can_throw_non_call_exceptions, cfun, clear_pending_stack_adjust(), clobber_return_register(), convert_move(), current_function_decl, do_pending_stack_adjust(), emit_group_load(), emit_group_move(), emit_insn(), emit_insn_after(), emit_insn_before(), emit_label(), emit_move_insn(), emit_stack_restore(), emit_stack_save(), end_sequence(), expand_eh_return(), gen_blockage(), gen_reg_rtx(), gen_rtx_REG(), generating_concat_p, GENERIC_STACK_CHECK, get_arg_pointer_save_area(), get_insns(), get_last_insn(), in_sequence_p(), input_location, int_size_in_bytes(), probe_stack_range(), prologue_location, promote_function_mode(), function::returns_pcc_struct, function::returns_struct, SAVE_FUNCTION, set_curr_insn_location(), set_insn_locations(), shift_return_value(), sjlj_emit_function_exit_after(), stack_protect_epilogue(), start_sequence(), targetm, UI_SJLJ, and use_return_register().
Referenced by construct_exit_block().
| void expand_function_start | ( | tree | ) |
| void expand_goto | ( | tree | ) |
| void expand_label | ( | tree | ) |
In stmt.c
| void expand_main_function | ( | void | ) |
In function.c
References emit_library_call(), init_one_libfunc(), and LCT_NORMAL.
Referenced by gimple_expand_cfg().
| void expand_return | ( | tree | ) |
| void expand_stack_restore | ( | tree | ) |
| rtx expand_stack_save | ( | void | ) |
Emit code to save the current value of stack.
References do_pending_stack_adjust(), emit_stack_save(), and SAVE_BLOCK.
Referenced by expand_builtin().
| unsigned int expr_align | ( | const_tree | ) |
|
inline |
These checks have to be special cased.
| int fields_length | ( | const_tree | ) |
Returns the number of FIELD_DECLs in a type.
| void finalize_size_functions | ( | void | ) |
Take, queue and compile all the size functions. It is essential that the size functions be gimplified at the very end of the compilation in order to guarantee transparent handling of self-referential sizes. Otherwise the GENERIC inliner would not be able to inline them back at each of their call sites, thus creating artificial non-constant size expressions which would trigger nasty problems later on.
References allocate_struct_function(), cgraph_finalize_function(), dump_function(), gimplify_function_tree(), set_cfun(), size_functions, TDI_generic, TDI_original, and vec_free().
Referenced by finalize_compilation_unit().
Given a tree EXP, find all occurrences of references to fields in a PLACEHOLDER_EXPR and place them in vector REFS without duplicates. Also record VAR_DECLs and CONST_DECLs. Note that we assume here that EXP contains only arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their argument list.
| void fini_object_sizes | ( | void | ) |
Destroy data structures after the object size computation.
References free(), object_size_info::object_size_type, and object_sizes.
Referenced by compute_object_sizes().
Finish up a builtin RECORD_TYPE. Give it a name and provide its fields. Optionally specify an alignment, and then lay it out.
Finish processing a builtin RECORD_TYPE type TYPE. It's name is NAME, its fields are chained in reverse on FIELDS. If ALIGN_TYPE is non-null, it is given the same alignment as ALIGN_TYPE.
References get_identifier(), layout_decl(), layout_type(), and type().
Referenced by build_fn_info_type(), and build_info_type().
| void finish_record_layout | ( | record_layout_info | , |
| int | |||
| ) |
|
inlinestatic |
Initialize the abstract argument list iterator object ITER, then advance
past and return the first argument. Useful in for expressions, e.g.
for (arg = first_call_expr_arg (exp, &iter); arg;
arg = next_call_expr_arg (&iter))
Referenced by maybe_inline_call_in_expr().
|
inlinestatic |
Referenced by operand_equal_p(), and simple_cst_equal().
| tree first_field | ( | const_tree | ) |
Returns the first FIELD_DECL in a type.
| int fixed_zerop | ( | const_tree | ) |
fixed_zerop (tree x) is nonzero if X is a fixed-point constant of value 0.
| void fixup_signed_type | ( | tree | ) |
| void fixup_unsigned_type | ( | tree | ) |
| int flags_from_decl_or_type | ( | const_tree | ) |
Fold constants as much as possible in an expression. Returns the simplified expression. Acts only on the top level of the expression; if the argument itself cannot be simplified, its subexpressions are not changed.
Referenced by convert_to_real(), expand_expr_real_1(), expand_simple_operations(), fold_assignment_stmt(), fold_gimple_assign(), fold_mem_refs(), remove_range_assertions(), save_expr(), simplify_replace_tree(), substitute_in_expr(), substitute_placeholder_in_expr(), and verify_expr().
Fold a binary expression of code CODE and type TYPE with operands OP0 and OP1. LOC is the location of the resulting expression. Return the folded expression if folding is successful. Otherwise, return NULL_TREE.
References double_int::and_not(), associate_trees(), build_all_ones_cst(), build_call_expr_loc(), build_complex(), build_fold_indirect_ref_loc(), build_int_cst(), build_int_cst_type(), build_minus_one_cst(), build_one_cst(), build_real(), build_zero_cst(), BUILT_IN_NORMAL, builtin_mathfn_code(), commutative_tree_code(), compare_tree_int(), const_binop(), constant_boolean_node(), dconst1, dconst2, distribute_bit_expr(), distribute_real_division(), double_int_to_tree(), element_precision(), exact_inverse(), exact_log2(), double_int::ext(), extract_muldiv(), fold_addr_of_array_ref_difference(), fold_binary_loc(), fold_binary_op_with_conditional_arg(), fold_build_pointer_plus_loc(), fold_comparison(), fold_convert_const(), fold_convert_loc(), fold_minmax(), fold_mult_zconjz(), fold_negate_const(), fold_overflow_warning(), fold_plusminus_mult_expr(), fold_real_zero_addition_p(), fold_relational_const(), fold_single_bit_test_into_sign_test(), fold_strip_sign_ops(), fold_to_nonsharp_ineq_using_bound(), fold_truth_andor(), fold_unary_loc(), double_int::from_uhwi(), get_addr_base_and_unit_offset(), get_callee_fndecl(), get_pointer_modulus_and_residue(), handled_component_p(), double_int::high, HOST_BITS_PER_WIDE_INT, host_integerp(), HOST_WIDE_INT, HOST_WIDE_INT_M1U, in_gimple_form, int_const_binop(), integer_all_onesp(), integer_minus_onep(), integer_nonzerop(), integer_onep(), integer_pow2p(), integer_zerop(), inverse(), invert_truthvalue_loc(), double_int::is_zero(), lookup_attribute(), double_int::low, double_int::mask(), mathfn_built_in(), multiple_of_p(), negate_expr(), negate_expr_p(), non_lvalue_loc(), OEP_ONLY_CONST, omit_one_operand_loc(), omit_two_operands_loc(), operand_equal_p(), optimize_bit_field_compare(), pedantic_non_lvalue_loc(), ptr_difference_const(), real_arithmetic(), real_minus_onep(), real_onep(), real_zerop(), reorder_operands_p(), shift, sign_bit_p(), signed_type_for(), split_tree(), strip_float_extensions(), tcc_binary, tcc_comparison, double_int::trailing_zeros(), tree_expr_nonnegative_p(), tree_expr_nonnegative_warnv_p(), tree_expr_nonzero_p(), tree_int_cst_equal(), tree_int_cst_lt(), tree_int_cst_sgn(), tree_log2(), tree_low_cst(), tree_strip_nop_conversions(), tree_swap_operands_p(), tree_to_double_int(), truth_value_p(), try_move_mult_to_index(), type(), uniform_vector_p(), unsigned_type_for(), vec_cst_ctor_to_array(), WARN_STRICT_OVERFLOW_ALL, WARN_STRICT_OVERFLOW_CONDITIONAL, and WARN_STRICT_OVERFLOW_MISC.
Referenced by ccp_fold(), cleanup_control_expr_graph(), combine_cond_expr_cond(), copy_prop_visit_cond_stmt(), fold(), fold_addr_of_array_ref_difference(), fold_binary_loc(), fold_build2_stat_loc(), fold_cond_expr_cond(), fold_gimple_assign(), fold_gimple_cond(), fold_to_nonsharp_ineq_using_bound(), gimple_fold_stmt_to_constant_1(), optimize_stmt(), propagate_rhs_into_lhs(), and try_move_mult_to_index().
| tree fold_build1_initializer_loc | ( | location_t | , |
| enum | tree_code, | ||
| tree | , | ||
| tree | |||
| ) |
| tree fold_build1_stat_loc | ( | location_t | , |
| enum | tree_code, | ||
| tree | , | ||
| tree | MEM_STAT_DECL | ||
| ) |
| tree fold_build2_initializer_loc | ( | location_t | , |
| enum | tree_code, | ||
| tree | , | ||
| tree | , | ||
| tree | |||
| ) |
| tree fold_build2_stat_loc | ( | location_t | , |
| enum | tree_code, | ||
| tree | , | ||
| tree | , | ||
| tree | MEM_STAT_DECL | ||
| ) |
| tree fold_build_call_array_initializer_loc | ( | location_t | , |
| tree | , | ||
| tree | , | ||
| int | , | ||
| tree * | |||
| ) |
References fold_build_call_array_loc().
| tree fold_build_call_array_loc | ( | location_t | loc, |
| tree | type, | ||
| tree | fn, | ||
| int | nargs, | ||
| tree * | argarray | ||
| ) |
Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS arguments in ARGARRAY, and a null static chain. Return a folded expression if successful. Otherwise, return a CALL_EXPR of type TYPE from the given operands as constructed by build_call_array.
References hash_table< Descriptor, Allocator >::create(), fold_builtin_call_array(), fold_check_failed(), and fold_checksum_tree().
Referenced by fold_build_call_array_initializer_loc().
|
inlinestatic |
Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF.
Referenced by extract_omp_for_data(), fold_builtin_memchr(), fold_builtin_strchr(), fold_builtin_strpbrk(), fold_builtin_strrchr(), fold_builtin_strstr(), mf_xform_derefs_1(), and thunk_adjust().
|
inlinestatic |
Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF.
Referenced by build_addr_arg_loc(), build_range_check(), fold_binary_loc(), fold_builtin_memory_chk(), fold_builtin_memory_op(), fold_builtin_stpcpy(), fold_builtin_strcat(), fold_unary_loc(), mf_xform_derefs_1(), and thunk_adjust().
| tree fold_builtin_call_array | ( | location_t | loc, |
| tree | type, | ||
| tree | fn, | ||
| int | n, | ||
| tree * | argarray | ||
| ) |
Construct a CALL_EXPR with type TYPE with FN as the function expression. N arguments are passed in the array ARGARRAY.
References avoid_folding_inline_builtin(), build_call_array_loc(), BUILT_IN_MD, BUILT_IN_NORMAL, exp(), fold_builtin_n(), fold_builtin_varargs(), get_callee_fndecl(), and targetm.
Referenced by build_call_expr_loc_array(), and fold_build_call_array_loc().
| tree fold_builtin_fputs | ( | location_t | loc, |
| tree | arg0, | ||
| tree | arg1, | ||
| bool | ignore, | ||
| bool | unlocked, | ||
| tree | len | ||
| ) |
Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments to the call. IGNORE is true if the value returned by the builtin will be ignored. UNLOCKED is true is true if this actually a call to fputs_unlocked. If LEN in non-NULL, it represents the known length of the string. Return NULL_TREE if no simplification was possible.
References build_call_expr_loc(), build_int_cst(), builtin_decl_explicit(), builtin_decl_implicit(), c_getstr(), c_strlen(), cfun, compare_tree_int(), omit_one_operand_loc(), optimize_function_for_size_p(), and validate_arg().
Referenced by fold_builtin_2(), and gimple_fold_builtin().
| tree fold_builtin_memory_chk | ( | location_t | loc, |
| tree | fndecl, | ||
| tree | dest, | ||
| tree | src, | ||
| tree | len, | ||
| tree | size, | ||
| tree | maxlen, | ||
| bool | ignore, | ||
| enum built_in_function | fcode | ||
| ) |
Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
DEST, SRC, LEN, and SIZE are the arguments to the call.
IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
code of the builtin. If MAXLEN is not NULL, it is maximum length
passed as third argument.
References build_call_expr_loc(), builtin_decl_explicit(), fold_build_pointer_plus_loc(), fold_convert_loc(), host_integerp(), integer_all_onesp(), len, omit_one_operand_loc(), operand_equal_p(), tree_int_cst_lt(), and validate_arg().
Referenced by fold_builtin_4(), and gimple_fold_builtin().
| bool fold_builtin_next_arg | ( | tree | , |
| bool | |||
| ) |
| tree fold_builtin_snprintf_chk | ( | location_t | loc, |
| tree | exp, | ||
| tree | maxlen, | ||
| enum built_in_function | fcode | ||
| ) |
Fold a call EXP to {,v}snprintf. Return NULL_TREE if
a normal call should be emitted rather than expanding the function
inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
passed as second argument.
References fold_builtin_snprintf_chk_1().
Referenced by fold_builtin_varargs().
Fold function call to builtin strncpy with arguments DEST, SRC, and LEN. If SLEN is not NULL, it represents the length of the source string. Return NULL_TREE if no simplification can be made.
References build_call_expr_loc(), builtin_decl_implicit(), c_strlen(), fold_convert_loc(), integer_zerop(), omit_one_operand_loc(), size_binop_loc(), tree_int_cst_lt(), and validate_arg().
Referenced by fold_builtin_3(), and gimple_fold_builtin().
| tree fold_builtin_stxcpy_chk | ( | location_t | loc, |
| tree | fndecl, | ||
| tree | dest, | ||
| tree | src, | ||
| tree | size, | ||
| tree | maxlen, | ||
| bool | ignore, | ||
| enum built_in_function | fcode | ||
| ) |
Fold a call to the __st[rp]cpy_chk builtin. DEST, SRC, and SIZE are the arguments to the call. IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_* code of the builtin. If MAXLEN is not NULL, it is maximum length of strings passed as second argument.
References build_call_expr_loc(), build_int_cst(), builtin_decl_explicit(), c_strlen(), fold_convert_loc(), host_integerp(), integer_all_onesp(), len, operand_equal_p(), size_binop_loc(), tree_int_cst_lt(), and validate_arg().
Referenced by fold_builtin_3(), and gimple_fold_builtin().
| tree fold_builtin_stxncpy_chk | ( | location_t | loc, |
| tree | dest, | ||
| tree | src, | ||
| tree | len, | ||
| tree | size, | ||
| tree | maxlen, | ||
| bool | ignore, | ||
| enum built_in_function | fcode | ||
| ) |
Fold a call to the __st{r,p}ncpy_chk builtin. DEST, SRC, LEN, and SIZE
are the arguments to the call. If MAXLEN is not NULL, it is maximum
length passed as third argument. IGNORE is true if return value can be
ignored. FCODE is the BUILT_IN_* code of the builtin.
References build_call_expr_loc(), builtin_decl_explicit(), host_integerp(), integer_all_onesp(), len, tree_int_cst_lt(), and validate_arg().
Referenced by fold_builtin_4(), and gimple_fold_builtin().
| tree fold_call_expr | ( | location_t | , |
| tree | , | ||
| bool | |||
| ) |
| tree fold_convert_loc | ( | location_t | , |
| tree | , | ||
| tree | |||
| ) |
| bool fold_convertible_p | ( | const_tree | , |
| const_tree | |||
| ) |
| void fold_defer_overflow_warnings | ( | void | ) |
Start deferring overflow warnings. We could use a stack here to permit nested calls, but at present it is not necessary.
References fold_deferring_overflow_warnings.
Referenced by cleanup_control_expr_graph(), combine_cond_expr_cond(), estimate_numbers_of_iterations(), evaluate_stmt(), expand_simple_operations(), fold_cond_expr_cond(), fold_gimple_assign(), loop_niter_by_eval(), number_of_iterations_exit(), operand_less_p(), scev_probably_wraps_p(), simplify_binary_expression(), and simplify_control_stmt_condition().
| bool fold_deferring_overflow_warnings_p | ( | void | ) |
Whether we are deferring overflow warnings.
References fold_deferring_overflow_warnings.
Referenced by verify_interpass_invariants().
Fold a fma operation with arguments ARG[012].
References do_mpfr_arg3().
Referenced by fold_builtin_fma(), and fold_ternary_loc().
| tree fold_indirect_ref_1 | ( | location_t | , |
| tree | , | ||
| tree | |||
| ) |
| tree fold_indirect_ref_loc | ( | location_t | , |
| tree | |||
| ) |
| bool fold_real_zero_addition_p | ( | const_tree | , |
| const_tree | , | ||
| int | |||
| ) |
| tree fold_single_bit_test | ( | location_t | loc, |
| enum tree_code | code, | ||
| tree | arg0, | ||
| tree | arg1, | ||
| tree | result_type | ||
| ) |
If CODE with arguments ARG0 and ARG1 represents a single bit equality/inequality test, then return a simplified form of the test using shifts and logical operations. Otherwise return NULL. TYPE is the desired result type.
References build_int_cst(), compare_tree_int(), fold_convert_loc(), fold_single_bit_test_into_sign_test(), integer_pow2p(), integer_zerop(), tree_log2(), lang_hooks_for_types::type_for_mode, and lang_hooks::types.
Referenced by do_store_flag().
| tree fold_ternary_loc | ( | location_t | loc, |
| enum tree_code | code, | ||
| tree | type, | ||
| tree | op0, | ||
| tree | op1, | ||
| tree | op2 | ||
| ) |
Fold a ternary expression of code CODE and type TYPE with operands OP0, OP1, and OP2. Return the folded expression if folding is successful. Otherwise, return NULL_TREE.
References build_constructor(), build_int_cst(), build_zero_cst(), can_native_interpret_type_p(), changed, const_binop(), contains_label_p(), expr_location_or(), fold_cond_expr_with_comparison(), fold_convert_loc(), fold_fma(), fold_invert_truthvalue(), fold_vec_perm(), HOST_BITS_PER_WIDE_INT, host_integerp(), HOST_WIDE_INT, HOST_WIDE_INT_M1U, integer_all_onesp(), integer_onep(), integer_pow2p(), integer_zerop(), invert_truthvalue_loc(), len, native_encode_expr(), native_interpret_expr(), OEP_ONLY_CONST, operand_equal_for_comparison_p(), operand_equal_p(), pedantic_non_lvalue_loc(), pedantic_omit_one_operand_loc(), sign_bit_p(), signed_type_for(), tree_log2(), tree_low_cst(), tree_swap_operands_p(), truth_value_p(), type_contains_placeholder_p(), unsigned_type_for(), and vec_alloc().
Referenced by fold(), fold_build3_stat_loc(), fold_gimple_assign(), gimple_fold_stmt_to_constant_1(), and maybe_fold_reference().
| tree fold_unary_ignore_overflow_loc | ( | location_t | loc, |
| enum tree_code | code, | ||
| tree | type, | ||
| tree | op0 | ||
| ) |
If the operation was a conversion do _not_ mark a resulting constant with TREE_OVERFLOW if the original constant was not. These conversions have implementation defined behavior and retaining the TREE_OVERFLOW flag here would confuse later passes such as VRP.
References fold_unary_loc().
Referenced by gimple_fold_stmt_to_constant_1().
| tree fold_unary_loc | ( | location_t | , |
| enum | tree_code, | ||
| tree | , | ||
| tree | |||
| ) |
| void fold_undefer_and_ignore_overflow_warnings | ( | void | ) |
Stop deferring overflow warnings, ignoring any deferred warnings.
References fold_undefer_overflow_warnings().
Referenced by cleanup_control_expr_graph(), estimate_numbers_of_iterations(), expand_simple_operations(), loop_niter_by_eval(), number_of_iterations_exit(), operand_less_p(), and scev_probably_wraps_p().
| void fold_undefer_overflow_warnings | ( | bool | , |
| const_gimple | , | ||
| int | |||
| ) |
| tree force_fit_type_double | ( | tree | type, |
| double_int | cst, | ||
| int | overflowable, | ||
| bool | overflowed | ||
| ) |
We force the double_int CST to the range of the type TYPE by sign or
zero extending it. OVERFLOWABLE indicates if we are interested in
overflow of the value, when >0 we are only interested in signed
overflow, for <0 we are interested in any overflow. OVERFLOWED
indicates whether overflow has already occurred. CONST_OVERFLOWED
indicates whether constant overflow has already occurred. We force
T's value to be within range of T's type (by setting to 0 or 1 all
the bits outside the type's range). We set TREE_OVERFLOWED if,
OVERFLOWED is nonzero,
or OVERFLOWABLE is >0 and signed overflow occurs
or OVERFLOWABLE is <0 and any overflow occurs
We return a new tree node for the extended double_int. The node
is shared if no overflow flags are set.
References double_int_fits_to_tree_p(), double_int_to_tree(), double_int::ext(), and type().
Referenced by extract_range_from_assert(), extract_range_from_unary_expr_1(), fold_abs_const(), fold_convert_const_int_from_fixed(), fold_convert_const_int_from_int(), fold_convert_const_int_from_real(), fold_div_compare(), fold_negate_const(), fold_not_const(), fold_sign_changed_comparison(), fold_unary_loc(), int_const_binop_1(), and round_up_loc().
| void free_temp_slots | ( | void | ) |
Free all temporaries used so far. This is normally called at the end of generating code for a statement.
References combine_temp_slots(), make_slot_available(), temp_slot::next, remove_unused_temp_slot_addresses(), and temp_slots_at_level().
Referenced by expand_asm_operands(), expand_asm_stmt(), expand_case(), expand_gimple_stmt(), expand_sjlj_dispatch_table(), pop_temp_slots(), and stack_protect_epilogue().
|
inlinestatic |
Return the next argument if there are more arguments to handle, otherwise return NULL.
|
inlinestatic |
Return a pointer that holds the next argument if there are more arguments to handle, otherwise return NULL.
|
inlinestatic |
Initialize the iterator I with arguments from function FNDECL
|
inlinestatic |
Advance to the next argument.
| void generate_setjmp_warnings | ( | void | ) |
Generate warning messages for variables live across setjmp.
References bitmap_empty_p(), current_function_decl, regstat_get_setjmp_crosses(), setjmp_args_warning(), setjmp_crosses, and setjmp_vars_warning().
Referenced by ira().
| tree get_attribute_name | ( | const_tree | ) |
| tree get_attribute_namespace | ( | const_tree | ) |
| tree get_binfo_at_offset | ( | tree | , |
| HOST_WIDE_INT | , | ||
| tree | |||
| ) |
| tree get_callee_fndecl | ( | const_tree | ) |
| tree get_containing_scope | ( | const_tree | ) |
Given a DECL or TYPE, return the scope in which it was declared, or NUL_TREE if there is no containing scope.
| tree get_file_function_name | ( | const char * | ) |
| tree get_identifier | ( | const char * | ) |
Return the (unique) IDENTIFIER_NODE node for a given name. The name is supplied as a char *.
| tree get_identifier_with_length | ( | const char * | , |
| size_t | |||
| ) |
Identical to get_identifier, except that the length is assumed known.
| tree get_inner_reference | ( | tree | exp, |
| HOST_WIDE_INT * | pbitsize, | ||
| HOST_WIDE_INT * | pbitpos, | ||
| tree * | poffset, | ||
| enum machine_mode * | pmode, | ||
| int * | punsignedp, | ||
| int * | pvolatilep, | ||
| bool | keep_aligning | ||
| ) |
Given an expression EXP that is a handled_component_p, look for the ultimate containing object, which is returned and specify the access position and size.
Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF, an ARRAY_REF, or an ARRAY_RANGE_REF, look for nested operations of these codes and find the ultimate containing object, which we return. We set *PBITSIZE to the size in bits that we want, *PBITPOS to the bit position, and *PUNSIGNEDP to the signedness of the field. If the position of the field is variable, we store a tree giving the variable offset (in units) in *POFFSET. This offset is in addition to the bit position. If the position is not variable, we store 0 in *POFFSET. If any of the extraction expressions is volatile, we store 1 in *PVOLATILEP. Otherwise we don't change that. If the field is a non-BLKmode bit-field, *PMODE is set to VOIDmode. Otherwise, it is a mode that can be used to access the field. If the field describes a variable-sized object, *PMODE is set to BLKmode and *PBITSIZE is set to -1. An access cannot be made in this case, but the address of the object can be found. If KEEP_ALIGNING is true and the target is STRICT_ALIGNMENT, we don't look through nodes that serve as markers of a greater alignment than the one that can be deduced from the expression. These nodes make it possible for front-ends to prevent temporaries from being created by the middle-end on alignment considerations. For that purpose, the normal operating mode at high-level is to always pass FALSE so that the ultimate containing object is really returned; moreover, the associated predicate handled_component_p will always return TRUE on these nodes, thus indicating that they are essentially handled by get_inner_reference. TRUE should only be passed when the caller is scanning the expression in order to build another representation and specifically knows how to handle these nodes; as such, this is the normal operating mode in the RTL expanders.
References double_int::and_not(), array_ref_element_size(), array_ref_low_bound(), double_int::arshift(), component_ref_field_offset(), double_int_to_tree(), exact_log2(), exp(), double_int::fits_shwi(), double_int::from_uhwi(), host_integerp(), integer_zerop(), double_int::is_negative(), double_int::lshift(), double_int::mask(), mem_ref_offset(), offset, double_int::sext(), double_int::to_shwi(), tree_int_cst_equal(), tree_low_cst(), and tree_to_double_int().
Referenced by dbxout_expand_expr(), decode_field_reference(), delegitimize_mem_from_attrs(), dr_analyze_innermost(), expand_assignment(), expand_debug_expr(), expand_expr_addr_expr_1(), expand_expr_real_1(), fold_comparison(), fold_unary_loc(), fortran_common(), get_bit_range(), get_inner_reference_aff(), get_object_alignment_2(), instrument_derefs(), instrument_expr(), interpret_rhs_expr(), loc_list_for_address_of_addr_expr_of_indirect_ref(), loc_list_from_tree(), may_be_unaligned_p(), optimize_bit_field_compare(), slsr_process_ref(), split_address_cost(), split_address_to_core_and_offset(), split_constant_offset_1(), tree_to_aff_combination(), vect_analyze_data_refs(), and vect_check_gather().
| const char* get_name | ( | tree | ) |
Return OP or a simpler expression for a narrower value which can be sign-extended or zero-extended to give back OP. Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended or 0 if the value should be sign-extended.
| unsigned int get_object_alignment | ( | tree | ) |
| bool get_object_alignment_1 | ( | tree | exp, |
| unsigned int * | alignp, | ||
| unsigned HOST_WIDE_INT * | bitposp | ||
| ) |
For a memory reference expression EXP compute values M and N such that M divides (&EXP - N) and such that N < M. If these numbers can be determined, store M in alignp and N in *BITPOSP and return true. Otherwise return false and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp.
References get_object_alignment_2().
Referenced by build_ref_for_offset(), get_object_alignment(), get_pointer_modulus_and_residue(), replace_ref(), and set_mem_attributes_minus_bitpos().
| unsigned int get_pointer_alignment | ( | tree | ) |
| bool get_pointer_alignment_1 | ( | tree | exp, |
| unsigned int * | alignp, | ||
| unsigned HOST_WIDE_INT * | bitposp | ||
| ) |
For a pointer valued expression EXP compute values M and N such that M divides (EXP - N) and such that N < M. If these numbers can be determined, store M in alignp and N in *BITPOSP and return true. Return false if the results are just a conservative approximation. If EXP is not a pointer, false is returned too.
References get_object_alignment_2(), and get_ptr_info_alignment().
Referenced by get_object_alignment_2(), get_pointer_alignment(), get_value_from_alignment(), and ipa_modify_call_arguments().
Return a version of the TYPE, qualified as indicated by the TYPE_QUALS, if one exists. If no qualified version exists yet, return NULL_TREE.
| tree get_ref_base_and_extent | ( | tree | exp, |
| HOST_WIDE_INT * | poffset, | ||
| HOST_WIDE_INT * | psize, | ||
| HOST_WIDE_INT * | pmax_size | ||
| ) |
If EXP is a handled component reference for a structure, return the base variable. The access range is delimited by bit positions *POFFSET and *POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either *PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE and *PMAX_SIZE are equal, the access is non-variable.
References array_ref_element_size(), array_ref_low_bound(), component_ref_field_offset(), exact_log2(), exp(), double_int::fits_shwi(), double_int::from_uhwi(), host_integerp(), HOST_WIDE_INT, integer_zerop(), double_int::lshift(), mem_ref_offset(), double_int::to_shwi(), and tree_to_double_int().
Referenced by add_var_loc_to_decl(), aliasing_component_refs_p(), ao_ref_base(), ao_ref_init_from_ptr_and_size(), compute_complex_assign_jump_func(), compute_known_type_jump_func(), create_access(), determine_known_aggregate_parts(), do_structure_copy(), expand_debug_expr(), extr_type_from_vtbl_ptr_store(), fold_builtin_memory_op(), fold_const_aggregate_ref_1(), get_access_for_expr(), get_ancestor_addr_info(), get_base_constructor(), get_constraint_for_component_ref(), gimple_extract_devirt_binfo_from_cst(), ipa_load_from_parm_agg_1(), mark_aliased_reaching_defs_necessary_1(), sra_ipa_modify_expr(), stmt_kills_ref_p_1(), track_expr_p(), and vn_reference_lookup_3().
| void get_type_static_bounds | ( | const_tree | , |
| mpz_t | , | ||
| mpz_t | |||
| ) |
Return EXP, stripped of any conversions to wider types in such a way that the result of converting to type FOR_TYPE is the same as if EXP were converted to FOR_TYPE. If FOR_TYPE is 0, it signifies EXP's type.
| bool gimple_alloca_call_p | ( | const_gimple | ) |
| tree gimple_fold_builtin_snprintf_chk | ( | gimple | stmt, |
| tree | maxlen, | ||
| enum built_in_function | fcode | ||
| ) |
Fold a call STMT to {,v}snprintf. Return NULL_TREE if
a normal call should be emitted rather than expanding the function
inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
passed as second argument.
References fold_builtin_snprintf_chk_1(), gimple_call_arg_ptr(), gimple_call_num_args(), and gimple_location().
Referenced by gimple_fold_builtin(), and gimple_fold_builtin_varargs().
| gimple_seq gimplify_parameters | ( | void | ) |
Gimplify the parameter list for current_function_decl. This involves evaluating SAVE_EXPRs of variable sized parameters and generating code to implement callee-copies reference parameters. Returns a sequence of statements to add to the beginning of the function.
References assign_parm_data_all::args_so_far, assign_parm_data_all::args_so_far_v, assign_parm_find_data_types(), assign_parms_augmented_arg_list(), assign_parms_initialize_all(), build_call_expr(), build_pointer_type(), builtin_decl_explicit(), compare_tree_int(), create_tmp_reg(), create_tmp_var(), GENERIC_STACK_CHECK, get_name(), gimplify_and_add(), gimplify_assign(), gimplify_one_sizepos(), gimplify_parm_type(), assign_parm_data_one::named_arg, assign_parm_data_one::passed_mode, assign_parm_data_one::passed_pointer, assign_parm_data_one::passed_type, assign_parm_data_one::promoted_mode, reference_callee_copied(), and targetm.
Referenced by gimplify_body().
|
write |
Define the overall contents of a tree node. It may be any of the structures declared above for various types of node.
Handle a "dllimport" or "dllexport" attribute.
Handle a "dllimport" or "dllexport" attribute; arguments as in struct attribute_spec.handler.
References ATTR_FLAG_ARRAY_NEXT, ATTR_FLAG_DECL_NEXT, ATTR_FLAG_FUNCTION_NEXT, current_function_decl, error(), is_attribute_p(), targetm, VISIBILITY_DEFAULT, and warning().
|
inlinestatic |
Return true if T is an expression that get_inner_reference handles.
Referenced by add_var_loc_to_decl(), addr_object_size(), aliasing_component_refs_p(), ao_ref_base_alias_set(), array_at_struct_end_p(), array_index_predicate(), build_addr(), build_simple_mem_ref_loc(), component_uses_parent_alias_set(), compute_reloc_for_constant(), constant_after_peeling(), contains_bitfld_component_ref_p(), contains_vce_or_bfcref_p(), contains_view_convert_expr_p(), convert_local_reference_op(), convert_nonlocal_reference_op(), create_access_replacement(), create_component_ref_by_pieces_1(), decl_refs_may_alias_p(), detect_type_change_1(), dr_analyze_indices(), expand_assignment(), expand_debug_expr(), expand_expr_real_1(), expr_with_var_bounded_array_refs_p(), find_func_clobbers(), find_interesting_uses_address(), fold_binary_loc(), fold_unary_loc(), forward_propagate_addr_expr_1(), get_alias_set(), get_base_address(), get_base_loadstore(), get_bit_range(), get_constraint_for_component_ref(), gimplify_compound_lval(), indirect_ref_may_alias_decl_p(), indirect_refs_may_alias_p(), input_gimple_stmt(), interpret_rhs_expr(), ipcp_transform_function(), is_gimple_address(), is_gimple_addressable(), mark_addressable(), maybe_fold_reference(), maybe_fold_tmr(), maybe_rewrite_mem_ref_base(), non_rewritable_mem_ref_base(), nonoverlapping_component_refs_of_decl_p(), object_address_invariant_in_loop_p(), output_addressed_constants(), output_gimple_stmt(), prepare_decl_rtl(), prepare_gimple_addressable(), ptr_parm_has_direct_uses(), recompute_tree_invariant_for_addr_expr(), ref_at_iteration(), ref_contains_array_ref(), ref_may_be_aliased(), reference_alias_ptr_type(), refs_may_alias_p_1(), requires_barrier(), search_for_addr_array(), self_reuse_distance(), slsr_process_ref(), strip_invariant_refs(), take_address_of(), track_expr_p(), tree_invariant_p_1(), try_move_mult_to_index(), valid_gimple_rhs_p(), var_decl_component_p(), verify_expr(), verify_gimple_assign_single(), verify_phi_args(), verify_types_in_gimple_reference(), vn_reference_lookup_3(), and walk_stmt_load_store_addr_ops().
| unsigned HOST_WIDE_INT highest_pow2_factor | ( | const_tree | ) |
| int host_integerp | ( | const_tree | , |
| int | |||
| ) |
| bool in_array_bounds_p | ( | tree | ) |
| void indent_to | ( | FILE * | , |
| int | |||
| ) |
| void init_attributes | ( | void | ) |
Initialize attribute tables, and make some sanity checks if --enable-checking.
References lang_hooks::attribute_table, attributes_initialized, lang_hooks::common_attribute_table, attribute_spec::decl_required, empty_attribute_table, lang_hooks::format_attribute_table, attribute_spec::function_type_required, invoke_plugin_callbacks(), len, attribute_spec::max_length, attribute_spec::min_length, attribute_spec::name, register_scoped_attributes(), strlen(), targetm, and attribute_spec::type_required.
Referenced by decl_attributes().
|
inlinestatic |
Initialize the abstract argument list iterator object ITER with the arguments from CALL_EXPR node EXP.
|
inlinestatic |
Referenced by builtin_mathfn_code(), and validate_arglist().
| void init_dummy_function_start | ( | void | ) |
Initialize the rtl expansion mechanism so that we can do simple things like generate sequences. This is used to provide a context during global initialization of some passes. You must call expand_dummy_function_end to exit this context.
References in_dummy_function, prepare_function_start(), and push_struct_function().
Referenced by backend_init_target(), and lang_dependent_init_target().
| void init_function_start | ( | tree | ) |
| void init_inline_once | ( | void | ) |
In tree-inline.c.
Initializes weights used by estimate_num_insns.
References eni_weights_d::call_cost, eni_weights_d::div_mod_cost, eni_weights_d::indirect_call_cost, eni_weights_d::omp_cost, eni_weights_d::return_cost, eni_weights_d::target_builtin_call_cost, eni_weights_d::time_based, and eni_weights_d::tm_cost.
Referenced by backend_init().
| void init_object_sizes | ( | void | ) |
In tree-object-size.c.
Initialize data structures for the object size computation.
References HOST_WIDE_INT, init_offset_limit(), object_size_info::object_size_type, and object_sizes.
Referenced by compute_object_sizes().
| void init_temp_slots | ( | void | ) |
Initialize temporary slots.
References n_temp_slots_in_use, temp_slot_address_eq(), temp_slot_address_hash(), temp_slot_address_table, and vec_alloc().
Referenced by prepare_function_start(), and rest_of_clean_state().
| void init_tree_optimization_optabs | ( | tree | ) |
| void init_ttree | ( | void | ) |
Init tree.c.
References cl_optimization_node, cl_option_hash_eq(), cl_option_hash_hash(), cl_option_hash_table, cl_target_option_node, debug_expr_for_decl, lang_hooks::init_ts, initialize_tree_contains_struct(), int_cst_hash_eq(), int_cst_hash_hash(), int_cst_hash_table, int_cst_node, tree_decl_map_hash(), type_hash_eq(), type_hash_hash(), type_hash_table, and value_expr_for_decl.
Referenced by general_init().
| void initialize_sizetypes | ( | void | ) |
Initialize sizetypes so layout_type can use them.
References get_identifier(), make_signed_type(), set_min_and_max_values_for_integral_type(), and smallest_mode_for_size().
Referenced by build_common_tree_nodes().
| bool initializer_constant_valid_for_bitfield_p | ( | tree | ) |
Return true if VALUE is a valid constant-valued expression for use in initializing a static bit-field; one that can be an element of a "constant" initializer.
Referenced by initializer_constant_valid_for_bitfield_p().
Return nonzero if VALUE is a valid constant-valued expression for use in initializing a static variable; one that can be an element of a "constant" initializer. Return null_pointer_node if the value is absolute; if it is relocatable, return the variable that determines the relocation. We assume that VALUE has been folded as much as possible; therefore, we do not need to check for such things as arithmetic-combinations of integers.
Referenced by categorize_ctor_elements_1(), check_final_bb(), gimplify_init_constructor(), rtl_for_decl_init(), and tree_add_const_value_attribute().
| bool initializer_zerop | ( | const_tree | ) |
Given an initializer INIT, return TRUE if INIT is zero or some aggregate of zeros. Otherwise return FALSE.
|
inlinestatic |
We set BLOCK_SOURCE_LOCATION only to inlined function entry points.
Referenced by add_high_low_attributes(), DFS_write_tree_body(), gen_block_die(), pack_ts_block_value_fields(), remove_unused_scope_block_p(), and write_ts_block_tree_pointers().
| HOST_WIDE_INT int_bit_position | ( | const_tree | ) |
| HOST_WIDE_INT int_byte_position | ( | const_tree | ) |
| tree int_const_binop | ( | enum | tree_code, |
| const_tree | , | ||
| const_tree | |||
| ) |
| HOST_WIDE_INT int_cst_value | ( | const_tree | ) |
| bool int_fits_type_p | ( | const_tree | , |
| const_tree | |||
| ) |
| HOST_WIDE_INT int_size_in_bytes | ( | const_tree | ) |
| int integer_all_onesp | ( | const_tree | ) |
integer_all_onesp (tree x) is nonzero if X is an integer constant all of whose significant bits are 1.
| int integer_minus_onep | ( | const_tree | ) |
integer_minus_onep (tree x) is nonzero if X is an integer constant of value -1.
| int integer_nonzerop | ( | const_tree | ) |
integer_nonzerop (tree x) is nonzero if X is an integer constant with a nonzero value.
| int integer_onep | ( | const_tree | ) |
integer_onep (tree x) is nonzero if X is an integer constant of value 1.
| int integer_pow2p | ( | const_tree | ) |
integer_pow2p (tree x) is nonzero is X is an integer constant with exactly one bit 1.
| int integer_zerop | ( | const_tree | ) |
integer_zerop (tree x) is nonzero if X is an integer constant of value 0.
| void internal_reference_types | ( | void | ) |
Show that REFERENCE_TYPES are internal and should use address_mode. Called only by front end.
References reference_types_internal.
| enum tree_code invert_tree_comparison | ( | enum | tree_code, |
| bool | |||
| ) |
| tree invert_truthvalue_loc | ( | location_t | , |
| tree | |||
| ) |
|
inlinestatic |
Given an identifier node IDENT and a string ATTR_NAME, return true if the identifier node is a valid attribute name for the string. ATTR_NAME must be in the form 'text' (not '__text__'). IDENT could be the identifier for 'text' or for '__text__'.
Referenced by decl_attributes(), function_attribute_inlinable_p(), and handle_dll_attribute().
| bool is_builtin_fn | ( | tree | ) |
| bool is_inexpensive_builtin | ( | tree | ) |
|
inlinestatic |
Return true if tree node T is a language-specific node.
Referenced by find_decls_types_r(), fld_worklist_push(), and lto_is_streamable().
| bool is_simple_builtin | ( | tree | ) |
| bool is_tm_ending_fndecl | ( | tree | ) |
| bool is_tm_may_cancel_outer | ( | tree | ) |
| bool is_tm_pure | ( | const_tree | ) |
| bool is_tm_safe | ( | const_tree | ) |
|
inlinestatic |
Referenced by diagnose_tm_1(), ipa_tm_execute(), ipa_tm_note_irrevocable(), and ipa_tm_scan_irr_block().
| bool is_typedef_decl | ( | tree | x | ) |
| hashval_t iterative_hash_expr | ( | const_tree | , |
| hashval_t | |||
| ) |
| hashval_t iterative_hash_exprs_commutative | ( | const_tree | t1, |
| const_tree | t2, | ||
| hashval_t | val | ||
| ) |
Generate a hash value for a pair of expressions. This can be used iteratively by passing a previous result as the VAL argument. The same hash value is always returned for a given pair of expressions, regardless of the order in which they are presented. This is useful in hashing the operands of commutative functions.
References iterative_hash_expr(), and iterative_hash_hashval_t().
Referenced by iterative_hash_hashable_expr().
| hashval_t iterative_hash_hashval_t | ( | hashval_t | , |
| hashval_t | |||
| ) |
| hashval_t iterative_hash_host_wide_int | ( | HOST_WIDE_INT | , |
| hashval_t | |||
| ) |
| void layout_decl | ( | tree | , |
| unsigned | |||
| ) |
Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node, calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE fields. Call this only once for any given decl node. Second argument is the boundary that this field can be assumed to be starting at (in bits). Zero means it can be assumed aligned on any boundary that may be needed.
| void layout_type | ( | tree | ) |
Given a ..._TYPE node, calculate the TYPE_SIZE, TYPE_SIZE_UNIT, TYPE_ALIGN and TYPE_MODE fields. If called more than once on one node, does nothing except for the first time.
| tree lhd_gcc_personality | ( | void | ) |
Return the GCC personality function decl.
References build_personality_function(), and gcc_eh_personality_decl.
| bool list_equal_p | ( | const_tree | , |
| const_tree | |||
| ) |
| int list_length | ( | const_tree | ) |
Returns the length of a chain of nodes (number of chain pointers to follow before reaching a null pointer).
|
inlinestatic |
Given an attribute name ATTR_NAME and a list of attributes LIST, return a pointer to the attribute's list element if the attribute is part of the list, or NULL_TREE if not found. If the attribute appears more than once, this only returns the first occurrence; the TREE_CHAIN of the return value should be passed back in if further occurrences are wanted. ATTR_NAME must be in the form 'text' (not '__text__').
Referenced by alloc_object_size(), asan_protect_global(), assemble_alias(), assemble_external(), assemble_start_function(), avoid_folding_inline_builtin(), block_nonartificial_location(), build_pointer_type_for_mode(), build_reference_type_for_mode(), can_inline_edge_p(), cgraph_create_function_alias(), cgraph_externally_visible_p(), comp_type_attributes(), compile(), compute_function_frequency(), ctor_for_folding(), decl_attributes(), decl_return_flags(), declare_weak(), default_binds_local_p_1(), do_assemble_alias(), do_warn_unused_result(), early_inliner(), expand_call_inline(), expand_expr_real_1(), flags_from_decl_or_type(), fold_binary_loc(), gate_asan(), gen_subprogram_die(), get_alias_symbol(), gimple_call_fnspec(), handle_alias_pairs(), inline_always_inline_functions(), inline_forbidden_p_stmt(), ipa_inline(), is_tm_callable(), is_tm_irrevocable(), is_tm_may_cancel_outer(), is_tm_safe(), lower_lastprivate_clauses(), merge_dllimport_decl_attributes(), nonnull_arg_p(), note_simd_array_uses_cb(), process_common_attributes(), process_function_and_variable_attributes(), remove_unused_scope_block_p(), rest_of_decl_compilation(), thread_prologue_and_epilogue_insns(), tree_bb_level_predictions(), tree_estimate_probability_bb(), tree_inlinable_function_p(), tree_versionable_function_p(), use_blocks_for_decl_p(), varpool_create_variable_alias(), varpool_externally_visible_p(), and warn_deprecated_use().
|
read |
In attribs.c.
|
read |
| tree make_accum_type | ( | int | , |
| int | , | ||
| int | |||
| ) |
Referenced by dw2_output_indirect_constant_1(), get_emutls_init_templ_addr(), and new_emutls_decl().
| void make_decl_rtl | ( | tree | ) |
Referenced by expand_debug_expr(), and rtl_for_decl_location().
| tree make_fract_type | ( | int | , |
| int | , | ||
| int | |||
| ) |
Construct various nodes representing fract or accum data types.
Lowest level primitive for allocating a node. The TREE_CODE is the only argument. Contents are initialized to zero except for a few of the common fields.
Given EXP, a logical expression, set the range it is testing into variables denoted by PIN_P, PLOW, and PHIGH. Return the expression actually being tested. *PLOW and *PHIGH will be made of the same type as the returned expression. If EXP is not a comparison, we will most likely not be returning a useful value and range. Set *STRICT_OVERFLOW_P to true if the return value is only valid because signed overflow is undefined; otherwise, do not change *STRICT_OVERFLOW_P.
References build_int_cst(), exp(), integer_onep(), make_range_step(), range_binop(), tcc_binary, tcc_comparison, and tcc_expression.
Referenced by fold_range_test().
| tree make_range_step | ( | location_t | loc, |
| enum tree_code | code, | ||
| tree | arg0, | ||
| tree | arg1, | ||
| tree | exp_type, | ||
| tree * | p_low, | ||
| tree * | p_high, | ||
| int * | p_in_p, | ||
| bool * | strict_overflow_p | ||
| ) |
Helper routine for make_range. Perform one step for it, return new expression if the loop should continue or NULL_TREE if it should stop.
References build_int_cst(), fold_convert_loc(), int_fits_type_p(), integer_zerop(), merge_ranges(), negate_expr(), normalize(), range_binop(), tree_int_cst_equal(), tree_int_cst_lt(), lang_hooks_for_types::type_for_mode, and lang_hooks::types.
Referenced by init_range_entry(), and make_range().
| tree make_signed_type | ( | int | ) |
Construct various nodes representing data types.
From expmed.c. Since rtl.h is included after tree.h, we can't put the prototype here. Rtl.h does declare the prototype if tree.h had been included.
| tree make_tree_binfo_stat | ( | unsigned | MEM_STAT_DECL | ) |
Make a BINFO.
| tree make_tree_vec_stat | ( | int | MEM_STAT_DECL | ) |
Make a TREE_VEC.
| tree make_unsigned_type | ( | int | ) |
| tree make_vector_stat | ( | unsigned | MEM_STAT_DECL | ) |
| void mark_addressable | ( | tree | ) |
| void mark_decl_referenced | ( | tree | ) |
| void mark_referenced | ( | tree | ) |
Referenced by assemble_name().
| tree mathfn_built_in | ( | tree | , |
| enum built_in_function | fn | ||
| ) |
| HOST_WIDE_INT max_int_size_in_bytes | ( | const_tree | ) |
| bool may_negate_without_overflow_p | ( | const_tree | ) |
| tree maybe_get_identifier | ( | const char * | ) |
If an identifier with the name TEXT (a null-terminated string) has previously been referred to, return that node; otherwise return NULL_TREE.
| double_int mem_ref_offset | ( | const_tree | ) |
Given two Windows decl attributes lists, possibly including dllimport, return a list of their union .
| bool merge_ranges | ( | int * | pin_p, |
| tree * | plow, | ||
| tree * | phigh, | ||
| int | in0_p, | ||
| tree | low0, | ||
| tree | high0, | ||
| int | in1_p, | ||
| tree | low1, | ||
| tree | high1 | ||
| ) |
Given two ranges, see if we can merge them into one. Return 1 if we can, 0 if we can't. Set the output range into the specified parameters.
References integer_onep(), integer_zerop(), range_binop(), range_predecessor(), range_successor(), and tree_int_cst_equal().
Referenced by fold_range_test(), make_range_step(), and optimize_range_tests().
| enum machine_mode mode_for_size_tree | ( | const_tree | , |
| enum | mode_class, | ||
| int | |||
| ) |
Return the mode for data of a given size SIZE and mode class CLASS. If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE. The value is BLKmode if no other mode is found. This is like mode_for_size, but is passed a tree.
|
inlinestatic |
Test whether there are more arguments in abstract argument list iterator ITER, without changing its state.
Referenced by dump_generic_node().
|
inlinestatic |
Referenced by builtin_mathfn_code(), and validate_arglist().
| int multiple_of_p | ( | tree | , |
| const_tree | , | ||
| const_tree | |||
| ) |
| bool must_pass_in_stack_var_size | ( | enum machine_mode | mode, |
| const_tree | type | ||
| ) |
Nonzero if we do not know how to pass TYPE solely in registers.
| bool must_pass_in_stack_var_size_or_pad | ( | enum | machine_mode, |
| const_tree | |||
| ) |
| int native_encode_expr | ( | const_tree | , |
| unsigned char * | , | ||
| int | |||
| ) |
Convert between trees and native memory representation.
| bool needs_to_live_in_memory | ( | const_tree | ) |
|
inlinestatic |
Return the next argument from abstract argument list iterator object ITER, and advance its state. Return NULL_TREE if there are no more arguments.
Referenced by maybe_inline_call_in_expr().
|
inlinestatic |
Referenced by builtin_mathfn_code(), operand_equal_p(), simple_cst_equal(), and validate_arglist().
| tree non_lvalue_loc | ( | location_t | , |
| tree | |||
| ) |
|
inline |
These checks have to be special cased.
| void normalize_rli | ( | record_layout_info | ) |
| void notice_global_symbol | ( | tree | ) |
Referenced by assemble_start_function(), assemble_variable(), cgraph_finalize_function(), and varpool_finalize_decl().
| tree num_ending_zeros | ( | const_tree | ) |
| tree omit_one_operand_loc | ( | location_t | , |
| tree | , | ||
| tree | , | ||
| tree | |||
| ) |
Return a tree for the case when the result of an expression is RESULT converted to TYPE and OMITTED1 and OMITTED2 were previously operands of the expression but are now not needed. If OMITTED1 or OMITTED2 has side effects, they must be evaluated. If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is evaluated before OMITTED2. Otherwise, if neither has side effects, just do the conversion of RESULT to TYPE.
References fold_convert_loc(), and non_lvalue_loc().
Referenced by fold_binary_loc(), fold_builtin_memcmp(), fold_builtin_strncat(), fold_builtin_strncmp(), fold_builtin_strspn(), fold_builtin_unordered_cmp(), and fold_comparison().
| void omp_clause_check_failed | ( | const_tree | node, |
| const char * | file, | ||
| int | line, | ||
| const char * | function, | ||
| enum omp_clause_code | code | ||
| ) |
Similar to tree_check_failed but applied to OMP_CLAUSE codes.
References internal_error(), tree_code_name, and trim_filename().
|
inline |
| void omp_clause_operand_check_failed | ( | int | idx, |
| const_tree | t, | ||
| const char * | file, | ||
| int | line, | ||
| const char * | function | ||
| ) |
Similar to above, except that the check is for the number of operands of an OMP_CLAUSE node.
References internal_error(), omp_clause_num_ops, and trim_filename().
|
inline |
| void omp_clause_range_check_failed | ( | const_tree | node, |
| const char * | file, | ||
| int | line, | ||
| const char * | function, | ||
| enum omp_clause_code | c1, | ||
| enum omp_clause_code | c2 | ||
| ) |
Similar to tree_range_check_failed but applied to OMP_CLAUSE codes.
References buffer, internal_error(), strlen(), and trim_filename().
|
inline |
| int operand_equal_for_phi_arg_p | ( | const_tree | , |
| const_tree | |||
| ) |
| int operand_equal_p | ( | const_tree | , |
| const_tree | , | ||
| unsigned | int | ||
| ) |
| bool operation_could_trap_helper_p | ( | enum tree_code | op, |
| bool | fp_operation, | ||
| bool | honor_trapv, | ||
| bool | honor_nans, | ||
| bool | honor_snans, | ||
| tree | divisor, | ||
| bool * | handled | ||
| ) |
Helper function for operation_could_trap_p and stmt_could_throw_p.
References integer_zerop().
Referenced by operation_could_trap_p(), stmt_could_throw_1_p(), and vn_nary_may_trap().
| bool operation_could_trap_p | ( | enum tree_code | op, |
| bool | fp_operation, | ||
| bool | honor_trapv, | ||
| tree | divisor | ||
| ) |
Return true if operation OP may trap. FP_OPERATION is true if OP is applied on floating-point values. HONOR_TRAPV is true if OP is applied on integer type operands that may trap. If OP is a division operator, DIVISOR contains the value of the divisor.
References operation_could_trap_helper_p(), tcc_binary, tcc_comparison, and tcc_unary.
Referenced by gimple_could_trap_p_1(), and tree_could_trap_p().
| bool parse_input_constraint | ( | const char ** | constraint_p, |
| int | input_num, | ||
| int | ninputs, | ||
| int | noutputs, | ||
| int | ninout, | ||
| const char *const * | constraints, | ||
| bool * | allows_mem, | ||
| bool * | allows_reg | ||
| ) |
Similar, but for input constraints.
References error(), strlen(), and warning().
Referenced by expand_asm_operands(), find_func_aliases(), fold_stmt_1(), get_asm_expr_operands(), gimple_regimplify_operands(), gimplify_asm_expr(), walk_gimple_asm(), and walk_stmt_load_store_addr_ops().
| bool parse_output_constraint | ( | const char ** | constraint_p, |
| int | operand_num, | ||
| int | ninputs, | ||
| int | noutputs, | ||
| bool * | allows_mem, | ||
| bool * | allows_reg, | ||
| bool * | is_inout | ||
| ) |
Parse the output constraint pointed to by *CONSTRAINT_P. It is the OPERAND_NUMth output operand, indexed from zero. There are NINPUTS inputs and NOUTPUTS outputs to this extended-asm. Upon return, *ALLOWS_MEM will be TRUE iff the constraint allows the use of a memory operand. Similarly, *ALLOWS_REG will be TRUE iff the constraint allows the use of a register operand. And, *IS_INOUT will be true if the operand is read-write, i.e., if it is used as an input as well as an output. If *CONSTRAINT_P is not in canonical form, it will be made canonical. (Note that `+' will be replaced with `=' as part of this process.) Returns TRUE if all went well; FALSE if an error occurred.
References error(), strlen(), and warning().
Referenced by expand_asm_operands(), find_func_aliases(), get_asm_expr_operands(), gimple_regimplify_operands(), gimplify_asm_expr(), walk_gimple_asm(), and walk_stmt_load_store_addr_ops().
| void phi_node_elt_check_failed | ( | int | , |
| int | , | ||
| const char * | , | ||
| int | , | ||
| const char * | |||
| ) |
| void place_field | ( | record_layout_info | , |
| tree | |||
| ) |
| void pop_function_context | ( | void | ) |
Restore the last saved context, at the end of a nested function. This function is called from language-specific code.
References current_function_decl, function::decl, function_context_stack, generating_concat_p, set_cfun(), and virtuals_instantiated.
| void pop_temp_slots | ( | void | ) |
Pop a temporary nesting level. All slots in use in the current level are freed.
References free_temp_slots().
Referenced by emit_library_call_value_1(), expand_assignment(), precompute_register_parameters(), rtx_for_function_call(), and store_one_arg().
Split the bit position POS into a byte offset *POFFSET and a bit position *PBITPOS with the byte offset aligned to OFF_ALIGN bits.
References tree_int_cst_equal().
Referenced by normalize_offset().
| void preserve_temp_slots | ( | rtx | ) |
| void print_node | ( | FILE * | , |
| const char * | , | ||
| tree | , | ||
| int | |||
| ) |
| void print_node_brief | ( | FILE * | , |
| const char * | , | ||
| const_tree | , | ||
| int | |||
| ) |
| void print_rtl | ( | FILE * | , |
| const_rtx | |||
| ) |
In print-rtl.c
| bool private_is_attribute_p | ( | const char * | , |
| size_t | , | ||
| const_tree | |||
| ) |
This function is a private implementation detail of is_attribute_p() and you should never call it directly.
This function is a private implementation detail of lookup_attribute() and you should never call it directly.
| void process_pending_assemble_externals | ( | void | ) |
References assemble_external_real(), and pointer_set_destroy().
Referenced by compile_file().
| void protected_set_expr_location | ( | tree | , |
| location_t | |||
| ) |
| bool prototype_p | ( | tree | ) |
| bool ptr_difference_const | ( | tree | , |
| tree | , | ||
| HOST_WIDE_INT * | |||
| ) |
|
inlinestatic |
Return whether TYPE is a type suitable for an offset for a POINTER_PLUS_EXPR.
Referenced by build2_stat(), build_polynomial_chrec(), chrec_fold_plus_poly_poly(), get_string_length(), reset_evolution_in_loop(), verify_expr(), verify_gimple_assign_binary(), and verify_gimple_assign_unary().
| tree purpose_member | ( | const_tree | , |
| tree | |||
| ) |
| void push_function_context | ( | void | ) |
Save the current context for compilation of a nested function. This is called from language-specific code.
References allocate_struct_function(), and set_cfun().
| void push_struct_function | ( | tree | fndecl | ) |
| void push_temp_slots | ( | void | ) |
Push deeper into the nesting level for stack temporaries.
Referenced by emit_library_call_value_1(), expand_assignment(), precompute_register_parameters(), rtx_for_function_call(), and store_one_arg().
| bool range_in_array_bounds_p | ( | tree | ) |
| int real_minus_onep | ( | const_tree | ) |
| int real_onep | ( | const_tree | ) |
| int real_twop | ( | const_tree | ) |
| int real_zerop | ( | const_tree | ) |
Return 1 if EXPR is the real constant zero.
| int really_constant_p | ( | const_tree | ) |
In tree.c
| void recompute_tree_invariant_for_addr_expr | ( | tree | ) |
| tree reference_alias_ptr_type | ( | const_tree | ) |
| void relayout_decl | ( | tree | ) |
Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of a previous call to layout_decl and calls it again.
Remove any instances of attribute ATTR_NAME in LIST and return the modified list. ATTR_NAME must be in the form 'text' (not '__text__').
| void resolve_unique_section | ( | tree | decl, |
| int | reloc, | ||
| int | flag_function_or_data_sections | ||
| ) |
If required, set DECL_SECTION_NAME to a unique name.
References targetm.
Referenced by expand_thunk(), get_variable_section(), and gimple_expand_cfg().
| tree rli_size_so_far | ( | record_layout_info | ) |
| tree rli_size_unit_so_far | ( | record_layout_info | ) |
| tree round_down_loc | ( | location_t | , |
| tree | , | ||
| int | |||
| ) |
| tree round_up_loc | ( | location_t | , |
| tree | , | ||
| int | |||
| ) |
save_expr (EXP) returns an expression equivalent to EXP but it can be used multiple times within context CTX and only evaluate EXP once.
| void save_vtable_map_decl | ( | tree | ) |
In vtable-verify.c.
|
inlinestatic |
Set explicit builtin function nodes and whether it is an implicit function.
Referenced by local_define_builtin(), and tree_ssa_prefetch_arrays().
|
inlinestatic |
Set the implicit flag for a builtin function.
| void set_builtin_user_assembler_name | ( | tree | decl, |
| const char * | asmspec | ||
| ) |
| void set_call_expr_flags | ( | tree | , |
| int | |||
| ) |
| void set_min_and_max_values_for_integral_type | ( | tree | type, |
| int | precision, | ||
| bool | is_unsigned | ||
| ) |
In stor-layout.c
TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE or BOOLEAN_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE for TYPE, based on the PRECISION and whether or not the TYPE IS_UNSIGNED. PRECISION need not correspond to a width supported natively by the hardware; for example, on a machine with 8-bit, 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or 61.
References build_int_cst(), build_int_cst_wide(), HOST_BITS_PER_WIDE_INT, and HOST_WIDE_INT.
Referenced by fixup_signed_type(), fixup_unsigned_type(), and initialize_sizetypes().
| void set_user_assembler_name | ( | tree | , |
| const char * | |||
| ) |
| int setjmp_call_p | ( | const_tree | ) |
| int simple_cst_equal | ( | const_tree | , |
| const_tree | |||
| ) |
| int simple_cst_list_equal | ( | const_tree | , |
| const_tree | |||
| ) |
| tree size_binop_loc | ( | location_t | , |
| enum | tree_code, | ||
| tree | , | ||
| tree | |||
| ) |
| tree size_diffop_loc | ( | location_t | , |
| tree | , | ||
| tree | |||
| ) |
| tree size_in_bytes | ( | const_tree | ) |
| tree size_int_kind | ( | HOST_WIDE_INT | , |
| enum | size_type_kind | ||
| ) |
| HOST_WIDE_INT size_low_cst | ( | const_tree | ) |
Look inside EXPR into any simple arithmetic operations. Return the outermost non-arithmetic or non-invariant node.
Look inside EXPR into simple arithmetic operations involving constants. Return the outermost non-arithmetic or non-constant node.
| bool ssa_name_nonnegative_p | ( | const_tree | ) |
In tree-vrp.c
stabilize_reference (EXP) returns a reference equivalent to EXP but it can be used multiple times and only evaluate the subexpressions once.
Subroutine of stabilize_reference; this is called for subtrees of references. Any expression with side-effects must be put in a SAVE_EXPR to ensure that it is only evaluated once.
| void stack_protect_epilogue | ( | void | ) |
References emit_cmp_and_jump_insns(), emit_insn(), emit_label(), expand_call(), expand_normal(), free_temp_slots(), gen_label_rtx(), get_last_insn(), predict_insn_def(), ptr_mode, TAKEN, and targetm.
Referenced by expand_call(), and expand_function_end().
| void stack_protect_prologue | ( | void | ) |
References emit_insn(), emit_move_insn(), expand_normal(), and targetm.
Referenced by gimple_expand_cfg().
| record_layout_info start_record_layout | ( | tree | ) |
staticp (tree x) is nonzero if X is a reference to data allocated at a fixed address in memory. Returns the outermost data.
| tree std_gimplify_va_arg_expr | ( | tree | valist, |
| tree | type, | ||
| gimple_seq * | pre_p, | ||
| gimple_seq * | post_p | ||
| ) |
The "standard" implementation of va_arg: read the value from the current (padded) address and increment by the (padded) size.
References build_int_cst(), build_pointer_type(), build_va_arg_indirect_ref(), build_variant_type_copy(), fb_rvalue, get_initialized_tmp_var(), gimplify_and_add(), gimplify_expr(), HOST_WIDE_INT, input_location, integer_zerop(), is_gimple_val(), pass_by_reference(), size_in_bytes(), and targetm.
| bool stdarg_p | ( | const_tree | ) |
| const_tree strip_invariant_refs | ( | const_tree | ) |
|
inlinestatic |
Compare and hash for any structure which begins with a canonical pointer. Assumes all pointers are interchangeable, which is sort of already assumed by gcc elsewhere IIRC.
Referenced by add_stmt_to_eh_lp_fn(), expand_block_edges(), and split_bb_make_tm_edge().
|
inlinestatic |
Referenced by add_stmt_to_eh_lp_fn(), expand_block_edges(), and split_bb_make_tm_edge().
| bool subrange_type_for_debug_p | ( | const_tree | , |
| tree * | , | ||
| tree * | |||
| ) |
Given a tree EXP, a FIELD_DECL F, and a replacement value R, return a tree with all occurrences of references to F in a PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and CONST_DECLs. Note that we assume here that EXP contains only arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their argument list.
Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement for it within OBJ, a tree that is an object or a chain of references.
| int supports_one_only | ( | void | ) |
Returns 1 if the target configuration supports defining public symbols so that one of them will be chosen at link time instead of generating a multiply-defined symbol error, whether through the use of weak symbols or a target-specific mechanism for having duplicates discarded.
| enum tree_code swap_tree_comparison | ( | enum | tree_code | ) |
| void tm_malloc_replacement | ( | tree | ) |
| bool tree_binary_nonnegative_warnv_p | ( | enum tree_code | code, |
| tree | type, | ||
| tree | op0, | ||
| tree | op1, | ||
| bool * | strict_overflow_p | ||
| ) |
Return true if (CODE OP0 OP1) is known to be non-negative. If the return value is based on the assumption that signed overflow is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change *STRICT_OVERFLOW_P.
References operand_equal_p(), tree_expr_nonnegative_warnv_p(), tree_int_cst_min_precision(), tree_int_cst_sgn(), and tree_simple_nonnegative_warnv_p().
Referenced by gimple_assign_nonnegative_warnv_p(), and tree_expr_nonnegative_warnv_p().
| bool tree_binary_nonzero_warnv_p | ( | enum tree_code | code, |
| tree | type, | ||
| tree | op0, | ||
| tree | op1, | ||
| bool * | strict_overflow_p | ||
| ) |
Return true when (CODE OP0 OP1) is an address and is known to be nonzero. For floating point we further ensure that T is not denormal. Similar logic is present in nonzero_address in rtlanal.h. If the return value is based on the assumption that signed overflow is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change *STRICT_OVERFLOW_P.
References tree_expr_nonnegative_warnv_p(), and tree_expr_nonzero_warnv_p().
Referenced by gimple_assign_nonzero_warnv_p(), and tree_expr_nonzero_warnv_p().
| tree tree_block | ( | tree | ) |
| bool tree_call_nonnegative_warnv_p | ( | tree | type, |
| tree | fndecl, | ||
| tree | arg0, | ||
| tree | arg1, | ||
| bool * | strict_overflow_p | ||
| ) |
Return true if T is known to be non-negative. If the return value is based on the assumption that signed overflow is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change *STRICT_OVERFLOW_P.
References BUILT_IN_NORMAL, HOST_WIDE_INT, real_from_integer(), real_identical(), real_to_integer(), tree_expr_nonnegative_warnv_p(), and tree_simple_nonnegative_warnv_p().
Referenced by gimple_call_nonnegative_warnv_p(), and tree_invalid_nonnegative_warnv_p().
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
| void tree_check_failed | ( | const_tree | node, |
| const char * | file, | ||
| int | line, | ||
| const char * | function, | ||
| ... | |||
| ) |
Complain that the tree code of NODE does not match the expected 0 terminated list of trailing codes. The trailing code list can be empty, for a more vague error message. FILE, LINE, and FUNCTION are of the caller.
References buffer, internal_error(), strlen(), tree_code_name, and trim_filename().
|
inline |
| void tree_class_check_failed | ( | const_tree | node, |
| const enum tree_code_class | cl, | ||
| const char * | file, | ||
| int | line, | ||
| const char * | function | ||
| ) |
Similar to tree_check_failed, except that we check for a class of tree code, given in CL.
References internal_error(), tree_code_name, and trim_filename().
| size_t tree_code_size | ( | enum | tree_code | ) |
Compute the number of bytes occupied by a tree with code CODE. This function cannot be used for TREE_VEC codes, which are of variable length.
Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN.
| void tree_contains_struct_check_failed | ( | const_tree | node, |
| const enum tree_node_structure_enum | en, | ||
| const char * | file, | ||
| int | line, | ||
| const char * | function | ||
| ) |
Similar to tree_class_check_failed, except that we check for whether CODE contains the tree structure identified by EN.
References internal_error(), tree_code_name, and trim_filename().
| bool tree_could_throw_p | ( | tree | ) |
| bool tree_could_trap_p | ( | tree | ) |
| unsigned int tree_decl_map_hash | ( | const void * | ) |
| bool tree_expr_nonnegative_p | ( | tree | ) |
| bool tree_expr_nonnegative_warnv_p | ( | tree | , |
| bool * | |||
| ) |
| bool tree_expr_nonzero_p | ( | tree | ) |
| bool tree_expr_nonzero_warnv_p | ( | tree | , |
| bool * | |||
| ) |
| tree tree_expr_size | ( | const_tree | ) |
| int tree_floor_log2 | ( | const_tree | ) |
| int tree_int_cst_compare | ( | const_tree | , |
| const_tree | |||
| ) |
| int tree_int_cst_equal | ( | const_tree | , |
| const_tree | |||
| ) |
| int tree_int_cst_lt | ( | const_tree | , |
| const_tree | |||
| ) |
| unsigned int tree_int_cst_min_precision | ( | tree | , |
| bool | |||
| ) |
| int tree_int_cst_sgn | ( | const_tree | ) |
| int tree_int_cst_sign_bit | ( | const_tree | ) |
| bool tree_invalid_nonnegative_warnv_p | ( | tree | t, |
| bool * | strict_overflow_p | ||
| ) |
| int tree_log2 | ( | const_tree | ) |
| HOST_WIDE_INT tree_low_cst | ( | const_tree | , |
| int | |||
| ) |
| int tree_map_base_eq | ( | const void * | , |
| const void * | |||
| ) |
| unsigned int tree_map_base_hash | ( | const void * | ) |
| int tree_map_base_marked_p | ( | const void * | ) |
| unsigned int tree_map_hash | ( | const void * | ) |
| enum tree_node_structure_enum tree_node_structure | ( | const_tree | ) |
Return which tree structure is used by T.
| location_t tree_nonartificial_location | ( | tree | ) |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
| void tree_not_check_failed | ( | const_tree | node, |
| const char * | file, | ||
| int | line, | ||
| const char * | function, | ||
| ... | |||
| ) |
Complain that the tree code of NODE does match the expected 0 terminated list of trailing codes. FILE, LINE, and FUNCTION are of the caller.
References buffer, internal_error(), strlen(), tree_code_name, and trim_filename().
| void tree_not_class_check_failed | ( | const_tree | node, |
| const enum tree_code_class | cl, | ||
| const char * | file, | ||
| int | line, | ||
| const char * | function | ||
| ) |
Similar to tree_check_failed, except that we check that a tree does not have the specified code, given in CL.
References internal_error(), tree_code_name, and trim_filename().
|
inline |
Special checks for TREE_OPERANDs.
|
inline |
| void tree_operand_check_failed | ( | int | idx, |
| const_tree | exp, | ||
| const char * | file, | ||
| int | line, | ||
| const char * | function | ||
| ) |
Similar to above, except that the check is for the bounds of the operand vector of an expression node EXP.
References internal_error(), tree_code_name, and trim_filename().
|
inlinestatic |
Compute the number of operands in an expression node NODE. For tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself, otherwise it is looked up from the node's code.
varasm.c
Referenced by gimplify_init_constructor().
| tree tree_overlaps_hard_reg_set | ( | tree | , |
| HARD_REG_SET * | |||
| ) |
Silly ifdef to avoid having all includers depend on hard-reg-set.h.
|
inline |
| void tree_range_check_failed | ( | const_tree | node, |
| const char * | file, | ||
| int | line, | ||
| const char * | function, | ||
| enum tree_code | c1, | ||
| enum tree_code | c2 | ||
| ) |
Similar to tree_check_failed, except that instead of specifying a dozen codes, use the knowledge that they're all sequential.
References buffer, internal_error(), strlen(), tree_code_name, and trim_filename().
| bool tree_single_nonnegative_warnv_p | ( | tree | t, |
| bool * | strict_overflow_p | ||
| ) |
| bool tree_single_nonzero_warnv_p | ( | tree | , |
| bool * | |||
| ) |
| size_t tree_size | ( | const_tree | ) |
Compute the number of bytes occupied by 'node'. This routine only looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH.
| bool tree_swap_operands_p | ( | const_tree | , |
| const_tree | , | ||
| bool | |||
| ) |
|
inlinestatic |
Constructs double_int from tree CST.
Referenced by addr_for_mem_ref(), adjust_range_with_scev(), aff_combination_dr_offset(), array_size_for_constructor(), assert_loop_rolls_lt(), associate_pointerplus(), canonicalize_loop_induction_variables(), ccp_lattice_meet(), cgraph_add_thunk(), const_vector_from_tree(), constant_multiple_of(), copy_reference_ops_from_ref(), create_add_imm_cand(), create_add_on_incoming_edge(), create_add_ssa_cand(), create_mul_imm_cand(), create_mul_ssa_cand(), derive_constant_upper_bound_ops(), div_if_zero_remainder(), do_warn_aggressive_loop_optimizations(), double_int_type_size_in_bits(), dump_generic_node(), dump_lattice_value(), estimate_numbers_of_iterations_loop(), extract_muldiv_1(), extract_range_from_assert(), extract_range_from_binary_expr_1(), extract_range_from_unary_expr_1(), field_byte_offset(), fold_abs_const(), fold_array_ctor_reference(), fold_binary_loc(), fold_convert_const_int_from_int(), fold_convert_const_int_from_real(), fold_negate_const(), fold_nonarray_ctor_reference(), fold_not_const(), fold_sign_changed_comparison(), fold_unary_loc(), get_constraint_for_ptr_offset(), get_inner_reference(), get_ref_base_and_extent(), get_type_static_bounds(), group_case_labels_stmt(), int_const_binop_1(), int_fits_type_p(), ipa_modify_call_arguments(), layout_type(), may_eliminate_iv(), mem_ref_offset(), non_rewritable_mem_ref_base(), number_of_iterations_exit(), number_of_iterations_lt(), number_of_iterations_lt_to_ne(), number_of_iterations_ne_max(), output_constructor_regular_field(), phi_translate_1(), predict_iv_comparison(), range_fits_type_p(), ranges_from_anti_range(), record_estimate(), register_edge_assert_for_2(), remove_redundant_iv_tests(), replace_conditional_candidate(), replace_unconditional_candidate(), restructure_reference(), round_up_loc(), search_for_addr_array(), set_lattice_value(), simplify_conversion_using_ranges(), size_low_cst(), slsr_process_add(), split_to_var_and_offset(), tree_int_to_gmp(), tree_to_aff_combination(), valid_lattice_transition(), value_to_double_int(), valueize_refs_1(), vn_reference_fold_indirect(), vn_reference_maybe_forwprop_address(), and zero_nonzero_bits_from_vr().
| bool tree_unary_nonnegative_warnv_p | ( | enum tree_code | code, |
| tree | type, | ||
| tree | op0, | ||
| bool * | strict_overflow_p | ||
| ) |
Return true if (CODE OP0) is known to be non-negative. If the return value is based on the assumption that signed overflow is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change *STRICT_OVERFLOW_P.
References tree_expr_nonnegative_warnv_p(), tree_simple_nonnegative_warnv_p(), and type().
Referenced by gimple_assign_nonnegative_warnv_p(), and tree_expr_nonnegative_warnv_p().
| bool tree_unary_nonzero_warnv_p | ( | enum tree_code | code, |
| tree | type, | ||
| tree | op0, | ||
| bool * | strict_overflow_p | ||
| ) |
Return true when (CODE OP0) is an address and is known to be nonzero. For floating point we further ensure that T is not denormal. Similar logic is present in nonzero_address in rtlanal.h. If the return value is based on the assumption that signed overflow is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change *STRICT_OVERFLOW_P.
References tree_expr_nonzero_warnv_p(), and type().
Referenced by gimple_assign_nonzero_warnv_p(), and tree_expr_nonzero_warnv_p().
|
inline |
| void tree_vec_elt_check_failed | ( | int | idx, |
| int | len, | ||
| const char * | file, | ||
| int | line, | ||
| const char * | function | ||
| ) |
Similar to above, except that the check is for the bounds of a TREE_VEC's (dynamically sized) vector.
References internal_error(), and trim_filename().
|
inlinestatic |
Return nonzero if CODE is a tree code that represents a truth value.
Referenced by canonicalize_cond_expr_cond(), find_func_aliases(), fold_binary_loc(), fold_ternary_loc(), gimple_boolify(), tree_simple_nonnegative_warnv_p(), and truth_valued_ssa_name().
| bool type_contains_placeholder_p | ( | tree | ) |
Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and field positions.
Given a hashcode and a ..._TYPE node (for which the hashcode was made), return a canonicalized ..._TYPE node, so that duplicates are not made. How the hash code is computed is up to the caller, as long as any two callers that could hash identical-looking type nodes agree.
| bool type_in_anonymous_namespace_p | ( | tree | ) |
| int type_list_equal | ( | const_tree | , |
| const_tree | |||
| ) |
| int type_num_arguments | ( | const_tree | ) |
| bool typedef_variant_p | ( | tree | ) |
| tree uniform_vector_p | ( | const_tree | ) |
Given a vector VEC, return its first element if all elements are the same. Otherwise return NULL_TREE.
| unsigned int update_alignment_for_field | ( | record_layout_info | rli, |
| tree | field, | ||
| unsigned int | known_align | ||
| ) |
FIELD is about to be added to RLI->T. The alignment (in bits) of the next available location within the record is given by KNOWN_ALIGN. Update the variable alignment fields in RLI, and return the alignment to give the FIELD.
References integer_zerop(), layout_decl(), maximum_field_alignment, record_layout_info_s::prev_field, record_layout_info_s::record_align, record_layout_info_s::t, targetm, and record_layout_info_s::unpacked_align.
Referenced by place_field(), and place_union_field().
| bool use_register_for_decl | ( | const_tree | ) |
| void using_eh_for_cleanups | ( | void | ) |
In tree-eh.c
References using_eh_for_cleanups_p.
| bool valid_constant_size_p | ( | const_tree | ) |
| bool validate_arglist | ( | const_tree | , |
| ... | |||
| ) |
variable_size (EXP) is like save_expr (EXP) except that it is for the special case of something that is part of a variable size for a data type. It makes special arrangements to compute the value at the right time when the data type belongs to a function parameter.
| bool vec_member | ( | const_tree | , |
| vec< tree, va_gc > * | |||
| ) |
| enum machine_mode vector_type_mode | ( | const_tree | ) |
Vector types need to check target flags to determine type.
| bool virtual_method_call_p | ( | tree | ) |
| tree walk_tree_1 | ( | tree * | tp, |
| walk_tree_fn | func, | ||
| void * | data, | ||
| struct pointer_set_t * | pset, | ||
| walk_tree_lh | lh | ||
| ) |
Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is called with the DATA and the address of each sub-tree. If FUNC returns a non-NULL value, the traversal is stopped, and the value returned by FUNC is returned. If PSET is non-NULL it is used to record the nodes visited, and to avoid visiting a node more than once.
References HOST_WIDE_INT, len, OMP_CLAUSE__SIMDUID_, OMP_CLAUSE_COLLAPSE, OMP_CLAUSE_COPYIN, OMP_CLAUSE_COPYPRIVATE, OMP_CLAUSE_DEFAULT, OMP_CLAUSE_FINAL, OMP_CLAUSE_FIRSTPRIVATE, OMP_CLAUSE_IF, OMP_CLAUSE_LASTPRIVATE, OMP_CLAUSE_LINEAR, OMP_CLAUSE_MERGEABLE, OMP_CLAUSE_NOWAIT, OMP_CLAUSE_NUM_THREADS, OMP_CLAUSE_ORDERED, OMP_CLAUSE_PRIVATE, OMP_CLAUSE_REDUCTION, OMP_CLAUSE_SAFELEN, OMP_CLAUSE_SCHEDULE, OMP_CLAUSE_SHARED, OMP_CLAUSE_UNIFORM, OMP_CLAUSE_UNTIED, pointer_set_insert(), tsi_end_p(), tsi_next(), tsi_start(), tsi_stmt_ptr(), constructor_elt_d::value, vec_safe_iterate(), and walk_type_fields().
Referenced by walk_tree_without_duplicates_1().
| tree walk_tree_without_duplicates_1 | ( | tree * | tp, |
| walk_tree_fn | func, | ||
| void * | data, | ||
| walk_tree_lh | lh | ||
| ) |
Like walk_tree, but does not walk duplicate nodes more than once.
References pointer_set_create(), pointer_set_destroy(), and walk_tree_1().
| HOST_WIDEST_INT widest_int_cst_value | ( | const_tree | ) |
Variable Documentation
| vec<alias_pair, va_gc>* alias_pairs |
Define gc'd vector type.
Referenced by assemble_alias(), free_lang_data_in_cgraph(), function_and_variable_visibility(), handle_alias_pairs(), ipa_lower_emutls(), and produce_asm_for_decls().
A vector of all translation-units.
Referenced by gen_compile_unit_die(), and unpack_ts_translation_unit_decl_value_fields().
| const char* const built_in_class_names[4] |
Names for the above.
Define the names of the builtin function types and codes.
Referenced by print_node().
| const char* built_in_names[(int) END_BUILTINS] |
Names for the above.
Referenced by build_common_builtin_nodes(), and print_node().
| builtin_info_type builtin_info |
Setup an array of _DECL trees, make sure each element is initialized to NULL_TREE.
| tree current_function_decl |
Points to the FUNCTION_DECL of the function whose body we are reading.
| const char* current_function_func_begin_label |
Nonzero means a FUNC_BEGIN label was emitted.
Referenced by crash_signal(), dw2_output_call_site_table(), and dwarf2out_begin_prologue().
| int folding_initializer |
In fold-const.c
Non-zero if we are folding constants inside an initializer; zero otherwise.
@verbatim Fold a constant sub-tree into a single node for C-compiler
Copyright (C) 1987-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 entry points in this file are fold, size_int_wide and size_binop. fold takes a tree as argument and returns a simplified tree. size_binop takes a tree code for an arithmetic operation and two operands that are trees, and produces a tree for the result, assuming the type comes from `sizetype'. size_int takes an integer value, and creates a tree constant with type from `sizetype'. Note: Since the folders get called on non-gimple code as well as gimple code, we need to handle GIMPLE tuples as well as their corresponding tree equivalents.
Nonzero if we are folding constants inside an initializer; zero otherwise.
Referenced by const_binop(), and fold_builtin_constant_p().
| bool force_folding_builtin_constant_p |
In builtins.c
Non-zero if __builtin_constant_p should be folded right away.
Non-zero if __builtin_constant_p should be folded right away.
Referenced by preload_common_nodes().
| bool in_gimple_form |
True if we are in gimple form and the actions of the folders need to be restricted. False if we are not in gimple form and folding is not restricted to creating gimple expressions.
Global variables used to communicate with passes.
Referenced by execute_one_ipa_transform_pass(), execute_one_pass(), fold_binary_loc(), fold_cond_expr_with_comparison(), fold_indirect_ref_1(), and non_lvalue_loc().
The standard C integer types. Use integer_type_kind to index into this array.
Referenced by free_lang_data(), and preload_common_nodes().
| unsigned int maximum_field_alignment |
If nonzero, an upper limit on alignment of structure fields, in bits,
If nonzero, this is an upper limit on alignment of structure fields. The value is measured in bits.
Referenced by layout_decl(), place_field(), process_options(), start_record_layout(), and update_alignment_for_field().
| const char* const omp_clause_code_name[] |
Referenced by dequeue_and_dump(), and print_node().
| unsigned const char omp_clause_num_ops[] |
In an OMP_CLAUSE node.
Number of operands and names for each clause.
Referenced by build_omp_clause(), dequeue_and_dump(), omp_clause_operand_check_failed(), print_node(), and tree_size().
| int pedantic_lvalues |
Declare commonly used variables for tree structure.
Nonzero means lvalues are limited to those valid in pedantic ANSI C. Zero means allow extended lvalues.
Nonzero means lvalues are limited to those valid in pedantic ANSI C. Zero means allow extended lvalues.
Referenced by pedantic_non_lvalue_loc().
| tree sizetype_tab[(int) stk_type_kind_last] |
@verbatim C-compiler utilities for types and variables storage layout
Copyright (C) 1987-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/.
Data type for the expressions representing sizes of data types. It is the first integer type laid out.
Referenced by preload_common_nodes(), and size_int_kind().
| const char* const tree_code_class_strings[] |
Each tree code class has an associated string representation. These must correspond to the tree_code_class entries.
| const unsigned char tree_code_length[] |
Number of argument-words in each kind of tree-node.
| const char* const tree_code_name[] |
Names of tree components.
Referenced by dequeue_and_dump(), DFS_write_tree(), do_niy(), dump_asserts_for(), dump_binary_rhs(), dump_generic_node(), dump_gimple_assign(), dump_gimple_cond(), dump_gimple_omp_for(), dump_ternary_rhs(), dump_tree_statistics(), dump_unary_rhs(), gimple_check_failed(), ipa_print_node_jump_functions_for_edge(), lto_tag_name(), lto_write_tree(), omp_clause_check_failed(), print_expr_hash_elt(), print_lto_report(), print_node(), print_node_brief(), print_pre_expr(), tree_check_failed(), tree_class_check_failed(), tree_contains_struct_check_failed(), tree_not_check_failed(), tree_not_class_check_failed(), tree_operand_check_failed(), tree_range_check_failed(), and vect_create_data_ref_ptr().
| enum tree_code_class tree_code_type[] |
| unsigned char tree_contains_struct[MAX_TREE_CODES][64] |
Referenced by initialize_tree_contains_struct().
| int tree_node_counts[] |
Referenced by dump_tree_statistics(), record_node_allocation_statistics(), and type_hash_canon().
| int tree_node_sizes[] |
Referenced by dump_tree_statistics(), record_node_allocation_statistics(), and type_hash_canon().
