ToolChain.cpp Source File (original) (raw)

18#include "clang/Config/config.h"

27#include "llvm/ADT/SmallString.h"

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

29#include "llvm/ADT/StringRef.h"

30#include "llvm/ADT/Twine.h"

31#include "llvm/Config/llvm-config.h"

32#include "llvm/MC/MCTargetOptions.h"

33#include "llvm/MC/TargetRegistry.h"

34#include "llvm/Option/Arg.h"

35#include "llvm/Option/ArgList.h"

36#include "llvm/Option/OptTable.h"

37#include "llvm/Option/Option.h"

38#include "llvm/Support/ErrorHandling.h"

39#include "llvm/Support/FileSystem.h"

40#include "llvm/Support/FileUtilities.h"

41#include "llvm/Support/Path.h"

42#include "llvm/Support/Process.h"

43#include "llvm/Support/VersionTuple.h"

44#include "llvm/Support/VirtualFileSystem.h"

45#include "llvm/TargetParser/AArch64TargetParser.h"

46#include "llvm/TargetParser/RISCVISAInfo.h"

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

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

49#include

50#include

51#include

52#include

54using namespace clang;

55using namespace driver;

56using namespace tools;

57using namespace llvm;

61 return Args.getLastArg(options::OPT_mkernel, options::OPT_fapple_kext,

62 options::OPT_fno_rtti, options::OPT_frtti);

63}

66 const llvm::Triple &Triple,

67 const Arg *CachedRTTIArg) {

69 if (CachedRTTIArg) {

70 if (CachedRTTIArg->getOption().matches(options::OPT_frtti))

72 else

74 }

77 bool NoRTTI = Triple.isPS() || Triple.isDriverKit();

79}

82 if (Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,

83 true)) {

85 }

87}

90 const ArgList &Args)

91 : D(D), Triple(T), Args(Args), CachedRTTIArg(GetRTTIArgument(Args)),

94 auto addIfExists = [this](path_list &List, const std::string &Path) {

95 if (getVFS().exists(Path))

96 List.push_back(Path);

97 };

99 if (std::optionalstd::string Path = getRuntimePath())

101 if (std::optionalstd::string Path = getStdlibPath())

105}

106

108 Triple.setEnvironment(Env);

109 if (EffectiveTriple != llvm::Triple())

110 EffectiveTriple.setEnvironment(Env);

111}

112

114

118

120 return Args.hasFlag(options::OPT_fintegrated_as,

121 options::OPT_fno_integrated_as,

123}

124

126 assert(

129 "(Non-)integrated backend set incorrectly!");

130

131 bool IBackend = Args.hasFlag(options::OPT_fintegrated_objemitter,

132 options::OPT_fno_integrated_objemitter,

134

135

136

137 unsigned DiagID;

140 DiagID = clang::diag::err_drv_unsupported_opt_for_target;

141 else

142 DiagID = clang::diag::warn_drv_unsupported_opt_for_target;

143 Arg *A = Args.getLastArg(options::OPT_fno_integrated_objemitter);

145 D.Diag(DiagID) << A->getAsString(Args) << Triple.getTriple();

146 A = Args.getLastArg(options::OPT_fintegrated_objemitter);

148 D.Diag(DiagID) << A->getAsString(Args) << Triple.getTriple();

149

150 return IBackend;

151}

152

154 return ENABLE_X86_RELAX_RELOCATIONS;

155}

156

158 return PPC_LINUX_DEFAULT_IEEELONGDOUBLE && getTriple().isOSLinux();

159}

160

162 const llvm::opt::ArgList &Args) {

163 for (const Arg *MultilibFlagArg :

164 Args.filtered(options::OPT_fmultilib_flag)) {

165 List.push_back(MultilibFlagArg->getAsString(Args));

166 MultilibFlagArg->claim();

167 }

168}

169

171 const llvm::Triple &Triple,

172 const llvm::opt::ArgList &Args,

174 std::vector Features;

176 false,

177 true);

179 llvm::DenseSet FeatureSet(UnifiedFeatures.begin(),

180 UnifiedFeatures.end());

181 std::vectorstd::string MArch;

182 for (const auto &Ext : AArch64::Extensions)

183 if (!Ext.UserVisibleName.empty())

184 if (FeatureSet.contains(Ext.PosTargetFeature))

185 MArch.push_back(Ext.UserVisibleName.str());

186 for (const auto &Ext : AArch64::Extensions)

187 if (!Ext.UserVisibleName.empty())

188 if (FeatureSet.contains(Ext.NegTargetFeature))

189 MArch.push_back(("no" + Ext.UserVisibleName).str());

190 StringRef ArchName;

191 for (const auto &ArchInfo : AArch64::ArchInfos)

192 if (FeatureSet.contains(ArchInfo->ArchFeature))

193 ArchName = ArchInfo->Name;

194 if (!ArchName.empty()) {

195 MArch.insert(MArch.begin(), ("-march=" + ArchName).str());

196 Result.push_back(llvm::join(MArch, "+"));

197 }

198

199 const Arg *BranchProtectionArg =

200 Args.getLastArgNoClaim(options::OPT_mbranch_protection_EQ);

201 if (BranchProtectionArg) {

202 Result.push_back(BranchProtectionArg->getAsString(Args));

203 }

204

205 if (FeatureSet.contains("+strict-align"))

206 Result.push_back("-mno-unaligned-access");

207 else

208 Result.push_back("-munaligned-access");

209

210 if (Arg *Endian = Args.getLastArg(options::OPT_mbig_endian,

211 options::OPT_mlittle_endian)) {

212 if (Endian->getOption().matches(options::OPT_mbig_endian))

213 Result.push_back(Endian->getAsString(Args));

214 }

215

216 const Arg *ABIArg = Args.getLastArgNoClaim(options::OPT_mabi_EQ);

217 if (ABIArg) {

218 Result.push_back(ABIArg->getAsString(Args));

219 }

220

221 if (const Arg *A = Args.getLastArg(options::OPT_O_Group);

222 A && A->getOption().matches(options::OPT_O)) {

223 switch (A->getValue()[0]) {

224 case 's':

225 Result.push_back("-Os");

226 break;

227 case 'z':

228 Result.push_back("-Oz");

229 break;

230 }

231 }

232

234}

235

237 llvm::Reloc::Model RelocationModel,

238 const llvm::opt::ArgList &Args,

240 std::vector Features;

242 D, Triple, Args, Features, false , true );

244 llvm::DenseSet FeatureSet(UnifiedFeatures.begin(),

245 UnifiedFeatures.end());

246 std::vectorstd::string MArch;

247 for (const auto &Ext : ARM::ARCHExtNames)

248 if (!Ext.Name.empty())

249 if (FeatureSet.contains(Ext.Feature))

250 MArch.push_back(Ext.Name.str());

251 for (const auto &Ext : ARM::ARCHExtNames)

252 if (!Ext.Name.empty())

253 if (FeatureSet.contains(Ext.NegFeature))

254 MArch.push_back(("no" + Ext.Name).str());

255 MArch.insert(MArch.begin(), ("-march=" + Triple.getArchName()).str());

256 Result.push_back(llvm::join(MArch, "+"));

257

258 switch (FPUKind) {

259#define ARM_FPU(NAME, KIND, VERSION, NEON_SUPPORT, RESTRICTION) \

260 case llvm::ARM::KIND: \

261 Result.push_back("-mfpu=" NAME); \

262 break;

263#include "llvm/TargetParser/ARMTargetParser.def"

264 default:

265 llvm_unreachable("Invalid FPUKind");

266 }

267

269 case arm::FloatABI::Soft:

270 Result.push_back("-mfloat-abi=soft");

271 break;

272 case arm::FloatABI::SoftFP:

273 Result.push_back("-mfloat-abi=softfp");

274 break;

275 case arm::FloatABI::Hard:

276 Result.push_back("-mfloat-abi=hard");

277 break;

278 case arm::FloatABI::Invalid:

279 llvm_unreachable("Invalid float ABI");

280 }

281

282 if (RelocationModel == llvm::Reloc::ROPI ||

283 RelocationModel == llvm::Reloc::ROPI_RWPI)

284 Result.push_back("-fropi");

285 else

286 Result.push_back("-fno-ropi");

287

288 if (RelocationModel == llvm::Reloc::RWPI ||

289 RelocationModel == llvm::Reloc::ROPI_RWPI)

290 Result.push_back("-frwpi");

291 else

292 Result.push_back("-fno-rwpi");

293

294 const Arg *BranchProtectionArg =

295 Args.getLastArgNoClaim(options::OPT_mbranch_protection_EQ);

296 if (BranchProtectionArg) {

297 Result.push_back(BranchProtectionArg->getAsString(Args));

298 }

299

300 if (FeatureSet.contains("+strict-align"))

301 Result.push_back("-mno-unaligned-access");

302 else

303 Result.push_back("-munaligned-access");

304

305 if (Arg *Endian = Args.getLastArg(options::OPT_mbig_endian,

306 options::OPT_mlittle_endian)) {

307 if (Endian->getOption().matches(options::OPT_mbig_endian))

308 Result.push_back(Endian->getAsString(Args));

309 }

310

311 if (const Arg *A = Args.getLastArg(options::OPT_O_Group);

312 A && A->getOption().matches(options::OPT_O)) {

313 switch (A->getValue()[0]) {

314 case 's':

315 Result.push_back("-Os");

316 break;

317 case 'z':

318 Result.push_back("-Oz");

319 break;

320 }

321 }

322

324}

325

327 const llvm::opt::ArgList &Args,

330

331 auto ISAInfo = llvm::RISCVISAInfo::parseArchString(

332 Arch, true);

333 if (!llvm::errorToBool(ISAInfo.takeError()))

334 Result.push_back("-march=" + (*ISAInfo)->toString());

335

336 Result.push_back(("-mabi=" + riscv::getRISCVABI(Args, Triple)).str());

337}

338

342

343 std::vectorstd::string Result;

345 Result.push_back("--target=" + Triple.str());

346

347

348

349

350

351 llvm::Reloc::Model RelocationModel;

352 unsigned PICLevel;

353 bool IsPIE;

354 {

356 std::tie(RelocationModel, PICLevel, IsPIE) = ParsePICArgs(*this, Args);

357 }

358

359 switch (Triple.getArch()) {

360 case llvm::Triple::aarch64:

361 case llvm::Triple::aarch64_32:

362 case llvm::Triple::aarch64_be:

364 break;

365 case llvm::Triple::arm:

366 case llvm::Triple::armeb:

367 case llvm::Triple::thumb:

368 case llvm::Triple::thumbeb:

370 break;

371 case llvm::Triple::riscv32:

372 case llvm::Triple::riscv64:

374 break;

375 default:

376 break;

377 }

378

379

380

382 Result.push_back("-fno-rtti");

383 else

384 Result.push_back("-frtti");

385

387 Result.push_back("-fno-exceptions");

388 else

389 Result.push_back("-fexceptions");

390

391 if (RelocationModel == llvm::Reloc::PIC_)

392 Result.push_back(IsPIE ? (PICLevel > 1 ? "-fPIE" : "-fpie")

393 : (PICLevel > 1 ? "-fPIC" : "-fpic"));

394 else

395 Result.push_back("-fno-pic");

396

397

401}

402

405 SanitizerArgs SanArgs(*this, JobArgs, !SanitizerArgsChecked);

406 SanitizerArgsChecked = true;

407 return SanArgs;

408}

409

411 XRayArgs XRayArguments(*this, JobArgs);

412 return XRayArguments;

413}

414

415namespace {

416

417struct DriverSuffix {

418 const char *Suffix;

419 const char *ModeFlag;

420};

421

422}

423

424static const DriverSuffix *FindDriverSuffix(StringRef ProgName, size_t &Pos) {

425

426

427

428 static const DriverSuffix DriverSuffixes[] = {

429 {"clang", nullptr},

430 {"clang++", "--driver-mode=g++"},

431 {"clang-c++", "--driver-mode=g++"},

432 {"clang-cc", nullptr},

433 {"clang-cpp", "--driver-mode=cpp"},

434 {"clang-g++", "--driver-mode=g++"},

435 {"clang-gcc", nullptr},

436 {"clang-cl", "--driver-mode=cl"},

437 {"cc", nullptr},

438 {"cpp", "--driver-mode=cpp"},

439 {"cl", "--driver-mode=cl"},

440 {"++", "--driver-mode=g++"},

441 {"flang", "--driver-mode=flang"},

442

443

444 {"flang-new", "--driver-mode=flang"},

445 {"clang-dxc", "--driver-mode=dxc"},

446 };

447

448 for (const auto &DS : DriverSuffixes) {

449 StringRef Suffix(DS.Suffix);

450 if (ProgName.ends_with(Suffix)) {

451 Pos = ProgName.size() - Suffix.size();

452 return &DS;

453 }

454 }

455 return nullptr;

456}

457

458

459

461 std::string ProgName = std::string(llvm::sys::path::filename(Argv0));

462 if (is_style_windows(llvm::sys::path::Style::native)) {

463

464 std::transform(ProgName.begin(), ProgName.end(), ProgName.begin(),

465 ::tolower);

466 }

467 return ProgName;

468}

469

470static const DriverSuffix *parseDriverSuffix(StringRef ProgName, size_t &Pos) {

471

472

473

474

475

476

477

479

480 if (!DS && ProgName.ends_with(".exe")) {

481

482

483 ProgName = ProgName.drop_back(StringRef(".exe").size());

485 }

486

487 if (!DS) {

488

489

490 ProgName = ProgName.rtrim("0123456789.");

492 }

493

494 if (!DS) {

495

496

497 ProgName = ProgName.slice(0, ProgName.rfind('-'));

499 }

500 return DS;

501}

502

506 size_t SuffixPos;

508 if (!DS)

509 return {};

510 size_t SuffixEnd = SuffixPos + strlen(DS->Suffix);

511

512 size_t LastComponent = ProgName.rfind('-', SuffixPos);

513 if (LastComponent == std:🧵:npos)

514 return ParsedClangName(ProgName.substr(0, SuffixEnd), DS->ModeFlag);

515 std::string ModeSuffix = ProgName.substr(LastComponent + 1,

516 SuffixEnd - LastComponent - 1);

517

518

519 StringRef Prefix(ProgName);

520 Prefix = Prefix.slice(0, LastComponent);

521 std::string IgnoredError;

522

523 llvm::Triple Triple(Prefix);

524 bool IsRegistered = llvm::TargetRegistry::lookupTarget(Triple, IgnoredError);

525 return ParsedClangName{std::string(Prefix), ModeSuffix, DS->ModeFlag,

526 IsRegistered};

527}

528

530

531

532

533 switch (Triple.getArch()) {

534 case llvm::Triple::aarch64: {

536 return "arm64e";

537 return "arm64";

538 }

539 case llvm::Triple::aarch64_32:

540 return "arm64_32";

541 case llvm::Triple::ppc:

542 return "ppc";

543 case llvm::Triple::ppcle:

544 return "ppcle";

545 case llvm::Triple::ppc64:

546 return "ppc64";

547 case llvm::Triple::ppc64le:

548 return "ppc64le";

549 default:

550 return Triple.getArchName();

551 }

552}

553

557

562

563Tool *ToolChain::getClang() const {

566 return Clang.get();

567}

568

569Tool *ToolChain::getFlang() const {

572 return Flang.get();

573}

574

578

580 llvm_unreachable("Linking is not supported by this toolchain");

581}

582

584 llvm_unreachable("Creating static lib is not supported by this toolchain");

585}

586

587Tool *ToolChain::getAssemble() const {

588 if (!Assemble)

590 return Assemble.get();

591}

592

593Tool *ToolChain::getClangAs() const {

594 if (!Assemble)

596 return Assemble.get();

597}

598

599Tool *ToolChain::getLink() const {

602 return Link.get();

603}

604

605Tool *ToolChain::getStaticLibTool() const {

606 if (!StaticLibTool)

608 return StaticLibTool.get();

609}

610

611Tool *ToolChain::getIfsMerge() const {

612 if (!IfsMerge)

613 IfsMerge.reset(new tools::ifstool::Merger(*this));

614 return IfsMerge.get();

615}

616

617Tool *ToolChain::getOffloadBundler() const {

618 if (!OffloadBundler)

619 OffloadBundler.reset(new tools::OffloadBundler(*this));

620 return OffloadBundler.get();

621}

622

623Tool *ToolChain::getOffloadPackager() const {

624 if (!OffloadPackager)

625 OffloadPackager.reset(new tools::OffloadPackager(*this));

626 return OffloadPackager.get();

627}

628

629Tool *ToolChain::getLinkerWrapper() const {

630 if (!LinkerWrapper)

631 LinkerWrapper.reset(new tools::LinkerWrapper(*this, getLink()));

632 return LinkerWrapper.get();

633}

634

636 switch (AC) {

638 return getAssemble();

639

641 return getIfsMerge();

642

644 return getLink();

645

647 return getStaticLibTool();

648

658 llvm_unreachable("Invalid tool kind.");

659

667 return getClang();

668

671 return getOffloadBundler();

672

674 return getOffloadPackager();

676 return getLinkerWrapper();

677 }

678

679 llvm_unreachable("Invalid tool kind.");

680}

681

683 const ArgList &Args) {

684 const llvm::Triple &Triple = TC.getTriple();

685 bool IsWindows = Triple.isOSWindows();

686

688 return Triple.getArchName();

689

690 if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb)

691 return (arm::getARMFloatABI(TC, Args) == arm::FloatABI::Hard && !IsWindows)

692 ? "armhf"

693 : "arm";

694

695

696 if (TC.getArch() == llvm::Triple::x86 && Triple.isAndroid())

697 return "i686";

698

699 if (TC.getArch() == llvm::Triple::x86_64 && Triple.isX32())

700 return "x32";

701

702 return llvm::Triple::getArchTypeName(TC.getArch());

703}

704

706 if (Triple.isOSDarwin())

707 return "darwin";

708

709 switch (Triple.getOS()) {

710 case llvm::Triple::FreeBSD:

711 return "freebsd";

712 case llvm::Triple::NetBSD:

713 return "netbsd";

714 case llvm::Triple::OpenBSD:

715 return "openbsd";

716 case llvm::Triple::Solaris:

717 return "sunos";

718 case llvm::Triple::AIX:

719 return "aix";

720 default:

722 }

723}

724

728 llvm::sys::path::append(Path, "lib", getOSLibName());

731 }

732 } else if (Triple.isOSUnknown()) {

733 llvm::sys::path::append(Path, "lib");

734 } else {

735 llvm::sys::path::append(Path, "lib", getOSLibName());

736 }

737 return std::string(Path);

738}

739

741 StringRef Component,

743 std::string CRTAbsolutePath = getCompilerRT(Args, Component, Type);

744 return llvm::sys::path::filename(CRTAbsolutePath).str();

745}

746

748 StringRef Component,

750 bool IsFortran) const {

751 const llvm::Triple &TT = getTriple();

752 bool IsITANMSVCWindows =

753 TT.isWindowsMSVCEnvironment() || TT.isWindowsItaniumEnvironment();

754

755 const char *Prefix =

757 const char *Suffix;

758 switch (Type) {

760 Suffix = IsITANMSVCWindows ? ".obj" : ".o";

761 break;

763 Suffix = IsITANMSVCWindows ? ".lib" : ".a";

764 break;

766 if (TT.isOSWindows())

767 Suffix = TT.isOSCygMing() ? ".dll.a" : ".lib";

768 else if (TT.isOSAIX())

769 Suffix = ".a";

770 else

771 Suffix = ".so";

772 break;

773 }

774

775 std::string ArchAndEnv;

776 if (AddArch) {

778 const char *Env = TT.isAndroid() ? "-android" : "";

779 ArchAndEnv = ("-" + Arch + Env).str();

780 }

781

782 std::string LibName = IsFortran ? "flang_rt." : "clang_rt.";

783 return (Prefix + Twine(LibName) + Component + ArchAndEnv + Suffix).str();

784}

785

788

790 Args, Component, Type, false, IsFortran);

794 llvm::sys::path::append(P, CRTBasename);

795 if (getVFS().exists(P))

796 return std::string(P);

797 if (Path.empty())

798 Path = P;

799 }

800

801

803 !IsFortran, IsFortran);

805 llvm::sys::path::append(OldPath, CRTBasename);

806 if (Path.empty() || getVFS().exists(OldPath))

807 return std::string(OldPath);

808

809

810

811

812 return std::string(Path);

813}

814

816 StringRef Component,

818 bool isFortran) const {

819 return Args.MakeArgString(getCompilerRT(Args, Component, Type, isFortran));

820}

821

822

824 llvm::opt::ArgStringList &CmdArgs) const {

825

826

827

828

829 if ( getTriple ().isKnownWindowsMSVCEnvironment()) {

831 F128LibName.consume_front_insensitive("lib");

832 if (!F128LibName.empty()) {

833 bool AsNeeded = getTriple ().isOSAIX();

834 CmdArgs.push_back("-lflang_rt.quadmath");

835 if (AsNeeded)

837 CmdArgs.push_back(Args.MakeArgString("-l" + F128LibName));

838 if (AsNeeded)

840 }

842

843

846 CmdArgs.push_back("-lexecinfo");

847 }

848

849

850 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,

851 options::OPT_fno_openmp, false)) {

856 getTriple ().isKnownWindowsMSVCEnvironment()) {

857 CmdArgs.push_back("-latomic");

858 }

859 }

860}

861

863 ArgStringList &CmdArgs) const {

864 auto AddLibSearchPathIfExists = [&](const Twine &Path) {

865

866 if (!llvm::sys::fs::is_directory(Path))

867 return;

868

869 if (getTriple().isKnownWindowsMSVCEnvironment())

870 CmdArgs.push_back(Args.MakeArgString("-libpath:" + Path));

871 else

872 CmdArgs.push_back(Args.MakeArgString("-L" + Path));

873 };

874

875

876

877

878

880

881

882

883

885 llvm::sys::path::parent_path(getDriver().Dir);

886 llvm::sys::path::append(DefaultLibPath, "lib");

887 AddLibSearchPathIfExists(DefaultLibPath);

888}

889

891 llvm::opt::ArgStringList &CmdArgs) const {

892

893

894 if (Args.hasFlag(options::OPT_static_libflangrt,

895 options::OPT_shared_libflangrt, getTriple().isOSAIX()))

896 CmdArgs.push_back(

898 else {

899 CmdArgs.push_back("-lflang_rt.runtime");

901 }

902}

903

904

905

906

907std::optionalstd::string

908ToolChain::getFallbackAndroidTargetPath(StringRef BaseDir) const {

909 llvm::Triple TripleWithoutLevel(getTriple());

910 TripleWithoutLevel.setEnvironmentName("android");

911 const std::string &TripleWithoutLevelStr = TripleWithoutLevel.str();

912 unsigned TripleVersion = getTriple().getEnvironmentVersion().getMajor();

913 unsigned BestVersion = 0;

914

916 bool UsingUnversionedDir = false;

917 std::error_code EC;

918 for (llvm::vfs::directory_iterator LI = getVFS().dir_begin(BaseDir, EC), LE;

919 !EC && LI != LE; LI = LI.increment(EC)) {

920 StringRef DirName = llvm::sys::path::filename(LI->path());

921 StringRef DirNameSuffix = DirName;

922 if (DirNameSuffix.consume_front(TripleWithoutLevelStr)) {

923 if (DirNameSuffix.empty() && TripleDir.empty()) {

924 TripleDir = DirName;

925 UsingUnversionedDir = true;

926 } else {

927 unsigned Version;

928 if (!DirNameSuffix.getAsInteger(10, Version) && Version > BestVersion &&

929 Version < TripleVersion) {

930 BestVersion = Version;

931 TripleDir = DirName;

932 UsingUnversionedDir = false;

933 }

934 }

935 }

936 }

937

938 if (TripleDir.empty())

939 return {};

940

941 SmallString<128> P(BaseDir);

942 llvm::sys::path::append(P, TripleDir);

943 if (UsingUnversionedDir)

944 D.Diag(diag::warn_android_unversioned_fallback) << P << getTripleString();

945 return std::string(P);

946}

947

949 return (Triple.hasEnvironment()

950 ? llvm::Triple(Triple.getArchName(), Triple.getVendorName(),

951 llvm::Triple::getOSTypeName(Triple.getOS()),

952 llvm::Triple::getEnvironmentTypeName(

953 Triple.getEnvironment()))

954 : llvm::Triple(Triple.getArchName(), Triple.getVendorName(),

955 llvm::Triple::getOSTypeName(Triple.getOS())));

956}

957

958std::optionalstd::string

960 auto getPathForTriple =

961 [&](const llvm::Triple &Triple) -> std::optionalstd::string {

963 llvm::sys::path::append(P, Triple.str());

964 if (getVFS().exists(P))

965 return std::string(P);

966 return {};

967 };

968

970 if (auto Path = getPathForTriple(T))

971 return *Path;

972

973 if (T.isOSAIX()) {

974 llvm::Triple AIXTriple;

975 if (T.getEnvironment() == Triple::UnknownEnvironment) {

976

977 AIXTriple = llvm::Triple(T.getArchName(), T.getVendorName(),

978 llvm::Triple::getOSTypeName(T.getOS()));

979 } else {

980

982 }

983 if (auto Path = getPathForTriple(AIXTriple))

984 return *Path;

985 }

986

987 if (T.isOSzOS() &&

988 (.getOSVersion().empty() || .getEnvironmentVersion().empty())) {

989

991 if (auto Path = getPathForTriple(TripleWithoutVersion))

992 return *Path;

993 }

994

995

996

997

998

999

1000

1001

1002

1003

1004

1005

1006

1007

1008

1009

1010 if (T.getArch() == Triple::arm && .isArmMClass()) {

1011 llvm::Triple ArmTriple = T;

1012 ArmTriple.setArch(Triple::arm);

1013 if (auto Path = getPathForTriple(ArmTriple))

1014 return *Path;

1015 }

1016

1017 if (T.isAndroid())

1018 return getFallbackAndroidTargetPath(BaseDir);

1019

1020 return {};

1021}

1022

1025 llvm::sys::path::append(P, "lib");

1027 return Ret;

1028

1029 if (Triple.isOSDarwin())

1030 return {};

1031

1032 llvm::sys::path::append(P, Triple.str());

1033 return std::string(P);

1034}

1035

1038 llvm::sys::path::append(P, "..", "lib");

1040}

1041

1044 llvm::sys::path::append(P, "..", "include");

1046}

1047

1050

1053 llvm::sys::path::append(Path, "lib");

1054 for (auto &S : SS)

1055 llvm::sys::path::append(Path, S);

1056 Paths.push_back(std::string(Path));

1057 };

1058

1061 return Paths;

1062}

1063

1065 if (Args.hasArg(options::OPT_noprofilelib))

1066 return false;

1067

1068 return Args.hasArg(options::OPT_fprofile_generate) ||

1069 Args.hasArg(options::OPT_fprofile_generate_EQ) ||

1070 Args.hasArg(options::OPT_fcs_profile_generate) ||

1071 Args.hasArg(options::OPT_fcs_profile_generate_EQ) ||

1072 Args.hasArg(options::OPT_fprofile_instr_generate) ||

1073 Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||

1074 Args.hasArg(options::OPT_fcreate_profile) ||

1075 Args.hasArg(options::OPT_fprofile_generate_cold_function_coverage) ||

1076 Args.hasArg(options::OPT_fprofile_generate_cold_function_coverage_EQ);

1077}

1078

1080 return Args.hasArg(options::OPT_coverage) ||

1081 Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,

1082 false);

1083}

1084

1086 if (D.IsFlangMode() && getDriver().ShouldUseFlangCompiler(JA)) return getFlang();

1087 if (getDriver().ShouldUseClangCompiler(JA)) return getClang();

1091 return getClangAs();

1093}

1094

1096 return D.GetFilePath(Name, *this);

1097}

1098

1100 return D.GetProgramPath(Name, *this);

1101}

1102

1104 if (LinkerIsLLD)

1105 *LinkerIsLLD = false;

1106

1107

1108

1109 const Arg* A = Args.getLastArg(options::OPT_fuse_ld_EQ);

1111

1112

1113

1114

1115

1116

1117 if (const Arg *A = Args.getLastArg(options::OPT_ld_path_EQ)) {

1118 std::string Path(A->getValue());

1119 if (!Path.empty()) {

1120 if (llvm::sys::path::parent_path(Path).empty())

1122 if (llvm::sys::fs::can_execute(Path)) {

1123 if (LinkerIsLLD)

1124 *LinkerIsLLD = UseLinker == "lld";

1125 return std::string(Path);

1126 }

1127 }

1128 getDriver().Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);

1130 }

1131

1132

1133 if (UseLinker.empty() || UseLinker == "ld") {

1135 if (llvm::sys::path::is_absolute(DefaultLinker))

1136 return std::string(DefaultLinker);

1137 else

1139 }

1140

1141

1142

1143

1144

1145 if (UseLinker.contains('/'))

1147

1148 if (llvm::sys::path::is_absolute(UseLinker)) {

1149

1150

1151 if (llvm::sys::fs::can_execute(UseLinker))

1152 return std::string(UseLinker);

1153 } else {

1155 if (Triple.isOSDarwin())

1156 LinkerName.append("ld64.");

1157 else

1158 LinkerName.append("ld.");

1159 LinkerName.append(UseLinker);

1160

1161 std::string LinkerPath(GetProgramPath(LinkerName.c_str()));

1162 if (llvm::sys::fs::can_execute(LinkerPath)) {

1163 if (LinkerIsLLD)

1164 *LinkerIsLLD = UseLinker == "lld";

1165 return LinkerPath;

1166 }

1167 }

1168

1169 if (A)

1170 getDriver().Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);

1171

1173}

1174

1176

1177 if (Triple.isOSDarwin())

1180}

1181

1184

1185

1186

1187

1188 if (D.IsFlangMode() && id == types::TY_PP_Fortran)

1189 id = types::TY_Fortran;

1190

1191 return id;

1192}

1193

1197

1199 llvm::Triple HostTriple(LLVM_HOST_TRIPLE);

1200 switch (HostTriple.getArch()) {

1201

1202

1203 case llvm::Triple::arm:

1204 case llvm::Triple::armeb:

1205 case llvm::Triple::thumb:

1206 case llvm::Triple::thumbeb:

1207 return getArch() != llvm::Triple::arm && getArch() != llvm::Triple::thumb &&

1208 getArch() != llvm::Triple::armeb && getArch() != llvm::Triple::thumbeb;

1209 default:

1210 return HostTriple.getArch() != getArch();

1211 }

1212}

1213

1216 VersionTuple());

1217}

1218

1219llvm::ExceptionHandling

1221 return llvm::ExceptionHandling::None;

1222}

1223

1225 if (Model == "single") {

1226

1227 return Triple.getArch() == llvm::Triple::arm ||

1228 Triple.getArch() == llvm::Triple::armeb ||

1229 Triple.getArch() == llvm::Triple::thumb ||

1230 Triple.getArch() == llvm::Triple::thumbeb || Triple.isWasm();

1231 } else if (Model == "posix")

1232 return true;

1233

1234 return false;

1235}

1236

1240 default:

1242

1243 case llvm::Triple::x86_64: {

1244 llvm::Triple Triple = getTriple();

1245 if (!Triple.isOSBinFormatMachO())

1247

1248 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {

1249

1250

1251 StringRef MArch = A->getValue();

1252 if (MArch == "x86_64h")

1253 Triple.setArchName(MArch);

1254 }

1255 return Triple.getTriple();

1256 }

1257 case llvm::Triple::aarch64: {

1258 llvm::Triple Triple = getTriple();

1259 if (!Triple.isOSBinFormatMachO())

1260 return Triple.getTriple();

1261

1262 if (Triple.isArm64e())

1263 return Triple.getTriple();

1264

1265

1266

1267

1268 Triple.setArchName("arm64");

1269 return Triple.getTriple();

1270 }

1271 case llvm::Triple::aarch64_32:

1273 case llvm::Triple::amdgcn: {

1274 llvm::Triple Triple = getTriple();

1275 if (Args.getLastArgValue(options::OPT_mcpu_EQ) == "amdgcnspirv")

1276 Triple.setArch(llvm::Triple::ArchType::spirv64);

1277 return Triple.getTriple();

1278 }

1279 case llvm::Triple::arm:

1280 case llvm::Triple::armeb:

1281 case llvm::Triple::thumb:

1282 case llvm::Triple::thumbeb: {

1283 llvm::Triple Triple = getTriple();

1286 return Triple.getTriple();

1287 }

1288 }

1289}

1290

1295

1297 return D.SysRoot;

1298}

1299

1301 ArgStringList &CC1Args) const {

1302

1303}

1304

1306 const ArgList &DriverArgs, ArgStringList &CC1Args,

1308

1310 ArgStringList &CC1ASArgs) const {}

1311

1313

1315 llvm::opt::ArgStringList &CmdArgs) const {

1317 return;

1318

1320}

1321

1323 const ArgList &Args) const {

1324 if (runtimeLibType)

1325 return *runtimeLibType;

1326

1327 const Arg* A = Args.getLastArg(options::OPT_rtlib_EQ);

1328 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_RTLIB;

1329

1330

1331 if (LibName == "compiler-rt")

1333 else if (LibName == "libgcc")

1335 else if (LibName == "platform")

1337 else {

1338 if (A)

1339 getDriver().Diag(diag::err_drv_invalid_rtlib_name)

1340 << A->getAsString(Args);

1341

1343 }

1344

1345 return *runtimeLibType;

1346}

1347

1349 const ArgList &Args) const {

1350 if (unwindLibType)

1351 return *unwindLibType;

1352

1353 const Arg *A = Args.getLastArg(options::OPT_unwindlib_EQ);

1354 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_UNWINDLIB;

1355

1356 if (LibName == "none")

1358 else if (LibName == "platform" || LibName == "") {

1363 else

1367 } else if (LibName == "libunwind") {

1369 getDriver().Diag(diag::err_drv_incompatible_unwindlib);

1371 } else if (LibName == "libgcc")

1373 else {

1374 if (A)

1375 getDriver().Diag(diag::err_drv_invalid_unwindlib_name)

1376 << A->getAsString(Args);

1377

1379 }

1380

1381 return *unwindLibType;

1382}

1383

1385 if (cxxStdlibType)

1386 return *cxxStdlibType;

1387

1388 const Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);

1389 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_CXX_STDLIB;

1390

1391

1392 if (LibName == "libc++")

1394 else if (LibName == "libstdc++")

1396 else if (LibName == "platform")

1398 else {

1399 if (A)

1400 getDriver().Diag(diag::err_drv_invalid_stdlib_name)

1401 << A->getAsString(Args);

1402

1404 }

1405

1406 return *cxxStdlibType;

1407}

1408

1409

1411 llvm::opt::ArgStringList &CC1Args,

1412 const Twine &Path) {

1413 CC1Args.push_back("-internal-iframework");

1414 CC1Args.push_back(DriverArgs.MakeArgString(Path));

1415}

1416

1417

1418

1419

1420

1421

1422

1423

1424

1426 ArgStringList &CC1Args,

1427 const Twine &Path) {

1428 CC1Args.push_back("-internal-externc-isystem");

1429 CC1Args.push_back(DriverArgs.MakeArgString(Path));

1430}

1431

1433 ArgStringList &CC1Args,

1434 const Twine &Path) {

1435 if (llvm::sys::fs::exists(Path))

1437}

1438

1439

1441 ArgStringList &CC1Args,

1442 const Twine &Path) {

1443 CC1Args.push_back("-internal-isystem");

1444 CC1Args.push_back(DriverArgs.MakeArgString(Path));

1445}

1446

1447

1449 ArgStringList &CC1Args,

1451 for (const auto &Path : Paths) {

1452 CC1Args.push_back("-internal-iframework");

1453 CC1Args.push_back(DriverArgs.MakeArgString(Path));

1454 }

1455}

1456

1457

1459 ArgStringList &CC1Args,

1461 for (const auto &Path : Paths) {

1462 CC1Args.push_back("-internal-isystem");

1463 CC1Args.push_back(DriverArgs.MakeArgString(Path));

1464 }

1465}

1466

1468 const Twine &C, const Twine &D) {

1470 llvm::sys::path::append(Result, llvm::sys::path::Style::posix, A, B, C, D);

1471 return std::string(Result);

1472}

1473

1475 std::error_code EC;

1476 int MaxVersion = 0;

1477 std::string MaxVersionString;

1479 llvm::sys::path::append(Path, "c++");

1480 for (llvm::vfs::directory_iterator LI = getVFS().dir_begin(Path, EC), LE;

1481 !EC && LI != LE; LI = LI.increment(EC)) {

1482 StringRef VersionText = llvm::sys::path::filename(LI->path());

1483 int Version;

1484 if (VersionText[0] == 'v' &&

1485 !VersionText.substr(1).getAsInteger(10, Version)) {

1486 if (Version > MaxVersion) {

1487 MaxVersion = Version;

1488 MaxVersionString = std::string(VersionText);

1489 }

1490 }

1491 }

1492 if (!MaxVersion)

1493 return "";

1494 return MaxVersionString;

1495}

1496

1498 ArgStringList &CC1Args) const {

1499

1500

1501

1502

1503

1504

1505

1506

1507

1508 DriverArgs.AddAllArgs(CC1Args, options::OPT_stdlib_EQ);

1509}

1510

1512 const llvm::opt::ArgList &DriverArgs,

1513 llvm::opt::ArgStringList &CC1Args) const {

1514 DriverArgs.ClaimAllArgs(options::OPT_stdlibxx_isystem);

1515

1516

1517

1518

1519

1520

1521

1522

1523 if (!DriverArgs.hasArg(options::OPT_nostdincxx))

1524 for (const auto &P :

1525 DriverArgs.getAllArgValues(options::OPT_stdlibxx_isystem))

1527}

1528

1531 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs,

1532 options::OPT_nostdlibxx);

1533}

1534

1536 ArgStringList &CmdArgs) const {

1537 assert(!Args.hasArg(options::OPT_nostdlibxx) &&

1538 "should not have called this");

1540

1541 switch (Type) {

1543 CmdArgs.push_back("-lc++");

1544 if (Args.hasArg(options::OPT_fexperimental_library))

1545 CmdArgs.push_back("-lc++experimental");

1546 break;

1547

1549 CmdArgs.push_back("-lstdc++");

1550 break;

1551 }

1552}

1553

1555 ArgStringList &CmdArgs) const {

1557 if(LibPath.length() > 0)

1558 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));

1559}

1560

1562 ArgStringList &CmdArgs) const {

1563 CmdArgs.push_back("-lcc_kext");

1564}

1565

1567 std::string &Path) const {

1568

1569

1570

1571 bool Default = !Args.hasArgNoClaim(options::OPT_shared);

1572

1573

1574

1576

1577 Arg *A = Args.getLastArg(

1578 options::OPT_ffast_math, options::OPT_fno_fast_math,

1579 options::OPT_funsafe_math_optimizations,

1580 options::OPT_fno_unsafe_math_optimizations, options::OPT_ffp_model_EQ);

1581

1582 if (!A || A->getOption().getID() == options::OPT_fno_fast_math ||

1583 A->getOption().getID() == options::OPT_fno_unsafe_math_optimizations)

1585 if (A && A->getOption().getID() == options::OPT_ffp_model_EQ) {

1586 StringRef Model = A->getValue();

1587 if (Model != "fast" && Model != "aggressive")

1589 }

1590 }

1591

1592

1593

1594 if (!Args.hasFlag(options::OPT_mdaz_ftz, options::OPT_mno_daz_ftz, Default))

1595 return false;

1596

1597

1599 return (Path != "crtfastmath.o");

1600}

1601

1603 ArgStringList &CmdArgs) const {

1604 std::string Path;

1606 CmdArgs.push_back(Args.MakeArgString(Path));

1607 return true;

1608 }

1609

1610 return false;

1611}

1612

1617

1619

1620

1621

1624 (SanitizerKind::CFI & ~SanitizerKind::CFIICall) |

1625 SanitizerKind::CFICastStrict | SanitizerKind::FloatDivideByZero |

1626 SanitizerKind::KCFI | SanitizerKind::UnsignedIntegerOverflow |

1627 SanitizerKind::UnsignedShiftBase | SanitizerKind::ImplicitConversion |

1628 SanitizerKind::Nullability | SanitizerKind::LocalBounds |

1629 SanitizerKind::AllocToken;

1636 Res |= SanitizerKind::CFIICall;

1639 Res |= SanitizerKind::ShadowCallStack;

1641 Res |= SanitizerKind::MemTag;

1643 Res |= SanitizerKind::KernelAddress;

1644 return Res;

1645}

1646

1648 ArgStringList &CC1Args) const {}

1649

1651 ArgStringList &CC1Args) const {}

1652

1654 ArgStringList &CC1Args) const {}

1655

1661

1663 ArgStringList &CC1Args) const {}

1664

1666 if (Version < 100)

1667 return VersionTuple(Version);

1668

1669 if (Version < 10000)

1670 return VersionTuple(Version / 100, Version % 100);

1671

1672 unsigned Build = 0, Factor = 1;

1673 for (; Version > 10000; Version = Version / 10, Factor = Factor * 10)

1674 Build = Build + (Version % 10) * Factor;

1675 return VersionTuple(Version / 100, Version % 100, Build);

1676}

1677

1678VersionTuple

1680 const llvm::opt::ArgList &Args) const {

1681 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);

1682 const Arg *MSCompatibilityVersion =

1683 Args.getLastArg(options::OPT_fms_compatibility_version);

1684

1685 if (MSCVersion && MSCompatibilityVersion) {

1686 if (D)

1687 D->Diag(diag::err_drv_argument_not_allowed_with)

1688 << MSCVersion->getAsString(Args)

1689 << MSCompatibilityVersion->getAsString(Args);

1690 return VersionTuple();

1691 }

1692

1693 if (MSCompatibilityVersion) {

1694 VersionTuple MSVT;

1695 if (MSVT.tryParse(MSCompatibilityVersion->getValue())) {

1696 if (D)

1697 D->Diag(diag::err_drv_invalid_value)

1698 << MSCompatibilityVersion->getAsString(Args)

1699 << MSCompatibilityVersion->getValue();

1700 } else {

1701 return MSVT;

1702 }

1703 }

1704

1705 if (MSCVersion) {

1706 unsigned Version = 0;

1707 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version)) {

1708 if (D)

1709 D->Diag(diag::err_drv_invalid_value)

1710 << MSCVersion->getAsString(Args) << MSCVersion->getValue();

1711 } else {

1713 }

1714 }

1715

1716 return VersionTuple();

1717}

1718

1720 const llvm::opt::DerivedArgList &Args, bool SameTripleAsHost,

1722 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());

1724 bool Modified = false;

1725

1726

1727 for (auto *A : Args) {

1728

1729

1730

1731

1732 if (A->getOption().matches(options::OPT_m_Group)) {

1733

1734

1735 if (SameTripleAsHost ||

1736 A->getOption().matches(options::OPT_mcode_object_version_EQ))

1737 DAL->append(A);

1738 else

1739 Modified = true;

1740 continue;

1741 }

1742

1743 unsigned Index;

1744 unsigned Prev;

1745 bool XOpenMPTargetNoTriple =

1746 A->getOption().matches(options::OPT_Xopenmp_target);

1747

1748 if (A->getOption().matches(options::OPT_Xopenmp_target_EQ)) {

1750

1751

1753 Index = Args.getBaseArgs().MakeIndex(A->getValue(1));

1754 else

1755 continue;

1756 } else if (XOpenMPTargetNoTriple) {

1757

1758 Index = Args.getBaseArgs().MakeIndex(A->getValue(0));

1759 } else {

1760 DAL->append(A);

1761 continue;

1762 }

1763

1764

1765 Prev = Index;

1766 std::unique_ptr XOpenMPTargetArg(Opts.ParseOneArg(Args, Index));

1767 if (!XOpenMPTargetArg || Index > Prev + 1) {

1768 if (!A->isClaimed()) {

1769 getDriver().Diag(diag::err_drv_invalid_Xopenmp_target_with_args)

1770 << A->getAsString(Args);

1771 }

1772 continue;

1773 }

1774 if (XOpenMPTargetNoTriple && XOpenMPTargetArg &&

1775 Args.getAllArgValues(options::OPT_offload_targets_EQ).size() != 1) {

1776 getDriver().Diag(diag::err_drv_Xopenmp_target_missing_triple);

1777 continue;

1778 }

1779 XOpenMPTargetArg->setBaseArg(A);

1780 A = XOpenMPTargetArg.release();

1781 AllocatedArgs.push_back(A);

1782 DAL->append(A);

1783 Modified = true;

1784 }

1785

1786 if (Modified)

1787 return DAL;

1788

1789 delete DAL;

1790 return nullptr;

1791}

1792

1793

1794

1795

1797 const llvm::opt::DerivedArgList &Args, llvm::opt::Arg *&A,

1798 llvm::opt::DerivedArgList *DAL,

1801 unsigned ValuePos = 1;

1802 if (A->getOption().matches(options::OPT_Xarch_device) ||

1803 A->getOption().matches(options::OPT_Xarch_host))

1804 ValuePos = 0;

1805

1806 const InputArgList &BaseArgs = Args.getBaseArgs();

1807 unsigned Index = BaseArgs.MakeIndex(A->getValue(ValuePos));

1808 unsigned Prev = Index;

1809 std::unique_ptrllvm::opt::Arg XarchArg(Opts.ParseOneArg(

1811

1812

1813

1814

1815

1816

1817

1818

1819 if (!XarchArg || Index > Prev + 1) {

1820 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)

1821 << A->getAsString(Args);

1822 return;

1825 unsigned DiagID =

1827 "invalid Xarch argument: '%0', not all driver "

1828 "options can be forwared via Xarch argument");

1829 Diags.Report(DiagID) << A->getAsString(Args);

1830 return;

1831 }

1832

1833 XarchArg->setBaseArg(A);

1834 A = XarchArg.release();

1835

1836

1837

1838

1840

1841

1842 for (const char *Value : A->getValues()) {

1843 auto Opt = Opts.getOption(options::OPT_Zlinker_input);

1844 unsigned Index = BaseArgs.MakeIndex(Opt.getName(), Value);

1845 auto NewArg =

1846 new Arg(Opt, BaseArgs.MakeArgString(Opt.getPrefix() + Opt.getName()),

1847 Index, BaseArgs.getArgString(Index + 1), A);

1848

1849 DAL->append(NewArg);

1850 if (!AllocatedArgs)

1851 DAL->AddSynthesizedArg(NewArg);

1852 else

1853 AllocatedArgs->push_back(NewArg);

1854 }

1855 }

1856

1857 if (!AllocatedArgs)

1858 DAL->AddSynthesizedArg(A);

1859 else

1860 AllocatedArgs->push_back(A);

1861}

1862

1864 const llvm::opt::DerivedArgList &Args, StringRef BoundArch,

1867 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());

1868 bool Modified = false;

1869

1871 for (Arg *A : Args) {

1872 bool NeedTrans = false;

1873 bool Skip = false;

1874 if (A->getOption().matches(options::OPT_Xarch_device)) {

1875 NeedTrans = IsDevice;

1876 Skip = !IsDevice;

1877 } else if (A->getOption().matches(options::OPT_Xarch_host)) {

1878 NeedTrans = !IsDevice;

1879 Skip = IsDevice;

1880 } else if (A->getOption().matches(options::OPT_Xarch__)) {

1881 NeedTrans = A->getValue() == getArchName() ||

1882 (!BoundArch.empty() && A->getValue() == BoundArch);

1883 Skip = !NeedTrans;

1884 }

1885 if (NeedTrans || Skip)

1886 Modified = true;

1887 if (NeedTrans) {

1888 A->claim();

1890 }

1892 DAL->append(A);

1893 }

1894

1895 if (Modified)

1896 return DAL;

1897

1898 delete DAL;

1899 return nullptr;

1900}

Defines types useful for describing an Objective-C runtime.

Defines the clang::SanitizerKind enum.

unsigned getCustomDiagID(Level L, const char(&FormatString)[N])

Return an ID for a diagnostic with the specified format string and level.

The basic abstraction for the target Objective-C runtime.

@ GNUstep

'gnustep' is the modern non-fragile GNUstep runtime.

@ GCC

'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI

The base class of the type hierarchy.

ActionClass getKind() const

@ OffloadUnbundlingJobClass

@ BinaryTranslatorJobClass

@ OffloadBundlingJobClass

@ VerifyDebugInfoJobClass

@ OffloadPackagerJobClass

Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...

DiagnosticsEngine & getDiags() const

OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const

Compute the desired OpenMP runtime from the flags provided.

DiagnosticBuilder Diag(unsigned DiagID) const

StringRef getFlangF128MathLibrary() const

const llvm::opt::OptTable & getOpts() const

llvm::vfs::FileSystem & getVFS() const

@ OMPRT_OMP

The LLVM OpenMP runtime.

StringRef getPreferredLinker() const

bool CCCIsCXX() const

Whether the driver should follow g++ like behavior.

InputInfo - Wrapper for information about an input source.

const char * getFilename() const

std::vector< std::string > flags_list

ID lookupTypeForExtension(llvm::StringRef Ext)

lookupTypeForExtension - Lookup the type to use for the file extension Ext.

bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)

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

@ Link

'link' clause, allowed on 'declare' construct.

@ Result

The result type of a method or function.

const FunctionProtoType * T

Diagnostic wrappers for TextAPI types for error reporting.

Helper structure used to pass information extracted from clang executable name such as i686-linux-and...