LLVM  13.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 
21 namespace llvm {
22 
23 class Module;
24 
26  std::unique_ptr<TargetLoweringObjectFile> TLOF;
27  mutable StringMap<std::unique_ptr<HexagonSubtarget>> SubtargetMap;
28 
29 public:
30  HexagonTargetMachine(const Target &T, const Triple &TT, StringRef CPU,
33  CodeGenOpt::Level OL, bool JIT);
34  ~HexagonTargetMachine() override;
35  const HexagonSubtarget *getSubtargetImpl(const Function &F) const override;
36 
37  static unsigned getModuleMatchQuality(const Module &M);
38 
39  void adjustPassManager(PassManagerBuilder &PMB) override;
43 
45  return static_cast<HexagonTargetObjectFile*>(TLOF.get());
46  }
47 };
48 
49 } // end namespace llvm
50 
51 #endif
llvm
Definition: AllocatorList.h:23
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::TargetOptions
Definition: TargetOptions.h:113
llvm::Function
Definition: Function.h:61
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:125
HexagonSubtarget.h
llvm::HexagonTargetMachine
Definition: HexagonTargetMachine.h:25
llvm::TargetTransformInfo
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Definition: TargetTransformInfo.h:167
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:45
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:325
llvm::TargetMachine::RM
Reloc::Model RM
Definition: TargetMachine.h:100
llvm::Optional< Reloc::Model >
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::HexagonTargetObjectFile
Definition: HexagonTargetObjectFile.h:18
F
#define F(x, y, z)
Definition: MD5.cpp:56
TargetMachine.h
llvm::PassBuilder
This class provides access to building LLVM's passes.
Definition: PassBuilder.h:139
llvm::HexagonTargetMachine::registerPassBuilderCallbacks
void registerPassBuilderCallbacks(PassBuilder &PB) override
Allow the target to modify the pass pipeline with New Pass Manager (similar to adjustPassManager for ...
Definition: HexagonTargetMachine.cpp:281
HexagonInstrInfo.h
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:108
llvm::PassManagerBuilder
PassManagerBuilder - This class is used to set up a standard optimization sequence for languages like...
Definition: PassManagerBuilder.h:59
PB
PassBuilder PB(Machine, PassOpts->PTO, None, &PIC)
llvm::TargetPassConfig
Target-Independent Code Generator Pass Configuration Options.
Definition: TargetPassConfig.h:84
llvm::EngineKind::JIT
@ JIT
Definition: ExecutionEngine.h:525
llvm::HexagonTargetMachine::getTargetTransformInfo
TargetTransformInfo getTargetTransformInfo(const Function &F) override
Get a TargetTransformInfo implementation for the target.
Definition: HexagonTargetMachine.cpp:293
llvm::TargetMachine::Options
TargetOptions Options
Definition: TargetMachine.h:115
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::HexagonTargetMachine::getModuleMatchQuality
static unsigned getModuleMatchQuality(const Module &M)
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
HexagonTargetObjectFile.h
Module
Machine Check Debug Module
Definition: MachineCheckDebugify.cpp:122
llvm::CodeGenOpt::Level
Level
Definition: CodeGen.h:52
llvm::HexagonTargetMachine::adjustPassManager
void adjustPassManager(PassManagerBuilder &PMB) override
Allow the target to modify the pass manager, e.g.
Definition: HexagonTargetMachine.cpp:268
llvm::HexagonTargetMachine::~HexagonTargetMachine
~HexagonTargetMachine() override
Definition: HexagonTargetMachine.cpp:298
llvm::HexagonTargetMachine::HexagonTargetMachine
HexagonTargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM, CodeGenOpt::Level OL, bool JIT)
Definition: HexagonTargetMachine.cpp:215
llvm::LLVMTargetMachine
This class describes a target machine that is implemented with the LLVM target-independent code gener...
Definition: TargetMachine.h:385
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:238
llvm::HexagonTargetMachine::getObjFileLowering
HexagonTargetObjectFile * getObjFileLowering() const override
Definition: HexagonTargetMachine.h:44
llvm::HexagonSubtarget
Definition: HexagonSubtarget.h:42
llvm::legacy::PassManagerBase
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
Definition: LegacyPassManager.h:39
llvm::X86AS::FS
@ FS
Definition: X86.h:188