[llvm-commits] [llvm] r172136 - /llvm/trunk/lib/MC/MCParser/AsmParser.cpp
Jim Grosbach
grosbach at apple.com
Thu Jan 10 15:23:30 PST 2013
Hi Eli,
This looks great, thanks!
Minor thing I should have mentioned before: the enum prefix should probably be "DK" here instead of "VK". It's usually a shorthand for the full enum tag.
-j
On Jan 10, 2013, at 2:44 PM, Eli Bendersky <eliben at google.com> wrote:
> Author: eliben
> Date: Thu Jan 10 16:44:57 2013
> New Revision: 172136
>
> URL: http://llvm.org/viewvc/llvm-project?rev=172136&view=rev
> Log:
> Remove a couple of if-else chains in parsing directives, replacing them by a
> switch. Committed with Jim's and Chris's approval.
>
>
> Modified:
> llvm/trunk/lib/MC/MCParser/AsmParser.cpp
>
> Modified: llvm/trunk/lib/MC/MCParser/AsmParser.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/MCParser/AsmParser.cpp?rev=172136&r1=172135&r2=172136&view=diff
> ==============================================================================
> --- llvm/trunk/lib/MC/MCParser/AsmParser.cpp (original)
> +++ llvm/trunk/lib/MC/MCParser/AsmParser.cpp Thu Jan 10 16:44:57 2013
> @@ -292,7 +292,26 @@
>
> // Directive Parsing.
>
> - // ".ascii", ".asciiz", ".string"
> + enum DirectiveKind {
> + VK_NO_DIRECTIVE, // Placeholder
> + VK_SET, VK_EQU, VK_EQUIV, VK_ASCII, VK_ASCIZ, VK_STRING, VK_BYTE, VK_SHORT,
> + VK_VALUE, VK_2BYTE, VK_LONG, VK_INT, VK_4BYTE, VK_QUAD, VK_8BYTE, VK_SINGLE,
> + VK_FLOAT, VK_DOUBLE, VK_ALIGN, VK_ALIGN32, VK_BALIGN, VK_BALIGNW,
> + VK_BALIGNL, VK_P2ALIGN, VK_P2ALIGNW, VK_P2ALIGNL, VK_ORG, VK_FILL,
> + VK_SPACE, VK_SKIP, VK_ENDR,
> + VK_BUNDLE_ALIGN_MODE, VK_BUNDLE_LOCK, VK_BUNDLE_UNLOCK,
> + VK_ZERO, VK_EXTERN, VK_GLOBL, VK_GLOBAL, VK_INDIRECT_SYMBOL,
> + VK_LAZY_REFERENCE, VK_NO_DEAD_STRIP, VK_SYMBOL_RESOLVER, VK_PRIVATE_EXTERN,
> + VK_REFERENCE, VK_WEAK_DEFINITION, VK_WEAK_REFERENCE,
> + VK_WEAK_DEF_CAN_BE_HIDDEN, VK_COMM, VM_COMMON, VK_LCOMM, VK_ABORT,
> + VK_INCLUDE, VK_INCBIN, VK_CODE16, VK_CODE16GCC, VK_REPT, VK_IRP, VK_IRPC,
> + VK_IF, VK_IFB, VK_IFNB, VK_IFC, VK_IFNC, VK_IFDEF, VK_IFNDEF, VK_IFNOTDEF,
> + VK_ELSEIF, VK_ELSE, VK_ENDIF
> + };
> +
> + StringMap<DirectiveKind> DirectiveKindMapping;
> +
> + // ".ascii", ".asciz", ".string"
> bool ParseDirectiveAscii(StringRef IDVal, bool ZeroTerminated);
> bool ParseDirectiveValue(unsigned Size); // ".byte", ".long", ...
> bool ParseDirectiveRealValue(const fltSemantics &); // ".single", ...
> @@ -351,6 +370,8 @@
>
> // "_emit"
> bool ParseDirectiveEmit(SMLoc DirectiveLoc, ParseStatementInfo &Info);
> +
> + void initializeDirectiveKindMapping();
> };
>
> /// \brief Generic implementations of directive handling, etc. which is shared
> @@ -508,6 +529,8 @@
> PlatformParser = createELFAsmParser();
> PlatformParser->Initialize(*this);
> }
> +
> + initializeDirectiveKindMapping();
> }
>
> AsmParser::~AsmParser() {
> @@ -1155,30 +1178,39 @@
> IDVal = "";
> }
>
> -
> // Handle conditional assembly here before checking for skipping. We
> // have to do this so that .endif isn't skipped in a ".if 0" block for
> // example.
> - if (IDVal == ".if")
> - return ParseDirectiveIf(IDLoc);
> - if (IDVal == ".ifb")
> - return ParseDirectiveIfb(IDLoc, true);
> - if (IDVal == ".ifnb")
> - return ParseDirectiveIfb(IDLoc, false);
> - if (IDVal == ".ifc")
> - return ParseDirectiveIfc(IDLoc, true);
> - if (IDVal == ".ifnc")
> - return ParseDirectiveIfc(IDLoc, false);
> - if (IDVal == ".ifdef")
> - return ParseDirectiveIfdef(IDLoc, true);
> - if (IDVal == ".ifndef" || IDVal == ".ifnotdef")
> - return ParseDirectiveIfdef(IDLoc, false);
> - if (IDVal == ".elseif")
> - return ParseDirectiveElseIf(IDLoc);
> - if (IDVal == ".else")
> - return ParseDirectiveElse(IDLoc);
> - if (IDVal == ".endif")
> - return ParseDirectiveEndIf(IDLoc);
> + StringMap<DirectiveKind>::const_iterator DirKindIt =
> + DirectiveKindMapping.find(IDVal);
> + DirectiveKind DirKind =
> + (DirKindIt == DirectiveKindMapping.end()) ? VK_NO_DIRECTIVE :
> + DirKindIt->getValue();
> + switch (DirKind) {
> + default:
> + break;
> + case VK_IF:
> + return ParseDirectiveIf(IDLoc);
> + case VK_IFB:
> + return ParseDirectiveIfb(IDLoc, true);
> + case VK_IFNB:
> + return ParseDirectiveIfb(IDLoc, false);
> + case VK_IFC:
> + return ParseDirectiveIfc(IDLoc, true);
> + case VK_IFNC:
> + return ParseDirectiveIfc(IDLoc, false);
> + case VK_IFDEF:
> + return ParseDirectiveIfdef(IDLoc, true);
> + case VK_IFNDEF:
> + case VK_IFNOTDEF:
> + return ParseDirectiveIfdef(IDLoc, false);
> + case VK_ELSEIF:
> + return ParseDirectiveElseIf(IDLoc);
> + case VK_ELSE:
> + return ParseDirectiveElse(IDLoc);
> + case VK_ENDIF:
> + return ParseDirectiveEndIf(IDLoc);
> + }
>
> // If we are in a ".if 0" block, ignore this statement.
> if (TheCondState.Ignore) {
> @@ -1256,139 +1288,126 @@
> if (!getTargetParser().ParseDirective(ID))
> return false;
>
> - // Assembler features
> - if (IDVal == ".set" || IDVal == ".equ")
> - return ParseDirectiveSet(IDVal, true);
> - if (IDVal == ".equiv")
> - return ParseDirectiveSet(IDVal, false);
> -
> - // Data directives
> -
> - if (IDVal == ".ascii")
> - return ParseDirectiveAscii(IDVal, false);
> - if (IDVal == ".asciz" || IDVal == ".string")
> - return ParseDirectiveAscii(IDVal, true);
> -
> - if (IDVal == ".byte")
> - return ParseDirectiveValue(1);
> - if (IDVal == ".short")
> - return ParseDirectiveValue(2);
> - if (IDVal == ".value")
> - return ParseDirectiveValue(2);
> - if (IDVal == ".2byte")
> - return ParseDirectiveValue(2);
> - if (IDVal == ".long")
> - return ParseDirectiveValue(4);
> - if (IDVal == ".int")
> - return ParseDirectiveValue(4);
> - if (IDVal == ".4byte")
> - return ParseDirectiveValue(4);
> - if (IDVal == ".quad")
> - return ParseDirectiveValue(8);
> - if (IDVal == ".8byte")
> - return ParseDirectiveValue(8);
> - if (IDVal == ".single" || IDVal == ".float")
> - return ParseDirectiveRealValue(APFloat::IEEEsingle);
> - if (IDVal == ".double")
> - return ParseDirectiveRealValue(APFloat::IEEEdouble);
> -
> - if (IDVal == ".align") {
> - bool IsPow2 = !getContext().getAsmInfo().getAlignmentIsInBytes();
> - return ParseDirectiveAlign(IsPow2, /*ExprSize=*/1);
> - }
> - if (IDVal == ".align32") {
> - bool IsPow2 = !getContext().getAsmInfo().getAlignmentIsInBytes();
> - return ParseDirectiveAlign(IsPow2, /*ExprSize=*/4);
> - }
> - if (IDVal == ".balign")
> - return ParseDirectiveAlign(/*IsPow2=*/false, /*ExprSize=*/1);
> - if (IDVal == ".balignw")
> - return ParseDirectiveAlign(/*IsPow2=*/false, /*ExprSize=*/2);
> - if (IDVal == ".balignl")
> - return ParseDirectiveAlign(/*IsPow2=*/false, /*ExprSize=*/4);
> - if (IDVal == ".p2align")
> - return ParseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/1);
> - if (IDVal == ".p2alignw")
> - return ParseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/2);
> - if (IDVal == ".p2alignl")
> - return ParseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/4);
> -
> - if (IDVal == ".bundle_align_mode")
> - return ParseDirectiveBundleAlignMode();
> - if (IDVal == ".bundle_lock")
> - return ParseDirectiveBundleLock();
> - if (IDVal == ".bundle_unlock")
> - return ParseDirectiveBundleUnlock();
> -
> - if (IDVal == ".org")
> - return ParseDirectiveOrg();
> -
> - if (IDVal == ".fill")
> - return ParseDirectiveFill();
> - if (IDVal == ".space" || IDVal == ".skip")
> - return ParseDirectiveSpace();
> - if (IDVal == ".zero")
> - return ParseDirectiveZero();
> -
> - // Symbol attribute directives
> -
> - if (IDVal == ".extern") {
> - EatToEndOfStatement(); // .extern is the default, ignore it.
> - return false;
> + switch (DirKind) {
> + default:
> + break;
> + case VK_SET:
> + case VK_EQU:
> + return ParseDirectiveSet(IDVal, true);
> + case VK_EQUIV:
> + return ParseDirectiveSet(IDVal, false);
> + case VK_ASCII:
> + return ParseDirectiveAscii(IDVal, false);
> + case VK_ASCIZ:
> + case VK_STRING:
> + return ParseDirectiveAscii(IDVal, true);
> + case VK_BYTE:
> + return ParseDirectiveValue(1);
> + case VK_SHORT:
> + case VK_VALUE:
> + case VK_2BYTE:
> + return ParseDirectiveValue(2);
> + case VK_LONG:
> + case VK_INT:
> + case VK_4BYTE:
> + return ParseDirectiveValue(4);
> + case VK_QUAD:
> + case VK_8BYTE:
> + return ParseDirectiveValue(8);
> + case VK_SINGLE:
> + case VK_FLOAT:
> + return ParseDirectiveRealValue(APFloat::IEEEsingle);
> + case VK_DOUBLE:
> + return ParseDirectiveRealValue(APFloat::IEEEdouble);
> + case VK_ALIGN: {
> + bool IsPow2 = !getContext().getAsmInfo().getAlignmentIsInBytes();
> + return ParseDirectiveAlign(IsPow2, /*ExprSize=*/1);
> + }
> + case VK_ALIGN32: {
> + bool IsPow2 = !getContext().getAsmInfo().getAlignmentIsInBytes();
> + return ParseDirectiveAlign(IsPow2, /*ExprSize=*/4);
> + }
> + case VK_BALIGN:
> + return ParseDirectiveAlign(/*IsPow2=*/false, /*ExprSize=*/1);
> + case VK_BALIGNW:
> + return ParseDirectiveAlign(/*IsPow2=*/false, /*ExprSize=*/2);
> + case VK_BALIGNL:
> + return ParseDirectiveAlign(/*IsPow2=*/false, /*ExprSize=*/4);
> + case VK_P2ALIGN:
> + return ParseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/1);
> + case VK_P2ALIGNW:
> + return ParseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/2);
> + case VK_P2ALIGNL:
> + return ParseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/4);
> + case VK_ORG:
> + return ParseDirectiveOrg();
> + case VK_FILL:
> + return ParseDirectiveFill();
> + case VK_SPACE:
> + case VK_SKIP:
> + return ParseDirectiveSpace();
> + case VK_ZERO:
> + return ParseDirectiveZero();
> + case VK_EXTERN:
> + EatToEndOfStatement(); // .extern is the default, ignore it.
> + return false;
> + case VK_GLOBL:
> + case VK_GLOBAL:
> + return ParseDirectiveSymbolAttribute(MCSA_Global);
> + case VK_INDIRECT_SYMBOL:
> + return ParseDirectiveSymbolAttribute(MCSA_IndirectSymbol);
> + case VK_LAZY_REFERENCE:
> + return ParseDirectiveSymbolAttribute(MCSA_LazyReference);
> + case VK_NO_DEAD_STRIP:
> + return ParseDirectiveSymbolAttribute(MCSA_NoDeadStrip);
> + case VK_SYMBOL_RESOLVER:
> + return ParseDirectiveSymbolAttribute(MCSA_SymbolResolver);
> + case VK_PRIVATE_EXTERN:
> + return ParseDirectiveSymbolAttribute(MCSA_PrivateExtern);
> + case VK_REFERENCE:
> + return ParseDirectiveSymbolAttribute(MCSA_Reference);
> + case VK_WEAK_DEFINITION:
> + return ParseDirectiveSymbolAttribute(MCSA_WeakDefinition);
> + case VK_WEAK_REFERENCE:
> + return ParseDirectiveSymbolAttribute(MCSA_WeakReference);
> + case VK_WEAK_DEF_CAN_BE_HIDDEN:
> + return ParseDirectiveSymbolAttribute(MCSA_WeakDefAutoPrivate);
> + case VK_COMM:
> + case VM_COMMON:
> + return ParseDirectiveComm(/*IsLocal=*/false);
> + case VK_LCOMM:
> + return ParseDirectiveComm(/*IsLocal=*/true);
> + case VK_ABORT:
> + return ParseDirectiveAbort();
> + case VK_INCLUDE:
> + return ParseDirectiveInclude();
> + case VK_INCBIN:
> + return ParseDirectiveIncbin();
> + case VK_CODE16:
> + case VK_CODE16GCC:
> + return TokError(Twine(IDVal) + " not supported yet");
> + case VK_REPT:
> + return ParseDirectiveRept(IDLoc);
> + case VK_IRP:
> + return ParseDirectiveIrp(IDLoc);
> + case VK_IRPC:
> + return ParseDirectiveIrpc(IDLoc);
> + case VK_ENDR:
> + return ParseDirectiveEndr(IDLoc);
> + case VK_BUNDLE_ALIGN_MODE:
> + return ParseDirectiveBundleAlignMode();
> + case VK_BUNDLE_LOCK:
> + return ParseDirectiveBundleLock();
> + case VK_BUNDLE_UNLOCK:
> + return ParseDirectiveBundleUnlock();
> }
> - if (IDVal == ".globl" || IDVal == ".global")
> - return ParseDirectiveSymbolAttribute(MCSA_Global);
> - if (IDVal == ".indirect_symbol")
> - return ParseDirectiveSymbolAttribute(MCSA_IndirectSymbol);
> - if (IDVal == ".lazy_reference")
> - return ParseDirectiveSymbolAttribute(MCSA_LazyReference);
> - if (IDVal == ".no_dead_strip")
> - return ParseDirectiveSymbolAttribute(MCSA_NoDeadStrip);
> - if (IDVal == ".symbol_resolver")
> - return ParseDirectiveSymbolAttribute(MCSA_SymbolResolver);
> - if (IDVal == ".private_extern")
> - return ParseDirectiveSymbolAttribute(MCSA_PrivateExtern);
> - if (IDVal == ".reference")
> - return ParseDirectiveSymbolAttribute(MCSA_Reference);
> - if (IDVal == ".weak_definition")
> - return ParseDirectiveSymbolAttribute(MCSA_WeakDefinition);
> - if (IDVal == ".weak_reference")
> - return ParseDirectiveSymbolAttribute(MCSA_WeakReference);
> - if (IDVal == ".weak_def_can_be_hidden")
> - return ParseDirectiveSymbolAttribute(MCSA_WeakDefAutoPrivate);
> -
> - if (IDVal == ".comm" || IDVal == ".common")
> - return ParseDirectiveComm(/*IsLocal=*/false);
> - if (IDVal == ".lcomm")
> - return ParseDirectiveComm(/*IsLocal=*/true);
> -
> - if (IDVal == ".abort")
> - return ParseDirectiveAbort();
> - if (IDVal == ".include")
> - return ParseDirectiveInclude();
> - if (IDVal == ".incbin")
> - return ParseDirectiveIncbin();
> -
> - if (IDVal == ".code16" || IDVal == ".code16gcc")
> - return TokError(Twine(IDVal) + " not supported yet");
> -
> - // Macro-like directives
> - if (IDVal == ".rept")
> - return ParseDirectiveRept(IDLoc);
> - if (IDVal == ".irp")
> - return ParseDirectiveIrp(IDLoc);
> - if (IDVal == ".irpc")
> - return ParseDirectiveIrpc(IDLoc);
> - if (IDVal == ".endr")
> - return ParseDirectiveEndr(IDLoc);
>
> - // Look up the handler in the handler table.
> + // Look up the handler in the extension handler table.
> std::pair<MCAsmParserExtension*, DirectiveHandler> Handler =
> DirectiveMap.lookup(IDVal);
> if (Handler.first)
> return (*Handler.second)(Handler.first, IDVal, IDLoc);
>
> -
> return Error(IDLoc, "unknown directive");
> }
>
> @@ -2872,6 +2891,78 @@
> return false;
> }
>
> +void AsmParser::initializeDirectiveKindMapping() {
> + DirectiveKindMapping[".set"] = VK_SET;
> + DirectiveKindMapping[".equ"] = VK_EQU;
> + DirectiveKindMapping[".equiv"] = VK_EQUIV;
> + DirectiveKindMapping[".ascii"] = VK_ASCII;
> + DirectiveKindMapping[".asciz"] = VK_ASCIZ;
> + DirectiveKindMapping[".string"] = VK_STRING;
> + DirectiveKindMapping[".byte"] = VK_BYTE;
> + DirectiveKindMapping[".short"] = VK_SHORT;
> + DirectiveKindMapping[".value"] = VK_VALUE;
> + DirectiveKindMapping[".2byte"] = VK_2BYTE;
> + DirectiveKindMapping[".long"] = VK_LONG;
> + DirectiveKindMapping[".int"] = VK_INT;
> + DirectiveKindMapping[".4byte"] = VK_4BYTE;
> + DirectiveKindMapping[".quad"] = VK_QUAD;
> + DirectiveKindMapping[".8byte"] = VK_8BYTE;
> + DirectiveKindMapping[".single"] = VK_SINGLE;
> + DirectiveKindMapping[".float"] = VK_FLOAT;
> + DirectiveKindMapping[".double"] = VK_DOUBLE;
> + DirectiveKindMapping[".align"] = VK_ALIGN;
> + DirectiveKindMapping[".align32"] = VK_ALIGN32;
> + DirectiveKindMapping[".balign"] = VK_BALIGN;
> + DirectiveKindMapping[".balignw"] = VK_BALIGNW;
> + DirectiveKindMapping[".balignl"] = VK_BALIGNL;
> + DirectiveKindMapping[".p2align"] = VK_P2ALIGN;
> + DirectiveKindMapping[".p2alignw"] = VK_P2ALIGNW;
> + DirectiveKindMapping[".p2alignl"] = VK_P2ALIGNL;
> + DirectiveKindMapping[".org"] = VK_ORG;
> + DirectiveKindMapping[".fill"] = VK_FILL;
> + DirectiveKindMapping[".space"] = VK_SPACE;
> + DirectiveKindMapping[".skip"] = VK_SKIP;
> + DirectiveKindMapping[".zero"] = VK_ZERO;
> + DirectiveKindMapping[".extern"] = VK_EXTERN;
> + DirectiveKindMapping[".globl"] = VK_GLOBL;
> + DirectiveKindMapping[".global"] = VK_GLOBAL;
> + DirectiveKindMapping[".indirect_symbol"] = VK_INDIRECT_SYMBOL;
> + DirectiveKindMapping[".lazy_reference"] = VK_LAZY_REFERENCE;
> + DirectiveKindMapping[".no_dead_strip"] = VK_NO_DEAD_STRIP;
> + DirectiveKindMapping[".symbol_resolver"] = VK_SYMBOL_RESOLVER;
> + DirectiveKindMapping[".private_extern"] = VK_PRIVATE_EXTERN;
> + DirectiveKindMapping[".reference"] = VK_REFERENCE;
> + DirectiveKindMapping[".weak_definition"] = VK_WEAK_DEFINITION;
> + DirectiveKindMapping[".weak_reference"] = VK_WEAK_REFERENCE;
> + DirectiveKindMapping[".weak_def_can_be_hidden"] = VK_WEAK_DEF_CAN_BE_HIDDEN;
> + DirectiveKindMapping[".comm"] = VK_COMM;
> + DirectiveKindMapping[".common"] = VM_COMMON;
> + DirectiveKindMapping[".lcomm"] = VK_LCOMM;
> + DirectiveKindMapping[".abort"] = VK_ABORT;
> + DirectiveKindMapping[".include"] = VK_INCLUDE;
> + DirectiveKindMapping[".incbin"] = VK_INCBIN;
> + DirectiveKindMapping[".code16"] = VK_CODE16;
> + DirectiveKindMapping[".code16gcc"] = VK_CODE16GCC;
> + DirectiveKindMapping[".rept"] = VK_REPT;
> + DirectiveKindMapping[".irp"] = VK_IRP;
> + DirectiveKindMapping[".irpc"] = VK_IRPC;
> + DirectiveKindMapping[".endr"] = VK_ENDR;
> + DirectiveKindMapping[".bundle_align_mode"] = VK_BUNDLE_ALIGN_MODE;
> + DirectiveKindMapping[".bundle_lock"] = VK_BUNDLE_LOCK;
> + DirectiveKindMapping[".bundle_unlock"] = VK_BUNDLE_UNLOCK;
> + DirectiveKindMapping[".if"] = VK_IF;
> + DirectiveKindMapping[".ifb"] = VK_IFB;
> + DirectiveKindMapping[".ifnb"] = VK_IFNB;
> + DirectiveKindMapping[".ifc"] = VK_IFC;
> + DirectiveKindMapping[".ifnc"] = VK_IFNC;
> + DirectiveKindMapping[".ifdef"] = VK_IFDEF;
> + DirectiveKindMapping[".ifndef"] = VK_IFNDEF;
> + DirectiveKindMapping[".ifnotdef"] = VK_IFNOTDEF;
> + DirectiveKindMapping[".elseif"] = VK_ELSEIF;
> + DirectiveKindMapping[".else"] = VK_ELSE;
> + DirectiveKindMapping[".endif"] = VK_ENDIF;
> +}
> +
> /// ParseDirectiveFile
> /// ::= .file [number] filename
> /// ::= .file number directory filename
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list