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::loongarch64:

217 CmdArgs.push_back("-m");

218 CmdArgs.push_back("elf64loongarch");

219 break;

220 default:

221 break;

222 }

223

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

225 CmdArgs.push_back("-X");

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

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

228 }

229

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

232 StringRef v = A->getValue();

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

234 A->claim();

235 }

236 }

237

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

240 CmdArgs.push_back("-o");

242 }

243

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

245 options::OPT_r)) {

246 const char *crt1 = nullptr;

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

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

249 crt1 = "gcrt1.o";

250 else if (IsPIE)

251 crt1 = "Scrt1.o";

252 else

253 crt1 = "crt1.o";

254 }

255 if (crt1)

257

259

260 const char *crtbegin = nullptr;

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

262 crtbegin = "crtbeginT.o";

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

264 crtbegin = "crtbeginS.o";

265 else

266 crtbegin = "crtbegin.o";

267

269 }

270

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

273 Args.addAllArgs(CmdArgs,

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

275

276 if (D.isUsingLTO()) {

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

278

279 auto Input = llvm::find_if(

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

282

283

284 Input = Inputs.begin();

285

288 }

289

294

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

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

298 options::OPT_r)) {

299

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

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

303

304 if (D.CCCIsCXX()) {

307 if (Profiling)

308 CmdArgs.push_back("-lm_p");

309 else

310 CmdArgs.push_back("-lm");

311 }

312

313

314 Args.ClaimAllArgs(options::OPT_stdlib_EQ);

315

316

317

318

319

320 if (D.IsFlangMode() &&

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

324 if (Profiling)

325 CmdArgs.push_back("-lm_p");

326 else

327 CmdArgs.push_back("-lm");

328 }

329

330 if (NeedsSanitizerDeps)

332 if (NeedsXRayDeps)

334

335

336 if (Profiling)

337 CmdArgs.push_back("-lgcc_p");

338 else

339 CmdArgs.push_back("-lgcc");

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

341 CmdArgs.push_back("-lgcc_eh");

342 } else if (Profiling) {

343 CmdArgs.push_back("-lgcc_eh_p");

344 } else {

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

346 CmdArgs.push_back("-lgcc_s");

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

348 }

349

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

351 if (Profiling)

352 CmdArgs.push_back("-lpthread_p");

353 else

354 CmdArgs.push_back("-lpthread");

355 }

356

357 if (Profiling) {

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

359 CmdArgs.push_back("-lc");

360 else

361 CmdArgs.push_back("-lc_p");

362 CmdArgs.push_back("-lgcc_p");

363 } else {

364 CmdArgs.push_back("-lc");

365 CmdArgs.push_back("-lgcc");

366 }

367

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

369 CmdArgs.push_back("-lgcc_eh");

370 } else if (Profiling) {

371 CmdArgs.push_back("-lgcc_eh_p");

372 } else {

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

374 CmdArgs.push_back("-lgcc_s");

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

376 }

377 }

378

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

380 options::OPT_r)) {

381 const char *crtend = nullptr;

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

383 crtend = "crtendS.o";

384 else

385 crtend = "crtend.o";

388 }

389

391

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

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

395 Exec, CmdArgs, Inputs, Output));

396}

397

398

399

401 const ArgList &Args)

403

404

405

406 if (Triple.isArch32Bit() &&

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

409 else

411}

412

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

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

417

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

419 return;

420

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

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

425 }

426

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

428 return;

429

430

431 StringRef CIncludeDirs(C_INCLUDE_DIRS);

432 if (CIncludeDirs != "") {

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

435 for (StringRef dir : dirs) {

436 StringRef Prefix =

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

439 }

440 return;

441 }

442

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

445}

446

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

451}

452

454 ArgStringList &CmdArgs) const {

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

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

457

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

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

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

461}

462

464 ArgStringList &CC1Args) const {

466}

467

469 ArgStringList &CC1Args) const {

471}

472

475}

476

478

480

484}

485

488}

489

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

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

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

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

496 Res |= SanitizerKind::Address;

497 Res |= SanitizerKind::PointerCompare;

498 Res |= SanitizerKind::PointerSubtract;

499 Res |= SanitizerKind::Vptr;

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

501 Res |= SanitizerKind::Leak;

502 Res |= SanitizerKind::Thread;

503 }

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

505 Res |= SanitizerKind::SafeStack;

506 Res |= SanitizerKind::Fuzzer;

507 Res |= SanitizerKind::FuzzerNoLink;

508 }

509 if (IsAArch64 || IsX86_64) {

510 Res |= SanitizerKind::KernelAddress;

511 Res |= SanitizerKind::KernelMemory;

512 Res |= SanitizerKind::Memory;

513 }

514 return Res;

515}

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()