LLVM 24.0.0git
RISCVTargetMachine.cpp
Go to the documentation of this file.
1//===-- RISCVTargetMachine.cpp - Define TargetMachine for RISC-V ----------===//
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 RISC-V target spec.
10//
11//===----------------------------------------------------------------------===//
12
13#include "RISCVTargetMachine.h"
14#include "RISCV.h"
30#include "llvm/CodeGen/Passes.h"
39#include "llvm/Transforms/IPO.h"
41#include <optional>
42using namespace llvm;
43
86}
87
89 std::optional<Reloc::Model> RM) {
90 if (TT.isOSBinFormatMachO())
91 return RM.value_or(Reloc::PIC_);
92
93 return RM.value_or(Reloc::Static);
94}
95
96static std::unique_ptr<TargetLoweringObjectFile> createTLOF(const Triple &TT) {
97 if (TT.isOSBinFormatMachO())
98 return std::make_unique<RISCVMachOTargetObjectFile>();
99 return std::make_unique<RISCVELFTargetObjectFile>();
100}
101
103 StringRef CPU, StringRef FS,
104 const TargetOptions &Options,
105 std::optional<Reloc::Model> RM,
106 std::optional<CodeModel::Model> CM,
107 CodeGenOptLevel OL, bool JIT)
108 : CodeGenTargetMachineImpl(T, TT, CPU, FS, Options,
110 getEffectiveCodeModel(CM, CodeModel::Small), OL),
111 CLOpts(cl::LibraryOptionsContext::get<RISCVOptions>(
112 Options.MCOptions.LibraryOptions)),
113 TLOF(createTLOF(TT)) {
114 initAsmInfo();
115
117
118 // RISC-V supports the MachineOutliner.
119 setMachineOutliner(true);
121
122 // RISC-V supports the debug entry values.
124
125 if (TT.isOSFuchsia() && !TT.isArch64Bit())
126 report_fatal_error("Fuchsia is only supported for 64-bit");
127
128 setCFIFixup(!CLOpts.enable_cfi_instr_inserter);
129}
130
131const RISCVSubtarget *
133 AttributeSet FnAttrs = F.getAttributes().getFnAttrs();
134 const Module *M = F.getParent();
135 if (const RISCVSubtarget *ST = LastSubtarget.lookup(FnAttrs, M))
136 return ST;
137
138 SubtargetAttrs Attrs;
139 Attrs.CPU = FnAttrs.getAttribute("target-cpu");
140 Attrs.TuneCPU = FnAttrs.getAttribute("tune-cpu");
141 Attrs.FS = FnAttrs.getAttribute("target-features");
142 Attrs.VScaleRange = FnAttrs.getAttribute(Attribute::VScaleRange);
143
144 if (const RISCVSubtarget *ST = LastSubtarget.lookup(FnAttrs, M, Attrs))
145 return ST;
146
147 StringRef CPU =
148 Attrs.CPU.isValid() ? Attrs.CPU.getValueAsString() : TargetCPU;
149 StringRef TuneCPU =
150 Attrs.TuneCPU.isValid() ? Attrs.TuneCPU.getValueAsString() : CPU;
151 StringRef FS = Attrs.FS.isValid() ? Attrs.FS.getValueAsString() : TargetFS;
152
153 unsigned RVVBitsMin = CLOpts.v_vector_bits_min.value_or(-1);
154 unsigned RVVBitsMax = CLOpts.v_vector_bits_max.value_or(0);
155
156 if (Attrs.VScaleRange.isValid()) {
157 if (!CLOpts.v_vector_bits_min)
158 RVVBitsMin =
159 Attrs.VScaleRange.getVScaleRangeMin() * RISCV::RVVBitsPerBlock;
160 std::optional<unsigned> VScaleMax = Attrs.VScaleRange.getVScaleRangeMax();
161 if (VScaleMax.has_value() && !CLOpts.v_vector_bits_max)
162 RVVBitsMax = *VScaleMax * RISCV::RVVBitsPerBlock;
163 }
164
165 if (RVVBitsMin != -1U) {
166 // FIXME: Change to >= 32 when VLEN = 32 is supported.
167 assert((RVVBitsMin == 0 || (RVVBitsMin >= 64 && RVVBitsMin <= 65536 &&
168 isPowerOf2_32(RVVBitsMin))) &&
169 "V or Zve* extension requires vector length to be in the range of "
170 "64 to 65536 and a power 2!");
171 assert((RVVBitsMax >= RVVBitsMin || RVVBitsMax == 0) &&
172 "Minimum V extension vector length should not be larger than its "
173 "maximum!");
174 }
175 assert((RVVBitsMax == 0 || (RVVBitsMax >= 64 && RVVBitsMax <= 65536 &&
176 isPowerOf2_32(RVVBitsMax))) &&
177 "V or Zve* extension requires vector length to be in the range of "
178 "64 to 65536 and a power 2!");
179
180 if (RVVBitsMin != -1U) {
181 if (RVVBitsMax != 0) {
182 RVVBitsMin = std::min(RVVBitsMin, RVVBitsMax);
183 RVVBitsMax = std::max(RVVBitsMin, RVVBitsMax);
184 }
185
186 RVVBitsMin = llvm::bit_floor(
187 (RVVBitsMin < 64 || RVVBitsMin > 65536) ? 0 : RVVBitsMin);
188 }
189 RVVBitsMax =
190 llvm::bit_floor((RVVBitsMax < 64 || RVVBitsMax > 65536) ? 0 : RVVBitsMax);
191
193 raw_svector_ostream(Key) << "RVVMin" << RVVBitsMin << "RVVMax" << RVVBitsMax
194 << CPU << TuneCPU << FS;
195 auto &I = SubtargetMap[Key];
196 if (!I) {
197 StringRef ABIName = getTargetABIName(*F.getParent());
198 I = std::make_unique<RISCVSubtarget>(
199 TargetTriple, CPU, TuneCPU, FS, ABIName, RVVBitsMin, RVVBitsMax, *this);
200 }
201 LastSubtarget.set(FnAttrs, M, Attrs, I.get());
202 return I.get();
203}
204
211
214 return TargetTransformInfo(std::make_unique<RISCVTTIImpl>(this, F));
215}
216
217// A RISC-V hart has a single byte-addressable address space of 2^XLEN bytes
218// for all memory accesses, so it is reasonable to assume that an
219// implementation has no-op address space casts. If an implementation makes a
220// change to this, they can override it here.
222 unsigned SrcAS,
223 unsigned DstAS) const {
224 return true;
225}
226
229 const RISCVSubtarget &ST = C->MF->getSubtarget<RISCVSubtarget>();
231
232 // Add MacroFusion mutation first with a higher priority than later clustering
233 const auto &MacroFusions = ST.getMacroFusions();
234 if (!MacroFusions.empty())
235 DAG->addMutation(createMacroFusionDAGMutation(MacroFusions));
236
237 if (ST.enableMISchedLoadClustering())
238 DAG->addMutation(createLoadClusterDAGMutation(
239 DAG->TII, /*ReorderWhileClustering=*/true));
240
241 if (ST.enableMISchedStoreClustering())
242 DAG->addMutation(createStoreClusterDAGMutation(
243 DAG->TII, /*ReorderWhileClustering=*/true));
244
245 if (CLOpts.vector_mask_mutation && ST.hasVInstructions())
246 DAG->addMutation(createRISCVVectorMaskDAGMutation(DAG->TRI));
247
248 return DAG;
249}
250
253 const RISCVSubtarget &ST = C->MF->getSubtarget<RISCVSubtarget>();
255
256 // Add MacroFusion mutation first with a higher priority than later clustering
257 const auto &MacroFusions = ST.getMacroFusions();
258 if (!MacroFusions.empty())
259 DAG->addMutation(createMacroFusionDAGMutation(MacroFusions));
260
261 if (ST.enablePostMISchedLoadClustering())
262 DAG->addMutation(createLoadClusterDAGMutation(
263 DAG->TII, /*ReorderWhileClustering=*/true));
264
265 if (ST.enablePostMISchedStoreClustering())
266 DAG->addMutation(createStoreClusterDAGMutation(
267 DAG->TII, /*ReorderWhileClustering=*/true));
268
269 return DAG;
270}
271
272namespace {
273
274class RVVRegisterRegAlloc : public RegisterRegAllocBase<RVVRegisterRegAlloc> {
275public:
276 RVVRegisterRegAlloc(const char *N, const char *D, FunctionPassCtor C)
277 : RegisterRegAllocBase(N, D, C) {}
278};
279
280static bool onlyAllocateRVVReg(const TargetRegisterInfo &TRI,
282 const Register Reg) {
285}
286
287static FunctionPass *useDefaultRegisterAllocator() { return nullptr; }
288
289static llvm::once_flag InitializeDefaultRVVRegisterAllocatorFlag;
290
291/// -riscv-rvv-regalloc=<fast|basic|greedy> command line option.
292/// This option could designate the rvv register allocator only.
293/// For example: -riscv-rvv-regalloc=basic
294static cl::opt<RVVRegisterRegAlloc::FunctionPassCtor, false,
296 RVVRegAlloc("riscv-rvv-regalloc", cl::Hidden,
298 cl::desc("Register allocator to use for RVV register."));
299
300static void initializeDefaultRVVRegisterAllocatorOnce() {
301 RegisterRegAlloc::FunctionPassCtor Ctor = RVVRegisterRegAlloc::getDefault();
302
303 if (!Ctor) {
304 Ctor = RVVRegAlloc;
305 RVVRegisterRegAlloc::setDefault(RVVRegAlloc);
306 }
307}
308
309static FunctionPass *createBasicRVVRegisterAllocator() {
310 return createBasicRegisterAllocator(onlyAllocateRVVReg);
311}
312
313static FunctionPass *createGreedyRVVRegisterAllocator() {
314 return createGreedyRegisterAllocator(onlyAllocateRVVReg);
315}
316
317static FunctionPass *createFastRVVRegisterAllocator() {
318 return createFastRegisterAllocator(onlyAllocateRVVReg, false);
319}
320
321static RVVRegisterRegAlloc basicRegAllocRVVReg("basic",
322 "basic register allocator",
323 createBasicRVVRegisterAllocator);
324static RVVRegisterRegAlloc
325 greedyRegAllocRVVReg("greedy", "greedy register allocator",
326 createGreedyRVVRegisterAllocator);
327
328static RVVRegisterRegAlloc fastRegAllocRVVReg("fast", "fast register allocator",
329 createFastRVVRegisterAllocator);
330
331class RISCVPassConfig : public TargetPassConfig {
332 const RISCVOptions &CLOpts;
333
334public:
335 RISCVPassConfig(RISCVTargetMachine &TM, PassManagerBase &PM)
336 : TargetPassConfig(TM, PM), CLOpts(TM.getCLOpts()) {
337 if (TM.getOptLevel() != CodeGenOptLevel::None)
338 substitutePass(&PostRASchedulerID, &PostMachineSchedulerID);
339 setEnableSinkAndFold(CLOpts.enable_sink_fold);
340 EnableLoopTermFold = true;
341 }
342
343 RISCVTargetMachine &getRISCVTargetMachine() const {
345 }
346
347 void addIRPasses() override;
348 bool addPreISel() override;
349 void addCodeGenPrepare() override;
350 bool addInstSelector() override;
351 bool addIRTranslator() override;
352 void addPreLegalizeMachineIR() override;
353 bool addLegalizeMachineIR() override;
354 void addPreRegBankSelect() override;
355 bool addRegBankSelect() override;
356 bool addGlobalInstructionSelect() override;
357 void addPreEmitPass() override;
358 void addPreEmitPass2() override;
359 void addPreSched2() override;
360 void addMachineSSAOptimization() override;
361 FunctionPass *createRVVRegAllocPass(bool Optimized);
362 bool addRegAssignAndRewriteFast() override;
363 bool addRegAssignAndRewriteOptimized() override;
364 void addPreRegAlloc() override;
365 void addPostRegAlloc() override;
366 void addFastRegAlloc() override;
367 bool addILPOpts() override;
368
369 std::unique_ptr<CSEConfigBase> getCSEConfig() const override;
370};
371} // namespace
372
374 return new RISCVPassConfig(*this, PM);
375}
376
377std::unique_ptr<CSEConfigBase> RISCVPassConfig::getCSEConfig() const {
378 return getStandardCSEConfigForOpt(TM->getOptLevel());
379}
380
381FunctionPass *RISCVPassConfig::createRVVRegAllocPass(bool Optimized) {
382 // Initialize the global default.
383 llvm::call_once(InitializeDefaultRVVRegisterAllocatorFlag,
384 initializeDefaultRVVRegisterAllocatorOnce);
385
386 RegisterRegAlloc::FunctionPassCtor Ctor = RVVRegisterRegAlloc::getDefault();
387 if (Ctor != useDefaultRegisterAllocator)
388 return Ctor();
389
390 if (Optimized)
391 return createGreedyRVVRegisterAllocator();
392
393 return createFastRVVRegisterAllocator();
394}
395
396bool RISCVPassConfig::addRegAssignAndRewriteFast() {
397 addPass(createRVVRegAllocPass(false));
399 if (TM->getOptLevel() != CodeGenOptLevel::None && CLOpts.enable_dead_defs)
402}
403
404bool RISCVPassConfig::addRegAssignAndRewriteOptimized() {
405 addPass(createRVVRegAllocPass(true));
406 addPass(createVirtRegRewriter(false));
408 if (TM->getOptLevel() != CodeGenOptLevel::None && CLOpts.enable_dead_defs)
411}
412
413void RISCVPassConfig::addIRPasses() {
416
417 if (getOptLevel() != CodeGenOptLevel::None) {
418 if (CLOpts.enable_loop_data_prefetch)
420
424 }
425
427
428 if (getOptLevel() == CodeGenOptLevel::Aggressive && CLOpts.select_opt)
429 addPass(createSelectOptimizePass());
430}
431
432bool RISCVPassConfig::addPreISel() {
433 if (TM->getOptLevel() != CodeGenOptLevel::None)
435 if (TM->getOptLevel() != CodeGenOptLevel::None) {
436 // Add a barrier before instruction selection so that we will not get
437 // deleted block address after enabling default outlining. See D99707 for
438 // more details.
439 addPass(createBarrierNoopPass());
440 }
441
442 if (valueOr(CLOpts.enable_global_merge,
443 TM->getOptLevel() != CodeGenOptLevel::None)) {
444 // FIXME: Like AArch64, we disable extern global merging by default due to
445 // concerns it might regress some workloads. Unlike AArch64, we don't
446 // currently support enabling the pass in an "OnlyOptimizeForSize" mode.
447 // Investigating and addressing both items are TODO.
448 addPass(createGlobalMergePass(TM, /* MaxOffset */ 2047,
449 /* OnlyOptimizeForSize */ false,
450 /* MergeExternalByDefault */ true));
451 }
452
453 return false;
454}
455
456void RISCVPassConfig::addCodeGenPrepare() {
457 if (getOptLevel() != CodeGenOptLevel::None)
460}
461
462bool RISCVPassConfig::addInstSelector() {
463 addPass(createRISCVISelDagLegacyPass(getRISCVTargetMachine(), getOptLevel()));
464
465 return false;
466}
467
468bool RISCVPassConfig::addIRTranslator() {
469 addPass(new IRTranslatorLegacy(getOptLevel()));
470 return false;
471}
472
473void RISCVPassConfig::addPreLegalizeMachineIR() {
474 if (getOptLevel() == CodeGenOptLevel::None) {
476 } else {
478 }
479}
480
481bool RISCVPassConfig::addLegalizeMachineIR() {
482 addPass(new LegalizerLegacy());
483 return false;
484}
485
486void RISCVPassConfig::addPreRegBankSelect() {
487 if (getOptLevel() != CodeGenOptLevel::None)
489}
490
491bool RISCVPassConfig::addRegBankSelect() {
492 addPass(new RegBankSelectLegacy());
493 return false;
494}
495
496bool RISCVPassConfig::addGlobalInstructionSelect() {
497 addPass(new InstructionSelectLegacy(getOptLevel()));
498 return false;
499}
500
501void RISCVPassConfig::addPreSched2() {
503
504 // Emit KCFI checks for indirect calls.
505 addPass(createKCFIPass());
506 if (TM->getOptLevel() != CodeGenOptLevel::None)
508}
509
510void RISCVPassConfig::addPreEmitPass() {
511 // TODO: It would potentially be better to schedule copy propagation after
512 // expanding pseudos (in addPreEmitPass2). However, performing copy
513 // propagation after the machine outliner (which runs after addPreEmitPass)
514 // currently leads to incorrect code-gen, where copies to registers within
515 // outlined functions are removed erroneously.
516 if (TM->getOptLevel() >= CodeGenOptLevel::Default &&
517 CLOpts.enable_copy_propagation)
519 if (TM->getOptLevel() >= CodeGenOptLevel::Default)
521 // The IndirectBranchTrackingPass inserts lpad and could have changed the
522 // basic block alignment. It must be done before Branch Relaxation to
523 // prevent the adjusted offset exceeding the branch range.
525 addPass(&BranchRelaxationPassID);
527}
528
529void RISCVPassConfig::addPreEmitPass2() {
530 if (TM->getOptLevel() != CodeGenOptLevel::None) {
532 // Schedule PushPop Optimization before expansion of Pseudo instruction,
533 // ensuring return instruction is detected correctly.
535 }
537
538 // Add QC Relaxation Markers as late as possible, and only for RV32
539 if (TM->getOptLevel() != CodeGenOptLevel::None &&
540 TM->getTargetTriple().isRISCV32())
542
543 // Schedule the expansion of AMOs at the last possible moment, avoiding the
544 // possibility for other passes to break the requirements for forward
545 // progress in the LR/SC block.
547
548 // KCFI indirect call checks are lowered to a bundle.
550 return MF.getFunction().getParent()->getModuleFlag("kcfi");
551 }));
552
553 if (CLOpts.enable_cfi_instr_inserter)
555}
556
557void RISCVPassConfig::addMachineSSAOptimization() {
558 // It's beneficial to reduce the VL to enable more
559 // Machine SSA optimizations.
560 if (TM->getOptLevel() != CodeGenOptLevel::None) {
561 // RISCVVLOptimizer can make loop invariant instructions like vmv.v.i
562 // loop variant by propagating a VL defined inside the loop. Run LICM and
563 // hoist them early. Don't do this at -O0 to avoid the compile-time
564 // overhead. Not reducing the VL of loop invariant pseudos results in more
565 // vsetvli toggles, and still requires the MachineLoopInfo analysis to be
566 // run.
567 addPass(&EarlyMachineLICMID);
569 }
570
573
575
576 if (TM->getTargetTriple().isRISCV64()) {
578 }
579}
580
581void RISCVPassConfig::addPreRegAlloc() {
583 if (TM->getOptLevel() != CodeGenOptLevel::None) {
586 }
587
592}
593
594void RISCVPassConfig::addFastRegAlloc() {
595 addPass(&InitUndefID);
597}
598
599
600void RISCVPassConfig::addPostRegAlloc() {
601 if (TM->getOptLevel() != CodeGenOptLevel::None && CLOpts.enable_copyelim)
603}
604
605bool RISCVPassConfig::addILPOpts() {
606 if (CLOpts.enable_machine_combiner)
607 addPass(&MachineCombinerID);
608
609 return true;
610}
611
616
622
625 SMDiagnostic &Error, SMRange &SourceRange) const {
626 const auto &YamlMFI =
627 static_cast<const yaml::RISCVMachineFunctionInfo &>(MFI);
628 PFS.MF.getInfo<RISCVMachineFunctionInfo>()->initializeBaseYamlFields(YamlMFI);
629 return false;
630}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
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")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
Provides analysis for continuously CSEing during GISel passes.
#define LLVM_ABI
Definition Compiler.h:211
#define LLVM_EXTERNAL_VISIBILITY
Definition Compiler.h:132
This file declares the IRTranslator pass.
#define F(x, y, z)
Definition MD5.cpp:54
#define I(x, y, z)
Definition MD5.cpp:57
Register Reg
Register const TargetRegisterInfo * TRI
#define T
MachineRegisterInfo & MRI
LLVM_ABI LLVM_EXTERNAL_VISIBILITY void LLVMInitializeRISCVTarget()
This file defines a TargetTransformInfoImplBase conforming object specific to the RISC-V target machi...
This file describes the interface of the MachineFunctionPass responsible for assigning the generic vi...
const GCNTargetMachine & getTM(const GCNSubtarget *STI)
static TableGen::Emitter::Opt Y("gen-skeleton-entry", EmitSkeleton, "Generate example skeleton entry")
static FunctionPass * useDefaultRegisterAllocator()
-regalloc=... command line option.
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 parsed version of the target data layout string in and methods for querying it.
Definition DataLayout.h:64
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
FunctionPass class - This class is used to implement most global optimizations.
Definition Pass.h:312
Module * getParent()
Get the module that this global value is contained inside of...
This pass is responsible for selecting generic machine instructions to target-specific instructions.
static void setUseExtended(bool Enable)
Function & getFunction()
Return the LLVM function that this machine code represents.
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
const TargetRegisterClass * getRegClass(Register Reg) const
Return the register class of the specified virtual register.
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:68
Metadata * getModuleFlag(StringRef Key) const
Return the corresponding value if Key appears in module flags, otherwise return null.
Definition Module.cpp:377
static LLVM_ABI PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
RISCVMachineFunctionInfo - This class is derived from MachineFunctionInfo and contains private RISCV-...
yaml::MachineFunctionInfo * createDefaultFuncInfoYAML() const override
Allocate and return a default initialized instance of the YAML representation for the MachineFunction...
RISCVTargetMachine(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)
TargetPassConfig * createPassConfig(PassManagerBase &PM) override
Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of ...
TargetTransformInfo getTargetTransformInfo(const Function &F) const override
Get a TargetTransformInfo implementation for the target.
bool isNoopAddrSpaceCast(const DataLayout &DL, unsigned SrcAS, unsigned DstAS) const override
Returns true if a cast between SrcAS and DestAS is a noop.
ScheduleDAGInstrs * createMachineScheduler(MachineSchedContext *C) const override
Create an instance of ScheduleDAGInstrs to be run within the standard MachineScheduler pass for this ...
ScheduleDAGInstrs * createPostMachineScheduler(MachineSchedContext *C) const override
Similar to createMachineScheduler but used when postRA machine scheduling is enabled.
MachineFunctionInfo * createMachineFunctionInfo(BumpPtrAllocator &Allocator, const Function &F, const TargetSubtargetInfo *STI) const override
Create the target's instance of MachineFunctionInfo.
yaml::MachineFunctionInfo * convertFuncInfoToYAML(const MachineFunction &MF) const override
Allocate and initialize an instance of the YAML representation of the MachineFunctionInfo.
bool parseMachineFunctionInfo(const yaml::MachineFunctionInfo &, PerFunctionMIParsingState &PFS, SMDiagnostic &Error, SMRange &SourceRange) const override
Parse out the target's MachineFunctionInfo from the YAML reprsentation.
const RISCVSubtarget * getSubtargetImpl() const =delete
This pass implements the reg bank selector pass used in the GlobalISel pipeline.
RegisterPassParser class - Handle the addition of new machine passes.
RegisterRegAllocBase class - Track the registration of register allocators.
Wrapper class representing virtual and physical registers.
Definition Register.h:20
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition SourceMgr.h:307
Represents a range in source code.
Definition SMLoc.h:47
A ScheduleDAG for scheduling lists of MachineInstr.
ScheduleDAGMILive is an implementation of ScheduleDAGInstrs that schedules machine instructions while...
ScheduleDAGMI is an implementation of ScheduleDAGInstrs that simply schedules machine instructions ac...
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition SmallString.h:28
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
CodeGenOptLevel getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
void setSupportsDebugEntryValues(bool Enable)
Triple TargetTriple
Triple string, CPU name, and target feature strings the TargetMachine instance is created with.
void setMachineOutliner(bool Enable)
void setCFIFixup(bool Enable)
void setSupportsDefaultOutlining(bool Enable)
StringRef getTargetABIName(const Module &M) const
Returns the effective target ABI name: the "target-abi" module flag if present, otherwise the -target...
const DataLayout DL
DataLayout for the target: keep ABI type size and alignment.
std::unique_ptr< const MCSubtargetInfo > STI
TargetOptions Options
Target-Independent Code Generator Pass Configuration Options.
virtual void addCodeGenPrepare()
Add pass to prepare the LLVM IR for code generation.
virtual bool addRegAssignAndRewriteFast()
Add core register allocator passes which do the actual register assignment and rewriting.
virtual void addIRPasses()
Add common target configurable passes that perform LLVM IR to IR transforms following machine indepen...
virtual void addFastRegAlloc()
addFastRegAlloc - Add the minimum set of target-independent passes that are required for fast registe...
virtual void addMachineSSAOptimization()
addMachineSSAOptimization - Add standard passes that optimize machine instructions in SSA form.
virtual bool addRegAssignAndRewriteOptimized()
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
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 ...
Registers T with cl::parseCommandLineOptions.
A raw_ostream that writes to an SmallVector or SmallString.
const AArch64MCOptions & getCLOpts(const MCTargetOptions &Options)
static constexpr unsigned RVVBitsPerBlock
This namespace contains all of the command line option processing machinery.
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.
FunctionPass * createRISCVVectorPeepholeLegacyPass()
void initializeRISCVO0PreLegalizerCombinerLegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createFastRegisterAllocator()
FastRegisterAllocation Pass - This pass register allocates as fast as possible.
void initializeRISCVFoldMemOffsetLegacyPass(PassRegistry &)
LLVM_ABI char & EarlyMachineLICMID
This pass performs loop invariant code motion on machine instructions.
LLVM_ABI char & InitUndefID
LLVM_ABI std::unique_ptr< ScheduleDAGMutation > createMacroFusionDAGMutation(ArrayRef< MacroFusionPredTy > Predicates, bool BranchOnly=false)
Create a DAG scheduling mutation to pair instructions back to back for instructions that benefit acco...
void initializeRISCVLateBranchOptLegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createTypePromotionLegacyPass()
Create IR Type Promotion pass.
LLVM_ABI FunctionPass * createGreedyRegisterAllocator()
Greedy register allocation pass - This pass implements a global register allocator for optimized buil...
FunctionPass * createRISCVCodeGenPrepareLegacyPass()
FunctionPass * createRISCVISelDagLegacyPass(RISCVTargetMachine &TM, CodeGenOptLevel OptLevel)
FunctionPass * createRISCVOptWInstrsLegacyPass()
void initializeRISCVQCRelaxMarkingLegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createSelectOptimizePass()
This pass converts conditional moves to conditional jumps when profitable.
LLVM_ABI Pass * createGlobalMergePass(const TargetMachine *TM, unsigned MaximalOffset, bool OnlyOptimizeForSize=false, bool MergeExternalByDefault=false, bool MergeConstantByDefault=false, bool MergeConstAggressiveByDefault=false)
GlobalMerge - This pass merges internal (by default) globals into structs to enable reuse of a base p...
LLVM_ABI std::unique_ptr< ScheduleDAGMutation > createLoadClusterDAGMutation(const TargetInstrInfo *TII, bool ReorderWhileClustering=false)
If ReorderWhileClustering is set to true, no attempt will be made to reduce reordering due to store c...
Target & getTheRISCV32Target()
FunctionPass * createRISCVGatherScatterLoweringLegacyPass()
FunctionPass * createRISCVMoveMergeLegacyPass()
Returns an instance of the move merge pass.
FunctionPass * createRISCVLandingPadSetupLegacyPass()
void initializeRISCVPromoteConstantLegacyPass(PassRegistry &)
LLVM_ABI char & PostRASchedulerID
PostRAScheduler - This pass performs post register allocation scheduling.
void initializeRISCVExpandPseudoPreEmitLegacyPass(PassRegistry &)
FunctionPass * createRISCVExpandPseudoPostRALegacyPass()
FunctionPass * createRISCVExpandPseudoAtomicsLegacyPass()
Target & getTheRISCV64beTarget()
FunctionPass * createRISCVZacasABIFixLegacyPass()
LLVM_ABI std::unique_ptr< CSEConfigBase > getStandardCSEConfigForOpt(CodeGenOptLevel Level)
Definition CSEInfo.cpp:85
LLVM_ABI char & PostMachineSchedulerID
PostMachineScheduler - This pass schedules machine instructions postRA.
LLVM_ABI std::unique_ptr< ScheduleDAGMutation > createStoreClusterDAGMutation(const TargetInstrInfo *TII, bool ReorderWhileClustering=false)
If ReorderWhileClustering is set to true, no attempt will be made to reduce reordering due to store c...
void initializeRISCVCodeGenPrepareLegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createCFIInstrInserterLegacy()
Creates CFI Instruction Inserter pass.
void initializeRISCVRedundantCopyEliminationLegacyPass(PassRegistry &)
FunctionPass * createRISCVLateBranchOptLegacyPass()
ModulePass * createRISCVPromoteConstantLegacyPass()
FunctionPass * createRISCVIndirectBranchTrackingLegacyPass()
FunctionPass * createRISCVDeadRegisterDefinitionsLegacyPass()
void initializeRISCVPostLegalizerCombinerLegacyPass(PassRegistry &)
LLVM_ABI void initializeMachineKCFILegacyPass(PassRegistry &)
LLVM_ABI char & MachineCombinerID
This pass performs instruction combining using trace metrics to estimate critical-path and resource d...
FunctionPass * createRISCVMakeCompressibleLegacyPass()
Returns an instance of the Make Compressible Optimization pass.
LLVM_ABI FunctionPass * createUnpackMachineBundlesLegacy(std::function< bool(const MachineFunction &)> Ftor)
static Reloc::Model getEffectiveRelocModel(std::optional< Reloc::Model > RM)
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.
FunctionPass * createRISCVPreLegalizerCombinerLegacyPass()
void initializeRISCVLoadStoreOptLegacyPass(PassRegistry &)
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
Definition MathExtras.h:280
void initializeRISCVExpandPseudoAtomicsLegacyPass(PassRegistry &)
ScheduleDAGMI * createSchedPostRA(MachineSchedContext *C)
Create a generic scheduler with no vreg liveness or DAG mutation passes.
LLVM_ABI char & BranchRelaxationPassID
BranchRelaxation - This pass replaces branches that need to jump further than is supported by a branc...
FunctionPass * createRISCVExpandPseudoPreEmitLegacyPass()
void initializeRISCVDAGToDAGISelLegacyPass(PassRegistry &)
decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
void initializeRISCVInsertVSETVLILegacyPass(PassRegistry &)
FunctionPass * createRISCVFoldMemOffsetLegacyPass()
LLVM_ABI FunctionPass * createKCFIPass()
Lowers KCFI operand bundles for indirect calls.
Definition KCFI.cpp:75
void initializeRISCVMakeCompressibleLegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createLoopDataPrefetchPass()
FunctionPass * createRISCVMergeBaseOffsetLegacyPass()
Returns an instance of the Merge Base Offset Optimization pass.
void initializeRISCVPushPopOptLegacyPass(PassRegistry &)
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
Definition Error.cpp:163
FunctionPass * createRISCVPushPopOptLegacyPass()
createRISCVPushPopOptimizationPass - returns an instance of the Push/Pop optimization pass.
FunctionPass * createRISCVQCRelaxMarkingLegacyPass()
FunctionPass * createRISCVLoadStoreOptLegacyPass()
void initializeRISCVExpandPseudoPreRALegacyPass(PassRegistry &)
void initializeRISCVInsertWriteVXRMLegacyPass(PassRegistry &)
CodeGenOptLevel
Code generation optimization level.
Definition CodeGen.h:280
@ Default
-O2, -Os, -Oz
Definition CodeGen.h:283
void initializeRISCVLandingPadSetupLegacyPass(PassRegistry &)
FunctionPass * createRISCVInsertWriteVXRMLegacyPass()
void initializeRISCVVLOptimizerLegacyPass(PassRegistry &)
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
FunctionPass * createRISCVPostLegalizerCombinerLegacyPass()
void initializeRISCVDeadRegisterDefinitionsLegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createInterleavedAccessPass()
InterleavedAccess Pass - This pass identifies and matches interleaved memory accesses to target speci...
void initializeRISCVPreAllocZilsdOptLegacyPass(PassRegistry &)
std::unique_ptr< ScheduleDAGMutation > createRISCVVectorMaskDAGMutation(const TargetRegisterInfo *TRI)
LLVM_ABI FunctionPass * createBasicRegisterAllocator()
BasicRegisterAllocation Pass - This pass implements a degenerate global register allocator using the ...
LLVM_ABI void initializeGlobalISel(PassRegistry &)
Initialize all passes linked into the GlobalISel library.
FunctionPass * createRISCVRedundantCopyEliminationLegacyPass()
void initializeRISCVVectorPeepholeLegacyPass(PassRegistry &)
void initializeRISCVVMV0EliminationLegacyPass(PassRegistry &)
LLVM_ABI ModulePass * createBarrierNoopPass()
createBarrierNoopPass - This pass is purely a module pass barrier in a pass manager.
void initializeRISCVIndirectBranchTrackingLegacyPass(PassRegistry &)
Target & getTheRISCV64Target()
FunctionPass * createRISCVExpandPseudoPreRALegacyPass()
FunctionPass * createRISCVVMV0EliminationLegacyPass()
void call_once(once_flag &flag, Function &&F, Args &&... ArgList)
Execute the function specified as a parameter once.
Definition Threading.h:86
FunctionPass * createRISCVO0PreLegalizerCombinerLegacyPass()
void initializeRISCVMergeBaseOffsetLegacyPass(PassRegistry &)
void initializeRISCVAsmPrinterPass(PassRegistry &)
FunctionPass * createRISCVInsertReadWriteCSRLegacyPass()
void initializeRISCVOptWInstrsLegacyPass(PassRegistry &)
void initializeRISCVGatherScatterLoweringLegacyPass(PassRegistry &)
void initializeRISCVInsertReadWriteCSRLegacyPass(PassRegistry &)
void initializeRISCVZacasABIFixLegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createVirtRegRewriter(bool ClearVirtRegs=true)
constexpr bool valueOr(BoolOrDefault X, bool Default)
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
void initializeRISCVPreLegalizerCombinerLegacyPass(PassRegistry &)
T bit_floor(T Value)
Returns the largest integral power of two no greater than Value if Value is nonzero.
Definition bit.h:347
LLVM_ABI MachineFunctionPass * createMachineCopyPropagationPass(bool UseCopyInstr)
FunctionPass * createRISCVVLOptimizerLegacyPass()
void initializeRISCVExpandPseudoPostRALegacyPass(PassRegistry &)
FunctionPass * createRISCVPreAllocZilsdOptLegacyPass()
FunctionPass * createRISCVInsertVSETVLILegacyPass()
Returns an instance of the Insert VSETVLI pass.
Target & getTheRISCV32beTarget()
void initializeRISCVMoveMergeLegacyPass(PassRegistry &)
MCRegisterClass TargetRegisterClass
Definition FastISel.h:58
#define N
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...
static bool isRVVRegClass(const TargetRegisterClass *RC)
RegisterTargetMachine - Helper template for registering a target machine implementation,...
The llvm::once_flag structure.
Definition Threading.h:67
Targets should override this in a way that mirrors the implementation of llvm::MachineFunctionInfo.