gcc/builtins.h

   1 /* Expand builtin functions.
   2    Copyright (C) 1988-2021 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 tree mathfn_built_in_type (combined_fn);
 113 extern rtx builtin_strncpy_read_str (void *, void *, HOST_WIDE_INT,
 114                                      scalar_int_mode);
 115 extern rtx builtin_memset_read_str (void *, void *, HOST_WIDE_INT,
 116                                     scalar_int_mode);
 117 extern rtx expand_builtin_saveregs (void);
 118 extern tree std_build_builtin_va_list (void);
 119 extern tree std_fn_abi_va_list (tree);
 120 extern tree std_canonical_va_list_type (tree);
 121 extern void std_expand_builtin_va_start (tree, rtx);
 122 extern void expand_builtin_trap (void);
 123 extern void expand_ifn_atomic_bit_test_and (gcall *);
 124 extern void expand_ifn_atomic_compare_exchange (gcall *);
 125 extern rtx expand_builtin (tree, rtx, rtx, machine_mode, int);
 126 extern enum built_in_function builtin_mathfn_code (const_tree);
 127 extern tree fold_builtin_expect (location_t, tree, tree, tree, tree);
 128 extern bool avoid_folding_inline_builtin (tree);
 129 extern tree fold_call_expr (location_t, tree, bool);
 130 extern tree fold_builtin_call_array (location_t, tree, tree, int, tree *);
 131 extern bool validate_gimple_arglist (const gcall *, ...);
 132 extern rtx default_expand_builtin (tree, rtx, rtx, machine_mode, int);
 133 extern void maybe_emit_call_builtin___clear_cache (rtx, rtx);
 134 extern bool fold_builtin_next_arg (tree, bool);
 135 extern tree do_mpc_arg2 (tree, tree, tree, int, int (*)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t));
 136 extern tree fold_call_stmt (gcall *, bool);
 137 extern void set_builtin_user_assembler_name (tree decl, const char *asmspec);
 138 extern bool is_simple_builtin (tree);
 139 extern bool is_inexpensive_builtin (tree);
 140 extern bool readonly_data_expr (tree exp);
 141 extern bool init_target_chars (void);
 142 extern unsigned HOST_WIDE_INT target_newline;
 143 extern unsigned HOST_WIDE_INT target_percent;
 144 extern char target_percent_s[3];
 145 extern char target_percent_c[3];
 146 extern char target_percent_s_newline[4];
 147 extern bool target_char_cst_p (tree t, char *p);
 148
 149 extern internal_fn associated_internal_fn (tree);
 150 extern internal_fn replacement_internal_fn (gcall *);
 151
 152 extern bool check_nul_terminated_array (tree, tree, tree = NULL_TREE);
 153 extern void warn_string_no_nul (location_t, tree, const char *, tree,
 154                                 tree, tree = NULL_TREE, bool = false,
 155                                 const wide_int[2] = NULL);
 156 extern tree unterminated_array (tree, tree * = NULL, bool * = NULL);
 157 extern bool builtin_with_linkage_p (tree);
 158
 159 /* Describes recursion limits used by functions that follow use-def
 160    chains of SSA_NAMEs.  */
 161
 162 class ssa_name_limit_t
 163 {
 164   bitmap visited;         /* Bitmap of visited SSA_NAMEs.  */
 165   unsigned ssa_def_max;   /* Longest chain of SSA_NAMEs to follow.  */
 166
 167   /* Not copyable or assignable.  */
 168   DISABLE_COPY_AND_ASSIGN (ssa_name_limit_t);
 169
 170 public:
 171
 172   ssa_name_limit_t ()
 173     : visited (),
 174       ssa_def_max (param_ssa_name_def_chain_limit) { }
 175
 176   /* Set a bit for the PHI in VISITED and return true if it wasn't
 177      already set.  */
 178   bool visit_phi (tree);
 179   /* Clear a bit for the PHI in VISITED.  */
 180   void leave_phi (tree);
 181   /* Return false if the SSA_NAME chain length counter has reached
 182      the limit, otherwise increment the counter and return true.  */
 183   bool next ();
 184
 185   /* If the SSA_NAME has already been "seen" return a positive value.
 186      Otherwise add it to VISITED.  If the SSA_NAME limit has been
 187      reached, return a negative value.  Otherwise return zero.  */
 188   int next_phi (tree);
 189
 190   ~ssa_name_limit_t ();
 191 };
 192
 193 class pointer_query;
 194
 195 /* Describes a reference to an object used in an access.  */
 196 struct access_ref
 197 {
 198   /* Set the bounds of the reference to at most as many bytes
 199      as the first argument or unknown when null, and at least
 200      one when the second argument is true unless the first one
 201      is a constant zero.  */
 202   access_ref (tree = NULL_TREE, bool = false);
 203
 204   /* Return the PHI node REF refers to or null if it doesn't.  */
 205   gphi *phi () const;
 206
 207   /* Return the object to which REF refers.  */
 208   tree get_ref (vec<access_ref> *, access_ref * = NULL, int = 1,
 209                 ssa_name_limit_t * = NULL, pointer_query * = NULL) const;
 210
 211   /* Return true if OFFRNG is the constant zero.  */
 212   bool offset_zero () const
 213   {
 214     return offrng[0] == 0 && offrng[1] == 0;
 215   }
 216
 217   /* Return true if OFFRNG is bounded to a subrange of offset values
 218      valid for the largest possible object.  */
 219   bool offset_bounded () const;
 220
 221   /* Return the maximum amount of space remaining and if non-null, set
 222      argument to the minimum.  */
 223   offset_int size_remaining (offset_int * = NULL) const;
 224
 225 /* Return true if the offset and object size are in range for SIZE.  */
 226   bool offset_in_range (const offset_int &) const;
 227
 228   /* Return true if *THIS is an access to a declared object.  */
 229   bool ref_declared () const
 230   {
 231     return DECL_P (ref) && base0 && deref < 1;
 232   }
 233
 234   /* Set the size range to the maximum.  */
 235   void set_max_size_range ()
 236   {
 237     sizrng[0] = 0;
 238     sizrng[1] = wi::to_offset (max_object_size ());
 239   }
 240
 241   /* Add OFF to the offset range.  */
 242   void add_offset (const offset_int &off)
 243   {
 244     add_offset (off, off);
 245   }
 246
 247   /* Add the range [MIN, MAX] to the offset range.  */
 248   void add_offset (const offset_int &, const offset_int &);
 249
 250   /* Add the maximum representable offset to the offset range.  */
 251   void add_max_offset ()
 252   {
 253     offset_int maxoff = wi::to_offset (TYPE_MAX_VALUE (ptrdiff_type_node));
 254     add_offset (-maxoff - 1, maxoff);
 255   }
 256
 257   /* Issue an informational message describing the target of an access
 258      with the given mode.  */
 259   void inform_access (access_mode) const;
 260
 261   /* Reference to the accessed object(s).  */
 262   tree ref;
 263
 264   /* Range of byte offsets into and sizes of the object(s).  */
 265   offset_int offrng[2];
 266   offset_int sizrng[2];
 267   /* The minimum and maximum offset computed.  */
 268   offset_int offmax[2];
 269   /* Range of the bound of the access: denotes that the access
 270      is at least BNDRNG[0] bytes but no more than BNDRNG[1].
 271      For string functions the size of the actual access is
 272      further constrained by the length of the string.  */
 273   offset_int bndrng[2];
 274
 275   /* Used to fold integer expressions when called from front ends.  */
 276   tree (*eval)(tree);
 277   /* Positive when REF is dereferenced, negative when its address is
 278      taken.  */
 279   int deref;
 280   /* Set if trailing one-element arrays should be treated as flexible
 281      array members.  */
 282   bool trail1special;
 283   /* Set if valid offsets must start at zero (for declared and allocated
 284      objects but not for others referenced by pointers).  */
 285   bool base0;
 286   /* Set if REF refers to a function array parameter not declared
 287      static.  */
 288   bool parmarray;
 289 };
 290
 291 class range_query;
 292
 293 /* Queries and caches compute_objsize results.  */
 294 class pointer_query
 295 {
 296   DISABLE_COPY_AND_ASSIGN (pointer_query);
 297
 298 public:
 299   /* Type of the two-level cache object defined by clients of the class
 300      to have pointer SSA_NAMEs cached for speedy access.  */
 301   struct cache_type
 302   {
 303     /* 1-based indices into cache.  */
 304     vec<unsigned> indices;
 305     /* The cache itself.  */
 306     vec<access_ref> access_refs;
 307   };
 308
 309   /* Construct an object with the given Ranger instance and cache.  */
 310   explicit pointer_query (range_query * = NULL, cache_type * = NULL);
 311
 312   /* Retrieve the access_ref for a variable from cache if it's there.  */
 313   const access_ref* get_ref (tree, int = 1) const;
 314
 315   /* Retrieve the access_ref for a variable from cache or compute it.  */
 316   bool get_ref (tree, access_ref*, int = 1);
 317
 318   /* Add an access_ref for the SSA_NAME to the cache.  */
 319   void put_ref (tree, const access_ref&, int = 1);
 320
 321   /* Flush the cache.  */
 322   void flush_cache ();
 323
 324   /* A Ranger instance.  May be null to use global ranges.  */
 325   range_query *rvals;
 326   /* Cache of SSA_NAMEs.  May be null to disable caching.  */
 327   cache_type *var_cache;
 328
 329   /* Cache performance counters.  */
 330   mutable unsigned hits;
 331   mutable unsigned misses;
 332   mutable unsigned failures;
 333   mutable unsigned depth;
 334   mutable unsigned max_depth;
 335 };
 336
 337 /* Describes a pair of references used in an access by built-in
 338    functions like memcpy.  */
 339 struct access_data
 340 {
 341   /* Set the access to at most MAXWRITE and MAXREAD bytes, and
 342      at least 1 when MINWRITE or MINREAD, respectively, is set.  */
 343   access_data (tree expr, access_mode mode,
 344                tree maxwrite = NULL_TREE, bool minwrite = false,
 345                tree maxread = NULL_TREE, bool minread = false)
 346     : call (expr),
 347       dst (maxwrite, minwrite), src (maxread, minread), mode (mode) { }
 348
 349   /* Built-in function call.  */
 350   tree call;
 351   /* Destination and source of the access.  */
 352   access_ref dst, src;
 353   /* Read-only for functions like memcmp or strlen, write-only
 354      for memset, read-write for memcpy or strcat.  */
 355   access_mode mode;
 356 };
 357
 358 extern tree gimple_call_alloc_size (gimple *, wide_int[2] = NULL,
 359                                     range_query * = NULL);
 360 extern tree gimple_parm_array_size (tree, wide_int[2], bool * = NULL);
 361
 362 extern tree compute_objsize (tree, int, access_ref *, range_query * = NULL);
 363 /* Legacy/transitional API.  Should not be used in new code.  */
 364 extern tree compute_objsize (tree, int, access_ref *, pointer_query *);
 365 extern tree compute_objsize (tree, int, tree * = NULL, tree * = NULL,
 366                              range_query * = NULL);
 367 extern bool check_access (tree, tree, tree, tree, tree,
 368                           access_mode, const access_data * = NULL);
 369 extern void maybe_emit_free_warning (tree);
 370
 371 #endif /* GCC_BUILTINS_H */