+2004-06-20 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * decl.c (elaborate_expression, elaborate_expression_1): Arguments
+ now bool instead of int.
+ (gnat_to_gnu_entity, elaborate_expression_1): New arg to COMPONENT_REF.
+ * trans.c (gnu_switch_label_stack): New function.
+ (gnat_to_gnu, N_Object_Renaming_Declaration): Result is what the
+ elaboration of renamed entity returns.
+ (gnat_to_gnu, case N_Case_Statement): Add branches to end label.
+ (add_decl_stmt): Don't add TYPE_DECL for UNCONSTRAINED_ARRAY_TYPE.
+ (gnat_gimplify_stmt): Use alloc_stmt_list, not build_empty_stmt.
+ (gnat_gimplify_stmt, case DECL_STMT): gimplify DECL_SIZE and
+ DECL_SIZE_UNIT and simplify variable-sized case.
+ (gnat_gimplify_type_sizes, gnat_gimplify_one_sizepos): Deleted.
+ Callers changes to call gimplify_type_sizes and gimplify_one_sizepos.
+ (gnat_stabilize_reference): Add arg to COMPONENT_REF.
+ (build_unit_elab): Disable for now.
+ * utils.c (mark_visited): New function.
+ (pushdecl): Walk tree to call it for global decl.
+ (update_pointer_to): Update all variants of pointer and ref types.
+ Add arg to COMPONENT_REF.
+ (convert): Likewise.
+ Move check for converting between variants lower down.
+ * utils2.c (build_simple_component_ref): Add arg to COMPONENT_REF.
+ (build_allocator): Don't force type of MODIFY_EXPR.
+ (gnat_mark_addressable, case VAR_DECL): Unconditionally call
+ put_var_into_stack.
+
2004-06-14 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
* ada-tree.def (LOOP_STMT, EXIT_STMT): Update documentation.
static tree substitution_list (Entity_Id, Entity_Id, tree, int);
static int allocatable_size_p (tree, int);
static struct attrib *build_attr_list (Entity_Id);
-static tree elaborate_expression (Node_Id, Entity_Id, tree, int, int, int);
+static tree elaborate_expression (Node_Id, Entity_Id, tree, bool, bool, bool);
static int is_variable_size (tree);
-static tree elaborate_expression_1 (Node_Id, Entity_Id, tree, tree, int, int);
+static tree elaborate_expression_1 (Node_Id, Entity_Id, tree, tree,
+ bool, bool);
static tree make_packable_type (tree);
static tree maybe_pad_type (tree, tree, unsigned int, Entity_Id, const char *,
int, int, int);
fields once we build them. */
tem = build (COMPONENT_REF, gnu_ptr_template,
build (PLACEHOLDER_EXPR, gnu_fat_type),
- TREE_CHAIN (TYPE_FIELDS (gnu_fat_type)));
+ TREE_CHAIN (TYPE_FIELDS (gnu_fat_type)), NULL_TREE);
gnu_template_reference
= build_unary_op (INDIRECT_REF, gnu_template_type, tem);
TREE_READONLY (gnu_template_reference) = 1;
/* We can't use build_component_ref here since the template
type isn't complete yet. */
gnu_min = build (COMPONENT_REF, gnu_ind_subtype,
- gnu_template_reference, gnu_min_field);
+ gnu_template_reference, gnu_min_field, NULL_TREE);
gnu_max = build (COMPONENT_REF, gnu_ind_subtype,
- gnu_template_reference, gnu_max_field);
+ gnu_template_reference, gnu_max_field, NULL_TREE);
TREE_READONLY (gnu_min) = TREE_READONLY (gnu_max) = 1;
/* Make a range type with the new ranges, but using
gnu_get_parent = build (COMPONENT_REF, void_type_node,
build (PLACEHOLDER_EXPR, gnu_type),
build_decl (FIELD_DECL, NULL_TREE,
- NULL_TREE));
+ NULL_TREE),
+ NULL_TREE);
if (Has_Discriminants (gnat_entity))
for (gnat_field = First_Stored_Discriminant (gnat_entity);
gnu_get_parent,
gnat_to_gnu_entity (Corresponding_Discriminant
(gnat_field),
- NULL_TREE, 0)),
+ NULL_TREE, 0),
+ NULL_TREE),
1);
gnu_parent = gnat_to_gnu_type (Parent_Subtype (gnat_entity));
build (COMPONENT_REF, TREE_TYPE (gnu_field),
build (PLACEHOLDER_EXPR,
DECL_CONTEXT (gnu_field)),
- gnu_field),
+ gnu_field, NULL_TREE),
1);
TREE_CHAIN (gnu_field) = gnu_field_list;
purposes even if it isn't needed for code generation. */
static tree
-elaborate_expression (Node_Id gnat_expr,
- Entity_Id gnat_entity,
- tree gnu_name,
- int definition,
- int need_value,
- int need_debug)
+elaborate_expression (Node_Id gnat_expr, Entity_Id gnat_entity,
+ tree gnu_name, bool definition, bool need_value,
+ bool need_debug)
{
tree gnu_expr;
= elaborate_expression_1 (gnat_expr, gnat_entity, gnat_to_gnu (gnat_expr),
gnu_name, definition, need_debug);
- /* Save the expression in case we try to elaborate this entity again.
- Since this is not a DECL, don't check it. If this is a constant,
- don't save it since GNAT_EXPR might be used more than once. Also,
- don't save if it's a discriminant. */
+ /* Save the expression in case we try to elaborate this entity again. Since
+ this is not a DECL, don't check it. Don't save if it's a discriminant. */
if (! CONTAINS_PLACEHOLDER_P (gnu_expr))
save_gnu_tree (gnat_expr, gnu_expr, 1);
/* Similar, but take a GNU expression. */
static tree
-elaborate_expression_1 (Node_Id gnat_expr,
- Entity_Id gnat_entity,
- tree gnu_expr,
- tree gnu_name,
- int definition,
- int need_debug)
+elaborate_expression_1 (Node_Id gnat_expr, Entity_Id gnat_entity,
+ tree gnu_expr, tree gnu_name, bool definition,
+ bool need_debug)
{
tree gnu_decl = 0;
/* Strip any conversions to see if the expression is a readonly variable.
if (TREE_CODE (gnu_expr) == FIELD_DECL)
gnu_expr = build (COMPONENT_REF, TREE_TYPE (gnu_expr),
build (PLACEHOLDER_EXPR, DECL_CONTEXT (gnu_expr)),
- gnu_expr);
+ gnu_expr, NULL_TREE);
/* If GNU_EXPR is neither a placeholder nor a constant, nor a variable
that is a constant, make a variable that is initialized to contain the
TREE_VALUE of each entry is the label of the corresponding LOOP_STMT. */
static GTY(()) tree gnu_loop_label_stack;
+/* List of TREE_LIST nodes representing labels for switch statements.
+ TREE_VALUE of each entry is the label at the end of the switch. */
+static GTY(()) tree gnu_switch_label_stack;
+
/* List of TREE_LIST nodes containing pending elaborations lists.
used to prevent the elaborations being reclaimed by GC. */
static GTY(()) tree gnu_pending_elaboration_lists;
case N_Object_Renaming_Declaration:
gnat_temp = Defining_Entity (gnat_node);
- gnu_result = alloc_stmt_list ();
- /* Don't do anything if this renaming is handled by the front end.
- or if we are just annotating types and this object has a
- composite or task type, don't elaborate it. */
+ /* Don't do anything if this renaming is handled by the front end. or if
+ we are just annotating types and this object has a composite or task
+ type, don't elaborate it. We return the result in case it has any
+ SAVE_EXPRs in it that need to be evaluated here. */
if (! Is_Renaming_Of_Object (gnat_temp)
&& ! (type_annotate_only
&& (Is_Array_Type (Etype (gnat_temp))
|| Is_Record_Type (Etype (gnat_temp))
|| Is_Concurrent_Type (Etype (gnat_temp)))))
- gnat_to_gnu_entity (gnat_temp,
- gnat_to_gnu (Renamed_Object (gnat_temp)), 1);
+ gnu_result
+ = gnat_to_gnu_entity (gnat_temp,
+ gnat_to_gnu (Renamed_Object (gnat_temp)), 1);
+ else
+ gnu_result = alloc_stmt_list ();
break;
case N_Implicit_Label_Declaration:
/* We build a SWITCH_EXPR that contains the code with interspersed
CASE_LABEL_EXPRs for each label. */
+ push_stack (&gnu_switch_label_stack, NULL_TREE,
+ create_artificial_label ());
start_stmt_group ();
for (gnat_when = First_Non_Pragma (Alternatives (gnat_node));
Present (gnat_when);
we want them to be local to this set of statements instead of
the block containing the Case statement. */
add_stmt (build_stmt_group (Statements (gnat_when), true));
+ add_stmt (build1 (GOTO_EXPR, void_type_node,
+ TREE_VALUE (gnu_switch_label_stack)));
+
}
+ /* Now emit a definition of the label all the cases branched to. */
+ add_stmt (build1 (LABEL_EXPR, void_type_node,
+ TREE_VALUE (gnu_switch_label_stack)));
gnu_result = build (SWITCH_EXPR, TREE_TYPE (gnu_expr), gnu_expr,
end_stmt_group (), NULL_TREE);
+ pop_stack (&gnu_switch_label_stack);
break;
}
{
/* If this is a variable that Gigi is to ignore, we may have been given
an ERROR_MARK. So test for it. We also might have been given a
- reference for a renaming. So only do something for a decl. */
- if (!DECL_P (gnu_decl))
+ reference for a renaming. So only do something for a decl. Also
+ ignore a TYPE_DECL for an UNCONSTRAINED_ARRAY_TYPE. */
+ if (!DECL_P (gnu_decl)
+ || (TREE_CODE (gnu_decl) == TYPE_DECL
+ && TREE_CODE (TREE_TYPE (gnu_decl)) == UNCONSTRAINED_ARRAY_TYPE))
return;
add_stmt_with_node (build (DECL_STMT, void_type_node, gnu_decl),
return GS_OK;
case USE_STMT:
- *stmt_p = build_empty_stmt ();
+ *stmt_p = alloc_stmt_list ();
return GS_ALL_DONE;
case DECL_STMT:
tree var = DECL_STMT_VAR (stmt);
if (TREE_CODE (var) == TYPE_DECL)
- *stmt_p = gnat_gimplify_type_sizes (TREE_TYPE (var));
- else if (TREE_CODE (var) == VAR_DECL && !DECL_EXTERNAL (var)
- && !TREE_CONSTANT (DECL_SIZE_UNIT (var)))
+ *stmt_p = gimplify_type_sizes (TREE_TYPE (var));
+ else if (TREE_CODE (var) == VAR_DECL)
{
- tree pt_type = build_pointer_type (TREE_TYPE (var));
- tree size, pre = NULL_TREE, post = NULL_TREE;
-
- /* This is a variable-sized decl. Simplify its size and mark it
- for deferred expansion. Note that mudflap depends on the format
- of the emitted code: see mx_register_decls. */
*stmt_p = NULL_TREE;
- size = get_initialized_tmp_var (DECL_SIZE_UNIT (var), &pre, &post);
- DECL_DEFER_OUTPUT (var) = 1;
- append_to_statement_list (pre, stmt_p);
- append_to_statement_list
- (build_function_call_expr
- (implicit_built_in_decls[BUILT_IN_STACK_ALLOC],
- tree_cons (NULL_TREE,
- build1 (ADDR_EXPR, pt_type, var),
- tree_cons (NULL_TREE, size, NULL_TREE))),
- stmt_p);
- append_to_statement_list (post, stmt_p);
+ gimplify_one_sizepos (&DECL_SIZE (var), stmt_p);
+ gimplify_one_sizepos (&DECL_SIZE_UNIT (var), stmt_p);
+
+ if (!DECL_EXTERNAL (var) && !TREE_CONSTANT (DECL_SIZE_UNIT (var)))
+ {
+ DECL_DEFER_OUTPUT (var) = 1;
+ append_to_statement_list
+ (build_function_call_expr
+ (implicit_built_in_decls[BUILT_IN_STACK_ALLOC],
+ tree_cons (NULL_TREE,
+ build1 (ADDR_EXPR,
+ build_pointer_type (TREE_TYPE (var)),
+ var),
+ tree_cons (NULL_TREE, DECL_SIZE_UNIT (var),
+ NULL_TREE))),
+ stmt_p);
+ }
+
+ if (*stmt_p == NULL_TREE)
+ *stmt_p = alloc_stmt_list ();
}
else
- *stmt_p = build_empty_stmt ();
+ *stmt_p = alloc_stmt_list ();
return GS_ALL_DONE;
}
abort ();
}
}
-
-/* Look through GNU_TYPE for variable-sized objects and gimplify each such
- size that we find. Return a STATEMENT_LIST containing the result. */
-
-static tree
-gnat_gimplify_type_sizes (tree gnu_type)
-{
- tree gnu_stmts = NULL_TREE;
- tree gnu_field;
-
- switch (TREE_CODE (gnu_type))
- {
- case ERROR_MARK:
- case UNCONSTRAINED_ARRAY_TYPE:
- return alloc_stmt_list ();
-
- case INTEGER_TYPE:
- case ENUMERAL_TYPE:
- case BOOLEAN_TYPE:
- case CHAR_TYPE:
- case REAL_TYPE:
- gnat_gimplify_one_sizepos (&TYPE_MIN_VALUE (gnu_type), &gnu_stmts);
- gnat_gimplify_one_sizepos (&TYPE_MAX_VALUE (gnu_type), &gnu_stmts);
- break;
-
- case RECORD_TYPE:
- case UNION_TYPE:
- case QUAL_UNION_TYPE:
- for (gnu_field = TYPE_FIELDS (gnu_type); gnu_field;
- gnu_field = TREE_CHAIN (gnu_field))
- if (TREE_CODE (gnu_field) == FIELD_DECL)
- gnat_gimplify_one_sizepos (&DECL_FIELD_OFFSET (gnu_field),
- &gnu_stmts);
- break;
-
- default:
- break;
- }
-
- gnat_gimplify_one_sizepos (&TYPE_SIZE (gnu_type), &gnu_stmts);
- gnat_gimplify_one_sizepos (&TYPE_SIZE_UNIT (gnu_type), &gnu_stmts);
-
- if (!gnu_stmts)
- gnu_stmts = alloc_stmt_list ();
-
- return gnu_stmts;
-}
-
-/* Subroutine of the above to gimplify one size or position, *GNU_EXPR_P.
- We add any required statements to GNU_STMT_P. */
-
-static void
-gnat_gimplify_one_sizepos (tree *gnu_expr_p, tree *gnu_stmt_p)
-{
- tree gnu_pre = NULL_TREE, gnu_post = NULL_TREE;
-
- /* We don't do anything if the value isn't there, is constant, or
- contains a PLACEHOLDER_EXPR. */
- if (*gnu_expr_p == NULL_TREE
- || TREE_CONSTANT (*gnu_expr_p)
- || CONTAINS_PLACEHOLDER_P (*gnu_expr_p))
- return;
-
- gimplify_expr (gnu_expr_p, &gnu_pre, &gnu_post, is_gimple_val, fb_rvalue);
-
- if (gnu_pre)
- append_to_statement_list (gnu_pre, gnu_stmt_p);
- if (gnu_post)
- append_to_statement_list (gnu_post, gnu_stmt_p);
-}
\f
/* Generate the RTL for the body of GNU_DECL. If NESTED_P is nonzero,
then we are already in the process of generating RTL for another
result = build (COMPONENT_REF, type,
gnat_stabilize_reference (TREE_OPERAND (ref, 0),
force),
- TREE_OPERAND (ref, 1));
+ TREE_OPERAND (ref, 1), NULL_TREE);
break;
case BIT_FIELD_REF:
rtx insn;
int result = 1;
+ /* ??? For now, force nothing to do. */
+ gnu_elab_list = 0;
+
/* If we have nothing to do, return. */
if (gnu_elab_list == 0)
return 1;
int unused;
};
+static tree mark_visited (tree *, int *, void *);
static void gnat_define_builtin (const char *, tree, int, const char *, bool);
static void gnat_install_builtins (void);
static tree merge_sizes (tree, tree, tree, int, int);
return BLOCK_VARS (current_binding_level->block) != 0;
}
\f
+/* Utility function to mark nodes with TREE_VISITED. Called from walk_tree.
+ We use this to indicate all variable sizes and positions in global types
+ may not be shared by any subprogram. */
+
+static tree
+mark_visited (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
+{
+ if (TREE_VISITED (*tp))
+ *walk_subtrees = 0;
+ else
+ TREE_VISITED (*tp) = 1;
+
+ return NULL_TREE;
+}
+\f
/* Records a ..._DECL node DECL as belonging to the current lexical scope.
Returns the ..._DECL node. */
pushdecl (tree decl)
{
/* If at top level, there is no context. But PARM_DECLs always go in the
- level of its function. */
+ level of its function. Also, at toplevel we must protect all trees
+ that are part of sizes and positions. */
if (global_bindings_p () && TREE_CODE (decl) != PARM_DECL)
- DECL_CONTEXT (decl) = 0;
+ {
+ DECL_CONTEXT (decl) = 0;
+ walk_tree (&decl, mark_visited, NULL, NULL);
+ }
else
DECL_CONTEXT (decl) = current_function_decl;
information about this type. */
tree
-create_type_decl (tree type_name,
- tree type,
- struct attrib *attr_list,
- int artificial_p,
- int debug_info_p)
+create_type_decl (tree type_name, tree type, struct attrib *attr_list,
+ int artificial_p, int debug_info_p)
{
tree type_decl = build_decl (TYPE_DECL, type_name, type);
enum tree_code code = TREE_CODE (type);
so that items like VLA sizes are expanded properly in the context of the
correct function. */
cgn = cgraph_node (fndecl);
- for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
+ for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
gnat_gimplify_function (cgn->decl);
}
{
tree ptr = TYPE_POINTER_TO (old_type);
tree ref = TYPE_REFERENCE_TO (old_type);
+ tree ptr1, ref1;
tree type;
/* If this is the main variant, process all the other variants first. */
TYPE_REFERENCE_TO (new_type) = ref;
for (; ptr; ptr = TYPE_NEXT_PTR_TO (ptr))
- {
- TREE_TYPE (ptr) = new_type;
+ for (ptr1 = TYPE_MAIN_VARIANT (ptr); ptr1;
+ ptr1 = TYPE_NEXT_VARIANT (ptr1))
+ {
+ TREE_TYPE (ptr1) = new_type;
- if (TYPE_NAME (ptr) != 0
- && TREE_CODE (TYPE_NAME (ptr)) == TYPE_DECL
- && TREE_CODE (new_type) != ENUMERAL_TYPE)
- rest_of_decl_compilation (TYPE_NAME (ptr), NULL,
- global_bindings_p (), 0);
- }
+ if (TYPE_NAME (ptr1) != 0
+ && TREE_CODE (TYPE_NAME (ptr1)) == TYPE_DECL
+ && TREE_CODE (new_type) != ENUMERAL_TYPE)
+ rest_of_decl_compilation (TYPE_NAME (ptr1), NULL,
+ global_bindings_p (), 0);
+ }
for (; ref; ref = TYPE_NEXT_PTR_TO (ref))
- {
- TREE_TYPE (ref) = new_type;
+ for (ref1 = TYPE_MAIN_VARIANT (ref); ref1;
+ ref1 = TYPE_NEXT_VARIANT (ref1))
+ {
+ TREE_TYPE (ref1) = new_type;
- if (TYPE_NAME (ref) != 0
- && TREE_CODE (TYPE_NAME (ref)) == TYPE_DECL
- && TREE_CODE (new_type) != ENUMERAL_TYPE)
- rest_of_decl_compilation (TYPE_NAME (ref), NULL,
- global_bindings_p (), 0);
- }
+ if (TYPE_NAME (ref1) != 0
+ && TREE_CODE (TYPE_NAME (ref1)) == TYPE_DECL
+ && TREE_CODE (new_type) != ENUMERAL_TYPE)
+ rest_of_decl_compilation (TYPE_NAME (ref1), NULL,
+ global_bindings_p (), 0);
+ }
}
/* Now deal with the unconstrained array case. In this case the "pointer"
ptr_temp_type = TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (ptr)));
new_ref = build (COMPONENT_REF, ptr_temp_type,
build (PLACEHOLDER_EXPR, ptr),
- TREE_CHAIN (TYPE_FIELDS (ptr)));
+ TREE_CHAIN (TYPE_FIELDS (ptr)), NULL_TREE);
update_pointer_to
(TREE_TYPE (TREE_TYPE (TYPE_FIELDS (ptr))),
/* If EXPR is already the right type, we are done. */
if (type == etype)
return expr;
- /* If we're converting between two aggregate types that have the same main
- variant, just make a VIEW_CONVER_EXPR. */
- else if (AGGREGATE_TYPE_P (type)
- && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (etype))
- return build1 (VIEW_CONVERT_EXPR, type, expr);
/* If the input type has padding, remove it by doing a component reference
to the field. If the output type has padding, make a constructor
&& operand_equal_p (TYPE_SIZE (type), TYPE_SIZE (etype), 0)
&& get_alias_set (type) == get_alias_set (etype))
return build (COMPONENT_REF, type, TREE_OPERAND (expr, 0),
- TREE_OPERAND (expr, 1));
+ TREE_OPERAND (expr, 1), NULL_TREE);
break;
if (TYPE_FAT_POINTER_P (type) && ! TYPE_FAT_POINTER_P (etype))
return convert_to_fat_pointer (type, expr);
- if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (etype)
- || (code == INTEGER_CST && ecode == INTEGER_CST
- && (type == TREE_TYPE (etype) || etype == TREE_TYPE (type))))
+ /* If we're converting between two aggregate types that have the same main
+ variant, just make a VIEW_CONVER_EXPR. */
+ else if (AGGREGATE_TYPE_P (type)
+ && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (etype))
+ return build1 (VIEW_CONVERT_EXPR, type, expr);
+
+ /* In all other cases of related types, make a NOP_EXPR. */
+ else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (etype)
+ || (code == INTEGER_CST && ecode == INTEGER_CST
+ && (type == TREE_TYPE (etype) || etype == TREE_TYPE (type))))
return fold (build1 (NOP_EXPR, type, expr));
switch (code)
actual record and know how to look for fields in variant parts. */
static tree
-build_simple_component_ref (tree record_variable,
- tree component,
- tree field,
- int no_fold_p)
+build_simple_component_ref (tree record_variable, tree component,
+ tree field, int no_fold_p)
{
tree record_type = TYPE_MAIN_VARIANT (TREE_TYPE (record_variable));
tree ref;
/* It would be nice to call "fold" here, but that can lose a type
we need to tag a PLACEHOLDER_EXPR with, so we can't do it. */
- ref = build (COMPONENT_REF, TREE_TYPE (field), record_variable, field);
+ ref = build (COMPONENT_REF, TREE_TYPE (field), record_variable, field,
+ NULL_TREE);
if (TREE_READONLY (record_variable) || TREE_READONLY (field))
TREE_READONLY (ref) = 1;
reference could not be found. */
tree
-build_component_ref (tree record_variable,
- tree component,
- tree field,
- int no_fold_p)
+build_component_ref (tree record_variable, tree component,
+ tree field, int no_fold_p)
{
tree ref = build_simple_component_ref (record_variable, component, field,
no_fold_p);
result
= build (COMPOUND_EXPR, TREE_TYPE (result),
build_binary_op
- (MODIFY_EXPR, TREE_TYPE (TREE_TYPE (result)),
+ (MODIFY_EXPR, NULL_TREE,
build_unary_op (INDIRECT_REF, TREE_TYPE (TREE_TYPE (result)),
result),
init),
case VAR_DECL:
case PARM_DECL:
case RESULT_DECL:
- /* If we have already made a REG for this decl, we must put it
- directly into the stack. Likewise for a MEM whose address is a
- pseudo. Otherwise, set a flag to mark us to do it later. */
- if (DECL_RTL_SET_P (expr_node)
- && (GET_CODE (DECL_RTL (expr_node)) == REG
- || (GET_CODE (DECL_RTL (expr_node)) == MEM
- && GET_CODE (XEXP (DECL_RTL (expr_node), 0)) == REG
- && (REGNO (XEXP (DECL_RTL (expr_node), 0))
- > LAST_VIRTUAL_REGISTER))))
- put_var_into_stack (expr_node, 1);
- else
- TREE_ADDRESSABLE (expr_node) = 1;
-
+ put_var_into_stack (expr_node, 1);
+ TREE_ADDRESSABLE (expr_node) = 1;
return true;
case FUNCTION_DECL:
projects / gcc.git / commitdiff