LLVM 24.0.0git
SystemZTargetMachine.cpp
Go to the documentation of this file.
1//===-- SystemZTargetMachine.cpp - Define TargetMachine for SystemZ -------===//
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
11#include "SystemZ.h"
17#include "llvm/ADT/StringRef.h"
19#include "llvm/CodeGen/Passes.h"
22#include "llvm/IR/DataLayout.h"
28#include <memory>
29#include <optional>
30#include <string>
31
32using namespace llvm;
33
35 EnableMachineCombinerPass("systemz-machine-combiner",
36 cl::desc("Enable the machine combiner pass"),
37 cl::init(true), cl::Hidden);
38
40 "generic-sched", cl::Hidden, cl::init(false),
41 cl::desc("Run the generic pre-ra scheduler instead of the SystemZ "
42 "scheduler."));
43
44// NOLINTNEXTLINE(readability-identifier-naming)
61
62static std::unique_ptr<TargetLoweringObjectFile> createTLOF(const Triple &TT) {
63 if (TT.isOSzOS())
64 return std::make_unique<TargetLoweringObjectFileGOFF>();
65
66 // Note: Some times run with -triple s390x-unknown.
67 // In this case, default to ELF unless z/OS specifically provided.
68 return std::make_unique<SystemZELFTargetObjectFile>();
69}
70
72 std::optional<Reloc::Model> RM) {
73 if (TT.isOSzOS()) {
74 // z/OS code is always position-independent, so -fpic and -fno-pic have
75 // no effect. Ignore the relocation model requested by the frontend.
76 // This also prevents optimizations (such as relative lookup tables)
77 // that generate 32-bit relative offsets, which are
78 // incompatible with the GOFF binder's requirement for 8-byte relocations
79 // in C_WSA64.
80 //
81 // Constant globals whose initializers contain pointer relocations (e.g.
82 // vtables) must be placed in a writable section (C_WSA64) so the GOFF
83 // binder can apply relocations at link time. Using DynamicNoPIC causes
84 // getKindForGlobal() to classify such globals as ReadOnlyWithRel instead
85 // of ReadOnly, which routes them to C_WSA64 rather than C_CODE64.
87 }
88 // For ELF/Linux, static code is suitable for use in a dynamic executable;
89 // there is no separate DynamicNoPIC model.
90 if (!RM || *RM == Reloc::DynamicNoPIC)
91 return Reloc::Static;
92 return *RM;
93}
94
95// For SystemZ we define the models as follows:
96//
97// Small: BRASL can call any function and will use a stub if necessary.
98// Locally-binding symbols will always be in range of LARL.
99//
100// Medium: BRASL can call any function and will use a stub if necessary.
101// GOT slots and locally-defined text will always be in range
102// of LARL, but other symbols might not be.
103//
104// Large: Equivalent to Medium for now.
105//
106// Kernel: Equivalent to Medium for now.
107//
108// This means that any PIC module smaller than 4GB meets the
109// requirements of Small, so Small seems like the best default there.
110//
111// All symbols bind locally in a non-PIC module, so the choice is less
112// obvious. There are two cases:
113//
114// - When creating an executable, PLTs and copy relocations allow
115// us to treat external symbols as part of the executable.
116// Any executable smaller than 4GB meets the requirements of Small,
117// so that seems like the best default.
118//
119// - When creating JIT code, stubs will be in range of BRASL if the
120// image is less than 4GB in size. GOT entries will likewise be
121// in range of LARL. However, the JIT environment has no equivalent
122// of copy relocs, so locally-binding data symbols might not be in
123// the range of LARL. We need the Medium model in that case.
124static CodeModel::Model
125getEffectiveSystemZCodeModel(std::optional<CodeModel::Model> CM,
126 Reloc::Model RM, bool JIT) {
127 if (CM) {
128 if (*CM == CodeModel::Tiny)
129 report_fatal_error("Target does not support the tiny CodeModel", false);
130 if (*CM == CodeModel::Kernel)
131 report_fatal_error("Target does not support the kernel CodeModel", false);
132 return *CM;
133 }
134 if (JIT)
136 return CodeModel::Small;
137}
138
140 StringRef CPU, StringRef FS,
141 const TargetOptions &Options,
142 std::optional<Reloc::Model> RM,
143 std::optional<CodeModel::Model> CM,
144 CodeGenOptLevel OL, bool JIT)
146 T, TT, CPU, FS, Options, getEffectiveRelocModel(TT, RM),
148 OL),
149 TLOF(createTLOF(getTargetTriple())) {
150 initAsmInfo();
151}
152
154
155const SystemZSubtarget *
157 AttributeSet FnAttrs = F.getAttributes().getFnAttrs();
158 const Module *M = F.getParent();
159 if (const SystemZSubtarget *ST = LastSubtarget.lookup(FnAttrs, M))
160 return ST;
161
162 SubtargetAttrs Attrs;
163 Attrs.CPU = FnAttrs.getAttribute("target-cpu");
164 Attrs.TuneCPU = FnAttrs.getAttribute("tune-cpu");
165 Attrs.FS = FnAttrs.getAttribute("target-features");
166 Attrs.SoftFloat = FnAttrs.getAttribute("use-soft-float");
167 Attrs.BackChain = FnAttrs.getAttribute("backchain");
168
169 if (const SystemZSubtarget *ST = LastSubtarget.lookup(FnAttrs, M, Attrs))
170 return ST;
171
172 std::string CPU =
173 Attrs.CPU.isValid() ? Attrs.CPU.getValueAsString().str() : TargetCPU;
174 std::string TuneCPU =
175 Attrs.TuneCPU.isValid() ? Attrs.TuneCPU.getValueAsString().str() : CPU;
176 std::string FS =
177 Attrs.FS.isValid() ? Attrs.FS.getValueAsString().str() : TargetFS;
178
179 // FIXME: This is related to the code below to reset the target options,
180 // we need to know whether the soft float and backchain flags are set on the
181 // function, so we can enable them as subtarget features.
182 bool SoftFloat = Attrs.SoftFloat.getValueAsBool();
183 if (SoftFloat)
184 FS += FS.empty() ? "+soft-float" : ",+soft-float";
185 bool BackChain = Attrs.BackChain.isValid();
186 if (BackChain)
187 FS += FS.empty() ? "+backchain" : ",+backchain";
188
189 auto &I = SubtargetMap[CPU + TuneCPU + FS];
190 if (!I) {
191 I = std::make_unique<SystemZSubtarget>(TargetTriple, CPU, TuneCPU, FS,
192 *this);
193 }
194
195 LastSubtarget.set(FnAttrs, M, Attrs, I.get());
196 return I.get();
197}
198
201 // Use GenericScheduler if requested on CL or for Z10 which has no sched
202 // model.
203 if (GenericSched ||
204 !C->MF->getSubtarget().getSchedModel().hasInstrSchedModel())
205 return nullptr;
206
208}
209
214
215namespace {
216
217/// SystemZ Code Generator Pass Configuration Options.
218class SystemZPassConfig : public TargetPassConfig {
219public:
220 SystemZPassConfig(SystemZTargetMachine &TM, PassManagerBase &PM)
221 : TargetPassConfig(TM, PM) {}
222
223 SystemZTargetMachine &getSystemZTargetMachine() const {
225 }
226
227 void addIRPasses() override;
228 bool addInstSelector() override;
229 bool addILPOpts() override;
230 void addPreRegAlloc() override;
231 void addPostRewrite() override;
232 void addPostRegAlloc() override;
233 void addPreSched2() override;
234 void addPreEmitPass() override;
235};
236
237} // end anonymous namespace
238
239void SystemZPassConfig::addIRPasses() {
240 if (getOptLevel() != CodeGenOptLevel::None) {
244 }
245
247
249}
250
251bool SystemZPassConfig::addInstSelector() {
252 addPass(
253 createSystemZISelDagLegacyPass(getSystemZTargetMachine(), getOptLevel()));
254
255 if (getOptLevel() != CodeGenOptLevel::None)
256 addPass(createSystemZLDCleanupLegacyPass(getSystemZTargetMachine()));
257
258 return false;
259}
260
261bool SystemZPassConfig::addILPOpts() {
262 addPass(&EarlyIfConverterLegacyID);
263
265 addPass(&MachineCombinerID);
266
267 return true;
268}
269
270void SystemZPassConfig::addPreRegAlloc() {
271 addPass(createSystemZCopyPhysRegsLegacyPass(getSystemZTargetMachine()));
272}
273
274void SystemZPassConfig::addPostRewrite() {
275 addPass(createSystemZPostRewriteLegacyPass(getSystemZTargetMachine()));
276}
277
278void SystemZPassConfig::addPostRegAlloc() {
279 // PostRewrite needs to be run at -O0 also (in which case addPostRewrite()
280 // is not called).
281 if (getOptLevel() == CodeGenOptLevel::None)
282 addPass(createSystemZPostRewriteLegacyPass(getSystemZTargetMachine()));
283}
284
285void SystemZPassConfig::addPreSched2() {
286 if (getOptLevel() != CodeGenOptLevel::None)
287 addPass(&IfConverterID);
288}
289
290void SystemZPassConfig::addPreEmitPass() {
291 // Do instruction shortening before compare elimination because some
292 // vector instructions will be shortened into opcodes that compare
293 // elimination recognizes.
294 if (getOptLevel() != CodeGenOptLevel::None)
295 addPass(createSystemZShortenInstLegacyPass(getSystemZTargetMachine()));
296
297 // We eliminate comparisons here rather than earlier because some
298 // transformations can change the set of available CC values and we
299 // generally want those transformations to have priority. This is
300 // especially true in the commonest case where the result of the comparison
301 // is used by a single in-range branch instruction, since we will then
302 // be able to fuse the compare and the branch instead.
303 //
304 // For example, two-address NILF can sometimes be converted into
305 // three-address RISBLG. NILF produces a CC value that indicates whether
306 // the low word is zero, but RISBLG does not modify CC at all. On the
307 // other hand, 64-bit ANDs like NILL can sometimes be converted to RISBG.
308 // The CC value produced by NILL isn't useful for our purposes, but the
309 // value produced by RISBG can be used for any comparison with zero
310 // (not just equality). So there are some transformations that lose
311 // CC values (while still being worthwhile) and others that happen to make
312 // the CC result more useful than it was originally.
313 //
314 // Another reason is that we only want to use BRANCH ON COUNT in cases
315 // where we know that the count register is not going to be spilled.
316 //
317 // Doing it so late makes it more likely that a register will be reused
318 // between the comparison and the branch, but it isn't clear whether
319 // preventing that would be a win or not.
320 if (getOptLevel() != CodeGenOptLevel::None)
321 addPass(createSystemZElimCompareLegacyPass(getSystemZTargetMachine()));
322 addPass(createSystemZLongBranchLegacyPass(getSystemZTargetMachine()));
323
324 // Do final scheduling after all other optimizations, to get an
325 // optimal input for the decoder (branch relaxation must happen
326 // after block placement).
327 if (getOptLevel() != CodeGenOptLevel::None)
328 addPass(&PostMachineSchedulerID);
329}
330
332 return new SystemZPassConfig(*this, PM);
333}
334
337 return TargetTransformInfo(std::make_unique<SystemZTTIImpl>(this, F));
338}
339
static std::unique_ptr< TargetLoweringObjectFile > createTLOF(const Triple &TT)
static Reloc::Model getEffectiveRelocModel()
#define X(NUM, ENUM, NAME)
Definition ELF.h:665
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
#define LLVM_ABI
Definition Compiler.h:211
#define LLVM_EXTERNAL_VISIBILITY
Definition Compiler.h:132
#define F(x, y, z)
Definition MD5.cpp:54
#define I(x, y, z)
Definition MD5.cpp:57
#define T
static cl::opt< bool > EnableMachineCombinerPass("ppc-machine-combiner", cl::desc("Enable the machine combiner pass"), cl::init(true), cl::Hidden)
const GCNTargetMachine & getTM(const GCNSubtarget *STI)
static CodeModel::Model getEffectiveSystemZCodeModel(std::optional< CodeModel::Model > CM, Reloc::Model RM, bool JIT)
static cl::opt< bool > GenericSched("generic-sched", cl::Hidden, cl::init(false), cl::desc("Run the generic pre-ra scheduler instead of the SystemZ " "scheduler."))
cl::opt< bool > EnableMachineCombinerPass("systemz-machine-combiner", cl::desc("Enable the machine combiner pass"), cl::init(true), cl::Hidden)
LLVM_ABI LLVM_EXTERNAL_VISIBILITY void LLVMInitializeSystemZTarget()
Target-Independent Code Generator Pass Configuration Options pass.
This pass exposes codegen information to IR-level passes.
static std::unique_ptr< TargetLoweringObjectFile > createTLOF()
This class holds the attributes for a particular argument, parameter, function, or return value.
Definition Attributes.h:448
LLVM_ABI Attribute getAttribute(Attribute::AttrKind Kind) const
Return the attribute object.
CodeGenTargetMachineImpl(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Reloc::Model RM, CodeModel::Model CM, CodeGenOptLevel OL)
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:68
static LLVM_ABI PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
A ScheduleDAG for scheduling lists of MachineInstr.
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
ScheduleDAGInstrs * createMachineScheduler(MachineSchedContext *C) const override
Create an instance of ScheduleDAGInstrs to be run within the standard MachineScheduler pass for this ...
const SystemZSubtarget * getSubtargetImpl() const =delete
SystemZTargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, std::optional< Reloc::Model > RM, std::optional< CodeModel::Model > CM, CodeGenOptLevel OL, bool JIT)
TargetTransformInfo getTargetTransformInfo(const Function &F) const override
Get a TargetTransformInfo implementation for the target.
MachineFunctionInfo * createMachineFunctionInfo(BumpPtrAllocator &Allocator, const Function &F, const TargetSubtargetInfo *STI) const override
Create the target's instance of MachineFunctionInfo.
TargetPassConfig * createPassConfig(PassManagerBase &PM) override
Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of ...
ScheduleDAGInstrs * createPostMachineScheduler(MachineSchedContext *C) const override
Similar to createMachineScheduler but used when postRA machine scheduling is enabled.
Triple TargetTriple
Triple string, CPU name, and target feature strings the TargetMachine instance is created with.
const Triple & getTargetTriple() const
std::unique_ptr< const MCSubtargetInfo > STI
TargetOptions Options
Target-Independent Code Generator Pass Configuration Options.
virtual void addIRPasses()
Add common target configurable passes that perform LLVM IR to IR transforms following machine indepen...
TargetSubtargetInfo - Generic base class for all target subtargets.
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Target - Wrapper for Target specific information.
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:48
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
@ DynamicNoPIC
Definition CodeGen.h:26
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
ScheduleDAGMILive * createSchedLive(MachineSchedContext *C)
Create the standard converging machine scheduler.
Target & getTheSystemZTarget()
FunctionPass * createSystemZISelDagLegacyPass(SystemZTargetMachine &TM, CodeGenOptLevel OptLevel)
void initializeSystemZPostRewriteLegacyPass(PassRegistry &)
FunctionPass * createSystemZLDCleanupLegacyPass(SystemZTargetMachine &TM)
void initializeSystemZCopyPhysRegsLegacyPass(PassRegistry &)
LLVM_ABI char & PostMachineSchedulerID
PostMachineScheduler - This pass schedules machine instructions postRA.
LLVM_ABI char & EarlyIfConverterLegacyID
EarlyIfConverter - This pass performs if-conversion on SSA form by inserting cmov instructions.
LLVM_ABI char & MachineCombinerID
This pass performs instruction combining using trace metrics to estimate critical-path and resource d...
static Reloc::Model getEffectiveRelocModel(std::optional< Reloc::Model > RM)
void initializeSystemZDAGToDAGISelLegacyPass(PassRegistry &)
void initializeSystemZTDCLegacyPass(PassRegistry &)
ScheduleDAGMI * createSchedPostRA(MachineSchedContext *C)
Create a generic scheduler with no vreg liveness or DAG mutation passes.
void initializeSystemZAlignGlobalsLegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createLoopDataPrefetchPass()
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
Definition Error.cpp:163
FunctionPass * createSystemZTDCLegacyPass()
FunctionPass * createSystemZCopyPhysRegsLegacyPass(SystemZTargetMachine &TM)
void initializeSystemZLDCleanupLegacyPass(PassRegistry &)
void initializeSystemZElimCompareLegacyPass(PassRegistry &)
CodeGenOptLevel
Code generation optimization level.
Definition CodeGen.h:280
void initializeSystemZAsmPrinterPass(PassRegistry &)
FunctionPass * createSystemZShortenInstLegacyPass(SystemZTargetMachine &TM)
ModulePass * createSystemZAlignGlobalsLegacyPass()
LLVM_ABI char & IfConverterID
IfConverter - This pass performs machine code if conversion.
LLVM_ABI FunctionPass * createAtomicExpandLegacyPass()
AtomicExpandPass - At IR level this pass replace atomic instructions with __atomic_* library calls,...
BumpPtrAllocatorImpl<> BumpPtrAllocator
The standard BumpPtrAllocator which just uses the default template parameters.
Definition Allocator.h:391
FunctionPass * createSystemZPostRewriteLegacyPass(SystemZTargetMachine &TM)
void initializeSystemZLongBranchLegacyPass(PassRegistry &)
FunctionPass * createSystemZElimCompareLegacyPass(SystemZTargetMachine &TM)
FunctionPass * createSystemZLongBranchLegacyPass(SystemZTargetMachine &TM)
void initializeSystemZShortenInstLegacyPass(PassRegistry &)
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...
static FuncInfoTy * create(BumpPtrAllocator &Allocator, const Function &F, const SubtargetTy *STI)
Factory function: default behavior is to call new using the supplied allocator.
MachineSchedContext provides enough context from the MachineScheduler pass for the target to instanti...
RegisterTargetMachine - Helper template for registering a target machine implementation,...