//===- AsmParser.cpp - Parser for Assembly Files --------------------------===//

//

//                     The LLVM Compiler Infrastructure

//

// This file is distributed under the University of Illinois Open Source

// License. See LICENSE.TXT for details.

//

//===----------------------------------------------------------------------===//

//

// This class implements the parser for assembly files.

//

//===----------------------------------------------------------------------===//

#include "llvm/ADT/APFloat.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/SmallString.h"

#include "llvm/ADT/StringMap.h"

#include "llvm/ADT/Twine.h"

#include "llvm/MC/MCAsmInfo.h"

#include "llvm/MC/MCContext.h"

#include "llvm/MC/MCDwarf.h"

#include "llvm/MC/MCExpr.h"

#include "llvm/MC/MCInstrInfo.h"

#include "llvm/MC/MCObjectFileInfo.h"

#include "llvm/MC/MCParser/AsmCond.h"

#include "llvm/MC/MCParser/AsmLexer.h"

#include "llvm/MC/MCParser/MCAsmParser.h"

#include "llvm/MC/MCParser/MCAsmParserUtils.h"

#include "llvm/MC/MCParser/MCParsedAsmOperand.h"

#include "llvm/MC/MCParser/MCTargetAsmParser.h"

#include "llvm/MC/MCRegisterInfo.h"

#include "llvm/MC/MCSectionMachO.h"

#include "llvm/MC/MCStreamer.h"

#include "llvm/MC/MCSymbol.h"

#include "llvm/MC/MCValue.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/MathExtras.h"

#include "llvm/Support/MemoryBuffer.h"

#include "llvm/Support/SourceMgr.h"

#include "llvm/Support/raw_ostream.h"

#include <cctype>

#include <deque>

#include <set>

#include <string>

#include <vector>

#include <keystone/keystone.h>

//#include <iostream>

using namespace llvm_ks;

MCAsmParserSemaCallback::~MCAsmParserSemaCallback() {}

namespace {

/// \brief Helper types for tracking macro definitions.

typedef std::vector<AsmToken> MCAsmMacroArgument;

typedef std::vector<MCAsmMacroArgument> MCAsmMacroArguments;

struct MCAsmMacroParameter {

  StringRef Name;

  MCAsmMacroArgument Value;

  bool Required;

  bool Vararg;

  MCAsmMacroParameter() : Required(false), Vararg(false) {}

};

typedef std::vector<MCAsmMacroParameter> MCAsmMacroParameters;

struct MCAsmMacro {

  StringRef Name;

  StringRef Body;

  MCAsmMacroParameters Parameters;

public:

  MCAsmMacro(StringRef N, StringRef B, MCAsmMacroParameters P)

      : Name(N), Body(B), Parameters(std::move(P)) {}

};

/// \brief Helper class for storing information about an active macro

/// instantiation.

struct MacroInstantiation {

  /// The location of the instantiation.

  SMLoc InstantiationLoc;

  /// The buffer where parsing should resume upon instantiation completion.

  int ExitBuffer;

  /// The location where parsing should resume upon instantiation completion.

  SMLoc ExitLoc;

  /// The depth of TheCondStack at the start of the instantiation.

  size_t CondStackDepth;

public:

  MacroInstantiation(SMLoc IL, int EB, SMLoc EL, size_t CondStackDepth);

};

struct ParseStatementInfo {

  // error code for Keystone

  unsigned int KsError;

  /// \brief The parsed operands from the last parsed statement.

  SmallVector<std::unique_ptr<MCParsedAsmOperand>, 8> ParsedOperands;

  /// \brief The opcode from the last parsed instruction.

  unsigned Opcode;

  /// \brief Was there an error parsing the inline assembly?

  bool ParseError;

  SmallVectorImpl<AsmRewrite> *AsmRewrites;

  ParseStatementInfo() : KsError(0), Opcode(~0U), ParseError(false), AsmRewrites(nullptr) {}

  ParseStatementInfo(SmallVectorImpl<AsmRewrite> *rewrites)

    : Opcode(~0), ParseError(false), AsmRewrites(rewrites) {}

};

/// \brief The concrete assembly parser instance.

class AsmParser : public MCAsmParser {

  AsmParser(const AsmParser &) = delete;

  void operator=(const AsmParser &) = delete;

private:

  AsmLexer Lexer;

  MCContext &Ctx;

  MCStreamer &Out;

  const MCAsmInfo &MAI;

  SourceMgr &SrcMgr;

  SourceMgr::DiagHandlerTy SavedDiagHandler;

  void *SavedDiagContext;

  std::unique_ptr<MCAsmParserExtension> PlatformParser;

  /// This is the current buffer index we're lexing from as managed by the

  /// SourceMgr object.

  unsigned CurBuffer;

  AsmCond TheCondState;

  std::vector<AsmCond> TheCondStack;

  /// \brief maps directive names to handler methods in parser

  /// extensions. Extensions register themselves in this map by calling

  /// addDirectiveHandler.

  StringMap<ExtensionDirectiveHandler> ExtensionDirectiveMap;

  /// \brief Map of currently defined macros.

  StringMap<MCAsmMacro> MacroMap;

  /// \brief Stack of active macro instantiations.

  std::vector<MacroInstantiation*> ActiveMacros;

  /// \brief List of bodies of anonymous macros.

  std::deque<MCAsmMacro> MacroLikeBodies;

  /// Boolean tracking whether macro substitution is enabled.

  unsigned MacrosEnabledFlag : 1;

  /// \brief Keeps track of how many .macro's have been instantiated.

  unsigned NumOfMacroInstantiations;

  /// Flag tracking whether any errors have been encountered.

  bool HadError;

  /// The values from the last parsed cpp hash file line comment if any.

  StringRef CppHashFilename;

  int64_t CppHashLineNumber;

  SMLoc CppHashLoc;

  unsigned CppHashBuf;

  /// When generating dwarf for assembly source files we need to calculate the

  /// logical line number based on the last parsed cpp hash file line comment

  /// and current line. Since this is slow and messes up the SourceMgr's

  /// cache we save the last info we queried with SrcMgr.FindLineNumber().

  SMLoc LastQueryIDLoc;

  /// AssemblerDialect. ~OU means unset value and use value provided by MAI.

  unsigned AssemblerDialect;

  /// \brief is Darwin compatibility enabled?

  bool IsDarwin;

  /// \brief Are we parsing ms-style inline assembly?

  bool ParsingInlineAsm;

  /// \brief Should we use PC relative offsets by default?

  bool NasmDefaultRel;

  // Keystone syntax support

  int KsSyntax;

public:

  AsmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,

            const MCAsmInfo &MAI);

  ~AsmParser() override;

  size_t Run(bool NoInitialTextSection, uint64_t Address, bool NoFinalize = false) override;

  void addDirectiveHandler(StringRef Directive,

                           ExtensionDirectiveHandler Handler) override {

    ExtensionDirectiveMap[Directive] = Handler;

  }

  void addAliasForDirective(StringRef Directive, StringRef Alias) override {

    DirectiveKindMap[Directive] = DirectiveKindMap[Alias];

  }

public:

  /// @name MCAsmParser Interface

  /// {

  SourceMgr &getSourceManager() override { return SrcMgr; }

  MCAsmLexer &getLexer() override { return Lexer; }

  MCContext &getContext() override { return Ctx; }

  MCStreamer &getStreamer() override { return Out; }

  unsigned getAssemblerDialect() override {

    if (AssemblerDialect == ~0U)

      return MAI.getAssemblerDialect();

    else

      return AssemblerDialect;

  }

  void setAssemblerDialect(unsigned i) override {

    AssemblerDialect = i;

  }

  void Note(SMLoc L, const Twine &Msg,

            ArrayRef<SMRange> Ranges = None) override;

  bool Warning(SMLoc L, const Twine &Msg,

               ArrayRef<SMRange> Ranges = None) override;

  bool Error(SMLoc L, const Twine &Msg,

             ArrayRef<SMRange> Ranges = None) override;

  const AsmToken &Lex() override;

  void setParsingInlineAsm(bool V) override { ParsingInlineAsm = V; }

  bool isParsingInlineAsm() override { return ParsingInlineAsm; }

  void setNasmDefaultRel(bool V) override { NasmDefaultRel = V; }

  bool isNasmDefaultRel() override { return NasmDefaultRel; }

  bool parseMSInlineAsm(void *AsmLoc, std::string &AsmString,

                        unsigned &NumOutputs, unsigned &NumInputs,

                        SmallVectorImpl<std::pair<void *,bool> > &OpDecls,

                        SmallVectorImpl<std::string> &Constraints,

                        SmallVectorImpl<std::string> &Clobbers,

                        const MCInstrInfo *MII,

                        MCAsmParserSemaCallback &SI, uint64_t &Address) override;

  bool parseExpression(const MCExpr *&Res);

  bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc) override;

  bool parsePrimaryExprAux(const MCExpr *&Res, SMLoc &EndLoc, unsigned int depth);

  bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) override;

  bool parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) override;

  bool parseParenExprOfDepth(unsigned ParenDepth, const MCExpr *&Res,

                             SMLoc &EndLoc) override;

  bool parseAbsoluteExpression(int64_t &Res) override;

  /// \brief Parse an identifier or string (as a quoted identifier)

  /// and set \p Res to the identifier contents.

  bool parseIdentifier(StringRef &Res) override;

  void eatToEndOfStatement() override;

  void checkForValidSection() override;

  void initializeDirectiveKindMap(int syntax) override;    // Keystone NASM support

  /// }

private:

  bool parseStatement(ParseStatementInfo &Info,

                      MCAsmParserSemaCallback *SI, uint64_t &Address);

  void eatToEndOfLine();

  bool parseCppHashLineFilenameComment(SMLoc L);

  void checkForBadMacro(SMLoc DirectiveLoc, StringRef Name, StringRef Body,

                        ArrayRef<MCAsmMacroParameter> Parameters);

  bool expandMacro(raw_svector_ostream &OS, StringRef Body,

                   ArrayRef<MCAsmMacroParameter> Parameters,

                   ArrayRef<MCAsmMacroArgument> A, bool EnableAtPseudoVariable,

                   SMLoc L);

  /// \brief Are macros enabled in the parser?

  bool areMacrosEnabled() {return MacrosEnabledFlag;}

  /// \brief Control a flag in the parser that enables or disables macros.

  void setMacrosEnabled(bool Flag) {MacrosEnabledFlag = Flag;}

  /// \brief Lookup a previously defined macro.

  /// \param Name Macro name.

  /// \returns Pointer to macro. NULL if no such macro was defined.

  const MCAsmMacro* lookupMacro(StringRef Name);

  /// \brief Define a new macro with the given name and information.

  void defineMacro(StringRef Name, MCAsmMacro Macro);

  /// \brief Undefine a macro. If no such macro was defined, it's a no-op.

  void undefineMacro(StringRef Name);

  /// \brief Are we inside a macro instantiation?

  bool isInsideMacroInstantiation() {return !ActiveMacros.empty();}

  /// \brief Handle entry to macro instantiation.

  ///

  /// \param M The macro.

  /// \param NameLoc Instantiation location.

  bool handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc);

  /// \brief Handle exit from macro instantiation.

  void handleMacroExit();

  /// \brief Extract AsmTokens for a macro argument.

  bool parseMacroArgument(MCAsmMacroArgument &MA, bool Vararg);

  /// \brief Parse all macro arguments for a given macro.

  bool parseMacroArguments(const MCAsmMacro *M, MCAsmMacroArguments &A);

  void printMacroInstantiations();

  void printMessage(SMLoc Loc, SourceMgr::DiagKind Kind, const Twine &Msg,

                    ArrayRef<SMRange> Ranges = None) const {

    SrcMgr.PrintMessage(Loc, Kind, Msg, Ranges);

  }

  static void DiagHandler(const SMDiagnostic &Diag, void *Context);

  /// \brief Enter the specified file. This returns true on failure.

  bool enterIncludeFile(const std::string &Filename);

  /// \brief Process the specified file for the .incbin directive.

  /// This returns true on failure.

  bool processIncbinFile(const std::string &Filename);

  /// \brief Reset the current lexer position to that given by \p Loc. The

  /// current token is not set; clients should ensure Lex() is called

  /// subsequently.

  ///

  /// \param InBuffer If not 0, should be the known buffer id that contains the

  /// location.

  void jumpToLoc(SMLoc Loc, unsigned InBuffer = 0);

  /// \brief Parse up to the end of statement and a return the contents from the

  /// current token until the end of the statement; the current token on exit

  /// will be either the EndOfStatement or EOF.

  StringRef parseStringToEndOfStatement() override;

  /// \brief Parse until the end of a statement or a comma is encountered,

  /// return the contents from the current token up to the end or comma.

  StringRef parseStringToComma();

  bool parseAssignment(StringRef Name, bool allow_redef,

                       bool NoDeadStrip = false);

  unsigned getBinOpPrecedence(AsmToken::TokenKind K,

                              MCBinaryExpr::Opcode &Kind);

  bool parseBinOpRHS(unsigned Precedence, const MCExpr *&Res, SMLoc &EndLoc);

  bool parseParenExpr(const MCExpr *&Res, SMLoc &EndLoc);

  bool parseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc);

  bool parseRegisterOrRegisterNumber(int64_t &Register, SMLoc DirectiveLoc);

  // Generic (target and platform independent) directive parsing.

  enum DirectiveKind {

    DK_NO_DIRECTIVE, // Placeholder

    DK_SET, DK_EQU, DK_EQUIV, DK_ASCII, DK_ASCIZ, DK_STRING, DK_BYTE, DK_SHORT,

    DK_RELOC,

    DK_VALUE, DK_2BYTE, DK_LONG, DK_INT, DK_4BYTE, DK_QUAD, DK_8BYTE, DK_OCTA,

    DK_SINGLE, DK_FLOAT, DK_DOUBLE, DK_ALIGN, DK_ALIGN32, DK_BALIGN, DK_BALIGNW,

    DK_BALIGNL, DK_P2ALIGN, DK_P2ALIGNW, DK_P2ALIGNL, DK_ORG, DK_FILL, DK_ENDR,

    DK_BUNDLE_ALIGN_MODE, DK_BUNDLE_LOCK, DK_BUNDLE_UNLOCK,

    DK_ZERO, DK_EXTERN, DK_GLOBL, DK_GLOBAL,

    DK_LAZY_REFERENCE, DK_NO_DEAD_STRIP, DK_SYMBOL_RESOLVER, DK_PRIVATE_EXTERN,

    DK_REFERENCE, DK_WEAK_DEFINITION, DK_WEAK_REFERENCE,

    DK_WEAK_DEF_CAN_BE_HIDDEN, DK_COMM, DK_COMMON, DK_LCOMM, DK_ABORT,

    DK_INCLUDE, DK_INCBIN, DK_CODE16, DK_CODE16GCC, DK_REPT, DK_IRP, DK_IRPC,

    DK_IF, DK_IFEQ, DK_IFGE, DK_IFGT, DK_IFLE, DK_IFLT, DK_IFNE, DK_IFB,

    DK_IFNB, DK_IFC, DK_IFEQS, DK_IFNC, DK_IFNES, DK_IFDEF, DK_IFNDEF,

    DK_IFNOTDEF, DK_ELSEIF, DK_ELSE, DK_ENDIF,

    DK_SPACE, DK_SKIP, DK_FILE, DK_LINE, DK_LOC, DK_STABS,

    DK_CV_FILE, DK_CV_LOC, DK_CV_LINETABLE, DK_CV_INLINE_LINETABLE,

    DK_CV_STRINGTABLE, DK_CV_FILECHECKSUMS,

    DK_CFI_SECTIONS, DK_CFI_STARTPROC, DK_CFI_ENDPROC, DK_CFI_DEF_CFA,

    DK_CFI_DEF_CFA_OFFSET, DK_CFI_ADJUST_CFA_OFFSET, DK_CFI_DEF_CFA_REGISTER,

    DK_CFI_OFFSET, DK_CFI_REL_OFFSET, DK_CFI_PERSONALITY, DK_CFI_LSDA,

    DK_CFI_REMEMBER_STATE, DK_CFI_RESTORE_STATE, DK_CFI_SAME_VALUE,

    DK_CFI_RESTORE, DK_CFI_ESCAPE, DK_CFI_SIGNAL_FRAME, DK_CFI_UNDEFINED,

    DK_CFI_REGISTER, DK_CFI_WINDOW_SAVE,

    DK_MACROS_ON, DK_MACROS_OFF,

    DK_MACRO, DK_EXITM, DK_ENDM, DK_ENDMACRO, DK_PURGEM,

    DK_SLEB128, DK_ULEB128,

    DK_ERR, DK_ERROR, DK_WARNING,

    DK_NASM_BITS,    // NASM directive 'bits'

    DK_NASM_DEFAULT, // NASM directive 'default'

    DK_NASM_USE32,   // NASM directive 'use32'

    DK_END

  };

  /// \brief Maps directive name --> DirectiveKind enum, for

  /// directives parsed by this class.

  StringMap<DirectiveKind> DirectiveKindMap;

  // ".ascii", ".asciz", ".string"

  bool parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated);

  bool parseDirectiveReloc(SMLoc DirectiveLoc); // ".reloc"

  bool parseDirectiveValue(unsigned Size, unsigned int &KsError); // ".byte", ".long", ...

  bool parseDirectiveOctaValue(unsigned int &KsError); // ".octa"

  bool parseDirectiveRealValue(const fltSemantics &); // ".single", ...

  bool parseDirectiveFill(); // ".fill"

  bool parseDirectiveZero(); // ".zero"

  // ".set", ".equ", ".equiv"

  bool parseDirectiveSet(StringRef IDVal, bool allow_redef);

  bool parseDirectiveOrg(); // ".org"

  // ".align{,32}", ".p2align{,w,l}"

  bool parseDirectiveAlign(bool IsPow2, unsigned ValueSize);

  // ".file", ".line", ".loc", ".stabs"

  bool parseDirectiveFile(SMLoc DirectiveLoc);

  bool parseDirectiveLine();

  bool parseDirectiveLoc();

  bool parseDirectiveStabs();

  // ".cv_file", ".cv_loc", ".cv_linetable", "cv_inline_linetable"

  bool parseDirectiveCVFile();

  bool parseDirectiveCVLoc();

  bool parseDirectiveCVLinetable();

  bool parseDirectiveCVInlineLinetable();

  bool parseDirectiveCVStringTable();

  bool parseDirectiveCVFileChecksums();

  // .cfi directives

  bool parseDirectiveCFIRegister(SMLoc DirectiveLoc);

  bool parseDirectiveCFIWindowSave();

  bool parseDirectiveCFISections();

  bool parseDirectiveCFIStartProc();

  bool parseDirectiveCFIEndProc();

  bool parseDirectiveCFIDefCfaOffset();

  bool parseDirectiveCFIDefCfa(SMLoc DirectiveLoc);

  bool parseDirectiveCFIAdjustCfaOffset();

  bool parseDirectiveCFIDefCfaRegister(SMLoc DirectiveLoc);

  bool parseDirectiveCFIOffset(SMLoc DirectiveLoc);

  bool parseDirectiveCFIRelOffset(SMLoc DirectiveLoc);

  bool parseDirectiveCFIPersonalityOrLsda(bool IsPersonality);

  bool parseDirectiveCFIRememberState();

  bool parseDirectiveCFIRestoreState();

  bool parseDirectiveCFISameValue(SMLoc DirectiveLoc);

  bool parseDirectiveCFIRestore(SMLoc DirectiveLoc);

  bool parseDirectiveCFIEscape();

  bool parseDirectiveCFISignalFrame();

  bool parseDirectiveCFIUndefined(SMLoc DirectiveLoc);

  // macro directives

  bool parseDirectivePurgeMacro(SMLoc DirectiveLoc);

  bool parseDirectiveExitMacro(StringRef Directive);

  bool parseDirectiveEndMacro(StringRef Directive);

  bool parseDirectiveMacro(SMLoc DirectiveLoc);

  bool parseDirectiveMacrosOnOff(StringRef Directive);

  // ".bundle_align_mode"

  bool parseDirectiveBundleAlignMode();

  // ".bundle_lock"

  bool parseDirectiveBundleLock();

  // ".bundle_unlock"

  bool parseDirectiveBundleUnlock();

  // ".space", ".skip"

  bool parseDirectiveSpace(StringRef IDVal);

  // .sleb128 (Signed=true) and .uleb128 (Signed=false)

  bool parseDirectiveLEB128(bool Signed);

  /// \brief Parse a directive like ".globl" which

  /// accepts a single symbol (which should be a label or an external).

  bool parseDirectiveSymbolAttribute(MCSymbolAttr Attr);

  bool parseDirectiveComm(bool IsLocal); // ".comm" and ".lcomm"

  bool parseDirectiveAbort(); // ".abort"

  bool parseDirectiveInclude(); // ".include"

  bool parseDirectiveIncbin(); // ".incbin"

  // ".if", ".ifeq", ".ifge", ".ifgt" , ".ifle", ".iflt" or ".ifne"

  bool parseDirectiveIf(SMLoc DirectiveLoc, DirectiveKind DirKind);

  // ".ifb" or ".ifnb", depending on ExpectBlank.

  bool parseDirectiveIfb(SMLoc DirectiveLoc, bool ExpectBlank);

  // ".ifc" or ".ifnc", depending on ExpectEqual.

  bool parseDirectiveIfc(SMLoc DirectiveLoc, bool ExpectEqual);

  // ".ifeqs" or ".ifnes", depending on ExpectEqual.

  bool parseDirectiveIfeqs(SMLoc DirectiveLoc, bool ExpectEqual);

  // ".ifdef" or ".ifndef", depending on expect_defined

  bool parseDirectiveIfdef(SMLoc DirectiveLoc, bool expect_defined);

  bool parseDirectiveElseIf(SMLoc DirectiveLoc); // ".elseif"

  bool parseDirectiveElse(SMLoc DirectiveLoc); // ".else"

  bool parseDirectiveEndIf(SMLoc DirectiveLoc); // .endif

  bool parseEscapedString(std::string &Data) override;

  const MCExpr *applyModifierToExpr(const MCExpr *E,

                                    MCSymbolRefExpr::VariantKind Variant);

  // Macro-like directives

  MCAsmMacro *parseMacroLikeBody(SMLoc DirectiveLoc);

  void instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc,

                                raw_svector_ostream &OS);

  bool parseDirectiveRept(SMLoc DirectiveLoc, StringRef Directive);

  bool parseDirectiveIrp(SMLoc DirectiveLoc);  // ".irp"

  bool parseDirectiveIrpc(SMLoc DirectiveLoc); // ".irpc"

  bool parseDirectiveEndr(SMLoc DirectiveLoc); // ".endr"

  // "_emit" or "__emit"

  bool parseDirectiveMSEmit(SMLoc DirectiveLoc, ParseStatementInfo &Info,

                            size_t Len);

  // "align"

  bool parseDirectiveMSAlign(SMLoc DirectiveLoc, ParseStatementInfo &Info);

  // "end"

  bool parseDirectiveEnd(SMLoc DirectiveLoc);

  // ".err" or ".error"

  bool parseDirectiveError(SMLoc DirectiveLoc, bool WithMessage);

  // ".warning"

  bool parseDirectiveWarning(SMLoc DirectiveLoc);

  // "bits" (Nasm)

  bool parseNasmDirectiveBits();

  // "use32" (Nasm)

  bool parseNasmDirectiveUse32();

  // "default" (Nasm)

  bool parseNasmDirectiveDefault();

  bool isNasmDirective(StringRef str);  // is this str a NASM directive?

  bool isDirective(StringRef str);  // is this str a directive?

};

}

namespace llvm_ks {

extern MCAsmParserExtension *createDarwinAsmParser();

extern MCAsmParserExtension *createELFAsmParser();

extern MCAsmParserExtension *createCOFFAsmParser();

}

enum { DEFAULT_ADDRSPACE = 0 };

AsmParser::AsmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,

                     const MCAsmInfo &MAI)

    : Lexer(MAI), Ctx(Ctx), Out(Out), MAI(MAI), SrcMgr(SM),

      PlatformParser(nullptr), CurBuffer(SM.getMainFileID()),

      MacrosEnabledFlag(true), HadError(false), CppHashLineNumber(0),

      AssemblerDialect(~0U), IsDarwin(false), ParsingInlineAsm(false),

      NasmDefaultRel(false) {

  // Save the old handler.

  SavedDiagHandler = SrcMgr.getDiagHandler();

  SavedDiagContext = SrcMgr.getDiagContext();

  // Set our own handler which calls the saved handler.

  SrcMgr.setDiagHandler(DiagHandler, this);

  Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());

  // Initialize the platform / file format parser.

  PlatformParser.reset(createDarwinAsmParser());

  IsDarwin = true;

#if 0

  switch (Ctx.getObjectFileInfo()->getObjectFileType()) {

  case MCObjectFileInfo::IsCOFF:

    PlatformParser.reset(createCOFFAsmParser());

    break;

  case MCObjectFileInfo::IsMachO:

    PlatformParser.reset(createDarwinAsmParser());

    IsDarwin = true;

    break;

  case MCObjectFileInfo::IsELF:

    PlatformParser.reset(createELFAsmParser());

    break;

  }

#endif

  PlatformParser->Initialize(*this);

  initializeDirectiveKindMap(0);

  NumOfMacroInstantiations = 0;

}

AsmParser::~AsmParser() {

  assert((HadError || ActiveMacros.empty()) &&

         "Unexpected active macro instantiation!");

  // Restore the saved diagnostics handler and context for use during

  // finalization

  SrcMgr.setDiagHandler(SavedDiagHandler, SavedDiagContext);  

}

void AsmParser::printMacroInstantiations() {

  // Print the active macro instantiation stack.

  for (std::vector<MacroInstantiation *>::const_reverse_iterator

           it = ActiveMacros.rbegin(),

           ie = ActiveMacros.rend();

       it != ie; ++it)

    printMessage((*it)->InstantiationLoc, SourceMgr::DK_Note,

                 "while in macro instantiation");

}

void AsmParser::Note(SMLoc L, const Twine &Msg, ArrayRef<SMRange> Ranges) {

  printMessage(L, SourceMgr::DK_Note, Msg, Ranges);

  printMacroInstantiations();

}

bool AsmParser::Warning(SMLoc L, const Twine &Msg, ArrayRef<SMRange> Ranges) {

  if(getTargetParser().getTargetOptions().MCNoWarn)

    return false;

  if (getTargetParser().getTargetOptions().MCFatalWarnings)

    return Error(L, Msg, Ranges);

  printMessage(L, SourceMgr::DK_Warning, Msg, Ranges);

  printMacroInstantiations();

  return false;

}

bool AsmParser::Error(SMLoc L, const Twine &Msg, ArrayRef<SMRange> Ranges) {

  HadError = true;

  printMessage(L, SourceMgr::DK_Error, Msg, Ranges);

  printMacroInstantiations();

  return true;

}

bool AsmParser::enterIncludeFile(const std::string &Filename) {

  std::string IncludedFile;

  unsigned NewBuf =

      SrcMgr.AddIncludeFile(Filename, Lexer.getLoc(), IncludedFile);

  if (!NewBuf)

    return true;

  CurBuffer = NewBuf;

  Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());

  return false;

}

/// Process the specified .incbin file by searching for it in the include paths

/// then just emitting the byte contents of the file to the streamer. This

/// returns true on failure.

bool AsmParser::processIncbinFile(const std::string &Filename) {

  std::string IncludedFile;

  unsigned NewBuf =

      SrcMgr.AddIncludeFile(Filename, Lexer.getLoc(), IncludedFile);

  if (!NewBuf)

    return true;

  // Pick up the bytes from the file and emit them.

  getStreamer().EmitBytes(SrcMgr.getMemoryBuffer(NewBuf)->getBuffer());

  return false;

}

void AsmParser::jumpToLoc(SMLoc Loc, unsigned InBuffer) {

  CurBuffer = InBuffer ? InBuffer : SrcMgr.FindBufferContainingLoc(Loc);

  Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer(),

                  Loc.getPointer());

}

const AsmToken &AsmParser::Lex() {

  const AsmToken *tok = &Lexer.Lex();

  if (tok->is(AsmToken::Eof)) {

    // If this is the end of an included file, pop the parent file off the

    // include stack.

    SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer);

    if (ParentIncludeLoc != SMLoc()) {

      jumpToLoc(ParentIncludeLoc);

      tok = &Lexer.Lex();   // qq

    }

  }

  //if (tok->is(AsmToken::Error))

  //  Error(Lexer.getErrLoc(), Lexer.getErr());

  return *tok;

}

size_t AsmParser::Run(bool NoInitialTextSection, uint64_t Address, bool NoFinalize)

{

  // count number of statement

  size_t count = 0;

  // Create the initial section, if requested.

  if (!NoInitialTextSection)

    Out.InitSections(false);

  // Prime the lexer.

  Lex();

  if (!Lexer.isNot(AsmToken::Error)) {

    KsError = KS_ERR_ASM_TOKEN_INVALID;

    return 0;

  }

  HadError = false;

  AsmCond StartingCondState = TheCondState;

  // If we are generating dwarf for assembly source files save the initial text

  // section and generate a .file directive.

  if (getContext().getGenDwarfForAssembly()) {

    MCSection *Sec = getStreamer().getCurrentSection().first;

    if (!Sec->getBeginSymbol()) {

      MCSymbol *SectionStartSym = getContext().createTempSymbol();

      getStreamer().EmitLabel(SectionStartSym);

      Sec->setBeginSymbol(SectionStartSym);

    }

    bool InsertResult = getContext().addGenDwarfSection(Sec);

    assert(InsertResult && ".text section should not have debug info yet");

    (void)InsertResult;

    getContext().setGenDwarfFileNumber(getStreamer().EmitDwarfFileDirective(

        0, StringRef(), getContext().getMainFileName()));

  }

  // While we have input, parse each statement.

  while (Lexer.isNot(AsmToken::Eof)) {

    ParseStatementInfo Info;

    if (!parseStatement(Info, nullptr, Address)) {

      count++;

      continue;

    }

    //printf(">> 222 error = %u\n", Info.KsError);

    if (!KsError) {

        KsError = Info.KsError;

        return 0;

    }

    // We had an error, validate that one was emitted and recover by skipping to

    // the next line.

    // assert(HadError && "Parse statement returned an error, but none emitted!");

    //eatToEndOfStatement();

  }

  if (TheCondState.TheCond != StartingCondState.TheCond ||

      TheCondState.Ignore != StartingCondState.Ignore) {

    //return TokError("unmatched .ifs or .elses");

    KsError = KS_ERR_ASM_DIRECTIVE_TOKEN;

    return 0;

  }

  // Check to see that all assembler local symbols were actually defined.

  // Targets that don't do subsections via symbols may not want this, though,

  // so conservatively exclude them. Only do this if we're finalizing, though,

  // as otherwise we won't necessarilly have seen everything yet.

  if (!NoFinalize && MAI.hasSubsectionsViaSymbols()) {

    for (const auto &TableEntry : getContext().getSymbols()) {

      MCSymbol *Sym = TableEntry.getValue();

      // Variable symbols may not be marked as defined, so check those

      // explicitly. If we know it's a variable, we have a definition for

      // the purposes of this check.

      if (Sym->isTemporary() && !Sym->isVariable() && !Sym->isDefined()) {

        // FIXME: We would really like to refer back to where the symbol was

        // first referenced for a source location. We need to add something

        // to track that. Currently, we just point to the end of the file.

        //return Error(getLexer().getLoc(), "assembler local symbol '" +

        //                                      Sym->getName() + "' not defined");    // qq: set KsError, then return 0

        KsError = KS_ERR_ASM_SYMBOL_MISSING;

        return 0;

      }

    }

  }

  // Finalize the output stream if there are no errors and if the client wants

  // us to.

  if (!KsError) {

      if (!HadError && !NoFinalize)

          KsError = Out.Finish();

  } else

      Out.Finish();

  //return HadError || getContext().hadError();

  return count;

}

void AsmParser::checkForValidSection()

{

#if 0

  if (!ParsingInlineAsm && !getStreamer().getCurrentSection().first) {

    TokError("expected section directive before assembly directive");

    Out.InitSections(false);

  }

#endif

}

/// \brief Throw away the rest of the line for testing purposes.

void AsmParser::eatToEndOfStatement()

{

  while (Lexer.isNot(AsmToken::EndOfStatement) && Lexer.isNot(AsmToken::Eof))

    Lex();

  // Eat EOL.

  if (Lexer.is(AsmToken::EndOfStatement))

    Lex();

}

StringRef AsmParser::parseStringToEndOfStatement() {

  const char *Start = getTok().getLoc().getPointer();

  while (Lexer.isNot(AsmToken::EndOfStatement) && Lexer.isNot(AsmToken::Eof))

    Lex();

  const char *End = getTok().getLoc().getPointer();

  return StringRef(Start, End - Start);

}

StringRef AsmParser::parseStringToComma() {

  const char *Start = getTok().getLoc().getPointer();

  while (Lexer.isNot(AsmToken::EndOfStatement) &&

         Lexer.isNot(AsmToken::Comma) && Lexer.isNot(AsmToken::Eof))

    Lex();

  const char *End = getTok().getLoc().getPointer();

  return StringRef(Start, End - Start);

}

/// \brief Parse a paren expression and return it.

/// NOTE: This assumes the leading '(' has already been consumed.

///

/// parenexpr ::= expr)

///

bool AsmParser::parseParenExpr(const MCExpr *&Res, SMLoc &EndLoc) {

  if (parseExpression(Res))

    return true;

  if (Lexer.isNot(AsmToken::RParen))

    //return TokError("expected ')' in parentheses expression");

    return true;

  EndLoc = Lexer.getTok().getEndLoc();

  Lex();

  return false;

}

/// \brief Parse a bracket expression and return it.

/// NOTE: This assumes the leading '[' has already been consumed.

///

/// bracketexpr ::= expr]

///

bool AsmParser::parseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc) {

  if (parseExpression(Res))

    return true;

  if (Lexer.isNot(AsmToken::RBrac)) {

    //return TokError("expected ']' in brackets expression");

    KsError = KS_ERR_ASM_INVALIDOPERAND;

    return true;

  }

  EndLoc = Lexer.getTok().getEndLoc();

  Lex();

  return false;

}

bool AsmParser::parsePrimaryExprAux(const MCExpr *&Res, SMLoc &EndLoc, unsigned int depth)

{

  if (depth > 0x100) {

    KsError = KS_ERR_ASM_EXPR_TOKEN;

    return true;

  }

  SMLoc FirstTokenLoc = getLexer().getLoc();

  AsmToken::TokenKind FirstTokenKind = Lexer.getKind();

  switch (FirstTokenKind) {

  default:

    //return TokError("unknown token in expression");

    KsError = KS_ERR_ASM_EXPR_TOKEN;

    return true;

  // If we have an error assume that we've already handled it.

  case AsmToken::Error:

    return true;

  case AsmToken::Exclaim:

    Lex(); // Eat the operator.

    if (parsePrimaryExprAux(Res, EndLoc, depth+1))

      return true;

    Res = MCUnaryExpr::createLNot(Res, getContext());

    return false;

  case AsmToken::Dollar:

  case AsmToken::At:

  case AsmToken::String:

  case AsmToken::Identifier: {

    StringRef Identifier;

    if (parseIdentifier(Identifier)) {

      if (FirstTokenKind == AsmToken::Dollar) {

        if (Lexer.getMAI().getDollarIsPC()) {

          // This is a '$' reference, which references the current PC.  Emit a

          // temporary label to the streamer and refer to it.

          MCSymbol *Sym = Ctx.createTempSymbol();

          Out.EmitLabel(Sym);

          Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None,

                                        getContext());

          EndLoc = FirstTokenLoc;

          return false;

        }

        //return Error(FirstTokenLoc, "invalid token in expression");

        KsError = KS_ERR_ASM_INVALIDOPERAND;

        return true;

      }

    }

    // Parse symbol variant

    std::pair<StringRef, StringRef> Split;

    if (!MAI.useParensForSymbolVariant()) {

      if (FirstTokenKind == AsmToken::String) {

        if (Lexer.is(AsmToken::At)) {

          Lexer.Lex(); // eat @

          //SMLoc AtLoc = getLexer().getLoc();

          StringRef VName;

          if (parseIdentifier(VName)) {

            //return Error(AtLoc, "expected symbol variant after '@'");

            KsError = KS_ERR_ASM_INVALIDOPERAND;

            return true;

          }

          Split = std::make_pair(Identifier, VName);

        }

      } else {

        Split = Identifier.split('@');

      }

    } else if (Lexer.is(AsmToken::LParen)) {

      Lexer.Lex(); // eat (

      StringRef VName;

      parseIdentifier(VName);

      if (Lexer.isNot(AsmToken::RParen)) {

          //return Error(Lexer.getTok().getLoc(),

          //             "unexpected token in variant, expected ')'");

          KsError = KS_ERR_ASM_INVALIDOPERAND;

          return true;

      }

      Lexer.Lex(); // eat )

      Split = std::make_pair(Identifier, VName);

    }

    EndLoc = SMLoc::getFromPointer(Identifier.end());

    // This is a symbol reference.

    StringRef SymbolName = Identifier;

    MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;

    // Lookup the symbol variant if used.

    if (Split.second.size()) {

      Variant = MCSymbolRefExpr::getVariantKindForName(Split.second);

      if (Variant != MCSymbolRefExpr::VK_Invalid) {

        SymbolName = Split.first;

      } else if (MAI.doesAllowAtInName() && !MAI.useParensForSymbolVariant()) {

        Variant = MCSymbolRefExpr::VK_None;

      } else {

        //return Error(SMLoc::getFromPointer(Split.second.begin()),

        //             "invalid variant '" + Split.second + "'");

        KsError = KS_ERR_ASM_INVALIDOPERAND;

        return true;

      }

    }

    if (SymbolName.empty()) {

        return true;

    }

    MCSymbol *Sym = getContext().getOrCreateSymbol(SymbolName);

    // If this is an absolute variable reference, substitute it now to preserve

    // semantics in the face of reassignment.

    if (Sym->isVariable() &&

        isa<MCConstantExpr>(Sym->getVariableValue(/*SetUsed*/ false))) {

      if (Variant) {

        //return Error(EndLoc, "unexpected modifier on variable reference");

        KsError = KS_ERR_ASM_INVALIDOPERAND;

        return true;

      }

      Res = Sym->getVariableValue(/*SetUsed*/ false);

      return false;

    }

    // Otherwise create a symbol ref.

    Res = MCSymbolRefExpr::create(Sym, Variant, getContext());

    return false;

  }

  case AsmToken::BigNum:

    // return TokError("literal value out of range for directive");

    KsError = KS_ERR_ASM_DIRECTIVE_VALUE_RANGE;

    return true;

  case AsmToken::Integer: {

    //SMLoc Loc = getTok().getLoc();

    bool valid;

    int64_t IntVal = getTok().getIntVal(valid);

    if (!valid) {

        return true;

    }

    Res = MCConstantExpr::create(IntVal, getContext());

    EndLoc = Lexer.getTok().getEndLoc();

    Lex(); // Eat token.

    // Look for 'b' or 'f' following an Integer as a directional label

    if (Lexer.getKind() == AsmToken::Identifier) {

      StringRef IDVal = getTok().getString();

      // Lookup the symbol variant if used.

      std::pair<StringRef, StringRef> Split = IDVal.split('@');

      MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;

      if (Split.first.size() != IDVal.size()) {

        Variant = MCSymbolRefExpr::getVariantKindForName(Split.second);

        if (Variant == MCSymbolRefExpr::VK_Invalid) {

          // return TokError("invalid variant '" + Split.second + "'");

          KsError = KS_ERR_ASM_VARIANT_INVALID;

          return true;

        }

        IDVal = Split.first;

      }

      if (IDVal == "f" || IDVal == "b") {

        bool valid;

        MCSymbol *Sym =

            Ctx.getDirectionalLocalSymbol(IntVal, IDVal == "b", valid);

        if (!valid)

            return true;

        Res = MCSymbolRefExpr::create(Sym, Variant, getContext());

        if (IDVal == "b" && Sym->isUndefined()) {

          //return Error(Loc, "invalid reference to undefined symbol");

          KsError = KS_ERR_ASM_INVALIDOPERAND;

          return true;

        }

        EndLoc = Lexer.getTok().getEndLoc();

        Lex(); // Eat identifier.

      }

    }

    return false;

  }

  case AsmToken::Real: {

    APFloat RealVal(APFloat::IEEEdouble, getTok().getString());

    uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue();

    Res = MCConstantExpr::create(IntVal, getContext());

    EndLoc = Lexer.getTok().getEndLoc();

    Lex(); // Eat token.

    return false;

  }

  case AsmToken::Dot: {

    // This is a '.' reference, which references the current PC.  Emit a

    // temporary label to the streamer and refer to it.

    MCSymbol *Sym = Ctx.createTempSymbol();

    Out.EmitLabel(Sym);

    Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());

    EndLoc = Lexer.getTok().getEndLoc();

    Lex(); // Eat identifier.

    return false;

  }

  case AsmToken::LParen:

    Lex(); // Eat the '('.

    return parseParenExpr(Res, EndLoc);

  case AsmToken::LBrac:

    if (!PlatformParser->HasBracketExpressions()) {

      // return TokError("brackets expression not supported on this target");

      KsError = KS_ERR_ASM_EXPR_BRACKET;

      return true;

    }

    Lex(); // Eat the '['.

    return parseBracketExpr(Res, EndLoc);

  case AsmToken::Minus:

    Lex(); // Eat the operator.

    if (parsePrimaryExprAux(Res, EndLoc, depth+1))

      return true;

    Res = MCUnaryExpr::createMinus(Res, getContext());

    return false;

  case AsmToken::Plus:

    Lex(); // Eat the operator.

    if (parsePrimaryExprAux(Res, EndLoc, depth+1))

      return true;

    Res = MCUnaryExpr::createPlus(Res, getContext());

    return false;

  case AsmToken::Tilde:

    Lex(); // Eat the operator.

    if (parsePrimaryExprAux(Res, EndLoc, depth+1))

      return true;

    Res = MCUnaryExpr::createNot(Res, getContext());

    return false;

  }

}

/// \brief Parse a primary expression and return it.

///  primaryexpr ::= (parenexpr

///  primaryexpr ::= symbol