GCC Middle and Back End API Reference
genmatch.cc File Reference
#include "bconfig.h"
#include "system.h"
#include "coretypes.h"
#include <cpplib.h>
#include "rich-location.h"
#include "errors.h"
#include "hash-table.h"
#include "hash-set.h"
#include "is-a.h"
#include "ordered-hash-map.h"
#include "tree.def"
#include "builtins.def"
#include "internal-fn.def"
#include "case-cfn-macros.h"
Include dependency graph for genmatch.cc:

Data Structures

class  id_base
class  operator_id
class  fn_id
class  predicate_id
class  user_id
class  operand
class  predicate
struct  expr
class  c_expr
class  c_expr::id_tab
class  capture
class  if_expr
class  with_expr
class  simplify
struct  sinfo
struct  sinfo_hashmap_traits
class  dt_node
class  dt_operand
class  dt_simplify
class  decision_tree
class  capture_info
struct  capture_info::cinfo
class  parser

Macros

#define DIAG_ARGMAX   30
#define diag_integer_with_precision(FS, ARG, PREC, T, F)
#define SIZED_BASED_CHUNKS   1
#define DEFTREECODE(SYM, STRING, TYPE, NARGS)
#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND)
#define DEF_GCC_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_SYNC_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_GCC_FLOATN_NX_BUILTINS(ENUM, NAME, TYPE_MACRO, ATTRS)
#define DEF_LIB_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_EXT_LIB_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_FLOATN_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_EXT_LIB_FLOATN_NX_BUILTINS(ENUM, NAME, TYPE_MACRO, ATTRS)
#define DEF_C94_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C99_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C11_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C23_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C2Y_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C99_COMPL_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C99_C90RES_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_EXT_C99RES_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_BUILTIN_STUB(ENUM, NAME)
#define DEF_COROUTINE_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOACC_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOACC_BUILTIN_COMPILER(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOACC_BUILTIN_ONLY(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOMP_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOMP_BUILTIN_COMPILER(ENUM, NAME, TYPE, ATTRS)
#define DEF_TM_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_SANITIZER_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define ATTR_MATHFN_ERRNO
#define ATTR_MATHFN_FPROUNDING
#define ATTR_MATHFN_FPROUNDING_ERRNO
#define ATTR_MATHFN_FPROUNDING_STORE   ATTR_NOTHROW_LEAF_LIST
#define ATTR_NOTHROWCALL_LEAF_LIST
#define ACOSH_TYPE(F)
#define ATAN2_TYPE(F)
#define ATANH_TYPE(F)
#define CEIL_TYPE(F)
#define COPYSIGN_TYPE(F)
#define COSH_TYPE(F)
#define FABS_TYPE(F)
#define FDIM_TYPE(F)
#define FLOOR_TYPE(F)
#define FMA_TYPE(F)
#define FMAX_TYPE(F)
#define FMIN_TYPE(F)
#define FREXP_TYPE(F)
#define HUGE_VAL_TYPE(F)
#define HYPOT_TYPE(F)
#define ILOGB_TYPE(F)
#define INF_TYPE(F)
#define LDEXP_TYPE(F)
#define LGAMMA_TYPE(F)
#define LLRINT_TYPE(F)
#define LOG10_TYPE(F)
#define LRINT_TYPE(F)
#define MODF_TYPE(F)
#define NAN_TYPE(F)
#define NEARBYINT_TYPE(F)
#define NEXTAFTER_TYPE(F)
#define REMQUO_TYPE(F)
#define RINT_TYPE(F)
#define ROUND_TYPE(F)
#define ROUNDEVEN_TYPE(F)
#define SCALBLN_TYPE(F)
#define SCALBN_TYPE(F)
#define SINH_TYPE(F)
#define SQRT_TYPE(F)
#define TRUNC_TYPE(F)
#define CABS_TYPE(F)
#define CACOSH_TYPE(F)
#define CARG_TYPE(F)
#define CASINH_TYPE(F)
#define CPOW_TYPE(F)
#define CPROJ_TYPE(F)
#define TRIG_TYPE(F)
#define TRIG2_TYPE(F)
#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC)
#define DEF_INTERNAL_OPTAB_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_SIGNED_OPTAB_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE)
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND)
#define DEF_GCC_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_SYNC_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_GCC_FLOATN_NX_BUILTINS(ENUM, NAME, TYPE_MACRO, ATTRS)
#define DEF_LIB_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_EXT_LIB_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_FLOATN_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_EXT_LIB_FLOATN_NX_BUILTINS(ENUM, NAME, TYPE_MACRO, ATTRS)
#define DEF_C94_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C99_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C11_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C23_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C2Y_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C99_COMPL_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C99_C90RES_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_EXT_C99RES_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_BUILTIN_STUB(ENUM, NAME)
#define DEF_COROUTINE_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOACC_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOACC_BUILTIN_COMPILER(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOACC_BUILTIN_ONLY(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOMP_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOMP_BUILTIN_COMPILER(ENUM, NAME, TYPE, ATTRS)
#define DEF_TM_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_SANITIZER_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define ATTR_MATHFN_ERRNO
#define ATTR_MATHFN_FPROUNDING
#define ATTR_MATHFN_FPROUNDING_ERRNO
#define ATTR_MATHFN_FPROUNDING_STORE   ATTR_NOTHROW_LEAF_LIST
#define ATTR_NOTHROWCALL_LEAF_LIST
#define ACOSH_TYPE(F)
#define ATAN2_TYPE(F)
#define ATANH_TYPE(F)
#define CEIL_TYPE(F)
#define COPYSIGN_TYPE(F)
#define COSH_TYPE(F)
#define FABS_TYPE(F)
#define FDIM_TYPE(F)
#define FLOOR_TYPE(F)
#define FMA_TYPE(F)
#define FMAX_TYPE(F)
#define FMIN_TYPE(F)
#define FREXP_TYPE(F)
#define HUGE_VAL_TYPE(F)
#define HYPOT_TYPE(F)
#define ILOGB_TYPE(F)
#define INF_TYPE(F)
#define LDEXP_TYPE(F)
#define LGAMMA_TYPE(F)
#define LLRINT_TYPE(F)
#define LOG10_TYPE(F)
#define LRINT_TYPE(F)
#define MODF_TYPE(F)
#define NAN_TYPE(F)
#define NEARBYINT_TYPE(F)
#define NEXTAFTER_TYPE(F)
#define REMQUO_TYPE(F)
#define RINT_TYPE(F)
#define ROUND_TYPE(F)
#define ROUNDEVEN_TYPE(F)
#define SCALBLN_TYPE(F)
#define SCALBN_TYPE(F)
#define SINH_TYPE(F)
#define SQRT_TYPE(F)
#define TRUNC_TYPE(F)
#define CABS_TYPE(F)
#define CACOSH_TYPE(F)
#define CARG_TYPE(F)
#define CASINH_TYPE(F)
#define CPOW_TYPE(F)
#define CPROJ_TYPE(F)
#define TRIG_TYPE(F)
#define TRIG2_TYPE(F)
#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC)
#define DEF_INTERNAL_OPTAB_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_SIGNED_OPTAB_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE)
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
#define DEFTREECODE(SYM, STRING, TYPE, NARGS)
#define END_OF_BASE_TREE_CODES
#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND)
#define DEF_GCC_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_SYNC_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_GCC_FLOATN_NX_BUILTINS(ENUM, NAME, TYPE_MACRO, ATTRS)
#define DEF_LIB_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_EXT_LIB_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_FLOATN_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_EXT_LIB_FLOATN_NX_BUILTINS(ENUM, NAME, TYPE_MACRO, ATTRS)
#define DEF_C94_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C99_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C11_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C23_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C2Y_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C99_COMPL_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_C99_C90RES_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_EXT_C99RES_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_BUILTIN_STUB(ENUM, NAME)
#define DEF_COROUTINE_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOACC_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOACC_BUILTIN_COMPILER(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOACC_BUILTIN_ONLY(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOMP_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_GOMP_BUILTIN_COMPILER(ENUM, NAME, TYPE, ATTRS)
#define DEF_TM_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define DEF_SANITIZER_BUILTIN(ENUM, NAME, TYPE, ATTRS)
#define ATTR_MATHFN_ERRNO
#define ATTR_MATHFN_FPROUNDING
#define ATTR_MATHFN_FPROUNDING_ERRNO
#define ATTR_MATHFN_FPROUNDING_STORE   ATTR_NOTHROW_LEAF_LIST
#define ATTR_NOTHROWCALL_LEAF_LIST
#define ACOSH_TYPE(F)
#define ATAN2_TYPE(F)
#define ATANH_TYPE(F)
#define CEIL_TYPE(F)
#define COPYSIGN_TYPE(F)
#define COSH_TYPE(F)
#define FABS_TYPE(F)
#define FDIM_TYPE(F)
#define FLOOR_TYPE(F)
#define FMA_TYPE(F)
#define FMAX_TYPE(F)
#define FMIN_TYPE(F)
#define FREXP_TYPE(F)
#define HUGE_VAL_TYPE(F)
#define HYPOT_TYPE(F)
#define ILOGB_TYPE(F)
#define INF_TYPE(F)
#define LDEXP_TYPE(F)
#define LGAMMA_TYPE(F)
#define LLRINT_TYPE(F)
#define LOG10_TYPE(F)
#define LRINT_TYPE(F)
#define MODF_TYPE(F)
#define NAN_TYPE(F)
#define NEARBYINT_TYPE(F)
#define NEXTAFTER_TYPE(F)
#define REMQUO_TYPE(F)
#define RINT_TYPE(F)
#define ROUND_TYPE(F)
#define ROUNDEVEN_TYPE(F)
#define SCALBLN_TYPE(F)
#define SCALBN_TYPE(F)
#define SINH_TYPE(F)
#define SQRT_TYPE(F)
#define TRUNC_TYPE(F)
#define CABS_TYPE(F)
#define CACOSH_TYPE(F)
#define CARG_TYPE(F)
#define CASINH_TYPE(F)
#define CPOW_TYPE(F)
#define CPROJ_TYPE(F)
#define TRIG_TYPE(F)
#define TRIG2_TYPE(F)
#define DEF_INTERNAL_FN(CODE, NAME, FNSPEC)
#define DEF_INTERNAL_OPTAB_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_SIGNED_OPTAB_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE)
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)

Typedefs

typedef hash_map< nofree_string_hash, unsigned > cid_map_t
typedef ordered_hash_map< void *, sinfo *, sinfo_hashmap_traits > sinfo_map_t

Enumerations

enum  tree_code { DEFTREECODE }
enum  built_in_function { DEF_BUILTIN }
enum  internal_fn { DEF_INTERNAL_OPTAB_FN , DEF_INTERNAL_OPTAB_FN }
enum  combined_fn { DEF_BUILTIN , DEF_BUILTIN }

Functions

void * ggc_internal_cleared_alloc (size_t, void(*)(void *), size_t, size_t MEM_STAT_DECL)
void * ggc_internal_cleared_alloc_no_dtor (size_t, void(*)(void *), size_t, size_t MEM_STAT_DECL)
void ggc_free (void *)
expanded_location linemap_client_expand_location_to_spelling_point (const line_maps *set, location_t loc, enum location_aspect)
static void diag_vfprintf (FILE *f, int err_no, const char *msg, va_list *ap)
static void genmatch_diag_selftests (void)
static bool diagnostic_cb (cpp_reader *, enum cpp_diagnostic_level errtype, enum cpp_warning_reason, rich_location *richloc, const char *msg, va_list *ap)
static void fatal_at (const cpp_token *tk, const char *msg,...)
static void fatal_at (location_t loc, const char *msg,...)
static void warning_at (const cpp_token *tk, const char *msg,...)
static void warning_at (location_t loc, const char *msg,...)
static void fprintf_indent (FILE *f, unsigned int indent, const char *format,...)
static void fp_decl (FILE *f, const char *format,...)
static void fp_decl_done (FILE *f, const char *trailer)
static void write_header_declarations (bool gimple, FILE *f)
static void define_dump_logs (bool gimple, FILE *f)
static void output_line_directive (FILE *f, location_t location, bool dumpfile=false, bool fnargs=false, bool indirect_line_numbers=false)
static FILE * choose_output (const vec< FILE * > &parts)
bool commutative_tree_code (enum tree_code code)
bool commutative_ternary_tree_code (enum tree_code code)
bool comparison_code_p (enum tree_code code)
static int commutative_op (id_base *id, bool compares_are_commutative=false)
static predicate_id * add_predicate (const char *id)
static void add_operator (enum tree_code code, const char *id, const char *tcc, unsigned nargs)
template<typename T>
static void add_function (T code, const char *id)
static bool operator== (id_base &id, enum tree_code code)
id_base * get_operator (const char *id, bool allow_null=false)
id_base * swap_tree_comparison (operator_id *p)
DEBUG_FUNCTION void print_operand (operand *o, FILE *f=stderr, bool flattened=false)
DEBUG_FUNCTION void print_matches (class simplify *s, FILE *f=stderr)
static void cartesian_product (const vec< vec< operand * > > &ops_vector, vec< vec< operand * > > &result, vec< operand * > &v, unsigned n)
static vec< operand * > commutate (operand *op, vec< vec< user_id * > > &for_vec)
static void lower_commutative (simplify *s, vec< simplify * > &simplifiers)
operand * lower_opt (operand *o, unsigned char grp, bool strip)
static bool has_opt (operand *o, unsigned char grp)
static vec< operand * > lower_opt (operand *o)
static void lower_opt (simplify *s, vec< simplify * > &simplifiers)
static vec< operand * > lower_cond (operand *o)
static void lower_cond (simplify *s, vec< simplify * > &simplifiers)
bool contains_id (operand *o, user_id *id)
operand * replace_id (operand *o, user_id *id, id_base *with)
static bool binary_ok (operator_id *op)
static void lower_for (simplify *sin, vec< simplify * > &simplifiers)
static void lower (vec< simplify * > &simplifiers, bool gimple)
bool cmp_operand (operand *o1, operand *o2)
bool is_conversion (id_base *op)
bool possible_noop_convert (id_base *op)
static const char * get_operand_type (id_base *op, unsigned pos, const char *in_type, const char *expr_type, const char *other_oprnd_type)
static int fns_cmp (const void *p1, const void *p2)
static void emit_logging_call (FILE *f, int indent, class simplify *s, operand *result, bool gimple)
static bool compare_op (operand *o1, simplify *s1, operand *o2, simplify *s2)
void write_predicate (FILE *f, predicate_id *p, decision_tree &dt, bool gimple)
static void write_header (FILE *f, const char *head)
static void walk_captures (operand *op, vec< vec< capture * > > &cpts)
static size_t round_alloc_size (size_t s)
static void usage ()
static void write_header_includes (bool gimple, FILE *header_file)
int main (int argc, char **argv)

Variables

unsigned verbose
static class line_maps * line_table
static FILE * header_file
static vec< int > dbg_line_numbers
static id_base * null_id
static hash_table< id_base > * operators
static unsigned current_id
static char * fail_label

Macro Definition Documentation

â—† ACOSH_TYPE [1/3]

#define ACOSH_TYPE ( F)
Value:
BT_FN_##F##_##F
Make sure 0 is not a legitimate builtin.   
Category: math builtins.

â—† ACOSH_TYPE [2/3]

#define ACOSH_TYPE ( F)
Value:
BT_FN_##F##_##F
Make sure 0 is not a legitimate builtin.   
Category: math builtins.

â—† ACOSH_TYPE [3/3]

#define ACOSH_TYPE ( F)
Value:
BT_FN_##F##_##F
Make sure 0 is not a legitimate builtin.   
Category: math builtins.

â—† ATAN2_TYPE [1/3]

#define ATAN2_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† ATAN2_TYPE [2/3]

#define ATAN2_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† ATAN2_TYPE [3/3]

#define ATAN2_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† ATANH_TYPE [1/3]

#define ATANH_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† ATANH_TYPE [2/3]

#define ATANH_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† ATANH_TYPE [3/3]

#define ATANH_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† ATTR_MATHFN_ERRNO [1/3]

#define ATTR_MATHFN_ERRNO
Value:
(flag_errno_math ? \
ATTR_ERRNOCONST_NOTHROW_LEAF_LIST : ATTR_CONST_NOTHROW_LEAF_LIST)
Define an attribute list for math functions that are normally
"impure" because some of them may write into global memory for
`errno'.  If !flag_errno_math they are instead "const".

â—† ATTR_MATHFN_ERRNO [2/3]

#define ATTR_MATHFN_ERRNO
Value:
(flag_errno_math ? \
ATTR_ERRNOCONST_NOTHROW_LEAF_LIST : ATTR_CONST_NOTHROW_LEAF_LIST)
Define an attribute list for math functions that are normally
"impure" because some of them may write into global memory for
`errno'.  If !flag_errno_math they are instead "const".

â—† ATTR_MATHFN_ERRNO [3/3]

#define ATTR_MATHFN_ERRNO
Value:
(flag_errno_math ? \
ATTR_ERRNOCONST_NOTHROW_LEAF_LIST : ATTR_CONST_NOTHROW_LEAF_LIST)
Define an attribute list for math functions that are normally
"impure" because some of them may write into global memory for
`errno'.  If !flag_errno_math they are instead "const".

â—† ATTR_MATHFN_FPROUNDING [1/3]

#define ATTR_MATHFN_FPROUNDING
Value:
(flag_rounding_math ? \
ATTR_PURE_NOTHROW_LEAF_LIST : ATTR_CONST_NOTHROW_LEAF_LIST)
Define an attribute list for math functions that are normally
"const" but if flag_rounding_math is set they are instead "pure".
This distinction accounts for the fact that some math functions
check the rounding mode which is akin to examining global
memory.

â—† ATTR_MATHFN_FPROUNDING [2/3]

#define ATTR_MATHFN_FPROUNDING
Value:
(flag_rounding_math ? \
ATTR_PURE_NOTHROW_LEAF_LIST : ATTR_CONST_NOTHROW_LEAF_LIST)
Define an attribute list for math functions that are normally
"const" but if flag_rounding_math is set they are instead "pure".
This distinction accounts for the fact that some math functions
check the rounding mode which is akin to examining global
memory.

â—† ATTR_MATHFN_FPROUNDING [3/3]

#define ATTR_MATHFN_FPROUNDING
Value:
(flag_rounding_math ? \
ATTR_PURE_NOTHROW_LEAF_LIST : ATTR_CONST_NOTHROW_LEAF_LIST)
Define an attribute list for math functions that are normally
"const" but if flag_rounding_math is set they are instead "pure".
This distinction accounts for the fact that some math functions
check the rounding mode which is akin to examining global
memory.

â—† ATTR_MATHFN_FPROUNDING_ERRNO [1/3]

#define ATTR_MATHFN_FPROUNDING_ERRNO
Value:
(flag_errno_math ? \
(flag_rounding_math ? ATTR_ERRNOPURE_NOTHROW_LEAF_LIST \
: ATTR_ERRNOCONST_NOTHROW_LEAF_LIST) : ATTR_MATHFN_FPROUNDING)
Define an attribute list for math functions that are normally
"impure" because some of them may write into global memory for
`errno'.  If !flag_errno_math, we can possibly use "pure" or
"const" depending on whether we care about FP rounding.

â—† ATTR_MATHFN_FPROUNDING_ERRNO [2/3]

#define ATTR_MATHFN_FPROUNDING_ERRNO
Value:
(flag_errno_math ? \
(flag_rounding_math ? ATTR_ERRNOPURE_NOTHROW_LEAF_LIST \
: ATTR_ERRNOCONST_NOTHROW_LEAF_LIST) : ATTR_MATHFN_FPROUNDING)
Define an attribute list for math functions that are normally
"impure" because some of them may write into global memory for
`errno'.  If !flag_errno_math, we can possibly use "pure" or
"const" depending on whether we care about FP rounding.

â—† ATTR_MATHFN_FPROUNDING_ERRNO [3/3]

#define ATTR_MATHFN_FPROUNDING_ERRNO
Value:
(flag_errno_math ? \
(flag_rounding_math ? ATTR_ERRNOPURE_NOTHROW_LEAF_LIST \
: ATTR_ERRNOCONST_NOTHROW_LEAF_LIST) : ATTR_MATHFN_FPROUNDING)
Define an attribute list for math functions that are normally
"impure" because some of them may write into global memory for
`errno'.  If !flag_errno_math, we can possibly use "pure" or
"const" depending on whether we care about FP rounding.

â—† ATTR_MATHFN_FPROUNDING_STORE [1/3]

#define ATTR_MATHFN_FPROUNDING_STORE   ATTR_NOTHROW_LEAF_LIST 
Define an attribute list for math functions that need to mind FP
rounding, but because they store into memory they are never "const"
or "pure".  Use of this macro is mainly for documentation and
maintenance purposes.

â—† ATTR_MATHFN_FPROUNDING_STORE [2/3]

#define ATTR_MATHFN_FPROUNDING_STORE   ATTR_NOTHROW_LEAF_LIST 
Define an attribute list for math functions that need to mind FP
rounding, but because they store into memory they are never "const"
or "pure".  Use of this macro is mainly for documentation and
maintenance purposes.

â—† ATTR_MATHFN_FPROUNDING_STORE [3/3]

#define ATTR_MATHFN_FPROUNDING_STORE   ATTR_NOTHROW_LEAF_LIST 
Define an attribute list for math functions that need to mind FP
rounding, but because they store into memory they are never "const"
or "pure".  Use of this macro is mainly for documentation and
maintenance purposes.

â—† ATTR_NOTHROWCALL_LEAF_LIST [1/3]

#define ATTR_NOTHROWCALL_LEAF_LIST
Value:
(flag_non_call_exceptions ? \
ATTR_LEAF_LIST : ATTR_NOTHROW_LEAF_LIST)
Define an attribute list for leaf functions that do not throw
exceptions normally, but may throw exceptions when using
-fnon-call-exceptions.

â—† ATTR_NOTHROWCALL_LEAF_LIST [2/3]

#define ATTR_NOTHROWCALL_LEAF_LIST
Value:
(flag_non_call_exceptions ? \
ATTR_LEAF_LIST : ATTR_NOTHROW_LEAF_LIST)
Define an attribute list for leaf functions that do not throw
exceptions normally, but may throw exceptions when using
-fnon-call-exceptions.

â—† ATTR_NOTHROWCALL_LEAF_LIST [3/3]

#define ATTR_NOTHROWCALL_LEAF_LIST
Value:
(flag_non_call_exceptions ? \
ATTR_LEAF_LIST : ATTR_NOTHROW_LEAF_LIST)
Define an attribute list for leaf functions that do not throw
exceptions normally, but may throw exceptions when using
-fnon-call-exceptions.

â—† CABS_TYPE [1/3]

#define CABS_TYPE ( F)
Value:
BT_FN_##F##_COMPLEX_##F
Category: _Complex math builtins.

â—† CABS_TYPE [2/3]

#define CABS_TYPE ( F)
Value:
BT_FN_##F##_COMPLEX_##F
Category: _Complex math builtins.

â—† CABS_TYPE [3/3]

#define CABS_TYPE ( F)
Value:
BT_FN_##F##_COMPLEX_##F
Category: _Complex math builtins.

â—† CACOSH_TYPE [1/3]

#define CACOSH_TYPE ( F)
Value:
BT_FN_COMPLEX_##F##_COMPLEX_##F

â—† CACOSH_TYPE [2/3]

#define CACOSH_TYPE ( F)
Value:
BT_FN_COMPLEX_##F##_COMPLEX_##F

â—† CACOSH_TYPE [3/3]

#define CACOSH_TYPE ( F)
Value:
BT_FN_COMPLEX_##F##_COMPLEX_##F

â—† CARG_TYPE [1/3]

#define CARG_TYPE ( F)
Value:
BT_FN_##F##_COMPLEX_##F

â—† CARG_TYPE [2/3]

#define CARG_TYPE ( F)
Value:
BT_FN_##F##_COMPLEX_##F

â—† CARG_TYPE [3/3]

#define CARG_TYPE ( F)
Value:
BT_FN_##F##_COMPLEX_##F

â—† CASINH_TYPE [1/3]

#define CASINH_TYPE ( F)
Value:
BT_FN_COMPLEX_##F##_COMPLEX_##F

â—† CASINH_TYPE [2/3]

#define CASINH_TYPE ( F)
Value:
BT_FN_COMPLEX_##F##_COMPLEX_##F

â—† CASINH_TYPE [3/3]

#define CASINH_TYPE ( F)
Value:
BT_FN_COMPLEX_##F##_COMPLEX_##F

â—† CEIL_TYPE [1/3]

#define CEIL_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† CEIL_TYPE [2/3]

#define CEIL_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† CEIL_TYPE [3/3]

#define CEIL_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† COPYSIGN_TYPE [1/3]

#define COPYSIGN_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† COPYSIGN_TYPE [2/3]

#define COPYSIGN_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† COPYSIGN_TYPE [3/3]

#define COPYSIGN_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† COSH_TYPE [1/3]

#define COSH_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† COSH_TYPE [2/3]

#define COSH_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† COSH_TYPE [3/3]

#define COSH_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† CPOW_TYPE [1/3]

#define CPOW_TYPE ( F)
Value:
BT_FN_COMPLEX_##F##_COMPLEX_##F##_COMPLEX_##F

â—† CPOW_TYPE [2/3]

#define CPOW_TYPE ( F)
Value:
BT_FN_COMPLEX_##F##_COMPLEX_##F##_COMPLEX_##F

â—† CPOW_TYPE [3/3]

#define CPOW_TYPE ( F)
Value:
BT_FN_COMPLEX_##F##_COMPLEX_##F##_COMPLEX_##F

â—† CPROJ_TYPE [1/3]

#define CPROJ_TYPE ( F)
Value:
BT_FN_COMPLEX_##F##_COMPLEX_##F

â—† CPROJ_TYPE [2/3]

#define CPROJ_TYPE ( F)
Value:
BT_FN_COMPLEX_##F##_COMPLEX_##F

â—† CPROJ_TYPE [3/3]

#define CPROJ_TYPE ( F)
Value:
BT_FN_COMPLEX_##F##_COMPLEX_##F

â—† DEF_BUILTIN [1/3]

#define DEF_BUILTIN ( ENUM,
N,
C,
T,
LT,
B,
F,
NA,
AT,
IM,
COND )
Value:
ENUM,
ENUM
@ ENUM
Definition gengtype.h:476

â—† DEF_BUILTIN [2/3]

#define DEF_BUILTIN ( ENUM,
N,
C,
T,
LT,
B,
F,
NA,
AT,
IM,
COND )
Value:
CFN_##ENUM = int (ENUM),

â—† DEF_BUILTIN [3/3]

#define DEF_BUILTIN ( ENUM,
N,
C,
T,
LT,
B,
F,
NA,
AT,
IM,
COND )
Value:
add_function (ENUM, "CFN_" # ENUM);
add_function
static void add_function(T code, const char *id)
Definition genmatch.cc:1366

â—† DEF_BUILTIN_STUB [1/3]

#define DEF_BUILTIN_STUB ( ENUM,
NAME )
Value:
DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, BT_LAST, BT_LAST, false, false, \
false, ATTR_LAST, false, false)
Allocate the enum and the name for a builtin, but do not actually
define it here at all.

â—† DEF_BUILTIN_STUB [2/3]

#define DEF_BUILTIN_STUB ( ENUM,
NAME )
Value:
DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, BT_LAST, BT_LAST, false, false, \
false, ATTR_LAST, false, false)
Allocate the enum and the name for a builtin, but do not actually
define it here at all.

â—† DEF_BUILTIN_STUB [3/3]

#define DEF_BUILTIN_STUB ( ENUM,
NAME )
Value:
DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, BT_LAST, BT_LAST, false, false, \
false, ATTR_LAST, false, false)
Allocate the enum and the name for a builtin, but do not actually
define it here at all.

â—† DEF_C11_BUILTIN [1/3]

#define DEF_C11_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc11, ATTRS, \
targetm.libc_has_function (function_c11_misc, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C11 or above.

â—† DEF_C11_BUILTIN [2/3]

#define DEF_C11_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc11, ATTRS, \
targetm.libc_has_function (function_c11_misc, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C11 or above.

â—† DEF_C11_BUILTIN [3/3]

#define DEF_C11_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc11, ATTRS, \
targetm.libc_has_function (function_c11_misc, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C11 or above.

â—† DEF_C23_BUILTIN [1/3]

#define DEF_C23_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc23, ATTRS, \
targetm.libc_has_function (function_c23_misc, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C23 or above.

â—† DEF_C23_BUILTIN [2/3]

#define DEF_C23_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc23, ATTRS, \
targetm.libc_has_function (function_c23_misc, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C23 or above.

â—† DEF_C23_BUILTIN [3/3]

#define DEF_C23_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc23, ATTRS, \
targetm.libc_has_function (function_c23_misc, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C23 or above.

â—† DEF_C2Y_BUILTIN [1/3]

#define DEF_C2Y_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc2y, ATTRS, \
targetm.libc_has_function (function_c2y_misc, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C2Y or above.

â—† DEF_C2Y_BUILTIN [2/3]

#define DEF_C2Y_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc2y, ATTRS, \
targetm.libc_has_function (function_c2y_misc, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C2Y or above.

â—† DEF_C2Y_BUILTIN [3/3]

#define DEF_C2Y_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc2y, ATTRS, \
targetm.libc_has_function (function_c2y_misc, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C2Y or above.

â—† DEF_C94_BUILTIN [1/3]

#define DEF_C94_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc94, ATTRS, \
targetm.libc_has_function (function_c94, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C94 or above.

â—† DEF_C94_BUILTIN [2/3]

#define DEF_C94_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc94, ATTRS, \
targetm.libc_has_function (function_c94, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C94 or above.

â—† DEF_C94_BUILTIN [3/3]

#define DEF_C94_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc94, ATTRS, \
targetm.libc_has_function (function_c94, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C94 or above.

â—† DEF_C99_BUILTIN [1/3]

#define DEF_C99_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc99, ATTRS, \
targetm.libc_has_function (function_c99_misc, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C99 or above.

â—† DEF_C99_BUILTIN [2/3]

#define DEF_C99_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc99, ATTRS, \
targetm.libc_has_function (function_c99_misc, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C99 or above.

â—† DEF_C99_BUILTIN [3/3]

#define DEF_C99_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc99, ATTRS, \
targetm.libc_has_function (function_c99_misc, NULL_TREE), true)
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C99 or above.

â—† DEF_C99_C90RES_BUILTIN [1/3]

#define DEF_C99_C90RES_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc99, ATTRS, \
targetm.libc_has_function (function_c99_misc, NULL_TREE), true)
Builtin that is specified by C99 and C90 reserve the name for future use.
We can still recognize the builtin in C90 mode but we can't produce it
implicitly.

â—† DEF_C99_C90RES_BUILTIN [2/3]

#define DEF_C99_C90RES_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc99, ATTRS, \
targetm.libc_has_function (function_c99_misc, NULL_TREE), true)
Builtin that is specified by C99 and C90 reserve the name for future use.
We can still recognize the builtin in C90 mode but we can't produce it
implicitly.

â—† DEF_C99_C90RES_BUILTIN [3/3]

#define DEF_C99_C90RES_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc99, ATTRS, \
targetm.libc_has_function (function_c99_misc, NULL_TREE), true)
Builtin that is specified by C99 and C90 reserve the name for future use.
We can still recognize the builtin in C90 mode but we can't produce it
implicitly.

â—† DEF_C99_COMPL_BUILTIN [1/3]

#define DEF_C99_COMPL_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc99, ATTRS, \
targetm.libc_has_function (function_c99_math_complex, \
NULL_TREE), \
true)
Like DEF_C99_BUILTIN, but for complex math functions.

â—† DEF_C99_COMPL_BUILTIN [2/3]

#define DEF_C99_COMPL_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc99, ATTRS, \
targetm.libc_has_function (function_c99_math_complex, \
NULL_TREE), \
true)
Like DEF_C99_BUILTIN, but for complex math functions.

â—† DEF_C99_COMPL_BUILTIN [3/3]

#define DEF_C99_COMPL_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, !flag_isoc99, ATTRS, \
targetm.libc_has_function (function_c99_math_complex, \
NULL_TREE), \
true)
Like DEF_C99_BUILTIN, but for complex math functions.

â—† DEF_COROUTINE_BUILTIN [1/3]

#define DEF_COROUTINE_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_coro_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, true, ATTRS, true, flag_coroutines)
Builtins used in implementing coroutine support.

â—† DEF_COROUTINE_BUILTIN [2/3]

#define DEF_COROUTINE_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_coro_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, true, ATTRS, true, flag_coroutines)
Builtins used in implementing coroutine support.

â—† DEF_COROUTINE_BUILTIN [3/3]

#define DEF_COROUTINE_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_coro_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, true, ATTRS, true, flag_coroutines)
Builtins used in implementing coroutine support.

â—† DEF_EXT_C99RES_BUILTIN [1/3]

#define DEF_EXT_C99RES_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, true, ATTRS, false, true)
Builtin that C99 reserve the name for future use. We can still recognize
the builtin in C99 mode but we can't produce it implicitly.

â—† DEF_EXT_C99RES_BUILTIN [2/3]

#define DEF_EXT_C99RES_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, true, ATTRS, false, true)
Builtin that C99 reserve the name for future use. We can still recognize
the builtin in C99 mode but we can't produce it implicitly.

â—† DEF_EXT_C99RES_BUILTIN [3/3]

#define DEF_EXT_C99RES_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, true, ATTRS, false, true)
Builtin that C99 reserve the name for future use. We can still recognize
the builtin in C99 mode but we can't produce it implicitly.

â—† DEF_EXT_LIB_BUILTIN [1/3]

#define DEF_EXT_LIB_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, true, ATTRS, false, true)
Like DEF_LIB_BUILTIN, except that the function is not one that is
specified by ANSI/ISO C.  So, when we're being fully conformant we
ignore the version of these builtins that does not begin with
__builtin.

â—† DEF_EXT_LIB_BUILTIN [2/3]

#define DEF_EXT_LIB_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, true, ATTRS, false, true)
Like DEF_LIB_BUILTIN, except that the function is not one that is
specified by ANSI/ISO C.  So, when we're being fully conformant we
ignore the version of these builtins that does not begin with
__builtin.

â—† DEF_EXT_LIB_BUILTIN [3/3]

#define DEF_EXT_LIB_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, true, ATTRS, false, true)
Like DEF_LIB_BUILTIN, except that the function is not one that is
specified by ANSI/ISO C.  So, when we're being fully conformant we
ignore the version of these builtins that does not begin with
__builtin.

â—† DEF_EXT_LIB_FLOATN_NX_BUILTINS [1/3]

#define DEF_EXT_LIB_FLOATN_NX_BUILTINS ( ENUM,
NAME,
TYPE_MACRO,
ATTRS )
Value:
DEF_FLOATN_BUILTIN (ENUM ## F16, NAME "f16", TYPE_MACRO (FLOAT16), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F32, NAME "f32", TYPE_MACRO (FLOAT32), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F64, NAME "f64", TYPE_MACRO (FLOAT64), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F128, NAME "f128", TYPE_MACRO (FLOAT128), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F32X, NAME "f32x", TYPE_MACRO (FLOAT32X), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F64X, NAME "f64x", TYPE_MACRO (FLOAT64X), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F128X, NAME "f128x", TYPE_MACRO (FLOAT128X), \
ATTRS)

â—† DEF_EXT_LIB_FLOATN_NX_BUILTINS [2/3]

#define DEF_EXT_LIB_FLOATN_NX_BUILTINS ( ENUM,
NAME,
TYPE_MACRO,
ATTRS )
Value:
DEF_FLOATN_BUILTIN (ENUM ## F16, NAME "f16", TYPE_MACRO (FLOAT16), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F32, NAME "f32", TYPE_MACRO (FLOAT32), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F64, NAME "f64", TYPE_MACRO (FLOAT64), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F128, NAME "f128", TYPE_MACRO (FLOAT128), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F32X, NAME "f32x", TYPE_MACRO (FLOAT32X), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F64X, NAME "f64x", TYPE_MACRO (FLOAT64X), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F128X, NAME "f128x", TYPE_MACRO (FLOAT128X), \
ATTRS)

â—† DEF_EXT_LIB_FLOATN_NX_BUILTINS [3/3]

#define DEF_EXT_LIB_FLOATN_NX_BUILTINS ( ENUM,
NAME,
TYPE_MACRO,
ATTRS )
Value:
DEF_FLOATN_BUILTIN (ENUM ## F16, NAME "f16", TYPE_MACRO (FLOAT16), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F32, NAME "f32", TYPE_MACRO (FLOAT32), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F64, NAME "f64", TYPE_MACRO (FLOAT64), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F128, NAME "f128", TYPE_MACRO (FLOAT128), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F32X, NAME "f32x", TYPE_MACRO (FLOAT32X), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F64X, NAME "f64x", TYPE_MACRO (FLOAT64X), ATTRS) \
DEF_FLOATN_BUILTIN (ENUM ## F128X, NAME "f128x", TYPE_MACRO (FLOAT128X), \
ATTRS)

â—† DEF_FLOATN_BUILTIN [1/3]

#define DEF_FLOATN_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
targetm.floatn_builtin_p ((int) ENUM), true, true, ATTRS, \
false, true)
A set of GCC builtins for _FloatN and _FloatNx types.  TYPE_MACRO is called
with an argument such as FLOAT32 to produce the enum value for the type.  If
we are compiling for the C language with GNU extensions, we enable the name
without the __builtin_ prefix as well as the name with the __builtin_
prefix.  C++ does not enable these names by default because a class based
library should use the __builtin_ names.

â—† DEF_FLOATN_BUILTIN [2/3]

#define DEF_FLOATN_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
targetm.floatn_builtin_p ((int) ENUM), true, true, ATTRS, \
false, true)
A set of GCC builtins for _FloatN and _FloatNx types.  TYPE_MACRO is called
with an argument such as FLOAT32 to produce the enum value for the type.  If
we are compiling for the C language with GNU extensions, we enable the name
without the __builtin_ prefix as well as the name with the __builtin_
prefix.  C++ does not enable these names by default because a class based
library should use the __builtin_ names.

â—† DEF_FLOATN_BUILTIN [3/3]

#define DEF_FLOATN_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
targetm.floatn_builtin_p ((int) ENUM), true, true, ATTRS, \
false, true)
A set of GCC builtins for _FloatN and _FloatNx types.  TYPE_MACRO is called
with an argument such as FLOAT32 to produce the enum value for the type.  If
we are compiling for the C language with GNU extensions, we enable the name
without the __builtin_ prefix as well as the name with the __builtin_
prefix.  C++ does not enable these names by default because a class based
library should use the __builtin_ names.

â—† DEF_GCC_BUILTIN [1/3]

#define DEF_GCC_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
false, false, false, ATTRS, true, true)
This file contains the definitions and documentation for the
   builtins used in the GNU compiler.
   Copyright (C) 2000-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
Before including this file, you should define a macro:

  DEF_BUILTIN (ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P,
               FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT, COND)

This macro will be called once for each builtin function.  The
ENUM will be of type `enum built_in_function', and will indicate
which builtin function is being processed.  The NAME of the builtin
function (which will always start with `__builtin_') is a string
literal.  The CLASS is of type `enum built_in_class' and indicates
what kind of builtin is being processed.

Some builtins are actually two separate functions.  For example,
for `strcmp' there are two builtin functions; `__builtin_strcmp'
and `strcmp' itself.  Both behave identically.  Other builtins
define only the `__builtin' variant.  If BOTH_P is TRUE, then this
builtin has both variants; otherwise, it is has only the first
variant.

TYPE indicates the type of the function.  The symbols correspond to
enumerals from builtin-types.def.  If BOTH_P is true, then LIBTYPE
is the type of the non-`__builtin_' variant.  Otherwise, LIBTYPE
should be ignored.

If FALLBACK_P is true then, if for some reason, the compiler cannot
expand the builtin function directly, it will call the
corresponding library function (which does not have the
`__builtin_' prefix.

If NONANSI_P is true, then the non-`__builtin_' variant is not an
ANSI/ISO library function, and so we should pretend it does not
exist when compiling in ANSI conformant mode.

ATTRs is an attribute list as defined in builtin-attrs.def that
describes the attributes of this builtin function.

IMPLICIT specifies condition when the builtin can be produced by
compiler.  For instance C90 reserves floorf function, but does not
define it's meaning.  When user uses floorf we may assume that the
floorf has the meaning we expect, but we can't produce floorf by
simplifying floor((double)float) since the runtime need not implement
it.

The builtins is registered only if COND is true.   
A GCC builtin (like __builtin_saveregs) is provided by the
compiler, but does not correspond to a function in the standard
library.

â—† DEF_GCC_BUILTIN [2/3]

#define DEF_GCC_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
false, false, false, ATTRS, true, true)
This file contains the definitions and documentation for the
   builtins used in the GNU compiler.
   Copyright (C) 2000-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
Before including this file, you should define a macro:

  DEF_BUILTIN (ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P,
               FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT, COND)

This macro will be called once for each builtin function.  The
ENUM will be of type `enum built_in_function', and will indicate
which builtin function is being processed.  The NAME of the builtin
function (which will always start with `__builtin_') is a string
literal.  The CLASS is of type `enum built_in_class' and indicates
what kind of builtin is being processed.

Some builtins are actually two separate functions.  For example,
for `strcmp' there are two builtin functions; `__builtin_strcmp'
and `strcmp' itself.  Both behave identically.  Other builtins
define only the `__builtin' variant.  If BOTH_P is TRUE, then this
builtin has both variants; otherwise, it is has only the first
variant.

TYPE indicates the type of the function.  The symbols correspond to
enumerals from builtin-types.def.  If BOTH_P is true, then LIBTYPE
is the type of the non-`__builtin_' variant.  Otherwise, LIBTYPE
should be ignored.

If FALLBACK_P is true then, if for some reason, the compiler cannot
expand the builtin function directly, it will call the
corresponding library function (which does not have the
`__builtin_' prefix.

If NONANSI_P is true, then the non-`__builtin_' variant is not an
ANSI/ISO library function, and so we should pretend it does not
exist when compiling in ANSI conformant mode.

ATTRs is an attribute list as defined in builtin-attrs.def that
describes the attributes of this builtin function.

IMPLICIT specifies condition when the builtin can be produced by
compiler.  For instance C90 reserves floorf function, but does not
define it's meaning.  When user uses floorf we may assume that the
floorf has the meaning we expect, but we can't produce floorf by
simplifying floor((double)float) since the runtime need not implement
it.

The builtins is registered only if COND is true.   
A GCC builtin (like __builtin_saveregs) is provided by the
compiler, but does not correspond to a function in the standard
library.

â—† DEF_GCC_BUILTIN [3/3]

#define DEF_GCC_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
false, false, false, ATTRS, true, true)
This file contains the definitions and documentation for the
   builtins used in the GNU compiler.
   Copyright (C) 2000-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
Before including this file, you should define a macro:

  DEF_BUILTIN (ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P,
               FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT, COND)

This macro will be called once for each builtin function.  The
ENUM will be of type `enum built_in_function', and will indicate
which builtin function is being processed.  The NAME of the builtin
function (which will always start with `__builtin_') is a string
literal.  The CLASS is of type `enum built_in_class' and indicates
what kind of builtin is being processed.

Some builtins are actually two separate functions.  For example,
for `strcmp' there are two builtin functions; `__builtin_strcmp'
and `strcmp' itself.  Both behave identically.  Other builtins
define only the `__builtin' variant.  If BOTH_P is TRUE, then this
builtin has both variants; otherwise, it is has only the first
variant.

TYPE indicates the type of the function.  The symbols correspond to
enumerals from builtin-types.def.  If BOTH_P is true, then LIBTYPE
is the type of the non-`__builtin_' variant.  Otherwise, LIBTYPE
should be ignored.

If FALLBACK_P is true then, if for some reason, the compiler cannot
expand the builtin function directly, it will call the
corresponding library function (which does not have the
`__builtin_' prefix.

If NONANSI_P is true, then the non-`__builtin_' variant is not an
ANSI/ISO library function, and so we should pretend it does not
exist when compiling in ANSI conformant mode.

ATTRs is an attribute list as defined in builtin-attrs.def that
describes the attributes of this builtin function.

IMPLICIT specifies condition when the builtin can be produced by
compiler.  For instance C90 reserves floorf function, but does not
define it's meaning.  When user uses floorf we may assume that the
floorf has the meaning we expect, but we can't produce floorf by
simplifying floor((double)float) since the runtime need not implement
it.

The builtins is registered only if COND is true.   
A GCC builtin (like __builtin_saveregs) is provided by the
compiler, but does not correspond to a function in the standard
library.

â—† DEF_GCC_FLOATN_NX_BUILTINS [1/3]

#define DEF_GCC_FLOATN_NX_BUILTINS ( ENUM,
NAME,
TYPE_MACRO,
ATTRS )
Value:
DEF_GCC_BUILTIN (ENUM ## F16, NAME "f16", TYPE_MACRO (FLOAT16), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F32, NAME "f32", TYPE_MACRO (FLOAT32), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F64, NAME "f64", TYPE_MACRO (FLOAT64), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F128, NAME "f128", TYPE_MACRO (FLOAT128), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F32X, NAME "f32x", TYPE_MACRO (FLOAT32X), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F64X, NAME "f64x", TYPE_MACRO (FLOAT64X), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F128X, NAME "f128x", TYPE_MACRO (FLOAT128X), ATTRS)
A set of GCC builtins for _FloatN and _FloatNx types.  TYPE_MACRO
is called with an argument such as FLOAT32 to produce the enum
value for the type.

â—† DEF_GCC_FLOATN_NX_BUILTINS [2/3]

#define DEF_GCC_FLOATN_NX_BUILTINS ( ENUM,
NAME,
TYPE_MACRO,
ATTRS )
Value:
DEF_GCC_BUILTIN (ENUM ## F16, NAME "f16", TYPE_MACRO (FLOAT16), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F32, NAME "f32", TYPE_MACRO (FLOAT32), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F64, NAME "f64", TYPE_MACRO (FLOAT64), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F128, NAME "f128", TYPE_MACRO (FLOAT128), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F32X, NAME "f32x", TYPE_MACRO (FLOAT32X), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F64X, NAME "f64x", TYPE_MACRO (FLOAT64X), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F128X, NAME "f128x", TYPE_MACRO (FLOAT128X), ATTRS)
A set of GCC builtins for _FloatN and _FloatNx types.  TYPE_MACRO
is called with an argument such as FLOAT32 to produce the enum
value for the type.

â—† DEF_GCC_FLOATN_NX_BUILTINS [3/3]

#define DEF_GCC_FLOATN_NX_BUILTINS ( ENUM,
NAME,
TYPE_MACRO,
ATTRS )
Value:
DEF_GCC_BUILTIN (ENUM ## F16, NAME "f16", TYPE_MACRO (FLOAT16), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F32, NAME "f32", TYPE_MACRO (FLOAT32), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F64, NAME "f64", TYPE_MACRO (FLOAT64), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F128, NAME "f128", TYPE_MACRO (FLOAT128), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F32X, NAME "f32x", TYPE_MACRO (FLOAT32X), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F64X, NAME "f64x", TYPE_MACRO (FLOAT64X), ATTRS) \
DEF_GCC_BUILTIN (ENUM ## F128X, NAME "f128x", TYPE_MACRO (FLOAT128X), ATTRS)
A set of GCC builtins for _FloatN and _FloatNx types.  TYPE_MACRO
is called with an argument such as FLOAT32 to produce the enum
value for the type.

â—† DEF_GOACC_BUILTIN [1/3]

#define DEF_GOACC_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
false, true, true, ATTRS, false, \
flag_openacc)
Builtin used by the implementation of OpenACC and OpenMP.  Few of these are
actually implemented in the compiler; most are in libgomp.

â—† DEF_GOACC_BUILTIN [2/3]

#define DEF_GOACC_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
false, true, true, ATTRS, false, \
flag_openacc)
Builtin used by the implementation of OpenACC and OpenMP.  Few of these are
actually implemented in the compiler; most are in libgomp.

â—† DEF_GOACC_BUILTIN [3/3]

#define DEF_GOACC_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
false, true, true, ATTRS, false, \
flag_openacc)
Builtin used by the implementation of OpenACC and OpenMP.  Few of these are
actually implemented in the compiler; most are in libgomp.

â—† DEF_GOACC_BUILTIN_COMPILER [1/3]

#define DEF_GOACC_BUILTIN_COMPILER ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
flag_openacc, true, true, ATTRS, false, true)
Set NONANSI_P = false to enable the builtins also with -fno-nonansi-builtins,
esp. as -std=c++../c.. imply that flag and -fopenacc should be othogonal.

â—† DEF_GOACC_BUILTIN_COMPILER [2/3]

#define DEF_GOACC_BUILTIN_COMPILER ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
flag_openacc, true, true, ATTRS, false, true)
Set NONANSI_P = false to enable the builtins also with -fno-nonansi-builtins,
esp. as -std=c++../c.. imply that flag and -fopenacc should be othogonal.

â—† DEF_GOACC_BUILTIN_COMPILER [3/3]

#define DEF_GOACC_BUILTIN_COMPILER ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
flag_openacc, true, true, ATTRS, false, true)
Set NONANSI_P = false to enable the builtins also with -fno-nonansi-builtins,
esp. as -std=c++../c.. imply that flag and -fopenacc should be othogonal.

â—† DEF_GOACC_BUILTIN_ONLY [1/3]

#define DEF_GOACC_BUILTIN_ONLY ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
false, false, true, ATTRS, false, flag_openacc)

â—† DEF_GOACC_BUILTIN_ONLY [2/3]

#define DEF_GOACC_BUILTIN_ONLY ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
false, false, true, ATTRS, false, flag_openacc)

â—† DEF_GOACC_BUILTIN_ONLY [3/3]

#define DEF_GOACC_BUILTIN_ONLY ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
false, false, true, ATTRS, false, flag_openacc)

â—† DEF_GOMP_BUILTIN [1/3]

#define DEF_GOMP_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
false, true, true, ATTRS, false, \
(flag_openacc \
|| flag_openmp \
|| flag_tree_parallelize_loops > 1))

â—† DEF_GOMP_BUILTIN [2/3]

#define DEF_GOMP_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
false, true, true, ATTRS, false, \
(flag_openacc \
|| flag_openmp \
|| flag_tree_parallelize_loops > 1))

â—† DEF_GOMP_BUILTIN [3/3]

#define DEF_GOMP_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
false, true, true, ATTRS, false, \
(flag_openacc \
|| flag_openmp \
|| flag_tree_parallelize_loops > 1))

â—† DEF_GOMP_BUILTIN_COMPILER [1/3]

#define DEF_GOMP_BUILTIN_COMPILER ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
flag_openmp, true, false, ATTRS, false, flag_openmp)
Set NONANSI_P = false to enable the builtins also with -fno-nonansi-builtins,
esp. as -std=c++../c.. imply that flag and -fopenmp should be othogonal.

â—† DEF_GOMP_BUILTIN_COMPILER [2/3]

#define DEF_GOMP_BUILTIN_COMPILER ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
flag_openmp, true, false, ATTRS, false, flag_openmp)
Set NONANSI_P = false to enable the builtins also with -fno-nonansi-builtins,
esp. as -std=c++../c.. imply that flag and -fopenmp should be othogonal.

â—† DEF_GOMP_BUILTIN_COMPILER [3/3]

#define DEF_GOMP_BUILTIN_COMPILER ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
flag_openmp, true, false, ATTRS, false, flag_openmp)
Set NONANSI_P = false to enable the builtins also with -fno-nonansi-builtins,
esp. as -std=c++../c.. imply that flag and -fopenmp should be othogonal.

â—† DEF_INTERNAL_COND_FN [1/3]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

â—† DEF_INTERNAL_COND_FN [2/3]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

â—† DEF_INTERNAL_COND_FN [3/3]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

â—† DEF_INTERNAL_FLT_FLOATN_FN [1/3]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

â—† DEF_INTERNAL_FLT_FLOATN_FN [2/3]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

â—† DEF_INTERNAL_FLT_FLOATN_FN [3/3]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

â—† DEF_INTERNAL_FLT_FN [1/3]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

â—† DEF_INTERNAL_FLT_FN [2/3]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

â—† DEF_INTERNAL_FLT_FN [3/3]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

â—† DEF_INTERNAL_FN [1/3]

#define DEF_INTERNAL_FN ( CODE,
FLAGS,
FNSPEC )
Value:
IFN_##CODE,

â—† DEF_INTERNAL_FN [2/3]

#define DEF_INTERNAL_FN ( CODE,
FLAGS,
FNSPEC )
Value:
CFN_##CODE = int (END_BUILTINS) + int (IFN_##CODE),
END_BUILTINS
@ END_BUILTINS
Definition tree-core.h:3541

â—† DEF_INTERNAL_FN [3/3]

#define DEF_INTERNAL_FN ( CODE,
NAME,
FNSPEC )
Value:
add_function (IFN_##CODE, "CFN_" #CODE);

â—† DEF_INTERNAL_INT_EXT_FN [1/3]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

â—† DEF_INTERNAL_INT_EXT_FN [2/3]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

â—† DEF_INTERNAL_INT_EXT_FN [3/3]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

â—† DEF_INTERNAL_INT_FN [1/3]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

â—† DEF_INTERNAL_INT_FN [2/3]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

â—† DEF_INTERNAL_INT_FN [3/3]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

â—† DEF_INTERNAL_OPTAB_FN [1/3]

#define DEF_INTERNAL_OPTAB_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)
Internal functions.
   Copyright (C) 2011-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file specifies a list of internal "functions".  These functions
differ from built-in functions in that they have no linkage and cannot
be called directly by the user.  They represent operations that are only
synthesised by GCC itself.

Internal functions are used instead of tree codes if the operation
and its operands are more naturally represented as a GIMPLE_CALL
than a GIMPLE_ASSIGN.

Each entry in this file has one of the forms:

  DEF_INTERNAL_FN (NAME, FLAGS, FNSPEC)
  DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SIGNED_OPTAB,
                           UNSIGNED_OPTAB, TYPE)
  DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_FLT_FLOATN_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_EXT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_WIDENING_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB,
                             TYPE)

where NAME is the name of the function, FLAGS is a set of
ECF_* flags and FNSPEC is a string describing functions fnspec.

DEF_INTERNAL_OPTAB_FN defines an internal function that maps to a
direct optab.  The function should only be called with a given
set of types if the associated optab is available for the modes
of those types.  OPTAB says what optab to use (without the trailing
"_optab") and TYPE categorizes the optab based on its inputs and
outputs.  The possible types of optab are:

- mask_load: currently just maskload
- load_lanes: currently just vec_load_lanes
- mask_load_lanes: currently just vec_mask_load_lanes
- mask_len_load_lanes: currently just vec_mask_len_load_lanes
- gather_load: used for {mask_,mask_len_,}gather_load
- strided_load: currently just mask_len_strided_load
- len_load: currently just len_load
- mask_len_load: currently just mask_len_load

- mask_store: currently just maskstore
- store_lanes: currently just vec_store_lanes
- mask_store_lanes: currently just vec_mask_store_lanes
- mask_len_store_lanes: currently just vec_mask_len_store_lanes
- scatter_store: used for {mask_,mask_len_,}scatter_store
- strided_store: currently just mask_len_strided_store
- len_store: currently just len_store
- mask_len_store: currently just mask_len_store

- unary: a normal unary optab, such as vec_reverse_<mode>
- binary: a normal binary optab, such as vec_interleave_lo_<mode>
- ternary: a normal ternary optab, such as fma<mode>4

- unary_convert: a single-input conversion optab, such as
  lround<srcmode><dstmode>2.

- cond_binary: a conditional binary optab, such as cond_add<mode>
- cond_unary: a conditional unary optab, such as cond_neg<mode>
- cond_ternary: a conditional ternary optab, such as cond_fma_rev<mode>

- fold_left: for scalar = FN (scalar, vector), keyed off the vector mode
- check_ptrs: used for check_{raw,war}_ptrs

- cond_len_unary: a conditional unary optab, such as cond_len_neg<mode>
- cond_len_binary: a conditional binary optab, such as cond_len_add<mode>
- cond_len_ternary: a conditional ternary optab, such as
cond_len_fma_rev<mode>

DEF_INTERNAL_SIGNED_OPTAB_FN defines an internal function that
maps to one of two optabs, depending on the signedness of an input.
SIGNED_OPTAB and UNSIGNED_OPTAB are the optabs for signed and
unsigned inputs respectively, both without the trailing "_optab".
SELECTOR says which type in the tree_pair determines the signedness.

DEF_INTERNAL_FLT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition,
the function implements the computational part of a built-in math
function BUILT_IN_<NAME>{F,,L}.  Unlike some built-in functions,
these internal functions never set errno.

DEF_INTERNAL_INT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition
says that the function extends the C-level BUILT_IN_<NAME>{,L,LL,IMAX}
group of functions to any integral mode (including vector modes).

DEF_INTERNAL_INT_EXT_FN is like DEF_INTERNAL_INT_FN, except that it
has expand_##NAME defined in internal-fn.cc to override the
DEF_INTERNAL_INT_FN expansion behavior.

DEF_INTERNAL_WIDENING_OPTAB_FN is a wrapper that defines five internal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN:
- one that describes a widening operation with the same number of elements
in the output and input vectors,
- two that describe a pair of high-low widening operations where the output
vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the top half and
bottom half, these have the suffixes _HI and _LO,
- and two that describe a pair of even-odd widening operations where the
output vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the even and odd
elements, these have the suffixes _EVEN and _ODD.
These five internal functions will require two optabs each, a SIGNED_OPTAB
and an UNSIGNED_OTPAB.

DEF_INTERNAL_COND_FN is a wrapper that defines 2 internal functions with
DEF_INTERNAL_OPTAB_FN:
- One is COND_* operations that are predicated by mask only. Such operations
  make sense for both vectors and scalars.
- The other is COND_LEN_* operations that are predicated by mask and len
  both. Such operations only make sense for vectors.

DEF_INTERNAL_SIGNED_COND_FN is like DEF_INTERNAL_COND_FN but defines intenal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN.

Each entry must have a corresponding expander of the form:

  void expand_NAME (gimple_call stmt)

where STMT is the statement that performs the call.  These are generated
automatically for optab functions and call out to a function or macro
called expand_<TYPE>_optab_fn.

â—† DEF_INTERNAL_OPTAB_FN [2/3]

#define DEF_INTERNAL_OPTAB_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)
Internal functions.
   Copyright (C) 2011-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file specifies a list of internal "functions".  These functions
differ from built-in functions in that they have no linkage and cannot
be called directly by the user.  They represent operations that are only
synthesised by GCC itself.

Internal functions are used instead of tree codes if the operation
and its operands are more naturally represented as a GIMPLE_CALL
than a GIMPLE_ASSIGN.

Each entry in this file has one of the forms:

  DEF_INTERNAL_FN (NAME, FLAGS, FNSPEC)
  DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SIGNED_OPTAB,
                           UNSIGNED_OPTAB, TYPE)
  DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_FLT_FLOATN_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_EXT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_WIDENING_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB,
                             TYPE)

where NAME is the name of the function, FLAGS is a set of
ECF_* flags and FNSPEC is a string describing functions fnspec.

DEF_INTERNAL_OPTAB_FN defines an internal function that maps to a
direct optab.  The function should only be called with a given
set of types if the associated optab is available for the modes
of those types.  OPTAB says what optab to use (without the trailing
"_optab") and TYPE categorizes the optab based on its inputs and
outputs.  The possible types of optab are:

- mask_load: currently just maskload
- load_lanes: currently just vec_load_lanes
- mask_load_lanes: currently just vec_mask_load_lanes
- mask_len_load_lanes: currently just vec_mask_len_load_lanes
- gather_load: used for {mask_,mask_len_,}gather_load
- strided_load: currently just mask_len_strided_load
- len_load: currently just len_load
- mask_len_load: currently just mask_len_load

- mask_store: currently just maskstore
- store_lanes: currently just vec_store_lanes
- mask_store_lanes: currently just vec_mask_store_lanes
- mask_len_store_lanes: currently just vec_mask_len_store_lanes
- scatter_store: used for {mask_,mask_len_,}scatter_store
- strided_store: currently just mask_len_strided_store
- len_store: currently just len_store
- mask_len_store: currently just mask_len_store

- unary: a normal unary optab, such as vec_reverse_<mode>
- binary: a normal binary optab, such as vec_interleave_lo_<mode>
- ternary: a normal ternary optab, such as fma<mode>4

- unary_convert: a single-input conversion optab, such as
  lround<srcmode><dstmode>2.

- cond_binary: a conditional binary optab, such as cond_add<mode>
- cond_unary: a conditional unary optab, such as cond_neg<mode>
- cond_ternary: a conditional ternary optab, such as cond_fma_rev<mode>

- fold_left: for scalar = FN (scalar, vector), keyed off the vector mode
- check_ptrs: used for check_{raw,war}_ptrs

- cond_len_unary: a conditional unary optab, such as cond_len_neg<mode>
- cond_len_binary: a conditional binary optab, such as cond_len_add<mode>
- cond_len_ternary: a conditional ternary optab, such as
cond_len_fma_rev<mode>

DEF_INTERNAL_SIGNED_OPTAB_FN defines an internal function that
maps to one of two optabs, depending on the signedness of an input.
SIGNED_OPTAB and UNSIGNED_OPTAB are the optabs for signed and
unsigned inputs respectively, both without the trailing "_optab".
SELECTOR says which type in the tree_pair determines the signedness.

DEF_INTERNAL_FLT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition,
the function implements the computational part of a built-in math
function BUILT_IN_<NAME>{F,,L}.  Unlike some built-in functions,
these internal functions never set errno.

DEF_INTERNAL_INT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition
says that the function extends the C-level BUILT_IN_<NAME>{,L,LL,IMAX}
group of functions to any integral mode (including vector modes).

DEF_INTERNAL_INT_EXT_FN is like DEF_INTERNAL_INT_FN, except that it
has expand_##NAME defined in internal-fn.cc to override the
DEF_INTERNAL_INT_FN expansion behavior.

DEF_INTERNAL_WIDENING_OPTAB_FN is a wrapper that defines five internal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN:
- one that describes a widening operation with the same number of elements
in the output and input vectors,
- two that describe a pair of high-low widening operations where the output
vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the top half and
bottom half, these have the suffixes _HI and _LO,
- and two that describe a pair of even-odd widening operations where the
output vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the even and odd
elements, these have the suffixes _EVEN and _ODD.
These five internal functions will require two optabs each, a SIGNED_OPTAB
and an UNSIGNED_OTPAB.

DEF_INTERNAL_COND_FN is a wrapper that defines 2 internal functions with
DEF_INTERNAL_OPTAB_FN:
- One is COND_* operations that are predicated by mask only. Such operations
  make sense for both vectors and scalars.
- The other is COND_LEN_* operations that are predicated by mask and len
  both. Such operations only make sense for vectors.

DEF_INTERNAL_SIGNED_COND_FN is like DEF_INTERNAL_COND_FN but defines intenal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN.

Each entry must have a corresponding expander of the form:

  void expand_NAME (gimple_call stmt)

where STMT is the statement that performs the call.  These are generated
automatically for optab functions and call out to a function or macro
called expand_<TYPE>_optab_fn.

â—† DEF_INTERNAL_OPTAB_FN [3/3]

#define DEF_INTERNAL_OPTAB_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)
Internal functions.
   Copyright (C) 2011-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file specifies a list of internal "functions".  These functions
differ from built-in functions in that they have no linkage and cannot
be called directly by the user.  They represent operations that are only
synthesised by GCC itself.

Internal functions are used instead of tree codes if the operation
and its operands are more naturally represented as a GIMPLE_CALL
than a GIMPLE_ASSIGN.

Each entry in this file has one of the forms:

  DEF_INTERNAL_FN (NAME, FLAGS, FNSPEC)
  DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SIGNED_OPTAB,
                           UNSIGNED_OPTAB, TYPE)
  DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_FLT_FLOATN_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_EXT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_WIDENING_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB,
                             TYPE)

where NAME is the name of the function, FLAGS is a set of
ECF_* flags and FNSPEC is a string describing functions fnspec.

DEF_INTERNAL_OPTAB_FN defines an internal function that maps to a
direct optab.  The function should only be called with a given
set of types if the associated optab is available for the modes
of those types.  OPTAB says what optab to use (without the trailing
"_optab") and TYPE categorizes the optab based on its inputs and
outputs.  The possible types of optab are:

- mask_load: currently just maskload
- load_lanes: currently just vec_load_lanes
- mask_load_lanes: currently just vec_mask_load_lanes
- mask_len_load_lanes: currently just vec_mask_len_load_lanes
- gather_load: used for {mask_,mask_len_,}gather_load
- strided_load: currently just mask_len_strided_load
- len_load: currently just len_load
- mask_len_load: currently just mask_len_load

- mask_store: currently just maskstore
- store_lanes: currently just vec_store_lanes
- mask_store_lanes: currently just vec_mask_store_lanes
- mask_len_store_lanes: currently just vec_mask_len_store_lanes
- scatter_store: used for {mask_,mask_len_,}scatter_store
- strided_store: currently just mask_len_strided_store
- len_store: currently just len_store
- mask_len_store: currently just mask_len_store

- unary: a normal unary optab, such as vec_reverse_<mode>
- binary: a normal binary optab, such as vec_interleave_lo_<mode>
- ternary: a normal ternary optab, such as fma<mode>4

- unary_convert: a single-input conversion optab, such as
  lround<srcmode><dstmode>2.

- cond_binary: a conditional binary optab, such as cond_add<mode>
- cond_unary: a conditional unary optab, such as cond_neg<mode>
- cond_ternary: a conditional ternary optab, such as cond_fma_rev<mode>

- fold_left: for scalar = FN (scalar, vector), keyed off the vector mode
- check_ptrs: used for check_{raw,war}_ptrs

- cond_len_unary: a conditional unary optab, such as cond_len_neg<mode>
- cond_len_binary: a conditional binary optab, such as cond_len_add<mode>
- cond_len_ternary: a conditional ternary optab, such as
cond_len_fma_rev<mode>

DEF_INTERNAL_SIGNED_OPTAB_FN defines an internal function that
maps to one of two optabs, depending on the signedness of an input.
SIGNED_OPTAB and UNSIGNED_OPTAB are the optabs for signed and
unsigned inputs respectively, both without the trailing "_optab".
SELECTOR says which type in the tree_pair determines the signedness.

DEF_INTERNAL_FLT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition,
the function implements the computational part of a built-in math
function BUILT_IN_<NAME>{F,,L}.  Unlike some built-in functions,
these internal functions never set errno.

DEF_INTERNAL_INT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition
says that the function extends the C-level BUILT_IN_<NAME>{,L,LL,IMAX}
group of functions to any integral mode (including vector modes).

DEF_INTERNAL_INT_EXT_FN is like DEF_INTERNAL_INT_FN, except that it
has expand_##NAME defined in internal-fn.cc to override the
DEF_INTERNAL_INT_FN expansion behavior.

DEF_INTERNAL_WIDENING_OPTAB_FN is a wrapper that defines five internal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN:
- one that describes a widening operation with the same number of elements
in the output and input vectors,
- two that describe a pair of high-low widening operations where the output
vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the top half and
bottom half, these have the suffixes _HI and _LO,
- and two that describe a pair of even-odd widening operations where the
output vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the even and odd
elements, these have the suffixes _EVEN and _ODD.
These five internal functions will require two optabs each, a SIGNED_OPTAB
and an UNSIGNED_OTPAB.

DEF_INTERNAL_COND_FN is a wrapper that defines 2 internal functions with
DEF_INTERNAL_OPTAB_FN:
- One is COND_* operations that are predicated by mask only. Such operations
  make sense for both vectors and scalars.
- The other is COND_LEN_* operations that are predicated by mask and len
  both. Such operations only make sense for vectors.

DEF_INTERNAL_SIGNED_COND_FN is like DEF_INTERNAL_COND_FN but defines intenal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN.

Each entry must have a corresponding expander of the form:

  void expand_NAME (gimple_call stmt)

where STMT is the statement that performs the call.  These are generated
automatically for optab functions and call out to a function or macro
called expand_<TYPE>_optab_fn.

â—† DEF_INTERNAL_SIGNED_COND_FN [1/3]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

â—† DEF_INTERNAL_SIGNED_COND_FN [2/3]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

â—† DEF_INTERNAL_SIGNED_COND_FN [3/3]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

â—† DEF_INTERNAL_SIGNED_OPTAB_FN [1/3]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

â—† DEF_INTERNAL_SIGNED_OPTAB_FN [2/3]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

â—† DEF_INTERNAL_SIGNED_OPTAB_FN [3/3]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

â—† DEF_INTERNAL_WIDENING_OPTAB_FN [1/3]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SOPTAB,
UOPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _LO, FLAGS, SELECTOR, SOPTAB##_lo, UOPTAB##_lo, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _HI, FLAGS, SELECTOR, SOPTAB##_hi, UOPTAB##_hi, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _EVEN, FLAGS, SELECTOR, SOPTAB##_even, UOPTAB##_even, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _ODD, FLAGS, SELECTOR, SOPTAB##_odd, UOPTAB##_odd, TYPE)

â—† DEF_INTERNAL_WIDENING_OPTAB_FN [2/3]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SOPTAB,
UOPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _LO, FLAGS, SELECTOR, SOPTAB##_lo, UOPTAB##_lo, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _HI, FLAGS, SELECTOR, SOPTAB##_hi, UOPTAB##_hi, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _EVEN, FLAGS, SELECTOR, SOPTAB##_even, UOPTAB##_even, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _ODD, FLAGS, SELECTOR, SOPTAB##_odd, UOPTAB##_odd, TYPE)

â—† DEF_INTERNAL_WIDENING_OPTAB_FN [3/3]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SOPTAB,
UOPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _LO, FLAGS, SELECTOR, SOPTAB##_lo, UOPTAB##_lo, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _HI, FLAGS, SELECTOR, SOPTAB##_hi, UOPTAB##_hi, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _EVEN, FLAGS, SELECTOR, SOPTAB##_even, UOPTAB##_even, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _ODD, FLAGS, SELECTOR, SOPTAB##_odd, UOPTAB##_odd, TYPE)

â—† DEF_LIB_BUILTIN [1/3]

#define DEF_LIB_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, false, ATTRS, true, true)
A library builtin (like __builtin_strchr) is a builtin equivalent
of an ANSI/ISO standard library function.  In addition to the
`__builtin' version, we will create an ordinary version (e.g,
`strchr') as well.  If we cannot compute the answer using the
builtin function, we will fall back to the standard library
version.

â—† DEF_LIB_BUILTIN [2/3]

#define DEF_LIB_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, false, ATTRS, true, true)
A library builtin (like __builtin_strchr) is a builtin equivalent
of an ANSI/ISO standard library function.  In addition to the
`__builtin' version, we will create an ordinary version (e.g,
`strchr') as well.  If we cannot compute the answer using the
builtin function, we will fall back to the standard library
version.

â—† DEF_LIB_BUILTIN [3/3]

#define DEF_LIB_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, false, ATTRS, true, true)
A library builtin (like __builtin_strchr) is a builtin equivalent
of an ANSI/ISO standard library function.  In addition to the
`__builtin' version, we will create an ordinary version (e.g,
`strchr') as well.  If we cannot compute the answer using the
builtin function, we will fall back to the standard library
version.

â—† DEF_SANITIZER_BUILTIN [1/3]

#define DEF_SANITIZER_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, true, ATTRS, true, \
(flag_sanitize & (SANITIZE_ADDRESS | SANITIZE_THREAD \
| SANITIZE_HWADDRESS \
| SANITIZE_UNDEFINED \
| SANITIZE_UNDEFINED_NONDEFAULT) \
|| flag_sanitize_coverage))
Builtin used by the implementation of libsanitizer. These
functions are mapped to the actual implementation of the
libtsan library.

â—† DEF_SANITIZER_BUILTIN [2/3]

#define DEF_SANITIZER_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, true, ATTRS, true, \
(flag_sanitize & (SANITIZE_ADDRESS | SANITIZE_THREAD \
| SANITIZE_HWADDRESS \
| SANITIZE_UNDEFINED \
| SANITIZE_UNDEFINED_NONDEFAULT) \
|| flag_sanitize_coverage))
Builtin used by the implementation of libsanitizer. These
functions are mapped to the actual implementation of the
libtsan library.

â—† DEF_SANITIZER_BUILTIN [3/3]

#define DEF_SANITIZER_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
true, true, true, ATTRS, true, \
(flag_sanitize & (SANITIZE_ADDRESS | SANITIZE_THREAD \
| SANITIZE_HWADDRESS \
| SANITIZE_UNDEFINED \
| SANITIZE_UNDEFINED_NONDEFAULT) \
|| flag_sanitize_coverage))
Builtin used by the implementation of libsanitizer. These
functions are mapped to the actual implementation of the
libtsan library.

â—† DEF_SYNC_BUILTIN [1/3]

#define DEF_SYNC_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
false, false, false, ATTRS, true, true)
Like DEF_GCC_BUILTIN, except we don't prepend "__builtin_".

â—† DEF_SYNC_BUILTIN [2/3]

#define DEF_SYNC_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
false, false, false, ATTRS, true, true)
Like DEF_GCC_BUILTIN, except we don't prepend "__builtin_".

â—† DEF_SYNC_BUILTIN [3/3]

#define DEF_SYNC_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
false, false, false, ATTRS, true, true)
Like DEF_GCC_BUILTIN, except we don't prepend "__builtin_".

â—† DEF_TM_BUILTIN [1/3]

#define DEF_TM_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
false, true, true, ATTRS, false, flag_tm)
Builtin used by the implementation of GNU TM.  These
functions are mapped to the actual implementation of the STM library.

â—† DEF_TM_BUILTIN [2/3]

#define DEF_TM_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
false, true, true, ATTRS, false, flag_tm)
Builtin used by the implementation of GNU TM.  These
functions are mapped to the actual implementation of the STM library.

â—† DEF_TM_BUILTIN [3/3]

#define DEF_TM_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
false, true, true, ATTRS, false, flag_tm)
Builtin used by the implementation of GNU TM.  These
functions are mapped to the actual implementation of the STM library.

â—† DEFTREECODE [1/2]

#define DEFTREECODE ( SYM,
STRING,
TYPE,
NARGS )
Value:
SYM,
Pull in tree codes and builtin function codes from their
definition files.

â—† DEFTREECODE [2/2]

#define DEFTREECODE ( SYM,
STRING,
TYPE,
NARGS )
Value:
add_operator (SYM, # SYM, # TYPE, NARGS);
add_operator
static void add_operator(enum tree_code code, const char *id, const char *tcc, unsigned nargs)
Definition genmatch.cc:1335
Pull in tree codes and builtin function codes from their
definition files.

â—† DIAG_ARGMAX

#define DIAG_ARGMAX   30

Referenced by diag_vfprintf().

â—† diag_integer_with_precision

#define diag_integer_with_precision ( FS,
ARG,
PREC,
T,
F )

Referenced by diag_vfprintf().

â—† END_OF_BASE_TREE_CODES

#define END_OF_BASE_TREE_CODES

â—† FABS_TYPE [1/3]

#define FABS_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† FABS_TYPE [2/3]

#define FABS_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† FABS_TYPE [3/3]

#define FABS_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† FDIM_TYPE [1/3]

#define FDIM_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† FDIM_TYPE [2/3]

#define FDIM_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† FDIM_TYPE [3/3]

#define FDIM_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† FLOOR_TYPE [1/3]

#define FLOOR_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† FLOOR_TYPE [2/3]

#define FLOOR_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† FLOOR_TYPE [3/3]

#define FLOOR_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† FMA_TYPE [1/3]

#define FMA_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F##_##F

â—† FMA_TYPE [2/3]

#define FMA_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F##_##F

â—† FMA_TYPE [3/3]

#define FMA_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F##_##F

â—† FMAX_TYPE [1/3]

#define FMAX_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† FMAX_TYPE [2/3]

#define FMAX_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† FMAX_TYPE [3/3]

#define FMAX_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† FMIN_TYPE [1/3]

#define FMIN_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† FMIN_TYPE [2/3]

#define FMIN_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† FMIN_TYPE [3/3]

#define FMIN_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† FREXP_TYPE [1/3]

#define FREXP_TYPE ( F)
Value:
BT_FN_##F##_##F##_INTPTR

â—† FREXP_TYPE [2/3]

#define FREXP_TYPE ( F)
Value:
BT_FN_##F##_##F##_INTPTR

â—† FREXP_TYPE [3/3]

#define FREXP_TYPE ( F)
Value:
BT_FN_##F##_##F##_INTPTR

â—† HUGE_VAL_TYPE [1/3]

#define HUGE_VAL_TYPE ( F)
Value:
BT_FN_##F

â—† HUGE_VAL_TYPE [2/3]

#define HUGE_VAL_TYPE ( F)
Value:
BT_FN_##F

â—† HUGE_VAL_TYPE [3/3]

#define HUGE_VAL_TYPE ( F)
Value:
BT_FN_##F

â—† HYPOT_TYPE [1/3]

#define HYPOT_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† HYPOT_TYPE [2/3]

#define HYPOT_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† HYPOT_TYPE [3/3]

#define HYPOT_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† ILOGB_TYPE [1/3]

#define ILOGB_TYPE ( F)
Value:
BT_FN_INT_##F

â—† ILOGB_TYPE [2/3]

#define ILOGB_TYPE ( F)
Value:
BT_FN_INT_##F

â—† ILOGB_TYPE [3/3]

#define ILOGB_TYPE ( F)
Value:
BT_FN_INT_##F

â—† INF_TYPE [1/3]

#define INF_TYPE ( F)
Value:
BT_FN_##F

â—† INF_TYPE [2/3]

#define INF_TYPE ( F)
Value:
BT_FN_##F

â—† INF_TYPE [3/3]

#define INF_TYPE ( F)
Value:
BT_FN_##F

â—† LDEXP_TYPE [1/3]

#define LDEXP_TYPE ( F)
Value:
BT_FN_##F##_##F##_INT

â—† LDEXP_TYPE [2/3]

#define LDEXP_TYPE ( F)
Value:
BT_FN_##F##_##F##_INT

â—† LDEXP_TYPE [3/3]

#define LDEXP_TYPE ( F)
Value:
BT_FN_##F##_##F##_INT

â—† LGAMMA_TYPE [1/3]

#define LGAMMA_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† LGAMMA_TYPE [2/3]

#define LGAMMA_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† LGAMMA_TYPE [3/3]

#define LGAMMA_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† LLRINT_TYPE [1/3]

#define LLRINT_TYPE ( F)
Value:
BT_FN_LONGLONG_##F

â—† LLRINT_TYPE [2/3]

#define LLRINT_TYPE ( F)
Value:
BT_FN_LONGLONG_##F

â—† LLRINT_TYPE [3/3]

#define LLRINT_TYPE ( F)
Value:
BT_FN_LONGLONG_##F

â—† LOG10_TYPE [1/3]

#define LOG10_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† LOG10_TYPE [2/3]

#define LOG10_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† LOG10_TYPE [3/3]

#define LOG10_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† LRINT_TYPE [1/3]

#define LRINT_TYPE ( F)
Value:
BT_FN_LONG_##F

â—† LRINT_TYPE [2/3]

#define LRINT_TYPE ( F)
Value:
BT_FN_LONG_##F

â—† LRINT_TYPE [3/3]

#define LRINT_TYPE ( F)
Value:
BT_FN_LONG_##F

â—† MODF_TYPE [1/3]

#define MODF_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F##PTR

â—† MODF_TYPE [2/3]

#define MODF_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F##PTR

â—† MODF_TYPE [3/3]

#define MODF_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F##PTR

â—† NAN_TYPE [1/3]

#define NAN_TYPE ( F)
Value:
BT_FN_##F##_CONST_STRING

â—† NAN_TYPE [2/3]

#define NAN_TYPE ( F)
Value:
BT_FN_##F##_CONST_STRING

â—† NAN_TYPE [3/3]

#define NAN_TYPE ( F)
Value:
BT_FN_##F##_CONST_STRING

â—† NEARBYINT_TYPE [1/3]

#define NEARBYINT_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† NEARBYINT_TYPE [2/3]

#define NEARBYINT_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† NEARBYINT_TYPE [3/3]

#define NEARBYINT_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† NEXTAFTER_TYPE [1/3]

#define NEXTAFTER_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† NEXTAFTER_TYPE [2/3]

#define NEXTAFTER_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† NEXTAFTER_TYPE [3/3]

#define NEXTAFTER_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† REMQUO_TYPE [1/3]

#define REMQUO_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F##_INTPTR

â—† REMQUO_TYPE [2/3]

#define REMQUO_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F##_INTPTR

â—† REMQUO_TYPE [3/3]

#define REMQUO_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F##_INTPTR

â—† RINT_TYPE [1/3]

#define RINT_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† RINT_TYPE [2/3]

#define RINT_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† RINT_TYPE [3/3]

#define RINT_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† ROUND_TYPE [1/3]

#define ROUND_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† ROUND_TYPE [2/3]

#define ROUND_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† ROUND_TYPE [3/3]

#define ROUND_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† ROUNDEVEN_TYPE [1/3]

#define ROUNDEVEN_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† ROUNDEVEN_TYPE [2/3]

#define ROUNDEVEN_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† ROUNDEVEN_TYPE [3/3]

#define ROUNDEVEN_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† SCALBLN_TYPE [1/3]

#define SCALBLN_TYPE ( F)
Value:
BT_FN_##F##_##F##_LONG

â—† SCALBLN_TYPE [2/3]

#define SCALBLN_TYPE ( F)
Value:
BT_FN_##F##_##F##_LONG

â—† SCALBLN_TYPE [3/3]

#define SCALBLN_TYPE ( F)
Value:
BT_FN_##F##_##F##_LONG

â—† SCALBN_TYPE [1/3]

#define SCALBN_TYPE ( F)
Value:
BT_FN_##F##_##F##_INT

â—† SCALBN_TYPE [2/3]

#define SCALBN_TYPE ( F)
Value:
BT_FN_##F##_##F##_INT

â—† SCALBN_TYPE [3/3]

#define SCALBN_TYPE ( F)
Value:
BT_FN_##F##_##F##_INT

â—† SINH_TYPE [1/3]

#define SINH_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† SINH_TYPE [2/3]

#define SINH_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† SINH_TYPE [3/3]

#define SINH_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† SIZED_BASED_CHUNKS

#define SIZED_BASED_CHUNKS   1 
Find the file to write into next.  We try to evenly distribute the contents
over the different files.

â—† SQRT_TYPE [1/3]

#define SQRT_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† SQRT_TYPE [2/3]

#define SQRT_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† SQRT_TYPE [3/3]

#define SQRT_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† TRIG2_TYPE [1/3]

#define TRIG2_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† TRIG2_TYPE [2/3]

#define TRIG2_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† TRIG2_TYPE [3/3]

#define TRIG2_TYPE ( F)
Value:
BT_FN_##F##_##F##_##F

â—† TRIG_TYPE [1/3]

#define TRIG_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† TRIG_TYPE [2/3]

#define TRIG_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† TRIG_TYPE [3/3]

#define TRIG_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† TRUNC_TYPE [1/3]

#define TRUNC_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† TRUNC_TYPE [2/3]

#define TRUNC_TYPE ( F)
Value:
BT_FN_##F##_##F

â—† TRUNC_TYPE [3/3]

#define TRUNC_TYPE ( F)
Value:
BT_FN_##F##_##F

Typedef Documentation

â—† cid_map_t

typedef hash_map<nofree_string_hash, unsigned> cid_map_t

â—† sinfo_map_t

typedef ordered_hash_map<void * , sinfo *, sinfo_hashmap_traits> sinfo_map_t

Enumeration Type Documentation

â—† built_in_function

enum built_in_function
Enumerator
DEF_BUILTIN 
Category: string/memory builtins.   
Category: stdio builtins.   
Category: ctype builtins.   
Category: wctype builtins.   
Category: integer overflow checking builtins.   
Clang compatibility.   
Category: miscellaneous builtins.   
[trans-mem]: Adjust BUILT_IN_TM_CALLOC if BUILT_IN_CALLOC is changed.   
[trans-mem]: Adjust BUILT_IN_TM_FREE if BUILT_IN_FREE is changed.   
[trans-mem]: Adjust BUILT_IN_TM_MALLOC if BUILT_IN_MALLOC is changed.   
Implementing nested functions.   
Implementing __builtin_setjmp.   
Implementing variable sized local variables.   
An internal version of memcmp, used when the result is only tested for
equality with zero.   
An internal version of strcmp/strncmp, used when the result is only
tested for equality with zero.   
Object size checking builtins.   
Profiling hooks.

â—† combined_fn

enum combined_fn
Enumerator
DEF_BUILTIN 
Category: string/memory builtins.   
Category: stdio builtins.   
Category: ctype builtins.   
Category: wctype builtins.   
Category: integer overflow checking builtins.   
Clang compatibility.   
Category: miscellaneous builtins.   
[trans-mem]: Adjust BUILT_IN_TM_CALLOC if BUILT_IN_CALLOC is changed.   
[trans-mem]: Adjust BUILT_IN_TM_FREE if BUILT_IN_FREE is changed.   
[trans-mem]: Adjust BUILT_IN_TM_MALLOC if BUILT_IN_MALLOC is changed.   
Implementing nested functions.   
Implementing __builtin_setjmp.   
Implementing variable sized local variables.   
An internal version of memcmp, used when the result is only tested for
equality with zero.   
An internal version of strcmp/strncmp, used when the result is only
tested for equality with zero.   
Object size checking builtins.   
Profiling hooks.
DEF_BUILTIN 
Category: string/memory builtins.   
Category: stdio builtins.   
Category: ctype builtins.   
Category: wctype builtins.   
Category: integer overflow checking builtins.   
Clang compatibility.   
Category: miscellaneous builtins.   
[trans-mem]: Adjust BUILT_IN_TM_CALLOC if BUILT_IN_CALLOC is changed.   
[trans-mem]: Adjust BUILT_IN_TM_FREE if BUILT_IN_FREE is changed.   
[trans-mem]: Adjust BUILT_IN_TM_MALLOC if BUILT_IN_MALLOC is changed.   
Implementing nested functions.   
Implementing __builtin_setjmp.   
Implementing variable sized local variables.   
An internal version of memcmp, used when the result is only tested for
equality with zero.   
An internal version of strcmp/strncmp, used when the result is only
tested for equality with zero.   
Object size checking builtins.   
Profiling hooks.

â—† internal_fn

enum internal_fn
Enumerator
DEF_INTERNAL_OPTAB_FN 
DEF_INTERNAL_OPTAB_FN 

â—† tree_code

enum tree_code
Enumerator
DEFTREECODE 
This file contains the definitions and documentation for the
   tree codes used in GCC.
   Copyright (C) 1987-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
For tcc_references, tcc_expression, tcc_comparison, tcc_unary,
tcc_binary, and tcc_statement nodes, which use struct tree_exp, the
4th element is the number of argument slots to allocate.  This
determines the size of the tree node object.  Other nodes use
different structures, and the size is determined by the tree_union
member structure; the 4th element should be zero.  Languages that
define language-specific tcc_exceptional or tcc_constant codes must
define the tree_size langhook to say how big they are.

These tree codes have been sorted so that the macros in tree.h that
check for various tree codes are optimized into range checks.  This
gives a measurable performance improvement.  When adding a new
code, consider its placement in relation to the other codes.   
Any erroneous construct is parsed into a node of this type.
This type of node is accepted without complaint in all contexts
by later parsing activities, to avoid multiple error messages
for one error.
No fields in these nodes are used except the TREE_CODE.   
Used to represent a name (such as, in the DECL_NAME of a decl node).
Internally it looks like a STRING_CST node.
There is only one IDENTIFIER_NODE ever made for any particular name.
Use `get_identifier' to get it (or create it, the first time).   
Has the TREE_VALUE and TREE_PURPOSE fields.   
These nodes are made into lists by chaining through the
TREE_CHAIN field.  The elements of the list live in the
TREE_VALUE fields, while TREE_PURPOSE fields are occasionally
used as well to get the effect of Lisp association lists.   
These nodes contain an array of tree nodes.   
A symbol binding block.  These are arranged in a tree,
where the BLOCK_SUBBLOCKS field contains a chain of subblocks
chained through the BLOCK_CHAIN field.
BLOCK_SUPERCONTEXT points to the parent block.
  For a block which represents the outermost scope of a function, it
  points to the FUNCTION_DECL node.
BLOCK_VARS points to a chain of decl nodes.
BLOCK_CHAIN points to the next BLOCK at the same level.
BLOCK_ABSTRACT_ORIGIN points to the original (abstract) tree node which
this block is an instance of, or else is NULL to indicate that this
block is not an instance of anything else.  When non-NULL, the value
could either point to another BLOCK node or it could point to a
FUNCTION_DECL node (e.g. in the case of a block representing the
outermost scope of a particular inlining of a function).
TREE_ASM_WRITTEN is nonzero if the block was actually referenced
in the generated assembly.   
Each data type is represented by a tree node whose code is one of
the following:   
Each node that represents a data type has a component TYPE_SIZE
 that evaluates either to a tree that is a (potentially non-constant)
 expression representing the type size in bits, or to a null pointer
 when the size of the type is unknown (for example, for incomplete
 types such as arrays of unspecified bound).
 The TYPE_MODE contains the machine mode for values of this type.
 The TYPE_POINTER_TO field contains a type for a pointer to this type,
   or zero if no such has been created yet.
 The TYPE_NEXT_VARIANT field is used to chain together types
   that are variants made by type modifiers such as "const" and "volatile".
 The TYPE_MAIN_VARIANT field, in any member of such a chain,
   points to the start of the chain.
 The TYPE_NAME field contains info on the name used in the program
   for this type (for GDB symbol table output).  It is either a
   TYPE_DECL node, for types that are typedefs, or an IDENTIFIER_NODE
   in the case of structs, unions or enums that are known with a tag,
   or zero for types that have no special name.
 The TYPE_CONTEXT for any sort of type which could have a name or
  which could have named members (e.g. tagged types in C/C++) will
  point to the node which represents the scope of the given type, or
  will be NULL_TREE if the type has "file scope".  For most types, this
  will point to a BLOCK node or a FUNCTION_DECL node, but it could also
  point to a FUNCTION_TYPE node (for types whose scope is limited to the
  formal parameter list of some function type specification) or it
  could point to a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE node
  (for C++ "member" types).
  For non-tagged-types, TYPE_CONTEXT need not be set to anything in
  particular, since any type which is of some type category  (e.g.
  an array type or a function type) which cannot either have a name
  itself or have named members doesn't really have a "scope" per se.
The TYPE_STUB_DECL field is used as a forward-references to names for
  ENUMERAL_TYPE, RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE nodes;
  see below.   
The ordering of the following codes is optimized for the checking
macros in tree.h.  Changing the order will degrade the speed of the
compiler.  OFFSET_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, INTEGER_TYPE,
BITINT_TYPE, REAL_TYPE, POINTER_TYPE.   
An offset is a pointer relative to an object.
The TREE_TYPE field is the type of the object at the offset.
The TYPE_OFFSET_BASETYPE points to the node for the type of object
that the offset is relative to.   
C enums.  The type node looks just like an INTEGER_TYPE node.
The symbols for the values of the enum type are defined by
CONST_DECL nodes, but the type does not point to them;
however, the TYPE_VALUES is a list in which each element's TREE_PURPOSE
is a name and the TREE_VALUE is the value (an INTEGER_CST node).   
A forward reference `enum foo' when no enum named foo is defined yet
has zero (a null pointer) in its TYPE_SIZE.  The tag name is in
the TYPE_NAME field.  If the type is later defined, the normal
fields are filled in.
RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE forward refs are
treated similarly.   
Boolean type (true or false are the only values).  Looks like an
INTEGER_TYPE, but must be dealt with specially because TYPE_PRECISION
may be arbitrary despite the restricted set of valid values (in other
words, boolean types with TYPE_PRECISION > 1 exist in some languages).
Similarly, TYPE_UNSIGNED may be false for components of vector masks,
as well as for boolean types in languages other than C.   
Integer types in all languages, including char in C.
Also used for sub-ranges of other discrete types.
Has components TYPE_MIN_VALUE, TYPE_MAX_VALUE (expressions, inclusive)
and TYPE_PRECISION (number of bits used by this type).   
Bit-precise integer type.  These are similar to INTEGER_TYPEs, but
can have arbitrary user selected precisions and do or can have different
alignment, function argument and return value passing conventions.
Larger BITINT_TYPEs can have BLKmode TYPE_MODE and need to be lowered
by a special BITINT_TYPE lowering pass.   
C's float and double.  Different floating types are distinguished
by machine mode and by the TYPE_SIZE and the TYPE_PRECISION.   
The ordering of the following codes is optimized for the checking
macros in tree.h.  Changing the order will degrade the speed of the
compiler.  POINTER_TYPE, REFERENCE_TYPE.  Note that this range
overlaps the previous range of ordered types.   
All pointer-to-x types have code POINTER_TYPE.
The TREE_TYPE points to the node for the type pointed to.   
A reference is like a pointer except that it is coerced
automatically to the value it points to.  Used in C++.   
The C++ decltype(nullptr) type.   
_Fract and _Accum types in Embedded-C.  Different fixed-point types
are distinguished by machine mode and by the TYPE_SIZE and the
TYPE_PRECISION.   
The ordering of the following codes is optimized for the checking
macros in tree.h.  Changing the order will degrade the speed of the
compiler.  COMPLEX_TYPE, VECTOR_TYPE, ARRAY_TYPE.   
Complex number types.  The TREE_TYPE field is the data type
of the real and imaginary parts.  It must be of scalar
arithmetic type, not including pointer type.   
Vector types.  The TREE_TYPE field is the data type of the vector
elements.  The TYPE_PRECISION field is the number of subparts of
the vector.   
The ordering of the following codes is optimized for the checking
macros in tree.h.  Changing the order will degrade the speed of the
compiler.  ARRAY_TYPE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE.
Note that this range overlaps the previous range.   
Types of arrays.  Special fields:
  TREE_TYPE               Type of an array element.
  TYPE_DOMAIN             Type to index by.
                    Its range of values specifies the array length.
The field TYPE_POINTER_TO (TREE_TYPE (array_type)) is always nonzero
and holds the type to coerce a value of that array type to in C.
TYPE_STRING_FLAG indicates a string (in contrast to an array of chars)
in languages (such as Chill) that make a distinction.   
Array types in C  
Struct in C.   
Special fields:
TYPE_FIELDS  chain of FIELD_DECLs for the fields of the struct,
  VAR_DECLs, TYPE_DECLs and CONST_DECLs for record-scope variables,
  types and enumerators and FUNCTION_DECLs for methods associated
  with the type.   
See the comment above, before ENUMERAL_TYPE, for how
forward references to struct tags are handled in C.   
Union in C.  Like a struct, except that the offsets of the fields
will all be zero.   
See the comment above, before ENUMERAL_TYPE, for how
forward references to union tags are handled in C.   
Similar to UNION_TYPE, except that the expressions in DECL_QUALIFIER
in each FIELD_DECL determine what the union contains.  The first
field whose DECL_QUALIFIER expression is true is deemed to occupy
the union.   
The ordering of the following codes is optimized for the checking
macros in tree.h.  Changing the order will degrade the speed of the
compiler.  VOID_TYPE, FUNCTION_TYPE, METHOD_TYPE.   
The void type in C  
Type of functions.  Special fields:
TREE_TYPE                   type of value returned.
TYPE_ARG_TYPES      list of types of arguments expected.
     this list is made of TREE_LIST nodes.
     In this list TREE_PURPOSE can be used to indicate the default
     value of parameter (used by C++ frontend).
Types of "Procedures" in languages where they are different from functions
have code FUNCTION_TYPE also, but then TREE_TYPE is zero or void type.   
METHOD_TYPE is the type of a function which takes an extra first
argument for "self", which is not present in the declared argument list.
The TREE_TYPE is the return type of the method.  The TYPE_METHOD_BASETYPE
is the type of "self".  TYPE_ARG_TYPES is the real argument list, which
includes the hidden argument for "self".   
This is a language-specific kind of type.
Its meaning is defined by the language front end.
layout_type does not know how to lay this out,
so the front-end must do so manually.   
This is for types that will use MODE_OPAQUE in the back end.  They are meant
to be able to go in a register of some sort but are explicitly not to be
converted or operated on like INTEGER_TYPE.  They will have size and
alignment information only.   
Expressions  
First, the constants.   
Contents are in an array of HOST_WIDE_INTs.

We often access these constants both in their native precision and
in wider precisions (with the constant being implicitly extended
according to TYPE_SIGN).  In each case, the useful part of the array
may be as wide as the precision requires but may be shorter when all
of the upper bits are sign bits.  The length of the array when accessed
in the constant's native precision is given by TREE_INT_CST_NUNITS.
The length of the array when accessed in wider precisions is given
by TREE_INT_CST_EXT_NUNITS.  Each element can be obtained using
TREE_INT_CST_ELT.

INTEGER_CST nodes can be shared, and therefore should be considered
read only.  They should be copied before setting a flag such as
TREE_OVERFLOW.  If an INTEGER_CST has TREE_OVERFLOW already set,
it is known to be unique.  INTEGER_CST nodes are created for the
integral types, for pointer types and for vector and float types in
some circumstances.   
Contents are given by POLY_INT_CST_COEFF.   
Contents are in TREE_REAL_CST field.   
Contents are in TREE_FIXED_CST field.   
Contents are in TREE_REALPART and TREE_IMAGPART fields,
whose contents are other constant nodes.   
See generic.texi for details.   
Contents are TREE_STRING_LENGTH and the actual contents of the string.   
Contents are RAW_DATA_LENGTH and the actual content
of the raw data, plus RAW_DATA_OWNER for owner of the
data.  That can be either a STRING_CST, used e.g. when writing
PCH header, or another RAW_DATA_CST representing data owned by
libcpp and representing the original range (if possible)
or NULL_TREE if it is the RAW_DATA_OWNER of other RAW_DATA_CST
nodes (and represents data owned by libcpp).
TREE_TYPE is the type of each of the RAW_DATA_LENGTH elements.   
Declarations.  All references to names are represented as ..._DECL
nodes.  The decls in one binding context are chained through the
TREE_CHAIN field.  Each DECL has a DECL_NAME field which contains
an IDENTIFIER_NODE.  (Some decls, most often labels, may have zero
as the DECL_NAME).  DECL_CONTEXT points to the node representing
the context in which this declaration has its scope.  For
FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
QUAL_UNION_TYPE node that the field is a member of.  For VAR_DECL,
PARM_DECL, FUNCTION_DECL, LABEL_DECL, and CONST_DECL nodes, this
points to either the FUNCTION_DECL for the containing function, the
RECORD_TYPE or UNION_TYPE for the containing type, or NULL_TREE or
a TRANSLATION_UNIT_DECL if the given decl has "file scope".
DECL_ABSTRACT_ORIGIN, if non-NULL, points to the original (abstract)
 ..._DECL node of which this decl is an (inlined or template expanded)
 instance.
The TREE_TYPE field holds the data type of the object, when relevant.
 LABEL_DECLs have no data type.  For TYPE_DECL, the TREE_TYPE field
 contents are the type whose name is being declared.
The DECL_ALIGN, DECL_SIZE,
 and DECL_MODE fields exist in decl nodes just as in type nodes.
 They are unused in LABEL_DECL, TYPE_DECL and CONST_DECL nodes.

DECL_FIELD_BIT_OFFSET holds an integer number of bits offset for
the location.  DECL_VOFFSET holds an expression for a variable
offset; it is to be multiplied by DECL_VOFFSET_UNIT (an integer).
These fields are relevant only in FIELD_DECLs and PARM_DECLs.

DECL_INITIAL holds the value to initialize a variable to,
or the value of a constant.  For a function, it holds the body
(a node of type BLOCK representing the function's binding contour
and whose body contains the function's statements.)  For a LABEL_DECL
in C, it is a flag, nonzero if the label's definition has been seen.

PARM_DECLs use a special field:
DECL_ARG_TYPE is the type in which the argument is actually
 passed, which may be different from its type within the function.

FUNCTION_DECLs use four special fields:
DECL_ARGUMENTS holds a chain of PARM_DECL nodes for the arguments.
DECL_RESULT holds a RESULT_DECL node for the value of a function.
 The DECL_RTL field is 0 for a function that returns no value.
 (C functions returning void have zero here.)
 The TREE_TYPE field is the type in which the result is actually
 returned.  This is usually the same as the return type of the
 FUNCTION_DECL, but it may be a wider integer type because of
 promotion.
DECL_FUNCTION_CODE is a code number that is nonzero for
 built-in functions.  Its value is an enum built_in_function
 that says which built-in function it is.

DECL_SOURCE_FILE holds a filename string and DECL_SOURCE_LINE
holds a line number.  In some cases these can be the location of
a reference, if no definition has been seen.

DECL_ABSTRACT is nonzero if the decl represents an abstract instance
of a decl (i.e. one which is nested within an abstract instance of a
inline function.   
The ordering of the following codes is optimized for the checking
macros in tree.h.  Changing the order will degrade the speed of the
compiler.  FIELD_DECL, VAR_DECL, CONST_DECL, PARM_DECL,
TYPE_DECL.   
A "declaration" of a debug temporary.  It should only appear in
DEBUG stmts.   
A stmt that marks the beginning of a source statement.   
A namespace declaration.  Namespaces appear in DECL_CONTEXT of other
_DECLs, providing a hierarchy of names.   
A declaration import.
The C++ FE uses this to represent a using-directive; eg:
"using namespace foo".
But it could be used to represent any declaration import construct.
Whenever a declaration import appears in a lexical block, the BLOCK node
representing that lexical block in GIMPLE will contain an IMPORTED_DECL
node, linked via BLOCK_VARS accessor of the said BLOCK.
For a given NODE which code is IMPORTED_DECL,
IMPORTED_DECL_ASSOCIATED_DECL (NODE) accesses the imported declaration.   
A namelist declaration.
The Fortran FE uses this to represent a namelist statement, e.g.:
NAMELIST /namelist-group-name/ namelist-group-object-list.
Whenever a declaration import appears in a lexical block, the BLOCK node
representing that lexical block in GIMPLE will contain an NAMELIST_DECL
node, linked via BLOCK_VARS accessor of the said BLOCK.
For a given NODE which code is NAMELIST_DECL,
NAMELIST_DECL_ASSOCIATED_DECL (NODE) accesses the imported declaration.   
A translation unit.  This is not technically a declaration, since it
can't be looked up, but it's close enough.

Function Documentation

â—† add_function()

template<typename T>
void add_function ( T code,
const char * id )
static 
Add a built-in or internal function identifier to the hash.  ID is
the name of its CFN_* enumeration value.

References fatal(), id_base::hashval, operators, and T.

â—† add_operator()

void add_operator ( enum tree_code code,
const char * id,
const char * tcc,
unsigned nargs )
static 
Add a tree code identifier to the hash.

â—† add_predicate()

predicate_id * add_predicate ( const char * id)
static 
Add a predicate identifier to the hash.

References fatal(), id_base::hashval, and operators.

Referenced by parser::parse_pattern(), and parser::parse_predicates().

â—† binary_ok()

bool binary_ok ( operator_id * op)
static 
Return true if the binary operator OP is ok for delayed substitution
during for lowering.

References operator_id::code.

Referenced by lower_for().

â—† cartesian_product()

void cartesian_product ( const vec< vec< operand * > > & ops_vector,
vec< vec< operand * > > & result,
vec< operand * > & v,
unsigned n )
static 
AST lowering.   
Lowering of commutative operators.

Referenced by lower_cond().

â—† choose_output()

FILE * choose_output ( const vec< FILE * > & parts)
static

References NULL.

Referenced by decision_tree::gen(), main(), main(), and print_subroutine_group().

â—† cmp_operand()

bool cmp_operand ( operand * o1,
operand * o2 ) 
Compare two AST operands O1 and O2 and return true if they are equal.

References as_a(), id_base::FN, expr::is_generic, id_base::kind, expr::match_phi, operand::OP_EXPR, operand::OP_PREDICATE, expr::operation, expr::ops, predicate::p, and operand::type.

Referenced by decision_tree::cmp_node().

â—† commutate()

vec< operand * > commutate ( operand * op,
vec< vec< user_id * > > & for_vec )
static 
Lower OP to two operands in case it is marked as commutative.

Referenced by lower_commutative().

â—† commutative_op()

int commutative_op ( id_base * id,
bool compares_are_commutative = false )
static 
If ID has a pair of consecutive, commutative operands, return the
index of the first, otherwise return -1.

References commutative_ternary_tree_code(), commutative_tree_code(), and dyn_cast().

Referenced by dt_operand::gen_gimple_expr(), parser::parse_expr(), and vect_get_and_check_slp_defs().

â—† commutative_ternary_tree_code()

bool commutative_ternary_tree_code ( enum tree_code code) 
Return true if CODE represents a ternary tree code for which the
first two operands are commutative.  Otherwise return false.

Referenced by inchash::add_hashable_expr(), commutative_op(), commutative_ternary_op_p(), first_commutative_argument(), fold_stmt_1(), fold_ternary_loc(), gimple_simplify(), hashable_expr_equal_p(), and vn_nary_op_compute_hash().

â—† commutative_tree_code()

bool commutative_tree_code ( enum tree_code code) 
Return true if CODE represents a commutative tree code.  Otherwise
return false.

Referenced by inchash::add_hashable_expr(), analyze_agg_content_value(), check_scan_store(), pcom_worker::combinable_refs_p(), commutative_binary_op_p(), commutative_op(), cond_stmts_equal_p(), const_binop(), expand_omp_atomic_fetch_op(), first_commutative_argument(), fold_binary_loc(), fold_stmt_1(), gimple_simplify(), operand_compare::hash_operand(), hashable_expr_equal_p(), is_cond_scalar_reduction(), may_reassociate_p(), operand_compare::operand_equal_p(), parloops_is_simple_reduction(), recognise_vec_perm_simplify_seq(), reorder_operands(), vect_build_slp_tree_2(), vect_get_and_check_slp_defs(), vect_reassociating_reduction_p(), vectorizable_scan_store(), and vn_nary_op_compute_hash().

â—† compare_op()

bool compare_op ( operand * o1,
simplify * s1,
operand * o2,
simplify * s2 )
static 
Compare function for finding equivalent transforms.

References as_a(), compare_op(), if_expr::cond, if_expr::falseexpr, capture_info::force_no_side_effects, i, capture_info::info, operand::OP_IF, operand::OP_WITH, with_expr::subexpr, if_expr::trueexpr, operand::type, and with_expr::with.

Referenced by compare_op(), and sinfo_hashmap_traits::equal_keys().

â—† comparison_code_p()

bool comparison_code_p ( enum tree_code code) 
Return true if CODE is a comparison.

â—† contains_id()

bool contains_id ( operand * o,
user_id * id ) 
Return true if O refers to ID.

References contains_id(), dyn_cast(), i, expr::operation, and expr::ops.

Referenced by contains_id(), and lower_for().

â—† define_dump_logs()

void define_dump_logs ( bool gimple,
FILE * f )
static

References dbg_line_numbers, fprintf_indent(), and i.

Referenced by main().

â—† diag_vfprintf()

void diag_vfprintf ( FILE * f,
int err_no,
const char * msg,
va_list * ap )
static 
This is a simplified version of pretty-print.cc (pp_format)
which emits the diagnostics to F stream directly.
It needs to support everything that libcpp needs in its diagnostics,
but doesn't have to bother with colors, UTF-8 quoting, URL pretty
printing, etc.

References ap, DIAG_ARGMAX, diag_integer_with_precision, end(), fputc(), gcc_assert, gcc_unreachable, HOST_WIDE_INT_PRINT, HOST_WIDE_INT_PRINT_DEC, HOST_WIDE_INT_PRINT_HEX, HOST_WIDE_INT_PRINT_UNSIGNED, i, and msg.

Referenced by diagnostic_cb().

â—† diagnostic_cb()

bool diagnostic_cb ( cpp_reader * ,
enum cpp_diagnostic_level errtype,
enum cpp_warning_reason,
rich_location * richloc,
const char * msg,
va_list * ap )
static

References ap, diag_vfprintf(), errno, fopen, fputc(), i, line_table, map, and msg.

Referenced by fatal_at(), fatal_at(), main(), warning_at(), and warning_at().

â—† emit_logging_call()

void emit_logging_call ( FILE * f,
int indent,
class simplify * s,
operand * result,
bool gimple )
static 
Emit a logging call to the debug file to the file F, with the INDENT from
either the RESULT location or the S's match location if RESULT is null.

References fprintf_indent(), simplify::kind, operand::location, simplify::match, output_line_directive(), and simplify::SIMPLIFY.

Referenced by dt_simplify::gen_1().

â—† fatal_at() [1/2]

void fatal_at ( const cpp_token * tk,
const char * msg,
... )
static

References ap, diagnostic_cb(), line_table, msg, and NULL.

Referenced by generator::add_exp(), check_attr_test(), convert_syntax(), function_reader::create_edges(), parser::eat_ident(), parser::expect(), parser::finish_match_operand(), gen_automata_option(), gen_automaton(), gen_bypass(), gen_cpu_unit(), gen_excl_set(), gen_expand(), gen_insn(), gen_presence_absence_set(), gen_query_cpu_unit(), c_expr::gen_transform(), expr::gen_transform(), get_attr_value(), function_reader::handle_unknown_directive(), join_c_conditions(), make_canonical(), make_length_attrs(), function_reader::parse_block(), parser::parse_c_expr(), parser::parse_capture(), parser::parse_expr(), parser::parse_for(), parser::parse_if(), function_reader::parse_insn(), function_reader::parse_insn_chain(), parser::parse_op(), parser::parse_operation(), parser::parse_operator_list(), function_reader::parse_param(), parser::parse_pattern(), parser::parse_result(), parse_section(), parse_section_layout(), parser::parse_simplify(), parser::peek(), preprocess_compact_syntax(), process_define_register_constraint(), process_template(), queue_expand(), queue_split(), function_reader::read_rtx_operand_r(), parser::record_operlist(), capture_info::walk_c_expr(), and capture_info::walk_match().

â—† fatal_at() [2/2]

void fatal_at ( location_t loc,
const char * msg,
... )
static

References ap, diagnostic_cb(), line_table, msg, and NULL.

â—† fns_cmp()

int fns_cmp ( const void * p1,
const void * p2 )
static 
Compare 2 fns or generic_fns vector entries for vector sorting.
Same operation entries with different number of arguments should
be adjacent.

References as_a(), id_base::hashval, id_base::id, dt_operand::op, and expr::operation.

Referenced by dt_node::gen_kids().

â—† fp_decl()

void fp_decl ( FILE * f,
const char * format,
... )
static 
Start or continue emitting a declaration in fprintf-like manner,
printing both to F and global header_file, if non-null.

References ap, header_file, and vfprintf().

Referenced by decision_tree::gen(), and write_predicate().

â—† fp_decl_done()

void fp_decl_done ( FILE * f,
const char * trailer )
static 
Finish a declaration being emitted by fp_decl.

References header_file.

Referenced by decision_tree::gen(), and write_predicate().

â—† fprintf_indent()

void fprintf_indent ( FILE * f,
unsigned int indent,
const char * format,
... )
static 
Like fprintf, but print INDENT spaces at the beginning.

References ap, fputc(), and vfprintf().

Referenced by define_dump_logs(), emit_logging_call(), decision_tree::gen(), dt_operand::gen(), dt_simplify::gen(), dt_simplify::gen_1(), dt_operand::gen_generic_expr(), dt_operand::gen_gimple_expr(), dt_node::gen_kids_1(), dt_operand::gen_match_op(), dt_operand::gen_phi_on_cond(), dt_operand::gen_predicate(), c_expr::gen_transform(), capture::gen_transform(), expr::gen_transform(), and write_predicate().

â—† genmatch_diag_selftests()

void genmatch_diag_selftests ( void )
static

Referenced by main().

â—† get_operand_type()

const char * get_operand_type ( id_base * op,
unsigned pos,
const char * in_type,
const char * expr_type,
const char * other_oprnd_type )
static 
Get the type to be used for generating operand POS of OP from the
various sources.

References as_a(), id_base::id, is_a(), is_conversion(), NULL, and startswith().

Referenced by dt_simplify::gen_1(), and expr::gen_transform().

â—† get_operator()

id_base * get_operator ( const char * id,
bool allow_null = false ) 
Lookup the identifier ID.  Allow "null" if ALLOW_NULL.

References id_base::CODE, dyn_cast(), id_base::hashval, null_id, and operators.

Referenced by parser::parse_c_expr(), parser::parse_for(), parser::parse_op(), parser::parse_operation(), parser::parse_operator_list(), parser::parse_pattern(), and capture_info::walk_c_expr().

â—† ggc_free()

void ggc_free ( void * ) 
Free a block.  To be used when known for certain it's not reachable.

Referenced by add_var_loc_to_decl(), adjust_agg_replacement_values(), modref_base_node< T >::collapse(), modref_tree< tree >::collapse(), ctfc_delete_container(), ctfc_delete_strtab(), hash_table< Descriptor, Lazy, Allocator >::empty_slow(), hash_table< Descriptor, Lazy, Allocator >::expand(), fini_ssa_operands(), flow_loop_free(), vrange_ggc_alloc::free(), free_block(), free_cfg(), free_edge(), symbol_table::free_edge(), free_loc_descr(), free_node(), free_numbers_of_iterations_estimates(), free_param_decl_accesses(), free_simple_loop_desc(), general_init(), ggc_realloc(), gimple_seq_discard(), gimplify_assign(), gimplify_decl_expr(), gimplify_init_ctor_eval(), gimplify_target_expr(), init_expmed(), init_tree_optimization_optabs(), internal_get_tmp_var(), ipcp_free_transformation_sum(), loc_list_from_tree_1(), loop_optimizer_finalize(), lto_delete_in_decl_state(), lto_free_function_in_decl_state(), cgraph_edge::make_direct(), move_sese_region_to_fn(), native_encode_initializer(), phi_dynamic_object_size(), range_info_free(), release_function_body(), release_phi_node(), release_section_hash_entry(), symbol_table::release_symbol(), loop_exit_hasher::remove(), odr_name_hasher::remove(), varpool_node::remove(), ipcp_transformation::remove_argaggs_if(), ipa_vr::set_unknown(), jump_threader::simplify_control_stmt_condition(), ipa_vr::streamer_read(), tree_add_const_value_attribute(), type_hash_canon(), wide_int_to_tree_1(), hash_table< Descriptor, Lazy, Allocator >::~hash_table(), and jump_threader::~jump_threader().

â—† ggc_internal_cleared_alloc()

void * ggc_internal_cleared_alloc ( size_t ,
void(*  )(void *),
size_t ,
size_t MEM_STAT_DECL ) 
Generate pattern matching and transform code shared between
   GENERIC and GIMPLE folding code from match-and-simplify description.

   Copyright (C) 2014-2025 Free Software Foundation, Inc.
   Contributed by Richard Biener <rguenther@suse.de>
   and Prathamesh Kulkarni  <bilbotheelffriend@gmail.com>

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
Stubs for GGC referenced through instantiations triggered by hash-map.

References MEM_STAT_DECL, and NULL.

Referenced by symtab_node::get_dump_name(), and simd_clone_struct_alloc().

â—† ggc_internal_cleared_alloc_no_dtor()

void * ggc_internal_cleared_alloc_no_dtor ( size_t ,
void(*  )(void *),
size_t ,
size_t MEM_STAT_DECL )

References MEM_STAT_DECL, and NULL.

Referenced by ggc_cleared_alloc(), ggc_cleared_vec_alloc(), and ggc_internal_cleared_alloc().

â—† has_opt()

bool has_opt ( operand * o,
unsigned char grp )
static 
Determine whether O or its children uses the conditional operation
group GRP.

References dyn_cast(), has_opt(), i, expr::ops, and expr::opt_grp.

Referenced by has_opt(), and lower_opt().

â—† is_conversion()

bool is_conversion ( id_base * op) 
Code generation off the decision tree and the refered AST nodes.

Referenced by expr::gen_transform(), and get_operand_type().

â—† linemap_client_expand_location_to_spelling_point()

expanded_location linemap_client_expand_location_to_spelling_point ( const line_maps * set,
location_t loc,
enum location_aspect  ) 
The rich_location class within libcpp requires a way to expand
location_t instances, and relies on the client code
providing a symbol named
  linemap_client_expand_location_to_spelling_point
to do this.

This is the implementation for genmatch.

References map.

â—† lower()

void lower ( vec< simplify * > & simplifiers,
bool gimple )
static 
Lower the AST for everything in SIMPLIFIERS.

References lower_commutative(), lower_cond(), lower_for(), and lower_opt().

Referenced by gimplify_init_ctor_eval(), gimplify_init_ctor_eval_range(), initialize_iterators(), main(), and double_int::wide_mul_with_sign().

â—† lower_commutative()

void lower_commutative ( simplify * s,
vec< simplify * > & simplifiers )
static 
Lower operations marked as commutative in the AST of S and push
the resulting patterns to SIMPLIFIERS.

References simplify::capture_ids, commutate(), simplify::for_vec, i, simplify::id, simplify::kind, simplify::match, and simplify::result.

Referenced by lower().

â—† lower_cond() [1/2]

vec< operand * > lower_cond ( operand * o)
static 
Lower the compare operand of COND_EXPRs to a
GENERIC and a GIMPLE variant.

References expr::append_op(), as_a(), cartesian_product(), dyn_cast(), i, is_a(), lower_cond(), expr::operation, expr::ops, and vNULL.

Referenced by lower(), lower_cond(), and lower_cond().

â—† lower_cond() [2/2]

void lower_cond ( simplify * s,
vec< simplify * > & simplifiers )
static 
Lower the compare operand of COND_EXPRs to a
GENERIC and a GIMPLE variant.

References simplify::capture_ids, simplify::for_subst_vec, simplify::for_vec, i, simplify::id, simplify::kind, lower_cond(), simplify::match, and simplify::result.

â—† lower_for()

void lower_for ( simplify * sin,
vec< simplify * > & simplifiers )
static 
Lower recorded fors for SIN and output to SIMPLIFIERS.

References as_a(), binary_ok(), simplify::capture_ids, contains_id(), dyn_cast(), simplify::for_subst_vec, i, id_base::id, simplify::id, c_expr::ids, is_a(), simplify::kind, simplify::MATCH, simplify::match, null_id, replace_id(), simplify::result, si, simplify::SIMPLIFY, sin(), subst(), operator_id::tcc, vNULL, and worklist.

Referenced by lower().

â—† lower_opt() [1/3]

vec< operand * > lower_opt ( operand * o)
static 
Lower conditional convert operators in O, expanding it to a vector
if required.

References has_opt(), i, lower_opt(), and vNULL.

â—† lower_opt() [2/3]

operand * lower_opt ( operand * o,
unsigned char grp,
bool strip ) 
Strip conditional operations using group GRP from O and its
children if STRIP, else replace them with an unconditional operation.

References expr::append_op(), dyn_cast(), i, lower_opt(), expr::ops, and expr::opt_grp.

Referenced by lower(), lower_opt(), lower_opt(), and lower_opt().

â—† lower_opt() [3/3]

void lower_opt ( simplify * s,
vec< simplify * > & simplifiers )
static 
Lower conditional convert operators in the AST of S and push
the resulting multiple patterns to SIMPLIFIERS.

References simplify::capture_ids, simplify::for_vec, i, simplify::id, simplify::kind, lower_opt(), simplify::match, and simplify::result.

â—† main()

int main ( int argc,
char ** argv ) 
The genmatch generator program.  It reads from a pattern description
and outputs GIMPLE or GENERIC IL matching and simplification routines.   
This file contains the definitions and documentation for the
   tree codes used in GCC.
   Copyright (C) 1987-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
For tcc_references, tcc_expression, tcc_comparison, tcc_unary,
tcc_binary, and tcc_statement nodes, which use struct tree_exp, the
4th element is the number of argument slots to allocate.  This
determines the size of the tree node object.  Other nodes use
different structures, and the size is determined by the tree_union
member structure; the 4th element should be zero.  Languages that
define language-specific tcc_exceptional or tcc_constant codes must
define the tree_size langhook to say how big they are.

These tree codes have been sorted so that the macros in tree.h that
check for various tree codes are optimized into range checks.  This
gives a measurable performance improvement.  When adding a new
code, consider its placement in relation to the other codes.   
Any erroneous construct is parsed into a node of this type.
This type of node is accepted without complaint in all contexts
by later parsing activities, to avoid multiple error messages
for one error.
No fields in these nodes are used except the TREE_CODE.   
Used to represent a name (such as, in the DECL_NAME of a decl node).
Internally it looks like a STRING_CST node.
There is only one IDENTIFIER_NODE ever made for any particular name.
Use `get_identifier' to get it (or create it, the first time).   
Has the TREE_VALUE and TREE_PURPOSE fields.   
These nodes are made into lists by chaining through the
TREE_CHAIN field.  The elements of the list live in the
TREE_VALUE fields, while TREE_PURPOSE fields are occasionally
used as well to get the effect of Lisp association lists.   
These nodes contain an array of tree nodes.   
A symbol binding block.  These are arranged in a tree,
where the BLOCK_SUBBLOCKS field contains a chain of subblocks
chained through the BLOCK_CHAIN field.
BLOCK_SUPERCONTEXT points to the parent block.
  For a block which represents the outermost scope of a function, it
  points to the FUNCTION_DECL node.
BLOCK_VARS points to a chain of decl nodes.
BLOCK_CHAIN points to the next BLOCK at the same level.
BLOCK_ABSTRACT_ORIGIN points to the original (abstract) tree node which
this block is an instance of, or else is NULL to indicate that this
block is not an instance of anything else.  When non-NULL, the value
could either point to another BLOCK node or it could point to a
FUNCTION_DECL node (e.g. in the case of a block representing the
outermost scope of a particular inlining of a function).
TREE_ASM_WRITTEN is nonzero if the block was actually referenced
in the generated assembly.   
Each data type is represented by a tree node whose code is one of
the following:   
Each node that represents a data type has a component TYPE_SIZE
 that evaluates either to a tree that is a (potentially non-constant)
 expression representing the type size in bits, or to a null pointer
 when the size of the type is unknown (for example, for incomplete
 types such as arrays of unspecified bound).
 The TYPE_MODE contains the machine mode for values of this type.
 The TYPE_POINTER_TO field contains a type for a pointer to this type,
   or zero if no such has been created yet.
 The TYPE_NEXT_VARIANT field is used to chain together types
   that are variants made by type modifiers such as "const" and "volatile".
 The TYPE_MAIN_VARIANT field, in any member of such a chain,
   points to the start of the chain.
 The TYPE_NAME field contains info on the name used in the program
   for this type (for GDB symbol table output).  It is either a
   TYPE_DECL node, for types that are typedefs, or an IDENTIFIER_NODE
   in the case of structs, unions or enums that are known with a tag,
   or zero for types that have no special name.
 The TYPE_CONTEXT for any sort of type which could have a name or
  which could have named members (e.g. tagged types in C/C++) will
  point to the node which represents the scope of the given type, or
  will be NULL_TREE if the type has "file scope".  For most types, this
  will point to a BLOCK node or a FUNCTION_DECL node, but it could also
  point to a FUNCTION_TYPE node (for types whose scope is limited to the
  formal parameter list of some function type specification) or it
  could point to a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE node
  (for C++ "member" types).
  For non-tagged-types, TYPE_CONTEXT need not be set to anything in
  particular, since any type which is of some type category  (e.g.
  an array type or a function type) which cannot either have a name
  itself or have named members doesn't really have a "scope" per se.
The TYPE_STUB_DECL field is used as a forward-references to names for
  ENUMERAL_TYPE, RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE nodes;
  see below.   
The ordering of the following codes is optimized for the checking
macros in tree.h.  Changing the order will degrade the speed of the
compiler.  OFFSET_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, INTEGER_TYPE,
BITINT_TYPE, REAL_TYPE, POINTER_TYPE.   
An offset is a pointer relative to an object.
The TREE_TYPE field is the type of the object at the offset.
The TYPE_OFFSET_BASETYPE points to the node for the type of object
that the offset is relative to.   
C enums.  The type node looks just like an INTEGER_TYPE node.
The symbols for the values of the enum type are defined by
CONST_DECL nodes, but the type does not point to them;
however, the TYPE_VALUES is a list in which each element's TREE_PURPOSE
is a name and the TREE_VALUE is the value (an INTEGER_CST node).   
A forward reference `enum foo' when no enum named foo is defined yet
has zero (a null pointer) in its TYPE_SIZE.  The tag name is in
the TYPE_NAME field.  If the type is later defined, the normal
fields are filled in.
RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE forward refs are
treated similarly.   
Boolean type (true or false are the only values).  Looks like an
INTEGER_TYPE, but must be dealt with specially because TYPE_PRECISION
may be arbitrary despite the restricted set of valid values (in other
words, boolean types with TYPE_PRECISION > 1 exist in some languages).
Similarly, TYPE_UNSIGNED may be false for components of vector masks,
as well as for boolean types in languages other than C.   
Integer types in all languages, including char in C.
Also used for sub-ranges of other discrete types.
Has components TYPE_MIN_VALUE, TYPE_MAX_VALUE (expressions, inclusive)
and TYPE_PRECISION (number of bits used by this type).   
Bit-precise integer type.  These are similar to INTEGER_TYPEs, but
can have arbitrary user selected precisions and do or can have different
alignment, function argument and return value passing conventions.
Larger BITINT_TYPEs can have BLKmode TYPE_MODE and need to be lowered
by a special BITINT_TYPE lowering pass.   
C's float and double.  Different floating types are distinguished
by machine mode and by the TYPE_SIZE and the TYPE_PRECISION.   
The ordering of the following codes is optimized for the checking
macros in tree.h.  Changing the order will degrade the speed of the
compiler.  POINTER_TYPE, REFERENCE_TYPE.  Note that this range
overlaps the previous range of ordered types.   
All pointer-to-x types have code POINTER_TYPE.
The TREE_TYPE points to the node for the type pointed to.   
A reference is like a pointer except that it is coerced
automatically to the value it points to.  Used in C++.   
The C++ decltype(nullptr) type.   
_Fract and _Accum types in Embedded-C.  Different fixed-point types
are distinguished by machine mode and by the TYPE_SIZE and the
TYPE_PRECISION.   
The ordering of the following codes is optimized for the checking
macros in tree.h.  Changing the order will degrade the speed of the
compiler.  COMPLEX_TYPE, VECTOR_TYPE, ARRAY_TYPE.   
Complex number types.  The TREE_TYPE field is the data type
of the real and imaginary parts.  It must be of scalar
arithmetic type, not including pointer type.   
Vector types.  The TREE_TYPE field is the data type of the vector
elements.  The TYPE_PRECISION field is the number of subparts of
the vector.   
The ordering of the following codes is optimized for the checking
macros in tree.h.  Changing the order will degrade the speed of the
compiler.  ARRAY_TYPE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE.
Note that this range overlaps the previous range.   
Types of arrays.  Special fields:
  TREE_TYPE               Type of an array element.
  TYPE_DOMAIN             Type to index by.
                    Its range of values specifies the array length.
The field TYPE_POINTER_TO (TREE_TYPE (array_type)) is always nonzero
and holds the type to coerce a value of that array type to in C.
TYPE_STRING_FLAG indicates a string (in contrast to an array of chars)
in languages (such as Chill) that make a distinction.   
Array types in C  
Struct in C.   
Special fields:
TYPE_FIELDS  chain of FIELD_DECLs for the fields of the struct,
  VAR_DECLs, TYPE_DECLs and CONST_DECLs for record-scope variables,
  types and enumerators and FUNCTION_DECLs for methods associated
  with the type.   
See the comment above, before ENUMERAL_TYPE, for how
forward references to struct tags are handled in C.   
Union in C.  Like a struct, except that the offsets of the fields
will all be zero.   
See the comment above, before ENUMERAL_TYPE, for how
forward references to union tags are handled in C.   
Similar to UNION_TYPE, except that the expressions in DECL_QUALIFIER
in each FIELD_DECL determine what the union contains.  The first
field whose DECL_QUALIFIER expression is true is deemed to occupy
the union.   
The ordering of the following codes is optimized for the checking
macros in tree.h.  Changing the order will degrade the speed of the
compiler.  VOID_TYPE, FUNCTION_TYPE, METHOD_TYPE.   
The void type in C  
Type of functions.  Special fields:
TREE_TYPE                   type of value returned.
TYPE_ARG_TYPES      list of types of arguments expected.
     this list is made of TREE_LIST nodes.
     In this list TREE_PURPOSE can be used to indicate the default
     value of parameter (used by C++ frontend).
Types of "Procedures" in languages where they are different from functions
have code FUNCTION_TYPE also, but then TREE_TYPE is zero or void type.   
METHOD_TYPE is the type of a function which takes an extra first
argument for "self", which is not present in the declared argument list.
The TREE_TYPE is the return type of the method.  The TYPE_METHOD_BASETYPE
is the type of "self".  TYPE_ARG_TYPES is the real argument list, which
includes the hidden argument for "self".   
This is a language-specific kind of type.
Its meaning is defined by the language front end.
layout_type does not know how to lay this out,
so the front-end must do so manually.   
This is for types that will use MODE_OPAQUE in the back end.  They are meant
to be able to go in a register of some sort but are explicitly not to be
converted or operated on like INTEGER_TYPE.  They will have size and
alignment information only.   
Expressions  
First, the constants.   
Contents are in an array of HOST_WIDE_INTs.

We often access these constants both in their native precision and
in wider precisions (with the constant being implicitly extended
according to TYPE_SIGN).  In each case, the useful part of the array
may be as wide as the precision requires but may be shorter when all
of the upper bits are sign bits.  The length of the array when accessed
in the constant's native precision is given by TREE_INT_CST_NUNITS.
The length of the array when accessed in wider precisions is given
by TREE_INT_CST_EXT_NUNITS.  Each element can be obtained using
TREE_INT_CST_ELT.

INTEGER_CST nodes can be shared, and therefore should be considered
read only.  They should be copied before setting a flag such as
TREE_OVERFLOW.  If an INTEGER_CST has TREE_OVERFLOW already set,
it is known to be unique.  INTEGER_CST nodes are created for the
integral types, for pointer types and for vector and float types in
some circumstances.   
Contents are given by POLY_INT_CST_COEFF.   
Contents are in TREE_REAL_CST field.   
Contents are in TREE_FIXED_CST field.   
Contents are in TREE_REALPART and TREE_IMAGPART fields,
whose contents are other constant nodes.   
See generic.texi for details.   
Contents are TREE_STRING_LENGTH and the actual contents of the string.   
Contents are RAW_DATA_LENGTH and the actual content
of the raw data, plus RAW_DATA_OWNER for owner of the
data.  That can be either a STRING_CST, used e.g. when writing
PCH header, or another RAW_DATA_CST representing data owned by
libcpp and representing the original range (if possible)
or NULL_TREE if it is the RAW_DATA_OWNER of other RAW_DATA_CST
nodes (and represents data owned by libcpp).
TREE_TYPE is the type of each of the RAW_DATA_LENGTH elements.   
Declarations.  All references to names are represented as ..._DECL
nodes.  The decls in one binding context are chained through the
TREE_CHAIN field.  Each DECL has a DECL_NAME field which contains
an IDENTIFIER_NODE.  (Some decls, most often labels, may have zero
as the DECL_NAME).  DECL_CONTEXT points to the node representing
the context in which this declaration has its scope.  For
FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
QUAL_UNION_TYPE node that the field is a member of.  For VAR_DECL,
PARM_DECL, FUNCTION_DECL, LABEL_DECL, and CONST_DECL nodes, this
points to either the FUNCTION_DECL for the containing function, the
RECORD_TYPE or UNION_TYPE for the containing type, or NULL_TREE or
a TRANSLATION_UNIT_DECL if the given decl has "file scope".
DECL_ABSTRACT_ORIGIN, if non-NULL, points to the original (abstract)
 ..._DECL node of which this decl is an (inlined or template expanded)
 instance.
The TREE_TYPE field holds the data type of the object, when relevant.
 LABEL_DECLs have no data type.  For TYPE_DECL, the TREE_TYPE field
 contents are the type whose name is being declared.
The DECL_ALIGN, DECL_SIZE,
 and DECL_MODE fields exist in decl nodes just as in type nodes.
 They are unused in LABEL_DECL, TYPE_DECL and CONST_DECL nodes.

DECL_FIELD_BIT_OFFSET holds an integer number of bits offset for
the location.  DECL_VOFFSET holds an expression for a variable
offset; it is to be multiplied by DECL_VOFFSET_UNIT (an integer).
These fields are relevant only in FIELD_DECLs and PARM_DECLs.

DECL_INITIAL holds the value to initialize a variable to,
or the value of a constant.  For a function, it holds the body
(a node of type BLOCK representing the function's binding contour
and whose body contains the function's statements.)  For a LABEL_DECL
in C, it is a flag, nonzero if the label's definition has been seen.

PARM_DECLs use a special field:
DECL_ARG_TYPE is the type in which the argument is actually
 passed, which may be different from its type within the function.

FUNCTION_DECLs use four special fields:
DECL_ARGUMENTS holds a chain of PARM_DECL nodes for the arguments.
DECL_RESULT holds a RESULT_DECL node for the value of a function.
 The DECL_RTL field is 0 for a function that returns no value.
 (C functions returning void have zero here.)
 The TREE_TYPE field is the type in which the result is actually
 returned.  This is usually the same as the return type of the
 FUNCTION_DECL, but it may be a wider integer type because of
 promotion.
DECL_FUNCTION_CODE is a code number that is nonzero for
 built-in functions.  Its value is an enum built_in_function
 that says which built-in function it is.

DECL_SOURCE_FILE holds a filename string and DECL_SOURCE_LINE
holds a line number.  In some cases these can be the location of
a reference, if no definition has been seen.

DECL_ABSTRACT is nonzero if the decl represents an abstract instance
of a decl (i.e. one which is nested within an abstract instance of a
inline function.   
The ordering of the following codes is optimized for the checking
macros in tree.h.  Changing the order will degrade the speed of the
compiler.  FIELD_DECL, VAR_DECL, CONST_DECL, PARM_DECL,
TYPE_DECL.   
A "declaration" of a debug temporary.  It should only appear in
DEBUG stmts.   
A stmt that marks the beginning of a source statement.   
A namespace declaration.  Namespaces appear in DECL_CONTEXT of other
_DECLs, providing a hierarchy of names.   
A declaration import.
The C++ FE uses this to represent a using-directive; eg:
"using namespace foo".
But it could be used to represent any declaration import construct.
Whenever a declaration import appears in a lexical block, the BLOCK node
representing that lexical block in GIMPLE will contain an IMPORTED_DECL
node, linked via BLOCK_VARS accessor of the said BLOCK.
For a given NODE which code is IMPORTED_DECL,
IMPORTED_DECL_ASSOCIATED_DECL (NODE) accesses the imported declaration.   
A namelist declaration.
The Fortran FE uses this to represent a namelist statement, e.g.:
NAMELIST /namelist-group-name/ namelist-group-object-list.
Whenever a declaration import appears in a lexical block, the BLOCK node
representing that lexical block in GIMPLE will contain an NAMELIST_DECL
node, linked via BLOCK_VARS accessor of the said BLOCK.
For a given NODE which code is NAMELIST_DECL,
NAMELIST_DECL_ASSOCIATED_DECL (NODE) accesses the imported declaration.   
A translation unit.  This is not technically a declaration, since it
can't be looked up, but it's close enough.   
References to storage.   
The ordering of the following codes is optimized for the classification
in handled_component_p.  Keep them in a consecutive group.   
Value is structure or union component.
Operand 0 is the structure or union (an expression).
Operand 1 is the field (a node of type FIELD_DECL).
Operand 2, if present, is the value of DECL_FIELD_OFFSET, measured
in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT.   
Reference to a group of bits within an object.  Similar to COMPONENT_REF
except the position is given explicitly rather than via a FIELD_DECL.
Operand 0 is the structure or union expression;
operand 1 is a tree giving the constant number of bits being referenced;
operand 2 is a tree giving the constant position of the first referenced bit.
The result type width has to match the number of bits referenced.
If the result type is integral, its signedness specifies how it is extended
to its mode width.   
Array indexing.
Operand 0 is the array; operand 1 is a (single) array index.
Operand 2, if present, is a copy of TYPE_MIN_VALUE of the index.
Operand 3, if present, is the element size, measured in units of
the alignment of the element type.   
Likewise, except that the result is a range ("slice") of the array.  The
starting index of the resulting array is taken from operand 1 and the size
of the range is taken from the type of the expression.   
Used only on an operand of complex type, these return
a value of the corresponding component type.   
Represents viewing something of one type as being of a second type.
This corresponds to an "Unchecked Conversion" in Ada and roughly to
the idiom *(type2 *)&X in C.  The only operand is the value to be
viewed as being of another type.  It is undefined if the type of the
input and of the expression have different sizes.

This code may also be used within the LHS of a MODIFY_EXPR, in which
case no actual data motion may occur.  TREE_ADDRESSABLE will be set in
this case and GCC must abort if it could not do the operation without
generating insns.   
C unary `*'.  One operand, an expression for a pointer.   
Used to represent lookup in a virtual method table which is dependent on
the runtime type of an object.  Operands are:
OBJ_TYPE_REF_EXPR: An expression that evaluates the value to use.
OBJ_TYPE_REF_OBJECT: Is the object on whose behalf the lookup is
being performed.  Through this the optimizers may be able to statically
determine the dynamic type of the object.
OBJ_TYPE_REF_TOKEN: An integer index to the virtual method table.
The integer index should have as type the original type of
OBJ_TYPE_REF_OBJECT; as pointer type conversions are useless in GIMPLE,
the type of OBJ_TYPE_REF_OBJECT can change to an unrelated pointer
type during optimizations.   
Used to represent the brace-enclosed initializers for a structure or an
array.  It contains a sequence of component values made out of a VEC of
constructor_elt.

For RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE:
The field INDEX of each constructor_elt is a FIELD_DECL.

For ARRAY_TYPE:
The field INDEX of each constructor_elt is the corresponding index.
If the index is a RANGE_EXPR, it is a short-hand for many nodes,
one for each index in the range.  (If the corresponding field VALUE
has side-effects, they are evaluated once for each element.  Wrap the
value in a SAVE_EXPR if you want to evaluate side effects only once.)
If the index is INTEGER_CST or NULL_TREE and value RAW_DATA_CST, it is
a short-hand for RAW_DATA_LENGTH consecutive nodes, first at the given
index or current location, each node being
build_int_cst (TREE_TYPE (value), TYPE_UNSIGNED (TREE_TYPE (value))
          ? (HOST_WIDE_INT) RAW_DATA_UCHAR_ELT (value, n)
          : (HOST_WIDE_INT) RAW_DATA_SCHAR_ELT (value, n)) at index
tree_to_uhwi (index) + n (or current location + n) for n from 0 to
RAW_DATA_LENGTH (value) - 1.

Components that aren't present are cleared as per the C semantics,
unless the CONSTRUCTOR_NO_CLEARING flag is set, in which case their
value becomes undefined.   
The expression types are mostly straightforward, with the fourth argument
of DEFTREECODE saying how many operands there are.
Unless otherwise specified, the operands are expressions and the
types of all the operands and the expression must all be the same.   
Contains two expressions to compute, one followed by the other.
the first value is ignored.  The second one's value is used.  The
type of the first expression need not agree with the other types.   
Assignment expression.  Operand 0 is the what to set; 1, the new value.   
Initialization expression.  Operand 0 is the variable to initialize;
Operand 1 is the initializer.  This differs from MODIFY_EXPR in that any
reference to the referent of operand 0 within operand 1 is undefined.   
For TARGET_EXPR, operand 0 is the target of an initialization,
operand 1 is the initializer for the target, which may be void
  if simply expanding it initializes the target.
operand 2 is the cleanup for this node, if any.
operand 3 is the saved initializer after this node has been
expanded once; this is so we can re-expand the tree later.   
Conditional expression ( ... ? ... : ...  in C).
Operand 0 is the condition.
Operand 1 is the then-value.
Operand 2 is the else-value.
Operand 0 may be of any type.
Operand 1 must have the same type as the entire expression, unless
it unconditionally throws an exception, in which case it should
have VOID_TYPE.  The same constraints apply to operand 2.  The
condition in operand 0 must be of integral type.

In cfg gimple, if you do not have a selection expression, operands
1 and 2 are NULL.  The operands are then taken from the cfg edges.  
Represents a vector in which every element is equal to operand 0.   
Vector series created from a start (base) value and a step.

A = VEC_SERIES_EXPR (B, C)

means

for (i = 0; i < N; i++)
  A[i] = B + C * i;   
Vector conditional expression. It is like COND_EXPR, but with
  vector operands.

  A = VEC_COND_EXPR ( X < Y, B, C)

  means

  for (i=0; i<N; i++)
    A[i] = X[i] < Y[i] ? B[i] : C[i];

Vector permutation expression.  A = VEC_PERM_EXPR<v0, v1, mask> means

  N = length(mask)
  foreach i in N:
    M = mask[i] % (length(v0) + length(v1))
    A[i] = M < length(v0) ? v0[M] : v1[M - length(v0)]

  V0 and V1 are vectors of the same type.

  When MASK is not constant:
    MASK is an integer-typed vector.  The number of MASK elements must
    be the same as the number of elements in V0 and V1.  The size of
    the inner type of the MASK and of the V0 and V1 must be the same.

  When MASK is constant:
    MASK is an integer-typed vector.

Declare local variables, including making RTL and allocating space.
BIND_EXPR_VARS is a chain of VAR_DECL nodes for the variables.
BIND_EXPR_BODY is the body, the expression to be computed using
the variables.  The value of operand 1 becomes that of the BIND_EXPR.
BIND_EXPR_BLOCK is the BLOCK that corresponds to these bindings
for debugging purposes.  If this BIND_EXPR is actually expanded,
that sets the TREE_USED flag in the BLOCK.

The BIND_EXPR is not responsible for informing parsers
about these variables.  If the body is coming from the input file,
then the code that creates the BIND_EXPR is also responsible for
informing the parser of the variables.

If the BIND_EXPR is ever expanded, its TREE_USED flag is set.
This tells the code for debugging symbol tables not to ignore the BIND_EXPR.
If the BIND_EXPR should be output for debugging but will not be expanded,
set the TREE_USED flag by hand.

In order for the BIND_EXPR to be known at all, the code that creates it
must also install it as a subblock in the tree of BLOCK
nodes for the function.   
Function call.  CALL_EXPRs are represented by variably-sized expression
nodes.  There are at least three fixed operands.  Operand 0 is an
INTEGER_CST node containing the total operand count, the number of
arguments plus 3.  Operand 1 is the function or NULL, while operand 2 is
is static chain argument, or NULL.  The remaining operands are the
arguments to the call.   
Specify a value to compute along with its corresponding cleanup.
Operand 0 is the cleanup expression.
The cleanup is executed by the first enclosing CLEANUP_POINT_EXPR,
which must exist.  This differs from TRY_CATCH_EXPR in that operand 1
is always evaluated when cleanups are run.   
Specify a cleanup point.
Operand 0 is an expression that may have cleanups.  If it does, those
cleanups are executed after the expression is expanded.

Note that if the expression is a reference to storage, it is forced out
of memory before the cleanups are run.  This is necessary to handle
cases where the cleanups modify the storage referenced; in the
expression 't.i', if 't' is a struct with an integer member 'i' and a
cleanup which modifies 'i', the value of the expression depends on
whether the cleanup is run before or after 't.i' is evaluated.  When
expand_expr is run on 't.i', it returns a MEM.  This is not good enough;
the value of 't.i' must be forced out of memory.

As a consequence, the operand of a CLEANUP_POINT_EXPR must not have
BLKmode, because it will not be forced out of memory.   
The following code is used in languages that have types where some
field in an object of the type contains a value that is used in the
computation of another field's offset or size and/or the size of the
type.  The positions and/or sizes of fields can vary from object to
object of the same type or even for one and the same object within
its scope.

Record types with discriminants in Ada are
examples of such types.  This mechanism is also used to create "fat
pointers" for unconstrained array types in Ada; the fat pointer is a
structure one of whose fields is a pointer to the actual array type
and the other field is a pointer to a template, which is a structure
containing the bounds of the array.  The bounds in the type pointed
to by the first field in the fat pointer refer to the values in the
template.

When you wish to construct such a type you need "self-references"
that allow you to reference the object having this type from the
TYPE node, i.e. without having a variable instantiating this type.

Such a "self-references" is done using a PLACEHOLDER_EXPR.  This is
a node that will later be replaced with the object being referenced.
Its type is that of the object and selects which object to use from
a chain of references (see below).  No other slots are used in the
PLACEHOLDER_EXPR.

For example, if your type FOO is a RECORD_TYPE with a field BAR,
and you need the value of <variable>.BAR to calculate TYPE_SIZE
(FOO), just substitute <variable> above with a PLACEHOLDER_EXPR
whose TREE_TYPE is FOO.  Then construct your COMPONENT_REF with
the PLACEHOLDER_EXPR as the first operand (which has the correct
type).  Later, when the size is needed in the program, the back-end
will find this PLACEHOLDER_EXPR and generate code to calculate the
actual size at run-time.  In the following, we describe how this
calculation is done.

When we wish to evaluate a size or offset, we check whether it contains a
PLACEHOLDER_EXPR.  If it does, we call substitute_placeholder_in_expr
passing both that tree and an expression within which the object may be
found.  The latter expression is the object itself in the simple case of
an Ada record with discriminant, but it can be the array in the case of an
unconstrained array.

In the latter case, we need the fat pointer, because the bounds of
the array can only be accessed from it.  However, we rely here on the
fact that the expression for the array contains the dereference of
the fat pointer that obtained the array pointer.   
Denotes a record to later be substituted before evaluating this expression.
The type of this expression is used to find the record to replace it.   
Simple arithmetic.   
Pointer addition.  The first operand is always a pointer and the
second operand is an integer of type sizetype.   
Pointer subtraction.  The two arguments are pointers, and the result
is a signed integer of the same precision.  Pointers are interpreted
as unsigned, the difference is computed as if in infinite signed
precision.  Behavior is undefined if the difference does not fit in
the result type.  The result does not depend on the pointer type,
it is not divided by the size of the pointed-to type.   
Highpart multiplication.  For an integral type with precision B,
returns bits [2B-1, B] of the full 2*B product.  Both operands
and the result should have integer types of the same precision
and signedness.   
Division for integer result that rounds the quotient toward zero.   
Division for integer result that rounds it toward plus infinity.   
Division for integer result that rounds it toward minus infinity.   
Division for integer result that rounds it toward nearest integer.   
Four kinds of remainder that go with the four kinds of division:   
The sign of the remainder is that of the dividend.   
The sign of the remainder is the opposite of that of the divisor.   
The sign of the remainder is that of the divisor.   
The sign of the remainder is not predictable.   
Division for real result.   
Division which is not supposed to need rounding.
Used for pointer subtraction in C.   
Conversion of real to fixed point by truncation.   
Conversion of an integer to a real.   
Unary negation.   
Minimum and maximum values.  When used with floating point, if both
operands are zeros, or if either operand is NaN, then it is unspecified
which of the two operands is returned as the result.   
Represents the absolute value of the operand.

An ABS_EXPR must have either an INTEGER_TYPE or a REAL_TYPE.  The
operand of the ABS_EXPR must have the same type.   
Represents the unsigned absolute value of the operand.
An ABSU_EXPR must have unsigned INTEGER_TYPE.  The operand of the ABSU_EXPR
must have the corresponding signed type.   
Shift operations for shift and rotate.
Shift means logical shift if done on an
unsigned type, arithmetic shift if done on a signed type.
The second operand is the number of bits to
shift by; it need not be the same type as the first operand and result.
Note that the result is undefined if the second operand is larger
than or equal to the first operand's type size.

The first operand of a shift can have either an integer or a
(non-integer) fixed-point type.  We follow the ISO/IEC TR 18037:2004
semantics for the latter.

Rotates are defined for integer types only.   
Bitwise operations.  Operands have same mode as result.   
ANDIF and ORIF allow the second operand not to be computed if the
value of the expression is determined from the first operand.  AND,
OR, and XOR always compute the second operand whether its value is
needed or not (for side effects).  The operand may have
BOOLEAN_TYPE or INTEGER_TYPE.  In either case, the argument will be
either zero or one.  For example, a TRUTH_NOT_EXPR will never have
an INTEGER_TYPE VAR_DECL as its argument; instead, a NE_EXPR will be
used to compare the VAR_DECL to zero, thereby obtaining a node with
value zero or one.   
Relational operators.
EQ_EXPR and NE_EXPR are allowed for any types.  The others, except for
LTGT_EXPR, are allowed only for integral, floating-point and vector types.
LTGT_EXPR is allowed only for floating-point types.
For floating-point operators, if either operand is a NaN, then NE_EXPR
returns true and the remaining operators return false.  The operators
other than EQ_EXPR and NE_EXPR may generate an exception on quiet NaNs.
In all cases the operands will have the same type,
and the value is either the type used by the language for booleans
or an integer vector type of the same size and with the same number
of elements as the comparison operands.  True for a vector of
comparison results has all bits set while false is equal to zero.   
Additional relational operators for floating-point unordered.   
These are equivalent to unordered or ...   
Represents a re-association barrier for floating point expressions
like explicit parenthesis in fortran.   
Represents a conversion of type of a value.
All conversions, including implicit ones, must be
represented by CONVERT_EXPR or NOP_EXPR nodes.   
Conversion of a pointer value to a pointer to a different
address space.   
Conversion of a fixed-point value to an integer, a real, or a fixed-point
value.  Or conversion of a fixed-point value from an integer, a real, or
a fixed-point value.   
Represents a conversion expected to require no code to be generated.   
Value is same as argument, but guaranteed not an lvalue.   
A COMPOUND_LITERAL_EXPR represents a literal that is placed in a DECL.  The
COMPOUND_LITERAL_EXPR_DECL_EXPR is the a DECL_EXPR containing the decl
for the anonymous object represented by the COMPOUND_LITERAL;
the DECL_INITIAL of that decl is the CONSTRUCTOR that initializes
the compound literal.   
Represents something we computed once and will use multiple times.
First operand is that expression.  After it is evaluated once, it
will be replaced by the temporary variable that holds the value.   
& in C.  Value is the address at which the operand's value resides.
Operand may have any mode.  Result mode is Pmode.   
Operand0 is a function constant; result is part N of a function
descriptor of type ptr_mode.   
Given a container value, a replacement value and a bit position within
the container, produce the value that results from replacing the part of
the container starting at the bit position with the replacement value.
Operand 0 is a tree for the container value of integral or vector type;
Operand 1 is a tree for the replacement value of another integral or
the vector element type;
Operand 2 is a tree giving the constant bit position;
The number of bits replaced is given by the precision of the type of the
replacement value if it is integral or by its size if it is non-integral.
???  The reason to make the size of the replacement implicit is to avoid
introducing a quaternary operation.
The replaced bits shall be fully inside the container.  If the container
is of vector type, then these bits shall be aligned with its elements.   
Given two real or integer operands of the same type,
returns a complex value of the corresponding complex type.   
Complex conjugate of operand.  Used only on complex types.   
Nodes for ++ and -- in C.
The second arg is how much to increment or decrement by.
For a pointer, it would be the size of the object pointed to.   
Used to implement `va_arg'.   
Evaluate operand 0.  If and only if an exception is thrown during
the evaluation of operand 0, evaluate operand 1.

This differs from TRY_FINALLY_EXPR in that operand 1 is not evaluated
on a normal or jump exit, only on an exception.   
Evaluate the first operand.
The second operand is a cleanup expression which is evaluated
on any exit (normal, exception, or jump out) from this expression.   
Evaluate either the normal or the exceptional cleanup.  This must
only be present as the cleanup expression in a TRY_FINALLY_EXPR.
If the TRY_FINALLY_EXPR completes normally, the first operand of
EH_ELSE_EXPR is used as a cleanup, otherwise the second operand is
used.   
These types of expressions have no useful value,
and always have side effects.   
Used to represent a local declaration. The operand is DECL_EXPR_DECL.   
A label definition, encapsulated as a statement.
Operand 0 is the LABEL_DECL node for the label that appears here.
The type should be void and the value should be ignored.   
GOTO.  Operand 0 is a LABEL_DECL node or an expression.
The type should be void and the value should be ignored.   
RETURN.  Evaluates operand 0, then returns from the current function.
Presumably that operand is an assignment that stores into the
RESULT_DECL that hold the value to be returned.
The operand may be null.
The type should be void and the value should be ignored.   
Exit the inner most loop conditionally.  Operand 0 is the condition.
The type should be void and the value should be ignored.   
A loop.  Operand 0 is the body of the loop.
It must contain an EXIT_EXPR or is an infinite loop.
The type should be void and the value should be ignored.   
Switch expression.

TREE_TYPE is the original type of the condition, before any
language required type conversions.  It may be NULL, in which case
the original type and final types are assumed to be the same.

Operand 0 is the expression used to perform the branch,
Operand 1 is the body of the switch, which probably contains
  CASE_LABEL_EXPRs.  It may also be NULL, in which case operand 2
  must not be NULL.   
Used to represent a case label.

Operand 0 is CASE_LOW.  It may be NULL_TREE, in which case the label
  is a 'default' label.
Operand 1 is CASE_HIGH.  If it is NULL_TREE, the label is a simple
  (one-value) case label.  If it is non-NULL_TREE, the case is a range.
Operand 2 is CASE_LABEL, which has the corresponding LABEL_DECL.
Operand 3 is CASE_CHAIN.  This operand is only used in tree-cfg.cc to
  speed up the lookup of case labels which use a particular edge in
  the control flow graph.   
Used to represent an inline assembly statement.  ASM_STRING returns a
STRING_CST for the instruction (e.g., "mov x, y"). ASM_OUTPUTS,
ASM_INPUTS, and ASM_CLOBBERS represent the outputs, inputs, and clobbers
for the statement.  ASM_LABELS, if present, indicates various destinations
for the asm; labels cannot be combined with outputs.   
Variable references for SSA analysis.  New SSA names are created every
time a variable is assigned a new value.  The SSA builder uses SSA_NAME
nodes to implement SSA versioning.   
Used to represent a typed exception handler.  CATCH_TYPES is the type (or
list of types) handled, and CATCH_BODY is the code for the handler.   
Used to represent an exception specification.  EH_FILTER_TYPES is a list
of allowed types, and EH_FILTER_FAILURE is an expression to evaluate on
failure.   
Node used for describing a property that is known at compile
time.   
Node used for describing a property that is not known at compile
time.   
Polynomial chains of recurrences.
cr = {CHREC_LEFT (cr), +, CHREC_RIGHT (cr)}_CHREC_VARIABLE (cr).   
Used to chain children of container statements together.
Use the interface in tree-iterator.h to access this node.   
NOTE: This code is deprecated and should only be used internally by ipa* as
temporary construct.

Predicate assertion.  Artificial expression generated by the optimizers
to keep track of predicate values.  This expression may only appear on
the RHS of assignments.

Given X = ASSERT_EXPR <Y, EXPR>, the optimizers can infer
two things:

        1- X is a copy of Y.
     2- EXPR is a conditional expression and is known to be true.

Valid and to be expected forms of conditional expressions are
valid GIMPLE conditional expressions (as defined by is_gimple_condexpr)
and conditional expressions with the first operand being a
PLUS_EXPR with a variable possibly wrapped in a NOP_EXPR first
operand and an integer constant second operand.

The type of the expression is the same as Y.   
Base class information. Holds information about a class as a
baseclass of itself or another class.   
Records the size for an expression of variable size type.  This is
for use in contexts in which we are accessing the entire object,
such as for a function call, or block copy.
Operand 0 is the real expression.
Operand 1 is the size of the type in the expression.   
Extract elements from two input vectors Operand 0 and Operand 1
size VS, according to the offset OFF defined by Operand 2 as
follows:
If OFF > 0, the last VS - OFF elements of vector OP0 are concatenated to
the first OFF elements of the vector OP1.
If OFF == 0, then the returned vector is OP1.
On different targets OFF may take different forms; It can be an address, in
which case its low log2(VS)-1 bits define the offset, or it can be a mask
generated by the builtin targetm.vectorize.mask_for_load_builtin_decl.   
Low-level memory addressing.  Operands are BASE (address of static or
global variable or register), OFFSET (integer constant),
INDEX (register), STEP (integer constant), INDEX2 (register),
The corresponding address is BASE + STEP * INDEX + INDEX2 + OFFSET.
Only variations and values valid on the target are allowed.

The type of STEP, INDEX and INDEX2 is sizetype.

The type of BASE is a pointer type.  If BASE is not an address of
a static or global variable INDEX2 will be NULL.

The type of OFFSET is a pointer type and determines TBAA the same as
the constant offset operand in MEM_REF.   
Memory addressing.  Operands are a pointer and a tree constant integer
byte offset of the pointer type that when dereferenced yields the
type of the base object the pointer points into and which is used for
TBAA purposes.
The type of the MEM_REF is the type the bytes at the memory location
are interpreted as.
MEM_REF <p, c> is equivalent to ((typeof(c))p)->x... where x... is a
chain of component references offsetting p by c.   
OpenACC and OpenMP.  As it is exposed in TREE_RANGE_CHECK invocations, do
not change the ordering of these codes.   
OpenACC - #pragma acc parallel [clause1 ... clauseN]
Operand 0: OMP_BODY: Code to be executed in parallel.
Operand 1: OMP_CLAUSES: List of clauses.   
OpenACC - #pragma acc kernels [clause1 ... clauseN]
Operand 0: OMP_BODY: Sequence of kernels.
Operand 1: OMP_CLAUSES: List of clauses.   
OpenACC - #pragma acc serial [clause1 ... clauseN]
Operand 0: OMP_BODY: Code to be executed sequentially.
Operand 1: OMP_CLAUSES: List of clauses.   
OpenACC - #pragma acc data [clause1 ... clauseN]
Operand 0: OACC_DATA_BODY: Data construct body.
Operand 1: OACC_DATA_CLAUSES: List of clauses.   
OpenACC - #pragma acc host_data [clause1 ... clauseN]
Operand 0: OACC_HOST_DATA_BODY: Host_data construct body.
Operand 1: OACC_HOST_DATA_CLAUSES: List of clauses.   
OpenMP - #pragma omp parallel [clause1 ... clauseN]
Operand 0: OMP_PARALLEL_BODY: Code to be executed by all threads.
Operand 1: OMP_PARALLEL_CLAUSES: List of clauses.   
OpenMP - #pragma omp task [clause1 ... clauseN]
Operand 0: OMP_TASK_BODY: Code to be executed by all threads.
Operand 1: OMP_TASK_CLAUSES: List of clauses.   
OpenMP - #pragma omp for [clause1 ... clauseN]

A single OMP_FOR node represents an entire nest of collapsed
loops; as noted below, some of its arguments are vectors of length
equal to the collapse depth, and the corresponding elements holding
data specific to a particular loop in the nest.  These vectors are
numbered from the outside in so that the outermost loop is element 0.

These constructs have seven operands:

Operand 0: OMP_FOR_BODY contains the loop body.

Operand 1: OMP_FOR_CLAUSES is the list of clauses
associated with the directive.

Operand 2: OMP_FOR_INIT is a vector containing iteration
variable initializations of the form VAR = N1.

Operand 3: OMP_FOR_COND is vector containing loop
conditional expressions of the form VAR {<,>,<=,>=,!=} N2.

Operand 4: OMP_FOR_INCR is a vector containing loop index
increment expressions of the form VAR {+=,-=} INCR.

Operand 5: OMP_FOR_PRE_BODY contains side effect code from
operands OMP_FOR_INIT, OMP_FOR_COND and
OMP_FOR_INCR.  These side effects are part of the
OMP_FOR block but must be evaluated before the start of
loop body.  OMP_FOR_PRE_BODY specifically
includes DECL_EXPRs for iteration variables that are
declared in the nested for loops.
Note this field is not a vector; it may be null, but otherwise is
usually a statement list collecting the side effect code from all
the collapsed loops.

Operand 6: OMP_FOR_ORIG_DECLS holds VAR_DECLS for the
original user-specified iterator variables in the source code.
In some cases, like C++ class iterators or range for with
decomposition, the for loop is rewritten by the front end to
use a temporary iteration variable.  The purpose of this field is to
make the original variables available to the gimplifier so it can
adjust their data-sharing attributes and diagnose errors.
OMP_FOR_ORIG_DECLS is a vector field, with each element holding
a list of VAR_DECLS for the corresponding collapse level.

The loop index variable VAR must be an integer variable,
which is implicitly private to each thread.  For rectangular loops,
the bounds N1 and N2 and the increment expression
INCR are required to be loop-invariant integer expressions
that are evaluated without any synchronization.  The evaluation order,
frequency of evaluation and side effects are otherwise unspecified
by the standard.

For non-rectangular loops, in which the bounds of an inner loop depend
on the index of an outer loop, the bit OMP_FOR_NON_RECTANGULAR
must be set.  In this case N1 and N2 are not ordinary
expressions, but instead a TREE_VEC with three elements:
the DECL for the outer loop variable, a multiplication
factor, and an offset.  
OpenMP - #pragma omp simd [clause1 ... clauseN]
Operands like for OMP_FOR.   
OpenMP - #pragma omp distribute [clause1 ... clauseN]
Operands like for OMP_FOR.   
OpenMP - #pragma omp taskloop [clause1 ... clauseN]
Operands like for OMP_FOR.   
OpenMP - #pragma omp loop [clause1 ... clauseN]
Operands like for OMP_FOR.   
OpenMP - #pragma omp tile [clause1 ... clauseN]
Operands like for OMP_FOR.   
OpenMP - #pragma omp unroll [clause1 ... clauseN]
Operands like for OMP_FOR.   
OpenACC - #pragma acc loop [clause1 ... clauseN]
Operands like for OMP_FOR.   
OpenMP - #pragma omp teams [clause1 ... clauseN]
Operand 0: OMP_TEAMS_BODY: Teams body.
Operand 1: OMP_TEAMS_CLAUSES: List of clauses.   
OpenMP - #pragma omp target data [clause1 ... clauseN]
Operand 0: OMP_TARGET_DATA_BODY: Target data construct body.
Operand 1: OMP_TARGET_DATA_CLAUSES: List of clauses.   
OpenMP - #pragma omp target [clause1 ... clauseN]
Operand 0: OMP_TARGET_BODY: Target construct body.
Operand 1: OMP_TARGET_CLAUSES: List of clauses.   
OpenMP - #pragma omp sections [clause1 ... clauseN]
Operand 0: OMP_SECTIONS_BODY: Sections body.
Operand 1: OMP_SECTIONS_CLAUSES: List of clauses.   
OpenMP - #pragma omp ordered
Operand 0: OMP_ORDERED_BODY: Master section body.
Operand 1: OMP_ORDERED_CLAUSES: List of clauses.   
OpenMP - #pragma omp critical [name]
Operand 0: OMP_CRITICAL_BODY: Critical section body.
Operand 1: OMP_CRITICAL_CLAUSES: List of clauses.
Operand 2: OMP_CRITICAL_NAME: Identifier for critical section.   
OpenMP - #pragma omp single
Operand 0: OMP_SINGLE_BODY: Single section body.
Operand 1: OMP_SINGLE_CLAUSES: List of clauses.   
OpenMP - #pragma omp scope
Operand 0: OMP_SCOPE_BODY: Masked section body.
Operand 1: OMP_SCOPE_CLAUSES: List of clauses.   
OpenMP - #pragma omp taskgroup
Operand 0: OMP_TASKGROUP_BODY: Taskgroup body.
Operand 1: OMP_SINGLE_CLAUSES: List of clauses.   
OpenMP - #pragma omp masked
Operand 0: OMP_MASKED_BODY: Masked section body.
Operand 1: OMP_MASKED_CLAUSES: List of clauses.   
OpenMP - #pragma omp scan
Operand 0: OMP_SCAN_BODY: Scan body.
Operand 1: OMP_SCAN_CLAUSES: List of clauses.   
OpenMP - #pragma omp dispatch [clause1 ... clauseN]
Operand 0: OMP_DISPATCH_BODY: Expression statement including a target call.
Operand 1: OMP_DISPATCH_CLAUSES: List of clauses.   
OpenMP - #pragma omp interop [clause1 ... clauseN]
Operand 0: OMP_INTEROP_CLAUSES: List of clauses.   
OpenMP - #pragma omp section
Operand 0: OMP_SECTION_BODY: Section body.   
OpenMP structured block sequences that don't correspond to the body
another directive.  This is used for code fragments within the body
of a directive that are separately required to be structured block
sequence; in particular, for intervening code sequences in
imperfectly-nested loops.
Operand 0: BODY: contains the statement(s) within the structured block
sequence.   
OpenMP - #pragma omp master
Operand 0: OMP_MASTER_BODY: Master section body.   
OpenMP - #pragma omp declare mapper ([id:] type var) [clause1 ... clauseN]
Operand 0: Identifier.
Operand 1: Variable decl.
Operand 2: List of clauses.
The type of the construct is used for the type to be mapped.   
OpenACC - #pragma acc cache (variable1 ... variableN)
Operand 0: OACC_CACHE_CLAUSES: List of variables (transformed into
     OMP_CLAUSE__CACHE_ clauses).   
OpenACC - #pragma acc declare [clause1 ... clauseN]
Operand 0: OACC_DECLARE_CLAUSES: List of clauses.   
OpenACC - #pragma acc enter data [clause1 ... clauseN]
Operand 0: OACC_ENTER_DATA_CLAUSES: List of clauses.   
OpenACC - #pragma acc exit data [clause1 ... clauseN]
Operand 0: OACC_EXIT_DATA_CLAUSES: List of clauses.   
OpenACC - #pragma acc update [clause1 ... clauseN]
Operand 0: OACC_UPDATE_CLAUSES: List of clauses.   
OpenMP - #pragma omp target update [clause1 ... clauseN]
Operand 0: OMP_TARGET_UPDATE_CLAUSES: List of clauses.   
OpenMP - #pragma omp target enter data [clause1 ... clauseN]
Operand 0: OMP_TARGET_ENTER_DATA_CLAUSES: List of clauses.   
OpenMP - #pragma omp target exit data [clause1 ... clauseN]
Operand 0: OMP_TARGET_EXIT_DATA_CLAUSES: List of clauses.   
OpenMP - #pragma omp metadirective [variant1 ... variantN]
Operand 0: OMP_METADIRECTIVE_VARIANTS: List of selectors and directive
variants.  The variants are internally TREE_LISTs, but use
make_omp_metadirective_variant to build them.   
OMP_ATOMIC through OMP_ATOMIC_CAPTURE_NEW must be consecutive,
or OMP_ATOMIC_SEQ_CST needs adjusting.   
OpenMP - #pragma omp atomic
Operand 0: The address at which the atomic operation is to be performed.
     This address should be stabilized with save_expr.
Operand 1: The expression to evaluate.  When the old value of the object
     at the address is used in the expression, it should appear as if
     build_fold_indirect_ref of the address.   
OpenMP - #pragma omp atomic read
Operand 0: The address at which the atomic operation is to be performed.
     This address should be stabilized with save_expr.   
OpenMP - #pragma omp atomic capture
Operand 0: The address at which the atomic operation is to be performed.
     This address should be stabilized with save_expr.
Operand 1: The expression to evaluate.  When the old value of the object
     at the address is used in the expression, it should appear as if
     build_fold_indirect_ref of the address.
OMP_ATOMIC_CAPTURE_OLD returns the old memory content,
OMP_ATOMIC_CAPTURE_NEW the new value.   
OpenMP clauses.   
An OpenMP array section.   
OpenMP variant construct selector, used only in the middle end in the
expansions of variant constructs that can't be resolved until the
ompdevlow pass.  These variants are converted into switch expressions
that use OMP_NEXT_VARIANT as a placeholder for the index of next variant
to try if a dynamic selector does not match.  The ompdevlow pass
replaces these nodes with constant integers after resolution.
Operand 0: OMP_NEXT_VARIANT_INDEX: an INTEGER_CST holding the switch
index of the current variant.
Operand 1: OMP_NEXT_VARIANT_STATE: a TREE_LIST that is shared among all
OMP_NEXT_VARIANT expressions for the same variant directive.  The
TREE_PURPOSE of this node holds the resolved lookup table, while
TREE_VALUE holds the saved construct context and TREE_CHAIN the
original vector of selectors that are used to fill in the table.   
OpenMP target_device match placeholder, similarly used only in the middle
end in the expansions of variant constructs that need to be resolved in
the ompdevlow pass.
Operand 0: OMP_TARGET_DEVICE_MATCHES_SELECTOR: INTEGER_CST encoding one
of OMP_TRAIT_DEVICE_KIND, OMP_TRAIT_DEVICE_ARCH, or OMP_TRAIT_DEVICE_ISA.
Operand 1: OMP_TARGET_DEVICE_MATCHES_PROPERTIES: A TREE_LIST of strings
and/or identifiers, corresponding to the OMP_TS_PROPERTIES for the trait
selector.
This resolves to a boolean truth value if the properties match the
trait selector for the offload compiler.   
TRANSACTION_EXPR tree code.
Operand 0: BODY: contains body of the transaction.   
Widening dot-product.
The first two arguments are of type t1.
The third argument and the result are of type t2, such that t2 is at least
twice the size of t1. DOT_PROD_EXPR(arg1,arg2,arg3) is equivalent to:
        tmp = WIDEN_MULT_EXPR(arg1, arg2);
        arg3 = PLUS_EXPR (tmp, arg3);
or:
     tmp = WIDEN_MULT_EXPR(arg1, arg2);
     arg3 = WIDEN_SUM_EXPR (tmp, arg3);           
Widening summation.
The first argument is of type t1.
The second argument is of type t2, such that t2 is at least twice
the size of t1. The type of the entire expression is also t2.
WIDEN_SUM_EXPR is equivalent to first widening (promoting)
the first argument from type t1 to type t2, and then summing it
with the second argument.   
Widening sad (sum of absolute differences).
 The first two arguments are of type t1 which should be a vector of integers.
 The third argument and the result are of type t2, such that the size of
 the elements of t2 is at least twice the size of the elements of t1.
 Like DOT_PROD_EXPR, SAD_EXPR (arg1,arg2,arg3) is
 equivalent to:
     tmp = IFN_VEC_WIDEN_MINUS_EXPR (arg1, arg2)
     tmp2 = ABS_EXPR (tmp)
     arg3 = PLUS_EXPR (tmp2, arg3)
or:
     tmp = IFN_VEC_WIDEN_MINUS_EXPR (arg1, arg2)
     tmp2 = ABS_EXPR (tmp)
     arg3 = WIDEN_SUM_EXPR (tmp2, arg3)

Widening multiplication.
The two arguments are of type t1 and t2, both integral types that
have the same precision, but possibly different signedness.
The result is of integral type t3, such that t3 is at least twice
the size of t1/t2. WIDEN_MULT_EXPR is equivalent to first widening
(promoting) the arguments from type t1 to type t3, and from t2 to
type t3 and then multiplying them.   
Widening multiply-accumulate.
The first two arguments are of type t1.
The third argument and the result are of type t2, such as t2 is at least
twice the size of t1.  t1 and t2 must be integral or fixed-point types.
The expression is equivalent to a WIDEN_MULT_EXPR operation
of the first two operands followed by an add or subtract of the third
operand.   
This is like the above, except in the final expression the multiply result
is subtracted from t3.   
Widening shift left.
The first operand is of type t1.
The second operand is the number of bits to shift by; it need not be the
same type as the first operand and result.
Note that the result is undefined if the second operand is larger
than or equal to the first operand's type size.
The type of the entire expression is t2, such that t2 is at least twice
the size of t1.
WIDEN_LSHIFT_EXPR is equivalent to first widening (promoting)
the first argument from type t1 to type t2, and then shifting it
by the second argument.   
Widening vector multiplication.
The two operands are vectors with N elements of size S. Multiplying the
elements of the two vectors will result in N products of size 2*S.
VEC_WIDEN_MULT_HI_EXPR computes the N/2 high products.
VEC_WIDEN_MULT_LO_EXPR computes the N/2 low products.   
Similarly, but return the even or odd N/2 products.   
Unpack (extract and promote/widen) the high/low elements of the input
vector into the output vector.  The input vector has twice as many
elements as the output vector, that are half the size of the elements
of the output vector.  This is used to support type promotion.  
Unpack (extract) the high/low elements of the input vector, convert
fixed point values to floating point and widen elements into the
output vector.  The input vector has twice as many elements as the output
vector, that are half the size of the elements of the output vector.   
Unpack (extract) the high/low elements of the input vector, convert
floating point values to integer and widen elements into the output
vector.  The input vector has twice as many elements as the output
vector, that are half the size of the elements of the output vector.   
Pack (demote/narrow and merge) the elements of the two input vectors
into the output vector using truncation/saturation.
The elements of the input vectors are twice the size of the elements of the
output vector.  This is used to support type demotion.   
Convert floating point values of the two input vectors to integer
and pack (narrow and merge) the elements into the output vector. The
elements of the input vector are twice the size of the elements of
the output vector.   
Convert fixed point values of the two input vectors to floating point
and pack (narrow and merge) the elements into the output vector. The
elements of the input vector are twice the size of the elements of
the output vector.   
Widening vector shift left in bits.
 Operand 0 is a vector to be shifted with N elements of size S.
 Operand 1 is an integer shift amount in bits.
 The result of the operation is N elements of size 2*S.
 VEC_WIDEN_LSHIFT_HI_EXPR computes the N/2 high results.
 VEC_WIDEN_LSHIFT_LO_EXPR computes the N/2 low results.

PREDICT_EXPR.  Specify hint for branch prediction.  The
PREDICT_EXPR_PREDICTOR specify predictor and PREDICT_EXPR_OUTCOME the
outcome (0 for not taken and 1 for taken).  Once the profile is guessed
all conditional branches leading to execution paths executing the
PREDICT_EXPR will get predicted by the specified predictor.   
OPTIMIZATION_NODE.  Node to store the optimization options.   
TARGET_OPTION_NODE.  Node to store the target specific options.   
ANNOTATE_EXPR.
Operand 0 is the expression to be annotated.
Operand 1 is the annotation kind.
Operand 2 is additional data.   
This file contains the definitions and documentation for the
   builtins used in the GNU compiler.
   Copyright (C) 2000-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
Before including this file, you should define a macro:

  DEF_BUILTIN (ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P,
               FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT, COND)

This macro will be called once for each builtin function.  The
ENUM will be of type `enum built_in_function', and will indicate
which builtin function is being processed.  The NAME of the builtin
function (which will always start with `__builtin_') is a string
literal.  The CLASS is of type `enum built_in_class' and indicates
what kind of builtin is being processed.

Some builtins are actually two separate functions.  For example,
for `strcmp' there are two builtin functions; `__builtin_strcmp'
and `strcmp' itself.  Both behave identically.  Other builtins
define only the `__builtin' variant.  If BOTH_P is TRUE, then this
builtin has both variants; otherwise, it is has only the first
variant.

TYPE indicates the type of the function.  The symbols correspond to
enumerals from builtin-types.def.  If BOTH_P is true, then LIBTYPE
is the type of the non-`__builtin_' variant.  Otherwise, LIBTYPE
should be ignored.

If FALLBACK_P is true then, if for some reason, the compiler cannot
expand the builtin function directly, it will call the
corresponding library function (which does not have the
`__builtin_' prefix.

If NONANSI_P is true, then the non-`__builtin_' variant is not an
ANSI/ISO library function, and so we should pretend it does not
exist when compiling in ANSI conformant mode.

ATTRs is an attribute list as defined in builtin-attrs.def that
describes the attributes of this builtin function.

IMPLICIT specifies condition when the builtin can be produced by
compiler.  For instance C90 reserves floorf function, but does not
define it's meaning.  When user uses floorf we may assume that the
floorf has the meaning we expect, but we can't produce floorf by
simplifying floor((double)float) since the runtime need not implement
it.

The builtins is registered only if COND is true.   
A GCC builtin (like __builtin_saveregs) is provided by the
compiler, but does not correspond to a function in the standard
library.   
Like DEF_GCC_BUILTIN, except we don't prepend "__builtin_".   
A set of GCC builtins for _FloatN and _FloatNx types.  TYPE_MACRO
is called with an argument such as FLOAT32 to produce the enum
value for the type.   
A library builtin (like __builtin_strchr) is a builtin equivalent
of an ANSI/ISO standard library function.  In addition to the
`__builtin' version, we will create an ordinary version (e.g,
`strchr') as well.  If we cannot compute the answer using the
builtin function, we will fall back to the standard library
version.   
Like DEF_LIB_BUILTIN, except that the function is not one that is
specified by ANSI/ISO C.  So, when we're being fully conformant we
ignore the version of these builtins that does not begin with
__builtin.   
A set of GCC builtins for _FloatN and _FloatNx types.  TYPE_MACRO is called
with an argument such as FLOAT32 to produce the enum value for the type.  If
we are compiling for the C language with GNU extensions, we enable the name
without the __builtin_ prefix as well as the name with the __builtin_
prefix.  C++ does not enable these names by default because a class based
library should use the __builtin_ names.   
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C94 or above.   
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C99 or above.   
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C11 or above.   
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C23 or above.   
Like DEF_LIB_BUILTIN, except that the function is only a part of
the standard in C2Y or above.   
Like DEF_C99_BUILTIN, but for complex math functions.   
Builtin that is specified by C99 and C90 reserve the name for future use.
We can still recognize the builtin in C90 mode but we can't produce it
implicitly.   
Builtin that C99 reserve the name for future use. We can still recognize
the builtin in C99 mode but we can't produce it implicitly.   
Allocate the enum and the name for a builtin, but do not actually
define it here at all.   
Builtins used in implementing coroutine support.  
Builtin used by the implementation of OpenACC and OpenMP.  Few of these are
actually implemented in the compiler; most are in libgomp.   
Set NONANSI_P = false to enable the builtins also with -fno-nonansi-builtins,
esp. as -std=c++../c.. imply that flag and -fopenacc should be othogonal.   
Set NONANSI_P = false to enable the builtins also with -fno-nonansi-builtins,
esp. as -std=c++../c.. imply that flag and -fopenmp should be othogonal.   
Builtin used by the implementation of GNU TM.  These
functions are mapped to the actual implementation of the STM library.  
Builtin used by the implementation of libsanitizer. These
functions are mapped to the actual implementation of the
libtsan library.  
Define an attribute list for math functions that are normally
"impure" because some of them may write into global memory for
`errno'.  If !flag_errno_math they are instead "const".   
Define an attribute list for math functions that are normally
"const" but if flag_rounding_math is set they are instead "pure".
This distinction accounts for the fact that some math functions
check the rounding mode which is akin to examining global
memory.   
Define an attribute list for math functions that are normally
"impure" because some of them may write into global memory for
`errno'.  If !flag_errno_math, we can possibly use "pure" or
"const" depending on whether we care about FP rounding.   
Define an attribute list for math functions that need to mind FP
rounding, but because they store into memory they are never "const"
or "pure".  Use of this macro is mainly for documentation and
maintenance purposes.   
Define an attribute list for leaf functions that do not throw
exceptions normally, but may throw exceptions when using
-fnon-call-exceptions.   
Make sure 0 is not a legitimate builtin.   
Category: math builtins.   
Category: _Complex math builtins.   
Category: string/memory builtins.   
Category: stdio builtins.   
Category: ctype builtins.   
Category: wctype builtins.   
Category: integer overflow checking builtins.   
Clang compatibility.   
Category: miscellaneous builtins.   
[trans-mem]: Adjust BUILT_IN_TM_CALLOC if BUILT_IN_CALLOC is changed.   
[trans-mem]: Adjust BUILT_IN_TM_FREE if BUILT_IN_FREE is changed.   
[trans-mem]: Adjust BUILT_IN_TM_MALLOC if BUILT_IN_MALLOC is changed.   
Implementing nested functions.   
Implementing __builtin_setjmp.   
Implementing variable sized local variables.   
An internal version of memcmp, used when the result is only tested for
equality with zero.   
An internal version of strcmp/strncmp, used when the result is only
tested for equality with zero.   
Object size checking builtins.   
Profiling hooks.   
TLS thread pointer related builtins.   
TLS emulation.   
Suppressing speculation.  Users are expected to use the first (N)
variant, which will be translated internally into one of the other
types.   
Exception support.   
__FILE__, __LINE__, __FUNCTION__ as builtins.   
Control Flow Redundancy hardening out-of-line checker.   
Synchronization Primitives.   
This file contains the definitions and documentation for the
   synchronization builtins used in the GNU compiler.
   Copyright (C) 2005-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
Before including this file, you should define a macro:

  DEF_SYNC_BUILTIN (ENUM, NAME, TYPE, ATTRS)

See builtins.def for details.   
Synchronization Primitives.  The "_N" version is the one that the user
is supposed to be using.  It's overloaded, and is resolved to one of the
"_1" through "_16" versions, plus some extra casts.   
__sync* builtins for the C++ memory model.   
This one is actually a function in libatomic and not expected to be
inlined, declared here for convenience of targets generating calls
to it.   
Offloading and Multi Processing builtins.   
This file contains the definitions and documentation for the
   Offloading and Multi Processing builtins used in the GNU compiler.
   Copyright (C) 2005-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
Before including this file, you should define a macro:

  DEF_GOACC_BUILTIN (ENUM, NAME, TYPE, ATTRS)
  DEF_GOACC_BUILTIN_COMPILER (ENUM, NAME, TYPE, ATTRS)
  DEF_GOMP_BUILTIN (ENUM, NAME, TYPE, ATTRS)
  DEF_GOMP_BUILTIN_COMPILER (ENUM, NAME, TYPE, ATTRS)

See builtins.def for details.   
The reason why they aren't in gcc/builtins.def is that the Fortran front end
doesn't source those.   
NOTE: Do not change the order of BUILT_IN_GOMP_LOOP_*_START.  They
are used in index arithmetic with enum omp_clause_schedule_kind
in omp-low.cc.   
NOTE: Do not change the order of BUILT_IN_GOMP_PARALLEL_LOOP_*.
They are used in index arithmetic with enum omp_clause_schedule_kind
in omp-low.cc.   
GTM builtins.  
Memory allocation builtins.   
Logging builtins.   
These stubs should get defined in the backend if applicable.   
Writes.

Note: The writes must follow the following order: STORE, WAR, WAW.
The TM optimizations depend on this order.

BUILT_IN_TM_STORE_1 must be the first builtin.
BUILTIN_TM_LOAD_STORE_P depends on this.   
These stubs should get defined in the backend if applicable.   
Note: BUILT_IN_TM_STORE_WAW_LDOUBLE must be the last TM store.
BUILTIN_TM_STORE_P depends on this.   
Reads.

Note: The reads must follow the following order: LOAD, RAR, RAW, RFW.
The TM optimizations depend on this order.   
These stubs should get defined in the backend if applicable.   
Note: BUILT_IN_TM_LOAD_RFW_LDOUBLE must be the last TM load as well
as the last builtin.  BUILTIN_TM_LOAD_STORE_P and BUILTIN_TM_LOAD_P
depend on this.   
Sanitizer builtins.  
This file contains the definitions and documentation for the
   Address Sanitizer and Thread Sanitizer builtins used in the GNU compiler.
   Copyright (C) 2012-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
Before including this file, you should define a macro:

  DEF_BUILTIN_STUB(ENUM, NAME)
  DEF_SANITIZER_BUILTIN (ENUM, NAME, TYPE, ATTRS)

See builtins.def for details.
The builtins are created by the C-family of FEs in c-family/c-common.cc,
for other FEs by asan.cc.   
This has to come before all the sanitizer builtins.   
Address Sanitizer  
Do not reorder the BUILT_IN_ASAN_{REPORT,CHECK}* builtins, e.g. cfgcleanup.cc
relies on this order.   
Hardware Address Sanitizer.   
Thread Sanitizer  
Undefined Behavior Sanitizer  
Sanitizer coverage  
This has to come after all the sanitizer builtins.   
Coroutine builtins.   
This file contains the definitions and documentation for the
   coroutines builtins used in GCC.

   Copyright (C) 2018-2025 Free Software Foundation, Inc.

 Contributed by Iain Sandoe <iain@sandoe.co.uk> under contract to Facebook.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
Before including this file, you should define a macro:

  DEF_BUILTIN_STUB(ENUM, NAME)
  DEF_COROUTINE_BUILTIN (ENUM, NAME, TYPE, ATTRS)

See builtins.def for details.
The builtins are created used by library implementations of C++
coroutines.   
This has to come before all the coroutine builtins.   
These are the builtins that are externally-visible and used by the
standard library implementation of the coroutine header.   
This has to come after all the coroutine builtins.   
Internal functions.
   Copyright (C) 2011-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file specifies a list of internal "functions".  These functions
differ from built-in functions in that they have no linkage and cannot
be called directly by the user.  They represent operations that are only
synthesised by GCC itself.

Internal functions are used instead of tree codes if the operation
and its operands are more naturally represented as a GIMPLE_CALL
than a GIMPLE_ASSIGN.

Each entry in this file has one of the forms:

  DEF_INTERNAL_FN (NAME, FLAGS, FNSPEC)
  DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SIGNED_OPTAB,
                           UNSIGNED_OPTAB, TYPE)
  DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_FLT_FLOATN_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_EXT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_WIDENING_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB,
                             TYPE)

where NAME is the name of the function, FLAGS is a set of
ECF_* flags and FNSPEC is a string describing functions fnspec.

DEF_INTERNAL_OPTAB_FN defines an internal function that maps to a
direct optab.  The function should only be called with a given
set of types if the associated optab is available for the modes
of those types.  OPTAB says what optab to use (without the trailing
"_optab") and TYPE categorizes the optab based on its inputs and
outputs.  The possible types of optab are:

- mask_load: currently just maskload
- load_lanes: currently just vec_load_lanes
- mask_load_lanes: currently just vec_mask_load_lanes
- mask_len_load_lanes: currently just vec_mask_len_load_lanes
- gather_load: used for {mask_,mask_len_,}gather_load
- strided_load: currently just mask_len_strided_load
- len_load: currently just len_load
- mask_len_load: currently just mask_len_load

- mask_store: currently just maskstore
- store_lanes: currently just vec_store_lanes
- mask_store_lanes: currently just vec_mask_store_lanes
- mask_len_store_lanes: currently just vec_mask_len_store_lanes
- scatter_store: used for {mask_,mask_len_,}scatter_store
- strided_store: currently just mask_len_strided_store
- len_store: currently just len_store
- mask_len_store: currently just mask_len_store

- unary: a normal unary optab, such as vec_reverse_<mode>
- binary: a normal binary optab, such as vec_interleave_lo_<mode>
- ternary: a normal ternary optab, such as fma<mode>4

- unary_convert: a single-input conversion optab, such as
  lround<srcmode><dstmode>2.

- cond_binary: a conditional binary optab, such as cond_add<mode>
- cond_unary: a conditional unary optab, such as cond_neg<mode>
- cond_ternary: a conditional ternary optab, such as cond_fma_rev<mode>

- fold_left: for scalar = FN (scalar, vector), keyed off the vector mode
- check_ptrs: used for check_{raw,war}_ptrs

- cond_len_unary: a conditional unary optab, such as cond_len_neg<mode>
- cond_len_binary: a conditional binary optab, such as cond_len_add<mode>
- cond_len_ternary: a conditional ternary optab, such as
cond_len_fma_rev<mode>

DEF_INTERNAL_SIGNED_OPTAB_FN defines an internal function that
maps to one of two optabs, depending on the signedness of an input.
SIGNED_OPTAB and UNSIGNED_OPTAB are the optabs for signed and
unsigned inputs respectively, both without the trailing "_optab".
SELECTOR says which type in the tree_pair determines the signedness.

DEF_INTERNAL_FLT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition,
the function implements the computational part of a built-in math
function BUILT_IN_<NAME>{F,,L}.  Unlike some built-in functions,
these internal functions never set errno.

DEF_INTERNAL_INT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition
says that the function extends the C-level BUILT_IN_<NAME>{,L,LL,IMAX}
group of functions to any integral mode (including vector modes).

DEF_INTERNAL_INT_EXT_FN is like DEF_INTERNAL_INT_FN, except that it
has expand_##NAME defined in internal-fn.cc to override the
DEF_INTERNAL_INT_FN expansion behavior.

DEF_INTERNAL_WIDENING_OPTAB_FN is a wrapper that defines five internal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN:
- one that describes a widening operation with the same number of elements
in the output and input vectors,
- two that describe a pair of high-low widening operations where the output
vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the top half and
bottom half, these have the suffixes _HI and _LO,
- and two that describe a pair of even-odd widening operations where the
output vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the even and odd
elements, these have the suffixes _EVEN and _ODD.
These five internal functions will require two optabs each, a SIGNED_OPTAB
and an UNSIGNED_OTPAB.

DEF_INTERNAL_COND_FN is a wrapper that defines 2 internal functions with
DEF_INTERNAL_OPTAB_FN:
- One is COND_* operations that are predicated by mask only. Such operations
  make sense for both vectors and scalars.
- The other is COND_LEN_* operations that are predicated by mask and len
  both. Such operations only make sense for vectors.

DEF_INTERNAL_SIGNED_COND_FN is like DEF_INTERNAL_COND_FN but defines intenal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN.

Each entry must have a corresponding expander of the form:

  void expand_NAME (gimple_call stmt)

where STMT is the statement that performs the call.  These are generated
automatically for optab functions and call out to a function or macro
called expand_<TYPE>_optab_fn.   
Extract the last active element from a vector.   
Same, but return the first argument if no elements are active.   
Unary math functions.   
Floating-point to integer conversions.

??? Here we preserve the I/L/LL prefix convention from the
corresponding built-in functions, rather than make the internal
functions polymorphic in both the argument and the return types.
Perhaps an alternative would be to pass a zero of the required
return type as a second parameter.   
FP rounding.   
Binary math functions.   
FP scales.   
Ternary math functions.   
Unary integer ops.   
An unduplicable, uncombinable function.  Generally used to preserve
a CFG property in the face of jump threading, tail merging or
other such optimizations.  The first argument distinguishes
between uses.  See internal-fn.h for usage.   
A function to represent an artifical initialization to an uninitialized
automatic variable.   
A function to associate the access size and access mode information
with the corresponding reference to an object.  It only reads from the
2nd argument.   
DIM_SIZE and DIM_POS return the size of a particular compute
dimension and the executing thread's position within that
dimension.  DIM_POS is pure (and not const) so that it isn't
thought to clobber memory and can be gcse'd within a single
parallel region, but not across FORK/JOIN boundaries.  They take a
single INTEGER_CST argument.  This might be overly conservative.   
OpenACC looping abstraction.  See internal-fn.h for usage.   
OpenACC reduction abstraction.  See internal-fn.h  for usage.   
Openacc tile abstraction. Describes the spans of the element loop.
GOACC_TILE (num-loops, loop-no, tile-arg, tile-mask, element-mask).   
Set errno to EDOM, if GCC knows how to do that directly for the
current target.   
Atomic functions.  These don't have ECF_NOTHROW because for
-fnon-call-exceptions they can throw, otherwise we set
gimple_call_nothrow_p on it.   
To implement [[fallthrough]].  If the TREE_NOTHROW or GF_CALL_NOTHROW flag
is set on the call (normally redundant with ECF_NOTHROW), it marks
[[fallthrough]] at the end of C++ loop body.   
To implement __builtin_launder.   
Divmod function.   
For coroutines.   
A NOP function with arbitrary arguments and return value.   
Temporary vehicle for __builtin_shufflevector.   
<=> optimization.   
[[assume (cond)]].   
For if-conversion of inbranch SIMD clones.   
_BitInt support.   
Bitwise functions.

References choose_output(), define_dump_logs(), diagnostic_cb(), fopen, decision_tree::gen(), genmatch_diag_selftests(), header_file, i, decision_tree::insert(), line_table, lower(), predicate_id::matchers, NULL, id_base::NULL_ID, null_id, operators, decision_tree::print(), print_matches(), progname, r, round_alloc_size(), parser::simplifiers, usage(), parser::user_predicates, verbose, write_header(), write_header_declarations(), write_header_includes(), and write_predicate().

â—† operator==()

bool operator== ( id_base & id,
enum tree_code code )
static 
Helper for easy comparing ID with tree code CODE.

References dyn_cast().

â—† output_line_directive()

void output_line_directive ( FILE * f,
location_t location,
bool dumpfile = false,
bool fnargs = false,
bool indirect_line_numbers = false )
static

References dbg_line_numbers, DIR_SEPARATOR, hash_map< KeyId, Value, Traits >::get_or_insert(), line_table, location_hash, map, and verbose.

Referenced by emit_logging_call(), decision_tree::gen(), dt_simplify::gen(), and dt_simplify::gen_1().

â—† possible_noop_convert()

bool possible_noop_convert ( id_base * op)

Referenced by dt_simplify::gen_1(), and expr::gen_transform().

â—† print_matches()

DEBUG_FUNCTION void print_matches ( class simplify * s,
FILE * f = stderr )

References simplify::match, and print_operand().

Referenced by main().

â—† print_operand()

DEBUG_FUNCTION void print_operand ( operand * o,
FILE * f = stderr,
bool flattened = false ) 
Debugging routines for dumping the AST.

References dyn_cast(), is_a(), and print_operand().

Referenced by dt_node::append_simplify(), print_matches(), decision_tree::print_node(), and print_operand().

â—† replace_id()

operand * replace_id ( operand * o,
user_id * id,
id_base * with ) 
In AST operand O replace operator ID with operator WITH.

References expr::append_op(), as_a(), c_expr::c_expr(), if_expr::cond, dyn_cast(), if_expr::falseexpr, i, id_base::id, c_expr::ids, expr::operation, expr::ops, replace_id(), with_expr::subexpr, if_expr::trueexpr, and with_expr::with.

Referenced by lower_for(), and replace_id().

â—† round_alloc_size()

size_t round_alloc_size ( size_t s)
static 
Helper for the linemap code.

Referenced by main().

â—† swap_tree_comparison()

id_base * swap_tree_comparison ( operator_id * p) 
Return the comparison operators that results if the operands are
swapped.  This is safe for floating-point.

References operator_id::code.

â—† usage()

void usage ( void )
static 
Construct and display the help menu.

References progname, and usage().

Referenced by main().

â—† walk_captures()

void walk_captures ( operand * op,
vec< vec< capture * > > & cpts )
static 
Helper for finish_match_operand, collecting captures of OP in CPTS
recursively.

References dyn_cast(), i, expr::ops, and walk_captures().

Referenced by parser::finish_match_operand(), and walk_captures().

â—† warning_at() [1/2]

void warning_at ( const cpp_token * tk,
const char * msg,
... )
static

References ap, diagnostic_cb(), line_table, msg, and NULL.

Referenced by dt_node::append_simplify(), decision_tree::find_node(), dt_simplify::gen_1(), parser::parse_for(), capture_info::walk_c_expr(), and capture_info::walk_match().

â—† warning_at() [2/2]

void warning_at ( location_t loc,
const char * msg,
... )
static

References ap, diagnostic_cb(), line_table, msg, and NULL.

â—† write_header()

void write_header ( FILE * f,
const char * head )
static 
Write the common header for the GIMPLE/GENERIC IL matching routines.

â—† write_header_declarations()

void write_header_declarations ( bool gimple,
FILE * f )
static

Referenced by main().

â—† write_header_includes()

void write_header_includes ( bool gimple,
FILE * header_file )
static 
Write out the correct include to the match-head fle containing the helper
files.

References header_file.

Referenced by main().

â—† write_predicate()

void write_predicate ( FILE * f,
predicate_id * p,
decision_tree & dt,
bool gimple ) 
Output code to implement the predicate P from the decision tree DT.

References fp_decl(), fp_decl_done(), fprintf_indent(), dt_node::gen_kids(), id_base::id, id_base::nargs, and decision_tree::root.

Referenced by main().

Variable Documentation

â—† current_id

unsigned current_id
static 
Current simplifier ID we are processing during insertion into the
decision tree.

Referenced by create_new_chain(), dt_operand::dt_operand(), decision_tree::find_node(), decision_tree::insert(), and regrename_analyze().

â—† dbg_line_numbers

vec<int> dbg_line_numbers
static 
Line numbers for use by indirect line directives.

Referenced by define_dump_logs(), and output_line_directive().

â—† fail_label

char* fail_label
static 
The current label failing the current matched pattern during
code generation.

Referenced by compare_by_pieces(), compare_by_pieces_d::compare_by_pieces_d(), dt_simplify::gen_1(), expr::gen_transform(), and match_rtx().

â—† header_file

FILE* header_file
static 
Secondary stream for fp_decl.

â—† line_table

class line_maps* line_table
static 
libccp helpers.

Referenced by simple_diagnostic_path::add_event(), simple_diagnostic_path::add_thread_event(), diagnostic_text_output_format::append_note(), lto_location_cache::apply_location_cache(), debug(), diagnostic_cb(), diagnostic_for_asm(), diagnostic_output_format_init(), dump_line_table_statistics(), dump_location_info(), emit_diagnostic(), emit_diagnostic_valist(), format_string_diagnostic_t::emit_warning_n_va(), error(), error_at(), error_n(), expand_location(), expand_location_to_spelling_point(), expansion_point_location(), expansion_point_location_if_in_system_header(), fatal_at(), fatal_at(), fatal_error(), fold_builtin_next_arg(), from_macro_definition_at(), from_macro_expansion_at(), gcc_rich_location::gcc_rich_location(), gcc_rich_location::gcc_rich_location(), c_expr::gen_transform(), general_init(), get_discriminator_from_loc(), get_expr_source_range(), get_finish(), get_pure_location(), get_start(), get_substring_ranges_for_loc(), gt_pch_restore(), handle_OPT_fdiagnostics_add_output_(), handle_OPT_fdiagnostics_set_output_(), in_system_header_at(), diagnostic_text_output_format::includes_seen_p(), inform(), inform_n(), internal_error(), internal_error_no_backtrace(), is_location_from_builtin_token(), location_with_discriminator(), main(), make_location(), make_location(), gcc::diagnostics_output_spec::html_scheme_handler::make_sink(), gcc::diagnostics_output_spec::sarif_scheme_handler::make_sink(), maybe_unwind_expanded_macro_loc(), optrecord_json_writer::optinfo_to_json(), output_line_directive(), pedwarn(), permerror(), permerror_opt(), diagnostic_text_output_format::report_current_module(), set_block(), diagnostic_manager::set_line_table_global(), sorry(), sorry_at(), diagnostic_option_classifier::update_effective_level_from_pragmas(), use_new_line(), warning(), warning_at(), warning_at(), warning_at(), diagnostic_context::warning_enabled_at(), and warning_n().

â—† null_id

id_base* null_id
static 
The special id "null", which matches nothing.

Referenced by get_operator(), lower_for(), and main().

â—† operators

hash_table<id_base>* operators
static 
Hashtable of known pattern operators.  This is pre-seeded from
all known tree codes and all known builtin function ids.

Referenced by add_function(), add_predicate(), get_operator(), main(), parser::parse_for(), and parser::parse_operator_list().

â—† verbose

unsigned verbose 
Global state.   
Verboseness.  0 is quiet, 1 adds some warnings, 2 is for debugging.

Referenced by dt_node::append_simplify(), decision_tree::find_node(), decision_tree::gen(), dt_simplify::gen_1(), capture_info::walk_c_expr(), and capture_info::walk_match().