ARMAsmParser.cpp revision ee04a6d3a40c3017124e3fd89a0db473a2824498
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 10ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "ARM.h" 11b72d2a92b75daa9cbac7338aff0cd8ae04c2b4bdEvan Cheng#include "ARMBaseRegisterInfo.h" 123483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar#include "ARMSubtarget.h" 13ee04a6d3a40c3017124e3fd89a0db473a2824498Evan Cheng#include "MCTargetDesc/ARMAddressingModes.h" 14ee04a6d3a40c3017124e3fd89a0db473a2824498Evan Cheng#include "MCTargetDesc/ARMMCExpr.h" 15c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/MC/MCParser/MCAsmLexer.h" 16c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/MC/MCParser/MCAsmParser.h" 17c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/MC/MCParser/MCParsedAsmOperand.h" 186469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola#include "llvm/MC/MCAsmInfo.h" 19642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach#include "llvm/MC/MCContext.h" 20ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/MC/MCStreamer.h" 21ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/MC/MCExpr.h" 22ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/MC/MCInst.h" 23ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng#include "llvm/MC/MCSubtargetInfo.h" 24ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/Target/TargetRegistry.h" 25ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/Target/TargetAsmParser.h" 26c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/Support/SourceMgr.h" 27fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar#include "llvm/Support/raw_ostream.h" 2875ca4b94bd9dcd3952fdc237429342a2154ba142Benjamin Kramer#include "llvm/ADT/OwningPtr.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 40ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbyclass ARMAsmParser : public TargetAsmParser { 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 50e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner int TryParseRegister(); 51bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky virtual bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc); 5250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling bool TryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &); 5319906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach int TryParseShiftRegister(SmallVectorImpl<MCParsedAsmOperand*> &); 5450d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling bool ParseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &); 55ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes bool ParseMemory(SmallVectorImpl<MCParsedAsmOperand*> &, 56ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ARMII::AddrMode AddrMode); 57fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes bool ParseOperand(SmallVectorImpl<MCParsedAsmOperand*> &, StringRef Mnemonic); 587597212abced110723f2fee985a7d60557c092ecEvan Cheng bool ParsePrefix(ARMMCExpr::VariantKind &RefKind); 599081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim const MCExpr *ApplyPrefixToExpr(const MCExpr *E, 609081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim MCSymbolRefExpr::VariantKind Variant); 619081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 62a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 639c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool ParseMemoryOffsetReg(bool &Negative, 649c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool &OffsetRegShifted, 650082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson enum ARM_AM::ShiftOpc &ShiftType, 669c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const MCExpr *&ShiftAmount, 679c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const MCExpr *&Offset, 689c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool &OffsetIsReg, 69762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan int &OffsetRegNum, 70762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc &E); 710082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson bool ParseShift(enum ARM_AM::ShiftOpc &St, 720082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson const MCExpr *&ShiftAmount, SMLoc &E); 73ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby bool ParseDirectiveWord(unsigned Size, SMLoc L); 74515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby bool ParseDirectiveThumb(SMLoc L); 75515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby bool ParseDirectiveThumbFunc(SMLoc L); 76515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby bool ParseDirectiveCode(SMLoc L); 77515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby bool ParseDirectiveSyntax(SMLoc L); 78515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 797036f8be4df8a1a830ca01afe9497b035a5647d6Chris Lattner bool MatchAndEmitInstruction(SMLoc IDLoc, 807c51a3172cf5104ebeaef22f1366fa634ca00d85Chris Lattner SmallVectorImpl<MCParsedAsmOperand*> &Operands, 81fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner MCStreamer &Out); 825f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach StringRef SplitMnemonic(StringRef Mnemonic, unsigned &PredicationCode, 835f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach bool &CarrySetting, unsigned &ProcessorIMod); 84fdcee77887372dbf6589d47cc33094965b679f24Bruno Cardoso Lopes void GetMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet, 85fdcee77887372dbf6589d47cc33094965b679f24Bruno Cardoso Lopes bool &CanAcceptPredicationCode); 8616c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 87ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng bool isThumb() const { 88ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng // FIXME: Can tablegen auto-generate this? 89ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng return (STI.getFeatureBits() & ARM::ModeThumb) != 0; 90ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng } 91ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng bool isThumbOne() const { 92ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2) == 0; 93ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng } 9432869205052430f45d598fba25ab878d8b29da2dEvan Cheng void SwitchMode() { 95ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng unsigned FB = ComputeAvailableFeatures(STI.ToggleFeature(ARM::ModeThumb)); 96ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng setAvailableFeatures(FB); 9732869205052430f45d598fba25ab878d8b29da2dEvan Cheng } 98ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng 99a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby /// @name Auto-generated Match Functions 100a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby /// { 1013483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 1020692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner#define GET_ASSEMBLER_HEADER 1030692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner#include "ARMGenAsmMatcher.inc" 104a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 105a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby /// } 106a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 107f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach OperandMatchResultTy tryParseCoprocNumOperand( 108f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach SmallVectorImpl<MCParsedAsmOperand*>&); 109f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach OperandMatchResultTy tryParseCoprocRegOperand( 110f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach SmallVectorImpl<MCParsedAsmOperand*>&); 111f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach OperandMatchResultTy tryParseMemBarrierOptOperand( 1128bba1a5ef0f8a71de2e58c7f05b8714a73464ca8Bruno Cardoso Lopes SmallVectorImpl<MCParsedAsmOperand*>&); 113a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes OperandMatchResultTy tryParseProcIFlagsOperand( 1148bba1a5ef0f8a71de2e58c7f05b8714a73464ca8Bruno Cardoso Lopes SmallVectorImpl<MCParsedAsmOperand*>&); 115584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes OperandMatchResultTy tryParseMSRMaskOperand( 1168bba1a5ef0f8a71de2e58c7f05b8714a73464ca8Bruno Cardoso Lopes SmallVectorImpl<MCParsedAsmOperand*>&); 117ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes OperandMatchResultTy tryParseMemMode2Operand( 118ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes SmallVectorImpl<MCParsedAsmOperand*>&); 119ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes OperandMatchResultTy tryParseMemMode3Operand( 120ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes SmallVectorImpl<MCParsedAsmOperand*>&); 121ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 122ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // Asm Match Converter Methods 123ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes bool CvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode, 124ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &); 125ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes bool CvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode, 126ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &); 127ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes bool CvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode, 128ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &); 129ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes bool CvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode, 130ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &); 131f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach 132ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbypublic: 133ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng ARMAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser) 134ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng : TargetAsmParser(), STI(_STI), Parser(_Parser) { 135ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng MCAsmParserExtension::Initialize(_Parser); 13632869205052430f45d598fba25ab878d8b29da2dEvan Cheng 137ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng // Initialize the set of available features. 138ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits())); 139ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng } 140ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 14138e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramer virtual bool ParseInstruction(StringRef Name, SMLoc NameLoc, 1429898671a74d3fc924347e679c45edaa685b3fe6eChris Lattner SmallVectorImpl<MCParsedAsmOperand*> &Operands); 143ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby virtual bool ParseDirective(AsmToken DirectiveID); 144ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby}; 14516c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach} // end anonymous namespace 14616c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 1473a69756e392942bc522193f38d7f33958ed3b131Chris Lattnernamespace { 1483a69756e392942bc522193f38d7f33958ed3b131Chris Lattner 149a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// ARMOperand - Instances of this class represent a parsed ARM machine 150a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// instruction. 151146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendlingclass ARMOperand : public MCParsedAsmOperand { 152762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan enum KindTy { 1538462b30548fb5969250858036638c73c16b65b43Daniel Dunbar CondCode, 154d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach CCOut, 155fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes CoprocNum, 156fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes CoprocReg, 157cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby Immediate, 158706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes MemBarrierOpt, 1598462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Memory, 160584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes MSRMask, 161a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ProcIFlags, 1628462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Register, 1638d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling RegisterList, 1640f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling DPRRegisterList, 1650f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling SPRRegisterList, 166e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ShiftedRegister, 1670082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson Shifter, 1688462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Token 169a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } Kind; 170a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 171762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc StartLoc, EndLoc; 17224d22d27640e9de954a5ac26f51a45cc96bb9135Bill Wendling SmallVector<unsigned, 8> Registers; 173a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 174a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby union { 175a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby struct { 1768462b30548fb5969250858036638c73c16b65b43Daniel Dunbar ARMCC::CondCodes Val; 1778462b30548fb5969250858036638c73c16b65b43Daniel Dunbar } CC; 1788462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 1798462b30548fb5969250858036638c73c16b65b43Daniel Dunbar struct { 180706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes ARM_MB::MemBOpt Val; 181706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes } MBOpt; 182706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 183706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes struct { 184fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes unsigned Val; 185fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } Cop; 186fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 187fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes struct { 188a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ARM_PROC::IFlags Val; 189a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } IFlags; 190a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 191a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes struct { 192584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes unsigned Val; 193584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } MMask; 194584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 195584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes struct { 196a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby const char *Data; 197a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby unsigned Length; 198a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } Tok; 199a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 200a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby struct { 201a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby unsigned RegNum; 202a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } Reg; 203a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 2048155e5b753aca42973cf317727f3805faddcaf90Bill Wendling struct { 205cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby const MCExpr *Val; 206cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby } Imm; 20716c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 2086a5c22ed89c8bb73034a70105340acf6539dc58bDaniel Dunbar /// Combined record for all forms of ARM address expressions. 209a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby struct { 210ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ARMII::AddrMode AddrMode; 211a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby unsigned BaseRegNum; 2122637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar union { 2132637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar unsigned RegNum; ///< Offset register num, when OffsetIsReg. 2142637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar const MCExpr *Value; ///< Offset value, when !OffsetIsReg. 2152637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar } Offset; 216146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling const MCExpr *ShiftAmount; // used when OffsetRegShifted is true 2170082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson enum ARM_AM::ShiftOpc ShiftType; // used when OffsetRegShifted is true 218146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling unsigned OffsetRegShifted : 1; // only used when OffsetIsReg is true 21950d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling unsigned Preindexed : 1; 22050d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling unsigned Postindexed : 1; 22150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling unsigned OffsetIsReg : 1; 22250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling unsigned Negative : 1; // only used when OffsetIsReg is true 22350d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling unsigned Writeback : 1; 224a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } Mem; 2250082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 2260082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson struct { 2270082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson ARM_AM::ShiftOpc ShiftTy; 228e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned Imm; 2290082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson } Shift; 230e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach struct { 231e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ARM_AM::ShiftOpc ShiftTy; 232e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned SrcReg; 233e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned ShiftReg; 234e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned ShiftImm; 235e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } ShiftedReg; 236a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby }; 23716c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 238146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling ARMOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {} 239146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendlingpublic: 240762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan ARMOperand(const ARMOperand &o) : MCParsedAsmOperand() { 241762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Kind = o.Kind; 242762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan StartLoc = o.StartLoc; 243762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan EndLoc = o.EndLoc; 244762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan switch (Kind) { 2458462b30548fb5969250858036638c73c16b65b43Daniel Dunbar case CondCode: 2468462b30548fb5969250858036638c73c16b65b43Daniel Dunbar CC = o.CC; 2478462b30548fb5969250858036638c73c16b65b43Daniel Dunbar break; 248762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan case Token: 2498462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Tok = o.Tok; 250762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan break; 251d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach case CCOut: 252762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan case Register: 253762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Reg = o.Reg; 254762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan break; 2558d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling case RegisterList: 2560f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling case DPRRegisterList: 2570f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling case SPRRegisterList: 25824d22d27640e9de954a5ac26f51a45cc96bb9135Bill Wendling Registers = o.Registers; 2598d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling break; 260fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes case CoprocNum: 261fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes case CoprocReg: 262fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Cop = o.Cop; 263fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes break; 264762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan case Immediate: 265762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Imm = o.Imm; 266762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan break; 267706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes case MemBarrierOpt: 268706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes MBOpt = o.MBOpt; 269706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes break; 270762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan case Memory: 271762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Mem = o.Mem; 272762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan break; 273584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes case MSRMask: 274584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes MMask = o.MMask; 275584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes break; 276a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes case ProcIFlags: 277a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes IFlags = o.IFlags; 2780082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson break; 2790082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson case Shifter: 2800082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson Shift = o.Shift; 2810082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson break; 282e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach case ShiftedRegister: 283e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ShiftedReg = o.ShiftedReg; 284e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach break; 285762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 286762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 28716c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 288762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan /// getStartLoc - Get the location of the first token of this operand. 289762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc getStartLoc() const { return StartLoc; } 290762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan /// getEndLoc - Get the location of the last token of this operand. 291762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc getEndLoc() const { return EndLoc; } 292a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 2938462b30548fb5969250858036638c73c16b65b43Daniel Dunbar ARMCC::CondCodes getCondCode() const { 2948462b30548fb5969250858036638c73c16b65b43Daniel Dunbar assert(Kind == CondCode && "Invalid access!"); 2958462b30548fb5969250858036638c73c16b65b43Daniel Dunbar return CC.Val; 2968462b30548fb5969250858036638c73c16b65b43Daniel Dunbar } 2978462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 298fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes unsigned getCoproc() const { 299fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes assert((Kind == CoprocNum || Kind == CoprocReg) && "Invalid access!"); 300fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes return Cop.Val; 301fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } 302fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 303a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby StringRef getToken() const { 304a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby assert(Kind == Token && "Invalid access!"); 305a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return StringRef(Tok.Data, Tok.Length); 306a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 307a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 308a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby unsigned getReg() const { 3096aa49435994c33257b7588cac24671785d17fa6eBenjamin Kramer assert((Kind == Register || Kind == CCOut) && "Invalid access!"); 3107729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling return Reg.RegNum; 311a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 312a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 3135fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling const SmallVectorImpl<unsigned> &getRegList() const { 3140f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling assert((Kind == RegisterList || Kind == DPRRegisterList || 3150f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling Kind == SPRRegisterList) && "Invalid access!"); 31624d22d27640e9de954a5ac26f51a45cc96bb9135Bill Wendling return Registers; 3178d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } 3188d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 319cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby const MCExpr *getImm() const { 320cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby assert(Kind == Immediate && "Invalid access!"); 321cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby return Imm.Val; 322cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby } 323cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby 324706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes ARM_MB::MemBOpt getMemBarrierOpt() const { 325706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes assert(Kind == MemBarrierOpt && "Invalid access!"); 326706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes return MBOpt.Val; 327706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes } 328706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 329a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ARM_PROC::IFlags getProcIFlags() const { 330a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes assert(Kind == ProcIFlags && "Invalid access!"); 331a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes return IFlags.Val; 332a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 333a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 334584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes unsigned getMSRMask() const { 335584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes assert(Kind == MSRMask && "Invalid access!"); 336584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return MMask.Val; 337584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 338584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 3396ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar /// @name Memory Operand Accessors 3406ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar /// @{ 341ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ARMII::AddrMode getMemAddrMode() const { 342ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return Mem.AddrMode; 343ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes } 3446ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar unsigned getMemBaseRegNum() const { 3456ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar return Mem.BaseRegNum; 3466ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 3476ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar unsigned getMemOffsetRegNum() const { 3486ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar assert(Mem.OffsetIsReg && "Invalid access!"); 3496ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar return Mem.Offset.RegNum; 3506ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 3516ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar const MCExpr *getMemOffset() const { 3526ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar assert(!Mem.OffsetIsReg && "Invalid access!"); 3536ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar return Mem.Offset.Value; 3546ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 3556ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar unsigned getMemOffsetRegShifted() const { 3566ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar assert(Mem.OffsetIsReg && "Invalid access!"); 3576ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar return Mem.OffsetRegShifted; 3586ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 3596ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar const MCExpr *getMemShiftAmount() const { 3606ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar assert(Mem.OffsetIsReg && Mem.OffsetRegShifted && "Invalid access!"); 3616ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar return Mem.ShiftAmount; 3626ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 3630082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson enum ARM_AM::ShiftOpc getMemShiftType() const { 3646ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar assert(Mem.OffsetIsReg && Mem.OffsetRegShifted && "Invalid access!"); 3656ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar return Mem.ShiftType; 3666ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 3676ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar bool getMemPreindexed() const { return Mem.Preindexed; } 3686ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar bool getMemPostindexed() const { return Mem.Postindexed; } 3696ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar bool getMemOffsetIsReg() const { return Mem.OffsetIsReg; } 3706ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar bool getMemNegative() const { return Mem.Negative; } 3716ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar bool getMemWriteback() const { return Mem.Writeback; } 3726ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar 3736ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar /// @} 3746ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar 375fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes bool isCoprocNum() const { return Kind == CoprocNum; } 376fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes bool isCoprocReg() const { return Kind == CoprocReg; } 3778462b30548fb5969250858036638c73c16b65b43Daniel Dunbar bool isCondCode() const { return Kind == CondCode; } 378d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach bool isCCOut() const { return Kind == CCOut; } 3793483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar bool isImm() const { return Kind == Immediate; } 3806b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach bool isImm0_255() const { 3816b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach if (Kind != Immediate) 3826b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach return false; 3836b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 3846b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach if (!CE) return false; 3856b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach int64_t Value = CE->getValue(); 3866b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach return Value >= 0 && Value < 256; 3876b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach } 38883ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach bool isImm0_7() const { 38983ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach if (Kind != Immediate) 39083ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach return false; 39183ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 39283ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach if (!CE) return false; 39383ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach int64_t Value = CE->getValue(); 39483ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach return Value >= 0 && Value < 8; 39583ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach } 39683ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach bool isImm0_15() const { 39783ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach if (Kind != Immediate) 39883ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach return false; 39983ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 40083ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach if (!CE) return false; 40183ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach int64_t Value = CE->getValue(); 40283ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach return Value >= 0 && Value < 16; 40383ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach } 404fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach bool isImm0_65535() const { 405fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach if (Kind != Immediate) 406fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach return false; 407fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 408fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach if (!CE) return false; 409fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach int64_t Value = CE->getValue(); 410fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach return Value >= 0 && Value < 65536; 411fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach } 412ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach bool isImm0_65535Expr() const { 413ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach if (Kind != Immediate) 414ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach return false; 415ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 416ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // If it's not a constant expression, it'll generate a fixup and be 417ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // handled later. 418ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach if (!CE) return true; 419ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach int64_t Value = CE->getValue(); 420ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach return Value >= 0 && Value < 65536; 421ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach } 4226bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach bool isARMSOImm() const { 4236bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach if (Kind != Immediate) 4246bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach return false; 4256bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 4266bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach if (!CE) return false; 4276bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach int64_t Value = CE->getValue(); 4286bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach return ARM_AM::getSOImmVal(Value) != -1; 4296bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach } 4306b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach bool isT2SOImm() const { 4316b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach if (Kind != Immediate) 4326b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach return false; 4336b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm()); 4346b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach if (!CE) return false; 4356b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach int64_t Value = CE->getValue(); 4366b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach return ARM_AM::getT2SOImmVal(Value) != -1; 4376b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach } 438b32e7844e9f79d2bd4ff34a1d19aba347f999abcBill Wendling bool isReg() const { return Kind == Register; } 4398d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling bool isRegList() const { return Kind == RegisterList; } 4400f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling bool isDPRRegList() const { return Kind == DPRRegisterList; } 4410f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling bool isSPRRegList() const { return Kind == SPRRegisterList; } 44214b93851cc7611ae6c2000f1c162592ead954420Chris Lattner bool isToken() const { return Kind == Token; } 443706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes bool isMemBarrierOpt() const { return Kind == MemBarrierOpt; } 44414b93851cc7611ae6c2000f1c162592ead954420Chris Lattner bool isMemory() const { return Kind == Memory; } 4450082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson bool isShifter() const { return Kind == Shifter; } 446e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach bool isShiftedReg() const { return Kind == ShiftedRegister; } 447ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes bool isMemMode2() const { 448ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (getMemAddrMode() != ARMII::AddrMode2) 449ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return false; 450ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 451ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (getMemOffsetIsReg()) 452ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return true; 453ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 454ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (getMemNegative() && 455ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes !(getMemPostindexed() || getMemPreindexed())) 456ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return false; 457ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 458ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 459ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (!CE) return false; 460ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes int64_t Value = CE->getValue(); 461ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 462ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // The offset must be in the range 0-4095 (imm12). 463ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (Value > 4095 || Value < -4095) 464ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return false; 465ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 466ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return true; 467ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes } 468ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes bool isMemMode3() const { 469ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (getMemAddrMode() != ARMII::AddrMode3) 470ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return false; 471ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 472ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (getMemOffsetIsReg()) { 473ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (getMemOffsetRegShifted()) 474ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return false; // No shift with offset reg allowed 475ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return true; 476ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } 477ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 478ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (getMemNegative() && 479ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes !(getMemPostindexed() || getMemPreindexed())) 480ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return false; 481ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 482ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 483ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (!CE) return false; 484ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes int64_t Value = CE->getValue(); 485ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 486ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // The offset must be in the range 0-255 (imm8). 487ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (Value > 255 || Value < -255) 488ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return false; 489ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 490ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return true; 491ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } 49287f4f9a946549ad93046990a364ac5190333a7ebBill Wendling bool isMemMode5() const { 4934b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar if (!isMemory() || getMemOffsetIsReg() || getMemWriteback() || 4944b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar getMemNegative()) 49587f4f9a946549ad93046990a364ac5190333a7ebBill Wendling return false; 496ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling 4974b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 498ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling if (!CE) return false; 499ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling 50087f4f9a946549ad93046990a364ac5190333a7ebBill Wendling // The offset must be a multiple of 4 in the range 0-1020. 50187f4f9a946549ad93046990a364ac5190333a7ebBill Wendling int64_t Value = CE->getValue(); 50287f4f9a946549ad93046990a364ac5190333a7ebBill Wendling return ((Value & 0x3) == 0 && Value <= 1020 && Value >= -1020); 50387f4f9a946549ad93046990a364ac5190333a7ebBill Wendling } 504505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes bool isMemMode7() const { 505505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes if (!isMemory() || 506505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes getMemPreindexed() || 507505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes getMemPostindexed() || 508505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes getMemOffsetIsReg() || 509505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes getMemNegative() || 510505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes getMemWriteback()) 511505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes return false; 512505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes 513505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 514505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes if (!CE) return false; 515505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes 516505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes if (CE->getValue()) 517505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes return false; 518505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes 519505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes return true; 520505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes } 521f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling bool isMemModeRegThumb() const { 5224b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar if (!isMemory() || !getMemOffsetIsReg() || getMemWriteback()) 523f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling return false; 524d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar return true; 525f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling } 526f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling bool isMemModeImmThumb() const { 5274b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar if (!isMemory() || getMemOffsetIsReg() || getMemWriteback()) 528ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling return false; 529ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling 5304b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 531ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling if (!CE) return false; 532ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling 533ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling // The offset must be a multiple of 4 in the range 0-124. 534ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling uint64_t Value = CE->getValue(); 535ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling return ((Value & 0x3) == 0 && Value <= 124); 536ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling } 537584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes bool isMSRMask() const { return Kind == MSRMask; } 538a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes bool isProcIFlags() const { return Kind == ProcIFlags; } 5393483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 5403483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar void addExpr(MCInst &Inst, const MCExpr *Expr) const { 54114b93851cc7611ae6c2000f1c162592ead954420Chris Lattner // Add as immediates when possible. Null MCExpr = 0. 54214b93851cc7611ae6c2000f1c162592ead954420Chris Lattner if (Expr == 0) 54314b93851cc7611ae6c2000f1c162592ead954420Chris Lattner Inst.addOperand(MCOperand::CreateImm(0)); 54414b93851cc7611ae6c2000f1c162592ead954420Chris Lattner else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr)) 5453483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar Inst.addOperand(MCOperand::CreateImm(CE->getValue())); 5463483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar else 5473483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar Inst.addOperand(MCOperand::CreateExpr(Expr)); 5483483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar } 5493483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 5508462b30548fb5969250858036638c73c16b65b43Daniel Dunbar void addCondCodeOperands(MCInst &Inst, unsigned N) const { 551345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar assert(N == 2 && "Invalid number of operands!"); 5528462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode()))); 55304f74942f2994a7c1d8e62c207c4005ed4652b6aJim Grosbach unsigned RegNum = getCondCode() == ARMCC::AL ? 0: ARM::CPSR; 55404f74942f2994a7c1d8e62c207c4005ed4652b6aJim Grosbach Inst.addOperand(MCOperand::CreateReg(RegNum)); 5558462b30548fb5969250858036638c73c16b65b43Daniel Dunbar } 5568462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 557fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes void addCoprocNumOperands(MCInst &Inst, unsigned N) const { 558fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes assert(N == 1 && "Invalid number of operands!"); 559fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(getCoproc())); 560fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } 561fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 562fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes void addCoprocRegOperands(MCInst &Inst, unsigned N) const { 563fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes assert(N == 1 && "Invalid number of operands!"); 564fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(getCoproc())); 565fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } 566fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 567d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach void addCCOutOperands(MCInst &Inst, unsigned N) const { 568d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach assert(N == 1 && "Invalid number of operands!"); 569d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach Inst.addOperand(MCOperand::CreateReg(getReg())); 570d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach } 571d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach 572a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby void addRegOperands(MCInst &Inst, unsigned N) const { 573a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby assert(N == 1 && "Invalid number of operands!"); 574a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Inst.addOperand(MCOperand::CreateReg(getReg())); 575a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 576a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 577e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach void addShiftedRegOperands(MCInst &Inst, unsigned N) const { 578e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach assert(N == 3 && "Invalid number of operands!"); 579e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach assert(isShiftedReg() && "addShiftedRegOperands() on non ShiftedReg!"); 580e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach assert((ShiftedReg.ShiftReg == 0 || 581e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ARM_AM::getSORegOffset(ShiftedReg.ShiftImm) == 0) && 582e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach "Invalid shifted register operand!"); 583e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Inst.addOperand(MCOperand::CreateReg(ShiftedReg.SrcReg)); 584e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Inst.addOperand(MCOperand::CreateReg(ShiftedReg.ShiftReg)); 585e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Inst.addOperand(MCOperand::CreateImm( 586e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ARM_AM::getSORegOpc(ShiftedReg.ShiftTy, ShiftedReg.ShiftImm))); 587e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } 588e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 5890082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson void addShifterOperands(MCInst &Inst, unsigned N) const { 5900082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson assert(N == 1 && "Invalid number of operands!"); 5910082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson Inst.addOperand(MCOperand::CreateImm( 5920082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson ARM_AM::getSORegOpc(Shift.ShiftTy, 0))); 5930082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson } 5940082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 59587f4f9a946549ad93046990a364ac5190333a7ebBill Wendling void addRegListOperands(MCInst &Inst, unsigned N) const { 5967729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling assert(N == 1 && "Invalid number of operands!"); 5975fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling const SmallVectorImpl<unsigned> &RegList = getRegList(); 5985fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling for (SmallVectorImpl<unsigned>::const_iterator 5997729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling I = RegList.begin(), E = RegList.end(); I != E; ++I) 6007729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling Inst.addOperand(MCOperand::CreateReg(*I)); 60187f4f9a946549ad93046990a364ac5190333a7ebBill Wendling } 60287f4f9a946549ad93046990a364ac5190333a7ebBill Wendling 6030f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling void addDPRRegListOperands(MCInst &Inst, unsigned N) const { 6040f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling addRegListOperands(Inst, N); 6050f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling } 6060f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling 6070f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling void addSPRRegListOperands(MCInst &Inst, unsigned N) const { 6080f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling addRegListOperands(Inst, N); 6090f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling } 6100f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling 6113483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar void addImmOperands(MCInst &Inst, unsigned N) const { 6126b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 6136b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach addExpr(Inst, getImm()); 6146b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach } 6156b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach 6166b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach void addImm0_255Operands(MCInst &Inst, unsigned N) const { 6176b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 6186b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach addExpr(Inst, getImm()); 6196b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach } 6206b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach 62183ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach void addImm0_7Operands(MCInst &Inst, unsigned N) const { 62283ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 62383ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach addExpr(Inst, getImm()); 62483ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach } 62583ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach 62683ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach void addImm0_15Operands(MCInst &Inst, unsigned N) const { 62783ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 62883ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach addExpr(Inst, getImm()); 62983ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach } 63083ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach 631fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach void addImm0_65535Operands(MCInst &Inst, unsigned N) const { 632fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach assert(N == 1 && "Invalid number of operands!"); 633fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach addExpr(Inst, getImm()); 634fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach } 635fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach 636ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach void addImm0_65535ExprOperands(MCInst &Inst, unsigned N) const { 637ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach assert(N == 1 && "Invalid number of operands!"); 638ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach addExpr(Inst, getImm()); 639ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach } 640ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 6416bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach void addARMSOImmOperands(MCInst &Inst, unsigned N) const { 6426bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach assert(N == 1 && "Invalid number of operands!"); 6436bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach addExpr(Inst, getImm()); 6446bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach } 6456bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach 6466b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach void addT2SOImmOperands(MCInst &Inst, unsigned N) const { 6473483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar assert(N == 1 && "Invalid number of operands!"); 6483483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar addExpr(Inst, getImm()); 6493483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar } 65016c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 651706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes void addMemBarrierOptOperands(MCInst &Inst, unsigned N) const { 652706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes assert(N == 1 && "Invalid number of operands!"); 653706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(unsigned(getMemBarrierOpt()))); 654706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes } 655706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 656505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes void addMemMode7Operands(MCInst &Inst, unsigned N) const { 657505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes assert(N == 1 && isMemMode7() && "Invalid number of operands!"); 658505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum())); 659505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes 660505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 6611866af4a982be999e4d0c08c38ebec71f3ed4025Matt Beaumont-Gay (void)CE; 662505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes assert((CE || CE->getValue() == 0) && 663505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes "No offset operand support in mode 7"); 664505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes } 665505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes 666ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes void addMemMode2Operands(MCInst &Inst, unsigned N) const { 667ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes assert(isMemMode2() && "Invalid mode or number of operands!"); 668ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum())); 669ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes unsigned IdxMode = (getMemPreindexed() | getMemPostindexed() << 1); 670ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 671ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (getMemOffsetIsReg()) { 672ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(getMemOffsetRegNum())); 673ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 674ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ARM_AM::AddrOpc AMOpc = getMemNegative() ? ARM_AM::sub : ARM_AM::add; 675ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ARM_AM::ShiftOpc ShOpc = ARM_AM::no_shift; 676ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes int64_t ShiftAmount = 0; 677ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 678ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (getMemOffsetRegShifted()) { 679ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ShOpc = getMemShiftType(); 680ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const MCConstantExpr *CE = 681ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes dyn_cast<MCConstantExpr>(getMemShiftAmount()); 682ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ShiftAmount = CE->getValue(); 683ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes } 684ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 685ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM2Opc(AMOpc, ShiftAmount, 686ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ShOpc, IdxMode))); 687ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return; 688ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes } 689ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 690ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // Create a operand placeholder to always yield the same number of operands. 691ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(0)); 692ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 693ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // FIXME: #-0 is encoded differently than #0. Does the parser preserve 694ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // the difference? 695ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 696ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes assert(CE && "Non-constant mode 2 offset operand!"); 697ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes int64_t Offset = CE->getValue(); 698ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 699ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (Offset >= 0) 700ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM2Opc(ARM_AM::add, 701ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Offset, ARM_AM::no_shift, IdxMode))); 702ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes else 703ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM2Opc(ARM_AM::sub, 704ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes -Offset, ARM_AM::no_shift, IdxMode))); 705ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes } 706ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 707ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes void addMemMode3Operands(MCInst &Inst, unsigned N) const { 708ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes assert(isMemMode3() && "Invalid mode or number of operands!"); 709ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum())); 710ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes unsigned IdxMode = (getMemPreindexed() | getMemPostindexed() << 1); 711ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 712ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (getMemOffsetIsReg()) { 713ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(getMemOffsetRegNum())); 714ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 715ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ARM_AM::AddrOpc AMOpc = getMemNegative() ? ARM_AM::sub : ARM_AM::add; 716ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM3Opc(AMOpc, 0, 717ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes IdxMode))); 718ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return; 719ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } 720ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 721ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // Create a operand placeholder to always yield the same number of operands. 722ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateReg(0)); 723ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 724ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // FIXME: #-0 is encoded differently than #0. Does the parser preserve 725ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // the difference? 726ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 727ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes assert(CE && "Non-constant mode 3 offset operand!"); 728ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes int64_t Offset = CE->getValue(); 729ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 730ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (Offset >= 0) 731ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM3Opc(ARM_AM::add, 732ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Offset, IdxMode))); 733ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes else 734ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM3Opc(ARM_AM::sub, 735ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes -Offset, IdxMode))); 736ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } 737ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 73814b93851cc7611ae6c2000f1c162592ead954420Chris Lattner void addMemMode5Operands(MCInst &Inst, unsigned N) const { 73914b93851cc7611ae6c2000f1c162592ead954420Chris Lattner assert(N == 2 && isMemMode5() && "Invalid number of operands!"); 74016c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 7414b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum())); 7424b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar assert(!getMemOffsetIsReg() && "Invalid mode 5 operand"); 74392b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling 74480eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // FIXME: #-0 is encoded differently than #0. Does the parser preserve 74580eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // the difference? 7464b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 747d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar assert(CE && "Non-constant mode 5 offset operand!"); 748d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar 749d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar // The MCInst offset operand doesn't include the low two bits (like 750d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar // the instruction encoding). 751d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar int64_t Offset = CE->getValue() / 4; 752d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar if (Offset >= 0) 753d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(ARM_AM::add, 754d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar Offset))); 755d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar else 756d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(ARM_AM::sub, 757d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar -Offset))); 75814b93851cc7611ae6c2000f1c162592ead954420Chris Lattner } 7593483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 760f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling void addMemModeRegThumbOperands(MCInst &Inst, unsigned N) const { 761f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling assert(N == 2 && isMemModeRegThumb() && "Invalid number of operands!"); 7624b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum())); 7634b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar Inst.addOperand(MCOperand::CreateReg(getMemOffsetRegNum())); 764f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling } 765ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling 766f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling void addMemModeImmThumbOperands(MCInst &Inst, unsigned N) const { 767f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling assert(N == 2 && isMemModeImmThumb() && "Invalid number of operands!"); 7684b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum())); 7694b462672d2b4950e5f059bd093db524aa10e8377Daniel Dunbar const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset()); 770f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling assert(CE && "Non-constant mode offset operand!"); 771f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling Inst.addOperand(MCOperand::CreateImm(CE->getValue())); 772ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling } 773ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling 774584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes void addMSRMaskOperands(MCInst &Inst, unsigned N) const { 775584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes assert(N == 1 && "Invalid number of operands!"); 776584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(unsigned(getMSRMask()))); 777584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 778584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 779a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes void addProcIFlagsOperands(MCInst &Inst, unsigned N) const { 780a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes assert(N == 1 && "Invalid number of operands!"); 781a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(unsigned(getProcIFlags()))); 782a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 783a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 784b7f689bab98777236a2bf600f299d232d246bb61Jim Grosbach virtual void print(raw_ostream &OS) const; 785b3cb6967949493a2e1b10d015ac08b746736764eDaniel Dunbar 7863a69756e392942bc522193f38d7f33958ed3b131Chris Lattner static ARMOperand *CreateCondCode(ARMCC::CondCodes CC, SMLoc S) { 7873a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(CondCode); 788345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Op->CC.Val = CC; 789345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Op->StartLoc = S; 790345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Op->EndLoc = S; 7913a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 792345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar } 793345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 794fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes static ARMOperand *CreateCoprocNum(unsigned CopVal, SMLoc S) { 795fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes ARMOperand *Op = new ARMOperand(CoprocNum); 796fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Op->Cop.Val = CopVal; 797fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Op->StartLoc = S; 798fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Op->EndLoc = S; 799fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes return Op; 800fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } 801fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 802fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes static ARMOperand *CreateCoprocReg(unsigned CopVal, SMLoc S) { 803fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes ARMOperand *Op = new ARMOperand(CoprocReg); 804fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Op->Cop.Val = CopVal; 805fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Op->StartLoc = S; 806fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Op->EndLoc = S; 807fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes return Op; 808fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } 809fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 810d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach static ARMOperand *CreateCCOut(unsigned RegNum, SMLoc S) { 811d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach ARMOperand *Op = new ARMOperand(CCOut); 812d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach Op->Reg.RegNum = RegNum; 813d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach Op->StartLoc = S; 814d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach Op->EndLoc = S; 815d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach return Op; 816d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach } 817d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach 8183a69756e392942bc522193f38d7f33958ed3b131Chris Lattner static ARMOperand *CreateToken(StringRef Str, SMLoc S) { 8193a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(Token); 820762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Tok.Data = Str.data(); 821762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Tok.Length = Str.size(); 822762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->StartLoc = S; 823762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->EndLoc = S; 8243a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 825a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 826a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 82750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling static ARMOperand *CreateReg(unsigned RegNum, SMLoc S, SMLoc E) { 8283a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(Register); 829762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Reg.RegNum = RegNum; 830762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->StartLoc = S; 831762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->EndLoc = E; 8323a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 833a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 834a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 835e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach static ARMOperand *CreateShiftedRegister(ARM_AM::ShiftOpc ShTy, 836e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned SrcReg, 837e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned ShiftReg, 838e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach unsigned ShiftImm, 839e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach SMLoc S, SMLoc E) { 840e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ARMOperand *Op = new ARMOperand(ShiftedRegister); 841e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Op->ShiftedReg.ShiftTy = ShTy; 842e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Op->ShiftedReg.SrcReg = SrcReg; 843e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Op->ShiftedReg.ShiftReg = ShiftReg; 844e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Op->ShiftedReg.ShiftImm = ShiftImm; 845e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Op->StartLoc = S; 846e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Op->EndLoc = E; 847e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach return Op; 848e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } 849e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 8500082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson static ARMOperand *CreateShifter(ARM_AM::ShiftOpc ShTy, 8510082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson SMLoc S, SMLoc E) { 8520082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson ARMOperand *Op = new ARMOperand(Shifter); 8530082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson Op->Shift.ShiftTy = ShTy; 8540082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson Op->StartLoc = S; 8550082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson Op->EndLoc = E; 8560082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson return Op; 8570082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson } 8580082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 8597729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling static ARMOperand * 8605fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling CreateRegList(const SmallVectorImpl<std::pair<unsigned, SMLoc> > &Regs, 861cc8d10e1a8a8555fa63f33e36e3c1ed2fb24389dMatt Beaumont-Gay SMLoc StartLoc, SMLoc EndLoc) { 8620f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling KindTy Kind = RegisterList; 8630f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling 8640f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling if (ARM::DPRRegClass.contains(Regs.front().first)) 8650f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling Kind = DPRRegisterList; 8660f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling else if (ARM::SPRRegClass.contains(Regs.front().first)) 8670f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling Kind = SPRRegisterList; 8680f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling 8690f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling ARMOperand *Op = new ARMOperand(Kind); 8705fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling for (SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator 8717729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling I = Regs.begin(), E = Regs.end(); I != E; ++I) 87224d22d27640e9de954a5ac26f51a45cc96bb9135Bill Wendling Op->Registers.push_back(I->first); 873cb21d1c9fd1cf53f063183f7eb28af7fa4052ef0Bill Wendling array_pod_sort(Op->Registers.begin(), Op->Registers.end()); 874cc8d10e1a8a8555fa63f33e36e3c1ed2fb24389dMatt Beaumont-Gay Op->StartLoc = StartLoc; 875cc8d10e1a8a8555fa63f33e36e3c1ed2fb24389dMatt Beaumont-Gay Op->EndLoc = EndLoc; 8768d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling return Op; 8778d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } 8788d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 8793a69756e392942bc522193f38d7f33958ed3b131Chris Lattner static ARMOperand *CreateImm(const MCExpr *Val, SMLoc S, SMLoc E) { 8803a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(Immediate); 881762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Imm.Val = Val; 882762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->StartLoc = S; 883762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->EndLoc = E; 8843a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 885cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby } 886cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby 887ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes static ARMOperand *CreateMem(ARMII::AddrMode AddrMode, unsigned BaseRegNum, 888ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes bool OffsetIsReg, const MCExpr *Offset, 889ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes int OffsetRegNum, bool OffsetRegShifted, 8900082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson enum ARM_AM::ShiftOpc ShiftType, 8913a69756e392942bc522193f38d7f33958ed3b131Chris Lattner const MCExpr *ShiftAmount, bool Preindexed, 8923a69756e392942bc522193f38d7f33958ed3b131Chris Lattner bool Postindexed, bool Negative, bool Writeback, 8933a69756e392942bc522193f38d7f33958ed3b131Chris Lattner SMLoc S, SMLoc E) { 894023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar assert((OffsetRegNum == -1 || OffsetIsReg) && 895023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar "OffsetRegNum must imply OffsetIsReg!"); 896023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar assert((!OffsetRegShifted || OffsetIsReg) && 897023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar "OffsetRegShifted must imply OffsetIsReg!"); 898d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar assert((Offset || OffsetIsReg) && 899d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar "Offset must exists unless register offset is used!"); 900023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar assert((!ShiftAmount || (OffsetIsReg && OffsetRegShifted)) && 901023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar "Cannot have shift amount without shifted register offset!"); 902023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar assert((!Offset || !OffsetIsReg) && 903023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar "Cannot have expression offset and register offset!"); 904023835d51b6dd6e3a253deefa595b0d916b605acDaniel Dunbar 9053a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(Memory); 906ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Op->Mem.AddrMode = AddrMode; 907762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.BaseRegNum = BaseRegNum; 908762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.OffsetIsReg = OffsetIsReg; 9092637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar if (OffsetIsReg) 9102637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar Op->Mem.Offset.RegNum = OffsetRegNum; 9112637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar else 9122637dc9a252f25fd1c63acfe0606860ee7c8cfdfDaniel Dunbar Op->Mem.Offset.Value = Offset; 913762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.OffsetRegShifted = OffsetRegShifted; 914762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.ShiftType = ShiftType; 915762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.ShiftAmount = ShiftAmount; 916762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.Preindexed = Preindexed; 917762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.Postindexed = Postindexed; 918762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.Negative = Negative; 919762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.Writeback = Writeback; 92016c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 921762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->StartLoc = S; 922762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->EndLoc = E; 9233a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 924a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 925706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 926706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes static ARMOperand *CreateMemBarrierOpt(ARM_MB::MemBOpt Opt, SMLoc S) { 927706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes ARMOperand *Op = new ARMOperand(MemBarrierOpt); 928706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Op->MBOpt.Val = Opt; 929706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Op->StartLoc = S; 930706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Op->EndLoc = S; 931706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes return Op; 932706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes } 933a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 934a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes static ARMOperand *CreateProcIFlags(ARM_PROC::IFlags IFlags, SMLoc S) { 935a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ARMOperand *Op = new ARMOperand(ProcIFlags); 936a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Op->IFlags.Val = IFlags; 937a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Op->StartLoc = S; 938a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Op->EndLoc = S; 939a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes return Op; 940a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 941584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 942584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes static ARMOperand *CreateMSRMask(unsigned MMask, SMLoc S) { 943584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes ARMOperand *Op = new ARMOperand(MSRMask); 944584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Op->MMask.Val = MMask; 945584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Op->StartLoc = S; 946584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Op->EndLoc = S; 947584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return Op; 948584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 949a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby}; 950a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 951a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} // end anonymous namespace. 952a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 953b7f689bab98777236a2bf600f299d232d246bb61Jim Grosbachvoid ARMOperand::print(raw_ostream &OS) const { 954fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar switch (Kind) { 955fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case CondCode: 9566a5c22ed89c8bb73034a70105340acf6539dc58bDaniel Dunbar OS << "<ARMCC::" << ARMCondCodeToString(getCondCode()) << ">"; 957fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 958d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach case CCOut: 959d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach OS << "<ccout " << getReg() << ">"; 960d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach break; 961fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes case CoprocNum: 962fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes OS << "<coprocessor number: " << getCoproc() << ">"; 963fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes break; 964fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes case CoprocReg: 965fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes OS << "<coprocessor register: " << getCoproc() << ">"; 966fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes break; 967584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes case MSRMask: 968584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes OS << "<mask: " << getMSRMask() << ">"; 969584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes break; 970fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case Immediate: 971fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar getImm()->print(OS); 972fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 973706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes case MemBarrierOpt: 974706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes OS << "<ARM_MB::" << MemBOptToString(getMemBarrierOpt()) << ">"; 975706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes break; 976fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case Memory: 9776ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << "<memory " 978ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes << "am:" << ARMII::AddrModeToString(getMemAddrMode()) 979ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes << " base:" << getMemBaseRegNum(); 9806ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemOffsetIsReg()) { 9816ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " offset:<register " << getMemOffsetRegNum(); 9826ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemOffsetRegShifted()) { 9836ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " offset-shift-type:" << getMemShiftType(); 9846ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " offset-shift-amount:" << *getMemShiftAmount(); 9856ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 9866ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } else { 9876ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " offset:" << *getMemOffset(); 9886ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar } 9896ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemOffsetIsReg()) 9906ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " (offset-is-reg)"; 9916ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemPreindexed()) 9926ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " (pre-indexed)"; 9936ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemPostindexed()) 9946ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " (post-indexed)"; 9956ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemNegative()) 9966ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " (negative)"; 9976ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (getMemWriteback()) 9986ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << " (writeback)"; 9996ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar OS << ">"; 1000fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 1001a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes case ProcIFlags: { 1002a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes OS << "<ARM_PROC::"; 1003a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes unsigned IFlags = getProcIFlags(); 1004a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes for (int i=2; i >= 0; --i) 1005a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (IFlags & (1 << i)) 1006a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes OS << ARM_PROC::IFlagsToString(1 << i); 1007a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes OS << ">"; 1008a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes break; 1009a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 1010fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case Register: 101150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling OS << "<register " << getReg() << ">"; 1012fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 10130082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson case Shifter: 1014e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach OS << "<shifter " << ARM_AM::getShiftOpcStr(Shift.ShiftTy) << ">"; 1015e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach break; 1016e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach case ShiftedRegister: 1017e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach OS << "<so_reg" 1018e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach << ShiftedReg.SrcReg 1019e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(ShiftedReg.ShiftImm)) 1020e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach << ", " << ShiftedReg.ShiftReg << ", " 1021e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach << ARM_AM::getSORegOffset(ShiftedReg.ShiftImm) 1022e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach << ">"; 10230082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson break; 10240f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling case RegisterList: 10250f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling case DPRRegisterList: 10260f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling case SPRRegisterList: { 10278d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling OS << "<register_list "; 10288d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 10295fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling const SmallVectorImpl<unsigned> &RegList = getRegList(); 10305fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling for (SmallVectorImpl<unsigned>::const_iterator 10317729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling I = RegList.begin(), E = RegList.end(); I != E; ) { 10327729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling OS << *I; 10337729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling if (++I < E) OS << ", "; 10348d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } 10358d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 10368d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling OS << ">"; 10378d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling break; 10388d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } 1039fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case Token: 1040fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar OS << "'" << getToken() << "'"; 1041fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 1042fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar } 1043fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar} 10443483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 10453483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar/// @name Auto-generated Match Functions 10463483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar/// { 10473483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 10483483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbarstatic unsigned MatchRegisterName(StringRef Name); 10493483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 10503483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar/// } 10513483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 105269df72367f45c0414541196efaf7c13b1ccd3f08Bob Wilsonbool ARMAsmParser::ParseRegister(unsigned &RegNo, 105369df72367f45c0414541196efaf7c13b1ccd3f08Bob Wilson SMLoc &StartLoc, SMLoc &EndLoc) { 1054bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky RegNo = TryParseRegister(); 1055bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky 1056bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky return (RegNo == (unsigned)-1); 1057bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky} 1058bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky 10599c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Try to parse a register name. The token must be an Identifier when called, 1060e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// and if it is a register name the token is eaten and the register number is 1061e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// returned. Otherwise return -1. 10623a69756e392942bc522193f38d7f33958ed3b131Chris Lattner/// 1063e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattnerint ARMAsmParser::TryParseRegister() { 106418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 1065a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 1066d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach 1067a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // FIXME: Validate register for the current architecture; we have to do 1068a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // validation later, so maybe there is no need for this here. 10690c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson std::string upperCase = Tok.getString().str(); 10700c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson std::string lowerCase = LowercaseString(upperCase); 10710c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson unsigned RegNum = MatchRegisterName(lowerCase); 10720c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson if (!RegNum) { 10730c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson RegNum = StringSwitch<unsigned>(lowerCase) 10740c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson .Case("r13", ARM::SP) 10750c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson .Case("r14", ARM::LR) 10760c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson .Case("r15", ARM::PC) 10770c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson .Case("ip", ARM::R12) 10780c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson .Default(0); 10790c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson } 10800c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson if (!RegNum) return -1; 108169df72367f45c0414541196efaf7c13b1ccd3f08Bob Wilson 1082b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat identifier token. 1083e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner return RegNum; 1084e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner} 1085d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach 108619906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach// Try to parse a shifter (e.g., "lsl <amt>"). On success, return 0. 108719906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach// If a recoverable error occurs, return 1. If an irrecoverable error 108819906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach// occurs, return -1. An irrecoverable error is one where tokens have been 108919906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach// consumed in the process of trying to parse the shifter (i.e., when it is 109019906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach// indeed a shifter operand, but malformed). 109119906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbachint ARMAsmParser::TryParseShiftRegister( 10920082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 10930082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson SMLoc S = Parser.getTok().getLoc(); 10940082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson const AsmToken &Tok = Parser.getTok(); 10950082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 10960082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 10970082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson std::string upperCase = Tok.getString().str(); 10980082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson std::string lowerCase = LowercaseString(upperCase); 10990082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson ARM_AM::ShiftOpc ShiftTy = StringSwitch<ARM_AM::ShiftOpc>(lowerCase) 11000082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson .Case("lsl", ARM_AM::lsl) 11010082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson .Case("lsr", ARM_AM::lsr) 11020082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson .Case("asr", ARM_AM::asr) 11030082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson .Case("ror", ARM_AM::ror) 11040082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson .Case("rrx", ARM_AM::rrx) 11050082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson .Default(ARM_AM::no_shift); 11060082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 11070082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson if (ShiftTy == ARM_AM::no_shift) 110819906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return 1; 11090082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 1110e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Parser.Lex(); // Eat the operator. 1111e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 1112e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // The source register for the shift has already been added to the 1113e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // operand list, so we need to pop it off and combine it into the shifted 1114e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // register operand instead. 1115eac0796542d098caa371856d545faa6cdab5aad3Benjamin Kramer OwningPtr<ARMOperand> PrevOp((ARMOperand*)Operands.pop_back_val()); 1116e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach if (!PrevOp->isReg()) 1117e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach return Error(PrevOp->getStartLoc(), "shift must be of a register"); 1118e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach int SrcReg = PrevOp->getReg(); 1119e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach int64_t Imm = 0; 1120e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach int ShiftReg = 0; 1121e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach if (ShiftTy == ARM_AM::rrx) { 1122e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // RRX Doesn't have an explicit shift amount. The encoder expects 1123e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // the shift register to be the same as the source register. Seems odd, 1124e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // but OK. 1125e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ShiftReg = SrcReg; 1126e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } else { 1127e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // Figure out if this is shifted by a constant or a register (for non-RRX). 1128e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach if (Parser.getTok().is(AsmToken::Hash)) { 1129e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Parser.Lex(); // Eat hash. 1130e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach SMLoc ImmLoc = Parser.getTok().getLoc(); 1131e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach const MCExpr *ShiftExpr = 0; 113219906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach if (getParser().ParseExpression(ShiftExpr)) { 113319906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach Error(ImmLoc, "invalid immediate shift value"); 113419906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return -1; 113519906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach } 1136e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // The expression must be evaluatable as an immediate. 1137e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftExpr); 113819906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach if (!CE) { 113919906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach Error(ImmLoc, "invalid immediate shift value"); 114019906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return -1; 114119906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach } 1142e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // Range check the immediate. 1143e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // lsl, ror: 0 <= imm <= 31 1144e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // lsr, asr: 0 <= imm <= 32 1145e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Imm = CE->getValue(); 1146e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach if (Imm < 0 || 1147e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ((ShiftTy == ARM_AM::lsl || ShiftTy == ARM_AM::ror) && Imm > 31) || 1148e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ((ShiftTy == ARM_AM::lsr || ShiftTy == ARM_AM::asr) && Imm > 32)) { 114919906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach Error(ImmLoc, "immediate shift value out of range"); 115019906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return -1; 1151e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } 1152e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } else if (Parser.getTok().is(AsmToken::Identifier)) { 1153e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ShiftReg = TryParseRegister(); 1154e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach SMLoc L = Parser.getTok().getLoc(); 115519906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach if (ShiftReg == -1) { 115619906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach Error (L, "expected immediate or register in shift operand"); 115719906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return -1; 115819906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach } 115919906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach } else { 116019906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach Error (Parser.getTok().getLoc(), 1161e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach "expected immediate or register in shift operand"); 116219906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return -1; 116319906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach } 1164e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } 1165e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 1166e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Operands.push_back(ARMOperand::CreateShiftedRegister(ShiftTy, SrcReg, 1167e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ShiftReg, Imm, 11680082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson S, Parser.getTok().getLoc())); 11690082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 117019906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return 0; 11710082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson} 11720082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 11730082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 117450d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling/// Try to parse a register name. The token must be an Identifier when called. 117550d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling/// If it's a register, an AsmOperand is created. Another AsmOperand is created 117650d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling/// if there is a "writeback". 'true' if it's not a register. 1177e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// 1178e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// TODO this is likely to change to allow different register types and or to 1179e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// parse for a specific register type. 118050d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendlingbool ARMAsmParser:: 118150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill WendlingTryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1182e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner SMLoc S = Parser.getTok().getLoc(); 1183e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner int RegNo = TryParseRegister(); 1184e717610f53e0465cde198536561a3c00ce29d59fBill Wendling if (RegNo == -1) 118550d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1186d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach 118750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling Operands.push_back(ARMOperand::CreateReg(RegNo, S, Parser.getTok().getLoc())); 1188a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 1189e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner const AsmToken &ExclaimTok = Parser.getTok(); 1190e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner if (ExclaimTok.is(AsmToken::Exclaim)) { 119150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling Operands.push_back(ARMOperand::CreateToken(ExclaimTok.getString(), 119250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling ExclaimTok.getLoc())); 1193e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner Parser.Lex(); // Eat exclaim token 119499e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby } 119599e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby 119650d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return false; 1197a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 1198a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 1199fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// MatchCoprocessorOperandName - Try to parse an coprocessor related 1200fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// instruction with a symbolic operand name. Example: "p1", "p7", "c3", 1201fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// "c5", ... 1202fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopesstatic int MatchCoprocessorOperandName(StringRef Name, char CoprocOp) { 1203e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // Use the same layout as the tablegen'erated register name matcher. Ugly, 1204e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // but efficient. 1205e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson switch (Name.size()) { 1206e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson default: break; 1207e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case 2: 1208fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes if (Name[0] != CoprocOp) 1209e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson return -1; 1210e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson switch (Name[1]) { 1211e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson default: return -1; 1212e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '0': return 0; 1213e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '1': return 1; 1214e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '2': return 2; 1215e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '3': return 3; 1216e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '4': return 4; 1217e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '5': return 5; 1218e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '6': return 6; 1219e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '7': return 7; 1220e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '8': return 8; 1221e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '9': return 9; 1222e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson } 1223e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson break; 1224e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case 3: 1225fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes if (Name[0] != CoprocOp || Name[1] != '1') 1226e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson return -1; 1227e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson switch (Name[2]) { 1228e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson default: return -1; 1229e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '0': return 10; 1230e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '1': return 11; 1231e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '2': return 12; 1232e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '3': return 13; 1233e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '4': return 14; 1234e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson case '5': return 15; 1235e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson } 1236e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson break; 1237e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson } 1238e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1239e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson return -1; 1240e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson} 1241e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1242f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach/// tryParseCoprocNumOperand - Try to parse an coprocessor number operand. The 1243fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// token must be an Identifier when called, and if it is a coprocessor 1244fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// number, the token is eaten and the operand is added to the operand list. 1245f922c47143d247cbae14b294a0bada139bcd35f6Jim GrosbachARMAsmParser::OperandMatchResultTy ARMAsmParser:: 1246f922c47143d247cbae14b294a0bada139bcd35f6Jim GrosbachtryParseCoprocNumOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1247e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson SMLoc S = Parser.getTok().getLoc(); 1248e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson const AsmToken &Tok = Parser.getTok(); 1249e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 1250e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1251fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes int Num = MatchCoprocessorOperandName(Tok.getString(), 'p'); 1252e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson if (Num == -1) 1253f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return MatchOperand_NoMatch; 1254e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1255e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson Parser.Lex(); // Eat identifier token. 1256fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateCoprocNum(Num, S)); 1257f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return MatchOperand_Success; 1258fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes} 1259fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1260f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach/// tryParseCoprocRegOperand - Try to parse an coprocessor register operand. The 1261fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// token must be an Identifier when called, and if it is a coprocessor 1262fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// number, the token is eaten and the operand is added to the operand list. 1263f922c47143d247cbae14b294a0bada139bcd35f6Jim GrosbachARMAsmParser::OperandMatchResultTy ARMAsmParser:: 1264f922c47143d247cbae14b294a0bada139bcd35f6Jim GrosbachtryParseCoprocRegOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1265fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes SMLoc S = Parser.getTok().getLoc(); 1266fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes const AsmToken &Tok = Parser.getTok(); 1267fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 1268fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1269fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes int Reg = MatchCoprocessorOperandName(Tok.getString(), 'c'); 1270fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes if (Reg == -1) 1271f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return MatchOperand_NoMatch; 1272fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1273fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Parser.Lex(); // Eat identifier token. 1274fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateCoprocReg(Reg, S)); 1275f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return MatchOperand_Success; 1276e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson} 1277e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1278c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner/// Parse a register list, return it if successful else return null. The first 1279c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner/// token must be a '{' when called. 128050d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendlingbool ARMAsmParser:: 128150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill WendlingParseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 128218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan assert(Parser.getTok().is(AsmToken::LCurly) && 1283a60f157b7c6fb60b33598fa5143ed8cb91aa5107Bill Wendling "Token is not a Left Curly Brace"); 1284e717610f53e0465cde198536561a3c00ce29d59fBill Wendling SMLoc S = Parser.getTok().getLoc(); 128516c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 12867729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling // Read the rest of the registers in the list. 12877729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling unsigned PrevRegNum = 0; 12885fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling SmallVector<std::pair<unsigned, SMLoc>, 32> Registers; 1289d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 12907729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling do { 1291e717610f53e0465cde198536561a3c00ce29d59fBill Wendling bool IsRange = Parser.getTok().is(AsmToken::Minus); 12927729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling Parser.Lex(); // Eat non-identifier token. 1293d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 129418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &RegTok = Parser.getTok(); 1295d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby SMLoc RegLoc = RegTok.getLoc(); 1296c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner if (RegTok.isNot(AsmToken::Identifier)) { 1297c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner Error(RegLoc, "register expected"); 129850d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1299c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner } 1300e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 13011d6a26507bfd75758f5c8a29bccf577784ead751Bill Wendling int RegNum = TryParseRegister(); 1302c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner if (RegNum == -1) { 1303c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner Error(RegLoc, "register expected"); 130450d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1305c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner } 1306d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 1307e717610f53e0465cde198536561a3c00ce29d59fBill Wendling if (IsRange) { 1308e717610f53e0465cde198536561a3c00ce29d59fBill Wendling int Reg = PrevRegNum; 1309e717610f53e0465cde198536561a3c00ce29d59fBill Wendling do { 1310e717610f53e0465cde198536561a3c00ce29d59fBill Wendling ++Reg; 1311e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Registers.push_back(std::make_pair(Reg, RegLoc)); 1312e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } while (Reg != RegNum); 1313e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } else { 1314e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Registers.push_back(std::make_pair(RegNum, RegLoc)); 1315e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } 1316e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 1317e717610f53e0465cde198536561a3c00ce29d59fBill Wendling PrevRegNum = RegNum; 13187729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling } while (Parser.getTok().is(AsmToken::Comma) || 13197729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling Parser.getTok().is(AsmToken::Minus)); 1320e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 1321e717610f53e0465cde198536561a3c00ce29d59fBill Wendling // Process the right curly brace of the list. 132218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &RCurlyTok = Parser.getTok(); 1323c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner if (RCurlyTok.isNot(AsmToken::RCurly)) { 1324c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner Error(RCurlyTok.getLoc(), "'}' expected"); 132550d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1326c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner } 1327d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 1328e717610f53e0465cde198536561a3c00ce29d59fBill Wendling SMLoc E = RCurlyTok.getLoc(); 1329e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Parser.Lex(); // Eat right curly brace token. 133003f44a04e63ff77af12df33e10ffdc473609dfe2Jim Grosbach 1331e717610f53e0465cde198536561a3c00ce29d59fBill Wendling // Verify the register list. 13325fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator 1333e717610f53e0465cde198536561a3c00ce29d59fBill Wendling RI = Registers.begin(), RE = Registers.end(); 1334e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 13357caebff83d90a59aa74876ff887e822387f479e0Bill Wendling unsigned HighRegNum = getARMRegisterNumbering(RI->first); 13368e8b18bcfa87ff919f127b1270a6891db1c9021fBill Wendling bool EmittedWarning = false; 13378e8b18bcfa87ff919f127b1270a6891db1c9021fBill Wendling 13387caebff83d90a59aa74876ff887e822387f479e0Bill Wendling DenseMap<unsigned, bool> RegMap; 13397caebff83d90a59aa74876ff887e822387f479e0Bill Wendling RegMap[HighRegNum] = true; 13407caebff83d90a59aa74876ff887e822387f479e0Bill Wendling 1341e717610f53e0465cde198536561a3c00ce29d59fBill Wendling for (++RI; RI != RE; ++RI) { 13427729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling const std::pair<unsigned, SMLoc> &RegInfo = *RI; 13437caebff83d90a59aa74876ff887e822387f479e0Bill Wendling unsigned Reg = getARMRegisterNumbering(RegInfo.first); 1344e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 13458e8b18bcfa87ff919f127b1270a6891db1c9021fBill Wendling if (RegMap[Reg]) { 1346e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Error(RegInfo.second, "register duplicated in register list"); 134750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1348e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } 1349e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 13508e8b18bcfa87ff919f127b1270a6891db1c9021fBill Wendling if (!EmittedWarning && Reg < HighRegNum) 1351e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Warning(RegInfo.second, 1352e717610f53e0465cde198536561a3c00ce29d59fBill Wendling "register not in ascending order in register list"); 1353e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 13548e8b18bcfa87ff919f127b1270a6891db1c9021fBill Wendling RegMap[Reg] = true; 13558e8b18bcfa87ff919f127b1270a6891db1c9021fBill Wendling HighRegNum = std::max(Reg, HighRegNum); 1356e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } 1357e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 135850d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling Operands.push_back(ARMOperand::CreateRegList(Registers, S, E)); 135950d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return false; 1360d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby} 1361d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 1362f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach/// tryParseMemBarrierOptOperand - Try to parse DSB/DMB data barrier options. 1363f922c47143d247cbae14b294a0bada139bcd35f6Jim GrosbachARMAsmParser::OperandMatchResultTy ARMAsmParser:: 1364f922c47143d247cbae14b294a0bada139bcd35f6Jim GrosbachtryParseMemBarrierOptOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1365706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes SMLoc S = Parser.getTok().getLoc(); 1366706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes const AsmToken &Tok = Parser.getTok(); 1367706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 1368706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes StringRef OptStr = Tok.getString(); 1369706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 1370706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes unsigned Opt = StringSwitch<unsigned>(OptStr.slice(0, OptStr.size())) 1371706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("sy", ARM_MB::SY) 1372706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("st", ARM_MB::ST) 1373032434d622b6cd030a60bb9045a520c93b0d7d68Jim Grosbach .Case("sh", ARM_MB::ISH) 1374706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("ish", ARM_MB::ISH) 1375032434d622b6cd030a60bb9045a520c93b0d7d68Jim Grosbach .Case("shst", ARM_MB::ISHST) 1376706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("ishst", ARM_MB::ISHST) 1377706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("nsh", ARM_MB::NSH) 1378032434d622b6cd030a60bb9045a520c93b0d7d68Jim Grosbach .Case("un", ARM_MB::NSH) 1379706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("nshst", ARM_MB::NSHST) 1380032434d622b6cd030a60bb9045a520c93b0d7d68Jim Grosbach .Case("unst", ARM_MB::NSHST) 1381706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("osh", ARM_MB::OSH) 1382706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Case("oshst", ARM_MB::OSHST) 1383706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes .Default(~0U); 1384706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 1385706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes if (Opt == ~0U) 1386f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return MatchOperand_NoMatch; 1387706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 1388706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Parser.Lex(); // Eat identifier token. 1389706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateMemBarrierOpt((ARM_MB::MemBOpt)Opt, S)); 1390f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return MatchOperand_Success; 1391706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes} 1392706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 13938bba1a5ef0f8a71de2e58c7f05b8714a73464ca8Bruno Cardoso Lopes/// tryParseProcIFlagsOperand - Try to parse iflags from CPS instruction. 1394a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso LopesARMAsmParser::OperandMatchResultTy ARMAsmParser:: 1395a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso LopestryParseProcIFlagsOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1396a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes SMLoc S = Parser.getTok().getLoc(); 1397a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes const AsmToken &Tok = Parser.getTok(); 1398a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 1399a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes StringRef IFlagsStr = Tok.getString(); 1400a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 1401a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes unsigned IFlags = 0; 1402a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes for (int i = 0, e = IFlagsStr.size(); i != e; ++i) { 1403a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes unsigned Flag = StringSwitch<unsigned>(IFlagsStr.substr(i, 1)) 1404a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Case("a", ARM_PROC::A) 1405a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Case("i", ARM_PROC::I) 1406a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Case("f", ARM_PROC::F) 1407a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Default(~0U); 1408a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 1409a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // If some specific iflag is already set, it means that some letter is 1410a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // present more than once, this is not acceptable. 1411a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (Flag == ~0U || (IFlags & Flag)) 1412a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes return MatchOperand_NoMatch; 1413a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 1414a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes IFlags |= Flag; 1415a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 1416a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 1417a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Parser.Lex(); // Eat identifier token. 1418a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateProcIFlags((ARM_PROC::IFlags)IFlags, S)); 1419a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes return MatchOperand_Success; 1420584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes} 1421584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1422584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes/// tryParseMSRMaskOperand - Try to parse mask flags from MSR instruction. 1423584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso LopesARMAsmParser::OperandMatchResultTy ARMAsmParser:: 1424584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso LopestryParseMSRMaskOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1425584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes SMLoc S = Parser.getTok().getLoc(); 1426584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes const AsmToken &Tok = Parser.getTok(); 1427584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 1428584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes StringRef Mask = Tok.getString(); 1429584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1430584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // Split spec_reg from flag, example: CPSR_sxf => "CPSR" and "sxf" 1431584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes size_t Start = 0, Next = Mask.find('_'); 1432584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes StringRef Flags = ""; 1433b29b4dd988c50d5c4a15cd196e7910bf46f30b83Jim Grosbach std::string SpecReg = LowercaseString(Mask.slice(Start, Next)); 1434584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (Next != StringRef::npos) 1435584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Flags = Mask.slice(Next+1, Mask.size()); 1436584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1437584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // FlagsVal contains the complete mask: 1438584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // 3-0: Mask 1439584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // 4: Special Reg (cpsr, apsr => 0; spsr => 1) 1440584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes unsigned FlagsVal = 0; 1441584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1442584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (SpecReg == "apsr") { 1443584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FlagsVal = StringSwitch<unsigned>(Flags) 1444b29b4dd988c50d5c4a15cd196e7910bf46f30b83Jim Grosbach .Case("nzcvq", 0x8) // same as CPSR_f 1445584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Case("g", 0x4) // same as CPSR_s 1446584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Case("nzcvqg", 0xc) // same as CPSR_fs 1447584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Default(~0U); 1448584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 14494b19c9865ee94367d7b3594c36e59e4c15ba82ccJoerg Sonnenberger if (FlagsVal == ~0U) { 1450584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (!Flags.empty()) 1451584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return MatchOperand_NoMatch; 1452584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes else 1453584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FlagsVal = 0; // No flag 14544b19c9865ee94367d7b3594c36e59e4c15ba82ccJoerg Sonnenberger } 1455584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } else if (SpecReg == "cpsr" || SpecReg == "spsr") { 145656926a39619bd644c83c4128f0b55189e52707d7Bruno Cardoso Lopes if (Flags == "all") // cpsr_all is an alias for cpsr_fc 145756926a39619bd644c83c4128f0b55189e52707d7Bruno Cardoso Lopes Flags = "fc"; 1458584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes for (int i = 0, e = Flags.size(); i != e; ++i) { 1459584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes unsigned Flag = StringSwitch<unsigned>(Flags.substr(i, 1)) 1460584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Case("c", 1) 1461584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Case("x", 2) 1462584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Case("s", 4) 1463584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Case("f", 8) 1464584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes .Default(~0U); 1465584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1466584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // If some specific flag is already set, it means that some letter is 1467584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // present more than once, this is not acceptable. 1468584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (FlagsVal == ~0U || (FlagsVal & Flag)) 1469584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return MatchOperand_NoMatch; 1470584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FlagsVal |= Flag; 1471584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 1472584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } else // No match for special register. 1473584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return MatchOperand_NoMatch; 1474584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1475584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // Special register without flags are equivalent to "fc" flags. 1476584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (!FlagsVal) 1477584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FlagsVal = 0x9; 1478584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1479584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // Bit 4: Special Reg (cpsr, apsr => 0; spsr => 1) 1480584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (SpecReg == "spsr") 1481584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FlagsVal |= 16; 1482584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1483584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Parser.Lex(); // Eat identifier token. 1484584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateMSRMask(FlagsVal, S)); 1485584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return MatchOperand_Success; 1486a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes} 1487a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 1488ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes/// tryParseMemMode2Operand - Try to parse memory addressing mode 2 operand. 1489ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso LopesARMAsmParser::OperandMatchResultTy ARMAsmParser:: 1490ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso LopestryParseMemMode2Operand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1491e3662cca5d204a3e0bceaead1b35361117630fabMatt Beaumont-Gay assert(Parser.getTok().is(AsmToken::LBrac) && "Token is not a \"[\""); 1492ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 1493ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (ParseMemory(Operands, ARMII::AddrMode2)) 1494ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return MatchOperand_NoMatch; 1495ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 1496ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return MatchOperand_Success; 1497ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes} 1498ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 1499ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes/// tryParseMemMode3Operand - Try to parse memory addressing mode 3 operand. 1500ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso LopesARMAsmParser::OperandMatchResultTy ARMAsmParser:: 1501ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso LopestryParseMemMode3Operand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1502ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes assert(Parser.getTok().is(AsmToken::LBrac) && "Token is not a \"[\""); 1503ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 1504ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (ParseMemory(Operands, ARMII::AddrMode3)) 1505ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return MatchOperand_NoMatch; 1506ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 1507ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return MatchOperand_Success; 1508ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes} 1509ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 1510ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes/// CvtLdWriteBackRegAddrMode2 - Convert parsed operands to MCInst. 1511ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes/// Needed here because the Asm Gen Matcher can't handle properly tied operands 1512ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes/// when they refer multiple MIOperands inside a single one. 1513ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopesbool ARMAsmParser:: 1514ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso LopesCvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode, 1515ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1516ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1); 1517ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 1518ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // Create a writeback register dummy placeholder. 1519ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(0)); 1520ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 1521ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ((ARMOperand*)Operands[3])->addMemMode2Operands(Inst, 3); 1522ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2); 1523ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return true; 1524ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes} 1525ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 1526ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes/// CvtStWriteBackRegAddrMode2 - Convert parsed operands to MCInst. 1527ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes/// Needed here because the Asm Gen Matcher can't handle properly tied operands 1528ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes/// when they refer multiple MIOperands inside a single one. 1529ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopesbool ARMAsmParser:: 1530ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso LopesCvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode, 1531ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1532ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // Create a writeback register dummy placeholder. 1533ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(0)); 1534ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1); 1535ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ((ARMOperand*)Operands[3])->addMemMode2Operands(Inst, 3); 1536ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2); 1537ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return true; 1538ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes} 1539ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 1540ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes/// CvtLdWriteBackRegAddrMode3 - Convert parsed operands to MCInst. 1541ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes/// Needed here because the Asm Gen Matcher can't handle properly tied operands 1542ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes/// when they refer multiple MIOperands inside a single one. 1543ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopesbool ARMAsmParser:: 1544ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso LopesCvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode, 1545ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1546ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1); 1547ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 1548ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // Create a writeback register dummy placeholder. 1549ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(0)); 1550ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 1551ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ((ARMOperand*)Operands[3])->addMemMode3Operands(Inst, 3); 1552ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2); 1553ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return true; 1554ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes} 1555ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 1556ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes/// CvtStWriteBackRegAddrMode3 - Convert parsed operands to MCInst. 1557ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes/// Needed here because the Asm Gen Matcher can't handle properly tied operands 1558ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes/// when they refer multiple MIOperands inside a single one. 1559ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopesbool ARMAsmParser:: 1560ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso LopesCvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode, 1561ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes const SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 1562ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // Create a writeback register dummy placeholder. 1563ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Inst.addOperand(MCOperand::CreateImm(0)); 1564ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1); 1565ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ((ARMOperand*)Operands[3])->addMemMode3Operands(Inst, 3); 1566ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2); 1567ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return true; 1568ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes} 1569ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 1570e717610f53e0465cde198536561a3c00ce29d59fBill Wendling/// Parse an ARM memory expression, return false if successful else return true 15719c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// or an error. The first token must be a '[' when called. 157250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling/// 15739c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// TODO Only preindexing and postindexing addressing are started, unindexed 15749c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// with option, etc are still to do. 157550d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendlingbool ARMAsmParser:: 1576ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso LopesParseMemory(SmallVectorImpl<MCParsedAsmOperand*> &Operands, 1577ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ARMII::AddrMode AddrMode = ARMII::AddrModeNone) { 1578762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc S, E; 157918b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan assert(Parser.getTok().is(AsmToken::LBrac) && 1580a60f157b7c6fb60b33598fa5143ed8cb91aa5107Bill Wendling "Token is not a Left Bracket"); 1581762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan S = Parser.getTok().getLoc(); 1582b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat left bracket token. 1583a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 158418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &BaseRegTok = Parser.getTok(); 1585550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (BaseRegTok.isNot(AsmToken::Identifier)) { 1586550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Error(BaseRegTok.getLoc(), "register expected"); 158750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1588550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner } 1589e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner int BaseRegNum = TryParseRegister(); 1590e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner if (BaseRegNum == -1) { 1591550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Error(BaseRegTok.getLoc(), "register expected"); 159250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1593550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner } 1594a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 15950571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar // The next token must either be a comma or a closing bracket. 15960571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar const AsmToken &Tok = Parser.getTok(); 15970571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar if (!Tok.is(AsmToken::Comma) && !Tok.is(AsmToken::RBrac)) 15980571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar return true; 15990571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar 1600a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool Preindexed = false; 1601a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool Postindexed = false; 1602a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool OffsetIsReg = false; 1603a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool Negative = false; 1604a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool Writeback = false; 160505d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar ARMOperand *WBOp = 0; 160605d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar int OffsetRegNum = -1; 160705d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar bool OffsetRegShifted = false; 16080082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson enum ARM_AM::ShiftOpc ShiftType = ARM_AM::lsl; 160905d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar const MCExpr *ShiftAmount = 0; 161005d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar const MCExpr *Offset = 0; 1611a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 16129c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // First look for preindexed address forms, that is after the "[Rn" we now 16139c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // have to see if the next token is a comma. 1614a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (Tok.is(AsmToken::Comma)) { 1615a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Preindexed = true; 1616b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat comma token. 161705d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar 1618550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (ParseMemoryOffsetReg(Negative, OffsetRegShifted, ShiftType, ShiftAmount, 1619550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Offset, OffsetIsReg, OffsetRegNum, E)) 162050d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 162118b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &RBracTok = Parser.getTok(); 1622550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (RBracTok.isNot(AsmToken::RBrac)) { 1623550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Error(RBracTok.getLoc(), "']' expected"); 162450d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1625550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner } 1626762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = RBracTok.getLoc(); 1627b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat right bracket token. 1628a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 162918b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &ExclaimTok = Parser.getTok(); 1630a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (ExclaimTok.is(AsmToken::Exclaim)) { 1631ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // None of addrmode3 instruction uses "!" 1632ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (AddrMode == ARMII::AddrMode3) 1633ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return true; 1634ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes 163550d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling WBOp = ARMOperand::CreateToken(ExclaimTok.getString(), 163650d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling ExclaimTok.getLoc()); 1637a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Writeback = true; 1638b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat exclaim token 1639ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes } else { // In addressing mode 2, pre-indexed mode always end with "!" 1640ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (AddrMode == ARMII::AddrMode2) 1641ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Preindexed = false; 1642a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 16430571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar } else { 16440571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar // The "[Rn" we have so far was not followed by a comma. 16450571093f4cf0414724674448fe6b973c0fa705b3Daniel Dunbar 164680eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // If there's anything other than the right brace, this is a post indexing 164780eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // addressing form. 1648762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = Tok.getLoc(); 1649b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat right bracket token. 1650a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 165118b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &NextTok = Parser.getTok(); 165203f44a04e63ff77af12df33e10ffdc473609dfe2Jim Grosbach 1653e2a98dd2a4f007d5d9d3c71460cfbe0a825b8993Kevin Enderby if (NextTok.isNot(AsmToken::EndOfStatement)) { 165480eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach Postindexed = true; 165580eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach Writeback = true; 165650d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling 1657550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (NextTok.isNot(AsmToken::Comma)) { 1658550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Error(NextTok.getLoc(), "',' expected"); 165950d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1660550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner } 166150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling 1662b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat comma token. 166350d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling 1664550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (ParseMemoryOffsetReg(Negative, OffsetRegShifted, ShiftType, 166516c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach ShiftAmount, Offset, OffsetIsReg, OffsetRegNum, 1666550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner E)) 166750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1668a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 166905d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar } 1670e2a98dd2a4f007d5d9d3c71460cfbe0a825b8993Kevin Enderby 167105d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar // Force Offset to exist if used. 167205d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar if (!OffsetIsReg) { 167305d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar if (!Offset) 167405d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar Offset = MCConstantExpr::Create(0, getContext()); 1675ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } else { 1676ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes if (AddrMode == ARMII::AddrMode3 && OffsetRegShifted) { 1677ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes Error(E, "shift amount not supported"); 1678ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return true; 1679ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } 1680a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 168105d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar 1682ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Operands.push_back(ARMOperand::CreateMem(AddrMode, BaseRegNum, OffsetIsReg, 1683ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Offset, OffsetRegNum, OffsetRegShifted, 1684ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes ShiftType, ShiftAmount, Preindexed, 1685ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes Postindexed, Negative, Writeback, S, E)); 168605d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar if (WBOp) 168705d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar Operands.push_back(WBOp); 168805d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar 168905d8b71424316ad7b014adbbb316f78c5bd46861Daniel Dunbar return false; 1690a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 1691a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 16929c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Parse the offset of a memory operand after we have seen "[Rn," or "[Rn]," 16939c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// we will parse the following (were +/- means that a plus or minus is 16949c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// optional): 16959c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// +/-Rm 16969c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// +/-Rm, shift 16979c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// #offset 16989c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// we return false on success or an error otherwise. 16999c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderbybool ARMAsmParser::ParseMemoryOffsetReg(bool &Negative, 1700762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan bool &OffsetRegShifted, 17010082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson enum ARM_AM::ShiftOpc &ShiftType, 17029c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const MCExpr *&ShiftAmount, 17039c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const MCExpr *&Offset, 17049c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool &OffsetIsReg, 1705762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan int &OffsetRegNum, 1706762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc &E) { 17079c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Negative = false; 17089c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby OffsetRegShifted = false; 17099c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby OffsetIsReg = false; 17109c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby OffsetRegNum = -1; 171118b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &NextTok = Parser.getTok(); 1712762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = NextTok.getLoc(); 17139c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (NextTok.is(AsmToken::Plus)) 1714b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat plus token. 17159c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby else if (NextTok.is(AsmToken::Minus)) { 17169c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Negative = true; 1717b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat minus token 17189c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 17199c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // See if there is a register following the "[Rn," or "[Rn]," we have so far. 172018b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &OffsetRegTok = Parser.getTok(); 17219c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (OffsetRegTok.is(AsmToken::Identifier)) { 1722e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner SMLoc CurLoc = OffsetRegTok.getLoc(); 1723e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner OffsetRegNum = TryParseRegister(); 1724e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner if (OffsetRegNum != -1) { 1725550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner OffsetIsReg = true; 1726e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner E = CurLoc; 1727762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 17289c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 1729d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach 173012f40e9a6305fe7553ebce19346cb55874073fc7Bill Wendling // If we parsed a register as the offset then there can be a shift after that. 17319c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (OffsetRegNum != -1) { 17329c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Look for a comma then a shift 173318b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 17349c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (Tok.is(AsmToken::Comma)) { 1735b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat comma token. 17369c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 173718b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 1738762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (ParseShift(ShiftType, ShiftAmount, E)) 17393472766f9eb7d66f234c390ce1b3a8b76f0ee9ceDuncan Sands return Error(Tok.getLoc(), "shift expected"); 17409c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby OffsetRegShifted = true; 17419c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 17429c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 17439c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby else { // the "[Rn," or "[Rn,]" we have so far was not followed by "Rm" 17449c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Look for #offset following the "[Rn," or "[Rn]," 174518b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &HashTok = Parser.getTok(); 17469c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (HashTok.isNot(AsmToken::Hash)) 17479c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return Error(HashTok.getLoc(), "'#' expected"); 174816c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 1749b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat hash token. 17509c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 17519c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (getParser().ParseExpression(Offset)) 17529c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return true; 1753762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 17549c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 17559c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return false; 17569c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby} 17579c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 1758a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// ParseShift as one of these two: 1759a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// ( lsl | lsr | asr | ror ) , # shift_amount 1760a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// rrx 1761a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// and returns true if it parses a shift otherwise it returns false. 17620082830cb26248178fe5cc9bbdbd00881556c33dOwen Andersonbool ARMAsmParser::ParseShift(ARM_AM::ShiftOpc &St, 17630082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson const MCExpr *&ShiftAmount, SMLoc &E) { 176418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 1765a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (Tok.isNot(AsmToken::Identifier)) 1766a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return true; 176738e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramer StringRef ShiftName = Tok.getString(); 1768a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (ShiftName == "lsl" || ShiftName == "LSL") 17690082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson St = ARM_AM::lsl; 1770a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else if (ShiftName == "lsr" || ShiftName == "LSR") 17710082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson St = ARM_AM::lsr; 1772a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else if (ShiftName == "asr" || ShiftName == "ASR") 17730082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson St = ARM_AM::asr; 1774a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else if (ShiftName == "ror" || ShiftName == "ROR") 17750082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson St = ARM_AM::ror; 1776a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else if (ShiftName == "rrx" || ShiftName == "RRX") 17770082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson St = ARM_AM::rrx; 1778a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else 1779a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return true; 1780b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat shift type token. 1781a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 17829c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Rrx stands alone. 17830082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson if (St == ARM_AM::rrx) 17849c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return false; 1785a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 17869c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Otherwise, there must be a '#' and a shift amount. 178718b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &HashTok = Parser.getTok(); 17889c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (HashTok.isNot(AsmToken::Hash)) 17899c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return Error(HashTok.getLoc(), "'#' expected"); 1790b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat hash token. 17919c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 17929c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (getParser().ParseExpression(ShiftAmount)) 17939c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return true; 1794a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 1795a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return false; 1796a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 1797a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 17989c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Parse a arm instruction operand. For now this parses the operand regardless 17999c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// of the mnemonic. 1800e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Andersonbool ARMAsmParser::ParseOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands, 1801fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes StringRef Mnemonic) { 1802762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc S, E; 1803fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1804fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // Check if the current operand has a custom associated parser, if so, try to 1805fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // custom parse the operand, or fallback to the general approach. 1806f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic); 1807f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach if (ResTy == MatchOperand_Success) 1808fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes return false; 1809f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach // If there wasn't a custom match, try the generic matcher below. Otherwise, 1810f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach // there was a match, but an error occurred, in which case, just return that 1811f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach // the operand parsing failed. 1812f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach if (ResTy == MatchOperand_ParseFail) 1813f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return true; 1814fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1815a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby switch (getLexer().getKind()) { 1816146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling default: 1817146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling Error(Parser.getTok().getLoc(), "unexpected token in operand"); 181850d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 181919906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach case AsmToken::Identifier: { 182050d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling if (!TryParseRegisterWithWriteBack(Operands)) 182150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return false; 182219906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach int Res = TryParseShiftRegister(Operands); 182319906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach if (Res == 0) // success 18240082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson return false; 182519906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach else if (Res == -1) // irrecoverable error 182619906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach return true; 1827e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1828e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // Fall though for the Identifier case that is not a register or a 1829e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // special name. 183019906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach } 183167b212e03b77e921e2b9780059681125a45d15a7Kevin Enderby case AsmToken::Integer: // things like 1f and 2b as a branch targets 183267b212e03b77e921e2b9780059681125a45d15a7Kevin Enderby case AsmToken::Dot: { // . as a branch target 1833515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // This was not a register so parse other operands that start with an 1834515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // identifier (like labels) as expressions and create them as immediates. 1835515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby const MCExpr *IdVal; 1836762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan S = Parser.getTok().getLoc(); 1837515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getParser().ParseExpression(IdVal)) 183850d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1839762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 184050d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling Operands.push_back(ARMOperand::CreateImm(IdVal, S, E)); 184150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return false; 184250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling } 1843a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby case AsmToken::LBrac: 184450d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return ParseMemory(Operands); 1845d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby case AsmToken::LCurly: 184650d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return ParseRegisterList(Operands); 1847d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby case AsmToken::Hash: 1848079469f649d8da3923b9f747d7062c84e01cc4aeKevin Enderby // #42 -> immediate. 1849079469f649d8da3923b9f747d7062c84e01cc4aeKevin Enderby // TODO: ":lower16:" and ":upper16:" modifiers after # before immediate 1850762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan S = Parser.getTok().getLoc(); 1851b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 1852515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby const MCExpr *ImmVal; 1853515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getParser().ParseExpression(ImmVal)) 185450d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return true; 1855762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 185650d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling Operands.push_back(ARMOperand::CreateImm(ImmVal, S, E)); 185750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return false; 18589081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim case AsmToken::Colon: { 18599081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim // ":lower16:" and ":upper16:" expression prefixes 18607597212abced110723f2fee985a7d60557c092ecEvan Cheng // FIXME: Check it's an expression prefix, 18617597212abced110723f2fee985a7d60557c092ecEvan Cheng // e.g. (FOO - :lower16:BAR) isn't legal. 18627597212abced110723f2fee985a7d60557c092ecEvan Cheng ARMMCExpr::VariantKind RefKind; 18639081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim if (ParsePrefix(RefKind)) 18649081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return true; 18659081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 18667597212abced110723f2fee985a7d60557c092ecEvan Cheng const MCExpr *SubExprVal; 18677597212abced110723f2fee985a7d60557c092ecEvan Cheng if (getParser().ParseExpression(SubExprVal)) 18689081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return true; 18699081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 18707597212abced110723f2fee985a7d60557c092ecEvan Cheng const MCExpr *ExprVal = ARMMCExpr::Create(RefKind, SubExprVal, 18717597212abced110723f2fee985a7d60557c092ecEvan Cheng getContext()); 18729081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 18737597212abced110723f2fee985a7d60557c092ecEvan Cheng Operands.push_back(ARMOperand::CreateImm(ExprVal, S, E)); 18749081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return false; 18759081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 1876a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 1877a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 1878a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 18797597212abced110723f2fee985a7d60557c092ecEvan Cheng// ParsePrefix - Parse ARM 16-bit relocations expression prefix, i.e. 18807597212abced110723f2fee985a7d60557c092ecEvan Cheng// :lower16: and :upper16:. 18817597212abced110723f2fee985a7d60557c092ecEvan Chengbool ARMAsmParser::ParsePrefix(ARMMCExpr::VariantKind &RefKind) { 18827597212abced110723f2fee985a7d60557c092ecEvan Cheng RefKind = ARMMCExpr::VK_ARM_None; 18839081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 18849081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim // :lower16: and :upper16: modifiers 18858a8696db6b6f6e735bb9de630876af83946b45f9Jason W Kim assert(getLexer().is(AsmToken::Colon) && "expected a :"); 18869081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim Parser.Lex(); // Eat ':' 18879081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 18889081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim if (getLexer().isNot(AsmToken::Identifier)) { 18899081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim Error(Parser.getTok().getLoc(), "expected prefix identifier in operand"); 18909081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return true; 18919081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 18929081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 18939081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim StringRef IDVal = Parser.getTok().getIdentifier(); 18949081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim if (IDVal == "lower16") { 18957597212abced110723f2fee985a7d60557c092ecEvan Cheng RefKind = ARMMCExpr::VK_ARM_LO16; 18969081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } else if (IDVal == "upper16") { 18977597212abced110723f2fee985a7d60557c092ecEvan Cheng RefKind = ARMMCExpr::VK_ARM_HI16; 18989081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } else { 18999081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim Error(Parser.getTok().getLoc(), "unexpected prefix in operand"); 19009081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return true; 19019081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 19029081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim Parser.Lex(); 19039081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 19049081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim if (getLexer().isNot(AsmToken::Colon)) { 19059081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim Error(Parser.getTok().getLoc(), "unexpected token after prefix"); 19069081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return true; 19079081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 19089081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim Parser.Lex(); // Eat the last ':' 19099081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return false; 19109081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim} 19119081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 19129081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kimconst MCExpr * 19139081b4b4cf89a161246e037f4817c69de2fcdf82Jason W KimARMAsmParser::ApplyPrefixToExpr(const MCExpr *E, 19149081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim MCSymbolRefExpr::VariantKind Variant) { 19159081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim // Recurse over the given expression, rebuilding it to apply the given variant 19169081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim // to the leftmost symbol. 19179081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim if (Variant == MCSymbolRefExpr::VK_None) 19189081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return E; 19199081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 19209081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim switch (E->getKind()) { 19219081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim case MCExpr::Target: 19229081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim llvm_unreachable("Can't handle target expr yet"); 19239081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim case MCExpr::Constant: 19249081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim llvm_unreachable("Can't handle lower16/upper16 of constant yet"); 19259081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 19269081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim case MCExpr::SymbolRef: { 19279081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E); 19289081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 19299081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim if (SRE->getKind() != MCSymbolRefExpr::VK_None) 19309081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return 0; 19319081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 19329081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return MCSymbolRefExpr::Create(&SRE->getSymbol(), Variant, getContext()); 19339081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 19349081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 19359081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim case MCExpr::Unary: 19369081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim llvm_unreachable("Can't handle unary expressions yet"); 19379081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 19389081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim case MCExpr::Binary: { 19399081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim const MCBinaryExpr *BE = cast<MCBinaryExpr>(E); 19409081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim const MCExpr *LHS = ApplyPrefixToExpr(BE->getLHS(), Variant); 19419081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim const MCExpr *RHS = BE->getRHS(); 19429081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim if (!LHS) 19439081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return 0; 19449081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 19459081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return MCBinaryExpr::Create(BE->getOpcode(), LHS, RHS, getContext()); 19469081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 19479081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim } 19489081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 19499081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim assert(0 && "Invalid expression kind!"); 19509081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim return 0; 19519081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim} 19529081b4b4cf89a161246e037f4817c69de2fcdf82Jason W Kim 1953352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar/// \brief Given a mnemonic, split out possible predication code and carry 1954352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar/// setting letters to form a canonical mnemonic and flags. 1955352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar// 1956badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar// FIXME: Would be nice to autogen this. 19575f16057d1e4b711d492091bc555693a03d4a1b6eJim GrosbachStringRef ARMAsmParser::SplitMnemonic(StringRef Mnemonic, 19585f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach unsigned &PredicationCode, 19595f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach bool &CarrySetting, 19605f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach unsigned &ProcessorIMod) { 1961352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar PredicationCode = ARMCC::AL; 1962352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar CarrySetting = false; 1963a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ProcessorIMod = 0; 1964352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar 1965badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar // Ignore some mnemonics we know aren't predicated forms. 1966352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar // 1967352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar // FIXME: Would be nice to autogen this. 19685f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach if ((Mnemonic == "movs" && isThumb()) || 19695f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "teq" || Mnemonic == "vceq" || Mnemonic == "svc" || 19705f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "mls" || Mnemonic == "smmls" || Mnemonic == "vcls" || 19715f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vmls" || Mnemonic == "vnmls" || Mnemonic == "vacge" || 19725f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vcge" || Mnemonic == "vclt" || Mnemonic == "vacgt" || 19735f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vcgt" || Mnemonic == "vcle" || Mnemonic == "smlal" || 19745f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "umaal" || Mnemonic == "umlal" || Mnemonic == "vabal" || 19755f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vmlal" || Mnemonic == "vpadal" || Mnemonic == "vqdmlal") 1976352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar return Mnemonic; 1977badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar 19783f00e317064560ad11168d22030416d853829f6eJim Grosbach // First, split out any predication code. Ignore mnemonics we know aren't 19793f00e317064560ad11168d22030416d853829f6eJim Grosbach // predicated but do have a carry-set and so weren't caught above. 1980ab40f4b737b0a87c4048a9ad2f0c02be735e3770Jim Grosbach if (Mnemonic != "adcs" && Mnemonic != "bics" && Mnemonic != "movs" && 1981ab40f4b737b0a87c4048a9ad2f0c02be735e3770Jim Grosbach Mnemonic != "muls") { 19823f00e317064560ad11168d22030416d853829f6eJim Grosbach unsigned CC = StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2)) 19833f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("eq", ARMCC::EQ) 19843f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("ne", ARMCC::NE) 19853f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("hs", ARMCC::HS) 19863f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("cs", ARMCC::HS) 19873f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("lo", ARMCC::LO) 19883f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("cc", ARMCC::LO) 19893f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("mi", ARMCC::MI) 19903f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("pl", ARMCC::PL) 19913f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("vs", ARMCC::VS) 19923f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("vc", ARMCC::VC) 19933f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("hi", ARMCC::HI) 19943f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("ls", ARMCC::LS) 19953f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("ge", ARMCC::GE) 19963f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("lt", ARMCC::LT) 19973f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("gt", ARMCC::GT) 19983f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("le", ARMCC::LE) 19993f00e317064560ad11168d22030416d853829f6eJim Grosbach .Case("al", ARMCC::AL) 20003f00e317064560ad11168d22030416d853829f6eJim Grosbach .Default(~0U); 20013f00e317064560ad11168d22030416d853829f6eJim Grosbach if (CC != ~0U) { 20023f00e317064560ad11168d22030416d853829f6eJim Grosbach Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 2); 20033f00e317064560ad11168d22030416d853829f6eJim Grosbach PredicationCode = CC; 20043f00e317064560ad11168d22030416d853829f6eJim Grosbach } 200552925b60f1cd4cf810524ca05b00a207a926ab9fBill Wendling } 2006345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 2007352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar // Next, determine if we have a carry setting bit. We explicitly ignore all 2008352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar // the instructions we know end in 's'. 2009352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar if (Mnemonic.endswith("s") && 2010352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar !(Mnemonic == "asrs" || Mnemonic == "cps" || Mnemonic == "mls" || 20115f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "mrs" || Mnemonic == "smmls" || Mnemonic == "vabs" || 20125f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vcls" || Mnemonic == "vmls" || Mnemonic == "vmrs" || 20135f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vnmls" || Mnemonic == "vqabs" || Mnemonic == "vrecps" || 20145f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "vrsqrts" || (Mnemonic == "movs" && isThumb()))) { 2015352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 1); 2016352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar CarrySetting = true; 2017352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar } 2018352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar 2019a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // The "cps" instruction can have a interrupt mode operand which is glued into 2020a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // the mnemonic. Check if this is the case, split it and parse the imod op 2021a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (Mnemonic.startswith("cps")) { 2022a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // Split out any imod code. 2023a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes unsigned IMod = 2024a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2, 2)) 2025a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Case("ie", ARM_PROC::IE) 2026a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Case("id", ARM_PROC::ID) 2027a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes .Default(~0U); 2028a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (IMod != ~0U) { 2029a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Mnemonic = Mnemonic.slice(0, Mnemonic.size()-2); 2030a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ProcessorIMod = IMod; 2031a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 2032a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 2033a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 2034352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar return Mnemonic; 2035352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar} 20363771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar 20373771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar/// \brief Given a canonical mnemonic, determine if the instruction ever allows 20383771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar/// inclusion of carry set or predication code operands. 20393771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar// 20403771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar// FIXME: It would be nice to autogen this. 2041fdcee77887372dbf6589d47cc33094965b679f24Bruno Cardoso Lopesvoid ARMAsmParser:: 2042fdcee77887372dbf6589d47cc33094965b679f24Bruno Cardoso LopesGetMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet, 2043fdcee77887372dbf6589d47cc33094965b679f24Bruno Cardoso Lopes bool &CanAcceptPredicationCode) { 2044eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar if (Mnemonic == "and" || Mnemonic == "lsl" || Mnemonic == "lsr" || 2045eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "rrx" || Mnemonic == "ror" || Mnemonic == "sub" || 2046eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "smull" || Mnemonic == "add" || Mnemonic == "adc" || 2047eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "mul" || Mnemonic == "bic" || Mnemonic == "asr" || 2048be64b394317feb8d7bcb732bdfb35e0b286efd4cBruno Cardoso Lopes Mnemonic == "umlal" || Mnemonic == "orr" || Mnemonic == "mvn" || 2049eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "rsb" || Mnemonic == "rsc" || Mnemonic == "orn" || 2050eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "sbc" || Mnemonic == "mla" || Mnemonic == "umull" || 2051be64b394317feb8d7bcb732bdfb35e0b286efd4cBruno Cardoso Lopes Mnemonic == "eor" || Mnemonic == "smlal" || 2052ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng (Mnemonic == "mov" && !isThumbOne())) { 2053eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar CanAcceptCarrySet = true; 2054eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar } else { 2055eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar CanAcceptCarrySet = false; 2056eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar } 20573771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar 2058eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar if (Mnemonic == "cbnz" || Mnemonic == "setend" || Mnemonic == "dmb" || 2059eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "cps" || Mnemonic == "mcr2" || Mnemonic == "it" || 2060eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "mcrr2" || Mnemonic == "cbz" || Mnemonic == "cdp2" || 2061eb9f3f91c03c29f020ee3c25cfefe7ae2b496526Daniel Dunbar Mnemonic == "trap" || Mnemonic == "mrc2" || Mnemonic == "mrrc2" || 20625f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic == "dsb" || Mnemonic == "isb" || Mnemonic == "clrex" || 20635f16057d1e4b711d492091bc555693a03d4a1b6eJim Grosbach Mnemonic.startswith("cps") || (Mnemonic == "movs" && isThumb())) { 20643771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar CanAcceptPredicationCode = false; 20653771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar } else { 20663771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar CanAcceptPredicationCode = true; 20673771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar } 2068fa5bd27fbe5188ca708ac0dda4f32d90505da9f5Bruno Cardoso Lopes 2069ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng if (isThumb()) 2070fa5bd27fbe5188ca708ac0dda4f32d90505da9f5Bruno Cardoso Lopes if (Mnemonic == "bkpt" || Mnemonic == "mcr" || Mnemonic == "mcrr" || 207163b46faeb8acae9b7e5f865b7417dc00b9b9dad3Jim Grosbach Mnemonic == "mrc" || Mnemonic == "mrrc" || Mnemonic == "cdp") 2072fa5bd27fbe5188ca708ac0dda4f32d90505da9f5Bruno Cardoso Lopes CanAcceptPredicationCode = false; 2073badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar} 2074badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar 2075badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar/// Parse an arm instruction mnemonic followed by its operands. 2076badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbarbool ARMAsmParser::ParseInstruction(StringRef Name, SMLoc NameLoc, 2077badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 2078badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar // Create the leading tokens for the mnemonic, split by '.' characters. 2079badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar size_t Start = 0, Next = Name.find('.'); 2080ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach StringRef Mnemonic = Name.slice(Start, Next); 2081badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar 2082352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar // Split out the predication code and carry setting flag from the mnemonic. 2083352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar unsigned PredicationCode; 2084a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes unsigned ProcessorIMod; 2085352e148cbe6498a6dd31b7fc71df7cd23c4b4d10Daniel Dunbar bool CarrySetting; 2086ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach Mnemonic = SplitMnemonic(Mnemonic, PredicationCode, CarrySetting, 2087a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ProcessorIMod); 2088badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar 2089ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach Operands.push_back(ARMOperand::CreateToken(Mnemonic, NameLoc)); 2090ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 2091ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // FIXME: This is all a pretty gross hack. We should automatically handle 2092ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // optional operands like this via tblgen. 20939717fa9f29696bca45ddfdf206b1c382c8b40b78Bill Wendling 20943771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // Next, add the CCOut and ConditionCode operands, if needed. 20953771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // 20963771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // For mnemonics which can ever incorporate a carry setting bit or predication 20973771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // code, our matching model involves us always generating CCOut and 20983771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // ConditionCode operands to match the mnemonic "as written" and then we let 20993771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // the matcher deal with finding the right instruction or generating an 21003771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // appropriate error. 21013771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar bool CanAcceptCarrySet, CanAcceptPredicationCode; 2102ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach GetMnemonicAcceptInfo(Mnemonic, CanAcceptCarrySet, CanAcceptPredicationCode); 21033771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar 210433c16a27370939de39679245c3dff72383c210bdJim Grosbach // If we had a carry-set on an instruction that can't do that, issue an 210533c16a27370939de39679245c3dff72383c210bdJim Grosbach // error. 210633c16a27370939de39679245c3dff72383c210bdJim Grosbach if (!CanAcceptCarrySet && CarrySetting) { 210733c16a27370939de39679245c3dff72383c210bdJim Grosbach Parser.EatToEndOfStatement(); 2108ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach return Error(NameLoc, "instruction '" + Mnemonic + 210933c16a27370939de39679245c3dff72383c210bdJim Grosbach "' can not set flags, but 's' suffix specified"); 211033c16a27370939de39679245c3dff72383c210bdJim Grosbach } 211133c16a27370939de39679245c3dff72383c210bdJim Grosbach 21123771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // Add the carry setting operand, if necessary. 21133771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // 21143771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // FIXME: It would be awesome if we could somehow invent a location such that 21153771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // match errors on this operand would print a nice diagnostic about how the 21163771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // 's' character in the mnemonic resulted in a CCOut operand. 211733c16a27370939de39679245c3dff72383c210bdJim Grosbach if (CanAcceptCarrySet) 21183771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar Operands.push_back(ARMOperand::CreateCCOut(CarrySetting ? ARM::CPSR : 0, 21193771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar NameLoc)); 21203771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar 21213771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // Add the predication code operand, if necessary. 21223771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar if (CanAcceptPredicationCode) { 21233771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar Operands.push_back(ARMOperand::CreateCondCode( 21243771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar ARMCC::CondCodes(PredicationCode), NameLoc)); 21253771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar } else { 21263771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // This mnemonic can't ever accept a predication code, but the user wrote 21273771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // one (or misspelled another mnemonic). 21283771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar 21293771dd041f6a68bef08b6f685a41d1d54f4e8b9dDaniel Dunbar // FIXME: Issue a nice error. 2130badbd2fde9b8debd6265e8ece511fb01123d1d5fDaniel Dunbar } 2131345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 2132a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // Add the processor imod operand, if necessary. 2133a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (ProcessorIMod) { 2134a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateImm( 2135a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes MCConstantExpr::Create(ProcessorIMod, getContext()), 2136a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes NameLoc, NameLoc)); 2137a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } else { 2138a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // This mnemonic can't ever accept a imod, but the user wrote 2139a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // one (or misspelled another mnemonic). 2140a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 2141a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // FIXME: Issue a nice error. 2142a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 2143a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 2144345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // Add the remaining tokens in the mnemonic. 21455747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar while (Next != StringRef::npos) { 21465747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar Start = Next; 21475747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar Next = Name.find('.', Start + 1); 2148a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes StringRef ExtraToken = Name.slice(Start, Next); 2149a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 2150a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Operands.push_back(ARMOperand::CreateToken(ExtraToken, NameLoc)); 21515747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar } 21525747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar 21535747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar // Read the remaining operands. 21545747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar if (getLexer().isNot(AsmToken::EndOfStatement)) { 2155a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Read the first operand. 2156ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach if (ParseOperand(Operands, Mnemonic)) { 2157cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner Parser.EatToEndOfStatement(); 2158cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner return true; 2159cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner } 2160a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 2161a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby while (getLexer().is(AsmToken::Comma)) { 2162b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat the comma. 2163a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 2164a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Parse and remember the operand. 2165ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach if (ParseOperand(Operands, Mnemonic)) { 2166cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner Parser.EatToEndOfStatement(); 2167cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner return true; 2168cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner } 2169a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 2170a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 217116c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 2172cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner if (getLexer().isNot(AsmToken::EndOfStatement)) { 2173cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner Parser.EatToEndOfStatement(); 217434e53140c2cc02ce4c9d060e48302576d3962e1cChris Lattner return TokError("unexpected token in argument list"); 2175cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner } 2176146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling 217734e53140c2cc02ce4c9d060e48302576d3962e1cChris Lattner Parser.Lex(); // Consume the EndOfStatement 2178ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 2179ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 2180ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // The 'mov' mnemonic is special. One variant has a cc_out operand, while 2181ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // another does not. Specifically, the MOVW instruction does not. So we 2182ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // special case it here and remove the defaulted (non-setting) cc_out 2183ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // operand if that's the instruction we're trying to match. 2184ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // 2185ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // We do this post-processing of the explicit operands rather than just 2186ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // conditionally adding the cc_out in the first place because we need 2187ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // to check the type of the parsed immediate operand. 2188ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach if (Mnemonic == "mov" && Operands.size() > 4 && 2189ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach !static_cast<ARMOperand*>(Operands[4])->isARMSOImm() && 2190731f2097944bfdf5b58ff1f19560a25ed15c9b2bJim Grosbach static_cast<ARMOperand*>(Operands[4])->isImm0_65535Expr() && 2191731f2097944bfdf5b58ff1f19560a25ed15c9b2bJim Grosbach static_cast<ARMOperand*>(Operands[1])->getReg() == 0) { 2192ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]); 2193ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach Operands.erase(Operands.begin() + 1); 2194ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach delete Op; 2195ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach } 2196ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 2197ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 2198ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 21999898671a74d3fc924347e679c45edaa685b3fe6eChris Lattner return false; 2200ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 2201ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 2202fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattnerbool ARMAsmParser:: 2203fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris LattnerMatchAndEmitInstruction(SMLoc IDLoc, 2204fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner SmallVectorImpl<MCParsedAsmOperand*> &Operands, 2205fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner MCStreamer &Out) { 2206fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner MCInst Inst; 2207fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner unsigned ErrorInfo; 22085a18700470f0831b9b2af78862672561dd980345Jim Grosbach MatchResultTy MatchResult; 2209193c3acbe5cdb60767d114016970e898c7502d7aKevin Enderby MatchResult = MatchInstructionImpl(Operands, Inst, ErrorInfo); 2210193c3acbe5cdb60767d114016970e898c7502d7aKevin Enderby switch (MatchResult) { 2211e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner case Match_Success: 2212fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner Out.EmitInstruction(Inst); 2213fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner return false; 2214e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner case Match_MissingFeature: 2215e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner Error(IDLoc, "instruction requires a CPU feature not currently enabled"); 2216e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner return true; 2217e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner case Match_InvalidOperand: { 2218e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner SMLoc ErrorLoc = IDLoc; 2219e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner if (ErrorInfo != ~0U) { 2220e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner if (ErrorInfo >= Operands.size()) 2221e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner return Error(IDLoc, "too few operands for instruction"); 222216c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 2223e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner ErrorLoc = ((ARMOperand*)Operands[ErrorInfo])->getStartLoc(); 2224e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc; 2225e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner } 222616c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 2227e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner return Error(ErrorLoc, "invalid operand for instruction"); 2228e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner } 2229e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner case Match_MnemonicFail: 2230e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner return Error(IDLoc, "unrecognized instruction mnemonic"); 2231b412915ff6229b3e2dffedcfb0f3fb7e85259841Daniel Dunbar case Match_ConversionFail: 2232b412915ff6229b3e2dffedcfb0f3fb7e85259841Daniel Dunbar return Error(IDLoc, "unable to convert operands to instruction"); 2233fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner } 223416c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 2235c223e2b10b4753a63dfe7e6980c650b179139983Eric Christopher llvm_unreachable("Implement any new match types added!"); 2236146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling return true; 2237fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner} 2238fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner 2239515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ParseDirective parses the arm specific directives 2240ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbybool ARMAsmParser::ParseDirective(AsmToken DirectiveID) { 2241ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby StringRef IDVal = DirectiveID.getIdentifier(); 2242ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (IDVal == ".word") 2243ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return ParseDirectiveWord(4, DirectiveID.getLoc()); 2244515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else if (IDVal == ".thumb") 2245515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return ParseDirectiveThumb(DirectiveID.getLoc()); 2246515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else if (IDVal == ".thumb_func") 2247515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return ParseDirectiveThumbFunc(DirectiveID.getLoc()); 2248515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else if (IDVal == ".code") 2249515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return ParseDirectiveCode(DirectiveID.getLoc()); 2250515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else if (IDVal == ".syntax") 2251515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return ParseDirectiveSyntax(DirectiveID.getLoc()); 2252ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return true; 2253ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 2254ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 2255ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby/// ParseDirectiveWord 2256ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby/// ::= .word [ expression (, expression)* ] 2257ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbybool ARMAsmParser::ParseDirectiveWord(unsigned Size, SMLoc L) { 2258ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) { 2259ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby for (;;) { 2260ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby const MCExpr *Value; 2261ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (getParser().ParseExpression(Value)) 2262ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return true; 2263ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 2264aaec205b87637cd0d59d4f11630db603686eb73dChris Lattner getParser().getStreamer().EmitValue(Value, Size, 0/*addrspace*/); 2265ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 2266ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (getLexer().is(AsmToken::EndOfStatement)) 2267ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby break; 226816c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 2269ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // FIXME: Improve diagnostic. 2270ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (getLexer().isNot(AsmToken::Comma)) 2271ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return Error(L, "unexpected token in directive"); 2272b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2273ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby } 2274ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby } 2275ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 2276b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2277ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return false; 2278ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 2279ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 2280515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ParseDirectiveThumb 2281515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ::= .thumb 2282515d509360d81946247fd0f937034cdf1f237c72Kevin Enderbybool ARMAsmParser::ParseDirectiveThumb(SMLoc L) { 2283515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) 2284515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unexpected token in directive"); 2285b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2286515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 2287515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // TODO: set thumb mode 2288515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // TODO: tell the MC streamer the mode 2289515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // getParser().getStreamer().Emit???(); 2290515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return false; 2291515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby} 2292515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 2293515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ParseDirectiveThumbFunc 2294515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ::= .thumbfunc symbol_name 2295515d509360d81946247fd0f937034cdf1f237c72Kevin Enderbybool ARMAsmParser::ParseDirectiveThumbFunc(SMLoc L) { 22966469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola const MCAsmInfo &MAI = getParser().getStreamer().getContext().getAsmInfo(); 22976469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola bool isMachO = MAI.hasSubsectionsViaSymbols(); 22986469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola StringRef Name; 22996469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola 23006469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola // Darwin asm has function name after .thumb_func direction 23016469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola // ELF doesn't 23026469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola if (isMachO) { 23036469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola const AsmToken &Tok = Parser.getTok(); 23046469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola if (Tok.isNot(AsmToken::Identifier) && Tok.isNot(AsmToken::String)) 23056469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola return Error(L, "unexpected token in .thumb_func directive"); 23066469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola Name = Tok.getString(); 23076469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola Parser.Lex(); // Consume the identifier token. 23086469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola } 23096469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola 2310515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) 2311515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unexpected token in directive"); 2312b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2313515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 23146469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola // FIXME: assuming function name will be the line following .thumb_func 23156469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola if (!isMachO) { 23166469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola Name = Parser.getTok().getString(); 23176469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola } 23186469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola 2319642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach // Mark symbol as a thumb symbol. 2320642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach MCSymbol *Func = getParser().getContext().GetOrCreateSymbol(Name); 2321642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach getParser().getStreamer().EmitThumbFunc(Func); 2322515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return false; 2323515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby} 2324515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 2325515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ParseDirectiveSyntax 2326515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ::= .syntax unified | divided 2327515d509360d81946247fd0f937034cdf1f237c72Kevin Enderbybool ARMAsmParser::ParseDirectiveSyntax(SMLoc L) { 232818b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 2329515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (Tok.isNot(AsmToken::Identifier)) 2330515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unexpected token in .syntax directive"); 233138e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramer StringRef Mode = Tok.getString(); 233258c86910b31c569a5709466c82e2fabae2014a56Duncan Sands if (Mode == "unified" || Mode == "UNIFIED") 2333b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 233458c86910b31c569a5709466c82e2fabae2014a56Duncan Sands else if (Mode == "divided" || Mode == "DIVIDED") 23359e56fb12c504c82c92947fe9c46287fc60116b91Kevin Enderby return Error(L, "'.syntax divided' arm asssembly not supported"); 2336515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else 2337515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unrecognized syntax mode in .syntax directive"); 2338515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 2339515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) 234018b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan return Error(Parser.getTok().getLoc(), "unexpected token in directive"); 2341b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2342515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 2343515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // TODO tell the MC streamer the mode 2344515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // getParser().getStreamer().Emit???(); 2345515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return false; 2346515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby} 2347515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 2348515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ParseDirectiveCode 2349515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ::= .code 16 | 32 2350515d509360d81946247fd0f937034cdf1f237c72Kevin Enderbybool ARMAsmParser::ParseDirectiveCode(SMLoc L) { 235118b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 2352515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (Tok.isNot(AsmToken::Integer)) 2353515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unexpected token in .code directive"); 235418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan int64_t Val = Parser.getTok().getIntVal(); 235558c86910b31c569a5709466c82e2fabae2014a56Duncan Sands if (Val == 16) 2356b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 235758c86910b31c569a5709466c82e2fabae2014a56Duncan Sands else if (Val == 32) 2358b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2359515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else 2360515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "invalid operand to .code directive"); 2361515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 2362515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) 236318b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan return Error(Parser.getTok().getLoc(), "unexpected token in directive"); 2364b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 2365515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 236632869205052430f45d598fba25ab878d8b29da2dEvan Cheng if (Val == 16) { 2367ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng if (!isThumb()) 2368ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng SwitchMode(); 23692a301704ea76535f0485d5c3b75664b323249bdbJim Grosbach getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16); 237032869205052430f45d598fba25ab878d8b29da2dEvan Cheng } else { 2371ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng if (isThumb()) 2372ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng SwitchMode(); 23732a301704ea76535f0485d5c3b75664b323249bdbJim Grosbach getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32); 2374eb0caa115491019f7f7fe45fc70ad47682244187Evan Cheng } 23752a301704ea76535f0485d5c3b75664b323249bdbJim Grosbach 2376515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return false; 2377515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby} 2378515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 237990b7097f92f6b4f6b27cd88c7c88a21b777f5795Sean Callananextern "C" void LLVMInitializeARMAsmLexer(); 238090b7097f92f6b4f6b27cd88c7c88a21b777f5795Sean Callanan 23819c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Force static initialization. 2382ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbyextern "C" void LLVMInitializeARMAsmParser() { 2383ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby RegisterAsmParser<ARMAsmParser> X(TheARMTarget); 2384ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby RegisterAsmParser<ARMAsmParser> Y(TheThumbTarget); 238590b7097f92f6b4f6b27cd88c7c88a21b777f5795Sean Callanan LLVMInitializeARMAsmLexer(); 2386ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 23873483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 23880692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner#define GET_REGISTER_MATCHER 23890692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner#define GET_MATCHER_IMPLEMENTATION 23903483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar#include "ARMGenAsmMatcher.inc" 2391