[SystemZ] Allow %r0 in address context for AsmParser

Registers used in any address (as well as in a few other contexts)
have special semantics when a "zero" register is used, which is
why the back-end defines extra register classes ADDR32, ADDR64 etc
to be used to prevent the register allocator from using %r0 there.

However, when writing assembler code "by hand", you sometimes need
to trigger that special semantics.  However, currently the AsmParser
will reject %r0 in those places.  In some cases it may be possible
to write that instruction differently - but in others it is currently
not possible at all.

This check in AsmParser simply seems overly strict, so this patch
just removes the check completely.  This brings the behaviour of
AsmParser in line with the GNU assembler as well.

Bugzilla: https://bugs.llvm.org/show_bug.cgi?id=45092

diff --git a/llvm/lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp b/llvm/lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp
index 8ad61dd..3bf54ed 100644 (file)
--- a/llvm/lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp
+++ b/llvm/lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp
@@ -53,8 +53,6 @@ enum RegisterKind {
   GRH32Reg,
   GR64Reg,
   GR128Reg,
-  ADDR32Reg,
-  ADDR64Reg,
   FP32Reg,
   FP64Reg,
   FP128Reg,
@@ -109,7 +107,7 @@ private:
 
   // Base + Disp + Index, where Base and Index are LLVM registers or 0.
   // MemKind says what type of memory this is and RegKind says what type
-  // the base register has (ADDR32Reg or ADDR64Reg).  Length is the operand
+  // the base register has (GR32Reg or GR64Reg).  Length is the operand
   // length for D(L,B)-style operands, otherwise it is null.
   struct MemOp {
     unsigned Base : 12;
@@ -348,8 +346,8 @@ public:
   bool isGRX32() const { return false; }
   bool isGR64() const { return isReg(GR64Reg); }
   bool isGR128() const { return isReg(GR128Reg); }
-  bool isADDR32() const { return isReg(ADDR32Reg); }
-  bool isADDR64() const { return isReg(ADDR64Reg); }
+  bool isADDR32() const { return isReg(GR32Reg); }
+  bool isADDR64() const { return isReg(GR64Reg); }
   bool isADDR128() const { return false; }
   bool isFP32() const { return isReg(FP32Reg); }
   bool isFP64() const { return isReg(FP64Reg); }
@@ -361,16 +359,16 @@ public:
   bool isAR32() const { return isReg(AR32Reg); }
   bool isCR64() const { return isReg(CR64Reg); }
   bool isAnyReg() const { return (isReg() || isImm(0, 15)); }
-  bool isBDAddr32Disp12() const { return isMemDisp12(BDMem, ADDR32Reg); }
-  bool isBDAddr32Disp20() const { return isMemDisp20(BDMem, ADDR32Reg); }
-  bool isBDAddr64Disp12() const { return isMemDisp12(BDMem, ADDR64Reg); }
-  bool isBDAddr64Disp20() const { return isMemDisp20(BDMem, ADDR64Reg); }
-  bool isBDXAddr64Disp12() const { return isMemDisp12(BDXMem, ADDR64Reg); }
-  bool isBDXAddr64Disp20() const { return isMemDisp20(BDXMem, ADDR64Reg); }
-  bool isBDLAddr64Disp12Len4() const { return isMemDisp12Len4(ADDR64Reg); }
-  bool isBDLAddr64Disp12Len8() const { return isMemDisp12Len8(ADDR64Reg); }
-  bool isBDRAddr64Disp12() const { return isMemDisp12(BDRMem, ADDR64Reg); }
-  bool isBDVAddr64Disp12() const { return isMemDisp12(BDVMem, ADDR64Reg); }
+  bool isBDAddr32Disp12() const { return isMemDisp12(BDMem, GR32Reg); }
+  bool isBDAddr32Disp20() const { return isMemDisp20(BDMem, GR32Reg); }
+  bool isBDAddr64Disp12() const { return isMemDisp12(BDMem, GR64Reg); }
+  bool isBDAddr64Disp20() const { return isMemDisp20(BDMem, GR64Reg); }
+  bool isBDXAddr64Disp12() const { return isMemDisp12(BDXMem, GR64Reg); }
+  bool isBDXAddr64Disp20() const { return isMemDisp20(BDXMem, GR64Reg); }
+  bool isBDLAddr64Disp12Len4() const { return isMemDisp12Len4(GR64Reg); }
+  bool isBDLAddr64Disp12Len8() const { return isMemDisp12Len8(GR64Reg); }
+  bool isBDRAddr64Disp12() const { return isMemDisp12(BDRMem, GR64Reg); }
+  bool isBDVAddr64Disp12() const { return isMemDisp12(BDVMem, GR64Reg); }
   bool isU1Imm() const { return isImm(0, 1); }
   bool isU2Imm() const { return isImm(0, 3); }
   bool isU3Imm() const { return isImm(0, 7); }
@@ -407,8 +405,7 @@ private:
 
   bool parseRegister(Register &Reg, bool RestoreOnFailure = false);
 
-  bool parseRegister(Register &Reg, RegisterGroup Group, const unsigned *Regs,
-                     bool IsAddress = false);
+  bool parseRegister(Register &Reg, RegisterGroup Group, const unsigned *Regs);
 
   OperandMatchResultTy parseRegister(OperandVector &Operands,
                                      RegisterGroup Group, const unsigned *Regs,
@@ -477,10 +474,12 @@ public:
     return parseRegister(Operands, RegGR, SystemZMC::GR128Regs, GR128Reg);
   }
   OperandMatchResultTy parseADDR32(OperandVector &Operands) {
-    return parseRegister(Operands, RegGR, SystemZMC::GR32Regs, ADDR32Reg);
+    // For the AsmParser, we will accept %r0 for ADDR32 as well.
+    return parseRegister(Operands, RegGR, SystemZMC::GR32Regs, GR32Reg);
   }
   OperandMatchResultTy parseADDR64(OperandVector &Operands) {
-    return parseRegister(Operands, RegGR, SystemZMC::GR64Regs, ADDR64Reg);
+    // For the AsmParser, we will accept %r0 for ADDR64 as well.
+    return parseRegister(Operands, RegGR, SystemZMC::GR64Regs, GR64Reg);
   }
   OperandMatchResultTy parseADDR128(OperandVector &Operands) {
     llvm_unreachable("Shouldn't be used as an operand");
@@ -516,22 +515,22 @@ public:
     return parseAnyRegister(Operands);
   }
   OperandMatchResultTy parseBDAddr32(OperandVector &Operands) {
-    return parseAddress(Operands, BDMem, SystemZMC::GR32Regs, ADDR32Reg);
+    return parseAddress(Operands, BDMem, SystemZMC::GR32Regs, GR32Reg);
   }
   OperandMatchResultTy parseBDAddr64(OperandVector &Operands) {
-    return parseAddress(Operands, BDMem, SystemZMC::GR64Regs, ADDR64Reg);
+    return parseAddress(Operands, BDMem, SystemZMC::GR64Regs, GR64Reg);
   }
   OperandMatchResultTy parseBDXAddr64(OperandVector &Operands) {
-    return parseAddress(Operands, BDXMem, SystemZMC::GR64Regs, ADDR64Reg);
+    return parseAddress(Operands, BDXMem, SystemZMC::GR64Regs, GR64Reg);
   }
   OperandMatchResultTy parseBDLAddr64(OperandVector &Operands) {
-    return parseAddress(Operands, BDLMem, SystemZMC::GR64Regs, ADDR64Reg);
+    return parseAddress(Operands, BDLMem, SystemZMC::GR64Regs, GR64Reg);
   }
   OperandMatchResultTy parseBDRAddr64(OperandVector &Operands) {
-    return parseAddress(Operands, BDRMem, SystemZMC::GR64Regs, ADDR64Reg);
+    return parseAddress(Operands, BDRMem, SystemZMC::GR64Regs, GR64Reg);
   }
   OperandMatchResultTy parseBDVAddr64(OperandVector &Operands) {
-    return parseAddress(Operands, BDVMem, SystemZMC::GR64Regs, ADDR64Reg);
+    return parseAddress(Operands, BDVMem, SystemZMC::GR64Regs, GR64Reg);
   }
   OperandMatchResultTy parsePCRel12(OperandVector &Operands) {
     return parsePCRel(Operands, -(1LL << 12), (1LL << 12) - 1, false);
@@ -751,20 +750,17 @@ bool SystemZAsmParser::parseRegister(Register &Reg, bool RestoreOnFailure) {
 
 // Parse a register of group Group.  If Regs is nonnull, use it to map
 // the raw register number to LLVM numbering, with zero entries
-// indicating an invalid register.  IsAddress says whether the
-// register appears in an address context. Allow FP Group if expecting
+// indicating an invalid register.  Allow FP Group if expecting
 // RegV Group, since the f-prefix yields the FP group even while used
 // with vector instructions.
 bool SystemZAsmParser::parseRegister(Register &Reg, RegisterGroup Group,
-                                     const unsigned *Regs, bool IsAddress) {
+                                     const unsigned *Regs) {
   if (parseRegister(Reg))
     return true;
   if (Reg.Group != Group && !(Reg.Group == RegFP && Group == RegV))
     return Error(Reg.StartLoc, "invalid operand for instruction");
   if (Regs && Regs[Reg.Num] == 0)
     return Error(Reg.StartLoc, "invalid register pair");
-  if (Reg.Num == 0 && IsAddress)
-    return Error(Reg.StartLoc, "%r0 used in an address");
   if (Regs)
     Reg.Num = Regs[Reg.Num];
   return false;
@@ -778,8 +774,7 @@ SystemZAsmParser::parseRegister(OperandVector &Operands, RegisterGroup Group,
     return MatchOperand_NoMatch;
 
   Register Reg;
-  bool IsAddress = (Kind == ADDR32Reg || Kind == ADDR64Reg);
-  if (parseRegister(Reg, Group, Regs, IsAddress))
+  if (parseRegister(Reg, Group, Regs))
     return MatchOperand_ParseFail;
 
   Operands.push_back(SystemZOperand::createReg(Kind, Reg.Num,
@@ -900,9 +895,6 @@ SystemZAsmParser::parseAddressRegister(Register &Reg) {
   } else if (Reg.Group != RegGR) {
     Error(Reg.StartLoc, "invalid address register");
     return true;
-  } else if (Reg.Num == 0) {
-    Error(Reg.StartLoc, "%r0 used in an address");
-    return true;
   }
   return false;
 }

diff --git a/llvm/test/MC/SystemZ/insn-bad-z13.s b/llvm/test/MC/SystemZ/insn-bad-z13.s
index c362b4b..4ae4fd9 100644 (file)
--- a/llvm/test/MC/SystemZ/insn-bad-z13.s
+++ b/llvm/test/MC/SystemZ/insn-bad-z13.s
@@ -33,8 +33,6 @@
 #CHECK: cdpt   %f0, -1(1,%r1), 0
 #CHECK: error: invalid operand
 #CHECK: cdpt   %f0, 4096(1,%r1), 0
-#CHECK: error: %r0 used in an address
-#CHECK: cdpt   %f0, 0(1,%r0), 0
 #CHECK: error: invalid use of indexed addressing
 #CHECK: cdpt   %f0, 0(%r1,%r2), 0
 #CHECK: error: unknown token in expression
@@ -48,7 +46,6 @@
        cdpt    %f0, 0(257,%r1), 0
        cdpt    %f0, -1(1,%r1), 0
        cdpt    %f0, 4096(1,%r1), 0
-       cdpt    %f0, 0(1,%r0), 0
        cdpt    %f0, 0(%r1,%r2), 0
        cdpt    %f0, 0(-), 0
 
@@ -68,8 +65,6 @@
 #CHECK: cpdt   %f0, -1(1,%r1), 0
 #CHECK: error: invalid operand
 #CHECK: cpdt   %f0, 4096(1,%r1), 0
-#CHECK: error: %r0 used in an address
-#CHECK: cpdt   %f0, 0(1,%r0), 0
 #CHECK: error: invalid use of indexed addressing
 #CHECK: cpdt   %f0, 0(%r1,%r2), 0
 #CHECK: error: unknown token in expression
@@ -83,7 +78,6 @@
        cpdt    %f0, 0(257,%r1), 0
        cpdt    %f0, -1(1,%r1), 0
        cpdt    %f0, 4096(1,%r1), 0
-       cpdt    %f0, 0(1,%r0), 0
        cpdt    %f0, 0(%r1,%r2), 0
        cpdt    %f0, 0(-), 0
 
@@ -103,8 +97,6 @@
 #CHECK: cpxt   %f0, -1(1,%r1), 0
 #CHECK: error: invalid operand
 #CHECK: cpxt   %f0, 4096(1,%r1), 0
-#CHECK: error: %r0 used in an address
-#CHECK: cpxt   %f0, 0(1,%r0), 0
 #CHECK: error: invalid use of indexed addressing
 #CHECK: cpxt   %f0, 0(%r1,%r2), 0
 #CHECK: error: unknown token in expression
@@ -120,7 +112,6 @@
        cpxt    %f0, 0(257,%r1), 0
        cpxt    %f0, -1(1,%r1), 0
        cpxt    %f0, 4096(1,%r1), 0
-       cpxt    %f0, 0(1,%r0), 0
        cpxt    %f0, 0(%r1,%r2), 0
        cpxt    %f0, 0(-), 0
        cpxt    %f15, 0(1), 0
@@ -141,8 +132,6 @@
 #CHECK: cxpt   %f0, -1(1,%r1), 0
 #CHECK: error: invalid operand
 #CHECK: cxpt   %f0, 4096(1,%r1), 0
-#CHECK: error: %r0 used in an address
-#CHECK: cxpt   %f0, 0(1,%r0), 0
 #CHECK: error: invalid use of indexed addressing
 #CHECK: cxpt   %f0, 0(%r1,%r2), 0
 #CHECK: error: unknown token in expression
@@ -158,7 +147,6 @@
        cxpt    %f0, 0(257,%r1), 0
        cxpt    %f0, -1(1,%r1), 0
        cxpt    %f0, 4096(1,%r1), 0
-       cxpt    %f0, 0(1,%r0), 0
        cxpt    %f0, 0(%r1,%r2), 0
        cxpt    %f0, 0(-), 0
        cxpt    %f15, 0(1), 0
@@ -1880,58 +1868,43 @@
 #CHECK: vlgv   %r0, %v0, -1, 0
 #CHECK: error: invalid operand
 #CHECK: vlgv   %r0, %v0, 4096, 0
-#CHECK: error: %r0 used in an address
-#CHECK: vlgv   %r0, %v0, 0(%r0), 0
 
        vlgv    %r0, %v0, 0, -1
        vlgv    %r0, %v0, 0, 16
        vlgv    %r0, %v0, -1, 0
        vlgv    %r0, %v0, 4096, 0
-       vlgv    %r0, %v0, 0(%r0), 0
 
 #CHECK: error: invalid operand
 #CHECK: vlgvb  %r0, %v0, -1
 #CHECK: error: invalid operand
 #CHECK: vlgvb  %r0, %v0, 4096
-#CHECK: error: %r0 used in an address
-#CHECK: vlgvb  %r0, %v0, 0(%r0)
 
        vlgvb   %r0, %v0, -1
        vlgvb   %r0, %v0, 4096
-       vlgvb   %r0, %v0, 0(%r0)
 
 #CHECK: error: invalid operand
 #CHECK: vlgvf  %r0, %v0, -1
 #CHECK: error: invalid operand
 #CHECK: vlgvf  %r0, %v0, 4096
-#CHECK: error: %r0 used in an address
-#CHECK: vlgvf  %r0, %v0, 0(%r0)
 
        vlgvf   %r0, %v0, -1
        vlgvf   %r0, %v0, 4096
-       vlgvf   %r0, %v0, 0(%r0)
 
 #CHECK: error: invalid operand
 #CHECK: vlgvg  %r0, %v0, -1
 #CHECK: error: invalid operand
 #CHECK: vlgvg  %r0, %v0, 4096
-#CHECK: error: %r0 used in an address
-#CHECK: vlgvg  %r0, %v0, 0(%r0)
 
        vlgvg   %r0, %v0, -1
        vlgvg   %r0, %v0, 4096
-       vlgvg   %r0, %v0, 0(%r0)
 
 #CHECK: error: invalid operand
 #CHECK: vlgvh  %r0, %v0, -1
 #CHECK: error: invalid operand
 #CHECK: vlgvh  %r0, %v0, 4096
-#CHECK: error: %r0 used in an address
-#CHECK: vlgvh  %r0, %v0, 0(%r0)
 
        vlgvh   %r0, %v0, -1
        vlgvh   %r0, %v0, 4096
-       vlgvh   %r0, %v0, 0(%r0)
 
 #CHECK: error: instruction requires: vector-packed-decimal
 #CHECK: vlip   %v0, 0, 0
@@ -1942,12 +1915,9 @@
 #CHECK: vll    %v0, %r0, -1
 #CHECK: error: invalid operand
 #CHECK: vll    %v0, %r0, 4096
-#CHECK: error: %r0 used in an address
-#CHECK: vll    %v0, %r0, 0(%r0)
 
        vll     %v0, %r0, -1
        vll     %v0, %r0, 4096
-       vll     %v0, %r0, 0(%r0)
 
 #CHECK: error: invalid operand
 #CHECK: vllez  %v0, 0, -1
@@ -2108,58 +2078,43 @@
 #CHECK: vlvg   %v0, %r0, -1, 0
 #CHECK: error: invalid operand
 #CHECK: vlvg   %v0, %r0, 4096, 0
-#CHECK: error: %r0 used in an address
-#CHECK: vlvg   %v0, %r0, 0(%r0), 0
 
        vlvg    %v0, %r0, 0, -1
        vlvg    %v0, %r0, 0, 16
        vlvg    %v0, %r0, -1, 0
        vlvg    %v0, %r0, 4096, 0
-       vlvg    %v0, %r0, 0(%r0), 0
 
 #CHECK: error: invalid operand
 #CHECK: vlvgb  %v0, %r0, -1
 #CHECK: error: invalid operand
 #CHECK: vlvgb  %v0, %r0, 4096
-#CHECK: error: %r0 used in an address
-#CHECK: vlvgb  %v0, %r0, 0(%r0)
 
        vlvgb   %v0, %r0, -1
        vlvgb   %v0, %r0, 4096
-       vlvgb   %v0, %r0, 0(%r0)
 
 #CHECK: error: invalid operand
 #CHECK: vlvgf  %v0, %r0, -1
 #CHECK: error: invalid operand
 #CHECK: vlvgf  %v0, %r0, 4096
-#CHECK: error: %r0 used in an address
-#CHECK: vlvgf  %v0, %r0, 0(%r0)
 
        vlvgf   %v0, %r0, -1
        vlvgf   %v0, %r0, 4096
-       vlvgf   %v0, %r0, 0(%r0)
 
 #CHECK: error: invalid operand
 #CHECK: vlvgg  %v0, %r0, -1
 #CHECK: error: invalid operand
 #CHECK: vlvgg  %v0, %r0, 4096
-#CHECK: error: %r0 used in an address
-#CHECK: vlvgg  %v0, %r0, 0(%r0)
 
        vlvgg   %v0, %r0, -1
        vlvgg   %v0, %r0, 4096
-       vlvgg   %v0, %r0, 0(%r0)
 
 #CHECK: error: invalid operand
 #CHECK: vlvgh  %v0, %r0, -1
 #CHECK: error: invalid operand
 #CHECK: vlvgh  %v0, %r0, 4096
-#CHECK: error: %r0 used in an address
-#CHECK: vlvgh  %v0, %r0, 0(%r0)
 
        vlvgh   %v0, %r0, -1
        vlvgh   %v0, %r0, 4096
-       vlvgh   %v0, %r0, 0(%r0)
 
 #CHECK: error: instruction requires: vector-packed-decimal
 #CHECK: vmp    %v0, %v0, %v0, 0, 0
@@ -2475,12 +2430,9 @@
 #CHECK: vstl   %v0, %r0, -1
 #CHECK: error: invalid operand
 #CHECK: vstl   %v0, %r0, 4096
-#CHECK: error: %r0 used in an address
-#CHECK: vstl   %v0, %r0, 0(%r0)
 
        vstl    %v0, %r0, -1
        vstl    %v0, %r0, 4096
-       vstl    %v0, %r0, 0(%r0)
 
 #CHECK: error: invalid operand
 #CHECK: vstm   %v0, %v0, -1

diff --git a/llvm/test/MC/SystemZ/insn-bad-z14.s b/llvm/test/MC/SystemZ/insn-bad-z14.s
index f3c8414..568717a 100644 (file)
--- a/llvm/test/MC/SystemZ/insn-bad-z14.s
+++ b/llvm/test/MC/SystemZ/insn-bad-z14.s
@@ -634,25 +634,19 @@
 #CHECK: vlrl   %v0, -1, 0
 #CHECK: error: invalid operand
 #CHECK: vlrl   %v0, 4096, 0
-#CHECK: error: %r0 used in an address
-#CHECK: vlrl   %v0, 0(%r0), 0
 
        vlrl    %v0, 0, -1
        vlrl    %v0, 0, 256
        vlrl    %v0, -1, 0
        vlrl    %v0, 4096, 0
-       vlrl    %v0, 0(%r0), 0
 
 #CHECK: error: invalid operand
 #CHECK: vlrlr  %v0, %r0, -1
 #CHECK: error: invalid operand
 #CHECK: vlrlr  %v0, %r0, 4096
-#CHECK: error: %r0 used in an address
-#CHECK: vlrlr  %v0, %r0, 0(%r0)
 
        vlrlr   %v0, %r0, -1
        vlrlr   %v0, %r0, 4096
-       vlrlr   %v0, %r0, 0(%r0)
 
 #CHECK: error: invalid operand
 #CHECK: vmp    %v0, %v0, %v0, 0, -1
@@ -712,14 +706,11 @@
 #CHECK: vpkz   %v0, -1, 0
 #CHECK: error: invalid operand
 #CHECK: vpkz   %v0, 4096, 0
-#CHECK: error: %r0 used in an address
-#CHECK: vpkz   %v0, 0(%r0), 0
 
        vpkz    %v0, 0, -1
        vpkz    %v0, 0, 256
        vpkz    %v0, -1, 0
        vpkz    %v0, 4096, 0
-       vpkz    %v0, 0(%r0), 0
 
 #CHECK: error: invalid operand
 #CHECK: vpsop  %v0, %v0, 0, 0, -1
@@ -863,25 +854,19 @@
 #CHECK: vstrl  %v0, -1, 0
 #CHECK: error: invalid operand
 #CHECK: vstrl  %v0, 4096, 0
-#CHECK: error: %r0 used in an address
-#CHECK: vstrl  %v0, 0(%r0), 0
 
        vstrl   %v0, 0, -1
        vstrl   %v0, 0, 256
        vstrl   %v0, -1, 0
        vstrl   %v0, 4096, 0
-       vstrl   %v0, 0(%r0), 0
 
 #CHECK: error: invalid operand
 #CHECK: vstrlr %v0, %r0, -1
 #CHECK: error: invalid operand
 #CHECK: vstrlr %v0, %r0, 4096
-#CHECK: error: %r0 used in an address
-#CHECK: vstrlr %v0, %r0, 0(%r0)
 
        vstrlr  %v0, %r0, -1
        vstrlr  %v0, %r0, 4096
-       vstrlr  %v0, %r0, 0(%r0)
 
 #CHECK: error: instruction requires: vector-enhancements-2
 #CHECK: vstrs  %v0, %v0, %v0, %v0, 0
@@ -914,14 +899,11 @@
 #CHECK: vupkz  %v0, -1, 0
 #CHECK: error: invalid operand
 #CHECK: vupkz  %v0, 4096, 0
-#CHECK: error: %r0 used in an address
-#CHECK: vupkz  %v0, 0(%r0), 0
 
        vupkz   %v0, 0, -1
        vupkz   %v0, 0, 256
        vupkz   %v0, -1, 0
        vupkz   %v0, 4096, 0
-       vupkz   %v0, 0(%r0), 0
 
 #CHECK: error: instruction requires: vector-enhancements-2
 #CHECK: wcefb  %v0, %v0, 0, 0

diff --git a/llvm/test/MC/SystemZ/insn-bad-z196.s b/llvm/test/MC/SystemZ/insn-bad-z196.s
index 3305952..04e53c3 100644 (file)
--- a/llvm/test/MC/SystemZ/insn-bad-z196.s
+++ b/llvm/test/MC/SystemZ/insn-bad-z196.s
@@ -1260,56 +1260,44 @@
 #CHECK: slak   %r0,%r0,-524289
 #CHECK: error: invalid operand
 #CHECK: slak   %r0,%r0,524288
-#CHECK: error: %r0 used in an address
-#CHECK: slak   %r0,%r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: slak   %r0,%r0,0(%r1,%r2)
 
        slak    %r0,%r0,-524289
        slak    %r0,%r0,524288
-       slak    %r0,%r0,0(%r0)
        slak    %r0,%r0,0(%r1,%r2)
 
 #CHECK: error: invalid operand
 #CHECK: sllk   %r0,%r0,-524289
 #CHECK: error: invalid operand
 #CHECK: sllk   %r0,%r0,524288
-#CHECK: error: %r0 used in an address
-#CHECK: sllk   %r0,%r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: sllk   %r0,%r0,0(%r1,%r2)
 
        sllk    %r0,%r0,-524289
        sllk    %r0,%r0,524288
-       sllk    %r0,%r0,0(%r0)
        sllk    %r0,%r0,0(%r1,%r2)
 
 #CHECK: error: invalid operand
 #CHECK: srak   %r0,%r0,-524289
 #CHECK: error: invalid operand
 #CHECK: srak   %r0,%r0,524288
-#CHECK: error: %r0 used in an address
-#CHECK: srak   %r0,%r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: srak   %r0,%r0,0(%r1,%r2)
 
        srak    %r0,%r0,-524289
        srak    %r0,%r0,524288
-       srak    %r0,%r0,0(%r0)
        srak    %r0,%r0,0(%r1,%r2)
 
 #CHECK: error: invalid operand
 #CHECK: srlk   %r0,%r0,-524289
 #CHECK: error: invalid operand
 #CHECK: srlk   %r0,%r0,524288
-#CHECK: error: %r0 used in an address
-#CHECK: srlk   %r0,%r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: srlk   %r0,%r0,0(%r1,%r2)
 
        srlk    %r0,%r0,-524289
        srlk    %r0,%r0,524288
-       srlk    %r0,%r0,0(%r0)
        srlk    %r0,%r0,0(%r1,%r2)
 
 #CHECK: error: invalid operand

diff --git a/llvm/test/MC/SystemZ/insn-bad-zEC12.s b/llvm/test/MC/SystemZ/insn-bad-zEC12.s
index 552180a..b5cc6eb 100644 (file)
--- a/llvm/test/MC/SystemZ/insn-bad-zEC12.s
+++ b/llvm/test/MC/SystemZ/insn-bad-zEC12.s
@@ -83,8 +83,6 @@
 #CHECK: cdzt   %f0, -1(1,%r1), 0
 #CHECK: error: invalid operand
 #CHECK: cdzt   %f0, 4096(1,%r1), 0
-#CHECK: error: %r0 used in an address
-#CHECK: cdzt   %f0, 0(1,%r0), 0
 #CHECK: error: invalid use of indexed addressing
 #CHECK: cdzt   %f0, 0(%r1,%r2), 0
 #CHECK: error: unknown token in expression
@@ -98,7 +96,6 @@
        cdzt    %f0, 0(257,%r1), 0
        cdzt    %f0, -1(1,%r1), 0
        cdzt    %f0, 4096(1,%r1), 0
-       cdzt    %f0, 0(1,%r0), 0
        cdzt    %f0, 0(%r1,%r2), 0
        cdzt    %f0, 0(-), 0
 
@@ -197,8 +194,6 @@
 #CHECK: cxzt   %f0, -1(1,%r1), 0
 #CHECK: error: invalid operand
 #CHECK: cxzt   %f0, 4096(1,%r1), 0
-#CHECK: error: %r0 used in an address
-#CHECK: cxzt   %f0, 0(1,%r0), 0
 #CHECK: error: invalid use of indexed addressing
 #CHECK: cxzt   %f0, 0(%r1,%r2), 0
 #CHECK: error: unknown token in expression
@@ -214,7 +209,6 @@
        cxzt    %f0, 0(257,%r1), 0
        cxzt    %f0, -1(1,%r1), 0
        cxzt    %f0, 4096(1,%r1), 0
-       cxzt    %f0, 0(1,%r0), 0
        cxzt    %f0, 0(%r1,%r2), 0
        cxzt    %f0, 0(-), 0
        cxzt    %f15, 0(1), 0
@@ -235,8 +229,6 @@
 #CHECK: czdt   %f0, -1(1,%r1), 0
 #CHECK: error: invalid operand
 #CHECK: czdt   %f0, 4096(1,%r1), 0
-#CHECK: error: %r0 used in an address
-#CHECK: czdt   %f0, 0(1,%r0), 0
 #CHECK: error: invalid use of indexed addressing
 #CHECK: czdt   %f0, 0(%r1,%r2), 0
 #CHECK: error: unknown token in expression
@@ -250,7 +242,6 @@
        czdt    %f0, 0(257,%r1), 0
        czdt    %f0, -1(1,%r1), 0
        czdt    %f0, 4096(1,%r1), 0
-       czdt    %f0, 0(1,%r0), 0
        czdt    %f0, 0(%r1,%r2), 0
        czdt    %f0, 0(-), 0
 
@@ -270,8 +261,6 @@
 #CHECK: czxt   %f0, -1(1,%r1), 0
 #CHECK: error: invalid operand
 #CHECK: czxt   %f0, 4096(1,%r1), 0
-#CHECK: error: %r0 used in an address
-#CHECK: czxt   %f0, 0(1,%r0), 0
 #CHECK: error: invalid use of indexed addressing
 #CHECK: czxt   %f0, 0(%r1,%r2), 0
 #CHECK: error: unknown token in expression
@@ -287,7 +276,6 @@
        czxt    %f0, 0(257,%r1), 0
        czxt    %f0, -1(1,%r1), 0
        czxt    %f0, 4096(1,%r1), 0
-       czxt    %f0, 0(1,%r0), 0
        czxt    %f0, 0(%r1,%r2), 0
        czxt    %f0, 0(-), 0
        czxt    %f15, 0(1), 0

diff --git a/llvm/test/MC/SystemZ/insn-bad.s b/llvm/test/MC/SystemZ/insn-bad.s
index 7dfbba7..c330fa4 100644 (file)
--- a/llvm/test/MC/SystemZ/insn-bad.s
+++ b/llvm/test/MC/SystemZ/insn-bad.s
@@ -328,10 +328,6 @@
 #CHECK: ap     0(1,%r1), -1(1,%r1)
 #CHECK: error: invalid operand
 #CHECK: ap     0(1,%r1), 4096(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: ap     0(1,%r0), 0(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: ap     0(1,%r1), 0(1,%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: ap     0(%r1,%r2), 0(1,%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -351,8 +347,6 @@
        ap      4096(1,%r1), 0(1,%r1)
        ap      0(1,%r1), -1(1,%r1)
        ap      0(1,%r1), 4096(1,%r1)
-       ap      0(1,%r0), 0(1,%r1)
-       ap      0(1,%r1), 0(1,%r0)
        ap      0(%r1,%r2), 0(1,%r1)
        ap      0(1,%r2), 0(%r1,%r2)
        ap      0(-), 0(1)
@@ -1363,10 +1357,6 @@
 #CHECK: clc    0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: clc    0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: clc    0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: clc    0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: clc    0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -1383,8 +1373,6 @@
        clc     4096(1,%r1), 0(%r1)
        clc     0(1,%r1), -1(%r1)
        clc     0(1,%r1), 4096(%r1)
-       clc     0(1,%r0), 0(%r1)
-       clc     0(1,%r1), 0(%r0)
        clc     0(%r1,%r2), 0(%r1)
        clc     0(1,%r2), 0(%r1,%r2)
        clc     0(-), 0
@@ -1904,10 +1892,6 @@
 #CHECK: cp     0(1,%r1), -1(1,%r1)
 #CHECK: error: invalid operand
 #CHECK: cp     0(1,%r1), 4096(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: cp     0(1,%r0), 0(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: cp     0(1,%r1), 0(1,%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: cp     0(%r1,%r2), 0(1,%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -1927,8 +1911,6 @@
        cp      4096(1,%r1), 0(1,%r1)
        cp      0(1,%r1), -1(1,%r1)
        cp      0(1,%r1), 4096(1,%r1)
-       cp      0(1,%r0), 0(1,%r1)
-       cp      0(1,%r1), 0(1,%r0)
        cp      0(%r1,%r2), 0(1,%r1)
        cp      0(1,%r2), 0(%r1,%r2)
        cp      0(-), 0(1)
@@ -2472,10 +2454,6 @@
 #CHECK: dp     0(1,%r1), -1(1,%r1)
 #CHECK: error: invalid operand
 #CHECK: dp     0(1,%r1), 4096(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: dp     0(1,%r0), 0(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: dp     0(1,%r1), 0(1,%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: dp     0(%r1,%r2), 0(1,%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -2495,8 +2473,6 @@
        dp      4096(1,%r1), 0(1,%r1)
        dp      0(1,%r1), -1(1,%r1)
        dp      0(1,%r1), 4096(1,%r1)
-       dp      0(1,%r0), 0(1,%r1)
-       dp      0(1,%r1), 0(1,%r0)
        dp      0(%r1,%r2), 0(1,%r1)
        dp      0(1,%r2), 0(%r1,%r2)
        dp      0(-), 0(1)
@@ -2611,10 +2587,6 @@
 #CHECK: ed     0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: ed     0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: ed     0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: ed     0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: ed     0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -2631,8 +2603,6 @@
        ed      4096(1,%r1), 0(%r1)
        ed      0(1,%r1), -1(%r1)
        ed      0(1,%r1), 4096(%r1)
-       ed      0(1,%r0), 0(%r1)
-       ed      0(1,%r1), 0(%r0)
        ed      0(%r1,%r2), 0(%r1)
        ed      0(1,%r2), 0(%r1,%r2)
        ed      0(-), 0
@@ -2655,10 +2625,6 @@
 #CHECK: edmk   0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: edmk   0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: edmk   0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: edmk   0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: edmk   0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -2675,8 +2641,6 @@
        edmk    4096(1,%r1), 0(%r1)
        edmk    0(1,%r1), -1(%r1)
        edmk    0(1,%r1), 4096(%r1)
-       edmk    0(1,%r0), 0(%r1)
-       edmk    0(1,%r1), 0(%r0)
        edmk    0(%r1,%r2), 0(%r1)
        edmk    0(1,%r2), 0(%r1,%r2)
        edmk    0(-), 0
@@ -4281,10 +4245,6 @@
 #CHECK: mp     0(1,%r1), -1(1,%r1)
 #CHECK: error: invalid operand
 #CHECK: mp     0(1,%r1), 4096(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: mp     0(1,%r0), 0(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: mp     0(1,%r1), 0(1,%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: mp     0(%r1,%r2), 0(1,%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -4304,8 +4264,6 @@
        mp      4096(1,%r1), 0(1,%r1)
        mp      0(1,%r1), -1(1,%r1)
        mp      0(1,%r1), 4096(1,%r1)
-       mp      0(1,%r0), 0(1,%r1)
-       mp      0(1,%r1), 0(1,%r0)
        mp      0(%r1,%r2), 0(1,%r1)
        mp      0(1,%r2), 0(%r1,%r2)
        mp      0(-), 0(1)
@@ -4429,10 +4387,6 @@
 #CHECK: mvc    0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: mvc    0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: mvc    0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: mvc    0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: mvc    0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -4449,8 +4403,6 @@
        mvc     4096(1,%r1), 0(%r1)
        mvc     0(1,%r1), -1(%r1)
        mvc     0(1,%r1), 4096(%r1)
-       mvc     0(1,%r0), 0(%r1)
-       mvc     0(1,%r1), 0(%r0)
        mvc     0(%r1,%r2), 0(%r1)
        mvc     0(1,%r2), 0(%r1,%r2)
        mvc     0(-), 0
@@ -4490,10 +4442,6 @@
 #CHECK: mvcin  0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: mvcin  0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: mvcin  0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: mvcin  0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: mvcin  0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -4510,8 +4458,6 @@
        mvcin   4096(1,%r1), 0(%r1)
        mvcin   0(1,%r1), -1(%r1)
        mvcin   0(1,%r1), 4096(%r1)
-       mvcin   0(1,%r0), 0(%r1)
-       mvcin   0(1,%r1), 0(%r0)
        mvcin   0(%r1,%r2), 0(%r1)
        mvcin   0(1,%r2), 0(%r1,%r2)
        mvcin   0(-), 0
@@ -4526,10 +4472,6 @@
 #CHECK: mvck   0(%r1,%r1), -1(%r1), %r3
 #CHECK: error: invalid operand
 #CHECK: mvck   0(%r1,%r1), 4096(%r1), %r3
-#CHECK: error: %r0 used in an address
-#CHECK: mvck   0(%r1,%r0), 0(%r1), %r3
-#CHECK: error: %r0 used in an address
-#CHECK: mvck   0(%r1,%r1), 0(%r0), %r3
 #CHECK: error: invalid use of indexed addressing
 #CHECK: mvck   0(%r1,%r2), 0(%r1,%r2), %r3
 #CHECK: error: unknown token in expression
@@ -4540,8 +4482,6 @@
        mvck    4096(%r1,%r1), 0(%r1), %r3
        mvck    0(%r1,%r1), -1(%r1), %r3
        mvck    0(%r1,%r1), 4096(%r1), %r3
-       mvck    0(%r1,%r0), 0(%r1), %r3
-       mvck    0(%r1,%r1), 0(%r0), %r3
        mvck    0(%r1,%r2), 0(%r1,%r2), %r3
        mvck    0(-), 0, %r3
 
@@ -4608,10 +4548,6 @@
 #CHECK: mvcp   0(%r1,%r1), -1(%r1), %r3
 #CHECK: error: invalid operand
 #CHECK: mvcp   0(%r1,%r1), 4096(%r1), %r3
-#CHECK: error: %r0 used in an address
-#CHECK: mvcp   0(%r1,%r0), 0(%r1), %r3
-#CHECK: error: %r0 used in an address
-#CHECK: mvcp   0(%r1,%r1), 0(%r0), %r3
 #CHECK: error: invalid use of indexed addressing
 #CHECK: mvcp   0(%r1,%r2), 0(%r1,%r2), %r3
 #CHECK: error: unknown token in expression
@@ -4622,8 +4558,6 @@
        mvcp    4096(%r1,%r1), 0(%r1), %r3
        mvcp    0(%r1,%r1), -1(%r1), %r3
        mvcp    0(%r1,%r1), 4096(%r1), %r3
-       mvcp    0(%r1,%r0), 0(%r1), %r3
-       mvcp    0(%r1,%r1), 0(%r0), %r3
        mvcp    0(%r1,%r2), 0(%r1,%r2), %r3
        mvcp    0(-), 0, %r3
 
@@ -4637,10 +4571,6 @@
 #CHECK: mvcs   0(%r1,%r1), -1(%r1), %r3
 #CHECK: error: invalid operand
 #CHECK: mvcs   0(%r1,%r1), 4096(%r1), %r3
-#CHECK: error: %r0 used in an address
-#CHECK: mvcs   0(%r1,%r0), 0(%r1), %r3
-#CHECK: error: %r0 used in an address
-#CHECK: mvcs   0(%r1,%r1), 0(%r0), %r3
 #CHECK: error: invalid use of indexed addressing
 #CHECK: mvcs   0(%r1,%r2), 0(%r1,%r2), %r3
 #CHECK: error: unknown token in expression
@@ -4651,8 +4581,6 @@
        mvcs    4096(%r1,%r1), 0(%r1), %r3
        mvcs    0(%r1,%r1), -1(%r1), %r3
        mvcs    0(%r1,%r1), 4096(%r1), %r3
-       mvcs    0(%r1,%r0), 0(%r1), %r3
-       mvcs    0(%r1,%r1), 0(%r0), %r3
        mvcs    0(%r1,%r2), 0(%r1,%r2), %r3
        mvcs    0(-), 0, %r3
 
@@ -4776,10 +4704,6 @@
 #CHECK: mvn    0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: mvn    0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: mvn    0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: mvn    0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: mvn    0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -4796,8 +4720,6 @@
        mvn     4096(1,%r1), 0(%r1)
        mvn     0(1,%r1), -1(%r1)
        mvn     0(1,%r1), 4096(%r1)
-       mvn     0(1,%r0), 0(%r1)
-       mvn     0(1,%r1), 0(%r0)
        mvn     0(%r1,%r2), 0(%r1)
        mvn     0(1,%r2), 0(%r1,%r2)
        mvn     0(-), 0
@@ -4826,10 +4748,6 @@
 #CHECK: mvo    0(1,%r1), -1(1,%r1)
 #CHECK: error: invalid operand
 #CHECK: mvo    0(1,%r1), 4096(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: mvo    0(1,%r0), 0(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: mvo    0(1,%r1), 0(1,%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: mvo    0(%r1,%r2), 0(1,%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -4849,8 +4767,6 @@
        mvo     4096(1,%r1), 0(1,%r1)
        mvo     0(1,%r1), -1(1,%r1)
        mvo     0(1,%r1), 4096(1,%r1)
-       mvo     0(1,%r0), 0(1,%r1)
-       mvo     0(1,%r1), 0(1,%r0)
        mvo     0(%r1,%r2), 0(1,%r1)
        mvo     0(1,%r2), 0(%r1,%r2)
        mvo     0(-), 0(1)
@@ -4873,10 +4789,6 @@
 #CHECK: mvz    0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: mvz    0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: mvz    0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: mvz    0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: mvz    0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -4893,8 +4805,6 @@
        mvz     4096(1,%r1), 0(%r1)
        mvz     0(1,%r1), -1(%r1)
        mvz     0(1,%r1), 4096(%r1)
-       mvz     0(1,%r0), 0(%r1)
-       mvz     0(1,%r1), 0(%r0)
        mvz     0(%r1,%r2), 0(%r1)
        mvz     0(1,%r2), 0(%r1,%r2)
        mvz     0(-), 0
@@ -5021,10 +4931,6 @@
 #CHECK: nc     0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: nc     0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: nc     0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: nc     0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: nc     0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -5041,8 +4947,6 @@
        nc      4096(1,%r1), 0(%r1)
        nc      0(1,%r1), -1(%r1)
        nc      0(1,%r1), 4096(%r1)
-       nc      0(1,%r0), 0(%r1)
-       nc      0(1,%r1), 0(%r0)
        nc      0(%r1,%r2), 0(%r1)
        nc      0(1,%r2), 0(%r1,%r2)
        nc      0(-), 0
@@ -5181,10 +5085,6 @@
 #CHECK: oc     0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: oc     0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: oc     0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: oc     0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: oc     0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -5201,8 +5101,6 @@
        oc      4096(1,%r1), 0(%r1)
        oc      0(1,%r1), -1(%r1)
        oc      0(1,%r1), 4096(%r1)
-       oc      0(1,%r0), 0(%r1)
-       oc      0(1,%r1), 0(%r0)
        oc      0(%r1,%r2), 0(%r1)
        oc      0(1,%r2), 0(%r1,%r2)
        oc      0(-), 0
@@ -5339,10 +5237,6 @@
 #CHECK: pack   0(1,%r1), -1(1,%r1)
 #CHECK: error: invalid operand
 #CHECK: pack   0(1,%r1), 4096(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: pack   0(1,%r0), 0(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: pack   0(1,%r1), 0(1,%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: pack   0(%r1,%r2), 0(1,%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -5362,8 +5256,6 @@
        pack    4096(1,%r1), 0(1,%r1)
        pack    0(1,%r1), -1(1,%r1)
        pack    0(1,%r1), 4096(1,%r1)
-       pack    0(1,%r0), 0(1,%r1)
-       pack    0(1,%r1), 0(1,%r0)
        pack    0(%r1,%r2), 0(1,%r1)
        pack    0(1,%r2), 0(%r1,%r2)
        pack    0(-), 0(1)
@@ -5441,10 +5333,6 @@
 #CHECK: pka    0(%r1), -1(1,%r1)
 #CHECK: error: invalid operand
 #CHECK: pka    0(%r1), 4096(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: pka    0(%r0), 0(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: pka    0(%r1), 0(1,%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: pka    0(%r1,%r2), 0(1,%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -5461,8 +5349,6 @@
        pka     4096(%r1), 0(1,%r1)
        pka     0(%r1), -1(1,%r1)
        pka     0(%r1), 4096(1,%r1)
-       pka     0(%r0), 0(1,%r1)
-       pka     0(%r1), 0(1,%r0)
        pka     0(%r1,%r2), 0(1,%r1)
        pka     0(%r2), 0(%r1,%r2)
        pka     0, 0(-)
@@ -5485,10 +5371,6 @@
 #CHECK: pku    0(%r1), -1(1,%r1)
 #CHECK: error: invalid operand
 #CHECK: pku    0(%r1), 4096(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: pku    0(%r0), 0(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: pku    0(%r1), 0(1,%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: pku    0(%r1,%r2), 0(1,%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -5618,28 +5500,22 @@
 #CHECK: rll    %r0,%r0,-524289
 #CHECK: error: invalid operand
 #CHECK: rll    %r0,%r0,524288
-#CHECK: error: %r0 used in an address
-#CHECK: rll    %r0,%r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: rll    %r0,%r0,0(%r1,%r2)
 
        rll     %r0,%r0,-524289
        rll     %r0,%r0,524288
-       rll     %r0,%r0,0(%r0)
        rll     %r0,%r0,0(%r1,%r2)
 
 #CHECK: error: invalid operand
 #CHECK: rllg   %r0,%r0,-524289
 #CHECK: error: invalid operand
 #CHECK: rllg   %r0,%r0,524288
-#CHECK: error: %r0 used in an address
-#CHECK: rllg   %r0,%r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: rllg   %r0,%r0,0(%r1,%r2)
 
        rllg    %r0,%r0,-524289
        rllg    %r0,%r0,524288
-       rllg    %r0,%r0,0(%r0)
        rllg    %r0,%r0,0(%r1,%r2)
 
 #CHECK: error: invalid operand
@@ -5924,28 +5800,22 @@
 #CHECK: sla    %r0,-1
 #CHECK: error: invalid operand
 #CHECK: sla    %r0,4096
-#CHECK: error: %r0 used in an address
-#CHECK: sla    %r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: sla    %r0,0(%r1,%r2)
 
        sla     %r0,-1
        sla     %r0,4096
-       sla     %r0,0(%r0)
        sla     %r0,0(%r1,%r2)
 
 #CHECK: error: invalid operand
 #CHECK: slag   %r0,%r0,-524289
 #CHECK: error: invalid operand
 #CHECK: slag   %r0,%r0,524288
-#CHECK: error: %r0 used in an address
-#CHECK: slag   %r0,%r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: slag   %r0,%r0,0(%r1,%r2)
 
        slag    %r0,%r0,-524289
        slag    %r0,%r0,524288
-       slag    %r0,%r0,0(%r0)
        slag    %r0,%r0,0(%r1,%r2)
 
 #CHECK: error: instruction requires: distinct-ops
@@ -5975,15 +5845,12 @@
 #CHECK: slda   %r0,-1
 #CHECK: error: invalid operand
 #CHECK: slda   %r0,4096
-#CHECK: error: %r0 used in an address
-#CHECK: slda   %r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: slda   %r0,0(%r1,%r2)
 
        slda    %r1,0
        slda    %r0,-1
        slda    %r0,4096
-       slda    %r0,0(%r0)
        slda    %r0,0(%r1,%r2)
 
 #CHECK: error: invalid register pair
@@ -5992,15 +5859,12 @@
 #CHECK: sldl   %r0,-1
 #CHECK: error: invalid operand
 #CHECK: sldl   %r0,4096
-#CHECK: error: %r0 used in an address
-#CHECK: sldl   %r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: sldl   %r0,0(%r1,%r2)
 
        sldl    %r1,0
        sldl    %r0,-1
        sldl    %r0,4096
-       sldl    %r0,0(%r0)
        sldl    %r0,0(%r1,%r2)
 
 #CHECK: error: invalid operand
@@ -6062,28 +5926,22 @@
 #CHECK: sll    %r0,-1
 #CHECK: error: invalid operand
 #CHECK: sll    %r0,4096
-#CHECK: error: %r0 used in an address
-#CHECK: sll    %r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: sll    %r0,0(%r1,%r2)
 
        sll     %r0,-1
        sll     %r0,4096
-       sll     %r0,0(%r0)
        sll     %r0,0(%r1,%r2)
 
 #CHECK: error: invalid operand
 #CHECK: sllg   %r0,%r0,-524289
 #CHECK: error: invalid operand
 #CHECK: sllg   %r0,%r0,524288
-#CHECK: error: %r0 used in an address
-#CHECK: sllg   %r0,%r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: sllg   %r0,%r0,0(%r1,%r2)
 
        sllg    %r0,%r0,-524289
        sllg    %r0,%r0,524288
-       sllg    %r0,%r0,0(%r0)
        sllg    %r0,%r0,0(%r1,%r2)
 
 #CHECK: error: instruction requires: distinct-ops
@@ -6142,10 +6000,6 @@
 #CHECK: sp     0(1,%r1), -1(1,%r1)
 #CHECK: error: invalid operand
 #CHECK: sp     0(1,%r1), 4096(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: sp     0(1,%r0), 0(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: sp     0(1,%r1), 0(1,%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: sp     0(%r1,%r2), 0(1,%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -6165,8 +6019,6 @@
        sp      4096(1,%r1), 0(1,%r1)
        sp      0(1,%r1), -1(1,%r1)
        sp      0(1,%r1), 4096(1,%r1)
-       sp      0(1,%r0), 0(1,%r1)
-       sp      0(1,%r1), 0(1,%r0)
        sp      0(%r1,%r2), 0(1,%r1)
        sp      0(1,%r2), 0(%r1,%r2)
        sp      0(-), 0(1)
@@ -6256,8 +6108,6 @@
 #CHECK: sra    %r0,-1
 #CHECK: error: invalid operand
 #CHECK: sra    %r0,4096
-#CHECK: error: %r0 used in an address
-#CHECK: sra    %r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: sra    %r0,0(%r1,%r2)
 
@@ -6270,8 +6120,6 @@
 #CHECK: srag   %r0,%r0,-524289
 #CHECK: error: invalid operand
 #CHECK: srag   %r0,%r0,524288
-#CHECK: error: %r0 used in an address
-#CHECK: srag   %r0,%r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: srag   %r0,%r0,0(%r1,%r2)
 
@@ -6291,15 +6139,12 @@
 #CHECK: srda   %r0,-1
 #CHECK: error: invalid operand
 #CHECK: srda   %r0,4096
-#CHECK: error: %r0 used in an address
-#CHECK: srda   %r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: srda   %r0,0(%r1,%r2)
 
        srda    %r1,0
        srda    %r0,-1
        srda    %r0,4096
-       srda    %r0,0(%r0)
        srda    %r0,0(%r1,%r2)
 
 #CHECK: error: invalid register pair
@@ -6308,15 +6153,12 @@
 #CHECK: srdl   %r0,-1
 #CHECK: error: invalid operand
 #CHECK: srdl   %r0,4096
-#CHECK: error: %r0 used in an address
-#CHECK: srdl   %r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: srdl   %r0,0(%r1,%r2)
 
        srdl    %r1,0
        srdl    %r0,-1
        srdl    %r0,4096
-       srdl    %r0,0(%r0)
        srdl    %r0,0(%r1,%r2)
 
 #CHECK: error: invalid operand
@@ -6336,28 +6178,22 @@
 #CHECK: srl    %r0,-1
 #CHECK: error: invalid operand
 #CHECK: srl    %r0,4096
-#CHECK: error: %r0 used in an address
-#CHECK: srl    %r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: srl    %r0,0(%r1,%r2)
 
        srl     %r0,-1
        srl     %r0,4096
-       srl     %r0,0(%r0)
        srl     %r0,0(%r1,%r2)
 
 #CHECK: error: invalid operand
 #CHECK: srlg   %r0,%r0,-524289
 #CHECK: error: invalid operand
 #CHECK: srlg   %r0,%r0,524288
-#CHECK: error: %r0 used in an address
-#CHECK: srlg   %r0,%r0,0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: srlg   %r0,%r0,0(%r1,%r2)
 
        srlg    %r0,%r0,-524289
        srlg    %r0,%r0,524288
-       srlg    %r0,%r0,0(%r0)
        srlg    %r0,%r0,0(%r1,%r2)
 
 #CHECK: error: instruction requires: distinct-ops
@@ -6410,10 +6246,6 @@
 #CHECK: srp    0(1,%r1), -1(%r1), 0
 #CHECK: error: invalid operand
 #CHECK: srp    0(1,%r1), 4096(%r1), 0
-#CHECK: error: %r0 used in an address
-#CHECK: srp    0(1,%r0), 0(%r1), 0
-#CHECK: error: %r0 used in an address
-#CHECK: srp    0(1,%r1), 0(%r0), 0
 #CHECK: error: invalid use of indexed addressing
 #CHECK: srp    0(%r1,%r2), 0(%r1), 0
 #CHECK: error: invalid use of indexed addressing
@@ -6434,8 +6266,6 @@
        srp     4096(1,%r1), 0(%r1), 0
        srp     0(1,%r1), -1(%r1), 0
        srp     0(1,%r1), 4096(%r1), 0
-       srp     0(1,%r0), 0(%r1), 0
-       srp     0(1,%r1), 0(%r0), 0
        srp     0(%r1,%r2), 0(%r1), 0
        srp     0(1,%r2), 0(%r1,%r2), 0
        srp     0(1), 0, -1
@@ -7242,8 +7072,6 @@
 #CHECK: tp     -1(1,%r1)
 #CHECK: error: invalid operand
 #CHECK: tp     4096(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: tp     0(1,%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: tp     0(%r1,%r2)
 #CHECK: error: unknown token in expression
@@ -7255,7 +7083,6 @@
        tp      0(17,%r1)
        tp      -1(1,%r1)
        tp      4096(1,%r1)
-       tp      0(1,%r0)
        tp      0(%r1,%r2)
        tp      0(-)
 
@@ -7305,10 +7132,6 @@
 #CHECK: tr     0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: tr     0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: tr     0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: tr     0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: tr     0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -7325,8 +7148,6 @@
        tr      4096(1,%r1), 0(%r1)
        tr      0(1,%r1), -1(%r1)
        tr      0(1,%r1), 4096(%r1)
-       tr      0(1,%r0), 0(%r1)
-       tr      0(1,%r1), 0(%r0)
        tr      0(%r1,%r2), 0(%r1)
        tr      0(1,%r2), 0(%r1,%r2)
        tr      0(-), 0
@@ -7409,10 +7230,6 @@
 #CHECK: trt    0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: trt    0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: trt    0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: trt    0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: trt    0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -7429,8 +7246,6 @@
        trt     4096(1,%r1), 0(%r1)
        trt     0(1,%r1), -1(%r1)
        trt     0(1,%r1), 4096(%r1)
-       trt     0(1,%r0), 0(%r1)
-       trt     0(1,%r1), 0(%r0)
        trt     0(%r1,%r2), 0(%r1)
        trt     0(1,%r2), 0(%r1,%r2)
        trt     0(-), 0
@@ -7475,10 +7290,6 @@
 #CHECK: trtr   0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: trtr   0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: trtr   0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: trtr   0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: trtr   0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -7495,8 +7306,6 @@
        trtr    4096(1,%r1), 0(%r1)
        trtr    0(1,%r1), -1(%r1)
        trtr    0(1,%r1), 4096(%r1)
-       trtr    0(1,%r0), 0(%r1)
-       trtr    0(1,%r1), 0(%r0)
        trtr    0(%r1,%r2), 0(%r1)
        trtr    0(1,%r2), 0(%r1,%r2)
        trtr    0(-), 0
@@ -7569,10 +7378,6 @@
 #CHECK: unpk   0(1,%r1), -1(1,%r1)
 #CHECK: error: invalid operand
 #CHECK: unpk   0(1,%r1), 4096(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: unpk   0(1,%r0), 0(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: unpk   0(1,%r1), 0(1,%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: unpk   0(%r1,%r2), 0(1,%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -7592,8 +7397,6 @@
        unpk    4096(1,%r1), 0(1,%r1)
        unpk    0(1,%r1), -1(1,%r1)
        unpk    0(1,%r1), 4096(1,%r1)
-       unpk    0(1,%r0), 0(1,%r1)
-       unpk    0(1,%r1), 0(1,%r0)
        unpk    0(%r1,%r2), 0(1,%r1)
        unpk    0(1,%r2), 0(%r1,%r2)
        unpk    0(-), 0(1)
@@ -7616,10 +7419,6 @@
 #CHECK: unpka  0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: unpka  0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: unpka  0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: unpka  0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: unpka  0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -7636,8 +7435,6 @@
        unpka   4096(1,%r1), 0(%r1)
        unpka   0(1,%r1), -1(%r1)
        unpka   0(1,%r1), 4096(%r1)
-       unpka   0(1,%r0), 0(%r1)
-       unpka   0(1,%r1), 0(%r0)
        unpka   0(%r1,%r2), 0(%r1)
        unpka   0(1,%r2), 0(%r1,%r2)
        unpka   0(-), 0
@@ -7660,10 +7457,6 @@
 #CHECK: unpku  0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: unpku  0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: unpku  0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: unpku  0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: unpku  0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -7680,8 +7473,6 @@
        unpku   4096(1,%r1), 0(%r1)
        unpku   0(1,%r1), -1(%r1)
        unpku   0(1,%r1), 4096(%r1)
-       unpku   0(1,%r0), 0(%r1)
-       unpku   0(1,%r1), 0(%r0)
        unpku   0(%r1,%r2), 0(%r1)
        unpku   0(1,%r2), 0(%r1,%r2)
        unpku   0(-), 0
@@ -7712,10 +7503,6 @@
 #CHECK: xc     0(1,%r1), -1(%r1)
 #CHECK: error: invalid operand
 #CHECK: xc     0(1,%r1), 4096(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: xc     0(1,%r0), 0(%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: xc     0(1,%r1), 0(%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: xc     0(%r1,%r2), 0(%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -7732,8 +7519,6 @@
        xc      4096(1,%r1), 0(%r1)
        xc      0(1,%r1), -1(%r1)
        xc      0(1,%r1), 4096(%r1)
-       xc      0(1,%r0), 0(%r1)
-       xc      0(1,%r1), 0(%r0)
        xc      0(%r1,%r2), 0(%r1)
        xc      0(1,%r2), 0(%r1,%r2)
        xc      0(-), 0
@@ -7838,10 +7623,6 @@
 #CHECK: zap    0(1,%r1), -1(1,%r1)
 #CHECK: error: invalid operand
 #CHECK: zap    0(1,%r1), 4096(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: zap    0(1,%r0), 0(1,%r1)
-#CHECK: error: %r0 used in an address
-#CHECK: zap    0(1,%r1), 0(1,%r0)
 #CHECK: error: invalid use of indexed addressing
 #CHECK: zap    0(%r1,%r2), 0(1,%r1)
 #CHECK: error: invalid use of indexed addressing
@@ -7861,8 +7642,6 @@
        zap     4096(1,%r1), 0(1,%r1)
        zap     0(1,%r1), -1(1,%r1)
        zap     0(1,%r1), 4096(1,%r1)
-       zap     0(1,%r0), 0(1,%r1)
-       zap     0(1,%r1), 0(1,%r0)
        zap     0(%r1,%r2), 0(1,%r1)
        zap     0(1,%r2), 0(%r1,%r2)
        zap     0(-), 0(1)

diff --git a/llvm/test/MC/SystemZ/insn-good.s b/llvm/test/MC/SystemZ/insn-good.s
index 5b93ef9..3c5b34a 100644 (file)
--- a/llvm/test/MC/SystemZ/insn-good.s
+++ b/llvm/test/MC/SystemZ/insn-good.s
@@ -765,12 +765,12 @@
        bal     %r14, 4095(%r1,%r15)
        bal     %r15, 4095(%r15,%r1)
 
-#CHECK: balr   %r0, %r1                # encoding: [0x05,0x01]
+#CHECK: balr   %r0, %r0                # encoding: [0x05,0x00]
 #CHECK: balr   %r0, %r15               # encoding: [0x05,0x0f]
 #CHECK: balr   %r14, %r9               # encoding: [0x05,0xe9]
 #CHECK: balr   %r15, %r1               # encoding: [0x05,0xf1]
 
-       balr    %r0,%r1
+       balr    %r0,%r0
        balr    %r0,%r15
        balr    %r14,%r9
        balr    %r15,%r1
@@ -789,22 +789,22 @@
        bas     %r14, 4095(%r1,%r15)
        bas     %r15, 4095(%r15,%r1)
 
-#CHECK: basr   %r0, %r1                # encoding: [0x0d,0x01]
+#CHECK: basr   %r0, %r0                # encoding: [0x0d,0x00]
 #CHECK: basr   %r0, %r15               # encoding: [0x0d,0x0f]
 #CHECK: basr   %r14, %r9               # encoding: [0x0d,0xe9]
 #CHECK: basr   %r15, %r1               # encoding: [0x0d,0xf1]
 
-       basr    %r0,%r1
+       basr    %r0,%r0
        basr    %r0,%r15
        basr    %r14,%r9
        basr    %r15,%r1
 
-#CHECK: bassm  %r0, %r1                # encoding: [0x0c,0x01]
+#CHECK: bassm  %r0, %r0                # encoding: [0x0c,0x00]
 #CHECK: bassm  %r0, %r15               # encoding: [0x0c,0x0f]
 #CHECK: bassm  %r14, %r9               # encoding: [0x0c,0xe9]
 #CHECK: bassm  %r15, %r1               # encoding: [0x0c,0xf1]
 
-       bassm   %r0,%r1
+       bassm   %r0,%r0
        bassm   %r0,%r15
        bassm   %r14,%r9
        bassm   %r15,%r1
@@ -829,12 +829,12 @@
        bsg     %r15,%r0
        bsg     %r7,%r8
 
-#CHECK: bsm    %r0, %r1                # encoding: [0x0b,0x01]
+#CHECK: bsm    %r0, %r0                # encoding: [0x0b,0x00]
 #CHECK: bsm    %r0, %r15               # encoding: [0x0b,0x0f]
 #CHECK: bsm    %r14, %r9               # encoding: [0x0b,0xe9]
 #CHECK: bsm    %r15, %r1               # encoding: [0x0b,0xf1]
 
-       bsm     %r0,%r1
+       bsm     %r0,%r0
        bsm     %r0,%r15
        bsm     %r14,%r9
        bsm     %r15,%r1
@@ -960,95 +960,125 @@
        bcr     0, %r15
 
 #CHECK:        bcr     1, %r7                  # encoding: [0x07,0x17]
+#CHECK:        bor     %r0                     # encoding: [0x07,0x10]
 #CHECK:        bor     %r15                    # encoding: [0x07,0x1f]
 
        bcr     1, %r7
+       bor     %r0
        bor     %r15
 
 #CHECK:        bcr     2, %r7                  # encoding: [0x07,0x27]
+#CHECK:        bhr     %r0                     # encoding: [0x07,0x20]
 #CHECK:        bhr     %r15                    # encoding: [0x07,0x2f]
 
        bcr     2, %r7
+       bhr     %r0
        bhr     %r15
 
 #CHECK:        bcr     3, %r7                  # encoding: [0x07,0x37]
+#CHECK:        bnler   %r0                     # encoding: [0x07,0x30]
 #CHECK:        bnler   %r15                    # encoding: [0x07,0x3f]
 
        bcr     3, %r7
+       bnler   %r0
        bnler   %r15
 
 #CHECK:        bcr     4, %r7                  # encoding: [0x07,0x47]
+#CHECK:        blr     %r0                     # encoding: [0x07,0x40]
 #CHECK:        blr     %r15                    # encoding: [0x07,0x4f]
 
        bcr     4, %r7
+       blr     %r0
        blr     %r15
 
 #CHECK:        bcr     5, %r7                  # encoding: [0x07,0x57]
+#CHECK:        bnher   %r0                     # encoding: [0x07,0x50]
 #CHECK:        bnher   %r15                    # encoding: [0x07,0x5f]
 
        bcr     5, %r7
+       bnher   %r0
        bnher   %r15
 
 #CHECK:        bcr     6, %r7                  # encoding: [0x07,0x67]
+#CHECK:        blhr    %r0                     # encoding: [0x07,0x60]
 #CHECK:        blhr    %r15                    # encoding: [0x07,0x6f]
 
        bcr     6, %r7
+       blhr    %r0
        blhr    %r15
 
 #CHECK:        bcr     7, %r7                  # encoding: [0x07,0x77]
+#CHECK:        bner    %r0                     # encoding: [0x07,0x70]
 #CHECK:        bner    %r15                    # encoding: [0x07,0x7f]
 
        bcr     7, %r7
+       bner    %r0
        bner    %r15
 
 #CHECK:        bcr     8, %r7                  # encoding: [0x07,0x87]
+#CHECK:        ber     %r0                     # encoding: [0x07,0x80]
 #CHECK:        ber     %r15                    # encoding: [0x07,0x8f]
 
        bcr     8, %r7
+       ber     %r0
        ber     %r15
 
 #CHECK:        bcr     9, %r7                  # encoding: [0x07,0x97]
+#CHECK:        bnlhr   %r0                     # encoding: [0x07,0x90]
 #CHECK:        bnlhr   %r15                    # encoding: [0x07,0x9f]
 
        bcr     9, %r7
+       bnlhr   %r0
        bnlhr   %r15
 
 #CHECK:        bcr     10, %r7                 # encoding: [0x07,0xa7]
+#CHECK:        bher    %r0                     # encoding: [0x07,0xa0]
 #CHECK:        bher    %r15                    # encoding: [0x07,0xaf]
 
        bcr     10, %r7
+       bher    %r0
        bher    %r15
 
 #CHECK:        bcr     11, %r7                 # encoding: [0x07,0xb7]
+#CHECK:        bnlr    %r0                     # encoding: [0x07,0xb0]
 #CHECK:        bnlr    %r15                    # encoding: [0x07,0xbf]
 
        bcr     11, %r7
+       bnlr    %r0
        bnlr    %r15
 
 #CHECK:        bcr     12, %r7                 # encoding: [0x07,0xc7]
+#CHECK:        bler    %r0                     # encoding: [0x07,0xc0]
 #CHECK:        bler    %r15                    # encoding: [0x07,0xcf]
 
        bcr     12, %r7
+       bler    %r0
        bler    %r15
 
 #CHECK:        bcr     13, %r7                 # encoding: [0x07,0xd7]
+#CHECK:        bnhr    %r0                     # encoding: [0x07,0xd0]
 #CHECK:        bnhr    %r15                    # encoding: [0x07,0xdf]
 
        bcr     13, %r7
+       bnhr    %r0
        bnhr    %r15
 
 #CHECK:        bcr     14, %r7                 # encoding: [0x07,0xe7]
+#CHECK:        bnor    %r0                     # encoding: [0x07,0xe0]
 #CHECK:        bnor    %r15                    # encoding: [0x07,0xef]
 
        bcr     14, %r7
+       bnor    %r0
        bnor    %r15
 
 #CHECK:        bcr     15, %r7                 # encoding: [0x07,0xf7]
+#CHECK: br     %r0                     # encoding: [0x07,0xf0]
 #CHECK: br     %r1                     # encoding: [0x07,0xf1]
 #CHECK: br     %r14                    # encoding: [0x07,0xfe]
 #CHECK: br     %r15                    # encoding: [0x07,0xff]
 
        bcr     15, %r7
+       br      %r0
        br      %r1
        br      %r14
        br      %r15
@@ -8002,17 +8032,23 @@
 
 #CHECK: l      %r0, 0                  # encoding: [0x58,0x00,0x00,0x00]
 #CHECK: l      %r0, 4095               # encoding: [0x58,0x00,0x0f,0xff]
+#CHECK: l      %r0, 0(%r0)             # encoding: [0x58,0x00,0x00,0x00]
 #CHECK: l      %r0, 0(%r1)             # encoding: [0x58,0x00,0x10,0x00]
 #CHECK: l      %r0, 0(%r15)            # encoding: [0x58,0x00,0xf0,0x00]
+#CHECK: l      %r0, 4095(%r0,%r15)     # encoding: [0x58,0x00,0xff,0xff]
 #CHECK: l      %r0, 4095(%r1,%r15)     # encoding: [0x58,0x01,0xff,0xff]
+#CHECK: l      %r0, 4095(%r15,%r0)     # encoding: [0x58,0x0f,0x0f,0xff]
 #CHECK: l      %r0, 4095(%r15,%r1)     # encoding: [0x58,0x0f,0x1f,0xff]
 #CHECK: l      %r15, 0                 # encoding: [0x58,0xf0,0x00,0x00]
 
        l       %r0, 0
        l       %r0, 4095
+       l       %r0, 0(%r0)
        l       %r0, 0(%r1)
        l       %r0, 0(%r15)
+       l       %r0, 4095(%r0,%r15)
        l       %r0, 4095(%r1,%r15)
+       l       %r0, 4095(%r15,%r0)
        l       %r0, 4095(%r15,%r1)
        l       %r15, 0
 

diff --git a/llvm/test/MC/SystemZ/regs-bad.s b/llvm/test/MC/SystemZ/regs-bad.s
index f4cdb69..c4d16ef 100644 (file)
--- a/llvm/test/MC/SystemZ/regs-bad.s
+++ b/llvm/test/MC/SystemZ/regs-bad.s
@@ -297,20 +297,3 @@
        .cfi_offset %arid,0
 
        .cfi_endproc
-
-#CHECK: error: %r0 used in an address
-#CHECK: sll    %r2,8(%r0)
-#CHECK: error: %r0 used in an address
-#CHECK: br     %r0
-#CHECK: error: %r0 used in an address
-#CHECK: l      %r1,8(%r0)
-#CHECK: error: %r0 used in an address
-#CHECK: l      %r1,8(%r0,%r15)
-#CHECK: error: %r0 used in an address
-#CHECK: l      %r1,8(%r15,%r0)
-
-       sll     %r2,8(%r0)
-       br      %r0
-       l       %r1,8(%r0)
-       l       %r1,8(%r0,%r15)
-       l       %r1,8(%r15,%r0)

diff --git a/llvm/test/MC/SystemZ/tokens.s b/llvm/test/MC/SystemZ/tokens.s
index 7cea21a..1773786 100644 (file)
--- a/llvm/test/MC/SystemZ/tokens.s
+++ b/llvm/test/MC/SystemZ/tokens.s
@@ -9,24 +9,18 @@
 #CHECK: foo    100(200), 300
 #CHECK: error: register expected
 #CHECK: foo    100(200,), 300
-#CHECK: error: %r0 used in an address
-#CHECK: foo    100(200,%r0), 300
 #CHECK: error: invalid instruction
 #CHECK: foo    100(200,%r1), 300
 #CHECK: error: invalid address register
 #CHECK: foo    100(%a0), 200
 #CHECK: error: invalid instruction
 #CHECK: foo    100(%r0), 200
-#CHECK: error: %r0 used in an address
-#CHECK: foo    100(%v1,%r0), 200
 #CHECK: error: invalid instruction
 #CHECK: foo    100(%v0,%r1), 200
 #CHECK: error: invalid instruction
 #CHECK: foo    100(%v31), 200
 #CHECK: error: invalid address register
 #CHECK: foo    100(%r1,%a0), 200
-#CHECK: error: %r0 used in an address
-#CHECK: foo    100(%r1,%r0), 200
 #CHECK: error: unexpected token in address
 #CHECK: foo    100(%r1,%r2, 200
 #CHECK: error: invalid instruction
@@ -68,15 +62,12 @@
        foo     100(, 200
        foo     100(200), 300
        foo     100(200,), 300
-       foo     100(200,%r0), 300
        foo     100(200,%r1), 300
        foo     100(%a0), 200
        foo     100(%r0), 200
-       foo     100(%v1,%r0), 200
        foo     100(%v0,%r1), 200
        foo     100(%v31), 200
        foo     100(%r1,%a0), 200
-       foo     100(%r1,%r0), 200
        foo     100(%r1,%r2, 200
        foo     100(%r1,%r2), 200
        foo     100(%r1,%r2)(, 200