[llvm] 0e1c71e - CodeGen: Move getAddressSpaceForPseudoSourceKind into TargetMachine
Matt Arsenault via llvm-commits
llvm-commits at lists.llvm.org
Wed Jun 1 06:45:45 PDT 2022
Author: Matt Arsenault
Date: 2022-06-01T09:45:40-04:00
New Revision: 0e1c71e4a42335399ce599086db2f99cf81d7624
URL: https://github.com/llvm/llvm-project/commit/0e1c71e4a42335399ce599086db2f99cf81d7624
DIFF: https://github.com/llvm/llvm-project/commit/0e1c71e4a42335399ce599086db2f99cf81d7624.diff
LOG: CodeGen: Move getAddressSpaceForPseudoSourceKind into TargetMachine
Avoid the dependency on TargetInstrInfo, which depends on the subtarget
and therefore the individual function.
Currently AMDGPU is constructing PseudoSourceValue instances in MachineFunctionInfo.
In order to facilitate copying MachineFunctionInfo, we need to stop allocating these
there. Alternatively we could allow targets to subclass PseudoSourceValueManager,
and allocate them similarly to MachineFunctionInfo.
Added:
Modified:
llvm/include/llvm/CodeGen/MachineMemOperand.h
llvm/include/llvm/CodeGen/PseudoSourceValue.h
llvm/include/llvm/CodeGen/TargetInstrInfo.h
llvm/include/llvm/Target/TargetMachine.h
llvm/lib/CodeGen/MachineFunction.cpp
llvm/lib/CodeGen/PseudoSourceValue.cpp
llvm/lib/Target/AMDGPU/AMDGPUMIRFormatter.cpp
llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp
llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.h
llvm/lib/Target/AMDGPU/R600InstrInfo.cpp
llvm/lib/Target/AMDGPU/R600InstrInfo.h
llvm/lib/Target/AMDGPU/SIISelLowering.cpp
llvm/lib/Target/AMDGPU/SIInstrInfo.cpp
llvm/lib/Target/AMDGPU/SIInstrInfo.h
llvm/lib/Target/AMDGPU/SIMachineFunctionInfo.h
llvm/lib/Target/Hexagon/HexagonInstrInfo.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/CodeGen/MachineMemOperand.h b/llvm/include/llvm/CodeGen/MachineMemOperand.h
index 1661d26bf1962..41574d8d556a8 100644
--- a/llvm/include/llvm/CodeGen/MachineMemOperand.h
+++ b/llvm/include/llvm/CodeGen/MachineMemOperand.h
@@ -31,6 +31,7 @@ class MDNode;
class raw_ostream;
class MachineFunction;
class ModuleSlotTracker;
+class TargetInstrInfo;
/// This class contains a discriminated union of information about pointers in
/// memory operands, relating them back to LLVM IR or to virtual locations (such
diff --git a/llvm/include/llvm/CodeGen/PseudoSourceValue.h b/llvm/include/llvm/CodeGen/PseudoSourceValue.h
index f1487017f2051..07b7ba3215669 100644
--- a/llvm/include/llvm/CodeGen/PseudoSourceValue.h
+++ b/llvm/include/llvm/CodeGen/PseudoSourceValue.h
@@ -25,7 +25,7 @@ class MachineMemOperand;
class MIRFormatter;
class PseudoSourceValue;
class raw_ostream;
-class TargetInstrInfo;
+class TargetMachine;
raw_ostream &operator<<(raw_ostream &OS, const PseudoSourceValue* PSV);
@@ -59,7 +59,7 @@ class PseudoSourceValue {
virtual void printCustom(raw_ostream &O) const;
public:
- explicit PseudoSourceValue(unsigned Kind, const TargetInstrInfo &TII);
+ explicit PseudoSourceValue(unsigned Kind, const TargetMachine &TM);
virtual ~PseudoSourceValue();
@@ -95,8 +95,8 @@ class FixedStackPseudoSourceValue : public PseudoSourceValue {
const int FI;
public:
- explicit FixedStackPseudoSourceValue(int FI, const TargetInstrInfo &TII)
- : PseudoSourceValue(FixedStack, TII), FI(FI) {}
+ explicit FixedStackPseudoSourceValue(int FI, const TargetMachine &TM)
+ : PseudoSourceValue(FixedStack, TM), FI(FI) {}
static bool classof(const PseudoSourceValue *V) {
return V->kind() == FixedStack;
@@ -115,7 +115,7 @@ class FixedStackPseudoSourceValue : public PseudoSourceValue {
class CallEntryPseudoSourceValue : public PseudoSourceValue {
protected:
- CallEntryPseudoSourceValue(unsigned Kind, const TargetInstrInfo &TII);
+ CallEntryPseudoSourceValue(unsigned Kind, const TargetMachine &TM);
public:
bool isConstant(const MachineFrameInfo *) const override;
@@ -128,8 +128,7 @@ class GlobalValuePseudoSourceValue : public CallEntryPseudoSourceValue {
const GlobalValue *GV;
public:
- GlobalValuePseudoSourceValue(const GlobalValue *GV,
- const TargetInstrInfo &TII);
+ GlobalValuePseudoSourceValue(const GlobalValue *GV, const TargetMachine &TM);
static bool classof(const PseudoSourceValue *V) {
return V->kind() == GlobalValueCallEntry;
@@ -143,7 +142,7 @@ class ExternalSymbolPseudoSourceValue : public CallEntryPseudoSourceValue {
const char *ES;
public:
- ExternalSymbolPseudoSourceValue(const char *ES, const TargetInstrInfo &TII);
+ ExternalSymbolPseudoSourceValue(const char *ES, const TargetMachine &TM);
static bool classof(const PseudoSourceValue *V) {
return V->kind() == ExternalSymbolCallEntry;
@@ -154,7 +153,7 @@ class ExternalSymbolPseudoSourceValue : public CallEntryPseudoSourceValue {
/// Manages creation of pseudo source values.
class PseudoSourceValueManager {
- const TargetInstrInfo &TII;
+ const TargetMachine &TM;
const PseudoSourceValue StackPSV, GOTPSV, JumpTablePSV, ConstantPoolPSV;
std::map<int, std::unique_ptr<FixedStackPseudoSourceValue>> FSValues;
StringMap<std::unique_ptr<const ExternalSymbolPseudoSourceValue>>
@@ -164,7 +163,7 @@ class PseudoSourceValueManager {
GlobalCallEntries;
public:
- PseudoSourceValueManager(const TargetInstrInfo &TII);
+ PseudoSourceValueManager(const TargetMachine &TM);
/// Return a pseudo source value referencing the area below the stack frame of
/// a function, e.g., the argument space.
diff --git a/llvm/include/llvm/CodeGen/TargetInstrInfo.h b/llvm/include/llvm/CodeGen/TargetInstrInfo.h
index d05493386bdf7..f9183e0a9c660 100644
--- a/llvm/include/llvm/CodeGen/TargetInstrInfo.h
+++ b/llvm/include/llvm/CodeGen/TargetInstrInfo.h
@@ -1283,13 +1283,6 @@ class TargetInstrInfo : public MCInstrInfo {
}
public:
- /// getAddressSpaceForPseudoSourceKind - Given the kind of memory
- /// (e.g. stack) the target returns the corresponding address space.
- virtual unsigned
- getAddressSpaceForPseudoSourceKind(unsigned Kind) const {
- return 0;
- }
-
/// unfoldMemoryOperand - Separate a single instruction which folded a load or
/// a store or a load and a store into two or more instruction. If this is
/// possible, returns true as well as the new instructions by reference.
diff --git a/llvm/include/llvm/Target/TargetMachine.h b/llvm/include/llvm/Target/TargetMachine.h
index ea1698fe0867a..a4d3581ff3a66 100644
--- a/llvm/include/llvm/Target/TargetMachine.h
+++ b/llvm/include/llvm/Target/TargetMachine.h
@@ -397,6 +397,12 @@ class TargetMachine {
virtual unsigned getSjLjDataSize() const { return DefaultSjLjDataSize; }
static std::pair<int, int> parseBinutilsVersion(StringRef Version);
+
+ /// getAddressSpaceForPseudoSourceKind - Given the kind of memory
+ /// (e.g. stack) the target returns the corresponding address space.
+ virtual unsigned getAddressSpaceForPseudoSourceKind(unsigned Kind) const {
+ return 0;
+ }
};
/// This class describes a target machine that is implemented with the LLVM
diff --git a/llvm/lib/CodeGen/MachineFunction.cpp b/llvm/lib/CodeGen/MachineFunction.cpp
index f2b0024ee4093..e0677997f9869 100644
--- a/llvm/lib/CodeGen/MachineFunction.cpp
+++ b/llvm/lib/CodeGen/MachineFunction.cpp
@@ -229,9 +229,7 @@ void MachineFunction::init() {
"Can't create a MachineFunction using a Module with a "
"Target-incompatible DataLayout attached\n");
- PSVManager =
- std::make_unique<PseudoSourceValueManager>(*(getSubtarget().
- getInstrInfo()));
+ PSVManager = std::make_unique<PseudoSourceValueManager>(getTarget());
}
MachineFunction::~MachineFunction() {
diff --git a/llvm/lib/CodeGen/PseudoSourceValue.cpp b/llvm/lib/CodeGen/PseudoSourceValue.cpp
index b11176f45e18e..40c52b9d97076 100644
--- a/llvm/lib/CodeGen/PseudoSourceValue.cpp
+++ b/llvm/lib/CodeGen/PseudoSourceValue.cpp
@@ -12,18 +12,19 @@
#include "llvm/CodeGen/PseudoSourceValue.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
-#include "llvm/CodeGen/TargetInstrInfo.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/TargetMachine.h"
+
using namespace llvm;
static const char *const PSVNames[] = {
"Stack", "GOT", "JumpTable", "ConstantPool", "FixedStack",
"GlobalValueCallEntry", "ExternalSymbolCallEntry"};
-PseudoSourceValue::PseudoSourceValue(unsigned Kind, const TargetInstrInfo &TII)
+PseudoSourceValue::PseudoSourceValue(unsigned Kind, const TargetMachine &TM)
: Kind(Kind) {
- AddressSpace = TII.getAddressSpaceForPseudoSourceKind(Kind);
+ AddressSpace = TM.getAddressSpaceForPseudoSourceKind(Kind);
}
PseudoSourceValue::~PseudoSourceValue() = default;
@@ -75,9 +76,9 @@ void FixedStackPseudoSourceValue::printCustom(raw_ostream &OS) const {
OS << "FixedStack" << FI;
}
-CallEntryPseudoSourceValue::CallEntryPseudoSourceValue(
- unsigned Kind, const TargetInstrInfo &TII)
- : PseudoSourceValue(Kind, TII) {}
+CallEntryPseudoSourceValue::CallEntryPseudoSourceValue(unsigned Kind,
+ const TargetMachine &TM)
+ : PseudoSourceValue(Kind, TM) {}
bool CallEntryPseudoSourceValue::isConstant(const MachineFrameInfo *) const {
return false;
@@ -92,20 +93,17 @@ bool CallEntryPseudoSourceValue::mayAlias(const MachineFrameInfo *) const {
}
GlobalValuePseudoSourceValue::GlobalValuePseudoSourceValue(
- const GlobalValue *GV,
- const TargetInstrInfo &TII)
- : CallEntryPseudoSourceValue(GlobalValueCallEntry, TII), GV(GV) {}
+ const GlobalValue *GV, const TargetMachine &TM)
+ : CallEntryPseudoSourceValue(GlobalValueCallEntry, TM), GV(GV) {}
ExternalSymbolPseudoSourceValue::ExternalSymbolPseudoSourceValue(
- const char *ES, const TargetInstrInfo &TII)
- : CallEntryPseudoSourceValue(ExternalSymbolCallEntry, TII), ES(ES) {}
+ const char *ES, const TargetMachine &TM)
+ : CallEntryPseudoSourceValue(ExternalSymbolCallEntry, TM), ES(ES) {}
-PseudoSourceValueManager::PseudoSourceValueManager(
- const TargetInstrInfo &TIInfo)
- : TII(TIInfo),
- StackPSV(PseudoSourceValue::Stack, TII),
- GOTPSV(PseudoSourceValue::GOT, TII),
- JumpTablePSV(PseudoSourceValue::JumpTable, TII),
- ConstantPoolPSV(PseudoSourceValue::ConstantPool, TII) {}
+PseudoSourceValueManager::PseudoSourceValueManager(const TargetMachine &TMInfo)
+ : TM(TMInfo), StackPSV(PseudoSourceValue::Stack, TM),
+ GOTPSV(PseudoSourceValue::GOT, TM),
+ JumpTablePSV(PseudoSourceValue::JumpTable, TM),
+ ConstantPoolPSV(PseudoSourceValue::ConstantPool, TM) {}
const PseudoSourceValue *PseudoSourceValueManager::getStack() {
return &StackPSV;
@@ -125,7 +123,7 @@ const PseudoSourceValue *
PseudoSourceValueManager::getFixedStack(int FI) {
std::unique_ptr<FixedStackPseudoSourceValue> &V = FSValues[FI];
if (!V)
- V = std::make_unique<FixedStackPseudoSourceValue>(FI, TII);
+ V = std::make_unique<FixedStackPseudoSourceValue>(FI, TM);
return V.get();
}
@@ -134,7 +132,7 @@ PseudoSourceValueManager::getGlobalValueCallEntry(const GlobalValue *GV) {
std::unique_ptr<const GlobalValuePseudoSourceValue> &E =
GlobalCallEntries[GV];
if (!E)
- E = std::make_unique<GlobalValuePseudoSourceValue>(GV, TII);
+ E = std::make_unique<GlobalValuePseudoSourceValue>(GV, TM);
return E.get();
}
@@ -143,6 +141,6 @@ PseudoSourceValueManager::getExternalSymbolCallEntry(const char *ES) {
std::unique_ptr<const ExternalSymbolPseudoSourceValue> &E =
ExternalCallEntries[ES];
if (!E)
- E = std::make_unique<ExternalSymbolPseudoSourceValue>(ES, TII);
+ E = std::make_unique<ExternalSymbolPseudoSourceValue>(ES, TM);
return E.get();
}
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUMIRFormatter.cpp b/llvm/lib/Target/AMDGPU/AMDGPUMIRFormatter.cpp
index c3441f81a78ee..0712466a0e88b 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUMIRFormatter.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUMIRFormatter.cpp
@@ -21,17 +21,18 @@ bool AMDGPUMIRFormatter::parseCustomPseudoSourceValue(
StringRef Src, MachineFunction &MF, PerFunctionMIParsingState &PFS,
const PseudoSourceValue *&PSV, ErrorCallbackType ErrorCallback) const {
SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
- const SIInstrInfo &TII = *MF.getSubtarget<GCNSubtarget>().getInstrInfo();
+ const AMDGPUTargetMachine &TM =
+ static_cast<const AMDGPUTargetMachine &>(MF.getTarget());
if (Src == "BufferResource") {
- PSV = MFI->getBufferPSV(TII);
+ PSV = MFI->getBufferPSV(TM);
return false;
}
if (Src == "ImageResource") {
- PSV = MFI->getImagePSV(TII);
+ PSV = MFI->getImagePSV(TM);
return false;
}
if (Src == "GWSResource") {
- PSV = MFI->getGWSPSV(TII);
+ PSV = MFI->getGWSPSV(TM);
return false;
}
llvm_unreachable("unknown MIR custom pseudo source value");
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp b/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp
index 7291d5d65e09f..d27190c75ced9 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp
@@ -808,6 +808,23 @@ AMDGPUTargetMachine::getPredicatedAddrSpace(const Value *V) const {
return std::make_pair(nullptr, -1);
}
+unsigned
+AMDGPUTargetMachine::getAddressSpaceForPseudoSourceKind(unsigned Kind) const {
+ switch (Kind) {
+ case PseudoSourceValue::Stack:
+ case PseudoSourceValue::FixedStack:
+ return AMDGPUAS::PRIVATE_ADDRESS;
+ case PseudoSourceValue::ConstantPool:
+ case PseudoSourceValue::GOT:
+ case PseudoSourceValue::JumpTable:
+ case PseudoSourceValue::GlobalValueCallEntry:
+ case PseudoSourceValue::ExternalSymbolCallEntry:
+ case PseudoSourceValue::TargetCustom:
+ return AMDGPUAS::CONSTANT_ADDRESS;
+ }
+ return AMDGPUAS::FLAT_ADDRESS;
+}
+
//===----------------------------------------------------------------------===//
// GCN Target Machine (SI+)
//===----------------------------------------------------------------------===//
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.h b/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.h
index cbfae571c8fc6..567cc9d610d28 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.h
+++ b/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.h
@@ -64,6 +64,8 @@ class AMDGPUTargetMachine : public LLVMTargetMachine {
std::pair<const Value *, unsigned>
getPredicatedAddrSpace(const Value *V) const override;
+
+ unsigned getAddressSpaceForPseudoSourceKind(unsigned Kind) const override;
};
//===----------------------------------------------------------------------===//
diff --git a/llvm/lib/Target/AMDGPU/R600InstrInfo.cpp b/llvm/lib/Target/AMDGPU/R600InstrInfo.cpp
index 18f0bd61322d1..d04ec6490aae5 100644
--- a/llvm/lib/Target/AMDGPU/R600InstrInfo.cpp
+++ b/llvm/lib/Target/AMDGPU/R600InstrInfo.cpp
@@ -1470,21 +1470,3 @@ void R600InstrInfo::clearFlag(MachineInstr &MI, unsigned Operand,
FlagOp.setImm(InstFlags);
}
}
-
-unsigned R600InstrInfo::getAddressSpaceForPseudoSourceKind(
- unsigned Kind) const {
- switch (Kind) {
- case PseudoSourceValue::Stack:
- case PseudoSourceValue::FixedStack:
- return AMDGPUAS::PRIVATE_ADDRESS;
- case PseudoSourceValue::ConstantPool:
- case PseudoSourceValue::GOT:
- case PseudoSourceValue::JumpTable:
- case PseudoSourceValue::GlobalValueCallEntry:
- case PseudoSourceValue::ExternalSymbolCallEntry:
- case PseudoSourceValue::TargetCustom:
- return AMDGPUAS::CONSTANT_ADDRESS;
- }
-
- llvm_unreachable("Invalid pseudo source kind");
-}
diff --git a/llvm/lib/Target/AMDGPU/R600InstrInfo.h b/llvm/lib/Target/AMDGPU/R600InstrInfo.h
index bc8a4786df77e..f720e4656348c 100644
--- a/llvm/lib/Target/AMDGPU/R600InstrInfo.h
+++ b/llvm/lib/Target/AMDGPU/R600InstrInfo.h
@@ -320,9 +320,6 @@ class R600InstrInfo final : public R600GenInstrInfo {
bool isRegisterLoad(const MachineInstr &MI) const {
return get(MI.getOpcode()).TSFlags & R600InstrFlags::REGISTER_LOAD;
}
-
- unsigned getAddressSpaceForPseudoSourceKind(
- unsigned Kind) const override;
};
namespace R600 {
diff --git a/llvm/lib/Target/AMDGPU/SIISelLowering.cpp b/llvm/lib/Target/AMDGPU/SIISelLowering.cpp
index 933f7b34954d1..a384f99c8747b 100644
--- a/llvm/lib/Target/AMDGPU/SIISelLowering.cpp
+++ b/llvm/lib/Target/AMDGPU/SIISelLowering.cpp
@@ -948,13 +948,14 @@ bool SITargetLowering::getTgtMemIntrinsic(IntrinsicInfo &Info,
SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
+ const GCNTargetMachine &TM =
+ static_cast<const GCNTargetMachine &>(getTargetMachine());
+
if (RsrcIntr->IsImage) {
- Info.ptrVal =
- MFI->getImagePSV(*MF.getSubtarget<GCNSubtarget>().getInstrInfo());
+ Info.ptrVal = MFI->getImagePSV(TM);
Info.align.reset();
} else {
- Info.ptrVal =
- MFI->getBufferPSV(*MF.getSubtarget<GCNSubtarget>().getInstrInfo());
+ Info.ptrVal = MFI->getBufferPSV(TM);
}
Info.flags |= MachineMemOperand::MODereferenceable;
@@ -1043,10 +1044,12 @@ bool SITargetLowering::getTgtMemIntrinsic(IntrinsicInfo &Info,
case Intrinsic::amdgcn_buffer_atomic_fadd: {
SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
+ const GCNTargetMachine &TM =
+ static_cast<const GCNTargetMachine &>(getTargetMachine());
+
Info.opc = ISD::INTRINSIC_W_CHAIN;
Info.memVT = MVT::getVT(CI.getOperand(0)->getType());
- Info.ptrVal =
- MFI->getBufferPSV(*MF.getSubtarget<GCNSubtarget>().getInstrInfo());
+ Info.ptrVal = MFI->getBufferPSV(TM);
Info.align.reset();
Info.flags |= MachineMemOperand::MOLoad | MachineMemOperand::MOStore;
@@ -1084,8 +1087,11 @@ bool SITargetLowering::getTgtMemIntrinsic(IntrinsicInfo &Info,
SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
Info.opc = ISD::INTRINSIC_W_CHAIN;
Info.memVT = MVT::getVT(CI.getType()); // XXX: what is correct VT?
- Info.ptrVal =
- MFI->getImagePSV(*MF.getSubtarget<GCNSubtarget>().getInstrInfo());
+
+ const GCNTargetMachine &TM =
+ static_cast<const GCNTargetMachine &>(getTargetMachine());
+
+ Info.ptrVal = MFI->getImagePSV(TM);
Info.align.reset();
Info.flags |= MachineMemOperand::MOLoad |
MachineMemOperand::MODereferenceable;
@@ -1117,9 +1123,11 @@ bool SITargetLowering::getTgtMemIntrinsic(IntrinsicInfo &Info,
case Intrinsic::amdgcn_ds_gws_sema_release_all: {
Info.opc = ISD::INTRINSIC_VOID;
+ const GCNTargetMachine &TM =
+ static_cast<const GCNTargetMachine &>(getTargetMachine());
+
SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
- Info.ptrVal =
- MFI->getGWSPSV(*MF.getSubtarget<GCNSubtarget>().getInstrInfo());
+ Info.ptrVal = MFI->getGWSPSV(TM);
// This is an abstract access, but we need to specify a type and size.
Info.memVT = MVT::i32;
diff --git a/llvm/lib/Target/AMDGPU/SIInstrInfo.cpp b/llvm/lib/Target/AMDGPU/SIInstrInfo.cpp
index a0b2a6d7439bd..314424da79d4d 100644
--- a/llvm/lib/Target/AMDGPU/SIInstrInfo.cpp
+++ b/llvm/lib/Target/AMDGPU/SIInstrInfo.cpp
@@ -2887,23 +2887,6 @@ bool SIInstrInfo::isFoldableCopy(const MachineInstr &MI) {
}
}
-unsigned SIInstrInfo::getAddressSpaceForPseudoSourceKind(
- unsigned Kind) const {
- switch(Kind) {
- case PseudoSourceValue::Stack:
- case PseudoSourceValue::FixedStack:
- return AMDGPUAS::PRIVATE_ADDRESS;
- case PseudoSourceValue::ConstantPool:
- case PseudoSourceValue::GOT:
- case PseudoSourceValue::JumpTable:
- case PseudoSourceValue::GlobalValueCallEntry:
- case PseudoSourceValue::ExternalSymbolCallEntry:
- case PseudoSourceValue::TargetCustom:
- return AMDGPUAS::CONSTANT_ADDRESS;
- }
- return AMDGPUAS::FLAT_ADDRESS;
-}
-
static constexpr unsigned ModifierOpNames[] = {
AMDGPU::OpName::src0_modifiers, AMDGPU::OpName::src1_modifiers,
AMDGPU::OpName::src2_modifiers, AMDGPU::OpName::clamp,
diff --git a/llvm/lib/Target/AMDGPU/SIInstrInfo.h b/llvm/lib/Target/AMDGPU/SIInstrInfo.h
index 99f4a4ae316c4..f0ea44f0d82e5 100644
--- a/llvm/lib/Target/AMDGPU/SIInstrInfo.h
+++ b/llvm/lib/Target/AMDGPU/SIInstrInfo.h
@@ -328,9 +328,6 @@ class SIInstrInfo final : public AMDGPUGenInstrInfo {
Register SrcReg2, int64_t CmpMask, int64_t CmpValue,
const MachineRegisterInfo *MRI) const override;
- unsigned getAddressSpaceForPseudoSourceKind(
- unsigned Kind) const override;
-
bool
areMemAccessesTriviallyDisjoint(const MachineInstr &MIa,
const MachineInstr &MIb) const override;
diff --git a/llvm/lib/Target/AMDGPU/SIMachineFunctionInfo.h b/llvm/lib/Target/AMDGPU/SIMachineFunctionInfo.h
index 224ba422f68c8..19725c0120052 100644
--- a/llvm/lib/Target/AMDGPU/SIMachineFunctionInfo.h
+++ b/llvm/lib/Target/AMDGPU/SIMachineFunctionInfo.h
@@ -15,6 +15,7 @@
#include "AMDGPUArgumentUsageInfo.h"
#include "AMDGPUMachineFunction.h"
+#include "AMDGPUTargetMachine.h"
#include "MCTargetDesc/AMDGPUMCTargetDesc.h"
#include "SIInstrInfo.h"
#include "llvm/ADT/SetVector.h"
@@ -39,8 +40,8 @@ class AMDGPUPseudoSourceValue : public PseudoSourceValue {
};
protected:
- AMDGPUPseudoSourceValue(unsigned Kind, const TargetInstrInfo &TII)
- : PseudoSourceValue(Kind, TII) {}
+ AMDGPUPseudoSourceValue(unsigned Kind, const AMDGPUTargetMachine &TM)
+ : PseudoSourceValue(Kind, TM) {}
public:
bool isConstant(const MachineFrameInfo *) const override {
@@ -60,8 +61,8 @@ class AMDGPUPseudoSourceValue : public PseudoSourceValue {
class AMDGPUBufferPseudoSourceValue final : public AMDGPUPseudoSourceValue {
public:
- explicit AMDGPUBufferPseudoSourceValue(const TargetInstrInfo &TII)
- : AMDGPUPseudoSourceValue(PSVBuffer, TII) {}
+ explicit AMDGPUBufferPseudoSourceValue(const AMDGPUTargetMachine &TM)
+ : AMDGPUPseudoSourceValue(PSVBuffer, TM) {}
static bool classof(const PseudoSourceValue *V) {
return V->kind() == PSVBuffer;
@@ -73,8 +74,8 @@ class AMDGPUBufferPseudoSourceValue final : public AMDGPUPseudoSourceValue {
class AMDGPUImagePseudoSourceValue final : public AMDGPUPseudoSourceValue {
public:
// TODO: Is the img rsrc useful?
- explicit AMDGPUImagePseudoSourceValue(const TargetInstrInfo &TII)
- : AMDGPUPseudoSourceValue(PSVImage, TII) {}
+ explicit AMDGPUImagePseudoSourceValue(const AMDGPUTargetMachine &TM)
+ : AMDGPUPseudoSourceValue(PSVImage, TM) {}
static bool classof(const PseudoSourceValue *V) {
return V->kind() == PSVImage;
@@ -85,8 +86,8 @@ class AMDGPUImagePseudoSourceValue final : public AMDGPUPseudoSourceValue {
class AMDGPUGWSResourcePseudoSourceValue final : public AMDGPUPseudoSourceValue {
public:
- explicit AMDGPUGWSResourcePseudoSourceValue(const TargetInstrInfo &TII)
- : AMDGPUPseudoSourceValue(GWSResource, TII) {}
+ explicit AMDGPUGWSResourcePseudoSourceValue(const AMDGPUTargetMachine &TM)
+ : AMDGPUPseudoSourceValue(GWSResource, TM) {}
static bool classof(const PseudoSourceValue *V) {
return V->kind() == GWSResource;
@@ -929,24 +930,26 @@ class SIMachineFunctionInfo final : public AMDGPUMachineFunction {
llvm_unreachable("unexpected dimension");
}
- const AMDGPUBufferPseudoSourceValue *getBufferPSV(const SIInstrInfo &TII) {
+ const AMDGPUBufferPseudoSourceValue *
+ getBufferPSV(const AMDGPUTargetMachine &TM) {
if (!BufferPSV)
- BufferPSV = std::make_unique<AMDGPUBufferPseudoSourceValue>(TII);
+ BufferPSV = std::make_unique<AMDGPUBufferPseudoSourceValue>(TM);
return BufferPSV.get();
}
- const AMDGPUImagePseudoSourceValue *getImagePSV(const SIInstrInfo &TII) {
+ const AMDGPUImagePseudoSourceValue *
+ getImagePSV(const AMDGPUTargetMachine &TM) {
if (!ImagePSV)
- ImagePSV = std::make_unique<AMDGPUImagePseudoSourceValue>(TII);
+ ImagePSV = std::make_unique<AMDGPUImagePseudoSourceValue>(TM);
return ImagePSV.get();
}
- const AMDGPUGWSResourcePseudoSourceValue *getGWSPSV(const SIInstrInfo &TII) {
+ const AMDGPUGWSResourcePseudoSourceValue *
+ getGWSPSV(const AMDGPUTargetMachine &TM) {
if (!GWSResourcePSV) {
- GWSResourcePSV =
- std::make_unique<AMDGPUGWSResourcePseudoSourceValue>(TII);
+ GWSResourcePSV = std::make_unique<AMDGPUGWSResourcePseudoSourceValue>(TM);
}
return GWSResourcePSV.get();
diff --git a/llvm/lib/Target/Hexagon/HexagonInstrInfo.cpp b/llvm/lib/Target/Hexagon/HexagonInstrInfo.cpp
index c5fe88edf9760..6d9cd919c3395 100644
--- a/llvm/lib/Target/Hexagon/HexagonInstrInfo.cpp
+++ b/llvm/lib/Target/Hexagon/HexagonInstrInfo.cpp
@@ -1429,8 +1429,8 @@ bool HexagonInstrInfo::expandPostRAPseudo(MachineInstr &MI) const {
// Generate a misaligned load that is guaranteed to cause a crash.
class CrashPseudoSourceValue : public PseudoSourceValue {
public:
- CrashPseudoSourceValue(const TargetInstrInfo &TII)
- : PseudoSourceValue(TargetCustom, TII) {}
+ CrashPseudoSourceValue(const TargetMachine &TM)
+ : PseudoSourceValue(TargetCustom, TM) {}
bool isConstant(const MachineFrameInfo *) const override {
return false;
@@ -1446,7 +1446,7 @@ bool HexagonInstrInfo::expandPostRAPseudo(MachineInstr &MI) const {
}
};
- static const CrashPseudoSourceValue CrashPSV(*this);
+ static const CrashPseudoSourceValue CrashPSV(MF.getTarget());
MachineMemOperand *MMO = MF.getMachineMemOperand(
MachinePointerInfo(&CrashPSV),
MachineMemOperand::MOLoad | MachineMemOperand::MOVolatile, 8,
More information about the llvm-commits
mailing list