PIPS
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "misc.h"
#include "text-util.h"
Go to the source code of this file.
Functions | |
entity | effect_field_dimension_entity (expression exp, list l_fields) |
type.c More... | |
static int | effect_indices_first_pointer_dimension_rank (list current_l_ind, type current_type, bool *exact_p) |
recursively walks thru current_l_ind and current_type in parallel until a pointer dimension is found. More... | |
static int | effect_reference_first_pointer_dimension_rank (reference ref, bool *exact_p) |
walks thru ref indices and ref entity type arborescence in parallel until a pointer dimension is found. More... | |
bool | effect_reference_contains_pointer_dimension_p (reference ref, bool *exact_p) |
bool | effect_reference_dereferencing_p (reference ref, bool *exact_p) |
static type | r_cell_reference_to_type (list ref_l_ind, type current_type, bool *to_be_freed) |
Lines 291 to 682. More... | |
type | cell_reference_to_type (reference ref, bool *to_be_freed) |
computes the type of a cell reference representing a memory access path. More... | |
type | cell_to_type (cell c, bool *to_be_freed) |
type | points_to_reference_to_type (reference ref, bool *to_be_freed) |
FI: I need more generality than is offered by cell_to_type() More... | |
static void | substitute_unbounded_call (call c) |
static expression | eliminate_calls_to_unbounded (expression e) |
Allocate a copy of expression "e" where calls to the unbounded function are replaced by calls to the zero function so that typing can be performed. More... | |
type | points_to_expression_to_type (expression e, bool *to_be_freed) |
FI: I need more generality than is offered by expression_to_type() because fields are assimilated to subscripts. More... | |
type | points_to_expression_to_concrete_type (expression e) |
The type returned is stored in a hash-table. More... | |
type | points_to_expression_to_pointed_type (expression e) |
Return a new allocated type "t" of the address pointed by expression "e", if expression "e" denotes an address. More... | |
type | points_to_cell_to_type (cell c, bool *to_be_freed) |
FI: I need more generality than is offered by cell_to_type() More... | |
type | points_to_cell_to_concrete_type (cell c) |
type | points_to_reference_to_concrete_type (reference r) |
bool | basic_concrete_types_compatible_for_effects_interprocedural_translation_p (type real_ct, type formal_ct) |
tests if the actual argument type and the formal argument type are compatible with the current state of the interprocedural translation algorithms. More... | |
bool | types_compatible_for_effects_interprocedural_translation_p (type real_arg_t, type formal_arg_t) |
tests if the actual argument type and the formal argument type are compatible with the current state of the interprocedural translation algorithms. More... | |
void | points_to_cell_types_compatibility (cell l, cell r) |
Make sure that cell l can points towards cell r. More... | |
bool | points_to_source_cell_compatible_p (cell c) |
bool | points_to_sink_cell_compatible_p (cell c __attribute__((unused))) |
list | find_points_to_subscript_for_type (cell c, type t) |
Find the subscript in the reference of cell "c" that would make the reference type be "t" if the subscript list were truncated just after it. More... | |
bool | adapt_reference_to_type (reference r, type et, int(*line_number_func)(void)) |
FI: a really stupid function... More... | |
bool | reference_unbounded_indices_p (reference r) |
This function should be at expression.c. More... | |
bool | strict_constant_path_p (reference r) |
bool | can_be_constant_path_p (reference r) |
TODO most of the time return same result that !effect_reference_dereferencing_p for the moment want to test if r can be a constant path for instance a[i] have to return false (something else?) a[0], a[1], i, j, a[*], var points by formal parameter (_p_0, ...), element of strut (s.id, ...), heap element have to return true. More... | |
FI: a really stupid function...
Why do we add zero subscript right away when building the sink cell to remove them later? Let's now remove the excessive subscripts of "r" with respect to type "at"...
et | t |
Definition at line 1327 of file type.c.
References array_pointer_string_type_equal_p(), array_pointer_type_equal_p(), CAR, compute_basic_concrete_type(), ENDP, EXPRESSION, expression_field_p(), free_type(), gen_last(), gen_length(), gen_remove_once(), int, pips_internal_error, pips_user_warning, points_to_reference_to_type(), reference_indices, reference_to_string(), and type_to_full_string_definition().
Referenced by dereferencing_subscript_to_points_to(), expression_to_points_to_cells(), filter_formal_context_according_to_actual_context(), new_filter_formal_context_according_to_actual_context(), points_to_with_stripped_sink(), process_casted_sinks(), process_casted_sources(), subscript_to_points_to_sinks(), and subscripted_reference_to_points_to().
bool basic_concrete_types_compatible_for_effects_interprocedural_translation_p | ( | type | real_ct, |
type | formal_ct | ||
) |
tests if the actual argument type and the formal argument type are compatible with the current state of the interprocedural translation algorithms.
Input types are
safe default result
easiest case
we do not take care of array dimension sizes
well, basic_equal_strict_p is at the same time too restrictive for derived and too optimistic for pointers and arrays because dimensions are skipped
skip same number of array and pointer dimensions until we reach the ultimate basic or there are no more corresponding dimensions
we have a void * as actual argument
translation cannot be accurate
we are sure here that gen_length(formal_dims) != 0
we have a void * as actual argument
translation cannot be accurate
we are sure here that gen_length(real_dims) != 0
store types and not bct becasue bct cannot be equal, since a new type is generated each time. We really need a global table for bcts
It should be a strict type equality here, but I don't think type_equal_p is very robust when types are declared in headers
real_ct | eal_ct |
formal_ct | ormal_ct |
Definition at line 699 of file type.c.
References basic_concrete_types_compatible_for_effects_interprocedural_translation_p(), basic_derived, basic_derived_p, basic_equal_p(), basic_pointer, basic_pointer_p, CAR, CDR, ENDP, ENTITY, entity_basic_concrete_type(), entity_name, entity_type, gen_chunk_undefined_p, gen_find_eq(), gen_free_list(), gen_length(), gen_position(), gen_type_cons(), is_type_enum, is_type_functional, is_type_struct, is_type_union, is_type_variable, is_type_void, NIL, pips_debug, pips_internal_error, POP, same_entity_p(), string_of_type(), type_fields(), type_tag, type_to_string(), type_variable, type_variable_p, type_void_p, variable_basic, and variable_dimensions.
Referenced by basic_concrete_types_compatible_for_effects_interprocedural_translation_p(), c_convex_effects_on_actual_parameter_forward_translation(), and types_compatible_for_effects_interprocedural_translation_p().
TODO most of the time return same result that !effect_reference_dereferencing_p for the moment want to test if r can be a constant path for instance a[i] have to return false (something else?) a[0], a[1], i, j, a[*], var points by formal parameter (_p_0, ...), element of strut (s.id, ...), heap element have to return true.
This function is not used by the points-to analysis, but by semantics
Definition at line 1492 of file type.c.
References effect_reference_dereferencing_p(), and strict_constant_path_p().
Referenced by update_reflhs_with_rhs_to_transformer().
computes the type of a cell reference representing a memory access path.
Cell references are not compatible with entity typing: spurious dimensions are added to handle struct fields and the dereferencing operator. BEWARE : does not work if field entity indices have been converted to ranks.
ref | is a reference from a cell. |
in particular, gets rid of non-store effect references
A reference to a function returns a pointer to a function of the very same time
FI: for some abstract locations that have type unknown instead of type variable, with basic overloaded
ref | ef |
to_be_freed | o_be_freed |
Definition at line 466 of file type.c.
References copy_type(), debug_off, debug_on, ENDP, entity_basic_concrete_type(), entity_name, is_basic_pointer, is_type_variable, make_basic(), make_type(), make_variable(), NIL, pips_debug, pips_internal_error, r_cell_reference_to_type(), ref, reference_indices, reference_to_string(), reference_variable, type_functional_p, type_tag, type_to_string(), type_undefined, type_unknown_p, and type_variable_p.
Referenced by cell_to_type(), formal_points_to_parameter(), multiple_pointer_assignment_to_post_pv(), points_to_reference_to_type(), and references_may_conflict_p().
to_be_freed | o_be_freed |
Definition at line 513 of file type.c.
References cell_gap_p, cell_preference, cell_reference, cell_reference_p, cell_reference_to_type(), pips_assert, preference_reference, and ref.
Referenced by cell_to_nowhere_sink(), external_call_to_post_pv(), generic_stub_source_to_sinks(), k_limit_points_to(), module_initial_parameter_pv(), safe_intrinsic_to_post_pv(), struct_assignment_to_points_to(), type_compatible_super_cell(), and type_compatible_with_points_to_cell_p().
entity effect_field_dimension_entity | ( | expression | exp, |
list | l_fields | ||
) |
type.c
exp | is an effect index expression which is either the rank or an entity corresponding to a struct, union or enum field |
l_fields | is the list of fields of the corresponding struct, union or enum |
exp | xp |
l_fields | _fields |
Definition at line 51 of file type.c.
References ENTITY, exp, expression_constant_p(), expression_to_entity(), expression_to_int(), gen_nth(), and rank.
Referenced by effect_indices_first_pointer_dimension_rank().
|
static |
recursively walks thru current_l_ind and current_type in parallel until a pointer dimension is found.
current_l_ind | is a list of effect reference indices. |
current_type | is the corresponding type in the original entity type arborescence |
exact_p | is a pointer to a bool, which is set to true if the result is not an approximation. |
ssume there is no pointer
FI: I do not understand this assert beacause an array may be referenced with a limited number of subscript to initialize a pointer.
irst skip array dimensions if any
Definition at line 72 of file type.c.
References basic_derived, basic_tag, basic_to_string(), CAR, CDR, derived_type_fields(), effect_field_dimension_entity(), ENDP, ENTITY, entity_basic_concrete_type(), entity_local_name(), entity_type, entity_user_name(), EXPRESSION, gen_length(), int, is_basic_derived, is_basic_pointer, pips_assert, pips_debug, POP, same_string_p, type_enum_p, type_to_string(), type_variable, type_variable_p, UNBOUNDED_DIMENSION_NAME, variable_basic, variable_dimensions, and variable_phi_p.
Referenced by effect_reference_first_pointer_dimension_rank().
ref | is an effect reference |
exact_p | is a pointer to a bool, which is set to true if the result is not an approximation. |
ref | ef |
exact_p | xact_p |
Definition at line 219 of file type.c.
References effect_reference_first_pointer_dimension_rank(), and ref.
ref | is an effect reference |
exact_p | is a pointer to a bool, which is set to true if the result is not an approximation. |
FI: ANY_MODULE:ANYWHERE should not be indexed because any indexing can be eliminated as it results in ANY_MODULE:ANYWHERE
FI: ANY_MODULE:ANYWHERE_b0, 1, 2 should not be indexed because any indexing can be eliminated and the reference replaced by a non-indexed reference to ANY_MODULE:ANYWHERE_bi , j, k depending on the type of the reference.
no dereferencement if scalar reference, in particular, gets rid of non store effect references
ref | ef |
exact_p | xact_p |
Definition at line 233 of file type.c.
References effect_reference_first_pointer_dimension_rank(), ENDP, entity_abstract_location_p(), entity_all_locations_p(), entity_typed_anywhere_locations_p(), gen_length(), int, pips_internal_error, ref, reference_indices, and reference_variable.
Referenced by can_be_constant_path_p(), convex_effect_to_constant_path_effects_with_pointer_values(), convex_effect_to_constant_path_effects_with_points_to(), effect_to_constant_path_effects_with_points_to(), generic_eval_cell_with_points_to(), references_may_conflict_p(), and simple_effect_to_constant_path_effects_with_pointer_values().
walks thru ref indices and ref entity type arborescence in parallel until a pointer dimension is found.
ref | is an effect reference |
exact_p | is a pointer to a bool, which is set to true if the result is not an approximation. |
if (FILE_star_effect_reference_p(ref))
Definition at line 180 of file type.c.
References effect_indices_first_pointer_dimension_rank(), effect_words_reference(), entity_basic_concrete_type(), pips_debug, ref, reference_indices, reference_variable, type_variable_p, and words_to_string().
Referenced by effect_reference_contains_pointer_dimension_p(), and effect_reference_dereferencing_p().
|
static |
Allocate a copy of expression "e" where calls to the unbounded function are replaced by calls to the zero function so that typing can be performed.
Definition at line 584 of file type.c.
References call_domain, gen_recurse, gen_true(), and substitute_unbounded_call().
Referenced by points_to_expression_to_type().
Find the subscript in the reference of cell "c" that would make the reference type be "t" if the subscript list were truncated just after it.
Select the longest possible subscript list.
Core dump if it is not possible.
No smart implementation: trial and error (probably already implemented somewhere else.
Let's try to add a zero subscript instead...
For the time being, no need to restore the reference in case of failure.
Definition at line 1274 of file type.c.
References array_pointer_type_equal_p(), cell_any_reference(), CONS, ENDP, EXPRESSION, free_reference(), gen_copy_seq(), gen_nconc(), gen_nreverse(), list_undefined, make_reference(), make_zero_expression(), NIL, pips_internal_error, points_to_reference_to_concrete_type(), POP, reference_indices, and reference_variable.
Referenced by offset_points_to_cell().
Definition at line 676 of file type.c.
References compute_basic_concrete_type(), free_type(), and points_to_cell_to_type().
Referenced by cell_must_point_to_nowhere_sink_in_set_p(), cell_points_to_non_null_sink_in_set_p(), cell_points_to_nowhere_sink_in_set_p(), cell_points_to_null_sink_in_set_p(), cells_to_read_or_write_effects(), create_scalar_stub_sink_cell(), create_stub_points_to(), expression_to_points_to_cells(), filter_formal_context_according_to_actual_context(), formal_source_to_sinks(), freed_list_to_points_to(), generic_points_to_cell_to_useful_pointer_cells(), list_assignment_to_points_to(), new_filter_formal_context_according_to_actual_context(), new_recursive_filter_formal_context_according_to_actual_context(), points_to_translation_mapping_is_typed_p(), points_to_translation_of_formal_parameters(), points_to_with_stripped_sink(), process_casted_sinks(), process_casted_sources(), recursive_filter_formal_context_according_to_actual_context(), remove_points_to_cell(), and source_to_sinks().
FI: I need more generality than is offered by cell_to_type()
to_be_freed | o_be_freed |
Definition at line 665 of file type.c.
References cell_any_reference(), cell_gap_p, pips_assert, points_to_reference_to_type(), ref, and type_undefined.
Referenced by any_source_to_sinks(), anywhere_source_to_sinks(), check_type_of_points_to_cells(), dereferencing_to_sinks(), expression_to_points_to_sources(), internal_pointer_assignment_to_points_to(), offset_cell(), points_to_cell_add_fixed_subscripts(), points_to_cell_to_concrete_type(), points_to_cell_types_compatibility(), points_to_set_block_projection(), points_to_source_to_translations(), recursive_cell_to_pointer_cells(), reduce_cell_to_pointer_type(), struct_initialization_to_points_to(), and subscript_to_points_to_sinks().
Make sure that cell l can points towards cell r.
FI-AM/FC: Unfortunately, a lot of specification work is missing to develop this function while taking care of abstract locations and their lattice.
Restrictions on cell "l"
1.1 "l" cannot be the abstract nowhere/undefined cell
...
Note: this should be part of points_to_set_consistent_p(), which is called consistent_points_to_set(), but this function goes beyond checking the compatibility. It enforces it when legal and possible.
Maybe this function should be relocated in alias-classes
Beware of possible side-effects on l
FI, 10 August 2012: this function is a mess. No side effect should be applied. it should be redesigned to check compatibility cases one after the other and it should be renamed points_to_cell_types_compatibility_p()
FI, 14 August 2012: the dimension of the sink entity and sink reference must be greater than the dimension of the source reference. This is not checked yet.
FI, 19 August 2012: all cells used in a points-to arc must be scalar, either pointers or basic types
&& overloaded_type_p(urt)
The source points towards an array and the cell is an element of this array.
Formal parameters and potentially stubs can be assumed to points towards an array although they are declared as pointers to a scalar.
This should never be a problem when sink cells are always array elements and not arrays.
Here we may be in trouble because of the heap modeling malloc() returns by default a "void *", or sometimes a "char *" which may be casted into anything...
The dimension of the allocated array should be given by the size of the pointed type and by the size of the right type.
Also, we have different heap modelling, with different flexibilities
& !all_heap_locations_typed_cell_p(r)
all_heap_locations_typed_cell_p(r)
There must be a typing issue.
This may happen with the heap model
Is it an (implicit) array of pointers
This may happen with the heap model
Definition at line 985 of file type.c.
References all_heap_locations_cell_p(), anywhere_cell_p(), array_pointer_type_equal_p(), array_type_p(), array_type_to_element_type(), basic_equal_p(), basic_int, basic_int_p, basic_pointer, basic_pointer_p, C_pointer_type_p(), cell_any_reference(), compute_basic_concrete_type(), CONS, copy_type(), DIMENSION, entity_name, entity_type, fprintf(), free_type(), functional_result, get_bool_property(), heap_cell_p(), int_to_expression(), make_dimension(), make_unbounded_expression(), NIL, nowhere_cell_p(), null_cell_p(), overloaded_type_p(), pips_internal_error, pointer_type_p(), points_to_cell_add_zero_subscripts(), points_to_cell_to_type(), points_to_sink_cell_compatible_p(), points_to_source_cell_compatible_p(), print_points_to_cell, print_type(), reference_add_zero_subscripts(), reference_variable, scalar_type_p(), string_type_p(), type_equal_up_to_typedefs_and_qualifiers_p(), type_functional, type_functional_p, type_to_pointed_type(), type_variable, type_variable_p, type_void_p, variable_basic, and variable_dimensions.
Referenced by create_stub_points_to(), and gen_may_constant_paths().
type points_to_expression_to_concrete_type | ( | expression | e | ) |
The type returned is stored in a hash-table.
It should not be freed. See compute_basic_concrete_type().
This function is useful to avoid the conditional free.
Definition at line 617 of file type.c.
References compute_basic_concrete_type(), free_type(), and points_to_expression_to_type().
Referenced by binary_intrinsic_call_to_points_to_sinks(), expression_to_points_to_cells(), freed_list_to_points_to(), intrinsic_call_condition_to_points_to(), intrinsic_call_to_points_to(), memory_dereferencing_p(), semantics_expression_to_points_to_sinks(), and unary_intrinsic_call_to_points_to_sinks().
type points_to_expression_to_pointed_type | ( | expression | e | ) |
Return a new allocated type "t" of the address pointed by expression "e", if expression "e" denotes an address.
"t" should not be freed.
We should return a pointer towards an array of dimension n-1. The first dimension is lost.
Build the pointed type, copy of cet except for its first dimension
Build the poiinter type
Definition at line 631 of file type.c.
References array_type_p(), CDR, compute_basic_concrete_type(), copy_basic(), copy_type(), free_type(), gen_full_copy_list(), make_basic_pointer(), make_type_variable(), make_variable(), NIL, pips_internal_error, pointer_type_p(), points_to_expression_to_type(), type_to_pointed_type(), type_undefined, type_variable, variable_basic, and variable_dimensions.
Referenced by expression_to_points_to_sinks_with_offset(), and unary_intrinsic_call_to_points_to_sinks().
type points_to_expression_to_type | ( | expression | e, |
bool * | to_be_freed | ||
) |
FI: I need more generality than is offered by expression_to_type() because fields are assimilated to subscripts.
In order to type t[*] as well as t[0]...
to_be_freed | o_be_freed |
Definition at line 592 of file type.c.
References copy_expression(), eliminate_calls_to_unbounded(), expression_syntax, expression_to_type(), free_expression(), points_to_reference_to_type(), syntax_reference, syntax_reference_p, and type_undefined.
Referenced by assignment_to_points_to(), check_rhs_value_types(), expression_to_points_to_sources(), pointer_arithmetic_to_points_to(), points_to_expression_to_concrete_type(), points_to_expression_to_pointed_type(), and subscript_to_points_to_sinks().
Definition at line 685 of file type.c.
References compute_basic_concrete_type(), free_type(), and points_to_reference_to_type().
Referenced by analyzed_reference_p(), assign_rhs_to_reflhs_to_transformer(), cells_to_read_or_write_effects(), consistent_points_to_arc_p(), create_values_for_simple_effect(), filter_formal_context_according_to_actual_context(), find_points_to_subscript_for_type(), generic_eval_cell_with_points_to(), generic_reference_to_transformer(), generic_transform_sink_cells_from_matching_list(), make_location_entity(), module_to_value_mappings(), new_filter_formal_context_according_to_actual_context(), perform_array_element_substitutions_in_transformer(), points_to_with_stripped_sink(), reference_to_address_entity(), reference_to_points_to_sinks(), semantics_usable_points_to_reference_p(), subscripted_reference_to_points_to(), substitute_stubs_in_transformer_with_translation_binding(), and use_default_sink_cell().
FI: I need more generality than is offered by cell_to_type()
Maybe because of fields.
Surely because of implicit arrays linked to scalar pointers
ref | ef |
to_be_freed | o_be_freed |
Definition at line 527 of file type.c.
References CAR, cell_reference_to_type(), ENDP, entity_field_p(), entity_scalar_p(), entity_type, EXPRESSION, expression_integer_constant_p(), expression_syntax, f(), gen_last(), gen_length(), int, ref, reference_indices, reference_variable, syntax_reference, syntax_reference_p, type_undefined, and type_undefined_p.
Referenced by adapt_reference_to_type(), create_scalar_stub_sink_cell(), gen_may_constant_paths(), gen_must_constant_paths(), opkill_may_constant_path(), opkill_must_constant_path(), points_to_cell_to_type(), points_to_expression_to_type(), points_to_reference_to_concrete_type(), points_to_reference_to_typed_index(), and reference_add_field_dimension().
Definition at line 1258 of file type.c.
Referenced by points_to_cell_types_compatibility().
Definition at line 1241 of file type.c.
References nowhere_cell_p(), and null_cell_p().
Referenced by points_to_cell_types_compatibility().
|
static |
Lines 291 to 682.
r_cell_reference_to_type cell_reference_to_type(reference ref, bool *to_be_freed) cell_to_type(cell c, bool * to_be_freed)
points_to_reference_to_type(reference r, bool * to_be_freed)
substitute_unbounded_call eliminate_calls_to_unbounded(expression e)
points_to_expression_to_type points_to_expression_to_concrete_type points_to_expression_to_pointed_type
points_to_cell_to_type points_to_cell_to_concrete_type
points_to_reference_to_concrete_type(reference r) cell references
the return type
current basic
current type array dimensions
the remainder of the function heavily relies on the following assumption
We have reached the current type and there are no array dimensions to skip
skip common array dimensions if any
We have reached the current basic
Warning : qualifiers are set to NIL, because I do not see the need for something else for the moment. BC.
Sub arrays are pointers to arrays, not arrays, at least for gcc
a[10][20][30] -> a is int (*)[20][30] -> a[1] is int *[30] -> a[1][2] is int *
Beatrice's version
The cell reference contains indices that go beyond the current type array dimensions. This can happen if and only if the current basic is a pointer or a derived (typedef have been eliminated by the use of basic_concrete_type).
if the input type is a bct, then I think there is no need to compute the bct of a basic_pointer. BC.
ype new_current_type = compute_basic_concrete_type(basic_pointer(current_basic));
pop the pointer dimension
free_type(new_current_type);
the next reference index should be a field entity
pop the field dimension
Definition at line 315 of file type.c.
References basic_pointer, basic_tag, basic_to_string(), CAR, CDR, copy_basic(), copy_type(), ENDP, entity_basic_concrete_type(), entity_field_p(), EXPRESSION, expression_syntax, gen_full_copy_list(), gen_length(), ifdebug, int, is_basic_derived, is_basic_overloaded, is_basic_pointer, is_type_variable, is_type_void, make_type(), make_variable(), MIN, NIL, pips_debug, pips_internal_error, POP, reference_variable, syntax_reference, syntax_reference_p, type_tag, type_to_pointer_type(), type_to_string(), type_undefined, type_variable, type_variable_p, variable_basic, and variable_dimensions.
Referenced by cell_reference_to_type().
This function should be at expression.c.
It already exist and is called reference_with_unbounded_indices_p() but includes two cases that should be disjoint: constant indices and unbounded ones.
Definition at line 1373 of file type.c.
References EXPRESSION, FOREACH, reference_indices, and unbounded_expression_p().
Referenced by strict_constant_path_p().
Definition at line 1407 of file type.c.
References ENDP, entity_abstract_location_p(), entity_all_dynamic_locations_p(), entity_all_heap_locations_p(), entity_all_locations_p(), entity_all_module_dynamic_locations_p(), entity_all_module_heap_locations_p(), entity_all_module_locations_p(), entity_all_module_stack_locations_p(), entity_all_module_static_locations_p(), entity_all_stack_locations_p(), entity_all_static_locations_p(), entity_anywhere_locations_p(), entity_nowhere_locations_p(), entity_null_locations_p(), entity_stub_sink_p(), entity_type, entity_typed_anywhere_locations_p(), entity_typed_nowhere_locations_p(), heap_area_p(), reference_indices, reference_unbounded_indices_p(), reference_variable, and struct_type_p().
Referenced by can_be_constant_path_p().
|
static |
Definition at line 570 of file type.c.
References call_function, entity_local_name(), f(), int_to_entity(), same_string_p, and UNBOUNDED_DIMENSION_NAME.
Referenced by eliminate_calls_to_unbounded().
bool types_compatible_for_effects_interprocedural_translation_p | ( | type | real_arg_t, |
type | formal_arg_t | ||
) |
tests if the actual argument type and the formal argument type are compatible with the current state of the interprocedural translation algorithms.
safe default result
real_arg_t | eal_arg_t |
formal_arg_t | ormal_arg_t |
Definition at line 932 of file type.c.
References basic_concrete_types_compatible_for_effects_interprocedural_translation_p(), compute_basic_concrete_type(), and free_type().
Referenced by c_convex_effects_on_formal_parameter_backward_translation().