/* Convert language-specific tree expression to rtl instructions,
for GNU compiler.
- Copyright (C) 1988, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+ Copyright (C) 1988, 92-97, 1998 Free Software Foundation, Inc.
This file is part of GNU CC.
#include "config.h"
+#include "system.h"
#include "rtl.h"
#include "tree.h"
#include "flags.h"
#include "expr.h"
#include "cp-tree.h"
+#include "toplev.h"
+#include "except.h"
+#include "tm_p.h"
-#undef NULL
-#define NULL 0
+#if 0
+static tree extract_aggr_init PROTO((tree, tree));
+static tree extract_scalar_init PROTO((tree, tree));
+#endif
+static rtx cplus_expand_expr PROTO((tree, rtx, enum machine_mode,
+ enum expand_modifier));
+
+/* Hook used by output_constant to expand language-specific
+ constants. */
+
+tree
+cplus_expand_constant (cst)
+ tree cst;
+{
+ switch (TREE_CODE (cst))
+ {
+ case PTRMEM_CST:
+ {
+ tree type = TREE_TYPE (cst);
+ tree member;
+ tree offset;
+
+ /* Find the member. */
+ member = PTRMEM_CST_MEMBER (cst);
+
+ if (TREE_CODE (member) == FIELD_DECL)
+ {
+ /* Find the offset for the field. */
+ offset = convert (sizetype,
+ size_binop (EASY_DIV_EXPR,
+ DECL_FIELD_BITPOS (member),
+ size_int (BITS_PER_UNIT)));
+
+ /* We offset all pointer to data members by 1 so that we
+ can distinguish between a null pointer to data member
+ and the first data member of a structure. */
+ offset = size_binop (PLUS_EXPR, offset, size_int (1));
+
+ cst = cp_convert (type, offset);
+ }
+ else
+ {
+ tree delta;
+ tree idx;
+ tree pfn;
+ tree delta2;
+
+ expand_ptrmemfunc_cst (cst, &delta, &idx, &pfn, &delta2);
+
+ cst = build_ptrmemfunc1 (type, delta, idx,
+ pfn, delta2);
+ }
+ }
+ break;
+
+ default:
+ /* There's nothing to do. */
+ break;
+ }
+
+ return cst;
+}
/* Hook used by expand_expr to expand language-specific tree codes. */
-rtx
+static rtx
cplus_expand_expr (exp, target, tmode, modifier)
tree exp;
rtx target;
tree type = TREE_TYPE (exp);
register enum machine_mode mode = TYPE_MODE (type);
register enum tree_code code = TREE_CODE (exp);
- rtx original_target = target;
int ignore = target == const0_rtx;
if (ignore)
- target = 0, original_target = 0;
+ target = 0;
/* No sense saving up arithmetic to be done
if it's all in the wrong mode to form part of an address.
switch (code)
{
- case NEW_EXPR:
+ case AGGR_INIT_EXPR:
{
/* Something needs to be initialized, but we didn't know
where that thing was when building the tree. For example,
tree func = TREE_OPERAND (exp, 0);
tree args = TREE_OPERAND (exp, 1);
tree type = TREE_TYPE (exp), slot;
- tree fn_type = TREE_TYPE (TREE_TYPE (func));
- tree return_type = TREE_TYPE (fn_type);
tree call_exp;
rtx call_target, return_target;
int pcc_struct_return = 0;
`target' represents. SLOT holds the slot for TARGET. */
slot = TREE_OPERAND (exp, 2);
- if (target == 0)
- {
- /* Should always be called with a target in BLKmode case. */
- my_friendly_assert (mode != BLKmode, 205);
- my_friendly_assert (DECL_RTL (slot) != 0, 206);
-
- target = gen_reg_rtx (mode);
- }
+ /* Should always be called with a target. */
+ my_friendly_assert (target != NULL_RTX, 205);
/* The target the initializer will initialize (CALL_TARGET)
must now be directed to initialize the target we are
initialization. It is left here to show the choices that
exist for C++. */
- if (TREE_CODE (func) == ADDR_EXPR
- && TREE_CODE (TREE_OPERAND (func, 0)) == FUNCTION_DECL
- && DECL_CONSTRUCTOR_P (TREE_OPERAND (func, 0)))
+ if (AGGR_INIT_VIA_CTOR_P (exp))
{
type = build_pointer_type (type);
- /* Don't clobber a value that might be part of a default
- parameter value. */
mark_addressable (slot);
- if (TREE_PERMANENT (args))
- args = tree_cons (0, build1 (ADDR_EXPR, type, slot),
- TREE_CHAIN (args));
- else
- TREE_VALUE (args) = build1 (ADDR_EXPR, type, slot);
- call_target = 0;
- }
- else if (TREE_CODE (return_type) == REFERENCE_TYPE)
- {
- type = return_type;
+ args = tree_cons (NULL_TREE,
+ build1 (ADDR_EXPR, type, slot),
+ TREE_CHAIN (args));
call_target = 0;
}
else
{
-#ifdef PCC_STATIC_STRUCT_RETURN
- pcc_struct_return = 1;
- call_target = 0;
-#else
call_target = target;
+#ifdef PCC_STATIC_STRUCT_RETURN
+ if (aggregate_value_p (type))
+ {
+ pcc_struct_return = 1;
+ call_target = 0;
+ }
#endif
}
- if (call_target)
- {
- /* Make this a valid memory address now. The code below assumes
- that it can compare rtx and make assumptions based on the
- result. The assumptions are true only if the address was
- valid to begin with. */
- call_target = validize_mem (call_target);
- }
call_exp = build (CALL_EXPR, type, func, args, NULL_TREE);
TREE_SIDE_EFFECTS (call_exp) = 1;
return_target = expand_call (call_exp, call_target, ignore);
- if (call_target == 0)
- {
- if (pcc_struct_return)
- {
- extern int flag_access_control;
- int old_ac = flag_access_control;
-
- tree init = build_decl (VAR_DECL, 0, type);
- TREE_ADDRESSABLE (init) = 1;
- DECL_RTL (init) = return_target;
-
- flag_access_control = 0;
- expand_aggr_init (slot, init, 0, LOOKUP_ONLYCONVERTING);
- flag_access_control = old_ac;
-
- if (TYPE_NEEDS_DESTRUCTOR (type))
- {
- init = build_decl (VAR_DECL, 0,
- build_reference_type (type));
- DECL_RTL (init) = XEXP (return_target, 0);
-
- init = maybe_build_cleanup (convert_from_reference (init));
- if (init != NULL_TREE)
- expand_expr (init, 0, 0, 0);
- }
- call_target = return_target = DECL_RTL (slot);
- }
- else
- call_target = return_target;
- }
-
- if (call_target != return_target)
- {
- my_friendly_assert (TYPE_HAS_TRIVIAL_INIT_REF (type), 317);
- if (GET_MODE (return_target) == BLKmode)
- emit_block_move (call_target, return_target, expr_size (exp),
- TYPE_ALIGN (type) / BITS_PER_UNIT);
- else
- emit_move_insn (call_target, return_target);
- }
- if (TREE_CODE (return_type) == REFERENCE_TYPE)
+ if (call_target)
+ /* Trust that the right thing has been done; it's too hard to
+ verify. */
+ return return_target;
+
+ /* If we're suffering under the ancient PCC_STATIC_STRUCT_RETURN
+ calling convention, we need to copy the return value out of
+ the static return buffer into slot. */
+ if (pcc_struct_return)
{
- tree init;
+ extern int flag_access_control;
+ int old_ac = flag_access_control;
- if (GET_CODE (call_target) == REG
- && REGNO (call_target) < FIRST_PSEUDO_REGISTER)
- my_friendly_abort (39);
+ tree init = build_decl (VAR_DECL, NULL_TREE,
+ build_reference_type (type));
+ DECL_RTL (init) = XEXP (return_target, 0);
+ init = convert_from_reference (init);
- type = TREE_TYPE (exp);
+ flag_access_control = 0;
+ expand_expr (build_aggr_init (slot, init,
+ LOOKUP_ONLYCONVERTING),
+ target, tmode, EXPAND_NORMAL);
+ flag_access_control = old_ac;
- init = build (RTL_EXPR, return_type, 0, call_target);
- /* We got back a reference to the type we want. Now initialize
- target with that. */
- expand_aggr_init (slot, init, 0, LOOKUP_ONLYCONVERTING);
+ if (TYPE_NEEDS_DESTRUCTOR (type))
+ {
+ init = maybe_build_cleanup (init);
+ if (init != NULL_TREE)
+ expand_expr (init, const0_rtx, VOIDmode, 0);
+ }
}
- if (DECL_RTL (slot) != target)
- emit_move_insn (DECL_RTL (slot), target);
return DECL_RTL (slot);
}
+ case PTRMEM_CST:
+ return expand_expr (cplus_expand_constant (exp),
+ target, tmode, modifier);
+
case OFFSET_REF:
{
-#if 1
return expand_expr (default_conversion (resolve_offset_ref (exp)),
target, tmode, EXPAND_NORMAL);
-#else
- /* This is old crusty code, and does not handle all that the
- resolve_offset_ref function does. (mrs) */
- tree base = build_unary_op (ADDR_EXPR, TREE_OPERAND (exp, 0), 0);
- tree offset = build_unary_op (ADDR_EXPR, TREE_OPERAND (exp, 1), 0);
- return expand_expr (build (PLUS_EXPR, TREE_TYPE (exp), base, offset),
- target, tmode, EXPAND_NORMAL);
-#endif
}
case THUNK_DECL:
return DECL_RTL (exp);
case THROW_EXPR:
- expand_throw (TREE_OPERAND (exp, 0));
+ expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
+ expand_internal_throw ();
return NULL;
- case VEC_INIT_EXPR:
- return expand_expr
- (expand_vec_init
- (NULL_TREE, TREE_OPERAND (exp, 0),
- build_binary_op (MINUS_EXPR, TREE_OPERAND (exp, 2),
- integer_one_node, 1),
- TREE_OPERAND (exp, 1), 0), target, tmode, modifier);
+ case EMPTY_CLASS_EXPR:
+ /* We don't need to generate any code for an empty class. */
+ return const0_rtx;
+
+ case STMT_EXPR:
+ {
+ tree rtl_expr = begin_stmt_expr ();
+ expand_stmt (STMT_EXPR_STMT (exp));
+ finish_stmt_expr (rtl_expr);
+ return expand_expr (rtl_expr, target, tmode, modifier);
+ }
+ break;
default:
break;
init_cplus_expand ()
{
lang_expand_expr = cplus_expand_expr;
+ lang_expand_constant = cplus_expand_constant;
}
/* If DECL had its rtl moved from where callers expect it
}
}
+#if 0
/* Expand this initialization inline and see if it's simple enough that
it can be done at compile-time. */
extern struct obstack temporary_obstack;
tree t = NULL_TREE;
- push_obstacks (&temporary_obstack, &temporary_obstack);
start_sequence ();
value = expand_expr (init, NULL_RTX, VOIDmode, 0);
insns = get_insns ();
end_sequence ();
reg_scan (insns, max_reg_num (), 0);
jump_optimize (insns, 0, 0, 1);
- pop_obstacks ();
for (insn = insns; insn; insn = NEXT_INSN (insn))
{
to = XEXP (r, 0);
- if (! (to == value ||
- (GET_CODE (to) == SUBREG && XEXP (to, 0) == value)))
+ if (! (to == value
+ || (GET_CODE (to) == SUBREG && XEXP (to, 0) == value)))
return 0;
r = XEXP (r, 1);
return t;
}
+#endif
int
extract_init (decl, init)
- tree decl, init;
+ tree decl ATTRIBUTE_UNUSED, init ATTRIBUTE_UNUSED;
{
return 0;
if (end && pedantic)
pedwarn ("ANSI C++ forbids range expressions in switch statement");
- if (current_template_parms)
- {
- add_tree (build_min_nt (CASE_LABEL, start, end));
- return;
- }
-
if (start)
value1 = check_cp_case_value (start);
if (end)
{
if (end)
error ("case label within scope of cleanup or variable array");
+ else if (! start)
+ error ("`default' label within scope of cleanup or variable array");
else
cp_error ("case label `%E' within scope of cleanup or variable array", start);
}
}
- if (start)
- define_case_label (label);
- else
- define_case_label (NULL_TREE);
+
+ current_function_return_value = NULL_TREE;
}
OSDN Git Service
