MinGW.cpp Source File (original) (raw)

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

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

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

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

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

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

23#include <system_error>

27using namespace clang;

34 const ArgList &Args,

35 const char *LinkingOutput) const {

37 ArgStringList CmdArgs;

39 if (getToolChain().getArch() == llvm::Triple::x86) {

40 CmdArgs.push_back("--32");

41 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {

42 CmdArgs.push_back("--64");

43 }

45 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);

47 CmdArgs.push_back("-o");

50 for (const auto &II : Inputs)

51 CmdArgs.push_back(II.getFilename());

53 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));

55 Exec, CmdArgs, Inputs, Output));

57 if (Args.hasArg(options::OPT_gsplit_dwarf))

60}

62void tools::MinGW::Linker::AddLibGCC(const ArgList &Args,

63 ArgStringList &CmdArgs) const {

64 if (Args.hasArg(options::OPT_mthreads))

65 CmdArgs.push_back("-lmingwthrd");

66 CmdArgs.push_back("-lmingw32");

71 bool Static = Args.hasArg(options::OPT_static_libgcc) ||

72 Args.hasArg(options::OPT_static);

73 bool Shared = Args.hasArg(options::OPT_shared);

74 bool CXX = getToolChain().getDriver().CCCIsCXX();

76 if (Static || ( CXX && !Shared)) {

77 CmdArgs.push_back("-lgcc");

78 CmdArgs.push_back("-lgcc_eh");

79 } else {

80 CmdArgs.push_back("-lgcc_s");

81 CmdArgs.push_back("-lgcc");

82 }

83 } else {

84 AddRunTimeLibs(getToolChain(), getToolChain().getDriver(), CmdArgs, Args);

85 }

87 CmdArgs.push_back("-lmoldname");

88 CmdArgs.push_back("-lmingwex");

89 for (auto Lib : Args.getAllArgValues(options::OPT_l))

90 if (StringRef(Lib).starts_with("msvcr") ||

91 StringRef(Lib).starts_with("ucrt") ||

92 StringRef(Lib).starts_with("crtdll"))

93 return;

94 CmdArgs.push_back("-lmsvcrt");

95}

100 const ArgList &Args,

101 const char *LinkingOutput) const {

102 const ToolChain &TC = getToolChain();

105

106 ArgStringList CmdArgs;

107

108

109 Args.ClaimAllArgs(options::OPT_g_Group);

110

111 Args.ClaimAllArgs(options::OPT_emit_llvm);

112

113

114 Args.ClaimAllArgs(options::OPT_w);

115

116 if (.SysRoot.empty())

117 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));

118

119 if (Args.hasArg(options::OPT_s))

120 CmdArgs.push_back("-s");

121

122 CmdArgs.push_back("-m");

124 case llvm::Triple::x86:

125 CmdArgs.push_back("i386pe");

126 break;

127 case llvm::Triple::x86_64:

128 CmdArgs.push_back("i386pep");

129 break;

130 case llvm::Triple::arm:

131 case llvm::Triple::thumb:

132

133 CmdArgs.push_back("thumb2pe");

134 break;

135 case llvm::Triple::aarch64:

137 CmdArgs.push_back("arm64ecpe");

138 else

139 CmdArgs.push_back("arm64pe");

140 break;

141 case llvm::Triple::mipsel:

142 CmdArgs.push_back("mipspe");

143 break;

144 default:

145 D.Diag(diag::err_target_unknown_triple) << TC.getEffectiveTriple().str();

146 }

147

148 Arg *SubsysArg =

149 Args.getLastArg(options::OPT_mwindows, options::OPT_mconsole);

150 if (SubsysArg && SubsysArg->getOption().matches(options::OPT_mwindows)) {

151 CmdArgs.push_back("--subsystem");

152 CmdArgs.push_back("windows");

153 } else if (SubsysArg &&

154 SubsysArg->getOption().matches(options::OPT_mconsole)) {

155 CmdArgs.push_back("--subsystem");

156 CmdArgs.push_back("console");

157 }

158

159 if (Args.hasArg(options::OPT_mdll))

160 CmdArgs.push_back("--dll");

161 else if (Args.hasArg(options::OPT_shared))

162 CmdArgs.push_back("--shared");

163 if (Args.hasArg(options::OPT_static))

164 CmdArgs.push_back("-Bstatic");

165 else

166 CmdArgs.push_back("-Bdynamic");

167 if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) {

168 CmdArgs.push_back("-e");

169 if (TC.getArch() == llvm::Triple::x86)

170 CmdArgs.push_back("_DllMainCRTStartup@12");

171 else

172 CmdArgs.push_back("DllMainCRTStartup");

173 CmdArgs.push_back("--enable-auto-image-base");

174 }

175

176 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))

177 CmdArgs.push_back("--no-demangle");

178

179 if (!Args.hasFlag(options::OPT_fauto_import, options::OPT_fno_auto_import,

180 true))

181 CmdArgs.push_back("--disable-auto-import");

182

183 if (Arg *A = Args.getLastArg(options::OPT_mguard_EQ)) {

184 StringRef GuardArgs = A->getValue();

185 if (GuardArgs == "none")

186 CmdArgs.push_back("--no-guard-cf");

187 else if (GuardArgs == "cf" || GuardArgs == "cf-nochecks")

188 CmdArgs.push_back("--guard-cf");

189 else

190 D.Diag(diag::err_drv_unsupported_option_argument)

191 << A->getSpelling() << GuardArgs;

192 }

193

194 if (Args.hasArg(options::OPT_fms_hotpatch))

195 CmdArgs.push_back("--functionpadmin");

196

197 CmdArgs.push_back("-o");

198 const char *OutputFile = Output.getFilename();

199

200

201

202

203 if (!llvm::sys::path::has_extension(OutputFile)) {

204 CmdArgs.push_back(Args.MakeArgString(Twine(OutputFile) + ".exe"));

205 OutputFile = CmdArgs.back();

206 } else

207 CmdArgs.push_back(OutputFile);

208

209

210 Args.AddLastArg(CmdArgs, options::OPT_r);

211 Args.AddLastArg(CmdArgs, options::OPT_s);

212 Args.AddLastArg(CmdArgs, options::OPT_t);

213 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);

214

215

216

217

218 if (Sanitize.needsAsanRt() && !Args.hasArg(options::OPT_nostdlib) &&

219 !Args.hasArg(options::OPT_nodefaultlibs)) {

220

221 CmdArgs.push_back(

223 }

224

225 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {

226 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) {

227 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("dllcrt2.o")));

228 } else {

229 if (Args.hasArg(options::OPT_municode))

230 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2u.o")));

231 else

232 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2.o")));

233 }

234 if (Args.hasArg(options::OPT_pg))

235 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("gcrt2.o")));

236 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtbegin.o")));

237 }

238

239 Args.AddAllArgs(CmdArgs, options::OPT_L);

241

242

243

245 if (TC.getVFS().exists(LibPath))

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

247 }

249 if (TC.getVFS().exists(CRTPath))

250 CmdArgs.push_back(Args.MakeArgString("-L" + CRTPath));

251

253

254 if (D.isUsingLTO()) {

255 assert(!Inputs.empty() && "Must have at least one input.");

256 addLTOOptions(TC, Args, CmdArgs, Output, Inputs[0],

258 }

259

260 if (C.getDriver().IsFlangMode() &&

261 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {

264 }

265

266

267

269 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&

270 !Args.hasArg(options::OPT_static);

271 if (OnlyLibstdcxxStatic)

272 CmdArgs.push_back("-Bstatic");

274 if (OnlyLibstdcxxStatic)

275 CmdArgs.push_back("-Bdynamic");

276 }

277

278 bool HasWindowsApp = false;

279 for (auto Lib : Args.getAllArgValues(options::OPT_l)) {

280 if (Lib == "windowsapp") {

281 HasWindowsApp = true;

282 break;

283 }

284 }

285

286 if (!Args.hasArg(options::OPT_nostdlib)) {

287 if (!Args.hasArg(options::OPT_nodefaultlibs)) {

288 if (Args.hasArg(options::OPT_static))

289 CmdArgs.push_back("--start-group");

290

291 if (Args.hasArg(options::OPT_fstack_protector) ||

292 Args.hasArg(options::OPT_fstack_protector_strong) ||

293 Args.hasArg(options::OPT_fstack_protector_all)) {

294 CmdArgs.push_back("-lssp_nonshared");

295 CmdArgs.push_back("-lssp");

296 }

297

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

299 options::OPT_fno_openmp, false)) {

302 CmdArgs.push_back("-lomp");

303 break;

305 CmdArgs.push_back("-liomp5md");

306 break;

308 CmdArgs.push_back("-lgomp");

309 break;

311

312 break;

313 }

314 }

315

316 AddLibGCC(Args, CmdArgs);

317

318 if (Args.hasArg(options::OPT_pg))

319 CmdArgs.push_back("-lgmon");

320

321 if (Args.hasArg(options::OPT_pthread))

322 CmdArgs.push_back("-lpthread");

323

325

328 CmdArgs.push_back(

330 CmdArgs.push_back("--require-defined");

331 CmdArgs.push_back(TC.getArch() == llvm::Triple::x86

332 ? "___asan_seh_interceptor"

333 : "__asan_seh_interceptor");

334

335

336 CmdArgs.push_back("--whole-archive");

337 CmdArgs.push_back(

339 CmdArgs.push_back("--no-whole-archive");

340 }

341

343

344 if (!HasWindowsApp) {

345

346

347

348 if (Args.hasArg(options::OPT_mwindows)) {

349 CmdArgs.push_back("-lgdi32");

350 CmdArgs.push_back("-lcomdlg32");

351 }

352 CmdArgs.push_back("-ladvapi32");

353 CmdArgs.push_back("-lshell32");

354 CmdArgs.push_back("-luser32");

355 CmdArgs.push_back("-lkernel32");

356 }

357

358 if (Args.hasArg(options::OPT_static)) {

359 CmdArgs.push_back("--end-group");

360 } else {

361 AddLibGCC(Args, CmdArgs);

362 if (!HasWindowsApp)

363 CmdArgs.push_back("-lkernel32");

364 }

365 }

366

367 if (!Args.hasArg(options::OPT_nostartfiles)) {

368

370

371 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));

372 }

373 }

374 const char *Exec = Args.MakeArgString(TC.GetLinkerPath());

375 C.addCommand(std::make_unique(JA, *this,

377 Exec, CmdArgs, Inputs, Output));

378}

379

381 llvm::Triple HostTriple(llvm::Triple::normalize(LLVM_HOST_TRIPLE));

382 if (HostTriple.getOS() != llvm::Triple::Win32)

383 return true;

384 if (RequireArchMatch && HostTriple.getArch() != T.getArch())

385 return true;

386 return false;

387}

388

389

390static bool findGccVersion(StringRef LibDir, std::string &GccLibDir,

391 std::string &Ver,

394 std::error_code EC;

395 for (llvm::sys::fs::directory_iterator LI(LibDir, EC), LE; !EC && LI != LE;

396 LI = LI.increment(EC)) {

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

398 auto CandidateVersion =

400 if (CandidateVersion.Major == -1)

401 continue;

402 if (CandidateVersion <= Version)

403 continue;

404 Version = CandidateVersion;

405 Ver = std::string(VersionText);

406 GccLibDir = LI->path();

407 }

408 return Ver.size();

409}

410

412 llvm::Triple LiteralTriple(D.getTargetTriple());

413

414 LiteralTriple.setArchName(T.getArchName());

415 return LiteralTriple;

416}

417

418void toolchains::MinGW::findGccLibDir(const llvm::Triple &LiteralTriple) {

420 SubdirNames.emplace_back(LiteralTriple.str());

421 SubdirNames.emplace_back(getTriple().str());

422 SubdirNames.emplace_back(getTriple().getArchName());

423 SubdirNames.back() += "-w64-mingw32";

424 SubdirNames.emplace_back(getTriple().getArchName());

425 SubdirNames.back() += "-w64-mingw32ucrt";

426 SubdirNames.emplace_back("mingw32");

427 if (SubdirName.empty()) {

428 SubdirName = getTriple().getArchName();

429 SubdirName += "-w64-mingw32";

430 }

431

432

433 for (StringRef CandidateLib : {"lib", "lib64"}) {

434 for (StringRef CandidateSysroot : SubdirNames) {

436 llvm::sys::path::append(LibDir, CandidateLib, "gcc", CandidateSysroot);

437 if (findGccVersion(LibDir, GccLibDir, Ver, GccVer)) {

438 SubdirName = std::string(CandidateSysroot);

439 return;

440 }

441 }

442 }

443}

444

445static llvm::ErrorOrstd::string findGcc(const llvm::Triple &LiteralTriple,

446 const llvm::Triple &T) {

448 Gccs.emplace_back(LiteralTriple.str());

449 Gccs.back() += "-gcc";

450 Gccs.emplace_back(T.str());

451 Gccs.back() += "-gcc";

452 Gccs.emplace_back(T.getArchName());

453 Gccs.back() += "-w64-mingw32-gcc";

454 Gccs.emplace_back(T.getArchName());

455 Gccs.back() += "-w64-mingw32ucrt-gcc";

456 Gccs.emplace_back("mingw32-gcc");

457

458 for (StringRef CandidateGcc : Gccs)

459 if (llvm::ErrorOrstd::string GPPName = llvm::sys::findProgramByName(CandidateGcc))

460 return GPPName;

461 return make_error_code(std::errc::no_such_file_or_directory);

462}

463

464static llvm::ErrorOrstd::string

466 const llvm::Triple &T, std::string &SubdirName) {

468 Subdirs.emplace_back(LiteralTriple.str());

469 Subdirs.emplace_back(T.str());

470 Subdirs.emplace_back(T.getArchName());

471 Subdirs.back() += "-w64-mingw32";

472 Subdirs.emplace_back(T.getArchName());

473 Subdirs.back() += "-w64-mingw32ucrt";

474 StringRef ClangRoot = llvm::sys::path::parent_path(D.Dir);

475 StringRef Sep = llvm::sys::path::get_separator();

476 for (StringRef CandidateSubdir : Subdirs) {

477 if (llvm::sys::fs::is_directory(ClangRoot + Sep + CandidateSubdir)) {

478 SubdirName = std::string(CandidateSubdir);

479 return (ClangRoot + Sep + CandidateSubdir).str();

480 }

481 }

482 return make_error_code(std::errc::no_such_file_or_directory);

483}

484

486 StringRef Sep = llvm::sys::path::get_separator();

487 if (!llvm::sys::fs::exists(Directory + Sep + "include" + Sep + "_mingw.h"))

488 return false;

489 if (!llvm::sys::fs::exists(Directory + Sep + "lib" + Sep + "libkernel32.a"))

490 return false;

491 return true;

492}

493

495 const ArgList &Args)

496 : ToolChain(D, Triple, Args), CudaInstallation(D, Triple, Args),

497 RocmInstallation(D, Triple, Args) {

499

500 std::string InstallBase =

501 std::string(llvm::sys::path::parent_path(getDriver().Dir));

502

503

507

508

511 Base = std::string(llvm::sys::path::parent_path(TargetSubdir.get()));

512

513

514

516 Base = InstallBase;

517 else if (llvm::ErrorOrstd::string GPPName =

519 Base = std::string(llvm::sys::path::parent_path(

520 llvm::sys::path::parent_path(GPPName.get())));

521 else

522 Base = InstallBase;

523

524 Base += llvm::sys::path::get_separator();

525 findGccLibDir(LiteralTriple);

526 TripleDirName = SubdirName;

527

528

530

531

532 std::string CandidateSubdir = SubdirName + "/sys-root/mingw";

534 SubdirName = CandidateSubdir;

535

537 (Base + SubdirName + llvm::sys::path::get_separator() + "lib").str());

538

539

541 (Base + SubdirName + llvm::sys::path::get_separator() + "mingw/lib").str());

542

543

544

545

546

550

551 NativeLLVMSupport =

552 Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER)

553 .equals_insensitive("lld");

554}

555

557 switch (AC) {

563 if (!Compiler)

565 return Compiler.get();

566 default:

568 }

569}

570

573}

574

577}

578

580 return NativeLLVMSupport;

581}

582

585 Arg *ExceptionArg = Args.getLastArg(options::OPT_fsjlj_exceptions,

586 options::OPT_fseh_exceptions,

587 options::OPT_fdwarf_exceptions);

588 if (ExceptionArg &&

589 ExceptionArg->getOption().matches(options::OPT_fseh_exceptions))

590 return UnwindTableLevel::Asynchronous;

591

592 if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::arm ||

593 getArch() == llvm::Triple::thumb || getArch() == llvm::Triple::aarch64)

594 return UnwindTableLevel::Asynchronous;

595 return UnwindTableLevel::None;

596}

597

599 return getArch() == llvm::Triple::x86_64 ||

600 getArch() == llvm::Triple::aarch64;

601}

602

604 return false;

605}

606

608

609llvm::ExceptionHandling

611 if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::aarch64 ||

612 getArch() == llvm::Triple::arm || getArch() == llvm::Triple::thumb)

613 return llvm::ExceptionHandling::WinEH;

614 return llvm::ExceptionHandling::DwarfCFI;

615}

616

619 Res |= SanitizerKind::Address;

620 Res |= SanitizerKind::PointerCompare;

621 Res |= SanitizerKind::PointerSubtract;

622 Res |= SanitizerKind::Vptr;

623 return Res;

624}

625

627 ArgStringList &CC1Args) const {

628 CudaInstallation->AddCudaIncludeArgs(DriverArgs, CC1Args);

629}

630

632 ArgStringList &CC1Args) const {

633 RocmInstallation->AddHIPIncludeArgs(DriverArgs, CC1Args);

634}

635

637 CudaInstallation->print(OS);

638 RocmInstallation->print(OS);

639}

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

688 ArgStringList &CC1Args) const {

689 if (DriverArgs.hasArg(options::OPT_nostdinc))

690 return;

691

692 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {

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

695 addSystemInclude(DriverArgs, CC1Args, P.str());

696 }

697

698 if (DriverArgs.hasArg(options::OPT_nostdlibinc))

699 return;

700

701 addSystemInclude(DriverArgs, CC1Args,

702 Base + SubdirName + llvm::sys::path::get_separator() +

703 "include");

704

705

706 addSystemInclude(DriverArgs, CC1Args,

707 Base + SubdirName + llvm::sys::path::get_separator() + "usr/include");

708

709

710

711

712

714 getDriver().SysRoot.size())

715 addSystemInclude(DriverArgs, CC1Args, Base + "include");

716}

717

719 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,

721 if (Arg *A = DriverArgs.getLastArg(options::OPT_mguard_EQ)) {

722 StringRef GuardArgs = A->getValue();

723 if (GuardArgs == "none") {

724

725 } else if (GuardArgs == "cf") {

726

727 CC1Args.push_back("-cfguard");

728 } else if (GuardArgs == "cf-nochecks") {

729

730 CC1Args.push_back("-cfguard-no-checks");

731 } else {

732 getDriver().Diag(diag::err_drv_unsupported_option_argument)

733 << A->getSpelling() << GuardArgs;

734 }

735 }

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757 if (!DriverArgs.hasArgNoClaim(options::OPT_fsized_deallocation,

758 options::OPT_fno_sized_deallocation))

759 CC1Args.push_back("-fno-sized-deallocation");

760

761 CC1Args.push_back("-fno-use-init-array");

762

763 for (auto Opt : {options::OPT_mthreads, options::OPT_mwindows,

764 options::OPT_mconsole, options::OPT_mdll}) {

765 if (Arg *A = DriverArgs.getLastArgNoClaim(Opt))

766 A->ignoreTargetSpecific();

767 }

768}

769

771 const ArgList &DriverArgs, ArgStringList &CC1Args) const {

772 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,

773 options::OPT_nostdincxx))

774 return;

775

776 StringRef Slash = llvm::sys::path::get_separator();

777

778 switch (GetCXXStdlibType(DriverArgs)) {

780 std::string TargetDir = (Base + "include" + Slash + getTripleString() +

781 Slash + "c++" + Slash + "v1")

782 .str();

783 if (getDriver().getVFS().exists(TargetDir))

784 addSystemInclude(DriverArgs, CC1Args, TargetDir);

785 addSystemInclude(DriverArgs, CC1Args,

786 Base + SubdirName + Slash + "include" + Slash + "c++" +

787 Slash + "v1");

788 addSystemInclude(DriverArgs, CC1Args,

789 Base + "include" + Slash + "c++" + Slash + "v1");

790 break;

791 }

792

795 CppIncludeBases.emplace_back(Base);

796 llvm::sys::path::append(CppIncludeBases[0], SubdirName, "include", "c++");

797 CppIncludeBases.emplace_back(Base);

798 llvm::sys::path::append(CppIncludeBases[1], SubdirName, "include", "c++",

799 Ver);

800 CppIncludeBases.emplace_back(Base);

801 llvm::sys::path::append(CppIncludeBases[2], "include", "c++", Ver);

802 CppIncludeBases.emplace_back(GccLibDir);

803 llvm::sys::path::append(CppIncludeBases[3], "include", "c++");

804 CppIncludeBases.emplace_back(GccLibDir);

805 llvm::sys::path::append(CppIncludeBases[4], "include",

806 "g++-v" + GccVer.Text);

807 CppIncludeBases.emplace_back(GccLibDir);

808 llvm::sys::path::append(CppIncludeBases[5], "include",

809 "g++-v" + GccVer.MajorStr + "." + GccVer.MinorStr);

810 CppIncludeBases.emplace_back(GccLibDir);

811 llvm::sys::path::append(CppIncludeBases[6], "include",

812 "g++-v" + GccVer.MajorStr);

813 for (auto &CppIncludeBase : CppIncludeBases) {

814 addSystemInclude(DriverArgs, CC1Args, CppIncludeBase);

815 CppIncludeBase += Slash;

816 addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + TripleDirName);

817 addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + "backward");

818 }

819 break;

820 }

821}

822

824 const ArgList &Args) {

825

826

827 std::string SubdirName;

828 if (D.SysRoot.size())

829 return true;

831 std::string InstallBase = std::string(llvm::sys::path::parent_path(D.Dir));

832 if (llvm::ErrorOrstd::string TargetSubdir =

834 return true;

835

836

838 return false;

839 if (llvm::ErrorOrstd::string GPPName = findGcc(LiteralTriple, Triple))

840 return true;

841

842

843 return false;

844}

845

847 const ArgList &Args) {

848

849

851 return Triple;

853

854

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

856 Archs.emplace_back("i386");

857 Archs.emplace_back("i586");

858 Archs.emplace_back("i686");

859 } else if (Triple.getArch() == llvm::Triple::arm ||

860 Triple.getArch() == llvm::Triple::thumb) {

861 Archs.emplace_back("armv7");

862 }

863 for (auto A : Archs) {

864 llvm::Triple TestTriple(Triple);

865 TestTriple.setArchName(A);

867 return TestTriple;

868 }

869

870 return Triple;

871}

872

874 const ArgList &Args) {

875 if (Triple.getArch() == llvm::Triple::x86 ||

876 Triple.getArch() == llvm::Triple::arm ||

877 Triple.getArch() == llvm::Triple::thumb)

879}

static llvm::Triple getLiteralTriple(const Driver &D, const llvm::Triple &T)

static bool looksLikeMinGWSysroot(const std::string &Directory)

static bool findGccVersion(StringRef LibDir, std::string &GccLibDir, std::string &Ver, toolchains::Generic_GCC::GCCVersion &Version)

static bool testTriple(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)

static llvm::Triple adjustTriple(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)

static llvm::ErrorOr< std::string > findGcc(const llvm::Triple &LiteralTriple, const llvm::Triple &T)

static llvm::ErrorOr< std::string > findClangRelativeSysroot(const Driver &D, const llvm::Triple &LiteralTriple, const llvm::Triple &T, std::string &SubdirName)

static bool isCrossCompiling(const llvm::Triple &T, bool RequireArchMatch)

Engages in a tight little dance with the lexer to efficiently preprocess tokens.

Compilation - A set of tasks to perform for a single driver invocation.

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

std::string SysRoot

sysroot, if present

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

Compute the desired OpenMP runtime from the flags provided.

@ OMPRT_IOMP5

The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.

@ OMPRT_OMP

The LLVM OpenMP runtime.

@ OMPRT_Unknown

An unknown OpenMP runtime.

@ OMPRT_GOMP

The GNU OpenMP runtime.

InputInfo - Wrapper for information about an input source.

const char * getFilename() const

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

std::error_code make_error_code(BuildPreambleError Error)

const FunctionProtoType * T

static constexpr ResponseFileSupport None()

Returns a ResponseFileSupport indicating that response files are not supported.

static constexpr ResponseFileSupport AtFileUTF8()