]>
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; | |
f55eed99 | 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 | ||
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 | ||
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; | |
98 | char *x_last_filename; | |
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. */ | |
111 | char *regno_pointer_align; | |
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 BS |
119 | #define reg_rtx_no (cfun->emit->x_reg_rtx_no) |
120 | #define seq_rtl_expr (cfun->emit->sequence_rtl_expr) | |
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 | ||
c2732da3 JM |
133 | /* Number of units that we should eventually pop off the stack. |
134 | These are the arguments to function calls that have not happened yet. */ | |
135 | int x_arg_space_so_far; | |
136 | ||
49ad7cfa BS |
137 | /* Under some ABIs, it is the caller's responsibility to pop arguments |
138 | pushed for function calls. A naive implementation would simply pop | |
139 | the arguments immediately after each call. However, if several | |
140 | function calls are made in a row, it is typically cheaper to pop | |
141 | all the arguments after all of the calls are complete since a | |
142 | single pop instruction can be used. Therefore, GCC attempts to | |
143 | defer popping the arguments until absolutely necessary. (For | |
144 | example, at the end of a conditional, the arguments must be popped, | |
145 | since code outside the conditional won't know whether or not the | |
146 | arguments need to be popped.) | |
147 | ||
148 | When INHIBIT_DEFER_POP is non-zero, however, the compiler does not | |
149 | attempt to defer pops. Instead, the stack is popped immediately | |
150 | after each call. Rather then setting this variable directly, use | |
151 | NO_DEFER_POP and OK_DEFER_POP. */ | |
152 | int x_inhibit_defer_pop; | |
153 | ||
154 | /* Nonzero means __builtin_saveregs has already been done in this function. | |
155 | The value is the pseudoreg containing the value __builtin_saveregs | |
156 | returned. */ | |
157 | rtx x_saveregs_value; | |
158 | ||
159 | /* Similarly for __builtin_apply_args. */ | |
160 | rtx x_apply_args_value; | |
161 | ||
162 | /* List of labels that must never be deleted. */ | |
163 | rtx x_forced_labels; | |
164 | ||
165 | /* Postincrements that still need to be expanded. */ | |
166 | rtx x_pending_chain; | |
167 | }; | |
168 | ||
01d939e8 | 169 | #define pending_stack_adjust (cfun->expr->x_pending_stack_adjust) |
c2732da3 | 170 | #define arg_space_so_far (cfun->expr->x_arg_space_so_far) |
01d939e8 BS |
171 | #define inhibit_defer_pop (cfun->expr->x_inhibit_defer_pop) |
172 | #define saveregs_value (cfun->expr->x_saveregs_value) | |
173 | #define apply_args_value (cfun->expr->x_apply_args_value) | |
174 | #define forced_labels (cfun->expr->x_forced_labels) | |
175 | #define pending_chain (cfun->expr->x_pending_chain) | |
49ad7cfa | 176 | |
bf6beae5 CH |
177 | /* This structure can save all the important global and static variables |
178 | describing the status of the current function. */ | |
179 | ||
180 | struct function | |
181 | { | |
b384405b | 182 | struct function *next_global; |
bf6beae5 CH |
183 | struct function *next; |
184 | ||
b384405b | 185 | struct eh_status *eh; |
3f1d071b | 186 | struct stmt_status *stmt; |
49ad7cfa BS |
187 | struct expr_status *expr; |
188 | struct emit_status *emit; | |
36edd3cc | 189 | struct varasm_status *varasm; |
b384405b | 190 | |
bf6beae5 | 191 | /* For function.c. */ |
49ad7cfa BS |
192 | |
193 | /* Name of this function. */ | |
5f8ded66 | 194 | const char *name; |
49ad7cfa | 195 | /* Points to the FUNCTION_DECL of this function. */ |
bf6beae5 | 196 | tree decl; |
49ad7cfa BS |
197 | |
198 | /* Number of bytes of args popped by function being compiled on its return. | |
199 | Zero if no bytes are to be popped. | |
200 | May affect compilation of return insn or of function epilogue. */ | |
bf6beae5 | 201 | int pops_args; |
49ad7cfa BS |
202 | |
203 | /* Nonzero if function being compiled needs to be given an address | |
204 | where the value should be stored. */ | |
bf6beae5 | 205 | int returns_struct; |
49ad7cfa BS |
206 | |
207 | /* Nonzero if function being compiled needs to | |
208 | return the address of where it has put a structure value. */ | |
bf6beae5 | 209 | int returns_pcc_struct; |
49ad7cfa BS |
210 | |
211 | /* Nonzero if the current function returns a pointer type. */ | |
04aa3b9c | 212 | int returns_pointer; |
49ad7cfa BS |
213 | |
214 | /* Nonzero if function being compiled needs to be passed a static chain. */ | |
bf6beae5 | 215 | int needs_context; |
49ad7cfa BS |
216 | |
217 | /* Nonzero if function being compiled can call setjmp. */ | |
bf6beae5 | 218 | int calls_setjmp; |
49ad7cfa BS |
219 | |
220 | /* Nonzero if function being compiled can call longjmp. */ | |
bf6beae5 | 221 | int calls_longjmp; |
49ad7cfa BS |
222 | |
223 | /* Nonzero if function being compiled can call alloca, | |
224 | either as a subroutine or builtin. */ | |
bf6beae5 | 225 | int calls_alloca; |
49ad7cfa BS |
226 | |
227 | /* Nonzero if function being compiled receives nonlocal gotos | |
228 | from nested functions. */ | |
229 | ||
bf6beae5 | 230 | int has_nonlocal_label; |
49ad7cfa BS |
231 | |
232 | /* Nonzero if function being compiled has nonlocal gotos to parent | |
233 | function. */ | |
67664664 | 234 | int has_nonlocal_goto; |
49ad7cfa BS |
235 | |
236 | /* Nonzero if function being compiled contains nested functions. */ | |
a0dabda5 | 237 | int contains_functions; |
49ad7cfa BS |
238 | |
239 | /* Nonzero if the function being compiled issues a computed jump. */ | |
acd693d1 | 240 | int has_computed_jump; |
49ad7cfa BS |
241 | |
242 | /* Nonzero if the current function is a thunk (a lightweight function that | |
243 | just adjusts one of its arguments and forwards to another function), so | |
244 | we should try to cut corners where we can. */ | |
173cd503 | 245 | int is_thunk; |
49ad7cfa BS |
246 | |
247 | /* If function's args have a fixed size, this is that size, in bytes. | |
248 | Otherwise, it is -1. | |
249 | May affect compilation of return insn or of function epilogue. */ | |
bf6beae5 | 250 | int args_size; |
49ad7cfa BS |
251 | |
252 | /* # bytes the prologue should push and pretend that the caller pushed them. | |
253 | The prologue must do this, but only if parms can be passed in | |
254 | registers. */ | |
bf6beae5 | 255 | int pretend_args_size; |
49ad7cfa BS |
256 | |
257 | /* # of bytes of outgoing arguments. If ACCUMULATE_OUTGOING_ARGS is | |
258 | defined, the needed space is pushed by the prologue. */ | |
259 | int outgoing_args_size; | |
260 | ||
261 | /* This is the offset from the arg pointer to the place where the first | |
262 | anonymous arg can be found, if there is one. */ | |
bf6beae5 | 263 | rtx arg_offset_rtx; |
49ad7cfa BS |
264 | |
265 | /* Nonzero if current function uses varargs.h or equivalent. | |
266 | Zero for functions that use stdarg.h. */ | |
91ab952c | 267 | int varargs; |
49ad7cfa BS |
268 | |
269 | /* Nonzero if current function uses stdarg.h or equivalent. | |
270 | Zero for functions that use varargs.h. */ | |
7da7e611 | 271 | int stdarg; |
49ad7cfa BS |
272 | |
273 | /* Quantities of various kinds of registers | |
274 | used for the current function's args. */ | |
275 | CUMULATIVE_ARGS args_info; | |
276 | ||
277 | /* If non-zero, an RTL expression for the location at which the current | |
278 | function returns its result. If the current function returns its | |
279 | result in a register, current_function_return_rtx will always be | |
280 | the hard register containing the result. */ | |
bf6beae5 | 281 | rtx return_rtx; |
49ad7cfa BS |
282 | |
283 | /* The arg pointer hard register, or the pseudo into which it was copied. */ | |
bf6beae5 | 284 | rtx internal_arg_pointer; |
49ad7cfa BS |
285 | |
286 | /* Language-specific reason why the current function cannot be made | |
287 | inline. */ | |
5f8ded66 | 288 | const char *cannot_inline; |
49ad7cfa BS |
289 | |
290 | /* Nonzero if instrumentation calls for function entry and exit should be | |
291 | generated. */ | |
07417085 | 292 | int instrument_entry_exit; |
bf6beae5 | 293 | |
49ad7cfa | 294 | /* Nonzero if memory access checking be enabled in the current function. */ |
7d384cc0 | 295 | int check_memory_usage; |
bf6beae5 | 296 | |
a157febd GK |
297 | /* Nonzero if stack limit checking should be enabled in the current |
298 | function. */ | |
299 | int limit_stack; | |
300 | ||
49ad7cfa BS |
301 | /* Number of function calls seen so far in current function. */ |
302 | int x_function_call_count; | |
303 | ||
e6fd097e MM |
304 | /* Nonzero if this function is being processed in function-at-a-time |
305 | mode. In other words, if all tree structure for this function, | |
306 | including the BLOCK tree is created, before RTL generation | |
307 | commences. */ | |
308 | int x_whole_function_mode_p; | |
309 | ||
d43163b7 MM |
310 | /* Nonzero if the back-end should not keep track of expressions that |
311 | determine the size of variable-sized objects. Normally, such | |
312 | expressions are saved away, and then expanded when the next | |
313 | function is started. For example, if a parameter has a | |
314 | variable-sized type, then the size of the parameter is computed | |
315 | when the function body is entered. However, some front-ends do | |
316 | not desire this behavior. */ | |
317 | int x_dont_save_pending_sizes_p; | |
318 | ||
49ad7cfa BS |
319 | /* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels |
320 | (labels to which there can be nonlocal gotos from nested functions) | |
321 | in this function. */ | |
322 | tree x_nonlocal_labels; | |
323 | ||
324 | /* List (chain of EXPR_LIST) of stack slots that hold the current handlers | |
325 | for nonlocal gotos. There is one for every nonlocal label in the | |
326 | function; this list matches the one in nonlocal_labels. | |
327 | Zero when function does not have nonlocal labels. */ | |
328 | rtx x_nonlocal_goto_handler_slots; | |
329 | ||
330 | /* List (chain of EXPR_LIST) of labels heading the current handlers for | |
331 | nonlocal gotos. */ | |
332 | rtx x_nonlocal_goto_handler_labels; | |
333 | ||
334 | /* RTX for stack slot that holds the stack pointer value to restore | |
335 | for a nonlocal goto. | |
336 | Zero when function does not have nonlocal labels. */ | |
337 | rtx x_nonlocal_goto_stack_level; | |
338 | ||
339 | /* Label that will go on parm cleanup code, if any. | |
340 | Jumping to this label runs cleanup code for parameters, if | |
341 | such code must be run. Following this code is the logical return | |
342 | label. */ | |
343 | rtx x_cleanup_label; | |
344 | ||
345 | /* Label that will go on function epilogue. | |
346 | Jumping to this label serves as a "return" instruction | |
347 | on machines which require execution of the epilogue on all returns. */ | |
348 | rtx x_return_label; | |
349 | ||
350 | /* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs. | |
351 | So we can mark them all live at the end of the function, if nonopt. */ | |
352 | rtx x_save_expr_regs; | |
353 | ||
354 | /* List (chain of EXPR_LISTs) of all stack slots in this function. | |
355 | Made for the sake of unshare_all_rtl. */ | |
356 | rtx x_stack_slot_list; | |
357 | ||
358 | /* Chain of all RTL_EXPRs that have insns in them. */ | |
359 | tree x_rtl_expr_chain; | |
360 | ||
361 | /* Label to jump back to for tail recursion, or 0 if we have | |
362 | not yet needed one for this function. */ | |
363 | rtx x_tail_recursion_label; | |
364 | ||
365 | /* Place after which to insert the tail_recursion_label if we need one. */ | |
366 | rtx x_tail_recursion_reentry; | |
367 | ||
368 | /* Location at which to save the argument pointer if it will need to be | |
369 | referenced. There are two cases where this is done: if nonlocal gotos | |
370 | exist, or if vars stored at an offset from the argument pointer will be | |
371 | needed by inner routines. */ | |
372 | rtx x_arg_pointer_save_area; | |
373 | ||
374 | /* Offset to end of allocated area of stack frame. | |
375 | If stack grows down, this is the address of the last stack slot allocated. | |
376 | If stack grows up, this is the address for the next slot. */ | |
377 | HOST_WIDE_INT x_frame_offset; | |
378 | ||
379 | /* List (chain of TREE_LISTs) of static chains for containing functions. | |
380 | Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx | |
381 | in an RTL_EXPR in the TREE_VALUE. */ | |
382 | tree x_context_display; | |
383 | ||
384 | /* List (chain of TREE_LISTs) of trampolines for nested functions. | |
385 | The trampoline sets up the static chain and jumps to the function. | |
386 | We supply the trampoline's address when the function's address is | |
387 | requested. | |
388 | ||
389 | Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx | |
390 | in an RTL_EXPR in the TREE_VALUE. */ | |
391 | tree x_trampoline_list; | |
392 | ||
393 | /* Insn after which register parms and SAVE_EXPRs are born, if nonopt. */ | |
394 | rtx x_parm_birth_insn; | |
395 | ||
396 | /* Last insn of those whose job was to put parms into their nominal | |
397 | homes. */ | |
398 | rtx x_last_parm_insn; | |
399 | ||
400 | /* 1 + last pseudo register number possibly used for loading a copy | |
401 | of a parameter of this function. */ | |
402 | int x_max_parm_reg; | |
403 | ||
404 | /* Vector indexed by REGNO, containing location on stack in which | |
405 | to put the parm which is nominally in pseudo register REGNO, | |
406 | if we discover that that parm must go in the stack. The highest | |
407 | element in this vector is one less than MAX_PARM_REG, above. */ | |
408 | rtx *x_parm_reg_stack_loc; | |
409 | ||
410 | /* List of all temporaries allocated, both available and in use. */ | |
411 | struct temp_slot *x_temp_slots; | |
412 | ||
413 | /* Current nesting level for temporaries. */ | |
414 | int x_temp_slot_level; | |
415 | ||
416 | /* Current nesting level for variables in a block. */ | |
417 | int x_var_temp_slot_level; | |
418 | ||
419 | /* When temporaries are created by TARGET_EXPRs, they are created at | |
420 | this level of temp_slot_level, so that they can remain allocated | |
421 | until no longer needed. CLEANUP_POINT_EXPRs define the lifetime | |
422 | of TARGET_EXPRs. */ | |
423 | int x_target_temp_slot_level; | |
424 | ||
425 | /* This slot is initialized as 0 and is added to | |
426 | during the nested function. */ | |
427 | struct var_refs_queue *fixup_var_refs_queue; | |
bf6beae5 CH |
428 | |
429 | /* For tree.c. */ | |
430 | int all_types_permanent; | |
431 | struct momentary_level *momentary_stack; | |
432 | char *maybepermanent_firstobj; | |
433 | char *temporary_firstobj; | |
434 | char *momentary_firstobj; | |
b8100453 | 435 | char *momentary_function_firstobj; |
bf6beae5 CH |
436 | struct obstack *current_obstack; |
437 | struct obstack *function_obstack; | |
438 | struct obstack *function_maybepermanent_obstack; | |
439 | struct obstack *expression_obstack; | |
440 | struct obstack *saveable_obstack; | |
441 | struct obstack *rtl_obstack; | |
442 | ||
36edd3cc | 443 | /* For integrate.c. */ |
49ad7cfa | 444 | int inlinable; |
49ad7cfa BS |
445 | /* This is in fact an rtvec. */ |
446 | void *original_arg_vector; | |
447 | tree original_decl_initial; | |
448 | /* Last insn of those whose job was to put parms into their nominal | |
449 | homes. */ | |
450 | rtx inl_last_parm_insn; | |
451 | /* Highest label number in current function. */ | |
452 | int inl_max_label_num; | |
453 | ||
454 | /* Nonzero if the current function uses the constant pool. */ | |
bf6beae5 CH |
455 | int uses_const_pool; |
456 | ||
457 | /* For md files. */ | |
49ad7cfa BS |
458 | |
459 | /* Nonzero if the current function uses pic_offset_table_rtx. */ | |
bf6beae5 | 460 | int uses_pic_offset_table; |
d6e1b011 RS |
461 | /* tm.h can use this to store whatever it likes. */ |
462 | struct machine_function *machine; | |
a0871656 JH |
463 | /* The largest alignment of slot allocated on the stack. */ |
464 | int stack_alignment_needed; | |
c2f8b491 JH |
465 | /* Preferred alignment of the end of stack frame. */ |
466 | int preferred_stack_boundary; | |
bd231550 | 467 | |
8c5666b4 BS |
468 | /* Language-specific code can use this to store whatever it likes. */ |
469 | struct language_function *language; | |
470 | ||
bd231550 | 471 | /* For reorg. */ |
49ad7cfa BS |
472 | |
473 | /* If some insns can be deferred to the delay slots of the epilogue, the | |
474 | delay list for them is recorded here. */ | |
bd231550 | 475 | rtx epilogue_delay_list; |
bf6beae5 CH |
476 | }; |
477 | ||
01d939e8 BS |
478 | /* The function currently being compiled. */ |
479 | extern struct function *cfun; | |
480 | ||
481 | /* A list of all functions we have compiled so far. */ | |
b384405b BS |
482 | extern struct function *all_functions; |
483 | ||
49ad7cfa | 484 | /* For backward compatibility... eventually these should all go away. */ |
01d939e8 BS |
485 | #define current_function_name (cfun->name) |
486 | #define current_function_pops_args (cfun->pops_args) | |
487 | #define current_function_returns_struct (cfun->returns_struct) | |
488 | #define current_function_returns_pcc_struct (cfun->returns_pcc_struct) | |
489 | #define current_function_returns_pointer (cfun->returns_pointer) | |
490 | #define current_function_needs_context (cfun->needs_context) | |
491 | #define current_function_calls_setjmp (cfun->calls_setjmp) | |
492 | #define current_function_calls_alloca (cfun->calls_alloca) | |
493 | #define current_function_calls_longjmp (cfun->calls_longjmp) | |
494 | #define current_function_has_computed_jump (cfun->has_computed_jump) | |
495 | #define current_function_contains_functions (cfun->contains_functions) | |
496 | #define current_function_is_thunk (cfun->is_thunk) | |
497 | #define current_function_args_info (cfun->args_info) | |
498 | #define current_function_args_size (cfun->args_size) | |
499 | #define current_function_pretend_args_size (cfun->pretend_args_size) | |
500 | #define current_function_outgoing_args_size (cfun->outgoing_args_size) | |
501 | #define current_function_arg_offset_rtx (cfun->arg_offset_rtx) | |
502 | #define current_function_varargs (cfun->varargs) | |
503 | #define current_function_stdarg (cfun->stdarg) | |
504 | #define current_function_internal_arg_pointer (cfun->internal_arg_pointer) | |
505 | #define current_function_return_rtx (cfun->return_rtx) | |
506 | #define current_function_instrument_entry_exit (cfun->instrument_entry_exit) | |
507 | #define current_function_check_memory_usage (cfun->check_memory_usage) | |
508 | #define current_function_limit_stack (cfun->limit_stack) | |
509 | #define current_function_uses_pic_offset_table (cfun->uses_pic_offset_table) | |
510 | #define current_function_uses_const_pool (cfun->uses_const_pool) | |
511 | #define current_function_cannot_inline (cfun->cannot_inline) | |
512 | #define current_function_epilogue_delay_list (cfun->epilogue_delay_list) | |
513 | #define current_function_has_nonlocal_label (cfun->has_nonlocal_label) | |
514 | #define current_function_has_nonlocal_goto (cfun->has_nonlocal_goto) | |
515 | ||
516 | #define max_parm_reg (cfun->x_max_parm_reg) | |
517 | #define parm_reg_stack_loc (cfun->x_parm_reg_stack_loc) | |
518 | #define cleanup_label (cfun->x_cleanup_label) | |
519 | #define return_label (cfun->x_return_label) | |
520 | #define save_expr_regs (cfun->x_save_expr_regs) | |
521 | #define stack_slot_list (cfun->x_stack_slot_list) | |
522 | #define parm_birth_insn (cfun->x_parm_birth_insn) | |
523 | #define frame_offset (cfun->x_frame_offset) | |
524 | #define tail_recursion_label (cfun->x_tail_recursion_label) | |
525 | #define tail_recursion_reentry (cfun->x_tail_recursion_reentry) | |
526 | #define arg_pointer_save_area (cfun->x_arg_pointer_save_area) | |
527 | #define rtl_expr_chain (cfun->x_rtl_expr_chain) | |
528 | #define last_parm_insn (cfun->x_last_parm_insn) | |
529 | #define context_display (cfun->x_context_display) | |
530 | #define trampoline_list (cfun->x_trampoline_list) | |
531 | #define function_call_count (cfun->x_function_call_count) | |
532 | #define temp_slots (cfun->x_temp_slots) | |
533 | #define temp_slot_level (cfun->x_temp_slot_level) | |
534 | #define target_temp_slot_level (cfun->x_target_temp_slot_level) | |
535 | #define var_temp_slot_level (cfun->x_var_temp_slot_level) | |
536 | #define nonlocal_labels (cfun->x_nonlocal_labels) | |
537 | #define nonlocal_goto_handler_slots (cfun->x_nonlocal_goto_handler_slots) | |
538 | #define nonlocal_goto_handler_labels (cfun->x_nonlocal_goto_handler_labels) | |
539 | #define nonlocal_goto_stack_level (cfun->x_nonlocal_goto_stack_level) | |
49ad7cfa | 540 | |
bf6beae5 CH |
541 | /* The FUNCTION_DECL for an inline function currently being expanded. */ |
542 | extern tree inline_function_decl; | |
543 | ||
ba534a45 JW |
544 | /* Given a function decl for a containing function, |
545 | return the `struct function' for it. */ | |
711d877c | 546 | struct function *find_function_data PARAMS ((tree)); |
ba534a45 JW |
547 | |
548 | /* Pointer to chain of `struct function' for containing functions. */ | |
549 | extern struct function *outer_function_chain; | |
550 | ||
551 | /* Put all this function's BLOCK nodes into a vector and return it. | |
552 | Also store in each NOTE for the beginning or end of a block | |
553 | the index of that block in the vector. */ | |
711d877c | 554 | extern void identify_blocks PARAMS ((tree, rtx)); |
d6e1b011 | 555 | |
18c038b9 MM |
556 | /* Set BLOCK_NUMBER for all the blocks in FN. */ |
557 | extern void number_blocks PARAMS ((tree)); | |
558 | ||
9a807d3a RK |
559 | /* Return size needed for stack frame based on slots so far allocated. |
560 | This size counts from zero. It is not rounded to STACK_BOUNDARY; | |
561 | the caller may have to do that. */ | |
711d877c | 562 | extern HOST_WIDE_INT get_frame_size PARAMS ((void)); |
49ad7cfa | 563 | /* Likewise, but for a different than the current function. */ |
711d877c | 564 | extern HOST_WIDE_INT get_func_frame_size PARAMS ((struct function *)); |
9a807d3a | 565 | |
d6e1b011 RS |
566 | /* These variables hold pointers to functions to |
567 | save and restore machine-specific data, | |
568 | in push_function_context and pop_function_context. */ | |
711d877c KG |
569 | extern void (*init_machine_status) PARAMS ((struct function *)); |
570 | extern void (*mark_machine_status) PARAMS ((struct function *)); | |
571 | extern void (*save_machine_status) PARAMS ((struct function *)); | |
572 | extern void (*restore_machine_status) PARAMS ((struct function *)); | |
573 | extern void (*free_machine_status) PARAMS ((struct function *)); | |
ba534a45 | 574 | |
8c5666b4 | 575 | /* Likewise, but for language-specific data. */ |
711d877c KG |
576 | extern void (*init_lang_status) PARAMS ((struct function *)); |
577 | extern void (*mark_lang_status) PARAMS ((struct function *)); | |
578 | extern void (*save_lang_status) PARAMS ((struct function *)); | |
579 | extern void (*restore_lang_status) PARAMS ((struct function *)); | |
580 | extern void (*free_lang_status) PARAMS ((struct function *)); | |
8c5666b4 | 581 | |
154bba13 | 582 | /* Save and restore status information for a nested function. */ |
711d877c KG |
583 | extern void save_tree_status PARAMS ((struct function *)); |
584 | extern void restore_tree_status PARAMS ((struct function *)); | |
585 | extern void restore_emit_status PARAMS ((struct function *)); | |
586 | extern void free_after_parsing PARAMS ((struct function *)); | |
587 | extern void free_after_compilation PARAMS ((struct function *)); | |
a00b8dfa | 588 | |
711d877c KG |
589 | extern void init_varasm_status PARAMS ((struct function *)); |
590 | extern void free_varasm_status PARAMS ((struct function *)); | |
591 | extern void free_emit_status PARAMS ((struct function *)); | |
592 | extern void free_stmt_status PARAMS ((struct function *)); | |
593 | extern void free_eh_status PARAMS ((struct function *)); | |
594 | extern void free_expr_status PARAMS ((struct function *)); | |
fa51b01b | 595 | |
711d877c | 596 | extern rtx get_first_block_beg PARAMS ((void)); |
a24da858 | 597 | |
bd695e1e | 598 | #ifdef RTX_CODE |
c13fde05 RH |
599 | extern void diddle_return_value PARAMS ((void (*)(rtx, void*), void*)); |
600 | extern void clobber_return_register PARAMS ((void)); | |
601 | extern void use_return_register PARAMS ((void)); | |
bd695e1e RH |
602 | #endif |
603 | ||
711d877c | 604 | extern void init_virtual_regs PARAMS ((struct emit_status *)); |
49ad7cfa | 605 | |
87ff9c8e | 606 | /* Called once, at initialization, to initialize function.c. */ |
711d877c | 607 | extern void init_function_once PARAMS ((void)); |
87ff9c8e | 608 | |
bf6beae5 CH |
609 | #ifdef rtx |
610 | #undef rtx | |
611 | #endif | |
612 | ||
613 | #ifdef tree | |
614 | #undef tree | |
615 | #endif |