ARMAsmParser.cpp revision b32e7844e9f79d2bd4ff34a1d19aba347f999abc
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" 1192b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling#include "ARMAddressingModes.h" 123483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar#include "ARMSubtarget.h" 13c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/MC/MCParser/MCAsmLexer.h" 14c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/MC/MCParser/MCAsmParser.h" 15c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/MC/MCParser/MCParsedAsmOperand.h" 16642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach#include "llvm/MC/MCContext.h" 17ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/MC/MCStreamer.h" 18ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/MC/MCExpr.h" 19ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/MC/MCInst.h" 20ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/Target/TargetRegistry.h" 21ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/Target/TargetAsmParser.h" 22c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/Support/SourceMgr.h" 23fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar#include "llvm/Support/raw_ostream.h" 24c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/ADT/SmallVector.h" 25345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar#include "llvm/ADT/StringSwitch.h" 26c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/ADT/Twine.h" 27ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbyusing namespace llvm; 28ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 29a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby// The shift types for register controlled shifts in arm memory addressing 30a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderbyenum ShiftType { 31a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Lsl, 32a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Lsr, 33a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Asr, 34a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Ror, 35a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Rrx 36a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby}; 37a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 383a69756e392942bc522193f38d7f33958ed3b131Chris Lattnernamespace { 39146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling 40146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendlingclass ARMOperand; 4116c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 42ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbyclass ARMAsmParser : public TargetAsmParser { 43ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby MCAsmParser &Parser; 44d73ada7d24832bc2a4c3965b8f00ffd951341acfDaniel Dunbar TargetMachine &TM; 45ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 46ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby MCAsmParser &getParser() const { return Parser; } 47ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby MCAsmLexer &getLexer() const { return Parser.getLexer(); } 48ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 49ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby void Warning(SMLoc L, const Twine &Msg) { Parser.Warning(L, Msg); } 50ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); } 51ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 52e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner int TryParseRegister(); 53e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner ARMOperand *TryParseRegisterWithWriteBack(); 54c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner ARMOperand *ParseRegisterList(); 55550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner ARMOperand *ParseMemory(); 56146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling ARMOperand *ParseOperand(); 57a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 589c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool ParseMemoryOffsetReg(bool &Negative, 599c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool &OffsetRegShifted, 609c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby enum ShiftType &ShiftType, 619c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const MCExpr *&ShiftAmount, 629c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const MCExpr *&Offset, 639c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool &OffsetIsReg, 64762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan int &OffsetRegNum, 65762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc &E); 66762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan bool ParseShift(enum ShiftType &St, const MCExpr *&ShiftAmount, SMLoc &E); 67ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby bool ParseDirectiveWord(unsigned Size, SMLoc L); 68515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby bool ParseDirectiveThumb(SMLoc L); 69515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby bool ParseDirectiveThumbFunc(SMLoc L); 70515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby bool ParseDirectiveCode(SMLoc L); 71515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby bool ParseDirectiveSyntax(SMLoc L); 72515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 737036f8be4df8a1a830ca01afe9497b035a5647d6Chris Lattner bool MatchAndEmitInstruction(SMLoc IDLoc, 747c51a3172cf5104ebeaef22f1366fa634ca00d85Chris Lattner SmallVectorImpl<MCParsedAsmOperand*> &Operands, 75fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner MCStreamer &Out); 7616c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 77a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby /// @name Auto-generated Match Functions 78a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby /// { 793483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 800692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner#define GET_ASSEMBLER_HEADER 810692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner#include "ARMGenAsmMatcher.inc" 82a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 83a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby /// } 84a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 85ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbypublic: 86d73ada7d24832bc2a4c3965b8f00ffd951341acfDaniel Dunbar ARMAsmParser(const Target &T, MCAsmParser &_Parser, TargetMachine &_TM) 87833c93c7958dbbd9d648f331091fbfbeabf342e6Jim Grosbach : TargetAsmParser(T), Parser(_Parser), TM(_TM) { 88833c93c7958dbbd9d648f331091fbfbeabf342e6Jim Grosbach // Initialize the set of available features. 89833c93c7958dbbd9d648f331091fbfbeabf342e6Jim Grosbach setAvailableFeatures(ComputeAvailableFeatures( 90833c93c7958dbbd9d648f331091fbfbeabf342e6Jim Grosbach &TM.getSubtarget<ARMSubtarget>())); 91833c93c7958dbbd9d648f331091fbfbeabf342e6Jim Grosbach } 92ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 9338e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramer virtual bool ParseInstruction(StringRef Name, SMLoc NameLoc, 949898671a74d3fc924347e679c45edaa685b3fe6eChris Lattner SmallVectorImpl<MCParsedAsmOperand*> &Operands); 95ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby virtual bool ParseDirective(AsmToken DirectiveID); 96ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby}; 9716c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach} // end anonymous namespace 9816c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 993a69756e392942bc522193f38d7f33958ed3b131Chris Lattnernamespace { 1003a69756e392942bc522193f38d7f33958ed3b131Chris Lattner 101a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// ARMOperand - Instances of this class represent a parsed ARM machine 102a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// instruction. 103146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendlingclass ARMOperand : public MCParsedAsmOperand { 104762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan enum KindTy { 1058462b30548fb5969250858036638c73c16b65b43Daniel Dunbar CondCode, 106cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby Immediate, 1078462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Memory, 1088462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Register, 1098d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling RegisterList, 1108462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Token 111a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } Kind; 112a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 113762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc StartLoc, EndLoc; 114a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 115a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby union { 116a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby struct { 1178462b30548fb5969250858036638c73c16b65b43Daniel Dunbar ARMCC::CondCodes Val; 1188462b30548fb5969250858036638c73c16b65b43Daniel Dunbar } CC; 1198462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 1208462b30548fb5969250858036638c73c16b65b43Daniel Dunbar struct { 121a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby const char *Data; 122a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby unsigned Length; 123a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } Tok; 124a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 125a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby struct { 126a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby unsigned RegNum; 12799e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby bool Writeback; 128a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } Reg; 129a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 1308155e5b753aca42973cf317727f3805faddcaf90Bill Wendling struct { 1318d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling unsigned RegStart; 1328d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling unsigned Number; 1338d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } RegList; 1348d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 135cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby struct { 136cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby const MCExpr *Val; 137cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby } Imm; 13816c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 139a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // This is for all forms of ARM address expressions 140a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby struct { 141a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby unsigned BaseRegNum; 142146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling unsigned OffsetRegNum; // used when OffsetIsReg is true 143146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling const MCExpr *Offset; // used when OffsetIsReg is false 144146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling const MCExpr *ShiftAmount; // used when OffsetRegShifted is true 145146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling enum ShiftType ShiftType; // used when OffsetRegShifted is true 146146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling unsigned OffsetRegShifted : 1; // only used when OffsetIsReg is true 147146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling unsigned Preindexed : 1; 148146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling unsigned Postindexed : 1; 149146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling unsigned OffsetIsReg : 1; 150146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling unsigned Negative : 1; // only used when OffsetIsReg is true 151146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling unsigned Writeback : 1; 152a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } Mem; 153a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby }; 15416c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 155146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling ARMOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {} 156146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendlingpublic: 157762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan ARMOperand(const ARMOperand &o) : MCParsedAsmOperand() { 158762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Kind = o.Kind; 159762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan StartLoc = o.StartLoc; 160762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan EndLoc = o.EndLoc; 161762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan switch (Kind) { 1628462b30548fb5969250858036638c73c16b65b43Daniel Dunbar case CondCode: 1638462b30548fb5969250858036638c73c16b65b43Daniel Dunbar CC = o.CC; 1648462b30548fb5969250858036638c73c16b65b43Daniel Dunbar break; 165762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan case Token: 1668462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Tok = o.Tok; 167762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan break; 168762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan case Register: 169762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Reg = o.Reg; 170762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan break; 1718d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling case RegisterList: 1728d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling RegList = o.RegList; 1738d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling break; 174762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan case Immediate: 175762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Imm = o.Imm; 176762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan break; 177762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan case Memory: 178762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Mem = o.Mem; 179762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan break; 180762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 181762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 18216c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 183762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan /// getStartLoc - Get the location of the first token of this operand. 184762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc getStartLoc() const { return StartLoc; } 185762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan /// getEndLoc - Get the location of the last token of this operand. 186762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc getEndLoc() const { return EndLoc; } 187a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 1888462b30548fb5969250858036638c73c16b65b43Daniel Dunbar ARMCC::CondCodes getCondCode() const { 1898462b30548fb5969250858036638c73c16b65b43Daniel Dunbar assert(Kind == CondCode && "Invalid access!"); 1908462b30548fb5969250858036638c73c16b65b43Daniel Dunbar return CC.Val; 1918462b30548fb5969250858036638c73c16b65b43Daniel Dunbar } 1928462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 193a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby StringRef getToken() const { 194a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby assert(Kind == Token && "Invalid access!"); 195a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return StringRef(Tok.Data, Tok.Length); 196a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 197a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 198a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby unsigned getReg() const { 1998155e5b753aca42973cf317727f3805faddcaf90Bill Wendling assert((Kind == Register || Kind == RegisterList) && "Invalid access!"); 2008155e5b753aca42973cf317727f3805faddcaf90Bill Wendling unsigned RegNum = 0; 2018155e5b753aca42973cf317727f3805faddcaf90Bill Wendling if (Kind == Register) 2028155e5b753aca42973cf317727f3805faddcaf90Bill Wendling RegNum = Reg.RegNum; 2038155e5b753aca42973cf317727f3805faddcaf90Bill Wendling else 2048155e5b753aca42973cf317727f3805faddcaf90Bill Wendling RegNum = RegList.RegStart; 2058155e5b753aca42973cf317727f3805faddcaf90Bill Wendling return RegNum; 206a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 207a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 2088d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling std::pair<unsigned, unsigned> getRegList() const { 2098d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling assert(Kind == RegisterList && "Invalid access!"); 2108d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling return std::make_pair(RegList.RegStart, RegList.Number); 2118d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } 2128d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 213cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby const MCExpr *getImm() const { 214cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby assert(Kind == Immediate && "Invalid access!"); 215cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby return Imm.Val; 216cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby } 217cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby 2188462b30548fb5969250858036638c73c16b65b43Daniel Dunbar bool isCondCode() const { return Kind == CondCode; } 2193483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar bool isImm() const { return Kind == Immediate; } 220b32e7844e9f79d2bd4ff34a1d19aba347f999abcBill Wendling bool isReg() const { return Kind == Register; } 2218d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling bool isRegList() const { return Kind == RegisterList; } 22214b93851cc7611ae6c2000f1c162592ead954420Chris Lattner bool isToken() const { return Kind == Token; } 22314b93851cc7611ae6c2000f1c162592ead954420Chris Lattner bool isMemory() const { return Kind == Memory; } 2243483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 2253483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar void addExpr(MCInst &Inst, const MCExpr *Expr) const { 22614b93851cc7611ae6c2000f1c162592ead954420Chris Lattner // Add as immediates when possible. Null MCExpr = 0. 22714b93851cc7611ae6c2000f1c162592ead954420Chris Lattner if (Expr == 0) 22814b93851cc7611ae6c2000f1c162592ead954420Chris Lattner Inst.addOperand(MCOperand::CreateImm(0)); 22914b93851cc7611ae6c2000f1c162592ead954420Chris Lattner else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr)) 2303483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar Inst.addOperand(MCOperand::CreateImm(CE->getValue())); 2313483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar else 2323483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar Inst.addOperand(MCOperand::CreateExpr(Expr)); 2333483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar } 2343483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 2358462b30548fb5969250858036638c73c16b65b43Daniel Dunbar void addCondCodeOperands(MCInst &Inst, unsigned N) const { 236345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar assert(N == 2 && "Invalid number of operands!"); 2378462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode()))); 238345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // FIXME: What belongs here? 239345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Inst.addOperand(MCOperand::CreateReg(0)); 2408462b30548fb5969250858036638c73c16b65b43Daniel Dunbar } 2418462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 242a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby void addRegOperands(MCInst &Inst, unsigned N) const { 243a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby assert(N == 1 && "Invalid number of operands!"); 244a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Inst.addOperand(MCOperand::CreateReg(getReg())); 245a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 246a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 2473483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar void addImmOperands(MCInst &Inst, unsigned N) const { 2483483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar assert(N == 1 && "Invalid number of operands!"); 2493483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar addExpr(Inst, getImm()); 2503483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar } 25116c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 25214b93851cc7611ae6c2000f1c162592ead954420Chris Lattner bool isMemMode5() const { 25314b93851cc7611ae6c2000f1c162592ead954420Chris Lattner if (!isMemory() || Mem.OffsetIsReg || Mem.OffsetRegShifted || 25480eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach Mem.Writeback || Mem.Negative) 25514b93851cc7611ae6c2000f1c162592ead954420Chris Lattner return false; 25680eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // If there is an offset expression, make sure it's valid. 25780eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach if (!Mem.Offset) 25880eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach return true; 25980eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Mem.Offset); 26080eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach if (!CE) 26180eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach return false; 26280eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // The offset must be a multiple of 4 in the range 0-1020. 26380eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach int64_t Value = CE->getValue(); 26480eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach return ((Value & 0x3) == 0 && Value <= 1020 && Value >= -1020); 26514b93851cc7611ae6c2000f1c162592ead954420Chris Lattner } 26616c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 26714b93851cc7611ae6c2000f1c162592ead954420Chris Lattner void addMemMode5Operands(MCInst &Inst, unsigned N) const { 26814b93851cc7611ae6c2000f1c162592ead954420Chris Lattner assert(N == 2 && isMemMode5() && "Invalid number of operands!"); 26916c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 27014b93851cc7611ae6c2000f1c162592ead954420Chris Lattner Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum)); 271a60f157b7c6fb60b33598fa5143ed8cb91aa5107Bill Wendling assert(!Mem.OffsetIsReg && "Invalid mode 5 operand"); 27292b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling 27380eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // FIXME: #-0 is encoded differently than #0. Does the parser preserve 27480eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // the difference? 27580eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach if (Mem.Offset) { 27680eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Mem.Offset); 27792b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling assert(CE && "Non-constant mode 5 offset operand!"); 27892b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling 27980eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // The MCInst offset operand doesn't include the low two bits (like 28080eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // the instruction encoding). 28192b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling int64_t Offset = CE->getValue() / 4; 28292b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling if (Offset >= 0) 28392b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(ARM_AM::add, 28492b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling Offset))); 28592b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling else 28692b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(ARM_AM::sub, 28792b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling -Offset))); 28892b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling } else { 28980eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach Inst.addOperand(MCOperand::CreateImm(0)); 29092b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling } 29114b93851cc7611ae6c2000f1c162592ead954420Chris Lattner } 2923483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 293fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar virtual void dump(raw_ostream &OS) const; 294b3cb6967949493a2e1b10d015ac08b746736764eDaniel Dunbar 2953a69756e392942bc522193f38d7f33958ed3b131Chris Lattner static ARMOperand *CreateCondCode(ARMCC::CondCodes CC, SMLoc S) { 2963a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(CondCode); 297345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Op->CC.Val = CC; 298345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Op->StartLoc = S; 299345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Op->EndLoc = S; 3003a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 301345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar } 302345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 3033a69756e392942bc522193f38d7f33958ed3b131Chris Lattner static ARMOperand *CreateToken(StringRef Str, SMLoc S) { 3043a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(Token); 305762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Tok.Data = Str.data(); 306762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Tok.Length = Str.size(); 307762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->StartLoc = S; 308762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->EndLoc = S; 3093a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 310a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 311a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 3123a69756e392942bc522193f38d7f33958ed3b131Chris Lattner static ARMOperand *CreateReg(unsigned RegNum, bool Writeback, SMLoc S, 3133a69756e392942bc522193f38d7f33958ed3b131Chris Lattner SMLoc E) { 3143a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(Register); 315762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Reg.RegNum = RegNum; 316762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Reg.Writeback = Writeback; 317762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->StartLoc = S; 318762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->EndLoc = E; 3193a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 320a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 321a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 3228d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling static ARMOperand *CreateRegList(unsigned RegStart, unsigned Number, 3238d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling SMLoc S, SMLoc E) { 3248d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling ARMOperand *Op = new ARMOperand(RegisterList); 3258d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling Op->RegList.RegStart = RegStart; 3268d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling Op->RegList.Number = Number; 3278d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling Op->StartLoc = S; 3288d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling Op->EndLoc = E; 3298d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling return Op; 3308d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } 3318d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 3323a69756e392942bc522193f38d7f33958ed3b131Chris Lattner static ARMOperand *CreateImm(const MCExpr *Val, SMLoc S, SMLoc E) { 3333a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(Immediate); 334762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Imm.Val = Val; 335762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->StartLoc = S; 336762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->EndLoc = E; 3373a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 338cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby } 339cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby 3403a69756e392942bc522193f38d7f33958ed3b131Chris Lattner static ARMOperand *CreateMem(unsigned BaseRegNum, bool OffsetIsReg, 3413a69756e392942bc522193f38d7f33958ed3b131Chris Lattner const MCExpr *Offset, unsigned OffsetRegNum, 3423a69756e392942bc522193f38d7f33958ed3b131Chris Lattner bool OffsetRegShifted, enum ShiftType ShiftType, 3433a69756e392942bc522193f38d7f33958ed3b131Chris Lattner const MCExpr *ShiftAmount, bool Preindexed, 3443a69756e392942bc522193f38d7f33958ed3b131Chris Lattner bool Postindexed, bool Negative, bool Writeback, 3453a69756e392942bc522193f38d7f33958ed3b131Chris Lattner SMLoc S, SMLoc E) { 3463a69756e392942bc522193f38d7f33958ed3b131Chris Lattner ARMOperand *Op = new ARMOperand(Memory); 347762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.BaseRegNum = BaseRegNum; 348762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.OffsetIsReg = OffsetIsReg; 349762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.Offset = Offset; 350762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.OffsetRegNum = OffsetRegNum; 351762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.OffsetRegShifted = OffsetRegShifted; 352762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.ShiftType = ShiftType; 353762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.ShiftAmount = ShiftAmount; 354762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.Preindexed = Preindexed; 355762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.Postindexed = Postindexed; 356762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.Negative = Negative; 357762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->Mem.Writeback = Writeback; 35816c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 359762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->StartLoc = S; 360762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Op->EndLoc = E; 3613a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return Op; 362a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 363a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby}; 364a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 365a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} // end anonymous namespace. 366a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 367fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbarvoid ARMOperand::dump(raw_ostream &OS) const { 368fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar switch (Kind) { 369fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case CondCode: 370fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar OS << ARMCondCodeToString(getCondCode()); 371fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 372fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case Immediate: 373fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar getImm()->print(OS); 374fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 375fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case Memory: 376fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar OS << "<memory>"; 377fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 378fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case Register: 379fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar OS << "<register " << getReg() << ">"; 380fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 3818d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling case RegisterList: { 3828d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling OS << "<register_list "; 3838d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling std::pair<unsigned, unsigned> List = getRegList(); 3848d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling unsigned RegEnd = List.first + List.second; 3858d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 3868d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling for (unsigned Idx = List.first; Idx < RegEnd; ) { 3878d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling OS << Idx; 3888d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling if (++Idx < RegEnd) OS << ", "; 3898d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } 3908d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 3918d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling OS << ">"; 3928d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling break; 3938d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } 394fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar case Token: 395fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar OS << "'" << getToken() << "'"; 396fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar break; 397fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar } 398fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar} 3993483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 4003483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar/// @name Auto-generated Match Functions 4013483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar/// { 4023483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 4033483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbarstatic unsigned MatchRegisterName(StringRef Name); 4043483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 4053483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar/// } 4063483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 4079c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Try to parse a register name. The token must be an Identifier when called, 408e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// and if it is a register name the token is eaten and the register number is 409e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// returned. Otherwise return -1. 4103a69756e392942bc522193f38d7f33958ed3b131Chris Lattner/// 411e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattnerint ARMAsmParser::TryParseRegister() { 41218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 413a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier"); 414d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach 415a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // FIXME: Validate register for the current architecture; we have to do 416a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // validation later, so maybe there is no need for this here. 417d68fd9c79eeb30980c18dc3f74b2da839bb259f3Bill Wendling unsigned RegNum = MatchRegisterName(Tok.getString()); 418d68fd9c79eeb30980c18dc3f74b2da839bb259f3Bill Wendling if (RegNum == 0) 419e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner return -1; 420b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat identifier token. 421e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner return RegNum; 422e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner} 423d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach 424d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach 425e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// Try to parse a register name. The token must be an Identifier when called, 426e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// and if it is a register name the token is eaten and the register number is 427e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// returned. Otherwise return -1. 428e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// 429e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// TODO this is likely to change to allow different register types and or to 430e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner/// parse for a specific register type. 431e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris LattnerARMOperand *ARMAsmParser::TryParseRegisterWithWriteBack() { 432e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner SMLoc S = Parser.getTok().getLoc(); 433e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner int RegNo = TryParseRegister(); 434e717610f53e0465cde198536561a3c00ce29d59fBill Wendling if (RegNo == -1) 435e717610f53e0465cde198536561a3c00ce29d59fBill Wendling return 0; 436d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach 437e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner SMLoc E = Parser.getTok().getLoc(); 438a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 43999e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby bool Writeback = false; 440e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner const AsmToken &ExclaimTok = Parser.getTok(); 441e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner if (ExclaimTok.is(AsmToken::Exclaim)) { 442e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner E = ExclaimTok.getLoc(); 443e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner Writeback = true; 444e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner Parser.Lex(); // Eat exclaim token 44599e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby } 44699e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby 447e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner return ARMOperand::CreateReg(RegNo, Writeback, S, E); 448a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 449a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 450c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner/// Parse a register list, return it if successful else return null. The first 451c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner/// token must be a '{' when called. 452c0ddfaa134fe60c09686906b3a8f489531653453Chris LattnerARMOperand *ARMAsmParser::ParseRegisterList() { 45318b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan assert(Parser.getTok().is(AsmToken::LCurly) && 454a60f157b7c6fb60b33598fa5143ed8cb91aa5107Bill Wendling "Token is not a Left Curly Brace"); 455e717610f53e0465cde198536561a3c00ce29d59fBill Wendling SMLoc S = Parser.getTok().getLoc(); 456b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat left curly brace token. 457d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 45818b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &RegTok = Parser.getTok(); 459d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby SMLoc RegLoc = RegTok.getLoc(); 460c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner if (RegTok.isNot(AsmToken::Identifier)) { 461c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner Error(RegLoc, "register expected"); 462c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner return 0; 463c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner } 464e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 4651d6a26507bfd75758f5c8a29bccf577784ead751Bill Wendling int RegNum = TryParseRegister(); 466c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner if (RegNum == -1) { 467c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner Error(RegLoc, "register expected"); 468c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner return 0; 469c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner } 47016c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 471e717610f53e0465cde198536561a3c00ce29d59fBill Wendling unsigned PrevRegNum = RegNum; 472e717610f53e0465cde198536561a3c00ce29d59fBill Wendling std::vector<std::pair<unsigned, SMLoc> > Registers; 473e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Registers.reserve(32); 474e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Registers.push_back(std::make_pair(RegNum, RegLoc)); 475d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 476e717610f53e0465cde198536561a3c00ce29d59fBill Wendling while (Parser.getTok().is(AsmToken::Comma) || 477e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Parser.getTok().is(AsmToken::Minus)) { 478e717610f53e0465cde198536561a3c00ce29d59fBill Wendling bool IsRange = Parser.getTok().is(AsmToken::Minus); 479e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Parser.Lex(); // Eat comma or minus token. 480d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 48118b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &RegTok = Parser.getTok(); 482d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby SMLoc RegLoc = RegTok.getLoc(); 483c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner if (RegTok.isNot(AsmToken::Identifier)) { 484c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner Error(RegLoc, "register expected"); 485c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner return 0; 486c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner } 487e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 4881d6a26507bfd75758f5c8a29bccf577784ead751Bill Wendling int RegNum = TryParseRegister(); 489c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner if (RegNum == -1) { 490c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner Error(RegLoc, "register expected"); 491c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner return 0; 492c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner } 493d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 494e717610f53e0465cde198536561a3c00ce29d59fBill Wendling if (IsRange) { 495e717610f53e0465cde198536561a3c00ce29d59fBill Wendling int Reg = PrevRegNum; 496e717610f53e0465cde198536561a3c00ce29d59fBill Wendling do { 497e717610f53e0465cde198536561a3c00ce29d59fBill Wendling ++Reg; 498e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Registers.push_back(std::make_pair(Reg, RegLoc)); 499e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } while (Reg != RegNum); 500e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } else { 501e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Registers.push_back(std::make_pair(RegNum, RegLoc)); 502e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } 503e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 504e717610f53e0465cde198536561a3c00ce29d59fBill Wendling PrevRegNum = RegNum; 505d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby } 506e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 507e717610f53e0465cde198536561a3c00ce29d59fBill Wendling // Process the right curly brace of the list. 50818b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &RCurlyTok = Parser.getTok(); 509c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner if (RCurlyTok.isNot(AsmToken::RCurly)) { 510c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner Error(RCurlyTok.getLoc(), "'}' expected"); 511c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner return 0; 512c0ddfaa134fe60c09686906b3a8f489531653453Chris Lattner } 513d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 514e717610f53e0465cde198536561a3c00ce29d59fBill Wendling SMLoc E = RCurlyTok.getLoc(); 515e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Parser.Lex(); // Eat right curly brace token. 516e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 517e717610f53e0465cde198536561a3c00ce29d59fBill Wendling // Verify the register list. 518e717610f53e0465cde198536561a3c00ce29d59fBill Wendling std::vector<std::pair<unsigned, SMLoc> >::iterator 519e717610f53e0465cde198536561a3c00ce29d59fBill Wendling RI = Registers.begin(), RE = Registers.end(); 520e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 521e717610f53e0465cde198536561a3c00ce29d59fBill Wendling unsigned Number = Registers.size(); 522e717610f53e0465cde198536561a3c00ce29d59fBill Wendling unsigned HighRegNum = RI->first; 523e717610f53e0465cde198536561a3c00ce29d59fBill Wendling unsigned RegStart = RI->first; 524e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 525e717610f53e0465cde198536561a3c00ce29d59fBill Wendling DenseMap<unsigned, bool> RegMap; 526e717610f53e0465cde198536561a3c00ce29d59fBill Wendling RegMap[RI->first] = true; 527e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 528e717610f53e0465cde198536561a3c00ce29d59fBill Wendling for (++RI; RI != RE; ++RI) { 529e717610f53e0465cde198536561a3c00ce29d59fBill Wendling std::pair<unsigned, SMLoc> &RegInfo = *RI; 530e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 531e717610f53e0465cde198536561a3c00ce29d59fBill Wendling if (RegMap[RegInfo.first]) { 532e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Error(RegInfo.second, "register duplicated in register list"); 533e717610f53e0465cde198536561a3c00ce29d59fBill Wendling return 0; 534e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } 535e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 536e717610f53e0465cde198536561a3c00ce29d59fBill Wendling if (RegInfo.first < HighRegNum) 537e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Warning(RegInfo.second, 538e717610f53e0465cde198536561a3c00ce29d59fBill Wendling "register not in ascending order in register list"); 539e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 540e717610f53e0465cde198536561a3c00ce29d59fBill Wendling RegMap[RegInfo.first] = true; 541e717610f53e0465cde198536561a3c00ce29d59fBill Wendling HighRegNum = std::max(RegInfo.first, HighRegNum); 542e717610f53e0465cde198536561a3c00ce29d59fBill Wendling RegStart = std::min(RegInfo.first, RegStart); 543e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } 544e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 545e717610f53e0465cde198536561a3c00ce29d59fBill Wendling if (RegStart + Number - 1 != HighRegNum) { 546e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Error(RegLoc, "non-contiguous register range"); 547e717610f53e0465cde198536561a3c00ce29d59fBill Wendling return 0; 548e717610f53e0465cde198536561a3c00ce29d59fBill Wendling } 549e717610f53e0465cde198536561a3c00ce29d59fBill Wendling 550e717610f53e0465cde198536561a3c00ce29d59fBill Wendling return ARMOperand::CreateRegList(RegStart, Number, S, E); 551d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby} 552d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 553e717610f53e0465cde198536561a3c00ce29d59fBill Wendling/// Parse an ARM memory expression, return false if successful else return true 5549c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// or an error. The first token must be a '[' when called. 5559c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// TODO Only preindexing and postindexing addressing are started, unindexed 5569c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// with option, etc are still to do. 557550276ee5bb3e115d4d81156dceffb9d3d78823aChris LattnerARMOperand *ARMAsmParser::ParseMemory() { 558762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc S, E; 55918b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan assert(Parser.getTok().is(AsmToken::LBrac) && 560a60f157b7c6fb60b33598fa5143ed8cb91aa5107Bill Wendling "Token is not a Left Bracket"); 561762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan S = Parser.getTok().getLoc(); 562b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat left bracket token. 563a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 56418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &BaseRegTok = Parser.getTok(); 565550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (BaseRegTok.isNot(AsmToken::Identifier)) { 566550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Error(BaseRegTok.getLoc(), "register expected"); 567550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return 0; 568550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner } 569e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner int BaseRegNum = TryParseRegister(); 570e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner if (BaseRegNum == -1) { 571550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Error(BaseRegTok.getLoc(), "register expected"); 572550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return 0; 573550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner } 574a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 575a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool Preindexed = false; 576a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool Postindexed = false; 577a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool OffsetIsReg = false; 578a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool Negative = false; 579a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool Writeback = false; 580a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 5819c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // First look for preindexed address forms, that is after the "[Rn" we now 5829c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // have to see if the next token is a comma. 58318b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 584a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (Tok.is(AsmToken::Comma)) { 585a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Preindexed = true; 586b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat comma token. 5879c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby int OffsetRegNum; 5889c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool OffsetRegShifted; 589a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby enum ShiftType ShiftType; 590a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby const MCExpr *ShiftAmount; 591a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby const MCExpr *Offset; 592550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (ParseMemoryOffsetReg(Negative, OffsetRegShifted, ShiftType, ShiftAmount, 593550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Offset, OffsetIsReg, OffsetRegNum, E)) 594550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return 0; 59518b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &RBracTok = Parser.getTok(); 596550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (RBracTok.isNot(AsmToken::RBrac)) { 597550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Error(RBracTok.getLoc(), "']' expected"); 598550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return 0; 599550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner } 600762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = RBracTok.getLoc(); 601b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat right bracket token. 602a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 60318b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &ExclaimTok = Parser.getTok(); 604a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (ExclaimTok.is(AsmToken::Exclaim)) { 605762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = ExclaimTok.getLoc(); 606a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Writeback = true; 607b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat exclaim token 608a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 609550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return ARMOperand::CreateMem(BaseRegNum, OffsetIsReg, Offset, OffsetRegNum, 610550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner OffsetRegShifted, ShiftType, ShiftAmount, 611550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Preindexed, Postindexed, Negative, Writeback, 612550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner S, E); 613a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 614a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // The "[Rn" we have so far was not followed by a comma. 615a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else if (Tok.is(AsmToken::RBrac)) { 61680eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // If there's anything other than the right brace, this is a post indexing 61780eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach // addressing form. 618762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = Tok.getLoc(); 619b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat right bracket token. 620a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 621e2a98dd2a4f007d5d9d3c71460cfbe0a825b8993Kevin Enderby int OffsetRegNum = 0; 622a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool OffsetRegShifted = false; 623a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby enum ShiftType ShiftType; 624a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby const MCExpr *ShiftAmount; 62514b93851cc7611ae6c2000f1c162592ead954420Chris Lattner const MCExpr *Offset = 0; 626a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 62718b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &NextTok = Parser.getTok(); 628e2a98dd2a4f007d5d9d3c71460cfbe0a825b8993Kevin Enderby if (NextTok.isNot(AsmToken::EndOfStatement)) { 62980eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach Postindexed = true; 63080eb233a3ce1a6f2e6c0847cb3e456d735e37569Jim Grosbach Writeback = true; 631550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (NextTok.isNot(AsmToken::Comma)) { 632550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Error(NextTok.getLoc(), "',' expected"); 633550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return 0; 634550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner } 635b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat comma token. 636550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (ParseMemoryOffsetReg(Negative, OffsetRegShifted, ShiftType, 63716c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach ShiftAmount, Offset, OffsetIsReg, OffsetRegNum, 638550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner E)) 639550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return 0; 640a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 641e2a98dd2a4f007d5d9d3c71460cfbe0a825b8993Kevin Enderby 642550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return ARMOperand::CreateMem(BaseRegNum, OffsetIsReg, Offset, OffsetRegNum, 643550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner OffsetRegShifted, ShiftType, ShiftAmount, 644550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Preindexed, Postindexed, Negative, Writeback, 645550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner S, E); 646a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 647a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 648550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return 0; 649a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 650a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 6519c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Parse the offset of a memory operand after we have seen "[Rn," or "[Rn]," 6529c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// we will parse the following (were +/- means that a plus or minus is 6539c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// optional): 6549c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// +/-Rm 6559c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// +/-Rm, shift 6569c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// #offset 6579c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// we return false on success or an error otherwise. 6589c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderbybool ARMAsmParser::ParseMemoryOffsetReg(bool &Negative, 659762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan bool &OffsetRegShifted, 6609c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby enum ShiftType &ShiftType, 6619c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const MCExpr *&ShiftAmount, 6629c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const MCExpr *&Offset, 6639c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool &OffsetIsReg, 664762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan int &OffsetRegNum, 665762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc &E) { 6669c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Negative = false; 6679c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby OffsetRegShifted = false; 6689c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby OffsetIsReg = false; 6699c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby OffsetRegNum = -1; 67018b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &NextTok = Parser.getTok(); 671762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = NextTok.getLoc(); 6729c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (NextTok.is(AsmToken::Plus)) 673b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat plus token. 6749c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby else if (NextTok.is(AsmToken::Minus)) { 6759c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Negative = true; 676b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat minus token 6779c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 6789c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // See if there is a register following the "[Rn," or "[Rn]," we have so far. 67918b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &OffsetRegTok = Parser.getTok(); 6809c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (OffsetRegTok.is(AsmToken::Identifier)) { 681e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner SMLoc CurLoc = OffsetRegTok.getLoc(); 682e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner OffsetRegNum = TryParseRegister(); 683e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner if (OffsetRegNum != -1) { 684550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner OffsetIsReg = true; 685e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner E = CurLoc; 686762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 6879c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 688d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach 68912f40e9a6305fe7553ebce19346cb55874073fc7Bill Wendling // If we parsed a register as the offset then there can be a shift after that. 6909c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (OffsetRegNum != -1) { 6919c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Look for a comma then a shift 69218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 6939c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (Tok.is(AsmToken::Comma)) { 694b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat comma token. 6959c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 69618b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 697762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (ParseShift(ShiftType, ShiftAmount, E)) 6983472766f9eb7d66f234c390ce1b3a8b76f0ee9ceDuncan Sands return Error(Tok.getLoc(), "shift expected"); 6999c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby OffsetRegShifted = true; 7009c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 7019c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 7029c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby else { // the "[Rn," or "[Rn,]" we have so far was not followed by "Rm" 7039c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Look for #offset following the "[Rn," or "[Rn]," 70418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &HashTok = Parser.getTok(); 7059c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (HashTok.isNot(AsmToken::Hash)) 7069c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return Error(HashTok.getLoc(), "'#' expected"); 70716c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 708b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat hash token. 7099c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 7109c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (getParser().ParseExpression(Offset)) 7119c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return true; 712762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 7139c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 7149c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return false; 7159c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby} 7169c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 717a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// ParseShift as one of these two: 718a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// ( lsl | lsr | asr | ror ) , # shift_amount 719a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// rrx 720a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// and returns true if it parses a shift otherwise it returns false. 72116c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbachbool ARMAsmParser::ParseShift(ShiftType &St, const MCExpr *&ShiftAmount, 722762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc &E) { 72318b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 724a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (Tok.isNot(AsmToken::Identifier)) 725a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return true; 72638e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramer StringRef ShiftName = Tok.getString(); 727a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (ShiftName == "lsl" || ShiftName == "LSL") 7289c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby St = Lsl; 729a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else if (ShiftName == "lsr" || ShiftName == "LSR") 7309c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby St = Lsr; 731a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else if (ShiftName == "asr" || ShiftName == "ASR") 7329c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby St = Asr; 733a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else if (ShiftName == "ror" || ShiftName == "ROR") 7349c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby St = Ror; 735a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else if (ShiftName == "rrx" || ShiftName == "RRX") 7369c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby St = Rrx; 737a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby else 738a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return true; 739b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat shift type token. 740a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 7419c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Rrx stands alone. 7429c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (St == Rrx) 7439c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return false; 744a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 7459c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Otherwise, there must be a '#' and a shift amount. 74618b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &HashTok = Parser.getTok(); 7479c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (HashTok.isNot(AsmToken::Hash)) 7489c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return Error(HashTok.getLoc(), "'#' expected"); 749b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat hash token. 7509c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 7519c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (getParser().ParseExpression(ShiftAmount)) 7529c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return true; 753a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 754a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return false; 755a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 756a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 7579c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Parse a arm instruction operand. For now this parses the operand regardless 7589c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// of the mnemonic. 759550276ee5bb3e115d4d81156dceffb9d3d78823aChris LattnerARMOperand *ARMAsmParser::ParseOperand() { 760762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan SMLoc S, E; 761a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby switch (getLexer().getKind()) { 762146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling default: 763146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling Error(Parser.getTok().getLoc(), "unexpected token in operand"); 764146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling return 0; 765a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby case AsmToken::Identifier: 766e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner if (ARMOperand *Op = TryParseRegisterWithWriteBack()) 767550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return Op; 76816c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 769515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // This was not a register so parse other operands that start with an 770515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // identifier (like labels) as expressions and create them as immediates. 771515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby const MCExpr *IdVal; 772762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan S = Parser.getTok().getLoc(); 773515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getParser().ParseExpression(IdVal)) 774550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return 0; 775762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 776550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return ARMOperand::CreateImm(IdVal, S, E); 777a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby case AsmToken::LBrac: 778550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return ParseMemory(); 779d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby case AsmToken::LCurly: 780550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return ParseRegisterList(); 781d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby case AsmToken::Hash: 782079469f649d8da3923b9f747d7062c84e01cc4aeKevin Enderby // #42 -> immediate. 783079469f649d8da3923b9f747d7062c84e01cc4aeKevin Enderby // TODO: ":lower16:" and ":upper16:" modifiers after # before immediate 784762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan S = Parser.getTok().getLoc(); 785b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 786515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby const MCExpr *ImmVal; 787515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getParser().ParseExpression(ImmVal)) 788550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return 0; 789762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1); 790550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner return ARMOperand::CreateImm(ImmVal, S, E); 791a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 792a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 793a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 7949c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Parse an arm instruction mnemonic followed by its operands. 79538e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramerbool ARMAsmParser::ParseInstruction(StringRef Name, SMLoc NameLoc, 7969898671a74d3fc924347e679c45edaa685b3fe6eChris Lattner SmallVectorImpl<MCParsedAsmOperand*> &Operands) { 7975747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar // Create the leading tokens for the mnemonic, split by '.' characters. 7985747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar size_t Start = 0, Next = Name.find('.'); 7995747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar StringRef Head = Name.slice(Start, Next); 8005747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar 801345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // Determine the predicate, if any. 802345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // 803345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // FIXME: We need a way to check whether a prefix supports predication, 804345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // otherwise we will end up with an ambiguity for instructions that happen to 805345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // end with a predicate name. 8063df518e67edaf358154af394cc99d21435b7b118Jim Grosbach // FIXME: Likewise, some arithmetic instructions have an 's' prefix which 8073df518e67edaf358154af394cc99d21435b7b118Jim Grosbach // indicates to update the condition codes. Those instructions have an 8083df518e67edaf358154af394cc99d21435b7b118Jim Grosbach // additional immediate operand which encodes the prefix as reg0 or CPSR. 8093df518e67edaf358154af394cc99d21435b7b118Jim Grosbach // Just checking for a suffix of 's' definitely creates ambiguities; e.g, 8103df518e67edaf358154af394cc99d21435b7b118Jim Grosbach // the SMMLS instruction. 811345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar unsigned CC = StringSwitch<unsigned>(Head.substr(Head.size()-2)) 812345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("eq", ARMCC::EQ) 813345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("ne", ARMCC::NE) 814345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("hs", ARMCC::HS) 815345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("lo", ARMCC::LO) 816345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("mi", ARMCC::MI) 817345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("pl", ARMCC::PL) 818345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("vs", ARMCC::VS) 819345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("vc", ARMCC::VC) 820345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("hi", ARMCC::HI) 821345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("ls", ARMCC::LS) 822345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("ge", ARMCC::GE) 823345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("lt", ARMCC::LT) 824345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("gt", ARMCC::GT) 825345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("le", ARMCC::LE) 826345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Case("al", ARMCC::AL) 827345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar .Default(~0U); 82816c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 829dba34d874d0ac8c334f03d770b80c6ee2f12808aChris Lattner if (CC == ~0U || 830dba34d874d0ac8c334f03d770b80c6ee2f12808aChris Lattner (CC == ARMCC::LS && (Head == "vmls" || Head == "vnmls"))) { 831345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar CC = ARMCC::AL; 832dba34d874d0ac8c334f03d770b80c6ee2f12808aChris Lattner } else { 833dba34d874d0ac8c334f03d770b80c6ee2f12808aChris Lattner Head = Head.slice(0, Head.size() - 2); 83452925b60f1cd4cf810524ca05b00a207a926ab9fBill Wendling } 835345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 8363a69756e392942bc522193f38d7f33958ed3b131Chris Lattner Operands.push_back(ARMOperand::CreateToken(Head, NameLoc)); 837469ebbe148b18a78963e8bc3fa7ae8e5700d8d27Jim Grosbach // FIXME: Should only add this operand for predicated instructions 8383a69756e392942bc522193f38d7f33958ed3b131Chris Lattner Operands.push_back(ARMOperand::CreateCondCode(ARMCC::CondCodes(CC), NameLoc)); 839345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 840345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // Add the remaining tokens in the mnemonic. 8415747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar while (Next != StringRef::npos) { 8425747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar Start = Next; 8435747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar Next = Name.find('.', Start + 1); 8445747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar Head = Name.slice(Start, Next); 845a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 8463a69756e392942bc522193f38d7f33958ed3b131Chris Lattner Operands.push_back(ARMOperand::CreateToken(Head, NameLoc)); 8475747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar } 8485747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar 8495747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar // Read the remaining operands. 8505747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar if (getLexer().isNot(AsmToken::EndOfStatement)) { 851a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Read the first operand. 852550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (ARMOperand *Op = ParseOperand()) 853550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Operands.push_back(Op); 854550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner else { 855cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner Parser.EatToEndOfStatement(); 856cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner return true; 857cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner } 858a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 859a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby while (getLexer().is(AsmToken::Comma)) { 860b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Eat the comma. 861a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 862a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Parse and remember the operand. 863550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner if (ARMOperand *Op = ParseOperand()) 864550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner Operands.push_back(Op); 865550276ee5bb3e115d4d81156dceffb9d3d78823aChris Lattner else { 866cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner Parser.EatToEndOfStatement(); 867cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner return true; 868cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner } 869a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 870a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 87116c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 872cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner if (getLexer().isNot(AsmToken::EndOfStatement)) { 873cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner Parser.EatToEndOfStatement(); 87434e53140c2cc02ce4c9d060e48302576d3962e1cChris Lattner return TokError("unexpected token in argument list"); 875cbf8a98c7c652e96967623c80cb945fef001b090Chris Lattner } 876146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling 87734e53140c2cc02ce4c9d060e48302576d3962e1cChris Lattner Parser.Lex(); // Consume the EndOfStatement 8789898671a74d3fc924347e679c45edaa685b3fe6eChris Lattner return false; 879ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 880ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 881fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattnerbool ARMAsmParser:: 882fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris LattnerMatchAndEmitInstruction(SMLoc IDLoc, 883fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner SmallVectorImpl<MCParsedAsmOperand*> &Operands, 884fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner MCStreamer &Out) { 885fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner MCInst Inst; 886fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner unsigned ErrorInfo; 887e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner switch (MatchInstructionImpl(Operands, Inst, ErrorInfo)) { 888e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner case Match_Success: 889fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner Out.EmitInstruction(Inst); 890fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner return false; 891e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner case Match_MissingFeature: 892e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner Error(IDLoc, "instruction requires a CPU feature not currently enabled"); 893e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner return true; 894e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner case Match_InvalidOperand: { 895e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner SMLoc ErrorLoc = IDLoc; 896e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner if (ErrorInfo != ~0U) { 897e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner if (ErrorInfo >= Operands.size()) 898e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner return Error(IDLoc, "too few operands for instruction"); 89916c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 900e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner ErrorLoc = ((ARMOperand*)Operands[ErrorInfo])->getStartLoc(); 901e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc; 902e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner } 90316c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 904e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner return Error(ErrorLoc, "invalid operand for instruction"); 905e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner } 906e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner case Match_MnemonicFail: 907e73d4f8ec7af68fc0f67811e4e004562ab538014Chris Lattner return Error(IDLoc, "unrecognized instruction mnemonic"); 908fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner } 90916c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 910c223e2b10b4753a63dfe7e6980c650b179139983Eric Christopher llvm_unreachable("Implement any new match types added!"); 911146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling return true; 912fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner} 913fa42fad8bf7b0058ba031a275e1e8ce53b2cb1adChris Lattner 914515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ParseDirective parses the arm specific directives 915ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbybool ARMAsmParser::ParseDirective(AsmToken DirectiveID) { 916ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby StringRef IDVal = DirectiveID.getIdentifier(); 917ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (IDVal == ".word") 918ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return ParseDirectiveWord(4, DirectiveID.getLoc()); 919515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else if (IDVal == ".thumb") 920515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return ParseDirectiveThumb(DirectiveID.getLoc()); 921515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else if (IDVal == ".thumb_func") 922515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return ParseDirectiveThumbFunc(DirectiveID.getLoc()); 923515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else if (IDVal == ".code") 924515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return ParseDirectiveCode(DirectiveID.getLoc()); 925515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else if (IDVal == ".syntax") 926515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return ParseDirectiveSyntax(DirectiveID.getLoc()); 927ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return true; 928ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 929ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 930ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby/// ParseDirectiveWord 931ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby/// ::= .word [ expression (, expression)* ] 932ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbybool ARMAsmParser::ParseDirectiveWord(unsigned Size, SMLoc L) { 933ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) { 934ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby for (;;) { 935ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby const MCExpr *Value; 936ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (getParser().ParseExpression(Value)) 937ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return true; 938ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 939aaec205b87637cd0d59d4f11630db603686eb73dChris Lattner getParser().getStreamer().EmitValue(Value, Size, 0/*addrspace*/); 940ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 941ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (getLexer().is(AsmToken::EndOfStatement)) 942ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby break; 94316c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 944ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // FIXME: Improve diagnostic. 945ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (getLexer().isNot(AsmToken::Comma)) 946ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return Error(L, "unexpected token in directive"); 947b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 948ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby } 949ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby } 950ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 951b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 952ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return false; 953ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 954ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 955515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ParseDirectiveThumb 956515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ::= .thumb 957515d509360d81946247fd0f937034cdf1f237c72Kevin Enderbybool ARMAsmParser::ParseDirectiveThumb(SMLoc L) { 958515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) 959515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unexpected token in directive"); 960b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 961515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 962515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // TODO: set thumb mode 963515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // TODO: tell the MC streamer the mode 964515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // getParser().getStreamer().Emit???(); 965515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return false; 966515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby} 967515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 968515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ParseDirectiveThumbFunc 969515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ::= .thumbfunc symbol_name 970515d509360d81946247fd0f937034cdf1f237c72Kevin Enderbybool ARMAsmParser::ParseDirectiveThumbFunc(SMLoc L) { 97118b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 972515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (Tok.isNot(AsmToken::Identifier) && Tok.isNot(AsmToken::String)) 97383c4018fcca18fe9c281c3943fc58a17621636c4Jim Grosbach return Error(L, "unexpected token in .thumb_func directive"); 974642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach StringRef Name = Tok.getString(); 975b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); // Consume the identifier token. 976515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) 977515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unexpected token in directive"); 978b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 979515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 980642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach // Mark symbol as a thumb symbol. 981642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach MCSymbol *Func = getParser().getContext().GetOrCreateSymbol(Name); 982642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach getParser().getStreamer().EmitThumbFunc(Func); 983515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return false; 984515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby} 985515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 986515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ParseDirectiveSyntax 987515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ::= .syntax unified | divided 988515d509360d81946247fd0f937034cdf1f237c72Kevin Enderbybool ARMAsmParser::ParseDirectiveSyntax(SMLoc L) { 98918b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 990515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (Tok.isNot(AsmToken::Identifier)) 991515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unexpected token in .syntax directive"); 99238e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramer StringRef Mode = Tok.getString(); 99358c86910b31c569a5709466c82e2fabae2014a56Duncan Sands if (Mode == "unified" || Mode == "UNIFIED") 994b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 99558c86910b31c569a5709466c82e2fabae2014a56Duncan Sands else if (Mode == "divided" || Mode == "DIVIDED") 996b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 997515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else 998515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unrecognized syntax mode in .syntax directive"); 999515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 1000515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) 100118b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan return Error(Parser.getTok().getLoc(), "unexpected token in directive"); 1002b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 1003515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 1004515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // TODO tell the MC streamer the mode 1005515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // getParser().getStreamer().Emit???(); 1006515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return false; 1007515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby} 1008515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 1009515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ParseDirectiveCode 1010515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// ::= .code 16 | 32 1011515d509360d81946247fd0f937034cdf1f237c72Kevin Enderbybool ARMAsmParser::ParseDirectiveCode(SMLoc L) { 101218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan const AsmToken &Tok = Parser.getTok(); 1013515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (Tok.isNot(AsmToken::Integer)) 1014515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "unexpected token in .code directive"); 101518b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan int64_t Val = Parser.getTok().getIntVal(); 101658c86910b31c569a5709466c82e2fabae2014a56Duncan Sands if (Val == 16) 1017b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 101858c86910b31c569a5709466c82e2fabae2014a56Duncan Sands else if (Val == 32) 1019b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 1020515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby else 1021515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Error(L, "invalid operand to .code directive"); 1022515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 1023515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getLexer().isNot(AsmToken::EndOfStatement)) 102418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan return Error(Parser.getTok().getLoc(), "unexpected token in directive"); 1025b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Parser.Lex(); 1026515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 10272a301704ea76535f0485d5c3b75664b323249bdbJim Grosbach if (Val == 16) 10282a301704ea76535f0485d5c3b75664b323249bdbJim Grosbach getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16); 10292a301704ea76535f0485d5c3b75664b323249bdbJim Grosbach else 10302a301704ea76535f0485d5c3b75664b323249bdbJim Grosbach getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32); 10312a301704ea76535f0485d5c3b75664b323249bdbJim Grosbach 1032515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return false; 1033515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby} 1034515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 103590b7097f92f6b4f6b27cd88c7c88a21b777f5795Sean Callananextern "C" void LLVMInitializeARMAsmLexer(); 103690b7097f92f6b4f6b27cd88c7c88a21b777f5795Sean Callanan 10379c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Force static initialization. 1038ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbyextern "C" void LLVMInitializeARMAsmParser() { 1039ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby RegisterAsmParser<ARMAsmParser> X(TheARMTarget); 1040ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby RegisterAsmParser<ARMAsmParser> Y(TheThumbTarget); 104190b7097f92f6b4f6b27cd88c7c88a21b777f5795Sean Callanan LLVMInitializeARMAsmLexer(); 1042ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 10433483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 10440692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner#define GET_REGISTER_MATCHER 10450692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner#define GET_MATCHER_IMPLEMENTATION 10463483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar#include "ARMGenAsmMatcher.inc" 1047