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