Fuchsia.cpp Source File (original) (raw)

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

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

19#include "llvm/ProfileData/InstrProf.h"

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

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

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

27using namespace clang;

35 const ArgList &Args,

36 const char *LinkingOutput) const {

42 ArgStringList CmdArgs;

45 Args.ClaimAllArgs(options::OPT_g_Group);

47 Args.ClaimAllArgs(options::OPT_emit_llvm);

50 Args.ClaimAllArgs(options::OPT_w);

52 CmdArgs.push_back("-z");

53 CmdArgs.push_back("max-page-size=4096");

55 CmdArgs.push_back("-z");

56 CmdArgs.push_back("now");

58 CmdArgs.push_back("-z");

59 CmdArgs.push_back("start-stop-visibility=hidden");

62 if (llvm::sys::path::filename(Exec).equals_insensitive("ld.lld") ||

63 llvm::sys::path::stem(Exec).equals_insensitive("ld.lld")) {

64 CmdArgs.push_back("-z");

65 CmdArgs.push_back("rodynamic");

66 CmdArgs.push_back("-z");

67 CmdArgs.push_back("separate-loadable-segments");

68 CmdArgs.push_back("-z");

69 CmdArgs.push_back("rel");

70 CmdArgs.push_back("--pack-dyn-relocs=relr");

71 }

73 if (.SysRoot.empty())

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

76 if (!Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_r))

77 CmdArgs.push_back("-pie");

79 if (Args.hasArg(options::OPT_rdynamic))

80 CmdArgs.push_back("-export-dynamic");

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

83 CmdArgs.push_back("-s");

85 if (Args.hasArg(options::OPT_r)) {

86 CmdArgs.push_back("-r");

87 } else {

88 CmdArgs.push_back("--build-id");

89 CmdArgs.push_back("--hash-style=gnu");

90 }

93 CmdArgs.push_back("--execute-only");

95 std::string CPU = getCPUName(D, Args, Triple);

96 if (CPU.empty() || CPU == "generic" || CPU == "cortex-a53")

97 CmdArgs.push_back("--fix-cortex-a53-843419");

98 }

100 CmdArgs.push_back("--eh-frame-hdr");

101

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

103 CmdArgs.push_back("-Bstatic");

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

105 CmdArgs.push_back("-shared");

106

108

109 if (!Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_r)) {

110 std::string Dyld = D.DyldPrefix;

112 Dyld += "asan/";

114 Dyld += "hwasan/";

116 Dyld += "tsan/";

117 Dyld += "ld.so.1";

118 CmdArgs.push_back("-dynamic-linker");

119 CmdArgs.push_back(Args.MakeArgString(Dyld));

120 }

121

122 if (Triple.isRISCV64()) {

123 CmdArgs.push_back("-X");

124 if (Args.hasArg(options::OPT_mno_relax))

125 CmdArgs.push_back("--no-relax");

126 }

127

128 CmdArgs.push_back("-o");

130

131 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles,

132 options::OPT_r)) {

133 if (!Args.hasArg(options::OPT_shared)) {

135 }

136 }

137

138 Args.addAllArgs(CmdArgs, {options::OPT_L, options::OPT_u});

139

141

142 if (D.isUsingLTO()) {

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

144

145 auto Input = llvm::find_if(

147 if (Input == Inputs.end())

148

149

150 Input = Inputs.begin();

151

154 }

155

158

159

160 bool NoLibc = Args.hasArg(options::OPT_nolibc);

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

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

163 bool Pthreads = Args.hasArg(options::OPT_pthread, options::OPT_pthreads);

164 bool SplitStack = Args.hasArg(options::OPT_fsplit_stack);

165 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs,

166 options::OPT_r)) {

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

168 CmdArgs.push_back("-Bdynamic");

169

170 if (D.CCCIsCXX()) {

172 CmdArgs.push_back("--push-state");

173 CmdArgs.push_back("--as-needed");

174 if (OnlyLibstdcxxStatic)

175 CmdArgs.push_back("-Bstatic");

177 if (OnlyLibstdcxxStatic)

178 CmdArgs.push_back("-Bdynamic");

179 CmdArgs.push_back("-lm");

180 CmdArgs.push_back("--pop-state");

181 }

182 }

183

184

185

186

188

190

192

194

195 if (Pthreads)

196 CmdArgs.push_back("-lpthread");

197

198 if (SplitStack)

199 CmdArgs.push_back("--wrap=pthread_create");

200

201 if (!NoLibc)

202 CmdArgs.push_back("-lc");

203 }

204

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

207 Exec, CmdArgs, Inputs, Output));

208}

209

213 const ArgList &Args,

214 const char *LinkingOutput) const {

215 const Driver &D = getToolChain().getDriver();

216

217

218 Args.ClaimAllArgs(options::OPT_g_Group);

219

220 Args.ClaimAllArgs(options::OPT_emit_llvm);

221

222

223 Args.ClaimAllArgs(options::OPT_w);

224

225 Args.ClaimAllArgs(options::OPT_stdlib_EQ);

226

227

228 ArgStringList CmdArgs;

229

230 CmdArgs.push_back("rcsD");

232

233 for (const auto &II : Inputs) {

234 if (II.isFilename()) {

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

236 }

237 }

238

239

240

241 const char *OutputFileName = Output.getFilename();

242 if (Output.isFilename() && llvm::sys::fs::exists(OutputFileName)) {

243 if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {

244 D.Diag(diag::err_drv_unable_to_remove_file) << EC.message();

245 return;

246 }

247 }

248

249 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());

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

252 Exec, CmdArgs, Inputs, Output));

253}

254

255

256

258 const ArgList &Args)

261

262 if (.SysRoot.empty()) {

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

266 }

267

268 auto FilePaths = [&](const Multilib &M) -> std::vectorstd::string {

269 std::vectorstd::string FP;

272 llvm::sys::path::append(P, M.gccSuffix());

273 FP.push_back(std::string(P));

274 }

275 return FP;

276 };

277

279

281 .flag("-fexceptions", true)

282 .flag("-fno-exceptions")

283 .makeMultilib());

284

286 .flag("-fsanitize=address")

287 .makeMultilib());

288

290 .flag("-fsanitize=address")

291 .flag("-fexceptions", true)

292 .flag("-fno-exceptions")

293 .makeMultilib());

294

295

297 .flag("-fsanitize=hwaddress")

298 .makeMultilib());

299

301 .flag("-fsanitize=hwaddress")

302 .flag("-fexceptions", true)

303 .flag("-fno-exceptions")

304 .makeMultilib());

305

307 .flag("-fc++-abi=itanium")

308 .makeMultilib());

309

311 std::vectorstd::string RD = FilePaths(M);

312 return llvm::all_of(RD, [&](std::string P) { return getVFS ().exists(P); });

313 });

314

316 bool Exceptions =

317 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions, true);

321 Flags);

323 "-fsanitize=hwaddress", Flags);

324

325 addMultilibFlag(Args.getLastArgValue(options::OPT_fcxx_abi_EQ) == "itanium",

326 "-fc++-abi=itanium", Flags);

327

329

331

334

338

340 }

341}

342

346 return Triple.str();

347}

348

350

353}

354

357 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_rtlib_EQ)) {

358 StringRef Value = A->getValue();

359 if (Value != "compiler-rt")

360 getDriver().Diag(clang::diag::err_drv_invalid_rtlib_name)

361 << A->getAsString(Args);

362 }

363

365}

366

368 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {

369 StringRef Value = A->getValue();

370 if (Value != "libc++")

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

372 << A->getAsString(Args);

373 }

374

376}

377

379 ArgStringList &CC1Args,

381 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,

382 options::OPT_fno_use_init_array, true))

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

384}

385

387 ArgStringList &CC1Args) const {

389

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

391 return;

392

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

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

397 }

398

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

400 return;

401

402

403 StringRef CIncludeDirs(C_INCLUDE_DIRS);

404 if (CIncludeDirs != "") {

406 CIncludeDirs.split(dirs, ":");

407 for (StringRef dir : dirs) {

408 StringRef Prefix =

409 llvm::sys::path::is_absolute(dir) ? "" : StringRef(D.SysRoot);

411 }

412 return;

413 }

414

415 if (.SysRoot.empty()) {

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

419 }

420}

421

423 ArgStringList &CC1Args) const {

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

425 options::OPT_nostdincxx))

426 return;

427

430

431 auto AddCXXIncludePath = [&](StringRef Path) {

433 if (Version.empty())

434 return;

435

436

440 llvm::sys::path::append(TargetDir, Target, M.gccSuffix(), "c++", Version);

441 if (getVFS().exists(TargetDir)) {

443 }

444 }

445

446

448 llvm::sys::path::append(TargetDir, Target, "c++", Version);

449 if (getVFS().exists(TargetDir))

451

452

454 llvm::sys::path::append(Dir, "c++", Version);

456 };

457

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

462 AddCXXIncludePath(P);

463 break;

464 }

465

466 default:

467 llvm_unreachable("invalid stdlib name");

468 }

469}

470

472 ArgStringList &CmdArgs) const {

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

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

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

478 break;

479

481 llvm_unreachable("invalid stdlib name");

482 }

483}

484

487 Res |= SanitizerKind::Address;

488 Res |= SanitizerKind::HWAddress;

489 Res |= SanitizerKind::PointerCompare;

490 Res |= SanitizerKind::PointerSubtract;

491 Res |= SanitizerKind::Fuzzer;

492 Res |= SanitizerKind::FuzzerNoLink;

493 Res |= SanitizerKind::Leak;

494 Res |= SanitizerKind::SafeStack;

495 Res |= SanitizerKind::Scudo;

496 Res |= SanitizerKind::Thread;

497 return Res;

498}

499

503 case llvm::Triple::aarch64:

504 case llvm::Triple::riscv64:

505 Res |= SanitizerKind::ShadowCallStack;

506 break;

507 case llvm::Triple::x86_64:

508 Res |= SanitizerKind::SafeStack;

509 break;

510 default:

511 break;

512 }

513 return Res;

514}

llvm::MachO::Target Target

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

DiagnosticBuilder Diag(unsigned DiagID) const

InputInfo - Wrapper for information about an input source.

const char * getFilename() const

This corresponds to a single GCC multilib, or a segment of one controlled by a command line flag.

bool select(const Driver &D, const Multilib::flags_list &Flags, llvm::SmallVectorImpl< Multilib > &, llvm::SmallVector< StringRef > *=nullptr) const

Select compatible variants,.

MultilibSet & setFilePathsCallback(IncludeDirsFunc F)

MultilibSet & FilterOut(FilterCallback F)

Filter out some subset of the Multilibs using a user defined callback.

const IncludeDirsFunc & filePathsCallback() const

void push_back(const Multilib &M)

Add a completed Multilib to the set.

This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.

const std::string & gccSuffix() const

Get the detected GCC installation path suffix for the multi-arch target variant.

std::vector< std::string > flags_list

bool needsHwasanRt() const

bool needsSharedRt() const

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

static constexpr ResponseFileSupport AtFileCurCP()