2009-04-22 Eric Botcazou <ebotcazou@adacore.com>
+ * gcc-interface/ada-tree.def: Fix formatting nits.
+ (REGION_STMT): Delete.
+ (HANDLER_STMT): Likewise.
+ * gcc-interface/ada-tree.h: Fix formatting nits.
+ (IS_STMT): Delete.
+ (REGION_STMT_BODY): Likewise.
+ (REGION_STMT_HANDLE): Likewise.
+ (REGION_STMT_BLOCK): Likewise.
+ (HANDLER_STMT_ARG): Likewise.
+ (HANDLER_STMT_LIST): Likewise.
+ (HANDLER_STMT_BLOCK): Likewise.
+ * gcc-interface/gigi.h (fp_prec_to_size): Update comment.
+ (fp_size_to_prec): Likewise.
+ (largest_move_alignment): Delete.
+ (gnat_compute_largest_alignment): Likewise.
+ Fix minor nits.
+ * gcc-interface/decl.c (gnat_to_gnu_entity) <E_Signed_Integer_Subtype>:
+ Remove redundant code.
+ <E_Array_Type>: Remove redundant assert.
+ <E_Array_Subtype>: Exit early from index computation in pathological
+ cases.
+ Rewrite conditional assignment.
+ (make_type_from_size): Likewise.
+ * gcc-interface/misc.c (largest_move_alignment): Delete.
+ (gnat_finish_incomplete_decl): Likewise.
+ (LANG_HOOKS_FINISH_INCOMPLETE_DECL): Likewise.
+ (asm_out_file): Likewise
+ (gnat_print_type) <INTEGER_TYPE>: Fall through to ENUMERAL_TYPE case.
+ (gnat_dwarf_name): Move around.
+ * gcc-interface/trans.c (Attribute_to_gnu): Fix minor nits.
+ (gigi): Remove call to gnat_compute_largest_alignment.
+ * utils.c (create_field_decl): Rewrite conditional assignment.
+ Fix minor nits.
+
+2009-04-22 Eric Botcazou <ebotcazou@adacore.com>
+
* gcc-interface/decl.c (gnat_to_gnu_entity): Compute is_type predicate
on entry. Defer common processing for types. Reorder and clean up.
Compute the equivalent GNAT node and the default size for types only.
* *
* Specification *
* *
- * Copyright (C) 1992-2008, Free Software Foundation, Inc. *
+ * Copyright (C) 1992-2009, Free Software Foundation, Inc. *
* *
* GNAT is free software; you can redistribute it and/or modify it under *
* terms of the GNU General Public License as published by the Free Soft- *
* *
****************************************************************************/
-/* A type that is an unconstrained array itself. This node is never passed
- to GCC. TREE_TYPE is the type of the fat pointer and TYPE_OBJECT_RECORD_TYPE
- is the type of a record containing the template and data. */
-
+/* A type that is an unconstrained array. This node is never passed to GCC.
+ TREE_TYPE is the type of the fat pointer and TYPE_OBJECT_RECORD_TYPE is
+ the type of a record containing the template and data. */
DEFTREECODE (UNCONSTRAINED_ARRAY_TYPE, "unconstrained_array_type", tcc_type, 0)
/* A reference to an unconstrained array. This node only exists as an
intermediate node during the translation of a GNAT tree to a GCC tree;
it is never passed to GCC. The only field used is operand 0, which
is the fat pointer object. */
-
DEFTREECODE (UNCONSTRAINED_ARRAY_REF, "unconstrained_array_ref",
- tcc_reference, 1)
+ tcc_reference, 1)
/* An expression that returns an RTL suitable for its type. Operand 0
is an expression to be evaluated for side effects only. */
/* Same as ADDR_EXPR, except that if the operand represents a bit field,
return the address of the byte containing the bit. This is used
- for the 'Address attribute and never shows up in the tree. */
+ for the Address attribute and never shows up in the tree. */
DEFTREECODE (ATTR_ADDR_EXPR, "attr_addr_expr", tcc_reference, 1)
/* Here are the tree codes for the statement types known to Ada. These
DEFTREECODE (STMT_STMT, "stmt_stmt", tcc_statement, 1)
/* A loop. LOOP_STMT_TOP_COND and LOOP_STMT_BOT_COND are the tests to exit a
- loop at the top and bottom, respectively. LOOP_STMT_UPDATE is the statement
+ loop at the top and bottom respectively. LOOP_STMT_UPDATE is the statement
to update the loop iterator at the continue point. LOOP_STMT_BODY are the
- statements in the body of the loop. LOOP_STMT_LABEL points to the LABEL_DECL
- of the end label of the loop. */
+ statements in the body of the loop. LOOP_STMT_LABEL points to the
+ LABEL_DECL of the end label of the loop. */
DEFTREECODE (LOOP_STMT, "loop_stmt", tcc_statement, 5)
/* Conditionally exit a loop. EXIT_STMT_COND is the condition, which, if
the loop is unconditionally exited. EXIT_STMT_LABEL is the end label
corresponding to the loop to exit. */
DEFTREECODE (EXIT_STMT, "exit_stmt", tcc_statement, 2)
-
-/* A exception region. REGION_STMT_BODY is the statement to be executed
- inside the region. REGION_STMT_HANDLE is a statement that represents
- the exception handlers (usually a BLOCK_STMT of HANDLE_STMTs).
- REGION_STMT_BLOCK is the BLOCK node for the declarative region, if any. */
-DEFTREECODE (REGION_STMT, "region_stmt", tcc_statement, 3)
-
-/* An exception handler. HANDLER_STMT_ARG is the value to pass to
- expand_start_catch, HANDLER_STMT_LIST is the list of statements for the
- handler itself, and HANDLER_STMT_BLOCK is the BLOCK node for this
- binding. */
-DEFTREECODE (HANDLER_STMT, "handler_stmt", tcc_statement, 3)
{
union tree_node GTY((tag ("0"))) t;
};
-struct lang_decl GTY(()) {tree t; };
-struct lang_type GTY(()) {tree t; };
+struct lang_decl GTY(()) { tree t; };
+struct lang_type GTY(()) { tree t; };
/* Define macros to get and set the tree in TYPE_ and DECL_LANG_SPECIFIC. */
#define GET_TYPE_LANG_SPECIFIC(NODE) \
#define SET_TYPE_LANG_SPECIFIC(NODE, X) \
(TYPE_LANG_SPECIFIC (NODE) \
= (TYPE_LANG_SPECIFIC (NODE) \
- ? TYPE_LANG_SPECIFIC (NODE) : GGC_NEW (struct lang_type))) \
+ ? TYPE_LANG_SPECIFIC (NODE) : GGC_NEW (struct lang_type))) \
->t = X;
#define GET_DECL_LANG_SPECIFIC(NODE) \
#define SET_DECL_LANG_SPECIFIC(NODE, VALUE) \
(DECL_LANG_SPECIFIC (NODE) \
= (DECL_LANG_SPECIFIC (NODE) \
- ? DECL_LANG_SPECIFIC (NODE) : GGC_NEW (struct lang_decl))) \
+ ? DECL_LANG_SPECIFIC (NODE) : GGC_NEW (struct lang_decl))) \
->t = VALUE;
/* Flags added to GCC type nodes. */
#define TYPE_IS_FAT_POINTER_P(NODE) \
TYPE_LANG_FLAG_0 (RECORD_OR_UNION_CHECK (NODE))
-#define TYPE_FAT_POINTER_P(NODE) \
+#define TYPE_FAT_POINTER_P(NODE) \
(TREE_CODE (NODE) == RECORD_TYPE && TYPE_IS_FAT_POINTER_P (NODE))
/* For integral types and array types, nonzero if this is a packed array type
/* For ARRAY_TYPE, nonzero if this type corresponds to a dimension of
an Ada array other than the first. */
-#define TYPE_MULTI_ARRAY_P(NODE) TYPE_LANG_FLAG_1 (ARRAY_TYPE_CHECK (NODE))
+#define TYPE_MULTI_ARRAY_P(NODE) TYPE_LANG_FLAG_1 (ARRAY_TYPE_CHECK (NODE))
/* For FUNCTION_TYPE, nonzero if this denotes a function returning an
unconstrained array or record. */
/* For INTEGER_TYPE, nonzero if this really represents a VAX
floating-point type. */
-#define TYPE_VAX_FLOATING_POINT_P(NODE) \
+#define TYPE_VAX_FLOATING_POINT_P(NODE) \
TYPE_LANG_FLAG_3 (INTEGER_TYPE_CHECK (NODE))
/* True if NODE is a thin pointer. */
/* True if TYPE can alias any other types. */
#define TYPE_UNIVERSAL_ALIASING_P(NODE) TYPE_LANG_FLAG_6 (NODE)
-/* This field is only defined for FUNCTION_TYPE nodes. If the Ada
- subprogram contains no parameters passed by copy in/copy out then this
- field is 0. Otherwise it points to a list of nodes used to specify the
- return values of the out (or in out) parameters that qualify to be passed
- by copy in copy out. It is a CONSTRUCTOR. For a full description of the
- cico parameter passing mechanism refer to the routine gnat_to_gnu_entity. */
-#define TYPE_CI_CO_LIST(NODE) TYPE_LANG_SLOT_1 (FUNCTION_TYPE_CHECK (NODE))
+/* This field is only defined for FUNCTION_TYPE nodes. If the Ada subprogram
+ contains no parameters passed by copy in/copy out then this field is zero.
+ Otherwise it points to a list of nodes used to specify the return values
+ of the out (or in out) parameters that qualify to be passed by copy in/
+ copy out. For a full description of the copy in/copy out parameter passing
+ mechanism refer to the routine gnat_to_gnu_entity. */
+#define TYPE_CI_CO_LIST(NODE) TYPE_LANG_SLOT_1 (FUNCTION_TYPE_CHECK (NODE))
/* For integral types, this is the RM Size of the type. */
-#define TYPE_RM_SIZE(NODE) \
+#define TYPE_RM_SIZE(NODE) \
TYPE_LANG_SLOT_1 (TREE_CHECK3 (NODE, ENUMERAL_TYPE, BOOLEAN_TYPE, INTEGER_TYPE))
/* For an INTEGER_TYPE with TYPE_MODULAR_P, this is the value of the
modulus. */
#define TYPE_MODULUS(NODE) GET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE))
-#define SET_TYPE_MODULUS(NODE, X) \
+#define SET_TYPE_MODULUS(NODE, X) \
SET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE), X)
/* For an INTEGER_TYPE that is the TYPE_DOMAIN of some ARRAY_TYPE, points to
Digits_Value. */
#define TYPE_DIGITS_VALUE(NODE) \
GET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE))
-#define SET_TYPE_DIGITS_VALUE(NODE, X) \
+#define SET_TYPE_DIGITS_VALUE(NODE, X) \
SET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE), X)
/* For a RECORD_TYPE that is a fat pointer, point to the type for the
unconstrained object. Likewise for a RECORD_TYPE that is pointed
to by a thin pointer. */
-#define TYPE_UNCONSTRAINED_ARRAY(NODE) \
+#define TYPE_UNCONSTRAINED_ARRAY(NODE) \
GET_TYPE_LANG_SPECIFIC (RECORD_TYPE_CHECK (NODE))
-#define SET_TYPE_UNCONSTRAINED_ARRAY(NODE, X) \
+#define SET_TYPE_UNCONSTRAINED_ARRAY(NODE, X) \
SET_TYPE_LANG_SPECIFIC (RECORD_TYPE_CHECK (NODE), X)
/* For other RECORD_TYPEs and all UNION_TYPEs and QUAL_UNION_TYPEs, the Ada
size of the object. This differs from the GCC size in that it does not
include any rounding up to the alignment of the type. */
-#define TYPE_ADA_SIZE(NODE) \
+#define TYPE_ADA_SIZE(NODE) \
GET_TYPE_LANG_SPECIFIC (RECORD_OR_UNION_CHECK (NODE))
#define SET_TYPE_ADA_SIZE(NODE, X) \
SET_TYPE_LANG_SPECIFIC (RECORD_OR_UNION_CHECK (NODE), X)
/* For an INTEGER_TYPE with TYPE_HAS_ACTUAL_BOUNDS_P or an ARRAY_TYPE, this is
the index type that should be used when the actual bounds are required for
a template. This is used in the case of packed arrays. */
-#define TYPE_ACTUAL_BOUNDS(NODE) \
+#define TYPE_ACTUAL_BOUNDS(NODE) \
GET_TYPE_LANG_SPECIFIC (TREE_CHECK2 (NODE, INTEGER_TYPE, ARRAY_TYPE))
#define SET_TYPE_ACTUAL_BOUNDS(NODE, X) \
SET_TYPE_LANG_SPECIFIC (TREE_CHECK2 (NODE, INTEGER_TYPE, ARRAY_TYPE), X)
discriminant number. */
#define DECL_DISCRIMINANT_NUMBER(NODE) DECL_INITIAL (FIELD_DECL_CHECK (NODE))
-/* Define fields and macros for statements.
+/* Define fields and macros for statements. */
+#define IS_ADA_STMT(NODE) \
+ (STATEMENT_CLASS_P (NODE) && TREE_CODE (NODE) >= STMT_STMT)
- Start by defining which tree codes are used for statements. */
-#define IS_STMT(NODE) (STATEMENT_CLASS_P (NODE))
-#define IS_ADA_STMT(NODE) (IS_STMT (NODE) \
- && TREE_CODE (NODE) >= STMT_STMT)
-
-#define STMT_STMT_STMT(NODE) TREE_OPERAND_CHECK_CODE (NODE, STMT_STMT, 0)
+#define STMT_STMT_STMT(NODE) TREE_OPERAND_CHECK_CODE (NODE, STMT_STMT, 0)
#define LOOP_STMT_TOP_COND(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 0)
#define LOOP_STMT_BOT_COND(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 1)
-#define LOOP_STMT_UPDATE(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 2)
-#define LOOP_STMT_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 3)
-#define LOOP_STMT_LABEL(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 4)
-#define EXIT_STMT_COND(NODE) TREE_OPERAND_CHECK_CODE (NODE, EXIT_STMT, 0)
-#define EXIT_STMT_LABEL(NODE) TREE_OPERAND_CHECK_CODE (NODE, EXIT_STMT, 1)
-#define REGION_STMT_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, REGION_STMT, 0)
-#define REGION_STMT_HANDLE(NODE) TREE_OPERAND_CHECK_CODE (NODE, REGION_STMT, 1)
-#define REGION_STMT_BLOCK(NODE) TREE_OPERAND_CHECK_CODE (NODE, REGION_STMT, 2)
-#define HANDLER_STMT_ARG(NODE) TREE_OPERAND_CHECK_CODE (NODE, HANDLER_STMT, 0)
-#define HANDLER_STMT_LIST(NODE) TREE_OPERAND_CHECK_CODE (NODE, HANDLER_STMT, 1)
-#define HANDLER_STMT_BLOCK(NODE) TREE_OPERAND_CHECK_CODE(NODE, HANDLER_STMT, 2)
+#define LOOP_STMT_UPDATE(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 2)
+#define LOOP_STMT_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 3)
+#define LOOP_STMT_LABEL(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 4)
+#define EXIT_STMT_COND(NODE) TREE_OPERAND_CHECK_CODE (NODE, EXIT_STMT, 0)
+#define EXIT_STMT_LABEL(NODE) TREE_OPERAND_CHECK_CODE (NODE, EXIT_STMT, 1)
else
max_esize = LONG_LONG_TYPE_SIZE;
- esize = MIN (esize, max_esize);
+ if (esize > max_esize)
+ esize = max_esize;
}
else
esize = LONG_LONG_TYPE_SIZE;
TYPE_BIASED_REPRESENTATION_P (gnu_type)
= Has_Biased_Representation (gnat_entity);
- /* This should be an unsigned type if the lower bound is constant
- and non-negative or if the base type is unsigned; a signed type
- otherwise. */
- TYPE_UNSIGNED (gnu_type)
- = (TYPE_UNSIGNED (TREE_TYPE (gnu_type))
- || (TREE_CODE (TYPE_MIN_VALUE (gnu_type)) == INTEGER_CST
- && TREE_INT_CST_HIGH (TYPE_MIN_VALUE (gnu_type)) >= 0)
- || TYPE_BIASED_REPRESENTATION_P (gnu_type)
- || Is_Unsigned_Type (gnat_entity));
+ /* This should be an unsigned type if the base type is unsigned or
+ if the lower bound is constant and non-negative (as computed by
+ layout_type) or if the type is biased. */
+ TYPE_UNSIGNED (gnu_type) = (TYPE_UNSIGNED (TREE_TYPE (gnu_type))
+ || TYPE_BIASED_REPRESENTATION_P (gnu_type)
+ || Is_Unsigned_Type (gnat_entity));
layout_type (gnu_type);
TYPE_NONALIASED_COMPONENT (tem) = 1;
}
- /* If an alignment is specified, use it if valid. But ignore it for
- types that represent the unpacked base type for packed arrays. If
- the alignment was requested with an explicit user alignment clause,
- state so. */
+ /* If an alignment is specified, use it if valid. But ignore it
+ for the original type of packed array types. If the alignment
+ was requested with an explicit alignment clause, state so. */
if (No (Packed_Array_Type (gnat_entity))
&& Known_Alignment (gnat_entity))
{
- gcc_assert (Present (Alignment (gnat_entity)));
TYPE_ALIGN (tem)
= validate_alignment (Alignment (gnat_entity), gnat_entity,
TYPE_ALIGN (tem));
&& TREE_CODE (gnu_min) == INTEGER_CST
&& TREE_CODE (gnu_max) == INTEGER_CST
&& TREE_OVERFLOW (gnu_min) && TREE_OVERFLOW (gnu_max)
- && (!TREE_OVERFLOW
+ && !TREE_OVERFLOW
(fold_build2 (MINUS_EXPR, gnu_index_subtype,
TYPE_MAX_VALUE (gnu_index_subtype),
- TYPE_MIN_VALUE (gnu_index_subtype)))))
+ TYPE_MIN_VALUE (gnu_index_subtype))))
{
TREE_OVERFLOW (gnu_min) = 0;
TREE_OVERFLOW (gnu_max) = 0;
+ if (tree_int_cst_lt (gnu_max, gnu_min))
+ {
+ gnu_min = size_one_node;
+ gnu_max = size_zero_node;
+ }
+ gnu_high = gnu_max;
}
/* Similarly, if the range is null, use bounds of 1..0 for
the sizetype bounds. */
else if ((TYPE_PRECISION (gnu_index_subtype)
> TYPE_PRECISION (sizetype)
- || TYPE_UNSIGNED (gnu_index_subtype)
- != TYPE_UNSIGNED (sizetype))
+ || TYPE_UNSIGNED (gnu_index_subtype)
+ != TYPE_UNSIGNED (sizetype))
&& TREE_CODE (gnu_min) == INTEGER_CST
&& TREE_CODE (gnu_max) == INTEGER_CST
&& (TREE_OVERFLOW (gnu_min) || TREE_OVERFLOW (gnu_max))
&& tree_int_cst_lt (TYPE_MAX_VALUE (gnu_index_subtype),
TYPE_MIN_VALUE (gnu_index_subtype)))
- gnu_min = size_one_node, gnu_max = size_zero_node;
-
- /* Now compute the size of this bound. We need to provide
- GCC with an upper bound to use but have to deal with the
- "superflat" case. There are three ways to do this. If we
- can prove that the array can never be superflat, we can
- just use the high bound of the index subtype. If we can
- prove that the low bound minus one can't overflow, we
- can do this as MAX (hb, lb - 1). Otherwise, we have to use
- the expression hb >= lb ? hb : lb - 1. */
- gnu_high = size_binop (MINUS_EXPR, gnu_min, size_one_node);
+ {
+ gnu_min = size_one_node;
+ gnu_max = size_zero_node;
+ gnu_high = gnu_max;
+ }
/* See if the base array type is already flat. If it is, we
- are probably compiling an ACVC test, but it will cause the
+ are probably compiling an ACATS test, but it will cause the
code below to malfunction if we don't handle it specially. */
- if (TREE_CODE (gnu_base_min) == INTEGER_CST
- && TREE_CODE (gnu_base_max) == INTEGER_CST
- && !TREE_OVERFLOW (gnu_base_min)
- && !TREE_OVERFLOW (gnu_base_max)
- && tree_int_cst_lt (gnu_base_max, gnu_base_min))
- gnu_high = size_zero_node, gnu_min = size_one_node;
-
- /* If gnu_high is now an integer which overflowed, the array
- cannot be superflat. */
- else if (TREE_CODE (gnu_high) == INTEGER_CST
- && TREE_OVERFLOW (gnu_high))
- gnu_high = gnu_max;
- else if (TYPE_UNSIGNED (gnu_base_subtype)
- || TREE_CODE (gnu_high) == INTEGER_CST)
- gnu_high = size_binop (MAX_EXPR, gnu_max, gnu_high);
+ else if (TREE_CODE (gnu_base_min) == INTEGER_CST
+ && TREE_CODE (gnu_base_max) == INTEGER_CST
+ && !TREE_OVERFLOW (gnu_base_min)
+ && !TREE_OVERFLOW (gnu_base_max)
+ && tree_int_cst_lt (gnu_base_max, gnu_base_min))
+ {
+ gnu_min = size_one_node;
+ gnu_max = size_zero_node;
+ gnu_high = gnu_max;
+ }
+
else
- gnu_high
- = build_cond_expr
- (sizetype, build_binary_op (GE_EXPR, integer_type_node,
- gnu_max, gnu_min),
- gnu_max, gnu_high);
+ {
+ /* Now compute the size of this bound. We need to provide
+ GCC with an upper bound to use but have to deal with the
+ "superflat" case. There are three ways to do this. If
+ we can prove that the array can never be superflat, we
+ can just use the high bound of the index subtype. If we
+ can prove that the low bound minus one can't overflow,
+ we can do this as MAX (hb, lb - 1). Otherwise, we have
+ to use the expression hb >= lb ? hb : lb - 1. */
+ gnu_high = size_binop (MINUS_EXPR, gnu_min, size_one_node);
+
+ /* If gnu_high is now an integer which overflowed, the array
+ cannot be superflat. */
+ if (TREE_CODE (gnu_high) == INTEGER_CST
+ && TREE_OVERFLOW (gnu_high))
+ gnu_high = gnu_max;
+
+ /* gnu_high cannot overflow if the subtype is unsigned since
+ sizetype is signed, or if it is now a constant that hasn't
+ overflowed. */
+ else if (TYPE_UNSIGNED (gnu_base_subtype)
+ || TREE_CODE (gnu_high) == INTEGER_CST)
+ gnu_high = size_binop (MAX_EXPR, gnu_max, gnu_high);
+
+ else
+ gnu_high
+ = build_cond_expr (sizetype,
+ build_binary_op (GE_EXPR,
+ integer_type_node,
+ gnu_max, gnu_min),
+ gnu_max, gnu_high);
+ }
gnu_index_type[index]
= create_index_type (gnu_min, gnu_high, gnu_index_subtype,
break;
biased_p |= for_biased;
- size = MIN (size, LONG_LONG_TYPE_SIZE);
+ if (size > LONG_LONG_TYPE_SIZE)
+ size = LONG_LONG_TYPE_SIZE;
if (TYPE_UNSIGNED (type) || biased_p)
new_type = make_unsigned_type (size);
/* Declare all functions and types used by gigi. */
-/* The largest alignment, in bits, that is needed for using the widest
- move instruction. */
-extern unsigned int largest_move_alignment;
-
-/* Compute the alignment of the largest mode that can be used for copying
- objects. */
-extern void gnat_compute_largest_alignment (void);
-
-/* GNU_TYPE is a type. Determine if it should be passed by reference by
- default. */
-extern bool default_pass_by_ref (tree gnu_type);
-
-/* GNU_TYPE is the type of a subprogram parameter. Determine from the type
- if it should be passed by reference. */
-extern bool must_pass_by_ref (tree gnu_type);
-
-/* Initialize DUMMY_NODE_TABLE. */
-extern void init_dummy_type (void);
-
-/* Given GNAT_ENTITY, an entity in the incoming GNAT tree, return a
- GCC type corresponding to that entity. GNAT_ENTITY is assumed to
- refer to an Ada type. */
-extern tree gnat_to_gnu_type (Entity_Id gnat_entity);
-
/* Given GNAT_ENTITY, a GNAT defining identifier node, which denotes some Ada
entity, this routine returns the equivalent GCC tree for that entity
(an ..._DECL node) and associates the ..._DECL node with the input GNAT
FIELD_DECL. */
extern tree gnat_to_gnu_field_decl (Entity_Id gnat_entity);
+/* Similar, but GNAT_ENTITY is assumed to refer to a GNAT type. Return
+ the GCC type corresponding to that entity. */
+extern tree gnat_to_gnu_type (Entity_Id gnat_entity);
+
/* Wrap up compilation of T, a TYPE_DECL, possibly deferring it. */
extern void rest_of_type_decl_compilation (tree t);
/* Mark nodes rooted at *TP with TREE_VISITED and types as having their
sized gimplified. We use this to indicate all variable sizes and
positions in global types may not be shared by any subprogram. */
-extern void mark_visited (tree *);
+extern void mark_visited (tree *tp);
/* Finalize any From_With_Type incomplete types. We do this after processing
our compilation unit and after processing its spec, if this is a body. */
for its representation, return GNAT_ENTITY. If a type is supposed to
exist, but does not, abort unless annotating types, in which case
return Empty. If GNAT_ENTITY is Empty, return Empty. */
-extern Entity_Id Gigi_Equivalent_Type (Entity_Id);
+extern Entity_Id Gigi_Equivalent_Type (Entity_Id gnat_entity);
/* Given GNAT_ENTITY, elaborate all expressions that are required to
be elaborated at the point of its definition, but do nothing else. */
any entities on its entity chain similarly. */
extern void mark_out_of_scope (Entity_Id gnat_entity);
-/* Make a dummy type corresponding to GNAT_TYPE. */
-extern tree make_dummy_type (Entity_Id gnat_type);
-
/* Get the unpadded version of a GNAT type. */
extern tree get_unpadded_type (Entity_Id gnat_entity);
/* GNU_STMT is a statement. We generate code for that statement. */
extern void gnat_expand_stmt (tree gnu_stmt);
-/* ??? missing documentation */
+/* Generate GIMPLE in place for the expression at *EXPR_P. */
extern int gnat_gimplify_expr (tree *expr_p, gimple_seq *pre_p,
gimple_seq *post_p ATTRIBUTE_UNUSED);
/* 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. */
-extern void post_error (const char *, Node_Id);
+extern void post_error (const char *msg, Node_Id node);
/* Similar, but NODE is the node at which to post the error and ENT
is the node to use for the "&" substitution. */
/* Return a label to branch to for the exception type in KIND or NULL_TREE
if none. */
-extern tree get_exception_label (char);
+extern tree get_exception_label (char kind);
/* Current node being treated, in case gigi_abort or Check_Elaboration_Code
called. */
/* Function declaration nodes for run-time functions for allocating memory.
Ada allocators cause calls to these functions to be generated. Malloc32
- is used only on 64bit systems needing to allocate 32bit memory. */
+ is used only on 64bit systems needing to allocate 32bit memory. */
ADT_malloc_decl,
ADT_malloc32_decl,
/* Returns nonzero if we are currently in the global binding level. */
extern int global_bindings_p (void);
-/* Enter and exit a new binding level. */
+/* Enter and exit a new binding level. */
extern void gnat_pushlevel (void);
extern void gnat_poplevel (void);
/* Routines created solely for the tree translator's sake. Their prototypes
can be changed as desired. */
+/* Initialize the association of GNAT nodes to GCC trees. */
+extern void init_gnat_to_gnu (void);
+
/* GNAT_ENTITY is a GNAT tree node for a defining identifier.
GNU_DECL is the GCC tree which is to be associated with
GNAT_ENTITY. Such gnu tree node is always an ..._DECL node.
/* Return nonzero if a GCC tree has been associated with GNAT_ENTITY. */
extern bool present_gnu_tree (Entity_Id gnat_entity);
-/* Initialize tables for above routines. */
-extern void init_gnat_to_gnu (void);
+/* Initialize the association of GNAT nodes to GCC trees as dummies. */
+extern void init_dummy_type (void);
+
+/* Make a dummy type corresponding to GNAT_TYPE. */
+extern tree make_dummy_type (Entity_Id gnat_type);
/* Record TYPE as a builtin type for Ada. NAME is the name of the type. */
extern void record_builtin_type (const char *name, tree type);
it indicates whether to always allocate storage to the variable.
GNAT_NODE is used for the position of the decl. */
-tree
+extern tree
create_var_decl_1 (tree var_name, tree asm_name, tree type, tree var_init,
bool const_flag, bool public_flag, bool extern_flag,
bool static_flag, bool const_decl_allowed_p,
/* Given a DECL and ATTR_LIST, apply the listed attributes. */
extern void process_attributes (tree decl, struct attrib *attr_list);
-/* Record a global renaming pointer. */
-void record_global_renaming_pointer (tree);
+/* Record DECL as a global renaming pointer. */
+extern void record_global_renaming_pointer (tree decl);
-/* Invalidate the global renaming pointers. */
-void invalidate_global_renaming_pointers (void);
+/* Invalidate the global renaming pointers. */
+extern void invalidate_global_renaming_pointers (void);
/* Returns a FIELD_DECL node. FIELD_NAME the field name, FIELD_TYPE is its
type, and RECORD_TYPE is the type of the parent. PACKED is nonzero if
/* Returns a PARM_DECL node. PARAM_NAME is the name of the parameter,
PARAM_TYPE is its type. READONLY is true if the parameter is
readonly (either an In parameter or an address of a pass-by-ref
- parameter). */
+ parameter). */
extern tree create_param_decl (tree param_name, tree param_type,
bool readonly);
extern tree build_vms_descriptor (tree type, Mechanism_Type mech,
Entity_Id gnat_entity);
-/* Build a 32bit VMS descriptor from a Mechanism_Type. See above. */
+/* Build a 32bit VMS descriptor from a Mechanism_Type. See above. */
extern tree build_vms_descriptor32 (tree type, Mechanism_Type mech,
Entity_Id gnat_entity);
tree name);
/* Same as build_unc_object_type, but taking a thin or fat pointer type
- instead of the template type. */
+ instead of the template type. */
extern tree build_unc_object_type_from_ptr (tree thin_fat_ptr_type,
tree object_type, tree name);
If NOTRUNC_P is true, truncation operations should be suppressed. */
extern tree unchecked_convert (tree type, tree expr, bool notrunc_p);
-/* Return the appropriate GCC tree code for the specified GNAT type,
+/* Return the appropriate GCC tree code for the specified GNAT_TYPE,
the latter being a record type as predicated by Is_Record_Type. */
-extern enum tree_code tree_code_for_record_type (Entity_Id);
+extern enum tree_code tree_code_for_record_type (Entity_Id gnat_type);
/* Return true if GNU_TYPE is suitable as the type of a non-aliased
component of an aggregate type. */
-extern bool type_for_nonaliased_component_p (tree);
+extern bool type_for_nonaliased_component_p (tree gnu_type);
/* Prepare expr to be an argument of a TRUTH_NOT_EXPR or other logical
operation.
extern unsigned int known_alignment (tree exp);
/* Return true if VALUE is a multiple of FACTOR. FACTOR must be a power
- of 2. */
+ of 2. */
extern bool value_factor_p (tree value, HOST_WIDE_INT factor);
/* Make a binary operation of kind OP_CODE. RESULT_TYPE is the type
extern tree build_binary_op (enum tree_code op_code, tree result_type,
tree left_operand, tree right_operand);
-/* Similar, but make unary operation. */
+/* Similar, but make unary operation. */
extern tree build_unary_op (enum tree_code op_code, tree result_type,
tree operand);
Return the first node found, if any, or NULL_TREE otherwise. */
extern tree builtin_decl_for (tree name);
+/* GNU_TYPE is a type. Determine if it should be passed by reference by
+ default. */
+extern bool default_pass_by_ref (tree gnu_type);
+
+/* GNU_TYPE is the type of a subprogram parameter. Determine from the type
+ if it should be passed by reference. */
+extern bool must_pass_by_ref (tree gnu_type);
+
/* This function is called by the front end to enumerate all the supported
modes for the machine. We pass a function which is called back with
the following integer parameters:
extern void enumerate_modes (void (*f) (int, int, int, int, int, int,
unsigned int));
-/* These are temporary function to deal with recent GCC changes related to
- FP type sizes and precisions. */
+/* Return the size of the FP mode with precision PREC. */
extern int fp_prec_to_size (int prec);
+
+/* Return the precision of the FP mode with size SIZE. */
extern int fp_size_to_prec (int size);
/* These functions return the basic data type sizes and related parameters
/* VMS macro set by default, when clear forces 32bit mallocs and 32bit
Descriptors. Always used in combination with TARGET_ABI_OPEN_VMS
- so no effect on non-VMS systems. */
+ so no effect on non-VMS systems. */
#ifndef TARGET_MALLOC64
#define TARGET_MALLOC64 0
#endif
#include "opts.h"
#include "options.h"
-extern FILE *asm_out_file;
-
-/* The largest alignment, in bits, that is needed for using the widest
- move instruction. */
-unsigned int largest_move_alignment;
-
static bool gnat_init (void);
-static void gnat_finish_incomplete_decl (tree);
static unsigned int gnat_init_options (unsigned int, const char **);
static int gnat_handle_option (size_t, const char *, int);
static bool gnat_post_options (const char **);
#define LANG_HOOKS_PUSHDECL gnat_return_tree
#undef LANG_HOOKS_WRITE_GLOBALS
#define LANG_HOOKS_WRITE_GLOBALS gnat_write_global_declarations
-#undef LANG_HOOKS_FINISH_INCOMPLETE_DECL
-#define LANG_HOOKS_FINISH_INCOMPLETE_DECL gnat_finish_incomplete_decl
#undef LANG_HOOKS_GET_ALIAS_SET
#define LANG_HOOKS_GET_ALIAS_SET gnat_get_alias_set
#undef LANG_HOOKS_MARK_ADDRESSABLE
are incompatible with regular GDB versions, so we must make sure to only
produce them on explicit request. This is eventually reflected into the
use_gnu_debug_info_extensions common flag for later processing. */
-
static int gnat_dwarf_extensions = 0;
-/* Command-line argc and argv.
- These variables are global, since they are imported and used in
- back_end.adb */
-
+/* Command-line argc and argv. These variables are global
+ since they are imported in back_end.adb. */
unsigned int save_argc;
const char **save_argv;
-/* gnat standard argc argv */
-
+/* GNAT argc and argv. */
extern int gnat_argc;
extern char **gnat_argv;
/* Decode all the language specific options that cannot be decoded by GCC.
The option decoding phase of GCC calls this routine on the flags that
- it cannot decode. This routine returns the number of consecutive arguments
- from ARGV that it successfully decoded; 0 indicates failure. */
+ it cannot decode. Return the number of consecutive arguments from ARGV
+ that have been successfully decoded or 0 on failure. */
static int
gnat_handle_option (size_t scode, const char *arg, int value)
return true;
}
-/* This function is called indirectly from toplev.c to handle incomplete
- declarations, i.e. VAR_DECL nodes whose DECL_SIZE is zero. To be precise,
- compile_file in toplev.c makes an indirect call through the function pointer
- incomplete_decl_finalize_hook which is initialized to this routine in
- init_decl_processing. */
-
-static void
-gnat_finish_incomplete_decl (tree dont_care ATTRIBUTE_UNUSED)
-{
- gcc_unreachable ();
-}
-\f
-/* Compute the alignment of the largest mode that can be used for copying
- objects. */
-
-void
-gnat_compute_largest_alignment (void)
-{
- enum machine_mode mode;
-
- for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
- mode = GET_MODE_WIDER_MODE (mode))
- if (optab_handler (mov_optab, mode)->insn_code != CODE_FOR_nothing)
- largest_move_alignment = MIN (BIGGEST_ALIGNMENT,
- MAX (largest_move_alignment,
- GET_MODE_ALIGNMENT (mode)));
-}
-
/* If we are using the GCC mechanism to process exception handling, we
have to register the personality routine for Ada and to initialize
various language dependent hooks. */
#endif
}
-/* Language hooks, first one to print language-specific items in a DECL. */
+/* Print language-specific items in declaration NODE. */
static void
gnat_print_decl (FILE *file, tree node, int indent)
}
}
+/* Print language-specific items in type NODE. */
+
static void
gnat_print_type (FILE *file, tree node, int indent)
{
print_node (file, "ci_co_list", TYPE_CI_CO_LIST (node), indent + 4);
break;
- case ENUMERAL_TYPE:
- case BOOLEAN_TYPE:
- print_node (file, "RM size", TYPE_RM_SIZE (node), indent + 4);
- break;
-
case INTEGER_TYPE:
if (TYPE_MODULAR_P (node))
print_node (file, "modulus", TYPE_MODULUS (node), indent + 4);
else
print_node (file, "index type", TYPE_INDEX_TYPE (node), indent + 4);
+ /* ... fall through ... */
+
+ case ENUMERAL_TYPE:
+ case BOOLEAN_TYPE:
print_node (file, "RM size", TYPE_RM_SIZE (node), indent + 4);
break;
}
}
-static const char *
-gnat_dwarf_name (tree t, int verbosity ATTRIBUTE_UNUSED)
-{
- gcc_assert (DECL_P (t));
-
- return (const char *) IDENTIFIER_POINTER (DECL_NAME (t));
-}
+/* Return the name to be printed for DECL. */
static const char *
gnat_printable_name (tree decl, int verbosity)
Set_Identifier_Casing (ada_name, (char *) DECL_SOURCE_FILE (decl));
return ggc_strdup (Name_Buffer);
}
- else
- return ada_name;
+
+ return ada_name;
+}
+
+/* Return the name to be used in DWARF debug info for DECL. */
+
+static const char *
+gnat_dwarf_name (tree decl, int verbosity ATTRIBUTE_UNUSED)
+{
+ gcc_assert (DECL_P (decl));
+ return (const char *) IDENTIFIER_POINTER (DECL_NAME (decl));
}
/* Do nothing (return the tree node passed). */
}
}
+/* Return the size of the FP mode with precision PREC. */
+
int
fp_prec_to_size (int prec)
{
gcc_unreachable ();
}
+/* Return the precision of the FP mode with size SIZE. */
+
int
fp_size_to_prec (int size)
{
/* Initialize ourselves. */
init_code_table ();
init_gnat_to_gnu ();
- gnat_compute_largest_alignment ();
init_dummy_type ();
/* If we are just annotating types, give VOID_TYPE zero sizes to avoid
return gnu_result;
}
\f
-/* Subroutine of gnat_to_gnu to translate gnat_node, an N_Attribute,
+/* Subroutine of gnat_to_gnu to translate GNAT_NODE, an N_Attribute node,
to a GCC tree, which is returned. GNU_RESULT_TYPE_P is a pointer to
where we should place the result type. ATTRIBUTE is the attribute ID. */
/* If the input is a NULL_EXPR, make a new one. */
if (TREE_CODE (gnu_prefix) == NULL_EXPR)
{
- *gnu_result_type_p = get_unpadded_type (Etype (gnat_node));
- return build1 (NULL_EXPR, *gnu_result_type_p,
- TREE_OPERAND (gnu_prefix, 0));
+ gnu_result_type = get_unpadded_type (Etype (gnat_node));
+ *gnu_result_type_p = gnu_result_type;
+ return build1 (NULL_EXPR, gnu_result_type, TREE_OPERAND (gnu_prefix, 0));
}
switch (attribute)
{
case Attr_Pos:
case Attr_Val:
- /* These are just conversions until since representation clauses for
- enumerations are handled in the front end. */
+ /* These are just conversions since representation clauses for
+ enumeration types are handled in the front-end. */
{
bool checkp = Do_Range_Check (First (Expressions (gnat_node)));
-
gnu_result = gnat_to_gnu (First (Expressions (gnat_node)));
gnu_result_type = get_unpadded_type (Etype (gnat_node));
gnu_result = convert_with_check (Etype (gnat_node), gnu_result,
case Attr_Pred:
case Attr_Succ:
- /* These just add or subject the constant 1. Representation clauses for
- enumerations are handled in the front-end. */
+ /* These just add or subtract the constant 1 since representation
+ clauses for enumeration types are handled in the front-end. */
gnu_expr = gnat_to_gnu (First (Expressions (gnat_node)));
gnu_result_type = get_unpadded_type (Etype (gnat_node));
}
gnu_result
- = build_binary_op (attribute == Attr_Pred
- ? MINUS_EXPR : PLUS_EXPR,
+ = build_binary_op (attribute == Attr_Pred ? MINUS_EXPR : PLUS_EXPR,
gnu_result_type, gnu_expr,
convert (gnu_result_type, integer_one_node));
break;
case Attr_Address:
case Attr_Unrestricted_Access:
- /* Conversions don't change something's address but can cause us to miss
- the COMPONENT_REF case below, so strip them off. */
+ /* Conversions don't change addresses but can cause us to miss the
+ COMPONENT_REF case below, so strip them off. */
gnu_prefix = remove_conversions (gnu_prefix,
!Must_Be_Byte_Aligned (gnat_node));
gnu_result_type = get_unpadded_type (Etype (gnat_node));
- /* If this is an unconstrained array, we know the object must have been
- allocated with the template in front of the object. So compute the
- template address.*/
+ /* If this is an unconstrained array, we know the object has been
+ allocated with the template in front of the object. So compute
+ the template address. */
if (TYPE_FAT_POINTER_P (TREE_TYPE (gnu_ptr)))
gnu_ptr
= convert (build_pointer_type
case Attr_Max_Size_In_Storage_Elements:
gnu_expr = gnu_prefix;
- /* Remove NOPS from gnu_expr and conversions from gnu_prefix.
+ /* Remove NOPs from GNU_EXPR and conversions from GNU_PREFIX.
We only use GNU_EXPR to see if a COMPONENT_REF was involved. */
while (TREE_CODE (gnu_expr) == NOP_EXPR)
gnu_expr = TREE_OPERAND (gnu_expr, 0);
gcc_assert (gnu_result);
- /* Deal with a self-referential size by returning the maximum size for a
- type and by qualifying the size with the object for 'Size of an
+ /* Deal with a self-referential size by returning the maximum size for
+ a type and by qualifying the size with the object for 'Size of an
object. */
if (CONTAINS_PLACEHOLDER_P (gnu_result))
{
much rarer cases, for extremely large arrays we expect
never to encounter in practice. In addition, the former
computation required the use of potentially constraining
- signed arithmetic while the latter doesn't. Note that the
+ signed arithmetic while the latter doesn't. Note that the
comparison must be done in the original index base type,
otherwise the conversion of either bound to gnu_compute_type
may overflow. */
break;
}
- /* If this has a PLACEHOLDER_EXPR, qualify it by the object
- we are handling. */
+ /* If this has a PLACEHOLDER_EXPR, qualify it by the object we are
+ handling. */
gnu_result = SUBSTITUTE_PLACEHOLDER_IN_EXPR (gnu_result, gnu_prefix);
break;
}
break;
case Attr_Null_Parameter:
- /* This is just a zero cast to the pointer type for
- our prefix and dereferenced. */
+ /* This is just a zero cast to the pointer type for our prefix and
+ dereferenced. */
gnu_result_type = get_unpadded_type (Etype (gnat_node));
gnu_result
= build_unary_op (INDIRECT_REF, NULL_TREE,
default:
/* Say we have an unimplemented attribute. Then set the value to be
- returned to be a zero and hope that's something we can convert to the
- type of this attribute. */
+ returned to be a zero and hope that's something we can convert to
+ the type of this attribute. */
post_error ("unimplemented attribute", gnat_node);
gnu_result_type = get_unpadded_type (Etype (gnat_node));
gnu_result = integer_zero_node;
DECL_BIT_FIELD (field_decl) = 1;
DECL_SIZE (field_decl) = size;
if (!packed && !pos)
- DECL_ALIGN (field_decl)
- = (TYPE_ALIGN (record_type) != 0
- ? MIN (TYPE_ALIGN (record_type), TYPE_ALIGN (field_type))
- : TYPE_ALIGN (field_type));
+ {
+ if (TYPE_ALIGN (record_type) != 0
+ && TYPE_ALIGN (record_type) < TYPE_ALIGN (field_type))
+ DECL_ALIGN (field_decl) = TYPE_ALIGN (record_type);
+ else
+ DECL_ALIGN (field_decl) = TYPE_ALIGN (field_type);
+ }
}
DECL_PACKED (field_decl) = pos ? DECL_BIT_FIELD (field_decl) : packed;
}
}
\f
-/* Record a global renaming pointer. */
+/* Record DECL as a global renaming pointer. */
void
record_global_renaming_pointer (tree decl)
return expr;
}
\f
-/* Return the appropriate GCC tree code for the specified GNAT type,
+/* Return the appropriate GCC tree code for the specified GNAT_TYPE,
the latter being a record type as predicated by Is_Record_Type. */
enum tree_code
projects / platform / upstream / linaro-gcc.git / commitdiff