From ce2d0ce29312a50296919565818edbb98543ae18 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Wed, 11 Nov 2020 15:24:28 +0100 Subject: [PATCH] Remove superfluous call to Base_Type gcc/ada/ChangeLog: * gcc-interface/gigi.h: Remove ^L characters throughout. * gcc-interface/decl.c: Likewise. * gcc-interface/utils.c: Likewise. * gcc-interface/utils2.c: Likewise. * gcc-interface/trans.c (gnat_to_gnu) : Do not explicitly go to the base type for the Has_Constrained_Partial_View flag. --- gcc/ada/gcc-interface/decl.c | 38 +++++++++--------- gcc/ada/gcc-interface/gigi.h | 2 +- gcc/ada/gcc-interface/trans.c | 70 +++++++++++++++++----------------- gcc/ada/gcc-interface/utils.c | 62 +++++++++++++++--------------- gcc/ada/gcc-interface/utils2.c | 32 ++++++++-------- 5 files changed, 101 insertions(+), 103 deletions(-) diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c index baae58a025f..fa17ad9453f 100644 --- a/gcc/ada/gcc-interface/decl.c +++ b/gcc/ada/gcc-interface/decl.c @@ -261,7 +261,7 @@ typedef struct { } intrin_binding_t; static bool intrin_profiles_compatible_p (intrin_binding_t *); - + /* Given GNAT_ENTITY, a GNAT defining identifier node, which denotes some Ada entity, return the equivalent GCC tree for that entity (a ..._DECL node) and associate the ..._DECL node with the input GNAT defining identifier. @@ -6578,7 +6578,7 @@ update_n_elem (tree n_elem, tree min, tree max) return n_elem; } - + /* Given GNAT_ENTITY, elaborate all expressions that are required to be elaborated at the point of its definition, but do nothing else. */ @@ -6635,7 +6635,7 @@ elaborate_entity (Entity_Id gnat_entity) } } - + /* Prepend to ATTR_LIST an entry for an attribute with provided TYPE, NAME, ARGS and ERROR_POINT. */ @@ -6750,7 +6750,7 @@ prepend_attributes (struct attrib **attr_list, Entity_Id gnat_entity) if (Nkind (gnat_temp) == N_Pragma) prepend_one_attribute_pragma (attr_list, gnat_temp); } - + /* Given a GNAT tree GNAT_EXPR, for an expression which is a value within a type definition (either a bound or a discriminant value) for GNAT_ENTITY, return the GCC tree to use for that expression. S is the suffix to use @@ -6957,7 +6957,7 @@ elaborate_reference (tree ref, Entity_Id gnat_entity, bool definition, struct er_data er = { gnat_entity, definition, 0 }; return gnat_rewrite_reference (ref, elaborate_reference_1, &er, init); } - + /* Given a GNU tree and a GNAT list of choices, generate an expression to test the value passed against the list of choices. */ @@ -7054,7 +7054,7 @@ choices_to_gnu (tree gnu_operand, Node_Id gnat_choices) return gnu_result; } - + /* Adjust PACKED setting as passed to gnat_to_gnu_field for a field of type FIELD_TYPE to be placed in RECORD_TYPE. Return the result. */ @@ -7467,7 +7467,7 @@ gnat_to_gnu_field (Entity_Id gnat_field, tree gnu_record_type, int packed, return gnu_field; } - + /* Return true if at least one member of COMPONENT_LIST needs strict alignment. */ @@ -8433,7 +8433,7 @@ components_to_record (Node_Id gnat_component_list, Entity_Id gnat_record_type, return (gnu_rep_list && !p_gnu_rep_list) || variants_have_rep; } - + /* Given GNU_SIZE, a GCC tree representing a size, return a Uint to be placed into an Esize, Component_Bit_Offset, or Component_Size value in the GNAT tree. */ @@ -8801,7 +8801,7 @@ annotate_rep (Entity_Id gnat_entity, tree gnu_type) } } } - + /* Scan all fields in GNU_TYPE and return a TREE_LIST where TREE_PURPOSE is the FIELD_DECL and TREE_VALUE a TREE_VEC containing the byte position, the value to be placed into DECL_OFFSET_ALIGN and the bit position. The list @@ -8959,7 +8959,7 @@ build_variant_list (tree gnu_qual_union_type, Node_Id gnat_variant_part, return gnu_list; } - + /* If SIZE has overflowed, return the maximum valid size, which is the upper bound of the signed sizetype in bits, rounded down to ALIGN. Otherwise return SIZE unmodified. */ @@ -9103,7 +9103,7 @@ validate_size (Uint uint_size, tree gnu_type, Entity_Id gnat_object, return size; } - + /* Similarly, but both validate and process a value of RM size. This routine is only called for types. */ @@ -9180,7 +9180,7 @@ set_rm_size (Uint uint_size, tree gnu_type, Entity_Id gnat_entity) && !TYPE_FAT_POINTER_P (gnu_type)) SET_TYPE_ADA_SIZE (gnu_type, size); } - + /* ALIGNMENT is a Uint giving the alignment specified for GNAT_ENTITY, a type or object whose present alignment is ALIGN. If this alignment is valid, return it. Otherwise, give an error and return ALIGN. */ @@ -9273,7 +9273,7 @@ validate_alignment (Uint alignment, Entity_Id gnat_entity, unsigned int align) return align; } - + /* Promote the alignment of GNU_TYPE corresponding to GNAT_ENTITY. Return a positive value on success or zero on failure. */ @@ -9320,7 +9320,7 @@ promote_object_alignment (tree gnu_type, Entity_Id gnat_entity) return align; } - + /* Verify that TYPE is something we can implement atomically. If not, issue an error for GNAT_ENTITY. COMPONENT_P is true if we are being called to process a component type. */ @@ -9388,7 +9388,7 @@ check_ok_for_atomic_type (tree type, Entity_Id gnat_entity, bool component_p) post_error_ne ("atomic access to & cannot be guaranteed", gnat_error_point, gnat_entity); } - + /* Helper for the intrin compatibility checks family. Evaluate whether two types are definitely incompatible. */ @@ -9543,7 +9543,7 @@ intrin_profiles_compatible_p (intrin_binding_t * inb) return return_compatible_p && arglists_compatible_p; } - + /* Return a FIELD_DECL node modeled on OLD_FIELD. FIELD_TYPE is its type and RECORD_TYPE is the type of the parent. If SIZE is nonzero, it is the specified size for this field. POS_LIST is a position list describing @@ -10157,7 +10157,7 @@ associate_original_type_to_packed_array (tree gnu_type, Entity_Id gnat_entity) return NULL_TREE; } } - + /* Given a type T, a FIELD_DECL F, and a replacement value R, return an equivalent type with adjusted size expressions where all occurrences of references to F in a PLACEHOLDER_EXPR have been replaced by R. @@ -10318,7 +10318,7 @@ substitute_in_type (tree t, tree f, tree r) return t; } } - + /* Return the RM size of GNU_TYPE. This is the actual number of bits needed to represent the object. */ @@ -10347,7 +10347,7 @@ rm_size (tree gnu_type) /* For other types, this is just the size. */ return TYPE_SIZE (gnu_type); } - + /* Return the name to be used for GNAT_ENTITY. If a type, create a fully-qualified name, possibly with type information encoding. Otherwise, return the name. */ diff --git a/gcc/ada/gcc-interface/gigi.h b/gcc/ada/gcc-interface/gigi.h index 355178e284f..328e5f3a119 100644 --- a/gcc/ada/gcc-interface/gigi.h +++ b/gcc/ada/gcc-interface/gigi.h @@ -325,7 +325,7 @@ extern int double_scalar_alignment; /* True if floating-point arithmetics may use wider intermediate results. */ extern bool fp_arith_may_widen; - + /* Data structures used to represent attributes. */ enum attrib_type diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c index 7be8463d32b..4bd9c8dafca 100644 --- a/gcc/ada/gcc-interface/trans.c +++ b/gcc/ada/gcc-interface/trans.c @@ -255,7 +255,7 @@ static bool maybe_make_gnu_thunk (Entity_Id gnat_thunk, tree gnu_thunk); of configurations. */ static const char *extract_encoding (const char *) ATTRIBUTE_UNUSED; static const char *decode_name (const char *) ATTRIBUTE_UNUSED; - + /* This makes gigi's file_info_ptr visible in this translation unit, so that Sloc_to_locus can look it up when deciding whether to map decls to instances. */ @@ -735,7 +735,7 @@ gigi (Node_Id gnat_root, /* We cannot track the location of errors past this point. */ Current_Error_Node = Empty; } - + /* Return a subprogram decl corresponding to __gnat_rcheck_xx for the given CHECK if KIND is EXCEPTION_SIMPLE, or else to __gnat_rcheck_xx_ext. */ @@ -779,7 +779,7 @@ build_raise_check (int check, enum exception_info_kind kind) return result; } - + /* Return a positive value if an lvalue is required for GNAT_NODE, which is an N_Attribute_Reference. */ @@ -1599,7 +1599,7 @@ Pragma_to_gnu (Node_Id gnat_node) return gnu_result; } - + /* Check the inline status of nested function FNDECL wrt its parent function. If a non-inline nested function is referenced from an inline external @@ -1645,7 +1645,7 @@ check_inlining_for_nested_subprog (tree fndecl) DECL_UNINLINABLE (parent_decl) = 1; } } - + /* Return an expression for the length of TYPE, an integral type, computed in RESULT_TYPE, another integral type. @@ -2590,7 +2590,7 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, int attribute) *gnu_result_type_p = gnu_result_type; return gnu_result; } - + /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Case_Statement, to a GCC tree, which is returned. */ @@ -2715,7 +2715,7 @@ Case_Statement_to_gnu (Node_Id gnat_node) return gnu_result; } - + /* Return true if we are in the body of a loop. */ static inline bool @@ -3328,7 +3328,7 @@ Loop_Statement_to_gnu (Node_Id gnat_node) return gnu_result; } - + /* This page implements a form of Named Return Value optimization modeled on the C++ optimization of the same name. The main difference is that we disregard any semantical considerations when applying it here, the @@ -3820,7 +3820,7 @@ build_return_expr (tree ret_obj, tree ret_val) return build1 (RETURN_EXPR, void_type_node, result_expr); } - + /* Subroutine of gnat_to_gnu to process gnat_node, an N_Subprogram_Body. We don't return anything. */ @@ -4144,7 +4144,7 @@ Subprogram_Body_to_gnu (Node_Id gnat_node) else rest_of_subprog_body_compilation (gnu_subprog_decl); } - + /* The type of an atomic access. */ typedef enum { NOT_ATOMIC, SIMPLE_ATOMIC, OUTER_ATOMIC } atomic_acces_t; @@ -4334,8 +4334,8 @@ not_atomic: *type = NOT_ATOMIC; *sync = false; } - - /* Return true if GNAT_NODE requires simple atomic access and, if so, set SYNC + +/* Return true if GNAT_NODE requires simple atomic access and, if so, set SYNC according to the associated synchronization setting. */ static inline bool @@ -5205,7 +5205,7 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, return gnu_result; } - + /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Handled_Sequence_Of_Statements, to a GCC tree, which is returned. */ @@ -5444,7 +5444,7 @@ Handled_Sequence_Of_Statements_to_gnu (Node_Id gnat_node) return gnu_result; } - + /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Exception_Handler, to a GCC tree, which is returned. This is the variant for front-end sjlj exception handling. */ @@ -5513,7 +5513,7 @@ Exception_Handler_to_gnu_fe_sjlj (Node_Id gnat_node) return build3 (COND_EXPR, void_type_node, gnu_choice, gnu_body, NULL_TREE); } - + /* Return true if no statement in GNAT_LIST can alter the control flow. */ static bool @@ -5720,7 +5720,7 @@ Exception_Handler_to_gnu_gcc (Node_Id gnat_node) return build2 (CATCH_EXPR, void_type_node, gnu_etypes_list, end_stmt_group ()); } - + /* Subroutine of gnat_to_gnu to generate code for an N_Compilation unit. */ static void @@ -5850,7 +5850,7 @@ Compilation_Unit_to_gnu (Node_Id gnat_node) /* Force the processing for all nodes that remain in the queue. */ process_deferred_decl_context (true); } - + /* Mark COND, a boolean expression, as predicating a call to a noreturn function, i.e. predict that it is very likely false, and return it. @@ -6064,7 +6064,7 @@ Raise_Error_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p) return gnu_result; } - + /* Return true if GNAT_NODE is on the LHS of an assignment or an actual parameter of a call. */ @@ -7159,9 +7159,7 @@ gnat_to_gnu (Node_Id gnat_node) const Entity_Id gnat_desig_type = Designated_Type (Underlying_Type (Etype (gnat_node))); - /* The flag is effectively only set on the base types. */ - ignore_init_type - = Has_Constrained_Partial_View (Base_Type (gnat_desig_type)); + ignore_init_type = Has_Constrained_Partial_View (gnat_desig_type); gnu_init = gnat_to_gnu (Expression (gnat_temp)); gnu_init = maybe_unconstrained_array (gnu_init); @@ -8331,7 +8329,7 @@ gnat_to_gnu_external (Node_Id gnat_node) return gnu_result; } - + /* Return true if the statement list STMT_LIST is empty. */ static bool @@ -8375,7 +8373,7 @@ insert_code_for (Node_Id gnat_node) save_gnu_tree (gnat_node, NULL_TREE, true); } - + /* Start a new statement group chained to the previous group. */ void @@ -8647,7 +8645,7 @@ build_stmt_group (List_Id gnat_list, bool binding_p) return end_stmt_group (); } - + /* Generate GIMPLE in place for the expression at *EXPR_P. */ int @@ -8896,7 +8894,7 @@ gnat_gimplify_stmt (tree *stmt_p) gcc_unreachable (); } } - + /* Force a reference to each of the entities in GNAT_PACKAGE recursively. This routine is exclusively called in type_annotate mode, to compute DDA @@ -9022,7 +9020,7 @@ elaborate_all_entities (Node_Id gnat_node) if (Nkind (Unit (gnat_node)) == N_Package_Body) elaborate_all_entities (Library_Unit (gnat_node)); } - + /* Do the processing of GNAT_NODE, an N_Freeze_Entity. */ static void @@ -9162,7 +9160,7 @@ process_freeze_entity (Node_Id gnat_node) used_types_insert (TREE_TYPE (gnu_new)); } } - + /* Elaborate decls in the lists GNAT_DECLS and GNAT_DECLS2, if present. We make two passes, one to elaborate anything other than bodies (but we declare a function if there was no spec). The second pass @@ -9297,7 +9295,7 @@ process_decls (List_Id gnat_decls, List_Id gnat_decls2, add_stmt (gnat_to_gnu (gnat_decl)); } } - + /* Make a unary operation of kind CODE using build_unary_op, but guard the operation by an overflow check. CODE can be one of NEGATE_EXPR or ABS_EXPR. GNU_TYPE is the type desired for the result. Usually @@ -9545,7 +9543,7 @@ emit_check (tree gnu_cond, tree gnu_expr, int reason, Node_Id gnat_node) : build_int_cst (TREE_TYPE (gnu_expr), 0)), gnu_expr); } - + /* Return an expression that converts GNU_EXPR to GNAT_TYPE, doing overflow checks if OVERFLOW_P is true. If TRUNCATE_P is true, do a fp-to-integer conversion with truncation, otherwise round. GNAT_NODE is the GNAT node @@ -9730,7 +9728,7 @@ convert_with_check (Entity_Id gnat_type, tree gnu_expr, bool overflow_p, return convert (gnu_type, gnu_result); } - + /* Return true if GNU_EXPR can be directly addressed. This is the case unless it is an expression involving computation or if it involves a reference to a bitfield or to an object not sufficiently aligned for @@ -9908,7 +9906,7 @@ addressable_p (tree gnu_expr, tree gnu_type) return false; } } - + /* Do the processing for the declaration of a GNAT_ENTITY, a type or subtype. If a Freeze node exists for the entity, delay the bulk of the processing. Otherwise make a GCC type for GNAT_ENTITY and set up the correspondence. */ @@ -9992,7 +9990,7 @@ process_type (Entity_Id gnat_entity) TREE_TYPE (gnu_new)); } } - + /* Subroutine of assoc_to_constructor: VALUES is a list of field associations, some of which are from RECORD_TYPE. Return a CONSTRUCTOR consisting of the associations that are from RECORD_TYPE. If we see an internal record, make @@ -10146,7 +10144,7 @@ pos_to_constructor (Node_Id gnat_expr, tree gnu_array_type) return gnat_build_constructor (gnu_array_type, gnu_expr_vec); } - + /* Process a N_Validate_Unchecked_Conversion node. */ static void @@ -10205,7 +10203,7 @@ validate_unchecked_conversion (Node_Id gnat_node) } } } - + /* Convert SLOC into LOCUS. Return true if SLOC corresponds to a source code location and false if it doesn't. If CLEAR_COLUMN is true, set the column information to 0. If DECL is given and SLOC @@ -10387,7 +10385,7 @@ set_end_locus_from_node (tree gnu_node, Node_Id gnat_node) return false; } } - + /* Return a colon-separated list of encodings contained in encoded Ada name. */ @@ -10408,7 +10406,7 @@ decode_name (const char *name) __gnat_decode (name, decoded, 0); return decoded; } - + /* Post an error message. MSG is the error message, properly annotated. NODE is the node at which to post the error and the node to use for the '&' substitution. */ diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c index dfde06e48c1..013fccdd657 100644 --- a/gcc/ada/gcc-interface/utils.c +++ b/gcc/ada/gcc-interface/utils.c @@ -357,7 +357,7 @@ add_deferred_decl_context (tree decl, Entity_Id gnat_scope, int force_global); computed. */ static void add_deferred_type_context (struct deferred_decl_context_node *n, tree type); - + /* Initialize data structures of the utils.c module. */ void @@ -397,7 +397,7 @@ destroy_gnat_utils (void) pad_type_hash_table->empty (); pad_type_hash_table = NULL; } - + /* GNAT_ENTITY is a GNAT tree node for an entity. Associate GNU_DECL, a GCC tree node, with GNAT_ENTITY. If GNU_DECL is not a ..._DECL node, abort. If NO_CHECK is true, the latter check is suppressed. @@ -438,7 +438,7 @@ present_gnu_tree (Entity_Id gnat_entity) { return PRESENT_GNU_TREE (gnat_entity); } - + /* Make a dummy type corresponding to GNAT_TYPE. */ tree @@ -533,7 +533,7 @@ build_dummy_unc_pointer_types (Entity_Id gnat_desig_type, tree gnu_desig_type) TYPE_REFERENCE_TO (gnu_desig_type) = gnu_fat_type; TYPE_OBJECT_RECORD_TYPE (gnu_desig_type) = gnu_object_type; } - + /* Return true if we are in the global binding level. */ bool @@ -663,7 +663,7 @@ gnat_zaplevel (void) level->chain = free_binding_level; free_binding_level = level; } - + /* Set the context of TYPE and its parallel types (if any) to CONTEXT. */ static void @@ -935,7 +935,7 @@ gnat_pushdecl (tree decl, Node_Id gnat_node) } } } - + /* Create a record type that contains a SIZE bytes long field of TYPE with a starting bit position so that it is aligned to ALIGN bits, and leaving at least ROOM bytes free before the field. BASE_ALIGN is the alignment the @@ -1772,7 +1772,7 @@ set_reverse_storage_order_on_pad_type (tree type) TYPE_REVERSE_STORAGE_ORDER (type) = 1; return canonicalize_pad_type (type); } - + /* Relate the alias sets of GNU_NEW_TYPE and GNU_OLD_TYPE according to OP. If this is a multi-dimensional array type, do this recursively. @@ -1847,7 +1847,7 @@ relate_alias_sets (tree gnu_new_type, tree gnu_old_type, enum alias_set_op op) record_component_aliases (gnu_new_type); } - + /* Record TYPE as a builtin type for Ada. NAME is the name of the type. ARTIFICIAL_P is true if the type was generated by the compiler. */ @@ -1863,7 +1863,7 @@ record_builtin_type (const char *name, tree type, bool artificial_p) if (debug_hooks->type_decl) debug_hooks->type_decl (type_decl, false); } - + /* Finish constructing the character type CHAR_TYPE. In Ada character types are enumeration types and, as a consequence, are @@ -2558,7 +2558,7 @@ split_plus (tree in, tree *pvar) else return bitsize_zero_node; } - + /* Return a copy of TYPE but safe to modify in any way. */ tree @@ -2595,7 +2595,7 @@ copy_type (tree type) return new_type; } - + /* Return a subtype of sizetype with range MIN to MAX and whose TYPE_INDEX_TYPE is INDEX. GNAT_NODE is used for the position of the associated TYPE_DECL. */ @@ -2634,8 +2634,8 @@ create_range_type (tree type, tree min, tree max) return range_type; } - - /* Return an extra subtype of TYPE with range MIN to MAX. */ + +/* Return an extra subtype of TYPE with range MIN to MAX. */ tree create_extra_subtype (tree type, tree min, tree max) @@ -2652,7 +2652,7 @@ create_extra_subtype (tree type, tree min, tree max) return subtype; } - + /* Return a TYPE_DECL node suitable for the TYPE_STUB_DECL field of TYPE. NAME gives the name of the type to be used in the declaration. */ @@ -2718,7 +2718,7 @@ create_type_decl (tree name, tree type, bool artificial_p, bool debug_info_p, return type_decl; } - + /* Return a VAR_DECL or CONST_DECL node. NAME gives the name of the variable. ASM_NAME is its assembler name @@ -2886,7 +2886,7 @@ create_var_decl (tree name, tree asm_name, tree type, tree init, return var_decl; } - + /* Return true if TYPE, an aggregate type, contains (or is) an array. If SELF_REFERENTIAL is true, then an additional requirement on the array is that it be self-referential. */ @@ -3097,7 +3097,7 @@ create_field_decl (tree name, tree type, tree record_type, tree size, tree pos, return field_decl; } - + /* Return a PARM_DECL node with NAME and TYPE. */ tree @@ -3131,7 +3131,7 @@ create_param_decl (tree name, tree type) DECL_ARG_TYPE (param_decl) = type; return param_decl; } - + /* Process the attributes in ATTR_LIST for NODE, which is either a DECL or a TYPE. If IN_PLACE is true, the tree pointed to by NODE should not be changed. GNAT_NODE is used for the position of error messages. */ @@ -3420,7 +3420,7 @@ create_label_decl (tree name, Node_Id gnat_node) return label_decl; } - + /* Return a FUNCTION_DECL node. NAME is the name of the subprogram, ASM_NAME its assembler name, TYPE its type (a FUNCTION_TYPE or METHOD_TYPE node), PARAM_DECL_LIST the list of its parameters (a list of PARM_DECL nodes @@ -3558,7 +3558,7 @@ finish_subprog_decl (tree decl, tree asm_name, tree type) DECL_NAME (decl) = main_identifier_node; } } - + /* Set up the framework for generating code for SUBPROG_DECL, a subprogram body. This routine needs to be invoked before processing the declarations appearing in the subprogram. */ @@ -3830,7 +3830,7 @@ fntype_same_flags_p (const_tree t, tree cico_list, bool return_unconstrained_p, && TYPE_RETURN_BY_DIRECT_REF_P (t) == return_by_direct_ref_p && TREE_ADDRESSABLE (t) == return_by_invisi_ref_p; } - + /* EXP is an expression for the size of an object. If this size contains discriminant references, replace them with the maximum (if MAX_P) or minimum (if !MAX_P) possible value of the discriminant. @@ -4042,7 +4042,7 @@ max_size (tree exp, bool max_p) gcc_unreachable (); } - + /* Build a template of type TEMPLATE_TYPE from the array bounds of ARRAY_TYPE. EXPR is an expression that we can use to locate any PLACEHOLDER_EXPRs. Return a constructor for the template. */ @@ -4108,7 +4108,7 @@ build_template (tree template_type, tree array_type, tree expr) return gnat_build_constructor (template_type, template_elts); } - + /* Return true if TYPE is suitable for the element type of a vector. */ static bool @@ -4198,7 +4198,7 @@ build_vector_type_for_array (tree array_type, tree attribute) TYPE_REPRESENTATIVE_ARRAY (vector_type) = array_type; return vector_type; } - + /* Build a type to be used to represent an aliased object whose nominal type is an unconstrained array. This consists of a RECORD_TYPE containing a field of TEMPLATE_TYPE and a field of OBJECT_TYPE, which is an ARRAY_TYPE. @@ -4248,7 +4248,7 @@ build_unc_object_type_from_ptr (tree thin_fat_ptr_type, tree object_type, return build_unc_object_type (template_type, object_type, name, debug_info_p); } - + /* Update anything previously pointing to OLD_TYPE to point to NEW_TYPE. In the normal case this is just two adjustments, but we have more to do if NEW_TYPE is an UNCONSTRAINED_ARRAY_TYPE. */ @@ -4379,7 +4379,7 @@ update_pointer_to (tree old_type, tree new_type) TYPE_REFERENCE_TO (old_type) = NULL_TREE; } } - + /* Convert EXPR, a pointer to a constrained array, into a pointer to an unconstrained one. This involves making or finding a template. */ @@ -4483,7 +4483,7 @@ convert_to_fat_pointer (tree type, tree expr) CONSTRUCTOR_APPEND_ELT (v, DECL_CHAIN (TYPE_FIELDS (type)), template_addr); return gnat_build_constructor (type, v); } - + /* Create an expression whose value is that of EXPR, converted to type TYPE. The TREE_TYPE of the value is always TYPE. This function implements all reasonable @@ -5170,7 +5170,7 @@ convert_to_index_type (tree expr) return convert (sizetype, expr); } - + /* Remove all conversions that are done in EXP. This includes converting from a padded type or to a justified modular type. If TRUE_ADDRESS is true, always return the address of the containing object even if @@ -5205,7 +5205,7 @@ remove_conversions (tree exp, bool true_address) return exp; } - + /* If EXP's type is an UNCONSTRAINED_ARRAY_TYPE, return an expression that refers to the underlying array. If it has TYPE_CONTAINS_TEMPLATE_P, likewise return an expression pointing to the underlying array. */ @@ -5293,7 +5293,7 @@ maybe_unconstrained_array (tree exp) return exp; } - + /* Return true if EXPR is an expression that can be folded as an operand of a VIEW_CONVERT_EXPR. See ada-tree.h for a complete rationale. */ @@ -5687,7 +5687,7 @@ unchecked_convert (tree type, tree expr, bool notrunc_p) return expr; } - + /* Return the appropriate GCC tree code for the specified GNAT_TYPE, the latter being a record type as predicated by Is_Record_Type. */ diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c index c8a2d7c31be..316033bdf60 100644 --- a/gcc/ada/gcc-interface/utils2.c +++ b/gcc/ada/gcc-interface/utils2.c @@ -73,7 +73,7 @@ get_base_type (tree type) return type; } - + /* EXP is a GCC tree representing an address. See if we can find how strictly the object at this address is aligned and, if so, return the alignment of the object in bits. Otherwise return 0. */ @@ -203,7 +203,7 @@ known_alignment (tree exp) return this_alignment; } - + /* We have a comparison or assignment operation on two types, T1 and T2, which are either both array types or both record types. T1 is assumed to be for the left hand side operand, and T2 for the right hand side. Return the @@ -271,7 +271,7 @@ find_common_type (tree t1, tree t2) could cause a bad self-referential reference. */ return NULL_TREE; } - + /* Return an expression tree representing an equality comparison of A1 and A2, two objects of type ARRAY_TYPE. The result should be of type RESULT_TYPE. @@ -533,7 +533,7 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2) build_binary_op (TRUTH_ORIF_EXPR, result_type, p1_array_is_null, same_bounds)); } - + /* Compute the result of applying OP_CODE to LHS and RHS, where both are of type TYPE. We know that TYPE is a modular type with a nonbinary modulus. */ @@ -629,7 +629,7 @@ nonbinary_modular_operation (enum tree_code op_code, tree type, tree lhs, return convert (type, result); } - + /* This page contains routines that implement the Ada semantics with regard to atomic objects. They are fully piggybacked on the middle-end support for atomic loads and stores. @@ -828,7 +828,7 @@ build_load_modify_store (tree dest, tree src, Node_Id gnat_node) /* Something went wrong earlier if we have not found the atomic load. */ gcc_unreachable (); } - + /* Make a binary operation of kind OP_CODE. RESULT_TYPE is the type desired for the result. Usually the operation is to be performed in that type. For INIT_EXPR and MODIFY_EXPR, RESULT_TYPE must be @@ -1323,7 +1323,7 @@ build_binary_op (enum tree_code op_code, tree result_type, return result; } - + /* Similar, but for unary operations. */ tree @@ -1683,7 +1683,7 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand) return result; } - + /* Similar, but for COND_EXPR. */ tree @@ -1758,7 +1758,7 @@ build_compound_expr (tree result_type, tree stmt_operand, tree expr_operand) return result; } - + /* Conveniently construct a function call expression. FNDECL names the function to be called, N is the number of arguments, and the "..." parameters are the argument expressions. Unlike build_call_expr @@ -1776,7 +1776,7 @@ build_call_n_expr (tree fndecl, int n, ...) va_end (ap); return fn; } - + /* Build a goto to LABEL for a raise, with an optional call to Local_Raise. MSG gives the exception's identity for the call to Local_Raise, if any. */ @@ -1924,7 +1924,7 @@ build_call_raise_range (int msg, Node_Id gnat_node, char kind, convert (integer_type_node, first), convert (integer_type_node, last)); } - + /* qsort comparer for the bit positions of two constructor elements for record components. */ @@ -1987,7 +1987,7 @@ gnat_build_constructor (tree type, vec *v) TREE_READONLY (result) = TYPE_READONLY (type) || read_only || allconstant; return result; } - + /* Return a COMPONENT_REF to access FIELD in RECORD, or NULL_TREE if the field is not found in the record. Don't fold the result if NO_FOLD is true. */ @@ -2113,7 +2113,7 @@ build_component_ref (tree record, tree field, bool no_fold) build_call_raise (CE_Discriminant_Check_Failed, Empty, N_Raise_Constraint_Error)); } - + /* Helper for build_call_alloc_dealloc, with arguments to be interpreted identically. Process the case where a GNAT_PROC to call is provided. */ @@ -2326,7 +2326,7 @@ build_call_alloc_dealloc (tree gnu_obj, tree gnu_size, tree gnu_type, return maybe_wrap_malloc (gnu_size, gnu_type, gnat_node); } } - + /* Build a GCC tree that corresponds to allocating an object of TYPE whose initial value is INIT, if INIT is nonzero. Convert the expression to RESULT_TYPE, which must be some pointer type, and return the result. @@ -2457,7 +2457,7 @@ build_allocator (tree type, tree init, tree result_type, Entity_Id gnat_proc, return storage; } - + /* Indicate that we need to take the address of T and that it therefore should not be allocated in a register. Return true if successful. */ @@ -2505,7 +2505,7 @@ gnat_mark_addressable (tree t) return true; } } - + /* Return true if EXP is a stable expression for the purpose of the functions below and, therefore, can be returned unmodified by them. We accept things that are actual constants or that have already been handled. */ -- 2.30.2