LLVM 19.0.0git
HexagonTargetMachine.cpp
Go to the documentation of this file.
1//===-- HexagonTargetMachine.cpp - Define TargetMachine for Hexagon -------===//
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 Hexagon target spec.
10//
11//===----------------------------------------------------------------------===//
12
14#include "Hexagon.h"
15#include "HexagonISelLowering.h"
23#include "llvm/CodeGen/Passes.h"
26#include "llvm/IR/Module.h"
31#include <optional>
32
33using namespace llvm;
34
35static cl::opt<bool>
36 EnableCExtOpt("hexagon-cext", cl::Hidden, cl::init(true),
37 cl::desc("Enable Hexagon constant-extender optimization"));
38
40 cl::desc("Enable RDF-based optimizations"));
41
43 "rdf-bb-limit", cl::Hidden, cl::init(1000),
44 cl::desc("Basic block limit for a function for RDF optimizations"));
45
46static cl::opt<bool> DisableHardwareLoops("disable-hexagon-hwloops",
47 cl::Hidden, cl::desc("Disable Hardware Loops for Hexagon target"));
48
49static cl::opt<bool>
50 DisableAModeOpt("disable-hexagon-amodeopt", cl::Hidden,
51 cl::desc("Disable Hexagon Addressing Mode Optimization"));
52
53static cl::opt<bool>
54 DisableHexagonCFGOpt("disable-hexagon-cfgopt", cl::Hidden,
55 cl::desc("Disable Hexagon CFG Optimization"));
56
57static cl::opt<bool>
58 DisableHCP("disable-hcp", cl::Hidden,
59 cl::desc("Disable Hexagon constant propagation"));
60
61static cl::opt<bool> DisableStoreWidening("disable-store-widen",
62 cl::Hidden, cl::init(false), cl::desc("Disable store widening"));
63
64static cl::opt<bool> EnableExpandCondsets("hexagon-expand-condsets",
65 cl::init(true), cl::Hidden,
66 cl::desc("Early expansion of MUX"));
67
68static cl::opt<bool> EnableTfrCleanup("hexagon-tfr-cleanup", cl::init(true),
70 cl::desc("Cleanup of TFRs/COPYs"));
71
72static cl::opt<bool> EnableEarlyIf("hexagon-eif", cl::init(true), cl::Hidden,
73 cl::desc("Enable early if-conversion"));
74
75static cl::opt<bool> EnableGenInsert("hexagon-insert", cl::init(true),
76 cl::Hidden, cl::desc("Generate \"insert\" instructions"));
77
78static cl::opt<bool>
79 EnableCommGEP("hexagon-commgep", cl::init(true), cl::Hidden,
80 cl::desc("Enable commoning of GEP instructions"));
81
82static cl::opt<bool> EnableGenExtract("hexagon-extract", cl::init(true),
83 cl::Hidden, cl::desc("Generate \"extract\" instructions"));
84
85static cl::opt<bool> EnableGenMux("hexagon-mux", cl::init(true), cl::Hidden,
86 cl::desc("Enable converting conditional transfers into MUX instructions"));
87
88static cl::opt<bool> EnableGenPred("hexagon-gen-pred", cl::init(true),
89 cl::Hidden, cl::desc("Enable conversion of arithmetic operations to "
90 "predicate instructions"));
91
92static cl::opt<bool>
93 EnableLoopPrefetch("hexagon-loop-prefetch", cl::Hidden,
94 cl::desc("Enable loop data prefetch on Hexagon"));
95
96static cl::opt<bool> DisableHSDR("disable-hsdr", cl::init(false), cl::Hidden,
97 cl::desc("Disable splitting double registers"));
98
99static cl::opt<bool>
100 EnableGenMemAbs("hexagon-mem-abs", cl::init(true), cl::Hidden,
101 cl::desc("Generate absolute set instructions"));
102
103static cl::opt<bool> EnableBitSimplify("hexagon-bit", cl::init(true),
104 cl::Hidden, cl::desc("Bit simplification"));
105
106static cl::opt<bool> EnableLoopResched("hexagon-loop-resched", cl::init(true),
107 cl::Hidden, cl::desc("Loop rescheduling"));
108
109static cl::opt<bool> HexagonNoOpt("hexagon-noopt", cl::init(false),
110 cl::Hidden, cl::desc("Disable backend optimizations"));
111
112static cl::opt<bool>
113 EnableVectorPrint("enable-hexagon-vector-print", cl::Hidden,
114 cl::desc("Enable Hexagon Vector print instr pass"));
115
116static cl::opt<bool>
117 EnableVExtractOpt("hexagon-opt-vextract", cl::Hidden, cl::init(true),
118 cl::desc("Enable vextract optimization"));
119
120static cl::opt<bool>
121 EnableVectorCombine("hexagon-vector-combine", cl::Hidden, cl::init(true),
122 cl::desc("Enable HVX vector combining"));
123
125 "hexagon-initial-cfg-cleanup", cl::Hidden, cl::init(true),
126 cl::desc("Simplify the CFG after atomic expansion pass"));
127
128static cl::opt<bool> EnableInstSimplify("hexagon-instsimplify", cl::Hidden,
129 cl::init(true),
130 cl::desc("Enable instsimplify"));
131
133 "hexagon-postinc-opt", cl::Hidden,
134 cl::desc("Disable Hexagon post-increment optimization"));
135
136/// HexagonTargetMachineModule - Note that this is used on hosts that
137/// cannot link in a library unless there are references into the
138/// library. In particular, it seems that it is not possible to get
139/// things to work on Win32 without this. Though it is unused, do not
140/// remove it.
143
146 C, std::make_unique<HexagonConvergingVLIWScheduler>());
147 DAG->addMutation(std::make_unique<HexagonSubtarget::UsrOverflowMutation>());
148 DAG->addMutation(std::make_unique<HexagonSubtarget::HVXMemLatencyMutation>());
149 DAG->addMutation(std::make_unique<HexagonSubtarget::CallMutation>());
151 return DAG;
152}
153
155SchedCustomRegistry("hexagon", "Run Hexagon's custom scheduler",
157
158namespace llvm {
159 extern char &HexagonExpandCondsetsID;
160 extern char &HexagonTfrCleanupID;
183
201 CodeGenOptLevel OptLevel);
217} // end namespace llvm;
218
219static Reloc::Model getEffectiveRelocModel(std::optional<Reloc::Model> RM) {
220 return RM.value_or(Reloc::Static);
221}
222
224 // Register the target.
226
247}
248
250 StringRef CPU, StringRef FS,
251 const TargetOptions &Options,
252 std::optional<Reloc::Model> RM,
253 std::optional<CodeModel::Model> CM,
254 CodeGenOptLevel OL, bool JIT)
255 // Specify the vector alignment explicitly. For v512x1, the calculated
256 // alignment would be 512*alignment(i1), which is 512 bytes, instead of
257 // the required minimum of 64 bytes.
259 T,
260 "e-m:e-p:32:32:32-a:0-n16:32-"
261 "i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-"
262 "v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048",
263 TT, CPU, FS, Options, getEffectiveRelocModel(RM),
264 getEffectiveCodeModel(CM, CodeModel::Small),
266 TLOF(std::make_unique<HexagonTargetObjectFile>()) {
270 initAsmInfo();
271}
272
273const HexagonSubtarget *
275 AttributeList FnAttrs = F.getAttributes();
276 Attribute CPUAttr =
277 FnAttrs.getFnAttr("target-cpu");
278 Attribute FSAttr =
279 FnAttrs.getFnAttr("target-features");
280
281 std::string CPU =
282 CPUAttr.isValid() ? CPUAttr.getValueAsString().str() : TargetCPU;
283 std::string FS =
284 FSAttr.isValid() ? FSAttr.getValueAsString().str() : TargetFS;
285 // Append the preexisting target features last, so that +mattr overrides
286 // the "unsafe-fp-math" function attribute.
287 // Creating a separate target feature is not strictly necessary, it only
288 // exists to make "unsafe-fp-math" force creating a new subtarget.
289
290 if (F.getFnAttribute("unsafe-fp-math").getValueAsBool())
291 FS = FS.empty() ? "+unsafe-fp" : "+unsafe-fp," + FS;
292
293 auto &I = SubtargetMap[CPU + FS];
294 if (!I) {
295 // This needs to be done before we create a new subtarget since any
296 // creation will depend on the TM and the code generation flags on the
297 // function that reside in TargetOptions.
299 I = std::make_unique<HexagonSubtarget>(TargetTriple, CPU, FS, *this);
300 }
301 return I.get();
302}
303
305 PassBuilder &PB, bool PopulateClassToPassNames) {
307 [=](LoopPassManager &LPM, OptimizationLevel Level) {
309 });
311 [=](LoopPassManager &LPM, OptimizationLevel Level) {
313 });
314}
315
318 return TargetTransformInfo(HexagonTTIImpl(this, F));
319}
320
322 BumpPtrAllocator &Allocator, const Function &F,
323 const TargetSubtargetInfo *STI) const {
324 return HexagonMachineFunctionInfo::create<HexagonMachineFunctionInfo>(
325 Allocator, F, STI);
326}
327
329
330namespace {
331/// Hexagon Code Generator Pass Configuration Options.
332class HexagonPassConfig : public TargetPassConfig {
333public:
334 HexagonPassConfig(HexagonTargetMachine &TM, PassManagerBase &PM)
335 : TargetPassConfig(TM, PM) {}
336
337 HexagonTargetMachine &getHexagonTargetMachine() const {
338 return getTM<HexagonTargetMachine>();
339 }
340
342 createMachineScheduler(MachineSchedContext *C) const override {
344 }
345
346 void addIRPasses() override;
347 bool addInstSelector() override;
348 void addPreRegAlloc() override;
349 void addPostRegAlloc() override;
350 void addPreSched2() override;
351 void addPreEmitPass() override;
352};
353} // namespace
354
356 return new HexagonPassConfig(*this, PM);
357}
358
359void HexagonPassConfig::addIRPasses() {
361 bool NoOpt = (getOptLevel() == CodeGenOptLevel::None);
362
363 if (!NoOpt) {
367 }
368
370
371 if (!NoOpt) {
374 .forwardSwitchCondToPhi(true)
375 .convertSwitchRangeToICmp(true)
376 .convertSwitchToLookupTable(true)
377 .needCanonicalLoops(false)
378 .hoistCommonInsts(true)
379 .sinkCommonInsts(true)));
384 if (EnableCommGEP)
385 addPass(createHexagonCommonGEP());
386 // Replace certain combinations of shifts and ands with extracts.
388 addPass(createHexagonGenExtract());
389 }
390}
391
392bool HexagonPassConfig::addInstSelector() {
393 HexagonTargetMachine &TM = getHexagonTargetMachine();
394 bool NoOpt = (getOptLevel() == CodeGenOptLevel::None);
395
396 if (!NoOpt)
398
399 addPass(createHexagonISelDag(TM, getOptLevel()));
400
401 if (!NoOpt) {
403 addPass(createHexagonVExtract());
404 // Create logical operations on predicate registers.
405 if (EnableGenPred)
406 addPass(createHexagonGenPredicate());
407 // Rotate loops to expose bit-simplification opportunities.
410 // Split double registers.
411 if (!DisableHSDR)
413 // Bit simplification.
415 addPass(createHexagonBitSimplify());
416 addPass(createHexagonPeephole());
417 // Constant propagation.
418 if (!DisableHCP) {
421 }
422 if (EnableGenInsert)
423 addPass(createHexagonGenInsert());
424 if (EnableEarlyIf)
426 }
427
428 return false;
429}
430
431void HexagonPassConfig::addPreRegAlloc() {
432 if (getOptLevel() != CodeGenOptLevel::None) {
433 if (EnableCExtOpt)
441 if (EnableGenMemAbs)
445 }
446
447 if (TM->getOptLevel() >= CodeGenOptLevel::Aggressive)
449 addPass(createHexagonPostIncOpt());
450
451 if (TM->getOptLevel() >= CodeGenOptLevel::Default)
452 addPass(&MachinePipelinerID);
453}
454
455void HexagonPassConfig::addPostRegAlloc() {
456 if (getOptLevel() != CodeGenOptLevel::None) {
457 if (EnableRDFOpt)
458 addPass(createHexagonRDFOpt());
460 addPass(createHexagonCFGOptimizer());
461 if (!DisableAModeOpt)
462 addPass(createHexagonOptAddrMode());
463 }
464}
465
466void HexagonPassConfig::addPreSched2() {
468 if (getOptLevel() != CodeGenOptLevel::None)
469 addPass(&IfConverterID);
471}
472
473void HexagonPassConfig::addPreEmitPass() {
474 bool NoOpt = (getOptLevel() == CodeGenOptLevel::None);
475
476 if (!NoOpt)
477 addPass(createHexagonNewValueJump());
478
480
481 if (!NoOpt) {
483 addPass(createHexagonFixupHwLoops());
484 // Generate MUX from pairs of conditional transfers.
485 if (EnableGenMux)
486 addPass(createHexagonGenMux());
487 }
488
489 // Packetization is mandatory: it handles gather/scatter at all opt levels.
490 addPass(createHexagonPacketizer(NoOpt));
491
493 addPass(createHexagonVectorPrint());
494
495 // Add CFI instructions if necessary.
497}
static cl::opt< bool > EnableLoopPrefetch("amdgpu-loop-prefetch", cl::desc("Enable loop data prefetch on AMDGPU"), cl::Hidden, cl::init(false))
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:135
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
static cl::opt< bool > EnableExpandCondsets("hexagon-expand-condsets", cl::init(true), cl::Hidden, cl::desc("Early expansion of MUX"))
static cl::opt< bool > HexagonNoOpt("hexagon-noopt", cl::init(false), cl::Hidden, cl::desc("Disable backend optimizations"))
static cl::opt< bool > EnableGenExtract("hexagon-extract", cl::init(true), cl::Hidden, cl::desc("Generate \"extract\" instructions"))
static cl::opt< bool > EnableVectorCombine("hexagon-vector-combine", cl::Hidden, cl::init(true), cl::desc("Enable HVX vector combining"))
static cl::opt< bool > EnableGenMux("hexagon-mux", cl::init(true), cl::Hidden, cl::desc("Enable converting conditional transfers into MUX instructions"))
static cl::opt< bool > DisableHexagonCFGOpt("disable-hexagon-cfgopt", cl::Hidden, cl::desc("Disable Hexagon CFG Optimization"))
static cl::opt< bool > DisableAModeOpt("disable-hexagon-amodeopt", cl::Hidden, cl::desc("Disable Hexagon Addressing Mode Optimization"))
static cl::opt< bool > DisableHCP("disable-hcp", cl::Hidden, cl::desc("Disable Hexagon constant propagation"))
static cl::opt< bool > DisableStoreWidening("disable-store-widen", cl::Hidden, cl::init(false), cl::desc("Disable store widening"))
static cl::opt< bool > EnableBitSimplify("hexagon-bit", cl::init(true), cl::Hidden, cl::desc("Bit simplification"))
static cl::opt< bool > EnableVectorPrint("enable-hexagon-vector-print", cl::Hidden, cl::desc("Enable Hexagon Vector print instr pass"))
static MachineSchedRegistry SchedCustomRegistry("hexagon", "Run Hexagon's custom scheduler", createVLIWMachineSched)
static cl::opt< bool > DisableHardwareLoops("disable-hexagon-hwloops", cl::Hidden, cl::desc("Disable Hardware Loops for Hexagon target"))
static cl::opt< bool > EnableGenPred("hexagon-gen-pred", cl::init(true), cl::Hidden, cl::desc("Enable conversion of arithmetic operations to " "predicate instructions"))
static cl::opt< bool > EnableGenMemAbs("hexagon-mem-abs", cl::init(true), cl::Hidden, cl::desc("Generate absolute set instructions"))
static cl::opt< bool > EnableVExtractOpt("hexagon-opt-vextract", cl::Hidden, cl::init(true), cl::desc("Enable vextract optimization"))
static cl::opt< bool > EnableInstSimplify("hexagon-instsimplify", cl::Hidden, cl::init(true), cl::desc("Enable instsimplify"))
static cl::opt< bool > EnableRDFOpt("rdf-opt", cl::Hidden, cl::init(true), cl::desc("Enable RDF-based optimizations"))
static cl::opt< bool > EnableCExtOpt("hexagon-cext", cl::Hidden, cl::init(true), cl::desc("Enable Hexagon constant-extender optimization"))
static Reloc::Model getEffectiveRelocModel(std::optional< Reloc::Model > RM)
int HexagonTargetMachineModule
HexagonTargetMachineModule - Note that this is used on hosts that cannot link in a library unless the...
static cl::opt< bool > EnableLoopResched("hexagon-loop-resched", cl::init(true), cl::Hidden, cl::desc("Loop rescheduling"))
static cl::opt< bool > DisableHexagonPostIncOpt("hexagon-postinc-opt", cl::Hidden, cl::desc("Disable Hexagon post-increment optimization"))
static ScheduleDAGInstrs * createVLIWMachineSched(MachineSchedContext *C)
static cl::opt< bool > EnableTfrCleanup("hexagon-tfr-cleanup", cl::init(true), cl::Hidden, cl::desc("Cleanup of TFRs/COPYs"))
static cl::opt< bool > DisableHSDR("disable-hsdr", cl::init(false), cl::Hidden, cl::desc("Disable splitting double registers"))
static cl::opt< bool > EnableInitialCFGCleanup("hexagon-initial-cfg-cleanup", cl::Hidden, cl::init(true), cl::desc("Simplify the CFG after atomic expansion pass"))
cl::opt< unsigned > RDFFuncBlockLimit("rdf-bb-limit", cl::Hidden, cl::init(1000), cl::desc("Basic block limit for a function for RDF optimizations"))
static cl::opt< bool > EnableLoopPrefetch("hexagon-loop-prefetch", cl::Hidden, cl::desc("Enable loop data prefetch on Hexagon"))
LLVM_EXTERNAL_VISIBILITY void LLVMInitializeHexagonTarget()
static cl::opt< bool > EnableGenInsert("hexagon-insert", cl::init(true), cl::Hidden, cl::desc("Generate \"insert\" instructions"))
static cl::opt< bool > EnableCommGEP("hexagon-commgep", cl::init(true), cl::Hidden, cl::desc("Enable commoning of GEP instructions"))
static cl::opt< bool > EnableEarlyIf("hexagon-eif", cl::init(true), cl::Hidden, cl::desc("Enable early if-conversion"))
This file implements a TargetTransformInfo analysis pass specific to the Hexagon target machine.
static LVOptions Options
Definition: LVOptions.cpp:25
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
Module.h This file contains the declarations for the Module class.
const char LLVMTargetMachineRef TM
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
Basic Register Allocator
Target-Independent Code Generator Pass Configuration Options pass.
@ None
Attribute getFnAttr(Attribute::AttrKind Kind) const
Return the attribute object that exists for the function.
Definition: Attributes.h:826
StringRef getValueAsString() const
Return the attribute's value as a string.
Definition: Attributes.cpp:318
bool isValid() const
Return true if the attribute is any kind of attribute.
Definition: Attributes.h:184
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:311
MachineFunctionInfo * createMachineFunctionInfo(BumpPtrAllocator &Allocator, const Function &F, const TargetSubtargetInfo *STI) const override
Create the target's instance of MachineFunctionInfo.
TargetPassConfig * createPassConfig(PassManagerBase &PM) override
Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of ...
HexagonTargetMachine(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)
void registerPassBuilderCallbacks(PassBuilder &PB, bool PopulateClassToPassNames) override
Allow the target to modify the pass pipeline.
const HexagonSubtarget * getSubtargetImpl(const Function &F) const override
Virtual method implemented by subclasses that returns a reference to that target's TargetSubtargetInf...
TargetTransformInfo getTargetTransformInfo(const Function &F) const override
Get a TargetTransformInfo implementation for the target.
This class describes a target machine that is implemented with the LLVM target-independent code gener...
MachineSchedRegistry provides a selection of available machine instruction schedulers.
This class provides access to building LLVM's passes.
Definition: PassBuilder.h:104
void registerLateLoopOptimizationsEPCallback(const std::function< void(LoopPassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:414
void registerLoopOptimizerEndEPCallback(const std::function< void(LoopPassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:424
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t< is_detected< HasRunOnLoopT, PassT >::value > addPass(PassT &&Pass)
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...
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:94
A ScheduleDAG for scheduling lists of MachineInstr.
ScheduleDAGMILive is an implementation of ScheduleDAGInstrs that schedules machine instructions while...
void addMutation(std::unique_ptr< ScheduleDAGMutation > Mutation)
Add a postprocessing step to the DAG builder.
const TargetInstrInfo * TII
Target instruction information.
Definition: ScheduleDAG.h:557
const TargetRegisterInfo * TRI
Target processor register info.
Definition: ScheduleDAG.h:558
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:222
Triple TargetTriple
Triple string, CPU name, and target feature strings the TargetMachine instance is created with.
Definition: TargetMachine.h:95
std::string TargetFS
Definition: TargetMachine.h:97
std::string TargetCPU
Definition: TargetMachine.h:96
std::unique_ptr< const MCSubtargetInfo > STI
void resetTargetOptions(const Function &F) const
Reset the target options based on the function's attributes.
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
Extend the standard ScheduleDAGMILive to provide more context and override the top-level schedule() d...
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
Interfaces for registering analysis passes, producing common pass manager configurations,...
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:450
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
FunctionPass * createHexagonVectorPrint()
FunctionPass * createHexagonVectorCombineLegacyPass()
void initializeHexagonOptAddrModePass(PassRegistry &)
FunctionPass * createCFGSimplificationPass(SimplifyCFGOptions Options=SimplifyCFGOptions(), std::function< bool(const Function &)> Ftor=nullptr)
FunctionPass * createHexagonPostIncOpt()
void initializeHexagonNewValueJumpPass(PassRegistry &)
char & HexagonTfrCleanupID
FunctionPass * createHexagonCFGOptimizer()
void initializeHexagonVectorLoopCarriedReuseLegacyPassPass(PassRegistry &)
char & RegisterCoalescerID
RegisterCoalescer - This pass merges live ranges to eliminate copies.
void initializeHexagonSplitDoubleRegsPass(PassRegistry &)
void initializeHexagonPostIncOptPass(PassRegistry &)
FunctionPass * createDeadCodeEliminationPass()
Definition: DCE.cpp:145
Pass * createHexagonLoopIdiomPass()
FunctionPass * createHexagonNewValueJump()
void initializeHexagonRDFOptPass(PassRegistry &)
FunctionPass * createHexagonBranchRelaxation()
void initializeHexagonGenMemAbsolutePass(PassRegistry &Registry)
FunctionPass * createHexagonBitSimplify()
FunctionPass * createHexagonPeephole()
FunctionPass * createHexagonConstExtenders()
FunctionPass * createHexagonConstPropagationPass()
FunctionPass * createHexagonFixupHwLoops()
void initializeHexagonDAGToDAGISelPass(PassRegistry &)
Target & getTheHexagonTarget()
void initializeHexagonExpandCondsetsPass(PassRegistry &)
void initializeHexagonPacketizerPass(PassRegistry &)
FunctionPass * createHexagonPacketizer(bool Minimal)
void initializeHexagonBitSimplifyPass(PassRegistry &Registry)
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 * createHexagonGenMux()
FunctionPass * createHexagonGenExtract()
FunctionPass * createHexagonEarlyIfConversion()
FunctionPass * createLoopDataPrefetchPass()
FunctionPass * createHexagonCallFrameInformation()
void initializeHexagonTfrCleanupPass(PassRegistry &)
FunctionPass * createHexagonVExtract()
FunctionPass * createHexagonGenPredicate()
void initializeHexagonVectorCombineLegacyPass(PassRegistry &)
CodeGenOptLevel
Code generation optimization level.
Definition: CodeGen.h:54
FunctionPass * createHexagonGenInsert()
FunctionPass * createHexagonOptimizeSZextends()
FunctionPass * createHexagonLoopRescheduling()
void initializeHexagonEarlyIfConversionPass(PassRegistry &Registry)
FunctionPass * createHexagonSplitConst32AndConst64()
FunctionPass * createHexagonCopyToCombine()
char & MachinePipelinerID
This pass performs software pipelining on machine instructions.
FunctionPass * createHexagonCommonGEP()
FunctionPass * createHexagonISelDag(HexagonTargetMachine &TM, CodeGenOptLevel OptLevel)
createHexagonISelDag - This pass converts a legalized DAG into a Hexagon-specific DAG,...
char & HexagonExpandCondsetsID
FunctionPass * createHexagonOptAddrMode()
void initializeHexagonCopyToCombinePass(PassRegistry &)
FunctionPass * createHexagonGenMemAbsolute()
void initializeHexagonLoopIdiomRecognizeLegacyPassPass(PassRegistry &)
char & VirtRegRewriterID
VirtRegRewriter pass.
Definition: VirtRegMap.cpp:227
FunctionPass * createHexagonTfrCleanup()
FunctionPass * createHexagonSplitDoubleRegs()
FunctionPass * createHexagonHardwareLoops()
void initializeHexagonConstPropagationPass(PassRegistry &Registry)
char & IfConverterID
IfConverter - This pass performs machine code if conversion.
Pass * createHexagonVectorLoopCarriedReuseLegacyPass()
char & UnreachableMachineBlockElimID
UnreachableMachineBlockElimination - This pass removes unreachable machine basic blocks.
FunctionPass * createAtomicExpandLegacyPass()
AtomicExpandPass - At IR level this pass replace atomic instructions with __atomic_* library calls,...
void initializeHexagonConstExtendersPass(PassRegistry &)
FunctionPass * createHexagonStoreWidening()
void initializeHexagonGenMuxPass(PassRegistry &Registry)
std::unique_ptr< ScheduleDAGMutation > createCopyConstrainDAGMutation(const TargetInstrInfo *TII, const TargetRegisterInfo *TRI)
void initializeHexagonHardwareLoopsPass(PassRegistry &)
FunctionPass * createHexagonRDFOpt()
FunctionPass * createInstSimplifyLegacyPass()
void initializeHexagonVExtractPass(PassRegistry &)
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
Hexagon Vector Loop Carried Reuse Pass.
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...
MachineSchedContext provides enough context from the MachineScheduler pass for the target to instanti...
RegisterTargetMachine - Helper template for registering a target machine implementation,...