Solaris.cpp Source File (original) (raw)

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

19#include "llvm/ADT/StringSwitch.h"

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

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

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

27using namespace clang;

33 const ArgList &Args,

34 const char *LinkingOutput) const {

37}

41 const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ);

43 return UseLinker == "bfd" || UseLinker == "gld";

44}

47 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_static) ||

48 Args.hasArg(options::OPT_r))

49 return false;

51 return Args.hasFlag(options::OPT_pie, options::OPT_no_pie,

53}

58 if (const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ)) {

59 StringRef UseLinker = A->getValue();

60 if (!UseLinker.empty()) {

61 if (llvm::sys::path::is_absolute(UseLinker) &&

62 llvm::sys::fs::can_execute(UseLinker))

63 return std::string(UseLinker);

66 if (UseLinker == "bfd" || UseLinker == "gld")

68 return "/usr/gnu/bin/ld";

71 if (UseLinker != "ld")

73 << A->getAsString(Args);

74 }

75 }

79}

84 const ArgList &Args,

85 const char *LinkingOutput) const {

91 ArgStringList CmdArgs;

94 if (!LinkerIsGnuLd)

95 CmdArgs.push_back("-C");

97 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared,

98 options::OPT_r)) {

99 CmdArgs.push_back("-e");

100 CmdArgs.push_back("_start");

101 }

102

103 if (IsPIE) {

104 if (LinkerIsGnuLd) {

105 CmdArgs.push_back("-pie");

106 } else {

107 CmdArgs.push_back("-z");

108 CmdArgs.push_back("type=pie");

109 }

110 }

111

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

113 CmdArgs.push_back("-Bstatic");

114 CmdArgs.push_back("-dn");

115 } else {

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

117 CmdArgs.push_back("-shared");

118

119

120

121 Args.ClaimAllArgs(options::OPT_pthread);

122 Args.ClaimAllArgs(options::OPT_pthreads);

123 }

124

125 if (LinkerIsGnuLd) {

126

127 switch (Arch) {

128 case llvm::Triple::x86:

129 CmdArgs.push_back("-m");

130 CmdArgs.push_back("elf_i386_sol2");

131 break;

132 case llvm::Triple::x86_64:

133 CmdArgs.push_back("-m");

134 CmdArgs.push_back("elf_x86_64_sol2");

135 break;

136 case llvm::Triple::sparc:

137 CmdArgs.push_back("-m");

138 CmdArgs.push_back("elf32_sparc_sol2");

139 break;

140 case llvm::Triple::sparcv9:

141 CmdArgs.push_back("-m");

142 CmdArgs.push_back("elf64_sparc_sol2");

143 break;

144 default:

145 break;

146 }

147

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

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

150

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

152 } else {

153

154 Args.ClaimAllArgs(options::OPT_rdynamic);

155 }

156

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

159 CmdArgs.push_back("-o");

161 }

162

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

164 options::OPT_r)) {

165 if (!Args.hasArg(options::OPT_shared))

167

169

170 const Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);

171 bool HaveAnsi = false;

173 if (Std) {

174 HaveAnsi = Std->getOption().matches(options::OPT_ansi);

175 if (!HaveAnsi)

177 }

178

179 const char *values_X = "values-Xa.o";

180

181 if (HaveAnsi || (LangStd && !LangStd->isGNUMode()))

182 values_X = "values-Xc.o";

184

185 const char *values_xpg = "values-xpg6.o";

186

188 values_xpg = "values-xpg4.o";

190

191 const char *crtbegin = nullptr;

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

193 crtbegin = "crtbeginS.o";

194 else

195 crtbegin = "crtbegin.o";

197

199 }

200

202

203 Args.addAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group});

204

207

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

209 options::OPT_r)) {

210

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

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

214

218 CmdArgs.push_back("-lm");

219 }

220

221 Args.ClaimAllArgs(options::OPT_stdlib_EQ);

222

223

224

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

229 CmdArgs.push_back("-lm");

230 }

231 if (Args.hasArg(options::OPT_fstack_protector) ||

232 Args.hasArg(options::OPT_fstack_protector_strong) ||

233 Args.hasArg(options::OPT_fstack_protector_all)) {

234

235 CmdArgs.push_back("-lssp_nonshared");

236 CmdArgs.push_back("-lssp");

237 }

238

239

240 if (Arch == llvm::Triple::sparc) {

242 CmdArgs.push_back("-latomic");

244 }

245

247 CmdArgs.push_back("-lc");

248

250 if (NeedsSanitizerDeps) {

252

253

254

255

256 if (Arch == llvm::Triple::x86_64 &&

259 !LinkerIsGnuLd) {

260 CmdArgs.push_back("-z");

261 CmdArgs.push_back("relax=transtls");

262 }

263 }

264

266 CmdArgs.push_back("-z");

267 CmdArgs.push_back("now");

268 }

269 }

270

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

272 options::OPT_r)) {

273 const char *crtend = nullptr;

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

275 crtend = "crtendS.o";

276 else

277 crtend = "crtend.o";

280 }

281

283

284 const char *Exec = Args.MakeArgString(getLinkerPath(Args));

286 Exec, CmdArgs, Inputs, Output));

287}

288

290 switch (Triple.getArch()) {

291 case llvm::Triple::x86:

292 case llvm::Triple::sparc:

293 default:

294 break;

295 case llvm::Triple::x86_64:

296 return "/amd64";

297 case llvm::Triple::sparcv9:

298 return "/sparcv9";

299 }

300 return "";

301}

302

303

304

306 const ArgList &Args)

308

310

314

315

319 Paths);

321 }

322

323

324

325 if (StringRef(D.Dir).starts_with(D.SysRoot))

327

328 addPathIfExists(D, D.SysRoot + "/usr/lib" + LibSuffix, Paths);

329}

330

332 const bool IsSparc = getTriple().getArch() == llvm::Triple::sparc;

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

335

336 if (IsSparc || IsX86) {

337 Res |= SanitizerKind::Address;

338 Res |= SanitizerKind::PointerCompare;

339 Res |= SanitizerKind::PointerSubtract;

340 }

341 Res |= SanitizerKind::SafeStack;

342 Res |= SanitizerKind::Vptr;

343 return Res;

344}

345

347

348 return llvm::StringSwitch<const char *>(getDriver().getPreferredLinker())

349 .Cases({"bfd", "gld"}, "/usr/gnu/bin/ld")

351}

352

356

358

360 ArgStringList &CC1Args) const {

362

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

364 return;

365

366 if (!DriverArgs.hasArg(options::OPT_nostdlibinc))

367 addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/local/include");

368

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

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

373 }

374

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

376 return;

377

378

379 StringRef CIncludeDirs(C_INCLUDE_DIRS);

380 if (CIncludeDirs != "") {

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

383 for (StringRef dir : dirs) {

384 StringRef Prefix =

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

387 }

388 return;

389 }

390

391

395 if (Callback) {

396 for (const auto &Path : Callback(GCCInstallation.getMultilib()))

398 DriverArgs, CC1Args, GCCInstallation.getInstallPath() + Path);

399 }

400 }

401

403}

404

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

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

408

409

411 return;

412

413

414

415

420

421

424 CC1Args);

425}

static StringRef getSolarisLibSuffix(const llvm::Triple &Triple)

Definition Solaris.cpp:289

static bool getPIE(const ArgList &Args, const ToolChain &TC)

Definition Solaris.cpp:46

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

bool IsFlangMode() const

Whether the driver should invoke flang for fortran inputs.

StringRef getPreferredLinker() const

bool CCCIsCXX() const

Whether the driver should follow g++ like behavior.

InputInfo - Wrapper for information about an input source.

const char * getFilename() const

std::function< std::vector< std::string >(const Multilib &M)> IncludeDirsFunc

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

const std::string & includeSuffix() const

Get the include directory suffix.

bool needsStatsRt() const

bool needsUbsanRt() const

bool requiresMinimalRuntime() const

bool needsSharedRt() const

SmallVector< InputInfo, 4 > InputInfoList

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

@ C

Languages that the frontend can parse and compile.

LangStandard - Information about the properties of a particular language standard.

static const LangStandard * getLangStandardForName(StringRef Name)

clang::Language getLanguage() const

Get the language that this standard describes.

bool isGNUMode() const

isGNUMode - Language includes GNU extensions.

bool isC99() const

isC99 - Language is a superset of C99.

static constexpr ResponseFileSupport None()

Returns a ResponseFileSupport indicating that response files are not supported.