[AMDGPU][MC] Disabled lds_direct for GFX90a

[dp]

Summary

Summary of changes:

• Refactored lds_direct validation;
• Disabled lds_direct for GFX90a.

Fixed bug 49382.

[dp]

Rebased.

[dp]

Updated to silence the linter.

[rampitec]

LGTM

llvm/lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp

private:
   bool validateMIMGAtomicDMask(const MCInst &Inst);
   bool validateMIMGGatherDMask(const MCInst &Inst);
   bool validateMovrels(const MCInst &Inst, const OperandVector &Operands);
   bool validateMIMGDataSize(const MCInst &Inst);
   bool validateMIMGAddrSize(const MCInst &Inst);
   bool validateMIMGD16(const MCInst &Inst);
   bool validateMIMGDim(const MCInst &Inst);
   bool validateMIMGMSAA(const MCInst &Inst);
-  bool validateLdsDirect(const MCInst &Inst);
   bool validateOpSel(const MCInst &Inst);
   bool validateVccOperand(unsigned Reg) const;
   bool validateVOP3Literal(const MCInst &Inst, const OperandVector &Operands);
   bool validateMAIAccWrite(const MCInst &Inst, const OperandVector &Operands);
   bool validateAGPRLdSt(const MCInst &Inst) const;
   bool validateVGPRAlign(const MCInst &Inst) const;
   bool validateDivScale(const MCInst &Inst);
   bool validateCoherencyBits(const MCInst &Inst, const OperandVector &Operands,
                              const SMLoc &IDLoc);
+  Optional<StringRef> validateLdsDirect(const MCInst &Inst);
   unsigned getConstantBusLimit(unsigned Opcode) const;
   bool usesConstantBus(const MCInst &Inst, unsigned OpIdx);
   bool isInlineConstant(const MCInst &Inst, unsigned OpIdx) const;
   unsigned findImplicitSGPRReadInVOP(const MCInst &Inst) const;
 
   bool isSupportedMnemo(StringRef Mnemo,
                         const FeatureBitset &FBS);
   bool isSupportedMnemo(StringRef Mnemo,
static bool IsRevOpcode(const unsigned Opcode)
   case AMDGPU::V_PK_ASHRREV_I16_gfx10:
   case AMDGPU::V_PK_ASHRREV_I16_vi:
     return true;
   default:
     return false;
   }
 }
 
-bool AMDGPUAsmParser::validateLdsDirect(const MCInst &Inst) {
+Optional<StringRef> AMDGPUAsmParser::validateLdsDirect(const MCInst &Inst) {
 
   using namespace SIInstrFlags;
   const unsigned Opcode = Inst.getOpcode();
   const MCInstrDesc &Desc = MII.get(Opcode);
 
   // lds_direct register is defined so that it can be used
   // with 9-bit operands only. Ignore encodings which do not accept these.
-  if ((Desc.TSFlags & (VOP1 | VOP2 | VOP3 | VOPC | VOP3P | SIInstrFlags::SDWA)) == 0)
-    return true;
+  const auto Enc = VOP1 | VOP2 | VOP3 | VOPC | VOP3P | SIInstrFlags::SDWA;
+  if ((Desc.TSFlags & Enc) == 0)
+    return None;
 
-  const int Src0Idx = AMDGPU::getNamedOperandIdx(Opcode, AMDGPU::OpName::src0);
-  const int Src1Idx = AMDGPU::getNamedOperandIdx(Opcode, AMDGPU::OpName::src1);
-  const int Src2Idx = AMDGPU::getNamedOperandIdx(Opcode, AMDGPU::OpName::src2);
+  for (auto SrcName : {OpName::src0, OpName::src1, OpName::src2}) {
+    auto SrcIdx = getNamedOperandIdx(Opcode, SrcName);
+    if (SrcIdx == -1)
+      break;
+    const auto &Src = Inst.getOperand(SrcIdx);
+    if (Src.isReg() && Src.getReg() == LDS_DIRECT) {
 
-  const int SrcIndices[] = { Src1Idx, Src2Idx };
+      if (isGFX90A())
+        return StringRef("lds_direct is not supported on this GPU");
 
-  // lds_direct cannot be specified as either src1 or src2.
-  for (int SrcIdx : SrcIndices) {
-    if (SrcIdx == -1) break;
-    const MCOperand &Src = Inst.getOperand(SrcIdx);
-    if (Src.isReg() && Src.getReg() == LDS_DIRECT) {
-      return false;
+      if (IsRevOpcode(Opcode) || (Desc.TSFlags & SIInstrFlags::SDWA))
+        return StringRef("lds_direct cannot be used with this instruction");
+
+      if (SrcName != OpName::src0)
+        return StringRef("lds_direct may be used as src0 only");
     }
   }
 
-  if (Src0Idx == -1)
-    return true;
-
-  const MCOperand &Src = Inst.getOperand(Src0Idx);
-  if (!Src.isReg() || Src.getReg() != LDS_DIRECT)
-    return true;
-
-  // lds_direct is specified as src0. Check additional limitations.
-  return (Desc.TSFlags & SIInstrFlags::SDWA) == 0 && !IsRevOpcode(Opcode);
+  return None;
 }
 
 SMLoc AMDGPUAsmParser::getFlatOffsetLoc(const OperandVector &Operands) const {
   for (unsigned i = 1, e = Operands.size(); i != e; ++i) {
     AMDGPUOperand &Op = ((AMDGPUOperand &)*Operands[i]);
     if (Op.isFlatOffset())
       return Op.getStartLoc();
   }
bool AMDGPUAsmParser::validateCoherencyBits(const MCInst &Inst,
   }
 
   return true;
 }
 
 bool AMDGPUAsmParser::validateInstruction(const MCInst &Inst,
                                           const SMLoc &IDLoc,
                                           const OperandVector &Operands) {
-  if (!validateLdsDirect(Inst)) {
-    Error(getRegLoc(AMDGPU::LDS_DIRECT, Operands),
-      "invalid use of lds_direct");
+  if (auto ErrMsg = validateLdsDirect(Inst)) {
+    Error(getRegLoc(LDS_DIRECT, Operands), *ErrMsg);
     return false;
   }
   if (!validateSOPLiteral(Inst)) {
     Error(getLitLoc(Operands),
       "only one literal operand is allowed");
     return false;
   }
   if (!validateVOP3Literal(Inst, Operands)) {

llvm/test/MC/AMDGPU/gfx10_err_pos.s

 // invalid syntax, expected 'neg' modifier
 
 v_ceil_f32 v0, --1
 // CHECK: error: invalid syntax, expected 'neg' modifier
 // CHECK-NEXT:{{^}}v_ceil_f32 v0, --1
 // CHECK-NEXT:{{^}}               ^
 
 //==============================================================================
-// invalid use of lds_direct
+// lane id must be in the interval [0,group size - 1]
+
+ds_swizzle_b32 v8, v2 offset:swizzle(BROADCAST,2,-1)
+// CHECK: error: lane id must be in the interval [0,group size - 1]
+// CHECK-NEXT:{{^}}ds_swizzle_b32 v8, v2 offset:swizzle(BROADCAST,2,-1)
+// CHECK-NEXT:{{^}}                                                 ^
+
+//==============================================================================
+// lds_direct cannot be used with this instruction
 
 v_ashrrev_i16 v0, lds_direct, v0
-// CHECK: error: invalid use of lds_direct
+// CHECK: error: lds_direct cannot be used with this instruction
 // CHECK-NEXT:{{^}}v_ashrrev_i16 v0, lds_direct, v0
 // CHECK-NEXT:{{^}}                  ^
 
+v_ashrrev_i16 v0, v1, lds_direct
+// CHECK: error: lds_direct cannot be used with this instruction
+// CHECK-NEXT:{{^}}v_ashrrev_i16 v0, v1, lds_direct
+// CHECK-NEXT:{{^}}                      ^
+
+v_mov_b32_sdwa v1, src_lds_direct dst_sel:DWORD
+// CHECK: error: lds_direct cannot be used with this instruction
+// CHECK-NEXT:{{^}}v_mov_b32_sdwa v1, src_lds_direct dst_sel:DWORD
+// CHECK-NEXT:{{^}}                   ^
+
+v_add_f32_sdwa v5, v1, lds_direct dst_sel:DWORD
+// CHECK: error: lds_direct cannot be used with this instruction
+// CHECK-NEXT:{{^}}v_add_f32_sdwa v5, v1, lds_direct dst_sel:DWORD
+// CHECK-NEXT:{{^}}                       ^
+
 //==============================================================================
-// lane id must be in the interval [0,group size - 1]
+// lds_direct may be used as src0 only
 
-ds_swizzle_b32 v8, v2 offset:swizzle(BROADCAST,2,-1)
-// CHECK: error: lane id must be in the interval [0,group size - 1]
-// CHECK-NEXT:{{^}}ds_swizzle_b32 v8, v2 offset:swizzle(BROADCAST,2,-1)
-// CHECK-NEXT:{{^}}                                                 ^
+v_add_f32 v5, v1, lds_direct
+// CHECK: error: lds_direct may be used as src0 only
+// CHECK-NEXT:{{^}}v_add_f32 v5, v1, lds_direct
+// CHECK-NEXT:{{^}}                  ^
 
 //==============================================================================
 // message does not support operations
 
 s_sendmsg sendmsg(MSG_GS_ALLOC_REQ, 0)
 // CHECK: error: message does not support operations
 // CHECK-NEXT:{{^}}s_sendmsg sendmsg(MSG_GS_ALLOC_REQ, 0)
 // CHECK-NEXT:{{^}}                                    ^

llvm/test/MC/AMDGPU/gfx90a_err.s

 global_atomic_add_f64 v[0:1], v[2:3], off scc
 // GFX90A: error: invalid operand for instruction
 
 global_atomic_min_f64 v[0:1], v[2:3], off scc
 // GFX90A: error: invalid operand for instruction
 
 global_atomic_max_f64 v[0:1], v[2:3], off scc
 // GFX90A: error: invalid operand for instruction
+
+v_mov_b32_sdwa v1, src_lds_direct dst_sel:DWORD
+// GFX90A: error: lds_direct is not supported on this GPU
+
+v_add_f32_sdwa v5, v1, lds_direct dst_sel:DWORD
+// GFX90A: error: lds_direct is not supported on this GPU
+
+v_ashrrev_i16 v0, lds_direct, v0
+// GFX90A: error: lds_direct is not supported on this GPU
+
+v_add_f32 v5, v1, lds_direct
+// GFX90A: error: lds_direct is not supported on this GPU

llvm/test/MC/AMDGPU/lds_direct-err.s

 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck %s --check-prefix=NOGFX9 --implicit-check-not=error:
 
 //---------------------------------------------------------------------------//
 // lds_direct may be used only with vector ALU instructions
 //---------------------------------------------------------------------------//
 
 s_and_b32 s2, lds_direct, s1
 // NOGFX9: error: invalid operand for instruction
 
 //---------------------------------------------------------------------------//
 // lds_direct may not be used with "REV" opcodes
 //---------------------------------------------------------------------------//
 
 v_ashrrev_i16 v0, lds_direct, v0
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 v_ashrrev_i32 v0, lds_direct, v0
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 v_lshlrev_b16 v0, lds_direct, v0
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 v_lshlrev_b32 v0, lds_direct, v0
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 v_lshrrev_b16 v0, lds_direct, v0
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 v_lshrrev_b32 v0, lds_direct, v0
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 v_pk_ashrrev_i16 v0, lds_direct, v0
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 v_pk_lshlrev_b16 v0, lds_direct, v0
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 v_pk_lshrrev_b16 v0, lds_direct, v0
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 v_subbrev_co_u32 v0, vcc, src_lds_direct, v0, vcc
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 v_subrev_co_u32 v0, vcc, src_lds_direct, v0
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 v_subrev_f16 v0, src_lds_direct, v0
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 v_subrev_u16 v0, src_lds_direct, v0
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 v_subrev_u32 v0, src_lds_direct, v0
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct cannot be used with this instruction
 
 //---------------------------------------------------------------------------//
 // lds_direct may not be used with v_writelane_b32 for VI/GFX9
 //---------------------------------------------------------------------------//
 
 v_writelane_b32 v0, lds_direct, s0
 // NOGFX9: error: operands are not valid for this GPU or mode
 
 //---------------------------------------------------------------------------//
 // lds_direct cannot be used with 64-bit and larger operands
 //---------------------------------------------------------------------------//
 
 v_add_f64 v[0:1], lds_direct, v[0:1]
 // NOGFX9: error: invalid operand for instruction
 
 //---------------------------------------------------------------------------//
 // Only SRC0 may specify lds_direct
 //---------------------------------------------------------------------------//
 
 v_add_i32 v0, v0, lds_direct
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct may be used as src0 only
 
 v_add_i32 lds_direct, v0, v0
 // NOGFX9: error: invalid operand for instruction
 
 v_fma_f32 v0, v0, v0, lds_direct
-// NOGFX9: error: invalid use of lds_direct
+// NOGFX9: error: lds_direct may be used as src0 only

llvm/test/MC/AMDGPU/lds_direct-gfx10.s

 
 v_permlane16_b32 v0, lds_direct, s0, s0
 // NOGFX10: error: invalid operand for instruction
 
 v_permlanex16_b32 v0, lds_direct, s0, s0
 // NOGFX10: error: invalid operand for instruction
 
 v_ashrrev_i16 v0, src_lds_direct, v0
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction
 
 v_ashrrev_i32 v0, src_lds_direct, v0
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction
 
 v_lshlrev_b16 v0, src_lds_direct, v0
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction
 
 v_lshlrev_b32 v0, src_lds_direct, v0
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction
 
 v_lshrrev_b16 v0, src_lds_direct, v0
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction
 
 v_lshrrev_b32 v0, src_lds_direct, v0
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction
 
 v_pk_ashrrev_i16 v0, src_lds_direct, v0
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction
 
 v_pk_lshlrev_b16 v0, src_lds_direct, v0
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction
 
 v_pk_lshrrev_b16 v0, src_lds_direct, v0
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction
 
 v_subrev_co_ci_u32 v0, vcc_lo, src_lds_direct, v0, vcc_lo
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction
 
 v_subrev_co_u32 v0, s0, src_lds_direct, v0
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction
 
 v_subrev_f16 v0, src_lds_direct, v0
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction
 
 v_subrev_f32 v0, src_lds_direct, v0
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction
 
 v_subrev_nc_u32 v0, src_lds_direct, v0
-// NOGFX10: error: invalid use of lds_direct
+// NOGFX10: error: lds_direct cannot be used with this instruction