AMDGPU/SI: Simplify address space checks in AMDGPUDAGToDAGISel

[• tstellarAMD]

Summary

Get the address space directly from the MemSDNode rather than from
the value associated with the MemOperand. This was broken for the
case when the MemOperand was a PseudoSourceValue.

[arsenm]

lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp

492–494

I've been planning on removing these entirely. There's no reason this can't be done in tablegen and some of the address space checks are already there

[• tstellarAMD]

Replace the c++ functions with TableGen code.

[arsenm]

LGTM

lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp

 
 private:
   bool isInlineImmediate(SDNode *N) const;
   bool FoldOperand(SDValue &Src, SDValue &Sel, SDValue &Neg, SDValue &Abs,
                    const R600InstrInfo *TII);
   bool FoldOperands(unsigned, const R600InstrInfo *, std::vector<SDValue> &);
   bool FoldDotOperands(unsigned, const R600InstrInfo *, std::vector<SDValue> &);
 
-  static bool checkType(const Value *ptr, unsigned int addrspace);
-
   static bool isGlobalStore(const MemSDNode *N);
   static bool isFlatStore(const MemSDNode *N);
   static bool isLocalStore(const StoreSDNode *N);
 
   bool isConstantLoad(const MemSDNode *N, int cbID) const;
   bool isGlobalLoad(const MemSDNode *N) const;
   bool isFlatLoad(const MemSDNode *N) const;
   bool isLocalLoad(const LoadSDNode *N) const;
case AMDGPU::REG_SEQUENCE: {
     return Subtarget->getRegisterInfo()->getSubClassWithSubReg(SuperRC,
                                                               SubRegIdx);
   }
   }
 }
 
 SDNode *AMDGPUDAGToDAGISel::glueCopyToM0(SDNode *N) const {
   if (Subtarget->getGeneration() < AMDGPUSubtarget::SOUTHERN_ISLANDS ||
-      !checkType(cast<MemSDNode>(N)->getMemOperand()->getValue(),
-                 AMDGPUAS::LOCAL_ADDRESS))
+      cast<MemSDNode>(N)->getAddressSpace() != AMDGPUAS::LOCAL_ADDRESS)
     return N;
 
   const SITargetLowering& Lowering =
       *static_cast<const SITargetLowering*>(getTargetLowering());
 
   // Write max value to m0 before each load operation
 
   SDValue M0 = Lowering.copyToM0(*CurDAG, CurDAG->getEntryNode(), SDLoc(N),
void AMDGPUDAGToDAGISel::Select(SDNode *N) {
   case AMDGPUISD::ATOMIC_CMP_SWAP:
     SelectATOMIC_CMP_SWAP(N);
     return;
   }
 
   SelectCode(N);
 }
 
-bool AMDGPUDAGToDAGISel::checkType(const Value *Ptr, unsigned AS) {
-  assert(AS != 0 && "Use checkPrivateAddress instead.");
-  if (!Ptr)
-    return false;
-
-  return Ptr->getType()->getPointerAddressSpace() == AS;
-}
-
 bool AMDGPUDAGToDAGISel::isGlobalStore(const MemSDNode *N) {
-  if (!N->writeMem())
-    return false;
-  return checkType(N->getMemOperand()->getValue(), AMDGPUAS::GLOBAL_ADDRESS);
+  return N->writeMem() && N->getAddressSpace() == AMDGPUAS::GLOBAL_ADDRESS;
 }
 
 bool AMDGPUDAGToDAGISel::isLocalStore(const StoreSDNode *N) {
-  return checkType(N->getMemOperand()->getValue(), AMDGPUAS::LOCAL_ADDRESS);
+  return N->writeMem() && N->getAddressSpace() == AMDGPUAS::LOCAL_ADDRESS;
 }
 
 bool AMDGPUDAGToDAGISel::isFlatStore(const MemSDNode *N) {
-  if (!N->writeMem())
-    return false;
-  return checkType(N->getMemOperand()->getValue(), AMDGPUAS::FLAT_ADDRESS);
+  return N->writeMem() && N->getAddressSpace() == AMDGPUAS::FLAT_ADDRESS;
 }
 
 bool AMDGPUDAGToDAGISel::isConstantLoad(const MemSDNode *N, int CbId) const {
   if (!N->readMem())
     return false;
-  const Value *MemVal = N->getMemOperand()->getValue();
   if (CbId == -1)
-    return checkType(MemVal, AMDGPUAS::CONSTANT_ADDRESS);
+    return N->getAddressSpace() == AMDGPUAS::CONSTANT_ADDRESS;
 
-  return checkType(MemVal, AMDGPUAS::CONSTANT_BUFFER_0 + CbId);
+  return N->getAddressSpace() == AMDGPUAS::CONSTANT_BUFFER_0 + CbId;
 }
 
 bool AMDGPUDAGToDAGISel::isGlobalLoad(const MemSDNode *N) const {
   if (!N->readMem())
     return false;
   if (N->getAddressSpace() == AMDGPUAS::CONSTANT_ADDRESS) {
     if (Subtarget->getGeneration() < AMDGPUSubtarget::SOUTHERN_ISLANDS)
       return !isa<GlobalValue>(GetUnderlyingObject(
           N->getMemOperand()->getValue(), CurDAG->getDataLayout()));
 
     //TODO: Why do we need this?
     if (N->getMemoryVT().bitsLT(MVT::i32))
       return true;
   }
 
-  return checkType(N->getMemOperand()->getValue(), AMDGPUAS::GLOBAL_ADDRESS);
+  return N->getAddressSpace() == AMDGPUAS::GLOBAL_ADDRESS;
 }
 
 bool AMDGPUDAGToDAGISel::isLocalLoad(const  LoadSDNode *N) const {
-  return checkType(N->getMemOperand()->getValue(), AMDGPUAS::LOCAL_ADDRESS);
+  return N->readMem() && N->getAddressSpace() == AMDGPUAS::LOCAL_ADDRESS;
 }
 
 bool AMDGPUDAGToDAGISel::isFlatLoad(const MemSDNode *N) const {
-  if (!N->readMem())
-    return false;
-  return checkType(N->getMemOperand()->getValue(), AMDGPUAS::FLAT_ADDRESS);
+  return N->readMem() && N->getAddressSpace() == AMDGPUAS::FLAT_ADDRESS;
 }
 
 bool AMDGPUDAGToDAGISel::isUniformBr(const SDNode *N) const {
   const BasicBlock *BB = FuncInfo->MBB->getBasicBlock();
   const Instruction *Term = BB->getTerminator();
   return Term->getMetadata("amdgpu.uniform") ||
          Term->getMetadata("structurizecfg.uniform");
 }