[M68k] Add MC support for bchg, bclr and bset instruction

[Jim]

Fix tests

[myhsu]

Thanks for the patch.
Have you confirmed that codegen tests are not affected? You used the same isel patterns for all of the bit instructions (btst/bset/bclr etc.) which I don't think that's correct.

It's okay to add only the MC support for certain instructions but please leave the isel pattern empty.

[glaubitz]

Is this still being worked on? We're still missing the BCHG, BCLR and BSET instructions.

[Jim]

Leave the isel pattern empty.

[Jim]

Rebase

[Jim]

Clean code style

[Jim]

Fix tab indent

[myhsu]

LGTM with minor issues, thanks!

llvm/lib/Target/M68k/M68kInstrBits.td

51

nit: ISel pattern is initialized to empty list by default so you don't need to put a [] here. Ditto for other places in this patch.

[Jim]

Address comment.

llvm/lib/Target/M68k/M68kInstrBits.td

 //===-- M68kInstrBits.td - Bit Manipulation Instrs ---------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file describes the bit manipulation instructions in the M68k
 /// architecture. Here is the current status of the file:
 ///
 ///  Machine:
 ///
-///    BCHG    [ ]   BCLR    [ ]   BSET     [ ]   BTST     [~]
+///    BCHG    [~]   BCLR    [~]   BSET     [~]   BTST     [~]
 ///
 ///  Map:
 ///
 ///   [ ] - was not touched at all
 ///   [!] - requires extarnal stuff implemented
 ///   [~] - in progress but usable
 ///   [x] - done
 ///
 //===----------------------------------------------------------------------===//
 
-//===----------------------------------------------------------------------===//
-// BTST
-//===----------------------------------------------------------------------===//
-
 /// ------------+---------+---------+---------+---------
 ///  F  E  D  C | B  A  9 | 8  7  6 | 5  4  3 | 2  1  0
 /// ------------+---------+---------+---------+---------
-///  0  0  0  0 |   REG   | 1  0  0 |   MODE  |   REG
+///  0  0  0  0 |   REG   | OP MODE |   MODE  |   REG
 /// ------------+---------+---------+---------+---------
-class MxBTSTEnc_R<MxBeadDReg REG, MxEncEA EA, MxEncExt EXT>
-    : MxEncoding<EA.Reg, EA.DA, EA.Mode, MxBead3Bits<0b100>, REG, MxBead4Bits<0b0000>,
+class MxBITEnc_R<bits<3> OPMODE, MxBeadDReg REG, MxEncEA EA, MxEncExt EXT>
+    : MxEncoding<EA.Reg, EA.DA, EA.Mode,
+                 MxBead3Bits<OPMODE>, REG, MxBead4Bits<0b0000>,
                  EXT.Imm, EXT.B8, EXT.Scale, EXT.WL, EXT.DAReg>;
 
-/// -------------------------------+---------+---------
-///  F  E  D  C  B  A  9  8 . 7  6 | 5  4  3 | 2  1  0
-/// -------------------------------+---------+---------
-///  0  0  0  0  1  0  0  0 . 0  0 |   MODE  |   REG
-/// ------------------------+------+---------+---------
-///  0  0  0  0  0  0  0  0 |        BIT NUMBER
-/// ------------------------+--------------------------
-class MxBTSTEnc_I<MxBead8Imm IMM, MxEncEA EA, MxEncExt EXT>
-    : MxEncoding<EA.Reg, EA.DA, EA.Mode, MxBead2Bits<0b00>,
-                 MxBead4Bits<0b1000>, MxBead4Bits<0b0000>, IMM,
+/// ---------------------+---------+---------+---------
+///  F  E  D  C  B  A  9 | 8  7  6 | 5  4  3 | 2  1  0
+/// ---------------------+---------+---------+---------
+///  0  0  0  0  1  0  0 | OP MODE |   MODE  |   REG
+/// ---------------------+---+-----+---------+---------
+///  0  0  0  0  0  0  0   0 |        BIT NUMBER
+/// -------------------------+--------------------------
+class MxBITEnc_I<bits<3> OPMODE, MxBead8Imm IMM, MxEncEA EA, MxEncExt EXT>
+    : MxEncoding<EA.Reg, EA.DA, EA.Mode, MxBead3Bits<OPMODE>,
+                 MxBead3Bits<0b100>, MxBead4Bits<0b0000>, IMM,
                  EXT.Imm, EXT.B8, EXT.Scale, EXT.WL, EXT.DAReg>;
 
 let Defs = [CCR] in {
-class MxBTST_RR<MxType TYPE>
-    : MxInst<(outs), (ins TYPE.ROp:$dst, TYPE.ROp:$bitno), "btst\t$bitno, $dst",
+class MxBIT_RR<string MN, bits<3> OPMODE, MxType TYPE>
+    : MxInst<(outs), (ins TYPE.ROp:$dst, TYPE.ROp:$bitno), MN#"\t$bitno, $dst",
              [(set CCR, (MxBt TYPE.VT:$dst, TYPE.VT:$bitno))],
-             MxBTSTEnc_R<MxBeadDReg<1>, MxEncEAd_0, MxExtEmpty>>;
+             MxBITEnc_R<OPMODE, MxBeadDReg<1>, MxEncEAd_0, MxExtEmpty>>;
 
-class MxBTST_RI<MxType TYPE>
-    : MxInst<(outs), (ins TYPE.ROp:$dst, TYPE.IOp:$bitno), "btst\t$bitno, $dst",
+class MxBIT_RI<string MN, bits<3> OPMODE, MxType TYPE>
+    : MxInst<(outs), (ins TYPE.ROp:$dst, TYPE.IOp:$bitno), MN#"\t$bitno, $dst",
              [(set CCR, (MxBt TYPE.VT:$dst, TYPE.IPat:$bitno))],
-             MxBTSTEnc_I<MxBead8Imm<1>, MxEncEAd_0, MxExtEmpty>>;
+             MxBITEnc_I<OPMODE, MxBead8Imm<1>, MxEncEAd_0, MxExtEmpty>>;
 
-class MxBTST_MR<MxType TYPE, MxOperand MEMOpd, ComplexPattern MEMPat,
-                MxEncEA EA, MxEncExt EXT>
-    : MxInst<(outs), (ins MEMOpd:$dst, TYPE.ROp:$bitno), "btst\t$bitno, $dst",
+class MxBIT_MR<string MN, bits<3> OPMODE, MxType TYPE, MxOperand MEMOpd,
+               ComplexPattern MEMPat, MxEncEA EA, MxEncExt EXT>
+    : MxInst<(outs), (ins MEMOpd:$dst, TYPE.ROp:$bitno), MN#"\t$bitno, $dst",
              [(set CCR, (MxBt (TYPE.Load MEMPat:$dst), TYPE.VT:$bitno))],
-             MxBTSTEnc_R<MxBeadDReg<1>, EA, EXT>>;
+             MxBITEnc_R<OPMODE, MxBeadDReg<1>, EA, EXT>>;
 
-class MxBTST_MI<MxType TYPE, MxOperand MEMOpd, ComplexPattern MEMPat,
-                MxEncEA EA, MxEncExt EXT>
-    : MxInst<(outs), (ins MEMOpd:$dst, TYPE.IOp:$bitno), "btst\t$bitno, $dst",
+class MxBIT_MI<string MN, bits<3> OPMODE, MxType TYPE, MxOperand MEMOpd,
+               ComplexPattern MEMPat, MxEncEA EA, MxEncExt EXT>
+    : MxInst<(outs), (ins MEMOpd:$dst, TYPE.IOp:$bitno), MN#"\t$bitno, $dst",
              [(set CCR, (MxBt (TYPE.Load MEMPat:$dst), TYPE.IPat:$bitno))],
-             MxBTSTEnc_I<MxBead8Imm<1>, EA, EXT>>;
+             MxBITEnc_I<OPMODE, MxBead8Imm<1>, EA, EXT>>;
 } // Defs = [CCR]
 
-// Register BTST limited to 32 bits only
-def BTST32dd : MxBTST_RR<MxType32d>;
-def BTST32di : MxBTST_RI<MxType32d>;
-
-// Memory BTST limited to 8 bits only
-def BTST8jd : MxBTST_MR<MxType8d, MxType8.JOp, MxType8.JPat,
-                        MxEncEAj_0, MxExtEmpty>;
-def BTST8od : MxBTST_MR<MxType8d, MxType8.OOp, MxType8.OPat,
-                        MxEncEAo_0, MxExtEmpty>;
-def BTST8ed : MxBTST_MR<MxType8d, MxType8.EOp, MxType8.EPat,
-                        MxEncEAe_0, MxExtEmpty>;
-def BTST8pd : MxBTST_MR<MxType8d, MxType8.POp, MxType8.PPat,
-                        MxEncEAp_0, MxExtI16_0>;
-def BTST8fd : MxBTST_MR<MxType8d, MxType8.FOp, MxType8.FPat,
-                        MxEncEAf_0, MxExtBrief_0>;
-def BTST8qd : MxBTST_MR<MxType8d, MxType8.QOp, MxType8.QPat,
-                        MxEncEAq,   MxExtI16_0>;
-def BTST8kd : MxBTST_MR<MxType8d, MxType8.KOp, MxType8.KPat,
-                        MxEncEAk,   MxExtBrief_0>;
-
-def BTST8ji : MxBTST_MI<MxType8d, MxType8.JOp, MxType8.JPat,
-                        MxEncEAj_0, MxExtEmpty>;
-def BTST8oi : MxBTST_MI<MxType8d, MxType8.OOp, MxType8.OPat,
-                        MxEncEAo_0, MxExtEmpty>;
-def BTST8ei : MxBTST_MI<MxType8d, MxType8.EOp, MxType8.EPat,
-                        MxEncEAe_0, MxExtEmpty>;
-def BTST8pi : MxBTST_MI<MxType8d, MxType8.POp, MxType8.PPat,
-                        MxEncEAp_0, MxExtI16_0>;
-def BTST8fi : MxBTST_MI<MxType8d, MxType8.FOp, MxType8.FPat,
-                        MxEncEAf_0, MxExtBrief_0>;
-def BTST8qi : MxBTST_MI<MxType8d, MxType8.QOp, MxType8.QPat,
-                        MxEncEAq,   MxExtI16_0>;
-def BTST8ki : MxBTST_MI<MxType8d, MxType8.KOp, MxType8.KPat,
-                        MxEncEAk,   MxExtBrief_0>;
+def BTST8qd : MxBIT_MR<"btst", 0b100, MxType8d, MxType8.QOp, MxType8.QPat,
+def BTST8kd : MxBIT_MR<"btst", 0b100, MxType8d, MxType8.KOp, MxType8.KPat,
+def BTST8qi : MxBIT_MI<"btst", 0b000, MxType8d, MxType8.QOp, MxType8.QPat,
+def BTST8ki : MxBIT_MI<"btst", 0b000, MxType8d, MxType8.KOp, MxType8.KPat,
+
+multiclass MxBIT<string MN, bits<3> OP, bits<3> OPI> {
+  // Register BIT limited to 32 bits only
+  def NAME#32dd : MxBIT_RR<MN, OP, MxType32d>;
+  def NAME#32di : MxBIT_RI<MN, OPI, MxType32d>;
+
+  // Memory BIT limited to 8 bits only
+  def NAME#8jd : MxBIT_MR<MN, OP, MxType8d, MxType8.JOp,
+                          MxType8.JPat, MxEncEAj_0, MxExtEmpty>;
+  def NAME#8od : MxBIT_MR<MN, OP, MxType8d, MxType8.OOp,
+                          MxType8.OPat, MxEncEAo_0, MxExtEmpty>;
+  def NAME#8ed : MxBIT_MR<MN, OP, MxType8d, MxType8.EOp,
+                          MxType8.EPat, MxEncEAe_0, MxExtEmpty>;
+  def NAME#8pd : MxBIT_MR<MN, OP, MxType8d, MxType8.POp,
+                          MxType8.PPat, MxEncEAp_0, MxExtI16_0>;
+  def NAME#8fd : MxBIT_MR<MN, OP, MxType8d, MxType8.FOp,
+                          MxType8.FPat, MxEncEAf_0, MxExtBrief_0>;
+
+  def NAME#8ji : MxBIT_MI<MN, OPI, MxType8d, MxType8.JOp,
+                          MxType8.JPat, MxEncEAj_0, MxExtEmpty>;
+  def NAME#8oi : MxBIT_MI<MN, OPI, MxType8d, MxType8.OOp,
+                          MxType8.OPat, MxEncEAo_0, MxExtEmpty>;
+  def NAME#8ei : MxBIT_MI<MN, OPI, MxType8d, MxType8.EOp,
+                          MxType8.EPat, MxEncEAe_0, MxExtEmpty>;
+  def NAME#8pi : MxBIT_MI<MN, OPI, MxType8d, MxType8.POp,
+                          MxType8.PPat, MxEncEAp_0, MxExtI16_0>;
+  def NAME#8fi : MxBIT_MI<MN, OPI, MxType8d, MxType8.FOp,
+                          MxType8.FPat, MxEncEAf_0, MxExtBrief_0>;
+}
+
+defm BCHG : MxBIT<"bchg", 0b101, 0b001>;
+defm BCLR : MxBIT<"bclr", 0b110, 0b010>;
+defm BSET : MxBIT<"bset", 0b111, 0b011>;
+defm BTST : MxBIT<"btst", 0b100, 0b000>;

llvm/test/MC/M68k/Bits/Classes/MxBTST_MI.s

 ; RUN: llvm-mc -triple=m68k -show-encoding %s | FileCheck %s
 
+; CHECK:      bchg  #0, (%a1)
+; CHECK-SAME: encoding: [0x08,0x51,0x00,0x00]
+bchg  #0, (%a1)
+; CHECK:      bchg  #-1, (%a0)
+; CHECK-SAME: encoding: [0x08,0x50,0x00,0xff]
+bchg  #-1, (%a0)
+
+; CHECK:      bclr  #0, (%a1)
+; CHECK-SAME: encoding: [0x08,0x91,0x00,0x00]
+bclr  #0, (%a1)
+; CHECK:      bclr  #-1, (%a0)
+; CHECK-SAME: encoding: [0x08,0x90,0x00,0xff]
+bclr  #-1, (%a0)
+
+; CHECK:      bset  #0, (%a1)
+; CHECK-SAME: encoding: [0x08,0xd1,0x00,0x00]
+bset  #0, (%a1)
+; CHECK:      bset  #-1, (%a0)
+; CHECK-SAME: encoding: [0x08,0xd0,0x00,0xff]
+bset  #-1, (%a0)
+
 ; CHECK:      btst  #0, (%a1)
 ; CHECK-SAME: encoding: [0x08,0x11,0x00,0x00]
 btst  #0, (%a1)
 ; CHECK:      btst  #-1, (%a0)
 ; CHECK-SAME: encoding: [0x08,0x10,0x00,0xff]
 btst  #-1, (%a0)
 
+; CHECK:      bchg  #0, (%a1)+
+; CHECK-SAME: encoding: [0x08,0x59,0x00,0x00]
+bchg  #0, (%a1)+
+; CHECK:      bchg  #-1, (%a0)+
+; CHECK-SAME: encoding: [0x08,0x58,0x00,0xff]
+bchg  #-1, (%a0)+
+
+; CHECK:      bclr  #0, (%a1)+
+; CHECK-SAME: encoding: [0x08,0x99,0x00,0x00]
+bclr  #0, (%a1)+
+; CHECK:      bclr  #-1, (%a0)+
+; CHECK-SAME: encoding: [0x08,0x98,0x00,0xff]
+bclr  #-1, (%a0)+
+
+; CHECK:      bset  #0, (%a1)+
+; CHECK-SAME: encoding: [0x08,0xd9,0x00,0x00]
+bset  #0, (%a1)+
+; CHECK:      bset  #-1, (%a0)+
+; CHECK-SAME: encoding: [0x08,0xd8,0x00,0xff]
+bset  #-1, (%a0)+
+
 ; CHECK:      btst  #0, (%a1)+
 ; CHECK-SAME: encoding: [0x08,0x19,0x00,0x00]
 btst  #0, (%a1)+
 ; CHECK:      btst  #-1, (%a0)+
 ; CHECK-SAME: encoding: [0x08,0x18,0x00,0xff]
 btst  #-1, (%a0)+
 
+; CHECK:      bchg  #0, -(%a1)
+; CHECK-SAME: encoding: [0x08,0x61,0x00,0x00]
+bchg  #0, -(%a1)
+; CHECK:      bchg  #-1, -(%a0)
+; CHECK-SAME: encoding: [0x08,0x60,0x00,0xff]
+bchg  #-1, -(%a0)
+
+; CHECK:      bclr  #0, -(%a1)
+; CHECK-SAME: encoding: [0x08,0xa1,0x00,0x00]
+bclr  #0, -(%a1)
+; CHECK:      bclr  #-1, -(%a0)
+; CHECK-SAME: encoding: [0x08,0xa0,0x00,0xff]
+bclr  #-1, -(%a0)
+
+; CHECK:      bset  #0, -(%a1)
+; CHECK-SAME: encoding: [0x08,0xe1,0x00,0x00]
+bset  #0, -(%a1)
+; CHECK:      bset  #-1, -(%a0)
+; CHECK-SAME: encoding: [0x08,0xe0,0x00,0xff]
+bset  #-1, -(%a0)
+
 ; CHECK:      btst  #0, -(%a1)
 ; CHECK-SAME: encoding: [0x08,0x21,0x00,0x00]
 btst  #0, -(%a1)
 ; CHECK:      btst  #-1, -(%a0)
 ; CHECK-SAME: encoding: [0x08,0x20,0x00,0xff]
 btst  #-1, -(%a0)
 
+; CHECK:      bchg  #0, (-1,%a1)
+; CHECK-SAME: encoding: [0x08,0x69,0x00,0x00,0xff,0xff]
+bchg  #0, (-1,%a1)
+; CHECK:      bchg  #-1, (0,%a0)
+; CHECK-SAME: encoding: [0x08,0x68,0x00,0xff,0x00,0x00]
+bchg  #-1, (0,%a0)
+
+; CHECK:      bclr  #0, (-1,%a1)
+; CHECK-SAME: encoding: [0x08,0xa9,0x00,0x00,0xff,0xff]
+bclr  #0, (-1,%a1)
+; CHECK:      bclr  #-1, (0,%a0)
+; CHECK-SAME: encoding: [0x08,0xa8,0x00,0xff,0x00,0x00]
+bclr  #-1, (0,%a0)
+
+; CHECK:      bset  #0, (-1,%a1)
+; CHECK-SAME: encoding: [0x08,0xe9,0x00,0x00,0xff,0xff]
+bset  #0, (-1,%a1)
+; CHECK:      bset  #-1, (0,%a0)
+; CHECK-SAME: encoding: [0x08,0xe8,0x00,0xff,0x00,0x00]
+bset  #-1, (0,%a0)
+
 ; CHECK:      btst  #0, (-1,%a1)
 ; CHECK-SAME: encoding: [0x08,0x29,0x00,0x00,0xff,0xff]
 btst  #0, (-1,%a1)
 ; CHECK:      btst  #-1, (0,%a0)
 ; CHECK-SAME: encoding: [0x08,0x28,0x00,0xff,0x00,0x00]
 btst  #-1, (0,%a0)
 
+; CHECK:      bchg  #0, (-1,%a1,%a0)
+; CHECK-SAME: encoding: [0x08,0x71,0x00,0x00,0x88,0xff]
+bchg  #0, (-1,%a1,%a0)
+; CHECK:      bchg  #-1, (0,%a0,%a0)
+; CHECK-SAME: encoding: [0x08,0x70,0x00,0xff,0x88,0x00]
+bchg  #-1, (0,%a0,%a0)
+
+; CHECK:      bclr  #0, (-1,%a1,%a0)
+; CHECK-SAME: encoding: [0x08,0xb1,0x00,0x00,0x88,0xff]
+bclr  #0, (-1,%a1,%a0)
+; CHECK:      bclr  #-1, (0,%a0,%a0)
+; CHECK-SAME: encoding: [0x08,0xb0,0x00,0xff,0x88,0x00]
+bclr  #-1, (0,%a0,%a0)
+
+; CHECK:      bset  #0, (-1,%a1,%a0)
+; CHECK-SAME: encoding: [0x08,0xf1,0x00,0x00,0x88,0xff]
+bset  #0, (-1,%a1,%a0)
+; CHECK:      bset  #-1, (0,%a0,%a0)
+; CHECK-SAME: encoding: [0x08,0xf0,0x00,0xff,0x88,0x00]
+bset  #-1, (0,%a0,%a0)
+
 ; CHECK:      btst  #0, (-1,%a1,%a0)
 ; CHECK-SAME: encoding: [0x08,0x31,0x00,0x00,0x88,0xff]
 btst  #0, (-1,%a1,%a0)
 ; CHECK:      btst  #-1, (0,%a0,%a0)
 ; CHECK-SAME: encoding: [0x08,0x30,0x00,0xff,0x88,0x00]
 btst  #-1, (0,%a0,%a0)
 
 ; CHECK:      btst  #0, (0,%pc)

llvm/test/MC/M68k/Bits/Classes/MxBTST_MR.s

 ; RUN: llvm-mc -triple=m68k -show-encoding %s | FileCheck %s
 
+; CHECK:      bchg  %d0, (%a1)
+; CHECK-SAME: encoding: [0x01,0x51]
+bchg  %d0, (%a1)
+; CHECK:      bchg  %d1, (%a0)
+; CHECK-SAME: encoding: [0x03,0x50]
+bchg  %d1, (%a0)
+
+; CHECK:      bclr  %d0, (%a1)
+; CHECK-SAME: encoding: [0x01,0x91]
+bclr  %d0, (%a1)
+; CHECK:      bclr  %d1, (%a0)
+; CHECK-SAME: encoding: [0x03,0x90]
+bclr  %d1, (%a0)
+
+; CHECK:      bset  %d0, (%a1)
+; CHECK-SAME: encoding: [0x01,0xd1]
+bset  %d0, (%a1)
+; CHECK:      bset  %d1, (%a0)
+; CHECK-SAME: encoding: [0x03,0xd0]
+bset  %d1, (%a0)
+
 ; CHECK:      btst  %d0, (%a1)
 ; CHECK-SAME: encoding: [0x01,0x11]
 btst  %d0, (%a1)
 ; CHECK:      btst  %d1, (%a0)
 ; CHECK-SAME: encoding: [0x03,0x10]
 btst  %d1, (%a0)
 
-; CHECK:      btst  %d0, (%a1)+
-; CHECK-SAME: encoding: [0x01,0x19]
-btst  %d0, (%a1)+
-; CHECK:      btst  %d1, (%a0)+
-; CHECK-SAME: encoding: [0x03,0x18]
-btst  %d1, (%a0)+
+; CHECK:      bchg  %d0, (%a1)+
+; CHECK-SAME: encoding: [0x01,0x59]
+bchg  %d0, (%a1)+
+; CHECK:      bchg  %d1, (%a0)+
+; CHECK-SAME: encoding: [0x03,0x58]
+bchg  %d1, (%a0)+
+
+; CHECK:      bclr  %d0, (%a1)+
+; CHECK-SAME: encoding: [0x01,0x99]
+bclr  %d0, (%a1)+
+; CHECK:      bclr  %d1, (%a0)+
+; CHECK-SAME: encoding: [0x03,0x98]
+bclr  %d1, (%a0)+
+
+; CHECK:      bset  %d0, (%a1)+
+; CHECK-SAME: encoding: [0x01,0xd9]
+bset  %d0, (%a1)+
+; CHECK:      bset  %d1, (%a0)+
+; CHECK-SAME: encoding: [0x03,0xd8]
+bset  %d1, (%a0)+
 
 ; CHECK:      btst  %d0, -(%a1)
 ; CHECK-SAME: encoding: [0x01,0x21]
 btst  %d0, -(%a1)
 ; CHECK:      btst  %d1, -(%a0)
 ; CHECK-SAME: encoding: [0x03,0x20]
 btst  %d1, -(%a0)
 
+; CHECK:      bchg  %d0, -(%a1)
+; CHECK-SAME: encoding: [0x01,0x61]
+bchg  %d0, -(%a1)
+; CHECK:      bchg  %d1, -(%a0)
+; CHECK-SAME: encoding: [0x03,0x60]
+bchg  %d1, -(%a0)
+
+; CHECK:      bclr  %d0, -(%a1)
+; CHECK-SAME: encoding: [0x01,0xa1]
+bclr  %d0, -(%a1)
+; CHECK:      bclr  %d1, -(%a0)
+; CHECK-SAME: encoding: [0x03,0xa0]
+bclr  %d1, -(%a0)
+
+; CHECK:      bset  %d0, -(%a1)
+; CHECK-SAME: encoding: [0x01,0xe1]
+bset  %d0, -(%a1)
+; CHECK:      bset  %d1, -(%a0)
+; CHECK-SAME: encoding: [0x03,0xe0]
+bset  %d1, -(%a0)
+
+; CHECK:      btst  %d0, -(%a1)
+; CHECK-SAME: encoding: [0x01,0x21]
+btst  %d0, -(%a1)
+; CHECK:      btst  %d1, -(%a0)
+; CHECK-SAME: encoding: [0x03,0x20]
+btst  %d1, -(%a0)
+
+; CHECK:      bchg  %d0, (-1,%a1)
+; CHECK-SAME: encoding: [0x01,0x69,0xff,0xff]
+bchg  %d0, (-1,%a1)
+; CHECK:      bchg  %d1, (0,%a0)
+; CHECK-SAME: encoding: [0x03,0x68,0x00,0x00]
+bchg  %d1, (0,%a0)
+
+; CHECK:      bclr  %d0, (-1,%a1)
+; CHECK-SAME: encoding: [0x01,0xa9,0xff,0xff]
+bclr  %d0, (-1,%a1)
+; CHECK:      bclr  %d1, (0,%a0)
+; CHECK-SAME: encoding: [0x03,0xa8,0x00,0x00]
+bclr  %d1, (0,%a0)
+
+; CHECK:      bset  %d0, (-1,%a1)
+; CHECK-SAME: encoding: [0x01,0xe9,0xff,0xff]
+bset  %d0, (-1,%a1)
+; CHECK:      bset  %d1, (0,%a0)
+; CHECK-SAME: encoding: [0x03,0xe8,0x00,0x00]
+bset  %d1, (0,%a0)
+
 ; CHECK:      btst  %d0, (-1,%a1)
 ; CHECK-SAME: encoding: [0x01,0x29,0xff,0xff]
 btst  %d0, (-1,%a1)
 ; CHECK:      btst  %d1, (0,%a0)
 ; CHECK-SAME: encoding: [0x03,0x28,0x00,0x00]
 btst  %d1, (0,%a0)
 
+; CHECK:      bchg  %d0, (-1,%a1,%a0)
+; CHECK-SAME: encoding: [0x01,0x71,0x88,0xff]
+bchg  %d0, (-1,%a1,%a0)
+; CHECK:      bchg  %d1, (0,%a0,%a0)
+; CHECK-SAME: encoding: [0x03,0x70,0x88,0x00]
+bchg  %d1, (0,%a0,%a0)
+
+; CHECK:      bclr  %d0, (-1,%a1,%a0)
+; CHECK-SAME: encoding: [0x01,0xb1,0x88,0xff]
+bclr  %d0, (-1,%a1,%a0)
+; CHECK:      bclr  %d1, (0,%a0,%a0)
+; CHECK-SAME: encoding: [0x03,0xb0,0x88,0x00]
+bclr  %d1, (0,%a0,%a0)
+
+; CHECK:      bset  %d0, (-1,%a1,%a0)
+; CHECK-SAME: encoding: [0x01,0xf1,0x88,0xff]
+bset  %d0, (-1,%a1,%a0)
+; CHECK:      bset  %d1, (0,%a0,%a0)
+; CHECK-SAME: encoding: [0x03,0xf0,0x88,0x00]
+bset  %d1, (0,%a0,%a0)
+
 ; CHECK:      btst  %d0, (-1,%a1,%a0)
 ; CHECK-SAME: encoding: [0x01,0x31,0x88,0xff]
 btst  %d0, (-1,%a1,%a0)
 ; CHECK:      btst  %d1, (0,%a0,%a0)
 ; CHECK-SAME: encoding: [0x03,0x30,0x88,0x00]
 btst  %d1, (0,%a0,%a0)
 
 ; CHECK:      btst  %d0, (0,%pc)

llvm/test/MC/M68k/Bits/Classes/MxBTST_RR.s

 ; RUN: llvm-mc -triple=m68k -show-encoding %s | FileCheck %s
 
+; CHECK:      bchg  %d1, %d0
+; CHECK-SAME: encoding: [0x03,0x40]
+bchg  %d1, %d0
+; CHECK:      bchg  %d0, %d3
+; CHECK-SAME: encoding: [0x01,0x43]
+bchg  %d0, %d3
+
+; CHECK:      bclr  %d1, %d0
+; CHECK-SAME: encoding: [0x03,0x80]
+bclr  %d1, %d0
+; CHECK:      bclr  %d0, %d3
+; CHECK-SAME: encoding: [0x01,0x83]
+bclr  %d0, %d3
+
+; CHECK:      bset  %d1, %d0
+; CHECK-SAME: encoding: [0x03,0xc0]
+bset  %d1, %d0
+; CHECK:      bset  %d0, %d3
+; CHECK-SAME: encoding: [0x01,0xc3]
+bset  %d0, %d3
+
 ; CHECK:      btst  %d1, %d0
 ; CHECK-SAME: encoding: [0x03,0x00]
 btst  %d1, %d0
 ; CHECK:      btst  %d0, %d3
 ; CHECK-SAME: encoding: [0x01,0x03]
 btst  %d0, %d3