gcc/emit-rtl.h

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