gcc/emit-rtl.h

   1 /* Exported functions from emit-rtl.c
   2    Copyright (C) 2004-2020 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_EMIT_RTL_H
  21 #define GCC_EMIT_RTL_H
  22
  23 class temp_slot;
  24 typedef class temp_slot *temp_slot_p;
  25 class predefined_function_abi;
  26
  27 /* Information mainlined about RTL representation of incoming arguments.  */
  28 struct GTY(()) incoming_args {
  29   /* Number of bytes of args popped by function being compiled on its return.
  30      Zero if no bytes are to be popped.
  31      May affect compilation of return insn or of function epilogue.  */
  32   poly_int64_pod pops_args;
  33
  34   /* If function's args have a fixed size, this is that size, in bytes.
  35      Otherwise, it is -1.
  36      May affect compilation of return insn or of function epilogue.  */
  37   poly_int64_pod size;
  38
  39   /* # bytes the prologue should push and pretend that the caller pushed them.
  40      The prologue must do this, but only if parms can be passed in
  41      registers.  */
  42   int pretend_args_size;
  43
  44   /* This is the offset from the arg pointer to the place where the first
  45      anonymous arg can be found, if there is one.  */
  46   rtx arg_offset_rtx;
  47
  48   /* Quantities of various kinds of registers
  49      used for the current function's args.  */
  50   CUMULATIVE_ARGS info;
  51
  52   /* The arg pointer hard register, or the pseudo into which it was copied.  */
  53   rtx internal_arg_pointer;
  54 };
  55
  56
  57 /* Datastructures maintained for currently processed function in RTL form.  */
  58 struct GTY(()) rtl_data {
  59   void init_stack_alignment ();
  60
  61   struct expr_status expr;
  62   struct emit_status emit;
  63   struct varasm_status varasm;
  64   struct incoming_args args;
  65   struct function_subsections subsections;
  66   struct rtl_eh eh;
  67
  68   /* The ABI of the function, i.e. the interface it presents to its callers.
  69      This is the ABI that should be queried to see which registers the
  70      function needs to save before it uses them.
  71
  72      Other functions (including those called by this function) might use
  73      different ABIs.  */
  74   const predefined_function_abi *GTY((skip)) abi;
  75
  76   /* For function.c  */
  77
  78   /* # of bytes of outgoing arguments.  If ACCUMULATE_OUTGOING_ARGS is
  79      defined, the needed space is pushed by the prologue.  */
  80   poly_int64_pod outgoing_args_size;
  81
  82   /* If nonzero, an RTL expression for the location at which the current
  83      function returns its result.  If the current function returns its
  84      result in a register, current_function_return_rtx will always be
  85      the hard register containing the result.  */
  86   rtx return_rtx;
  87
  88   /* Vector of initial-value pairs.  Each pair consists of a pseudo
  89      register of approprite mode that stores the initial value a hard
  90      register REGNO, and that hard register itself.  */
  91   /* ??? This could be a VEC but there is currently no way to define an
  92          opaque VEC type.  */
  93   struct initial_value_struct *hard_reg_initial_vals;
  94
  95   /* A variable living at the top of the frame that holds a known value.
  96      Used for detecting stack clobbers.  */
  97   tree stack_protect_guard;
  98
  99   /* The __stack_chk_guard variable or expression holding the stack
 100      protector canary value.  */
 101   tree stack_protect_guard_decl;
 102
 103   /* List (chain of INSN_LIST) of labels heading the current handlers for
 104      nonlocal gotos.  */
 105   rtx_insn_list *x_nonlocal_goto_handler_labels;
 106
 107   /* Label that will go on function epilogue.
 108      Jumping to this label serves as a "return" instruction
 109      on machines which require execution of the epilogue on all returns.  */
 110   rtx_code_label *x_return_label;
 111
 112   /* Label that will go on the end of function epilogue.
 113      Jumping to this label serves as a "naked return" instruction
 114      on machines which require execution of the epilogue on all returns.  */
 115   rtx_code_label *x_naked_return_label;
 116
 117   /* List (chain of EXPR_LISTs) of all stack slots in this function.
 118      Made for the sake of unshare_all_rtl.  */
 119   vec<rtx, va_gc> *x_stack_slot_list;
 120
 121   /* List of empty areas in the stack frame.  */
 122   class frame_space *frame_space_list;
 123
 124   /* Place after which to insert the tail_recursion_label if we need one.  */
 125   rtx_note *x_stack_check_probe_note;
 126
 127   /* Location at which to save the argument pointer if it will need to be
 128      referenced.  There are two cases where this is done: if nonlocal gotos
 129      exist, or if vars stored at an offset from the argument pointer will be
 130      needed by inner routines.  */
 131   rtx x_arg_pointer_save_area;
 132
 133   /* Dynamic Realign Argument Pointer used for realigning stack.  */
 134   rtx drap_reg;
 135
 136   /* Offset to end of allocated area of stack frame.
 137      If stack grows down, this is the address of the last stack slot allocated.
 138      If stack grows up, this is the address for the next slot.  */
 139   poly_int64_pod x_frame_offset;
 140
 141   /* Insn after which register parms and SAVE_EXPRs are born, if nonopt.  */
 142   rtx_insn *x_parm_birth_insn;
 143
 144   /* List of all used temporaries allocated, by level.  */
 145   vec<temp_slot_p, va_gc> *x_used_temp_slots;
 146
 147   /* List of available temp slots.  */
 148   class temp_slot *x_avail_temp_slots;
 149
 150   /* Current nesting level for temporaries.  */
 151   int x_temp_slot_level;
 152
 153   /* The largest alignment needed on the stack, including requirement
 154      for outgoing stack alignment.  */
 155   unsigned int stack_alignment_needed;
 156
 157   /* Preferred alignment of the end of stack frame, which is preferred
 158      to call other functions.  */
 159   unsigned int preferred_stack_boundary;
 160
 161   /* The minimum alignment of parameter stack.  */
 162   unsigned int parm_stack_boundary;
 163
 164   /* The largest alignment of slot allocated on the stack.  */
 165   unsigned int max_used_stack_slot_alignment;
 166
 167   /* The stack alignment estimated before reload, with consideration of
 168      following factors:
 169      1. Alignment of local stack variables (max_used_stack_slot_alignment)
 170      2. Alignment requirement to call other functions
 171         (preferred_stack_boundary)
 172      3. Alignment of non-local stack variables but might be spilled in
 173         local stack.  */
 174   unsigned int stack_alignment_estimated;
 175
 176   /* How many NOP insns to place at each function entry by default.  */
 177   unsigned short patch_area_size;
 178
 179   /* How far the real asm entry point is into this area.  */
 180   unsigned short patch_area_entry;
 181
 182   /* For reorg.  */
 183
 184   /* Nonzero if function being compiled called builtin_return_addr or
 185      builtin_frame_address with nonzero count.  */
 186   bool accesses_prior_frames;
 187
 188   /* Nonzero if the function calls __builtin_eh_return.  */
 189   bool calls_eh_return;
 190
 191   /* Nonzero if function saves all registers, e.g. if it has a nonlocal
 192      label that can reach the exit block via non-exceptional paths. */
 193   bool saves_all_registers;
 194
 195   /* Nonzero if function being compiled has nonlocal gotos to parent
 196      function.  */
 197   bool has_nonlocal_goto;
 198
 199   /* Nonzero if function being compiled has an asm statement.  */
 200   bool has_asm_statement;
 201
 202   /* This bit is used by the exception handling logic.  It is set if all
 203      calls (if any) are sibling calls.  Such functions do not have to
 204      have EH tables generated, as they cannot throw.  A call to such a
 205      function, however, should be treated as throwing if any of its callees
 206      can throw.  */
 207   bool all_throwers_are_sibcalls;
 208
 209   /* Nonzero if stack limit checking should be enabled in the current
 210      function.  */
 211   bool limit_stack;
 212
 213   /* Nonzero if profiling code should be generated.  */
 214   bool profile;
 215
 216   /* Nonzero if the current function uses the constant pool.  */
 217   bool uses_const_pool;
 218
 219   /* Nonzero if the current function uses pic_offset_table_rtx.  */
 220   bool uses_pic_offset_table;
 221
 222   /* Nonzero if the current function needs an lsda for exception handling.  */
 223   bool uses_eh_lsda;
 224
 225   /* Set when the tail call has been produced.  */
 226   bool tail_call_emit;
 227
 228   /* Nonzero if code to initialize arg_pointer_save_area has been emitted.  */
 229   bool arg_pointer_save_area_init;
 230
 231   /* Nonzero if current function must be given a frame pointer.
 232      Set in reload1.c or lra-eliminations.c if anything is allocated
 233      on the stack there.  */
 234   bool frame_pointer_needed;
 235
 236   /* When set, expand should optimize for speed.  */
 237   bool maybe_hot_insn_p;
 238
 239   /* Nonzero if function stack realignment is needed.  This flag may be
 240      set twice: before and after reload.  It is set before reload wrt
 241      stack alignment estimation before reload.  It will be changed after
 242      reload if by then criteria of stack realignment is different.
 243      The value set after reload is the accurate one and is finalized.  */
 244   bool stack_realign_needed;
 245
 246   /* Nonzero if function stack realignment is tried.  This flag is set
 247      only once before reload.  It affects register elimination.  This
 248      is used to generate DWARF debug info for stack variables.  */
 249   bool stack_realign_tried;
 250
 251   /* Nonzero if function being compiled needs dynamic realigned
 252      argument pointer (drap) if stack needs realigning.  */
 253   bool need_drap;
 254
 255   /* Nonzero if function stack realignment estimation is done, namely
 256      stack_realign_needed flag has been set before reload wrt estimated
 257      stack alignment info.  */
 258   bool stack_realign_processed;
 259
 260   /* Nonzero if function stack realignment has been finalized, namely
 261      stack_realign_needed flag has been set and finalized after reload.  */
 262   bool stack_realign_finalized;
 263
 264   /* True if dbr_schedule has already been called for this function.  */
 265   bool dbr_scheduled_p;
 266
 267   /* True if current function cannot throw.  Unlike
 268      TREE_NOTHROW (current_function_decl) it is set even for overwritable
 269      function where currently compiled version of it is nothrow.  */
 270   bool nothrow;
 271
 272   /* True if we performed shrink-wrapping for the current function.  */
 273   bool shrink_wrapped;
 274
 275   /* True if we performed shrink-wrapping for separate components for
 276      the current function.  */
 277   bool shrink_wrapped_separate;
 278
 279   /* Nonzero if function being compiled doesn't modify the stack pointer
 280      (ignoring the prologue and epilogue).  This is only valid after
 281      pass_stack_ptr_mod has run.  */
 282   bool sp_is_unchanging;
 283
 284   /* True if the stack pointer is clobbered by asm statement.  */
 285   bool sp_is_clobbered_by_asm;
 286
 287   /* Nonzero if function being compiled doesn't contain any calls
 288      (ignoring the prologue and epilogue).  This is set prior to
 289      register allocation in IRA and is valid for the remaining
 290      compiler passes.  */
 291   bool is_leaf;
 292
 293   /* Nonzero if the function being compiled is a leaf function which only
 294      uses leaf registers.  This is valid after reload (specifically after
 295      sched2) and is useful only if the port defines LEAF_REGISTERS.  */
 296   bool uses_only_leaf_regs;
 297
 298   /* Nonzero if the function being compiled has undergone hot/cold partitioning
 299      (under flag_reorder_blocks_and_partition) and has at least one cold
 300      block.  */
 301   bool has_bb_partition;
 302
 303   /* Nonzero if the function being compiled has completed the bb reordering
 304      pass.  */
 305   bool bb_reorder_complete;
 306
 307   /* Like regs_ever_live, but 1 if a reg is set or clobbered from an
 308      asm.  Unlike regs_ever_live, elements of this array corresponding
 309      to eliminable regs (like the frame pointer) are set if an asm
 310      sets them.  */
 311   HARD_REG_SET asm_clobbers;
 312
 313   /* All hard registers that need to be zeroed at the return of the routine.  */
 314   HARD_REG_SET must_be_zero_on_return;
 315
 316   /* The highest address seen during shorten_branches.  */
 317   int max_insn_address;
 318 };
 319
 320 #define return_label (crtl->x_return_label)
 321 #define naked_return_label (crtl->x_naked_return_label)
 322 #define stack_slot_list (crtl->x_stack_slot_list)
 323 #define parm_birth_insn (crtl->x_parm_birth_insn)
 324 #define frame_offset (crtl->x_frame_offset)
 325 #define stack_check_probe_note (crtl->x_stack_check_probe_note)
 326 #define arg_pointer_save_area (crtl->x_arg_pointer_save_area)
 327 #define used_temp_slots (crtl->x_used_temp_slots)
 328 #define avail_temp_slots (crtl->x_avail_temp_slots)
 329 #define temp_slot_level (crtl->x_temp_slot_level)
 330 #define nonlocal_goto_handler_labels (crtl->x_nonlocal_goto_handler_labels)
 331 #define frame_pointer_needed (crtl->frame_pointer_needed)
 332 #define stack_realign_fp (crtl->stack_realign_needed && !crtl->need_drap)
 333 #define stack_realign_drap (crtl->stack_realign_needed && crtl->need_drap)
 334
 335 extern GTY(()) struct rtl_data x_rtl;
 336
 337 /* Accessor to RTL datastructures.  We keep them statically allocated now since
 338    we never keep multiple functions.  For threaded compiler we might however
 339    want to do differently.  */
 340 #define crtl (&x_rtl)
 341
 342 /* Return whether two MEM_ATTRs are equal.  */
 343 bool mem_attrs_eq_p (const class mem_attrs *, const class mem_attrs *);
 344
 345 /* Set the alias set of MEM to SET.  */
 346 extern void set_mem_alias_set (rtx, alias_set_type);
 347
 348 /* Set the alignment of MEM to ALIGN bits.  */
 349 extern void set_mem_align (rtx, unsigned int);
 350
 351 /* Set the address space of MEM to ADDRSPACE.  */
 352 extern void set_mem_addr_space (rtx, addr_space_t);
 353
 354 /* Set the expr for MEM to EXPR.  */
 355 extern void set_mem_expr (rtx, tree);
 356
 357 /* Set the offset for MEM to OFFSET.  */
 358 extern void set_mem_offset (rtx, poly_int64);
 359
 360 /* Clear the offset recorded for MEM.  */
 361 extern void clear_mem_offset (rtx);
 362
 363 /* Set the size for MEM to SIZE.  */
 364 extern void set_mem_size (rtx, poly_int64);
 365
 366 /* Clear the size recorded for MEM.  */
 367 extern void clear_mem_size (rtx);
 368
 369 /* Set the attributes for MEM appropriate for a spill slot.  */
 370 extern void set_mem_attrs_for_spill (rtx);
 371 extern tree get_spill_slot_decl (bool);
 372
 373 /* Return a memory reference like MEMREF, but with its address changed to
 374    ADDR.  The caller is asserting that the actual piece of memory pointed
 375    to is the same, just the form of the address is being changed, such as
 376    by putting something into a register.  */
 377 extern rtx replace_equiv_address (rtx, rtx, bool = false);
 378
 379 /* Likewise, but the reference is not required to be valid.  */
 380 extern rtx replace_equiv_address_nv (rtx, rtx, bool = false);
 381
 382 extern rtx gen_blockage (void);
 383 extern rtvec gen_rtvec (int, ...);
 384 extern rtx copy_insn_1 (rtx);
 385 extern rtx copy_insn (rtx);
 386 extern rtx_insn *copy_delay_slot_insn (rtx_insn *);
 387 extern rtx gen_int_mode (poly_int64, machine_mode);
 388 extern rtx_insn *emit_copy_of_insn_after (rtx_insn *, rtx_insn *);
 389 extern void set_reg_attrs_from_value (rtx, rtx);
 390 extern void set_reg_attrs_for_parm (rtx, rtx);
 391 extern void set_reg_attrs_for_decl_rtl (tree t, rtx x);
 392 extern void adjust_reg_mode (rtx, machine_mode);
 393 extern int mem_expr_equal_p (const_tree, const_tree);
 394 extern rtx gen_int_shift_amount (machine_mode, poly_int64);
 395
 396 extern bool need_atomic_barrier_p (enum memmodel, bool);
 397
 398 /* Return the current sequence.  */
 399
 400 static inline struct sequence_stack *
 401 get_current_sequence (void)
 402 {
 403   return &crtl->emit.seq;
 404 }
 405
 406 /* Return the outermost sequence.  */
 407
 408 static inline struct sequence_stack *
 409 get_topmost_sequence (void)
 410 {
 411   struct sequence_stack *seq, *top;
 412
 413   seq = get_current_sequence ();
 414   do
 415     {
 416       top = seq;
 417       seq = seq->next;
 418     } while (seq);
 419   return top;
 420 }
 421
 422 /* Return the first insn of the current sequence or current function.  */
 423
 424 static inline rtx_insn *
 425 get_insns (void)
 426 {
 427   return get_current_sequence ()->first;
 428 }
 429
 430 /* Specify a new insn as the first in the chain.  */
 431
 432 static inline void
 433 set_first_insn (rtx_insn *insn)
 434 {
 435   gcc_checking_assert (!insn || !PREV_INSN (insn));
 436   get_current_sequence ()->first = insn;
 437 }
 438
 439 /* Return the last insn emitted in current sequence or current function.  */
 440
 441 static inline rtx_insn *
 442 get_last_insn (void)
 443 {
 444   return get_current_sequence ()->last;
 445 }
 446
 447 /* Specify a new insn as the last in the chain.  */
 448
 449 static inline void
 450 set_last_insn (rtx_insn *insn)
 451 {
 452   gcc_checking_assert (!insn || !NEXT_INSN (insn));
 453   get_current_sequence ()->last = insn;
 454 }
 455
 456 /* Return a number larger than any instruction's uid in this function.  */
 457
 458 static inline int
 459 get_max_uid (void)
 460 {
 461   return crtl->emit.x_cur_insn_uid;
 462 }
 463
 464 extern bool valid_for_const_vector_p (machine_mode, rtx);
 465 extern rtx gen_const_vec_duplicate (machine_mode, rtx);
 466 extern rtx gen_vec_duplicate (machine_mode, rtx);
 467
 468 extern rtx gen_const_vec_series (machine_mode, rtx, rtx);
 469 extern rtx gen_vec_series (machine_mode, rtx, rtx);
 470
 471 extern void set_decl_incoming_rtl (tree, rtx, bool);
 472
 473 /* Return a memory reference like MEMREF, but with its mode changed
 474    to MODE and its address changed to ADDR.
 475    (VOIDmode means don't change the mode.
 476    NULL for ADDR means don't change the address.)  */
 477 extern rtx change_address (rtx, machine_mode, rtx);
 478
 479 /* Return a memory reference like MEMREF, but with its mode changed
 480    to MODE and its address offset by OFFSET bytes.  */
 481 #define adjust_address(MEMREF, MODE, OFFSET) \
 482   adjust_address_1 (MEMREF, MODE, OFFSET, 1, 1, 0, 0)
 483
 484 /* Likewise, but the reference is not required to be valid.  */
 485 #define adjust_address_nv(MEMREF, MODE, OFFSET) \
 486   adjust_address_1 (MEMREF, MODE, OFFSET, 0, 1, 0, 0)
 487
 488 /* Return a memory reference like MEMREF, but with its mode changed
 489    to MODE and its address offset by OFFSET bytes.  Assume that it's
 490    for a bitfield and conservatively drop the underlying object if we
 491    cannot be sure to stay within its bounds.  */
 492 #define adjust_bitfield_address(MEMREF, MODE, OFFSET) \
 493   adjust_address_1 (MEMREF, MODE, OFFSET, 1, 1, 1, 0)
 494
 495 /* As for adjust_bitfield_address, but specify that the width of
 496    BLKmode accesses is SIZE bytes.  */
 497 #define adjust_bitfield_address_size(MEMREF, MODE, OFFSET, SIZE) \
 498   adjust_address_1 (MEMREF, MODE, OFFSET, 1, 1, 1, SIZE)
 499
 500 /* Likewise, but the reference is not required to be valid.  */
 501 #define adjust_bitfield_address_nv(MEMREF, MODE, OFFSET) \
 502   adjust_address_1 (MEMREF, MODE, OFFSET, 0, 1, 1, 0)
 503
 504 /* Return a memory reference like MEMREF, but with its mode changed
 505    to MODE and its address changed to ADDR, which is assumed to be
 506    increased by OFFSET bytes from MEMREF.  */
 507 #define adjust_automodify_address(MEMREF, MODE, ADDR, OFFSET) \
 508   adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 1)
 509
 510 /* Likewise, but the reference is not required to be valid.  */
 511 #define adjust_automodify_address_nv(MEMREF, MODE, ADDR, OFFSET) \
 512   adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 0)
 513
 514 extern rtx adjust_address_1 (rtx, machine_mode, poly_int64, int, int,
 515                              int, poly_int64);
 516 extern rtx adjust_automodify_address_1 (rtx, machine_mode, rtx,
 517                                         poly_int64, int);
 518
 519 /* Return a memory reference like MEMREF, but whose address is changed by
 520    adding OFFSET, an RTX, to it.  POW2 is the highest power of two factor
 521    known to be in OFFSET (possibly 1).  */
 522 extern rtx offset_address (rtx, rtx, unsigned HOST_WIDE_INT);
 523
 524 /* Given REF, a MEM, and T, either the type of X or the expression
 525    corresponding to REF, set the memory attributes.  OBJECTP is nonzero
 526    if we are making a new object of this type.  */
 527 extern void set_mem_attributes (rtx, tree, int);
 528
 529 /* Similar, except that BITPOS has not yet been applied to REF, so if
 530    we alter MEM_OFFSET according to T then we should subtract BITPOS
 531    expecting that it'll be added back in later.  */
 532 extern void set_mem_attributes_minus_bitpos (rtx, tree, int, poly_int64);
 533
 534 /* Return OFFSET if XEXP (MEM, 0) - OFFSET is known to be ALIGN
 535    bits aligned for 0 <= OFFSET < ALIGN / BITS_PER_UNIT, or
 536    -1 if not known.  */
 537 extern int get_mem_align_offset (rtx, unsigned int);
 538
 539 /* Return a memory reference like MEMREF, but with its mode widened to
 540    MODE and adjusted by OFFSET.  */
 541 extern rtx widen_memory_access (rtx, machine_mode, poly_int64);
 542
 543 extern void maybe_set_max_label_num (rtx_code_label *x);
 544
 545 #endif /* GCC_EMIT_RTL_H */