DriverUtils.cpp | Explore in Territory

//===- DriverUtils.cpp ----------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file contains utility functions for the driver. Because there
// are so many small functions, we created this separate file to make
// Driver.cpp less cluttered.
//
//===----------------------------------------------------------------------===//

#include "COFFLinkerContext.h"
#include "Driver.h"
#include "Symbols.h"
#include "lld/Common/ErrorHandler.h"
#include "lld/Common/Memory.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/BinaryFormat/COFF.h"
#include "llvm/IR/Mangler.h"
#include "llvm/Object/COFF.h"
#include "llvm/Object/WindowsResource.h"
#include "llvm/Option/Arg.h"
#include "llvm/Option/ArgList.h"
#include "llvm/Option/Option.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/FileUtilities.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/Process.h"
#include "llvm/Support/Program.h"
#include "llvm/Support/TimeProfiler.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/WindowsManifest/WindowsManifestMerger.h"
#include <limits>
#include <memory>
#include <optional>

usingnamespacellvm::COFF;
usingnamespacellvm::object;
usingnamespacellvm::opt;
usingnamespacellvm;
Process;

namespace lld {
namespace coff {
namespace {

const uint16_t SUBLANG_ENGLISH_US = …;
const uint16_t RT_MANIFEST = …;

class Executor { … };

} // anonymous namespace

// Parses a string in the form of "<integer>[,<integer>]".
void LinkerDriver::parseNumbers(StringRef arg, uint64_t *addr, uint64_t *size) { … }

// Parses a string in the form of "<integer>[.<integer>]".
// If second number is not present, Minor is set to 0.
void LinkerDriver::parseVersion(StringRef arg, uint32_t *major,
                                uint32_t *minor) { … }

void LinkerDriver::parseGuard(StringRef fullArg) { … }

// Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]".
void LinkerDriver::parseSubsystem(StringRef arg, WindowsSubsystem *sys,
                                  uint32_t *major, uint32_t *minor,
                                  bool *gotVersion) { … }

// Parse a string of the form of "<from>=<to>".
// Results are directly written to Config.
void LinkerDriver::parseAlternateName(StringRef s) { … }

// Parse a string of the form of "<from>=<to>".
// Results are directly written to Config.
void LinkerDriver::parseMerge(StringRef s) { … }

void LinkerDriver::parsePDBPageSize(StringRef s) { … }

static uint32_t parseSectionAttributes(StringRef s) { … }

// Parses /section option argument.
void LinkerDriver::parseSection(StringRef s) { … }

// Parses /aligncomm option argument.
void LinkerDriver::parseAligncomm(StringRef s) { … }

// Parses /functionpadmin option argument.
void LinkerDriver::parseFunctionPadMin(llvm::opt::Arg *a) { … }

// Parses /dependentloadflag option argument.
void LinkerDriver::parseDependentLoadFlags(llvm::opt::Arg *a) { … }

// Parses a string in the form of "EMBED[,=<integer>]|NO".
// Results are directly written to
// Config.
void LinkerDriver::parseManifest(StringRef arg) { … }

// Parses a string in the form of "level=<string>|uiAccess=<string>|NO".
// Results are directly written to Config.
void LinkerDriver::parseManifestUAC(StringRef arg) { … }

// Parses a string in the form of "cd|net[,(cd|net)]*"
// Results are directly written to Config.
void LinkerDriver::parseSwaprun(StringRef arg) { … }

// An RAII temporary file class that automatically removes a temporary file.
namespace {
class TemporaryFile { … };
}

std::string LinkerDriver::createDefaultXml() { … }

std::string
LinkerDriver::createManifestXmlWithInternalMt(StringRef defaultXml) { … }

std::string
LinkerDriver::createManifestXmlWithExternalMt(StringRef defaultXml) { … }

std::string LinkerDriver::createManifestXml() { … }

std::unique_ptr<WritableMemoryBuffer>
LinkerDriver::createMemoryBufferForManifestRes(size_t manifestSize) { … }

static void writeResFileHeader(char *&buf) { … }

static void writeResEntryHeader(char *&buf, size_t manifestSize,
                                int manifestID) { … }

// Create a resource file containing a manifest XML.
std::unique_ptr<MemoryBuffer> LinkerDriver::createManifestRes() { … }

void LinkerDriver::createSideBySideManifest() { … }

// Parse a string in the form of
// "<name>[=<internalname>][,@ordinal[,NONAME]][,DATA][,PRIVATE]"
// or "<name>=<dllname>.<name>".
// Used for parsing /export arguments.
Export LinkerDriver::parseExport(StringRef arg) { … }

// Convert stdcall/fastcall style symbols into unsuffixed symbols,
// with or without a leading underscore. (MinGW specific.)
static StringRef killAt(StringRef sym, bool prefix) { … }

static StringRef exportSourceName(ExportSource s) { … }

// Performs error checking on all /export arguments.
// It also sets ordinals.
void LinkerDriver::fixupExports() { … }

void LinkerDriver::assignExportOrdinals() { … }

// Parses a string in the form of "key=value" and check
// if value matches previous values for the same key.
void LinkerDriver::checkFailIfMismatch(StringRef arg, InputFile *source) { … }

// Convert Windows resource files (.res files) to a .obj file.
// Does what cvtres.exe does, but in-process and cross-platform.
MemoryBufferRef LinkerDriver::convertResToCOFF(ArrayRef<MemoryBufferRef> mbs,
                                               ArrayRef<ObjFile *> objs) { … }

// Create OptTable

// Create prefix string literals used in Options.td
#define PREFIX …
#include "Options.inc"
#undef PREFIX

// Create table mapping all options defined in Options.td
static constexpr llvm::opt::OptTable::Info infoTable[] = …;

COFFOptTable::COFFOptTable() : … { … }

// Set color diagnostics according to --color-diagnostics={auto,always,never}
// or --no-color-diagnostics flags.
static void handleColorDiagnostics(opt::InputArgList &args) { … }

static cl::TokenizerCallback getQuotingStyle(opt::InputArgList &args) { … }

ArgParser::ArgParser(COFFLinkerContext &c) : … { … }

// Parses a given list of options.
opt::InputArgList ArgParser::parse(ArrayRef<const char *> argv) { … }

// Tokenizes and parses a given string as command line in .drective section.
ParsedDirectives ArgParser::parseDirectives(StringRef s) { … }

// link.exe has an interesting feature. If LINK or _LINK_ environment
// variables exist, their contents are handled as command line strings.
// So you can pass extra arguments using them.
void ArgParser::addLINK(SmallVector<const char *, 256> &argv) { … }

std::vector<const char *> ArgParser::tokenize(StringRef s) { … }

void LinkerDriver::printHelp(const char *argv0) { … }

} // namespace coff
} // namespace lld
llvm/lld/COFF/DriverUtils.cpp
