#
#     Copyright (c) 2017-2024, NVIDIA CORPORATION.  All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto.  Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
# 

# Compiler Configurations for native x86 targets
#

# Target specific LLVM opt flags
#set OPTTARGET160ARGS=  # not currently used, for example only
set OPTTARGET170ARGS=$ifn($INTEL,$if($USECLANG,-mllvm) -memdep-block-scan-limit=160,);
set OPTTARGET180ARGS=$ifn($INTEL,$if($USECLANG,-mllvm) -memdep-block-scan-limit=160,);
set OPTTARGET190ARGS=$ifn($INTEL,$if($USECLANG,-mllvm) -memdep-block-scan-limit=160,);
set OPTTARGET200ARGS=$ifn($INTEL,$if($USECLANG,-mllvm) -memdep-block-scan-limit=160,);

# Target specific NVHPC LLVM opt flags
set NVOPTTARGET170ARGS=-nvhpc-consider-undef=true
                        $if($equal($TPVAL, -tp znver3), -nvhpc-shuffle-opt,)
                        $if($equal($TPVAL, -tp icelake-server), 
                            -nvhpc-unswitch-loops-with-trip-count=4,
                            -nvhpc-unswitch-loops-with-trip-count=2
                        );
set NVOPTTARGET180ARGS=-nvhpc-consider-undef=true
                        $if($equal($TPVAL, -tp znver3), -nvhpc-shuffle-opt,)
                        $if($equal($TPVAL, -tp icelake-server),
                            -nvhpc-unswitch-loops-with-trip-count=4,
                            -nvhpc-unswitch-loops-with-trip-count=2
                        );
set NVOPTTARGET190ARGS=-nvhpc-consider-undef=true
                        #$if($equal($TPVAL, -tp znver3), -nvhpc-shuffle-opt,)
                        $if($equal($TPVAL, -tp sapphirerapids), -nvhpc-phi-opt=true)
                        $if($contains($TPVAL, icelake-server,sapphirerapids,znver3,znver4),
                            -nvhpc-store-opt=true)
                        $if($contains($TPVAL, icelake-server,znver4),
                            -nvhpc-unswitch-loops-with-trip-count=4,
                            -nvhpc-unswitch-loops-with-trip-count=2
                        )
                        -nvhpc-reassoc=true 
                        $if($equal($TPVAL, -tp sapphirerapids), -nvhpc-consider-doms=false)
                        $if($equal($TPVAL, -tp znver4),
                            -nvhpc-consider-doms=false -nvhpc-gep-opt=false)
                        $if($contains($TPVAL, icelake-server,znver4),
                            -nvhpc-select-fold=true)
                        $if($contains($TPVAL, sapphirerapids,znver4),
                            $if($not($ISFTN), -nvhpc-slp-gather-opt=true))
                        $if($contains($TPVAL, sapphirerapids,znver4),
                            -nvhpc-slp-gather-cost=true)
                        $if($equal($TPVAL, -tp znver4),
                            -nvhpc-ashr-opt=true)
                        $if($equal($TPVAL, -tp znver4),
                            -nvhpc-$escape(switch)-opt=true)
                        #$if($equal($TPVAL, -tp icelake-server),
                        #    -nvhpc-slp-avoid-long-stores=true)
                        $if($equal($TPVAL, -tp znver3),
                            -unroll-partial-threshold=29)
                        $if($equal($TPVAL, -tp znver4),
                            -partial-unrolling-threshold=12)
                        ;

set NVOPTTARGET200ARGS=-nvhpc-consider-undef=true
                        #$if($equal($TPVAL, -tp znver3), -nvhpc-shuffle-opt,)
                        $if($equal($TPVAL, -tp icelake-server),
                            -nvhpc-unswitch-loops-with-trip-count=4,
                            -nvhpc-unswitch-loops-with-trip-count=2
                        );

# Target specific LLVM llc flags
# -dwarf-directory=false: The older assemblers do not like DWARF5 directory syntax
set LLCTARGETCOMMONARGS=-x86-cmov-converter=$LLCX86CMOV -dwarf-directory=false;
set LLCTARGET160ARGS=$LLCTARGETCOMMONARGS;
set LLCTARGET170ARGS=$LLCTARGETCOMMONARGS;
set LLCTARGET180ARGS=$LLCTARGETCOMMONARGS;
set LLCTARGET190ARGS=$LLCTARGETCOMMONARGS;
set LLCTARGET200ARGS=$LLCTARGETCOMMONARGS;

# Target specific NVHPC LLVM llc flags
set NVLLCTARGET170ARGS=;
set NVLLCTARGET180ARGS=;
set NVLLCTARGET190ARGS=$if($contains($TPVAL, sapphirerapids,znver4,bdver2),
                           -nvhpc-select-transform=true)
                       $if($equal($TPVAL, -tp sapphirerapids),
                           -x86-br-merging-base-cost=0)
                       $if($equal($TPVAL, -tp sapphirerapids),
                           -enable-split-loopiv-heuristic=false)
                       $if($equal($TPVAL, -tp znver4),
                           -nvhpc-block-freq=true)
                       ;
set NVLLCTARGET200ARGS=;

set LLVMOPTSKIPNATIVE=0;

# enable dwarf generation by default
variable DODWARF is default(1);

variable DLLIB is default($(LIBSW)dl);

variable ATHLON is
    default(0);

variable INTEL is default($test(intel));

# X86_64 is set if the host is a x86_64, meaning -tp k8 is allowed
variable X86_64 is
    default($test(x86_64));

# X86_64TARGET is set if the target processor is a x86_64 (amd64, ia32e)
# default is to $test(x86_64)
# but X86_64TARGET will still be set
variable X86_64TARGET is
    default($test(x86_64));

variable DEFFLUSHVAL is
    default();

variable FLUSHVAL is
    default($DEFFLUSHVAL);

variable WRSTR is
    default($if(-Xt,-y 119 0x20,$if(-Xs,-y 119 0x20,-x 119 0x20)));

append CARGS=$WRSTR $DEFGNUC;
append CPP1ARGS=$DEFGNU;
append CPP2ARGS=$DEFGNU2;
set PGATM=$PGISTATICX -lnvhpcatm $PGIUNSTATICX;
# threadprivate C++ runtime
append CPP2ARGS=-x 69 0x200;
append CPP1ARGS=$if($REALNOFRAME,--no_fixed_bp);

# Keep track of which x86 extended instructions are available.  Only a few of
# them are automatically detected, and some borrow the automatic detection of
# a different group of instructions.  The automatic detection should be
# enhanced and expanded over time.
variable NO_TP_OR_TP_HOST is	default($if($or($ISTPHOST,$ifn(-tp,1,0)),1,0));
variable ABM		is	default($if($NO_TP_OR_TP_HOST,$test(abm)));
variable ADX		is	default($if($NO_TP_OR_TP_HOST,$test(adx)));
variable AES		is	default($if($NO_TP_OR_TP_HOST,$test(aes)));
variable AMX_BF16	is	default($if($NO_TP_OR_TP_HOST,$test(amx_bf16)));
variable AMX_COMPLEX	is	default($if($NO_TP_OR_TP_HOST,$test(amx_complex)));
variable AMX_FP16	is	default($if($NO_TP_OR_TP_HOST,$test(amx_fp16)));
variable AMX_INT8	is	default($if($NO_TP_OR_TP_HOST,$test(amx_int8)));
variable AMX_TILE	is	default($if($NO_TP_OR_TP_HOST,$test(amx_tile)));
variable AVX		is	default(1);
variable AVX2		is	default($if($NO_TP_OR_TP_HOST,$test(avx2)));
variable AVX512BF16     is 	default($if($NO_TP_OR_TP_HOST,$test(avx512bf16)));
variable AVX512BITALG	is	default($if($NO_TP_OR_TP_HOST,$test(avx512bitalg)));
variable AVX512BW	is	default($if($NO_TP_OR_TP_HOST,$test(avx512bw)));
variable AVX512CD	is	default($if($NO_TP_OR_TP_HOST,$test(avx512cd)));
variable AVX512DQ	is	default($if($NO_TP_OR_TP_HOST,$test(avx512dq)));
variable AVX512ER	is	default($if($NO_TP_OR_TP_HOST,$test(avx512er)));
variable AVX512F	is	default($if($NO_TP_OR_TP_HOST,$test(avx512f)));
variable AVX512FP16     is 	default($if($NO_TP_OR_TP_HOST,$test(avx512fp16)));
variable AVX512IFMA	is	default($if($NO_TP_OR_TP_HOST,$test(avx512ifma)));
variable AVX512PF	is	default($if($NO_TP_OR_TP_HOST,$test(avx512pf)));
variable AVX512VBMI	is	default($if($NO_TP_OR_TP_HOST,$test(avx512vbmi)));
variable AVX512VBMI2	is	default($if($NO_TP_OR_TP_HOST,$test(avx512vbmi2)));
variable AVX512VL	is	default($if($NO_TP_OR_TP_HOST,$test(avx512vl)));
variable AVX512VNNI	is	default($if($NO_TP_OR_TP_HOST,$test(avx512vnni)));
variable AVX512VP2INTERSECT	is	default($if($NO_TP_OR_TP_HOST,$test(avx512vp2intersect)));
variable AVX512VPOPCNTDQ is	default($if($NO_TP_OR_TP_HOST,$test(avx512vpopcntdq)));
variable AVXIFMA	is	default($if($NO_TP_OR_TP_HOST,$test(avxifma)));
variable AVXNECONVERT	is	default($if($NO_TP_OR_TP_HOST,$test(avxneconvert)));
variable AVXVNNI	is	default($if($NO_TP_OR_TP_HOST,$test(avxvnni)));
variable AVXVNNIINT8	is	default($if($NO_TP_OR_TP_HOST,$test(avxvnniint8)));
variable BMI		is	default($if($NO_TP_OR_TP_HOST,$test(bmi1)));
variable BMI2		is	default($if($NO_TP_OR_TP_HOST,$test(bmi2)));
variable CLDEMOTE	is	default($if($NO_TP_OR_TP_HOST,$test(cldemote)));
variable CLFLUSHOPT	is	default($if($NO_TP_OR_TP_HOST,$test(clflushopt)));
variable CLWB		is	default($if($NO_TP_OR_TP_HOST,$test(clwb)));
variable CLZERO		is	default($if($NO_TP_OR_TP_HOST,$test(clzero)));
variable CMPCCXADD	is	default($if($NO_TP_OR_TP_HOST,$test(cmpccxadd)));
variable CX16		is	default($if($NO_TP_OR_TP_HOST,$test(cx16)));
variable ENQCMD		is	default($if($NO_TP_OR_TP_HOST,$test(enqcmd)));
variable F16C		is	default($if($NO_TP_OR_TP_HOST,$test(f16c)));
variable FMA		is	default($if($NO_TP_OR_TP_HOST,$test(fma)));
variable FMA4		is	default($if($NO_TP_OR_TP_HOST,$test(fma4)));
variable FSGSBASE	is	default($if($NO_TP_OR_TP_HOST,$test(fsgsbase)));
variable FXSR		is	default(1);
variable GFNI		is	default($if($NO_TP_OR_TP_HOST,$test(gfni)));
variable HLE		is	default($if($NO_TP_OR_TP_HOST,$test(hle)));
variable HRESET		is	default($if($NO_TP_OR_TP_HOST,$test(hreset)));
variable KL		is	default($if($NO_TP_OR_TP_HOST,$test(kl)));
variable LWP		is	default($if($NO_TP_OR_TP_HOST,$test(lwp)));
variable LZCNT		is	default($if($NO_TP_OR_TP_HOST,$test(abm)));
variable MMX		is	default(1);
variable MOVBE		is	default($if($NO_TP_OR_TP_HOST,$test(movbe)));
variable MOVDIR64B	is	default($if($NO_TP_OR_TP_HOST,$test(movdir64b)));
variable MOVDIRI	is	default($if($NO_TP_OR_TP_HOST,$test(movdiri)));
variable MPX		is	default(0); # MPX	is	pretty much deprecated everywhere.
variable MWAITX		is	default($if($NO_TP_OR_TP_HOST,$test(mwaitx)));
variable PCLMUL		is	default(1);
variable PCONFIG	is	default($if($NO_TP_OR_TP_HOST,$test(pconfig)));
variable PKU		is	default($if($NO_TP_OR_TP_HOST,$test(pku)));
variable POPCNT		is	default(1);
variable PREFETCHI	is	default($if($NO_TP_OR_TP_HOST,$test(prefetchi)));
variable PREFETCHWT1	is	default($if($NO_TP_OR_TP_HOST,$test(prefetchwt1)));
variable PRFCHW		is	default($if($NO_TP_OR_TP_HOST,$test(prfchw)));
variable PTWRITE	is	default($if($NO_TP_OR_TP_HOST,$test(ptwrite)));
variable RAOINT		is	default($if($NO_TP_OR_TP_HOST,$test(raoint)));
variable RDPID		is	default($if($NO_TP_OR_TP_HOST,$test(rdpid)));
variable RDRND		is	default($if($NO_TP_OR_TP_HOST,$test(rdrand)));
variable RDSEED		is	default($if($NO_TP_OR_TP_HOST,$test(rdseed)));
variable RTM		is	default($if($NO_TP_OR_TP_HOST,$test(rtm)));
variable SAHF		is	default(1);
variable SERIALIZE	is	default($if($NO_TP_OR_TP_HOST,$test(serialize)));
variable SGX		is	default($if($NO_TP_OR_TP_HOST,$test(sgx)));
variable SHA		is	default($if($NO_TP_OR_TP_HOST,$test(sha)));
variable SHSTK		is	default($if($NO_TP_OR_TP_HOST,$test(shstk)));
variable SSE		is	default(1);
variable SSE2		is	default(1);
variable SSE3		is	default(1);
variable SSE41		is	default(1);
variable SSE42		is	default(1);
variable SSE4A		is	default($if($NO_TP_OR_TP_HOST,$test(sse4a)));
variable SSSE3		is	default(1);
variable TBM		is	default($if($NO_TP_OR_TP_HOST,$test(tbm)));
variable TSXLDTRK	is	default($if($NO_TP_OR_TP_HOST,$test(tsxldtrk)));
variable UINTR		is	default($if($NO_TP_OR_TP_HOST,$test(uintr)));
variable VAES		is	default($if($NO_TP_OR_TP_HOST,$test(vaes)));
variable VPCLMULQDQ	is	default($if($NO_TP_OR_TP_HOST,$test(vpclmulqdq)));
variable WAITPKG	is	default($if($NO_TP_OR_TP_HOST,$test(waitpkg)));
variable WBNOINVD	is	default($if($NO_TP_OR_TP_HOST,$test(wbnoinvd)));
variable WIDEKL		is	default($if($NO_TP_OR_TP_HOST,$test(widekl)));
variable XOP		is	default($if($NO_TP_OR_TP_HOST,$test(xop)));
variable XSAVE		is	default(1);
variable XSAVEC		is	default($if($NO_TP_OR_TP_HOST,$test(xsavec)));
variable XSAVEOPT	is	default($if($NO_TP_OR_TP_HOST,$test(xsaveopt)));
variable XSAVES		is	default($if($NO_TP_OR_TP_HOST,$test(xsaves)));
variable ZNVER2		is	default($if($NO_TP_OR_TP_HOST,$test(znver2)));
variable ZNVER3		is	default($if($NO_TP_OR_TP_HOST,$test(znver3)));
variable ZNVER4		is	default($if($NO_TP_OR_TP_HOST,$test(znver4)));
variable ZNVER5		is	default($if($NO_TP_OR_TP_HOST,$test(znver5)));

variable mach_bitflag is default(
  -mach $add(
  $if($and($M_SSE,$SSE),0x1),
  $if($and($M_SSE2,$SSE2),0x2),
  $if($and($M_SSE3,$SSE3),0x4),
  $if($and($M_SSE41,$SSE41),0x8),
  $if($and($M_SSE42,$SSE42),0x10),
  $if($and($M_SSE4A,$SSE4A),0x20),
  $if($and($M_AVX,$AVX),0x40),
  $if($and($M_AVX2,$AVX2),0x80),
  $if($and($M_AVX512F,$AVX512F),0x100),
  $if($and($M_AVX512VL,$AVX512VL),0x200),
  $if($and($M_ABM,$ABM),0x400),
  $if($and($M_FMA,$FMA),0x800),
  $if($and($M_FMA4,$FMA4),0x1000),
));

variable nomach_bitflag is default(
  -nomach $add(
  $if($and($M_SSE,$notequal($SSE,1)),0x1),
  $if($and($M_SSE2,$notequal($SSE2,1)),0x2),
  $if($and($M_SSE3,$notequal($SSE3,1)),0x4),
  $if($and($M_SSE41,$notequal($SSE41,1)),0x8),
  $if($and($M_SSE42,$notequal($SSE42,1)),0x10),
  $if($and($M_SSE4A,$notequal($SSE4A,1)),0x20),
  $if($and($M_AVX,$notequal($AVX,1)),0x40),
  $if($and($M_AVX2,$notequal($AVX2,1)),0x80),
  $if($and($M_AVX512F,$notequal($AVX512F,1)),0x100),
  $if($and($M_AVX512VL,$notequal($AVX512VL,1)),0x200),
  $if($and($M_ABM,$notequal($ABM,1)),0x400),
  $if($and($M_FMA,$notequal($FMA,1)),0x800),
  $if($and($M_FMA4,$notequal($FMA4,1)),0x1000),
));

append CPP2ARGS=$mach_bitflag $nomach_bitflag;
append F901ARGS=$mach_bitflag $nomach_bitflag;
append F902ARGS=$mach_bitflag $nomach_bitflag;
#
# M_<ATTRIBUTE> vars are nonzero if -m<attribute> is specified on the
# command line.
#
variable M_ABM			is	default(0);
variable M_ADX			is	default(0);
variable M_AES			is	default(0);
variable M_AMX_BF16		is	default(0);
variable M_AMX_COMPLEX		is	default(0);
variable M_AMX_FP16		is	default(0);
variable M_AMX_INT8		is	default(0);
variable M_AMX_TILE		is	default(0);
variable M_AVX			is	default(0);
variable M_AVX2			is	default(0);
variable M_AVX512BF16i		is 	default(0);
variable M_AVX512BITALG		is	default(0);
variable M_AVX512BW		is	default(0);
variable M_AVX512CD		is	default(0);
variable M_AVX512DQ		is	default(0);
variable M_AVX512ER		is	default(0);
variable M_AVX512F		is	default(0);
variable M_AVX512FP16   	is 	default(0);
variable M_AVX512IFMA		is	default(0);
variable M_AVX512PF		is	default(0);
variable M_AVX512VBMI		is	default(0);
variable M_AVX512VBMI2		is	default(0);
variable M_AVX512VL		is	default(0);
variable M_AVX512VNNI		is	default(0);
variable M_AVX512VP2INTERSECT	is	default(0);
variable M_AVX512VPOPCNTDQ 	is	default(0);
variable M_AVXIFMA		is	default(0);
variable M_AVXNECONVERT		is	default(0);
variable M_AVXVNNI		is	default(0);
variable M_AVXVNNIINT8		is	default(0);
variable M_BMI			is	default(0);
variable M_BMI2			is	default(0);
variable M_CLDEMOTE		is	default(0);
variable M_CLFLUSHOPT		is	default(0);
variable M_CLWB			is	default(0);
variable M_CLZERO		is	default(0);
variable M_CMPCCXADD		is	default(0);
variable M_CX16			is	default(0);
variable M_ENQCMD		is	default(0);
variable M_F16C			is	default(0);
variable M_FMA			is	default(0);
variable M_FMA4			is	default(0);
variable M_FSGSBASE		is	default(0);
variable M_FXSR			is	default(0);
variable M_GFNI			is	default(0);
variable M_HLE			is	default(0);
variable M_HRESET		is	default(0);
variable M_KL			is	default(0);
variable M_LWP			is	default(0);
variable M_LZCNT		is	default(0);
variable M_MMX			is	default(0);
variable M_MOVBE		is	default(0);
variable M_MOVDIR64B		is	default(0);
variable M_MOVDIRI		is	default(0);
variable M_MPX			is	default(0);
variable M_MWAITX		is	default(0);
variable M_PCLMUL		is	default(0);
variable M_PCONFIG		is	default(0);
variable M_PKU			is	default(0);
variable M_POPCNT		is	default(0);
variable M_PREFETCHI		is	default(0);
variable M_PREFETCHWT1		is	default(0);
variable M_PRFCHW		is	default(0);
variable M_PTWRITE		is	default(0);
variable M_RAOINT		is	default(0);
variable M_RDPID		is	default(0);
variable M_RDRND		is	default(0);
variable M_RDSEED		is	default(0);
variable M_RTM			is	default(0);
variable M_SAHF			is	default(0);
variable M_SERIALIZE		is	default(0);
variable M_SGX			is	default(0);
variable M_SHA			is	default(0);
variable M_SHSTK		is	default(0);
variable M_SSE			is	default(0);
variable M_SSE2			is	default(0);
variable M_SSE3			is	default(0);
variable M_SSE41		is	default(0);
variable M_SSE42		is	default(0);
variable M_SSE4A		is	default(0);
variable M_SSSE3		is	default(0);
variable M_TBM			is	default(0);
variable M_TSXLDTRK		is	default(0);
variable M_UINTR		is	default(0);
variable M_VAES			is	default(0);
variable M_VPCLMULQDQ		is	default(0);
variable M_WAITPKG		is	default(0);
variable M_WBNOINVD		is	default(0);
variable M_WIDEKL		is	default(0);
variable M_XOP			is	default(0);
variable M_XSAVE		is	default(0);
variable M_XSAVEC		is	default(0);
variable M_XSAVEOPT		is	default(0);
variable M_XSAVES		is	default(0);

variable KNL is
        default(0);
variable LIBMEMIL is
	default($if($SSE2,$lookup($COMPBASE/$COMPSYS/$COMPVER/$(COMPLIBPREFIX)lib,libmem.il)));
variable INTRINLEVEL is
	default(4);

variable BASIC_SSE_DEFS is default(
	__MMX__
	__SSE_MATH__
	__MMX_WITH_SSE__
	__SSE__
	__SSE2__
	__SSE2_MATH__
	__SSE3__
	__SSSE3__
	$if($SSE4A,__SSE4A__)
	__SSE4_1__
	__SSE4_2__
);

variable FULL_SSE_DEFS is default(
	$BASIC_SSE_DEFS
	$if($ABM,__ABM__)
	$if($ADX,__ADX__)
	$if($AES,__AES__)
	$if($AMX_BF16,__AMX_BF16__)
	$if($AMX_COMPLEX,__AMX_COMPLEX__)
	$if($AMX_FP16,__AMX_FP16__)
	$if($AMX_INT8,__AMX_INT8__)
	$if($AMX_TILE,__AMX_TILE__)
	__AVX__
	$if($AVX2,__AVX2__)
	$if($AVX512BF16,__AVX512BF16__)
	$if($AVX512BITALG,__AVX512BITALG__)
	$if($AVX512BW,__AVX512BW__)
	$if($AVX512CD,__AVX512CD__)
	$if($AVX512DQ,__AVX512DQ__)
	$if($AVX512ER,__AVX512ER__)
	$if($AVX512F,__AVX512F__)
	$if($AVX512FP16,__AVX512FP16__)
	$if($AVX512IFMA,__AVX512IFMA__)
	$if($AVX512PF,__AVX512PF__)
	$if($AVX512VBMI,__AVX512VBMI__)
	$if($AVX512VBMI2,__AVX512VBMI2__)
	$if($AVX512VL,__AVX512VL__)
	$if($AVX512VNNI,__AVX512VNNI__)
	$if($AVX512VP2INTERSECT,__AVX512VP2INTERSECT__)
	$if($AVX512VPOPCNTDQ,__AVX512VPOPCNTDQ__)
	$if($AVXIFMA,__AVXIFMA__)
	$if($AVXNECONVERT,__AVXNECONVERT__)
	$if($AVXVNNI,__AVXVNNI__)
	$if($AVXVNNIINT8,__AVXVNNIINT8__)
	$if($BMI,__BMI__)
	$if($BMI2,__BMI2__)
	$if($CLDEMOTE,__CLDEMOTE__)
	$if($CLFLUSHOPT,__CLFLUSHOPT__)
	$if($CLWB,__CLWB__)
	$if($CLZERO,__CLZERO__)
	$if($CMPCCXADD,__CMPCCXADD__)
	$if($CX16,__CX16__)
	$if($ENQCMD,__ENQCMD__)
	$if($F16C,__F16C__)
	$if($FMA,__FMA__)
	$if($FMA4,__FMA4__)
	$if($FSGSBASE,__FSGSBASE__)
	$if($FXSR,__FXSR__)
	$if($GFNI,__GFNI__)
	$if($HLE,__HLE__)
	$if($HRESET,__HRESET__)
	$if($KL,__KL__)
	$if($LWP,__LWP__)
	$if($LZCNT,__LZCNT__)
	$if($MOVBE,__MOVBE__)
	$if($MOVDIR64B,__MOVDIR64B__)
	$if($MOVDIRI,__MOVDIRI__)
	$if($MWAITX,__MWAITX__)
	$if($PCLMUL,__PCLMUL__)
	$if($PCONFIG,__PCONFIG__)
	$if($PKU,__PKU__)
	$if($POPCNT,__POPCNT__)
	$if($PREFETCHI,__PREFETCHI__)
	$if($PREFETCHWT1,__PREFETCHWT1__)
	$if($PRFCHW,__PRFCHW__)
	$if($PTWRITE,__PTWRITE__)
	$if($RAOINT,__RAOINT__)
	$if($RDPID,__RDPID__)
	$if($RDRND,__RDRND__)
	$if($RDSEED,__RDSEED__)
	$if($RTM,__RTM__)
	$if($SAHF,__LAHF_SAHF__)
	$if($SERIALIZE,__SERIALIZE__)
	$if($SGX,__SGX__)
	$if($SHA,__SHA__)
	$if($SHSTK,__SHSTK__)
	$if($TBM,__TBM__)
	$if($TSXLDTRK,__TSXLDTRK__)
	$if($UINTR,__UINTR__)
	$if($VAES,__VAES__)
	$if($VPCLMULQDQ,__VPCLMULQDQ__)
	$if($WAITPKG,__WAITPKG__)
	$if($WBNOINVD,__WBNOINVD__)
	$if($WIDEKL,__WIDEKL__)
	$if($XOP,__XOP__)
	$if($XSAVE,__XSAVE__)
	$if($XSAVEC,__XSAVEC__)
	$if($XSAVEOPT,__XSAVEOPT__)
	$if($XSAVES,__XSAVES__)
	);

# LLVM uses the full set of SSE-related macros.
variable SSEDEFS is default($FULL_SSE_DEFS);

# User can override default MPIDIR with environment variable,
# otherwise MPI is found from $DRIVERDIR.
variable MPIUDIR is environment(MPIDIR);
variable MPITYPE is environment(MPITYPE) default(MPICH);
variable MPIBASEDIR is default($if($MPIUDIR,$MPIUDIR,$DRIVERDIR/../mpi/mpich));

variable MPIINC is default($MPIBASEDIR/include);

variable MPILIBDIRNAME is default(lib);
variable MPIBASELIB is default($MPIBASEDIR/lib);
variable MPILIB is default($MPIBASELIB);

# open fabrics infiniband libs for mvapich et al
variable OFEDLIBDIR is default($if(environment(OFEDLIBDIR),environment(OFEDLIBDIR),$if($isdir(/usr/lib64),/usr/lib64)));

# Use SGI-specific MPI_ROOT if set, otherwise use MPIDIR if set,
# otherwise use default if it exists
variable MPISGIROOT is environment(MPI_ROOT);
variable MPISGIDIR is default($if($MPISGIROOT,$MPISGIROOT,$if($MPIUDIR,$MPIUDIR,/opt/sgi/mpt/mpt-2.06)));
variable MPISGILIB is default($MPISGIDIR/lib);
variable MPISGIINC is default($MPISGIDIR/include);

# User can override the default MPI library for linking
variable MPILIBNAME is environment(MPILIBNAME) default(mpich);

variable MPILIBDIR is default($MPILIB);
variable MPILIBINC is default($MPIINC);

variable MPILIBVER is environment(MPILIBVER);

# MSMPI: headers, libraries, binaries
#
# For HPC 2012 SP1, MS-MPI is installed by an MS-MPI redistributable
# package and components are located by environment variables beginning
# with "MSMPI_". Support for HPC 2008 RTM/SP1/SP2 was dropped with the
# 14.0 release.

variable MSMPIDIR is default();

# MSMPI Inc
variable MSMPI_INC is environment(MSMPI_INC);
variable MSMPIINC is default($if($MSMPI_INC,$MSMPI_INC $(MSMPI_INC)amd64));
variable MPIMSINC is default($replace($MSMPIINC,"\\","/"));

# MSMPI Libs
variable MSMPI_LIB32 is environment(MSMPI_LIB32);
variable MSMPI_LIB64 is environment(MSMPI_LIB64);
variable MSMPILIB32 is default($if($MSMPI_LIB32,$MSMPI_LIB32));
variable MSMPILIB64 is default($if($MSMPI_LIB64,$MSMPI_LIB64));
variable MPIMSLIB is default($replace($if( $or($equal($TARGET,win64),$equal($TARGET,win64-llvm)),$MSMPILIB64),"\\","/"));
variable MPIMSLIBNAME is default(msmpi);

# The last two letters in the name of the MSMPI Fortran libraries
# denote the conditions under which they should be used. The second-to
# last letter indicates where character lengths are passed in an argument
# list where 'e' means at the end and 'm' means mixed with the other
# arguments. The last letter indicates the calling convention. On Win64,
# the only option is 'c'.
variable MSMPIFLIBNAME is default(msmpifec);
variable HASMSMPIFLIBNAME is default($and($ISFTN,$MSMPIFLIBNAME));
variable HASMSMPIFLIBNAME32 is default(0);
variable HASMSMPIFLIBNAME64 is default($and($MSMPIFLIBNAME,$or($equal($TARGET,win64),$equal($TARGET,win64-llvm))));

variable ISTPHOST is default(0);	# Whether -tp host is specified
variable CLTPVAL is default();	# command line TPVAL
variable ACTTPVAL is default($CLTPVAL);
variable TESTTPVAL is default($test(get_tp));
variable DEFTPVAL is default(
  -tp $choose(
    $equal($TESTTPVAL,unsupported),$error(Unsupported processor),
    $equal($TESTTPVAL,0),px,
    1,$TESTTPVAL
  )
);
variable USETPVAL is default($if($notequal($ACTTPVAL,),$ACTTPVAL,$DEFTPVAL));
variable MSGTPVAL is default();
variable INFOTPVAL is default($if($notequal($MSGTPVAL,),$MSGTPVAL,$DEFTPVAL));

variable TPVAL is
    default($FLUSHVAL $SETDAZ $USETPVAL);

#  if SSE
variable DEFUSESSELIBS is
	default($if($SSE,1));

variable USESSELIBS is
 	default($DEFUSESSELIBS$SCALARSSE$VECTSSE);

variable SCALARSSE is default();	# set if -Mscalarsse requires use of sse libraries
variable VECTSSE is default();	# set if -Mvect=sse requires use of sse libraries

variable CPP is default(pgCC);

variable PAPIDIR is
	default(/usr/local/lib)
	help(Directory containing libpapi.a);

set DEFC99=1;

# MPSET and MPSETCPP are set by -mp, and over-ridden by -Mpfi
variable MPSET is default($MPSETDEF);
variable MPSETDEF is default();
variable MPSETCPP is default($MPSETDEFCPP);
variable MPDEFCPPDEF is default();
variable MPDEFCPP is default($MPDEFCPPDEF);
variable MPSETDEFCPP is default();

# MPFAIR is set by -mp
variable MPFAIR is default($MPFAIRDEF);
variable MPFAIRDEF is default();

set DEFCCOMPDIR=$COMPBIN;

switch -gopt is
	help(Generate information for debugger without disabling optimizations)
	helpgroup(debug)
	set(DEBUG=-debug $DEFDEBUG $DEBUG2 -x 123 0x400)
	set(DODWARF=)
	set(DEBUGSET=1)
	set(DEBUGFLAG=1)
	set(DEBUG2DEF=-x 120 0x8000)
	append(F901ARGS=-x 49 0x1000)
	append(F902ARGS=$if($expr($CUDAXXYY>=11060), -x 120 0x2000000))
	append(CPP1ARGS=-g $DEBUGCPP);

switch -Kieee is
	help(Use IEEE division, optionally enable traps)
	helpgroup(target)
	helpname(-K[no]ieee)
	append(CGARGS=-x 42 0x400000)
	set(FLUSHVAL=-y 129 2 -x 129 0x8000)	# -Mnoflushz
	append(CGARGS=-y 129 4 -x 129 0x400) # -Mnodaz
	append(CGARGS=-x 28 0x08) # No MIN/MAX rewrite
	set(NOSIGNEDZEROS=0)      # disable no-signed-zeros
    set(NONAN=0)              # disable no-nan
	or(IEEE=1);

switch -Knoieee is hide
	help(Use default division, disable underflow traps)
	helpgroup(target)
	set(FLUSHVAL=$DEFFLUSHVAL)
        append(CGARGS=-y 28 0x08) # Allow MIN/MAX rewrite
	and(IEEE=0);

switch -Ktrap is
	help(Control IEEE floating point exception trapping)
	helpgroup(target)
	set(trapval=0)
	set(notrapval=0)
	keyword(
	    align(
		or(trapval=2) andnot(notrapval=2)
		help(Unaligned memory references))
	    divz(
		or(trapval=32) andnot(notrapval=32) #not
		help(Divide by zero))
	    denorm(
		or(trapval=16) andnot(notrapval=16)
		help(Denormalized))
	    fp(
		or(trapval=1) andnot(notrapval=1)
		help(Shorthand for -Ktrap=inv,divz,ovf))
	    inexact(
		or(trapval=256) andnot(notrapval=256) #not
		help(Inexact))
	    inv(
		or(trapval=8) andnot(notrapval=8) #not
		help(Invalid))
	    none(
		and(trapval=0) or(notrapval=511)
		help(Clear exceptions E.g. -Ktrap=inv,none,ovf implies -Ktrap=ovf))
	    ovf(
		or(trapval=64) andnot(notrapval=64) #not
		help(Overflow))
	    unf(
		or(trapval=128) andnot(notrapval=128) #not
		help(Underflow))
	)
	append(CGARGS=$if($trapval,-x 24 $trapval) $if($notrapval,-y 24 $notrapval));

switch -Mchkstk is
	help(Check for sufficient stack space upon subprogram entry)
	helpgroup(debug)
	append(CGARGS=-x 121 0x8000000);

switch -Mcoff is #not
	help(Generate COFF format object)
	helpgroup(debug)
	set(ASTYPE=COFF);

# also need to add libraries, objects

switch -Mdwarf3 is
	help(Generate DWARF3 debug information with -g)
	helpgroup(debug)
	set(DEBUG2=-x 120 0x4000)
	set(DEBUGCPP=--dwarf2);

switch -Mnodwarf is
	help(Do not add DWARF debug information)
	helpgroup(debug)
	set(DEBUG=-nodebug)
	set(DEBUGFLAG=0)
	set(DODWARF=);

switch -Melf is #not
	help(Generate ELF format object)
	helpgroup(debug)
	set(ASTYPE=ELF);

switch -Mflushz is
	help(Set SSE to flush-to-zero mode)
	helpgroup(target)
	helpname(-M[no]flushz)
	set(FLUSHVAL=)
	append(CGARGS=-x 129 2 -y 129 0x8000);

switch -Mnoflushz is
	hide
	help(Set SSE to no-flush-to-zero mode)
	helpgroup(target)
	set(FLUSHVAL=)
	append(CGARGS=-y 129 2 -x 129 0x8000);

switch -Mfma is
	helpgroup(opt)
	helpname(-M[no]fma)
	help(Enable (disable) generation of FMA instructions)
	shorthand(-Mnv-fma)
	;

switch -Mnofma is hide
	helpgroup(opt)
	help(Enable generation of FMA instructions)
	shorthand(-Mnonv-fma)
	;

# -x 15 0x04    - compute x/y as x*(1.0/y)  (aka div)
# -x 15 0x10    - relaxed fpmath
#                 includes rsqrt and sqrt if Intel 
#                 sqrt occurs for AMD iff the cputype check is disabled 
# -x 15 0x20    - disable cputype check for relaxed fpmath sqrt
# -x 15 0x400   - disable intrinsic
# -x 15 0x10000 - disable relaxed sqrt
# -x 15 0x20000 - disable relaxed rsqrt
# -x 15 0x40000 - disable relaxed recip (default and independent of
#                 cputype check)
# 
# -x 56 0x2     - order
# -x 187 0x10   - enables -Mfprelaxed=rsqrt for accelerator code
# -x 187 0x20   - 1/(x*sqrt(x)) computed as rsqrt(x)**3 for accelerator

switch -Mfprelaxed is
	help(Perform certain fp operations using relaxed precision)
	helpname(-M[no]fprelaxed)
	helpgroup(target)
	# div + relaxed fpmath defaults, norecip, LLVM 'fast' attribute
	shorthand(-Mllvm-fast)
	shorthand(-Mrecip-div)
	set(x15=$or(0x40010, $RECIPDIV))
	set(x56=2)
	set(x187=0x30)
	set(LLFASTMATH=1)
	keyword(
	    div(helpname([no]div) or(x15=0x4)
		help(Perform divide with relaxed precision))
	    nodiv(andnot(x15=0x4) hide
		help(Don't perform divide with relaxed precision))
	    intrinsic(or(x15=0x400) helpname([no]intrinsic)
		help(Perform intrinsics with relaxed precision))
	    nointrinsic(andnot(x15=0x400) hide
		help(Don't perform intrinsics with relaxed precision))
	    recip(andnot(x15=0x40000) helpname([no]recip)
		help(Perform reciprocal with relaxed precision))
	    norecip(or(x15=0x40000) hide
		help(Don't perform reciprocal with relaxed precision))
	    sqrt(or(x15=0x20) helpname([no]sqrt)
		andnot(x15=0x10000)
		help(Perform square root with relaxed precision))
	    nosqrt(or(x15=0x10000) hide
		help(Don't perform square root with relaxed precision))
	    rsqrt(helpname([no]rsqrt)
		andnot(x15=0x20000)
		or(x187=0x30)
		help(Perform reciprocal square root with relaxed precision)
		)
	    norsqrt(or(x15=0x20000) hide
		andnot(x187=0x30)
		help(Don't perform reciprocal square root with relaxed precision))
	    order(helpname([no]order)
		or(x56=2)
		help(Allow expression reordering, including factoring))
	    noorder(andnot(x56=2) hide
		help(Disallow expression reordering, including factoring))
	)
	nokeyword(
	    help(-Mfprelaxed=div,rsqrt,sqrt (sqrt only for x86_64 targets))
	)
	append(CGARGS  =-x 15 $x15 -x 56 $x56 -x 187 $x187)
	append(F901ARGS=-x 15 $x15 -x 56 $x56)
	;

switch -Mnofprelaxed is hide
	help(Don't enable relaxed fp operations)
	helpgroup(target)
	shorthand(-Mno-llvm-fast)
	set(XFPP=0)
	set(LLFASTMATH=0)
	set(LLFAST=0)
	append(CGARGS  =-y 15 0x70414 -y 56 2 -y 187 0x30)
	append(F901ARGS=-y 15 0x70414 -y 56 2 -y 187 0x30);

switch -Mfpapprox is
	help(Perform certain fp operations using low-precision approximation)
	helpname(-M[no]fpapprox)
	helpgroup(target)
	set(x15=0)
	keyword(
	    div(help(Approximate floating point division)
		or(x15=0x10000000))
	    sqrt(help(Approximate floating point square root)
		or(x15=0x20000000))
	    rsqrt(help(Approximate floating point reciprocal square root)
		or(x15=0x40000000))
	)
	nokeyword(
	    help(Approximate div,sqrt,rsqrt)
		or(x15=0x70000000)
	)
	append(CGARGS=$if($x15,-x 15 $x15));

switch -Mnofpapprox is hide
	help(Don't use low-precision fp approximation operations)
	helpgroup(target)
	append(CGARGS=-y 15 0x70000000);

switch -Mfpmisalign is
	help(Allow use of vector arithmetic instructions for unaligned operands)
	helpname(-M[no]fpmisalign)
	helpgroup(target)
	append(CGARGS=-x 129 0x100);

switch -Mnofpmisalign is hide
	help(Don't use vector arithmetic instructions for unaligned operands)
	helpgroup(target)
	append(CGARGS=-y 129 0x100);

switch -Mfptrap is hide
	help(For compatibility only, same as -Ktrap=fp)
	helpgroup(target)
	append(CGARGS=-x 24 1);

switch -Mnofptrap is hide
	help(For compatibility only, reverses -Ktrap=fp)
	helpgroup(target)
	append(CGARGS=-y 24 1);

switch -Mfunc32 is
	help(Align functions on 32 byte boundaries)
	helpname(-M[no]func32)
	helpgroup(target)
	append(CGARGS=-x 119 4)
	append(F901ARGS=-x 119 4);

switch -Mnofunc32 is hide
	help(Don't align functions on 32 byte boundaries)
	helpgroup(target)
	append(CGARGS=-y 119 4)
	append(F901ARGS=-y 119 4);

switch -Mloop32 is hide
	help(Align innermost loops on 32 byte boundaries with -tp barcelona)
	helpname(-M[no]loop32)
	helpgroup(target)
	append(CGARGS=-x 135 0x400000);

switch -Mnoloop32 is hide
	help(Don't align innermost loops on 32 byte boundaries with -tp barcelona)
	helpgroup(target)
	append(CGARGS=-y 135 0x400000);

switch -Mlongbranch is
	help(Enable long branches)
	helpgroup(target)
	helpname(-M[no]longbranch)
	append(CGARGS=-x 12 1);

switch -Mnolongbranch is
	hide
	help(Disable long branches)
	helpgroup(target)
	append(CGARGS=-y 12 1);

switch -Mmovnt is
	help(Force generation of nontemporal moves)
	helpgroup(opt)
	helpname(-M[no]movnt)
	append(CGARGS=-x 39 0x4200);

switch -Mnomovnt is hide
	help(Disable nontemporal moves; also disables -Mvect=movntaltcode)
	helpgroup(opt)
	append(CGARGS=-y 39 0x4200 -x 151 0x2000);

switch -Mnontemporal is hide
	help(Allow nontemporal moves and prefetching)
	helpgroup(opt)
	append(CGARGS=-x 39 0x4200);

variable DDEFNOOPENMP is default();
variable DEFNOOPENMP is default($DDEFNOOPENMP);
variable NOOPENMP is default($DEFNOOPENMP);

switch -Mnoopenmp is
	help(Ignore OpenMP directives; use with -mp)
	helpgroup(opt)
	set(NOOPENMP=-x 69 1);
	;

variable DDEFNOSGIMP is default();
variable DEFNOSGIMP is default($DDEFNOSGIMP);
variable NOSGIMP is default($DEFNOSGIMP);

switch -Mnosgimp is
	help(Ignore SGI parallelization directives; use with -mp)
	helpgroup(opt)
	set(NOSGIMP=-x 69 2);
	;

switch -Mnovintr is
	help(Do not generate vector intrinsic calls)
	helpgroup(opt)
	append(CGARGS=-x 34 8 -y 39 0x80);

switch -Mprefetch is
	help(Enable prefetch instructions)
	helpgroup(opt)
	helpname(-M[no]prefetch)
	append(CGARGS=-y 39 1)
	keyword(
	    default(hide append(CGARGS=-y 39 0x15800) help(Use default prefetch type heuristics))
	    distance:d(append(CGARGS=-x 142 $d) help(Set prefetch-ahead distance in cache lines))
	    n:n(append(CGARGS=-x 138 $n) help(Set maximum number of prefetches to generate))
	    nta(append(CGARGS=-y 39 0x14000 -x 39 0x800) help(Use prefetchnta))
	    plain(append(CGARGS=-y 39 0x4800 -x 39 0x10000) help(Use prefetch))
	    t0(append(CGARGS=-y 39 0x10800 -x 39 0x4000) help(Use prefetcht0))
	    w(append(CGARGS=-x 39 0x1000) help(Allow prefetchw))
	)
	nokeyword();

switch -Mnoprefetch is hide
	help(Disable prefetch instructions)
	helpgroup(opt)
	helpname(-Mnoprefetch)
	append(CGARGS=-x 39 1);

switch -Mpropcond is
	helpgroup(opt)
	helpname(-M[no]propcond)
	help(Enable constant propagation from assertions derived from equality conditionals)
	append(CGARGS=-y 6 0x80000);

switch -Mnopropcond is hide
	helpgroup(opt)
	help(Disable constant propagation from assertions derived from equality conditionals)
	append(CGARGS=-x 6 0x80000);

variable PROFFLAG is default();	# for error messages

switch -Mprof is
	help(Generate additional code for profiling)
	helpgroup(opt)
	set(profval=)
	set(profsw=)
	set(mpiprofsw=YES)
	set(mpinotok=1)
	set(mpiused=0)
	keyword(
	    ccff(	hide
			helpname([no]ccff) help(Enable (disable) CCFF information)
			set(enableccff=1) set(doccff=YES)
		)
	    noccff(	hide
			hide help(Disable CCFF information)
			set(enableccff=) set(doccff=)
		)
	    dwarf(
			help(Add limited DWARF info sufficient for performance profilers)
			error($if($equal($TARGET,nt86),"-Mprof=dwarf is not supported on this target"))
			append(CGARGS=-x 120 0x1000)
			append(DEBUGSET=$if($index($TARGET,win64,win64-llvm),1))
		)
	    func(
			hide help(Function-level profiling)
			warning(-Mprof=func does not enable profiling use the tool pgprof instead or the -Minstrument option for library interposition.)
			set(PROFILE=YES)	# default profile library
	                error($if($FPIC,"-Mprof=func is not supported with ")$FPIC)
	                set(PROFILESW=-Mprof=func)
			set(mpiprofsw=YES)
			set(mpinotok=0)
			set(profsw=YES)
			error($if($and($notequal($PROFFLAG,),$notequal($PROFFLAG,-Mprof=func)),Profile flag -Mprof=func is not valid with $PROFFLAG))
			set(PROFFLAG=-Mprof=func)
		)
	    lines(
			hide help(Line-level profiling)
			warning(-Mprof=lines is not supported)
		)
	    time(
			hide help(sampling profiling)
			warning(-Mprof=time is not supported)
		)
	    mpich(
			hide help(MPI profiling)
			warning(-Mprof=mpich is not supported)
		)
	    msmpi(
			hide help(MPI profiling)
			warning(-Mprof=msmpi is not supported)
		)
	    sgimpi(
			hide help(MPI profiling)
			warning(-Mprof=sgimpi is not supported)
		)
	    mpich1(
			hide help(MPI profiling)
			warning(-Mprof=mpich1 is not supported)
		)
	    mpich2(
			hide help(MPI profiling)
			warning(-Mprof=mpich2 is not supported)
		)
	    mvapich1(
			hide help(MPI profiling)
			warning(-Mprof=mvapich1 is not supported)
		)
	)
	nokeyword(
			)
	error($if($and($mpiused,$mpinotok),"-Mprof=" with mpi profiling option requires one of "-Mprof=time,func,line"))
	append(CGARGS=$if($profsw,-profile $profval))
	append(SETDOCCFF=$doccff)
	append(ENABLECCFF=$enableccff);

switch -Mpfi is
    help(Enable profile-feedback instrumentation)
    helpgroup(opt)
    set(PROFILE=YES)
    set(IPACGARGS=)	# disable IPA for profile instrumentation
    set(FIPACGARGS=)
    set(IPALINK=)
    set(MPSET=)
    set(MPSETCPP=)
    max(OPTLEVELDEF=2)
    max(OPTLEVELMIN=2)
    append(OPTLEVELMINLIMIT=" -Mpfi")
    append(CGARGS=-x 148 0x1 -x 19 0x80)
    keyword(
	indirect( helpname([no]indirect)
		help(Save [don't save] indirect function call targets)
		append(CGARGS=-x 148 0x4000000))
	noindirect( hide
		help(Don't save indirect function call targets)
		append(CGARGS=-y 148 0x4000000))
    )
    nokeyword();

info($if($and(-Mpfi,-mp),Switch -Mpfi disables -mp));

switch -Mpfo is
    help(Enable profile-feedback optimizations)
    helpgroup(opt)
    max(OPTLEVELDEF=2)
    max(OPTLEVELMIN=2)
    append(OPTLEVELMINLIMIT=" -Mpfo")
    append(CGARGS=-x 148 0x1000)
    keyword(
	indirect( helpname([no]indirect)
		help(Enable [disable] indirect function call inlining)
		append(CGARGS=-x 148 0x4000000))
	noindirect( hide help(Disable indirect function call inlining)
		append(CGARGS=-y 148 0x4000000))
	layout( help(Enable [disable] dynamic code layout) helpname([no]layout)
		append(CGARGS=-y 148 0x10000))
	nolayout( help(Disable dynamic code layout) hide
		append(CGARGS=-x 148 0x10000))
	dir:dir( help(Specify directory containing pgfi.out file)
		append(CGARGS=-pfodir $path($dir)))
	"":dir( hide help(Specify directory containing pgfi.out file)
		append(CGARGS=-pfodir $path($dir)))
    )
    nokeyword();

switch -ql is hide
	help(Enable line-level profiling";" same as -Mprof=lines)
	helpgroup(opt)
	error($if($FPIC,"-ql is not supported with ")$FPIC)
	set(PROFILE=YES)
	set(PROFILESW=-ql)
	append(CGARGS=-profile lines);

switch -Msafe_lastval is
	help(Allow parallelization of loops with conditional scalar assignments)
	helpgroup(opt)
	append(CGARGS=-x 34 0x800);

switch -Mscalarsse is hide
	help(Generate scalar sse code with xmm registers";" implies -Mflushz)
	helpgroup(opt)
	helpname(-M[no]scalarsse)
	set(DEFFLUSHVAL=-x 129 2 -y 129 0x8000)
	set(SCALARSSE=1)
	append(CGARGS=-x 80 0x800000);

switch -Mnoscalarsse is hide
	help(Don't generate scalar sse code with xmm registers)
	helpgroup(opt)
	set(DEFFLUSHVAL=-y 129 2)
	set(SCALARSSE=)
	append(CGARGS=-y 80 0x800000);

switch -Msecond_underscore is
	help(Add second underscore to global symbols that already contain an underscore)
	helpgroup(target)
	helpname(-M[no]second_underscore)
	append(CGARGS=-x 119 0x2000000);

switch -Mnosecond_underscore is hide
	help(Don't add second underscore to global symbols that already contain an underscore)
	helpgroup(target)
	append(CGARGS=-y 119 0x2000000);

switch -Munderscoring is hide
	help(Default for Fortran: append underscore to external names)
	helpgroup(target)
	helpname(-M[no]underscoring)
	append(F901ARGS=-y 119 0x1000000)
	append(CGARGS=-y 119 0x1000000);

switch -Mnounderscoring is hide
	help(Don't add underscore to external names)
	helpgroup(target)
	append(F901ARGS=-x 119 0x1000000)
	append(CGARGS=-x 119 0x1000000);

switch -Munsafe_par_align is
	help(Generate aligned moves in parallelized loops if first element is aligned)
	helpname(-M[no]unsafe_par_align)
	helpgroup(opt)
	append(CGARGS=-x 39 0x100000);

switch -Mnounsafe_par_align is hide
	help(Don't generate aligned moves in parallelized loops if first element is aligned)
	helpgroup(opt)
	append(CGARGS=-y 39 0x100000);

variable MVECT is help(Collected set of -Mvect options) default();
variable MVECTVAL is hide help(-Mvect values)
	default(-vect $MVECTVALUE
		-y 34 16
        -x 37 0x480000  # vectorize min/max
		$if($MVECTIDIOM,-y 34 0x8,-x 34 0x8)
		$if($MVECTSHORT,-x 39 0x1000000)
		$if($MVECTCACHE,-x 32 $MVECTCACHE)
		$if($MVECTTRANS,-y 19 8,-x 19 8)
		$if($equal($MVECTSMALL,0),-y 35 0,-x 35 $MVECTSMALL)
		$if($MVECTLEVEL,-x 30 $MVECTLEVEL)
		$if($MVECTSIZ,-x 39 0x2000 $if($MVECTSIZLIMIT,-x 139 $MVECTSIZLIMIT -x 140 $MVECTSIZLIMIT))
		# inhibit tiling and unroll&jam by default, -x 42 0x30
		-x 42 0x30 
		# if sse then
		#    generate prefetch0 instead of prefetchnta, -x 39 0x40
		#    if prefetch then
		#         also allow prefetching, -y 39 1
		$if($MVECTSSE,-x 39 0x40 $if($MVECTPREF,-y 39 1),
		# else
		#    if prefetch then
		#        generate prefetch0 instead of prefetchnta, -x 39 0x40
		#        suppress idiom recognition
		#        enable prefetch, -y 39 1
		$if($MVECTPREF,-x 39 0x42 -x 34 0x08 -y 39 1))
		# explicit -Mvect=nosse
		#    should just inhibit generating packed sse (llvect).
		#    continue to
		#        generate prefetch0 instead of prefetchnta,
		#        disallow unroll&jam and tiling
		$if($MVECTNOSSE,-x 39 0x40)
		# fusion
		$if($MVECTFUSE,-x 42 0x20000)
		$if($and($MVECTFASTFUSE, $notequal($MVECTFUSE,1)),-x 199 10)
		# recognize vector intrinsics
		$if($MVINTR,-x 39 0x80)
		# -Mvect=altcode values
		$MVECTALTCODE
		$MVECTSPLIT
		$MVECTTILE
		$MVECTSIMDWID
	);

variable MVECTVALUE is	help(-vect value) hide
			default($if($DEFVECT,$DEFVECT,48));
variable MVECTALTCODE is help(-Mvect=altcode) hide
			default();	# llvect() sets the default
variable MVECTSPLIT is	help(-Mvect=split) hide
			default();
variable MVECTASSOC is	help(-Mvect=assoc) hide
			default(0);
variable MVECTCACHE is	help(-Mvect=cachesize:c value) hide
			default($if($DEFCACHESIZE,$DEFCACHESIZE,0));
variable MVECTIDIOM is	help(-Mvect=idiom) hide
			default(0);
variable MVECTTRANS is	help(-Mvect=transform value) hide
			default(1);
variable MVECTSMALL is	help(-Mvect=smallvect value) hide
			default(0);
variable MVECTLEVEL is	help(-Mvect=levels value) hide
			default(0);
variable MVECTSIZ is	help(-Mvect=sizelimit value) hide
			default(0);
variable MVECTSIZLIMIT is	help(-Mvect=sizelimit:n value) hide
			default();
variable MVECTPREF is	help(-Mvect=prefetch value) hide
			default(0);
variable MVECTSSE is	help(-Mvect=sse value) hide
			default(0);
variable MVECTNOSSE is	help(-Mvect=nosse explicitly set) hide
			default(0);
variable MVECTSIMDWID is	help(SIMD width flag) hide
			default();
variable MVECTTILE is	help(-Mvect=tile set) hide default();
variable MVECTFUSE is	help(-Mvect=fuse set) hide default(1);
variable MVECTFASTFUSE is	help(-Mvect=fastfuse set) hide default(0);


variable MVECTSHORT is	help(-Mvect=short) hide
			default(0);

variable MVINTR is	help(-Mvect=simd use vector intrinsics) hide default(0);

variable COMPLIBSUBDIR is default($(COMPLIBPREFIX)lib);	# used with -KPIC

# NEW: libraries as if -mp were specified, all the time
variable LOCALBINDLIB is default();
variable COMPLIBMP is default( $foreach(dd,$COMPLIBSUBDIR,$if($isdir($COMPBASE/$COMPSYS/$COMPVER/$(COMPLIBPREFIX)$dd/mp),$COMPBASE/$COMPSYS/$COMPVER/$(COMPLIBPREFIX)$dd/mp )));

variable STDRPATHMP is default($foreach(dd,$COMPLIBSUBDIR,$if($isdir($COMPBASE/$COMPSYS/$COMPVER/$(COMPLIBPREFIX)$dd/mp),-rpath $COMPBASE/$COMPSYS/$COMPVER/$(COMPLIBPREFIX)$dd/mp )));


# OpenMP initialization, whether to include allcores, bind, or both
variable OMPINIT is default($if($ANYCU,3,0));
variable OMPINITOBJ is default();
variable OMPLINKFILE is default($OMPINITOBJ);

variable NOSIMD512 is default();
variable SIMD256 is default(0);
variable SIMD512 is default(0);

set CONCUR=YES;

switch -Mvect is
	help(Control automatic vector pipelining)
	helpname(-M[no]vect)
	helpgroup(opt)
	set(sse=0)
	set(nosse=0)
	keyword(
	    alignaltcode(hide 
		helpname([no]alignaltcode)
		help(Generate alternative loop code with extra alignments)
		append(MVECTALTCODE=-x 34 0x400000 -y 151 0x1000))
	    noalignaltcode(hide
		append(MVECTALTCODE=-x 151 0x1000))
	    altcode:n(hide
		help(Ignored. To generate scalar alternate code use scalaraltcode:n instead))
	    altcode(helpname([no]altcode)
		help(Generate appropriate alternative code for vectorized loops)
		append(MVECTALTCODE=-x 34 0x400000 -x 149 1 -x 150 1))
	    noaltcode(hide
		append(MVECTALTCODE=-x 151 0xf000))
	    assoc(andnot(MVECTVALUE=4) or(MVECTASSOC=1)
		helpname([no]assoc) help(Allow [disallow] reassociation))
	    noassoc(hide or(MVECTVALUE=4) andnot(MVECTASSOC=1))
	    cachesize:c(set(MVECTCACHE=$c)
		help(Optimize for cache size c))
	    fuse(or(MVECTFUSE=1) and(MVECTFASTFUSE=0) helpname([no]fuse) help(Enable [disable] loop fusion))
	    nofuse(hide and(MVECTFASTFUSE=0) and(MVECTFUSE=0))
	    gather(helpname([no]gather) help(Enable [disable] vectorization of indirect array references)
		append(CGARGS=-y 39 0x4000000))
	    nogather(hide help(Disable vectorization of indirect array references)
		append(CGARGS=-x 39 0x4000000))
	    idiom(or(MVECTIDIOM=1) helpname([no]idiom)
		help(Enable [disable] idiom recognition))
	    noidiom(andnot(MVECTIDIOM=1)
		append(F901ARGS=-x 8 0x8000000)
		append(CGARGS=-x 8 0x18000000)
		append(CGARGS=-x 37 0x20)
		hide)
	    levels:n(set(MVECTLEVEL=$n) help(Maximum nest level of loops to optimize))
	    beta(hide help(Enable chained control dependence for conditional vectorization)
		append(CGARGS=-x 25 0x20))
	    nocond(help(Disable vectorization of loops with conditionals)
		append(CGARGS=-x 37 0x200))
	    movntaltcode:n(hide
		helpname([no]movntaltcode:<n>)
		help(Execute code with nontemporal moves if loop count is greater than n)
		append(MVECTALTCODE=-x 150 $n -y 151 0x2000))
	    movntaltcode(hide
		help(Execute alternate code with nontemporal moves)
		append(MVECTALTCODE=-x 150 1 -y 151 0x2000))
	    nomovntaltcode(hide
		append(MVECTALTCODE=-x 151 0x2000))
	    nopeelaltcode:n(hide
		helpname([no]nopeelaltcode:<n>)
		help(Execute loop without peeling if loop count is less than or equal to n)
		append(MVECTALTCODE=-x 149 $n -y 151 0x4000))
	    nopeelaltcode(hide
		help(Execute loop without peeling)
		append(MVECTALTCODE=-x 149 1 -y 151 0x4000))
	    nonopeelaltcode(hide
		append(MVECTALTCODE=-x 151 0x4000))
	    partial(	append(CGARGS=-x 46 4)
			helpname([no]partial)
			help(Enable [disable] partial loop vectorization via inner loop distribution))
	    nopartial(append(CGARGS=-y 46 4) hide)
	    prefetch(set(junk=$if($sse,$error(-Mvect=simd and -Mvect=prefetch are incompatible)))
		set(MVECTPREF=1) or(MVECTVALUE=8)
		help(Generate prefetch instructions))
	    recog(or(MVECTVALUE=32) helpname([no]recog) hide)
	    norecog(andnot(MVECTVALUE=16) hide)
	    scalaraltcode:n(hide
		helpname([no]scalaraltcode:<n>)
		help(Execute scalar code if loop count is less than or equal to n)
		append(MVECTALTCODE=-x 16 $n -y 151 0x8000))
	    scalaraltcode(hide
		help(Execute scalar code if loop count)
		append(MVECTALTCODE=-x 16 1 -y 151 0x8000))
	    noscalaraltcode(hide append(MVECTALTCODE=-x 151 0x8000))
	    short(or(MVECTSHORT=1) helpname([no]short)
		help(Enable [disable] short vector operations))
	    noshort(andnot(MVECTSHORT=1) hide)
	    simd(or(MVECTSSE=1)
		andnot(MVECTNOSSE=1)
		or(MVECTVALUE=8)
		set(VECTSSE=1)	# do need sse libs
		set(DEFFLUSHVAL=-x 129 2 -y 129 0x8000)
		set(MVINTR=$if($equal($TARGETARCH,64),1))
		helpname([no]simd[:{128|256|512}])
		help(Generate [don't generate] SIMD instructions)
		keyword(
		"128"( help(Use 128-bit SIMD instructions)
		    set(SIMD256=0)
		    set(SIMD512=0)
		    set(MVECTSIMDWID=-x 56 0x40)
		    )
		"256"( help(Use 256-bit SIMD instructions)
		    set(SIMD256=1)
		    set(SIMD512=0)
		    set(MVECTSIMDWID=-x 56 0x100)
		    )
		"512"( help(Use 512-bit SIMD instructions)
		    set(SIMD256=0)
		    set(SIMD512=1)
		    set(MVECTSIMDWID=-x 56 0x800)
		    )
		)
	    )
	    nosimd(andnot(MVECTSSE=1)
		or(MVECTNOSSE=1)
		andnot(MVECTVALUE=8)
		set(MVINTR=0)
		set(VECTSSE=)	# may not need sse libs
		set(DEFFLUSHVAL=-y 129 2 -x 129 0x8000)
                hide)
	    simdresidual(append(CGARGS=-y 151 0x40000000)
		helpname([no]simdresidual)
		help(Enable [disable] vectorization of the residual loop of a vectorized loop))
	    nosimdresidual(append(CGARGS=-x 151 0x40000000) hide)
	    sizelimit(set(MVECTSIZ=1) set(MVECTSIZLIMIT=) helpname([no]sizelimit[:n])
		help(Limit size of vectorized loops))
	    sizelimit:n(hide set(MVECTSIZ=1) set(MVECTSIZLIMIT=$n)
		help(Limit size of vectorized loops to n))
	    nosizelimit(set(MVECTSIZ=0) hide help(Vectorize large loops))
	    smallvect:n(set(MVECTSMALL=$n) hide)
	    split:n(hide
		help(Split loops)
		set(MVECTSPLIT=-x 42 0x80 -x 152 $n))
	    split(hide
		help(Split loops)
		set(MVECTSPLIT=-x 42 0x80))
	    nosplit(hide
		help(Don't split loops)
		set(MVECTSPLIT=))
	    sse(or(MVECTSSE=1)
		andnot(MVECTNOSSE=1)
		or(MVECTVALUE=8)
		set(VECTSSE=1)	# do need sse libs
		set(DEFFLUSHVAL=-x 129 2 -y 129 0x8000)
		set(MVINTR=$if($equal($TARGETARCH,64),1))
		helpname([no]sse)
		help(The [no]sse option is deprecated, use [no]simd instead.))
	    nosse(andnot(MVECTSSE=1)
		or(MVECTNOSSE=1)
		andnot(MVECTVALUE=8)
		set(MVINTR=0)
		set(VECTSSE=)	# may not need sse libs
		set(DEFFLUSHVAL=-y 129 2 -x 129 0x8000)
                hide)
	    tile( helpname([no]tile)
		set(MVECTTILE=-x 181 8)
		help(Enable [disable] loop tiling))
	    notile( hide set(MVECTTILE=-x 181 0) )
	    transform(or(MVECTVALUE=32) or(MVECTTRANS=1) helpname([no]transform) hide)
	    notransform(andnot(MVECTVALUE=32) andnot(MVECTTRANS=1) hide)
	    uniform( hide
		echo(-Mvect=[no]uniform has been deprecated and will be removed in a future release; see -M[no]uniform))
	    nouniform( hide 
		echo(-Mvect=[no]uniform has been deprecated and will be removed in a future release; see -M[no]uniform))
	)
	nokeyword()
	max(OPTLEVELDEF=2)
	max(OPTLEVELMIN=2)
	append(OPTLEVELMINLIMIT=" -Mvect")
	set(VECT=48)	# for Fortran
	set(MVECT=$MVECTVAL);

switch -pc is hide
	help(Precision control in x87 stack)
	helpgroup(target)
	onekeyword
	keyword(
		32(append(CGARGS=-x 119 0x2000))
		64(append(CGARGS=-x 119 0x4000))
		80(append(CGARGS=-x 119 0x8000))
	);

switch -tp is
	early
	help(Select target processor)
	helpgroup(target)
	set(msgtpval=)
	mustkeyword
	onekeyword
	keyword(
		px(	help(Generic Linux/Windows x86_64 Processor.)
			set(INTEL=0)
			set(THISTP=px)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp px)
			set(NOSIMD512=px)
			set(XSAVEOPT=1)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=x86-64)
			set(LLVMOPTMCPU=$LLCMCPU)
		    )
		"px-64"="px"	(hide help(Alias for -tp=px) hide)
		"py"="px"	(hide help(Alias for -tp=px) hide)
		"py-64"="px"	(hide help(Alias for -tp=px) hide)
		x64( hide help(Same as -tp=px) hide
			warning(-tp=x64 Unified Binary is no longer supported; using -tp=px)
			set(INTEL=0)
			set(THISTP=px)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp px)
			set(NOSIMD512=px)
			set(XSAVEOPT=1)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=x86-64)
			set(LLVMOPTMCPU=$LLCMCPU)
		    )

		k8( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp k8 is not supported. See -help -tp for supported target processors.)
		)
		"k8-64"( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp k8-64 is not supported. See -help -tp for supported target processors.)
		)
		"k8-64e"( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp k8-64e is not supported. See -help -tp for supported target processors.)
		)
		amd64( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp amd64 is not supported. See -help -tp for supported target processors.)
		)
		amd64e( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp amd64e is not supported. See -help -tp for supported target processors.)
		)
		hammer( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp hammer is not supported. See -help -tp for supported target processors.)
		)
		"hammer-64"( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp hammer-64 is not supported. See -help -tp for supported target processors.)
		)
		barcelona( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp barcelona is not supported. See -help -tp for supported target processors.)
		)
		"barcelona-64"( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp barcelona-64 is not supported. See -help -tp for supported target processors.)
		)
		gh( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp gh is not supported. See -help -tp for supported target processors.)
		)
		"gh-64"( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp gh-64 is not supported. See -help -tp for supported target processors.)
		)
		shanghai( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp shanghai is not supported. See -help -tp for supported target processors.)
		)
		"shanghai-64"( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp shanghai-64 is not supported. See -help -tp for supported target processors.)
		)
		instanbul( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp instanbul is not supported. See -help -tp for supported target processors.)
		)
		"instanbul-64"( hide
			help(AMD64 Processor - pre AVX support) hide
			error(-tp instanbul-64 is not supported. See -help -tp for supported target processors.)
		)
		bulldozer( help(AMD Bulldozer processor)
			set(INTEL=0)
			set(THISTP=bulldozer-64)
			set(NOSIMD512=bulldozer-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp bulldozer)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=bdver1)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=1)
			set(ADX=0)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=0)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=0)
			set(BMI2=0)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=0)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=0)
			set(FMA=0)
			set(FMA4=1)
			set(FSGSBASE=0)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=1)
			set(LZCNT=1)
			set(MOVBE=0)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=0)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=0)
			set(RDSEED=0)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=1)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=1)
			set(XSAVEC=0)
			set(XSAVEOPT=0)
			set(XSAVES=0)
		    )
		"bulldozer-64"=bulldozer (hide)
		bdver1=bulldozer (hide)

		piledriver( help(AMD Piledriver processor)
			set(INTEL=0)
			set(THISTP=piledriver-64)
			set(NOSIMD512=piledriver-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp piledriver)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=bdver2)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=1)
			set(ADX=0)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=0)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=0)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=0)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=1)
			set(FSGSBASE=0)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=1)
			set(LZCNT=1)
			set(MOVBE=0)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=0)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=0)
			set(RDSEED=0)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=1)
			set(TBM=1)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=1)
			set(XSAVEC=0)
			set(XSAVEOPT=0)
			set(XSAVES=0)
		    )
		"piledriver-64"=piledriver (hide)
		bdver2=piledriver (hide)

		bdver3( help(AMD Family 15h core)
			set(INTEL=0)
			set(THISTP=piledriver-64)
			set(NOSIMD512=piledriver-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp piledriver)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=bdver3)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=1)
			set(ADX=0)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=0)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=0)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=0)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=1)
			set(FSGSBASE=1)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=1)
			set(LZCNT=1)
			set(MOVBE=0)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=0)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=0)
			set(RDSEED=0)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=1)
			set(TBM=1)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=1)
			set(XSAVEC=0)
			set(XSAVEOPT=1)
			set(XSAVES=0)
		    )

		bdver4( help(AMD Family 15h core)
			set(INTEL=0)
			set(THISTP=piledriver-64)
			set(NOSIMD512=piledriver-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp piledriver)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=bdver4)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=1)
			set(ADX=0)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=0)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=1)
			set(FSGSBASE=1)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=1)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=1)
			set(PCONFIG=0)
			set(PKU=0)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=1)
			set(RDSEED=0)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=1)
			set(TBM=1)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=1)
			set(XSAVEC=0)
			set(XSAVEOPT=1)
			set(XSAVES=0)
		    )

		zen( hide help(AMD Zen architecture (Epyc, Ryzen))
			set(INTEL=0)
			set(THISTP=zen-64)
			set(NOSIMD512=zen-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp zen)
			set(LZCNT=1)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=znver1)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=1)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=0)
			set(CLZERO=1)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=1)
			set(PCONFIG=0)
			set(PKU=0)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=1)
			set(SHSTK=0)
			set(SSE4A=1)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )
		"znver1"=zen( help(AMD Zen architecture (Epyc, Ryzen)))
		"zen-64"=zen (hide)
		zen2( hide help(AMD Zen 2 architecture (Ryzen 2))
			set(INTEL=0)
			set(THISTP=zen2-64)
			set(NOSIMD512=zen2-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp zen2)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=znver2)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=1)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=1)
			set(CLZERO=1)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=1)
			set(PCONFIG=0)
			set(PKU=0)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=1)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=1)
			set(SHSTK=0)
			set(SSE4A=1)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=1)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )
		"znver2"=zen2( help(AMD Zen 2 architecture (Ryzen 2)))
		"zen2-64"=zen2 (hide)
		zen3( hide help(AMD Zen 3 architecture (Ryzen 3))
			set(INTEL=0)
			set(THISTP=zen3-64)
			set(NOSIMD512=zen3-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp znver3)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=znver3)
			set(LLVMOPTMCPU=$LLCMCPU)
			error($if($expr($LLVMVERINT < 120),"-tp znver3 (zen3)" not supported with LLVM version < 12.0))

			set(ABM=1)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=1)
			set(CLZERO=1)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=1)
			set(PCONFIG=0)
			set(PKU=1)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=1)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=1)
			set(SHSTK=0)
			set(SSE4A=1)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=1)
			set(VPCLMULQDQ=1)
			set(WAITPKG=0)
			set(WBNOINVD=1)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )
		"znver3"=zen3( help(AMD Zen 3 architecture (Ryzen 3)))
		"zen3-64"=zen3 (hide)
		zen4( hide help(AMD Zen 4 architecture (Ryzen 4))
			set(INTEL=0)
			set(THISTP=zen4-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp znver4)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=znver4)
			set(LLVMOPTMCPU=$LLCMCPU)
			error($if($expr($LLVMVERINT < 120),"-tp znver4 (zen4)" not supported with LLVM version < 12.0))

			set(ABM=1)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=1)
			set(AVX512BITALG=1)
			set(AVX512BW=1)
			set(AVX512CD=1)
			set(AVX512DQ=1)
			set(AVX512ER=0)
			set(AVX512F=1)
			set(AVX512FP16=0)
			set(AVX512IFMA=1)
			set(AVX512PF=0)
			set(AVX512VBMI=1)
			set(AVX512VBMI2=1)
			set(AVX512VL=1)
			set(AVX512VNNI=1)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=1)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=1)
			set(CLZERO=1)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=1)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=1)
			set(PCONFIG=0)
			set(PKU=1)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=1)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=1)
			set(SHSTK=0)
			set(SSE4A=1)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=1)
			set(VPCLMULQDQ=1)
			set(WAITPKG=0)
			set(WBNOINVD=1)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )
		"znver4"=zen4( help(AMD Zen 4 architecture (Ryzen 4)))
		"zen4-64"=zen4 (hide)
		znver5( hide help(AMD Zen 5 architecture)
			set(INTEL=0)
			set(THISTP=znver5)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp znver5)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=znver5)
			set(LLVMOPTMCPU=$LLCMCPU)
			error($if($expr($LLVMVERINT < 170),"-tp znver5 (zen5)" not supported with LLVM version < 17.0))

			set(ABM=1)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=1)
			set(AVX512BITALG=1)
			set(AVX512BW=1)
			set(AVX512CD=1)
			set(AVX512DQ=1)
			set(AVX512ER=0)
			set(AVX512F=1)
			set(AVX512FP16=0)
			set(AVX512IFMA=1)
			set(AVX512PF=0)
			set(AVX512VBMI=1)
			set(AVX512VBMI2=1)
			set(AVX512VL=1)
			set(AVX512VNNI=1)
			set(AVX512VP2INTERSECT=1)
			set(AVX512VPOPCNTDQ=1)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=1)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=1)
			set(CLZERO=1)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=1)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=1)
			set(MOVDIRI=1)
			set(MWAITX=1)
			set(PCONFIG=0)
			set(PKU=1)
			set(PREFETCHI=1)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=1)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=1)
			set(SHSTK=0)
			set(SSE4A=1)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=1)
			set(VPCLMULQDQ=1)
			set(WAITPKG=0)
			set(WBNOINVD=1)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )
		p7=px( hide
			help(Intel Processor - pre AVX support) hide
			if(0,$warning(-tp p7 is not supported. Defaulting to -tp px. See -help -tp for supported target processors.))
		)
		"p7-64"=px( hide
			help(Intel Processor - pre AVX support) hide
			if(0,$warning(-tp p7-64 is not supported. Defaulting to -tp px. See -help -tp for supported target processors.))
		)
		core2( hide
			help(Intel Processor - pre AVX support) hide
			error(-tp core2 is not supported. See -help -tp for supported target processors.)
		)
		"core2-64"( hide
			help(Intel Processor - pre AVX support) hide
			error(-tp core2-64 is not supported. See -help -tp for supported target processors.)
		)
		penryn( hide
			help(Intel Processor - pre AVX support) hide
			error(-tp penryn is not supported. See -help -tp for supported target processors.)
		)
		"penryn-64"( hide
			help(Intel Processor - pre AVX support) hide
			error(-tp penryn-64 is not supported. See -help -tp for supported target processors.)
		)
		nehalem( hide
			help(Intel Processor - pre AVX support) hide
			error(-tp nehalem is not supported. See -help -tp for supported target processors.)
		)
		"nehalem-64"( hide
			help(Intel Processor - pre AVX support) hide
			error(-tp nehalem-64 is not supported. See -help -tp for supported target processors.)
		)
    "corei7"="p7" (hide)

		sandybridge( help(Intel SandyBridge processor)
			set(INTEL=1)
			set(THISTP=sandybridge-64)
			set(NOSIMD512=sandybridge-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp sandybridge)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=sandybridge)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=0)
			set(AES=0)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=0)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=0)
			set(BMI2=0)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=0)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=0)
			set(FMA=0)
			set(FMA4=0)
			set(FSGSBASE=0)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=0)
			set(MOVBE=0)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=0)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=0)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=0)
			set(RDSEED=0)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=0)
			set(XSAVEOPT=1)
			set(XSAVES=0)
		    )
		"sandybridge-64"=sandybridge (hide)
    "corei7-avx"=sandybridge (hide)

		ivybridge( hide help(Intel IvyBridge processor)
			set(INTEL=1)
			set(THISTP=ivybridge-64)
			set(NOSIMD512=ivybridge-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp ivybridge)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=ivybridge)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=0)
			set(AES=0)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=0)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=0)
			set(BMI2=0)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=0)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=0)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=0)
			set(MOVBE=0)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=0)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=0)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=1)
			set(RDSEED=0)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=0)
			set(XSAVEOPT=1)
			set(XSAVES=0)

		    )
		"ivybridge-64"=ivybridge (hide)
    "core-avx-i"=ivybridge (hide)

		haswell( help(Intel Haswell processor)
			set(THISTP=haswell-64)
			set(NOSIMD512=haswell-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp haswell)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=haswell)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=0)
			set(AES=0)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=0)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=0)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=0)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=1)
			set(RDSEED=0)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=0)
			set(XSAVEOPT=1)
			set(XSAVES=0)
		    )
		"haswell-64"=haswell (hide)
		"core-avx2"=haswell (hide)

		broadwell( help(Intel Broadwell processor)
			set(THISTP=haswell-64)
			set(NOSIMD512=haswell-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp haswell)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=broadwell)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=1)
			set(AES=0)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=0)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=0)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=0)
			set(XSAVEOPT=1)
			set(XSAVES=0)
		    )
		"broadwell-64"=broadwell (hide)

		knl(	hide
			help(Intel Knights Landing processor)
			error(Intel Knights Landing processor no longer supported)
		)
		"knl-64"="knl"	(hide)

		skylake( help(Intel Skylake Xeon processor)
			set(INTEL=1)
			set(THISTP=skylake-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp skylake)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCARCH=)
			set(LLCMCPU=-mcpu=skylake-avx512)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=1)
			set(AVX512CD=1)
			set(AVX512DQ=1)
			set(AVX512ER=0)
			set(AVX512F=1)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=1)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=1)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=1)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=1)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )
		"skylake-64"=skylake (hide)
		"skylake-avx512"=skylake (hide)

		skylakeclient( help(Intel Skylake Core processor)
			set(INTEL=1)
			set(THISTP=skylake-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp skylake)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCARCH=)
			set(LLCMCPU=-mcpu=skylake)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=0)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=1)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )

		icelake( help(Intel Ice Lake Xeon processor)
			set(INTEL=1)
			set(THISTP=icelake-server)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp icelake-server)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCARCH=)
			set(LLCMCPU=-mcpu=icelake-server)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=1)
			set(AVX512BW=1)
			set(AVX512CD=1)
			set(AVX512DQ=1)
			set(AVX512ER=0)
			set(AVX512F=1)
			set(AVX512FP16=0)
			set(AVX512IFMA=1)
			set(AVX512PF=0)
			set(AVX512VBMI=1)
			set(AVX512VBMI2=1)
			set(AVX512VL=1)
			set(AVX512VNNI=1)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=1)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=1)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=1)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=1)
			set(PKU=1)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=1)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=1)
			set(SHA=1)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=1)
			set(VPCLMULQDQ=1)
			set(WAITPKG=0)
			set(WBNOINVD=1)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)

		    )
		"icelake-server"=icelake (hide)

		icelakeclient( hide help(Intel Ice Lake client processor)
			set(INTEL=1)
			set(THISTP=icelake-client)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp icelake-client)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCARCH=)
			set(LLCMCPU=-mcpu=icelake-client)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=1)
			set(AVX512BW=1)
			set(AVX512CD=1)
			set(AVX512DQ=1)
			set(AVX512ER=0)
			set(AVX512F=1)
			set(AVX512FP16=0)
			set(AVX512IFMA=1)
			set(AVX512PF=0)
			set(AVX512VBMI=1)
			set(AVX512VBMI2=1)
			set(AVX512VL=1)
			set(AVX512VNNI=1)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=1)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=1)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=1)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=1)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=1)
			set(SHA=1)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=1)
			set(VPCLMULQDQ=1)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )
		"icelake-client"=icelakeclient(help(Intel Ice Lake client processor))

		cannonlake( help(Intel Cannon Lake Xeon processor)
			set(INTEL=1)
			#!!!!!!!!!!!!set(THISTP=cannonlake)
			set(THISTP=icelake)
			set(msgtpval=$THISTP)
			#!!!!!!!!!!!!set(CLTPVAL=-tp cannonlake)
			set(CLTPVAL=-tp icelake)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCARCH=)
			set(LLCMCPU=-mcpu=cannonlake)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=1)
			set(AVX512CD=1)
			set(AVX512DQ=1)
			set(AVX512ER=0)
			set(AVX512F=1)
			set(AVX512FP16=0)
			set(AVX512IFMA=1)
			set(AVX512PF=0)
			set(AVX512VBMI=1)
			set(AVX512VBMI2=0)
			set(AVX512VL=1)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=1)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=1)
			set(SHA=1)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )
#	Cascade Lake is Skylake with AVX512VNNI.
		cascadelake( help(Intel Cascade Lake Xeon processor)
			set(INTEL=1)
			#!!!!!!!!!!!!!!!!set(THISTP=cascadelake)
			set(THISTP=skylake)
			set(msgtpval=$THISTP)
			#!!!!!!!!!!!!!!!!set(CLTPVAL=-tp cascadelake)
			set(CLTPVAL=-tp skylake)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCARCH=)
			set(LLCMCPU=-mcpu=cascadelake)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=1)
			set(AVX512CD=1)
			set(AVX512DQ=1)
			set(AVX512ER=0)
			set(AVX512F=1)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=1)
			set(AVX512VNNI=1)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=1)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=1)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=1)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )

#	Cooper Lake is Skylake with AVX512BF16.
		cooperlake( help(Intel Cooper Lake Xeon processor)
			set(INTEL=1)
			#!!!!!!!!!!!!!!!!set(THISTP=cooperlake)
			set(THISTP=skylake)
			set(msgtpval=$THISTP)
			#!!!!!!!!!!!!!!!!set(CLTPVAL=-tp cooperlake)
			set(CLTPVAL=-tp skylake)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCARCH=)
			set(LLCMCPU=-mcpu=cooperlake)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=1)
			set(AVX512BITALG=0)
			set(AVX512BW=1)
			set(AVX512CD=1)
			set(AVX512DQ=1)
			set(AVX512ER=0)
			set(AVX512F=1)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=1)
			set(AVX512VNNI=1)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=1)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=1)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=1)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )

		tigerlake( help(Intel Tiger Lake Xeon processor)
			set(INTEL=1)
			#!!!!!!!!!!!!!!!!set(THISTP=tigerlake)
			set(THISTP=icelake)
			set(msgtpval=$THISTP)
			#!!!!!!!!!!!!!!!!set(CLTPVAL=-tp tigerlake)
			set(CLTPVAL=-tp icelake)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCARCH=)
			set(LLCMCPU=-mcpu=tigerlake)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=1)
			set(AVX512BW=1)
			set(AVX512CD=1)
			set(AVX512DQ=1)
			set(AVX512ER=0)
			set(AVX512F=1)
			set(AVX512FP16=0)
			set(AVX512IFMA=1)
			set(AVX512PF=0)
			set(AVX512VBMI=1)
			set(AVX512VBMI2=1)
			set(AVX512VL=1)
			set(AVX512VNNI=1)
			set(AVX512VP2INTERSECT=1)
			set(AVX512VPOPCNTDQ=1)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=1)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=1)
			set(HLE=0)
			set(HRESET=0)
			set(KL=1)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=1)
			set(MOVDIRI=1)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=1)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=1)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=1)
			set(SHA=1)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=1)
			set(VPCLMULQDQ=1)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=1)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )

#	Alder Lake is more like Haswell - No AVX512.
		alderlake( help(Intel Alder Lake Xeon processor)
			set(INTEL=1)
			#!!!!!!!!!!!!!!!!set(THISTP=alderlake)
			set(THISTP=haswell)
			set(msgtpval=$THISTP)
			#!!!!!!!!!!!!!!!!set(CLTPVAL=-tp alderlake)
			set(CLTPVAL=-tp haswell)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCARCH=)
			set(LLCMCPU=-mcpu=alderlake)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=1)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=1)
			set(CLFLUSHOPT=1)
			set(CLWB=1)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=1)
			set(HLE=0)
			set(HRESET=1)
			set(KL=1)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=1)
			set(MOVDIRI=1)
			set(MWAITX=0)
			set(PCONFIG=1)
			set(PKU=1)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=1)
			set(RAOINT=0)
			set(RDPID=1)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=1)
			set(SGX=1)
			set(SHA=1)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=1)
			set(VPCLMULQDQ=1)
			set(WAITPKG=1)
			set(WBNOINVD=0)
			set(WIDEKL=1)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )

		rocketlake( help(Intel Rocket Lake Xeon processor)
			set(INTEL=1)
			#!!!!!!!!!!!!!!!!set(THISTP=rocketlake)
			set(THISTP=icelake)
			set(msgtpval=$THISTP)
			#!!!!!!!!!!!!!!!!set(CLTPVAL=-tp rocketlake)
			set(CLTPVAL=-tp icelake)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCARCH=)
			set(LLCMCPU=-mcpu=rocketlake)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=1)
			set(AVX512BW=1)
			set(AVX512CD=1)
			set(AVX512DQ=1)
			set(AVX512ER=0)
			set(AVX512F=1)
			set(AVX512FP16=0)
			set(AVX512IFMA=1)
			set(AVX512PF=0)
			set(AVX512VBMI=1)
			set(AVX512VBMI2=1)
			set(AVX512VL=1)
			set(AVX512VNNI=1)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=1)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=1)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=1)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCONFIG=0)
			set(PKU=1)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=1)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=1)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=1)
			set(VPCLMULQDQ=1)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )

		sapphirerapids( help(Intel Sapphire Rapids Xeon processor)
			set(INTEL=1)
			set(THISTP=sapphirerapids)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp sapphirerapids)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCARCH=)
			set(LLCMCPU=-mcpu=sapphirerapids)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=1)
			set(AMX_INT8=1)
			set(AMX_TILE=1)
			set(AVX2=1)
			set(AVX512BF16=1)
			set(AVX512BITALG=1)
			set(AVX512BW=1)
			set(AVX512CD=1)
			set(AVX512DQ=1)
			set(AVX512ER=0)
			set(AVX512F=1)
			set(AVX512FP16=1)
			set(AVX512IFMA=1)
			set(AVX512PF=0)
			set(AVX512VBMI=1)
			set(AVX512VBMI2=1)
			set(AVX512VL=1)
			set(AVX512VNNI=1)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=1)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=1)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=1)
			set(CLFLUSHOPT=1)
			set(CLWB=1)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=1)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=1)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=1)
			set(MOVDIRI=1)
			set(MWAITX=0)
			set(PCONFIG=1)
			set(PKU=1)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=1)
			set(RAOINT=0)
			set(RDPID=1)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=1)
			set(SGX=1)
			set(SHA=1)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=1)
			set(UINTR=1)
			set(VAES=1)
			set(VPCLMULQDQ=1)
			set(WAITPKG=1)
			set(WBNOINVD=1)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )
		graniterapids( help(Intel Granite Rapids Xeon processor)
			set(INTEL=1)
			set(THISTP=sapphirerapids)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp sapphirerapids)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCARCH=)
			set(LLCMCPU=-mcpu=graniterapids)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=1)
			set(AES=1)
			set(AMX_BF16=1)
			set(AMX_COMPLEX=1)
			set(AMX_FP16=1)
			set(AMX_INT8=1)
			set(AMX_TILE=1)
			set(AVX2=1)
			set(AVX512BF16=1)
			set(AVX512BITALG=1)
			set(AVX512BW=1)
			set(AVX512CD=1)
			set(AVX512DQ=1)
			set(AVX512ER=0)
			set(AVX512F=1)
			set(AVX512FP16=1)
			set(AVX512IFMA=1)
			set(AVX512PF=0)
			set(AVX512VBMI=1)
			set(AVX512VBMI2=1)
			set(AVX512VL=1)
			set(AVX512VNNI=1)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=1)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=1)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=1)
			set(CLFLUSHOPT=1)
			set(CLWB=1)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=1)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=1)
			set(GFNI=1)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=1)
			set(MOVDIRI=1)
			set(MWAITX=0)
			set(PCONFIG=1)
			set(PKU=1)
			set(PREFETCHI=1)
			set(PREFETCHWT1=0)
			set(PRFCHW=1)
			set(PTWRITE=1)
			set(RAOINT=0)
			set(RDPID=1)
			set(RDRND=1)
			set(RDSEED=1)
			set(RTM=0)
			set(SERIALIZE=1)
			set(SGX=1)
			set(SHA=1)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=1)
			set(UINTR=1)
			set(VAES=1)
			set(VPCLMULQDQ=1)
			set(WAITPKG=1)
			set(WBNOINVD=1)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=1)
			set(XSAVEOPT=1)
			set(XSAVES=1)
		    )

		x86_64_v2( hide help(x86-64 microarchitectural level including SSE)
			error(x86_64-v2 not supported - x86_64-v3 is minimum supported)
		)
		"x86-64-v2"=x86_64_v2(help(x86-64 microarchitectural level including SSE))

		x86_64_v3( hide help(x86-64 microarchitectural level including AVX2)
			set(INTEL=1)
			set(THISTP=haswell-64)
			set(NOSIMD512=haswell-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp haswell)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=x86-64-v3)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=0)
			set(AES=0)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=0)
			set(AVX512CD=0)
			set(AVX512DQ=0)
			set(AVX512ER=0)
			set(AVX512F=0)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=0)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=0)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=0)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCLMUL=0)	#!!!!!!! Exception to NVHPC base defs
			set(PCONFIG=0)
			set(PKU=0)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=0)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=0)
			set(RDSEED=0)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=0)
			set(XSAVEOPT=0)
			set(XSAVES=0)
		    )
		"x86-64-v3"=x86_64_v3(help(x86-64 microarchitectural level including AVX2))

		x86_64_v4( hide help(x86-64 microarchitectural level including some AVX512 variants)
			set(INTEL=1)
			set(THISTP=haswell-64)
			set(NOSIMD512=haswell-64)
			set(msgtpval=$THISTP)
			set(CLTPVAL=-tp haswell)
			set(DEFCACHESIZE=)
			set(X86_64TARGET=YES)
			set(TARGETARCH=64)
			set(LLCMCPU=-mcpu=x86-64-v4)
			set(LLVMOPTMCPU=$LLCMCPU)

			set(ABM=0)
			set(ADX=0)
			set(AES=0)
			set(AMX_BF16=0)
			set(AMX_COMPLEX=0)
			set(AMX_FP16=0)
			set(AMX_INT8=0)
			set(AMX_TILE=0)
			set(AVX2=1)
			set(AVX512BF16=0)
			set(AVX512BITALG=0)
			set(AVX512BW=1)
			set(AVX512CD=1)
			set(AVX512DQ=1)
			set(AVX512ER=0)
			set(AVX512F=1)
			set(AVX512FP16=0)
			set(AVX512IFMA=0)
			set(AVX512PF=0)
			set(AVX512VBMI=0)
			set(AVX512VBMI2=0)
			set(AVX512VL=1)
			set(AVX512VNNI=0)
			set(AVX512VP2INTERSECT=0)
			set(AVX512VPOPCNTDQ=0)
			set(AVXIFMA=0)
			set(AVXNECONVERT=0)
			set(AVXVNNI=0)
			set(AVXVNNIINT8=0)
			set(BMI=1)
			set(BMI2=1)
			set(CLDEMOTE=0)
			set(CLFLUSHOPT=0)
			set(CLWB=0)
			set(CLZERO=0)
			set(CMPCCXADD=0)
			set(CX16=0)
			set(ENQCMD=0)
			set(F16C=1)
			set(FMA=1)
			set(FMA4=0)
			set(FSGSBASE=0)
			set(GFNI=0)
			set(HLE=0)
			set(HRESET=0)
			set(KL=0)
			set(LWP=0)
			set(LZCNT=1)
			set(MOVBE=1)
			set(MOVDIR64B=0)
			set(MOVDIRI=0)
			set(MWAITX=0)
			set(PCLMUL=0)	#!!!!!!! Exception to NVHPC base defs
			set(PCONFIG=0)
			set(PKU=0)
			set(PREFETCHI=0)
			set(PREFETCHWT1=0)
			set(PRFCHW=0)
			set(PTWRITE=0)
			set(RAOINT=0)
			set(RDPID=0)
			set(RDRND=0)
			set(RDSEED=0)
			set(RTM=0)
			set(SERIALIZE=0)
			set(SGX=0)
			set(SHA=0)
			set(SHSTK=0)
			set(SSE4A=0)
			set(TBM=0)
			set(TSXLDTRK=0)
			set(UINTR=0)
			set(VAES=0)
			set(VPCLMULQDQ=0)
			set(WAITPKG=0)
			set(WBNOINVD=0)
			set(WIDEKL=0)
			set(XOP=0)
			set(XSAVEC=0)
			set(XSAVEOPT=0)
			set(XSAVES=0)
		    )
		"x86-64-v4"=x86_64_v4(help(x86-64 microarchitectural level including some AVX512 variants))
		"sandybridge-64"=sandybridge (hide)

		host(help(Link native version of HPC SDK cpu math library)
			set(msgtpval=)
			set(ISTPHOST=1)
		)
		"native"=host(help(Alias for -tp host))
	)
	set(MSGTPVAL=$if($msgtpval,-tp $replace($msgtpval,,","),$DEFTPVAL))
	;

switch -mmmx is
	help(Enable [disable] MMX instructions - option ignored: AVX is minimum ISA supported)
	helpname(-m[no-]mmx)
	helpgroup(target)
	;

switch -mno-mmx is hide
	help(Disable MMX instructions - option ignored: AVX is minimum ISA supported)
	helpgroup(target)
	warning(Cannot disable ISA extensions AVX and earlier)
	;

switch -msse is
	help(Enable [disable] SSE instructions - option ignored: AVX is minimum ISA supported)
	helpname(-m[no-]sse)
	helpgroup(target)
	;

switch -mno-sse is hide
	help(Disable SSE instructions - option ignored: AVX is minimum ISA supported)
	helpgroup(target)
	warning(Cannot disable ISA extensions AVX and earlier)
	;

switch -msse2 is
	help(Enable [disable] SSE2 instructions - option ignored: AVX is minimum ISA supported)
	helpname(-m[no-]sse2)
	helpgroup(target)
	;

switch -mno-sse2 is hide
	help(Disable SSE2 instructions - option ignored: AVX is minimum ISA supported)
	helpgroup(target)
	warning(Cannot disable ISA extensions AVX and earlier)
	;

switch -msse3 is
	help(Enable [disable] SSE3 instructions - option ignored: AVX is minimum ISA supported)
	helpname(-m[no-]sse3)
	helpgroup(target)
	;

switch -mno-sse3 is hide
	help(Disable SSE3 instructions - option ignored: AVX is minimum ISA supported)
	helpgroup(target)
	warning(Cannot disable ISA extensions AVX and earlier)
	;

switch -mssse3 is
	help(Enable [disable] SSSE3 instructions - option ignored: AVX is minimum ISA supported)
	helpname(-m[no-]ssse3)
	helpgroup(target)
	;

switch -mno-ssse3 is hide
	help(Disable SSSE3 instructions - option ignored: AVX is minimum ISA supported)
	helpgroup(target)
	warning(Cannot disable ISA extensions AVX and earlier)
	;

switch -msse4a is
	help(Enable [disable] SSE 4a instructions)
	helpname(-m[no-]sse4a)
	helpgroup(target)
	set(SSE4A=1)
	set(M_SSE4A=1)
	;

switch -mno-sse4a is hide
	help(Disable SSE 4a instructions)
	helpgroup(target)
	set(SSE4A=0)
	set(M_SSE4A=1)
	;

switch -msse4 is
	help(Enable [disable] SSE 4 instructions - option ignored: AVX is minimum ISA supported)
	helpname(-m[no-]sse4)
	helpgroup(target)
	shorthand("-msse4.2")
	;

switch -mno-sse4 is hide
	help(Disable SSE 4 instructions - option ignored: AVX is minimum ISA supported)
	helpgroup(target)
	warning(Cannot disable ISA extensions AVX and earlier)
	;

switch "-msse4.1" is
	help(Enable [disable] SSE 4.1 instructions - option ignored: AVX is minimum ISA supported)
	helpname(-m[no-]sse4.1)
	helpgroup(target)
	shorthand(-mssse3)
	;

switch "-mno-sse4.1" is hide
	help(Disable SSE 4.1 instructions - option ignored: AVX is minimum ISA supported)
	helpgroup(target)
	warning(Cannot disable ISA extensions AVX and earlier)
	;

switch "-msse4.2" is
	help(Enable [disable] SSE 4.2 instructions - option ignored: AVX is minimum ISA supported)
	helpname(-m[no-]sse4.2)
	helpgroup(target)
	shorthand("-msse4.1")
	;

switch "-mno-sse4.2" is hide
	help(Disable SSE 4.2 instructions - option ignored: AVX is minimum ISA supported)
	helpgroup(target)
	warning(Cannot disable ISA extensions AVX and earlier)
	;

switch -mavx is
	help(Enable [disable] AVX instructions - option ignored: AVX is minimum ISA supported)
	helpname(-m[no-]avx)
	helpgroup(target)
	set(AVX=1)
	;

switch -mno-avx is hide
	help(Disable AVX instructions - option ignored AVX is minimum ISA supported)
	helpgroup(target)
	warning(Cannot disable ISA extensions AVX and earlier)
	;

switch -mavx2 is
	help(Enable [disable] AVX2 instructions)
	helpname(-m[no-]avx2)
	helpgroup(target)
	set(AVX2=1)
	set(M_AVX2=1)
	shorthand(-mavx)
	;

switch -mno-avx2 is hide
	help(Disable AVX2 instructions)
	helpgroup(target)
	set(AVX2=0)
	set(M_AVX2=1)
	shorthand(-mno-avx512f)
	;

switch -mavx512f is
	help(Enable [disable] AVX-512 instructions)
	helpname(-m[no-]avx512f)
	helpgroup(target)
	set(AVX512F=1)
	set(M_AVX512F=1)
	shorthand(-mavx2)
	;

switch -mno-avx512f is hide
	help(Disable AVX-512 instructions)
	helpgroup(target)
	set(AVX512F=0)
	set(M_AVX512F=1)
	shorthand(-mno-avx512vl)
	shorthand(-mno-avx512pf)
	shorthand(-mno-avx512er)
	shorthand(-mno-avx512cd)
	shorthand(-mno-avx512bw)
	shorthand(-mno-avx512ifma)
	shorthand(-mno-avx512vbmi)
	shorthand(-mno-avx512vbmi2)
	shorthand(-mno-avx512bitalg)
	shorthand(-mno-avx512vpopcntdq)
	shorthand(-mno-avx512dq)
	shorthand(-mno-avx512vnni)
	;

switch -mavx512pf is
	help(Enable [disable] AVX-512 prefetch instructions)
	helpname(-m[no-]avx512pf)
	helpgroup(target)
	set(AVX512PF=1)
	set(M_AVX512PF=1)
	shorthand(-mavx512f)
	;

switch -mno-avx512pf is hide
	help(Disable AVX-512 prefetch instructions)
	helpgroup(target)
	set(AVX512PF=0)
	set(M_AVX512PF=1)
	;

switch -mavx512er is
	help(Enable [disable] AVX-512 exponential and reciprocal instructions)
	helpname(-m[no-]avx512er)
	helpgroup(target)
	set(AVX512ER=1)
	set(M_AVX512ER=1)
	shorthand(-mavx512f)
	;

switch -mno-avx512er is hide
	help(Disable AVX-512 exponential and reciprocal instructions)
	helpgroup(target)
	set(AVX512ER=0)
	set(M_AVX512ER=1)
	;

switch -mavx512cd is
	help(Enable [disable] AVX-512 conflict detection instructions)
	helpname(-m[no-]avx512cd)
	helpgroup(target)
	set(AVX512CD=1)
	set(M_AVX512CD=1)
	shorthand(-mavx512f)
	;

switch -mno-avx512cd is hide
	help(Disable AVX-512 conflict detection instructions)
	helpgroup(target)
	set(AVX512CD=0)
	set(M_AVX512CD=1)
	;

switch -mavx512vl is
	help(Enable [disable] AVX-512 vector length extensions)
	helpname(-m[no-]avx512vl)
	helpgroup(target)
	set(AVX512VL=1)
	set(M_AVX512VL=1)
	shorthand(-mavx512f)
	;

switch -mno-avx512vl is hide
	help(Disable AVX-512 vector length extensions)
	helpgroup(target)
	set(AVX512VL=0)
	set(M_AVX512VL=1)
	shorthand(-mno-avx512bf16)
	shorthand(-mno-avx512fp16)
	shorthand(-mno-avx512vp2intersect)
	;

switch -mavx512bw is
	help(Enable [disable] AVX-512 byte and word instructions)
	helpname(-m[no-]avx512bw)
	helpgroup(target)
	set(AVX512BW=1)
	set(M_AVX512BW=1)
	shorthand(-mavx512f)
	;

switch -mno-avx512bw is hide
	help(Disable AVX-512 byte and word instructions)
	helpgroup(target)
	set(AVX512BW=0)
	set(M_AVX512BW=1)
	shorthand(-mno-avx512vbmi)
	;

switch -mavx512dq is
	help(Enable [disable] AVX-512 doubleword and quadword instructions)
	helpname(-m[no-]avx512dq)
	helpgroup(target)
	set(AVX512DQ=1)
	set(M_AVX512DQ=1)
	shorthand(-mavx512f)
	;

switch -mno-avx512dq is hide
	help(Disable AVX-512 doubleword and quadword instructions)
	helpgroup(target)
	set(AVX512DQ=0)
	set(M_AVX512DQ=1)
	;

switch -mavx512ifma is
	help(Enable [disable] AVX-512 integer fused multiply-add instructions)
	helpname(-m[no-]avx512ifma)
	helpgroup(target)
	set(AVX512IFMA=1)
	set(M_AVX512IFMA=1)
	shorthand(-mavx512f)
	;

switch -mno-avx512ifma is hide
	help(Disable AVX-512 integer fused multiply-add instructions)
	helpgroup(target)
	set(AVX512IFMA=0)
	set(M_AVX512IFMA=1)
	;

switch -mavx512vbmi is
	help(Enable [disable] AVX-512 vector byte manipulation instructions)
	helpname(-m[no-]avx512vbmi)
	helpgroup(target)
	set(AVX512VBMI=1)
	set(M_AVX512VBMI=1)
	shorthand(-mavx512bw)
	;

switch -mno-avx512vbmi is hide
	help(Disable AVX-512 vector byte manipulation instructions)
	helpgroup(target)
	set(AVX512VBMI=0)
	set(M_AVX512VBMI=1)
	;

switch -mavx512vbmi2 is
	help(Enable [disable] AVX-512 further vector byte manipulation instructions)
	helpname(-m[no-]avx512vbmi2)
	helpgroup(target)
	set(AVX512VBMI2=1)
	set(M_AVX512VBMI2=1)
	shorthand(-mavx512f)
	;

switch -mno-avx512vbmi2 is hide
	help(Disable AVX-512 further vector byte manipulation instructions)
	helpgroup(target)
	set(AVX512VBMI2=0)
	set(M_AVX512VBMI2=1)
	;

switch -mavx512bitalg is
	help(Enable [disable] AVX-512 bit algorithms)
	helpname(-m[no-]avx512bitalg)
	helpgroup(target)
	set(AVX512BITALG=1)
	set(M_AVX512BITALG=1)
	shorthand(-mavx512f)
	;

switch -mno-avx512bitalg is hide
	help(Disable AVX-512 bit algorithms)
	helpgroup(target)
	set(AVX512BITALG=0)
	set(M_AVX512BITALG=1)
	;

switch -mavx512vpopcntdq is
	help(Enable [disable] AVX-512 population count instructions)
	helpname(-m[no-]avx512vpopcntdq)
	helpgroup(target)
	set(AVX512VPOPCNTDQ=1)
	set(M_AVX512VPOPCNTDQ=1)
	shorthand(-mavx512f)
	;

switch -mno-avx512vpopcntdq is hide
	help(Disable AVX-512 population count instructions)
	helpgroup(target)
	set(AVX512VPOPCNTDQ=0)
	set(M_AVX512VPOPCNTDQ=1)
	;

switch -mavx512vnni is
	help(Enable [disable] AVX-512 Vector Neural Network Instructions)
	helpname(-m[no-]avx512vnni)
	helpgroup(target)
	set(AVX512VNNI=1)
	set(M_AVX512VNNI=1)
	shorthand(-mavx512f)
	;

switch -mno-avx512vnni is hide
	help(Disable AVX-512 Vector Neural Network Instructions)
	helpgroup(target)
	set(AVX512VNNI=0)
	set(M_AVX512VNNI=1)
	;

switch -mf16c is
	help(Enable [disable] 16-bit floating-point conversion instructions)
	helpname(-m[no-]f16c)
	helpgroup(target)
	set(F16C=1)
	set(M_F16C=1)
	shorthand(-mavx)
	;

switch -mno-f16c is hide
	help(Disable 16-bit floating-point conversion instructions)
	helpgroup(target)
	set(F16C=0)
	set(M_F16C=1)
	;

switch -mfma is
	help(Enable [disable] three-operand fused multiply-add)
	helpname(-m[no-]fma)
	helpgroup(target)
	set(FMA=1)
	set(M_FMA=1)
	shorthand(-mavx)
	;

switch -mno-fma is hide
	help(Disable three-operand fused multiply-add)
	helpgroup(target)
	set(FMA=0)
	set(M_FMA=1)
	;

switch -mfma4 is
	help(Enable [disable] four-operand fused multiply-add)
	helpname(-m[no-]fma4)
	helpgroup(target)
	set(FMA4=1)
	set(M_FMA4=1)
	shorthand(-mavx)
	shorthand(-msse4a)
	;

switch -mno-fma4 is hide
	help(Disable four-operand fused multiply-add)
	helpgroup(target)
	set(FMA4=0)
	set(M_FMA4=1)
	shorthand(-mno-xop)
	;

switch -mxop is
	help(Enable [disable] XOP instructions)
	helpname(-m[no-]xop)
	helpgroup(target)
	set(XOP=1)
	set(M_XOP=1)
	shorthand(-mfma4)
	;

switch -mno-xop is hide
	help(Disable XOP instructions)
	helpgroup(target)
	set(XOP=0)
	set(M_XOP=1)
	;

switch -mxsave is
	help(Enable [disable] XSAVE instructions)
	helpname(-m[no-]xsave)
	helpgroup(target)
	set(XSAVE=1)
	set(M_XSAVE=1)
	;

switch -mno-xsave is hide
	help(Disable XSAVE instructions)
	helpgroup(target)
	set(XSAVE=0)
	set(M_XSAVE=1)
	shorthand(-mno-avx)
	shorthand(-mno-xsaves)
	shorthand(-mno-xsavec)
	shorthand(-mno-xsaveopt)
	;

switch -mxsaveopt is
	help(Enable [disable] XSAVEOPT instructions)
	helpname(-m[no-]xsaveopt)
	helpgroup(target)
	set(XSAVEOPT=1)
	set(M_XSAVEOPT=1)
	shorthand(-mxsave)
	;

switch -mno-xsaveopt is hide
	help(Disable XSAVEOPT instructions)
	helpgroup(target)
	set(XSAVEOPT=0)
	set(M_XSAVEOPT=1)
	;

switch -mxsavec is
	help(Enable [disable] XSAVEC instructions)
	helpname(-m[no-]xsavec)
	helpgroup(target)
	set(XSAVEC=1)
	set(M_XSAVEC=1)
	shorthand(-mxsave)
	;

switch -mno-xsavec is hide
	help(Disable XSAVEC instructions)
	helpgroup(target)
	set(XSAVEC=0)
	set(M_XSAVEC=1)
	;

switch -mxsaves is
	help(Enable [disable] XSAVES instructions)
	helpname(-m[no-]xsaves)
	helpgroup(target)
	set(XSAVES=1)
	set(M_XSAVES=1)
	shorthand(-mxsave)
	;

switch -mno-xsaves is hide
	help(Disable XSAVES instructions)
	helpgroup(target)
	set(XSAVES=0)
	set(M_XSAVES=1)
	;

switch -mpopcnt is
	help(Enable [disable] population count instructions)
	helpname(-m[no-]popcnt)
	helpgroup(target)
	set(POPCNT=1)
	set(M_POPCNT=1)
	;

switch -mno-popcnt is hide
	help(Disable population count instructions)
	helpgroup(target)
	set(POPCNT=0)
	set(M_POPCNT=1)
	;

switch -msha is
	help(Enable [disable] SHA instructions)
	helpname(-m[no-]sha)
	helpgroup(target)
	set(SHA=1)
	set(M_SHA=1)
	shorthand(-msse2)
	;

switch -mno-sha is hide
	help(Disable SHA instructions)
	helpgroup(target)
	set(SHA=0)
	set(M_SHA=1)
	;

switch -maes is
	help(Enable [disable] AES instructions)
	helpname(-m[no-]aes)
	helpgroup(target)
	set(AES=1)
	set(M_AES=1)
	shorthand(-msse2);

switch -mno-aes is hide
	help(Disable AES instructions)
	helpgroup(target)
	set(AES=0)
	set(M_AES=1)
	;

switch -mpclmul is
	help(Enable [disable] packed carry-less multiplication instructions)
	helpname(-m[no-]pclmul)
	helpgroup(target)
	set(PCLMUL=1)
	set(M_PCLMUL=1)
	shorthand(-msse2)
	;

switch -mno-pclmul is hide
	help(Disable packed carry-less multiplication instructions)
	helpgroup(target)
	set(PCLMUL=0)
	set(M_PCLMUL=1)
	;

switch -mclflushopt is
	help(Enable [disable] optimized cache line flush instructions)
	helpname(-m[no-]clflushopt)
	helpgroup(target)
	set(CLFLUSHOPT=1)
	set(M_CLFLUSHOPT=1)
	;

switch -mno-clflushopt is hide
	help(Disable optimized cache line flush instructions)
	helpgroup(target)
	set(CLFLUSHOPT=0)
	set(M_CLFLUSHOPT=1)
	;

switch -mfsgsbase is
	help(Enable [disable] FS/GS base instructions)
	helpname(-m[no-]fsgsbase)
	helpgroup(target)
	set(FSGSBASE=1)
	set(M_FSGBASE=1)
	;

switch -mno-fsgsbase is hide
	help(Disable FS/GS base instructions)
	helpgroup(target)
	set(FSGSBASE=0)
	set(M_FSGBASE=1)
	;

switch -mrdrnd is
	help(Enable [disable] RDRND instructions)
	helpname(-m[no-]rdrnd)
	helpgroup(target)
	set(RDRND=1)
	set(M_RDRND=1)
	;

switch -mno-rdrnd is hide
	help(Disable RDRND instructions)
	helpgroup(target)
	set(RDRND=0)
	set(M_RDRND=1)
	;

switch -mprefetchwt1 is
	help(Enable [disable] prefetch with intent to write and T1 hint instructions)
	helpname(-m[no-]prefetchwt1)
	helpgroup(target)
	set(PREFETCHWT1=1)
	set(M_PREFETCHWT1=1)
	;

switch -mno-prefetchwt1 is hide
	help(Disable prefetch with intent to write and T1 hint instructions)
	helpgroup(target)
	set(PREFETCHWT1=0)
	set(M_PREFETCHWT1=1)
	;

switch -mlwp is
	help(Enable [disable] LWP instructions)
	helpname(-m[no-]lwp)
	helpgroup(target)
	set(LWP=1)
	set(M_LWP=1)
	;

switch -mno-lwp is hide
	help(Disable LWP instructions)
	helpgroup(target)
	set(LWP=0)
	set(M_LWP=1)
	;

# -mabm is the only GCC option that doesn't have a matching LLVM feature.
switch -mabm is
	help(Enable [disable] ABM instructions)
	helpname(-m[no-]abm)
	helpgroup(target)
	set(ABM=1)
	set(M_ABM=1)
	shorthand(-mpopcnt)
	;

switch -mno-abm is hide
	help(Disable ABM instructions)
	helpgroup(target)
	set(ABM=0)
	set(M_ABM=1)
	;

switch -mbmi is
	help(Enable [disable] BMI instructions)
	helpname(-m[no-]bmi)
	helpgroup(target)
	set(BMI=1)
	set(M_BMI=1)
	;

switch -mno-bmi is hide
	help(Disable BMI instructions)
	helpgroup(target)
	set(BMI=0)
	set(M_BMI=1)
	;

switch -mbmi2 is
	help(Enable [disable] BMI2 instructions)
	helpname(-m[no-]bmi2)
	helpgroup(target)
	set(BMI2=1)
	set(M_BMI2=1)
	;

switch -mno-bmi2 is hide
	help(Disable BMI2 instructions)
	helpgroup(target)
	set(BMI2=0)
	set(M_BMI2=1)
	;

switch -mlzcnt is
	help(Enable [disable] LZCNT instructions)
	helpname(-m[no-]lzcnt)
	helpgroup(target)
	set(LZCNT=1)
	set(M_LZCNT=1)
	;

switch -mno-lzcnt is hide
	help(Disable LZCNT instructions)
	helpgroup(target)
	set(LZCNT=0)
	set(M_LZCNT=1)
	;

switch -mfxsr is
	help(Enable [disable] fxsave/fxrestore instructions)
	helpname(-m[no-]fxsr)
	helpgroup(target)
	set(FXSR=1)
	set(M_FXSR=1)
	;

switch -mno-fxsr is hide
	help(Disable fxsave/fxrestore instructions)
	helpgroup(target)
	set(FXSR=0)
	set(M_FXSR=1)
	;

switch -mrtm is
	help(Enable [disable] RTM instructions)
	helpname(-m[no-]rtm)
	helpgroup(target)
	set(RTM=1)
	set(M_RTM=1)
	;

switch -mno-rtm is hide
	help(Disable RTM instructions)
	helpgroup(target)
	set(RTM=0)
	set(M_RTM=1)
	;

switch -mtbm is
	help(Enable [disable] TBM instructions)
	helpname(-m[no-]tbm)
	helpgroup(target)
	set(TBM=1)
	set(M_TBM=1)
	;

switch -mno-tbm is hide
	help(Disable TBM instructions)
	helpgroup(target)
	set(TBM=0)
	set(M_TBM=1)
	;

switch -mmwaitx is
	help(Enable [disable] MONITOR/MWAITX timer functionality)
	helpname(-m[no-]mwaitx)
	helpgroup(target)
	set(MWAITX=1)
	set(M_MWAITX=1)
	;

switch -mno-mwaitx is hide
	help(Disable MONITOR/MWAITX timer functionality)
	helpgroup(target)
	set(MWAITX=0)
	set(M_MWAITX=1)
	;

switch -mclzero is
	help(Enable [disable] cache line zero instructions)
	helpname(-m[no-]clzero)
	helpgroup(target)
	set(CLZERO=1)
	set(M_CLZERO=1)
	;

switch -mno-clzero is hide
	help(Disable cache line zero instructions)
	helpgroup(target)
	set(CLZERO=0)
	set(M_CLZERO=1)
	;

switch -mpku is
	help(Enable [disable] protection keys)
	helpname(-m[no-]pku)
	helpgroup(target)
	set(PKU=1)
	set(M_PKU=1)
	;

switch -mno-pku is hide
	help(Disable protection keys)
	helpgroup(target)
	set(PKU=0)
	set(M_PKU=1)
	;

switch -mgfni is
	help(Enable [disable] Galois field arithmetic instructions)
	helpname(-m[no-]gfni)
	helpgroup(target)
	set(GFNI=1)
	set(M_GFNI=1)
	;

switch -mno-gfni is hide
	help(Disable Galois field arithmetic instructions)
	helpgroup(target)
	set(GFNI=0)
	set(M_GFNI=1)
	;

switch -mvaes is
	help(Enable [disable] promotion of selected AES instructions to AVX512/AVX registers)
	helpname(-m[no-]vaes)
	helpgroup(target)
	set(VAES=1)
	set(M_VAES=1)
	;

switch -mno-vaes is hide
	help(Disable promotion of selected AES instructions to AVX512/AVX registers)
	helpgroup(target)
	set(VAES=0)
	set(M_VAES=1)
	;

switch -mvpclmulqdq is
	help(Enable [disable] VPCLMULQDQ instructions)
	helpname(-m[no-]vpclmulqdq)
	helpgroup(target)
	set(VPCLMULQDQ=1)
	set(M_VPCLMULQDQ=1)
	;

switch -mno-vpclmulqdq is hide
	help(Disable VPCLMULQDQ instructions)
	helpgroup(target)
	set(VPCLMULQDQ=0)
	set(M_VPCLMULQDQ=1)
	;

switch -mmovdiri is
	help(Enable [disable] MOVDIRI instructions)
	helpname(-m[no-]movdiri)
	helpgroup(target)
	set(MOVDIRI=1)
	set(M_MOVDIRI=1)
	;

switch -mno-movdiri is hide
	help(Disable MOVDIRI instructions)
	helpgroup(target)
	set(MOVDIRI=0)
	set(M_MOVDIRI=1)
	;

switch -mmovdir64b is
	help(Enable [disable] MOVDIR64B instructions)
	helpname(-m[no-]movdir64b)
	helpgroup(target)
	set(MOVDIR64B=1)
	set(M_MOVDIR64B=1)
	;

switch -mno-movdir64b is hide
	help(Disable MOVDIR64B instructions)
	helpgroup(target)
	set(MOVDIR64B=0)
	set(M_MOVDIR64B=1)
	;

switch -madx is
	help(Enable [disable] ADX instructions)
	helpname(-m[no-]adx)
	helpgroup(target)
	set(ADX=1)
	set(M_ADX=1)
	;

switch -mno-adx is hide
	help(Disable ADX instructions)
	helpgroup(target)
	set(ADX=0)
	set(M_ADX=1)
	;

switch -mamx-bf16 is
	help(Enable [disable] AMX-BF16 instructions)
	helpname(-m[no-]amx-bf16)
	helpgroup(target)
	set(AMX_BF16=1)
	set(M_AMX_BF16=1)
	;

switch -mno-amx-bf16 is hide
	help(Disable AMX-BF16 instructions)
	helpgroup(target)
	set(AMX_BF16=0)
	set(M_AMX_BF16=1)
	;

switch -mamx-complex is
	help(Enable [disable] AMX-COMPLEX instructions)
	helpname(-m[no-]amx-complex)
	helpgroup(target)
	set(AMX_COMPLEX=1)
	set(M_AMX_COMPLEX=1)
	;

switch -mno-amx-complex is hide
	help(Disable AMX-COMPLEX instructions)
	helpgroup(target)
	set(AMX_COMPLEX=0)
	set(M_AMX_COMPLEX=1)
	;

switch -mamx-fp16 is
	help(Enable [disable] AMX-FP16 instructions)
	helpname(-m[no-]amx-fp16)
	helpgroup(target)
	set(AMX_FP16=1)
	set(M_AMX_FP16=1)
	;

switch -mno-amx-fp16 is hide
	help(Disable AMX-FP16 instructions)
	helpgroup(target)
	set(AMX_FP16=0)
	set(M_AMX_FP16=1)
	;

switch -mamx-int8 is
	help(Enable [disable] AMX-INT8 instructions)
	helpname(-m[no-]amx-int8)
	helpgroup(target)
	set(AMX_INT8=1)
	set(M_AMX_INT8=1)
	;

switch -mno-amx-int8 is hide
	help(Disable AMX-INT8 instructions)
	helpgroup(target)
	set(AMX_INT8=0)
	set(M_AMX_INT8=1)
	;

switch -mamx-tile is
	help(Enable [disable] AMX-TILE instructions)
	helpname(-m[no-]amx-tile)
	helpgroup(target)
	set(AMX_TILE=1)
	set(M_AMX_TILE=1)
	;

switch -mno-amx-tile is hide
	help(Disable AMX-TILE instructions)
	helpgroup(target)
	set(AMX_TILE=0)
	set(M_AMX_TILE=1)
	;

switch -mavx512bf16 is
	help(Enable [disable] AVX512BF16 instructions)
	helpname(-m[no-]avx512bf16)
	helpgroup(target)
	set(AVX512BF16=1)
	set(M_AVX512BF16=1)
	shorthand(-mavx512vl)
	;

switch -mno-avx512bf16 is hide
	help(Disable AVX512BF16 instructions)
	helpgroup(target)
	set(AVX512BF16=0)
	set(M_AVX512BF16=1)
	;

switch -mavx512fp16 is
	help(Enable [disable] AVX512FP16 instructions)
	helpname(-m[no-]avx512fp16)
	helpgroup(target)
	set(AVX512FP16=1)
	set(M_AVX512FP16=1)
	shorthand(-mavx512vl)
	;

switch -mno-avx512fp16 is hide
	help(Disable AVX512FP16 instructions)
	helpgroup(target)
	set(AVX512FP16=0)
	set(M_AVX512FP16=1)
	;

switch -mavx512vp2intersect is
	help(Enable [disable] AVX512VP2INTERSECT instructions)
	helpname(-m[no-]avx512vp2intersect)
	helpgroup(target)
	set(AVX512VP2INTERSECT=1)
	set(M_AVX512VP2INTERSECT=1)
	shorthand(-mavx512vl)
	;

switch -mno-avx512vp2intersect is hide
	help(Disable AVX512VP2INTERSECT instructions)
	helpgroup(target)
	set(AVX512VP2INTERSECT=0)
	set(M_AVX512VP2INTERSECT=1)
	;

switch -mavxifma is
	help(Enable [disable] AVXIFMA instructions)
	helpname(-m[no-]avxifma)
	helpgroup(target)
	set(AVXIFMA=1)
	set(M_AVXIFMA=1)
	;

switch -mno-avxifma is hide
	help(Disable AVXIFMA instructions)
	helpgroup(target)
	set(AVXIFMA=0)
	set(M_AVXIFMA=1)
	;

switch -mavxneconvert is
	help(Enable [disable] AVXNECONVERT instructions)
	helpname(-m[no-]avxneconvert)
	helpgroup(target)
	set(AVXNECONVERT=1)
	set(M_AVXNECONVERT=1)
	;

switch -mno-avxneconvert is hide
	help(Disable AVXNECONVERT instructions)
	helpgroup(target)
	set(AVXNECONVERT=0)
	set(M_AVXNECONVERT=1)
	;

switch -mavxvnni is
	help(Enable [disable] AVXVNNI instructions)
	helpname(-m[no-]avxvnni)
	helpgroup(target)
	set(AVXVNNI=1)
	set(M_AVXVNNI=1)
	;

switch -mno-avxvnni is hide
	help(Disable AVXVNNI instructions)
	helpgroup(target)
	set(AVXVNNI=0)
	set(M_AVXVNNI=1)
	;

switch -mavxvnniint8 is
	help(Enable [disable] AVXVNNIINT8 instructions)
	helpname(-m[no-]avxvnniint8)
	helpgroup(target)
	set(AVXVNNIINT8=1)
	set(M_AVXVNNIINT8=1)
	;

switch -mno-avxvnniint8 is hide
	help(Disable AVXVNNIINT8 instructions)
	helpgroup(target)
	set(AVXVNNIINT8=0)
	set(M_AVXVNNIINT8=1)
	;

switch -mcldemote is
	help(Enable [disable] CLDEMOTE instructions)
	helpname(-m[no-]cldemote)
	helpgroup(target)
	set(CLDEMOTE=1)
	set(M_CLDEMOTE=1)
	;

switch -mno-cldemote is hide
	help(Disable CLDEMOTE instructions)
	helpgroup(target)
	set(CLDEMOTE=0)
	set(M_CLDEMOTE=1)
	;

switch -mclwb is
	help(Enable [disable] CLWB instructions)
	helpname(-m[no-]clwb)
	helpgroup(target)
	set(CLWB=1)
	set(M_CLWB=1)
	;

switch -mno-clwb is hide
	help(Disable CLWB instructions)
	helpgroup(target)
	set(CLWB=0)
	set(M_CLWB=1)
	;

switch -mcmpccxadd is
	help(Enable [disable] CMPCCXADD instructions)
	helpname(-m[no-]cmpccxadd)
	helpgroup(target)
	set(CMPCCXADD=1)
	set(M_CMPCCXADD=1)
	;

switch -mno-cmpccxadd is hide
	help(Disable CMPCCXADD instructions)
	helpgroup(target)
	set(CMPCCXADD=0)
	set(M_CMPCCXADD=1)
	;

switch -mcx16 is
	help(Enable [disable] CX16 instructions)
	helpname(-m[no-]cx16)
	helpgroup(target)
	set(CX16=1)
	set(M_CX16=1)
	;

switch -mno-cx16 is hide
	help(Disable CX16 instructions)
	helpgroup(target)
	set(CX16=0)
	set(M_CX16=1)
	;

switch -menqcmd is
	help(Enable [disable] ENQCMD instructions)
	helpname(-m[no-]enqcmd)
	helpgroup(target)
	set(ENQCMD=1)
	set(M_ENQCMD=1)
	;

switch -mno-enqcmd is hide
	help(Disable ENQCMD instructions)
	helpgroup(target)
	set(ENQCMD=0)
	set(M_ENQCMD=1)
	;

switch -mhle is
	help(Enable [disable] HLE instructions)
	helpname(-m[no-]hle)
	helpgroup(target)
	set(HLE=1)
	set(M_HLE=1)
	;

switch -mno-hle is hide
	help(Disable HLE instructions)
	helpgroup(target)
	set(HLE=0)
	set(M_HLE=1)
	;

switch -mhreset is
	help(Enable [disable] HRESET instructions)
	helpname(-m[no-]hreset)
	helpgroup(target)
	set(HRESET=1)
	set(M_HRESET=1)
	;

switch -mno-hreset is hide
	help(Disable HRESET instructions)
	helpgroup(target)
	set(HRESET=0)
	set(M_HRESET=1)
	;

switch -mkl is
	help(Enable [disable] KL instructions)
	helpname(-m[no-]kl)
	helpgroup(target)
	set(KL=1)
	set(M_KL=1)
	;

switch -mno-kl is hide
	help(Disable KL instructions)
	helpgroup(target)
	set(KL=0)
	set(M_KL=1)
	;

switch -mmovbe is
	help(Enable [disable] MOVBE instructions)
	helpname(-m[no-]movbe)
	helpgroup(target)
	set(MOVBE=1)
	set(M_MOVBE=1)
	;

switch -mno-movbe is hide
	help(Disable MOVBE instructions)
	helpgroup(target)
	set(MOVBE=0)
	set(M_MOVBE=1)
	;

switch -mpconfig is
	help(Enable [disable] PCONFIG instructions)
	helpname(-m[no-]pconfig)
	helpgroup(target)
	set(PCONFIG=1)
	set(M_PCONFIG=1)
	;

switch -mno-pconfig is hide
	help(Disable PCONFIG instructions)
	helpgroup(target)
	set(PCONFIG=0)
	set(M_PCONFIG=1)
	;

switch -mprefetchi is
	help(Enable [disable] PREFETCHI instructions)
	helpname(-m[no-]prefetchi)
	helpgroup(target)
	set(PREFETCHI=1)
	set(M_PREFETCHI=1)
	;

switch -mno-prefetchi is hide
	help(Disable PREFETCHI instructions)
	helpgroup(target)
	set(PREFETCHI=0)
	set(M_PREFETCHI=1)
	;

switch -mprfchw is
	help(Enable [disable] PRFCHW instructions)
	helpname(-m[no-]prfchw)
	helpgroup(target)
	set(PRFCHW=1)
	set(M_PRFCHW=1)
	;

switch -mno-prfchw is hide
	help(Disable PRFCHW instructions)
	helpgroup(target)
	set(PRFCHW=0)
	set(M_PRFCHW=1)
	;

switch -mptwrite is
	help(Enable [disable] PTWRITE instructions)
	helpname(-m[no-]ptwrite)
	helpgroup(target)
	set(PTWRITE=1)
	set(M_PTWRITE=1)
	;

switch -mno-ptwrite is hide
	help(Disable PTWRITE instructions)
	helpgroup(target)
	set(PTWRITE=0)
	set(M_PTWRITE=1)
	;

switch -mraoint is
	help(Enable [disable] RAOINT instructions)
	helpname(-m[no-]raoint)
	helpgroup(target)
	set(RAOINT=1)
	set(M_RAOINT=1)
	;

switch -mno-raoint is hide
	help(Disable RAOINT instructions)
	helpgroup(target)
	set(RAOINT=0)
	set(M_RAOINT=1)
	;

switch -mrdpid is
	help(Enable [disable] RDPID instructions)
	helpname(-m[no-]rdpid)
	helpgroup(target)
	set(RDPID=1)
	set(M_RDPID=1)
	;

switch -mno-rdpid is hide
	help(Disable RDPID instructions)
	helpgroup(target)
	set(RDPID=0)
	set(M_RDPID=1)
	;

switch -mrdseed is
	help(Enable [disable] RDSEED instructions)
	helpname(-m[no-]rdseed)
	helpgroup(target)
	set(RDSEED=1)
	set(M_RDSEED=1)
	;

switch -mno-rdseed is hide
	help(Disable RDSEED instructions)
	helpgroup(target)
	set(RDSEED=0)
	set(M_RDSEED=1)
	;

switch -msahf is
	help(Enable [disable] SAHF instructions)
	helpname(-m[no-]sahf)
	helpgroup(target)
	set(SAHF=1)
	set(M_SAHF=1)
	;

switch -mno-sahf is hide
	help(Disable SAHF instructions)
	helpgroup(target)
	set(SAHF=0)
	set(M_SAHF=1)
	;

switch -mserialize is
	help(Enable [disable] SERIALIZE instructions)
	helpname(-m[no-]serialize)
	helpgroup(target)
	set(SERIALIZE=1)
	set(M_SERIALIZE=1)
	;

switch -mno-serialize is hide
	help(Disable SERIALIZE instructions)
	helpgroup(target)
	set(SERIALIZE=0)
	set(M_SERIALIZE=1)
	;

switch -msgx is
	help(Enable [disable] SGX instructions)
	helpname(-m[no-]sgx)
	helpgroup(target)
	set(SGX=1)
	set(M_SGX=1)
	;

switch -mno-sgx is hide
	help(Disable SGX instructions)
	helpgroup(target)
	set(SGX=0)
	set(M_SGX=1)
	;

switch -mshstk is
	help(Enable [disable] SHSTK instructions)
	helpname(-m[no-]shstk)
	helpgroup(target)
	set(SHSTK=1)
	set(M_SHSTK=1)
	;

switch -mno-shstk is hide
	help(Disable SHSTK instructions)
	helpgroup(target)
	set(SHSTK=0)
	set(M_SHSTK=1)
	;

switch -mtsxldtrk is
	help(Enable [disable] TSXLDTRK instructions)
	helpname(-m[no-]tsxldtrk)
	helpgroup(target)
	set(TSXLDTRK=1)
	set(M_TSXLDTRK=1)
	;

switch -mno-tsxldtrk is hide
	help(Disable TSXLDTRK instructions)
	helpgroup(target)
	set(TSXLDTRK=0)
	set(M_TSXLDTRK=1)
	;

switch -muintr is
	help(Enable [disable] UINTR instructions)
	helpname(-m[no-]uintr)
	helpgroup(target)
	set(UINTR=1)
	set(M_UINTR=1)
	;

switch -mno-uintr is hide
	help(Disable UINTR instructions)
	helpgroup(target)
	set(UINTR=0)
	set(M_UINTR=1)
	;

switch -mwaitpkg is
	help(Enable [disable] WAITPKG instructions)
	helpname(-m[no-]waitpkg)
	helpgroup(target)
	set(WAITPKG=1)
	set(M_WAITPKG=1)
	;

switch -mno-waitpkg is hide
	help(Disable WAITPKG instructions)
	helpgroup(target)
	set(WAITPKG=0)
	set(M_WAITPKG=1)
	;

switch -mwbnoinvd is
	help(Enable [disable] WBNOINVD instructions)
	helpname(-m[no-]wbnoinvd)
	helpgroup(target)
	set(WBNOINVD=1)
	set(M_WBNOINVD=1)
	;

switch -mno-wbnoinvd is hide
	help(Disable WBNOINVD instructions)
	helpgroup(target)
	set(WBNOINVD=0)
	set(M_WBNOINVD=1)
	;

switch -mwidekl is
	help(Enable [disable] WIDEKL instructions)
	helpname(-m[no-]widekl)
	helpgroup(target)
	set(WIDEKL=1)
	set(M_WIDEKL=1)
	;

switch -mno-widekl is hide
	help(Disable WIDEKL instructions)
	helpgroup(target)
	set(WIDEKL=0)
	set(M_WIDEKL=1)
	;


switch -m32 is hide
	help(Compile for 32-bit target)
	helpgroup(target)
	fatal(-m32 is not supported in this installation);

switch -m64 is hide
	help(Compile for 64-bit target, now the default)
	helpgroup(target);

switch -tpp7 is hide
	early
	help(Unsupported option)
	helpgroup(target)
	fatal(-tpp7 is not supported in this installation);

switch -Mdaz is
	help(Treat denormalized numbers as zero)
	helpname(-M[no]daz)
	helpgroup(target)
	append(CGARGS=-x 129 4 -y 129 0x400)
	append(LLVMOPTAPPENDARGS=--denormal-fp-math=positive-zero);

switch -Mnodaz is hide
	help(Don't treat denormalized numbers as zero)
	helpgroup(target)
	append(CGARGS=-y 129 4 -x 129 0x400);

switch -Midiom is
	help(Loop idiom recognition)
	helpgroup(opt)
        helpname(-M[no]idiom)
	append(F901ARGS=-y 8 0x8000000)
	append(CGARGS=-y 8 0x18000000);

switch -Mnoidiom is hide
	help(Suppress loop idiom recognition)
	helpgroup(opt)
	append(F901ARGS=-x 8 0x8000000)
	append(CGARGS=-x 8 0x18000000)
	append(CGARGS=-x 37 0x20);

switch -Mdse is
	help(Dead store elimination)
	helpgroup(opt)
	helpname(-M[no]dse)
	append(CGARGS=-x 135 0x200 -x 53 10);

switch -Mnodse is hide
	help(Disable dead store elimination)
	helpgroup(opt)
	append(CGARGS=-y 135 0x200 -y 53 10);

switch -Mpre is
	help(Enable partial redundancy elimination)
	helpgroup(opt)
	helpname(-M[no]pre)
	append(CGARGS=-x 164 0x1000);

switch -Mnopre is hide
	help(Disable partial redundancy elimination)
	helpgroup(opt)
	append(CGARGS=-y 164 0x1000);

switch -Mlre is
	help(Loop-carried redundancy elimination)
	helpgroup(opt)
	helpname(-M[no]lre)
	set(x42=0x14200000)	# prefer, noassoc, array
	keyword(
	    assoc( helpname([no]assoc) help(Allow expression reassociation) andnot(x42=0x400000))
	    noassoc( hide help(Disallow expression reassociation) or(x42=0x400000))
	    array( hide helpname([no]array) help(Treat arrays as expressions) or(x42=0x2000000))
	    noarray( hide help(Don't treat arrays as expressions) andnot(x42=0x2000000))
	    prefer( hide helpname([no]prefer) help(Prefer LRE over vectorization) or(x42=0x10000000))
	    noprefer( hide help(Don't prefer LRE over vectorization) andnot(x42=0x10000000))
	)
	nokeyword()
	append(CGARGS=-x 42 $x42);

switch -Mnolre is hide
	help(Disable loop-carried redundancy elimination)
	helpgroup(opt)
	append(CGARGS=-y 42 0x600000);

variable MPI_EXTRAFTNOBJ is default();

switch -Mmpi is
	if ($index($TARGET,linux86-64,win64,win64-llvm))
	help(Use default or specified MPI communication libraries)
	helpgroup(linker)
	keyword(
	    mpich(
            if($index($TARGET,linux86-64))
		    help(Use default or MPIDIR-specified MPICH v3.0 libraries)
		    set(MPILIBDIR=$if($MPILIB,$MPILIB))
		    set(MPILIBINC=$if($MPIINC,$MPIINC))
		    append(USRINC=$MPILIBINC)
		    append(USRRPATH=$foreach(ll,$MPILIBDIR, -rpath $ll))
		    append(LMPILIB=-l$MPILIBNAME -lopa -lmpl -lpthread)
		    append(LMPILIB=$foreach(ll,$MPILIBDIR, -L$ll)
			    $if($FORTRANMPI,$foreach(ll,$FORTRANMPI, -l$ll) $MPI_EXTRAFTNOBJ))
		    set(LRTLIB=$LRTLIBNAME)
	    )
	    msmpi(
            if($index($TARGET,win64,win64-llvm))
		    help(Use default MS-MPI libraries)
		    set(MPILIBDIR=$MPIMSLIB)
		    set(MPILIBINC=$MPIMSINC)
		    append(LMPILIB=$foreach(ll,$MPILIBDIR, $(LDIRSW)$ll))
		    append(LDLIB1=$if($HASMSMPIFLIBNAME,$foreach(dd,$MSMPIFLIBNAME, $(LIBSW_NOLIB)$dd)))
		    append(LDLIB1=$if($HASMSMPIFLIBNAME,-nodefaultlib:ifconsol))
		    append(LDLIB1=$if($HASMSMPIFLIBNAME64,-nodefaultlib:libifcoremt))
		    append(LDLIB1=$if($HASMSMPIFLIBNAME32,-nodefaultlib:libifcore))
		    append(LDLIB1=$if($HASMSMPIFLIBNAME,-nodefaultlib:libifport))
		    append(LDLIB1=$if($HASMSMPIFLIBNAME64,-nodefaultlib:libmmt))
		    append(LDLIB1=$if($HASMSMPIFLIBNAME32,-nodefaultlib:libm))
		    append(LDLIB1=$if($HASMSMPIFLIBNAME32,-nodefaultlib:LIBC))
		    append(LDLIB1=$if($HASMSMPIFLIBNAME,-nodefaultlib:libirc))
		    append(LDLIB1=$if($HASMSMPIFLIBNAME,-nodefaultlib:svml_disp))
		    append(USRINC=$MPILIBINC)
		    append(LMPILIB=$(LIBSW_NOLIB)$MPIMSLIBNAME)
		    set(LRTLIB=$LRTLIBNAME)
	    )
	    sgimpi(
            if($index($TARGET,linux86-64))
		    help(Use default or MPI_ROOT-specified SGI MPI libraries)
		    set(MPILIBDIR=$if($MPISGILIB,$MPISGILIB))
		    set(MPILIBINC=$if($MPISGIINC,$MPISGIINC))
		    append(LDLIB1=$foreach(ll,$MPILIBDIR, -L$ll))
		    append(USRINC=$MPILIBINC)
		    append(USRRPATH=$foreach(ll,$MPILIBDIR, -rpath $ll))
		    set(LMPILIB=-lmpi)
		    set(LRTLIB=$LRTLIBNAME)
	    )
	    mpich1(
            if($index($TARGET,linux86-64))
		    help(DEPRECATED: Use MPIDIR to specify MPICH1 libraries)
            echo(-Mmpi=mpich1 has been deprecated and will be removed in a future release)
			error($ifn($MPIUDIR,The environment variable "$"MPIDIR must be set to use MPICH1))
		    set(MPILIBDIR=$if($MPILIB,$MPILIB))
		    set(MPILIBINC=$if($MPIINC,$MPIINC))
		    append(LDLIB1=$foreach(ll,$MPILIBDIR, -L$ll)
			    $if($FORTRANMPI,$foreach(ll,$FORTRANMPI, -l$ll) $MPI_EXTRAFTNOBJ))
		    append(USRINC=$MPILIBINC)
		    append(USRRPATH=$foreach(ll,$MPILIBDIR, -rpath $ll))
		    set(LMPILIB=-l$MPILIBNAME -lpthread)
		    set(LRTLIB=$LRTLIBNAME)
	    )
	    mpich2(
            if($index($TARGET,linux86-64))
		    help(DEPRECATED: Use MPIDIR to specify MPICH2 libraries)
            echo(-Mmpi=mpich2 has been deprecated and will be removed in a future release)
			error($ifn($MPIUDIR,The environment variable "$"MPIDIR must be set to use MPICH2))
		    set(MPILIBDIR=$if($MPILIB,$MPILIB))
		    set(MPILIBINC=$if($MPIINC,$MPIINC))
		    append(LDLIB1=$foreach(ll,$MPILIBDIR, -L$ll)
			    $if($FORTRANMPI,$foreach(ll,$FORTRANMPI, -l$ll) $MPI_EXTRAFTNOBJ))
		    append(USRINC=$MPILIBINC)
		    append(USRRPATH=$foreach(ll,$MPILIBDIR, -rpath $ll))
		    set(LMPILIB=-l$MPILIBNAME -lopa -lmpl  -lpthread)
		    set(LRTLIB=$LRTLIBNAME)
	    )
	    mvapich1(
            if($index($TARGET,linux86-64))
		    help(DEPRECATED: Use MPIDIR to specify MVAPICH1 libraries)
            echo(-Mmpi=mvapich1 has been deprecated and will be removed in a future release)
			error($ifn($MPIUDIR,The environment variable "$"MPIDIR must be set to use MVAPICH1))
		    set(MPILIBDIR=$if($MPILIB,$MPILIB))
		    set(MPILIBINC=$if($MPIINC,$MPIINC))
		    append(LMPILIB=$foreach(ll,$MPILIBDIR, -L$ll)
			    $if($FORTRANMPI,$foreach(ll,$FORTRANMPI, -l$ll) $MPI_EXTRAFTNOBJ))
		    append(LDLIB1=$if($MPILIBDIR,-L$OFEDLIBDIR -libverbs -libumad -lpthread -lpthread  -lrt))
		    append(USRINC=$MPILIBINC)
		    append(USRRPATH=$foreach(ll,$MPILIBDIR, -rpath $ll))
		    append(LMPILIB=-lmpichf90nc -lmpichfarg -l$MPILIBNAME -lpthread)
		    set(LRTLIB=$LRTLIBNAME)
	    )
	);

switch -Mgccbugs is
	help(Match behavior of certain gcc bugs)
	helpgroup(target)
	helpname(-Mgccbug[s])
	append(CGARGS=-x 122 0x4000);

switch -Mgccbug is hide	# recognize singular as well
	help(Match behavior of certain gcc bugs)
	helpgroup(target)
	helpname(-Mgccbug[s])
	append(CGARGS=-x 122 0x4000);

switch -newcg is hide
	help(No longer in use)
	helpgroup(target);

variable FTNRTL is
	help(Name of f77 runtime library)
	default($USRFTNRTL $DEFFTNRTL);

variable USRFTNRTL is
	help(Additional fortran runtime libraries);

switch -pgcpplibs is hide
	help(Deprecated: Append C++ libraries to the link line)
	helpgroup(linker)
	warning( -pgcpplibs is no longer supported: use -c++libs);

switch -pgc++libs is
	help(Deprecated; see -c++libs)
	shorthand(-c++libs);

switch -c++libs is
	help(Append gnu compatible C++ libraries to the link line)
	helpgroup(linker)
	set(NOSTDCPPLIBS=)
	set(DEFLANGSTDLIB= $if($index($TARGET,linux86-64,linuxarm),stdc++,$NORMALSTDLIB))
	set(ZCLIBS= $PGISTATICX $PGATM $PGIUNSTATICX )
	append(ZCLIBS= $if($index($TARGET,linux86-64,linuxarm),--eh-frame-hdr ))
	set(DEFCPPLIBS=$ZCLIBS $LIBSW$DEFLANGSTDLIB  $CPPSTDLIBS $BLTINLIBS)
	append(CPPSTDLIBS=$DEFCPPSTDLIBS)
	append(CPPLDARGS=$DEFCPPLDARGS);

switch -acclibs is
	help(Append Accelerator libraries to the link line)
	helpgroup(linker)
	append(DEFACCLIB=$(LIBSW)accdevice $DLLIB)
	append(DEFACCLIB=$if($index($TARGET,win64,win64-llvm),-defaultlib:ws2_32.lib));

variable TRACEBACK is default(OFF) values(ON OFF);	# default is OFF, Fortran sets ON
variable TRACEBACKSW is default(OFF) values(ON OFF);	# default is OFF

append CGARGS=$ifn($equal($TRACEBACK,ON),-x 120 0x200000);

switch -traceback is
	helpgroup(debug)
	helpname(-[no]traceback)
	help(Add debug information for runtime traceback)
	set(TRACEBACKSW=ON)
	set(TRACEBACK=ON);
switch -notraceback is hide
	helpgroup(debug)
	help(Do not add debug information for runtime traceback)
	set(TRACEBACKSW=OFF)
	set(TRACEBACK=OFF);

switch -Mreg_struct_return is hide
	helpgroup(target)
	helpname(-M[no]reg_struct_return)
	help(Return small struct/union values in registers)
	append(CGARGS=-x 121 0x100000);

switch -Mnoreg_struct_return is hide
	helpgroup(target)
	help(Don't return small struct/union values in registers)
	append(CGARGS=-y 121 0x100000);

switch -Mwritable-strings is
	helpgroup(target)
	help(Store string constants in the writable data segment)
	set(WRSTR=-y 119 0x20);

switch -Mwritable-constants is
	helpgroup(target)
	help(Store constants in the writable data segment)
	append(CGARGS=-x 183 0x20000000);

switch -dA is hide
	helpgroup(overall)
	help(Annotate DWARF code with comments; implies -Mkeepasm)
	set(KEEPASM=YES)
	append(CGARGS=-x 120 0x100);

error($if($and($SIMD512,$notequal($NOSIMD512,)),Target processor -tp $NOSIMD512  does not support 512-bit SIMD instructions));

error($if($and($equal($CLTPVAL,),$SIMD512,$notequal($AVX512F,1)),Target processor $INFOTPVAL does not support 512-bit SIMD instructions));

## Unsigned chars support

# Char is signed by defaul
variable DEFDEFUNSIGNED is default(NO);
# Add unsigned char macros if needed
append USRDDEF=$if($equal($DEFUNSIGNED,YES),-D__CHAR_UNSIGNED__);
append USRDEFDEF=$if($equal($DEFUNSIGNED,YES),-def __CHAR_UNSIGNED__);

#
# -mattr_internal - place holder so that llmvcomprc does not fail.
# To be filled in.
#
switch -mattr_internal=arg is early
    hide
    help(x86_64 support for -mattr and -mcpu=target+<FEATS>)
;
