AMDGPU: Fix set but not used warnings related to AMDGPUAS

[yaxunl]

LGTM. Thanks!

lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

void AMDGPUAsmPrinter::EmitFunctionEntryLabel() {
   }
 
   AsmPrinter::EmitFunctionEntryLabel();
 }
 
 void AMDGPUAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
 
   // Group segment variables aren't emitted in HSA.
-  if (AMDGPU::isGroupSegment(GV, AMDGPUASI))
+  if (AMDGPU::isGroupSegment(GV))
     return;
 
   AsmPrinter::EmitGlobalVariable(GV);
 }
 
 bool AMDGPUAsmPrinter::doFinalization(Module &M) {
   CallGraphResourceInfo.clear();
   return AsmPrinter::doFinalization(M);

lib/Target/AMDGPU/AMDGPUOpenCLEnqueuedBlockLowering.cpp

if (auto *CI = dyn_cast<CallInst>(&*U)) {
       collectCallers(Caller, Callers);
     }
   }
 }
 
 bool AMDGPUOpenCLEnqueuedBlockLowering::runOnModule(Module &M) {
   DenseSet<Function *> Callers;
   auto &C = M.getContext();
-  auto AS = AMDGPU::getAMDGPUAS(M);
   bool Changed = false;
   for (auto &F : M.functions()) {
     if (F.hasFnAttribute("enqueued-block")) {
       if (!F.hasOneUse() || !F.user_begin()->hasOneUse() ||
           !isa<ConstantExpr>(*F.user_begin()) ||
           !isa<ConstantExpr>(*F.user_begin()->user_begin())) {
         continue;
       }
       auto *BitCast = cast<ConstantExpr>(*F.user_begin());
       auto *AddrCast = cast<ConstantExpr>(*BitCast->user_begin());
       auto RuntimeHandle = (F.getName() + "_runtime_handle").str();
       auto *GV = new GlobalVariable(
-          M, Type::getInt8Ty(C)->getPointerTo(AS.GLOBAL_ADDRESS),
+          M, Type::getInt8Ty(C)->getPointerTo(AMDGPUAS::GLOBAL_ADDRESS),
           /*IsConstant=*/true, GlobalValue::ExternalLinkage,
           /*Initializer=*/nullptr, RuntimeHandle, /*InsertBefore=*/nullptr,
-          GlobalValue::NotThreadLocal, AS.GLOBAL_ADDRESS,
+          GlobalValue::NotThreadLocal, AMDGPUAS::GLOBAL_ADDRESS,
           /*IsExternallyInitialized=*/true);
       DEBUG(dbgs() << "runtime handle created: " << *GV << '\n');
       auto *NewPtr = ConstantExpr::getPointerCast(GV, AddrCast->getType());
       AddrCast->replaceAllUsesWith(NewPtr);
       F.addFnAttr("runtime-handle", RuntimeHandle);
       F.setLinkage(GlobalValue::ExternalLinkage);
 
       // Collect direct or indirect callers of enqueue_kernel.

lib/Target/AMDGPU/AMDGPUTargetObjectFile.cpp

 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
 // Generic Object File
 //===----------------------------------------------------------------------===//
 
 MCSection *AMDGPUTargetObjectFile::SelectSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
-  auto AS = static_cast<const AMDGPUTargetMachine*>(&TM)->getAMDGPUAS();
-  if (Kind.isReadOnly() && AMDGPU::isReadOnlySegment(GO, AS) &&
+  if (Kind.isReadOnly() && AMDGPU::isReadOnlySegment(GO) &&
       AMDGPU::shouldEmitConstantsToTextSection(TM.getTargetTriple()))
     return TextSection;
 
   return TargetLoweringObjectFileELF::SelectSectionForGlobal(GO, Kind, TM);
 }

lib/Target/AMDGPU/R600ISelLowering.cpp

SDValue R600TargetLowering::LowerSTORE(SDValue Op, SelectionDAG &DAG) const {
   }
 
   // Tagged i32+ stores will be matched by patterns
   return SDValue();
 }
 
 // return (512 + (kc_bank << 12)
 static int
-ConstantAddressBlock(unsigned AddressSpace, AMDGPUAS AMDGPUASI) {
+ConstantAddressBlock(unsigned AddressSpace) {
   switch (AddressSpace) {
-  case AMDGPUASI.CONSTANT_BUFFER_0:
+  case AMDGPUAS::CONSTANT_BUFFER_0:
     return 512;
-  case AMDGPUASI.CONSTANT_BUFFER_1:
+  case AMDGPUAS::CONSTANT_BUFFER_1:
     return 512 + 4096;
-  case AMDGPUASI.CONSTANT_BUFFER_2:
+  case AMDGPUAS::CONSTANT_BUFFER_2:
     return 512 + 4096 * 2;
-  case AMDGPUASI.CONSTANT_BUFFER_3:
+  case AMDGPUAS::CONSTANT_BUFFER_3:
     return 512 + 4096 * 3;
-  case AMDGPUASI.CONSTANT_BUFFER_4:
+  case AMDGPUAS::CONSTANT_BUFFER_4:
     return 512 + 4096 * 4;
-  case AMDGPUASI.CONSTANT_BUFFER_5:
+  case AMDGPUAS::CONSTANT_BUFFER_5:
     return 512 + 4096 * 5;
-  case AMDGPUASI.CONSTANT_BUFFER_6:
+  case AMDGPUAS::CONSTANT_BUFFER_6:
     return 512 + 4096 * 6;
-  case AMDGPUASI.CONSTANT_BUFFER_7:
+  case AMDGPUAS::CONSTANT_BUFFER_7:
     return 512 + 4096 * 7;
-  case AMDGPUASI.CONSTANT_BUFFER_8:
+  case AMDGPUAS::CONSTANT_BUFFER_8:
     return 512 + 4096 * 8;
-  case AMDGPUASI.CONSTANT_BUFFER_9:
+  case AMDGPUAS::CONSTANT_BUFFER_9:
     return 512 + 4096 * 9;
-  case AMDGPUASI.CONSTANT_BUFFER_10:
+  case AMDGPUAS::CONSTANT_BUFFER_10:
     return 512 + 4096 * 10;
-  case AMDGPUASI.CONSTANT_BUFFER_11:
+  case AMDGPUAS::CONSTANT_BUFFER_11:
     return 512 + 4096 * 11;
-  case AMDGPUASI.CONSTANT_BUFFER_12:
+  case AMDGPUAS::CONSTANT_BUFFER_12:
     return 512 + 4096 * 12;
-  case AMDGPUASI.CONSTANT_BUFFER_13:
+  case AMDGPUAS::CONSTANT_BUFFER_13:
     return 512 + 4096 * 13;
-  case AMDGPUASI.CONSTANT_BUFFER_14:
+  case AMDGPUAS::CONSTANT_BUFFER_14:
     return 512 + 4096 * 14;
-  case AMDGPUASI.CONSTANT_BUFFER_15:
+  case AMDGPUAS::CONSTANT_BUFFER_15:
     return 512 + 4096 * 15;
   default:
     return -1;
   }
 }
 
 SDValue R600TargetLowering::lowerPrivateExtLoad(SDValue Op,
                                                 SelectionDAG &DAG) const {
SDValue R600TargetLowering::LowerLOAD(SDValue Op, SelectionDAG &DAG) const {
   SDValue Ptr = LoadNode->getBasePtr();
 
   if ((LoadNode->getAddressSpace() == AMDGPUASI.LOCAL_ADDRESS ||
       LoadNode->getAddressSpace() == AMDGPUASI.PRIVATE_ADDRESS) &&
       VT.isVector()) {
       return scalarizeVectorLoad(LoadNode, DAG);
   }
 
-  int ConstantBlock = ConstantAddressBlock(LoadNode->getAddressSpace(),
-      AMDGPUASI);
+  int ConstantBlock = ConstantAddressBlock(LoadNode->getAddressSpace());
   if (ConstantBlock > -1 &&
       ((LoadNode->getExtensionType() == ISD::NON_EXTLOAD) ||
        (LoadNode->getExtensionType() == ISD::ZEXTLOAD))) {
     SDValue Result;
     if (isa<ConstantExpr>(LoadNode->getMemOperand()->getValue()) ||
         isa<Constant>(LoadNode->getMemOperand()->getValue()) ||
         isa<ConstantSDNode>(Ptr)) {
       SDValue Slots[4];

lib/Target/AMDGPU/SIFrameLowering.cpp

 void SIFrameLowering::emitEntryFunctionScratchSetup(const SISubtarget &ST,
       MachineFunction &MF, MachineBasicBlock &MBB, SIMachineFunctionInfo *MFI,
       MachineBasicBlock::iterator I, unsigned PreloadedPrivateBufferReg,
       unsigned ScratchRsrcReg) const {
 
   const SIInstrInfo *TII = ST.getInstrInfo();
   const SIRegisterInfo *TRI = &TII->getRegisterInfo();
   DebugLoc DL;
-  auto AMDGPUASI = ST.getAMDGPUAS();
 
   if (ST.isAmdPalOS()) {
     // The pointer to the GIT is formed from the offset passed in and either
     // the amdgpu-git-ptr-high function attribute or the top part of the PC
     unsigned RsrcLo = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub0);
     unsigned RsrcHi = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub1);
     unsigned Rsrc01 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub0_sub1);
 
if (MFI->hasImplicitBufferPtr()) {
         BuildMI(MBB, I, DL, Mov64, Rsrc01)
           .addReg(MFI->getImplicitBufferPtrUserSGPR())
           .addReg(ScratchRsrcReg, RegState::ImplicitDefine);
       } else {
         const MCInstrDesc &LoadDwordX2 = TII->get(AMDGPU::S_LOAD_DWORDX2_IMM);
 
         PointerType *PtrTy =
           PointerType::get(Type::getInt64Ty(MF.getFunction()->getContext()),
-                           AMDGPUASI.CONSTANT_ADDRESS);
+                           AMDGPUAS::CONSTANT_ADDRESS);
         MachinePointerInfo PtrInfo(UndefValue::get(PtrTy));
         auto MMO = MF.getMachineMemOperand(PtrInfo,
                                            MachineMemOperand::MOLoad |
                                            MachineMemOperand::MOInvariant |
                                            MachineMemOperand::MODereferenceable,
                                            0, 0);
         BuildMI(MBB, I, DL, LoadDwordX2, Rsrc01)
           .addReg(MFI->getImplicitBufferPtrUserSGPR())

lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.h

 } // end namespace IsaInfo
 
 LLVM_READONLY
 int16_t getNamedOperandIdx(uint16_t Opcode, uint16_t NamedIdx);
 
 void initDefaultAMDKernelCodeT(amd_kernel_code_t &Header,
                                const FeatureBitset &Features);
 
-bool isGroupSegment(const GlobalValue *GV, AMDGPUAS AS);
-bool isGlobalSegment(const GlobalValue *GV, AMDGPUAS AS);
-bool isReadOnlySegment(const GlobalValue *GV, AMDGPUAS AS);
+bool isGroupSegment(const GlobalValue *GV);
+bool isGlobalSegment(const GlobalValue *GV);
+bool isReadOnlySegment(const GlobalValue *GV);
 
 /// \returns True if constants should be emitted to .text section for given
 /// target triple \p TT, false otherwise.
 bool shouldEmitConstantsToTextSection(const Triple &TT);
 
 /// \returns Integer value requested using \p F's \p Name attribute.
 ///
 /// \returns \p Default if attribute is not present.

lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp

void initDefaultAMDKernelCodeT(amd_kernel_code_t &Header,
 
   // These alignment values are specified in powers of two, so alignment =
   // 2^n.  The minimum alignment is 2^4 = 16.
   Header.kernarg_segment_alignment = 4;
   Header.group_segment_alignment = 4;
   Header.private_segment_alignment = 4;
 }
 
-bool isGroupSegment(const GlobalValue *GV, AMDGPUAS AS) {
-  return GV->getType()->getAddressSpace() == AS.LOCAL_ADDRESS;
+bool isGroupSegment(const GlobalValue *GV) {
+  return GV->getType()->getAddressSpace() == AMDGPUAS::LOCAL_ADDRESS;
 }
 
-bool isGlobalSegment(const GlobalValue *GV, AMDGPUAS AS) {
-  return GV->getType()->getAddressSpace() == AS.GLOBAL_ADDRESS;
+bool isGlobalSegment(const GlobalValue *GV) {
+  return GV->getType()->getAddressSpace() == AMDGPUAS::GLOBAL_ADDRESS;
 }
 
-bool isReadOnlySegment(const GlobalValue *GV, AMDGPUAS AS) {
-  return GV->getType()->getAddressSpace() == AS.CONSTANT_ADDRESS;
+bool isReadOnlySegment(const GlobalValue *GV) {
+  return GV->getType()->getAddressSpace() == AMDGPUAS::CONSTANT_ADDRESS;
 }
 
 bool shouldEmitConstantsToTextSection(const Triple &TT) {
   return TT.getOS() != Triple::AMDHSA;
 }
 
 int getIntegerAttribute(const Function &F, StringRef Name, int Default) {
   Attribute A = F.getFnAttribute(Name);