gcc/explow.h

   1 /* Export function prototypes from explow.c.
   2    Copyright (C) 2015-2017 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_EXPLOW_H
  21 #define GCC_EXPLOW_H
  22
  23 /* Return a memory reference like MEMREF, but which is known to have a
  24    valid address.  */
  25 extern rtx validize_mem (rtx);
  26
  27 extern rtx use_anchored_address (rtx);
  28
  29 /* Copy given rtx to a new temp reg and return that.  */
  30 extern rtx copy_to_reg (rtx);
  31
  32 /* Like copy_to_reg but always make the reg Pmode.  */
  33 extern rtx copy_addr_to_reg (rtx);
  34
  35 /* Like copy_to_reg but always make the reg the specified mode MODE.  */
  36 extern rtx copy_to_mode_reg (machine_mode, rtx);
  37
  38 /* Copy given rtx to given temp reg and return that.  */
  39 extern rtx copy_to_suggested_reg (rtx, rtx, machine_mode);
  40
  41 /* Copy a value to a register if it isn't already a register.
  42    Args are mode (in case value is a constant) and the value.  */
  43 extern rtx force_reg (machine_mode, rtx);
  44
  45 /* Return given rtx, copied into a new temp reg if it was in memory.  */
  46 extern rtx force_not_mem (rtx);
  47
  48 /* Return mode and signedness to use when an argument or result in the
  49    given mode is promoted.  */
  50 extern machine_mode promote_function_mode (const_tree, machine_mode, int *,
  51                                                 const_tree, int);
  52
  53 /* Return mode and signedness to use when an object in the given mode
  54    is promoted.  */
  55 extern machine_mode promote_mode (const_tree, machine_mode, int *);
  56
  57 /* Return mode and signedness to use when object is promoted.  */
  58 machine_mode promote_decl_mode (const_tree, int *);
  59
  60 /* Return mode and signedness to use when object is promoted.  */
  61 machine_mode promote_ssa_mode (const_tree, int *);
  62
  63 /* Remove some bytes from the stack.  An rtx says how many.  */
  64 extern void adjust_stack (rtx);
  65
  66 /* Add some bytes to the stack.  An rtx says how many.  */
  67 extern void anti_adjust_stack (rtx);
  68
  69 /* Add some bytes to the stack while probing it.  An rtx says how many. */
  70 extern void anti_adjust_stack_and_probe (rtx, bool);
  71
  72 /* Support for building allocation/probing loops for stack-clash
  73    protection of dyamically allocated stack space.  */
  74 extern void compute_stack_clash_protection_loop_data (rtx *, rtx *, rtx *,
  75                                                       HOST_WIDE_INT *, rtx);
  76 extern void emit_stack_clash_protection_probe_loop_start (rtx *, rtx *,
  77                                                           rtx, bool);
  78 extern void emit_stack_clash_protection_probe_loop_end (rtx, rtx,
  79                                                         rtx, bool);
  80
  81 /* This enum is used for the following two functions.  */
  82 enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL};
  83
  84 /* Save the stack pointer at the specified level.  */
  85 extern void emit_stack_save (enum save_level, rtx *);
  86
  87 /* Restore the stack pointer from a save area of the specified level.  */
  88 extern void emit_stack_restore (enum save_level, rtx);
  89
  90 /* Invoke emit_stack_save for the nonlocal_goto_save_area.  */
  91 extern void update_nonlocal_goto_save_area (void);
  92
  93 /* Record a new stack level.  */
  94 extern void record_new_stack_level (void);
  95
  96 /* Allocate some space on the stack dynamically and return its address.  */
  97 extern rtx allocate_dynamic_stack_space (rtx, unsigned, unsigned,
  98                                          HOST_WIDE_INT, bool);
  99
 100 /* Calculate the necessary size of a constant dynamic stack allocation from the
 101    size of the variable area.  */
 102 extern void get_dynamic_stack_size (rtx *, unsigned, unsigned, HOST_WIDE_INT *);
 103
 104 /* Returns the address of the dynamic stack space without allocating it.  */
 105 extern rtx get_dynamic_stack_base (HOST_WIDE_INT offset,
 106                                    unsigned required_align);
 107
 108 /* Emit one stack probe at ADDRESS, an address within the stack.  */
 109 extern void emit_stack_probe (rtx);
 110
 111 /* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive.
 112    FIRST is a constant and size is a Pmode RTX.  These are offsets from
 113    the current stack pointer.  STACK_GROWS_DOWNWARD says whether to add
 114    or subtract them from the stack pointer.  */
 115 extern void probe_stack_range (HOST_WIDE_INT, rtx);
 116
 117 /* Return an rtx that refers to the value returned by a library call
 118    in its original home.  This becomes invalid if any more code is emitted.  */
 119 extern rtx hard_libcall_value (machine_mode, rtx);
 120
 121 /* Return an rtx that refers to the value returned by a function
 122    in its original home.  This becomes invalid if any more code is emitted.  */
 123 extern rtx hard_function_value (const_tree, const_tree, const_tree, int);
 124
 125 /* Convert arg to a valid memory address for specified machine mode that points
 126    to a specific named address space, by emitting insns to perform arithmetic
 127    if necessary.  */
 128 extern rtx memory_address_addr_space (machine_mode, rtx, addr_space_t);
 129
 130 extern rtx eliminate_constant_term (rtx, rtx *);
 131
 132 /* Like memory_address_addr_space, except assume the memory address points to
 133    the generic named address space.  */
 134 #define memory_address(MODE,RTX) \
 135         memory_address_addr_space ((MODE), (RTX), ADDR_SPACE_GENERIC)
 136
 137 #endif /* GCC_EXPLOW_H */