COFFAsmParser.cpp | Explore in Territory

//===- COFFAsmParser.cpp - COFF Assembly Parser ---------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/ADT/Twine.h"
#include "llvm/BinaryFormat/COFF.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCDirectives.h"
#include "llvm/MC/MCParser/MCAsmLexer.h"
#include "llvm/MC/MCParser/MCAsmParserExtension.h"
#include "llvm/MC/MCSectionCOFF.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/MC/SectionKind.h"
#include "llvm/Support/SMLoc.h"
#include "llvm/TargetParser/Triple.h"
#include <cassert>
#include <cstdint>
#include <limits>
#include <utility>

usingnamespacellvm;

namespace {

class COFFAsmParser : public MCAsmParserExtension { … };

} // end anonymous namespace.

bool COFFAsmParser::ParseSectionFlags(StringRef SectionName,
                                      StringRef FlagsString, unsigned *Flags) { … }

/// ParseDirectiveSymbolAttribute
///  ::= { ".weak", ... } [ identifier ( , identifier )* ]
bool COFFAsmParser::ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) { … }

bool COFFAsmParser::ParseDirectiveCGProfile(StringRef S, SMLoc Loc) { … }

bool COFFAsmParser::ParseSectionSwitch(StringRef Section,
                                       unsigned Characteristics) { … }

bool COFFAsmParser::ParseSectionSwitch(StringRef Section,
                                       unsigned Characteristics,
                                       StringRef COMDATSymName,
                                       COFF::COMDATType Type) { … }

bool COFFAsmParser::ParseSectionName(StringRef &SectionName) { … }

bool COFFAsmParser::ParseDirectiveSection(StringRef directive, SMLoc loc) { … }

// .section name [, "flags"] [, identifier [ identifier ], identifier]
// .pushsection <same as above>
//
// Supported flags:
//   a: Ignored.
//   b: BSS section (uninitialized data)
//   d: data section (initialized data)
//   n: "noload" section (removed by linker)
//   D: Discardable section
//   r: Readable section
//   s: Shared section
//   w: Writable section
//   x: Executable section
//   y: Not-readable section (clears 'r')
//
// Subsections are not supported.
bool COFFAsmParser::parseSectionArguments(StringRef, SMLoc) { … }

bool COFFAsmParser::ParseDirectivePushSection(StringRef directive, SMLoc loc) { … }

bool COFFAsmParser::ParseDirectivePopSection(StringRef, SMLoc) { … }

bool COFFAsmParser::ParseDirectiveDef(StringRef, SMLoc) { … }

bool COFFAsmParser::ParseDirectiveScl(StringRef, SMLoc) { … }

bool COFFAsmParser::ParseDirectiveType(StringRef, SMLoc) { … }

bool COFFAsmParser::ParseDirectiveEndef(StringRef, SMLoc) { … }

bool COFFAsmParser::ParseDirectiveSecRel32(StringRef, SMLoc) { … }

bool COFFAsmParser::ParseDirectiveRVA(StringRef, SMLoc) { … }

bool COFFAsmParser::ParseDirectiveSafeSEH(StringRef, SMLoc) { … }

bool COFFAsmParser::ParseDirectiveSecIdx(StringRef, SMLoc) { … }

bool COFFAsmParser::ParseDirectiveSymIdx(StringRef, SMLoc) { … }

/// ::= [ identifier ]
bool COFFAsmParser::parseCOMDATType(COFF::COMDATType &Type) { … }

/// ParseDirectiveLinkOnce
///  ::= .linkonce [ identifier ]
bool COFFAsmParser::ParseDirectiveLinkOnce(StringRef, SMLoc Loc) { … }

bool COFFAsmParser::ParseSEHDirectiveStartProc(StringRef, SMLoc Loc) { … }

bool COFFAsmParser::ParseSEHDirectiveEndProc(StringRef, SMLoc Loc) { … }

bool COFFAsmParser::ParseSEHDirectiveEndFuncletOrFunc(StringRef, SMLoc Loc) { … }

bool COFFAsmParser::ParseSEHDirectiveStartChained(StringRef, SMLoc Loc) { … }

bool COFFAsmParser::ParseSEHDirectiveEndChained(StringRef, SMLoc Loc) { … }

bool COFFAsmParser::ParseSEHDirectiveHandler(StringRef, SMLoc Loc) { … }

bool COFFAsmParser::ParseSEHDirectiveHandlerData(StringRef, SMLoc Loc) { … }

bool COFFAsmParser::ParseSEHDirectiveAllocStack(StringRef, SMLoc Loc) { … }

bool COFFAsmParser::ParseSEHDirectiveEndProlog(StringRef, SMLoc Loc) { … }

bool COFFAsmParser::ParseAtUnwindOrAtExcept(bool &unwind, bool &except) { … }

namespace llvm {

MCAsmParserExtension *createCOFFAsmParser() { … }

} // end namespace llvm
llvm/llvm/lib/MC/MCParser/COFFAsmParser.cpp
