LLVM  8.0.0svn
SparcTargetMachine.cpp
Go to the documentation of this file.
1 //===-- SparcTargetMachine.cpp - Define TargetMachine for Sparc -----------===//
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 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "SparcTargetMachine.h"
14 #include "LeonPasses.h"
15 #include "Sparc.h"
16 #include "SparcTargetObjectFile.h"
17 #include "llvm/CodeGen/Passes.h"
21 using namespace llvm;
22 
23 extern "C" void LLVMInitializeSparcTarget() {
24  // Register the target.
28 }
29 
30 static std::string computeDataLayout(const Triple &T, bool is64Bit) {
31  // Sparc is typically big endian, but some are little.
32  std::string Ret = T.getArch() == Triple::sparcel ? "e" : "E";
33  Ret += "-m:e";
34 
35  // Some ABIs have 32bit pointers.
36  if (!is64Bit)
37  Ret += "-p:32:32";
38 
39  // Alignments for 64 bit integers.
40  Ret += "-i64:64";
41 
42  // On SparcV9 128 floats are aligned to 128 bits, on others only to 64.
43  // On SparcV9 registers can hold 64 or 32 bits, on others only 32.
44  if (is64Bit)
45  Ret += "-n32:64";
46  else
47  Ret += "-f128:64-n32";
48 
49  if (is64Bit)
50  Ret += "-S128";
51  else
52  Ret += "-S64";
53 
54  return Ret;
55 }
56 
58  if (!RM.hasValue())
59  return Reloc::Static;
60  return *RM;
61 }
62 
63 // Code models. Some only make sense for 64-bit code.
64 //
65 // SunCC Reloc CodeModel Constraints
66 // abs32 Static Small text+data+bss linked below 2^32 bytes
67 // abs44 Static Medium text+data+bss linked below 2^44 bytes
68 // abs64 Static Large text smaller than 2^31 bytes
69 // pic13 PIC_ Small GOT < 2^13 bytes
70 // pic32 PIC_ Medium GOT < 2^32 bytes
71 //
72 // All code models require that the text segment is smaller than 2GB.
73 static CodeModel::Model
75  bool Is64Bit, bool JIT) {
76  if (CM) {
77  if (*CM == CodeModel::Tiny)
78  report_fatal_error("Target does not support the tiny CodeModel");
79  if (*CM == CodeModel::Kernel)
80  report_fatal_error("Target does not support the kernel CodeModel");
81  return *CM;
82  }
83  if (Is64Bit) {
84  if (JIT)
85  return CodeModel::Large;
87  }
88  return CodeModel::Small;
89 }
90 
91 /// Create an ILP32 architecture model
93  const Target &T, const Triple &TT, StringRef CPU, StringRef FS,
94  const TargetOptions &Options, Optional<Reloc::Model> RM,
95  Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT, bool is64bit)
96  : LLVMTargetMachine(T, computeDataLayout(TT, is64bit), TT, CPU, FS, Options,
99  CM, getEffectiveRelocModel(RM), is64bit, JIT),
100  OL),
102  Subtarget(TT, CPU, FS, *this, is64bit), is64Bit(is64bit) {
103  initAsmInfo();
104 }
105 
107 
108 const SparcSubtarget *
110  Attribute CPUAttr = F.getFnAttribute("target-cpu");
111  Attribute FSAttr = F.getFnAttribute("target-features");
112 
113  std::string CPU = !CPUAttr.hasAttribute(Attribute::None)
114  ? CPUAttr.getValueAsString().str()
115  : TargetCPU;
116  std::string FS = !FSAttr.hasAttribute(Attribute::None)
117  ? FSAttr.getValueAsString().str()
118  : TargetFS;
119 
120  // FIXME: This is related to the code below to reset the target options,
121  // we need to know whether or not the soft float flag is set on the
122  // function, so we can enable it as a subtarget feature.
123  bool softFloat =
124  F.hasFnAttribute("use-soft-float") &&
125  F.getFnAttribute("use-soft-float").getValueAsString() == "true";
126 
127  if (softFloat)
128  FS += FS.empty() ? "+soft-float" : ",+soft-float";
129 
130  auto &I = SubtargetMap[CPU + FS];
131  if (!I) {
132  // This needs to be done before we create a new subtarget since any
133  // creation will depend on the TM and the code generation flags on the
134  // function that reside in TargetOptions.
136  I = llvm::make_unique<SparcSubtarget>(TargetTriple, CPU, FS, *this,
137  this->is64Bit);
138  }
139  return I.get();
140 }
141 
142 namespace {
143 /// Sparc Code Generator Pass Configuration Options.
144 class SparcPassConfig : public TargetPassConfig {
145 public:
146  SparcPassConfig(SparcTargetMachine &TM, PassManagerBase &PM)
147  : TargetPassConfig(TM, PM) {}
148 
149  SparcTargetMachine &getSparcTargetMachine() const {
150  return getTM<SparcTargetMachine>();
151  }
152 
153  void addIRPasses() override;
154  bool addInstSelector() override;
155  void addPreEmitPass() override;
156 };
157 } // namespace
158 
160  return new SparcPassConfig(*this, PM);
161 }
162 
163 void SparcPassConfig::addIRPasses() {
164  addPass(createAtomicExpandPass());
165 
167 }
168 
169 bool SparcPassConfig::addInstSelector() {
170  addPass(createSparcISelDag(getSparcTargetMachine()));
171  return false;
172 }
173 
174 void SparcPassConfig::addPreEmitPass(){
176 
177  if (this->getSparcTargetMachine().getSubtargetImpl()->insertNOPLoad())
178  {
179  addPass(new InsertNOPLoad());
180  }
181  if (this->getSparcTargetMachine().getSubtargetImpl()->detectRoundChange()) {
182  addPass(new DetectRoundChange());
183  }
184  if (this->getSparcTargetMachine().getSubtargetImpl()->fixAllFDIVSQRT())
185  {
186  addPass(new FixAllFDIVSQRT());
187  }
188 }
189 
190 void SparcV8TargetMachine::anchor() { }
191 
193  StringRef CPU, StringRef FS,
194  const TargetOptions &Options,
197  CodeGenOpt::Level OL, bool JIT)
198  : SparcTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, JIT, false) {}
199 
200 void SparcV9TargetMachine::anchor() { }
201 
203  StringRef CPU, StringRef FS,
204  const TargetOptions &Options,
207  CodeGenOpt::Level OL, bool JIT)
208  : SparcTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, JIT, true) {}
209 
210 void SparcelTargetMachine::anchor() {}
211 
213  StringRef CPU, StringRef FS,
214  const TargetOptions &Options,
217  CodeGenOpt::Level OL, bool JIT)
218  : SparcTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, JIT, false) {}
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:228
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
This class represents lattice values for constants.
Definition: AllocatorList.h:24
FunctionPass * createSparcDelaySlotFillerPass()
createSparcDelaySlotFillerPass - Returns a pass that fills in delay slots in Sparc MachineFunctions ...
virtual void addIRPasses()
Add common target configurable passes that perform LLVM IR to IR transforms following machine indepen...
Triple TargetTriple
Triple string, CPU name, and target feature strings the TargetMachine instance is created with...
Definition: TargetMachine.h:78
SparcelTargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM, CodeGenOpt::Level OL, bool JIT)
SparcV8TargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM, CodeGenOpt::Level OL, bool JIT)
const SparcSubtarget * getSubtargetImpl() const
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:321
F(f)
block Block Frequency true
std::enable_if<!std::is_array< T >::value, std::unique_ptr< T > >::type make_unique(Args &&... args)
Constructs a new T() with the given args and returns a unique_ptr<T> which owns the object...
Definition: STLExtras.h:1343
void LLVMInitializeSparcTarget()
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
void resetTargetOptions(const Function &F) const
Reset the target options based on the function&#39;s attributes.
No attributes have been set.
Definition: Attributes.h:72
Target-Independent Code Generator Pass Configuration Options.
RegisterTargetMachine - Helper template for registering a target machine implementation, for use in the target machine initialization function.
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:290
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
Target & getTheSparcTarget()
static CodeModel::Model getEffectiveSparcCodeModel(Optional< CodeModel::Model > CM, Reloc::Model RM, bool Is64Bit, bool JIT)
bool hasAttribute(AttrKind Val) const
Return true if the attribute is present.
Definition: Attributes.cpp:202
static Reloc::Model getEffectiveRelocModel(Optional< Reloc::Model > RM)
static bool is64Bit(const char *name)
Target & getTheSparcelTarget()
This class describes a target machine that is implemented with the LLVM target-independent code gener...
FunctionPass * createSparcISelDag(SparcTargetMachine &TM)
createSparcISelDag - This pass converts a legalized DAG into a SPARC-specific DAG, ready for instruction scheduling.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
SparcTargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM, CodeGenOpt::Level OL, bool JIT, bool is64bit)
Create an ILP32 architecture model.
Target - Wrapper for Target specific information.
std::string TargetCPU
Definition: TargetMachine.h:79
Target & getTheSparcV9Target()
static std::string computeDataLayout(const Triple &T, bool is64Bit)
bool hasValue() const
Definition: Optional.h:165
StringRef getValueAsString() const
Return the attribute&#39;s value as a string.
Definition: Attributes.cpp:195
TargetOptions Options
Definition: TargetMachine.h:97
#define I(x, y, z)
Definition: MD5.cpp:58
std::string TargetFS
Definition: TargetMachine.h:80
TargetPassConfig * createPassConfig(PassManagerBase &PM) override
Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of ...
SparcV9TargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM, CodeGenOpt::Level OL, bool JIT)
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
Definition: Function.h:331
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
FunctionPass * createAtomicExpandPass()