}
void ObjFile::dumpInfo() const {
- log("info for: " + getName() +
+ log("info for: " + toString(this) +
"\n Symbols : " + Twine(Symbols.size()) +
"\n Function Imports : " + Twine(WasmObj->getNumImportedFunctions()) +
"\n Global Imports : " + Twine(WasmObj->getNumImportedGlobals()) +
}
}
-void ObjFile::parse() {
+void ObjFile::parse(bool IgnoreComdats) {
// Parse a memory buffer as a wasm file.
LLVM_DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
std::unique_ptr<Binary> Bin = CHECK(createBinary(MB), toString(this));
TypeIsUsed.resize(getWasmObj()->types().size(), false);
ArrayRef<StringRef> Comdats = WasmObj->linkingData().Comdats;
- UsedComdats.resize(Comdats.size());
for (unsigned I = 0; I < Comdats.size(); ++I)
- UsedComdats[I] = Symtab->addComdat(Comdats[I]);
+ if (IgnoreComdats)
+ KeptComdats.push_back(true);
+ else
+ KeptComdats.push_back(Symtab->addComdat(Comdats[I]));
// Populate `Segments`.
for (const WasmSegment &S : WasmObj->dataSegments())
uint32_t C = Chunk->getComdat();
if (C == UINT32_MAX)
return false;
- return !UsedComdats[C];
+ return !KeptComdats[C];
}
FunctionSymbol *ObjFile::getFunctionSymbol(uint32_t Index) const {
llvm_unreachable("unknown symbol kind");
}
-void ArchiveFile::parse() {
+void ArchiveFile::parse(bool IgnoreComdats) {
// Parse a MemoryBufferRef as an archive file.
LLVM_DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
File = CHECK(Archive::create(MB), toString(this));
llvm_unreachable("unknown visibility");
}
-static Symbol *createBitcodeSymbol(const lto::InputFile::Symbol &ObjSym,
+static Symbol *createBitcodeSymbol(const std::vector<bool> &KeptComdats,
+ const lto::InputFile::Symbol &ObjSym,
BitcodeFile &F) {
StringRef Name = Saver.save(ObjSym.getName());
uint32_t Flags = ObjSym.isWeak() ? WASM_SYMBOL_BINDING_WEAK : 0;
Flags |= mapVisibility(ObjSym.getVisibility());
- if (ObjSym.isUndefined()) {
+ int C = ObjSym.getComdatIndex();
+ bool ExcludedByComdat = C != -1 && !KeptComdats[C];
+
+ if (ObjSym.isUndefined() || ExcludedByComdat) {
if (ObjSym.isExecutable())
return Symtab->addUndefinedFunction(Name, Name, DefaultModule, Flags, &F,
nullptr);
return Symtab->addDefinedData(Name, Flags, &F, nullptr, 0, 0);
}
-void BitcodeFile::parse() {
+void BitcodeFile::parse(bool IgnoreComdats) {
Obj = check(lto::InputFile::create(MemoryBufferRef(
MB.getBuffer(), Saver.save(ArchiveName + MB.getBufferIdentifier()))));
Triple T(Obj->getTargetTriple());
error(toString(MB.getBufferIdentifier()) + ": machine type must be wasm32");
return;
}
+ std::vector<bool> KeptComdats;
+ for (StringRef S : Obj->getComdatTable())
+ if (IgnoreComdats)
+ KeptComdats.push_back(true);
+ else
+ KeptComdats.push_back(Symtab->addComdat(S));
for (const lto::InputFile::Symbol &ObjSym : Obj->symbols())
- Symbols.push_back(createBitcodeSymbol(ObjSym, *this));
+ Symbols.push_back(createBitcodeSymbol(KeptComdats, ObjSym, *this));
}
// Returns a string in the format of "foo.o" or "foo.a(bar.o)".
StringRef getName() const { return MB.getBufferIdentifier(); }
// Reads a file (the constructor doesn't do that).
- virtual void parse() = 0;
+ virtual void parse(bool IgnoreComdats = false) = 0;
Kind kind() const { return FileKind; }
void addMember(const llvm::object::Archive::Symbol *Sym);
- void parse() override;
+ void parse(bool IgnoreComdats) override;
private:
std::unique_ptr<llvm::object::Archive> File;
}
static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
- void parse() override;
+ void parse(bool IgnoreComdats) override;
// Returns the underlying wasm file.
const WasmObjectFile *getWasmObj() const { return WasmObj.get(); }
std::vector<bool> TypeIsUsed;
// Maps function indices to table indices
std::vector<uint32_t> TableEntries;
- std::vector<bool> UsedComdats;
+ std::vector<bool> KeptComdats;
std::vector<InputSegment *> Segments;
std::vector<InputFunction *> Functions;
std::vector<InputGlobal *> Globals;
explicit SharedFile(MemoryBufferRef M) : InputFile(SharedKind, M) {}
static bool classof(const InputFile *F) { return F->kind() == SharedKind; }
- void parse() override {}
+ void parse(bool IgnoreComdats) override {}
};
// .bc file
}
static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
- void parse() override;
+ void parse(bool IgnoreComdats) override;
std::unique_ptr<llvm::lto::InputFile> Obj;
};