RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/Basic_2Targets_2X86_8cpp_source.html below:

clang: lib/Basic/Targets/X86.cpp Source File

17#include "llvm/ADT/StringExtras.h" 18#include "llvm/ADT/StringRef.h" 19#include "llvm/ADT/StringSwitch.h" 20#include "llvm/TargetParser/X86TargetParser.h" 27#define BUILTIN(ID, TYPE, ATTRS) \ 28 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES}, 29#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \ 30 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES}, 31#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \ 32 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::HEADER, LANGS}, 33#include "clang/Basic/BuiltinsX86.inc" 35#define BUILTIN(ID, TYPE, ATTRS) \ 36 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES}, 37#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \ 38 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES}, 39#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \ 40 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::HEADER, LANGS}, 41#include "clang/Basic/BuiltinsX86_64.inc" 45 "ax"

"dx"

"cx"

"bx"

"si"

"di"

"bp"

"sp"

46 "st"

"st(1)"

"st(2)"

"st(3)"

"st(4)"

"st(5)"

"st(6)"

"st(7)"

47 "argp"

"flags"

"fpcr"

"fpsr"

"dirflag"

"frame"

"xmm0"

"xmm1"

48 "xmm2"

"xmm3"

"xmm4"

"xmm5"

"xmm6"

"xmm7"

"mm0"

"mm1"

49 "mm2"

"mm3"

"mm4"

"mm5"

"mm6"

"mm7"

"r8"

"r9"

50 "r10"

"r11"

"r12"

"r13"

"r14"

"r15"

"xmm8"

"xmm9"

51 "xmm10"

"xmm11"

"xmm12"

"xmm13"

"xmm14"

"xmm15"

"ymm0"

"ymm1"

52 "ymm2"

"ymm3"

"ymm4"

"ymm5"

"ymm6"

"ymm7"

"ymm8"

"ymm9"

53 "ymm10"

"ymm11"

"ymm12"

"ymm13"

"ymm14"

"ymm15"

"xmm16"

"xmm17"

54 "xmm18"

"xmm19"

"xmm20"

"xmm21"

"xmm22"

"xmm23"

"xmm24"

"xmm25"

55 "xmm26"

"xmm27"

"xmm28"

"xmm29"

"xmm30"

"xmm31"

"ymm16"

"ymm17"

56 "ymm18"

"ymm19"

"ymm20"

"ymm21"

"ymm22"

"ymm23"

"ymm24"

"ymm25"

57 "ymm26"

"ymm27"

"ymm28"

"ymm29"

"ymm30"

"ymm31"

"zmm0"

"zmm1"

58 "zmm2"

"zmm3"

"zmm4"

"zmm5"

"zmm6"

"zmm7"

"zmm8"

"zmm9"

59 "zmm10"

"zmm11"

"zmm12"

"zmm13"

"zmm14"

"zmm15"

"zmm16"

"zmm17"

60 "zmm18"

"zmm19"

"zmm20"

"zmm21"

"zmm22"

"zmm23"

"zmm24"

"zmm25"

61 "zmm26"

"zmm27"

"zmm28"

"zmm29"

"zmm30"

"zmm31"

"k0"

"k1"

62 "k2"

"k3"

"k4"

"k5"

"k6"

"k7"

63 "cr0"

"cr2"

"cr3"

"cr4"

"cr8"

64 "dr0"

"dr1"

"dr2"

"dr3"

"dr6"

"dr7"

65 "bnd0"

"bnd1"

"bnd2"

"bnd3"

66 "tmm0"

"tmm1"

"tmm2"

"tmm3"

"tmm4"

"tmm5"

"tmm6"

"tmm7"

67 "r16"

"r17"

"r18"

"r19"

"r20"

"r21"

"r22"

"r23"

68 "r24"

"r25"

"r26"

"r27"

"r28"

"r29"

"r30"

"r31"

72

{{

"al"

"ah"

"eax"

"rax"

}, 0},

73

{{

"bl"

"bh"

"ebx"

"rbx"

}, 3},

74

{{

"cl"

"ch"

"ecx"

"rcx"

}, 2},

75

{{

"dl"

"dh"

"edx"

"rdx"

}, 1},

76

{{

"esi"

"rsi"

}, 4},

77

{{

"edi"

"rdi"

}, 5},

78

{{

"esp"

"rsp"

}, 7},

79

{{

"ebp"

"rbp"

}, 6},

80

{{

"r8d"

"r8w"

"r8b"

}, 38},

81

{{

"r9d"

"r9w"

"r9b"

}, 39},

82

{{

"r10d"

"r10w"

"r10b"

}, 40},

83

{{

"r11d"

"r11w"

"r11b"

}, 41},

84

{{

"r12d"

"r12w"

"r12b"

}, 42},

85

{{

"r13d"

"r13w"

"r13b"

}, 43},

86

{{

"r14d"

"r14w"

"r14b"

}, 44},

87

{{

"r15d"

"r15w"

"r15b"

}, 45},

88

{{

"r16d"

"r16w"

"r16b"

}, 165},

89

{{

"r17d"

"r17w"

"r17b"

}, 166},

90

{{

"r18d"

"r18w"

"r18b"

}, 167},

91

{{

"r19d"

"r19w"

"r19b"

}, 168},

92

{{

"r20d"

"r20w"

"r20b"

}, 169},

93

{{

"r21d"

"r21w"

"r21b"

}, 170},

94

{{

"r22d"

"r22w"

"r22b"

}, 171},

95

{{

"r23d"

"r23w"

"r23b"

}, 172},

96

{{

"r24d"

"r24w"

"r24b"

}, 173},

97

{{

"r25d"

"r25w"

"r25b"

}, 174},

98

{{

"r26d"

"r26w"

"r26b"

}, 175},

99

{{

"r27d"

"r27w"

"r27b"

}, 176},

100

{{

"r28d"

"r28w"

"r28b"

}, 177},

101

{{

"r29d"

"r29w"

"r29b"

}, 178},

102

{{

"r30d"

"r30w"

"r30b"

}, 179},

103

{{

"r31d"

"r31w"

"r31b"

}, 180},

108using namespace clang

;

112 if

(Name ==

"387"

) {

116 if

(Name ==

"sse"

) {

125 const

std::vector<std::string> &FeaturesVec)

const

{

128 if

(

getTriple

().getArch() == llvm::Triple::x86_64)

131 using namespace

llvm::X86;

134

getFeaturesForCPU(

CPU

, CPUFeatures);

135 for

(

auto

&F : CPUFeatures)

138

std::vector<std::string> UpdatedFeaturesVec;

139

std::vector<std::string> UpdatedAVX10FeaturesVec;

140 enum

{ FE_NOSET = -1, FE_FALSE, FE_TRUE };

141 int

HasEVEX512 = FE_NOSET;

142 bool

HasAVX512F = Features.lookup(

"avx512f"

);

143 bool

HasAVX10 = Features.lookup(

"avx10.1-256"

);

144 bool

HasAVX10_512 = Features.lookup(

"avx10.1-512"

);

145

std::string LastAVX10;

146

std::string LastAVX512;

147 for

(

const auto

&Feature : FeaturesVec) {

149 if

(Feature ==

"+general-regs-only"

) {

150

UpdatedFeaturesVec.push_back(

"-x87"

);

151

UpdatedFeaturesVec.push_back(

"-mmx"

);

152

UpdatedFeaturesVec.push_back(

"-sse"

);

156 if

(Feature.substr(1, 6) ==

"avx10."

) {

157 if

(Feature[0] ==

'+'

) {

159 if

(StringRef(Feature).ends_with(

"512"

))

160

HasAVX10_512 =

true

;

162

}

else if

(HasAVX10 && Feature ==

"-avx10.1-256"

) {

164

HasAVX10_512 =

false

;

165

}

else if

(HasAVX10_512 && Feature ==

"-avx10.1-512"

) {

166

HasAVX10_512 =

false

;

169

UpdatedAVX10FeaturesVec.push_back(Feature);

171

}

else if

(!HasAVX512F && StringRef(Feature).starts_with(

"+avx512"

)) {

173

LastAVX512 = Feature;

174

}

else if

(HasAVX512F && Feature ==

"-avx512f"

) {

176

}

else if

(HasEVEX512 != FE_TRUE && Feature ==

"+evex512"

) {

177

HasEVEX512 = FE_TRUE;

179

}

else if

(HasEVEX512 != FE_FALSE && Feature ==

"-evex512"

) {

180

HasEVEX512 = FE_FALSE;

184

UpdatedFeaturesVec.push_back(Feature);

186

llvm::append_range(UpdatedFeaturesVec, UpdatedAVX10FeaturesVec);

189 if

(!HasAVX10_512 && HasAVX512F) {

190

UpdatedFeaturesVec.push_back(HasEVEX512 == FE_FALSE ?

"-evex512" 192 if

(HasAVX10 && HasEVEX512 != FE_FALSE)

193

Diags.

Report

(diag::warn_invalid_feature_combination)

194

<< LastAVX512 +

" "

+ LastAVX10 +

"; will be promoted to avx10.1-512"

;

195

}

else if

(HasAVX10) {

196 if

(!HasAVX512F && HasEVEX512 != FE_NOSET)

197

Diags.

Report

(diag::warn_invalid_feature_combination)

198

<< LastAVX10 + (HasEVEX512 == FE_TRUE ?

" +evex512"

" -evex512"

);

199

UpdatedFeaturesVec.push_back(HasAVX10_512 ?

"+evex512"

"-evex512"

);

209 auto

I = Features.find(

"sse4.2"

);

210 if

(I != Features.end() && I->getValue() &&

211

!llvm::is_contained(UpdatedFeaturesVec,

"-popcnt"

))

212

Features[

"popcnt"

] =

true

;

216

I = Features.find(

"sse"

);

217 if

(I != Features.end() && I->getValue() &&

218

!llvm::is_contained(UpdatedFeaturesVec,

"-mmx"

))

219

Features[

"mmx"

] =

true

;

222

I = Features.find(

"avx"

);

223 if

(I != Features.end() && I->getValue() &&

224

!llvm::is_contained(UpdatedFeaturesVec,

"-xsave"

))

225

Features[

"xsave"

] =

true

;

228

I = Features.find(

"sse4.2"

);

229 if

(I != Features.end() && I->getValue() &&

230

!llvm::is_contained(UpdatedFeaturesVec,

"-crc32"

))

231

Features[

"crc32"

] =

true

;

237

StringRef Name,

bool

Enabled)

const

{

238 if

(Name ==

"sse4"

) {

249

Features[Name] = Enabled;

250

llvm::X86::updateImpliedFeatures(Name, Enabled, Features);

257 for

(

const auto

&Feature : Features) {

258 if

(Feature[0] !=

'+'

)

261 if

(Feature ==

"+mmx"

) {

263

}

else if

(Feature ==

"+aes"

) {

265

}

else if

(Feature ==

"+vaes"

) {

267

}

else if

(Feature ==

"+pclmul"

) {

269

}

else if

(Feature ==

"+vpclmulqdq"

) {

270

HasVPCLMULQDQ =

true

;

271

}

else if

(Feature ==

"+lzcnt"

) {

273

}

else if

(Feature ==

"+rdrnd"

) {

275

}

else if

(Feature ==

"+fsgsbase"

) {

277

}

else if

(Feature ==

"+bmi"

) {

279

}

else if

(Feature ==

"+bmi2"

) {

281

}

else if

(Feature ==

"+popcnt"

) {

283

}

else if

(Feature ==

"+rtm"

) {

285

}

else if

(Feature ==

"+prfchw"

) {

287

}

else if

(Feature ==

"+rdseed"

) {

289

}

else if

(Feature ==

"+adx"

) {

291

}

else if

(Feature ==

"+tbm"

) {

293

}

else if

(Feature ==

"+lwp"

) {

295

}

else if

(Feature ==

"+fma"

) {

297

}

else if

(Feature ==

"+f16c"

) {

299

}

else if

(Feature ==

"+gfni"

) {

301

}

else if

(Feature ==

"+evex512"

) {

303

}

else if

(Feature ==

"+avx10.1-256"

) {

305

}

else if

(Feature ==

"+avx10.1-512"

) {

306

HasAVX10_1_512 =

true

;

307

}

else if

(Feature ==

"+avx10.2-256"

) {

310

}

else if

(Feature ==

"+avx10.2-512"

) {

311

HasAVX10_2_512 =

true

;

312

}

else if

(Feature ==

"+avx512cd"

) {

314

}

else if

(Feature ==

"+avx512vpopcntdq"

) {

315

HasAVX512VPOPCNTDQ =

true

;

316

}

else if

(Feature ==

"+avx512vnni"

) {

317

HasAVX512VNNI =

true

;

318

}

else if

(Feature ==

"+avx512bf16"

) {

319

HasAVX512BF16 =

true

;

320

}

else if

(Feature ==

"+avx512fp16"

) {

321

HasAVX512FP16 =

true

;

323

}

else if

(Feature ==

"+avx512dq"

) {

325

}

else if

(Feature ==

"+avx512bitalg"

) {

326

HasAVX512BITALG =

true

;

327

}

else if

(Feature ==

"+avx512bw"

) {

329

}

else if

(Feature ==

"+avx512vl"

) {

331

}

else if

(Feature ==

"+avx512vbmi"

) {

332

HasAVX512VBMI =

true

;

333

}

else if

(Feature ==

"+avx512vbmi2"

) {

334

HasAVX512VBMI2 =

true

;

335

}

else if

(Feature ==

"+avx512ifma"

) {

336

HasAVX512IFMA =

true

;

337

}

else if

(Feature ==

"+avx512vp2intersect"

) {

338

HasAVX512VP2INTERSECT =

true

;

339

}

else if

(Feature ==

"+sha"

) {

341

}

else if

(Feature ==

"+sha512"

) {

343

}

else if

(Feature ==

"+shstk"

) {

345

}

else if

(Feature ==

"+sm3"

) {

347

}

else if

(Feature ==

"+sm4"

) {

349

}

else if

(Feature ==

"+movbe"

) {

351

}

else if

(Feature ==

"+movrs"

) {

353

}

else if

(Feature ==

"+sgx"

) {

355

}

else if

(Feature ==

"+cx8"

) {

357

}

else if

(Feature ==

"+cx16"

) {

359

}

else if

(Feature ==

"+fxsr"

) {

361

}

else if

(Feature ==

"+xsave"

) {

363

}

else if

(Feature ==

"+xsaveopt"

) {

365

}

else if

(Feature ==

"+xsavec"

) {

367

}

else if

(Feature ==

"+xsaves"

) {

369

}

else if

(Feature ==

"+mwaitx"

) {

371

}

else if

(Feature ==

"+pku"

) {

373

}

else if

(Feature ==

"+clflushopt"

) {

374

HasCLFLUSHOPT =

true

;

375

}

else if

(Feature ==

"+clwb"

) {

377

}

else if

(Feature ==

"+wbnoinvd"

) {

379

}

else if

(Feature ==

"+prefetchi"

) {

380

HasPREFETCHI =

true

;

381

}

else if

(Feature ==

"+clzero"

) {

383

}

else if

(Feature ==

"+cldemote"

) {

385

}

else if

(Feature ==

"+rdpid"

) {

387

}

else if

(Feature ==

"+rdpru"

) {

389

}

else if

(Feature ==

"+kl"

) {

391

}

else if

(Feature ==

"+widekl"

) {

393

}

else if

(Feature ==

"+retpoline-external-thunk"

) {

394

HasRetpolineExternalThunk =

true

;

395

}

else if

(Feature ==

"+sahf"

) {

397

}

else if

(Feature ==

"+waitpkg"

) {

399

}

else if

(Feature ==

"+movdiri"

) {

401

}

else if

(Feature ==

"+movdir64b"

) {

402

HasMOVDIR64B =

true

;

403

}

else if

(Feature ==

"+pconfig"

) {

405

}

else if

(Feature ==

"+ptwrite"

) {

407

}

else if

(Feature ==

"+invpcid"

) {

409

}

else if

(Feature ==

"+enqcmd"

) {

411

}

else if

(Feature ==

"+hreset"

) {

413

}

else if

(Feature ==

"+amx-bf16"

) {

415

}

else if

(Feature ==

"+amx-fp16"

) {

417

}

else if

(Feature ==

"+amx-int8"

) {

419

}

else if

(Feature ==

"+amx-tile"

) {

421

}

else if

(Feature ==

"+amx-complex"

) {

422

HasAMXCOMPLEX =

true

;

423

}

else if

(Feature ==

"+amx-fp8"

) {

425

}

else if

(Feature ==

"+amx-movrs"

) {

427

}

else if

(Feature ==

"+amx-transpose"

) {

428

HasAMXTRANSPOSE =

true

;

429

}

else if

(Feature ==

"+amx-avx512"

) {

430

HasAMXAVX512 =

true

;

431

}

else if

(Feature ==

"+amx-tf32"

) {

433

}

else if

(Feature ==

"+cmpccxadd"

) {

434

HasCMPCCXADD =

true

;

435

}

else if

(Feature ==

"+raoint"

) {

437

}

else if

(Feature ==

"+avxifma"

) {

439

}

else if

(Feature ==

"+avxneconvert"

) {

440

HasAVXNECONVERT=

true

;

441

}

else if

(Feature ==

"+avxvnni"

) {

443

}

else if

(Feature ==

"+avxvnniint16"

) {

444

HasAVXVNNIINT16 =

true

;

445

}

else if

(Feature ==

"+avxvnniint8"

) {

446

HasAVXVNNIINT8 =

true

;

447

}

else if

(Feature ==

"+serialize"

) {

448

HasSERIALIZE =

true

;

449

}

else if

(Feature ==

"+tsxldtrk"

) {

451

}

else if

(Feature ==

"+uintr"

) {

453

}

else if

(Feature ==

"+usermsr"

) {

455

}

else if

(Feature ==

"+crc32"

) {

457

}

else if

(Feature ==

"+x87"

) {

459

}

else if

(Feature ==

"+fullbf16"

) {

461

}

else if

(Feature ==

"+egpr"

) {

463

}

else if

(Feature ==

"+inline-asm-use-gpr32"

) {

464

HasInlineAsmUseGPR32 =

true

;

465

}

else if

(Feature ==

"+push2pop2"

) {

466

HasPush2Pop2 =

true

;

467

}

else if

(Feature ==

"+ppx"

) {

469

}

else if

(Feature ==

"+ndd"

) {

471

}

else if

(Feature ==

"+ccmp"

) {

473

}

else if

(Feature ==

"+nf"

) {

475

}

else if

(Feature ==

"+cf"

) {

477

}

else if

(Feature ==

"+zu"

) {

479

}

else if

(Feature ==

"+branch-hint"

) {

480

HasBranchHint =

true

;

483

X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)

484

.Case(

"+avx512f"

, AVX512F)

485

.Case(

"+avx2"

, AVX2)

487

.Case(

"+sse4.2"

, SSE42)

488

.Case(

"+sse4.1"

, SSE41)

489

.Case(

"+ssse3"

, SSSE3)

490

.Case(

"+sse3"

, SSE3)

491

.Case(

"+sse2"

, SSE2)

492

.Case(

"+sse"

, SSE1)

494

SSELevel = std::max(SSELevel, Level);

509

XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)

511

.Case(

"+fma4"

, FMA4)

512

.Case(

"+sse4a"

, SSE4A)

514

XOPLevel = std::max(XOPLevel, XLevel);

521

Diags.

Report

(diag::err_target_unsupported_fpmath)

539

Builder.defineMacro(

"__GCC_ASM_FLAG_OUTPUTS__"

);

542 if

(CodeModel ==

"default"

)

543

CodeModel =

"small"

;

544

Builder.defineMacro(

"__code_model_"

+ CodeModel +

"__"

);

547 if

(

getTriple

().getArch() == llvm::Triple::x86_64) {

548

Builder.defineMacro(

"__amd64__"

);

549

Builder.defineMacro(

"__amd64"

);

550

Builder.defineMacro(

"__x86_64"

);

551

Builder.defineMacro(

"__x86_64__"

);

552 if

(

getTriple

().getArchName() ==

"x86_64h"

) {

553

Builder.defineMacro(

"__x86_64h"

);

554

Builder.defineMacro(

"__x86_64h__"

);

560

Builder.defineMacro(

"__SEG_GS"

);

561

Builder.defineMacro(

"__SEG_FS"

);

562

Builder.defineMacro(

"__seg_gs"

"__attribute__((address_space(256)))"

);

563

Builder.defineMacro(

"__seg_fs"

"__attribute__((address_space(257)))"

);

568 using namespace

llvm::X86;

574

Builder.defineMacro(

"__tune_i386__"

);

583

Builder.defineMacro(

"__pentium_mmx__"

);

584

Builder.defineMacro(

"__tune_pentium_mmx__"

);

593

Builder.defineMacro(

"__tune_pentium3__"

);

597

Builder.defineMacro(

"__tune_pentium2__"

);

625 case

CK_GoldmontPlus:

639 case

CK_SkylakeClient:

640 case

CK_SkylakeServer:

644 case

CK_IcelakeClient:

646 case

CK_IcelakeServer:

648 case

CK_SapphireRapids:

656 case

CK_Sierraforest:

658 case

CK_Graniterapids:

659 case

CK_GraniterapidsD:

660 case

CK_Emeraldrapids:

661 case

CK_Clearwaterforest:

662 case

CK_Diamondrapids:

676

Builder.defineMacro(

"__tune_lakemont__"

);

679

Builder.defineMacro(

"__k6_2__"

);

680

Builder.defineMacro(

"__tune_k6_2__"

);

683 if

(

CPU

!= CK_K6_2) {

687

Builder.defineMacro(

"__k6_3__"

);

688

Builder.defineMacro(

"__tune_k6_3__"

);

697 if

(SSELevel != NoSSE) {

698

Builder.defineMacro(

"__athlon_sse__"

);

699

Builder.defineMacro(

"__tune_athlon_sse__"

);

753

Builder.defineMacro(

"__REGISTER_PREFIX__"

""

);

758

Builder.defineMacro(

"__NO_MATH_INLINES"

);

761

Builder.defineMacro(

"__AES__"

);

764

Builder.defineMacro(

"__VAES__"

);

767

Builder.defineMacro(

"__PCLMUL__"

);

770

Builder.defineMacro(

"__VPCLMULQDQ__"

);

774 if

(HasLAHFSAHF ||

getTriple

().getArch() == llvm::Triple::x86)

775

Builder.defineMacro(

"__LAHF_SAHF__"

);

778

Builder.defineMacro(

"__LZCNT__"

);

781

Builder.defineMacro(

"__RDRND__"

);

784

Builder.defineMacro(

"__FSGSBASE__"

);

787

Builder.defineMacro(

"__BMI__"

);

790

Builder.defineMacro(

"__BMI2__"

);

793

Builder.defineMacro(

"__POPCNT__"

);

796

Builder.defineMacro(

"__RTM__"

);

799

Builder.defineMacro(

"__PRFCHW__"

);

802

Builder.defineMacro(

"__RDSEED__"

);

805

Builder.defineMacro(

"__ADX__"

);

808

Builder.defineMacro(

"__TBM__"

);

811

Builder.defineMacro(

"__LWP__"

);

814

Builder.defineMacro(

"__MWAITX__"

);

817

Builder.defineMacro(

"__MOVBE__"

);

821

Builder.defineMacro(

"__XOP__"

);

824

Builder.defineMacro(

"__FMA4__"

);

827

Builder.defineMacro(

"__SSE4A__"

);

834

Builder.defineMacro(

"__FMA__"

);

837

Builder.defineMacro(

"__F16C__"

);

840

Builder.defineMacro(

"__GFNI__"

);

843

Builder.defineMacro(

"__EVEX512__"

);

845

Builder.defineMacro(

"__AVX10_1__"

);

847

Builder.defineMacro(

"__AVX10_1_512__"

);

849

Builder.defineMacro(

"__AVX10_2__"

);

851

Builder.defineMacro(

"__AVX10_2_512__"

);

853

Builder.defineMacro(

"__AVX512CD__"

);

854 if

(HasAVX512VPOPCNTDQ)

855

Builder.defineMacro(

"__AVX512VPOPCNTDQ__"

);

857

Builder.defineMacro(

"__AVX512VNNI__"

);

859

Builder.defineMacro(

"__AVX512BF16__"

);

861

Builder.defineMacro(

"__AVX512FP16__"

);

863

Builder.defineMacro(

"__AVX512DQ__"

);

865

Builder.defineMacro(

"__AVX512BITALG__"

);

867

Builder.defineMacro(

"__AVX512BW__"

);

869

Builder.defineMacro(

"__AVX512VL__"

);

870

Builder.defineMacro(

"__EVEX256__"

);

873

Builder.defineMacro(

"__AVX512VBMI__"

);

875

Builder.defineMacro(

"__AVX512VBMI2__"

);

877

Builder.defineMacro(

"__AVX512IFMA__"

);

878 if

(HasAVX512VP2INTERSECT)

879

Builder.defineMacro(

"__AVX512VP2INTERSECT__"

);

881

Builder.defineMacro(

"__SHA__"

);

883

Builder.defineMacro(

"__SHA512__"

);

886

Builder.defineMacro(

"__FXSR__"

);

888

Builder.defineMacro(

"__XSAVE__"

);

890

Builder.defineMacro(

"__XSAVEOPT__"

);

892

Builder.defineMacro(

"__XSAVEC__"

);

894

Builder.defineMacro(

"__XSAVES__"

);

896

Builder.defineMacro(

"__PKU__"

);

898

Builder.defineMacro(

"__CLFLUSHOPT__"

);

900

Builder.defineMacro(

"__CLWB__"

);

902

Builder.defineMacro(

"__WBNOINVD__"

);

904

Builder.defineMacro(

"__SHSTK__"

);

906

Builder.defineMacro(

"__SGX__"

);

908

Builder.defineMacro(

"__SM3__"

);

910

Builder.defineMacro(

"__SM4__"

);

912

Builder.defineMacro(

"__PREFETCHI__"

);

914

Builder.defineMacro(

"__CLZERO__"

);

916

Builder.defineMacro(

"__KL__"

);

918

Builder.defineMacro(

"__WIDEKL__"

);

920

Builder.defineMacro(

"__RDPID__"

);

922

Builder.defineMacro(

"__RDPRU__"

);

924

Builder.defineMacro(

"__CLDEMOTE__"

);

926

Builder.defineMacro(

"__WAITPKG__"

);

928

Builder.defineMacro(

"__MOVDIRI__"

);

930

Builder.defineMacro(

"__MOVDIR64B__"

);

932

Builder.defineMacro(

"__MOVRS__"

);

934

Builder.defineMacro(

"__PCONFIG__"

);

936

Builder.defineMacro(

"__PTWRITE__"

);

938

Builder.defineMacro(

"__INVPCID__"

);

940

Builder.defineMacro(

"__ENQCMD__"

);

942

Builder.defineMacro(

"__HRESET__"

);

944

Builder.defineMacro(

"__AMX_TILE__"

);

946

Builder.defineMacro(

"__AMX_INT8__"

);

948

Builder.defineMacro(

"__AMX_BF16__"

);

950

Builder.defineMacro(

"__AMX_FP16__"

);

952

Builder.defineMacro(

"__AMX_COMPLEX__"

);

954

Builder.defineMacro(

"__AMX_FP8__"

);

956

Builder.defineMacro(

"__AMX_MOVRS__"

);

958

Builder.defineMacro(

"__AMX_TRANSPOSE__"

);

960

Builder.defineMacro(

"__AMX_AVX512__"

);

962

Builder.defineMacro(

"__AMX_TF32__"

);

964

Builder.defineMacro(

"__CMPCCXADD__"

);

966

Builder.defineMacro(

"__RAOINT__"

);

968

Builder.defineMacro(

"__AVXIFMA__"

);

970

Builder.defineMacro(

"__AVXNECONVERT__"

);

972

Builder.defineMacro(

"__AVXVNNI__"

);

974

Builder.defineMacro(

"__AVXVNNIINT16__"

);

976

Builder.defineMacro(

"__AVXVNNIINT8__"

);

978

Builder.defineMacro(

"__SERIALIZE__"

);

980

Builder.defineMacro(

"__TSXLDTRK__"

);

982

Builder.defineMacro(

"__UINTR__"

);

984

Builder.defineMacro(

"__USERMSR__"

);

986

Builder.defineMacro(

"__CRC32__"

);

988

Builder.defineMacro(

"__EGPR__"

);

990

Builder.defineMacro(

"__PUSH2POP2__"

);

992

Builder.defineMacro(

"__PPX__"

);

994

Builder.defineMacro(

"__NDD__"

);

996

Builder.defineMacro(

"__CCMP__"

);

998

Builder.defineMacro(

"__NF__"

);

1000

Builder.defineMacro(

"__CF__"

);

1002

Builder.defineMacro(

"__ZU__"

);

1003 if

(HasEGPR && HasPush2Pop2 && HasPPX && HasNDD && HasCCMP && HasNF &&

1005

Builder.defineMacro(

"__APX_F__"

);

1006 if

(HasEGPR && HasInlineAsmUseGPR32)

1007

Builder.defineMacro(

"__APX_INLINE_ASM_USE_GPR32__"

);

1012

Builder.defineMacro(

"__AVX512F__"

);

1015

Builder.defineMacro(

"__AVX2__"

);

1018

Builder.defineMacro(

"__AVX__"

);

1021

Builder.defineMacro(

"__SSE4_2__"

);

1024

Builder.defineMacro(

"__SSE4_1__"

);

1027

Builder.defineMacro(

"__SSSE3__"

);

1030

Builder.defineMacro(

"__SSE3__"

);

1033

Builder.defineMacro(

"__SSE2__"

);

1034

Builder.defineMacro(

"__SSE2_MATH__"

);

1037

Builder.defineMacro(

"__SSE__"

);

1038

Builder.defineMacro(

"__SSE_MATH__"

);

1044 if

(Opts.MicrosoftExt &&

getTriple

().getArch() == llvm::Triple::x86) {

1054

Builder.defineMacro(

"_M_IX86_FP"

, Twine(2));

1057

Builder.defineMacro(

"_M_IX86_FP"

, Twine(1));

1060

Builder.defineMacro(

"_M_IX86_FP"

, Twine(0));

1067

Builder.defineMacro(

"__MMX__"

);

1070 if

(

CPU

>= CK_i486 ||

CPU

== CK_None) {

1071

Builder.defineMacro(

"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"

);

1072

Builder.defineMacro(

"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"

);

1073

Builder.defineMacro(

"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"

);

1076

Builder.defineMacro(

"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"

);

1077 if

(HasCX16 &&

getTriple

().getArch() == llvm::Triple::x86_64)

1078

Builder.defineMacro(

"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16"

);

1081

Builder.defineMacro(

"__SIZEOF_FLOAT128__"

"16"

);

1085 return

llvm::StringSwitch<bool>(Name)

1086

.Case(

"adx"

true

)

1087

.Case(

"aes"

true

)

1088

.Case(

"amx-avx512"

true

)

1089

.Case(

"amx-bf16"

true

)

1090

.Case(

"amx-complex"

true

)

1091

.Case(

"amx-fp16"

true

)

1092

.Case(

"amx-fp8"

true

)

1093

.Case(

"amx-int8"

true

)

1094

.Case(

"amx-movrs"

true

)

1095

.Case(

"amx-tf32"

true

)

1096

.Case(

"amx-tile"

true

)

1097

.Case(

"amx-transpose"

true

)

1098

.Case(

"avx"

true

)

1099

.Case(

"avx10.1-256"

true

)

1100

.Case(

"avx10.1-512"

true

)

1101

.Case(

"avx10.2-256"

true

)

1102

.Case(

"avx10.2-512"

true

)

1103

.Case(

"avx2"

true

)

1104

.Case(

"avx512f"

true

)

1105

.Case(

"avx512cd"

true

)

1106

.Case(

"avx512vpopcntdq"

true

)

1107

.Case(

"avx512vnni"

true

)

1108

.Case(

"avx512bf16"

true

)

1109

.Case(

"avx512fp16"

true

)

1110

.Case(

"avx512dq"

true

)

1111

.Case(

"avx512bitalg"

true

)

1112

.Case(

"avx512bw"

true

)

1113

.Case(

"avx512vl"

true

)

1114

.Case(

"avx512vbmi"

true

)

1115

.Case(

"avx512vbmi2"

true

)

1116

.Case(

"avx512ifma"

true

)

1117

.Case(

"avx512vp2intersect"

true

)

1118

.Case(

"avxifma"

true

)

1119

.Case(

"avxneconvert"

true

)

1120

.Case(

"avxvnni"

true

)

1121

.Case(

"avxvnniint16"

true

)

1122

.Case(

"avxvnniint8"

true

)

1123

.Case(

"bmi"

true

)

1124

.Case(

"bmi2"

true

)

1125

.Case(

"cldemote"

true

)

1126

.Case(

"clflushopt"

true

)

1127

.Case(

"clwb"

true

)

1128

.Case(

"clzero"

true

)

1129

.Case(

"cmpccxadd"

true

)

1130

.Case(

"crc32"

true

)

1131

.Case(

"cx16"

true

)

1132

.Case(

"enqcmd"

true

)

1133

.Case(

"evex512"

true

)

1134

.Case(

"f16c"

true

)

1135

.Case(

"fma"

true

)

1136

.Case(

"fma4"

true

)

1137

.Case(

"fsgsbase"

true

)

1138

.Case(

"fxsr"

true

)

1139

.Case(

"general-regs-only"

true

)

1140

.Case(

"gfni"

true

)

1141

.Case(

"hreset"

true

)

1142

.Case(

"invpcid"

true

)

1143

.Case(

"kl"

true

)

1144

.Case(

"widekl"

true

)

1145

.Case(

"lwp"

true

)

1146

.Case(

"lzcnt"

true

)

1147

.Case(

"mmx"

true

)

1148

.Case(

"movbe"

true

)

1149

.Case(

"movrs"

true

)

1150

.Case(

"movdiri"

true

)

1151

.Case(

"movdir64b"

true

)

1152

.Case(

"mwaitx"

true

)

1153

.Case(

"pclmul"

true

)

1154

.Case(

"pconfig"

true

)

1155

.Case(

"pku"

true

)

1156

.Case(

"popcnt"

true

)

1157

.Case(

"prefer-256-bit"

true

)

1158

.Case(

"prefetchi"

true

)

1159

.Case(

"prfchw"

true

)

1160

.Case(

"ptwrite"

true

)

1161

.Case(

"raoint"

true

)

1162

.Case(

"rdpid"

true

)

1163

.Case(

"rdpru"

true

)

1164

.Case(

"rdrnd"

true

)

1165

.Case(

"rdseed"

true

)

1166

.Case(

"rtm"

true

)

1167

.Case(

"sahf"

true

)

1168

.Case(

"serialize"

true

)

1169

.Case(

"sgx"

true

)

1170

.Case(

"sha"

true

)

1171

.Case(

"sha512"

true

)

1172

.Case(

"shstk"

true

)

1173

.Case(

"sm3"

true

)

1174

.Case(

"sm4"

true

)

1175

.Case(

"sse"

true

)

1176

.Case(

"sse2"

true

)

1177

.Case(

"sse3"

true

)

1178

.Case(

"ssse3"

true

)

1179

.Case(

"sse4"

true

)

1180

.Case(

"sse4.1"

true

)

1181

.Case(

"sse4.2"

true

)

1182

.Case(

"sse4a"

true

)

1183

.Case(

"tbm"

true

)

1184

.Case(

"tsxldtrk"

true

)

1185

.Case(

"uintr"

true

)

1186

.Case(

"usermsr"

true

)

1187

.Case(

"vaes"

true

)

1188

.Case(

"vpclmulqdq"

true

)

1189

.Case(

"wbnoinvd"

true

)

1190

.Case(

"waitpkg"

true

)

1191

.Case(

"x87"

true

)

1192

.Case(

"xop"

true

)

1193

.Case(

"xsave"

true

)

1194

.Case(

"xsavec"

true

)

1195

.Case(

"xsaves"

true

)

1196

.Case(

"xsaveopt"

true

)

1197

.Case(

"egpr"

true

)

1198

.Case(

"push2pop2"

true

)

1199

.Case(

"ppx"

true

)

1200

.Case(

"ndd"

true

)

1201

.Case(

"ccmp"

true

)

1202

.Case(

"nf"

true

)

1203

.Case(

"cf"

true

)

1204

.Case(

"zu"

true

)

1209 return

llvm::StringSwitch<bool>(Feature)

1210

.Case(

"adx"

, HasADX)

1211

.Case(

"aes"

, HasAES)

1212

.Case(

"amx-avx512"

, HasAMXAVX512)

1213

.Case(

"amx-bf16"

, HasAMXBF16)

1214

.Case(

"amx-complex"

, HasAMXCOMPLEX)

1215

.Case(

"amx-fp16"

, HasAMXFP16)

1216

.Case(

"amx-fp8"

, HasAMXFP8)

1217

.Case(

"amx-int8"

, HasAMXINT8)

1218

.Case(

"amx-movrs"

, HasAMXMOVRS)

1219

.Case(

"amx-tf32"

, HasAMXTF32)

1220

.Case(

"amx-tile"

, HasAMXTILE)

1221

.Case(

"amx-transpose"

, HasAMXTRANSPOSE)

1222

.Case(

"avx"

, SSELevel >= AVX)

1223

.Case(

"avx10.1-256"

, HasAVX10_1)

1224

.Case(

"avx10.1-512"

, HasAVX10_1_512)

1225

.Case(

"avx10.2-256"

, HasAVX10_2)

1226

.Case(

"avx10.2-512"

, HasAVX10_2_512)

1227

.Case(

"avx2"

, SSELevel >= AVX2)

1228

.Case(

"avx512f"

, SSELevel >= AVX512F)

1229

.Case(

"avx512cd"

, HasAVX512CD)

1230

.Case(

"avx512vpopcntdq"

, HasAVX512VPOPCNTDQ)

1231

.Case(

"avx512vnni"

, HasAVX512VNNI)

1232

.Case(

"avx512bf16"

, HasAVX512BF16)

1233

.Case(

"avx512fp16"

, HasAVX512FP16)

1234

.Case(

"avx512dq"

, HasAVX512DQ)

1235

.Case(

"avx512bitalg"

, HasAVX512BITALG)

1236

.Case(

"avx512bw"

, HasAVX512BW)

1237

.Case(

"avx512vl"

, HasAVX512VL)

1238

.Case(

"avx512vbmi"

, HasAVX512VBMI)

1239

.Case(

"avx512vbmi2"

, HasAVX512VBMI2)

1240

.Case(

"avx512ifma"

, HasAVX512IFMA)

1241

.Case(

"avx512vp2intersect"

, HasAVX512VP2INTERSECT)

1242

.Case(

"avxifma"

, HasAVXIFMA)

1243

.Case(

"avxneconvert"

, HasAVXNECONVERT)

1244

.Case(

"avxvnni"

, HasAVXVNNI)

1245

.Case(

"avxvnniint16"

, HasAVXVNNIINT16)

1246

.Case(

"avxvnniint8"

, HasAVXVNNIINT8)

1247

.Case(

"bmi"

, HasBMI)

1248

.Case(

"bmi2"

, HasBMI2)

1249

.Case(

"cldemote"

, HasCLDEMOTE)

1250

.Case(

"clflushopt"

, HasCLFLUSHOPT)

1251

.Case(

"clwb"

, HasCLWB)

1252

.Case(

"clzero"

, HasCLZERO)

1253

.Case(

"cmpccxadd"

, HasCMPCCXADD)

1254

.Case(

"crc32"

, HasCRC32)

1255

.Case(

"cx8"

, HasCX8)

1256

.Case(

"cx16"

, HasCX16)

1257

.Case(

"enqcmd"

, HasENQCMD)

1258

.Case(

"evex512"

, HasEVEX512)

1259

.Case(

"f16c"

, HasF16C)

1260

.Case(

"fma"

, HasFMA)

1261

.Case(

"fma4"

, XOPLevel >= FMA4)

1262

.Case(

"fsgsbase"

, HasFSGSBASE)

1263

.Case(

"fxsr"

, HasFXSR)

1264

.Case(

"gfni"

, HasGFNI)

1265

.Case(

"hreset"

, HasHRESET)

1266

.Case(

"invpcid"

, HasINVPCID)

1267

.Case(

"kl"

, HasKL)

1268

.Case(

"widekl"

, HasWIDEKL)

1269

.Case(

"lwp"

, HasLWP)

1270

.Case(

"lzcnt"

, HasLZCNT)

1271

.Case(

"mmx"

, HasMMX)

1272

.Case(

"movbe"

, HasMOVBE)

1273

.Case(

"movrs"

, HasMOVRS)

1274

.Case(

"movdiri"

, HasMOVDIRI)

1275

.Case(

"movdir64b"

, HasMOVDIR64B)

1276

.Case(

"mwaitx"

, HasMWAITX)

1277

.Case(

"pclmul"

, HasPCLMUL)

1278

.Case(

"pconfig"

, HasPCONFIG)

1279

.Case(

"pku"

, HasPKU)

1280

.Case(

"popcnt"

, HasPOPCNT)

1281

.Case(

"prefetchi"

, HasPREFETCHI)

1282

.Case(

"prfchw"

, HasPRFCHW)

1283

.Case(

"ptwrite"

, HasPTWRITE)

1284

.Case(

"raoint"

, HasRAOINT)

1285

.Case(

"rdpid"

, HasRDPID)

1286

.Case(

"rdpru"

, HasRDPRU)

1287

.Case(

"rdrnd"

, HasRDRND)

1288

.Case(

"rdseed"

, HasRDSEED)

1289

.Case(

"retpoline-external-thunk"

, HasRetpolineExternalThunk)

1290

.Case(

"rtm"

, HasRTM)

1291

.Case(

"sahf"

, HasLAHFSAHF)

1292

.Case(

"serialize"

, HasSERIALIZE)

1293

.Case(

"sgx"

, HasSGX)

1294

.Case(

"sha"

, HasSHA)

1295

.Case(

"sha512"

, HasSHA512)

1296

.Case(

"shstk"

, HasSHSTK)

1297

.Case(

"sm3"

, HasSM3)

1298

.Case(

"sm4"

, HasSM4)

1299

.Case(

"sse"

, SSELevel >= SSE1)

1300

.Case(

"sse2"

, SSELevel >= SSE2)

1301

.Case(

"sse3"

, SSELevel >= SSE3)

1302

.Case(

"ssse3"

, SSELevel >= SSSE3)

1303

.Case(

"sse4.1"

, SSELevel >= SSE41)

1304

.Case(

"sse4.2"

, SSELevel >= SSE42)

1305

.Case(

"sse4a"

, XOPLevel >= SSE4A)

1306

.Case(

"tbm"

, HasTBM)

1307

.Case(

"tsxldtrk"

, HasTSXLDTRK)

1308

.Case(

"uintr"

, HasUINTR)

1309

.Case(

"usermsr"

, HasUSERMSR)

1310

.Case(

"vaes"

, HasVAES)

1311

.Case(

"vpclmulqdq"

, HasVPCLMULQDQ)

1312

.Case(

"wbnoinvd"

, HasWBNOINVD)

1313

.Case(

"waitpkg"

, HasWAITPKG)

1314

.Case(

"x86"

true

)

1315

.Case(

"x86_32"

getTriple

().getArch() == llvm::Triple::x86)

1316

.Case(

"x86_64"

getTriple

().getArch() == llvm::Triple::x86_64)

1317

.Case(

"x87"

, HasX87)

1318

.Case(

"xop"

, XOPLevel >= XOP)

1319

.Case(

"xsave"

, HasXSAVE)

1320

.Case(

"xsavec"

, HasXSAVEC)

1321

.Case(

"xsaves"

, HasXSAVES)

1322

.Case(

"xsaveopt"

, HasXSAVEOPT)

1324

.Case(

"egpr"

, HasEGPR)

1325

.Case(

"push2pop2"

, HasPush2Pop2)

1326

.Case(

"ppx"

, HasPPX)

1327

.Case(

"ndd"

, HasNDD)

1328

.Case(

"ccmp"

, HasCCMP)

1329

.Case(

"nf"

, HasNF)

1330

.Case(

"cf"

, HasCF)

1331

.Case(

"zu"

, HasZU)

1332

.Case(

"branch-hint"

, HasBranchHint)

1342 return

llvm::StringSwitch<bool>(FeatureStr)

1343#define X86_FEATURE_COMPAT(ENUM, STR, PRIORITY) .Case(STR, true) 1344#define X86_MICROARCH_LEVEL(ENUM, STR, PRIORITY) .Case(STR, true) 1345#include "llvm/TargetParser/X86TargetParser.def" 1350 return

llvm::StringSwitch<llvm::X86::ProcessorFeatures>(Name)

1351#define X86_FEATURE_COMPAT(ENUM, STR, PRIORITY) \ 1352 .Case(STR, llvm::X86::FEATURE_##ENUM) 1354#include "llvm/TargetParser/X86TargetParser.def" 1361 auto

getPriority = [](StringRef Feature) -> uint64_t {

1364 using namespace

llvm::X86;

1365

CPUKind Kind = parseArchX86(Feature);

1366 if

(Kind != CK_None) {

1367

ProcessorFeatures KeyFeature = getKeyFeature(Kind);

1368 return

(getFeaturePriority(KeyFeature) << 1) + 1;

1372 return

getFeaturePriority(

getFeature

(Feature)) << 1;

1376 for

(StringRef Feature : Features)

1377 if

(!Feature.empty())

1383 return

llvm::X86::validateCPUSpecificCPUDispatch(Name);

1387 return

llvm::X86::getCPUDispatchMangling(Name);

1393

llvm::X86::getFeaturesForCPU(Name, TargetCPUFeatures,

true

);

1394 for

(

auto

&F : TargetCPUFeatures)

1395

Features.push_back(F);

1403 return

llvm::StringSwitch<bool>(FeatureStr)

1404#define X86_VENDOR(ENUM, STRING) .Case(STRING, true) 1405#define X86_CPU_TYPE_ALIAS(ENUM, ALIAS) .Case(ALIAS, true) 1406#define X86_CPU_TYPE(ENUM, STR) .Case(STR, true) 1407#define X86_CPU_SUBTYPE_ALIAS(ENUM, ALIAS) .Case(ALIAS, true) 1408#define X86_CPU_SUBTYPE(ENUM, STR) .Case(STR, true) 1409#include "llvm/TargetParser/X86TargetParser.def" 1414 auto

RV = llvm::StringSwitch<unsigned>(Name)

1427

.Case(

"@ccnae"

, 6)

1429

.Case(

"@ccnbe"

, 6)

1434

.Case(

"@ccnge"

, 6)

1436

.Case(

"@ccnle"

, 6)

1582 using namespace

llvm::X86;

1622 case

CK_GoldmontPlus:

1627 case

CK_SandyBridge:

1631 case

CK_SkylakeClient:

1632 case

CK_SkylakeServer:

1633 case

CK_Cascadelake:

1638 case

CK_SapphireRapids:

1639 case

CK_IcelakeClient:

1641 case

CK_IcelakeServer:

1648 case

CK_Pantherlake:

1649 case

CK_Sierraforest:

1651 case

CK_Graniterapids:

1652 case

CK_GraniterapidsD:

1653 case

CK_Emeraldrapids:

1654 case

CK_Clearwaterforest:

1655 case

CK_Diamondrapids:

1692 return

std::nullopt;

1694

llvm_unreachable(

"Unknown CPU kind"

);

1698

StringRef Constraint,

1699 unsigned

Size)

const

{

1701

Constraint = Constraint.ltrim(

"=+&"

);

1707

StringRef Constraint,

1708 unsigned

Size)

const

{

1713

StringRef Constraint,

1714 unsigned

Size)

const

{

1715 switch

(Constraint[0]) {

1728 switch

(Constraint[1]) {

1740 return

Size <= 512U;

1743 return

Size <= 256U;

1745 return

Size <= 128U;

1751 if

(SSELevel < SSE2)

1762 return

Size <= 512U;

1765 return

Size <= 256U;

1766 return

Size <= 128U;

1774 switch

(*Constraint) {

1777

std::string Converted =

"{"

+ std::string(Constraint, Len) +

"}"

;

1778

Constraint += Len - 1;

1781 return

std::string(1, *Constraint);

1783 return

std::string(

"{ax}"

);

1785 return

std::string(

"{bx}"

);

1787 return

std::string(

"{cx}"

);

1789 return

std::string(

"{dx}"

);

1791 return

std::string(

"{si}"

);

1793 return

std::string(

"{di}"

);

1795 return

std::string(

"p"

);

1797 return

std::string(

"{st}"

);

1799 return

std::string(

"{st(1)}"

);

1801

assert(Constraint[1] ==

's'

);

1802 return '^'

+ std::string(Constraint++, 2);

1804 switch

(Constraint[1]) {

1819 return

std::string(

"^"

) + std::string(Constraint++, 2);

1823 switch

(Constraint[1]) {

1834 return

std::string(

"^"

) + std::string(Constraint++, 2);

1838 return

std::string(1, *Constraint);

1843 bool

Only64Bit =

getTriple

().getArch() != llvm::Triple::x86;

1844

llvm::X86::fillValidCPUArchList(Values, Only64Bit);

1848

llvm::X86::fillValidTuneCPUList(Values);

Defines the Diagnostic-related interfaces.

static unsigned matchAsmCCConstraint(const char *Name)

static llvm::X86::ProcessorFeatures getFeature(StringRef Name)

Defines enum values for all the target-independent builtin functions.

Enumerates target-specific builtins in their own namespaces within namespace clang.

Concrete class used by the front-end to report problems and issues.

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

TargetOptions & getTargetOpts() const

Retrieve the target options.

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

virtual bool hasFeatureEnabled(const llvm::StringMap< bool > &Features, StringRef Name) const

Check if target has a given feature enabled.

virtual bool initFeatureMap(llvm::StringMap< bool > &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector< std::string > &FeatureVec) const

Initialize the map with the default set of target features for the CPU this should include all legal ...

enum clang::targets::X86TargetInfo::FPMathKind FPMath

bool handleTargetFeatures(std::vector< std::string > &Features, DiagnosticsEngine &Diags) override

handleTargetFeatures - Perform initialization based on the user configured set of features.

std::optional< unsigned > getCPUCacheLineSize() const override

bool validateAsmConstraint(const char *&Name, TargetInfo::ConstraintInfo &info) const override

bool setFPMath(StringRef Name) override

Use the specified unit for FP math.

ArrayRef< const char * > getGCCRegNames() const override

char CPUSpecificManglingCharacter(StringRef Name) const override

std::string convertConstraint(const char *&Constraint) const override

void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override

X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro definitions for this parti...

bool initFeatureMap(llvm::StringMap< bool > &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector< std::string > &FeaturesVec) const override

Initialize the map with the default set of target features for the CPU this should include all legal ...

void getCPUSpecificCPUDispatchFeatures(StringRef Name, llvm::SmallVectorImpl< StringRef > &Features) const override

bool validateCpuIs(StringRef FeatureStr) const override

bool validateOutputSize(const llvm::StringMap< bool > &FeatureMap, StringRef Constraint, unsigned Size) const override

virtual bool validateOperandSize(const llvm::StringMap< bool > &FeatureMap, StringRef Constraint, unsigned Size) const

void fillValidTuneCPUList(SmallVectorImpl< StringRef > &Values) const override

Fill a SmallVectorImpl with the valid values for tuning CPU.

bool validateCPUSpecificCPUDispatch(StringRef Name) const override

bool validateCpuSupports(StringRef FeatureStr) const override

bool isValidFeatureName(StringRef Name) const override

Determine whether this TargetInfo supports the given feature.

bool hasFeature(StringRef Feature) const final

Determine whether the given target has the given feature.

void setFeatureEnabled(llvm::StringMap< bool > &Features, StringRef Name, bool Enabled) const final

Enable or disable a specific target feature; the feature name must be valid.

void fillValidCPUList(SmallVectorImpl< StringRef > &Values) const override

Fill a SmallVectorImpl with the valid values to setCPU.

ArrayRef< TargetInfo::AddlRegName > getGCCAddlRegNames() const override

uint64_t getFMVPriority(ArrayRef< StringRef > Features) const override

bool validateInputSize(const llvm::StringMap< bool > &FeatureMap, StringRef Constraint, unsigned Size) const override

ArrayRef< Builtin::Info > getTargetBuiltins() const override

Return information about target-specific builtins for the current primary target, and info about whic...

ArrayRef< Builtin::Info > getTargetBuiltins() const override

Return information about target-specific builtins for the current primary target, and info about whic...

LLVM_LIBRARY_VISIBILITY void defineCPUMacros(clang::MacroBuilder &Builder, llvm::StringRef CPUName, bool Tuning=true)

static constexpr Builtin::Info BuiltinInfoX86[]

const TargetInfo::AddlRegName AddlRegNames[]

static const char *const GCCRegNames[]

LLVM_LIBRARY_VISIBILITY void DefineStd(clang::MacroBuilder &Builder, llvm::StringRef MacroName, const clang::LangOptions &Opts)

Define a macro name and standard variants.

The JSON file list parser is used to communicate input to InstallAPI.

std::string ConstraintStr

void setRequiresImmediate(int Min, int Max)

const llvm::fltSemantics * LongDoubleFormat

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4