GCC Middle and Back End API Reference
Data Structures | Macros | Typedefs | Enumerations
tree-core.h File Reference
#include "symtab.h"
#include "all-tree.def"
#include "builtins.def"
#include "internal-fn.def"
#include "treestruct.def"
Include dependency graph for tree-core.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  alias_pair
 
struct  tree_base
 
struct  tree_typed
 
struct  tree_common
 
struct  tree_int_cst
 
struct  tree_real_cst
 
struct  tree_fixed_cst
 
struct  tree_string
 
struct  tree_raw_data
 
struct  tree_complex
 
struct  tree_vector
 
struct  tree_poly_int_cst
 
struct  tree_identifier
 
struct  tree_list
 
struct  tree_vec
 
struct  constructor_elt
 
struct  tree_constructor
 
struct  tree_exp
 
struct  ssa_use_operand_t
 

Macros

#define ECF_CONST   (1 << 0)
 
#define ECF_PURE   (1 << 1)
 
#define ECF_LOOPING_CONST_OR_PURE   (1 << 2)
 
#define ECF_NORETURN   (1 << 3)
 
#define ECF_MALLOC   (1 << 4)
 
#define ECF_MAY_BE_ALLOCA   (1 << 5)
 
#define ECF_NOTHROW   (1 << 6)
 
#define ECF_RETURNS_TWICE   (1 << 7)
 
#define ECF_SIBCALL   (1 << 8)
 
#define ECF_NOVOPS   (1 << 9)
 
#define ECF_LEAF   (1 << 10)
 
#define ECF_RET1   (1 << 11)
 
#define ECF_TM_PURE   (1 << 12)
 
#define ECF_TM_BUILTIN   (1 << 13)
 
#define ECF_BY_DESCRIPTOR   (1 << 14)
 
#define ECF_COLD   (1 << 15)
 
#define ECF_XTHROW   (1 << 16)
 
#define EAF_UNUSED   (1 << 1)
 
#define EAF_NO_DIRECT_CLOBBER   (1 << 2)
 
#define EAF_NO_INDIRECT_CLOBBER   (1 << 3)
 
#define EAF_NO_DIRECT_ESCAPE   (1 << 4)
 
#define EAF_NO_INDIRECT_ESCAPE   (1 << 5)
 
#define EAF_NOT_RETURNED_DIRECTLY   (1 << 6)
 
#define EAF_NOT_RETURNED_INDIRECTLY   (1 << 7)
 
#define EAF_NO_DIRECT_READ   (1 << 8)
 
#define EAF_NO_INDIRECT_READ   (1 << 9)
 
#define ERF_RETURN_ARG_MASK   (3)
 
#define ERF_RETURNS_ARG   (1 << 2)
 
#define ERF_NOALIAS   (1 << 3)
 
#define DEFTREECODE(SYM, STRING, TYPE, NARGS)
 
#define END_OF_BASE_TREE_CODES   LAST_AND_UNUSED_TREE_CODE,
 
#define NUM_TREE_CODES    ((int) LAST_AND_UNUSED_TREE_CODE)
 
#define CODE_CONTAINS_STRUCT(CODE, STRUCT)
 
#define BUILT_IN_LAST   (BUILT_IN_NORMAL + 1)
 
#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 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 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 DEFTREESTRUCT(ENUM, NAME)
 
#define OMP_FAIL_MEMORY_ORDER_SHIFT   3
 
#define NUM_FLOATN_TYPES
 
#define NUM_FLOATNX_TYPES
 
#define NUM_FLOATN_NX_TYPES
 

Typedefs

typedef unsigned short priority_type
 
typedef tree(* walk_tree_fn) (tree *, int *, void *)
 
typedef tree(* walk_tree_lh) (tree *, int *, tree(*) (tree *, int *, void *), void *, hash_set< tree > *)
 

Enumerations

enum  tree_code { MAX_TREE_CODES }
 
enum  built_in_class { NOT_BUILT_IN = 0 , BUILT_IN_FRONTEND , BUILT_IN_MD , BUILT_IN_NORMAL }
 
enum  built_in_function {
  DEF_BUILTIN , BUILT_IN_COMPLEX_MUL_MAX , BUILT_IN_COMPLEX_DIV_MIN , BUILT_IN_COMPLEX_DIV_MAX ,
  END_BUILTINS
}
 
enum  internal_fn { DEF_INTERNAL_OPTAB_FN , DEF_INTERNAL_OPTAB_FN }
 
enum  combined_fn { DEF_BUILTIN , DEF_BUILTIN }
 
enum  tree_code_class {
  tcc_exceptional , tcc_constant , tcc_type , tcc_declaration ,
  tcc_reference , tcc_comparison , tcc_unary , tcc_binary ,
  tcc_statement , tcc_vl_exp , tcc_expression
}
 
enum  omp_clause_code {
  OMP_CLAUSE_ERROR = 0 , OMP_CLAUSE_PRIVATE , OMP_CLAUSE_SHARED , OMP_CLAUSE_FIRSTPRIVATE ,
  OMP_CLAUSE_LASTPRIVATE , OMP_CLAUSE_REDUCTION , OMP_CLAUSE_TASK_REDUCTION , OMP_CLAUSE_IN_REDUCTION ,
  OMP_CLAUSE_COPYIN , OMP_CLAUSE_COPYPRIVATE , OMP_CLAUSE_LINEAR , OMP_CLAUSE_AFFINITY ,
  OMP_CLAUSE_ALIGNED , OMP_CLAUSE_ALLOCATE , OMP_CLAUSE_DEPEND , OMP_CLAUSE_NONTEMPORAL ,
  OMP_CLAUSE_UNIFORM , OMP_CLAUSE_ENTER , OMP_CLAUSE_LINK , OMP_CLAUSE_DETACH ,
  OMP_CLAUSE_USE_DEVICE_PTR , OMP_CLAUSE_USE_DEVICE_ADDR , OMP_CLAUSE_IS_DEVICE_PTR , OMP_CLAUSE_INCLUSIVE ,
  OMP_CLAUSE_EXCLUSIVE , OMP_CLAUSE_FROM , OMP_CLAUSE_TO , OMP_CLAUSE_MAP ,
  OMP_CLAUSE_HAS_DEVICE_ADDR , OMP_CLAUSE_DOACROSS , OMP_CLAUSE__CACHE_ , OMP_CLAUSE_DESTROY ,
  OMP_CLAUSE_INIT , OMP_CLAUSE_USE , OMP_CLAUSE_INTEROP , OMP_CLAUSE_GANG ,
  OMP_CLAUSE_ASYNC , OMP_CLAUSE_WAIT , OMP_CLAUSE_AUTO , OMP_CLAUSE_SEQ ,
  OMP_CLAUSE__LOOPTEMP_ , OMP_CLAUSE__REDUCTEMP_ , OMP_CLAUSE__CONDTEMP_ , OMP_CLAUSE__SCANTEMP_ ,
  OMP_CLAUSE_IF , OMP_CLAUSE_SELF , OMP_CLAUSE_NUM_THREADS , OMP_CLAUSE_SCHEDULE ,
  OMP_CLAUSE_NOWAIT , OMP_CLAUSE_ORDERED , OMP_CLAUSE_DEFAULT , OMP_CLAUSE_COLLAPSE ,
  OMP_CLAUSE_UNTIED , OMP_CLAUSE_FINAL , OMP_CLAUSE_MERGEABLE , OMP_CLAUSE_DEVICE ,
  OMP_CLAUSE_DIST_SCHEDULE , OMP_CLAUSE_INBRANCH , OMP_CLAUSE_NOTINBRANCH , OMP_CLAUSE_NUM_TEAMS ,
  OMP_CLAUSE_THREAD_LIMIT , OMP_CLAUSE_PROC_BIND , OMP_CLAUSE_SAFELEN , OMP_CLAUSE_SIMDLEN ,
  OMP_CLAUSE_DEVICE_TYPE , OMP_CLAUSE_FOR , OMP_CLAUSE_PARALLEL , OMP_CLAUSE_SECTIONS ,
  OMP_CLAUSE_TASKGROUP , OMP_CLAUSE_PRIORITY , OMP_CLAUSE_GRAINSIZE , OMP_CLAUSE_NUM_TASKS ,
  OMP_CLAUSE_NOGROUP , OMP_CLAUSE_THREADS , OMP_CLAUSE_SIMD , OMP_CLAUSE_HINT ,
  OMP_CLAUSE_DEFAULTMAP , OMP_CLAUSE_ORDER , OMP_CLAUSE_BIND , OMP_CLAUSE_FILTER ,
  OMP_CLAUSE_INDIRECT , OMP_CLAUSE_PARTIAL , OMP_CLAUSE_FULL , OMP_CLAUSE_SIZES ,
  OMP_CLAUSE__SIMDUID_ , OMP_CLAUSE__SIMT_ , OMP_CLAUSE_INDEPENDENT , OMP_CLAUSE_WORKER ,
  OMP_CLAUSE_VECTOR , OMP_CLAUSE_NUM_GANGS , OMP_CLAUSE_NUM_WORKERS , OMP_CLAUSE_VECTOR_LENGTH ,
  OMP_CLAUSE_TILE , OMP_CLAUSE_IF_PRESENT , OMP_CLAUSE_FINALIZE , OMP_CLAUSE_NOHOST ,
  OMP_CLAUSE_NOVARIANTS , OMP_CLAUSE_NOCONTEXT
}
 
enum  tree_node_structure_enum { LAST_TS_ENUM }
 
enum  omp_clause_schedule_kind {
  OMP_CLAUSE_SCHEDULE_STATIC , OMP_CLAUSE_SCHEDULE_DYNAMIC , OMP_CLAUSE_SCHEDULE_GUIDED , OMP_CLAUSE_SCHEDULE_AUTO ,
  OMP_CLAUSE_SCHEDULE_RUNTIME , OMP_CLAUSE_SCHEDULE_MASK = (1 << 3) - 1 , OMP_CLAUSE_SCHEDULE_MONOTONIC = (1 << 3) , OMP_CLAUSE_SCHEDULE_NONMONOTONIC = (1 << 4) ,
  OMP_CLAUSE_SCHEDULE_LAST = 2 * OMP_CLAUSE_SCHEDULE_NONMONOTONIC - 1
}
 
enum  omp_clause_default_kind {
  OMP_CLAUSE_DEFAULT_UNSPECIFIED , OMP_CLAUSE_DEFAULT_SHARED , OMP_CLAUSE_DEFAULT_NONE , OMP_CLAUSE_DEFAULT_PRIVATE ,
  OMP_CLAUSE_DEFAULT_FIRSTPRIVATE , OMP_CLAUSE_DEFAULT_PRESENT , OMP_CLAUSE_DEFAULT_LAST
}
 
enum  omp_clause_defaultmap_kind {
  OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED , OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL , OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR , OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE ,
  OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE , OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER , OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK = 7 , OMP_CLAUSE_DEFAULTMAP_ALLOC = 1 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1) ,
  OMP_CLAUSE_DEFAULTMAP_TO = 2 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1) , OMP_CLAUSE_DEFAULTMAP_FROM = 3 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1) , OMP_CLAUSE_DEFAULTMAP_TOFROM = 4 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1) , OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE = 5 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1) ,
  OMP_CLAUSE_DEFAULTMAP_NONE = 6 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1) , OMP_CLAUSE_DEFAULTMAP_DEFAULT = 7 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1) , OMP_CLAUSE_DEFAULTMAP_PRESENT = 8 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1) , OMP_CLAUSE_DEFAULTMAP_MASK = 15 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1)
}
 
enum  omp_clause_bind_kind { OMP_CLAUSE_BIND_TEAMS , OMP_CLAUSE_BIND_PARALLEL , OMP_CLAUSE_BIND_THREAD }
 
enum  omp_memory_order {
  OMP_MEMORY_ORDER_UNSPECIFIED , OMP_MEMORY_ORDER_RELAXED , OMP_MEMORY_ORDER_ACQUIRE , OMP_MEMORY_ORDER_RELEASE ,
  OMP_MEMORY_ORDER_ACQ_REL , OMP_MEMORY_ORDER_SEQ_CST , OMP_MEMORY_ORDER_MASK = 7 , OMP_FAIL_MEMORY_ORDER_UNSPECIFIED = OMP_MEMORY_ORDER_UNSPECIFIED * 8 ,
  OMP_FAIL_MEMORY_ORDER_RELAXED = OMP_MEMORY_ORDER_RELAXED * 8 , OMP_FAIL_MEMORY_ORDER_ACQUIRE = OMP_MEMORY_ORDER_ACQUIRE * 8 , OMP_FAIL_MEMORY_ORDER_RELEASE = OMP_MEMORY_ORDER_RELEASE * 8 , OMP_FAIL_MEMORY_ORDER_ACQ_REL = OMP_MEMORY_ORDER_ACQ_REL * 8 ,
  OMP_FAIL_MEMORY_ORDER_SEQ_CST = OMP_MEMORY_ORDER_SEQ_CST * 8 , OMP_FAIL_MEMORY_ORDER_MASK = OMP_MEMORY_ORDER_MASK * 8
}
 
enum  cv_qualifier {
  TYPE_UNQUALIFIED = 0x0 , TYPE_QUAL_CONST = 0x1 , TYPE_QUAL_VOLATILE = 0x2 , TYPE_QUAL_RESTRICT = 0x4 ,
  TYPE_QUAL_ATOMIC = 0x8
}
 
enum  tree_index : unsigned {
  TI_ERROR_MARK , TI_INTQI_TYPE , TI_INTHI_TYPE , TI_INTSI_TYPE ,
  TI_INTDI_TYPE , TI_INTTI_TYPE , TI_UINTQI_TYPE , TI_UINTHI_TYPE ,
  TI_UINTSI_TYPE , TI_UINTDI_TYPE , TI_UINTTI_TYPE , TI_ATOMICQI_TYPE ,
  TI_ATOMICHI_TYPE , TI_ATOMICSI_TYPE , TI_ATOMICDI_TYPE , TI_ATOMICTI_TYPE ,
  TI_UINT16_TYPE , TI_UINT32_TYPE , TI_UINT64_TYPE , TI_UINT128_TYPE ,
  TI_VOID , TI_INTEGER_ZERO , TI_INTEGER_ONE , TI_INTEGER_MINUS_ONE ,
  TI_NULL_POINTER , TI_SIZE_ZERO , TI_SIZE_ONE , TI_BITSIZE_ZERO ,
  TI_BITSIZE_ONE , TI_BITSIZE_UNIT , TI_PUBLIC , TI_PROTECTED ,
  TI_PRIVATE , TI_BOOLEAN_FALSE , TI_BOOLEAN_TRUE , TI_FLOAT_TYPE ,
  TI_DOUBLE_TYPE , TI_LONG_DOUBLE_TYPE , TI_BFLOAT16_TYPE , TI_FLOAT16_TYPE ,
  TI_FLOATN_TYPE_FIRST = TI_FLOAT16_TYPE , TI_FLOATN_NX_TYPE_FIRST = TI_FLOAT16_TYPE , TI_FLOAT32_TYPE , TI_FLOAT64_TYPE ,
  TI_FLOAT128_TYPE , TI_FLOATN_TYPE_LAST = TI_FLOAT128_TYPE , TI_FLOAT32X_TYPE , TI_FLOATNX_TYPE_FIRST = TI_FLOAT32X_TYPE ,
  TI_FLOAT64X_TYPE , TI_FLOAT128X_TYPE , TI_FLOATNX_TYPE_LAST = TI_FLOAT128X_TYPE , TI_FLOATN_NX_TYPE_LAST = TI_FLOAT128X_TYPE ,
  TI_FLOAT128T_TYPE , TI_COMPLEX_INTEGER_TYPE , TI_COMPLEX_FLOAT_TYPE , TI_COMPLEX_DOUBLE_TYPE ,
  TI_COMPLEX_LONG_DOUBLE_TYPE , TI_COMPLEX_FLOAT16_TYPE , TI_COMPLEX_FLOATN_NX_TYPE_FIRST = TI_COMPLEX_FLOAT16_TYPE , TI_COMPLEX_FLOAT32_TYPE ,
  TI_COMPLEX_FLOAT64_TYPE , TI_COMPLEX_FLOAT128_TYPE , TI_COMPLEX_FLOAT32X_TYPE , TI_COMPLEX_FLOAT64X_TYPE ,
  TI_COMPLEX_FLOAT128X_TYPE , TI_FLOAT_PTR_TYPE , TI_DOUBLE_PTR_TYPE , TI_LONG_DOUBLE_PTR_TYPE ,
  TI_INTEGER_PTR_TYPE , TI_VOID_TYPE , TI_PTR_TYPE , TI_CONST_PTR_TYPE ,
  TI_SIZE_TYPE , TI_PID_TYPE , TI_PTRDIFF_TYPE , TI_VA_LIST_TYPE ,
  TI_VA_LIST_GPR_COUNTER_FIELD , TI_VA_LIST_FPR_COUNTER_FIELD , TI_BOOLEAN_TYPE , TI_FILEPTR_TYPE ,
  TI_CONST_TM_PTR_TYPE , TI_FENV_T_PTR_TYPE , TI_CONST_FENV_T_PTR_TYPE , TI_FEXCEPT_T_PTR_TYPE ,
  TI_CONST_FEXCEPT_T_PTR_TYPE , TI_POINTER_SIZED_TYPE , TI_DFLOAT32_TYPE , TI_DFLOAT64_TYPE ,
  TI_DFLOAT128_TYPE , TI_DFLOAT64X_TYPE , TI_VOID_LIST_NODE , TI_MAIN_IDENTIFIER ,
  TI_SAT_SFRACT_TYPE , TI_SAT_FRACT_TYPE , TI_SAT_LFRACT_TYPE , TI_SAT_LLFRACT_TYPE ,
  TI_SAT_USFRACT_TYPE , TI_SAT_UFRACT_TYPE , TI_SAT_ULFRACT_TYPE , TI_SAT_ULLFRACT_TYPE ,
  TI_SFRACT_TYPE , TI_FRACT_TYPE , TI_LFRACT_TYPE , TI_LLFRACT_TYPE ,
  TI_USFRACT_TYPE , TI_UFRACT_TYPE , TI_ULFRACT_TYPE , TI_ULLFRACT_TYPE ,
  TI_SAT_SACCUM_TYPE , TI_SAT_ACCUM_TYPE , TI_SAT_LACCUM_TYPE , TI_SAT_LLACCUM_TYPE ,
  TI_SAT_USACCUM_TYPE , TI_SAT_UACCUM_TYPE , TI_SAT_ULACCUM_TYPE , TI_SAT_ULLACCUM_TYPE ,
  TI_SACCUM_TYPE , TI_ACCUM_TYPE , TI_LACCUM_TYPE , TI_LLACCUM_TYPE ,
  TI_USACCUM_TYPE , TI_UACCUM_TYPE , TI_ULACCUM_TYPE , TI_ULLACCUM_TYPE ,
  TI_QQ_TYPE , TI_HQ_TYPE , TI_SQ_TYPE , TI_DQ_TYPE ,
  TI_TQ_TYPE , TI_UQQ_TYPE , TI_UHQ_TYPE , TI_USQ_TYPE ,
  TI_UDQ_TYPE , TI_UTQ_TYPE , TI_SAT_QQ_TYPE , TI_SAT_HQ_TYPE ,
  TI_SAT_SQ_TYPE , TI_SAT_DQ_TYPE , TI_SAT_TQ_TYPE , TI_SAT_UQQ_TYPE ,
  TI_SAT_UHQ_TYPE , TI_SAT_USQ_TYPE , TI_SAT_UDQ_TYPE , TI_SAT_UTQ_TYPE ,
  TI_HA_TYPE , TI_SA_TYPE , TI_DA_TYPE , TI_TA_TYPE ,
  TI_UHA_TYPE , TI_USA_TYPE , TI_UDA_TYPE , TI_UTA_TYPE ,
  TI_SAT_HA_TYPE , TI_SAT_SA_TYPE , TI_SAT_DA_TYPE , TI_SAT_TA_TYPE ,
  TI_SAT_UHA_TYPE , TI_SAT_USA_TYPE , TI_SAT_UDA_TYPE , TI_SAT_UTA_TYPE ,
  TI_MODULE_HWM , TI_OPTIMIZATION_DEFAULT , TI_OPTIMIZATION_CURRENT , TI_TARGET_OPTION_DEFAULT ,
  TI_TARGET_OPTION_CURRENT , TI_CURRENT_TARGET_PRAGMA , TI_CURRENT_OPTIMIZE_PRAGMA , TI_CHREC_DONT_KNOW ,
  TI_CHREC_KNOWN , TI_MAX
}
 
enum  integer_type_kind {
  itk_char , itk_signed_char , itk_unsigned_char , itk_short ,
  itk_unsigned_short , itk_int , itk_unsigned_int , itk_long ,
  itk_unsigned_long , itk_long_long , itk_unsigned_long_long , itk_intN_0 ,
  itk_unsigned_intN_0 , itk_intN_1 , itk_unsigned_intN_1 , itk_intN_2 ,
  itk_unsigned_intN_2 , itk_intN_3 , itk_unsigned_intN_3 , itk_none
}
 
enum  ptrmemfunc_vbit_where_t { ptrmemfunc_vbit_in_pfn , ptrmemfunc_vbit_in_delta }
 
enum  attribute_flags {
  ATTR_FLAG_DECL_NEXT = 1 , ATTR_FLAG_FUNCTION_NEXT = 2 , ATTR_FLAG_ARRAY_NEXT = 4 , ATTR_FLAG_TYPE_IN_PLACE = 8 ,
  ATTR_FLAG_BUILT_IN = 16 , ATTR_FLAG_CXX11 = 32 , ATTR_FLAG_INTERNAL = 64
}
 
enum  size_type_kind {
  stk_sizetype , stk_ssizetype , stk_bitsizetype , stk_sbitsizetype ,
  stk_type_kind_last
}
 
enum  operand_equal_flag {
  OEP_ONLY_CONST = 1 , OEP_PURE_SAME = 2 , OEP_MATCH_SIDE_EFFECTS = 4 , OEP_ADDRESS_OF = 8 ,
  OEP_NO_HASH_CHECK = 16 , OEP_HASH_CHECK = 32 , OEP_LEXICOGRAPHIC = 64 , OEP_BITWISE = 128 ,
  OEP_ADDRESS_OF_SAME_FIELD = 256 , OEP_DECL_NAME = 512
}
 
enum  tree_node_kind {
  d_kind , t_kind , b_kind , s_kind ,
  r_kind , e_kind , c_kind , id_kind ,
  vec_kind , binfo_kind , ssa_name_kind , constr_kind ,
  x_kind , lang_decl , lang_type , omp_clause_kind ,
  all_kinds
}
 
enum  annot_expr_kind {
  annot_expr_ivdep_kind , annot_expr_unroll_kind , annot_expr_no_vector_kind , annot_expr_vector_kind ,
  annot_expr_parallel_kind , annot_expr_maybe_infinite_kind , annot_expr_kind_last
}
 
enum  clobber_kind {
  CLOBBER_UNDEF , CLOBBER_STORAGE_BEGIN , CLOBBER_OBJECT_BEGIN , CLOBBER_OBJECT_END ,
  CLOBBER_STORAGE_END , CLOBBER_LAST
}
 
enum  omp_clause_depend_kind {
  OMP_CLAUSE_DEPEND_IN , OMP_CLAUSE_DEPEND_OUT , OMP_CLAUSE_DEPEND_INOUT , OMP_CLAUSE_DEPEND_MUTEXINOUTSET ,
  OMP_CLAUSE_DEPEND_INOUTSET , OMP_CLAUSE_DEPEND_DEPOBJ , OMP_CLAUSE_DEPEND_INVALID , OMP_CLAUSE_DEPEND_LAST
}
 
enum  omp_clause_doacross_kind { OMP_CLAUSE_DOACROSS_SOURCE , OMP_CLAUSE_DOACROSS_SINK , OMP_CLAUSE_DOACROSS_LAST }
 
enum  omp_clause_proc_bind_kind {
  OMP_CLAUSE_PROC_BIND_FALSE = 0 , OMP_CLAUSE_PROC_BIND_TRUE = 1 , OMP_CLAUSE_PROC_BIND_PRIMARY = 2 , OMP_CLAUSE_PROC_BIND_MASTER = 2 ,
  OMP_CLAUSE_PROC_BIND_CLOSE = 3 , OMP_CLAUSE_PROC_BIND_SPREAD = 4 , OMP_CLAUSE_PROC_BIND_LAST
}
 
enum  omp_clause_device_type_kind { OMP_CLAUSE_DEVICE_TYPE_HOST = 1 , OMP_CLAUSE_DEVICE_TYPE_NOHOST = 2 , OMP_CLAUSE_DEVICE_TYPE_ANY = 3 }
 
enum  omp_clause_linear_kind { OMP_CLAUSE_LINEAR_DEFAULT , OMP_CLAUSE_LINEAR_REF , OMP_CLAUSE_LINEAR_VAL , OMP_CLAUSE_LINEAR_UVAL }
 

Macro Definition Documentation

◆ ACOSH_TYPE [1/2]

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

◆ ACOSH_TYPE [2/2]

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

◆ ATAN2_TYPE [1/2]

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

◆ ATAN2_TYPE [2/2]

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

◆ ATANH_TYPE [1/2]

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

◆ ATANH_TYPE [2/2]

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

◆ ATTR_MATHFN_ERRNO [1/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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.

◆ BUILT_IN_LAST

#define BUILT_IN_LAST   (BUILT_IN_NORMAL + 1) 
Last marker used for LTO stremaing of built_in_class.  We cannot add it
to the enum since we need the enumb to fit in 2 bits.

Referenced by maybe_warn_pass_by_reference(), pack_ts_function_decl_value_fields(), and unpack_ts_function_decl_value_fields().

◆ CABS_TYPE [1/2]

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

◆ CABS_TYPE [2/2]

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

◆ CACOSH_TYPE [1/2]

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

◆ CACOSH_TYPE [2/2]

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

◆ CARG_TYPE [1/2]

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

◆ CARG_TYPE [2/2]

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

◆ CASINH_TYPE [1/2]

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

◆ CASINH_TYPE [2/2]

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

◆ CEIL_TYPE [1/2]

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

◆ CEIL_TYPE [2/2]

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

◆ CODE_CONTAINS_STRUCT

#define CODE_CONTAINS_STRUCT ( CODE,
STRUCT )
Value:
(tree_contains_struct[(CODE)][(STRUCT)])
STRUCT
@ STRUCT
Definition gengtype.h:475
tree_contains_struct
bool tree_contains_struct[MAX_TREE_CODES][64]
Definition tree.cc:234

Referenced by copy_node(), copy_tree_r(), decl_ultimate_origin(), dequeue_and_dump(), DFS::DFS_write_tree_body(), free_node(), hash_tree(), make_node(), print_node(), streamer_alloc_tree(), streamer_read_tree_bitfields(), streamer_read_tree_body(), streamer_write_tree_bitfields(), streamer_write_tree_body(), and streamer_write_tree_header().

◆ COPYSIGN_TYPE [1/2]

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

◆ COPYSIGN_TYPE [2/2]

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

◆ COSH_TYPE [1/2]

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

◆ COSH_TYPE [2/2]

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

◆ CPOW_TYPE [1/2]

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

◆ CPOW_TYPE [2/2]

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

◆ CPROJ_TYPE [1/2]

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

◆ CPROJ_TYPE [2/2]

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

◆ DEF_BUILTIN [1/2]

#define DEF_BUILTIN ( ENUM,
N,
C,
T,
LT,
B,
F,
NA,
AT,
IM,
COND )
Value:
ENUM,
ENUM
@ ENUM
Definition gengtype.h:476
Codes that identify the various built in functions
so that expand_call can identify them quickly.

◆ DEF_BUILTIN [2/2]

#define DEF_BUILTIN ( ENUM,
N,
C,
T,
LT,
B,
F,
NA,
AT,
IM,
COND )
Value:
CFN_##ENUM = int (ENUM),
Codes that identify the various built in functions
so that expand_call can identify them quickly.

◆ DEF_BUILTIN_STUB [1/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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-2024 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/2]

#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-2024 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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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)

◆ DEF_GOACC_BUILTIN_COMPILER [2/2]

#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)

◆ DEF_GOACC_BUILTIN_ONLY [1/2]

#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/2]

#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/2]

#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/2]

#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/2]

#define DEF_GOMP_BUILTIN_COMPILER ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
flag_openmp, true, true, ATTRS, false, flag_openmp)

◆ DEF_GOMP_BUILTIN_COMPILER [2/2]

#define DEF_GOMP_BUILTIN_COMPILER ( ENUM,
NAME,
TYPE,
ATTRS )
Value:
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
flag_openmp, true, true, ATTRS, false, flag_openmp)

◆ DEF_INTERNAL_COND_FN [1/2]

#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/2]

#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/2]

#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/2]

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

◆ DEF_INTERNAL_FLT_FN [1/2]

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

◆ DEF_INTERNAL_FLT_FN [2/2]

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

◆ DEF_INTERNAL_FN [1/2]

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

◆ DEF_INTERNAL_FN [2/2]

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

◆ DEF_INTERNAL_INT_EXT_FN [1/2]

#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/2]

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

◆ DEF_INTERNAL_INT_FN [1/2]

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

◆ DEF_INTERNAL_INT_FN [2/2]

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

◆ DEF_INTERNAL_OPTAB_FN [1/2]

#define DEF_INTERNAL_OPTAB_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)
Internal functions.
   Copyright (C) 2011-2024 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/2]

#define DEF_INTERNAL_OPTAB_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)
Internal functions.
   Copyright (C) 2011-2024 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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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/2]

#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

#define DEFTREECODE ( SYM,
STRING,
TYPE,
NARGS )
Value:
SYM,
Codes of tree nodes.

◆ DEFTREESTRUCT

#define DEFTREESTRUCT ( ENUM,
NAME )
Value:
ENUM,

◆ EAF_NO_DIRECT_CLOBBER

#define EAF_NO_DIRECT_CLOBBER   (1 << 2) 
Following flags come in pairs.  First one is about direct dereferences
from the parameter, while the second is about memory reachable by
recursive dereferences.   
Nonzero if memory reached by the argument is not clobbered.

Referenced by attr_fnspec::arg_eaf_flags(), handle_call_arg(), interposable_eaf_flags(), and sra_modify_call_arg().

◆ EAF_NO_DIRECT_ESCAPE

#define EAF_NO_DIRECT_ESCAPE   (1 << 4) 
Nonzero if the argument does not escape.

Referenced by attr_fnspec::arg_eaf_flags(), handle_call_arg(), handle_rhs_call(), and interposable_eaf_flags().

◆ EAF_NO_DIRECT_READ

#define EAF_NO_DIRECT_READ   (1 << 8) 
Nonzero if the argument is not read.

Referenced by handle_call_arg(), interposable_eaf_flags(), maybe_warn_pass_by_reference(), and ref_maybe_used_by_call_p_1().

◆ EAF_NO_INDIRECT_CLOBBER

#define EAF_NO_INDIRECT_CLOBBER   (1 << 3)

Referenced by attr_fnspec::arg_eaf_flags(), handle_call_arg(), and interposable_eaf_flags().

◆ EAF_NO_INDIRECT_ESCAPE

#define EAF_NO_INDIRECT_ESCAPE   (1 << 5)

Referenced by attr_fnspec::arg_eaf_flags(), handle_call_arg(), and interposable_eaf_flags().

◆ EAF_NO_INDIRECT_READ

#define EAF_NO_INDIRECT_READ   (1 << 9)

Referenced by attr_fnspec::arg_eaf_flags(), handle_call_arg(), and interposable_eaf_flags().

◆ EAF_NOT_RETURNED_DIRECTLY

#define EAF_NOT_RETURNED_DIRECTLY   (1 << 6) 
Nonzero if the argument does not escape to return value.

Referenced by handle_call_arg(), handle_rhs_call(), interposable_eaf_flags(), remove_useless_eaf_flags(), and scan_function().

◆ EAF_NOT_RETURNED_INDIRECTLY

#define EAF_NOT_RETURNED_INDIRECTLY   (1 << 7)

Referenced by attr_fnspec::arg_eaf_flags(), handle_call_arg(), interposable_eaf_flags(), and remove_useless_eaf_flags().

◆ EAF_UNUSED

#define EAF_UNUSED   (1 << 1) 
Call argument flags.   
Nonzero if the argument is not used by the function.

Referenced by attr_fnspec::arg_eaf_flags(), handle_call_arg(), handle_rhs_call(), interposable_eaf_flags(), maybe_warn_pass_by_reference(), ref_maybe_used_by_call_p_1(), and sra_modify_call_arg().

◆ ECF_BY_DESCRIPTOR

#define ECF_BY_DESCRIPTOR   (1 << 14) 
Nonzero if this is an indirect call by descriptor.

Referenced by call_expr_flags(), expand_call(), gimple_call_flags(), and prepare_call_address().

◆ ECF_COLD

#define ECF_COLD   (1 << 15) 
Nonzero if this is a cold function.

Referenced by build_common_builtin_nodes(), flags_from_decl_or_type(), and set_call_expr_flags().

◆ ECF_CONST

#define ECF_CONST   (1 << 0) 
Nonzero if this is a call to a function whose return value depends
solely on its arguments, has no side effects, and does not read
global memory.  This corresponds to TREE_READONLY for function
decls.

Referenced by auto_simd_check_stmt(), build_common_builtin_nodes(), call_may_clobber_ref_p_1(), check_stmt_for_type_change(), cleanup_call_ctrl_altering_flag(), compute_avail(), compute_points_to_sets(), decl_maybe_in_construction_p(), dse_optimize_call(), emit_call_1(), emit_library_call_value_1(), execute_fixup_cfg(), expand_builtin(), expand_call(), expr_hash_elt::expr_hash_elt(), find_always_executed_bbs(), find_func_aliases_for_call(), find_obviously_necessary_stmts(), finite_loop_p(), flags_from_decl_or_type(), ccp_folder::fold_stmt(), function_and_variable_visibility(), gather_memory_references(), get_read_write_all_from_node(), get_references_in_stmt(), gimple_call_reset_alias_info(), gimple_has_side_effects(), gimple_regimplify_operands(), gimplify_call_expr(), gsi_replace_with_seq_vops(), if_convertible_stmt_p(), initialize_argument_information(), input_edge(), ipa_merge_modref_summary_after_inlining(), ipa_modref_callee_reads_no_memory_p(), ipa_pta_execute(), is_removable_cxa_atexit_call(), is_tm_pure_call(), lto_output_edge(), operands_scanner::maybe_add_call_vops(), maybe_push_res_to_seq(), maybe_warn_pass_by_reference(), nonbarrier_call_p(), operand_compare::operand_equal_p(), param_type_may_change_p(), polymorphic_ctor_dtor_p(), process_call_operands(), propagate(), propagate_bits(), pure_const_read_summary(), read_write_all_from_decl(), ref_maybe_used_by_call_p_1(), remove_useless_eaf_flags(), set_call_expr_flags(), should_duplicate_loop_header_p(), speculation_useful_p(), state_from_flags(), statement_sink_location(), stmt_can_terminate_bb_p(), stmt_may_terminate_function_p(), tree_estimate_loop_size(), modref_summary::useful_p(), modref_summary_lto::useful_p(), vect_finish_stmt_generation(), visit_reference_op_call(), visit_stmt(), and will_be_nonconstant_predicate().

◆ ECF_LEAF

#define ECF_LEAF   (1 << 10) 
The function does not lead to calls within current function unit.

Referenced by build_common_builtin_nodes(), build_cxa_atexit_decl(), call_can_make_abnormal_goto(), cleanup_call_ctrl_altering_flag(), flags_from_decl_or_type(), ignore_edge_p(), ipa_reference_get_read_global(), ipa_reference_get_written_global(), lto_output_edge(), nonfreeing_call_p(), propagate_bits(), read_write_all_from_decl(), and set_call_expr_flags().

◆ ECF_LOOPING_CONST_OR_PURE

#define ECF_LOOPING_CONST_OR_PURE   (1 << 2) 
Nonzero if this is ECF_CONST or ECF_PURE but cannot be proven to no
infinite loop.  This corresponds to DECL_LOOPING_CONST_OR_PURE_P
for function decls.

Referenced by call_may_clobber_ref_p_1(), cleanup_call_ctrl_altering_flag(), compute_avail(), dse_optimize_call(), emit_call_1(), emit_library_call_value_1(), execute_fixup_cfg(), expand_builtin(), expand_call(), find_always_executed_bbs(), find_func_aliases_for_call(), find_obviously_necessary_stmts(), finite_loop_p(), flags_from_decl_or_type(), ccp_folder::fold_stmt(), function_and_variable_visibility(), gimple_has_side_effects(), gimple_regimplify_operands(), gimplify_call_expr(), if_convertible_stmt_p(), initialize_argument_information(), ipa_merge_modref_summary_after_inlining(), is_removable_cxa_atexit_call(), lto_output_edge(), process_call_operands(), set_call_expr_flags(), state_from_flags(), statement_sink_location(), stmt_can_terminate_bb_p(), stmt_may_terminate_function_p(), modref_summary::useful_p(), and modref_summary_lto::useful_p().

◆ ECF_MALLOC

#define ECF_MALLOC   (1 << 4) 
Nonzero if this is a call to malloc or a related function.

Referenced by build_common_builtin_nodes(), execute_split_functions(), expand_call(), flags_from_decl_or_type(), gimple_call_return_flags(), input_edge(), lto_output_edge(), set_call_expr_flags(), and thread_private_new_memory().

◆ ECF_MAY_BE_ALLOCA

#define ECF_MAY_BE_ALLOCA   (1 << 5) 
Nonzero if it is plausible that this is a call to alloca.

Referenced by expand_call(), gimple_maybe_alloca_call_p(), lto_output_edge(), notice_special_calls(), special_function_p(), and store_one_arg().

◆ ECF_NORETURN

#define ECF_NORETURN   (1 << 3) 
Nonzero if this call will never return.

Referenced by block_may_fallthru(), build_common_builtin_nodes(), can_implement_as_sibling_call_p(), cgraph_edge::cannot_lead_to_return_p(), cgraph_node::cannot_return_p(), check_call(), cleanup_call_ctrl_altering_flag(), compute_function_frequency(), determine_unlikely_bbs(), emit_call_1(), emit_library_call_value_1(), execute_fixup_cfg(), execute_split_functions(), expand_call(), flags_from_decl_or_type(), gimple_build_eh_must_not_throw(), gimple_call_initialize_ctrl_altering(), gimple_call_noreturn_p(), gimple_ic(), gsi_replace_with_seq_vops(), input_edge(), is_removable_cxa_atexit_call(), likely_target_p(), lower_stmt(), lto_output_edge(), mark_stmt_if_obviously_necessary(), remove_useless_eaf_flags(), set_call_expr_flags(), and stmt_can_terminate_bb_p().

◆ ECF_NOTHROW

#define ECF_NOTHROW   (1 << 6) 
Nonzero if this is a call to a function that won't throw an exception.

Referenced by build_common_builtin_nodes(), build_cxa_atexit_decl(), cgraph_edge::cannot_lead_to_return_p(), cgraph_node::cannot_return_p(), check_call(), emit_library_call_value_1(), expand_call(), flags_from_decl_or_type(), gimple_call_flags(), gimple_call_nothrow_p(), input_edge(), lto_output_edge(), make_reg_eh_region_note(), propagate_nothrow(), pure_const_read_summary(), set_call_expr_flags(), stmt_can_terminate_bb_p(), and tree_could_throw_p().

◆ ECF_NOVOPS

#define ECF_NOVOPS   (1 << 9) 
Function does not read or write memory (but may have side effects, so
it does not necessarily fit ECF_CONST).

Referenced by call_may_clobber_ref_p_1(), compute_points_to_sets(), dse_optimize_call(), find_func_aliases_for_call(), flags_from_decl_or_type(), gimple_call_reset_alias_info(), gsi_replace_with_seq_vops(), ipa_merge_modref_summary_after_inlining(), ipa_pta_execute(), lto_output_edge(), operands_scanner::maybe_add_call_vops(), ref_maybe_used_by_call_p_1(), remove_useless_eaf_flags(), set_call_expr_flags(), modref_summary_lto::useful_p(), and vect_finish_stmt_generation().

◆ ECF_PURE

#define ECF_PURE   (1 << 1) 
Nonzero if this is a call to "pure" function (like const function,
but may read memory.  This corresponds to DECL_PURE_P for function
decls.

Referenced by auto_simd_check_stmt(), build_common_builtin_nodes(), call_may_clobber_ref_p_1(), check_stmt_for_type_change(), cleanup_call_ctrl_altering_flag(), compute_avail(), compute_points_to_sets(), decl_maybe_in_construction_p(), dse_optimize_call(), emit_call_1(), emit_library_call_value_1(), execute_fixup_cfg(), expand_builtin(), expand_call(), expr_hash_elt::expr_hash_elt(), find_always_executed_bbs(), find_func_aliases_for_call(), find_obviously_necessary_stmts(), finite_loop_p(), flags_from_decl_or_type(), ccp_folder::fold_stmt(), function_and_variable_visibility(), get_read_write_all_from_node(), gimple_call_reset_alias_info(), gimple_has_side_effects(), gimple_regimplify_operands(), gimplify_call_expr(), gsi_replace_with_seq_vops(), initialize_argument_information(), input_edge(), ipa_merge_modref_summary_after_inlining(), ipa_pta_execute(), is_removable_cxa_atexit_call(), lto_output_edge(), operands_scanner::maybe_add_call_vops(), nonbarrier_call_p(), operand_compare::operand_equal_p(), param_type_may_change_p(), polymorphic_ctor_dtor_p(), process_call_operands(), propagate(), propagate_bits(), pure_const_read_summary(), read_write_all_from_decl(), remove_useless_eaf_flags(), set_call_expr_flags(), speculation_useful_p(), state_from_flags(), statement_sink_location(), stmt_can_terminate_bb_p(), stmt_may_terminate_function_p(), tree_estimate_loop_size(), modref_summary::useful_p(), modref_summary_lto::useful_p(), vect_finish_stmt_generation(), visit_reference_op_call(), and visit_stmt().

◆ ECF_RET1

#define ECF_RET1   (1 << 11) 
Nonzero if this call returns its first argument.

Referenced by set_call_expr_flags().

◆ ECF_RETURNS_TWICE

#define ECF_RETURNS_TWICE   (1 << 7) 
Nonzero if this is a call to setjmp or a related function.

Referenced by branch_prob(), build_access_from_call_arg(), build_and_add_sum(), can_implement_as_sibling_call_p(), determine_max_movement(), edge_before_returns_twice_call(), emit_call_1(), emit_library_call_value_1(), execute_split_functions(), flags_from_decl_or_type(), gimple_can_duplicate_bb_p(), gimple_verify_flow_info(), gimplify_call_expr(), gimplify_modify_expr(), gsi_safe_insert_before(), gsi_safe_insert_seq_before(), input_edge(), lto_output_edge(), make_edges(), notice_special_calls(), set_call_expr_flags(), setjmp_call_p(), special_function_p(), statement_sink_location(), stmt_can_terminate_bb_p(), stmt_starts_bb_p(), and vect_slp_function().

◆ ECF_SIBCALL

#define ECF_SIBCALL   (1 << 8) 
Nonzero if this call replaces the current stack frame.

Referenced by emit_call_1(), expand_call(), load_register_parameters(), lto_output_edge(), prepare_call_address(), and store_one_arg().

◆ ECF_TM_BUILTIN

#define ECF_TM_BUILTIN   (1 << 13) 
Nonzero if this call is into the transaction runtime library.

Referenced by diagnose_tm_1(), expand_block_edges(), flags_from_decl_or_type(), gimple_call_initialize_ctrl_altering(), ipa_tm_mayenterirr_function(), and ipa_tm_transform_calls_redirect().

◆ ECF_TM_PURE

#define ECF_TM_PURE   (1 << 12) 
Nonzero if this call does not affect transactions.

Referenced by build_common_builtin_nodes(), flags_from_decl_or_type(), ipa_tm_mayenterirr_function(), is_tm_pure(), is_tm_pure_call(), and set_call_expr_flags().

◆ ECF_XTHROW

#define ECF_XTHROW   (1 << 16) 
Nonzero if this is a function expected to end with an exception.

Referenced by build_common_builtin_nodes(), flags_from_decl_or_type(), gimple_build_call_from_tree(), gimple_call_expected_throw_p(), gimple_call_flags(), and set_call_expr_flags().

◆ END_OF_BASE_TREE_CODES

#define END_OF_BASE_TREE_CODES   LAST_AND_UNUSED_TREE_CODE,

◆ ERF_NOALIAS

#define ERF_NOALIAS   (1 << 3) 
Nonzero if the return value does not alias with anything.  Functions
with the malloc attribute have this set on their return value.

Referenced by decl_return_flags(), find_func_aliases_for_builtin_call(), gimple_call_return_flags(), handle_lhs_call(), and visit_stmt().

◆ ERF_RETURN_ARG_MASK

#define ERF_RETURN_ARG_MASK   (3) 
Call return flags.   
Mask for the argument number that is returned.  Lower two bits of
the return flags, encodes argument slots zero to three.

Referenced by decompose_param_expr(), evaluate_stmt(), expand_call(), gimple_call_nonnull_arg(), handle_lhs_call(), and pass_through_call().

◆ ERF_RETURNS_ARG

#define ERF_RETURNS_ARG   (1 << 2) 
Nonzero if the return value is equal to the argument number
flags & ERF_RETURN_ARG_MASK.

Referenced by decl_return_flags(), decompose_param_expr(), evaluate_stmt(), expand_call(), gimple_call_nonnull_arg(), gimple_call_return_flags(), handle_lhs_call(), and pass_through_call().

◆ FABS_TYPE [1/2]

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

◆ FABS_TYPE [2/2]

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

◆ FDIM_TYPE [1/2]

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

◆ FDIM_TYPE [2/2]

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

◆ FLOOR_TYPE [1/2]

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

◆ FLOOR_TYPE [2/2]

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

◆ FMA_TYPE [1/2]

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

◆ FMA_TYPE [2/2]

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

◆ FMAX_TYPE [1/2]

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

◆ FMAX_TYPE [2/2]

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

◆ FMIN_TYPE [1/2]

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

◆ FMIN_TYPE [2/2]

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

◆ FREXP_TYPE [1/2]

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

◆ FREXP_TYPE [2/2]

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

◆ HUGE_VAL_TYPE [1/2]

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

◆ HUGE_VAL_TYPE [2/2]

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

◆ HYPOT_TYPE [1/2]

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

◆ HYPOT_TYPE [2/2]

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

◆ ILOGB_TYPE [1/2]

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

◆ ILOGB_TYPE [2/2]

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

◆ INF_TYPE [1/2]

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

◆ INF_TYPE [2/2]

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

◆ LDEXP_TYPE [1/2]

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

◆ LDEXP_TYPE [2/2]

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

◆ LGAMMA_TYPE [1/2]

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

◆ LGAMMA_TYPE [2/2]

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

◆ LLRINT_TYPE [1/2]

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

◆ LLRINT_TYPE [2/2]

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

◆ LOG10_TYPE [1/2]

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

◆ LOG10_TYPE [2/2]

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

◆ LRINT_TYPE [1/2]

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

◆ LRINT_TYPE [2/2]

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

◆ MODF_TYPE [1/2]

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

◆ MODF_TYPE [2/2]

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

◆ NAN_TYPE [1/2]

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

◆ NAN_TYPE [2/2]

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

◆ NEARBYINT_TYPE [1/2]

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

◆ NEARBYINT_TYPE [2/2]

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

◆ NEXTAFTER_TYPE [1/2]

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

◆ NEXTAFTER_TYPE [2/2]

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

◆ NUM_FLOATN_NX_TYPES

#define NUM_FLOATN_NX_TYPES
Value:
((int) (TI_FLOATN_NX_TYPE_LAST \
- TI_FLOATN_NX_TYPE_FIRST + 1))
TI_FLOATN_NX_TYPE_FIRST
@ TI_FLOATN_NX_TYPE_FIRST
Definition tree-core.h:742
TI_FLOATN_NX_TYPE_LAST
@ TI_FLOATN_NX_TYPE_LAST
Definition tree-core.h:754

Referenced by build_common_tree_nodes(), and long_double_as_float128().

◆ NUM_FLOATN_TYPES

#define NUM_FLOATN_TYPES
Value:
((int) (TI_FLOATN_TYPE_LAST \
- TI_FLOATN_TYPE_FIRST + 1))
TI_FLOATN_TYPE_LAST
@ TI_FLOATN_TYPE_LAST
Definition tree-core.h:746
TI_FLOATN_TYPE_FIRST
@ TI_FLOATN_TYPE_FIRST
Definition tree-core.h:741

◆ NUM_FLOATNX_TYPES

#define NUM_FLOATNX_TYPES
Value:
((int) (TI_FLOATNX_TYPE_LAST \
- TI_FLOATNX_TYPE_FIRST + 1))
TI_FLOATNX_TYPE_LAST
@ TI_FLOATNX_TYPE_LAST
Definition tree-core.h:753
TI_FLOATNX_TYPE_FIRST
@ TI_FLOATNX_TYPE_FIRST
Definition tree-core.h:750

◆ NUM_TREE_CODES

#define NUM_TREE_CODES    ((int) LAST_AND_UNUSED_TREE_CODE) 
Number of language-independent tree codes.

Referenced by is_lang_specific(), maybe_lvalue_p(), print_lto_report(), and tree_code_size().

◆ OMP_FAIL_MEMORY_ORDER_SHIFT

#define OMP_FAIL_MEMORY_ORDER_SHIFT   3

◆ REMQUO_TYPE [1/2]

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

◆ REMQUO_TYPE [2/2]

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

◆ RINT_TYPE [1/2]

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

◆ RINT_TYPE [2/2]

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

◆ ROUND_TYPE [1/2]

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

◆ ROUND_TYPE [2/2]

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

◆ ROUNDEVEN_TYPE [1/2]

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

◆ ROUNDEVEN_TYPE [2/2]

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

◆ SCALBLN_TYPE [1/2]

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

◆ SCALBLN_TYPE [2/2]

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

◆ SCALBN_TYPE [1/2]

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

◆ SCALBN_TYPE [2/2]

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

◆ SINH_TYPE [1/2]

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

◆ SINH_TYPE [2/2]

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

◆ SQRT_TYPE [1/2]

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

◆ SQRT_TYPE [2/2]

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

◆ TRUNC_TYPE [1/2]

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

◆ TRUNC_TYPE [2/2]

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

Typedef Documentation

◆ priority_type

typedef unsigned short priority_type 
An initialization priority.

◆ walk_tree_fn

typedef tree(* walk_tree_fn) (tree *, int *, void *) 
The type of a callback function for walking over tree structure.

◆ walk_tree_lh

typedef tree(* walk_tree_lh) (tree *, int *, tree(*)(tree *, int *, void *), void *, hash_set< tree > *) 
The type of a callback function that represents a custom walk_tree.

Enumeration Type Documentation

◆ annot_expr_kind

enum annot_expr_kind
Enumerator
annot_expr_ivdep_kind 
annot_expr_unroll_kind 
annot_expr_no_vector_kind 
annot_expr_vector_kind 
annot_expr_parallel_kind 
annot_expr_maybe_infinite_kind 
annot_expr_kind_last 

◆ attribute_flags

enum attribute_flags 
Flags that may be passed in the third argument of decl_attributes, and
to handler functions for attributes.
Enumerator
ATTR_FLAG_DECL_NEXT 
ATTR_FLAG_FUNCTION_NEXT 
ATTR_FLAG_ARRAY_NEXT 
ATTR_FLAG_TYPE_IN_PLACE 
ATTR_FLAG_BUILT_IN 
ATTR_FLAG_CXX11 
ATTR_FLAG_INTERNAL 

◆ built_in_class

enum built_in_class 
Classify which part of the compiler has defined a given builtin function.
Note that we assume below that this is no more than two bits.
Enumerator
NOT_BUILT_IN 
BUILT_IN_FRONTEND 
BUILT_IN_MD 
BUILT_IN_NORMAL 

◆ 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.
BUILT_IN_COMPLEX_MUL_MAX 
BUILT_IN_COMPLEX_DIV_MIN 
BUILT_IN_COMPLEX_DIV_MAX 
END_BUILTINS 

◆ clobber_kind

enum clobber_kind 
The kind of a TREE_CLOBBER_P CONSTRUCTOR node.  Other than _UNDEF, these are
in roughly sequential order.
Enumerator
CLOBBER_UNDEF 
CLOBBER_STORAGE_BEGIN 
CLOBBER_OBJECT_BEGIN 
CLOBBER_OBJECT_END 
CLOBBER_STORAGE_END 
CLOBBER_LAST 

◆ combined_fn

enum combined_fn 
An enum that combines target-independent built-in functions with
internal functions, so that they can be treated in a similar way.
The numbers for built-in functions are the same as for the
built_in_function enum.  The numbers for internal functions
start at END_BUITLINS.
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.

◆ cv_qualifier

enum cv_qualifier 
There is a TYPE_QUAL value for each type qualifier.  They can be
combined by bitwise-or to form the complete set of qualifiers for a
type.
Enumerator
TYPE_UNQUALIFIED 
TYPE_QUAL_CONST 
TYPE_QUAL_VOLATILE 
TYPE_QUAL_RESTRICT 
TYPE_QUAL_ATOMIC 

◆ integer_type_kind

enum integer_type_kind 
An enumeration of the standard C integer types.  These must be
ordered so that shorter types appear before longer ones, and so
that signed types appear before unsigned ones, for the correct
functioning of interpret_integer() in c-lex.cc.
Enumerator
itk_char 
itk_signed_char 
itk_unsigned_char 
itk_short 
itk_unsigned_short 
itk_int 
itk_unsigned_int 
itk_long 
itk_unsigned_long 
itk_long_long 
itk_unsigned_long_long 
itk_intN_0 
itk_unsigned_intN_0 
itk_intN_1 
itk_unsigned_intN_1 
itk_intN_2 
itk_unsigned_intN_2 
itk_intN_3 
itk_unsigned_intN_3 
itk_none 

◆ internal_fn

enum internal_fn 
Internal functions.
Enumerator
DEF_INTERNAL_OPTAB_FN 
DEF_INTERNAL_OPTAB_FN 

◆ omp_clause_bind_kind

enum omp_clause_bind_kind
Enumerator
OMP_CLAUSE_BIND_TEAMS 
OMP_CLAUSE_BIND_PARALLEL 
OMP_CLAUSE_BIND_THREAD 

◆ omp_clause_code

enum omp_clause_code 
OMP_CLAUSE codes.  Do not reorder, as this is used to index into
the tables omp_clause_num_ops and omp_clause_code_name.

Note additionally that there are various range checks such as
for OMP_CLAUSE_SIZE or OMP_CLAUSE_DECL; clauses having those shall
be inside that range, those that have not shall be outside.
Enumerator
OMP_CLAUSE_ERROR 
OMP_CLAUSE_PRIVATE 
OMP_CLAUSE_SHARED 
OMP_CLAUSE_FIRSTPRIVATE 
OMP_CLAUSE_LASTPRIVATE 
OMP_CLAUSE_REDUCTION 
OMP_CLAUSE_TASK_REDUCTION 
OMP_CLAUSE_IN_REDUCTION 
OMP_CLAUSE_COPYIN 
OMP_CLAUSE_COPYPRIVATE 
OMP_CLAUSE_LINEAR 
OMP_CLAUSE_AFFINITY 
OMP_CLAUSE_ALIGNED 
OMP_CLAUSE_ALLOCATE 
OMP_CLAUSE_DEPEND 
OMP_CLAUSE_NONTEMPORAL 
OMP_CLAUSE_UNIFORM 
OMP_CLAUSE_ENTER 
OMP_CLAUSE_LINK 
OMP_CLAUSE_DETACH 
OMP_CLAUSE_USE_DEVICE_PTR 
OMP_CLAUSE_USE_DEVICE_ADDR 
OMP_CLAUSE_IS_DEVICE_PTR 
OMP_CLAUSE_INCLUSIVE 
OMP_CLAUSE_EXCLUSIVE 
OMP_CLAUSE_FROM 
OMP_CLAUSE_TO 
OMP_CLAUSE_MAP 
OMP_CLAUSE_HAS_DEVICE_ADDR 
OMP_CLAUSE_DOACROSS 
OMP_CLAUSE__CACHE_ 
OMP_CLAUSE_DESTROY 
OMP_CLAUSE_INIT 
OMP_CLAUSE_USE 
OMP_CLAUSE_INTEROP 
OMP_CLAUSE_GANG 
OMP_CLAUSE_ASYNC 
OMP_CLAUSE_WAIT 
OMP_CLAUSE_AUTO 
OMP_CLAUSE_SEQ 
OMP_CLAUSE__LOOPTEMP_ 
OMP_CLAUSE__REDUCTEMP_ 
OMP_CLAUSE__CONDTEMP_ 
OMP_CLAUSE__SCANTEMP_ 
OMP_CLAUSE_IF 
OMP_CLAUSE_SELF 
OMP_CLAUSE_NUM_THREADS 
OMP_CLAUSE_SCHEDULE 
OMP_CLAUSE_NOWAIT 
OMP_CLAUSE_ORDERED 
OMP_CLAUSE_DEFAULT 
OMP_CLAUSE_COLLAPSE 
OMP_CLAUSE_UNTIED 
OMP_CLAUSE_FINAL 
OMP_CLAUSE_MERGEABLE 
OMP_CLAUSE_DEVICE 
OMP_CLAUSE_DIST_SCHEDULE 
OMP_CLAUSE_INBRANCH 
OMP_CLAUSE_NOTINBRANCH 
OMP_CLAUSE_NUM_TEAMS 
OMP_CLAUSE_THREAD_LIMIT 
OMP_CLAUSE_PROC_BIND 
OMP_CLAUSE_SAFELEN 
OMP_CLAUSE_SIMDLEN 
OMP_CLAUSE_DEVICE_TYPE 
OMP_CLAUSE_FOR 
OMP_CLAUSE_PARALLEL 
OMP_CLAUSE_SECTIONS 
OMP_CLAUSE_TASKGROUP 
OMP_CLAUSE_PRIORITY 
OMP_CLAUSE_GRAINSIZE 
OMP_CLAUSE_NUM_TASKS 
OMP_CLAUSE_NOGROUP 
OMP_CLAUSE_THREADS 
OMP_CLAUSE_SIMD 
OMP_CLAUSE_HINT 
OMP_CLAUSE_DEFAULTMAP 
OMP_CLAUSE_ORDER 
OMP_CLAUSE_BIND 
OMP_CLAUSE_FILTER 
OMP_CLAUSE_INDIRECT 
OMP_CLAUSE_PARTIAL 
OMP_CLAUSE_FULL 
OMP_CLAUSE_SIZES 
OMP_CLAUSE__SIMDUID_ 
OMP_CLAUSE__SIMT_ 
OMP_CLAUSE_INDEPENDENT 
OMP_CLAUSE_WORKER 
OMP_CLAUSE_VECTOR 
OMP_CLAUSE_NUM_GANGS 
OMP_CLAUSE_NUM_WORKERS 
OMP_CLAUSE_VECTOR_LENGTH 
OMP_CLAUSE_TILE 
OMP_CLAUSE_IF_PRESENT 
OMP_CLAUSE_FINALIZE 
OMP_CLAUSE_NOHOST 
OMP_CLAUSE_NOVARIANTS 
OMP_CLAUSE_NOCONTEXT 

◆ omp_clause_default_kind

enum omp_clause_default_kind
Enumerator
OMP_CLAUSE_DEFAULT_UNSPECIFIED 
OMP_CLAUSE_DEFAULT_SHARED 
OMP_CLAUSE_DEFAULT_NONE 
OMP_CLAUSE_DEFAULT_PRIVATE 
OMP_CLAUSE_DEFAULT_FIRSTPRIVATE 
OMP_CLAUSE_DEFAULT_PRESENT 
OMP_CLAUSE_DEFAULT_LAST 

◆ omp_clause_defaultmap_kind

enum omp_clause_defaultmap_kind
Enumerator
OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED 
OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL 
OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR 
OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE 
OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE 
OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER 
OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK 
OMP_CLAUSE_DEFAULTMAP_ALLOC 
OMP_CLAUSE_DEFAULTMAP_TO 
OMP_CLAUSE_DEFAULTMAP_FROM 
OMP_CLAUSE_DEFAULTMAP_TOFROM 
OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE 
OMP_CLAUSE_DEFAULTMAP_NONE 
OMP_CLAUSE_DEFAULTMAP_DEFAULT 
OMP_CLAUSE_DEFAULTMAP_PRESENT 
OMP_CLAUSE_DEFAULTMAP_MASK 

◆ omp_clause_depend_kind

enum omp_clause_depend_kind
Enumerator
OMP_CLAUSE_DEPEND_IN 
OMP_CLAUSE_DEPEND_OUT 
OMP_CLAUSE_DEPEND_INOUT 
OMP_CLAUSE_DEPEND_MUTEXINOUTSET 
OMP_CLAUSE_DEPEND_INOUTSET 
OMP_CLAUSE_DEPEND_DEPOBJ 
OMP_CLAUSE_DEPEND_INVALID 
OMP_CLAUSE_DEPEND_LAST 

◆ omp_clause_device_type_kind

enum omp_clause_device_type_kind
Enumerator
OMP_CLAUSE_DEVICE_TYPE_HOST 
OMP_CLAUSE_DEVICE_TYPE_NOHOST 
OMP_CLAUSE_DEVICE_TYPE_ANY 

◆ omp_clause_doacross_kind

enum omp_clause_doacross_kind
Enumerator
OMP_CLAUSE_DOACROSS_SOURCE 
OMP_CLAUSE_DOACROSS_SINK 
OMP_CLAUSE_DOACROSS_LAST 

◆ omp_clause_linear_kind

enum omp_clause_linear_kind
Enumerator
OMP_CLAUSE_LINEAR_DEFAULT 
OMP_CLAUSE_LINEAR_REF 
OMP_CLAUSE_LINEAR_VAL 
OMP_CLAUSE_LINEAR_UVAL 

◆ omp_clause_proc_bind_kind

enum omp_clause_proc_bind_kind
Enumerator
OMP_CLAUSE_PROC_BIND_FALSE 
OMP_CLAUSE_PROC_BIND_TRUE 
OMP_CLAUSE_PROC_BIND_PRIMARY 
OMP_CLAUSE_PROC_BIND_MASTER 
OMP_CLAUSE_PROC_BIND_CLOSE 
OMP_CLAUSE_PROC_BIND_SPREAD 
OMP_CLAUSE_PROC_BIND_LAST 

◆ omp_clause_schedule_kind

enum omp_clause_schedule_kind
Enumerator
OMP_CLAUSE_SCHEDULE_STATIC 
OMP_CLAUSE_SCHEDULE_DYNAMIC 
OMP_CLAUSE_SCHEDULE_GUIDED 
OMP_CLAUSE_SCHEDULE_AUTO 
OMP_CLAUSE_SCHEDULE_RUNTIME 
OMP_CLAUSE_SCHEDULE_MASK 
OMP_CLAUSE_SCHEDULE_MONOTONIC 
OMP_CLAUSE_SCHEDULE_NONMONOTONIC 
OMP_CLAUSE_SCHEDULE_LAST 

◆ omp_memory_order

enum omp_memory_order 
memory-order-clause on OpenMP atomic/flush constructs or
argument of atomic_default_mem_order clause.
Enumerator
OMP_MEMORY_ORDER_UNSPECIFIED 
OMP_MEMORY_ORDER_RELAXED 
OMP_MEMORY_ORDER_ACQUIRE 
OMP_MEMORY_ORDER_RELEASE 
OMP_MEMORY_ORDER_ACQ_REL 
OMP_MEMORY_ORDER_SEQ_CST 
OMP_MEMORY_ORDER_MASK 
OMP_FAIL_MEMORY_ORDER_UNSPECIFIED 
OMP_FAIL_MEMORY_ORDER_RELAXED 
OMP_FAIL_MEMORY_ORDER_ACQUIRE 
OMP_FAIL_MEMORY_ORDER_RELEASE 
OMP_FAIL_MEMORY_ORDER_ACQ_REL 
OMP_FAIL_MEMORY_ORDER_SEQ_CST 
OMP_FAIL_MEMORY_ORDER_MASK 

◆ operand_equal_flag

enum operand_equal_flag 
Flags controlling operand_equal_p() behavior.
Enumerator
OEP_ONLY_CONST 
OEP_PURE_SAME 
OEP_MATCH_SIDE_EFFECTS 
OEP_ADDRESS_OF 
OEP_NO_HASH_CHECK 
OEP_HASH_CHECK 
OEP_LEXICOGRAPHIC 
OEP_BITWISE 
OEP_ADDRESS_OF_SAME_FIELD 
OEP_DECL_NAME 

◆ ptrmemfunc_vbit_where_t

enum ptrmemfunc_vbit_where_t 
A pointer-to-function member type looks like:

  struct {
    __P __pfn;
    ptrdiff_t __delta;
  };

If __pfn is NULL, it is a NULL pointer-to-member-function.

(Because the vtable is always the first thing in the object, we
don't need its offset.)  If the function is virtual, then PFN is
one plus twice the index into the vtable; otherwise, it is just a
pointer to the function.

Unfortunately, using the lowest bit of PFN doesn't work in
architectures that don't impose alignment requirements on function
addresses, or that use the lowest bit to tell one ISA from another,
for example.  For such architectures, we use the lowest bit of
DELTA instead of the lowest bit of the PFN, and DELTA will be
multiplied by 2.
Enumerator
ptrmemfunc_vbit_in_pfn 
ptrmemfunc_vbit_in_delta 

◆ size_type_kind

enum size_type_kind 
Types used to represent sizes.
Enumerator
stk_sizetype 
stk_ssizetype 
stk_bitsizetype 
stk_sbitsizetype 
stk_type_kind_last 

◆ tree_code

enum tree_code
Enumerator
MAX_TREE_CODES 

◆ tree_code_class

enum tree_code_class 
Tree code classes.  Each tree_code has an associated code class
represented by a TREE_CODE_CLASS.
Enumerator
tcc_exceptional 
tcc_constant 
tcc_type 
tcc_declaration 
tcc_reference 
tcc_comparison 
tcc_unary 
tcc_binary 
tcc_statement 
tcc_vl_exp 
tcc_expression 

◆ tree_index

enum tree_index : unsigned 
Standard named or nameless data types of the C compiler.
Enumerator
TI_ERROR_MARK 
TI_INTQI_TYPE 
TI_INTHI_TYPE 
TI_INTSI_TYPE 
TI_INTDI_TYPE 
TI_INTTI_TYPE 
TI_UINTQI_TYPE 
TI_UINTHI_TYPE 
TI_UINTSI_TYPE 
TI_UINTDI_TYPE 
TI_UINTTI_TYPE 
TI_ATOMICQI_TYPE 
TI_ATOMICHI_TYPE 
TI_ATOMICSI_TYPE 
TI_ATOMICDI_TYPE 
TI_ATOMICTI_TYPE 
TI_UINT16_TYPE 
TI_UINT32_TYPE 
TI_UINT64_TYPE 
TI_UINT128_TYPE 
TI_VOID 
TI_INTEGER_ZERO 
TI_INTEGER_ONE 
TI_INTEGER_MINUS_ONE 
TI_NULL_POINTER 
TI_SIZE_ZERO 
TI_SIZE_ONE 
TI_BITSIZE_ZERO 
TI_BITSIZE_ONE 
TI_BITSIZE_UNIT 
TI_PUBLIC 
TI_PROTECTED 
TI_PRIVATE 
TI_BOOLEAN_FALSE 
TI_BOOLEAN_TRUE 
TI_FLOAT_TYPE 
TI_DOUBLE_TYPE 
TI_LONG_DOUBLE_TYPE 
TI_BFLOAT16_TYPE 
TI_FLOAT16_TYPE 
TI_FLOATN_TYPE_FIRST 
TI_FLOATN_NX_TYPE_FIRST 
TI_FLOAT32_TYPE 
TI_FLOAT64_TYPE 
TI_FLOAT128_TYPE 
TI_FLOATN_TYPE_LAST 
TI_FLOAT32X_TYPE 
TI_FLOATNX_TYPE_FIRST 
TI_FLOAT64X_TYPE 
TI_FLOAT128X_TYPE 
TI_FLOATNX_TYPE_LAST 
TI_FLOATN_NX_TYPE_LAST 
TI_FLOAT128T_TYPE 
TI_COMPLEX_INTEGER_TYPE 
TI_COMPLEX_FLOAT_TYPE 
TI_COMPLEX_DOUBLE_TYPE 
TI_COMPLEX_LONG_DOUBLE_TYPE 
TI_COMPLEX_FLOAT16_TYPE 
TI_COMPLEX_FLOATN_NX_TYPE_FIRST 
TI_COMPLEX_FLOAT32_TYPE 
TI_COMPLEX_FLOAT64_TYPE 
TI_COMPLEX_FLOAT128_TYPE 
TI_COMPLEX_FLOAT32X_TYPE 
TI_COMPLEX_FLOAT64X_TYPE 
TI_COMPLEX_FLOAT128X_TYPE 
TI_FLOAT_PTR_TYPE 
TI_DOUBLE_PTR_TYPE 
TI_LONG_DOUBLE_PTR_TYPE 
TI_INTEGER_PTR_TYPE 
TI_VOID_TYPE 
TI_PTR_TYPE 
TI_CONST_PTR_TYPE 
TI_SIZE_TYPE 
TI_PID_TYPE 
TI_PTRDIFF_TYPE 
TI_VA_LIST_TYPE 
TI_VA_LIST_GPR_COUNTER_FIELD 
TI_VA_LIST_FPR_COUNTER_FIELD 
TI_BOOLEAN_TYPE 
TI_FILEPTR_TYPE 
TI_CONST_TM_PTR_TYPE 
TI_FENV_T_PTR_TYPE 
TI_CONST_FENV_T_PTR_TYPE 
TI_FEXCEPT_T_PTR_TYPE 
TI_CONST_FEXCEPT_T_PTR_TYPE 
TI_POINTER_SIZED_TYPE 
TI_DFLOAT32_TYPE 
TI_DFLOAT64_TYPE 
TI_DFLOAT128_TYPE 
TI_DFLOAT64X_TYPE 
TI_VOID_LIST_NODE 
TI_MAIN_IDENTIFIER 
TI_SAT_SFRACT_TYPE 
TI_SAT_FRACT_TYPE 
TI_SAT_LFRACT_TYPE 
TI_SAT_LLFRACT_TYPE 
TI_SAT_USFRACT_TYPE 
TI_SAT_UFRACT_TYPE 
TI_SAT_ULFRACT_TYPE 
TI_SAT_ULLFRACT_TYPE 
TI_SFRACT_TYPE 
TI_FRACT_TYPE 
TI_LFRACT_TYPE 
TI_LLFRACT_TYPE 
TI_USFRACT_TYPE 
TI_UFRACT_TYPE 
TI_ULFRACT_TYPE 
TI_ULLFRACT_TYPE 
TI_SAT_SACCUM_TYPE 
TI_SAT_ACCUM_TYPE 
TI_SAT_LACCUM_TYPE 
TI_SAT_LLACCUM_TYPE 
TI_SAT_USACCUM_TYPE 
TI_SAT_UACCUM_TYPE 
TI_SAT_ULACCUM_TYPE 
TI_SAT_ULLACCUM_TYPE 
TI_SACCUM_TYPE 
TI_ACCUM_TYPE 
TI_LACCUM_TYPE 
TI_LLACCUM_TYPE 
TI_USACCUM_TYPE 
TI_UACCUM_TYPE 
TI_ULACCUM_TYPE 
TI_ULLACCUM_TYPE 
TI_QQ_TYPE 
TI_HQ_TYPE 
TI_SQ_TYPE 
TI_DQ_TYPE 
TI_TQ_TYPE 
TI_UQQ_TYPE 
TI_UHQ_TYPE 
TI_USQ_TYPE 
TI_UDQ_TYPE 
TI_UTQ_TYPE 
TI_SAT_QQ_TYPE 
TI_SAT_HQ_TYPE 
TI_SAT_SQ_TYPE 
TI_SAT_DQ_TYPE 
TI_SAT_TQ_TYPE 
TI_SAT_UQQ_TYPE 
TI_SAT_UHQ_TYPE 
TI_SAT_USQ_TYPE 
TI_SAT_UDQ_TYPE 
TI_SAT_UTQ_TYPE 
TI_HA_TYPE 
TI_SA_TYPE 
TI_DA_TYPE 
TI_TA_TYPE 
TI_UHA_TYPE 
TI_USA_TYPE 
TI_UDA_TYPE 
TI_UTA_TYPE 
TI_SAT_HA_TYPE 
TI_SAT_SA_TYPE 
TI_SAT_DA_TYPE 
TI_SAT_TA_TYPE 
TI_SAT_UHA_TYPE 
TI_SAT_USA_TYPE 
TI_SAT_UDA_TYPE 
TI_SAT_UTA_TYPE 
TI_MODULE_HWM 
TI_OPTIMIZATION_DEFAULT 
TI_OPTIMIZATION_CURRENT 
TI_TARGET_OPTION_DEFAULT 
TI_TARGET_OPTION_CURRENT 
TI_CURRENT_TARGET_PRAGMA 
TI_CURRENT_OPTIMIZE_PRAGMA 
TI_CHREC_DONT_KNOW 
TI_CHREC_KNOWN 
TI_MAX 

◆ tree_node_kind

enum tree_node_kind 
Enum and arrays used for tree allocation stats.
Keep in sync with tree.cc:tree_node_kind_names.
Enumerator
d_kind 
t_kind 
b_kind 
s_kind 
r_kind 
e_kind 
c_kind 
id_kind 
vec_kind 
binfo_kind 
ssa_name_kind 
constr_kind 
x_kind 
lang_decl 
lang_type 
omp_clause_kind 
all_kinds 

◆ tree_node_structure_enum

enum tree_node_structure_enum
Enumerator
LAST_TS_ENUM 
This file contains the definitions for the tree structure
   enumeration used in GCC.

Copyright (C) 2005-2024 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/>.   
The format of this file is

DEFTREESTRUCT(enumeration value, printable name).

Each enumeration value should correspond with a single member of
union tree_node.

These enumerator values are used in order to distinguish members of
union tree_node for garbage collection purposes, as well as
specifying what structures contain what other structures in the
tree_contains_struct array.