OpenBSD.cpp Source File (original) (raw)

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

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

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

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

25using namespace clang;

31 const ArgList &Args,

32 const char *LinkingOutput) const {

36 ArgStringList CmdArgs;

41 case llvm::Triple::x86:

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

45 break;

47 case llvm::Triple::arm: {

48 StringRef MArch, MCPU;

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

52 break;

53 }

55 case llvm::Triple::ppc:

56 CmdArgs.push_back("-mppc");

57 CmdArgs.push_back("-many");

58 break;

60 case llvm::Triple::sparcv9: {

61 CmdArgs.push_back("-64");

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

65 break;

66 }

68 case llvm::Triple::mips64:

69 case llvm::Triple::mips64el: {

70 StringRef CPUName;

71 StringRef ABIName;

74 CmdArgs.push_back("-march");

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

77 CmdArgs.push_back("-mabi");

80 if (Triple.isLittleEndian())

81 CmdArgs.push_back("-EL");

82 else

83 CmdArgs.push_back("-EB");

86 break;

87 }

89 default:

90 break;

91 }

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

95 CmdArgs.push_back("-o");

98 for (const auto &II : Inputs)

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

100

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

104 Exec, CmdArgs, Inputs, Output));

105}

106

110 const ArgList &Args,

111 const char *LinkingOutput) const {

112 const auto &ToolChain = static_cast<const OpenBSD &>(getToolChain());

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

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

118 const bool Profiling = Args.hasArg(options::OPT_pg);

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

120 const bool Nopie = Args.hasArg(options::OPT_no_pie, options::OPT_nopie);

121 const bool Relocatable = Args.hasArg(options::OPT_r);

122 ArgStringList CmdArgs;

123

124

125 Args.ClaimAllArgs(options::OPT_g_Group);

126

127 Args.ClaimAllArgs(options::OPT_emit_llvm);

128

129

130 Args.ClaimAllArgs(options::OPT_w);

131

132 if (.SysRoot.empty())

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

134

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

136 CmdArgs.push_back("-EB");

137 else if (Arch == llvm::Triple::mips64el)

138 CmdArgs.push_back("-EL");

139

140 if (!Args.hasArg(options::OPT_nostdlib) && !Shared && !Relocatable) {

141 CmdArgs.push_back("-e");

142 CmdArgs.push_back("__start");

143 }

144

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

147 CmdArgs.push_back("-Bstatic");

148 } else {

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

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

151 if (Shared) {

152 CmdArgs.push_back("-shared");

153 } else if (!Relocatable) {

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

155 CmdArgs.push_back("/usr/libexec/ld.so");

156 }

157 }

158

159 if (Pie)

160 CmdArgs.push_back("-pie");

161 if (Nopie || Profiling)

162 CmdArgs.push_back("-nopie");

163

164 if (Triple.isRISCV64()) {

165 CmdArgs.push_back("-X");

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

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

168 }

169

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

172 CmdArgs.push_back("-o");

174 }

175

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

177 options::OPT_r)) {

178 const char *crt0 = nullptr;

179 const char *crtbegin = nullptr;

180 if (!Shared) {

181 if (Profiling)

182 crt0 = "gcrt0.o";

183 else if (Static && !Nopie)

184 crt0 = "rcrt0.o";

185 else

186 crt0 = "crt0.o";

187 crtbegin = "crtbegin.o";

188 } else {

189 crtbegin = "crtbeginS.o";

190 }

191

192 if (crt0)

195 }

196

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

199 Args.addAllArgs(CmdArgs,

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

201

202 if (D.isUsingLTO()) {

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

204

205 auto Input = llvm::find_if(

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

208

209

210 Input = Inputs.begin();

211

214 }

215

219

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

221 options::OPT_r)) {

222

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

225

226 if (D.CCCIsCXX()) {

229 if (Profiling)

230 CmdArgs.push_back("-lm_p");

231 else

232 CmdArgs.push_back("-lm");

233 }

234

235

236 Args.ClaimAllArgs(options::OPT_stdlib_EQ);

237

238

239

240

241

242 if (D.IsFlangMode() &&

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

246 if (Profiling)

247 CmdArgs.push_back("-lm_p");

248 else

249 CmdArgs.push_back("-lm");

250 }

251

252 if (NeedsSanitizerDeps) {

255 }

256 if (NeedsXRayDeps) {

259 }

260

261

262 CmdArgs.push_back("-lcompiler_rt");

263

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

265 if (!Shared && Profiling)

266 CmdArgs.push_back("-lpthread_p");

267 else

268 CmdArgs.push_back("-lpthread");

269 }

270

271 if (!Shared) {

272 if (Profiling)

273 CmdArgs.push_back("-lc_p");

274 else

275 CmdArgs.push_back("-lc");

276 }

277

278 CmdArgs.push_back("-lcompiler_rt");

279 }

280

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

282 options::OPT_r)) {

283 const char *crtend = nullptr;

284 if (!Shared)

285 crtend = "crtend.o";

286 else

287 crtend = "crtendS.o";

288

290 }

291

293

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

297 Exec, CmdArgs, Inputs, Output));

298}

299

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

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

304 if (IsX86 || IsX86_64) {

305 Res |= SanitizerKind::Vptr;

306 Res |= SanitizerKind::Fuzzer;

307 Res |= SanitizerKind::FuzzerNoLink;

308 }

309 if (IsX86_64) {

310 Res |= SanitizerKind::KernelAddress;

311 }

312 return Res;

313}

314

315

316

318 const ArgList &Args)

321}

322

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

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

327

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

329 return;

330

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

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

335 }

336

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

338 return;

339

340

341 StringRef CIncludeDirs(C_INCLUDE_DIRS);

342 if (CIncludeDirs != "") {

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

345 for (StringRef dir : dirs) {

346 StringRef Prefix =

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

349 }

350 return;

351 }

352

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

355}

356

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

361}

362

364 ArgStringList &CmdArgs) const {

365 bool Profiling = Args.hasArg(options::OPT_pg);

366

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

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

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

370 CmdArgs.push_back(Profiling ? "-lc++abi_p" : "-lc++abi");

371 CmdArgs.push_back(Profiling ? "-lpthread_p" : "-lpthread");

372}

373

376 if (Component == "builtins") {

378 llvm::sys::path::append(Path, "/usr/lib/libcompiler_rt.a");

380 return std::string(Path);

381 }

383 std::string CRTBasename =

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

386

388 return std::string(P);

390}

391

394}

395

397

399

403 case llvm::Triple::arm:

405 default:

407 }

408}

The base class of the type hierarchy.

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