1//===-- LoongArchTargetMachine.cpp - Define TargetMachine for LoongArch ---===//
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 LoongArch target spec.
10//
11//===----------------------------------------------------------------------===//
12
13#include "LoongArchTargetMachine.h"
14#include "LoongArch.h"
15#include "LoongArchMachineFunctionInfo.h"
16#include "LoongArchTargetObjectFile.h"
17#include "LoongArchTargetTransformInfo.h"
18#include "TargetInfo/LoongArchTargetInfo.h"
19#include "llvm/Analysis/TargetTransformInfo.h"
20#include "llvm/CodeGen/Passes.h"
21#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
22#include "llvm/CodeGen/TargetPassConfig.h"
23#include "llvm/MC/TargetRegistry.h"
24#include "llvm/Support/CodeGen.h"
25#include "llvm/Support/Compiler.h"
26#include "llvm/Transforms/Scalar.h"
27#include <optional>
28
29using namespace llvm;
30
31#define DEBUG_TYPE "loongarch"
32
33extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void
34LLVMInitializeLoongArchTarget() {
35 // Register the target.
36 RegisterTargetMachine<LoongArchTargetMachine> X(getTheLoongArch32Target());
37 RegisterTargetMachine<LoongArchTargetMachine> Y(getTheLoongArch64Target());
38 auto *PR = PassRegistry::getPassRegistry();
39 initializeLoongArchDeadRegisterDefinitionsPass(*PR);
40 initializeLoongArchMemoryBarrierOptPass(*PR);
41 initializeLoongArchMergeBaseOffsetOptPass(*PR);
42 initializeLoongArchOptWInstrsPass(*PR);
43 initializeLoongArchPreRAExpandPseudoPass(*PR);
44 initializeLoongArchExpandPseudoPass(*PR);
45 initializeLoongArchDAGToDAGISelLegacyPass(*PR);
46 initializeLoongArchExpandAtomicPseudoPass(*PR);
47 initializeLoongArchLateBranchOptPass(*PR);
48}
49
50static cl::opt<bool> EnableLoongArchDeadRegisterElimination(
51 "loongarch-enable-dead-defs", cl::Hidden,
52 cl::desc("Enable the pass that removes dead"
53 " definitons and replaces stores to"
54 " them with stores to r0"),
55 cl::init(Val: true));
56
57static cl::opt<bool>
58 EnableLoopDataPrefetch("loongarch-enable-loop-data-prefetch", cl::Hidden,
59 cl::desc("Enable the loop data prefetch pass"),
60 cl::init(Val: true));
61
62static cl::opt<bool>
63 EnableMergeBaseOffset("loongarch-enable-merge-offset",
64 cl::desc("Enable the merge base offset pass"),
65 cl::init(Val: true), cl::Hidden);
66
67static cl::opt<bool>
68 EnableSinkFold("loongarch-enable-sink-fold",
69 cl::desc("Enable sinking and folding of instruction copies"),
70 cl::init(Val: true), cl::Hidden);
71
72static cl::opt<bool>
73 EnableMachineCombiner("loongarch-enable-machine-combiner",
74 cl::desc("Enable the machine combiner pass"),
75 cl::init(Val: true), cl::Hidden);
76
77static Reloc::Model getEffectiveRelocModel(std::optional<Reloc::Model> RM) {
78 return RM.value_or(u: Reloc::Static);
79}
80
81static CodeModel::Model
82getEffectiveLoongArchCodeModel(const Triple &TT,
83 std::optional<CodeModel::Model> CM) {
84 if (!CM)
85 return TT.isArch64Bit() ? CodeModel::Medium : CodeModel::Small;
86
87 switch (*CM) {
88 case CodeModel::Small:
89 case CodeModel::Medium:
90 return *CM;
91 case CodeModel::Large:
92 if (!TT.isArch64Bit())
93 report_fatal_error(reason: "Large code model requires LA64");
94 return *CM;
95 default:
96 report_fatal_error(
97 reason: "Only small, medium and large code models are allowed on LoongArch");
98 }
99}
100
101LoongArchTargetMachine::LoongArchTargetMachine(
102 const Target &T, const Triple &TT, StringRef CPU, StringRef FS,
103 const TargetOptions &Options, std::optional<Reloc::Model> RM,
104 std::optional<CodeModel::Model> CM, CodeGenOptLevel OL, bool JIT)
105 : CodeGenTargetMachineImpl(T, TT, CPU, FS, Options,
106 getEffectiveRelocModel(RM),
107 getEffectiveLoongArchCodeModel(TT, CM), OL),
108 TLOF(std::make_unique<LoongArchELFTargetObjectFile>()) {
109 initAsmInfo();
110}
111
112LoongArchTargetMachine::~LoongArchTargetMachine() = default;
113
114const LoongArchSubtarget *
115LoongArchTargetMachine::getSubtargetImpl(const Function &F) const {
116 Attribute CPUAttr = F.getFnAttribute(Kind: "target-cpu");
117 Attribute TuneAttr = F.getFnAttribute(Kind: "tune-cpu");
118 Attribute FSAttr = F.getFnAttribute(Kind: "target-features");
119
120 std::string CPU =
121 CPUAttr.isValid() ? CPUAttr.getValueAsString().str() : TargetCPU;
122 std::string TuneCPU =
123 TuneAttr.isValid() ? TuneAttr.getValueAsString().str() : CPU;
124 std::string FS =
125 FSAttr.isValid() ? FSAttr.getValueAsString().str() : TargetFS;
126
127 std::string Key = CPU + TuneCPU + FS;
128 auto &I = SubtargetMap[Key];
129 if (!I) {
130 StringRef ABIName = getTargetABIName(M: *F.getParent());
131 I = std::make_unique<LoongArchSubtarget>(args: TargetTriple, args&: CPU, args&: TuneCPU, args&: FS,
132 args&: ABIName, args: *this);
133 }
134 return I.get();
135}
136
137MachineFunctionInfo *LoongArchTargetMachine::createMachineFunctionInfo(
138 BumpPtrAllocator &Allocator, const Function &F,
139 const TargetSubtargetInfo *STI) const {
140 return LoongArchMachineFunctionInfo::create<LoongArchMachineFunctionInfo>(
141 Allocator, F, STI);
142}
143
144namespace {
145class LoongArchPassConfig : public TargetPassConfig {
146public:
147 LoongArchPassConfig(LoongArchTargetMachine &TM, PassManagerBase &PM)
148 : TargetPassConfig(TM, PM) {
149 setEnableSinkAndFold(EnableSinkFold);
150 }
151
152 LoongArchTargetMachine &getLoongArchTargetMachine() const {
153 return getTM<LoongArchTargetMachine>();
154 }
155
156 void addIRPasses() override;
157 void addCodeGenPrepare() override;
158 bool addInstSelector() override;
159 void addPreEmitPass() override;
160 void addPreEmitPass2() override;
161 void addMachineSSAOptimization() override;
162 void addPreRegAlloc() override;
163 bool addILPOpts() override;
164 bool addRegAssignAndRewriteFast() override;
165 bool addRegAssignAndRewriteOptimized() override;
166 void addMachineLateOptimization() override;
167};
168} // end namespace
169
170TargetPassConfig *
171LoongArchTargetMachine::createPassConfig(PassManagerBase &PM) {
172 return new LoongArchPassConfig(*this, PM);
173}
174
175void LoongArchPassConfig::addIRPasses() {
176 // Run LoopDataPrefetch
177 //
178 // Run this before LSR to remove the multiplies involved in computing the
179 // pointer values N iterations ahead.
180 if (TM->getOptLevel() != CodeGenOptLevel::None && EnableLoopDataPrefetch)
181 addPass(P: createLoopDataPrefetchPass());
182 addPass(P: createAtomicExpandLegacyPass());
183
184 TargetPassConfig::addIRPasses();
185}
186
187void LoongArchPassConfig::addCodeGenPrepare() {
188 if (getOptLevel() != CodeGenOptLevel::None)
189 addPass(P: createTypePromotionLegacyPass());
190 TargetPassConfig::addCodeGenPrepare();
191}
192
193bool LoongArchPassConfig::addInstSelector() {
194 addPass(P: createLoongArchISelDag(TM&: getLoongArchTargetMachine(), OptLevel: getOptLevel()));
195
196 return false;
197}
198
199TargetTransformInfo
200LoongArchTargetMachine::getTargetTransformInfo(const Function &F) const {
201 return TargetTransformInfo(std::make_unique<LoongArchTTIImpl>(args: this, args: F));
202}
203
204void LoongArchPassConfig::addPreEmitPass() { addPass(PassID: &BranchRelaxationPassID); }
205
206void LoongArchPassConfig::addPreEmitPass2() {
207 addPass(P: createLoongArchExpandPseudoPass());
208 // Schedule the expansion of AtomicPseudos at the last possible moment,
209 // avoiding the possibility for other passes to break the requirements for
210 // forward progress in the LL/SC block.
211 addPass(P: createLoongArchExpandAtomicPseudoPass());
212 if (TM->getOptLevel() != CodeGenOptLevel::None)
213 addPass(P: createLoongArchMemoryBarrierOptPass());
214}
215
216void LoongArchPassConfig::addMachineSSAOptimization() {
217 TargetPassConfig::addMachineSSAOptimization();
218
219 if (TM->getTargetTriple().isLoongArch64()) {
220 addPass(P: createLoongArchOptWInstrsPass());
221 }
222}
223
224void LoongArchPassConfig::addPreRegAlloc() {
225 addPass(P: createLoongArchPreRAExpandPseudoPass());
226 if (TM->getOptLevel() != CodeGenOptLevel::None && EnableMergeBaseOffset)
227 addPass(P: createLoongArchMergeBaseOffsetOptPass());
228}
229
230bool LoongArchPassConfig::addILPOpts() {
231 if (EnableMachineCombiner)
232 addPass(PassID: &MachineCombinerID);
233
234 return true;
235}
236
237bool LoongArchPassConfig::addRegAssignAndRewriteFast() {
238 if (TM->getOptLevel() != CodeGenOptLevel::None &&
239 EnableLoongArchDeadRegisterElimination)
240 addPass(P: createLoongArchDeadRegisterDefinitionsPass());
241 return TargetPassConfig::addRegAssignAndRewriteFast();
242}
243
244bool LoongArchPassConfig::addRegAssignAndRewriteOptimized() {
245 if (TM->getOptLevel() != CodeGenOptLevel::None &&
246 EnableLoongArchDeadRegisterElimination)
247 addPass(P: createLoongArchDeadRegisterDefinitionsPass());
248 return TargetPassConfig::addRegAssignAndRewriteOptimized();
249}
250
251void LoongArchPassConfig::addMachineLateOptimization() {
252 if (TM->getOptLevel() != CodeGenOptLevel::None)
253 addPass(P: createLoongArchLateBranchOptPass());
254 TargetPassConfig::addMachineLateOptimization();
255}
256