lib/Target/ARM/AsmParser/ARMAsmLexer.cpp

   1 //===-- ARMAsmLexer.cpp - Tokenize ARM 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/ARMBaseInfo.h"
  11 #include "llvm/ADT/StringSwitch.h"
  12 #include "llvm/MC/MCAsmInfo.h"
  13 #include "llvm/MC/MCParser/MCAsmLexer.h"
  14 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  15 #include "llvm/MC/MCRegisterInfo.h"
  16 #include "llvm/MC/MCTargetAsmLexer.h"
  17 #include "llvm/Support/TargetRegistry.h"
  18 #include <map>
  19 #include <string>
  20
  21 using namespace llvm;
  22
  23 namespace {
  24
  25 class ARMBaseAsmLexer : public MCTargetAsmLexer {
  26   const MCAsmInfo &AsmInfo;
  27
  28   const AsmToken &lexDefinite() {
  29     return getLexer()->Lex();
  30   }
  31
  32   AsmToken LexTokenUAL();
  33 protected:
  34   typedef std::map <std::string, unsigned> rmap_ty;
  35
  36   rmap_ty RegisterMap;
  37
  38   void InitRegisterMap(const MCRegisterInfo *info) {
  39     unsigned numRegs = info->getNumRegs();
  40
  41     for (unsigned i = 0; i < numRegs; ++i) {
  42       const char *regName = info->getName(i);
  43       if (regName)
  44         RegisterMap[regName] = i;
  45     }
  46   }
  47
  48   unsigned MatchRegisterName(StringRef Name) {
  49     rmap_ty::iterator iter = RegisterMap.find(Name.str());
  50     if (iter != RegisterMap.end())
  51       return iter->second;
  52     else
  53       return 0;
  54   }
  55
  56   AsmToken LexToken() {
  57     if (!Lexer) {
  58       SetError(SMLoc(), "No MCAsmLexer installed");
  59       return AsmToken(AsmToken::Error, "", 0);
  60     }
  61
  62     switch (AsmInfo.getAssemblerDialect()) {
  63     default:
  64       SetError(SMLoc(), "Unhandled dialect");
  65       return AsmToken(AsmToken::Error, "", 0);
  66     case 0:
  67       return LexTokenUAL();
  68     }
  69   }
  70 public:
  71   ARMBaseAsmLexer(const Target &T, const MCAsmInfo &MAI)
  72     : MCTargetAsmLexer(T), AsmInfo(MAI) {
  73   }
  74 };
  75
  76 class ARMAsmLexer : public ARMBaseAsmLexer {
  77 public:
  78   ARMAsmLexer(const Target &T, const MCRegisterInfo &MRI, const MCAsmInfo &MAI)
  79     : ARMBaseAsmLexer(T, MAI) {
  80     InitRegisterMap(&MRI);
  81   }
  82 };
  83
  84 class ThumbAsmLexer : public ARMBaseAsmLexer {
  85 public:
  86   ThumbAsmLexer(const Target &T, const MCRegisterInfo &MRI,const MCAsmInfo &MAI)
  87     : ARMBaseAsmLexer(T, MAI) {
  88     InitRegisterMap(&MRI);
  89   }
  90 };
  91
  92 } // end anonymous namespace
  93
  94 AsmToken ARMBaseAsmLexer::LexTokenUAL() {
  95   const AsmToken &lexedToken = lexDefinite();
  96
  97   switch (lexedToken.getKind()) {
  98   default: break;
  99   case AsmToken::Error:
 100     SetError(Lexer->getErrLoc(), Lexer->getErr());
 101     break;
 102   case AsmToken::Identifier: {
 103     std::string lowerCase = lexedToken.getString().lower();
 104
 105     unsigned regID = MatchRegisterName(lowerCase);
 106     // Check for register aliases.
 107     //   r13 -> sp
 108     //   r14 -> lr
 109     //   r15 -> pc
 110     //   ip  -> r12
 111     //   FIXME: Some assemblers support lots of others. Do we want them all?
 112     if (!regID) {
 113       regID = StringSwitch<unsigned>(lowerCase)
 114         .Case("r13", ARM::SP)
 115         .Case("r14", ARM::LR)
 116         .Case("r15", ARM::PC)
 117         .Case("ip", ARM::R12)
 118         .Default(0);
 119     }
 120
 121     if (regID)
 122       return AsmToken(AsmToken::Register,
 123                       lexedToken.getString(),
 124                       static_cast<int64_t>(regID));
 125   }
 126   }
 127
 128   return AsmToken(lexedToken);
 129 }
 130
 131 extern "C" void LLVMInitializeARMAsmLexer() {
 132   RegisterMCAsmLexer<ARMAsmLexer> X(TheARMTarget);
 133   RegisterMCAsmLexer<ThumbAsmLexer> Y(TheThumbTarget);
 134 }