LLVM 19.0.0git
LanaiTargetMachine.cpp
Go to the documentation of this file.
1//===-- LanaiTargetMachine.cpp - Define TargetMachine for Lanai ---------===//
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// Implements the info about Lanai target spec.
10//
11//===----------------------------------------------------------------------===//
12
13#include "LanaiTargetMachine.h"
14
15#include "Lanai.h"
21#include "llvm/CodeGen/Passes.h"
27#include <optional>
28
29using namespace llvm;
30
31namespace llvm {
33} // namespace llvm
34
36 // Register the target.
41}
42
43static std::string computeDataLayout() {
44 // Data layout (keep in sync with clang/lib/Basic/Targets.cpp)
45 return "E" // Big endian
46 "-m:e" // ELF name manging
47 "-p:32:32" // 32-bit pointers, 32 bit aligned
48 "-i64:64" // 64 bit integers, 64 bit aligned
49 "-a:0:32" // 32 bit alignment of objects of aggregate type
50 "-n32" // 32 bit native integer width
51 "-S64"; // 64 bit natural stack alignment
52}
53
54static Reloc::Model getEffectiveRelocModel(std::optional<Reloc::Model> RM) {
55 return RM.value_or(Reloc::PIC_);
56}
57
59 const Target &T, const Triple &TT, StringRef Cpu, StringRef FeatureString,
60 const TargetOptions &Options, std::optional<Reloc::Model> RM,
61 std::optional<CodeModel::Model> CodeModel, CodeGenOptLevel OptLevel,
62 bool JIT)
63 : LLVMTargetMachine(T, computeDataLayout(), TT, Cpu, FeatureString, Options,
65 getEffectiveCodeModel(CodeModel, CodeModel::Medium),
66 OptLevel),
67 Subtarget(TT, Cpu, FeatureString, *this, Options, getCodeModel(),
68 OptLevel),
69 TLOF(new LanaiTargetObjectFile()) {
71}
72
75 return TargetTransformInfo(LanaiTTIImpl(this, F));
76}
77
79 BumpPtrAllocator &Allocator, const Function &F,
80 const TargetSubtargetInfo *STI) const {
81 return LanaiMachineFunctionInfo::create<LanaiMachineFunctionInfo>(Allocator,
82 F, STI);
83}
84
85namespace {
86// Lanai Code Generator Pass Configuration Options.
87class LanaiPassConfig : public TargetPassConfig {
88public:
91
92 LanaiTargetMachine &getLanaiTargetMachine() const {
93 return getTM<LanaiTargetMachine>();
94 }
95
96 void addIRPasses() override;
97 bool addInstSelector() override;
98 void addPreSched2() override;
99 void addPreEmitPass() override;
100};
101} // namespace
102
105 return new LanaiPassConfig(*this, &PassManager);
106}
107
108void LanaiPassConfig::addIRPasses() {
109 addPass(createAtomicExpandPass());
110
112}
113
114// Install an instruction selector pass.
115bool LanaiPassConfig::addInstSelector() {
116 addPass(createLanaiISelDag(getLanaiTargetMachine()));
117 return false;
118}
119
120// Implemented by targets that want to run passes immediately before
121// machine code is emitted.
122void LanaiPassConfig::addPreEmitPass() {
123 addPass(createLanaiDelaySlotFillerPass(getLanaiTargetMachine()));
124}
125
126// Run passes after prolog-epilog insertion and before the second instruction
127// scheduling pass.
128void LanaiPassConfig::addPreSched2() {
130}
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:135
static LVOptions Options
Definition: LVOptions.cpp:25
static std::string computeDataLayout()
static Reloc::Model getEffectiveRelocModel(std::optional< Reloc::Model > RM)
LLVM_EXTERNAL_VISIBILITY void LLVMInitializeLanaiTarget()
#define F(x, y, z)
Definition: MD5.cpp:55
const char LLVMTargetMachineRef TM
Basic Register Allocator
Target-Independent Code Generator Pass Configuration Options pass.
This pass exposes codegen information to IR-level passes.
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
This class describes a target machine that is implemented with the LLVM target-independent code gener...
TargetPassConfig * createPassConfig(PassManagerBase &pass_manager) override
Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of ...
LanaiTargetMachine(const Target &TheTarget, const Triple &TargetTriple, StringRef Cpu, StringRef FeatureString, const TargetOptions &Options, std::optional< Reloc::Model > RM, std::optional< CodeModel::Model > CodeModel, CodeGenOptLevel OptLevel, bool JIT)
MachineFunctionInfo * createMachineFunctionInfo(BumpPtrAllocator &Allocator, const Function &F, const TargetSubtargetInfo *STI) const override
Create the target's instance of MachineFunctionInfo.
TargetTransformInfo getTargetTransformInfo(const Function &F) const override
Get a TargetTransformInfo implementation for the target.
Manages a sequence of passes over a particular unit of IR.
Definition: PassManager.h:190
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
Definition: PassRegistry.h:37
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
std::unique_ptr< const MCSubtargetInfo > STI
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:44
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
FunctionPass * createAtomicExpandPass()
AtomicExpandPass - At IR level this pass replace atomic instructions with __atomic_* library calls,...
Target & getTheLanaiTarget()
FunctionPass * createLanaiMemAluCombinerPass()
FunctionPass * createLanaiISelDag(LanaiTargetMachine &TM)
CodeModel::Model getEffectiveCodeModel(std::optional< CodeModel::Model > CM, CodeModel::Model Default)
Helper method for getting the code model, returning Default if CM does not have a value.
CodeGenOptLevel
Code generation optimization level.
Definition: CodeGen.h:54
void initializeLanaiDAGToDAGISelPass(PassRegistry &)
void initializeLanaiMemAluCombinerPass(PassRegistry &)
FunctionPass * createLanaiDelaySlotFillerPass(const LanaiTargetMachine &TM)
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...
RegisterTargetMachine - Helper template for registering a target machine implementation,...