gcc/emit-rtl.h

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