CrossWindows.cpp Source File (original) (raw)

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

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

21using llvm::opt::ArgList;

22using llvm::opt::ArgStringList;

27 const char *LinkingOutput) const {

29 const auto &TC =

31 ArgStringList CmdArgs;

32 const char *Exec;

34 switch (TC.getArch()) {

35 default:

36 llvm_unreachable("unsupported architecture");

37 case llvm::Triple::arm:

38 case llvm::Triple::thumb:

39 case llvm::Triple::aarch64:

40 break;

41 case llvm::Triple::x86:

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

43 break;

44 case llvm::Triple::x86_64:

45 CmdArgs.push_back("--64");

46 break;

47 }

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

51 CmdArgs.push_back("-o");

54 for (const auto &Input : Inputs)

55 CmdArgs.push_back(Input.getFilename());

57 const std::string Assembler = TC.GetProgramPath("as");

58 Exec = Args.MakeArgString(Assembler);

61 Exec, CmdArgs, Inputs, Output));

62}

67 const char *LinkingOutput) const {

68 const auto &TC =

70 const llvm::Triple &T = TC.getTriple();

71 const Driver &D = TC.getDriver();

73 ArgStringList CmdArgs;

74 const char *Exec;

77 Args.ClaimAllArgs(options::OPT_g_Group);

79 Args.ClaimAllArgs(options::OPT_emit_llvm);

81 Args.ClaimAllArgs(options::OPT_w);

84 if (.SysRoot.empty())

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

87 if (Args.hasArg(options::OPT_pie))

88 CmdArgs.push_back("-pie");

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

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

91 if (Args.hasArg(options::OPT_s))

92 CmdArgs.push_back("--strip-all");

94 CmdArgs.push_back("-m");

95 switch (TC.getArch()) {

96 default:

97 D.Diag(diag::err_target_unknown_triple) << TC.getEffectiveTriple().str();

98 break;

99 case llvm::Triple::arm:

100 case llvm::Triple::thumb:

101

102 CmdArgs.push_back("thumb2pe");

103 break;

104 case llvm::Triple::aarch64:

105 CmdArgs.push_back("arm64pe");

106 break;

107 case llvm::Triple::x86:

108 CmdArgs.push_back("i386pe");

109 EntryPoint.append("_");

110 break;

111 case llvm::Triple::x86_64:

112 CmdArgs.push_back("i386pep");

113 break;

114 }

115

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

117 switch (T.getArch()) {

118 default:

119 llvm_unreachable("unsupported architecture");

120 case llvm::Triple::aarch64:

121 case llvm::Triple::arm:

122 case llvm::Triple::thumb:

123 case llvm::Triple::x86_64:

124 EntryPoint.append("_DllMainCRTStartup");

125 break;

126 case llvm::Triple::x86:

127 EntryPoint.append("_DllMainCRTStartup@12");

128 break;

129 }

130

131 CmdArgs.push_back("-shared");

132 CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"

133 : "-Bdynamic");

134

135 CmdArgs.push_back("--enable-auto-image-base");

136

137 CmdArgs.push_back("--entry");

138 CmdArgs.push_back(Args.MakeArgString(EntryPoint));

139 } else {

140 EntryPoint.append("mainCRTStartup");

141

142 CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"

143 : "-Bdynamic");

144

145 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {

146 CmdArgs.push_back("--entry");

147 CmdArgs.push_back(Args.MakeArgString(EntryPoint));

148 }

149

150

151 }

152

153

154 CmdArgs.push_back("--allow-multiple-definition");

155

156 CmdArgs.push_back("-o");

158

159 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {

161 llvm::sys::path::replace_extension(ImpLib, ".lib");

162

163 CmdArgs.push_back("--out-implib");

164 CmdArgs.push_back(Args.MakeArgString(ImpLib));

165 }

166

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

168 TC.AddFilePathLibArgs(Args, CmdArgs);

170

171 if (TC.ShouldLinkCXXStdlib(Args)) {

172 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&

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

174 if (StaticCXX)

175 CmdArgs.push_back("-Bstatic");

176 TC.AddCXXStdlibLibArgs(Args, CmdArgs);

177 if (StaticCXX)

178 CmdArgs.push_back("-Bdynamic");

179 }

180

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

182 if (!Args.hasArg(options::OPT_nodefaultlibs)) {

183

184 CmdArgs.push_back("-lmsvcrt");

186 }

187 }

188

189 if (TC.getSanitizerArgs(Args).needsAsanRt()) {

190

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

192 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));

193 } else {

194 for (const auto &Lib : {"asan_dynamic", "asan_dynamic_runtime_thunk"})

195 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));

196

197

198 CmdArgs.push_back(Args.MakeArgString("--undefined"));

199 CmdArgs.push_back(Args.MakeArgString(TC.getArch() == llvm::Triple::x86

200 ? "___asan_seh_interceptor"

201 : "__asan_seh_interceptor"));

202 }

203 }

204

205 Exec = Args.MakeArgString(TC.GetLinkerPath());

206

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

209 Exec, CmdArgs, Inputs, Output));

210}

211

213 const llvm::Triple &T,

214 const llvm::opt::ArgList &Args)

216

219

220

222}

223

225 return getArch() == llvm::Triple::x86_64;

226}

227

229 return getArch() == llvm::Triple::x86_64;

230}

231

233 return getArch() == llvm::Triple::x86_64;

234}

235

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

240 const std::string &SysRoot = D.SysRoot;

241

242 auto AddSystemAfterIncludes = [&]() {

243 for (const auto &P : DriverArgs.getAllArgValues(options::OPT_isystem_after))

245 };

246

247 if (DriverArgs.hasArg(options::OPT_nostdinc)) {

248 AddSystemAfterIncludes();

249 return;

250 }

251

252 addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");

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

255 llvm::sys::path::append(ResourceDir, "include");

257 }

258 AddSystemAfterIncludes();

260}

261

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

266

267 if (DriverArgs.hasArg(options::OPT_nostdinc) ||

268 DriverArgs.hasArg(options::OPT_nostdincxx))

269 return;

270

272 addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include/c++/v1");

273}

274

277 llvm::opt::ArgStringList &CmdArgs) const {

279 CmdArgs.push_back("-lc++");

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

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

282 }

283}

284

287 Res |= SanitizerKind::Address;

288 Res |= SanitizerKind::PointerCompare;

289 Res |= SanitizerKind::PointerSubtract;

290 return Res;

291}

292

295}

296

299}

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

std::string SysRoot

sysroot, if present

InputInfo - Wrapper for information about an input source.

const char * getFilename() const

const FunctionProtoType * T

static constexpr ResponseFileSupport None()

Returns a ResponseFileSupport indicating that response files are not supported.

static constexpr ResponseFileSupport AtFileUTF8()