llvm/llvm/lib/MC/MCParser/ELFAsmParser.cpp

//===- ELFAsmParser.cpp - ELF 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/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/BinaryFormat/ELF.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCDirectives.h"
#include "llvm/MC/MCParser/MCAsmLexer.h"
#include "llvm/MC/MCParser/MCAsmParser.h"
#include "llvm/MC/MCParser/MCAsmParserExtension.h"
#include "llvm/MC/MCSectionELF.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/MC/MCSymbolELF.h"
#include "llvm/MC/SectionKind.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/SMLoc.h"
#include <cassert>
#include <cstdint>
#include <utility>

usingnamespacellvm;

namespace {

class ELFAsmParser : public MCAsmParserExtension { … };

} // end anonymous namespace

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

bool ELFAsmParser::ParseSectionSwitch(StringRef Section, unsigned Type,
                                      unsigned Flags, SectionKind Kind) { … }

bool ELFAsmParser::ParseDirectiveSize(StringRef, SMLoc) { … }

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

static unsigned parseSectionFlags(const Triple &TT, StringRef flagsStr,
                                  bool *UseLastGroup) { … }

unsigned ELFAsmParser::parseSunStyleSectionFlags() { … }


bool ELFAsmParser::ParseDirectivePushSection(StringRef s, SMLoc loc) { … }

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

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

bool ELFAsmParser::maybeParseSectionType(StringRef &TypeName) { … }

bool ELFAsmParser::parseMergeSize(int64_t &Size) { … }

bool ELFAsmParser::parseGroup(StringRef &GroupName, bool &IsComdat) { … }

bool ELFAsmParser::parseLinkedToSym(MCSymbolELF *&LinkedToSym) { … }

bool ELFAsmParser::maybeParseUniqueID(int64_t &UniqueID) { … }

static bool hasPrefix(StringRef SectionName, StringRef Prefix) { … }

static bool allowSectionTypeMismatch(const Triple &TT, StringRef SectionName,
                                     unsigned Type) { … }

bool ELFAsmParser::ParseSectionArguments(bool IsPush, SMLoc loc) { … }

bool ELFAsmParser::ParseDirectivePrevious(StringRef DirName, SMLoc) { … }

static MCSymbolAttr MCAttrForString(StringRef Type) { … }

/// ParseDirectiveELFType
///  ::= .type identifier , STT_<TYPE_IN_UPPER_CASE>
///  ::= .type identifier , #attribute
///  ::= .type identifier , @attribute
///  ::= .type identifier , %attribute
///  ::= .type identifier , "attribute"
bool ELFAsmParser::ParseDirectiveType(StringRef, SMLoc) { … }

/// ParseDirectiveIdent
///  ::= .ident string
bool ELFAsmParser::ParseDirectiveIdent(StringRef, SMLoc) { … }

/// ParseDirectiveSymver
///  ::= .symver foo, bar2@zed
bool ELFAsmParser::ParseDirectiveSymver(StringRef, SMLoc) { … }

/// ParseDirectiveVersion
///  ::= .version string
bool ELFAsmParser::ParseDirectiveVersion(StringRef, SMLoc) { … }

/// ParseDirectiveWeakref
///  ::= .weakref foo, bar
bool ELFAsmParser::ParseDirectiveWeakref(StringRef, SMLoc) { … }

bool ELFAsmParser::ParseDirectiveSubsection(StringRef, SMLoc) { … }

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

namespace llvm {

MCAsmParserExtension *createELFAsmParser() { … }

} // end namespace llvm