include/llvm/MC/MCTargetAsmParser.h

   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
  15 namespace llvm {
  16 class MCStreamer;
  17 class StringRef;
  18 class SMLoc;
  19 class AsmToken;
  20 class MCParsedAsmOperand;
  21 class MCInst;
  22 template <typename T> class SmallVectorImpl;
  23
  24 enum 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
  36 struct AsmRewrite {
  37   AsmRewriteKind Kind;
  38   SMLoc Loc;
  39   unsigned Len;
  40   unsigned Val;
  41 public:
  42   AsmRewrite(AsmRewriteKind kind, SMLoc loc, unsigned len = 0, unsigned val = 0)
  43     : Kind(kind), Loc(loc), Len(len), Val(val) {}
  44 };
  45
  46 struct 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.
  58 class MCTargetAsmParser : public MCAsmParserExtension {
  59 public:
  60   enum MatchResultTy {
  61     Match_InvalidOperand,
  62     Match_MissingFeature,
  63     Match_MnemonicFail,
  64     Match_Success,
  65     FIRST_TARGET_MATCH_RESULT_TY
  66   };
  67
  68 private:
  69   MCTargetAsmParser(const MCTargetAsmParser &) LLVM_DELETED_FUNCTION;
  70   void operator=(const MCTargetAsmParser &) LLVM_DELETED_FUNCTION;
  71 protected: // 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
  84 public:
  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