Home | History | Annotate | Download | only in AsmParser 
      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 
    116