lib/Target/Hexagon/AsmParser/HexagonAsmParser.cpp

   1 //===-- HexagonAsmParser.cpp - Parse Hexagon asm to MCInst instructions----===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #define DEBUG_TYPE "mcasmparser"
  11
  12 #include "Hexagon.h"
  13 #include "HexagonRegisterInfo.h"
  14 #include "HexagonTargetStreamer.h"
  15 #include "MCTargetDesc/HexagonBaseInfo.h"
  16 #include "MCTargetDesc/HexagonMCELFStreamer.h"
  17 #include "MCTargetDesc/HexagonMCChecker.h"
  18 #include "MCTargetDesc/HexagonMCExpr.h"
  19 #include "MCTargetDesc/HexagonMCShuffler.h"
  20 #include "MCTargetDesc/HexagonMCTargetDesc.h"
  21 #include "MCTargetDesc/HexagonMCAsmInfo.h"
  22 #include "MCTargetDesc/HexagonShuffler.h"
  23 #include "llvm/ADT/SmallString.h"
  24 #include "llvm/ADT/SmallVector.h"
  25 #include "llvm/ADT/StringExtras.h"
  26 #include "llvm/ADT/Twine.h"
  27 #include "llvm/MC/MCContext.h"
  28 #include "llvm/MC/MCELFStreamer.h"
  29 #include "llvm/MC/MCExpr.h"
  30 #include "llvm/MC/MCInst.h"
  31 #include "llvm/MC/MCParser/MCAsmLexer.h"
  32 #include "llvm/MC/MCParser/MCAsmParser.h"
  33 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  34 #include "llvm/MC/MCStreamer.h"
  35 #include "llvm/MC/MCSectionELF.h"
  36 #include "llvm/MC/MCSubtargetInfo.h"
  37 #include "llvm/MC/MCTargetAsmParser.h"
  38 #include "llvm/Support/CommandLine.h"
  39 #include "llvm/Support/Debug.h"
  40 #include "llvm/Support/ELF.h"
  41 #include "llvm/Support/Format.h"
  42 #include "llvm/Support/SourceMgr.h"
  43 #include "llvm/Support/MemoryBuffer.h"
  44 #include "llvm/Support/TargetRegistry.h"
  45 #include "llvm/Support/raw_ostream.h"
  46 #include <sstream>
  47
  48 using namespace llvm;
  49
  50 static cl::opt<bool> EnableFutureRegs("mfuture-regs",
  51                                       cl::desc("Enable future registers"));
  52
  53 static cl::opt<bool> WarnMissingParenthesis("mwarn-missing-parenthesis",
  54 cl::desc("Warn for missing parenthesis around predicate registers"),
  55 cl::init(true));
  56 static cl::opt<bool> ErrorMissingParenthesis("merror-missing-parenthesis",
  57 cl::desc("Error for missing parenthesis around predicate registers"),
  58 cl::init(false));
  59 static cl::opt<bool> WarnSignedMismatch("mwarn-sign-mismatch",
  60 cl::desc("Warn for mismatching a signed and unsigned value"),
  61 cl::init(true));
  62 static cl::opt<bool> WarnNoncontigiousRegister("mwarn-noncontigious-register",
  63 cl::desc("Warn for register names that arent contigious"),
  64 cl::init(true));
  65 static cl::opt<bool> ErrorNoncontigiousRegister("merror-noncontigious-register",
  66 cl::desc("Error for register names that aren't contigious"),
  67 cl::init(false));
  68
  69
  70 namespace {
  71 struct HexagonOperand;
  72
  73 class HexagonAsmParser : public MCTargetAsmParser {
  74
  75   HexagonTargetStreamer &getTargetStreamer() {
  76     MCTargetStreamer &TS = *Parser.getStreamer().getTargetStreamer();
  77     return static_cast<HexagonTargetStreamer &>(TS);
  78   }
  79
  80   MCAsmParser &Parser;
  81   MCAssembler *Assembler;
  82   MCInstrInfo const &MCII;
  83   MCInst MCB;
  84   bool InBrackets;
  85
  86   MCAsmParser &getParser() const { return Parser; }
  87   MCAssembler *getAssembler() const { return Assembler; }
  88   MCAsmLexer &getLexer() const { return Parser.getLexer(); }
  89
  90   bool equalIsAsmAssignment() override { return false; }
  91   bool isLabel(AsmToken &Token) override;
  92
  93   void Warning(SMLoc L, const Twine &Msg) { Parser.Warning(L, Msg); }
  94   bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); }
  95   bool ParseDirectiveFalign(unsigned Size, SMLoc L);
  96
  97   virtual bool ParseRegister(unsigned &RegNo,
  98                              SMLoc &StartLoc,
  99                              SMLoc &EndLoc) override;
 100   bool ParseDirectiveSubsection(SMLoc L);
 101   bool ParseDirectiveValue(unsigned Size, SMLoc L);
 102   bool ParseDirectiveComm(bool IsLocal, SMLoc L);
 103   bool RegisterMatchesArch(unsigned MatchNum) const;
 104
 105   bool matchBundleOptions();
 106   bool handleNoncontigiousRegister(bool Contigious, SMLoc &Loc);
 107   bool finishBundle(SMLoc IDLoc, MCStreamer &Out);
 108   void canonicalizeImmediates(MCInst &MCI);
 109   bool matchOneInstruction(MCInst &MCB, SMLoc IDLoc,
 110                            OperandVector &InstOperands, uint64_t &ErrorInfo,
 111                            bool MatchingInlineAsm, bool &MustExtend);
 112
 113   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
 114                                OperandVector &Operands, MCStreamer &Out,
 115                                uint64_t &ErrorInfo, bool MatchingInlineAsm) override;
 116
 117   unsigned validateTargetOperandClass(MCParsedAsmOperand &Op, unsigned Kind) override;
 118   void OutOfRange(SMLoc IDLoc, long long Val, long long Max);
 119   int processInstruction(MCInst &Inst, OperandVector const &Operands,
 120                          SMLoc IDLoc, bool &MustExtend);
 121
 122   // Check if we have an assembler and, if so, set the ELF e_header flags.
 123   void chksetELFHeaderEFlags(unsigned flags) {
 124     if (getAssembler())
 125       getAssembler()->setELFHeaderEFlags(flags);
 126   }
 127
 128 /// @name Auto-generated Match Functions
 129 /// {
 130
 131 #define GET_ASSEMBLER_HEADER
 132 #include "HexagonGenAsmMatcher.inc"
 133
 134   /// }
 135
 136 public:
 137   HexagonAsmParser(const MCSubtargetInfo &_STI, MCAsmParser &_Parser,
 138                    const MCInstrInfo &MII, const MCTargetOptions &Options)
 139     : MCTargetAsmParser(Options, _STI), Parser(_Parser),
 140       MCII (MII), MCB(HexagonMCInstrInfo::createBundle()), InBrackets(false) {
 141     setAvailableFeatures(ComputeAvailableFeatures(getSTI().getFeatureBits()));
 142
 143   MCAsmParserExtension::Initialize(_Parser);
 144
 145   Assembler = nullptr;
 146   // FIXME: need better way to detect AsmStreamer (upstream removed getKind())
 147   if (!Parser.getStreamer().hasRawTextSupport()) {
 148     MCELFStreamer *MES = static_cast<MCELFStreamer *>(&Parser.getStreamer());
 149     Assembler = &MES->getAssembler();
 150   }
 151   }
 152
 153   bool mustExtend(OperandVector &Operands);
 154   bool splitIdentifier(OperandVector &Operands);
 155   bool parseOperand(OperandVector &Operands);
 156   bool parseInstruction(OperandVector &Operands);
 157   bool implicitExpressionLocation(OperandVector &Operands);
 158   bool parseExpressionOrOperand(OperandVector &Operands);
 159   bool parseExpression(MCExpr const *& Expr);
 160   virtual bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
 161                                 SMLoc NameLoc, OperandVector &Operands) override
 162   {
 163     llvm_unreachable("Unimplemented");
 164   }
 165   virtual bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
 166                                 AsmToken ID, OperandVector &Operands) override;
 167
 168   virtual bool ParseDirective(AsmToken DirectiveID) override;
 169 };
 170
 171 /// HexagonOperand - Instances of this class represent a parsed Hexagon machine
 172 /// instruction.
 173 struct HexagonOperand : public MCParsedAsmOperand {
 174   enum KindTy { Token, Immediate, Register } Kind;
 175
 176   SMLoc StartLoc, EndLoc;
 177
 178   struct TokTy {
 179     const char *Data;
 180     unsigned Length;
 181   };
 182
 183   struct RegTy {
 184     unsigned RegNum;
 185   };
 186
 187   struct ImmTy {
 188     const MCExpr *Val;
 189     bool MustExtend;
 190   };
 191
 192   struct InstTy {
 193     OperandVector *SubInsts;
 194   };
 195
 196   union {
 197     struct TokTy Tok;
 198     struct RegTy Reg;
 199     struct ImmTy Imm;
 200   };
 201
 202   HexagonOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {}
 203
 204 public:
 205   HexagonOperand(const HexagonOperand &o) : MCParsedAsmOperand() {
 206     Kind = o.Kind;
 207     StartLoc = o.StartLoc;
 208     EndLoc = o.EndLoc;
 209     switch (Kind) {
 210     case Register:
 211       Reg = o.Reg;
 212       break;
 213     case Immediate:
 214       Imm = o.Imm;
 215       break;
 216     case Token:
 217       Tok = o.Tok;
 218       break;
 219     }
 220   }
 221
 222   /// getStartLoc - Get the location of the first token of this operand.
 223   SMLoc getStartLoc() const { return StartLoc; }
 224
 225   /// getEndLoc - Get the location of the last token of this operand.
 226   SMLoc getEndLoc() const { return EndLoc; }
 227
 228   unsigned getReg() const {
 229     assert(Kind == Register && "Invalid access!");
 230     return Reg.RegNum;
 231   }
 232
 233   const MCExpr *getImm() const {
 234     assert(Kind == Immediate && "Invalid access!");
 235     return Imm.Val;
 236   }
 237
 238   bool isToken() const { return Kind == Token; }
 239   bool isImm() const { return Kind == Immediate; }
 240   bool isMem() const { llvm_unreachable("No isMem"); }
 241   bool isReg() const { return Kind == Register; }
 242
 243   bool CheckImmRange(int immBits, int zeroBits, bool isSigned,
 244                      bool isRelocatable, bool Extendable) const {
 245     if (Kind == Immediate) {
 246       const MCExpr *myMCExpr = getImm();
 247       if (Imm.MustExtend && !Extendable)
 248         return false;
 249       int64_t Res;
 250       if (myMCExpr->evaluateAsAbsolute(Res)) {
 251         int bits = immBits + zeroBits;
 252         // Field bit range is zerobits + bits
 253         // zeroBits must be 0
 254         if (Res & ((1 << zeroBits) - 1))
 255           return false;
 256         if (isSigned) {
 257           if (Res < (1LL << (bits - 1)) && Res >= -(1LL << (bits - 1)))
 258             return true;
 259         } else {
 260           if (bits == 64)
 261             return true;
 262           if (Res >= 0)
 263             return ((uint64_t)Res < (uint64_t)(1ULL << bits)) ? true : false;
 264           else {
 265             const int64_t high_bit_set = 1ULL << 63;
 266             const uint64_t mask = (high_bit_set >> (63 - bits));
 267             return (((uint64_t)Res & mask) == mask) ? true : false;
 268           }
 269         }
 270       } else if (myMCExpr->getKind() == MCExpr::SymbolRef && isRelocatable)
 271         return true;
 272       else if (myMCExpr->getKind() == MCExpr::Binary ||
 273                myMCExpr->getKind() == MCExpr::Unary)
 274         return true;
 275     }
 276     return false;
 277   }
 278
 279   bool isf32Ext() const { return false; }
 280   bool iss32Imm() const { return CheckImmRange(32, 0, true, true, false); }
 281   bool iss8Imm() const { return CheckImmRange(8, 0, true, false, false); }
 282   bool iss8Imm64() const { return CheckImmRange(8, 0, true, true, false); }
 283   bool iss7Imm() const { return CheckImmRange(7, 0, true, false, false); }
 284   bool iss6Imm() const { return CheckImmRange(6, 0, true, false, false); }
 285   bool iss4Imm() const { return CheckImmRange(4, 0, true, false, false); }
 286   bool iss4_0Imm() const { return CheckImmRange(4, 0, true, false, false); }
 287   bool iss4_1Imm() const { return CheckImmRange(4, 1, true, false, false); }
 288   bool iss4_2Imm() const { return CheckImmRange(4, 2, true, false, false); }
 289   bool iss4_3Imm() const { return CheckImmRange(4, 3, true, false, false); }
 290   bool iss4_6Imm() const { return CheckImmRange(4, 0, true, false, false); }
 291   bool iss3_6Imm() const { return CheckImmRange(3, 0, true, false, false); }
 292   bool iss3Imm() const { return CheckImmRange(3, 0, true, false, false); }
 293
 294   bool isu64Imm() const { return CheckImmRange(64, 0, false, true, true); }
 295   bool isu32Imm() const { return CheckImmRange(32, 0, false, true, false); }
 296   bool isu26_6Imm() const { return CheckImmRange(26, 6, false, true, false); }
 297   bool isu16Imm() const { return CheckImmRange(16, 0, false, true, false); }
 298   bool isu16_0Imm() const { return CheckImmRange(16, 0, false, true, false); }
 299   bool isu16_1Imm() const { return CheckImmRange(16, 1, false, true, false); }
 300   bool isu16_2Imm() const { return CheckImmRange(16, 2, false, true, false); }
 301   bool isu16_3Imm() const { return CheckImmRange(16, 3, false, true, false); }
 302   bool isu11_3Imm() const { return CheckImmRange(11, 3, false, false, false); }
 303   bool isu6_0Imm() const { return CheckImmRange(6, 0, false, false, false); }
 304   bool isu6_1Imm() const { return CheckImmRange(6, 1, false, false, false); }
 305   bool isu6_2Imm() const { return CheckImmRange(6, 2, false, false, false); }
 306   bool isu6_3Imm() const { return CheckImmRange(6, 3, false, false, false); }
 307   bool isu10Imm() const { return CheckImmRange(10, 0, false, false, false); }
 308   bool isu9Imm() const { return CheckImmRange(9, 0, false, false, false); }
 309   bool isu8Imm() const { return CheckImmRange(8, 0, false, false, false); }
 310   bool isu7Imm() const { return CheckImmRange(7, 0, false, false, false); }
 311   bool isu6Imm() const { return CheckImmRange(6, 0, false, false, false); }
 312   bool isu5Imm() const { return CheckImmRange(5, 0, false, false, false); }
 313   bool isu4Imm() const { return CheckImmRange(4, 0, false, false, false); }
 314   bool isu3Imm() const { return CheckImmRange(3, 0, false, false, false); }
 315   bool isu2Imm() const { return CheckImmRange(2, 0, false, false, false); }
 316   bool isu1Imm() const { return CheckImmRange(1, 0, false, false, false); }
 317
 318   bool ism6Imm() const { return CheckImmRange(6, 0, false, false, false); }
 319   bool isn8Imm() const { return CheckImmRange(8, 0, false, false, false); }
 320
 321   bool iss16Ext() const { return CheckImmRange(16 + 26, 0, true, true, true); }
 322   bool iss12Ext() const { return CheckImmRange(12 + 26, 0, true, true, true); }
 323   bool iss10Ext() const { return CheckImmRange(10 + 26, 0, true, true, true); }
 324   bool iss9Ext() const { return CheckImmRange(9 + 26, 0, true, true, true); }
 325   bool iss8Ext() const { return CheckImmRange(8 + 26, 0, true, true, true); }
 326   bool iss7Ext() const { return CheckImmRange(7 + 26, 0, true, true, true); }
 327   bool iss6Ext() const { return CheckImmRange(6 + 26, 0, true, true, true); }
 328   bool iss11_0Ext() const {
 329     return CheckImmRange(11 + 26, 0, true, true, true);
 330   }
 331   bool iss11_1Ext() const {
 332     return CheckImmRange(11 + 26, 1, true, true, true);
 333   }
 334   bool iss11_2Ext() const {
 335     return CheckImmRange(11 + 26, 2, true, true, true);
 336   }
 337   bool iss11_3Ext() const {
 338     return CheckImmRange(11 + 26, 3, true, true, true);
 339   }
 340
 341   bool isu6Ext() const { return CheckImmRange(6 + 26, 0, false, true, true); }
 342   bool isu7Ext() const { return CheckImmRange(7 + 26, 0, false, true, true); }
 343   bool isu8Ext() const { return CheckImmRange(8 + 26, 0, false, true, true); }
 344   bool isu9Ext() const { return CheckImmRange(9 + 26, 0, false, true, true); }
 345   bool isu10Ext() const { return CheckImmRange(10 + 26, 0, false, true, true); }
 346   bool isu6_0Ext() const { return CheckImmRange(6 + 26, 0, false, true, true); }
 347   bool isu6_1Ext() const { return CheckImmRange(6 + 26, 1, false, true, true); }
 348   bool isu6_2Ext() const { return CheckImmRange(6 + 26, 2, false, true, true); }
 349   bool isu6_3Ext() const { return CheckImmRange(6 + 26, 3, false, true, true); }
 350   bool isu32MustExt() const { return isImm() && Imm.MustExtend; }
 351
 352   void addRegOperands(MCInst &Inst, unsigned N) const {
 353     assert(N == 1 && "Invalid number of operands!");
 354     Inst.addOperand(MCOperand::createReg(getReg()));
 355   }
 356
 357   void addImmOperands(MCInst &Inst, unsigned N) const {
 358     assert(N == 1 && "Invalid number of operands!");
 359     Inst.addOperand(MCOperand::createExpr(getImm()));
 360   }
 361
 362   void addSignedImmOperands(MCInst &Inst, unsigned N) const {
 363     assert(N == 1 && "Invalid number of operands!");
 364     MCExpr const *Expr = getImm();
 365     int64_t Value;
 366     if (!Expr->evaluateAsAbsolute(Value)) {
 367       Inst.addOperand(MCOperand::createExpr(Expr));
 368       return;
 369     }
 370     int64_t Extended = SignExtend64 (Value, 32);
 371     if ((Extended < 0) == (Value < 0)) {
 372       Inst.addOperand(MCOperand::createExpr(Expr));
 373       return;
 374     }
 375     // Flip bit 33 to signal signed unsigned mismatch
 376     Extended ^= 0x100000000;
 377     Inst.addOperand(MCOperand::createImm(Extended));
 378   }
 379
 380   void addf32ExtOperands(MCInst &Inst, unsigned N) const {
 381     addImmOperands(Inst, N);
 382   }
 383
 384   void adds32ImmOperands(MCInst &Inst, unsigned N) const {
 385     addSignedImmOperands(Inst, N);
 386   }
 387   void adds8ImmOperands(MCInst &Inst, unsigned N) const {
 388     addSignedImmOperands(Inst, N);
 389   }
 390   void adds8Imm64Operands(MCInst &Inst, unsigned N) const {
 391     addSignedImmOperands(Inst, N);
 392   }
 393   void adds6ImmOperands(MCInst &Inst, unsigned N) const {
 394     addSignedImmOperands(Inst, N);
 395   }
 396   void adds4ImmOperands(MCInst &Inst, unsigned N) const {
 397     addSignedImmOperands(Inst, N);
 398   }
 399   void adds4_0ImmOperands(MCInst &Inst, unsigned N) const {
 400     addSignedImmOperands(Inst, N);
 401   }
 402   void adds4_1ImmOperands(MCInst &Inst, unsigned N) const {
 403     addSignedImmOperands(Inst, N);
 404   }
 405   void adds4_2ImmOperands(MCInst &Inst, unsigned N) const {
 406     addSignedImmOperands(Inst, N);
 407   }
 408   void adds4_3ImmOperands(MCInst &Inst, unsigned N) const {
 409     addSignedImmOperands(Inst, N);
 410   }
 411   void adds3ImmOperands(MCInst &Inst, unsigned N) const {
 412     addSignedImmOperands(Inst, N);
 413   }
 414
 415   void addu64ImmOperands(MCInst &Inst, unsigned N) const {
 416     addImmOperands(Inst, N);
 417   }
 418   void addu32ImmOperands(MCInst &Inst, unsigned N) const {
 419     addImmOperands(Inst, N);
 420   }
 421   void addu26_6ImmOperands(MCInst &Inst, unsigned N) const {
 422     addImmOperands(Inst, N);
 423   }
 424   void addu16ImmOperands(MCInst &Inst, unsigned N) const {
 425     addImmOperands(Inst, N);
 426   }
 427   void addu16_0ImmOperands(MCInst &Inst, unsigned N) const {
 428     addImmOperands(Inst, N);
 429   }
 430   void addu16_1ImmOperands(MCInst &Inst, unsigned N) const {
 431     addImmOperands(Inst, N);
 432   }
 433   void addu16_2ImmOperands(MCInst &Inst, unsigned N) const {
 434     addImmOperands(Inst, N);
 435   }
 436   void addu16_3ImmOperands(MCInst &Inst, unsigned N) const {
 437     addImmOperands(Inst, N);
 438   }
 439   void addu11_3ImmOperands(MCInst &Inst, unsigned N) const {
 440     addImmOperands(Inst, N);
 441   }
 442   void addu10ImmOperands(MCInst &Inst, unsigned N) const {
 443     addImmOperands(Inst, N);
 444   }
 445   void addu9ImmOperands(MCInst &Inst, unsigned N) const {
 446     addImmOperands(Inst, N);
 447   }
 448   void addu8ImmOperands(MCInst &Inst, unsigned N) const {
 449     addImmOperands(Inst, N);
 450   }
 451   void addu7ImmOperands(MCInst &Inst, unsigned N) const {
 452     addImmOperands(Inst, N);
 453   }
 454   void addu6ImmOperands(MCInst &Inst, unsigned N) const {
 455     addImmOperands(Inst, N);
 456   }
 457   void addu6_0ImmOperands(MCInst &Inst, unsigned N) const {
 458     addImmOperands(Inst, N);
 459   }
 460   void addu6_1ImmOperands(MCInst &Inst, unsigned N) const {
 461     addImmOperands(Inst, N);
 462   }
 463   void addu6_2ImmOperands(MCInst &Inst, unsigned N) const {
 464     addImmOperands(Inst, N);
 465   }
 466   void addu6_3ImmOperands(MCInst &Inst, unsigned N) const {
 467     addImmOperands(Inst, N);
 468   }
 469   void addu5ImmOperands(MCInst &Inst, unsigned N) const {
 470     addImmOperands(Inst, N);
 471   }
 472   void addu4ImmOperands(MCInst &Inst, unsigned N) const {
 473     addImmOperands(Inst, N);
 474   }
 475   void addu3ImmOperands(MCInst &Inst, unsigned N) const {
 476     addImmOperands(Inst, N);
 477   }
 478   void addu2ImmOperands(MCInst &Inst, unsigned N) const {
 479     addImmOperands(Inst, N);
 480   }
 481   void addu1ImmOperands(MCInst &Inst, unsigned N) const {
 482     addImmOperands(Inst, N);
 483   }
 484
 485   void addm6ImmOperands(MCInst &Inst, unsigned N) const {
 486     addImmOperands(Inst, N);
 487   }
 488   void addn8ImmOperands(MCInst &Inst, unsigned N) const {
 489     addImmOperands(Inst, N);
 490   }
 491
 492   void adds16ExtOperands(MCInst &Inst, unsigned N) const {
 493     addSignedImmOperands(Inst, N);
 494   }
 495   void adds12ExtOperands(MCInst &Inst, unsigned N) const {
 496     addSignedImmOperands(Inst, N);
 497   }
 498   void adds10ExtOperands(MCInst &Inst, unsigned N) const {
 499     addSignedImmOperands(Inst, N);
 500   }
 501   void adds9ExtOperands(MCInst &Inst, unsigned N) const {
 502     addSignedImmOperands(Inst, N);
 503   }
 504   void adds8ExtOperands(MCInst &Inst, unsigned N) const {
 505     addSignedImmOperands(Inst, N);
 506   }
 507   void adds6ExtOperands(MCInst &Inst, unsigned N) const {
 508     addSignedImmOperands(Inst, N);
 509   }
 510   void adds11_0ExtOperands(MCInst &Inst, unsigned N) const {
 511     addSignedImmOperands(Inst, N);
 512   }
 513   void adds11_1ExtOperands(MCInst &Inst, unsigned N) const {
 514     addSignedImmOperands(Inst, N);
 515   }
 516   void adds11_2ExtOperands(MCInst &Inst, unsigned N) const {
 517     addSignedImmOperands(Inst, N);
 518   }
 519   void adds11_3ExtOperands(MCInst &Inst, unsigned N) const {
 520     addSignedImmOperands(Inst, N);
 521   }
 522
 523   void addu6ExtOperands(MCInst &Inst, unsigned N) const {
 524     addImmOperands(Inst, N);
 525   }
 526   void addu7ExtOperands(MCInst &Inst, unsigned N) const {
 527     addImmOperands(Inst, N);
 528   }
 529   void addu8ExtOperands(MCInst &Inst, unsigned N) const {
 530     addImmOperands(Inst, N);
 531   }
 532   void addu9ExtOperands(MCInst &Inst, unsigned N) const {
 533     addImmOperands(Inst, N);
 534   }
 535   void addu10ExtOperands(MCInst &Inst, unsigned N) const {
 536     addImmOperands(Inst, N);
 537   }
 538   void addu6_0ExtOperands(MCInst &Inst, unsigned N) const {
 539     addImmOperands(Inst, N);
 540   }
 541   void addu6_1ExtOperands(MCInst &Inst, unsigned N) const {
 542     addImmOperands(Inst, N);
 543   }
 544   void addu6_2ExtOperands(MCInst &Inst, unsigned N) const {
 545     addImmOperands(Inst, N);
 546   }
 547   void addu6_3ExtOperands(MCInst &Inst, unsigned N) const {
 548     addImmOperands(Inst, N);
 549   }
 550   void addu32MustExtOperands(MCInst &Inst, unsigned N) const {
 551     addImmOperands(Inst, N);
 552   }
 553
 554   void adds4_6ImmOperands(MCInst &Inst, unsigned N) const {
 555     assert(N == 1 && "Invalid number of operands!");
 556     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 557     Inst.addOperand(MCOperand::createImm(CE->getValue() << 6));
 558   }
 559
 560   void adds3_6ImmOperands(MCInst &Inst, unsigned N) const {
 561     assert(N == 1 && "Invalid number of operands!");
 562     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 563     Inst.addOperand(MCOperand::createImm(CE->getValue() << 6));
 564   }
 565
 566   StringRef getToken() const {
 567     assert(Kind == Token && "Invalid access!");
 568     return StringRef(Tok.Data, Tok.Length);
 569   }
 570
 571   virtual void print(raw_ostream &OS) const;
 572
 573   static std::unique_ptr<HexagonOperand> CreateToken(StringRef Str, SMLoc S) {
 574     HexagonOperand *Op = new HexagonOperand(Token);
 575     Op->Tok.Data = Str.data();
 576     Op->Tok.Length = Str.size();
 577     Op->StartLoc = S;
 578     Op->EndLoc = S;
 579     return std::unique_ptr<HexagonOperand>(Op);
 580   }
 581
 582   static std::unique_ptr<HexagonOperand> CreateReg(unsigned RegNum, SMLoc S,
 583                                                    SMLoc E) {
 584     HexagonOperand *Op = new HexagonOperand(Register);
 585     Op->Reg.RegNum = RegNum;
 586     Op->StartLoc = S;
 587     Op->EndLoc = E;
 588     return std::unique_ptr<HexagonOperand>(Op);
 589   }
 590
 591   static std::unique_ptr<HexagonOperand> CreateImm(const MCExpr *Val, SMLoc S,
 592                                                    SMLoc E) {
 593     HexagonOperand *Op = new HexagonOperand(Immediate);
 594     Op->Imm.Val = Val;
 595     Op->Imm.MustExtend = false;
 596     Op->StartLoc = S;
 597     Op->EndLoc = E;
 598     return std::unique_ptr<HexagonOperand>(Op);
 599   }
 600 };
 601
 602 } // end anonymous namespace.
 603
 604 void HexagonOperand::print(raw_ostream &OS) const {
 605   switch (Kind) {
 606   case Immediate:
 607     getImm()->print(OS, nullptr);
 608     break;
 609   case Register:
 610     OS << "<register R";
 611     OS << getReg() << ">";
 612     break;
 613   case Token:
 614     OS << "'" << getToken() << "'";
 615     break;
 616   }
 617 }
 618
 619 /// @name Auto-generated Match Functions
 620 static unsigned MatchRegisterName(StringRef Name);
 621
 622 bool HexagonAsmParser::finishBundle(SMLoc IDLoc, MCStreamer &Out) {
 623   DEBUG(dbgs() << "Bundle:");
 624   DEBUG(MCB.dump_pretty(dbgs()));
 625   DEBUG(dbgs() << "--\n");
 626
 627   // Check the bundle for errors.
 628   const MCRegisterInfo *RI = getContext().getRegisterInfo();
 629   HexagonMCChecker Check(MCII, getSTI(), MCB, MCB, *RI);
 630
 631   bool CheckOk = HexagonMCInstrInfo::canonicalizePacket(MCII, getSTI(),
 632                                                         getContext(), MCB,
 633                                                         &Check);
 634
 635   while (Check.getNextErrInfo() == true) {
 636     unsigned Reg = Check.getErrRegister();
 637     Twine R(RI->getName(Reg));
 638
 639     uint64_t Err = Check.getError();
 640     if (Err != HexagonMCErrInfo::CHECK_SUCCESS) {
 641       if (HexagonMCErrInfo::CHECK_ERROR_BRANCHES & Err)
 642         Error(IDLoc,
 643               "unconditional branch cannot precede another branch in packet");
 644
 645       if (HexagonMCErrInfo::CHECK_ERROR_NEWP & Err ||
 646           HexagonMCErrInfo::CHECK_ERROR_NEWV & Err)
 647         Error(IDLoc, "register `" + R +
 648                          "' used with `.new' "
 649                          "but not validly modified in the same packet");
 650
 651       if (HexagonMCErrInfo::CHECK_ERROR_REGISTERS & Err)
 652         Error(IDLoc, "register `" + R + "' modified more than once");
 653
 654       if (HexagonMCErrInfo::CHECK_ERROR_READONLY & Err)
 655         Error(IDLoc, "cannot write to read-only register `" + R + "'");
 656
 657       if (HexagonMCErrInfo::CHECK_ERROR_LOOP & Err)
 658         Error(IDLoc, "loop-setup and some branch instructions "
 659                      "cannot be in the same packet");
 660
 661       if (HexagonMCErrInfo::CHECK_ERROR_ENDLOOP & Err) {
 662         Twine N(HexagonMCInstrInfo::isInnerLoop(MCB) ? '0' : '1');
 663         Error(IDLoc, "packet marked with `:endloop" + N + "' " +
 664                          "cannot contain instructions that modify register " +
 665                          "`" + R + "'");
 666       }
 667
 668       if (HexagonMCErrInfo::CHECK_ERROR_SOLO & Err)
 669         Error(IDLoc,
 670               "instruction cannot appear in packet with other instructions");
 671
 672       if (HexagonMCErrInfo::CHECK_ERROR_NOSLOTS & Err)
 673         Error(IDLoc, "too many slots used in packet");
 674
 675       if (Err & HexagonMCErrInfo::CHECK_ERROR_SHUFFLE) {
 676         uint64_t Erm = Check.getShuffleError();
 677
 678         if (HexagonShuffler::SHUFFLE_ERROR_INVALID == Erm)
 679           Error(IDLoc, "invalid instruction packet");
 680         else if (HexagonShuffler::SHUFFLE_ERROR_STORES == Erm)
 681           Error(IDLoc, "invalid instruction packet: too many stores");
 682         else if (HexagonShuffler::SHUFFLE_ERROR_LOADS == Erm)
 683           Error(IDLoc, "invalid instruction packet: too many loads");
 684         else if (HexagonShuffler::SHUFFLE_ERROR_BRANCHES == Erm)
 685           Error(IDLoc, "too many branches in packet");
 686         else if (HexagonShuffler::SHUFFLE_ERROR_NOSLOTS == Erm)
 687           Error(IDLoc, "invalid instruction packet: out of slots");
 688         else if (HexagonShuffler::SHUFFLE_ERROR_SLOTS == Erm)
 689           Error(IDLoc, "invalid instruction packet: slot error");
 690         else if (HexagonShuffler::SHUFFLE_ERROR_ERRATA2 == Erm)
 691           Error(IDLoc, "v60 packet violation");
 692         else if (HexagonShuffler::SHUFFLE_ERROR_STORE_LOAD_CONFLICT == Erm)
 693           Error(IDLoc, "slot 0 instruction does not allow slot 1 store");
 694         else
 695           Error(IDLoc, "unknown error in instruction packet");
 696       }
 697     }
 698
 699     unsigned Warn = Check.getWarning();
 700     if (Warn != HexagonMCErrInfo::CHECK_SUCCESS) {
 701       if (HexagonMCErrInfo::CHECK_WARN_CURRENT & Warn)
 702         Warning(IDLoc, "register `" + R + "' used with `.cur' "
 703                                           "but not used in the same packet");
 704       else if (HexagonMCErrInfo::CHECK_WARN_TEMPORARY & Warn)
 705         Warning(IDLoc, "register `" + R + "' used with `.tmp' "
 706                                           "but not used in the same packet");
 707     }
 708   }
 709
 710   if (CheckOk) {
 711     MCB.setLoc(IDLoc);
 712     if (HexagonMCInstrInfo::bundleSize(MCB) == 0) {
 713       assert(!HexagonMCInstrInfo::isInnerLoop(MCB));
 714       assert(!HexagonMCInstrInfo::isOuterLoop(MCB));
 715       // Empty packets are valid yet aren't emitted
 716       return false;
 717     }
 718     Out.EmitInstruction(MCB, getSTI());
 719   } else {
 720     // If compounding and duplexing didn't reduce the size below
 721     // 4 or less we have a packet that is too big.
 722     if (HexagonMCInstrInfo::bundleSize(MCB) > HEXAGON_PACKET_SIZE) {
 723       Error(IDLoc, "invalid instruction packet: out of slots");
 724       return true; // Error
 725     }
 726   }
 727
 728   return false; // No error
 729 }
 730
 731 bool HexagonAsmParser::matchBundleOptions() {
 732   MCAsmParser &Parser = getParser();
 733   MCAsmLexer &Lexer = getLexer();
 734   while (true) {
 735     if (!Parser.getTok().is(AsmToken::Colon))
 736       return false;
 737     Lexer.Lex();
 738     StringRef Option = Parser.getTok().getString();
 739     if (Option.compare_lower("endloop0") == 0)
 740       HexagonMCInstrInfo::setInnerLoop(MCB);
 741     else if (Option.compare_lower("endloop1") == 0)
 742       HexagonMCInstrInfo::setOuterLoop(MCB);
 743     else if (Option.compare_lower("mem_noshuf") == 0)
 744       HexagonMCInstrInfo::setMemReorderDisabled(MCB);
 745     else if (Option.compare_lower("mem_shuf") == 0)
 746       HexagonMCInstrInfo::setMemStoreReorderEnabled(MCB);
 747     else
 748       return true;
 749     Lexer.Lex();
 750   }
 751 }
 752
 753 // For instruction aliases, immediates are generated rather than
 754 // MCConstantExpr.  Convert them for uniform MCExpr.
 755 // Also check for signed/unsigned mismatches and warn
 756 void HexagonAsmParser::canonicalizeImmediates(MCInst &MCI) {
 757   MCInst NewInst;
 758   NewInst.setOpcode(MCI.getOpcode());
 759   for (MCOperand &I : MCI)
 760     if (I.isImm()) {
 761       int64_t Value (I.getImm());
 762       if ((Value & 0x100000000) != (Value & 0x80000000)) {
 763         // Detect flipped bit 33 wrt bit 32 and signal warning
 764         Value ^= 0x100000000;
 765         if (WarnSignedMismatch)
 766           Warning (MCI.getLoc(), "Signed/Unsigned mismatch");
 767       }
 768       NewInst.addOperand(MCOperand::createExpr(
 769           MCConstantExpr::create(Value, getContext())));
 770     }
 771     else
 772       NewInst.addOperand(I);
 773   MCI = NewInst;
 774 }
 775
 776 bool HexagonAsmParser::matchOneInstruction(MCInst &MCI, SMLoc IDLoc,
 777                                            OperandVector &InstOperands,
 778                                            uint64_t &ErrorInfo,
 779                                            bool MatchingInlineAsm,
 780                                            bool &MustExtend) {
 781   // Perform matching with tablegen asmmatcher generated function
 782   int result =
 783       MatchInstructionImpl(InstOperands, MCI, ErrorInfo, MatchingInlineAsm);
 784   if (result == Match_Success) {
 785     MCI.setLoc(IDLoc);
 786     MustExtend = mustExtend(InstOperands);
 787     canonicalizeImmediates(MCI);
 788     result = processInstruction(MCI, InstOperands, IDLoc, MustExtend);
 789
 790     DEBUG(dbgs() << "Insn:");
 791     DEBUG(MCI.dump_pretty(dbgs()));
 792     DEBUG(dbgs() << "\n\n");
 793
 794     MCI.setLoc(IDLoc);
 795   }
 796
 797   // Create instruction operand for bundle instruction
 798   //   Break this into a separate function Code here is less readable
 799   //   Think about how to get an instruction error to report correctly.
 800   //   SMLoc will return the "{"
 801   switch (result) {
 802   default:
 803     break;
 804   case Match_Success:
 805     return false;
 806   case Match_MissingFeature:
 807     return Error(IDLoc, "invalid instruction");
 808   case Match_MnemonicFail:
 809     return Error(IDLoc, "unrecognized instruction");
 810   case Match_InvalidOperand:
 811     SMLoc ErrorLoc = IDLoc;
 812     if (ErrorInfo != ~0U) {
 813       if (ErrorInfo >= InstOperands.size())
 814         return Error(IDLoc, "too few operands for instruction");
 815
 816       ErrorLoc = (static_cast<HexagonOperand *>(InstOperands[ErrorInfo].get()))
 817                      ->getStartLoc();
 818       if (ErrorLoc == SMLoc())
 819         ErrorLoc = IDLoc;
 820     }
 821     return Error(ErrorLoc, "invalid operand for instruction");
 822   }
 823   llvm_unreachable("Implement any new match types added!");
 824 }
 825
 826 bool HexagonAsmParser::mustExtend(OperandVector &Operands) {
 827   unsigned Count = 0;
 828   for (std::unique_ptr<MCParsedAsmOperand> &i : Operands)
 829     if (i->isImm())
 830       if (static_cast<HexagonOperand *>(i.get())->Imm.MustExtend)
 831         ++Count;
 832   // Multiple extenders should have been filtered by iss9Ext et. al.
 833   assert(Count < 2 && "Multiple extenders");
 834   return Count == 1;
 835 }
 836
 837 bool HexagonAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
 838                                                OperandVector &Operands,
 839                                                MCStreamer &Out,
 840                                                uint64_t &ErrorInfo,
 841                                                bool MatchingInlineAsm) {
 842   if (!InBrackets) {
 843     MCB.clear();
 844     MCB.addOperand(MCOperand::createImm(0));
 845   }
 846   HexagonOperand &FirstOperand = static_cast<HexagonOperand &>(*Operands[0]);
 847   if (FirstOperand.isToken() && FirstOperand.getToken() == "{") {
 848     assert(Operands.size() == 1 && "Brackets should be by themselves");
 849     if (InBrackets) {
 850       getParser().Error(IDLoc, "Already in a packet");
 851       return true;
 852     }
 853     InBrackets = true;
 854     return false;
 855   }
 856   if (FirstOperand.isToken() && FirstOperand.getToken() == "}") {
 857     assert(Operands.size() == 1 && "Brackets should be by themselves");
 858     if (!InBrackets) {
 859       getParser().Error(IDLoc, "Not in a packet");
 860       return true;
 861     }
 862     InBrackets = false;
 863     if (matchBundleOptions())
 864       return true;
 865     return finishBundle(IDLoc, Out);
 866   }
 867   MCInst *SubInst = new (getParser().getContext()) MCInst;
 868   bool MustExtend = false;
 869   if (matchOneInstruction(*SubInst, IDLoc, Operands, ErrorInfo,
 870                           MatchingInlineAsm, MustExtend))
 871     return true;
 872   HexagonMCInstrInfo::extendIfNeeded(
 873       getParser().getContext(), MCII, MCB, *SubInst,
 874       HexagonMCInstrInfo::isExtended(MCII, *SubInst) || MustExtend);
 875   MCB.addOperand(MCOperand::createInst(SubInst));
 876   if (!InBrackets)
 877     return finishBundle(IDLoc, Out);
 878   return false;
 879 }
 880
 881 /// ParseDirective parses the Hexagon specific directives
 882 bool HexagonAsmParser::ParseDirective(AsmToken DirectiveID) {
 883   StringRef IDVal = DirectiveID.getIdentifier();
 884   if ((IDVal.lower() == ".word") || (IDVal.lower() == ".4byte"))
 885     return ParseDirectiveValue(4, DirectiveID.getLoc());
 886   if (IDVal.lower() == ".short" || IDVal.lower() == ".hword" ||
 887       IDVal.lower() == ".half")
 888     return ParseDirectiveValue(2, DirectiveID.getLoc());
 889   if (IDVal.lower() == ".falign")
 890     return ParseDirectiveFalign(256, DirectiveID.getLoc());
 891   if ((IDVal.lower() == ".lcomm") || (IDVal.lower() == ".lcommon"))
 892     return ParseDirectiveComm(true, DirectiveID.getLoc());
 893   if ((IDVal.lower() == ".comm") || (IDVal.lower() == ".common"))
 894     return ParseDirectiveComm(false, DirectiveID.getLoc());
 895   if (IDVal.lower() == ".subsection")
 896     return ParseDirectiveSubsection(DirectiveID.getLoc());
 897
 898   return true;
 899 }
 900 bool HexagonAsmParser::ParseDirectiveSubsection(SMLoc L) {
 901   const MCExpr *Subsection = 0;
 902   int64_t Res;
 903
 904   assert((getLexer().isNot(AsmToken::EndOfStatement)) &&
 905          "Invalid subsection directive");
 906   getParser().parseExpression(Subsection);
 907
 908   if (!Subsection->evaluateAsAbsolute(Res))
 909     return Error(L, "Cannot evaluate subsection number");
 910
 911   if (getLexer().isNot(AsmToken::EndOfStatement))
 912     return TokError("unexpected token in directive");
 913
 914   // 0-8192 is the hard-coded range in MCObjectStreamper.cpp, this keeps the
 915   // negative subsections together and in the same order but at the opposite
 916   // end of the section.  Only legacy hexagon-gcc created assembly code
 917   // used negative subsections.
 918   if ((Res < 0) && (Res > -8193))
 919     Subsection = MCConstantExpr::create(8192 + Res, this->getContext());
 920
 921   getStreamer().SubSection(Subsection);
 922   return false;
 923 }
 924
 925 ///  ::= .falign [expression]
 926 bool HexagonAsmParser::ParseDirectiveFalign(unsigned Size, SMLoc L) {
 927
 928   int64_t MaxBytesToFill = 15;
 929
 930   // if there is an arguement
 931   if (getLexer().isNot(AsmToken::EndOfStatement)) {
 932     const MCExpr *Value;
 933     SMLoc ExprLoc = L;
 934
 935     // Make sure we have a number (false is returned if expression is a number)
 936     if (getParser().parseExpression(Value) == false) {
 937       // Make sure this is a number that is in range
 938       const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value);
 939       uint64_t IntValue = MCE->getValue();
 940       if (!isUIntN(Size, IntValue) && !isIntN(Size, IntValue))
 941         return Error(ExprLoc, "literal value out of range (256) for falign");
 942       MaxBytesToFill = IntValue;
 943       Lex();
 944     } else {
 945       return Error(ExprLoc, "not a valid expression for falign directive");
 946     }
 947   }
 948
 949   getTargetStreamer().emitFAlign(16, MaxBytesToFill);
 950   Lex();
 951
 952   return false;
 953 }
 954
 955 ///  ::= .word [ expression (, expression)* ]
 956 bool HexagonAsmParser::ParseDirectiveValue(unsigned Size, SMLoc L) {
 957   if (getLexer().isNot(AsmToken::EndOfStatement)) {
 958
 959     for (;;) {
 960       const MCExpr *Value;
 961       SMLoc ExprLoc = L;
 962       if (getParser().parseExpression(Value))
 963         return true;
 964
 965       // Special case constant expressions to match code generator.
 966       if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value)) {
 967         assert(Size <= 8 && "Invalid size");
 968         uint64_t IntValue = MCE->getValue();
 969         if (!isUIntN(8 * Size, IntValue) && !isIntN(8 * Size, IntValue))
 970           return Error(ExprLoc, "literal value out of range for directive");
 971         getStreamer().EmitIntValue(IntValue, Size);
 972       } else
 973         getStreamer().EmitValue(Value, Size);
 974
 975       if (getLexer().is(AsmToken::EndOfStatement))
 976         break;
 977
 978       // FIXME: Improve diagnostic.
 979       if (getLexer().isNot(AsmToken::Comma))
 980         return TokError("unexpected token in directive");
 981       Lex();
 982     }
 983   }
 984
 985   Lex();
 986   return false;
 987 }
 988
 989 // This is largely a copy of AsmParser's ParseDirectiveComm extended to
 990 // accept a 3rd argument, AccessAlignment which indicates the smallest
 991 // memory access made to the symbol, expressed in bytes.  If no
 992 // AccessAlignment is specified it defaults to the Alignment Value.
 993 // Hexagon's .lcomm:
 994 //   .lcomm Symbol, Length, Alignment, AccessAlignment
 995 bool HexagonAsmParser::ParseDirectiveComm(bool IsLocal, SMLoc Loc) {
 996   // FIXME: need better way to detect if AsmStreamer (upstream removed
 997   // getKind())
 998   if (getStreamer().hasRawTextSupport())
 999     return true; // Only object file output requires special treatment.
1000
1001   StringRef Name;
1002   if (getParser().parseIdentifier(Name))
1003     return TokError("expected identifier in directive");
1004   // Handle the identifier as the key symbol.
1005   MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
1006
1007   if (getLexer().isNot(AsmToken::Comma))
1008     return TokError("unexpected token in directive");
1009   Lex();
1010
1011   int64_t Size;
1012   SMLoc SizeLoc = getLexer().getLoc();
1013   if (getParser().parseAbsoluteExpression(Size))
1014     return true;
1015
1016   int64_t ByteAlignment = 1;
1017   SMLoc ByteAlignmentLoc;
1018   if (getLexer().is(AsmToken::Comma)) {
1019     Lex();
1020     ByteAlignmentLoc = getLexer().getLoc();
1021     if (getParser().parseAbsoluteExpression(ByteAlignment))
1022       return true;
1023     if (!isPowerOf2_64(ByteAlignment))
1024       return Error(ByteAlignmentLoc, "alignment must be a power of 2");
1025   }
1026
1027   int64_t AccessAlignment = 0;
1028   if (getLexer().is(AsmToken::Comma)) {
1029     // The optional access argument specifies the size of the smallest memory
1030     //   access to be made to the symbol, expressed in bytes.
1031     SMLoc AccessAlignmentLoc;
1032     Lex();
1033     AccessAlignmentLoc = getLexer().getLoc();
1034     if (getParser().parseAbsoluteExpression(AccessAlignment))
1035       return true;
1036
1037     if (!isPowerOf2_64(AccessAlignment))
1038       return Error(AccessAlignmentLoc, "access alignment must be a power of 2");
1039   }
1040
1041   if (getLexer().isNot(AsmToken::EndOfStatement))
1042     return TokError("unexpected token in '.comm' or '.lcomm' directive");
1043
1044   Lex();
1045
1046   // NOTE: a size of zero for a .comm should create a undefined symbol
1047   // but a size of .lcomm creates a bss symbol of size zero.
1048   if (Size < 0)
1049     return Error(SizeLoc, "invalid '.comm' or '.lcomm' directive size, can't "
1050                           "be less than zero");
1051
1052   // NOTE: The alignment in the directive is a power of 2 value, the assembler
1053   // may internally end up wanting an alignment in bytes.
1054   // FIXME: Diagnose overflow.
1055   if (ByteAlignment < 0)
1056     return Error(ByteAlignmentLoc, "invalid '.comm' or '.lcomm' directive "
1057                                    "alignment, can't be less than zero");
1058
1059   if (!Sym->isUndefined())
1060     return Error(Loc, "invalid symbol redefinition");
1061
1062   HexagonMCELFStreamer &HexagonELFStreamer =
1063       static_cast<HexagonMCELFStreamer &>(getStreamer());
1064   if (IsLocal) {
1065     HexagonELFStreamer.HexagonMCEmitLocalCommonSymbol(Sym, Size, ByteAlignment,
1066                                                       AccessAlignment);
1067     return false;
1068   }
1069
1070   HexagonELFStreamer.HexagonMCEmitCommonSymbol(Sym, Size, ByteAlignment,
1071                                                AccessAlignment);
1072   return false;
1073 }
1074
1075 // validate register against architecture
1076 bool HexagonAsmParser::RegisterMatchesArch(unsigned MatchNum) const {
1077   return true;
1078 }
1079
1080 // extern "C" void LLVMInitializeHexagonAsmLexer();
1081
1082 /// Force static initialization.
1083 extern "C" void LLVMInitializeHexagonAsmParser() {
1084   RegisterMCAsmParser<HexagonAsmParser> X(TheHexagonTarget);
1085 }
1086
1087 #define GET_MATCHER_IMPLEMENTATION
1088 #define GET_REGISTER_MATCHER
1089 #include "HexagonGenAsmMatcher.inc"
1090
1091 namespace {
1092 bool previousEqual(OperandVector &Operands, size_t Index, StringRef String) {
1093   if (Index >= Operands.size())
1094     return false;
1095   MCParsedAsmOperand &Operand = *Operands[Operands.size() - Index - 1];
1096   if (!Operand.isToken())
1097     return false;
1098   return static_cast<HexagonOperand &>(Operand).getToken().equals_lower(String);
1099 }
1100 bool previousIsLoop(OperandVector &Operands, size_t Index) {
1101   return previousEqual(Operands, Index, "loop0") ||
1102          previousEqual(Operands, Index, "loop1") ||
1103          previousEqual(Operands, Index, "sp1loop0") ||
1104          previousEqual(Operands, Index, "sp2loop0") ||
1105          previousEqual(Operands, Index, "sp3loop0");
1106 }
1107 }
1108
1109 bool HexagonAsmParser::splitIdentifier(OperandVector &Operands) {
1110   AsmToken const &Token = getParser().getTok();
1111   StringRef String = Token.getString();
1112   SMLoc Loc = Token.getLoc();
1113   getLexer().Lex();
1114   do {
1115     std::pair<StringRef, StringRef> HeadTail = String.split('.');
1116     if (!HeadTail.first.empty())
1117       Operands.push_back(HexagonOperand::CreateToken(HeadTail.first, Loc));
1118     if (!HeadTail.second.empty())
1119       Operands.push_back(HexagonOperand::CreateToken(
1120           String.substr(HeadTail.first.size(), 1), Loc));
1121     String = HeadTail.second;
1122   } while (!String.empty());
1123   return false;
1124 }
1125
1126 bool HexagonAsmParser::parseOperand(OperandVector &Operands) {
1127   unsigned Register;
1128   SMLoc Begin;
1129   SMLoc End;
1130   MCAsmLexer &Lexer = getLexer();
1131   if (!ParseRegister(Register, Begin, End)) {
1132     if (!ErrorMissingParenthesis)
1133       switch (Register) {
1134       default:
1135         break;
1136       case Hexagon::P0:
1137       case Hexagon::P1:
1138       case Hexagon::P2:
1139       case Hexagon::P3:
1140         if (previousEqual(Operands, 0, "if")) {
1141           if (WarnMissingParenthesis)
1142             Warning (Begin, "Missing parenthesis around predicate register");
1143           static char const *LParen = "(";
1144           static char const *RParen = ")";
1145           Operands.push_back(HexagonOperand::CreateToken(LParen, Begin));
1146           Operands.push_back(HexagonOperand::CreateReg(Register, Begin, End));
1147           AsmToken MaybeDotNew = Lexer.getTok();
1148           if (MaybeDotNew.is(AsmToken::TokenKind::Identifier) &&
1149               MaybeDotNew.getString().equals_lower(".new"))
1150             splitIdentifier(Operands);
1151           Operands.push_back(HexagonOperand::CreateToken(RParen, Begin));
1152           return false;
1153         }
1154         if (previousEqual(Operands, 0, "!") &&
1155             previousEqual(Operands, 1, "if")) {
1156           if (WarnMissingParenthesis)
1157             Warning (Begin, "Missing parenthesis around predicate register");
1158           static char const *LParen = "(";
1159           static char const *RParen = ")";
1160           Operands.insert(Operands.end () - 1,
1161                           HexagonOperand::CreateToken(LParen, Begin));
1162           Operands.push_back(HexagonOperand::CreateReg(Register, Begin, End));
1163           AsmToken MaybeDotNew = Lexer.getTok();
1164           if (MaybeDotNew.is(AsmToken::TokenKind::Identifier) &&
1165               MaybeDotNew.getString().equals_lower(".new"))
1166             splitIdentifier(Operands);
1167           Operands.push_back(HexagonOperand::CreateToken(RParen, Begin));
1168           return false;
1169         }
1170         break;
1171       }
1172     Operands.push_back(HexagonOperand::CreateReg(
1173         Register, Begin, End));
1174     return false;
1175   }
1176   return splitIdentifier(Operands);
1177 }
1178
1179 bool HexagonAsmParser::isLabel(AsmToken &Token) {
1180   MCAsmLexer &Lexer = getLexer();
1181   AsmToken const &Second = Lexer.getTok();
1182   AsmToken Third = Lexer.peekTok();
1183   StringRef String = Token.getString();
1184   if (Token.is(AsmToken::TokenKind::LCurly) ||
1185       Token.is(AsmToken::TokenKind::RCurly))
1186     return false;
1187   if (!Token.is(AsmToken::TokenKind::Identifier))
1188     return true;
1189   if (!MatchRegisterName(String.lower()))
1190     return true;
1191   (void)Second;
1192   assert(Second.is(AsmToken::Colon));
1193   StringRef Raw (String.data(), Third.getString().data() - String.data() +
1194                  Third.getString().size());
1195   std::string Collapsed = Raw;
1196   Collapsed.erase(std::remove_if(Collapsed.begin(), Collapsed.end(), isspace),
1197                   Collapsed.end());
1198   StringRef Whole = Collapsed;
1199   std::pair<StringRef, StringRef> DotSplit = Whole.split('.');
1200   if (!MatchRegisterName(DotSplit.first.lower()))
1201     return true;
1202   return false;
1203 }
1204
1205 bool HexagonAsmParser::handleNoncontigiousRegister(bool Contigious, SMLoc &Loc) {
1206   if (!Contigious && ErrorNoncontigiousRegister) {
1207     Error(Loc, "Register name is not contigious");
1208     return true;
1209   }
1210   if (!Contigious && WarnNoncontigiousRegister)
1211     Warning(Loc, "Register name is not contigious");
1212   return false;
1213 }
1214
1215 bool HexagonAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) {
1216   MCAsmLexer &Lexer = getLexer();
1217   StartLoc = getLexer().getLoc();
1218   SmallVector<AsmToken, 5> Lookahead;
1219   StringRef RawString(Lexer.getTok().getString().data(), 0);
1220   bool Again = Lexer.is(AsmToken::Identifier);
1221   bool NeededWorkaround = false;
1222   while (Again) {
1223     AsmToken const &Token = Lexer.getTok();
1224     RawString = StringRef(RawString.data(),
1225                           Token.getString().data() - RawString.data () +
1226                           Token.getString().size());
1227     Lookahead.push_back(Token);
1228     Lexer.Lex();
1229     bool Contigious = Lexer.getTok().getString().data() ==
1230                       Lookahead.back().getString().data() +
1231                       Lookahead.back().getString().size();
1232     bool Type = Lexer.is(AsmToken::Identifier) || Lexer.is(AsmToken::Dot) ||
1233                 Lexer.is(AsmToken::Integer) || Lexer.is(AsmToken::Real) ||
1234                 Lexer.is(AsmToken::Colon);
1235     bool Workaround = Lexer.is(AsmToken::Colon) ||
1236                       Lookahead.back().is(AsmToken::Colon);
1237     Again = (Contigious && Type) || (Workaround && Type);
1238     NeededWorkaround = NeededWorkaround || (Again && !(Contigious && Type));
1239   }
1240   std::string Collapsed = RawString;
1241   Collapsed.erase(std::remove_if(Collapsed.begin(), Collapsed.end(), isspace),
1242                   Collapsed.end());
1243   StringRef FullString = Collapsed;
1244   std::pair<StringRef, StringRef> DotSplit = FullString.split('.');
1245   unsigned DotReg = MatchRegisterName(DotSplit.first.lower());
1246   if (DotReg != Hexagon::NoRegister && RegisterMatchesArch(DotReg)) {
1247     if (DotSplit.second.empty()) {
1248       RegNo = DotReg;
1249       EndLoc = Lexer.getLoc();
1250       if (handleNoncontigiousRegister(!NeededWorkaround, StartLoc))
1251         return true;
1252       return false;
1253     } else {
1254       RegNo = DotReg;
1255       size_t First = RawString.find('.');
1256       StringRef DotString (RawString.data() + First, RawString.size() - First);
1257       Lexer.UnLex(AsmToken(AsmToken::Identifier, DotString));
1258       EndLoc = Lexer.getLoc();
1259       if (handleNoncontigiousRegister(!NeededWorkaround, StartLoc))
1260         return true;
1261       return false;
1262     }
1263   }
1264   std::pair<StringRef, StringRef> ColonSplit = StringRef(FullString).split(':');
1265   unsigned ColonReg = MatchRegisterName(ColonSplit.first.lower());
1266   if (ColonReg != Hexagon::NoRegister && RegisterMatchesArch(DotReg)) {
1267     Lexer.UnLex(Lookahead.back());
1268     Lookahead.pop_back();
1269     Lexer.UnLex(Lookahead.back());
1270     Lookahead.pop_back();
1271     RegNo = ColonReg;
1272     EndLoc = Lexer.getLoc();
1273     if (handleNoncontigiousRegister(!NeededWorkaround, StartLoc))
1274       return true;
1275     return false;
1276   }
1277   while (!Lookahead.empty()) {
1278     Lexer.UnLex(Lookahead.back());
1279     Lookahead.pop_back();
1280   }
1281   return true;
1282 }
1283
1284 bool HexagonAsmParser::implicitExpressionLocation(OperandVector &Operands) {
1285   if (previousEqual(Operands, 0, "call"))
1286     return true;
1287   if (previousEqual(Operands, 0, "jump"))
1288     if (!getLexer().getTok().is(AsmToken::Colon))
1289       return true;
1290   if (previousEqual(Operands, 0, "(") && previousIsLoop(Operands, 1))
1291     return true;
1292   if (previousEqual(Operands, 1, ":") && previousEqual(Operands, 2, "jump") &&
1293       (previousEqual(Operands, 0, "nt") || previousEqual(Operands, 0, "t")))
1294     return true;
1295   return false;
1296 }
1297
1298 bool HexagonAsmParser::parseExpression(MCExpr const *& Expr) {
1299   llvm::SmallVector<AsmToken, 4> Tokens;
1300   MCAsmLexer &Lexer = getLexer();
1301   bool Done = false;
1302   static char const * Comma = ",";
1303   do {
1304     Tokens.emplace_back (Lexer.getTok());
1305     Lexer.Lex();
1306     switch (Tokens.back().getKind())
1307     {
1308     case AsmToken::TokenKind::Hash:
1309       if (Tokens.size () > 1)
1310         if ((Tokens.end () - 2)->getKind() == AsmToken::TokenKind::Plus) {
1311           Tokens.insert(Tokens.end() - 2,
1312                         AsmToken(AsmToken::TokenKind::Comma, Comma));
1313           Done = true;
1314         }
1315       break;
1316     case AsmToken::TokenKind::RCurly:
1317     case AsmToken::TokenKind::EndOfStatement:
1318     case AsmToken::TokenKind::Eof:
1319       Done = true;
1320       break;
1321     default:
1322       break;
1323     }
1324   } while (!Done);
1325   while (!Tokens.empty()) {
1326     Lexer.UnLex(Tokens.back());
1327     Tokens.pop_back();
1328   }
1329   return getParser().parseExpression(Expr);
1330 }
1331
1332 bool HexagonAsmParser::parseExpressionOrOperand(OperandVector &Operands) {
1333   if (implicitExpressionLocation(Operands)) {
1334     MCAsmParser &Parser = getParser();
1335     SMLoc Loc = Parser.getLexer().getLoc();
1336     std::unique_ptr<HexagonOperand> Expr =
1337         HexagonOperand::CreateImm(nullptr, Loc, Loc);
1338     MCExpr const *& Val = Expr->Imm.Val;
1339     Operands.push_back(std::move(Expr));
1340     return parseExpression(Val);
1341   }
1342   return parseOperand(Operands);
1343 }
1344
1345 /// Parse an instruction.
1346 bool HexagonAsmParser::parseInstruction(OperandVector &Operands) {
1347   MCAsmParser &Parser = getParser();
1348   MCAsmLexer &Lexer = getLexer();
1349   while (true) {
1350     AsmToken const &Token = Parser.getTok();
1351     switch (Token.getKind()) {
1352     case AsmToken::EndOfStatement: {
1353       Lexer.Lex();
1354       return false;
1355     }
1356     case AsmToken::LCurly: {
1357       if (!Operands.empty())
1358         return true;
1359       Operands.push_back(
1360           HexagonOperand::CreateToken(Token.getString(), Token.getLoc()));
1361       Lexer.Lex();
1362       return false;
1363     }
1364     case AsmToken::RCurly: {
1365       if (Operands.empty()) {
1366         Operands.push_back(
1367             HexagonOperand::CreateToken(Token.getString(), Token.getLoc()));
1368         Lexer.Lex();
1369       }
1370       return false;
1371     }
1372     case AsmToken::Comma: {
1373       Lexer.Lex();
1374       continue;
1375     }
1376     case AsmToken::EqualEqual:
1377     case AsmToken::ExclaimEqual:
1378     case AsmToken::GreaterEqual:
1379     case AsmToken::GreaterGreater:
1380     case AsmToken::LessEqual:
1381     case AsmToken::LessLess: {
1382       Operands.push_back(HexagonOperand::CreateToken(
1383           Token.getString().substr(0, 1), Token.getLoc()));
1384       Operands.push_back(HexagonOperand::CreateToken(
1385           Token.getString().substr(1, 1), Token.getLoc()));
1386       Lexer.Lex();
1387       continue;
1388     }
1389     case AsmToken::Hash: {
1390       bool MustNotExtend = false;
1391       bool ImplicitExpression = implicitExpressionLocation(Operands);
1392       std::unique_ptr<HexagonOperand> Expr = HexagonOperand::CreateImm(
1393           nullptr, Lexer.getLoc(), Lexer.getLoc());
1394       if (!ImplicitExpression)
1395         Operands.push_back(
1396           HexagonOperand::CreateToken(Token.getString(), Token.getLoc()));
1397       Lexer.Lex();
1398       bool MustExtend = false;
1399       bool HiOnly = false;
1400       bool LoOnly = false;
1401       if (Lexer.is(AsmToken::Hash)) {
1402         Lexer.Lex();
1403         MustExtend = true;
1404       } else if (ImplicitExpression)
1405         MustNotExtend = true;
1406       AsmToken const &Token = Parser.getTok();
1407       if (Token.is(AsmToken::Identifier)) {
1408         StringRef String = Token.getString();
1409         AsmToken IDToken = Token;
1410         if (String.lower() == "hi") {
1411           HiOnly = true;
1412         } else if (String.lower() == "lo") {
1413           LoOnly = true;
1414         }
1415         if (HiOnly || LoOnly) {
1416           AsmToken LParen = Lexer.peekTok();
1417           if (!LParen.is(AsmToken::LParen)) {
1418             HiOnly = false;
1419             LoOnly = false;
1420           } else {
1421             Lexer.Lex();
1422           }
1423         }
1424       }
1425       if (parseExpression(Expr->Imm.Val))
1426         return true;
1427       int64_t Value;
1428       MCContext &Context = Parser.getContext();
1429       assert(Expr->Imm.Val != nullptr);
1430       if (Expr->Imm.Val->evaluateAsAbsolute(Value)) {
1431         if (HiOnly)
1432           Expr->Imm.Val = MCBinaryExpr::createLShr(
1433               Expr->Imm.Val, MCConstantExpr::create(16, Context), Context);
1434         if (HiOnly || LoOnly)
1435           Expr->Imm.Val = MCBinaryExpr::createAnd(
1436               Expr->Imm.Val, MCConstantExpr::create(0xffff, Context), Context);
1437       }
1438       if (MustNotExtend)
1439         Expr->Imm.Val = HexagonNoExtendOperand::Create(Expr->Imm.Val, Context);
1440       Expr->Imm.MustExtend = MustExtend;
1441       Operands.push_back(std::move(Expr));
1442       continue;
1443     }
1444     default:
1445       break;
1446     }
1447     if (parseExpressionOrOperand(Operands))
1448       return true;
1449   }
1450 }
1451
1452 bool HexagonAsmParser::ParseInstruction(ParseInstructionInfo &Info,
1453                                         StringRef Name,
1454                                         AsmToken ID,
1455                                         OperandVector &Operands) {
1456   getLexer().UnLex(ID);
1457   return parseInstruction(Operands);
1458 }
1459
1460 namespace {
1461 MCInst makeCombineInst(int opCode, MCOperand &Rdd,
1462                        MCOperand &MO1, MCOperand &MO2) {
1463   MCInst TmpInst;
1464   TmpInst.setOpcode(opCode);
1465   TmpInst.addOperand(Rdd);
1466   TmpInst.addOperand(MO1);
1467   TmpInst.addOperand(MO2);
1468
1469   return TmpInst;
1470 }
1471 }
1472
1473 // Define this matcher function after the auto-generated include so we
1474 // have the match class enum definitions.
1475 unsigned HexagonAsmParser::validateTargetOperandClass(MCParsedAsmOperand &AsmOp,
1476                                                       unsigned Kind) {
1477   HexagonOperand *Op = static_cast<HexagonOperand *>(&AsmOp);
1478
1479   switch (Kind) {
1480   case MCK_0: {
1481     int64_t Value;
1482     return Op->isImm() && Op->Imm.Val->evaluateAsAbsolute(Value) && Value == 0
1483                ? Match_Success
1484                : Match_InvalidOperand;
1485   }
1486   case MCK_1: {
1487     int64_t Value;
1488     return Op->isImm() && Op->Imm.Val->evaluateAsAbsolute(Value) && Value == 1
1489                ? Match_Success
1490                : Match_InvalidOperand;
1491   }
1492   case MCK__MINUS_1: {
1493     int64_t Value;
1494     return Op->isImm() && Op->Imm.Val->evaluateAsAbsolute(Value) && Value == -1
1495                ? Match_Success
1496                : Match_InvalidOperand;
1497   }
1498   }
1499   if (Op->Kind == HexagonOperand::Token && Kind != InvalidMatchClass) {
1500     StringRef myStringRef = StringRef(Op->Tok.Data, Op->Tok.Length);
1501     if (matchTokenString(myStringRef.lower()) == (MatchClassKind)Kind)
1502       return Match_Success;
1503     if (matchTokenString(myStringRef.upper()) == (MatchClassKind)Kind)
1504       return Match_Success;
1505   }
1506
1507   DEBUG(dbgs() << "Unmatched Operand:");
1508   DEBUG(Op->dump());
1509   DEBUG(dbgs() << "\n");
1510
1511   return Match_InvalidOperand;
1512 }
1513
1514 void HexagonAsmParser::OutOfRange(SMLoc IDLoc, long long Val, long long Max) {
1515   std::string errStr;
1516   raw_string_ostream ES(errStr);
1517   ES << "value " << Val << "(" << format("0x%" PRIx64, Val)
1518          << ") out of range: ";
1519   if (Max >= 0)
1520     ES << "0-" << Max;
1521   else
1522     ES << Max << "-" << (-Max - 1);
1523   Error(IDLoc, ES.str().c_str());
1524 }
1525
1526 int HexagonAsmParser::processInstruction(MCInst &Inst,
1527                                          OperandVector const &Operands,
1528                                          SMLoc IDLoc, bool &MustExtend) {
1529   MCContext &Context = getParser().getContext();
1530   const MCRegisterInfo *RI = getContext().getRegisterInfo();
1531   std::string r = "r";
1532   std::string v = "v";
1533   std::string Colon = ":";
1534
1535   bool is32bit = false; // used to distinguish between CONST32 and CONST64
1536   switch (Inst.getOpcode()) {
1537   default:
1538     break;
1539
1540   case Hexagon::M4_mpyrr_addr:
1541   case Hexagon::S4_addi_asl_ri:
1542   case Hexagon::S4_addi_lsr_ri:
1543   case Hexagon::S4_andi_asl_ri:
1544   case Hexagon::S4_andi_lsr_ri:
1545   case Hexagon::S4_ori_asl_ri:
1546   case Hexagon::S4_ori_lsr_ri:
1547   case Hexagon::S4_or_andix:
1548   case Hexagon::S4_subi_asl_ri:
1549   case Hexagon::S4_subi_lsr_ri: {
1550     MCOperand &Ry = Inst.getOperand(0);
1551     MCOperand &src = Inst.getOperand(2);
1552     if (RI->getEncodingValue(Ry.getReg()) != RI->getEncodingValue(src.getReg()))
1553       return Match_InvalidOperand;
1554     break;
1555   }
1556
1557   case Hexagon::C2_cmpgei: {
1558     MCOperand &MO = Inst.getOperand(2);
1559     MO.setExpr(MCBinaryExpr::createSub(
1560         MO.getExpr(), MCConstantExpr::create(1, Context), Context));
1561     Inst.setOpcode(Hexagon::C2_cmpgti);
1562     break;
1563   }
1564
1565   case Hexagon::C2_cmpgeui: {
1566     MCOperand &MO = Inst.getOperand(2);
1567     int64_t Value;
1568     bool Success = MO.getExpr()->evaluateAsAbsolute(Value);
1569     (void)Success;
1570     assert(Success && "Assured by matcher");
1571     if (Value == 0) {
1572       MCInst TmpInst;
1573       MCOperand &Pd = Inst.getOperand(0);
1574       MCOperand &Rt = Inst.getOperand(1);
1575       TmpInst.setOpcode(Hexagon::C2_cmpeq);
1576       TmpInst.addOperand(Pd);
1577       TmpInst.addOperand(Rt);
1578       TmpInst.addOperand(Rt);
1579       Inst = TmpInst;
1580     } else {
1581       MO.setExpr(MCBinaryExpr::createSub(
1582           MO.getExpr(), MCConstantExpr::create(1, Context), Context));
1583       Inst.setOpcode(Hexagon::C2_cmpgtui);
1584     }
1585     break;
1586   }
1587   case Hexagon::J2_loop1r:
1588   case Hexagon::J2_loop1i:
1589   case Hexagon::J2_loop0r:
1590   case Hexagon::J2_loop0i: {
1591     MCOperand &MO = Inst.getOperand(0);
1592     // Loop has different opcodes for extended vs not extended, but we should
1593     //   not use the other opcode as it is a legacy artifact of TD files.
1594     int64_t Value;
1595     if (MO.getExpr()->evaluateAsAbsolute(Value)) {
1596       // if the the operand can fit within a 7:2 field
1597       if (Value < (1 << 8) && Value >= -(1 << 8)) {
1598         SMLoc myLoc = Operands[2]->getStartLoc();
1599         // # is left in startLoc in the case of ##
1600         // If '##' found then force extension.
1601         if (*myLoc.getPointer() == '#') {
1602           MustExtend = true;
1603           break;
1604         }
1605       } else {
1606         // If immediate and out of 7:2 range.
1607         MustExtend = true;
1608       }
1609     }
1610     break;
1611   }
1612
1613   // Translate a "$Rdd = $Rss" to "$Rdd = combine($Rs, $Rt)"
1614   case Hexagon::A2_tfrp: {
1615     MCOperand &MO = Inst.getOperand(1);
1616     unsigned int RegPairNum = RI->getEncodingValue(MO.getReg());
1617     std::string R1 = r + llvm::utostr_32(RegPairNum + 1);
1618     StringRef Reg1(R1);
1619     MO.setReg(MatchRegisterName(Reg1));
1620     // Add a new operand for the second register in the pair.
1621     std::string R2 = r + llvm::utostr_32(RegPairNum);
1622     StringRef Reg2(R2);
1623     Inst.addOperand(MCOperand::createReg(MatchRegisterName(Reg2)));
1624     Inst.setOpcode(Hexagon::A2_combinew);
1625     break;
1626   }
1627
1628   case Hexagon::A2_tfrpt:
1629   case Hexagon::A2_tfrpf: {
1630     MCOperand &MO = Inst.getOperand(2);
1631     unsigned int RegPairNum = RI->getEncodingValue(MO.getReg());
1632     std::string R1 = r + llvm::utostr_32(RegPairNum + 1);
1633     StringRef Reg1(R1);
1634     MO.setReg(MatchRegisterName(Reg1));
1635     // Add a new operand for the second register in the pair.
1636     std::string R2 = r + llvm::utostr_32(RegPairNum);
1637     StringRef Reg2(R2);
1638     Inst.addOperand(MCOperand::createReg(MatchRegisterName(Reg2)));
1639     Inst.setOpcode((Inst.getOpcode() == Hexagon::A2_tfrpt)
1640                        ? Hexagon::C2_ccombinewt
1641                        : Hexagon::C2_ccombinewf);
1642     break;
1643   }
1644   case Hexagon::A2_tfrptnew:
1645   case Hexagon::A2_tfrpfnew: {
1646     MCOperand &MO = Inst.getOperand(2);
1647     unsigned int RegPairNum = RI->getEncodingValue(MO.getReg());
1648     std::string R1 = r + llvm::utostr_32(RegPairNum + 1);
1649     StringRef Reg1(R1);
1650     MO.setReg(MatchRegisterName(Reg1));
1651     // Add a new operand for the second register in the pair.
1652     std::string R2 = r + llvm::utostr_32(RegPairNum);
1653     StringRef Reg2(R2);
1654     Inst.addOperand(MCOperand::createReg(MatchRegisterName(Reg2)));
1655     Inst.setOpcode((Inst.getOpcode() == Hexagon::A2_tfrptnew)
1656                        ? Hexagon::C2_ccombinewnewt
1657                        : Hexagon::C2_ccombinewnewf);
1658     break;
1659   }
1660
1661   // Translate a "$Rx =  CONST32(#imm)" to "$Rx = memw(gp+#LABEL) "
1662   case Hexagon::CONST32:
1663   case Hexagon::CONST32_Float_Real:
1664   case Hexagon::CONST32_Int_Real:
1665   case Hexagon::FCONST32_nsdata:
1666     is32bit = true;
1667   // Translate a "$Rx:y =  CONST64(#imm)" to "$Rx:y = memd(gp+#LABEL) "
1668   case Hexagon::CONST64_Float_Real:
1669   case Hexagon::CONST64_Int_Real:
1670
1671     // FIXME: need better way to detect AsmStreamer (upstream removed getKind())
1672     if (!Parser.getStreamer().hasRawTextSupport()) {
1673       MCELFStreamer *MES = static_cast<MCELFStreamer *>(&Parser.getStreamer());
1674       MCOperand &MO_1 = Inst.getOperand(1);
1675       MCOperand &MO_0 = Inst.getOperand(0);
1676
1677       // push section onto section stack
1678       MES->PushSection();
1679
1680       std::string myCharStr;
1681       MCSectionELF *mySection;
1682
1683       // check if this as an immediate or a symbol
1684       int64_t Value;
1685       bool Absolute = MO_1.getExpr()->evaluateAsAbsolute(Value);
1686       if (Absolute) {
1687         // Create a new section - one for each constant
1688         // Some or all of the zeros are replaced with the given immediate.
1689         if (is32bit) {
1690           std::string myImmStr = utohexstr(static_cast<uint32_t>(Value));
1691           myCharStr = StringRef(".gnu.linkonce.l4.CONST_00000000")
1692                           .drop_back(myImmStr.size())
1693                           .str() +
1694                       myImmStr;
1695         } else {
1696           std::string myImmStr = utohexstr(Value);
1697           myCharStr = StringRef(".gnu.linkonce.l8.CONST_0000000000000000")
1698                           .drop_back(myImmStr.size())
1699                           .str() +
1700                       myImmStr;
1701         }
1702
1703         mySection = getContext().getELFSection(myCharStr, ELF::SHT_PROGBITS,
1704                                                ELF::SHF_ALLOC | ELF::SHF_WRITE);
1705       } else if (MO_1.isExpr()) {
1706         // .lita - for expressions
1707         myCharStr = ".lita";
1708         mySection = getContext().getELFSection(myCharStr, ELF::SHT_PROGBITS,
1709                                                ELF::SHF_ALLOC | ELF::SHF_WRITE);
1710       } else
1711         llvm_unreachable("unexpected type of machine operand!");
1712
1713       MES->SwitchSection(mySection);
1714       unsigned byteSize = is32bit ? 4 : 8;
1715       getStreamer().EmitCodeAlignment(byteSize, byteSize);
1716
1717       MCSymbol *Sym;
1718
1719       // for symbols, get rid of prepended ".gnu.linkonce.lx."
1720
1721       // emit symbol if needed
1722       if (Absolute) {
1723         Sym = getContext().getOrCreateSymbol(StringRef(myCharStr.c_str() + 16));
1724         if (Sym->isUndefined()) {
1725           getStreamer().EmitLabel(Sym);
1726           getStreamer().EmitSymbolAttribute(Sym, MCSA_Global);
1727           getStreamer().EmitIntValue(Value, byteSize);
1728         }
1729       } else if (MO_1.isExpr()) {
1730         const char *StringStart = 0;
1731         const char *StringEnd = 0;
1732         if (*Operands[4]->getStartLoc().getPointer() == '#') {
1733           StringStart = Operands[5]->getStartLoc().getPointer();
1734           StringEnd = Operands[6]->getStartLoc().getPointer();
1735         } else { // no pound
1736           StringStart = Operands[4]->getStartLoc().getPointer();
1737           StringEnd = Operands[5]->getStartLoc().getPointer();
1738         }
1739
1740         unsigned size = StringEnd - StringStart;
1741         std::string DotConst = ".CONST_";
1742         Sym = getContext().getOrCreateSymbol(DotConst +
1743                                              StringRef(StringStart, size));
1744
1745         if (Sym->isUndefined()) {
1746           // case where symbol is not yet defined: emit symbol
1747           getStreamer().EmitLabel(Sym);
1748           getStreamer().EmitSymbolAttribute(Sym, MCSA_Local);
1749           getStreamer().EmitValue(MO_1.getExpr(), 4);
1750         }
1751       } else
1752         llvm_unreachable("unexpected type of machine operand!");
1753
1754       MES->PopSection();
1755
1756       if (Sym) {
1757         MCInst TmpInst;
1758         if (is32bit) // 32 bit
1759           TmpInst.setOpcode(Hexagon::L2_loadrigp);
1760         else // 64 bit
1761           TmpInst.setOpcode(Hexagon::L2_loadrdgp);
1762
1763         TmpInst.addOperand(MO_0);
1764         TmpInst.addOperand(
1765             MCOperand::createExpr(MCSymbolRefExpr::create(Sym, getContext())));
1766         Inst = TmpInst;
1767       }
1768     }
1769     break;
1770
1771   // Translate a "$Rdd = #-imm" to "$Rdd = combine(#[-1,0], #-imm)"
1772   case Hexagon::A2_tfrpi: {
1773     MCOperand &Rdd = Inst.getOperand(0);
1774     MCOperand &MO = Inst.getOperand(1);
1775     int64_t Value;
1776     int sVal = (MO.getExpr()->evaluateAsAbsolute(Value) && Value < 0) ? -1 : 0;
1777     MCOperand imm(MCOperand::createExpr(MCConstantExpr::create(sVal, Context)));
1778     Inst = makeCombineInst(Hexagon::A2_combineii, Rdd, imm, MO);
1779     break;
1780   }
1781
1782   // Translate a "$Rdd = [#]#imm" to "$Rdd = combine(#, [#]#imm)"
1783   case Hexagon::TFRI64_V4: {
1784     MCOperand &Rdd = Inst.getOperand(0);
1785     MCOperand &MO = Inst.getOperand(1);
1786     int64_t Value;
1787     if (MO.getExpr()->evaluateAsAbsolute(Value)) {
1788       unsigned long long u64 = Value;
1789       signed int s8 = (u64 >> 32) & 0xFFFFFFFF;
1790       if (s8 < -128 || s8 > 127)
1791         OutOfRange(IDLoc, s8, -128);
1792       MCOperand imm(MCOperand::createExpr(
1793           MCConstantExpr::create(s8, Context))); // upper 32
1794       MCOperand imm2(MCOperand::createExpr(
1795           MCConstantExpr::create(u64 & 0xFFFFFFFF, Context))); // lower 32
1796       Inst = makeCombineInst(Hexagon::A4_combineii, Rdd, imm, imm2);
1797     } else {
1798       MCOperand imm(MCOperand::createExpr(
1799           MCConstantExpr::create(0, Context))); // upper 32
1800       Inst = makeCombineInst(Hexagon::A4_combineii, Rdd, imm, MO);
1801     }
1802     break;
1803   }
1804
1805   // Handle $Rdd = combine(##imm, #imm)"
1806   case Hexagon::TFRI64_V2_ext: {
1807     MCOperand &Rdd = Inst.getOperand(0);
1808     MCOperand &MO1 = Inst.getOperand(1);
1809     MCOperand &MO2 = Inst.getOperand(2);
1810     int64_t Value;
1811     if (MO2.getExpr()->evaluateAsAbsolute(Value)) {
1812       int s8 = Value;
1813       if (s8 < -128 || s8 > 127)
1814         OutOfRange(IDLoc, s8, -128);
1815     }
1816     Inst = makeCombineInst(Hexagon::A2_combineii, Rdd, MO1, MO2);
1817     break;
1818   }
1819
1820   // Handle $Rdd = combine(#imm, ##imm)"
1821   case Hexagon::A4_combineii: {
1822     MCOperand &Rdd = Inst.getOperand(0);
1823     MCOperand &MO1 = Inst.getOperand(1);
1824     int64_t Value;
1825     if (MO1.getExpr()->evaluateAsAbsolute(Value)) {
1826       int s8 = Value;
1827       if (s8 < -128 || s8 > 127)
1828         OutOfRange(IDLoc, s8, -128);
1829     }
1830     MCOperand &MO2 = Inst.getOperand(2);
1831     Inst = makeCombineInst(Hexagon::A4_combineii, Rdd, MO1, MO2);
1832     break;
1833   }
1834
1835   case Hexagon::S2_tableidxb_goodsyntax: {
1836     Inst.setOpcode(Hexagon::S2_tableidxb);
1837     break;
1838   }
1839
1840   case Hexagon::S2_tableidxh_goodsyntax: {
1841     MCInst TmpInst;
1842     MCOperand &Rx = Inst.getOperand(0);
1843     MCOperand &_dst_ = Inst.getOperand(1);
1844     MCOperand &Rs = Inst.getOperand(2);
1845     MCOperand &Imm4 = Inst.getOperand(3);
1846     MCOperand &Imm6 = Inst.getOperand(4);
1847     Imm6.setExpr(MCBinaryExpr::createSub(
1848         Imm6.getExpr(), MCConstantExpr::create(1, Context), Context));
1849     TmpInst.setOpcode(Hexagon::S2_tableidxh);
1850     TmpInst.addOperand(Rx);
1851     TmpInst.addOperand(_dst_);
1852     TmpInst.addOperand(Rs);
1853     TmpInst.addOperand(Imm4);
1854     TmpInst.addOperand(Imm6);
1855     Inst = TmpInst;
1856     break;
1857   }
1858
1859   case Hexagon::S2_tableidxw_goodsyntax: {
1860     MCInst TmpInst;
1861     MCOperand &Rx = Inst.getOperand(0);
1862     MCOperand &_dst_ = Inst.getOperand(1);
1863     MCOperand &Rs = Inst.getOperand(2);
1864     MCOperand &Imm4 = Inst.getOperand(3);
1865     MCOperand &Imm6 = Inst.getOperand(4);
1866     Imm6.setExpr(MCBinaryExpr::createSub(
1867         Imm6.getExpr(), MCConstantExpr::create(2, Context), Context));
1868     TmpInst.setOpcode(Hexagon::S2_tableidxw);
1869     TmpInst.addOperand(Rx);
1870     TmpInst.addOperand(_dst_);
1871     TmpInst.addOperand(Rs);
1872     TmpInst.addOperand(Imm4);
1873     TmpInst.addOperand(Imm6);
1874     Inst = TmpInst;
1875     break;
1876   }
1877
1878   case Hexagon::S2_tableidxd_goodsyntax: {
1879     MCInst TmpInst;
1880     MCOperand &Rx = Inst.getOperand(0);
1881     MCOperand &_dst_ = Inst.getOperand(1);
1882     MCOperand &Rs = Inst.getOperand(2);
1883     MCOperand &Imm4 = Inst.getOperand(3);
1884     MCOperand &Imm6 = Inst.getOperand(4);
1885     Imm6.setExpr(MCBinaryExpr::createSub(
1886         Imm6.getExpr(), MCConstantExpr::create(3, Context), Context));
1887     TmpInst.setOpcode(Hexagon::S2_tableidxd);
1888     TmpInst.addOperand(Rx);
1889     TmpInst.addOperand(_dst_);
1890     TmpInst.addOperand(Rs);
1891     TmpInst.addOperand(Imm4);
1892     TmpInst.addOperand(Imm6);
1893     Inst = TmpInst;
1894     break;
1895   }
1896
1897   case Hexagon::M2_mpyui: {
1898     Inst.setOpcode(Hexagon::M2_mpyi);
1899     break;
1900   }
1901   case Hexagon::M2_mpysmi: {
1902     MCInst TmpInst;
1903     MCOperand &Rd = Inst.getOperand(0);
1904     MCOperand &Rs = Inst.getOperand(1);
1905     MCOperand &Imm = Inst.getOperand(2);
1906     int64_t Value;
1907     bool Absolute = Imm.getExpr()->evaluateAsAbsolute(Value);
1908     assert(Absolute);
1909     (void)Absolute;
1910     if (!MustExtend) {
1911       if (Value < 0 && Value > -256) {
1912         Imm.setExpr(MCConstantExpr::create(Value * -1, Context));
1913         TmpInst.setOpcode(Hexagon::M2_mpysin);
1914       } else if (Value < 256 && Value >= 0)
1915         TmpInst.setOpcode(Hexagon::M2_mpysip);
1916       else
1917         return Match_InvalidOperand;
1918     } else {
1919       if (Value >= 0)
1920         TmpInst.setOpcode(Hexagon::M2_mpysip);
1921       else
1922         return Match_InvalidOperand;
1923     }
1924     TmpInst.addOperand(Rd);
1925     TmpInst.addOperand(Rs);
1926     TmpInst.addOperand(Imm);
1927     Inst = TmpInst;
1928     break;
1929   }
1930
1931   case Hexagon::S2_asr_i_r_rnd_goodsyntax: {
1932     MCOperand &Imm = Inst.getOperand(2);
1933     MCInst TmpInst;
1934     int64_t Value;
1935     bool Absolute = Imm.getExpr()->evaluateAsAbsolute(Value);
1936     assert(Absolute);
1937     (void)Absolute;
1938     if (Value == 0) { // convert to $Rd = $Rs
1939       TmpInst.setOpcode(Hexagon::A2_tfr);
1940       MCOperand &Rd = Inst.getOperand(0);
1941       MCOperand &Rs = Inst.getOperand(1);
1942       TmpInst.addOperand(Rd);
1943       TmpInst.addOperand(Rs);
1944     } else {
1945       Imm.setExpr(MCBinaryExpr::createSub(
1946           Imm.getExpr(), MCConstantExpr::create(1, Context), Context));
1947       TmpInst.setOpcode(Hexagon::S2_asr_i_r_rnd);
1948       MCOperand &Rd = Inst.getOperand(0);
1949       MCOperand &Rs = Inst.getOperand(1);
1950       TmpInst.addOperand(Rd);
1951       TmpInst.addOperand(Rs);
1952       TmpInst.addOperand(Imm);
1953     }
1954     Inst = TmpInst;
1955     break;
1956   }
1957
1958   case Hexagon::S2_asr_i_p_rnd_goodsyntax: {
1959     MCOperand &Rdd = Inst.getOperand(0);
1960     MCOperand &Rss = Inst.getOperand(1);
1961     MCOperand &Imm = Inst.getOperand(2);
1962     int64_t Value;
1963     bool Absolute = Imm.getExpr()->evaluateAsAbsolute(Value);
1964     assert(Absolute);
1965     (void)Absolute;
1966     if (Value == 0) { // convert to $Rdd = combine ($Rs[0], $Rs[1])
1967       MCInst TmpInst;
1968       unsigned int RegPairNum = RI->getEncodingValue(Rss.getReg());
1969       std::string R1 = r + llvm::utostr_32(RegPairNum + 1);
1970       StringRef Reg1(R1);
1971       Rss.setReg(MatchRegisterName(Reg1));
1972       // Add a new operand for the second register in the pair.
1973       std::string R2 = r + llvm::utostr_32(RegPairNum);
1974       StringRef Reg2(R2);
1975       TmpInst.setOpcode(Hexagon::A2_combinew);
1976       TmpInst.addOperand(Rdd);
1977       TmpInst.addOperand(Rss);
1978       TmpInst.addOperand(MCOperand::createReg(MatchRegisterName(Reg2)));
1979       Inst = TmpInst;
1980     } else {
1981       Imm.setExpr(MCBinaryExpr::createSub(
1982           Imm.getExpr(), MCConstantExpr::create(1, Context), Context));
1983       Inst.setOpcode(Hexagon::S2_asr_i_p_rnd);
1984     }
1985     break;
1986   }
1987
1988   case Hexagon::A4_boundscheck: {
1989     MCOperand &Rs = Inst.getOperand(1);
1990     unsigned int RegNum = RI->getEncodingValue(Rs.getReg());
1991     if (RegNum & 1) { // Odd mapped to raw:hi, regpair is rodd:odd-1, like r3:2
1992       Inst.setOpcode(Hexagon::A4_boundscheck_hi);
1993       std::string Name =
1994           r + llvm::utostr_32(RegNum) + Colon + llvm::utostr_32(RegNum - 1);
1995       StringRef RegPair = Name;
1996       Rs.setReg(MatchRegisterName(RegPair));
1997     } else { // raw:lo
1998       Inst.setOpcode(Hexagon::A4_boundscheck_lo);
1999       std::string Name =
2000           r + llvm::utostr_32(RegNum + 1) + Colon + llvm::utostr_32(RegNum);
2001       StringRef RegPair = Name;
2002       Rs.setReg(MatchRegisterName(RegPair));
2003     }
2004     break;
2005   }
2006
2007   case Hexagon::A2_addsp: {
2008     MCOperand &Rs = Inst.getOperand(1);
2009     unsigned int RegNum = RI->getEncodingValue(Rs.getReg());
2010     if (RegNum & 1) { // Odd mapped to raw:hi
2011       Inst.setOpcode(Hexagon::A2_addsph);
2012       std::string Name =
2013           r + llvm::utostr_32(RegNum) + Colon + llvm::utostr_32(RegNum - 1);
2014       StringRef RegPair = Name;
2015       Rs.setReg(MatchRegisterName(RegPair));
2016     } else { // Even mapped raw:lo
2017       Inst.setOpcode(Hexagon::A2_addspl);
2018       std::string Name =
2019           r + llvm::utostr_32(RegNum + 1) + Colon + llvm::utostr_32(RegNum);
2020       StringRef RegPair = Name;
2021       Rs.setReg(MatchRegisterName(RegPair));
2022     }
2023     break;
2024   }
2025
2026   case Hexagon::M2_vrcmpys_s1: {
2027     MCOperand &Rt = Inst.getOperand(2);
2028     unsigned int RegNum = RI->getEncodingValue(Rt.getReg());
2029     if (RegNum & 1) { // Odd mapped to sat:raw:hi
2030       Inst.setOpcode(Hexagon::M2_vrcmpys_s1_h);
2031       std::string Name =
2032           r + llvm::utostr_32(RegNum) + Colon + llvm::utostr_32(RegNum - 1);
2033       StringRef RegPair = Name;
2034       Rt.setReg(MatchRegisterName(RegPair));
2035     } else { // Even mapped sat:raw:lo
2036       Inst.setOpcode(Hexagon::M2_vrcmpys_s1_l);
2037       std::string Name =
2038           r + llvm::utostr_32(RegNum + 1) + Colon + llvm::utostr_32(RegNum);
2039       StringRef RegPair = Name;
2040       Rt.setReg(MatchRegisterName(RegPair));
2041     }
2042     break;
2043   }
2044
2045   case Hexagon::M2_vrcmpys_acc_s1: {
2046     MCInst TmpInst;
2047     MCOperand &Rxx = Inst.getOperand(0);
2048     MCOperand &Rss = Inst.getOperand(2);
2049     MCOperand &Rt = Inst.getOperand(3);
2050     unsigned int RegNum = RI->getEncodingValue(Rt.getReg());
2051     if (RegNum & 1) { // Odd mapped to sat:raw:hi
2052       TmpInst.setOpcode(Hexagon::M2_vrcmpys_acc_s1_h);
2053       std::string Name =
2054           r + llvm::utostr_32(RegNum) + Colon + llvm::utostr_32(RegNum - 1);
2055       StringRef RegPair = Name;
2056       Rt.setReg(MatchRegisterName(RegPair));
2057     } else { // Even mapped sat:raw:lo
2058       TmpInst.setOpcode(Hexagon::M2_vrcmpys_acc_s1_l);
2059       std::string Name =
2060           r + llvm::utostr_32(RegNum + 1) + Colon + llvm::utostr_32(RegNum);
2061       StringRef RegPair = Name;
2062       Rt.setReg(MatchRegisterName(RegPair));
2063     }
2064     // Registers are in different positions
2065     TmpInst.addOperand(Rxx);
2066     TmpInst.addOperand(Rxx);
2067     TmpInst.addOperand(Rss);
2068     TmpInst.addOperand(Rt);
2069     Inst = TmpInst;
2070     break;
2071   }
2072
2073   case Hexagon::M2_vrcmpys_s1rp: {
2074     MCOperand &Rt = Inst.getOperand(2);
2075     unsigned int RegNum = RI->getEncodingValue(Rt.getReg());
2076     if (RegNum & 1) { // Odd mapped to rnd:sat:raw:hi
2077       Inst.setOpcode(Hexagon::M2_vrcmpys_s1rp_h);
2078       std::string Name =
2079           r + llvm::utostr_32(RegNum) + Colon + llvm::utostr_32(RegNum - 1);
2080       StringRef RegPair = Name;
2081       Rt.setReg(MatchRegisterName(RegPair));
2082     } else { // Even mapped rnd:sat:raw:lo
2083       Inst.setOpcode(Hexagon::M2_vrcmpys_s1rp_l);
2084       std::string Name =
2085           r + llvm::utostr_32(RegNum + 1) + Colon + llvm::utostr_32(RegNum);
2086       StringRef RegPair = Name;
2087       Rt.setReg(MatchRegisterName(RegPair));
2088     }
2089     break;
2090   }
2091
2092   case Hexagon::S5_asrhub_rnd_sat_goodsyntax: {
2093     MCOperand &Imm = Inst.getOperand(2);
2094     int64_t Value;
2095     bool Absolute = Imm.getExpr()->evaluateAsAbsolute(Value);
2096     assert(Absolute);
2097     (void)Absolute;
2098     if (Value == 0)
2099       Inst.setOpcode(Hexagon::S2_vsathub);
2100     else {
2101       Imm.setExpr(MCBinaryExpr::createSub(
2102           Imm.getExpr(), MCConstantExpr::create(1, Context), Context));
2103       Inst.setOpcode(Hexagon::S5_asrhub_rnd_sat);
2104     }
2105     break;
2106   }
2107
2108   case Hexagon::S5_vasrhrnd_goodsyntax: {
2109     MCOperand &Rdd = Inst.getOperand(0);
2110     MCOperand &Rss = Inst.getOperand(1);
2111     MCOperand &Imm = Inst.getOperand(2);
2112     int64_t Value;
2113     bool Absolute = Imm.getExpr()->evaluateAsAbsolute(Value);
2114     assert(Absolute);
2115     (void)Absolute;
2116     if (Value == 0) {
2117       MCInst TmpInst;
2118       unsigned int RegPairNum = RI->getEncodingValue(Rss.getReg());
2119       std::string R1 = r + llvm::utostr_32(RegPairNum + 1);
2120       StringRef Reg1(R1);
2121       Rss.setReg(MatchRegisterName(Reg1));
2122       // Add a new operand for the second register in the pair.
2123       std::string R2 = r + llvm::utostr_32(RegPairNum);
2124       StringRef Reg2(R2);
2125       TmpInst.setOpcode(Hexagon::A2_combinew);
2126       TmpInst.addOperand(Rdd);
2127       TmpInst.addOperand(Rss);
2128       TmpInst.addOperand(MCOperand::createReg(MatchRegisterName(Reg2)));
2129       Inst = TmpInst;
2130     } else {
2131       Imm.setExpr(MCBinaryExpr::createSub(
2132           Imm.getExpr(), MCConstantExpr::create(1, Context), Context));
2133       Inst.setOpcode(Hexagon::S5_vasrhrnd);
2134     }
2135     break;
2136   }
2137
2138   case Hexagon::A2_not: {
2139     MCInst TmpInst;
2140     MCOperand &Rd = Inst.getOperand(0);
2141     MCOperand &Rs = Inst.getOperand(1);
2142     TmpInst.setOpcode(Hexagon::A2_subri);
2143     TmpInst.addOperand(Rd);
2144     TmpInst.addOperand(
2145         MCOperand::createExpr(MCConstantExpr::create(-1, Context)));
2146     TmpInst.addOperand(Rs);
2147     Inst = TmpInst;
2148     break;
2149   }
2150   } // switch
2151
2152   return Match_Success;
2153 }