[M68k] Implement AsmParser

[ricky26]

Summary

This is a work-in-progress implementation of an assembler for M68k.

Outstanding work:

• Updating existing tests assembly syntax
• Writing new tests for the assembler (and disassembler)

I've left those until there's consensus that this approach is okay (I hope that's okay!).

Questions I'm aware of:

• Should this use Motorola or gas syntax? (At the moment it uses Motorola syntax.)

Depends on D98519

Depends on D98532

Depends on D98534

Depends on D98535

Depends on D98536

[ricky26]

Move operand parser definitions into earlier patch

[myhsu]

Should this use Motorola or gas syntax? (At the moment it uses Motorola syntax.)

I spent some time dig into GCC and binutils's source. By default GCC generate assembly that conforms to Motorola's syntax (thus GAS should consume that syntax by default). Jessica has pointed out in the review for the 4-th patch that for some reason, (GNU) objdump doesn't conform to Motorola's syntax. Though I didn't know the full story but apparently objdump and GCC are using separate code base to print out assembly and for unknown reasons, the former just didn't want to adopt Motorola's syntax :-P (it doesn't have the option to switch between different syntaxes either)
The bottom line is that I would recommend to implement Motorola's syntax first. We can always add "GNU flavor" assembly printer if needed in the future, just like ATT/Intel syntax in X86 land.

P.S. Alternatively GCC can generate they called "MIT syntax" which -- I have no idea what that is tbh --is probably closer to conventional GNU assembly syntax. But that syntax is only enabled if you're building cross-compile m68k gcc for openbsd

[ricky26]

I've marked this 'Ready for Review' since otherwise notifications don't happen. To be clear though, this is not ready to merge.

In D98537#2625355, @myhsu wrote:

Should this use Motorola or gas syntax? (At the moment it uses Motorola syntax.)

I spent some time dig into GCC and binutils's source. By default GCC generate assembly that conforms to Motorola's syntax (thus GAS should consume that syntax by default). Jessica has pointed out in the review for the 4-th patch that for some reason, (GNU) objdump doesn't conform to Motorola's syntax. Though I didn't know the full story but apparently objdump and GCC are using separate code base to print out assembly and for unknown reasons, the former just didn't want to adopt Motorola's syntax :-P (it doesn't have the option to switch between different syntaxes either)
The bottom line is that I would recommend to implement Motorola's syntax first. We can always add "GNU flavor" assembly printer if needed in the future, just like ATT/Intel syntax in X86 land.

P.S. Alternatively GCC can generate they called "MIT syntax" which -- I have no idea what that is tbh --is probably closer to conventional GNU assembly syntax. But that syntax is only enabled if you're building cross-compile m68k gcc for openbsd

The MIT syntax appears to be the default documented syntax in the as manual (http://web.mit.edu/gnu/doc/html/as_16.html#SEC189, a mirror but it seems up to date). Their logic seems sensible to me: we should support both addressing syntaxes and it should be pretty sane to support both.

However, as' manual on Motorola Syntax still does something which doesn't match Motorola's manual: prefixing the registers with %. Does GCC do this? It looks like as supports bare registers, but it's behind a flag. (Motorola's assembly syntax uses % for binary numbers but we can support both with a bit of peeking.)

So, perhaps the strategy should be this:

• Change the assembler/disassembler to use %-prefixed registers in this patch
• Add support for parsing MIT operand syntax in a later patch
• Add support for emitting MIT operand syntax on a flag in a later patch
• Add support for the alternate assembly directive names in a later patch
• Add support for parsing register names without a prefix on a flag in a later patch

The last point worries me a little since it seems a very commonly referenced format but we'd be doing what as does, if I understand correctly.

[anirudhp]

Hi!

I came across the series of patches that are adding Motorola asm support. I have a quick question as I'm not too familiar with Motorola asm.

Are there any differences in how the input/output/clobber operands in a possible inline asm statement that is parsed, or do they follow the standard GNU asm format with just platform specific syntactical differences in the assembler text?

[ricky26]

In D98537#2659066, @anirudhp wrote:

Are there any differences in how the input/output/clobber operands in a possible inline asm statement that is parsed, or do they follow the standard GNU asm format with just platform specific syntactical differences in the assembler text?

The only difference should be in the actual assembly syntax itself, however, you raise an interesting point because in Motorola-flavour assembly %0/%1 would be parsed as a single-bit constant... Which I hadn't thought of.

I'll be honest: at this stage I've not tested inline assembly at all.

[anirudhp]

The only difference should be in the actual assembly syntax itself, however, you raise an interesting point because in Motorola-flavour assembly %0/%1 would be parsed as a single-bit constant... Which I hadn't thought of.

I'll be honest: at this stage I've not tested inline assembly at all.

Thank you for clarifying!

[ricky26]

Reworked parsing and added the first test

[ricky26]

Rebase onto latest main

[ricky26]

I've added a test (it uses many of the instructions which are defined with both Motorola & MIT operand syntax) and tidied everything up.

I think this is now ready for a real review.

[ricky26]

Remove header to appease clang-tidy

[glaubitz]

llvm/lib/Target/M68k/MCTargetDesc/M68kMCAsmInfo.cpp

34

This change is already part of D98519. Could you remove it from here or from D98519?

[ricky26]

Rebase onto changed AsmLexer patch

[ricky26]

llvm/lib/Target/M68k/MCTargetDesc/M68kMCAsmInfo.cpp

34

Yeah, I just needed to rebase. :)

[myhsu]

Thanks for this amazing efforts :-) I only have minor formatting comments inlined in the code.
I do have a more high-level question: It seems that you only support Motorola syntax right now, is that true? I'm totally fine if you don't add the MIT syntax in this patch, just want to make sure.
Now a bigger issue is the testing: Presumably we should rewrite all of our existing tests under test/CodeGen/M68k/Encoding into assembly and put it under test/MC/M68k. I believe this can give us a better testing coverage on all of our MC components including AsmParser.
On one hand I don't want to put those migrating changes into this patch because it will easily bloat the size. Not to mention those tests contains binary encoding tests, so if we need migrate both kinds of tests at once. On the other hand, I still need to make sure this patch reaches certain test coverage. Fortunately, the test you provided seemed to cover cases in each instruction classes. Can you add a comment in that test file to note our tests migration plan?

llvm/lib/Target/M68k/AsmParser/M68kAsmParser.cpp

52

Should this be exposed as public method?

56

ditto for the above three. Ideally we should minimize the number of public methods

llvm/test/MC/M68k/instructions.s

1 ↗

(On Diff #335186)

-check-prefixes=CHECK is redundant

[ricky26]

In D98537#2669604, @myhsu wrote:

Thanks for this amazing efforts :-) I only have minor formatting comments inlined in the code.
I do have a more high-level question: It seems that you only support Motorola syntax right now, is that true? I'm totally fine if you don't add the MIT syntax in this patch, just want to make sure.
Now a bigger issue is the testing: Presumably we should rewrite all of our existing tests under test/CodeGen/M68k/Encoding into assembly and put it under test/MC/M68k. I believe this can give us a better testing coverage on all of our MC components including AsmParser.
On one hand I don't want to put those migrating changes into this patch because it will easily bloat the size. Not to mention those tests contains binary encoding tests, so if we need migrate both kinds of tests at once. On the other hand, I still need to make sure this patch reaches certain test coverage. Fortunately, the test you provided seemed to cover cases in each instruction classes. Can you add a comment in that test file to note our tests migration plan?

Thanks! I'm having fun and it's been nice to dip my toes into LLVM contribution. :)

For now, this only supports Motorola syntax (actually, MIT-style (offset, %reg) should parse correctly too). It also only supports _some_ operand formats (immediate, address, direct register, indirect and indirect with displacement).

I agree about the tests. I think the existing tests should be converted to Motorola syntax too (as that seems to be the canonical format), however, I'd argue that we should do those after the assembler & disassembler have landed (in my opinion, fleshing out that functionality is more pressing as it helps us write better tests more easily).

The included test covers the broad strokes of the supported syntax so far and should be enough to prevent code rot. As per the older comment it'll still need a fair few (smaller) revisions. In my opinion, it makes the most sense to add more tests as we go through and ensure the AsmParser actually supports everything it should. Perhaps it makes sense to add relevant Bugzilla bugs for the missing functionality as a prerequisite to landing this?

llvm/lib/Target/M68k/AsmParser/M68kAsmParser.cpp

52

Hadn't thought much about this as the class is in an anonymous namespace but yes, makes sense, I'll sort them out properly.

[myhsu]

I agree about the tests. I think the existing tests should be converted to Motorola syntax too (as that seems to be the canonical format), however, I'd argue that we should do those after the assembler & disassembler have landed (in my opinion, fleshing out that functionality is more pressing as it helps us write better tests more easily).

Perfect, I'll start to rewrite the tests in parallel because we also need to solve several issues (e.g. try to get rid of extract-section command in the tests) alone the way so I can imagine it takes time.

The included test covers the broad strokes of the supported syntax so far and should be enough to prevent code rot. As per the older comment it'll still need a fair few (smaller) revisions. In my opinion, it makes the most sense to add more tests as we go through and ensure the AsmParser actually supports everything it should. Perhaps it makes sense to add relevant Bugzilla bugs for the missing functionality as a prerequisite to landing this?

For sure, please do it.

[ricky26]

• Hide private implementation details of M68kAsmParser
• Remove superfluous FileCheck parameter from test
• Add migration notice to test

[ricky26]

Use assembly comments in the assembly test rather than C++ comments

[ricky26]

@myhsu when you get a moment, can you check that this is all OK now? :)

[myhsu]

In D98537#2682808, @ricky26 wrote:

@myhsu when you get a moment, can you check that this is all OK now? :)

sorry I missed your last update. LGTM now

[glaubitz]

In D98537#2684910, @myhsu wrote:

In D98537#2682808, @ricky26 wrote:

@myhsu when you get a moment, can you check that this is all OK now? :)

sorry I missed your last update. LGTM now

Great to see such a major step forward already! Great work!

llvm/lib/Target/M68k/AsmParser/CMakeLists.txt

+add_llvm_component_library(LLVMM68kAsmParser
+        M68kAsmParser.cpp
+
+  LINK_COMPONENTS
+  MC
+  MCParser
+  Support
+
+  ADD_TO_COMPONENT
+  M68k
+)

llvm/lib/Target/M68k/AsmParser/M68kAsmParser.cpp

+//===---- M68kAsmParser.cpp - Parse M68k assembly to MCInst instructions --===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "M68k.h"
+#include "M68kInstrInfo.h"
+#include "M68kRegisterInfo.h"
+#include "TargetInfo/M68kTargetInfo.h"
+
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCParser/MCParsedAsmOperand.h"
+#include "llvm/MC/MCParser/MCTargetAsmParser.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/Support/TargetRegistry.h"
+
+#include <sstream>
+
+#define DEBUG_TYPE "m68k-asm-parser"
+
+using namespace llvm;
+
+namespace {
+/// Parses M68k assembly from a stream.
+class M68kAsmParser : public MCTargetAsmParser {
+  const MCSubtargetInfo &STI;
+  MCAsmParser &Parser;
+  const MCRegisterInfo *MRI;
+
+#define GET_ASSEMBLER_HEADER
+#include "M68kGenAsmMatcher.inc"
+
+public:
+  M68kAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser,
+                const MCInstrInfo &MII, const MCTargetOptions &Options)
+      : MCTargetAsmParser(Options, STI, MII), STI(STI), Parser(Parser) {
+    MCAsmParserExtension::Initialize(Parser);
+    MRI = getContext().getRegisterInfo();
+
+    setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
+  }
+
+  // Parser functions.
+  void eatComma();
+
+  OperandMatchResultTy parseMxImm(OperandVector &Operands);
+  OperandMatchResultTy parseAddr(OperandVector &Operands);
+  OperandMatchResultTy parseARI(OperandVector &Operands);
+  OperandMatchResultTy parseARID(OperandVector &Operands);
+  OperandMatchResultTy parseARII(OperandVector &Operands);
+  OperandMatchResultTy parseARIPD(OperandVector &Operands);
+  OperandMatchResultTy parseARIPI(OperandVector &Operands);
+  OperandMatchResultTy parsePCD(OperandVector &Operands);
+  OperandMatchResultTy parsePCI(OperandVector &Operands);
+  OperandMatchResultTy parseMemOp(OperandVector &Operands);
+
+  unsigned validateTargetOperandClass(MCParsedAsmOperand &Op,
+                                      unsigned Kind) override;
+  bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
+  OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+                                        SMLoc &EndLoc) override;
+  bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
+                        SMLoc NameLoc, OperandVector &Operands) override;
+  bool ParseDirective(AsmToken DirectiveID) override;
+  bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
+                               OperandVector &Operands, MCStreamer &Out,
+                               uint64_t &ErrorInfo,
+                               bool MatchingInlineAsm) override;
+
+  // Helpers for Match&Emit.
+  bool invalidOperand(const SMLoc &Loc, const OperandVector &Operands,
+                      const uint64_t &ErrorInfo);
+  bool missingFeature(const SMLoc &Loc, const uint64_t &ErrorInfo);
+  bool emit(MCInst &Inst, SMLoc const &Loc, MCStreamer &Out) const;
+  bool parseRegisterName(unsigned int &RegNo, SMLoc Loc,
+                         StringRef RegisterName);
+  OperandMatchResultTy parseRegister(unsigned int &RegNo);
+};
+
+/// An parsed M68k assembly operand.
+class M68kOperand : public MCParsedAsmOperand {
+  typedef MCParsedAsmOperand Base;
+
+  enum Kind {
+    Kind_Invalid,
+    Kind_Token,
+    Kind_Reg,
+    Kind_Imm,
+    Kind_Expr,
+    Kind_AddrImm,
+    Kind_AddrExpr,
+
+    // Complex operands
+    Kind_ARI,
+    Kind_ARID,
+    Kind_ARII,
+    Kind_ARIPD,
+    Kind_ARIPI,
+    Kind_PCD,
+    Kind_PCI,
+  };
+
+  struct MemOp {
+    unsigned RegNo;
+    int64_t Displacement;
+    unsigned Index;
+  };
+
+  Kind Kind;
+  SMLoc Start, End;
+  union {
+    StringRef Token;
+    unsigned RegNo;
+    uint64_t Imm;
+    MemOp Mem;
+    const MCExpr *Expr;
+  };
+
+public:
+  M68kOperand(enum Kind Kind, SMLoc Start, SMLoc End)
+      : Base(), Kind(Kind), Start(Start), End(End) {}
+
+  bool isToken() const override { return Kind == Kind_Token; }
+  bool isImm() const override {
+    return (Kind == Kind_Imm) || (Kind == Kind_Expr);
+  }
+  bool isReg() const override { return Kind == Kind_Reg; }
+  bool isMem() const override { return false; }
+
+  unsigned getReg() const override {
+    assert(Kind == Kind_Reg);
+    return RegNo;
+  }
+
+  SMLoc getStartLoc() const override { return Start; }
+  SMLoc getEndLoc() const override { return End; }
+
+  void print(raw_ostream &OS) const override;
+
+  StringRef getToken() const {
+    assert(isToken());
+    return Token;
+  }
+
+  void addRegOperands(MCInst &Inst, unsigned N) const {
+    assert(isReg() && "wrong operand kind");
+    assert((N == 1) && "can only handle one register operand");
+
+    Inst.addOperand(MCOperand::createReg(getReg()));
+  }
+
+  void addImmOperands(MCInst &Inst, unsigned N) const {
+    assert(isImm() && "wrong oeprand kind");
+    assert((N == 1) && "can only handle one register operand");
+
+    if (Kind == Kind_Expr) {
+      Inst.addOperand(MCOperand::createExpr(Expr));
+      return;
+    }
+
+    Inst.addOperand(MCOperand::createImm(Imm));
+  }
+
+  static std::unique_ptr<M68kOperand> createToken(StringRef Token, SMLoc Start,
+                                                  SMLoc End) {
+    auto Op = std::make_unique<M68kOperand>(Kind_Token, Start, End);
+    Op->Token = Token;
+    return Op;
+  }
+
+  static std::unique_ptr<M68kOperand> createRegister(unsigned RegNo,
+                                                     SMLoc Start, SMLoc End) {
+    auto Op = std::make_unique<M68kOperand>(Kind_Reg, Start, End);
+    Op->RegNo = RegNo;
+    return Op;
+  }
+
+  // MxImm
+  void addMxImmOperands(MCInst &Inst, unsigned N) const {
+    addImmOperands(Inst, N);
+  }
+  bool isMxImm() const { return isImm(); }
+  static std::unique_ptr<M68kOperand> createImm(int64_t Imm, SMLoc Start,
+                                                SMLoc End) {
+    auto Op = std::make_unique<M68kOperand>(Kind_Imm, Start, End);
+    Op->Imm = Imm;
+    return Op;
+  }
+  static std::unique_ptr<M68kOperand> createExpr(const MCExpr *Expr,
+                                                 SMLoc Start, SMLoc End) {
+    auto Op = std::make_unique<M68kOperand>(Kind_Expr, Start, End);
+    Op->Expr = Expr;
+    return Op;
+  }
+
+  // Addr
+  void addAddrOperands(MCInst &Inst, unsigned N) const {
+    if (Kind == Kind_AddrExpr) {
+      Inst.addOperand(MCOperand::createExpr(Expr));
+      return;
+    }
+
+    Inst.addOperand(MCOperand::createImm(Imm));
+  }
+  bool isAddr() const { return Kind == Kind_AddrImm || Kind == Kind_AddrExpr; }
+  static std::unique_ptr<M68kOperand> createAddrImm(int64_t Imm, SMLoc Start,
+                                                    SMLoc End) {
+    auto Op = std::make_unique<M68kOperand>(Kind_AddrImm, Start, End);
+    Op->Imm = Imm;
+    return Op;
+  }
+  static std::unique_ptr<M68kOperand> createAddrExpr(const MCExpr *Expr,
+                                                     SMLoc Start, SMLoc End) {
+    auto Op = std::make_unique<M68kOperand>(Kind_AddrExpr, Start, End);
+    Op->Expr = Expr;
+    return Op;
+  }
+
+  // ARI
+  void addARIOperands(MCInst &Inst, unsigned N) const {
+    Inst.addOperand(MCOperand::createReg(Mem.RegNo));
+  }
+  bool isARI() const { return Kind == Kind_ARI; }
+  static std::unique_ptr<M68kOperand> createARI(unsigned RegNo, SMLoc Start,
+                                                SMLoc End) {
+    auto Op = std::make_unique<M68kOperand>(Kind_ARI, Start, End);
+    Op->Mem.RegNo = RegNo;
+    return Op;
+  }
+
+  // ARID
+  void addARIDOperands(MCInst &Inst, unsigned N) const {
+    Inst.addOperand(MCOperand::createImm(Mem.Displacement));
+    Inst.addOperand(MCOperand::createReg(Mem.RegNo));
+  }
+  bool isARID() const { return Kind == Kind_ARID; }
+  static std::unique_ptr<M68kOperand>
+  createARID(unsigned RegNo, int64_t Displacement, SMLoc Start, SMLoc End) {
+    auto Op = std::make_unique<M68kOperand>(Kind_ARID, Start, End);
+    Op->Mem.RegNo = RegNo;
+    Op->Mem.Displacement = Displacement;
+    return Op;
+  }
+
+  // ARII
+  void addARIIOperands(MCInst &Inst, unsigned N) const {
+    Inst.addOperand(MCOperand::createImm(Mem.Displacement));
+    Inst.addOperand(MCOperand::createReg(Mem.RegNo));
+    Inst.addOperand(MCOperand::createReg(Mem.Index));
+  }
+  bool isARII() const { return Kind == Kind_ARII; }
+  static std::unique_ptr<M68kOperand> createARII(unsigned RegNo,
+                                                 int64_t Displacement,
+                                                 unsigned IndexReg, SMLoc Start,
+                                                 SMLoc End) {
+    auto Op = std::make_unique<M68kOperand>(Kind_ARII, Start, End);
+    Op->Mem.RegNo = RegNo;
+    Op->Mem.Displacement = Displacement;
+    Op->Mem.Index = IndexReg;
+    return Op;
+  }
+
+  // ARIPD
+  void addARIPDOperands(MCInst &Inst, unsigned N) const {
+    Inst.addOperand(MCOperand::createReg(Mem.RegNo));
+  }
+  bool isARIPD() const { return Kind == Kind_ARIPD; }
+  static std::unique_ptr<M68kOperand> createARIPD(unsigned RegNo, SMLoc Start,
+                                                  SMLoc End) {
+    auto Op = std::make_unique<M68kOperand>(Kind_ARIPD, Start, End);
+    Op->Mem.RegNo = RegNo;
+    return Op;
+  }
+
+  // ARIPI
+  void addARIPIOperands(MCInst &Inst, unsigned N) const {
+    Inst.addOperand(MCOperand::createReg(Mem.RegNo));
+  }
+  bool isARIPI() const { return Kind == Kind_ARIPI; }
+  static std::unique_ptr<M68kOperand> createARIPI(unsigned RegNo, SMLoc Start,
+                                                  SMLoc End) {
+    auto Op = std::make_unique<M68kOperand>(Kind_ARIPI, Start, End);
+    Op->Mem.RegNo = RegNo;
+    return Op;
+  }
+
+  // PCD
+  void addPCDOperands(MCInst &Inst, unsigned N) const {
+    Inst.addOperand(MCOperand::createImm(Mem.Displacement));
+  }
+  bool isPCD() const { return Kind == Kind_PCD; }
+  static std::unique_ptr<M68kOperand> createPCD(int64_t Displacement,
+                                                SMLoc Start, SMLoc End) {
+    auto Op = std::make_unique<M68kOperand>(Kind_PCD, Start, End);
+    Op->Mem.Displacement = Displacement;
+    return Op;
+  }
+
+  // PCI
+  void addPCIOperands(MCInst &Inst, unsigned N) const {
+    Inst.addOperand(MCOperand::createImm(Mem.Displacement));
+    Inst.addOperand(MCOperand::createReg(Mem.RegNo));
+  }
+  bool isPCI() const { return Kind == Kind_PCI; }
+  static std::unique_ptr<M68kOperand>
+  createPCI(unsigned RegNo, int64_t Displacement, SMLoc Start, SMLoc End) {
+    auto Op = std::make_unique<M68kOperand>(Kind_PCI, Start, End);
+    Op->Mem.RegNo = RegNo;
+    Op->Mem.Displacement = Displacement;
+    return Op;
+  }
+};
+
+} // end anonymous namespace.
+
+extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeM68kAsmParser() {
+  RegisterMCAsmParser<M68kAsmParser> X(getTheM68kTarget());
+}
+
+#define GET_MATCHER_IMPLEMENTATION
+#include "M68kGenAsmMatcher.inc"
+
+static inline bool checkRegisterClass(unsigned RegNo, bool Data, bool Address,
+                                      bool SP) {
+  switch (RegNo) {
+  case M68k::A0:
+  case M68k::A1:
+  case M68k::A2:
+  case M68k::A3:
+  case M68k::A4:
+  case M68k::A5:
+  case M68k::A6:
+    return Address;
+
+  case M68k::SP:
+    return SP;
+
+  case M68k::D0:
+  case M68k::D1:
+  case M68k::D2:
+  case M68k::D3:
+  case M68k::D4:
+  case M68k::D5:
+  case M68k::D6:
+  case M68k::D7:
+    return Data;
+
+  case M68k::SR:
+  case M68k::CCR:
+    return false;
+
+  default:
+    llvm_unreachable("unexpected register type");
+    return false;
+  }
+}
+
+unsigned M68kAsmParser::validateTargetOperandClass(MCParsedAsmOperand &Op,
+                                                   unsigned Kind) {
+  M68kOperand &Operand = (M68kOperand &)Op;
+
+  switch (Kind) {
+  case MCK_XR16:
+  case MCK_SPILL:
+    if (Operand.isReg() &&
+        checkRegisterClass(Operand.getReg(), true, true, true)) {
+      return Match_Success;
+    }
+    break;
+
+  case MCK_AR16:
+  case MCK_AR32:
+    if (Operand.isReg() &&
+        checkRegisterClass(Operand.getReg(), false, true, true)) {
+      return Match_Success;
+    }
+    break;
+
+  case MCK_AR32_NOSP:
+    if (Operand.isReg() &&
+        checkRegisterClass(Operand.getReg(), false, true, false)) {
+      return Match_Success;
+    }
+    break;
+
+  case MCK_DR8:
+  case MCK_DR16:
+  case MCK_DR32:
+    if (Operand.isReg() &&
+        checkRegisterClass(Operand.getReg(), true, false, false)) {
+      return Match_Success;
+    }
+    break;
+
+  case MCK_AR16_TC:
+    if (Operand.isReg() &&
+        ((Operand.getReg() == M68k::A0) || (Operand.getReg() == M68k::A1))) {
+      return Match_Success;
+    }
+    break;
+
+  case MCK_DR16_TC:
+    if (Operand.isReg() &&
+        ((Operand.getReg() == M68k::D0) || (Operand.getReg() == M68k::D1))) {
+      return Match_Success;
+    }
+    break;
+
+  case MCK_XR16_TC:
+    if (Operand.isReg() &&
+        ((Operand.getReg() == M68k::D0) || (Operand.getReg() == M68k::D1) ||
+         (Operand.getReg() == M68k::A0) || (Operand.getReg() == M68k::A1))) {
+      return Match_Success;
+    }
+    break;
+  }
+
+  return Match_InvalidOperand;
+}
+
+bool M68kAsmParser::parseRegisterName(unsigned &RegNo, SMLoc Loc,
+                                      StringRef RegisterName) {
+  auto RegisterNameLower = RegisterName.lower();
+
+  // Parse simple general-purpose registers.
+  if (RegisterNameLower.size() == 2) {
+    static unsigned RegistersByIndex[] = {
+        M68k::D0, M68k::D1, M68k::D2, M68k::D3, M68k::D4, M68k::D5,
+        M68k::D6, M68k::D7, M68k::A0, M68k::A1, M68k::A2, M68k::A3,
+        M68k::A4, M68k::A5, M68k::A6, M68k::SP,
+    };
+
+    switch (RegisterNameLower[0]) {
+    case 'd':
+    case 'a': {
+      if (isdigit(RegisterNameLower[1])) {
+        unsigned IndexOffset = (RegisterNameLower[0] == 'a') ? 8 : 0;
+        unsigned RegIndex = (unsigned)(RegisterNameLower[1] - '0');
+        if (RegIndex < 8) {
+          RegNo = RegistersByIndex[IndexOffset + RegIndex];
+          return true;
+        }
+      }
+      break;
+    }
+
+    case 'c':
+      if (RegisterNameLower[1] == 'c' && RegisterNameLower[2] == 'r') {
+        RegNo = M68k::CCR;
+        return true;
+      }
+      break;
+
+    case 's':
+      if (RegisterNameLower[1] == 'p') {
+        RegNo = M68k::SP;
+        return true;
+      } else if (RegisterNameLower[1] == 'r') {
+        RegNo = M68k::SR;
+        return true;
+      }
+      break;
+
+    case 'p':
+      if (RegisterNameLower[1] == 'c') {
+        RegNo = M68k::PC;
+        return true;
+      }
+      break;
+    }
+  }
+
+  return false;
+}
+
+OperandMatchResultTy M68kAsmParser::parseRegister(unsigned &RegNo) {
+  if (!Parser.getTok().is(AsmToken::Identifier)) {
+    return MatchOperand_NoMatch;
+  }
+
+  auto RegisterName = Parser.getTok().getString();
+  if (!parseRegisterName(RegNo, Parser.getLexer().getLoc(), RegisterName)) {
+    return MatchOperand_NoMatch;
+  }
+
+  Parser.Lex();
+  return MatchOperand_Success;
+}
+
+bool M68kAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+                                  SMLoc &EndLoc) {
+  auto Result = tryParseRegister(RegNo, StartLoc, EndLoc);
+  if (Result != MatchOperand_Success) {
+    return Error(StartLoc, "expected register");
+  }
+
+  return false;
+}
+
+OperandMatchResultTy M68kAsmParser::tryParseRegister(unsigned &RegNo,
+                                                     SMLoc &StartLoc,
+                                                     SMLoc &EndLoc) {
+  StartLoc = getLexer().getLoc();
+  auto Result = parseRegister(RegNo);
+  EndLoc = getLexer().getLoc();
+  return Result;
+}
+
+OperandMatchResultTy M68kAsmParser::parseMxImm(OperandVector &Operands) {
+  if (getLexer().isNot(AsmToken::Hash)) {
+    return MatchOperand_NoMatch;
+  }
+  SMLoc Start = getLexer().getLoc();
+  Parser.Lex();
+
+  SMLoc End;
+  const MCExpr *Expr;
+
+  if (parsePrimaryExpr(Expr, End)) {
+    return MatchOperand_ParseFail;
+  }
+
+  Operands.push_back(M68kOperand::createExpr(Expr, Start, End));
+  return MatchOperand_Success;
+}
+
+OperandMatchResultTy M68kAsmParser::parseAddr(OperandVector &Operands) {
+  SMLoc Start = getLexer().getLoc();
+  SMLoc End;
+  const MCExpr *Expr;
+
+  const AsmToken &Tok = getLexer().getTok();
+  if (Tok.isNot(AsmToken::Identifier) && Tok.isNot(AsmToken::Integer)) {
+    return MatchOperand_NoMatch;
+  }
+
+  if (parsePrimaryExpr(Expr, End)) {
+    return MatchOperand_ParseFail;
+  }
+
+  Operands.push_back(M68kOperand::createAddrExpr(Expr, Start, End));
+  return MatchOperand_Success;
+}
+
+OperandMatchResultTy M68kAsmParser::parseARI(OperandVector &Operands) {
+  return parseMemOp(Operands);
+}
+
+OperandMatchResultTy M68kAsmParser::parseARID(OperandVector &Operands) {
+  return parseMemOp(Operands);
+}
+
+OperandMatchResultTy M68kAsmParser::parseARII(OperandVector &Operands) {
+  return parseMemOp(Operands);
+}
+
+OperandMatchResultTy M68kAsmParser::parseARIPD(OperandVector &Operands) {
+  return parseMemOp(Operands);
+}
+
+OperandMatchResultTy M68kAsmParser::parseARIPI(OperandVector &Operands) {
+  return parseMemOp(Operands);
+}
+
+OperandMatchResultTy M68kAsmParser::parsePCD(OperandVector &Operands) {
+  return parseMemOp(Operands);
+}
+
+OperandMatchResultTy M68kAsmParser::parsePCI(OperandVector &Operands) {
+  return parseMemOp(Operands);
+}
+
+OperandMatchResultTy M68kAsmParser::parseMemOp(OperandVector &Operands) {
+  SMLoc Start = getLexer().getLoc();
+  bool IsPD = false;
+  unsigned RegNo;
+
+  // Try plain register, eg. D0.
+  auto Result = parseRegister(RegNo);
+  if (Result == MatchOperand_Success) {
+    Operands.push_back(
+        M68kOperand::createRegister(RegNo, Start, getLexer().getLoc()));
+    return MatchOperand_Success;
+  }
+
+  if (Result == MatchOperand_ParseFail) {
+    return Result;
+  }
+
+  // Check for pre-decrement.
+  if (getLexer().is(AsmToken::Minus)) {
+    Parser.Lex();
+    IsPD = true;
+  }
+
+  if (getLexer().isNot(AsmToken::LParen)) {
+    if (IsPD) {
+      Error(getLexer().getLoc(), "unexpected token parsing expression");
+      return MatchOperand_ParseFail;
+    }
+
+    return MatchOperand_NoMatch;
+  }
+  Parser.Lex();
+
+  // Check for Displacement
+  bool HasDisplacement = false;
+  int64_t Displacement = 0;
+  if (getLexer().is(AsmToken::Integer)) {
+    if (Parser.parseIntToken(Displacement,
+                             "unexpected token in displacement")) {
+      return MatchOperand_ParseFail;
+    }
+    Parser.Lex();
+
+    if (getLexer().isNot(AsmToken::Comma)) {
+      Error(getLexer().getLoc(), "expected comma");
+      return MatchOperand_ParseFail;
+    }
+
+    HasDisplacement = true;
+  }
+
+  Result = parseRegister(RegNo);
+  if (Result == MatchOperand_ParseFail) {
+    return MatchOperand_ParseFail;
+  }
+
+  if (Result != MatchOperand_Success) {
+    Error(getLexer().getLoc(), "expected register");
+    return MatchOperand_ParseFail;
+  }
+
+  // Check for Index.
+  bool HasIndex = false;
+  unsigned IndexRegNo;
+  if (Parser.getTok().is(AsmToken::Comma)) {
+    Parser.Lex();
+
+    Result = parseRegister(IndexRegNo);
+    if (Result == MatchOperand_ParseFail) {
+      return Result;
+    }
+
+    if (Result == MatchOperand_NoMatch) {
+      Error(getLexer().getLoc(), "expected register");
+      return MatchOperand_ParseFail;
+    }
+
+    HasIndex = true;
+  }
+
+  if (Parser.getTok().isNot(AsmToken::RParen)) {
+    Error(getLexer().getLoc(), "expected )");
+    return MatchOperand_ParseFail;
+  }
+  Parser.Lex();
+
+  bool IsPI = false;
+  if (Parser.getTok().is(AsmToken::Plus)) {
+    Parser.Lex();
+    IsPI = true;
+  }
+
+  SMLoc End = getLexer().getLoc();
+
+  if (RegNo == M68k::PC) {
+    if (HasIndex) {
+      Operands.push_back(M68kOperand::createPCD(Displacement, Start, End));
+    } else {
+      Operands.push_back(
+          M68kOperand::createPCI(IndexRegNo, Displacement, Start, End));
+    }
+    return MatchOperand_Success;
+  }
+
+  unsigned OpCount = IsPD + IsPI + (HasIndex || HasDisplacement);
+  if (OpCount > 1) {
+    Error(Start, "only one of post-increment, pre-decrement or displacement "
+                 "can be used");
+    return MatchOperand_ParseFail;
+  }
+
+  if (IsPD) {
+    Operands.push_back(M68kOperand::createARIPD(RegNo, Start, End));
+  } else if (IsPI) {
+    Operands.push_back(M68kOperand::createARIPI(RegNo, Start, End));
+  } else if (HasIndex) {
+    Operands.push_back(
+        M68kOperand::createARII(RegNo, Displacement, IndexRegNo, Start, End));
+  } else if (HasDisplacement) {
+    Operands.push_back(
+        M68kOperand::createARID(RegNo, Displacement, Start, End));
+  } else {
+    Operands.push_back(M68kOperand::createARI(RegNo, Start, End));
+  }
+  return MatchOperand_Success;
+}
+
+void M68kAsmParser::eatComma() {
+  if (Parser.getTok().is(AsmToken::Comma)) {
+    Parser.Lex();
+  }
+}
+
+bool M68kAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
+                                     SMLoc NameLoc, OperandVector &Operands) {
+  SMLoc Start = getLexer().getLoc();
+  Operands.push_back(M68kOperand::createToken(Name, Start, Start));
+
+  bool First = true;
+  while (Parser.getTok().isNot(AsmToken::EndOfStatement)) {
+    if (!First) {
+      eatComma();
+    } else {
+      First = false;
+    }
+
+    auto MatchResult = MatchOperandParserImpl(Operands, Name);
+    if (MatchResult == MatchOperand_Success) {
+      continue;
+    }
+
+    // Add custom operand formats here...
+    SMLoc Loc = getLexer().getLoc();
+    Parser.eatToEndOfStatement();
+    return Error(Loc, "unexpected token parsing operands");
+  }
+
+  // Eat EndOfStatement.
+  Parser.Lex();
+  return false;
+}
+
+bool M68kAsmParser::ParseDirective(AsmToken DirectiveID) { return true; }
+
+bool M68kAsmParser::invalidOperand(SMLoc const &Loc,
+                                   OperandVector const &Operands,
+                                   uint64_t const &ErrorInfo) {
+  SMLoc ErrorLoc = Loc;
+  char const *Diag = 0;
+
+  if (ErrorInfo != ~0U) {
+    if (ErrorInfo >= Operands.size()) {
+      Diag = "too few operands for instruction.";
+    } else {
+      auto const &Op = (M68kOperand const &)*Operands[ErrorInfo];
+      if (Op.getStartLoc() != SMLoc()) {
+        ErrorLoc = Op.getStartLoc();
+      }
+    }
+  }
+
+  if (!Diag) {
+    Diag = "invalid operand for instruction";
+  }
+
+  return Error(ErrorLoc, Diag);
+}
+
+bool M68kAsmParser::missingFeature(llvm::SMLoc const &Loc,
+                                   uint64_t const &ErrorInfo) {
+  return Error(Loc, "instruction requires a CPU feature not currently enabled");
+}
+
+bool M68kAsmParser::emit(MCInst &Inst, SMLoc const &Loc,
+                         MCStreamer &Out) const {
+  Inst.setLoc(Loc);
+  Out.emitInstruction(Inst, STI);
+
+  return false;
+}
+
+bool M68kAsmParser::MatchAndEmitInstruction(SMLoc Loc, unsigned &Opcode,
+                                            OperandVector &Operands,
+                                            MCStreamer &Out,
+                                            uint64_t &ErrorInfo,
+                                            bool MatchingInlineAsm) {
+  MCInst Inst;
+  unsigned MatchResult =
+      MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm);
+
+  switch (MatchResult) {
+  case Match_Success:
+    return emit(Inst, Loc, Out);
+  case Match_MissingFeature:
+    return missingFeature(Loc, ErrorInfo);
+  case Match_InvalidOperand:
+    return invalidOperand(Loc, Operands, ErrorInfo);
+  case Match_MnemonicFail:
+    return Error(Loc, "invalid instruction");
+  default:
+    return true;
+  }
+}
+
+void M68kOperand::print(raw_ostream &OS) const {
+  switch (Kind) {
+  case Kind_Invalid:
+    OS << "invalid";
+    break;
+
+  case Kind_Token:
+    OS << "token '" << Token << "'";
+    break;
+
+  case Kind_Reg:
+    OS << "register " << RegNo;
+    break;
+
+  case Kind_Imm:
+    OS << "immediate " << Imm;
+    break;
+
+  case Kind_Expr:
+    OS << "expression " << Expr->getKind();
+    break;
+
+  case Kind_AddrImm:
+    OS << "addr imm " << Imm;
+    break;
+
+  case Kind_AddrExpr:
+    OS << "addr expr " << Expr->getKind();
+    break;
+
+  case Kind_ARI:
+    OS << "(" << Mem.RegNo << ")";
+    break;
+
+  case Kind_ARID:
+    OS << "(" << Mem.Displacement << "," << Mem.RegNo << ")";
+    break;
+
+  case Kind_ARII:
+    OS << "(" << Mem.Displacement << "," << Mem.RegNo << "," << Mem.Index
+       << ")";
+    break;
+
+  case Kind_ARIPD:
+    OS << "-(" << Mem.RegNo << ")";
+    break;
+
+  case Kind_ARIPI:
+    OS << "(" << Mem.RegNo << ")+";
+    break;
+
+  case Kind_PCD:
+    OS << "(" << Mem.Displacement << ",pc)";
+    break;
+
+  case Kind_PCI:
+    OS << "(" << Mem.Displacement << ",pc," << Mem.Index << ")";
+    break;
+
+  default:
+    llvm_unreachable("unhandled operand kind");
+  }
+}

llvm/lib/Target/M68k/CMakeLists.txt

 add_llvm_component_group(M68k)
 
 set(LLVM_TARGET_DEFINITIONS M68k.td)
 
 tablegen(LLVM M68kGenRegisterInfo.inc     -gen-register-info)
 tablegen(LLVM M68kGenInstrInfo.inc        -gen-instr-info)
 tablegen(LLVM M68kGenSubtargetInfo.inc    -gen-subtarget)
 tablegen(LLVM M68kGenMCCodeBeads.inc      -gen-code-beads)
 tablegen(LLVM M68kGenMCPseudoLowering.inc -gen-pseudo-lowering)
 tablegen(LLVM M68kGenDAGISel.inc          -gen-dag-isel)
 tablegen(LLVM M68kGenCallingConv.inc      -gen-callingconv)
 tablegen(LLVM M68kGenAsmWriter.inc        -gen-asm-writer)
+tablegen(LLVM M68kGenAsmMatcher.inc       -gen-asm-matcher)
 
 add_public_tablegen_target(M68kCommonTableGen)
 
 add_llvm_target(M68kCodeGen
   M68kAsmPrinter.cpp
   M68kCollapseMOVEMPass.cpp
   M68kExpandPseudo.cpp
   M68kFrameLowering.cpp
add_llvm_target(M68kCodeGen
   M68kInfo
 
   ADD_TO_COMPONENT
   M68k
 )
 
 add_subdirectory(TargetInfo)
 add_subdirectory(MCTargetDesc)
+add_subdirectory(AsmParser)

llvm/lib/Target/M68k/M68k.td

 def M68kInstrInfo : InstrInfo;
 
 //===----------------------------------------------------------------------===//
 // Calling Conventions
 //===----------------------------------------------------------------------===//
 
 include "M68kCallingConv.td"
 
+//===---------------------------------------------------------------------===//
+// Assembly Printers
+//===---------------------------------------------------------------------===//
+
+def M68kAsmWriter : AsmWriter {
+ string AsmWriterClassName = "InstPrinter";
+ bit isMCAsmWriter = 1;
+}
+
+//===---------------------------------------------------------------------===//
+// Assembly Parsers
+//===---------------------------------------------------------------------===//
+
+def M68kAsmParser : AsmParser {
+  let ShouldEmitMatchRegisterName = 0;
+  let ShouldEmitMatchRegisterAltName = 0;
+}
+
+def M68kAsmParserVariant : AsmParserVariant {
+  int Variant = 0;
+}
+
 //===----------------------------------------------------------------------===//
 // Target
 //===----------------------------------------------------------------------===//
 
 def M68k : Target {
   let InstructionSet = M68kInstrInfo;
+  let AssemblyParsers = [M68kAsmParser];
+  let AssemblyWriters = [M68kAsmWriter];
 }

llvm/lib/Target/M68k/M68kInstrInfo.td

 def MxARD16 : MxRegOp<i16, AR16, MxSize16, "a">;
 def MxARD32 : MxRegOp<i32, AR32, MxSize32, "a">;
 
 def MxARD16_TC : MxRegOp<i16, AR16_TC, MxSize16, "a">;
 def MxARD32_TC : MxRegOp<i32, AR32_TC, MxSize32, "a">;
 
 class MxOpClass<string name> : AsmOperandClass {
   let Name = name;
+  let ParserMethod = "parse"#name;
 }
 
 class MxMemOp<dag ops, MxSize size, string letter,
               string printMethod = "printOperand",
-              AsmOperandClass parserMatchClass = MxMemAsmOperand>
+              AsmOperandClass parserMatchClass = ImmAsmOperand>
     : Operand<iPTR>, MxOperand<iPTR, size, letter, ?> {
   let PrintMethod = printMethod;
   let MIOperandInfo = ops;
   let ParserMatchClass = parserMatchClass;
   let OperandType = "OPERAND_MEMORY";
 }
 
 // ADDRESS REGISTER INDIRECT. The address of the operand is in the address

 def MxPCI16  : MxMemOp<(ops i8imm, XR32), MxSize16, "k", "printPCI16Mem", MxPCI>;
 def MxPCI32  : MxMemOp<(ops i8imm, XR32), MxSize32, "k", "printPCI32Mem", MxPCI>;
 } // OPERAND_PCREL
 
 def MxImm : MxOpClass<"MxImm">;
 
 class MxOp<ValueType vt, MxSize size, string letter>
     : Operand<vt>,
-      MxOperand<vt, size, letter, ?>;
+      MxOperand<vt, size, letter, ?> {
+  let ParserMatchClass = MxImm;
+}
 
 let OperandType = "OPERAND_IMMEDIATE",
     PrintMethod = "printImmediate" in {
 // IMMEDIATE DATA. This addressing mode requires either one or two words of
 // extension depending on the size of the operation.
 //     Byte Operation - operand is low order byte of extension word
 //     Word Operation - operand is extension word
 //     Long Word Operation - operand is in the two extension words,
 //                           high order 16 bits are in the first
 //                           extension word, low order 16 bits are
 //                           in the second extension word.
 def Mxi8imm  : MxOp<i8,  MxSize8,  "i">;
 def Mxi16imm : MxOp<i16, MxSize16, "i">;
 def Mxi32imm : MxOp<i32, MxSize32, "i">;
 } // OPERAND_IMMEDIATE
 
 let OperandType = "OPERAND_PCREL",
+    ParserMatchClass = MxImm,
     PrintMethod = "printPCRelImm" in {
 
 // Branch targets have OtherVT type and print as pc-relative values.
 def MxBrTarget8  : Operand<OtherVT>;
 def MxBrTarget16 : Operand<OtherVT>;
 def MxBrTarget32 : Operand<OtherVT>;
 
 } // OPERAND_PCREL

llvm/lib/Target/M68k/MCTargetDesc/M68kMCAsmInfo.cpp

M68kELFMCAsmInfo::M68kELFMCAsmInfo(const Triple &T) {
   IsLittleEndian = false;
 
   // Debug Information
   SupportsDebugInformation = true;
 
   // Exceptions handling
   ExceptionsType = ExceptionHandling::DwarfCFI;
 
+  UseMotorolaIntegers = true;
   CommentString = ";";
 }