OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[Ada] Small housekeeping work in gnat_gimplify_expr

Browse Source 
This alphabetizes the large switch statement, removes a useless nested
switch statement, an artificial fall through and adds a default return.

No functional changes.

gcc/ada/

	* gcc-interface/trans.cc (gnat_gimplify_expr): Tidy up.
This commit is contained in:
Eric Botcazou 2022-03-23 14:35:40 +01:00 committed by Pierre-Marie de Rodat
parent cfc07102ef
commit 9ae384160f
1 changed files with 60 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
gcc/ada/gcc-interface/trans.cc
View File

@ -8638,30 +8638,6 @@ gnat_gimplify_expr (tree *expr_p, gimple_seq *pre_p,
switch (TREE_CODE (expr))
{
case NULL_EXPR:
/* If this is an aggregate type, build a null pointer of the appropriate
type and dereference it. */
if (AGGREGATE_TYPE_P (type)
|| TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE)
*expr_p = build_unary_op (INDIRECT_REF, NULL_TREE,
convert (build_pointer_type (type),
integer_zero_node));
/* Otherwise, just make a VAR_DECL. */
else
{
*expr_p = create_tmp_var (type, NULL);
suppress_warning (*expr_p);
}
gimplify_and_add (TREE_OPERAND (expr, 0), pre_p);
return GS_OK;
case UNCONSTRAINED_ARRAY_REF:
/* We should only do this if we are just elaborating for side-effects,
but we can't know that yet. */
*expr_p = TREE_OPERAND (*expr_p, 0);
return GS_OK;
case ADDR_EXPR:
op = TREE_OPERAND (expr, 0);
@ -8695,8 +8671,7 @@ gnat_gimplify_expr (tree *expr_p, gimple_seq *pre_p,
else
op = inner;
}
return GS_UNHANDLED;
break;
case CALL_EXPR:
/* If we are passing a constant fat pointer CONSTRUCTOR, make sure it is
@ -8720,8 +8695,62 @@ gnat_gimplify_expr (tree *expr_p, gimple_seq *pre_p,
*(CALL_EXPR_ARGP (expr) + i) = tree_output_constant_def (arg);
}
}
break;
return GS_UNHANDLED;
case DECL_EXPR:
op = DECL_EXPR_DECL (expr);
/* The expressions for the RM bounds must be gimplified to ensure that
they are properly elaborated. See gimplify_decl_expr. */
if ((TREE_CODE (op) == TYPE_DECL || TREE_CODE (op) == VAR_DECL)
&& !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (op))
&& (INTEGRAL_TYPE_P (TREE_TYPE (op))
|| SCALAR_FLOAT_TYPE_P (TREE_TYPE (op))))
{
tree type = TYPE_MAIN_VARIANT (TREE_TYPE (op)), t, val;
val = TYPE_RM_MIN_VALUE (type);
if (val)
{
gimplify_one_sizepos (&val, pre_p);
for (t = type; t; t = TYPE_NEXT_VARIANT (t))
SET_TYPE_RM_MIN_VALUE (t, val);
}
val = TYPE_RM_MAX_VALUE (type);
if (val)
{
gimplify_one_sizepos (&val, pre_p);
for (t = type; t; t = TYPE_NEXT_VARIANT (t))
SET_TYPE_RM_MAX_VALUE (t, val);
}
}
break;
case NULL_EXPR:
/* If this is an aggregate type, build a null pointer of the appropriate
type and dereference it. */
if (AGGREGATE_TYPE_P (type)
|| TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE)
*expr_p = build_unary_op (INDIRECT_REF, NULL_TREE,
convert (build_pointer_type (type),
integer_zero_node));
/* Otherwise, just make a VAR_DECL. */
else
{
*expr_p = create_tmp_var (type, NULL);
suppress_warning (*expr_p);
}
gimplify_and_add (TREE_OPERAND (expr, 0), pre_p);
return GS_OK;
case UNCONSTRAINED_ARRAY_REF:
/* We should only do this if we are just elaborating for side effects,
but we can't know that yet. */
*expr_p = TREE_OPERAND (*expr_p, 0);
return GS_OK;
case VIEW_CONVERT_EXPR:
op = TREE_OPERAND (expr, 0);
@ -8742,53 +8771,13 @@ gnat_gimplify_expr (tree *expr_p, gimple_seq *pre_p,
TREE_OPERAND (expr, 0) = new_var;
return GS_OK;
}
return GS_UNHANDLED;
case DECL_EXPR:
op = DECL_EXPR_DECL (expr);
/* The expressions for the RM bounds must be gimplified to ensure that
they are properly elaborated. See gimplify_decl_expr. */
if ((TREE_CODE (op) == TYPE_DECL || TREE_CODE (op) == VAR_DECL)
&& !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (op)))
switch (TREE_CODE (TREE_TYPE (op)))
{
case INTEGER_TYPE:
case ENUMERAL_TYPE:
case BOOLEAN_TYPE:
case REAL_TYPE:
{
tree type = TYPE_MAIN_VARIANT (TREE_TYPE (op)), t, val;
val = TYPE_RM_MIN_VALUE (type);
if (val)
{
gimplify_one_sizepos (&val, pre_p);
for (t = type; t; t = TYPE_NEXT_VARIANT (t))
SET_TYPE_RM_MIN_VALUE (t, val);
}
val = TYPE_RM_MAX_VALUE (type);
if (val)
{
gimplify_one_sizepos (&val, pre_p);
for (t = type; t; t = TYPE_NEXT_VARIANT (t))
SET_TYPE_RM_MAX_VALUE (t, val);
}
}
break;
default:
break;
}
/* ... fall through ... */
break;
default:
return GS_UNHANDLED;
break;
}
return GS_UNHANDLED;
}
/* Generate GIMPLE in place for the statement at *STMT_P. */