maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[WebAssembly] Wrap definitions in namespace lld { namespace wasm {. NFC 

Similar to D68323, but for wasm.

Reviewed By: ruiu

Differential Revision: https://reviews.llvm.org/D68759

llvm-svn: 374279
This commit is contained in:
Fangrui Song 2019-10-10 05:25:39 +00:00
parent c05a875c8c
commit 33c59abf5c
11 changed files with 187 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
lld/wasm/Driver.cpp
View File

@ -37,10 +37,9 @@ using namespace llvm::object;
using namespace llvm::sys;
using namespace llvm::wasm;
using namespace lld;
using namespace lld::wasm;
Configuration *lld::wasm::config;
namespace lld {
namespace wasm {
Configuration *config;
namespace {
@ -79,8 +78,7 @@ private:
};
} // anonymous namespace
bool lld::wasm::link(ArrayRef<const char *> args, bool canExitEarly,
raw_ostream &error) {
bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &error) {
errorHandler().logName = args::getFilenameWithoutExe(args[0]);
errorHandler().errorOS = &error;
errorHandler().errorLimitExceededMsg =
@ -787,3 +785,6 @@ void LinkerDriver::link(ArrayRef<const char *> argsArr) {
// Write the result to the file.
writeResult();
}
} // namespace wasm
} // namespace lld

11
lld/wasm/InputChunks.cpp
View File

@ -19,10 +19,9 @@
using namespace llvm;
using namespace llvm::wasm;
using namespace llvm::support::endian;
using namespace lld;
using namespace lld::wasm;
StringRef lld::relocTypeToString(uint8_t relocType) {
namespace lld {
StringRef relocTypeToString(uint8_t relocType) {
switch (relocType) {
#define WASM_RELOC(NAME, REL) \
case REL: \
@ -33,10 +32,11 @@ StringRef lld::relocTypeToString(uint8_t relocType) {
llvm_unreachable("unknown reloc type");
}
std::string lld::toString(const InputChunk *c) {
std::string toString(const wasm::InputChunk *c) {
return (toString(c->file) + ":(" + c->getName() + ")").str();
}
namespace wasm {
StringRef InputChunk::getComdatName() const {
uint32_t index = getComdat();
if (index == UINT32_MAX)
@ -346,3 +346,6 @@ void InputSegment::generateRelocationCode(raw_ostream &os) const {
writeUleb128(os, 0, "offset");
}
}
} // namespace wasm
} // namespace lld

35
lld/wasm/InputFiles.cpp
View File

@ -22,16 +22,27 @@
#define DEBUG_TYPE "lld"
using namespace lld;
using namespace lld::wasm;
using namespace llvm;
using namespace llvm::object;
using namespace llvm::wasm;
std::unique_ptr<llvm::TarWriter> lld::wasm::tar;
namespace lld {
Optional<MemoryBufferRef> lld::wasm::readFile(StringRef path) {
// Returns a string in the format of "foo.o" or "foo.a(bar.o)".
std::string toString(const wasm::InputFile *file) {
if (!file)
return "<internal>";
if (file->archiveName.empty())
return file->getName();
return (file->archiveName + "(" + file->getName() + ")").str();
}
namespace wasm {
std::unique_ptr<llvm::TarWriter> tar;
Optional<MemoryBufferRef> readFile(StringRef path) {
log("Loading: " + path);
auto mbOrErr = MemoryBuffer::getFile(path);
@ -48,7 +59,7 @@ Optional<MemoryBufferRef> lld::wasm::readFile(StringRef path) {
return mbref;
}
InputFile *lld::wasm::createObjectFile(MemoryBufferRef mb,
InputFile *createObjectFile(MemoryBufferRef mb,
StringRef archiveName) {
file_magic magic = identify_magic(mb.getBuffer());
if (magic == file_magic::wasm_object) {
@ -542,13 +553,5 @@ void BitcodeFile::parse() {
symbols.push_back(createBitcodeSymbol(keptComdats, objSym, *this));
}
// Returns a string in the format of "foo.o" or "foo.a(bar.o)".
std::string lld::toString(const wasm::InputFile *file) {
if (!file)
return "<internal>";
if (file->archiveName.empty())
return file->getName();
return (file->archiveName + "(" + file->getName() + ")").str();
}
} // namespace wasm
} // namespace lld

7
lld/wasm/LTO.cpp
View File

@ -36,9 +36,9 @@
#include <vector>
using namespace llvm;
using namespace lld;
using namespace lld::wasm;
namespace lld {
namespace wasm {
static std::unique_ptr<lto::LTO> createLTO() {
lto::Config c;
c.Options = initTargetOptionsFromCodeGenFlags();
@ -165,3 +165,6 @@ std::vector<StringRef> BitcodeCompiler::compile() {
return ret;
}
} // namespace wasm
} // namespace lld

22
lld/wasm/OutputSections.cpp
View File

@ -20,9 +20,17 @@
using namespace llvm;
using namespace llvm::wasm;
using namespace lld;
using namespace lld::wasm;
namespace lld {
// Returns a string, e.g. "FUNCTION(.text)".
std::string toString(const wasm::OutputSection &sec) {
if (!sec.name.empty())
return (sec.getSectionName() + "(" + sec.name + ")").str();
return sec.getSectionName();
}
namespace wasm {
static StringRef sectionTypeToString(uint32_t sectionType) {
switch (sectionType) {
case WASM_SEC_CUSTOM:
@ -58,13 +66,6 @@ static StringRef sectionTypeToString(uint32_t sectionType) {
}
}
// Returns a string, e.g. "FUNCTION(.text)".
std::string lld::toString(const OutputSection &sec) {
if (!sec.name.empty())
return (sec.getSectionName() + "(" + sec.name + ")").str();
return sec.getSectionName();
}
StringRef OutputSection::getSectionName() const {
return sectionTypeToString(type);
}
@ -248,3 +249,6 @@ void CustomSection::writeRelocations(raw_ostream &os) const {
for (const InputSection *s : inputSections)
s->writeRelocations(os);
}
} // namespace wasm
} // namespace lld

10
lld/wasm/Relocations.cpp
View File

@ -14,9 +14,8 @@
using namespace llvm;
using namespace llvm::wasm;
using namespace lld;
using namespace lld::wasm;
namespace lld {
namespace wasm {
static bool requiresGOTAccess(const Symbol *sym) {
return config->isPic && !sym->isHidden() && !sym->isLocal();
}
@ -54,7 +53,7 @@ static void addGOTEntry(Symbol *sym) {
out.globalSec->addStaticGOTEntry(sym);
}
void lld::wasm::scanRelocations(InputChunk *chunk) {
void scanRelocations(InputChunk *chunk) {
if (!chunk->live)
return;
ObjFile *file = chunk->file;
@ -113,3 +112,6 @@ void lld::wasm::scanRelocations(InputChunk *chunk) {
}
}
} // namespace wasm
} // namespace lld

9
lld/wasm/SymbolTable.cpp
View File

@ -21,10 +21,10 @@
using namespace llvm;
using namespace llvm::wasm;
using namespace llvm::object;
using namespace lld;
using namespace lld::wasm;
SymbolTable *lld::wasm::symtab;
namespace lld {
namespace wasm {
SymbolTable *symtab;
void SymbolTable::addFile(InputFile *file) {
log("Processing: " + toString(file));
@ -692,3 +692,6 @@ void SymbolTable::handleSymbolVariants() {
}
}
}
} // namespace wasm
} // namespace lld

88
lld/wasm/Symbols.cpp
View File

@ -21,9 +21,45 @@
using namespace llvm;
using namespace llvm::wasm;
using namespace lld;
using namespace lld::wasm;
namespace lld {
std::string toString(const wasm::Symbol &sym) {
return maybeDemangleSymbol(sym.getName());
}
std::string maybeDemangleSymbol(StringRef name) {
if (wasm::config->demangle)
return demangleItanium(name);
return name;
}
std::string toString(wasm::Symbol::Kind kind) {
switch (kind) {
case wasm::Symbol::DefinedFunctionKind:
return "DefinedFunction";
case wasm::Symbol::DefinedDataKind:
return "DefinedData";
case wasm::Symbol::DefinedGlobalKind:
return "DefinedGlobal";
case wasm::Symbol::DefinedEventKind:
return "DefinedEvent";
case wasm::Symbol::UndefinedFunctionKind:
return "UndefinedFunction";
case wasm::Symbol::UndefinedDataKind:
return "UndefinedData";
case wasm::Symbol::UndefinedGlobalKind:
return "UndefinedGlobal";
case wasm::Symbol::LazyKind:
return "LazyKind";
case wasm::Symbol::SectionKind:
return "SectionKind";
case wasm::Symbol::OutputSectionKind:
return "OutputSectionKind";
}
llvm_unreachable("invalid symbol kind");
}
namespace wasm {
DefinedFunction *WasmSym::callCtors;
DefinedFunction *WasmSym::initMemory;
DefinedFunction *WasmSym::applyRelocs;
@ -298,49 +334,12 @@ const OutputSectionSymbol *SectionSymbol::getOutputSectionSymbol() const {
void LazySymbol::fetch() { cast<ArchiveFile>(file)->addMember(&archiveSymbol); }
std::string lld::toString(const wasm::Symbol &sym) {
return lld::maybeDemangleSymbol(sym.getName());
}
std::string lld::maybeDemangleSymbol(StringRef name) {
if (config->demangle)
return demangleItanium(name);
return name;
}
std::string lld::toString(wasm::Symbol::Kind kind) {
switch (kind) {
case wasm::Symbol::DefinedFunctionKind:
return "DefinedFunction";
case wasm::Symbol::DefinedDataKind:
return "DefinedData";
case wasm::Symbol::DefinedGlobalKind:
return "DefinedGlobal";
case wasm::Symbol::DefinedEventKind:
return "DefinedEvent";
case wasm::Symbol::UndefinedFunctionKind:
return "UndefinedFunction";
case wasm::Symbol::UndefinedDataKind:
return "UndefinedData";
case wasm::Symbol::UndefinedGlobalKind:
return "UndefinedGlobal";
case wasm::Symbol::LazyKind:
return "LazyKind";
case wasm::Symbol::SectionKind:
return "SectionKind";
case wasm::Symbol::OutputSectionKind:
return "OutputSectionKind";
}
llvm_unreachable("invalid symbol kind");
}
void lld::wasm::printTraceSymbolUndefined(StringRef name, const InputFile* file) {
void printTraceSymbolUndefined(StringRef name, const InputFile* file) {
message(toString(file) + ": reference to " + name);
}
// Print out a log message for --trace-symbol.
void lld::wasm::printTraceSymbol(Symbol *sym) {
void printTraceSymbol(Symbol *sym) {
// Undefined symbols are traced via printTraceSymbolUndefined
if (sym->isUndefined())
return;
@ -354,5 +353,8 @@ void lld::wasm::printTraceSymbol(Symbol *sym) {
message(toString(sym->getFile()) + s + sym->getName());
}
const char *lld::wasm::defaultModule = "env";
const char *lld::wasm::functionTableName = "__indirect_function_table";
const char *defaultModule = "env";
const char *functionTableName = "__indirect_function_table";
} // namespace wasm
} // namespace lld

9
lld/wasm/SyntheticSections.cpp
View File

@ -22,10 +22,10 @@
using namespace llvm;
using namespace llvm::wasm;
using namespace lld;
using namespace lld::wasm;
namespace lld {
namespace wasm {
OutStruct lld::wasm::out;
OutStruct out;
namespace {
@ -567,3 +567,6 @@ void RelocSection::writeBody() {
writeUleb128(bodyOutputStream, count, "reloc count");
sec->writeRelocations(bodyOutputStream);
}
} // namespace wasm
} // namespace lld

9
lld/wasm/Writer.cpp
View File

@ -39,9 +39,9 @@
using namespace llvm;
using namespace llvm::wasm;
using namespace lld;
using namespace lld::wasm;
namespace lld {
namespace wasm {
static constexpr int stackAlignment = 16;
namespace {
@ -1088,4 +1088,7 @@ void Writer::createHeader() {
fileSize += header.size();
}
void lld::wasm::writeResult() { Writer().run(); }
void writeResult() { Writer().run(); }
} // namespace wasm
} // namespace lld

132
lld/wasm/WriterUtils.cpp
View File

@ -18,50 +18,94 @@ using namespace llvm;
using namespace llvm::wasm;
namespace lld {
std::string toString(ValType type) {
switch (type) {
case ValType::I32:
return "i32";
case ValType::I64:
return "i64";
case ValType::F32:
return "f32";
case ValType::F64:
return "f64";
case ValType::V128:
return "v128";
case ValType::EXNREF:
return "exnref";
}
llvm_unreachable("Invalid wasm::ValType");
}
void wasm::debugWrite(uint64_t offset, const Twine &msg) {
std::string toString(const WasmSignature &sig) {
SmallString<128> s("(");
for (ValType type : sig.Params) {
if (s.size() != 1)
s += ", ";
s += toString(type);
}
s += ") -> ";
if (sig.Returns.empty())
s += "void";
else
s += toString(sig.Returns[0]);
return s.str();
}
std::string toString(const WasmGlobalType &type) {
return (type.Mutable ? "var " : "const ") +
toString(static_cast<ValType>(type.Type));
}
std::string toString(const WasmEventType &type) {
if (type.Attribute == WASM_EVENT_ATTRIBUTE_EXCEPTION)
return "exception";
return "unknown";
}
namespace wasm {
void debugWrite(uint64_t offset, const Twine &msg) {
LLVM_DEBUG(dbgs() << format(" | %08lld: ", offset) << msg << "\n");
}
void wasm::writeUleb128(raw_ostream &os, uint32_t number, const Twine &msg) {
void writeUleb128(raw_ostream &os, uint32_t number, const Twine &msg) {
debugWrite(os.tell(), msg + "[" + utohexstr(number) + "]");
encodeULEB128(number, os);
}
void wasm::writeSleb128(raw_ostream &os, int32_t number, const Twine &msg) {
void writeSleb128(raw_ostream &os, int32_t number, const Twine &msg) {
debugWrite(os.tell(), msg + "[" + utohexstr(number) + "]");
encodeSLEB128(number, os);
}
void wasm::writeBytes(raw_ostream &os, const char *bytes, size_t count,
void writeBytes(raw_ostream &os, const char *bytes, size_t count,
const Twine &msg) {
debugWrite(os.tell(), msg + " [data[" + Twine(count) + "]]");
os.write(bytes, count);
}
void wasm::writeStr(raw_ostream &os, StringRef string, const Twine &msg) {
void writeStr(raw_ostream &os, StringRef string, const Twine &msg) {
debugWrite(os.tell(),
msg + " [str[" + Twine(string.size()) + "]: " + string + "]");
encodeULEB128(string.size(), os);
os.write(string.data(), string.size());
}
void wasm::writeU8(raw_ostream &os, uint8_t byte, const Twine &msg) {
void writeU8(raw_ostream &os, uint8_t byte, const Twine &msg) {
debugWrite(os.tell(), msg + " [0x" + utohexstr(byte) + "]");
os << byte;
}
void wasm::writeU32(raw_ostream &os, uint32_t number, const Twine &msg) {
void writeU32(raw_ostream &os, uint32_t number, const Twine &msg) {
debugWrite(os.tell(), msg + "[0x" + utohexstr(number) + "]");
support::endian::write(os, number, support::little);
}
void wasm::writeValueType(raw_ostream &os, ValType type, const Twine &msg) {
void writeValueType(raw_ostream &os, ValType type, const Twine &msg) {
writeU8(os, static_cast<uint8_t>(type),
msg + "[type: " + toString(type) + "]");
}
void wasm::writeSig(raw_ostream &os, const WasmSignature &sig) {
void writeSig(raw_ostream &os, const WasmSignature &sig) {
writeU8(os, WASM_TYPE_FUNC, "signature type");
writeUleb128(os, sig.Params.size(), "param Count");
for (ValType paramType : sig.Params) {
@ -73,22 +117,22 @@ void wasm::writeSig(raw_ostream &os, const WasmSignature &sig) {
}
}
void wasm::writeI32Const(raw_ostream &os, int32_t number, const Twine &msg) {
void writeI32Const(raw_ostream &os, int32_t number, const Twine &msg) {
writeU8(os, WASM_OPCODE_I32_CONST, "i32.const");
writeSleb128(os, number, msg);
}
void wasm::writeI64Const(raw_ostream &os, int32_t number, const Twine &msg) {
void writeI64Const(raw_ostream &os, int32_t number, const Twine &msg) {
writeU8(os, WASM_OPCODE_I64_CONST, "i64.const");
writeSleb128(os, number, msg);
}
void wasm::writeMemArg(raw_ostream &os, uint32_t alignment, uint32_t offset) {
void writeMemArg(raw_ostream &os, uint32_t alignment, uint32_t offset) {
writeUleb128(os, alignment, "alignment");
writeUleb128(os, offset, "offset");
}
void wasm::writeInitExpr(raw_ostream &os, const WasmInitExpr &initExpr) {
void writeInitExpr(raw_ostream &os, const WasmInitExpr &initExpr) {
writeU8(os, initExpr.Opcode, "opcode");
switch (initExpr.Opcode) {
case WASM_OPCODE_I32_CONST:
@ -106,39 +150,39 @@ void wasm::writeInitExpr(raw_ostream &os, const WasmInitExpr &initExpr) {
writeU8(os, WASM_OPCODE_END, "opcode:end");
}
void wasm::writeLimits(raw_ostream &os, const WasmLimits &limits) {
void writeLimits(raw_ostream &os, const WasmLimits &limits) {
writeU8(os, limits.Flags, "limits flags");
writeUleb128(os, limits.Initial, "limits initial");
if (limits.Flags & WASM_LIMITS_FLAG_HAS_MAX)
writeUleb128(os, limits.Maximum, "limits max");
}
void wasm::writeGlobalType(raw_ostream &os, const WasmGlobalType &type) {
void writeGlobalType(raw_ostream &os, const WasmGlobalType &type) {
// TODO: Update WasmGlobalType to use ValType and remove this cast.
writeValueType(os, ValType(type.Type), "global type");
writeU8(os, type.Mutable, "global mutable");
}
void wasm::writeGlobal(raw_ostream &os, const WasmGlobal &global) {
void writeGlobal(raw_ostream &os, const WasmGlobal &global) {
writeGlobalType(os, global.Type);
writeInitExpr(os, global.InitExpr);
}
void wasm::writeEventType(raw_ostream &os, const WasmEventType &type) {
void writeEventType(raw_ostream &os, const WasmEventType &type) {
writeUleb128(os, type.Attribute, "event attribute");
writeUleb128(os, type.SigIndex, "sig index");
}
void wasm::writeEvent(raw_ostream &os, const WasmEvent &event) {
void writeEvent(raw_ostream &os, const WasmEvent &event) {
writeEventType(os, event.Type);
}
void wasm::writeTableType(raw_ostream &os, const llvm::wasm::WasmTable &type) {
void writeTableType(raw_ostream &os, const llvm::wasm::WasmTable &type) {
writeU8(os, WASM_TYPE_FUNCREF, "table type");
writeLimits(os, type.Limits);
}
void wasm::writeImport(raw_ostream &os, const WasmImport &import) {
void writeImport(raw_ostream &os, const WasmImport &import) {
writeStr(os, import.Module, "import module name");
writeStr(os, import.Field, "import field name");
writeU8(os, import.Kind, "import kind");
@ -163,7 +207,7 @@ void wasm::writeImport(raw_ostream &os, const WasmImport &import) {
}
}
void wasm::writeExport(raw_ostream &os, const WasmExport &export_) {
void writeExport(raw_ostream &os, const WasmExport &export_) {
writeStr(os, export_.Name, "export name");
writeU8(os, export_.Kind, "export kind");
switch (export_.Kind) {
@ -183,48 +227,6 @@ void wasm::writeExport(raw_ostream &os, const WasmExport &export_) {
fatal("unsupported export type: " + Twine(export_.Kind));
}
}
} // namespace wasm
} // namespace lld
std::string lld::toString(ValType type) {
switch (type) {
case ValType::I32:
return "i32";
case ValType::I64:
return "i64";
case ValType::F32:
return "f32";
case ValType::F64:
return "f64";
case ValType::V128:
return "v128";
case ValType::EXNREF:
return "exnref";
}
llvm_unreachable("Invalid wasm::ValType");
}
std::string lld::toString(const WasmSignature &sig) {
SmallString<128> s("(");
for (ValType type : sig.Params) {
if (s.size() != 1)
s += ", ";
s += toString(type);
}
s += ") -> ";
if (sig.Returns.empty())
s += "void";
else
s += toString(sig.Returns[0]);
return s.str();
}
std::string lld::toString(const WasmGlobalType &type) {
return (type.Mutable ? "var " : "const ") +
toString(static_cast<ValType>(type.Type));
}
std::string lld::toString(const WasmEventType &type) {
if (type.Attribute == WASM_EVENT_ATTRIBUTE_EXCEPTION)
return "exception";
return "unknown";
}