llvm/lib/Target/MSP430/AsmParser/MSP430AsmParser.cpp

   1 //===- MSP430AsmParser.cpp - Parse MSP430 assembly to MCInst instructions -===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "MSP430.h"
  10 #include "MSP430RegisterInfo.h"
  11 #include "MCTargetDesc/MSP430MCTargetDesc.h"
  12 #include "TargetInfo/MSP430TargetInfo.h"
  13
  14 #include "llvm/ADT/APInt.h"
  15 #include "llvm/MC/MCContext.h"
  16 #include "llvm/MC/MCExpr.h"
  17 #include "llvm/MC/MCInst.h"
  18 #include "llvm/MC/MCInstBuilder.h"
  19 #include "llvm/MC/MCParser/MCAsmLexer.h"
  20 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  21 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
  22 #include "llvm/MC/MCStreamer.h"
  23 #include "llvm/MC/MCSubtargetInfo.h"
  24 #include "llvm/MC/MCSymbol.h"
  25 #include "llvm/MC/MCValue.h"
  26 #include "llvm/Support/Debug.h"
  27 #include "llvm/Support/MathExtras.h"
  28 #include "llvm/Support/TargetRegistry.h"
  29
  30 #define DEBUG_TYPE "msp430-asm-parser"
  31
  32 using namespace llvm;
  33
  34 namespace {
  35
  36 /// Parses MSP430 assembly from a stream.
  37 class MSP430AsmParser : public MCTargetAsmParser {
  38   const MCSubtargetInfo &STI;
  39   MCAsmParser &Parser;
  40   const MCRegisterInfo *MRI;
  41
  42   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
  43                                OperandVector &Operands, MCStreamer &Out,
  44                                uint64_t &ErrorInfo,
  45                                bool MatchingInlineAsm) override;
  46
  47   bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
  48   OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
  49                                         SMLoc &EndLoc) override;
  50
  51   bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
  52                         SMLoc NameLoc, OperandVector &Operands) override;
  53
  54   bool ParseDirective(AsmToken DirectiveID) override;
  55   bool ParseDirectiveRefSym(AsmToken DirectiveID);
  56
  57   unsigned validateTargetOperandClass(MCParsedAsmOperand &Op,
  58                                       unsigned Kind) override;
  59
  60   bool parseJccInstruction(ParseInstructionInfo &Info, StringRef Name,
  61                            SMLoc NameLoc, OperandVector &Operands);
  62
  63   bool ParseOperand(OperandVector &Operands);
  64
  65   bool ParseLiteralValues(unsigned Size, SMLoc L);
  66
  67   MCAsmParser &getParser() const { return Parser; }
  68   MCAsmLexer &getLexer() const { return Parser.getLexer(); }
  69
  70   /// @name Auto-generated Matcher Functions
  71   /// {
  72
  73 #define GET_ASSEMBLER_HEADER
  74 #include "MSP430GenAsmMatcher.inc"
  75
  76   /// }
  77
  78 public:
  79   MSP430AsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser,
  80                   const MCInstrInfo &MII, const MCTargetOptions &Options)
  81       : MCTargetAsmParser(Options, STI, MII), STI(STI), Parser(Parser) {
  82     MCAsmParserExtension::Initialize(Parser);
  83     MRI = getContext().getRegisterInfo();
  84
  85     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
  86   }
  87 };
  88
  89 /// A parsed MSP430 assembly operand.
  90 class MSP430Operand : public MCParsedAsmOperand {
  91   typedef MCParsedAsmOperand Base;
  92
  93   enum KindTy {
  94     k_Imm,
  95     k_Reg,
  96     k_Tok,
  97     k_Mem,
  98     k_IndReg,
  99     k_PostIndReg
 100   } Kind;
 101
 102   struct Memory {
 103     unsigned Reg;
 104     const MCExpr *Offset;
 105   };
 106   union {
 107     const MCExpr *Imm;
 108     unsigned      Reg;
 109     StringRef     Tok;
 110     Memory        Mem;
 111   };
 112
 113   SMLoc Start, End;
 114
 115 public:
 116   MSP430Operand(StringRef Tok, SMLoc const &S)
 117       : Base(), Kind(k_Tok), Tok(Tok), Start(S), End(S) {}
 118   MSP430Operand(KindTy Kind, unsigned Reg, SMLoc const &S, SMLoc const &E)
 119       : Base(), Kind(Kind), Reg(Reg), Start(S), End(E) {}
 120   MSP430Operand(MCExpr const *Imm, SMLoc const &S, SMLoc const &E)
 121       : Base(), Kind(k_Imm), Imm(Imm), Start(S), End(E) {}
 122   MSP430Operand(unsigned Reg, MCExpr const *Expr, SMLoc const &S, SMLoc const &E)
 123       : Base(), Kind(k_Mem), Mem({Reg, Expr}), Start(S), End(E) {}
 124
 125   void addRegOperands(MCInst &Inst, unsigned N) const {
 126     assert((Kind == k_Reg || Kind == k_IndReg || Kind == k_PostIndReg) &&
 127         "Unexpected operand kind");
 128     assert(N == 1 && "Invalid number of operands!");
 129
 130     Inst.addOperand(MCOperand::createReg(Reg));
 131   }
 132
 133   void addExprOperand(MCInst &Inst, const MCExpr *Expr) const {
 134     // Add as immediate when possible
 135     if (!Expr)
 136       Inst.addOperand(MCOperand::createImm(0));
 137     else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
 138       Inst.addOperand(MCOperand::createImm(CE->getValue()));
 139     else
 140       Inst.addOperand(MCOperand::createExpr(Expr));
 141   }
 142
 143   void addImmOperands(MCInst &Inst, unsigned N) const {
 144     assert(Kind == k_Imm && "Unexpected operand kind");
 145     assert(N == 1 && "Invalid number of operands!");
 146
 147     addExprOperand(Inst, Imm);
 148   }
 149
 150   void addMemOperands(MCInst &Inst, unsigned N) const {
 151     assert(Kind == k_Mem && "Unexpected operand kind");
 152     assert(N == 2 && "Invalid number of operands");
 153
 154     Inst.addOperand(MCOperand::createReg(Mem.Reg));
 155     addExprOperand(Inst, Mem.Offset);
 156   }
 157
 158   bool isReg()   const override { return Kind == k_Reg; }
 159   bool isImm()   const override { return Kind == k_Imm; }
 160   bool isToken() const override { return Kind == k_Tok; }
 161   bool isMem()   const override { return Kind == k_Mem; }
 162   bool isIndReg()         const { return Kind == k_IndReg; }
 163   bool isPostIndReg()     const { return Kind == k_PostIndReg; }
 164
 165   bool isCGImm() const {
 166     if (Kind != k_Imm)
 167       return false;
 168
 169     int64_t Val;
 170     if (!Imm->evaluateAsAbsolute(Val))
 171       return false;
 172
 173     if (Val == 0 || Val == 1 || Val == 2 || Val == 4 || Val == 8 || Val == -1)
 174       return true;
 175
 176     return false;
 177   }
 178
 179   StringRef getToken() const {
 180     assert(Kind == k_Tok && "Invalid access!");
 181     return Tok;
 182   }
 183
 184   unsigned getReg() const override {
 185     assert(Kind == k_Reg && "Invalid access!");
 186     return Reg;
 187   }
 188
 189   void setReg(unsigned RegNo) {
 190     assert(Kind == k_Reg && "Invalid access!");
 191     Reg = RegNo;
 192   }
 193
 194   static std::unique_ptr<MSP430Operand> CreateToken(StringRef Str, SMLoc S) {
 195     return std::make_unique<MSP430Operand>(Str, S);
 196   }
 197
 198   static std::unique_ptr<MSP430Operand> CreateReg(unsigned RegNum, SMLoc S,
 199                                                   SMLoc E) {
 200     return std::make_unique<MSP430Operand>(k_Reg, RegNum, S, E);
 201   }
 202
 203   static std::unique_ptr<MSP430Operand> CreateImm(const MCExpr *Val, SMLoc S,
 204                                                   SMLoc E) {
 205     return std::make_unique<MSP430Operand>(Val, S, E);
 206   }
 207
 208   static std::unique_ptr<MSP430Operand> CreateMem(unsigned RegNum,
 209                                                   const MCExpr *Val,
 210                                                   SMLoc S, SMLoc E) {
 211     return std::make_unique<MSP430Operand>(RegNum, Val, S, E);
 212   }
 213
 214   static std::unique_ptr<MSP430Operand> CreateIndReg(unsigned RegNum, SMLoc S,
 215                                                   SMLoc E) {
 216     return std::make_unique<MSP430Operand>(k_IndReg, RegNum, S, E);
 217   }
 218
 219   static std::unique_ptr<MSP430Operand> CreatePostIndReg(unsigned RegNum, SMLoc S,
 220                                                   SMLoc E) {
 221     return std::make_unique<MSP430Operand>(k_PostIndReg, RegNum, S, E);
 222   }
 223
 224   SMLoc getStartLoc() const override { return Start; }
 225   SMLoc getEndLoc() const override { return End; }
 226
 227   void print(raw_ostream &O) const override {
 228     switch (Kind) {
 229     case k_Tok:
 230       O << "Token " << Tok;
 231       break;
 232     case k_Reg:
 233       O << "Register " << Reg;
 234       break;
 235     case k_Imm:
 236       O << "Immediate " << *Imm;
 237       break;
 238     case k_Mem:
 239       O << "Memory ";
 240       O << *Mem.Offset << "(" << Reg << ")";
 241       break;
 242     case k_IndReg:
 243       O << "RegInd " << Reg;
 244       break;
 245     case k_PostIndReg:
 246       O << "PostInc " << Reg;
 247       break;
 248     }
 249   }
 250 };
 251 } // end anonymous namespace
 252
 253 bool MSP430AsmParser::MatchAndEmitInstruction(SMLoc Loc, unsigned &Opcode,
 254                                               OperandVector &Operands,
 255                                               MCStreamer &Out,
 256                                               uint64_t &ErrorInfo,
 257                                               bool MatchingInlineAsm) {
 258   MCInst Inst;
 259   unsigned MatchResult =
 260       MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm);
 261
 262   switch (MatchResult) {
 263   case Match_Success:
 264     Inst.setLoc(Loc);
 265     Out.emitInstruction(Inst, STI);
 266     return false;
 267   case Match_MnemonicFail:
 268     return Error(Loc, "invalid instruction mnemonic");
 269   case Match_InvalidOperand: {
 270     SMLoc ErrorLoc = Loc;
 271     if (ErrorInfo != ~0U) {
 272       if (ErrorInfo >= Operands.size())
 273         return Error(ErrorLoc, "too few operands for instruction");
 274
 275       ErrorLoc = ((MSP430Operand &)*Operands[ErrorInfo]).getStartLoc();
 276       if (ErrorLoc == SMLoc())
 277         ErrorLoc = Loc;
 278     }
 279     return Error(ErrorLoc, "invalid operand for instruction");
 280   }
 281   default:
 282     return true;
 283   }
 284 }
 285
 286 // Auto-generated by TableGen
 287 static unsigned MatchRegisterName(StringRef Name);
 288 static unsigned MatchRegisterAltName(StringRef Name);
 289
 290 bool MSP430AsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
 291                                     SMLoc &EndLoc) {
 292   switch (tryParseRegister(RegNo, StartLoc, EndLoc)) {
 293   case MatchOperand_ParseFail:
 294     return Error(StartLoc, "invalid register name");
 295   case MatchOperand_Success:
 296     return false;
 297   case MatchOperand_NoMatch:
 298     return true;
 299   }
 300
 301   llvm_unreachable("unknown match result type");
 302 }
 303
 304 OperandMatchResultTy MSP430AsmParser::tryParseRegister(unsigned &RegNo,
 305                                                        SMLoc &StartLoc,
 306                                                        SMLoc &EndLoc) {
 307   if (getLexer().getKind() == AsmToken::Identifier) {
 308     auto Name = getLexer().getTok().getIdentifier().lower();
 309     RegNo = MatchRegisterName(Name);
 310     if (RegNo == MSP430::NoRegister) {
 311       RegNo = MatchRegisterAltName(Name);
 312       if (RegNo == MSP430::NoRegister)
 313         return MatchOperand_NoMatch;
 314     }
 315
 316     AsmToken const &T = getParser().getTok();
 317     StartLoc = T.getLoc();
 318     EndLoc = T.getEndLoc();
 319     getLexer().Lex(); // eat register token
 320
 321     return MatchOperand_Success;
 322   }
 323
 324   return MatchOperand_ParseFail;
 325 }
 326
 327 bool MSP430AsmParser::parseJccInstruction(ParseInstructionInfo &Info,
 328                                           StringRef Name, SMLoc NameLoc,
 329                                           OperandVector &Operands) {
 330   if (!Name.startswith_insensitive("j"))
 331     return true;
 332
 333   auto CC = Name.drop_front().lower();
 334   unsigned CondCode;
 335   if (CC == "ne" || CC == "nz")
 336     CondCode = MSP430CC::COND_NE;
 337   else if (CC == "eq" || CC == "z")
 338     CondCode = MSP430CC::COND_E;
 339   else if (CC == "lo" || CC == "nc")
 340     CondCode = MSP430CC::COND_LO;
 341   else if (CC == "hs" || CC == "c")
 342     CondCode = MSP430CC::COND_HS;
 343   else if (CC == "n")
 344     CondCode = MSP430CC::COND_N;
 345   else if (CC == "ge")
 346     CondCode = MSP430CC::COND_GE;
 347   else if (CC == "l")
 348     CondCode = MSP430CC::COND_L;
 349   else if (CC == "mp")
 350     CondCode = MSP430CC::COND_NONE;
 351   else
 352     return Error(NameLoc, "unknown instruction");
 353
 354   if (CondCode == (unsigned)MSP430CC::COND_NONE)
 355     Operands.push_back(MSP430Operand::CreateToken("jmp", NameLoc));
 356   else {
 357     Operands.push_back(MSP430Operand::CreateToken("j", NameLoc));
 358     const MCExpr *CCode = MCConstantExpr::create(CondCode, getContext());
 359     Operands.push_back(MSP430Operand::CreateImm(CCode, SMLoc(), SMLoc()));
 360   }
 361
 362   // Skip optional '$' sign.
 363   if (getLexer().getKind() == AsmToken::Dollar)
 364     getLexer().Lex(); // Eat '$'
 365
 366   const MCExpr *Val;
 367   SMLoc ExprLoc = getLexer().getLoc();
 368   if (getParser().parseExpression(Val))
 369     return Error(ExprLoc, "expected expression operand");
 370
 371   int64_t Res;
 372   if (Val->evaluateAsAbsolute(Res))
 373     if (Res < -512 || Res > 511)
 374       return Error(ExprLoc, "invalid jump offset");
 375
 376   Operands.push_back(MSP430Operand::CreateImm(Val, ExprLoc,
 377     getLexer().getLoc()));
 378
 379   if (getLexer().isNot(AsmToken::EndOfStatement)) {
 380     SMLoc Loc = getLexer().getLoc();
 381     getParser().eatToEndOfStatement();
 382     return Error(Loc, "unexpected token");
 383   }
 384
 385   getParser().Lex(); // Consume the EndOfStatement.
 386   return false;
 387 }
 388
 389 bool MSP430AsmParser::ParseInstruction(ParseInstructionInfo &Info,
 390                                        StringRef Name, SMLoc NameLoc,
 391                                        OperandVector &Operands) {
 392   // Drop .w suffix
 393   if (Name.endswith_insensitive(".w"))
 394     Name = Name.drop_back(2);
 395
 396   if (!parseJccInstruction(Info, Name, NameLoc, Operands))
 397     return false;
 398
 399   // First operand is instruction mnemonic
 400   Operands.push_back(MSP430Operand::CreateToken(Name, NameLoc));
 401
 402   // If there are no more operands, then finish
 403   if (getLexer().is(AsmToken::EndOfStatement))
 404     return false;
 405
 406   // Parse first operand
 407   if (ParseOperand(Operands))
 408     return true;
 409
 410   // Parse second operand if any
 411   if (getLexer().is(AsmToken::Comma)) {
 412     getLexer().Lex(); // Eat ','
 413     if (ParseOperand(Operands))
 414       return true;
 415   }
 416
 417   if (getLexer().isNot(AsmToken::EndOfStatement)) {
 418     SMLoc Loc = getLexer().getLoc();
 419     getParser().eatToEndOfStatement();
 420     return Error(Loc, "unexpected token");
 421   }
 422
 423   getParser().Lex(); // Consume the EndOfStatement.
 424   return false;
 425 }
 426
 427 bool MSP430AsmParser::ParseDirectiveRefSym(AsmToken DirectiveID) {
 428     StringRef Name;
 429     if (getParser().parseIdentifier(Name))
 430       return TokError("expected identifier in directive");
 431
 432     MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
 433     getStreamer().emitSymbolAttribute(Sym, MCSA_Global);
 434     return false;
 435 }
 436
 437 bool MSP430AsmParser::ParseDirective(AsmToken DirectiveID) {
 438   StringRef IDVal = DirectiveID.getIdentifier();
 439   if (IDVal.lower() == ".long") {
 440     ParseLiteralValues(4, DirectiveID.getLoc());
 441   } else if (IDVal.lower() == ".word" || IDVal.lower() == ".short") {
 442     ParseLiteralValues(2, DirectiveID.getLoc());
 443   } else if (IDVal.lower() == ".byte") {
 444     ParseLiteralValues(1, DirectiveID.getLoc());
 445   } else if (IDVal.lower() == ".refsym") {
 446     return ParseDirectiveRefSym(DirectiveID);
 447   }
 448   return true;
 449 }
 450
 451 bool MSP430AsmParser::ParseOperand(OperandVector &Operands) {
 452   switch (getLexer().getKind()) {
 453     default: return true;
 454     case AsmToken::Identifier: {
 455       // try rN
 456       unsigned RegNo;
 457       SMLoc StartLoc, EndLoc;
 458       if (!ParseRegister(RegNo, StartLoc, EndLoc)) {
 459         Operands.push_back(MSP430Operand::CreateReg(RegNo, StartLoc, EndLoc));
 460         return false;
 461       }
 462       LLVM_FALLTHROUGH;
 463     }
 464     case AsmToken::Integer:
 465     case AsmToken::Plus:
 466     case AsmToken::Minus: {
 467       SMLoc StartLoc = getParser().getTok().getLoc();
 468       const MCExpr *Val;
 469       // Try constexpr[(rN)]
 470       if (!getParser().parseExpression(Val)) {
 471         unsigned RegNo = MSP430::PC;
 472         SMLoc EndLoc = getParser().getTok().getLoc();
 473         // Try (rN)
 474         if (getLexer().getKind() == AsmToken::LParen) {
 475           getLexer().Lex(); // Eat '('
 476           SMLoc RegStartLoc;
 477           if (ParseRegister(RegNo, RegStartLoc, EndLoc))
 478             return true;
 479           if (getLexer().getKind() != AsmToken::RParen)
 480             return true;
 481           EndLoc = getParser().getTok().getEndLoc();
 482           getLexer().Lex(); // Eat ')'
 483         }
 484         Operands.push_back(MSP430Operand::CreateMem(RegNo, Val, StartLoc,
 485           EndLoc));
 486         return false;
 487       }
 488       return true;
 489     }
 490     case AsmToken::Amp: {
 491       // Try &constexpr
 492       SMLoc StartLoc = getParser().getTok().getLoc();
 493       getLexer().Lex(); // Eat '&'
 494       const MCExpr *Val;
 495       if (!getParser().parseExpression(Val)) {
 496         SMLoc EndLoc = getParser().getTok().getLoc();
 497         Operands.push_back(MSP430Operand::CreateMem(MSP430::SR, Val, StartLoc,
 498           EndLoc));
 499         return false;
 500       }
 501       return true;
 502     }
 503     case AsmToken::At: {
 504       // Try @rN[+]
 505       SMLoc StartLoc = getParser().getTok().getLoc();
 506       getLexer().Lex(); // Eat '@'
 507       unsigned RegNo;
 508       SMLoc RegStartLoc, EndLoc;
 509       if (ParseRegister(RegNo, RegStartLoc, EndLoc))
 510         return true;
 511       if (getLexer().getKind() == AsmToken::Plus) {
 512         Operands.push_back(MSP430Operand::CreatePostIndReg(RegNo, StartLoc, EndLoc));
 513         getLexer().Lex(); // Eat '+'
 514         return false;
 515       }
 516       if (Operands.size() > 1) // Emulate @rd in destination position as 0(rd)
 517         Operands.push_back(MSP430Operand::CreateMem(RegNo,
 518             MCConstantExpr::create(0, getContext()), StartLoc, EndLoc));
 519       else
 520         Operands.push_back(MSP430Operand::CreateIndReg(RegNo, StartLoc, EndLoc));
 521       return false;
 522     }
 523     case AsmToken::Hash:
 524       // Try #constexpr
 525       SMLoc StartLoc = getParser().getTok().getLoc();
 526       getLexer().Lex(); // Eat '#'
 527       const MCExpr *Val;
 528       if (!getParser().parseExpression(Val)) {
 529         SMLoc EndLoc = getParser().getTok().getLoc();
 530         Operands.push_back(MSP430Operand::CreateImm(Val, StartLoc, EndLoc));
 531         return false;
 532       }
 533       return true;
 534   }
 535 }
 536
 537 bool MSP430AsmParser::ParseLiteralValues(unsigned Size, SMLoc L) {
 538   auto parseOne = [&]() -> bool {
 539     const MCExpr *Value;
 540     if (getParser().parseExpression(Value))
 541       return true;
 542     getParser().getStreamer().emitValue(Value, Size, L);
 543     return false;
 544   };
 545   return (parseMany(parseOne));
 546 }
 547
 548 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeMSP430AsmParser() {
 549   RegisterMCAsmParser<MSP430AsmParser> X(getTheMSP430Target());
 550 }
 551
 552 #define GET_REGISTER_MATCHER
 553 #define GET_MATCHER_IMPLEMENTATION
 554 #include "MSP430GenAsmMatcher.inc"
 555
 556 static unsigned convertGR16ToGR8(unsigned Reg) {
 557   switch (Reg) {
 558   default:
 559     llvm_unreachable("Unknown GR16 register");
 560   case MSP430::PC:  return MSP430::PCB;
 561   case MSP430::SP:  return MSP430::SPB;
 562   case MSP430::SR:  return MSP430::SRB;
 563   case MSP430::CG:  return MSP430::CGB;
 564   case MSP430::R4:  return MSP430::R4B;
 565   case MSP430::R5:  return MSP430::R5B;
 566   case MSP430::R6:  return MSP430::R6B;
 567   case MSP430::R7:  return MSP430::R7B;
 568   case MSP430::R8:  return MSP430::R8B;
 569   case MSP430::R9:  return MSP430::R9B;
 570   case MSP430::R10: return MSP430::R10B;
 571   case MSP430::R11: return MSP430::R11B;
 572   case MSP430::R12: return MSP430::R12B;
 573   case MSP430::R13: return MSP430::R13B;
 574   case MSP430::R14: return MSP430::R14B;
 575   case MSP430::R15: return MSP430::R15B;
 576   }
 577 }
 578
 579 unsigned MSP430AsmParser::validateTargetOperandClass(MCParsedAsmOperand &AsmOp,
 580                                                      unsigned Kind) {
 581   MSP430Operand &Op = static_cast<MSP430Operand &>(AsmOp);
 582
 583   if (!Op.isReg())
 584     return Match_InvalidOperand;
 585
 586   unsigned Reg = Op.getReg();
 587   bool isGR16 =
 588       MSP430MCRegisterClasses[MSP430::GR16RegClassID].contains(Reg);
 589
 590   if (isGR16 && (Kind == MCK_GR8)) {
 591     Op.setReg(convertGR16ToGR8(Reg));
 592     return Match_Success;
 593   }
 594
 595   return Match_InvalidOperand;
 596 }