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