MCTargetAsmParser.h revision efcb3d9c1cd9410949b4005fbe6f2817f8dfe395
1//===-- llvm/MC/MCTargetAsmParser.h - Target Assembly Parser ----*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef LLVM_MC_TARGETPARSER_H 11#define LLVM_MC_TARGETPARSER_H 12 13#include "llvm/MC/MCParser/MCAsmParserExtension.h" 14 15namespace llvm { 16class MCStreamer; 17class StringRef; 18class SMLoc; 19class AsmToken; 20class MCParsedAsmOperand; 21class MCInst; 22template <typename T> class SmallVectorImpl; 23 24enum AsmRewriteKind { 25 AOK_DotOperator, // Rewrite a dot operator expression as an immediate. 26 // E.g., [eax].foo.bar -> [eax].8 27 AOK_Emit, // Rewrite _emit as .byte. 28 AOK_Imm, // Rewrite as $$N. 29 AOK_ImmPrefix, // Add $$ before a parsed Imm. 30 AOK_Input, // Rewrite in terms of $N. 31 AOK_Output, // Rewrite in terms of $N. 32 AOK_SizeDirective, // Add a sizing directive (e.g., dword ptr). 33 AOK_Skip // Skip emission (e.g., offset/type operators). 34}; 35 36struct AsmRewrite { 37 AsmRewriteKind Kind; 38 SMLoc Loc; 39 unsigned Len; 40 unsigned Val; 41public: 42 AsmRewrite(AsmRewriteKind kind, SMLoc loc, unsigned len = 0, unsigned val = 0) 43 : Kind(kind), Loc(loc), Len(len), Val(val) {} 44}; 45 46struct ParseInstructionInfo { 47 48 SmallVectorImpl<AsmRewrite> *AsmRewrites; 49 50 ParseInstructionInfo() : AsmRewrites(0) {} 51 ParseInstructionInfo(SmallVectorImpl<AsmRewrite> *rewrites) 52 : AsmRewrites(rewrites) {} 53 54 ~ParseInstructionInfo() {} 55}; 56 57/// MCTargetAsmParser - Generic interface to target specific assembly parsers. 58class MCTargetAsmParser : public MCAsmParserExtension { 59public: 60 enum MatchResultTy { 61 Match_InvalidOperand, 62 Match_MissingFeature, 63 Match_MnemonicFail, 64 Match_Success, 65 FIRST_TARGET_MATCH_RESULT_TY 66 }; 67 68private: 69 MCTargetAsmParser(const MCTargetAsmParser &) LLVM_DELETED_FUNCTION; 70 void operator=(const MCTargetAsmParser &) LLVM_DELETED_FUNCTION; 71protected: // Can only create subclasses. 72 MCTargetAsmParser(); 73 74 /// AvailableFeatures - The current set of available features. 75 unsigned AvailableFeatures; 76 77 /// ParsingInlineAsm - Are we parsing ms-style inline assembly? 78 bool ParsingInlineAsm; 79 80 /// SemaCallback - The Sema callback implementation. Must be set when parsing 81 /// ms-style inline assembly. 82 MCAsmParserSemaCallback *SemaCallback; 83 84public: 85 virtual ~MCTargetAsmParser(); 86 87 unsigned getAvailableFeatures() const { return AvailableFeatures; } 88 void setAvailableFeatures(unsigned Value) { AvailableFeatures = Value; } 89 90 bool isParsingInlineAsm () { return ParsingInlineAsm; } 91 void setParsingInlineAsm (bool Value) { ParsingInlineAsm = Value; } 92 93 void setSemaCallback(MCAsmParserSemaCallback *Callback) { 94 SemaCallback = Callback; 95 } 96 97 virtual bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, 98 SMLoc &EndLoc) = 0; 99 100 /// ParseInstruction - Parse one assembly instruction. 101 /// 102 /// The parser is positioned following the instruction name. The target 103 /// specific instruction parser should parse the entire instruction and 104 /// construct the appropriate MCInst, or emit an error. On success, the entire 105 /// line should be parsed up to and including the end-of-statement token. On 106 /// failure, the parser is not required to read to the end of the line. 107 // 108 /// \param Name - The instruction name. 109 /// \param NameLoc - The source location of the name. 110 /// \param Operands [out] - The list of parsed operands, this returns 111 /// ownership of them to the caller. 112 /// \return True on failure. 113 virtual bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name, 114 SMLoc NameLoc, 115 SmallVectorImpl<MCParsedAsmOperand*> &Operands) = 0; 116 117 /// ParseDirective - Parse a target specific assembler directive 118 /// 119 /// The parser is positioned following the directive name. The target 120 /// specific directive parser should parse the entire directive doing or 121 /// recording any target specific work, or return true and do nothing if the 122 /// directive is not target specific. If the directive is specific for 123 /// the target, the entire line is parsed up to and including the 124 /// end-of-statement token and false is returned. 125 /// 126 /// \param DirectiveID - the identifier token of the directive. 127 virtual bool ParseDirective(AsmToken DirectiveID) = 0; 128 129 /// mnemonicIsValid - This returns true if this is a valid mnemonic and false 130 /// otherwise. 131 virtual bool mnemonicIsValid(StringRef Mnemonic) = 0; 132 133 /// MatchAndEmitInstruction - Recognize a series of operands of a parsed 134 /// instruction as an actual MCInst and emit it to the specified MCStreamer. 135 /// This returns false on success and returns true on failure to match. 136 /// 137 /// On failure, the target parser is responsible for emitting a diagnostic 138 /// explaining the match failure. 139 virtual bool 140 MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode, 141 SmallVectorImpl<MCParsedAsmOperand*> &Operands, 142 MCStreamer &Out, unsigned &ErrorInfo, 143 bool MatchingInlineAsm) = 0; 144 145 /// checkTargetMatchPredicate - Validate the instruction match against 146 /// any complex target predicates not expressible via match classes. 147 virtual unsigned checkTargetMatchPredicate(MCInst &Inst) { 148 return Match_Success; 149 } 150 151 virtual void convertToMapAndConstraints(unsigned Kind, 152 const SmallVectorImpl<MCParsedAsmOperand*> &Operands) = 0; 153}; 154 155} // End llvm namespace 156 157#endif 158