blob: a98089b7ccac604fcaae6cea7ff7e7a1f0da354e [file] [log] [blame]
/* D-specific tree lowering bits; see also gimple.cc.
Copyright (C) 2020-2022 Free Software Foundation, Inc.
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "dmd/globals.h"
#include "tree.h"
#include "gimple-expr.h"
#include "gimplify.h"
#include "d-tree.h"
/* Return TRUE if an operand OP of a given TYPE being copied has no data.
The middle-end does a similar check with zero sized types. */
static bool
empty_modify_p (tree type, tree op)
{
tree_code code = TREE_CODE (op);
switch (code)
{
case COMPOUND_EXPR:
return empty_modify_p (type, TREE_OPERAND (op, 1));
case CONSTRUCTOR:
/* Non-empty construcors are valid. */
if (CONSTRUCTOR_NELTS (op) != 0 || TREE_CLOBBER_P (op))
return false;
break;
case CALL_EXPR:
/* Leave nrvo alone because it isn't a copy. */
if (CALL_EXPR_RETURN_SLOT_OPT (op))
return false;
break;
default:
/* If the operand doesn't have a simple form. */
if (!is_gimple_lvalue (op) && !INDIRECT_REF_P (op))
return false;
break;
}
return empty_aggregate_p (type);
}
/* Return TRUE if EXPR is a COMPONENT_REF to a bit-field declaration. */
static bool
bit_field_ref (const_tree expr)
{
if (TREE_CODE (expr) == COMPONENT_REF
&& DECL_BIT_FIELD (TREE_OPERAND (expr, 1)))
return true;
return false;
}
/* Gimplify assignment from an INIT_EXPR or MODIFY_EXPR. */
static gimplify_status
d_gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
{
tree op0 = TREE_OPERAND (*expr_p, 0);
tree op1 = TREE_OPERAND (*expr_p, 1);
if (error_operand_p (op0) || error_operand_p (op1))
return GS_UNHANDLED;
/* Remove any copies of empty aggregates. */
if (empty_modify_p (TREE_TYPE (op0), op1))
{
gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
is_gimple_lvalue, fb_lvalue);
if (TREE_SIDE_EFFECTS (op1))
gimplify_and_add (op1, pre_p);
*expr_p = TREE_OPERAND (*expr_p, 0);
return GS_OK;
}
/* If the back end isn't clever enough to know that the lhs and rhs
types are the same, add an explicit conversion. */
if ((AGGREGATE_TYPE_P (TREE_TYPE (op0)) || AGGREGATE_TYPE_P (TREE_TYPE (op1)))
&& !useless_type_conversion_p (TREE_TYPE (op1), TREE_TYPE (op0)))
{
TREE_OPERAND (*expr_p, 1) = build1 (VIEW_CONVERT_EXPR,
TREE_TYPE (op0), op1);
return GS_OK;
}
/* Same as above, but for bit-field assignments. */
if (bit_field_ref (op0) && TREE_TYPE (op0) != TREE_TYPE (op1))
{
TREE_OPERAND (*expr_p, 1) = convert (TREE_TYPE (op0), op1);
return GS_OK;
}
return GS_UNHANDLED;
}
/* Gimplify an ADDR_EXPR node. */
static gimplify_status
d_gimplify_addr_expr (tree *expr_p)
{
tree op0 = TREE_OPERAND (*expr_p, 0);
/* Constructors are not lvalues, so make them one. */
if (TREE_CODE (op0) == CONSTRUCTOR)
{
TREE_OPERAND (*expr_p, 0) = force_target_expr (op0);
return GS_OK;
}
return GS_UNHANDLED;
}
/* Gimplify a CALL_EXPR node. */
static gimplify_status
d_gimplify_call_expr (tree *expr_p, gimple_seq *pre_p)
{
/* Strictly evaluate all arguments from left to right. */
int nargs = call_expr_nargs (*expr_p);
location_t loc = EXPR_LOC_OR_LOC (*expr_p, input_location);
/* No need to enforce evaluation order if only one argument. */
if (nargs < 2)
return GS_UNHANDLED;
/* Or if all arguments are already free of side-effects. */
bool has_side_effects = false;
for (int i = 0; i < nargs; i++)
{
if (TREE_SIDE_EFFECTS (CALL_EXPR_ARG (*expr_p, i)))
{
has_side_effects = true;
break;
}
}
if (!has_side_effects)
return GS_UNHANDLED;
/* Leave the last argument for gimplify_call_expr. */
for (int i = 0; i < nargs - 1; i++)
{
tree new_arg = CALL_EXPR_ARG (*expr_p, i);
/* If argument has a side-effect, gimplify_arg will handle it. */
if (gimplify_arg (&new_arg, pre_p, loc) == GS_ERROR)
return GS_ERROR;
/* Even if an argument itself doesn't have any side-effects, it
might be altered by another argument in the list. */
if (new_arg == CALL_EXPR_ARG (*expr_p, i)
&& !really_constant_p (new_arg))
new_arg = get_formal_tmp_var (new_arg, pre_p);
CALL_EXPR_ARG (*expr_p, i) = new_arg;
}
return GS_OK;
}
/* Gimplify an UNSIGNED_RSHIFT_EXPR node. */
static gimplify_status
d_gimplify_unsigned_rshift_expr (tree *expr_p)
{
/* Convert op0 to an unsigned type. */
tree op0 = TREE_OPERAND (*expr_p, 0);
tree op1 = TREE_OPERAND (*expr_p, 1);
tree type = d_unsigned_type (TREE_TYPE (op0));
*expr_p = convert (TREE_TYPE (*expr_p),
build2 (RSHIFT_EXPR, type, convert (type, op0), op1));
return GS_OK;
}
/* Gimplify an unary expression node. */
static gimplify_status
d_gimplify_unary_expr (tree *expr_p)
{
tree op0 = TREE_OPERAND (*expr_p, 0);
if (error_operand_p (op0))
return GS_UNHANDLED;
/* Front end doesn't know that bit-field types are really different
from basic types, add an explicit conversion in unary expressions. */
if (bit_field_ref (op0) && TREE_TYPE (op0) != TREE_TYPE (*expr_p))
{
TREE_OPERAND (*expr_p, 0) = convert (TREE_TYPE (*expr_p), op0);
return GS_OK;
}
return GS_UNHANDLED;
}
/* Gimplify a binary expression node. */
static gimplify_status
d_gimplify_binary_expr (tree *expr_p)
{
tree op0 = TREE_OPERAND (*expr_p, 0);
tree op1 = TREE_OPERAND (*expr_p, 1);
if (error_operand_p (op0) || error_operand_p (op1))
return GS_UNHANDLED;
/* Front end doesn't know that bit-field types are really different
from basic types, add an explicit conversion in binary expressions. */
if (bit_field_ref (op0) || bit_field_ref (op1))
{
if (TREE_TYPE (op0) != TREE_TYPE (*expr_p))
TREE_OPERAND (*expr_p, 0) = convert (TREE_TYPE (*expr_p), op0);
if (TREE_TYPE (op1) != TREE_TYPE (*expr_p))
TREE_OPERAND (*expr_p, 1) = convert (TREE_TYPE (*expr_p), op1);
return GS_OK;
}
return GS_UNHANDLED;
}
/* Implements the lang_hooks.gimplify_expr routine for language D.
Do gimplification of D specific expression trees in EXPR_P. */
int
d_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
{
switch (TREE_CODE (*expr_p))
{
case INIT_EXPR:
case MODIFY_EXPR:
return d_gimplify_modify_expr (expr_p, pre_p, post_p);
case ADDR_EXPR:
return d_gimplify_addr_expr (expr_p);
case CALL_EXPR:
return d_gimplify_call_expr (expr_p, pre_p);
case UNSIGNED_RSHIFT_EXPR:
return d_gimplify_unsigned_rshift_expr (expr_p);
case FLOAT_MOD_EXPR:
gcc_unreachable ();
default:
if (UNARY_CLASS_P (*expr_p) && !CONVERT_EXPR_P (*expr_p))
return d_gimplify_unary_expr (expr_p);
if (BINARY_CLASS_P (*expr_p))
return d_gimplify_binary_expr (expr_p);
break;
}
return GS_UNHANDLED;
}