RetroSearch Browse

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

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

clang: lib/Basic/Targets.cpp Source File

46#include "llvm/ADT/StringExtras.h" 47#include "llvm/TargetParser/Triple.h" 49using namespace clang

;

62

assert(MacroName[0] !=

'_'

"Identifier should be in the user's namespace"

);

67

Builder.defineMacro(MacroName);

70

Builder.defineMacro(

"__"

+ MacroName);

73

Builder.defineMacro(

"__"

+ MacroName +

"__"

);

77

Builder.defineMacro(

"__"

+ CPUName);

78

Builder.defineMacro(

"__"

+ CPUName +

"__"

);

80

Builder.defineMacro(

"__tune_"

+ CPUName +

"__"

);

88 if

(Opts.DeclSpecKeyword)

89

Builder.defineMacro(

"__declspec"

);

91

Builder.defineMacro(

"__declspec(a)"

"__attribute__((a))"

);

93 if

(!Opts.MicrosoftExt) {

97 const char

*CCs[] = {

"cdecl"

"stdcall"

"fastcall"

"thiscall"

"pascal"

};

98 for

(

const char

*CC : CCs) {

99

std::string GCCSpelling =

"__attribute__((__"

;

101

GCCSpelling +=

"__))"

;

102

Builder.defineMacro(Twine(

"_"

) + CC, GCCSpelling);

103

Builder.defineMacro(Twine(

"__"

) + CC, GCCSpelling);

114

llvm::Triple::OSType os = Triple.getOS();

116 switch

(Triple.getArch()) {

120 case

llvm::Triple::arc:

121 return

std::make_unique<ARCTargetInfo>(Triple, Opts);

123 case

llvm::Triple::xcore:

124 return

std::make_unique<XCoreTargetInfo>(Triple, Opts);

126 case

llvm::Triple::hexagon:

127 if

(os == llvm::Triple::Linux &&

128

Triple.getEnvironment() == llvm::Triple::Musl)

129 return

std::make_unique<LinuxTargetInfo<HexagonTargetInfo>>(Triple, Opts);

130 return

std::make_unique<HexagonTargetInfo>(Triple, Opts);

132 case

llvm::Triple::lanai:

133 return

std::make_unique<LanaiTargetInfo>(Triple, Opts);

135 case

llvm::Triple::aarch64_32:

136 if

(Triple.isOSDarwin())

137 return

std::make_unique<DarwinAArch64TargetInfo>(Triple, Opts);

138 else if

(Triple.isAppleMachO())

139 return

std::make_unique<AppleMachOAArch64TargetInfo>(Triple, Opts);

142 case

llvm::Triple::aarch64:

143 if

(Triple.isOSDarwin())

144 return

std::make_unique<DarwinAArch64TargetInfo>(Triple, Opts);

145 else if

(Triple.isAppleMachO())

146 return

std::make_unique<AppleMachOAArch64TargetInfo>(Triple, Opts);

149 case

llvm::Triple::FreeBSD:

150 return

std::make_unique<FreeBSDTargetInfo<AArch64leTargetInfo>>(Triple,

152 case

llvm::Triple::Fuchsia:

153 return

std::make_unique<FuchsiaTargetInfo<AArch64leTargetInfo>>(Triple,

155 case

llvm::Triple::Haiku:

156 return

std::make_unique<HaikuTargetInfo<AArch64leTargetInfo>>(Triple,

158 case

llvm::Triple::Linux:

159 switch

(Triple.getEnvironment()) {

161 return

std::make_unique<LinuxTargetInfo<AArch64leTargetInfo>>(Triple,

163 case

llvm::Triple::OpenHOS:

164 return

std::make_unique<OHOSTargetInfo<AArch64leTargetInfo>>(Triple,

167 case

llvm::Triple::NetBSD:

168 return

std::make_unique<NetBSDTargetInfo<AArch64leTargetInfo>>(Triple,

170 case

llvm::Triple::OpenBSD:

171 return

std::make_unique<OpenBSDTargetInfo<AArch64leTargetInfo>>(Triple,

173 case

llvm::Triple::Win32:

174 switch

(Triple.getEnvironment()) {

175 case

llvm::Triple::GNU:

176 return

std::make_unique<MinGWARM64TargetInfo>(Triple, Opts);

177 case

llvm::Triple::MSVC:

179 return

std::make_unique<MicrosoftARM64TargetInfo>(Triple, Opts);

182 return

std::make_unique<AArch64leTargetInfo>(Triple, Opts);

185 case

llvm::Triple::aarch64_be:

187 case

llvm::Triple::FreeBSD:

188 return

std::make_unique<FreeBSDTargetInfo<AArch64beTargetInfo>>(Triple,

190 case

llvm::Triple::Fuchsia:

191 return

std::make_unique<FuchsiaTargetInfo<AArch64beTargetInfo>>(Triple,

193 case

llvm::Triple::Linux:

194 return

std::make_unique<LinuxTargetInfo<AArch64beTargetInfo>>(Triple,

196 case

llvm::Triple::NetBSD:

197 return

std::make_unique<NetBSDTargetInfo<AArch64beTargetInfo>>(Triple,

200 return

std::make_unique<AArch64beTargetInfo>(Triple, Opts);

203 case

llvm::Triple::arm:

204 case

llvm::Triple::thumb:

205 if

(Triple.isOSBinFormatMachO())

206 return

std::make_unique<DarwinARMTargetInfo>(Triple, Opts);

209 case

llvm::Triple::Linux:

210 switch

(Triple.getEnvironment()) {

212 return

std::make_unique<LinuxTargetInfo<ARMleTargetInfo>>(Triple, Opts);

213 case

llvm::Triple::OpenHOS:

214 return

std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(Triple, Opts);

216 case

llvm::Triple::LiteOS:

217 return

std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(Triple, Opts);

218 case

llvm::Triple::FreeBSD:

219 return

std::make_unique<FreeBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts);

220 case

llvm::Triple::NetBSD:

221 return

std::make_unique<NetBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts);

222 case

llvm::Triple::OpenBSD:

223 return

std::make_unique<OpenBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts);

224 case

llvm::Triple::RTEMS:

225 return

std::make_unique<RTEMSTargetInfo<ARMleTargetInfo>>(Triple, Opts);

226 case

llvm::Triple::Haiku:

227 return

std::make_unique<HaikuTargetInfo<ARMleTargetInfo>>(Triple, Opts);

228 case

llvm::Triple::NaCl:

229 return

std::make_unique<NaClTargetInfo<ARMleTargetInfo>>(Triple, Opts);

230 case

llvm::Triple::Win32:

231 switch

(Triple.getEnvironment()) {

232 case

llvm::Triple::Cygnus:

233 return

std::make_unique<CygwinARMTargetInfo>(Triple, Opts);

234 case

llvm::Triple::GNU:

235 return

std::make_unique<MinGWARMTargetInfo>(Triple, Opts);

236 case

llvm::Triple::Itanium:

237 return

std::make_unique<ItaniumWindowsARMleTargetInfo>(Triple, Opts);

238 case

llvm::Triple::MSVC:

240 return

std::make_unique<MicrosoftARMleTargetInfo>(Triple, Opts);

243 return

std::make_unique<ARMleTargetInfo>(Triple, Opts);

246 case

llvm::Triple::armeb:

247 case

llvm::Triple::thumbeb:

248 if

(Triple.isOSDarwin())

249 return

std::make_unique<DarwinARMTargetInfo>(Triple, Opts);

250 else if

(Triple.isAppleMachO())

251 return

std::make_unique<AppleMachOARMTargetInfo>(Triple, Opts);

254 case

llvm::Triple::Linux:

255 return

std::make_unique<LinuxTargetInfo<ARMbeTargetInfo>>(Triple, Opts);

256 case

llvm::Triple::NetBSD:

257 return

std::make_unique<NetBSDTargetInfo<ARMbeTargetInfo>>(Triple, Opts);

258 case

llvm::Triple::RTEMS:

259 return

std::make_unique<RTEMSTargetInfo<ARMbeTargetInfo>>(Triple, Opts);

260 case

llvm::Triple::NaCl:

261 return

std::make_unique<NaClTargetInfo<ARMbeTargetInfo>>(Triple, Opts);

263 return

std::make_unique<ARMbeTargetInfo>(Triple, Opts);

266 case

llvm::Triple::avr:

267 return

std::make_unique<AVRTargetInfo>(Triple, Opts);

268 case

llvm::Triple::bpfeb:

269 case

llvm::Triple::bpfel:

270 return

std::make_unique<BPFTargetInfo>(Triple, Opts);

272 case

llvm::Triple::msp430:

273 return

std::make_unique<MSP430TargetInfo>(Triple, Opts);

275 case

llvm::Triple::mips:

277 case

llvm::Triple::Linux:

278 return

std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);

279 case

llvm::Triple::RTEMS:

280 return

std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);

281 case

llvm::Triple::FreeBSD:

282 return

std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);

283 case

llvm::Triple::NetBSD:

284 return

std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);

286 return

std::make_unique<MipsTargetInfo>(Triple, Opts);

289 case

llvm::Triple::mipsel:

291 case

llvm::Triple::Linux:

292 switch

(Triple.getEnvironment()) {

294 return

std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);

295 case

llvm::Triple::OpenHOS:

296 return

std::make_unique<OHOSTargetInfo<MipsTargetInfo>>(Triple, Opts);

298 case

llvm::Triple::RTEMS:

299 return

std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);

300 case

llvm::Triple::FreeBSD:

301 return

std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);

302 case

llvm::Triple::NetBSD:

303 return

std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);

304 case

llvm::Triple::NaCl:

305 return

std::make_unique<NaClTargetInfo<NaClMips32TargetInfo>>(Triple,

307 case

llvm::Triple::Win32:

308 switch

(Triple.getEnvironment()) {

309 case

llvm::Triple::GNU:

310 return

std::make_unique<MinGWMipsTargetInfo>(Triple, Opts);

311 case

llvm::Triple::MSVC:

313 return

std::make_unique<MicrosoftMipsTargetInfo>(Triple, Opts);

316 return

std::make_unique<MipsTargetInfo>(Triple, Opts);

319 case

llvm::Triple::mips64:

321 case

llvm::Triple::Linux:

322 return

std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);

323 case

llvm::Triple::RTEMS:

324 return

std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);

325 case

llvm::Triple::FreeBSD:

326 return

std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);

327 case

llvm::Triple::NetBSD:

328 return

std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);

329 case

llvm::Triple::OpenBSD:

330 return

std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);

332 return

std::make_unique<MipsTargetInfo>(Triple, Opts);

335 case

llvm::Triple::mips64el:

337 case

llvm::Triple::Linux:

338 return

std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);

339 case

llvm::Triple::RTEMS:

340 return

std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);

341 case

llvm::Triple::FreeBSD:

342 return

std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);

343 case

llvm::Triple::NetBSD:

344 return

std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);

345 case

llvm::Triple::OpenBSD:

346 return

std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);

348 return

std::make_unique<MipsTargetInfo>(Triple, Opts);

351 case

llvm::Triple::m68k:

353 case

llvm::Triple::Linux:

354 return

std::make_unique<LinuxTargetInfo<M68kTargetInfo>>(Triple, Opts);

355 case

llvm::Triple::NetBSD:

356 return

std::make_unique<NetBSDTargetInfo<M68kTargetInfo>>(Triple, Opts);

358 return

std::make_unique<M68kTargetInfo>(Triple, Opts);

361 case

llvm::Triple::ppc:

363 case

llvm::Triple::Linux:

364 return

std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts);

365 case

llvm::Triple::FreeBSD:

366 return

std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);

367 case

llvm::Triple::NetBSD:

368 return

std::make_unique<NetBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);

369 case

llvm::Triple::OpenBSD:

370 return

std::make_unique<OpenBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);

371 case

llvm::Triple::RTEMS:

372 return

std::make_unique<RTEMSTargetInfo<PPC32TargetInfo>>(Triple, Opts);

373 case

llvm::Triple::AIX:

374 return

std::make_unique<AIXPPC32TargetInfo>(Triple, Opts);

376 return

std::make_unique<PPC32TargetInfo>(Triple, Opts);

379 case

llvm::Triple::ppcle:

381 case

llvm::Triple::Linux:

382 return

std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts);

383 case

llvm::Triple::FreeBSD:

384 return

std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);

386 return

std::make_unique<PPC32TargetInfo>(Triple, Opts);

389 case

llvm::Triple::ppc64:

391 case

llvm::Triple::Linux:

392 return

std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts);

393 case

llvm::Triple::Lv2:

394 return

std::make_unique<PS3PPUTargetInfo<PPC64TargetInfo>>(Triple, Opts);

395 case

llvm::Triple::FreeBSD:

396 return

std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);

397 case

llvm::Triple::NetBSD:

398 return

std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);

399 case

llvm::Triple::OpenBSD:

400 return

std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);

401 case

llvm::Triple::AIX:

402 return

std::make_unique<AIXPPC64TargetInfo>(Triple, Opts);

404 return

std::make_unique<PPC64TargetInfo>(Triple, Opts);

407 case

llvm::Triple::ppc64le:

409 case

llvm::Triple::Linux:

410 return

std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts);

411 case

llvm::Triple::FreeBSD:

412 return

std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);

413 case

llvm::Triple::NetBSD:

414 return

std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);

415 case

llvm::Triple::OpenBSD:

416 return

std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);

418 return

std::make_unique<PPC64TargetInfo>(Triple, Opts);

421 case

llvm::Triple::nvptx:

422 return

std::make_unique<NVPTXTargetInfo>(Triple, Opts,

424 case

llvm::Triple::nvptx64:

425 return

std::make_unique<NVPTXTargetInfo>(Triple, Opts,

428 case

llvm::Triple::amdgcn:

429 case

llvm::Triple::r600:

430 return

std::make_unique<AMDGPUTargetInfo>(Triple, Opts);

432 case

llvm::Triple::riscv32:

434 case

llvm::Triple::NetBSD:

435 return

std::make_unique<NetBSDTargetInfo<RISCV32TargetInfo>>(Triple,

437 case

llvm::Triple::Linux:

438 return

std::make_unique<LinuxTargetInfo<RISCV32TargetInfo>>(Triple, Opts);

440 return

std::make_unique<RISCV32TargetInfo>(Triple, Opts);

443 case

llvm::Triple::riscv64:

445 case

llvm::Triple::FreeBSD:

446 return

std::make_unique<FreeBSDTargetInfo<RISCV64TargetInfo>>(Triple,

448 case

llvm::Triple::NetBSD:

449 return

std::make_unique<NetBSDTargetInfo<RISCV64TargetInfo>>(Triple,

451 case

llvm::Triple::OpenBSD:

452 return

std::make_unique<OpenBSDTargetInfo<RISCV64TargetInfo>>(Triple,

454 case

llvm::Triple::Fuchsia:

455 return

std::make_unique<FuchsiaTargetInfo<RISCV64TargetInfo>>(Triple,

457 case

llvm::Triple::Haiku:

458 return

std::make_unique<HaikuTargetInfo<RISCV64TargetInfo>>(Triple,

460 case

llvm::Triple::Linux:

461 switch

(Triple.getEnvironment()) {

463 return

std::make_unique<LinuxTargetInfo<RISCV64TargetInfo>>(Triple,

465 case

llvm::Triple::OpenHOS:

466 return

std::make_unique<OHOSTargetInfo<RISCV64TargetInfo>>(Triple,

470 return

std::make_unique<RISCV64TargetInfo>(Triple, Opts);

473 case

llvm::Triple::sparc:

475 case

llvm::Triple::Linux:

476 return

std::make_unique<LinuxTargetInfo<SparcV8TargetInfo>>(Triple, Opts);

477 case

llvm::Triple::Solaris:

478 return

std::make_unique<SolarisTargetInfo<SparcV8TargetInfo>>(Triple,

480 case

llvm::Triple::NetBSD:

481 return

std::make_unique<NetBSDTargetInfo<SparcV8TargetInfo>>(Triple,

483 case

llvm::Triple::RTEMS:

484 return

std::make_unique<RTEMSTargetInfo<SparcV8TargetInfo>>(Triple, Opts);

486 return

std::make_unique<SparcV8TargetInfo>(Triple, Opts);

489 case

llvm::Triple::sparcel:

491 case

llvm::Triple::Linux:

492 return

std::make_unique<LinuxTargetInfo<SparcV8elTargetInfo>>(Triple,

494 case

llvm::Triple::RTEMS:

495 return

std::make_unique<RTEMSTargetInfo<SparcV8elTargetInfo>>(Triple,

498 return

std::make_unique<SparcV8elTargetInfo>(Triple, Opts);

501 case

llvm::Triple::sparcv9:

503 case

llvm::Triple::Linux:

504 return

std::make_unique<LinuxTargetInfo<SparcV9TargetInfo>>(Triple, Opts);

505 case

llvm::Triple::Solaris:

506 return

std::make_unique<SolarisTargetInfo<SparcV9TargetInfo>>(Triple,

508 case

llvm::Triple::NetBSD:

509 return

std::make_unique<NetBSDTargetInfo<SparcV9TargetInfo>>(Triple,

511 case

llvm::Triple::OpenBSD:

512 return

std::make_unique<OpenBSDTargetInfo<SparcV9TargetInfo>>(Triple,

514 case

llvm::Triple::FreeBSD:

515 return

std::make_unique<FreeBSDTargetInfo<SparcV9TargetInfo>>(Triple,

518 return

std::make_unique<SparcV9TargetInfo>(Triple, Opts);

521 case

llvm::Triple::systemz:

523 case

llvm::Triple::Linux:

524 return

std::make_unique<LinuxTargetInfo<SystemZTargetInfo>>(Triple, Opts);

525 case

llvm::Triple::ZOS:

526 return

std::make_unique<ZOSTargetInfo<SystemZTargetInfo>>(Triple, Opts);

528 return

std::make_unique<SystemZTargetInfo>(Triple, Opts);

531 case

llvm::Triple::tce:

532 return

std::make_unique<TCETargetInfo>(Triple, Opts);

534 case

llvm::Triple::tcele:

535 return

std::make_unique<TCELETargetInfo>(Triple, Opts);

537 case

llvm::Triple::x86:

538 if

(Triple.isOSDarwin())

539 return

std::make_unique<DarwinI386TargetInfo>(Triple, Opts);

540 else if

(Triple.isAppleMachO())

541 return

std::make_unique<AppleMachOI386TargetInfo>(Triple, Opts);

544 case

llvm::Triple::Linux: {

545 switch

(Triple.getEnvironment()) {

547 return

std::make_unique<LinuxTargetInfo<X86_32TargetInfo>>(Triple,

549 case

llvm::Triple::Android:

550 return

std::make_unique<AndroidX86_32TargetInfo>(Triple, Opts);

553 case

llvm::Triple::DragonFly:

554 return

std::make_unique<DragonFlyBSDTargetInfo<X86_32TargetInfo>>(Triple,

556 case

llvm::Triple::NetBSD:

557 return

std::make_unique<NetBSDI386TargetInfo>(Triple, Opts);

558 case

llvm::Triple::OpenBSD:

559 return

std::make_unique<OpenBSDI386TargetInfo>(Triple, Opts);

560 case

llvm::Triple::FreeBSD:

561 return

std::make_unique<FreeBSDTargetInfo<X86_32TargetInfo>>(Triple,

563 case

llvm::Triple::Fuchsia:

564 return

std::make_unique<FuchsiaTargetInfo<X86_32TargetInfo>>(Triple,

566 case

llvm::Triple::KFreeBSD:

567 return

std::make_unique<KFreeBSDTargetInfo<X86_32TargetInfo>>(Triple,

569 case

llvm::Triple::Solaris:

570 return

std::make_unique<SolarisTargetInfo<X86_32TargetInfo>>(Triple,

572 case

llvm::Triple::Win32: {

573 switch

(Triple.getEnvironment()) {

574 case

llvm::Triple::Cygnus:

575 return

std::make_unique<CygwinX86_32TargetInfo>(Triple, Opts);

576 case

llvm::Triple::GNU:

577 return

std::make_unique<MinGWX86_32TargetInfo>(Triple, Opts);

578 case

llvm::Triple::Itanium:

579 case

llvm::Triple::MSVC:

581 return

std::make_unique<MicrosoftX86_32TargetInfo>(Triple, Opts);

584 case

llvm::Triple::Haiku:

585 return

std::make_unique<HaikuX86_32TargetInfo>(Triple, Opts);

586 case

llvm::Triple::RTEMS:

587 return

std::make_unique<RTEMSX86_32TargetInfo>(Triple, Opts);

588 case

llvm::Triple::NaCl:

589 return

std::make_unique<NaClTargetInfo<X86_32TargetInfo>>(Triple, Opts);

590 case

llvm::Triple::ELFIAMCU:

591 return

std::make_unique<MCUX86_32TargetInfo>(Triple, Opts);

592 case

llvm::Triple::Hurd:

593 return

std::make_unique<HurdTargetInfo<X86_32TargetInfo>>(Triple, Opts);

595 return

std::make_unique<X86_32TargetInfo>(Triple, Opts);

598 case

llvm::Triple::x86_64:

599 if

(Triple.isOSDarwin() || Triple.isOSBinFormatMachO())

600 return

std::make_unique<DarwinX86_64TargetInfo>(Triple, Opts);

603 case

llvm::Triple::Linux: {

604 switch

(Triple.getEnvironment()) {

606 return

std::make_unique<LinuxTargetInfo<X86_64TargetInfo>>(Triple,

608 case

llvm::Triple::Android:

609 return

std::make_unique<AndroidX86_64TargetInfo>(Triple, Opts);

610 case

llvm::Triple::OpenHOS:

611 return

std::make_unique<OHOSX86_64TargetInfo>(Triple, Opts);

614 case

llvm::Triple::DragonFly:

615 return

std::make_unique<DragonFlyBSDTargetInfo<X86_64TargetInfo>>(Triple,

617 case

llvm::Triple::NetBSD:

618 return

std::make_unique<NetBSDTargetInfo<X86_64TargetInfo>>(Triple, Opts);

619 case

llvm::Triple::OpenBSD:

620 return

std::make_unique<OpenBSDX86_64TargetInfo>(Triple, Opts);

621 case

llvm::Triple::FreeBSD:

622 return

std::make_unique<FreeBSDTargetInfo<X86_64TargetInfo>>(Triple,

624 case

llvm::Triple::Fuchsia:

625 return

std::make_unique<FuchsiaTargetInfo<X86_64TargetInfo>>(Triple,

627 case

llvm::Triple::KFreeBSD:

628 return

std::make_unique<KFreeBSDTargetInfo<X86_64TargetInfo>>(Triple,

630 case

llvm::Triple::Solaris:

631 return

std::make_unique<SolarisTargetInfo<X86_64TargetInfo>>(Triple,

633 case

llvm::Triple::UEFI:

634 return

std::make_unique<UEFIX86_64TargetInfo>(Triple, Opts);

636 case

llvm::Triple::Win32: {

637 switch

(Triple.getEnvironment()) {

638 case

llvm::Triple::Cygnus:

639 return

std::make_unique<CygwinX86_64TargetInfo>(Triple, Opts);

640 case

llvm::Triple::GNU:

641 return

std::make_unique<MinGWX86_64TargetInfo>(Triple, Opts);

642 case

llvm::Triple::MSVC:

644 return

std::make_unique<MicrosoftX86_64TargetInfo>(Triple, Opts);

647 case

llvm::Triple::Haiku:

648 return

std::make_unique<HaikuTargetInfo<X86_64TargetInfo>>(Triple, Opts);

649 case

llvm::Triple::NaCl:

650 return

std::make_unique<NaClTargetInfo<X86_64TargetInfo>>(Triple, Opts);

651 case

llvm::Triple::PS4:

652 return

std::make_unique<PS4OSTargetInfo<X86_64TargetInfo>>(Triple, Opts);

653 case

llvm::Triple::PS5:

654 return

std::make_unique<PS5OSTargetInfo<X86_64TargetInfo>>(Triple, Opts);

655 case

llvm::Triple::Hurd:

656 return

std::make_unique<HurdTargetInfo<X86_64TargetInfo>>(Triple, Opts);

658 return

std::make_unique<X86_64TargetInfo>(Triple, Opts);

661 case

llvm::Triple::spir: {

662 if

(os != llvm::Triple::UnknownOS ||

663

Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)

665 return

std::make_unique<SPIR32TargetInfo>(Triple, Opts);

667 case

llvm::Triple::spir64: {

668 if

(os != llvm::Triple::UnknownOS ||

669

Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)

671 return

std::make_unique<SPIR64TargetInfo>(Triple, Opts);

673 case

llvm::Triple::spirv: {

674 return

std::make_unique<SPIRVTargetInfo>(Triple, Opts);

676 case

llvm::Triple::spirv32: {

677 if

(os != llvm::Triple::UnknownOS ||

678

Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)

680 return

std::make_unique<SPIRV32TargetInfo>(Triple, Opts);

682 case

llvm::Triple::spirv64: {

683 if

(os != llvm::Triple::UnknownOS ||

684

Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) {

685 if

(os == llvm::Triple::OSType::AMDHSA)

686 return

std::make_unique<SPIRV64AMDGCNTargetInfo>(Triple, Opts);

689 return

std::make_unique<SPIRV64TargetInfo>(Triple, Opts);

691 case

llvm::Triple::wasm32:

692 if

(Triple.getSubArch() != llvm::Triple::NoSubArch ||

693

Triple.getVendor() != llvm::Triple::UnknownVendor ||

694

!Triple.isOSBinFormatWasm())

697 case

llvm::Triple::WASI:

698 return

std::make_unique<WASITargetInfo<WebAssembly32TargetInfo>>(Triple,

700 case

llvm::Triple::Emscripten:

701 return

std::make_unique<EmscriptenTargetInfo<WebAssembly32TargetInfo>>(

703 case

llvm::Triple::UnknownOS:

704 return

std::make_unique<WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>>(

709 case

llvm::Triple::wasm64:

710 if

(Triple.getSubArch() != llvm::Triple::NoSubArch ||

711

Triple.getVendor() != llvm::Triple::UnknownVendor ||

712

!Triple.isOSBinFormatWasm())

715 case

llvm::Triple::WASI:

716 return

std::make_unique<WASITargetInfo<WebAssembly64TargetInfo>>(Triple,

718 case

llvm::Triple::Emscripten:

719 return

std::make_unique<EmscriptenTargetInfo<WebAssembly64TargetInfo>>(

721 case

llvm::Triple::UnknownOS:

722 return

std::make_unique<WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>>(

728 case

llvm::Triple::dxil:

729 return

std::make_unique<DirectXTargetInfo>(Triple, Opts);

731 case

llvm::Triple::ve:

732 return

std::make_unique<LinuxTargetInfo<VETargetInfo>>(Triple, Opts);

734 case

llvm::Triple::csky:

736 case

llvm::Triple::Linux:

737 return

std::make_unique<LinuxTargetInfo<CSKYTargetInfo>>(Triple, Opts);

739 return

std::make_unique<CSKYTargetInfo>(Triple, Opts);

741 case

llvm::Triple::loongarch32:

743 case

llvm::Triple::Linux:

744 return

std::make_unique<LinuxTargetInfo<LoongArch32TargetInfo>>(Triple,

747 return

std::make_unique<LoongArch32TargetInfo>(Triple, Opts);

749 case

llvm::Triple::loongarch64:

751 case

llvm::Triple::Linux:

752 return

std::make_unique<LinuxTargetInfo<LoongArch64TargetInfo>>(Triple,

754 case

llvm::Triple::FreeBSD:

755 return

std::make_unique<FreeBSDTargetInfo<LoongArch64TargetInfo>>(Triple,

758 return

std::make_unique<LoongArch64TargetInfo>(Triple, Opts);

761 case

llvm::Triple::xtensa:

762 return

std::make_unique<XtensaTargetInfo>(Triple, Opts);

773 const

std::shared_ptr<TargetOptions> &Opts) {

774

llvm::Triple Triple(llvm::Triple::normalize(Opts->Triple));

779

Diags.

Report

(diag::err_target_unknown_triple) << Triple.str();

782 Target

->TargetOpts = Opts;

785 if

(!Opts->CPU.empty() && !

Target

->setCPU(Opts->CPU)) {

786

Diags.

Report

(diag::err_target_unknown_cpu) << Opts->CPU;

788 Target

->fillValidCPUList(ValidList);

789 if

(!ValidList.empty())

790

Diags.

Report

(diag::note_valid_options) << llvm::join(ValidList,

", "

);

795 if

(!Opts->TuneCPU.empty() &&

796

Target

->isValidTuneCPUName(Opts->TuneCPU)) {

797

Diags.

Report

(diag::err_target_unknown_cpu) << Opts->TuneCPU;

799 Target

->fillValidTuneCPUList(ValidList);

800 if

(!ValidList.empty())

801

Diags.

Report

(diag::note_valid_options) << llvm::join(ValidList,

", "

);

806 if

(!Opts->ABI.empty() && !

Target

->setABI(Opts->ABI)) {

807

Diags.

Report

(diag::err_target_unknown_abi) << Opts->ABI;

812 if

(!Opts->FPMath.empty() && !

Target

->setFPMath(Opts->FPMath)) {

813

Diags.

Report

(diag::err_target_unknown_fpmath) << Opts->FPMath;

819

llvm::erase_if(Opts->FeaturesAsWritten, [&](StringRef Name) {

820

if (Target->isReadOnlyFeature(Name.substr(1))) {

821

Diags.Report(diag::warn_fe_backend_readonly_feature_flag) << Name;

826 if

Target

->initFeatureMap(Opts->FeatureMap, Diags, Opts->CPU,

827

Opts->FeaturesAsWritten))

831

Opts->Features.clear();

832 for

(

const auto

&F : Opts->FeatureMap)

833

Opts->Features.push_back((F.getValue() ?

"+"

"-"

) + F.getKey().str());

836

llvm::sort(Opts->Features);

838 if

Target

->handleTargetFeatures(Opts->Features, Diags))

841 Target

->setSupportedOpenCLOpts();

842 Target

->setCommandLineOpenCLOpts();

843 Target

->setMaxAtomicWidth();

845 if

(!Opts->DarwinTargetVariantTriple.empty())

846 Target

->DarwinTargetVariantTriple =

847

llvm::Triple(Opts->DarwinTargetVariantTriple);

849 if

Target

->validateTarget(Diags))

852 Target

->CheckFixedPointBits();

862 auto

diagnoseNotSupportedCore = [&](llvm::StringRef Name,

auto

... OptArgs) {

865

Diags.

Report

(diag::warn_opencl_unsupported_core_feature)

866

<< Name << Opts.OpenCLCPlusPlus

869#define OPENCL_GENERIC_EXTENSION(Ext, ...) \ 870 diagnoseNotSupportedCore(#Ext, __VA_ARGS__); 871#include "clang/Basic/OpenCLExtensions.def"

Defines the Diagnostic-related interfaces.

llvm::MachO::Target Target

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

VersionTuple getOpenCLVersionTuple() const

Return the OpenCL C or C++ version as a VersionTuple.

unsigned getOpenCLCompatibleVersion() const

Return the OpenCL version that kernel language is compatible with.

static bool diagnoseUnsupportedFeatureDependencies(const TargetInfo &TI, DiagnosticsEngine &Diags)

static bool diagnoseFeatureExtensionDifferences(const TargetInfo &TI, DiagnosticsEngine &Diags)

static bool isOpenCLOptionCoreIn(const LangOptions &LO, Args &&... args)

Exposes information about the current target.

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

Check if target has a given feature enabled.

static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)

Construct a target for the given options.

virtual bool validateOpenCLTarget(const LangOptions &Opts, DiagnosticsEngine &Diags) const

Check that OpenCL target has valid options setting based on OpenCL version.

llvm::StringMap< bool > & getSupportedOpenCLOpts()

Get supported OpenCL extensions and optional core features.

Options for controlling the target.

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

LLVM_LIBRARY_VISIBILITY void addCygMingDefines(const clang::LangOptions &Opts, clang::MacroBuilder &Builder)

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

Define a macro name and standard variants.

std::unique_ptr< clang::TargetInfo > AllocateTarget(const llvm::Triple &Triple, const clang::TargetOptions &Opts)

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

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