gcc/function.h

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