]>
Commit | Line | Data |
---|---|---|
5e6908ea | 1 | /* Expands front end tree to back end RTL for GCC. |
af841dbd | 2 | Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, |
589fe865 | 3 | 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. |
6f086dfc | 4 | |
1322177d | 5 | This file is part of GCC. |
6f086dfc | 6 | |
1322177d LB |
7 | GCC is free software; you can redistribute it and/or modify it under |
8 | the terms of the GNU General Public License as published by the Free | |
9 | Software Foundation; either version 2, or (at your option) any later | |
10 | version. | |
6f086dfc | 11 | |
1322177d LB |
12 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
13 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 | for more details. | |
6f086dfc RS |
16 | |
17 | You should have received a copy of the GNU General Public License | |
1322177d LB |
18 | along with GCC; see the file COPYING. If not, write to the Free |
19 | Software Foundation, 59 Temple Place - Suite 330, Boston, MA | |
20 | 02111-1307, USA. */ | |
6f086dfc | 21 | |
6f086dfc RS |
22 | /* This file handles the generation of rtl code from tree structure |
23 | at the level of the function as a whole. | |
24 | It creates the rtl expressions for parameters and auto variables | |
25 | and has full responsibility for allocating stack slots. | |
26 | ||
27 | `expand_function_start' is called at the beginning of a function, | |
28 | before the function body is parsed, and `expand_function_end' is | |
29 | called after parsing the body. | |
30 | ||
31 | Call `assign_stack_local' to allocate a stack slot for a local variable. | |
32 | This is usually done during the RTL generation for the function body, | |
33 | but it can also be done in the reload pass when a pseudo-register does | |
8fff4fc1 | 34 | not get a hard register. */ |
6f086dfc RS |
35 | |
36 | #include "config.h" | |
670ee920 | 37 | #include "system.h" |
4977bab6 ZW |
38 | #include "coretypes.h" |
39 | #include "tm.h" | |
6f086dfc RS |
40 | #include "rtl.h" |
41 | #include "tree.h" | |
42 | #include "flags.h" | |
1ef08c63 | 43 | #include "except.h" |
6f086dfc | 44 | #include "function.h" |
6f086dfc | 45 | #include "expr.h" |
c6b97fac | 46 | #include "optabs.h" |
e78d8e51 | 47 | #include "libfuncs.h" |
6f086dfc RS |
48 | #include "regs.h" |
49 | #include "hard-reg-set.h" | |
50 | #include "insn-config.h" | |
51 | #include "recog.h" | |
52 | #include "output.h" | |
bdac5f58 | 53 | #include "basic-block.h" |
10f0ad3d | 54 | #include "toplev.h" |
e2500fed | 55 | #include "hashtab.h" |
87ff9c8e | 56 | #include "ggc.h" |
b1474bb7 | 57 | #include "tm_p.h" |
c0e7830f | 58 | #include "integrate.h" |
7afff7cf | 59 | #include "langhooks.h" |
61f71b34 | 60 | #include "target.h" |
623a66fa | 61 | #include "cfglayout.h" |
6f086dfc | 62 | |
d16790f2 JW |
63 | #ifndef LOCAL_ALIGNMENT |
64 | #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT | |
65 | #endif | |
66 | ||
95f3f59e JDA |
67 | #ifndef STACK_ALIGNMENT_NEEDED |
68 | #define STACK_ALIGNMENT_NEEDED 1 | |
69 | #endif | |
70 | ||
975f3818 RS |
71 | #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT) |
72 | ||
293e3de4 RS |
73 | /* Some systems use __main in a way incompatible with its use in gcc, in these |
74 | cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to | |
75 | give the same symbol without quotes for an alternative entry point. You | |
0f41302f | 76 | must define both, or neither. */ |
293e3de4 RS |
77 | #ifndef NAME__MAIN |
78 | #define NAME__MAIN "__main" | |
293e3de4 RS |
79 | #endif |
80 | ||
6f086dfc RS |
81 | /* Round a value to the lowest integer less than it that is a multiple of |
82 | the required alignment. Avoid using division in case the value is | |
83 | negative. Assume the alignment is a power of two. */ | |
84 | #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1)) | |
85 | ||
86 | /* Similar, but round to the next highest integer that meets the | |
87 | alignment. */ | |
88 | #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1)) | |
89 | ||
90 | /* NEED_SEPARATE_AP means that we cannot derive ap from the value of fp | |
91 | during rtl generation. If they are different register numbers, this is | |
92 | always true. It may also be true if | |
93 | FIRST_PARM_OFFSET - STARTING_FRAME_OFFSET is not a constant during rtl | |
94 | generation. See fix_lexical_addr for details. */ | |
95 | ||
96 | #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM | |
97 | #define NEED_SEPARATE_AP | |
98 | #endif | |
99 | ||
54ff41b7 JW |
100 | /* Nonzero if function being compiled doesn't contain any calls |
101 | (ignoring the prologue and epilogue). This is set prior to | |
102 | local register allocation and is valid for the remaining | |
718fe406 | 103 | compiler passes. */ |
54ff41b7 JW |
104 | int current_function_is_leaf; |
105 | ||
fb13d4d0 JM |
106 | /* Nonzero if function being compiled doesn't contain any instructions |
107 | that can throw an exception. This is set prior to final. */ | |
108 | ||
109 | int current_function_nothrow; | |
110 | ||
fdb8a883 JW |
111 | /* Nonzero if function being compiled doesn't modify the stack pointer |
112 | (ignoring the prologue and epilogue). This is only valid after | |
718fe406 | 113 | life_analysis has run. */ |
fdb8a883 JW |
114 | int current_function_sp_is_unchanging; |
115 | ||
54ff41b7 JW |
116 | /* Nonzero if the function being compiled is a leaf function which only |
117 | uses leaf registers. This is valid after reload (specifically after | |
118 | sched2) and is useful only if the port defines LEAF_REGISTERS. */ | |
54ff41b7 JW |
119 | int current_function_uses_only_leaf_regs; |
120 | ||
6f086dfc | 121 | /* Nonzero once virtual register instantiation has been done. |
c39ada04 DD |
122 | assign_stack_local uses frame_pointer_rtx when this is nonzero. |
123 | calls.c:emit_library_call_value_1 uses it to set up | |
124 | post-instantiation libcalls. */ | |
125 | int virtuals_instantiated; | |
6f086dfc | 126 | |
df696a75 | 127 | /* Assign unique numbers to labels generated for profiling, debugging, etc. */ |
17211ab5 | 128 | static GTY(()) int funcdef_no; |
f6f315fe | 129 | |
414c4dc4 NC |
130 | /* These variables hold pointers to functions to create and destroy |
131 | target specific, per-function data structures. */ | |
fa8db1f7 | 132 | struct machine_function * (*init_machine_status) (void); |
46766466 | 133 | |
b384405b | 134 | /* The currently compiled function. */ |
01d939e8 | 135 | struct function *cfun = 0; |
b384405b | 136 | |
5c7675e9 | 137 | /* These arrays record the INSN_UIDs of the prologue and epilogue insns. */ |
e2500fed GK |
138 | static GTY(()) varray_type prologue; |
139 | static GTY(()) varray_type epilogue; | |
0a1c58a2 JL |
140 | |
141 | /* Array of INSN_UIDs to hold the INSN_UIDs for each sibcall epilogue | |
142 | in this function. */ | |
e2500fed | 143 | static GTY(()) varray_type sibcall_epilogue; |
6f086dfc RS |
144 | \f |
145 | /* In order to evaluate some expressions, such as function calls returning | |
146 | structures in memory, we need to temporarily allocate stack locations. | |
147 | We record each allocated temporary in the following structure. | |
148 | ||
149 | Associated with each temporary slot is a nesting level. When we pop up | |
150 | one level, all temporaries associated with the previous level are freed. | |
151 | Normally, all temporaries are freed after the execution of the statement | |
152 | in which they were created. However, if we are inside a ({...}) grouping, | |
153 | the result may be in a temporary and hence must be preserved. If the | |
154 | result could be in a temporary, we preserve it if we can determine which | |
155 | one it is in. If we cannot determine which temporary may contain the | |
156 | result, all temporaries are preserved. A temporary is preserved by | |
157 | pretending it was allocated at the previous nesting level. | |
158 | ||
159 | Automatic variables are also assigned temporary slots, at the nesting | |
160 | level where they are defined. They are marked a "kept" so that | |
161 | free_temp_slots will not free them. */ | |
162 | ||
e2500fed | 163 | struct temp_slot GTY(()) |
6f086dfc RS |
164 | { |
165 | /* Points to next temporary slot. */ | |
166 | struct temp_slot *next; | |
0aea6467 ZD |
167 | /* Points to previous temporary slot. */ |
168 | struct temp_slot *prev; | |
169 | ||
0f41302f | 170 | /* The rtx to used to reference the slot. */ |
6f086dfc | 171 | rtx slot; |
e5e76139 RK |
172 | /* The rtx used to represent the address if not the address of the |
173 | slot above. May be an EXPR_LIST if multiple addresses exist. */ | |
174 | rtx address; | |
718fe406 | 175 | /* The alignment (in bits) of the slot. */ |
b5c02bff | 176 | unsigned int align; |
6f086dfc | 177 | /* The size, in units, of the slot. */ |
e5e809f4 | 178 | HOST_WIDE_INT size; |
1da68f56 RK |
179 | /* The type of the object in the slot, or zero if it doesn't correspond |
180 | to a type. We use this to determine whether a slot can be reused. | |
181 | It can be reused if objects of the type of the new slot will always | |
182 | conflict with objects of the type of the old slot. */ | |
183 | tree type; | |
cc2902df | 184 | /* Nonzero if this temporary is currently in use. */ |
6f086dfc | 185 | char in_use; |
cc2902df | 186 | /* Nonzero if this temporary has its address taken. */ |
a25d4ba2 | 187 | char addr_taken; |
6f086dfc RS |
188 | /* Nesting level at which this slot is being used. */ |
189 | int level; | |
cc2902df | 190 | /* Nonzero if this should survive a call to free_temp_slots. */ |
6f086dfc | 191 | int keep; |
fc91b0d0 RK |
192 | /* The offset of the slot from the frame_pointer, including extra space |
193 | for alignment. This info is for combine_temp_slots. */ | |
e5e809f4 | 194 | HOST_WIDE_INT base_offset; |
fc91b0d0 RK |
195 | /* The size of the slot, including extra space for alignment. This |
196 | info is for combine_temp_slots. */ | |
e5e809f4 | 197 | HOST_WIDE_INT full_size; |
6f086dfc | 198 | }; |
6f086dfc | 199 | \f |
e15679f8 RK |
200 | /* Forward declarations. */ |
201 | ||
fa8db1f7 AJ |
202 | static rtx assign_stack_local_1 (enum machine_mode, HOST_WIDE_INT, int, |
203 | struct function *); | |
204 | static struct temp_slot *find_temp_slot_from_address (rtx); | |
fa8db1f7 AJ |
205 | static void instantiate_decls (tree, int); |
206 | static void instantiate_decls_1 (tree, int); | |
207 | static void instantiate_decl (rtx, HOST_WIDE_INT, int); | |
208 | static rtx instantiate_new_reg (rtx, HOST_WIDE_INT *); | |
209 | static int instantiate_virtual_regs_1 (rtx *, rtx, int); | |
fa8db1f7 AJ |
210 | static void pad_to_arg_alignment (struct args_size *, int, struct args_size *); |
211 | static void pad_below (struct args_size *, enum machine_mode, tree); | |
fa8db1f7 AJ |
212 | static void reorder_blocks_1 (rtx, tree, varray_type *); |
213 | static void reorder_fix_fragments (tree); | |
fa8db1f7 AJ |
214 | static int all_blocks (tree, tree *); |
215 | static tree *get_block_vector (tree, int *); | |
216 | extern tree debug_find_var_in_block_tree (tree, tree); | |
1f52178b | 217 | /* We always define `record_insns' even if it's not used so that we |
ec97b83a | 218 | can always export `prologue_epilogue_contains'. */ |
fa8db1f7 AJ |
219 | static void record_insns (rtx, varray_type *) ATTRIBUTE_UNUSED; |
220 | static int contains (rtx, varray_type); | |
73ef99fb | 221 | #ifdef HAVE_return |
fa8db1f7 | 222 | static void emit_return_into_block (basic_block, rtx); |
73ef99fb | 223 | #endif |
fa8db1f7 | 224 | static void purge_single_hard_subreg_set (rtx); |
3258e996 | 225 | #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX) |
fa8db1f7 | 226 | static rtx keep_stack_depressed (rtx); |
7393c642 | 227 | #endif |
3a70d621 | 228 | static void prepare_function_start (tree); |
fa8db1f7 AJ |
229 | static void do_clobber_return_reg (rtx, void *); |
230 | static void do_use_return_reg (rtx, void *); | |
231 | static void instantiate_virtual_regs_lossage (rtx); | |
ded9bf77 | 232 | static tree split_complex_args (tree); |
4c4d143a | 233 | static void set_insn_locators (rtx, int) ATTRIBUTE_UNUSED; |
c20bf1f3 | 234 | \f |
6f086dfc | 235 | /* Pointer to chain of `struct function' for containing functions. */ |
1be4cd1f | 236 | struct function *outer_function_chain; |
6f086dfc RS |
237 | |
238 | /* Given a function decl for a containing function, | |
239 | return the `struct function' for it. */ | |
240 | ||
241 | struct function * | |
fa8db1f7 | 242 | find_function_data (tree decl) |
6f086dfc RS |
243 | { |
244 | struct function *p; | |
e5e809f4 | 245 | |
eb3ae3e1 | 246 | for (p = outer_function_chain; p; p = p->outer) |
6f086dfc RS |
247 | if (p->decl == decl) |
248 | return p; | |
e5e809f4 | 249 | |
6f086dfc RS |
250 | abort (); |
251 | } | |
252 | ||
253 | /* Save the current context for compilation of a nested function. | |
8c5666b4 | 254 | This is called from language-specific code. The caller should use |
b03e38e1 | 255 | the enter_nested langhook to save any language-specific state, |
8c5666b4 BS |
256 | since this function knows only about language-independent |
257 | variables. */ | |
6f086dfc RS |
258 | |
259 | void | |
fa8db1f7 | 260 | push_function_context_to (tree context) |
6f086dfc | 261 | { |
eb3ae3e1 | 262 | struct function *p; |
36edd3cc BS |
263 | |
264 | if (context) | |
265 | { | |
eb3ae3e1 ZW |
266 | if (context == current_function_decl) |
267 | cfun->contains_functions = 1; | |
268 | else | |
269 | { | |
270 | struct function *containing = find_function_data (context); | |
271 | containing->contains_functions = 1; | |
272 | } | |
36edd3cc | 273 | } |
b384405b | 274 | |
01d939e8 | 275 | if (cfun == 0) |
b384405b | 276 | init_dummy_function_start (); |
01d939e8 | 277 | p = cfun; |
6f086dfc | 278 | |
eb3ae3e1 | 279 | p->outer = outer_function_chain; |
6f086dfc | 280 | outer_function_chain = p; |
6f086dfc | 281 | |
ae2bcd98 | 282 | lang_hooks.function.enter_nested (p); |
b384405b | 283 | |
01d939e8 | 284 | cfun = 0; |
6f086dfc RS |
285 | } |
286 | ||
e4a4639e | 287 | void |
fa8db1f7 | 288 | push_function_context (void) |
e4a4639e | 289 | { |
a0dabda5 | 290 | push_function_context_to (current_function_decl); |
e4a4639e JM |
291 | } |
292 | ||
6f086dfc RS |
293 | /* Restore the last saved context, at the end of a nested function. |
294 | This function is called from language-specific code. */ | |
295 | ||
296 | void | |
fa8db1f7 | 297 | pop_function_context_from (tree context ATTRIBUTE_UNUSED) |
6f086dfc RS |
298 | { |
299 | struct function *p = outer_function_chain; | |
300 | ||
01d939e8 | 301 | cfun = p; |
eb3ae3e1 | 302 | outer_function_chain = p->outer; |
6f086dfc | 303 | |
6f086dfc | 304 | current_function_decl = p->decl; |
7cbc7b0c | 305 | reg_renumber = 0; |
6f086dfc | 306 | |
6f086dfc | 307 | restore_emit_status (p); |
6f086dfc | 308 | |
ae2bcd98 | 309 | lang_hooks.function.leave_nested (p); |
46766466 | 310 | |
6f086dfc RS |
311 | /* Reset variables that have known state during rtx generation. */ |
312 | rtx_equal_function_value_matters = 1; | |
313 | virtuals_instantiated = 0; | |
1b3d8f8a | 314 | generating_concat_p = 1; |
6f086dfc | 315 | } |
e4a4639e | 316 | |
36edd3cc | 317 | void |
fa8db1f7 | 318 | pop_function_context (void) |
e4a4639e | 319 | { |
a0dabda5 | 320 | pop_function_context_from (current_function_decl); |
e4a4639e | 321 | } |
e2ecd91c | 322 | |
fa51b01b RH |
323 | /* Clear out all parts of the state in F that can safely be discarded |
324 | after the function has been parsed, but not compiled, to let | |
325 | garbage collection reclaim the memory. */ | |
326 | ||
327 | void | |
fa8db1f7 | 328 | free_after_parsing (struct function *f) |
fa51b01b RH |
329 | { |
330 | /* f->expr->forced_labels is used by code generation. */ | |
331 | /* f->emit->regno_reg_rtx is used by code generation. */ | |
332 | /* f->varasm is used by code generation. */ | |
333 | /* f->eh->eh_return_stub_label is used by code generation. */ | |
334 | ||
ae2bcd98 | 335 | lang_hooks.function.final (f); |
e2500fed | 336 | f->stmt = NULL; |
fa51b01b RH |
337 | } |
338 | ||
e2ecd91c BS |
339 | /* Clear out all parts of the state in F that can safely be discarded |
340 | after the function has been compiled, to let garbage collection | |
0a8a198c | 341 | reclaim the memory. */ |
21cd906e | 342 | |
e2ecd91c | 343 | void |
fa8db1f7 | 344 | free_after_compilation (struct function *f) |
e2ecd91c | 345 | { |
e2500fed GK |
346 | f->eh = NULL; |
347 | f->expr = NULL; | |
348 | f->emit = NULL; | |
349 | f->varasm = NULL; | |
350 | f->machine = NULL; | |
fa51b01b | 351 | |
0aea6467 ZD |
352 | f->x_avail_temp_slots = NULL; |
353 | f->x_used_temp_slots = NULL; | |
fa51b01b RH |
354 | f->arg_offset_rtx = NULL; |
355 | f->return_rtx = NULL; | |
356 | f->internal_arg_pointer = NULL; | |
fa51b01b | 357 | f->x_nonlocal_goto_handler_labels = NULL; |
fa51b01b | 358 | f->x_return_label = NULL; |
6e3077c6 | 359 | f->x_naked_return_label = NULL; |
fa51b01b | 360 | f->x_stack_slot_list = NULL; |
fa51b01b RH |
361 | f->x_tail_recursion_reentry = NULL; |
362 | f->x_arg_pointer_save_area = NULL; | |
fa51b01b | 363 | f->x_parm_birth_insn = NULL; |
fa51b01b RH |
364 | f->original_arg_vector = NULL; |
365 | f->original_decl_initial = NULL; | |
fa51b01b | 366 | f->epilogue_delay_list = NULL; |
e2ecd91c | 367 | } |
6f086dfc RS |
368 | \f |
369 | /* Allocate fixed slots in the stack frame of the current function. */ | |
370 | ||
49ad7cfa BS |
371 | /* Return size needed for stack frame based on slots so far allocated in |
372 | function F. | |
c795bca9 | 373 | This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY; |
6f086dfc RS |
374 | the caller may have to do that. */ |
375 | ||
8af5168b | 376 | HOST_WIDE_INT |
fa8db1f7 | 377 | get_func_frame_size (struct function *f) |
6f086dfc RS |
378 | { |
379 | #ifdef FRAME_GROWS_DOWNWARD | |
49ad7cfa | 380 | return -f->x_frame_offset; |
6f086dfc | 381 | #else |
49ad7cfa | 382 | return f->x_frame_offset; |
6f086dfc RS |
383 | #endif |
384 | } | |
385 | ||
49ad7cfa BS |
386 | /* Return size needed for stack frame based on slots so far allocated. |
387 | This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY; | |
388 | the caller may have to do that. */ | |
389 | HOST_WIDE_INT | |
fa8db1f7 | 390 | get_frame_size (void) |
49ad7cfa | 391 | { |
01d939e8 | 392 | return get_func_frame_size (cfun); |
49ad7cfa BS |
393 | } |
394 | ||
6f086dfc RS |
395 | /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it |
396 | with machine mode MODE. | |
718fe406 | 397 | |
6f086dfc RS |
398 | ALIGN controls the amount of alignment for the address of the slot: |
399 | 0 means according to MODE, | |
400 | -1 means use BIGGEST_ALIGNMENT and round size to multiple of that, | |
cfa29a4c | 401 | -2 means use BITS_PER_UNIT, |
6f086dfc RS |
402 | positive specifies alignment boundary in bits. |
403 | ||
e2ecd91c | 404 | We do not round to stack_boundary here. |
6f086dfc | 405 | |
e2ecd91c BS |
406 | FUNCTION specifies the function to allocate in. */ |
407 | ||
408 | static rtx | |
fa8db1f7 AJ |
409 | assign_stack_local_1 (enum machine_mode mode, HOST_WIDE_INT size, int align, |
410 | struct function *function) | |
6f086dfc | 411 | { |
b3694847 | 412 | rtx x, addr; |
6f086dfc RS |
413 | int bigend_correction = 0; |
414 | int alignment; | |
58dbcf05 | 415 | int frame_off, frame_alignment, frame_phase; |
6f086dfc RS |
416 | |
417 | if (align == 0) | |
418 | { | |
d16790f2 JW |
419 | tree type; |
420 | ||
6f086dfc | 421 | if (mode == BLKmode) |
d16790f2 | 422 | alignment = BIGGEST_ALIGNMENT; |
dbab7b72 | 423 | else |
718fe406 | 424 | alignment = GET_MODE_ALIGNMENT (mode); |
d16790f2 JW |
425 | |
426 | /* Allow the target to (possibly) increase the alignment of this | |
427 | stack slot. */ | |
ae2bcd98 | 428 | type = lang_hooks.types.type_for_mode (mode, 0); |
d16790f2 JW |
429 | if (type) |
430 | alignment = LOCAL_ALIGNMENT (type, alignment); | |
431 | ||
432 | alignment /= BITS_PER_UNIT; | |
6f086dfc RS |
433 | } |
434 | else if (align == -1) | |
435 | { | |
436 | alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT; | |
437 | size = CEIL_ROUND (size, alignment); | |
438 | } | |
cfa29a4c EB |
439 | else if (align == -2) |
440 | alignment = 1; /* BITS_PER_UNIT / BITS_PER_UNIT */ | |
6f086dfc RS |
441 | else |
442 | alignment = align / BITS_PER_UNIT; | |
443 | ||
1474e303 | 444 | #ifdef FRAME_GROWS_DOWNWARD |
e2ecd91c | 445 | function->x_frame_offset -= size; |
1474e303 JL |
446 | #endif |
447 | ||
a0871656 JH |
448 | /* Ignore alignment we can't do with expected alignment of the boundary. */ |
449 | if (alignment * BITS_PER_UNIT > PREFERRED_STACK_BOUNDARY) | |
450 | alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; | |
451 | ||
452 | if (function->stack_alignment_needed < alignment * BITS_PER_UNIT) | |
453 | function->stack_alignment_needed = alignment * BITS_PER_UNIT; | |
454 | ||
58dbcf05 AH |
455 | /* Calculate how many bytes the start of local variables is off from |
456 | stack alignment. */ | |
457 | frame_alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; | |
458 | frame_off = STARTING_FRAME_OFFSET % frame_alignment; | |
459 | frame_phase = frame_off ? frame_alignment - frame_off : 0; | |
460 | ||
95f3f59e JDA |
461 | /* Round the frame offset to the specified alignment. The default is |
462 | to always honor requests to align the stack but a port may choose to | |
463 | do its own stack alignment by defining STACK_ALIGNMENT_NEEDED. */ | |
464 | if (STACK_ALIGNMENT_NEEDED | |
465 | || mode != BLKmode | |
466 | || size != 0) | |
467 | { | |
468 | /* We must be careful here, since FRAME_OFFSET might be negative and | |
469 | division with a negative dividend isn't as well defined as we might | |
470 | like. So we instead assume that ALIGNMENT is a power of two and | |
471 | use logical operations which are unambiguous. */ | |
6f086dfc | 472 | #ifdef FRAME_GROWS_DOWNWARD |
95f3f59e JDA |
473 | function->x_frame_offset |
474 | = (FLOOR_ROUND (function->x_frame_offset - frame_phase, alignment) | |
475 | + frame_phase); | |
6f086dfc | 476 | #else |
95f3f59e JDA |
477 | function->x_frame_offset |
478 | = (CEIL_ROUND (function->x_frame_offset - frame_phase, alignment) | |
479 | + frame_phase); | |
6f086dfc | 480 | #endif |
95f3f59e | 481 | } |
6f086dfc RS |
482 | |
483 | /* On a big-endian machine, if we are allocating more space than we will use, | |
484 | use the least significant bytes of those that are allocated. */ | |
f76b9db2 | 485 | if (BYTES_BIG_ENDIAN && mode != BLKmode) |
6f086dfc | 486 | bigend_correction = size - GET_MODE_SIZE (mode); |
6f086dfc | 487 | |
6f086dfc RS |
488 | /* If we have already instantiated virtual registers, return the actual |
489 | address relative to the frame pointer. */ | |
01d939e8 | 490 | if (function == cfun && virtuals_instantiated) |
6f086dfc | 491 | addr = plus_constant (frame_pointer_rtx, |
c41536f5 | 492 | trunc_int_for_mode |
6f086dfc | 493 | (frame_offset + bigend_correction |
c41536f5 | 494 | + STARTING_FRAME_OFFSET, Pmode)); |
6f086dfc RS |
495 | else |
496 | addr = plus_constant (virtual_stack_vars_rtx, | |
c41536f5 AO |
497 | trunc_int_for_mode |
498 | (function->x_frame_offset + bigend_correction, | |
499 | Pmode)); | |
6f086dfc RS |
500 | |
501 | #ifndef FRAME_GROWS_DOWNWARD | |
e2ecd91c | 502 | function->x_frame_offset += size; |
6f086dfc RS |
503 | #endif |
504 | ||
38a448ca | 505 | x = gen_rtx_MEM (mode, addr); |
6f086dfc | 506 | |
e2ecd91c BS |
507 | function->x_stack_slot_list |
508 | = gen_rtx_EXPR_LIST (VOIDmode, x, function->x_stack_slot_list); | |
509 | ||
6f086dfc RS |
510 | return x; |
511 | } | |
512 | ||
e2ecd91c BS |
513 | /* Wrapper around assign_stack_local_1; assign a local stack slot for the |
514 | current function. */ | |
3bdf5ad1 | 515 | |
e2ecd91c | 516 | rtx |
fa8db1f7 | 517 | assign_stack_local (enum machine_mode mode, HOST_WIDE_INT size, int align) |
6f086dfc | 518 | { |
01d939e8 | 519 | return assign_stack_local_1 (mode, size, align, cfun); |
6f086dfc | 520 | } |
0aea6467 ZD |
521 | |
522 | \f | |
523 | /* Removes temporary slot TEMP from LIST. */ | |
524 | ||
525 | static void | |
526 | cut_slot_from_list (struct temp_slot *temp, struct temp_slot **list) | |
527 | { | |
528 | if (temp->next) | |
529 | temp->next->prev = temp->prev; | |
530 | if (temp->prev) | |
531 | temp->prev->next = temp->next; | |
532 | else | |
533 | *list = temp->next; | |
534 | ||
535 | temp->prev = temp->next = NULL; | |
536 | } | |
537 | ||
538 | /* Inserts temporary slot TEMP to LIST. */ | |
539 | ||
540 | static void | |
541 | insert_slot_to_list (struct temp_slot *temp, struct temp_slot **list) | |
542 | { | |
543 | temp->next = *list; | |
544 | if (*list) | |
545 | (*list)->prev = temp; | |
546 | temp->prev = NULL; | |
547 | *list = temp; | |
548 | } | |
549 | ||
550 | /* Returns the list of used temp slots at LEVEL. */ | |
551 | ||
552 | static struct temp_slot ** | |
553 | temp_slots_at_level (int level) | |
554 | { | |
555 | level++; | |
556 | ||
557 | if (!used_temp_slots) | |
558 | VARRAY_GENERIC_PTR_INIT (used_temp_slots, 3, "used_temp_slots"); | |
559 | ||
560 | while (level >= (int) VARRAY_ACTIVE_SIZE (used_temp_slots)) | |
561 | VARRAY_PUSH_GENERIC_PTR (used_temp_slots, NULL); | |
562 | ||
563 | return (struct temp_slot **) &VARRAY_GENERIC_PTR (used_temp_slots, level); | |
564 | } | |
565 | ||
566 | /* Returns the maximal temporary slot level. */ | |
567 | ||
568 | static int | |
569 | max_slot_level (void) | |
570 | { | |
571 | if (!used_temp_slots) | |
572 | return -1; | |
573 | ||
574 | return VARRAY_ACTIVE_SIZE (used_temp_slots) - 1; | |
575 | } | |
576 | ||
577 | /* Moves temporary slot TEMP to LEVEL. */ | |
578 | ||
579 | static void | |
580 | move_slot_to_level (struct temp_slot *temp, int level) | |
581 | { | |
582 | cut_slot_from_list (temp, temp_slots_at_level (temp->level)); | |
583 | insert_slot_to_list (temp, temp_slots_at_level (level)); | |
584 | temp->level = level; | |
585 | } | |
586 | ||
587 | /* Make temporary slot TEMP available. */ | |
588 | ||
589 | static void | |
590 | make_slot_available (struct temp_slot *temp) | |
591 | { | |
592 | cut_slot_from_list (temp, temp_slots_at_level (temp->level)); | |
593 | insert_slot_to_list (temp, &avail_temp_slots); | |
594 | temp->in_use = 0; | |
595 | temp->level = -1; | |
596 | } | |
6f086dfc RS |
597 | \f |
598 | /* Allocate a temporary stack slot and record it for possible later | |
599 | reuse. | |
600 | ||
601 | MODE is the machine mode to be given to the returned rtx. | |
602 | ||
603 | SIZE is the size in units of the space required. We do no rounding here | |
604 | since assign_stack_local will do any required rounding. | |
605 | ||
d93d4205 MS |
606 | KEEP is 1 if this slot is to be retained after a call to |
607 | free_temp_slots. Automatic variables for a block are allocated | |
e5e809f4 JL |
608 | with this flag. KEEP is 2 if we allocate a longer term temporary, |
609 | whose lifetime is controlled by CLEANUP_POINT_EXPRs. KEEP is 3 | |
610 | if we are to allocate something at an inner level to be treated as | |
718fe406 | 611 | a variable in the block (e.g., a SAVE_EXPR). |
a4c6502a MM |
612 | |
613 | TYPE is the type that will be used for the stack slot. */ | |
6f086dfc | 614 | |
a06ef755 | 615 | rtx |
fa8db1f7 AJ |
616 | assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size, int keep, |
617 | tree type) | |
6f086dfc | 618 | { |
74e2819c | 619 | unsigned int align; |
0aea6467 | 620 | struct temp_slot *p, *best_p = 0, *selected = NULL, **pp; |
faa964e5 | 621 | rtx slot; |
6f086dfc | 622 | |
303ec2aa RK |
623 | /* If SIZE is -1 it means that somebody tried to allocate a temporary |
624 | of a variable size. */ | |
625 | if (size == -1) | |
626 | abort (); | |
627 | ||
d16790f2 JW |
628 | if (mode == BLKmode) |
629 | align = BIGGEST_ALIGNMENT; | |
dbab7b72 JH |
630 | else |
631 | align = GET_MODE_ALIGNMENT (mode); | |
6f086dfc | 632 | |
d16790f2 | 633 | if (! type) |
ae2bcd98 | 634 | type = lang_hooks.types.type_for_mode (mode, 0); |
3bdf5ad1 | 635 | |
d16790f2 JW |
636 | if (type) |
637 | align = LOCAL_ALIGNMENT (type, align); | |
638 | ||
639 | /* Try to find an available, already-allocated temporary of the proper | |
640 | mode which meets the size and alignment requirements. Choose the | |
641 | smallest one with the closest alignment. */ | |
0aea6467 ZD |
642 | for (p = avail_temp_slots; p; p = p->next) |
643 | { | |
644 | if (p->align >= align && p->size >= size && GET_MODE (p->slot) == mode | |
645 | && objects_must_conflict_p (p->type, type) | |
646 | && (best_p == 0 || best_p->size > p->size | |
647 | || (best_p->size == p->size && best_p->align > p->align))) | |
648 | { | |
649 | if (p->align == align && p->size == size) | |
650 | { | |
651 | selected = p; | |
652 | cut_slot_from_list (selected, &avail_temp_slots); | |
653 | best_p = 0; | |
654 | break; | |
655 | } | |
656 | best_p = p; | |
657 | } | |
658 | } | |
6f086dfc RS |
659 | |
660 | /* Make our best, if any, the one to use. */ | |
661 | if (best_p) | |
a45035b6 | 662 | { |
0aea6467 ZD |
663 | selected = best_p; |
664 | cut_slot_from_list (selected, &avail_temp_slots); | |
665 | ||
a45035b6 JW |
666 | /* If there are enough aligned bytes left over, make them into a new |
667 | temp_slot so that the extra bytes don't get wasted. Do this only | |
668 | for BLKmode slots, so that we can be sure of the alignment. */ | |
3bdf5ad1 | 669 | if (GET_MODE (best_p->slot) == BLKmode) |
a45035b6 | 670 | { |
d16790f2 | 671 | int alignment = best_p->align / BITS_PER_UNIT; |
e5e809f4 | 672 | HOST_WIDE_INT rounded_size = CEIL_ROUND (size, alignment); |
a45035b6 JW |
673 | |
674 | if (best_p->size - rounded_size >= alignment) | |
675 | { | |
703ad42b | 676 | p = ggc_alloc (sizeof (struct temp_slot)); |
a25d4ba2 | 677 | p->in_use = p->addr_taken = 0; |
a45035b6 | 678 | p->size = best_p->size - rounded_size; |
307d8cd6 RK |
679 | p->base_offset = best_p->base_offset + rounded_size; |
680 | p->full_size = best_p->full_size - rounded_size; | |
38a448ca RH |
681 | p->slot = gen_rtx_MEM (BLKmode, |
682 | plus_constant (XEXP (best_p->slot, 0), | |
683 | rounded_size)); | |
d16790f2 | 684 | p->align = best_p->align; |
e5e76139 | 685 | p->address = 0; |
1da68f56 | 686 | p->type = best_p->type; |
0aea6467 | 687 | insert_slot_to_list (p, &avail_temp_slots); |
a45035b6 | 688 | |
38a448ca RH |
689 | stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, p->slot, |
690 | stack_slot_list); | |
a45035b6 JW |
691 | |
692 | best_p->size = rounded_size; | |
291dde90 | 693 | best_p->full_size = rounded_size; |
a45035b6 JW |
694 | } |
695 | } | |
a45035b6 | 696 | } |
718fe406 | 697 | |
6f086dfc | 698 | /* If we still didn't find one, make a new temporary. */ |
0aea6467 | 699 | if (selected == 0) |
6f086dfc | 700 | { |
e5e809f4 JL |
701 | HOST_WIDE_INT frame_offset_old = frame_offset; |
702 | ||
703ad42b | 703 | p = ggc_alloc (sizeof (struct temp_slot)); |
e5e809f4 | 704 | |
c87a0a39 JL |
705 | /* We are passing an explicit alignment request to assign_stack_local. |
706 | One side effect of that is assign_stack_local will not round SIZE | |
707 | to ensure the frame offset remains suitably aligned. | |
708 | ||
709 | So for requests which depended on the rounding of SIZE, we go ahead | |
710 | and round it now. We also make sure ALIGNMENT is at least | |
711 | BIGGEST_ALIGNMENT. */ | |
010529e5 | 712 | if (mode == BLKmode && align < BIGGEST_ALIGNMENT) |
c4f2c499 | 713 | abort (); |
6f67a30d | 714 | p->slot = assign_stack_local (mode, |
010529e5 | 715 | (mode == BLKmode |
fc555370 | 716 | ? CEIL_ROUND (size, (int) align / BITS_PER_UNIT) |
010529e5 | 717 | : size), |
6f67a30d | 718 | align); |
d16790f2 JW |
719 | |
720 | p->align = align; | |
e5e809f4 | 721 | |
b2a80c0d DE |
722 | /* The following slot size computation is necessary because we don't |
723 | know the actual size of the temporary slot until assign_stack_local | |
724 | has performed all the frame alignment and size rounding for the | |
fc91b0d0 RK |
725 | requested temporary. Note that extra space added for alignment |
726 | can be either above or below this stack slot depending on which | |
727 | way the frame grows. We include the extra space if and only if it | |
728 | is above this slot. */ | |
b2a80c0d DE |
729 | #ifdef FRAME_GROWS_DOWNWARD |
730 | p->size = frame_offset_old - frame_offset; | |
731 | #else | |
fc91b0d0 RK |
732 | p->size = size; |
733 | #endif | |
e5e809f4 | 734 | |
fc91b0d0 RK |
735 | /* Now define the fields used by combine_temp_slots. */ |
736 | #ifdef FRAME_GROWS_DOWNWARD | |
737 | p->base_offset = frame_offset; | |
738 | p->full_size = frame_offset_old - frame_offset; | |
739 | #else | |
740 | p->base_offset = frame_offset_old; | |
741 | p->full_size = frame_offset - frame_offset_old; | |
b2a80c0d | 742 | #endif |
e5e76139 | 743 | p->address = 0; |
0aea6467 ZD |
744 | |
745 | selected = p; | |
6f086dfc RS |
746 | } |
747 | ||
0aea6467 | 748 | p = selected; |
6f086dfc | 749 | p->in_use = 1; |
a25d4ba2 | 750 | p->addr_taken = 0; |
1da68f56 | 751 | p->type = type; |
a25d4ba2 | 752 | |
d93d4205 MS |
753 | if (keep == 2) |
754 | { | |
755 | p->level = target_temp_slot_level; | |
e2655d15 | 756 | p->keep = 1; |
d93d4205 | 757 | } |
e5e809f4 JL |
758 | else if (keep == 3) |
759 | { | |
760 | p->level = var_temp_slot_level; | |
761 | p->keep = 0; | |
762 | } | |
d93d4205 MS |
763 | else |
764 | { | |
765 | p->level = temp_slot_level; | |
766 | p->keep = keep; | |
767 | } | |
1995f267 | 768 | |
0aea6467 ZD |
769 | pp = temp_slots_at_level (p->level); |
770 | insert_slot_to_list (p, pp); | |
faa964e5 UW |
771 | |
772 | /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */ | |
773 | slot = gen_rtx_MEM (mode, XEXP (p->slot, 0)); | |
774 | stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, slot, stack_slot_list); | |
3bdf5ad1 | 775 | |
1da68f56 RK |
776 | /* If we know the alias set for the memory that will be used, use |
777 | it. If there's no TYPE, then we don't know anything about the | |
778 | alias set for the memory. */ | |
faa964e5 UW |
779 | set_mem_alias_set (slot, type ? get_alias_set (type) : 0); |
780 | set_mem_align (slot, align); | |
1da68f56 | 781 | |
30f7a378 | 782 | /* If a type is specified, set the relevant flags. */ |
3bdf5ad1 | 783 | if (type != 0) |
1da68f56 | 784 | { |
fa8db1f7 | 785 | RTX_UNCHANGING_P (slot) = (lang_hooks.honor_readonly |
a3b88570 | 786 | && TYPE_READONLY (type)); |
faa964e5 UW |
787 | MEM_VOLATILE_P (slot) = TYPE_VOLATILE (type); |
788 | MEM_SET_IN_STRUCT_P (slot, AGGREGATE_TYPE_P (type)); | |
1da68f56 | 789 | } |
3bdf5ad1 | 790 | |
faa964e5 | 791 | return slot; |
6f086dfc | 792 | } |
d16790f2 JW |
793 | |
794 | /* Allocate a temporary stack slot and record it for possible later | |
795 | reuse. First three arguments are same as in preceding function. */ | |
796 | ||
797 | rtx | |
fa8db1f7 | 798 | assign_stack_temp (enum machine_mode mode, HOST_WIDE_INT size, int keep) |
d16790f2 JW |
799 | { |
800 | return assign_stack_temp_for_type (mode, size, keep, NULL_TREE); | |
801 | } | |
638141a6 | 802 | \f |
9432c136 EB |
803 | /* Assign a temporary. |
804 | If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl | |
805 | and so that should be used in error messages. In either case, we | |
806 | allocate of the given type. | |
230f21b4 PB |
807 | KEEP is as for assign_stack_temp. |
808 | MEMORY_REQUIRED is 1 if the result must be addressable stack memory; | |
b55d9ff8 RK |
809 | it is 0 if a register is OK. |
810 | DONT_PROMOTE is 1 if we should not promote values in register | |
811 | to wider modes. */ | |
230f21b4 PB |
812 | |
813 | rtx | |
fa8db1f7 AJ |
814 | assign_temp (tree type_or_decl, int keep, int memory_required, |
815 | int dont_promote ATTRIBUTE_UNUSED) | |
230f21b4 | 816 | { |
9432c136 EB |
817 | tree type, decl; |
818 | enum machine_mode mode; | |
9e1622ed | 819 | #ifdef PROMOTE_MODE |
9432c136 EB |
820 | int unsignedp; |
821 | #endif | |
822 | ||
823 | if (DECL_P (type_or_decl)) | |
824 | decl = type_or_decl, type = TREE_TYPE (decl); | |
825 | else | |
826 | decl = NULL, type = type_or_decl; | |
827 | ||
828 | mode = TYPE_MODE (type); | |
9e1622ed | 829 | #ifdef PROMOTE_MODE |
8df83eae | 830 | unsignedp = TYPE_UNSIGNED (type); |
0ce8a59c | 831 | #endif |
638141a6 | 832 | |
230f21b4 PB |
833 | if (mode == BLKmode || memory_required) |
834 | { | |
e5e809f4 | 835 | HOST_WIDE_INT size = int_size_in_bytes (type); |
e30bb772 | 836 | tree size_tree; |
230f21b4 PB |
837 | rtx tmp; |
838 | ||
44affdae JH |
839 | /* Zero sized arrays are GNU C extension. Set size to 1 to avoid |
840 | problems with allocating the stack space. */ | |
841 | if (size == 0) | |
842 | size = 1; | |
843 | ||
230f21b4 PB |
844 | /* Unfortunately, we don't yet know how to allocate variable-sized |
845 | temporaries. However, sometimes we have a fixed upper limit on | |
846 | the size (which is stored in TYPE_ARRAY_MAX_SIZE) and can use that | |
0f41302f | 847 | instead. This is the case for Chill variable-sized strings. */ |
230f21b4 PB |
848 | if (size == -1 && TREE_CODE (type) == ARRAY_TYPE |
849 | && TYPE_ARRAY_MAX_SIZE (type) != NULL_TREE | |
3bdf5ad1 RK |
850 | && host_integerp (TYPE_ARRAY_MAX_SIZE (type), 1)) |
851 | size = tree_low_cst (TYPE_ARRAY_MAX_SIZE (type), 1); | |
230f21b4 | 852 | |
e30bb772 RK |
853 | /* If we still haven't been able to get a size, see if the language |
854 | can compute a maximum size. */ | |
855 | if (size == -1 | |
856 | && (size_tree = lang_hooks.type_max_size (type)) != 0 | |
857 | && host_integerp (size_tree, 1)) | |
858 | size = tree_low_cst (size_tree, 1); | |
859 | ||
9432c136 EB |
860 | /* The size of the temporary may be too large to fit into an integer. */ |
861 | /* ??? Not sure this should happen except for user silliness, so limit | |
797a6ac1 | 862 | this to things that aren't compiler-generated temporaries. The |
9432c136 EB |
863 | rest of the time we'll abort in assign_stack_temp_for_type. */ |
864 | if (decl && size == -1 | |
865 | && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST) | |
866 | { | |
ddd2d57e | 867 | error ("%Jsize of variable '%D' is too large", decl, decl); |
9432c136 EB |
868 | size = 1; |
869 | } | |
870 | ||
d16790f2 | 871 | tmp = assign_stack_temp_for_type (mode, size, keep, type); |
230f21b4 PB |
872 | return tmp; |
873 | } | |
638141a6 | 874 | |
9e1622ed | 875 | #ifdef PROMOTE_MODE |
b55d9ff8 RK |
876 | if (! dont_promote) |
877 | mode = promote_mode (type, mode, &unsignedp, 0); | |
230f21b4 | 878 | #endif |
638141a6 | 879 | |
230f21b4 PB |
880 | return gen_reg_rtx (mode); |
881 | } | |
638141a6 | 882 | \f |
a45035b6 JW |
883 | /* Combine temporary stack slots which are adjacent on the stack. |
884 | ||
885 | This allows for better use of already allocated stack space. This is only | |
886 | done for BLKmode slots because we can be sure that we won't have alignment | |
887 | problems in this case. */ | |
888 | ||
889 | void | |
fa8db1f7 | 890 | combine_temp_slots (void) |
a45035b6 | 891 | { |
0aea6467 | 892 | struct temp_slot *p, *q, *next, *next_q; |
e5e809f4 JL |
893 | int num_slots; |
894 | ||
a4c6502a MM |
895 | /* We can't combine slots, because the information about which slot |
896 | is in which alias set will be lost. */ | |
897 | if (flag_strict_aliasing) | |
898 | return; | |
899 | ||
718fe406 | 900 | /* If there are a lot of temp slots, don't do anything unless |
d6a7951f | 901 | high levels of optimization. */ |
e5e809f4 | 902 | if (! flag_expensive_optimizations) |
0aea6467 | 903 | for (p = avail_temp_slots, num_slots = 0; p; p = p->next, num_slots++) |
e5e809f4 JL |
904 | if (num_slots > 100 || (num_slots > 10 && optimize == 0)) |
905 | return; | |
a45035b6 | 906 | |
0aea6467 | 907 | for (p = avail_temp_slots; p; p = next) |
e9b7093a RS |
908 | { |
909 | int delete_p = 0; | |
e5e809f4 | 910 | |
0aea6467 ZD |
911 | next = p->next; |
912 | ||
913 | if (GET_MODE (p->slot) != BLKmode) | |
914 | continue; | |
915 | ||
916 | for (q = p->next; q; q = next_q) | |
e9b7093a | 917 | { |
0aea6467 ZD |
918 | int delete_q = 0; |
919 | ||
920 | next_q = q->next; | |
921 | ||
922 | if (GET_MODE (q->slot) != BLKmode) | |
923 | continue; | |
924 | ||
925 | if (p->base_offset + p->full_size == q->base_offset) | |
926 | { | |
927 | /* Q comes after P; combine Q into P. */ | |
928 | p->size += q->size; | |
929 | p->full_size += q->full_size; | |
930 | delete_q = 1; | |
931 | } | |
932 | else if (q->base_offset + q->full_size == p->base_offset) | |
933 | { | |
934 | /* P comes after Q; combine P into Q. */ | |
935 | q->size += p->size; | |
936 | q->full_size += p->full_size; | |
937 | delete_p = 1; | |
938 | break; | |
939 | } | |
940 | if (delete_q) | |
941 | cut_slot_from_list (q, &avail_temp_slots); | |
e9b7093a | 942 | } |
0aea6467 ZD |
943 | |
944 | /* Either delete P or advance past it. */ | |
945 | if (delete_p) | |
946 | cut_slot_from_list (p, &avail_temp_slots); | |
e9b7093a | 947 | } |
a45035b6 | 948 | } |
6f086dfc | 949 | \f |
e5e76139 RK |
950 | /* Find the temp slot corresponding to the object at address X. */ |
951 | ||
952 | static struct temp_slot * | |
fa8db1f7 | 953 | find_temp_slot_from_address (rtx x) |
e5e76139 RK |
954 | { |
955 | struct temp_slot *p; | |
956 | rtx next; | |
0aea6467 | 957 | int i; |
e5e76139 | 958 | |
0aea6467 ZD |
959 | for (i = max_slot_level (); i >= 0; i--) |
960 | for (p = *temp_slots_at_level (i); p; p = p->next) | |
961 | { | |
962 | if (XEXP (p->slot, 0) == x | |
963 | || p->address == x | |
964 | || (GET_CODE (x) == PLUS | |
965 | && XEXP (x, 0) == virtual_stack_vars_rtx | |
966 | && GET_CODE (XEXP (x, 1)) == CONST_INT | |
967 | && INTVAL (XEXP (x, 1)) >= p->base_offset | |
968 | && INTVAL (XEXP (x, 1)) < p->base_offset + p->full_size)) | |
969 | return p; | |
970 | ||
971 | else if (p->address != 0 && GET_CODE (p->address) == EXPR_LIST) | |
972 | for (next = p->address; next; next = XEXP (next, 1)) | |
973 | if (XEXP (next, 0) == x) | |
974 | return p; | |
975 | } | |
e5e76139 | 976 | |
14a774a9 RK |
977 | /* If we have a sum involving a register, see if it points to a temp |
978 | slot. */ | |
f8cfc6aa | 979 | if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 0)) |
14a774a9 RK |
980 | && (p = find_temp_slot_from_address (XEXP (x, 0))) != 0) |
981 | return p; | |
f8cfc6aa | 982 | else if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 1)) |
14a774a9 RK |
983 | && (p = find_temp_slot_from_address (XEXP (x, 1))) != 0) |
984 | return p; | |
985 | ||
e5e76139 RK |
986 | return 0; |
987 | } | |
718fe406 | 988 | |
9faa82d8 | 989 | /* Indicate that NEW is an alternate way of referring to the temp slot |
e5e809f4 | 990 | that previously was known by OLD. */ |
e5e76139 RK |
991 | |
992 | void | |
fa8db1f7 | 993 | update_temp_slot_address (rtx old, rtx new) |
e5e76139 | 994 | { |
14a774a9 | 995 | struct temp_slot *p; |
e5e76139 | 996 | |
14a774a9 | 997 | if (rtx_equal_p (old, new)) |
e5e76139 | 998 | return; |
14a774a9 RK |
999 | |
1000 | p = find_temp_slot_from_address (old); | |
1001 | ||
700f19f0 RK |
1002 | /* If we didn't find one, see if both OLD is a PLUS. If so, and NEW |
1003 | is a register, see if one operand of the PLUS is a temporary | |
1004 | location. If so, NEW points into it. Otherwise, if both OLD and | |
1005 | NEW are a PLUS and if there is a register in common between them. | |
1006 | If so, try a recursive call on those values. */ | |
14a774a9 RK |
1007 | if (p == 0) |
1008 | { | |
700f19f0 RK |
1009 | if (GET_CODE (old) != PLUS) |
1010 | return; | |
1011 | ||
f8cfc6aa | 1012 | if (REG_P (new)) |
700f19f0 RK |
1013 | { |
1014 | update_temp_slot_address (XEXP (old, 0), new); | |
1015 | update_temp_slot_address (XEXP (old, 1), new); | |
1016 | return; | |
1017 | } | |
1018 | else if (GET_CODE (new) != PLUS) | |
14a774a9 RK |
1019 | return; |
1020 | ||
1021 | if (rtx_equal_p (XEXP (old, 0), XEXP (new, 0))) | |
1022 | update_temp_slot_address (XEXP (old, 1), XEXP (new, 1)); | |
1023 | else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 0))) | |
1024 | update_temp_slot_address (XEXP (old, 0), XEXP (new, 1)); | |
1025 | else if (rtx_equal_p (XEXP (old, 0), XEXP (new, 1))) | |
1026 | update_temp_slot_address (XEXP (old, 1), XEXP (new, 0)); | |
1027 | else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 1))) | |
1028 | update_temp_slot_address (XEXP (old, 0), XEXP (new, 0)); | |
1029 | ||
1030 | return; | |
1031 | } | |
1032 | ||
718fe406 | 1033 | /* Otherwise add an alias for the temp's address. */ |
e5e76139 RK |
1034 | else if (p->address == 0) |
1035 | p->address = new; | |
1036 | else | |
1037 | { | |
1038 | if (GET_CODE (p->address) != EXPR_LIST) | |
38a448ca | 1039 | p->address = gen_rtx_EXPR_LIST (VOIDmode, p->address, NULL_RTX); |
e5e76139 | 1040 | |
38a448ca | 1041 | p->address = gen_rtx_EXPR_LIST (VOIDmode, new, p->address); |
e5e76139 RK |
1042 | } |
1043 | } | |
1044 | ||
a25d4ba2 | 1045 | /* If X could be a reference to a temporary slot, mark the fact that its |
9faa82d8 | 1046 | address was taken. */ |
a25d4ba2 RK |
1047 | |
1048 | void | |
fa8db1f7 | 1049 | mark_temp_addr_taken (rtx x) |
a25d4ba2 RK |
1050 | { |
1051 | struct temp_slot *p; | |
1052 | ||
1053 | if (x == 0) | |
1054 | return; | |
1055 | ||
1056 | /* If X is not in memory or is at a constant address, it cannot be in | |
1057 | a temporary slot. */ | |
3c0cb5de | 1058 | if (!MEM_P (x) || CONSTANT_P (XEXP (x, 0))) |
a25d4ba2 RK |
1059 | return; |
1060 | ||
1061 | p = find_temp_slot_from_address (XEXP (x, 0)); | |
1062 | if (p != 0) | |
1063 | p->addr_taken = 1; | |
1064 | } | |
1065 | ||
9cca6a99 MS |
1066 | /* If X could be a reference to a temporary slot, mark that slot as |
1067 | belonging to the to one level higher than the current level. If X | |
1068 | matched one of our slots, just mark that one. Otherwise, we can't | |
1069 | easily predict which it is, so upgrade all of them. Kept slots | |
1070 | need not be touched. | |
6f086dfc RS |
1071 | |
1072 | This is called when an ({...}) construct occurs and a statement | |
1073 | returns a value in memory. */ | |
1074 | ||
1075 | void | |
fa8db1f7 | 1076 | preserve_temp_slots (rtx x) |
6f086dfc | 1077 | { |
0aea6467 | 1078 | struct temp_slot *p = 0, *next; |
6f086dfc | 1079 | |
73620b82 RK |
1080 | /* If there is no result, we still might have some objects whose address |
1081 | were taken, so we need to make sure they stay around. */ | |
e3a77161 | 1082 | if (x == 0) |
73620b82 | 1083 | { |
0aea6467 ZD |
1084 | for (p = *temp_slots_at_level (temp_slot_level); p; p = next) |
1085 | { | |
1086 | next = p->next; | |
1087 | ||
1088 | if (p->addr_taken) | |
1089 | move_slot_to_level (p, temp_slot_level - 1); | |
1090 | } | |
73620b82 | 1091 | |
8fff4fc1 RH |
1092 | return; |
1093 | } | |
f7b6d104 | 1094 | |
8fff4fc1 RH |
1095 | /* If X is a register that is being used as a pointer, see if we have |
1096 | a temporary slot we know it points to. To be consistent with | |
1097 | the code below, we really should preserve all non-kept slots | |
1098 | if we can't find a match, but that seems to be much too costly. */ | |
1099 | if (REG_P (x) && REG_POINTER (x)) | |
1100 | p = find_temp_slot_from_address (x); | |
f7b6d104 | 1101 | |
8fff4fc1 RH |
1102 | /* If X is not in memory or is at a constant address, it cannot be in |
1103 | a temporary slot, but it can contain something whose address was | |
1104 | taken. */ | |
1105 | if (p == 0 && (!MEM_P (x) || CONSTANT_P (XEXP (x, 0)))) | |
1106 | { | |
1107 | for (p = *temp_slots_at_level (temp_slot_level); p; p = next) | |
1108 | { | |
1109 | next = p->next; | |
b5bd3b3c | 1110 | |
8fff4fc1 RH |
1111 | if (p->addr_taken) |
1112 | move_slot_to_level (p, temp_slot_level - 1); | |
e9a25f70 | 1113 | } |
c5c76735 | 1114 | |
8fff4fc1 RH |
1115 | return; |
1116 | } | |
1117 | ||
1118 | /* First see if we can find a match. */ | |
1119 | if (p == 0) | |
1120 | p = find_temp_slot_from_address (XEXP (x, 0)); | |
1121 | ||
1122 | if (p != 0) | |
1123 | { | |
1124 | /* Move everything at our level whose address was taken to our new | |
1125 | level in case we used its address. */ | |
1126 | struct temp_slot *q; | |
1127 | ||
1128 | if (p->level == temp_slot_level) | |
fbdfe39c | 1129 | { |
8fff4fc1 | 1130 | for (q = *temp_slots_at_level (temp_slot_level); q; q = next) |
8b04083b | 1131 | { |
8fff4fc1 | 1132 | next = q->next; |
8b04083b | 1133 | |
8fff4fc1 RH |
1134 | if (p != q && q->addr_taken) |
1135 | move_slot_to_level (q, temp_slot_level - 1); | |
8b04083b | 1136 | } |
8fff4fc1 RH |
1137 | |
1138 | move_slot_to_level (p, temp_slot_level - 1); | |
1139 | p->addr_taken = 0; | |
fbdfe39c | 1140 | } |
8fff4fc1 | 1141 | return; |
f7b6d104 | 1142 | } |
e9a25f70 | 1143 | |
8fff4fc1 RH |
1144 | /* Otherwise, preserve all non-kept slots at this level. */ |
1145 | for (p = *temp_slots_at_level (temp_slot_level); p; p = next) | |
e9a25f70 | 1146 | { |
8fff4fc1 | 1147 | next = p->next; |
fe9b4957 | 1148 | |
8fff4fc1 RH |
1149 | if (!p->keep) |
1150 | move_slot_to_level (p, temp_slot_level - 1); | |
1151 | } | |
fe9b4957 MM |
1152 | } |
1153 | ||
8fff4fc1 RH |
1154 | /* Free all temporaries used so far. This is normally called at the |
1155 | end of generating code for a statement. */ | |
fe9b4957 | 1156 | |
8fff4fc1 RH |
1157 | void |
1158 | free_temp_slots (void) | |
fe9b4957 | 1159 | { |
8fff4fc1 | 1160 | struct temp_slot *p, *next; |
fe9b4957 | 1161 | |
8fff4fc1 RH |
1162 | for (p = *temp_slots_at_level (temp_slot_level); p; p = next) |
1163 | { | |
1164 | next = p->next; | |
fe9b4957 | 1165 | |
8fff4fc1 RH |
1166 | if (!p->keep) |
1167 | make_slot_available (p); | |
1168 | } | |
fe9b4957 | 1169 | |
8fff4fc1 RH |
1170 | combine_temp_slots (); |
1171 | } | |
fe9b4957 | 1172 | |
8fff4fc1 | 1173 | /* Push deeper into the nesting level for stack temporaries. */ |
fe9b4957 | 1174 | |
8fff4fc1 RH |
1175 | void |
1176 | push_temp_slots (void) | |
fe9b4957 | 1177 | { |
8fff4fc1 | 1178 | temp_slot_level++; |
fe9b4957 MM |
1179 | } |
1180 | ||
8fff4fc1 RH |
1181 | /* Pop a temporary nesting level. All slots in use in the current level |
1182 | are freed. */ | |
fe9b4957 | 1183 | |
8fff4fc1 RH |
1184 | void |
1185 | pop_temp_slots (void) | |
fe9b4957 | 1186 | { |
8fff4fc1 | 1187 | struct temp_slot *p, *next; |
fe9b4957 | 1188 | |
8fff4fc1 RH |
1189 | for (p = *temp_slots_at_level (temp_slot_level); p; p = next) |
1190 | { | |
1191 | next = p->next; | |
1192 | make_slot_available (p); | |
1193 | } | |
e9a25f70 | 1194 | |
8fff4fc1 | 1195 | combine_temp_slots (); |
b987f237 | 1196 | |
8fff4fc1 | 1197 | temp_slot_level--; |
8c36698e NC |
1198 | } |
1199 | ||
8fff4fc1 | 1200 | /* Initialize temporary slots. */ |
e9a25f70 JL |
1201 | |
1202 | void | |
8fff4fc1 | 1203 | init_temp_slots (void) |
e9a25f70 | 1204 | { |
8fff4fc1 RH |
1205 | /* We have not allocated any temporaries yet. */ |
1206 | avail_temp_slots = 0; | |
1207 | used_temp_slots = 0; | |
1208 | temp_slot_level = 0; | |
1209 | var_temp_slot_level = 0; | |
1210 | target_temp_slot_level = 0; | |
1211 | } | |
1212 | \f | |
1213 | /* These routines are responsible for converting virtual register references | |
1214 | to the actual hard register references once RTL generation is complete. | |
718fe406 | 1215 | |
8fff4fc1 RH |
1216 | The following four variables are used for communication between the |
1217 | routines. They contain the offsets of the virtual registers from their | |
1218 | respective hard registers. */ | |
fe9b4957 | 1219 | |
8fff4fc1 RH |
1220 | static int in_arg_offset; |
1221 | static int var_offset; | |
1222 | static int dynamic_offset; | |
1223 | static int out_arg_offset; | |
1224 | static int cfa_offset; | |
8a5275eb | 1225 | |
8fff4fc1 RH |
1226 | /* In most machines, the stack pointer register is equivalent to the bottom |
1227 | of the stack. */ | |
718fe406 | 1228 | |
8fff4fc1 RH |
1229 | #ifndef STACK_POINTER_OFFSET |
1230 | #define STACK_POINTER_OFFSET 0 | |
1231 | #endif | |
8c36698e | 1232 | |
8fff4fc1 RH |
1233 | /* If not defined, pick an appropriate default for the offset of dynamically |
1234 | allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS, | |
1235 | REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */ | |
fe9b4957 | 1236 | |
8fff4fc1 | 1237 | #ifndef STACK_DYNAMIC_OFFSET |
8a5275eb | 1238 | |
8fff4fc1 RH |
1239 | /* The bottom of the stack points to the actual arguments. If |
1240 | REG_PARM_STACK_SPACE is defined, this includes the space for the register | |
1241 | parameters. However, if OUTGOING_REG_PARM_STACK space is not defined, | |
1242 | stack space for register parameters is not pushed by the caller, but | |
1243 | rather part of the fixed stack areas and hence not included in | |
1244 | `current_function_outgoing_args_size'. Nevertheless, we must allow | |
1245 | for it when allocating stack dynamic objects. */ | |
8a5275eb | 1246 | |
8fff4fc1 RH |
1247 | #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE) |
1248 | #define STACK_DYNAMIC_OFFSET(FNDECL) \ | |
1249 | ((ACCUMULATE_OUTGOING_ARGS \ | |
1250 | ? (current_function_outgoing_args_size + REG_PARM_STACK_SPACE (FNDECL)) : 0)\ | |
1251 | + (STACK_POINTER_OFFSET)) \ | |
4fa48eae | 1252 | |
8fff4fc1 RH |
1253 | #else |
1254 | #define STACK_DYNAMIC_OFFSET(FNDECL) \ | |
1255 | ((ACCUMULATE_OUTGOING_ARGS ? current_function_outgoing_args_size : 0) \ | |
1256 | + (STACK_POINTER_OFFSET)) | |
1257 | #endif | |
1258 | #endif | |
4fa48eae | 1259 | |
8fff4fc1 | 1260 | /* On most machines, the CFA coincides with the first incoming parm. */ |
4fa48eae | 1261 | |
8fff4fc1 RH |
1262 | #ifndef ARG_POINTER_CFA_OFFSET |
1263 | #define ARG_POINTER_CFA_OFFSET(FNDECL) FIRST_PARM_OFFSET (FNDECL) | |
1264 | #endif | |
4fa48eae | 1265 | |
e9a25f70 | 1266 | \f |
d6a7951f | 1267 | /* Convert a SET of a hard subreg to a set of the appropriate hard |
659e47fb AH |
1268 | register. A subroutine of purge_hard_subreg_sets. */ |
1269 | ||
1270 | static void | |
fa8db1f7 | 1271 | purge_single_hard_subreg_set (rtx pattern) |
659e47fb AH |
1272 | { |
1273 | rtx reg = SET_DEST (pattern); | |
1274 | enum machine_mode mode = GET_MODE (SET_DEST (pattern)); | |
ddef6bc7 JJ |
1275 | int offset = 0; |
1276 | ||
f8cfc6aa | 1277 | if (GET_CODE (reg) == SUBREG && REG_P (SUBREG_REG (reg)) |
ddef6bc7 | 1278 | && REGNO (SUBREG_REG (reg)) < FIRST_PSEUDO_REGISTER) |
659e47fb | 1279 | { |
ddef6bc7 JJ |
1280 | offset = subreg_regno_offset (REGNO (SUBREG_REG (reg)), |
1281 | GET_MODE (SUBREG_REG (reg)), | |
1282 | SUBREG_BYTE (reg), | |
1283 | GET_MODE (reg)); | |
659e47fb AH |
1284 | reg = SUBREG_REG (reg); |
1285 | } | |
ddef6bc7 | 1286 | |
797a6ac1 | 1287 | |
f8cfc6aa | 1288 | if (REG_P (reg) && REGNO (reg) < FIRST_PSEUDO_REGISTER) |
659e47fb | 1289 | { |
ddef6bc7 | 1290 | reg = gen_rtx_REG (mode, REGNO (reg) + offset); |
659e47fb AH |
1291 | SET_DEST (pattern) = reg; |
1292 | } | |
1293 | } | |
1294 | ||
1295 | /* Eliminate all occurrences of SETs of hard subregs from INSNS. The | |
1296 | only such SETs that we expect to see are those left in because | |
1297 | integrate can't handle sets of parts of a return value register. | |
1298 | ||
1299 | We don't use alter_subreg because we only want to eliminate subregs | |
1300 | of hard registers. */ | |
1301 | ||
1302 | void | |
fa8db1f7 | 1303 | purge_hard_subreg_sets (rtx insn) |
659e47fb AH |
1304 | { |
1305 | for (; insn; insn = NEXT_INSN (insn)) | |
1306 | { | |
1307 | if (INSN_P (insn)) | |
1308 | { | |
1309 | rtx pattern = PATTERN (insn); | |
1310 | switch (GET_CODE (pattern)) | |
1311 | { | |
1312 | case SET: | |
1313 | if (GET_CODE (SET_DEST (pattern)) == SUBREG) | |
1314 | purge_single_hard_subreg_set (pattern); | |
797a6ac1 | 1315 | break; |
659e47fb AH |
1316 | case PARALLEL: |
1317 | { | |
1318 | int j; | |
1319 | for (j = XVECLEN (pattern, 0) - 1; j >= 0; j--) | |
1320 | { | |
1321 | rtx inner_pattern = XVECEXP (pattern, 0, j); | |
1322 | if (GET_CODE (inner_pattern) == SET | |
1323 | && GET_CODE (SET_DEST (inner_pattern)) == SUBREG) | |
1324 | purge_single_hard_subreg_set (inner_pattern); | |
1325 | } | |
1326 | } | |
1327 | break; | |
1328 | default: | |
1329 | break; | |
1330 | } | |
1331 | } | |
1332 | } | |
1333 | } | |
1334 | \f | |
6f086dfc RS |
1335 | /* Pass through the INSNS of function FNDECL and convert virtual register |
1336 | references to hard register references. */ | |
1337 | ||
1338 | void | |
fd743bc1 | 1339 | instantiate_virtual_regs (void) |
6f086dfc RS |
1340 | { |
1341 | rtx insn; | |
1342 | ||
1343 | /* Compute the offsets to use for this function. */ | |
fd743bc1 | 1344 | in_arg_offset = FIRST_PARM_OFFSET (current_function_decl); |
6f086dfc | 1345 | var_offset = STARTING_FRAME_OFFSET; |
fd743bc1 | 1346 | dynamic_offset = STACK_DYNAMIC_OFFSET (current_function_decl); |
6f086dfc | 1347 | out_arg_offset = STACK_POINTER_OFFSET; |
fd743bc1 | 1348 | cfa_offset = ARG_POINTER_CFA_OFFSET (current_function_decl); |
6f086dfc RS |
1349 | |
1350 | /* Scan all variables and parameters of this function. For each that is | |
1351 | in memory, instantiate all virtual registers if the result is a valid | |
1352 | address. If not, we do it later. That will handle most uses of virtual | |
1353 | regs on many machines. */ | |
fd743bc1 | 1354 | instantiate_decls (current_function_decl, 1); |
6f086dfc RS |
1355 | |
1356 | /* Initialize recognition, indicating that volatile is OK. */ | |
1357 | init_recog (); | |
1358 | ||
1359 | /* Scan through all the insns, instantiating every virtual register still | |
1360 | present. */ | |
fd743bc1 | 1361 | for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) |
6f086dfc RS |
1362 | if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN |
1363 | || GET_CODE (insn) == CALL_INSN) | |
1364 | { | |
1365 | instantiate_virtual_regs_1 (&PATTERN (insn), insn, 1); | |
5dc96d60 JH |
1366 | if (INSN_DELETED_P (insn)) |
1367 | continue; | |
5f4f0e22 | 1368 | instantiate_virtual_regs_1 (®_NOTES (insn), NULL_RTX, 0); |
87c61e2d JL |
1369 | /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */ |
1370 | if (GET_CODE (insn) == CALL_INSN) | |
1371 | instantiate_virtual_regs_1 (&CALL_INSN_FUNCTION_USAGE (insn), | |
1372 | NULL_RTX, 0); | |
f90e4dea JH |
1373 | |
1374 | /* Past this point all ASM statements should match. Verify that | |
1375 | to avoid failures later in the compilation process. */ | |
1376 | if (asm_noperands (PATTERN (insn)) >= 0 | |
1377 | && ! check_asm_operands (PATTERN (insn))) | |
1378 | instantiate_virtual_regs_lossage (insn); | |
6f086dfc RS |
1379 | } |
1380 | ||
1381 | /* Now instantiate the remaining register equivalences for debugging info. | |
1382 | These will not be valid addresses. */ | |
fd743bc1 | 1383 | instantiate_decls (current_function_decl, 0); |
6f086dfc RS |
1384 | |
1385 | /* Indicate that, from now on, assign_stack_local should use | |
1386 | frame_pointer_rtx. */ | |
1387 | virtuals_instantiated = 1; | |
1388 | } | |
1389 | ||
1390 | /* Scan all decls in FNDECL (both variables and parameters) and instantiate | |
1391 | all virtual registers in their DECL_RTL's. | |
1392 | ||
1393 | If VALID_ONLY, do this only if the resulting address is still valid. | |
1394 | Otherwise, always do it. */ | |
1395 | ||
1396 | static void | |
fa8db1f7 | 1397 | instantiate_decls (tree fndecl, int valid_only) |
6f086dfc RS |
1398 | { |
1399 | tree decl; | |
1400 | ||
6f086dfc RS |
1401 | /* Process all parameters of the function. */ |
1402 | for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl)) | |
1403 | { | |
e5e809f4 | 1404 | HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (decl)); |
ae0ed63a | 1405 | HOST_WIDE_INT size_rtl; |
e5e809f4 | 1406 | |
718fe406 | 1407 | instantiate_decl (DECL_RTL (decl), size, valid_only); |
ce717ce4 JW |
1408 | |
1409 | /* If the parameter was promoted, then the incoming RTL mode may be | |
1410 | larger than the declared type size. We must use the larger of | |
1411 | the two sizes. */ | |
ae0ed63a JM |
1412 | size_rtl = GET_MODE_SIZE (GET_MODE (DECL_INCOMING_RTL (decl))); |
1413 | size = MAX (size_rtl, size); | |
ce717ce4 | 1414 | instantiate_decl (DECL_INCOMING_RTL (decl), size, valid_only); |
6f086dfc RS |
1415 | } |
1416 | ||
0f41302f | 1417 | /* Now process all variables defined in the function or its subblocks. */ |
6f086dfc | 1418 | instantiate_decls_1 (DECL_INITIAL (fndecl), valid_only); |
6f086dfc RS |
1419 | } |
1420 | ||
1421 | /* Subroutine of instantiate_decls: Process all decls in the given | |
1422 | BLOCK node and all its subblocks. */ | |
1423 | ||
1424 | static void | |
fa8db1f7 | 1425 | instantiate_decls_1 (tree let, int valid_only) |
6f086dfc RS |
1426 | { |
1427 | tree t; | |
1428 | ||
1429 | for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t)) | |
19e7881c | 1430 | if (DECL_RTL_SET_P (t)) |
797a6ac1 | 1431 | instantiate_decl (DECL_RTL (t), |
19e7881c MM |
1432 | int_size_in_bytes (TREE_TYPE (t)), |
1433 | valid_only); | |
6f086dfc RS |
1434 | |
1435 | /* Process all subblocks. */ | |
1436 | for (t = BLOCK_SUBBLOCKS (let); t; t = TREE_CHAIN (t)) | |
1437 | instantiate_decls_1 (t, valid_only); | |
1438 | } | |
5a73491b | 1439 | |
8008b228 | 1440 | /* Subroutine of the preceding procedures: Given RTL representing a |
5a73491b RK |
1441 | decl and the size of the object, do any instantiation required. |
1442 | ||
cc2902df | 1443 | If VALID_ONLY is nonzero, it means that the RTL should only be |
5a73491b RK |
1444 | changed if the new address is valid. */ |
1445 | ||
1446 | static void | |
fa8db1f7 | 1447 | instantiate_decl (rtx x, HOST_WIDE_INT size, int valid_only) |
5a73491b RK |
1448 | { |
1449 | enum machine_mode mode; | |
1450 | rtx addr; | |
1451 | ||
1452 | /* If this is not a MEM, no need to do anything. Similarly if the | |
1453 | address is a constant or a register that is not a virtual register. */ | |
1454 | ||
3c0cb5de | 1455 | if (x == 0 || !MEM_P (x)) |
5a73491b RK |
1456 | return; |
1457 | ||
1458 | addr = XEXP (x, 0); | |
1459 | if (CONSTANT_P (addr) | |
f8cfc6aa | 1460 | || (REG_P (addr) |
5a73491b RK |
1461 | && (REGNO (addr) < FIRST_VIRTUAL_REGISTER |
1462 | || REGNO (addr) > LAST_VIRTUAL_REGISTER))) | |
1463 | return; | |
1464 | ||
1465 | /* If we should only do this if the address is valid, copy the address. | |
1466 | We need to do this so we can undo any changes that might make the | |
1467 | address invalid. This copy is unfortunate, but probably can't be | |
1468 | avoided. */ | |
1469 | ||
1470 | if (valid_only) | |
1471 | addr = copy_rtx (addr); | |
1472 | ||
1473 | instantiate_virtual_regs_1 (&addr, NULL_RTX, 0); | |
1474 | ||
770ae6cc | 1475 | if (valid_only && size >= 0) |
87ce34d6 | 1476 | { |
770ae6cc RK |
1477 | unsigned HOST_WIDE_INT decl_size = size; |
1478 | ||
87ce34d6 JW |
1479 | /* Now verify that the resulting address is valid for every integer or |
1480 | floating-point mode up to and including SIZE bytes long. We do this | |
1481 | since the object might be accessed in any mode and frame addresses | |
1482 | are shared. */ | |
1483 | ||
1484 | for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); | |
770ae6cc | 1485 | mode != VOIDmode && GET_MODE_SIZE (mode) <= decl_size; |
87ce34d6 JW |
1486 | mode = GET_MODE_WIDER_MODE (mode)) |
1487 | if (! memory_address_p (mode, addr)) | |
1488 | return; | |
5a73491b | 1489 | |
87ce34d6 | 1490 | for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); |
770ae6cc | 1491 | mode != VOIDmode && GET_MODE_SIZE (mode) <= decl_size; |
87ce34d6 JW |
1492 | mode = GET_MODE_WIDER_MODE (mode)) |
1493 | if (! memory_address_p (mode, addr)) | |
1494 | return; | |
1495 | } | |
5a73491b | 1496 | |
87ce34d6 JW |
1497 | /* Put back the address now that we have updated it and we either know |
1498 | it is valid or we don't care whether it is valid. */ | |
5a73491b RK |
1499 | |
1500 | XEXP (x, 0) = addr; | |
1501 | } | |
6f086dfc | 1502 | \f |
d1405722 | 1503 | /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX |
d6a7951f | 1504 | is a virtual register, return the equivalent hard register and set the |
d1405722 RK |
1505 | offset indirectly through the pointer. Otherwise, return 0. */ |
1506 | ||
1507 | static rtx | |
fa8db1f7 | 1508 | instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset) |
d1405722 RK |
1509 | { |
1510 | rtx new; | |
1511 | HOST_WIDE_INT offset; | |
1512 | ||
1513 | if (x == virtual_incoming_args_rtx) | |
1514 | new = arg_pointer_rtx, offset = in_arg_offset; | |
1515 | else if (x == virtual_stack_vars_rtx) | |
1516 | new = frame_pointer_rtx, offset = var_offset; | |
1517 | else if (x == virtual_stack_dynamic_rtx) | |
1518 | new = stack_pointer_rtx, offset = dynamic_offset; | |
1519 | else if (x == virtual_outgoing_args_rtx) | |
1520 | new = stack_pointer_rtx, offset = out_arg_offset; | |
1521 | else if (x == virtual_cfa_rtx) | |
1522 | new = arg_pointer_rtx, offset = cfa_offset; | |
1523 | else | |
1524 | return 0; | |
1525 | ||
1526 | *poffset = offset; | |
1527 | return new; | |
1528 | } | |
1529 | \f | |
5dc96d60 JH |
1530 | |
1531 | /* Called when instantiate_virtual_regs has failed to update the instruction. | |
1532 | Usually this means that non-matching instruction has been emit, however for | |
1533 | asm statements it may be the problem in the constraints. */ | |
1534 | static void | |
fa8db1f7 | 1535 | instantiate_virtual_regs_lossage (rtx insn) |
5dc96d60 JH |
1536 | { |
1537 | if (asm_noperands (PATTERN (insn)) >= 0) | |
1538 | { | |
1539 | error_for_asm (insn, "impossible constraint in `asm'"); | |
1540 | delete_insn (insn); | |
1541 | } | |
1542 | else | |
1543 | abort (); | |
1544 | } | |
6f086dfc RS |
1545 | /* Given a pointer to a piece of rtx and an optional pointer to the |
1546 | containing object, instantiate any virtual registers present in it. | |
1547 | ||
1548 | If EXTRA_INSNS, we always do the replacement and generate | |
1549 | any extra insns before OBJECT. If it zero, we do nothing if replacement | |
1550 | is not valid. | |
1551 | ||
1552 | Return 1 if we either had nothing to do or if we were able to do the | |
718fe406 | 1553 | needed replacement. Return 0 otherwise; we only return zero if |
6f086dfc RS |
1554 | EXTRA_INSNS is zero. |
1555 | ||
1556 | We first try some simple transformations to avoid the creation of extra | |
1557 | pseudos. */ | |
1558 | ||
1559 | static int | |
fa8db1f7 | 1560 | instantiate_virtual_regs_1 (rtx *loc, rtx object, int extra_insns) |
6f086dfc RS |
1561 | { |
1562 | rtx x; | |
1563 | RTX_CODE code; | |
1564 | rtx new = 0; | |
07444f1d | 1565 | HOST_WIDE_INT offset = 0; |
6f086dfc RS |
1566 | rtx temp; |
1567 | rtx seq; | |
1568 | int i, j; | |
6f7d635c | 1569 | const char *fmt; |
6f086dfc RS |
1570 | |
1571 | /* Re-start here to avoid recursion in common cases. */ | |
1572 | restart: | |
1573 | ||
1574 | x = *loc; | |
1575 | if (x == 0) | |
1576 | return 1; | |
1577 | ||
5dc96d60 JH |
1578 | /* We may have detected and deleted invalid asm statements. */ |
1579 | if (object && INSN_P (object) && INSN_DELETED_P (object)) | |
1580 | return 1; | |
1581 | ||
6f086dfc RS |
1582 | code = GET_CODE (x); |
1583 | ||
1584 | /* Check for some special cases. */ | |
1585 | switch (code) | |
1586 | { | |
1587 | case CONST_INT: | |
1588 | case CONST_DOUBLE: | |
69ef87e2 | 1589 | case CONST_VECTOR: |
6f086dfc RS |
1590 | case CONST: |
1591 | case SYMBOL_REF: | |
1592 | case CODE_LABEL: | |
1593 | case PC: | |
1594 | case CC0: | |
1595 | case ASM_INPUT: | |
1596 | case ADDR_VEC: | |
1597 | case ADDR_DIFF_VEC: | |
1598 | case RETURN: | |
1599 | return 1; | |
1600 | ||
1601 | case SET: | |
1602 | /* We are allowed to set the virtual registers. This means that | |
38e01259 | 1603 | the actual register should receive the source minus the |
6f086dfc RS |
1604 | appropriate offset. This is used, for example, in the handling |
1605 | of non-local gotos. */ | |
d1405722 | 1606 | if ((new = instantiate_new_reg (SET_DEST (x), &offset)) != 0) |
6f086dfc | 1607 | { |
14a774a9 RK |
1608 | rtx src = SET_SRC (x); |
1609 | ||
d1405722 RK |
1610 | /* We are setting the register, not using it, so the relevant |
1611 | offset is the negative of the offset to use were we using | |
1612 | the register. */ | |
1613 | offset = - offset; | |
14a774a9 RK |
1614 | instantiate_virtual_regs_1 (&src, NULL_RTX, 0); |
1615 | ||
6f086dfc RS |
1616 | /* The only valid sources here are PLUS or REG. Just do |
1617 | the simplest possible thing to handle them. */ | |
f8cfc6aa | 1618 | if (!REG_P (src) && GET_CODE (src) != PLUS) |
5dc96d60 JH |
1619 | { |
1620 | instantiate_virtual_regs_lossage (object); | |
1621 | return 1; | |
1622 | } | |
6f086dfc RS |
1623 | |
1624 | start_sequence (); | |
f8cfc6aa | 1625 | if (!REG_P (src)) |
14a774a9 | 1626 | temp = force_operand (src, NULL_RTX); |
6f086dfc | 1627 | else |
14a774a9 | 1628 | temp = src; |
5f4f0e22 | 1629 | temp = force_operand (plus_constant (temp, offset), NULL_RTX); |
6f086dfc RS |
1630 | seq = get_insns (); |
1631 | end_sequence (); | |
1632 | ||
2f937369 | 1633 | emit_insn_before (seq, object); |
6f086dfc RS |
1634 | SET_DEST (x) = new; |
1635 | ||
e9a25f70 | 1636 | if (! validate_change (object, &SET_SRC (x), temp, 0) |
6f086dfc | 1637 | || ! extra_insns) |
5dc96d60 | 1638 | instantiate_virtual_regs_lossage (object); |
6f086dfc RS |
1639 | |
1640 | return 1; | |
1641 | } | |
1642 | ||
1643 | instantiate_virtual_regs_1 (&SET_DEST (x), object, extra_insns); | |
1644 | loc = &SET_SRC (x); | |
1645 | goto restart; | |
1646 | ||
1647 | case PLUS: | |
1648 | /* Handle special case of virtual register plus constant. */ | |
1649 | if (CONSTANT_P (XEXP (x, 1))) | |
1650 | { | |
b1f82ccf | 1651 | rtx old, new_offset; |
6f086dfc RS |
1652 | |
1653 | /* Check for (plus (plus VIRT foo) (const_int)) first. */ | |
1654 | if (GET_CODE (XEXP (x, 0)) == PLUS) | |
1655 | { | |
d1405722 RK |
1656 | if ((new = instantiate_new_reg (XEXP (XEXP (x, 0), 0), &offset))) |
1657 | { | |
1658 | instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 1), object, | |
1659 | extra_insns); | |
1660 | new = gen_rtx_PLUS (Pmode, new, XEXP (XEXP (x, 0), 1)); | |
1661 | } | |
6f086dfc RS |
1662 | else |
1663 | { | |
1664 | loc = &XEXP (x, 0); | |
1665 | goto restart; | |
1666 | } | |
6f086dfc RS |
1667 | } |
1668 | ||
d1405722 RK |
1669 | #ifdef POINTERS_EXTEND_UNSIGNED |
1670 | /* If we have (plus (subreg (virtual-reg)) (const_int)), we know | |
1671 | we can commute the PLUS and SUBREG because pointers into the | |
1672 | frame are well-behaved. */ | |
1673 | else if (GET_CODE (XEXP (x, 0)) == SUBREG && GET_MODE (x) == ptr_mode | |
1674 | && GET_CODE (XEXP (x, 1)) == CONST_INT | |
1675 | && 0 != (new | |
1676 | = instantiate_new_reg (SUBREG_REG (XEXP (x, 0)), | |
1677 | &offset)) | |
1678 | && validate_change (object, loc, | |
1679 | plus_constant (gen_lowpart (ptr_mode, | |
1680 | new), | |
1681 | offset | |
1682 | + INTVAL (XEXP (x, 1))), | |
1683 | 0)) | |
1684 | return 1; | |
1685 | #endif | |
1686 | else if ((new = instantiate_new_reg (XEXP (x, 0), &offset)) == 0) | |
6f086dfc RS |
1687 | { |
1688 | /* We know the second operand is a constant. Unless the | |
1689 | first operand is a REG (which has been already checked), | |
1690 | it needs to be checked. */ | |
f8cfc6aa | 1691 | if (!REG_P (XEXP (x, 0))) |
6f086dfc RS |
1692 | { |
1693 | loc = &XEXP (x, 0); | |
1694 | goto restart; | |
1695 | } | |
1696 | return 1; | |
1697 | } | |
1698 | ||
b1f82ccf | 1699 | new_offset = plus_constant (XEXP (x, 1), offset); |
6f086dfc | 1700 | |
b1f82ccf DE |
1701 | /* If the new constant is zero, try to replace the sum with just |
1702 | the register. */ | |
1703 | if (new_offset == const0_rtx | |
1704 | && validate_change (object, loc, new, 0)) | |
6f086dfc RS |
1705 | return 1; |
1706 | ||
b1f82ccf DE |
1707 | /* Next try to replace the register and new offset. |
1708 | There are two changes to validate here and we can't assume that | |
1709 | in the case of old offset equals new just changing the register | |
1710 | will yield a valid insn. In the interests of a little efficiency, | |
1711 | however, we only call validate change once (we don't queue up the | |
0f41302f | 1712 | changes and then call apply_change_group). */ |
b1f82ccf DE |
1713 | |
1714 | old = XEXP (x, 0); | |
1715 | if (offset == 0 | |
1716 | ? ! validate_change (object, &XEXP (x, 0), new, 0) | |
1717 | : (XEXP (x, 0) = new, | |
1718 | ! validate_change (object, &XEXP (x, 1), new_offset, 0))) | |
6f086dfc RS |
1719 | { |
1720 | if (! extra_insns) | |
1721 | { | |
1722 | XEXP (x, 0) = old; | |
1723 | return 0; | |
1724 | } | |
1725 | ||
1726 | /* Otherwise copy the new constant into a register and replace | |
1727 | constant with that register. */ | |
1728 | temp = gen_reg_rtx (Pmode); | |
b1f82ccf | 1729 | XEXP (x, 0) = new; |
6f086dfc | 1730 | if (validate_change (object, &XEXP (x, 1), temp, 0)) |
b1f82ccf | 1731 | emit_insn_before (gen_move_insn (temp, new_offset), object); |
6f086dfc RS |
1732 | else |
1733 | { | |
1734 | /* If that didn't work, replace this expression with a | |
1735 | register containing the sum. */ | |
1736 | ||
6f086dfc | 1737 | XEXP (x, 0) = old; |
38a448ca | 1738 | new = gen_rtx_PLUS (Pmode, new, new_offset); |
6f086dfc RS |
1739 | |
1740 | start_sequence (); | |
5f4f0e22 | 1741 | temp = force_operand (new, NULL_RTX); |
6f086dfc RS |
1742 | seq = get_insns (); |
1743 | end_sequence (); | |
1744 | ||
2f937369 | 1745 | emit_insn_before (seq, object); |
6f086dfc RS |
1746 | if (! validate_change (object, loc, temp, 0) |
1747 | && ! validate_replace_rtx (x, temp, object)) | |
5dc96d60 JH |
1748 | { |
1749 | instantiate_virtual_regs_lossage (object); | |
1750 | return 1; | |
1751 | } | |
6f086dfc RS |
1752 | } |
1753 | } | |
1754 | ||
1755 | return 1; | |
1756 | } | |
1757 | ||
1758 | /* Fall through to generic two-operand expression case. */ | |
1759 | case EXPR_LIST: | |
1760 | case CALL: | |
1761 | case COMPARE: | |
1762 | case MINUS: | |
1763 | case MULT: | |
1764 | case DIV: case UDIV: | |
1765 | case MOD: case UMOD: | |
1766 | case AND: case IOR: case XOR: | |
45620ed4 RK |
1767 | case ROTATERT: case ROTATE: |
1768 | case ASHIFTRT: case LSHIFTRT: case ASHIFT: | |
6f086dfc RS |
1769 | case NE: case EQ: |
1770 | case GE: case GT: case GEU: case GTU: | |
1771 | case LE: case LT: case LEU: case LTU: | |
1772 | if (XEXP (x, 1) && ! CONSTANT_P (XEXP (x, 1))) | |
1773 | instantiate_virtual_regs_1 (&XEXP (x, 1), object, extra_insns); | |
1774 | loc = &XEXP (x, 0); | |
1775 | goto restart; | |
1776 | ||
1777 | case MEM: | |
1778 | /* Most cases of MEM that convert to valid addresses have already been | |
4fd796bb | 1779 | handled by our scan of decls. The only special handling we |
6f086dfc | 1780 | need here is to make a copy of the rtx to ensure it isn't being |
718fe406 | 1781 | shared if we have to change it to a pseudo. |
6f086dfc RS |
1782 | |
1783 | If the rtx is a simple reference to an address via a virtual register, | |
1784 | it can potentially be shared. In such cases, first try to make it | |
1785 | a valid address, which can also be shared. Otherwise, copy it and | |
718fe406 | 1786 | proceed normally. |
6f086dfc RS |
1787 | |
1788 | First check for common cases that need no processing. These are | |
1789 | usually due to instantiation already being done on a previous instance | |
1790 | of a shared rtx. */ | |
1791 | ||
1792 | temp = XEXP (x, 0); | |
1793 | if (CONSTANT_ADDRESS_P (temp) | |
1794 | #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM | |
1795 | || temp == arg_pointer_rtx | |
b37f453b DE |
1796 | #endif |
1797 | #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM | |
1798 | || temp == hard_frame_pointer_rtx | |
6f086dfc RS |
1799 | #endif |
1800 | || temp == frame_pointer_rtx) | |
1801 | return 1; | |
1802 | ||
1803 | if (GET_CODE (temp) == PLUS | |
1804 | && CONSTANT_ADDRESS_P (XEXP (temp, 1)) | |
1805 | && (XEXP (temp, 0) == frame_pointer_rtx | |
b37f453b DE |
1806 | #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM |
1807 | || XEXP (temp, 0) == hard_frame_pointer_rtx | |
1808 | #endif | |
6f086dfc RS |
1809 | #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM |
1810 | || XEXP (temp, 0) == arg_pointer_rtx | |
1811 | #endif | |
1812 | )) | |
1813 | return 1; | |
1814 | ||
1815 | if (temp == virtual_stack_vars_rtx | |
1816 | || temp == virtual_incoming_args_rtx | |
1817 | || (GET_CODE (temp) == PLUS | |
1818 | && CONSTANT_ADDRESS_P (XEXP (temp, 1)) | |
1819 | && (XEXP (temp, 0) == virtual_stack_vars_rtx | |
1820 | || XEXP (temp, 0) == virtual_incoming_args_rtx))) | |
1821 | { | |
1822 | /* This MEM may be shared. If the substitution can be done without | |
1823 | the need to generate new pseudos, we want to do it in place | |
1824 | so all copies of the shared rtx benefit. The call below will | |
1825 | only make substitutions if the resulting address is still | |
1826 | valid. | |
1827 | ||
1828 | Note that we cannot pass X as the object in the recursive call | |
1829 | since the insn being processed may not allow all valid | |
6461be14 RS |
1830 | addresses. However, if we were not passed on object, we can |
1831 | only modify X without copying it if X will have a valid | |
1832 | address. | |
6f086dfc | 1833 | |
6461be14 RS |
1834 | ??? Also note that this can still lose if OBJECT is an insn that |
1835 | has less restrictions on an address that some other insn. | |
1836 | In that case, we will modify the shared address. This case | |
4fd796bb RK |
1837 | doesn't seem very likely, though. One case where this could |
1838 | happen is in the case of a USE or CLOBBER reference, but we | |
1839 | take care of that below. */ | |
6461be14 RS |
1840 | |
1841 | if (instantiate_virtual_regs_1 (&XEXP (x, 0), | |
1842 | object ? object : x, 0)) | |
6f086dfc RS |
1843 | return 1; |
1844 | ||
1845 | /* Otherwise make a copy and process that copy. We copy the entire | |
1846 | RTL expression since it might be a PLUS which could also be | |
1847 | shared. */ | |
1848 | *loc = x = copy_rtx (x); | |
1849 | } | |
1850 | ||
1851 | /* Fall through to generic unary operation case. */ | |
21b8482a | 1852 | case PREFETCH: |
6f086dfc RS |
1853 | case SUBREG: |
1854 | case STRICT_LOW_PART: | |
1855 | case NEG: case NOT: | |
1856 | case PRE_DEC: case PRE_INC: case POST_DEC: case POST_INC: | |
1857 | case SIGN_EXTEND: case ZERO_EXTEND: | |
1858 | case TRUNCATE: case FLOAT_EXTEND: case FLOAT_TRUNCATE: | |
1859 | case FLOAT: case FIX: | |
1860 | case UNSIGNED_FIX: case UNSIGNED_FLOAT: | |
1861 | case ABS: | |
1862 | case SQRT: | |
1863 | case FFS: | |
2928cd7a RH |
1864 | case CLZ: case CTZ: |
1865 | case POPCOUNT: case PARITY: | |
6f086dfc RS |
1866 | /* These case either have just one operand or we know that we need not |
1867 | check the rest of the operands. */ | |
1868 | loc = &XEXP (x, 0); | |
1869 | goto restart; | |
1870 | ||
4fd796bb RK |
1871 | case USE: |
1872 | case CLOBBER: | |
1873 | /* If the operand is a MEM, see if the change is a valid MEM. If not, | |
1874 | go ahead and make the invalid one, but do it to a copy. For a REG, | |
718fe406 | 1875 | just make the recursive call, since there's no chance of a problem. */ |
4fd796bb | 1876 | |
3c0cb5de | 1877 | if ((MEM_P (XEXP (x, 0)) |
4fd796bb RK |
1878 | && instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), XEXP (x, 0), |
1879 | 0)) | |
f8cfc6aa | 1880 | || (REG_P (XEXP (x, 0)) |
7694ce35 | 1881 | && instantiate_virtual_regs_1 (&XEXP (x, 0), object, 0))) |
4fd796bb RK |
1882 | return 1; |
1883 | ||
1884 | XEXP (x, 0) = copy_rtx (XEXP (x, 0)); | |
1885 | loc = &XEXP (x, 0); | |
1886 | goto restart; | |
1887 | ||
6f086dfc RS |
1888 | case REG: |
1889 | /* Try to replace with a PLUS. If that doesn't work, compute the sum | |
1890 | in front of this insn and substitute the temporary. */ | |
d1405722 | 1891 | if ((new = instantiate_new_reg (x, &offset)) != 0) |
6f086dfc RS |
1892 | { |
1893 | temp = plus_constant (new, offset); | |
1894 | if (!validate_change (object, loc, temp, 0)) | |
1895 | { | |
1896 | if (! extra_insns) | |
1897 | return 0; | |
1898 | ||
1899 | start_sequence (); | |
5f4f0e22 | 1900 | temp = force_operand (temp, NULL_RTX); |
6f086dfc RS |
1901 | seq = get_insns (); |
1902 | end_sequence (); | |
1903 | ||
2f937369 | 1904 | emit_insn_before (seq, object); |
6f086dfc RS |
1905 | if (! validate_change (object, loc, temp, 0) |
1906 | && ! validate_replace_rtx (x, temp, object)) | |
5dc96d60 | 1907 | instantiate_virtual_regs_lossage (object); |
6f086dfc RS |
1908 | } |
1909 | } | |
1910 | ||
1911 | return 1; | |
e9a25f70 | 1912 | |
e9a25f70 JL |
1913 | default: |
1914 | break; | |
6f086dfc RS |
1915 | } |
1916 | ||
1917 | /* Scan all subexpressions. */ | |
1918 | fmt = GET_RTX_FORMAT (code); | |
1919 | for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++) | |
1920 | if (*fmt == 'e') | |
1921 | { | |
1922 | if (!instantiate_virtual_regs_1 (&XEXP (x, i), object, extra_insns)) | |
1923 | return 0; | |
1924 | } | |
1925 | else if (*fmt == 'E') | |
1926 | for (j = 0; j < XVECLEN (x, i); j++) | |
1927 | if (! instantiate_virtual_regs_1 (&XVECEXP (x, i, j), object, | |
1928 | extra_insns)) | |
1929 | return 0; | |
1930 | ||
1931 | return 1; | |
1932 | } | |
1933 | \f | |
d181c154 RS |
1934 | /* Return 1 if EXP is an aggregate type (or a value with aggregate type). |
1935 | This means a type for which function calls must pass an address to the | |
1936 | function or get an address back from the function. | |
1937 | EXP may be a type node or an expression (whose type is tested). */ | |
6f086dfc RS |
1938 | |
1939 | int | |
61f71b34 | 1940 | aggregate_value_p (tree exp, tree fntype) |
6f086dfc | 1941 | { |
9d790a4f RS |
1942 | int i, regno, nregs; |
1943 | rtx reg; | |
2f939d94 TP |
1944 | |
1945 | tree type = (TYPE_P (exp)) ? exp : TREE_TYPE (exp); | |
d181c154 | 1946 | |
61f71b34 DD |
1947 | if (fntype) |
1948 | switch (TREE_CODE (fntype)) | |
1949 | { | |
1950 | case CALL_EXPR: | |
1951 | fntype = get_callee_fndecl (fntype); | |
1952 | fntype = fntype ? TREE_TYPE (fntype) : 0; | |
1953 | break; | |
1954 | case FUNCTION_DECL: | |
1955 | fntype = TREE_TYPE (fntype); | |
1956 | break; | |
1957 | case FUNCTION_TYPE: | |
1958 | case METHOD_TYPE: | |
1959 | break; | |
1960 | case IDENTIFIER_NODE: | |
1961 | fntype = 0; | |
1962 | break; | |
1963 | default: | |
1964 | /* We don't expect other rtl types here. */ | |
1965 | abort(); | |
1966 | } | |
1967 | ||
d7bf8ada MM |
1968 | if (TREE_CODE (type) == VOID_TYPE) |
1969 | return 0; | |
61f71b34 | 1970 | if (targetm.calls.return_in_memory (type, fntype)) |
6f086dfc | 1971 | return 1; |
956d6950 | 1972 | /* Types that are TREE_ADDRESSABLE must be constructed in memory, |
49a2e5b2 DE |
1973 | and thus can't be returned in registers. */ |
1974 | if (TREE_ADDRESSABLE (type)) | |
1975 | return 1; | |
05e3bdb9 | 1976 | if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type)) |
6f086dfc | 1977 | return 1; |
9d790a4f RS |
1978 | /* Make sure we have suitable call-clobbered regs to return |
1979 | the value in; if not, we must return it in memory. */ | |
4dc07bd7 | 1980 | reg = hard_function_value (type, 0, 0); |
e71f7aa5 JW |
1981 | |
1982 | /* If we have something other than a REG (e.g. a PARALLEL), then assume | |
1983 | it is OK. */ | |
f8cfc6aa | 1984 | if (!REG_P (reg)) |
e71f7aa5 JW |
1985 | return 0; |
1986 | ||
9d790a4f | 1987 | regno = REGNO (reg); |
66fd46b6 | 1988 | nregs = hard_regno_nregs[regno][TYPE_MODE (type)]; |
9d790a4f RS |
1989 | for (i = 0; i < nregs; i++) |
1990 | if (! call_used_regs[regno + i]) | |
1991 | return 1; | |
6f086dfc RS |
1992 | return 0; |
1993 | } | |
1994 | \f | |
8fff4fc1 RH |
1995 | /* Return true if we should assign DECL a pseudo register; false if it |
1996 | should live on the local stack. */ | |
1997 | ||
1998 | bool | |
1999 | use_register_for_decl (tree decl) | |
2000 | { | |
2001 | /* Honor volatile. */ | |
2002 | if (TREE_SIDE_EFFECTS (decl)) | |
2003 | return false; | |
2004 | ||
2005 | /* Honor addressability. */ | |
2006 | if (TREE_ADDRESSABLE (decl)) | |
2007 | return false; | |
2008 | ||
2009 | /* Only register-like things go in registers. */ | |
2010 | if (DECL_MODE (decl) == BLKmode) | |
2011 | return false; | |
2012 | ||
2013 | /* If -ffloat-store specified, don't put explicit float variables | |
2014 | into registers. */ | |
2015 | /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa | |
2016 | propagates values across these stores, and it probably shouldn't. */ | |
2017 | if (flag_float_store && FLOAT_TYPE_P (TREE_TYPE (decl))) | |
2018 | return false; | |
2019 | ||
2020 | /* Compiler-generated temporaries can always go in registers. */ | |
2021 | if (DECL_ARTIFICIAL (decl)) | |
2022 | return true; | |
2023 | ||
2024 | #ifdef NON_SAVING_SETJMP | |
2025 | /* Protect variables not declared "register" from setjmp. */ | |
2026 | if (NON_SAVING_SETJMP | |
2027 | && current_function_calls_setjmp | |
2028 | && !DECL_REGISTER (decl)) | |
2029 | return false; | |
2030 | #endif | |
2031 | ||
2032 | return (optimize || DECL_REGISTER (decl)); | |
2033 | } | |
2034 | ||
6f086dfc RS |
2035 | /* Assign RTL expressions to the function's parameters. |
2036 | This may involve copying them into registers and using | |
0d1416c6 | 2037 | those registers as the RTL for them. */ |
6f086dfc RS |
2038 | |
2039 | void | |
fa8db1f7 | 2040 | assign_parms (tree fndecl) |
6f086dfc | 2041 | { |
b3694847 | 2042 | tree parm; |
6f086dfc | 2043 | CUMULATIVE_ARGS args_so_far; |
6f086dfc RS |
2044 | /* Total space needed so far for args on the stack, |
2045 | given as a constant and a tree-expression. */ | |
2046 | struct args_size stack_args_size; | |
53c428d0 | 2047 | HOST_WIDE_INT extra_pretend_bytes = 0; |
6f086dfc | 2048 | tree fntype = TREE_TYPE (fndecl); |
ded9bf77 | 2049 | tree fnargs = DECL_ARGUMENTS (fndecl), orig_fnargs; |
6f086dfc RS |
2050 | /* This is used for the arg pointer when referring to stack args. */ |
2051 | rtx internal_arg_pointer; | |
718fe406 | 2052 | /* This is a dummy PARM_DECL that we used for the function result if |
6f086dfc RS |
2053 | the function returns a structure. */ |
2054 | tree function_result_decl = 0; | |
6f086dfc | 2055 | int varargs_setup = 0; |
2b256a46 | 2056 | int reg_parm_stack_space ATTRIBUTE_UNUSED = 0; |
3412b298 | 2057 | rtx conversion_insns = 0; |
6f086dfc | 2058 | |
6f086dfc RS |
2059 | /* Nonzero if function takes extra anonymous args. |
2060 | This means the last named arg must be on the stack | |
0f41302f | 2061 | right before the anonymous ones. */ |
6de9cd9a | 2062 | int stdarg = current_function_stdarg; |
ebb904cb | 2063 | |
6f086dfc RS |
2064 | /* If the reg that the virtual arg pointer will be translated into is |
2065 | not a fixed reg or is the stack pointer, make a copy of the virtual | |
2066 | arg pointer, and address parms via the copy. The frame pointer is | |
2067 | considered fixed even though it is not marked as such. | |
2068 | ||
2069 | The second time through, simply use ap to avoid generating rtx. */ | |
2070 | ||
2071 | if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM | |
2072 | || ! (fixed_regs[ARG_POINTER_REGNUM] | |
0d1416c6 | 2073 | || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM))) |
6f086dfc RS |
2074 | internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx); |
2075 | else | |
2076 | internal_arg_pointer = virtual_incoming_args_rtx; | |
2077 | current_function_internal_arg_pointer = internal_arg_pointer; | |
2078 | ||
2079 | stack_args_size.constant = 0; | |
2080 | stack_args_size.var = 0; | |
2081 | ||
2082 | /* If struct value address is treated as the first argument, make it so. */ | |
61f71b34 | 2083 | if (aggregate_value_p (DECL_RESULT (fndecl), fndecl) |
6f086dfc | 2084 | && ! current_function_returns_pcc_struct |
61f71b34 | 2085 | && targetm.calls.struct_value_rtx (TREE_TYPE (fndecl), 1) == 0) |
6f086dfc | 2086 | { |
f9f29478 | 2087 | tree type = build_pointer_type (TREE_TYPE (fntype)); |
6f086dfc | 2088 | |
5f4f0e22 | 2089 | function_result_decl = build_decl (PARM_DECL, NULL_TREE, type); |
6f086dfc RS |
2090 | |
2091 | DECL_ARG_TYPE (function_result_decl) = type; | |
2092 | TREE_CHAIN (function_result_decl) = fnargs; | |
2093 | fnargs = function_result_decl; | |
2094 | } | |
718fe406 | 2095 | |
ded9bf77 AH |
2096 | orig_fnargs = fnargs; |
2097 | ||
42ba5130 RH |
2098 | /* If the target wants to split complex arguments into scalars, do so. */ |
2099 | if (targetm.calls.split_complex_arg) | |
ded9bf77 AH |
2100 | fnargs = split_complex_args (fnargs); |
2101 | ||
e7949876 | 2102 | #ifdef REG_PARM_STACK_SPACE |
e7949876 AM |
2103 | reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl); |
2104 | #endif | |
e7949876 | 2105 | |
6f086dfc | 2106 | #ifdef INIT_CUMULATIVE_INCOMING_ARGS |
ea0d4c4b | 2107 | INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, NULL_RTX); |
6f086dfc | 2108 | #else |
0f6937fe | 2109 | INIT_CUMULATIVE_ARGS (args_so_far, fntype, NULL_RTX, fndecl, -1); |
6f086dfc RS |
2110 | #endif |
2111 | ||
2112 | /* We haven't yet found an argument that we must push and pretend the | |
2113 | caller did. */ | |
2114 | current_function_pretend_args_size = 0; | |
2115 | ||
2116 | for (parm = fnargs; parm; parm = TREE_CHAIN (parm)) | |
2117 | { | |
e7949876 AM |
2118 | rtx entry_parm; |
2119 | rtx stack_parm; | |
2120 | enum machine_mode promoted_mode, passed_mode; | |
2121 | enum machine_mode nominal_mode, promoted_nominal_mode; | |
2122 | int unsignedp; | |
2123 | struct locate_and_pad_arg_data locate; | |
6f086dfc | 2124 | int passed_pointer = 0; |
621061f4 | 2125 | int did_conversion = 0; |
6f086dfc | 2126 | tree passed_type = DECL_ARG_TYPE (parm); |
621061f4 | 2127 | tree nominal_type = TREE_TYPE (parm); |
108b7d3d | 2128 | int last_named = 0, named_arg; |
e7949876 AM |
2129 | int in_regs; |
2130 | int partial = 0; | |
975f3818 | 2131 | int pretend_bytes = 0; |
6e290f11 | 2132 | int loaded_in_reg = 0; |
6f086dfc | 2133 | |
108b7d3d | 2134 | /* Set LAST_NAMED if this is last named arg before last |
bf9c83fe | 2135 | anonymous args. */ |
6c535c69 | 2136 | if (stdarg) |
108b7d3d JJ |
2137 | { |
2138 | tree tem; | |
2139 | ||
2140 | for (tem = TREE_CHAIN (parm); tem; tem = TREE_CHAIN (tem)) | |
2141 | if (DECL_NAME (tem)) | |
2142 | break; | |
2143 | ||
2144 | if (tem == 0) | |
2145 | last_named = 1; | |
2146 | } | |
bf9c83fe JW |
2147 | /* Set NAMED_ARG if this arg should be treated as a named arg. For |
2148 | most machines, if this is a varargs/stdarg function, then we treat | |
2149 | the last named arg as if it were anonymous too. */ | |
f276fb54 DE |
2150 | named_arg = (targetm.calls.strict_argument_naming (&args_so_far) |
2151 | ? 1 : !last_named); | |
6f086dfc RS |
2152 | |
2153 | if (TREE_TYPE (parm) == error_mark_node | |
2154 | /* This can happen after weird syntax errors | |
2155 | or if an enum type is defined among the parms. */ | |
2156 | || TREE_CODE (parm) != PARM_DECL | |
2157 | || passed_type == NULL) | |
2158 | { | |
19e7881c MM |
2159 | SET_DECL_RTL (parm, gen_rtx_MEM (BLKmode, const0_rtx)); |
2160 | DECL_INCOMING_RTL (parm) = DECL_RTL (parm); | |
6f086dfc RS |
2161 | TREE_USED (parm) = 1; |
2162 | continue; | |
2163 | } | |
2164 | ||
6f086dfc RS |
2165 | /* Find mode of arg as it is passed, and mode of arg |
2166 | as it should be during execution of this function. */ | |
2167 | passed_mode = TYPE_MODE (passed_type); | |
621061f4 | 2168 | nominal_mode = TYPE_MODE (nominal_type); |
6f086dfc | 2169 | |
16bae307 RS |
2170 | /* If the parm's mode is VOID, its value doesn't matter, |
2171 | and avoid the usual things like emit_move_insn that could crash. */ | |
2172 | if (nominal_mode == VOIDmode) | |
2173 | { | |
19e7881c MM |
2174 | SET_DECL_RTL (parm, const0_rtx); |
2175 | DECL_INCOMING_RTL (parm) = DECL_RTL (parm); | |
16bae307 RS |
2176 | continue; |
2177 | } | |
2178 | ||
3f46679a RK |
2179 | /* If the parm is to be passed as a transparent union, use the |
2180 | type of the first field for the tests below. We have already | |
2181 | verified that the modes are the same. */ | |
2182 | if (DECL_TRANSPARENT_UNION (parm) | |
2bf105ab RK |
2183 | || (TREE_CODE (passed_type) == UNION_TYPE |
2184 | && TYPE_TRANSPARENT_UNION (passed_type))) | |
3f46679a RK |
2185 | passed_type = TREE_TYPE (TYPE_FIELDS (passed_type)); |
2186 | ||
a14ae508 RK |
2187 | /* See if this arg was passed by invisible reference. It is if |
2188 | it is an object whose size depends on the contents of the | |
2189 | object itself or if the machine requires these objects be passed | |
2190 | that way. */ | |
2191 | ||
7a6cdb44 | 2192 | if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (passed_type)) |
657bb6dc | 2193 | || TREE_ADDRESSABLE (passed_type) |
6f086dfc | 2194 | #ifdef FUNCTION_ARG_PASS_BY_REFERENCE |
a14ae508 | 2195 | || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, passed_mode, |
e7949876 | 2196 | passed_type, named_arg) |
a14ae508 RK |
2197 | #endif |
2198 | ) | |
6f086dfc | 2199 | { |
621061f4 | 2200 | passed_type = nominal_type = build_pointer_type (passed_type); |
6f086dfc RS |
2201 | passed_pointer = 1; |
2202 | passed_mode = nominal_mode = Pmode; | |
2203 | } | |
8e51619a JM |
2204 | /* See if the frontend wants to pass this by invisible reference. */ |
2205 | else if (passed_type != nominal_type | |
2206 | && POINTER_TYPE_P (passed_type) | |
2207 | && TREE_TYPE (passed_type) == nominal_type) | |
2208 | { | |
2209 | nominal_type = passed_type; | |
2210 | passed_pointer = 1; | |
2211 | passed_mode = nominal_mode = Pmode; | |
2212 | } | |
6f086dfc | 2213 | |
a53e14c0 RK |
2214 | promoted_mode = passed_mode; |
2215 | ||
61f71b34 DD |
2216 | if (targetm.calls.promote_function_args (TREE_TYPE (fndecl))) |
2217 | { | |
2218 | /* Compute the mode in which the arg is actually extended to. */ | |
8df83eae RK |
2219 | unsignedp = TYPE_UNSIGNED (passed_type); |
2220 | promoted_mode = promote_mode (passed_type, promoted_mode, | |
2221 | &unsignedp, 1); | |
61f71b34 | 2222 | } |
a53e14c0 | 2223 | |
6f086dfc RS |
2224 | /* Let machine desc say which reg (if any) the parm arrives in. |
2225 | 0 means it arrives on the stack. */ | |
2226 | #ifdef FUNCTION_INCOMING_ARG | |
a53e14c0 | 2227 | entry_parm = FUNCTION_INCOMING_ARG (args_so_far, promoted_mode, |
bf9c83fe | 2228 | passed_type, named_arg); |
6f086dfc | 2229 | #else |
a53e14c0 | 2230 | entry_parm = FUNCTION_ARG (args_so_far, promoted_mode, |
bf9c83fe | 2231 | passed_type, named_arg); |
6f086dfc RS |
2232 | #endif |
2233 | ||
621061f4 RK |
2234 | if (entry_parm == 0) |
2235 | promoted_mode = passed_mode; | |
a53e14c0 | 2236 | |
6f086dfc RS |
2237 | /* If this is the last named parameter, do any required setup for |
2238 | varargs or stdargs. We need to know about the case of this being an | |
2239 | addressable type, in which case we skip the registers it | |
2240 | would have arrived in. | |
2241 | ||
2242 | For stdargs, LAST_NAMED will be set for two parameters, the one that | |
2243 | is actually the last named, and the dummy parameter. We only | |
2244 | want to do this action once. | |
2245 | ||
2246 | Also, indicate when RTL generation is to be suppressed. */ | |
2247 | if (last_named && !varargs_setup) | |
2248 | { | |
975f3818 | 2249 | int varargs_pretend_bytes = 0; |
61f71b34 | 2250 | targetm.calls.setup_incoming_varargs (&args_so_far, promoted_mode, |
975f3818 RS |
2251 | passed_type, |
2252 | &varargs_pretend_bytes, 0); | |
6f086dfc | 2253 | varargs_setup = 1; |
975f3818 RS |
2254 | |
2255 | /* If the back-end has requested extra stack space, record how | |
2256 | much is needed. Do not change pretend_args_size otherwise | |
2257 | since it may be nonzero from an earlier partial argument. */ | |
2258 | if (varargs_pretend_bytes > 0) | |
2259 | current_function_pretend_args_size = varargs_pretend_bytes; | |
6f086dfc | 2260 | } |
6f086dfc RS |
2261 | |
2262 | /* Determine parm's home in the stack, | |
2263 | in case it arrives in the stack or we should pretend it did. | |
2264 | ||
2265 | Compute the stack position and rtx where the argument arrives | |
2266 | and its size. | |
2267 | ||
2268 | There is one complexity here: If this was a parameter that would | |
2269 | have been passed in registers, but wasn't only because it is | |
2270 | __builtin_va_alist, we want locate_and_pad_parm to treat it as if | |
2271 | it came in a register so that REG_PARM_STACK_SPACE isn't skipped. | |
2272 | In this case, we call FUNCTION_ARG with NAMED set to 1 instead of | |
2273 | 0 as it was the previous time. */ | |
e7949876 | 2274 | in_regs = entry_parm != 0; |
6f086dfc | 2275 | #ifdef STACK_PARMS_IN_REG_PARM_AREA |
e7949876 AM |
2276 | in_regs = 1; |
2277 | #endif | |
2278 | if (!in_regs && !named_arg) | |
2279 | { | |
61f71b34 DD |
2280 | int pretend_named = |
2281 | targetm.calls.pretend_outgoing_varargs_named (&args_so_far); | |
e7949876 AM |
2282 | if (pretend_named) |
2283 | { | |
6f086dfc | 2284 | #ifdef FUNCTION_INCOMING_ARG |
e7949876 AM |
2285 | in_regs = FUNCTION_INCOMING_ARG (args_so_far, promoted_mode, |
2286 | passed_type, | |
2287 | pretend_named) != 0; | |
6f086dfc | 2288 | #else |
e7949876 AM |
2289 | in_regs = FUNCTION_ARG (args_so_far, promoted_mode, |
2290 | passed_type, | |
2291 | pretend_named) != 0; | |
6f086dfc | 2292 | #endif |
e7949876 AM |
2293 | } |
2294 | } | |
2295 | ||
2296 | /* If this parameter was passed both in registers and in the stack, | |
2297 | use the copy on the stack. */ | |
2298 | if (MUST_PASS_IN_STACK (promoted_mode, passed_type)) | |
2299 | entry_parm = 0; | |
2300 | ||
2301 | #ifdef FUNCTION_ARG_PARTIAL_NREGS | |
2302 | if (entry_parm) | |
975f3818 RS |
2303 | { |
2304 | partial = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, promoted_mode, | |
2305 | passed_type, named_arg); | |
2306 | if (partial | |
975f3818 RS |
2307 | /* The caller might already have allocated stack space |
2308 | for the register parameters. */ | |
6c5caf00 | 2309 | && reg_parm_stack_space == 0) |
975f3818 RS |
2310 | { |
2311 | /* Part of this argument is passed in registers and part | |
2312 | is passed on the stack. Ask the prologue code to extend | |
2313 | the stack part so that we can recreate the full value. | |
2314 | ||
2315 | PRETEND_BYTES is the size of the registers we need to store. | |
2316 | CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra | |
2317 | stack space that the prologue should allocate. | |
2318 | ||
2319 | Internally, gcc assumes that the argument pointer is | |
2320 | aligned to STACK_BOUNDARY bits. This is used both for | |
368ebcd6 | 2321 | alignment optimizations (see init_emit) and to locate |
975f3818 RS |
2322 | arguments that are aligned to more than PARM_BOUNDARY |
2323 | bits. We must preserve this invariant by rounding | |
2324 | CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to a stack | |
2325 | boundary. */ | |
53c428d0 PB |
2326 | |
2327 | /* We assume at most one partial arg, and it must be the first | |
2328 | argument on the stack. */ | |
2329 | if (extra_pretend_bytes || current_function_pretend_args_size) | |
2330 | abort (); | |
2331 | ||
975f3818 RS |
2332 | pretend_bytes = partial * UNITS_PER_WORD; |
2333 | current_function_pretend_args_size | |
2334 | = CEIL_ROUND (pretend_bytes, STACK_BYTES); | |
2335 | ||
53c428d0 PB |
2336 | /* We want to align relative to the actual stack pointer, so |
2337 | don't include this in the stack size until later. */ | |
2338 | extra_pretend_bytes = current_function_pretend_args_size; | |
975f3818 RS |
2339 | } |
2340 | } | |
6f086dfc | 2341 | #endif |
e7949876 AM |
2342 | |
2343 | memset (&locate, 0, sizeof (locate)); | |
2344 | locate_and_pad_parm (promoted_mode, passed_type, in_regs, | |
2345 | entry_parm ? partial : 0, fndecl, | |
2346 | &stack_args_size, &locate); | |
ce407aa9 PB |
2347 | /* Adjust offsets to include the pretend args. */ |
2348 | locate.slot_offset.constant += extra_pretend_bytes - pretend_bytes; | |
2349 | locate.offset.constant += extra_pretend_bytes - pretend_bytes; | |
6f086dfc | 2350 | |
0d1416c6 | 2351 | { |
e7949876 | 2352 | rtx offset_rtx; |
ebca59c3 | 2353 | unsigned int align, boundary; |
e7949876 AM |
2354 | |
2355 | /* If we're passing this arg using a reg, make its stack home | |
2356 | the aligned stack slot. */ | |
2357 | if (entry_parm) | |
2358 | offset_rtx = ARGS_SIZE_RTX (locate.slot_offset); | |
2359 | else | |
2360 | offset_rtx = ARGS_SIZE_RTX (locate.offset); | |
0d1416c6 BS |
2361 | |
2362 | if (offset_rtx == const0_rtx) | |
2363 | stack_parm = gen_rtx_MEM (promoted_mode, internal_arg_pointer); | |
2364 | else | |
2365 | stack_parm = gen_rtx_MEM (promoted_mode, | |
2366 | gen_rtx_PLUS (Pmode, | |
2367 | internal_arg_pointer, | |
2368 | offset_rtx)); | |
2369 | ||
3bdf5ad1 | 2370 | set_mem_attributes (stack_parm, parm, 1); |
ebca59c3 RH |
2371 | |
2372 | boundary = FUNCTION_ARG_BOUNDARY (promoted_mode, passed_type); | |
2373 | align = 0; | |
2374 | ||
2375 | /* If we're padding upward, we know that the alignment of the slot | |
2376 | is FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're | |
2377 | intentionally forcing upward padding. Otherwise we have to come | |
2378 | up with a guess at the alignment based on OFFSET_RTX. */ | |
2379 | if (locate.where_pad == upward || entry_parm) | |
2380 | align = boundary; | |
2381 | else if (GET_CODE (offset_rtx) == CONST_INT) | |
2382 | { | |
2383 | align = INTVAL (offset_rtx) * BITS_PER_UNIT | boundary; | |
2384 | align = align & -align; | |
2385 | } | |
2386 | if (align > 0) | |
2387 | set_mem_align (stack_parm, align); | |
2388 | ||
1d14f992 | 2389 | if (entry_parm) |
9d18e06b | 2390 | set_reg_attrs_for_parm (entry_parm, stack_parm); |
0d1416c6 | 2391 | } |
6f086dfc | 2392 | |
6f086dfc RS |
2393 | /* If this parm was passed part in regs and part in memory, |
2394 | pretend it arrived entirely in memory | |
2395 | by pushing the register-part onto the stack. | |
2396 | ||
2397 | In the special case of a DImode or DFmode that is split, | |
2398 | we could put it together in a pseudoreg directly, | |
2399 | but for now that's not worth bothering with. */ | |
2400 | ||
e7949876 | 2401 | if (partial) |
6f086dfc | 2402 | { |
e7949876 AM |
2403 | /* Handle calls that pass values in multiple non-contiguous |
2404 | locations. The Irix 6 ABI has examples of this. */ | |
2405 | if (GET_CODE (entry_parm) == PARALLEL) | |
2406 | emit_group_store (validize_mem (stack_parm), entry_parm, | |
6e985040 | 2407 | TREE_TYPE (parm), |
e7949876 | 2408 | int_size_in_bytes (TREE_TYPE (parm))); |
718fe406 | 2409 | |
e7949876 AM |
2410 | else |
2411 | move_block_from_reg (REGNO (entry_parm), validize_mem (stack_parm), | |
c6b97fac | 2412 | partial); |
0d1416c6 | 2413 | |
e7949876 | 2414 | entry_parm = stack_parm; |
6f086dfc RS |
2415 | } |
2416 | ||
2417 | /* If we didn't decide this parm came in a register, | |
2418 | by default it came on the stack. */ | |
2419 | if (entry_parm == 0) | |
2420 | entry_parm = stack_parm; | |
2421 | ||
2422 | /* Record permanently how this parm was passed. */ | |
fbe6ec81 | 2423 | set_decl_incoming_rtl (parm, entry_parm); |
6f086dfc RS |
2424 | |
2425 | /* If there is actually space on the stack for this parm, | |
2426 | count it in stack_args_size; otherwise set stack_parm to 0 | |
2427 | to indicate there is no preallocated stack slot for the parm. */ | |
2428 | ||
2429 | if (entry_parm == stack_parm | |
dd3f0101 KH |
2430 | || (GET_CODE (entry_parm) == PARALLEL |
2431 | && XEXP (XVECEXP (entry_parm, 0, 0), 0) == NULL_RTX) | |
6c5caf00 | 2432 | #if defined (REG_PARM_STACK_SPACE) |
6f086dfc | 2433 | /* On some machines, even if a parm value arrives in a register |
6c5caf00 KH |
2434 | there is still an (uninitialized) stack slot allocated |
2435 | for it. */ | |
6f086dfc RS |
2436 | || REG_PARM_STACK_SPACE (fndecl) > 0 |
2437 | #endif | |
2438 | ) | |
2439 | { | |
53c428d0 | 2440 | stack_args_size.constant += locate.size.constant; |
e7949876 AM |
2441 | if (locate.size.var) |
2442 | ADD_PARM_SIZE (stack_args_size, locate.size.var); | |
6f086dfc RS |
2443 | } |
2444 | else | |
2445 | /* No stack slot was pushed for this parm. */ | |
2446 | stack_parm = 0; | |
2447 | ||
2448 | /* Update info on where next arg arrives in registers. */ | |
2449 | ||
621061f4 | 2450 | FUNCTION_ARG_ADVANCE (args_so_far, promoted_mode, |
bf9c83fe | 2451 | passed_type, named_arg); |
6f086dfc | 2452 | |
e16c591a RS |
2453 | /* If we can't trust the parm stack slot to be aligned enough |
2454 | for its ultimate type, don't use that slot after entry. | |
2455 | We'll make another stack slot, if we need one. */ | |
e66e7856 RH |
2456 | if (STRICT_ALIGNMENT && stack_parm |
2457 | && GET_MODE_ALIGNMENT (nominal_mode) > MEM_ALIGN (stack_parm)) | |
2458 | stack_parm = 0; | |
e16c591a | 2459 | |
cb61f66f RS |
2460 | /* If parm was passed in memory, and we need to convert it on entry, |
2461 | don't store it back in that same slot. */ | |
e7949876 | 2462 | if (entry_parm == stack_parm |
cb61f66f RS |
2463 | && nominal_mode != BLKmode && nominal_mode != passed_mode) |
2464 | stack_parm = 0; | |
2465 | ||
e68a6ce1 AO |
2466 | /* When an argument is passed in multiple locations, we can't |
2467 | make use of this information, but we can save some copying if | |
2468 | the whole argument is passed in a single register. */ | |
2469 | if (GET_CODE (entry_parm) == PARALLEL | |
2470 | && nominal_mode != BLKmode && passed_mode != BLKmode) | |
2471 | { | |
2472 | int i, len = XVECLEN (entry_parm, 0); | |
2473 | ||
2474 | for (i = 0; i < len; i++) | |
2475 | if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX | |
f8cfc6aa | 2476 | && REG_P (XEXP (XVECEXP (entry_parm, 0, i), 0)) |
e68a6ce1 AO |
2477 | && (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0)) |
2478 | == passed_mode) | |
b845f897 | 2479 | && INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0) |
e68a6ce1 AO |
2480 | { |
2481 | entry_parm = XEXP (XVECEXP (entry_parm, 0, i), 0); | |
fbe6ec81 | 2482 | set_decl_incoming_rtl (parm, entry_parm); |
e68a6ce1 AO |
2483 | break; |
2484 | } | |
2485 | } | |
2486 | ||
6f086dfc RS |
2487 | /* ENTRY_PARM is an RTX for the parameter as it arrives, |
2488 | in the mode in which it arrives. | |
2489 | STACK_PARM is an RTX for a stack slot where the parameter can live | |
2490 | during the function (in case we want to put it there). | |
2491 | STACK_PARM is 0 if no stack slot was pushed for it. | |
2492 | ||
2493 | Now output code if necessary to convert ENTRY_PARM to | |
2494 | the type in which this function declares it, | |
2495 | and store that result in an appropriate place, | |
2496 | which may be a pseudo reg, may be STACK_PARM, | |
2497 | or may be a local stack slot if STACK_PARM is 0. | |
2498 | ||
2499 | Set DECL_RTL to that place. */ | |
2500 | ||
8fff4fc1 RH |
2501 | if (GET_CODE (entry_parm) == PARALLEL |
2502 | && nominal_mode != BLKmode | |
a0506b54 | 2503 | && XVECLEN (entry_parm, 0) > 1) |
531547e9 | 2504 | { |
a0506b54 DE |
2505 | /* Reconstitute objects the size of a register or larger using |
2506 | register operations instead of the stack. */ | |
531547e9 | 2507 | rtx parmreg = gen_reg_rtx (nominal_mode); |
a0506b54 DE |
2508 | |
2509 | if (REG_P (parmreg)) | |
2510 | { | |
2511 | emit_group_store (parmreg, entry_parm, TREE_TYPE (parm), | |
2512 | int_size_in_bytes (TREE_TYPE (parm))); | |
2513 | SET_DECL_RTL (parm, parmreg); | |
6e290f11 | 2514 | loaded_in_reg = 1; |
a0506b54 | 2515 | } |
531547e9 FJ |
2516 | } |
2517 | ||
6e985040 AM |
2518 | if (nominal_mode == BLKmode |
2519 | #ifdef BLOCK_REG_PADDING | |
2520 | || (locate.where_pad == (BYTES_BIG_ENDIAN ? upward : downward) | |
2521 | && GET_MODE_SIZE (promoted_mode) < UNITS_PER_WORD) | |
2522 | #endif | |
2523 | || GET_CODE (entry_parm) == PARALLEL) | |
6f086dfc | 2524 | { |
5c4cdc9f JW |
2525 | /* If a BLKmode arrives in registers, copy it to a stack slot. |
2526 | Handle calls that pass values in multiple non-contiguous | |
2527 | locations. The Irix 6 ABI has examples of this. */ | |
f8cfc6aa | 2528 | if (REG_P (entry_parm) |
6e290f11 FJ |
2529 | || (GET_CODE (entry_parm) == PARALLEL |
2530 | && (!loaded_in_reg || !optimize))) | |
6f086dfc | 2531 | { |
c6b97fac AM |
2532 | int size = int_size_in_bytes (TREE_TYPE (parm)); |
2533 | int size_stored = CEIL_ROUND (size, UNITS_PER_WORD); | |
2534 | rtx mem; | |
6f086dfc RS |
2535 | |
2536 | /* Note that we will be storing an integral number of words. | |
2537 | So we have to be careful to ensure that we allocate an | |
2538 | integral number of words. We do this below in the | |
2539 | assign_stack_local if space was not allocated in the argument | |
2540 | list. If it was, this will not work if PARM_BOUNDARY is not | |
2541 | a multiple of BITS_PER_WORD. It isn't clear how to fix this | |
531547e9 FJ |
2542 | if it becomes a problem. Exception is when BLKmode arrives |
2543 | with arguments not conforming to word_mode. */ | |
6f086dfc RS |
2544 | |
2545 | if (stack_parm == 0) | |
7e41ffa2 | 2546 | { |
648bb159 RS |
2547 | stack_parm = assign_stack_local (BLKmode, size_stored, 0); |
2548 | PUT_MODE (stack_parm, GET_MODE (entry_parm)); | |
3bdf5ad1 | 2549 | set_mem_attributes (stack_parm, parm, 1); |
7e41ffa2 | 2550 | } |
a926b253 | 2551 | else if (GET_CODE (entry_parm) == PARALLEL) |
531547e9 | 2552 | ; |
afc066ef | 2553 | else if (size != 0 && PARM_BOUNDARY % BITS_PER_WORD != 0) |
6f086dfc RS |
2554 | abort (); |
2555 | ||
c6b97fac AM |
2556 | mem = validize_mem (stack_parm); |
2557 | ||
5c4cdc9f JW |
2558 | /* Handle calls that pass values in multiple non-contiguous |
2559 | locations. The Irix 6 ABI has examples of this. */ | |
2560 | if (GET_CODE (entry_parm) == PARALLEL) | |
6e985040 | 2561 | emit_group_store (mem, entry_parm, TREE_TYPE (parm), size); |
c6b97fac | 2562 | |
5c07bd7a AM |
2563 | else if (size == 0) |
2564 | ; | |
2565 | ||
c6b97fac AM |
2566 | /* If SIZE is that of a mode no bigger than a word, just use |
2567 | that mode's store operation. */ | |
2568 | else if (size <= UNITS_PER_WORD) | |
2569 | { | |
2570 | enum machine_mode mode | |
2571 | = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0); | |
2572 | ||
6e985040 AM |
2573 | if (mode != BLKmode |
2574 | #ifdef BLOCK_REG_PADDING | |
2575 | && (size == UNITS_PER_WORD | |
2576 | || (BLOCK_REG_PADDING (mode, TREE_TYPE (parm), 1) | |
2577 | != (BYTES_BIG_ENDIAN ? upward : downward))) | |
2578 | #endif | |
2579 | ) | |
c6b97fac AM |
2580 | { |
2581 | rtx reg = gen_rtx_REG (mode, REGNO (entry_parm)); | |
2582 | emit_move_insn (change_address (mem, mode, 0), reg); | |
2583 | } | |
2584 | ||
2585 | /* Blocks smaller than a word on a BYTES_BIG_ENDIAN | |
2586 | machine must be aligned to the left before storing | |
2587 | to memory. Note that the previous test doesn't | |
2588 | handle all cases (e.g. SIZE == 3). */ | |
2589 | else if (size != UNITS_PER_WORD | |
6e985040 AM |
2590 | #ifdef BLOCK_REG_PADDING |
2591 | && (BLOCK_REG_PADDING (mode, TREE_TYPE (parm), 1) | |
2592 | == downward) | |
2593 | #else | |
2594 | && BYTES_BIG_ENDIAN | |
2595 | #endif | |
2596 | ) | |
c6b97fac AM |
2597 | { |
2598 | rtx tem, x; | |
2599 | int by = (UNITS_PER_WORD - size) * BITS_PER_UNIT; | |
2600 | rtx reg = gen_rtx_REG (word_mode, REGNO (entry_parm)); | |
2601 | ||
2602 | x = expand_binop (word_mode, ashl_optab, reg, | |
2603 | GEN_INT (by), 0, 1, OPTAB_WIDEN); | |
2604 | tem = change_address (mem, word_mode, 0); | |
2605 | emit_move_insn (tem, x); | |
2606 | } | |
2607 | else | |
2608 | move_block_from_reg (REGNO (entry_parm), mem, | |
2609 | size_stored / UNITS_PER_WORD); | |
2610 | } | |
5c4cdc9f | 2611 | else |
c6b97fac AM |
2612 | move_block_from_reg (REGNO (entry_parm), mem, |
2613 | size_stored / UNITS_PER_WORD); | |
6f086dfc | 2614 | } |
531547e9 | 2615 | /* If parm is already bound to register pair, don't change |
6614fd40 | 2616 | this binding. */ |
531547e9 FJ |
2617 | if (! DECL_RTL_SET_P (parm)) |
2618 | SET_DECL_RTL (parm, stack_parm); | |
6f086dfc | 2619 | } |
8fff4fc1 | 2620 | else if (use_register_for_decl (parm) |
6f086dfc RS |
2621 | /* Always assign pseudo to structure return or item passed |
2622 | by invisible reference. */ | |
2623 | || passed_pointer || parm == function_result_decl) | |
2624 | { | |
00d8a4c1 RK |
2625 | /* Store the parm in a pseudoregister during the function, but we |
2626 | may need to do it in a wider mode. */ | |
2627 | ||
b3694847 | 2628 | rtx parmreg; |
00d8a4c1 | 2629 | |
8df83eae | 2630 | unsignedp = TYPE_UNSIGNED (TREE_TYPE (parm)); |
cd5b3469 | 2631 | |
621061f4 RK |
2632 | promoted_nominal_mode |
2633 | = promote_mode (TREE_TYPE (parm), nominal_mode, &unsignedp, 0); | |
6f086dfc | 2634 | |
621061f4 | 2635 | parmreg = gen_reg_rtx (promoted_nominal_mode); |
ddb7361a | 2636 | mark_user_reg (parmreg); |
6f086dfc RS |
2637 | |
2638 | /* If this was an item that we received a pointer to, set DECL_RTL | |
2639 | appropriately. */ | |
2640 | if (passed_pointer) | |
2641 | { | |
abde42f7 | 2642 | rtx x = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (passed_type)), |
797a6ac1 | 2643 | parmreg); |
abde42f7 JH |
2644 | set_mem_attributes (x, parm, 1); |
2645 | SET_DECL_RTL (parm, x); | |
6f086dfc RS |
2646 | } |
2647 | else | |
d64236b4 | 2648 | { |
19e7881c | 2649 | SET_DECL_RTL (parm, parmreg); |
d64236b4 RK |
2650 | maybe_set_unchanging (DECL_RTL (parm), parm); |
2651 | } | |
797a6ac1 | 2652 | |
6f086dfc | 2653 | /* Copy the value into the register. */ |
621061f4 RK |
2654 | if (nominal_mode != passed_mode |
2655 | || promoted_nominal_mode != promoted_mode) | |
86f8eff3 | 2656 | { |
efd8cba0 | 2657 | int save_tree_used; |
621061f4 | 2658 | /* ENTRY_PARM has been converted to PROMOTED_MODE, its |
718fe406 | 2659 | mode, by the caller. We now have to convert it to |
621061f4 | 2660 | NOMINAL_MODE, if different. However, PARMREG may be in |
956d6950 | 2661 | a different mode than NOMINAL_MODE if it is being stored |
621061f4 RK |
2662 | promoted. |
2663 | ||
2664 | If ENTRY_PARM is a hard register, it might be in a register | |
86f8eff3 RK |
2665 | not valid for operating in its mode (e.g., an odd-numbered |
2666 | register for a DFmode). In that case, moves are the only | |
2667 | thing valid, so we can't do a convert from there. This | |
2668 | occurs when the calling sequence allow such misaligned | |
3412b298 JW |
2669 | usages. |
2670 | ||
2671 | In addition, the conversion may involve a call, which could | |
2672 | clobber parameters which haven't been copied to pseudo | |
2673 | registers yet. Therefore, we must first copy the parm to | |
2674 | a pseudo reg here, and save the conversion until after all | |
2675 | parameters have been moved. */ | |
2676 | ||
2677 | rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm)); | |
2678 | ||
2679 | emit_move_insn (tempreg, validize_mem (entry_parm)); | |
2680 | ||
2681 | push_to_sequence (conversion_insns); | |
ad241351 RK |
2682 | tempreg = convert_to_mode (nominal_mode, tempreg, unsignedp); |
2683 | ||
ddef6bc7 JJ |
2684 | if (GET_CODE (tempreg) == SUBREG |
2685 | && GET_MODE (tempreg) == nominal_mode | |
f8cfc6aa | 2686 | && REG_P (SUBREG_REG (tempreg)) |
ddef6bc7 JJ |
2687 | && nominal_mode == passed_mode |
2688 | && GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (entry_parm) | |
2689 | && GET_MODE_SIZE (GET_MODE (tempreg)) | |
2690 | < GET_MODE_SIZE (GET_MODE (entry_parm))) | |
2691 | { | |
2692 | /* The argument is already sign/zero extended, so note it | |
2693 | into the subreg. */ | |
2694 | SUBREG_PROMOTED_VAR_P (tempreg) = 1; | |
7879b81e | 2695 | SUBREG_PROMOTED_UNSIGNED_SET (tempreg, unsignedp); |
ddef6bc7 JJ |
2696 | } |
2697 | ||
efd8cba0 DB |
2698 | /* TREE_USED gets set erroneously during expand_assignment. */ |
2699 | save_tree_used = TREE_USED (parm); | |
621061f4 | 2700 | expand_assignment (parm, |
b90f141a | 2701 | make_tree (nominal_type, tempreg), 0); |
efd8cba0 | 2702 | TREE_USED (parm) = save_tree_used; |
3412b298 | 2703 | conversion_insns = get_insns (); |
621061f4 | 2704 | did_conversion = 1; |
3412b298 | 2705 | end_sequence (); |
86f8eff3 | 2706 | } |
6f086dfc RS |
2707 | else |
2708 | emit_move_insn (parmreg, validize_mem (entry_parm)); | |
2709 | ||
74bd77a8 RS |
2710 | /* If we were passed a pointer but the actual value |
2711 | can safely live in a register, put it in one. */ | |
8fff4fc1 RH |
2712 | if (passed_pointer |
2713 | && use_register_for_decl (parm) | |
4606272b | 2714 | /* If by-reference argument was promoted, demote it. */ |
8fff4fc1 | 2715 | && TYPE_MODE (TREE_TYPE (parm)) != GET_MODE (DECL_RTL (parm))) |
74bd77a8 | 2716 | { |
2654605a JW |
2717 | /* We can't use nominal_mode, because it will have been set to |
2718 | Pmode above. We must use the actual mode of the parm. */ | |
2719 | parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm))); | |
ddb7361a | 2720 | mark_user_reg (parmreg); |
f523247a AO |
2721 | if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm))) |
2722 | { | |
2723 | rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm))); | |
8df83eae | 2724 | int unsigned_p = TYPE_UNSIGNED (TREE_TYPE (parm)); |
f523247a AO |
2725 | push_to_sequence (conversion_insns); |
2726 | emit_move_insn (tempreg, DECL_RTL (parm)); | |
19e7881c | 2727 | SET_DECL_RTL (parm, |
797a6ac1 | 2728 | convert_to_mode (GET_MODE (parmreg), |
19e7881c MM |
2729 | tempreg, |
2730 | unsigned_p)); | |
f523247a AO |
2731 | emit_move_insn (parmreg, DECL_RTL (parm)); |
2732 | conversion_insns = get_insns(); | |
2733 | did_conversion = 1; | |
2734 | end_sequence (); | |
2735 | } | |
2736 | else | |
2737 | emit_move_insn (parmreg, DECL_RTL (parm)); | |
19e7881c | 2738 | SET_DECL_RTL (parm, parmreg); |
c110c53d RS |
2739 | /* STACK_PARM is the pointer, not the parm, and PARMREG is |
2740 | now the parm. */ | |
2741 | stack_parm = 0; | |
74bd77a8 | 2742 | } |
137a2a7b DE |
2743 | #ifdef FUNCTION_ARG_CALLEE_COPIES |
2744 | /* If we are passed an arg by reference and it is our responsibility | |
2745 | to make a copy, do it now. | |
2746 | PASSED_TYPE and PASSED mode now refer to the pointer, not the | |
2747 | original argument, so we must recreate them in the call to | |
2748 | FUNCTION_ARG_CALLEE_COPIES. */ | |
2749 | /* ??? Later add code to handle the case that if the argument isn't | |
2750 | modified, don't do the copy. */ | |
2751 | ||
2752 | else if (passed_pointer | |
2753 | && FUNCTION_ARG_CALLEE_COPIES (args_so_far, | |
7f3a6a92 JM |
2754 | TYPE_MODE (TREE_TYPE (passed_type)), |
2755 | TREE_TYPE (passed_type), | |
bf9c83fe | 2756 | named_arg) |
7f3a6a92 | 2757 | && ! TREE_ADDRESSABLE (TREE_TYPE (passed_type))) |
137a2a7b DE |
2758 | { |
2759 | rtx copy; | |
7f3a6a92 | 2760 | tree type = TREE_TYPE (passed_type); |
137a2a7b DE |
2761 | |
2762 | /* This sequence may involve a library call perhaps clobbering | |
2763 | registers that haven't been copied to pseudos yet. */ | |
2764 | ||
2765 | push_to_sequence (conversion_insns); | |
2766 | ||
d0f062fb | 2767 | if (!COMPLETE_TYPE_P (type) |
137a2a7b | 2768 | || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) |
1fd3ef7f | 2769 | /* This is a variable sized object. */ |
38a448ca RH |
2770 | copy = gen_rtx_MEM (BLKmode, |
2771 | allocate_dynamic_stack_space | |
2772 | (expr_size (parm), NULL_RTX, | |
2773 | TYPE_ALIGN (type))); | |
137a2a7b | 2774 | else |
1fd3ef7f RK |
2775 | copy = assign_stack_temp (TYPE_MODE (type), |
2776 | int_size_in_bytes (type), 1); | |
a696c1d6 | 2777 | set_mem_attributes (copy, parm, 1); |
137a2a7b DE |
2778 | |
2779 | store_expr (parm, copy, 0); | |
2780 | emit_move_insn (parmreg, XEXP (copy, 0)); | |
2781 | conversion_insns = get_insns (); | |
621061f4 | 2782 | did_conversion = 1; |
137a2a7b DE |
2783 | end_sequence (); |
2784 | } | |
2785 | #endif /* FUNCTION_ARG_CALLEE_COPIES */ | |
74bd77a8 | 2786 | |
6f086dfc RS |
2787 | /* Mark the register as eliminable if we did no conversion |
2788 | and it was copied from memory at a fixed offset, | |
2789 | and the arg pointer was not copied to a pseudo-reg. | |
2790 | If the arg pointer is a pseudo reg or the offset formed | |
2791 | an invalid address, such memory-equivalences | |
2792 | as we make here would screw up life analysis for it. */ | |
2793 | if (nominal_mode == passed_mode | |
621061f4 | 2794 | && ! did_conversion |
38b610ed | 2795 | && stack_parm != 0 |
3c0cb5de | 2796 | && MEM_P (stack_parm) |
e7949876 | 2797 | && locate.offset.var == 0 |
6f086dfc | 2798 | && reg_mentioned_p (virtual_incoming_args_rtx, |
38b610ed | 2799 | XEXP (stack_parm, 0))) |
a03caf76 RK |
2800 | { |
2801 | rtx linsn = get_last_insn (); | |
69685820 | 2802 | rtx sinsn, set; |
a03caf76 RK |
2803 | |
2804 | /* Mark complex types separately. */ | |
2805 | if (GET_CODE (parmreg) == CONCAT) | |
8fff4fc1 RH |
2806 | { |
2807 | enum machine_mode submode | |
2808 | = GET_MODE_INNER (GET_MODE (parmreg)); | |
2809 | int regnor = REGNO (gen_realpart (submode, parmreg)); | |
2810 | int regnoi = REGNO (gen_imagpart (submode, parmreg)); | |
2811 | rtx stackr = gen_realpart (submode, stack_parm); | |
2812 | rtx stacki = gen_imagpart (submode, stack_parm); | |
2813 | ||
2814 | /* Scan backwards for the set of the real and | |
2815 | imaginary parts. */ | |
2816 | for (sinsn = linsn; sinsn != 0; | |
2817 | sinsn = prev_nonnote_insn (sinsn)) | |
2818 | { | |
2819 | set = single_set (sinsn); | |
2820 | if (set == 0) | |
2821 | continue; | |
2822 | ||
2823 | if (SET_DEST (set) == regno_reg_rtx [regnoi]) | |
2824 | REG_NOTES (sinsn) | |
2825 | = gen_rtx_EXPR_LIST (REG_EQUIV, stacki, | |
2826 | REG_NOTES (sinsn)); | |
2827 | else if (SET_DEST (set) == regno_reg_rtx [regnor]) | |
2828 | REG_NOTES (sinsn) | |
2829 | = gen_rtx_EXPR_LIST (REG_EQUIV, stackr, | |
2830 | REG_NOTES (sinsn)); | |
2831 | } | |
2832 | } | |
69685820 RK |
2833 | else if ((set = single_set (linsn)) != 0 |
2834 | && SET_DEST (set) == parmreg) | |
718fe406 | 2835 | REG_NOTES (linsn) |
38a448ca RH |
2836 | = gen_rtx_EXPR_LIST (REG_EQUIV, |
2837 | stack_parm, REG_NOTES (linsn)); | |
a03caf76 | 2838 | } |
6f086dfc RS |
2839 | |
2840 | /* For pointer data type, suggest pointer register. */ | |
e5e809f4 | 2841 | if (POINTER_TYPE_P (TREE_TYPE (parm))) |
6c6166bd | 2842 | mark_reg_pointer (parmreg, |
bdb429a5 | 2843 | TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm)))); |
6f086dfc RS |
2844 | } |
2845 | else | |
2846 | { | |
2847 | /* Value must be stored in the stack slot STACK_PARM | |
2848 | during function execution. */ | |
2849 | ||
621061f4 | 2850 | if (promoted_mode != nominal_mode) |
86f8eff3 | 2851 | { |
6d2f8887 | 2852 | /* Conversion is required. */ |
3412b298 JW |
2853 | rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm)); |
2854 | ||
2855 | emit_move_insn (tempreg, validize_mem (entry_parm)); | |
86f8eff3 | 2856 | |
3412b298 JW |
2857 | push_to_sequence (conversion_insns); |
2858 | entry_parm = convert_to_mode (nominal_mode, tempreg, | |
8df83eae | 2859 | TYPE_UNSIGNED (TREE_TYPE (parm))); |
de957303 | 2860 | if (stack_parm) |
f4ef873c RK |
2861 | /* ??? This may need a big-endian conversion on sparc64. */ |
2862 | stack_parm = adjust_address (stack_parm, nominal_mode, 0); | |
2863 | ||
3412b298 | 2864 | conversion_insns = get_insns (); |
621061f4 | 2865 | did_conversion = 1; |
3412b298 | 2866 | end_sequence (); |
86f8eff3 | 2867 | } |
6f086dfc RS |
2868 | |
2869 | if (entry_parm != stack_parm) | |
2870 | { | |
2871 | if (stack_parm == 0) | |
7e41ffa2 RS |
2872 | { |
2873 | stack_parm | |
2874 | = assign_stack_local (GET_MODE (entry_parm), | |
e7949876 AM |
2875 | GET_MODE_SIZE (GET_MODE (entry_parm)), |
2876 | 0); | |
3bdf5ad1 | 2877 | set_mem_attributes (stack_parm, parm, 1); |
7e41ffa2 RS |
2878 | } |
2879 | ||
621061f4 | 2880 | if (promoted_mode != nominal_mode) |
3412b298 JW |
2881 | { |
2882 | push_to_sequence (conversion_insns); | |
2883 | emit_move_insn (validize_mem (stack_parm), | |
2884 | validize_mem (entry_parm)); | |
2885 | conversion_insns = get_insns (); | |
2886 | end_sequence (); | |
2887 | } | |
2888 | else | |
2889 | emit_move_insn (validize_mem (stack_parm), | |
2890 | validize_mem (entry_parm)); | |
6f086dfc RS |
2891 | } |
2892 | ||
19e7881c | 2893 | SET_DECL_RTL (parm, stack_parm); |
6f086dfc | 2894 | } |
6f086dfc RS |
2895 | } |
2896 | ||
42ba5130 | 2897 | if (targetm.calls.split_complex_arg && fnargs != orig_fnargs) |
ded9bf77 | 2898 | { |
48144cd4 | 2899 | for (parm = orig_fnargs; parm; parm = TREE_CHAIN (parm)) |
ded9bf77 | 2900 | { |
42ba5130 RH |
2901 | if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE |
2902 | && targetm.calls.split_complex_arg (TREE_TYPE (parm))) | |
ded9bf77 | 2903 | { |
196c42cd AM |
2904 | rtx tmp, real, imag; |
2905 | enum machine_mode inner = GET_MODE_INNER (DECL_MODE (parm)); | |
2906 | ||
2907 | real = DECL_RTL (fnargs); | |
2908 | imag = DECL_RTL (TREE_CHAIN (fnargs)); | |
2909 | if (inner != GET_MODE (real)) | |
2910 | { | |
2911 | real = gen_lowpart_SUBREG (inner, real); | |
2912 | imag = gen_lowpart_SUBREG (inner, imag); | |
2913 | } | |
2914 | tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag); | |
2915 | SET_DECL_RTL (parm, tmp); | |
2916 | ||
2917 | real = DECL_INCOMING_RTL (fnargs); | |
2918 | imag = DECL_INCOMING_RTL (TREE_CHAIN (fnargs)); | |
2919 | if (inner != GET_MODE (real)) | |
2920 | { | |
2921 | real = gen_lowpart_SUBREG (inner, real); | |
2922 | imag = gen_lowpart_SUBREG (inner, imag); | |
2923 | } | |
2924 | tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag); | |
fbe6ec81 | 2925 | set_decl_incoming_rtl (parm, tmp); |
ded9bf77 AH |
2926 | fnargs = TREE_CHAIN (fnargs); |
2927 | } | |
2928 | else | |
2929 | { | |
2930 | SET_DECL_RTL (parm, DECL_RTL (fnargs)); | |
fbe6ec81 | 2931 | set_decl_incoming_rtl (parm, DECL_INCOMING_RTL (fnargs)); |
c6ca23fb JZ |
2932 | |
2933 | /* Set MEM_EXPR to the original decl, i.e. to PARM, | |
2934 | instead of the copy of decl, i.e. FNARGS. */ | |
2935 | if (DECL_INCOMING_RTL (parm) | |
3c0cb5de | 2936 | && MEM_P (DECL_INCOMING_RTL (parm))) |
c6ca23fb | 2937 | set_mem_expr (DECL_INCOMING_RTL (parm), parm); |
ded9bf77 AH |
2938 | } |
2939 | fnargs = TREE_CHAIN (fnargs); | |
2940 | } | |
2941 | } | |
2942 | ||
3412b298 JW |
2943 | /* Output all parameter conversion instructions (possibly including calls) |
2944 | now that all parameters have been copied out of hard registers. */ | |
2f937369 | 2945 | emit_insn (conversion_insns); |
3412b298 | 2946 | |
b36a8cc2 OH |
2947 | /* If we are receiving a struct value address as the first argument, set up |
2948 | the RTL for the function result. As this might require code to convert | |
2949 | the transmitted address to Pmode, we do this here to ensure that possible | |
2950 | preliminary conversions of the address have been emitted already. */ | |
2951 | if (function_result_decl) | |
2952 | { | |
2953 | tree result = DECL_RESULT (fndecl); | |
2954 | rtx addr = DECL_RTL (function_result_decl); | |
2955 | rtx x; | |
fa8db1f7 | 2956 | |
5ae6cd0d | 2957 | addr = convert_memory_address (Pmode, addr); |
b36a8cc2 OH |
2958 | x = gen_rtx_MEM (DECL_MODE (result), addr); |
2959 | set_mem_attributes (x, result, 1); | |
2960 | SET_DECL_RTL (result, x); | |
2961 | } | |
2962 | ||
53c428d0 PB |
2963 | /* We have aligned all the args, so add space for the pretend args. */ |
2964 | stack_args_size.constant += extra_pretend_bytes; | |
6f086dfc RS |
2965 | current_function_args_size = stack_args_size.constant; |
2966 | ||
2967 | /* Adjust function incoming argument size for alignment and | |
2968 | minimum length. */ | |
2969 | ||
2970 | #ifdef REG_PARM_STACK_SPACE | |
2971 | current_function_args_size = MAX (current_function_args_size, | |
2972 | REG_PARM_STACK_SPACE (fndecl)); | |
6f90e075 | 2973 | #endif |
6f086dfc | 2974 | |
4433e339 RH |
2975 | current_function_args_size |
2976 | = ((current_function_args_size + STACK_BYTES - 1) | |
2977 | / STACK_BYTES) * STACK_BYTES; | |
4433e339 | 2978 | |
6f086dfc RS |
2979 | #ifdef ARGS_GROW_DOWNWARD |
2980 | current_function_arg_offset_rtx | |
5f4f0e22 | 2981 | = (stack_args_size.var == 0 ? GEN_INT (-stack_args_size.constant) |
718fe406 KH |
2982 | : expand_expr (size_diffop (stack_args_size.var, |
2983 | size_int (-stack_args_size.constant)), | |
a57263bc | 2984 | NULL_RTX, VOIDmode, 0)); |
6f086dfc RS |
2985 | #else |
2986 | current_function_arg_offset_rtx = ARGS_SIZE_RTX (stack_args_size); | |
2987 | #endif | |
2988 | ||
2989 | /* See how many bytes, if any, of its args a function should try to pop | |
2990 | on return. */ | |
2991 | ||
64e6d9cc | 2992 | current_function_pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl), |
6f086dfc RS |
2993 | current_function_args_size); |
2994 | ||
3b69d50e RK |
2995 | /* For stdarg.h function, save info about |
2996 | regs and stack space used by the named args. */ | |
6f086dfc | 2997 | |
6c535c69 | 2998 | current_function_args_info = args_so_far; |
6f086dfc RS |
2999 | |
3000 | /* Set the rtx used for the function return value. Put this in its | |
3001 | own variable so any optimizers that need this information don't have | |
3002 | to include tree.h. Do this here so it gets done when an inlined | |
3003 | function gets output. */ | |
3004 | ||
19e7881c MM |
3005 | current_function_return_rtx |
3006 | = (DECL_RTL_SET_P (DECL_RESULT (fndecl)) | |
3007 | ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX); | |
ce5e43d0 JJ |
3008 | |
3009 | /* If scalar return value was computed in a pseudo-reg, or was a named | |
3010 | return value that got dumped to the stack, copy that to the hard | |
3011 | return register. */ | |
3012 | if (DECL_RTL_SET_P (DECL_RESULT (fndecl))) | |
3013 | { | |
3014 | tree decl_result = DECL_RESULT (fndecl); | |
3015 | rtx decl_rtl = DECL_RTL (decl_result); | |
3016 | ||
3017 | if (REG_P (decl_rtl) | |
3018 | ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER | |
3019 | : DECL_REGISTER (decl_result)) | |
3020 | { | |
3021 | rtx real_decl_rtl; | |
3022 | ||
3023 | #ifdef FUNCTION_OUTGOING_VALUE | |
3024 | real_decl_rtl = FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl_result), | |
3025 | fndecl); | |
3026 | #else | |
3027 | real_decl_rtl = FUNCTION_VALUE (TREE_TYPE (decl_result), | |
3028 | fndecl); | |
3029 | #endif | |
3030 | REG_FUNCTION_VALUE_P (real_decl_rtl) = 1; | |
3031 | /* The delay slot scheduler assumes that current_function_return_rtx | |
3032 | holds the hard register containing the return value, not a | |
3033 | temporary pseudo. */ | |
3034 | current_function_return_rtx = real_decl_rtl; | |
3035 | } | |
3036 | } | |
6f086dfc | 3037 | } |
ded9bf77 | 3038 | |
48144cd4 RH |
3039 | /* If ARGS contains entries with complex types, split the entry into two |
3040 | entries of the component type. Return a new list of substitutions are | |
3041 | needed, else the old list. */ | |
3042 | ||
ded9bf77 AH |
3043 | static tree |
3044 | split_complex_args (tree args) | |
3045 | { | |
3046 | tree p; | |
3047 | ||
48144cd4 RH |
3048 | /* Before allocating memory, check for the common case of no complex. */ |
3049 | for (p = args; p; p = TREE_CHAIN (p)) | |
42ba5130 RH |
3050 | { |
3051 | tree type = TREE_TYPE (p); | |
3052 | if (TREE_CODE (type) == COMPLEX_TYPE | |
3053 | && targetm.calls.split_complex_arg (type)) | |
3054 | goto found; | |
3055 | } | |
48144cd4 RH |
3056 | return args; |
3057 | ||
3058 | found: | |
ded9bf77 AH |
3059 | args = copy_list (args); |
3060 | ||
3061 | for (p = args; p; p = TREE_CHAIN (p)) | |
3062 | { | |
48144cd4 | 3063 | tree type = TREE_TYPE (p); |
42ba5130 RH |
3064 | if (TREE_CODE (type) == COMPLEX_TYPE |
3065 | && targetm.calls.split_complex_arg (type)) | |
ded9bf77 AH |
3066 | { |
3067 | tree decl; | |
48144cd4 | 3068 | tree subtype = TREE_TYPE (type); |
ded9bf77 AH |
3069 | |
3070 | /* Rewrite the PARM_DECL's type with its component. */ | |
3071 | TREE_TYPE (p) = subtype; | |
3072 | DECL_ARG_TYPE (p) = TREE_TYPE (DECL_ARG_TYPE (p)); | |
48144cd4 RH |
3073 | DECL_MODE (p) = VOIDmode; |
3074 | DECL_SIZE (p) = NULL; | |
3075 | DECL_SIZE_UNIT (p) = NULL; | |
3076 | layout_decl (p, 0); | |
ded9bf77 | 3077 | |
48144cd4 | 3078 | /* Build a second synthetic decl. */ |
ded9bf77 AH |
3079 | decl = build_decl (PARM_DECL, NULL_TREE, subtype); |
3080 | DECL_ARG_TYPE (decl) = DECL_ARG_TYPE (p); | |
48144cd4 RH |
3081 | layout_decl (decl, 0); |
3082 | ||
3083 | /* Splice it in; skip the new decl. */ | |
ded9bf77 AH |
3084 | TREE_CHAIN (decl) = TREE_CHAIN (p); |
3085 | TREE_CHAIN (p) = decl; | |
48144cd4 | 3086 | p = decl; |
ded9bf77 AH |
3087 | } |
3088 | } | |
3089 | ||
3090 | return args; | |
3091 | } | |
6f086dfc | 3092 | \f |
75dc3319 RK |
3093 | /* Indicate whether REGNO is an incoming argument to the current function |
3094 | that was promoted to a wider mode. If so, return the RTX for the | |
3095 | register (to get its mode). PMODE and PUNSIGNEDP are set to the mode | |
3096 | that REGNO is promoted from and whether the promotion was signed or | |
3097 | unsigned. */ | |
3098 | ||
75dc3319 | 3099 | rtx |
fa8db1f7 | 3100 | promoted_input_arg (unsigned int regno, enum machine_mode *pmode, int *punsignedp) |
75dc3319 RK |
3101 | { |
3102 | tree arg; | |
3103 | ||
3104 | for (arg = DECL_ARGUMENTS (current_function_decl); arg; | |
3105 | arg = TREE_CHAIN (arg)) | |
f8cfc6aa | 3106 | if (REG_P (DECL_INCOMING_RTL (arg)) |
621061f4 RK |
3107 | && REGNO (DECL_INCOMING_RTL (arg)) == regno |
3108 | && TYPE_MODE (DECL_ARG_TYPE (arg)) == TYPE_MODE (TREE_TYPE (arg))) | |
75dc3319 RK |
3109 | { |
3110 | enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg)); | |
8df83eae | 3111 | int unsignedp = TYPE_UNSIGNED (TREE_TYPE (arg)); |
75dc3319 | 3112 | |
a5a52dbc | 3113 | mode = promote_mode (TREE_TYPE (arg), mode, &unsignedp, 1); |
75dc3319 RK |
3114 | if (mode == GET_MODE (DECL_INCOMING_RTL (arg)) |
3115 | && mode != DECL_MODE (arg)) | |
3116 | { | |
3117 | *pmode = DECL_MODE (arg); | |
3118 | *punsignedp = unsignedp; | |
3119 | return DECL_INCOMING_RTL (arg); | |
3120 | } | |
3121 | } | |
3122 | ||
3123 | return 0; | |
3124 | } | |
3125 | ||
75dc3319 | 3126 | \f |
6f086dfc RS |
3127 | /* Compute the size and offset from the start of the stacked arguments for a |
3128 | parm passed in mode PASSED_MODE and with type TYPE. | |
3129 | ||
3130 | INITIAL_OFFSET_PTR points to the current offset into the stacked | |
3131 | arguments. | |
3132 | ||
e7949876 AM |
3133 | The starting offset and size for this parm are returned in |
3134 | LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is | |
3135 | nonzero, the offset is that of stack slot, which is returned in | |
3136 | LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of | |
3137 | padding required from the initial offset ptr to the stack slot. | |
6f086dfc | 3138 | |
cc2902df | 3139 | IN_REGS is nonzero if the argument will be passed in registers. It will |
6f086dfc RS |
3140 | never be set if REG_PARM_STACK_SPACE is not defined. |
3141 | ||
3142 | FNDECL is the function in which the argument was defined. | |
3143 | ||
3144 | There are two types of rounding that are done. The first, controlled by | |
3145 | FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument | |
3146 | list to be aligned to the specific boundary (in bits). This rounding | |
3147 | affects the initial and starting offsets, but not the argument size. | |
3148 | ||
3149 | The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY, | |
3150 | optionally rounds the size of the parm to PARM_BOUNDARY. The | |
3151 | initial offset is not affected by this rounding, while the size always | |
3152 | is and the starting offset may be. */ | |
3153 | ||
e7949876 AM |
3154 | /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case; |
3155 | INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's | |
6f086dfc | 3156 | callers pass in the total size of args so far as |
e7949876 | 3157 | INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */ |
6f086dfc | 3158 | |
6f086dfc | 3159 | void |
fa8db1f7 AJ |
3160 | locate_and_pad_parm (enum machine_mode passed_mode, tree type, int in_regs, |
3161 | int partial, tree fndecl ATTRIBUTE_UNUSED, | |
3162 | struct args_size *initial_offset_ptr, | |
3163 | struct locate_and_pad_arg_data *locate) | |
6f086dfc | 3164 | { |
e7949876 AM |
3165 | tree sizetree; |
3166 | enum direction where_pad; | |
3167 | int boundary; | |
3168 | int reg_parm_stack_space = 0; | |
3169 | int part_size_in_regs; | |
6f086dfc RS |
3170 | |
3171 | #ifdef REG_PARM_STACK_SPACE | |
e7949876 | 3172 | reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl); |
e7949876 | 3173 | |
6f086dfc RS |
3174 | /* If we have found a stack parm before we reach the end of the |
3175 | area reserved for registers, skip that area. */ | |
3176 | if (! in_regs) | |
3177 | { | |
6f086dfc RS |
3178 | if (reg_parm_stack_space > 0) |
3179 | { | |
3180 | if (initial_offset_ptr->var) | |
3181 | { | |
3182 | initial_offset_ptr->var | |
3183 | = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr), | |
fed3cef0 | 3184 | ssize_int (reg_parm_stack_space)); |
6f086dfc RS |
3185 | initial_offset_ptr->constant = 0; |
3186 | } | |
3187 | else if (initial_offset_ptr->constant < reg_parm_stack_space) | |
3188 | initial_offset_ptr->constant = reg_parm_stack_space; | |
3189 | } | |
3190 | } | |
3191 | #endif /* REG_PARM_STACK_SPACE */ | |
3192 | ||
e7949876 AM |
3193 | part_size_in_regs = 0; |
3194 | if (reg_parm_stack_space == 0) | |
3195 | part_size_in_regs = ((partial * UNITS_PER_WORD) | |
3196 | / (PARM_BOUNDARY / BITS_PER_UNIT) | |
3197 | * (PARM_BOUNDARY / BITS_PER_UNIT)); | |
3198 | ||
3199 | sizetree | |
3200 | = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode)); | |
3201 | where_pad = FUNCTION_ARG_PADDING (passed_mode, type); | |
3202 | boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type); | |
6e985040 | 3203 | locate->where_pad = where_pad; |
6f086dfc RS |
3204 | |
3205 | #ifdef ARGS_GROW_DOWNWARD | |
e7949876 | 3206 | locate->slot_offset.constant = -initial_offset_ptr->constant; |
6f086dfc | 3207 | if (initial_offset_ptr->var) |
e7949876 AM |
3208 | locate->slot_offset.var = size_binop (MINUS_EXPR, ssize_int (0), |
3209 | initial_offset_ptr->var); | |
9dff28ab | 3210 | |
e7949876 AM |
3211 | { |
3212 | tree s2 = sizetree; | |
3213 | if (where_pad != none | |
3214 | && (!host_integerp (sizetree, 1) | |
3215 | || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY)) | |
3216 | s2 = round_up (s2, PARM_BOUNDARY / BITS_PER_UNIT); | |
3217 | SUB_PARM_SIZE (locate->slot_offset, s2); | |
3218 | } | |
3219 | ||
3220 | locate->slot_offset.constant += part_size_in_regs; | |
9dff28ab JDA |
3221 | |
3222 | if (!in_regs | |
3223 | #ifdef REG_PARM_STACK_SPACE | |
3224 | || REG_PARM_STACK_SPACE (fndecl) > 0 | |
3225 | #endif | |
3226 | ) | |
e7949876 AM |
3227 | pad_to_arg_alignment (&locate->slot_offset, boundary, |
3228 | &locate->alignment_pad); | |
9dff28ab | 3229 | |
e7949876 AM |
3230 | locate->size.constant = (-initial_offset_ptr->constant |
3231 | - locate->slot_offset.constant); | |
6f086dfc | 3232 | if (initial_offset_ptr->var) |
e7949876 AM |
3233 | locate->size.var = size_binop (MINUS_EXPR, |
3234 | size_binop (MINUS_EXPR, | |
3235 | ssize_int (0), | |
3236 | initial_offset_ptr->var), | |
3237 | locate->slot_offset.var); | |
3238 | ||
3239 | /* Pad_below needs the pre-rounded size to know how much to pad | |
3240 | below. */ | |
3241 | locate->offset = locate->slot_offset; | |
3242 | if (where_pad == downward) | |
3243 | pad_below (&locate->offset, passed_mode, sizetree); | |
9dff28ab | 3244 | |
6f086dfc | 3245 | #else /* !ARGS_GROW_DOWNWARD */ |
832ea3b3 FS |
3246 | if (!in_regs |
3247 | #ifdef REG_PARM_STACK_SPACE | |
3248 | || REG_PARM_STACK_SPACE (fndecl) > 0 | |
3249 | #endif | |
3250 | ) | |
e7949876 AM |
3251 | pad_to_arg_alignment (initial_offset_ptr, boundary, |
3252 | &locate->alignment_pad); | |
3253 | locate->slot_offset = *initial_offset_ptr; | |
6f086dfc RS |
3254 | |
3255 | #ifdef PUSH_ROUNDING | |
3256 | if (passed_mode != BLKmode) | |
3257 | sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree))); | |
3258 | #endif | |
3259 | ||
d4b0a7a0 DE |
3260 | /* Pad_below needs the pre-rounded size to know how much to pad below |
3261 | so this must be done before rounding up. */ | |
e7949876 AM |
3262 | locate->offset = locate->slot_offset; |
3263 | if (where_pad == downward) | |
3264 | pad_below (&locate->offset, passed_mode, sizetree); | |
d4b0a7a0 | 3265 | |
6f086dfc | 3266 | if (where_pad != none |
1468899d RK |
3267 | && (!host_integerp (sizetree, 1) |
3268 | || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY)) | |
6f086dfc RS |
3269 | sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT); |
3270 | ||
e7949876 AM |
3271 | ADD_PARM_SIZE (locate->size, sizetree); |
3272 | ||
3273 | locate->size.constant -= part_size_in_regs; | |
6f086dfc RS |
3274 | #endif /* ARGS_GROW_DOWNWARD */ |
3275 | } | |
3276 | ||
e16c591a RS |
3277 | /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY. |
3278 | BOUNDARY is measured in bits, but must be a multiple of a storage unit. */ | |
3279 | ||
6f086dfc | 3280 | static void |
fa8db1f7 AJ |
3281 | pad_to_arg_alignment (struct args_size *offset_ptr, int boundary, |
3282 | struct args_size *alignment_pad) | |
6f086dfc | 3283 | { |
a544cfd2 KG |
3284 | tree save_var = NULL_TREE; |
3285 | HOST_WIDE_INT save_constant = 0; | |
a751cd5b | 3286 | int boundary_in_bytes = boundary / BITS_PER_UNIT; |
a594a19c GK |
3287 | HOST_WIDE_INT sp_offset = STACK_POINTER_OFFSET; |
3288 | ||
3289 | #ifdef SPARC_STACK_BOUNDARY_HACK | |
3290 | /* The sparc port has a bug. It sometimes claims a STACK_BOUNDARY | |
3291 | higher than the real alignment of %sp. However, when it does this, | |
3292 | the alignment of %sp+STACK_POINTER_OFFSET will be STACK_BOUNDARY. | |
3293 | This is a temporary hack while the sparc port is fixed. */ | |
3294 | if (SPARC_STACK_BOUNDARY_HACK) | |
3295 | sp_offset = 0; | |
3296 | #endif | |
4fc026cd | 3297 | |
9399d5c6 | 3298 | if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY) |
4fc026cd CM |
3299 | { |
3300 | save_var = offset_ptr->var; | |
3301 | save_constant = offset_ptr->constant; | |
3302 | } | |
3303 | ||
3304 | alignment_pad->var = NULL_TREE; | |
3305 | alignment_pad->constant = 0; | |
4fc026cd | 3306 | |
6f086dfc RS |
3307 | if (boundary > BITS_PER_UNIT) |
3308 | { | |
3309 | if (offset_ptr->var) | |
3310 | { | |
a594a19c GK |
3311 | tree sp_offset_tree = ssize_int (sp_offset); |
3312 | tree offset = size_binop (PLUS_EXPR, | |
3313 | ARGS_SIZE_TREE (*offset_ptr), | |
3314 | sp_offset_tree); | |
6f086dfc | 3315 | #ifdef ARGS_GROW_DOWNWARD |
a594a19c | 3316 | tree rounded = round_down (offset, boundary / BITS_PER_UNIT); |
6f086dfc | 3317 | #else |
a594a19c | 3318 | tree rounded = round_up (offset, boundary / BITS_PER_UNIT); |
6f086dfc | 3319 | #endif |
a594a19c GK |
3320 | |
3321 | offset_ptr->var = size_binop (MINUS_EXPR, rounded, sp_offset_tree); | |
e7949876 AM |
3322 | /* ARGS_SIZE_TREE includes constant term. */ |
3323 | offset_ptr->constant = 0; | |
dd3f0101 KH |
3324 | if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY) |
3325 | alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var, | |
fed3cef0 | 3326 | save_var); |
6f086dfc RS |
3327 | } |
3328 | else | |
718fe406 | 3329 | { |
a594a19c | 3330 | offset_ptr->constant = -sp_offset + |
6f086dfc | 3331 | #ifdef ARGS_GROW_DOWNWARD |
a594a19c | 3332 | FLOOR_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes); |
6f086dfc | 3333 | #else |
a594a19c | 3334 | CEIL_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes); |
6f086dfc | 3335 | #endif |
718fe406 KH |
3336 | if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY) |
3337 | alignment_pad->constant = offset_ptr->constant - save_constant; | |
3338 | } | |
6f086dfc RS |
3339 | } |
3340 | } | |
3341 | ||
3342 | static void | |
fa8db1f7 | 3343 | pad_below (struct args_size *offset_ptr, enum machine_mode passed_mode, tree sizetree) |
6f086dfc RS |
3344 | { |
3345 | if (passed_mode != BLKmode) | |
3346 | { | |
3347 | if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY) | |
3348 | offset_ptr->constant | |
3349 | += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1) | |
3350 | / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT) | |
3351 | - GET_MODE_SIZE (passed_mode)); | |
3352 | } | |
3353 | else | |
3354 | { | |
3355 | if (TREE_CODE (sizetree) != INTEGER_CST | |
3356 | || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY) | |
3357 | { | |
3358 | /* Round the size up to multiple of PARM_BOUNDARY bits. */ | |
3359 | tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT); | |
3360 | /* Add it in. */ | |
3361 | ADD_PARM_SIZE (*offset_ptr, s2); | |
3362 | SUB_PARM_SIZE (*offset_ptr, sizetree); | |
3363 | } | |
3364 | } | |
3365 | } | |
6f086dfc RS |
3366 | \f |
3367 | /* Walk the tree of blocks describing the binding levels within a function | |
6de9cd9a | 3368 | and warn about variables the might be killed by setjmp or vfork. |
6f086dfc RS |
3369 | This is done after calling flow_analysis and before global_alloc |
3370 | clobbers the pseudo-regs to hard regs. */ | |
3371 | ||
3372 | void | |
6de9cd9a | 3373 | setjmp_vars_warning (tree block) |
6f086dfc | 3374 | { |
b3694847 | 3375 | tree decl, sub; |
6de9cd9a | 3376 | |
6f086dfc RS |
3377 | for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl)) |
3378 | { | |
6de9cd9a | 3379 | if (TREE_CODE (decl) == VAR_DECL |
bc41842b | 3380 | && DECL_RTL_SET_P (decl) |
f8cfc6aa | 3381 | && REG_P (DECL_RTL (decl)) |
6f086dfc | 3382 | && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl)))) |
ddd2d57e RH |
3383 | warning ("%Jvariable '%D' might be clobbered by `longjmp' or `vfork'", |
3384 | decl, decl); | |
6f086dfc | 3385 | } |
6de9cd9a | 3386 | |
6f086dfc | 3387 | for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub)) |
6de9cd9a | 3388 | setjmp_vars_warning (sub); |
6f086dfc RS |
3389 | } |
3390 | ||
6de9cd9a | 3391 | /* Do the appropriate part of setjmp_vars_warning |
6f086dfc RS |
3392 | but for arguments instead of local variables. */ |
3393 | ||
3394 | void | |
fa8db1f7 | 3395 | setjmp_args_warning (void) |
6f086dfc | 3396 | { |
b3694847 | 3397 | tree decl; |
6f086dfc RS |
3398 | for (decl = DECL_ARGUMENTS (current_function_decl); |
3399 | decl; decl = TREE_CHAIN (decl)) | |
3400 | if (DECL_RTL (decl) != 0 | |
f8cfc6aa | 3401 | && REG_P (DECL_RTL (decl)) |
6f086dfc | 3402 | && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl)))) |
ddd2d57e RH |
3403 | warning ("%Jargument '%D' might be clobbered by `longjmp' or `vfork'", |
3404 | decl, decl); | |
6f086dfc RS |
3405 | } |
3406 | ||
6f086dfc | 3407 | \f |
6f086dfc RS |
3408 | /* Convert a stack slot address ADDR for variable VAR |
3409 | (from a containing function) | |
3410 | into an address valid in this function (using a static chain). */ | |
3411 | ||
3412 | rtx | |
fa8db1f7 | 3413 | fix_lexical_addr (rtx addr, tree var) |
6f086dfc RS |
3414 | { |
3415 | rtx basereg; | |
e5e809f4 | 3416 | HOST_WIDE_INT displacement; |
6f086dfc RS |
3417 | tree context = decl_function_context (var); |
3418 | struct function *fp; | |
3419 | rtx base = 0; | |
3420 | ||
3421 | /* If this is the present function, we need not do anything. */ | |
6de9cd9a | 3422 | if (context == current_function_decl) |
6f086dfc RS |
3423 | return addr; |
3424 | ||
eb3ae3e1 | 3425 | fp = find_function_data (context); |
6f086dfc RS |
3426 | |
3427 | /* Decode given address as base reg plus displacement. */ | |
f8cfc6aa | 3428 | if (REG_P (addr)) |
6f086dfc RS |
3429 | basereg = addr, displacement = 0; |
3430 | else if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT) | |
3431 | basereg = XEXP (addr, 0), displacement = INTVAL (XEXP (addr, 1)); | |
3432 | else | |
3433 | abort (); | |
3434 | ||
6f086dfc RS |
3435 | if (base == 0) |
3436 | abort (); | |
3437 | ||
3438 | /* Use same offset, relative to appropriate static chain or argument | |
3439 | pointer. */ | |
3440 | return plus_constant (base, displacement); | |
3441 | } | |
3442 | \f | |
a20612aa RH |
3443 | /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END}, |
3444 | and create duplicate blocks. */ | |
3445 | /* ??? Need an option to either create block fragments or to create | |
3446 | abstract origin duplicates of a source block. It really depends | |
3447 | on what optimization has been performed. */ | |
467456d0 | 3448 | |
116eebd6 | 3449 | void |
fa8db1f7 | 3450 | reorder_blocks (void) |
467456d0 | 3451 | { |
116eebd6 | 3452 | tree block = DECL_INITIAL (current_function_decl); |
18c038b9 | 3453 | varray_type block_stack; |
467456d0 | 3454 | |
1a4450c7 | 3455 | if (block == NULL_TREE) |
116eebd6 | 3456 | return; |
fc289cd1 | 3457 | |
18c038b9 MM |
3458 | VARRAY_TREE_INIT (block_stack, 10, "block_stack"); |
3459 | ||
a20612aa | 3460 | /* Reset the TREE_ASM_WRITTEN bit for all blocks. */ |
6de9cd9a | 3461 | clear_block_marks (block); |
a20612aa | 3462 | |
116eebd6 MM |
3463 | /* Prune the old trees away, so that they don't get in the way. */ |
3464 | BLOCK_SUBBLOCKS (block) = NULL_TREE; | |
3465 | BLOCK_CHAIN (block) = NULL_TREE; | |
fc289cd1 | 3466 | |
a20612aa | 3467 | /* Recreate the block tree from the note nesting. */ |
116eebd6 | 3468 | reorder_blocks_1 (get_insns (), block, &block_stack); |
718fe406 | 3469 | BLOCK_SUBBLOCKS (block) = blocks_nreverse (BLOCK_SUBBLOCKS (block)); |
18c038b9 | 3470 | |
a20612aa RH |
3471 | /* Remove deleted blocks from the block fragment chains. */ |
3472 | reorder_fix_fragments (block); | |
467456d0 RS |
3473 | } |
3474 | ||
a20612aa | 3475 | /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */ |
0a1c58a2 | 3476 | |
6de9cd9a DN |
3477 | void |
3478 | clear_block_marks (tree block) | |
cc1fe44f | 3479 | { |
a20612aa | 3480 | while (block) |
cc1fe44f | 3481 | { |
a20612aa | 3482 | TREE_ASM_WRITTEN (block) = 0; |
6de9cd9a | 3483 | clear_block_marks (BLOCK_SUBBLOCKS (block)); |
a20612aa | 3484 | block = BLOCK_CHAIN (block); |
cc1fe44f DD |
3485 | } |
3486 | } | |
3487 | ||
0a1c58a2 | 3488 | static void |
fa8db1f7 | 3489 | reorder_blocks_1 (rtx insns, tree current_block, varray_type *p_block_stack) |
0a1c58a2 JL |
3490 | { |
3491 | rtx insn; | |
3492 | ||
3493 | for (insn = insns; insn; insn = NEXT_INSN (insn)) | |
3494 | { | |
3495 | if (GET_CODE (insn) == NOTE) | |
3496 | { | |
3497 | if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG) | |
3498 | { | |
3499 | tree block = NOTE_BLOCK (insn); | |
a20612aa RH |
3500 | |
3501 | /* If we have seen this block before, that means it now | |
3502 | spans multiple address regions. Create a new fragment. */ | |
0a1c58a2 JL |
3503 | if (TREE_ASM_WRITTEN (block)) |
3504 | { | |
a20612aa RH |
3505 | tree new_block = copy_node (block); |
3506 | tree origin; | |
3507 | ||
3508 | origin = (BLOCK_FRAGMENT_ORIGIN (block) | |
3509 | ? BLOCK_FRAGMENT_ORIGIN (block) | |
3510 | : block); | |
3511 | BLOCK_FRAGMENT_ORIGIN (new_block) = origin; | |
3512 | BLOCK_FRAGMENT_CHAIN (new_block) | |
3513 | = BLOCK_FRAGMENT_CHAIN (origin); | |
3514 | BLOCK_FRAGMENT_CHAIN (origin) = new_block; | |
3515 | ||
3516 | NOTE_BLOCK (insn) = new_block; | |
3517 | block = new_block; | |
0a1c58a2 | 3518 | } |
a20612aa | 3519 | |
0a1c58a2 JL |
3520 | BLOCK_SUBBLOCKS (block) = 0; |
3521 | TREE_ASM_WRITTEN (block) = 1; | |
339a28b9 ZW |
3522 | /* When there's only one block for the entire function, |
3523 | current_block == block and we mustn't do this, it | |
3524 | will cause infinite recursion. */ | |
3525 | if (block != current_block) | |
3526 | { | |
3527 | BLOCK_SUPERCONTEXT (block) = current_block; | |
3528 | BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block); | |
3529 | BLOCK_SUBBLOCKS (current_block) = block; | |
3530 | current_block = block; | |
3531 | } | |
0a1c58a2 JL |
3532 | VARRAY_PUSH_TREE (*p_block_stack, block); |
3533 | } | |
3534 | else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END) | |
3535 | { | |
3536 | NOTE_BLOCK (insn) = VARRAY_TOP_TREE (*p_block_stack); | |
3537 | VARRAY_POP (*p_block_stack); | |
3538 | BLOCK_SUBBLOCKS (current_block) | |
3539 | = blocks_nreverse (BLOCK_SUBBLOCKS (current_block)); | |
3540 | current_block = BLOCK_SUPERCONTEXT (current_block); | |
3541 | } | |
3542 | } | |
0a1c58a2 JL |
3543 | } |
3544 | } | |
3545 | ||
a20612aa RH |
3546 | /* Rationalize BLOCK_FRAGMENT_ORIGIN. If an origin block no longer |
3547 | appears in the block tree, select one of the fragments to become | |
3548 | the new origin block. */ | |
3549 | ||
3550 | static void | |
fa8db1f7 | 3551 | reorder_fix_fragments (tree block) |
a20612aa RH |
3552 | { |
3553 | while (block) | |
3554 | { | |
3555 | tree dup_origin = BLOCK_FRAGMENT_ORIGIN (block); | |
3556 | tree new_origin = NULL_TREE; | |
3557 | ||
3558 | if (dup_origin) | |
3559 | { | |
3560 | if (! TREE_ASM_WRITTEN (dup_origin)) | |
3561 | { | |
3562 | new_origin = BLOCK_FRAGMENT_CHAIN (dup_origin); | |
797a6ac1 | 3563 | |
a20612aa RH |
3564 | /* Find the first of the remaining fragments. There must |
3565 | be at least one -- the current block. */ | |
3566 | while (! TREE_ASM_WRITTEN (new_origin)) | |
3567 | new_origin = BLOCK_FRAGMENT_CHAIN (new_origin); | |
3568 | BLOCK_FRAGMENT_ORIGIN (new_origin) = NULL_TREE; | |
3569 | } | |
3570 | } | |
3571 | else if (! dup_origin) | |
3572 | new_origin = block; | |
3573 | ||
3574 | /* Re-root the rest of the fragments to the new origin. In the | |
3575 | case that DUP_ORIGIN was null, that means BLOCK was the origin | |
3576 | of a chain of fragments and we want to remove those fragments | |
3577 | that didn't make it to the output. */ | |
3578 | if (new_origin) | |
3579 | { | |
3580 | tree *pp = &BLOCK_FRAGMENT_CHAIN (new_origin); | |
3581 | tree chain = *pp; | |
3582 | ||
3583 | while (chain) | |
3584 | { | |
3585 | if (TREE_ASM_WRITTEN (chain)) | |
3586 | { | |
3587 | BLOCK_FRAGMENT_ORIGIN (chain) = new_origin; | |
3588 | *pp = chain; | |
3589 | pp = &BLOCK_FRAGMENT_CHAIN (chain); | |
3590 | } | |
3591 | chain = BLOCK_FRAGMENT_CHAIN (chain); | |
3592 | } | |
3593 | *pp = NULL_TREE; | |
3594 | } | |
3595 | ||
3596 | reorder_fix_fragments (BLOCK_SUBBLOCKS (block)); | |
3597 | block = BLOCK_CHAIN (block); | |
3598 | } | |
3599 | } | |
3600 | ||
467456d0 RS |
3601 | /* Reverse the order of elements in the chain T of blocks, |
3602 | and return the new head of the chain (old last element). */ | |
3603 | ||
6de9cd9a | 3604 | tree |
fa8db1f7 | 3605 | blocks_nreverse (tree t) |
467456d0 | 3606 | { |
b3694847 | 3607 | tree prev = 0, decl, next; |
467456d0 RS |
3608 | for (decl = t; decl; decl = next) |
3609 | { | |
3610 | next = BLOCK_CHAIN (decl); | |
3611 | BLOCK_CHAIN (decl) = prev; | |
3612 | prev = decl; | |
3613 | } | |
3614 | return prev; | |
3615 | } | |
3616 | ||
18c038b9 MM |
3617 | /* Count the subblocks of the list starting with BLOCK. If VECTOR is |
3618 | non-NULL, list them all into VECTOR, in a depth-first preorder | |
3619 | traversal of the block tree. Also clear TREE_ASM_WRITTEN in all | |
b2a59b15 | 3620 | blocks. */ |
467456d0 RS |
3621 | |
3622 | static int | |
fa8db1f7 | 3623 | all_blocks (tree block, tree *vector) |
467456d0 | 3624 | { |
b2a59b15 MS |
3625 | int n_blocks = 0; |
3626 | ||
a84efb51 JO |
3627 | while (block) |
3628 | { | |
3629 | TREE_ASM_WRITTEN (block) = 0; | |
b2a59b15 | 3630 | |
a84efb51 JO |
3631 | /* Record this block. */ |
3632 | if (vector) | |
3633 | vector[n_blocks] = block; | |
b2a59b15 | 3634 | |
a84efb51 | 3635 | ++n_blocks; |
718fe406 | 3636 | |
a84efb51 JO |
3637 | /* Record the subblocks, and their subblocks... */ |
3638 | n_blocks += all_blocks (BLOCK_SUBBLOCKS (block), | |
3639 | vector ? vector + n_blocks : 0); | |
3640 | block = BLOCK_CHAIN (block); | |
3641 | } | |
467456d0 RS |
3642 | |
3643 | return n_blocks; | |
3644 | } | |
18c038b9 MM |
3645 | |
3646 | /* Return a vector containing all the blocks rooted at BLOCK. The | |
3647 | number of elements in the vector is stored in N_BLOCKS_P. The | |
3648 | vector is dynamically allocated; it is the caller's responsibility | |
3649 | to call `free' on the pointer returned. */ | |
718fe406 | 3650 | |
18c038b9 | 3651 | static tree * |
fa8db1f7 | 3652 | get_block_vector (tree block, int *n_blocks_p) |
18c038b9 MM |
3653 | { |
3654 | tree *block_vector; | |
3655 | ||
3656 | *n_blocks_p = all_blocks (block, NULL); | |
703ad42b | 3657 | block_vector = xmalloc (*n_blocks_p * sizeof (tree)); |
18c038b9 MM |
3658 | all_blocks (block, block_vector); |
3659 | ||
3660 | return block_vector; | |
3661 | } | |
3662 | ||
f83b236e | 3663 | static GTY(()) int next_block_index = 2; |
18c038b9 MM |
3664 | |
3665 | /* Set BLOCK_NUMBER for all the blocks in FN. */ | |
3666 | ||
3667 | void | |
fa8db1f7 | 3668 | number_blocks (tree fn) |
18c038b9 MM |
3669 | { |
3670 | int i; | |
3671 | int n_blocks; | |
3672 | tree *block_vector; | |
3673 | ||
3674 | /* For SDB and XCOFF debugging output, we start numbering the blocks | |
3675 | from 1 within each function, rather than keeping a running | |
3676 | count. */ | |
3677 | #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) | |
b0e3a658 RK |
3678 | if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG) |
3679 | next_block_index = 1; | |
18c038b9 MM |
3680 | #endif |
3681 | ||
3682 | block_vector = get_block_vector (DECL_INITIAL (fn), &n_blocks); | |
3683 | ||
3684 | /* The top-level BLOCK isn't numbered at all. */ | |
3685 | for (i = 1; i < n_blocks; ++i) | |
3686 | /* We number the blocks from two. */ | |
3687 | BLOCK_NUMBER (block_vector[i]) = next_block_index++; | |
3688 | ||
3689 | free (block_vector); | |
3690 | ||
3691 | return; | |
3692 | } | |
df8992f8 RH |
3693 | |
3694 | /* If VAR is present in a subblock of BLOCK, return the subblock. */ | |
3695 | ||
3696 | tree | |
fa8db1f7 | 3697 | debug_find_var_in_block_tree (tree var, tree block) |
df8992f8 RH |
3698 | { |
3699 | tree t; | |
3700 | ||
3701 | for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t)) | |
3702 | if (t == var) | |
3703 | return block; | |
3704 | ||
3705 | for (t = BLOCK_SUBBLOCKS (block); t; t = TREE_CHAIN (t)) | |
3706 | { | |
3707 | tree ret = debug_find_var_in_block_tree (var, t); | |
3708 | if (ret) | |
3709 | return ret; | |
3710 | } | |
3711 | ||
3712 | return NULL_TREE; | |
3713 | } | |
467456d0 | 3714 | \f |
3a70d621 RH |
3715 | /* Allocate a function structure for FNDECL and set its contents |
3716 | to the defaults. */ | |
7a80cf9a | 3717 | |
3a70d621 RH |
3718 | void |
3719 | allocate_struct_function (tree fndecl) | |
6f086dfc | 3720 | { |
3a70d621 | 3721 | tree result; |
6de9cd9a | 3722 | tree fntype = fndecl ? TREE_TYPE (fndecl) : NULL_TREE; |
6f086dfc | 3723 | |
3a70d621 | 3724 | cfun = ggc_alloc_cleared (sizeof (struct function)); |
b384405b | 3725 | |
3a70d621 RH |
3726 | cfun->stack_alignment_needed = STACK_BOUNDARY; |
3727 | cfun->preferred_stack_boundary = STACK_BOUNDARY; | |
6f086dfc | 3728 | |
3a70d621 | 3729 | current_function_funcdef_no = funcdef_no++; |
6f086dfc | 3730 | |
3a70d621 | 3731 | cfun->function_frequency = FUNCTION_FREQUENCY_NORMAL; |
6f086dfc | 3732 | |
3a70d621 RH |
3733 | init_stmt_for_function (); |
3734 | init_eh_for_function (); | |
6f086dfc | 3735 | |
ae2bcd98 | 3736 | lang_hooks.function.init (cfun); |
3a70d621 RH |
3737 | if (init_machine_status) |
3738 | cfun->machine = (*init_machine_status) (); | |
e2ecd91c | 3739 | |
3a70d621 RH |
3740 | if (fndecl == NULL) |
3741 | return; | |
a0871656 | 3742 | |
1da326c3 | 3743 | DECL_STRUCT_FUNCTION (fndecl) = cfun; |
3a70d621 | 3744 | cfun->decl = fndecl; |
6f086dfc | 3745 | |
3a70d621 | 3746 | result = DECL_RESULT (fndecl); |
61f71b34 | 3747 | if (aggregate_value_p (result, fndecl)) |
3a70d621 RH |
3748 | { |
3749 | #ifdef PCC_STATIC_STRUCT_RETURN | |
3750 | current_function_returns_pcc_struct = 1; | |
3751 | #endif | |
3752 | current_function_returns_struct = 1; | |
3753 | } | |
6f086dfc | 3754 | |
3a70d621 | 3755 | current_function_returns_pointer = POINTER_TYPE_P (TREE_TYPE (result)); |
6f086dfc | 3756 | |
6de9cd9a DN |
3757 | current_function_stdarg |
3758 | = (fntype | |
3759 | && TYPE_ARG_TYPES (fntype) != 0 | |
3760 | && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype))) | |
3761 | != void_type_node)); | |
3a70d621 | 3762 | } |
6f086dfc | 3763 | |
3a70d621 | 3764 | /* Reset cfun, and other non-struct-function variables to defaults as |
2067c116 | 3765 | appropriate for emitting rtl at the start of a function. */ |
6f086dfc | 3766 | |
3a70d621 RH |
3767 | static void |
3768 | prepare_function_start (tree fndecl) | |
3769 | { | |
1da326c3 SB |
3770 | if (fndecl && DECL_STRUCT_FUNCTION (fndecl)) |
3771 | cfun = DECL_STRUCT_FUNCTION (fndecl); | |
3a70d621 RH |
3772 | else |
3773 | allocate_struct_function (fndecl); | |
0de456a5 JH |
3774 | init_emit (); |
3775 | init_varasm_status (cfun); | |
3776 | init_expr (); | |
6f086dfc | 3777 | |
3a70d621 | 3778 | cse_not_expected = ! optimize; |
6f086dfc | 3779 | |
3a70d621 RH |
3780 | /* Caller save not needed yet. */ |
3781 | caller_save_needed = 0; | |
6f086dfc | 3782 | |
3a70d621 RH |
3783 | /* We haven't done register allocation yet. */ |
3784 | reg_renumber = 0; | |
6f086dfc | 3785 | |
b384405b BS |
3786 | /* Indicate that we need to distinguish between the return value of the |
3787 | present function and the return value of a function being called. */ | |
3788 | rtx_equal_function_value_matters = 1; | |
3789 | ||
3790 | /* Indicate that we have not instantiated virtual registers yet. */ | |
3791 | virtuals_instantiated = 0; | |
3792 | ||
1b3d8f8a GK |
3793 | /* Indicate that we want CONCATs now. */ |
3794 | generating_concat_p = 1; | |
3795 | ||
b384405b BS |
3796 | /* Indicate we have no need of a frame pointer yet. */ |
3797 | frame_pointer_needed = 0; | |
b384405b BS |
3798 | } |
3799 | ||
3800 | /* Initialize the rtl expansion mechanism so that we can do simple things | |
3801 | like generate sequences. This is used to provide a context during global | |
3802 | initialization of some passes. */ | |
3803 | void | |
fa8db1f7 | 3804 | init_dummy_function_start (void) |
b384405b | 3805 | { |
3a70d621 | 3806 | prepare_function_start (NULL); |
b384405b BS |
3807 | } |
3808 | ||
3809 | /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node) | |
3810 | and initialize static variables for generating RTL for the statements | |
3811 | of the function. */ | |
3812 | ||
3813 | void | |
fa8db1f7 | 3814 | init_function_start (tree subr) |
b384405b | 3815 | { |
3a70d621 | 3816 | prepare_function_start (subr); |
b384405b | 3817 | |
ee6b0296 NS |
3818 | /* Prevent ever trying to delete the first instruction of a |
3819 | function. Also tell final how to output a linenum before the | |
3820 | function prologue. Note linenums could be missing, e.g. when | |
3821 | compiling a Java .class file. */ | |
3c20847b | 3822 | if (! DECL_IS_BUILTIN (subr)) |
f31686a3 | 3823 | emit_line_note (DECL_SOURCE_LOCATION (subr)); |
6f086dfc RS |
3824 | |
3825 | /* Make sure first insn is a note even if we don't want linenums. | |
3826 | This makes sure the first insn will never be deleted. | |
3827 | Also, final expects a note to appear there. */ | |
2e040219 | 3828 | emit_note (NOTE_INSN_DELETED); |
6f086dfc | 3829 | |
6f086dfc RS |
3830 | /* Warn if this value is an aggregate type, |
3831 | regardless of which calling convention we are using for it. */ | |
3832 | if (warn_aggregate_return | |
05e3bdb9 | 3833 | && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr)))) |
6f086dfc | 3834 | warning ("function returns an aggregate"); |
49ad7cfa | 3835 | } |
5c7675e9 | 3836 | |
49ad7cfa BS |
3837 | /* Make sure all values used by the optimization passes have sane |
3838 | defaults. */ | |
3839 | void | |
fa8db1f7 | 3840 | init_function_for_compilation (void) |
49ad7cfa BS |
3841 | { |
3842 | reg_renumber = 0; | |
0a1c58a2 | 3843 | |
5c7675e9 | 3844 | /* No prologue/epilogue insns yet. */ |
0a1c58a2 JL |
3845 | VARRAY_GROW (prologue, 0); |
3846 | VARRAY_GROW (epilogue, 0); | |
3847 | VARRAY_GROW (sibcall_epilogue, 0); | |
6f086dfc RS |
3848 | } |
3849 | ||
6f086dfc RS |
3850 | /* Expand a call to __main at the beginning of a possible main function. */ |
3851 | ||
e2fd1d94 JM |
3852 | #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main) |
3853 | #undef HAS_INIT_SECTION | |
3854 | #define HAS_INIT_SECTION | |
3855 | #endif | |
3856 | ||
6f086dfc | 3857 | void |
fa8db1f7 | 3858 | expand_main_function (void) |
6f086dfc | 3859 | { |
1d482056 RH |
3860 | #ifdef FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN |
3861 | if (FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN) | |
3862 | { | |
3863 | int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; | |
8a723db2 | 3864 | rtx tmp, seq; |
1d482056 | 3865 | |
8a723db2 | 3866 | start_sequence (); |
ef89d648 | 3867 | /* Forcibly align the stack. */ |
1d482056 | 3868 | #ifdef STACK_GROWS_DOWNWARD |
ef89d648 ZW |
3869 | tmp = expand_simple_binop (Pmode, AND, stack_pointer_rtx, GEN_INT(-align), |
3870 | stack_pointer_rtx, 1, OPTAB_WIDEN); | |
1d482056 | 3871 | #else |
ef89d648 ZW |
3872 | tmp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx, |
3873 | GEN_INT (align - 1), NULL_RTX, 1, OPTAB_WIDEN); | |
3874 | tmp = expand_simple_binop (Pmode, AND, tmp, GEN_INT (-align), | |
3875 | stack_pointer_rtx, 1, OPTAB_WIDEN); | |
1d482056 RH |
3876 | #endif |
3877 | if (tmp != stack_pointer_rtx) | |
3878 | emit_move_insn (stack_pointer_rtx, tmp); | |
797a6ac1 | 3879 | |
1d482056 RH |
3880 | /* Enlist allocate_dynamic_stack_space to pick up the pieces. */ |
3881 | tmp = force_reg (Pmode, const0_rtx); | |
3882 | allocate_dynamic_stack_space (tmp, NULL_RTX, BIGGEST_ALIGNMENT); | |
2f937369 | 3883 | seq = get_insns (); |
8a723db2 DD |
3884 | end_sequence (); |
3885 | ||
3886 | for (tmp = get_last_insn (); tmp; tmp = PREV_INSN (tmp)) | |
3887 | if (NOTE_P (tmp) && NOTE_LINE_NUMBER (tmp) == NOTE_INSN_FUNCTION_BEG) | |
3888 | break; | |
3889 | if (tmp) | |
3890 | emit_insn_before (seq, tmp); | |
3891 | else | |
3892 | emit_insn (seq); | |
1d482056 RH |
3893 | } |
3894 | #endif | |
3895 | ||
3896 | #ifndef HAS_INIT_SECTION | |
68d28100 | 3897 | emit_library_call (init_one_libfunc (NAME__MAIN), LCT_NORMAL, VOIDmode, 0); |
1d482056 | 3898 | #endif |
6f086dfc RS |
3899 | } |
3900 | \f | |
1f731749 MM |
3901 | /* The PENDING_SIZES represent the sizes of variable-sized types. |
3902 | Create RTL for the various sizes now (using temporary variables), | |
3903 | so that we can refer to the sizes from the RTL we are generating | |
3904 | for the current function. The PENDING_SIZES are a TREE_LIST. The | |
3905 | TREE_VALUE of each node is a SAVE_EXPR. */ | |
3906 | ||
3907 | void | |
fa8db1f7 | 3908 | expand_pending_sizes (tree pending_sizes) |
1f731749 MM |
3909 | { |
3910 | tree tem; | |
3911 | ||
3912 | /* Evaluate now the sizes of any types declared among the arguments. */ | |
3913 | for (tem = pending_sizes; tem; tem = TREE_CHAIN (tem)) | |
3914 | { | |
37a08a29 | 3915 | expand_expr (TREE_VALUE (tem), const0_rtx, VOIDmode, 0); |
1f731749 MM |
3916 | /* Flush the queue in case this parameter declaration has |
3917 | side-effects. */ | |
3918 | emit_queue (); | |
3919 | } | |
3920 | } | |
3921 | ||
6f086dfc RS |
3922 | /* Start the RTL for a new function, and set variables used for |
3923 | emitting RTL. | |
3924 | SUBR is the FUNCTION_DECL node. | |
3925 | PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with | |
3926 | the function's parameters, which must be run at any return statement. */ | |
3927 | ||
3928 | void | |
b79c5284 | 3929 | expand_function_start (tree subr) |
6f086dfc | 3930 | { |
6f086dfc RS |
3931 | /* Make sure volatile mem refs aren't considered |
3932 | valid operands of arithmetic insns. */ | |
3933 | init_recog_no_volatile (); | |
3934 | ||
70f4f91c WC |
3935 | current_function_profile |
3936 | = (profile_flag | |
3937 | && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr)); | |
3938 | ||
a157febd GK |
3939 | current_function_limit_stack |
3940 | = (stack_limit_rtx != NULL_RTX && ! DECL_NO_LIMIT_STACK (subr)); | |
3941 | ||
52a11cbf RH |
3942 | /* Make the label for return statements to jump to. Do not special |
3943 | case machines with special return instructions -- they will be | |
3944 | handled later during jump, ifcvt, or epilogue creation. */ | |
6f086dfc | 3945 | return_label = gen_label_rtx (); |
6f086dfc RS |
3946 | |
3947 | /* Initialize rtx used to return the value. */ | |
3948 | /* Do this before assign_parms so that we copy the struct value address | |
3949 | before any library calls that assign parms might generate. */ | |
3950 | ||
3951 | /* Decide whether to return the value in memory or in a register. */ | |
61f71b34 | 3952 | if (aggregate_value_p (DECL_RESULT (subr), subr)) |
6f086dfc RS |
3953 | { |
3954 | /* Returning something that won't go in a register. */ | |
b3694847 | 3955 | rtx value_address = 0; |
6f086dfc RS |
3956 | |
3957 | #ifdef PCC_STATIC_STRUCT_RETURN | |
3958 | if (current_function_returns_pcc_struct) | |
3959 | { | |
3960 | int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr))); | |
3961 | value_address = assemble_static_space (size); | |
3962 | } | |
3963 | else | |
3964 | #endif | |
3965 | { | |
61f71b34 | 3966 | rtx sv = targetm.calls.struct_value_rtx (TREE_TYPE (subr), 1); |
6f086dfc RS |
3967 | /* Expect to be passed the address of a place to store the value. |
3968 | If it is passed as an argument, assign_parms will take care of | |
3969 | it. */ | |
61f71b34 | 3970 | if (sv) |
6f086dfc RS |
3971 | { |
3972 | value_address = gen_reg_rtx (Pmode); | |
61f71b34 | 3973 | emit_move_insn (value_address, sv); |
6f086dfc RS |
3974 | } |
3975 | } | |
3976 | if (value_address) | |
ccdecf58 | 3977 | { |
abde42f7 JH |
3978 | rtx x = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), value_address); |
3979 | set_mem_attributes (x, DECL_RESULT (subr), 1); | |
3980 | SET_DECL_RTL (DECL_RESULT (subr), x); | |
ccdecf58 | 3981 | } |
6f086dfc RS |
3982 | } |
3983 | else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode) | |
3984 | /* If return mode is void, this decl rtl should not be used. */ | |
19e7881c | 3985 | SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX); |
d5bf1143 | 3986 | else |
a53e14c0 | 3987 | { |
d5bf1143 RH |
3988 | /* Compute the return values into a pseudo reg, which we will copy |
3989 | into the true return register after the cleanups are done. */ | |
db3c0315 MM |
3990 | |
3991 | /* In order to figure out what mode to use for the pseudo, we | |
3992 | figure out what the mode of the eventual return register will | |
3993 | actually be, and use that. */ | |
3994 | rtx hard_reg | |
3995 | = hard_function_value (TREE_TYPE (DECL_RESULT (subr)), | |
3996 | subr, 1); | |
3997 | ||
80a480ca | 3998 | /* Structures that are returned in registers are not aggregate_value_p, |
084a1106 JDA |
3999 | so we may see a PARALLEL or a REG. */ |
4000 | if (REG_P (hard_reg)) | |
4001 | SET_DECL_RTL (DECL_RESULT (subr), gen_reg_rtx (GET_MODE (hard_reg))); | |
4002 | else if (GET_CODE (hard_reg) == PARALLEL) | |
4003 | SET_DECL_RTL (DECL_RESULT (subr), gen_group_rtx (hard_reg)); | |
80a480ca | 4004 | else |
084a1106 | 4005 | abort (); |
a53e14c0 | 4006 | |
084a1106 JDA |
4007 | /* Set DECL_REGISTER flag so that expand_function_end will copy the |
4008 | result to the real return register(s). */ | |
4009 | DECL_REGISTER (DECL_RESULT (subr)) = 1; | |
a53e14c0 | 4010 | } |
6f086dfc RS |
4011 | |
4012 | /* Initialize rtx for parameters and local variables. | |
4013 | In some cases this requires emitting insns. */ | |
0d1416c6 | 4014 | assign_parms (subr); |
6f086dfc | 4015 | |
6de9cd9a DN |
4016 | /* If function gets a static chain arg, store it. */ |
4017 | if (cfun->static_chain_decl) | |
4018 | { | |
7e140280 RH |
4019 | tree parm = cfun->static_chain_decl; |
4020 | rtx local = gen_reg_rtx (Pmode); | |
4021 | ||
4022 | set_decl_incoming_rtl (parm, static_chain_incoming_rtx); | |
4023 | SET_DECL_RTL (parm, local); | |
4024 | maybe_set_unchanging (local, parm); | |
4025 | mark_reg_pointer (local, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm)))); | |
6de9cd9a | 4026 | |
7e140280 | 4027 | emit_move_insn (local, static_chain_incoming_rtx); |
6de9cd9a DN |
4028 | } |
4029 | ||
4030 | /* If the function receives a non-local goto, then store the | |
4031 | bits we need to restore the frame pointer. */ | |
4032 | if (cfun->nonlocal_goto_save_area) | |
4033 | { | |
4034 | tree t_save; | |
4035 | rtx r_save; | |
4036 | ||
4037 | /* ??? We need to do this save early. Unfortunately here is | |
4038 | before the frame variable gets declared. Help out... */ | |
4039 | expand_var (TREE_OPERAND (cfun->nonlocal_goto_save_area, 0)); | |
4040 | ||
4041 | t_save = build (ARRAY_REF, ptr_type_node, cfun->nonlocal_goto_save_area, | |
44de5aeb | 4042 | integer_zero_node, NULL_TREE, NULL_TREE); |
6de9cd9a | 4043 | r_save = expand_expr (t_save, NULL_RTX, VOIDmode, EXPAND_WRITE); |
f0c51a1e | 4044 | |
6de9cd9a DN |
4045 | emit_move_insn (r_save, virtual_stack_vars_rtx); |
4046 | update_nonlocal_goto_save_area (); | |
4047 | } | |
f0c51a1e | 4048 | |
6f086dfc RS |
4049 | /* The following was moved from init_function_start. |
4050 | The move is supposed to make sdb output more accurate. */ | |
4051 | /* Indicate the beginning of the function body, | |
4052 | as opposed to parm setup. */ | |
2e040219 | 4053 | emit_note (NOTE_INSN_FUNCTION_BEG); |
6f086dfc | 4054 | |
6f086dfc | 4055 | if (GET_CODE (get_last_insn ()) != NOTE) |
2e040219 | 4056 | emit_note (NOTE_INSN_DELETED); |
6f086dfc RS |
4057 | parm_birth_insn = get_last_insn (); |
4058 | ||
70f4f91c | 4059 | if (current_function_profile) |
f6f315fe | 4060 | { |
f6f315fe | 4061 | #ifdef PROFILE_HOOK |
df696a75 | 4062 | PROFILE_HOOK (current_function_funcdef_no); |
411707f4 | 4063 | #endif |
f6f315fe | 4064 | } |
411707f4 | 4065 | |
6f086dfc RS |
4066 | /* After the display initializations is where the tail-recursion label |
4067 | should go, if we end up needing one. Ensure we have a NOTE here | |
4068 | since some things (like trampolines) get placed before this. */ | |
2e040219 | 4069 | tail_recursion_reentry = emit_note (NOTE_INSN_DELETED); |
6f086dfc RS |
4070 | |
4071 | /* Evaluate now the sizes of any types declared among the arguments. */ | |
1f731749 | 4072 | expand_pending_sizes (nreverse (get_pending_sizes ())); |
6f086dfc RS |
4073 | |
4074 | /* Make sure there is a line number after the function entry setup code. */ | |
4075 | force_next_line_note (); | |
4076 | } | |
4077 | \f | |
49ad7cfa BS |
4078 | /* Undo the effects of init_dummy_function_start. */ |
4079 | void | |
fa8db1f7 | 4080 | expand_dummy_function_end (void) |
49ad7cfa BS |
4081 | { |
4082 | /* End any sequences that failed to be closed due to syntax errors. */ | |
4083 | while (in_sequence_p ()) | |
4084 | end_sequence (); | |
4085 | ||
4086 | /* Outside function body, can't compute type's actual size | |
4087 | until next function's body starts. */ | |
fa51b01b | 4088 | |
01d939e8 BS |
4089 | free_after_parsing (cfun); |
4090 | free_after_compilation (cfun); | |
01d939e8 | 4091 | cfun = 0; |
49ad7cfa BS |
4092 | } |
4093 | ||
c13fde05 RH |
4094 | /* Call DOIT for each hard register used as a return value from |
4095 | the current function. */ | |
bd695e1e RH |
4096 | |
4097 | void | |
fa8db1f7 | 4098 | diddle_return_value (void (*doit) (rtx, void *), void *arg) |
bd695e1e | 4099 | { |
c13fde05 RH |
4100 | rtx outgoing = current_function_return_rtx; |
4101 | ||
4102 | if (! outgoing) | |
4103 | return; | |
bd695e1e | 4104 | |
f8cfc6aa | 4105 | if (REG_P (outgoing)) |
c13fde05 RH |
4106 | (*doit) (outgoing, arg); |
4107 | else if (GET_CODE (outgoing) == PARALLEL) | |
4108 | { | |
4109 | int i; | |
bd695e1e | 4110 | |
c13fde05 RH |
4111 | for (i = 0; i < XVECLEN (outgoing, 0); i++) |
4112 | { | |
4113 | rtx x = XEXP (XVECEXP (outgoing, 0, i), 0); | |
4114 | ||
f8cfc6aa | 4115 | if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER) |
c13fde05 | 4116 | (*doit) (x, arg); |
bd695e1e RH |
4117 | } |
4118 | } | |
4119 | } | |
4120 | ||
c13fde05 | 4121 | static void |
fa8db1f7 | 4122 | do_clobber_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED) |
c13fde05 RH |
4123 | { |
4124 | emit_insn (gen_rtx_CLOBBER (VOIDmode, reg)); | |
4125 | } | |
4126 | ||
4127 | void | |
fa8db1f7 | 4128 | clobber_return_register (void) |
c13fde05 RH |
4129 | { |
4130 | diddle_return_value (do_clobber_return_reg, NULL); | |
9c65bbf4 JH |
4131 | |
4132 | /* In case we do use pseudo to return value, clobber it too. */ | |
4133 | if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl))) | |
4134 | { | |
4135 | tree decl_result = DECL_RESULT (current_function_decl); | |
4136 | rtx decl_rtl = DECL_RTL (decl_result); | |
4137 | if (REG_P (decl_rtl) && REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER) | |
4138 | { | |
4139 | do_clobber_return_reg (decl_rtl, NULL); | |
4140 | } | |
4141 | } | |
c13fde05 RH |
4142 | } |
4143 | ||
4144 | static void | |
fa8db1f7 | 4145 | do_use_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED) |
c13fde05 RH |
4146 | { |
4147 | emit_insn (gen_rtx_USE (VOIDmode, reg)); | |
4148 | } | |
4149 | ||
4150 | void | |
fa8db1f7 | 4151 | use_return_register (void) |
c13fde05 RH |
4152 | { |
4153 | diddle_return_value (do_use_return_reg, NULL); | |
4154 | } | |
4155 | ||
902edd36 JH |
4156 | /* Possibly warn about unused parameters. */ |
4157 | void | |
4158 | do_warn_unused_parameter (tree fn) | |
4159 | { | |
4160 | tree decl; | |
4161 | ||
4162 | for (decl = DECL_ARGUMENTS (fn); | |
4163 | decl; decl = TREE_CHAIN (decl)) | |
4164 | if (!TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL | |
4165 | && DECL_NAME (decl) && !DECL_ARTIFICIAL (decl)) | |
4166 | warning ("%Junused parameter '%D'", decl, decl); | |
4167 | } | |
4168 | ||
e2500fed GK |
4169 | static GTY(()) rtx initial_trampoline; |
4170 | ||
71c0e7fc | 4171 | /* Generate RTL for the end of the current function. */ |
6f086dfc RS |
4172 | |
4173 | void | |
fa8db1f7 | 4174 | expand_function_end (void) |
6f086dfc | 4175 | { |
932f0847 | 4176 | rtx clobber_after; |
6f086dfc | 4177 | |
49ad7cfa BS |
4178 | finish_expr_for_function (); |
4179 | ||
964be02f RH |
4180 | /* If arg_pointer_save_area was referenced only from a nested |
4181 | function, we will not have initialized it yet. Do that now. */ | |
4182 | if (arg_pointer_save_area && ! cfun->arg_pointer_save_area_init) | |
4183 | get_arg_pointer_save_area (cfun); | |
4184 | ||
11044f66 RK |
4185 | /* If we are doing stack checking and this function makes calls, |
4186 | do a stack probe at the start of the function to ensure we have enough | |
4187 | space for another stack frame. */ | |
4188 | if (flag_stack_check && ! STACK_CHECK_BUILTIN) | |
4189 | { | |
4190 | rtx insn, seq; | |
4191 | ||
4192 | for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) | |
4193 | if (GET_CODE (insn) == CALL_INSN) | |
4194 | { | |
4195 | start_sequence (); | |
4196 | probe_stack_range (STACK_CHECK_PROTECT, | |
4197 | GEN_INT (STACK_CHECK_MAX_FRAME_SIZE)); | |
4198 | seq = get_insns (); | |
4199 | end_sequence (); | |
2f937369 | 4200 | emit_insn_before (seq, tail_recursion_reentry); |
11044f66 RK |
4201 | break; |
4202 | } | |
4203 | } | |
4204 | ||
902edd36 JH |
4205 | /* Possibly warn about unused parameters. |
4206 | When frontend does unit-at-a-time, the warning is already | |
4207 | issued at finalization time. */ | |
4208 | if (warn_unused_parameter | |
4209 | && !lang_hooks.callgraph.expand_function) | |
4210 | do_warn_unused_parameter (current_function_decl); | |
6f086dfc | 4211 | |
6f086dfc RS |
4212 | /* End any sequences that failed to be closed due to syntax errors. */ |
4213 | while (in_sequence_p ()) | |
5f4f0e22 | 4214 | end_sequence (); |
6f086dfc | 4215 | |
6f086dfc RS |
4216 | clear_pending_stack_adjust (); |
4217 | do_pending_stack_adjust (); | |
4218 | ||
ffad84cd AH |
4219 | /* @@@ This is a kludge. We want to ensure that instructions that |
4220 | may trap are not moved into the epilogue by scheduling, because | |
4221 | we don't always emit unwind information for the epilogue. | |
4222 | However, not all machine descriptions define a blockage insn, so | |
4223 | emit an ASM_INPUT to act as one. */ | |
4224 | if (flag_non_call_exceptions) | |
4225 | emit_insn (gen_rtx_ASM_INPUT (VOIDmode, "")); | |
4226 | ||
6f086dfc RS |
4227 | /* Mark the end of the function body. |
4228 | If control reaches this insn, the function can drop through | |
4229 | without returning a value. */ | |
2e040219 | 4230 | emit_note (NOTE_INSN_FUNCTION_END); |
6f086dfc | 4231 | |
82e415a3 DE |
4232 | /* Must mark the last line number note in the function, so that the test |
4233 | coverage code can avoid counting the last line twice. This just tells | |
4234 | the code to ignore the immediately following line note, since there | |
4235 | already exists a copy of this note somewhere above. This line number | |
4236 | note is still needed for debugging though, so we can't delete it. */ | |
4237 | if (flag_test_coverage) | |
2e040219 | 4238 | emit_note (NOTE_INSN_REPEATED_LINE_NUMBER); |
82e415a3 | 4239 | |
6f086dfc RS |
4240 | /* Output a linenumber for the end of the function. |
4241 | SDB depends on this. */ | |
0cea056b NS |
4242 | force_next_line_note (); |
4243 | emit_line_note (input_location); | |
6f086dfc | 4244 | |
fbffc70a | 4245 | /* Before the return label (if any), clobber the return |
a1f300c0 | 4246 | registers so that they are not propagated live to the rest of |
fbffc70a GK |
4247 | the function. This can only happen with functions that drop |
4248 | through; if there had been a return statement, there would | |
932f0847 JH |
4249 | have either been a return rtx, or a jump to the return label. |
4250 | ||
4251 | We delay actual code generation after the current_function_value_rtx | |
4252 | is computed. */ | |
4253 | clobber_after = get_last_insn (); | |
fbffc70a | 4254 | |
6f086dfc RS |
4255 | /* Output the label for the actual return from the function, |
4256 | if one is expected. This happens either because a function epilogue | |
4257 | is used instead of a return instruction, or because a return was done | |
4258 | with a goto in order to run local cleanups, or because of pcc-style | |
4259 | structure returning. */ | |
6f086dfc | 4260 | if (return_label) |
fbffc70a | 4261 | emit_label (return_label); |
6f086dfc | 4262 | |
52a11cbf RH |
4263 | /* Let except.c know where it should emit the call to unregister |
4264 | the function context for sjlj exceptions. */ | |
4265 | if (flag_exceptions && USING_SJLJ_EXCEPTIONS) | |
4266 | sjlj_emit_function_exit_after (get_last_insn ()); | |
4267 | ||
6f086dfc RS |
4268 | /* If we had calls to alloca, and this machine needs |
4269 | an accurate stack pointer to exit the function, | |
4270 | insert some code to save and restore the stack pointer. */ | |
9d05bbce KH |
4271 | if (! EXIT_IGNORE_STACK |
4272 | && current_function_calls_alloca) | |
4273 | { | |
4274 | rtx tem = 0; | |
59257ff7 | 4275 | |
9d05bbce KH |
4276 | emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn); |
4277 | emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX); | |
4278 | } | |
6f086dfc | 4279 | |
3e4eac3f RH |
4280 | /* If scalar return value was computed in a pseudo-reg, or was a named |
4281 | return value that got dumped to the stack, copy that to the hard | |
4282 | return register. */ | |
19e7881c | 4283 | if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl))) |
6f086dfc | 4284 | { |
3e4eac3f RH |
4285 | tree decl_result = DECL_RESULT (current_function_decl); |
4286 | rtx decl_rtl = DECL_RTL (decl_result); | |
4287 | ||
4288 | if (REG_P (decl_rtl) | |
4289 | ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER | |
4290 | : DECL_REGISTER (decl_result)) | |
4291 | { | |
ce5e43d0 | 4292 | rtx real_decl_rtl = current_function_return_rtx; |
6f086dfc | 4293 | |
ce5e43d0 JJ |
4294 | /* This should be set in assign_parms. */ |
4295 | if (! REG_FUNCTION_VALUE_P (real_decl_rtl)) | |
4296 | abort (); | |
3e4eac3f RH |
4297 | |
4298 | /* If this is a BLKmode structure being returned in registers, | |
4299 | then use the mode computed in expand_return. Note that if | |
797a6ac1 | 4300 | decl_rtl is memory, then its mode may have been changed, |
3e4eac3f RH |
4301 | but that current_function_return_rtx has not. */ |
4302 | if (GET_MODE (real_decl_rtl) == BLKmode) | |
ce5e43d0 | 4303 | PUT_MODE (real_decl_rtl, GET_MODE (decl_rtl)); |
3e4eac3f RH |
4304 | |
4305 | /* If a named return value dumped decl_return to memory, then | |
797a6ac1 | 4306 | we may need to re-do the PROMOTE_MODE signed/unsigned |
3e4eac3f RH |
4307 | extension. */ |
4308 | if (GET_MODE (real_decl_rtl) != GET_MODE (decl_rtl)) | |
4309 | { | |
8df83eae | 4310 | int unsignedp = TYPE_UNSIGNED (TREE_TYPE (decl_result)); |
3e4eac3f | 4311 | |
61f71b34 DD |
4312 | if (targetm.calls.promote_function_return (TREE_TYPE (current_function_decl))) |
4313 | promote_mode (TREE_TYPE (decl_result), GET_MODE (decl_rtl), | |
4314 | &unsignedp, 1); | |
3e4eac3f RH |
4315 | |
4316 | convert_move (real_decl_rtl, decl_rtl, unsignedp); | |
4317 | } | |
aa570f54 | 4318 | else if (GET_CODE (real_decl_rtl) == PARALLEL) |
084a1106 JDA |
4319 | { |
4320 | /* If expand_function_start has created a PARALLEL for decl_rtl, | |
4321 | move the result to the real return registers. Otherwise, do | |
4322 | a group load from decl_rtl for a named return. */ | |
4323 | if (GET_CODE (decl_rtl) == PARALLEL) | |
4324 | emit_group_move (real_decl_rtl, decl_rtl); | |
4325 | else | |
4326 | emit_group_load (real_decl_rtl, decl_rtl, | |
6e985040 | 4327 | TREE_TYPE (decl_result), |
084a1106 JDA |
4328 | int_size_in_bytes (TREE_TYPE (decl_result))); |
4329 | } | |
3e4eac3f RH |
4330 | else |
4331 | emit_move_insn (real_decl_rtl, decl_rtl); | |
3e4eac3f | 4332 | } |
6f086dfc RS |
4333 | } |
4334 | ||
4335 | /* If returning a structure, arrange to return the address of the value | |
4336 | in a place where debuggers expect to find it. | |
4337 | ||
4338 | If returning a structure PCC style, | |
4339 | the caller also depends on this value. | |
4340 | And current_function_returns_pcc_struct is not necessarily set. */ | |
4341 | if (current_function_returns_struct | |
4342 | || current_function_returns_pcc_struct) | |
4343 | { | |
d1608933 RK |
4344 | rtx value_address |
4345 | = XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0); | |
6f086dfc RS |
4346 | tree type = TREE_TYPE (DECL_RESULT (current_function_decl)); |
4347 | #ifdef FUNCTION_OUTGOING_VALUE | |
4348 | rtx outgoing | |
4349 | = FUNCTION_OUTGOING_VALUE (build_pointer_type (type), | |
4350 | current_function_decl); | |
4351 | #else | |
4352 | rtx outgoing | |
d1608933 | 4353 | = FUNCTION_VALUE (build_pointer_type (type), current_function_decl); |
6f086dfc RS |
4354 | #endif |
4355 | ||
4356 | /* Mark this as a function return value so integrate will delete the | |
4357 | assignment and USE below when inlining this function. */ | |
4358 | REG_FUNCTION_VALUE_P (outgoing) = 1; | |
4359 | ||
d1608933 | 4360 | /* The address may be ptr_mode and OUTGOING may be Pmode. */ |
5ae6cd0d MM |
4361 | value_address = convert_memory_address (GET_MODE (outgoing), |
4362 | value_address); | |
d1608933 | 4363 | |
6f086dfc | 4364 | emit_move_insn (outgoing, value_address); |
d1608933 RK |
4365 | |
4366 | /* Show return register used to hold result (in this case the address | |
4367 | of the result. */ | |
4368 | current_function_return_rtx = outgoing; | |
6f086dfc RS |
4369 | } |
4370 | ||
52a11cbf RH |
4371 | /* If this is an implementation of throw, do what's necessary to |
4372 | communicate between __builtin_eh_return and the epilogue. */ | |
4373 | expand_eh_return (); | |
4374 | ||
932f0847 JH |
4375 | /* Emit the actual code to clobber return register. */ |
4376 | { | |
4377 | rtx seq, after; | |
797a6ac1 | 4378 | |
932f0847 JH |
4379 | start_sequence (); |
4380 | clobber_return_register (); | |
2f937369 | 4381 | seq = get_insns (); |
932f0847 JH |
4382 | end_sequence (); |
4383 | ||
4384 | after = emit_insn_after (seq, clobber_after); | |
932f0847 JH |
4385 | } |
4386 | ||
6e3077c6 EB |
4387 | /* Output the label for the naked return from the function, if one is |
4388 | expected. This is currently used only by __builtin_return. */ | |
4389 | if (naked_return_label) | |
4390 | emit_label (naked_return_label); | |
4391 | ||
c13fde05 RH |
4392 | /* ??? This should no longer be necessary since stupid is no longer with |
4393 | us, but there are some parts of the compiler (eg reload_combine, and | |
4394 | sh mach_dep_reorg) that still try and compute their own lifetime info | |
4395 | instead of using the general framework. */ | |
4396 | use_return_register (); | |
4397 | ||
6f086dfc RS |
4398 | /* Fix up any gotos that jumped out to the outermost |
4399 | binding level of the function. | |
4400 | Must follow emitting RETURN_LABEL. */ | |
4401 | ||
4402 | /* If you have any cleanups to do at this point, | |
4403 | and they need to create temporary variables, | |
4404 | then you will lose. */ | |
e15679f8 | 4405 | expand_fixups (get_insns ()); |
6f086dfc | 4406 | } |
278ed218 RH |
4407 | |
4408 | rtx | |
fa8db1f7 | 4409 | get_arg_pointer_save_area (struct function *f) |
278ed218 RH |
4410 | { |
4411 | rtx ret = f->x_arg_pointer_save_area; | |
4412 | ||
4413 | if (! ret) | |
4414 | { | |
278ed218 RH |
4415 | ret = assign_stack_local_1 (Pmode, GET_MODE_SIZE (Pmode), 0, f); |
4416 | f->x_arg_pointer_save_area = ret; | |
964be02f RH |
4417 | } |
4418 | ||
4419 | if (f == cfun && ! f->arg_pointer_save_area_init) | |
4420 | { | |
4421 | rtx seq; | |
278ed218 | 4422 | |
797a6ac1 | 4423 | /* Save the arg pointer at the beginning of the function. The |
964be02f | 4424 | generated stack slot may not be a valid memory address, so we |
278ed218 RH |
4425 | have to check it and fix it if necessary. */ |
4426 | start_sequence (); | |
4427 | emit_move_insn (validize_mem (ret), virtual_incoming_args_rtx); | |
2f937369 | 4428 | seq = get_insns (); |
278ed218 RH |
4429 | end_sequence (); |
4430 | ||
964be02f RH |
4431 | push_topmost_sequence (); |
4432 | emit_insn_after (seq, get_insns ()); | |
4433 | pop_topmost_sequence (); | |
278ed218 RH |
4434 | } |
4435 | ||
4436 | return ret; | |
4437 | } | |
bdac5f58 | 4438 | \f |
2f937369 DM |
4439 | /* Extend a vector that records the INSN_UIDs of INSNS |
4440 | (a list of one or more insns). */ | |
bdac5f58 | 4441 | |
0a1c58a2 | 4442 | static void |
fa8db1f7 | 4443 | record_insns (rtx insns, varray_type *vecp) |
bdac5f58 | 4444 | { |
2f937369 DM |
4445 | int i, len; |
4446 | rtx tmp; | |
0a1c58a2 | 4447 | |
2f937369 DM |
4448 | tmp = insns; |
4449 | len = 0; | |
4450 | while (tmp != NULL_RTX) | |
4451 | { | |
4452 | len++; | |
4453 | tmp = NEXT_INSN (tmp); | |
bdac5f58 | 4454 | } |
2f937369 DM |
4455 | |
4456 | i = VARRAY_SIZE (*vecp); | |
4457 | VARRAY_GROW (*vecp, i + len); | |
4458 | tmp = insns; | |
4459 | while (tmp != NULL_RTX) | |
bdac5f58 | 4460 | { |
2f937369 DM |
4461 | VARRAY_INT (*vecp, i) = INSN_UID (tmp); |
4462 | i++; | |
4463 | tmp = NEXT_INSN (tmp); | |
bdac5f58 | 4464 | } |
bdac5f58 TW |
4465 | } |
4466 | ||
589fe865 | 4467 | /* Set the locator of the insn chain starting at INSN to LOC. */ |
0435312e | 4468 | static void |
fa8db1f7 | 4469 | set_insn_locators (rtx insn, int loc) |
0435312e JH |
4470 | { |
4471 | while (insn != NULL_RTX) | |
4472 | { | |
4473 | if (INSN_P (insn)) | |
4474 | INSN_LOCATOR (insn) = loc; | |
4475 | insn = NEXT_INSN (insn); | |
4476 | } | |
4477 | } | |
4478 | ||
2f937369 DM |
4479 | /* Determine how many INSN_UIDs in VEC are part of INSN. Because we can |
4480 | be running after reorg, SEQUENCE rtl is possible. */ | |
bdac5f58 | 4481 | |
10914065 | 4482 | static int |
fa8db1f7 | 4483 | contains (rtx insn, varray_type vec) |
bdac5f58 | 4484 | { |
b3694847 | 4485 | int i, j; |
bdac5f58 TW |
4486 | |
4487 | if (GET_CODE (insn) == INSN | |
4488 | && GET_CODE (PATTERN (insn)) == SEQUENCE) | |
4489 | { | |
10914065 | 4490 | int count = 0; |
bdac5f58 | 4491 | for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) |
0a1c58a2 JL |
4492 | for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j) |
4493 | if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) == VARRAY_INT (vec, j)) | |
10914065 TW |
4494 | count++; |
4495 | return count; | |
bdac5f58 TW |
4496 | } |
4497 | else | |
4498 | { | |
0a1c58a2 JL |
4499 | for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j) |
4500 | if (INSN_UID (insn) == VARRAY_INT (vec, j)) | |
10914065 | 4501 | return 1; |
bdac5f58 TW |
4502 | } |
4503 | return 0; | |
4504 | } | |
5c7675e9 RH |
4505 | |
4506 | int | |
fa8db1f7 | 4507 | prologue_epilogue_contains (rtx insn) |
5c7675e9 | 4508 | { |
0a1c58a2 | 4509 | if (contains (insn, prologue)) |
5c7675e9 | 4510 | return 1; |
0a1c58a2 | 4511 | if (contains (insn, epilogue)) |
5c7675e9 RH |
4512 | return 1; |
4513 | return 0; | |
4514 | } | |
bdac5f58 | 4515 | |
0a1c58a2 | 4516 | int |
fa8db1f7 | 4517 | sibcall_epilogue_contains (rtx insn) |
0a1c58a2 JL |
4518 | { |
4519 | if (sibcall_epilogue) | |
4520 | return contains (insn, sibcall_epilogue); | |
4521 | return 0; | |
4522 | } | |
4523 | ||
73ef99fb | 4524 | #ifdef HAVE_return |
69732dcb RH |
4525 | /* Insert gen_return at the end of block BB. This also means updating |
4526 | block_for_insn appropriately. */ | |
4527 | ||
4528 | static void | |
fa8db1f7 | 4529 | emit_return_into_block (basic_block bb, rtx line_note) |
69732dcb | 4530 | { |
a813c111 | 4531 | emit_jump_insn_after (gen_return (), BB_END (bb)); |
86c82654 | 4532 | if (line_note) |
a813c111 | 4533 | emit_note_copy_after (line_note, PREV_INSN (BB_END (bb))); |
69732dcb | 4534 | } |
73ef99fb | 4535 | #endif /* HAVE_return */ |
69732dcb | 4536 | |
3258e996 RK |
4537 | #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX) |
4538 | ||
4539 | /* These functions convert the epilogue into a variant that does not modify the | |
4540 | stack pointer. This is used in cases where a function returns an object | |
d6a7951f | 4541 | whose size is not known until it is computed. The called function leaves the |
3258e996 RK |
4542 | object on the stack, leaves the stack depressed, and returns a pointer to |
4543 | the object. | |
4544 | ||
4545 | What we need to do is track all modifications and references to the stack | |
4546 | pointer, deleting the modifications and changing the references to point to | |
4547 | the location the stack pointer would have pointed to had the modifications | |
4548 | taken place. | |
4549 | ||
4550 | These functions need to be portable so we need to make as few assumptions | |
4551 | about the epilogue as we can. However, the epilogue basically contains | |
4552 | three things: instructions to reset the stack pointer, instructions to | |
4553 | reload registers, possibly including the frame pointer, and an | |
4554 | instruction to return to the caller. | |
4555 | ||
4556 | If we can't be sure of what a relevant epilogue insn is doing, we abort. | |
4557 | We also make no attempt to validate the insns we make since if they are | |
4558 | invalid, we probably can't do anything valid. The intent is that these | |
4559 | routines get "smarter" as more and more machines start to use them and | |
4560 | they try operating on different epilogues. | |
4561 | ||
4562 | We use the following structure to track what the part of the epilogue that | |
4563 | we've already processed has done. We keep two copies of the SP equivalence, | |
4564 | one for use during the insn we are processing and one for use in the next | |
4565 | insn. The difference is because one part of a PARALLEL may adjust SP | |
4566 | and the other may use it. */ | |
4567 | ||
4568 | struct epi_info | |
4569 | { | |
4570 | rtx sp_equiv_reg; /* REG that SP is set from, perhaps SP. */ | |
4571 | HOST_WIDE_INT sp_offset; /* Offset from SP_EQUIV_REG of present SP. */ | |
3ef42a0c | 4572 | rtx new_sp_equiv_reg; /* REG to be used at end of insn. */ |
3258e996 RK |
4573 | HOST_WIDE_INT new_sp_offset; /* Offset to be used at end of insn. */ |
4574 | rtx equiv_reg_src; /* If nonzero, the value that SP_EQUIV_REG | |
4575 | should be set to once we no longer need | |
4576 | its value. */ | |
f285d67b RK |
4577 | rtx const_equiv[FIRST_PSEUDO_REGISTER]; /* Any known constant equivalences |
4578 | for registers. */ | |
3258e996 RK |
4579 | }; |
4580 | ||
fa8db1f7 | 4581 | static void handle_epilogue_set (rtx, struct epi_info *); |
80fcc7bc | 4582 | static void update_epilogue_consts (rtx, rtx, void *); |
fa8db1f7 | 4583 | static void emit_equiv_load (struct epi_info *); |
7393c642 | 4584 | |
2f937369 DM |
4585 | /* Modify INSN, a list of one or more insns that is part of the epilogue, to |
4586 | no modifications to the stack pointer. Return the new list of insns. */ | |
7393c642 | 4587 | |
3258e996 | 4588 | static rtx |
fa8db1f7 | 4589 | keep_stack_depressed (rtx insns) |
7393c642 | 4590 | { |
2f937369 | 4591 | int j; |
3258e996 | 4592 | struct epi_info info; |
2f937369 | 4593 | rtx insn, next; |
7393c642 | 4594 | |
f285d67b | 4595 | /* If the epilogue is just a single instruction, it must be OK as is. */ |
2f937369 DM |
4596 | if (NEXT_INSN (insns) == NULL_RTX) |
4597 | return insns; | |
7393c642 | 4598 | |
3258e996 RK |
4599 | /* Otherwise, start a sequence, initialize the information we have, and |
4600 | process all the insns we were given. */ | |
4601 | start_sequence (); | |
4602 | ||
4603 | info.sp_equiv_reg = stack_pointer_rtx; | |
4604 | info.sp_offset = 0; | |
4605 | info.equiv_reg_src = 0; | |
7393c642 | 4606 | |
f285d67b RK |
4607 | for (j = 0; j < FIRST_PSEUDO_REGISTER; j++) |
4608 | info.const_equiv[j] = 0; | |
4609 | ||
2f937369 DM |
4610 | insn = insns; |
4611 | next = NULL_RTX; | |
4612 | while (insn != NULL_RTX) | |
7393c642 | 4613 | { |
2f937369 | 4614 | next = NEXT_INSN (insn); |
7393c642 | 4615 | |
3258e996 RK |
4616 | if (!INSN_P (insn)) |
4617 | { | |
4618 | add_insn (insn); | |
2f937369 | 4619 | insn = next; |
3258e996 RK |
4620 | continue; |
4621 | } | |
7393c642 | 4622 | |
3258e996 RK |
4623 | /* If this insn references the register that SP is equivalent to and |
4624 | we have a pending load to that register, we must force out the load | |
4625 | first and then indicate we no longer know what SP's equivalent is. */ | |
4626 | if (info.equiv_reg_src != 0 | |
4627 | && reg_referenced_p (info.sp_equiv_reg, PATTERN (insn))) | |
7393c642 | 4628 | { |
3258e996 RK |
4629 | emit_equiv_load (&info); |
4630 | info.sp_equiv_reg = 0; | |
4631 | } | |
7393c642 | 4632 | |
3258e996 RK |
4633 | info.new_sp_equiv_reg = info.sp_equiv_reg; |
4634 | info.new_sp_offset = info.sp_offset; | |
7393c642 | 4635 | |
3258e996 RK |
4636 | /* If this is a (RETURN) and the return address is on the stack, |
4637 | update the address and change to an indirect jump. */ | |
4638 | if (GET_CODE (PATTERN (insn)) == RETURN | |
4639 | || (GET_CODE (PATTERN (insn)) == PARALLEL | |
4640 | && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == RETURN)) | |
4641 | { | |
4642 | rtx retaddr = INCOMING_RETURN_ADDR_RTX; | |
4643 | rtx base = 0; | |
4644 | HOST_WIDE_INT offset = 0; | |
4645 | rtx jump_insn, jump_set; | |
4646 | ||
4647 | /* If the return address is in a register, we can emit the insn | |
4648 | unchanged. Otherwise, it must be a MEM and we see what the | |
4649 | base register and offset are. In any case, we have to emit any | |
4650 | pending load to the equivalent reg of SP, if any. */ | |
f8cfc6aa | 4651 | if (REG_P (retaddr)) |
3258e996 RK |
4652 | { |
4653 | emit_equiv_load (&info); | |
4654 | add_insn (insn); | |
2f937369 | 4655 | insn = next; |
3258e996 RK |
4656 | continue; |
4657 | } | |
3c0cb5de | 4658 | else if (MEM_P (retaddr) |
f8cfc6aa | 4659 | && REG_P (XEXP (retaddr, 0))) |
3258e996 | 4660 | base = gen_rtx_REG (Pmode, REGNO (XEXP (retaddr, 0))), offset = 0; |
3c0cb5de | 4661 | else if (MEM_P (retaddr) |
3258e996 | 4662 | && GET_CODE (XEXP (retaddr, 0)) == PLUS |
f8cfc6aa | 4663 | && REG_P (XEXP (XEXP (retaddr, 0), 0)) |
3258e996 RK |
4664 | && GET_CODE (XEXP (XEXP (retaddr, 0), 1)) == CONST_INT) |
4665 | { | |
4666 | base = gen_rtx_REG (Pmode, REGNO (XEXP (XEXP (retaddr, 0), 0))); | |
4667 | offset = INTVAL (XEXP (XEXP (retaddr, 0), 1)); | |
4668 | } | |
7393c642 | 4669 | else |
3258e996 RK |
4670 | abort (); |
4671 | ||
4672 | /* If the base of the location containing the return pointer | |
4673 | is SP, we must update it with the replacement address. Otherwise, | |
4674 | just build the necessary MEM. */ | |
4675 | retaddr = plus_constant (base, offset); | |
4676 | if (base == stack_pointer_rtx) | |
4677 | retaddr = simplify_replace_rtx (retaddr, stack_pointer_rtx, | |
4678 | plus_constant (info.sp_equiv_reg, | |
4679 | info.sp_offset)); | |
4680 | ||
4681 | retaddr = gen_rtx_MEM (Pmode, retaddr); | |
4682 | ||
4683 | /* If there is a pending load to the equivalent register for SP | |
4684 | and we reference that register, we must load our address into | |
4685 | a scratch register and then do that load. */ | |
4686 | if (info.equiv_reg_src | |
4687 | && reg_overlap_mentioned_p (info.equiv_reg_src, retaddr)) | |
4688 | { | |
4689 | unsigned int regno; | |
4690 | rtx reg; | |
4691 | ||
4692 | for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) | |
4693 | if (HARD_REGNO_MODE_OK (regno, Pmode) | |
53b6fb26 RK |
4694 | && !fixed_regs[regno] |
4695 | && TEST_HARD_REG_BIT (regs_invalidated_by_call, regno) | |
b5ed05aa RK |
4696 | && !REGNO_REG_SET_P (EXIT_BLOCK_PTR->global_live_at_start, |
4697 | regno) | |
4698 | && !refers_to_regno_p (regno, | |
66fd46b6 JH |
4699 | regno + hard_regno_nregs[regno] |
4700 | [Pmode], | |
f285d67b RK |
4701 | info.equiv_reg_src, NULL) |
4702 | && info.const_equiv[regno] == 0) | |
3258e996 RK |
4703 | break; |
4704 | ||
4705 | if (regno == FIRST_PSEUDO_REGISTER) | |
4706 | abort (); | |
7393c642 | 4707 | |
3258e996 RK |
4708 | reg = gen_rtx_REG (Pmode, regno); |
4709 | emit_move_insn (reg, retaddr); | |
4710 | retaddr = reg; | |
4711 | } | |
4712 | ||
4713 | emit_equiv_load (&info); | |
4714 | jump_insn = emit_jump_insn (gen_indirect_jump (retaddr)); | |
4715 | ||
4716 | /* Show the SET in the above insn is a RETURN. */ | |
4717 | jump_set = single_set (jump_insn); | |
4718 | if (jump_set == 0) | |
4719 | abort (); | |
4720 | else | |
4721 | SET_IS_RETURN_P (jump_set) = 1; | |
7393c642 | 4722 | } |
3258e996 RK |
4723 | |
4724 | /* If SP is not mentioned in the pattern and its equivalent register, if | |
4725 | any, is not modified, just emit it. Otherwise, if neither is set, | |
4726 | replace the reference to SP and emit the insn. If none of those are | |
4727 | true, handle each SET individually. */ | |
4728 | else if (!reg_mentioned_p (stack_pointer_rtx, PATTERN (insn)) | |
4729 | && (info.sp_equiv_reg == stack_pointer_rtx | |
4730 | || !reg_set_p (info.sp_equiv_reg, insn))) | |
4731 | add_insn (insn); | |
4732 | else if (! reg_set_p (stack_pointer_rtx, insn) | |
4733 | && (info.sp_equiv_reg == stack_pointer_rtx | |
4734 | || !reg_set_p (info.sp_equiv_reg, insn))) | |
7393c642 | 4735 | { |
3258e996 RK |
4736 | if (! validate_replace_rtx (stack_pointer_rtx, |
4737 | plus_constant (info.sp_equiv_reg, | |
4738 | info.sp_offset), | |
4739 | insn)) | |
7393c642 RK |
4740 | abort (); |
4741 | ||
3258e996 RK |
4742 | add_insn (insn); |
4743 | } | |
4744 | else if (GET_CODE (PATTERN (insn)) == SET) | |
4745 | handle_epilogue_set (PATTERN (insn), &info); | |
4746 | else if (GET_CODE (PATTERN (insn)) == PARALLEL) | |
4747 | { | |
4748 | for (j = 0; j < XVECLEN (PATTERN (insn), 0); j++) | |
4749 | if (GET_CODE (XVECEXP (PATTERN (insn), 0, j)) == SET) | |
4750 | handle_epilogue_set (XVECEXP (PATTERN (insn), 0, j), &info); | |
4751 | } | |
4752 | else | |
4753 | add_insn (insn); | |
4754 | ||
4755 | info.sp_equiv_reg = info.new_sp_equiv_reg; | |
4756 | info.sp_offset = info.new_sp_offset; | |
2f937369 | 4757 | |
f285d67b RK |
4758 | /* Now update any constants this insn sets. */ |
4759 | note_stores (PATTERN (insn), update_epilogue_consts, &info); | |
2f937369 | 4760 | insn = next; |
3258e996 RK |
4761 | } |
4762 | ||
2f937369 | 4763 | insns = get_insns (); |
3258e996 | 4764 | end_sequence (); |
2f937369 | 4765 | return insns; |
3258e996 RK |
4766 | } |
4767 | ||
d6a7951f | 4768 | /* SET is a SET from an insn in the epilogue. P is a pointer to the epi_info |
3258e996 | 4769 | structure that contains information about what we've seen so far. We |
797a6ac1 | 4770 | process this SET by either updating that data or by emitting one or |
3258e996 RK |
4771 | more insns. */ |
4772 | ||
4773 | static void | |
fa8db1f7 | 4774 | handle_epilogue_set (rtx set, struct epi_info *p) |
3258e996 RK |
4775 | { |
4776 | /* First handle the case where we are setting SP. Record what it is being | |
4777 | set from. If unknown, abort. */ | |
4778 | if (reg_set_p (stack_pointer_rtx, set)) | |
4779 | { | |
4780 | if (SET_DEST (set) != stack_pointer_rtx) | |
4781 | abort (); | |
4782 | ||
f285d67b | 4783 | if (GET_CODE (SET_SRC (set)) == PLUS) |
3258e996 RK |
4784 | { |
4785 | p->new_sp_equiv_reg = XEXP (SET_SRC (set), 0); | |
f285d67b RK |
4786 | if (GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT) |
4787 | p->new_sp_offset = INTVAL (XEXP (SET_SRC (set), 1)); | |
f8cfc6aa | 4788 | else if (REG_P (XEXP (SET_SRC (set), 1)) |
f285d67b RK |
4789 | && REGNO (XEXP (SET_SRC (set), 1)) < FIRST_PSEUDO_REGISTER |
4790 | && p->const_equiv[REGNO (XEXP (SET_SRC (set), 1))] != 0) | |
4791 | p->new_sp_offset | |
4792 | = INTVAL (p->const_equiv[REGNO (XEXP (SET_SRC (set), 1))]); | |
4793 | else | |
4794 | abort (); | |
7393c642 | 4795 | } |
3258e996 RK |
4796 | else |
4797 | p->new_sp_equiv_reg = SET_SRC (set), p->new_sp_offset = 0; | |
4798 | ||
4799 | /* If we are adjusting SP, we adjust from the old data. */ | |
4800 | if (p->new_sp_equiv_reg == stack_pointer_rtx) | |
4801 | { | |
4802 | p->new_sp_equiv_reg = p->sp_equiv_reg; | |
4803 | p->new_sp_offset += p->sp_offset; | |
4804 | } | |
4805 | ||
f8cfc6aa | 4806 | if (p->new_sp_equiv_reg == 0 || !REG_P (p->new_sp_equiv_reg)) |
3258e996 RK |
4807 | abort (); |
4808 | ||
4809 | return; | |
4810 | } | |
4811 | ||
4812 | /* Next handle the case where we are setting SP's equivalent register. | |
4813 | If we already have a value to set it to, abort. We could update, but | |
f189c7ca RK |
4814 | there seems little point in handling that case. Note that we have |
4815 | to allow for the case where we are setting the register set in | |
4816 | the previous part of a PARALLEL inside a single insn. But use the | |
f285d67b RK |
4817 | old offset for any updates within this insn. We must allow for the case |
4818 | where the register is being set in a different (usually wider) mode than | |
4819 | Pmode). */ | |
f189c7ca | 4820 | else if (p->new_sp_equiv_reg != 0 && reg_set_p (p->new_sp_equiv_reg, set)) |
3258e996 | 4821 | { |
f285d67b | 4822 | if (p->equiv_reg_src != 0 |
f8cfc6aa JQ |
4823 | || !REG_P (p->new_sp_equiv_reg) |
4824 | || !REG_P (SET_DEST (set)) | |
f285d67b RK |
4825 | || GET_MODE_BITSIZE (GET_MODE (SET_DEST (set))) > BITS_PER_WORD |
4826 | || REGNO (p->new_sp_equiv_reg) != REGNO (SET_DEST (set))) | |
3258e996 RK |
4827 | abort (); |
4828 | else | |
4829 | p->equiv_reg_src | |
4830 | = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx, | |
4831 | plus_constant (p->sp_equiv_reg, | |
4832 | p->sp_offset)); | |
4833 | } | |
4834 | ||
4835 | /* Otherwise, replace any references to SP in the insn to its new value | |
4836 | and emit the insn. */ | |
4837 | else | |
4838 | { | |
4839 | SET_SRC (set) = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx, | |
4840 | plus_constant (p->sp_equiv_reg, | |
4841 | p->sp_offset)); | |
4842 | SET_DEST (set) = simplify_replace_rtx (SET_DEST (set), stack_pointer_rtx, | |
4843 | plus_constant (p->sp_equiv_reg, | |
4844 | p->sp_offset)); | |
4845 | emit_insn (set); | |
7393c642 RK |
4846 | } |
4847 | } | |
3258e996 | 4848 | |
f285d67b RK |
4849 | /* Update the tracking information for registers set to constants. */ |
4850 | ||
4851 | static void | |
4852 | update_epilogue_consts (rtx dest, rtx x, void *data) | |
4853 | { | |
4854 | struct epi_info *p = (struct epi_info *) data; | |
8fbc67c0 | 4855 | rtx new; |
f285d67b | 4856 | |
f8cfc6aa | 4857 | if (!REG_P (dest) || REGNO (dest) >= FIRST_PSEUDO_REGISTER) |
f285d67b | 4858 | return; |
8fbc67c0 RK |
4859 | |
4860 | /* If we are either clobbering a register or doing a partial set, | |
4861 | show we don't know the value. */ | |
4862 | else if (GET_CODE (x) == CLOBBER || ! rtx_equal_p (dest, SET_DEST (x))) | |
f285d67b | 4863 | p->const_equiv[REGNO (dest)] = 0; |
8fbc67c0 RK |
4864 | |
4865 | /* If we are setting it to a constant, record that constant. */ | |
4866 | else if (GET_CODE (SET_SRC (x)) == CONST_INT) | |
f285d67b | 4867 | p->const_equiv[REGNO (dest)] = SET_SRC (x); |
8fbc67c0 RK |
4868 | |
4869 | /* If this is a binary operation between a register we have been tracking | |
4870 | and a constant, see if we can compute a new constant value. */ | |
ec8e098d | 4871 | else if (ARITHMETIC_P (SET_SRC (x)) |
f8cfc6aa | 4872 | && REG_P (XEXP (SET_SRC (x), 0)) |
8fbc67c0 RK |
4873 | && REGNO (XEXP (SET_SRC (x), 0)) < FIRST_PSEUDO_REGISTER |
4874 | && p->const_equiv[REGNO (XEXP (SET_SRC (x), 0))] != 0 | |
4875 | && GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT | |
4876 | && 0 != (new = simplify_binary_operation | |
4877 | (GET_CODE (SET_SRC (x)), GET_MODE (dest), | |
4878 | p->const_equiv[REGNO (XEXP (SET_SRC (x), 0))], | |
4879 | XEXP (SET_SRC (x), 1))) | |
4880 | && GET_CODE (new) == CONST_INT) | |
4881 | p->const_equiv[REGNO (dest)] = new; | |
4882 | ||
4883 | /* Otherwise, we can't do anything with this value. */ | |
4884 | else | |
4885 | p->const_equiv[REGNO (dest)] = 0; | |
f285d67b RK |
4886 | } |
4887 | ||
3258e996 RK |
4888 | /* Emit an insn to do the load shown in p->equiv_reg_src, if needed. */ |
4889 | ||
4890 | static void | |
fa8db1f7 | 4891 | emit_equiv_load (struct epi_info *p) |
3258e996 RK |
4892 | { |
4893 | if (p->equiv_reg_src != 0) | |
f285d67b RK |
4894 | { |
4895 | rtx dest = p->sp_equiv_reg; | |
4896 | ||
4897 | if (GET_MODE (p->equiv_reg_src) != GET_MODE (dest)) | |
4898 | dest = gen_rtx_REG (GET_MODE (p->equiv_reg_src), | |
4899 | REGNO (p->sp_equiv_reg)); | |
3258e996 | 4900 | |
f285d67b RK |
4901 | emit_move_insn (dest, p->equiv_reg_src); |
4902 | p->equiv_reg_src = 0; | |
4903 | } | |
3258e996 | 4904 | } |
7393c642 RK |
4905 | #endif |
4906 | ||
9faa82d8 | 4907 | /* Generate the prologue and epilogue RTL if the machine supports it. Thread |
bdac5f58 TW |
4908 | this into place with notes indicating where the prologue ends and where |
4909 | the epilogue begins. Update the basic block information when possible. */ | |
4910 | ||
4911 | void | |
fa8db1f7 | 4912 | thread_prologue_and_epilogue_insns (rtx f ATTRIBUTE_UNUSED) |
bdac5f58 | 4913 | { |
ca1117cc | 4914 | int inserted = 0; |
19d3c25c | 4915 | edge e; |
91ea4f8d | 4916 | #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue) |
19d3c25c | 4917 | rtx seq; |
91ea4f8d | 4918 | #endif |
ca1117cc RH |
4919 | #ifdef HAVE_prologue |
4920 | rtx prologue_end = NULL_RTX; | |
4921 | #endif | |
86c82654 RH |
4922 | #if defined (HAVE_epilogue) || defined(HAVE_return) |
4923 | rtx epilogue_end = NULL_RTX; | |
4924 | #endif | |
e881bb1b | 4925 | |
bdac5f58 TW |
4926 | #ifdef HAVE_prologue |
4927 | if (HAVE_prologue) | |
4928 | { | |
e881bb1b | 4929 | start_sequence (); |
718fe406 | 4930 | seq = gen_prologue (); |
e881bb1b | 4931 | emit_insn (seq); |
bdac5f58 TW |
4932 | |
4933 | /* Retain a map of the prologue insns. */ | |
0a1c58a2 | 4934 | record_insns (seq, &prologue); |
2e040219 | 4935 | prologue_end = emit_note (NOTE_INSN_PROLOGUE_END); |
9185a8d5 | 4936 | |
2f937369 | 4937 | seq = get_insns (); |
e881bb1b | 4938 | end_sequence (); |
0435312e | 4939 | set_insn_locators (seq, prologue_locator); |
e881bb1b | 4940 | |
d6a7951f | 4941 | /* Can't deal with multiple successors of the entry block |
75540af0 JH |
4942 | at the moment. Function should always have at least one |
4943 | entry point. */ | |
4944 | if (!ENTRY_BLOCK_PTR->succ || ENTRY_BLOCK_PTR->succ->succ_next) | |
4945 | abort (); | |
e881bb1b | 4946 | |
75540af0 JH |
4947 | insert_insn_on_edge (seq, ENTRY_BLOCK_PTR->succ); |
4948 | inserted = 1; | |
bdac5f58 | 4949 | } |
bdac5f58 | 4950 | #endif |
bdac5f58 | 4951 | |
19d3c25c RH |
4952 | /* If the exit block has no non-fake predecessors, we don't need |
4953 | an epilogue. */ | |
718fe406 | 4954 | for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next) |
19d3c25c RH |
4955 | if ((e->flags & EDGE_FAKE) == 0) |
4956 | break; | |
4957 | if (e == NULL) | |
4958 | goto epilogue_done; | |
4959 | ||
69732dcb RH |
4960 | #ifdef HAVE_return |
4961 | if (optimize && HAVE_return) | |
4962 | { | |
4963 | /* If we're allowed to generate a simple return instruction, | |
4964 | then by definition we don't need a full epilogue. Examine | |
718fe406 KH |
4965 | the block that falls through to EXIT. If it does not |
4966 | contain any code, examine its predecessors and try to | |
69732dcb RH |
4967 | emit (conditional) return instructions. */ |
4968 | ||
4969 | basic_block last; | |
4970 | edge e_next; | |
4971 | rtx label; | |
4972 | ||
718fe406 | 4973 | for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next) |
69732dcb RH |
4974 | if (e->flags & EDGE_FALLTHRU) |
4975 | break; | |
4976 | if (e == NULL) | |
4977 | goto epilogue_done; | |
4978 | last = e->src; | |
4979 | ||
4980 | /* Verify that there are no active instructions in the last block. */ | |
a813c111 | 4981 | label = BB_END (last); |
69732dcb RH |
4982 | while (label && GET_CODE (label) != CODE_LABEL) |
4983 | { | |
4984 | if (active_insn_p (label)) | |
4985 | break; | |
4986 | label = PREV_INSN (label); | |
4987 | } | |
4988 | ||
a813c111 | 4989 | if (BB_HEAD (last) == label && GET_CODE (label) == CODE_LABEL) |
69732dcb | 4990 | { |
718fe406 | 4991 | rtx epilogue_line_note = NULL_RTX; |
86c82654 RH |
4992 | |
4993 | /* Locate the line number associated with the closing brace, | |
4994 | if we can find one. */ | |
4995 | for (seq = get_last_insn (); | |
4996 | seq && ! active_insn_p (seq); | |
4997 | seq = PREV_INSN (seq)) | |
4998 | if (GET_CODE (seq) == NOTE && NOTE_LINE_NUMBER (seq) > 0) | |
4999 | { | |
5000 | epilogue_line_note = seq; | |
5001 | break; | |
5002 | } | |
5003 | ||
718fe406 | 5004 | for (e = last->pred; e; e = e_next) |
69732dcb RH |
5005 | { |
5006 | basic_block bb = e->src; | |
5007 | rtx jump; | |
5008 | ||
5009 | e_next = e->pred_next; | |
5010 | if (bb == ENTRY_BLOCK_PTR) | |
5011 | continue; | |
5012 | ||
a813c111 | 5013 | jump = BB_END (bb); |
a617c13f | 5014 | if ((GET_CODE (jump) != JUMP_INSN) || JUMP_LABEL (jump) != label) |
69732dcb RH |
5015 | continue; |
5016 | ||
5017 | /* If we have an unconditional jump, we can replace that | |
5018 | with a simple return instruction. */ | |
5019 | if (simplejump_p (jump)) | |
5020 | { | |
86c82654 | 5021 | emit_return_into_block (bb, epilogue_line_note); |
53c17031 | 5022 | delete_insn (jump); |
69732dcb RH |
5023 | } |
5024 | ||
5025 | /* If we have a conditional jump, we can try to replace | |
5026 | that with a conditional return instruction. */ | |
5027 | else if (condjump_p (jump)) | |
5028 | { | |
47009d11 | 5029 | if (! redirect_jump (jump, 0, 0)) |
69732dcb | 5030 | continue; |
718fe406 | 5031 | |
3a75e42e CP |
5032 | /* If this block has only one successor, it both jumps |
5033 | and falls through to the fallthru block, so we can't | |
5034 | delete the edge. */ | |
718fe406 KH |
5035 | if (bb->succ->succ_next == NULL) |
5036 | continue; | |
69732dcb RH |
5037 | } |
5038 | else | |
5039 | continue; | |
5040 | ||
5041 | /* Fix up the CFG for the successful change we just made. */ | |
86c82654 | 5042 | redirect_edge_succ (e, EXIT_BLOCK_PTR); |
69732dcb | 5043 | } |
69732dcb | 5044 | |
2dd8bc01 GK |
5045 | /* Emit a return insn for the exit fallthru block. Whether |
5046 | this is still reachable will be determined later. */ | |
69732dcb | 5047 | |
a813c111 | 5048 | emit_barrier_after (BB_END (last)); |
86c82654 | 5049 | emit_return_into_block (last, epilogue_line_note); |
a813c111 | 5050 | epilogue_end = BB_END (last); |
ab75d1f1 | 5051 | last->succ->flags &= ~EDGE_FALLTHRU; |
718fe406 | 5052 | goto epilogue_done; |
2dd8bc01 | 5053 | } |
69732dcb RH |
5054 | } |
5055 | #endif | |
623a66fa R |
5056 | /* Find the edge that falls through to EXIT. Other edges may exist |
5057 | due to RETURN instructions, but those don't need epilogues. | |
5058 | There really shouldn't be a mixture -- either all should have | |
5059 | been converted or none, however... */ | |
5060 | ||
5061 | for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next) | |
5062 | if (e->flags & EDGE_FALLTHRU) | |
5063 | break; | |
5064 | if (e == NULL) | |
5065 | goto epilogue_done; | |
5066 | ||
bdac5f58 TW |
5067 | #ifdef HAVE_epilogue |
5068 | if (HAVE_epilogue) | |
5069 | { | |
19d3c25c | 5070 | start_sequence (); |
2e040219 | 5071 | epilogue_end = emit_note (NOTE_INSN_EPILOGUE_BEG); |
a78bdb38 | 5072 | |
19d3c25c | 5073 | seq = gen_epilogue (); |
7393c642 | 5074 | |
3258e996 RK |
5075 | #ifdef INCOMING_RETURN_ADDR_RTX |
5076 | /* If this function returns with the stack depressed and we can support | |
5077 | it, massage the epilogue to actually do that. */ | |
43db0363 RK |
5078 | if (TREE_CODE (TREE_TYPE (current_function_decl)) == FUNCTION_TYPE |
5079 | && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl))) | |
3258e996 RK |
5080 | seq = keep_stack_depressed (seq); |
5081 | #endif | |
7393c642 | 5082 | |
19d3c25c | 5083 | emit_jump_insn (seq); |
bdac5f58 | 5084 | |
19d3c25c | 5085 | /* Retain a map of the epilogue insns. */ |
0a1c58a2 | 5086 | record_insns (seq, &epilogue); |
0435312e | 5087 | set_insn_locators (seq, epilogue_locator); |
bdac5f58 | 5088 | |
2f937369 | 5089 | seq = get_insns (); |
718fe406 | 5090 | end_sequence (); |
e881bb1b | 5091 | |
19d3c25c | 5092 | insert_insn_on_edge (seq, e); |
ca1117cc | 5093 | inserted = 1; |
bdac5f58 | 5094 | } |
623a66fa | 5095 | else |
bdac5f58 | 5096 | #endif |
623a66fa R |
5097 | { |
5098 | basic_block cur_bb; | |
5099 | ||
5100 | if (! next_active_insn (BB_END (e->src))) | |
5101 | goto epilogue_done; | |
5102 | /* We have a fall-through edge to the exit block, the source is not | |
5103 | at the end of the function, and there will be an assembler epilogue | |
5104 | at the end of the function. | |
5105 | We can't use force_nonfallthru here, because that would try to | |
5106 | use return. Inserting a jump 'by hand' is extremely messy, so | |
5107 | we take advantage of cfg_layout_finalize using | |
5108 | fixup_fallthru_exit_predecessor. */ | |
5109 | cfg_layout_initialize (); | |
5110 | FOR_EACH_BB (cur_bb) | |
5111 | if (cur_bb->index >= 0 && cur_bb->next_bb->index >= 0) | |
5112 | cur_bb->rbi->next = cur_bb->next_bb; | |
5113 | cfg_layout_finalize (); | |
5114 | } | |
19d3c25c | 5115 | epilogue_done: |
e881bb1b | 5116 | |
ca1117cc | 5117 | if (inserted) |
e881bb1b | 5118 | commit_edge_insertions (); |
0a1c58a2 JL |
5119 | |
5120 | #ifdef HAVE_sibcall_epilogue | |
5121 | /* Emit sibling epilogues before any sibling call sites. */ | |
718fe406 | 5122 | for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next) |
0a1c58a2 JL |
5123 | { |
5124 | basic_block bb = e->src; | |
a813c111 | 5125 | rtx insn = BB_END (bb); |
0a1c58a2 | 5126 | rtx i; |
1b513b77 | 5127 | rtx newinsn; |
0a1c58a2 JL |
5128 | |
5129 | if (GET_CODE (insn) != CALL_INSN | |
5130 | || ! SIBLING_CALL_P (insn)) | |
5131 | continue; | |
5132 | ||
5133 | start_sequence (); | |
0af5c896 RE |
5134 | emit_insn (gen_sibcall_epilogue ()); |
5135 | seq = get_insns (); | |
0a1c58a2 JL |
5136 | end_sequence (); |
5137 | ||
2f937369 DM |
5138 | /* Retain a map of the epilogue insns. Used in life analysis to |
5139 | avoid getting rid of sibcall epilogue insns. Do this before we | |
5140 | actually emit the sequence. */ | |
5141 | record_insns (seq, &sibcall_epilogue); | |
0435312e | 5142 | set_insn_locators (seq, epilogue_locator); |
2f937369 | 5143 | |
0a1c58a2 | 5144 | i = PREV_INSN (insn); |
1b513b77 | 5145 | newinsn = emit_insn_before (seq, insn); |
0a1c58a2 JL |
5146 | } |
5147 | #endif | |
ca1117cc RH |
5148 | |
5149 | #ifdef HAVE_prologue | |
589fe865 | 5150 | /* This is probably all useless now that we use locators. */ |
ca1117cc RH |
5151 | if (prologue_end) |
5152 | { | |
5153 | rtx insn, prev; | |
5154 | ||
5155 | /* GDB handles `break f' by setting a breakpoint on the first | |
30196c1f | 5156 | line note after the prologue. Which means (1) that if |
ca1117cc | 5157 | there are line number notes before where we inserted the |
30196c1f RH |
5158 | prologue we should move them, and (2) we should generate a |
5159 | note before the end of the first basic block, if there isn't | |
016030fe JH |
5160 | one already there. |
5161 | ||
8d9afc4e | 5162 | ??? This behavior is completely broken when dealing with |
016030fe JH |
5163 | multiple entry functions. We simply place the note always |
5164 | into first basic block and let alternate entry points | |
5165 | to be missed. | |
5166 | */ | |
ca1117cc | 5167 | |
718fe406 | 5168 | for (insn = prologue_end; insn; insn = prev) |
ca1117cc RH |
5169 | { |
5170 | prev = PREV_INSN (insn); | |
5171 | if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) | |
5172 | { | |
5173 | /* Note that we cannot reorder the first insn in the | |
5174 | chain, since rest_of_compilation relies on that | |
30196c1f | 5175 | remaining constant. */ |
ca1117cc | 5176 | if (prev == NULL) |
30196c1f RH |
5177 | break; |
5178 | reorder_insns (insn, insn, prologue_end); | |
ca1117cc RH |
5179 | } |
5180 | } | |
5181 | ||
30196c1f | 5182 | /* Find the last line number note in the first block. */ |
a813c111 | 5183 | for (insn = BB_END (ENTRY_BLOCK_PTR->next_bb); |
016030fe | 5184 | insn != prologue_end && insn; |
30196c1f RH |
5185 | insn = PREV_INSN (insn)) |
5186 | if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) | |
5187 | break; | |
5188 | ||
5189 | /* If we didn't find one, make a copy of the first line number | |
5190 | we run across. */ | |
5191 | if (! insn) | |
ca1117cc | 5192 | { |
30196c1f RH |
5193 | for (insn = next_active_insn (prologue_end); |
5194 | insn; | |
5195 | insn = PREV_INSN (insn)) | |
5196 | if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) | |
5197 | { | |
5f2fc772 | 5198 | emit_note_copy_after (insn, prologue_end); |
30196c1f RH |
5199 | break; |
5200 | } | |
ca1117cc RH |
5201 | } |
5202 | } | |
5203 | #endif | |
86c82654 RH |
5204 | #ifdef HAVE_epilogue |
5205 | if (epilogue_end) | |
5206 | { | |
5207 | rtx insn, next; | |
5208 | ||
5209 | /* Similarly, move any line notes that appear after the epilogue. | |
ff7cc307 | 5210 | There is no need, however, to be quite so anal about the existence |
84c1fa24 UW |
5211 | of such a note. Also move the NOTE_INSN_FUNCTION_END and (possibly) |
5212 | NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug | |
5213 | info generation. */ | |
718fe406 | 5214 | for (insn = epilogue_end; insn; insn = next) |
86c82654 RH |
5215 | { |
5216 | next = NEXT_INSN (insn); | |
84c1fa24 UW |
5217 | if (GET_CODE (insn) == NOTE |
5218 | && (NOTE_LINE_NUMBER (insn) > 0 | |
5219 | || NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG | |
5220 | || NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_END)) | |
86c82654 RH |
5221 | reorder_insns (insn, insn, PREV_INSN (epilogue_end)); |
5222 | } | |
5223 | } | |
5224 | #endif | |
bdac5f58 TW |
5225 | } |
5226 | ||
5227 | /* Reposition the prologue-end and epilogue-begin notes after instruction | |
5228 | scheduling and delayed branch scheduling. */ | |
5229 | ||
5230 | void | |
fa8db1f7 | 5231 | reposition_prologue_and_epilogue_notes (rtx f ATTRIBUTE_UNUSED) |
bdac5f58 TW |
5232 | { |
5233 | #if defined (HAVE_prologue) || defined (HAVE_epilogue) | |
9f53e965 | 5234 | rtx insn, last, note; |
0a1c58a2 JL |
5235 | int len; |
5236 | ||
5237 | if ((len = VARRAY_SIZE (prologue)) > 0) | |
bdac5f58 | 5238 | { |
9f53e965 | 5239 | last = 0, note = 0; |
bdac5f58 | 5240 | |
0a1c58a2 JL |
5241 | /* Scan from the beginning until we reach the last prologue insn. |
5242 | We apparently can't depend on basic_block_{head,end} after | |
5243 | reorg has run. */ | |
9f53e965 | 5244 | for (insn = f; insn; insn = NEXT_INSN (insn)) |
bdac5f58 | 5245 | { |
0a1c58a2 | 5246 | if (GET_CODE (insn) == NOTE) |
9392c110 | 5247 | { |
0a1c58a2 JL |
5248 | if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END) |
5249 | note = insn; | |
5250 | } | |
9f53e965 | 5251 | else if (contains (insn, prologue)) |
0a1c58a2 | 5252 | { |
9f53e965 RH |
5253 | last = insn; |
5254 | if (--len == 0) | |
5255 | break; | |
5256 | } | |
5257 | } | |
797a6ac1 | 5258 | |
9f53e965 RH |
5259 | if (last) |
5260 | { | |
9f53e965 RH |
5261 | /* Find the prologue-end note if we haven't already, and |
5262 | move it to just after the last prologue insn. */ | |
5263 | if (note == 0) | |
5264 | { | |
5265 | for (note = last; (note = NEXT_INSN (note));) | |
5266 | if (GET_CODE (note) == NOTE | |
5267 | && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END) | |
5268 | break; | |
5269 | } | |
c93b03c2 | 5270 | |
9f53e965 RH |
5271 | /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */ |
5272 | if (GET_CODE (last) == CODE_LABEL) | |
5273 | last = NEXT_INSN (last); | |
5274 | reorder_insns (note, note, last); | |
bdac5f58 | 5275 | } |
0a1c58a2 JL |
5276 | } |
5277 | ||
5278 | if ((len = VARRAY_SIZE (epilogue)) > 0) | |
5279 | { | |
9f53e965 | 5280 | last = 0, note = 0; |
bdac5f58 | 5281 | |
0a1c58a2 JL |
5282 | /* Scan from the end until we reach the first epilogue insn. |
5283 | We apparently can't depend on basic_block_{head,end} after | |
5284 | reorg has run. */ | |
9f53e965 | 5285 | for (insn = get_last_insn (); insn; insn = PREV_INSN (insn)) |
bdac5f58 | 5286 | { |
0a1c58a2 | 5287 | if (GET_CODE (insn) == NOTE) |
9392c110 | 5288 | { |
0a1c58a2 JL |
5289 | if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG) |
5290 | note = insn; | |
5291 | } | |
9f53e965 | 5292 | else if (contains (insn, epilogue)) |
0a1c58a2 | 5293 | { |
9f53e965 RH |
5294 | last = insn; |
5295 | if (--len == 0) | |
5296 | break; | |
5297 | } | |
5298 | } | |
c93b03c2 | 5299 | |
9f53e965 RH |
5300 | if (last) |
5301 | { | |
5302 | /* Find the epilogue-begin note if we haven't already, and | |
5303 | move it to just before the first epilogue insn. */ | |
5304 | if (note == 0) | |
5305 | { | |
5306 | for (note = insn; (note = PREV_INSN (note));) | |
5307 | if (GET_CODE (note) == NOTE | |
5308 | && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG) | |
5309 | break; | |
9392c110 | 5310 | } |
9f53e965 RH |
5311 | |
5312 | if (PREV_INSN (last) != note) | |
5313 | reorder_insns (note, note, PREV_INSN (last)); | |
bdac5f58 TW |
5314 | } |
5315 | } | |
5316 | #endif /* HAVE_prologue or HAVE_epilogue */ | |
5317 | } | |
87ff9c8e | 5318 | |
87ff9c8e RH |
5319 | /* Called once, at initialization, to initialize function.c. */ |
5320 | ||
5321 | void | |
fa8db1f7 | 5322 | init_function_once (void) |
87ff9c8e | 5323 | { |
0a1c58a2 JL |
5324 | VARRAY_INT_INIT (prologue, 0, "prologue"); |
5325 | VARRAY_INT_INIT (epilogue, 0, "epilogue"); | |
5326 | VARRAY_INT_INIT (sibcall_epilogue, 0, "sibcall_epilogue"); | |
87ff9c8e | 5327 | } |
e2500fed | 5328 | |
6de9cd9a DN |
5329 | /* Resets insn_block_boundaries array. */ |
5330 | ||
5331 | void | |
5332 | reset_block_changes (void) | |
5333 | { | |
5334 | VARRAY_TREE_INIT (cfun->ib_boundaries_block, 100, "ib_boundaries_block"); | |
5335 | VARRAY_PUSH_TREE (cfun->ib_boundaries_block, NULL_TREE); | |
5336 | } | |
5337 | ||
5338 | /* Record the boundary for BLOCK. */ | |
5339 | void | |
5340 | record_block_change (tree block) | |
5341 | { | |
5342 | int i, n; | |
5343 | tree last_block; | |
5344 | ||
5345 | if (!block) | |
5346 | return; | |
5347 | ||
5348 | last_block = VARRAY_TOP_TREE (cfun->ib_boundaries_block); | |
5349 | VARRAY_POP (cfun->ib_boundaries_block); | |
5350 | n = get_max_uid (); | |
5351 | for (i = VARRAY_ACTIVE_SIZE (cfun->ib_boundaries_block); i < n; i++) | |
5352 | VARRAY_PUSH_TREE (cfun->ib_boundaries_block, last_block); | |
5353 | ||
5354 | VARRAY_PUSH_TREE (cfun->ib_boundaries_block, block); | |
5355 | } | |
5356 | ||
5357 | /* Finishes record of boundaries. */ | |
5358 | void finalize_block_changes (void) | |
5359 | { | |
5360 | record_block_change (DECL_INITIAL (current_function_decl)); | |
5361 | } | |
5362 | ||
5363 | /* For INSN return the BLOCK it belongs to. */ | |
5364 | void | |
5365 | check_block_change (rtx insn, tree *block) | |
5366 | { | |
5367 | unsigned uid = INSN_UID (insn); | |
5368 | ||
5369 | if (uid >= VARRAY_ACTIVE_SIZE (cfun->ib_boundaries_block)) | |
5370 | return; | |
5371 | ||
5372 | *block = VARRAY_TREE (cfun->ib_boundaries_block, uid); | |
5373 | } | |
5374 | ||
5375 | /* Releases the ib_boundaries_block records. */ | |
5376 | void | |
5377 | free_block_changes (void) | |
5378 | { | |
5379 | cfun->ib_boundaries_block = NULL; | |
5380 | } | |
5381 | ||
faed5cc3 SB |
5382 | /* Returns the name of the current function. */ |
5383 | const char * | |
5384 | current_function_name (void) | |
5385 | { | |
ae2bcd98 | 5386 | return lang_hooks.decl_printable_name (cfun->decl, 2); |
faed5cc3 SB |
5387 | } |
5388 | ||
e2500fed | 5389 | #include "gt-function.h" |