gcc/builtins.h

   1 /* Expand builtin functions.
   2    Copyright (C) 1988-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_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   /* Nonzero iff the arrays above have been initialized.  The _plus_one suffix
  42      is for zero initialization to make it an unreasonable size, used to signal
  43      that the size and the corresponding mode array has not been
  44      initialized.  */
  45   int x_apply_args_size_plus_one;
  46   int x_apply_result_size_plus_one;
  47 };
  48
  49 extern struct target_builtins default_target_builtins;
  50 #if SWITCHABLE_TARGET
  51 extern struct target_builtins *this_target_builtins;
  52 #else
  53 #define this_target_builtins (&default_target_builtins)
  54 #endif
  55
  56 /* Non-zero if __builtin_constant_p should be folded right away.  */
  57 extern bool force_folding_builtin_constant_p;
  58
  59 extern bool called_as_built_in (tree);
  60 extern bool get_object_alignment_1 (tree, unsigned int *,
  61                                     unsigned HOST_WIDE_INT *);
  62 extern bool get_object_alignment_2 (tree, unsigned int *,
  63                                     unsigned HOST_WIDE_INT *, bool);
  64 extern unsigned int get_object_alignment (tree);
  65 extern bool get_pointer_alignment_1 (tree, unsigned int *,
  66                                      unsigned HOST_WIDE_INT *);
  67 extern unsigned int get_pointer_alignment (tree);
  68 extern unsigned string_length (const void*, unsigned, unsigned);
  69
  70 struct c_strlen_data
  71 {
  72   /* [MINLEN, MAXBOUND, MAXLEN] is a range describing the length of
  73      one or more strings of possibly unknown length.  For a single
  74      string of known length the range is a constant where
  75      MINLEN == MAXBOUND == MAXLEN holds.
  76      For other strings, MINLEN is the length of the shortest known
  77      string.  MAXBOUND is the length of a string that could be stored
  78      in the largest array referenced by the expression.  MAXLEN is
  79      the length of the longest sequence of non-zero bytes
  80      in an object referenced by the expression.  For such strings,
  81      MINLEN <= MAXBOUND <= MAXLEN holds.  For example, given:
  82        struct A { char a[7], b[]; };
  83        extern struct A *p;
  84        n = strlen (p->a);
  85      the computed range will be [0, 6, ALL_ONES].
  86      However, for a conditional expression involving a string
  87      of known length and an array of unknown bound such as
  88        n = strlen (i ? p->b : "123");
  89      the range will be [3, 3, ALL_ONES].
  90      MINLEN != 0 && MAXLEN == ALL_ONES indicates that MINLEN is
  91      the length of the shortest known string and implies that
  92      the shortest possible string referenced by the expression may
  93      actually be the empty string.  This distinction is useful for
  94      diagnostics.  get_range_strlen() return value distinguishes
  95      between these two cases.
  96      As the tighter (and more optimistic) bound, MAXBOUND is suitable
  97      for diagnostics but not for optimization.
  98      As the more conservative bound, MAXLEN is intended to be used
  99      for optimization.  */
 100   tree minlen;
 101   tree maxlen;
 102   tree maxbound;
 103   /* When non-null, DECL refers to the declaration known to store
 104      an unterminated constant character array, as in:
 105      const char s[] = { 'a', 'b', 'c' };
 106      It is used to diagnose uses of such arrays in functions such as
 107      strlen() that expect a nul-terminated string as an argument.  */
 108   tree decl;
 109   /* Non-constant offset from the beginning of a string not accounted
 110      for in the length range.  Used to improve diagnostics.  */
 111   tree off;
 112 };
 113
 114 extern tree c_strlen (tree, int, c_strlen_data * = NULL, unsigned = 1);
 115 extern rtx c_readstr (const char *, fixed_size_mode, bool = true);
 116 extern void expand_builtin_setjmp_setup (rtx, rtx);
 117 extern void expand_builtin_setjmp_receiver (rtx);
 118 extern void expand_builtin_update_setjmp_buf (rtx);
 119 extern tree mathfn_built_in (tree, enum built_in_function fn);
 120 extern tree mathfn_built_in (tree, combined_fn);
 121 extern tree mathfn_built_in_type (combined_fn);
 122 extern rtx builtin_strncpy_read_str (void *, void *, HOST_WIDE_INT,
 123                                      fixed_size_mode);
 124 extern rtx builtin_memset_read_str (void *, void *, HOST_WIDE_INT,
 125                                     fixed_size_mode);
 126 extern rtx expand_builtin_memset (tree, rtx, machine_mode);
 127 extern rtx expand_builtin_saveregs (void);
 128 extern tree std_build_builtin_va_list (void);
 129 extern tree std_fn_abi_va_list (tree);
 130 extern tree std_canonical_va_list_type (tree);
 131 extern void std_expand_builtin_va_start (tree, rtx);
 132 extern void expand_builtin_trap (void);
 133 extern void expand_ifn_atomic_bit_test_and (gcall *);
 134 extern void expand_ifn_atomic_compare_exchange (gcall *);
 135 extern void expand_ifn_atomic_op_fetch_cmp_0 (gcall *);
 136 extern rtx expand_builtin (tree, rtx, rtx, machine_mode, int);
 137 extern enum built_in_function builtin_mathfn_code (const_tree);
 138 extern tree fold_builtin_expect (location_t, tree, tree, tree, tree);
 139 extern bool avoid_folding_inline_builtin (tree);
 140 extern tree fold_call_expr (location_t, tree, bool);
 141 extern tree fold_builtin_call_array (location_t, tree, tree, int, tree *);
 142 extern bool validate_gimple_arglist (const gcall *, ...);
 143 extern rtx default_expand_builtin (tree, rtx, rtx, machine_mode, int);
 144 extern void maybe_emit_call_builtin___clear_cache (rtx, rtx);
 145 extern bool fold_builtin_next_arg (tree, bool);
 146 extern tree do_mpc_arg2 (tree, tree, tree, int, int (*)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t));
 147 extern tree fold_call_stmt (gcall *, bool);
 148 extern void set_builtin_user_assembler_name (tree decl, const char *asmspec);
 149 extern bool is_simple_builtin (tree);
 150 extern bool is_inexpensive_builtin (tree);
 151 extern bool readonly_data_expr (tree exp);
 152 extern bool init_target_chars (void);
 153 extern unsigned HOST_WIDE_INT target_newline;
 154 extern unsigned HOST_WIDE_INT target_percent;
 155 extern char target_percent_s[3];
 156 extern char target_percent_c[3];
 157 extern char target_percent_s_newline[4];
 158 extern bool target_char_cst_p (tree t, char *p);
 159 extern rtx get_memory_rtx (tree exp, tree len);
 160
 161 extern internal_fn associated_internal_fn (combined_fn, tree);
 162 extern internal_fn associated_internal_fn (tree);
 163 extern internal_fn replacement_internal_fn (gcall *);
 164
 165 extern bool builtin_with_linkage_p (tree);
 166 extern int type_to_class (tree);
 167
 168 #endif /* GCC_BUILTINS_H */