//
//===----------------------------------------------------------------------===//
-#include "ARM.h"
-#include "ARMTargetMachine.h"
-
-#include "llvm/ADT/OwningPtr.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringExtras.h"
+#include "MCTargetDesc/ARMBaseInfo.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCParser/MCAsmLexer.h"
#include "llvm/MC/MCParser/MCParsedAsmOperand.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCTargetAsmLexer.h"
-#include "llvm/Target/TargetAsmLexer.h"
-#include "llvm/Target/TargetMachine.h"
-#include "llvm/Target/TargetRegistry.h"
+#include "llvm/Support/TargetRegistry.h"
+
+#include "llvm/ADT/OwningPtr.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringSwitch.h"
#include <string>
#include <map>
namespace {
- class ARMBaseAsmLexer : public TargetAsmLexer {
- const MCAsmInfo &AsmInfo;
+class ARMBaseAsmLexer : public MCTargetAsmLexer {
+ const MCAsmInfo &AsmInfo;
- const AsmToken &lexDefinite() {
- return getLexer()->Lex();
- }
+ const AsmToken &lexDefinite() {
+ return getLexer()->Lex();
+ }
- AsmToken LexTokenUAL();
- protected:
- typedef std::map <std::string, unsigned> rmap_ty;
+ AsmToken LexTokenUAL();
+protected:
+ typedef std::map <std::string, unsigned> rmap_ty;
- rmap_ty RegisterMap;
+ rmap_ty RegisterMap;
- void InitRegisterMap(const TargetRegisterInfo *info) {
- unsigned numRegs = info->getNumRegs();
+ void InitRegisterMap(const MCRegisterInfo *info) {
+ unsigned numRegs = info->getNumRegs();
- for (unsigned i = 0; i < numRegs; ++i) {
- const char *regName = info->getName(i);
- if (regName)
- RegisterMap[regName] = i;
- }
+ for (unsigned i = 0; i < numRegs; ++i) {
+ const char *regName = info->getName(i);
+ if (regName)
+ RegisterMap[regName] = i;
}
+ }
- unsigned MatchRegisterName(StringRef Name) {
- rmap_ty::iterator iter = RegisterMap.find(Name.str());
- if (iter != RegisterMap.end())
- return iter->second;
- else
- return 0;
- }
+ unsigned MatchRegisterName(StringRef Name) {
+ rmap_ty::iterator iter = RegisterMap.find(Name.str());
+ if (iter != RegisterMap.end())
+ return iter->second;
+ else
+ return 0;
+ }
- AsmToken LexToken() {
- if (!Lexer) {
- SetError(SMLoc(), "No MCAsmLexer installed");
- return AsmToken(AsmToken::Error, "", 0);
- }
-
- switch (AsmInfo.getAssemblerDialect()) {
- default:
- SetError(SMLoc(), "Unhandled dialect");
- return AsmToken(AsmToken::Error, "", 0);
- case 0:
- return LexTokenUAL();
- }
- }
- public:
- ARMBaseAsmLexer(const Target &T, const MCAsmInfo &MAI)
- : TargetAsmLexer(T), AsmInfo(MAI) {
+ AsmToken LexToken() {
+ if (!Lexer) {
+ SetError(SMLoc(), "No MCAsmLexer installed");
+ return AsmToken(AsmToken::Error, "", 0);
}
- };
-
- class ARMAsmLexer : public ARMBaseAsmLexer {
- public:
- ARMAsmLexer(const Target &T, const MCAsmInfo &MAI)
- : ARMBaseAsmLexer(T, MAI) {
- std::string tripleString("arm-unknown-unknown");
- std::string featureString;
- OwningPtr<const TargetMachine>
- targetMachine(T.createTargetMachine(tripleString, featureString));
- InitRegisterMap(targetMachine->getRegisterInfo());
- }
- };
-
- class ThumbAsmLexer : public ARMBaseAsmLexer {
- public:
- ThumbAsmLexer(const Target &T, const MCAsmInfo &MAI)
- : ARMBaseAsmLexer(T, MAI) {
- std::string tripleString("thumb-unknown-unknown");
- std::string featureString;
- OwningPtr<const TargetMachine>
- targetMachine(T.createTargetMachine(tripleString, featureString));
- InitRegisterMap(targetMachine->getRegisterInfo());
+
+ switch (AsmInfo.getAssemblerDialect()) {
+ default:
+ SetError(SMLoc(), "Unhandled dialect");
+ return AsmToken(AsmToken::Error, "", 0);
+ case 0:
+ return LexTokenUAL();
}
- };
-}
+ }
+public:
+ ARMBaseAsmLexer(const Target &T, const MCAsmInfo &MAI)
+ : MCTargetAsmLexer(T), AsmInfo(MAI) {
+ }
+};
+
+class ARMAsmLexer : public ARMBaseAsmLexer {
+public:
+ ARMAsmLexer(const Target &T, const MCRegisterInfo &MRI, const MCAsmInfo &MAI)
+ : ARMBaseAsmLexer(T, MAI) {
+ InitRegisterMap(&MRI);
+ }
+};
+
+class ThumbAsmLexer : public ARMBaseAsmLexer {
+public:
+ ThumbAsmLexer(const Target &T, const MCRegisterInfo &MRI,const MCAsmInfo &MAI)
+ : ARMBaseAsmLexer(T, MAI) {
+ InitRegisterMap(&MRI);
+ }
+};
+
+} // end anonymous namespace
AsmToken ARMBaseAsmLexer::LexTokenUAL() {
const AsmToken &lexedToken = lexDefinite();
switch (lexedToken.getKind()) {
- default:
- return AsmToken(lexedToken);
+ default: break;
case AsmToken::Error:
SetError(Lexer->getErrLoc(), Lexer->getErr());
- return AsmToken(lexedToken);
- case AsmToken::Identifier:
- {
+ break;
+ case AsmToken::Identifier: {
std::string upperCase = lexedToken.getString().str();
std::string lowerCase = LowercaseString(upperCase);
StringRef lowerRef(lowerCase);
// ip -> r12
// FIXME: Some assemblers support lots of others. Do we want them all?
if (!regID) {
- if (lowerCase.size() == 3 && lowerCase[0] == 'r'
- && lowerCase[1] == '1') {
- switch (lowerCase[2]) {
- default: break;
- case '3': regID = ARM::SP;
- case '4': regID = ARM::LR;
- case '5': regID = ARM::PC;
- }
- } else if (lowerCase == "ip")
- regID = ARM::R12;
+ regID = StringSwitch<unsigned>(lowerCase)
+ .Case("r13", ARM::SP)
+ .Case("r14", ARM::LR)
+ .Case("r15", ARM::PC)
+ .Case("ip", ARM::R12)
+ .Default(0);
}
- if (regID) {
+ if (regID)
return AsmToken(AsmToken::Register,
lexedToken.getString(),
static_cast<int64_t>(regID));
- } else {
- return AsmToken(lexedToken);
- }
}
}
+
+ return AsmToken(lexedToken);
}
extern "C" void LLVMInitializeARMAsmLexer() {
- RegisterAsmLexer<ARMAsmLexer> X(TheARMTarget);
- RegisterAsmLexer<ThumbAsmLexer> Y(TheThumbTarget);
+ RegisterMCAsmLexer<ARMAsmLexer> X(TheARMTarget);
+ RegisterMCAsmLexer<ThumbAsmLexer> Y(TheThumbTarget);
}
-