LLVM  17.0.0git
HexagonTargetMachine.h
Go to the documentation of this file.
1 //=-- HexagonTargetMachine.h - Define TargetMachine for Hexagon ---*- C++ -*-=//
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 // This file declares the Hexagon specific subclass of TargetMachine.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_LIB_TARGET_HEXAGON_HEXAGONTARGETMACHINE_H
14 #define LLVM_LIB_TARGET_HEXAGON_HEXAGONTARGETMACHINE_H
15 
16 #include "HexagonInstrInfo.h"
17 #include "HexagonSubtarget.h"
20 #include <optional>
21 
22 namespace llvm {
23 
24 class Module;
25 
27  std::unique_ptr<TargetLoweringObjectFile> TLOF;
28  mutable StringMap<std::unique_ptr<HexagonSubtarget>> SubtargetMap;
29 
30 public:
31  HexagonTargetMachine(const Target &T, const Triple &TT, StringRef CPU,
33  std::optional<Reloc::Model> RM,
34  std::optional<CodeModel::Model> CM, CodeGenOpt::Level OL,
35  bool JIT);
36  ~HexagonTargetMachine() override;
37  const HexagonSubtarget *getSubtargetImpl(const Function &F) const override;
38 
39  static unsigned getModuleMatchQuality(const Module &M);
40 
44 
46  return static_cast<HexagonTargetObjectFile*>(TLOF.get());
47  }
48 
51  const TargetSubtargetInfo *STI) const override;
52 };
53 
54 } // end namespace llvm
55 
56 #endif
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::TargetMachine::STI
std::unique_ptr< const MCSubtargetInfo > STI
Definition: TargetMachine.h:109
llvm::TargetOptions
Definition: TargetOptions.h:124
llvm::Function
Definition: Function.h:59
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:149
HexagonSubtarget.h
llvm::HexagonTargetMachine
Definition: HexagonTargetMachine.h:26
llvm::TargetTransformInfo
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Definition: TargetTransformInfo.h:172
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
llvm::HexagonTargetMachine::createPassConfig
TargetPassConfig * createPassConfig(PassManagerBase &PM) override
Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of ...
Definition: HexagonTargetMachine.cpp:328
llvm::X86AS::FS
@ FS
Definition: X86.h:201
llvm::TargetMachine::RM
Reloc::Model RM
Definition: TargetMachine.h:101
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::HexagonTargetObjectFile
Definition: HexagonTargetObjectFile.h:18
F
#define F(x, y, z)
Definition: MD5.cpp:55
TargetMachine.h
llvm::PassBuilder
This class provides access to building LLVM's passes.
Definition: PassBuilder.h:96
llvm::HexagonTargetMachine::registerPassBuilderCallbacks
void registerPassBuilderCallbacks(PassBuilder &PB) override
Allow the target to modify the pass pipeline.
Definition: HexagonTargetMachine.cpp:278
HexagonInstrInfo.h
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:110
llvm::TargetPassConfig
Target-Independent Code Generator Pass Configuration Options.
Definition: TargetPassConfig.h:84
llvm::EngineKind::JIT
@ JIT
Definition: ExecutionEngine.h:524
llvm::BumpPtrAllocatorImpl
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:63
llvm::TargetMachine::Options
TargetOptions Options
Definition: TargetMachine.h:119
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::HexagonTargetMachine::getModuleMatchQuality
static unsigned getModuleMatchQuality(const Module &M)
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
HexagonTargetObjectFile.h
Module
Machine Check Debug Module
Definition: MachineCheckDebugify.cpp:122
llvm::TargetSubtargetInfo
TargetSubtargetInfo - Generic base class for all target subtargets.
Definition: TargetSubtargetInfo.h:62
llvm::HexagonTargetMachine::~HexagonTargetMachine
~HexagonTargetMachine() override
llvm::HexagonTargetMachine::getTargetTransformInfo
TargetTransformInfo getTargetTransformInfo(const Function &F) const override
Get a TargetTransformInfo implementation for the target.
Definition: HexagonTargetMachine.cpp:290
llvm::LLVMTargetMachine
This class describes a target machine that is implemented with the LLVM target-independent code gener...
Definition: TargetMachine.h:417
llvm::HexagonTargetMachine::createMachineFunctionInfo
MachineFunctionInfo * createMachineFunctionInfo(BumpPtrAllocator &Allocator, const Function &F, const TargetSubtargetInfo *STI) const override
Create the target's instance of MachineFunctionInfo.
Definition: HexagonTargetMachine.cpp:294
llvm::HexagonTargetMachine::getSubtargetImpl
const HexagonSubtarget * getSubtargetImpl(const Function &F) const override
Virtual method implemented by subclasses that returns a reference to that target's TargetSubtargetInf...
Definition: HexagonTargetMachine.cpp:248
Allocator
Basic Register Allocator
Definition: RegAllocBasic.cpp:143
llvm::HexagonTargetMachine::getObjFileLowering
HexagonTargetObjectFile * getObjFileLowering() const override
Definition: HexagonTargetMachine.h:45
llvm::HexagonSubtarget
Definition: HexagonSubtarget.h:43
llvm::legacy::PassManagerBase
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
Definition: LegacyPassManager.h:39
llvm::CodeGenOpt::Level
Level
Code generation optimization level.
Definition: CodeGen.h:57
PB
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
llvm::MachineFunctionInfo
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...
Definition: MachineFunction.h:95
llvm::HexagonTargetMachine::HexagonTargetMachine
HexagonTargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, std::optional< Reloc::Model > RM, std::optional< CodeModel::Model > CM, CodeGenOpt::Level OL, bool JIT)
Definition: HexagonTargetMachine.cpp:225