NetBSD.cpp Source File (original) (raw)

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

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

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

25using namespace clang;

31 const ArgList &Args,

32 const char *LinkingOutput) const {

36 ArgStringList CmdArgs;

43 case llvm::Triple::x86:

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

45 break;

46 case llvm::Triple::arm:

47 case llvm::Triple::armeb:

48 case llvm::Triple::thumb:

49 case llvm::Triple::thumbeb: {

50 StringRef MArch, MCPU;

53 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + Arch));

54 break;

55 }

57 case llvm::Triple::mips:

58 case llvm::Triple::mipsel:

59 case llvm::Triple::mips64:

60 case llvm::Triple::mips64el: {

61 StringRef CPUName;

62 StringRef ABIName;

65 CmdArgs.push_back("-march");

66 CmdArgs.push_back(CPUName.data());

68 CmdArgs.push_back("-mabi");

71 if (Triple.isLittleEndian())

72 CmdArgs.push_back("-EL");

73 else

74 CmdArgs.push_back("-EB");

77 break;

78 }

80 case llvm::Triple::sparc: {

81 CmdArgs.push_back("-32");

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

85 break;

86 }

88 case llvm::Triple::sparcv9: {

89 CmdArgs.push_back("-64");

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

93 break;

94 }

96 default:

97 break;

98 }

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

101

102 CmdArgs.push_back("-o");

104

105 for (const auto &II : Inputs)

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

107

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

111 Exec, CmdArgs, Inputs, Output));

112}

113

117 const ArgList &Args,

118 const char *LinkingOutput) const {

119 const auto &ToolChain = static_cast<const NetBSD &>(getToolChain());

123 const bool Static = Args.hasArg(options::OPT_static);

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

125 const bool Pie = Args.hasArg(options::OPT_pie);

126 ArgStringList CmdArgs;

127

128 if (.SysRoot.empty())

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

130

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

133 CmdArgs.push_back("-Bstatic");

134 if (Pie) {

135 Args.AddAllArgs(CmdArgs, options::OPT_pie);

136 CmdArgs.push_back("--no-dynamic-linker");

137 }

138 } else {

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

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

141 if (Shared) {

142 CmdArgs.push_back("-shared");

143 } else if (!Args.hasArg(options::OPT_r)) {

144 Args.AddAllArgs(CmdArgs, options::OPT_pie);

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

146 CmdArgs.push_back("/libexec/ld.elf_so");

147 }

148 }

149

150

151

152 switch (Arch) {

153 case llvm::Triple::x86:

154 CmdArgs.push_back("-m");

155 CmdArgs.push_back("elf_i386");

156 break;

157 case llvm::Triple::arm:

158 case llvm::Triple::thumb:

159 CmdArgs.push_back("-m");

160 switch (Triple.getEnvironment()) {

161 case llvm::Triple::EABI:

162 case llvm::Triple::GNUEABI:

163 CmdArgs.push_back("armelf_nbsd_eabi");

164 break;

165 case llvm::Triple::EABIHF:

166 case llvm::Triple::GNUEABIHF:

167 CmdArgs.push_back("armelf_nbsd_eabihf");

168 break;

169 default:

170 CmdArgs.push_back("armelf_nbsd");

171 break;

172 }

173 break;

174 case llvm::Triple::armeb:

175 case llvm::Triple::thumbeb:

177 CmdArgs.push_back("-m");

178 switch (Triple.getEnvironment()) {

179 case llvm::Triple::EABI:

180 case llvm::Triple::GNUEABI:

181 CmdArgs.push_back("armelfb_nbsd_eabi");

182 break;

183 case llvm::Triple::EABIHF:

184 case llvm::Triple::GNUEABIHF:

185 CmdArgs.push_back("armelfb_nbsd_eabihf");

186 break;

187 default:

188 CmdArgs.push_back("armelfb_nbsd");

189 break;

190 }

191 break;

192 case llvm::Triple::mips64:

193 case llvm::Triple::mips64el:

195 CmdArgs.push_back("-m");

196 if (Arch == llvm::Triple::mips64)

197 CmdArgs.push_back("elf32btsmip");

198 else

199 CmdArgs.push_back("elf32ltsmip");

201 CmdArgs.push_back("-m");

202 if (Arch == llvm::Triple::mips64)

203 CmdArgs.push_back("elf64btsmip");

204 else

205 CmdArgs.push_back("elf64ltsmip");

206 }

207 break;

208 case llvm::Triple::ppc:

209 CmdArgs.push_back("-m");

210 CmdArgs.push_back("elf32ppc_nbsd");

211 break;

212

213 case llvm::Triple::ppc64:

214 case llvm::Triple::ppc64le:

215 CmdArgs.push_back("-m");

216 CmdArgs.push_back("elf64ppc");

217 break;

218

219 case llvm::Triple::riscv32:

220 CmdArgs.push_back("-m");

221 CmdArgs.push_back("elf32lriscv");

222 break;

223

224 case llvm::Triple::riscv64:

225 CmdArgs.push_back("-m");

226 CmdArgs.push_back("elf64lriscv");

227 break;

228

229 case llvm::Triple::sparc:

230 CmdArgs.push_back("-m");

231 CmdArgs.push_back("elf32_sparc");

232 break;

233

234 case llvm::Triple::sparcv9:

235 CmdArgs.push_back("-m");

236 CmdArgs.push_back("elf64_sparc");

237 break;

238

239 default:

240 break;

241 }

242

243 if (Triple.isRISCV()) {

244 CmdArgs.push_back("-X");

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

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

247 }

248

249 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");

251 CmdArgs.push_back("-o");

253 }

254

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

256 options::OPT_r)) {

257 const char *crt0 = nullptr;

258 const char *crtbegin = nullptr;

259 if (!Shared)

260 crt0 = "crt0.o";

261

262 if (Shared || Pie)

263 crtbegin = "crtbeginS.o";

264 else

265 crtbegin = "crtbegin.o";

266

267 if (crt0)

271 }

272

273 Args.addAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,

274 options::OPT_s, options::OPT_t});

276

280

283 CmdArgs.push_back("-rpath");

285 }

286

287 bool useLibgcc = true;

289 case llvm::Triple::aarch64:

290 case llvm::Triple::aarch64_be:

291 case llvm::Triple::arm:

292 case llvm::Triple::armeb:

293 case llvm::Triple::thumb:

294 case llvm::Triple::thumbeb:

295 case llvm::Triple::ppc:

296 case llvm::Triple::ppc64:

297 case llvm::Triple::ppc64le:

298 case llvm::Triple::riscv32:

299 case llvm::Triple::riscv64:

300 case llvm::Triple::sparc:

301 case llvm::Triple::sparcv9:

302 case llvm::Triple::x86:

303 case llvm::Triple::x86_64:

304 useLibgcc = false;

305 break;

306 default:

307 break;

308 }

309

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

311 options::OPT_r)) {

312

313 bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) && Static ;

315

316 if (D.CCCIsCXX()) {

319 CmdArgs.push_back("-lm");

320 }

321

322

323 Args.ClaimAllArgs(options::OPT_stdlib_EQ);

324

325

326

327

328

329 if (D.IsFlangMode() &&

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

333 CmdArgs.push_back("-lm");

334 }

335

336 if (NeedsSanitizerDeps)

338 if (NeedsXRayDeps)

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

341 CmdArgs.push_back("-lpthread");

342 CmdArgs.push_back("-lc");

343

344 if (useLibgcc) {

346

347

348

349 CmdArgs.push_back("-lgcc_eh");

350 CmdArgs.push_back("-lc");

351 CmdArgs.push_back("-lgcc");

352 } else {

353 CmdArgs.push_back("-lgcc");

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

355 CmdArgs.push_back("-lgcc_s");

356 CmdArgs.push_back("--no-as-needed");

357 }

358 }

359 }

360

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

362 options::OPT_r)) {

363 const char *crtend = nullptr;

364 if (Shared || Pie)

365 crtend = "crtendS.o";

366 else

367 crtend = "crtend.o";

368

371 }

372

374

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

378 Exec, CmdArgs, Inputs, Output));

379}

380

381

382

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

386

387

388

389

390

391 switch (Triple.getArch()) {

392 case llvm::Triple::x86:

394 break;

395 case llvm::Triple::arm:

396 case llvm::Triple::armeb:

397 case llvm::Triple::thumb:

398 case llvm::Triple::thumbeb:

399 switch (Triple.getEnvironment()) {

400 case llvm::Triple::EABI:

401 case llvm::Triple::GNUEABI:

403 break;

404 case llvm::Triple::EABIHF:

405 case llvm::Triple::GNUEABIHF:

407 break;

408 default:

410 break;

411 }

412 break;

413 case llvm::Triple::mips64:

414 case llvm::Triple::mips64el:

419 break;

420 case llvm::Triple::ppc:

422 break;

423 case llvm::Triple::sparc:

425 break;

426 default:

427 break;

428 }

429

431 }

432}

433

436}

437

439

442 case llvm::Triple::aarch64:

443 case llvm::Triple::aarch64_be:

444 case llvm::Triple::arm:

445 case llvm::Triple::armeb:

446 case llvm::Triple::thumb:

447 case llvm::Triple::thumbeb:

448 case llvm::Triple::ppc:

449 case llvm::Triple::ppc64:

450 case llvm::Triple::ppc64le:

451 case llvm::Triple::riscv32:

452 case llvm::Triple::riscv64:

453 case llvm::Triple::sparc:

454 case llvm::Triple::sparcv9:

455 case llvm::Triple::x86:

456 case llvm::Triple::x86_64:

458 default:

459 break;

460 }

462}

463

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

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

468

469 if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc))

470 return;

471

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

474 llvm::sys::path::append(Dir, "include");

476 }

477

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

479 return;

480

481

482 StringRef CIncludeDirs(C_INCLUDE_DIRS);

483 if (CIncludeDirs != "") {

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

486 for (StringRef dir : dirs) {

487 StringRef Prefix =

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

490 }

491 return;

492 }

493

495 concat(D.SysRoot, "/usr/include"));

496}

497

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

500 const std::string Candidates[] = {

501

503

505

507 };

508

509 for (const auto &IncludePath : Candidates) {

510 if ( getVFS ().exists(IncludePath + "/__config"))

511 continue;

512

513

515 return;

516 }

517}

518

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

522 DriverArgs, CC1Args);

523}

524

526

527 llvm::Triple::ArchType TArch = getTriple().getArch();

528 if (TArch == llvm::Triple::arm || TArch == llvm::Triple::armeb ||

529 TArch == llvm::Triple::thumb || TArch == llvm::Triple::thumbeb)

530 return llvm::ExceptionHandling::DwarfCFI;

531 return llvm::ExceptionHandling::None;

532}

533

535 const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;

536 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;

538 if (IsX86 || IsX86_64) {

539 Res |= SanitizerKind::Address;

540 Res |= SanitizerKind::PointerCompare;

541 Res |= SanitizerKind::PointerSubtract;

542 Res |= SanitizerKind::Leak;

543 Res |= SanitizerKind::SafeStack;

544 Res |= SanitizerKind::Scudo;

545 Res |= SanitizerKind::Vptr;

546 }

547 if (IsX86_64) {

548 Res |= SanitizerKind::DataFlow;

549 Res |= SanitizerKind::Fuzzer;

550 Res |= SanitizerKind::FuzzerNoLink;

551 Res |= SanitizerKind::HWAddress;

552 Res |= SanitizerKind::KernelAddress;

553 Res |= SanitizerKind::KernelHWAddress;

554 Res |= SanitizerKind::KernelMemory;

555 Res |= SanitizerKind::Memory;

556 Res |= SanitizerKind::Thread;

557 }

558 return Res;

559}

560

562 ArgStringList &CC1Args,

566 CC1Args.push_back("-D_REENTRANT");

567}

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

InputInfo - Wrapper for information about an input source.

const char * getFilename() const

bool hasAnySanitizer() const

bool needsSharedRt() const

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

static constexpr ResponseFileSupport AtFileCurCP()