[thirdparty/gcc.git] / gcc / flag-types.h

/* Compilation switch flag type definitions for GCC.
   Copyright (C) 1987-2020 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/>.  */

#ifndef GCC_FLAG_TYPES_H
#define GCC_FLAG_TYPES_H

enum debug_info_type
{
  NO_DEBUG,	    /* Write no debug info.  */
  DBX_DEBUG,	    /* Write BSD .stabs for DBX (using dbxout.c).  */
  DWARF2_DEBUG,	    /* Write Dwarf v2 debug info (using dwarf2out.c).  */
  XCOFF_DEBUG,	    /* Write IBM/Xcoff debug info (using dbxout.c).  */
  VMS_DEBUG,        /* Write VMS debug info (using vmsdbgout.c).  */
  VMS_AND_DWARF2_DEBUG /* Write VMS debug info (using vmsdbgout.c).
                          and DWARF v2 debug info (using dwarf2out.c).  */
};

enum debug_info_levels
{
  DINFO_LEVEL_NONE,	/* Write no debugging info.  */
  DINFO_LEVEL_TERSE,	/* Write minimal info to support tracebacks only.  */
  DINFO_LEVEL_NORMAL,	/* Write info for all declarations (and line table).  */
  DINFO_LEVEL_VERBOSE	/* Write normal info plus #define/#undef info.  */
};

/* A major contribution to object and executable size is debug
   information size.  A major contribution to debug information
   size is struct descriptions replicated in several object files.
   The following function determines whether or not debug information
   should be generated for a given struct.  The indirect parameter
   indicates that the struct is being handled indirectly, via
   a pointer.  See opts.c for the implementation. */

enum debug_info_usage
{
  DINFO_USAGE_DFN,	/* A struct definition. */
  DINFO_USAGE_DIR_USE,	/* A direct use, such as the type of a variable. */
  DINFO_USAGE_IND_USE,	/* An indirect use, such as through a pointer. */
  DINFO_USAGE_NUM_ENUMS	/* The number of enumerators. */
};

/* A major contribution to object and executable size is debug
   information size.  A major contribution to debug information size
   is struct descriptions replicated in several object files. The
   following flags attempt to reduce this information.  The basic
   idea is to not emit struct debugging information in the current
   compilation unit when that information will be generated by
   another compilation unit.

   Debug information for a struct defined in the current source
   file should be generated in the object file.  Likewise the
   debug information for a struct defined in a header should be
   generated in the object file of the corresponding source file.
   Both of these case are handled when the base name of the file of
   the struct definition matches the base name of the source file
   of the current compilation unit.  This matching emits minimal
   struct debugging information.

   The base file name matching rule above will fail to emit debug
   information for structs defined in system headers.  So a second
   category of files includes system headers in addition to files
   with matching bases.

   The remaining types of files are library headers and application
   headers.  We cannot currently distinguish these two types.  */

enum debug_struct_file
{
  DINFO_STRUCT_FILE_NONE,   /* Debug no structs. */
  DINFO_STRUCT_FILE_BASE,   /* Debug structs defined in files with the
                               same base name as the compilation unit. */
  DINFO_STRUCT_FILE_SYS,    /* Also debug structs defined in system
                               header files.  */
  DINFO_STRUCT_FILE_ANY     /* Debug structs defined in all files. */
};

/* Balance between GNAT encodings and standard DWARF to emit.  */

enum dwarf_gnat_encodings
{
  DWARF_GNAT_ENCODINGS_ALL = 0,	    /* Emit all GNAT encodings, then emit as
				       much standard DWARF as possible so it
				       does not conflict with GNAT
				       encodings.  */
  DWARF_GNAT_ENCODINGS_GDB = 1,	    /* Emit as much standard DWARF as possible
				       as long as GDB handles them.  Emit GNAT
				       encodings for the rest.  */
  DWARF_GNAT_ENCODINGS_MINIMAL = 2  /* Emit all the standard DWARF we can.
				       Emit GNAT encodings for the rest.  */
};

/* Enumerate Objective-c instance variable visibility settings. */

enum ivar_visibility
{
  IVAR_VISIBILITY_PRIVATE,
  IVAR_VISIBILITY_PROTECTED,
  IVAR_VISIBILITY_PUBLIC,
  IVAR_VISIBILITY_PACKAGE
};

/* The stack reuse level.  */
enum stack_reuse_level
{
  SR_NONE,
  SR_NAMED_VARS,
  SR_ALL
};

/* The live patching level.  */
enum live_patching_level
{
  LIVE_PATCHING_NONE = 0,
  LIVE_PATCHING_INLINE_ONLY_STATIC,
  LIVE_PATCHING_INLINE_CLONE
};

/* The algorithm used for basic block reordering.  */
enum reorder_blocks_algorithm
{
  REORDER_BLOCKS_ALGORITHM_SIMPLE,
  REORDER_BLOCKS_ALGORITHM_STC
};

/* The algorithm used for the integrated register allocator (IRA).  */
enum ira_algorithm
{
  IRA_ALGORITHM_CB,
  IRA_ALGORITHM_PRIORITY
};

/* The regions used for the integrated register allocator (IRA).  */
enum ira_region
{
  IRA_REGION_ONE,
  IRA_REGION_ALL,
  IRA_REGION_MIXED,
  /* This value means that there were no options -fira-region on the
     command line and that we should choose a value depending on the
     used -O option.  */
  IRA_REGION_AUTODETECT
};

/* The options for excess precision.  */
enum excess_precision
{
  EXCESS_PRECISION_DEFAULT,
  EXCESS_PRECISION_FAST,
  EXCESS_PRECISION_STANDARD
};

/* The options for which values of FLT_EVAL_METHOD are permissible.  */
enum permitted_flt_eval_methods
{
  PERMITTED_FLT_EVAL_METHODS_DEFAULT,
  PERMITTED_FLT_EVAL_METHODS_TS_18661,
  PERMITTED_FLT_EVAL_METHODS_C11
};

/* Type of stack check.

   Stack checking is designed to detect infinite recursion and stack
   overflows for Ada programs.  Furthermore stack checking tries to ensure
   in that scenario that enough stack space is left to run a signal handler.

   -fstack-check= does not prevent stack-clash style attacks.  For that
   you want -fstack-clash-protection.  */
enum stack_check_type
{
  /* Do not check the stack.  */
  NO_STACK_CHECK = 0,

  /* Check the stack generically, i.e. assume no specific support
     from the target configuration files.  */
  GENERIC_STACK_CHECK,

  /* Check the stack and rely on the target configuration files to
     check the static frame of functions, i.e. use the generic
     mechanism only for dynamic stack allocations.  */
  STATIC_BUILTIN_STACK_CHECK,

  /* Check the stack and entirely rely on the target configuration
     files, i.e. do not use the generic mechanism at all.  */
  FULL_BUILTIN_STACK_CHECK
};

/* Type of callgraph information.  */
enum callgraph_info_type
{
  /* No information.  */
  NO_CALLGRAPH_INFO = 0,

  /* Naked callgraph.  */
  CALLGRAPH_INFO_NAKED = 1,

  /* Callgraph decorated with stack usage information.  */
  CALLGRAPH_INFO_STACK_USAGE = 2,

  /* Callgraph decoration with dynamic allocation information.  */
  CALLGRAPH_INFO_DYNAMIC_ALLOC = 4
};

/* Floating-point contraction mode.  */
enum fp_contract_mode {
  FP_CONTRACT_OFF = 0,
  FP_CONTRACT_ON = 1,
  FP_CONTRACT_FAST = 2
};

/* Scalar storage order kind.  */
enum scalar_storage_order_kind {
  SSO_NATIVE = 0,
  SSO_BIG_ENDIAN,
  SSO_LITTLE_ENDIAN
};

/* Vectorizer cost-model.  */
enum vect_cost_model {
  VECT_COST_MODEL_UNLIMITED = 0,
  VECT_COST_MODEL_CHEAP = 1,
  VECT_COST_MODEL_DYNAMIC = 2,
  VECT_COST_MODEL_DEFAULT = 3
};

/* Different instrumentation modes.  */
enum sanitize_code {
  /* AddressSanitizer.  */
  SANITIZE_ADDRESS = 1UL << 0,
  SANITIZE_USER_ADDRESS = 1UL << 1,
  SANITIZE_KERNEL_ADDRESS = 1UL << 2,
  /* ThreadSanitizer.  */
  SANITIZE_THREAD = 1UL << 3,
  /* LeakSanitizer.  */
  SANITIZE_LEAK = 1UL << 4,
  /* UndefinedBehaviorSanitizer.  */
  SANITIZE_SHIFT_BASE = 1UL << 5,
  SANITIZE_SHIFT_EXPONENT = 1UL << 6,
  SANITIZE_DIVIDE = 1UL << 7,
  SANITIZE_UNREACHABLE = 1UL << 8,
  SANITIZE_VLA = 1UL << 9,
  SANITIZE_NULL = 1UL << 10,
  SANITIZE_RETURN = 1UL << 11,
  SANITIZE_SI_OVERFLOW = 1UL << 12,
  SANITIZE_BOOL = 1UL << 13,
  SANITIZE_ENUM = 1UL << 14,
  SANITIZE_FLOAT_DIVIDE = 1UL << 15,
  SANITIZE_FLOAT_CAST = 1UL << 16,
  SANITIZE_BOUNDS = 1UL << 17,
  SANITIZE_ALIGNMENT = 1UL << 18,
  SANITIZE_NONNULL_ATTRIBUTE = 1UL << 19,
  SANITIZE_RETURNS_NONNULL_ATTRIBUTE = 1UL << 20,
  SANITIZE_OBJECT_SIZE = 1UL << 21,
  SANITIZE_VPTR = 1UL << 22,
  SANITIZE_BOUNDS_STRICT = 1UL << 23,
  SANITIZE_POINTER_OVERFLOW = 1UL << 24,
  SANITIZE_BUILTIN = 1UL << 25,
  SANITIZE_POINTER_COMPARE = 1UL << 26,
  SANITIZE_POINTER_SUBTRACT = 1UL << 27,
  SANITIZE_SHIFT = SANITIZE_SHIFT_BASE | SANITIZE_SHIFT_EXPONENT,
  SANITIZE_UNDEFINED = SANITIZE_SHIFT | SANITIZE_DIVIDE | SANITIZE_UNREACHABLE
		       | SANITIZE_VLA | SANITIZE_NULL | SANITIZE_RETURN
		       | SANITIZE_SI_OVERFLOW | SANITIZE_BOOL | SANITIZE_ENUM
		       | SANITIZE_BOUNDS | SANITIZE_ALIGNMENT
		       | SANITIZE_NONNULL_ATTRIBUTE
		       | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
		       | SANITIZE_OBJECT_SIZE | SANITIZE_VPTR
		       | SANITIZE_POINTER_OVERFLOW | SANITIZE_BUILTIN,
  SANITIZE_UNDEFINED_NONDEFAULT = SANITIZE_FLOAT_DIVIDE | SANITIZE_FLOAT_CAST
				  | SANITIZE_BOUNDS_STRICT
};

/* Settings of flag_incremental_link.  */
enum incremental_link {
  INCREMENTAL_LINK_NONE,
  /* Do incremental linking and produce binary.  */
  INCREMENTAL_LINK_NOLTO,
  /* Do incremental linking and produce IL.  */
  INCREMENTAL_LINK_LTO
};

/* Different trace modes.  */
enum sanitize_coverage_code {
  /* Trace PC.  */
  SANITIZE_COV_TRACE_PC = 1 << 0,
  /* Trace Comparison.  */
  SANITIZE_COV_TRACE_CMP = 1 << 1
};

/* flag_vtable_verify initialization levels. */
enum vtv_priority {
  VTV_NO_PRIORITY       = 0,  /* i.E. Do NOT do vtable verification. */
  VTV_STANDARD_PRIORITY = 1,
  VTV_PREINIT_PRIORITY  = 2
};

/* flag_lto_partition initialization values.  */
enum lto_partition_model {
  LTO_PARTITION_NONE = 0,
  LTO_PARTITION_ONE = 1,
  LTO_PARTITION_BALANCED = 2,
  LTO_PARTITION_1TO1 = 3,
  LTO_PARTITION_MAX = 4
};

/* flag_lto_linker_output initialization values.  */
enum lto_linker_output {
  LTO_LINKER_OUTPUT_UNKNOWN,
  LTO_LINKER_OUTPUT_REL,
  LTO_LINKER_OUTPUT_NOLTOREL,
  LTO_LINKER_OUTPUT_DYN,
  LTO_LINKER_OUTPUT_PIE,
  LTO_LINKER_OUTPUT_EXEC
};

/* gfortran -finit-real= values.  */

enum gfc_init_local_real
{
  GFC_INIT_REAL_OFF = 0,
  GFC_INIT_REAL_ZERO,
  GFC_INIT_REAL_NAN,
  GFC_INIT_REAL_SNAN,
  GFC_INIT_REAL_INF,
  GFC_INIT_REAL_NEG_INF
};

/* gfortran -fcoarray= values.  */

enum gfc_fcoarray
{
  GFC_FCOARRAY_NONE = 0,
  GFC_FCOARRAY_SINGLE,
  GFC_FCOARRAY_LIB
};


/* gfortran -fconvert= values; used for unformatted I/O.
   Keep in sync with GFC_CONVERT_* in gcc/fortran/libgfortran.h.   */
enum gfc_convert
{
  GFC_FLAG_CONVERT_NATIVE = 0,
  GFC_FLAG_CONVERT_SWAP,
  GFC_FLAG_CONVERT_BIG,
  GFC_FLAG_CONVERT_LITTLE
};


/* Control-Flow Protection values.  */
enum cf_protection_level
{
  CF_NONE = 0,
  CF_BRANCH = 1 << 0,
  CF_RETURN = 1 << 1,
  CF_FULL = CF_BRANCH | CF_RETURN,
  CF_SET = 1 << 2
};

/* Parloops schedule type.  */
enum parloops_schedule_type
{
  PARLOOPS_SCHEDULE_STATIC = 0,
  PARLOOPS_SCHEDULE_DYNAMIC,
  PARLOOPS_SCHEDULE_GUIDED,
  PARLOOPS_SCHEDULE_AUTO,
  PARLOOPS_SCHEDULE_RUNTIME
};

#endif /* ! GCC_FLAG_TYPES_H */
Commit	Line	Data
f938f60c	1	/* Compilation switch flag type definitions for GCC.
8d9254fc	2	Copyright (C) 1987-2020 Free Software Foundation, Inc.
f938f60c JM	3
	4	This file is part of GCC.
	5
	6	GCC is free software; you can redistribute it and/or modify it under
	7	the terms of the GNU General Public License as published by the Free
	8	Software Foundation; either version 3, or (at your option) any later
	9	version.
	10
	11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GCC; see the file COPYING3. If not see
	18	<http://www.gnu.org/licenses/>. */
	19
	20	#ifndef GCC_FLAG_TYPES_H
	21	#define GCC_FLAG_TYPES_H
	22
	23	enum debug_info_type
	24	{
	25	NO_DEBUG, /* Write no debug info. */
	26	DBX_DEBUG, /* Write BSD .stabs for DBX (using dbxout.c). */
f938f60c JM	27	DWARF2_DEBUG, /* Write Dwarf v2 debug info (using dwarf2out.c). */
	28	XCOFF_DEBUG, /* Write IBM/Xcoff debug info (using dbxout.c). */
	29	VMS_DEBUG, /* Write VMS debug info (using vmsdbgout.c). */
	30	VMS_AND_DWARF2_DEBUG /* Write VMS debug info (using vmsdbgout.c).
	31	and DWARF v2 debug info (using dwarf2out.c). */
	32	};
	33
0576d21f	34	enum debug_info_levels
f938f60c JM	35	{
	36	DINFO_LEVEL_NONE, /* Write no debugging info. */
	37	DINFO_LEVEL_TERSE, /* Write minimal info to support tracebacks only. */
	38	DINFO_LEVEL_NORMAL, /* Write info for all declarations (and line table). */
	39	DINFO_LEVEL_VERBOSE /* Write normal info plus #define/#undef info. */
	40	};
	41
	42	/* A major contribution to object and executable size is debug
	43	information size. A major contribution to debug information
	44	size is struct descriptions replicated in several object files.
	45	The following function determines whether or not debug information
	46	should be generated for a given struct. The indirect parameter
	47	indicates that the struct is being handled indirectly, via
	48	a pointer. See opts.c for the implementation. */
	49
	50	enum debug_info_usage
	51	{
	52	DINFO_USAGE_DFN, /* A struct definition. */
	53	DINFO_USAGE_DIR_USE, /* A direct use, such as the type of a variable. */
	54	DINFO_USAGE_IND_USE, /* An indirect use, such as through a pointer. */
	55	DINFO_USAGE_NUM_ENUMS /* The number of enumerators. */
	56	};
	57
69ccdddb JM	58	/* A major contribution to object and executable size is debug
	59	information size. A major contribution to debug information size
	60	is struct descriptions replicated in several object files. The
	61	following flags attempt to reduce this information. The basic
	62	idea is to not emit struct debugging information in the current
	63	compilation unit when that information will be generated by
	64	another compilation unit.
	65
	66	Debug information for a struct defined in the current source
	67	file should be generated in the object file. Likewise the
	68	debug information for a struct defined in a header should be
	69	generated in the object file of the corresponding source file.
	70	Both of these case are handled when the base name of the file of
	71	the struct definition matches the base name of the source file
	72	of the current compilation unit. This matching emits minimal
	73	struct debugging information.
	74
	75	The base file name matching rule above will fail to emit debug
	76	information for structs defined in system headers. So a second
	77	category of files includes system headers in addition to files
	78	with matching bases.
	79
	80	The remaining types of files are library headers and application
	81	headers. We cannot currently distinguish these two types. */
	82
	83	enum debug_struct_file
	84	{
	85	DINFO_STRUCT_FILE_NONE, /* Debug no structs. */
	86	DINFO_STRUCT_FILE_BASE, /* Debug structs defined in files with the
	87	same base name as the compilation unit. */
	88	DINFO_STRUCT_FILE_SYS, /* Also debug structs defined in system
	89	header files. */
	90	DINFO_STRUCT_FILE_ANY /* Debug structs defined in all files. */
	91	};
	92
6592d14b PMR	93	/* Balance between GNAT encodings and standard DWARF to emit. */
	94
	95	enum dwarf_gnat_encodings
	96	{
	97	DWARF_GNAT_ENCODINGS_ALL = 0, /* Emit all GNAT encodings, then emit as
	98	much standard DWARF as possible so it
	99	does not conflict with GNAT
	100	encodings. */
	101	DWARF_GNAT_ENCODINGS_GDB = 1, /* Emit as much standard DWARF as possible
	102	as long as GDB handles them. Emit GNAT
	103	encodings for the rest. */
	104	DWARF_GNAT_ENCODINGS_MINIMAL = 2 /* Emit all the standard DWARF we can.
	105	Emit GNAT encodings for the rest. */
	106	};
	107
dcaaa5a0 DP	108	/* Enumerate Objective-c instance variable visibility settings. */
	109
	110	enum ivar_visibility
	111	{
	112	IVAR_VISIBILITY_PRIVATE,
	113	IVAR_VISIBILITY_PROTECTED,
	114	IVAR_VISIBILITY_PUBLIC,
	115	IVAR_VISIBILITY_PACKAGE
	116	};
	117
87e2a8fd XDL	118	/* The stack reuse level. */
	119	enum stack_reuse_level
	120	{
	121	SR_NONE,
	122	SR_NAMED_VARS,
	123	SR_ALL
	124	};
	125
6fd6a2ff QZ	126	/* The live patching level. */
	127	enum live_patching_level
	128	{
	129	LIVE_PATCHING_NONE = 0,
	130	LIVE_PATCHING_INLINE_ONLY_STATIC,
	131	LIVE_PATCHING_INLINE_CLONE
	132	};
	133
59faab7c SB	134	/* The algorithm used for basic block reordering. */
	135	enum reorder_blocks_algorithm
	136	{
	137	REORDER_BLOCKS_ALGORITHM_SIMPLE,
	138	REORDER_BLOCKS_ALGORITHM_STC
	139	};
	140
f938f60c JM	141	/* The algorithm used for the integrated register allocator (IRA). */
	142	enum ira_algorithm
	143	{
	144	IRA_ALGORITHM_CB,
	145	IRA_ALGORITHM_PRIORITY
	146	};
	147
	148	/* The regions used for the integrated register allocator (IRA). */
	149	enum ira_region
	150	{
	151	IRA_REGION_ONE,
	152	IRA_REGION_ALL,
ffe8727f VM	153	IRA_REGION_MIXED,
	154	/* This value means that there were no options -fira-region on the
	155	command line and that we should choose a value depending on the
	156	used -O option. */
	157	IRA_REGION_AUTODETECT
f938f60c JM	158	};
	159
	160	/* The options for excess precision. */
	161	enum excess_precision
	162	{
	163	EXCESS_PRECISION_DEFAULT,
	164	EXCESS_PRECISION_FAST,
	165	EXCESS_PRECISION_STANDARD
	166	};
	167
04f0fcf7 JG	168	/* The options for which values of FLT_EVAL_METHOD are permissible. */
	169	enum permitted_flt_eval_methods
	170	{
	171	PERMITTED_FLT_EVAL_METHODS_DEFAULT,
	172	PERMITTED_FLT_EVAL_METHODS_TS_18661,
	173	PERMITTED_FLT_EVAL_METHODS_C11
	174	};
	175
ee8f15c6 JL	176	/* Type of stack check.
	177
	178	Stack checking is designed to detect infinite recursion and stack
	179	overflows for Ada programs. Furthermore stack checking tries to ensure
	180	in that scenario that enough stack space is left to run a signal handler.
	181
	182	-fstack-check= does not prevent stack-clash style attacks. For that
	183	you want -fstack-clash-protection. */
f938f60c JM	184	enum stack_check_type
	185	{
	186	/* Do not check the stack. */
	187	NO_STACK_CHECK = 0,
	188
	189	/* Check the stack generically, i.e. assume no specific support
	190	from the target configuration files. */
	191	GENERIC_STACK_CHECK,
	192
	193	/* Check the stack and rely on the target configuration files to
	194	check the static frame of functions, i.e. use the generic
	195	mechanism only for dynamic stack allocations. */
	196	STATIC_BUILTIN_STACK_CHECK,
	197
	198	/* Check the stack and entirely rely on the target configuration
	199	files, i.e. do not use the generic mechanism at all. */
	200	FULL_BUILTIN_STACK_CHECK
	201	};
	202
3cf3da88 EB	203	/* Type of callgraph information. */
	204	enum callgraph_info_type
	205	{
	206	/* No information. */
	207	NO_CALLGRAPH_INFO = 0,
	208
	209	/* Naked callgraph. */
	210	CALLGRAPH_INFO_NAKED = 1,
	211
	212	/* Callgraph decorated with stack usage information. */
	213	CALLGRAPH_INFO_STACK_USAGE = 2,
	214
	215	/* Callgraph decoration with dynamic allocation information. */
	216	CALLGRAPH_INFO_DYNAMIC_ALLOC = 4
	217	};
	218
16949072 RG	219	/* Floating-point contraction mode. */
	220	enum fp_contract_mode {
	221	FP_CONTRACT_OFF = 0,
	222	FP_CONTRACT_ON = 1,
	223	FP_CONTRACT_FAST = 2
	224	};
	225
ee45a32d EB	226	/* Scalar storage order kind. */
	227	enum scalar_storage_order_kind {
	228	SSO_NATIVE = 0,
	229	SSO_BIG_ENDIAN,
	230	SSO_LITTLE_ENDIAN
	231	};
	232
d6d11272 XDL	233	/* Vectorizer cost-model. */
	234	enum vect_cost_model {
	235	VECT_COST_MODEL_UNLIMITED = 0,
	236	VECT_COST_MODEL_CHEAP = 1,
	237	VECT_COST_MODEL_DYNAMIC = 2,
	238	VECT_COST_MODEL_DEFAULT = 3
	239	};
	240
de5a5fa1 MP	241	/* Different instrumentation modes. */
	242	enum sanitize_code {
	243	/* AddressSanitizer. */
5cc6c41c ML	244	SANITIZE_ADDRESS = 1UL << 0,
	245	SANITIZE_USER_ADDRESS = 1UL << 1,
	246	SANITIZE_KERNEL_ADDRESS = 1UL << 2,
de5a5fa1	247	/* ThreadSanitizer. */
5cc6c41c	248	SANITIZE_THREAD = 1UL << 3,
9065ada9	249	/* LeakSanitizer. */
5cc6c41c	250	SANITIZE_LEAK = 1UL << 4,
de5a5fa1	251	/* UndefinedBehaviorSanitizer. */
2e955d50 JJ	252	SANITIZE_SHIFT_BASE = 1UL << 5,
	253	SANITIZE_SHIFT_EXPONENT = 1UL << 6,
	254	SANITIZE_DIVIDE = 1UL << 7,
	255	SANITIZE_UNREACHABLE = 1UL << 8,
	256	SANITIZE_VLA = 1UL << 9,
	257	SANITIZE_NULL = 1UL << 10,
	258	SANITIZE_RETURN = 1UL << 11,
	259	SANITIZE_SI_OVERFLOW = 1UL << 12,
	260	SANITIZE_BOOL = 1UL << 13,
	261	SANITIZE_ENUM = 1UL << 14,
	262	SANITIZE_FLOAT_DIVIDE = 1UL << 15,
	263	SANITIZE_FLOAT_CAST = 1UL << 16,
	264	SANITIZE_BOUNDS = 1UL << 17,
	265	SANITIZE_ALIGNMENT = 1UL << 18,
	266	SANITIZE_NONNULL_ATTRIBUTE = 1UL << 19,
	267	SANITIZE_RETURNS_NONNULL_ATTRIBUTE = 1UL << 20,
	268	SANITIZE_OBJECT_SIZE = 1UL << 21,
	269	SANITIZE_VPTR = 1UL << 22,
	270	SANITIZE_BOUNDS_STRICT = 1UL << 23,
c9b39a49	271	SANITIZE_POINTER_OVERFLOW = 1UL << 24,
07d7c611	272	SANITIZE_BUILTIN = 1UL << 25,
05abad4c ML	273	SANITIZE_POINTER_COMPARE = 1UL << 26,
05abad4c ML	274	SANITIZE_POINTER_SUBTRACT = 1UL << 27,
2e955d50	275	SANITIZE_SHIFT = SANITIZE_SHIFT_BASE \| SANITIZE_SHIFT_EXPONENT,
de5a5fa1	276	SANITIZE_UNDEFINED = SANITIZE_SHIFT \| SANITIZE_DIVIDE \| SANITIZE_UNREACHABLE
0a508bb6	277	\| SANITIZE_VLA \| SANITIZE_NULL \| SANITIZE_RETURN
0e37a2f3	278	\| SANITIZE_SI_OVERFLOW \| SANITIZE_BOOL \| SANITIZE_ENUM
126edc3f JJ	279	\| SANITIZE_BOUNDS \| SANITIZE_ALIGNMENT
126edc3f JJ	280	\| SANITIZE_NONNULL_ATTRIBUTE
0e82f089	281	\| SANITIZE_RETURNS_NONNULL_ATTRIBUTE
c9b39a49	282	\| SANITIZE_OBJECT_SIZE \| SANITIZE_VPTR
07d7c611	283	\| SANITIZE_POINTER_OVERFLOW \| SANITIZE_BUILTIN,
45b2222a ML	284	SANITIZE_UNDEFINED_NONDEFAULT = SANITIZE_FLOAT_DIVIDE \| SANITIZE_FLOAT_CAST
45b2222a ML	285	\| SANITIZE_BOUNDS_STRICT
de5a5fa1 MP	286	};
de5a5fa1 MP	287
5b42d196 JH	288	/* Settings of flag_incremental_link. */
	289	enum incremental_link {
	290	INCREMENTAL_LINK_NONE,
	291	/* Do incremental linking and produce binary. */
	292	INCREMENTAL_LINK_NOLTO,
	293	/* Do incremental linking and produce IL. */
	294	INCREMENTAL_LINK_LTO
	295	};
	296
f6e50a7d WW	297	/* Different trace modes. */
	298	enum sanitize_coverage_code {
	299	/* Trace PC. */
	300	SANITIZE_COV_TRACE_PC = 1 << 0,
	301	/* Trace Comparison. */
	302	SANITIZE_COV_TRACE_CMP = 1 << 1
	303	};
	304
2077db1b CT	305	/* flag_vtable_verify initialization levels. */
	306	enum vtv_priority {
	307	VTV_NO_PRIORITY = 0, /* i.E. Do NOT do vtable verification. */
	308	VTV_STANDARD_PRIORITY = 1,
	309	VTV_PREINIT_PRIORITY = 2
	310	};
783dab6b RB	311
	312	/* flag_lto_partition initialization values. */
	313	enum lto_partition_model {
	314	LTO_PARTITION_NONE = 0,
	315	LTO_PARTITION_ONE = 1,
	316	LTO_PARTITION_BALANCED = 2,
	317	LTO_PARTITION_1TO1 = 3,
	318	LTO_PARTITION_MAX = 4
	319	};
	320
1ff9ed6f JH	321	/* flag_lto_linker_output initialization values. */
	322	enum lto_linker_output {
	323	LTO_LINKER_OUTPUT_UNKNOWN,
	324	LTO_LINKER_OUTPUT_REL,
5b42d196	325	LTO_LINKER_OUTPUT_NOLTOREL,
1ff9ed6f JH	326	LTO_LINKER_OUTPUT_DYN,
	327	LTO_LINKER_OUTPUT_PIE,
	328	LTO_LINKER_OUTPUT_EXEC
	329	};
f19626cf TB	330
	331	/* gfortran -finit-real= values. */
	332
	333	enum gfc_init_local_real
	334	{
	335	GFC_INIT_REAL_OFF = 0,
	336	GFC_INIT_REAL_ZERO,
	337	GFC_INIT_REAL_NAN,
	338	GFC_INIT_REAL_SNAN,
	339	GFC_INIT_REAL_INF,
	340	GFC_INIT_REAL_NEG_INF
	341	};
	342
	343	/* gfortran -fcoarray= values. */
	344
	345	enum gfc_fcoarray
	346	{
	347	GFC_FCOARRAY_NONE = 0,
	348	GFC_FCOARRAY_SINGLE,
	349	GFC_FCOARRAY_LIB
	350	};
	351
	352
	353	/* gfortran -fconvert= values; used for unformatted I/O.
	354	Keep in sync with GFC_CONVERT_* in gcc/fortran/libgfortran.h. */
	355	enum gfc_convert
	356	{
	357	GFC_FLAG_CONVERT_NATIVE = 0,
	358	GFC_FLAG_CONVERT_SWAP,
	359	GFC_FLAG_CONVERT_BIG,
	360	GFC_FLAG_CONVERT_LITTLE
	361	};
	362
	363
5c5f0b65 IT	364	/* Control-Flow Protection values. */
	365	enum cf_protection_level
	366	{
	367	CF_NONE = 0,
	368	CF_BRANCH = 1 << 0,
	369	CF_RETURN = 1 << 1,
	370	CF_FULL = CF_BRANCH \| CF_RETURN,
	371	CF_SET = 1 << 2
	372	};
7e1792c9 ML	373
	374	/* Parloops schedule type. */
	375	enum parloops_schedule_type
	376	{
	377	PARLOOPS_SCHEDULE_STATIC = 0,
	378	PARLOOPS_SCHEDULE_DYNAMIC,
	379	PARLOOPS_SCHEDULE_GUIDED,
	380	PARLOOPS_SCHEDULE_AUTO,
	381	PARLOOPS_SCHEDULE_RUNTIME
	382	};
	383
f938f60c	384	#endif /* ! GCC_FLAG_TYPES_H */