Targets.cpp Source File (original) (raw)

46#include "llvm/ADT/StringExtras.h"

47#include "llvm/TargetParser/Triple.h"

49using namespace clang;

52namespace targets {

62 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");

66 if (Opts.GNUMode)

67 Builder.defineMacro(MacroName);

70 Builder.defineMacro("__" + MacroName);

73 Builder.defineMacro("__" + MacroName + "__");

74}

77 Builder.defineMacro("__" + CPUName);

78 Builder.defineMacro("__" + CPUName + "__");

79 if (Tuning)

80 Builder.defineMacro("__tune_" + CPUName + "__");

81}

88 if (Opts.DeclSpecKeyword)

89 Builder.defineMacro("__declspec", "__declspec");

90 else

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__((__";

100 GCCSpelling += CC;

101 GCCSpelling += "__))";

102 Builder.defineMacro(Twine("_") + CC, GCCSpelling);

103 Builder.defineMacro(Twine("__") + CC, GCCSpelling);

104 }

105 }

106}

107

108

109

110

111

112std::unique_ptr AllocateTarget(const llvm::Triple &Triple,

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

115

116 switch (Triple.getArch()) {

117 default:

118 return nullptr;

119

120 case llvm::Triple::arc:

121 return std::make_unique(Triple, Opts);

122

123 case llvm::Triple::xcore:

124 return std::make_unique(Triple, Opts);

125

126 case llvm::Triple::hexagon:

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

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

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

130 return std::make_unique(Triple, Opts);

131

132 case llvm::Triple::lanai:

133 return std::make_unique(Triple, Opts);

134

135 case llvm::Triple::aarch64_32:

136 if (Triple.isOSDarwin())

137 return std::make_unique(Triple, Opts);

138 else if (Triple.isAppleMachO())

139 return std::make_unique(Triple, Opts);

140

141 return nullptr;

142 case llvm::Triple::aarch64:

143 if (Triple.isOSDarwin())

144 return std::make_unique(Triple, Opts);

145 else if (Triple.isAppleMachO())

146 return std::make_unique(Triple, Opts);

147

148 switch (os) {

149 case llvm::Triple::FreeBSD:

150 return std::make_unique<FreeBSDTargetInfo>(Triple,

151 Opts);

152 case llvm::Triple::Fuchsia:

153 return std::make_unique<FuchsiaTargetInfo>(Triple,

154 Opts);

155 case llvm::Triple::Haiku:

156 return std::make_unique<HaikuTargetInfo>(Triple,

157 Opts);

158 case llvm::Triple::Linux:

159 switch (Triple.getEnvironment()) {

160 default:

161 return std::make_unique<LinuxTargetInfo>(Triple,

162 Opts);

163 case llvm::Triple::OpenHOS:

164 return std::make_unique<OHOSTargetInfo>(Triple,

165 Opts);

166 }

167 case llvm::Triple::NetBSD:

168 return std::make_unique<NetBSDTargetInfo>(Triple,

169 Opts);

170 case llvm::Triple::OpenBSD:

171 return std::make_unique<OpenBSDTargetInfo>(Triple,

172 Opts);

173 case llvm::Triple::Win32:

174 switch (Triple.getEnvironment()) {

175 case llvm::Triple::GNU:

176 return std::make_unique(Triple, Opts);

177 case llvm::Triple::MSVC:

178 default:

179 return std::make_unique(Triple, Opts);

180 }

181 default:

182 return std::make_unique(Triple, Opts);

183 }

184

185 case llvm::Triple::aarch64_be:

186 switch (os) {

187 case llvm::Triple::FreeBSD:

188 return std::make_unique<FreeBSDTargetInfo>(Triple,

189 Opts);

190 case llvm::Triple::Fuchsia:

191 return std::make_unique<FuchsiaTargetInfo>(Triple,

192 Opts);

193 case llvm::Triple::Linux:

194 return std::make_unique<LinuxTargetInfo>(Triple,

195 Opts);

196 case llvm::Triple::NetBSD:

197 return std::make_unique<NetBSDTargetInfo>(Triple,

198 Opts);

199 default:

200 return std::make_unique(Triple, Opts);

201 }

202

203 case llvm::Triple::arm:

204 case llvm::Triple::thumb:

205 if (Triple.isOSBinFormatMachO())

206 return std::make_unique(Triple, Opts);

207

208 switch (os) {

209 case llvm::Triple::Linux:

210 switch (Triple.getEnvironment()) {

211 default:

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

213 case llvm::Triple::OpenHOS:

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

215 }

216 case llvm::Triple::LiteOS:

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

218 case llvm::Triple::FreeBSD:

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

220 case llvm::Triple::NetBSD:

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

222 case llvm::Triple::OpenBSD:

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

224 case llvm::Triple::RTEMS:

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

226 case llvm::Triple::Haiku:

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

228 case llvm::Triple::NaCl:

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

230 case llvm::Triple::Win32:

231 switch (Triple.getEnvironment()) {

232 case llvm::Triple::Cygnus:

233 return std::make_unique(Triple, Opts);

234 case llvm::Triple::GNU:

235 return std::make_unique(Triple, Opts);

236 case llvm::Triple::Itanium:

237 return std::make_unique(Triple, Opts);

238 case llvm::Triple::MSVC:

239 default:

240 return std::make_unique(Triple, Opts);

241 }

242 default:

243 return std::make_unique(Triple, Opts);

244 }

245

246 case llvm::Triple::armeb:

247 case llvm::Triple::thumbeb:

248 if (Triple.isOSDarwin())

249 return std::make_unique(Triple, Opts);

250 else if (Triple.isAppleMachO())

251 return std::make_unique(Triple, Opts);

252

253 switch (os) {

254 case llvm::Triple::Linux:

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

256 case llvm::Triple::NetBSD:

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

258 case llvm::Triple::RTEMS:

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

260 case llvm::Triple::NaCl:

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

262 default:

263 return std::make_unique(Triple, Opts);

264 }

265

266 case llvm::Triple::avr:

267 return std::make_unique(Triple, Opts);

268 case llvm::Triple::bpfeb:

269 case llvm::Triple::bpfel:

270 return std::make_unique(Triple, Opts);

271

272 case llvm::Triple::msp430:

273 return std::make_unique(Triple, Opts);

274

275 case llvm::Triple::mips:

276 switch (os) {

277 case llvm::Triple::Linux:

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

279 case llvm::Triple::RTEMS:

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

281 case llvm::Triple::FreeBSD:

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

283 case llvm::Triple::NetBSD:

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

285 default:

286 return std::make_unique(Triple, Opts);

287 }

288

289 case llvm::Triple::mipsel:

290 switch (os) {

291 case llvm::Triple::Linux:

292 switch (Triple.getEnvironment()) {

293 default:

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

295 case llvm::Triple::OpenHOS:

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

297 }

298 case llvm::Triple::RTEMS:

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

300 case llvm::Triple::FreeBSD:

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

302 case llvm::Triple::NetBSD:

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

304 case llvm::Triple::NaCl:

305 return std::make_unique<NaClTargetInfo>(Triple,

306 Opts);

307 case llvm::Triple::Win32:

308 switch (Triple.getEnvironment()) {

309 case llvm::Triple::GNU:

310 return std::make_unique(Triple, Opts);

311 case llvm::Triple::MSVC:

312 default:

313 return std::make_unique(Triple, Opts);

314 }

315 default:

316 return std::make_unique(Triple, Opts);

317 }

318

319 case llvm::Triple::mips64:

320 switch (os) {

321 case llvm::Triple::Linux:

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

323 case llvm::Triple::RTEMS:

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

325 case llvm::Triple::FreeBSD:

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

327 case llvm::Triple::NetBSD:

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

329 case llvm::Triple::OpenBSD:

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

331 default:

332 return std::make_unique(Triple, Opts);

333 }

334

335 case llvm::Triple::mips64el:

336 switch (os) {

337 case llvm::Triple::Linux:

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

339 case llvm::Triple::RTEMS:

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

341 case llvm::Triple::FreeBSD:

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

343 case llvm::Triple::NetBSD:

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

345 case llvm::Triple::OpenBSD:

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

347 default:

348 return std::make_unique(Triple, Opts);

349 }

350

351 case llvm::Triple::m68k:

352 switch (os) {

353 case llvm::Triple::Linux:

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

355 case llvm::Triple::NetBSD:

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

357 default:

358 return std::make_unique(Triple, Opts);

359 }

360

361 case llvm::Triple::ppc:

362 switch (os) {

363 case llvm::Triple::Linux:

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

365 case llvm::Triple::FreeBSD:

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

367 case llvm::Triple::NetBSD:

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

369 case llvm::Triple::OpenBSD:

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

371 case llvm::Triple::RTEMS:

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

373 case llvm::Triple::AIX:

374 return std::make_unique(Triple, Opts);

375 default:

376 return std::make_unique(Triple, Opts);

377 }

378

379 case llvm::Triple::ppcle:

380 switch (os) {

381 case llvm::Triple::Linux:

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

383 case llvm::Triple::FreeBSD:

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

385 default:

386 return std::make_unique(Triple, Opts);

387 }

388

389 case llvm::Triple::ppc64:

390 switch (os) {

391 case llvm::Triple::Linux:

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

393 case llvm::Triple::Lv2:

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

395 case llvm::Triple::FreeBSD:

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

397 case llvm::Triple::NetBSD:

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

399 case llvm::Triple::OpenBSD:

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

401 case llvm::Triple::AIX:

402 return std::make_unique(Triple, Opts);

403 default:

404 return std::make_unique(Triple, Opts);

405 }

406

407 case llvm::Triple::ppc64le:

408 switch (os) {

409 case llvm::Triple::Linux:

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

411 case llvm::Triple::FreeBSD:

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

413 case llvm::Triple::NetBSD:

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

415 case llvm::Triple::OpenBSD:

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

417 default:

418 return std::make_unique(Triple, Opts);

419 }

420

421 case llvm::Triple::nvptx:

422 return std::make_unique(Triple, Opts,

423 32);

424 case llvm::Triple::nvptx64:

425 return std::make_unique(Triple, Opts,

426 64);

427

428 case llvm::Triple::amdgcn:

429 case llvm::Triple::r600:

430 return std::make_unique(Triple, Opts);

431

432 case llvm::Triple::riscv32:

433 switch (os) {

434 case llvm::Triple::NetBSD:

435 return std::make_unique<NetBSDTargetInfo>(Triple,

436 Opts);

437 case llvm::Triple::Linux:

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

439 default:

440 return std::make_unique(Triple, Opts);

441 }

442

443 case llvm::Triple::riscv64:

444 switch (os) {

445 case llvm::Triple::FreeBSD:

446 return std::make_unique<FreeBSDTargetInfo>(Triple,

447 Opts);

448 case llvm::Triple::NetBSD:

449 return std::make_unique<NetBSDTargetInfo>(Triple,

450 Opts);

451 case llvm::Triple::OpenBSD:

452 return std::make_unique<OpenBSDTargetInfo>(Triple,

453 Opts);

454 case llvm::Triple::Fuchsia:

455 return std::make_unique<FuchsiaTargetInfo>(Triple,

456 Opts);

457 case llvm::Triple::Haiku:

458 return std::make_unique<HaikuTargetInfo>(Triple,

459 Opts);

460 case llvm::Triple::Linux:

461 switch (Triple.getEnvironment()) {

462 default:

463 return std::make_unique<LinuxTargetInfo>(Triple,

464 Opts);

465 case llvm::Triple::OpenHOS:

466 return std::make_unique<OHOSTargetInfo>(Triple,

467 Opts);

468 }

469 default:

470 return std::make_unique(Triple, Opts);

471 }

472

473 case llvm::Triple::sparc:

474 switch (os) {

475 case llvm::Triple::Linux:

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

477 case llvm::Triple::Solaris:

478 return std::make_unique<SolarisTargetInfo>(Triple,

479 Opts);

480 case llvm::Triple::NetBSD:

481 return std::make_unique<NetBSDTargetInfo>(Triple,

482 Opts);

483 case llvm::Triple::RTEMS:

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

485 default:

486 return std::make_unique(Triple, Opts);

487 }

488

489 case llvm::Triple::sparcel:

490 switch (os) {

491 case llvm::Triple::Linux:

492 return std::make_unique<LinuxTargetInfo>(Triple,

493 Opts);

494 case llvm::Triple::RTEMS:

495 return std::make_unique<RTEMSTargetInfo>(Triple,

496 Opts);

497 default:

498 return std::make_unique(Triple, Opts);

499 }

500

501 case llvm::Triple::sparcv9:

502 switch (os) {

503 case llvm::Triple::Linux:

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

505 case llvm::Triple::Solaris:

506 return std::make_unique<SolarisTargetInfo>(Triple,

507 Opts);

508 case llvm::Triple::NetBSD:

509 return std::make_unique<NetBSDTargetInfo>(Triple,

510 Opts);

511 case llvm::Triple::OpenBSD:

512 return std::make_unique<OpenBSDTargetInfo>(Triple,

513 Opts);

514 case llvm::Triple::FreeBSD:

515 return std::make_unique<FreeBSDTargetInfo>(Triple,

516 Opts);

517 default:

518 return std::make_unique(Triple, Opts);

519 }

520

521 case llvm::Triple::systemz:

522 switch (os) {

523 case llvm::Triple::Linux:

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

525 case llvm::Triple::ZOS:

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

527 default:

528 return std::make_unique(Triple, Opts);

529 }

530

531 case llvm::Triple::tce:

532 return std::make_unique(Triple, Opts);

533

534 case llvm::Triple::tcele:

535 return std::make_unique(Triple, Opts);

536

537 case llvm::Triple::x86:

538 if (Triple.isOSDarwin())

539 return std::make_unique(Triple, Opts);

540 else if (Triple.isAppleMachO())

541 return std::make_unique(Triple, Opts);

542

543 switch (os) {

544 case llvm::Triple::Linux: {

545 switch (Triple.getEnvironment()) {

546 default:

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

548 Opts);

549 case llvm::Triple::Android:

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

551 }

552 }

553 case llvm::Triple::DragonFly:

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

555 Opts);

556 case llvm::Triple::NetBSD:

557 return std::make_unique(Triple, Opts);

558 case llvm::Triple::OpenBSD:

559 return std::make_unique(Triple, Opts);

560 case llvm::Triple::FreeBSD:

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

562 Opts);

563 case llvm::Triple::Fuchsia:

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

565 Opts);

566 case llvm::Triple::KFreeBSD:

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

568 Opts);

569 case llvm::Triple::Solaris:

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

571 Opts);

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:

580 default:

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

582 }

583 }

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

594 default:

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

596 }

597

598 case llvm::Triple::x86_64:

599 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())

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

601

602 switch (os) {

603 case llvm::Triple::Linux: {

604 switch (Triple.getEnvironment()) {

605 default:

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

607 Opts);

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

612 }

613 }

614 case llvm::Triple::DragonFly:

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

616 Opts);

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,

623 Opts);

624 case llvm::Triple::Fuchsia:

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

626 Opts);

627 case llvm::Triple::KFreeBSD:

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

629 Opts);

630 case llvm::Triple::Solaris:

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

632 Opts);

633 case llvm::Triple::UEFI:

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

635

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:

643 default:

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

645 }

646 }

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

657 default:

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

659 }

660

661 case llvm::Triple::spir: {

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

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

664 return nullptr;

665 return std::make_unique(Triple, Opts);

666 }

667 case llvm::Triple::spir64: {

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

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

670 return nullptr;

671 return std::make_unique(Triple, Opts);

672 }

673 case llvm::Triple::spirv: {

674 return std::make_unique(Triple, Opts);

675 }

676 case llvm::Triple::spirv32: {

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

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

679 return nullptr;

680 return std::make_unique(Triple, Opts);

681 }

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(Triple, Opts);

687 return nullptr;

688 }

689 return std::make_unique(Triple, Opts);

690 }

691 case llvm::Triple::wasm32:

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

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

694 !Triple.isOSBinFormatWasm())

695 return nullptr;

696 switch (os) {

697 case llvm::Triple::WASI:

698 return std::make_unique<WASITargetInfo>(Triple,

699 Opts);

700 case llvm::Triple::Emscripten:

701 return std::make_unique<EmscriptenTargetInfo>(

702 Triple, Opts);

703 case llvm::Triple::UnknownOS:

704 return std::make_unique<WebAssemblyOSTargetInfo>(

705 Triple, Opts);

706 default:

707 return nullptr;

708 }

709 case llvm::Triple::wasm64:

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

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

712 !Triple.isOSBinFormatWasm())

713 return nullptr;

714 switch (os) {

715 case llvm::Triple::WASI:

716 return std::make_unique<WASITargetInfo>(Triple,

717 Opts);

718 case llvm::Triple::Emscripten:

719 return std::make_unique<EmscriptenTargetInfo>(

720 Triple, Opts);

721 case llvm::Triple::UnknownOS:

722 return std::make_unique<WebAssemblyOSTargetInfo>(

723 Triple, Opts);

724 default:

725 return nullptr;

726 }

727

728 case llvm::Triple::dxil:

729 return std::make_unique(Triple, Opts);

730

731 case llvm::Triple::ve:

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

733

734 case llvm::Triple::csky:

735 switch (os) {

736 case llvm::Triple::Linux:

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

738 default:

739 return std::make_unique(Triple, Opts);

740 }

741 case llvm::Triple::loongarch32:

742 switch (os) {

743 case llvm::Triple::Linux:

744 return std::make_unique<LinuxTargetInfo>(Triple,

745 Opts);

746 default:

747 return std::make_unique(Triple, Opts);

748 }

749 case llvm::Triple::loongarch64:

750 switch (os) {

751 case llvm::Triple::Linux:

752 return std::make_unique<LinuxTargetInfo>(Triple,

753 Opts);

754 case llvm::Triple::FreeBSD:

755 return std::make_unique<FreeBSDTargetInfo>(Triple,

756 Opts);

757 default:

758 return std::make_unique(Triple, Opts);

759 }

760

761 case llvm::Triple::xtensa:

762 return std::make_unique(Triple, Opts);

763 }

764}

765}

766}

767

769

770

773 const std::shared_ptr &Opts) {

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

775

776

779 Diags.Report(diag::err_target_unknown_triple) << Triple.str();

780 return nullptr;

781 }

782 Target->TargetOpts = Opts;

783

784

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, ", ");

791 return nullptr;

792 }

793

794

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, ", ");

802 return nullptr;

803 }

804

805

806 if (!Opts->ABI.empty() && Target ->setABI(Opts->ABI)) {

807 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;

808 return nullptr;

809 }

810

811

812 if (!Opts->FPMath.empty() && Target ->setFPMath(Opts->FPMath)) {

813 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;

814 return nullptr;

815 }

816

817

818

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;

822 return true;

823 }

824 return false;

825 });

826 if ( Target ->initFeatureMap(Opts->FeatureMap, Diags, Opts->CPU,

827 Opts->FeaturesAsWritten))

828 return nullptr;

829

830

831 Opts->Features.clear();

832 for (const auto &F : Opts->FeatureMap)

833 Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());

834

835

836 llvm::sort(Opts->Features);

837

838 if ( Target ->handleTargetFeatures(Opts->Features, Diags))

839 return nullptr;

840

841 Target->setSupportedOpenCLOpts();

842 Target->setCommandLineOpenCLOpts();

843 Target->setMaxAtomicWidth();

844

845 if (!Opts->DarwinTargetVariantTriple.empty())

846 Target->DarwinTargetVariantTriple =

847 llvm::Triple(Opts->DarwinTargetVariantTriple);

848

849 if ( Target ->validateTarget(Diags))

850 return nullptr;

851

852 Target->CheckFixedPointBits();

853

854 return Target.release();

855}

856

857

861

862 auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) {

865 Diags.Report(diag::warn_opencl_unsupported_core_feature)

866 << Name << Opts.OpenCLCPlusPlus

868 };

869#define OPENCL_GENERIC_EXTENSION(Ext, ...) \

870 diagnoseNotSupportedCore(#Ext, __VA_ARGS__);

871#include "clang/Basic/OpenCLExtensions.def"

872

873

874

876 return true;

877

880}

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.