CodeGen: Add AddressSpace field to PseudoSourceValue

[• tstellarAMD]

Summary

AMDGPU will use this to create a GOT PseudoSourceValue in
a non-zero address space.

[• tstellarAMD]

Ping.

[arsenm]

LGTM

[arsenm]

This is necessary to fix FixedStack pseudovalues with non-0 address space allocas

[yaxunl]

Ping. We need this patch for fixing a failure in OpenCL conformance test. Thanks.

[hfinkel]

In D21688#830868, @yaxunl wrote:

Ping. We need this patch for fixing a failure in OpenCL conformance test. Thanks.

You're just pinging for someone to commit this, correct?

[yaxunl]

In D21688#830874, @hfinkel wrote:

In D21688#830868, @yaxunl wrote:

Ping. We need this patch for fixing a failure in OpenCL conformance test. Thanks.

You're just pinging for someone to commit this, correct?

I am not sure if Tom is still waiting for another reviewer's approval. But if it could be committed, yes. Thanks.

[arsenm]

D35089 is a more up to date version

include/llvm/CodeGen/PseudoSourceValue.h

enum PSVKind {
     ConstantPool,
     FixedStack,
     GlobalValueCallEntry,
     ExternalSymbolCallEntry
   };
 
 private:
   PSVKind Kind;
+  unsigned AddressSpace;
   friend raw_ostream &llvm::operator<<(raw_ostream &OS,
                                        const PseudoSourceValue* PSV);
 
   friend class MachineMemOperand; // For printCustom().
 
   /// Implement printing for PseudoSourceValue. This is called from
   /// Value::print or Value's operator<<.
   virtual void printCustom(raw_ostream &O) const;
 
 public:
-  explicit PseudoSourceValue(PSVKind Kind);
+  explicit PseudoSourceValue(PSVKind Kind, unsigned AdressSpace = 0);
 
   virtual ~PseudoSourceValue();
 
   PSVKind kind() const { return Kind; }
 
   bool isStack() const { return Kind == Stack; }
   bool isGOT() const { return Kind == GOT; }
   bool isConstantPool() const { return Kind == ConstantPool; }
   bool isJumpTable() const { return Kind == JumpTable; }
 
+  unsigned getAddressSpace() const { return AddressSpace; }
+
   /// Test whether the memory pointed to by this PseudoSourceValue has a
   /// constant value.
   virtual bool isConstant(const MachineFrameInfo *) const;
 
   /// Test whether the memory pointed to by this PseudoSourceValue may also be
   /// pointed to by an LLVM IR Value.
   virtual bool isAliased(const MachineFrameInfo *) const;
 

lib/CodeGen/MachineInstr.cpp

 
 //===----------------------------------------------------------------------===//
 // MachineMemOperand Implementation
 //===----------------------------------------------------------------------===//
 
 /// getAddrSpace - Return the LLVM IR address space number that this pointer
 /// points into.
 unsigned MachinePointerInfo::getAddrSpace() const {
-  if (V.isNull() || V.is<const PseudoSourceValue*>()) return 0;
+  if (V.isNull()) return 0;
+
+  if (V.is<const PseudoSourceValue*>())
+    return V.get<const PseudoSourceValue*>()->getAddressSpace();
+
   return cast<PointerType>(V.get<const Value*>()->getType())->getAddressSpace();
 }
 
 /// getConstantPool - Return a MachinePointerInfo record that refers to the
 /// constant pool.
 MachinePointerInfo MachinePointerInfo::getConstantPool(MachineFunction &MF) {
   return MachinePointerInfo(MF.getPSVManager().getConstantPool());
 }

lib/CodeGen/PseudoSourceValue.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 static const char *const PSVNames[] = {
     "Stack", "GOT", "JumpTable", "ConstantPool", "FixedStack",
     "GlobalValueCallEntry", "ExternalSymbolCallEntry"};
 
-PseudoSourceValue::PseudoSourceValue(PSVKind Kind) : Kind(Kind) {}
+PseudoSourceValue::PseudoSourceValue(PSVKind Kind, unsigned AddressSpace)
+    : Kind(Kind), AddressSpace(AddressSpace) {}
 
 PseudoSourceValue::~PseudoSourceValue() {}
 
 void PseudoSourceValue::printCustom(raw_ostream &O) const {
   O << PSVNames[Kind];
 }
 
 bool PseudoSourceValue::isConstant(const MachineFrameInfo *) const {