gcc/builtins.h

   1 /* Expand builtin functions.
   2    Copyright (C) 1988-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_BUILTINS_H
  21 #define GCC_BUILTINS_H
  22
  23 #include <mpc.h>
  24
  25 /* Target-dependent globals.  */
  26 struct target_builtins {
  27   /* For each register that may be used for calling a function, this
  28      gives a mode used to copy the register's value.  VOIDmode indicates
  29      the register is not used for calling a function.  If the machine
  30      has register windows, this gives only the outbound registers.
  31      INCOMING_REGNO gives the corresponding inbound register.  */
  32   fixed_size_mode_pod x_apply_args_mode[FIRST_PSEUDO_REGISTER];
  33
  34   /* For each register that may be used for returning values, this gives
  35      a mode used to copy the register's value.  VOIDmode indicates the
  36      register is not used for returning values.  If the machine has
  37      register windows, this gives only the outbound registers.
  38      INCOMING_REGNO gives the corresponding inbound register.  */
  39   fixed_size_mode_pod x_apply_result_mode[FIRST_PSEUDO_REGISTER];
  40 };
  41
  42 extern struct target_builtins default_target_builtins;
  43 #if SWITCHABLE_TARGET
  44 extern struct target_builtins *this_target_builtins;
  45 #else
  46 #define this_target_builtins (&default_target_builtins)
  47 #endif
  48
  49 /* Non-zero if __builtin_constant_p should be folded right away.  */
  50 extern bool force_folding_builtin_constant_p;
  51
  52 extern bool called_as_built_in (tree);
  53 extern bool get_object_alignment_1 (tree, unsigned int *,
  54                                     unsigned HOST_WIDE_INT *);
  55 extern unsigned int get_object_alignment (tree);
  56 extern bool get_pointer_alignment_1 (tree, unsigned int *,
  57                                      unsigned HOST_WIDE_INT *);
  58 extern unsigned int get_pointer_alignment (tree);
  59 extern unsigned string_length (const void*, unsigned, unsigned);
  60
  61 struct c_strlen_data
  62 {
  63   /* [MINLEN, MAXBOUND, MAXLEN] is a range describing the length of
  64      one or more strings of possibly unknown length.  For a single
  65      string of known length the range is a constant where
  66      MINLEN == MAXBOUND == MAXLEN holds.
  67      For other strings, MINLEN is the length of the shortest known
  68      string.  MAXBOUND is the length of a string that could be stored
  69      in the largest array referenced by the expression.  MAXLEN is
  70      the length of the longest sequence of non-zero bytes
  71      in an object referenced by the expression.  For such strings,
  72      MINLEN <= MAXBOUND <= MAXLEN holds.  For example, given:
  73        struct A { char a[7], b[]; };
  74        extern struct A *p;
  75        n = strlen (p->a);
  76      the computed range will be [0, 6, ALL_ONES].
  77      However, for a conditional expression involving a string
  78      of known length and an array of unknown bound such as
  79        n = strlen (i ? p->b : "123");
  80      the range will be [3, 3, ALL_ONES].
  81      MINLEN != 0 && MAXLEN == ALL_ONES indicates that MINLEN is
  82      the length of the shortest known string and implies that
  83      the shortest possible string referenced by the expression may
  84      actually be the empty string.  This distinction is useful for
  85      diagnostics.  get_range_strlen() return value distinguishes
  86      between these two cases.
  87      As the tighter (and more optimistic) bound, MAXBOUND is suitable
  88      for diagnostics but not for optimization.
  89      As the more conservative bound, MAXLEN is intended to be used
  90      for optimization.  */
  91   tree minlen;
  92   tree maxlen;
  93   tree maxbound;
  94   /* When non-null, DECL refers to the declaration known to store
  95      an unterminated constant character array, as in:
  96      const char s[] = { 'a', 'b', 'c' };
  97      It is used to diagnose uses of such arrays in functions such as
  98      strlen() that expect a nul-terminated string as an argument.  */
  99   tree decl;
 100   /* Non-constant offset from the beginning of a string not accounted
 101      for in the length range.  Used to improve diagnostics.  */
 102   tree off;
 103 };
 104
 105 extern tree c_strlen (tree, int, c_strlen_data * = NULL, unsigned = 1);
 106 extern rtx c_readstr (const char *, scalar_int_mode, bool = true);
 107 extern void expand_builtin_setjmp_setup (rtx, rtx);
 108 extern void expand_builtin_setjmp_receiver (rtx);
 109 extern void expand_builtin_update_setjmp_buf (rtx);
 110 extern tree mathfn_built_in (tree, enum built_in_function fn);
 111 extern tree mathfn_built_in (tree, combined_fn);
 112 extern rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, scalar_int_mode);
 113 extern rtx builtin_memset_read_str (void *, HOST_WIDE_INT, scalar_int_mode);
 114 extern rtx expand_builtin_saveregs (void);
 115 extern tree std_build_builtin_va_list (void);
 116 extern tree std_fn_abi_va_list (tree);
 117 extern tree std_canonical_va_list_type (tree);
 118 extern void std_expand_builtin_va_start (tree, rtx);
 119 extern void expand_builtin_trap (void);
 120 extern void expand_ifn_atomic_bit_test_and (gcall *);
 121 extern void expand_ifn_atomic_compare_exchange (gcall *);
 122 extern rtx expand_builtin (tree, rtx, rtx, machine_mode, int);
 123 extern enum built_in_function builtin_mathfn_code (const_tree);
 124 extern tree fold_builtin_expect (location_t, tree, tree, tree, tree);
 125 extern bool avoid_folding_inline_builtin (tree);
 126 extern tree fold_call_expr (location_t, tree, bool);
 127 extern tree fold_builtin_call_array (location_t, tree, tree, int, tree *);
 128 extern bool validate_gimple_arglist (const gcall *, ...);
 129 extern rtx default_expand_builtin (tree, rtx, rtx, machine_mode, int);
 130 extern bool fold_builtin_next_arg (tree, bool);
 131 extern tree do_mpc_arg2 (tree, tree, tree, int, int (*)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t));
 132 extern tree fold_call_stmt (gcall *, bool);
 133 extern void set_builtin_user_assembler_name (tree decl, const char *asmspec);
 134 extern bool is_simple_builtin (tree);
 135 extern bool is_inexpensive_builtin (tree);
 136 extern bool readonly_data_expr (tree exp);
 137 extern bool init_target_chars (void);
 138 extern unsigned HOST_WIDE_INT target_newline;
 139 extern unsigned HOST_WIDE_INT target_percent;
 140 extern char target_percent_s[3];
 141 extern char target_percent_c[3];
 142 extern char target_percent_s_newline[4];
 143 extern bool target_char_cst_p (tree t, char *p);
 144
 145 extern internal_fn associated_internal_fn (tree);
 146 extern internal_fn replacement_internal_fn (gcall *);
 147
 148 extern bool check_nul_terminated_array (tree, tree, tree = NULL_TREE);
 149 extern void warn_string_no_nul (location_t, tree, const char *, tree,
 150                                 tree, tree = NULL_TREE, bool = false,
 151                                 const wide_int[2] = NULL);
 152 extern tree unterminated_array (tree, tree * = NULL, bool * = NULL);
 153 extern bool builtin_with_linkage_p (tree);
 154
 155 /* Describes a reference to an object used in an access.  */
 156 struct access_ref
 157 {
 158   /* Set the bounds of the reference to at most as many bytes
 159      as the first argument or unknown when null, and at least
 160      one when the second argument is true unless the first one
 161      is a constant zero.  */
 162   access_ref (tree = NULL_TREE, bool = false);
 163
 164   /* Reference to the accessed object(s).  */
 165   tree ref;
 166
 167   /* Range of byte offsets into and sizes of the object(s).  */
 168   offset_int offrng[2];
 169   offset_int sizrng[2];
 170   /* Range of the bound of the access: denotes that the access
 171      is at least BNDRNG[0] bytes but no more than BNDRNG[1].
 172      For string functions the size of the actual access is
 173      further constrained by the length of the string.  */
 174   offset_int bndrng[2];
 175 };
 176
 177 /* Describes a pair of references used in an access by built-in
 178    functions like memcpy.  */
 179 struct access_data
 180 {
 181   /* Set the access to at most MAXWRITE and MAXREAD bytes, and
 182      at least 1 when MINWRITE or MINREAD, respectively, is set.  */
 183   access_data (tree expr, access_mode mode,
 184                tree maxwrite = NULL_TREE, bool minwrite = false,
 185                tree maxread = NULL_TREE, bool minread = false)
 186     : call (expr),
 187       dst (maxwrite, minwrite), src (maxread, minread), mode (mode) { }
 188
 189   /* Built-in function call.  */
 190   tree call;
 191   /* Destination and source of the access.  */
 192   access_ref dst, src;
 193   /* Read-only for functions like memcmp or strlen, write-only
 194      for memset, read-write for memcpy or strcat.  */
 195   access_mode mode;
 196 };
 197
 198 class range_query;
 199 extern tree gimple_call_alloc_size (gimple *, wide_int[2] = NULL,
 200                                     range_query * = NULL);
 201 extern tree gimple_parm_array_size (tree, wide_int[2], range_query * = NULL);
 202 extern tree compute_objsize (tree, int, tree * = NULL, tree * = NULL,
 203                              range_query * = NULL);
 204 extern tree compute_objsize (tree, int, access_ref *, range_query * = NULL);
 205
 206 extern bool check_access (tree, tree, tree, tree, tree, access_mode,
 207                           const access_data * = NULL);
 208
 209 #endif /* GCC_BUILTINS_H */