LLVM 24.0.0git
ARMTargetMachine.h
Go to the documentation of this file.
1//===-- ARMTargetMachine.h - Define TargetMachine for ARM -------*- 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 ARM specific subclass of TargetMachine.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_LIB_TARGET_ARM_ARMTARGETMACHINE_H
14#define LLVM_LIB_TARGET_ARM_ARMTARGETMACHINE_H
15
16#include "ARMSubtarget.h"
17#include "llvm/ADT/StringMap.h"
18#include "llvm/ADT/StringRef.h"
25#include <memory>
26#include <optional>
27
28namespace llvm {
29
31protected:
32 std::unique_ptr<TargetLoweringObjectFile> TLOF;
35
36 /// The attributes that select a subtarget.
41
42 bool operator==(const SubtargetAttrs &RHS) const {
43 return CPU == RHS.CPU && FS == RHS.FS && SoftFloat == RHS.SoftFloat &&
44 MinSize == RHS.MinSize && DenormalFPEnv == RHS.DenormalFPEnv &&
45 FloatABI == RHS.FloatABI && ABI == RHS.ABI;
46 }
47
48 bool operator!=(const SubtargetAttrs &RHS) const { return !(*this == RHS); }
49 };
51
52 /// Reset internal state.
53 void reset() override;
54
55public:
56 ARMBaseTargetMachine(const Target &T, const Triple &TT, StringRef CPU,
58 std::optional<Reloc::Model> RM,
59 std::optional<CodeModel::Model> CM, CodeGenOptLevel OL);
61
62 const ARMSubtarget *getSubtargetImpl(const Function &F) const override;
63 // DO NOT IMPLEMENT: There is no such thing as a valid default subtarget,
64 // subtargets are per-function entities based on the target-specific
65 // attributes of each function.
66 const ARMSubtarget *getSubtargetImpl() const = delete;
67 bool isLittleEndian() const { return isLittle; }
68
69 /// Returns the floating-point ABI in effect for \p M: the "float-abi" module
70 /// flag if present, otherwise the ABI implied by the target triple. An
71 /// explicit -target-abi=aapcs16 forces the hard-float ABI.
72 FloatABI::ABIType getFloatABI(const Module &M) const;
73
74 /// Returns the ABI in effect for \p M: the "target-abi" module flag if
75 /// present, otherwise the legacy -target-abi option; falling back to the
76 /// TargetMachine-level ABI computed at construction.
77 ARM::ARMABI getEffectiveABI(const Module &M) const;
78
80
81 // Pass Pipeline Configuration
83
85
87 return TLOF.get();
88 }
89
90 bool targetSchedulesPostRAScheduling() const override { return true; };
91
94 const TargetSubtargetInfo *STI) const override;
95
96 /// Returns true if a cast between SrcAS and DestAS is a noop.
97 bool isNoopAddrSpaceCast(const DataLayout &, unsigned SrcAS,
98 unsigned DestAS) const override {
99 // Addrspacecasts are always noops.
100 return true;
101 }
102
103 bool isGVIndirectSymbol(const GlobalValue *GV) const {
104 if (!shouldAssumeDSOLocal(GV))
105 return true;
106
107 // 32 bit macho has no relocation for a-b if a is undefined, even if b is in
108 // the section that is being relocated. This means we have to use o load
109 // even for GVs that are known to be local to the dso.
110 if (getTargetTriple().isOSBinFormatMachO() && isPositionIndependent() &&
112 return true;
113
114 return false;
115 }
116
119 convertFuncInfoToYAML(const MachineFunction &MF) const override;
123 SMRange &SourceRange) const override;
128};
129
130/// ARM/Thumb little endian target machine.
131///
133public:
134 ARMLETargetMachine(const Target &T, const Triple &TT, StringRef CPU,
136 std::optional<Reloc::Model> RM,
137 std::optional<CodeModel::Model> CM, CodeGenOptLevel OL,
138 bool JIT);
139};
140
141/// ARM/Thumb big endian target machine.
142///
144public:
145 ARMBETargetMachine(const Target &T, const Triple &TT, StringRef CPU,
147 std::optional<Reloc::Model> RM,
148 std::optional<CodeModel::Model> CM, CodeGenOptLevel OL,
149 bool JIT);
150};
151
152} // end namespace llvm
153
154#endif // LLVM_LIB_TARGET_ARM_ARMTARGETMACHINE_H
This file defines the StringMap class.
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
Cache of the last subtarget a TargetMachine returned, to skip building the subtarget key for consecut...
#define F(x, y, z)
Definition MD5.cpp:54
#define T
PassBuilder PB(Mod->getContext(), Machine, PassOpts->PTO, std::nullopt, &PIC)
Basic Register Allocator
This pass exposes codegen information to IR-level passes.
Value * RHS
ARMBETargetMachine(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)
TargetLoweringObjectFile * getObjFileLowering() const override
LastSubtargetCache< ARMSubtarget, SubtargetAttrs > LastSubtarget
bool parseMachineFunctionInfo(const yaml::MachineFunctionInfo &, PerFunctionMIParsingState &PFS, SMDiagnostic &Error, SMRange &SourceRange) const override
Parse out the target's MachineFunctionInfo from the YAML reprsentation.
void registerPassBuilderCallbacks(PassBuilder &PB) override
Allow the target to modify the pass pipeline.
TargetPassConfig * createPassConfig(PassManagerBase &PM) override
Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of ...
std::unique_ptr< TargetLoweringObjectFile > TLOF
ARM::ARMABI getEffectiveABI(const Module &M) const
Returns the ABI in effect for M: the "target-abi" module flag if present, otherwise the legacy -targe...
void reset() override
Reset internal state.
ARMBaseTargetMachine(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)
Create an ARM architecture model.
MachineFunctionInfo * createMachineFunctionInfo(BumpPtrAllocator &Allocator, const Function &F, const TargetSubtargetInfo *STI) const override
Create the target's instance of MachineFunctionInfo.
yaml::MachineFunctionInfo * createDefaultFuncInfoYAML() const override
Allocate and return a default initialized instance of the YAML representation for the MachineFunction...
bool targetSchedulesPostRAScheduling() const override
True if subtarget inserts the final scheduling pass on its own.
bool isGVIndirectSymbol(const GlobalValue *GV) const
bool isNoopAddrSpaceCast(const DataLayout &, unsigned SrcAS, unsigned DestAS) const override
Returns true if a cast between SrcAS and DestAS is a noop.
const ARMSubtarget * getSubtargetImpl() const =delete
FloatABI::ABIType getFloatABI(const Module &M) const
Returns the floating-point ABI in effect for M: the "float-abi" module flag if present,...
ScheduleDAGInstrs * createMachineScheduler(MachineSchedContext *C) const override
Create an instance of ScheduleDAGInstrs to be run within the standard MachineScheduler pass for this ...
StringMap< std::unique_ptr< ARMSubtarget > > SubtargetMap
TargetTransformInfo getTargetTransformInfo(const Function &F) const override
Return a TargetTransformInfo for a given function.
ScheduleDAGInstrs * createPostMachineScheduler(MachineSchedContext *C) const override
Similar to createMachineScheduler but used when postRA machine scheduling is enabled.
yaml::MachineFunctionInfo * convertFuncInfoToYAML(const MachineFunction &MF) const override
Allocate and initialize an instance of the YAML representation of the MachineFunctionInfo.
ARMLETargetMachine(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)
Functions, function parameters, and return types can have attributes to indicate how they should be t...
Definition Attributes.h:107
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
bool isDeclarationForLinker() const
bool hasCommonLinkage() const
Cache of the last subtarget returned by getSubtargetImpl.
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:68
This class provides access to building LLVM's passes.
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.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition StringMap.h:129
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
bool isPositionIndependent() const
const Triple & getTargetTriple() const
bool shouldAssumeDSOLocal(const GlobalValue *GV) const
std::unique_ptr< const MCSubtargetInfo > STI
TargetOptions Options
Target-Independent Code Generator Pass Configuration Options.
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 ...
This is an optimization pass for GlobalISel generic memory operations.
CodeGenOptLevel
Code generation optimization level.
Definition CodeGen.h:280
BumpPtrAllocatorImpl<> BumpPtrAllocator
The standard BumpPtrAllocator which just uses the default template parameters.
Definition Allocator.h:391
The attributes that select a subtarget.
bool operator==(const SubtargetAttrs &RHS) const
bool operator!=(const SubtargetAttrs &RHS) const
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...
Targets should override this in a way that mirrors the implementation of llvm::MachineFunctionInfo.