contrib/llvm/lib/Target/X86/AsmParser/X86AsmLexer.cpp

   1 //===-- X86AsmLexer.cpp - Tokenize X86 assembly to AsmTokens --------------===//
   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 #include "MCTargetDesc/X86BaseInfo.h"
  11 #include "llvm/MC/MCAsmInfo.h"
  12 #include "llvm/MC/MCParser/MCAsmLexer.h"
  13 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  14 #include "llvm/MC/MCTargetAsmLexer.h"
  15 #include "llvm/Support/TargetRegistry.h"
  16 #include "llvm/ADT/SmallVector.h"
  17
  18 using namespace llvm;
  19
  20 namespace {
  21
  22 class X86AsmLexer : public MCTargetAsmLexer {
  23   const MCAsmInfo &AsmInfo;
  24
  25   bool tentativeIsValid;
  26   AsmToken tentativeToken;
  27
  28   const AsmToken &lexTentative() {
  29     tentativeToken = getLexer()->Lex();
  30     tentativeIsValid = true;
  31     return tentativeToken;
  32   }
  33
  34   const AsmToken &lexDefinite() {
  35     if (tentativeIsValid) {
  36       tentativeIsValid = false;
  37       return tentativeToken;
  38     }
  39     return getLexer()->Lex();
  40   }
  41
  42   AsmToken LexTokenATT();
  43   AsmToken LexTokenIntel();
  44 protected:
  45   AsmToken LexToken() {
  46     if (!Lexer) {
  47       SetError(SMLoc(), "No MCAsmLexer installed");
  48       return AsmToken(AsmToken::Error, "", 0);
  49     }
  50
  51     switch (AsmInfo.getAssemblerDialect()) {
  52     default:
  53       SetError(SMLoc(), "Unhandled dialect");
  54       return AsmToken(AsmToken::Error, "", 0);
  55     case 0:
  56       return LexTokenATT();
  57     case 1:
  58       return LexTokenIntel();
  59     }
  60   }
  61 public:
  62   X86AsmLexer(const Target &T, const MCRegisterInfo &MRI, const MCAsmInfo &MAI)
  63     : MCTargetAsmLexer(T), AsmInfo(MAI), tentativeIsValid(false) {
  64   }
  65 };
  66
  67 } // end anonymous namespace
  68
  69 #define GET_REGISTER_MATCHER
  70 #include "X86GenAsmMatcher.inc"
  71
  72 AsmToken X86AsmLexer::LexTokenATT() {
  73   AsmToken lexedToken = lexDefinite();
  74
  75   switch (lexedToken.getKind()) {
  76   default:
  77     return lexedToken;
  78   case AsmToken::Error:
  79     SetError(Lexer->getErrLoc(), Lexer->getErr());
  80     return lexedToken;
  81
  82   case AsmToken::Percent: {
  83     const AsmToken &nextToken = lexTentative();
  84     if (nextToken.getKind() != AsmToken::Identifier)
  85       return lexedToken;
  86
  87     if (unsigned regID = MatchRegisterName(nextToken.getString())) {
  88       lexDefinite();
  89
  90       // FIXME: This is completely wrong when there is a space or other
  91       // punctuation between the % and the register name.
  92       StringRef regStr(lexedToken.getString().data(),
  93                        lexedToken.getString().size() +
  94                        nextToken.getString().size());
  95
  96       return AsmToken(AsmToken::Register, regStr,
  97                       static_cast<int64_t>(regID));
  98     }
  99
 100     // Match register name failed.  If this is "db[0-7]", match it as an alias
 101     // for dr[0-7].
 102     if (nextToken.getString().size() == 3 &&
 103         nextToken.getString().startswith("db")) {
 104       int RegNo = -1;
 105       switch (nextToken.getString()[2]) {
 106       case '0': RegNo = X86::DR0; break;
 107       case '1': RegNo = X86::DR1; break;
 108       case '2': RegNo = X86::DR2; break;
 109       case '3': RegNo = X86::DR3; break;
 110       case '4': RegNo = X86::DR4; break;
 111       case '5': RegNo = X86::DR5; break;
 112       case '6': RegNo = X86::DR6; break;
 113       case '7': RegNo = X86::DR7; break;
 114       }
 115
 116       if (RegNo != -1) {
 117         lexDefinite();
 118
 119         // FIXME: This is completely wrong when there is a space or other
 120         // punctuation between the % and the register name.
 121         StringRef regStr(lexedToken.getString().data(),
 122                          lexedToken.getString().size() +
 123                          nextToken.getString().size());
 124         return AsmToken(AsmToken::Register, regStr,
 125                         static_cast<int64_t>(RegNo));
 126       }
 127     }
 128
 129
 130     return lexedToken;
 131   }
 132   }
 133 }
 134
 135 AsmToken X86AsmLexer::LexTokenIntel() {
 136   const AsmToken &lexedToken = lexDefinite();
 137
 138   switch(lexedToken.getKind()) {
 139   default:
 140     return lexedToken;
 141   case AsmToken::Error:
 142     SetError(Lexer->getErrLoc(), Lexer->getErr());
 143     return lexedToken;
 144   case AsmToken::Identifier: {
 145     unsigned regID = MatchRegisterName(lexedToken.getString().lower());
 146
 147     if (regID)
 148       return AsmToken(AsmToken::Register,
 149                       lexedToken.getString(),
 150                       static_cast<int64_t>(regID));
 151     return lexedToken;
 152   }
 153   }
 154 }
 155
 156 extern "C" void LLVMInitializeX86AsmLexer() {
 157   RegisterMCAsmLexer<X86AsmLexer> X(TheX86_32Target);
 158   RegisterMCAsmLexer<X86AsmLexer> Y(TheX86_64Target);
 159 }