1//===-- SystemZTargetMachine.cpp - Define TargetMachine for SystemZ -------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#include "SystemZTargetMachine.h" 11#include "SystemZTargetTransformInfo.h" 12#include "llvm/CodeGen/Passes.h" 13#include "llvm/Support/TargetRegistry.h" 14#include "llvm/Transforms/Scalar.h" 15#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h" 16 17using namespace llvm; 18 19extern "C" void LLVMInitializeSystemZTarget() { 20 // Register the target. 21 RegisterTargetMachine<SystemZTargetMachine> X(TheSystemZTarget); 22} 23 24SystemZTargetMachine::SystemZTargetMachine(const Target &T, StringRef TT, 25 StringRef CPU, StringRef FS, 26 const TargetOptions &Options, 27 Reloc::Model RM, CodeModel::Model CM, 28 CodeGenOpt::Level OL) 29 // Make sure that global data has at least 16 bits of alignment by 30 // default, so that we can refer to it using LARL. We don't have any 31 // special requirements for stack variables though. 32 : LLVMTargetMachine(T, "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64", 33 TT, CPU, FS, Options, RM, CM, OL), 34 TLOF(make_unique<TargetLoweringObjectFileELF>()), 35 Subtarget(TT, CPU, FS, *this) { 36 initAsmInfo(); 37} 38 39SystemZTargetMachine::~SystemZTargetMachine() {} 40 41namespace { 42/// SystemZ Code Generator Pass Configuration Options. 43class SystemZPassConfig : public TargetPassConfig { 44public: 45 SystemZPassConfig(SystemZTargetMachine *TM, PassManagerBase &PM) 46 : TargetPassConfig(TM, PM) {} 47 48 SystemZTargetMachine &getSystemZTargetMachine() const { 49 return getTM<SystemZTargetMachine>(); 50 } 51 52 void addIRPasses() override; 53 bool addInstSelector() override; 54 void addPreSched2() override; 55 void addPreEmitPass() override; 56}; 57} // end anonymous namespace 58 59void SystemZPassConfig::addIRPasses() { 60 TargetPassConfig::addIRPasses(); 61} 62 63bool SystemZPassConfig::addInstSelector() { 64 addPass(createSystemZISelDag(getSystemZTargetMachine(), getOptLevel())); 65 66 if (getOptLevel() != CodeGenOpt::None) 67 addPass(createSystemZLDCleanupPass(getSystemZTargetMachine())); 68 69 return false; 70} 71 72void SystemZPassConfig::addPreSched2() { 73 if (getOptLevel() != CodeGenOpt::None && 74 getSystemZTargetMachine().getSubtargetImpl()->hasLoadStoreOnCond()) 75 addPass(&IfConverterID); 76} 77 78void SystemZPassConfig::addPreEmitPass() { 79 // We eliminate comparisons here rather than earlier because some 80 // transformations can change the set of available CC values and we 81 // generally want those transformations to have priority. This is 82 // especially true in the commonest case where the result of the comparison 83 // is used by a single in-range branch instruction, since we will then 84 // be able to fuse the compare and the branch instead. 85 // 86 // For example, two-address NILF can sometimes be converted into 87 // three-address RISBLG. NILF produces a CC value that indicates whether 88 // the low word is zero, but RISBLG does not modify CC at all. On the 89 // other hand, 64-bit ANDs like NILL can sometimes be converted to RISBG. 90 // The CC value produced by NILL isn't useful for our purposes, but the 91 // value produced by RISBG can be used for any comparison with zero 92 // (not just equality). So there are some transformations that lose 93 // CC values (while still being worthwhile) and others that happen to make 94 // the CC result more useful than it was originally. 95 // 96 // Another reason is that we only want to use BRANCH ON COUNT in cases 97 // where we know that the count register is not going to be spilled. 98 // 99 // Doing it so late makes it more likely that a register will be reused 100 // between the comparison and the branch, but it isn't clear whether 101 // preventing that would be a win or not. 102 if (getOptLevel() != CodeGenOpt::None) 103 addPass(createSystemZElimComparePass(getSystemZTargetMachine()), false); 104 if (getOptLevel() != CodeGenOpt::None) 105 addPass(createSystemZShortenInstPass(getSystemZTargetMachine()), false); 106 addPass(createSystemZLongBranchPass(getSystemZTargetMachine())); 107} 108 109TargetPassConfig *SystemZTargetMachine::createPassConfig(PassManagerBase &PM) { 110 return new SystemZPassConfig(this, PM); 111} 112 113TargetIRAnalysis SystemZTargetMachine::getTargetIRAnalysis() { 114 return TargetIRAnalysis([this](Function &F) { 115 return TargetTransformInfo(SystemZTTIImpl(this, F)); 116 }); 117} 118