contrib/llvm/lib/Target/MBlaze/AsmParser/MBlazeAsmLexer.cpp

   1 //===-- MBlazeAsmLexer.cpp - Tokenize MBlaze 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/MBlazeBaseInfo.h"
  11
  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
  18 #include "llvm/Support/TargetRegistry.h"
  19
  20 #include <string>
  21 #include <map>
  22
  23 using namespace llvm;
  24
  25 namespace {
  26
  27   class MBlazeBaseAsmLexer : public MCTargetAsmLexer {
  28     const MCAsmInfo &AsmInfo;
  29
  30     const AsmToken &lexDefinite() {
  31       return getLexer()->Lex();
  32     }
  33
  34     AsmToken LexTokenUAL();
  35   protected:
  36     typedef std::map <std::string, unsigned> rmap_ty;
  37
  38     rmap_ty RegisterMap;
  39
  40     void InitRegisterMap(const MCRegisterInfo *info) {
  41       unsigned numRegs = info->getNumRegs();
  42
  43       for (unsigned i = 0; i < numRegs; ++i) {
  44         const char *regName = info->getName(i);
  45         if (regName)
  46           RegisterMap[regName] = i;
  47       }
  48     }
  49
  50     unsigned MatchRegisterName(StringRef Name) {
  51       rmap_ty::iterator iter = RegisterMap.find(Name.str());
  52       if (iter != RegisterMap.end())
  53         return iter->second;
  54       else
  55         return 0;
  56     }
  57
  58     AsmToken LexToken() {
  59       if (!Lexer) {
  60         SetError(SMLoc(), "No MCAsmLexer installed");
  61         return AsmToken(AsmToken::Error, "", 0);
  62       }
  63
  64       switch (AsmInfo.getAssemblerDialect()) {
  65       default:
  66         SetError(SMLoc(), "Unhandled dialect");
  67         return AsmToken(AsmToken::Error, "", 0);
  68       case 0:
  69         return LexTokenUAL();
  70       }
  71     }
  72   public:
  73     MBlazeBaseAsmLexer(const Target &T, const MCAsmInfo &MAI)
  74       : MCTargetAsmLexer(T), AsmInfo(MAI) {
  75     }
  76   };
  77
  78   class MBlazeAsmLexer : public MBlazeBaseAsmLexer {
  79   public:
  80     MBlazeAsmLexer(const Target &T, const MCRegisterInfo &MRI,
  81                    const MCAsmInfo &MAI)
  82       : MBlazeBaseAsmLexer(T, MAI) {
  83       InitRegisterMap(&MRI);
  84     }
  85   };
  86 }
  87
  88 AsmToken MBlazeBaseAsmLexer::LexTokenUAL() {
  89   const AsmToken &lexedToken = lexDefinite();
  90
  91   switch (lexedToken.getKind()) {
  92   default:
  93     return AsmToken(lexedToken);
  94   case AsmToken::Error:
  95     SetError(Lexer->getErrLoc(), Lexer->getErr());
  96     return AsmToken(lexedToken);
  97   case AsmToken::Identifier:
  98   {
  99     unsigned regID = MatchRegisterName(lexedToken.getString().lower());
 100
 101     if (regID) {
 102       return AsmToken(AsmToken::Register,
 103                       lexedToken.getString(),
 104                       static_cast<int64_t>(regID));
 105     } else {
 106       return AsmToken(lexedToken);
 107     }
 108   }
 109   }
 110 }
 111
 112 extern "C" void LLVMInitializeMBlazeAsmLexer() {
 113   RegisterMCAsmLexer<MBlazeAsmLexer> X(TheMBlazeTarget);
 114 }
 115