ARMAsmParser.cpp revision fb8989e64024547e4ad5ab6fe4d94fe146a7899f
1ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby//===-- ARMAsmParser.cpp - Parse ARM assembly to MCInst instructions ------===// 2ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// 3ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// The LLVM Compiler Infrastructure 4ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// 5ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// This file is distributed under the University of Illinois Open Source 6ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// License. See LICENSE.TXT for details. 7ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// 8ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby//===----------------------------------------------------------------------===// 9ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 1094b9550a32d189704a8eae55505edf62662c0534Evan Cheng#include "MCTargetDesc/ARMBaseInfo.h" 11ee04a6d3a40c3017124e3fd89a0db473a2824498Evan Cheng#include "MCTargetDesc/ARMAddressingModes.h" 12ee04a6d3a40c3017124e3fd89a0db473a2824498Evan Cheng#include "MCTargetDesc/ARMMCExpr.h" 13c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/MC/MCParser/MCAsmLexer.h" 14c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/MC/MCParser/MCAsmParser.h" 15c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/MC/MCParser/MCParsedAsmOperand.h" 166469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola#include "llvm/MC/MCAsmInfo.h" 17642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach#include "llvm/MC/MCContext.h" 18ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/MC/MCStreamer.h" 19ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/MC/MCExpr.h" 20ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/MC/MCInst.h" 2194b9550a32d189704a8eae55505edf62662c0534Evan Cheng#include "llvm/MC/MCRegisterInfo.h" 22ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng#include "llvm/MC/MCSubtargetInfo.h" 2394b9550a32d189704a8eae55505edf62662c0534Evan Cheng#include "llvm/MC/MCTargetAsmParser.h" 24ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/Target/TargetRegistry.h" 25c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/Support/SourceMgr.h" 26fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar#include "llvm/Support/raw_ostream.h" 2775ca4b94bd9dcd3952fdc237429342a2154ba142Benjamin Kramer#include "llvm/ADT/OwningPtr.h" 2894b9550a32d189704a8eae55505edf62662c0534Evan Cheng#include "llvm/ADT/STLExtras.h" 29c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/ADT/SmallVector.h" 300c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson#include "llvm/ADT/StringExtras.h" 31345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar#include "llvm/ADT/StringSwitch.h" 32c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/ADT/Twine.h" 33ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng 34ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbyusing namespace llvm; 35ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 363a69756e392942bc522193f38d7f33958ed3b131Chris Lattnernamespace { 37146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling 38146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendlingclass ARMOperand; 3916c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 4094b9550a32d189704a8eae55505edf62662c0534Evan Chengclass ARMAsmParser : public MCTargetAsmParser { 41ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng MCSubtargetInfo &STI; 42ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby MCAsmParser &Parser; 43ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 44ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby MCAsmParser &getParser() const { return Parser; } 45ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby MCAsmLexer &getLexer() const { return Parser.getLexer(); } 46ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 47ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby void Warning(SMLoc L, const Twine &Msg) { Parser.Warning(L, Msg); } 48ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); } 49ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 501355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach int tryParseRegister(); 511355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool tryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &); 520d87ec21d79c8622733b8367aa41067169602480Jim Grosbach int tryParseShiftRegister(SmallVectorImpl<MCParsedAsmOperand*> &); 531355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool parseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &); 541355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool parseMemory(SmallVectorImpl<MCParsedAsmOperand*> &, 55ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ARMII::AddrMode AddrMode); 561355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &, StringRef Mnemonic); 571355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool parsePrefix(ARMMCExpr::VariantKind &RefKind); 581355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach const MCExpr *applyPrefixToExpr(const MCExpr *E, 599081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim MCSymbolRefExpr::VariantKind Variant); 609081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 61a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 621355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool parseMemoryOffsetReg(bool &Negative, 639c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool &OffsetRegShifted, 640082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson enum ARM_AM::ShiftOpc &ShiftType, 659c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const MCExpr *&ShiftAmount, 669c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const MCExpr *&Offset, 679c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool &OffsetIsReg, 68762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan int &OffsetRegNum, 69762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc &E); 701355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool parseShift(enum ARM_AM::ShiftOpc &St, 710082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson const MCExpr *&ShiftAmount, SMLoc &E); 721355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool parseDirectiveWord(unsigned Size, SMLoc L); 731355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool parseDirectiveThumb(SMLoc L); 741355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool parseDirectiveThumbFunc(SMLoc L); 751355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool parseDirectiveCode(SMLoc L); 761355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool parseDirectiveSyntax(SMLoc L); 77515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 781355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach StringRef splitMnemonic(StringRef Mnemonic, unsigned &PredicationCode, 795f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach bool &CarrySetting, unsigned &ProcessorIMod); 801355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach void getMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet, 81fdcee77887372dbf6589d47cc33094965b679f24Bruno Cardoso Lopes bool &CanAcceptPredicationCode); 8216c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 83ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng bool isThumb() const { 84ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng // FIXME: Can tablegen auto-generate this? 85ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng return (STI.getFeatureBits() & ARM::ModeThumb) != 0; 86ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng } 87ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng bool isThumbOne() const { 88ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2) == 0; 89ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng } 9032869205052430f45d598fba25ab878d8b29da2dEvan Cheng void SwitchMode() { 91ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng unsigned FB = ComputeAvailableFeatures(STI.ToggleFeature(ARM::ModeThumb)); 92ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng setAvailableFeatures(FB); 9332869205052430f45d598fba25ab878d8b29da2dEvan Cheng } 94ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng 95a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby /// @name Auto-generated Match Functions 96a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby /// { 973483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 980692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner#define GET_ASSEMBLER_HEADER 990692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner#include "ARMGenAsmMatcher.inc" 100a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 101a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby /// } 102a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 10343904299b05bdf579415749041f77c4490fe5f5bJim Grosbach OperandMatchResultTy parseCoprocNumOperand( 104f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach SmallVectorImpl<MCParsedAsmOperand*>&); 10543904299b05bdf579415749041f77c4490fe5f5bJim Grosbach OperandMatchResultTy parseCoprocRegOperand( 106f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach SmallVectorImpl<MCParsedAsmOperand*>&); 10743904299b05bdf579415749041f77c4490fe5f5bJim Grosbach OperandMatchResultTy parseMemBarrierOptOperand( 1088bba1a5ef0f8a71de2e58c7f05b8714a73464ca8Bruno Cardoso Lopes SmallVectorImpl<MCParsedAsmOperand*>&); 10943904299b05bdf579415749041f77c4490fe5f5bJim Grosbach OperandMatchResultTy parseProcIFlagsOperand( 1108bba1a5ef0f8a71de2e58c7f05b8714a73464ca8Bruno Cardoso Lopes SmallVectorImpl<MCParsedAsmOperand*>&); 11143904299b05bdf579415749041f77c4490fe5f5bJim Grosbach OperandMatchResultTy parseMSRMaskOperand( 1128bba1a5ef0f8a71de2e58c7f05b8714a73464ca8Bruno Cardoso Lopes SmallVectorImpl<MCParsedAsmOperand*>&); 11343904299b05bdf579415749041f77c4490fe5f5bJim Grosbach OperandMatchResultTy parseMemMode2Operand( 114ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes SmallVectorImpl<MCParsedAsmOperand*>&); 11543904299b05bdf579415749041f77c4490fe5f5bJim Grosbach OperandMatchResultTy parseMemMode3Operand( 116ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes SmallVectorImpl<MCParsedAsmOperand*>&); 117f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach OperandMatchResultTy parsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &O, 118f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach StringRef Op, int Low, int High); 119f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach OperandMatchResultTy parsePKHLSLImm(SmallVectorImpl<MCParsedAsmOperand*> &O) { 120f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return parsePKHImm(O, "lsl", 0, 31); 121f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 122f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach OperandMatchResultTy parsePKHASRImm(SmallVectorImpl<MCParsedAsmOperand*> &O) { 123f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return parsePKHImm(O, "asr", 1, 32); 124f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 125c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach OperandMatchResultTy parseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*>&); 126580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach OperandMatchResultTy parseShifterImm(SmallVectorImpl<MCParsedAsmOperand*>&); 1277e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach OperandMatchResultTy parseRotImm(SmallVectorImpl<MCParsedAsmOperand*>&); 128ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 129ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // Asm Match Converter Methods 1301355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool cvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode, 131ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &); 1321355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool cvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode, 133ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &); 1341355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool cvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode, 135ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &); 1361355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool cvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode, 137ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &); 138f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach 139189610f9466686a91fb7d847b572e1645c785323Jim Grosbach 140189610f9466686a91fb7d847b572e1645c785323Jim Grosbach bool validateInstruction(MCInst &Inst, 141189610f9466686a91fb7d847b572e1645c785323Jim Grosbach const SmallVectorImpl<MCParsedAsmOperand*> &Ops); 142189610f9466686a91fb7d847b572e1645c785323Jim Grosbach 143ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbypublic: 144ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng ARMAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser) 14594b9550a32d189704a8eae55505edf62662c0534Evan Cheng : MCTargetAsmParser(), STI(_STI), Parser(_Parser) { 146ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng MCAsmParserExtension::Initialize(_Parser); 14732869205052430f45d598fba25ab878d8b29da2dEvan Cheng 148ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng // Initialize the set of available features. 149ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits())); 150ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng } 151ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 1521355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach // Implementation of the MCTargetAsmParser interface: 1531355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc); 1541355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool ParseInstruction(StringRef Name, SMLoc NameLoc, 155189610f9466686a91fb7d847b572e1645c785323Jim Grosbach SmallVectorImpl<MCParsedAsmOperand*> &Operands); 1561355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool ParseDirective(AsmToken DirectiveID); 1571355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach 1581355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach bool MatchAndEmitInstruction(SMLoc IDLoc, 1591355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach SmallVectorImpl<MCParsedAsmOperand*> &Operands, 1601355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach MCStreamer &Out); 161ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby}; 16216c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach} // end anonymous namespace 16316c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 164275944afb55086d0b4b20d4d831de7c1c7507925Evan Chengnamespace llvm { 165275944afb55086d0b4b20d4d831de7c1c7507925Evan Cheng // FIXME: TableGen this? 166275944afb55086d0b4b20d4d831de7c1c7507925Evan Cheng extern MCRegisterClass ARMMCRegisterClasses[]; // In ARMGenRegisterInfo.inc. 167275944afb55086d0b4b20d4d831de7c1c7507925Evan Cheng} 168275944afb55086d0b4b20d4d831de7c1c7507925Evan Cheng 1693a69756e392942bc522193f38d7f33958ed3b131Chris Lattnernamespace { 1703a69756e392942bc522193f38d7f33958ed3b131Chris Lattner 171a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// ARMOperand - Instances of this class represent a parsed ARM machine 172a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// instruction. 173146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendlingclass ARMOperand : public MCParsedAsmOperand { 174762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan enum KindTy { 1758462b30548fb5969250858036638c73c16b65b43Daniel Dunbar CondCode, 176d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach CCOut, 177fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes CoprocNum, 178fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes CoprocReg, 179cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby Immediate, 180706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes MemBarrierOpt, 1818462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Memory, 182584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes MSRMask, 183a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ProcIFlags, 1848462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Register, 1858d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling RegisterList, 1860f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling DPRRegisterList, 1870f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling SPRRegisterList, 188e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ShiftedRegister, 18992a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson ShiftedImmediate, 190580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach ShifterImmediate, 1917e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach RotateImmediate, 1928462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Token 193a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } Kind; 194a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 195762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc StartLoc, EndLoc; 19624d22d27640e9de954a5ac26f51a45cc96bb9135Bill Wendling SmallVector<unsigned, 8> Registers; 197a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 198a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby union { 199a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby struct { 2008462b30548fb5969250858036638c73c16b65b43Daniel Dunbar ARMCC::CondCodes Val; 2018462b30548fb5969250858036638c73c16b65b43Daniel Dunbar } CC; 2028462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 2038462b30548fb5969250858036638c73c16b65b43Daniel Dunbar struct { 204706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes ARM_MB::MemBOpt Val; 205706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes } MBOpt; 206706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 207706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes struct { 208fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes unsigned Val; 209fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } Cop; 210fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 211fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes struct { 212a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ARM_PROC::IFlags Val; 213a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } IFlags; 214a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 215a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes struct { 216584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes unsigned Val; 217584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } MMask; 218584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 219584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes struct { 220a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby const char *Data; 221a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby unsigned Length; 222a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } Tok; 223a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 224a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby struct { 225a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby unsigned RegNum; 226a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } Reg; 227a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 2288155e5b753aca42973cf317727f3805faddcaf90Bill Wendling struct { 229cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby const MCExpr *Val; 230cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby } Imm; 23116c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 2326a5c22ed89c8bb73034a70105340acf6539dc58bDaniel Dunbar /// Combined record for all forms of ARM address expressions. 233a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby struct { 234ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ARMII::AddrMode AddrMode; 235a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby unsigned BaseRegNum; 2362637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar union { 2372637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar unsigned RegNum; ///< Offset register num, when OffsetIsReg. 2382637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar const MCExpr *Value; ///< Offset value, when !OffsetIsReg. 2392637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar } Offset; 240146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling const MCExpr *ShiftAmount; // used when OffsetRegShifted is true 2410082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson enum ARM_AM::ShiftOpc ShiftType; // used when OffsetRegShifted is true 242146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling unsigned OffsetRegShifted : 1; // only used when OffsetIsReg is true 24350d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling unsigned Preindexed : 1; 24450d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling unsigned Postindexed : 1; 24550d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling unsigned OffsetIsReg : 1; 24650d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling unsigned Negative : 1; // only used when OffsetIsReg is true 24750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling unsigned Writeback : 1; 248a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } Mem; 2490082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 2500082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson struct { 251580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach bool isASR; 252e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned Imm; 253580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } ShifterImm; 254e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach struct { 255e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ARM_AM::ShiftOpc ShiftTy; 256e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned SrcReg; 257e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned ShiftReg; 258e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned ShiftImm; 259af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach } RegShiftedReg; 26092a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson struct { 26192a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson ARM_AM::ShiftOpc ShiftTy; 26292a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson unsigned SrcReg; 26392a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson unsigned ShiftImm; 264af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach } RegShiftedImm; 2657e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach struct { 2667e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach unsigned Imm; 2677e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach } RotImm; 268a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby }; 26916c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 270146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling ARMOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {} 271146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendlingpublic: 272762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan ARMOperand(const ARMOperand &o) : MCParsedAsmOperand() { 273762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Kind = o.Kind; 274762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan StartLoc = o.StartLoc; 275762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan EndLoc = o.EndLoc; 276762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan switch (Kind) { 2778462b30548fb5969250858036638c73c16b65b43Daniel Dunbar case CondCode: 2788462b30548fb5969250858036638c73c16b65b43Daniel Dunbar CC = o.CC; 2798462b30548fb5969250858036638c73c16b65b43Daniel Dunbar break; 280762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan case Token: 2818462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Tok = o.Tok; 282762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan break; 283d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach case CCOut: 284762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan case Register: 285762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Reg = o.Reg; 286762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan break; 2878d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling case RegisterList: 2880f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling case DPRRegisterList: 2890f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling case SPRRegisterList: 29024d22d27640e9de954a5ac26f51a45cc96bb9135Bill Wendling Registers = o.Registers; 2918d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling break; 292fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes case CoprocNum: 293fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes case CoprocReg: 294fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Cop = o.Cop; 295fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes break; 296762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan case Immediate: 297762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Imm = o.Imm; 298762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan break; 299706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes case MemBarrierOpt: 300706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes MBOpt = o.MBOpt; 301706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes break; 302762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan case Memory: 303762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Mem = o.Mem; 304762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan break; 305584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes case MSRMask: 306584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes MMask = o.MMask; 307584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes break; 308a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes case ProcIFlags: 309a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes IFlags = o.IFlags; 3100082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson break; 311580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach case ShifterImmediate: 312580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach ShifterImm = o.ShifterImm; 3130082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson break; 314e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach case ShiftedRegister: 315af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach RegShiftedReg = o.RegShiftedReg; 316e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach break; 31792a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson case ShiftedImmediate: 318af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach RegShiftedImm = o.RegShiftedImm; 31992a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson break; 3207e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach case RotateImmediate: 3217e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach RotImm = o.RotImm; 3227e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach break; 323762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 324762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 32516c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 326762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan /// getStartLoc - Get the location of the first token of this operand. 327762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc getStartLoc() const { return StartLoc; } 328762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan /// getEndLoc - Get the location of the last token of this operand. 329762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc getEndLoc() const { return EndLoc; } 330a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 3318462b30548fb5969250858036638c73c16b65b43Daniel Dunbar ARMCC::CondCodes getCondCode() const { 3328462b30548fb5969250858036638c73c16b65b43Daniel Dunbar assert(Kind == CondCode && "Invalid access!"); 3338462b30548fb5969250858036638c73c16b65b43Daniel Dunbar return CC.Val; 3348462b30548fb5969250858036638c73c16b65b43Daniel Dunbar } 3358462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 336fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes unsigned getCoproc() const { 337fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes assert((Kind == CoprocNum || Kind == CoprocReg) && "Invalid access!"); 338fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes return Cop.Val; 339fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } 340fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 341a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby StringRef getToken() const { 342a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby assert(Kind == Token && "Invalid access!"); 343a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return StringRef(Tok.Data, Tok.Length); 344a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 345a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 346a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby unsigned getReg() const { 3476aa49435994c33257b7588cac24671785d17fa6eBenjamin Kramer assert((Kind == Register || Kind == CCOut) && "Invalid access!"); 3487729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling return Reg.RegNum; 349a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 350a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 3515fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling const SmallVectorImpl<unsigned> &getRegList() const { 3520f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling assert((Kind == RegisterList || Kind == DPRRegisterList || 3530f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling Kind == SPRRegisterList) && "Invalid access!"); 35424d22d27640e9de954a5ac26f51a45cc96bb9135Bill Wendling return Registers; 3558d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } 3568d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 357cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby const MCExpr *getImm() const { 358cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby assert(Kind == Immediate && "Invalid access!"); 359cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby return Imm.Val; 360cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby } 361cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby 362706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes ARM_MB::MemBOpt getMemBarrierOpt() const { 363706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes assert(Kind == MemBarrierOpt && "Invalid access!"); 364706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes return MBOpt.Val; 365706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes } 366706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 367a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ARM_PROC::IFlags getProcIFlags() const { 368a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes assert(Kind == ProcIFlags && "Invalid access!"); 369a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes return IFlags.Val; 370a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 371a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 372584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes unsigned getMSRMask() const { 373584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes assert(Kind == MSRMask && "Invalid access!"); 374584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return MMask.Val; 375584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 376584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 3776ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar /// @name Memory Operand Accessors 3786ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar /// @{ 379ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ARMII::AddrMode getMemAddrMode() const { 380ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return Mem.AddrMode; 381ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes } 3826ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar unsigned getMemBaseRegNum() const { 3836ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar return Mem.BaseRegNum; 3846ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 3856ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar unsigned getMemOffsetRegNum() const { 3866ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar assert(Mem.OffsetIsReg && "Invalid access!"); 3876ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar return Mem.Offset.RegNum; 3886ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 3896ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar const MCExpr *getMemOffset() const { 3906ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar assert(!Mem.OffsetIsReg && "Invalid access!"); 3916ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar return Mem.Offset.Value; 3926ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 3936ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar unsigned getMemOffsetRegShifted() const { 3946ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar assert(Mem.OffsetIsReg && "Invalid access!"); 3956ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar return Mem.OffsetRegShifted; 3966ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 3976ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar const MCExpr *getMemShiftAmount() const { 3986ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar assert(Mem.OffsetIsReg && Mem.OffsetRegShifted && "Invalid access!"); 3996ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar return Mem.ShiftAmount; 4006ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 4010082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson enum ARM_AM::ShiftOpc getMemShiftType() const { 4026ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar assert(Mem.OffsetIsReg && Mem.OffsetRegShifted && "Invalid access!"); 4036ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar return Mem.ShiftType; 4046ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 4056ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar bool getMemPreindexed() const { return Mem.Preindexed; } 4066ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar bool getMemPostindexed() const { return Mem.Postindexed; } 4076ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar bool getMemOffsetIsReg() const { return Mem.OffsetIsReg; } 4086ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar bool getMemNegative() const { return Mem.Negative; } 4096ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar bool getMemWriteback() const { return Mem.Writeback; } 4106ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar 4116ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar /// @} 4126ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar 413fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes bool isCoprocNum() const { return Kind == CoprocNum; } 414fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes bool isCoprocReg() const { return Kind == CoprocReg; } 4158462b30548fb5969250858036638c73c16b65b43Daniel Dunbar bool isCondCode() const { return Kind == CondCode; } 416d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach bool isCCOut() const { return Kind == CCOut; } 4173483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar bool isImm() const { return Kind == Immediate; } 4186b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach bool isImm0_255() const { 4196b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach if (Kind != Immediate) 4206b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach return false; 4216b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 4226b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach if (!CE) return false; 4236b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach int64_t Value = CE->getValue(); 4246b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach return Value >= 0 && Value < 256; 4256b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach } 42683ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach bool isImm0_7() const { 42783ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach if (Kind != Immediate) 42883ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach return false; 42983ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 43083ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach if (!CE) return false; 43183ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach int64_t Value = CE->getValue(); 43283ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach return Value >= 0 && Value < 8; 43383ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach } 43483ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach bool isImm0_15() const { 43583ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach if (Kind != Immediate) 43683ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach return false; 43783ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 43883ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach if (!CE) return false; 43983ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach int64_t Value = CE->getValue(); 44083ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach return Value >= 0 && Value < 16; 44183ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach } 4427c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach bool isImm0_31() const { 4437c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach if (Kind != Immediate) 4447c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach return false; 4457c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 4467c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach if (!CE) return false; 4477c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach int64_t Value = CE->getValue(); 4487c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach return Value >= 0 && Value < 32; 4497c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach } 450f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach bool isImm1_16() const { 451f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach if (Kind != Immediate) 452f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach return false; 453f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 454f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach if (!CE) return false; 455f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach int64_t Value = CE->getValue(); 456f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach return Value > 0 && Value < 17; 457f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach } 4584a5ffb399f841783c201c599b88d576757f1922eJim Grosbach bool isImm1_32() const { 4594a5ffb399f841783c201c599b88d576757f1922eJim Grosbach if (Kind != Immediate) 4604a5ffb399f841783c201c599b88d576757f1922eJim Grosbach return false; 4614a5ffb399f841783c201c599b88d576757f1922eJim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 4624a5ffb399f841783c201c599b88d576757f1922eJim Grosbach if (!CE) return false; 4634a5ffb399f841783c201c599b88d576757f1922eJim Grosbach int64_t Value = CE->getValue(); 4644a5ffb399f841783c201c599b88d576757f1922eJim Grosbach return Value > 0 && Value < 33; 4654a5ffb399f841783c201c599b88d576757f1922eJim Grosbach } 466fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach bool isImm0_65535() const { 467fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach if (Kind != Immediate) 468fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach return false; 469fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 470fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach if (!CE) return false; 471fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach int64_t Value = CE->getValue(); 472fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach return Value >= 0 && Value < 65536; 473fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach } 474ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach bool isImm0_65535Expr() const { 475ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach if (Kind != Immediate) 476ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach return false; 477ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 478ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // If it's not a constant expression, it'll generate a fixup and be 479ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // handled later. 480ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach if (!CE) return true; 481ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach int64_t Value = CE->getValue(); 482ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach return Value >= 0 && Value < 65536; 483ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach } 484ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach bool isImm24bit() const { 485ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach if (Kind != Immediate) 486ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach return false; 487ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 488ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach if (!CE) return false; 489ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach int64_t Value = CE->getValue(); 490ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach return Value >= 0 && Value <= 0xffffff; 491ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach } 492f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach bool isPKHLSLImm() const { 493f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (Kind != Immediate) 494f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return false; 495f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 496f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (!CE) return false; 497f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach int64_t Value = CE->getValue(); 498f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return Value >= 0 && Value < 32; 499f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 500f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach bool isPKHASRImm() const { 501f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (Kind != Immediate) 502f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return false; 503f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 504f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (!CE) return false; 505f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach int64_t Value = CE->getValue(); 506f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return Value > 0 && Value <= 32; 507f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 5086bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach bool isARMSOImm() const { 5096bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach if (Kind != Immediate) 5106bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach return false; 5116bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 5126bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach if (!CE) return false; 5136bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach int64_t Value = CE->getValue(); 5146bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach return ARM_AM::getSOImmVal(Value) != -1; 5156bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach } 5166b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach bool isT2SOImm() const { 5176b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach if (Kind != Immediate) 5186b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach return false; 5196b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 5206b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach if (!CE) return false; 5216b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach int64_t Value = CE->getValue(); 5226b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach return ARM_AM::getT2SOImmVal(Value) != -1; 5236b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach } 524c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach bool isSetEndImm() const { 525c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach if (Kind != Immediate) 526c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach return false; 527c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 528c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach if (!CE) return false; 529c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach int64_t Value = CE->getValue(); 530c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach return Value == 1 || Value == 0; 531c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach } 532b32e7844e9f79d2bd4ff34a1d19aba347f999abcBill Wendling bool isReg() const { return Kind == Register; } 5338d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling bool isRegList() const { return Kind == RegisterList; } 5340f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling bool isDPRRegList() const { return Kind == DPRRegisterList; } 5350f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling bool isSPRRegList() const { return Kind == SPRRegisterList; } 53614b93851cc7611ae6c2000f1c162592ead954420Chris Lattner bool isToken() const { return Kind == Token; } 537706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes bool isMemBarrierOpt() const { return Kind == MemBarrierOpt; } 53814b93851cc7611ae6c2000f1c162592ead954420Chris Lattner bool isMemory() const { return Kind == Memory; } 539580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach bool isShifterImm() const { return Kind == ShifterImmediate; } 540af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach bool isRegShiftedReg() const { return Kind == ShiftedRegister; } 541af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach bool isRegShiftedImm() const { return Kind == ShiftedImmediate; } 5427e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach bool isRotImm() const { return Kind == RotateImmediate; } 543ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes bool isMemMode2() const { 544ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (getMemAddrMode() != ARMII::AddrMode2) 545ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return false; 546ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 547ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (getMemOffsetIsReg()) 548ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return true; 549ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 550ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (getMemNegative() && 551ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes !(getMemPostindexed() || getMemPreindexed())) 552ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return false; 553ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 554ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 555ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (!CE) return false; 556ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes int64_t Value = CE->getValue(); 557ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 558ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // The offset must be in the range 0-4095 (imm12). 559ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (Value > 4095 || Value < -4095) 560ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return false; 561ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 562ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return true; 563ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes } 564ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes bool isMemMode3() const { 565ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (getMemAddrMode() != ARMII::AddrMode3) 566ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return false; 567ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 568ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (getMemOffsetIsReg()) { 569ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (getMemOffsetRegShifted()) 570ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return false; // No shift with offset reg allowed 571ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return true; 572ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } 573ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 574ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (getMemNegative() && 575ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes !(getMemPostindexed() || getMemPreindexed())) 576ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return false; 577ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 578ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 579ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (!CE) return false; 580ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes int64_t Value = CE->getValue(); 581ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 582ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // The offset must be in the range 0-255 (imm8). 583ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (Value > 255 || Value < -255) 584ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return false; 585ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 586ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return true; 587ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } 58887f4f9a946549ad93046990a364ac5190333a7ebBill Wendling bool isMemMode5() const { 5894b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar if (!isMemory() || getMemOffsetIsReg() || getMemWriteback() || 5904b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar getMemNegative()) 59187f4f9a946549ad93046990a364ac5190333a7ebBill Wendling return false; 592ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling 5934b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 594ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling if (!CE) return false; 595ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling 59687f4f9a946549ad93046990a364ac5190333a7ebBill Wendling // The offset must be a multiple of 4 in the range 0-1020. 59787f4f9a946549ad93046990a364ac5190333a7ebBill Wendling int64_t Value = CE->getValue(); 59887f4f9a946549ad93046990a364ac5190333a7ebBill Wendling return ((Value & 0x3) == 0 && Value <= 1020 && Value >= -1020); 59987f4f9a946549ad93046990a364ac5190333a7ebBill Wendling } 600505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes bool isMemMode7() const { 601505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes if (!isMemory() || 602505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes getMemPreindexed() || 603505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes getMemPostindexed() || 604505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes getMemOffsetIsReg() || 605505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes getMemNegative() || 606505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes getMemWriteback()) 607505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes return false; 608505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes 609505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 610505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes if (!CE) return false; 611505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes 612505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes if (CE->getValue()) 613505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes return false; 614505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes 615505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes return true; 616505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes } 617f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling bool isMemModeRegThumb() const { 6184b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar if (!isMemory() || !getMemOffsetIsReg() || getMemWriteback()) 619f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling return false; 620d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar return true; 621f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling } 622f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling bool isMemModeImmThumb() const { 6234b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar if (!isMemory() || getMemOffsetIsReg() || getMemWriteback()) 624ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling return false; 625ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling 6264b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 627ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling if (!CE) return false; 628ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling 629ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling // The offset must be a multiple of 4 in the range 0-124. 630ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling uint64_t Value = CE->getValue(); 631ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling return ((Value & 0x3) == 0 && Value <= 124); 632ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling } 633584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes bool isMSRMask() const { return Kind == MSRMask; } 634a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes bool isProcIFlags() const { return Kind == ProcIFlags; } 6353483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 6363483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar void addExpr(MCInst &Inst, const MCExpr *Expr) const { 63714b93851cc7611ae6c2000f1c162592ead954420Chris Lattner // Add as immediates when possible. Null MCExpr = 0. 63814b93851cc7611ae6c2000f1c162592ead954420Chris Lattner if (Expr == 0) 63914b93851cc7611ae6c2000f1c162592ead954420Chris Lattner Inst.addOperand(MCOperand::CreateImm(0)); 64014b93851cc7611ae6c2000f1c162592ead954420Chris Lattner else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr)) 6413483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar Inst.addOperand(MCOperand::CreateImm(CE->getValue())); 6423483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar else 6433483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar Inst.addOperand(MCOperand::CreateExpr(Expr)); 6443483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar } 6453483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 6468462b30548fb5969250858036638c73c16b65b43Daniel Dunbar void addCondCodeOperands(MCInst &Inst, unsigned N) const { 647345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar assert(N == 2 && "Invalid number of operands!"); 6488462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode()))); 64904f74942f2994a7c1d8e62c207c4005ed4652b6aJim Grosbach unsigned RegNum = getCondCode() == ARMCC::AL ? 0: ARM::CPSR; 65004f74942f2994a7c1d8e62c207c4005ed4652b6aJim Grosbach Inst.addOperand(MCOperand::CreateReg(RegNum)); 6518462b30548fb5969250858036638c73c16b65b43Daniel Dunbar } 6528462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 653fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes void addCoprocNumOperands(MCInst &Inst, unsigned N) const { 654fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes assert(N == 1 && "Invalid number of operands!"); 655fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(getCoproc())); 656fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } 657fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 658fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes void addCoprocRegOperands(MCInst &Inst, unsigned N) const { 659fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes assert(N == 1 && "Invalid number of operands!"); 660fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(getCoproc())); 661fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } 662fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 663d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach void addCCOutOperands(MCInst &Inst, unsigned N) const { 664d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach assert(N == 1 && "Invalid number of operands!"); 665d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach Inst.addOperand(MCOperand::CreateReg(getReg())); 666d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach } 667d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach 668a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby void addRegOperands(MCInst &Inst, unsigned N) const { 669a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby assert(N == 1 && "Invalid number of operands!"); 670a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Inst.addOperand(MCOperand::CreateReg(getReg())); 671a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 672a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 673af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach void addRegShiftedRegOperands(MCInst &Inst, unsigned N) const { 674e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach assert(N == 3 && "Invalid number of operands!"); 675af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach assert(isRegShiftedReg() && "addRegShiftedRegOperands() on non RegShiftedReg!"); 676af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.SrcReg)); 677af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.ShiftReg)); 678e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Inst.addOperand(MCOperand::CreateImm( 679af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach ARM_AM::getSORegOpc(RegShiftedReg.ShiftTy, RegShiftedReg.ShiftImm))); 680e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } 681e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 682af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach void addRegShiftedImmOperands(MCInst &Inst, unsigned N) const { 683152d4a4bb6b75de740b4b8a9f48abb9069d50c17Owen Anderson assert(N == 2 && "Invalid number of operands!"); 684af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach assert(isRegShiftedImm() && "addRegShiftedImmOperands() on non RegShiftedImm!"); 685af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach Inst.addOperand(MCOperand::CreateReg(RegShiftedImm.SrcReg)); 68692a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson Inst.addOperand(MCOperand::CreateImm( 687af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach ARM_AM::getSORegOpc(RegShiftedImm.ShiftTy, RegShiftedImm.ShiftImm))); 68892a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson } 68992a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson 69092a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson 691580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach void addShifterImmOperands(MCInst &Inst, unsigned N) const { 6920082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson assert(N == 1 && "Invalid number of operands!"); 693580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Inst.addOperand(MCOperand::CreateImm((ShifterImm.isASR << 5) | 694580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach ShifterImm.Imm)); 6950082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson } 6960082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 69787f4f9a946549ad93046990a364ac5190333a7ebBill Wendling void addRegListOperands(MCInst &Inst, unsigned N) const { 6987729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling assert(N == 1 && "Invalid number of operands!"); 6995fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling const SmallVectorImpl<unsigned> &RegList = getRegList(); 7005fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling for (SmallVectorImpl<unsigned>::const_iterator 7017729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling I = RegList.begin(), E = RegList.end(); I != E; ++I) 7027729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling Inst.addOperand(MCOperand::CreateReg(*I)); 70387f4f9a946549ad93046990a364ac5190333a7ebBill Wendling } 70487f4f9a946549ad93046990a364ac5190333a7ebBill Wendling 7050f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling void addDPRRegListOperands(MCInst &Inst, unsigned N) const { 7060f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling addRegListOperands(Inst, N); 7070f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling } 7080f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling 7090f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling void addSPRRegListOperands(MCInst &Inst, unsigned N) const { 7100f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling addRegListOperands(Inst, N); 7110f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling } 7120f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling 7137e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach void addRotImmOperands(MCInst &Inst, unsigned N) const { 7147e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 7157e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // Encoded as val>>3. The printer handles display as 8, 16, 24. 7167e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Inst.addOperand(MCOperand::CreateImm(RotImm.Imm >> 3)); 7177e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach } 7187e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 7193483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar void addImmOperands(MCInst &Inst, unsigned N) const { 7206b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 7216b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach addExpr(Inst, getImm()); 7226b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach } 7236b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach 7246b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach void addImm0_255Operands(MCInst &Inst, unsigned N) const { 7256b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 7266b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach addExpr(Inst, getImm()); 7276b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach } 7286b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach 72983ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach void addImm0_7Operands(MCInst &Inst, unsigned N) const { 73083ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 73183ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach addExpr(Inst, getImm()); 73283ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach } 73383ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach 73483ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach void addImm0_15Operands(MCInst &Inst, unsigned N) const { 7357c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 7367c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach addExpr(Inst, getImm()); 7377c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach } 7387c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach 7397c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach void addImm0_31Operands(MCInst &Inst, unsigned N) const { 74083ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 74183ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach addExpr(Inst, getImm()); 74283ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach } 74383ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach 744f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach void addImm1_16Operands(MCInst &Inst, unsigned N) const { 745f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach assert(N == 1 && "Invalid number of operands!"); 746f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach // The constant encodes as the immediate-1, and we store in the instruction 747f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach // the bits as encoded, so subtract off one here. 748f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 749f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1)); 750f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach } 751f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach 7524a5ffb399f841783c201c599b88d576757f1922eJim Grosbach void addImm1_32Operands(MCInst &Inst, unsigned N) const { 7534a5ffb399f841783c201c599b88d576757f1922eJim Grosbach assert(N == 1 && "Invalid number of operands!"); 7544a5ffb399f841783c201c599b88d576757f1922eJim Grosbach // The constant encodes as the immediate-1, and we store in the instruction 7554a5ffb399f841783c201c599b88d576757f1922eJim Grosbach // the bits as encoded, so subtract off one here. 7564a5ffb399f841783c201c599b88d576757f1922eJim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 7574a5ffb399f841783c201c599b88d576757f1922eJim Grosbach Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1)); 7584a5ffb399f841783c201c599b88d576757f1922eJim Grosbach } 7594a5ffb399f841783c201c599b88d576757f1922eJim Grosbach 760fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach void addImm0_65535Operands(MCInst &Inst, unsigned N) const { 761fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach assert(N == 1 && "Invalid number of operands!"); 762fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach addExpr(Inst, getImm()); 763fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach } 764fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach 765ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach void addImm0_65535ExprOperands(MCInst &Inst, unsigned N) const { 766ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 767ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach addExpr(Inst, getImm()); 768ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach } 769ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach 770ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach void addImm24bitOperands(MCInst &Inst, unsigned N) const { 771ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach assert(N == 1 && "Invalid number of operands!"); 772ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach addExpr(Inst, getImm()); 773ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach } 774ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 775f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach void addPKHLSLImmOperands(MCInst &Inst, unsigned N) const { 776f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 777f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach addExpr(Inst, getImm()); 778f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 779f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 780f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach void addPKHASRImmOperands(MCInst &Inst, unsigned N) const { 781f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 782f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // An ASR value of 32 encodes as 0, so that's how we want to add it to 783f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // the instruction as well. 784f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 785f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach int Val = CE->getValue(); 786f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Inst.addOperand(MCOperand::CreateImm(Val == 32 ? 0 : Val)); 787f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 788f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 7896bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach void addARMSOImmOperands(MCInst &Inst, unsigned N) const { 7906bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach assert(N == 1 && "Invalid number of operands!"); 7916bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach addExpr(Inst, getImm()); 7926bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach } 7936bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach 7946b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach void addT2SOImmOperands(MCInst &Inst, unsigned N) const { 7953483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar assert(N == 1 && "Invalid number of operands!"); 7963483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar addExpr(Inst, getImm()); 7973483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar } 79816c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 799c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach void addSetEndImmOperands(MCInst &Inst, unsigned N) const { 800c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 801c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach addExpr(Inst, getImm()); 802c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach } 803c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach 804706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes void addMemBarrierOptOperands(MCInst &Inst, unsigned N) const { 805706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes assert(N == 1 && "Invalid number of operands!"); 806706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(unsigned(getMemBarrierOpt()))); 807706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes } 808706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 809505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes void addMemMode7Operands(MCInst &Inst, unsigned N) const { 810505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes assert(N == 1 && isMemMode7() && "Invalid number of operands!"); 811505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum())); 812505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes 813505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 8141866af4a982be999e4d0c08c38ebec71f3ed4025Matt Beaumont-Gay (void)CE; 815505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes assert((CE || CE->getValue() == 0) && 816505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes "No offset operand support in mode 7"); 817505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes } 818505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes 819ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes void addMemMode2Operands(MCInst &Inst, unsigned N) const { 820ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes assert(isMemMode2() && "Invalid mode or number of operands!"); 821ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum())); 822ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes unsigned IdxMode = (getMemPreindexed() | getMemPostindexed() << 1); 823ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 824ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (getMemOffsetIsReg()) { 825ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(getMemOffsetRegNum())); 826ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 827ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ARM_AM::AddrOpc AMOpc = getMemNegative() ? ARM_AM::sub : ARM_AM::add; 828ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ARM_AM::ShiftOpc ShOpc = ARM_AM::no_shift; 829ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes int64_t ShiftAmount = 0; 830ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 831ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (getMemOffsetRegShifted()) { 832ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ShOpc = getMemShiftType(); 833ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const MCConstantExpr *CE = 834ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes dyn_cast<MCConstantExpr>(getMemShiftAmount()); 835ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ShiftAmount = CE->getValue(); 836ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes } 837ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 838ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM2Opc(AMOpc, ShiftAmount, 839ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ShOpc, IdxMode))); 840ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return; 841ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes } 842ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 843ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // Create a operand placeholder to always yield the same number of operands. 844ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(0)); 845ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 846ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // FIXME: #-0 is encoded differently than #0. Does the parser preserve 847ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // the difference? 848ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 849ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes assert(CE && "Non-constant mode 2 offset operand!"); 850ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes int64_t Offset = CE->getValue(); 851ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 852ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (Offset >= 0) 853ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM2Opc(ARM_AM::add, 854ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Offset, ARM_AM::no_shift, IdxMode))); 855ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes else 856ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM2Opc(ARM_AM::sub, 857ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes -Offset, ARM_AM::no_shift, IdxMode))); 858ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes } 859ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 860ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes void addMemMode3Operands(MCInst &Inst, unsigned N) const { 861ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes assert(isMemMode3() && "Invalid mode or number of operands!"); 862ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum())); 863ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes unsigned IdxMode = (getMemPreindexed() | getMemPostindexed() << 1); 864ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 865ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (getMemOffsetIsReg()) { 866ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(getMemOffsetRegNum())); 867ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 868ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ARM_AM::AddrOpc AMOpc = getMemNegative() ? ARM_AM::sub : ARM_AM::add; 869ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM3Opc(AMOpc, 0, 870ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes IdxMode))); 871ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return; 872ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } 873ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 874ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // Create a operand placeholder to always yield the same number of operands. 875ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(0)); 876ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 877ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // FIXME: #-0 is encoded differently than #0. Does the parser preserve 878ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // the difference? 879ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 880ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes assert(CE && "Non-constant mode 3 offset operand!"); 881ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes int64_t Offset = CE->getValue(); 882ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 883ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (Offset >= 0) 884ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM3Opc(ARM_AM::add, 885ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Offset, IdxMode))); 886ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes else 887ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM3Opc(ARM_AM::sub, 888ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes -Offset, IdxMode))); 889ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } 890ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 89114b93851cc7611ae6c2000f1c162592ead954420Chris Lattner void addMemMode5Operands(MCInst &Inst, unsigned N) const { 89214b93851cc7611ae6c2000f1c162592ead954420Chris Lattner assert(N == 2 && isMemMode5() && "Invalid number of operands!"); 89316c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 8944b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum())); 8954b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar assert(!getMemOffsetIsReg() && "Invalid mode 5 operand"); 89692b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling 89780eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // FIXME: #-0 is encoded differently than #0. Does the parser preserve 89880eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // the difference? 8994b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 900d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar assert(CE && "Non-constant mode 5 offset operand!"); 901d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar 902d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar // The MCInst offset operand doesn't include the low two bits (like 903d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar // the instruction encoding). 904d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar int64_t Offset = CE->getValue() / 4; 905d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar if (Offset >= 0) 906d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(ARM_AM::add, 907d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar Offset))); 908d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar else 909d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(ARM_AM::sub, 910d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar -Offset))); 91114b93851cc7611ae6c2000f1c162592ead954420Chris Lattner } 9123483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 913f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling void addMemModeRegThumbOperands(MCInst &Inst, unsigned N) const { 914f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling assert(N == 2 && isMemModeRegThumb() && "Invalid number of operands!"); 9154b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum())); 9164b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar Inst.addOperand(MCOperand::CreateReg(getMemOffsetRegNum())); 917f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling } 918ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling 919f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling void addMemModeImmThumbOperands(MCInst &Inst, unsigned N) const { 920f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling assert(N == 2 && isMemModeImmThumb() && "Invalid number of operands!"); 9214b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum())); 9224b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 923f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling assert(CE && "Non-constant mode offset operand!"); 924f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling Inst.addOperand(MCOperand::CreateImm(CE->getValue())); 925ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling } 926ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling 927584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes void addMSRMaskOperands(MCInst &Inst, unsigned N) const { 928584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes assert(N == 1 && "Invalid number of operands!"); 929584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(unsigned(getMSRMask()))); 930584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 931584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 932a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes void addProcIFlagsOperands(MCInst &Inst, unsigned N) const { 933a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes assert(N == 1 && "Invalid number of operands!"); 934a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(unsigned(getProcIFlags()))); 935a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 936a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 937b7f689bab98777236a2bf600f299d232d246bb61Jim Grosbach virtual void print(raw_ostream &OS) const; 938b3cb6967949493a2e1b10d015ac08b746736764eDaniel Dunbar 9393a69756e392942bc522193f38d7f33958ed3b131Chris Lattner static ARMOperand *CreateCondCode(ARMCC::CondCodes CC, SMLoc S) { 9403a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(CondCode); 941345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Op->CC.Val = CC; 942345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Op->StartLoc = S; 943345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Op->EndLoc = S; 9443a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 945345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar } 946345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 947fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes static ARMOperand *CreateCoprocNum(unsigned CopVal, SMLoc S) { 948fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes ARMOperand *Op = new ARMOperand(CoprocNum); 949fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Op->Cop.Val = CopVal; 950fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Op->StartLoc = S; 951fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Op->EndLoc = S; 952fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes return Op; 953fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } 954fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 955fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes static ARMOperand *CreateCoprocReg(unsigned CopVal, SMLoc S) { 956fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes ARMOperand *Op = new ARMOperand(CoprocReg); 957fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Op->Cop.Val = CopVal; 958fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Op->StartLoc = S; 959fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Op->EndLoc = S; 960fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes return Op; 961fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } 962fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 963d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach static ARMOperand *CreateCCOut(unsigned RegNum, SMLoc S) { 964d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach ARMOperand *Op = new ARMOperand(CCOut); 965d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach Op->Reg.RegNum = RegNum; 966d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach Op->StartLoc = S; 967d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach Op->EndLoc = S; 968d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach return Op; 969d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach } 970d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach 9713a69756e392942bc522193f38d7f33958ed3b131Chris Lattner static ARMOperand *CreateToken(StringRef Str, SMLoc S) { 9723a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(Token); 973762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Tok.Data = Str.data(); 974762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Tok.Length = Str.size(); 975762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->StartLoc = S; 976762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->EndLoc = S; 9773a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 978a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 979a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 98050d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling static ARMOperand *CreateReg(unsigned RegNum, SMLoc S, SMLoc E) { 9813a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(Register); 982762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Reg.RegNum = RegNum; 983762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->StartLoc = S; 984762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->EndLoc = E; 9853a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 986a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 987a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 988e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach static ARMOperand *CreateShiftedRegister(ARM_AM::ShiftOpc ShTy, 989e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned SrcReg, 990e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned ShiftReg, 991e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned ShiftImm, 992e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach SMLoc S, SMLoc E) { 993e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ARMOperand *Op = new ARMOperand(ShiftedRegister); 994af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach Op->RegShiftedReg.ShiftTy = ShTy; 995af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach Op->RegShiftedReg.SrcReg = SrcReg; 996af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach Op->RegShiftedReg.ShiftReg = ShiftReg; 997af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach Op->RegShiftedReg.ShiftImm = ShiftImm; 998e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Op->StartLoc = S; 999e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Op->EndLoc = E; 1000e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach return Op; 1001e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } 1002e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 100392a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson static ARMOperand *CreateShiftedImmediate(ARM_AM::ShiftOpc ShTy, 100492a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson unsigned SrcReg, 100592a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson unsigned ShiftImm, 100692a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson SMLoc S, SMLoc E) { 100792a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson ARMOperand *Op = new ARMOperand(ShiftedImmediate); 1008af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach Op->RegShiftedImm.ShiftTy = ShTy; 1009af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach Op->RegShiftedImm.SrcReg = SrcReg; 1010af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach Op->RegShiftedImm.ShiftImm = ShiftImm; 101192a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson Op->StartLoc = S; 101292a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson Op->EndLoc = E; 101392a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson return Op; 101492a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson } 101592a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson 1016580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach static ARMOperand *CreateShifterImm(bool isASR, unsigned Imm, 10170082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson SMLoc S, SMLoc E) { 1018580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach ARMOperand *Op = new ARMOperand(ShifterImmediate); 1019580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Op->ShifterImm.isASR = isASR; 1020580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Op->ShifterImm.Imm = Imm; 10210082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson Op->StartLoc = S; 10220082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson Op->EndLoc = E; 10230082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson return Op; 10240082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson } 10250082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 10267e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach static ARMOperand *CreateRotImm(unsigned Imm, SMLoc S, SMLoc E) { 10277e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach ARMOperand *Op = new ARMOperand(RotateImmediate); 10287e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Op->RotImm.Imm = Imm; 10297e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Op->StartLoc = S; 10307e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Op->EndLoc = E; 10317e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach return Op; 10327e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach } 10337e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 10347729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling static ARMOperand * 10355fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling CreateRegList(const SmallVectorImpl<std::pair<unsigned, SMLoc> > &Regs, 1036cc8d10e1a8a8555fa63f33e36e3c1ed2fb24389dMatt Beaumont-Gay SMLoc StartLoc, SMLoc EndLoc) { 10370f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling KindTy Kind = RegisterList; 10380f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling 1039275944afb55086d0b4b20d4d831de7c1c7507925Evan Cheng if (llvm::ARMMCRegisterClasses[ARM::DPRRegClassID]. 1040275944afb55086d0b4b20d4d831de7c1c7507925Evan Cheng contains(Regs.front().first)) 10410f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling Kind = DPRRegisterList; 1042275944afb55086d0b4b20d4d831de7c1c7507925Evan Cheng else if (llvm::ARMMCRegisterClasses[ARM::SPRRegClassID]. 1043275944afb55086d0b4b20d4d831de7c1c7507925Evan Cheng contains(Regs.front().first)) 10440f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling Kind = SPRRegisterList; 10450f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling 10460f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling ARMOperand *Op = new ARMOperand(Kind); 10475fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling for (SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator 10487729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling I = Regs.begin(), E = Regs.end(); I != E; ++I) 104924d22d27640e9de954a5ac26f51a45cc96bb9135Bill Wendling Op->Registers.push_back(I->first); 1050cb21d1c9fd1cf53f063183f7eb28af7fa4052ef0Bill Wendling array_pod_sort(Op->Registers.begin(), Op->Registers.end()); 1051cc8d10e1a8a8555fa63f33e36e3c1ed2fb24389dMatt Beaumont-Gay Op->StartLoc = StartLoc; 1052cc8d10e1a8a8555fa63f33e36e3c1ed2fb24389dMatt Beaumont-Gay Op->EndLoc = EndLoc; 10538d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling return Op; 10548d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } 10558d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 10563a69756e392942bc522193f38d7f33958ed3b131Chris Lattner static ARMOperand *CreateImm(const MCExpr *Val, SMLoc S, SMLoc E) { 10573a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(Immediate); 1058762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Imm.Val = Val; 1059762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->StartLoc = S; 1060762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->EndLoc = E; 10613a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 1062cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby } 1063cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby 1064ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes static ARMOperand *CreateMem(ARMII::AddrMode AddrMode, unsigned BaseRegNum, 1065ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes bool OffsetIsReg, const MCExpr *Offset, 1066ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes int OffsetRegNum, bool OffsetRegShifted, 10670082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson enum ARM_AM::ShiftOpc ShiftType, 10683a69756e392942bc522193f38d7f33958ed3b131Chris Lattner const MCExpr *ShiftAmount, bool Preindexed, 10693a69756e392942bc522193f38d7f33958ed3b131Chris Lattner bool Postindexed, bool Negative, bool Writeback, 10703a69756e392942bc522193f38d7f33958ed3b131Chris Lattner SMLoc S, SMLoc E) { 1071023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar assert((OffsetRegNum == -1 || OffsetIsReg) && 1072023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar "OffsetRegNum must imply OffsetIsReg!"); 1073023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar assert((!OffsetRegShifted || OffsetIsReg) && 1074023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar "OffsetRegShifted must imply OffsetIsReg!"); 1075d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar assert((Offset || OffsetIsReg) && 1076d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar "Offset must exists unless register offset is used!"); 1077023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar assert((!ShiftAmount || (OffsetIsReg && OffsetRegShifted)) && 1078023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar "Cannot have shift amount without shifted register offset!"); 1079023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar assert((!Offset || !OffsetIsReg) && 1080023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar "Cannot have expression offset and register offset!"); 1081023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar 10823a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(Memory); 1083ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Op->Mem.AddrMode = AddrMode; 1084762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.BaseRegNum = BaseRegNum; 1085762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.OffsetIsReg = OffsetIsReg; 10862637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar if (OffsetIsReg) 10872637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar Op->Mem.Offset.RegNum = OffsetRegNum; 10882637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar else 10892637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar Op->Mem.Offset.Value = Offset; 1090762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.OffsetRegShifted = OffsetRegShifted; 1091762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.ShiftType = ShiftType; 1092762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.ShiftAmount = ShiftAmount; 1093762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.Preindexed = Preindexed; 1094762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.Postindexed = Postindexed; 1095762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.Negative = Negative; 1096762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.Writeback = Writeback; 109716c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 1098762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->StartLoc = S; 1099762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->EndLoc = E; 11003a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 1101a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 1102706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 1103706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes static ARMOperand *CreateMemBarrierOpt(ARM_MB::MemBOpt Opt, SMLoc S) { 1104706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes ARMOperand *Op = new ARMOperand(MemBarrierOpt); 1105706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Op->MBOpt.Val = Opt; 1106706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Op->StartLoc = S; 1107706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Op->EndLoc = S; 1108706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes return Op; 1109706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes } 1110a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 1111a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes static ARMOperand *CreateProcIFlags(ARM_PROC::IFlags IFlags, SMLoc S) { 1112a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ARMOperand *Op = new ARMOperand(ProcIFlags); 1113a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Op->IFlags.Val = IFlags; 1114a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Op->StartLoc = S; 1115a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Op->EndLoc = S; 1116a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes return Op; 1117a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 1118584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1119584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes static ARMOperand *CreateMSRMask(unsigned MMask, SMLoc S) { 1120584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes ARMOperand *Op = new ARMOperand(MSRMask); 1121584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Op->MMask.Val = MMask; 1122584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Op->StartLoc = S; 1123584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Op->EndLoc = S; 1124584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return Op; 1125584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 1126a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby}; 1127a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 1128a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} // end anonymous namespace. 1129a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 1130b7f689bab98777236a2bf600f299d232d246bb61Jim Grosbachvoid ARMOperand::print(raw_ostream &OS) const { 1131fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar switch (Kind) { 1132fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case CondCode: 11336a5c22ed89c8bb73034a70105340acf6539dc58bDaniel Dunbar OS << "<ARMCC::" << ARMCondCodeToString(getCondCode()) << ">"; 1134fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 1135d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach case CCOut: 1136d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach OS << "<ccout " << getReg() << ">"; 1137d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach break; 1138fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes case CoprocNum: 1139fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes OS << "<coprocessor number: " << getCoproc() << ">"; 1140fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes break; 1141fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes case CoprocReg: 1142fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes OS << "<coprocessor register: " << getCoproc() << ">"; 1143fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes break; 1144584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes case MSRMask: 1145584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes OS << "<mask: " << getMSRMask() << ">"; 1146584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes break; 1147fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case Immediate: 1148fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar getImm()->print(OS); 1149fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 1150706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes case MemBarrierOpt: 1151706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes OS << "<ARM_MB::" << MemBOptToString(getMemBarrierOpt()) << ">"; 1152706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes break; 1153fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case Memory: 11546ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << "<memory " 1155ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes << "am:" << ARMII::AddrModeToString(getMemAddrMode()) 1156ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes << " base:" << getMemBaseRegNum(); 11576ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemOffsetIsReg()) { 11586ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " offset:<register " << getMemOffsetRegNum(); 11596ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemOffsetRegShifted()) { 11606ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " offset-shift-type:" << getMemShiftType(); 11616ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " offset-shift-amount:" << *getMemShiftAmount(); 11626ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 11636ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } else { 11646ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " offset:" << *getMemOffset(); 11656ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 11666ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemOffsetIsReg()) 11676ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " (offset-is-reg)"; 11686ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemPreindexed()) 11696ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " (pre-indexed)"; 11706ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemPostindexed()) 11716ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " (post-indexed)"; 11726ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemNegative()) 11736ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " (negative)"; 11746ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemWriteback()) 11756ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " (writeback)"; 11766ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << ">"; 1177fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 1178a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes case ProcIFlags: { 1179a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes OS << "<ARM_PROC::"; 1180a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes unsigned IFlags = getProcIFlags(); 1181a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes for (int i=2; i >= 0; --i) 1182a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (IFlags & (1 << i)) 1183a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes OS << ARM_PROC::IFlagsToString(1 << i); 1184a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes OS << ">"; 1185a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes break; 1186a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 1187fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case Register: 118850d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling OS << "<register " << getReg() << ">"; 1189fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 1190580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach case ShifterImmediate: 1191580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach OS << "<shift " << (ShifterImm.isASR ? "asr" : "lsl") 1192580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach << " #" << ShifterImm.Imm << ">"; 1193e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach break; 1194e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach case ShiftedRegister: 119592a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson OS << "<so_reg_reg " 1196af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach << RegShiftedReg.SrcReg 1197af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(RegShiftedReg.ShiftImm)) 1198af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach << ", " << RegShiftedReg.ShiftReg << ", " 1199af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach << ARM_AM::getSORegOffset(RegShiftedReg.ShiftImm) 1200e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach << ">"; 12010082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson break; 120292a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson case ShiftedImmediate: 120392a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson OS << "<so_reg_imm " 1204af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach << RegShiftedImm.SrcReg 1205af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(RegShiftedImm.ShiftImm)) 1206af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach << ", " << ARM_AM::getSORegOffset(RegShiftedImm.ShiftImm) 120792a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson << ">"; 120892a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson break; 12097e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach case RotateImmediate: 12107e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach OS << "<ror " << " #" << (RotImm.Imm * 8) << ">"; 12117e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach break; 12120f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling case RegisterList: 12130f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling case DPRRegisterList: 12140f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling case SPRRegisterList: { 12158d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling OS << "<register_list "; 12168d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 12175fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling const SmallVectorImpl<unsigned> &RegList = getRegList(); 12185fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling for (SmallVectorImpl<unsigned>::const_iterator 12197729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling I = RegList.begin(), E = RegList.end(); I != E; ) { 12207729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling OS << *I; 12217729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling if (++I < E) OS << ", "; 12228d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } 12238d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 12248d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling OS << ">"; 12258d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling break; 12268d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } 1227fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case Token: 1228fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar OS << "'" << getToken() << "'"; 1229fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 1230fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar } 1231fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar} 12323483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 12333483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar/// @name Auto-generated Match Functions 12343483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar/// { 12353483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 12363483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbarstatic unsigned MatchRegisterName(StringRef Name); 12373483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 12383483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar/// } 12393483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 124069df72367f45c0414541196efaf7c13b1ccd3f08Bob Wilsonbool ARMAsmParser::ParseRegister(unsigned &RegNo, 124169df72367f45c0414541196efaf7c13b1ccd3f08Bob Wilson SMLoc &StartLoc, SMLoc &EndLoc) { 12421355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach RegNo = tryParseRegister(); 1243bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky 1244bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky return (RegNo == (unsigned)-1); 1245bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky} 1246bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky 12479c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Try to parse a register name. The token must be an Identifier when called, 1248e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// and if it is a register name the token is eaten and the register number is 1249e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// returned. Otherwise return -1. 12503a69756e392942bc522193f38d7f33958ed3b131Chris Lattner/// 12511355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbachint ARMAsmParser::tryParseRegister() { 125218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 1253a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 1254d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach 1255a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // FIXME: Validate register for the current architecture; we have to do 1256a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // validation later, so maybe there is no need for this here. 12570c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson std::string upperCase = Tok.getString().str(); 12580c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson std::string lowerCase = LowercaseString(upperCase); 12590c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson unsigned RegNum = MatchRegisterName(lowerCase); 12600c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson if (!RegNum) { 12610c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson RegNum = StringSwitch<unsigned>(lowerCase) 12620c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson .Case("r13", ARM::SP) 12630c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson .Case("r14", ARM::LR) 12640c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson .Case("r15", ARM::PC) 12650c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson .Case("ip", ARM::R12) 12660c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson .Default(0); 12670c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson } 12680c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson if (!RegNum) return -1; 126969df72367f45c0414541196efaf7c13b1ccd3f08Bob Wilson 1270b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat identifier token. 1271e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner return RegNum; 1272e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner} 1273d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach 127419906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach// Try to parse a shifter (e.g., "lsl <amt>"). On success, return 0. 127519906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach// If a recoverable error occurs, return 1. If an irrecoverable error 127619906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach// occurs, return -1. An irrecoverable error is one where tokens have been 127719906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach// consumed in the process of trying to parse the shifter (i.e., when it is 127819906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach// indeed a shifter operand, but malformed). 12790d87ec21d79c8622733b8367aa41067169602480Jim Grosbachint ARMAsmParser::tryParseShiftRegister( 12800082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 12810082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson SMLoc S = Parser.getTok().getLoc(); 12820082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson const AsmToken &Tok = Parser.getTok(); 12830082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 12840082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 12850082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson std::string upperCase = Tok.getString().str(); 12860082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson std::string lowerCase = LowercaseString(upperCase); 12870082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson ARM_AM::ShiftOpc ShiftTy = StringSwitch<ARM_AM::ShiftOpc>(lowerCase) 12880082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson .Case("lsl", ARM_AM::lsl) 12890082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson .Case("lsr", ARM_AM::lsr) 12900082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson .Case("asr", ARM_AM::asr) 12910082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson .Case("ror", ARM_AM::ror) 12920082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson .Case("rrx", ARM_AM::rrx) 12930082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson .Default(ARM_AM::no_shift); 12940082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 12950082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson if (ShiftTy == ARM_AM::no_shift) 129619906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return 1; 12970082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 1298e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Parser.Lex(); // Eat the operator. 1299e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 1300e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // The source register for the shift has already been added to the 1301e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // operand list, so we need to pop it off and combine it into the shifted 1302e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // register operand instead. 1303eac0796542d098caa371856d545faa6cdab5aad3Benjamin Kramer OwningPtr<ARMOperand> PrevOp((ARMOperand*)Operands.pop_back_val()); 1304e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach if (!PrevOp->isReg()) 1305e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach return Error(PrevOp->getStartLoc(), "shift must be of a register"); 1306e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach int SrcReg = PrevOp->getReg(); 1307e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach int64_t Imm = 0; 1308e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach int ShiftReg = 0; 1309e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach if (ShiftTy == ARM_AM::rrx) { 1310e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // RRX Doesn't have an explicit shift amount. The encoder expects 1311e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // the shift register to be the same as the source register. Seems odd, 1312e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // but OK. 1313e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ShiftReg = SrcReg; 1314e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } else { 1315e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // Figure out if this is shifted by a constant or a register (for non-RRX). 1316e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach if (Parser.getTok().is(AsmToken::Hash)) { 1317e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Parser.Lex(); // Eat hash. 1318e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach SMLoc ImmLoc = Parser.getTok().getLoc(); 1319e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach const MCExpr *ShiftExpr = 0; 132019906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach if (getParser().ParseExpression(ShiftExpr)) { 132119906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach Error(ImmLoc, "invalid immediate shift value"); 132219906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return -1; 132319906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach } 1324e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // The expression must be evaluatable as an immediate. 1325e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftExpr); 132619906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach if (!CE) { 132719906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach Error(ImmLoc, "invalid immediate shift value"); 132819906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return -1; 132919906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach } 1330e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // Range check the immediate. 1331e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // lsl, ror: 0 <= imm <= 31 1332e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // lsr, asr: 0 <= imm <= 32 1333e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Imm = CE->getValue(); 1334e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach if (Imm < 0 || 1335e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ((ShiftTy == ARM_AM::lsl || ShiftTy == ARM_AM::ror) && Imm > 31) || 1336e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ((ShiftTy == ARM_AM::lsr || ShiftTy == ARM_AM::asr) && Imm > 32)) { 133719906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach Error(ImmLoc, "immediate shift value out of range"); 133819906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return -1; 1339e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } 1340e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } else if (Parser.getTok().is(AsmToken::Identifier)) { 13411355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach ShiftReg = tryParseRegister(); 1342e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach SMLoc L = Parser.getTok().getLoc(); 134319906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach if (ShiftReg == -1) { 134419906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach Error (L, "expected immediate or register in shift operand"); 134519906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return -1; 134619906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach } 134719906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach } else { 134819906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach Error (Parser.getTok().getLoc(), 1349e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach "expected immediate or register in shift operand"); 135019906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return -1; 135119906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach } 1352e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } 1353e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 135492a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson if (ShiftReg && ShiftTy != ARM_AM::rrx) 135592a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson Operands.push_back(ARMOperand::CreateShiftedRegister(ShiftTy, SrcReg, 1356af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach ShiftReg, Imm, 13570082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson S, Parser.getTok().getLoc())); 135892a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson else 135992a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson Operands.push_back(ARMOperand::CreateShiftedImmediate(ShiftTy, SrcReg, Imm, 136092a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson S, Parser.getTok().getLoc())); 13610082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 136219906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return 0; 13630082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson} 13640082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 13650082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 136650d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling/// Try to parse a register name. The token must be an Identifier when called. 136750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling/// If it's a register, an AsmOperand is created. Another AsmOperand is created 136850d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling/// if there is a "writeback". 'true' if it's not a register. 1369e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// 1370e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// TODO this is likely to change to allow different register types and or to 1371e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// parse for a specific register type. 137250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendlingbool ARMAsmParser:: 13731355cf1f76abe9699cd1c2838da132ff8b25b76bJim GrosbachtryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1374e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner SMLoc S = Parser.getTok().getLoc(); 13751355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach int RegNo = tryParseRegister(); 1376e717610f53e0465cde198536561a3c00ce29d59fBill Wendling if (RegNo == -1) 137750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1378d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach 137950d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling Operands.push_back(ARMOperand::CreateReg(RegNo, S, Parser.getTok().getLoc())); 1380a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 1381e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner const AsmToken &ExclaimTok = Parser.getTok(); 1382e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner if (ExclaimTok.is(AsmToken::Exclaim)) { 138350d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling Operands.push_back(ARMOperand::CreateToken(ExclaimTok.getString(), 138450d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling ExclaimTok.getLoc())); 1385e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner Parser.Lex(); // Eat exclaim token 138699e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby } 138799e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby 138850d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return false; 1389a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 1390a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 1391fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// MatchCoprocessorOperandName - Try to parse an coprocessor related 1392fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// instruction with a symbolic operand name. Example: "p1", "p7", "c3", 1393fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// "c5", ... 1394fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopesstatic int MatchCoprocessorOperandName(StringRef Name, char CoprocOp) { 1395e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // Use the same layout as the tablegen'erated register name matcher. Ugly, 1396e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // but efficient. 1397e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson switch (Name.size()) { 1398e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson default: break; 1399e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case 2: 1400fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes if (Name[0] != CoprocOp) 1401e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson return -1; 1402e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson switch (Name[1]) { 1403e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson default: return -1; 1404e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '0': return 0; 1405e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '1': return 1; 1406e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '2': return 2; 1407e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '3': return 3; 1408e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '4': return 4; 1409e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '5': return 5; 1410e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '6': return 6; 1411e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '7': return 7; 1412e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '8': return 8; 1413e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '9': return 9; 1414e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson } 1415e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson break; 1416e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case 3: 1417fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes if (Name[0] != CoprocOp || Name[1] != '1') 1418e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson return -1; 1419e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson switch (Name[2]) { 1420e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson default: return -1; 1421e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '0': return 10; 1422e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '1': return 11; 1423e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '2': return 12; 1424e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '3': return 13; 1425e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '4': return 14; 1426e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '5': return 15; 1427e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson } 1428e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson break; 1429e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson } 1430e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1431e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson return -1; 1432e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson} 1433e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 143443904299b05bdf579415749041f77c4490fe5f5bJim Grosbach/// parseCoprocNumOperand - Try to parse an coprocessor number operand. The 1435fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// token must be an Identifier when called, and if it is a coprocessor 1436fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// number, the token is eaten and the operand is added to the operand list. 1437f922c47143d247cbae14b294a0bada139bcd35f6Jim GrosbachARMAsmParser::OperandMatchResultTy ARMAsmParser:: 143843904299b05bdf579415749041f77c4490fe5f5bJim GrosbachparseCoprocNumOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1439e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson SMLoc S = Parser.getTok().getLoc(); 1440e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson const AsmToken &Tok = Parser.getTok(); 1441e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 1442e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1443fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes int Num = MatchCoprocessorOperandName(Tok.getString(), 'p'); 1444e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson if (Num == -1) 1445f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return MatchOperand_NoMatch; 1446e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1447e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson Parser.Lex(); // Eat identifier token. 1448fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateCoprocNum(Num, S)); 1449f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return MatchOperand_Success; 1450fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes} 1451fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 145243904299b05bdf579415749041f77c4490fe5f5bJim Grosbach/// parseCoprocRegOperand - Try to parse an coprocessor register operand. The 1453fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// token must be an Identifier when called, and if it is a coprocessor 1454fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// number, the token is eaten and the operand is added to the operand list. 1455f922c47143d247cbae14b294a0bada139bcd35f6Jim GrosbachARMAsmParser::OperandMatchResultTy ARMAsmParser:: 145643904299b05bdf579415749041f77c4490fe5f5bJim GrosbachparseCoprocRegOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1457fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes SMLoc S = Parser.getTok().getLoc(); 1458fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes const AsmToken &Tok = Parser.getTok(); 1459fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 1460fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1461fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes int Reg = MatchCoprocessorOperandName(Tok.getString(), 'c'); 1462fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes if (Reg == -1) 1463f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return MatchOperand_NoMatch; 1464fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1465fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Parser.Lex(); // Eat identifier token. 1466fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateCoprocReg(Reg, S)); 1467f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return MatchOperand_Success; 1468e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson} 1469e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1470c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner/// Parse a register list, return it if successful else return null. The first 1471c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner/// token must be a '{' when called. 147250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendlingbool ARMAsmParser:: 14731355cf1f76abe9699cd1c2838da132ff8b25b76bJim GrosbachparseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 147418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan assert(Parser.getTok().is(AsmToken::LCurly) && 1475a60f157b7c6fb60b33598fa5143ed8cb91aa5107Bill Wendling "Token is not a Left Curly Brace"); 1476e717610f53e0465cde198536561a3c00ce29d59fBill Wendling SMLoc S = Parser.getTok().getLoc(); 147716c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 14787729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling // Read the rest of the registers in the list. 14797729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling unsigned PrevRegNum = 0; 14805fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling SmallVector<std::pair<unsigned, SMLoc>, 32> Registers; 1481d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 14827729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling do { 1483e717610f53e0465cde198536561a3c00ce29d59fBill Wendling bool IsRange = Parser.getTok().is(AsmToken::Minus); 14847729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling Parser.Lex(); // Eat non-identifier token. 1485d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 148618b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &RegTok = Parser.getTok(); 1487d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby SMLoc RegLoc = RegTok.getLoc(); 1488c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner if (RegTok.isNot(AsmToken::Identifier)) { 1489c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner Error(RegLoc, "register expected"); 149050d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1491c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner } 1492e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 14931355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach int RegNum = tryParseRegister(); 1494c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner if (RegNum == -1) { 1495c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner Error(RegLoc, "register expected"); 149650d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1497c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner } 1498d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 1499e717610f53e0465cde198536561a3c00ce29d59fBill Wendling if (IsRange) { 1500e717610f53e0465cde198536561a3c00ce29d59fBill Wendling int Reg = PrevRegNum; 1501e717610f53e0465cde198536561a3c00ce29d59fBill Wendling do { 1502e717610f53e0465cde198536561a3c00ce29d59fBill Wendling ++Reg; 1503e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Registers.push_back(std::make_pair(Reg, RegLoc)); 1504e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } while (Reg != RegNum); 1505e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } else { 1506e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Registers.push_back(std::make_pair(RegNum, RegLoc)); 1507e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } 1508e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 1509e717610f53e0465cde198536561a3c00ce29d59fBill Wendling PrevRegNum = RegNum; 15107729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling } while (Parser.getTok().is(AsmToken::Comma) || 15117729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling Parser.getTok().is(AsmToken::Minus)); 1512e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 1513e717610f53e0465cde198536561a3c00ce29d59fBill Wendling // Process the right curly brace of the list. 151418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &RCurlyTok = Parser.getTok(); 1515c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner if (RCurlyTok.isNot(AsmToken::RCurly)) { 1516c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner Error(RCurlyTok.getLoc(), "'}' expected"); 151750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1518c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner } 1519d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 1520e717610f53e0465cde198536561a3c00ce29d59fBill Wendling SMLoc E = RCurlyTok.getLoc(); 1521e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Parser.Lex(); // Eat right curly brace token. 152203f44a04e63ff77af12df33e10ffdc473609dfe2Jim Grosbach 1523e717610f53e0465cde198536561a3c00ce29d59fBill Wendling // Verify the register list. 15245fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator 1525e717610f53e0465cde198536561a3c00ce29d59fBill Wendling RI = Registers.begin(), RE = Registers.end(); 1526e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 15277caebff83d90a59aa74876ff887e822387f479e0Bill Wendling unsigned HighRegNum = getARMRegisterNumbering(RI->first); 15288e8b18bcfa87ff919f127b1270a6891db1c9021fBill Wendling bool EmittedWarning = false; 15298e8b18bcfa87ff919f127b1270a6891db1c9021fBill Wendling 15307caebff83d90a59aa74876ff887e822387f479e0Bill Wendling DenseMap<unsigned, bool> RegMap; 15317caebff83d90a59aa74876ff887e822387f479e0Bill Wendling RegMap[HighRegNum] = true; 15327caebff83d90a59aa74876ff887e822387f479e0Bill Wendling 1533e717610f53e0465cde198536561a3c00ce29d59fBill Wendling for (++RI; RI != RE; ++RI) { 15347729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling const std::pair<unsigned, SMLoc> &RegInfo = *RI; 15357caebff83d90a59aa74876ff887e822387f479e0Bill Wendling unsigned Reg = getARMRegisterNumbering(RegInfo.first); 1536e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 15378e8b18bcfa87ff919f127b1270a6891db1c9021fBill Wendling if (RegMap[Reg]) { 1538e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Error(RegInfo.second, "register duplicated in register list"); 153950d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1540e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } 1541e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 15428e8b18bcfa87ff919f127b1270a6891db1c9021fBill Wendling if (!EmittedWarning && Reg < HighRegNum) 1543e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Warning(RegInfo.second, 1544e717610f53e0465cde198536561a3c00ce29d59fBill Wendling "register not in ascending order in register list"); 1545e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 15468e8b18bcfa87ff919f127b1270a6891db1c9021fBill Wendling RegMap[Reg] = true; 15478e8b18bcfa87ff919f127b1270a6891db1c9021fBill Wendling HighRegNum = std::max(Reg, HighRegNum); 1548e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } 1549e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 155050d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling Operands.push_back(ARMOperand::CreateRegList(Registers, S, E)); 155150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return false; 1552d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby} 1553d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 155443904299b05bdf579415749041f77c4490fe5f5bJim Grosbach/// parseMemBarrierOptOperand - Try to parse DSB/DMB data barrier options. 1555f922c47143d247cbae14b294a0bada139bcd35f6Jim GrosbachARMAsmParser::OperandMatchResultTy ARMAsmParser:: 155643904299b05bdf579415749041f77c4490fe5f5bJim GrosbachparseMemBarrierOptOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1557706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes SMLoc S = Parser.getTok().getLoc(); 1558706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes const AsmToken &Tok = Parser.getTok(); 1559706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 1560706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes StringRef OptStr = Tok.getString(); 1561706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 1562706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes unsigned Opt = StringSwitch<unsigned>(OptStr.slice(0, OptStr.size())) 1563706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("sy", ARM_MB::SY) 1564706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("st", ARM_MB::ST) 1565032434d622b6cd030a60bb9045a520c93b0d7d68Jim Grosbach .Case("sh", ARM_MB::ISH) 1566706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("ish", ARM_MB::ISH) 1567032434d622b6cd030a60bb9045a520c93b0d7d68Jim Grosbach .Case("shst", ARM_MB::ISHST) 1568706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("ishst", ARM_MB::ISHST) 1569706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("nsh", ARM_MB::NSH) 1570032434d622b6cd030a60bb9045a520c93b0d7d68Jim Grosbach .Case("un", ARM_MB::NSH) 1571706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("nshst", ARM_MB::NSHST) 1572032434d622b6cd030a60bb9045a520c93b0d7d68Jim Grosbach .Case("unst", ARM_MB::NSHST) 1573706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("osh", ARM_MB::OSH) 1574706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("oshst", ARM_MB::OSHST) 1575706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Default(~0U); 1576706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 1577706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes if (Opt == ~0U) 1578f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return MatchOperand_NoMatch; 1579706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 1580706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Parser.Lex(); // Eat identifier token. 1581706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateMemBarrierOpt((ARM_MB::MemBOpt)Opt, S)); 1582f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return MatchOperand_Success; 1583706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes} 1584706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 158543904299b05bdf579415749041f77c4490fe5f5bJim Grosbach/// parseProcIFlagsOperand - Try to parse iflags from CPS instruction. 1586a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso LopesARMAsmParser::OperandMatchResultTy ARMAsmParser:: 158743904299b05bdf579415749041f77c4490fe5f5bJim GrosbachparseProcIFlagsOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1588a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes SMLoc S = Parser.getTok().getLoc(); 1589a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes const AsmToken &Tok = Parser.getTok(); 1590a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 1591a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes StringRef IFlagsStr = Tok.getString(); 1592a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 1593a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes unsigned IFlags = 0; 1594a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes for (int i = 0, e = IFlagsStr.size(); i != e; ++i) { 1595a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes unsigned Flag = StringSwitch<unsigned>(IFlagsStr.substr(i, 1)) 1596a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Case("a", ARM_PROC::A) 1597a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Case("i", ARM_PROC::I) 1598a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Case("f", ARM_PROC::F) 1599a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Default(~0U); 1600a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 1601a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // If some specific iflag is already set, it means that some letter is 1602a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // present more than once, this is not acceptable. 1603a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (Flag == ~0U || (IFlags & Flag)) 1604a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes return MatchOperand_NoMatch; 1605a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 1606a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes IFlags |= Flag; 1607a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 1608a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 1609a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Parser.Lex(); // Eat identifier token. 1610a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateProcIFlags((ARM_PROC::IFlags)IFlags, S)); 1611a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes return MatchOperand_Success; 1612584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes} 1613584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 161443904299b05bdf579415749041f77c4490fe5f5bJim Grosbach/// parseMSRMaskOperand - Try to parse mask flags from MSR instruction. 1615584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso LopesARMAsmParser::OperandMatchResultTy ARMAsmParser:: 161643904299b05bdf579415749041f77c4490fe5f5bJim GrosbachparseMSRMaskOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1617584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes SMLoc S = Parser.getTok().getLoc(); 1618584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes const AsmToken &Tok = Parser.getTok(); 1619584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 1620584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes StringRef Mask = Tok.getString(); 1621584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1622584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // Split spec_reg from flag, example: CPSR_sxf => "CPSR" and "sxf" 1623584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes size_t Start = 0, Next = Mask.find('_'); 1624584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes StringRef Flags = ""; 1625b29b4dd988c50d5c4a15cd196e7910bf46f30b83Jim Grosbach std::string SpecReg = LowercaseString(Mask.slice(Start, Next)); 1626584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (Next != StringRef::npos) 1627584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Flags = Mask.slice(Next+1, Mask.size()); 1628584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1629584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // FlagsVal contains the complete mask: 1630584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // 3-0: Mask 1631584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // 4: Special Reg (cpsr, apsr => 0; spsr => 1) 1632584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes unsigned FlagsVal = 0; 1633584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1634584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (SpecReg == "apsr") { 1635584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FlagsVal = StringSwitch<unsigned>(Flags) 1636b29b4dd988c50d5c4a15cd196e7910bf46f30b83Jim Grosbach .Case("nzcvq", 0x8) // same as CPSR_f 1637584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Case("g", 0x4) // same as CPSR_s 1638584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Case("nzcvqg", 0xc) // same as CPSR_fs 1639584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Default(~0U); 1640584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 16414b19c9865ee94367d7b3594c36e59e4c15ba82ccJoerg Sonnenberger if (FlagsVal == ~0U) { 1642584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (!Flags.empty()) 1643584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return MatchOperand_NoMatch; 1644584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes else 1645584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FlagsVal = 0; // No flag 16464b19c9865ee94367d7b3594c36e59e4c15ba82ccJoerg Sonnenberger } 1647584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } else if (SpecReg == "cpsr" || SpecReg == "spsr") { 164856926a39619bd644c83c4128f0b55189e52707d7Bruno Cardoso Lopes if (Flags == "all") // cpsr_all is an alias for cpsr_fc 164956926a39619bd644c83c4128f0b55189e52707d7Bruno Cardoso Lopes Flags = "fc"; 1650584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes for (int i = 0, e = Flags.size(); i != e; ++i) { 1651584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes unsigned Flag = StringSwitch<unsigned>(Flags.substr(i, 1)) 1652584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Case("c", 1) 1653584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Case("x", 2) 1654584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Case("s", 4) 1655584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Case("f", 8) 1656584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Default(~0U); 1657584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1658584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // If some specific flag is already set, it means that some letter is 1659584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // present more than once, this is not acceptable. 1660584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (FlagsVal == ~0U || (FlagsVal & Flag)) 1661584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return MatchOperand_NoMatch; 1662584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FlagsVal |= Flag; 1663584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 1664584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } else // No match for special register. 1665584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return MatchOperand_NoMatch; 1666584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1667584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // Special register without flags are equivalent to "fc" flags. 1668584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (!FlagsVal) 1669584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FlagsVal = 0x9; 1670584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1671584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // Bit 4: Special Reg (cpsr, apsr => 0; spsr => 1) 1672584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (SpecReg == "spsr") 1673584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FlagsVal |= 16; 1674584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1675584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Parser.Lex(); // Eat identifier token. 1676584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateMSRMask(FlagsVal, S)); 1677584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return MatchOperand_Success; 1678a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes} 1679a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 168043904299b05bdf579415749041f77c4490fe5f5bJim Grosbach/// parseMemMode2Operand - Try to parse memory addressing mode 2 operand. 1681ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso LopesARMAsmParser::OperandMatchResultTy ARMAsmParser:: 168243904299b05bdf579415749041f77c4490fe5f5bJim GrosbachparseMemMode2Operand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1683e3662cca5d204a3e0bceaead1b35361117630fabMatt Beaumont-Gay assert(Parser.getTok().is(AsmToken::LBrac) && "Token is not a \"[\""); 1684ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 16851355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach if (parseMemory(Operands, ARMII::AddrMode2)) 1686ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return MatchOperand_NoMatch; 1687ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 1688ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return MatchOperand_Success; 1689ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes} 1690ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 169143904299b05bdf579415749041f77c4490fe5f5bJim Grosbach/// parseMemMode3Operand - Try to parse memory addressing mode 3 operand. 1692ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso LopesARMAsmParser::OperandMatchResultTy ARMAsmParser:: 169343904299b05bdf579415749041f77c4490fe5f5bJim GrosbachparseMemMode3Operand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1694ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes assert(Parser.getTok().is(AsmToken::LBrac) && "Token is not a \"[\""); 1695ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 16961355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach if (parseMemory(Operands, ARMII::AddrMode3)) 1697ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return MatchOperand_NoMatch; 1698ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 1699ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return MatchOperand_Success; 1700ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes} 1701ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 1702f6c0525d421cb48119423a96e23289b473eddbd7Jim GrosbachARMAsmParser::OperandMatchResultTy ARMAsmParser:: 1703f6c0525d421cb48119423a96e23289b473eddbd7Jim GrosbachparsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands, StringRef Op, 1704f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach int Low, int High) { 1705f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach const AsmToken &Tok = Parser.getTok(); 1706f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (Tok.isNot(AsmToken::Identifier)) { 1707f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Error(Parser.getTok().getLoc(), Op + " operand expected."); 1708f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return MatchOperand_ParseFail; 1709f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 1710f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach StringRef ShiftName = Tok.getString(); 1711f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach std::string LowerOp = LowercaseString(Op); 1712f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach std::string UpperOp = UppercaseString(Op); 1713f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (ShiftName != LowerOp && ShiftName != UpperOp) { 1714f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Error(Parser.getTok().getLoc(), Op + " operand expected."); 1715f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return MatchOperand_ParseFail; 1716f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 1717f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Parser.Lex(); // Eat shift type token. 1718f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 1719f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // There must be a '#' and a shift amount. 1720f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (Parser.getTok().isNot(AsmToken::Hash)) { 1721f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Error(Parser.getTok().getLoc(), "'#' expected"); 1722f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return MatchOperand_ParseFail; 1723f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 1724f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Parser.Lex(); // Eat hash token. 1725f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 1726f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach const MCExpr *ShiftAmount; 1727f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach SMLoc Loc = Parser.getTok().getLoc(); 1728f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (getParser().ParseExpression(ShiftAmount)) { 1729f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Error(Loc, "illegal expression"); 1730f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return MatchOperand_ParseFail; 1731f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 1732f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount); 1733f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (!CE) { 1734f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Error(Loc, "constant expression expected"); 1735f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return MatchOperand_ParseFail; 1736f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 1737f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach int Val = CE->getValue(); 1738f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (Val < Low || Val > High) { 1739f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Error(Loc, "immediate value out of range"); 1740f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return MatchOperand_ParseFail; 1741f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 1742f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 1743f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Operands.push_back(ARMOperand::CreateImm(CE, Loc, Parser.getTok().getLoc())); 1744f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 1745f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return MatchOperand_Success; 1746f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach} 1747f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 1748c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim GrosbachARMAsmParser::OperandMatchResultTy ARMAsmParser:: 1749c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim GrosbachparseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1750c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach const AsmToken &Tok = Parser.getTok(); 1751c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach SMLoc S = Tok.getLoc(); 1752c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach if (Tok.isNot(AsmToken::Identifier)) { 1753c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach Error(Tok.getLoc(), "'be' or 'le' operand expected"); 1754c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach return MatchOperand_ParseFail; 1755c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach } 1756c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach int Val = StringSwitch<int>(Tok.getString()) 1757c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach .Case("be", 1) 1758c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach .Case("le", 0) 1759c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach .Default(-1); 1760c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach Parser.Lex(); // Eat the token. 1761c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach 1762c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach if (Val == -1) { 1763c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach Error(Tok.getLoc(), "'be' or 'le' operand expected"); 1764c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach return MatchOperand_ParseFail; 1765c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach } 1766c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach Operands.push_back(ARMOperand::CreateImm(MCConstantExpr::Create(Val, 1767c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach getContext()), 1768c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach S, Parser.getTok().getLoc())); 1769c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach return MatchOperand_Success; 1770c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach} 1771c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach 1772580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach/// parseShifterImm - Parse the shifter immediate operand for SSAT/USAT 1773580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach/// instructions. Legal values are: 1774580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach/// lsl #n 'n' in [0,31] 1775580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach/// asr #n 'n' in [1,32] 1776580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach/// n == 32 encoded as n == 0. 1777580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim GrosbachARMAsmParser::OperandMatchResultTy ARMAsmParser:: 1778580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim GrosbachparseShifterImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1779580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach const AsmToken &Tok = Parser.getTok(); 1780580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach SMLoc S = Tok.getLoc(); 1781580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (Tok.isNot(AsmToken::Identifier)) { 1782580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Error(S, "shift operator 'asr' or 'lsl' expected"); 1783580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach return MatchOperand_ParseFail; 1784580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 1785580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach StringRef ShiftName = Tok.getString(); 1786580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach bool isASR; 1787580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (ShiftName == "lsl" || ShiftName == "LSL") 1788580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach isASR = false; 1789580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach else if (ShiftName == "asr" || ShiftName == "ASR") 1790580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach isASR = true; 1791580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach else { 1792580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Error(S, "shift operator 'asr' or 'lsl' expected"); 1793580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach return MatchOperand_ParseFail; 1794580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 1795580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Parser.Lex(); // Eat the operator. 1796580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 1797580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // A '#' and a shift amount. 1798580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (Parser.getTok().isNot(AsmToken::Hash)) { 1799580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Error(Parser.getTok().getLoc(), "'#' expected"); 1800580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach return MatchOperand_ParseFail; 1801580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 1802580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Parser.Lex(); // Eat hash token. 1803580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 1804580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach const MCExpr *ShiftAmount; 1805580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach SMLoc E = Parser.getTok().getLoc(); 1806580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (getParser().ParseExpression(ShiftAmount)) { 1807580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Error(E, "malformed shift expression"); 1808580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach return MatchOperand_ParseFail; 1809580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 1810580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount); 1811580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (!CE) { 1812580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Error(E, "shift amount must be an immediate"); 1813580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach return MatchOperand_ParseFail; 1814580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 1815580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 1816580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach int64_t Val = CE->getValue(); 1817580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (isASR) { 1818580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // Shift amount must be in [1,32] 1819580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (Val < 1 || Val > 32) { 1820580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Error(E, "'asr' shift amount must be in range [1,32]"); 1821580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach return MatchOperand_ParseFail; 1822580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 1823580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // asr #32 encoded as asr #0. 1824580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (Val == 32) Val = 0; 1825580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } else { 1826580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // Shift amount must be in [1,32] 1827580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (Val < 0 || Val > 31) { 1828580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Error(E, "'lsr' shift amount must be in range [0,31]"); 1829580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach return MatchOperand_ParseFail; 1830580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 1831580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 1832580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 1833580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach E = Parser.getTok().getLoc(); 1834580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Operands.push_back(ARMOperand::CreateShifterImm(isASR, Val, S, E)); 1835580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 1836580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach return MatchOperand_Success; 1837580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach} 1838580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 18397e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach/// parseRotImm - Parse the shifter immediate operand for SXTB/UXTB family 18407e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach/// of instructions. Legal values are: 18417e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach/// ror #n 'n' in {0, 8, 16, 24} 18427e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim GrosbachARMAsmParser::OperandMatchResultTy ARMAsmParser:: 18437e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim GrosbachparseRotImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 18447e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach const AsmToken &Tok = Parser.getTok(); 18457e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach SMLoc S = Tok.getLoc(); 18467e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (Tok.isNot(AsmToken::Identifier)) { 18477e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Error(S, "rotate operator 'ror' expected"); 18487e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach return MatchOperand_ParseFail; 18497e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach } 18507e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach StringRef ShiftName = Tok.getString(); 18517e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (ShiftName != "ror" && ShiftName != "ROR") { 18527e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Error(S, "rotate operator 'ror' expected"); 18537e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach return MatchOperand_ParseFail; 18547e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach } 18557e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Parser.Lex(); // Eat the operator. 18567e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 18577e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // A '#' and a rotate amount. 18587e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (Parser.getTok().isNot(AsmToken::Hash)) { 18597e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Error(Parser.getTok().getLoc(), "'#' expected"); 18607e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach return MatchOperand_ParseFail; 18617e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach } 18627e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Parser.Lex(); // Eat hash token. 18637e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 18647e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach const MCExpr *ShiftAmount; 18657e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach SMLoc E = Parser.getTok().getLoc(); 18667e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (getParser().ParseExpression(ShiftAmount)) { 18677e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Error(E, "malformed rotate expression"); 18687e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach return MatchOperand_ParseFail; 18697e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach } 18707e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount); 18717e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (!CE) { 18727e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Error(E, "rotate amount must be an immediate"); 18737e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach return MatchOperand_ParseFail; 18747e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach } 18757e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 18767e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach int64_t Val = CE->getValue(); 18777e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // Shift amount must be in {0, 8, 16, 24} (0 is undocumented extension) 18787e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // normally, zero is represented in asm by omitting the rotate operand 18797e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // entirely. 18807e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (Val != 8 && Val != 16 && Val != 24 && Val != 0) { 18817e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Error(E, "'ror' rotate amount must be 8, 16, or 24"); 18827e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach return MatchOperand_ParseFail; 18837e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach } 18847e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 18857e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach E = Parser.getTok().getLoc(); 18867e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Operands.push_back(ARMOperand::CreateRotImm(Val, S, E)); 18877e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 18887e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach return MatchOperand_Success; 18897e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach} 18907e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 18911355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach/// cvtLdWriteBackRegAddrMode2 - Convert parsed operands to MCInst. 1892ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes/// Needed here because the Asm Gen Matcher can't handle properly tied operands 1893ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes/// when they refer multiple MIOperands inside a single one. 1894ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopesbool ARMAsmParser:: 18951355cf1f76abe9699cd1c2838da132ff8b25b76bJim GrosbachcvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode, 1896ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1897ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1); 1898ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 1899ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // Create a writeback register dummy placeholder. 1900ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(0)); 1901ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 1902ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ((ARMOperand*)Operands[3])->addMemMode2Operands(Inst, 3); 1903ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2); 1904ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return true; 1905ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes} 1906ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 19071355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach/// cvtStWriteBackRegAddrMode2 - Convert parsed operands to MCInst. 1908ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes/// Needed here because the Asm Gen Matcher can't handle properly tied operands 1909ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes/// when they refer multiple MIOperands inside a single one. 1910ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopesbool ARMAsmParser:: 19111355cf1f76abe9699cd1c2838da132ff8b25b76bJim GrosbachcvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode, 1912ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1913ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // Create a writeback register dummy placeholder. 1914ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(0)); 1915ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1); 1916ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ((ARMOperand*)Operands[3])->addMemMode2Operands(Inst, 3); 1917ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2); 1918ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return true; 1919ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes} 1920ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 19211355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach/// cvtLdWriteBackRegAddrMode3 - Convert parsed operands to MCInst. 1922ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes/// Needed here because the Asm Gen Matcher can't handle properly tied operands 1923ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes/// when they refer multiple MIOperands inside a single one. 1924ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopesbool ARMAsmParser:: 19251355cf1f76abe9699cd1c2838da132ff8b25b76bJim GrosbachcvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode, 1926ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1927ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1); 1928ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 1929ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // Create a writeback register dummy placeholder. 1930ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(0)); 1931ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 1932ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ((ARMOperand*)Operands[3])->addMemMode3Operands(Inst, 3); 1933ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2); 1934ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return true; 1935ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes} 1936ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 19371355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach/// cvtStWriteBackRegAddrMode3 - Convert parsed operands to MCInst. 1938ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes/// Needed here because the Asm Gen Matcher can't handle properly tied operands 1939ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes/// when they refer multiple MIOperands inside a single one. 1940ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopesbool ARMAsmParser:: 19411355cf1f76abe9699cd1c2838da132ff8b25b76bJim GrosbachcvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode, 1942ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1943ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // Create a writeback register dummy placeholder. 1944ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(0)); 1945ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1); 1946ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ((ARMOperand*)Operands[3])->addMemMode3Operands(Inst, 3); 1947ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2); 1948ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return true; 1949ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes} 1950ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 1951e717610f53e0465cde198536561a3c00ce29d59fBill Wendling/// Parse an ARM memory expression, return false if successful else return true 19529c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// or an error. The first token must be a '[' when called. 195350d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling/// 19549c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// TODO Only preindexing and postindexing addressing are started, unindexed 19559c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// with option, etc are still to do. 195650d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendlingbool ARMAsmParser:: 19571355cf1f76abe9699cd1c2838da132ff8b25b76bJim GrosbachparseMemory(SmallVectorImpl<MCParsedAsmOperand*> &Operands, 1958ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ARMII::AddrMode AddrMode = ARMII::AddrModeNone) { 1959762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc S, E; 196018b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan assert(Parser.getTok().is(AsmToken::LBrac) && 1961a60f157b7c6fb60b33598fa5143ed8cb91aa5107Bill Wendling "Token is not a Left Bracket"); 1962762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan S = Parser.getTok().getLoc(); 1963b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat left bracket token. 1964a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 196518b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &BaseRegTok = Parser.getTok(); 1966550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (BaseRegTok.isNot(AsmToken::Identifier)) { 1967550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Error(BaseRegTok.getLoc(), "register expected"); 196850d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1969550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner } 19701355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach int BaseRegNum = tryParseRegister(); 1971e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner if (BaseRegNum == -1) { 1972550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Error(BaseRegTok.getLoc(), "register expected"); 197350d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1974550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner } 1975a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 19760571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar // The next token must either be a comma or a closing bracket. 19770571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar const AsmToken &Tok = Parser.getTok(); 19780571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar if (!Tok.is(AsmToken::Comma) && !Tok.is(AsmToken::RBrac)) 19790571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar return true; 19800571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar 1981a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool Preindexed = false; 1982a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool Postindexed = false; 1983a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool OffsetIsReg = false; 1984a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool Negative = false; 1985a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool Writeback = false; 198605d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar ARMOperand *WBOp = 0; 198705d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar int OffsetRegNum = -1; 198805d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar bool OffsetRegShifted = false; 19890082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson enum ARM_AM::ShiftOpc ShiftType = ARM_AM::lsl; 199005d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar const MCExpr *ShiftAmount = 0; 199105d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar const MCExpr *Offset = 0; 1992a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 19939c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // First look for preindexed address forms, that is after the "[Rn" we now 19949c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // have to see if the next token is a comma. 1995a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (Tok.is(AsmToken::Comma)) { 1996a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Preindexed = true; 1997b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat comma token. 199805d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar 19991355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach if (parseMemoryOffsetReg(Negative, OffsetRegShifted, ShiftType, ShiftAmount, 2000550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Offset, OffsetIsReg, OffsetRegNum, E)) 200150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 200218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &RBracTok = Parser.getTok(); 2003550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (RBracTok.isNot(AsmToken::RBrac)) { 2004550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Error(RBracTok.getLoc(), "']' expected"); 200550d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 2006550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner } 2007762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = RBracTok.getLoc(); 2008b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat right bracket token. 2009a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 201018b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &ExclaimTok = Parser.getTok(); 2011a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (ExclaimTok.is(AsmToken::Exclaim)) { 2012ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // None of addrmode3 instruction uses "!" 2013ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (AddrMode == ARMII::AddrMode3) 2014ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return true; 2015ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 201650d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling WBOp = ARMOperand::CreateToken(ExclaimTok.getString(), 201750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling ExclaimTok.getLoc()); 2018a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Writeback = true; 2019b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat exclaim token 2020ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes } else { // In addressing mode 2, pre-indexed mode always end with "!" 2021ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (AddrMode == ARMII::AddrMode2) 2022ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Preindexed = false; 2023a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 20240571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar } else { 20250571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar // The "[Rn" we have so far was not followed by a comma. 20260571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar 202780eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // If there's anything other than the right brace, this is a post indexing 202880eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // addressing form. 2029762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = Tok.getLoc(); 2030b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat right bracket token. 2031a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 203218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &NextTok = Parser.getTok(); 203303f44a04e63ff77af12df33e10ffdc473609dfe2Jim Grosbach 2034e2a98dd2a4f007d5d9d3c71460cfbe0a825b8993Kevin Enderby if (NextTok.isNot(AsmToken::EndOfStatement)) { 203580eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach Postindexed = true; 203680eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach Writeback = true; 203750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling 2038550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (NextTok.isNot(AsmToken::Comma)) { 2039550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Error(NextTok.getLoc(), "',' expected"); 204050d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 2041550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner } 204250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling 2043b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat comma token. 204450d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling 20451355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach if (parseMemoryOffsetReg(Negative, OffsetRegShifted, ShiftType, 204616c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach ShiftAmount, Offset, OffsetIsReg, OffsetRegNum, 2047550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner E)) 204850d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 2049a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 205005d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar } 2051e2a98dd2a4f007d5d9d3c71460cfbe0a825b8993Kevin Enderby 205205d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar // Force Offset to exist if used. 205305d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar if (!OffsetIsReg) { 205405d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar if (!Offset) 205505d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar Offset = MCConstantExpr::Create(0, getContext()); 2056ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } else { 2057ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (AddrMode == ARMII::AddrMode3 && OffsetRegShifted) { 2058ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Error(E, "shift amount not supported"); 2059ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return true; 2060ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } 2061a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 206205d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar 2063ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Operands.push_back(ARMOperand::CreateMem(AddrMode, BaseRegNum, OffsetIsReg, 2064ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Offset, OffsetRegNum, OffsetRegShifted, 2065ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ShiftType, ShiftAmount, Preindexed, 2066ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Postindexed, Negative, Writeback, S, E)); 206705d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar if (WBOp) 206805d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar Operands.push_back(WBOp); 206905d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar 207005d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar return false; 2071a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 2072a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 20739c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Parse the offset of a memory operand after we have seen "[Rn," or "[Rn]," 20749c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// we will parse the following (were +/- means that a plus or minus is 20759c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// optional): 20769c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// +/-Rm 20779c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// +/-Rm, shift 20789c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// #offset 20799c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// we return false on success or an error otherwise. 20801355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbachbool ARMAsmParser::parseMemoryOffsetReg(bool &Negative, 2081762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan bool &OffsetRegShifted, 20820082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson enum ARM_AM::ShiftOpc &ShiftType, 20839c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const MCExpr *&ShiftAmount, 20849c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const MCExpr *&Offset, 20859c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool &OffsetIsReg, 2086762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan int &OffsetRegNum, 2087762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc &E) { 20889c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Negative = false; 20899c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby OffsetRegShifted = false; 20909c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby OffsetIsReg = false; 20919c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby OffsetRegNum = -1; 209218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &NextTok = Parser.getTok(); 2093762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = NextTok.getLoc(); 20949c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (NextTok.is(AsmToken::Plus)) 2095b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat plus token. 20969c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby else if (NextTok.is(AsmToken::Minus)) { 20979c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Negative = true; 2098b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat minus token 20999c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 21009c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // See if there is a register following the "[Rn," or "[Rn]," we have so far. 210118b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &OffsetRegTok = Parser.getTok(); 21029c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (OffsetRegTok.is(AsmToken::Identifier)) { 2103e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner SMLoc CurLoc = OffsetRegTok.getLoc(); 21041355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach OffsetRegNum = tryParseRegister(); 2105e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner if (OffsetRegNum != -1) { 2106550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner OffsetIsReg = true; 2107e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner E = CurLoc; 2108762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 21099c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 2110d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach 211112f40e9a6305fe7553ebce19346cb55874073fc7Bill Wendling // If we parsed a register as the offset then there can be a shift after that. 21129c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (OffsetRegNum != -1) { 21139c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Look for a comma then a shift 211418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 21159c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (Tok.is(AsmToken::Comma)) { 2116b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat comma token. 21179c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 211818b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 21191355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach if (parseShift(ShiftType, ShiftAmount, E)) 21203472766f9eb7d66f234c390ce1b3a8b76f0ee9ceDuncan Sands return Error(Tok.getLoc(), "shift expected"); 21219c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby OffsetRegShifted = true; 21229c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 21239c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 21249c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby else { // the "[Rn," or "[Rn,]" we have so far was not followed by "Rm" 21259c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Look for #offset following the "[Rn," or "[Rn]," 212618b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &HashTok = Parser.getTok(); 21279c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (HashTok.isNot(AsmToken::Hash)) 21289c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return Error(HashTok.getLoc(), "'#' expected"); 212916c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 2130b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat hash token. 21319c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 21329c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (getParser().ParseExpression(Offset)) 21339c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return true; 2134762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 21359c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 21369c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return false; 21379c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby} 21389c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 21391355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach/// parseShift as one of these two: 2140a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// ( lsl | lsr | asr | ror ) , # shift_amount 2141a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// rrx 2142a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// and returns true if it parses a shift otherwise it returns false. 21431355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbachbool ARMAsmParser::parseShift(ARM_AM::ShiftOpc &St, 21440082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson const MCExpr *&ShiftAmount, SMLoc &E) { 214518b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 2146a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (Tok.isNot(AsmToken::Identifier)) 2147a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return true; 214838e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramer StringRef ShiftName = Tok.getString(); 2149a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (ShiftName == "lsl" || ShiftName == "LSL") 21500082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson St = ARM_AM::lsl; 2151a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else if (ShiftName == "lsr" || ShiftName == "LSR") 21520082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson St = ARM_AM::lsr; 2153a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else if (ShiftName == "asr" || ShiftName == "ASR") 21540082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson St = ARM_AM::asr; 2155a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else if (ShiftName == "ror" || ShiftName == "ROR") 21560082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson St = ARM_AM::ror; 2157a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else if (ShiftName == "rrx" || ShiftName == "RRX") 21580082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson St = ARM_AM::rrx; 2159a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else 2160a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return true; 2161b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat shift type token. 2162a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 21639c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Rrx stands alone. 21640082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson if (St == ARM_AM::rrx) 21659c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return false; 2166a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 21679c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Otherwise, there must be a '#' and a shift amount. 216818b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &HashTok = Parser.getTok(); 21699c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (HashTok.isNot(AsmToken::Hash)) 21709c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return Error(HashTok.getLoc(), "'#' expected"); 2171b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat hash token. 21729c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 21739c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (getParser().ParseExpression(ShiftAmount)) 21749c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return true; 2175a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 2176a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return false; 2177a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 2178a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 21799c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Parse a arm instruction operand. For now this parses the operand regardless 21809c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// of the mnemonic. 21811355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbachbool ARMAsmParser::parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands, 2182fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes StringRef Mnemonic) { 2183762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc S, E; 2184fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 2185fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // Check if the current operand has a custom associated parser, if so, try to 2186fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // custom parse the operand, or fallback to the general approach. 2187f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic); 2188f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach if (ResTy == MatchOperand_Success) 2189fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes return false; 2190f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach // If there wasn't a custom match, try the generic matcher below. Otherwise, 2191f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach // there was a match, but an error occurred, in which case, just return that 2192f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach // the operand parsing failed. 2193f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach if (ResTy == MatchOperand_ParseFail) 2194f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return true; 2195fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 2196a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby switch (getLexer().getKind()) { 2197146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling default: 2198146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling Error(Parser.getTok().getLoc(), "unexpected token in operand"); 219950d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 220019906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach case AsmToken::Identifier: { 22011355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach if (!tryParseRegisterWithWriteBack(Operands)) 220250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return false; 22030d87ec21d79c8622733b8367aa41067169602480Jim Grosbach int Res = tryParseShiftRegister(Operands); 220419906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach if (Res == 0) // success 22050082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson return false; 220619906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach else if (Res == -1) // irrecoverable error 220719906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return true; 2208e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 2209e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // Fall though for the Identifier case that is not a register or a 2210e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // special name. 221119906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach } 221267b212e03b77e921e2b9780059681125a45d15a7Kevin Enderby case AsmToken::Integer: // things like 1f and 2b as a branch targets 221367b212e03b77e921e2b9780059681125a45d15a7Kevin Enderby case AsmToken::Dot: { // . as a branch target 2214515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // This was not a register so parse other operands that start with an 2215515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // identifier (like labels) as expressions and create them as immediates. 2216515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby const MCExpr *IdVal; 2217762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan S = Parser.getTok().getLoc(); 2218515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getParser().ParseExpression(IdVal)) 221950d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 2220762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 222150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling Operands.push_back(ARMOperand::CreateImm(IdVal, S, E)); 222250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return false; 222350d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling } 2224a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby case AsmToken::LBrac: 22251355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach return parseMemory(Operands); 2226d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby case AsmToken::LCurly: 22271355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach return parseRegisterList(Operands); 2228d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby case AsmToken::Hash: 2229079469f649d8da3923b9f747d7062c84e01cc4aeKevin Enderby // #42 -> immediate. 2230079469f649d8da3923b9f747d7062c84e01cc4aeKevin Enderby // TODO: ":lower16:" and ":upper16:" modifiers after # before immediate 2231762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan S = Parser.getTok().getLoc(); 2232b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2233515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby const MCExpr *ImmVal; 2234515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getParser().ParseExpression(ImmVal)) 223550d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 2236762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 223750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling Operands.push_back(ARMOperand::CreateImm(ImmVal, S, E)); 223850d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return false; 22399081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim case AsmToken::Colon: { 22409081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim // ":lower16:" and ":upper16:" expression prefixes 22417597212abced110723f2fee985a7d60557c092ecEvan Cheng // FIXME: Check it's an expression prefix, 22427597212abced110723f2fee985a7d60557c092ecEvan Cheng // e.g. (FOO - :lower16:BAR) isn't legal. 22437597212abced110723f2fee985a7d60557c092ecEvan Cheng ARMMCExpr::VariantKind RefKind; 22441355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach if (parsePrefix(RefKind)) 22459081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return true; 22469081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 22477597212abced110723f2fee985a7d60557c092ecEvan Cheng const MCExpr *SubExprVal; 22487597212abced110723f2fee985a7d60557c092ecEvan Cheng if (getParser().ParseExpression(SubExprVal)) 22499081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return true; 22509081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 22517597212abced110723f2fee985a7d60557c092ecEvan Cheng const MCExpr *ExprVal = ARMMCExpr::Create(RefKind, SubExprVal, 22527597212abced110723f2fee985a7d60557c092ecEvan Cheng getContext()); 22539081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 22547597212abced110723f2fee985a7d60557c092ecEvan Cheng Operands.push_back(ARMOperand::CreateImm(ExprVal, S, E)); 22559081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return false; 22569081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 2257a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 2258a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 2259a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 22601355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach// parsePrefix - Parse ARM 16-bit relocations expression prefix, i.e. 22617597212abced110723f2fee985a7d60557c092ecEvan Cheng// :lower16: and :upper16:. 22621355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbachbool ARMAsmParser::parsePrefix(ARMMCExpr::VariantKind &RefKind) { 22637597212abced110723f2fee985a7d60557c092ecEvan Cheng RefKind = ARMMCExpr::VK_ARM_None; 22649081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 22659081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim // :lower16: and :upper16: modifiers 22668a8696db6b6f6e735bb9de630876af83946b45f9Jason W Kim assert(getLexer().is(AsmToken::Colon) && "expected a :"); 22679081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim Parser.Lex(); // Eat ':' 22689081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 22699081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim if (getLexer().isNot(AsmToken::Identifier)) { 22709081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim Error(Parser.getTok().getLoc(), "expected prefix identifier in operand"); 22719081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return true; 22729081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 22739081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 22749081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim StringRef IDVal = Parser.getTok().getIdentifier(); 22759081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim if (IDVal == "lower16") { 22767597212abced110723f2fee985a7d60557c092ecEvan Cheng RefKind = ARMMCExpr::VK_ARM_LO16; 22779081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } else if (IDVal == "upper16") { 22787597212abced110723f2fee985a7d60557c092ecEvan Cheng RefKind = ARMMCExpr::VK_ARM_HI16; 22799081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } else { 22809081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim Error(Parser.getTok().getLoc(), "unexpected prefix in operand"); 22819081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return true; 22829081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 22839081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim Parser.Lex(); 22849081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 22859081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim if (getLexer().isNot(AsmToken::Colon)) { 22869081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim Error(Parser.getTok().getLoc(), "unexpected token after prefix"); 22879081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return true; 22889081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 22899081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim Parser.Lex(); // Eat the last ':' 22909081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return false; 22919081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim} 22929081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 22939081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kimconst MCExpr * 22941355cf1f76abe9699cd1c2838da132ff8b25b76bJim GrosbachARMAsmParser::applyPrefixToExpr(const MCExpr *E, 22959081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim MCSymbolRefExpr::VariantKind Variant) { 22969081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim // Recurse over the given expression, rebuilding it to apply the given variant 22979081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim // to the leftmost symbol. 22989081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim if (Variant == MCSymbolRefExpr::VK_None) 22999081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return E; 23009081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 23019081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim switch (E->getKind()) { 23029081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim case MCExpr::Target: 23039081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim llvm_unreachable("Can't handle target expr yet"); 23049081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim case MCExpr::Constant: 23059081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim llvm_unreachable("Can't handle lower16/upper16 of constant yet"); 23069081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 23079081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim case MCExpr::SymbolRef: { 23089081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E); 23099081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 23109081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim if (SRE->getKind() != MCSymbolRefExpr::VK_None) 23119081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return 0; 23129081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 23139081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return MCSymbolRefExpr::Create(&SRE->getSymbol(), Variant, getContext()); 23149081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 23159081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 23169081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim case MCExpr::Unary: 23179081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim llvm_unreachable("Can't handle unary expressions yet"); 23189081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 23199081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim case MCExpr::Binary: { 23209081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim const MCBinaryExpr *BE = cast<MCBinaryExpr>(E); 23211355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach const MCExpr *LHS = applyPrefixToExpr(BE->getLHS(), Variant); 23229081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim const MCExpr *RHS = BE->getRHS(); 23239081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim if (!LHS) 23249081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return 0; 23259081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 23269081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return MCBinaryExpr::Create(BE->getOpcode(), LHS, RHS, getContext()); 23279081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 23289081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 23299081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 23309081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim assert(0 && "Invalid expression kind!"); 23319081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return 0; 23329081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim} 23339081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 2334352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar/// \brief Given a mnemonic, split out possible predication code and carry 2335352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar/// setting letters to form a canonical mnemonic and flags. 2336352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar// 2337badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar// FIXME: Would be nice to autogen this. 23381355cf1f76abe9699cd1c2838da132ff8b25b76bJim GrosbachStringRef ARMAsmParser::splitMnemonic(StringRef Mnemonic, 23395f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach unsigned &PredicationCode, 23405f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach bool &CarrySetting, 23415f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach unsigned &ProcessorIMod) { 2342352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar PredicationCode = ARMCC::AL; 2343352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar CarrySetting = false; 2344a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ProcessorIMod = 0; 2345352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar 2346badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar // Ignore some mnemonics we know aren't predicated forms. 2347352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar // 2348352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar // FIXME: Would be nice to autogen this. 23495f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach if ((Mnemonic == "movs" && isThumb()) || 23505f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "teq" || Mnemonic == "vceq" || Mnemonic == "svc" || 23515f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "mls" || Mnemonic == "smmls" || Mnemonic == "vcls" || 23525f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vmls" || Mnemonic == "vnmls" || Mnemonic == "vacge" || 23535f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vcge" || Mnemonic == "vclt" || Mnemonic == "vacgt" || 23545f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vcgt" || Mnemonic == "vcle" || Mnemonic == "smlal" || 23555f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "umaal" || Mnemonic == "umlal" || Mnemonic == "vabal" || 23565f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vmlal" || Mnemonic == "vpadal" || Mnemonic == "vqdmlal") 2357352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar return Mnemonic; 2358badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar 23593f00e317064560ad11168d22030416d853829f6eJim Grosbach // First, split out any predication code. Ignore mnemonics we know aren't 23603f00e317064560ad11168d22030416d853829f6eJim Grosbach // predicated but do have a carry-set and so weren't caught above. 2361ab40f4b737b0a87c4048a9ad2f0c02be735e3770Jim Grosbach if (Mnemonic != "adcs" && Mnemonic != "bics" && Mnemonic != "movs" && 2362bf2845c0d8a77d24e9971871badeba8cee7b2648Jim Grosbach Mnemonic != "muls" && Mnemonic != "smlals" && Mnemonic != "smulls") { 23633f00e317064560ad11168d22030416d853829f6eJim Grosbach unsigned CC = StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2)) 23643f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("eq", ARMCC::EQ) 23653f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("ne", ARMCC::NE) 23663f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("hs", ARMCC::HS) 23673f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("cs", ARMCC::HS) 23683f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("lo", ARMCC::LO) 23693f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("cc", ARMCC::LO) 23703f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("mi", ARMCC::MI) 23713f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("pl", ARMCC::PL) 23723f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("vs", ARMCC::VS) 23733f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("vc", ARMCC::VC) 23743f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("hi", ARMCC::HI) 23753f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("ls", ARMCC::LS) 23763f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("ge", ARMCC::GE) 23773f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("lt", ARMCC::LT) 23783f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("gt", ARMCC::GT) 23793f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("le", ARMCC::LE) 23803f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("al", ARMCC::AL) 23813f00e317064560ad11168d22030416d853829f6eJim Grosbach .Default(~0U); 23823f00e317064560ad11168d22030416d853829f6eJim Grosbach if (CC != ~0U) { 23833f00e317064560ad11168d22030416d853829f6eJim Grosbach Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 2); 23843f00e317064560ad11168d22030416d853829f6eJim Grosbach PredicationCode = CC; 23853f00e317064560ad11168d22030416d853829f6eJim Grosbach } 238652925b60f1cd4cf810524ca05b00a207a926ab9fBill Wendling } 2387345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 2388352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar // Next, determine if we have a carry setting bit. We explicitly ignore all 2389352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar // the instructions we know end in 's'. 2390352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar if (Mnemonic.endswith("s") && 2391352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar !(Mnemonic == "asrs" || Mnemonic == "cps" || Mnemonic == "mls" || 23925f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "mrs" || Mnemonic == "smmls" || Mnemonic == "vabs" || 23935f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vcls" || Mnemonic == "vmls" || Mnemonic == "vmrs" || 23945f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vnmls" || Mnemonic == "vqabs" || Mnemonic == "vrecps" || 23955f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vrsqrts" || (Mnemonic == "movs" && isThumb()))) { 2396352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 1); 2397352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar CarrySetting = true; 2398352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar } 2399352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar 2400a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // The "cps" instruction can have a interrupt mode operand which is glued into 2401a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // the mnemonic. Check if this is the case, split it and parse the imod op 2402a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (Mnemonic.startswith("cps")) { 2403a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // Split out any imod code. 2404a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes unsigned IMod = 2405a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2, 2)) 2406a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Case("ie", ARM_PROC::IE) 2407a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Case("id", ARM_PROC::ID) 2408a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Default(~0U); 2409a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (IMod != ~0U) { 2410a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Mnemonic = Mnemonic.slice(0, Mnemonic.size()-2); 2411a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ProcessorIMod = IMod; 2412a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 2413a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 2414a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 2415352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar return Mnemonic; 2416352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar} 24173771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar 24183771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar/// \brief Given a canonical mnemonic, determine if the instruction ever allows 24193771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar/// inclusion of carry set or predication code operands. 24203771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar// 24213771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar// FIXME: It would be nice to autogen this. 2422fdcee77887372dbf6589d47cc33094965b679f24Bruno Cardoso Lopesvoid ARMAsmParser:: 24231355cf1f76abe9699cd1c2838da132ff8b25b76bJim GrosbachgetMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet, 2424fdcee77887372dbf6589d47cc33094965b679f24Bruno Cardoso Lopes bool &CanAcceptPredicationCode) { 2425eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar if (Mnemonic == "and" || Mnemonic == "lsl" || Mnemonic == "lsr" || 2426eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "rrx" || Mnemonic == "ror" || Mnemonic == "sub" || 2427eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "smull" || Mnemonic == "add" || Mnemonic == "adc" || 2428eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "mul" || Mnemonic == "bic" || Mnemonic == "asr" || 2429be64b394317feb8d7bcb732bdfb35e0b286efd4cBruno Cardoso Lopes Mnemonic == "umlal" || Mnemonic == "orr" || Mnemonic == "mvn" || 2430eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "rsb" || Mnemonic == "rsc" || Mnemonic == "orn" || 2431eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "sbc" || Mnemonic == "mla" || Mnemonic == "umull" || 2432be64b394317feb8d7bcb732bdfb35e0b286efd4cBruno Cardoso Lopes Mnemonic == "eor" || Mnemonic == "smlal" || 2433ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng (Mnemonic == "mov" && !isThumbOne())) { 2434eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar CanAcceptCarrySet = true; 2435eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar } else { 2436eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar CanAcceptCarrySet = false; 2437eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar } 24383771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar 2439eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar if (Mnemonic == "cbnz" || Mnemonic == "setend" || Mnemonic == "dmb" || 2440eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "cps" || Mnemonic == "mcr2" || Mnemonic == "it" || 2441eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "mcrr2" || Mnemonic == "cbz" || Mnemonic == "cdp2" || 2442eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "trap" || Mnemonic == "mrc2" || Mnemonic == "mrrc2" || 24435f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "dsb" || Mnemonic == "isb" || Mnemonic == "clrex" || 2444c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach Mnemonic == "setend" || 24455f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic.startswith("cps") || (Mnemonic == "movs" && isThumb())) { 24463771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar CanAcceptPredicationCode = false; 24473771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar } else { 24483771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar CanAcceptPredicationCode = true; 24493771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar } 2450fa5bd27fbe5188ca708ac0dda4f32d90505da9f5Bruno Cardoso Lopes 2451ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng if (isThumb()) 2452fa5bd27fbe5188ca708ac0dda4f32d90505da9f5Bruno Cardoso Lopes if (Mnemonic == "bkpt" || Mnemonic == "mcr" || Mnemonic == "mcrr" || 245363b46faeb8acae9b7e5f865b7417dc00b9b9dad3Jim Grosbach Mnemonic == "mrc" || Mnemonic == "mrrc" || Mnemonic == "cdp") 2454fa5bd27fbe5188ca708ac0dda4f32d90505da9f5Bruno Cardoso Lopes CanAcceptPredicationCode = false; 2455badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar} 2456badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar 2457badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar/// Parse an arm instruction mnemonic followed by its operands. 2458badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbarbool ARMAsmParser::ParseInstruction(StringRef Name, SMLoc NameLoc, 2459badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 2460badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar // Create the leading tokens for the mnemonic, split by '.' characters. 2461badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar size_t Start = 0, Next = Name.find('.'); 2462ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach StringRef Mnemonic = Name.slice(Start, Next); 2463badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar 2464352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar // Split out the predication code and carry setting flag from the mnemonic. 2465352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar unsigned PredicationCode; 2466a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes unsigned ProcessorIMod; 2467352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar bool CarrySetting; 24681355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach Mnemonic = splitMnemonic(Mnemonic, PredicationCode, CarrySetting, 2469c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach ProcessorIMod); 2470badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar 2471ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach Operands.push_back(ARMOperand::CreateToken(Mnemonic, NameLoc)); 2472ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 2473ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // FIXME: This is all a pretty gross hack. We should automatically handle 2474ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // optional operands like this via tblgen. 24759717fa9f29696bca45ddfdf206b1c382c8b40b78Bill Wendling 24763771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // Next, add the CCOut and ConditionCode operands, if needed. 24773771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // 24783771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // For mnemonics which can ever incorporate a carry setting bit or predication 24793771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // code, our matching model involves us always generating CCOut and 24803771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // ConditionCode operands to match the mnemonic "as written" and then we let 24813771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // the matcher deal with finding the right instruction or generating an 24823771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // appropriate error. 24833771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar bool CanAcceptCarrySet, CanAcceptPredicationCode; 24841355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach getMnemonicAcceptInfo(Mnemonic, CanAcceptCarrySet, CanAcceptPredicationCode); 24853771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar 248633c16a27370939de39679245c3dff72383c210bdJim Grosbach // If we had a carry-set on an instruction that can't do that, issue an 248733c16a27370939de39679245c3dff72383c210bdJim Grosbach // error. 248833c16a27370939de39679245c3dff72383c210bdJim Grosbach if (!CanAcceptCarrySet && CarrySetting) { 248933c16a27370939de39679245c3dff72383c210bdJim Grosbach Parser.EatToEndOfStatement(); 2490ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach return Error(NameLoc, "instruction '" + Mnemonic + 249133c16a27370939de39679245c3dff72383c210bdJim Grosbach "' can not set flags, but 's' suffix specified"); 249233c16a27370939de39679245c3dff72383c210bdJim Grosbach } 2493c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach // If we had a predication code on an instruction that can't do that, issue an 2494c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach // error. 2495c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach if (!CanAcceptPredicationCode && PredicationCode != ARMCC::AL) { 2496c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach Parser.EatToEndOfStatement(); 2497c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach return Error(NameLoc, "instruction '" + Mnemonic + 2498c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach "' is not predicable, but condition code specified"); 2499c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach } 250033c16a27370939de39679245c3dff72383c210bdJim Grosbach 25013771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // Add the carry setting operand, if necessary. 25023771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // 25033771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // FIXME: It would be awesome if we could somehow invent a location such that 25043771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // match errors on this operand would print a nice diagnostic about how the 25053771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // 's' character in the mnemonic resulted in a CCOut operand. 250633c16a27370939de39679245c3dff72383c210bdJim Grosbach if (CanAcceptCarrySet) 25073771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar Operands.push_back(ARMOperand::CreateCCOut(CarrySetting ? ARM::CPSR : 0, 25083771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar NameLoc)); 25093771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar 25103771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // Add the predication code operand, if necessary. 25113771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar if (CanAcceptPredicationCode) { 25123771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar Operands.push_back(ARMOperand::CreateCondCode( 25133771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar ARMCC::CondCodes(PredicationCode), NameLoc)); 2514badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar } 2515345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 2516a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // Add the processor imod operand, if necessary. 2517a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (ProcessorIMod) { 2518a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateImm( 2519a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes MCConstantExpr::Create(ProcessorIMod, getContext()), 2520a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes NameLoc, NameLoc)); 2521a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } else { 2522a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // This mnemonic can't ever accept a imod, but the user wrote 2523a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // one (or misspelled another mnemonic). 2524a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 2525a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // FIXME: Issue a nice error. 2526a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 2527a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 2528345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // Add the remaining tokens in the mnemonic. 25295747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar while (Next != StringRef::npos) { 25305747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar Start = Next; 25315747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar Next = Name.find('.', Start + 1); 2532a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes StringRef ExtraToken = Name.slice(Start, Next); 2533a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 2534a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateToken(ExtraToken, NameLoc)); 25355747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar } 25365747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar 25375747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar // Read the remaining operands. 25385747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar if (getLexer().isNot(AsmToken::EndOfStatement)) { 2539a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Read the first operand. 25401355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach if (parseOperand(Operands, Mnemonic)) { 2541cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner Parser.EatToEndOfStatement(); 2542cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner return true; 2543cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner } 2544a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 2545a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby while (getLexer().is(AsmToken::Comma)) { 2546b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat the comma. 2547a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 2548a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Parse and remember the operand. 25491355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach if (parseOperand(Operands, Mnemonic)) { 2550cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner Parser.EatToEndOfStatement(); 2551cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner return true; 2552cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner } 2553a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 2554a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 255516c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 2556cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner if (getLexer().isNot(AsmToken::EndOfStatement)) { 2557cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner Parser.EatToEndOfStatement(); 255834e53140c2cc02ce4c9d060e48302576d3962e1cChris Lattner return TokError("unexpected token in argument list"); 2559cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner } 2560146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling 256134e53140c2cc02ce4c9d060e48302576d3962e1cChris Lattner Parser.Lex(); // Consume the EndOfStatement 2562ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 2563ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 2564ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // The 'mov' mnemonic is special. One variant has a cc_out operand, while 2565ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // another does not. Specifically, the MOVW instruction does not. So we 2566ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // special case it here and remove the defaulted (non-setting) cc_out 2567ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // operand if that's the instruction we're trying to match. 2568ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // 2569ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // We do this post-processing of the explicit operands rather than just 2570ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // conditionally adding the cc_out in the first place because we need 2571ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // to check the type of the parsed immediate operand. 2572ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach if (Mnemonic == "mov" && Operands.size() > 4 && 2573ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach !static_cast<ARMOperand*>(Operands[4])->isARMSOImm() && 2574731f2097944bfdf5b58ff1f19560a25ed15c9b2bJim Grosbach static_cast<ARMOperand*>(Operands[4])->isImm0_65535Expr() && 2575731f2097944bfdf5b58ff1f19560a25ed15c9b2bJim Grosbach static_cast<ARMOperand*>(Operands[1])->getReg() == 0) { 2576ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]); 2577ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach Operands.erase(Operands.begin() + 1); 2578ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach delete Op; 2579ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach } 2580ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 25819898671a74d3fc924347e679c45edaa685b3fe6eChris Lattner return false; 2582ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 2583ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 2584189610f9466686a91fb7d847b572e1645c785323Jim Grosbach// Validate context-sensitive operand constraints. 2585189610f9466686a91fb7d847b572e1645c785323Jim Grosbach// FIXME: We would really like to be able to tablegen'erate this. 2586189610f9466686a91fb7d847b572e1645c785323Jim Grosbachbool ARMAsmParser:: 2587189610f9466686a91fb7d847b572e1645c785323Jim GrosbachvalidateInstruction(MCInst &Inst, 2588189610f9466686a91fb7d847b572e1645c785323Jim Grosbach const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 2589189610f9466686a91fb7d847b572e1645c785323Jim Grosbach switch (Inst.getOpcode()) { 2590189610f9466686a91fb7d847b572e1645c785323Jim Grosbach case ARM::LDREXD: { 2591189610f9466686a91fb7d847b572e1645c785323Jim Grosbach // Rt2 must be Rt + 1. 2592189610f9466686a91fb7d847b572e1645c785323Jim Grosbach unsigned Rt = getARMRegisterNumbering(Inst.getOperand(0).getReg()); 2593189610f9466686a91fb7d847b572e1645c785323Jim Grosbach unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(1).getReg()); 2594189610f9466686a91fb7d847b572e1645c785323Jim Grosbach if (Rt2 != Rt + 1) 2595189610f9466686a91fb7d847b572e1645c785323Jim Grosbach return Error(Operands[3]->getStartLoc(), 2596189610f9466686a91fb7d847b572e1645c785323Jim Grosbach "destination operands must be sequential"); 2597189610f9466686a91fb7d847b572e1645c785323Jim Grosbach return false; 2598189610f9466686a91fb7d847b572e1645c785323Jim Grosbach } 2599189610f9466686a91fb7d847b572e1645c785323Jim Grosbach case ARM::STREXD: { 2600189610f9466686a91fb7d847b572e1645c785323Jim Grosbach // Rt2 must be Rt + 1. 2601189610f9466686a91fb7d847b572e1645c785323Jim Grosbach unsigned Rt = getARMRegisterNumbering(Inst.getOperand(1).getReg()); 2602189610f9466686a91fb7d847b572e1645c785323Jim Grosbach unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(2).getReg()); 2603189610f9466686a91fb7d847b572e1645c785323Jim Grosbach if (Rt2 != Rt + 1) 2604189610f9466686a91fb7d847b572e1645c785323Jim Grosbach return Error(Operands[4]->getStartLoc(), 2605189610f9466686a91fb7d847b572e1645c785323Jim Grosbach "source operands must be sequential"); 2606189610f9466686a91fb7d847b572e1645c785323Jim Grosbach return false; 2607189610f9466686a91fb7d847b572e1645c785323Jim Grosbach } 2608fb8989e64024547e4ad5ab6fe4d94fe146a7899fJim Grosbach case ARM::SBFX: 2609fb8989e64024547e4ad5ab6fe4d94fe146a7899fJim Grosbach case ARM::UBFX: { 2610fb8989e64024547e4ad5ab6fe4d94fe146a7899fJim Grosbach // width must be in range [1, 32-lsb] 2611fb8989e64024547e4ad5ab6fe4d94fe146a7899fJim Grosbach unsigned lsb = Inst.getOperand(2).getImm(); 2612fb8989e64024547e4ad5ab6fe4d94fe146a7899fJim Grosbach unsigned widthm1 = Inst.getOperand(3).getImm(); 2613fb8989e64024547e4ad5ab6fe4d94fe146a7899fJim Grosbach if (widthm1 >= 32 - lsb) 2614fb8989e64024547e4ad5ab6fe4d94fe146a7899fJim Grosbach return Error(Operands[5]->getStartLoc(), 2615fb8989e64024547e4ad5ab6fe4d94fe146a7899fJim Grosbach "bitfield width must be in range [1,32-lsb]"); 2616fb8989e64024547e4ad5ab6fe4d94fe146a7899fJim Grosbach } 2617189610f9466686a91fb7d847b572e1645c785323Jim Grosbach } 2618189610f9466686a91fb7d847b572e1645c785323Jim Grosbach 2619189610f9466686a91fb7d847b572e1645c785323Jim Grosbach return false; 2620189610f9466686a91fb7d847b572e1645c785323Jim Grosbach} 2621189610f9466686a91fb7d847b572e1645c785323Jim Grosbach 2622fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattnerbool ARMAsmParser:: 2623fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris LattnerMatchAndEmitInstruction(SMLoc IDLoc, 2624fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner SmallVectorImpl<MCParsedAsmOperand*> &Operands, 2625fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner MCStreamer &Out) { 2626fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner MCInst Inst; 2627fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner unsigned ErrorInfo; 26285a18700470f0831b9b2af78862672561dd980345Jim Grosbach MatchResultTy MatchResult; 2629193c3acbe5cdb60767d114016970e898c7502d7aKevin Enderby MatchResult = MatchInstructionImpl(Operands, Inst, ErrorInfo); 2630193c3acbe5cdb60767d114016970e898c7502d7aKevin Enderby switch (MatchResult) { 2631e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner case Match_Success: 2632189610f9466686a91fb7d847b572e1645c785323Jim Grosbach // Context sensitive operand constraints aren't handled by the matcher, 2633189610f9466686a91fb7d847b572e1645c785323Jim Grosbach // so check them here. 2634189610f9466686a91fb7d847b572e1645c785323Jim Grosbach if (validateInstruction(Inst, Operands)) 2635189610f9466686a91fb7d847b572e1645c785323Jim Grosbach return true; 2636189610f9466686a91fb7d847b572e1645c785323Jim Grosbach 2637fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner Out.EmitInstruction(Inst); 2638fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner return false; 2639e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner case Match_MissingFeature: 2640e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner Error(IDLoc, "instruction requires a CPU feature not currently enabled"); 2641e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner return true; 2642e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner case Match_InvalidOperand: { 2643e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner SMLoc ErrorLoc = IDLoc; 2644e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner if (ErrorInfo != ~0U) { 2645e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner if (ErrorInfo >= Operands.size()) 2646e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner return Error(IDLoc, "too few operands for instruction"); 264716c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 2648e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner ErrorLoc = ((ARMOperand*)Operands[ErrorInfo])->getStartLoc(); 2649e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc; 2650e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner } 265116c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 2652e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner return Error(ErrorLoc, "invalid operand for instruction"); 2653e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner } 2654e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner case Match_MnemonicFail: 2655e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner return Error(IDLoc, "unrecognized instruction mnemonic"); 2656b412915ff6229b3e2dffedcfb0f3fb7e85259841Daniel Dunbar case Match_ConversionFail: 2657b412915ff6229b3e2dffedcfb0f3fb7e85259841Daniel Dunbar return Error(IDLoc, "unable to convert operands to instruction"); 2658fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner } 265916c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 2660c223e2b10b4753a63dfe7e6980c650b179139983Eric Christopher llvm_unreachable("Implement any new match types added!"); 2661146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling return true; 2662fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner} 2663fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner 26641355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach/// parseDirective parses the arm specific directives 2665ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbybool ARMAsmParser::ParseDirective(AsmToken DirectiveID) { 2666ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby StringRef IDVal = DirectiveID.getIdentifier(); 2667ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (IDVal == ".word") 26681355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach return parseDirectiveWord(4, DirectiveID.getLoc()); 2669515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else if (IDVal == ".thumb") 26701355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach return parseDirectiveThumb(DirectiveID.getLoc()); 2671515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else if (IDVal == ".thumb_func") 26721355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach return parseDirectiveThumbFunc(DirectiveID.getLoc()); 2673515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else if (IDVal == ".code") 26741355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach return parseDirectiveCode(DirectiveID.getLoc()); 2675515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else if (IDVal == ".syntax") 26761355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach return parseDirectiveSyntax(DirectiveID.getLoc()); 2677ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return true; 2678ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 2679ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 26801355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach/// parseDirectiveWord 2681ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby/// ::= .word [ expression (, expression)* ] 26821355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbachbool ARMAsmParser::parseDirectiveWord(unsigned Size, SMLoc L) { 2683ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) { 2684ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby for (;;) { 2685ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby const MCExpr *Value; 2686ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (getParser().ParseExpression(Value)) 2687ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return true; 2688ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 2689aaec205b87637cd0d59d4f11630db603686eb73dChris Lattner getParser().getStreamer().EmitValue(Value, Size, 0/*addrspace*/); 2690ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 2691ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (getLexer().is(AsmToken::EndOfStatement)) 2692ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby break; 269316c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 2694ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // FIXME: Improve diagnostic. 2695ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (getLexer().isNot(AsmToken::Comma)) 2696ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return Error(L, "unexpected token in directive"); 2697b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2698ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby } 2699ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby } 2700ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 2701b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2702ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return false; 2703ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 2704ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 27051355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach/// parseDirectiveThumb 2706515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ::= .thumb 27071355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbachbool ARMAsmParser::parseDirectiveThumb(SMLoc L) { 2708515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) 2709515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unexpected token in directive"); 2710b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2711515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 2712515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // TODO: set thumb mode 2713515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // TODO: tell the MC streamer the mode 2714515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // getParser().getStreamer().Emit???(); 2715515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return false; 2716515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby} 2717515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 27181355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach/// parseDirectiveThumbFunc 2719515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ::= .thumbfunc symbol_name 27201355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbachbool ARMAsmParser::parseDirectiveThumbFunc(SMLoc L) { 27216469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola const MCAsmInfo &MAI = getParser().getStreamer().getContext().getAsmInfo(); 27226469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola bool isMachO = MAI.hasSubsectionsViaSymbols(); 27236469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola StringRef Name; 27246469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola 27256469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola // Darwin asm has function name after .thumb_func direction 27266469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola // ELF doesn't 27276469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola if (isMachO) { 27286469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola const AsmToken &Tok = Parser.getTok(); 27296469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola if (Tok.isNot(AsmToken::Identifier) && Tok.isNot(AsmToken::String)) 27306469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola return Error(L, "unexpected token in .thumb_func directive"); 27316469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola Name = Tok.getString(); 27326469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola Parser.Lex(); // Consume the identifier token. 27336469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola } 27346469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola 2735515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) 2736515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unexpected token in directive"); 2737b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2738515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 27396469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola // FIXME: assuming function name will be the line following .thumb_func 27406469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola if (!isMachO) { 27416469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola Name = Parser.getTok().getString(); 27426469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola } 27436469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola 2744642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach // Mark symbol as a thumb symbol. 2745642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach MCSymbol *Func = getParser().getContext().GetOrCreateSymbol(Name); 2746642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach getParser().getStreamer().EmitThumbFunc(Func); 2747515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return false; 2748515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby} 2749515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 27501355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach/// parseDirectiveSyntax 2751515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ::= .syntax unified | divided 27521355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbachbool ARMAsmParser::parseDirectiveSyntax(SMLoc L) { 275318b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 2754515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (Tok.isNot(AsmToken::Identifier)) 2755515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unexpected token in .syntax directive"); 275638e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramer StringRef Mode = Tok.getString(); 275758c86910b31c569a5709466c82e2fabae2014a56Duncan Sands if (Mode == "unified" || Mode == "UNIFIED") 2758b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 275958c86910b31c569a5709466c82e2fabae2014a56Duncan Sands else if (Mode == "divided" || Mode == "DIVIDED") 27609e56fb12c504c82c92947fe9c46287fc60116b91Kevin Enderby return Error(L, "'.syntax divided' arm asssembly not supported"); 2761515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else 2762515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unrecognized syntax mode in .syntax directive"); 2763515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 2764515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) 276518b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan return Error(Parser.getTok().getLoc(), "unexpected token in directive"); 2766b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2767515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 2768515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // TODO tell the MC streamer the mode 2769515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // getParser().getStreamer().Emit???(); 2770515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return false; 2771515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby} 2772515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 27731355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach/// parseDirectiveCode 2774515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ::= .code 16 | 32 27751355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbachbool ARMAsmParser::parseDirectiveCode(SMLoc L) { 277618b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 2777515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (Tok.isNot(AsmToken::Integer)) 2778515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unexpected token in .code directive"); 277918b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan int64_t Val = Parser.getTok().getIntVal(); 278058c86910b31c569a5709466c82e2fabae2014a56Duncan Sands if (Val == 16) 2781b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 278258c86910b31c569a5709466c82e2fabae2014a56Duncan Sands else if (Val == 32) 2783b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2784515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else 2785515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "invalid operand to .code directive"); 2786515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 2787515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) 278818b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan return Error(Parser.getTok().getLoc(), "unexpected token in directive"); 2789b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2790515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 279132869205052430f45d598fba25ab878d8b29da2dEvan Cheng if (Val == 16) { 2792bd27f5adbd8f3b8ab8def5aa43fbc406ac9b8cbeEvan Cheng if (!isThumb()) { 2793ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng SwitchMode(); 2794bd27f5adbd8f3b8ab8def5aa43fbc406ac9b8cbeEvan Cheng getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16); 2795bd27f5adbd8f3b8ab8def5aa43fbc406ac9b8cbeEvan Cheng } 279632869205052430f45d598fba25ab878d8b29da2dEvan Cheng } else { 2797bd27f5adbd8f3b8ab8def5aa43fbc406ac9b8cbeEvan Cheng if (isThumb()) { 2798ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng SwitchMode(); 2799bd27f5adbd8f3b8ab8def5aa43fbc406ac9b8cbeEvan Cheng getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32); 2800bd27f5adbd8f3b8ab8def5aa43fbc406ac9b8cbeEvan Cheng } 2801eb0caa115491019f7f7fe45fc70ad47682244187Evan Cheng } 28022a301704ea76535f0485d5c3b75664b323249bdbJim Grosbach 2803515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return false; 2804515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby} 2805515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 280690b7097f92f6b4f6b27cd88c7c88a21b777f5795Sean Callananextern "C" void LLVMInitializeARMAsmLexer(); 280790b7097f92f6b4f6b27cd88c7c88a21b777f5795Sean Callanan 28089c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Force static initialization. 2809ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbyextern "C" void LLVMInitializeARMAsmParser() { 281094b9550a32d189704a8eae55505edf62662c0534Evan Cheng RegisterMCAsmParser<ARMAsmParser> X(TheARMTarget); 281194b9550a32d189704a8eae55505edf62662c0534Evan Cheng RegisterMCAsmParser<ARMAsmParser> Y(TheThumbTarget); 281290b7097f92f6b4f6b27cd88c7c88a21b777f5795Sean Callanan LLVMInitializeARMAsmLexer(); 2813ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 28143483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 28150692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner#define GET_REGISTER_MATCHER 28160692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner#define GET_MATCHER_IMPLEMENTATION 28173483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar#include "ARMGenAsmMatcher.inc" 2818