|
0
|
1 /* Structure for saving state for a nested function.
|
|
|
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
|
|
3 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
|
|
4 Free Software Foundation, Inc.
|
|
|
5
|
|
|
6 This file is part of GCC.
|
|
|
7
|
|
|
8 GCC is free software; you can redistribute it and/or modify it under
|
|
|
9 the terms of the GNU General Public License as published by the Free
|
|
|
10 Software Foundation; either version 3, or (at your option) any later
|
|
|
11 version.
|
|
|
12
|
|
|
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
16 for more details.
|
|
|
17
|
|
|
18 You should have received a copy of the GNU General Public License
|
|
|
19 along with GCC; see the file COPYING3. If not see
|
|
|
20 <http://www.gnu.org/licenses/>. */
|
|
|
21
|
|
|
22 #ifndef GCC_FUNCTION_H
|
|
|
23 #define GCC_FUNCTION_H
|
|
|
24
|
|
|
25 #include "tree.h"
|
|
|
26 #include "hashtab.h"
|
|
|
27 #include "varray.h"
|
|
|
28
|
|
|
29 /* Stack of pending (incomplete) sequences saved by `start_sequence'.
|
|
|
30 Each element describes one pending sequence.
|
|
|
31 The main insn-chain is saved in the last element of the chain,
|
|
|
32 unless the chain is empty. */
|
|
|
33
|
|
|
34 struct sequence_stack GTY(())
|
|
|
35 {
|
|
|
36 /* First and last insns in the chain of the saved sequence. */
|
|
|
37 rtx first;
|
|
|
38 rtx last;
|
|
|
39 struct sequence_stack *next;
|
|
|
40 };
|
|
|
41
|
|
|
42 struct emit_status GTY(())
|
|
|
43 {
|
|
|
44 /* This is reset to LAST_VIRTUAL_REGISTER + 1 at the start of each function.
|
|
|
45 After rtl generation, it is 1 plus the largest register number used. */
|
|
|
46 int x_reg_rtx_no;
|
|
|
47
|
|
|
48 /* Lowest label number in current function. */
|
|
|
49 int x_first_label_num;
|
|
|
50
|
|
|
51 /* The ends of the doubly-linked chain of rtl for the current function.
|
|
|
52 Both are reset to null at the start of rtl generation for the function.
|
|
|
53
|
|
|
54 start_sequence saves both of these on `sequence_stack' and then starts
|
|
|
55 a new, nested sequence of insns. */
|
|
|
56 rtx x_first_insn;
|
|
|
57 rtx x_last_insn;
|
|
|
58
|
|
|
59 /* Stack of pending (incomplete) sequences saved by `start_sequence'.
|
|
|
60 Each element describes one pending sequence.
|
|
|
61 The main insn-chain is saved in the last element of the chain,
|
|
|
62 unless the chain is empty. */
|
|
|
63 struct sequence_stack *sequence_stack;
|
|
|
64
|
|
|
65 /* INSN_UID for next insn emitted.
|
|
|
66 Reset to 1 for each function compiled. */
|
|
|
67 int x_cur_insn_uid;
|
|
|
68
|
|
|
69 /* Location the last line-number NOTE emitted.
|
|
|
70 This is used to avoid generating duplicates. */
|
|
|
71 location_t x_last_location;
|
|
|
72
|
|
|
73 /* The length of the regno_pointer_align, regno_decl, and x_regno_reg_rtx
|
|
|
74 vectors. Since these vectors are needed during the expansion phase when
|
|
|
75 the total number of registers in the function is not yet known, the
|
|
|
76 vectors are copied and made bigger when necessary. */
|
|
|
77 int regno_pointer_align_length;
|
|
|
78
|
|
|
79 /* Indexed by pseudo register number, if nonzero gives the known alignment
|
|
|
80 for that pseudo (if REG_POINTER is set in x_regno_reg_rtx).
|
|
|
81 Allocated in parallel with x_regno_reg_rtx. */
|
|
|
82 unsigned char * GTY((skip)) regno_pointer_align;
|
|
|
83 };
|
|
|
84
|
|
|
85
|
|
|
86 /* Indexed by pseudo register number, gives the rtx for that pseudo.
|
|
|
87 Allocated in parallel with regno_pointer_align.
|
|
|
88 FIXME: We could put it into emit_status struct, but gengtype is not able to deal
|
|
|
89 with length attribute nested in top level structures. */
|
|
|
90
|
|
|
91 extern GTY ((length ("crtl->emit.x_reg_rtx_no"))) rtx * regno_reg_rtx;
|
|
|
92
|
|
|
93 /* For backward compatibility... eventually these should all go away. */
|
|
|
94 #define reg_rtx_no (crtl->emit.x_reg_rtx_no)
|
|
|
95 #define seq_stack (crtl->emit.sequence_stack)
|
|
|
96
|
|
|
97 #define REGNO_POINTER_ALIGN(REGNO) (crtl->emit.regno_pointer_align[REGNO])
|
|
|
98
|
|
|
99 struct expr_status GTY(())
|
|
|
100 {
|
|
|
101 /* Number of units that we should eventually pop off the stack.
|
|
|
102 These are the arguments to function calls that have already returned. */
|
|
|
103 int x_pending_stack_adjust;
|
|
|
104
|
|
|
105 /* Under some ABIs, it is the caller's responsibility to pop arguments
|
|
|
106 pushed for function calls. A naive implementation would simply pop
|
|
|
107 the arguments immediately after each call. However, if several
|
|
|
108 function calls are made in a row, it is typically cheaper to pop
|
|
|
109 all the arguments after all of the calls are complete since a
|
|
|
110 single pop instruction can be used. Therefore, GCC attempts to
|
|
|
111 defer popping the arguments until absolutely necessary. (For
|
|
|
112 example, at the end of a conditional, the arguments must be popped,
|
|
|
113 since code outside the conditional won't know whether or not the
|
|
|
114 arguments need to be popped.)
|
|
|
115
|
|
|
116 When INHIBIT_DEFER_POP is nonzero, however, the compiler does not
|
|
|
117 attempt to defer pops. Instead, the stack is popped immediately
|
|
|
118 after each call. Rather then setting this variable directly, use
|
|
|
119 NO_DEFER_POP and OK_DEFER_POP. */
|
|
|
120 int x_inhibit_defer_pop;
|
|
|
121
|
|
|
122 /* If PREFERRED_STACK_BOUNDARY and PUSH_ROUNDING are defined, the stack
|
|
|
123 boundary can be momentarily unaligned while pushing the arguments.
|
|
|
124 Record the delta since last aligned boundary here in order to get
|
|
|
125 stack alignment in the nested function calls working right. */
|
|
|
126 int x_stack_pointer_delta;
|
|
|
127
|
|
|
128 /* Nonzero means __builtin_saveregs has already been done in this function.
|
|
|
129 The value is the pseudoreg containing the value __builtin_saveregs
|
|
|
130 returned. */
|
|
|
131 rtx x_saveregs_value;
|
|
|
132
|
|
|
133 /* Similarly for __builtin_apply_args. */
|
|
|
134 rtx x_apply_args_value;
|
|
|
135
|
|
|
136 /* List of labels that must never be deleted. */
|
|
|
137 rtx x_forced_labels;
|
|
|
138 };
|
|
|
139
|
|
|
140 typedef struct call_site_record *call_site_record;
|
|
|
141 DEF_VEC_P(call_site_record);
|
|
|
142 DEF_VEC_ALLOC_P(call_site_record, gc);
|
|
|
143
|
|
|
144 /* RTL representation of exception handling. */
|
|
|
145 struct rtl_eh GTY(())
|
|
|
146 {
|
|
|
147 rtx filter;
|
|
|
148 rtx exc_ptr;
|
|
|
149
|
|
|
150 int built_landing_pads;
|
|
|
151
|
|
|
152 rtx ehr_stackadj;
|
|
|
153 rtx ehr_handler;
|
|
|
154 rtx ehr_label;
|
|
|
155
|
|
|
156 rtx sjlj_fc;
|
|
|
157 rtx sjlj_exit_after;
|
|
|
158
|
|
|
159 htab_t GTY ((param_is (struct ehl_map_entry))) exception_handler_label_map;
|
|
|
160
|
|
|
161 VEC(tree,gc) *ttype_data;
|
|
|
162 varray_type ehspec_data;
|
|
|
163 varray_type action_record_data;
|
|
|
164
|
|
|
165 VEC(call_site_record,gc) *call_site_record;
|
|
|
166 };
|
|
|
167
|
|
|
168 #define pending_stack_adjust (crtl->expr.x_pending_stack_adjust)
|
|
|
169 #define inhibit_defer_pop (crtl->expr.x_inhibit_defer_pop)
|
|
|
170 #define saveregs_value (crtl->expr.x_saveregs_value)
|
|
|
171 #define apply_args_value (crtl->expr.x_apply_args_value)
|
|
|
172 #define forced_labels (crtl->expr.x_forced_labels)
|
|
|
173 #define stack_pointer_delta (crtl->expr.x_stack_pointer_delta)
|
|
|
174
|
|
|
175 struct gimple_df;
|
|
|
176 struct temp_slot;
|
|
|
177 typedef struct temp_slot *temp_slot_p;
|
|
|
178 struct call_site_record;
|
|
|
179
|
|
|
180 DEF_VEC_P(temp_slot_p);
|
|
|
181 DEF_VEC_ALLOC_P(temp_slot_p,gc);
|
|
|
182 struct ipa_opt_pass;
|
|
|
183 typedef struct ipa_opt_pass *ipa_opt_pass;
|
|
|
184
|
|
|
185 DEF_VEC_P(ipa_opt_pass);
|
|
|
186 DEF_VEC_ALLOC_P(ipa_opt_pass,heap);
|
|
|
187
|
|
|
188 enum function_frequency {
|
|
|
189 /* This function most likely won't be executed at all.
|
|
|
190 (set only when profile feedback is available or via function attribute). */
|
|
|
191 FUNCTION_FREQUENCY_UNLIKELY_EXECUTED,
|
|
|
192 /* The default value. */
|
|
|
193 FUNCTION_FREQUENCY_NORMAL,
|
|
|
194 /* Optimize this function hard
|
|
|
195 (set only when profile feedback is available or via function attribute). */
|
|
|
196 FUNCTION_FREQUENCY_HOT
|
|
|
197 };
|
|
|
198
|
|
|
199 struct varasm_status GTY(())
|
|
|
200 {
|
|
|
201 /* If we're using a per-function constant pool, this is it. */
|
|
|
202 struct rtx_constant_pool *pool;
|
|
|
203
|
|
|
204 /* Number of tree-constants deferred during the expansion of this
|
|
|
205 function. */
|
|
|
206 unsigned int deferred_constants;
|
|
|
207 };
|
|
|
208
|
|
|
209 /* Information mainlined about RTL representation of incoming arguments. */
|
|
|
210 struct incoming_args GTY(())
|
|
|
211 {
|
|
|
212 /* Number of bytes of args popped by function being compiled on its return.
|
|
|
213 Zero if no bytes are to be popped.
|
|
|
214 May affect compilation of return insn or of function epilogue. */
|
|
|
215 int pops_args;
|
|
|
216
|
|
|
217 /* If function's args have a fixed size, this is that size, in bytes.
|
|
|
218 Otherwise, it is -1.
|
|
|
219 May affect compilation of return insn or of function epilogue. */
|
|
|
220 int size;
|
|
|
221
|
|
|
222 /* # bytes the prologue should push and pretend that the caller pushed them.
|
|
|
223 The prologue must do this, but only if parms can be passed in
|
|
|
224 registers. */
|
|
|
225 int pretend_args_size;
|
|
|
226
|
|
|
227 /* This is the offset from the arg pointer to the place where the first
|
|
|
228 anonymous arg can be found, if there is one. */
|
|
|
229 rtx arg_offset_rtx;
|
|
|
230
|
|
|
231 /* Quantities of various kinds of registers
|
|
|
232 used for the current function's args. */
|
|
|
233 CUMULATIVE_ARGS info;
|
|
|
234
|
|
|
235 /* The arg pointer hard register, or the pseudo into which it was copied. */
|
|
|
236 rtx internal_arg_pointer;
|
|
|
237 };
|
|
|
238
|
|
|
239 /* Data for function partitioning. */
|
|
|
240 struct function_subsections GTY(())
|
|
|
241 {
|
|
|
242 /* Assembly labels for the hot and cold text sections, to
|
|
|
243 be used by debugger functions for determining the size of text
|
|
|
244 sections. */
|
|
|
245
|
|
|
246 const char *hot_section_label;
|
|
|
247 const char *cold_section_label;
|
|
|
248 const char *hot_section_end_label;
|
|
|
249 const char *cold_section_end_label;
|
|
|
250
|
|
|
251 /* String to be used for name of cold text sections, via
|
|
|
252 targetm.asm_out.named_section. */
|
|
|
253
|
|
|
254 const char *unlikely_text_section_name;
|
|
|
255 };
|
|
|
256
|
|
|
257 /* Datastructures maintained for currently processed function in RTL form. */
|
|
|
258 struct rtl_data GTY(())
|
|
|
259 {
|
|
|
260 struct expr_status expr;
|
|
|
261 struct emit_status emit;
|
|
|
262 struct varasm_status varasm;
|
|
|
263 struct incoming_args args;
|
|
|
264 struct function_subsections subsections;
|
|
|
265 struct rtl_eh eh;
|
|
|
266
|
|
|
267 /* For function.c */
|
|
|
268
|
|
|
269 /* # of bytes of outgoing arguments. If ACCUMULATE_OUTGOING_ARGS is
|
|
|
270 defined, the needed space is pushed by the prologue. */
|
|
|
271 int outgoing_args_size;
|
|
|
272
|
|
|
273 /* If nonzero, an RTL expression for the location at which the current
|
|
|
274 function returns its result. If the current function returns its
|
|
|
275 result in a register, current_function_return_rtx will always be
|
|
|
276 the hard register containing the result. */
|
|
|
277 rtx return_rtx;
|
|
|
278
|
|
|
279 /* Opaque pointer used by get_hard_reg_initial_val and
|
|
|
280 has_hard_reg_initial_val (see integrate.[hc]). */
|
|
|
281 struct initial_value_struct *hard_reg_initial_vals;
|
|
|
282
|
|
|
283 /* A variable living at the top of the frame that holds a known value.
|
|
|
284 Used for detecting stack clobbers. */
|
|
|
285 tree stack_protect_guard;
|
|
|
286
|
|
|
287 /* List (chain of EXPR_LIST) of labels heading the current handlers for
|
|
|
288 nonlocal gotos. */
|
|
|
289 rtx x_nonlocal_goto_handler_labels;
|
|
|
290
|
|
|
291 /* Label that will go on function epilogue.
|
|
|
292 Jumping to this label serves as a "return" instruction
|
|
|
293 on machines which require execution of the epilogue on all returns. */
|
|
|
294 rtx x_return_label;
|
|
|
295
|
|
|
296 /* Label that will go on the end of function epilogue.
|
|
|
297 Jumping to this label serves as a "naked return" instruction
|
|
|
298 on machines which require execution of the epilogue on all returns. */
|
|
|
299 rtx x_naked_return_label;
|
|
|
300
|
|
|
301 /* List (chain of EXPR_LISTs) of all stack slots in this function.
|
|
|
302 Made for the sake of unshare_all_rtl. */
|
|
|
303 rtx x_stack_slot_list;
|
|
|
304
|
|
|
305 /* Place after which to insert the tail_recursion_label if we need one. */
|
|
|
306 rtx x_stack_check_probe_note;
|
|
|
307
|
|
|
308 /* Location at which to save the argument pointer if it will need to be
|
|
|
309 referenced. There are two cases where this is done: if nonlocal gotos
|
|
|
310 exist, or if vars stored at an offset from the argument pointer will be
|
|
|
311 needed by inner routines. */
|
|
|
312 rtx x_arg_pointer_save_area;
|
|
|
313
|
|
|
314 /* Dynamic Realign Argument Pointer used for realigning stack. */
|
|
|
315 rtx drap_reg;
|
|
|
316
|
|
|
317 /* Offset to end of allocated area of stack frame.
|
|
|
318 If stack grows down, this is the address of the last stack slot allocated.
|
|
|
319 If stack grows up, this is the address for the next slot. */
|
|
|
320 HOST_WIDE_INT x_frame_offset;
|
|
|
321
|
|
|
322 /* Insn after which register parms and SAVE_EXPRs are born, if nonopt. */
|
|
|
323 rtx x_parm_birth_insn;
|
|
|
324
|
|
|
325 /* List of all used temporaries allocated, by level. */
|
|
|
326 VEC(temp_slot_p,gc) *x_used_temp_slots;
|
|
|
327
|
|
|
328 /* List of available temp slots. */
|
|
|
329 struct temp_slot *x_avail_temp_slots;
|
|
|
330
|
|
|
331 /* Current nesting level for temporaries. */
|
|
|
332 int x_temp_slot_level;
|
|
|
333
|
|
|
334 /* The largest alignment needed on the stack, including requirement
|
|
|
335 for outgoing stack alignment. */
|
|
|
336 unsigned int stack_alignment_needed;
|
|
|
337
|
|
|
338 /* Preferred alignment of the end of stack frame, which is preferred
|
|
|
339 to call other functions. */
|
|
|
340 unsigned int preferred_stack_boundary;
|
|
|
341
|
|
|
342 /* The minimum alignment of parameter stack. */
|
|
|
343 unsigned int parm_stack_boundary;
|
|
|
344
|
|
|
345 /* The largest alignment of slot allocated on the stack. */
|
|
|
346 unsigned int max_used_stack_slot_alignment;
|
|
|
347
|
|
|
348 /* The stack alignment estimated before reload, with consideration of
|
|
|
349 following factors:
|
|
|
350 1. Alignment of local stack variables (max_used_stack_slot_alignment)
|
|
|
351 2. Alignment requirement to call other functions
|
|
|
352 (preferred_stack_boundary)
|
|
|
353 3. Alignment of non-local stack variables but might be spilled in
|
|
|
354 local stack. */
|
|
|
355 unsigned int stack_alignment_estimated;
|
|
|
356
|
|
|
357 /* For reorg. */
|
|
|
358
|
|
|
359 /* If some insns can be deferred to the delay slots of the epilogue, the
|
|
|
360 delay list for them is recorded here. */
|
|
|
361 rtx epilogue_delay_list;
|
|
|
362
|
|
|
363 /* Nonzero if function being compiled called builtin_return_addr or
|
|
|
364 builtin_frame_address with nonzero count. */
|
|
|
365 bool accesses_prior_frames;
|
|
|
366
|
|
|
367 /* Nonzero if the function calls __builtin_eh_return. */
|
|
|
368 bool calls_eh_return;
|
|
|
369
|
|
|
370 /* Nonzero if function saves all registers, e.g. if it has a nonlocal
|
|
|
371 label that can reach the exit block via non-exceptional paths. */
|
|
|
372 bool saves_all_registers;
|
|
|
373
|
|
|
374 /* Nonzero if function being compiled has nonlocal gotos to parent
|
|
|
375 function. */
|
|
|
376 bool has_nonlocal_goto;
|
|
|
377
|
|
|
378 /* Nonzero if function being compiled has an asm statement. */
|
|
|
379 bool has_asm_statement;
|
|
|
380
|
|
|
381 /* This bit is used by the exception handling logic. It is set if all
|
|
|
382 calls (if any) are sibling calls. Such functions do not have to
|
|
|
383 have EH tables generated, as they cannot throw. A call to such a
|
|
|
384 function, however, should be treated as throwing if any of its callees
|
|
|
385 can throw. */
|
|
|
386 bool all_throwers_are_sibcalls;
|
|
|
387
|
|
|
388 /* Nonzero if stack limit checking should be enabled in the current
|
|
|
389 function. */
|
|
|
390 bool limit_stack;
|
|
|
391
|
|
|
392 /* Nonzero if profiling code should be generated. */
|
|
|
393 bool profile;
|
|
|
394
|
|
|
395 /* Nonzero if the current function uses the constant pool. */
|
|
|
396 bool uses_const_pool;
|
|
|
397
|
|
|
398 /* Nonzero if the current function uses pic_offset_table_rtx. */
|
|
|
399 bool uses_pic_offset_table;
|
|
|
400
|
|
|
401 /* Nonzero if the current function needs an lsda for exception handling. */
|
|
|
402 bool uses_eh_lsda;
|
|
|
403
|
|
|
404 /* Set when the tail call has been produced. */
|
|
|
405 bool tail_call_emit;
|
|
|
406
|
|
|
407 /* Nonzero if code to initialize arg_pointer_save_area has been emitted. */
|
|
|
408 bool arg_pointer_save_area_init;
|
|
|
409
|
|
|
410 /* Nonzero if current function must be given a frame pointer.
|
|
|
411 Set in global.c if anything is allocated on the stack there. */
|
|
|
412 bool frame_pointer_needed;
|
|
|
413
|
|
|
414 /* When set, expand should optimize for speed. */
|
|
|
415 bool maybe_hot_insn_p;
|
|
|
416
|
|
|
417 /* Nonzero if function stack realignment is needed. This flag may be
|
|
|
418 set twice: before and after reload. It is set before reload wrt
|
|
|
419 stack alignment estimation before reload. It will be changed after
|
|
|
420 reload if by then criteria of stack realignment is different.
|
|
|
421 The value set after reload is the accurate one and is finalized. */
|
|
|
422 bool stack_realign_needed;
|
|
|
423
|
|
|
424 /* Nonzero if function stack realignment is tried. This flag is set
|
|
|
425 only once before reload. It affects register elimination. This
|
|
|
426 is used to generate DWARF debug info for stack variables. */
|
|
|
427 bool stack_realign_tried;
|
|
|
428
|
|
|
429 /* Nonzero if function being compiled needs dynamic realigned
|
|
|
430 argument pointer (drap) if stack needs realigning. */
|
|
|
431 bool need_drap;
|
|
|
432
|
|
|
433 /* Nonzero if function stack realignment estimation is done, namely
|
|
|
434 stack_realign_needed flag has been set before reload wrt estimated
|
|
|
435 stack alignment info. */
|
|
|
436 bool stack_realign_processed;
|
|
|
437
|
|
|
438 /* Nonzero if function stack realignment has been finalized, namely
|
|
|
439 stack_realign_needed flag has been set and finalized after reload. */
|
|
|
440 bool stack_realign_finalized;
|
|
|
441
|
|
|
442 /* True if dbr_schedule has already been called for this function. */
|
|
|
443 bool dbr_scheduled_p;
|
|
|
444 };
|
|
|
445
|
|
|
446 #define return_label (crtl->x_return_label)
|
|
|
447 #define naked_return_label (crtl->x_naked_return_label)
|
|
|
448 #define stack_slot_list (crtl->x_stack_slot_list)
|
|
|
449 #define parm_birth_insn (crtl->x_parm_birth_insn)
|
|
|
450 #define frame_offset (crtl->x_frame_offset)
|
|
|
451 #define stack_check_probe_note (crtl->x_stack_check_probe_note)
|
|
|
452 #define arg_pointer_save_area (crtl->x_arg_pointer_save_area)
|
|
|
453 #define used_temp_slots (crtl->x_used_temp_slots)
|
|
|
454 #define avail_temp_slots (crtl->x_avail_temp_slots)
|
|
|
455 #define temp_slot_level (crtl->x_temp_slot_level)
|
|
|
456 #define nonlocal_goto_handler_labels (crtl->x_nonlocal_goto_handler_labels)
|
|
|
457 #define frame_pointer_needed (crtl->frame_pointer_needed)
|
|
|
458 #define stack_realign_fp (crtl->stack_realign_needed && !crtl->need_drap)
|
|
|
459 #define stack_realign_drap (crtl->stack_realign_needed && crtl->need_drap)
|
|
|
460
|
|
|
461 extern GTY(()) struct rtl_data x_rtl;
|
|
|
462
|
|
|
463 /* Accessor to RTL datastructures. We keep them statically allocated now since
|
|
|
464 we never keep multiple functions. For threaded compiler we might however
|
|
|
465 want to do differently. */
|
|
|
466 #define crtl (&x_rtl)
|
|
|
467
|
|
|
468 /* This structure can save all the important global and static variables
|
|
|
469 describing the status of the current function. */
|
|
|
470
|
|
|
471 struct function GTY(())
|
|
|
472 {
|
|
|
473 struct eh_status *eh;
|
|
|
474
|
|
|
475 /* The control flow graph for this function. */
|
|
|
476 struct control_flow_graph *cfg;
|
|
|
477
|
|
|
478 /* GIMPLE body for this function. */
|
|
|
479 struct gimple_seq_d *gimple_body;
|
|
|
480
|
|
|
481 /* SSA and dataflow information. */
|
|
|
482 struct gimple_df *gimple_df;
|
|
|
483
|
|
|
484 /* The loops in this function. */
|
|
|
485 struct loops *x_current_loops;
|
|
|
486
|
|
|
487 /* Value histograms attached to particular statements. */
|
|
|
488 htab_t GTY((skip)) value_histograms;
|
|
|
489
|
|
|
490 /* For function.c. */
|
|
|
491
|
|
|
492 /* Points to the FUNCTION_DECL of this function. */
|
|
|
493 tree decl;
|
|
|
494
|
|
|
495 /* A PARM_DECL that should contain the static chain for this function.
|
|
|
496 It will be initialized at the beginning of the function. */
|
|
|
497 tree static_chain_decl;
|
|
|
498
|
|
|
499 /* An expression that contains the non-local goto save area. The first
|
|
|
500 word is the saved frame pointer and the second is the saved stack
|
|
|
501 pointer. */
|
|
|
502 tree nonlocal_goto_save_area;
|
|
|
503
|
|
|
504 /* List of function local variables, functions, types and constants. */
|
|
|
505 tree local_decls;
|
|
|
506
|
|
|
507 /* For md files. */
|
|
|
508
|
|
|
509 /* tm.h can use this to store whatever it likes. */
|
|
|
510 struct machine_function * GTY ((maybe_undef)) machine;
|
|
|
511
|
|
|
512 /* Language-specific code can use this to store whatever it likes. */
|
|
|
513 struct language_function * language;
|
|
|
514
|
|
|
515 /* Used types hash table. */
|
|
|
516 htab_t GTY ((param_is (union tree_node))) used_types_hash;
|
|
|
517
|
|
|
518 /* Last statement uid. */
|
|
|
519 int last_stmt_uid;
|
|
|
520
|
|
|
521 /* Function sequence number for profiling, debugging, etc. */
|
|
|
522 int funcdef_no;
|
|
|
523
|
|
|
524 /* Line number of the start of the function for debugging purposes. */
|
|
|
525 location_t function_start_locus;
|
|
|
526
|
|
|
527 /* Line number of the end of the function. */
|
|
|
528 location_t function_end_locus;
|
|
|
529
|
|
|
530 /* Properties used by the pass manager. */
|
|
|
531 unsigned int curr_properties;
|
|
|
532 unsigned int last_verified;
|
|
|
533 /* Interprocedural passes scheduled to have their transform functions
|
|
|
534 applied next time we execute local pass on them. We maintain it
|
|
|
535 per-function in order to allow IPA passes to introduce new functions. */
|
|
|
536 VEC(ipa_opt_pass,heap) * GTY((skip)) ipa_transforms_to_apply;
|
|
|
537
|
|
|
538 /* Collected bit flags. */
|
|
|
539
|
|
|
540 /* Number of units of general registers that need saving in stdarg
|
|
|
541 function. What unit is depends on the backend, either it is number
|
|
|
542 of bytes, or it can be number of registers. */
|
|
|
543 unsigned int va_list_gpr_size : 8;
|
|
|
544
|
|
|
545 /* Number of units of floating point registers that need saving in stdarg
|
|
|
546 function. */
|
|
|
547 unsigned int va_list_fpr_size : 8;
|
|
|
548
|
|
|
549
|
|
|
550 /* How commonly executed the function is. Initialized during branch
|
|
|
551 probabilities pass. */
|
|
|
552 ENUM_BITFIELD (function_frequency) function_frequency : 2;
|
|
|
553
|
|
|
554 /* Nonzero if function being compiled can call setjmp. */
|
|
|
555 unsigned int calls_setjmp : 1;
|
|
|
556
|
|
|
557 /* Nonzero if function being compiled can call alloca,
|
|
|
558 either as a subroutine or builtin. */
|
|
|
559 unsigned int calls_alloca : 1;
|
|
|
560
|
|
|
561 /* Nonzero if function being compiled receives nonlocal gotos
|
|
|
562 from nested functions. */
|
|
|
563 unsigned int has_nonlocal_label : 1;
|
|
|
564
|
|
|
565 /* Nonzero if current function uses stdarg.h or equivalent. */
|
|
|
566 unsigned int stdarg : 1;
|
|
|
567
|
|
|
568 /* Nonzero if the back-end should not keep track of expressions that
|
|
|
569 determine the size of variable-sized objects. Normally, such
|
|
|
570 expressions are saved away, and then expanded when the next
|
|
|
571 function is started. For example, if a parameter has a
|
|
|
572 variable-sized type, then the size of the parameter is computed
|
|
|
573 when the function body is entered. However, some front-ends do
|
|
|
574 not desire this behavior. */
|
|
|
575 unsigned int dont_save_pending_sizes_p : 1;
|
|
|
576
|
|
|
577 unsigned int after_inlining : 1;
|
|
|
578 unsigned int always_inline_functions_inlined : 1;
|
|
|
579
|
|
|
580 /* Fields below this point are not set for abstract functions; see
|
|
|
581 allocate_struct_function. */
|
|
|
582
|
|
|
583 /* Nonzero if function being compiled needs to be given an address
|
|
|
584 where the value should be stored. */
|
|
|
585 unsigned int returns_struct : 1;
|
|
|
586
|
|
|
587 /* Nonzero if function being compiled needs to
|
|
|
588 return the address of where it has put a structure value. */
|
|
|
589 unsigned int returns_pcc_struct : 1;
|
|
|
590
|
|
|
591 /* Nonzero if pass_tree_profile was run on this function. */
|
|
|
592 unsigned int after_tree_profile : 1;
|
|
|
593
|
|
|
594 /* Nonzero if this function has local DECL_HARD_REGISTER variables.
|
|
|
595 In this case code motion has to be done more carefully. */
|
|
|
596 unsigned int has_local_explicit_reg_vars : 1;
|
|
|
597
|
|
|
598 /* Nonzero if the current function is a thunk, i.e., a lightweight
|
|
|
599 function implemented by the output_mi_thunk hook) that just
|
|
|
600 adjusts one of its arguments and forwards to another
|
|
|
601 function. */
|
|
|
602 unsigned int is_thunk : 1;
|
|
|
603 };
|
|
|
604
|
|
|
605 /* If va_list_[gf]pr_size is set to this, it means we don't know how
|
|
|
606 many units need to be saved. */
|
|
|
607 #define VA_LIST_MAX_GPR_SIZE 255
|
|
|
608 #define VA_LIST_MAX_FPR_SIZE 255
|
|
|
609
|
|
|
610 /* The function currently being compiled. */
|
|
|
611 extern GTY(()) struct function *cfun;
|
|
|
612
|
|
|
613 /* In order to ensure that cfun is not set directly, we redefine it so
|
|
|
614 that it is not an lvalue. Rather than assign to cfun, use
|
|
|
615 push_cfun or set_cfun. */
|
|
|
616 #define cfun (cfun + 0)
|
|
|
617
|
|
|
618 /* Nonzero if we've already converted virtual regs to hard regs. */
|
|
|
619 extern int virtuals_instantiated;
|
|
|
620
|
|
|
621 /* Nonzero if at least one trampoline has been created. */
|
|
|
622 extern int trampolines_created;
|
|
|
623
|
|
|
624 /* cfun shouldn't be set directly; use one of these functions instead. */
|
|
|
625 extern void set_cfun (struct function *new_cfun);
|
|
|
626 extern void push_cfun (struct function *new_cfun);
|
|
|
627 extern void pop_cfun (void);
|
|
|
628 extern void instantiate_decl_rtl (rtx x);
|
|
|
629
|
|
|
630 /* For backward compatibility... eventually these should all go away. */
|
|
|
631 #define current_function_funcdef_no (cfun->funcdef_no)
|
|
|
632
|
|
|
633 #define current_loops (cfun->x_current_loops)
|
|
|
634 #define dom_computed (cfun->cfg->x_dom_computed)
|
|
|
635 #define n_bbs_in_dom_tree (cfun->cfg->x_n_bbs_in_dom_tree)
|
|
|
636 #define VALUE_HISTOGRAMS(fun) (fun)->value_histograms
|
|
|
637
|
|
|
638 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
|
|
|
639 and create duplicate blocks. */
|
|
|
640 extern void reorder_blocks (void);
|
|
|
641
|
|
|
642 /* Set BLOCK_NUMBER for all the blocks in FN. */
|
|
|
643 extern void number_blocks (tree);
|
|
|
644
|
|
|
645 extern void clear_block_marks (tree);
|
|
|
646 extern tree blocks_nreverse (tree);
|
|
|
647
|
|
|
648 /* Return size needed for stack frame based on slots so far allocated.
|
|
|
649 This size counts from zero. It is not rounded to STACK_BOUNDARY;
|
|
|
650 the caller may have to do that. */
|
|
|
651 extern HOST_WIDE_INT get_frame_size (void);
|
|
|
652
|
|
|
653 /* Issue an error message and return TRUE if frame OFFSET overflows in
|
|
|
654 the signed target pointer arithmetics for function FUNC. Otherwise
|
|
|
655 return FALSE. */
|
|
|
656 extern bool frame_offset_overflow (HOST_WIDE_INT, tree);
|
|
|
657
|
|
|
658 /* A pointer to a function to create target specific, per-function
|
|
|
659 data structures. */
|
|
|
660 extern struct machine_function * (*init_machine_status) (void);
|
|
|
661
|
|
|
662 /* Save and restore status information for a nested function. */
|
|
|
663 extern void free_after_parsing (struct function *);
|
|
|
664 extern void free_after_compilation (struct function *);
|
|
|
665
|
|
|
666 extern void init_varasm_status (void);
|
|
|
667
|
|
|
668 #ifdef RTX_CODE
|
|
|
669 extern void diddle_return_value (void (*)(rtx, void*), void*);
|
|
|
670 extern void clobber_return_register (void);
|
|
|
671 #endif
|
|
|
672
|
|
|
673 extern rtx get_arg_pointer_save_area (void);
|
|
|
674
|
|
|
675 /* Returns the name of the current function. */
|
|
|
676 extern const char *current_function_name (void);
|
|
|
677 /* Returns the assembler name (raw, mangled) of the current function. */
|
|
|
678 extern const char *current_function_assembler_name (void);
|
|
|
679
|
|
|
680 extern void do_warn_unused_parameter (tree);
|
|
|
681
|
|
|
682 extern bool pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
|
|
|
683 tree, bool);
|
|
|
684 extern bool reference_callee_copied (CUMULATIVE_ARGS *, enum machine_mode,
|
|
|
685 tree, bool);
|
|
|
686
|
|
|
687 extern void used_types_insert (tree);
|
|
|
688
|
|
|
689 extern int get_next_funcdef_no (void);
|
|
|
690 #endif /* GCC_FUNCTION_H */
|
