[AMDGPU][MC] Corrected parsing of optional modifiers

[dp]

Summary

Summary of changes:

• Refactored parseNamedBit;
• Removed obsoleted code (handling of default values have changed long ago);
• Fixed bugs in parsing of "no*" modifiers (bug 41282);
• Improved errors handling.

[foad]

LGTM.

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

5933

drop_front might be a bit clearer than substr?

[dp]

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

5933

Thanks! I'll correct this before committing.

[rampitec]

LGTM

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

public:
 
   OperandMatchResultTy
   parseOperandArrayWithPrefix(const char *Prefix,
                               OperandVector &Operands,
                               AMDGPUOperand::ImmTy ImmTy = AMDGPUOperand::ImmTyNone,
                               bool (*ConvertResult)(int64_t&) = nullptr);
 
   OperandMatchResultTy
-  parseNamedBit(const char *Name, OperandVector &Operands,
+  parseNamedBit(StringRef Name, OperandVector &Operands,
                 AMDGPUOperand::ImmTy ImmTy = AMDGPUOperand::ImmTyNone);
   OperandMatchResultTy parseStringWithPrefix(StringRef Prefix,
                                              StringRef &Value,
                                              SMLoc &StringLoc);
 
   bool isModifier();
   bool isOperandModifier(const AsmToken &Token, const AsmToken &NextToken) const;
   bool isRegOrOperandModifier(const AsmToken &Token, const AsmToken &NextToken) const;
bool isSupportedMnemo(StringRef Mnemo,
                         const FeatureBitset &FBS,
                         ArrayRef<unsigned> Variants);
   bool checkUnsupportedInstruction(StringRef Name, const SMLoc &IDLoc);
 
   bool isId(const StringRef Id) const;
   bool isId(const AsmToken &Token, const StringRef Id) const;
   bool isToken(const AsmToken::TokenKind Kind) const;
   bool trySkipId(const StringRef Id);
+  bool trySkipId(const StringRef Pref, const StringRef Id);
   bool trySkipId(const StringRef Id, const AsmToken::TokenKind Kind);
   bool trySkipToken(const AsmToken::TokenKind Kind);
   bool skipToken(const AsmToken::TokenKind Kind, const StringRef ErrMsg);
   bool parseString(StringRef &Val, const StringRef ErrMsg = "expected a string");
   bool parseId(StringRef &Val, const StringRef ErrMsg = "");
 
   void peekTokens(MutableArrayRef<AsmToken> Tokens);
   AsmToken::TokenKind getTokenKind() const;
if (!skipToken(AsmToken::Comma, "expected a comma"))
       return MatchOperand_ParseFail;
   }
 
   Operands.push_back(AMDGPUOperand::CreateImm(this, Val, S, ImmTy));
   return MatchOperand_Success;
 }
 
 OperandMatchResultTy
-AMDGPUAsmParser::parseNamedBit(const char *Name, OperandVector &Operands,
+AMDGPUAsmParser::parseNamedBit(StringRef Name, OperandVector &Operands,
                                AMDGPUOperand::ImmTy ImmTy) {
-  int64_t Bit = 0;
+  int64_t Bit;
   SMLoc S = getLoc();
 
-  // We are at the end of the statement, and this is a default argument, so
-  // use a default value.
-  if (!isToken(AsmToken::EndOfStatement)) {
-    switch(getTokenKind()) {
-      case AsmToken::Identifier: {
-        StringRef Tok = getTokenStr();
-        if (Tok == Name) {
-          if (Tok == "r128" && !hasMIMG_R128())
-            Error(S, "r128 modifier is not supported on this GPU");
-          if (Tok == "a16" && !isGFX9() && !hasGFX10A16())
-            Error(S, "a16 modifier is not supported on this GPU");
-          Bit = 1;
-          Parser.Lex();
-        } else if (Tok.startswith("no") && Tok.endswith(Name)) {
-          Bit = 0;
-          Parser.Lex();
-        } else {
-          return MatchOperand_NoMatch;
-        }
-        break;
-      }
-      default:
-        return MatchOperand_NoMatch;
-    }
+  if (trySkipId(Name)) {
+  } else if (trySkipId("no", Name)) {
+
+  if (Name == "r128" && !hasMIMG_R128()) {
+    Error(S, "r128 modifier is not supported on this GPU");
+    return MatchOperand_ParseFail;
+  } 
+  if (Name == "a16" && !isGFX9() && !hasGFX10A16()) {
+    Error(S, "a16 modifier is not supported on this GPU");
+    return MatchOperand_ParseFail;
   }
-
-  if (!isGFX10Plus() && ImmTy == AMDGPUOperand::ImmTyDLC)
+  if (!isGFX10Plus() && ImmTy == AMDGPUOperand::ImmTyDLC) {
+    Error(S, "dlc modifier is not supported on this GPU");
     return MatchOperand_ParseFail;
+  }
 
   if (isGFX9() && ImmTy == AMDGPUOperand::ImmTyA16)
     ImmTy = AMDGPUOperand::ImmTyR128A16;
 
   Operands.push_back(AMDGPUOperand::CreateImm(this, Bit, S, ImmTy));
   return MatchOperand_Success;
 }
 
AMDGPUAsmParser::trySkipId(const StringRef Id) {
   if (isId(Id)) {
     lex();
     return true;
   }
   return false;
 }
 
 bool
+AMDGPUAsmParser::trySkipId(const StringRef Pref, const StringRef Id) {
+  if (isToken(AsmToken::Identifier)) {
+    StringRef Tok = getTokenStr();
+    if (Tok.startswith(Pref) && Tok.substr(Pref.size()) == Id) {
+      lex();
+      return true;
+    }
+  }
+  return false;
+}
+
+bool
 AMDGPUAsmParser::trySkipId(const StringRef Id, const AsmToken::TokenKind Kind) {
   if (isId(Id) && peekToken().is(Kind)) {
     lex();
     lex();
     return true;
   }
   return false;
 }

llvm/test/MC/AMDGPU/flat-global.s

 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 -show-encoding %s | FileCheck --check-prefixes=GFX9,GCN %s
 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 2>&1 %s | FileCheck -check-prefix=GFX9-ERR --implicit-check-not=error: %s
 // RUN: not llvm-mc -arch=amdgcn -mcpu=tonga 2>&1 %s | FileCheck -check-prefix=VI-ERR --implicit-check-not=error: %s
 
 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1010 -show-encoding %s | FileCheck --check-prefix=GFX10 %s
 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1010 %s 2>&1 | FileCheck --check-prefix=GFX10-ERR --implicit-check-not=error: %s
 
 global_load_ubyte v1, v[3:4], off
 // GFX10: encoding: [0x00,0x80,0x20,0xdc,0x03,0x00,0x7d,0x01]
 // GFX9: global_load_ubyte v1, v[3:4], off ; encoding: [0x00,0x80,0x40,0xdc,0x03,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_ubyte v1, v[3:4], off dlc
 // GFX10: encoding: [0x00,0x90,0x20,0xdc,0x03,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_sbyte v1, v[3:4], off
 // GFX10: encoding: [0x00,0x80,0x24,0xdc,0x03,0x00,0x7d,0x01]
 // GFX9: global_load_sbyte v1, v[3:4], off ; encoding: [0x00,0x80,0x44,0xdc,0x03,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_sbyte v1, v[3:4], off dlc
 // GFX10: encoding: [0x00,0x90,0x24,0xdc,0x03,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_ushort v1, v[3:4], off
 // GFX10: encoding: [0x00,0x80,0x28,0xdc,0x03,0x00,0x7d,0x01]
 // GFX9: global_load_ushort v1, v[3:4], off ; encoding: [0x00,0x80,0x48,0xdc,0x03,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_ushort v1, v[3:4], off dlc
 // GFX10: encoding: [0x00,0x90,0x28,0xdc,0x03,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_sshort v1, v[3:4], off
 // GFX10: encoding: [0x00,0x80,0x2c,0xdc,0x03,0x00,0x7d,0x01]
 // GFX9: global_load_sshort v1, v[3:4], off ; encoding: [0x00,0x80,0x4c,0xdc,0x03,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_sshort v1, v[3:4], off dlc
 // GFX10: encoding: [0x00,0x90,0x2c,0xdc,0x03,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_dword v1, v[3:4], off
 // GFX10: encoding: [0x00,0x80,0x30,0xdc,0x03,0x00,0x7d,0x01]
 // GFX9: global_load_dword v1, v[3:4], off ; encoding: [0x00,0x80,0x50,0xdc,0x03,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_dword v1, v[3:4], off dlc
 // GFX10: encoding: [0x00,0x90,0x30,0xdc,0x03,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_dwordx2 v[1:2], v[3:4], off
 // GFX10: encoding: [0x00,0x80,0x34,0xdc,0x03,0x00,0x7d,0x01]
 // GFX9: global_load_dwordx2 v[1:2], v[3:4], off ; encoding: [0x00,0x80,0x54,0xdc,0x03,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_dwordx2 v[1:2], v[3:4], off dlc
 // GFX10: encoding: [0x00,0x90,0x34,0xdc,0x03,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_dwordx3 v[1:3], v[3:4], off
 // GFX10: encoding: [0x00,0x80,0x3c,0xdc,0x03,0x00,0x7d,0x01]
 // GFX9: global_load_dwordx3 v[1:3], v[3:4], off ; encoding: [0x00,0x80,0x58,0xdc,0x03,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_dwordx3 v[1:3], v[3:4], off dlc
 // GFX10: encoding: [0x00,0x90,0x3c,0xdc,0x03,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_dwordx4 v[1:4], v[3:4], off
 // GFX10: encoding: [0x00,0x80,0x38,0xdc,0x03,0x00,0x7d,0x01]
 // GFX9: global_load_dwordx4 v[1:4], v[3:4], off   ; encoding: [0x00,0x80,0x5c,0xdc,0x03,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_dwordx4 v[1:4], v[3:4], off dlc
 // GFX10: encoding: [0x00,0x90,0x38,0xdc,0x03,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_load_dword v1, v[3:4], off offset:0
 // GFX10: encoding: [0x00,0x80,0x30,0xdc,0x03,0x00,0x7d,0x01]
 // GFX9: global_load_dword v1, v[3:4], off    ; encoding: [0x00,0x80,0x50,0xdc,0x03,0x00,0x7f,0x01]
 // VI-ERR: :1: error: instruction not supported on this GPU
 
 global_load_dword v1, v[3:4], off offset:4095

 
 global_store_byte v[3:4], v1, off
 // GFX10: encoding: [0x00,0x80,0x60,0xdc,0x03,0x01,0x7d,0x00]
 // GFX9: global_store_byte v[3:4], v1, off ; encoding: [0x00,0x80,0x60,0xdc,0x03,0x01,0x7f,0x00]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_store_byte v[3:4], v1, off dlc
 // GFX10: encoding: [0x00,0x90,0x60,0xdc,0x03,0x01,0x7d,0x00]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_store_short v[3:4], v1, off
 // GFX10: encoding: [0x00,0x80,0x68,0xdc,0x03,0x01,0x7d,0x00]
 // GFX9: global_store_short v[3:4], v1, off ; encoding: [0x00,0x80,0x68,0xdc,0x03,0x01,0x7f,0x00]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_store_short v[3:4], v1, off dlc
 // GFX10: encoding: [0x00,0x90,0x68,0xdc,0x03,0x01,0x7d,0x00]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_store_dword v[3:4], v1, off
 // GFX10: encoding: [0x00,0x80,0x70,0xdc,0x03,0x01,0x7d,0x00]
 // GFX9: global_store_dword v[3:4], v1, off ; encoding: [0x00,0x80,0x70,0xdc,0x03,0x01,0x7f,0x00]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_store_dword v[3:4], v1, off dlc
 // GFX10: encoding: [0x00,0x90,0x70,0xdc,0x03,0x01,0x7d,0x00]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_store_dwordx2 v[3:4], v[1:2], off
 // GFX10: encoding: [0x00,0x80,0x74,0xdc,0x03,0x01,0x7d,0x00]
 // GFX9: global_store_dwordx2 v[3:4], v[1:2], off ; encoding: [0x00,0x80,0x74,0xdc,0x03,0x01,0x7f,0x00]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_store_dwordx2 v[3:4], v[1:2], off dlc
 // GFX10: encoding: [0x00,0x90,0x74,0xdc,0x03,0x01,0x7d,0x00]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_store_dwordx3 v[3:4], v[1:3], off
 // GFX10: encoding: [0x00,0x80,0x7c,0xdc,0x03,0x01,0x7d,0x00]
 // GFX9: global_store_dwordx3 v[3:4], v[1:3], off ; encoding: [0x00,0x80,0x78,0xdc,0x03,0x01,0x7f,0x00]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_store_dwordx3 v[3:4], v[1:3], off dlc
 // GFX10: encoding: [0x00,0x90,0x7c,0xdc,0x03,0x01,0x7d,0x00]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_store_dwordx4 v[3:4], v[1:4], off
 // GFX10: encoding: [0x00,0x80,0x78,0xdc,0x03,0x01,0x7d,0x00]
 // GFX9: global_store_dwordx4 v[3:4], v[1:4], off ; encoding: [0x00,0x80,0x7c,0xdc,0x03,0x01,0x7f,0x00]
 // VI-ERR: error: instruction not supported on this GPU
 
 global_store_dwordx4 v[3:4], v[1:4], off dlc
 // GFX10: encoding: [0x00,0x90,0x78,0xdc,0x03,0x01,0x7d,0x00]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 global_store_dword v[3:4], v1, off offset:12
 // GFX10: encoding: [0x0c,0x80,0x70,0xdc,0x03,0x01,0x7d,0x00]
 // GFX9: global_store_dword v[3:4], v1, off offset:12 ; encoding: [0x0c,0x80,0x70,0xdc,0x03,0x01,0x7f,0x00]
 // VI-ERR: :1: error: instruction not supported on this GPU
 
 global_load_dword v1, v3, s[2:3]

llvm/test/MC/AMDGPU/flat-scratch-instructions.s

 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 -show-encoding %s | FileCheck -check-prefix=GFX9 %s
 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 2>&1 %s | FileCheck -check-prefix=GFX9-ERR --implicit-check-not=error: %s
 // RUN: not llvm-mc -arch=amdgcn -mcpu=tonga 2>&1 %s | FileCheck -check-prefix=VI-ERR --implicit-check-not=error: %s
 
 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1010 -show-encoding %s | FileCheck --check-prefix=GFX10 %s
 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1010 %s 2>&1 | FileCheck --check-prefix=GFX10-ERR --implicit-check-not=error: %s
 
 scratch_load_ubyte v1, v2, off
 // GFX10: encoding: [0x00,0x40,0x20,0xdc,0x02,0x00,0x7d,0x01]
 // GFX9: scratch_load_ubyte v1, v2, off      ; encoding: [0x00,0x40,0x40,0xdc,0x02,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_ubyte v1, v2, off dlc
 // GFX10: encoding: [0x00,0x50,0x20,0xdc,0x02,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_sbyte v1, v2, off
 // GFX10: encoding: [0x00,0x40,0x24,0xdc,0x02,0x00,0x7d,0x01]
 // GFX9: scratch_load_sbyte v1, v2, off      ; encoding: [0x00,0x40,0x44,0xdc,0x02,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_sbyte v1, v2, off dlc
 // GFX10: encoding: [0x00,0x50,0x24,0xdc,0x02,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_ushort v1, v2, off
 // GFX10: encoding: [0x00,0x40,0x28,0xdc,0x02,0x00,0x7d,0x01]
 // GFX9: scratch_load_ushort v1, v2, off      ; encoding: [0x00,0x40,0x48,0xdc,0x02,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_ushort v1, v2, off dlc
 // GFX10: encoding: [0x00,0x50,0x28,0xdc,0x02,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_sshort v1, v2, off
 // GFX10: encoding: [0x00,0x40,0x2c,0xdc,0x02,0x00,0x7d,0x01]
 // GFX9: scratch_load_sshort v1, v2, off      ; encoding: [0x00,0x40,0x4c,0xdc,0x02,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_sshort v1, v2, off dlc
 // GFX10: encoding: [0x00,0x50,0x2c,0xdc,0x02,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_dword v1, v2, off
 // GFX10: encoding: [0x00,0x40,0x30,0xdc,0x02,0x00,0x7d,0x01]
 // GFX9: scratch_load_dword v1, v2, off ; encoding: [0x00,0x40,0x50,0xdc,0x02,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_dword v1, v2, off dlc
 // GFX10: encoding: [0x00,0x50,0x30,0xdc,0x02,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_dwordx2 v[1:2], v3, off
 // GFX10: encoding: [0x00,0x40,0x34,0xdc,0x03,0x00,0x7d,0x01]
 // GFX9: scratch_load_dwordx2 v[1:2], v3, off      ; encoding: [0x00,0x40,0x54,0xdc,0x03,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_dwordx2 v[1:2], v3, off dlc
 // GFX10: encoding: [0x00,0x50,0x34,0xdc,0x03,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_dwordx3 v[1:3], v4, off
 // GFX10: encoding: [0x00,0x40,0x3c,0xdc,0x04,0x00,0x7d,0x01]
 // GFX9: scratch_load_dwordx3 v[1:3], v4, off      ; encoding: [0x00,0x40,0x58,0xdc,0x04,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_dwordx3 v[1:3], v4, off dlc
 // GFX10: encoding: [0x00,0x50,0x3c,0xdc,0x04,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_dwordx4 v[1:4], v5, off
 // GFX10: encoding: [0x00,0x40,0x38,0xdc,0x05,0x00,0x7d,0x01]
 // GFX9: scratch_load_dwordx4 v[1:4], v5, off      ; encoding: [0x00,0x40,0x5c,0xdc,0x05,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_dwordx4 v[1:4], v5, off dlc
 // GFX10: encoding: [0x00,0x50,0x38,0xdc,0x05,0x00,0x7d,0x01]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_dword v1, v2, off offset:0
 // GFX10: encoding: [0x00,0x40,0x30,0xdc,0x02,0x00,0x7d,0x01]
 // GFX9: scratch_load_dword v1, v2, off      ; encoding: [0x00,0x40,0x50,0xdc,0x02,0x00,0x7f,0x01]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_dword v1, v2, off offset:4095

 
 scratch_store_byte v1, v2, off
 // GFX10: encoding: [0x00,0x40,0x60,0xdc,0x01,0x02,0x7d,0x00]
 // GFX9: scratch_store_byte v1, v2, off ; encoding: [0x00,0x40,0x60,0xdc,0x01,0x02,0x7f,0x00]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_store_byte v1, v2, off dlc
 // GFX10: encoding: [0x00,0x50,0x60,0xdc,0x01,0x02,0x7d,0x00]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_store_short v1, v2, off
 // GFX10: encoding: [0x00,0x40,0x68,0xdc,0x01,0x02,0x7d,0x00]
 // GFX9: scratch_store_short v1, v2, off ; encoding: [0x00,0x40,0x68,0xdc,0x01,0x02,0x7f,0x00]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_store_short v1, v2, off dlc
 // GFX10: encoding: [0x00,0x50,0x68,0xdc,0x01,0x02,0x7d,0x00]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_store_dword v1, v2, off
 // GFX10: encoding: [0x00,0x40,0x70,0xdc,0x01,0x02,0x7d,0x00]
 // GFX9: scratch_store_dword v1, v2, off ; encoding: [0x00,0x40,0x70,0xdc,0x01,0x02,0x7f,0x00]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_store_dword v1, v2, off dlc
 // GFX10: encoding: [0x00,0x50,0x70,0xdc,0x01,0x02,0x7d,0x00]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_store_dwordx2 v1, v[2:3], off
 // GFX10: encoding: [0x00,0x40,0x74,0xdc,0x01,0x02,0x7d,0x00]
 // GFX9: scratch_store_dwordx2 v1, v[2:3], off ; encoding: [0x00,0x40,0x74,0xdc,0x01,0x02,0x7f,0x00]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_store_dwordx2 v1, v[2:3], off dlc
 // GFX10: encoding: [0x00,0x50,0x74,0xdc,0x01,0x02,0x7d,0x00]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_store_dwordx3 v1, v[2:4], off
 // GFX10: encoding: [0x00,0x40,0x7c,0xdc,0x01,0x02,0x7d,0x00]
 // GFX9: scratch_store_dwordx3 v1, v[2:4], off ; encoding: [0x00,0x40,0x78,0xdc,0x01,0x02,0x7f,0x00]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_store_dwordx3 v1, v[2:4], off dlc
 // GFX10: encoding: [0x00,0x50,0x7c,0xdc,0x01,0x02,0x7d,0x00]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_store_dwordx4 v1, v[2:5], off
 // GFX10: encoding: [0x00,0x40,0x78,0xdc,0x01,0x02,0x7d,0x00]
 // GFX9: scratch_store_dwordx4 v1, v[2:5], off ; encoding: [0x00,0x40,0x7c,0xdc,0x01,0x02,0x7f,0x00]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_store_dwordx4 v1, v[2:5], off dlc
 // GFX10: encoding: [0x00,0x50,0x78,0xdc,0x01,0x02,0x7d,0x00]
-// GFX9-ERR: error: failed parsing operand
+// GFX9-ERR: error: dlc modifier is not supported on this GPU
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_store_dword v1, v2, off offset:12
 // GFX10: encoding: [0x0c,0x40,0x70,0xdc,0x01,0x02,0x7d,0x00]
 // GFX9: scratch_store_dword v1, v2, off offset:12 ; encoding: [0x0c,0x40,0x70,0xdc,0x01,0x02,0x7f,0x00]
 // VI-ERR: error: instruction not supported on this GPU
 
 scratch_load_dword v1, off, s1

llvm/test/MC/AMDGPU/gfx8_err_pos.s

 // RUN: not llvm-mc -arch=amdgcn -mcpu=tonga %s 2>&1 | FileCheck %s --implicit-check-not=error: --strict-whitespace
 
 //==============================================================================
 // a16 modifier is not supported on this GPU
 
 image_gather4 v[5:8], v1, s[8:15], s[12:15] dmask:0x1 a16
 // CHECK: error: a16 modifier is not supported on this GPU
 // CHECK-NEXT:{{^}}image_gather4 v[5:8], v1, s[8:15], s[12:15] dmask:0x1 a16
 // CHECK-NEXT:{{^}}                                                      ^
 
+image_gather4 v[5:8], v1, s[8:15], s[12:15] dmask:0x1 noa16
+// CHECK: error: a16 modifier is not supported on this GPU
+// CHECK-NEXT:{{^}}image_gather4 v[5:8], v1, s[8:15], s[12:15] dmask:0x1 noa16
+// CHECK-NEXT:{{^}}                                                      ^
+
 //==============================================================================
 // expected a 20-bit unsigned offset
 
 s_atc_probe 0x7, s[4:5], -1
 // CHECK: error: expected a 20-bit unsigned offset
 // CHECK-NEXT:{{^}}s_atc_probe 0x7, s[4:5], -1
 // CHECK-NEXT:{{^}}                         ^
 

llvm/test/MC/AMDGPU/gfx9_err_pos.s

 // ABS not allowed in VOP3B instructions
 
 v_div_scale_f64  v[24:25], vcc, -|v[22:23]|, v[22:23], v[20:21]
 // CHECK: error: ABS not allowed in VOP3B instructions
 // CHECK-NEXT:{{^}}v_div_scale_f64  v[24:25], vcc, -|v[22:23]|, v[22:23], v[20:21]
 // CHECK-NEXT:{{^}}^
 
 //==============================================================================
+// dlc modifier is not supported on this GPU
+
+scratch_load_ubyte v1, v2, off dlc
+// CHECK: error: dlc modifier is not supported on this GPU
+// CHECK-NEXT:{{^}}scratch_load_ubyte v1, v2, off dlc
+// CHECK-NEXT:{{^}}                               ^
+
+scratch_load_ubyte v1, v2, off nodlc
+// CHECK: error: dlc modifier is not supported on this GPU
+// CHECK-NEXT:{{^}}scratch_load_ubyte v1, v2, off nodlc
+// CHECK-NEXT:{{^}}                               ^
+
+//==============================================================================
 // duplicate VGPR index mode
 
 s_set_gpr_idx_on s0, gpr_idx(SRC0,DST,SRC1,DST)
 // CHECK: error: duplicate VGPR index mode
 // CHECK-NEXT:{{^}}s_set_gpr_idx_on s0, gpr_idx(SRC0,DST,SRC1,DST)
 // CHECK-NEXT:{{^}}                                           ^
 
 //==============================================================================

 //==============================================================================
 // r128 modifier is not supported on this GPU
 
 image_atomic_add v10, v6, s[8:15] dmask:0x1 r128
 // CHECK: error: r128 modifier is not supported on this GPU
 // CHECK-NEXT:{{^}}image_atomic_add v10, v6, s[8:15] dmask:0x1 r128
 // CHECK-NEXT:{{^}}                                            ^
 
+image_atomic_add v10, v6, s[8:15] dmask:0x1 nor128
+// CHECK: error: r128 modifier is not supported on this GPU
+// CHECK-NEXT:{{^}}image_atomic_add v10, v6, s[8:15] dmask:0x1 nor128
+// CHECK-NEXT:{{^}}                                            ^
+
 //==============================================================================
 // unified format is not supported on this GPU
 
 tbuffer_store_format_xyzw v[1:4], v1, s[4:7], s0 format:[BUF_FMT_8_SNORM,BUF_DATA_FORMAT_8] idxen
 // CHECK: error: unified format is not supported on this GPU
 // CHECK-NEXT:{{^}}tbuffer_store_format_xyzw v[1:4], v1, s[4:7], s0 format:[BUF_FMT_8_SNORM,BUF_DATA_FORMAT_8] idxen
 // CHECK-NEXT:{{^}}                                                         ^
 

llvm/test/MC/AMDGPU/vop3-modifiers-err.s

 // RUN: not llvm-mc -arch=amdgcn -mcpu=tonga %s 2>&1 | FileCheck --implicit-check-not=error: %s
 
 //---------------------------------------------------------------------------//
 // VOP3 Modifiers
 //---------------------------------------------------------------------------//
 
 // 'neg(1)' cannot be encoded as 32-bit literal while preserving e64 semantics
 v_ceil_f64_e32 v[0:1], neg(1)
 // CHECK: error: invalid operand for instruction
 
 v_ceil_f32 v0, --1
 // CHECK: error: invalid syntax, expected 'neg' modifier
 
 v_ceil_f16 v0, abs(neg(1))
 // CHECK: error: failed parsing operand
+
+v_cvt_f16_u16_e64 v5, s1 noXXXclamp
+// CHECK: error: invalid operand for instruction

llvm/test/MC/AMDGPU/vop3-modifiers.s

 
 // NB: output modifiers are not supported for f16
 v_cvt_f16_i16_e64 v5, s1 clamp
 // CHECK: [0x05,0x80,0x7a,0xd1,0x01,0x00,0x00,0x00]
 
 // NB: output modifiers are not supported for f16
 v_cvt_f16_u16_e64 v5, s1 clamp
 // CHECK: [0x05,0x80,0x79,0xd1,0x01,0x00,0x00,0x00]
+
+v_cvt_f16_u16_e64 v5, s1 noclamp
+// CHECK: [0x05,0x00,0x79,0xd1,0x01,0x00,0x00,0x00]