6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-07-25 13:24:46 +00:00
Code Issues Projects Releases Wiki Activity

MC: make ELF .type handling more GNU AS compatible

Browse Source 
GAS documents the .type directive as having an optional comma following the key
symbol name when using the STT_<TYPE_IN_UPPER_CASE> form.  However, it treats
the comma as optional in all cases.  This makes the IAS support both forms of
inputs.  Furthermore, the prefixed forms take either the upper case name or the
lower case alias.

The tests are split into two separate sets as the hash character serves as a
comment character on x86, which is tested in the second set by using arm-elf
which uses the at symbol as a comment character.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@210407 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Saleem Abdulrasool
2014-06-08 00:34:34 +00:00
parent a926467222
commit eb5f5ae200
5 changed files with 115 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
lib/MC/MCParser/ELFAsmParser.cpp
View File

@@ -561,6 +561,19 @@ bool ELFAsmParser::ParseDirectivePrevious(StringRef DirName, SMLoc) {
return false;
}
static MCSymbolAttr MCAttrForString(StringRef Type) {
return StringSwitch<MCSymbolAttr>(Type)
.Cases("STT_FUNC", "function", MCSA_ELF_TypeFunction)
.Cases("STT_OBJECT", "object", MCSA_ELF_TypeObject)
.Cases("STT_TLS", "tls_object", MCSA_ELF_TypeTLS)
.Cases("STT_COMMON", "common", MCSA_ELF_TypeCommon)
.Cases("STT_NOTYPE", "notype", MCSA_ELF_TypeNoType)
.Cases("STT_GNU_IFUNC", "gnu_indirect_function",
MCSA_ELF_TypeIndFunction)
.Case("gnu_unique_object", MCSA_ELF_TypeGnuUniqueObject)
.Default(MCSA_Invalid);
}
/// ParseDirectiveELFType
/// ::= .type identifier , STT_<TYPE_IN_UPPER_CASE>
/// ::= .type identifier , #attribute
@@ -575,53 +588,36 @@ bool ELFAsmParser::ParseDirectiveType(StringRef, SMLoc) {
// Handle the identifier as the key symbol.
MCSymbol *Sym = getContext().GetOrCreateSymbol(Name);
if (getLexer().isNot(AsmToken::Comma))
return TokError("unexpected token in '.type' directive");
Lex();
// NOTE the comma is optional in all cases. It is only documented as being
// optional in the first case, however, GAS will silently treat the comma as
// optional in all cases. Furthermore, although the documentation states that
// the first form only accepts STT_<TYPE_IN_UPPER_CASE>, in reality, GAS
// accepts both the upper case name as well as the lower case aliases.
if (getLexer().is(AsmToken::Comma))
Lex();
StringRef Type;
SMLoc TypeLoc;
MCSymbolAttr Attr;
if (getLexer().is(AsmToken::Identifier)) {
TypeLoc = getLexer().getLoc();
if (getParser().parseIdentifier(Type))
return TokError("expected symbol type in directive");
Attr = StringSwitch<MCSymbolAttr>(Type)
.Case("STT_FUNC", MCSA_ELF_TypeFunction)
.Case("STT_OBJECT", MCSA_ELF_TypeObject)
.Case("STT_TLS", MCSA_ELF_TypeTLS)
.Case("STT_COMMON", MCSA_ELF_TypeCommon)
.Case("STT_NOTYPE", MCSA_ELF_TypeNoType)
.Case("STT_GNU_IFUNC", MCSA_ELF_TypeIndFunction)
.Default(MCSA_Invalid);
} else if (getLexer().is(AsmToken::Hash) || getLexer().is(AsmToken::At) ||
getLexer().is(AsmToken::Percent) ||
getLexer().is(AsmToken::String)) {
if (!getLexer().is(AsmToken::String))
Lex();
TypeLoc = getLexer().getLoc();
if (getParser().parseIdentifier(Type))
return TokError("expected symbol type in directive");
Attr = StringSwitch<MCSymbolAttr>(Type)
.Case("function", MCSA_ELF_TypeFunction)
.Case("object", MCSA_ELF_TypeObject)
.Case("tls_object", MCSA_ELF_TypeTLS)
.Case("common", MCSA_ELF_TypeCommon)
.Case("notype", MCSA_ELF_TypeNoType)
.Case("gnu_unique_object", MCSA_ELF_TypeGnuUniqueObject)
.Case("gnu_indirect_function", MCSA_ELF_TypeIndFunction)
.Default(MCSA_Invalid);
} else
if (getLexer().isNot(AsmToken::Identifier) &&
getLexer().isNot(AsmToken::Hash) && getLexer().isNot(AsmToken::At) &&
getLexer().isNot(AsmToken::Percent) && getLexer().isNot(AsmToken::String))
return TokError("expected STT_<TYPE_IN_UPPER_CASE>, '#<type>', '@<type>', "
"'%<type>' or \"<type>\"");
if (getLexer().isNot(AsmToken::String) &&
getLexer().isNot(AsmToken::Identifier))
Lex();
SMLoc TypeLoc = getLexer().getLoc();
StringRef Type;
if (getParser().parseIdentifier(Type))
return TokError("expected symbol type in directive");
MCSymbolAttr Attr = MCAttrForString(Type);
if (Attr == MCSA_Invalid)
return Error(TypeLoc, "unsupported attribute in '.type' directive");
if (getLexer().isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '.type' directive");
Lex();
getStreamer().EmitSymbolAttribute(Sym, Attr);