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, BoundArch BA,
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(Cmd: 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 CmdArgs.push_back(Elt: "-e");
144 CmdArgs.push_back(Elt: "CELQSTRT");
145 CmdArgs.push_back(Elt: "-O");
146 CmdArgs.push_back(Elt: "CELQSTRT");
147 if (!IsSharedLib) {
148 CmdArgs.push_back(Elt: "-u");
149 CmdArgs.push_back(Elt: "CELQMAIN");
150 }
151
152 // Generate side file if -shared option is present.
153 if (IsSharedLib) {
154 // Check if user has specified -Wl,-x option
155 bool HasSideDeck = false;
156 for (auto *Arg : Args.filtered(Ids: options::OPT_Wl_COMMA)) {
157 if (std::find_if(first: Arg->getValues().begin(), last: Arg->getValues().end(),
158 pred: [](StringRef ArgValue) {
159 return ArgValue.starts_with(Prefix: "-x");
160 }) != Arg->getValues().end()) {
161 HasSideDeck = true;
162 break;
163 }
164 }
165 // Only add default -x option if user hasn't specified one
166 if (!HasSideDeck) {
167 StringRef OutputName = Output.getFilename();
168 // Strip away the last file suffix in presence from output name and add
169 // a new .x suffix.
170 SmallString<128> SideDeckName = OutputName;
171 llvm::sys::path::replace_extension(path&: SideDeckName, extension: "x");
172 CmdArgs.push_back(Elt: "-x");
173 CmdArgs.push_back(Elt: Args.MakeArgString(Str: SideDeckName));
174 }
175 } else {
176 // We need to direct side file to /dev/null to suppress linker warning when
177 // the object file contains exported symbols, and -shared or
178 // -Wl,-x<sidedeck>.x is not specified.
179 CmdArgs.push_back(Elt: "-x");
180 CmdArgs.push_back(Elt: "/dev/null");
181 }
182
183 // Add archive library search paths.
184 Args.addAllArgs(Output&: CmdArgs, Ids: {options::OPT_L, options::OPT_u});
185
186 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
187
188 // Specify linker input file(s)
189 AddLinkerInputs(TC: ToolChain, Inputs, Args, CmdArgs, JA);
190
191 // z/OS tool chain depends on LE data sets and the CSSLIB data set.
192 // These data sets can have different high level qualifiers (HLQs)
193 // as each installation can define them differently.
194
195 std::string LEHLQ = getLEHLQ(Args);
196 std::string CsslibHLQ = getCSSHLQ(Args);
197
198 StringRef ld_env_var = StringRef(getenv(name: "_LD_SYSLIB")).trim();
199 if (ld_env_var.empty()) {
200 CmdArgs.push_back(Elt: "-S");
201 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "//'" + LEHLQ + ".SCEEBND2'"));
202 CmdArgs.push_back(Elt: "-S");
203 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "//'" + CsslibHLQ + ".CSSLIB'"));
204 }
205
206 if (!Args.hasArg(Ids: options::OPT_nostdlib, Ids: options::OPT_nodefaultlibs)) {
207 ld_env_var = StringRef(getenv(name: "_LD_SIDE_DECKS")).trim();
208 if (ld_env_var.empty()) {
209 CmdArgs.push_back(
210 Elt: Args.MakeArgString(Str: "//'" + LEHLQ + ".SCEELIB(CELQS001)'"));
211 CmdArgs.push_back(
212 Elt: Args.MakeArgString(Str: "//'" + LEHLQ + ".SCEELIB(CELQS003)'"));
213 } else {
214 SmallVector<StringRef> ld_side_deck;
215 ld_env_var.split(A&: ld_side_deck, Separator: ":");
216 for (StringRef ld_loc : ld_side_deck) {
217 CmdArgs.push_back(Elt: (ld_loc.str()).c_str());
218 }
219 }
220 }
221 // Link libc++ library
222 if (ToolChain.ShouldLinkCXXStdlib(Args)) {
223 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
224 }
225
226 // Specify compiler-rt library path for linker
227 if (!Args.hasArg(Ids: options::OPT_nostdlib, Ids: options::OPT_nodefaultlibs,
228 Ids: options::OPT_nodefaultrtlibs))
229 AddRunTimeLibs(TC: ToolChain, D: ToolChain.getDriver(), CmdArgs, Args);
230
231 const char *Exec = Args.MakeArgString(Str: ToolChain.GetLinkerPath());
232 C.addCommand(Cmd: std::make_unique<Command>(args: JA, args: *this, args: ResponseFileSupport::None(),
233 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
234}
235
236ToolChain::RuntimeLibType ZOS::GetDefaultRuntimeLibType() const {
237 return ToolChain::RLT_CompilerRT;
238}
239
240ToolChain::CXXStdlibType ZOS::GetDefaultCXXStdlibType() const {
241 return ToolChain::CST_Libcxx;
242}
243
244void ZOS::AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
245 llvm::opt::ArgStringList &CmdArgs) const {
246 switch (GetCXXStdlibType(Args)) {
247 case ToolChain::CST_Libstdcxx:
248 llvm::report_fatal_error(reason: "linking libstdc++ is unimplemented on z/OS");
249 break;
250 case ToolChain::CST_Libcxx: {
251 std::string ClangHLQ = getClangHLQ(Args);
252 CmdArgs.push_back(
253 Elt: Args.MakeArgString(Str: "//'" + ClangHLQ + ".SCEELIB(CRTDQCXE)'"));
254 CmdArgs.push_back(
255 Elt: Args.MakeArgString(Str: "//'" + ClangHLQ + ".SCEELIB(CRTDQCXS)'"));
256 CmdArgs.push_back(
257 Elt: Args.MakeArgString(Str: "//'" + ClangHLQ + ".SCEELIB(CRTDQCXP)'"));
258 CmdArgs.push_back(
259 Elt: Args.MakeArgString(Str: "//'" + ClangHLQ + ".SCEELIB(CRTDQCXA)'"));
260 CmdArgs.push_back(
261 Elt: Args.MakeArgString(Str: "//'" + ClangHLQ + ".SCEELIB(CRTDQXLA)'"));
262 CmdArgs.push_back(
263 Elt: Args.MakeArgString(Str: "//'" + ClangHLQ + ".SCEELIB(CRTDQUNW)'"));
264 } break;
265 }
266}
267
268auto ZOS::buildAssembler() const -> Tool * { return new zos::Assembler(*this); }
269
270auto ZOS::buildLinker() const -> Tool * { return new zos::Linker(*this); }
271
272void ZOS::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
273 ArgStringList &CC1Args) const {
274 if (DriverArgs.hasArg(Ids: options::OPT_nostdinc))
275 return;
276
277 const Driver &D = getDriver();
278
279 // resolve ResourceDir
280 std::string ResourceDir(D.ResourceDir);
281
282 // zos_wrappers must take highest precedence
283
284 // - <clang>/lib/clang/<ver>/include/zos_wrappers
285 if (!DriverArgs.hasArg(Ids: options::OPT_nobuiltininc)) {
286 SmallString<128> P(ResourceDir);
287 path::append(path&: P, a: "include", b: "zos_wrappers");
288 addSystemInclude(DriverArgs, CC1Args, Path: P.str());
289
290 // - <clang>/lib/clang/<ver>/include
291 SmallString<128> P2(ResourceDir);
292 path::append(path&: P2, a: "include");
293 addSystemInclude(DriverArgs, CC1Args, Path: P2.str());
294 }
295
296 // - /usr/include
297 if (Arg *SysIncludeArg =
298 DriverArgs.getLastArg(Ids: options::OPT_mzos_sys_include_EQ)) {
299 StringRef SysInclude = SysIncludeArg->getValue();
300
301 // fall back to the default include path
302 if (!SysInclude.empty()) {
303
304 // -mzos-sys-include opton can have colon separated
305 // list of paths, so we need to parse the value.
306 StringRef PathLE(SysInclude);
307 size_t Colon = PathLE.find(C: ':');
308 if (Colon == StringRef::npos) {
309 addSystemInclude(DriverArgs, CC1Args, Path: PathLE.str());
310 return;
311 }
312
313 while (Colon != StringRef::npos) {
314 SmallString<128> P = PathLE.substr(Start: 0, N: Colon);
315 addSystemInclude(DriverArgs, CC1Args, Path: P.str());
316 PathLE = PathLE.substr(Start: Colon + 1);
317 Colon = PathLE.find(C: ':');
318 }
319 if (PathLE.size())
320 addSystemInclude(DriverArgs, CC1Args, Path: PathLE.str());
321
322 return;
323 }
324 }
325
326 addSystemInclude(DriverArgs, CC1Args, Path: "/usr/include");
327}
328
329void ZOS::TryAddIncludeFromPath(llvm::SmallString<128> Path,
330 const llvm::opt::ArgList &DriverArgs,
331 llvm::opt::ArgStringList &CC1Args) const {
332 if (!getVFS().exists(Path)) {
333 if (DriverArgs.hasArg(Ids: options::OPT_v))
334 WithColor::warning(OS&: errs(), Prefix: "Clang")
335 << "ignoring nonexistent directory \"" << Path << "\"\n";
336 if (!DriverArgs.hasArg(Ids: options::OPT__HASH_HASH_HASH))
337 return;
338 }
339 addSystemInclude(DriverArgs, CC1Args, Path);
340}
341
342void ZOS::AddClangCXXStdlibIncludeArgs(
343 const llvm::opt::ArgList &DriverArgs,
344 llvm::opt::ArgStringList &CC1Args) const {
345 if (DriverArgs.hasArg(Ids: options::OPT_nostdinc) ||
346 DriverArgs.hasArg(Ids: options::OPT_nostdincxx) ||
347 DriverArgs.hasArg(Ids: options::OPT_nostdlibinc))
348 return;
349
350 switch (GetCXXStdlibType(Args: DriverArgs)) {
351 case ToolChain::CST_Libcxx: {
352 // <install>/bin/../include/c++/v1
353 llvm::SmallString<128> InstallBin(getDriver().Dir);
354 llvm::sys::path::append(path&: InstallBin, a: "..", b: "include", c: "c++", d: "v1");
355 TryAddIncludeFromPath(Path: InstallBin, DriverArgs, CC1Args);
356 break;
357 }
358 case ToolChain::CST_Libstdcxx:
359 llvm::report_fatal_error(
360 reason: "picking up libstdc++ headers is unimplemented on z/OS");
361 break;
362 }
363}
364