1 //===-- ARMAsmParser.cpp - Parse ARM assembly 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 #include "llvm/MC/MCTargetAsmParser.h" 11 #include "MCTargetDesc/ARMAddressingModes.h" 12 #include "MCTargetDesc/ARMBaseInfo.h" 13 #include "MCTargetDesc/ARMMCExpr.h" 14 #include "llvm/ADT/BitVector.h" 15 #include "llvm/ADT/OwningPtr.h" 16 #include "llvm/ADT/STLExtras.h" 17 #include "llvm/ADT/SmallVector.h" 18 #include "llvm/ADT/StringSwitch.h" 19 #include "llvm/ADT/Twine.h" 20 #include "llvm/MC/MCAsmInfo.h" 21 #include "llvm/MC/MCAssembler.h" 22 #include "llvm/MC/MCContext.h" 23 #include "llvm/MC/MCELFStreamer.h" 24 #include "llvm/MC/MCExpr.h" 25 #include "llvm/MC/MCInst.h" 26 #include "llvm/MC/MCInstrDesc.h" 27 #include "llvm/MC/MCParser/MCAsmLexer.h" 28 #include "llvm/MC/MCParser/MCAsmParser.h" 29 #include "llvm/MC/MCParser/MCParsedAsmOperand.h" 30 #include "llvm/MC/MCRegisterInfo.h" 31 #include "llvm/MC/MCStreamer.h" 32 #include "llvm/MC/MCSubtargetInfo.h" 33 #include "llvm/Support/ELF.h" 34 #include "llvm/Support/MathExtras.h" 35 #include "llvm/Support/SourceMgr.h" 36 #include "llvm/Support/TargetRegistry.h" 37 #include "llvm/Support/raw_ostream.h" 38 39 using namespace llvm; 40 41 namespace { 42 43 class ARMOperand; 44 45 enum VectorLaneTy { NoLanes, AllLanes, IndexedLane }; 46 47 class ARMAsmParser : public MCTargetAsmParser { 48 MCSubtargetInfo &STI; 49 MCAsmParser &Parser; 50 const MCRegisterInfo *MRI; 51 52 // Unwind directives state 53 SMLoc FnStartLoc; 54 SMLoc CantUnwindLoc; 55 SMLoc PersonalityLoc; 56 SMLoc HandlerDataLoc; 57 int FPReg; 58 void resetUnwindDirectiveParserState() { 59 FnStartLoc = SMLoc(); 60 CantUnwindLoc = SMLoc(); 61 PersonalityLoc = SMLoc(); 62 HandlerDataLoc = SMLoc(); 63 FPReg = -1; 64 } 65 66 // Map of register aliases registers via the .req directive. 67 StringMap<unsigned> RegisterReqs; 68 69 struct { 70 ARMCC::CondCodes Cond; // Condition for IT block. 71 unsigned Mask:4; // Condition mask for instructions. 72 // Starting at first 1 (from lsb). 73 // '1' condition as indicated in IT. 74 // '0' inverse of condition (else). 75 // Count of instructions in IT block is 76 // 4 - trailingzeroes(mask) 77 78 bool FirstCond; // Explicit flag for when we're parsing the 79 // First instruction in the IT block. It's 80 // implied in the mask, so needs special 81 // handling. 82 83 unsigned CurPosition; // Current position in parsing of IT 84 // block. In range [0,3]. Initialized 85 // according to count of instructions in block. 86 // ~0U if no active IT block. 87 } ITState; 88 bool inITBlock() { return ITState.CurPosition != ~0U;} 89 void forwardITPosition() { 90 if (!inITBlock()) return; 91 // Move to the next instruction in the IT block, if there is one. If not, 92 // mark the block as done. 93 unsigned TZ = countTrailingZeros(ITState.Mask); 94 if (++ITState.CurPosition == 5 - TZ) 95 ITState.CurPosition = ~0U; // Done with the IT block after this. 96 } 97 98 99 MCAsmParser &getParser() const { return Parser; } 100 MCAsmLexer &getLexer() const { return Parser.getLexer(); } 101 102 bool Warning(SMLoc L, const Twine &Msg, 103 ArrayRef<SMRange> Ranges = None) { 104 return Parser.Warning(L, Msg, Ranges); 105 } 106 bool Error(SMLoc L, const Twine &Msg, 107 ArrayRef<SMRange> Ranges = None) { 108 return Parser.Error(L, Msg, Ranges); 109 } 110 111 int tryParseRegister(); 112 bool tryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &); 113 int tryParseShiftRegister(SmallVectorImpl<MCParsedAsmOperand*> &); 114 bool parseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &); 115 bool parseMemory(SmallVectorImpl<MCParsedAsmOperand*> &); 116 bool parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &, StringRef Mnemonic); 117 bool parsePrefix(ARMMCExpr::VariantKind &RefKind); 118 bool parseMemRegOffsetShift(ARM_AM::ShiftOpc &ShiftType, 119 unsigned &ShiftAmount); 120 bool parseDirectiveWord(unsigned Size, SMLoc L); 121 bool parseDirectiveThumb(SMLoc L); 122 bool parseDirectiveARM(SMLoc L); 123 bool parseDirectiveThumbFunc(SMLoc L); 124 bool parseDirectiveCode(SMLoc L); 125 bool parseDirectiveSyntax(SMLoc L); 126 bool parseDirectiveReq(StringRef Name, SMLoc L); 127 bool parseDirectiveUnreq(SMLoc L); 128 bool parseDirectiveArch(SMLoc L); 129 bool parseDirectiveEabiAttr(SMLoc L); 130 bool parseDirectiveFnStart(SMLoc L); 131 bool parseDirectiveFnEnd(SMLoc L); 132 bool parseDirectiveCantUnwind(SMLoc L); 133 bool parseDirectivePersonality(SMLoc L); 134 bool parseDirectiveHandlerData(SMLoc L); 135 bool parseDirectiveSetFP(SMLoc L); 136 bool parseDirectivePad(SMLoc L); 137 bool parseDirectiveRegSave(SMLoc L, bool IsVector); 138 139 StringRef splitMnemonic(StringRef Mnemonic, unsigned &PredicationCode, 140 bool &CarrySetting, unsigned &ProcessorIMod, 141 StringRef &ITMask); 142 void getMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet, 143 bool &CanAcceptPredicationCode); 144 145 bool isThumb() const { 146 // FIXME: Can tablegen auto-generate this? 147 return (STI.getFeatureBits() & ARM::ModeThumb) != 0; 148 } 149 bool isThumbOne() const { 150 return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2) == 0; 151 } 152 bool isThumbTwo() const { 153 return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2); 154 } 155 bool hasThumb() const { 156 return STI.getFeatureBits() & ARM::HasV4TOps; 157 } 158 bool hasV6Ops() const { 159 return STI.getFeatureBits() & ARM::HasV6Ops; 160 } 161 bool hasV7Ops() const { 162 return STI.getFeatureBits() & ARM::HasV7Ops; 163 } 164 bool hasV8Ops() const { 165 return STI.getFeatureBits() & ARM::HasV8Ops; 166 } 167 bool hasARM() const { 168 return !(STI.getFeatureBits() & ARM::FeatureNoARM); 169 } 170 171 void SwitchMode() { 172 unsigned FB = ComputeAvailableFeatures(STI.ToggleFeature(ARM::ModeThumb)); 173 setAvailableFeatures(FB); 174 } 175 bool isMClass() const { 176 return STI.getFeatureBits() & ARM::FeatureMClass; 177 } 178 179 /// @name Auto-generated Match Functions 180 /// { 181 182 #define GET_ASSEMBLER_HEADER 183 #include "ARMGenAsmMatcher.inc" 184 185 /// } 186 187 OperandMatchResultTy parseITCondCode(SmallVectorImpl<MCParsedAsmOperand*>&); 188 OperandMatchResultTy parseCoprocNumOperand( 189 SmallVectorImpl<MCParsedAsmOperand*>&); 190 OperandMatchResultTy parseCoprocRegOperand( 191 SmallVectorImpl<MCParsedAsmOperand*>&); 192 OperandMatchResultTy parseCoprocOptionOperand( 193 SmallVectorImpl<MCParsedAsmOperand*>&); 194 OperandMatchResultTy parseMemBarrierOptOperand( 195 SmallVectorImpl<MCParsedAsmOperand*>&); 196 OperandMatchResultTy parseInstSyncBarrierOptOperand( 197 SmallVectorImpl<MCParsedAsmOperand*>&); 198 OperandMatchResultTy parseProcIFlagsOperand( 199 SmallVectorImpl<MCParsedAsmOperand*>&); 200 OperandMatchResultTy parseMSRMaskOperand( 201 SmallVectorImpl<MCParsedAsmOperand*>&); 202 OperandMatchResultTy parsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &O, 203 StringRef Op, int Low, int High); 204 OperandMatchResultTy parsePKHLSLImm(SmallVectorImpl<MCParsedAsmOperand*> &O) { 205 return parsePKHImm(O, "lsl", 0, 31); 206 } 207 OperandMatchResultTy parsePKHASRImm(SmallVectorImpl<MCParsedAsmOperand*> &O) { 208 return parsePKHImm(O, "asr", 1, 32); 209 } 210 OperandMatchResultTy parseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*>&); 211 OperandMatchResultTy parseShifterImm(SmallVectorImpl<MCParsedAsmOperand*>&); 212 OperandMatchResultTy parseRotImm(SmallVectorImpl<MCParsedAsmOperand*>&); 213 OperandMatchResultTy parseBitfield(SmallVectorImpl<MCParsedAsmOperand*>&); 214 OperandMatchResultTy parsePostIdxReg(SmallVectorImpl<MCParsedAsmOperand*>&); 215 OperandMatchResultTy parseAM3Offset(SmallVectorImpl<MCParsedAsmOperand*>&); 216 OperandMatchResultTy parseFPImm(SmallVectorImpl<MCParsedAsmOperand*>&); 217 OperandMatchResultTy parseVectorList(SmallVectorImpl<MCParsedAsmOperand*>&); 218 OperandMatchResultTy parseVectorLane(VectorLaneTy &LaneKind, unsigned &Index, 219 SMLoc &EndLoc); 220 221 // Asm Match Converter Methods 222 void cvtThumbMultiply(MCInst &Inst, 223 const SmallVectorImpl<MCParsedAsmOperand*> &); 224 void cvtThumbBranches(MCInst &Inst, 225 const SmallVectorImpl<MCParsedAsmOperand*> &); 226 227 bool validateInstruction(MCInst &Inst, 228 const SmallVectorImpl<MCParsedAsmOperand*> &Ops); 229 bool processInstruction(MCInst &Inst, 230 const SmallVectorImpl<MCParsedAsmOperand*> &Ops); 231 bool shouldOmitCCOutOperand(StringRef Mnemonic, 232 SmallVectorImpl<MCParsedAsmOperand*> &Operands); 233 bool shouldOmitPredicateOperand(StringRef Mnemonic, 234 SmallVectorImpl<MCParsedAsmOperand*> &Operands); 235 bool isDeprecated(MCInst &Inst, StringRef &Info); 236 237 public: 238 enum ARMMatchResultTy { 239 Match_RequiresITBlock = FIRST_TARGET_MATCH_RESULT_TY, 240 Match_RequiresNotITBlock, 241 Match_RequiresV6, 242 Match_RequiresThumb2, 243 #define GET_OPERAND_DIAGNOSTIC_TYPES 244 #include "ARMGenAsmMatcher.inc" 245 246 }; 247 248 ARMAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser) 249 : MCTargetAsmParser(), STI(_STI), Parser(_Parser), FPReg(-1) { 250 MCAsmParserExtension::Initialize(_Parser); 251 252 // Cache the MCRegisterInfo. 253 MRI = getContext().getRegisterInfo(); 254 255 // Initialize the set of available features. 256 setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits())); 257 258 // Not in an ITBlock to start with. 259 ITState.CurPosition = ~0U; 260 261 // Set ELF header flags. 262 // FIXME: This should eventually end up somewhere else where more 263 // intelligent flag decisions can be made. For now we are just maintaining 264 // the statu/parseDirects quo for ARM and setting EF_ARM_EABI_VER5 as the default. 265 if (MCELFStreamer *MES = dyn_cast<MCELFStreamer>(&Parser.getStreamer())) 266 MES->getAssembler().setELFHeaderEFlags(ELF::EF_ARM_EABI_VER5); 267 } 268 269 // Implementation of the MCTargetAsmParser interface: 270 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc); 271 bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name, 272 SMLoc NameLoc, 273 SmallVectorImpl<MCParsedAsmOperand*> &Operands); 274 bool ParseDirective(AsmToken DirectiveID); 275 276 unsigned validateTargetOperandClass(MCParsedAsmOperand *Op, unsigned Kind); 277 unsigned checkTargetMatchPredicate(MCInst &Inst); 278 279 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode, 280 SmallVectorImpl<MCParsedAsmOperand*> &Operands, 281 MCStreamer &Out, unsigned &ErrorInfo, 282 bool MatchingInlineAsm); 283 }; 284 } // end anonymous namespace 285 286 namespace { 287 288 /// ARMOperand - Instances of this class represent a parsed ARM machine 289 /// operand. 290 class ARMOperand : public MCParsedAsmOperand { 291 enum KindTy { 292 k_CondCode, 293 k_CCOut, 294 k_ITCondMask, 295 k_CoprocNum, 296 k_CoprocReg, 297 k_CoprocOption, 298 k_Immediate, 299 k_MemBarrierOpt, 300 k_InstSyncBarrierOpt, 301 k_Memory, 302 k_PostIndexRegister, 303 k_MSRMask, 304 k_ProcIFlags, 305 k_VectorIndex, 306 k_Register, 307 k_RegisterList, 308 k_DPRRegisterList, 309 k_SPRRegisterList, 310 k_VectorList, 311 k_VectorListAllLanes, 312 k_VectorListIndexed, 313 k_ShiftedRegister, 314 k_ShiftedImmediate, 315 k_ShifterImmediate, 316 k_RotateImmediate, 317 k_BitfieldDescriptor, 318 k_Token 319 } Kind; 320 321 SMLoc StartLoc, EndLoc; 322 SmallVector<unsigned, 8> Registers; 323 324 struct CCOp { 325 ARMCC::CondCodes Val; 326 }; 327 328 struct CopOp { 329 unsigned Val; 330 }; 331 332 struct CoprocOptionOp { 333 unsigned Val; 334 }; 335 336 struct ITMaskOp { 337 unsigned Mask:4; 338 }; 339 340 struct MBOptOp { 341 ARM_MB::MemBOpt Val; 342 }; 343 344 struct ISBOptOp { 345 ARM_ISB::InstSyncBOpt Val; 346 }; 347 348 struct IFlagsOp { 349 ARM_PROC::IFlags Val; 350 }; 351 352 struct MMaskOp { 353 unsigned Val; 354 }; 355 356 struct TokOp { 357 const char *Data; 358 unsigned Length; 359 }; 360 361 struct RegOp { 362 unsigned RegNum; 363 }; 364 365 // A vector register list is a sequential list of 1 to 4 registers. 366 struct VectorListOp { 367 unsigned RegNum; 368 unsigned Count; 369 unsigned LaneIndex; 370 bool isDoubleSpaced; 371 }; 372 373 struct VectorIndexOp { 374 unsigned Val; 375 }; 376 377 struct ImmOp { 378 const MCExpr *Val; 379 }; 380 381 /// Combined record for all forms of ARM address expressions. 382 struct MemoryOp { 383 unsigned BaseRegNum; 384 // Offset is in OffsetReg or OffsetImm. If both are zero, no offset 385 // was specified. 386 const MCConstantExpr *OffsetImm; // Offset immediate value 387 unsigned OffsetRegNum; // Offset register num, when OffsetImm == NULL 388 ARM_AM::ShiftOpc ShiftType; // Shift type for OffsetReg 389 unsigned ShiftImm; // shift for OffsetReg. 390 unsigned Alignment; // 0 = no alignment specified 391 // n = alignment in bytes (2, 4, 8, 16, or 32) 392 unsigned isNegative : 1; // Negated OffsetReg? (~'U' bit) 393 }; 394 395 struct PostIdxRegOp { 396 unsigned RegNum; 397 bool isAdd; 398 ARM_AM::ShiftOpc ShiftTy; 399 unsigned ShiftImm; 400 }; 401 402 struct ShifterImmOp { 403 bool isASR; 404 unsigned Imm; 405 }; 406 407 struct RegShiftedRegOp { 408 ARM_AM::ShiftOpc ShiftTy; 409 unsigned SrcReg; 410 unsigned ShiftReg; 411 unsigned ShiftImm; 412 }; 413 414 struct RegShiftedImmOp { 415 ARM_AM::ShiftOpc ShiftTy; 416 unsigned SrcReg; 417 unsigned ShiftImm; 418 }; 419 420 struct RotImmOp { 421 unsigned Imm; 422 }; 423 424 struct BitfieldOp { 425 unsigned LSB; 426 unsigned Width; 427 }; 428 429 union { 430 struct CCOp CC; 431 struct CopOp Cop; 432 struct CoprocOptionOp CoprocOption; 433 struct MBOptOp MBOpt; 434 struct ISBOptOp ISBOpt; 435 struct ITMaskOp ITMask; 436 struct IFlagsOp IFlags; 437 struct MMaskOp MMask; 438 struct TokOp Tok; 439 struct RegOp Reg; 440 struct VectorListOp VectorList; 441 struct VectorIndexOp VectorIndex; 442 struct ImmOp Imm; 443 struct MemoryOp Memory; 444 struct PostIdxRegOp PostIdxReg; 445 struct ShifterImmOp ShifterImm; 446 struct RegShiftedRegOp RegShiftedReg; 447 struct RegShiftedImmOp RegShiftedImm; 448 struct RotImmOp RotImm; 449 struct BitfieldOp Bitfield; 450 }; 451 452 ARMOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {} 453 public: 454 ARMOperand(const ARMOperand &o) : MCParsedAsmOperand() { 455 Kind = o.Kind; 456 StartLoc = o.StartLoc; 457 EndLoc = o.EndLoc; 458 switch (Kind) { 459 case k_CondCode: 460 CC = o.CC; 461 break; 462 case k_ITCondMask: 463 ITMask = o.ITMask; 464 break; 465 case k_Token: 466 Tok = o.Tok; 467 break; 468 case k_CCOut: 469 case k_Register: 470 Reg = o.Reg; 471 break; 472 case k_RegisterList: 473 case k_DPRRegisterList: 474 case k_SPRRegisterList: 475 Registers = o.Registers; 476 break; 477 case k_VectorList: 478 case k_VectorListAllLanes: 479 case k_VectorListIndexed: 480 VectorList = o.VectorList; 481 break; 482 case k_CoprocNum: 483 case k_CoprocReg: 484 Cop = o.Cop; 485 break; 486 case k_CoprocOption: 487 CoprocOption = o.CoprocOption; 488 break; 489 case k_Immediate: 490 Imm = o.Imm; 491 break; 492 case k_MemBarrierOpt: 493 MBOpt = o.MBOpt; 494 break; 495 case k_InstSyncBarrierOpt: 496 ISBOpt = o.ISBOpt; 497 case k_Memory: 498 Memory = o.Memory; 499 break; 500 case k_PostIndexRegister: 501 PostIdxReg = o.PostIdxReg; 502 break; 503 case k_MSRMask: 504 MMask = o.MMask; 505 break; 506 case k_ProcIFlags: 507 IFlags = o.IFlags; 508 break; 509 case k_ShifterImmediate: 510 ShifterImm = o.ShifterImm; 511 break; 512 case k_ShiftedRegister: 513 RegShiftedReg = o.RegShiftedReg; 514 break; 515 case k_ShiftedImmediate: 516 RegShiftedImm = o.RegShiftedImm; 517 break; 518 case k_RotateImmediate: 519 RotImm = o.RotImm; 520 break; 521 case k_BitfieldDescriptor: 522 Bitfield = o.Bitfield; 523 break; 524 case k_VectorIndex: 525 VectorIndex = o.VectorIndex; 526 break; 527 } 528 } 529 530 /// getStartLoc - Get the location of the first token of this operand. 531 SMLoc getStartLoc() const { return StartLoc; } 532 /// getEndLoc - Get the location of the last token of this operand. 533 SMLoc getEndLoc() const { return EndLoc; } 534 /// getLocRange - Get the range between the first and last token of this 535 /// operand. 536 SMRange getLocRange() const { return SMRange(StartLoc, EndLoc); } 537 538 ARMCC::CondCodes getCondCode() const { 539 assert(Kind == k_CondCode && "Invalid access!"); 540 return CC.Val; 541 } 542 543 unsigned getCoproc() const { 544 assert((Kind == k_CoprocNum || Kind == k_CoprocReg) && "Invalid access!"); 545 return Cop.Val; 546 } 547 548 StringRef getToken() const { 549 assert(Kind == k_Token && "Invalid access!"); 550 return StringRef(Tok.Data, Tok.Length); 551 } 552 553 unsigned getReg() const { 554 assert((Kind == k_Register || Kind == k_CCOut) && "Invalid access!"); 555 return Reg.RegNum; 556 } 557 558 const SmallVectorImpl<unsigned> &getRegList() const { 559 assert((Kind == k_RegisterList || Kind == k_DPRRegisterList || 560 Kind == k_SPRRegisterList) && "Invalid access!"); 561 return Registers; 562 } 563 564 const MCExpr *getImm() const { 565 assert(isImm() && "Invalid access!"); 566 return Imm.Val; 567 } 568 569 unsigned getVectorIndex() const { 570 assert(Kind == k_VectorIndex && "Invalid access!"); 571 return VectorIndex.Val; 572 } 573 574 ARM_MB::MemBOpt getMemBarrierOpt() const { 575 assert(Kind == k_MemBarrierOpt && "Invalid access!"); 576 return MBOpt.Val; 577 } 578 579 ARM_ISB::InstSyncBOpt getInstSyncBarrierOpt() const { 580 assert(Kind == k_InstSyncBarrierOpt && "Invalid access!"); 581 return ISBOpt.Val; 582 } 583 584 ARM_PROC::IFlags getProcIFlags() const { 585 assert(Kind == k_ProcIFlags && "Invalid access!"); 586 return IFlags.Val; 587 } 588 589 unsigned getMSRMask() const { 590 assert(Kind == k_MSRMask && "Invalid access!"); 591 return MMask.Val; 592 } 593 594 bool isCoprocNum() const { return Kind == k_CoprocNum; } 595 bool isCoprocReg() const { return Kind == k_CoprocReg; } 596 bool isCoprocOption() const { return Kind == k_CoprocOption; } 597 bool isCondCode() const { return Kind == k_CondCode; } 598 bool isCCOut() const { return Kind == k_CCOut; } 599 bool isITMask() const { return Kind == k_ITCondMask; } 600 bool isITCondCode() const { return Kind == k_CondCode; } 601 bool isImm() const { return Kind == k_Immediate; } 602 // checks whether this operand is an unsigned offset which fits is a field 603 // of specified width and scaled by a specific number of bits 604 template<unsigned width, unsigned scale> 605 bool isUnsignedOffset() const { 606 if (!isImm()) return false; 607 if (isa<MCSymbolRefExpr>(Imm.Val)) return true; 608 if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Imm.Val)) { 609 int64_t Val = CE->getValue(); 610 int64_t Align = 1LL << scale; 611 int64_t Max = Align * ((1LL << width) - 1); 612 return ((Val % Align) == 0) && (Val >= 0) && (Val <= Max); 613 } 614 return false; 615 } 616 // checks whether this operand is an signed offset which fits is a field 617 // of specified width and scaled by a specific number of bits 618 template<unsigned width, unsigned scale> 619 bool isSignedOffset() const { 620 if (!isImm()) return false; 621 if (isa<MCSymbolRefExpr>(Imm.Val)) return true; 622 if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Imm.Val)) { 623 int64_t Val = CE->getValue(); 624 int64_t Align = 1LL << scale; 625 int64_t Max = Align * ((1LL << (width-1)) - 1); 626 int64_t Min = -Align * (1LL << (width-1)); 627 return ((Val % Align) == 0) && (Val >= Min) && (Val <= Max); 628 } 629 return false; 630 } 631 632 // checks whether this operand is a memory operand computed as an offset 633 // applied to PC. the offset may have 8 bits of magnitude and is represented 634 // with two bits of shift. textually it may be either [pc, #imm], #imm or 635 // relocable expression... 636 bool isThumbMemPC() const { 637 int64_t Val = 0; 638 if (isImm()) { 639 if (isa<MCSymbolRefExpr>(Imm.Val)) return true; 640 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Imm.Val); 641 if (!CE) return false; 642 Val = CE->getValue(); 643 } 644 else if (isMem()) { 645 if(!Memory.OffsetImm || Memory.OffsetRegNum) return false; 646 if(Memory.BaseRegNum != ARM::PC) return false; 647 Val = Memory.OffsetImm->getValue(); 648 } 649 else return false; 650 return ((Val % 4) == 0) && (Val >= 0) && (Val <= 1020); 651 } 652 bool isFPImm() const { 653 if (!isImm()) return false; 654 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 655 if (!CE) return false; 656 int Val = ARM_AM::getFP32Imm(APInt(32, CE->getValue())); 657 return Val != -1; 658 } 659 bool isFBits16() const { 660 if (!isImm()) return false; 661 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 662 if (!CE) return false; 663 int64_t Value = CE->getValue(); 664 return Value >= 0 && Value <= 16; 665 } 666 bool isFBits32() const { 667 if (!isImm()) return false; 668 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 669 if (!CE) return false; 670 int64_t Value = CE->getValue(); 671 return Value >= 1 && Value <= 32; 672 } 673 bool isImm8s4() const { 674 if (!isImm()) return false; 675 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 676 if (!CE) return false; 677 int64_t Value = CE->getValue(); 678 return ((Value & 3) == 0) && Value >= -1020 && Value <= 1020; 679 } 680 bool isImm0_4() const { 681 if (!isImm()) return false; 682 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 683 if (!CE) return false; 684 int64_t Value = CE->getValue(); 685 return Value >= 0 && Value < 5; 686 } 687 bool isImm0_1020s4() const { 688 if (!isImm()) return false; 689 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 690 if (!CE) return false; 691 int64_t Value = CE->getValue(); 692 return ((Value & 3) == 0) && Value >= 0 && Value <= 1020; 693 } 694 bool isImm0_508s4() const { 695 if (!isImm()) return false; 696 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 697 if (!CE) return false; 698 int64_t Value = CE->getValue(); 699 return ((Value & 3) == 0) && Value >= 0 && Value <= 508; 700 } 701 bool isImm0_508s4Neg() const { 702 if (!isImm()) return false; 703 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 704 if (!CE) return false; 705 int64_t Value = -CE->getValue(); 706 // explicitly exclude zero. we want that to use the normal 0_508 version. 707 return ((Value & 3) == 0) && Value > 0 && Value <= 508; 708 } 709 bool isImm0_255() const { 710 if (!isImm()) return false; 711 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 712 if (!CE) return false; 713 int64_t Value = CE->getValue(); 714 return Value >= 0 && Value < 256; 715 } 716 bool isImm0_4095() const { 717 if (!isImm()) return false; 718 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 719 if (!CE) return false; 720 int64_t Value = CE->getValue(); 721 return Value >= 0 && Value < 4096; 722 } 723 bool isImm0_4095Neg() const { 724 if (!isImm()) return false; 725 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 726 if (!CE) return false; 727 int64_t Value = -CE->getValue(); 728 return Value > 0 && Value < 4096; 729 } 730 bool isImm0_1() const { 731 if (!isImm()) return false; 732 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 733 if (!CE) return false; 734 int64_t Value = CE->getValue(); 735 return Value >= 0 && Value < 2; 736 } 737 bool isImm0_3() const { 738 if (!isImm()) return false; 739 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 740 if (!CE) return false; 741 int64_t Value = CE->getValue(); 742 return Value >= 0 && Value < 4; 743 } 744 bool isImm0_7() const { 745 if (!isImm()) return false; 746 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 747 if (!CE) return false; 748 int64_t Value = CE->getValue(); 749 return Value >= 0 && Value < 8; 750 } 751 bool isImm0_15() const { 752 if (!isImm()) return false; 753 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 754 if (!CE) return false; 755 int64_t Value = CE->getValue(); 756 return Value >= 0 && Value < 16; 757 } 758 bool isImm0_31() const { 759 if (!isImm()) return false; 760 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 761 if (!CE) return false; 762 int64_t Value = CE->getValue(); 763 return Value >= 0 && Value < 32; 764 } 765 bool isImm0_63() const { 766 if (!isImm()) return false; 767 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 768 if (!CE) return false; 769 int64_t Value = CE->getValue(); 770 return Value >= 0 && Value < 64; 771 } 772 bool isImm8() const { 773 if (!isImm()) return false; 774 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 775 if (!CE) return false; 776 int64_t Value = CE->getValue(); 777 return Value == 8; 778 } 779 bool isImm16() const { 780 if (!isImm()) return false; 781 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 782 if (!CE) return false; 783 int64_t Value = CE->getValue(); 784 return Value == 16; 785 } 786 bool isImm32() const { 787 if (!isImm()) return false; 788 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 789 if (!CE) return false; 790 int64_t Value = CE->getValue(); 791 return Value == 32; 792 } 793 bool isShrImm8() const { 794 if (!isImm()) return false; 795 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 796 if (!CE) return false; 797 int64_t Value = CE->getValue(); 798 return Value > 0 && Value <= 8; 799 } 800 bool isShrImm16() const { 801 if (!isImm()) return false; 802 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 803 if (!CE) return false; 804 int64_t Value = CE->getValue(); 805 return Value > 0 && Value <= 16; 806 } 807 bool isShrImm32() const { 808 if (!isImm()) return false; 809 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 810 if (!CE) return false; 811 int64_t Value = CE->getValue(); 812 return Value > 0 && Value <= 32; 813 } 814 bool isShrImm64() const { 815 if (!isImm()) return false; 816 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 817 if (!CE) return false; 818 int64_t Value = CE->getValue(); 819 return Value > 0 && Value <= 64; 820 } 821 bool isImm1_7() const { 822 if (!isImm()) return false; 823 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 824 if (!CE) return false; 825 int64_t Value = CE->getValue(); 826 return Value > 0 && Value < 8; 827 } 828 bool isImm1_15() const { 829 if (!isImm()) return false; 830 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 831 if (!CE) return false; 832 int64_t Value = CE->getValue(); 833 return Value > 0 && Value < 16; 834 } 835 bool isImm1_31() const { 836 if (!isImm()) return false; 837 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 838 if (!CE) return false; 839 int64_t Value = CE->getValue(); 840 return Value > 0 && Value < 32; 841 } 842 bool isImm1_16() const { 843 if (!isImm()) return false; 844 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 845 if (!CE) return false; 846 int64_t Value = CE->getValue(); 847 return Value > 0 && Value < 17; 848 } 849 bool isImm1_32() const { 850 if (!isImm()) return false; 851 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 852 if (!CE) return false; 853 int64_t Value = CE->getValue(); 854 return Value > 0 && Value < 33; 855 } 856 bool isImm0_32() const { 857 if (!isImm()) return false; 858 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 859 if (!CE) return false; 860 int64_t Value = CE->getValue(); 861 return Value >= 0 && Value < 33; 862 } 863 bool isImm0_65535() const { 864 if (!isImm()) return false; 865 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 866 if (!CE) return false; 867 int64_t Value = CE->getValue(); 868 return Value >= 0 && Value < 65536; 869 } 870 bool isImm256_65535Expr() const { 871 if (!isImm()) return false; 872 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 873 // If it's not a constant expression, it'll generate a fixup and be 874 // handled later. 875 if (!CE) return true; 876 int64_t Value = CE->getValue(); 877 return Value >= 256 && Value < 65536; 878 } 879 bool isImm0_65535Expr() const { 880 if (!isImm()) return false; 881 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 882 // If it's not a constant expression, it'll generate a fixup and be 883 // handled later. 884 if (!CE) return true; 885 int64_t Value = CE->getValue(); 886 return Value >= 0 && Value < 65536; 887 } 888 bool isImm24bit() const { 889 if (!isImm()) return false; 890 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 891 if (!CE) return false; 892 int64_t Value = CE->getValue(); 893 return Value >= 0 && Value <= 0xffffff; 894 } 895 bool isImmThumbSR() const { 896 if (!isImm()) return false; 897 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 898 if (!CE) return false; 899 int64_t Value = CE->getValue(); 900 return Value > 0 && Value < 33; 901 } 902 bool isPKHLSLImm() const { 903 if (!isImm()) return false; 904 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 905 if (!CE) return false; 906 int64_t Value = CE->getValue(); 907 return Value >= 0 && Value < 32; 908 } 909 bool isPKHASRImm() const { 910 if (!isImm()) return false; 911 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 912 if (!CE) return false; 913 int64_t Value = CE->getValue(); 914 return Value > 0 && Value <= 32; 915 } 916 bool isAdrLabel() const { 917 // If we have an immediate that's not a constant, treat it as a label 918 // reference needing a fixup. If it is a constant, but it can't fit 919 // into shift immediate encoding, we reject it. 920 if (isImm() && !isa<MCConstantExpr>(getImm())) return true; 921 else return (isARMSOImm() || isARMSOImmNeg()); 922 } 923 bool isARMSOImm() const { 924 if (!isImm()) return false; 925 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 926 if (!CE) return false; 927 int64_t Value = CE->getValue(); 928 return ARM_AM::getSOImmVal(Value) != -1; 929 } 930 bool isARMSOImmNot() const { 931 if (!isImm()) return false; 932 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 933 if (!CE) return false; 934 int64_t Value = CE->getValue(); 935 return ARM_AM::getSOImmVal(~Value) != -1; 936 } 937 bool isARMSOImmNeg() const { 938 if (!isImm()) return false; 939 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 940 if (!CE) return false; 941 int64_t Value = CE->getValue(); 942 // Only use this when not representable as a plain so_imm. 943 return ARM_AM::getSOImmVal(Value) == -1 && 944 ARM_AM::getSOImmVal(-Value) != -1; 945 } 946 bool isT2SOImm() const { 947 if (!isImm()) return false; 948 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 949 if (!CE) return false; 950 int64_t Value = CE->getValue(); 951 return ARM_AM::getT2SOImmVal(Value) != -1; 952 } 953 bool isT2SOImmNot() const { 954 if (!isImm()) return false; 955 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 956 if (!CE) return false; 957 int64_t Value = CE->getValue(); 958 return ARM_AM::getT2SOImmVal(Value) == -1 && 959 ARM_AM::getT2SOImmVal(~Value) != -1; 960 } 961 bool isT2SOImmNeg() const { 962 if (!isImm()) return false; 963 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 964 if (!CE) return false; 965 int64_t Value = CE->getValue(); 966 // Only use this when not representable as a plain so_imm. 967 return ARM_AM::getT2SOImmVal(Value) == -1 && 968 ARM_AM::getT2SOImmVal(-Value) != -1; 969 } 970 bool isSetEndImm() const { 971 if (!isImm()) return false; 972 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 973 if (!CE) return false; 974 int64_t Value = CE->getValue(); 975 return Value == 1 || Value == 0; 976 } 977 bool isReg() const { return Kind == k_Register; } 978 bool isRegList() const { return Kind == k_RegisterList; } 979 bool isDPRRegList() const { return Kind == k_DPRRegisterList; } 980 bool isSPRRegList() const { return Kind == k_SPRRegisterList; } 981 bool isToken() const { return Kind == k_Token; } 982 bool isMemBarrierOpt() const { return Kind == k_MemBarrierOpt; } 983 bool isInstSyncBarrierOpt() const { return Kind == k_InstSyncBarrierOpt; } 984 bool isMem() const { return Kind == k_Memory; } 985 bool isShifterImm() const { return Kind == k_ShifterImmediate; } 986 bool isRegShiftedReg() const { return Kind == k_ShiftedRegister; } 987 bool isRegShiftedImm() const { return Kind == k_ShiftedImmediate; } 988 bool isRotImm() const { return Kind == k_RotateImmediate; } 989 bool isBitfield() const { return Kind == k_BitfieldDescriptor; } 990 bool isPostIdxRegShifted() const { return Kind == k_PostIndexRegister; } 991 bool isPostIdxReg() const { 992 return Kind == k_PostIndexRegister && PostIdxReg.ShiftTy ==ARM_AM::no_shift; 993 } 994 bool isMemNoOffset(bool alignOK = false) const { 995 if (!isMem()) 996 return false; 997 // No offset of any kind. 998 return Memory.OffsetRegNum == 0 && Memory.OffsetImm == 0 && 999 (alignOK || Memory.Alignment == 0); 1000 } 1001 bool isMemPCRelImm12() const { 1002 if (!isMem() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0) 1003 return false; 1004 // Base register must be PC. 1005 if (Memory.BaseRegNum != ARM::PC) 1006 return false; 1007 // Immediate offset in range [-4095, 4095]. 1008 if (!Memory.OffsetImm) return true; 1009 int64_t Val = Memory.OffsetImm->getValue(); 1010 return (Val > -4096 && Val < 4096) || (Val == INT32_MIN); 1011 } 1012 bool isAlignedMemory() const { 1013 return isMemNoOffset(true); 1014 } 1015 bool isAddrMode2() const { 1016 if (!isMem() || Memory.Alignment != 0) return false; 1017 // Check for register offset. 1018 if (Memory.OffsetRegNum) return true; 1019 // Immediate offset in range [-4095, 4095]. 1020 if (!Memory.OffsetImm) return true; 1021 int64_t Val = Memory.OffsetImm->getValue(); 1022 return Val > -4096 && Val < 4096; 1023 } 1024 bool isAM2OffsetImm() const { 1025 if (!isImm()) return false; 1026 // Immediate offset in range [-4095, 4095]. 1027 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1028 if (!CE) return false; 1029 int64_t Val = CE->getValue(); 1030 return (Val == INT32_MIN) || (Val > -4096 && Val < 4096); 1031 } 1032 bool isAddrMode3() const { 1033 // If we have an immediate that's not a constant, treat it as a label 1034 // reference needing a fixup. If it is a constant, it's something else 1035 // and we reject it. 1036 if (isImm() && !isa<MCConstantExpr>(getImm())) 1037 return true; 1038 if (!isMem() || Memory.Alignment != 0) return false; 1039 // No shifts are legal for AM3. 1040 if (Memory.ShiftType != ARM_AM::no_shift) return false; 1041 // Check for register offset. 1042 if (Memory.OffsetRegNum) return true; 1043 // Immediate offset in range [-255, 255]. 1044 if (!Memory.OffsetImm) return true; 1045 int64_t Val = Memory.OffsetImm->getValue(); 1046 // The #-0 offset is encoded as INT32_MIN, and we have to check 1047 // for this too. 1048 return (Val > -256 && Val < 256) || Val == INT32_MIN; 1049 } 1050 bool isAM3Offset() const { 1051 if (Kind != k_Immediate && Kind != k_PostIndexRegister) 1052 return false; 1053 if (Kind == k_PostIndexRegister) 1054 return PostIdxReg.ShiftTy == ARM_AM::no_shift; 1055 // Immediate offset in range [-255, 255]. 1056 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1057 if (!CE) return false; 1058 int64_t Val = CE->getValue(); 1059 // Special case, #-0 is INT32_MIN. 1060 return (Val > -256 && Val < 256) || Val == INT32_MIN; 1061 } 1062 bool isAddrMode5() const { 1063 // If we have an immediate that's not a constant, treat it as a label 1064 // reference needing a fixup. If it is a constant, it's something else 1065 // and we reject it. 1066 if (isImm() && !isa<MCConstantExpr>(getImm())) 1067 return true; 1068 if (!isMem() || Memory.Alignment != 0) return false; 1069 // Check for register offset. 1070 if (Memory.OffsetRegNum) return false; 1071 // Immediate offset in range [-1020, 1020] and a multiple of 4. 1072 if (!Memory.OffsetImm) return true; 1073 int64_t Val = Memory.OffsetImm->getValue(); 1074 return (Val >= -1020 && Val <= 1020 && ((Val & 3) == 0)) || 1075 Val == INT32_MIN; 1076 } 1077 bool isMemTBB() const { 1078 if (!isMem() || !Memory.OffsetRegNum || Memory.isNegative || 1079 Memory.ShiftType != ARM_AM::no_shift || Memory.Alignment != 0) 1080 return false; 1081 return true; 1082 } 1083 bool isMemTBH() const { 1084 if (!isMem() || !Memory.OffsetRegNum || Memory.isNegative || 1085 Memory.ShiftType != ARM_AM::lsl || Memory.ShiftImm != 1 || 1086 Memory.Alignment != 0 ) 1087 return false; 1088 return true; 1089 } 1090 bool isMemRegOffset() const { 1091 if (!isMem() || !Memory.OffsetRegNum || Memory.Alignment != 0) 1092 return false; 1093 return true; 1094 } 1095 bool isT2MemRegOffset() const { 1096 if (!isMem() || !Memory.OffsetRegNum || Memory.isNegative || 1097 Memory.Alignment != 0) 1098 return false; 1099 // Only lsl #{0, 1, 2, 3} allowed. 1100 if (Memory.ShiftType == ARM_AM::no_shift) 1101 return true; 1102 if (Memory.ShiftType != ARM_AM::lsl || Memory.ShiftImm > 3) 1103 return false; 1104 return true; 1105 } 1106 bool isMemThumbRR() const { 1107 // Thumb reg+reg addressing is simple. Just two registers, a base and 1108 // an offset. No shifts, negations or any other complicating factors. 1109 if (!isMem() || !Memory.OffsetRegNum || Memory.isNegative || 1110 Memory.ShiftType != ARM_AM::no_shift || Memory.Alignment != 0) 1111 return false; 1112 return isARMLowRegister(Memory.BaseRegNum) && 1113 (!Memory.OffsetRegNum || isARMLowRegister(Memory.OffsetRegNum)); 1114 } 1115 bool isMemThumbRIs4() const { 1116 if (!isMem() || Memory.OffsetRegNum != 0 || 1117 !isARMLowRegister(Memory.BaseRegNum) || Memory.Alignment != 0) 1118 return false; 1119 // Immediate offset, multiple of 4 in range [0, 124]. 1120 if (!Memory.OffsetImm) return true; 1121 int64_t Val = Memory.OffsetImm->getValue(); 1122 return Val >= 0 && Val <= 124 && (Val % 4) == 0; 1123 } 1124 bool isMemThumbRIs2() const { 1125 if (!isMem() || Memory.OffsetRegNum != 0 || 1126 !isARMLowRegister(Memory.BaseRegNum) || Memory.Alignment != 0) 1127 return false; 1128 // Immediate offset, multiple of 4 in range [0, 62]. 1129 if (!Memory.OffsetImm) return true; 1130 int64_t Val = Memory.OffsetImm->getValue(); 1131 return Val >= 0 && Val <= 62 && (Val % 2) == 0; 1132 } 1133 bool isMemThumbRIs1() const { 1134 if (!isMem() || Memory.OffsetRegNum != 0 || 1135 !isARMLowRegister(Memory.BaseRegNum) || Memory.Alignment != 0) 1136 return false; 1137 // Immediate offset in range [0, 31]. 1138 if (!Memory.OffsetImm) return true; 1139 int64_t Val = Memory.OffsetImm->getValue(); 1140 return Val >= 0 && Val <= 31; 1141 } 1142 bool isMemThumbSPI() const { 1143 if (!isMem() || Memory.OffsetRegNum != 0 || 1144 Memory.BaseRegNum != ARM::SP || Memory.Alignment != 0) 1145 return false; 1146 // Immediate offset, multiple of 4 in range [0, 1020]. 1147 if (!Memory.OffsetImm) return true; 1148 int64_t Val = Memory.OffsetImm->getValue(); 1149 return Val >= 0 && Val <= 1020 && (Val % 4) == 0; 1150 } 1151 bool isMemImm8s4Offset() const { 1152 // If we have an immediate that's not a constant, treat it as a label 1153 // reference needing a fixup. If it is a constant, it's something else 1154 // and we reject it. 1155 if (isImm() && !isa<MCConstantExpr>(getImm())) 1156 return true; 1157 if (!isMem() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0) 1158 return false; 1159 // Immediate offset a multiple of 4 in range [-1020, 1020]. 1160 if (!Memory.OffsetImm) return true; 1161 int64_t Val = Memory.OffsetImm->getValue(); 1162 // Special case, #-0 is INT32_MIN. 1163 return (Val >= -1020 && Val <= 1020 && (Val & 3) == 0) || Val == INT32_MIN; 1164 } 1165 bool isMemImm0_1020s4Offset() const { 1166 if (!isMem() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0) 1167 return false; 1168 // Immediate offset a multiple of 4 in range [0, 1020]. 1169 if (!Memory.OffsetImm) return true; 1170 int64_t Val = Memory.OffsetImm->getValue(); 1171 return Val >= 0 && Val <= 1020 && (Val & 3) == 0; 1172 } 1173 bool isMemImm8Offset() const { 1174 if (!isMem() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0) 1175 return false; 1176 // Base reg of PC isn't allowed for these encodings. 1177 if (Memory.BaseRegNum == ARM::PC) return false; 1178 // Immediate offset in range [-255, 255]. 1179 if (!Memory.OffsetImm) return true; 1180 int64_t Val = Memory.OffsetImm->getValue(); 1181 return (Val == INT32_MIN) || (Val > -256 && Val < 256); 1182 } 1183 bool isMemPosImm8Offset() const { 1184 if (!isMem() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0) 1185 return false; 1186 // Immediate offset in range [0, 255]. 1187 if (!Memory.OffsetImm) return true; 1188 int64_t Val = Memory.OffsetImm->getValue(); 1189 return Val >= 0 && Val < 256; 1190 } 1191 bool isMemNegImm8Offset() const { 1192 if (!isMem() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0) 1193 return false; 1194 // Base reg of PC isn't allowed for these encodings. 1195 if (Memory.BaseRegNum == ARM::PC) return false; 1196 // Immediate offset in range [-255, -1]. 1197 if (!Memory.OffsetImm) return false; 1198 int64_t Val = Memory.OffsetImm->getValue(); 1199 return (Val == INT32_MIN) || (Val > -256 && Val < 0); 1200 } 1201 bool isMemUImm12Offset() const { 1202 if (!isMem() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0) 1203 return false; 1204 // Immediate offset in range [0, 4095]. 1205 if (!Memory.OffsetImm) return true; 1206 int64_t Val = Memory.OffsetImm->getValue(); 1207 return (Val >= 0 && Val < 4096); 1208 } 1209 bool isMemImm12Offset() const { 1210 // If we have an immediate that's not a constant, treat it as a label 1211 // reference needing a fixup. If it is a constant, it's something else 1212 // and we reject it. 1213 if (isImm() && !isa<MCConstantExpr>(getImm())) 1214 return true; 1215 1216 if (!isMem() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0) 1217 return false; 1218 // Immediate offset in range [-4095, 4095]. 1219 if (!Memory.OffsetImm) return true; 1220 int64_t Val = Memory.OffsetImm->getValue(); 1221 return (Val > -4096 && Val < 4096) || (Val == INT32_MIN); 1222 } 1223 bool isPostIdxImm8() const { 1224 if (!isImm()) return false; 1225 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1226 if (!CE) return false; 1227 int64_t Val = CE->getValue(); 1228 return (Val > -256 && Val < 256) || (Val == INT32_MIN); 1229 } 1230 bool isPostIdxImm8s4() const { 1231 if (!isImm()) return false; 1232 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1233 if (!CE) return false; 1234 int64_t Val = CE->getValue(); 1235 return ((Val & 3) == 0 && Val >= -1020 && Val <= 1020) || 1236 (Val == INT32_MIN); 1237 } 1238 1239 bool isMSRMask() const { return Kind == k_MSRMask; } 1240 bool isProcIFlags() const { return Kind == k_ProcIFlags; } 1241 1242 // NEON operands. 1243 bool isSingleSpacedVectorList() const { 1244 return Kind == k_VectorList && !VectorList.isDoubleSpaced; 1245 } 1246 bool isDoubleSpacedVectorList() const { 1247 return Kind == k_VectorList && VectorList.isDoubleSpaced; 1248 } 1249 bool isVecListOneD() const { 1250 if (!isSingleSpacedVectorList()) return false; 1251 return VectorList.Count == 1; 1252 } 1253 1254 bool isVecListDPair() const { 1255 if (!isSingleSpacedVectorList()) return false; 1256 return (ARMMCRegisterClasses[ARM::DPairRegClassID] 1257 .contains(VectorList.RegNum)); 1258 } 1259 1260 bool isVecListThreeD() const { 1261 if (!isSingleSpacedVectorList()) return false; 1262 return VectorList.Count == 3; 1263 } 1264 1265 bool isVecListFourD() const { 1266 if (!isSingleSpacedVectorList()) return false; 1267 return VectorList.Count == 4; 1268 } 1269 1270 bool isVecListDPairSpaced() const { 1271 if (isSingleSpacedVectorList()) return false; 1272 return (ARMMCRegisterClasses[ARM::DPairSpcRegClassID] 1273 .contains(VectorList.RegNum)); 1274 } 1275 1276 bool isVecListThreeQ() const { 1277 if (!isDoubleSpacedVectorList()) return false; 1278 return VectorList.Count == 3; 1279 } 1280 1281 bool isVecListFourQ() const { 1282 if (!isDoubleSpacedVectorList()) return false; 1283 return VectorList.Count == 4; 1284 } 1285 1286 bool isSingleSpacedVectorAllLanes() const { 1287 return Kind == k_VectorListAllLanes && !VectorList.isDoubleSpaced; 1288 } 1289 bool isDoubleSpacedVectorAllLanes() const { 1290 return Kind == k_VectorListAllLanes && VectorList.isDoubleSpaced; 1291 } 1292 bool isVecListOneDAllLanes() const { 1293 if (!isSingleSpacedVectorAllLanes()) return false; 1294 return VectorList.Count == 1; 1295 } 1296 1297 bool isVecListDPairAllLanes() const { 1298 if (!isSingleSpacedVectorAllLanes()) return false; 1299 return (ARMMCRegisterClasses[ARM::DPairRegClassID] 1300 .contains(VectorList.RegNum)); 1301 } 1302 1303 bool isVecListDPairSpacedAllLanes() const { 1304 if (!isDoubleSpacedVectorAllLanes()) return false; 1305 return VectorList.Count == 2; 1306 } 1307 1308 bool isVecListThreeDAllLanes() const { 1309 if (!isSingleSpacedVectorAllLanes()) return false; 1310 return VectorList.Count == 3; 1311 } 1312 1313 bool isVecListThreeQAllLanes() const { 1314 if (!isDoubleSpacedVectorAllLanes()) return false; 1315 return VectorList.Count == 3; 1316 } 1317 1318 bool isVecListFourDAllLanes() const { 1319 if (!isSingleSpacedVectorAllLanes()) return false; 1320 return VectorList.Count == 4; 1321 } 1322 1323 bool isVecListFourQAllLanes() const { 1324 if (!isDoubleSpacedVectorAllLanes()) return false; 1325 return VectorList.Count == 4; 1326 } 1327 1328 bool isSingleSpacedVectorIndexed() const { 1329 return Kind == k_VectorListIndexed && !VectorList.isDoubleSpaced; 1330 } 1331 bool isDoubleSpacedVectorIndexed() const { 1332 return Kind == k_VectorListIndexed && VectorList.isDoubleSpaced; 1333 } 1334 bool isVecListOneDByteIndexed() const { 1335 if (!isSingleSpacedVectorIndexed()) return false; 1336 return VectorList.Count == 1 && VectorList.LaneIndex <= 7; 1337 } 1338 1339 bool isVecListOneDHWordIndexed() const { 1340 if (!isSingleSpacedVectorIndexed()) return false; 1341 return VectorList.Count == 1 && VectorList.LaneIndex <= 3; 1342 } 1343 1344 bool isVecListOneDWordIndexed() const { 1345 if (!isSingleSpacedVectorIndexed()) return false; 1346 return VectorList.Count == 1 && VectorList.LaneIndex <= 1; 1347 } 1348 1349 bool isVecListTwoDByteIndexed() const { 1350 if (!isSingleSpacedVectorIndexed()) return false; 1351 return VectorList.Count == 2 && VectorList.LaneIndex <= 7; 1352 } 1353 1354 bool isVecListTwoDHWordIndexed() const { 1355 if (!isSingleSpacedVectorIndexed()) return false; 1356 return VectorList.Count == 2 && VectorList.LaneIndex <= 3; 1357 } 1358 1359 bool isVecListTwoQWordIndexed() const { 1360 if (!isDoubleSpacedVectorIndexed()) return false; 1361 return VectorList.Count == 2 && VectorList.LaneIndex <= 1; 1362 } 1363 1364 bool isVecListTwoQHWordIndexed() const { 1365 if (!isDoubleSpacedVectorIndexed()) return false; 1366 return VectorList.Count == 2 && VectorList.LaneIndex <= 3; 1367 } 1368 1369 bool isVecListTwoDWordIndexed() const { 1370 if (!isSingleSpacedVectorIndexed()) return false; 1371 return VectorList.Count == 2 && VectorList.LaneIndex <= 1; 1372 } 1373 1374 bool isVecListThreeDByteIndexed() const { 1375 if (!isSingleSpacedVectorIndexed()) return false; 1376 return VectorList.Count == 3 && VectorList.LaneIndex <= 7; 1377 } 1378 1379 bool isVecListThreeDHWordIndexed() const { 1380 if (!isSingleSpacedVectorIndexed()) return false; 1381 return VectorList.Count == 3 && VectorList.LaneIndex <= 3; 1382 } 1383 1384 bool isVecListThreeQWordIndexed() const { 1385 if (!isDoubleSpacedVectorIndexed()) return false; 1386 return VectorList.Count == 3 && VectorList.LaneIndex <= 1; 1387 } 1388 1389 bool isVecListThreeQHWordIndexed() const { 1390 if (!isDoubleSpacedVectorIndexed()) return false; 1391 return VectorList.Count == 3 && VectorList.LaneIndex <= 3; 1392 } 1393 1394 bool isVecListThreeDWordIndexed() const { 1395 if (!isSingleSpacedVectorIndexed()) return false; 1396 return VectorList.Count == 3 && VectorList.LaneIndex <= 1; 1397 } 1398 1399 bool isVecListFourDByteIndexed() const { 1400 if (!isSingleSpacedVectorIndexed()) return false; 1401 return VectorList.Count == 4 && VectorList.LaneIndex <= 7; 1402 } 1403 1404 bool isVecListFourDHWordIndexed() const { 1405 if (!isSingleSpacedVectorIndexed()) return false; 1406 return VectorList.Count == 4 && VectorList.LaneIndex <= 3; 1407 } 1408 1409 bool isVecListFourQWordIndexed() const { 1410 if (!isDoubleSpacedVectorIndexed()) return false; 1411 return VectorList.Count == 4 && VectorList.LaneIndex <= 1; 1412 } 1413 1414 bool isVecListFourQHWordIndexed() const { 1415 if (!isDoubleSpacedVectorIndexed()) return false; 1416 return VectorList.Count == 4 && VectorList.LaneIndex <= 3; 1417 } 1418 1419 bool isVecListFourDWordIndexed() const { 1420 if (!isSingleSpacedVectorIndexed()) return false; 1421 return VectorList.Count == 4 && VectorList.LaneIndex <= 1; 1422 } 1423 1424 bool isVectorIndex8() const { 1425 if (Kind != k_VectorIndex) return false; 1426 return VectorIndex.Val < 8; 1427 } 1428 bool isVectorIndex16() const { 1429 if (Kind != k_VectorIndex) return false; 1430 return VectorIndex.Val < 4; 1431 } 1432 bool isVectorIndex32() const { 1433 if (Kind != k_VectorIndex) return false; 1434 return VectorIndex.Val < 2; 1435 } 1436 1437 bool isNEONi8splat() const { 1438 if (!isImm()) return false; 1439 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1440 // Must be a constant. 1441 if (!CE) return false; 1442 int64_t Value = CE->getValue(); 1443 // i8 value splatted across 8 bytes. The immediate is just the 8 byte 1444 // value. 1445 return Value >= 0 && Value < 256; 1446 } 1447 1448 bool isNEONi16splat() const { 1449 if (!isImm()) return false; 1450 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1451 // Must be a constant. 1452 if (!CE) return false; 1453 int64_t Value = CE->getValue(); 1454 // i16 value in the range [0,255] or [0x0100, 0xff00] 1455 return (Value >= 0 && Value < 256) || (Value >= 0x0100 && Value <= 0xff00); 1456 } 1457 1458 bool isNEONi32splat() const { 1459 if (!isImm()) return false; 1460 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1461 // Must be a constant. 1462 if (!CE) return false; 1463 int64_t Value = CE->getValue(); 1464 // i32 value with set bits only in one byte X000, 0X00, 00X0, or 000X. 1465 return (Value >= 0 && Value < 256) || 1466 (Value >= 0x0100 && Value <= 0xff00) || 1467 (Value >= 0x010000 && Value <= 0xff0000) || 1468 (Value >= 0x01000000 && Value <= 0xff000000); 1469 } 1470 1471 bool isNEONi32vmov() const { 1472 if (!isImm()) return false; 1473 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1474 // Must be a constant. 1475 if (!CE) return false; 1476 int64_t Value = CE->getValue(); 1477 // i32 value with set bits only in one byte X000, 0X00, 00X0, or 000X, 1478 // for VMOV/VMVN only, 00Xf or 0Xff are also accepted. 1479 return (Value >= 0 && Value < 256) || 1480 (Value >= 0x0100 && Value <= 0xff00) || 1481 (Value >= 0x010000 && Value <= 0xff0000) || 1482 (Value >= 0x01000000 && Value <= 0xff000000) || 1483 (Value >= 0x01ff && Value <= 0xffff && (Value & 0xff) == 0xff) || 1484 (Value >= 0x01ffff && Value <= 0xffffff && (Value & 0xffff) == 0xffff); 1485 } 1486 bool isNEONi32vmovNeg() const { 1487 if (!isImm()) return false; 1488 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1489 // Must be a constant. 1490 if (!CE) return false; 1491 int64_t Value = ~CE->getValue(); 1492 // i32 value with set bits only in one byte X000, 0X00, 00X0, or 000X, 1493 // for VMOV/VMVN only, 00Xf or 0Xff are also accepted. 1494 return (Value >= 0 && Value < 256) || 1495 (Value >= 0x0100 && Value <= 0xff00) || 1496 (Value >= 0x010000 && Value <= 0xff0000) || 1497 (Value >= 0x01000000 && Value <= 0xff000000) || 1498 (Value >= 0x01ff && Value <= 0xffff && (Value & 0xff) == 0xff) || 1499 (Value >= 0x01ffff && Value <= 0xffffff && (Value & 0xffff) == 0xffff); 1500 } 1501 1502 bool isNEONi64splat() const { 1503 if (!isImm()) return false; 1504 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1505 // Must be a constant. 1506 if (!CE) return false; 1507 uint64_t Value = CE->getValue(); 1508 // i64 value with each byte being either 0 or 0xff. 1509 for (unsigned i = 0; i < 8; ++i) 1510 if ((Value & 0xff) != 0 && (Value & 0xff) != 0xff) return false; 1511 return true; 1512 } 1513 1514 void addExpr(MCInst &Inst, const MCExpr *Expr) const { 1515 // Add as immediates when possible. Null MCExpr = 0. 1516 if (Expr == 0) 1517 Inst.addOperand(MCOperand::CreateImm(0)); 1518 else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr)) 1519 Inst.addOperand(MCOperand::CreateImm(CE->getValue())); 1520 else 1521 Inst.addOperand(MCOperand::CreateExpr(Expr)); 1522 } 1523 1524 void addCondCodeOperands(MCInst &Inst, unsigned N) const { 1525 assert(N == 2 && "Invalid number of operands!"); 1526 Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode()))); 1527 unsigned RegNum = getCondCode() == ARMCC::AL ? 0: ARM::CPSR; 1528 Inst.addOperand(MCOperand::CreateReg(RegNum)); 1529 } 1530 1531 void addCoprocNumOperands(MCInst &Inst, unsigned N) const { 1532 assert(N == 1 && "Invalid number of operands!"); 1533 Inst.addOperand(MCOperand::CreateImm(getCoproc())); 1534 } 1535 1536 void addCoprocRegOperands(MCInst &Inst, unsigned N) const { 1537 assert(N == 1 && "Invalid number of operands!"); 1538 Inst.addOperand(MCOperand::CreateImm(getCoproc())); 1539 } 1540 1541 void addCoprocOptionOperands(MCInst &Inst, unsigned N) const { 1542 assert(N == 1 && "Invalid number of operands!"); 1543 Inst.addOperand(MCOperand::CreateImm(CoprocOption.Val)); 1544 } 1545 1546 void addITMaskOperands(MCInst &Inst, unsigned N) const { 1547 assert(N == 1 && "Invalid number of operands!"); 1548 Inst.addOperand(MCOperand::CreateImm(ITMask.Mask)); 1549 } 1550 1551 void addITCondCodeOperands(MCInst &Inst, unsigned N) const { 1552 assert(N == 1 && "Invalid number of operands!"); 1553 Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode()))); 1554 } 1555 1556 void addCCOutOperands(MCInst &Inst, unsigned N) const { 1557 assert(N == 1 && "Invalid number of operands!"); 1558 Inst.addOperand(MCOperand::CreateReg(getReg())); 1559 } 1560 1561 void addRegOperands(MCInst &Inst, unsigned N) const { 1562 assert(N == 1 && "Invalid number of operands!"); 1563 Inst.addOperand(MCOperand::CreateReg(getReg())); 1564 } 1565 1566 void addRegShiftedRegOperands(MCInst &Inst, unsigned N) const { 1567 assert(N == 3 && "Invalid number of operands!"); 1568 assert(isRegShiftedReg() && 1569 "addRegShiftedRegOperands() on non RegShiftedReg!"); 1570 Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.SrcReg)); 1571 Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.ShiftReg)); 1572 Inst.addOperand(MCOperand::CreateImm( 1573 ARM_AM::getSORegOpc(RegShiftedReg.ShiftTy, RegShiftedReg.ShiftImm))); 1574 } 1575 1576 void addRegShiftedImmOperands(MCInst &Inst, unsigned N) const { 1577 assert(N == 2 && "Invalid number of operands!"); 1578 assert(isRegShiftedImm() && 1579 "addRegShiftedImmOperands() on non RegShiftedImm!"); 1580 Inst.addOperand(MCOperand::CreateReg(RegShiftedImm.SrcReg)); 1581 // Shift of #32 is encoded as 0 where permitted 1582 unsigned Imm = (RegShiftedImm.ShiftImm == 32 ? 0 : RegShiftedImm.ShiftImm); 1583 Inst.addOperand(MCOperand::CreateImm( 1584 ARM_AM::getSORegOpc(RegShiftedImm.ShiftTy, Imm))); 1585 } 1586 1587 void addShifterImmOperands(MCInst &Inst, unsigned N) const { 1588 assert(N == 1 && "Invalid number of operands!"); 1589 Inst.addOperand(MCOperand::CreateImm((ShifterImm.isASR << 5) | 1590 ShifterImm.Imm)); 1591 } 1592 1593 void addRegListOperands(MCInst &Inst, unsigned N) const { 1594 assert(N == 1 && "Invalid number of operands!"); 1595 const SmallVectorImpl<unsigned> &RegList = getRegList(); 1596 for (SmallVectorImpl<unsigned>::const_iterator 1597 I = RegList.begin(), E = RegList.end(); I != E; ++I) 1598 Inst.addOperand(MCOperand::CreateReg(*I)); 1599 } 1600 1601 void addDPRRegListOperands(MCInst &Inst, unsigned N) const { 1602 addRegListOperands(Inst, N); 1603 } 1604 1605 void addSPRRegListOperands(MCInst &Inst, unsigned N) const { 1606 addRegListOperands(Inst, N); 1607 } 1608 1609 void addRotImmOperands(MCInst &Inst, unsigned N) const { 1610 assert(N == 1 && "Invalid number of operands!"); 1611 // Encoded as val>>3. The printer handles display as 8, 16, 24. 1612 Inst.addOperand(MCOperand::CreateImm(RotImm.Imm >> 3)); 1613 } 1614 1615 void addBitfieldOperands(MCInst &Inst, unsigned N) const { 1616 assert(N == 1 && "Invalid number of operands!"); 1617 // Munge the lsb/width into a bitfield mask. 1618 unsigned lsb = Bitfield.LSB; 1619 unsigned width = Bitfield.Width; 1620 // Make a 32-bit mask w/ the referenced bits clear and all other bits set. 1621 uint32_t Mask = ~(((uint32_t)0xffffffff >> lsb) << (32 - width) >> 1622 (32 - (lsb + width))); 1623 Inst.addOperand(MCOperand::CreateImm(Mask)); 1624 } 1625 1626 void addImmOperands(MCInst &Inst, unsigned N) const { 1627 assert(N == 1 && "Invalid number of operands!"); 1628 addExpr(Inst, getImm()); 1629 } 1630 1631 void addFBits16Operands(MCInst &Inst, unsigned N) const { 1632 assert(N == 1 && "Invalid number of operands!"); 1633 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1634 Inst.addOperand(MCOperand::CreateImm(16 - CE->getValue())); 1635 } 1636 1637 void addFBits32Operands(MCInst &Inst, unsigned N) const { 1638 assert(N == 1 && "Invalid number of operands!"); 1639 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1640 Inst.addOperand(MCOperand::CreateImm(32 - CE->getValue())); 1641 } 1642 1643 void addFPImmOperands(MCInst &Inst, unsigned N) const { 1644 assert(N == 1 && "Invalid number of operands!"); 1645 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1646 int Val = ARM_AM::getFP32Imm(APInt(32, CE->getValue())); 1647 Inst.addOperand(MCOperand::CreateImm(Val)); 1648 } 1649 1650 void addImm8s4Operands(MCInst &Inst, unsigned N) const { 1651 assert(N == 1 && "Invalid number of operands!"); 1652 // FIXME: We really want to scale the value here, but the LDRD/STRD 1653 // instruction don't encode operands that way yet. 1654 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1655 Inst.addOperand(MCOperand::CreateImm(CE->getValue())); 1656 } 1657 1658 void addImm0_1020s4Operands(MCInst &Inst, unsigned N) const { 1659 assert(N == 1 && "Invalid number of operands!"); 1660 // The immediate is scaled by four in the encoding and is stored 1661 // in the MCInst as such. Lop off the low two bits here. 1662 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1663 Inst.addOperand(MCOperand::CreateImm(CE->getValue() / 4)); 1664 } 1665 1666 void addImm0_508s4NegOperands(MCInst &Inst, unsigned N) const { 1667 assert(N == 1 && "Invalid number of operands!"); 1668 // The immediate is scaled by four in the encoding and is stored 1669 // in the MCInst as such. Lop off the low two bits here. 1670 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1671 Inst.addOperand(MCOperand::CreateImm(-(CE->getValue() / 4))); 1672 } 1673 1674 void addImm0_508s4Operands(MCInst &Inst, unsigned N) const { 1675 assert(N == 1 && "Invalid number of operands!"); 1676 // The immediate is scaled by four in the encoding and is stored 1677 // in the MCInst as such. Lop off the low two bits here. 1678 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1679 Inst.addOperand(MCOperand::CreateImm(CE->getValue() / 4)); 1680 } 1681 1682 void addImm1_16Operands(MCInst &Inst, unsigned N) const { 1683 assert(N == 1 && "Invalid number of operands!"); 1684 // The constant encodes as the immediate-1, and we store in the instruction 1685 // the bits as encoded, so subtract off one here. 1686 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1687 Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1)); 1688 } 1689 1690 void addImm1_32Operands(MCInst &Inst, unsigned N) const { 1691 assert(N == 1 && "Invalid number of operands!"); 1692 // The constant encodes as the immediate-1, and we store in the instruction 1693 // the bits as encoded, so subtract off one here. 1694 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1695 Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1)); 1696 } 1697 1698 void addImmThumbSROperands(MCInst &Inst, unsigned N) const { 1699 assert(N == 1 && "Invalid number of operands!"); 1700 // The constant encodes as the immediate, except for 32, which encodes as 1701 // zero. 1702 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1703 unsigned Imm = CE->getValue(); 1704 Inst.addOperand(MCOperand::CreateImm((Imm == 32 ? 0 : Imm))); 1705 } 1706 1707 void addPKHASRImmOperands(MCInst &Inst, unsigned N) const { 1708 assert(N == 1 && "Invalid number of operands!"); 1709 // An ASR value of 32 encodes as 0, so that's how we want to add it to 1710 // the instruction as well. 1711 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1712 int Val = CE->getValue(); 1713 Inst.addOperand(MCOperand::CreateImm(Val == 32 ? 0 : Val)); 1714 } 1715 1716 void addT2SOImmNotOperands(MCInst &Inst, unsigned N) const { 1717 assert(N == 1 && "Invalid number of operands!"); 1718 // The operand is actually a t2_so_imm, but we have its bitwise 1719 // negation in the assembly source, so twiddle it here. 1720 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1721 Inst.addOperand(MCOperand::CreateImm(~CE->getValue())); 1722 } 1723 1724 void addT2SOImmNegOperands(MCInst &Inst, unsigned N) const { 1725 assert(N == 1 && "Invalid number of operands!"); 1726 // The operand is actually a t2_so_imm, but we have its 1727 // negation in the assembly source, so twiddle it here. 1728 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1729 Inst.addOperand(MCOperand::CreateImm(-CE->getValue())); 1730 } 1731 1732 void addImm0_4095NegOperands(MCInst &Inst, unsigned N) const { 1733 assert(N == 1 && "Invalid number of operands!"); 1734 // The operand is actually an imm0_4095, but we have its 1735 // negation in the assembly source, so twiddle it here. 1736 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1737 Inst.addOperand(MCOperand::CreateImm(-CE->getValue())); 1738 } 1739 1740 void addUnsignedOffset_b8s2Operands(MCInst &Inst, unsigned N) const { 1741 if(const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm())) { 1742 Inst.addOperand(MCOperand::CreateImm(CE->getValue() >> 2)); 1743 return; 1744 } 1745 1746 const MCSymbolRefExpr *SR = dyn_cast<MCSymbolRefExpr>(Imm.Val); 1747 assert(SR && "Unknown value type!"); 1748 Inst.addOperand(MCOperand::CreateExpr(SR)); 1749 } 1750 1751 void addThumbMemPCOperands(MCInst &Inst, unsigned N) const { 1752 assert(N == 1 && "Invalid number of operands!"); 1753 if (isImm()) { 1754 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1755 if (CE) { 1756 Inst.addOperand(MCOperand::CreateImm(CE->getValue())); 1757 return; 1758 } 1759 1760 const MCSymbolRefExpr *SR = dyn_cast<MCSymbolRefExpr>(Imm.Val); 1761 assert(SR && "Unknown value type!"); 1762 Inst.addOperand(MCOperand::CreateExpr(SR)); 1763 return; 1764 } 1765 1766 assert(isMem() && "Unknown value type!"); 1767 assert(isa<MCConstantExpr>(Memory.OffsetImm) && "Unknown value type!"); 1768 Inst.addOperand(MCOperand::CreateImm(Memory.OffsetImm->getValue())); 1769 } 1770 1771 void addARMSOImmNotOperands(MCInst &Inst, unsigned N) const { 1772 assert(N == 1 && "Invalid number of operands!"); 1773 // The operand is actually a so_imm, but we have its bitwise 1774 // negation in the assembly source, so twiddle it here. 1775 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1776 Inst.addOperand(MCOperand::CreateImm(~CE->getValue())); 1777 } 1778 1779 void addARMSOImmNegOperands(MCInst &Inst, unsigned N) const { 1780 assert(N == 1 && "Invalid number of operands!"); 1781 // The operand is actually a so_imm, but we have its 1782 // negation in the assembly source, so twiddle it here. 1783 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1784 Inst.addOperand(MCOperand::CreateImm(-CE->getValue())); 1785 } 1786 1787 void addMemBarrierOptOperands(MCInst &Inst, unsigned N) const { 1788 assert(N == 1 && "Invalid number of operands!"); 1789 Inst.addOperand(MCOperand::CreateImm(unsigned(getMemBarrierOpt()))); 1790 } 1791 1792 void addInstSyncBarrierOptOperands(MCInst &Inst, unsigned N) const { 1793 assert(N == 1 && "Invalid number of operands!"); 1794 Inst.addOperand(MCOperand::CreateImm(unsigned(getInstSyncBarrierOpt()))); 1795 } 1796 1797 void addMemNoOffsetOperands(MCInst &Inst, unsigned N) const { 1798 assert(N == 1 && "Invalid number of operands!"); 1799 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 1800 } 1801 1802 void addMemPCRelImm12Operands(MCInst &Inst, unsigned N) const { 1803 assert(N == 1 && "Invalid number of operands!"); 1804 int32_t Imm = Memory.OffsetImm->getValue(); 1805 Inst.addOperand(MCOperand::CreateImm(Imm)); 1806 } 1807 1808 void addAdrLabelOperands(MCInst &Inst, unsigned N) const { 1809 assert(N == 1 && "Invalid number of operands!"); 1810 assert(isImm() && "Not an immediate!"); 1811 1812 // If we have an immediate that's not a constant, treat it as a label 1813 // reference needing a fixup. 1814 if (!isa<MCConstantExpr>(getImm())) { 1815 Inst.addOperand(MCOperand::CreateExpr(getImm())); 1816 return; 1817 } 1818 1819 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1820 int Val = CE->getValue(); 1821 Inst.addOperand(MCOperand::CreateImm(Val)); 1822 } 1823 1824 void addAlignedMemoryOperands(MCInst &Inst, unsigned N) const { 1825 assert(N == 2 && "Invalid number of operands!"); 1826 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 1827 Inst.addOperand(MCOperand::CreateImm(Memory.Alignment)); 1828 } 1829 1830 void addAddrMode2Operands(MCInst &Inst, unsigned N) const { 1831 assert(N == 3 && "Invalid number of operands!"); 1832 int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0; 1833 if (!Memory.OffsetRegNum) { 1834 ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add; 1835 // Special case for #-0 1836 if (Val == INT32_MIN) Val = 0; 1837 if (Val < 0) Val = -Val; 1838 Val = ARM_AM::getAM2Opc(AddSub, Val, ARM_AM::no_shift); 1839 } else { 1840 // For register offset, we encode the shift type and negation flag 1841 // here. 1842 Val = ARM_AM::getAM2Opc(Memory.isNegative ? ARM_AM::sub : ARM_AM::add, 1843 Memory.ShiftImm, Memory.ShiftType); 1844 } 1845 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 1846 Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum)); 1847 Inst.addOperand(MCOperand::CreateImm(Val)); 1848 } 1849 1850 void addAM2OffsetImmOperands(MCInst &Inst, unsigned N) const { 1851 assert(N == 2 && "Invalid number of operands!"); 1852 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 1853 assert(CE && "non-constant AM2OffsetImm operand!"); 1854 int32_t Val = CE->getValue(); 1855 ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add; 1856 // Special case for #-0 1857 if (Val == INT32_MIN) Val = 0; 1858 if (Val < 0) Val = -Val; 1859 Val = ARM_AM::getAM2Opc(AddSub, Val, ARM_AM::no_shift); 1860 Inst.addOperand(MCOperand::CreateReg(0)); 1861 Inst.addOperand(MCOperand::CreateImm(Val)); 1862 } 1863 1864 void addAddrMode3Operands(MCInst &Inst, unsigned N) const { 1865 assert(N == 3 && "Invalid number of operands!"); 1866 // If we have an immediate that's not a constant, treat it as a label 1867 // reference needing a fixup. If it is a constant, it's something else 1868 // and we reject it. 1869 if (isImm()) { 1870 Inst.addOperand(MCOperand::CreateExpr(getImm())); 1871 Inst.addOperand(MCOperand::CreateReg(0)); 1872 Inst.addOperand(MCOperand::CreateImm(0)); 1873 return; 1874 } 1875 1876 int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0; 1877 if (!Memory.OffsetRegNum) { 1878 ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add; 1879 // Special case for #-0 1880 if (Val == INT32_MIN) Val = 0; 1881 if (Val < 0) Val = -Val; 1882 Val = ARM_AM::getAM3Opc(AddSub, Val); 1883 } else { 1884 // For register offset, we encode the shift type and negation flag 1885 // here. 1886 Val = ARM_AM::getAM3Opc(Memory.isNegative ? ARM_AM::sub : ARM_AM::add, 0); 1887 } 1888 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 1889 Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum)); 1890 Inst.addOperand(MCOperand::CreateImm(Val)); 1891 } 1892 1893 void addAM3OffsetOperands(MCInst &Inst, unsigned N) const { 1894 assert(N == 2 && "Invalid number of operands!"); 1895 if (Kind == k_PostIndexRegister) { 1896 int32_t Val = 1897 ARM_AM::getAM3Opc(PostIdxReg.isAdd ? ARM_AM::add : ARM_AM::sub, 0); 1898 Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum)); 1899 Inst.addOperand(MCOperand::CreateImm(Val)); 1900 return; 1901 } 1902 1903 // Constant offset. 1904 const MCConstantExpr *CE = static_cast<const MCConstantExpr*>(getImm()); 1905 int32_t Val = CE->getValue(); 1906 ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add; 1907 // Special case for #-0 1908 if (Val == INT32_MIN) Val = 0; 1909 if (Val < 0) Val = -Val; 1910 Val = ARM_AM::getAM3Opc(AddSub, Val); 1911 Inst.addOperand(MCOperand::CreateReg(0)); 1912 Inst.addOperand(MCOperand::CreateImm(Val)); 1913 } 1914 1915 void addAddrMode5Operands(MCInst &Inst, unsigned N) const { 1916 assert(N == 2 && "Invalid number of operands!"); 1917 // If we have an immediate that's not a constant, treat it as a label 1918 // reference needing a fixup. If it is a constant, it's something else 1919 // and we reject it. 1920 if (isImm()) { 1921 Inst.addOperand(MCOperand::CreateExpr(getImm())); 1922 Inst.addOperand(MCOperand::CreateImm(0)); 1923 return; 1924 } 1925 1926 // The lower two bits are always zero and as such are not encoded. 1927 int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() / 4 : 0; 1928 ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add; 1929 // Special case for #-0 1930 if (Val == INT32_MIN) Val = 0; 1931 if (Val < 0) Val = -Val; 1932 Val = ARM_AM::getAM5Opc(AddSub, Val); 1933 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 1934 Inst.addOperand(MCOperand::CreateImm(Val)); 1935 } 1936 1937 void addMemImm8s4OffsetOperands(MCInst &Inst, unsigned N) const { 1938 assert(N == 2 && "Invalid number of operands!"); 1939 // If we have an immediate that's not a constant, treat it as a label 1940 // reference needing a fixup. If it is a constant, it's something else 1941 // and we reject it. 1942 if (isImm()) { 1943 Inst.addOperand(MCOperand::CreateExpr(getImm())); 1944 Inst.addOperand(MCOperand::CreateImm(0)); 1945 return; 1946 } 1947 1948 int64_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0; 1949 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 1950 Inst.addOperand(MCOperand::CreateImm(Val)); 1951 } 1952 1953 void addMemImm0_1020s4OffsetOperands(MCInst &Inst, unsigned N) const { 1954 assert(N == 2 && "Invalid number of operands!"); 1955 // The lower two bits are always zero and as such are not encoded. 1956 int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() / 4 : 0; 1957 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 1958 Inst.addOperand(MCOperand::CreateImm(Val)); 1959 } 1960 1961 void addMemImm8OffsetOperands(MCInst &Inst, unsigned N) const { 1962 assert(N == 2 && "Invalid number of operands!"); 1963 int64_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0; 1964 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 1965 Inst.addOperand(MCOperand::CreateImm(Val)); 1966 } 1967 1968 void addMemPosImm8OffsetOperands(MCInst &Inst, unsigned N) const { 1969 addMemImm8OffsetOperands(Inst, N); 1970 } 1971 1972 void addMemNegImm8OffsetOperands(MCInst &Inst, unsigned N) const { 1973 addMemImm8OffsetOperands(Inst, N); 1974 } 1975 1976 void addMemUImm12OffsetOperands(MCInst &Inst, unsigned N) const { 1977 assert(N == 2 && "Invalid number of operands!"); 1978 // If this is an immediate, it's a label reference. 1979 if (isImm()) { 1980 addExpr(Inst, getImm()); 1981 Inst.addOperand(MCOperand::CreateImm(0)); 1982 return; 1983 } 1984 1985 // Otherwise, it's a normal memory reg+offset. 1986 int64_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0; 1987 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 1988 Inst.addOperand(MCOperand::CreateImm(Val)); 1989 } 1990 1991 void addMemImm12OffsetOperands(MCInst &Inst, unsigned N) const { 1992 assert(N == 2 && "Invalid number of operands!"); 1993 // If this is an immediate, it's a label reference. 1994 if (isImm()) { 1995 addExpr(Inst, getImm()); 1996 Inst.addOperand(MCOperand::CreateImm(0)); 1997 return; 1998 } 1999 2000 // Otherwise, it's a normal memory reg+offset. 2001 int64_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0; 2002 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 2003 Inst.addOperand(MCOperand::CreateImm(Val)); 2004 } 2005 2006 void addMemTBBOperands(MCInst &Inst, unsigned N) const { 2007 assert(N == 2 && "Invalid number of operands!"); 2008 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 2009 Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum)); 2010 } 2011 2012 void addMemTBHOperands(MCInst &Inst, unsigned N) const { 2013 assert(N == 2 && "Invalid number of operands!"); 2014 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 2015 Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum)); 2016 } 2017 2018 void addMemRegOffsetOperands(MCInst &Inst, unsigned N) const { 2019 assert(N == 3 && "Invalid number of operands!"); 2020 unsigned Val = 2021 ARM_AM::getAM2Opc(Memory.isNegative ? ARM_AM::sub : ARM_AM::add, 2022 Memory.ShiftImm, Memory.ShiftType); 2023 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 2024 Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum)); 2025 Inst.addOperand(MCOperand::CreateImm(Val)); 2026 } 2027 2028 void addT2MemRegOffsetOperands(MCInst &Inst, unsigned N) const { 2029 assert(N == 3 && "Invalid number of operands!"); 2030 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 2031 Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum)); 2032 Inst.addOperand(MCOperand::CreateImm(Memory.ShiftImm)); 2033 } 2034 2035 void addMemThumbRROperands(MCInst &Inst, unsigned N) const { 2036 assert(N == 2 && "Invalid number of operands!"); 2037 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 2038 Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum)); 2039 } 2040 2041 void addMemThumbRIs4Operands(MCInst &Inst, unsigned N) const { 2042 assert(N == 2 && "Invalid number of operands!"); 2043 int64_t Val = Memory.OffsetImm ? (Memory.OffsetImm->getValue() / 4) : 0; 2044 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 2045 Inst.addOperand(MCOperand::CreateImm(Val)); 2046 } 2047 2048 void addMemThumbRIs2Operands(MCInst &Inst, unsigned N) const { 2049 assert(N == 2 && "Invalid number of operands!"); 2050 int64_t Val = Memory.OffsetImm ? (Memory.OffsetImm->getValue() / 2) : 0; 2051 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 2052 Inst.addOperand(MCOperand::CreateImm(Val)); 2053 } 2054 2055 void addMemThumbRIs1Operands(MCInst &Inst, unsigned N) const { 2056 assert(N == 2 && "Invalid number of operands!"); 2057 int64_t Val = Memory.OffsetImm ? (Memory.OffsetImm->getValue()) : 0; 2058 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 2059 Inst.addOperand(MCOperand::CreateImm(Val)); 2060 } 2061 2062 void addMemThumbSPIOperands(MCInst &Inst, unsigned N) const { 2063 assert(N == 2 && "Invalid number of operands!"); 2064 int64_t Val = Memory.OffsetImm ? (Memory.OffsetImm->getValue() / 4) : 0; 2065 Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum)); 2066 Inst.addOperand(MCOperand::CreateImm(Val)); 2067 } 2068 2069 void addPostIdxImm8Operands(MCInst &Inst, unsigned N) const { 2070 assert(N == 1 && "Invalid number of operands!"); 2071 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 2072 assert(CE && "non-constant post-idx-imm8 operand!"); 2073 int Imm = CE->getValue(); 2074 bool isAdd = Imm >= 0; 2075 if (Imm == INT32_MIN) Imm = 0; 2076 Imm = (Imm < 0 ? -Imm : Imm) | (int)isAdd << 8; 2077 Inst.addOperand(MCOperand::CreateImm(Imm)); 2078 } 2079 2080 void addPostIdxImm8s4Operands(MCInst &Inst, unsigned N) const { 2081 assert(N == 1 && "Invalid number of operands!"); 2082 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 2083 assert(CE && "non-constant post-idx-imm8s4 operand!"); 2084 int Imm = CE->getValue(); 2085 bool isAdd = Imm >= 0; 2086 if (Imm == INT32_MIN) Imm = 0; 2087 // Immediate is scaled by 4. 2088 Imm = ((Imm < 0 ? -Imm : Imm) / 4) | (int)isAdd << 8; 2089 Inst.addOperand(MCOperand::CreateImm(Imm)); 2090 } 2091 2092 void addPostIdxRegOperands(MCInst &Inst, unsigned N) const { 2093 assert(N == 2 && "Invalid number of operands!"); 2094 Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum)); 2095 Inst.addOperand(MCOperand::CreateImm(PostIdxReg.isAdd)); 2096 } 2097 2098 void addPostIdxRegShiftedOperands(MCInst &Inst, unsigned N) const { 2099 assert(N == 2 && "Invalid number of operands!"); 2100 Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum)); 2101 // The sign, shift type, and shift amount are encoded in a single operand 2102 // using the AM2 encoding helpers. 2103 ARM_AM::AddrOpc opc = PostIdxReg.isAdd ? ARM_AM::add : ARM_AM::sub; 2104 unsigned Imm = ARM_AM::getAM2Opc(opc, PostIdxReg.ShiftImm, 2105 PostIdxReg.ShiftTy); 2106 Inst.addOperand(MCOperand::CreateImm(Imm)); 2107 } 2108 2109 void addMSRMaskOperands(MCInst &Inst, unsigned N) const { 2110 assert(N == 1 && "Invalid number of operands!"); 2111 Inst.addOperand(MCOperand::CreateImm(unsigned(getMSRMask()))); 2112 } 2113 2114 void addProcIFlagsOperands(MCInst &Inst, unsigned N) const { 2115 assert(N == 1 && "Invalid number of operands!"); 2116 Inst.addOperand(MCOperand::CreateImm(unsigned(getProcIFlags()))); 2117 } 2118 2119 void addVecListOperands(MCInst &Inst, unsigned N) const { 2120 assert(N == 1 && "Invalid number of operands!"); 2121 Inst.addOperand(MCOperand::CreateReg(VectorList.RegNum)); 2122 } 2123 2124 void addVecListIndexedOperands(MCInst &Inst, unsigned N) const { 2125 assert(N == 2 && "Invalid number of operands!"); 2126 Inst.addOperand(MCOperand::CreateReg(VectorList.RegNum)); 2127 Inst.addOperand(MCOperand::CreateImm(VectorList.LaneIndex)); 2128 } 2129 2130 void addVectorIndex8Operands(MCInst &Inst, unsigned N) const { 2131 assert(N == 1 && "Invalid number of operands!"); 2132 Inst.addOperand(MCOperand::CreateImm(getVectorIndex())); 2133 } 2134 2135 void addVectorIndex16Operands(MCInst &Inst, unsigned N) const { 2136 assert(N == 1 && "Invalid number of operands!"); 2137 Inst.addOperand(MCOperand::CreateImm(getVectorIndex())); 2138 } 2139 2140 void addVectorIndex32Operands(MCInst &Inst, unsigned N) const { 2141 assert(N == 1 && "Invalid number of operands!"); 2142 Inst.addOperand(MCOperand::CreateImm(getVectorIndex())); 2143 } 2144 2145 void addNEONi8splatOperands(MCInst &Inst, unsigned N) const { 2146 assert(N == 1 && "Invalid number of operands!"); 2147 // The immediate encodes the type of constant as well as the value. 2148 // Mask in that this is an i8 splat. 2149 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 2150 Inst.addOperand(MCOperand::CreateImm(CE->getValue() | 0xe00)); 2151 } 2152 2153 void addNEONi16splatOperands(MCInst &Inst, unsigned N) const { 2154 assert(N == 1 && "Invalid number of operands!"); 2155 // The immediate encodes the type of constant as well as the value. 2156 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 2157 unsigned Value = CE->getValue(); 2158 if (Value >= 256) 2159 Value = (Value >> 8) | 0xa00; 2160 else 2161 Value |= 0x800; 2162 Inst.addOperand(MCOperand::CreateImm(Value)); 2163 } 2164 2165 void addNEONi32splatOperands(MCInst &Inst, unsigned N) const { 2166 assert(N == 1 && "Invalid number of operands!"); 2167 // The immediate encodes the type of constant as well as the value. 2168 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 2169 unsigned Value = CE->getValue(); 2170 if (Value >= 256 && Value <= 0xff00) 2171 Value = (Value >> 8) | 0x200; 2172 else if (Value > 0xffff && Value <= 0xff0000) 2173 Value = (Value >> 16) | 0x400; 2174 else if (Value > 0xffffff) 2175 Value = (Value >> 24) | 0x600; 2176 Inst.addOperand(MCOperand::CreateImm(Value)); 2177 } 2178 2179 void addNEONi32vmovOperands(MCInst &Inst, unsigned N) const { 2180 assert(N == 1 && "Invalid number of operands!"); 2181 // The immediate encodes the type of constant as well as the value. 2182 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 2183 unsigned Value = CE->getValue(); 2184 if (Value >= 256 && Value <= 0xffff) 2185 Value = (Value >> 8) | ((Value & 0xff) ? 0xc00 : 0x200); 2186 else if (Value > 0xffff && Value <= 0xffffff) 2187 Value = (Value >> 16) | ((Value & 0xff) ? 0xd00 : 0x400); 2188 else if (Value > 0xffffff) 2189 Value = (Value >> 24) | 0x600; 2190 Inst.addOperand(MCOperand::CreateImm(Value)); 2191 } 2192 2193 void addNEONi32vmovNegOperands(MCInst &Inst, unsigned N) const { 2194 assert(N == 1 && "Invalid number of operands!"); 2195 // The immediate encodes the type of constant as well as the value. 2196 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 2197 unsigned Value = ~CE->getValue(); 2198 if (Value >= 256 && Value <= 0xffff) 2199 Value = (Value >> 8) | ((Value & 0xff) ? 0xc00 : 0x200); 2200 else if (Value > 0xffff && Value <= 0xffffff) 2201 Value = (Value >> 16) | ((Value & 0xff) ? 0xd00 : 0x400); 2202 else if (Value > 0xffffff) 2203 Value = (Value >> 24) | 0x600; 2204 Inst.addOperand(MCOperand::CreateImm(Value)); 2205 } 2206 2207 void addNEONi64splatOperands(MCInst &Inst, unsigned N) const { 2208 assert(N == 1 && "Invalid number of operands!"); 2209 // The immediate encodes the type of constant as well as the value. 2210 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 2211 uint64_t Value = CE->getValue(); 2212 unsigned Imm = 0; 2213 for (unsigned i = 0; i < 8; ++i, Value >>= 8) { 2214 Imm |= (Value & 1) << i; 2215 } 2216 Inst.addOperand(MCOperand::CreateImm(Imm | 0x1e00)); 2217 } 2218 2219 virtual void print(raw_ostream &OS) const; 2220 2221 static ARMOperand *CreateITMask(unsigned Mask, SMLoc S) { 2222 ARMOperand *Op = new ARMOperand(k_ITCondMask); 2223 Op->ITMask.Mask = Mask; 2224 Op->StartLoc = S; 2225 Op->EndLoc = S; 2226 return Op; 2227 } 2228 2229 static ARMOperand *CreateCondCode(ARMCC::CondCodes CC, SMLoc S) { 2230 ARMOperand *Op = new ARMOperand(k_CondCode); 2231 Op->CC.Val = CC; 2232 Op->StartLoc = S; 2233 Op->EndLoc = S; 2234 return Op; 2235 } 2236 2237 static ARMOperand *CreateCoprocNum(unsigned CopVal, SMLoc S) { 2238 ARMOperand *Op = new ARMOperand(k_CoprocNum); 2239 Op->Cop.Val = CopVal; 2240 Op->StartLoc = S; 2241 Op->EndLoc = S; 2242 return Op; 2243 } 2244 2245 static ARMOperand *CreateCoprocReg(unsigned CopVal, SMLoc S) { 2246 ARMOperand *Op = new ARMOperand(k_CoprocReg); 2247 Op->Cop.Val = CopVal; 2248 Op->StartLoc = S; 2249 Op->EndLoc = S; 2250 return Op; 2251 } 2252 2253 static ARMOperand *CreateCoprocOption(unsigned Val, SMLoc S, SMLoc E) { 2254 ARMOperand *Op = new ARMOperand(k_CoprocOption); 2255 Op->Cop.Val = Val; 2256 Op->StartLoc = S; 2257 Op->EndLoc = E; 2258 return Op; 2259 } 2260 2261 static ARMOperand *CreateCCOut(unsigned RegNum, SMLoc S) { 2262 ARMOperand *Op = new ARMOperand(k_CCOut); 2263 Op->Reg.RegNum = RegNum; 2264 Op->StartLoc = S; 2265 Op->EndLoc = S; 2266 return Op; 2267 } 2268 2269 static ARMOperand *CreateToken(StringRef Str, SMLoc S) { 2270 ARMOperand *Op = new ARMOperand(k_Token); 2271 Op->Tok.Data = Str.data(); 2272 Op->Tok.Length = Str.size(); 2273 Op->StartLoc = S; 2274 Op->EndLoc = S; 2275 return Op; 2276 } 2277 2278 static ARMOperand *CreateReg(unsigned RegNum, SMLoc S, SMLoc E) { 2279 ARMOperand *Op = new ARMOperand(k_Register); 2280 Op->Reg.RegNum = RegNum; 2281 Op->StartLoc = S; 2282 Op->EndLoc = E; 2283 return Op; 2284 } 2285 2286 static ARMOperand *CreateShiftedRegister(ARM_AM::ShiftOpc ShTy, 2287 unsigned SrcReg, 2288 unsigned ShiftReg, 2289 unsigned ShiftImm, 2290 SMLoc S, SMLoc E) { 2291 ARMOperand *Op = new ARMOperand(k_ShiftedRegister); 2292 Op->RegShiftedReg.ShiftTy = ShTy; 2293 Op->RegShiftedReg.SrcReg = SrcReg; 2294 Op->RegShiftedReg.ShiftReg = ShiftReg; 2295 Op->RegShiftedReg.ShiftImm = ShiftImm; 2296 Op->StartLoc = S; 2297 Op->EndLoc = E; 2298 return Op; 2299 } 2300 2301 static ARMOperand *CreateShiftedImmediate(ARM_AM::ShiftOpc ShTy, 2302 unsigned SrcReg, 2303 unsigned ShiftImm, 2304 SMLoc S, SMLoc E) { 2305 ARMOperand *Op = new ARMOperand(k_ShiftedImmediate); 2306 Op->RegShiftedImm.ShiftTy = ShTy; 2307 Op->RegShiftedImm.SrcReg = SrcReg; 2308 Op->RegShiftedImm.ShiftImm = ShiftImm; 2309 Op->StartLoc = S; 2310 Op->EndLoc = E; 2311 return Op; 2312 } 2313 2314 static ARMOperand *CreateShifterImm(bool isASR, unsigned Imm, 2315 SMLoc S, SMLoc E) { 2316 ARMOperand *Op = new ARMOperand(k_ShifterImmediate); 2317 Op->ShifterImm.isASR = isASR; 2318 Op->ShifterImm.Imm = Imm; 2319 Op->StartLoc = S; 2320 Op->EndLoc = E; 2321 return Op; 2322 } 2323 2324 static ARMOperand *CreateRotImm(unsigned Imm, SMLoc S, SMLoc E) { 2325 ARMOperand *Op = new ARMOperand(k_RotateImmediate); 2326 Op->RotImm.Imm = Imm; 2327 Op->StartLoc = S; 2328 Op->EndLoc = E; 2329 return Op; 2330 } 2331 2332 static ARMOperand *CreateBitfield(unsigned LSB, unsigned Width, 2333 SMLoc S, SMLoc E) { 2334 ARMOperand *Op = new ARMOperand(k_BitfieldDescriptor); 2335 Op->Bitfield.LSB = LSB; 2336 Op->Bitfield.Width = Width; 2337 Op->StartLoc = S; 2338 Op->EndLoc = E; 2339 return Op; 2340 } 2341 2342 static ARMOperand * 2343 CreateRegList(SmallVectorImpl<std::pair<unsigned, unsigned> > &Regs, 2344 SMLoc StartLoc, SMLoc EndLoc) { 2345 assert (Regs.size() > 0 && "RegList contains no registers?"); 2346 KindTy Kind = k_RegisterList; 2347 2348 if (ARMMCRegisterClasses[ARM::DPRRegClassID].contains(Regs.front().second)) 2349 Kind = k_DPRRegisterList; 2350 else if (ARMMCRegisterClasses[ARM::SPRRegClassID]. 2351 contains(Regs.front().second)) 2352 Kind = k_SPRRegisterList; 2353 2354 // Sort based on the register encoding values. 2355 array_pod_sort(Regs.begin(), Regs.end()); 2356 2357 ARMOperand *Op = new ARMOperand(Kind); 2358 for (SmallVectorImpl<std::pair<unsigned, unsigned> >::const_iterator 2359 I = Regs.begin(), E = Regs.end(); I != E; ++I) 2360 Op->Registers.push_back(I->second); 2361 Op->StartLoc = StartLoc; 2362 Op->EndLoc = EndLoc; 2363 return Op; 2364 } 2365 2366 static ARMOperand *CreateVectorList(unsigned RegNum, unsigned Count, 2367 bool isDoubleSpaced, SMLoc S, SMLoc E) { 2368 ARMOperand *Op = new ARMOperand(k_VectorList); 2369 Op->VectorList.RegNum = RegNum; 2370 Op->VectorList.Count = Count; 2371 Op->VectorList.isDoubleSpaced = isDoubleSpaced; 2372 Op->StartLoc = S; 2373 Op->EndLoc = E; 2374 return Op; 2375 } 2376 2377 static ARMOperand *CreateVectorListAllLanes(unsigned RegNum, unsigned Count, 2378 bool isDoubleSpaced, 2379 SMLoc S, SMLoc E) { 2380 ARMOperand *Op = new ARMOperand(k_VectorListAllLanes); 2381 Op->VectorList.RegNum = RegNum; 2382 Op->VectorList.Count = Count; 2383 Op->VectorList.isDoubleSpaced = isDoubleSpaced; 2384 Op->StartLoc = S; 2385 Op->EndLoc = E; 2386 return Op; 2387 } 2388 2389 static ARMOperand *CreateVectorListIndexed(unsigned RegNum, unsigned Count, 2390 unsigned Index, 2391 bool isDoubleSpaced, 2392 SMLoc S, SMLoc E) { 2393 ARMOperand *Op = new ARMOperand(k_VectorListIndexed); 2394 Op->VectorList.RegNum = RegNum; 2395 Op->VectorList.Count = Count; 2396 Op->VectorList.LaneIndex = Index; 2397 Op->VectorList.isDoubleSpaced = isDoubleSpaced; 2398 Op->StartLoc = S; 2399 Op->EndLoc = E; 2400 return Op; 2401 } 2402 2403 static ARMOperand *CreateVectorIndex(unsigned Idx, SMLoc S, SMLoc E, 2404 MCContext &Ctx) { 2405 ARMOperand *Op = new ARMOperand(k_VectorIndex); 2406 Op->VectorIndex.Val = Idx; 2407 Op->StartLoc = S; 2408 Op->EndLoc = E; 2409 return Op; 2410 } 2411 2412 static ARMOperand *CreateImm(const MCExpr *Val, SMLoc S, SMLoc E) { 2413 ARMOperand *Op = new ARMOperand(k_Immediate); 2414 Op->Imm.Val = Val; 2415 Op->StartLoc = S; 2416 Op->EndLoc = E; 2417 return Op; 2418 } 2419 2420 static ARMOperand *CreateMem(unsigned BaseRegNum, 2421 const MCConstantExpr *OffsetImm, 2422 unsigned OffsetRegNum, 2423 ARM_AM::ShiftOpc ShiftType, 2424 unsigned ShiftImm, 2425 unsigned Alignment, 2426 bool isNegative, 2427 SMLoc S, SMLoc E) { 2428 ARMOperand *Op = new ARMOperand(k_Memory); 2429 Op->Memory.BaseRegNum = BaseRegNum; 2430 Op->Memory.OffsetImm = OffsetImm; 2431 Op->Memory.OffsetRegNum = OffsetRegNum; 2432 Op->Memory.ShiftType = ShiftType; 2433 Op->Memory.ShiftImm = ShiftImm; 2434 Op->Memory.Alignment = Alignment; 2435 Op->Memory.isNegative = isNegative; 2436 Op->StartLoc = S; 2437 Op->EndLoc = E; 2438 return Op; 2439 } 2440 2441 static ARMOperand *CreatePostIdxReg(unsigned RegNum, bool isAdd, 2442 ARM_AM::ShiftOpc ShiftTy, 2443 unsigned ShiftImm, 2444 SMLoc S, SMLoc E) { 2445 ARMOperand *Op = new ARMOperand(k_PostIndexRegister); 2446 Op->PostIdxReg.RegNum = RegNum; 2447 Op->PostIdxReg.isAdd = isAdd; 2448 Op->PostIdxReg.ShiftTy = ShiftTy; 2449 Op->PostIdxReg.ShiftImm = ShiftImm; 2450 Op->StartLoc = S; 2451 Op->EndLoc = E; 2452 return Op; 2453 } 2454 2455 static ARMOperand *CreateMemBarrierOpt(ARM_MB::MemBOpt Opt, SMLoc S) { 2456 ARMOperand *Op = new ARMOperand(k_MemBarrierOpt); 2457 Op->MBOpt.Val = Opt; 2458 Op->StartLoc = S; 2459 Op->EndLoc = S; 2460 return Op; 2461 } 2462 2463 static ARMOperand *CreateInstSyncBarrierOpt(ARM_ISB::InstSyncBOpt Opt, 2464 SMLoc S) { 2465 ARMOperand *Op = new ARMOperand(k_InstSyncBarrierOpt); 2466 Op->ISBOpt.Val = Opt; 2467 Op->StartLoc = S; 2468 Op->EndLoc = S; 2469 return Op; 2470 } 2471 2472 static ARMOperand *CreateProcIFlags(ARM_PROC::IFlags IFlags, SMLoc S) { 2473 ARMOperand *Op = new ARMOperand(k_ProcIFlags); 2474 Op->IFlags.Val = IFlags; 2475 Op->StartLoc = S; 2476 Op->EndLoc = S; 2477 return Op; 2478 } 2479 2480 static ARMOperand *CreateMSRMask(unsigned MMask, SMLoc S) { 2481 ARMOperand *Op = new ARMOperand(k_MSRMask); 2482 Op->MMask.Val = MMask; 2483 Op->StartLoc = S; 2484 Op->EndLoc = S; 2485 return Op; 2486 } 2487 }; 2488 2489 } // end anonymous namespace. 2490 2491 void ARMOperand::print(raw_ostream &OS) const { 2492 switch (Kind) { 2493 case k_CondCode: 2494 OS << "<ARMCC::" << ARMCondCodeToString(getCondCode()) << ">"; 2495 break; 2496 case k_CCOut: 2497 OS << "<ccout " << getReg() << ">"; 2498 break; 2499 case k_ITCondMask: { 2500 static const char *const MaskStr[] = { 2501 "()", "(t)", "(e)", "(tt)", "(et)", "(te)", "(ee)", "(ttt)", "(ett)", 2502 "(tet)", "(eet)", "(tte)", "(ete)", "(tee)", "(eee)" 2503 }; 2504 assert((ITMask.Mask & 0xf) == ITMask.Mask); 2505 OS << "<it-mask " << MaskStr[ITMask.Mask] << ">"; 2506 break; 2507 } 2508 case k_CoprocNum: 2509 OS << "<coprocessor number: " << getCoproc() << ">"; 2510 break; 2511 case k_CoprocReg: 2512 OS << "<coprocessor register: " << getCoproc() << ">"; 2513 break; 2514 case k_CoprocOption: 2515 OS << "<coprocessor option: " << CoprocOption.Val << ">"; 2516 break; 2517 case k_MSRMask: 2518 OS << "<mask: " << getMSRMask() << ">"; 2519 break; 2520 case k_Immediate: 2521 getImm()->print(OS); 2522 break; 2523 case k_MemBarrierOpt: 2524 OS << "<ARM_MB::" << MemBOptToString(getMemBarrierOpt()) << ">"; 2525 break; 2526 case k_InstSyncBarrierOpt: 2527 OS << "<ARM_ISB::" << InstSyncBOptToString(getInstSyncBarrierOpt()) << ">"; 2528 break; 2529 case k_Memory: 2530 OS << "<memory " 2531 << " base:" << Memory.BaseRegNum; 2532 OS << ">"; 2533 break; 2534 case k_PostIndexRegister: 2535 OS << "post-idx register " << (PostIdxReg.isAdd ? "" : "-") 2536 << PostIdxReg.RegNum; 2537 if (PostIdxReg.ShiftTy != ARM_AM::no_shift) 2538 OS << ARM_AM::getShiftOpcStr(PostIdxReg.ShiftTy) << " " 2539 << PostIdxReg.ShiftImm; 2540 OS << ">"; 2541 break; 2542 case k_ProcIFlags: { 2543 OS << "<ARM_PROC::"; 2544 unsigned IFlags = getProcIFlags(); 2545 for (int i=2; i >= 0; --i) 2546 if (IFlags & (1 << i)) 2547 OS << ARM_PROC::IFlagsToString(1 << i); 2548 OS << ">"; 2549 break; 2550 } 2551 case k_Register: 2552 OS << "<register " << getReg() << ">"; 2553 break; 2554 case k_ShifterImmediate: 2555 OS << "<shift " << (ShifterImm.isASR ? "asr" : "lsl") 2556 << " #" << ShifterImm.Imm << ">"; 2557 break; 2558 case k_ShiftedRegister: 2559 OS << "<so_reg_reg " 2560 << RegShiftedReg.SrcReg << " " 2561 << ARM_AM::getShiftOpcStr(RegShiftedReg.ShiftTy) 2562 << " " << RegShiftedReg.ShiftReg << ">"; 2563 break; 2564 case k_ShiftedImmediate: 2565 OS << "<so_reg_imm " 2566 << RegShiftedImm.SrcReg << " " 2567 << ARM_AM::getShiftOpcStr(RegShiftedImm.ShiftTy) 2568 << " #" << RegShiftedImm.ShiftImm << ">"; 2569 break; 2570 case k_RotateImmediate: 2571 OS << "<ror " << " #" << (RotImm.Imm * 8) << ">"; 2572 break; 2573 case k_BitfieldDescriptor: 2574 OS << "<bitfield " << "lsb: " << Bitfield.LSB 2575 << ", width: " << Bitfield.Width << ">"; 2576 break; 2577 case k_RegisterList: 2578 case k_DPRRegisterList: 2579 case k_SPRRegisterList: { 2580 OS << "<register_list "; 2581 2582 const SmallVectorImpl<unsigned> &RegList = getRegList(); 2583 for (SmallVectorImpl<unsigned>::const_iterator 2584 I = RegList.begin(), E = RegList.end(); I != E; ) { 2585 OS << *I; 2586 if (++I < E) OS << ", "; 2587 } 2588 2589 OS << ">"; 2590 break; 2591 } 2592 case k_VectorList: 2593 OS << "<vector_list " << VectorList.Count << " * " 2594 << VectorList.RegNum << ">"; 2595 break; 2596 case k_VectorListAllLanes: 2597 OS << "<vector_list(all lanes) " << VectorList.Count << " * " 2598 << VectorList.RegNum << ">"; 2599 break; 2600 case k_VectorListIndexed: 2601 OS << "<vector_list(lane " << VectorList.LaneIndex << ") " 2602 << VectorList.Count << " * " << VectorList.RegNum << ">"; 2603 break; 2604 case k_Token: 2605 OS << "'" << getToken() << "'"; 2606 break; 2607 case k_VectorIndex: 2608 OS << "<vectorindex " << getVectorIndex() << ">"; 2609 break; 2610 } 2611 } 2612 2613 /// @name Auto-generated Match Functions 2614 /// { 2615 2616 static unsigned MatchRegisterName(StringRef Name); 2617 2618 /// } 2619 2620 bool ARMAsmParser::ParseRegister(unsigned &RegNo, 2621 SMLoc &StartLoc, SMLoc &EndLoc) { 2622 StartLoc = Parser.getTok().getLoc(); 2623 EndLoc = Parser.getTok().getEndLoc(); 2624 RegNo = tryParseRegister(); 2625 2626 return (RegNo == (unsigned)-1); 2627 } 2628 2629 /// Try to parse a register name. The token must be an Identifier when called, 2630 /// and if it is a register name the token is eaten and the register number is 2631 /// returned. Otherwise return -1. 2632 /// 2633 int ARMAsmParser::tryParseRegister() { 2634 const AsmToken &Tok = Parser.getTok(); 2635 if (Tok.isNot(AsmToken::Identifier)) return -1; 2636 2637 std::string lowerCase = Tok.getString().lower(); 2638 unsigned RegNum = MatchRegisterName(lowerCase); 2639 if (!RegNum) { 2640 RegNum = StringSwitch<unsigned>(lowerCase) 2641 .Case("r13", ARM::SP) 2642 .Case("r14", ARM::LR) 2643 .Case("r15", ARM::PC) 2644 .Case("ip", ARM::R12) 2645 // Additional register name aliases for 'gas' compatibility. 2646 .Case("a1", ARM::R0) 2647 .Case("a2", ARM::R1) 2648 .Case("a3", ARM::R2) 2649 .Case("a4", ARM::R3) 2650 .Case("v1", ARM::R4) 2651 .Case("v2", ARM::R5) 2652 .Case("v3", ARM::R6) 2653 .Case("v4", ARM::R7) 2654 .Case("v5", ARM::R8) 2655 .Case("v6", ARM::R9) 2656 .Case("v7", ARM::R10) 2657 .Case("v8", ARM::R11) 2658 .Case("sb", ARM::R9) 2659 .Case("sl", ARM::R10) 2660 .Case("fp", ARM::R11) 2661 .Default(0); 2662 } 2663 if (!RegNum) { 2664 // Check for aliases registered via .req. Canonicalize to lower case. 2665 // That's more consistent since register names are case insensitive, and 2666 // it's how the original entry was passed in from MC/MCParser/AsmParser. 2667 StringMap<unsigned>::const_iterator Entry = RegisterReqs.find(lowerCase); 2668 // If no match, return failure. 2669 if (Entry == RegisterReqs.end()) 2670 return -1; 2671 Parser.Lex(); // Eat identifier token. 2672 return Entry->getValue(); 2673 } 2674 2675 Parser.Lex(); // Eat identifier token. 2676 2677 return RegNum; 2678 } 2679 2680 // Try to parse a shifter (e.g., "lsl <amt>"). On success, return 0. 2681 // If a recoverable error occurs, return 1. If an irrecoverable error 2682 // occurs, return -1. An irrecoverable error is one where tokens have been 2683 // consumed in the process of trying to parse the shifter (i.e., when it is 2684 // indeed a shifter operand, but malformed). 2685 int ARMAsmParser::tryParseShiftRegister( 2686 SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 2687 SMLoc S = Parser.getTok().getLoc(); 2688 const AsmToken &Tok = Parser.getTok(); 2689 assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 2690 2691 std::string lowerCase = Tok.getString().lower(); 2692 ARM_AM::ShiftOpc ShiftTy = StringSwitch<ARM_AM::ShiftOpc>(lowerCase) 2693 .Case("asl", ARM_AM::lsl) 2694 .Case("lsl", ARM_AM::lsl) 2695 .Case("lsr", ARM_AM::lsr) 2696 .Case("asr", ARM_AM::asr) 2697 .Case("ror", ARM_AM::ror) 2698 .Case("rrx", ARM_AM::rrx) 2699 .Default(ARM_AM::no_shift); 2700 2701 if (ShiftTy == ARM_AM::no_shift) 2702 return 1; 2703 2704 Parser.Lex(); // Eat the operator. 2705 2706 // The source register for the shift has already been added to the 2707 // operand list, so we need to pop it off and combine it into the shifted 2708 // register operand instead. 2709 OwningPtr<ARMOperand> PrevOp((ARMOperand*)Operands.pop_back_val()); 2710 if (!PrevOp->isReg()) 2711 return Error(PrevOp->getStartLoc(), "shift must be of a register"); 2712 int SrcReg = PrevOp->getReg(); 2713 2714 SMLoc EndLoc; 2715 int64_t Imm = 0; 2716 int ShiftReg = 0; 2717 if (ShiftTy == ARM_AM::rrx) { 2718 // RRX Doesn't have an explicit shift amount. The encoder expects 2719 // the shift register to be the same as the source register. Seems odd, 2720 // but OK. 2721 ShiftReg = SrcReg; 2722 } else { 2723 // Figure out if this is shifted by a constant or a register (for non-RRX). 2724 if (Parser.getTok().is(AsmToken::Hash) || 2725 Parser.getTok().is(AsmToken::Dollar)) { 2726 Parser.Lex(); // Eat hash. 2727 SMLoc ImmLoc = Parser.getTok().getLoc(); 2728 const MCExpr *ShiftExpr = 0; 2729 if (getParser().parseExpression(ShiftExpr, EndLoc)) { 2730 Error(ImmLoc, "invalid immediate shift value"); 2731 return -1; 2732 } 2733 // The expression must be evaluatable as an immediate. 2734 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftExpr); 2735 if (!CE) { 2736 Error(ImmLoc, "invalid immediate shift value"); 2737 return -1; 2738 } 2739 // Range check the immediate. 2740 // lsl, ror: 0 <= imm <= 31 2741 // lsr, asr: 0 <= imm <= 32 2742 Imm = CE->getValue(); 2743 if (Imm < 0 || 2744 ((ShiftTy == ARM_AM::lsl || ShiftTy == ARM_AM::ror) && Imm > 31) || 2745 ((ShiftTy == ARM_AM::lsr || ShiftTy == ARM_AM::asr) && Imm > 32)) { 2746 Error(ImmLoc, "immediate shift value out of range"); 2747 return -1; 2748 } 2749 // shift by zero is a nop. Always send it through as lsl. 2750 // ('as' compatibility) 2751 if (Imm == 0) 2752 ShiftTy = ARM_AM::lsl; 2753 } else if (Parser.getTok().is(AsmToken::Identifier)) { 2754 SMLoc L = Parser.getTok().getLoc(); 2755 EndLoc = Parser.getTok().getEndLoc(); 2756 ShiftReg = tryParseRegister(); 2757 if (ShiftReg == -1) { 2758 Error (L, "expected immediate or register in shift operand"); 2759 return -1; 2760 } 2761 } else { 2762 Error (Parser.getTok().getLoc(), 2763 "expected immediate or register in shift operand"); 2764 return -1; 2765 } 2766 } 2767 2768 if (ShiftReg && ShiftTy != ARM_AM::rrx) 2769 Operands.push_back(ARMOperand::CreateShiftedRegister(ShiftTy, SrcReg, 2770 ShiftReg, Imm, 2771 S, EndLoc)); 2772 else 2773 Operands.push_back(ARMOperand::CreateShiftedImmediate(ShiftTy, SrcReg, Imm, 2774 S, EndLoc)); 2775 2776 return 0; 2777 } 2778 2779 2780 /// Try to parse a register name. The token must be an Identifier when called. 2781 /// If it's a register, an AsmOperand is created. Another AsmOperand is created 2782 /// if there is a "writeback". 'true' if it's not a register. 2783 /// 2784 /// TODO this is likely to change to allow different register types and or to 2785 /// parse for a specific register type. 2786 bool ARMAsmParser:: 2787 tryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 2788 const AsmToken &RegTok = Parser.getTok(); 2789 int RegNo = tryParseRegister(); 2790 if (RegNo == -1) 2791 return true; 2792 2793 Operands.push_back(ARMOperand::CreateReg(RegNo, RegTok.getLoc(), 2794 RegTok.getEndLoc())); 2795 2796 const AsmToken &ExclaimTok = Parser.getTok(); 2797 if (ExclaimTok.is(AsmToken::Exclaim)) { 2798 Operands.push_back(ARMOperand::CreateToken(ExclaimTok.getString(), 2799 ExclaimTok.getLoc())); 2800 Parser.Lex(); // Eat exclaim token 2801 return false; 2802 } 2803 2804 // Also check for an index operand. This is only legal for vector registers, 2805 // but that'll get caught OK in operand matching, so we don't need to 2806 // explicitly filter everything else out here. 2807 if (Parser.getTok().is(AsmToken::LBrac)) { 2808 SMLoc SIdx = Parser.getTok().getLoc(); 2809 Parser.Lex(); // Eat left bracket token. 2810 2811 const MCExpr *ImmVal; 2812 if (getParser().parseExpression(ImmVal)) 2813 return true; 2814 const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(ImmVal); 2815 if (!MCE) 2816 return TokError("immediate value expected for vector index"); 2817 2818 if (Parser.getTok().isNot(AsmToken::RBrac)) 2819 return Error(Parser.getTok().getLoc(), "']' expected"); 2820 2821 SMLoc E = Parser.getTok().getEndLoc(); 2822 Parser.Lex(); // Eat right bracket token. 2823 2824 Operands.push_back(ARMOperand::CreateVectorIndex(MCE->getValue(), 2825 SIdx, E, 2826 getContext())); 2827 } 2828 2829 return false; 2830 } 2831 2832 /// MatchCoprocessorOperandName - Try to parse an coprocessor related 2833 /// instruction with a symbolic operand name. Example: "p1", "p7", "c3", 2834 /// "c5", ... 2835 static int MatchCoprocessorOperandName(StringRef Name, char CoprocOp) { 2836 // Use the same layout as the tablegen'erated register name matcher. Ugly, 2837 // but efficient. 2838 switch (Name.size()) { 2839 default: return -1; 2840 case 2: 2841 if (Name[0] != CoprocOp) 2842 return -1; 2843 switch (Name[1]) { 2844 default: return -1; 2845 case '0': return 0; 2846 case '1': return 1; 2847 case '2': return 2; 2848 case '3': return 3; 2849 case '4': return 4; 2850 case '5': return 5; 2851 case '6': return 6; 2852 case '7': return 7; 2853 case '8': return 8; 2854 case '9': return 9; 2855 } 2856 case 3: 2857 if (Name[0] != CoprocOp || Name[1] != '1') 2858 return -1; 2859 switch (Name[2]) { 2860 default: return -1; 2861 case '0': return 10; 2862 case '1': return 11; 2863 case '2': return 12; 2864 case '3': return 13; 2865 case '4': return 14; 2866 case '5': return 15; 2867 } 2868 } 2869 } 2870 2871 /// parseITCondCode - Try to parse a condition code for an IT instruction. 2872 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 2873 parseITCondCode(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 2874 SMLoc S = Parser.getTok().getLoc(); 2875 const AsmToken &Tok = Parser.getTok(); 2876 if (!Tok.is(AsmToken::Identifier)) 2877 return MatchOperand_NoMatch; 2878 unsigned CC = StringSwitch<unsigned>(Tok.getString().lower()) 2879 .Case("eq", ARMCC::EQ) 2880 .Case("ne", ARMCC::NE) 2881 .Case("hs", ARMCC::HS) 2882 .Case("cs", ARMCC::HS) 2883 .Case("lo", ARMCC::LO) 2884 .Case("cc", ARMCC::LO) 2885 .Case("mi", ARMCC::MI) 2886 .Case("pl", ARMCC::PL) 2887 .Case("vs", ARMCC::VS) 2888 .Case("vc", ARMCC::VC) 2889 .Case("hi", ARMCC::HI) 2890 .Case("ls", ARMCC::LS) 2891 .Case("ge", ARMCC::GE) 2892 .Case("lt", ARMCC::LT) 2893 .Case("gt", ARMCC::GT) 2894 .Case("le", ARMCC::LE) 2895 .Case("al", ARMCC::AL) 2896 .Default(~0U); 2897 if (CC == ~0U) 2898 return MatchOperand_NoMatch; 2899 Parser.Lex(); // Eat the token. 2900 2901 Operands.push_back(ARMOperand::CreateCondCode(ARMCC::CondCodes(CC), S)); 2902 2903 return MatchOperand_Success; 2904 } 2905 2906 /// parseCoprocNumOperand - Try to parse an coprocessor number operand. The 2907 /// token must be an Identifier when called, and if it is a coprocessor 2908 /// number, the token is eaten and the operand is added to the operand list. 2909 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 2910 parseCoprocNumOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 2911 SMLoc S = Parser.getTok().getLoc(); 2912 const AsmToken &Tok = Parser.getTok(); 2913 if (Tok.isNot(AsmToken::Identifier)) 2914 return MatchOperand_NoMatch; 2915 2916 int Num = MatchCoprocessorOperandName(Tok.getString(), 'p'); 2917 if (Num == -1) 2918 return MatchOperand_NoMatch; 2919 2920 Parser.Lex(); // Eat identifier token. 2921 Operands.push_back(ARMOperand::CreateCoprocNum(Num, S)); 2922 return MatchOperand_Success; 2923 } 2924 2925 /// parseCoprocRegOperand - Try to parse an coprocessor register operand. The 2926 /// token must be an Identifier when called, and if it is a coprocessor 2927 /// number, the token is eaten and the operand is added to the operand list. 2928 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 2929 parseCoprocRegOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 2930 SMLoc S = Parser.getTok().getLoc(); 2931 const AsmToken &Tok = Parser.getTok(); 2932 if (Tok.isNot(AsmToken::Identifier)) 2933 return MatchOperand_NoMatch; 2934 2935 int Reg = MatchCoprocessorOperandName(Tok.getString(), 'c'); 2936 if (Reg == -1) 2937 return MatchOperand_NoMatch; 2938 2939 Parser.Lex(); // Eat identifier token. 2940 Operands.push_back(ARMOperand::CreateCoprocReg(Reg, S)); 2941 return MatchOperand_Success; 2942 } 2943 2944 /// parseCoprocOptionOperand - Try to parse an coprocessor option operand. 2945 /// coproc_option : '{' imm0_255 '}' 2946 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 2947 parseCoprocOptionOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 2948 SMLoc S = Parser.getTok().getLoc(); 2949 2950 // If this isn't a '{', this isn't a coprocessor immediate operand. 2951 if (Parser.getTok().isNot(AsmToken::LCurly)) 2952 return MatchOperand_NoMatch; 2953 Parser.Lex(); // Eat the '{' 2954 2955 const MCExpr *Expr; 2956 SMLoc Loc = Parser.getTok().getLoc(); 2957 if (getParser().parseExpression(Expr)) { 2958 Error(Loc, "illegal expression"); 2959 return MatchOperand_ParseFail; 2960 } 2961 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr); 2962 if (!CE || CE->getValue() < 0 || CE->getValue() > 255) { 2963 Error(Loc, "coprocessor option must be an immediate in range [0, 255]"); 2964 return MatchOperand_ParseFail; 2965 } 2966 int Val = CE->getValue(); 2967 2968 // Check for and consume the closing '}' 2969 if (Parser.getTok().isNot(AsmToken::RCurly)) 2970 return MatchOperand_ParseFail; 2971 SMLoc E = Parser.getTok().getEndLoc(); 2972 Parser.Lex(); // Eat the '}' 2973 2974 Operands.push_back(ARMOperand::CreateCoprocOption(Val, S, E)); 2975 return MatchOperand_Success; 2976 } 2977 2978 // For register list parsing, we need to map from raw GPR register numbering 2979 // to the enumeration values. The enumeration values aren't sorted by 2980 // register number due to our using "sp", "lr" and "pc" as canonical names. 2981 static unsigned getNextRegister(unsigned Reg) { 2982 // If this is a GPR, we need to do it manually, otherwise we can rely 2983 // on the sort ordering of the enumeration since the other reg-classes 2984 // are sane. 2985 if (!ARMMCRegisterClasses[ARM::GPRRegClassID].contains(Reg)) 2986 return Reg + 1; 2987 switch(Reg) { 2988 default: llvm_unreachable("Invalid GPR number!"); 2989 case ARM::R0: return ARM::R1; case ARM::R1: return ARM::R2; 2990 case ARM::R2: return ARM::R3; case ARM::R3: return ARM::R4; 2991 case ARM::R4: return ARM::R5; case ARM::R5: return ARM::R6; 2992 case ARM::R6: return ARM::R7; case ARM::R7: return ARM::R8; 2993 case ARM::R8: return ARM::R9; case ARM::R9: return ARM::R10; 2994 case ARM::R10: return ARM::R11; case ARM::R11: return ARM::R12; 2995 case ARM::R12: return ARM::SP; case ARM::SP: return ARM::LR; 2996 case ARM::LR: return ARM::PC; case ARM::PC: return ARM::R0; 2997 } 2998 } 2999 3000 // Return the low-subreg of a given Q register. 3001 static unsigned getDRegFromQReg(unsigned QReg) { 3002 switch (QReg) { 3003 default: llvm_unreachable("expected a Q register!"); 3004 case ARM::Q0: return ARM::D0; 3005 case ARM::Q1: return ARM::D2; 3006 case ARM::Q2: return ARM::D4; 3007 case ARM::Q3: return ARM::D6; 3008 case ARM::Q4: return ARM::D8; 3009 case ARM::Q5: return ARM::D10; 3010 case ARM::Q6: return ARM::D12; 3011 case ARM::Q7: return ARM::D14; 3012 case ARM::Q8: return ARM::D16; 3013 case ARM::Q9: return ARM::D18; 3014 case ARM::Q10: return ARM::D20; 3015 case ARM::Q11: return ARM::D22; 3016 case ARM::Q12: return ARM::D24; 3017 case ARM::Q13: return ARM::D26; 3018 case ARM::Q14: return ARM::D28; 3019 case ARM::Q15: return ARM::D30; 3020 } 3021 } 3022 3023 /// Parse a register list. 3024 bool ARMAsmParser:: 3025 parseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 3026 assert(Parser.getTok().is(AsmToken::LCurly) && 3027 "Token is not a Left Curly Brace"); 3028 SMLoc S = Parser.getTok().getLoc(); 3029 Parser.Lex(); // Eat '{' token. 3030 SMLoc RegLoc = Parser.getTok().getLoc(); 3031 3032 // Check the first register in the list to see what register class 3033 // this is a list of. 3034 int Reg = tryParseRegister(); 3035 if (Reg == -1) 3036 return Error(RegLoc, "register expected"); 3037 3038 // The reglist instructions have at most 16 registers, so reserve 3039 // space for that many. 3040 int EReg = 0; 3041 SmallVector<std::pair<unsigned, unsigned>, 16> Registers; 3042 3043 // Allow Q regs and just interpret them as the two D sub-registers. 3044 if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) { 3045 Reg = getDRegFromQReg(Reg); 3046 EReg = MRI->getEncodingValue(Reg); 3047 Registers.push_back(std::pair<unsigned, unsigned>(EReg, Reg)); 3048 ++Reg; 3049 } 3050 const MCRegisterClass *RC; 3051 if (ARMMCRegisterClasses[ARM::GPRRegClassID].contains(Reg)) 3052 RC = &ARMMCRegisterClasses[ARM::GPRRegClassID]; 3053 else if (ARMMCRegisterClasses[ARM::DPRRegClassID].contains(Reg)) 3054 RC = &ARMMCRegisterClasses[ARM::DPRRegClassID]; 3055 else if (ARMMCRegisterClasses[ARM::SPRRegClassID].contains(Reg)) 3056 RC = &ARMMCRegisterClasses[ARM::SPRRegClassID]; 3057 else 3058 return Error(RegLoc, "invalid register in register list"); 3059 3060 // Store the register. 3061 EReg = MRI->getEncodingValue(Reg); 3062 Registers.push_back(std::pair<unsigned, unsigned>(EReg, Reg)); 3063 3064 // This starts immediately after the first register token in the list, 3065 // so we can see either a comma or a minus (range separator) as a legal 3066 // next token. 3067 while (Parser.getTok().is(AsmToken::Comma) || 3068 Parser.getTok().is(AsmToken::Minus)) { 3069 if (Parser.getTok().is(AsmToken::Minus)) { 3070 Parser.Lex(); // Eat the minus. 3071 SMLoc AfterMinusLoc = Parser.getTok().getLoc(); 3072 int EndReg = tryParseRegister(); 3073 if (EndReg == -1) 3074 return Error(AfterMinusLoc, "register expected"); 3075 // Allow Q regs and just interpret them as the two D sub-registers. 3076 if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(EndReg)) 3077 EndReg = getDRegFromQReg(EndReg) + 1; 3078 // If the register is the same as the start reg, there's nothing 3079 // more to do. 3080 if (Reg == EndReg) 3081 continue; 3082 // The register must be in the same register class as the first. 3083 if (!RC->contains(EndReg)) 3084 return Error(AfterMinusLoc, "invalid register in register list"); 3085 // Ranges must go from low to high. 3086 if (MRI->getEncodingValue(Reg) > MRI->getEncodingValue(EndReg)) 3087 return Error(AfterMinusLoc, "bad range in register list"); 3088 3089 // Add all the registers in the range to the register list. 3090 while (Reg != EndReg) { 3091 Reg = getNextRegister(Reg); 3092 EReg = MRI->getEncodingValue(Reg); 3093 Registers.push_back(std::pair<unsigned, unsigned>(EReg, Reg)); 3094 } 3095 continue; 3096 } 3097 Parser.Lex(); // Eat the comma. 3098 RegLoc = Parser.getTok().getLoc(); 3099 int OldReg = Reg; 3100 const AsmToken RegTok = Parser.getTok(); 3101 Reg = tryParseRegister(); 3102 if (Reg == -1) 3103 return Error(RegLoc, "register expected"); 3104 // Allow Q regs and just interpret them as the two D sub-registers. 3105 bool isQReg = false; 3106 if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) { 3107 Reg = getDRegFromQReg(Reg); 3108 isQReg = true; 3109 } 3110 // The register must be in the same register class as the first. 3111 if (!RC->contains(Reg)) 3112 return Error(RegLoc, "invalid register in register list"); 3113 // List must be monotonically increasing. 3114 if (MRI->getEncodingValue(Reg) < MRI->getEncodingValue(OldReg)) { 3115 if (ARMMCRegisterClasses[ARM::GPRRegClassID].contains(Reg)) 3116 Warning(RegLoc, "register list not in ascending order"); 3117 else 3118 return Error(RegLoc, "register list not in ascending order"); 3119 } 3120 if (MRI->getEncodingValue(Reg) == MRI->getEncodingValue(OldReg)) { 3121 Warning(RegLoc, "duplicated register (" + RegTok.getString() + 3122 ") in register list"); 3123 continue; 3124 } 3125 // VFP register lists must also be contiguous. 3126 if (RC != &ARMMCRegisterClasses[ARM::GPRRegClassID] && 3127 Reg != OldReg + 1) 3128 return Error(RegLoc, "non-contiguous register range"); 3129 EReg = MRI->getEncodingValue(Reg); 3130 Registers.push_back(std::pair<unsigned, unsigned>(EReg, Reg)); 3131 if (isQReg) { 3132 EReg = MRI->getEncodingValue(++Reg); 3133 Registers.push_back(std::pair<unsigned, unsigned>(EReg, Reg)); 3134 } 3135 } 3136 3137 if (Parser.getTok().isNot(AsmToken::RCurly)) 3138 return Error(Parser.getTok().getLoc(), "'}' expected"); 3139 SMLoc E = Parser.getTok().getEndLoc(); 3140 Parser.Lex(); // Eat '}' token. 3141 3142 // Push the register list operand. 3143 Operands.push_back(ARMOperand::CreateRegList(Registers, S, E)); 3144 3145 // The ARM system instruction variants for LDM/STM have a '^' token here. 3146 if (Parser.getTok().is(AsmToken::Caret)) { 3147 Operands.push_back(ARMOperand::CreateToken("^",Parser.getTok().getLoc())); 3148 Parser.Lex(); // Eat '^' token. 3149 } 3150 3151 return false; 3152 } 3153 3154 // Helper function to parse the lane index for vector lists. 3155 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 3156 parseVectorLane(VectorLaneTy &LaneKind, unsigned &Index, SMLoc &EndLoc) { 3157 Index = 0; // Always return a defined index value. 3158 if (Parser.getTok().is(AsmToken::LBrac)) { 3159 Parser.Lex(); // Eat the '['. 3160 if (Parser.getTok().is(AsmToken::RBrac)) { 3161 // "Dn[]" is the 'all lanes' syntax. 3162 LaneKind = AllLanes; 3163 EndLoc = Parser.getTok().getEndLoc(); 3164 Parser.Lex(); // Eat the ']'. 3165 return MatchOperand_Success; 3166 } 3167 3168 // There's an optional '#' token here. Normally there wouldn't be, but 3169 // inline assemble puts one in, and it's friendly to accept that. 3170 if (Parser.getTok().is(AsmToken::Hash)) 3171 Parser.Lex(); // Eat '#' or '$'. 3172 3173 const MCExpr *LaneIndex; 3174 SMLoc Loc = Parser.getTok().getLoc(); 3175 if (getParser().parseExpression(LaneIndex)) { 3176 Error(Loc, "illegal expression"); 3177 return MatchOperand_ParseFail; 3178 } 3179 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(LaneIndex); 3180 if (!CE) { 3181 Error(Loc, "lane index must be empty or an integer"); 3182 return MatchOperand_ParseFail; 3183 } 3184 if (Parser.getTok().isNot(AsmToken::RBrac)) { 3185 Error(Parser.getTok().getLoc(), "']' expected"); 3186 return MatchOperand_ParseFail; 3187 } 3188 EndLoc = Parser.getTok().getEndLoc(); 3189 Parser.Lex(); // Eat the ']'. 3190 int64_t Val = CE->getValue(); 3191 3192 // FIXME: Make this range check context sensitive for .8, .16, .32. 3193 if (Val < 0 || Val > 7) { 3194 Error(Parser.getTok().getLoc(), "lane index out of range"); 3195 return MatchOperand_ParseFail; 3196 } 3197 Index = Val; 3198 LaneKind = IndexedLane; 3199 return MatchOperand_Success; 3200 } 3201 LaneKind = NoLanes; 3202 return MatchOperand_Success; 3203 } 3204 3205 // parse a vector register list 3206 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 3207 parseVectorList(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 3208 VectorLaneTy LaneKind; 3209 unsigned LaneIndex; 3210 SMLoc S = Parser.getTok().getLoc(); 3211 // As an extension (to match gas), support a plain D register or Q register 3212 // (without encosing curly braces) as a single or double entry list, 3213 // respectively. 3214 if (Parser.getTok().is(AsmToken::Identifier)) { 3215 SMLoc E = Parser.getTok().getEndLoc(); 3216 int Reg = tryParseRegister(); 3217 if (Reg == -1) 3218 return MatchOperand_NoMatch; 3219 if (ARMMCRegisterClasses[ARM::DPRRegClassID].contains(Reg)) { 3220 OperandMatchResultTy Res = parseVectorLane(LaneKind, LaneIndex, E); 3221 if (Res != MatchOperand_Success) 3222 return Res; 3223 switch (LaneKind) { 3224 case NoLanes: 3225 Operands.push_back(ARMOperand::CreateVectorList(Reg, 1, false, S, E)); 3226 break; 3227 case AllLanes: 3228 Operands.push_back(ARMOperand::CreateVectorListAllLanes(Reg, 1, false, 3229 S, E)); 3230 break; 3231 case IndexedLane: 3232 Operands.push_back(ARMOperand::CreateVectorListIndexed(Reg, 1, 3233 LaneIndex, 3234 false, S, E)); 3235 break; 3236 } 3237 return MatchOperand_Success; 3238 } 3239 if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) { 3240 Reg = getDRegFromQReg(Reg); 3241 OperandMatchResultTy Res = parseVectorLane(LaneKind, LaneIndex, E); 3242 if (Res != MatchOperand_Success) 3243 return Res; 3244 switch (LaneKind) { 3245 case NoLanes: 3246 Reg = MRI->getMatchingSuperReg(Reg, ARM::dsub_0, 3247 &ARMMCRegisterClasses[ARM::DPairRegClassID]); 3248 Operands.push_back(ARMOperand::CreateVectorList(Reg, 2, false, S, E)); 3249 break; 3250 case AllLanes: 3251 Reg = MRI->getMatchingSuperReg(Reg, ARM::dsub_0, 3252 &ARMMCRegisterClasses[ARM::DPairRegClassID]); 3253 Operands.push_back(ARMOperand::CreateVectorListAllLanes(Reg, 2, false, 3254 S, E)); 3255 break; 3256 case IndexedLane: 3257 Operands.push_back(ARMOperand::CreateVectorListIndexed(Reg, 2, 3258 LaneIndex, 3259 false, S, E)); 3260 break; 3261 } 3262 return MatchOperand_Success; 3263 } 3264 Error(S, "vector register expected"); 3265 return MatchOperand_ParseFail; 3266 } 3267 3268 if (Parser.getTok().isNot(AsmToken::LCurly)) 3269 return MatchOperand_NoMatch; 3270 3271 Parser.Lex(); // Eat '{' token. 3272 SMLoc RegLoc = Parser.getTok().getLoc(); 3273 3274 int Reg = tryParseRegister(); 3275 if (Reg == -1) { 3276 Error(RegLoc, "register expected"); 3277 return MatchOperand_ParseFail; 3278 } 3279 unsigned Count = 1; 3280 int Spacing = 0; 3281 unsigned FirstReg = Reg; 3282 // The list is of D registers, but we also allow Q regs and just interpret 3283 // them as the two D sub-registers. 3284 if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) { 3285 FirstReg = Reg = getDRegFromQReg(Reg); 3286 Spacing = 1; // double-spacing requires explicit D registers, otherwise 3287 // it's ambiguous with four-register single spaced. 3288 ++Reg; 3289 ++Count; 3290 } 3291 3292 SMLoc E; 3293 if (parseVectorLane(LaneKind, LaneIndex, E) != MatchOperand_Success) 3294 return MatchOperand_ParseFail; 3295 3296 while (Parser.getTok().is(AsmToken::Comma) || 3297 Parser.getTok().is(AsmToken::Minus)) { 3298 if (Parser.getTok().is(AsmToken::Minus)) { 3299 if (!Spacing) 3300 Spacing = 1; // Register range implies a single spaced list. 3301 else if (Spacing == 2) { 3302 Error(Parser.getTok().getLoc(), 3303 "sequential registers in double spaced list"); 3304 return MatchOperand_ParseFail; 3305 } 3306 Parser.Lex(); // Eat the minus. 3307 SMLoc AfterMinusLoc = Parser.getTok().getLoc(); 3308 int EndReg = tryParseRegister(); 3309 if (EndReg == -1) { 3310 Error(AfterMinusLoc, "register expected"); 3311 return MatchOperand_ParseFail; 3312 } 3313 // Allow Q regs and just interpret them as the two D sub-registers. 3314 if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(EndReg)) 3315 EndReg = getDRegFromQReg(EndReg) + 1; 3316 // If the register is the same as the start reg, there's nothing 3317 // more to do. 3318 if (Reg == EndReg) 3319 continue; 3320 // The register must be in the same register class as the first. 3321 if (!ARMMCRegisterClasses[ARM::DPRRegClassID].contains(EndReg)) { 3322 Error(AfterMinusLoc, "invalid register in register list"); 3323 return MatchOperand_ParseFail; 3324 } 3325 // Ranges must go from low to high. 3326 if (Reg > EndReg) { 3327 Error(AfterMinusLoc, "bad range in register list"); 3328 return MatchOperand_ParseFail; 3329 } 3330 // Parse the lane specifier if present. 3331 VectorLaneTy NextLaneKind; 3332 unsigned NextLaneIndex; 3333 if (parseVectorLane(NextLaneKind, NextLaneIndex, E) != 3334 MatchOperand_Success) 3335 return MatchOperand_ParseFail; 3336 if (NextLaneKind != LaneKind || LaneIndex != NextLaneIndex) { 3337 Error(AfterMinusLoc, "mismatched lane index in register list"); 3338 return MatchOperand_ParseFail; 3339 } 3340 3341 // Add all the registers in the range to the register list. 3342 Count += EndReg - Reg; 3343 Reg = EndReg; 3344 continue; 3345 } 3346 Parser.Lex(); // Eat the comma. 3347 RegLoc = Parser.getTok().getLoc(); 3348 int OldReg = Reg; 3349 Reg = tryParseRegister(); 3350 if (Reg == -1) { 3351 Error(RegLoc, "register expected"); 3352 return MatchOperand_ParseFail; 3353 } 3354 // vector register lists must be contiguous. 3355 // It's OK to use the enumeration values directly here rather, as the 3356 // VFP register classes have the enum sorted properly. 3357 // 3358 // The list is of D registers, but we also allow Q regs and just interpret 3359 // them as the two D sub-registers. 3360 if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) { 3361 if (!Spacing) 3362 Spacing = 1; // Register range implies a single spaced list. 3363 else if (Spacing == 2) { 3364 Error(RegLoc, 3365 "invalid register in double-spaced list (must be 'D' register')"); 3366 return MatchOperand_ParseFail; 3367 } 3368 Reg = getDRegFromQReg(Reg); 3369 if (Reg != OldReg + 1) { 3370 Error(RegLoc, "non-contiguous register range"); 3371 return MatchOperand_ParseFail; 3372 } 3373 ++Reg; 3374 Count += 2; 3375 // Parse the lane specifier if present. 3376 VectorLaneTy NextLaneKind; 3377 unsigned NextLaneIndex; 3378 SMLoc LaneLoc = Parser.getTok().getLoc(); 3379 if (parseVectorLane(NextLaneKind, NextLaneIndex, E) != 3380 MatchOperand_Success) 3381 return MatchOperand_ParseFail; 3382 if (NextLaneKind != LaneKind || LaneIndex != NextLaneIndex) { 3383 Error(LaneLoc, "mismatched lane index in register list"); 3384 return MatchOperand_ParseFail; 3385 } 3386 continue; 3387 } 3388 // Normal D register. 3389 // Figure out the register spacing (single or double) of the list if 3390 // we don't know it already. 3391 if (!Spacing) 3392 Spacing = 1 + (Reg == OldReg + 2); 3393 3394 // Just check that it's contiguous and keep going. 3395 if (Reg != OldReg + Spacing) { 3396 Error(RegLoc, "non-contiguous register range"); 3397 return MatchOperand_ParseFail; 3398 } 3399 ++Count; 3400 // Parse the lane specifier if present. 3401 VectorLaneTy NextLaneKind; 3402 unsigned NextLaneIndex; 3403 SMLoc EndLoc = Parser.getTok().getLoc(); 3404 if (parseVectorLane(NextLaneKind, NextLaneIndex, E) != MatchOperand_Success) 3405 return MatchOperand_ParseFail; 3406 if (NextLaneKind != LaneKind || LaneIndex != NextLaneIndex) { 3407 Error(EndLoc, "mismatched lane index in register list"); 3408 return MatchOperand_ParseFail; 3409 } 3410 } 3411 3412 if (Parser.getTok().isNot(AsmToken::RCurly)) { 3413 Error(Parser.getTok().getLoc(), "'}' expected"); 3414 return MatchOperand_ParseFail; 3415 } 3416 E = Parser.getTok().getEndLoc(); 3417 Parser.Lex(); // Eat '}' token. 3418 3419 switch (LaneKind) { 3420 case NoLanes: 3421 // Two-register operands have been converted to the 3422 // composite register classes. 3423 if (Count == 2) { 3424 const MCRegisterClass *RC = (Spacing == 1) ? 3425 &ARMMCRegisterClasses[ARM::DPairRegClassID] : 3426 &ARMMCRegisterClasses[ARM::DPairSpcRegClassID]; 3427 FirstReg = MRI->getMatchingSuperReg(FirstReg, ARM::dsub_0, RC); 3428 } 3429 3430 Operands.push_back(ARMOperand::CreateVectorList(FirstReg, Count, 3431 (Spacing == 2), S, E)); 3432 break; 3433 case AllLanes: 3434 // Two-register operands have been converted to the 3435 // composite register classes. 3436 if (Count == 2) { 3437 const MCRegisterClass *RC = (Spacing == 1) ? 3438 &ARMMCRegisterClasses[ARM::DPairRegClassID] : 3439 &ARMMCRegisterClasses[ARM::DPairSpcRegClassID]; 3440 FirstReg = MRI->getMatchingSuperReg(FirstReg, ARM::dsub_0, RC); 3441 } 3442 Operands.push_back(ARMOperand::CreateVectorListAllLanes(FirstReg, Count, 3443 (Spacing == 2), 3444 S, E)); 3445 break; 3446 case IndexedLane: 3447 Operands.push_back(ARMOperand::CreateVectorListIndexed(FirstReg, Count, 3448 LaneIndex, 3449 (Spacing == 2), 3450 S, E)); 3451 break; 3452 } 3453 return MatchOperand_Success; 3454 } 3455 3456 /// parseMemBarrierOptOperand - Try to parse DSB/DMB data barrier options. 3457 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 3458 parseMemBarrierOptOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 3459 SMLoc S = Parser.getTok().getLoc(); 3460 const AsmToken &Tok = Parser.getTok(); 3461 unsigned Opt; 3462 3463 if (Tok.is(AsmToken::Identifier)) { 3464 StringRef OptStr = Tok.getString(); 3465 3466 Opt = StringSwitch<unsigned>(OptStr.slice(0, OptStr.size()).lower()) 3467 .Case("sy", ARM_MB::SY) 3468 .Case("st", ARM_MB::ST) 3469 .Case("sh", ARM_MB::ISH) 3470 .Case("ish", ARM_MB::ISH) 3471 .Case("shst", ARM_MB::ISHST) 3472 .Case("ishst", ARM_MB::ISHST) 3473 .Case("nsh", ARM_MB::NSH) 3474 .Case("un", ARM_MB::NSH) 3475 .Case("nshst", ARM_MB::NSHST) 3476 .Case("unst", ARM_MB::NSHST) 3477 .Case("osh", ARM_MB::OSH) 3478 .Case("oshst", ARM_MB::OSHST) 3479 .Default(~0U); 3480 3481 if (Opt == ~0U) 3482 return MatchOperand_NoMatch; 3483 3484 Parser.Lex(); // Eat identifier token. 3485 } else if (Tok.is(AsmToken::Hash) || 3486 Tok.is(AsmToken::Dollar) || 3487 Tok.is(AsmToken::Integer)) { 3488 if (Parser.getTok().isNot(AsmToken::Integer)) 3489 Parser.Lex(); // Eat '#' or '$'. 3490 SMLoc Loc = Parser.getTok().getLoc(); 3491 3492 const MCExpr *MemBarrierID; 3493 if (getParser().parseExpression(MemBarrierID)) { 3494 Error(Loc, "illegal expression"); 3495 return MatchOperand_ParseFail; 3496 } 3497 3498 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(MemBarrierID); 3499 if (!CE) { 3500 Error(Loc, "constant expression expected"); 3501 return MatchOperand_ParseFail; 3502 } 3503 3504 int Val = CE->getValue(); 3505 if (Val & ~0xf) { 3506 Error(Loc, "immediate value out of range"); 3507 return MatchOperand_ParseFail; 3508 } 3509 3510 Opt = ARM_MB::RESERVED_0 + Val; 3511 } else 3512 return MatchOperand_ParseFail; 3513 3514 Operands.push_back(ARMOperand::CreateMemBarrierOpt((ARM_MB::MemBOpt)Opt, S)); 3515 return MatchOperand_Success; 3516 } 3517 3518 /// parseInstSyncBarrierOptOperand - Try to parse ISB inst sync barrier options. 3519 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 3520 parseInstSyncBarrierOptOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 3521 SMLoc S = Parser.getTok().getLoc(); 3522 const AsmToken &Tok = Parser.getTok(); 3523 unsigned Opt; 3524 3525 if (Tok.is(AsmToken::Identifier)) { 3526 StringRef OptStr = Tok.getString(); 3527 3528 if (OptStr.lower() == "sy") 3529 Opt = ARM_ISB::SY; 3530 else 3531 return MatchOperand_NoMatch; 3532 3533 Parser.Lex(); // Eat identifier token. 3534 } else if (Tok.is(AsmToken::Hash) || 3535 Tok.is(AsmToken::Dollar) || 3536 Tok.is(AsmToken::Integer)) { 3537 if (Parser.getTok().isNot(AsmToken::Integer)) 3538 Parser.Lex(); // Eat '#' or '$'. 3539 SMLoc Loc = Parser.getTok().getLoc(); 3540 3541 const MCExpr *ISBarrierID; 3542 if (getParser().parseExpression(ISBarrierID)) { 3543 Error(Loc, "illegal expression"); 3544 return MatchOperand_ParseFail; 3545 } 3546 3547 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ISBarrierID); 3548 if (!CE) { 3549 Error(Loc, "constant expression expected"); 3550 return MatchOperand_ParseFail; 3551 } 3552 3553 int Val = CE->getValue(); 3554 if (Val & ~0xf) { 3555 Error(Loc, "immediate value out of range"); 3556 return MatchOperand_ParseFail; 3557 } 3558 3559 Opt = ARM_ISB::RESERVED_0 + Val; 3560 } else 3561 return MatchOperand_ParseFail; 3562 3563 Operands.push_back(ARMOperand::CreateInstSyncBarrierOpt( 3564 (ARM_ISB::InstSyncBOpt)Opt, S)); 3565 return MatchOperand_Success; 3566 } 3567 3568 3569 /// parseProcIFlagsOperand - Try to parse iflags from CPS instruction. 3570 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 3571 parseProcIFlagsOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 3572 SMLoc S = Parser.getTok().getLoc(); 3573 const AsmToken &Tok = Parser.getTok(); 3574 if (!Tok.is(AsmToken::Identifier)) 3575 return MatchOperand_NoMatch; 3576 StringRef IFlagsStr = Tok.getString(); 3577 3578 // An iflags string of "none" is interpreted to mean that none of the AIF 3579 // bits are set. Not a terribly useful instruction, but a valid encoding. 3580 unsigned IFlags = 0; 3581 if (IFlagsStr != "none") { 3582 for (int i = 0, e = IFlagsStr.size(); i != e; ++i) { 3583 unsigned Flag = StringSwitch<unsigned>(IFlagsStr.substr(i, 1)) 3584 .Case("a", ARM_PROC::A) 3585 .Case("i", ARM_PROC::I) 3586 .Case("f", ARM_PROC::F) 3587 .Default(~0U); 3588 3589 // If some specific iflag is already set, it means that some letter is 3590 // present more than once, this is not acceptable. 3591 if (Flag == ~0U || (IFlags & Flag)) 3592 return MatchOperand_NoMatch; 3593 3594 IFlags |= Flag; 3595 } 3596 } 3597 3598 Parser.Lex(); // Eat identifier token. 3599 Operands.push_back(ARMOperand::CreateProcIFlags((ARM_PROC::IFlags)IFlags, S)); 3600 return MatchOperand_Success; 3601 } 3602 3603 /// parseMSRMaskOperand - Try to parse mask flags from MSR instruction. 3604 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 3605 parseMSRMaskOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 3606 SMLoc S = Parser.getTok().getLoc(); 3607 const AsmToken &Tok = Parser.getTok(); 3608 if (!Tok.is(AsmToken::Identifier)) 3609 return MatchOperand_NoMatch; 3610 StringRef Mask = Tok.getString(); 3611 3612 if (isMClass()) { 3613 // See ARMv6-M 10.1.1 3614 std::string Name = Mask.lower(); 3615 unsigned FlagsVal = StringSwitch<unsigned>(Name) 3616 // Note: in the documentation: 3617 // ARM deprecates using MSR APSR without a _<bits> qualifier as an alias 3618 // for MSR APSR_nzcvq. 3619 // but we do make it an alias here. This is so to get the "mask encoding" 3620 // bits correct on MSR APSR writes. 3621 // 3622 // FIXME: Note the 0xc00 "mask encoding" bits version of the registers 3623 // should really only be allowed when writing a special register. Note 3624 // they get dropped in the MRS instruction reading a special register as 3625 // the SYSm field is only 8 bits. 3626 // 3627 // FIXME: the _g and _nzcvqg versions are only allowed if the processor 3628 // includes the DSP extension but that is not checked. 3629 .Case("apsr", 0x800) 3630 .Case("apsr_nzcvq", 0x800) 3631 .Case("apsr_g", 0x400) 3632 .Case("apsr_nzcvqg", 0xc00) 3633 .Case("iapsr", 0x801) 3634 .Case("iapsr_nzcvq", 0x801) 3635 .Case("iapsr_g", 0x401) 3636 .Case("iapsr_nzcvqg", 0xc01) 3637 .Case("eapsr", 0x802) 3638 .Case("eapsr_nzcvq", 0x802) 3639 .Case("eapsr_g", 0x402) 3640 .Case("eapsr_nzcvqg", 0xc02) 3641 .Case("xpsr", 0x803) 3642 .Case("xpsr_nzcvq", 0x803) 3643 .Case("xpsr_g", 0x403) 3644 .Case("xpsr_nzcvqg", 0xc03) 3645 .Case("ipsr", 0x805) 3646 .Case("epsr", 0x806) 3647 .Case("iepsr", 0x807) 3648 .Case("msp", 0x808) 3649 .Case("psp", 0x809) 3650 .Case("primask", 0x810) 3651 .Case("basepri", 0x811) 3652 .Case("basepri_max", 0x812) 3653 .Case("faultmask", 0x813) 3654 .Case("control", 0x814) 3655 .Default(~0U); 3656 3657 if (FlagsVal == ~0U) 3658 return MatchOperand_NoMatch; 3659 3660 if (!hasV7Ops() && FlagsVal >= 0x811 && FlagsVal <= 0x813) 3661 // basepri, basepri_max and faultmask only valid for V7m. 3662 return MatchOperand_NoMatch; 3663 3664 Parser.Lex(); // Eat identifier token. 3665 Operands.push_back(ARMOperand::CreateMSRMask(FlagsVal, S)); 3666 return MatchOperand_Success; 3667 } 3668 3669 // Split spec_reg from flag, example: CPSR_sxf => "CPSR" and "sxf" 3670 size_t Start = 0, Next = Mask.find('_'); 3671 StringRef Flags = ""; 3672 std::string SpecReg = Mask.slice(Start, Next).lower(); 3673 if (Next != StringRef::npos) 3674 Flags = Mask.slice(Next+1, Mask.size()); 3675 3676 // FlagsVal contains the complete mask: 3677 // 3-0: Mask 3678 // 4: Special Reg (cpsr, apsr => 0; spsr => 1) 3679 unsigned FlagsVal = 0; 3680 3681 if (SpecReg == "apsr") { 3682 FlagsVal = StringSwitch<unsigned>(Flags) 3683 .Case("nzcvq", 0x8) // same as CPSR_f 3684 .Case("g", 0x4) // same as CPSR_s 3685 .Case("nzcvqg", 0xc) // same as CPSR_fs 3686 .Default(~0U); 3687 3688 if (FlagsVal == ~0U) { 3689 if (!Flags.empty()) 3690 return MatchOperand_NoMatch; 3691 else 3692 FlagsVal = 8; // No flag 3693 } 3694 } else if (SpecReg == "cpsr" || SpecReg == "spsr") { 3695 // cpsr_all is an alias for cpsr_fc, as is plain cpsr. 3696 if (Flags == "all" || Flags == "") 3697 Flags = "fc"; 3698 for (int i = 0, e = Flags.size(); i != e; ++i) { 3699 unsigned Flag = StringSwitch<unsigned>(Flags.substr(i, 1)) 3700 .Case("c", 1) 3701 .Case("x", 2) 3702 .Case("s", 4) 3703 .Case("f", 8) 3704 .Default(~0U); 3705 3706 // If some specific flag is already set, it means that some letter is 3707 // present more than once, this is not acceptable. 3708 if (FlagsVal == ~0U || (FlagsVal & Flag)) 3709 return MatchOperand_NoMatch; 3710 FlagsVal |= Flag; 3711 } 3712 } else // No match for special register. 3713 return MatchOperand_NoMatch; 3714 3715 // Special register without flags is NOT equivalent to "fc" flags. 3716 // NOTE: This is a divergence from gas' behavior. Uncommenting the following 3717 // two lines would enable gas compatibility at the expense of breaking 3718 // round-tripping. 3719 // 3720 // if (!FlagsVal) 3721 // FlagsVal = 0x9; 3722 3723 // Bit 4: Special Reg (cpsr, apsr => 0; spsr => 1) 3724 if (SpecReg == "spsr") 3725 FlagsVal |= 16; 3726 3727 Parser.Lex(); // Eat identifier token. 3728 Operands.push_back(ARMOperand::CreateMSRMask(FlagsVal, S)); 3729 return MatchOperand_Success; 3730 } 3731 3732 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 3733 parsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands, StringRef Op, 3734 int Low, int High) { 3735 const AsmToken &Tok = Parser.getTok(); 3736 if (Tok.isNot(AsmToken::Identifier)) { 3737 Error(Parser.getTok().getLoc(), Op + " operand expected."); 3738 return MatchOperand_ParseFail; 3739 } 3740 StringRef ShiftName = Tok.getString(); 3741 std::string LowerOp = Op.lower(); 3742 std::string UpperOp = Op.upper(); 3743 if (ShiftName != LowerOp && ShiftName != UpperOp) { 3744 Error(Parser.getTok().getLoc(), Op + " operand expected."); 3745 return MatchOperand_ParseFail; 3746 } 3747 Parser.Lex(); // Eat shift type token. 3748 3749 // There must be a '#' and a shift amount. 3750 if (Parser.getTok().isNot(AsmToken::Hash) && 3751 Parser.getTok().isNot(AsmToken::Dollar)) { 3752 Error(Parser.getTok().getLoc(), "'#' expected"); 3753 return MatchOperand_ParseFail; 3754 } 3755 Parser.Lex(); // Eat hash token. 3756 3757 const MCExpr *ShiftAmount; 3758 SMLoc Loc = Parser.getTok().getLoc(); 3759 SMLoc EndLoc; 3760 if (getParser().parseExpression(ShiftAmount, EndLoc)) { 3761 Error(Loc, "illegal expression"); 3762 return MatchOperand_ParseFail; 3763 } 3764 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount); 3765 if (!CE) { 3766 Error(Loc, "constant expression expected"); 3767 return MatchOperand_ParseFail; 3768 } 3769 int Val = CE->getValue(); 3770 if (Val < Low || Val > High) { 3771 Error(Loc, "immediate value out of range"); 3772 return MatchOperand_ParseFail; 3773 } 3774 3775 Operands.push_back(ARMOperand::CreateImm(CE, Loc, EndLoc)); 3776 3777 return MatchOperand_Success; 3778 } 3779 3780 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 3781 parseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 3782 const AsmToken &Tok = Parser.getTok(); 3783 SMLoc S = Tok.getLoc(); 3784 if (Tok.isNot(AsmToken::Identifier)) { 3785 Error(S, "'be' or 'le' operand expected"); 3786 return MatchOperand_ParseFail; 3787 } 3788 int Val = StringSwitch<int>(Tok.getString().lower()) 3789 .Case("be", 1) 3790 .Case("le", 0) 3791 .Default(-1); 3792 Parser.Lex(); // Eat the token. 3793 3794 if (Val == -1) { 3795 Error(S, "'be' or 'le' operand expected"); 3796 return MatchOperand_ParseFail; 3797 } 3798 Operands.push_back(ARMOperand::CreateImm(MCConstantExpr::Create(Val, 3799 getContext()), 3800 S, Tok.getEndLoc())); 3801 return MatchOperand_Success; 3802 } 3803 3804 /// parseShifterImm - Parse the shifter immediate operand for SSAT/USAT 3805 /// instructions. Legal values are: 3806 /// lsl #n 'n' in [0,31] 3807 /// asr #n 'n' in [1,32] 3808 /// n == 32 encoded as n == 0. 3809 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 3810 parseShifterImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 3811 const AsmToken &Tok = Parser.getTok(); 3812 SMLoc S = Tok.getLoc(); 3813 if (Tok.isNot(AsmToken::Identifier)) { 3814 Error(S, "shift operator 'asr' or 'lsl' expected"); 3815 return MatchOperand_ParseFail; 3816 } 3817 StringRef ShiftName = Tok.getString(); 3818 bool isASR; 3819 if (ShiftName == "lsl" || ShiftName == "LSL") 3820 isASR = false; 3821 else if (ShiftName == "asr" || ShiftName == "ASR") 3822 isASR = true; 3823 else { 3824 Error(S, "shift operator 'asr' or 'lsl' expected"); 3825 return MatchOperand_ParseFail; 3826 } 3827 Parser.Lex(); // Eat the operator. 3828 3829 // A '#' and a shift amount. 3830 if (Parser.getTok().isNot(AsmToken::Hash) && 3831 Parser.getTok().isNot(AsmToken::Dollar)) { 3832 Error(Parser.getTok().getLoc(), "'#' expected"); 3833 return MatchOperand_ParseFail; 3834 } 3835 Parser.Lex(); // Eat hash token. 3836 SMLoc ExLoc = Parser.getTok().getLoc(); 3837 3838 const MCExpr *ShiftAmount; 3839 SMLoc EndLoc; 3840 if (getParser().parseExpression(ShiftAmount, EndLoc)) { 3841 Error(ExLoc, "malformed shift expression"); 3842 return MatchOperand_ParseFail; 3843 } 3844 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount); 3845 if (!CE) { 3846 Error(ExLoc, "shift amount must be an immediate"); 3847 return MatchOperand_ParseFail; 3848 } 3849 3850 int64_t Val = CE->getValue(); 3851 if (isASR) { 3852 // Shift amount must be in [1,32] 3853 if (Val < 1 || Val > 32) { 3854 Error(ExLoc, "'asr' shift amount must be in range [1,32]"); 3855 return MatchOperand_ParseFail; 3856 } 3857 // asr #32 encoded as asr #0, but is not allowed in Thumb2 mode. 3858 if (isThumb() && Val == 32) { 3859 Error(ExLoc, "'asr #32' shift amount not allowed in Thumb mode"); 3860 return MatchOperand_ParseFail; 3861 } 3862 if (Val == 32) Val = 0; 3863 } else { 3864 // Shift amount must be in [1,32] 3865 if (Val < 0 || Val > 31) { 3866 Error(ExLoc, "'lsr' shift amount must be in range [0,31]"); 3867 return MatchOperand_ParseFail; 3868 } 3869 } 3870 3871 Operands.push_back(ARMOperand::CreateShifterImm(isASR, Val, S, EndLoc)); 3872 3873 return MatchOperand_Success; 3874 } 3875 3876 /// parseRotImm - Parse the shifter immediate operand for SXTB/UXTB family 3877 /// of instructions. Legal values are: 3878 /// ror #n 'n' in {0, 8, 16, 24} 3879 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 3880 parseRotImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 3881 const AsmToken &Tok = Parser.getTok(); 3882 SMLoc S = Tok.getLoc(); 3883 if (Tok.isNot(AsmToken::Identifier)) 3884 return MatchOperand_NoMatch; 3885 StringRef ShiftName = Tok.getString(); 3886 if (ShiftName != "ror" && ShiftName != "ROR") 3887 return MatchOperand_NoMatch; 3888 Parser.Lex(); // Eat the operator. 3889 3890 // A '#' and a rotate amount. 3891 if (Parser.getTok().isNot(AsmToken::Hash) && 3892 Parser.getTok().isNot(AsmToken::Dollar)) { 3893 Error(Parser.getTok().getLoc(), "'#' expected"); 3894 return MatchOperand_ParseFail; 3895 } 3896 Parser.Lex(); // Eat hash token. 3897 SMLoc ExLoc = Parser.getTok().getLoc(); 3898 3899 const MCExpr *ShiftAmount; 3900 SMLoc EndLoc; 3901 if (getParser().parseExpression(ShiftAmount, EndLoc)) { 3902 Error(ExLoc, "malformed rotate expression"); 3903 return MatchOperand_ParseFail; 3904 } 3905 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount); 3906 if (!CE) { 3907 Error(ExLoc, "rotate amount must be an immediate"); 3908 return MatchOperand_ParseFail; 3909 } 3910 3911 int64_t Val = CE->getValue(); 3912 // Shift amount must be in {0, 8, 16, 24} (0 is undocumented extension) 3913 // normally, zero is represented in asm by omitting the rotate operand 3914 // entirely. 3915 if (Val != 8 && Val != 16 && Val != 24 && Val != 0) { 3916 Error(ExLoc, "'ror' rotate amount must be 8, 16, or 24"); 3917 return MatchOperand_ParseFail; 3918 } 3919 3920 Operands.push_back(ARMOperand::CreateRotImm(Val, S, EndLoc)); 3921 3922 return MatchOperand_Success; 3923 } 3924 3925 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 3926 parseBitfield(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 3927 SMLoc S = Parser.getTok().getLoc(); 3928 // The bitfield descriptor is really two operands, the LSB and the width. 3929 if (Parser.getTok().isNot(AsmToken::Hash) && 3930 Parser.getTok().isNot(AsmToken::Dollar)) { 3931 Error(Parser.getTok().getLoc(), "'#' expected"); 3932 return MatchOperand_ParseFail; 3933 } 3934 Parser.Lex(); // Eat hash token. 3935 3936 const MCExpr *LSBExpr; 3937 SMLoc E = Parser.getTok().getLoc(); 3938 if (getParser().parseExpression(LSBExpr)) { 3939 Error(E, "malformed immediate expression"); 3940 return MatchOperand_ParseFail; 3941 } 3942 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(LSBExpr); 3943 if (!CE) { 3944 Error(E, "'lsb' operand must be an immediate"); 3945 return MatchOperand_ParseFail; 3946 } 3947 3948 int64_t LSB = CE->getValue(); 3949 // The LSB must be in the range [0,31] 3950 if (LSB < 0 || LSB > 31) { 3951 Error(E, "'lsb' operand must be in the range [0,31]"); 3952 return MatchOperand_ParseFail; 3953 } 3954 E = Parser.getTok().getLoc(); 3955 3956 // Expect another immediate operand. 3957 if (Parser.getTok().isNot(AsmToken::Comma)) { 3958 Error(Parser.getTok().getLoc(), "too few operands"); 3959 return MatchOperand_ParseFail; 3960 } 3961 Parser.Lex(); // Eat hash token. 3962 if (Parser.getTok().isNot(AsmToken::Hash) && 3963 Parser.getTok().isNot(AsmToken::Dollar)) { 3964 Error(Parser.getTok().getLoc(), "'#' expected"); 3965 return MatchOperand_ParseFail; 3966 } 3967 Parser.Lex(); // Eat hash token. 3968 3969 const MCExpr *WidthExpr; 3970 SMLoc EndLoc; 3971 if (getParser().parseExpression(WidthExpr, EndLoc)) { 3972 Error(E, "malformed immediate expression"); 3973 return MatchOperand_ParseFail; 3974 } 3975 CE = dyn_cast<MCConstantExpr>(WidthExpr); 3976 if (!CE) { 3977 Error(E, "'width' operand must be an immediate"); 3978 return MatchOperand_ParseFail; 3979 } 3980 3981 int64_t Width = CE->getValue(); 3982 // The LSB must be in the range [1,32-lsb] 3983 if (Width < 1 || Width > 32 - LSB) { 3984 Error(E, "'width' operand must be in the range [1,32-lsb]"); 3985 return MatchOperand_ParseFail; 3986 } 3987 3988 Operands.push_back(ARMOperand::CreateBitfield(LSB, Width, S, EndLoc)); 3989 3990 return MatchOperand_Success; 3991 } 3992 3993 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 3994 parsePostIdxReg(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 3995 // Check for a post-index addressing register operand. Specifically: 3996 // postidx_reg := '+' register {, shift} 3997 // | '-' register {, shift} 3998 // | register {, shift} 3999 4000 // This method must return MatchOperand_NoMatch without consuming any tokens 4001 // in the case where there is no match, as other alternatives take other 4002 // parse methods. 4003 AsmToken Tok = Parser.getTok(); 4004 SMLoc S = Tok.getLoc(); 4005 bool haveEaten = false; 4006 bool isAdd = true; 4007 if (Tok.is(AsmToken::Plus)) { 4008 Parser.Lex(); // Eat the '+' token. 4009 haveEaten = true; 4010 } else if (Tok.is(AsmToken::Minus)) { 4011 Parser.Lex(); // Eat the '-' token. 4012 isAdd = false; 4013 haveEaten = true; 4014 } 4015 4016 SMLoc E = Parser.getTok().getEndLoc(); 4017 int Reg = tryParseRegister(); 4018 if (Reg == -1) { 4019 if (!haveEaten) 4020 return MatchOperand_NoMatch; 4021 Error(Parser.getTok().getLoc(), "register expected"); 4022 return MatchOperand_ParseFail; 4023 } 4024 4025 ARM_AM::ShiftOpc ShiftTy = ARM_AM::no_shift; 4026 unsigned ShiftImm = 0; 4027 if (Parser.getTok().is(AsmToken::Comma)) { 4028 Parser.Lex(); // Eat the ','. 4029 if (parseMemRegOffsetShift(ShiftTy, ShiftImm)) 4030 return MatchOperand_ParseFail; 4031 4032 // FIXME: Only approximates end...may include intervening whitespace. 4033 E = Parser.getTok().getLoc(); 4034 } 4035 4036 Operands.push_back(ARMOperand::CreatePostIdxReg(Reg, isAdd, ShiftTy, 4037 ShiftImm, S, E)); 4038 4039 return MatchOperand_Success; 4040 } 4041 4042 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 4043 parseAM3Offset(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 4044 // Check for a post-index addressing register operand. Specifically: 4045 // am3offset := '+' register 4046 // | '-' register 4047 // | register 4048 // | # imm 4049 // | # + imm 4050 // | # - imm 4051 4052 // This method must return MatchOperand_NoMatch without consuming any tokens 4053 // in the case where there is no match, as other alternatives take other 4054 // parse methods. 4055 AsmToken Tok = Parser.getTok(); 4056 SMLoc S = Tok.getLoc(); 4057 4058 // Do immediates first, as we always parse those if we have a '#'. 4059 if (Parser.getTok().is(AsmToken::Hash) || 4060 Parser.getTok().is(AsmToken::Dollar)) { 4061 Parser.Lex(); // Eat '#' or '$'. 4062 // Explicitly look for a '-', as we need to encode negative zero 4063 // differently. 4064 bool isNegative = Parser.getTok().is(AsmToken::Minus); 4065 const MCExpr *Offset; 4066 SMLoc E; 4067 if (getParser().parseExpression(Offset, E)) 4068 return MatchOperand_ParseFail; 4069 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Offset); 4070 if (!CE) { 4071 Error(S, "constant expression expected"); 4072 return MatchOperand_ParseFail; 4073 } 4074 // Negative zero is encoded as the flag value INT32_MIN. 4075 int32_t Val = CE->getValue(); 4076 if (isNegative && Val == 0) 4077 Val = INT32_MIN; 4078 4079 Operands.push_back( 4080 ARMOperand::CreateImm(MCConstantExpr::Create(Val, getContext()), S, E)); 4081 4082 return MatchOperand_Success; 4083 } 4084 4085 4086 bool haveEaten = false; 4087 bool isAdd = true; 4088 if (Tok.is(AsmToken::Plus)) { 4089 Parser.Lex(); // Eat the '+' token. 4090 haveEaten = true; 4091 } else if (Tok.is(AsmToken::Minus)) { 4092 Parser.Lex(); // Eat the '-' token. 4093 isAdd = false; 4094 haveEaten = true; 4095 } 4096 4097 Tok = Parser.getTok(); 4098 int Reg = tryParseRegister(); 4099 if (Reg == -1) { 4100 if (!haveEaten) 4101 return MatchOperand_NoMatch; 4102 Error(Tok.getLoc(), "register expected"); 4103 return MatchOperand_ParseFail; 4104 } 4105 4106 Operands.push_back(ARMOperand::CreatePostIdxReg(Reg, isAdd, ARM_AM::no_shift, 4107 0, S, Tok.getEndLoc())); 4108 4109 return MatchOperand_Success; 4110 } 4111 4112 /// Convert parsed operands to MCInst. Needed here because this instruction 4113 /// only has two register operands, but multiplication is commutative so 4114 /// assemblers should accept both "mul rD, rN, rD" and "mul rD, rD, rN". 4115 void ARMAsmParser:: 4116 cvtThumbMultiply(MCInst &Inst, 4117 const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 4118 ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1); 4119 ((ARMOperand*)Operands[1])->addCCOutOperands(Inst, 1); 4120 // If we have a three-operand form, make sure to set Rn to be the operand 4121 // that isn't the same as Rd. 4122 unsigned RegOp = 4; 4123 if (Operands.size() == 6 && 4124 ((ARMOperand*)Operands[4])->getReg() == 4125 ((ARMOperand*)Operands[3])->getReg()) 4126 RegOp = 5; 4127 ((ARMOperand*)Operands[RegOp])->addRegOperands(Inst, 1); 4128 Inst.addOperand(Inst.getOperand(0)); 4129 ((ARMOperand*)Operands[2])->addCondCodeOperands(Inst, 2); 4130 } 4131 4132 void ARMAsmParser:: 4133 cvtThumbBranches(MCInst &Inst, 4134 const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 4135 int CondOp = -1, ImmOp = -1; 4136 switch(Inst.getOpcode()) { 4137 case ARM::tB: 4138 case ARM::tBcc: CondOp = 1; ImmOp = 2; break; 4139 4140 case ARM::t2B: 4141 case ARM::t2Bcc: CondOp = 1; ImmOp = 3; break; 4142 4143 default: llvm_unreachable("Unexpected instruction in cvtThumbBranches"); 4144 } 4145 // first decide whether or not the branch should be conditional 4146 // by looking at it's location relative to an IT block 4147 if(inITBlock()) { 4148 // inside an IT block we cannot have any conditional branches. any 4149 // such instructions needs to be converted to unconditional form 4150 switch(Inst.getOpcode()) { 4151 case ARM::tBcc: Inst.setOpcode(ARM::tB); break; 4152 case ARM::t2Bcc: Inst.setOpcode(ARM::t2B); break; 4153 } 4154 } else { 4155 // outside IT blocks we can only have unconditional branches with AL 4156 // condition code or conditional branches with non-AL condition code 4157 unsigned Cond = static_cast<ARMOperand*>(Operands[CondOp])->getCondCode(); 4158 switch(Inst.getOpcode()) { 4159 case ARM::tB: 4160 case ARM::tBcc: 4161 Inst.setOpcode(Cond == ARMCC::AL ? ARM::tB : ARM::tBcc); 4162 break; 4163 case ARM::t2B: 4164 case ARM::t2Bcc: 4165 Inst.setOpcode(Cond == ARMCC::AL ? ARM::t2B : ARM::t2Bcc); 4166 break; 4167 } 4168 } 4169 4170 // now decide on encoding size based on branch target range 4171 switch(Inst.getOpcode()) { 4172 // classify tB as either t2B or t1B based on range of immediate operand 4173 case ARM::tB: { 4174 ARMOperand* op = static_cast<ARMOperand*>(Operands[ImmOp]); 4175 if(!op->isSignedOffset<11, 1>() && isThumbTwo()) 4176 Inst.setOpcode(ARM::t2B); 4177 break; 4178 } 4179 // classify tBcc as either t2Bcc or t1Bcc based on range of immediate operand 4180 case ARM::tBcc: { 4181 ARMOperand* op = static_cast<ARMOperand*>(Operands[ImmOp]); 4182 if(!op->isSignedOffset<8, 1>() && isThumbTwo()) 4183 Inst.setOpcode(ARM::t2Bcc); 4184 break; 4185 } 4186 } 4187 ((ARMOperand*)Operands[ImmOp])->addImmOperands(Inst, 1); 4188 ((ARMOperand*)Operands[CondOp])->addCondCodeOperands(Inst, 2); 4189 } 4190 4191 /// Parse an ARM memory expression, return false if successful else return true 4192 /// or an error. The first token must be a '[' when called. 4193 bool ARMAsmParser:: 4194 parseMemory(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 4195 SMLoc S, E; 4196 assert(Parser.getTok().is(AsmToken::LBrac) && 4197 "Token is not a Left Bracket"); 4198 S = Parser.getTok().getLoc(); 4199 Parser.Lex(); // Eat left bracket token. 4200 4201 const AsmToken &BaseRegTok = Parser.getTok(); 4202 int BaseRegNum = tryParseRegister(); 4203 if (BaseRegNum == -1) 4204 return Error(BaseRegTok.getLoc(), "register expected"); 4205 4206 // The next token must either be a comma, a colon or a closing bracket. 4207 const AsmToken &Tok = Parser.getTok(); 4208 if (!Tok.is(AsmToken::Colon) && !Tok.is(AsmToken::Comma) && 4209 !Tok.is(AsmToken::RBrac)) 4210 return Error(Tok.getLoc(), "malformed memory operand"); 4211 4212 if (Tok.is(AsmToken::RBrac)) { 4213 E = Tok.getEndLoc(); 4214 Parser.Lex(); // Eat right bracket token. 4215 4216 Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, 0, ARM_AM::no_shift, 4217 0, 0, false, S, E)); 4218 4219 // If there's a pre-indexing writeback marker, '!', just add it as a token 4220 // operand. It's rather odd, but syntactically valid. 4221 if (Parser.getTok().is(AsmToken::Exclaim)) { 4222 Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc())); 4223 Parser.Lex(); // Eat the '!'. 4224 } 4225 4226 return false; 4227 } 4228 4229 assert((Tok.is(AsmToken::Colon) || Tok.is(AsmToken::Comma)) && 4230 "Lost colon or comma in memory operand?!"); 4231 if (Tok.is(AsmToken::Comma)) { 4232 Parser.Lex(); // Eat the comma. 4233 } 4234 4235 // If we have a ':', it's an alignment specifier. 4236 if (Parser.getTok().is(AsmToken::Colon)) { 4237 Parser.Lex(); // Eat the ':'. 4238 E = Parser.getTok().getLoc(); 4239 4240 const MCExpr *Expr; 4241 if (getParser().parseExpression(Expr)) 4242 return true; 4243 4244 // The expression has to be a constant. Memory references with relocations 4245 // don't come through here, as they use the <label> forms of the relevant 4246 // instructions. 4247 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr); 4248 if (!CE) 4249 return Error (E, "constant expression expected"); 4250 4251 unsigned Align = 0; 4252 switch (CE->getValue()) { 4253 default: 4254 return Error(E, 4255 "alignment specifier must be 16, 32, 64, 128, or 256 bits"); 4256 case 16: Align = 2; break; 4257 case 32: Align = 4; break; 4258 case 64: Align = 8; break; 4259 case 128: Align = 16; break; 4260 case 256: Align = 32; break; 4261 } 4262 4263 // Now we should have the closing ']' 4264 if (Parser.getTok().isNot(AsmToken::RBrac)) 4265 return Error(Parser.getTok().getLoc(), "']' expected"); 4266 E = Parser.getTok().getEndLoc(); 4267 Parser.Lex(); // Eat right bracket token. 4268 4269 // Don't worry about range checking the value here. That's handled by 4270 // the is*() predicates. 4271 Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, 0, 4272 ARM_AM::no_shift, 0, Align, 4273 false, S, E)); 4274 4275 // If there's a pre-indexing writeback marker, '!', just add it as a token 4276 // operand. 4277 if (Parser.getTok().is(AsmToken::Exclaim)) { 4278 Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc())); 4279 Parser.Lex(); // Eat the '!'. 4280 } 4281 4282 return false; 4283 } 4284 4285 // If we have a '#', it's an immediate offset, else assume it's a register 4286 // offset. Be friendly and also accept a plain integer (without a leading 4287 // hash) for gas compatibility. 4288 if (Parser.getTok().is(AsmToken::Hash) || 4289 Parser.getTok().is(AsmToken::Dollar) || 4290 Parser.getTok().is(AsmToken::Integer)) { 4291 if (Parser.getTok().isNot(AsmToken::Integer)) 4292 Parser.Lex(); // Eat '#' or '$'. 4293 E = Parser.getTok().getLoc(); 4294 4295 bool isNegative = getParser().getTok().is(AsmToken::Minus); 4296 const MCExpr *Offset; 4297 if (getParser().parseExpression(Offset)) 4298 return true; 4299 4300 // The expression has to be a constant. Memory references with relocations 4301 // don't come through here, as they use the <label> forms of the relevant 4302 // instructions. 4303 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Offset); 4304 if (!CE) 4305 return Error (E, "constant expression expected"); 4306 4307 // If the constant was #-0, represent it as INT32_MIN. 4308 int32_t Val = CE->getValue(); 4309 if (isNegative && Val == 0) 4310 CE = MCConstantExpr::Create(INT32_MIN, getContext()); 4311 4312 // Now we should have the closing ']' 4313 if (Parser.getTok().isNot(AsmToken::RBrac)) 4314 return Error(Parser.getTok().getLoc(), "']' expected"); 4315 E = Parser.getTok().getEndLoc(); 4316 Parser.Lex(); // Eat right bracket token. 4317 4318 // Don't worry about range checking the value here. That's handled by 4319 // the is*() predicates. 4320 Operands.push_back(ARMOperand::CreateMem(BaseRegNum, CE, 0, 4321 ARM_AM::no_shift, 0, 0, 4322 false, S, E)); 4323 4324 // If there's a pre-indexing writeback marker, '!', just add it as a token 4325 // operand. 4326 if (Parser.getTok().is(AsmToken::Exclaim)) { 4327 Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc())); 4328 Parser.Lex(); // Eat the '!'. 4329 } 4330 4331 return false; 4332 } 4333 4334 // The register offset is optionally preceded by a '+' or '-' 4335 bool isNegative = false; 4336 if (Parser.getTok().is(AsmToken::Minus)) { 4337 isNegative = true; 4338 Parser.Lex(); // Eat the '-'. 4339 } else if (Parser.getTok().is(AsmToken::Plus)) { 4340 // Nothing to do. 4341 Parser.Lex(); // Eat the '+'. 4342 } 4343 4344 E = Parser.getTok().getLoc(); 4345 int OffsetRegNum = tryParseRegister(); 4346 if (OffsetRegNum == -1) 4347 return Error(E, "register expected"); 4348 4349 // If there's a shift operator, handle it. 4350 ARM_AM::ShiftOpc ShiftType = ARM_AM::no_shift; 4351 unsigned ShiftImm = 0; 4352 if (Parser.getTok().is(AsmToken::Comma)) { 4353 Parser.Lex(); // Eat the ','. 4354 if (parseMemRegOffsetShift(ShiftType, ShiftImm)) 4355 return true; 4356 } 4357 4358 // Now we should have the closing ']' 4359 if (Parser.getTok().isNot(AsmToken::RBrac)) 4360 return Error(Parser.getTok().getLoc(), "']' expected"); 4361 E = Parser.getTok().getEndLoc(); 4362 Parser.Lex(); // Eat right bracket token. 4363 4364 Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, OffsetRegNum, 4365 ShiftType, ShiftImm, 0, isNegative, 4366 S, E)); 4367 4368 // If there's a pre-indexing writeback marker, '!', just add it as a token 4369 // operand. 4370 if (Parser.getTok().is(AsmToken::Exclaim)) { 4371 Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc())); 4372 Parser.Lex(); // Eat the '!'. 4373 } 4374 4375 return false; 4376 } 4377 4378 /// parseMemRegOffsetShift - one of these two: 4379 /// ( lsl | lsr | asr | ror ) , # shift_amount 4380 /// rrx 4381 /// return true if it parses a shift otherwise it returns false. 4382 bool ARMAsmParser::parseMemRegOffsetShift(ARM_AM::ShiftOpc &St, 4383 unsigned &Amount) { 4384 SMLoc Loc = Parser.getTok().getLoc(); 4385 const AsmToken &Tok = Parser.getTok(); 4386 if (Tok.isNot(AsmToken::Identifier)) 4387 return true; 4388 StringRef ShiftName = Tok.getString(); 4389 if (ShiftName == "lsl" || ShiftName == "LSL" || 4390 ShiftName == "asl" || ShiftName == "ASL") 4391 St = ARM_AM::lsl; 4392 else if (ShiftName == "lsr" || ShiftName == "LSR") 4393 St = ARM_AM::lsr; 4394 else if (ShiftName == "asr" || ShiftName == "ASR") 4395 St = ARM_AM::asr; 4396 else if (ShiftName == "ror" || ShiftName == "ROR") 4397 St = ARM_AM::ror; 4398 else if (ShiftName == "rrx" || ShiftName == "RRX") 4399 St = ARM_AM::rrx; 4400 else 4401 return Error(Loc, "illegal shift operator"); 4402 Parser.Lex(); // Eat shift type token. 4403 4404 // rrx stands alone. 4405 Amount = 0; 4406 if (St != ARM_AM::rrx) { 4407 Loc = Parser.getTok().getLoc(); 4408 // A '#' and a shift amount. 4409 const AsmToken &HashTok = Parser.getTok(); 4410 if (HashTok.isNot(AsmToken::Hash) && 4411 HashTok.isNot(AsmToken::Dollar)) 4412 return Error(HashTok.getLoc(), "'#' expected"); 4413 Parser.Lex(); // Eat hash token. 4414 4415 const MCExpr *Expr; 4416 if (getParser().parseExpression(Expr)) 4417 return true; 4418 // Range check the immediate. 4419 // lsl, ror: 0 <= imm <= 31 4420 // lsr, asr: 0 <= imm <= 32 4421 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr); 4422 if (!CE) 4423 return Error(Loc, "shift amount must be an immediate"); 4424 int64_t Imm = CE->getValue(); 4425 if (Imm < 0 || 4426 ((St == ARM_AM::lsl || St == ARM_AM::ror) && Imm > 31) || 4427 ((St == ARM_AM::lsr || St == ARM_AM::asr) && Imm > 32)) 4428 return Error(Loc, "immediate shift value out of range"); 4429 // If <ShiftTy> #0, turn it into a no_shift. 4430 if (Imm == 0) 4431 St = ARM_AM::lsl; 4432 // For consistency, treat lsr #32 and asr #32 as having immediate value 0. 4433 if (Imm == 32) 4434 Imm = 0; 4435 Amount = Imm; 4436 } 4437 4438 return false; 4439 } 4440 4441 /// parseFPImm - A floating point immediate expression operand. 4442 ARMAsmParser::OperandMatchResultTy ARMAsmParser:: 4443 parseFPImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 4444 // Anything that can accept a floating point constant as an operand 4445 // needs to go through here, as the regular parseExpression is 4446 // integer only. 4447 // 4448 // This routine still creates a generic Immediate operand, containing 4449 // a bitcast of the 64-bit floating point value. The various operands 4450 // that accept floats can check whether the value is valid for them 4451 // via the standard is*() predicates. 4452 4453 SMLoc S = Parser.getTok().getLoc(); 4454 4455 if (Parser.getTok().isNot(AsmToken::Hash) && 4456 Parser.getTok().isNot(AsmToken::Dollar)) 4457 return MatchOperand_NoMatch; 4458 4459 // Disambiguate the VMOV forms that can accept an FP immediate. 4460 // vmov.f32 <sreg>, #imm 4461 // vmov.f64 <dreg>, #imm 4462 // vmov.f32 <dreg>, #imm @ vector f32x2 4463 // vmov.f32 <qreg>, #imm @ vector f32x4 4464 // 4465 // There are also the NEON VMOV instructions which expect an 4466 // integer constant. Make sure we don't try to parse an FPImm 4467 // for these: 4468 // vmov.i{8|16|32|64} <dreg|qreg>, #imm 4469 ARMOperand *TyOp = static_cast<ARMOperand*>(Operands[2]); 4470 if (!TyOp->isToken() || (TyOp->getToken() != ".f32" && 4471 TyOp->getToken() != ".f64")) 4472 return MatchOperand_NoMatch; 4473 4474 Parser.Lex(); // Eat '#' or '$'. 4475 4476 // Handle negation, as that still comes through as a separate token. 4477 bool isNegative = false; 4478 if (Parser.getTok().is(AsmToken::Minus)) { 4479 isNegative = true; 4480 Parser.Lex(); 4481 } 4482 const AsmToken &Tok = Parser.getTok(); 4483 SMLoc Loc = Tok.getLoc(); 4484 if (Tok.is(AsmToken::Real)) { 4485 APFloat RealVal(APFloat::IEEEsingle, Tok.getString()); 4486 uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue(); 4487 // If we had a '-' in front, toggle the sign bit. 4488 IntVal ^= (uint64_t)isNegative << 31; 4489 Parser.Lex(); // Eat the token. 4490 Operands.push_back(ARMOperand::CreateImm( 4491 MCConstantExpr::Create(IntVal, getContext()), 4492 S, Parser.getTok().getLoc())); 4493 return MatchOperand_Success; 4494 } 4495 // Also handle plain integers. Instructions which allow floating point 4496 // immediates also allow a raw encoded 8-bit value. 4497 if (Tok.is(AsmToken::Integer)) { 4498 int64_t Val = Tok.getIntVal(); 4499 Parser.Lex(); // Eat the token. 4500 if (Val > 255 || Val < 0) { 4501 Error(Loc, "encoded floating point value out of range"); 4502 return MatchOperand_ParseFail; 4503 } 4504 double RealVal = ARM_AM::getFPImmFloat(Val); 4505 Val = APFloat(APFloat::IEEEdouble, RealVal).bitcastToAPInt().getZExtValue(); 4506 Operands.push_back(ARMOperand::CreateImm( 4507 MCConstantExpr::Create(Val, getContext()), S, 4508 Parser.getTok().getLoc())); 4509 return MatchOperand_Success; 4510 } 4511 4512 Error(Loc, "invalid floating point immediate"); 4513 return MatchOperand_ParseFail; 4514 } 4515 4516 /// Parse a arm instruction operand. For now this parses the operand regardless 4517 /// of the mnemonic. 4518 bool ARMAsmParser::parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands, 4519 StringRef Mnemonic) { 4520 SMLoc S, E; 4521 4522 // Check if the current operand has a custom associated parser, if so, try to 4523 // custom parse the operand, or fallback to the general approach. 4524 OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic); 4525 if (ResTy == MatchOperand_Success) 4526 return false; 4527 // If there wasn't a custom match, try the generic matcher below. Otherwise, 4528 // there was a match, but an error occurred, in which case, just return that 4529 // the operand parsing failed. 4530 if (ResTy == MatchOperand_ParseFail) 4531 return true; 4532 4533 switch (getLexer().getKind()) { 4534 default: 4535 Error(Parser.getTok().getLoc(), "unexpected token in operand"); 4536 return true; 4537 case AsmToken::Identifier: { 4538 // If we've seen a branch mnemonic, the next operand must be a label. This 4539 // is true even if the label is a register name. So "br r1" means branch to 4540 // label "r1". 4541 bool ExpectLabel = Mnemonic == "b" || Mnemonic == "bl"; 4542 if (!ExpectLabel) { 4543 if (!tryParseRegisterWithWriteBack(Operands)) 4544 return false; 4545 int Res = tryParseShiftRegister(Operands); 4546 if (Res == 0) // success 4547 return false; 4548 else if (Res == -1) // irrecoverable error 4549 return true; 4550 // If this is VMRS, check for the apsr_nzcv operand. 4551 if (Mnemonic == "vmrs" && 4552 Parser.getTok().getString().equals_lower("apsr_nzcv")) { 4553 S = Parser.getTok().getLoc(); 4554 Parser.Lex(); 4555 Operands.push_back(ARMOperand::CreateToken("APSR_nzcv", S)); 4556 return false; 4557 } 4558 } 4559 4560 // Fall though for the Identifier case that is not a register or a 4561 // special name. 4562 } 4563 case AsmToken::LParen: // parenthesized expressions like (_strcmp-4) 4564 case AsmToken::Integer: // things like 1f and 2b as a branch targets 4565 case AsmToken::String: // quoted label names. 4566 case AsmToken::Dot: { // . as a branch target 4567 // This was not a register so parse other operands that start with an 4568 // identifier (like labels) as expressions and create them as immediates. 4569 const MCExpr *IdVal; 4570 S = Parser.getTok().getLoc(); 4571 if (getParser().parseExpression(IdVal)) 4572 return true; 4573 E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 4574 Operands.push_back(ARMOperand::CreateImm(IdVal, S, E)); 4575 return false; 4576 } 4577 case AsmToken::LBrac: 4578 return parseMemory(Operands); 4579 case AsmToken::LCurly: 4580 return parseRegisterList(Operands); 4581 case AsmToken::Dollar: 4582 case AsmToken::Hash: { 4583 // #42 -> immediate. 4584 S = Parser.getTok().getLoc(); 4585 Parser.Lex(); 4586 4587 if (Parser.getTok().isNot(AsmToken::Colon)) { 4588 bool isNegative = Parser.getTok().is(AsmToken::Minus); 4589 const MCExpr *ImmVal; 4590 if (getParser().parseExpression(ImmVal)) 4591 return true; 4592 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ImmVal); 4593 if (CE) { 4594 int32_t Val = CE->getValue(); 4595 if (isNegative && Val == 0) 4596 ImmVal = MCConstantExpr::Create(INT32_MIN, getContext()); 4597 } 4598 E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 4599 Operands.push_back(ARMOperand::CreateImm(ImmVal, S, E)); 4600 4601 // There can be a trailing '!' on operands that we want as a separate 4602 // '!' Token operand. Handle that here. For example, the compatibilty 4603 // alias for 'srsdb sp!, #imm' is 'srsdb #imm!'. 4604 if (Parser.getTok().is(AsmToken::Exclaim)) { 4605 Operands.push_back(ARMOperand::CreateToken(Parser.getTok().getString(), 4606 Parser.getTok().getLoc())); 4607 Parser.Lex(); // Eat exclaim token 4608 } 4609 return false; 4610 } 4611 // w/ a ':' after the '#', it's just like a plain ':'. 4612 // FALLTHROUGH 4613 } 4614 case AsmToken::Colon: { 4615 // ":lower16:" and ":upper16:" expression prefixes 4616 // FIXME: Check it's an expression prefix, 4617 // e.g. (FOO - :lower16:BAR) isn't legal. 4618 ARMMCExpr::VariantKind RefKind; 4619 if (parsePrefix(RefKind)) 4620 return true; 4621 4622 const MCExpr *SubExprVal; 4623 if (getParser().parseExpression(SubExprVal)) 4624 return true; 4625 4626 const MCExpr *ExprVal = ARMMCExpr::Create(RefKind, SubExprVal, 4627 getContext()); 4628 E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 4629 Operands.push_back(ARMOperand::CreateImm(ExprVal, S, E)); 4630 return false; 4631 } 4632 } 4633 } 4634 4635 // parsePrefix - Parse ARM 16-bit relocations expression prefix, i.e. 4636 // :lower16: and :upper16:. 4637 bool ARMAsmParser::parsePrefix(ARMMCExpr::VariantKind &RefKind) { 4638 RefKind = ARMMCExpr::VK_ARM_None; 4639 4640 // :lower16: and :upper16: modifiers 4641 assert(getLexer().is(AsmToken::Colon) && "expected a :"); 4642 Parser.Lex(); // Eat ':' 4643 4644 if (getLexer().isNot(AsmToken::Identifier)) { 4645 Error(Parser.getTok().getLoc(), "expected prefix identifier in operand"); 4646 return true; 4647 } 4648 4649 StringRef IDVal = Parser.getTok().getIdentifier(); 4650 if (IDVal == "lower16") { 4651 RefKind = ARMMCExpr::VK_ARM_LO16; 4652 } else if (IDVal == "upper16") { 4653 RefKind = ARMMCExpr::VK_ARM_HI16; 4654 } else { 4655 Error(Parser.getTok().getLoc(), "unexpected prefix in operand"); 4656 return true; 4657 } 4658 Parser.Lex(); 4659 4660 if (getLexer().isNot(AsmToken::Colon)) { 4661 Error(Parser.getTok().getLoc(), "unexpected token after prefix"); 4662 return true; 4663 } 4664 Parser.Lex(); // Eat the last ':' 4665 return false; 4666 } 4667 4668 /// \brief Given a mnemonic, split out possible predication code and carry 4669 /// setting letters to form a canonical mnemonic and flags. 4670 // 4671 // FIXME: Would be nice to autogen this. 4672 // FIXME: This is a bit of a maze of special cases. 4673 StringRef ARMAsmParser::splitMnemonic(StringRef Mnemonic, 4674 unsigned &PredicationCode, 4675 bool &CarrySetting, 4676 unsigned &ProcessorIMod, 4677 StringRef &ITMask) { 4678 PredicationCode = ARMCC::AL; 4679 CarrySetting = false; 4680 ProcessorIMod = 0; 4681 4682 // Ignore some mnemonics we know aren't predicated forms. 4683 // 4684 // FIXME: Would be nice to autogen this. 4685 if ((Mnemonic == "movs" && isThumb()) || 4686 Mnemonic == "teq" || Mnemonic == "vceq" || Mnemonic == "svc" || 4687 Mnemonic == "mls" || Mnemonic == "smmls" || Mnemonic == "vcls" || 4688 Mnemonic == "vmls" || Mnemonic == "vnmls" || Mnemonic == "vacge" || 4689 Mnemonic == "vcge" || Mnemonic == "vclt" || Mnemonic == "vacgt" || 4690 Mnemonic == "vaclt" || Mnemonic == "vacle" || 4691 Mnemonic == "vcgt" || Mnemonic == "vcle" || Mnemonic == "smlal" || 4692 Mnemonic == "umaal" || Mnemonic == "umlal" || Mnemonic == "vabal" || 4693 Mnemonic == "vmlal" || Mnemonic == "vpadal" || Mnemonic == "vqdmlal" || 4694 Mnemonic == "fmuls" || Mnemonic == "vmaxnm" || Mnemonic == "vminnm" || 4695 Mnemonic == "vcvta" || Mnemonic == "vcvtn" || Mnemonic == "vcvtp" || 4696 Mnemonic == "vcvtm" || Mnemonic == "vrinta" || Mnemonic == "vrintn" || 4697 Mnemonic == "vrintp" || Mnemonic == "vrintm" || Mnemonic.startswith("vsel")) 4698 return Mnemonic; 4699 4700 // First, split out any predication code. Ignore mnemonics we know aren't 4701 // predicated but do have a carry-set and so weren't caught above. 4702 if (Mnemonic != "adcs" && Mnemonic != "bics" && Mnemonic != "movs" && 4703 Mnemonic != "muls" && Mnemonic != "smlals" && Mnemonic != "smulls" && 4704 Mnemonic != "umlals" && Mnemonic != "umulls" && Mnemonic != "lsls" && 4705 Mnemonic != "sbcs" && Mnemonic != "rscs") { 4706 unsigned CC = StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2)) 4707 .Case("eq", ARMCC::EQ) 4708 .Case("ne", ARMCC::NE) 4709 .Case("hs", ARMCC::HS) 4710 .Case("cs", ARMCC::HS) 4711 .Case("lo", ARMCC::LO) 4712 .Case("cc", ARMCC::LO) 4713 .Case("mi", ARMCC::MI) 4714 .Case("pl", ARMCC::PL) 4715 .Case("vs", ARMCC::VS) 4716 .Case("vc", ARMCC::VC) 4717 .Case("hi", ARMCC::HI) 4718 .Case("ls", ARMCC::LS) 4719 .Case("ge", ARMCC::GE) 4720 .Case("lt", ARMCC::LT) 4721 .Case("gt", ARMCC::GT) 4722 .Case("le", ARMCC::LE) 4723 .Case("al", ARMCC::AL) 4724 .Default(~0U); 4725 if (CC != ~0U) { 4726 Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 2); 4727 PredicationCode = CC; 4728 } 4729 } 4730 4731 // Next, determine if we have a carry setting bit. We explicitly ignore all 4732 // the instructions we know end in 's'. 4733 if (Mnemonic.endswith("s") && 4734 !(Mnemonic == "cps" || Mnemonic == "mls" || 4735 Mnemonic == "mrs" || Mnemonic == "smmls" || Mnemonic == "vabs" || 4736 Mnemonic == "vcls" || Mnemonic == "vmls" || Mnemonic == "vmrs" || 4737 Mnemonic == "vnmls" || Mnemonic == "vqabs" || Mnemonic == "vrecps" || 4738 Mnemonic == "vrsqrts" || Mnemonic == "srs" || Mnemonic == "flds" || 4739 Mnemonic == "fmrs" || Mnemonic == "fsqrts" || Mnemonic == "fsubs" || 4740 Mnemonic == "fsts" || Mnemonic == "fcpys" || Mnemonic == "fdivs" || 4741 Mnemonic == "fmuls" || Mnemonic == "fcmps" || Mnemonic == "fcmpzs" || 4742 Mnemonic == "vfms" || Mnemonic == "vfnms" || 4743 (Mnemonic == "movs" && isThumb()))) { 4744 Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 1); 4745 CarrySetting = true; 4746 } 4747 4748 // The "cps" instruction can have a interrupt mode operand which is glued into 4749 // the mnemonic. Check if this is the case, split it and parse the imod op 4750 if (Mnemonic.startswith("cps")) { 4751 // Split out any imod code. 4752 unsigned IMod = 4753 StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2, 2)) 4754 .Case("ie", ARM_PROC::IE) 4755 .Case("id", ARM_PROC::ID) 4756 .Default(~0U); 4757 if (IMod != ~0U) { 4758 Mnemonic = Mnemonic.slice(0, Mnemonic.size()-2); 4759 ProcessorIMod = IMod; 4760 } 4761 } 4762 4763 // The "it" instruction has the condition mask on the end of the mnemonic. 4764 if (Mnemonic.startswith("it")) { 4765 ITMask = Mnemonic.slice(2, Mnemonic.size()); 4766 Mnemonic = Mnemonic.slice(0, 2); 4767 } 4768 4769 return Mnemonic; 4770 } 4771 4772 /// \brief Given a canonical mnemonic, determine if the instruction ever allows 4773 /// inclusion of carry set or predication code operands. 4774 // 4775 // FIXME: It would be nice to autogen this. 4776 void ARMAsmParser:: 4777 getMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet, 4778 bool &CanAcceptPredicationCode) { 4779 if (Mnemonic == "and" || Mnemonic == "lsl" || Mnemonic == "lsr" || 4780 Mnemonic == "rrx" || Mnemonic == "ror" || Mnemonic == "sub" || 4781 Mnemonic == "add" || Mnemonic == "adc" || 4782 Mnemonic == "mul" || Mnemonic == "bic" || Mnemonic == "asr" || 4783 Mnemonic == "orr" || Mnemonic == "mvn" || 4784 Mnemonic == "rsb" || Mnemonic == "rsc" || Mnemonic == "orn" || 4785 Mnemonic == "sbc" || Mnemonic == "eor" || Mnemonic == "neg" || 4786 Mnemonic == "vfm" || Mnemonic == "vfnm" || 4787 (!isThumb() && (Mnemonic == "smull" || Mnemonic == "mov" || 4788 Mnemonic == "mla" || Mnemonic == "smlal" || 4789 Mnemonic == "umlal" || Mnemonic == "umull"))) { 4790 CanAcceptCarrySet = true; 4791 } else 4792 CanAcceptCarrySet = false; 4793 4794 if (Mnemonic == "bkpt" || Mnemonic == "cbnz" || Mnemonic == "setend" || 4795 Mnemonic == "cps" || Mnemonic == "it" || Mnemonic == "cbz" || 4796 Mnemonic == "trap" || Mnemonic == "setend" || 4797 Mnemonic.startswith("cps") || Mnemonic.startswith("vsel") || 4798 Mnemonic == "vmaxnm" || Mnemonic == "vminnm" || Mnemonic == "vcvta" || 4799 Mnemonic == "vcvtn" || Mnemonic == "vcvtp" || Mnemonic == "vcvtm" || 4800 Mnemonic == "vrinta" || Mnemonic == "vrintn" || Mnemonic == "vrintp" || 4801 Mnemonic == "vrintm") { 4802 // These mnemonics are never predicable 4803 CanAcceptPredicationCode = false; 4804 } else if (!isThumb()) { 4805 // Some instructions are only predicable in Thumb mode 4806 CanAcceptPredicationCode 4807 = Mnemonic != "cdp2" && Mnemonic != "clrex" && Mnemonic != "mcr2" && 4808 Mnemonic != "mcrr2" && Mnemonic != "mrc2" && Mnemonic != "mrrc2" && 4809 Mnemonic != "dmb" && Mnemonic != "dsb" && Mnemonic != "isb" && 4810 Mnemonic != "pld" && Mnemonic != "pli" && Mnemonic != "pldw" && 4811 Mnemonic != "ldc2" && Mnemonic != "ldc2l" && 4812 Mnemonic != "stc2" && Mnemonic != "stc2l" && 4813 !Mnemonic.startswith("rfe") && !Mnemonic.startswith("srs"); 4814 } else if (isThumbOne()) { 4815 CanAcceptPredicationCode = Mnemonic != "nop" && Mnemonic != "movs"; 4816 } else 4817 CanAcceptPredicationCode = true; 4818 } 4819 4820 bool ARMAsmParser::shouldOmitCCOutOperand(StringRef Mnemonic, 4821 SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 4822 // FIXME: This is all horribly hacky. We really need a better way to deal 4823 // with optional operands like this in the matcher table. 4824 4825 // The 'mov' mnemonic is special. One variant has a cc_out operand, while 4826 // another does not. Specifically, the MOVW instruction does not. So we 4827 // special case it here and remove the defaulted (non-setting) cc_out 4828 // operand if that's the instruction we're trying to match. 4829 // 4830 // We do this as post-processing of the explicit operands rather than just 4831 // conditionally adding the cc_out in the first place because we need 4832 // to check the type of the parsed immediate operand. 4833 if (Mnemonic == "mov" && Operands.size() > 4 && !isThumb() && 4834 !static_cast<ARMOperand*>(Operands[4])->isARMSOImm() && 4835 static_cast<ARMOperand*>(Operands[4])->isImm0_65535Expr() && 4836 static_cast<ARMOperand*>(Operands[1])->getReg() == 0) 4837 return true; 4838 4839 // Register-register 'add' for thumb does not have a cc_out operand 4840 // when there are only two register operands. 4841 if (isThumb() && Mnemonic == "add" && Operands.size() == 5 && 4842 static_cast<ARMOperand*>(Operands[3])->isReg() && 4843 static_cast<ARMOperand*>(Operands[4])->isReg() && 4844 static_cast<ARMOperand*>(Operands[1])->getReg() == 0) 4845 return true; 4846 // Register-register 'add' for thumb does not have a cc_out operand 4847 // when it's an ADD Rdm, SP, {Rdm|#imm0_255} instruction. We do 4848 // have to check the immediate range here since Thumb2 has a variant 4849 // that can handle a different range and has a cc_out operand. 4850 if (((isThumb() && Mnemonic == "add") || 4851 (isThumbTwo() && Mnemonic == "sub")) && 4852 Operands.size() == 6 && 4853 static_cast<ARMOperand*>(Operands[3])->isReg() && 4854 static_cast<ARMOperand*>(Operands[4])->isReg() && 4855 static_cast<ARMOperand*>(Operands[4])->getReg() == ARM::SP && 4856 static_cast<ARMOperand*>(Operands[1])->getReg() == 0 && 4857 ((Mnemonic == "add" &&static_cast<ARMOperand*>(Operands[5])->isReg()) || 4858 static_cast<ARMOperand*>(Operands[5])->isImm0_1020s4())) 4859 return true; 4860 // For Thumb2, add/sub immediate does not have a cc_out operand for the 4861 // imm0_4095 variant. That's the least-preferred variant when 4862 // selecting via the generic "add" mnemonic, so to know that we 4863 // should remove the cc_out operand, we have to explicitly check that 4864 // it's not one of the other variants. Ugh. 4865 if (isThumbTwo() && (Mnemonic == "add" || Mnemonic == "sub") && 4866 Operands.size() == 6 && 4867 static_cast<ARMOperand*>(Operands[3])->isReg() && 4868 static_cast<ARMOperand*>(Operands[4])->isReg() && 4869 static_cast<ARMOperand*>(Operands[5])->isImm()) { 4870 // Nest conditions rather than one big 'if' statement for readability. 4871 // 4872 // If both registers are low, we're in an IT block, and the immediate is 4873 // in range, we should use encoding T1 instead, which has a cc_out. 4874 if (inITBlock() && 4875 isARMLowRegister(static_cast<ARMOperand*>(Operands[3])->getReg()) && 4876 isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg()) && 4877 static_cast<ARMOperand*>(Operands[5])->isImm0_7()) 4878 return false; 4879 // Check against T3. If the second register is the PC, this is an 4880 // alternate form of ADR, which uses encoding T4, so check for that too. 4881 if (static_cast<ARMOperand*>(Operands[4])->getReg() != ARM::PC && 4882 static_cast<ARMOperand*>(Operands[5])->isT2SOImm()) 4883 return false; 4884 4885 // Otherwise, we use encoding T4, which does not have a cc_out 4886 // operand. 4887 return true; 4888 } 4889 4890 // The thumb2 multiply instruction doesn't have a CCOut register, so 4891 // if we have a "mul" mnemonic in Thumb mode, check if we'll be able to 4892 // use the 16-bit encoding or not. 4893 if (isThumbTwo() && Mnemonic == "mul" && Operands.size() == 6 && 4894 static_cast<ARMOperand*>(Operands[1])->getReg() == 0 && 4895 static_cast<ARMOperand*>(Operands[3])->isReg() && 4896 static_cast<ARMOperand*>(Operands[4])->isReg() && 4897 static_cast<ARMOperand*>(Operands[5])->isReg() && 4898 // If the registers aren't low regs, the destination reg isn't the 4899 // same as one of the source regs, or the cc_out operand is zero 4900 // outside of an IT block, we have to use the 32-bit encoding, so 4901 // remove the cc_out operand. 4902 (!isARMLowRegister(static_cast<ARMOperand*>(Operands[3])->getReg()) || 4903 !isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg()) || 4904 !isARMLowRegister(static_cast<ARMOperand*>(Operands[5])->getReg()) || 4905 !inITBlock() || 4906 (static_cast<ARMOperand*>(Operands[3])->getReg() != 4907 static_cast<ARMOperand*>(Operands[5])->getReg() && 4908 static_cast<ARMOperand*>(Operands[3])->getReg() != 4909 static_cast<ARMOperand*>(Operands[4])->getReg()))) 4910 return true; 4911 4912 // Also check the 'mul' syntax variant that doesn't specify an explicit 4913 // destination register. 4914 if (isThumbTwo() && Mnemonic == "mul" && Operands.size() == 5 && 4915 static_cast<ARMOperand*>(Operands[1])->getReg() == 0 && 4916 static_cast<ARMOperand*>(Operands[3])->isReg() && 4917 static_cast<ARMOperand*>(Operands[4])->isReg() && 4918 // If the registers aren't low regs or the cc_out operand is zero 4919 // outside of an IT block, we have to use the 32-bit encoding, so 4920 // remove the cc_out operand. 4921 (!isARMLowRegister(static_cast<ARMOperand*>(Operands[3])->getReg()) || 4922 !isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg()) || 4923 !inITBlock())) 4924 return true; 4925 4926 4927 4928 // Register-register 'add/sub' for thumb does not have a cc_out operand 4929 // when it's an ADD/SUB SP, #imm. Be lenient on count since there's also 4930 // the "add/sub SP, SP, #imm" version. If the follow-up operands aren't 4931 // right, this will result in better diagnostics (which operand is off) 4932 // anyway. 4933 if (isThumb() && (Mnemonic == "add" || Mnemonic == "sub") && 4934 (Operands.size() == 5 || Operands.size() == 6) && 4935 static_cast<ARMOperand*>(Operands[3])->isReg() && 4936 static_cast<ARMOperand*>(Operands[3])->getReg() == ARM::SP && 4937 static_cast<ARMOperand*>(Operands[1])->getReg() == 0 && 4938 (static_cast<ARMOperand*>(Operands[4])->isImm() || 4939 (Operands.size() == 6 && 4940 static_cast<ARMOperand*>(Operands[5])->isImm()))) 4941 return true; 4942 4943 return false; 4944 } 4945 4946 bool ARMAsmParser::shouldOmitPredicateOperand( 4947 StringRef Mnemonic, SmallVectorImpl<MCParsedAsmOperand *> &Operands) { 4948 // VRINT{Z, R, X} have a predicate operand in VFP, but not in NEON 4949 unsigned RegIdx = 3; 4950 if ((Mnemonic == "vrintz" || Mnemonic == "vrintx" || Mnemonic == "vrintr") && 4951 static_cast<ARMOperand *>(Operands[2])->getToken() == ".f32") { 4952 if (static_cast<ARMOperand *>(Operands[3])->isToken() && 4953 static_cast<ARMOperand *>(Operands[3])->getToken() == ".f32") 4954 RegIdx = 4; 4955 4956 if (static_cast<ARMOperand *>(Operands[RegIdx])->isReg() && 4957 (ARMMCRegisterClasses[ARM::DPRRegClassID] 4958 .contains(static_cast<ARMOperand *>(Operands[RegIdx])->getReg()) || 4959 ARMMCRegisterClasses[ARM::QPRRegClassID] 4960 .contains(static_cast<ARMOperand *>(Operands[RegIdx])->getReg()))) 4961 return true; 4962 } 4963 return false; 4964 } 4965 4966 bool ARMAsmParser::isDeprecated(MCInst &Inst, StringRef &Info) { 4967 if (hasV8Ops() && Inst.getOpcode() == ARM::SETEND) { 4968 Info = "armv8"; 4969 return true; 4970 } 4971 return false; 4972 } 4973 4974 static bool isDataTypeToken(StringRef Tok) { 4975 return Tok == ".8" || Tok == ".16" || Tok == ".32" || Tok == ".64" || 4976 Tok == ".i8" || Tok == ".i16" || Tok == ".i32" || Tok == ".i64" || 4977 Tok == ".u8" || Tok == ".u16" || Tok == ".u32" || Tok == ".u64" || 4978 Tok == ".s8" || Tok == ".s16" || Tok == ".s32" || Tok == ".s64" || 4979 Tok == ".p8" || Tok == ".p16" || Tok == ".f32" || Tok == ".f64" || 4980 Tok == ".f" || Tok == ".d"; 4981 } 4982 4983 // FIXME: This bit should probably be handled via an explicit match class 4984 // in the .td files that matches the suffix instead of having it be 4985 // a literal string token the way it is now. 4986 static bool doesIgnoreDataTypeSuffix(StringRef Mnemonic, StringRef DT) { 4987 return Mnemonic.startswith("vldm") || Mnemonic.startswith("vstm"); 4988 } 4989 static void applyMnemonicAliases(StringRef &Mnemonic, unsigned Features, 4990 unsigned VariantID); 4991 /// Parse an arm instruction mnemonic followed by its operands. 4992 bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name, 4993 SMLoc NameLoc, 4994 SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 4995 // Apply mnemonic aliases before doing anything else, as the destination 4996 // mnemnonic may include suffices and we want to handle them normally. 4997 // The generic tblgen'erated code does this later, at the start of 4998 // MatchInstructionImpl(), but that's too late for aliases that include 4999 // any sort of suffix. 5000 unsigned AvailableFeatures = getAvailableFeatures(); 5001 unsigned AssemblerDialect = getParser().getAssemblerDialect(); 5002 applyMnemonicAliases(Name, AvailableFeatures, AssemblerDialect); 5003 5004 // First check for the ARM-specific .req directive. 5005 if (Parser.getTok().is(AsmToken::Identifier) && 5006 Parser.getTok().getIdentifier() == ".req") { 5007 parseDirectiveReq(Name, NameLoc); 5008 // We always return 'error' for this, as we're done with this 5009 // statement and don't need to match the 'instruction." 5010 return true; 5011 } 5012 5013 // Create the leading tokens for the mnemonic, split by '.' characters. 5014 size_t Start = 0, Next = Name.find('.'); 5015 StringRef Mnemonic = Name.slice(Start, Next); 5016 5017 // Split out the predication code and carry setting flag from the mnemonic. 5018 unsigned PredicationCode; 5019 unsigned ProcessorIMod; 5020 bool CarrySetting; 5021 StringRef ITMask; 5022 Mnemonic = splitMnemonic(Mnemonic, PredicationCode, CarrySetting, 5023 ProcessorIMod, ITMask); 5024 5025 // In Thumb1, only the branch (B) instruction can be predicated. 5026 if (isThumbOne() && PredicationCode != ARMCC::AL && Mnemonic != "b") { 5027 Parser.eatToEndOfStatement(); 5028 return Error(NameLoc, "conditional execution not supported in Thumb1"); 5029 } 5030 5031 Operands.push_back(ARMOperand::CreateToken(Mnemonic, NameLoc)); 5032 5033 // Handle the IT instruction ITMask. Convert it to a bitmask. This 5034 // is the mask as it will be for the IT encoding if the conditional 5035 // encoding has a '1' as it's bit0 (i.e. 't' ==> '1'). In the case 5036 // where the conditional bit0 is zero, the instruction post-processing 5037 // will adjust the mask accordingly. 5038 if (Mnemonic == "it") { 5039 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + 2); 5040 if (ITMask.size() > 3) { 5041 Parser.eatToEndOfStatement(); 5042 return Error(Loc, "too many conditions on IT instruction"); 5043 } 5044 unsigned Mask = 8; 5045 for (unsigned i = ITMask.size(); i != 0; --i) { 5046 char pos = ITMask[i - 1]; 5047 if (pos != 't' && pos != 'e') { 5048 Parser.eatToEndOfStatement(); 5049 return Error(Loc, "illegal IT block condition mask '" + ITMask + "'"); 5050 } 5051 Mask >>= 1; 5052 if (ITMask[i - 1] == 't') 5053 Mask |= 8; 5054 } 5055 Operands.push_back(ARMOperand::CreateITMask(Mask, Loc)); 5056 } 5057 5058 // FIXME: This is all a pretty gross hack. We should automatically handle 5059 // optional operands like this via tblgen. 5060 5061 // Next, add the CCOut and ConditionCode operands, if needed. 5062 // 5063 // For mnemonics which can ever incorporate a carry setting bit or predication 5064 // code, our matching model involves us always generating CCOut and 5065 // ConditionCode operands to match the mnemonic "as written" and then we let 5066 // the matcher deal with finding the right instruction or generating an 5067 // appropriate error. 5068 bool CanAcceptCarrySet, CanAcceptPredicationCode; 5069 getMnemonicAcceptInfo(Mnemonic, CanAcceptCarrySet, CanAcceptPredicationCode); 5070 5071 // If we had a carry-set on an instruction that can't do that, issue an 5072 // error. 5073 if (!CanAcceptCarrySet && CarrySetting) { 5074 Parser.eatToEndOfStatement(); 5075 return Error(NameLoc, "instruction '" + Mnemonic + 5076 "' can not set flags, but 's' suffix specified"); 5077 } 5078 // If we had a predication code on an instruction that can't do that, issue an 5079 // error. 5080 if (!CanAcceptPredicationCode && PredicationCode != ARMCC::AL) { 5081 Parser.eatToEndOfStatement(); 5082 return Error(NameLoc, "instruction '" + Mnemonic + 5083 "' is not predicable, but condition code specified"); 5084 } 5085 5086 // Add the carry setting operand, if necessary. 5087 if (CanAcceptCarrySet) { 5088 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size()); 5089 Operands.push_back(ARMOperand::CreateCCOut(CarrySetting ? ARM::CPSR : 0, 5090 Loc)); 5091 } 5092 5093 // Add the predication code operand, if necessary. 5094 if (CanAcceptPredicationCode) { 5095 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size() + 5096 CarrySetting); 5097 Operands.push_back(ARMOperand::CreateCondCode( 5098 ARMCC::CondCodes(PredicationCode), Loc)); 5099 } 5100 5101 // Add the processor imod operand, if necessary. 5102 if (ProcessorIMod) { 5103 Operands.push_back(ARMOperand::CreateImm( 5104 MCConstantExpr::Create(ProcessorIMod, getContext()), 5105 NameLoc, NameLoc)); 5106 } 5107 5108 // Add the remaining tokens in the mnemonic. 5109 while (Next != StringRef::npos) { 5110 Start = Next; 5111 Next = Name.find('.', Start + 1); 5112 StringRef ExtraToken = Name.slice(Start, Next); 5113 5114 // Some NEON instructions have an optional datatype suffix that is 5115 // completely ignored. Check for that. 5116 if (isDataTypeToken(ExtraToken) && 5117 doesIgnoreDataTypeSuffix(Mnemonic, ExtraToken)) 5118 continue; 5119 5120 // For for ARM mode generate an error if the .n qualifier is used. 5121 if (ExtraToken == ".n" && !isThumb()) { 5122 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Start); 5123 return Error(Loc, "instruction with .n (narrow) qualifier not allowed in " 5124 "arm mode"); 5125 } 5126 5127 // The .n qualifier is always discarded as that is what the tables 5128 // and matcher expect. In ARM mode the .w qualifier has no effect, 5129 // so discard it to avoid errors that can be caused by the matcher. 5130 if (ExtraToken != ".n" && (isThumb() || ExtraToken != ".w")) { 5131 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Start); 5132 Operands.push_back(ARMOperand::CreateToken(ExtraToken, Loc)); 5133 } 5134 } 5135 5136 // Read the remaining operands. 5137 if (getLexer().isNot(AsmToken::EndOfStatement)) { 5138 // Read the first operand. 5139 if (parseOperand(Operands, Mnemonic)) { 5140 Parser.eatToEndOfStatement(); 5141 return true; 5142 } 5143 5144 while (getLexer().is(AsmToken::Comma)) { 5145 Parser.Lex(); // Eat the comma. 5146 5147 // Parse and remember the operand. 5148 if (parseOperand(Operands, Mnemonic)) { 5149 Parser.eatToEndOfStatement(); 5150 return true; 5151 } 5152 } 5153 } 5154 5155 if (getLexer().isNot(AsmToken::EndOfStatement)) { 5156 SMLoc Loc = getLexer().getLoc(); 5157 Parser.eatToEndOfStatement(); 5158 return Error(Loc, "unexpected token in argument list"); 5159 } 5160 5161 Parser.Lex(); // Consume the EndOfStatement 5162 5163 // Some instructions, mostly Thumb, have forms for the same mnemonic that 5164 // do and don't have a cc_out optional-def operand. With some spot-checks 5165 // of the operand list, we can figure out which variant we're trying to 5166 // parse and adjust accordingly before actually matching. We shouldn't ever 5167 // try to remove a cc_out operand that was explicitly set on the the 5168 // mnemonic, of course (CarrySetting == true). Reason number #317 the 5169 // table driven matcher doesn't fit well with the ARM instruction set. 5170 if (!CarrySetting && shouldOmitCCOutOperand(Mnemonic, Operands)) { 5171 ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]); 5172 Operands.erase(Operands.begin() + 1); 5173 delete Op; 5174 } 5175 5176 // Some instructions have the same mnemonic, but don't always 5177 // have a predicate. Distinguish them here and delete the 5178 // predicate if needed. 5179 if (shouldOmitPredicateOperand(Mnemonic, Operands)) { 5180 ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]); 5181 Operands.erase(Operands.begin() + 1); 5182 delete Op; 5183 } 5184 5185 // ARM mode 'blx' need special handling, as the register operand version 5186 // is predicable, but the label operand version is not. So, we can't rely 5187 // on the Mnemonic based checking to correctly figure out when to put 5188 // a k_CondCode operand in the list. If we're trying to match the label 5189 // version, remove the k_CondCode operand here. 5190 if (!isThumb() && Mnemonic == "blx" && Operands.size() == 3 && 5191 static_cast<ARMOperand*>(Operands[2])->isImm()) { 5192 ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]); 5193 Operands.erase(Operands.begin() + 1); 5194 delete Op; 5195 } 5196 5197 // Adjust operands of ldrexd/strexd to MCK_GPRPair. 5198 // ldrexd/strexd require even/odd GPR pair. To enforce this constraint, 5199 // a single GPRPair reg operand is used in the .td file to replace the two 5200 // GPRs. However, when parsing from asm, the two GRPs cannot be automatically 5201 // expressed as a GPRPair, so we have to manually merge them. 5202 // FIXME: We would really like to be able to tablegen'erate this. 5203 if (!isThumb() && Operands.size() > 4 && 5204 (Mnemonic == "ldrexd" || Mnemonic == "strexd" || Mnemonic == "ldaexd" || 5205 Mnemonic == "stlexd")) { 5206 bool isLoad = (Mnemonic == "ldrexd" || Mnemonic == "ldaexd"); 5207 unsigned Idx = isLoad ? 2 : 3; 5208 ARMOperand* Op1 = static_cast<ARMOperand*>(Operands[Idx]); 5209 ARMOperand* Op2 = static_cast<ARMOperand*>(Operands[Idx+1]); 5210 5211 const MCRegisterClass& MRC = MRI->getRegClass(ARM::GPRRegClassID); 5212 // Adjust only if Op1 and Op2 are GPRs. 5213 if (Op1->isReg() && Op2->isReg() && MRC.contains(Op1->getReg()) && 5214 MRC.contains(Op2->getReg())) { 5215 unsigned Reg1 = Op1->getReg(); 5216 unsigned Reg2 = Op2->getReg(); 5217 unsigned Rt = MRI->getEncodingValue(Reg1); 5218 unsigned Rt2 = MRI->getEncodingValue(Reg2); 5219 5220 // Rt2 must be Rt + 1 and Rt must be even. 5221 if (Rt + 1 != Rt2 || (Rt & 1)) { 5222 Error(Op2->getStartLoc(), isLoad ? 5223 "destination operands must be sequential" : 5224 "source operands must be sequential"); 5225 return true; 5226 } 5227 unsigned NewReg = MRI->getMatchingSuperReg(Reg1, ARM::gsub_0, 5228 &(MRI->getRegClass(ARM::GPRPairRegClassID))); 5229 Operands.erase(Operands.begin() + Idx, Operands.begin() + Idx + 2); 5230 Operands.insert(Operands.begin() + Idx, ARMOperand::CreateReg( 5231 NewReg, Op1->getStartLoc(), Op2->getEndLoc())); 5232 delete Op1; 5233 delete Op2; 5234 } 5235 } 5236 5237 // FIXME: As said above, this is all a pretty gross hack. This instruction 5238 // does not fit with other "subs" and tblgen. 5239 // Adjust operands of B9.3.19 SUBS PC, LR, #imm (Thumb2) system instruction 5240 // so the Mnemonic is the original name "subs" and delete the predicate 5241 // operand so it will match the table entry. 5242 if (isThumbTwo() && Mnemonic == "sub" && Operands.size() == 6 && 5243 static_cast<ARMOperand*>(Operands[3])->isReg() && 5244 static_cast<ARMOperand*>(Operands[3])->getReg() == ARM::PC && 5245 static_cast<ARMOperand*>(Operands[4])->isReg() && 5246 static_cast<ARMOperand*>(Operands[4])->getReg() == ARM::LR && 5247 static_cast<ARMOperand*>(Operands[5])->isImm()) { 5248 ARMOperand *Op0 = static_cast<ARMOperand*>(Operands[0]); 5249 Operands.erase(Operands.begin()); 5250 delete Op0; 5251 Operands.insert(Operands.begin(), ARMOperand::CreateToken(Name, NameLoc)); 5252 5253 ARMOperand *Op1 = static_cast<ARMOperand*>(Operands[1]); 5254 Operands.erase(Operands.begin() + 1); 5255 delete Op1; 5256 } 5257 return false; 5258 } 5259 5260 // Validate context-sensitive operand constraints. 5261 5262 // return 'true' if register list contains non-low GPR registers, 5263 // 'false' otherwise. If Reg is in the register list or is HiReg, set 5264 // 'containsReg' to true. 5265 static bool checkLowRegisterList(MCInst Inst, unsigned OpNo, unsigned Reg, 5266 unsigned HiReg, bool &containsReg) { 5267 containsReg = false; 5268 for (unsigned i = OpNo; i < Inst.getNumOperands(); ++i) { 5269 unsigned OpReg = Inst.getOperand(i).getReg(); 5270 if (OpReg == Reg) 5271 containsReg = true; 5272 // Anything other than a low register isn't legal here. 5273 if (!isARMLowRegister(OpReg) && (!HiReg || OpReg != HiReg)) 5274 return true; 5275 } 5276 return false; 5277 } 5278 5279 // Check if the specified regisgter is in the register list of the inst, 5280 // starting at the indicated operand number. 5281 static bool listContainsReg(MCInst &Inst, unsigned OpNo, unsigned Reg) { 5282 for (unsigned i = OpNo; i < Inst.getNumOperands(); ++i) { 5283 unsigned OpReg = Inst.getOperand(i).getReg(); 5284 if (OpReg == Reg) 5285 return true; 5286 } 5287 return false; 5288 } 5289 5290 // FIXME: We would really prefer to have MCInstrInfo (the wrapper around 5291 // the ARMInsts array) instead. Getting that here requires awkward 5292 // API changes, though. Better way? 5293 namespace llvm { 5294 extern const MCInstrDesc ARMInsts[]; 5295 } 5296 static const MCInstrDesc &getInstDesc(unsigned Opcode) { 5297 return ARMInsts[Opcode]; 5298 } 5299 5300 // FIXME: We would really like to be able to tablegen'erate this. 5301 bool ARMAsmParser:: 5302 validateInstruction(MCInst &Inst, 5303 const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 5304 const MCInstrDesc &MCID = getInstDesc(Inst.getOpcode()); 5305 SMLoc Loc = Operands[0]->getStartLoc(); 5306 5307 // Check the IT block state first. 5308 // NOTE: BKPT instruction has the interesting property of being 5309 // allowed in IT blocks, but not being predicable. It just always 5310 // executes. 5311 if (inITBlock() && Inst.getOpcode() != ARM::tBKPT && 5312 Inst.getOpcode() != ARM::BKPT) { 5313 unsigned bit = 1; 5314 if (ITState.FirstCond) 5315 ITState.FirstCond = false; 5316 else 5317 bit = (ITState.Mask >> (5 - ITState.CurPosition)) & 1; 5318 // The instruction must be predicable. 5319 if (!MCID.isPredicable()) 5320 return Error(Loc, "instructions in IT block must be predicable"); 5321 unsigned Cond = Inst.getOperand(MCID.findFirstPredOperandIdx()).getImm(); 5322 unsigned ITCond = bit ? ITState.Cond : 5323 ARMCC::getOppositeCondition(ITState.Cond); 5324 if (Cond != ITCond) { 5325 // Find the condition code Operand to get its SMLoc information. 5326 SMLoc CondLoc; 5327 for (unsigned i = 1; i < Operands.size(); ++i) 5328 if (static_cast<ARMOperand*>(Operands[i])->isCondCode()) 5329 CondLoc = Operands[i]->getStartLoc(); 5330 return Error(CondLoc, "incorrect condition in IT block; got '" + 5331 StringRef(ARMCondCodeToString(ARMCC::CondCodes(Cond))) + 5332 "', but expected '" + 5333 ARMCondCodeToString(ARMCC::CondCodes(ITCond)) + "'"); 5334 } 5335 // Check for non-'al' condition codes outside of the IT block. 5336 } else if (isThumbTwo() && MCID.isPredicable() && 5337 Inst.getOperand(MCID.findFirstPredOperandIdx()).getImm() != 5338 ARMCC::AL && Inst.getOpcode() != ARM::tBcc && 5339 Inst.getOpcode() != ARM::t2Bcc) 5340 return Error(Loc, "predicated instructions must be in IT block"); 5341 5342 switch (Inst.getOpcode()) { 5343 case ARM::LDRD: 5344 case ARM::LDRD_PRE: 5345 case ARM::LDRD_POST: { 5346 // Rt2 must be Rt + 1. 5347 unsigned Rt = MRI->getEncodingValue(Inst.getOperand(0).getReg()); 5348 unsigned Rt2 = MRI->getEncodingValue(Inst.getOperand(1).getReg()); 5349 if (Rt2 != Rt + 1) 5350 return Error(Operands[3]->getStartLoc(), 5351 "destination operands must be sequential"); 5352 return false; 5353 } 5354 case ARM::STRD: { 5355 // Rt2 must be Rt + 1. 5356 unsigned Rt = MRI->getEncodingValue(Inst.getOperand(0).getReg()); 5357 unsigned Rt2 = MRI->getEncodingValue(Inst.getOperand(1).getReg()); 5358 if (Rt2 != Rt + 1) 5359 return Error(Operands[3]->getStartLoc(), 5360 "source operands must be sequential"); 5361 return false; 5362 } 5363 case ARM::STRD_PRE: 5364 case ARM::STRD_POST: { 5365 // Rt2 must be Rt + 1. 5366 unsigned Rt = MRI->getEncodingValue(Inst.getOperand(1).getReg()); 5367 unsigned Rt2 = MRI->getEncodingValue(Inst.getOperand(2).getReg()); 5368 if (Rt2 != Rt + 1) 5369 return Error(Operands[3]->getStartLoc(), 5370 "source operands must be sequential"); 5371 return false; 5372 } 5373 case ARM::SBFX: 5374 case ARM::UBFX: { 5375 // width must be in range [1, 32-lsb] 5376 unsigned lsb = Inst.getOperand(2).getImm(); 5377 unsigned widthm1 = Inst.getOperand(3).getImm(); 5378 if (widthm1 >= 32 - lsb) 5379 return Error(Operands[5]->getStartLoc(), 5380 "bitfield width must be in range [1,32-lsb]"); 5381 return false; 5382 } 5383 case ARM::tLDMIA: { 5384 // If we're parsing Thumb2, the .w variant is available and handles 5385 // most cases that are normally illegal for a Thumb1 LDM 5386 // instruction. We'll make the transformation in processInstruction() 5387 // if necessary. 5388 // 5389 // Thumb LDM instructions are writeback iff the base register is not 5390 // in the register list. 5391 unsigned Rn = Inst.getOperand(0).getReg(); 5392 bool hasWritebackToken = 5393 (static_cast<ARMOperand*>(Operands[3])->isToken() && 5394 static_cast<ARMOperand*>(Operands[3])->getToken() == "!"); 5395 bool listContainsBase; 5396 if (checkLowRegisterList(Inst, 3, Rn, 0, listContainsBase) && !isThumbTwo()) 5397 return Error(Operands[3 + hasWritebackToken]->getStartLoc(), 5398 "registers must be in range r0-r7"); 5399 // If we should have writeback, then there should be a '!' token. 5400 if (!listContainsBase && !hasWritebackToken && !isThumbTwo()) 5401 return Error(Operands[2]->getStartLoc(), 5402 "writeback operator '!' expected"); 5403 // If we should not have writeback, there must not be a '!'. This is 5404 // true even for the 32-bit wide encodings. 5405 if (listContainsBase && hasWritebackToken) 5406 return Error(Operands[3]->getStartLoc(), 5407 "writeback operator '!' not allowed when base register " 5408 "in register list"); 5409 5410 break; 5411 } 5412 case ARM::t2LDMIA_UPD: { 5413 if (listContainsReg(Inst, 3, Inst.getOperand(0).getReg())) 5414 return Error(Operands[4]->getStartLoc(), 5415 "writeback operator '!' not allowed when base register " 5416 "in register list"); 5417 break; 5418 } 5419 case ARM::tMUL: { 5420 // The second source operand must be the same register as the destination 5421 // operand. 5422 // 5423 // In this case, we must directly check the parsed operands because the 5424 // cvtThumbMultiply() function is written in such a way that it guarantees 5425 // this first statement is always true for the new Inst. Essentially, the 5426 // destination is unconditionally copied into the second source operand 5427 // without checking to see if it matches what we actually parsed. 5428 if (Operands.size() == 6 && 5429 (((ARMOperand*)Operands[3])->getReg() != 5430 ((ARMOperand*)Operands[5])->getReg()) && 5431 (((ARMOperand*)Operands[3])->getReg() != 5432 ((ARMOperand*)Operands[4])->getReg())) { 5433 return Error(Operands[3]->getStartLoc(), 5434 "destination register must match source register"); 5435 } 5436 break; 5437 } 5438 // Like for ldm/stm, push and pop have hi-reg handling version in Thumb2, 5439 // so only issue a diagnostic for thumb1. The instructions will be 5440 // switched to the t2 encodings in processInstruction() if necessary. 5441 case ARM::tPOP: { 5442 bool listContainsBase; 5443 if (checkLowRegisterList(Inst, 2, 0, ARM::PC, listContainsBase) && 5444 !isThumbTwo()) 5445 return Error(Operands[2]->getStartLoc(), 5446 "registers must be in range r0-r7 or pc"); 5447 break; 5448 } 5449 case ARM::tPUSH: { 5450 bool listContainsBase; 5451 if (checkLowRegisterList(Inst, 2, 0, ARM::LR, listContainsBase) && 5452 !isThumbTwo()) 5453 return Error(Operands[2]->getStartLoc(), 5454 "registers must be in range r0-r7 or lr"); 5455 break; 5456 } 5457 case ARM::tSTMIA_UPD: { 5458 bool listContainsBase; 5459 if (checkLowRegisterList(Inst, 4, 0, 0, listContainsBase) && !isThumbTwo()) 5460 return Error(Operands[4]->getStartLoc(), 5461 "registers must be in range r0-r7"); 5462 break; 5463 } 5464 case ARM::tADDrSP: { 5465 // If the non-SP source operand and the destination operand are not the 5466 // same, we need thumb2 (for the wide encoding), or we have an error. 5467 if (!isThumbTwo() && 5468 Inst.getOperand(0).getReg() != Inst.getOperand(2).getReg()) { 5469 return Error(Operands[4]->getStartLoc(), 5470 "source register must be the same as destination"); 5471 } 5472 break; 5473 } 5474 // final range checking for Thumb unconditional branch instructions 5475 case ARM::tB: 5476 if(!(static_cast<ARMOperand*>(Operands[2]))->isSignedOffset<11, 1>()) 5477 return Error(Operands[2]->getStartLoc(), "Branch target out of range"); 5478 break; 5479 case ARM::t2B: { 5480 int op = (Operands[2]->isImm()) ? 2 : 3; 5481 if(!(static_cast<ARMOperand*>(Operands[op]))->isSignedOffset<24, 1>()) 5482 return Error(Operands[op]->getStartLoc(), "Branch target out of range"); 5483 break; 5484 } 5485 // final range checking for Thumb conditional branch instructions 5486 case ARM::tBcc: 5487 if(!(static_cast<ARMOperand*>(Operands[2]))->isSignedOffset<8, 1>()) 5488 return Error(Operands[2]->getStartLoc(), "Branch target out of range"); 5489 break; 5490 case ARM::t2Bcc: { 5491 int op = (Operands[2]->isImm()) ? 2 : 3; 5492 if(!(static_cast<ARMOperand*>(Operands[op]))->isSignedOffset<20, 1>()) 5493 return Error(Operands[op]->getStartLoc(), "Branch target out of range"); 5494 break; 5495 } 5496 } 5497 5498 StringRef DepInfo; 5499 if (isDeprecated(Inst, DepInfo)) 5500 Warning(Loc, "deprecated on " + DepInfo); 5501 5502 return false; 5503 } 5504 5505 static unsigned getRealVSTOpcode(unsigned Opc, unsigned &Spacing) { 5506 switch(Opc) { 5507 default: llvm_unreachable("unexpected opcode!"); 5508 // VST1LN 5509 case ARM::VST1LNdWB_fixed_Asm_8: Spacing = 1; return ARM::VST1LNd8_UPD; 5510 case ARM::VST1LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VST1LNd16_UPD; 5511 case ARM::VST1LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VST1LNd32_UPD; 5512 case ARM::VST1LNdWB_register_Asm_8: Spacing = 1; return ARM::VST1LNd8_UPD; 5513 case ARM::VST1LNdWB_register_Asm_16: Spacing = 1; return ARM::VST1LNd16_UPD; 5514 case ARM::VST1LNdWB_register_Asm_32: Spacing = 1; return ARM::VST1LNd32_UPD; 5515 case ARM::VST1LNdAsm_8: Spacing = 1; return ARM::VST1LNd8; 5516 case ARM::VST1LNdAsm_16: Spacing = 1; return ARM::VST1LNd16; 5517 case ARM::VST1LNdAsm_32: Spacing = 1; return ARM::VST1LNd32; 5518 5519 // VST2LN 5520 case ARM::VST2LNdWB_fixed_Asm_8: Spacing = 1; return ARM::VST2LNd8_UPD; 5521 case ARM::VST2LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VST2LNd16_UPD; 5522 case ARM::VST2LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VST2LNd32_UPD; 5523 case ARM::VST2LNqWB_fixed_Asm_16: Spacing = 2; return ARM::VST2LNq16_UPD; 5524 case ARM::VST2LNqWB_fixed_Asm_32: Spacing = 2; return ARM::VST2LNq32_UPD; 5525 5526 case ARM::VST2LNdWB_register_Asm_8: Spacing = 1; return ARM::VST2LNd8_UPD; 5527 case ARM::VST2LNdWB_register_Asm_16: Spacing = 1; return ARM::VST2LNd16_UPD; 5528 case ARM::VST2LNdWB_register_Asm_32: Spacing = 1; return ARM::VST2LNd32_UPD; 5529 case ARM::VST2LNqWB_register_Asm_16: Spacing = 2; return ARM::VST2LNq16_UPD; 5530 case ARM::VST2LNqWB_register_Asm_32: Spacing = 2; return ARM::VST2LNq32_UPD; 5531 5532 case ARM::VST2LNdAsm_8: Spacing = 1; return ARM::VST2LNd8; 5533 case ARM::VST2LNdAsm_16: Spacing = 1; return ARM::VST2LNd16; 5534 case ARM::VST2LNdAsm_32: Spacing = 1; return ARM::VST2LNd32; 5535 case ARM::VST2LNqAsm_16: Spacing = 2; return ARM::VST2LNq16; 5536 case ARM::VST2LNqAsm_32: Spacing = 2; return ARM::VST2LNq32; 5537 5538 // VST3LN 5539 case ARM::VST3LNdWB_fixed_Asm_8: Spacing = 1; return ARM::VST3LNd8_UPD; 5540 case ARM::VST3LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VST3LNd16_UPD; 5541 case ARM::VST3LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VST3LNd32_UPD; 5542 case ARM::VST3LNqWB_fixed_Asm_16: Spacing = 1; return ARM::VST3LNq16_UPD; 5543 case ARM::VST3LNqWB_fixed_Asm_32: Spacing = 2; return ARM::VST3LNq32_UPD; 5544 case ARM::VST3LNdWB_register_Asm_8: Spacing = 1; return ARM::VST3LNd8_UPD; 5545 case ARM::VST3LNdWB_register_Asm_16: Spacing = 1; return ARM::VST3LNd16_UPD; 5546 case ARM::VST3LNdWB_register_Asm_32: Spacing = 1; return ARM::VST3LNd32_UPD; 5547 case ARM::VST3LNqWB_register_Asm_16: Spacing = 2; return ARM::VST3LNq16_UPD; 5548 case ARM::VST3LNqWB_register_Asm_32: Spacing = 2; return ARM::VST3LNq32_UPD; 5549 case ARM::VST3LNdAsm_8: Spacing = 1; return ARM::VST3LNd8; 5550 case ARM::VST3LNdAsm_16: Spacing = 1; return ARM::VST3LNd16; 5551 case ARM::VST3LNdAsm_32: Spacing = 1; return ARM::VST3LNd32; 5552 case ARM::VST3LNqAsm_16: Spacing = 2; return ARM::VST3LNq16; 5553 case ARM::VST3LNqAsm_32: Spacing = 2; return ARM::VST3LNq32; 5554 5555 // VST3 5556 case ARM::VST3dWB_fixed_Asm_8: Spacing = 1; return ARM::VST3d8_UPD; 5557 case ARM::VST3dWB_fixed_Asm_16: Spacing = 1; return ARM::VST3d16_UPD; 5558 case ARM::VST3dWB_fixed_Asm_32: Spacing = 1; return ARM::VST3d32_UPD; 5559 case ARM::VST3qWB_fixed_Asm_8: Spacing = 2; return ARM::VST3q8_UPD; 5560 case ARM::VST3qWB_fixed_Asm_16: Spacing = 2; return ARM::VST3q16_UPD; 5561 case ARM::VST3qWB_fixed_Asm_32: Spacing = 2; return ARM::VST3q32_UPD; 5562 case ARM::VST3dWB_register_Asm_8: Spacing = 1; return ARM::VST3d8_UPD; 5563 case ARM::VST3dWB_register_Asm_16: Spacing = 1; return ARM::VST3d16_UPD; 5564 case ARM::VST3dWB_register_Asm_32: Spacing = 1; return ARM::VST3d32_UPD; 5565 case ARM::VST3qWB_register_Asm_8: Spacing = 2; return ARM::VST3q8_UPD; 5566 case ARM::VST3qWB_register_Asm_16: Spacing = 2; return ARM::VST3q16_UPD; 5567 case ARM::VST3qWB_register_Asm_32: Spacing = 2; return ARM::VST3q32_UPD; 5568 case ARM::VST3dAsm_8: Spacing = 1; return ARM::VST3d8; 5569 case ARM::VST3dAsm_16: Spacing = 1; return ARM::VST3d16; 5570 case ARM::VST3dAsm_32: Spacing = 1; return ARM::VST3d32; 5571 case ARM::VST3qAsm_8: Spacing = 2; return ARM::VST3q8; 5572 case ARM::VST3qAsm_16: Spacing = 2; return ARM::VST3q16; 5573 case ARM::VST3qAsm_32: Spacing = 2; return ARM::VST3q32; 5574 5575 // VST4LN 5576 case ARM::VST4LNdWB_fixed_Asm_8: Spacing = 1; return ARM::VST4LNd8_UPD; 5577 case ARM::VST4LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VST4LNd16_UPD; 5578 case ARM::VST4LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VST4LNd32_UPD; 5579 case ARM::VST4LNqWB_fixed_Asm_16: Spacing = 1; return ARM::VST4LNq16_UPD; 5580 case ARM::VST4LNqWB_fixed_Asm_32: Spacing = 2; return ARM::VST4LNq32_UPD; 5581 case ARM::VST4LNdWB_register_Asm_8: Spacing = 1; return ARM::VST4LNd8_UPD; 5582 case ARM::VST4LNdWB_register_Asm_16: Spacing = 1; return ARM::VST4LNd16_UPD; 5583 case ARM::VST4LNdWB_register_Asm_32: Spacing = 1; return ARM::VST4LNd32_UPD; 5584 case ARM::VST4LNqWB_register_Asm_16: Spacing = 2; return ARM::VST4LNq16_UPD; 5585 case ARM::VST4LNqWB_register_Asm_32: Spacing = 2; return ARM::VST4LNq32_UPD; 5586 case ARM::VST4LNdAsm_8: Spacing = 1; return ARM::VST4LNd8; 5587 case ARM::VST4LNdAsm_16: Spacing = 1; return ARM::VST4LNd16; 5588 case ARM::VST4LNdAsm_32: Spacing = 1; return ARM::VST4LNd32; 5589 case ARM::VST4LNqAsm_16: Spacing = 2; return ARM::VST4LNq16; 5590 case ARM::VST4LNqAsm_32: Spacing = 2; return ARM::VST4LNq32; 5591 5592 // VST4 5593 case ARM::VST4dWB_fixed_Asm_8: Spacing = 1; return ARM::VST4d8_UPD; 5594 case ARM::VST4dWB_fixed_Asm_16: Spacing = 1; return ARM::VST4d16_UPD; 5595 case ARM::VST4dWB_fixed_Asm_32: Spacing = 1; return ARM::VST4d32_UPD; 5596 case ARM::VST4qWB_fixed_Asm_8: Spacing = 2; return ARM::VST4q8_UPD; 5597 case ARM::VST4qWB_fixed_Asm_16: Spacing = 2; return ARM::VST4q16_UPD; 5598 case ARM::VST4qWB_fixed_Asm_32: Spacing = 2; return ARM::VST4q32_UPD; 5599 case ARM::VST4dWB_register_Asm_8: Spacing = 1; return ARM::VST4d8_UPD; 5600 case ARM::VST4dWB_register_Asm_16: Spacing = 1; return ARM::VST4d16_UPD; 5601 case ARM::VST4dWB_register_Asm_32: Spacing = 1; return ARM::VST4d32_UPD; 5602 case ARM::VST4qWB_register_Asm_8: Spacing = 2; return ARM::VST4q8_UPD; 5603 case ARM::VST4qWB_register_Asm_16: Spacing = 2; return ARM::VST4q16_UPD; 5604 case ARM::VST4qWB_register_Asm_32: Spacing = 2; return ARM::VST4q32_UPD; 5605 case ARM::VST4dAsm_8: Spacing = 1; return ARM::VST4d8; 5606 case ARM::VST4dAsm_16: Spacing = 1; return ARM::VST4d16; 5607 case ARM::VST4dAsm_32: Spacing = 1; return ARM::VST4d32; 5608 case ARM::VST4qAsm_8: Spacing = 2; return ARM::VST4q8; 5609 case ARM::VST4qAsm_16: Spacing = 2; return ARM::VST4q16; 5610 case ARM::VST4qAsm_32: Spacing = 2; return ARM::VST4q32; 5611 } 5612 } 5613 5614 static unsigned getRealVLDOpcode(unsigned Opc, unsigned &Spacing) { 5615 switch(Opc) { 5616 default: llvm_unreachable("unexpected opcode!"); 5617 // VLD1LN 5618 case ARM::VLD1LNdWB_fixed_Asm_8: Spacing = 1; return ARM::VLD1LNd8_UPD; 5619 case ARM::VLD1LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VLD1LNd16_UPD; 5620 case ARM::VLD1LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VLD1LNd32_UPD; 5621 case ARM::VLD1LNdWB_register_Asm_8: Spacing = 1; return ARM::VLD1LNd8_UPD; 5622 case ARM::VLD1LNdWB_register_Asm_16: Spacing = 1; return ARM::VLD1LNd16_UPD; 5623 case ARM::VLD1LNdWB_register_Asm_32: Spacing = 1; return ARM::VLD1LNd32_UPD; 5624 case ARM::VLD1LNdAsm_8: Spacing = 1; return ARM::VLD1LNd8; 5625 case ARM::VLD1LNdAsm_16: Spacing = 1; return ARM::VLD1LNd16; 5626 case ARM::VLD1LNdAsm_32: Spacing = 1; return ARM::VLD1LNd32; 5627 5628 // VLD2LN 5629 case ARM::VLD2LNdWB_fixed_Asm_8: Spacing = 1; return ARM::VLD2LNd8_UPD; 5630 case ARM::VLD2LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VLD2LNd16_UPD; 5631 case ARM::VLD2LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VLD2LNd32_UPD; 5632 case ARM::VLD2LNqWB_fixed_Asm_16: Spacing = 1; return ARM::VLD2LNq16_UPD; 5633 case ARM::VLD2LNqWB_fixed_Asm_32: Spacing = 2; return ARM::VLD2LNq32_UPD; 5634 case ARM::VLD2LNdWB_register_Asm_8: Spacing = 1; return ARM::VLD2LNd8_UPD; 5635 case ARM::VLD2LNdWB_register_Asm_16: Spacing = 1; return ARM::VLD2LNd16_UPD; 5636 case ARM::VLD2LNdWB_register_Asm_32: Spacing = 1; return ARM::VLD2LNd32_UPD; 5637 case ARM::VLD2LNqWB_register_Asm_16: Spacing = 2; return ARM::VLD2LNq16_UPD; 5638 case ARM::VLD2LNqWB_register_Asm_32: Spacing = 2; return ARM::VLD2LNq32_UPD; 5639 case ARM::VLD2LNdAsm_8: Spacing = 1; return ARM::VLD2LNd8; 5640 case ARM::VLD2LNdAsm_16: Spacing = 1; return ARM::VLD2LNd16; 5641 case ARM::VLD2LNdAsm_32: Spacing = 1; return ARM::VLD2LNd32; 5642 case ARM::VLD2LNqAsm_16: Spacing = 2; return ARM::VLD2LNq16; 5643 case ARM::VLD2LNqAsm_32: Spacing = 2; return ARM::VLD2LNq32; 5644 5645 // VLD3DUP 5646 case ARM::VLD3DUPdWB_fixed_Asm_8: Spacing = 1; return ARM::VLD3DUPd8_UPD; 5647 case ARM::VLD3DUPdWB_fixed_Asm_16: Spacing = 1; return ARM::VLD3DUPd16_UPD; 5648 case ARM::VLD3DUPdWB_fixed_Asm_32: Spacing = 1; return ARM::VLD3DUPd32_UPD; 5649 case ARM::VLD3DUPqWB_fixed_Asm_8: Spacing = 1; return ARM::VLD3DUPq8_UPD; 5650 case ARM::VLD3DUPqWB_fixed_Asm_16: Spacing = 1; return ARM::VLD3DUPq16_UPD; 5651 case ARM::VLD3DUPqWB_fixed_Asm_32: Spacing = 2; return ARM::VLD3DUPq32_UPD; 5652 case ARM::VLD3DUPdWB_register_Asm_8: Spacing = 1; return ARM::VLD3DUPd8_UPD; 5653 case ARM::VLD3DUPdWB_register_Asm_16: Spacing = 1; return ARM::VLD3DUPd16_UPD; 5654 case ARM::VLD3DUPdWB_register_Asm_32: Spacing = 1; return ARM::VLD3DUPd32_UPD; 5655 case ARM::VLD3DUPqWB_register_Asm_8: Spacing = 2; return ARM::VLD3DUPq8_UPD; 5656 case ARM::VLD3DUPqWB_register_Asm_16: Spacing = 2; return ARM::VLD3DUPq16_UPD; 5657 case ARM::VLD3DUPqWB_register_Asm_32: Spacing = 2; return ARM::VLD3DUPq32_UPD; 5658 case ARM::VLD3DUPdAsm_8: Spacing = 1; return ARM::VLD3DUPd8; 5659 case ARM::VLD3DUPdAsm_16: Spacing = 1; return ARM::VLD3DUPd16; 5660 case ARM::VLD3DUPdAsm_32: Spacing = 1; return ARM::VLD3DUPd32; 5661 case ARM::VLD3DUPqAsm_8: Spacing = 2; return ARM::VLD3DUPq8; 5662 case ARM::VLD3DUPqAsm_16: Spacing = 2; return ARM::VLD3DUPq16; 5663 case ARM::VLD3DUPqAsm_32: Spacing = 2; return ARM::VLD3DUPq32; 5664 5665 // VLD3LN 5666 case ARM::VLD3LNdWB_fixed_Asm_8: Spacing = 1; return ARM::VLD3LNd8_UPD; 5667 case ARM::VLD3LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VLD3LNd16_UPD; 5668 case ARM::VLD3LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VLD3LNd32_UPD; 5669 case ARM::VLD3LNqWB_fixed_Asm_16: Spacing = 1; return ARM::VLD3LNq16_UPD; 5670 case ARM::VLD3LNqWB_fixed_Asm_32: Spacing = 2; return ARM::VLD3LNq32_UPD; 5671 case ARM::VLD3LNdWB_register_Asm_8: Spacing = 1; return ARM::VLD3LNd8_UPD; 5672 case ARM::VLD3LNdWB_register_Asm_16: Spacing = 1; return ARM::VLD3LNd16_UPD; 5673 case ARM::VLD3LNdWB_register_Asm_32: Spacing = 1; return ARM::VLD3LNd32_UPD; 5674 case ARM::VLD3LNqWB_register_Asm_16: Spacing = 2; return ARM::VLD3LNq16_UPD; 5675 case ARM::VLD3LNqWB_register_Asm_32: Spacing = 2; return ARM::VLD3LNq32_UPD; 5676 case ARM::VLD3LNdAsm_8: Spacing = 1; return ARM::VLD3LNd8; 5677 case ARM::VLD3LNdAsm_16: Spacing = 1; return ARM::VLD3LNd16; 5678 case ARM::VLD3LNdAsm_32: Spacing = 1; return ARM::VLD3LNd32; 5679 case ARM::VLD3LNqAsm_16: Spacing = 2; return ARM::VLD3LNq16; 5680 case ARM::VLD3LNqAsm_32: Spacing = 2; return ARM::VLD3LNq32; 5681 5682 // VLD3 5683 case ARM::VLD3dWB_fixed_Asm_8: Spacing = 1; return ARM::VLD3d8_UPD; 5684 case ARM::VLD3dWB_fixed_Asm_16: Spacing = 1; return ARM::VLD3d16_UPD; 5685 case ARM::VLD3dWB_fixed_Asm_32: Spacing = 1; return ARM::VLD3d32_UPD; 5686 case ARM::VLD3qWB_fixed_Asm_8: Spacing = 2; return ARM::VLD3q8_UPD; 5687 case ARM::VLD3qWB_fixed_Asm_16: Spacing = 2; return ARM::VLD3q16_UPD; 5688 case ARM::VLD3qWB_fixed_Asm_32: Spacing = 2; return ARM::VLD3q32_UPD; 5689 case ARM::VLD3dWB_register_Asm_8: Spacing = 1; return ARM::VLD3d8_UPD; 5690 case ARM::VLD3dWB_register_Asm_16: Spacing = 1; return ARM::VLD3d16_UPD; 5691 case ARM::VLD3dWB_register_Asm_32: Spacing = 1; return ARM::VLD3d32_UPD; 5692 case ARM::VLD3qWB_register_Asm_8: Spacing = 2; return ARM::VLD3q8_UPD; 5693 case ARM::VLD3qWB_register_Asm_16: Spacing = 2; return ARM::VLD3q16_UPD; 5694 case ARM::VLD3qWB_register_Asm_32: Spacing = 2; return ARM::VLD3q32_UPD; 5695 case ARM::VLD3dAsm_8: Spacing = 1; return ARM::VLD3d8; 5696 case ARM::VLD3dAsm_16: Spacing = 1; return ARM::VLD3d16; 5697 case ARM::VLD3dAsm_32: Spacing = 1; return ARM::VLD3d32; 5698 case ARM::VLD3qAsm_8: Spacing = 2; return ARM::VLD3q8; 5699 case ARM::VLD3qAsm_16: Spacing = 2; return ARM::VLD3q16; 5700 case ARM::VLD3qAsm_32: Spacing = 2; return ARM::VLD3q32; 5701 5702 // VLD4LN 5703 case ARM::VLD4LNdWB_fixed_Asm_8: Spacing = 1; return ARM::VLD4LNd8_UPD; 5704 case ARM::VLD4LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VLD4LNd16_UPD; 5705 case ARM::VLD4LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VLD4LNd32_UPD; 5706 case ARM::VLD4LNqWB_fixed_Asm_16: Spacing = 1; return ARM::VLD4LNq16_UPD; 5707 case ARM::VLD4LNqWB_fixed_Asm_32: Spacing = 2; return ARM::VLD4LNq32_UPD; 5708 case ARM::VLD4LNdWB_register_Asm_8: Spacing = 1; return ARM::VLD4LNd8_UPD; 5709 case ARM::VLD4LNdWB_register_Asm_16: Spacing = 1; return ARM::VLD4LNd16_UPD; 5710 case ARM::VLD4LNdWB_register_Asm_32: Spacing = 1; return ARM::VLD4LNd32_UPD; 5711 case ARM::VLD4LNqWB_register_Asm_16: Spacing = 2; return ARM::VLD4LNq16_UPD; 5712 case ARM::VLD4LNqWB_register_Asm_32: Spacing = 2; return ARM::VLD4LNq32_UPD; 5713 case ARM::VLD4LNdAsm_8: Spacing = 1; return ARM::VLD4LNd8; 5714 case ARM::VLD4LNdAsm_16: Spacing = 1; return ARM::VLD4LNd16; 5715 case ARM::VLD4LNdAsm_32: Spacing = 1; return ARM::VLD4LNd32; 5716 case ARM::VLD4LNqAsm_16: Spacing = 2; return ARM::VLD4LNq16; 5717 case ARM::VLD4LNqAsm_32: Spacing = 2; return ARM::VLD4LNq32; 5718 5719 // VLD4DUP 5720 case ARM::VLD4DUPdWB_fixed_Asm_8: Spacing = 1; return ARM::VLD4DUPd8_UPD; 5721 case ARM::VLD4DUPdWB_fixed_Asm_16: Spacing = 1; return ARM::VLD4DUPd16_UPD; 5722 case ARM::VLD4DUPdWB_fixed_Asm_32: Spacing = 1; return ARM::VLD4DUPd32_UPD; 5723 case ARM::VLD4DUPqWB_fixed_Asm_8: Spacing = 1; return ARM::VLD4DUPq8_UPD; 5724 case ARM::VLD4DUPqWB_fixed_Asm_16: Spacing = 1; return ARM::VLD4DUPq16_UPD; 5725 case ARM::VLD4DUPqWB_fixed_Asm_32: Spacing = 2; return ARM::VLD4DUPq32_UPD; 5726 case ARM::VLD4DUPdWB_register_Asm_8: Spacing = 1; return ARM::VLD4DUPd8_UPD; 5727 case ARM::VLD4DUPdWB_register_Asm_16: Spacing = 1; return ARM::VLD4DUPd16_UPD; 5728 case ARM::VLD4DUPdWB_register_Asm_32: Spacing = 1; return ARM::VLD4DUPd32_UPD; 5729 case ARM::VLD4DUPqWB_register_Asm_8: Spacing = 2; return ARM::VLD4DUPq8_UPD; 5730 case ARM::VLD4DUPqWB_register_Asm_16: Spacing = 2; return ARM::VLD4DUPq16_UPD; 5731 case ARM::VLD4DUPqWB_register_Asm_32: Spacing = 2; return ARM::VLD4DUPq32_UPD; 5732 case ARM::VLD4DUPdAsm_8: Spacing = 1; return ARM::VLD4DUPd8; 5733 case ARM::VLD4DUPdAsm_16: Spacing = 1; return ARM::VLD4DUPd16; 5734 case ARM::VLD4DUPdAsm_32: Spacing = 1; return ARM::VLD4DUPd32; 5735 case ARM::VLD4DUPqAsm_8: Spacing = 2; return ARM::VLD4DUPq8; 5736 case ARM::VLD4DUPqAsm_16: Spacing = 2; return ARM::VLD4DUPq16; 5737 case ARM::VLD4DUPqAsm_32: Spacing = 2; return ARM::VLD4DUPq32; 5738 5739 // VLD4 5740 case ARM::VLD4dWB_fixed_Asm_8: Spacing = 1; return ARM::VLD4d8_UPD; 5741 case ARM::VLD4dWB_fixed_Asm_16: Spacing = 1; return ARM::VLD4d16_UPD; 5742 case ARM::VLD4dWB_fixed_Asm_32: Spacing = 1; return ARM::VLD4d32_UPD; 5743 case ARM::VLD4qWB_fixed_Asm_8: Spacing = 2; return ARM::VLD4q8_UPD; 5744 case ARM::VLD4qWB_fixed_Asm_16: Spacing = 2; return ARM::VLD4q16_UPD; 5745 case ARM::VLD4qWB_fixed_Asm_32: Spacing = 2; return ARM::VLD4q32_UPD; 5746 case ARM::VLD4dWB_register_Asm_8: Spacing = 1; return ARM::VLD4d8_UPD; 5747 case ARM::VLD4dWB_register_Asm_16: Spacing = 1; return ARM::VLD4d16_UPD; 5748 case ARM::VLD4dWB_register_Asm_32: Spacing = 1; return ARM::VLD4d32_UPD; 5749 case ARM::VLD4qWB_register_Asm_8: Spacing = 2; return ARM::VLD4q8_UPD; 5750 case ARM::VLD4qWB_register_Asm_16: Spacing = 2; return ARM::VLD4q16_UPD; 5751 case ARM::VLD4qWB_register_Asm_32: Spacing = 2; return ARM::VLD4q32_UPD; 5752 case ARM::VLD4dAsm_8: Spacing = 1; return ARM::VLD4d8; 5753 case ARM::VLD4dAsm_16: Spacing = 1; return ARM::VLD4d16; 5754 case ARM::VLD4dAsm_32: Spacing = 1; return ARM::VLD4d32; 5755 case ARM::VLD4qAsm_8: Spacing = 2; return ARM::VLD4q8; 5756 case ARM::VLD4qAsm_16: Spacing = 2; return ARM::VLD4q16; 5757 case ARM::VLD4qAsm_32: Spacing = 2; return ARM::VLD4q32; 5758 } 5759 } 5760 5761 bool ARMAsmParser:: 5762 processInstruction(MCInst &Inst, 5763 const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 5764 switch (Inst.getOpcode()) { 5765 // Alias for alternate form of 'ADR Rd, #imm' instruction. 5766 case ARM::ADDri: { 5767 if (Inst.getOperand(1).getReg() != ARM::PC || 5768 Inst.getOperand(5).getReg() != 0) 5769 return false; 5770 MCInst TmpInst; 5771 TmpInst.setOpcode(ARM::ADR); 5772 TmpInst.addOperand(Inst.getOperand(0)); 5773 TmpInst.addOperand(Inst.getOperand(2)); 5774 TmpInst.addOperand(Inst.getOperand(3)); 5775 TmpInst.addOperand(Inst.getOperand(4)); 5776 Inst = TmpInst; 5777 return true; 5778 } 5779 // Aliases for alternate PC+imm syntax of LDR instructions. 5780 case ARM::t2LDRpcrel: 5781 // Select the narrow version if the immediate will fit. 5782 if (Inst.getOperand(1).getImm() > 0 && 5783 Inst.getOperand(1).getImm() <= 0xff && 5784 !(static_cast<ARMOperand*>(Operands[2])->isToken() && 5785 static_cast<ARMOperand*>(Operands[2])->getToken() == ".w")) 5786 Inst.setOpcode(ARM::tLDRpci); 5787 else 5788 Inst.setOpcode(ARM::t2LDRpci); 5789 return true; 5790 case ARM::t2LDRBpcrel: 5791 Inst.setOpcode(ARM::t2LDRBpci); 5792 return true; 5793 case ARM::t2LDRHpcrel: 5794 Inst.setOpcode(ARM::t2LDRHpci); 5795 return true; 5796 case ARM::t2LDRSBpcrel: 5797 Inst.setOpcode(ARM::t2LDRSBpci); 5798 return true; 5799 case ARM::t2LDRSHpcrel: 5800 Inst.setOpcode(ARM::t2LDRSHpci); 5801 return true; 5802 // Handle NEON VST complex aliases. 5803 case ARM::VST1LNdWB_register_Asm_8: 5804 case ARM::VST1LNdWB_register_Asm_16: 5805 case ARM::VST1LNdWB_register_Asm_32: { 5806 MCInst TmpInst; 5807 // Shuffle the operands around so the lane index operand is in the 5808 // right place. 5809 unsigned Spacing; 5810 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 5811 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 5812 TmpInst.addOperand(Inst.getOperand(2)); // Rn 5813 TmpInst.addOperand(Inst.getOperand(3)); // alignment 5814 TmpInst.addOperand(Inst.getOperand(4)); // Rm 5815 TmpInst.addOperand(Inst.getOperand(0)); // Vd 5816 TmpInst.addOperand(Inst.getOperand(1)); // lane 5817 TmpInst.addOperand(Inst.getOperand(5)); // CondCode 5818 TmpInst.addOperand(Inst.getOperand(6)); 5819 Inst = TmpInst; 5820 return true; 5821 } 5822 5823 case ARM::VST2LNdWB_register_Asm_8: 5824 case ARM::VST2LNdWB_register_Asm_16: 5825 case ARM::VST2LNdWB_register_Asm_32: 5826 case ARM::VST2LNqWB_register_Asm_16: 5827 case ARM::VST2LNqWB_register_Asm_32: { 5828 MCInst TmpInst; 5829 // Shuffle the operands around so the lane index operand is in the 5830 // right place. 5831 unsigned Spacing; 5832 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 5833 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 5834 TmpInst.addOperand(Inst.getOperand(2)); // Rn 5835 TmpInst.addOperand(Inst.getOperand(3)); // alignment 5836 TmpInst.addOperand(Inst.getOperand(4)); // Rm 5837 TmpInst.addOperand(Inst.getOperand(0)); // Vd 5838 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 5839 Spacing)); 5840 TmpInst.addOperand(Inst.getOperand(1)); // lane 5841 TmpInst.addOperand(Inst.getOperand(5)); // CondCode 5842 TmpInst.addOperand(Inst.getOperand(6)); 5843 Inst = TmpInst; 5844 return true; 5845 } 5846 5847 case ARM::VST3LNdWB_register_Asm_8: 5848 case ARM::VST3LNdWB_register_Asm_16: 5849 case ARM::VST3LNdWB_register_Asm_32: 5850 case ARM::VST3LNqWB_register_Asm_16: 5851 case ARM::VST3LNqWB_register_Asm_32: { 5852 MCInst TmpInst; 5853 // Shuffle the operands around so the lane index operand is in the 5854 // right place. 5855 unsigned Spacing; 5856 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 5857 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 5858 TmpInst.addOperand(Inst.getOperand(2)); // Rn 5859 TmpInst.addOperand(Inst.getOperand(3)); // alignment 5860 TmpInst.addOperand(Inst.getOperand(4)); // Rm 5861 TmpInst.addOperand(Inst.getOperand(0)); // Vd 5862 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 5863 Spacing)); 5864 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 5865 Spacing * 2)); 5866 TmpInst.addOperand(Inst.getOperand(1)); // lane 5867 TmpInst.addOperand(Inst.getOperand(5)); // CondCode 5868 TmpInst.addOperand(Inst.getOperand(6)); 5869 Inst = TmpInst; 5870 return true; 5871 } 5872 5873 case ARM::VST4LNdWB_register_Asm_8: 5874 case ARM::VST4LNdWB_register_Asm_16: 5875 case ARM::VST4LNdWB_register_Asm_32: 5876 case ARM::VST4LNqWB_register_Asm_16: 5877 case ARM::VST4LNqWB_register_Asm_32: { 5878 MCInst TmpInst; 5879 // Shuffle the operands around so the lane index operand is in the 5880 // right place. 5881 unsigned Spacing; 5882 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 5883 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 5884 TmpInst.addOperand(Inst.getOperand(2)); // Rn 5885 TmpInst.addOperand(Inst.getOperand(3)); // alignment 5886 TmpInst.addOperand(Inst.getOperand(4)); // Rm 5887 TmpInst.addOperand(Inst.getOperand(0)); // Vd 5888 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 5889 Spacing)); 5890 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 5891 Spacing * 2)); 5892 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 5893 Spacing * 3)); 5894 TmpInst.addOperand(Inst.getOperand(1)); // lane 5895 TmpInst.addOperand(Inst.getOperand(5)); // CondCode 5896 TmpInst.addOperand(Inst.getOperand(6)); 5897 Inst = TmpInst; 5898 return true; 5899 } 5900 5901 case ARM::VST1LNdWB_fixed_Asm_8: 5902 case ARM::VST1LNdWB_fixed_Asm_16: 5903 case ARM::VST1LNdWB_fixed_Asm_32: { 5904 MCInst TmpInst; 5905 // Shuffle the operands around so the lane index operand is in the 5906 // right place. 5907 unsigned Spacing; 5908 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 5909 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 5910 TmpInst.addOperand(Inst.getOperand(2)); // Rn 5911 TmpInst.addOperand(Inst.getOperand(3)); // alignment 5912 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 5913 TmpInst.addOperand(Inst.getOperand(0)); // Vd 5914 TmpInst.addOperand(Inst.getOperand(1)); // lane 5915 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 5916 TmpInst.addOperand(Inst.getOperand(5)); 5917 Inst = TmpInst; 5918 return true; 5919 } 5920 5921 case ARM::VST2LNdWB_fixed_Asm_8: 5922 case ARM::VST2LNdWB_fixed_Asm_16: 5923 case ARM::VST2LNdWB_fixed_Asm_32: 5924 case ARM::VST2LNqWB_fixed_Asm_16: 5925 case ARM::VST2LNqWB_fixed_Asm_32: { 5926 MCInst TmpInst; 5927 // Shuffle the operands around so the lane index operand is in the 5928 // right place. 5929 unsigned Spacing; 5930 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 5931 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 5932 TmpInst.addOperand(Inst.getOperand(2)); // Rn 5933 TmpInst.addOperand(Inst.getOperand(3)); // alignment 5934 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 5935 TmpInst.addOperand(Inst.getOperand(0)); // Vd 5936 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 5937 Spacing)); 5938 TmpInst.addOperand(Inst.getOperand(1)); // lane 5939 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 5940 TmpInst.addOperand(Inst.getOperand(5)); 5941 Inst = TmpInst; 5942 return true; 5943 } 5944 5945 case ARM::VST3LNdWB_fixed_Asm_8: 5946 case ARM::VST3LNdWB_fixed_Asm_16: 5947 case ARM::VST3LNdWB_fixed_Asm_32: 5948 case ARM::VST3LNqWB_fixed_Asm_16: 5949 case ARM::VST3LNqWB_fixed_Asm_32: { 5950 MCInst TmpInst; 5951 // Shuffle the operands around so the lane index operand is in the 5952 // right place. 5953 unsigned Spacing; 5954 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 5955 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 5956 TmpInst.addOperand(Inst.getOperand(2)); // Rn 5957 TmpInst.addOperand(Inst.getOperand(3)); // alignment 5958 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 5959 TmpInst.addOperand(Inst.getOperand(0)); // Vd 5960 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 5961 Spacing)); 5962 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 5963 Spacing * 2)); 5964 TmpInst.addOperand(Inst.getOperand(1)); // lane 5965 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 5966 TmpInst.addOperand(Inst.getOperand(5)); 5967 Inst = TmpInst; 5968 return true; 5969 } 5970 5971 case ARM::VST4LNdWB_fixed_Asm_8: 5972 case ARM::VST4LNdWB_fixed_Asm_16: 5973 case ARM::VST4LNdWB_fixed_Asm_32: 5974 case ARM::VST4LNqWB_fixed_Asm_16: 5975 case ARM::VST4LNqWB_fixed_Asm_32: { 5976 MCInst TmpInst; 5977 // Shuffle the operands around so the lane index operand is in the 5978 // right place. 5979 unsigned Spacing; 5980 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 5981 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 5982 TmpInst.addOperand(Inst.getOperand(2)); // Rn 5983 TmpInst.addOperand(Inst.getOperand(3)); // alignment 5984 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 5985 TmpInst.addOperand(Inst.getOperand(0)); // Vd 5986 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 5987 Spacing)); 5988 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 5989 Spacing * 2)); 5990 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 5991 Spacing * 3)); 5992 TmpInst.addOperand(Inst.getOperand(1)); // lane 5993 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 5994 TmpInst.addOperand(Inst.getOperand(5)); 5995 Inst = TmpInst; 5996 return true; 5997 } 5998 5999 case ARM::VST1LNdAsm_8: 6000 case ARM::VST1LNdAsm_16: 6001 case ARM::VST1LNdAsm_32: { 6002 MCInst TmpInst; 6003 // Shuffle the operands around so the lane index operand is in the 6004 // right place. 6005 unsigned Spacing; 6006 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 6007 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6008 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6009 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6010 TmpInst.addOperand(Inst.getOperand(1)); // lane 6011 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6012 TmpInst.addOperand(Inst.getOperand(5)); 6013 Inst = TmpInst; 6014 return true; 6015 } 6016 6017 case ARM::VST2LNdAsm_8: 6018 case ARM::VST2LNdAsm_16: 6019 case ARM::VST2LNdAsm_32: 6020 case ARM::VST2LNqAsm_16: 6021 case ARM::VST2LNqAsm_32: { 6022 MCInst TmpInst; 6023 // Shuffle the operands around so the lane index operand is in the 6024 // right place. 6025 unsigned Spacing; 6026 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 6027 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6028 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6029 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6030 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6031 Spacing)); 6032 TmpInst.addOperand(Inst.getOperand(1)); // lane 6033 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6034 TmpInst.addOperand(Inst.getOperand(5)); 6035 Inst = TmpInst; 6036 return true; 6037 } 6038 6039 case ARM::VST3LNdAsm_8: 6040 case ARM::VST3LNdAsm_16: 6041 case ARM::VST3LNdAsm_32: 6042 case ARM::VST3LNqAsm_16: 6043 case ARM::VST3LNqAsm_32: { 6044 MCInst TmpInst; 6045 // Shuffle the operands around so the lane index operand is in the 6046 // right place. 6047 unsigned Spacing; 6048 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 6049 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6050 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6051 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6052 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6053 Spacing)); 6054 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6055 Spacing * 2)); 6056 TmpInst.addOperand(Inst.getOperand(1)); // lane 6057 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6058 TmpInst.addOperand(Inst.getOperand(5)); 6059 Inst = TmpInst; 6060 return true; 6061 } 6062 6063 case ARM::VST4LNdAsm_8: 6064 case ARM::VST4LNdAsm_16: 6065 case ARM::VST4LNdAsm_32: 6066 case ARM::VST4LNqAsm_16: 6067 case ARM::VST4LNqAsm_32: { 6068 MCInst TmpInst; 6069 // Shuffle the operands around so the lane index operand is in the 6070 // right place. 6071 unsigned Spacing; 6072 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 6073 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6074 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6075 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6076 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6077 Spacing)); 6078 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6079 Spacing * 2)); 6080 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6081 Spacing * 3)); 6082 TmpInst.addOperand(Inst.getOperand(1)); // lane 6083 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6084 TmpInst.addOperand(Inst.getOperand(5)); 6085 Inst = TmpInst; 6086 return true; 6087 } 6088 6089 // Handle NEON VLD complex aliases. 6090 case ARM::VLD1LNdWB_register_Asm_8: 6091 case ARM::VLD1LNdWB_register_Asm_16: 6092 case ARM::VLD1LNdWB_register_Asm_32: { 6093 MCInst TmpInst; 6094 // Shuffle the operands around so the lane index operand is in the 6095 // right place. 6096 unsigned Spacing; 6097 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6098 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6099 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 6100 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6101 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6102 TmpInst.addOperand(Inst.getOperand(4)); // Rm 6103 TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd) 6104 TmpInst.addOperand(Inst.getOperand(1)); // lane 6105 TmpInst.addOperand(Inst.getOperand(5)); // CondCode 6106 TmpInst.addOperand(Inst.getOperand(6)); 6107 Inst = TmpInst; 6108 return true; 6109 } 6110 6111 case ARM::VLD2LNdWB_register_Asm_8: 6112 case ARM::VLD2LNdWB_register_Asm_16: 6113 case ARM::VLD2LNdWB_register_Asm_32: 6114 case ARM::VLD2LNqWB_register_Asm_16: 6115 case ARM::VLD2LNqWB_register_Asm_32: { 6116 MCInst TmpInst; 6117 // Shuffle the operands around so the lane index operand is in the 6118 // right place. 6119 unsigned Spacing; 6120 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6121 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6122 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6123 Spacing)); 6124 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 6125 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6126 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6127 TmpInst.addOperand(Inst.getOperand(4)); // Rm 6128 TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd) 6129 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6130 Spacing)); 6131 TmpInst.addOperand(Inst.getOperand(1)); // lane 6132 TmpInst.addOperand(Inst.getOperand(5)); // CondCode 6133 TmpInst.addOperand(Inst.getOperand(6)); 6134 Inst = TmpInst; 6135 return true; 6136 } 6137 6138 case ARM::VLD3LNdWB_register_Asm_8: 6139 case ARM::VLD3LNdWB_register_Asm_16: 6140 case ARM::VLD3LNdWB_register_Asm_32: 6141 case ARM::VLD3LNqWB_register_Asm_16: 6142 case ARM::VLD3LNqWB_register_Asm_32: { 6143 MCInst TmpInst; 6144 // Shuffle the operands around so the lane index operand is in the 6145 // right place. 6146 unsigned Spacing; 6147 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6148 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6149 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6150 Spacing)); 6151 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6152 Spacing * 2)); 6153 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 6154 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6155 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6156 TmpInst.addOperand(Inst.getOperand(4)); // Rm 6157 TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd) 6158 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6159 Spacing)); 6160 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6161 Spacing * 2)); 6162 TmpInst.addOperand(Inst.getOperand(1)); // lane 6163 TmpInst.addOperand(Inst.getOperand(5)); // CondCode 6164 TmpInst.addOperand(Inst.getOperand(6)); 6165 Inst = TmpInst; 6166 return true; 6167 } 6168 6169 case ARM::VLD4LNdWB_register_Asm_8: 6170 case ARM::VLD4LNdWB_register_Asm_16: 6171 case ARM::VLD4LNdWB_register_Asm_32: 6172 case ARM::VLD4LNqWB_register_Asm_16: 6173 case ARM::VLD4LNqWB_register_Asm_32: { 6174 MCInst TmpInst; 6175 // Shuffle the operands around so the lane index operand is in the 6176 // right place. 6177 unsigned Spacing; 6178 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6179 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6180 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6181 Spacing)); 6182 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6183 Spacing * 2)); 6184 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6185 Spacing * 3)); 6186 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 6187 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6188 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6189 TmpInst.addOperand(Inst.getOperand(4)); // Rm 6190 TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd) 6191 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6192 Spacing)); 6193 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6194 Spacing * 2)); 6195 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6196 Spacing * 3)); 6197 TmpInst.addOperand(Inst.getOperand(1)); // lane 6198 TmpInst.addOperand(Inst.getOperand(5)); // CondCode 6199 TmpInst.addOperand(Inst.getOperand(6)); 6200 Inst = TmpInst; 6201 return true; 6202 } 6203 6204 case ARM::VLD1LNdWB_fixed_Asm_8: 6205 case ARM::VLD1LNdWB_fixed_Asm_16: 6206 case ARM::VLD1LNdWB_fixed_Asm_32: { 6207 MCInst TmpInst; 6208 // Shuffle the operands around so the lane index operand is in the 6209 // right place. 6210 unsigned Spacing; 6211 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6212 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6213 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 6214 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6215 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6216 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 6217 TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd) 6218 TmpInst.addOperand(Inst.getOperand(1)); // lane 6219 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6220 TmpInst.addOperand(Inst.getOperand(5)); 6221 Inst = TmpInst; 6222 return true; 6223 } 6224 6225 case ARM::VLD2LNdWB_fixed_Asm_8: 6226 case ARM::VLD2LNdWB_fixed_Asm_16: 6227 case ARM::VLD2LNdWB_fixed_Asm_32: 6228 case ARM::VLD2LNqWB_fixed_Asm_16: 6229 case ARM::VLD2LNqWB_fixed_Asm_32: { 6230 MCInst TmpInst; 6231 // Shuffle the operands around so the lane index operand is in the 6232 // right place. 6233 unsigned Spacing; 6234 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6235 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6236 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6237 Spacing)); 6238 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 6239 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6240 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6241 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 6242 TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd) 6243 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6244 Spacing)); 6245 TmpInst.addOperand(Inst.getOperand(1)); // lane 6246 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6247 TmpInst.addOperand(Inst.getOperand(5)); 6248 Inst = TmpInst; 6249 return true; 6250 } 6251 6252 case ARM::VLD3LNdWB_fixed_Asm_8: 6253 case ARM::VLD3LNdWB_fixed_Asm_16: 6254 case ARM::VLD3LNdWB_fixed_Asm_32: 6255 case ARM::VLD3LNqWB_fixed_Asm_16: 6256 case ARM::VLD3LNqWB_fixed_Asm_32: { 6257 MCInst TmpInst; 6258 // Shuffle the operands around so the lane index operand is in the 6259 // right place. 6260 unsigned Spacing; 6261 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6262 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6263 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6264 Spacing)); 6265 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6266 Spacing * 2)); 6267 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 6268 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6269 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6270 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 6271 TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd) 6272 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6273 Spacing)); 6274 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6275 Spacing * 2)); 6276 TmpInst.addOperand(Inst.getOperand(1)); // lane 6277 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6278 TmpInst.addOperand(Inst.getOperand(5)); 6279 Inst = TmpInst; 6280 return true; 6281 } 6282 6283 case ARM::VLD4LNdWB_fixed_Asm_8: 6284 case ARM::VLD4LNdWB_fixed_Asm_16: 6285 case ARM::VLD4LNdWB_fixed_Asm_32: 6286 case ARM::VLD4LNqWB_fixed_Asm_16: 6287 case ARM::VLD4LNqWB_fixed_Asm_32: { 6288 MCInst TmpInst; 6289 // Shuffle the operands around so the lane index operand is in the 6290 // right place. 6291 unsigned Spacing; 6292 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6293 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6294 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6295 Spacing)); 6296 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6297 Spacing * 2)); 6298 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6299 Spacing * 3)); 6300 TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb 6301 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6302 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6303 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 6304 TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd) 6305 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6306 Spacing)); 6307 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6308 Spacing * 2)); 6309 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6310 Spacing * 3)); 6311 TmpInst.addOperand(Inst.getOperand(1)); // lane 6312 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6313 TmpInst.addOperand(Inst.getOperand(5)); 6314 Inst = TmpInst; 6315 return true; 6316 } 6317 6318 case ARM::VLD1LNdAsm_8: 6319 case ARM::VLD1LNdAsm_16: 6320 case ARM::VLD1LNdAsm_32: { 6321 MCInst TmpInst; 6322 // Shuffle the operands around so the lane index operand is in the 6323 // right place. 6324 unsigned Spacing; 6325 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6326 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6327 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6328 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6329 TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd) 6330 TmpInst.addOperand(Inst.getOperand(1)); // lane 6331 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6332 TmpInst.addOperand(Inst.getOperand(5)); 6333 Inst = TmpInst; 6334 return true; 6335 } 6336 6337 case ARM::VLD2LNdAsm_8: 6338 case ARM::VLD2LNdAsm_16: 6339 case ARM::VLD2LNdAsm_32: 6340 case ARM::VLD2LNqAsm_16: 6341 case ARM::VLD2LNqAsm_32: { 6342 MCInst TmpInst; 6343 // Shuffle the operands around so the lane index operand is in the 6344 // right place. 6345 unsigned Spacing; 6346 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6347 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6348 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6349 Spacing)); 6350 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6351 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6352 TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd) 6353 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6354 Spacing)); 6355 TmpInst.addOperand(Inst.getOperand(1)); // lane 6356 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6357 TmpInst.addOperand(Inst.getOperand(5)); 6358 Inst = TmpInst; 6359 return true; 6360 } 6361 6362 case ARM::VLD3LNdAsm_8: 6363 case ARM::VLD3LNdAsm_16: 6364 case ARM::VLD3LNdAsm_32: 6365 case ARM::VLD3LNqAsm_16: 6366 case ARM::VLD3LNqAsm_32: { 6367 MCInst TmpInst; 6368 // Shuffle the operands around so the lane index operand is in the 6369 // right place. 6370 unsigned Spacing; 6371 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6372 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6373 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6374 Spacing)); 6375 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6376 Spacing * 2)); 6377 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6378 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6379 TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd) 6380 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6381 Spacing)); 6382 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6383 Spacing * 2)); 6384 TmpInst.addOperand(Inst.getOperand(1)); // lane 6385 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6386 TmpInst.addOperand(Inst.getOperand(5)); 6387 Inst = TmpInst; 6388 return true; 6389 } 6390 6391 case ARM::VLD4LNdAsm_8: 6392 case ARM::VLD4LNdAsm_16: 6393 case ARM::VLD4LNdAsm_32: 6394 case ARM::VLD4LNqAsm_16: 6395 case ARM::VLD4LNqAsm_32: { 6396 MCInst TmpInst; 6397 // Shuffle the operands around so the lane index operand is in the 6398 // right place. 6399 unsigned Spacing; 6400 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6401 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6402 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6403 Spacing)); 6404 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6405 Spacing * 2)); 6406 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6407 Spacing * 3)); 6408 TmpInst.addOperand(Inst.getOperand(2)); // Rn 6409 TmpInst.addOperand(Inst.getOperand(3)); // alignment 6410 TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd) 6411 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6412 Spacing)); 6413 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6414 Spacing * 2)); 6415 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6416 Spacing * 3)); 6417 TmpInst.addOperand(Inst.getOperand(1)); // lane 6418 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6419 TmpInst.addOperand(Inst.getOperand(5)); 6420 Inst = TmpInst; 6421 return true; 6422 } 6423 6424 // VLD3DUP single 3-element structure to all lanes instructions. 6425 case ARM::VLD3DUPdAsm_8: 6426 case ARM::VLD3DUPdAsm_16: 6427 case ARM::VLD3DUPdAsm_32: 6428 case ARM::VLD3DUPqAsm_8: 6429 case ARM::VLD3DUPqAsm_16: 6430 case ARM::VLD3DUPqAsm_32: { 6431 MCInst TmpInst; 6432 unsigned Spacing; 6433 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6434 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6435 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6436 Spacing)); 6437 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6438 Spacing * 2)); 6439 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6440 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6441 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6442 TmpInst.addOperand(Inst.getOperand(4)); 6443 Inst = TmpInst; 6444 return true; 6445 } 6446 6447 case ARM::VLD3DUPdWB_fixed_Asm_8: 6448 case ARM::VLD3DUPdWB_fixed_Asm_16: 6449 case ARM::VLD3DUPdWB_fixed_Asm_32: 6450 case ARM::VLD3DUPqWB_fixed_Asm_8: 6451 case ARM::VLD3DUPqWB_fixed_Asm_16: 6452 case ARM::VLD3DUPqWB_fixed_Asm_32: { 6453 MCInst TmpInst; 6454 unsigned Spacing; 6455 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6456 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6457 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6458 Spacing)); 6459 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6460 Spacing * 2)); 6461 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6462 TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn 6463 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6464 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 6465 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6466 TmpInst.addOperand(Inst.getOperand(4)); 6467 Inst = TmpInst; 6468 return true; 6469 } 6470 6471 case ARM::VLD3DUPdWB_register_Asm_8: 6472 case ARM::VLD3DUPdWB_register_Asm_16: 6473 case ARM::VLD3DUPdWB_register_Asm_32: 6474 case ARM::VLD3DUPqWB_register_Asm_8: 6475 case ARM::VLD3DUPqWB_register_Asm_16: 6476 case ARM::VLD3DUPqWB_register_Asm_32: { 6477 MCInst TmpInst; 6478 unsigned Spacing; 6479 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6480 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6481 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6482 Spacing)); 6483 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6484 Spacing * 2)); 6485 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6486 TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn 6487 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6488 TmpInst.addOperand(Inst.getOperand(3)); // Rm 6489 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6490 TmpInst.addOperand(Inst.getOperand(5)); 6491 Inst = TmpInst; 6492 return true; 6493 } 6494 6495 // VLD3 multiple 3-element structure instructions. 6496 case ARM::VLD3dAsm_8: 6497 case ARM::VLD3dAsm_16: 6498 case ARM::VLD3dAsm_32: 6499 case ARM::VLD3qAsm_8: 6500 case ARM::VLD3qAsm_16: 6501 case ARM::VLD3qAsm_32: { 6502 MCInst TmpInst; 6503 unsigned Spacing; 6504 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6505 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6506 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6507 Spacing)); 6508 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6509 Spacing * 2)); 6510 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6511 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6512 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6513 TmpInst.addOperand(Inst.getOperand(4)); 6514 Inst = TmpInst; 6515 return true; 6516 } 6517 6518 case ARM::VLD3dWB_fixed_Asm_8: 6519 case ARM::VLD3dWB_fixed_Asm_16: 6520 case ARM::VLD3dWB_fixed_Asm_32: 6521 case ARM::VLD3qWB_fixed_Asm_8: 6522 case ARM::VLD3qWB_fixed_Asm_16: 6523 case ARM::VLD3qWB_fixed_Asm_32: { 6524 MCInst TmpInst; 6525 unsigned Spacing; 6526 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6527 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6528 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6529 Spacing)); 6530 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6531 Spacing * 2)); 6532 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6533 TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn 6534 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6535 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 6536 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6537 TmpInst.addOperand(Inst.getOperand(4)); 6538 Inst = TmpInst; 6539 return true; 6540 } 6541 6542 case ARM::VLD3dWB_register_Asm_8: 6543 case ARM::VLD3dWB_register_Asm_16: 6544 case ARM::VLD3dWB_register_Asm_32: 6545 case ARM::VLD3qWB_register_Asm_8: 6546 case ARM::VLD3qWB_register_Asm_16: 6547 case ARM::VLD3qWB_register_Asm_32: { 6548 MCInst TmpInst; 6549 unsigned Spacing; 6550 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6551 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6552 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6553 Spacing)); 6554 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6555 Spacing * 2)); 6556 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6557 TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn 6558 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6559 TmpInst.addOperand(Inst.getOperand(3)); // Rm 6560 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6561 TmpInst.addOperand(Inst.getOperand(5)); 6562 Inst = TmpInst; 6563 return true; 6564 } 6565 6566 // VLD4DUP single 3-element structure to all lanes instructions. 6567 case ARM::VLD4DUPdAsm_8: 6568 case ARM::VLD4DUPdAsm_16: 6569 case ARM::VLD4DUPdAsm_32: 6570 case ARM::VLD4DUPqAsm_8: 6571 case ARM::VLD4DUPqAsm_16: 6572 case ARM::VLD4DUPqAsm_32: { 6573 MCInst TmpInst; 6574 unsigned Spacing; 6575 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6576 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6577 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6578 Spacing)); 6579 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6580 Spacing * 2)); 6581 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6582 Spacing * 3)); 6583 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6584 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6585 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6586 TmpInst.addOperand(Inst.getOperand(4)); 6587 Inst = TmpInst; 6588 return true; 6589 } 6590 6591 case ARM::VLD4DUPdWB_fixed_Asm_8: 6592 case ARM::VLD4DUPdWB_fixed_Asm_16: 6593 case ARM::VLD4DUPdWB_fixed_Asm_32: 6594 case ARM::VLD4DUPqWB_fixed_Asm_8: 6595 case ARM::VLD4DUPqWB_fixed_Asm_16: 6596 case ARM::VLD4DUPqWB_fixed_Asm_32: { 6597 MCInst TmpInst; 6598 unsigned Spacing; 6599 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6600 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6601 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6602 Spacing)); 6603 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6604 Spacing * 2)); 6605 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6606 Spacing * 3)); 6607 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6608 TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn 6609 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6610 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 6611 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6612 TmpInst.addOperand(Inst.getOperand(4)); 6613 Inst = TmpInst; 6614 return true; 6615 } 6616 6617 case ARM::VLD4DUPdWB_register_Asm_8: 6618 case ARM::VLD4DUPdWB_register_Asm_16: 6619 case ARM::VLD4DUPdWB_register_Asm_32: 6620 case ARM::VLD4DUPqWB_register_Asm_8: 6621 case ARM::VLD4DUPqWB_register_Asm_16: 6622 case ARM::VLD4DUPqWB_register_Asm_32: { 6623 MCInst TmpInst; 6624 unsigned Spacing; 6625 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6626 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6627 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6628 Spacing)); 6629 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6630 Spacing * 2)); 6631 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6632 Spacing * 3)); 6633 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6634 TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn 6635 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6636 TmpInst.addOperand(Inst.getOperand(3)); // Rm 6637 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6638 TmpInst.addOperand(Inst.getOperand(5)); 6639 Inst = TmpInst; 6640 return true; 6641 } 6642 6643 // VLD4 multiple 4-element structure instructions. 6644 case ARM::VLD4dAsm_8: 6645 case ARM::VLD4dAsm_16: 6646 case ARM::VLD4dAsm_32: 6647 case ARM::VLD4qAsm_8: 6648 case ARM::VLD4qAsm_16: 6649 case ARM::VLD4qAsm_32: { 6650 MCInst TmpInst; 6651 unsigned Spacing; 6652 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6653 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6654 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6655 Spacing)); 6656 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6657 Spacing * 2)); 6658 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6659 Spacing * 3)); 6660 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6661 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6662 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6663 TmpInst.addOperand(Inst.getOperand(4)); 6664 Inst = TmpInst; 6665 return true; 6666 } 6667 6668 case ARM::VLD4dWB_fixed_Asm_8: 6669 case ARM::VLD4dWB_fixed_Asm_16: 6670 case ARM::VLD4dWB_fixed_Asm_32: 6671 case ARM::VLD4qWB_fixed_Asm_8: 6672 case ARM::VLD4qWB_fixed_Asm_16: 6673 case ARM::VLD4qWB_fixed_Asm_32: { 6674 MCInst TmpInst; 6675 unsigned Spacing; 6676 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6677 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6678 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6679 Spacing)); 6680 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6681 Spacing * 2)); 6682 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6683 Spacing * 3)); 6684 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6685 TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn 6686 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6687 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 6688 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6689 TmpInst.addOperand(Inst.getOperand(4)); 6690 Inst = TmpInst; 6691 return true; 6692 } 6693 6694 case ARM::VLD4dWB_register_Asm_8: 6695 case ARM::VLD4dWB_register_Asm_16: 6696 case ARM::VLD4dWB_register_Asm_32: 6697 case ARM::VLD4qWB_register_Asm_8: 6698 case ARM::VLD4qWB_register_Asm_16: 6699 case ARM::VLD4qWB_register_Asm_32: { 6700 MCInst TmpInst; 6701 unsigned Spacing; 6702 TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing)); 6703 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6704 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6705 Spacing)); 6706 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6707 Spacing * 2)); 6708 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6709 Spacing * 3)); 6710 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6711 TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn 6712 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6713 TmpInst.addOperand(Inst.getOperand(3)); // Rm 6714 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6715 TmpInst.addOperand(Inst.getOperand(5)); 6716 Inst = TmpInst; 6717 return true; 6718 } 6719 6720 // VST3 multiple 3-element structure instructions. 6721 case ARM::VST3dAsm_8: 6722 case ARM::VST3dAsm_16: 6723 case ARM::VST3dAsm_32: 6724 case ARM::VST3qAsm_8: 6725 case ARM::VST3qAsm_16: 6726 case ARM::VST3qAsm_32: { 6727 MCInst TmpInst; 6728 unsigned Spacing; 6729 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 6730 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6731 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6732 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6733 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6734 Spacing)); 6735 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6736 Spacing * 2)); 6737 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6738 TmpInst.addOperand(Inst.getOperand(4)); 6739 Inst = TmpInst; 6740 return true; 6741 } 6742 6743 case ARM::VST3dWB_fixed_Asm_8: 6744 case ARM::VST3dWB_fixed_Asm_16: 6745 case ARM::VST3dWB_fixed_Asm_32: 6746 case ARM::VST3qWB_fixed_Asm_8: 6747 case ARM::VST3qWB_fixed_Asm_16: 6748 case ARM::VST3qWB_fixed_Asm_32: { 6749 MCInst TmpInst; 6750 unsigned Spacing; 6751 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 6752 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6753 TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn 6754 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6755 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 6756 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6757 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6758 Spacing)); 6759 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6760 Spacing * 2)); 6761 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6762 TmpInst.addOperand(Inst.getOperand(4)); 6763 Inst = TmpInst; 6764 return true; 6765 } 6766 6767 case ARM::VST3dWB_register_Asm_8: 6768 case ARM::VST3dWB_register_Asm_16: 6769 case ARM::VST3dWB_register_Asm_32: 6770 case ARM::VST3qWB_register_Asm_8: 6771 case ARM::VST3qWB_register_Asm_16: 6772 case ARM::VST3qWB_register_Asm_32: { 6773 MCInst TmpInst; 6774 unsigned Spacing; 6775 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 6776 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6777 TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn 6778 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6779 TmpInst.addOperand(Inst.getOperand(3)); // Rm 6780 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6781 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6782 Spacing)); 6783 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6784 Spacing * 2)); 6785 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6786 TmpInst.addOperand(Inst.getOperand(5)); 6787 Inst = TmpInst; 6788 return true; 6789 } 6790 6791 // VST4 multiple 3-element structure instructions. 6792 case ARM::VST4dAsm_8: 6793 case ARM::VST4dAsm_16: 6794 case ARM::VST4dAsm_32: 6795 case ARM::VST4qAsm_8: 6796 case ARM::VST4qAsm_16: 6797 case ARM::VST4qAsm_32: { 6798 MCInst TmpInst; 6799 unsigned Spacing; 6800 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 6801 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6802 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6803 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6804 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6805 Spacing)); 6806 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6807 Spacing * 2)); 6808 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6809 Spacing * 3)); 6810 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6811 TmpInst.addOperand(Inst.getOperand(4)); 6812 Inst = TmpInst; 6813 return true; 6814 } 6815 6816 case ARM::VST4dWB_fixed_Asm_8: 6817 case ARM::VST4dWB_fixed_Asm_16: 6818 case ARM::VST4dWB_fixed_Asm_32: 6819 case ARM::VST4qWB_fixed_Asm_8: 6820 case ARM::VST4qWB_fixed_Asm_16: 6821 case ARM::VST4qWB_fixed_Asm_32: { 6822 MCInst TmpInst; 6823 unsigned Spacing; 6824 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 6825 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6826 TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn 6827 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6828 TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm 6829 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6830 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6831 Spacing)); 6832 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6833 Spacing * 2)); 6834 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6835 Spacing * 3)); 6836 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6837 TmpInst.addOperand(Inst.getOperand(4)); 6838 Inst = TmpInst; 6839 return true; 6840 } 6841 6842 case ARM::VST4dWB_register_Asm_8: 6843 case ARM::VST4dWB_register_Asm_16: 6844 case ARM::VST4dWB_register_Asm_32: 6845 case ARM::VST4qWB_register_Asm_8: 6846 case ARM::VST4qWB_register_Asm_16: 6847 case ARM::VST4qWB_register_Asm_32: { 6848 MCInst TmpInst; 6849 unsigned Spacing; 6850 TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing)); 6851 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6852 TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn 6853 TmpInst.addOperand(Inst.getOperand(2)); // alignment 6854 TmpInst.addOperand(Inst.getOperand(3)); // Rm 6855 TmpInst.addOperand(Inst.getOperand(0)); // Vd 6856 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6857 Spacing)); 6858 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6859 Spacing * 2)); 6860 TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() + 6861 Spacing * 3)); 6862 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6863 TmpInst.addOperand(Inst.getOperand(5)); 6864 Inst = TmpInst; 6865 return true; 6866 } 6867 6868 // Handle encoding choice for the shift-immediate instructions. 6869 case ARM::t2LSLri: 6870 case ARM::t2LSRri: 6871 case ARM::t2ASRri: { 6872 if (isARMLowRegister(Inst.getOperand(0).getReg()) && 6873 Inst.getOperand(0).getReg() == Inst.getOperand(1).getReg() && 6874 Inst.getOperand(5).getReg() == (inITBlock() ? 0 : ARM::CPSR) && 6875 !(static_cast<ARMOperand*>(Operands[3])->isToken() && 6876 static_cast<ARMOperand*>(Operands[3])->getToken() == ".w")) { 6877 unsigned NewOpc; 6878 switch (Inst.getOpcode()) { 6879 default: llvm_unreachable("unexpected opcode"); 6880 case ARM::t2LSLri: NewOpc = ARM::tLSLri; break; 6881 case ARM::t2LSRri: NewOpc = ARM::tLSRri; break; 6882 case ARM::t2ASRri: NewOpc = ARM::tASRri; break; 6883 } 6884 // The Thumb1 operands aren't in the same order. Awesome, eh? 6885 MCInst TmpInst; 6886 TmpInst.setOpcode(NewOpc); 6887 TmpInst.addOperand(Inst.getOperand(0)); 6888 TmpInst.addOperand(Inst.getOperand(5)); 6889 TmpInst.addOperand(Inst.getOperand(1)); 6890 TmpInst.addOperand(Inst.getOperand(2)); 6891 TmpInst.addOperand(Inst.getOperand(3)); 6892 TmpInst.addOperand(Inst.getOperand(4)); 6893 Inst = TmpInst; 6894 return true; 6895 } 6896 return false; 6897 } 6898 6899 // Handle the Thumb2 mode MOV complex aliases. 6900 case ARM::t2MOVsr: 6901 case ARM::t2MOVSsr: { 6902 // Which instruction to expand to depends on the CCOut operand and 6903 // whether we're in an IT block if the register operands are low 6904 // registers. 6905 bool isNarrow = false; 6906 if (isARMLowRegister(Inst.getOperand(0).getReg()) && 6907 isARMLowRegister(Inst.getOperand(1).getReg()) && 6908 isARMLowRegister(Inst.getOperand(2).getReg()) && 6909 Inst.getOperand(0).getReg() == Inst.getOperand(1).getReg() && 6910 inITBlock() == (Inst.getOpcode() == ARM::t2MOVsr)) 6911 isNarrow = true; 6912 MCInst TmpInst; 6913 unsigned newOpc; 6914 switch(ARM_AM::getSORegShOp(Inst.getOperand(3).getImm())) { 6915 default: llvm_unreachable("unexpected opcode!"); 6916 case ARM_AM::asr: newOpc = isNarrow ? ARM::tASRrr : ARM::t2ASRrr; break; 6917 case ARM_AM::lsr: newOpc = isNarrow ? ARM::tLSRrr : ARM::t2LSRrr; break; 6918 case ARM_AM::lsl: newOpc = isNarrow ? ARM::tLSLrr : ARM::t2LSLrr; break; 6919 case ARM_AM::ror: newOpc = isNarrow ? ARM::tROR : ARM::t2RORrr; break; 6920 } 6921 TmpInst.setOpcode(newOpc); 6922 TmpInst.addOperand(Inst.getOperand(0)); // Rd 6923 if (isNarrow) 6924 TmpInst.addOperand(MCOperand::CreateReg( 6925 Inst.getOpcode() == ARM::t2MOVSsr ? ARM::CPSR : 0)); 6926 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6927 TmpInst.addOperand(Inst.getOperand(2)); // Rm 6928 TmpInst.addOperand(Inst.getOperand(4)); // CondCode 6929 TmpInst.addOperand(Inst.getOperand(5)); 6930 if (!isNarrow) 6931 TmpInst.addOperand(MCOperand::CreateReg( 6932 Inst.getOpcode() == ARM::t2MOVSsr ? ARM::CPSR : 0)); 6933 Inst = TmpInst; 6934 return true; 6935 } 6936 case ARM::t2MOVsi: 6937 case ARM::t2MOVSsi: { 6938 // Which instruction to expand to depends on the CCOut operand and 6939 // whether we're in an IT block if the register operands are low 6940 // registers. 6941 bool isNarrow = false; 6942 if (isARMLowRegister(Inst.getOperand(0).getReg()) && 6943 isARMLowRegister(Inst.getOperand(1).getReg()) && 6944 inITBlock() == (Inst.getOpcode() == ARM::t2MOVsi)) 6945 isNarrow = true; 6946 MCInst TmpInst; 6947 unsigned newOpc; 6948 switch(ARM_AM::getSORegShOp(Inst.getOperand(2).getImm())) { 6949 default: llvm_unreachable("unexpected opcode!"); 6950 case ARM_AM::asr: newOpc = isNarrow ? ARM::tASRri : ARM::t2ASRri; break; 6951 case ARM_AM::lsr: newOpc = isNarrow ? ARM::tLSRri : ARM::t2LSRri; break; 6952 case ARM_AM::lsl: newOpc = isNarrow ? ARM::tLSLri : ARM::t2LSLri; break; 6953 case ARM_AM::ror: newOpc = ARM::t2RORri; isNarrow = false; break; 6954 case ARM_AM::rrx: isNarrow = false; newOpc = ARM::t2RRX; break; 6955 } 6956 unsigned Amount = ARM_AM::getSORegOffset(Inst.getOperand(2).getImm()); 6957 if (Amount == 32) Amount = 0; 6958 TmpInst.setOpcode(newOpc); 6959 TmpInst.addOperand(Inst.getOperand(0)); // Rd 6960 if (isNarrow) 6961 TmpInst.addOperand(MCOperand::CreateReg( 6962 Inst.getOpcode() == ARM::t2MOVSsi ? ARM::CPSR : 0)); 6963 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6964 if (newOpc != ARM::t2RRX) 6965 TmpInst.addOperand(MCOperand::CreateImm(Amount)); 6966 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6967 TmpInst.addOperand(Inst.getOperand(4)); 6968 if (!isNarrow) 6969 TmpInst.addOperand(MCOperand::CreateReg( 6970 Inst.getOpcode() == ARM::t2MOVSsi ? ARM::CPSR : 0)); 6971 Inst = TmpInst; 6972 return true; 6973 } 6974 // Handle the ARM mode MOV complex aliases. 6975 case ARM::ASRr: 6976 case ARM::LSRr: 6977 case ARM::LSLr: 6978 case ARM::RORr: { 6979 ARM_AM::ShiftOpc ShiftTy; 6980 switch(Inst.getOpcode()) { 6981 default: llvm_unreachable("unexpected opcode!"); 6982 case ARM::ASRr: ShiftTy = ARM_AM::asr; break; 6983 case ARM::LSRr: ShiftTy = ARM_AM::lsr; break; 6984 case ARM::LSLr: ShiftTy = ARM_AM::lsl; break; 6985 case ARM::RORr: ShiftTy = ARM_AM::ror; break; 6986 } 6987 unsigned Shifter = ARM_AM::getSORegOpc(ShiftTy, 0); 6988 MCInst TmpInst; 6989 TmpInst.setOpcode(ARM::MOVsr); 6990 TmpInst.addOperand(Inst.getOperand(0)); // Rd 6991 TmpInst.addOperand(Inst.getOperand(1)); // Rn 6992 TmpInst.addOperand(Inst.getOperand(2)); // Rm 6993 TmpInst.addOperand(MCOperand::CreateImm(Shifter)); // Shift value and ty 6994 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 6995 TmpInst.addOperand(Inst.getOperand(4)); 6996 TmpInst.addOperand(Inst.getOperand(5)); // cc_out 6997 Inst = TmpInst; 6998 return true; 6999 } 7000 case ARM::ASRi: 7001 case ARM::LSRi: 7002 case ARM::LSLi: 7003 case ARM::RORi: { 7004 ARM_AM::ShiftOpc ShiftTy; 7005 switch(Inst.getOpcode()) { 7006 default: llvm_unreachable("unexpected opcode!"); 7007 case ARM::ASRi: ShiftTy = ARM_AM::asr; break; 7008 case ARM::LSRi: ShiftTy = ARM_AM::lsr; break; 7009 case ARM::LSLi: ShiftTy = ARM_AM::lsl; break; 7010 case ARM::RORi: ShiftTy = ARM_AM::ror; break; 7011 } 7012 // A shift by zero is a plain MOVr, not a MOVsi. 7013 unsigned Amt = Inst.getOperand(2).getImm(); 7014 unsigned Opc = Amt == 0 ? ARM::MOVr : ARM::MOVsi; 7015 // A shift by 32 should be encoded as 0 when permitted 7016 if (Amt == 32 && (ShiftTy == ARM_AM::lsr || ShiftTy == ARM_AM::asr)) 7017 Amt = 0; 7018 unsigned Shifter = ARM_AM::getSORegOpc(ShiftTy, Amt); 7019 MCInst TmpInst; 7020 TmpInst.setOpcode(Opc); 7021 TmpInst.addOperand(Inst.getOperand(0)); // Rd 7022 TmpInst.addOperand(Inst.getOperand(1)); // Rn 7023 if (Opc == ARM::MOVsi) 7024 TmpInst.addOperand(MCOperand::CreateImm(Shifter)); // Shift value and ty 7025 TmpInst.addOperand(Inst.getOperand(3)); // CondCode 7026 TmpInst.addOperand(Inst.getOperand(4)); 7027 TmpInst.addOperand(Inst.getOperand(5)); // cc_out 7028 Inst = TmpInst; 7029 return true; 7030 } 7031 case ARM::RRXi: { 7032 unsigned Shifter = ARM_AM::getSORegOpc(ARM_AM::rrx, 0); 7033 MCInst TmpInst; 7034 TmpInst.setOpcode(ARM::MOVsi); 7035 TmpInst.addOperand(Inst.getOperand(0)); // Rd 7036 TmpInst.addOperand(Inst.getOperand(1)); // Rn 7037 TmpInst.addOperand(MCOperand::CreateImm(Shifter)); // Shift value and ty 7038 TmpInst.addOperand(Inst.getOperand(2)); // CondCode 7039 TmpInst.addOperand(Inst.getOperand(3)); 7040 TmpInst.addOperand(Inst.getOperand(4)); // cc_out 7041 Inst = TmpInst; 7042 return true; 7043 } 7044 case ARM::t2LDMIA_UPD: { 7045 // If this is a load of a single register, then we should use 7046 // a post-indexed LDR instruction instead, per the ARM ARM. 7047 if (Inst.getNumOperands() != 5) 7048 return false; 7049 MCInst TmpInst; 7050 TmpInst.setOpcode(ARM::t2LDR_POST); 7051 TmpInst.addOperand(Inst.getOperand(4)); // Rt 7052 TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb 7053 TmpInst.addOperand(Inst.getOperand(1)); // Rn 7054 TmpInst.addOperand(MCOperand::CreateImm(4)); 7055 TmpInst.addOperand(Inst.getOperand(2)); // CondCode 7056 TmpInst.addOperand(Inst.getOperand(3)); 7057 Inst = TmpInst; 7058 return true; 7059 } 7060 case ARM::t2STMDB_UPD: { 7061 // If this is a store of a single register, then we should use 7062 // a pre-indexed STR instruction instead, per the ARM ARM. 7063 if (Inst.getNumOperands() != 5) 7064 return false; 7065 MCInst TmpInst; 7066 TmpInst.setOpcode(ARM::t2STR_PRE); 7067 TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb 7068 TmpInst.addOperand(Inst.getOperand(4)); // Rt 7069 TmpInst.addOperand(Inst.getOperand(1)); // Rn 7070 TmpInst.addOperand(MCOperand::CreateImm(-4)); 7071 TmpInst.addOperand(Inst.getOperand(2)); // CondCode 7072 TmpInst.addOperand(Inst.getOperand(3)); 7073 Inst = TmpInst; 7074 return true; 7075 } 7076 case ARM::LDMIA_UPD: 7077 // If this is a load of a single register via a 'pop', then we should use 7078 // a post-indexed LDR instruction instead, per the ARM ARM. 7079 if (static_cast<ARMOperand*>(Operands[0])->getToken() == "pop" && 7080 Inst.getNumOperands() == 5) { 7081 MCInst TmpInst; 7082 TmpInst.setOpcode(ARM::LDR_POST_IMM); 7083 TmpInst.addOperand(Inst.getOperand(4)); // Rt 7084 TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb 7085 TmpInst.addOperand(Inst.getOperand(1)); // Rn 7086 TmpInst.addOperand(MCOperand::CreateReg(0)); // am2offset 7087 TmpInst.addOperand(MCOperand::CreateImm(4)); 7088 TmpInst.addOperand(Inst.getOperand(2)); // CondCode 7089 TmpInst.addOperand(Inst.getOperand(3)); 7090 Inst = TmpInst; 7091 return true; 7092 } 7093 break; 7094 case ARM::STMDB_UPD: 7095 // If this is a store of a single register via a 'push', then we should use 7096 // a pre-indexed STR instruction instead, per the ARM ARM. 7097 if (static_cast<ARMOperand*>(Operands[0])->getToken() == "push" && 7098 Inst.getNumOperands() == 5) { 7099 MCInst TmpInst; 7100 TmpInst.setOpcode(ARM::STR_PRE_IMM); 7101 TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb 7102 TmpInst.addOperand(Inst.getOperand(4)); // Rt 7103 TmpInst.addOperand(Inst.getOperand(1)); // addrmode_imm12 7104 TmpInst.addOperand(MCOperand::CreateImm(-4)); 7105 TmpInst.addOperand(Inst.getOperand(2)); // CondCode 7106 TmpInst.addOperand(Inst.getOperand(3)); 7107 Inst = TmpInst; 7108 } 7109 break; 7110 case ARM::t2ADDri12: 7111 // If the immediate fits for encoding T3 (t2ADDri) and the generic "add" 7112 // mnemonic was used (not "addw"), encoding T3 is preferred. 7113 if (static_cast<ARMOperand*>(Operands[0])->getToken() != "add" || 7114 ARM_AM::getT2SOImmVal(Inst.getOperand(2).getImm()) == -1) 7115 break; 7116 Inst.setOpcode(ARM::t2ADDri); 7117 Inst.addOperand(MCOperand::CreateReg(0)); // cc_out 7118 break; 7119 case ARM::t2SUBri12: 7120 // If the immediate fits for encoding T3 (t2SUBri) and the generic "sub" 7121 // mnemonic was used (not "subw"), encoding T3 is preferred. 7122 if (static_cast<ARMOperand*>(Operands[0])->getToken() != "sub" || 7123 ARM_AM::getT2SOImmVal(Inst.getOperand(2).getImm()) == -1) 7124 break; 7125 Inst.setOpcode(ARM::t2SUBri); 7126 Inst.addOperand(MCOperand::CreateReg(0)); // cc_out 7127 break; 7128 case ARM::tADDi8: 7129 // If the immediate is in the range 0-7, we want tADDi3 iff Rd was 7130 // explicitly specified. From the ARM ARM: "Encoding T1 is preferred 7131 // to encoding T2 if <Rd> is specified and encoding T2 is preferred 7132 // to encoding T1 if <Rd> is omitted." 7133 if ((unsigned)Inst.getOperand(3).getImm() < 8 && Operands.size() == 6) { 7134 Inst.setOpcode(ARM::tADDi3); 7135 return true; 7136 } 7137 break; 7138 case ARM::tSUBi8: 7139 // If the immediate is in the range 0-7, we want tADDi3 iff Rd was 7140 // explicitly specified. From the ARM ARM: "Encoding T1 is preferred 7141 // to encoding T2 if <Rd> is specified and encoding T2 is preferred 7142 // to encoding T1 if <Rd> is omitted." 7143 if ((unsigned)Inst.getOperand(3).getImm() < 8 && Operands.size() == 6) { 7144 Inst.setOpcode(ARM::tSUBi3); 7145 return true; 7146 } 7147 break; 7148 case ARM::t2ADDri: 7149 case ARM::t2SUBri: { 7150 // If the destination and first source operand are the same, and 7151 // the flags are compatible with the current IT status, use encoding T2 7152 // instead of T3. For compatibility with the system 'as'. Make sure the 7153 // wide encoding wasn't explicit. 7154 if (Inst.getOperand(0).getReg() != Inst.getOperand(1).getReg() || 7155 !isARMLowRegister(Inst.getOperand(0).getReg()) || 7156 (unsigned)Inst.getOperand(2).getImm() > 255 || 7157 ((!inITBlock() && Inst.getOperand(5).getReg() != ARM::CPSR) || 7158 (inITBlock() && Inst.getOperand(5).getReg() != 0)) || 7159 (static_cast<ARMOperand*>(Operands[3])->isToken() && 7160 static_cast<ARMOperand*>(Operands[3])->getToken() == ".w")) 7161 break; 7162 MCInst TmpInst; 7163 TmpInst.setOpcode(Inst.getOpcode() == ARM::t2ADDri ? 7164 ARM::tADDi8 : ARM::tSUBi8); 7165 TmpInst.addOperand(Inst.getOperand(0)); 7166 TmpInst.addOperand(Inst.getOperand(5)); 7167 TmpInst.addOperand(Inst.getOperand(0)); 7168 TmpInst.addOperand(Inst.getOperand(2)); 7169 TmpInst.addOperand(Inst.getOperand(3)); 7170 TmpInst.addOperand(Inst.getOperand(4)); 7171 Inst = TmpInst; 7172 return true; 7173 } 7174 case ARM::t2ADDrr: { 7175 // If the destination and first source operand are the same, and 7176 // there's no setting of the flags, use encoding T2 instead of T3. 7177 // Note that this is only for ADD, not SUB. This mirrors the system 7178 // 'as' behaviour. Make sure the wide encoding wasn't explicit. 7179 if (Inst.getOperand(0).getReg() != Inst.getOperand(1).getReg() || 7180 Inst.getOperand(5).getReg() != 0 || 7181 (static_cast<ARMOperand*>(Operands[3])->isToken() && 7182 static_cast<ARMOperand*>(Operands[3])->getToken() == ".w")) 7183 break; 7184 MCInst TmpInst; 7185 TmpInst.setOpcode(ARM::tADDhirr); 7186 TmpInst.addOperand(Inst.getOperand(0)); 7187 TmpInst.addOperand(Inst.getOperand(0)); 7188 TmpInst.addOperand(Inst.getOperand(2)); 7189 TmpInst.addOperand(Inst.getOperand(3)); 7190 TmpInst.addOperand(Inst.getOperand(4)); 7191 Inst = TmpInst; 7192 return true; 7193 } 7194 case ARM::tADDrSP: { 7195 // If the non-SP source operand and the destination operand are not the 7196 // same, we need to use the 32-bit encoding if it's available. 7197 if (Inst.getOperand(0).getReg() != Inst.getOperand(2).getReg()) { 7198 Inst.setOpcode(ARM::t2ADDrr); 7199 Inst.addOperand(MCOperand::CreateReg(0)); // cc_out 7200 return true; 7201 } 7202 break; 7203 } 7204 case ARM::tB: 7205 // A Thumb conditional branch outside of an IT block is a tBcc. 7206 if (Inst.getOperand(1).getImm() != ARMCC::AL && !inITBlock()) { 7207 Inst.setOpcode(ARM::tBcc); 7208 return true; 7209 } 7210 break; 7211 case ARM::t2B: 7212 // A Thumb2 conditional branch outside of an IT block is a t2Bcc. 7213 if (Inst.getOperand(1).getImm() != ARMCC::AL && !inITBlock()){ 7214 Inst.setOpcode(ARM::t2Bcc); 7215 return true; 7216 } 7217 break; 7218 case ARM::t2Bcc: 7219 // If the conditional is AL or we're in an IT block, we really want t2B. 7220 if (Inst.getOperand(1).getImm() == ARMCC::AL || inITBlock()) { 7221 Inst.setOpcode(ARM::t2B); 7222 return true; 7223 } 7224 break; 7225 case ARM::tBcc: 7226 // If the conditional is AL, we really want tB. 7227 if (Inst.getOperand(1).getImm() == ARMCC::AL) { 7228 Inst.setOpcode(ARM::tB); 7229 return true; 7230 } 7231 break; 7232 case ARM::tLDMIA: { 7233 // If the register list contains any high registers, or if the writeback 7234 // doesn't match what tLDMIA can do, we need to use the 32-bit encoding 7235 // instead if we're in Thumb2. Otherwise, this should have generated 7236 // an error in validateInstruction(). 7237 unsigned Rn = Inst.getOperand(0).getReg(); 7238 bool hasWritebackToken = 7239 (static_cast<ARMOperand*>(Operands[3])->isToken() && 7240 static_cast<ARMOperand*>(Operands[3])->getToken() == "!"); 7241 bool listContainsBase; 7242 if (checkLowRegisterList(Inst, 3, Rn, 0, listContainsBase) || 7243 (!listContainsBase && !hasWritebackToken) || 7244 (listContainsBase && hasWritebackToken)) { 7245 // 16-bit encoding isn't sufficient. Switch to the 32-bit version. 7246 assert (isThumbTwo()); 7247 Inst.setOpcode(hasWritebackToken ? ARM::t2LDMIA_UPD : ARM::t2LDMIA); 7248 // If we're switching to the updating version, we need to insert 7249 // the writeback tied operand. 7250 if (hasWritebackToken) 7251 Inst.insert(Inst.begin(), 7252 MCOperand::CreateReg(Inst.getOperand(0).getReg())); 7253 return true; 7254 } 7255 break; 7256 } 7257 case ARM::tSTMIA_UPD: { 7258 // If the register list contains any high registers, we need to use 7259 // the 32-bit encoding instead if we're in Thumb2. Otherwise, this 7260 // should have generated an error in validateInstruction(). 7261 unsigned Rn = Inst.getOperand(0).getReg(); 7262 bool listContainsBase; 7263 if (checkLowRegisterList(Inst, 4, Rn, 0, listContainsBase)) { 7264 // 16-bit encoding isn't sufficient. Switch to the 32-bit version. 7265 assert (isThumbTwo()); 7266 Inst.setOpcode(ARM::t2STMIA_UPD); 7267 return true; 7268 } 7269 break; 7270 } 7271 case ARM::tPOP: { 7272 bool listContainsBase; 7273 // If the register list contains any high registers, we need to use 7274 // the 32-bit encoding instead if we're in Thumb2. Otherwise, this 7275 // should have generated an error in validateInstruction(). 7276 if (!checkLowRegisterList(Inst, 2, 0, ARM::PC, listContainsBase)) 7277 return false; 7278 assert (isThumbTwo()); 7279 Inst.setOpcode(ARM::t2LDMIA_UPD); 7280 // Add the base register and writeback operands. 7281 Inst.insert(Inst.begin(), MCOperand::CreateReg(ARM::SP)); 7282 Inst.insert(Inst.begin(), MCOperand::CreateReg(ARM::SP)); 7283 return true; 7284 } 7285 case ARM::tPUSH: { 7286 bool listContainsBase; 7287 if (!checkLowRegisterList(Inst, 2, 0, ARM::LR, listContainsBase)) 7288 return false; 7289 assert (isThumbTwo()); 7290 Inst.setOpcode(ARM::t2STMDB_UPD); 7291 // Add the base register and writeback operands. 7292 Inst.insert(Inst.begin(), MCOperand::CreateReg(ARM::SP)); 7293 Inst.insert(Inst.begin(), MCOperand::CreateReg(ARM::SP)); 7294 return true; 7295 } 7296 case ARM::t2MOVi: { 7297 // If we can use the 16-bit encoding and the user didn't explicitly 7298 // request the 32-bit variant, transform it here. 7299 if (isARMLowRegister(Inst.getOperand(0).getReg()) && 7300 (unsigned)Inst.getOperand(1).getImm() <= 255 && 7301 ((!inITBlock() && Inst.getOperand(2).getImm() == ARMCC::AL && 7302 Inst.getOperand(4).getReg() == ARM::CPSR) || 7303 (inITBlock() && Inst.getOperand(4).getReg() == 0)) && 7304 (!static_cast<ARMOperand*>(Operands[2])->isToken() || 7305 static_cast<ARMOperand*>(Operands[2])->getToken() != ".w")) { 7306 // The operands aren't in the same order for tMOVi8... 7307 MCInst TmpInst; 7308 TmpInst.setOpcode(ARM::tMOVi8); 7309 TmpInst.addOperand(Inst.getOperand(0)); 7310 TmpInst.addOperand(Inst.getOperand(4)); 7311 TmpInst.addOperand(Inst.getOperand(1)); 7312 TmpInst.addOperand(Inst.getOperand(2)); 7313 TmpInst.addOperand(Inst.getOperand(3)); 7314 Inst = TmpInst; 7315 return true; 7316 } 7317 break; 7318 } 7319 case ARM::t2MOVr: { 7320 // If we can use the 16-bit encoding and the user didn't explicitly 7321 // request the 32-bit variant, transform it here. 7322 if (isARMLowRegister(Inst.getOperand(0).getReg()) && 7323 isARMLowRegister(Inst.getOperand(1).getReg()) && 7324 Inst.getOperand(2).getImm() == ARMCC::AL && 7325 Inst.getOperand(4).getReg() == ARM::CPSR && 7326 (!static_cast<ARMOperand*>(Operands[2])->isToken() || 7327 static_cast<ARMOperand*>(Operands[2])->getToken() != ".w")) { 7328 // The operands aren't the same for tMOV[S]r... (no cc_out) 7329 MCInst TmpInst; 7330 TmpInst.setOpcode(Inst.getOperand(4).getReg() ? ARM::tMOVSr : ARM::tMOVr); 7331 TmpInst.addOperand(Inst.getOperand(0)); 7332 TmpInst.addOperand(Inst.getOperand(1)); 7333 TmpInst.addOperand(Inst.getOperand(2)); 7334 TmpInst.addOperand(Inst.getOperand(3)); 7335 Inst = TmpInst; 7336 return true; 7337 } 7338 break; 7339 } 7340 case ARM::t2SXTH: 7341 case ARM::t2SXTB: 7342 case ARM::t2UXTH: 7343 case ARM::t2UXTB: { 7344 // If we can use the 16-bit encoding and the user didn't explicitly 7345 // request the 32-bit variant, transform it here. 7346 if (isARMLowRegister(Inst.getOperand(0).getReg()) && 7347 isARMLowRegister(Inst.getOperand(1).getReg()) && 7348 Inst.getOperand(2).getImm() == 0 && 7349 (!static_cast<ARMOperand*>(Operands[2])->isToken() || 7350 static_cast<ARMOperand*>(Operands[2])->getToken() != ".w")) { 7351 unsigned NewOpc; 7352 switch (Inst.getOpcode()) { 7353 default: llvm_unreachable("Illegal opcode!"); 7354 case ARM::t2SXTH: NewOpc = ARM::tSXTH; break; 7355 case ARM::t2SXTB: NewOpc = ARM::tSXTB; break; 7356 case ARM::t2UXTH: NewOpc = ARM::tUXTH; break; 7357 case ARM::t2UXTB: NewOpc = ARM::tUXTB; break; 7358 } 7359 // The operands aren't the same for thumb1 (no rotate operand). 7360 MCInst TmpInst; 7361 TmpInst.setOpcode(NewOpc); 7362 TmpInst.addOperand(Inst.getOperand(0)); 7363 TmpInst.addOperand(Inst.getOperand(1)); 7364 TmpInst.addOperand(Inst.getOperand(3)); 7365 TmpInst.addOperand(Inst.getOperand(4)); 7366 Inst = TmpInst; 7367 return true; 7368 } 7369 break; 7370 } 7371 case ARM::MOVsi: { 7372 ARM_AM::ShiftOpc SOpc = ARM_AM::getSORegShOp(Inst.getOperand(2).getImm()); 7373 // rrx shifts and asr/lsr of #32 is encoded as 0 7374 if (SOpc == ARM_AM::rrx || SOpc == ARM_AM::asr || SOpc == ARM_AM::lsr) 7375 return false; 7376 if (ARM_AM::getSORegOffset(Inst.getOperand(2).getImm()) == 0) { 7377 // Shifting by zero is accepted as a vanilla 'MOVr' 7378 MCInst TmpInst; 7379 TmpInst.setOpcode(ARM::MOVr); 7380 TmpInst.addOperand(Inst.getOperand(0)); 7381 TmpInst.addOperand(Inst.getOperand(1)); 7382 TmpInst.addOperand(Inst.getOperand(3)); 7383 TmpInst.addOperand(Inst.getOperand(4)); 7384 TmpInst.addOperand(Inst.getOperand(5)); 7385 Inst = TmpInst; 7386 return true; 7387 } 7388 return false; 7389 } 7390 case ARM::ANDrsi: 7391 case ARM::ORRrsi: 7392 case ARM::EORrsi: 7393 case ARM::BICrsi: 7394 case ARM::SUBrsi: 7395 case ARM::ADDrsi: { 7396 unsigned newOpc; 7397 ARM_AM::ShiftOpc SOpc = ARM_AM::getSORegShOp(Inst.getOperand(3).getImm()); 7398 if (SOpc == ARM_AM::rrx) return false; 7399 switch (Inst.getOpcode()) { 7400 default: llvm_unreachable("unexpected opcode!"); 7401 case ARM::ANDrsi: newOpc = ARM::ANDrr; break; 7402 case ARM::ORRrsi: newOpc = ARM::ORRrr; break; 7403 case ARM::EORrsi: newOpc = ARM::EORrr; break; 7404 case ARM::BICrsi: newOpc = ARM::BICrr; break; 7405 case ARM::SUBrsi: newOpc = ARM::SUBrr; break; 7406 case ARM::ADDrsi: newOpc = ARM::ADDrr; break; 7407 } 7408 // If the shift is by zero, use the non-shifted instruction definition. 7409 // The exception is for right shifts, where 0 == 32 7410 if (ARM_AM::getSORegOffset(Inst.getOperand(3).getImm()) == 0 && 7411 !(SOpc == ARM_AM::lsr || SOpc == ARM_AM::asr)) { 7412 MCInst TmpInst; 7413 TmpInst.setOpcode(newOpc); 7414 TmpInst.addOperand(Inst.getOperand(0)); 7415 TmpInst.addOperand(Inst.getOperand(1)); 7416 TmpInst.addOperand(Inst.getOperand(2)); 7417 TmpInst.addOperand(Inst.getOperand(4)); 7418 TmpInst.addOperand(Inst.getOperand(5)); 7419 TmpInst.addOperand(Inst.getOperand(6)); 7420 Inst = TmpInst; 7421 return true; 7422 } 7423 return false; 7424 } 7425 case ARM::ITasm: 7426 case ARM::t2IT: { 7427 // The mask bits for all but the first condition are represented as 7428 // the low bit of the condition code value implies 't'. We currently 7429 // always have 1 implies 't', so XOR toggle the bits if the low bit 7430 // of the condition code is zero. 7431 MCOperand &MO = Inst.getOperand(1); 7432 unsigned Mask = MO.getImm(); 7433 unsigned OrigMask = Mask; 7434 unsigned TZ = countTrailingZeros(Mask); 7435 if ((Inst.getOperand(0).getImm() & 1) == 0) { 7436 assert(Mask && TZ <= 3 && "illegal IT mask value!"); 7437 Mask ^= (0xE << TZ) & 0xF; 7438 } 7439 MO.setImm(Mask); 7440 7441 // Set up the IT block state according to the IT instruction we just 7442 // matched. 7443 assert(!inITBlock() && "nested IT blocks?!"); 7444 ITState.Cond = ARMCC::CondCodes(Inst.getOperand(0).getImm()); 7445 ITState.Mask = OrigMask; // Use the original mask, not the updated one. 7446 ITState.CurPosition = 0; 7447 ITState.FirstCond = true; 7448 break; 7449 } 7450 case ARM::t2LSLrr: 7451 case ARM::t2LSRrr: 7452 case ARM::t2ASRrr: 7453 case ARM::t2SBCrr: 7454 case ARM::t2RORrr: 7455 case ARM::t2BICrr: 7456 { 7457 // Assemblers should use the narrow encodings of these instructions when permissible. 7458 if ((isARMLowRegister(Inst.getOperand(1).getReg()) && 7459 isARMLowRegister(Inst.getOperand(2).getReg())) && 7460 Inst.getOperand(0).getReg() == Inst.getOperand(1).getReg() && 7461 ((!inITBlock() && Inst.getOperand(5).getReg() == ARM::CPSR) || 7462 (inITBlock() && Inst.getOperand(5).getReg() != ARM::CPSR)) && 7463 (!static_cast<ARMOperand*>(Operands[3])->isToken() || 7464 !static_cast<ARMOperand*>(Operands[3])->getToken().equals_lower(".w"))) { 7465 unsigned NewOpc; 7466 switch (Inst.getOpcode()) { 7467 default: llvm_unreachable("unexpected opcode"); 7468 case ARM::t2LSLrr: NewOpc = ARM::tLSLrr; break; 7469 case ARM::t2LSRrr: NewOpc = ARM::tLSRrr; break; 7470 case ARM::t2ASRrr: NewOpc = ARM::tASRrr; break; 7471 case ARM::t2SBCrr: NewOpc = ARM::tSBC; break; 7472 case ARM::t2RORrr: NewOpc = ARM::tROR; break; 7473 case ARM::t2BICrr: NewOpc = ARM::tBIC; break; 7474 } 7475 MCInst TmpInst; 7476 TmpInst.setOpcode(NewOpc); 7477 TmpInst.addOperand(Inst.getOperand(0)); 7478 TmpInst.addOperand(Inst.getOperand(5)); 7479 TmpInst.addOperand(Inst.getOperand(1)); 7480 TmpInst.addOperand(Inst.getOperand(2)); 7481 TmpInst.addOperand(Inst.getOperand(3)); 7482 TmpInst.addOperand(Inst.getOperand(4)); 7483 Inst = TmpInst; 7484 return true; 7485 } 7486 return false; 7487 } 7488 case ARM::t2ANDrr: 7489 case ARM::t2EORrr: 7490 case ARM::t2ADCrr: 7491 case ARM::t2ORRrr: 7492 { 7493 // Assemblers should use the narrow encodings of these instructions when permissible. 7494 // These instructions are special in that they are commutable, so shorter encodings 7495 // are available more often. 7496 if ((isARMLowRegister(Inst.getOperand(1).getReg()) && 7497 isARMLowRegister(Inst.getOperand(2).getReg())) && 7498 (Inst.getOperand(0).getReg() == Inst.getOperand(1).getReg() || 7499 Inst.getOperand(0).getReg() == Inst.getOperand(2).getReg()) && 7500 ((!inITBlock() && Inst.getOperand(5).getReg() == ARM::CPSR) || 7501 (inITBlock() && Inst.getOperand(5).getReg() != ARM::CPSR)) && 7502 (!static_cast<ARMOperand*>(Operands[3])->isToken() || 7503 !static_cast<ARMOperand*>(Operands[3])->getToken().equals_lower(".w"))) { 7504 unsigned NewOpc; 7505 switch (Inst.getOpcode()) { 7506 default: llvm_unreachable("unexpected opcode"); 7507 case ARM::t2ADCrr: NewOpc = ARM::tADC; break; 7508 case ARM::t2ANDrr: NewOpc = ARM::tAND; break; 7509 case ARM::t2EORrr: NewOpc = ARM::tEOR; break; 7510 case ARM::t2ORRrr: NewOpc = ARM::tORR; break; 7511 } 7512 MCInst TmpInst; 7513 TmpInst.setOpcode(NewOpc); 7514 TmpInst.addOperand(Inst.getOperand(0)); 7515 TmpInst.addOperand(Inst.getOperand(5)); 7516 if (Inst.getOperand(0).getReg() == Inst.getOperand(1).getReg()) { 7517 TmpInst.addOperand(Inst.getOperand(1)); 7518 TmpInst.addOperand(Inst.getOperand(2)); 7519 } else { 7520 TmpInst.addOperand(Inst.getOperand(2)); 7521 TmpInst.addOperand(Inst.getOperand(1)); 7522 } 7523 TmpInst.addOperand(Inst.getOperand(3)); 7524 TmpInst.addOperand(Inst.getOperand(4)); 7525 Inst = TmpInst; 7526 return true; 7527 } 7528 return false; 7529 } 7530 } 7531 return false; 7532 } 7533 7534 unsigned ARMAsmParser::checkTargetMatchPredicate(MCInst &Inst) { 7535 // 16-bit thumb arithmetic instructions either require or preclude the 'S' 7536 // suffix depending on whether they're in an IT block or not. 7537 unsigned Opc = Inst.getOpcode(); 7538 const MCInstrDesc &MCID = getInstDesc(Opc); 7539 if (MCID.TSFlags & ARMII::ThumbArithFlagSetting) { 7540 assert(MCID.hasOptionalDef() && 7541 "optionally flag setting instruction missing optional def operand"); 7542 assert(MCID.NumOperands == Inst.getNumOperands() && 7543 "operand count mismatch!"); 7544 // Find the optional-def operand (cc_out). 7545 unsigned OpNo; 7546 for (OpNo = 0; 7547 !MCID.OpInfo[OpNo].isOptionalDef() && OpNo < MCID.NumOperands; 7548 ++OpNo) 7549 ; 7550 // If we're parsing Thumb1, reject it completely. 7551 if (isThumbOne() && Inst.getOperand(OpNo).getReg() != ARM::CPSR) 7552 return Match_MnemonicFail; 7553 // If we're parsing Thumb2, which form is legal depends on whether we're 7554 // in an IT block. 7555 if (isThumbTwo() && Inst.getOperand(OpNo).getReg() != ARM::CPSR && 7556 !inITBlock()) 7557 return Match_RequiresITBlock; 7558 if (isThumbTwo() && Inst.getOperand(OpNo).getReg() == ARM::CPSR && 7559 inITBlock()) 7560 return Match_RequiresNotITBlock; 7561 } 7562 // Some high-register supporting Thumb1 encodings only allow both registers 7563 // to be from r0-r7 when in Thumb2. 7564 else if (Opc == ARM::tADDhirr && isThumbOne() && 7565 isARMLowRegister(Inst.getOperand(1).getReg()) && 7566 isARMLowRegister(Inst.getOperand(2).getReg())) 7567 return Match_RequiresThumb2; 7568 // Others only require ARMv6 or later. 7569 else if (Opc == ARM::tMOVr && isThumbOne() && !hasV6Ops() && 7570 isARMLowRegister(Inst.getOperand(0).getReg()) && 7571 isARMLowRegister(Inst.getOperand(1).getReg())) 7572 return Match_RequiresV6; 7573 return Match_Success; 7574 } 7575 7576 static const char *getSubtargetFeatureName(unsigned Val); 7577 bool ARMAsmParser:: 7578 MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode, 7579 SmallVectorImpl<MCParsedAsmOperand*> &Operands, 7580 MCStreamer &Out, unsigned &ErrorInfo, 7581 bool MatchingInlineAsm) { 7582 MCInst Inst; 7583 unsigned MatchResult; 7584 7585 MatchResult = MatchInstructionImpl(Operands, Inst, ErrorInfo, 7586 MatchingInlineAsm); 7587 switch (MatchResult) { 7588 default: break; 7589 case Match_Success: 7590 // Context sensitive operand constraints aren't handled by the matcher, 7591 // so check them here. 7592 if (validateInstruction(Inst, Operands)) { 7593 // Still progress the IT block, otherwise one wrong condition causes 7594 // nasty cascading errors. 7595 forwardITPosition(); 7596 return true; 7597 } 7598 7599 // Some instructions need post-processing to, for example, tweak which 7600 // encoding is selected. Loop on it while changes happen so the 7601 // individual transformations can chain off each other. E.g., 7602 // tPOP(r8)->t2LDMIA_UPD(sp,r8)->t2STR_POST(sp,r8) 7603 while (processInstruction(Inst, Operands)) 7604 ; 7605 7606 // Only move forward at the very end so that everything in validate 7607 // and process gets a consistent answer about whether we're in an IT 7608 // block. 7609 forwardITPosition(); 7610 7611 // ITasm is an ARM mode pseudo-instruction that just sets the ITblock and 7612 // doesn't actually encode. 7613 if (Inst.getOpcode() == ARM::ITasm) 7614 return false; 7615 7616 Inst.setLoc(IDLoc); 7617 Out.EmitInstruction(Inst); 7618 return false; 7619 case Match_MissingFeature: { 7620 assert(ErrorInfo && "Unknown missing feature!"); 7621 // Special case the error message for the very common case where only 7622 // a single subtarget feature is missing (Thumb vs. ARM, e.g.). 7623 std::string Msg = "instruction requires:"; 7624 unsigned Mask = 1; 7625 for (unsigned i = 0; i < (sizeof(ErrorInfo)*8-1); ++i) { 7626 if (ErrorInfo & Mask) { 7627 Msg += " "; 7628 Msg += getSubtargetFeatureName(ErrorInfo & Mask); 7629 } 7630 Mask <<= 1; 7631 } 7632 return Error(IDLoc, Msg); 7633 } 7634 case Match_InvalidOperand: { 7635 SMLoc ErrorLoc = IDLoc; 7636 if (ErrorInfo != ~0U) { 7637 if (ErrorInfo >= Operands.size()) 7638 return Error(IDLoc, "too few operands for instruction"); 7639 7640 ErrorLoc = ((ARMOperand*)Operands[ErrorInfo])->getStartLoc(); 7641 if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc; 7642 } 7643 7644 return Error(ErrorLoc, "invalid operand for instruction"); 7645 } 7646 case Match_MnemonicFail: 7647 return Error(IDLoc, "invalid instruction", 7648 ((ARMOperand*)Operands[0])->getLocRange()); 7649 case Match_RequiresNotITBlock: 7650 return Error(IDLoc, "flag setting instruction only valid outside IT block"); 7651 case Match_RequiresITBlock: 7652 return Error(IDLoc, "instruction only valid inside IT block"); 7653 case Match_RequiresV6: 7654 return Error(IDLoc, "instruction variant requires ARMv6 or later"); 7655 case Match_RequiresThumb2: 7656 return Error(IDLoc, "instruction variant requires Thumb2"); 7657 case Match_ImmRange0_4: { 7658 SMLoc ErrorLoc = ((ARMOperand*)Operands[ErrorInfo])->getStartLoc(); 7659 if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc; 7660 return Error(ErrorLoc, "immediate operand must be in the range [0,4]"); 7661 } 7662 case Match_ImmRange0_15: { 7663 SMLoc ErrorLoc = ((ARMOperand*)Operands[ErrorInfo])->getStartLoc(); 7664 if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc; 7665 return Error(ErrorLoc, "immediate operand must be in the range [0,15]"); 7666 } 7667 } 7668 7669 llvm_unreachable("Implement any new match types added!"); 7670 } 7671 7672 /// parseDirective parses the arm specific directives 7673 bool ARMAsmParser::ParseDirective(AsmToken DirectiveID) { 7674 StringRef IDVal = DirectiveID.getIdentifier(); 7675 if (IDVal == ".word") 7676 return parseDirectiveWord(4, DirectiveID.getLoc()); 7677 else if (IDVal == ".thumb") 7678 return parseDirectiveThumb(DirectiveID.getLoc()); 7679 else if (IDVal == ".arm") 7680 return parseDirectiveARM(DirectiveID.getLoc()); 7681 else if (IDVal == ".thumb_func") 7682 return parseDirectiveThumbFunc(DirectiveID.getLoc()); 7683 else if (IDVal == ".code") 7684 return parseDirectiveCode(DirectiveID.getLoc()); 7685 else if (IDVal == ".syntax") 7686 return parseDirectiveSyntax(DirectiveID.getLoc()); 7687 else if (IDVal == ".unreq") 7688 return parseDirectiveUnreq(DirectiveID.getLoc()); 7689 else if (IDVal == ".arch") 7690 return parseDirectiveArch(DirectiveID.getLoc()); 7691 else if (IDVal == ".eabi_attribute") 7692 return parseDirectiveEabiAttr(DirectiveID.getLoc()); 7693 else if (IDVal == ".fnstart") 7694 return parseDirectiveFnStart(DirectiveID.getLoc()); 7695 else if (IDVal == ".fnend") 7696 return parseDirectiveFnEnd(DirectiveID.getLoc()); 7697 else if (IDVal == ".cantunwind") 7698 return parseDirectiveCantUnwind(DirectiveID.getLoc()); 7699 else if (IDVal == ".personality") 7700 return parseDirectivePersonality(DirectiveID.getLoc()); 7701 else if (IDVal == ".handlerdata") 7702 return parseDirectiveHandlerData(DirectiveID.getLoc()); 7703 else if (IDVal == ".setfp") 7704 return parseDirectiveSetFP(DirectiveID.getLoc()); 7705 else if (IDVal == ".pad") 7706 return parseDirectivePad(DirectiveID.getLoc()); 7707 else if (IDVal == ".save") 7708 return parseDirectiveRegSave(DirectiveID.getLoc(), false); 7709 else if (IDVal == ".vsave") 7710 return parseDirectiveRegSave(DirectiveID.getLoc(), true); 7711 return true; 7712 } 7713 7714 /// parseDirectiveWord 7715 /// ::= .word [ expression (, expression)* ] 7716 bool ARMAsmParser::parseDirectiveWord(unsigned Size, SMLoc L) { 7717 if (getLexer().isNot(AsmToken::EndOfStatement)) { 7718 for (;;) { 7719 const MCExpr *Value; 7720 if (getParser().parseExpression(Value)) 7721 return true; 7722 7723 getParser().getStreamer().EmitValue(Value, Size); 7724 7725 if (getLexer().is(AsmToken::EndOfStatement)) 7726 break; 7727 7728 // FIXME: Improve diagnostic. 7729 if (getLexer().isNot(AsmToken::Comma)) 7730 return Error(L, "unexpected token in directive"); 7731 Parser.Lex(); 7732 } 7733 } 7734 7735 Parser.Lex(); 7736 return false; 7737 } 7738 7739 /// parseDirectiveThumb 7740 /// ::= .thumb 7741 bool ARMAsmParser::parseDirectiveThumb(SMLoc L) { 7742 if (getLexer().isNot(AsmToken::EndOfStatement)) 7743 return Error(L, "unexpected token in directive"); 7744 Parser.Lex(); 7745 7746 if (!hasThumb()) 7747 return Error(L, "target does not support Thumb mode"); 7748 7749 if (!isThumb()) 7750 SwitchMode(); 7751 getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16); 7752 return false; 7753 } 7754 7755 /// parseDirectiveARM 7756 /// ::= .arm 7757 bool ARMAsmParser::parseDirectiveARM(SMLoc L) { 7758 if (getLexer().isNot(AsmToken::EndOfStatement)) 7759 return Error(L, "unexpected token in directive"); 7760 Parser.Lex(); 7761 7762 if (!hasARM()) 7763 return Error(L, "target does not support ARM mode"); 7764 7765 if (isThumb()) 7766 SwitchMode(); 7767 getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32); 7768 return false; 7769 } 7770 7771 /// parseDirectiveThumbFunc 7772 /// ::= .thumbfunc symbol_name 7773 bool ARMAsmParser::parseDirectiveThumbFunc(SMLoc L) { 7774 const MCAsmInfo *MAI = getParser().getStreamer().getContext().getAsmInfo(); 7775 bool isMachO = MAI->hasSubsectionsViaSymbols(); 7776 StringRef Name; 7777 bool needFuncName = true; 7778 7779 // Darwin asm has (optionally) function name after .thumb_func direction 7780 // ELF doesn't 7781 if (isMachO) { 7782 const AsmToken &Tok = Parser.getTok(); 7783 if (Tok.isNot(AsmToken::EndOfStatement)) { 7784 if (Tok.isNot(AsmToken::Identifier) && Tok.isNot(AsmToken::String)) 7785 return Error(L, "unexpected token in .thumb_func directive"); 7786 Name = Tok.getIdentifier(); 7787 Parser.Lex(); // Consume the identifier token. 7788 needFuncName = false; 7789 } 7790 } 7791 7792 if (getLexer().isNot(AsmToken::EndOfStatement)) 7793 return Error(L, "unexpected token in directive"); 7794 7795 // Eat the end of statement and any blank lines that follow. 7796 while (getLexer().is(AsmToken::EndOfStatement)) 7797 Parser.Lex(); 7798 7799 // FIXME: assuming function name will be the line following .thumb_func 7800 // We really should be checking the next symbol definition even if there's 7801 // stuff in between. 7802 if (needFuncName) { 7803 Name = Parser.getTok().getIdentifier(); 7804 } 7805 7806 // Mark symbol as a thumb symbol. 7807 MCSymbol *Func = getParser().getContext().GetOrCreateSymbol(Name); 7808 getParser().getStreamer().EmitThumbFunc(Func); 7809 return false; 7810 } 7811 7812 /// parseDirectiveSyntax 7813 /// ::= .syntax unified | divided 7814 bool ARMAsmParser::parseDirectiveSyntax(SMLoc L) { 7815 const AsmToken &Tok = Parser.getTok(); 7816 if (Tok.isNot(AsmToken::Identifier)) 7817 return Error(L, "unexpected token in .syntax directive"); 7818 StringRef Mode = Tok.getString(); 7819 if (Mode == "unified" || Mode == "UNIFIED") 7820 Parser.Lex(); 7821 else if (Mode == "divided" || Mode == "DIVIDED") 7822 return Error(L, "'.syntax divided' arm asssembly not supported"); 7823 else 7824 return Error(L, "unrecognized syntax mode in .syntax directive"); 7825 7826 if (getLexer().isNot(AsmToken::EndOfStatement)) 7827 return Error(Parser.getTok().getLoc(), "unexpected token in directive"); 7828 Parser.Lex(); 7829 7830 // TODO tell the MC streamer the mode 7831 // getParser().getStreamer().Emit???(); 7832 return false; 7833 } 7834 7835 /// parseDirectiveCode 7836 /// ::= .code 16 | 32 7837 bool ARMAsmParser::parseDirectiveCode(SMLoc L) { 7838 const AsmToken &Tok = Parser.getTok(); 7839 if (Tok.isNot(AsmToken::Integer)) 7840 return Error(L, "unexpected token in .code directive"); 7841 int64_t Val = Parser.getTok().getIntVal(); 7842 if (Val == 16) 7843 Parser.Lex(); 7844 else if (Val == 32) 7845 Parser.Lex(); 7846 else 7847 return Error(L, "invalid operand to .code directive"); 7848 7849 if (getLexer().isNot(AsmToken::EndOfStatement)) 7850 return Error(Parser.getTok().getLoc(), "unexpected token in directive"); 7851 Parser.Lex(); 7852 7853 if (Val == 16) { 7854 if (!hasThumb()) 7855 return Error(L, "target does not support Thumb mode"); 7856 7857 if (!isThumb()) 7858 SwitchMode(); 7859 getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16); 7860 } else { 7861 if (!hasARM()) 7862 return Error(L, "target does not support ARM mode"); 7863 7864 if (isThumb()) 7865 SwitchMode(); 7866 getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32); 7867 } 7868 7869 return false; 7870 } 7871 7872 /// parseDirectiveReq 7873 /// ::= name .req registername 7874 bool ARMAsmParser::parseDirectiveReq(StringRef Name, SMLoc L) { 7875 Parser.Lex(); // Eat the '.req' token. 7876 unsigned Reg; 7877 SMLoc SRegLoc, ERegLoc; 7878 if (ParseRegister(Reg, SRegLoc, ERegLoc)) { 7879 Parser.eatToEndOfStatement(); 7880 return Error(SRegLoc, "register name expected"); 7881 } 7882 7883 // Shouldn't be anything else. 7884 if (Parser.getTok().isNot(AsmToken::EndOfStatement)) { 7885 Parser.eatToEndOfStatement(); 7886 return Error(Parser.getTok().getLoc(), 7887 "unexpected input in .req directive."); 7888 } 7889 7890 Parser.Lex(); // Consume the EndOfStatement 7891 7892 if (RegisterReqs.GetOrCreateValue(Name, Reg).getValue() != Reg) 7893 return Error(SRegLoc, "redefinition of '" + Name + 7894 "' does not match original."); 7895 7896 return false; 7897 } 7898 7899 /// parseDirectiveUneq 7900 /// ::= .unreq registername 7901 bool ARMAsmParser::parseDirectiveUnreq(SMLoc L) { 7902 if (Parser.getTok().isNot(AsmToken::Identifier)) { 7903 Parser.eatToEndOfStatement(); 7904 return Error(L, "unexpected input in .unreq directive."); 7905 } 7906 RegisterReqs.erase(Parser.getTok().getIdentifier()); 7907 Parser.Lex(); // Eat the identifier. 7908 return false; 7909 } 7910 7911 /// parseDirectiveArch 7912 /// ::= .arch token 7913 bool ARMAsmParser::parseDirectiveArch(SMLoc L) { 7914 return true; 7915 } 7916 7917 /// parseDirectiveEabiAttr 7918 /// ::= .eabi_attribute int, int 7919 bool ARMAsmParser::parseDirectiveEabiAttr(SMLoc L) { 7920 return true; 7921 } 7922 7923 /// parseDirectiveFnStart 7924 /// ::= .fnstart 7925 bool ARMAsmParser::parseDirectiveFnStart(SMLoc L) { 7926 if (FnStartLoc.isValid()) { 7927 Error(L, ".fnstart starts before the end of previous one"); 7928 Error(FnStartLoc, "previous .fnstart starts here"); 7929 return true; 7930 } 7931 7932 FnStartLoc = L; 7933 getParser().getStreamer().EmitFnStart(); 7934 return false; 7935 } 7936 7937 /// parseDirectiveFnEnd 7938 /// ::= .fnend 7939 bool ARMAsmParser::parseDirectiveFnEnd(SMLoc L) { 7940 // Check the ordering of unwind directives 7941 if (!FnStartLoc.isValid()) 7942 return Error(L, ".fnstart must precede .fnend directive"); 7943 7944 // Reset the unwind directives parser state 7945 resetUnwindDirectiveParserState(); 7946 7947 getParser().getStreamer().EmitFnEnd(); 7948 return false; 7949 } 7950 7951 /// parseDirectiveCantUnwind 7952 /// ::= .cantunwind 7953 bool ARMAsmParser::parseDirectiveCantUnwind(SMLoc L) { 7954 // Check the ordering of unwind directives 7955 CantUnwindLoc = L; 7956 if (!FnStartLoc.isValid()) 7957 return Error(L, ".fnstart must precede .cantunwind directive"); 7958 if (HandlerDataLoc.isValid()) { 7959 Error(L, ".cantunwind can't be used with .handlerdata directive"); 7960 Error(HandlerDataLoc, ".handlerdata was specified here"); 7961 return true; 7962 } 7963 if (PersonalityLoc.isValid()) { 7964 Error(L, ".cantunwind can't be used with .personality directive"); 7965 Error(PersonalityLoc, ".personality was specified here"); 7966 return true; 7967 } 7968 7969 getParser().getStreamer().EmitCantUnwind(); 7970 return false; 7971 } 7972 7973 /// parseDirectivePersonality 7974 /// ::= .personality name 7975 bool ARMAsmParser::parseDirectivePersonality(SMLoc L) { 7976 // Check the ordering of unwind directives 7977 PersonalityLoc = L; 7978 if (!FnStartLoc.isValid()) 7979 return Error(L, ".fnstart must precede .personality directive"); 7980 if (CantUnwindLoc.isValid()) { 7981 Error(L, ".personality can't be used with .cantunwind directive"); 7982 Error(CantUnwindLoc, ".cantunwind was specified here"); 7983 return true; 7984 } 7985 if (HandlerDataLoc.isValid()) { 7986 Error(L, ".personality must precede .handlerdata directive"); 7987 Error(HandlerDataLoc, ".handlerdata was specified here"); 7988 return true; 7989 } 7990 7991 // Parse the name of the personality routine 7992 if (Parser.getTok().isNot(AsmToken::Identifier)) { 7993 Parser.eatToEndOfStatement(); 7994 return Error(L, "unexpected input in .personality directive."); 7995 } 7996 StringRef Name(Parser.getTok().getIdentifier()); 7997 Parser.Lex(); 7998 7999 MCSymbol *PR = getParser().getContext().GetOrCreateSymbol(Name); 8000 getParser().getStreamer().EmitPersonality(PR); 8001 return false; 8002 } 8003 8004 /// parseDirectiveHandlerData 8005 /// ::= .handlerdata 8006 bool ARMAsmParser::parseDirectiveHandlerData(SMLoc L) { 8007 // Check the ordering of unwind directives 8008 HandlerDataLoc = L; 8009 if (!FnStartLoc.isValid()) 8010 return Error(L, ".fnstart must precede .personality directive"); 8011 if (CantUnwindLoc.isValid()) { 8012 Error(L, ".handlerdata can't be used with .cantunwind directive"); 8013 Error(CantUnwindLoc, ".cantunwind was specified here"); 8014 return true; 8015 } 8016 8017 getParser().getStreamer().EmitHandlerData(); 8018 return false; 8019 } 8020 8021 /// parseDirectiveSetFP 8022 /// ::= .setfp fpreg, spreg [, offset] 8023 bool ARMAsmParser::parseDirectiveSetFP(SMLoc L) { 8024 // Check the ordering of unwind directives 8025 if (!FnStartLoc.isValid()) 8026 return Error(L, ".fnstart must precede .setfp directive"); 8027 if (HandlerDataLoc.isValid()) 8028 return Error(L, ".setfp must precede .handlerdata directive"); 8029 8030 // Parse fpreg 8031 SMLoc NewFPRegLoc = Parser.getTok().getLoc(); 8032 int NewFPReg = tryParseRegister(); 8033 if (NewFPReg == -1) 8034 return Error(NewFPRegLoc, "frame pointer register expected"); 8035 8036 // Consume comma 8037 if (!Parser.getTok().is(AsmToken::Comma)) 8038 return Error(Parser.getTok().getLoc(), "comma expected"); 8039 Parser.Lex(); // skip comma 8040 8041 // Parse spreg 8042 SMLoc NewSPRegLoc = Parser.getTok().getLoc(); 8043 int NewSPReg = tryParseRegister(); 8044 if (NewSPReg == -1) 8045 return Error(NewSPRegLoc, "stack pointer register expected"); 8046 8047 if (NewSPReg != ARM::SP && NewSPReg != FPReg) 8048 return Error(NewSPRegLoc, 8049 "register should be either $sp or the latest fp register"); 8050 8051 // Update the frame pointer register 8052 FPReg = NewFPReg; 8053 8054 // Parse offset 8055 int64_t Offset = 0; 8056 if (Parser.getTok().is(AsmToken::Comma)) { 8057 Parser.Lex(); // skip comma 8058 8059 if (Parser.getTok().isNot(AsmToken::Hash) && 8060 Parser.getTok().isNot(AsmToken::Dollar)) { 8061 return Error(Parser.getTok().getLoc(), "'#' expected"); 8062 } 8063 Parser.Lex(); // skip hash token. 8064 8065 const MCExpr *OffsetExpr; 8066 SMLoc ExLoc = Parser.getTok().getLoc(); 8067 SMLoc EndLoc; 8068 if (getParser().parseExpression(OffsetExpr, EndLoc)) 8069 return Error(ExLoc, "malformed setfp offset"); 8070 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(OffsetExpr); 8071 if (!CE) 8072 return Error(ExLoc, "setfp offset must be an immediate"); 8073 8074 Offset = CE->getValue(); 8075 } 8076 8077 getParser().getStreamer().EmitSetFP(static_cast<unsigned>(NewFPReg), 8078 static_cast<unsigned>(NewSPReg), 8079 Offset); 8080 return false; 8081 } 8082 8083 /// parseDirective 8084 /// ::= .pad offset 8085 bool ARMAsmParser::parseDirectivePad(SMLoc L) { 8086 // Check the ordering of unwind directives 8087 if (!FnStartLoc.isValid()) 8088 return Error(L, ".fnstart must precede .pad directive"); 8089 if (HandlerDataLoc.isValid()) 8090 return Error(L, ".pad must precede .handlerdata directive"); 8091 8092 // Parse the offset 8093 if (Parser.getTok().isNot(AsmToken::Hash) && 8094 Parser.getTok().isNot(AsmToken::Dollar)) { 8095 return Error(Parser.getTok().getLoc(), "'#' expected"); 8096 } 8097 Parser.Lex(); // skip hash token. 8098 8099 const MCExpr *OffsetExpr; 8100 SMLoc ExLoc = Parser.getTok().getLoc(); 8101 SMLoc EndLoc; 8102 if (getParser().parseExpression(OffsetExpr, EndLoc)) 8103 return Error(ExLoc, "malformed pad offset"); 8104 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(OffsetExpr); 8105 if (!CE) 8106 return Error(ExLoc, "pad offset must be an immediate"); 8107 8108 getParser().getStreamer().EmitPad(CE->getValue()); 8109 return false; 8110 } 8111 8112 /// parseDirectiveRegSave 8113 /// ::= .save { registers } 8114 /// ::= .vsave { registers } 8115 bool ARMAsmParser::parseDirectiveRegSave(SMLoc L, bool IsVector) { 8116 // Check the ordering of unwind directives 8117 if (!FnStartLoc.isValid()) 8118 return Error(L, ".fnstart must precede .save or .vsave directives"); 8119 if (HandlerDataLoc.isValid()) 8120 return Error(L, ".save or .vsave must precede .handlerdata directive"); 8121 8122 // RAII object to make sure parsed operands are deleted. 8123 struct CleanupObject { 8124 SmallVector<MCParsedAsmOperand *, 1> Operands; 8125 ~CleanupObject() { 8126 for (unsigned I = 0, E = Operands.size(); I != E; ++I) 8127 delete Operands[I]; 8128 } 8129 } CO; 8130 8131 // Parse the register list 8132 if (parseRegisterList(CO.Operands)) 8133 return true; 8134 ARMOperand *Op = (ARMOperand*)CO.Operands[0]; 8135 if (!IsVector && !Op->isRegList()) 8136 return Error(L, ".save expects GPR registers"); 8137 if (IsVector && !Op->isDPRRegList()) 8138 return Error(L, ".vsave expects DPR registers"); 8139 8140 getParser().getStreamer().EmitRegSave(Op->getRegList(), IsVector); 8141 return false; 8142 } 8143 8144 /// Force static initialization. 8145 extern "C" void LLVMInitializeARMAsmParser() { 8146 RegisterMCAsmParser<ARMAsmParser> X(TheARMTarget); 8147 RegisterMCAsmParser<ARMAsmParser> Y(TheThumbTarget); 8148 } 8149 8150 #define GET_REGISTER_MATCHER 8151 #define GET_SUBTARGET_FEATURE_NAME 8152 #define GET_MATCHER_IMPLEMENTATION 8153 #include "ARMGenAsmMatcher.inc" 8154 8155 // Define this matcher function after the auto-generated include so we 8156 // have the match class enum definitions. 8157 unsigned ARMAsmParser::validateTargetOperandClass(MCParsedAsmOperand *AsmOp, 8158 unsigned Kind) { 8159 ARMOperand *Op = static_cast<ARMOperand*>(AsmOp); 8160 // If the kind is a token for a literal immediate, check if our asm 8161 // operand matches. This is for InstAliases which have a fixed-value 8162 // immediate in the syntax. 8163 if (Kind == MCK__35_0 && Op->isImm()) { 8164 const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Op->getImm()); 8165 if (!CE) 8166 return Match_InvalidOperand; 8167 if (CE->getValue() == 0) 8168 return Match_Success; 8169 } 8170 return Match_InvalidOperand; 8171 } 8172