llvm-6502/lib/MC/MCParser/ELFAsmParser.cpp
2010-07-20 21:12:46 +00:00

282 lines
9.8 KiB
C++

//===- ELFAsmParser.cpp - ELF Assembly Parser -----------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/MC/MCParser/MCAsmParserExtension.h"
#include "llvm/ADT/Twine.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCParser/MCAsmLexer.h"
#include "llvm/MC/MCSectionELF.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/ADT/Twine.h"
using namespace llvm;
namespace {
class ELFAsmParser : public MCAsmParserExtension {
template<bool (ELFAsmParser::*Handler)(StringRef, SMLoc)>
void AddDirectiveHandler(StringRef Directive) {
getParser().AddDirectiveHandler(this, Directive,
HandleDirective<ELFAsmParser, Handler>);
}
bool ParseSectionSwitch(StringRef Section, unsigned Type,
unsigned Flags, SectionKind Kind);
public:
ELFAsmParser() {}
virtual void Initialize(MCAsmParser &Parser) {
// Call the base implementation.
this->MCAsmParserExtension::Initialize(Parser);
AddDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveData>(".data");
AddDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveText>(".text");
AddDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveBSS>(".bss");
AddDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveRoData>(".rodata");
AddDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveTData>(".tdata");
AddDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveTBSS>(".tbss");
AddDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveDataRel>(".data.rel");
AddDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveDataRelRo>(".data.rel.ro");
AddDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveDataRelRoLocal>(".data.rel.ro.local");
AddDirectiveHandler<&ELFAsmParser::ParseSectionDirectiveEhFrame>(".eh_frame");
AddDirectiveHandler<&ELFAsmParser::ParseDirectiveSection>(".section");
AddDirectiveHandler<&ELFAsmParser::ParseDirectiveSize>(".size");
AddDirectiveHandler<&ELFAsmParser::ParseDirectiveLEB128>(".sleb128");
AddDirectiveHandler<&ELFAsmParser::ParseDirectiveLEB128>(".uleb128");
}
bool ParseSectionDirectiveData(StringRef, SMLoc) {
return ParseSectionSwitch(".data", MCSectionELF::SHT_PROGBITS,
MCSectionELF::SHF_WRITE |MCSectionELF::SHF_ALLOC,
SectionKind::getDataRel());
}
bool ParseSectionDirectiveText(StringRef, SMLoc) {
return ParseSectionSwitch(".text", MCSectionELF::SHT_PROGBITS,
MCSectionELF::SHF_EXECINSTR |
MCSectionELF::SHF_ALLOC, SectionKind::getText());
}
bool ParseSectionDirectiveBSS(StringRef, SMLoc) {
return ParseSectionSwitch(".bss", MCSectionELF::SHT_NOBITS,
MCSectionELF::SHF_WRITE |
MCSectionELF::SHF_ALLOC, SectionKind::getBSS());
}
bool ParseSectionDirectiveRoData(StringRef, SMLoc) {
return ParseSectionSwitch(".rodata", MCSectionELF::SHT_PROGBITS,
MCSectionELF::SHF_ALLOC,
SectionKind::getReadOnly());
}
bool ParseSectionDirectiveTData(StringRef, SMLoc) {
return ParseSectionSwitch(".tdata", MCSectionELF::SHT_PROGBITS,
MCSectionELF::SHF_ALLOC |
MCSectionELF::SHF_TLS | MCSectionELF::SHF_WRITE,
SectionKind::getThreadData());
}
bool ParseSectionDirectiveTBSS(StringRef, SMLoc) {
return ParseSectionSwitch(".tbss", MCSectionELF::SHT_NOBITS,
MCSectionELF::SHF_ALLOC |
MCSectionELF::SHF_TLS | MCSectionELF::SHF_WRITE,
SectionKind::getThreadBSS());
}
bool ParseSectionDirectiveDataRel(StringRef, SMLoc) {
return ParseSectionSwitch(".data.rel", MCSectionELF::SHT_PROGBITS,
MCSectionELF::SHF_ALLOC |
MCSectionELF::SHF_WRITE,
SectionKind::getDataRel());
}
bool ParseSectionDirectiveDataRelRo(StringRef, SMLoc) {
return ParseSectionSwitch(".data.rel.ro", MCSectionELF::SHT_PROGBITS,
MCSectionELF::SHF_ALLOC |
MCSectionELF::SHF_WRITE,
SectionKind::getReadOnlyWithRel());
}
bool ParseSectionDirectiveDataRelRoLocal(StringRef, SMLoc) {
return ParseSectionSwitch(".data.rel.ro.local", MCSectionELF::SHT_PROGBITS,
MCSectionELF::SHF_ALLOC |
MCSectionELF::SHF_WRITE,
SectionKind::getReadOnlyWithRelLocal());
}
bool ParseSectionDirectiveEhFrame(StringRef, SMLoc) {
return ParseSectionSwitch(".eh_frame", MCSectionELF::SHT_PROGBITS,
MCSectionELF::SHF_ALLOC |
MCSectionELF::SHF_WRITE,
SectionKind::getDataRel());
}
bool ParseDirectiveLEB128(StringRef, SMLoc);
bool ParseDirectiveSection(StringRef, SMLoc);
bool ParseDirectiveSize(StringRef, SMLoc);
};
}
bool ELFAsmParser::ParseSectionSwitch(StringRef Section, unsigned Type,
unsigned Flags, SectionKind Kind) {
if (getLexer().isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in section switching directive");
Lex();
getStreamer().SwitchSection(getContext().getELFSection(
Section, Type, Flags, Kind));
return false;
}
bool ELFAsmParser::ParseDirectiveSize(StringRef, SMLoc) {
StringRef Name;
if (getParser().ParseIdentifier(Name))
return TokError("expected identifier in directive");
MCSymbol *Sym = getContext().GetOrCreateSymbol(Name);;
if (getLexer().isNot(AsmToken::Comma))
return TokError("unexpected token in directive");
Lex();
const MCExpr *Expr;
if (getParser().ParseExpression(Expr))
return true;
if (getLexer().isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in directive");
getStreamer().EmitELFSize(Sym, Expr);
return false;
}
// FIXME: This is a work in progress.
bool ELFAsmParser::ParseDirectiveSection(StringRef, SMLoc) {
StringRef SectionName;
// FIXME: This doesn't parse section names like ".note.GNU-stack" correctly.
if (getParser().ParseIdentifier(SectionName))
return TokError("expected identifier in directive");
std::string FlagsStr;
StringRef TypeName;
int64_t Size = 0;
if (getLexer().is(AsmToken::Comma)) {
Lex();
if (getLexer().isNot(AsmToken::String))
return TokError("expected string in directive");
FlagsStr = getTok().getStringContents();
Lex();
AsmToken::TokenKind TypeStartToken;
if (getContext().getAsmInfo().getCommentString()[0] == '@')
TypeStartToken = AsmToken::Percent;
else
TypeStartToken = AsmToken::At;
if (getLexer().is(AsmToken::Comma)) {
Lex();
if (getLexer().is(TypeStartToken)) {
Lex();
if (getParser().ParseIdentifier(TypeName))
return TokError("expected identifier in directive");
if (getLexer().is(AsmToken::Comma)) {
Lex();
if (getParser().ParseAbsoluteExpression(Size))
return true;
if (Size <= 0)
return TokError("section size must be positive");
}
}
}
}
if (getLexer().isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in directive");
unsigned Flags = 0;
for (unsigned i = 0; i < FlagsStr.size(); i++) {
switch (FlagsStr[i]) {
case 'a':
Flags |= MCSectionELF::SHF_ALLOC;
break;
case 'x':
Flags |= MCSectionELF::SHF_EXECINSTR;
break;
case 'w':
Flags |= MCSectionELF::SHF_WRITE;
break;
case 'M':
Flags |= MCSectionELF::SHF_MERGE;
break;
case 'S':
Flags |= MCSectionELF::SHF_STRINGS;
break;
case 'T':
Flags |= MCSectionELF::SHF_TLS;
break;
case 'c':
Flags |= MCSectionELF::XCORE_SHF_CP_SECTION;
break;
case 'd':
Flags |= MCSectionELF::XCORE_SHF_DP_SECTION;
break;
default:
return TokError("unknown flag");
}
}
unsigned Type = MCSectionELF::SHT_NULL;
if (!TypeName.empty()) {
if (TypeName == "init_array")
Type = MCSectionELF::SHT_INIT_ARRAY;
else if (TypeName == "fini_array")
Type = MCSectionELF::SHT_FINI_ARRAY;
else if (TypeName == "preinit_array")
Type = MCSectionELF::SHT_PREINIT_ARRAY;
else if (TypeName == "nobits")
Type = MCSectionELF::SHT_NOBITS;
else if (TypeName == "progbits")
Type = MCSectionELF::SHT_PROGBITS;
else
return TokError("unknown section type");
}
SectionKind Kind = (Flags & MCSectionELF::SHF_EXECINSTR)
? SectionKind::getText()
: SectionKind::getDataRel();
getStreamer().SwitchSection(getContext().getELFSection(SectionName, Type,
Flags, Kind, false));
return false;
}
bool ELFAsmParser::ParseDirectiveLEB128(StringRef DirName, SMLoc) {
int64_t Value;
if (getParser().ParseAbsoluteExpression(Value))
return true;
if (getLexer().isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in directive");
// FIXME: Add proper MC support.
if (getContext().getAsmInfo().hasLEB128()) {
if (DirName[1] == 's')
getStreamer().EmitRawText("\t.sleb128\t" + Twine(Value));
else
getStreamer().EmitRawText("\t.uleb128\t" + Twine(Value));
return false;
}
// FIXME: This shouldn't be an error!
return TokError("LEB128 not supported yet");
}
namespace llvm {
MCAsmParserExtension *createELFAsmParser() {
return new ELFAsmParser;
}
}