1//===--- ZOS.cpp - z/OS ToolChain Implementations ---------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "ZOS.h"
10#include "clang/Driver/CommonArgs.h"
11#include "clang/Driver/Compilation.h"
12#include "clang/Options/Options.h"
13#include "llvm/Option/ArgList.h"
14#include "llvm/Support/VirtualFileSystem.h"
15#include "llvm/Support/WithColor.h"
16
17using namespace clang;
18using namespace clang::driver;
19using namespace clang::driver::tools;
20using namespace clang::driver::toolchains;
21using namespace llvm;
22using namespace llvm::opt;
23using namespace llvm::sys;
24
25ZOS::ZOS(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
26 : ToolChain(D, Triple, Args) {}
27
28ZOS::~ZOS() {}
29
30void ZOS::addClangTargetOptions(const ArgList &DriverArgs,
31 ArgStringList &CC1Args,
32 Action::OffloadKind DeviceOffloadKind) const {
33 // Pass "-faligned-alloc-unavailable" only when the user hasn't manually
34 // enabled or disabled aligned allocations.
35 if (!DriverArgs.hasArgNoClaim(Ids: options::OPT_faligned_allocation,
36 Ids: options::OPT_fno_aligned_allocation))
37 CC1Args.push_back(Elt: "-faligned-alloc-unavailable");
38
39 if (!DriverArgs.hasArg(Ids: options::OPT_fvisibility_EQ,
40 Ids: options::OPT_fvisibility_ms_compat))
41 CC1Args.push_back(Elt: "-fvisibility=hidden");
42
43 if (DriverArgs.hasFlag(Pos: options::OPT_fxl_pragma_pack,
44 Neg: options::OPT_fno_xl_pragma_pack, Default: true))
45 CC1Args.push_back(Elt: "-fxl-pragma-pack");
46
47 // Pass "-fno-sized-deallocation" only when the user hasn't manually enabled
48 // or disabled sized deallocations.
49 if (!DriverArgs.hasArgNoClaim(Ids: options::OPT_fsized_deallocation,
50 Ids: options::OPT_fno_sized_deallocation))
51 CC1Args.push_back(Elt: "-fno-sized-deallocation");
52}
53
54void zos::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
55 const InputInfo &Output,
56 const InputInfoList &Inputs,
57 const ArgList &Args,
58 const char *LinkingOutput) const {
59 ArgStringList CmdArgs;
60
61 Args.AddAllArgValues(Output&: CmdArgs, Id0: options::OPT_Wa_COMMA, Id1: options::OPT_Xassembler);
62
63 // Specify assembler output file.
64 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
65 if (Output.isFilename()) {
66 CmdArgs.push_back(Elt: "-o");
67 CmdArgs.push_back(Elt: Output.getFilename());
68 }
69
70 // Specify assembler input file.
71 // The system assembler on z/OS takes exactly one input file. The driver is
72 // expected to invoke as(1) separately for each assembler source input file.
73 if (Inputs.size() != 1)
74 llvm_unreachable("Invalid number of input files.");
75 const InputInfo &II = Inputs[0];
76 assert((II.isFilename() || II.isNothing()) && "Invalid input.");
77 if (II.isFilename())
78 CmdArgs.push_back(Elt: II.getFilename());
79
80 const char *Exec = Args.MakeArgString(Str: getToolChain().GetProgramPath(Name: "as"));
81 C.addCommand(C: std::make_unique<Command>(args: JA, args: *this, args: ResponseFileSupport::None(),
82 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
83}
84
85static std::string getLEHLQ(const ArgList &Args) {
86 if (Args.hasArg(Ids: options::OPT_mzos_hlq_le_EQ)) {
87 Arg *LEHLQArg = Args.getLastArg(Ids: options::OPT_mzos_hlq_le_EQ);
88 StringRef HLQ = LEHLQArg->getValue();
89 if (!HLQ.empty())
90 return HLQ.str();
91 }
92 return "CEE";
93}
94
95static std::string getClangHLQ(const ArgList &Args) {
96 if (Args.hasArg(Ids: options::OPT_mzos_hlq_clang_EQ)) {
97 Arg *ClangHLQArg = Args.getLastArg(Ids: options::OPT_mzos_hlq_clang_EQ);
98 StringRef HLQ = ClangHLQArg->getValue();
99 if (!HLQ.empty())
100 return HLQ.str();
101 }
102 return getLEHLQ(Args);
103}
104
105static std::string getCSSHLQ(const ArgList &Args) {
106 if (Args.hasArg(Ids: options::OPT_mzos_hlq_csslib_EQ)) {
107 Arg *CsslibHLQArg = Args.getLastArg(Ids: options::OPT_mzos_hlq_csslib_EQ);
108 StringRef HLQ = CsslibHLQArg->getValue();
109 if (!HLQ.empty())
110 return HLQ.str();
111 }
112 return "SYS1";
113}
114
115void zos::Linker::ConstructJob(Compilation &C, const JobAction &JA,
116 const InputInfo &Output,
117 const InputInfoList &Inputs, const ArgList &Args,
118 const char *LinkingOutput) const {
119 const ZOS &ToolChain = static_cast<const ZOS &>(getToolChain());
120 ArgStringList CmdArgs;
121
122 const bool IsSharedLib =
123 Args.hasFlag(Pos: options::OPT_shared, Neg: options::OPT_static, Default: false);
124
125 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
126 if (Output.isFilename()) {
127 CmdArgs.push_back(Elt: "-o");
128 CmdArgs.push_back(Elt: Output.getFilename());
129 }
130
131 SmallString<128> LinkerOptions;
132 LinkerOptions = "AMODE=";
133 LinkerOptions += "64";
134 LinkerOptions += ",LIST";
135 LinkerOptions += ",DYNAM=DLL";
136 LinkerOptions += ",MSGLEVEL=4";
137 LinkerOptions += ",CASE=MIXED";
138 LinkerOptions += ",REUS=RENT";
139
140 CmdArgs.push_back(Elt: "-b");
141 CmdArgs.push_back(Elt: Args.MakeArgString(Str: LinkerOptions));
142
143 if (!IsSharedLib) {
144 CmdArgs.push_back(Elt: "-e");
145 CmdArgs.push_back(Elt: "CELQSTRT");
146
147 CmdArgs.push_back(Elt: "-O");
148 CmdArgs.push_back(Elt: "CELQSTRT");
149
150 CmdArgs.push_back(Elt: "-u");
151 CmdArgs.push_back(Elt: "CELQMAIN");
152 }
153
154 // Generate side file if -shared option is present.
155 if (IsSharedLib) {
156 StringRef OutputName = Output.getFilename();
157 // Strip away the last file suffix in presence from output name and add
158 // a new .x suffix.
159 SmallString<128> SideDeckName = OutputName;
160 llvm::sys::path::replace_extension(path&: SideDeckName, extension: "x");
161 CmdArgs.push_back(Elt: "-x");
162 CmdArgs.push_back(Elt: Args.MakeArgString(Str: SideDeckName));
163 } else {
164 // We need to direct side file to /dev/null to suppress linker warning when
165 // the object file contains exported symbols, and -shared or
166 // -Wl,-x<sidedeck>.x is not specified.
167 CmdArgs.push_back(Elt: "-x");
168 CmdArgs.push_back(Elt: "/dev/null");
169 }
170
171 // Add archive library search paths.
172 Args.addAllArgs(Output&: CmdArgs, Ids: {options::OPT_L, options::OPT_u});
173
174 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
175
176 // Specify linker input file(s)
177 AddLinkerInputs(TC: ToolChain, Inputs, Args, CmdArgs, JA);
178
179 // z/OS tool chain depends on LE data sets and the CSSLIB data set.
180 // These data sets can have different high level qualifiers (HLQs)
181 // as each installation can define them differently.
182
183 std::string LEHLQ = getLEHLQ(Args);
184 std::string CsslibHLQ = getCSSHLQ(Args);
185
186 StringRef ld_env_var = StringRef(getenv(name: "_LD_SYSLIB")).trim();
187 if (ld_env_var.empty()) {
188 CmdArgs.push_back(Elt: "-S");
189 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "//'" + LEHLQ + ".SCEEBND2'"));
190 CmdArgs.push_back(Elt: "-S");
191 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "//'" + CsslibHLQ + ".CSSLIB'"));
192 }
193
194 if (!Args.hasArg(Ids: options::OPT_nostdlib, Ids: options::OPT_nodefaultlibs)) {
195 ld_env_var = StringRef(getenv(name: "_LD_SIDE_DECKS")).trim();
196 if (ld_env_var.empty()) {
197 CmdArgs.push_back(
198 Elt: Args.MakeArgString(Str: "//'" + LEHLQ + ".SCEELIB(CELQS001)'"));
199 CmdArgs.push_back(
200 Elt: Args.MakeArgString(Str: "//'" + LEHLQ + ".SCEELIB(CELQS003)'"));
201 } else {
202 SmallVector<StringRef> ld_side_deck;
203 ld_env_var.split(A&: ld_side_deck, Separator: ":");
204 for (StringRef ld_loc : ld_side_deck) {
205 CmdArgs.push_back(Elt: (ld_loc.str()).c_str());
206 }
207 }
208 }
209 // Link libc++ library
210 if (ToolChain.ShouldLinkCXXStdlib(Args)) {
211 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
212 }
213
214 // Specify compiler-rt library path for linker
215 if (!Args.hasArg(Ids: options::OPT_nostdlib, Ids: options::OPT_nodefaultlibs))
216 AddRunTimeLibs(TC: ToolChain, D: ToolChain.getDriver(), CmdArgs, Args);
217
218 const char *Exec = Args.MakeArgString(Str: ToolChain.GetLinkerPath());
219 C.addCommand(C: std::make_unique<Command>(args: JA, args: *this, args: ResponseFileSupport::None(),
220 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
221}
222
223ToolChain::RuntimeLibType ZOS::GetDefaultRuntimeLibType() const {
224 return ToolChain::RLT_CompilerRT;
225}
226
227ToolChain::CXXStdlibType ZOS::GetDefaultCXXStdlibType() const {
228 return ToolChain::CST_Libcxx;
229}
230
231void ZOS::AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
232 llvm::opt::ArgStringList &CmdArgs) const {
233 switch (GetCXXStdlibType(Args)) {
234 case ToolChain::CST_Libstdcxx:
235 llvm::report_fatal_error(reason: "linking libstdc++ is unimplemented on z/OS");
236 break;
237 case ToolChain::CST_Libcxx: {
238 std::string ClangHLQ = getClangHLQ(Args);
239 CmdArgs.push_back(
240 Elt: Args.MakeArgString(Str: "//'" + ClangHLQ + ".SCEELIB(CRTDQCXE)'"));
241 CmdArgs.push_back(
242 Elt: Args.MakeArgString(Str: "//'" + ClangHLQ + ".SCEELIB(CRTDQCXS)'"));
243 CmdArgs.push_back(
244 Elt: Args.MakeArgString(Str: "//'" + ClangHLQ + ".SCEELIB(CRTDQCXP)'"));
245 CmdArgs.push_back(
246 Elt: Args.MakeArgString(Str: "//'" + ClangHLQ + ".SCEELIB(CRTDQCXA)'"));
247 CmdArgs.push_back(
248 Elt: Args.MakeArgString(Str: "//'" + ClangHLQ + ".SCEELIB(CRTDQXLA)'"));
249 CmdArgs.push_back(
250 Elt: Args.MakeArgString(Str: "//'" + ClangHLQ + ".SCEELIB(CRTDQUNW)'"));
251 } break;
252 }
253}
254
255auto ZOS::buildAssembler() const -> Tool * { return new zos::Assembler(*this); }
256
257auto ZOS::buildLinker() const -> Tool * { return new zos::Linker(*this); }
258
259void ZOS::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
260 ArgStringList &CC1Args) const {
261 if (DriverArgs.hasArg(Ids: options::OPT_nostdinc))
262 return;
263
264 const Driver &D = getDriver();
265
266 // resolve ResourceDir
267 std::string ResourceDir(D.ResourceDir);
268
269 // zos_wrappers must take highest precedence
270
271 // - <clang>/lib/clang/<ver>/include/zos_wrappers
272 if (!DriverArgs.hasArg(Ids: options::OPT_nobuiltininc)) {
273 SmallString<128> P(ResourceDir);
274 path::append(path&: P, a: "include", b: "zos_wrappers");
275 addSystemInclude(DriverArgs, CC1Args, Path: P.str());
276
277 // - <clang>/lib/clang/<ver>/include
278 SmallString<128> P2(ResourceDir);
279 path::append(path&: P2, a: "include");
280 addSystemInclude(DriverArgs, CC1Args, Path: P2.str());
281 }
282
283 // - /usr/include
284 if (Arg *SysIncludeArg =
285 DriverArgs.getLastArg(Ids: options::OPT_mzos_sys_include_EQ)) {
286 StringRef SysInclude = SysIncludeArg->getValue();
287
288 // fall back to the default include path
289 if (!SysInclude.empty()) {
290
291 // -mzos-sys-include opton can have colon separated
292 // list of paths, so we need to parse the value.
293 StringRef PathLE(SysInclude);
294 size_t Colon = PathLE.find(C: ':');
295 if (Colon == StringRef::npos) {
296 addSystemInclude(DriverArgs, CC1Args, Path: PathLE.str());
297 return;
298 }
299
300 while (Colon != StringRef::npos) {
301 SmallString<128> P = PathLE.substr(Start: 0, N: Colon);
302 addSystemInclude(DriverArgs, CC1Args, Path: P.str());
303 PathLE = PathLE.substr(Start: Colon + 1);
304 Colon = PathLE.find(C: ':');
305 }
306 if (PathLE.size())
307 addSystemInclude(DriverArgs, CC1Args, Path: PathLE.str());
308
309 return;
310 }
311 }
312
313 addSystemInclude(DriverArgs, CC1Args, Path: "/usr/include");
314}
315
316void ZOS::TryAddIncludeFromPath(llvm::SmallString<128> Path,
317 const llvm::opt::ArgList &DriverArgs,
318 llvm::opt::ArgStringList &CC1Args) const {
319 if (!getVFS().exists(Path)) {
320 if (DriverArgs.hasArg(Ids: options::OPT_v))
321 WithColor::warning(OS&: errs(), Prefix: "Clang")
322 << "ignoring nonexistent directory \"" << Path << "\"\n";
323 if (!DriverArgs.hasArg(Ids: options::OPT__HASH_HASH_HASH))
324 return;
325 }
326 addSystemInclude(DriverArgs, CC1Args, Path);
327}
328
329void ZOS::AddClangCXXStdlibIncludeArgs(
330 const llvm::opt::ArgList &DriverArgs,
331 llvm::opt::ArgStringList &CC1Args) const {
332 if (DriverArgs.hasArg(Ids: options::OPT_nostdinc) ||
333 DriverArgs.hasArg(Ids: options::OPT_nostdincxx) ||
334 DriverArgs.hasArg(Ids: options::OPT_nostdlibinc))
335 return;
336
337 switch (GetCXXStdlibType(Args: DriverArgs)) {
338 case ToolChain::CST_Libcxx: {
339 // <install>/bin/../include/c++/v1
340 llvm::SmallString<128> InstallBin(getDriver().Dir);
341 llvm::sys::path::append(path&: InstallBin, a: "..", b: "include", c: "c++", d: "v1");
342 TryAddIncludeFromPath(Path: InstallBin, DriverArgs, CC1Args);
343 break;
344 }
345 case ToolChain::CST_Libstdcxx:
346 llvm::report_fatal_error(
347 reason: "picking up libstdc++ headers is unimplemented on z/OS");
348 break;
349 }
350}
351