1 /* Structure for saving state for a nested function. 2 Copyright (C) 1989-2024 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #ifndef GCC_FUNCTION_H 21 #define GCC_FUNCTION_H 22 23 24 /* Stack of pending (incomplete) sequences saved by `start_sequence'. 25 Each element describes one pending sequence. 26 The main insn-chain is saved in the last element of the chain, 27 unless the chain is empty. */ 28 29 struct GTY(()) sequence_stack { 30 /* First and last insns in the chain of the saved sequence. */ 31 rtx_insn *first; 32 rtx_insn *last; 33 struct sequence_stack *next; 34 }; 35 36 struct GTY(()) emit_status { 38 void ensure_regno_capacity (); 39 40 /* This is reset to LAST_VIRTUAL_REGISTER + 1 at the start of each function. 41 After rtl generation, it is 1 plus the largest register number used. */ 42 int x_reg_rtx_no; 43 44 /* Lowest label number in current function. */ 45 int x_first_label_num; 46 47 /* seq.first and seq.last are the ends of the doubly-linked chain of 48 rtl for the current function. Both are reset to null at the 49 start of rtl generation for the function. 50 51 start_sequence saves both of these on seq.next and then starts 52 a new, nested sequence of insns. 53 54 seq.next is a stack of pending (incomplete) sequences saved by 55 start_sequence. Each element describes one pending sequence. 56 The main insn-chain is the last element of the chain. */ 57 struct sequence_stack seq; 58 59 /* INSN_UID for next insn emitted. 60 Reset to 1 for each function compiled. */ 61 int x_cur_insn_uid; 62 63 /* INSN_UID for next debug insn emitted. Only used if 64 --param min-nondebug-insn-uid=<value> is given with nonzero value. */ 65 int x_cur_debug_insn_uid; 66 67 /* The length of the regno_pointer_align, regno_decl, and x_regno_reg_rtx 68 vectors. Since these vectors are needed during the expansion phase when 69 the total number of registers in the function is not yet known, the 70 vectors are copied and made bigger when necessary. */ 71 int regno_pointer_align_length; 72 73 /* Indexed by pseudo register number, if nonzero gives the known alignment 74 for that pseudo (if REG_POINTER is set in x_regno_reg_rtx). 75 Allocated in parallel with x_regno_reg_rtx. */ 76 unsigned char * GTY((skip)) regno_pointer_align; 77 }; 78 79 80 /* Indexed by register number, gives an rtx for that register (and only 81 that register). For pseudo registers, it is the unique rtx for 82 that pseudo. For hard registers, it is an rtx of the mode specified 83 by reg_raw_mode. 84 85 FIXME: We could put it into emit_status struct, but gengtype is not 86 able to deal with length attribute nested in top level structures. */ 87 88 extern GTY ((length ("crtl->emit.x_reg_rtx_no"))) rtx * regno_reg_rtx; 89 90 /* For backward compatibility... eventually these should all go away. */ 91 #define reg_rtx_no (crtl->emit.x_reg_rtx_no) 92 93 #define REGNO_POINTER_ALIGN(REGNO) (crtl->emit.regno_pointer_align[REGNO]) 94 95 struct GTY(()) expr_status { 96 /* Number of units that we should eventually pop off the stack. 97 These are the arguments to function calls that have already returned. */ 98 poly_int64 x_pending_stack_adjust; 99 100 /* Under some ABIs, it is the caller's responsibility to pop arguments 101 pushed for function calls. A naive implementation would simply pop 102 the arguments immediately after each call. However, if several 103 function calls are made in a row, it is typically cheaper to pop 104 all the arguments after all of the calls are complete since a 105 single pop instruction can be used. Therefore, GCC attempts to 106 defer popping the arguments until absolutely necessary. (For 107 example, at the end of a conditional, the arguments must be popped, 108 since code outside the conditional won't know whether or not the 109 arguments need to be popped.) 110 111 When INHIBIT_DEFER_POP is nonzero, however, the compiler does not 112 attempt to defer pops. Instead, the stack is popped immediately 113 after each call. Rather then setting this variable directly, use 114 NO_DEFER_POP and OK_DEFER_POP. */ 115 int x_inhibit_defer_pop; 116 117 /* If PREFERRED_STACK_BOUNDARY and PUSH_ROUNDING are defined, the stack 118 boundary can be momentarily unaligned while pushing the arguments. 119 Record the delta since last aligned boundary here in order to get 120 stack alignment in the nested function calls working right. */ 121 poly_int64 x_stack_pointer_delta; 122 123 /* Nonzero means __builtin_saveregs has already been done in this function. 124 The value is the pseudoreg containing the value __builtin_saveregs 125 returned. */ 126 rtx x_saveregs_value; 127 128 /* Similarly for __builtin_apply_args. */ 129 rtx x_apply_args_value; 130 131 /* List of labels that must never be deleted. */ 132 vec<rtx_insn *, va_gc> *x_forced_labels; 133 }; 134 135 typedef struct call_site_record_d *call_site_record; 136 137 /* RTL representation of exception handling. */ 138 struct GTY(()) rtl_eh { 139 rtx ehr_stackadj; 140 rtx ehr_handler; 141 rtx_code_label *ehr_label; 142 143 rtx sjlj_fc; 144 rtx_insn *sjlj_exit_after; 145 146 vec<uchar, va_gc> *action_record_data; 147 148 vec<call_site_record, va_gc> *call_site_record_v[2]; 149 }; 150 151 #define pending_stack_adjust (crtl->expr.x_pending_stack_adjust) 152 #define inhibit_defer_pop (crtl->expr.x_inhibit_defer_pop) 153 #define saveregs_value (crtl->expr.x_saveregs_value) 154 #define apply_args_value (crtl->expr.x_apply_args_value) 155 #define forced_labels (crtl->expr.x_forced_labels) 156 #define stack_pointer_delta (crtl->expr.x_stack_pointer_delta) 157 158 struct gimple_df; 159 struct call_site_record_d; 160 struct dw_fde_node; 161 class range_query; 162 163 struct GTY(()) varasm_status { 164 /* If we're using a per-function constant pool, this is it. */ 165 struct rtx_constant_pool *pool; 166 167 /* Number of tree-constants deferred during the expansion of this 168 function. */ 169 unsigned int deferred_constants; 170 }; 171 172 173 /* Data for function partitioning. */ 174 struct GTY(()) function_subsections { 175 /* Assembly labels for the hot and cold text sections, to 176 be used by debugger functions for determining the size of text 177 sections. */ 178 179 const char *hot_section_label; 180 const char *cold_section_label; 181 const char *hot_section_end_label; 182 const char *cold_section_end_label; 183 }; 184 185 /* Describe an empty area of space in the stack frame. These can be chained 186 into a list; this is used to keep track of space wasted for alignment 187 reasons. */ 188 class GTY(()) frame_space 189 { 190 public: 191 class frame_space *next; 192 193 poly_int64 start; 194 poly_int64 length; 195 }; 196 197 /* Describe emitted calls for -fcallgraph-info. */ 198 struct GTY(()) callinfo_callee 199 { 200 location_t location; 201 tree decl; 202 }; 203 204 /* Describe dynamic allocation for -fcallgraph-info=da. */ 205 struct GTY(()) callinfo_dalloc 206 { 207 location_t location; 208 char const *name; 209 }; 210 211 class GTY(()) stack_usage 212 { 213 public: 214 /* # of bytes of static stack space allocated by the function. */ 215 HOST_WIDE_INT static_stack_size; 216 217 /* # of bytes of dynamic stack space allocated by the function. This is 218 meaningful only if has_unbounded_dynamic_stack_size is zero. */ 219 HOST_WIDE_INT dynamic_stack_size; 220 221 /* Upper bound on the number of bytes pushed onto the stack after the 222 prologue. If !ACCUMULATE_OUTGOING_ARGS, it contains the outgoing 223 arguments. */ 224 poly_int64 pushed_stack_size; 225 226 /* Nonzero if the amount of stack space allocated dynamically cannot 227 be bounded at compile-time. */ 228 unsigned int has_unbounded_dynamic_stack_size : 1; 229 230 /* Functions called within the function, if callgraph is enabled. */ 231 vec<callinfo_callee, va_gc> *callees; 232 233 /* Dynamic allocations encountered within the function, if callgraph 234 da is enabled. */ 235 vec<callinfo_dalloc, va_gc> *dallocs; 236 }; 237 238 #define current_function_static_stack_size (cfun->su->static_stack_size) 239 #define current_function_dynamic_stack_size (cfun->su->dynamic_stack_size) 240 #define current_function_pushed_stack_size (cfun->su->pushed_stack_size) 241 #define current_function_has_unbounded_dynamic_stack_size \ 242 (cfun->su->has_unbounded_dynamic_stack_size) 243 #define current_function_allocates_dynamic_stack_space \ 244 (current_function_dynamic_stack_size != 0 \ 245 || current_function_has_unbounded_dynamic_stack_size) 246 247 /* This structure can save all the important global and static variables 248 describing the status of the current function. */ 249 250 struct GTY(()) function { 251 struct eh_status *eh; 252 253 /* The control flow graph for this function. */ 254 struct control_flow_graph *cfg; 255 256 /* GIMPLE body for this function. */ 257 gimple_seq gimple_body; 258 259 /* SSA and dataflow information. */ 260 struct gimple_df *gimple_df; 261 262 /* The loops in this function. */ 263 struct loops *x_current_loops; 264 265 /* Filled by the GIMPLE and RTL FEs, pass to start compilation with. */ 266 char *pass_startwith; 267 268 /* The stack usage of this function. */ 269 class stack_usage *su; 270 271 /* Value histograms attached to particular statements. */ 272 htab_t GTY((skip)) value_histograms; 273 274 /* Annotated gconds so that basic conditions in the same expression map to 275 the same uid. This is used for condition coverage. */ 276 hash_map <gcond*, unsigned> *GTY((skip)) cond_uids; 277 278 /* For function.cc. */ 279 280 /* Points to the FUNCTION_DECL of this function. */ 281 tree decl; 282 283 /* A PARM_DECL that should contain the static chain for this function. 284 It will be initialized at the beginning of the function. */ 285 tree static_chain_decl; 286 287 /* An expression that contains the non-local goto save area. The first 288 word is the saved frame pointer and the second is the saved stack 289 pointer. */ 290 tree nonlocal_goto_save_area; 291 292 /* Vector of function local variables, functions, types and constants. */ 293 vec<tree, va_gc> *local_decls; 294 295 /* For md files. */ 296 297 /* tm.h can use this to store whatever it likes. */ 298 struct machine_function * GTY ((maybe_undef)) machine; 299 300 /* Language-specific code can use this to store whatever it likes. */ 301 struct language_function * language; 302 303 /* Used types hash table. */ 304 hash_set<tree> *GTY (()) used_types_hash; 305 306 /* Dwarf2 Frame Description Entry, containing the Call Frame Instructions 307 used for unwinding. Only set when either dwarf2 unwinding or dwarf2 308 debugging is enabled. */ 309 struct dw_fde_node *fde; 310 311 /* Range query mechanism for functions. The default is to pick up 312 global ranges. If a pass wants on-demand ranges OTOH, it must 313 call enable/disable_ranger(). The pointer is never null. It 314 should be queried by calling get_range_query(). */ 315 range_query * GTY ((skip)) x_range_query; 316 317 /* Last statement uid. */ 318 int last_stmt_uid; 319 320 /* Debug marker counter. Count begin stmt markers. We don't have 321 to keep it exact, it's more of a rough estimate to enable us to 322 decide whether they are too many to copy during inlining, or when 323 expanding to RTL. */ 324 int debug_marker_count; 325 326 /* Function sequence number for profiling, debugging, etc. */ 327 int funcdef_no; 328 329 /* Line number of the start of the function for debugging purposes. */ 330 location_t function_start_locus; 331 332 /* Line number of the end of the function. */ 333 location_t function_end_locus; 334 335 /* Properties used by the pass manager. */ 336 unsigned int curr_properties; 337 unsigned int last_verified; 338 339 /* Different from normal TODO_flags which are handled right at the 340 beginning or the end of one pass execution, the pending_TODOs 341 are passed down in the pipeline until one of its consumers can 342 perform the requested action. Consumers should then clear the 343 flags for the actions that they have taken. */ 344 unsigned int pending_TODOs; 345 346 /* Non-null if the function does something that would prevent it from 347 being copied; this applies to both versioning and inlining. Set to 348 a string describing the reason for failure. */ 349 const char * GTY((skip)) cannot_be_copied_reason; 350 351 /* Last assigned dependence info clique. */ 352 unsigned short last_clique; 353 354 /* Collected bit flags. */ 355 356 /* Number of units of general registers that need saving in stdarg 357 function. What unit is depends on the backend, either it is number 358 of bytes, or it can be number of registers. */ 359 unsigned int va_list_gpr_size : 8; 360 361 /* Number of units of floating point registers that need saving in stdarg 362 function. */ 363 unsigned int va_list_fpr_size : 8; 364 365 /* Nonzero if function being compiled can call setjmp. */ 366 unsigned int calls_setjmp : 1; 367 368 /* Nonzero if function being compiled can call alloca, 369 either as a subroutine or builtin. */ 370 unsigned int calls_alloca : 1; 371 372 /* Nonzero if function being compiled can call __builtin_eh_return. */ 373 unsigned int calls_eh_return : 1; 374 375 /* Nonzero if function being compiled receives nonlocal gotos 376 from nested functions. */ 377 unsigned int has_nonlocal_label : 1; 378 379 /* Nonzero if function being compiled has a forced label 380 placed into static storage. */ 381 unsigned int has_forced_label_in_static : 1; 382 383 /* Nonzero if we've set cannot_be_copied_reason. I.e. if 384 (cannot_be_copied_set && !cannot_be_copied_reason), the function 385 can in fact be copied. */ 386 unsigned int cannot_be_copied_set : 1; 387 388 /* Nonzero if current function uses stdarg.h or equivalent. */ 389 unsigned int stdarg : 1; 390 391 unsigned int after_inlining : 1; 392 unsigned int always_inline_functions_inlined : 1; 393 394 /* Nonzero if function being compiled can throw synchronous non-call 395 exceptions. */ 396 unsigned int can_throw_non_call_exceptions : 1; 397 398 /* Nonzero if instructions that may throw exceptions but don't otherwise 399 contribute to the execution of the program can be deleted. */ 400 unsigned int can_delete_dead_exceptions : 1; 401 402 /* Fields below this point are not set for abstract functions; see 403 allocate_struct_function. */ 404 405 /* Nonzero if function being compiled needs to be given an address 406 where the value should be stored. */ 407 unsigned int returns_struct : 1; 408 409 /* Nonzero if function being compiled needs to 410 return the address of where it has put a structure value. */ 411 unsigned int returns_pcc_struct : 1; 412 413 /* Nonzero if this function has local DECL_HARD_REGISTER variables. 414 In this case code motion has to be done more carefully. */ 415 unsigned int has_local_explicit_reg_vars : 1; 416 417 /* Nonzero if the current function is a thunk, i.e., a lightweight 418 function implemented by the output_mi_thunk hook) that just 419 adjusts one of its arguments and forwards to another 420 function. */ 421 unsigned int is_thunk : 1; 422 423 /* Nonzero if the current function contains any loops with 424 loop->force_vectorize set. */ 425 unsigned int has_force_vectorize_loops : 1; 426 427 /* Nonzero if the current function contains any loops with 428 nonzero value in loop->simduid. */ 429 unsigned int has_simduid_loops : 1; 430 431 /* Nonzero when the tail call has been identified. */ 432 unsigned int tail_call_marked : 1; 433 434 /* Nonzero if the current function contains a #pragma GCC unroll. */ 435 unsigned int has_unroll : 1; 436 437 /* Set when the function was compiled with generation of debug 438 (begin stmt, inline entry, ...) markers enabled. */ 439 unsigned int debug_nonbind_markers : 1; 440 441 /* Set if this is a coroutine-related function. */ 442 unsigned int coroutine_component : 1; 443 444 /* Set if there are any OMP_TARGET regions in the function. */ 445 unsigned int has_omp_target : 1; 446 447 /* Set for artificial function created for [[assume (cond)]]. 448 These should be GIMPLE optimized, but not expanded to RTL. */ 449 unsigned int assume_function : 1; 450 }; 451 452 /* Add the decl D to the local_decls list of FUN. */ 453 454 void add_local_decl (struct function *fun, tree d); 455 456 #define FOR_EACH_LOCAL_DECL(FUN, I, D) \ 457 FOR_EACH_VEC_SAFE_ELT_REVERSE ((FUN)->local_decls, I, D) 458 459 /* Record a final call to CALLEE at LOCATION. */ 460 void record_final_call (tree callee, location_t location); 461 462 /* Record a dynamic allocation made for DECL_OR_EXP. */ 463 void record_dynamic_alloc (tree decl_or_exp); 464 465 /* If va_list_[gf]pr_size is set to this, it means we don't know how 466 many units need to be saved. */ 467 #define VA_LIST_MAX_GPR_SIZE 255 468 #define VA_LIST_MAX_FPR_SIZE 255 469 470 /* The function currently being compiled. */ 471 extern GTY(()) struct function *cfun; 472 473 /* In order to ensure that cfun is not set directly, we redefine it so 474 that it is not an lvalue. Rather than assign to cfun, use 475 push_cfun or set_cfun. */ 476 #define cfun (cfun + 0) 477 478 /* Nonzero if we've already converted virtual regs to hard regs. */ 479 extern int virtuals_instantiated; 480 481 /* Nonzero if at least one trampoline has been created. */ 482 extern int trampolines_created; 483 484 struct GTY((for_user)) types_used_by_vars_entry { 485 tree type; 486 tree var_decl; 487 }; 488 489 struct used_type_hasher : ggc_ptr_hash<types_used_by_vars_entry> 490 { 491 static hashval_t hash (types_used_by_vars_entry *); 492 static bool equal (types_used_by_vars_entry *, types_used_by_vars_entry *); 493 }; 494 495 /* Hash table making the relationship between a global variable 496 and the types it references in its initializer. The key of the 497 entry is a referenced type, and the value is the DECL of the global 498 variable. types_use_by_vars_do_hash and types_used_by_vars_eq below are 499 the hash and equality functions to use for this hash table. */ 500 extern GTY(()) hash_table<used_type_hasher> *types_used_by_vars_hash; 501 502 void types_used_by_var_decl_insert (tree type, tree var_decl); 503 504 /* During parsing of a global variable, this vector contains the types 505 referenced by the global variable. */ 506 extern GTY(()) vec<tree, va_gc> *types_used_by_cur_var_decl; 507 508 509 /* Return the loop tree of FN. */ 510 511 inline struct loops * 512 loops_for_fn (struct function *fn) 513 { 514 return fn->x_current_loops; 515 } 516 517 /* Set the loop tree of FN to LOOPS. */ 518 519 inline void 520 set_loops_for_fn (struct function *fn, struct loops *loops) 521 { 522 gcc_checking_assert (fn->x_current_loops == NULL || loops == NULL); 523 fn->x_current_loops = loops; 524 } 525 526 /* Get a new unique dependence clique or zero if none is left. */ 527 528 inline unsigned short 529 get_new_clique (function *fn) 530 { 531 unsigned short clique = fn->last_clique + 1; 532 if (clique != 0) 533 fn->last_clique = clique; 534 return clique; 535 } 536 537 /* For backward compatibility... eventually these should all go away. */ 538 #define current_function_funcdef_no (cfun->funcdef_no) 539 540 #define current_loops (cfun->x_current_loops) 541 #define dom_computed (cfun->cfg->x_dom_computed) 542 #define n_bbs_in_dom_tree (cfun->cfg->x_n_bbs_in_dom_tree) 543 #define VALUE_HISTOGRAMS(fun) (fun)->value_histograms 544 545 /* A pointer to a function to create target specific, per-function 546 data structures. */ 547 extern struct machine_function * (*init_machine_status) (void); 548 549 /* Structure to record the size of a sequence of arguments 550 as the sum of a tree-expression and a constant. This structure is 551 also used to store offsets from the stack, which might be negative, 552 so the variable part must be ssizetype, not sizetype. */ 553 554 struct args_size 555 { 556 poly_int64 constant; 557 tree var; 558 }; 559 560 /* Package up various arg related fields of struct args for 561 locate_and_pad_parm. */ 562 struct locate_and_pad_arg_data 563 { 564 /* Size of this argument on the stack, rounded up for any padding it 565 gets. If REG_PARM_STACK_SPACE is defined, then register parms are 566 counted here, otherwise they aren't. */ 567 struct args_size size; 568 /* Offset of this argument from beginning of stack-args. */ 569 struct args_size offset; 570 /* Offset to the start of the stack slot. Different from OFFSET 571 if this arg pads downward. */ 572 struct args_size slot_offset; 573 /* The amount that the stack pointer needs to be adjusted to 574 force alignment for the next argument. */ 575 struct args_size alignment_pad; 576 /* Which way we should pad this arg. */ 577 pad_direction where_pad; 578 /* slot_offset is at least this aligned. */ 579 unsigned int boundary; 580 }; 581 582 /* Add the value of the tree INC to the `struct args_size' TO. */ 583 584 #define ADD_PARM_SIZE(TO, INC) \ 585 do { \ 586 tree inc = (INC); \ 587 if (tree_fits_shwi_p (inc)) \ 588 (TO).constant += tree_to_shwi (inc); \ 589 else if ((TO).var == 0) \ 590 (TO).var = fold_convert (ssizetype, inc); \ 591 else \ 592 (TO).var = size_binop (PLUS_EXPR, (TO).var, \ 593 fold_convert (ssizetype, inc)); \ 594 } while (0) 595 596 #define SUB_PARM_SIZE(TO, DEC) \ 597 do { \ 598 tree dec = (DEC); \ 599 if (tree_fits_shwi_p (dec)) \ 600 (TO).constant -= tree_to_shwi (dec); \ 601 else if ((TO).var == 0) \ 602 (TO).var = size_binop (MINUS_EXPR, ssize_int (0), \ 603 fold_convert (ssizetype, dec)); \ 604 else \ 605 (TO).var = size_binop (MINUS_EXPR, (TO).var, \ 606 fold_convert (ssizetype, dec)); \ 607 } while (0) 608 609 /* Convert the implicit sum in a `struct args_size' into a tree 610 of type ssizetype. */ 611 #define ARGS_SIZE_TREE(SIZE) \ 612 ((SIZE).var == 0 ? ssize_int ((SIZE).constant) \ 613 : size_binop (PLUS_EXPR, fold_convert (ssizetype, (SIZE).var), \ 614 ssize_int ((SIZE).constant))) 615 616 /* Convert the implicit sum in a `struct args_size' into an rtx. */ 617 #define ARGS_SIZE_RTX(SIZE) \ 618 ((SIZE).var == 0 ? gen_int_mode ((SIZE).constant, Pmode) \ 619 : expand_normal (ARGS_SIZE_TREE (SIZE))) 620 621 #define ASLK_REDUCE_ALIGN 1 622 #define ASLK_RECORD_PAD 2 623 624 /* If pointers to member functions use the least significant bit to 625 indicate whether a function is virtual, ensure a pointer 626 to this function will have that bit clear. */ 627 #define MINIMUM_METHOD_BOUNDARY \ 628 ((TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn) \ 629 ? MAX (FUNCTION_BOUNDARY, 2 * BITS_PER_UNIT) : FUNCTION_BOUNDARY) 630 631 enum stack_clash_probes { 632 NO_PROBE_NO_FRAME, 633 NO_PROBE_SMALL_FRAME, 634 PROBE_INLINE, 635 PROBE_LOOP 636 }; 637 638 extern void dump_stack_clash_frame_info (enum stack_clash_probes, bool); 639 640 642 extern void push_function_context (void); 643 extern void pop_function_context (void); 644 645 /* Save and restore status information for a nested function. */ 646 extern void free_after_parsing (struct function *); 647 extern void free_after_compilation (struct function *); 648 649 /* Return size needed for stack frame based on slots so far allocated. 650 This size counts from zero. It is not rounded to STACK_BOUNDARY; 651 the caller may have to do that. */ 652 extern poly_int64 get_frame_size (void); 653 654 /* Issue an error message and return TRUE if frame OFFSET overflows in 655 the signed target pointer arithmetics for function FUNC. Otherwise 656 return FALSE. */ 657 extern bool frame_offset_overflow (poly_int64, tree); 658 659 extern unsigned int spill_slot_alignment (machine_mode); 660 661 extern rtx assign_stack_local_1 (machine_mode, poly_int64, int, int); 662 extern rtx assign_stack_local (machine_mode, poly_int64, int); 663 extern rtx assign_stack_temp_for_type (machine_mode, poly_int64, tree); 664 extern rtx assign_stack_temp (machine_mode, poly_int64); 665 extern rtx assign_temp (tree, int, int); 666 extern void update_temp_slot_address (rtx, rtx); 667 extern void preserve_temp_slots (rtx); 668 extern void free_temp_slots (void); 669 extern void push_temp_slots (void); 670 extern void pop_temp_slots (void); 671 extern void init_temp_slots (void); 672 extern rtx get_hard_reg_initial_reg (rtx); 673 extern rtx get_hard_reg_initial_val (machine_mode, unsigned int); 674 extern rtx has_hard_reg_initial_val (machine_mode, unsigned int); 675 676 /* Called from gimple_expand_cfg. */ 677 extern void emit_initial_value_sets (void); 678 679 extern bool initial_value_entry (int i, rtx *, rtx *); 680 extern void instantiate_decl_rtl (rtx x); 681 extern bool aggregate_value_p (const_tree, const_tree); 682 extern bool use_register_for_decl (const_tree); 683 extern gimple_seq gimplify_parameters (gimple_seq *); 684 extern void locate_and_pad_parm (machine_mode, tree, int, int, int, 685 tree, struct args_size *, 686 struct locate_and_pad_arg_data *); 687 extern void generate_setjmp_warnings (void); 688 689 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END}, 690 and create duplicate blocks. */ 691 extern void reorder_blocks (void); 692 extern void clear_block_marks (tree); 693 extern tree blocks_nreverse (tree); 694 extern tree block_chainon (tree, tree); 695 696 /* Set BLOCK_NUMBER for all the blocks in FN. */ 697 extern void number_blocks (tree); 698 699 /* cfun shouldn't be set directly; use one of these functions instead. */ 700 extern void set_cfun (struct function *new_cfun, bool force = false); 701 extern void push_cfun (struct function *new_cfun); 702 extern void pop_cfun (void); 703 704 extern int get_next_funcdef_no (void); 705 extern int get_last_funcdef_no (void); 706 extern void allocate_struct_function (tree, bool); 707 extern void push_struct_function (tree fndecl, bool = false); 708 extern void push_dummy_function (bool); 709 extern void pop_dummy_function (void); 710 extern void init_dummy_function_start (void); 711 extern void init_function_start (tree); 712 extern void stack_protect_epilogue (void); 713 extern void expand_function_start (tree); 714 extern void expand_dummy_function_end (void); 715 716 extern void thread_prologue_and_epilogue_insns (void); 717 extern void diddle_return_value (void (*)(rtx, void*), void*); 718 extern void clobber_return_register (void); 719 extern void expand_function_end (void); 720 extern rtx get_arg_pointer_save_area (void); 721 extern void maybe_copy_prologue_epilogue_insn (rtx, rtx); 722 extern bool prologue_contains (const rtx_insn *); 723 extern bool epilogue_contains (const rtx_insn *); 724 extern bool prologue_epilogue_contains (const rtx_insn *); 725 extern void record_prologue_seq (rtx_insn *); 726 extern void record_epilogue_seq (rtx_insn *); 727 extern void emit_return_into_block (bool simple_p, basic_block bb); 728 extern void set_return_jump_label (rtx_insn *); 729 extern bool active_insn_between (rtx_insn *head, rtx_insn *tail); 730 extern vec<edge> convert_jumps_to_returns (basic_block last_bb, bool simple_p, 731 vec<edge> unconverted); 732 extern basic_block emit_return_for_exit (edge exit_fallthru_edge, 733 bool simple_p); 734 extern void reposition_prologue_and_epilogue_notes (void); 735 extern poly_int64 get_stack_dynamic_offset (); 736 737 /* Returns the name of the current function. */ 738 extern const char *fndecl_name (tree); 739 extern const char *function_name (const function *); 740 extern const char *current_function_name (void); 741 742 extern void used_types_insert (tree); 743 744 extern bool currently_expanding_function_start; 745 746 #endif /* GCC_FUNCTION_H */ 747
Indexes created Mon Jul 20 00:27:07 UTC 2026