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, NULL_TREE);
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, const0_rtx, VOIDmode, 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 (NULL_TREE, TREE_OPERAND (exp, 0),
233 build_binary_op (MINUS_EXPR, TREE_OPERAND (exp, 2),
234 integer_one_node, 1),
235 TREE_OPERAND (exp, 1), 0), target, tmode, modifier);
240 my_friendly_abort (40);
248 lang_expand_expr = cplus_expand_expr;
251 /* If DECL had its rtl moved from where callers expect it
252 to be, fix it up. RESULT is the nominal rtl for the RESULT_DECL,
253 which may be a pseudo instead of a hard register. */
256 fixup_result_decl (decl, result)
262 if (REGNO (result) >= FIRST_PSEUDO_REGISTER)
264 rtx real_decl_result;
266 #ifdef FUNCTION_OUTGOING_VALUE
268 = FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl), current_function_decl);
271 = FUNCTION_VALUE (TREE_TYPE (decl), current_function_decl);
273 REG_FUNCTION_VALUE_P (real_decl_result) = 1;
274 result = real_decl_result;
276 store_expr (decl, result, 0);
277 emit_insn (gen_rtx (USE, VOIDmode, result));
281 /* Expand this initialization inline and see if it's simple enough that
282 it can be done at compile-time. */
285 extract_aggr_init (decl, init)
292 extract_scalar_init (decl, init)
295 rtx value, insns, insn;
296 extern struct obstack temporary_obstack;
299 push_obstacks (&temporary_obstack, &temporary_obstack);
301 value = expand_expr (init, NULL_RTX, VOIDmode, 0);
302 insns = get_insns ();
304 reg_scan (insns, max_reg_num (), 0);
305 jump_optimize (insns, 0, 0, 1);
308 for (insn = insns; insn; insn = NEXT_INSN (insn))
312 if (GET_CODE (insn) == NOTE)
314 else if (GET_CODE (insn) != INSN)
318 if (GET_CODE (r) != SET)
323 if (! (to == value ||
324 (GET_CODE (to) == SUBREG && XEXP (to, 0) == value)))
329 switch (GET_CODE (r))
332 t = build_int_2 (XEXP (r, 0), 0);
343 extract_init (decl, init)
349 if (IS_AGGR_TYPE (TREE_TYPE (decl))
350 || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
351 init = extract_aggr_init (decl, init);
353 init = extract_scalar_init (decl, init);
355 if (init == NULL_TREE)
358 DECL_INITIAL (decl) = init;
367 tree value1 = NULL_TREE, value2 = NULL_TREE, label;
369 if (start != NULL_TREE && TREE_TYPE (start) != NULL_TREE
370 && POINTER_TYPE_P (TREE_TYPE (start)))
371 error ("pointers are not permitted as case values");
374 pedwarn ("ANSI C++ forbids range expressions in switch statement");
376 if (processing_template_decl)
378 add_tree (build_min_nt (CASE_LABEL, start, end));
383 value1 = check_cp_case_value (start);
385 value2 = check_cp_case_value (end);
387 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
389 if (value1 != error_mark_node
390 && value2 != error_mark_node)
396 success = pushcase_range (value1, value2, convert_and_check,
399 success = pushcase (value1, convert_and_check, label, &duplicate);
401 success = pushcase (NULL_TREE, 0, label, &duplicate);
406 error ("case label not within a switch statement");
408 cp_error ("case label `%E' not within a switch statement", start);
410 error ("default label not within a switch statement");
412 else if (success == 2)
416 error ("duplicate (or overlapping) case value");
417 cp_error_at ("this is the first entry overlapping that value",
422 cp_error ("duplicate case value `%E'", start);
423 cp_error_at ("previously used here", duplicate);
427 error ("multiple default labels in one switch");
428 cp_error_at ("this is the first default label", duplicate);
431 else if (success == 3)
432 warning ("case value out of range");
433 else if (success == 4)
434 warning ("empty range specified");
435 else if (success == 5)
438 error ("case label within scope of cleanup or variable array");
440 cp_error ("case label `%E' within scope of cleanup or variable array", start);
444 define_case_label (label);
446 define_case_label (NULL_TREE);