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