]>
Commit | Line | Data |
---|---|---|
bf6beae5 | 1 | /* Structure for saving state for a nested function. |
af841dbd JL |
2 | Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, |
3 | 1999, 2000 Free Software Foundation, Inc. | |
bf6beae5 | 4 | |
1322177d | 5 | This file is part of GCC. |
bf6beae5 | 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. | |
bf6beae5 | 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. | |
bf6beae5 CH |
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. */ | |
bf6beae5 | 21 | |
e2500fed | 22 | struct var_refs_queue GTY(()) |
a00b8dfa RK |
23 | { |
24 | rtx modified; | |
25 | enum machine_mode promoted_mode; | |
26 | int unsignedp; | |
27 | struct var_refs_queue *next; | |
28 | }; | |
bf6beae5 CH |
29 | |
30 | /* Stack of pending (incomplete) sequences saved by `start_sequence'. | |
31 | Each element describes one pending sequence. | |
32 | The main insn-chain is saved in the last element of the chain, | |
33 | unless the chain is empty. */ | |
34 | ||
e2500fed | 35 | struct sequence_stack GTY(()) |
bf6beae5 CH |
36 | { |
37 | /* First and last insns in the chain of the saved sequence. */ | |
e2500fed GK |
38 | rtx first; |
39 | rtx last; | |
591ccf92 | 40 | tree sequence_rtl_expr; |
bf6beae5 CH |
41 | struct sequence_stack *next; |
42 | }; | |
43 | ||
44 | extern struct sequence_stack *sequence_stack; | |
a0dabda5 JM |
45 | |
46 | /* Stack of single obstacks. */ | |
47 | ||
48 | struct simple_obstack_stack | |
49 | { | |
50 | struct obstack *obstack; | |
51 | struct simple_obstack_stack *next; | |
52 | }; | |
bf6beae5 | 53 | \f |
e2500fed | 54 | struct emit_status GTY(()) |
49ad7cfa BS |
55 | { |
56 | /* This is reset to LAST_VIRTUAL_REGISTER + 1 at the start of each function. | |
57 | After rtl generation, it is 1 plus the largest register number used. */ | |
58 | int x_reg_rtx_no; | |
59 | ||
60 | /* Lowest label number in current function. */ | |
61 | int x_first_label_num; | |
62 | ||
63 | /* The ends of the doubly-linked chain of rtl for the current function. | |
64 | Both are reset to null at the start of rtl generation for the function. | |
65 | ||
66 | start_sequence saves both of these on `sequence_stack' along with | |
67 | `sequence_rtl_expr' and then starts a new, nested sequence of insns. */ | |
68 | rtx x_first_insn; | |
69 | rtx x_last_insn; | |
70 | ||
591ccf92 MM |
71 | /* RTL_EXPR within which the current sequence will be placed. Use to |
72 | prevent reuse of any temporaries within the sequence until after the | |
73 | RTL_EXPR is emitted. */ | |
74 | tree sequence_rtl_expr; | |
75 | ||
49ad7cfa BS |
76 | /* Stack of pending (incomplete) sequences saved by `start_sequence'. |
77 | Each element describes one pending sequence. | |
78 | The main insn-chain is saved in the last element of the chain, | |
79 | unless the chain is empty. */ | |
80 | struct sequence_stack *sequence_stack; | |
81 | ||
82 | /* INSN_UID for next insn emitted. | |
83 | Reset to 1 for each function compiled. */ | |
84 | int x_cur_insn_uid; | |
85 | ||
86 | /* Line number and source file of the last line-number NOTE emitted. | |
87 | This is used to avoid generating duplicates. */ | |
88 | int x_last_linenum; | |
3cce094d | 89 | const char *x_last_filename; |
49ad7cfa | 90 | |
0d4903b8 RK |
91 | /* The length of the regno_pointer_align, regno_decl, and x_regno_reg_rtx |
92 | vectors. Since these vectors are needed during the expansion phase when | |
93 | the total number of registers in the function is not yet known, the | |
94 | vectors are copied and made bigger when necessary. */ | |
3502dc9c | 95 | int regno_pointer_align_length; |
49ad7cfa BS |
96 | |
97 | /* Indexed by pseudo register number, if nonzero gives the known alignment | |
3502dc9c JDA |
98 | for that pseudo (if REG_POINTER is set in x_regno_reg_rtx). |
99 | Allocated in parallel with x_regno_reg_rtx. */ | |
e2500fed GK |
100 | unsigned char * GTY ((length ("%h.regno_pointer_align_length"))) |
101 | regno_pointer_align; | |
49ad7cfa | 102 | |
0d4903b8 RK |
103 | /* Indexed by pseudo register number, if nonzero gives the decl |
104 | corresponding to that register. */ | |
e2500fed | 105 | tree * GTY ((length ("%h.regno_pointer_align_length"))) regno_decl; |
0d4903b8 | 106 | |
49ad7cfa | 107 | /* Indexed by pseudo register number, gives the rtx for that pseudo. |
3502dc9c | 108 | Allocated in parallel with regno_pointer_align. */ |
e2500fed | 109 | rtx * GTY ((length ("%h.regno_pointer_align_length"))) x_regno_reg_rtx; |
49ad7cfa BS |
110 | }; |
111 | ||
112 | /* For backward compatibility... eventually these should all go away. */ | |
01d939e8 | 113 | #define reg_rtx_no (cfun->emit->x_reg_rtx_no) |
591ccf92 | 114 | #define seq_rtl_expr (cfun->emit->sequence_rtl_expr) |
01d939e8 BS |
115 | #define regno_reg_rtx (cfun->emit->x_regno_reg_rtx) |
116 | #define seq_stack (cfun->emit->sequence_stack) | |
49ad7cfa | 117 | |
01d939e8 | 118 | #define REGNO_POINTER_ALIGN(REGNO) (cfun->emit->regno_pointer_align[REGNO]) |
0d4903b8 | 119 | #define REGNO_DECL(REGNO) (cfun->emit->regno_decl[REGNO]) |
49ad7cfa | 120 | |
e2500fed | 121 | struct expr_status GTY(()) |
49ad7cfa BS |
122 | { |
123 | /* Number of units that we should eventually pop off the stack. | |
124 | These are the arguments to function calls that have already returned. */ | |
125 | int x_pending_stack_adjust; | |
126 | ||
127 | /* Under some ABIs, it is the caller's responsibility to pop arguments | |
128 | pushed for function calls. A naive implementation would simply pop | |
129 | the arguments immediately after each call. However, if several | |
130 | function calls are made in a row, it is typically cheaper to pop | |
131 | all the arguments after all of the calls are complete since a | |
132 | single pop instruction can be used. Therefore, GCC attempts to | |
133 | defer popping the arguments until absolutely necessary. (For | |
134 | example, at the end of a conditional, the arguments must be popped, | |
135 | since code outside the conditional won't know whether or not the | |
136 | arguments need to be popped.) | |
137 | ||
138 | When INHIBIT_DEFER_POP is non-zero, however, the compiler does not | |
139 | attempt to defer pops. Instead, the stack is popped immediately | |
140 | after each call. Rather then setting this variable directly, use | |
141 | NO_DEFER_POP and OK_DEFER_POP. */ | |
142 | int x_inhibit_defer_pop; | |
143 | ||
1503a7ec | 144 | /* If PREFERRED_STACK_BOUNDARY and PUSH_ROUNDING are defined, the stack |
98ef4163 | 145 | boundary can be momentarily unaligned while pushing the arguments. |
1503a7ec JH |
146 | Record the delta since last aligned boundary here in order to get |
147 | stack alignment in the nested function calls working right. */ | |
148 | int x_stack_pointer_delta; | |
149 | ||
49ad7cfa BS |
150 | /* Nonzero means __builtin_saveregs has already been done in this function. |
151 | The value is the pseudoreg containing the value __builtin_saveregs | |
152 | returned. */ | |
153 | rtx x_saveregs_value; | |
154 | ||
155 | /* Similarly for __builtin_apply_args. */ | |
156 | rtx x_apply_args_value; | |
157 | ||
158 | /* List of labels that must never be deleted. */ | |
159 | rtx x_forced_labels; | |
160 | ||
161 | /* Postincrements that still need to be expanded. */ | |
162 | rtx x_pending_chain; | |
163 | }; | |
164 | ||
01d939e8 BS |
165 | #define pending_stack_adjust (cfun->expr->x_pending_stack_adjust) |
166 | #define inhibit_defer_pop (cfun->expr->x_inhibit_defer_pop) | |
167 | #define saveregs_value (cfun->expr->x_saveregs_value) | |
168 | #define apply_args_value (cfun->expr->x_apply_args_value) | |
169 | #define forced_labels (cfun->expr->x_forced_labels) | |
170 | #define pending_chain (cfun->expr->x_pending_chain) | |
1503a7ec | 171 | #define stack_pointer_delta (cfun->expr->x_stack_pointer_delta) |
49ad7cfa | 172 | |
bf6beae5 CH |
173 | /* This structure can save all the important global and static variables |
174 | describing the status of the current function. */ | |
175 | ||
e2500fed | 176 | struct function GTY(()) |
bf6beae5 | 177 | { |
b384405b | 178 | struct eh_status *eh; |
3f1d071b | 179 | struct stmt_status *stmt; |
49ad7cfa BS |
180 | struct expr_status *expr; |
181 | struct emit_status *emit; | |
36edd3cc | 182 | struct varasm_status *varasm; |
b384405b | 183 | |
bf6beae5 | 184 | /* For function.c. */ |
49ad7cfa BS |
185 | |
186 | /* Name of this function. */ | |
5f8ded66 | 187 | const char *name; |
89996b6e | 188 | |
19eb1ad7 | 189 | /* Points to the FUNCTION_DECL of this function. */ |
bf6beae5 | 190 | tree decl; |
49ad7cfa | 191 | |
eb3ae3e1 ZW |
192 | /* Function containing this function, if any. */ |
193 | struct function *outer; | |
194 | ||
49ad7cfa BS |
195 | /* Number of bytes of args popped by function being compiled on its return. |
196 | Zero if no bytes are to be popped. | |
197 | May affect compilation of return insn or of function epilogue. */ | |
bf6beae5 | 198 | int pops_args; |
49ad7cfa | 199 | |
49ad7cfa BS |
200 | /* If function's args have a fixed size, this is that size, in bytes. |
201 | Otherwise, it is -1. | |
202 | May affect compilation of return insn or of function epilogue. */ | |
bf6beae5 | 203 | int args_size; |
49ad7cfa BS |
204 | |
205 | /* # bytes the prologue should push and pretend that the caller pushed them. | |
206 | The prologue must do this, but only if parms can be passed in | |
207 | registers. */ | |
bf6beae5 | 208 | int pretend_args_size; |
49ad7cfa BS |
209 | |
210 | /* # of bytes of outgoing arguments. If ACCUMULATE_OUTGOING_ARGS is | |
211 | defined, the needed space is pushed by the prologue. */ | |
212 | int outgoing_args_size; | |
213 | ||
214 | /* This is the offset from the arg pointer to the place where the first | |
215 | anonymous arg can be found, if there is one. */ | |
bf6beae5 | 216 | rtx arg_offset_rtx; |
49ad7cfa | 217 | |
49ad7cfa BS |
218 | /* Quantities of various kinds of registers |
219 | used for the current function's args. */ | |
220 | CUMULATIVE_ARGS args_info; | |
221 | ||
222 | /* If non-zero, an RTL expression for the location at which the current | |
223 | function returns its result. If the current function returns its | |
224 | result in a register, current_function_return_rtx will always be | |
225 | the hard register containing the result. */ | |
bf6beae5 | 226 | rtx return_rtx; |
49ad7cfa BS |
227 | |
228 | /* The arg pointer hard register, or the pseudo into which it was copied. */ | |
bf6beae5 | 229 | rtx internal_arg_pointer; |
49ad7cfa BS |
230 | |
231 | /* Language-specific reason why the current function cannot be made | |
232 | inline. */ | |
5f8ded66 | 233 | const char *cannot_inline; |
49ad7cfa | 234 | |
c0e7830f | 235 | /* Opaque pointer used by get_hard_reg_initial_val and |
19eb1ad7 | 236 | has_hard_reg_initial_val (see integrate.[hc]). */ |
c0e7830f DD |
237 | struct initial_value_struct *hard_reg_initial_vals; |
238 | ||
49ad7cfa BS |
239 | /* Number of function calls seen so far in current function. */ |
240 | int x_function_call_count; | |
241 | ||
242 | /* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels | |
243 | (labels to which there can be nonlocal gotos from nested functions) | |
244 | in this function. */ | |
245 | tree x_nonlocal_labels; | |
246 | ||
247 | /* List (chain of EXPR_LIST) of stack slots that hold the current handlers | |
248 | for nonlocal gotos. There is one for every nonlocal label in the | |
249 | function; this list matches the one in nonlocal_labels. | |
250 | Zero when function does not have nonlocal labels. */ | |
251 | rtx x_nonlocal_goto_handler_slots; | |
252 | ||
253 | /* List (chain of EXPR_LIST) of labels heading the current handlers for | |
254 | nonlocal gotos. */ | |
255 | rtx x_nonlocal_goto_handler_labels; | |
256 | ||
257 | /* RTX for stack slot that holds the stack pointer value to restore | |
258 | for a nonlocal goto. | |
259 | Zero when function does not have nonlocal labels. */ | |
260 | rtx x_nonlocal_goto_stack_level; | |
261 | ||
262 | /* Label that will go on parm cleanup code, if any. | |
263 | Jumping to this label runs cleanup code for parameters, if | |
264 | such code must be run. Following this code is the logical return | |
265 | label. */ | |
266 | rtx x_cleanup_label; | |
267 | ||
268 | /* Label that will go on function epilogue. | |
269 | Jumping to this label serves as a "return" instruction | |
270 | on machines which require execution of the epilogue on all returns. */ | |
271 | rtx x_return_label; | |
272 | ||
273 | /* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs. | |
274 | So we can mark them all live at the end of the function, if nonopt. */ | |
275 | rtx x_save_expr_regs; | |
276 | ||
277 | /* List (chain of EXPR_LISTs) of all stack slots in this function. | |
278 | Made for the sake of unshare_all_rtl. */ | |
279 | rtx x_stack_slot_list; | |
280 | ||
281 | /* Chain of all RTL_EXPRs that have insns in them. */ | |
282 | tree x_rtl_expr_chain; | |
283 | ||
284 | /* Label to jump back to for tail recursion, or 0 if we have | |
285 | not yet needed one for this function. */ | |
286 | rtx x_tail_recursion_label; | |
287 | ||
288 | /* Place after which to insert the tail_recursion_label if we need one. */ | |
289 | rtx x_tail_recursion_reentry; | |
290 | ||
291 | /* Location at which to save the argument pointer if it will need to be | |
292 | referenced. There are two cases where this is done: if nonlocal gotos | |
293 | exist, or if vars stored at an offset from the argument pointer will be | |
294 | needed by inner routines. */ | |
295 | rtx x_arg_pointer_save_area; | |
296 | ||
b313a0fe RH |
297 | /* If the function returns non-void, we will emit a clobber of the |
298 | return registers just in case the user fell off the end without | |
299 | returning a proper value. This is that insn. */ | |
300 | rtx x_clobber_return_insn; | |
301 | ||
49ad7cfa BS |
302 | /* Offset to end of allocated area of stack frame. |
303 | If stack grows down, this is the address of the last stack slot allocated. | |
304 | If stack grows up, this is the address for the next slot. */ | |
305 | HOST_WIDE_INT x_frame_offset; | |
306 | ||
307 | /* List (chain of TREE_LISTs) of static chains for containing functions. | |
308 | Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx | |
309 | in an RTL_EXPR in the TREE_VALUE. */ | |
310 | tree x_context_display; | |
311 | ||
312 | /* List (chain of TREE_LISTs) of trampolines for nested functions. | |
313 | The trampoline sets up the static chain and jumps to the function. | |
314 | We supply the trampoline's address when the function's address is | |
315 | requested. | |
316 | ||
317 | Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx | |
318 | in an RTL_EXPR in the TREE_VALUE. */ | |
319 | tree x_trampoline_list; | |
320 | ||
321 | /* Insn after which register parms and SAVE_EXPRs are born, if nonopt. */ | |
322 | rtx x_parm_birth_insn; | |
323 | ||
324 | /* Last insn of those whose job was to put parms into their nominal | |
325 | homes. */ | |
326 | rtx x_last_parm_insn; | |
327 | ||
328 | /* 1 + last pseudo register number possibly used for loading a copy | |
19eb1ad7 | 329 | of a parameter of this function. */ |
770ae6cc | 330 | unsigned int x_max_parm_reg; |
49ad7cfa BS |
331 | |
332 | /* Vector indexed by REGNO, containing location on stack in which | |
333 | to put the parm which is nominally in pseudo register REGNO, | |
334 | if we discover that that parm must go in the stack. The highest | |
335 | element in this vector is one less than MAX_PARM_REG, above. */ | |
e2500fed | 336 | rtx * GTY ((length ("%h.x_max_parm_reg"))) x_parm_reg_stack_loc; |
49ad7cfa BS |
337 | |
338 | /* List of all temporaries allocated, both available and in use. */ | |
339 | struct temp_slot *x_temp_slots; | |
340 | ||
341 | /* Current nesting level for temporaries. */ | |
342 | int x_temp_slot_level; | |
343 | ||
344 | /* Current nesting level for variables in a block. */ | |
345 | int x_var_temp_slot_level; | |
346 | ||
347 | /* When temporaries are created by TARGET_EXPRs, they are created at | |
348 | this level of temp_slot_level, so that they can remain allocated | |
349 | until no longer needed. CLEANUP_POINT_EXPRs define the lifetime | |
350 | of TARGET_EXPRs. */ | |
351 | int x_target_temp_slot_level; | |
352 | ||
353 | /* This slot is initialized as 0 and is added to | |
354 | during the nested function. */ | |
355 | struct var_refs_queue *fixup_var_refs_queue; | |
bf6beae5 | 356 | |
36edd3cc | 357 | /* For integrate.c. */ |
49ad7cfa | 358 | int inlinable; |
f93dacbd | 359 | int no_debugging_symbols; |
e2500fed | 360 | rtvec original_arg_vector; |
49ad7cfa BS |
361 | tree original_decl_initial; |
362 | /* Last insn of those whose job was to put parms into their nominal | |
363 | homes. */ | |
364 | rtx inl_last_parm_insn; | |
365 | /* Highest label number in current function. */ | |
366 | int inl_max_label_num; | |
367 | ||
f6f315fe AM |
368 | /* Profile label number. */ |
369 | int profile_label_no; | |
370 | ||
bf6beae5 | 371 | /* For md files. */ |
49ad7cfa | 372 | |
d6e1b011 | 373 | /* tm.h can use this to store whatever it likes. */ |
e2500fed | 374 | struct machine_function * GTY ((maybe_undef (""))) machine; |
a0871656 JH |
375 | /* The largest alignment of slot allocated on the stack. */ |
376 | int stack_alignment_needed; | |
c2f8b491 JH |
377 | /* Preferred alignment of the end of stack frame. */ |
378 | int preferred_stack_boundary; | |
bd231550 | 379 | |
8c5666b4 | 380 | /* Language-specific code can use this to store whatever it likes. */ |
e2500fed | 381 | struct language_function * language; |
8c5666b4 | 382 | |
bd231550 | 383 | /* For reorg. */ |
49ad7cfa BS |
384 | |
385 | /* If some insns can be deferred to the delay slots of the epilogue, the | |
386 | delay list for them is recorded here. */ | |
bd231550 | 387 | rtx epilogue_delay_list; |
89996b6e RH |
388 | |
389 | /* Collected bit flags. */ | |
390 | ||
391 | /* Nonzero if function being compiled needs to be given an address | |
392 | where the value should be stored. */ | |
393 | unsigned int returns_struct : 1; | |
394 | ||
395 | /* Nonzero if function being compiled needs to | |
396 | return the address of where it has put a structure value. */ | |
397 | unsigned int returns_pcc_struct : 1; | |
398 | ||
399 | /* Nonzero if the current function returns a pointer type. */ | |
400 | unsigned int returns_pointer : 1; | |
401 | ||
402 | /* Nonzero if function being compiled needs to be passed a static chain. */ | |
403 | unsigned int needs_context : 1; | |
404 | ||
405 | /* Nonzero if function being compiled can call setjmp. */ | |
406 | unsigned int calls_setjmp : 1; | |
407 | ||
408 | /* Nonzero if function being compiled can call longjmp. */ | |
409 | unsigned int calls_longjmp : 1; | |
410 | ||
411 | /* Nonzero if function being compiled can call alloca, | |
412 | either as a subroutine or builtin. */ | |
413 | unsigned int calls_alloca : 1; | |
414 | ||
52a11cbf RH |
415 | /* Nonzero if the function calls __builtin_eh_return. */ |
416 | unsigned int calls_eh_return : 1; | |
417 | ||
89996b6e RH |
418 | /* Nonzero if function being compiled receives nonlocal gotos |
419 | from nested functions. */ | |
420 | unsigned int has_nonlocal_label : 1; | |
421 | ||
422 | /* Nonzero if function being compiled has nonlocal gotos to parent | |
423 | function. */ | |
424 | unsigned int has_nonlocal_goto : 1; | |
425 | ||
426 | /* Nonzero if function being compiled contains nested functions. */ | |
427 | unsigned int contains_functions : 1; | |
428 | ||
429 | /* Nonzero if the function being compiled issues a computed jump. */ | |
430 | unsigned int has_computed_jump : 1; | |
431 | ||
432 | /* Nonzero if the current function is a thunk (a lightweight function that | |
433 | just adjusts one of its arguments and forwards to another function), so | |
434 | we should try to cut corners where we can. */ | |
435 | unsigned int is_thunk : 1; | |
436 | ||
437 | /* Nonzero if instrumentation calls for function entry and exit should be | |
438 | generated. */ | |
439 | unsigned int instrument_entry_exit : 1; | |
440 | ||
2292e8fc | 441 | /* Nonzero if arc profiling should be done for the function. */ |
b7c9bf28 JH |
442 | unsigned int arc_profile : 1; |
443 | ||
70f4f91c WC |
444 | /* Nonzero if profiling code should be generated. */ |
445 | unsigned int profile : 1; | |
446 | ||
89996b6e RH |
447 | /* Nonzero if stack limit checking should be enabled in the current |
448 | function. */ | |
449 | unsigned int limit_stack : 1; | |
450 | ||
451 | /* Nonzero if current function uses varargs.h or equivalent. | |
452 | Zero for functions that use stdarg.h. */ | |
453 | unsigned int varargs : 1; | |
454 | ||
455 | /* Nonzero if current function uses stdarg.h or equivalent. | |
456 | Zero for functions that use varargs.h. */ | |
457 | unsigned int stdarg : 1; | |
458 | ||
459 | /* Nonzero if this function is being processed in function-at-a-time | |
460 | mode. In other words, if all tree structure for this function, | |
461 | including the BLOCK tree, is created before RTL generation | |
462 | commences. */ | |
463 | unsigned int x_whole_function_mode_p : 1; | |
464 | ||
465 | /* Nonzero if the back-end should not keep track of expressions that | |
466 | determine the size of variable-sized objects. Normally, such | |
467 | expressions are saved away, and then expanded when the next | |
468 | function is started. For example, if a parameter has a | |
469 | variable-sized type, then the size of the parameter is computed | |
470 | when the function body is entered. However, some front-ends do | |
471 | not desire this behavior. */ | |
472 | unsigned int x_dont_save_pending_sizes_p : 1; | |
473 | ||
474 | /* Nonzero if the current function uses the constant pool. */ | |
475 | unsigned int uses_const_pool : 1; | |
476 | ||
477 | /* Nonzero if the current function uses pic_offset_table_rtx. */ | |
478 | unsigned int uses_pic_offset_table : 1; | |
479 | ||
480 | /* Nonzero if the current function needs an lsda for exception handling. */ | |
481 | unsigned int uses_eh_lsda : 1; | |
964be02f RH |
482 | |
483 | /* Nonzero if code to initialize arg_pointer_save_area has been emited. */ | |
484 | unsigned int arg_pointer_save_area_init : 1; | |
194734e9 JH |
485 | |
486 | /* How commonly executed the function is. Initialized during branch | |
487 | probabilities pass. */ | |
488 | enum function_frequency { | |
489 | /* This function most likely won't be executed at all. | |
490 | (set only when profile feedback is available). */ | |
491 | FUNCTION_FREQUENCY_UNLIKELY_EXECUTED, | |
492 | /* The default value. */ | |
493 | FUNCTION_FREQUENCY_NORMAL, | |
494 | /* Optimize this function hard | |
495 | (set only when profile feedback is available). */ | |
496 | FUNCTION_FREQUENCY_HOT | |
497 | } function_frequency; | |
bf6beae5 CH |
498 | }; |
499 | ||
01d939e8 | 500 | /* The function currently being compiled. */ |
e2500fed | 501 | extern GTY(()) struct function *cfun; |
01d939e8 | 502 | |
c39ada04 DD |
503 | /* Nonzero if we've already converted virtual regs to hard regs. */ |
504 | extern int virtuals_instantiated; | |
505 | ||
49ad7cfa | 506 | /* For backward compatibility... eventually these should all go away. */ |
01d939e8 BS |
507 | #define current_function_name (cfun->name) |
508 | #define current_function_pops_args (cfun->pops_args) | |
509 | #define current_function_returns_struct (cfun->returns_struct) | |
510 | #define current_function_returns_pcc_struct (cfun->returns_pcc_struct) | |
511 | #define current_function_returns_pointer (cfun->returns_pointer) | |
512 | #define current_function_needs_context (cfun->needs_context) | |
513 | #define current_function_calls_setjmp (cfun->calls_setjmp) | |
514 | #define current_function_calls_alloca (cfun->calls_alloca) | |
515 | #define current_function_calls_longjmp (cfun->calls_longjmp) | |
52a11cbf | 516 | #define current_function_calls_eh_return (cfun->calls_eh_return) |
01d939e8 BS |
517 | #define current_function_has_computed_jump (cfun->has_computed_jump) |
518 | #define current_function_contains_functions (cfun->contains_functions) | |
519 | #define current_function_is_thunk (cfun->is_thunk) | |
520 | #define current_function_args_info (cfun->args_info) | |
521 | #define current_function_args_size (cfun->args_size) | |
522 | #define current_function_pretend_args_size (cfun->pretend_args_size) | |
523 | #define current_function_outgoing_args_size (cfun->outgoing_args_size) | |
524 | #define current_function_arg_offset_rtx (cfun->arg_offset_rtx) | |
525 | #define current_function_varargs (cfun->varargs) | |
526 | #define current_function_stdarg (cfun->stdarg) | |
527 | #define current_function_internal_arg_pointer (cfun->internal_arg_pointer) | |
528 | #define current_function_return_rtx (cfun->return_rtx) | |
529 | #define current_function_instrument_entry_exit (cfun->instrument_entry_exit) | |
70f4f91c | 530 | #define current_function_profile (cfun->profile) |
f6f315fe | 531 | #define current_function_profile_label_no (cfun->profile_label_no) |
01d939e8 BS |
532 | #define current_function_limit_stack (cfun->limit_stack) |
533 | #define current_function_uses_pic_offset_table (cfun->uses_pic_offset_table) | |
534 | #define current_function_uses_const_pool (cfun->uses_const_pool) | |
535 | #define current_function_cannot_inline (cfun->cannot_inline) | |
536 | #define current_function_epilogue_delay_list (cfun->epilogue_delay_list) | |
537 | #define current_function_has_nonlocal_label (cfun->has_nonlocal_label) | |
538 | #define current_function_has_nonlocal_goto (cfun->has_nonlocal_goto) | |
539 | ||
540 | #define max_parm_reg (cfun->x_max_parm_reg) | |
541 | #define parm_reg_stack_loc (cfun->x_parm_reg_stack_loc) | |
542 | #define cleanup_label (cfun->x_cleanup_label) | |
543 | #define return_label (cfun->x_return_label) | |
544 | #define save_expr_regs (cfun->x_save_expr_regs) | |
545 | #define stack_slot_list (cfun->x_stack_slot_list) | |
546 | #define parm_birth_insn (cfun->x_parm_birth_insn) | |
547 | #define frame_offset (cfun->x_frame_offset) | |
548 | #define tail_recursion_label (cfun->x_tail_recursion_label) | |
549 | #define tail_recursion_reentry (cfun->x_tail_recursion_reentry) | |
550 | #define arg_pointer_save_area (cfun->x_arg_pointer_save_area) | |
551 | #define rtl_expr_chain (cfun->x_rtl_expr_chain) | |
552 | #define last_parm_insn (cfun->x_last_parm_insn) | |
553 | #define context_display (cfun->x_context_display) | |
554 | #define trampoline_list (cfun->x_trampoline_list) | |
555 | #define function_call_count (cfun->x_function_call_count) | |
556 | #define temp_slots (cfun->x_temp_slots) | |
557 | #define temp_slot_level (cfun->x_temp_slot_level) | |
558 | #define target_temp_slot_level (cfun->x_target_temp_slot_level) | |
559 | #define var_temp_slot_level (cfun->x_var_temp_slot_level) | |
560 | #define nonlocal_labels (cfun->x_nonlocal_labels) | |
561 | #define nonlocal_goto_handler_slots (cfun->x_nonlocal_goto_handler_slots) | |
562 | #define nonlocal_goto_handler_labels (cfun->x_nonlocal_goto_handler_labels) | |
563 | #define nonlocal_goto_stack_level (cfun->x_nonlocal_goto_stack_level) | |
49ad7cfa | 564 | |
bf6beae5 CH |
565 | /* The FUNCTION_DECL for an inline function currently being expanded. */ |
566 | extern tree inline_function_decl; | |
567 | ||
ba534a45 JW |
568 | /* Given a function decl for a containing function, |
569 | return the `struct function' for it. */ | |
711d877c | 570 | struct function *find_function_data PARAMS ((tree)); |
ba534a45 | 571 | |
116eebd6 MM |
572 | /* Set NOTE_BLOCK for each block note in the current function. */ |
573 | extern void identify_blocks PARAMS ((void)); | |
574 | ||
575 | /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END}, | |
576 | and create duplicate blocks. */ | |
577 | extern void reorder_blocks PARAMS ((void)); | |
d6e1b011 | 578 | |
18c038b9 MM |
579 | /* Set BLOCK_NUMBER for all the blocks in FN. */ |
580 | extern void number_blocks PARAMS ((tree)); | |
581 | ||
9a807d3a RK |
582 | /* Return size needed for stack frame based on slots so far allocated. |
583 | This size counts from zero. It is not rounded to STACK_BOUNDARY; | |
584 | the caller may have to do that. */ | |
711d877c | 585 | extern HOST_WIDE_INT get_frame_size PARAMS ((void)); |
49ad7cfa | 586 | /* Likewise, but for a different than the current function. */ |
711d877c | 587 | extern HOST_WIDE_INT get_func_frame_size PARAMS ((struct function *)); |
9a807d3a | 588 | |
e2500fed GK |
589 | /* A pointer to a function to create target specific, per-function |
590 | data structures. */ | |
591 | extern struct machine_function * (*init_machine_status) PARAMS ((void)); | |
ba534a45 | 592 | |
154bba13 | 593 | /* Save and restore status information for a nested function. */ |
711d877c KG |
594 | extern void restore_emit_status PARAMS ((struct function *)); |
595 | extern void free_after_parsing PARAMS ((struct function *)); | |
596 | extern void free_after_compilation PARAMS ((struct function *)); | |
a00b8dfa | 597 | |
711d877c | 598 | extern void init_varasm_status PARAMS ((struct function *)); |
fa51b01b | 599 | |
711d877c | 600 | extern rtx get_first_block_beg PARAMS ((void)); |
a24da858 | 601 | |
bd695e1e | 602 | #ifdef RTX_CODE |
c13fde05 RH |
603 | extern void diddle_return_value PARAMS ((void (*)(rtx, void*), void*)); |
604 | extern void clobber_return_register PARAMS ((void)); | |
605 | extern void use_return_register PARAMS ((void)); | |
bd695e1e RH |
606 | #endif |
607 | ||
278ed218 RH |
608 | extern rtx get_arg_pointer_save_area PARAMS ((struct function *)); |
609 | ||
711d877c | 610 | extern void init_virtual_regs PARAMS ((struct emit_status *)); |
49ad7cfa | 611 | |
87ff9c8e | 612 | /* Called once, at initialization, to initialize function.c. */ |
711d877c | 613 | extern void init_function_once PARAMS ((void)); |