FreeBSD.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 default:

44 break;

45 case llvm::Triple::x86:

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

47 break;

48 case llvm::Triple::ppc:

49 case llvm::Triple::ppcle:

50 CmdArgs.push_back("-a32");

51 break;

52 case llvm::Triple::mips:

53 case llvm::Triple::mipsel:

54 case llvm::Triple::mips64:

55 case llvm::Triple::mips64el: {

56 StringRef CPUName;

57 StringRef ABIName;

60 CmdArgs.push_back("-march");

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

63 CmdArgs.push_back("-mabi");

66 if (Triple.isLittleEndian())

67 CmdArgs.push_back("-EL");

68 else

69 CmdArgs.push_back("-EB");

71 if (Arg *A = Args.getLastArg(options::OPT_G)) {

72 StringRef v = A->getValue();

73 CmdArgs.push_back(Args.MakeArgString("-G" + v));

74 A->claim();

75 }

78 break;

79 }

80 case llvm::Triple::arm:

81 case llvm::Triple::armeb:

82 case llvm::Triple::thumb:

83 case llvm::Triple::thumbeb: {

87 CmdArgs.push_back("-mfpu=vfp");

88 else

89 CmdArgs.push_back("-mfpu=softvfp");

91 CmdArgs.push_back("-meabi=5");

92 break;

93 }

94 case llvm::Triple::sparcv9: {

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

98 break;

99 }

100 }

101

102 for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,

103 options::OPT_fdebug_prefix_map_EQ)) {

104 StringRef Map = A->getValue();

105 if (!Map.contains('='))

106 D.Diag(diag::err_drv_invalid_argument_to_option)

107 << Map << A->getOption().getName();

108 else {

109 CmdArgs.push_back(Args.MakeArgString("--debug-prefix-map"));

110 CmdArgs.push_back(Args.MakeArgString(Map));

111 }

112 A->claim();

113 }

114

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

116

117 CmdArgs.push_back("-o");

119

120 for (const auto &II : Inputs)

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

122

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

126 Exec, CmdArgs, Inputs, Output));

127}

128

132 const ArgList &Args,

133 const char *LinkingOutput) const {

134 const auto &ToolChain = static_cast<const FreeBSD &>(getToolChain());

138 const bool IsPIE =

139 !Args.hasArg(options::OPT_shared) &&

141 ArgStringList CmdArgs;

142

143

144 Args.ClaimAllArgs(options::OPT_g_Group);

145

146 Args.ClaimAllArgs(options::OPT_emit_llvm);

147

148

149 Args.ClaimAllArgs(options::OPT_w);

150

151 if (.SysRoot.empty())

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

153

154 if (IsPIE)

155 CmdArgs.push_back("-pie");

156

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

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

159 CmdArgs.push_back("-Bstatic");

160 } else {

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

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

163 if (Args.hasArg(options::OPT_shared)) {

164 CmdArgs.push_back("-shared");

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

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

167 CmdArgs.push_back("/libexec/ld-elf.so.1");

168 }

169 if (Arch == llvm::Triple::arm || Triple.isX86())

170 CmdArgs.push_back("--hash-style=both");

171 CmdArgs.push_back("--enable-new-dtags");

172 }

173

174

175

176 switch (Arch) {

177 case llvm::Triple::x86:

178 CmdArgs.push_back("-m");

179 CmdArgs.push_back("elf_i386_fbsd");

180 break;

181 case llvm::Triple::ppc:

182 CmdArgs.push_back("-m");

183 CmdArgs.push_back("elf32ppc_fbsd");

184 break;

185 case llvm::Triple::ppcle:

186 CmdArgs.push_back("-m");

187

188 CmdArgs.push_back("elf32lppc");

189 break;

190 case llvm::Triple::mips:

191 CmdArgs.push_back("-m");

192 CmdArgs.push_back("elf32btsmip_fbsd");

193 break;

194 case llvm::Triple::mipsel:

195 CmdArgs.push_back("-m");

196 CmdArgs.push_back("elf32ltsmip_fbsd");

197 break;

198 case llvm::Triple::mips64:

199 CmdArgs.push_back("-m");

201 CmdArgs.push_back("elf32btsmipn32_fbsd");

202 else

203 CmdArgs.push_back("elf64btsmip_fbsd");

204 break;

205 case llvm::Triple::mips64el:

206 CmdArgs.push_back("-m");

208 CmdArgs.push_back("elf32ltsmipn32_fbsd");

209 else

210 CmdArgs.push_back("elf64ltsmip_fbsd");

211 break;

212 case llvm::Triple::riscv64:

213 CmdArgs.push_back("-m");

214 CmdArgs.push_back("elf64lriscv");

215 break;

216 case llvm::Triple::loongarch32:

217 CmdArgs.push_back("-m");

218 CmdArgs.push_back("elf32loongarch");

219 break;

220 case llvm::Triple::loongarch64:

221 CmdArgs.push_back("-m");

222 CmdArgs.push_back("elf64loongarch");

223 break;

224 default:

225 break;

226 }

227

228 if (Triple.isLoongArch64() || Triple.isRISCV64()) {

229 CmdArgs.push_back("-X");

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

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

232 }

233

234 if (Arg *A = Args.getLastArg(options::OPT_G)) {

236 StringRef v = A->getValue();

237 CmdArgs.push_back(Args.MakeArgString("-G" + v));

238 A->claim();

239 }

240 }

241

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

244 CmdArgs.push_back("-o");

246 }

247

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

249 options::OPT_r)) {

250 const char *crt1 = nullptr;

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

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

253 crt1 = "gcrt1.o";

254 else if (IsPIE)

255 crt1 = "Scrt1.o";

256 else

257 crt1 = "crt1.o";

258 }

259 if (crt1)

261

263

264 const char *crtbegin = nullptr;

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

266 crtbegin = "crtbeginT.o";

267 else if (Args.hasArg(options::OPT_shared) || IsPIE)

268 crtbegin = "crtbeginS.o";

269 else

270 crtbegin = "crtbegin.o";

271

273 }

274

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

277 Args.addAllArgs(CmdArgs,

278 {options::OPT_T_Group, options::OPT_s, options::OPT_t});

279

280 if (D.isUsingLTO()) {

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

282

283 auto Input = llvm::find_if(

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

286

287

288 Input = Inputs.begin();

289

292 }

293

298

300 bool Profiling = Args.hasArg(options::OPT_pg) && Major != 0 && Major < 14;

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

302 options::OPT_r)) {

303

304 bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) &&

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

307

308 if (D.CCCIsCXX()) {

311 if (Profiling)

312 CmdArgs.push_back("-lm_p");

313 else

314 CmdArgs.push_back("-lm");

315 }

316

317

318 Args.ClaimAllArgs(options::OPT_stdlib_EQ);

319

320

321

322

323

324 if (D.IsFlangMode() &&

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

328 if (Profiling)

329 CmdArgs.push_back("-lm_p");

330 else

331 CmdArgs.push_back("-lm");

332 }

333

334 if (NeedsSanitizerDeps)

336 if (NeedsXRayDeps)

338

339

340 if (Profiling)

341 CmdArgs.push_back("-lgcc_p");

342 else

343 CmdArgs.push_back("-lgcc");

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

345 CmdArgs.push_back("-lgcc_eh");

346 } else if (Profiling) {

347 CmdArgs.push_back("-lgcc_eh_p");

348 } else {

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

350 CmdArgs.push_back("-lgcc_s");

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

352 }

353

354 if (Args.hasArg(options::OPT_pthread)) {

355 if (Profiling)

356 CmdArgs.push_back("-lpthread_p");

357 else

358 CmdArgs.push_back("-lpthread");

359 }

360

361 if (Profiling) {

362 if (Args.hasArg(options::OPT_shared))

363 CmdArgs.push_back("-lc");

364 else

365 CmdArgs.push_back("-lc_p");

366 CmdArgs.push_back("-lgcc_p");

367 } else {

368 CmdArgs.push_back("-lc");

369 CmdArgs.push_back("-lgcc");

370 }

371

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

373 CmdArgs.push_back("-lgcc_eh");

374 } else if (Profiling) {

375 CmdArgs.push_back("-lgcc_eh_p");

376 } else {

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

378 CmdArgs.push_back("-lgcc_s");

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

380 }

381 }

382

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

384 options::OPT_r)) {

385 const char *crtend = nullptr;

386 if (Args.hasArg(options::OPT_shared) || IsPIE)

387 crtend = "crtendS.o";

388 else

389 crtend = "crtend.o";

392 }

393

395

396 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());

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

399 Exec, CmdArgs, Inputs, Output));

400}

401

402

403

405 const ArgList &Args)

407

408

409

410 if (Triple.isArch32Bit() &&

411 D.getVFS().exists(concat(getDriver().SysRoot, "/usr/lib32/crt1.o")))

413 else

415}

416

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

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

421

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

423 return;

424

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

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

429 }

430

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

432 return;

433

434

435 StringRef CIncludeDirs(C_INCLUDE_DIRS);

436 if (CIncludeDirs != "") {

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

439 for (StringRef dir : dirs) {

440 StringRef Prefix =

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

443 }

444 return;

445 }

446

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

449}

450

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

455}

456

458 ArgStringList &CmdArgs) const {

459 unsigned Major = getTriple().getOSMajorVersion();

460 bool Profiling = Args.hasArg(options::OPT_pg) && Major != 0 && Major < 14;

461

462 CmdArgs.push_back(Profiling ? "-lc++_p" : "-lc++");

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

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

465}

466

468 ArgStringList &CC1Args) const {

470}

471

473 ArgStringList &CC1Args) const {

475}

476

479}

480

482

484

488}

489

492}

493

495 const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64;

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

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

498 const bool IsMIPS64 = getTriple().isMIPS64();

500 Res |= SanitizerKind::Address;

501 Res |= SanitizerKind::PointerCompare;

502 Res |= SanitizerKind::PointerSubtract;

503 Res |= SanitizerKind::Vptr;

504 if (IsAArch64 || IsX86_64 || IsMIPS64) {

505 Res |= SanitizerKind::Leak;

506 Res |= SanitizerKind::Thread;

507 }

508 if (IsAArch64 || IsX86 || IsX86_64) {

509 Res |= SanitizerKind::SafeStack;

510 Res |= SanitizerKind::Fuzzer;

511 Res |= SanitizerKind::FuzzerNoLink;

512 }

513 if (IsAArch64 || IsX86_64) {

514 Res |= SanitizerKind::KernelAddress;

515 Res |= SanitizerKind::KernelMemory;

516 Res |= SanitizerKind::Memory;

517 }

518 return Res;

519}

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

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

static constexpr ResponseFileSupport AtFileCurCP()