1 /* Convert language-specific tree expression to rtl instructions,
3 Copyright (C) 1988, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
33 /* Hook used by expand_expr to expand language-specific tree codes. */
36 cplus_expand_expr (exp, target, tmode, modifier)
39 enum machine_mode tmode;
40 enum expand_modifier modifier;
42 tree type = TREE_TYPE (exp);
43 register enum machine_mode mode = TYPE_MODE (type);
44 register enum tree_code code = TREE_CODE (exp);
45 rtx original_target = target;
46 int ignore = target == const0_rtx;
49 target = 0, original_target = 0;
51 /* No sense saving up arithmetic to be done
52 if it's all in the wrong mode to form part of an address.
53 And force_operand won't know whether to sign-extend or zero-extend. */
55 if (mode != Pmode && modifier == EXPAND_SUM)
56 modifier = EXPAND_NORMAL;
62 /* Something needs to be initialized, but we didn't know
63 where that thing was when building the tree. For example,
64 it could be the return value of a function, or a parameter
65 to a function which lays down in the stack, or a temporary
66 variable which must be passed by reference.
68 Cleanups are handled in a language-specific way: they
69 might be run by the called function (true in GNU C++
70 for parameters with cleanups), or they might be
71 run by the caller, after the call (true in GNU C++
72 for other cleanup needs). */
74 tree func = TREE_OPERAND (exp, 0);
75 tree args = TREE_OPERAND (exp, 1);
76 tree type = TREE_TYPE (exp), slot;
77 tree fn_type = TREE_TYPE (TREE_TYPE (func));
78 tree return_type = TREE_TYPE (fn_type);
80 rtx call_target, return_target;
81 int pcc_struct_return = 0;
83 /* The expression `init' wants to initialize what
84 `target' represents. SLOT holds the slot for TARGET. */
85 slot = TREE_OPERAND (exp, 2);
89 /* Should always be called with a target in BLKmode case. */
90 my_friendly_assert (mode != BLKmode, 205);
91 my_friendly_assert (DECL_RTL (slot) != 0, 206);
93 target = gen_reg_rtx (mode);
96 /* The target the initializer will initialize (CALL_TARGET)
97 must now be directed to initialize the target we are
98 supposed to initialize (TARGET). The semantics for
99 choosing what CALL_TARGET is is language-specific,
100 as is building the call which will perform the
101 initialization. It is left here to show the choices that
104 if (TREE_CODE (func) == ADDR_EXPR
105 && TREE_CODE (TREE_OPERAND (func, 0)) == FUNCTION_DECL
106 && DECL_CONSTRUCTOR_P (TREE_OPERAND (func, 0)))
108 type = build_pointer_type (type);
109 /* Don't clobber a value that might be part of a default
111 mark_addressable (slot);
112 if (TREE_PERMANENT (args))
113 args = tree_cons (0, build1 (ADDR_EXPR, type, slot),
116 TREE_VALUE (args) = build1 (ADDR_EXPR, type, slot);
119 else if (TREE_CODE (return_type) == REFERENCE_TYPE)
126 #ifdef PCC_STATIC_STRUCT_RETURN
127 pcc_struct_return = 1;
130 call_target = target;
135 /* Make this a valid memory address now. The code below assumes
136 that it can compare rtx and make assumptions based on the
137 result. The assumptions are true only if the address was
138 valid to begin with. */
139 call_target = validize_mem (call_target);
142 call_exp = build (CALL_EXPR, type, func, args, 0);
143 TREE_SIDE_EFFECTS (call_exp) = 1;
144 return_target = expand_call (call_exp, call_target, ignore);
145 if (call_target == 0)
147 if (pcc_struct_return)
149 extern int flag_access_control;
150 int old_ac = flag_access_control;
152 tree init = build_decl (VAR_DECL, 0, type);
153 TREE_ADDRESSABLE (init) = 1;
154 DECL_RTL (init) = return_target;
156 flag_access_control = 0;
157 expand_aggr_init (slot, init, 0, LOOKUP_ONLYCONVERTING);
158 flag_access_control = old_ac;
160 if (TYPE_NEEDS_DESTRUCTOR (type))
162 init = build_decl (VAR_DECL, 0,
163 build_reference_type (type));
164 DECL_RTL (init) = XEXP (return_target, 0);
166 init = maybe_build_cleanup (convert_from_reference (init));
167 if (init != NULL_TREE)
168 expand_expr (init, 0, 0, 0);
170 call_target = return_target = DECL_RTL (slot);
173 call_target = return_target;
176 if (call_target != return_target)
178 my_friendly_assert (TYPE_HAS_TRIVIAL_INIT_REF (type), 317);
179 if (GET_MODE (return_target) == BLKmode)
180 emit_block_move (call_target, return_target, expr_size (exp),
181 TYPE_ALIGN (type) / BITS_PER_UNIT);
183 emit_move_insn (call_target, return_target);
186 if (TREE_CODE (return_type) == REFERENCE_TYPE)
190 if (GET_CODE (call_target) == REG
191 && REGNO (call_target) < FIRST_PSEUDO_REGISTER)
192 my_friendly_abort (39);
194 type = TREE_TYPE (exp);
196 init = build (RTL_EXPR, return_type, 0, call_target);
197 /* We got back a reference to the type we want. Now initialize
199 expand_aggr_init (slot, init, 0, LOOKUP_ONLYCONVERTING);
202 if (DECL_RTL (slot) != target)
203 emit_move_insn (DECL_RTL (slot), target);
204 return DECL_RTL (slot);
210 return expand_expr (default_conversion (resolve_offset_ref (exp)),
211 target, tmode, EXPAND_NORMAL);
213 /* This is old crusty code, and does not handle all that the
214 resolve_offset_ref function does. (mrs) */
215 tree base = build_unary_op (ADDR_EXPR, TREE_OPERAND (exp, 0), 0);
216 tree offset = build_unary_op (ADDR_EXPR, TREE_OPERAND (exp, 1), 0);
217 return expand_expr (build (PLUS_EXPR, TREE_TYPE (exp), base, offset),
218 target, tmode, EXPAND_NORMAL);
223 return DECL_RTL (exp);
226 expand_throw (TREE_OPERAND (exp, 0));
232 temp = expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier);
233 TREE_OPERAND (exp, 0) = unsave_expr_now (TREE_OPERAND (exp, 0));
240 (NULL_TREE, TREE_OPERAND (exp, 0),
241 build_binary_op (MINUS_EXPR, TREE_OPERAND (exp, 2),
242 integer_one_node, 1),
243 TREE_OPERAND (exp, 1), 0), target, tmode, modifier);
248 my_friendly_abort (40);
256 lang_expand_expr = cplus_expand_expr;
259 /* If DECL had its rtl moved from where callers expect it
260 to be, fix it up. RESULT is the nominal rtl for the RESULT_DECL,
261 which may be a pseudo instead of a hard register. */
264 fixup_result_decl (decl, result)
270 if (REGNO (result) >= FIRST_PSEUDO_REGISTER)
272 rtx real_decl_result;
274 #ifdef FUNCTION_OUTGOING_VALUE
276 = FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl), current_function_decl);
279 = FUNCTION_VALUE (TREE_TYPE (decl), current_function_decl);
281 REG_FUNCTION_VALUE_P (real_decl_result) = 1;
282 result = real_decl_result;
284 store_expr (decl, result, 0);
285 emit_insn (gen_rtx (USE, VOIDmode, result));
289 /* Expand this initialization inline and see if it's simple enough that
290 it can be done at compile-time. */
293 extract_aggr_init (decl, init)
300 extract_scalar_init (decl, init)
303 rtx value, insns, insn;
304 extern struct obstack temporary_obstack;
307 push_obstacks (&temporary_obstack, &temporary_obstack);
309 value = expand_expr (init, NULL_RTX, VOIDmode, 0);
310 insns = get_insns ();
312 reg_scan (insns, max_reg_num (), 0);
313 jump_optimize (insns, 0, 0, 1);
316 for (insn = insns; insn; insn = NEXT_INSN (insn))
320 if (GET_CODE (insn) == NOTE)
322 else if (GET_CODE (insn) != INSN)
326 if (GET_CODE (r) != SET)
331 if (! (to == value ||
332 (GET_CODE (to) == SUBREG && XEXP (to, 0) == value)))
337 switch (GET_CODE (r))
340 t = build_int_2 (XEXP (r, 0), 0);
351 extract_init (decl, init)
357 if (IS_AGGR_TYPE (TREE_TYPE (decl))
358 || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
359 init = extract_aggr_init (decl, init);
361 init = extract_scalar_init (decl, init);
363 if (init == NULL_TREE)
366 DECL_INITIAL (decl) = init;
375 tree value1 = NULL_TREE, value2 = NULL_TREE, label;
377 if (start && POINTER_TYPE_P (TREE_TYPE (start)))
378 error ("pointers are not permitted as case values");
381 pedwarn ("ANSI C++ forbids range expressions in switch statement");
383 if (current_template_parms)
385 add_tree (build_min_nt (CASE_LABEL, start, end));
390 value1 = check_cp_case_value (start);
392 value2 = check_cp_case_value (end);
394 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
396 if (value1 != error_mark_node
397 && value2 != error_mark_node)
403 success = pushcase_range (value1, value2, convert_and_check,
406 success = pushcase (value1, convert_and_check, label, &duplicate);
408 success = pushcase (NULL_TREE, 0, label, &duplicate);
413 error ("case label not within a switch statement");
415 cp_error ("case label `%E' not within a switch statement", start);
417 error ("default label not within a switch statement");
419 else if (success == 2)
423 error ("duplicate (or overlapping) case value");
424 cp_error_at ("this is the first entry overlapping that value",
429 cp_error ("duplicate case value `%E'", start);
430 cp_error_at ("previously used here", duplicate);
434 error ("multiple default labels in one switch");
435 cp_error_at ("this is the first default label", duplicate);
438 else if (success == 3)
439 warning ("case value out of range");
440 else if (success == 4)
441 warning ("empty range specified");
442 else if (success == 5)
445 error ("case label within scope of cleanup or variable array");
447 cp_error ("case label `%E' within scope of cleanup or variable array", start);
451 define_case_label (label);
453 define_case_label (NULL_TREE);