This is an archive of the discontinued LLVM Phabricator instance.

Differential D64473

[Coding style change][lld] Rename variables for non-ELF ports.
ClosedPublic

Authored by ruiu on Jul 10 2019, 2:15 AM.

Details

Reviewers
rnk
mstorsjo
sbc100
MaskRay
peter.smith
grimar
• espindola
Commits
rG136d27ab4de0: [Coding style change][lld] Rename variables for non-ELF ports
rL365730: [Coding style change][lld] Rename variables for non-ELF ports
rLLD365730: [Coding style change][lld] Rename variables for non-ELF ports
Summary

This patch does the same thing as r365595 to other subdirectories,
which completes the naming style change for the entire lld directory.

Diff Detail

Repository
rL LLVM

Event Timeline

ruiu created this revision.Jul 10 2019, 2:15 AM
Herald added a reviewer: • espindola. · View Herald TranscriptJul 10 2019, 2:15 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: jfb, dexonsmith, steven_wu and 6 others. · View Herald Transcript
Harbormaster completed remote builds in B34676: Diff 208899.Jul 10 2019, 2:15 AM
grimar added inline comments.Jul 10 2019, 2:26 AM
lld/COFF/Chunks.h
102 ↗(On Diff #208899)

Should it be osIdx perhaps?

lld/COFF/DebugTypes.cpp
263 ↗(On Diff #208899)

pdbFile?

lld/COFF/Driver.h
124 ↗(On Diff #208899)

mbRef?

lld/COFF/InputFiles.cpp
139 ↗(On Diff #208899)

coffObj?

lld/wasm/SymbolTable.cpp
520 ↗(On Diff #208899)

It looks unformatted. Perhaps you could apply the clang format at the same time?

lld/wasm/SyntheticSections.h
289 ↗(On Diff #208899)

sDKs looks strange. sdks?

ruiu updated this revision to Diff 208901.Jul 10 2019, 2:30 AM
  • fix odd names such as cOFFSym
Harbormaster completed remote builds in B34678: Diff 208901.Jul 10 2019, 2:30 AM
ruiu updated this revision to Diff 208902.Jul 10 2019, 2:33 AM
ruiu marked an inline comment as done.
  • address review comments
Harbormaster completed remote builds in B34679: Diff 208902.Jul 10 2019, 2:34 AM
ruiu marked 4 inline comments as done.Jul 10 2019, 2:34 AM
ruiu added inline comments.
lld/COFF/Driver.h
124 ↗(On Diff #208899)

I think this is fine.

lld/wasm/SymbolTable.cpp
520 ↗(On Diff #208899)

It is intentional that I did not run clang-format, as some code was intended to not be formatted using clang-format. I don't judge whether that expectation is good or not, but I wanted to avoid the problem by not running clang-format to this patch. If we do, we'd virtually apply clang-format to the entire code base. That might be a good thing but needs a separate discussion.

MaskRay added a comment.Jul 10 2019, 8:40 AM

Many variables in assert and LLVM_DEBUG are not processed. You probably need to apply the tool on a debug (or -DLLVM_ENABLE_ASSERTIONS=on) build .

lld/wasm/Symbols.cpp
96 ↗(On Diff #208902)

outputSymbolIndex

101 ↗(On Diff #208902)

name index

103 ↗(On Diff #208902)

outputSymbolIndex

108 ↗(On Diff #208902)

name index

109 ↗(On Diff #208902)

gotIndex

191 ↗(On Diff #208902)

assert(tableIndex == INVALID_INDEX);

lld/wasm/Symbols.h
115 ↗(On Diff #208902)

gotIndex

ruiu updated this revision to Diff 209117.Jul 10 2019, 8:21 PM
  • enable assertion so that expressions in assert() are properly converted
Harbormaster completed remote builds in B34735: Diff 209117.Jul 10 2019, 8:21 PM
ruiu updated this revision to Diff 209118.Jul 10 2019, 8:50 PM
  • skimmed through the patch again to find and corrected odd conversion such as gCRoot
Harbormaster completed remote builds in B34736: Diff 209118.Jul 10 2019, 8:52 PM
MaskRay accepted this revision.Jul 10 2019, 10:31 PM
MaskRay added inline comments.
lld/COFF/Driver.cpp
126 ↗(On Diff #209118)

This tool doesn't handle argument comments like /*FileSize*/ .

But I think it is fine to update them in another commit.

This revision is now accepted and ready to land.Jul 10 2019, 10:31 PM
Closed by commit rL365730: [Coding style change][lld] Rename variables for non-ELF ports (authored by ruiu). · Explain WhyJul 10 2019, 10:41 PM
This revision was automatically updated to reflect the committed changes.
jrtc27 added a subscriber: jrtc27.Sep 10 2019, 11:05 AM

I'm trying to merge this into our fork. The previous ELF patch was fine, but for this commit I'm having issues because the tool in D64123 doesn't produce this exact result, and so running it on our tree produces a ton of conflicts. Did you use a modified clang-llvm-rename for this (and if so could you please upload it), or are all the discrepancies changes you made by hand afterwards (or with a separate script you would be able to provide)?

Revision Contents

PathSize
lld/
trunk/
COFF/
352 lines
798 lines
222 lines
52 lines
564 lines
24 lines
194 lines
96 lines
1818 lines
924 lines
2 lines
270 lines
182 lines
816 lines
8 lines
124 lines
2 lines
104 lines
2 lines
58 lines
16 lines
88 lines
12 lines
1790 lines
68 lines
744 lines
228 lines
110 lines
34 lines
52 lines
1930 lines
Common/
82 lines
110 lines
42 lines
12 lines
50 lines
92 lines
2 lines
58 lines
ELF/
16 lines
24 lines
12 lines
2 lines
18 lines
4 lines
4 lines
8 lines
6 lines
8 lines
32 lines
10 lines
MinGW/
348 lines
include/
lld/
Common/
12 lines
20 lines
90 lines
4 lines
18 lines
6 lines
16 lines
28 lines
20 lines
lib/
Driver/
24 lines
tools/
lld/
88 lines
wasm/
88 lines
686 lines
154 lines
300 lines
30 lines
120 lines
580 lines
28 lines
8 lines
146 lines
122 lines
84 lines
232 lines
34 lines
2 lines
68 lines
106 lines
798 lines
332 lines
302 lines
208 lines
692 lines
806 lines
48 lines
200 lines

Diff 209126

lld/trunk/COFF/Chunks.h

Show All 34 Lines
class DefinedImportData; class DefinedImportData;
class DefinedRegular; class DefinedRegular;
class ObjFile; class ObjFile;
class OutputSection; class OutputSection;
class RuntimePseudoReloc; class RuntimePseudoReloc;
class Symbol; class Symbol;
// Mask for permissions (discardable, writable, readable, executable, etc). // Mask for permissions (discardable, writable, readable, executable, etc).
const uint32_t PermMask = 0xFE000000; const uint32_t permMask = 0xFE000000;
// Mask for section types (code, data, bss). // Mask for section types (code, data, bss).
const uint32_t TypeMask = 0x000000E0; const uint32_t typeMask = 0x000000E0;
// The log base 2 of the largest section alignment, which is log2(8192), or 13. // The log base 2 of the largest section alignment, which is log2(8192), or 13.
enum : unsigned { Log2MaxSectionAlignment = 13 }; enum : unsigned { Log2MaxSectionAlignment = 13 };
// A Chunk represents a chunk of data that will occupy space in the // A Chunk represents a chunk of data that will occupy space in the
// output (if the resolver chose that). It may or may not be backed by // output (if the resolver chose that). It may or may not be backed by
// a section of an input file. It could be linker-created data, or // a section of an input file. It could be linker-created data, or
// doesn't even have actual data (if common or bss). // doesn't even have actual data (if common or bss).
class Chunk { class Chunk {
public: public:
enum Kind : uint8_t { SectionKind, OtherKind, ImportThunkKind }; enum Kind : uint8_t { SectionKind, OtherKind, ImportThunkKind };
Kind kind() const { return ChunkKind; } Kind kind() const { return chunkKind; }
// Returns the size of this chunk (even if this is a common or BSS.) // Returns the size of this chunk (even if this is a common or BSS.)
size_t getSize() const; size_t getSize() const;
// Returns chunk alignment in power of two form. Value values are powers of // Returns chunk alignment in power of two form. Value values are powers of
// two from 1 to 8192. // two from 1 to 8192.
uint32_t getAlignment() const { return 1U << P2Align; } uint32_t getAlignment() const { return 1U << p2Align; }
// Update the chunk section alignment measured in bytes. Internally alignment // Update the chunk section alignment measured in bytes. Internally alignment
// is stored in log2. // is stored in log2.
void setAlignment(uint32_t Align) { void setAlignment(uint32_t align) {
// Treat zero byte alignment as 1 byte alignment. // Treat zero byte alignment as 1 byte alignment.
Align = Align ? Align : 1; align = align ? align : 1;
assert(llvm::isPowerOf2_32(Align) && "alignment is not a power of 2"); assert(llvm::isPowerOf2_32(align) && "alignment is not a power of 2");
P2Align = llvm::Log2_32(Align); p2Align = llvm::Log2_32(align);
assert(P2Align <= Log2MaxSectionAlignment && assert(p2Align <= Log2MaxSectionAlignment &&
"impossible requested alignment"); "impossible requested alignment");
} }
// Write this chunk to a mmap'ed file, assuming Buf is pointing to // Write this chunk to a mmap'ed file, assuming Buf is pointing to
// beginning of the file. Because this function may use RVA values // beginning of the file. Because this function may use RVA values
// of other chunks for relocations, you need to set them properly // of other chunks for relocations, you need to set them properly
// before calling this function. // before calling this function.
void writeTo(uint8_t *Buf) const; void writeTo(uint8_t *buf) const;
// The writer sets and uses the addresses. In practice, PE images cannot be // The writer sets and uses the addresses. In practice, PE images cannot be
// larger than 2GB. Chunks are always laid as part of the image, so Chunk RVAs // larger than 2GB. Chunks are always laid as part of the image, so Chunk RVAs
// can be stored with 32 bits. // can be stored with 32 bits.
uint32_t getRVA() const { return RVA; } uint32_t getRVA() const { return rva; }
void setRVA(uint64_t V) { void setRVA(uint64_t v) {
RVA = (uint32_t)V; rva = (uint32_t)v;
assert(RVA == V && "RVA truncated"); assert(rva == v && "RVA truncated");
} }
// Returns readable/writable/executable bits. // Returns readable/writable/executable bits.
uint32_t getOutputCharacteristics() const; uint32_t getOutputCharacteristics() const;
// Returns the section name if this is a section chunk. // Returns the section name if this is a section chunk.
// It is illegal to call this function on non-section chunks. // It is illegal to call this function on non-section chunks.
StringRef getSectionName() const; StringRef getSectionName() const;
// An output section has pointers to chunks in the section, and each // An output section has pointers to chunks in the section, and each
// chunk has a back pointer to an output section. // chunk has a back pointer to an output section.
void setOutputSectionIdx(uint16_t O) { OSIdx = O; } void setOutputSectionIdx(uint16_t o) { osidx = o; }
uint16_t getOutputSectionIdx() const { return OSIdx; } uint16_t getOutputSectionIdx() const { return osidx; }
OutputSection *getOutputSection() const; OutputSection *getOutputSection() const;
// Windows-specific. // Windows-specific.
// Collect all locations that contain absolute addresses for base relocations. // Collect all locations that contain absolute addresses for base relocations.
void getBaserels(std::vector<Baserel> *Res); void getBaserels(std::vector<Baserel> *res);
// Returns a human-readable name of this chunk. Chunks are unnamed chunks of // Returns a human-readable name of this chunk. Chunks are unnamed chunks of
// bytes, so this is used only for logging or debugging. // bytes, so this is used only for logging or debugging.
StringRef getDebugName() const; StringRef getDebugName() const;
// Return true if this file has the hotpatch flag set to true in the // Return true if this file has the hotpatch flag set to true in the
// S_COMPILE3 record in codeview debug info. Also returns true for some thunks // S_COMPILE3 record in codeview debug info. Also returns true for some thunks
// synthesized by the linker. // synthesized by the linker.
bool isHotPatchable() const; bool isHotPatchable() const;
protected: protected:
Chunk(Kind K = OtherKind) : ChunkKind(K), HasData(true), P2Align(0) {} Chunk(Kind k = OtherKind) : chunkKind(k), hasData(true), p2Align(0) {}
const Kind ChunkKind; const Kind chunkKind;
public: public:
// Returns true if this has non-zero data. BSS chunks return // Returns true if this has non-zero data. BSS chunks return
// false. If false is returned, the space occupied by this chunk // false. If false is returned, the space occupied by this chunk
// will be filled with zeros. Corresponds to the // will be filled with zeros. Corresponds to the
// IMAGE_SCN_CNT_UNINITIALIZED_DATA section characteristic bit. // IMAGE_SCN_CNT_UNINITIALIZED_DATA section characteristic bit.
uint8_t HasData : 1; uint8_t hasData : 1;
public: public:
// The alignment of this chunk, stored in log2 form. The writer uses the // The alignment of this chunk, stored in log2 form. The writer uses the
// value. // value.
uint8_t P2Align : 7; uint8_t p2Align : 7;
// The output section index for this chunk. The first valid section number is // The output section index for this chunk. The first valid section number is
// one. // one.
uint16_t OSIdx = 0; uint16_t osidx = 0;
// The RVA of this chunk in the output. The writer sets a value. // The RVA of this chunk in the output. The writer sets a value.
uint32_t RVA = 0; uint32_t rva = 0;
}; };
class NonSectionChunk : public Chunk { class NonSectionChunk : public Chunk {
public: public:
virtual ~NonSectionChunk() = default; virtual ~NonSectionChunk() = default;
// Returns the size of this chunk (even if this is a common or BSS.) // Returns the size of this chunk (even if this is a common or BSS.)
virtual size_t getSize() const = 0; virtual size_t getSize() const = 0;
virtual uint32_t getOutputCharacteristics() const { return 0; } virtual uint32_t getOutputCharacteristics() const { return 0; }
// Write this chunk to a mmap'ed file, assuming Buf is pointing to // Write this chunk to a mmap'ed file, assuming Buf is pointing to
// beginning of the file. Because this function may use RVA values // beginning of the file. Because this function may use RVA values
// of other chunks for relocations, you need to set them properly // of other chunks for relocations, you need to set them properly
// before calling this function. // before calling this function.
virtual void writeTo(uint8_t *Buf) const {} virtual void writeTo(uint8_t *buf) const {}
// Returns the section name if this is a section chunk. // Returns the section name if this is a section chunk.
// It is illegal to call this function on non-section chunks. // It is illegal to call this function on non-section chunks.
virtual StringRef getSectionName() const { virtual StringRef getSectionName() const {
llvm_unreachable("unimplemented getSectionName"); llvm_unreachable("unimplemented getSectionName");
} }
// Windows-specific. // Windows-specific.
// Collect all locations that contain absolute addresses for base relocations. // Collect all locations that contain absolute addresses for base relocations.
virtual void getBaserels(std::vector<Baserel> *Res) {} virtual void getBaserels(std::vector<Baserel> *res) {}
// Returns a human-readable name of this chunk. Chunks are unnamed chunks of // Returns a human-readable name of this chunk. Chunks are unnamed chunks of
// bytes, so this is used only for logging or debugging. // bytes, so this is used only for logging or debugging.
virtual StringRef getDebugName() const { return ""; } virtual StringRef getDebugName() const { return ""; }
static bool classof(const Chunk *C) { return C->kind() != SectionKind; } static bool classof(const Chunk *c) { return c->kind() != SectionKind; }
protected: protected:
NonSectionChunk(Kind K = OtherKind) : Chunk(K) {} NonSectionChunk(Kind k = OtherKind) : Chunk(k) {}
}; };
// A chunk corresponding a section of an input file. // A chunk corresponding a section of an input file.
class SectionChunk final : public Chunk { class SectionChunk final : public Chunk {
// Identical COMDAT Folding feature accesses section internal data. // Identical COMDAT Folding feature accesses section internal data.
friend class ICF; friend class ICF;
public: public:
class symbol_iterator : public llvm::iterator_adaptor_base< class symbol_iterator : public llvm::iterator_adaptor_base<
symbol_iterator, const coff_relocation *, symbol_iterator, const coff_relocation *,
std::random_access_iterator_tag, Symbol *> { std::random_access_iterator_tag, Symbol *> {
friend SectionChunk; friend SectionChunk;
ObjFile *File; ObjFile *file;
symbol_iterator(ObjFile *File, const coff_relocation *I) symbol_iterator(ObjFile *file, const coff_relocation *i)
: symbol_iterator::iterator_adaptor_base(I), File(File) {} : symbol_iterator::iterator_adaptor_base(i), file(file) {}
public: public:
symbol_iterator() = default; symbol_iterator() = default;
Symbol *operator*() const { return File->getSymbol(I->SymbolTableIndex); } Symbol *operator*() const { return file->getSymbol(I->SymbolTableIndex); }
}; };
SectionChunk(ObjFile *File, const coff_section *Header); SectionChunk(ObjFile *file, const coff_section *header);
static bool classof(const Chunk *C) { return C->kind() == SectionKind; } static bool classof(const Chunk *c) { return c->kind() == SectionKind; }
size_t getSize() const { return Header->SizeOfRawData; } size_t getSize() const { return header->SizeOfRawData; }
ArrayRef<uint8_t> getContents() const; ArrayRef<uint8_t> getContents() const;
void writeTo(uint8_t *Buf) const; void writeTo(uint8_t *buf) const;
uint32_t getOutputCharacteristics() const { uint32_t getOutputCharacteristics() const {
return Header->Characteristics & (PermMask | TypeMask); return header->Characteristics & (permMask | typeMask);
} }
StringRef getSectionName() const { StringRef getSectionName() const {
return StringRef(SectionNameData, SectionNameSize); return StringRef(sectionNameData, sectionNameSize);
} }
void getBaserels(std::vector<Baserel> *Res); void getBaserels(std::vector<Baserel> *res);
bool isCOMDAT() const; bool isCOMDAT() const;
void applyRelX64(uint8_t *Off, uint16_t Type, OutputSection *OS, uint64_t S, void applyRelX64(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s,
uint64_t P) const; uint64_t p) const;
void applyRelX86(uint8_t *Off, uint16_t Type, OutputSection *OS, uint64_t S, void applyRelX86(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s,
uint64_t P) const; uint64_t p) const;
void applyRelARM(uint8_t *Off, uint16_t Type, OutputSection *OS, uint64_t S, void applyRelARM(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s,
uint64_t P) const; uint64_t p) const;
void applyRelARM64(uint8_t *Off, uint16_t Type, OutputSection *OS, uint64_t S, void applyRelARM64(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s,
uint64_t P) const; uint64_t p) const;
void getRuntimePseudoRelocs(std::vector<RuntimePseudoReloc> &Res); void getRuntimePseudoRelocs(std::vector<RuntimePseudoReloc> &res);
// Called if the garbage collector decides to not include this chunk // Called if the garbage collector decides to not include this chunk
// in a final output. It's supposed to print out a log message to stdout. // in a final output. It's supposed to print out a log message to stdout.
void printDiscardedMessage() const; void printDiscardedMessage() const;
// Adds COMDAT associative sections to this COMDAT section. A chunk // Adds COMDAT associative sections to this COMDAT section. A chunk
// and its children are treated as a group by the garbage collector. // and its children are treated as a group by the garbage collector.
void addAssociative(SectionChunk *Child); void addAssociative(SectionChunk *child);
StringRef getDebugName() const; StringRef getDebugName() const;
// True if this is a codeview debug info chunk. These will not be laid out in // True if this is a codeview debug info chunk. These will not be laid out in
// the image. Instead they will end up in the PDB, if one is requested. // the image. Instead they will end up in the PDB, if one is requested.
bool isCodeView() const { bool isCodeView() const {
return getSectionName() == ".debug" || getSectionName().startswith(".debug$"); return getSectionName() == ".debug" || getSectionName().startswith(".debug$");
} }
// True if this is a DWARF debug info or exception handling chunk. // True if this is a DWARF debug info or exception handling chunk.
bool isDWARF() const { bool isDWARF() const {
return getSectionName().startswith(".debug_") || getSectionName() == ".eh_frame"; return getSectionName().startswith(".debug_") || getSectionName() == ".eh_frame";
} }
// Allow iteration over the bodies of this chunk's relocated symbols. // Allow iteration over the bodies of this chunk's relocated symbols.
llvm::iterator_range<symbol_iterator> symbols() const { llvm::iterator_range<symbol_iterator> symbols() const {
return llvm::make_range(symbol_iterator(File, RelocsData), return llvm::make_range(symbol_iterator(file, relocsData),
symbol_iterator(File, RelocsData + RelocsSize)); symbol_iterator(file, relocsData + relocsSize));
} }
ArrayRef<coff_relocation> getRelocs() const { ArrayRef<coff_relocation> getRelocs() const {
return llvm::makeArrayRef(RelocsData, RelocsSize); return llvm::makeArrayRef(relocsData, relocsSize);
} }
// Reloc setter used by ARM range extension thunk insertion. // Reloc setter used by ARM range extension thunk insertion.
void setRelocs(ArrayRef<coff_relocation> NewRelocs) { void setRelocs(ArrayRef<coff_relocation> newRelocs) {
RelocsData = NewRelocs.data(); relocsData = newRelocs.data();
RelocsSize = NewRelocs.size(); relocsSize = newRelocs.size();
assert(RelocsSize == NewRelocs.size() && "reloc size truncation"); assert(relocsSize == newRelocs.size() && "reloc size truncation");
} }
// Single linked list iterator for associated comdat children. // Single linked list iterator for associated comdat children.
class AssociatedIterator class AssociatedIterator
: public llvm::iterator_facade_base< : public llvm::iterator_facade_base<
AssociatedIterator, std::forward_iterator_tag, SectionChunk> { AssociatedIterator, std::forward_iterator_tag, SectionChunk> {
public: public:
AssociatedIterator() = default; AssociatedIterator() = default;
AssociatedIterator(SectionChunk *Head) : Cur(Head) {} AssociatedIterator(SectionChunk *head) : cur(head) {}
AssociatedIterator &operator=(const AssociatedIterator &R) { AssociatedIterator &operator=(const AssociatedIterator &r) {
Cur = R.Cur; cur = r.cur;
return *this; return *this;
} }
bool operator==(const AssociatedIterator &R) const { return Cur == R.Cur; } bool operator==(const AssociatedIterator &r) const { return cur == r.cur; }
const SectionChunk &operator*() const { return *Cur; } const SectionChunk &operator*() const { return *cur; }
SectionChunk &operator*() { return *Cur; } SectionChunk &operator*() { return *cur; }
AssociatedIterator &operator++() { AssociatedIterator &operator++() {
Cur = Cur->AssocChildren; cur = cur->assocChildren;
return *this; return *this;
} }
private: private:
SectionChunk *Cur = nullptr; SectionChunk *cur = nullptr;
}; };
// Allow iteration over the associated child chunks for this section. // Allow iteration over the associated child chunks for this section.
llvm::iterator_range<AssociatedIterator> children() const { llvm::iterator_range<AssociatedIterator> children() const {
return llvm::make_range(AssociatedIterator(AssocChildren), return llvm::make_range(AssociatedIterator(assocChildren),
AssociatedIterator(nullptr)); AssociatedIterator(nullptr));
} }
// The section ID this chunk belongs to in its Obj. // The section ID this chunk belongs to in its Obj.
uint32_t getSectionNumber() const; uint32_t getSectionNumber() const;
ArrayRef<uint8_t> consumeDebugMagic(); ArrayRef<uint8_t> consumeDebugMagic();
static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> Data, static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> data,
StringRef SectionName); StringRef sectionName);
static SectionChunk *findByName(ArrayRef<SectionChunk *> Sections, static SectionChunk *findByName(ArrayRef<SectionChunk *> sections,
StringRef Name); StringRef name);
// The file that this chunk was created from. // The file that this chunk was created from.
ObjFile *File; ObjFile *file;
// Pointer to the COFF section header in the input file. // Pointer to the COFF section header in the input file.
const coff_section *Header; const coff_section *header;
// The COMDAT leader symbol if this is a COMDAT chunk. // The COMDAT leader symbol if this is a COMDAT chunk.
DefinedRegular *Sym = nullptr; DefinedRegular *sym = nullptr;
// The CRC of the contents as described in the COFF spec 4.5.5. // The CRC of the contents as described in the COFF spec 4.5.5.
// Auxiliary Format 5: Section Definitions. Used for ICF. // Auxiliary Format 5: Section Definitions. Used for ICF.
uint32_t Checksum = 0; uint32_t checksum = 0;
// Used by the garbage collector. // Used by the garbage collector.
bool Live; bool live;
// Whether this section needs to be kept distinct from other sections during // Whether this section needs to be kept distinct from other sections during
// ICF. This is set by the driver using address-significance tables. // ICF. This is set by the driver using address-significance tables.
bool KeepUnique = false; bool keepUnique = false;
// The COMDAT selection if this is a COMDAT chunk. // The COMDAT selection if this is a COMDAT chunk.
llvm::COFF::COMDATType Selection = (llvm::COFF::COMDATType)0; llvm::COFF::COMDATType selection = (llvm::COFF::COMDATType)0;
// A pointer pointing to a replacement for this chunk. // A pointer pointing to a replacement for this chunk.
// Initially it points to "this" object. If this chunk is merged // Initially it points to "this" object. If this chunk is merged
// with other chunk by ICF, it points to another chunk, // with other chunk by ICF, it points to another chunk,
// and this chunk is considered as dead. // and this chunk is considered as dead.
SectionChunk *Repl; SectionChunk *repl;
private: private:
SectionChunk *AssocChildren = nullptr; SectionChunk *assocChildren = nullptr;
// Used for ICF (Identical COMDAT Folding) // Used for ICF (Identical COMDAT Folding)
void replace(SectionChunk *Other); void replace(SectionChunk *other);
uint32_t Class[2] = {0, 0}; uint32_t eqClass[2] = {0, 0};
// Relocations for this section. Size is stored below. // Relocations for this section. Size is stored below.
const coff_relocation *RelocsData; const coff_relocation *relocsData;
// Section name string. Size is stored below. // Section name string. Size is stored below.
const char *SectionNameData; const char *sectionNameData;
uint32_t RelocsSize = 0; uint32_t relocsSize = 0;
uint32_t SectionNameSize = 0; uint32_t sectionNameSize = 0;
}; };
// Inline methods to implement faux-virtual dispatch for SectionChunk. // Inline methods to implement faux-virtual dispatch for SectionChunk.
inline size_t Chunk::getSize() const { inline size_t Chunk::getSize() const {
if (isa<SectionChunk>(this)) if (isa<SectionChunk>(this))
return static_cast<const SectionChunk *>(this)->getSize(); return static_cast<const SectionChunk *>(this)->getSize();
else else
return static_cast<const NonSectionChunk *>(this)->getSize(); return static_cast<const NonSectionChunk *>(this)->getSize();
} }
inline uint32_t Chunk::getOutputCharacteristics() const { inline uint32_t Chunk::getOutputCharacteristics() const {
if (isa<SectionChunk>(this)) if (isa<SectionChunk>(this))
return static_cast<const SectionChunk *>(this)->getOutputCharacteristics(); return static_cast<const SectionChunk *>(this)->getOutputCharacteristics();
else else
return static_cast<const NonSectionChunk *>(this) return static_cast<const NonSectionChunk *>(this)
->getOutputCharacteristics(); ->getOutputCharacteristics();
} }
inline void Chunk::writeTo(uint8_t *Buf) const { inline void Chunk::writeTo(uint8_t *buf) const {
if (isa<SectionChunk>(this)) if (isa<SectionChunk>(this))
static_cast<const SectionChunk *>(this)->writeTo(Buf); static_cast<const SectionChunk *>(this)->writeTo(buf);
else else
static_cast<const NonSectionChunk *>(this)->writeTo(Buf); static_cast<const NonSectionChunk *>(this)->writeTo(buf);
} }
inline StringRef Chunk::getSectionName() const { inline StringRef Chunk::getSectionName() const {
if (isa<SectionChunk>(this)) if (isa<SectionChunk>(this))
return static_cast<const SectionChunk *>(this)->getSectionName(); return static_cast<const SectionChunk *>(this)->getSectionName();
else else
return static_cast<const NonSectionChunk *>(this)->getSectionName(); return static_cast<const NonSectionChunk *>(this)->getSectionName();
} }
inline void Chunk::getBaserels(std::vector<Baserel> *Res) { inline void Chunk::getBaserels(std::vector<Baserel> *res) {
if (isa<SectionChunk>(this)) if (isa<SectionChunk>(this))
static_cast<SectionChunk *>(this)->getBaserels(Res); static_cast<SectionChunk *>(this)->getBaserels(res);
else else
static_cast<NonSectionChunk *>(this)->getBaserels(Res); static_cast<NonSectionChunk *>(this)->getBaserels(res);
} }
inline StringRef Chunk::getDebugName() const { inline StringRef Chunk::getDebugName() const {
if (isa<SectionChunk>(this)) if (isa<SectionChunk>(this))
return static_cast<const SectionChunk *>(this)->getDebugName(); return static_cast<const SectionChunk *>(this)->getDebugName();
else else
return static_cast<const NonSectionChunk *>(this)->getDebugName(); return static_cast<const NonSectionChunk *>(this)->getDebugName();
} }
// This class is used to implement an lld-specific feature (not implemented in // This class is used to implement an lld-specific feature (not implemented in
// MSVC) that minimizes the output size by finding string literals sharing tail // MSVC) that minimizes the output size by finding string literals sharing tail
// parts and merging them. // parts and merging them.
// //
// If string tail merging is enabled and a section is identified as containing a // If string tail merging is enabled and a section is identified as containing a
// string literal, it is added to a MergeChunk with an appropriate alignment. // string literal, it is added to a MergeChunk with an appropriate alignment.
// The MergeChunk then tail merges the strings using the StringTableBuilder // The MergeChunk then tail merges the strings using the StringTableBuilder
// class and assigns RVAs and section offsets to each of the member chunks based // class and assigns RVAs and section offsets to each of the member chunks based
// on the offsets assigned by the StringTableBuilder. // on the offsets assigned by the StringTableBuilder.
class MergeChunk : public NonSectionChunk { class MergeChunk : public NonSectionChunk {
public: public:
MergeChunk(uint32_t Alignment); MergeChunk(uint32_t alignment);
static void addSection(SectionChunk *C); static void addSection(SectionChunk *c);
void finalizeContents(); void finalizeContents();
void assignSubsectionRVAs(); void assignSubsectionRVAs();
uint32_t getOutputCharacteristics() const override; uint32_t getOutputCharacteristics() const override;
StringRef getSectionName() const override { return ".rdata"; } StringRef getSectionName() const override { return ".rdata"; }
size_t getSize() const override; size_t getSize() const override;
void writeTo(uint8_t *Buf) const override; void writeTo(uint8_t *buf) const override;
static MergeChunk *Instances[Log2MaxSectionAlignment + 1]; static MergeChunk *instances[Log2MaxSectionAlignment + 1];
std::vector<SectionChunk *> Sections; std::vector<SectionChunk *> sections;
private: private:
llvm::StringTableBuilder Builder; llvm::StringTableBuilder builder;
bool Finalized = false; bool finalized = false;
}; };
// A chunk for common symbols. Common chunks don't have actual data. // A chunk for common symbols. Common chunks don't have actual data.
class CommonChunk : public NonSectionChunk { class CommonChunk : public NonSectionChunk {
public: public:
CommonChunk(const COFFSymbolRef Sym); CommonChunk(const COFFSymbolRef sym);
size_t getSize() const override { return Sym.getValue(); } size_t getSize() const override { return sym.getValue(); }
uint32_t getOutputCharacteristics() const override; uint32_t getOutputCharacteristics() const override;
StringRef getSectionName() const override { return ".bss"; } StringRef getSectionName() const override { return ".bss"; }
private: private:
const COFFSymbolRef Sym; const COFFSymbolRef sym;
}; };
// A chunk for linker-created strings. // A chunk for linker-created strings.
class StringChunk : public NonSectionChunk { class StringChunk : public NonSectionChunk {
public: public:
explicit StringChunk(StringRef S) : Str(S) {} explicit StringChunk(StringRef s) : str(s) {}
size_t getSize() const override { return Str.size() + 1; } size_t getSize() const override { return str.size() + 1; }
void writeTo(uint8_t *Buf) const override; void writeTo(uint8_t *buf) const override;
private: private:
StringRef Str; StringRef str;
}; };
static const uint8_t ImportThunkX86[] = { static const uint8_t importThunkX86[] = {
0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // JMP *0x0 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // JMP *0x0
}; };
static const uint8_t ImportThunkARM[] = { static const uint8_t importThunkARM[] = {
0x40, 0xf2, 0x00, 0x0c, // mov.w ip, #0 0x40, 0xf2, 0x00, 0x0c, // mov.w ip, #0
0xc0, 0xf2, 0x00, 0x0c, // mov.t ip, #0 0xc0, 0xf2, 0x00, 0x0c, // mov.t ip, #0
0xdc, 0xf8, 0x00, 0xf0, // ldr.w pc, [ip] 0xdc, 0xf8, 0x00, 0xf0, // ldr.w pc, [ip]
}; };
static const uint8_t ImportThunkARM64[] = { static const uint8_t importThunkARM64[] = {
0x10, 0x00, 0x00, 0x90, // adrp x16, #0 0x10, 0x00, 0x00, 0x90, // adrp x16, #0
0x10, 0x02, 0x40, 0xf9, // ldr x16, [x16] 0x10, 0x02, 0x40, 0xf9, // ldr x16, [x16]
0x00, 0x02, 0x1f, 0xd6, // br x16 0x00, 0x02, 0x1f, 0xd6, // br x16
}; };
// Windows-specific. // Windows-specific.
// A chunk for DLL import jump table entry. In a final output, its // A chunk for DLL import jump table entry. In a final output, its
// contents will be a JMP instruction to some __imp_ symbol. // contents will be a JMP instruction to some __imp_ symbol.
class ImportThunkChunk : public NonSectionChunk { class ImportThunkChunk : public NonSectionChunk {
public: public:
ImportThunkChunk(Defined *S) ImportThunkChunk(Defined *s)
: NonSectionChunk(ImportThunkKind), ImpSymbol(S) {} : NonSectionChunk(ImportThunkKind), impSymbol(s) {}
static bool classof(const Chunk *C) { return C->kind() == ImportThunkKind; } static bool classof(const Chunk *c) { return c->kind() == ImportThunkKind; }
protected: protected:
Defined *ImpSymbol; Defined *impSymbol;
}; };
class ImportThunkChunkX64 : public ImportThunkChunk { class ImportThunkChunkX64 : public ImportThunkChunk {
public: public:
explicit ImportThunkChunkX64(Defined *S); explicit ImportThunkChunkX64(Defined *s);
size_t getSize() const override { return sizeof(ImportThunkX86); } size_t getSize() const override { return sizeof(importThunkX86); }
void writeTo(uint8_t *Buf) const override; void writeTo(uint8_t *buf) const override;
}; };
class ImportThunkChunkX86 : public ImportThunkChunk { class ImportThunkChunkX86 : public ImportThunkChunk {
public: public:
explicit ImportThunkChunkX86(Defined *S) : ImportThunkChunk(S) {} explicit ImportThunkChunkX86(Defined *s) : ImportThunkChunk(s) {}
size_t getSize() const override { return sizeof(ImportThunkX86); } size_t getSize() const override { return sizeof(importThunkX86); }
void getBaserels(std::vector<Baserel> *Res) override; void getBaserels(std::vector<Baserel> *res) override;
void writeTo(uint8_t *Buf) const override; void writeTo(uint8_t *buf) const override;
}; };
class ImportThunkChunkARM : public ImportThunkChunk { class ImportThunkChunkARM : public ImportThunkChunk {
public: public:
explicit ImportThunkChunkARM(Defined *S) : ImportThunkChunk(S) {} explicit ImportThunkChunkARM(Defined *s) : ImportThunkChunk(s) {}
size_t getSize() const override { return sizeof(ImportThunkARM); } size_t getSize() const override { return sizeof(importThunkARM); }
void getBaserels(std::vector<Baserel> *Res) override; void getBaserels(std::vector<Baserel> *res) override;
void writeTo(uint8_t *Buf) const override; void writeTo(uint8_t *buf) const override;
}; };
class ImportThunkChunkARM64 : public ImportThunkChunk { class ImportThunkChunkARM64 : public ImportThunkChunk {
public: public:
explicit ImportThunkChunkARM64(Defined *S) : ImportThunkChunk(S) {} explicit ImportThunkChunkARM64(Defined *s) : ImportThunkChunk(s) {}
size_t getSize() const override { return sizeof(ImportThunkARM64); } size_t getSize() const override { return sizeof(importThunkARM64); }
void writeTo(uint8_t *Buf) const override; void writeTo(uint8_t *buf) const override;
}; };
class RangeExtensionThunkARM : public NonSectionChunk { class RangeExtensionThunkARM : public NonSectionChunk {
public: public:
explicit RangeExtensionThunkARM(Defined *T) : Target(T) {} explicit RangeExtensionThunkARM(Defined *t) : target(t) {}
size_t getSize() const override; size_t getSize() const override;
void writeTo(uint8_t *Buf) const override; void writeTo(uint8_t *buf) const override;
Defined *Target; Defined *target;
}; };
class RangeExtensionThunkARM64 : public NonSectionChunk { class RangeExtensionThunkARM64 : public NonSectionChunk {
public: public:
explicit RangeExtensionThunkARM64(Defined *T) : Target(T) {} explicit RangeExtensionThunkARM64(Defined *t) : target(t) {}
size_t getSize() const override; size_t getSize() const override;
void writeTo(uint8_t *Buf) const override; void writeTo(uint8_t *buf) const override;
Defined *Target; Defined *target;
}; };
// Windows-specific. // Windows-specific.
// See comments for DefinedLocalImport class. // See comments for DefinedLocalImport class.
class LocalImportChunk : public NonSectionChunk { class LocalImportChunk : public NonSectionChunk {
public: public:
explicit LocalImportChunk(Defined *S) : Sym(S) { explicit LocalImportChunk(Defined *s) : sym(s) {
setAlignment(Config->Wordsize); setAlignment(config->wordsize);
} }
size_t getSize() const override; size_t getSize() const override;
void getBaserels(std::vector<Baserel> *Res) override; void getBaserels(std::vector<Baserel> *res) override;
void writeTo(uint8_t *Buf) const override; void writeTo(uint8_t *buf) const override;
private: private:
Defined *Sym; Defined *sym;
}; };
// Duplicate RVAs are not allowed in RVA tables, so unique symbols by chunk and // Duplicate RVAs are not allowed in RVA tables, so unique symbols by chunk and
// offset into the chunk. Order does not matter as the RVA table will be sorted // offset into the chunk. Order does not matter as the RVA table will be sorted
// later. // later.
struct ChunkAndOffset { struct ChunkAndOffset {
Chunk *InputChunk; Chunk *inputChunk;
uint32_t Offset; uint32_t offset;
struct DenseMapInfo { struct DenseMapInfo {
static ChunkAndOffset getEmptyKey() { static ChunkAndOffset getEmptyKey() {
return {llvm::DenseMapInfo<Chunk *>::getEmptyKey(), 0}; return {llvm::DenseMapInfo<Chunk *>::getEmptyKey(), 0};
} }
static ChunkAndOffset getTombstoneKey() { static ChunkAndOffset getTombstoneKey() {
return {llvm::DenseMapInfo<Chunk *>::getTombstoneKey(), 0}; return {llvm::DenseMapInfo<Chunk *>::getTombstoneKey(), 0};
} }
static unsigned getHashValue(const ChunkAndOffset &CO) { static unsigned getHashValue(const ChunkAndOffset &co) {
return llvm::DenseMapInfo<std::pair<Chunk *, uint32_t>>::getHashValue( return llvm::DenseMapInfo<std::pair<Chunk *, uint32_t>>::getHashValue(
{CO.InputChunk, CO.Offset}); {co.inputChunk, co.offset});
} }
static bool isEqual(const ChunkAndOffset &LHS, const ChunkAndOffset &RHS) { static bool isEqual(const ChunkAndOffset &lhs, const ChunkAndOffset &rhs) {
return LHS.InputChunk == RHS.InputChunk && LHS.Offset == RHS.Offset; return lhs.inputChunk == rhs.inputChunk && lhs.offset == rhs.offset;
} }
}; };
}; };
using SymbolRVASet = llvm::DenseSet<ChunkAndOffset>; using SymbolRVASet = llvm::DenseSet<ChunkAndOffset>;
// Table which contains symbol RVAs. Used for /safeseh and /guard:cf. // Table which contains symbol RVAs. Used for /safeseh and /guard:cf.
class RVATableChunk : public NonSectionChunk { class RVATableChunk : public NonSectionChunk {
public: public:
explicit RVATableChunk(SymbolRVASet S) : Syms(std::move(S)) {} explicit RVATableChunk(SymbolRVASet s) : syms(std::move(s)) {}
size_t getSize() const override { return Syms.size() * 4; } size_t getSize() const override { return syms.size() * 4; }
void writeTo(uint8_t *Buf) const override; void writeTo(uint8_t *buf) const override;
private: private:
SymbolRVASet Syms; SymbolRVASet syms;
}; };
// Windows-specific. // Windows-specific.
// This class represents a block in .reloc section. // This class represents a block in .reloc section.
// See the PE/COFF spec 5.6 for details. // See the PE/COFF spec 5.6 for details.
class BaserelChunk : public NonSectionChunk { class BaserelChunk : public NonSectionChunk {
public: public:
BaserelChunk(uint32_t Page, Baserel *Begin, Baserel *End); BaserelChunk(uint32_t page, Baserel *begin, Baserel *end);
size_t getSize() const override { return Data.size(); } size_t getSize() const override { return data.size(); }
void writeTo(uint8_t *Buf) const override; void writeTo(uint8_t *buf) const override;
private: private:
std::vector<uint8_t> Data; std::vector<uint8_t> data;
}; };
class Baserel { class Baserel {
public: public:
Baserel(uint32_t V, uint8_t Ty) : RVA(V), Type(Ty) {} Baserel(uint32_t v, uint8_t ty) : rva(v), type(ty) {}
explicit Baserel(uint32_t V) : Baserel(V, getDefaultType()) {} explicit Baserel(uint32_t v) : Baserel(v, getDefaultType()) {}
uint8_t getDefaultType(); uint8_t getDefaultType();
uint32_t RVA; uint32_t rva;
uint8_t Type; uint8_t type;
}; };
// This is a placeholder Chunk, to allow attaching a DefinedSynthetic to a // This is a placeholder Chunk, to allow attaching a DefinedSynthetic to a
// specific place in a section, without any data. This is used for the MinGW // specific place in a section, without any data. This is used for the MinGW
// specific symbol __RUNTIME_PSEUDO_RELOC_LIST_END__, even though the concept // specific symbol __RUNTIME_PSEUDO_RELOC_LIST_END__, even though the concept
// of an empty chunk isn't MinGW specific. // of an empty chunk isn't MinGW specific.
class EmptyChunk : public NonSectionChunk { class EmptyChunk : public NonSectionChunk {
public: public:
EmptyChunk() {} EmptyChunk() {}
size_t getSize() const override { return 0; } size_t getSize() const override { return 0; }
void writeTo(uint8_t *Buf) const override {} void writeTo(uint8_t *buf) const override {}
}; };
// MinGW specific, for the "automatic import of variables from DLLs" feature. // MinGW specific, for the "automatic import of variables from DLLs" feature.
// This provides the table of runtime pseudo relocations, for variable // This provides the table of runtime pseudo relocations, for variable
// references that turned out to need to be imported from a DLL even though // references that turned out to need to be imported from a DLL even though
// the reference didn't use the dllimport attribute. The MinGW runtime will // the reference didn't use the dllimport attribute. The MinGW runtime will
// process this table after loading, before handling control over to user // process this table after loading, before handling control over to user
// code. // code.
class PseudoRelocTableChunk : public NonSectionChunk { class PseudoRelocTableChunk : public NonSectionChunk {
public: public:
PseudoRelocTableChunk(std::vector<RuntimePseudoReloc> &Relocs) PseudoRelocTableChunk(std::vector<RuntimePseudoReloc> &relocs)
: Relocs(std::move(Relocs)) { : relocs(std::move(relocs)) {
setAlignment(4); setAlignment(4);
} }
size_t getSize() const override; size_t getSize() const override;
void writeTo(uint8_t *Buf) const override; void writeTo(uint8_t *buf) const override;
private: private:
std::vector<RuntimePseudoReloc> Relocs; std::vector<RuntimePseudoReloc> relocs;
}; };
// MinGW specific; information about one individual location in the image // MinGW specific; information about one individual location in the image
// that needs to be fixed up at runtime after loading. This represents // that needs to be fixed up at runtime after loading. This represents
// one individual element in the PseudoRelocTableChunk table. // one individual element in the PseudoRelocTableChunk table.
class RuntimePseudoReloc { class RuntimePseudoReloc {
public: public:
RuntimePseudoReloc(Defined *Sym, SectionChunk *Target, uint32_t TargetOffset, RuntimePseudoReloc(Defined *sym, SectionChunk *target, uint32_t targetOffset,
int Flags) int flags)
: Sym(Sym), Target(Target), TargetOffset(TargetOffset), Flags(Flags) {} : sym(sym), target(target), targetOffset(targetOffset), flags(flags) {}
Defined *Sym; Defined *sym;
SectionChunk *Target; SectionChunk *target;
uint32_t TargetOffset; uint32_t targetOffset;
// The Flags field contains the size of the relocation, in bits. No other // The Flags field contains the size of the relocation, in bits. No other
// flags are currently defined. // flags are currently defined.
int Flags; int flags;
}; };
// MinGW specific. A Chunk that contains one pointer-sized absolute value. // MinGW specific. A Chunk that contains one pointer-sized absolute value.
class AbsolutePointerChunk : public NonSectionChunk { class AbsolutePointerChunk : public NonSectionChunk {
public: public:
AbsolutePointerChunk(uint64_t Value) : Value(Value) { AbsolutePointerChunk(uint64_t value) : value(value) {
setAlignment(getSize()); setAlignment(getSize());
} }
size_t getSize() const override; size_t getSize() const override;
void writeTo(uint8_t *Buf) const override; void writeTo(uint8_t *buf) const override;
private: private:
uint64_t Value; uint64_t value;
}; };
// Return true if this file has the hotpatch flag set to true in the S_COMPILE3 // Return true if this file has the hotpatch flag set to true in the S_COMPILE3
// record in codeview debug info. Also returns true for some thunks synthesized // record in codeview debug info. Also returns true for some thunks synthesized
// by the linker. // by the linker.
inline bool Chunk::isHotPatchable() const { inline bool Chunk::isHotPatchable() const {
if (auto *SC = dyn_cast<SectionChunk>(this)) if (auto *sc = dyn_cast<SectionChunk>(this))
return SC->File->HotPatchable; return sc->file->hotPatchable;
else if (isa<ImportThunkChunk>(this)) else if (isa<ImportThunkChunk>(this))
return true; return true;
return false; return false;
} }
void applyMOV32T(uint8_t *Off, uint32_t V); void applyMOV32T(uint8_t *off, uint32_t v);
void applyBranch24T(uint8_t *Off, int32_t V); void applyBranch24T(uint8_t *off, int32_t v);
void applyArm64Addr(uint8_t *Off, uint64_t S, uint64_t P, int Shift); void applyArm64Addr(uint8_t *off, uint64_t s, uint64_t p, int shift);
void applyArm64Imm(uint8_t *Off, uint64_t Imm, uint32_t RangeLimit); void applyArm64Imm(uint8_t *off, uint64_t imm, uint32_t rangeLimit);
void applyArm64Branch26(uint8_t *Off, int64_t V); void applyArm64Branch26(uint8_t *off, int64_t v);
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
namespace llvm { namespace llvm {
template <> template <>
struct DenseMapInfo<lld::coff::ChunkAndOffset> struct DenseMapInfo<lld::coff::ChunkAndOffset>
: lld::coff::ChunkAndOffset::DenseMapInfo {}; : lld::coff::ChunkAndOffset::DenseMapInfo {};
} }
#endif #endif

lld/trunk/COFF/Chunks.cpp

Show All 23 Lines
using namespace llvm::object; using namespace llvm::object;
using namespace llvm::support::endian; using namespace llvm::support::endian;
using namespace llvm::COFF; using namespace llvm::COFF;
using llvm::support::ulittle32_t; using llvm::support::ulittle32_t;
namespace lld { namespace lld {
namespace coff { namespace coff {
SectionChunk::SectionChunk(ObjFile *F, const coff_section *H) SectionChunk::SectionChunk(ObjFile *f, const coff_section *h)
: Chunk(SectionKind), File(F), Header(H), Repl(this) { : Chunk(SectionKind), file(f), header(h), repl(this) {
// Initialize Relocs. // Initialize Relocs.
setRelocs(File->getCOFFObj()->getRelocations(Header)); setRelocs(file->getCOFFObj()->getRelocations(header));
// Initialize SectionName. // Initialize SectionName.
StringRef SectionName; StringRef sectionName;
if (Expected<StringRef> E = File->getCOFFObj()->getSectionName(Header)) if (Expected<StringRef> e = file->getCOFFObj()->getSectionName(header))
SectionName = *E; sectionName = *e;
SectionNameData = SectionName.data(); sectionNameData = sectionName.data();
SectionNameSize = SectionName.size(); sectionNameSize = sectionName.size();
setAlignment(Header->getAlignment()); setAlignment(header->getAlignment());
HasData = !(Header->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA); hasData = !(header->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA);
// If linker GC is disabled, every chunk starts out alive. If linker GC is // If linker GC is disabled, every chunk starts out alive. If linker GC is
// enabled, treat non-comdat sections as roots. Generally optimized object // enabled, treat non-comdat sections as roots. Generally optimized object
// files will be built with -ffunction-sections or /Gy, so most things worth // files will be built with -ffunction-sections or /Gy, so most things worth
// stripping will be in a comdat. // stripping will be in a comdat.
Live = !Config->DoGC || !isCOMDAT(); live = !config->doGC || !isCOMDAT();
} }
// SectionChunk is one of the most frequently allocated classes, so it is // SectionChunk is one of the most frequently allocated classes, so it is
// important to keep it as compact as possible. As of this writing, the number // important to keep it as compact as possible. As of this writing, the number
// below is the size of this class on x64 platforms. // below is the size of this class on x64 platforms.
static_assert(sizeof(SectionChunk) <= 88, "SectionChunk grew unexpectedly"); static_assert(sizeof(SectionChunk) <= 88, "SectionChunk grew unexpectedly");
static void add16(uint8_t *P, int16_t V) { write16le(P, read16le(P) + V); } static void add16(uint8_t *p, int16_t v) { write16le(p, read16le(p) + v); }
static void add32(uint8_t *P, int32_t V) { write32le(P, read32le(P) + V); } static void add32(uint8_t *p, int32_t v) { write32le(p, read32le(p) + v); }
static void add64(uint8_t *P, int64_t V) { write64le(P, read64le(P) + V); } static void add64(uint8_t *p, int64_t v) { write64le(p, read64le(p) + v); }
static void or16(uint8_t *P, uint16_t V) { write16le(P, read16le(P) | V); } static void or16(uint8_t *p, uint16_t v) { write16le(p, read16le(p) | v); }
static void or32(uint8_t *P, uint32_t V) { write32le(P, read32le(P) | V); } static void or32(uint8_t *p, uint32_t v) { write32le(p, read32le(p) | v); }
// Verify that given sections are appropriate targets for SECREL // Verify that given sections are appropriate targets for SECREL
// relocations. This check is relaxed because unfortunately debug // relocations. This check is relaxed because unfortunately debug
// sections have section-relative relocations against absolute symbols. // sections have section-relative relocations against absolute symbols.
static bool checkSecRel(const SectionChunk *Sec, OutputSection *OS) { static bool checkSecRel(const SectionChunk *sec, OutputSection *os) {
if (OS) if (os)
return true; return true;
if (Sec->isCodeView()) if (sec->isCodeView())
return false; return false;
error("SECREL relocation cannot be applied to absolute symbols"); error("SECREL relocation cannot be applied to absolute symbols");
return false; return false;
} }
static void applySecRel(const SectionChunk *Sec, uint8_t *Off, static void applySecRel(const SectionChunk *sec, uint8_t *off,
OutputSection *OS, uint64_t S) { OutputSection *os, uint64_t s) {
if (!checkSecRel(Sec, OS)) if (!checkSecRel(sec, os))
return; return;
uint64_t SecRel = S - OS->getRVA(); uint64_t secRel = s - os->getRVA();
if (SecRel > UINT32_MAX) { if (secRel > UINT32_MAX) {
error("overflow in SECREL relocation in section: " + Sec->getSectionName()); error("overflow in SECREL relocation in section: " + sec->getSectionName());
return; return;
} }
add32(Off, SecRel); add32(off, secRel);
} }
static void applySecIdx(uint8_t *Off, OutputSection *OS) { static void applySecIdx(uint8_t *off, OutputSection *os) {
// Absolute symbol doesn't have section index, but section index relocation // Absolute symbol doesn't have section index, but section index relocation
// against absolute symbol should be resolved to one plus the last output // against absolute symbol should be resolved to one plus the last output
// section index. This is required for compatibility with MSVC. // section index. This is required for compatibility with MSVC.
if (OS) if (os)
add16(Off, OS->SectionIndex); add16(off, os->sectionIndex);
else else
add16(Off, DefinedAbsolute::NumOutputSections + 1); add16(off, DefinedAbsolute::numOutputSections + 1);
} }
void SectionChunk::applyRelX64(uint8_t *Off, uint16_t Type, OutputSection *OS, void SectionChunk::applyRelX64(uint8_t *off, uint16_t type, OutputSection *os,
uint64_t S, uint64_t P) const { uint64_t s, uint64_t p) const {
switch (Type) { switch (type) {
case IMAGE_REL_AMD64_ADDR32: add32(Off, S + Config->ImageBase); break; case IMAGE_REL_AMD64_ADDR32: add32(off, s + config->imageBase); break;
case IMAGE_REL_AMD64_ADDR64: add64(Off, S + Config->ImageBase); break; case IMAGE_REL_AMD64_ADDR64: add64(off, s + config->imageBase); break;
case IMAGE_REL_AMD64_ADDR32NB: add32(Off, S); break; case IMAGE_REL_AMD64_ADDR32NB: add32(off, s); break;
case IMAGE_REL_AMD64_REL32: add32(Off, S - P - 4); break; case IMAGE_REL_AMD64_REL32: add32(off, s - p - 4); break;
case IMAGE_REL_AMD64_REL32_1: add32(Off, S - P - 5); break; case IMAGE_REL_AMD64_REL32_1: add32(off, s - p - 5); break;
case IMAGE_REL_AMD64_REL32_2: add32(Off, S - P - 6); break; case IMAGE_REL_AMD64_REL32_2: add32(off, s - p - 6); break;
case IMAGE_REL_AMD64_REL32_3: add32(Off, S - P - 7); break; case IMAGE_REL_AMD64_REL32_3: add32(off, s - p - 7); break;
case IMAGE_REL_AMD64_REL32_4: add32(Off, S - P - 8); break; case IMAGE_REL_AMD64_REL32_4: add32(off, s - p - 8); break;
case IMAGE_REL_AMD64_REL32_5: add32(Off, S - P - 9); break; case IMAGE_REL_AMD64_REL32_5: add32(off, s - p - 9); break;
case IMAGE_REL_AMD64_SECTION: applySecIdx(Off, OS); break; case IMAGE_REL_AMD64_SECTION: applySecIdx(off, os); break;
case IMAGE_REL_AMD64_SECREL: applySecRel(this, Off, OS, S); break; case IMAGE_REL_AMD64_SECREL: applySecRel(this, off, os, s); break;
default: default:
error("unsupported relocation type 0x" + Twine::utohexstr(Type) + " in " + error("unsupported relocation type 0x" + Twine::utohexstr(type) + " in " +
toString(File)); toString(file));
} }
} }
void SectionChunk::applyRelX86(uint8_t *Off, uint16_t Type, OutputSection *OS, void SectionChunk::applyRelX86(uint8_t *off, uint16_t type, OutputSection *os,
uint64_t S, uint64_t P) const { uint64_t s, uint64_t p) const {
switch (Type) { switch (type) {
case IMAGE_REL_I386_ABSOLUTE: break; case IMAGE_REL_I386_ABSOLUTE: break;
case IMAGE_REL_I386_DIR32: add32(Off, S + Config->ImageBase); break; case IMAGE_REL_I386_DIR32: add32(off, s + config->imageBase); break;
case IMAGE_REL_I386_DIR32NB: add32(Off, S); break; case IMAGE_REL_I386_DIR32NB: add32(off, s); break;
case IMAGE_REL_I386_REL32: add32(Off, S - P - 4); break; case IMAGE_REL_I386_REL32: add32(off, s - p - 4); break;
case IMAGE_REL_I386_SECTION: applySecIdx(Off, OS); break; case IMAGE_REL_I386_SECTION: applySecIdx(off, os); break;
case IMAGE_REL_I386_SECREL: applySecRel(this, Off, OS, S); break; case IMAGE_REL_I386_SECREL: applySecRel(this, off, os, s); break;
default: default:
error("unsupported relocation type 0x" + Twine::utohexstr(Type) + " in " + error("unsupported relocation type 0x" + Twine::utohexstr(type) + " in " +
toString(File)); toString(file));
} }
} }
static void applyMOV(uint8_t *Off, uint16_t V) { static void applyMOV(uint8_t *off, uint16_t v) {
write16le(Off, (read16le(Off) & 0xfbf0) | ((V & 0x800) >> 1) | ((V >> 12) & 0xf)); write16le(off, (read16le(off) & 0xfbf0) | ((v & 0x800) >> 1) | ((v >> 12) & 0xf));
write16le(Off + 2, (read16le(Off + 2) & 0x8f00) | ((V & 0x700) << 4) | (V & 0xff)); write16le(off + 2, (read16le(off + 2) & 0x8f00) | ((v & 0x700) << 4) | (v & 0xff));
} }
static uint16_t readMOV(uint8_t *Off, bool MOVT) { static uint16_t readMOV(uint8_t *off, bool movt) {
uint16_t Op1 = read16le(Off); uint16_t op1 = read16le(off);
if ((Op1 & 0xfbf0) != (MOVT ? 0xf2c0 : 0xf240)) if ((op1 & 0xfbf0) != (movt ? 0xf2c0 : 0xf240))
error("unexpected instruction in " + Twine(MOVT ? "MOVT" : "MOVW") + error("unexpected instruction in " + Twine(movt ? "MOVT" : "MOVW") +
" instruction in MOV32T relocation"); " instruction in MOV32T relocation");
uint16_t Op2 = read16le(Off + 2); uint16_t op2 = read16le(off + 2);
if ((Op2 & 0x8000) != 0) if ((op2 & 0x8000) != 0)
error("unexpected instruction in " + Twine(MOVT ? "MOVT" : "MOVW") + error("unexpected instruction in " + Twine(movt ? "MOVT" : "MOVW") +
" instruction in MOV32T relocation"); " instruction in MOV32T relocation");
return (Op2 & 0x00ff) | ((Op2 >> 4) & 0x0700) | ((Op1 << 1) & 0x0800) | return (op2 & 0x00ff) | ((op2 >> 4) & 0x0700) | ((op1 << 1) & 0x0800) |
((Op1 & 0x000f) << 12); ((op1 & 0x000f) << 12);
} }
void applyMOV32T(uint8_t *Off, uint32_t V) { void applyMOV32T(uint8_t *off, uint32_t v) {
uint16_t ImmW = readMOV(Off, false); // read MOVW operand uint16_t immW = readMOV(off, false); // read MOVW operand
uint16_t ImmT = readMOV(Off + 4, true); // read MOVT operand uint16_t immT = readMOV(off + 4, true); // read MOVT operand
uint32_t Imm = ImmW | (ImmT << 16); uint32_t imm = immW | (immT << 16);
V += Imm; // add the immediate offset v += imm; // add the immediate offset
applyMOV(Off, V); // set MOVW operand applyMOV(off, v); // set MOVW operand
applyMOV(Off + 4, V >> 16); // set MOVT operand applyMOV(off + 4, v >> 16); // set MOVT operand
} }
static void applyBranch20T(uint8_t *Off, int32_t V) { static void applyBranch20T(uint8_t *off, int32_t v) {
if (!isInt<21>(V)) if (!isInt<21>(v))
error("relocation out of range"); error("relocation out of range");
uint32_t S = V < 0 ? 1 : 0; uint32_t s = v < 0 ? 1 : 0;
uint32_t J1 = (V >> 19) & 1; uint32_t j1 = (v >> 19) & 1;
uint32_t J2 = (V >> 18) & 1; uint32_t j2 = (v >> 18) & 1;
or16(Off, (S << 10) | ((V >> 12) & 0x3f)); or16(off, (s << 10) | ((v >> 12) & 0x3f));
or16(Off + 2, (J1 << 13) | (J2 << 11) | ((V >> 1) & 0x7ff)); or16(off + 2, (j1 << 13) | (j2 << 11) | ((v >> 1) & 0x7ff));
} }
void applyBranch24T(uint8_t *Off, int32_t V) { void applyBranch24T(uint8_t *off, int32_t v) {
if (!isInt<25>(V)) if (!isInt<25>(v))
error("relocation out of range"); error("relocation out of range");
uint32_t S = V < 0 ? 1 : 0; uint32_t s = v < 0 ? 1 : 0;
uint32_t J1 = ((~V >> 23) & 1) ^ S; uint32_t j1 = ((~v >> 23) & 1) ^ s;
uint32_t J2 = ((~V >> 22) & 1) ^ S; uint32_t j2 = ((~v >> 22) & 1) ^ s;
or16(Off, (S << 10) | ((V >> 12) & 0x3ff)); or16(off, (s << 10) | ((v >> 12) & 0x3ff));
// Clear out the J1 and J2 bits which may be set. // Clear out the J1 and J2 bits which may be set.
write16le(Off + 2, (read16le(Off + 2) & 0xd000) | (J1 << 13) | (J2 << 11) | ((V >> 1) & 0x7ff)); write16le(off + 2, (read16le(off + 2) & 0xd000) | (j1 << 13) | (j2 << 11) | ((v >> 1) & 0x7ff));
} }
void SectionChunk::applyRelARM(uint8_t *Off, uint16_t Type, OutputSection *OS, void SectionChunk::applyRelARM(uint8_t *off, uint16_t type, OutputSection *os,
uint64_t S, uint64_t P) const { uint64_t s, uint64_t p) const {
// Pointer to thumb code must have the LSB set. // Pointer to thumb code must have the LSB set.
uint64_t SX = S; uint64_t sx = s;
if (OS && (OS->Header.Characteristics & IMAGE_SCN_MEM_EXECUTE)) if (os && (os->header.Characteristics & IMAGE_SCN_MEM_EXECUTE))
SX |= 1; sx |= 1;
switch (Type) { switch (type) {
case IMAGE_REL_ARM_ADDR32: add32(Off, SX + Config->ImageBase); break; case IMAGE_REL_ARM_ADDR32: add32(off, sx + config->imageBase); break;
case IMAGE_REL_ARM_ADDR32NB: add32(Off, SX); break; case IMAGE_REL_ARM_ADDR32NB: add32(off, sx); break;
case IMAGE_REL_ARM_MOV32T: applyMOV32T(Off, SX + Config->ImageBase); break; case IMAGE_REL_ARM_MOV32T: applyMOV32T(off, sx + config->imageBase); break;
case IMAGE_REL_ARM_BRANCH20T: applyBranch20T(Off, SX - P - 4); break; case IMAGE_REL_ARM_BRANCH20T: applyBranch20T(off, sx - p - 4); break;
case IMAGE_REL_ARM_BRANCH24T: applyBranch24T(Off, SX - P - 4); break; case IMAGE_REL_ARM_BRANCH24T: applyBranch24T(off, sx - p - 4); break;
case IMAGE_REL_ARM_BLX23T: applyBranch24T(Off, SX - P - 4); break; case IMAGE_REL_ARM_BLX23T: applyBranch24T(off, sx - p - 4); break;
case IMAGE_REL_ARM_SECTION: applySecIdx(Off, OS); break; case IMAGE_REL_ARM_SECTION: applySecIdx(off, os); break;
case IMAGE_REL_ARM_SECREL: applySecRel(this, Off, OS, S); break; case IMAGE_REL_ARM_SECREL: applySecRel(this, off, os, s); break;
case IMAGE_REL_ARM_REL32: add32(Off, SX - P - 4); break; case IMAGE_REL_ARM_REL32: add32(off, sx - p - 4); break;
default: default:
error("unsupported relocation type 0x" + Twine::utohexstr(Type) + " in " + error("unsupported relocation type 0x" + Twine::utohexstr(type) + " in " +
toString(File)); toString(file));
} }
} }
// Interpret the existing immediate value as a byte offset to the // Interpret the existing immediate value as a byte offset to the
// target symbol, then update the instruction with the immediate as // target symbol, then update the instruction with the immediate as
// the page offset from the current instruction to the target. // the page offset from the current instruction to the target.
void applyArm64Addr(uint8_t *Off, uint64_t S, uint64_t P, int Shift) { void applyArm64Addr(uint8_t *off, uint64_t s, uint64_t p, int shift) {
uint32_t Orig = read32le(Off); uint32_t orig = read32le(off);
uint64_t Imm = ((Orig >> 29) & 0x3) | ((Orig >> 3) & 0x1FFFFC); uint64_t imm = ((orig >> 29) & 0x3) | ((orig >> 3) & 0x1FFFFC);
S += Imm; s += imm;
Imm = (S >> Shift) - (P >> Shift); imm = (s >> shift) - (p >> shift);
uint32_t ImmLo = (Imm & 0x3) << 29; uint32_t immLo = (imm & 0x3) << 29;
uint32_t ImmHi = (Imm & 0x1FFFFC) << 3; uint32_t immHi = (imm & 0x1FFFFC) << 3;
uint64_t Mask = (0x3 << 29) | (0x1FFFFC << 3); uint64_t mask = (0x3 << 29) | (0x1FFFFC << 3);
write32le(Off, (Orig & ~Mask) | ImmLo | ImmHi); write32le(off, (orig & ~mask) | immLo | immHi);
} }
// Update the immediate field in a AARCH64 ldr, str, and add instruction. // Update the immediate field in a AARCH64 ldr, str, and add instruction.
// Optionally limit the range of the written immediate by one or more bits // Optionally limit the range of the written immediate by one or more bits
// (RangeLimit). // (RangeLimit).
void applyArm64Imm(uint8_t *Off, uint64_t Imm, uint32_t RangeLimit) { void applyArm64Imm(uint8_t *off, uint64_t imm, uint32_t rangeLimit) {
uint32_t Orig = read32le(Off); uint32_t orig = read32le(off);
Imm += (Orig >> 10) & 0xFFF; imm += (orig >> 10) & 0xFFF;
Orig &= ~(0xFFF << 10); orig &= ~(0xFFF << 10);
write32le(Off, Orig | ((Imm & (0xFFF >> RangeLimit)) << 10)); write32le(off, orig | ((imm & (0xFFF >> rangeLimit)) << 10));
} }
// Add the 12 bit page offset to the existing immediate. // Add the 12 bit page offset to the existing immediate.
// Ldr/str instructions store the opcode immediate scaled // Ldr/str instructions store the opcode immediate scaled
// by the load/store size (giving a larger range for larger // by the load/store size (giving a larger range for larger
// loads/stores). The immediate is always (both before and after // loads/stores). The immediate is always (both before and after
// fixing up the relocation) stored scaled similarly. // fixing up the relocation) stored scaled similarly.
// Even if larger loads/stores have a larger range, limit the // Even if larger loads/stores have a larger range, limit the
// effective offset to 12 bit, since it is intended to be a // effective offset to 12 bit, since it is intended to be a
// page offset. // page offset.
static void applyArm64Ldr(uint8_t *Off, uint64_t Imm) { static void applyArm64Ldr(uint8_t *off, uint64_t imm) {
uint32_t Orig = read32le(Off); uint32_t orig = read32le(off);
uint32_t Size = Orig >> 30; uint32_t size = orig >> 30;
// 0x04000000 indicates SIMD/FP registers // 0x04000000 indicates SIMD/FP registers
// 0x00800000 indicates 128 bit // 0x00800000 indicates 128 bit
if ((Orig & 0x4800000) == 0x4800000) if ((orig & 0x4800000) == 0x4800000)
Size += 4; size += 4;
if ((Imm & ((1 << Size) - 1)) != 0) if ((imm & ((1 << size) - 1)) != 0)
error("misaligned ldr/str offset"); error("misaligned ldr/str offset");
applyArm64Imm(Off, Imm >> Size, Size); applyArm64Imm(off, imm >> size, size);
} }
static void applySecRelLow12A(const SectionChunk *Sec, uint8_t *Off, static void applySecRelLow12A(const SectionChunk *sec, uint8_t *off,
OutputSection *OS, uint64_t S) { OutputSection *os, uint64_t s) {
if (checkSecRel(Sec, OS)) if (checkSecRel(sec, os))
applyArm64Imm(Off, (S - OS->getRVA()) & 0xfff, 0); applyArm64Imm(off, (s - os->getRVA()) & 0xfff, 0);
} }
static void applySecRelHigh12A(const SectionChunk *Sec, uint8_t *Off, static void applySecRelHigh12A(const SectionChunk *sec, uint8_t *off,
OutputSection *OS, uint64_t S) { OutputSection *os, uint64_t s) {
if (!checkSecRel(Sec, OS)) if (!checkSecRel(sec, os))
return; return;
uint64_t SecRel = (S - OS->getRVA()) >> 12; uint64_t secRel = (s - os->getRVA()) >> 12;
if (0xfff < SecRel) { if (0xfff < secRel) {
error("overflow in SECREL_HIGH12A relocation in section: " + error("overflow in SECREL_HIGH12A relocation in section: " +
Sec->getSectionName()); sec->getSectionName());
return; return;
} }
applyArm64Imm(Off, SecRel & 0xfff, 0); applyArm64Imm(off, secRel & 0xfff, 0);
} }
static void applySecRelLdr(const SectionChunk *Sec, uint8_t *Off, static void applySecRelLdr(const SectionChunk *sec, uint8_t *off,
OutputSection *OS, uint64_t S) { OutputSection *os, uint64_t s) {
if (checkSecRel(Sec, OS)) if (checkSecRel(sec, os))
applyArm64Ldr(Off, (S - OS->getRVA()) & 0xfff); applyArm64Ldr(off, (s - os->getRVA()) & 0xfff);
} }
void applyArm64Branch26(uint8_t *Off, int64_t V) { void applyArm64Branch26(uint8_t *off, int64_t v) {
if (!isInt<28>(V)) if (!isInt<28>(v))
error("relocation out of range"); error("relocation out of range");
or32(Off, (V & 0x0FFFFFFC) >> 2); or32(off, (v & 0x0FFFFFFC) >> 2);
} }
static void applyArm64Branch19(uint8_t *Off, int64_t V) { static void applyArm64Branch19(uint8_t *off, int64_t v) {
if (!isInt<21>(V)) if (!isInt<21>(v))
error("relocation out of range"); error("relocation out of range");
or32(Off, (V & 0x001FFFFC) << 3); or32(off, (v & 0x001FFFFC) << 3);
} }
static void applyArm64Branch14(uint8_t *Off, int64_t V) { static void applyArm64Branch14(uint8_t *off, int64_t v) {
if (!isInt<16>(V)) if (!isInt<16>(v))
error("relocation out of range"); error("relocation out of range");
or32(Off, (V & 0x0000FFFC) << 3); or32(off, (v & 0x0000FFFC) << 3);
} }
void SectionChunk::applyRelARM64(uint8_t *Off, uint16_t Type, OutputSection *OS, void SectionChunk::applyRelARM64(uint8_t *off, uint16_t type, OutputSection *os,
uint64_t S, uint64_t P) const { uint64_t s, uint64_t p) const {
switch (Type) { switch (type) {
case IMAGE_REL_ARM64_PAGEBASE_REL21: applyArm64Addr(Off, S, P, 12); break; case IMAGE_REL_ARM64_PAGEBASE_REL21: applyArm64Addr(off, s, p, 12); break;
case IMAGE_REL_ARM64_REL21: applyArm64Addr(Off, S, P, 0); break; case IMAGE_REL_ARM64_REL21: applyArm64Addr(off, s, p, 0); break;
case IMAGE_REL_ARM64_PAGEOFFSET_12A: applyArm64Imm(Off, S & 0xfff, 0); break; case IMAGE_REL_ARM64_PAGEOFFSET_12A: applyArm64Imm(off, s & 0xfff, 0); break;
case IMAGE_REL_ARM64_PAGEOFFSET_12L: applyArm64Ldr(Off, S & 0xfff); break; case IMAGE_REL_ARM64_PAGEOFFSET_12L: applyArm64Ldr(off, s & 0xfff); break;
case IMAGE_REL_ARM64_BRANCH26: applyArm64Branch26(Off, S - P); break; case IMAGE_REL_ARM64_BRANCH26: applyArm64Branch26(off, s - p); break;
case IMAGE_REL_ARM64_BRANCH19: applyArm64Branch19(Off, S - P); break; case IMAGE_REL_ARM64_BRANCH19: applyArm64Branch19(off, s - p); break;
case IMAGE_REL_ARM64_BRANCH14: applyArm64Branch14(Off, S - P); break; case IMAGE_REL_ARM64_BRANCH14: applyArm64Branch14(off, s - p); break;
case IMAGE_REL_ARM64_ADDR32: add32(Off, S + Config->ImageBase); break; case IMAGE_REL_ARM64_ADDR32: add32(off, s + config->imageBase); break;
case IMAGE_REL_ARM64_ADDR32NB: add32(Off, S); break; case IMAGE_REL_ARM64_ADDR32NB: add32(off, s); break;
case IMAGE_REL_ARM64_ADDR64: add64(Off, S + Config->ImageBase); break; case IMAGE_REL_ARM64_ADDR64: add64(off, s + config->imageBase); break;
case IMAGE_REL_ARM64_SECREL: applySecRel(this, Off, OS, S); break; case IMAGE_REL_ARM64_SECREL: applySecRel(this, off, os, s); break;
case IMAGE_REL_ARM64_SECREL_LOW12A: applySecRelLow12A(this, Off, OS, S); break; case IMAGE_REL_ARM64_SECREL_LOW12A: applySecRelLow12A(this, off, os, s); break;
case IMAGE_REL_ARM64_SECREL_HIGH12A: applySecRelHigh12A(this, Off, OS, S); break; case IMAGE_REL_ARM64_SECREL_HIGH12A: applySecRelHigh12A(this, off, os, s); break;
case IMAGE_REL_ARM64_SECREL_LOW12L: applySecRelLdr(this, Off, OS, S); break; case IMAGE_REL_ARM64_SECREL_LOW12L: applySecRelLdr(this, off, os, s); break;
case IMAGE_REL_ARM64_SECTION: applySecIdx(Off, OS); break; case IMAGE_REL_ARM64_SECTION: applySecIdx(off, os); break;
case IMAGE_REL_ARM64_REL32: add32(Off, S - P - 4); break; case IMAGE_REL_ARM64_REL32: add32(off, s - p - 4); break;
default: default:
error("unsupported relocation type 0x" + Twine::utohexstr(Type) + " in " + error("unsupported relocation type 0x" + Twine::utohexstr(type) + " in " +
toString(File)); toString(file));
} }
} }
static void maybeReportRelocationToDiscarded(const SectionChunk *FromChunk, static void maybeReportRelocationToDiscarded(const SectionChunk *fromChunk,
Defined *Sym, Defined *sym,
const coff_relocation &Rel) { const coff_relocation &rel) {
// Don't report these errors when the relocation comes from a debug info // Don't report these errors when the relocation comes from a debug info
// section or in mingw mode. MinGW mode object files (built by GCC) can // section or in mingw mode. MinGW mode object files (built by GCC) can
// have leftover sections with relocations against discarded comdat // have leftover sections with relocations against discarded comdat
// sections. Such sections are left as is, with relocations untouched. // sections. Such sections are left as is, with relocations untouched.
if (FromChunk->isCodeView() || FromChunk->isDWARF() || Config->MinGW) if (fromChunk->isCodeView() || fromChunk->isDWARF() || config->mingw)
return; return;
// Get the name of the symbol. If it's null, it was discarded early, so we // Get the name of the symbol. If it's null, it was discarded early, so we
// have to go back to the object file. // have to go back to the object file.
ObjFile *File = FromChunk->File; ObjFile *file = fromChunk->file;
StringRef Name; StringRef name;
if (Sym) { if (sym) {
Name = Sym->getName(); name = sym->getName();
} else { } else {
COFFSymbolRef COFFSym = COFFSymbolRef coffSym =
check(File->getCOFFObj()->getSymbol(Rel.SymbolTableIndex)); check(file->getCOFFObj()->getSymbol(rel.SymbolTableIndex));
File->getCOFFObj()->getSymbolName(COFFSym, Name); file->getCOFFObj()->getSymbolName(coffSym, name);
} }
std::vector<std::string> SymbolLocations = std::vector<std::string> symbolLocations =
getSymbolLocations(File, Rel.SymbolTableIndex); getSymbolLocations(file, rel.SymbolTableIndex);
std::string Out; std::string out;
llvm::raw_string_ostream OS(Out); llvm::raw_string_ostream os(out);
OS << "relocation against symbol in discarded section: " + Name; os << "relocation against symbol in discarded section: " + name;
for (const std::string &S : SymbolLocations) for (const std::string &s : symbolLocations)
OS << S; os << s;
error(OS.str()); error(os.str());
} }
void SectionChunk::writeTo(uint8_t *Buf) const { void SectionChunk::writeTo(uint8_t *buf) const {
if (!HasData) if (!hasData)
return; return;
// Copy section contents from source object file to output file. // Copy section contents from source object file to output file.
ArrayRef<uint8_t> A = getContents(); ArrayRef<uint8_t> a = getContents();
if (!A.empty()) if (!a.empty())
memcpy(Buf, A.data(), A.size()); memcpy(buf, a.data(), a.size());
// Apply relocations. // Apply relocations.
size_t InputSize = getSize(); size_t inputSize = getSize();
for (size_t I = 0, E = RelocsSize; I < E; I++) { for (size_t i = 0, e = relocsSize; i < e; i++) {
const coff_relocation &Rel = RelocsData[I]; const coff_relocation &rel = relocsData[i];
// Check for an invalid relocation offset. This check isn't perfect, because // Check for an invalid relocation offset. This check isn't perfect, because
// we don't have the relocation size, which is only known after checking the // we don't have the relocation size, which is only known after checking the
// machine and relocation type. As a result, a relocation may overwrite the // machine and relocation type. As a result, a relocation may overwrite the
// beginning of the following input section. // beginning of the following input section.
if (Rel.VirtualAddress >= InputSize) { if (rel.VirtualAddress >= inputSize) {
error("relocation points beyond the end of its parent section"); error("relocation points beyond the end of its parent section");
continue; continue;
} }
uint8_t *Off = Buf + Rel.VirtualAddress; uint8_t *off = buf + rel.VirtualAddress;
auto *Sym = auto *sym =
dyn_cast_or_null<Defined>(File->getSymbol(Rel.SymbolTableIndex)); dyn_cast_or_null<Defined>(file->getSymbol(rel.SymbolTableIndex));
// Get the output section of the symbol for this relocation. The output // Get the output section of the symbol for this relocation. The output
// section is needed to compute SECREL and SECTION relocations used in debug // section is needed to compute SECREL and SECTION relocations used in debug
// info. // info.
Chunk *C = Sym ? Sym->getChunk() : nullptr; Chunk *c = sym ? sym->getChunk() : nullptr;
OutputSection *OS = C ? C->getOutputSection() : nullptr; OutputSection *os = c ? c->getOutputSection() : nullptr;
// Skip the relocation if it refers to a discarded section, and diagnose it // Skip the relocation if it refers to a discarded section, and diagnose it
// as an error if appropriate. If a symbol was discarded early, it may be // as an error if appropriate. If a symbol was discarded early, it may be
// null. If it was discarded late, the output section will be null, unless // null. If it was discarded late, the output section will be null, unless
// it was an absolute or synthetic symbol. // it was an absolute or synthetic symbol.
if (!Sym || if (!sym ||
(!OS && !isa<DefinedAbsolute>(Sym) && !isa<DefinedSynthetic>(Sym))) { (!os && !isa<DefinedAbsolute>(sym) && !isa<DefinedSynthetic>(sym))) {
maybeReportRelocationToDiscarded(this, Sym, Rel); maybeReportRelocationToDiscarded(this, sym, rel);
continue; continue;
} }
uint64_t S = Sym->getRVA(); uint64_t s = sym->getRVA();
// Compute the RVA of the relocation for relative relocations. // Compute the RVA of the relocation for relative relocations.
uint64_t P = RVA + Rel.VirtualAddress; uint64_t p = rva + rel.VirtualAddress;
switch (Config->Machine) { switch (config->machine) {
case AMD64: case AMD64:
applyRelX64(Off, Rel.Type, OS, S, P); applyRelX64(off, rel.Type, os, s, p);
break; break;
case I386: case I386:
applyRelX86(Off, Rel.Type, OS, S, P); applyRelX86(off, rel.Type, os, s, p);
break; break;
case ARMNT: case ARMNT:
applyRelARM(Off, Rel.Type, OS, S, P); applyRelARM(off, rel.Type, os, s, p);
break; break;
case ARM64: case ARM64:
applyRelARM64(Off, Rel.Type, OS, S, P); applyRelARM64(off, rel.Type, os, s, p);
break; break;
default: default:
llvm_unreachable("unknown machine type"); llvm_unreachable("unknown machine type");
} }
} }
} }
void SectionChunk::addAssociative(SectionChunk *Child) { void SectionChunk::addAssociative(SectionChunk *child) {
// Insert this child at the head of the list. // Insert this child at the head of the list.
assert(Child->AssocChildren == nullptr && assert(child->assocChildren == nullptr &&
"associated sections cannot have their own associated children"); "associated sections cannot have their own associated children");
Child->AssocChildren = AssocChildren; child->assocChildren = assocChildren;
AssocChildren = Child; assocChildren = child;
} }
static uint8_t getBaserelType(const coff_relocation &Rel) { static uint8_t getBaserelType(const coff_relocation &rel) {
switch (Config->Machine) { switch (config->machine) {
case AMD64: case AMD64:
if (Rel.Type == IMAGE_REL_AMD64_ADDR64) if (rel.Type == IMAGE_REL_AMD64_ADDR64)
return IMAGE_REL_BASED_DIR64; return IMAGE_REL_BASED_DIR64;
return IMAGE_REL_BASED_ABSOLUTE; return IMAGE_REL_BASED_ABSOLUTE;
case I386: case I386:
if (Rel.Type == IMAGE_REL_I386_DIR32) if (rel.Type == IMAGE_REL_I386_DIR32)
return IMAGE_REL_BASED_HIGHLOW; return IMAGE_REL_BASED_HIGHLOW;
return IMAGE_REL_BASED_ABSOLUTE; return IMAGE_REL_BASED_ABSOLUTE;
case ARMNT: case ARMNT:
if (Rel.Type == IMAGE_REL_ARM_ADDR32) if (rel.Type == IMAGE_REL_ARM_ADDR32)
return IMAGE_REL_BASED_HIGHLOW; return IMAGE_REL_BASED_HIGHLOW;
if (Rel.Type == IMAGE_REL_ARM_MOV32T) if (rel.Type == IMAGE_REL_ARM_MOV32T)
return IMAGE_REL_BASED_ARM_MOV32T; return IMAGE_REL_BASED_ARM_MOV32T;
return IMAGE_REL_BASED_ABSOLUTE; return IMAGE_REL_BASED_ABSOLUTE;
case ARM64: case ARM64:
if (Rel.Type == IMAGE_REL_ARM64_ADDR64) if (rel.Type == IMAGE_REL_ARM64_ADDR64)
return IMAGE_REL_BASED_DIR64; return IMAGE_REL_BASED_DIR64;
return IMAGE_REL_BASED_ABSOLUTE; return IMAGE_REL_BASED_ABSOLUTE;
default: default:
llvm_unreachable("unknown machine type"); llvm_unreachable("unknown machine type");
} }
} }
// Windows-specific. // Windows-specific.
// Collect all locations that contain absolute addresses, which need to be // Collect all locations that contain absolute addresses, which need to be
// fixed by the loader if load-time relocation is needed. // fixed by the loader if load-time relocation is needed.
// Only called when base relocation is enabled. // Only called when base relocation is enabled.
void SectionChunk::getBaserels(std::vector<Baserel> *Res) { void SectionChunk::getBaserels(std::vector<Baserel> *res) {
for (size_t I = 0, E = RelocsSize; I < E; I++) { for (size_t i = 0, e = relocsSize; i < e; i++) {
const coff_relocation &Rel = RelocsData[I]; const coff_relocation &rel = relocsData[i];
uint8_t Ty = getBaserelType(Rel); uint8_t ty = getBaserelType(rel);
if (Ty == IMAGE_REL_BASED_ABSOLUTE) if (ty == IMAGE_REL_BASED_ABSOLUTE)
continue; continue;
Symbol *Target = File->getSymbol(Rel.SymbolTableIndex); Symbol *target = file->getSymbol(rel.SymbolTableIndex);
if (!Target || isa<DefinedAbsolute>(Target)) if (!target || isa<DefinedAbsolute>(target))
continue; continue;
Res->emplace_back(RVA + Rel.VirtualAddress, Ty); res->emplace_back(rva + rel.VirtualAddress, ty);
} }
} }
// MinGW specific. // MinGW specific.
// Check whether a static relocation of type Type can be deferred and // Check whether a static relocation of type Type can be deferred and
// handled at runtime as a pseudo relocation (for references to a module // handled at runtime as a pseudo relocation (for references to a module
// local variable, which turned out to actually need to be imported from // local variable, which turned out to actually need to be imported from
// another DLL) This returns the size the relocation is supposed to update, // another DLL) This returns the size the relocation is supposed to update,
// in bits, or 0 if the relocation cannot be handled as a runtime pseudo // in bits, or 0 if the relocation cannot be handled as a runtime pseudo
// relocation. // relocation.
static int getRuntimePseudoRelocSize(uint16_t Type) { static int getRuntimePseudoRelocSize(uint16_t type) {
// Relocations that either contain an absolute address, or a plain // Relocations that either contain an absolute address, or a plain
// relative offset, since the runtime pseudo reloc implementation // relative offset, since the runtime pseudo reloc implementation
// adds 8/16/32/64 bit values to a memory address. // adds 8/16/32/64 bit values to a memory address.
// //
// Given a pseudo relocation entry, // Given a pseudo relocation entry,
// //
// typedef struct { // typedef struct {
// DWORD sym; // DWORD sym;
Show All 9 Linesstatic int getRuntimePseudoRelocSize(uint16_t type) {
// the address of the IAT slot, and for relative addresses (IMAGE_REL*_REL32), // the address of the IAT slot, and for relative addresses (IMAGE_REL*_REL32),
// where the memory location originally contains the relative offset to the // where the memory location originally contains the relative offset to the
// IAT slot. // IAT slot.
// //
// This requires the target address to be writable, either directly out of // This requires the target address to be writable, either directly out of
// the image, or temporarily changed at runtime with VirtualProtect. // the image, or temporarily changed at runtime with VirtualProtect.
// Since this only operates on direct address values, it doesn't work for // Since this only operates on direct address values, it doesn't work for
// ARM/ARM64 relocations, other than the plain ADDR32/ADDR64 relocations. // ARM/ARM64 relocations, other than the plain ADDR32/ADDR64 relocations.
switch (Config->Machine) { switch (config->machine) {
case AMD64: case AMD64:
switch (Type) { switch (type) {
case IMAGE_REL_AMD64_ADDR64: case IMAGE_REL_AMD64_ADDR64:
return 64; return 64;
case IMAGE_REL_AMD64_ADDR32: case IMAGE_REL_AMD64_ADDR32:
case IMAGE_REL_AMD64_REL32: case IMAGE_REL_AMD64_REL32:
case IMAGE_REL_AMD64_REL32_1: case IMAGE_REL_AMD64_REL32_1:
case IMAGE_REL_AMD64_REL32_2: case IMAGE_REL_AMD64_REL32_2:
case IMAGE_REL_AMD64_REL32_3: case IMAGE_REL_AMD64_REL32_3:
case IMAGE_REL_AMD64_REL32_4: case IMAGE_REL_AMD64_REL32_4:
case IMAGE_REL_AMD64_REL32_5: case IMAGE_REL_AMD64_REL32_5:
return 32; return 32;
default: default:
return 0; return 0;
} }
case I386: case I386:
switch (Type) { switch (type) {
case IMAGE_REL_I386_DIR32: case IMAGE_REL_I386_DIR32:
case IMAGE_REL_I386_REL32: case IMAGE_REL_I386_REL32:
return 32; return 32;
default: default:
return 0; return 0;
} }
case ARMNT: case ARMNT:
switch (Type) { switch (type) {
case IMAGE_REL_ARM_ADDR32: case IMAGE_REL_ARM_ADDR32:
return 32; return 32;
default: default:
return 0; return 0;
} }
case ARM64: case ARM64:
switch (Type) { switch (type) {
case IMAGE_REL_ARM64_ADDR64: case IMAGE_REL_ARM64_ADDR64:
return 64; return 64;
case IMAGE_REL_ARM64_ADDR32: case IMAGE_REL_ARM64_ADDR32:
return 32; return 32;
default: default:
return 0; return 0;
} }
default: default:
llvm_unreachable("unknown machine type"); llvm_unreachable("unknown machine type");
} }
} }
// MinGW specific. // MinGW specific.
// Append information to the provided vector about all relocations that // Append information to the provided vector about all relocations that
// need to be handled at runtime as runtime pseudo relocations (references // need to be handled at runtime as runtime pseudo relocations (references
// to a module local variable, which turned out to actually need to be // to a module local variable, which turned out to actually need to be
// imported from another DLL). // imported from another DLL).
void SectionChunk::getRuntimePseudoRelocs( void SectionChunk::getRuntimePseudoRelocs(
std::vector<RuntimePseudoReloc> &Res) { std::vector<RuntimePseudoReloc> &res) {
for (const coff_relocation &Rel : getRelocs()) { for (const coff_relocation &rel : getRelocs()) {
auto *Target = auto *target =
dyn_cast_or_null<Defined>(File->getSymbol(Rel.SymbolTableIndex)); dyn_cast_or_null<Defined>(file->getSymbol(rel.SymbolTableIndex));
if (!Target || !Target->IsRuntimePseudoReloc) if (!target || !target->isRuntimePseudoReloc)
continue; continue;
int SizeInBits = getRuntimePseudoRelocSize(Rel.Type); int sizeInBits = getRuntimePseudoRelocSize(rel.Type);
if (SizeInBits == 0) { if (sizeInBits == 0) {
error("unable to automatically import from " + Target->getName() + error("unable to automatically import from " + target->getName() +
" with relocation type " + " with relocation type " +
File->getCOFFObj()->getRelocationTypeName(Rel.Type) + " in " + file->getCOFFObj()->getRelocationTypeName(rel.Type) + " in " +
toString(File)); toString(file));
continue; continue;
} }
// SizeInBits is used to initialize the Flags field; currently no // SizeInBits is used to initialize the Flags field; currently no
// other flags are defined. // other flags are defined.
Res.emplace_back( res.emplace_back(
RuntimePseudoReloc(Target, this, Rel.VirtualAddress, SizeInBits)); RuntimePseudoReloc(target, this, rel.VirtualAddress, sizeInBits));
} }
} }
bool SectionChunk::isCOMDAT() const { bool SectionChunk::isCOMDAT() const {
return Header->Characteristics & IMAGE_SCN_LNK_COMDAT; return header->Characteristics & IMAGE_SCN_LNK_COMDAT;
} }
void SectionChunk::printDiscardedMessage() const { void SectionChunk::printDiscardedMessage() const {
// Removed by dead-stripping. If it's removed by ICF, ICF already // Removed by dead-stripping. If it's removed by ICF, ICF already
// printed out the name, so don't repeat that here. // printed out the name, so don't repeat that here.
if (Sym && this == Repl) if (sym && this == repl)
message("Discarded " + Sym->getName()); message("Discarded " + sym->getName());
} }
StringRef SectionChunk::getDebugName() const { StringRef SectionChunk::getDebugName() const {
if (Sym) if (sym)
return Sym->getName(); return sym->getName();
return ""; return "";
} }
ArrayRef<uint8_t> SectionChunk::getContents() const { ArrayRef<uint8_t> SectionChunk::getContents() const {
ArrayRef<uint8_t> A; ArrayRef<uint8_t> a;
cantFail(File->getCOFFObj()->getSectionContents(Header, A)); cantFail(file->getCOFFObj()->getSectionContents(header, a));
return A; return a;
} }
ArrayRef<uint8_t> SectionChunk::consumeDebugMagic() { ArrayRef<uint8_t> SectionChunk::consumeDebugMagic() {
assert(isCodeView()); assert(isCodeView());
return consumeDebugMagic(getContents(), getSectionName()); return consumeDebugMagic(getContents(), getSectionName());
} }
ArrayRef<uint8_t> SectionChunk::consumeDebugMagic(ArrayRef<uint8_t> Data, ArrayRef<uint8_t> SectionChunk::consumeDebugMagic(ArrayRef<uint8_t> data,
StringRef SectionName) { StringRef sectionName) {
if (Data.empty()) if (data.empty())
return {}; return {};
// First 4 bytes are section magic. // First 4 bytes are section magic.
if (Data.size() < 4) if (data.size() < 4)
fatal("the section is too short: " + SectionName); fatal("the section is too short: " + sectionName);
if (!SectionName.startswith(".debug$")) if (!sectionName.startswith(".debug$"))
fatal("invalid section: " + SectionName); fatal("invalid section: " + sectionName);
uint32_t Magic = support::endian::read32le(Data.data()); uint32_t magic = support::endian::read32le(data.data());
uint32_t ExpectedMagic = SectionName == ".debug$H" uint32_t expectedMagic = sectionName == ".debug$H"
? DEBUG_HASHES_SECTION_MAGIC ? DEBUG_HASHES_SECTION_MAGIC
: DEBUG_SECTION_MAGIC; : DEBUG_SECTION_MAGIC;
if (Magic != ExpectedMagic) { if (magic != expectedMagic) {
warn("ignoring section " + SectionName + " with unrecognized magic 0x" + warn("ignoring section " + sectionName + " with unrecognized magic 0x" +
utohexstr(Magic)); utohexstr(magic));
return {}; return {};
} }
return Data.slice(4); return data.slice(4);
} }
SectionChunk *SectionChunk::findByName(ArrayRef<SectionChunk *> Sections, SectionChunk *SectionChunk::findByName(ArrayRef<SectionChunk *> sections,
StringRef Name) { StringRef name) {
for (SectionChunk *C : Sections) for (SectionChunk *c : sections)
if (C->getSectionName() == Name) if (c->getSectionName() == name)
return C; return c;
return nullptr; return nullptr;
} }
void SectionChunk::replace(SectionChunk *Other) { void SectionChunk::replace(SectionChunk *other) {
P2Align = std::max(P2Align, Other->P2Align); p2Align = std::max(p2Align, other->p2Align);
Other->Repl = Repl; other->repl = repl;
Other->Live = false; other->live = false;
} }
uint32_t SectionChunk::getSectionNumber() const { uint32_t SectionChunk::getSectionNumber() const {
DataRefImpl R; DataRefImpl r;
R.p = reinterpret_cast<uintptr_t>(Header); r.p = reinterpret_cast<uintptr_t>(header);
SectionRef S(R, File->getCOFFObj()); SectionRef s(r, file->getCOFFObj());
return S.getIndex() + 1; return s.getIndex() + 1;
} }
CommonChunk::CommonChunk(const COFFSymbolRef S) : Sym(S) { CommonChunk::CommonChunk(const COFFSymbolRef s) : sym(s) {
// The value of a common symbol is its size. Align all common symbols smaller // The value of a common symbol is its size. Align all common symbols smaller
// than 32 bytes naturally, i.e. round the size up to the next power of two. // than 32 bytes naturally, i.e. round the size up to the next power of two.
// This is what MSVC link.exe does. // This is what MSVC link.exe does.
setAlignment(std::min(32U, uint32_t(PowerOf2Ceil(Sym.getValue())))); setAlignment(std::min(32U, uint32_t(PowerOf2Ceil(sym.getValue()))));
HasData = false; hasData = false;
} }
uint32_t CommonChunk::getOutputCharacteristics() const { uint32_t CommonChunk::getOutputCharacteristics() const {
return IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ | return IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ |
IMAGE_SCN_MEM_WRITE; IMAGE_SCN_MEM_WRITE;
} }
void StringChunk::writeTo(uint8_t *Buf) const { void StringChunk::writeTo(uint8_t *buf) const {
memcpy(Buf, Str.data(), Str.size()); memcpy(buf, str.data(), str.size());
Buf[Str.size()] = '\0'; buf[str.size()] = '\0';
} }
ImportThunkChunkX64::ImportThunkChunkX64(Defined *S) : ImportThunkChunk(S) { ImportThunkChunkX64::ImportThunkChunkX64(Defined *s) : ImportThunkChunk(s) {
// Intel Optimization Manual says that all branch targets // Intel Optimization Manual says that all branch targets
// should be 16-byte aligned. MSVC linker does this too. // should be 16-byte aligned. MSVC linker does this too.
setAlignment(16); setAlignment(16);
} }
void ImportThunkChunkX64::writeTo(uint8_t *Buf) const { void ImportThunkChunkX64::writeTo(uint8_t *buf) const {
memcpy(Buf, ImportThunkX86, sizeof(ImportThunkX86)); memcpy(buf, importThunkX86, sizeof(importThunkX86));
// The first two bytes is a JMP instruction. Fill its operand. // The first two bytes is a JMP instruction. Fill its operand.
write32le(Buf + 2, ImpSymbol->getRVA() - RVA - getSize()); write32le(buf + 2, impSymbol->getRVA() - rva - getSize());
} }
void ImportThunkChunkX86::getBaserels(std::vector<Baserel> *Res) { void ImportThunkChunkX86::getBaserels(std::vector<Baserel> *res) {
Res->emplace_back(getRVA() + 2); res->emplace_back(getRVA() + 2);
} }
void ImportThunkChunkX86::writeTo(uint8_t *Buf) const { void ImportThunkChunkX86::writeTo(uint8_t *buf) const {
memcpy(Buf, ImportThunkX86, sizeof(ImportThunkX86)); memcpy(buf, importThunkX86, sizeof(importThunkX86));
// The first two bytes is a JMP instruction. Fill its operand. // The first two bytes is a JMP instruction. Fill its operand.
write32le(Buf + 2, write32le(buf + 2,
ImpSymbol->getRVA() + Config->ImageBase); impSymbol->getRVA() + config->imageBase);
} }
void ImportThunkChunkARM::getBaserels(std::vector<Baserel> *Res) { void ImportThunkChunkARM::getBaserels(std::vector<Baserel> *res) {
Res->emplace_back(getRVA(), IMAGE_REL_BASED_ARM_MOV32T); res->emplace_back(getRVA(), IMAGE_REL_BASED_ARM_MOV32T);
} }
void ImportThunkChunkARM::writeTo(uint8_t *Buf) const { void ImportThunkChunkARM::writeTo(uint8_t *buf) const {
memcpy(Buf, ImportThunkARM, sizeof(ImportThunkARM)); memcpy(buf, importThunkARM, sizeof(importThunkARM));
// Fix mov.w and mov.t operands. // Fix mov.w and mov.t operands.
applyMOV32T(Buf, ImpSymbol->getRVA() + Config->ImageBase); applyMOV32T(buf, impSymbol->getRVA() + config->imageBase);
} }
void ImportThunkChunkARM64::writeTo(uint8_t *Buf) const { void ImportThunkChunkARM64::writeTo(uint8_t *buf) const {
int64_t Off = ImpSymbol->getRVA() & 0xfff; int64_t off = impSymbol->getRVA() & 0xfff;
memcpy(Buf, ImportThunkARM64, sizeof(ImportThunkARM64)); memcpy(buf, importThunkARM64, sizeof(importThunkARM64));
applyArm64Addr(Buf, ImpSymbol->getRVA(), RVA, 12); applyArm64Addr(buf, impSymbol->getRVA(), rva, 12);
applyArm64Ldr(Buf + 4, Off); applyArm64Ldr(buf + 4, off);
} }
// A Thumb2, PIC, non-interworking range extension thunk. // A Thumb2, PIC, non-interworking range extension thunk.
const uint8_t ArmThunk[] = { const uint8_t armThunk[] = {
0x40, 0xf2, 0x00, 0x0c, // P: movw ip,:lower16:S - (P + (L1-P) + 4) 0x40, 0xf2, 0x00, 0x0c, // P: movw ip,:lower16:S - (P + (L1-P) + 4)
0xc0, 0xf2, 0x00, 0x0c, // movt ip,:upper16:S - (P + (L1-P) + 4) 0xc0, 0xf2, 0x00, 0x0c, // movt ip,:upper16:S - (P + (L1-P) + 4)
0xe7, 0x44, // L1: add pc, ip 0xe7, 0x44, // L1: add pc, ip
}; };
size_t RangeExtensionThunkARM::getSize() const { size_t RangeExtensionThunkARM::getSize() const {
assert(Config->Machine == ARMNT); assert(config->machine == ARMNT);
return sizeof(ArmThunk); return sizeof(armThunk);
} }
void RangeExtensionThunkARM::writeTo(uint8_t *Buf) const { void RangeExtensionThunkARM::writeTo(uint8_t *buf) const {
assert(Config->Machine == ARMNT); assert(config->machine == ARMNT);
uint64_t Offset = Target->getRVA() - RVA - 12; uint64_t offset = target->getRVA() - rva - 12;
memcpy(Buf, ArmThunk, sizeof(ArmThunk)); memcpy(buf, armThunk, sizeof(armThunk));
applyMOV32T(Buf, uint32_t(Offset)); applyMOV32T(buf, uint32_t(offset));
} }
// A position independent ARM64 adrp+add thunk, with a maximum range of // A position independent ARM64 adrp+add thunk, with a maximum range of
// +/- 4 GB, which is enough for any PE-COFF. // +/- 4 GB, which is enough for any PE-COFF.
const uint8_t Arm64Thunk[] = { const uint8_t arm64Thunk[] = {
0x10, 0x00, 0x00, 0x90, // adrp x16, Dest 0x10, 0x00, 0x00, 0x90, // adrp x16, Dest
0x10, 0x02, 0x00, 0x91, // add x16, x16, :lo12:Dest 0x10, 0x02, 0x00, 0x91, // add x16, x16, :lo12:Dest
0x00, 0x02, 0x1f, 0xd6, // br x16 0x00, 0x02, 0x1f, 0xd6, // br x16
}; };
size_t RangeExtensionThunkARM64::getSize() const { size_t RangeExtensionThunkARM64::getSize() const {
assert(Config->Machine == ARM64); assert(config->machine == ARM64);
return sizeof(Arm64Thunk); return sizeof(arm64Thunk);
} }
void RangeExtensionThunkARM64::writeTo(uint8_t *Buf) const { void RangeExtensionThunkARM64::writeTo(uint8_t *buf) const {
assert(Config->Machine == ARM64); assert(config->machine == ARM64);
memcpy(Buf, Arm64Thunk, sizeof(Arm64Thunk)); memcpy(buf, arm64Thunk, sizeof(arm64Thunk));
applyArm64Addr(Buf + 0, Target->getRVA(), RVA, 12); applyArm64Addr(buf + 0, target->getRVA(), rva, 12);
applyArm64Imm(Buf + 4, Target->getRVA() & 0xfff, 0); applyArm64Imm(buf + 4, target->getRVA() & 0xfff, 0);
} }
void LocalImportChunk::getBaserels(std::vector<Baserel> *Res) { void LocalImportChunk::getBaserels(std::vector<Baserel> *res) {
Res->emplace_back(getRVA()); res->emplace_back(getRVA());
} }
size_t LocalImportChunk::getSize() const { return Config->Wordsize; } size_t LocalImportChunk::getSize() const { return config->wordsize; }
void LocalImportChunk::writeTo(uint8_t *Buf) const { void LocalImportChunk::writeTo(uint8_t *buf) const {
if (Config->is64()) { if (config->is64()) {
write64le(Buf, Sym->getRVA() + Config->ImageBase); write64le(buf, sym->getRVA() + config->imageBase);
} else { } else {
write32le(Buf, Sym->getRVA() + Config->ImageBase); write32le(buf, sym->getRVA() + config->imageBase);
} }
} }
void RVATableChunk::writeTo(uint8_t *Buf) const { void RVATableChunk::writeTo(uint8_t *buf) const {
ulittle32_t *Begin = reinterpret_cast<ulittle32_t *>(Buf); ulittle32_t *begin = reinterpret_cast<ulittle32_t *>(buf);
size_t Cnt = 0; size_t cnt = 0;
for (const ChunkAndOffset &CO : Syms) for (const ChunkAndOffset &co : syms)
Begin[Cnt++] = CO.InputChunk->getRVA() + CO.Offset; begin[cnt++] = co.inputChunk->getRVA() + co.offset;
std::sort(Begin, Begin + Cnt); std::sort(begin, begin + cnt);
assert(std::unique(Begin, Begin + Cnt) == Begin + Cnt && assert(std::unique(begin, begin + cnt) == begin + cnt &&
"RVA tables should be de-duplicated"); "RVA tables should be de-duplicated");
} }
// MinGW specific, for the "automatic import of variables from DLLs" feature. // MinGW specific, for the "automatic import of variables from DLLs" feature.
size_t PseudoRelocTableChunk::getSize() const { size_t PseudoRelocTableChunk::getSize() const {
if (Relocs.empty()) if (relocs.empty())
return 0; return 0;
return 12 + 12 * Relocs.size(); return 12 + 12 * relocs.size();
} }
// MinGW specific. // MinGW specific.
void PseudoRelocTableChunk::writeTo(uint8_t *Buf) const { void PseudoRelocTableChunk::writeTo(uint8_t *buf) const {
if (Relocs.empty()) if (relocs.empty())
return; return;
ulittle32_t *Table = reinterpret_cast<ulittle32_t *>(Buf); ulittle32_t *table = reinterpret_cast<ulittle32_t *>(buf);
// This is the list header, to signal the runtime pseudo relocation v2 // This is the list header, to signal the runtime pseudo relocation v2
// format. // format.
Table[0] = 0; table[0] = 0;
Table[1] = 0; table[1] = 0;
Table[2] = 1; table[2] = 1;
size_t Idx = 3; size_t idx = 3;
for (const RuntimePseudoReloc &RPR : Relocs) { for (const RuntimePseudoReloc &rpr : relocs) {
Table[Idx + 0] = RPR.Sym->getRVA(); table[idx + 0] = rpr.sym->getRVA();
Table[Idx + 1] = RPR.Target->getRVA() + RPR.TargetOffset; table[idx + 1] = rpr.target->getRVA() + rpr.targetOffset;
Table[Idx + 2] = RPR.Flags; table[idx + 2] = rpr.flags;
Idx += 3; idx += 3;
} }
} }
// Windows-specific. This class represents a block in .reloc section. // Windows-specific. This class represents a block in .reloc section.
// The format is described here. // The format is described here.
// //
// On Windows, each DLL is linked against a fixed base address and // On Windows, each DLL is linked against a fixed base address and
// usually loaded to that address. However, if there's already another // usually loaded to that address. However, if there's already another
Show All 26 Lines
// 0xAA00 // 0xAA00
// 0x20000 -- page address (4 bytes) // 0x20000 -- page address (4 bytes)
// 12 -- size of this block (4 bytes) // 12 -- size of this block (4 bytes)
// 0xA004 -- entries (2 bytes each) // 0xA004 -- entries (2 bytes each)
// 0xA008 // 0xA008
// //
// Usually we have a lot of relocations for each page, so the number of // Usually we have a lot of relocations for each page, so the number of
// bytes for one .reloc entry is close to 2 bytes on average. // bytes for one .reloc entry is close to 2 bytes on average.
BaserelChunk::BaserelChunk(uint32_t Page, Baserel *Begin, Baserel *End) { BaserelChunk::BaserelChunk(uint32_t page, Baserel *begin, Baserel *end) {
// Block header consists of 4 byte page RVA and 4 byte block size. // Block header consists of 4 byte page RVA and 4 byte block size.
// Each entry is 2 byte. Last entry may be padding. // Each entry is 2 byte. Last entry may be padding.
Data.resize(alignTo((End - Begin) * 2 + 8, 4)); data.resize(alignTo((end - begin) * 2 + 8, 4));
uint8_t *P = Data.data(); uint8_t *p = data.data();
write32le(P, Page); write32le(p, page);
write32le(P + 4, Data.size()); write32le(p + 4, data.size());
P += 8; p += 8;
for (Baserel *I = Begin; I != End; ++I) { for (Baserel *i = begin; i != end; ++i) {
write16le(P, (I->Type << 12) | (I->RVA - Page)); write16le(p, (i->type << 12) | (i->rva - page));
P += 2; p += 2;
} }
} }
void BaserelChunk::writeTo(uint8_t *Buf) const { void BaserelChunk::writeTo(uint8_t *buf) const {
memcpy(Buf, Data.data(), Data.size()); memcpy(buf, data.data(), data.size());
} }
uint8_t Baserel::getDefaultType() { uint8_t Baserel::getDefaultType() {
switch (Config->Machine) { switch (config->machine) {
case AMD64: case AMD64:
case ARM64: case ARM64:
return IMAGE_REL_BASED_DIR64; return IMAGE_REL_BASED_DIR64;
case I386: case I386:
case ARMNT: case ARMNT:
return IMAGE_REL_BASED_HIGHLOW; return IMAGE_REL_BASED_HIGHLOW;
default: default:
llvm_unreachable("unknown machine type"); llvm_unreachable("unknown machine type");
} }
} }
MergeChunk *MergeChunk::Instances[Log2MaxSectionAlignment + 1] = {}; MergeChunk *MergeChunk::instances[Log2MaxSectionAlignment + 1] = {};
MergeChunk::MergeChunk(uint32_t Alignment) MergeChunk::MergeChunk(uint32_t alignment)
: Builder(StringTableBuilder::RAW, Alignment) { : builder(StringTableBuilder::RAW, alignment) {
setAlignment(Alignment); setAlignment(alignment);
} }
void MergeChunk::addSection(SectionChunk *C) { void MergeChunk::addSection(SectionChunk *c) {
assert(isPowerOf2_32(C->getAlignment())); assert(isPowerOf2_32(c->getAlignment()));
uint8_t P2Align = llvm::Log2_32(C->getAlignment()); uint8_t p2Align = llvm::Log2_32(c->getAlignment());
assert(P2Align < array_lengthof(Instances)); assert(p2Align < array_lengthof(instances));
auto *&MC = Instances[P2Align]; auto *&mc = instances[p2Align];
if (!MC) if (!mc)
MC = make<MergeChunk>(C->getAlignment()); mc = make<MergeChunk>(c->getAlignment());
MC->Sections.push_back(C); mc->sections.push_back(c);
} }
void MergeChunk::finalizeContents() { void MergeChunk::finalizeContents() {
assert(!Finalized && "should only finalize once"); assert(!finalized && "should only finalize once");
for (SectionChunk *C : Sections) for (SectionChunk *c : sections)
if (C->Live) if (c->live)
Builder.add(toStringRef(C->getContents())); builder.add(toStringRef(c->getContents()));
Builder.finalize(); builder.finalize();
Finalized = true; finalized = true;
} }
void MergeChunk::assignSubsectionRVAs() { void MergeChunk::assignSubsectionRVAs() {
for (SectionChunk *C : Sections) { for (SectionChunk *c : sections) {
if (!C->Live) if (!c->live)
continue; continue;
size_t Off = Builder.getOffset(toStringRef(C->getContents())); size_t off = builder.getOffset(toStringRef(c->getContents()));
C->setRVA(RVA + Off); c->setRVA(rva + off);
} }
} }
uint32_t MergeChunk::getOutputCharacteristics() const { uint32_t MergeChunk::getOutputCharacteristics() const {
return IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA; return IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA;
} }
size_t MergeChunk::getSize() const { size_t MergeChunk::getSize() const {
return Builder.getSize(); return builder.getSize();
} }
void MergeChunk::writeTo(uint8_t *Buf) const { void MergeChunk::writeTo(uint8_t *buf) const {
Builder.write(Buf); builder.write(buf);
} }
// MinGW specific. // MinGW specific.
size_t AbsolutePointerChunk::getSize() const { return Config->Wordsize; } size_t AbsolutePointerChunk::getSize() const { return config->wordsize; }
void AbsolutePointerChunk::writeTo(uint8_t *Buf) const { void AbsolutePointerChunk::writeTo(uint8_t *buf) const {
if (Config->is64()) { if (config->is64()) {
write64le(Buf, Value); write64le(buf, value);
} else { } else {
write32le(Buf, Value); write32le(buf, value);
} }
} }
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld

lld/trunk/COFF/Config.h

Show All 32 Lines
// Short aliases. // Short aliases.
static const auto AMD64 = llvm::COFF::IMAGE_FILE_MACHINE_AMD64; static const auto AMD64 = llvm::COFF::IMAGE_FILE_MACHINE_AMD64;
static const auto ARM64 = llvm::COFF::IMAGE_FILE_MACHINE_ARM64; static const auto ARM64 = llvm::COFF::IMAGE_FILE_MACHINE_ARM64;
static const auto ARMNT = llvm::COFF::IMAGE_FILE_MACHINE_ARMNT; static const auto ARMNT = llvm::COFF::IMAGE_FILE_MACHINE_ARMNT;
static const auto I386 = llvm::COFF::IMAGE_FILE_MACHINE_I386; static const auto I386 = llvm::COFF::IMAGE_FILE_MACHINE_I386;
// Represents an /export option. // Represents an /export option.
struct Export { struct Export {
StringRef Name; // N in /export:N or /export:E=N StringRef name; // N in /export:N or /export:E=N
StringRef ExtName; // E in /export:E=N StringRef extName; // E in /export:E=N
Symbol *Sym = nullptr; Symbol *sym = nullptr;
uint16_t Ordinal = 0; uint16_t ordinal = 0;
bool Noname = false; bool noname = false;
bool Data = false; bool data = false;
bool Private = false; bool isPrivate = false;
bool Constant = false; bool constant = false;
// If an export is a form of /export:foo=dllname.bar, that means // If an export is a form of /export:foo=dllname.bar, that means
// that foo should be exported as an alias to bar in the DLL. // that foo should be exported as an alias to bar in the DLL.
// ForwardTo is set to "dllname.bar" part. Usually empty. // ForwardTo is set to "dllname.bar" part. Usually empty.
StringRef ForwardTo; StringRef forwardTo;
StringChunk *ForwardChunk = nullptr; StringChunk *forwardChunk = nullptr;
// True if this /export option was in .drectves section. // True if this /export option was in .drectves section.
bool Directives = false; bool directives = false;
StringRef SymbolName; StringRef symbolName;
StringRef ExportName; // Name in DLL StringRef exportName; // Name in DLL
bool operator==(const Export &E) { bool operator==(const Export &e) {
return (Name == E.Name && ExtName == E.ExtName && return (name == e.name && extName == e.extName &&
Ordinal == E.Ordinal && Noname == E.Noname && ordinal == e.ordinal && noname == e.noname &&
Data == E.Data && Private == E.Private); data == e.data && isPrivate == e.isPrivate);
} }
}; };
enum class DebugType { enum class DebugType {
None = 0x0, None = 0x0,
CV = 0x1, /// CodeView CV = 0x1, /// CodeView
PData = 0x2, /// Procedure Data PData = 0x2, /// Procedure Data
Fixup = 0x4, /// Relocation Table Fixup = 0x4, /// Relocation Table
}; };
enum class GuardCFLevel { enum class GuardCFLevel {
Off, Off,
NoLongJmp, // Emit gfids but no longjmp tables NoLongJmp, // Emit gfids but no longjmp tables
Full, // Enable all protections. Full, // Enable all protections.
}; };
// Global configuration. // Global configuration.
struct Configuration { struct Configuration {
enum ManifestKind { SideBySide, Embed, No }; enum ManifestKind { SideBySide, Embed, No };
bool is64() { return Machine == AMD64 || Machine == ARM64; } bool is64() { return machine == AMD64 || machine == ARM64; }
llvm::COFF::MachineTypes Machine = IMAGE_FILE_MACHINE_UNKNOWN; llvm::COFF::MachineTypes machine = IMAGE_FILE_MACHINE_UNKNOWN;
size_t Wordsize; size_t wordsize;
bool Verbose = false; bool verbose = false;
WindowsSubsystem Subsystem = llvm::COFF::IMAGE_SUBSYSTEM_UNKNOWN; WindowsSubsystem subsystem = llvm::COFF::IMAGE_SUBSYSTEM_UNKNOWN;
Symbol *Entry = nullptr; Symbol *entry = nullptr;
bool NoEntry = false; bool noEntry = false;
std::string OutputFile; std::string outputFile;
std::string ImportName; std::string importName;
bool Demangle = true; bool demangle = true;
bool DoGC = true; bool doGC = true;
bool DoICF = true; bool doICF = true;
bool TailMerge; bool tailMerge;
bool Relocatable = true; bool relocatable = true;
bool ForceMultiple = false; bool forceMultiple = false;
bool ForceMultipleRes = false; bool forceMultipleRes = false;
bool ForceUnresolved = false; bool forceUnresolved = false;
bool Debug = false; bool debug = false;
bool DebugDwarf = false; bool debugDwarf = false;
bool DebugGHashes = false; bool debugGHashes = false;
bool DebugSymtab = false; bool debugSymtab = false;
bool ShowTiming = false; bool showTiming = false;
bool ShowSummary = false; bool showSummary = false;
unsigned DebugTypes = static_cast<unsigned>(DebugType::None); unsigned debugTypes = static_cast<unsigned>(DebugType::None);
std::vector<std::string> NatvisFiles; std::vector<std::string> natvisFiles;
llvm::SmallString<128> PDBAltPath; llvm::SmallString<128> pdbAltPath;
llvm::SmallString<128> PDBPath; llvm::SmallString<128> pdbPath;
llvm::SmallString<128> PDBSourcePath; llvm::SmallString<128> pdbSourcePath;
std::vector<llvm::StringRef> Argv; std::vector<llvm::StringRef> argv;
// Symbols in this set are considered as live by the garbage collector. // Symbols in this set are considered as live by the garbage collector.
std::vector<Symbol *> GCRoot; std::vector<Symbol *> gCRoot;
std::set<std::string> NoDefaultLibs; std::set<std::string> noDefaultLibs;
bool NoDefaultLibAll = false; bool noDefaultLibAll = false;
// True if we are creating a DLL. // True if we are creating a DLL.
bool DLL = false; bool dll = false;
StringRef Implib; StringRef implib;
std::vector<Export> Exports; std::vector<Export> exports;
std::set<std::string> DelayLoads; std::set<std::string> delayLoads;
std::map<std::string, int> DLLOrder; std::map<std::string, int> dllOrder;
Symbol *DelayLoadHelper = nullptr; Symbol *delayLoadHelper = nullptr;
bool SaveTemps = false; bool saveTemps = false;
// /guard:cf // /guard:cf
GuardCFLevel GuardCF = GuardCFLevel::Off; GuardCFLevel guardCF = GuardCFLevel::Off;
// Used for SafeSEH. // Used for SafeSEH.
Symbol *SEHTable = nullptr; Symbol *sehTable = nullptr;
Symbol *SEHCount = nullptr; Symbol *sehCount = nullptr;
// Used for /opt:lldlto=N // Used for /opt:lldlto=N
unsigned LTOO = 2; unsigned ltoo = 2;
// Used for /opt:lldltojobs=N // Used for /opt:lldltojobs=N
unsigned ThinLTOJobs = 0; unsigned thinLTOJobs = 0;
// Used for /opt:lldltopartitions=N // Used for /opt:lldltopartitions=N
unsigned LTOPartitions = 1; unsigned ltoPartitions = 1;
// Used for /opt:lldltocache=path // Used for /opt:lldltocache=path
StringRef LTOCache; StringRef ltoCache;
// Used for /opt:lldltocachepolicy=policy // Used for /opt:lldltocachepolicy=policy
llvm::CachePruningPolicy LTOCachePolicy; llvm::CachePruningPolicy ltoCachePolicy;
// Used for /merge:from=to (e.g. /merge:.rdata=.text) // Used for /merge:from=to (e.g. /merge:.rdata=.text)
std::map<StringRef, StringRef> Merge; std::map<StringRef, StringRef> merge;
// Used for /section=.name,{DEKPRSW} to set section attributes. // Used for /section=.name,{DEKPRSW} to set section attributes.
std::map<StringRef, uint32_t> Section; std::map<StringRef, uint32_t> section;
// Options for manifest files. // Options for manifest files.
ManifestKind Manifest = No; ManifestKind manifest = No;
int ManifestID = 1; int manifestID = 1;
StringRef ManifestDependency; StringRef manifestDependency;
bool ManifestUAC = true; bool manifestUAC = true;
std::vector<std::string> ManifestInput; std::vector<std::string> manifestInput;
StringRef ManifestLevel = "'asInvoker'"; StringRef manifestLevel = "'asInvoker'";
StringRef ManifestUIAccess = "'false'"; StringRef manifestUIAccess = "'false'";
StringRef ManifestFile; StringRef manifestFile;
// Used for /aligncomm. // Used for /aligncomm.
std::map<std::string, int> AlignComm; std::map<std::string, int> alignComm;
// Used for /failifmismatch. // Used for /failifmismatch.
std::map<StringRef, std::pair<StringRef, InputFile *>> MustMatch; std::map<StringRef, std::pair<StringRef, InputFile *>> mustMatch;
// Used for /alternatename. // Used for /alternatename.
std::map<StringRef, StringRef> AlternateNames; std::map<StringRef, StringRef> alternateNames;
// Used for /order. // Used for /order.
llvm::StringMap<int> Order; llvm::StringMap<int> order;
// Used for /lldmap. // Used for /lldmap.
std::string MapFile; std::string mapFile;
uint64_t ImageBase = -1; uint64_t imageBase = -1;
uint64_t FileAlign = 512; uint64_t fileAlign = 512;
uint64_t StackReserve = 1024 * 1024; uint64_t stackReserve = 1024 * 1024;
uint64_t StackCommit = 4096; uint64_t stackCommit = 4096;
uint64_t HeapReserve = 1024 * 1024; uint64_t heapReserve = 1024 * 1024;
uint64_t HeapCommit = 4096; uint64_t heapCommit = 4096;
uint32_t MajorImageVersion = 0; uint32_t majorImageVersion = 0;
uint32_t MinorImageVersion = 0; uint32_t minorImageVersion = 0;
uint32_t MajorOSVersion = 6; uint32_t majorOSVersion = 6;
uint32_t MinorOSVersion = 0; uint32_t minorOSVersion = 0;
uint32_t Timestamp = 0; uint32_t timestamp = 0;
uint32_t FunctionPadMin = 0; uint32_t functionPadMin = 0;
bool DynamicBase = true; bool dynamicBase = true;
bool AllowBind = true; bool allowBind = true;
bool NxCompat = true; bool nxCompat = true;
bool AllowIsolation = true; bool allowIsolation = true;
bool TerminalServerAware = true; bool terminalServerAware = true;
bool LargeAddressAware = false; bool largeAddressAware = false;
bool HighEntropyVA = false; bool highEntropyVA = false;
bool AppContainer = false; bool appContainer = false;
bool MinGW = false; bool mingw = false;
bool WarnMissingOrderSymbol = true; bool warnMissingOrderSymbol = true;
bool WarnLocallyDefinedImported = true; bool warnLocallyDefinedImported = true;
bool WarnDebugInfoUnusable = true; bool warnDebugInfoUnusable = true;
bool Incremental = true; bool incremental = true;
bool IntegrityCheck = false; bool integrityCheck = false;
bool KillAt = false; bool killAt = false;
bool Repro = false; bool repro = false;
bool SwaprunCD = false; bool swaprunCD = false;
bool SwaprunNet = false; bool swaprunNet = false;
}; };
extern Configuration *Config; extern Configuration *config;
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/COFF/DLL.h

Show All 15 Lines
namespace coff { namespace coff {
// Windows-specific. // Windows-specific.
// IdataContents creates all chunks for the DLL import table. // IdataContents creates all chunks for the DLL import table.
// You are supposed to call add() to add symbols and then // You are supposed to call add() to add symbols and then
// call create() to populate the chunk vectors. // call create() to populate the chunk vectors.
class IdataContents { class IdataContents {
public: public:
void add(DefinedImportData *Sym) { Imports.push_back(Sym); } void add(DefinedImportData *sym) { imports.push_back(sym); }
bool empty() { return Imports.empty(); } bool empty() { return imports.empty(); }
void create(); void create();
std::vector<DefinedImportData *> Imports; std::vector<DefinedImportData *> imports;
std::vector<Chunk *> Dirs; std::vector<Chunk *> dirs;
std::vector<Chunk *> Lookups; std::vector<Chunk *> lookups;
std::vector<Chunk *> Addresses; std::vector<Chunk *> addresses;
std::vector<Chunk *> Hints; std::vector<Chunk *> hints;
std::vector<Chunk *> DLLNames; std::vector<Chunk *> dllNames;
}; };
// Windows-specific. // Windows-specific.
// DelayLoadContents creates all chunks for the delay-load DLL import table. // DelayLoadContents creates all chunks for the delay-load DLL import table.
class DelayLoadContents { class DelayLoadContents {
public: public:
void add(DefinedImportData *Sym) { Imports.push_back(Sym); } void add(DefinedImportData *sym) { imports.push_back(sym); }
bool empty() { return Imports.empty(); } bool empty() { return imports.empty(); }
void create(Defined *Helper); void create(Defined *helper);
std::vector<Chunk *> getChunks(); std::vector<Chunk *> getChunks();
std::vector<Chunk *> getDataChunks(); std::vector<Chunk *> getDataChunks();
ArrayRef<Chunk *> getCodeChunks() { return Thunks; } ArrayRef<Chunk *> getCodeChunks() { return thunks; }
uint64_t getDirRVA() { return Dirs[0]->getRVA(); } uint64_t getDirRVA() { return dirs[0]->getRVA(); }
uint64_t getDirSize(); uint64_t getDirSize();
private: private:
Chunk *newThunkChunk(DefinedImportData *S, Chunk *Dir); Chunk *newThunkChunk(DefinedImportData *s, Chunk *dir);
Defined *Helper; Defined *helper;
std::vector<DefinedImportData *> Imports; std::vector<DefinedImportData *> imports;
std::vector<Chunk *> Dirs; std::vector<Chunk *> dirs;
std::vector<Chunk *> ModuleHandles; std::vector<Chunk *> moduleHandles;
std::vector<Chunk *> Addresses; std::vector<Chunk *> addresses;
std::vector<Chunk *> Names; std::vector<Chunk *> names;
std::vector<Chunk *> HintNames; std::vector<Chunk *> hintNames;
std::vector<Chunk *> Thunks; std::vector<Chunk *> thunks;
std::vector<Chunk *> DLLNames; std::vector<Chunk *> dllNames;
}; };
// Windows-specific. // Windows-specific.
// EdataContents creates all chunks for the DLL export table. // EdataContents creates all chunks for the DLL export table.
class EdataContents { class EdataContents {
public: public:
EdataContents(); EdataContents();
std::vector<Chunk *> Chunks; std::vector<Chunk *> chunks;
uint64_t getRVA() { return Chunks[0]->getRVA(); } uint64_t getRVA() { return chunks[0]->getRVA(); }
uint64_t getSize() { uint64_t getSize() {
return Chunks.back()->getRVA() + Chunks.back()->getSize() - getRVA(); return chunks.back()->getRVA() + chunks.back()->getSize() - getRVA();
} }
}; };
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/COFF/DLL.cpp

Show All 31 Lines
namespace coff { namespace coff {
namespace { namespace {
// Import table // Import table
// A chunk for the import descriptor table. // A chunk for the import descriptor table.
class HintNameChunk : public NonSectionChunk { class HintNameChunk : public NonSectionChunk {
public: public:
HintNameChunk(StringRef N, uint16_t H) : Name(N), Hint(H) {} HintNameChunk(StringRef n, uint16_t h) : name(n), hint(h) {}
size_t getSize() const override { size_t getSize() const override {
// Starts with 2 byte Hint field, followed by a null-terminated string, // Starts with 2 byte Hint field, followed by a null-terminated string,
// ends with 0 or 1 byte padding. // ends with 0 or 1 byte padding.
return alignTo(Name.size() + 3, 2); return alignTo(name.size() + 3, 2);
} }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
memset(Buf, 0, getSize()); memset(buf, 0, getSize());
write16le(Buf, Hint); write16le(buf, hint);
memcpy(Buf + 2, Name.data(), Name.size()); memcpy(buf + 2, name.data(), name.size());
} }
private: private:
StringRef Name; StringRef name;
uint16_t Hint; uint16_t hint;
}; };
// A chunk for the import descriptor table. // A chunk for the import descriptor table.
class LookupChunk : public NonSectionChunk { class LookupChunk : public NonSectionChunk {
public: public:
explicit LookupChunk(Chunk *C) : HintName(C) { explicit LookupChunk(Chunk *c) : hintName(c) {
setAlignment(Config->Wordsize); setAlignment(config->wordsize);
} }
size_t getSize() const override { return Config->Wordsize; } size_t getSize() const override { return config->wordsize; }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
if (Config->is64()) if (config->is64())
write64le(Buf, HintName->getRVA()); write64le(buf, hintName->getRVA());
else else
write32le(Buf, HintName->getRVA()); write32le(buf, hintName->getRVA());
} }
Chunk *HintName; Chunk *hintName;
}; };
// A chunk for the import descriptor table. // A chunk for the import descriptor table.
// This chunk represent import-by-ordinal symbols. // This chunk represent import-by-ordinal symbols.
// See Microsoft PE/COFF spec 7.1. Import Header for details. // See Microsoft PE/COFF spec 7.1. Import Header for details.
class OrdinalOnlyChunk : public NonSectionChunk { class OrdinalOnlyChunk : public NonSectionChunk {
public: public:
explicit OrdinalOnlyChunk(uint16_t V) : Ordinal(V) { explicit OrdinalOnlyChunk(uint16_t v) : ordinal(v) {
setAlignment(Config->Wordsize); setAlignment(config->wordsize);
} }
size_t getSize() const override { return Config->Wordsize; } size_t getSize() const override { return config->wordsize; }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
// An import-by-ordinal slot has MSB 1 to indicate that // An import-by-ordinal slot has MSB 1 to indicate that
// this is import-by-ordinal (and not import-by-name). // this is import-by-ordinal (and not import-by-name).
if (Config->is64()) { if (config->is64()) {
write64le(Buf, (1ULL << 63) | Ordinal); write64le(buf, (1ULL << 63) | ordinal);
} else { } else {
write32le(Buf, (1ULL << 31) | Ordinal); write32le(buf, (1ULL << 31) | ordinal);
} }
} }
uint16_t Ordinal; uint16_t ordinal;
}; };
// A chunk for the import descriptor table. // A chunk for the import descriptor table.
class ImportDirectoryChunk : public NonSectionChunk { class ImportDirectoryChunk : public NonSectionChunk {
public: public:
explicit ImportDirectoryChunk(Chunk *N) : DLLName(N) {} explicit ImportDirectoryChunk(Chunk *n) : dllName(n) {}
size_t getSize() const override { return sizeof(ImportDirectoryTableEntry); } size_t getSize() const override { return sizeof(ImportDirectoryTableEntry); }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
memset(Buf, 0, getSize()); memset(buf, 0, getSize());
auto *E = (coff_import_directory_table_entry *)(Buf); auto *e = (coff_import_directory_table_entry *)(buf);
E->ImportLookupTableRVA = LookupTab->getRVA(); e->ImportLookupTableRVA = lookupTab->getRVA();
E->NameRVA = DLLName->getRVA(); e->NameRVA = dllName->getRVA();
E->ImportAddressTableRVA = AddressTab->getRVA(); e->ImportAddressTableRVA = addressTab->getRVA();
} }
Chunk *DLLName; Chunk *dllName;
Chunk *LookupTab; Chunk *lookupTab;
Chunk *AddressTab; Chunk *addressTab;
}; };
// A chunk representing null terminator in the import table. // A chunk representing null terminator in the import table.
// Contents of this chunk is always null bytes. // Contents of this chunk is always null bytes.
class NullChunk : public NonSectionChunk { class NullChunk : public NonSectionChunk {
public: public:
explicit NullChunk(size_t N) : Size(N) { HasData = false; } explicit NullChunk(size_t n) : size(n) { hasData = false; }
size_t getSize() const override { return Size; } size_t getSize() const override { return size; }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
memset(Buf, 0, Size); memset(buf, 0, size);
} }
private: private:
size_t Size; size_t size;
}; };
static std::vector<std::vector<DefinedImportData *>> static std::vector<std::vector<DefinedImportData *>>
binImports(const std::vector<DefinedImportData *> &Imports) { binImports(const std::vector<DefinedImportData *> &imports) {
// Group DLL-imported symbols by DLL name because that's how // Group DLL-imported symbols by DLL name because that's how
// symbols are layed out in the import descriptor table. // symbols are layed out in the import descriptor table.
auto Less = [](const std::string &A, const std::string &B) { auto less = [](const std::string &a, const std::string &b) {
return Config->DLLOrder[A] < Config->DLLOrder[B]; return config->dllOrder[a] < config->dllOrder[b];
}; };
std::map<std::string, std::vector<DefinedImportData *>, std::map<std::string, std::vector<DefinedImportData *>,
bool(*)(const std::string &, const std::string &)> M(Less); bool(*)(const std::string &, const std::string &)> m(less);
for (DefinedImportData *Sym : Imports) for (DefinedImportData *sym : imports)
M[Sym->getDLLName().lower()].push_back(Sym); m[sym->getDLLName().lower()].push_back(sym);
std::vector<std::vector<DefinedImportData *>> V; std::vector<std::vector<DefinedImportData *>> v;
for (auto &KV : M) { for (auto &kv : m) {
// Sort symbols by name for each group. // Sort symbols by name for each group.
std::vector<DefinedImportData *> &Syms = KV.second; std::vector<DefinedImportData *> &syms = kv.second;
std::sort(Syms.begin(), Syms.end(), std::sort(syms.begin(), syms.end(),
[](DefinedImportData *A, DefinedImportData *B) { [](DefinedImportData *a, DefinedImportData *b) {
return A->getName() < B->getName(); return a->getName() < b->getName();
}); });
V.push_back(std::move(Syms)); v.push_back(std::move(syms));
} }
return V; return v;
} }
// Export table // Export table
// See Microsoft PE/COFF spec 4.3 for details. // See Microsoft PE/COFF spec 4.3 for details.
// A chunk for the delay import descriptor table etnry. // A chunk for the delay import descriptor table etnry.
class DelayDirectoryChunk : public NonSectionChunk { class DelayDirectoryChunk : public NonSectionChunk {
public: public:
explicit DelayDirectoryChunk(Chunk *N) : DLLName(N) {} explicit DelayDirectoryChunk(Chunk *n) : dllName(n) {}
size_t getSize() const override { size_t getSize() const override {
return sizeof(delay_import_directory_table_entry); return sizeof(delay_import_directory_table_entry);
} }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
memset(Buf, 0, getSize()); memset(buf, 0, getSize());
auto *E = (delay_import_directory_table_entry *)(Buf); auto *e = (delay_import_directory_table_entry *)(buf);
E->Attributes = 1; e->Attributes = 1;
E->Name = DLLName->getRVA(); e->Name = dllName->getRVA();
E->ModuleHandle = ModuleHandle->getRVA(); e->ModuleHandle = moduleHandle->getRVA();
E->DelayImportAddressTable = AddressTab->getRVA(); e->DelayImportAddressTable = addressTab->getRVA();
E->DelayImportNameTable = NameTab->getRVA(); e->DelayImportNameTable = nameTab->getRVA();
} }
Chunk *DLLName; Chunk *dllName;
Chunk *ModuleHandle; Chunk *moduleHandle;
Chunk *AddressTab; Chunk *addressTab;
Chunk *NameTab; Chunk *nameTab;
}; };
// Initial contents for delay-loaded functions. // Initial contents for delay-loaded functions.
// This code calls __delayLoadHelper2 function to resolve a symbol // This code calls __delayLoadHelper2 function to resolve a symbol
// and then overwrites its jump table slot with the result // and then overwrites its jump table slot with the result
// for subsequent function calls. // for subsequent function calls.
static const uint8_t ThunkX64[] = { static const uint8_t thunkX64[] = {
0x51, // push rcx 0x51, // push rcx
0x52, // push rdx 0x52, // push rdx
0x41, 0x50, // push r8 0x41, 0x50, // push r8
0x41, 0x51, // push r9 0x41, 0x51, // push r9
0x48, 0x83, 0xEC, 0x48, // sub rsp, 48h 0x48, 0x83, 0xEC, 0x48, // sub rsp, 48h
0x66, 0x0F, 0x7F, 0x04, 0x24, // movdqa xmmword ptr [rsp], xmm0 0x66, 0x0F, 0x7F, 0x04, 0x24, // movdqa xmmword ptr [rsp], xmm0
0x66, 0x0F, 0x7F, 0x4C, 0x24, 0x10, // movdqa xmmword ptr [rsp+10h], xmm1 0x66, 0x0F, 0x7F, 0x4C, 0x24, 0x10, // movdqa xmmword ptr [rsp+10h], xmm1
0x66, 0x0F, 0x7F, 0x54, 0x24, 0x20, // movdqa xmmword ptr [rsp+20h], xmm2 0x66, 0x0F, 0x7F, 0x54, 0x24, 0x20, // movdqa xmmword ptr [rsp+20h], xmm2
0x66, 0x0F, 0x7F, 0x5C, 0x24, 0x30, // movdqa xmmword ptr [rsp+30h], xmm3 0x66, 0x0F, 0x7F, 0x5C, 0x24, 0x30, // movdqa xmmword ptr [rsp+30h], xmm3
0x48, 0x8D, 0x15, 0, 0, 0, 0, // lea rdx, [__imp_<FUNCNAME>] 0x48, 0x8D, 0x15, 0, 0, 0, 0, // lea rdx, [__imp_<FUNCNAME>]
0x48, 0x8D, 0x0D, 0, 0, 0, 0, // lea rcx, [___DELAY_IMPORT_...] 0x48, 0x8D, 0x0D, 0, 0, 0, 0, // lea rcx, [___DELAY_IMPORT_...]
0xE8, 0, 0, 0, 0, // call __delayLoadHelper2 0xE8, 0, 0, 0, 0, // call __delayLoadHelper2
0x66, 0x0F, 0x6F, 0x04, 0x24, // movdqa xmm0, xmmword ptr [rsp] 0x66, 0x0F, 0x6F, 0x04, 0x24, // movdqa xmm0, xmmword ptr [rsp]
0x66, 0x0F, 0x6F, 0x4C, 0x24, 0x10, // movdqa xmm1, xmmword ptr [rsp+10h] 0x66, 0x0F, 0x6F, 0x4C, 0x24, 0x10, // movdqa xmm1, xmmword ptr [rsp+10h]
0x66, 0x0F, 0x6F, 0x54, 0x24, 0x20, // movdqa xmm2, xmmword ptr [rsp+20h] 0x66, 0x0F, 0x6F, 0x54, 0x24, 0x20, // movdqa xmm2, xmmword ptr [rsp+20h]
0x66, 0x0F, 0x6F, 0x5C, 0x24, 0x30, // movdqa xmm3, xmmword ptr [rsp+30h] 0x66, 0x0F, 0x6F, 0x5C, 0x24, 0x30, // movdqa xmm3, xmmword ptr [rsp+30h]
0x48, 0x83, 0xC4, 0x48, // add rsp, 48h 0x48, 0x83, 0xC4, 0x48, // add rsp, 48h
0x41, 0x59, // pop r9 0x41, 0x59, // pop r9
0x41, 0x58, // pop r8 0x41, 0x58, // pop r8
0x5A, // pop rdx 0x5A, // pop rdx
0x59, // pop rcx 0x59, // pop rcx
0xFF, 0xE0, // jmp rax 0xFF, 0xE0, // jmp rax
}; };
static const uint8_t ThunkX86[] = { static const uint8_t thunkX86[] = {
0x51, // push ecx 0x51, // push ecx
0x52, // push edx 0x52, // push edx
0x68, 0, 0, 0, 0, // push offset ___imp__<FUNCNAME> 0x68, 0, 0, 0, 0, // push offset ___imp__<FUNCNAME>
0x68, 0, 0, 0, 0, // push offset ___DELAY_IMPORT_DESCRIPTOR_<DLLNAME>_dll 0x68, 0, 0, 0, 0, // push offset ___DELAY_IMPORT_DESCRIPTOR_<DLLNAME>_dll
0xE8, 0, 0, 0, 0, // call ___delayLoadHelper2@8 0xE8, 0, 0, 0, 0, // call ___delayLoadHelper2@8
0x5A, // pop edx 0x5A, // pop edx
0x59, // pop ecx 0x59, // pop ecx
0xFF, 0xE0, // jmp eax 0xFF, 0xE0, // jmp eax
}; };
static const uint8_t ThunkARM[] = { static const uint8_t thunkARM[] = {
0x40, 0xf2, 0x00, 0x0c, // mov.w ip, #0 __imp_<FUNCNAME> 0x40, 0xf2, 0x00, 0x0c, // mov.w ip, #0 __imp_<FUNCNAME>
0xc0, 0xf2, 0x00, 0x0c, // mov.t ip, #0 __imp_<FUNCNAME> 0xc0, 0xf2, 0x00, 0x0c, // mov.t ip, #0 __imp_<FUNCNAME>
0x2d, 0xe9, 0x0f, 0x48, // push.w {r0, r1, r2, r3, r11, lr} 0x2d, 0xe9, 0x0f, 0x48, // push.w {r0, r1, r2, r3, r11, lr}
0x0d, 0xf2, 0x10, 0x0b, // addw r11, sp, #16 0x0d, 0xf2, 0x10, 0x0b, // addw r11, sp, #16
0x2d, 0xed, 0x10, 0x0b, // vpush {d0, d1, d2, d3, d4, d5, d6, d7} 0x2d, 0xed, 0x10, 0x0b, // vpush {d0, d1, d2, d3, d4, d5, d6, d7}
0x61, 0x46, // mov r1, ip 0x61, 0x46, // mov r1, ip
0x40, 0xf2, 0x00, 0x00, // mov.w r0, #0 DELAY_IMPORT_DESCRIPTOR 0x40, 0xf2, 0x00, 0x00, // mov.w r0, #0 DELAY_IMPORT_DESCRIPTOR
0xc0, 0xf2, 0x00, 0x00, // mov.t r0, #0 DELAY_IMPORT_DESCRIPTOR 0xc0, 0xf2, 0x00, 0x00, // mov.t r0, #0 DELAY_IMPORT_DESCRIPTOR
0x00, 0xf0, 0x00, 0xd0, // bl #0 __delayLoadHelper2 0x00, 0xf0, 0x00, 0xd0, // bl #0 __delayLoadHelper2
0x84, 0x46, // mov ip, r0 0x84, 0x46, // mov ip, r0
0xbd, 0xec, 0x10, 0x0b, // vpop {d0, d1, d2, d3, d4, d5, d6, d7} 0xbd, 0xec, 0x10, 0x0b, // vpop {d0, d1, d2, d3, d4, d5, d6, d7}
0xbd, 0xe8, 0x0f, 0x48, // pop.w {r0, r1, r2, r3, r11, lr} 0xbd, 0xe8, 0x0f, 0x48, // pop.w {r0, r1, r2, r3, r11, lr}
0x60, 0x47, // bx ip 0x60, 0x47, // bx ip
}; };
static const uint8_t ThunkARM64[] = { static const uint8_t thunkARM64[] = {
0x11, 0x00, 0x00, 0x90, // adrp x17, #0 __imp_<FUNCNAME> 0x11, 0x00, 0x00, 0x90, // adrp x17, #0 __imp_<FUNCNAME>
0x31, 0x02, 0x00, 0x91, // add x17, x17, #0 :lo12:__imp_<FUNCNAME> 0x31, 0x02, 0x00, 0x91, // add x17, x17, #0 :lo12:__imp_<FUNCNAME>
0xfd, 0x7b, 0xb3, 0xa9, // stp x29, x30, [sp, #-208]! 0xfd, 0x7b, 0xb3, 0xa9, // stp x29, x30, [sp, #-208]!
0xfd, 0x03, 0x00, 0x91, // mov x29, sp 0xfd, 0x03, 0x00, 0x91, // mov x29, sp
0xe0, 0x07, 0x01, 0xa9, // stp x0, x1, [sp, #16] 0xe0, 0x07, 0x01, 0xa9, // stp x0, x1, [sp, #16]
0xe2, 0x0f, 0x02, 0xa9, // stp x2, x3, [sp, #32] 0xe2, 0x0f, 0x02, 0xa9, // stp x2, x3, [sp, #32]
0xe4, 0x17, 0x03, 0xa9, // stp x4, x5, [sp, #48] 0xe4, 0x17, 0x03, 0xa9, // stp x4, x5, [sp, #48]
0xe6, 0x1f, 0x04, 0xa9, // stp x6, x7, [sp, #64] 0xe6, 0x1f, 0x04, 0xa9, // stp x6, x7, [sp, #64]
Show All 16 Linesstatic const uint8_t thunkARM64[] = {
0xe0, 0x07, 0x41, 0xa9, // ldp x0, x1, [sp, #16] 0xe0, 0x07, 0x41, 0xa9, // ldp x0, x1, [sp, #16]
0xfd, 0x7b, 0xcd, 0xa8, // ldp x29, x30, [sp], #208 0xfd, 0x7b, 0xcd, 0xa8, // ldp x29, x30, [sp], #208
0x00, 0x02, 0x1f, 0xd6, // br x16 0x00, 0x02, 0x1f, 0xd6, // br x16
}; };
// A chunk for the delay import thunk. // A chunk for the delay import thunk.
class ThunkChunkX64 : public NonSectionChunk { class ThunkChunkX64 : public NonSectionChunk {
public: public:
ThunkChunkX64(Defined *I, Chunk *D, Defined *H) ThunkChunkX64(Defined *i, Chunk *d, Defined *h)
: Imp(I), Desc(D), Helper(H) {} : imp(i), desc(d), helper(h) {}
size_t getSize() const override { return sizeof(ThunkX64); } size_t getSize() const override { return sizeof(thunkX64); }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
memcpy(Buf, ThunkX64, sizeof(ThunkX64)); memcpy(buf, thunkX64, sizeof(thunkX64));
write32le(Buf + 36, Imp->getRVA() - RVA - 40); write32le(buf + 36, imp->getRVA() - rva - 40);
write32le(Buf + 43, Desc->getRVA() - RVA - 47); write32le(buf + 43, desc->getRVA() - rva - 47);
write32le(Buf + 48, Helper->getRVA() - RVA - 52); write32le(buf + 48, helper->getRVA() - rva - 52);
} }
Defined *Imp = nullptr; Defined *imp = nullptr;
Chunk *Desc = nullptr; Chunk *desc = nullptr;
Defined *Helper = nullptr; Defined *helper = nullptr;
}; };
class ThunkChunkX86 : public NonSectionChunk { class ThunkChunkX86 : public NonSectionChunk {
public: public:
ThunkChunkX86(Defined *I, Chunk *D, Defined *H) ThunkChunkX86(Defined *i, Chunk *d, Defined *h)
: Imp(I), Desc(D), Helper(H) {} : imp(i), desc(d), helper(h) {}
size_t getSize() const override { return sizeof(ThunkX86); } size_t getSize() const override { return sizeof(thunkX86); }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
memcpy(Buf, ThunkX86, sizeof(ThunkX86)); memcpy(buf, thunkX86, sizeof(thunkX86));
write32le(Buf + 3, Imp->getRVA() + Config->ImageBase); write32le(buf + 3, imp->getRVA() + config->imageBase);
write32le(Buf + 8, Desc->getRVA() + Config->ImageBase); write32le(buf + 8, desc->getRVA() + config->imageBase);
write32le(Buf + 13, Helper->getRVA() - RVA - 17); write32le(buf + 13, helper->getRVA() - rva - 17);
} }
void getBaserels(std::vector<Baserel> *Res) override { void getBaserels(std::vector<Baserel> *res) override {
Res->emplace_back(RVA + 3); res->emplace_back(rva + 3);
Res->emplace_back(RVA + 8); res->emplace_back(rva + 8);
} }
Defined *Imp = nullptr; Defined *imp = nullptr;
Chunk *Desc = nullptr; Chunk *desc = nullptr;
Defined *Helper = nullptr; Defined *helper = nullptr;
}; };
class ThunkChunkARM : public NonSectionChunk { class ThunkChunkARM : public NonSectionChunk {
public: public:
ThunkChunkARM(Defined *I, Chunk *D, Defined *H) ThunkChunkARM(Defined *i, Chunk *d, Defined *h)
: Imp(I), Desc(D), Helper(H) {} : imp(i), desc(d), helper(h) {}
size_t getSize() const override { return sizeof(ThunkARM); } size_t getSize() const override { return sizeof(thunkARM); }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
memcpy(Buf, ThunkARM, sizeof(ThunkARM)); memcpy(buf, thunkARM, sizeof(thunkARM));
applyMOV32T(Buf + 0, Imp->getRVA() + Config->ImageBase); applyMOV32T(buf + 0, imp->getRVA() + config->imageBase);
applyMOV32T(Buf + 22, Desc->getRVA() + Config->ImageBase); applyMOV32T(buf + 22, desc->getRVA() + config->imageBase);
applyBranch24T(Buf + 30, Helper->getRVA() - RVA - 34); applyBranch24T(buf + 30, helper->getRVA() - rva - 34);
} }
void getBaserels(std::vector<Baserel> *Res) override { void getBaserels(std::vector<Baserel> *res) override {
Res->emplace_back(RVA + 0, IMAGE_REL_BASED_ARM_MOV32T); res->emplace_back(rva + 0, IMAGE_REL_BASED_ARM_MOV32T);
Res->emplace_back(RVA + 22, IMAGE_REL_BASED_ARM_MOV32T); res->emplace_back(rva + 22, IMAGE_REL_BASED_ARM_MOV32T);
} }
Defined *Imp = nullptr; Defined *imp = nullptr;
Chunk *Desc = nullptr; Chunk *desc = nullptr;
Defined *Helper = nullptr; Defined *helper = nullptr;
}; };
class ThunkChunkARM64 : public NonSectionChunk { class ThunkChunkARM64 : public NonSectionChunk {
public: public:
ThunkChunkARM64(Defined *I, Chunk *D, Defined *H) ThunkChunkARM64(Defined *i, Chunk *d, Defined *h)
: Imp(I), Desc(D), Helper(H) {} : imp(i), desc(d), helper(h) {}
size_t getSize() const override { return sizeof(ThunkARM64); } size_t getSize() const override { return sizeof(thunkARM64); }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
memcpy(Buf, ThunkARM64, sizeof(ThunkARM64)); memcpy(buf, thunkARM64, sizeof(thunkARM64));
applyArm64Addr(Buf + 0, Imp->getRVA(), RVA + 0, 12); applyArm64Addr(buf + 0, imp->getRVA(), rva + 0, 12);
applyArm64Imm(Buf + 4, Imp->getRVA() & 0xfff, 0); applyArm64Imm(buf + 4, imp->getRVA() & 0xfff, 0);
applyArm64Addr(Buf + 52, Desc->getRVA(), RVA + 52, 12); applyArm64Addr(buf + 52, desc->getRVA(), rva + 52, 12);
applyArm64Imm(Buf + 56, Desc->getRVA() & 0xfff, 0); applyArm64Imm(buf + 56, desc->getRVA() & 0xfff, 0);
applyArm64Branch26(Buf + 60, Helper->getRVA() - RVA - 60); applyArm64Branch26(buf + 60, helper->getRVA() - rva - 60);
} }
Defined *Imp = nullptr; Defined *imp = nullptr;
Chunk *Desc = nullptr; Chunk *desc = nullptr;
Defined *Helper = nullptr; Defined *helper = nullptr;
}; };
// A chunk for the import descriptor table. // A chunk for the import descriptor table.
class DelayAddressChunk : public NonSectionChunk { class DelayAddressChunk : public NonSectionChunk {
public: public:
explicit DelayAddressChunk(Chunk *C) : Thunk(C) { explicit DelayAddressChunk(Chunk *c) : thunk(c) {
setAlignment(Config->Wordsize); setAlignment(config->wordsize);
} }
size_t getSize() const override { return Config->Wordsize; } size_t getSize() const override { return config->wordsize; }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
if (Config->is64()) { if (config->is64()) {
write64le(Buf, Thunk->getRVA() + Config->ImageBase); write64le(buf, thunk->getRVA() + config->imageBase);
} else { } else {
uint32_t Bit = 0; uint32_t bit = 0;
// Pointer to thumb code must have the LSB set, so adjust it. // Pointer to thumb code must have the LSB set, so adjust it.
if (Config->Machine == ARMNT) if (config->machine == ARMNT)
Bit = 1; bit = 1;
write32le(Buf, (Thunk->getRVA() + Config->ImageBase) | Bit); write32le(buf, (thunk->getRVA() + config->imageBase) | bit);
} }
} }
void getBaserels(std::vector<Baserel> *Res) override { void getBaserels(std::vector<Baserel> *res) override {
Res->emplace_back(RVA); res->emplace_back(rva);
} }
Chunk *Thunk; Chunk *thunk;
}; };
// Export table // Export table
// Read Microsoft PE/COFF spec 5.3 for details. // Read Microsoft PE/COFF spec 5.3 for details.
// A chunk for the export descriptor table. // A chunk for the export descriptor table.
class ExportDirectoryChunk : public NonSectionChunk { class ExportDirectoryChunk : public NonSectionChunk {
public: public:
ExportDirectoryChunk(int I, int J, Chunk *D, Chunk *A, Chunk *N, Chunk *O) ExportDirectoryChunk(int i, int j, Chunk *d, Chunk *a, Chunk *n, Chunk *o)
: MaxOrdinal(I), NameTabSize(J), DLLName(D), AddressTab(A), NameTab(N), : maxOrdinal(i), nameTabSize(j), dllName(d), addressTab(a), nameTab(n),
OrdinalTab(O) {} ordinalTab(o) {}
size_t getSize() const override { size_t getSize() const override {
return sizeof(export_directory_table_entry); return sizeof(export_directory_table_entry);
} }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
memset(Buf, 0, getSize()); memset(buf, 0, getSize());
auto *E = (export_directory_table_entry *)(Buf); auto *e = (export_directory_table_entry *)(buf);
E->NameRVA = DLLName->getRVA(); e->NameRVA = dllName->getRVA();
E->OrdinalBase = 0; e->OrdinalBase = 0;
E->AddressTableEntries = MaxOrdinal + 1; e->AddressTableEntries = maxOrdinal + 1;
E->NumberOfNamePointers = NameTabSize; e->NumberOfNamePointers = nameTabSize;
E->ExportAddressTableRVA = AddressTab->getRVA(); e->ExportAddressTableRVA = addressTab->getRVA();
E->NamePointerRVA = NameTab->getRVA(); e->NamePointerRVA = nameTab->getRVA();
E->OrdinalTableRVA = OrdinalTab->getRVA(); e->OrdinalTableRVA = ordinalTab->getRVA();
} }
uint16_t MaxOrdinal; uint16_t maxOrdinal;
uint16_t NameTabSize; uint16_t nameTabSize;
Chunk *DLLName; Chunk *dllName;
Chunk *AddressTab; Chunk *addressTab;
Chunk *NameTab; Chunk *nameTab;
Chunk *OrdinalTab; Chunk *ordinalTab;
}; };
class AddressTableChunk : public NonSectionChunk { class AddressTableChunk : public NonSectionChunk {
public: public:
explicit AddressTableChunk(size_t MaxOrdinal) : Size(MaxOrdinal + 1) {} explicit AddressTableChunk(size_t maxOrdinal) : size(maxOrdinal + 1) {}
size_t getSize() const override { return Size * 4; } size_t getSize() const override { return size * 4; }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
memset(Buf, 0, getSize()); memset(buf, 0, getSize());
for (const Export &E : Config->Exports) { for (const Export &e : config->exports) {
uint8_t *P = Buf + E.Ordinal * 4; uint8_t *p = buf + e.ordinal * 4;
uint32_t Bit = 0; uint32_t bit = 0;
// Pointer to thumb code must have the LSB set, so adjust it. // Pointer to thumb code must have the LSB set, so adjust it.
if (Config->Machine == ARMNT && !E.Data) if (config->machine == ARMNT && !e.data)
Bit = 1; bit = 1;
if (E.ForwardChunk) { if (e.forwardChunk) {
write32le(P, E.ForwardChunk->getRVA() | Bit); write32le(p, e.forwardChunk->getRVA() | bit);
} else { } else {
write32le(P, cast<Defined>(E.Sym)->getRVA() | Bit); write32le(p, cast<Defined>(e.sym)->getRVA() | bit);
} }
} }
} }
private: private:
size_t Size; size_t size;
}; };
class NamePointersChunk : public NonSectionChunk { class NamePointersChunk : public NonSectionChunk {
public: public:
explicit NamePointersChunk(std::vector<Chunk *> &V) : Chunks(V) {} explicit NamePointersChunk(std::vector<Chunk *> &v) : chunks(v) {}
size_t getSize() const override { return Chunks.size() * 4; } size_t getSize() const override { return chunks.size() * 4; }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
for (Chunk *C : Chunks) { for (Chunk *c : chunks) {
write32le(Buf, C->getRVA()); write32le(buf, c->getRVA());
Buf += 4; buf += 4;
} }
} }
private: private:
std::vector<Chunk *> Chunks; std::vector<Chunk *> chunks;
}; };
class ExportOrdinalChunk : public NonSectionChunk { class ExportOrdinalChunk : public NonSectionChunk {
public: public:
explicit ExportOrdinalChunk(size_t I) : Size(I) {} explicit ExportOrdinalChunk(size_t i) : size(i) {}
size_t getSize() const override { return Size * 2; } size_t getSize() const override { return size * 2; }
void writeTo(uint8_t *Buf) const override { void writeTo(uint8_t *buf) const override {
for (Export &E : Config->Exports) { for (Export &e : config->exports) {
if (E.Noname) if (e.noname)
continue; continue;
write16le(Buf, E.Ordinal); write16le(buf, e.ordinal);
Buf += 2; buf += 2;
} }
} }
private: private:
size_t Size; size_t size;
}; };
} // anonymous namespace } // anonymous namespace
void IdataContents::create() { void IdataContents::create() {
std::vector<std::vector<DefinedImportData *>> V = binImports(Imports); std::vector<std::vector<DefinedImportData *>> v = binImports(imports);
// Create .idata contents for each DLL. // Create .idata contents for each DLL.
for (std::vector<DefinedImportData *> &Syms : V) { for (std::vector<DefinedImportData *> &syms : v) {
// Create lookup and address tables. If they have external names, // Create lookup and address tables. If they have external names,
// we need to create HintName chunks to store the names. // we need to create HintName chunks to store the names.
// If they don't (if they are import-by-ordinals), we store only // If they don't (if they are import-by-ordinals), we store only
// ordinal values to the table. // ordinal values to the table.
size_t Base = Lookups.size(); size_t base = lookups.size();
for (DefinedImportData *S : Syms) { for (DefinedImportData *s : syms) {
uint16_t Ord = S->getOrdinal(); uint16_t ord = s->getOrdinal();
if (S->getExternalName().empty()) { if (s->getExternalName().empty()) {
Lookups.push_back(make<OrdinalOnlyChunk>(Ord)); lookups.push_back(make<OrdinalOnlyChunk>(ord));
Addresses.push_back(make<OrdinalOnlyChunk>(Ord)); addresses.push_back(make<OrdinalOnlyChunk>(ord));
continue; continue;
} }
auto *C = make<HintNameChunk>(S->getExternalName(), Ord); auto *c = make<HintNameChunk>(s->getExternalName(), ord);
Lookups.push_back(make<LookupChunk>(C)); lookups.push_back(make<LookupChunk>(c));
Addresses.push_back(make<LookupChunk>(C)); addresses.push_back(make<LookupChunk>(c));
Hints.push_back(C); hints.push_back(c);
} }
// Terminate with null values. // Terminate with null values.
Lookups.push_back(make<NullChunk>(Config->Wordsize)); lookups.push_back(make<NullChunk>(config->wordsize));
Addresses.push_back(make<NullChunk>(Config->Wordsize)); addresses.push_back(make<NullChunk>(config->wordsize));
for (int I = 0, E = Syms.size(); I < E; ++I) for (int i = 0, e = syms.size(); i < e; ++i)
Syms[I]->setLocation(Addresses[Base + I]); syms[i]->setLocation(addresses[base + i]);
// Create the import table header. // Create the import table header.
DLLNames.push_back(make<StringChunk>(Syms[0]->getDLLName())); dllNames.push_back(make<StringChunk>(syms[0]->getDLLName()));
auto *Dir = make<ImportDirectoryChunk>(DLLNames.back()); auto *dir = make<ImportDirectoryChunk>(dllNames.back());
Dir->LookupTab = Lookups[Base]; dir->lookupTab = lookups[base];
Dir->AddressTab = Addresses[Base]; dir->addressTab = addresses[base];
Dirs.push_back(Dir); dirs.push_back(dir);
} }
// Add null terminator. // Add null terminator.
Dirs.push_back(make<NullChunk>(sizeof(ImportDirectoryTableEntry))); dirs.push_back(make<NullChunk>(sizeof(ImportDirectoryTableEntry)));
} }
std::vector<Chunk *> DelayLoadContents::getChunks() { std::vector<Chunk *> DelayLoadContents::getChunks() {
std::vector<Chunk *> V; std::vector<Chunk *> v;
V.insert(V.end(), Dirs.begin(), Dirs.end()); v.insert(v.end(), dirs.begin(), dirs.end());
V.insert(V.end(), Names.begin(), Names.end()); v.insert(v.end(), names.begin(), names.end());
V.insert(V.end(), HintNames.begin(), HintNames.end()); v.insert(v.end(), hintNames.begin(), hintNames.end());
V.insert(V.end(), DLLNames.begin(), DLLNames.end()); v.insert(v.end(), dllNames.begin(), dllNames.end());
return V; return v;
} }
std::vector<Chunk *> DelayLoadContents::getDataChunks() { std::vector<Chunk *> DelayLoadContents::getDataChunks() {
std::vector<Chunk *> V; std::vector<Chunk *> v;
V.insert(V.end(), ModuleHandles.begin(), ModuleHandles.end()); v.insert(v.end(), moduleHandles.begin(), moduleHandles.end());
V.insert(V.end(), Addresses.begin(), Addresses.end()); v.insert(v.end(), addresses.begin(), addresses.end());
return V; return v;
} }
uint64_t DelayLoadContents::getDirSize() { uint64_t DelayLoadContents::getDirSize() {
return Dirs.size() * sizeof(delay_import_directory_table_entry); return dirs.size() * sizeof(delay_import_directory_table_entry);
} }
void DelayLoadContents::create(Defined *H) { void DelayLoadContents::create(Defined *h) {
Helper = H; helper = h;
std::vector<std::vector<DefinedImportData *>> V = binImports(Imports); std::vector<std::vector<DefinedImportData *>> v = binImports(imports);
// Create .didat contents for each DLL. // Create .didat contents for each DLL.
for (std::vector<DefinedImportData *> &Syms : V) { for (std::vector<DefinedImportData *> &syms : v) {
// Create the delay import table header. // Create the delay import table header.
DLLNames.push_back(make<StringChunk>(Syms[0]->getDLLName())); dllNames.push_back(make<StringChunk>(syms[0]->getDLLName()));
auto *Dir = make<DelayDirectoryChunk>(DLLNames.back()); auto *dir = make<DelayDirectoryChunk>(dllNames.back());
size_t Base = Addresses.size(); size_t base = addresses.size();
for (DefinedImportData *S : Syms) { for (DefinedImportData *s : syms) {
Chunk *T = newThunkChunk(S, Dir); Chunk *t = newThunkChunk(s, dir);
auto *A = make<DelayAddressChunk>(T); auto *a = make<DelayAddressChunk>(t);
Addresses.push_back(A); addresses.push_back(a);
Thunks.push_back(T); thunks.push_back(t);
StringRef ExtName = S->getExternalName(); StringRef extName = s->getExternalName();
if (ExtName.empty()) { if (extName.empty()) {
Names.push_back(make<OrdinalOnlyChunk>(S->getOrdinal())); names.push_back(make<OrdinalOnlyChunk>(s->getOrdinal()));
} else { } else {
auto *C = make<HintNameChunk>(ExtName, 0); auto *c = make<HintNameChunk>(extName, 0);
Names.push_back(make<LookupChunk>(C)); names.push_back(make<LookupChunk>(c));
HintNames.push_back(C); hintNames.push_back(c);
} }
} }
// Terminate with null values. // Terminate with null values.
Addresses.push_back(make<NullChunk>(8)); addresses.push_back(make<NullChunk>(8));
Names.push_back(make<NullChunk>(8)); names.push_back(make<NullChunk>(8));
for (int I = 0, E = Syms.size(); I < E; ++I) for (int i = 0, e = syms.size(); i < e; ++i)
Syms[I]->setLocation(Addresses[Base + I]); syms[i]->setLocation(addresses[base + i]);
auto *MH = make<NullChunk>(8); auto *mh = make<NullChunk>(8);
MH->setAlignment(8); mh->setAlignment(8);
ModuleHandles.push_back(MH); moduleHandles.push_back(mh);
// Fill the delay import table header fields. // Fill the delay import table header fields.
Dir->ModuleHandle = MH; dir->moduleHandle = mh;
Dir->AddressTab = Addresses[Base]; dir->addressTab = addresses[base];
Dir->NameTab = Names[Base]; dir->nameTab = names[base];
Dirs.push_back(Dir); dirs.push_back(dir);
} }
// Add null terminator. // Add null terminator.
Dirs.push_back(make<NullChunk>(sizeof(delay_import_directory_table_entry))); dirs.push_back(make<NullChunk>(sizeof(delay_import_directory_table_entry)));
} }
Chunk *DelayLoadContents::newThunkChunk(DefinedImportData *S, Chunk *Dir) { Chunk *DelayLoadContents::newThunkChunk(DefinedImportData *s, Chunk *dir) {
switch (Config->Machine) { switch (config->machine) {
case AMD64: case AMD64:
return make<ThunkChunkX64>(S, Dir, Helper); return make<ThunkChunkX64>(s, dir, helper);
case I386: case I386:
return make<ThunkChunkX86>(S, Dir, Helper); return make<ThunkChunkX86>(s, dir, helper);
case ARMNT: case ARMNT:
return make<ThunkChunkARM>(S, Dir, Helper); return make<ThunkChunkARM>(s, dir, helper);
case ARM64: case ARM64:
return make<ThunkChunkARM64>(S, Dir, Helper); return make<ThunkChunkARM64>(s, dir, helper);
default: default:
llvm_unreachable("unsupported machine type"); llvm_unreachable("unsupported machine type");
} }
} }
EdataContents::EdataContents() { EdataContents::EdataContents() {
uint16_t MaxOrdinal = 0; uint16_t maxOrdinal = 0;
for (Export &E : Config->Exports) for (Export &e : config->exports)
MaxOrdinal = std::max(MaxOrdinal, E.Ordinal); maxOrdinal = std::max(maxOrdinal, e.ordinal);
auto *DLLName = make<StringChunk>(sys::path::filename(Config->OutputFile)); auto *dllName = make<StringChunk>(sys::path::filename(config->outputFile));
auto *AddressTab = make<AddressTableChunk>(MaxOrdinal); auto *addressTab = make<AddressTableChunk>(maxOrdinal);
std::vector<Chunk *> Names; std::vector<Chunk *> names;
for (Export &E : Config->Exports) for (Export &e : config->exports)
if (!E.Noname) if (!e.noname)
Names.push_back(make<StringChunk>(E.ExportName)); names.push_back(make<StringChunk>(e.exportName));
std::vector<Chunk *> Forwards; std::vector<Chunk *> forwards;
for (Export &E : Config->Exports) { for (Export &e : config->exports) {
if (E.ForwardTo.empty()) if (e.forwardTo.empty())
continue; continue;
E.ForwardChunk = make<StringChunk>(E.ForwardTo); e.forwardChunk = make<StringChunk>(e.forwardTo);
Forwards.push_back(E.ForwardChunk); forwards.push_back(e.forwardChunk);
} }
auto *NameTab = make<NamePointersChunk>(Names); auto *nameTab = make<NamePointersChunk>(names);
auto *OrdinalTab = make<ExportOrdinalChunk>(Names.size()); auto *ordinalTab = make<ExportOrdinalChunk>(names.size());
auto *Dir = make<ExportDirectoryChunk>(MaxOrdinal, Names.size(), DLLName, auto *dir = make<ExportDirectoryChunk>(maxOrdinal, names.size(), dllName,
AddressTab, NameTab, OrdinalTab); addressTab, nameTab, ordinalTab);
Chunks.push_back(Dir); chunks.push_back(dir);
Chunks.push_back(DLLName); chunks.push_back(dllName);
Chunks.push_back(AddressTab); chunks.push_back(addressTab);
Chunks.push_back(NameTab); chunks.push_back(nameTab);
Chunks.push_back(OrdinalTab); chunks.push_back(ordinalTab);
Chunks.insert(Chunks.end(), Names.begin(), Names.end()); chunks.insert(chunks.end(), names.begin(), names.end());
Chunks.insert(Chunks.end(), Forwards.begin(), Forwards.end()); chunks.insert(chunks.end(), forwards.begin(), forwards.end());
} }
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld

lld/trunk/COFF/DebugTypes.h

Show All 25 Lines
namespace coff { namespace coff {
class ObjFile; class ObjFile;
class TpiSource { class TpiSource {
public: public:
enum TpiKind { Regular, PCH, UsingPCH, PDB, UsingPDB }; enum TpiKind { Regular, PCH, UsingPCH, PDB, UsingPDB };
TpiSource(TpiKind K, const ObjFile *F); TpiSource(TpiKind k, const ObjFile *f);
virtual ~TpiSource() {} virtual ~TpiSource() {}
const TpiKind Kind; const TpiKind kind;
const ObjFile *File; const ObjFile *file;
}; };
TpiSource *makeTpiSource(const ObjFile *F); TpiSource *makeTpiSource(const ObjFile *f);
TpiSource *makeUseTypeServerSource(const ObjFile *F, TpiSource *makeUseTypeServerSource(const ObjFile *f,
const llvm::codeview::TypeServer2Record *TS); const llvm::codeview::TypeServer2Record *ts);
TpiSource *makePrecompSource(const ObjFile *F); TpiSource *makePrecompSource(const ObjFile *f);
TpiSource *makeUsePrecompSource(const ObjFile *F, TpiSource *makeUsePrecompSource(const ObjFile *f,
const llvm::codeview::PrecompRecord *Precomp); const llvm::codeview::PrecompRecord *precomp);
void loadTypeServerSource(llvm::MemoryBufferRef M); void loadTypeServerSource(llvm::MemoryBufferRef m);
// Temporary interface to get the dependency // Temporary interface to get the dependency
template <typename T> const T &retrieveDependencyInfo(const TpiSource *Source); template <typename T> const T &retrieveDependencyInfo(const TpiSource *source);
// Temporary interface until we move PDBLinker::maybeMergeTypeServerPDB here // Temporary interface until we move PDBLinker::maybeMergeTypeServerPDB here
llvm::Expected<llvm::pdb::NativeSession *> llvm::Expected<llvm::pdb::NativeSession *>
findTypeServerSource(const ObjFile *F); findTypeServerSource(const ObjFile *f);
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
#endif #endif
No newline at end of file No newline at end of file

lld/trunk/COFF/DebugTypes.cpp

Show All 26 Lines
// OBJ files compiled with MSVC /Zi. A single PDB can be shared by several OBJ // OBJ files compiled with MSVC /Zi. A single PDB can be shared by several OBJ
// files, therefore there must be only once instance per OBJ lot. The file path // files, therefore there must be only once instance per OBJ lot. The file path
// is discovered from the dependent OBJ's debug type stream. The // is discovered from the dependent OBJ's debug type stream. The
// TypeServerSource object is then queued and loaded by the COFF Driver. The // TypeServerSource object is then queued and loaded by the COFF Driver. The
// debug type stream for such PDB files will be merged first in the final PDB, // debug type stream for such PDB files will be merged first in the final PDB,
// before any dependent OBJ. // before any dependent OBJ.
class TypeServerSource : public TpiSource { class TypeServerSource : public TpiSource {
public: public:
explicit TypeServerSource(MemoryBufferRef M, llvm::pdb::NativeSession *S) explicit TypeServerSource(MemoryBufferRef m, llvm::pdb::NativeSession *s)
: TpiSource(PDB, nullptr), Session(S), MB(M) {} : TpiSource(PDB, nullptr), session(s), mb(m) {}
// Queue a PDB type server for loading in the COFF Driver // Queue a PDB type server for loading in the COFF Driver
static void enqueue(const ObjFile *DependentFile, static void enqueue(const ObjFile *dependentFile,
const TypeServer2Record &TS); const TypeServer2Record &ts);
// Create an instance // Create an instance
static Expected<TypeServerSource *> getInstance(MemoryBufferRef M); static Expected<TypeServerSource *> getInstance(MemoryBufferRef m);
// Fetch the PDB instance loaded for a corresponding dependent OBJ. // Fetch the PDB instance loaded for a corresponding dependent OBJ.
static Expected<TypeServerSource *> static Expected<TypeServerSource *>
findFromFile(const ObjFile *DependentFile); findFromFile(const ObjFile *dependentFile);
static std::map<std::string, std::pair<std::string, TypeServerSource *>> static std::map<std::string, std::pair<std::string, TypeServerSource *>>
Instances; instances;
// The interface to the PDB (if it was opened successfully) // The interface to the PDB (if it was opened successfully)
std::unique_ptr<llvm::pdb::NativeSession> Session; std::unique_ptr<llvm::pdb::NativeSession> session;
private: private:
MemoryBufferRef MB; MemoryBufferRef mb;
}; };
// This class represents the debug type stream of an OBJ file that depends on a // This class represents the debug type stream of an OBJ file that depends on a
// PDB type server (see TypeServerSource). // PDB type server (see TypeServerSource).
class UseTypeServerSource : public TpiSource { class UseTypeServerSource : public TpiSource {
public: public:
UseTypeServerSource(const ObjFile *F, const TypeServer2Record *TS) UseTypeServerSource(const ObjFile *f, const TypeServer2Record *ts)
: TpiSource(UsingPDB, F), TypeServerDependency(*TS) {} : TpiSource(UsingPDB, f), typeServerDependency(*ts) {}
// Information about the PDB type server dependency, that needs to be loaded // Information about the PDB type server dependency, that needs to be loaded
// in before merging this OBJ. // in before merging this OBJ.
TypeServer2Record TypeServerDependency; TypeServer2Record typeServerDependency;
}; };
// This class represents the debug type stream of a Microsoft precompiled // This class represents the debug type stream of a Microsoft precompiled
// headers OBJ (PCH OBJ). This OBJ kind needs to be merged first in the output // headers OBJ (PCH OBJ). This OBJ kind needs to be merged first in the output
// PDB, before any other OBJs that depend on this. Note that only MSVC generate // PDB, before any other OBJs that depend on this. Note that only MSVC generate
// such files, clang does not. // such files, clang does not.
class PrecompSource : public TpiSource { class PrecompSource : public TpiSource {
public: public:
PrecompSource(const ObjFile *F) : TpiSource(PCH, F) {} PrecompSource(const ObjFile *f) : TpiSource(PCH, f) {}
}; };
// This class represents the debug type stream of an OBJ file that depends on a // This class represents the debug type stream of an OBJ file that depends on a
// Microsoft precompiled headers OBJ (see PrecompSource). // Microsoft precompiled headers OBJ (see PrecompSource).
class UsePrecompSource : public TpiSource { class UsePrecompSource : public TpiSource {
public: public:
UsePrecompSource(const ObjFile *F, const PrecompRecord *Precomp) UsePrecompSource(const ObjFile *f, const PrecompRecord *precomp)
: TpiSource(UsingPCH, F), PrecompDependency(*Precomp) {} : TpiSource(UsingPCH, f), precompDependency(*precomp) {}
// Information about the Precomp OBJ dependency, that needs to be loaded in // Information about the Precomp OBJ dependency, that needs to be loaded in
// before merging this OBJ. // before merging this OBJ.
PrecompRecord PrecompDependency; PrecompRecord precompDependency;
}; };
} // namespace } // namespace
static std::vector<std::unique_ptr<TpiSource>> GC; static std::vector<std::unique_ptr<TpiSource>> GC;
TpiSource::TpiSource(TpiKind K, const ObjFile *F) : Kind(K), File(F) { TpiSource::TpiSource(TpiKind k, const ObjFile *f) : kind(k), file(f) {
GC.push_back(std::unique_ptr<TpiSource>(this)); GC.push_back(std::unique_ptr<TpiSource>(this));
} }
TpiSource *lld::coff::makeTpiSource(const ObjFile *F) { TpiSource *lld::coff::makeTpiSource(const ObjFile *f) {
return new TpiSource(TpiSource::Regular, F); return new TpiSource(TpiSource::Regular, f);
} }
TpiSource *lld::coff::makeUseTypeServerSource(const ObjFile *F, TpiSource *lld::coff::makeUseTypeServerSource(const ObjFile *f,
const TypeServer2Record *TS) { const TypeServer2Record *ts) {
TypeServerSource::enqueue(F, *TS); TypeServerSource::enqueue(f, *ts);
return new UseTypeServerSource(F, TS); return new UseTypeServerSource(f, ts);
} }
TpiSource *lld::coff::makePrecompSource(const ObjFile *F) { TpiSource *lld::coff::makePrecompSource(const ObjFile *f) {
return new PrecompSource(F); return new PrecompSource(f);
} }
TpiSource *lld::coff::makeUsePrecompSource(const ObjFile *F, TpiSource *lld::coff::makeUsePrecompSource(const ObjFile *f,
const PrecompRecord *Precomp) { const PrecompRecord *precomp) {
return new UsePrecompSource(F, Precomp); return new UsePrecompSource(f, precomp);
} }
namespace lld { namespace lld {
namespace coff { namespace coff {
template <> template <>
const PrecompRecord &retrieveDependencyInfo(const TpiSource *Source) { const PrecompRecord &retrieveDependencyInfo(const TpiSource *source) {
assert(Source->Kind == TpiSource::UsingPCH); assert(source->kind == TpiSource::UsingPCH);
return ((const UsePrecompSource *)Source)->PrecompDependency; return ((const UsePrecompSource *)source)->precompDependency;
} }
template <> template <>
const TypeServer2Record &retrieveDependencyInfo(const TpiSource *Source) { const TypeServer2Record &retrieveDependencyInfo(const TpiSource *source) {
assert(Source->Kind == TpiSource::UsingPDB); assert(source->kind == TpiSource::UsingPDB);
return ((const UseTypeServerSource *)Source)->TypeServerDependency; return ((const UseTypeServerSource *)source)->typeServerDependency;
} }
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
std::map<std::string, std::pair<std::string, TypeServerSource *>> std::map<std::string, std::pair<std::string, TypeServerSource *>>
TypeServerSource::Instances; TypeServerSource::instances;
// Make a PDB path assuming the PDB is in the same folder as the OBJ // Make a PDB path assuming the PDB is in the same folder as the OBJ
static std::string getPdbBaseName(const ObjFile *File, StringRef TSPath) { static std::string getPdbBaseName(const ObjFile *file, StringRef tSPath) {
StringRef LocalPath = StringRef localPath =
!File->ParentName.empty() ? File->ParentName : File->getName(); !file->parentName.empty() ? file->parentName : file->getName();
SmallString<128> Path = sys::path::parent_path(LocalPath); SmallString<128> path = sys::path::parent_path(localPath);
// Currently, type server PDBs are only created by MSVC cl, which only runs // Currently, type server PDBs are only created by MSVC cl, which only runs
// on Windows, so we can assume type server paths are Windows style. // on Windows, so we can assume type server paths are Windows style.
sys::path::append(Path, sys::path::filename(TSPath, sys::path::Style::windows)); sys::path::append(path, sys::path::filename(tSPath, sys::path::Style::windows));
return Path.str(); return path.str();
} }
// The casing of the PDB path stamped in the OBJ can differ from the actual path // The casing of the PDB path stamped in the OBJ can differ from the actual path
// on disk. With this, we ensure to always use lowercase as a key for the // on disk. With this, we ensure to always use lowercase as a key for the
// PDBInputFile::Instances map, at least on Windows. // PDBInputFile::Instances map, at least on Windows.
static std::string normalizePdbPath(StringRef path) { static std::string normalizePdbPath(StringRef path) {
#if defined(_WIN32) #if defined(_WIN32)
return path.lower(); return path.lower();
#else // LINUX #else // LINUX
return path; return path;
#endif #endif
} }
// If existing, return the actual PDB path on disk. // If existing, return the actual PDB path on disk.
static Optional<std::string> findPdbPath(StringRef PDBPath, static Optional<std::string> findPdbPath(StringRef pdbPath,
const ObjFile *DependentFile) { const ObjFile *dependentFile) {
// Ensure the file exists before anything else. In some cases, if the path // Ensure the file exists before anything else. In some cases, if the path
// points to a removable device, Driver::enqueuePath() would fail with an // points to a removable device, Driver::enqueuePath() would fail with an
// error (EAGAIN, "resource unavailable try again") which we want to skip // error (EAGAIN, "resource unavailable try again") which we want to skip
// silently. // silently.
if (llvm::sys::fs::exists(PDBPath)) if (llvm::sys::fs::exists(pdbPath))
return normalizePdbPath(PDBPath); return normalizePdbPath(pdbPath);
std::string Ret = getPdbBaseName(DependentFile, PDBPath); std::string ret = getPdbBaseName(dependentFile, pdbPath);
if (llvm::sys::fs::exists(Ret)) if (llvm::sys::fs::exists(ret))
return normalizePdbPath(Ret); return normalizePdbPath(ret);
return None; return None;
} }
// Fetch the PDB instance that was already loaded by the COFF Driver. // Fetch the PDB instance that was already loaded by the COFF Driver.
Expected<TypeServerSource *> Expected<TypeServerSource *>
TypeServerSource::findFromFile(const ObjFile *DependentFile) { TypeServerSource::findFromFile(const ObjFile *dependentFile) {
const TypeServer2Record &TS = const TypeServer2Record &ts =
retrieveDependencyInfo<TypeServer2Record>(DependentFile->DebugTypesObj); retrieveDependencyInfo<TypeServer2Record>(dependentFile->debugTypesObj);
Optional<std::string> P = findPdbPath(TS.Name, DependentFile); Optional<std::string> p = findPdbPath(ts.Name, dependentFile);
if (!P) if (!p)
return createFileError(TS.Name, errorCodeToError(std::error_code( return createFileError(ts.Name, errorCodeToError(std::error_code(
ENOENT, std::generic_category()))); ENOENT, std::generic_category())));
auto It = TypeServerSource::Instances.find(*P); auto it = TypeServerSource::instances.find(*p);
// The PDB file exists on disk, at this point we expect it to have been // The PDB file exists on disk, at this point we expect it to have been
// inserted in the map by TypeServerSource::loadPDB() // inserted in the map by TypeServerSource::loadPDB()
assert(It != TypeServerSource::Instances.end()); assert(it != TypeServerSource::instances.end());
std::pair<std::string, TypeServerSource *> &PDB = It->second; std::pair<std::string, TypeServerSource *> &pdb = it->second;
if (!PDB.second) if (!pdb.second)
return createFileError( return createFileError(
*P, createStringError(inconvertibleErrorCode(), PDB.first.c_str())); *p, createStringError(inconvertibleErrorCode(), pdb.first.c_str()));
pdb::PDBFile &PDBFile = (PDB.second)->Session->getPDBFile(); pdb::PDBFile &pdbFile = (pdb.second)->session->getPDBFile();
pdb::InfoStream &Info = cantFail(PDBFile.getPDBInfoStream()); pdb::InfoStream &info = cantFail(pdbFile.getPDBInfoStream());
// Just because a file with a matching name was found doesn't mean it can be // Just because a file with a matching name was found doesn't mean it can be
// used. The GUID must match between the PDB header and the OBJ // used. The GUID must match between the PDB header and the OBJ
// TypeServer2 record. The 'Age' is used by MSVC incremental compilation. // TypeServer2 record. The 'Age' is used by MSVC incremental compilation.
if (Info.getGuid() != TS.getGuid()) if (info.getGuid() != ts.getGuid())
return createFileError( return createFileError(
TS.Name, ts.Name,
make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date)); make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date));
return PDB.second; return pdb.second;
} }
// FIXME: Temporary interface until PDBLinker::maybeMergeTypeServerPDB() is // FIXME: Temporary interface until PDBLinker::maybeMergeTypeServerPDB() is
// moved here. // moved here.
Expected<llvm::pdb::NativeSession *> Expected<llvm::pdb::NativeSession *>
lld::coff::findTypeServerSource(const ObjFile *F) { lld::coff::findTypeServerSource(const ObjFile *f) {
Expected<TypeServerSource *> TS = TypeServerSource::findFromFile(F); Expected<TypeServerSource *> ts = TypeServerSource::findFromFile(f);
if (!TS) if (!ts)
return TS.takeError(); return ts.takeError();
return TS.get()->Session.get(); return ts.get()->session.get();
} }
// Queue a PDB type server for loading in the COFF Driver // Queue a PDB type server for loading in the COFF Driver
void TypeServerSource::enqueue(const ObjFile *DependentFile, void TypeServerSource::enqueue(const ObjFile *dependentFile,
const TypeServer2Record &TS) { const TypeServer2Record &ts) {
// Start by finding where the PDB is located (either the record path or next // Start by finding where the PDB is located (either the record path or next
// to the OBJ file) // to the OBJ file)
Optional<std::string> P = findPdbPath(TS.Name, DependentFile); Optional<std::string> p = findPdbPath(ts.Name, dependentFile);
if (!P) if (!p)
return; return;
auto It = TypeServerSource::Instances.emplace( auto it = TypeServerSource::instances.emplace(
*P, std::pair<std::string, TypeServerSource *>{}); *p, std::pair<std::string, TypeServerSource *>{});
if (!It.second) if (!it.second)
return; // another OBJ already scheduled this PDB for load return; // another OBJ already scheduled this PDB for load
Driver->enqueuePath(*P, false); driver->enqueuePath(*p, false);
} }
// Create an instance of TypeServerSource or an error string if the PDB couldn't // Create an instance of TypeServerSource or an error string if the PDB couldn't
// be loaded. The error message will be displayed later, when the referring OBJ // be loaded. The error message will be displayed later, when the referring OBJ
// will be merged in. NOTE - a PDB load failure is not a link error: some // will be merged in. NOTE - a PDB load failure is not a link error: some
// debug info will simply be missing from the final PDB - that is the default // debug info will simply be missing from the final PDB - that is the default
// accepted behavior. // accepted behavior.
void lld::coff::loadTypeServerSource(llvm::MemoryBufferRef M) { void lld::coff::loadTypeServerSource(llvm::MemoryBufferRef m) {
std::string Path = normalizePdbPath(M.getBufferIdentifier()); std::string path = normalizePdbPath(m.getBufferIdentifier());
Expected<TypeServerSource *> TS = TypeServerSource::getInstance(M); Expected<TypeServerSource *> ts = TypeServerSource::getInstance(m);
if (!TS) if (!ts)
TypeServerSource::Instances[Path] = {toString(TS.takeError()), nullptr}; TypeServerSource::instances[path] = {toString(ts.takeError()), nullptr};
else else
TypeServerSource::Instances[Path] = {{}, *TS}; TypeServerSource::instances[path] = {{}, *ts};
} }
Expected<TypeServerSource *> TypeServerSource::getInstance(MemoryBufferRef M) { Expected<TypeServerSource *> TypeServerSource::getInstance(MemoryBufferRef m) {
std::unique_ptr<llvm::pdb::IPDBSession> ISession; std::unique_ptr<llvm::pdb::IPDBSession> iSession;
Error Err = pdb::NativeSession::createFromPdb( Error err = pdb::NativeSession::createFromPdb(
MemoryBuffer::getMemBuffer(M, false), ISession); MemoryBuffer::getMemBuffer(m, false), iSession);
if (Err) if (err)
return std::move(Err); return std::move(err);
std::unique_ptr<llvm::pdb::NativeSession> Session( std::unique_ptr<llvm::pdb::NativeSession> session(
static_cast<pdb::NativeSession *>(ISession.release())); static_cast<pdb::NativeSession *>(iSession.release()));
pdb::PDBFile &PDBFile = Session->getPDBFile(); pdb::PDBFile &pdbFile = session->getPDBFile();
Expected<pdb::InfoStream &> Info = PDBFile.getPDBInfoStream(); Expected<pdb::InfoStream &> info = pdbFile.getPDBInfoStream();
// All PDB Files should have an Info stream. // All PDB Files should have an Info stream.
if (!Info) if (!info)
return Info.takeError(); return info.takeError();
return new TypeServerSource(M, Session.release()); return new TypeServerSource(m, session.release());
} }

lld/trunk/COFF/Driver.h

Show All 24 Lines
#include <memory> #include <memory>
#include <set> #include <set>
#include <vector> #include <vector>
namespace lld { namespace lld {
namespace coff { namespace coff {
class LinkerDriver; class LinkerDriver;
extern LinkerDriver *Driver; extern LinkerDriver *driver;
using llvm::COFF::MachineTypes; using llvm::COFF::MachineTypes;
using llvm::COFF::WindowsSubsystem; using llvm::COFF::WindowsSubsystem;
using llvm::Optional; using llvm::Optional;
class COFFOptTable : public llvm::opt::OptTable { class COFFOptTable : public llvm::opt::OptTable {
public: public:
COFFOptTable(); COFFOptTable();
}; };
class ArgParser { class ArgParser {
public: public:
// Concatenate LINK environment variable and given arguments and parse them. // Concatenate LINK environment variable and given arguments and parse them.
llvm::opt::InputArgList parseLINK(std::vector<const char *> Args); llvm::opt::InputArgList parseLINK(std::vector<const char *> args);
// Tokenizes a given string and then parses as command line options. // Tokenizes a given string and then parses as command line options.
llvm::opt::InputArgList parse(StringRef S) { return parse(tokenize(S)); } llvm::opt::InputArgList parse(StringRef s) { return parse(tokenize(s)); }
// Tokenizes a given string and then parses as command line options in // Tokenizes a given string and then parses as command line options in
// .drectve section. /EXPORT options are returned in second element // .drectve section. /EXPORT options are returned in second element
// to be processed in fastpath. // to be processed in fastpath.
std::pair<llvm::opt::InputArgList, std::vector<StringRef>> std::pair<llvm::opt::InputArgList, std::vector<StringRef>>
parseDirectives(StringRef S); parseDirectives(StringRef s);
private: private:
// Parses command line options. // Parses command line options.
llvm::opt::InputArgList parse(llvm::ArrayRef<const char *> Args); llvm::opt::InputArgList parse(llvm::ArrayRef<const char *> args);
std::vector<const char *> tokenize(StringRef S); std::vector<const char *> tokenize(StringRef s);
COFFOptTable Table; COFFOptTable table;
}; };
class LinkerDriver { class LinkerDriver {
public: public:
void link(llvm::ArrayRef<const char *> Args); void link(llvm::ArrayRef<const char *> args);
// Used by the resolver to parse .drectve section contents. // Used by the resolver to parse .drectve section contents.
void parseDirectives(InputFile *File); void parseDirectives(InputFile *file);
// Used by ArchiveFile to enqueue members. // Used by ArchiveFile to enqueue members.
void enqueueArchiveMember(const Archive::Child &C, StringRef SymName, void enqueueArchiveMember(const Archive::Child &c, StringRef symName,
StringRef ParentName); StringRef parentName);
MemoryBufferRef takeBuffer(std::unique_ptr<MemoryBuffer> MB); MemoryBufferRef takeBuffer(std::unique_ptr<MemoryBuffer> mb);
void enqueuePath(StringRef Path, bool WholeArchive); void enqueuePath(StringRef path, bool wholeArchive);
private: private:
std::unique_ptr<llvm::TarWriter> Tar; // for /linkrepro std::unique_ptr<llvm::TarWriter> tar; // for /linkrepro
// Opens a file. Path has to be resolved already. // Opens a file. Path has to be resolved already.
MemoryBufferRef openFile(StringRef Path); MemoryBufferRef openFile(StringRef path);
// Searches a file from search paths. // Searches a file from search paths.
Optional<StringRef> findFile(StringRef Filename); Optional<StringRef> findFile(StringRef filename);
Optional<StringRef> findLib(StringRef Filename); Optional<StringRef> findLib(StringRef filename);
StringRef doFindFile(StringRef Filename); StringRef doFindFile(StringRef filename);
StringRef doFindLib(StringRef Filename); StringRef doFindLib(StringRef filename);
StringRef doFindLibMinGW(StringRef Filename); StringRef doFindLibMinGW(StringRef filename);
// Parses LIB environment which contains a list of search paths. // Parses LIB environment which contains a list of search paths.
void addLibSearchPaths(); void addLibSearchPaths();
// Library search path. The first element is always "" (current directory). // Library search path. The first element is always "" (current directory).
std::vector<StringRef> SearchPaths; std::vector<StringRef> searchPaths;
void maybeExportMinGWSymbols(const llvm::opt::InputArgList &Args); void maybeExportMinGWSymbols(const llvm::opt::InputArgList &args);
// We don't want to add the same file more than once. // We don't want to add the same file more than once.
// Files are uniquified by their filesystem and file number. // Files are uniquified by their filesystem and file number.
std::set<llvm::sys::fs::UniqueID> VisitedFiles; std::set<llvm::sys::fs::UniqueID> visitedFiles;
std::set<std::string> VisitedLibs; std::set<std::string> visitedLibs;
Symbol *addUndefined(StringRef Sym); Symbol *addUndefined(StringRef sym);
StringRef mangleMaybe(Symbol *S); StringRef mangleMaybe(Symbol *s);
// Windows specific -- "main" is not the only main function in Windows. // Windows specific -- "main" is not the only main function in Windows.
// You can choose one from these four -- {w,}{WinMain,main}. // You can choose one from these four -- {w,}{WinMain,main}.
// There are four different entry point functions for them, // There are four different entry point functions for them,
// {w,}{WinMain,main}CRTStartup, respectively. The linker needs to // {w,}{WinMain,main}CRTStartup, respectively. The linker needs to
// choose the right one depending on which "main" function is defined. // choose the right one depending on which "main" function is defined.
// This function looks up the symbol table and resolve corresponding // This function looks up the symbol table and resolve corresponding
// entry point name. // entry point name.
StringRef findDefaultEntry(); StringRef findDefaultEntry();
WindowsSubsystem inferSubsystem(); WindowsSubsystem inferSubsystem();
void addBuffer(std::unique_ptr<MemoryBuffer> MB, bool WholeArchive); void addBuffer(std::unique_ptr<MemoryBuffer> mb, bool wholeArchive);
void addArchiveBuffer(MemoryBufferRef MBRef, StringRef SymName, void addArchiveBuffer(MemoryBufferRef mbref, StringRef symName,
StringRef ParentName, uint64_t OffsetInArchive); StringRef parentName, uint64_t offsetInArchive);
void enqueueTask(std::function<void()> Task); void enqueueTask(std::function<void()> task);
bool run(); bool run();
std::list<std::function<void()>> TaskQueue; std::list<std::function<void()>> taskQueue;
std::vector<StringRef> FilePaths; std::vector<StringRef> filePaths;
std::vector<MemoryBufferRef> Resources; std::vector<MemoryBufferRef> resources;
llvm::StringSet<> DirectivesExports; llvm::StringSet<> directivesExports;
}; };
// Functions below this line are defined in DriverUtils.cpp. // Functions below this line are defined in DriverUtils.cpp.
void printHelp(const char *Argv0); void printHelp(const char *argv0);
// Parses a string in the form of "<integer>[,<integer>]". // Parses a string in the form of "<integer>[,<integer>]".
void parseNumbers(StringRef Arg, uint64_t *Addr, uint64_t *Size = nullptr); void parseNumbers(StringRef arg, uint64_t *addr, uint64_t *size = nullptr);
void parseGuard(StringRef Arg); void parseGuard(StringRef arg);
// Parses a string in the form of "<integer>[.<integer>]". // Parses a string in the form of "<integer>[.<integer>]".
// Minor's default value is 0. // Minor's default value is 0.
void parseVersion(StringRef Arg, uint32_t *Major, uint32_t *Minor); void parseVersion(StringRef arg, uint32_t *major, uint32_t *minor);
// Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]". // Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]".
void parseSubsystem(StringRef Arg, WindowsSubsystem *Sys, uint32_t *Major, void parseSubsystem(StringRef arg, WindowsSubsystem *sys, uint32_t *major,
uint32_t *Minor); uint32_t *minor);
void parseAlternateName(StringRef); void parseAlternateName(StringRef);
void parseMerge(StringRef); void parseMerge(StringRef);
void parseSection(StringRef); void parseSection(StringRef);
void parseAligncomm(StringRef); void parseAligncomm(StringRef);
// Parses a string in the form of "[:<integer>]" // Parses a string in the form of "[:<integer>]"
void parseFunctionPadMin(llvm::opt::Arg *A, llvm::COFF::MachineTypes Machine); void parseFunctionPadMin(llvm::opt::Arg *a, llvm::COFF::MachineTypes machine);
// Parses a string in the form of "EMBED[,=<integer>]|NO". // Parses a string in the form of "EMBED[,=<integer>]|NO".
void parseManifest(StringRef Arg); void parseManifest(StringRef arg);
// Parses a string in the form of "level=<string>|uiAccess=<string>" // Parses a string in the form of "level=<string>|uiAccess=<string>"
void parseManifestUAC(StringRef Arg); void parseManifestUAC(StringRef arg);
// Parses a string in the form of "cd|net[,(cd|net)]*" // Parses a string in the form of "cd|net[,(cd|net)]*"
void parseSwaprun(StringRef Arg); void parseSwaprun(StringRef arg);
// Create a resource file containing a manifest XML. // Create a resource file containing a manifest XML.
std::unique_ptr<MemoryBuffer> createManifestRes(); std::unique_ptr<MemoryBuffer> createManifestRes();
void createSideBySideManifest(); void createSideBySideManifest();
// Used for dllexported symbols. // Used for dllexported symbols.
Export parseExport(StringRef Arg); Export parseExport(StringRef arg);
void fixupExports(); void fixupExports();
void assignExportOrdinals(); void assignExportOrdinals();
// Parses a string in the form of "key=value" and check // Parses a string in the form of "key=value" and check
// if value matches previous values for the key. // if value matches previous values for the key.
// This feature used in the directive section to reject // This feature used in the directive section to reject
// incompatible objects. // incompatible objects.
void checkFailIfMismatch(StringRef Arg, InputFile *Source); void checkFailIfMismatch(StringRef arg, InputFile *source);
// Convert Windows resource files (.res files) to a .obj file. // Convert Windows resource files (.res files) to a .obj file.
MemoryBufferRef convertResToCOFF(ArrayRef<MemoryBufferRef> MBs); MemoryBufferRef convertResToCOFF(ArrayRef<MemoryBufferRef> mbs);
void runMSVCLinker(std::string Rsp, ArrayRef<StringRef> Objects); void runMSVCLinker(std::string rsp, ArrayRef<StringRef> objects);
// Create enum with OPT_xxx values for each option in Options.td // Create enum with OPT_xxx values for each option in Options.td
enum { enum {
OPT_INVALID = 0, OPT_INVALID = 0,
#define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID, #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
#include "Options.inc" #include "Options.inc"
#undef OPTION #undef OPTION
}; };
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/COFF/Driver.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
using namespace llvm; using namespace llvm;
using namespace llvm::object; using namespace llvm::object;
using namespace llvm::COFF; using namespace llvm::COFF;
using llvm::sys::Process; using llvm::sys::Process;
namespace lld { namespace lld {
namespace coff { namespace coff {
static Timer InputFileTimer("Input File Reading", Timer::root()); static Timer inputFileTimer("Input File Reading", Timer::root());
Configuration *Config; Configuration *config;
LinkerDriver *Driver; LinkerDriver *driver;
bool link(ArrayRef<const char *> Args, bool CanExitEarly, raw_ostream &Diag) { bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &diag) {
errorHandler().LogName = args::getFilenameWithoutExe(Args[0]); errorHandler().logName = args::getFilenameWithoutExe(args[0]);
errorHandler().ErrorOS = &Diag; errorHandler().errorOS = &diag;
errorHandler().ColorDiagnostics = Diag.has_colors(); errorHandler().colorDiagnostics = diag.has_colors();
errorHandler().ErrorLimitExceededMsg = errorHandler().errorLimitExceededMsg =
"too many errors emitted, stopping now" "too many errors emitted, stopping now"
" (use /errorlimit:0 to see all errors)"; " (use /errorlimit:0 to see all errors)";
errorHandler().ExitEarly = CanExitEarly; errorHandler().exitEarly = canExitEarly;
Config = make<Configuration>(); config = make<Configuration>();
Symtab = make<SymbolTable>(); symtab = make<SymbolTable>();
Driver = make<LinkerDriver>(); driver = make<LinkerDriver>();
Driver->link(Args); driver->link(args);
// Call exit() if we can to avoid calling destructors. // Call exit() if we can to avoid calling destructors.
if (CanExitEarly) if (canExitEarly)
exitLld(errorCount() ? 1 : 0); exitLld(errorCount() ? 1 : 0);
freeArena(); freeArena();
ObjFile::Instances.clear(); ObjFile::instances.clear();
ImportFile::Instances.clear(); ImportFile::instances.clear();
BitcodeFile::Instances.clear(); BitcodeFile::instances.clear();
memset(MergeChunk::Instances, 0, sizeof(MergeChunk::Instances)); memset(MergeChunk::instances, 0, sizeof(MergeChunk::instances));
return !errorCount(); return !errorCount();
} }
// Drop directory components and replace extension with ".exe" or ".dll". // Drop directory components and replace extension with ".exe" or ".dll".
static std::string getOutputPath(StringRef Path) { static std::string getOutputPath(StringRef path) {
auto P = Path.find_last_of("\\/"); auto p = path.find_last_of("\\/");
StringRef S = (P == StringRef::npos) ? Path : Path.substr(P + 1); StringRef s = (p == StringRef::npos) ? path : path.substr(p + 1);
const char* E = Config->DLL ? ".dll" : ".exe"; const char* e = config->dll ? ".dll" : ".exe";
return (S.substr(0, S.rfind('.')) + E).str(); return (s.substr(0, s.rfind('.')) + e).str();
} }
// Returns true if S matches /crtend.?\.o$/. // Returns true if S matches /crtend.?\.o$/.
static bool isCrtend(StringRef S) { static bool isCrtend(StringRef s) {
if (!S.endswith(".o")) if (!s.endswith(".o"))
return false; return false;
S = S.drop_back(2); s = s.drop_back(2);
if (S.endswith("crtend")) if (s.endswith("crtend"))
return true; return true;
return !S.empty() && S.drop_back().endswith("crtend"); return !s.empty() && s.drop_back().endswith("crtend");
} }
// ErrorOr is not default constructible, so it cannot be used as the type // ErrorOr is not default constructible, so it cannot be used as the type
// parameter of a future. // parameter of a future.
// FIXME: We could open the file in createFutureForFile and avoid needing to // FIXME: We could open the file in createFutureForFile and avoid needing to
// return an error here, but for the moment that would cost us a file descriptor // return an error here, but for the moment that would cost us a file descriptor
// (a limited resource on Windows) for the duration that the future is pending. // (a limited resource on Windows) for the duration that the future is pending.
using MBErrPair = std::pair<std::unique_ptr<MemoryBuffer>, std::error_code>; using MBErrPair = std::pair<std::unique_ptr<MemoryBuffer>, std::error_code>;
// Create a std::future that opens and maps a file using the best strategy for // Create a std::future that opens and maps a file using the best strategy for
// the host platform. // the host platform.
static std::future<MBErrPair> createFutureForFile(std::string Path) { static std::future<MBErrPair> createFutureForFile(std::string path) {
#if _WIN32 #if _WIN32
// On Windows, file I/O is relatively slow so it is best to do this // On Windows, file I/O is relatively slow so it is best to do this
// asynchronously. // asynchronously.
auto Strategy = std::launch::async; auto Strategy = std::launch::async;
#else #else
auto Strategy = std::launch::deferred; auto strategy = std::launch::deferred;
#endif #endif
return std::async(Strategy, [=]() { return std::async(strategy, [=]() {
auto MBOrErr = MemoryBuffer::getFile(Path, auto mbOrErr = MemoryBuffer::getFile(path,
/*FileSize*/ -1, /*FileSize*/ -1,
/*RequiresNullTerminator*/ false); /*RequiresNullTerminator*/ false);
if (!MBOrErr) if (!mbOrErr)
return MBErrPair{nullptr, MBOrErr.getError()}; return MBErrPair{nullptr, mbOrErr.getError()};
return MBErrPair{std::move(*MBOrErr), std::error_code()}; return MBErrPair{std::move(*mbOrErr), std::error_code()};
}); });
} }
// Symbol names are mangled by prepending "_" on x86. // Symbol names are mangled by prepending "_" on x86.
static StringRef mangle(StringRef Sym) { static StringRef mangle(StringRef sym) {
assert(Config->Machine != IMAGE_FILE_MACHINE_UNKNOWN); assert(config->machine != IMAGE_FILE_MACHINE_UNKNOWN);
if (Config->Machine == I386) if (config->machine == I386)
return Saver.save("_" + Sym); return saver.save("_" + sym);
return Sym; return sym;
} }
static bool findUnderscoreMangle(StringRef Sym) { static bool findUnderscoreMangle(StringRef sym) {
Symbol *S = Symtab->findMangle(mangle(Sym)); Symbol *s = symtab->findMangle(mangle(sym));
return S && !isa<Undefined>(S); return s && !isa<Undefined>(s);
} }
MemoryBufferRef LinkerDriver::takeBuffer(std::unique_ptr<MemoryBuffer> MB) { MemoryBufferRef LinkerDriver::takeBuffer(std::unique_ptr<MemoryBuffer> mb) {
MemoryBufferRef MBRef = *MB; MemoryBufferRef mbref = *mb;
make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take ownership make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take ownership
if (Driver->Tar) if (driver->tar)
Driver->Tar->append(relativeToRoot(MBRef.getBufferIdentifier()), driver->tar->append(relativeToRoot(mbref.getBufferIdentifier()),
MBRef.getBuffer()); mbref.getBuffer());
return MBRef; return mbref;
} }
void LinkerDriver::addBuffer(std::unique_ptr<MemoryBuffer> MB, void LinkerDriver::addBuffer(std::unique_ptr<MemoryBuffer> mb,
bool WholeArchive) { bool wholeArchive) {
StringRef Filename = MB->getBufferIdentifier(); StringRef filename = mb->getBufferIdentifier();
MemoryBufferRef MBRef = takeBuffer(std::move(MB)); MemoryBufferRef mbref = takeBuffer(std::move(mb));
FilePaths.push_back(Filename); filePaths.push_back(filename);
// File type is detected by contents, not by file extension. // File type is detected by contents, not by file extension.
switch (identify_magic(MBRef.getBuffer())) { switch (identify_magic(mbref.getBuffer())) {
case file_magic::windows_resource: case file_magic::windows_resource:
Resources.push_back(MBRef); resources.push_back(mbref);
break; break;
case file_magic::archive: case file_magic::archive:
if (WholeArchive) { if (wholeArchive) {
std::unique_ptr<Archive> File = std::unique_ptr<Archive> file =
CHECK(Archive::create(MBRef), Filename + ": failed to parse archive"); CHECK(Archive::create(mbref), filename + ": failed to parse archive");
for (MemoryBufferRef M : getArchiveMembers(File.get())) for (MemoryBufferRef m : getArchiveMembers(file.get()))
addArchiveBuffer(M, "<whole-archive>", Filename, 0); addArchiveBuffer(m, "<whole-archive>", filename, 0);
return; return;
} }
Symtab->addFile(make<ArchiveFile>(MBRef)); symtab->addFile(make<ArchiveFile>(mbref));
break; break;
case file_magic::bitcode: case file_magic::bitcode:
Symtab->addFile(make<BitcodeFile>(MBRef, "", 0)); symtab->addFile(make<BitcodeFile>(mbref, "", 0));
break; break;
case file_magic::coff_object: case file_magic::coff_object:
case file_magic::coff_import_library: case file_magic::coff_import_library:
Symtab->addFile(make<ObjFile>(MBRef)); symtab->addFile(make<ObjFile>(mbref));
break; break;
case file_magic::pdb: case file_magic::pdb:
loadTypeServerSource(MBRef); loadTypeServerSource(mbref);
break; break;
case file_magic::coff_cl_gl_object: case file_magic::coff_cl_gl_object:
error(Filename + ": is not a native COFF file. Recompile without /GL"); error(filename + ": is not a native COFF file. Recompile without /GL");
break; break;
case file_magic::pecoff_executable: case file_magic::pecoff_executable:
if (Filename.endswith_lower(".dll")) { if (filename.endswith_lower(".dll")) {
error(Filename + ": bad file type. Did you specify a DLL instead of an " error(filename + ": bad file type. Did you specify a DLL instead of an "
"import library?"); "import library?");
break; break;
} }
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
default: default:
error(MBRef.getBufferIdentifier() + ": unknown file type"); error(mbref.getBufferIdentifier() + ": unknown file type");
break; break;
} }
} }
void LinkerDriver::enqueuePath(StringRef Path, bool WholeArchive) { void LinkerDriver::enqueuePath(StringRef path, bool wholeArchive) {
auto Future = auto future =
std::make_shared<std::future<MBErrPair>>(createFutureForFile(Path)); std::make_shared<std::future<MBErrPair>>(createFutureForFile(path));
std::string PathStr = Path; std::string pathStr = path;
enqueueTask([=]() { enqueueTask([=]() {
auto MBOrErr = Future->get(); auto mbOrErr = future->get();
if (MBOrErr.second) { if (mbOrErr.second) {
std::string Msg = std::string msg =
"could not open '" + PathStr + "': " + MBOrErr.second.message(); "could not open '" + pathStr + "': " + mbOrErr.second.message();
// Check if the filename is a typo for an option flag. OptTable thinks // Check if the filename is a typo for an option flag. OptTable thinks
// that all args that are not known options and that start with / are // that all args that are not known options and that start with / are
// filenames, but e.g. `/nodefaultlibs` is more likely a typo for // filenames, but e.g. `/nodefaultlibs` is more likely a typo for
// the option `/nodefaultlib` than a reference to a file in the root // the option `/nodefaultlib` than a reference to a file in the root
// directory. // directory.
std::string Nearest; std::string nearest;
if (COFFOptTable().findNearest(PathStr, Nearest) > 1) if (COFFOptTable().findNearest(pathStr, nearest) > 1)
error(Msg); error(msg);
else else
error(Msg + "; did you mean '" + Nearest + "'"); error(msg + "; did you mean '" + nearest + "'");
} else } else
Driver->addBuffer(std::move(MBOrErr.first), WholeArchive); driver->addBuffer(std::move(mbOrErr.first), wholeArchive);
}); });
} }
void LinkerDriver::addArchiveBuffer(MemoryBufferRef MB, StringRef SymName, void LinkerDriver::addArchiveBuffer(MemoryBufferRef mb, StringRef symName,
StringRef ParentName, StringRef parentName,
uint64_t OffsetInArchive) { uint64_t offsetInArchive) {
file_magic Magic = identify_magic(MB.getBuffer()); file_magic magic = identify_magic(mb.getBuffer());
if (Magic == file_magic::coff_import_library) { if (magic == file_magic::coff_import_library) {
InputFile *Imp = make<ImportFile>(MB); InputFile *imp = make<ImportFile>(mb);
Imp->ParentName = ParentName; imp->parentName = parentName;
Symtab->addFile(Imp); symtab->addFile(imp);
return; return;
} }
InputFile *Obj; InputFile *obj;
if (Magic == file_magic::coff_object) { if (magic == file_magic::coff_object) {
Obj = make<ObjFile>(MB); obj = make<ObjFile>(mb);
} else if (Magic == file_magic::bitcode) { } else if (magic == file_magic::bitcode) {
Obj = make<BitcodeFile>(MB, ParentName, OffsetInArchive); obj = make<BitcodeFile>(mb, parentName, offsetInArchive);
} else { } else {
error("unknown file type: " + MB.getBufferIdentifier()); error("unknown file type: " + mb.getBufferIdentifier());
return; return;
} }
Obj->ParentName = ParentName; obj->parentName = parentName;
Symtab->addFile(Obj); symtab->addFile(obj);
log("Loaded " + toString(Obj) + " for " + SymName); log("Loaded " + toString(obj) + " for " + symName);
} }
void LinkerDriver::enqueueArchiveMember(const Archive::Child &C, void LinkerDriver::enqueueArchiveMember(const Archive::Child &c,
StringRef SymName, StringRef symName,
StringRef ParentName) { StringRef parentName) {
auto ReportBufferError = [=](Error &&E, auto reportBufferError = [=](Error &&e,
StringRef ChildName) { StringRef childName) {
fatal("could not get the buffer for the member defining symbol " + fatal("could not get the buffer for the member defining symbol " +
SymName + ": " + ParentName + "(" + ChildName + "): " + symName + ": " + parentName + "(" + childName + "): " +
toString(std::move(E))); toString(std::move(e)));
}; };
if (!C.getParent()->isThin()) { if (!c.getParent()->isThin()) {
uint64_t OffsetInArchive = C.getChildOffset(); uint64_t offsetInArchive = c.getChildOffset();
Expected<MemoryBufferRef> MBOrErr = C.getMemoryBufferRef(); Expected<MemoryBufferRef> mbOrErr = c.getMemoryBufferRef();
if (!MBOrErr) if (!mbOrErr)
ReportBufferError(MBOrErr.takeError(), check(C.getFullName())); reportBufferError(mbOrErr.takeError(), check(c.getFullName()));
MemoryBufferRef MB = MBOrErr.get(); MemoryBufferRef mb = mbOrErr.get();
enqueueTask([=]() { enqueueTask([=]() {
Driver->addArchiveBuffer(MB, SymName, ParentName, OffsetInArchive); driver->addArchiveBuffer(mb, symName, parentName, offsetInArchive);
}); });
return; return;
} }
std::string ChildName = CHECK( std::string childName = CHECK(
C.getFullName(), c.getFullName(),
"could not get the filename for the member defining symbol " + "could not get the filename for the member defining symbol " +
SymName); symName);
auto Future = std::make_shared<std::future<MBErrPair>>( auto future = std::make_shared<std::future<MBErrPair>>(
createFutureForFile(ChildName)); createFutureForFile(childName));
enqueueTask([=]() { enqueueTask([=]() {
auto MBOrErr = Future->get(); auto mbOrErr = future->get();
if (MBOrErr.second) if (mbOrErr.second)
ReportBufferError(errorCodeToError(MBOrErr.second), ChildName); reportBufferError(errorCodeToError(mbOrErr.second), childName);
Driver->addArchiveBuffer(takeBuffer(std::move(MBOrErr.first)), SymName, driver->addArchiveBuffer(takeBuffer(std::move(mbOrErr.first)), symName,
ParentName, /* OffsetInArchive */ 0); parentName, /* OffsetInArchive */ 0);
}); });
} }
static bool isDecorated(StringRef Sym) { static bool isDecorated(StringRef sym) {
return Sym.startswith("@") || Sym.contains("@@") || Sym.startswith("?") || return sym.startswith("@") || sym.contains("@@") || sym.startswith("?") ||
(!Config->MinGW && Sym.contains('@')); (!config->mingw && sym.contains('@'));
} }
// Parses .drectve section contents and returns a list of files // Parses .drectve section contents and returns a list of files
// specified by /defaultlib. // specified by /defaultlib.
void LinkerDriver::parseDirectives(InputFile *File) { void LinkerDriver::parseDirectives(InputFile *file) {
StringRef S = File->getDirectives(); StringRef s = file->getDirectives();
if (S.empty()) if (s.empty())
return; return;
log("Directives: " + toString(File) + ": " + S); log("Directives: " + toString(file) + ": " + s);
ArgParser Parser; ArgParser parser;
// .drectve is always tokenized using Windows shell rules. // .drectve is always tokenized using Windows shell rules.
// /EXPORT: option can appear too many times, processing in fastpath. // /EXPORT: option can appear too many times, processing in fastpath.
opt::InputArgList Args; opt::InputArgList args;
std::vector<StringRef> Exports; std::vector<StringRef> exports;
std::tie(Args, Exports) = Parser.parseDirectives(S); std::tie(args, exports) = parser.parseDirectives(s);
for (StringRef E : Exports) { for (StringRef e : exports) {
// If a common header file contains dllexported function // If a common header file contains dllexported function
// declarations, many object files may end up with having the // declarations, many object files may end up with having the
// same /EXPORT options. In order to save cost of parsing them, // same /EXPORT options. In order to save cost of parsing them,
// we dedup them first. // we dedup them first.
if (!DirectivesExports.insert(E).second) if (!directivesExports.insert(e).second)
continue; continue;
Export Exp = parseExport(E); Export exp = parseExport(e);
if (Config->Machine == I386 && Config->MinGW) { if (config->machine == I386 && config->mingw) {
if (!isDecorated(Exp.Name)) if (!isDecorated(exp.name))
Exp.Name = Saver.save("_" + Exp.Name); exp.name = saver.save("_" + exp.name);
if (!Exp.ExtName.empty() && !isDecorated(Exp.ExtName)) if (!exp.extName.empty() && !isDecorated(exp.extName))
Exp.ExtName = Saver.save("_" + Exp.ExtName); exp.extName = saver.save("_" + exp.extName);
} }
Exp.Directives = true; exp.directives = true;
Config->Exports.push_back(Exp); config->exports.push_back(exp);
} }
for (auto *Arg : Args) { for (auto *arg : args) {
switch (Arg->getOption().getID()) { switch (arg->getOption().getID()) {
case OPT_aligncomm: case OPT_aligncomm:
parseAligncomm(Arg->getValue()); parseAligncomm(arg->getValue());
break; break;
case OPT_alternatename: case OPT_alternatename:
parseAlternateName(Arg->getValue()); parseAlternateName(arg->getValue());
break; break;
case OPT_defaultlib: case OPT_defaultlib:
if (Optional<StringRef> Path = findLib(Arg->getValue())) if (Optional<StringRef> path = findLib(arg->getValue()))
enqueuePath(*Path, false); enqueuePath(*path, false);
break; break;
case OPT_entry: case OPT_entry:
Config->Entry = addUndefined(mangle(Arg->getValue())); config->entry = addUndefined(mangle(arg->getValue()));
break; break;
case OPT_failifmismatch: case OPT_failifmismatch:
checkFailIfMismatch(Arg->getValue(), File); checkFailIfMismatch(arg->getValue(), file);
break; break;
case OPT_incl: case OPT_incl:
addUndefined(Arg->getValue()); addUndefined(arg->getValue());
break; break;
case OPT_merge: case OPT_merge:
parseMerge(Arg->getValue()); parseMerge(arg->getValue());
break; break;
case OPT_nodefaultlib: case OPT_nodefaultlib:
Config->NoDefaultLibs.insert(doFindLib(Arg->getValue()).lower()); config->noDefaultLibs.insert(doFindLib(arg->getValue()).lower());
break; break;
case OPT_section: case OPT_section:
parseSection(Arg->getValue()); parseSection(arg->getValue());
break; break;
case OPT_subsystem: case OPT_subsystem:
parseSubsystem(Arg->getValue(), &Config->Subsystem, parseSubsystem(arg->getValue(), &config->subsystem,
&Config->MajorOSVersion, &Config->MinorOSVersion); &config->majorOSVersion, &config->minorOSVersion);
break; break;
// Only add flags here that link.exe accepts in // Only add flags here that link.exe accepts in
// `#pragma comment(linker, "/flag")`-generated sections. // `#pragma comment(linker, "/flag")`-generated sections.
case OPT_editandcontinue: case OPT_editandcontinue:
case OPT_guardsym: case OPT_guardsym:
case OPT_throwingnew: case OPT_throwingnew:
break; break;
default: default:
error(Arg->getSpelling() + " is not allowed in .drectve"); error(arg->getSpelling() + " is not allowed in .drectve");
} }
} }
} }
// Find file from search paths. You can omit ".obj", this function takes // Find file from search paths. You can omit ".obj", this function takes
// care of that. Note that the returned path is not guaranteed to exist. // care of that. Note that the returned path is not guaranteed to exist.
StringRef LinkerDriver::doFindFile(StringRef Filename) { StringRef LinkerDriver::doFindFile(StringRef filename) {
bool HasPathSep = (Filename.find_first_of("/\\") != StringRef::npos); bool hasPathSep = (filename.find_first_of("/\\") != StringRef::npos);
if (HasPathSep) if (hasPathSep)
return Filename; return filename;
bool HasExt = Filename.contains('.'); bool hasExt = filename.contains('.');
for (StringRef Dir : SearchPaths) { for (StringRef dir : searchPaths) {
SmallString<128> Path = Dir; SmallString<128> path = dir;
sys::path::append(Path, Filename); sys::path::append(path, filename);
if (sys::fs::exists(Path.str())) if (sys::fs::exists(path.str()))
return Saver.save(Path.str()); return saver.save(path.str());
if (!HasExt) { if (!hasExt) {
Path.append(".obj"); path.append(".obj");
if (sys::fs::exists(Path.str())) if (sys::fs::exists(path.str()))
return Saver.save(Path.str()); return saver.save(path.str());
} }
} }
return Filename; return filename;
} }
static Optional<sys::fs::UniqueID> getUniqueID(StringRef Path) { static Optional<sys::fs::UniqueID> getUniqueID(StringRef path) {
sys::fs::UniqueID Ret; sys::fs::UniqueID ret;
if (sys::fs::getUniqueID(Path, Ret)) if (sys::fs::getUniqueID(path, ret))
return None; return None;
return Ret; return ret;
} }
// Resolves a file path. This never returns the same path // Resolves a file path. This never returns the same path
// (in that case, it returns None). // (in that case, it returns None).
Optional<StringRef> LinkerDriver::findFile(StringRef Filename) { Optional<StringRef> LinkerDriver::findFile(StringRef filename) {
StringRef Path = doFindFile(Filename); StringRef path = doFindFile(filename);
if (Optional<sys::fs::UniqueID> ID = getUniqueID(Path)) { if (Optional<sys::fs::UniqueID> id = getUniqueID(path)) {
bool Seen = !VisitedFiles.insert(*ID).second; bool seen = !visitedFiles.insert(*id).second;
if (Seen) if (seen)
return None; return None;
} }
if (Path.endswith_lower(".lib")) if (path.endswith_lower(".lib"))
VisitedLibs.insert(sys::path::filename(Path)); visitedLibs.insert(sys::path::filename(path));
return Path; return path;
} }
// MinGW specific. If an embedded directive specified to link to // MinGW specific. If an embedded directive specified to link to
// foo.lib, but it isn't found, try libfoo.a instead. // foo.lib, but it isn't found, try libfoo.a instead.
StringRef LinkerDriver::doFindLibMinGW(StringRef Filename) { StringRef LinkerDriver::doFindLibMinGW(StringRef filename) {
if (Filename.contains('/') || Filename.contains('\\')) if (filename.contains('/') || filename.contains('\\'))
return Filename; return filename;
SmallString<128> S = Filename; SmallString<128> s = filename;
sys::path::replace_extension(S, ".a"); sys::path::replace_extension(s, ".a");
StringRef LibName = Saver.save("lib" + S.str()); StringRef libName = saver.save("lib" + s.str());
return doFindFile(LibName); return doFindFile(libName);
} }
// Find library file from search path. // Find library file from search path.
StringRef LinkerDriver::doFindLib(StringRef Filename) { StringRef LinkerDriver::doFindLib(StringRef filename) {
// Add ".lib" to Filename if that has no file extension. // Add ".lib" to Filename if that has no file extension.
bool HasExt = Filename.contains('.'); bool hasExt = filename.contains('.');
if (!HasExt) if (!hasExt)
Filename = Saver.save(Filename + ".lib"); filename = saver.save(filename + ".lib");
StringRef Ret = doFindFile(Filename); StringRef ret = doFindFile(filename);
// For MinGW, if the find above didn't turn up anything, try // For MinGW, if the find above didn't turn up anything, try
// looking for a MinGW formatted library name. // looking for a MinGW formatted library name.
if (Config->MinGW && Ret == Filename) if (config->mingw && ret == filename)
return doFindLibMinGW(Filename); return doFindLibMinGW(filename);
return Ret; return ret;
} }
// Resolves a library path. /nodefaultlib options are taken into // Resolves a library path. /nodefaultlib options are taken into
// consideration. This never returns the same path (in that case, // consideration. This never returns the same path (in that case,
// it returns None). // it returns None).
Optional<StringRef> LinkerDriver::findLib(StringRef Filename) { Optional<StringRef> LinkerDriver::findLib(StringRef filename) {
if (Config->NoDefaultLibAll) if (config->noDefaultLibAll)
return None; return None;
if (!VisitedLibs.insert(Filename.lower()).second) if (!visitedLibs.insert(filename.lower()).second)
return None; return None;
StringRef Path = doFindLib(Filename); StringRef path = doFindLib(filename);
if (Config->NoDefaultLibs.count(Path.lower())) if (config->noDefaultLibs.count(path.lower()))
return None; return None;
if (Optional<sys::fs::UniqueID> ID = getUniqueID(Path)) if (Optional<sys::fs::UniqueID> id = getUniqueID(path))
if (!VisitedFiles.insert(*ID).second) if (!visitedFiles.insert(*id).second)
return None; return None;
return Path; return path;
} }
// Parses LIB environment which contains a list of search paths. // Parses LIB environment which contains a list of search paths.
void LinkerDriver::addLibSearchPaths() { void LinkerDriver::addLibSearchPaths() {
Optional<std::string> EnvOpt = Process::GetEnv("LIB"); Optional<std::string> envOpt = Process::GetEnv("LIB");
if (!EnvOpt.hasValue()) if (!envOpt.hasValue())
return; return;
StringRef Env = Saver.save(*EnvOpt); StringRef env = saver.save(*envOpt);
while (!Env.empty()) { while (!env.empty()) {
StringRef Path; StringRef path;
std::tie(Path, Env) = Env.split(';'); std::tie(path, env) = env.split(';');
SearchPaths.push_back(Path); searchPaths.push_back(path);
} }
} }
Symbol *LinkerDriver::addUndefined(StringRef Name) { Symbol *LinkerDriver::addUndefined(StringRef name) {
Symbol *B = Symtab->addUndefined(Name); Symbol *b = symtab->addUndefined(name);
if (!B->IsGCRoot) { if (!b->isGCRoot) {
B->IsGCRoot = true; b->isGCRoot = true;
Config->GCRoot.push_back(B); config->gCRoot.push_back(b);
} }
return B; return b;
} }
StringRef LinkerDriver::mangleMaybe(Symbol *S) { StringRef LinkerDriver::mangleMaybe(Symbol *s) {
// If the plain symbol name has already been resolved, do nothing. // If the plain symbol name has already been resolved, do nothing.
Undefined *Unmangled = dyn_cast<Undefined>(S); Undefined *unmangled = dyn_cast<Undefined>(s);
if (!Unmangled) if (!unmangled)
return ""; return "";
// Otherwise, see if a similar, mangled symbol exists in the symbol table. // Otherwise, see if a similar, mangled symbol exists in the symbol table.
Symbol *Mangled = Symtab->findMangle(Unmangled->getName()); Symbol *mangled = symtab->findMangle(unmangled->getName());
if (!Mangled) if (!mangled)
return ""; return "";
// If we find a similar mangled symbol, make this an alias to it and return // If we find a similar mangled symbol, make this an alias to it and return
// its name. // its name.
log(Unmangled->getName() + " aliased to " + Mangled->getName()); log(unmangled->getName() + " aliased to " + mangled->getName());
Unmangled->WeakAlias = Symtab->addUndefined(Mangled->getName()); unmangled->weakAlias = symtab->addUndefined(mangled->getName());
return Mangled->getName(); return mangled->getName();
} }
// Windows specific -- find default entry point name. // Windows specific -- find default entry point name.
// //
// There are four different entry point functions for Windows executables, // There are four different entry point functions for Windows executables,
// each of which corresponds to a user-defined "main" function. This function // each of which corresponds to a user-defined "main" function. This function
// infers an entry point from a user-defined "main" function. // infers an entry point from a user-defined "main" function.
StringRef LinkerDriver::findDefaultEntry() { StringRef LinkerDriver::findDefaultEntry() {
assert(Config->Subsystem != IMAGE_SUBSYSTEM_UNKNOWN && assert(config->subsystem != IMAGE_SUBSYSTEM_UNKNOWN &&
"must handle /subsystem before calling this"); "must handle /subsystem before calling this");
if (Config->MinGW) if (config->mingw)
return mangle(Config->Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI return mangle(config->subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI
? "WinMainCRTStartup" ? "WinMainCRTStartup"
: "mainCRTStartup"); : "mainCRTStartup");
if (Config->Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI) { if (config->subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI) {
if (findUnderscoreMangle("wWinMain")) { if (findUnderscoreMangle("wWinMain")) {
if (!findUnderscoreMangle("WinMain")) if (!findUnderscoreMangle("WinMain"))
return mangle("wWinMainCRTStartup"); return mangle("wWinMainCRTStartup");
warn("found both wWinMain and WinMain; using latter"); warn("found both wWinMain and WinMain; using latter");
} }
return mangle("WinMainCRTStartup"); return mangle("WinMainCRTStartup");
} }
if (findUnderscoreMangle("wmain")) { if (findUnderscoreMangle("wmain")) {
if (!findUnderscoreMangle("main")) if (!findUnderscoreMangle("main"))
return mangle("wmainCRTStartup"); return mangle("wmainCRTStartup");
warn("found both wmain and main; using latter"); warn("found both wmain and main; using latter");
} }
return mangle("mainCRTStartup"); return mangle("mainCRTStartup");
} }
WindowsSubsystem LinkerDriver::inferSubsystem() { WindowsSubsystem LinkerDriver::inferSubsystem() {
if (Config->DLL) if (config->dll)
return IMAGE_SUBSYSTEM_WINDOWS_GUI; return IMAGE_SUBSYSTEM_WINDOWS_GUI;
if (Config->MinGW) if (config->mingw)
return IMAGE_SUBSYSTEM_WINDOWS_CUI; return IMAGE_SUBSYSTEM_WINDOWS_CUI;
// Note that link.exe infers the subsystem from the presence of these // Note that link.exe infers the subsystem from the presence of these
// functions even if /entry: or /nodefaultlib are passed which causes them // functions even if /entry: or /nodefaultlib are passed which causes them
// to not be called. // to not be called.
bool HaveMain = findUnderscoreMangle("main"); bool haveMain = findUnderscoreMangle("main");
bool HaveWMain = findUnderscoreMangle("wmain"); bool haveWMain = findUnderscoreMangle("wmain");
bool HaveWinMain = findUnderscoreMangle("WinMain"); bool haveWinMain = findUnderscoreMangle("WinMain");
bool HaveWWinMain = findUnderscoreMangle("wWinMain"); bool haveWWinMain = findUnderscoreMangle("wWinMain");
if (HaveMain || HaveWMain) { if (haveMain || haveWMain) {
if (HaveWinMain || HaveWWinMain) { if (haveWinMain || haveWWinMain) {
warn(std::string("found ") + (HaveMain ? "main" : "wmain") + " and " + warn(std::string("found ") + (haveMain ? "main" : "wmain") + " and " +
(HaveWinMain ? "WinMain" : "wWinMain") + (haveWinMain ? "WinMain" : "wWinMain") +
"; defaulting to /subsystem:console"); "; defaulting to /subsystem:console");
} }
return IMAGE_SUBSYSTEM_WINDOWS_CUI; return IMAGE_SUBSYSTEM_WINDOWS_CUI;
} }
if (HaveWinMain || HaveWWinMain) if (haveWinMain || haveWWinMain)
return IMAGE_SUBSYSTEM_WINDOWS_GUI; return IMAGE_SUBSYSTEM_WINDOWS_GUI;
return IMAGE_SUBSYSTEM_UNKNOWN; return IMAGE_SUBSYSTEM_UNKNOWN;
} }
static uint64_t getDefaultImageBase() { static uint64_t getDefaultImageBase() {
if (Config->is64()) if (config->is64())
return Config->DLL ? 0x180000000 : 0x140000000; return config->dll ? 0x180000000 : 0x140000000;
return Config->DLL ? 0x10000000 : 0x400000; return config->dll ? 0x10000000 : 0x400000;
} }
static std::string createResponseFile(const opt::InputArgList &Args, static std::string createResponseFile(const opt::InputArgList &args,
ArrayRef<StringRef> FilePaths, ArrayRef<StringRef> filePaths,
ArrayRef<StringRef> SearchPaths) { ArrayRef<StringRef> searchPaths) {
SmallString<0> Data; SmallString<0> data;
raw_svector_ostream OS(Data); raw_svector_ostream os(data);
for (auto *Arg : Args) { for (auto *arg : args) {
switch (Arg->getOption().getID()) { switch (arg->getOption().getID()) {
case OPT_linkrepro: case OPT_linkrepro:
case OPT_INPUT: case OPT_INPUT:
case OPT_defaultlib: case OPT_defaultlib:
case OPT_libpath: case OPT_libpath:
case OPT_manifest: case OPT_manifest:
case OPT_manifest_colon: case OPT_manifest_colon:
case OPT_manifestdependency: case OPT_manifestdependency:
case OPT_manifestfile: case OPT_manifestfile:
case OPT_manifestinput: case OPT_manifestinput:
case OPT_manifestuac: case OPT_manifestuac:
break; break;
case OPT_implib: case OPT_implib:
case OPT_pdb: case OPT_pdb:
case OPT_out: case OPT_out:
OS << Arg->getSpelling() << sys::path::filename(Arg->getValue()) << "\n"; os << arg->getSpelling() << sys::path::filename(arg->getValue()) << "\n";
break; break;
default: default:
OS << toString(*Arg) << "\n"; os << toString(*arg) << "\n";
} }
} }
for (StringRef Path : SearchPaths) { for (StringRef path : searchPaths) {
std::string RelPath = relativeToRoot(Path); std::string relPath = relativeToRoot(path);
OS << "/libpath:" << quote(RelPath) << "\n"; os << "/libpath:" << quote(relPath) << "\n";
} }
for (StringRef Path : FilePaths) for (StringRef path : filePaths)
OS << quote(relativeToRoot(Path)) << "\n"; os << quote(relativeToRoot(path)) << "\n";
return Data.str(); return data.str();
} }
enum class DebugKind { Unknown, None, Full, FastLink, GHash, Dwarf, Symtab }; enum class DebugKind { Unknown, None, Full, FastLink, GHash, Dwarf, Symtab };
static DebugKind parseDebugKind(const opt::InputArgList &Args) { static DebugKind parseDebugKind(const opt::InputArgList &args) {
auto *A = Args.getLastArg(OPT_debug, OPT_debug_opt); auto *a = args.getLastArg(OPT_debug, OPT_debug_opt);
if (!A) if (!a)
return DebugKind::None; return DebugKind::None;
if (A->getNumValues() == 0) if (a->getNumValues() == 0)
return DebugKind::Full; return DebugKind::Full;
DebugKind Debug = StringSwitch<DebugKind>(A->getValue()) DebugKind debug = StringSwitch<DebugKind>(a->getValue())
.CaseLower("none", DebugKind::None) .CaseLower("none", DebugKind::None)
.CaseLower("full", DebugKind::Full) .CaseLower("full", DebugKind::Full)
.CaseLower("fastlink", DebugKind::FastLink) .CaseLower("fastlink", DebugKind::FastLink)
// LLD extensions // LLD extensions
.CaseLower("ghash", DebugKind::GHash) .CaseLower("ghash", DebugKind::GHash)
.CaseLower("dwarf", DebugKind::Dwarf) .CaseLower("dwarf", DebugKind::Dwarf)
.CaseLower("symtab", DebugKind::Symtab) .CaseLower("symtab", DebugKind::Symtab)
.Default(DebugKind::Unknown); .Default(DebugKind::Unknown);
if (Debug == DebugKind::FastLink) { if (debug == DebugKind::FastLink) {
warn("/debug:fastlink unsupported; using /debug:full"); warn("/debug:fastlink unsupported; using /debug:full");
return DebugKind::Full; return DebugKind::Full;
} }
if (Debug == DebugKind::Unknown) { if (debug == DebugKind::Unknown) {
error("/debug: unknown option: " + Twine(A->getValue())); error("/debug: unknown option: " + Twine(a->getValue()));
return DebugKind::None; return DebugKind::None;
} }
return Debug; return debug;
} }
static unsigned parseDebugTypes(const opt::InputArgList &Args) { static unsigned parseDebugTypes(const opt::InputArgList &args) {
unsigned DebugTypes = static_cast<unsigned>(DebugType::None); unsigned debugTypes = static_cast<unsigned>(DebugType::None);
if (auto *A = Args.getLastArg(OPT_debugtype)) { if (auto *a = args.getLastArg(OPT_debugtype)) {
SmallVector<StringRef, 3> Types; SmallVector<StringRef, 3> types;
StringRef(A->getValue()) StringRef(a->getValue())
.split(Types, ',', /*MaxSplit=*/-1, /*KeepEmpty=*/false); .split(types, ',', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
for (StringRef Type : Types) { for (StringRef type : types) {
unsigned V = StringSwitch<unsigned>(Type.lower()) unsigned v = StringSwitch<unsigned>(type.lower())
.Case("cv", static_cast<unsigned>(DebugType::CV)) .Case("cv", static_cast<unsigned>(DebugType::CV))
.Case("pdata", static_cast<unsigned>(DebugType::PData)) .Case("pdata", static_cast<unsigned>(DebugType::PData))
.Case("fixup", static_cast<unsigned>(DebugType::Fixup)) .Case("fixup", static_cast<unsigned>(DebugType::Fixup))
.Default(0); .Default(0);
if (V == 0) { if (v == 0) {
warn("/debugtype: unknown option '" + Type + "'"); warn("/debugtype: unknown option '" + type + "'");
continue; continue;
} }
DebugTypes |= V; debugTypes |= v;
} }
return DebugTypes; return debugTypes;
} }
// Default debug types // Default debug types
DebugTypes = static_cast<unsigned>(DebugType::CV); debugTypes = static_cast<unsigned>(DebugType::CV);
if (Args.hasArg(OPT_driver)) if (args.hasArg(OPT_driver))
DebugTypes |= static_cast<unsigned>(DebugType::PData); debugTypes |= static_cast<unsigned>(DebugType::PData);
if (Args.hasArg(OPT_profile)) if (args.hasArg(OPT_profile))
DebugTypes |= static_cast<unsigned>(DebugType::Fixup); debugTypes |= static_cast<unsigned>(DebugType::Fixup);
return DebugTypes; return debugTypes;
} }
static std::string getMapFile(const opt::InputArgList &Args) { static std::string getMapFile(const opt::InputArgList &args) {
auto *Arg = Args.getLastArg(OPT_lldmap, OPT_lldmap_file); auto *arg = args.getLastArg(OPT_lldmap, OPT_lldmap_file);
if (!Arg) if (!arg)
return ""; return "";
if (Arg->getOption().getID() == OPT_lldmap_file) if (arg->getOption().getID() == OPT_lldmap_file)
return Arg->getValue(); return arg->getValue();
assert(Arg->getOption().getID() == OPT_lldmap); assert(arg->getOption().getID() == OPT_lldmap);
StringRef OutFile = Config->OutputFile; StringRef outFile = config->outputFile;
return (OutFile.substr(0, OutFile.rfind('.')) + ".map").str(); return (outFile.substr(0, outFile.rfind('.')) + ".map").str();
} }
static std::string getImplibPath() { static std::string getImplibPath() {
if (!Config->Implib.empty()) if (!config->implib.empty())
return Config->Implib; return config->implib;
SmallString<128> Out = StringRef(Config->OutputFile); SmallString<128> out = StringRef(config->outputFile);
sys::path::replace_extension(Out, ".lib"); sys::path::replace_extension(out, ".lib");
return Out.str(); return out.str();
} }
// //
// The import name is caculated as the following: // The import name is caculated as the following:
// //
// | LIBRARY w/ ext | LIBRARY w/o ext | no LIBRARY // | LIBRARY w/ ext | LIBRARY w/o ext | no LIBRARY
// -----+----------------+---------------------+------------------ // -----+----------------+---------------------+------------------
// LINK | {value} | {value}.{.dll/.exe} | {output name} // LINK | {value} | {value}.{.dll/.exe} | {output name}
// LIB | {value} | {value}.dll | {output name}.dll // LIB | {value} | {value}.dll | {output name}.dll
// //
static std::string getImportName(bool AsLib) { static std::string getImportName(bool asLib) {
SmallString<128> Out; SmallString<128> out;
if (Config->ImportName.empty()) { if (config->importName.empty()) {
Out.assign(sys::path::filename(Config->OutputFile)); out.assign(sys::path::filename(config->outputFile));
if (AsLib) if (asLib)
sys::path::replace_extension(Out, ".dll"); sys::path::replace_extension(out, ".dll");
} else { } else {
Out.assign(Config->ImportName); out.assign(config->importName);
if (!sys::path::has_extension(Out)) if (!sys::path::has_extension(out))
sys::path::replace_extension(Out, sys::path::replace_extension(out,
(Config->DLL || AsLib) ? ".dll" : ".exe"); (config->dll || asLib) ? ".dll" : ".exe");
} }
return Out.str(); return out.str();
} }
static void createImportLibrary(bool AsLib) { static void createImportLibrary(bool asLib) {
std::vector<COFFShortExport> Exports; std::vector<COFFShortExport> exports;
for (Export &E1 : Config->Exports) { for (Export &e1 : config->exports) {
COFFShortExport E2; COFFShortExport e2;
E2.Name = E1.Name; e2.Name = e1.name;
E2.SymbolName = E1.SymbolName; e2.SymbolName = e1.symbolName;
E2.ExtName = E1.ExtName; e2.ExtName = e1.extName;
E2.Ordinal = E1.Ordinal; e2.Ordinal = e1.ordinal;
E2.Noname = E1.Noname; e2.Noname = e1.noname;
E2.Data = E1.Data; e2.Data = e1.data;
E2.Private = E1.Private; e2.Private = e1.isPrivate;
E2.Constant = E1.Constant; e2.Constant = e1.constant;
Exports.push_back(E2); exports.push_back(e2);
} }
auto HandleError = [](Error &&E) { auto handleError = [](Error &&e) {
handleAllErrors(std::move(E), handleAllErrors(std::move(e),
[](ErrorInfoBase &EIB) { error(EIB.message()); }); [](ErrorInfoBase &eib) { error(eib.message()); });
}; };
std::string LibName = getImportName(AsLib); std::string libName = getImportName(asLib);
std::string Path = getImplibPath(); std::string path = getImplibPath();
if (!Config->Incremental) { if (!config->incremental) {
HandleError(writeImportLibrary(LibName, Path, Exports, Config->Machine, handleError(writeImportLibrary(libName, path, exports, config->machine,
Config->MinGW)); config->mingw));
return; return;
} }
// If the import library already exists, replace it only if the contents // If the import library already exists, replace it only if the contents
// have changed. // have changed.
ErrorOr<std::unique_ptr<MemoryBuffer>> OldBuf = MemoryBuffer::getFile( ErrorOr<std::unique_ptr<MemoryBuffer>> oldBuf = MemoryBuffer::getFile(
Path, /*FileSize*/ -1, /*RequiresNullTerminator*/ false); path, /*FileSize*/ -1, /*RequiresNullTerminator*/ false);
if (!OldBuf) { if (!oldBuf) {
HandleError(writeImportLibrary(LibName, Path, Exports, Config->Machine, handleError(writeImportLibrary(libName, path, exports, config->machine,
Config->MinGW)); config->mingw));
return; return;
} }
SmallString<128> TmpName; SmallString<128> tmpName;
if (std::error_code EC = if (std::error_code ec =
sys::fs::createUniqueFile(Path + ".tmp-%%%%%%%%.lib", TmpName)) sys::fs::createUniqueFile(path + ".tmp-%%%%%%%%.lib", tmpName))
fatal("cannot create temporary file for import library " + Path + ": " + fatal("cannot create temporary file for import library " + path + ": " +
EC.message()); ec.message());
if (Error E = writeImportLibrary(LibName, TmpName, Exports, Config->Machine, if (Error e = writeImportLibrary(libName, tmpName, exports, config->machine,
Config->MinGW)) { config->mingw)) {
HandleError(std::move(E)); handleError(std::move(e));
return; return;
} }
std::unique_ptr<MemoryBuffer> NewBuf = check(MemoryBuffer::getFile( std::unique_ptr<MemoryBuffer> newBuf = check(MemoryBuffer::getFile(
TmpName, /*FileSize*/ -1, /*RequiresNullTerminator*/ false)); tmpName, /*FileSize*/ -1, /*RequiresNullTerminator*/ false));
if ((*OldBuf)->getBuffer() != NewBuf->getBuffer()) { if ((*oldBuf)->getBuffer() != newBuf->getBuffer()) {
OldBuf->reset(); oldBuf->reset();
HandleError(errorCodeToError(sys::fs::rename(TmpName, Path))); handleError(errorCodeToError(sys::fs::rename(tmpName, path)));
} else { } else {
sys::fs::remove(TmpName); sys::fs::remove(tmpName);
} }
} }
static void parseModuleDefs(StringRef Path) { static void parseModuleDefs(StringRef path) {
std::unique_ptr<MemoryBuffer> MB = CHECK( std::unique_ptr<MemoryBuffer> mb = CHECK(
MemoryBuffer::getFile(Path, -1, false, true), "could not open " + Path); MemoryBuffer::getFile(path, -1, false, true), "could not open " + path);
COFFModuleDefinition M = check(parseCOFFModuleDefinition( COFFModuleDefinition m = check(parseCOFFModuleDefinition(
MB->getMemBufferRef(), Config->Machine, Config->MinGW)); mb->getMemBufferRef(), config->machine, config->mingw));
if (Config->OutputFile.empty()) if (config->outputFile.empty())
Config->OutputFile = Saver.save(M.OutputFile); config->outputFile = saver.save(m.OutputFile);
Config->ImportName = Saver.save(M.ImportName); config->importName = saver.save(m.ImportName);
if (M.ImageBase) if (m.ImageBase)
Config->ImageBase = M.ImageBase; config->imageBase = m.ImageBase;
if (M.StackReserve) if (m.StackReserve)
Config->StackReserve = M.StackReserve; config->stackReserve = m.StackReserve;
if (M.StackCommit) if (m.StackCommit)
Config->StackCommit = M.StackCommit; config->stackCommit = m.StackCommit;
if (M.HeapReserve) if (m.HeapReserve)
Config->HeapReserve = M.HeapReserve; config->heapReserve = m.HeapReserve;
if (M.HeapCommit) if (m.HeapCommit)
Config->HeapCommit = M.HeapCommit; config->heapCommit = m.HeapCommit;
if (M.MajorImageVersion) if (m.MajorImageVersion)
Config->MajorImageVersion = M.MajorImageVersion; config->majorImageVersion = m.MajorImageVersion;
if (M.MinorImageVersion) if (m.MinorImageVersion)
Config->MinorImageVersion = M.MinorImageVersion; config->minorImageVersion = m.MinorImageVersion;
if (M.MajorOSVersion) if (m.MajorOSVersion)
Config->MajorOSVersion = M.MajorOSVersion; config->majorOSVersion = m.MajorOSVersion;
if (M.MinorOSVersion) if (m.MinorOSVersion)
Config->MinorOSVersion = M.MinorOSVersion; config->minorOSVersion = m.MinorOSVersion;
for (COFFShortExport E1 : M.Exports) { for (COFFShortExport e1 : m.Exports) {
Export E2; Export e2;
// In simple cases, only Name is set. Renamed exports are parsed // In simple cases, only Name is set. Renamed exports are parsed
// and set as "ExtName = Name". If Name has the form "OtherDll.Func", // and set as "ExtName = Name". If Name has the form "OtherDll.Func",
// it shouldn't be a normal exported function but a forward to another // it shouldn't be a normal exported function but a forward to another
// DLL instead. This is supported by both MS and GNU linkers. // DLL instead. This is supported by both MS and GNU linkers.
if (E1.ExtName != E1.Name && StringRef(E1.Name).contains('.')) { if (e1.ExtName != e1.Name && StringRef(e1.Name).contains('.')) {
E2.Name = Saver.save(E1.ExtName); e2.name = saver.save(e1.ExtName);
E2.ForwardTo = Saver.save(E1.Name); e2.forwardTo = saver.save(e1.Name);
Config->Exports.push_back(E2); config->exports.push_back(e2);
continue; continue;
} }
E2.Name = Saver.save(E1.Name); e2.name = saver.save(e1.Name);
E2.ExtName = Saver.save(E1.ExtName); e2.extName = saver.save(e1.ExtName);
E2.Ordinal = E1.Ordinal; e2.ordinal = e1.Ordinal;
E2.Noname = E1.Noname; e2.noname = e1.Noname;
E2.Data = E1.Data; e2.data = e1.Data;
E2.Private = E1.Private; e2.isPrivate = e1.Private;
E2.Constant = E1.Constant; e2.constant = e1.Constant;
Config->Exports.push_back(E2); config->exports.push_back(e2);
} }
} }
void LinkerDriver::enqueueTask(std::function<void()> Task) { void LinkerDriver::enqueueTask(std::function<void()> task) {
TaskQueue.push_back(std::move(Task)); taskQueue.push_back(std::move(task));
} }
bool LinkerDriver::run() { bool LinkerDriver::run() {
ScopedTimer T(InputFileTimer); ScopedTimer t(inputFileTimer);
bool DidWork = !TaskQueue.empty(); bool didWork = !taskQueue.empty();
while (!TaskQueue.empty()) { while (!taskQueue.empty()) {
TaskQueue.front()(); taskQueue.front()();
TaskQueue.pop_front(); taskQueue.pop_front();
} }
return DidWork; return didWork;
} }
// Parse an /order file. If an option is given, the linker places // Parse an /order file. If an option is given, the linker places
// COMDAT sections in the same order as their names appear in the // COMDAT sections in the same order as their names appear in the
// given file. // given file.
static void parseOrderFile(StringRef Arg) { static void parseOrderFile(StringRef arg) {
// For some reason, the MSVC linker requires a filename to be // For some reason, the MSVC linker requires a filename to be
// preceded by "@". // preceded by "@".
if (!Arg.startswith("@")) { if (!arg.startswith("@")) {
error("malformed /order option: '@' missing"); error("malformed /order option: '@' missing");
return; return;
} }
// Get a list of all comdat sections for error checking. // Get a list of all comdat sections for error checking.
DenseSet<StringRef> Set; DenseSet<StringRef> set;
for (Chunk *C : Symtab->getChunks()) for (Chunk *c : symtab->getChunks())
if (auto *Sec = dyn_cast<SectionChunk>(C)) if (auto *sec = dyn_cast<SectionChunk>(c))
if (Sec->Sym) if (sec->sym)
Set.insert(Sec->Sym->getName()); set.insert(sec->sym->getName());
// Open a file. // Open a file.
StringRef Path = Arg.substr(1); StringRef path = arg.substr(1);
std::unique_ptr<MemoryBuffer> MB = CHECK( std::unique_ptr<MemoryBuffer> mb = CHECK(
MemoryBuffer::getFile(Path, -1, false, true), "could not open " + Path); MemoryBuffer::getFile(path, -1, false, true), "could not open " + path);
// Parse a file. An order file contains one symbol per line. // Parse a file. An order file contains one symbol per line.
// All symbols that were not present in a given order file are // All symbols that were not present in a given order file are
// considered to have the lowest priority 0 and are placed at // considered to have the lowest priority 0 and are placed at
// end of an output section. // end of an output section.
for (std::string S : args::getLines(MB->getMemBufferRef())) { for (std::string s : args::getLines(mb->getMemBufferRef())) {
if (Config->Machine == I386 && !isDecorated(S)) if (config->machine == I386 && !isDecorated(s))
S = "_" + S; s = "_" + s;
if (Set.count(S) == 0) { if (set.count(s) == 0) {
if (Config->WarnMissingOrderSymbol) if (config->warnMissingOrderSymbol)
warn("/order:" + Arg + ": missing symbol: " + S + " [LNK4037]"); warn("/order:" + arg + ": missing symbol: " + s + " [LNK4037]");
} }
else else
Config->Order[S] = INT_MIN + Config->Order.size(); config->order[s] = INT_MIN + config->order.size();
} }
} }
static void markAddrsig(Symbol *S) { static void markAddrsig(Symbol *s) {
if (auto *D = dyn_cast_or_null<Defined>(S)) if (auto *d = dyn_cast_or_null<Defined>(s))
if (SectionChunk *C = dyn_cast_or_null<SectionChunk>(D->getChunk())) if (SectionChunk *c = dyn_cast_or_null<SectionChunk>(d->getChunk()))
C->KeepUnique = true; c->keepUnique = true;
} }
static void findKeepUniqueSections() { static void findKeepUniqueSections() {
// Exported symbols could be address-significant in other executables or DSOs, // Exported symbols could be address-significant in other executables or DSOs,
// so we conservatively mark them as address-significant. // so we conservatively mark them as address-significant.
for (Export &R : Config->Exports) for (Export &r : config->exports)
markAddrsig(R.Sym); markAddrsig(r.sym);
// Visit the address-significance table in each object file and mark each // Visit the address-significance table in each object file and mark each
// referenced symbol as address-significant. // referenced symbol as address-significant.
for (ObjFile *Obj : ObjFile::Instances) { for (ObjFile *obj : ObjFile::instances) {
ArrayRef<Symbol *> Syms = Obj->getSymbols(); ArrayRef<Symbol *> syms = obj->getSymbols();
if (Obj->AddrsigSec) { if (obj->addrsigSec) {
ArrayRef<uint8_t> Contents; ArrayRef<uint8_t> contents;
cantFail( cantFail(
Obj->getCOFFObj()->getSectionContents(Obj->AddrsigSec, Contents)); obj->getCOFFObj()->getSectionContents(obj->addrsigSec, contents));
const uint8_t *Cur = Contents.begin(); const uint8_t *cur = contents.begin();
while (Cur != Contents.end()) { while (cur != contents.end()) {
unsigned Size; unsigned size;
const char *Err; const char *err;
uint64_t SymIndex = decodeULEB128(Cur, &Size, Contents.end(), &Err); uint64_t symIndex = decodeULEB128(cur, &size, contents.end(), &err);
if (Err) if (err)
fatal(toString(Obj) + ": could not decode addrsig section: " + Err); fatal(toString(obj) + ": could not decode addrsig section: " + err);
if (SymIndex >= Syms.size()) if (symIndex >= syms.size())
fatal(toString(Obj) + ": invalid symbol index in addrsig section"); fatal(toString(obj) + ": invalid symbol index in addrsig section");
markAddrsig(Syms[SymIndex]); markAddrsig(syms[symIndex]);
Cur += Size; cur += size;
} }
} else { } else {
// If an object file does not have an address-significance table, // If an object file does not have an address-significance table,
// conservatively mark all of its symbols as address-significant. // conservatively mark all of its symbols as address-significant.
for (Symbol *S : Syms) for (Symbol *s : syms)
markAddrsig(S); markAddrsig(s);
} }
} }
} }
// link.exe replaces each %foo% in AltPath with the contents of environment // link.exe replaces each %foo% in AltPath with the contents of environment
// variable foo, and adds the two magic env vars _PDB (expands to the basename // variable foo, and adds the two magic env vars _PDB (expands to the basename
// of pdb's output path) and _EXT (expands to the extension of the output // of pdb's output path) and _EXT (expands to the extension of the output
// binary). // binary).
// lld only supports %_PDB% and %_EXT% and warns on references to all other env // lld only supports %_PDB% and %_EXT% and warns on references to all other env
// vars. // vars.
static void parsePDBAltPath(StringRef AltPath) { static void parsePDBAltPath(StringRef altPath) {
SmallString<128> Buf; SmallString<128> buf;
StringRef PDBBasename = StringRef pdbBasename =
sys::path::filename(Config->PDBPath, sys::path::Style::windows); sys::path::filename(config->pdbPath, sys::path::Style::windows);
StringRef BinaryExtension = StringRef binaryExtension =
sys::path::extension(Config->OutputFile, sys::path::Style::windows); sys::path::extension(config->outputFile, sys::path::Style::windows);
if (!BinaryExtension.empty()) if (!binaryExtension.empty())
BinaryExtension = BinaryExtension.substr(1); // %_EXT% does not include '.'. binaryExtension = binaryExtension.substr(1); // %_EXT% does not include '.'.
// Invariant: // Invariant:
// +--------- Cursor ('a...' might be the empty string). // +--------- Cursor ('a...' might be the empty string).
// | +----- FirstMark // | +----- FirstMark
// | | +- SecondMark // | | +- SecondMark
// v v v // v v v
// a...%...%... // a...%...%...
size_t Cursor = 0; size_t cursor = 0;
while (Cursor < AltPath.size()) { while (cursor < altPath.size()) {
size_t FirstMark, SecondMark; size_t firstMark, secondMark;
if ((FirstMark = AltPath.find('%', Cursor)) == StringRef::npos || if ((firstMark = altPath.find('%', cursor)) == StringRef::npos ||
(SecondMark = AltPath.find('%', FirstMark + 1)) == StringRef::npos) { (secondMark = altPath.find('%', firstMark + 1)) == StringRef::npos) {
// Didn't find another full fragment, treat rest of string as literal. // Didn't find another full fragment, treat rest of string as literal.
Buf.append(AltPath.substr(Cursor)); buf.append(altPath.substr(cursor));
break; break;
} }
// Found a full fragment. Append text in front of first %, and interpret // Found a full fragment. Append text in front of first %, and interpret
// text between first and second % as variable name. // text between first and second % as variable name.
Buf.append(AltPath.substr(Cursor, FirstMark - Cursor)); buf.append(altPath.substr(cursor, firstMark - cursor));
StringRef Var = AltPath.substr(FirstMark, SecondMark - FirstMark + 1); StringRef var = altPath.substr(firstMark, secondMark - firstMark + 1);
if (Var.equals_lower("%_pdb%")) if (var.equals_lower("%_pdb%"))
Buf.append(PDBBasename); buf.append(pdbBasename);
else if (Var.equals_lower("%_ext%")) else if (var.equals_lower("%_ext%"))
Buf.append(BinaryExtension); buf.append(binaryExtension);
else { else {
warn("only %_PDB% and %_EXT% supported in /pdbaltpath:, keeping " + warn("only %_PDB% and %_EXT% supported in /pdbaltpath:, keeping " +
Var + " as literal"); var + " as literal");
Buf.append(Var); buf.append(var);
} }
Cursor = SecondMark + 1; cursor = secondMark + 1;
} }
Config->PDBAltPath = Buf; config->pdbAltPath = buf;
} }
/// Check that at most one resource obj file was used. /// Check that at most one resource obj file was used.
/// Call after ObjFile::Instances is complete. /// Call after ObjFile::Instances is complete.
static void diagnoseMultipleResourceObjFiles() { static void diagnoseMultipleResourceObjFiles() {
// The .rsrc$01 section in a resource obj file contains a tree description // The .rsrc$01 section in a resource obj file contains a tree description
// of resources. Merging multiple resource obj files would require merging // of resources. Merging multiple resource obj files would require merging
// the trees instead of using usual linker section merging semantics. // the trees instead of using usual linker section merging semantics.
// Since link.exe disallows linking more than one resource obj file with // Since link.exe disallows linking more than one resource obj file with
// LNK4078, mirror that. The normal use of resource files is to give the // LNK4078, mirror that. The normal use of resource files is to give the
// linker many .res files, which are then converted to a single resource obj // linker many .res files, which are then converted to a single resource obj
// file internally, so this is not a big restriction in practice. // file internally, so this is not a big restriction in practice.
ObjFile *ResourceObjFile = nullptr; ObjFile *resourceObjFile = nullptr;
for (ObjFile *F : ObjFile::Instances) { for (ObjFile *f : ObjFile::instances) {
if (!F->IsResourceObjFile) if (!f->isResourceObjFile)
continue; continue;
if (!ResourceObjFile) { if (!resourceObjFile) {
ResourceObjFile = F; resourceObjFile = f;
continue; continue;
} }
error(toString(F) + error(toString(f) +
": more than one resource obj file not allowed, already got " + ": more than one resource obj file not allowed, already got " +
toString(ResourceObjFile)); toString(resourceObjFile));
} }
} }
// In MinGW, if no symbols are chosen to be exported, then all symbols are // In MinGW, if no symbols are chosen to be exported, then all symbols are
// automatically exported by default. This behavior can be forced by the // automatically exported by default. This behavior can be forced by the
// -export-all-symbols option, so that it happens even when exports are // -export-all-symbols option, so that it happens even when exports are
// explicitly specified. The automatic behavior can be disabled using the // explicitly specified. The automatic behavior can be disabled using the
// -exclude-all-symbols option, so that lld-link behaves like link.exe rather // -exclude-all-symbols option, so that lld-link behaves like link.exe rather
// than MinGW in the case that nothing is explicitly exported. // than MinGW in the case that nothing is explicitly exported.
void LinkerDriver::maybeExportMinGWSymbols(const opt::InputArgList &Args) { void LinkerDriver::maybeExportMinGWSymbols(const opt::InputArgList &args) {
if (!Config->DLL) if (!config->dll)
return; return;
if (!Args.hasArg(OPT_export_all_symbols)) { if (!args.hasArg(OPT_export_all_symbols)) {
if (!Config->Exports.empty()) if (!config->exports.empty())
return; return;
if (Args.hasArg(OPT_exclude_all_symbols)) if (args.hasArg(OPT_exclude_all_symbols))
return; return;
} }
AutoExporter Exporter; AutoExporter exporter;
for (auto *Arg : Args.filtered(OPT_wholearchive_file)) for (auto *arg : args.filtered(OPT_wholearchive_file))
if (Optional<StringRef> Path = doFindFile(Arg->getValue())) if (Optional<StringRef> path = doFindFile(arg->getValue()))
Exporter.addWholeArchive(*Path); exporter.addWholeArchive(*path);
Symtab->forEachSymbol([&](Symbol *S) { symtab->forEachSymbol([&](Symbol *s) {
auto *Def = dyn_cast<Defined>(S); auto *def = dyn_cast<Defined>(s);
if (!Exporter.shouldExport(Def)) if (!exporter.shouldExport(def))
return; return;
Export E; Export e;
E.Name = Def->getName(); e.name = def->getName();
E.Sym = Def; e.sym = def;
if (Chunk *C = Def->getChunk()) if (Chunk *c = def->getChunk())
if (!(C->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE)) if (!(c->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE))
E.Data = true; e.data = true;
Config->Exports.push_back(E); config->exports.push_back(e);
}); });
} }
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) { void LinkerDriver::link(ArrayRef<const char *> argsArr) {
// Needed for LTO. // Needed for LTO.
InitializeAllTargetInfos(); InitializeAllTargetInfos();
InitializeAllTargets(); InitializeAllTargets();
InitializeAllTargetMCs(); InitializeAllTargetMCs();
InitializeAllAsmParsers(); InitializeAllAsmParsers();
InitializeAllAsmPrinters(); InitializeAllAsmPrinters();
// If the first command line argument is "/lib", link.exe acts like lib.exe. // If the first command line argument is "/lib", link.exe acts like lib.exe.
// We call our own implementation of lib.exe that understands bitcode files. // We call our own implementation of lib.exe that understands bitcode files.
if (ArgsArr.size() > 1 && StringRef(ArgsArr[1]).equals_lower("/lib")) { if (argsArr.size() > 1 && StringRef(argsArr[1]).equals_lower("/lib")) {
if (llvm::libDriverMain(ArgsArr.slice(1)) != 0) if (llvm::libDriverMain(argsArr.slice(1)) != 0)
fatal("lib failed"); fatal("lib failed");
return; return;
} }
// Parse command line options. // Parse command line options.
ArgParser Parser; ArgParser parser;
opt::InputArgList Args = Parser.parseLINK(ArgsArr); opt::InputArgList args = parser.parseLINK(argsArr);
// Parse and evaluate -mllvm options. // Parse and evaluate -mllvm options.
std::vector<const char *> V; std::vector<const char *> v;
V.push_back("lld-link (LLVM option parsing)"); v.push_back("lld-link (LLVM option parsing)");
for (auto *Arg : Args.filtered(OPT_mllvm)) for (auto *arg : args.filtered(OPT_mllvm))
V.push_back(Arg->getValue()); v.push_back(arg->getValue());
cl::ParseCommandLineOptions(V.size(), V.data()); cl::ParseCommandLineOptions(v.size(), v.data());
// Handle /errorlimit early, because error() depends on it. // Handle /errorlimit early, because error() depends on it.
if (auto *Arg = Args.getLastArg(OPT_errorlimit)) { if (auto *arg = args.getLastArg(OPT_errorlimit)) {
int N = 20; int n = 20;
StringRef S = Arg->getValue(); StringRef s = arg->getValue();
if (S.getAsInteger(10, N)) if (s.getAsInteger(10, n))
error(Arg->getSpelling() + " number expected, but got " + S); error(arg->getSpelling() + " number expected, but got " + s);
errorHandler().ErrorLimit = N; errorHandler().errorLimit = n;
} }
// Handle /help // Handle /help
if (Args.hasArg(OPT_help)) { if (args.hasArg(OPT_help)) {
printHelp(ArgsArr[0]); printHelp(argsArr[0]);
return; return;
} }
lld::ThreadsEnabled = Args.hasFlag(OPT_threads, OPT_threads_no, true); lld::threadsEnabled = args.hasFlag(OPT_threads, OPT_threads_no, true);
if (Args.hasArg(OPT_show_timing)) if (args.hasArg(OPT_show_timing))
Config->ShowTiming = true; config->showTiming = true;
Config->ShowSummary = Args.hasArg(OPT_summary); config->showSummary = args.hasArg(OPT_summary);
ScopedTimer T(Timer::root()); ScopedTimer t(Timer::root());
// Handle --version, which is an lld extension. This option is a bit odd // Handle --version, which is an lld extension. This option is a bit odd
// because it doesn't start with "/", but we deliberately chose "--" to // because it doesn't start with "/", but we deliberately chose "--" to
// avoid conflict with /version and for compatibility with clang-cl. // avoid conflict with /version and for compatibility with clang-cl.
if (Args.hasArg(OPT_dash_dash_version)) { if (args.hasArg(OPT_dash_dash_version)) {
outs() << getLLDVersion() << "\n"; outs() << getLLDVersion() << "\n";
return; return;
} }
// Handle /lldmingw early, since it can potentially affect how other // Handle /lldmingw early, since it can potentially affect how other
// options are handled. // options are handled.
Config->MinGW = Args.hasArg(OPT_lldmingw); config->mingw = args.hasArg(OPT_lldmingw);
if (auto *Arg = Args.getLastArg(OPT_linkrepro)) { if (auto *arg = args.getLastArg(OPT_linkrepro)) {
SmallString<64> Path = StringRef(Arg->getValue()); SmallString<64> path = StringRef(arg->getValue());
sys::path::append(Path, "repro.tar"); sys::path::append(path, "repro.tar");
Expected<std::unique_ptr<TarWriter>> ErrOrWriter = Expected<std::unique_ptr<TarWriter>> errOrWriter =
TarWriter::create(Path, "repro"); TarWriter::create(path, "repro");
if (ErrOrWriter) { if (errOrWriter) {
Tar = std::move(*ErrOrWriter); tar = std::move(*errOrWriter);
} else { } else {
error("/linkrepro: failed to open " + Path + ": " + error("/linkrepro: failed to open " + path + ": " +
toString(ErrOrWriter.takeError())); toString(errOrWriter.takeError()));
} }
} }
if (!Args.hasArg(OPT_INPUT)) { if (!args.hasArg(OPT_INPUT)) {
if (Args.hasArg(OPT_deffile)) if (args.hasArg(OPT_deffile))
Config->NoEntry = true; config->noEntry = true;
else else
fatal("no input files"); fatal("no input files");
} }
// Construct search path list. // Construct search path list.
SearchPaths.push_back(""); searchPaths.push_back("");
for (auto *Arg : Args.filtered(OPT_libpath)) for (auto *arg : args.filtered(OPT_libpath))
SearchPaths.push_back(Arg->getValue()); searchPaths.push_back(arg->getValue());
addLibSearchPaths(); addLibSearchPaths();
// Handle /ignore // Handle /ignore
for (auto *Arg : Args.filtered(OPT_ignore)) { for (auto *arg : args.filtered(OPT_ignore)) {
SmallVector<StringRef, 8> Vec; SmallVector<StringRef, 8> vec;
StringRef(Arg->getValue()).split(Vec, ','); StringRef(arg->getValue()).split(vec, ',');
for (StringRef S : Vec) { for (StringRef s : vec) {
if (S == "4037") if (s == "4037")
Config->WarnMissingOrderSymbol = false; config->warnMissingOrderSymbol = false;
else if (S == "4099") else if (s == "4099")
Config->WarnDebugInfoUnusable = false; config->warnDebugInfoUnusable = false;
else if (S == "4217") else if (s == "4217")
Config->WarnLocallyDefinedImported = false; config->warnLocallyDefinedImported = false;
// Other warning numbers are ignored. // Other warning numbers are ignored.
} }
} }
// Handle /out // Handle /out
if (auto *Arg = Args.getLastArg(OPT_out)) if (auto *arg = args.getLastArg(OPT_out))
Config->OutputFile = Arg->getValue(); config->outputFile = arg->getValue();
// Handle /verbose // Handle /verbose
if (Args.hasArg(OPT_verbose)) if (args.hasArg(OPT_verbose))
Config->Verbose = true; config->verbose = true;
errorHandler().Verbose = Config->Verbose; errorHandler().verbose = config->verbose;
// Handle /force or /force:unresolved // Handle /force or /force:unresolved
if (Args.hasArg(OPT_force, OPT_force_unresolved)) if (args.hasArg(OPT_force, OPT_force_unresolved))
Config->ForceUnresolved = true; config->forceUnresolved = true;
// Handle /force or /force:multiple // Handle /force or /force:multiple
if (Args.hasArg(OPT_force, OPT_force_multiple)) if (args.hasArg(OPT_force, OPT_force_multiple))
Config->ForceMultiple = true; config->forceMultiple = true;
// Handle /force or /force:multipleres // Handle /force or /force:multipleres
if (Args.hasArg(OPT_force, OPT_force_multipleres)) if (args.hasArg(OPT_force, OPT_force_multipleres))
Config->ForceMultipleRes = true; config->forceMultipleRes = true;
// Handle /debug // Handle /debug
DebugKind Debug = parseDebugKind(Args); DebugKind debug = parseDebugKind(args);
if (Debug == DebugKind::Full || Debug == DebugKind::Dwarf || if (debug == DebugKind::Full || debug == DebugKind::Dwarf ||
Debug == DebugKind::GHash) { debug == DebugKind::GHash) {
Config->Debug = true; config->debug = true;
Config->Incremental = true; config->incremental = true;
} }
// Handle /demangle // Handle /demangle
Config->Demangle = Args.hasFlag(OPT_demangle, OPT_demangle_no); config->demangle = args.hasFlag(OPT_demangle, OPT_demangle_no);
// Handle /debugtype // Handle /debugtype
Config->DebugTypes = parseDebugTypes(Args); config->debugTypes = parseDebugTypes(args);
// Handle /pdb // Handle /pdb
bool ShouldCreatePDB = bool shouldCreatePDB =
(Debug == DebugKind::Full || Debug == DebugKind::GHash); (debug == DebugKind::Full || debug == DebugKind::GHash);
if (ShouldCreatePDB) { if (shouldCreatePDB) {
if (auto *Arg = Args.getLastArg(OPT_pdb)) if (auto *arg = args.getLastArg(OPT_pdb))
Config->PDBPath = Arg->getValue(); config->pdbPath = arg->getValue();
if (auto *Arg = Args.getLastArg(OPT_pdbaltpath)) if (auto *arg = args.getLastArg(OPT_pdbaltpath))
Config->PDBAltPath = Arg->getValue(); config->pdbAltPath = arg->getValue();
if (Args.hasArg(OPT_natvis)) if (args.hasArg(OPT_natvis))
Config->NatvisFiles = Args.getAllArgValues(OPT_natvis); config->natvisFiles = args.getAllArgValues(OPT_natvis);
if (auto *Arg = Args.getLastArg(OPT_pdb_source_path)) if (auto *arg = args.getLastArg(OPT_pdb_source_path))
Config->PDBSourcePath = Arg->getValue(); config->pdbSourcePath = arg->getValue();
} }
// Handle /noentry // Handle /noentry
if (Args.hasArg(OPT_noentry)) { if (args.hasArg(OPT_noentry)) {
if (Args.hasArg(OPT_dll)) if (args.hasArg(OPT_dll))
Config->NoEntry = true; config->noEntry = true;
else else
error("/noentry must be specified with /dll"); error("/noentry must be specified with /dll");
} }
// Handle /dll // Handle /dll
if (Args.hasArg(OPT_dll)) { if (args.hasArg(OPT_dll)) {
Config->DLL = true; config->dll = true;
Config->ManifestID = 2; config->manifestID = 2;
} }
// Handle /dynamicbase and /fixed. We can't use hasFlag for /dynamicbase // Handle /dynamicbase and /fixed. We can't use hasFlag for /dynamicbase
// because we need to explicitly check whether that option or its inverse was // because we need to explicitly check whether that option or its inverse was
// present in the argument list in order to handle /fixed. // present in the argument list in order to handle /fixed.
auto *DynamicBaseArg = Args.getLastArg(OPT_dynamicbase, OPT_dynamicbase_no); auto *dynamicBaseArg = args.getLastArg(OPT_dynamicbase, OPT_dynamicbase_no);
if (DynamicBaseArg && if (dynamicBaseArg &&
DynamicBaseArg->getOption().getID() == OPT_dynamicbase_no) dynamicBaseArg->getOption().getID() == OPT_dynamicbase_no)
Config->DynamicBase = false; config->dynamicBase = false;
// MSDN claims "/FIXED:NO is the default setting for a DLL, and /FIXED is the // MSDN claims "/FIXED:NO is the default setting for a DLL, and /FIXED is the
// default setting for any other project type.", but link.exe defaults to // default setting for any other project type.", but link.exe defaults to
// /FIXED:NO for exe outputs as well. Match behavior, not docs. // /FIXED:NO for exe outputs as well. Match behavior, not docs.
bool Fixed = Args.hasFlag(OPT_fixed, OPT_fixed_no, false); bool fixed = args.hasFlag(OPT_fixed, OPT_fixed_no, false);
if (Fixed) { if (fixed) {
if (DynamicBaseArg && if (dynamicBaseArg &&
DynamicBaseArg->getOption().getID() == OPT_dynamicbase) { dynamicBaseArg->getOption().getID() == OPT_dynamicbase) {
error("/fixed must not be specified with /dynamicbase"); error("/fixed must not be specified with /dynamicbase");
} else { } else {
Config->Relocatable = false; config->relocatable = false;
Config->DynamicBase = false; config->dynamicBase = false;
} }
} }
// Handle /appcontainer // Handle /appcontainer
Config->AppContainer = config->appContainer =
Args.hasFlag(OPT_appcontainer, OPT_appcontainer_no, false); args.hasFlag(OPT_appcontainer, OPT_appcontainer_no, false);
// Handle /machine // Handle /machine
if (auto *Arg = Args.getLastArg(OPT_machine)) { if (auto *arg = args.getLastArg(OPT_machine)) {
Config->Machine = getMachineType(Arg->getValue()); config->machine = getMachineType(arg->getValue());
if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) if (config->machine == IMAGE_FILE_MACHINE_UNKNOWN)
fatal(Twine("unknown /machine argument: ") + Arg->getValue()); fatal(Twine("unknown /machine argument: ") + arg->getValue());
} }
// Handle /nodefaultlib:<filename> // Handle /nodefaultlib:<filename>
for (auto *Arg : Args.filtered(OPT_nodefaultlib)) for (auto *arg : args.filtered(OPT_nodefaultlib))
Config->NoDefaultLibs.insert(doFindLib(Arg->getValue()).lower()); config->noDefaultLibs.insert(doFindLib(arg->getValue()).lower());
// Handle /nodefaultlib // Handle /nodefaultlib
if (Args.hasArg(OPT_nodefaultlib_all)) if (args.hasArg(OPT_nodefaultlib_all))
Config->NoDefaultLibAll = true; config->noDefaultLibAll = true;
// Handle /base // Handle /base
if (auto *Arg = Args.getLastArg(OPT_base)) if (auto *arg = args.getLastArg(OPT_base))
parseNumbers(Arg->getValue(), &Config->ImageBase); parseNumbers(arg->getValue(), &config->imageBase);
// Handle /filealign // Handle /filealign
if (auto *Arg = Args.getLastArg(OPT_filealign)) { if (auto *arg = args.getLastArg(OPT_filealign)) {
parseNumbers(Arg->getValue(), &Config->FileAlign); parseNumbers(arg->getValue(), &config->fileAlign);
if (!isPowerOf2_64(Config->FileAlign)) if (!isPowerOf2_64(config->fileAlign))
error("/filealign: not a power of two: " + Twine(Config->FileAlign)); error("/filealign: not a power of two: " + Twine(config->fileAlign));
} }
// Handle /stack // Handle /stack
if (auto *Arg = Args.getLastArg(OPT_stack)) if (auto *arg = args.getLastArg(OPT_stack))
parseNumbers(Arg->getValue(), &Config->StackReserve, &Config->StackCommit); parseNumbers(arg->getValue(), &config->stackReserve, &config->stackCommit);
// Handle /guard:cf // Handle /guard:cf
if (auto *Arg = Args.getLastArg(OPT_guard)) if (auto *arg = args.getLastArg(OPT_guard))
parseGuard(Arg->getValue()); parseGuard(arg->getValue());
// Handle /heap // Handle /heap
if (auto *Arg = Args.getLastArg(OPT_heap)) if (auto *arg = args.getLastArg(OPT_heap))
parseNumbers(Arg->getValue(), &Config->HeapReserve, &Config->HeapCommit); parseNumbers(arg->getValue(), &config->heapReserve, &config->heapCommit);
// Handle /version // Handle /version
if (auto *Arg = Args.getLastArg(OPT_version)) if (auto *arg = args.getLastArg(OPT_version))
parseVersion(Arg->getValue(), &Config->MajorImageVersion, parseVersion(arg->getValue(), &config->majorImageVersion,
&Config->MinorImageVersion); &config->minorImageVersion);
// Handle /subsystem // Handle /subsystem
if (auto *Arg = Args.getLastArg(OPT_subsystem)) if (auto *arg = args.getLastArg(OPT_subsystem))
parseSubsystem(Arg->getValue(), &Config->Subsystem, &Config->MajorOSVersion, parseSubsystem(arg->getValue(), &config->subsystem, &config->majorOSVersion,
&Config->MinorOSVersion); &config->minorOSVersion);
// Handle /timestamp // Handle /timestamp
if (llvm::opt::Arg *Arg = Args.getLastArg(OPT_timestamp, OPT_repro)) { if (llvm::opt::Arg *arg = args.getLastArg(OPT_timestamp, OPT_repro)) {
if (Arg->getOption().getID() == OPT_repro) { if (arg->getOption().getID() == OPT_repro) {
Config->Timestamp = 0; config->timestamp = 0;
Config->Repro = true; config->repro = true;
} else { } else {
Config->Repro = false; config->repro = false;
StringRef Value(Arg->getValue()); StringRef value(arg->getValue());
if (Value.getAsInteger(0, Config->Timestamp)) if (value.getAsInteger(0, config->timestamp))
fatal(Twine("invalid timestamp: ") + Value + fatal(Twine("invalid timestamp: ") + value +
". Expected 32-bit integer"); ". Expected 32-bit integer");
} }
} else { } else {
Config->Repro = false; config->repro = false;
Config->Timestamp = time(nullptr); config->timestamp = time(nullptr);
} }
// Handle /alternatename // Handle /alternatename
for (auto *Arg : Args.filtered(OPT_alternatename)) for (auto *arg : args.filtered(OPT_alternatename))
parseAlternateName(Arg->getValue()); parseAlternateName(arg->getValue());
// Handle /include // Handle /include
for (auto *Arg : Args.filtered(OPT_incl)) for (auto *arg : args.filtered(OPT_incl))
addUndefined(Arg->getValue()); addUndefined(arg->getValue());
// Handle /implib // Handle /implib
if (auto *Arg = Args.getLastArg(OPT_implib)) if (auto *arg = args.getLastArg(OPT_implib))
Config->Implib = Arg->getValue(); config->implib = arg->getValue();
// Handle /opt. // Handle /opt.
bool DoGC = Debug == DebugKind::None || Args.hasArg(OPT_profile); bool doGC = debug == DebugKind::None || args.hasArg(OPT_profile);
unsigned ICFLevel = unsigned icfLevel =
Args.hasArg(OPT_profile) ? 0 : 1; // 0: off, 1: limited, 2: on args.hasArg(OPT_profile) ? 0 : 1; // 0: off, 1: limited, 2: on
unsigned TailMerge = 1; unsigned tailMerge = 1;
for (auto *Arg : Args.filtered(OPT_opt)) { for (auto *arg : args.filtered(OPT_opt)) {
std::string Str = StringRef(Arg->getValue()).lower(); std::string str = StringRef(arg->getValue()).lower();
SmallVector<StringRef, 1> Vec; SmallVector<StringRef, 1> vec;
StringRef(Str).split(Vec, ','); StringRef(str).split(vec, ',');
for (StringRef S : Vec) { for (StringRef s : vec) {
if (S == "ref") { if (s == "ref") {
DoGC = true; doGC = true;
} else if (S == "noref") { } else if (s == "noref") {
DoGC = false; doGC = false;
} else if (S == "icf" || S.startswith("icf=")) { } else if (s == "icf" || s.startswith("icf=")) {
ICFLevel = 2; icfLevel = 2;
} else if (S == "noicf") { } else if (s == "noicf") {
ICFLevel = 0; icfLevel = 0;
} else if (S == "lldtailmerge") { } else if (s == "lldtailmerge") {
TailMerge = 2; tailMerge = 2;
} else if (S == "nolldtailmerge") { } else if (s == "nolldtailmerge") {
TailMerge = 0; tailMerge = 0;
} else if (S.startswith("lldlto=")) { } else if (s.startswith("lldlto=")) {
StringRef OptLevel = S.substr(7); StringRef optLevel = s.substr(7);
if (OptLevel.getAsInteger(10, Config->LTOO) || Config->LTOO > 3) if (optLevel.getAsInteger(10, config->ltoo) || config->ltoo > 3)
error("/opt:lldlto: invalid optimization level: " + OptLevel); error("/opt:lldlto: invalid optimization level: " + optLevel);
} else if (S.startswith("lldltojobs=")) { } else if (s.startswith("lldltojobs=")) {
StringRef Jobs = S.substr(11); StringRef jobs = s.substr(11);
if (Jobs.getAsInteger(10, Config->ThinLTOJobs) || if (jobs.getAsInteger(10, config->thinLTOJobs) ||
Config->ThinLTOJobs == 0) config->thinLTOJobs == 0)
error("/opt:lldltojobs: invalid job count: " + Jobs); error("/opt:lldltojobs: invalid job count: " + jobs);
} else if (S.startswith("lldltopartitions=")) { } else if (s.startswith("lldltopartitions=")) {
StringRef N = S.substr(17); StringRef n = s.substr(17);
if (N.getAsInteger(10, Config->LTOPartitions) || if (n.getAsInteger(10, config->ltoPartitions) ||
Config->LTOPartitions == 0) config->ltoPartitions == 0)
error("/opt:lldltopartitions: invalid partition count: " + N); error("/opt:lldltopartitions: invalid partition count: " + n);
} else if (S != "lbr" && S != "nolbr") } else if (s != "lbr" && s != "nolbr")
error("/opt: unknown option: " + S); error("/opt: unknown option: " + s);
} }
} }
// Limited ICF is enabled if GC is enabled and ICF was never mentioned // Limited ICF is enabled if GC is enabled and ICF was never mentioned
// explicitly. // explicitly.
// FIXME: LLD only implements "limited" ICF, i.e. it only merges identical // FIXME: LLD only implements "limited" ICF, i.e. it only merges identical
// code. If the user passes /OPT:ICF explicitly, LLD should merge identical // code. If the user passes /OPT:ICF explicitly, LLD should merge identical
// comdat readonly data. // comdat readonly data.
if (ICFLevel == 1 && !DoGC) if (icfLevel == 1 && !doGC)
ICFLevel = 0; icfLevel = 0;
Config->DoGC = DoGC; config->doGC = doGC;
Config->DoICF = ICFLevel > 0; config->doICF = icfLevel > 0;
Config->TailMerge = (TailMerge == 1 && Config->DoICF) || TailMerge == 2; config->tailMerge = (tailMerge == 1 && config->doICF) || tailMerge == 2;
// Handle /lldsavetemps // Handle /lldsavetemps
if (Args.hasArg(OPT_lldsavetemps)) if (args.hasArg(OPT_lldsavetemps))
Config->SaveTemps = true; config->saveTemps = true;
// Handle /kill-at // Handle /kill-at
if (Args.hasArg(OPT_kill_at)) if (args.hasArg(OPT_kill_at))
Config->KillAt = true; config->killAt = true;
// Handle /lldltocache // Handle /lldltocache
if (auto *Arg = Args.getLastArg(OPT_lldltocache)) if (auto *arg = args.getLastArg(OPT_lldltocache))
Config->LTOCache = Arg->getValue(); config->ltoCache = arg->getValue();
// Handle /lldsavecachepolicy // Handle /lldsavecachepolicy
if (auto *Arg = Args.getLastArg(OPT_lldltocachepolicy)) if (auto *arg = args.getLastArg(OPT_lldltocachepolicy))
Config->LTOCachePolicy = CHECK( config->ltoCachePolicy = CHECK(
parseCachePruningPolicy(Arg->getValue()), parseCachePruningPolicy(arg->getValue()),
Twine("/lldltocachepolicy: invalid cache policy: ") + Arg->getValue()); Twine("/lldltocachepolicy: invalid cache policy: ") + arg->getValue());
// Handle /failifmismatch // Handle /failifmismatch
for (auto *Arg : Args.filtered(OPT_failifmismatch)) for (auto *arg : args.filtered(OPT_failifmismatch))
checkFailIfMismatch(Arg->getValue(), nullptr); checkFailIfMismatch(arg->getValue(), nullptr);
// Handle /merge // Handle /merge
for (auto *Arg : Args.filtered(OPT_merge)) for (auto *arg : args.filtered(OPT_merge))
parseMerge(Arg->getValue()); parseMerge(arg->getValue());
// Add default section merging rules after user rules. User rules take // Add default section merging rules after user rules. User rules take
// precedence, but we will emit a warning if there is a conflict. // precedence, but we will emit a warning if there is a conflict.
parseMerge(".idata=.rdata"); parseMerge(".idata=.rdata");
parseMerge(".didat=.rdata"); parseMerge(".didat=.rdata");
parseMerge(".edata=.rdata"); parseMerge(".edata=.rdata");
parseMerge(".xdata=.rdata"); parseMerge(".xdata=.rdata");
parseMerge(".bss=.data"); parseMerge(".bss=.data");
if (Config->MinGW) { if (config->mingw) {
parseMerge(".ctors=.rdata"); parseMerge(".ctors=.rdata");
parseMerge(".dtors=.rdata"); parseMerge(".dtors=.rdata");
parseMerge(".CRT=.rdata"); parseMerge(".CRT=.rdata");
} }
// Handle /section // Handle /section
for (auto *Arg : Args.filtered(OPT_section)) for (auto *arg : args.filtered(OPT_section))
parseSection(Arg->getValue()); parseSection(arg->getValue());
// Handle /aligncomm // Handle /aligncomm
for (auto *Arg : Args.filtered(OPT_aligncomm)) for (auto *arg : args.filtered(OPT_aligncomm))
parseAligncomm(Arg->getValue()); parseAligncomm(arg->getValue());
// Handle /manifestdependency. This enables /manifest unless /manifest:no is // Handle /manifestdependency. This enables /manifest unless /manifest:no is
// also passed. // also passed.
if (auto *Arg = Args.getLastArg(OPT_manifestdependency)) { if (auto *arg = args.getLastArg(OPT_manifestdependency)) {
Config->ManifestDependency = Arg->getValue(); config->manifestDependency = arg->getValue();
Config->Manifest = Configuration::SideBySide; config->manifest = Configuration::SideBySide;
} }
// Handle /manifest and /manifest: // Handle /manifest and /manifest:
if (auto *Arg = Args.getLastArg(OPT_manifest, OPT_manifest_colon)) { if (auto *arg = args.getLastArg(OPT_manifest, OPT_manifest_colon)) {
if (Arg->getOption().getID() == OPT_manifest) if (arg->getOption().getID() == OPT_manifest)
Config->Manifest = Configuration::SideBySide; config->manifest = Configuration::SideBySide;
else else
parseManifest(Arg->getValue()); parseManifest(arg->getValue());
} }
// Handle /manifestuac // Handle /manifestuac
if (auto *Arg = Args.getLastArg(OPT_manifestuac)) if (auto *arg = args.getLastArg(OPT_manifestuac))
parseManifestUAC(Arg->getValue()); parseManifestUAC(arg->getValue());
// Handle /manifestfile // Handle /manifestfile
if (auto *Arg = Args.getLastArg(OPT_manifestfile)) if (auto *arg = args.getLastArg(OPT_manifestfile))
Config->ManifestFile = Arg->getValue(); config->manifestFile = arg->getValue();
// Handle /manifestinput // Handle /manifestinput
for (auto *Arg : Args.filtered(OPT_manifestinput)) for (auto *arg : args.filtered(OPT_manifestinput))
Config->ManifestInput.push_back(Arg->getValue()); config->manifestInput.push_back(arg->getValue());
if (!Config->ManifestInput.empty() && if (!config->manifestInput.empty() &&
Config->Manifest != Configuration::Embed) { config->manifest != Configuration::Embed) {
fatal("/manifestinput: requires /manifest:embed"); fatal("/manifestinput: requires /manifest:embed");
} }
// Handle miscellaneous boolean flags. // Handle miscellaneous boolean flags.
Config->AllowBind = Args.hasFlag(OPT_allowbind, OPT_allowbind_no, true); config->allowBind = args.hasFlag(OPT_allowbind, OPT_allowbind_no, true);
Config->AllowIsolation = config->allowIsolation =
Args.hasFlag(OPT_allowisolation, OPT_allowisolation_no, true); args.hasFlag(OPT_allowisolation, OPT_allowisolation_no, true);
Config->Incremental = config->incremental =
Args.hasFlag(OPT_incremental, OPT_incremental_no, args.hasFlag(OPT_incremental, OPT_incremental_no,
!Config->DoGC && !Config->DoICF && !Args.hasArg(OPT_order) && !config->doGC && !config->doICF && !args.hasArg(OPT_order) &&
!Args.hasArg(OPT_profile)); !args.hasArg(OPT_profile));
Config->IntegrityCheck = config->integrityCheck =
Args.hasFlag(OPT_integritycheck, OPT_integritycheck_no, false); args.hasFlag(OPT_integritycheck, OPT_integritycheck_no, false);
Config->NxCompat = Args.hasFlag(OPT_nxcompat, OPT_nxcompat_no, true); config->nxCompat = args.hasFlag(OPT_nxcompat, OPT_nxcompat_no, true);
for (auto *Arg : Args.filtered(OPT_swaprun)) for (auto *arg : args.filtered(OPT_swaprun))
parseSwaprun(Arg->getValue()); parseSwaprun(arg->getValue());
Config->TerminalServerAware = config->terminalServerAware =
!Config->DLL && Args.hasFlag(OPT_tsaware, OPT_tsaware_no, true); !config->dll && args.hasFlag(OPT_tsaware, OPT_tsaware_no, true);
Config->DebugDwarf = Debug == DebugKind::Dwarf; config->debugDwarf = debug == DebugKind::Dwarf;
Config->DebugGHashes = Debug == DebugKind::GHash; config->debugGHashes = debug == DebugKind::GHash;
Config->DebugSymtab = Debug == DebugKind::Symtab; config->debugSymtab = debug == DebugKind::Symtab;
Config->MapFile = getMapFile(Args); config->mapFile = getMapFile(args);
if (Config->Incremental && Args.hasArg(OPT_profile)) { if (config->incremental && args.hasArg(OPT_profile)) {
warn("ignoring '/incremental' due to '/profile' specification"); warn("ignoring '/incremental' due to '/profile' specification");
Config->Incremental = false; config->incremental = false;
} }
if (Config->Incremental && Args.hasArg(OPT_order)) { if (config->incremental && args.hasArg(OPT_order)) {
warn("ignoring '/incremental' due to '/order' specification"); warn("ignoring '/incremental' due to '/order' specification");
Config->Incremental = false; config->incremental = false;
} }
if (Config->Incremental && Config->DoGC) { if (config->incremental && config->doGC) {
warn("ignoring '/incremental' because REF is enabled; use '/opt:noref' to " warn("ignoring '/incremental' because REF is enabled; use '/opt:noref' to "
"disable"); "disable");
Config->Incremental = false; config->incremental = false;
} }
if (Config->Incremental && Config->DoICF) { if (config->incremental && config->doICF) {
warn("ignoring '/incremental' because ICF is enabled; use '/opt:noicf' to " warn("ignoring '/incremental' because ICF is enabled; use '/opt:noicf' to "
"disable"); "disable");
Config->Incremental = false; config->incremental = false;
} }
if (errorCount()) if (errorCount())
return; return;
std::set<sys::fs::UniqueID> WholeArchives; std::set<sys::fs::UniqueID> wholeArchives;
for (auto *Arg : Args.filtered(OPT_wholearchive_file)) for (auto *arg : args.filtered(OPT_wholearchive_file))
if (Optional<StringRef> Path = doFindFile(Arg->getValue())) if (Optional<StringRef> path = doFindFile(arg->getValue()))
if (Optional<sys::fs::UniqueID> ID = getUniqueID(*Path)) if (Optional<sys::fs::UniqueID> id = getUniqueID(*path))
WholeArchives.insert(*ID); wholeArchives.insert(*id);
// A predicate returning true if a given path is an argument for // A predicate returning true if a given path is an argument for
// /wholearchive:, or /wholearchive is enabled globally. // /wholearchive:, or /wholearchive is enabled globally.
// This function is a bit tricky because "foo.obj /wholearchive:././foo.obj" // This function is a bit tricky because "foo.obj /wholearchive:././foo.obj"
// needs to be handled as "/wholearchive:foo.obj foo.obj". // needs to be handled as "/wholearchive:foo.obj foo.obj".
auto IsWholeArchive = [&](StringRef Path) -> bool { auto isWholeArchive = [&](StringRef path) -> bool {
if (Args.hasArg(OPT_wholearchive_flag)) if (args.hasArg(OPT_wholearchive_flag))
return true; return true;
if (Optional<sys::fs::UniqueID> ID = getUniqueID(Path)) if (Optional<sys::fs::UniqueID> id = getUniqueID(path))
return WholeArchives.count(*ID); return wholeArchives.count(*id);
return false; return false;
}; };
// Create a list of input files. Files can be given as arguments // Create a list of input files. Files can be given as arguments
// for /defaultlib option. // for /defaultlib option.
for (auto *Arg : Args.filtered(OPT_INPUT, OPT_wholearchive_file)) for (auto *arg : args.filtered(OPT_INPUT, OPT_wholearchive_file))
if (Optional<StringRef> Path = findFile(Arg->getValue())) if (Optional<StringRef> path = findFile(arg->getValue()))
enqueuePath(*Path, IsWholeArchive(*Path)); enqueuePath(*path, isWholeArchive(*path));
for (auto *Arg : Args.filtered(OPT_defaultlib)) for (auto *arg : args.filtered(OPT_defaultlib))
if (Optional<StringRef> Path = findLib(Arg->getValue())) if (Optional<StringRef> path = findLib(arg->getValue()))
enqueuePath(*Path, false); enqueuePath(*path, false);
// Windows specific -- Create a resource file containing a manifest file. // Windows specific -- Create a resource file containing a manifest file.
if (Config->Manifest == Configuration::Embed) if (config->manifest == Configuration::Embed)
addBuffer(createManifestRes(), false); addBuffer(createManifestRes(), false);
// Read all input files given via the command line. // Read all input files given via the command line.
run(); run();
if (errorCount()) if (errorCount())
return; return;
// We should have inferred a machine type by now from the input files, but if // We should have inferred a machine type by now from the input files, but if
// not we assume x64. // not we assume x64.
if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) { if (config->machine == IMAGE_FILE_MACHINE_UNKNOWN) {
warn("/machine is not specified. x64 is assumed"); warn("/machine is not specified. x64 is assumed");
Config->Machine = AMD64; config->machine = AMD64;
} }
Config->Wordsize = Config->is64() ? 8 : 4; config->wordsize = config->is64() ? 8 : 4;
// Handle /functionpadmin // Handle /functionpadmin
for (auto *Arg : Args.filtered(OPT_functionpadmin, OPT_functionpadmin_opt)) for (auto *arg : args.filtered(OPT_functionpadmin, OPT_functionpadmin_opt))
parseFunctionPadMin(Arg, Config->Machine); parseFunctionPadMin(arg, config->machine);
// Input files can be Windows resource files (.res files). We use // Input files can be Windows resource files (.res files). We use
// WindowsResource to convert resource files to a regular COFF file, // WindowsResource to convert resource files to a regular COFF file,
// then link the resulting file normally. // then link the resulting file normally.
if (!Resources.empty()) if (!resources.empty())
Symtab->addFile(make<ObjFile>(convertResToCOFF(Resources))); symtab->addFile(make<ObjFile>(convertResToCOFF(resources)));
if (Tar) if (tar)
Tar->append("response.txt", tar->append("response.txt",
createResponseFile(Args, FilePaths, createResponseFile(args, filePaths,
ArrayRef<StringRef>(SearchPaths).slice(1))); ArrayRef<StringRef>(searchPaths).slice(1)));
// Handle /largeaddressaware // Handle /largeaddressaware
Config->LargeAddressAware = Args.hasFlag( config->largeAddressAware = args.hasFlag(
OPT_largeaddressaware, OPT_largeaddressaware_no, Config->is64()); OPT_largeaddressaware, OPT_largeaddressaware_no, config->is64());
// Handle /highentropyva // Handle /highentropyva
Config->HighEntropyVA = config->highEntropyVA =
Config->is64() && config->is64() &&
Args.hasFlag(OPT_highentropyva, OPT_highentropyva_no, true); args.hasFlag(OPT_highentropyva, OPT_highentropyva_no, true);
if (!Config->DynamicBase && if (!config->dynamicBase &&
(Config->Machine == ARMNT || Config->Machine == ARM64)) (config->machine == ARMNT || config->machine == ARM64))
error("/dynamicbase:no is not compatible with " + error("/dynamicbase:no is not compatible with " +
machineToStr(Config->Machine)); machineToStr(config->machine));
// Handle /export // Handle /export
for (auto *Arg : Args.filtered(OPT_export)) { for (auto *arg : args.filtered(OPT_export)) {
Export E = parseExport(Arg->getValue()); Export e = parseExport(arg->getValue());
if (Config->Machine == I386) { if (config->machine == I386) {
if (!isDecorated(E.Name)) if (!isDecorated(e.name))
E.Name = Saver.save("_" + E.Name); e.name = saver.save("_" + e.name);
if (!E.ExtName.empty() && !isDecorated(E.ExtName)) if (!e.extName.empty() && !isDecorated(e.extName))
E.ExtName = Saver.save("_" + E.ExtName); e.extName = saver.save("_" + e.extName);
} }
Config->Exports.push_back(E); config->exports.push_back(e);
} }
// Handle /def // Handle /def
if (auto *Arg = Args.getLastArg(OPT_deffile)) { if (auto *arg = args.getLastArg(OPT_deffile)) {
// parseModuleDefs mutates Config object. // parseModuleDefs mutates Config object.
parseModuleDefs(Arg->getValue()); parseModuleDefs(arg->getValue());
} }
// Handle generation of import library from a def file. // Handle generation of import library from a def file.
if (!Args.hasArg(OPT_INPUT)) { if (!args.hasArg(OPT_INPUT)) {
fixupExports(); fixupExports();
createImportLibrary(/*AsLib=*/true); createImportLibrary(/*AsLib=*/true);
return; return;
} }
// Windows specific -- if no /subsystem is given, we need to infer // Windows specific -- if no /subsystem is given, we need to infer
// that from entry point name. Must happen before /entry handling, // that from entry point name. Must happen before /entry handling,
// and after the early return when just writing an import library. // and after the early return when just writing an import library.
if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) { if (config->subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
Config->Subsystem = inferSubsystem(); config->subsystem = inferSubsystem();
if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) if (config->subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
fatal("subsystem must be defined"); fatal("subsystem must be defined");
} }
// Handle /entry and /dll // Handle /entry and /dll
if (auto *Arg = Args.getLastArg(OPT_entry)) { if (auto *arg = args.getLastArg(OPT_entry)) {
Config->Entry = addUndefined(mangle(Arg->getValue())); config->entry = addUndefined(mangle(arg->getValue()));
} else if (!Config->Entry && !Config->NoEntry) { } else if (!config->entry && !config->noEntry) {
if (Args.hasArg(OPT_dll)) { if (args.hasArg(OPT_dll)) {
StringRef S = (Config->Machine == I386) ? "__DllMainCRTStartup@12" StringRef s = (config->machine == I386) ? "__DllMainCRTStartup@12"
: "_DllMainCRTStartup"; : "_DllMainCRTStartup";
Config->Entry = addUndefined(S); config->entry = addUndefined(s);
} else { } else {
// Windows specific -- If entry point name is not given, we need to // Windows specific -- If entry point name is not given, we need to
// infer that from user-defined entry name. // infer that from user-defined entry name.
StringRef S = findDefaultEntry(); StringRef s = findDefaultEntry();
if (S.empty()) if (s.empty())
fatal("entry point must be defined"); fatal("entry point must be defined");
Config->Entry = addUndefined(S); config->entry = addUndefined(s);
log("Entry name inferred: " + S); log("Entry name inferred: " + s);
} }
} }
// Handle /delayload // Handle /delayload
for (auto *Arg : Args.filtered(OPT_delayload)) { for (auto *arg : args.filtered(OPT_delayload)) {
Config->DelayLoads.insert(StringRef(Arg->getValue()).lower()); config->delayLoads.insert(StringRef(arg->getValue()).lower());
if (Config->Machine == I386) { if (config->machine == I386) {
Config->DelayLoadHelper = addUndefined("___delayLoadHelper2@8"); config->delayLoadHelper = addUndefined("___delayLoadHelper2@8");
} else { } else {
Config->DelayLoadHelper = addUndefined("__delayLoadHelper2"); config->delayLoadHelper = addUndefined("__delayLoadHelper2");
} }
} }
// Set default image name if neither /out or /def set it. // Set default image name if neither /out or /def set it.
if (Config->OutputFile.empty()) { if (config->outputFile.empty()) {
Config->OutputFile = config->outputFile =
getOutputPath((*Args.filtered(OPT_INPUT).begin())->getValue()); getOutputPath((*args.filtered(OPT_INPUT).begin())->getValue());
} }
// Fail early if an output file is not writable. // Fail early if an output file is not writable.
if (auto E = tryCreateFile(Config->OutputFile)) { if (auto e = tryCreateFile(config->outputFile)) {
error("cannot open output file " + Config->OutputFile + ": " + E.message()); error("cannot open output file " + config->outputFile + ": " + e.message());
return; return;
} }
if (ShouldCreatePDB) { if (shouldCreatePDB) {
// Put the PDB next to the image if no /pdb flag was passed. // Put the PDB next to the image if no /pdb flag was passed.
if (Config->PDBPath.empty()) { if (config->pdbPath.empty()) {
Config->PDBPath = Config->OutputFile; config->pdbPath = config->outputFile;
sys::path::replace_extension(Config->PDBPath, ".pdb"); sys::path::replace_extension(config->pdbPath, ".pdb");
} }
// The embedded PDB path should be the absolute path to the PDB if no // The embedded PDB path should be the absolute path to the PDB if no
// /pdbaltpath flag was passed. // /pdbaltpath flag was passed.
if (Config->PDBAltPath.empty()) { if (config->pdbAltPath.empty()) {
Config->PDBAltPath = Config->PDBPath; config->pdbAltPath = config->pdbPath;
// It's important to make the path absolute and remove dots. This path // It's important to make the path absolute and remove dots. This path
// will eventually be written into the PE header, and certain Microsoft // will eventually be written into the PE header, and certain Microsoft
// tools won't work correctly if these assumptions are not held. // tools won't work correctly if these assumptions are not held.
sys::fs::make_absolute(Config->PDBAltPath); sys::fs::make_absolute(config->pdbAltPath);
sys::path::remove_dots(Config->PDBAltPath); sys::path::remove_dots(config->pdbAltPath);
} else { } else {
// Don't do this earlier, so that Config->OutputFile is ready. // Don't do this earlier, so that Config->OutputFile is ready.
parsePDBAltPath(Config->PDBAltPath); parsePDBAltPath(config->pdbAltPath);
} }
} }
// Set default image base if /base is not given. // Set default image base if /base is not given.
if (Config->ImageBase == uint64_t(-1)) if (config->imageBase == uint64_t(-1))
Config->ImageBase = getDefaultImageBase(); config->imageBase = getDefaultImageBase();
Symtab->addSynthetic(mangle("__ImageBase"), nullptr); symtab->addSynthetic(mangle("__ImageBase"), nullptr);
if (Config->Machine == I386) { if (config->machine == I386) {
Symtab->addAbsolute("___safe_se_handler_table", 0); symtab->addAbsolute("___safe_se_handler_table", 0);
Symtab->addAbsolute("___safe_se_handler_count", 0); symtab->addAbsolute("___safe_se_handler_count", 0);
} }
Symtab->addAbsolute(mangle("__guard_fids_count"), 0); symtab->addAbsolute(mangle("__guard_fids_count"), 0);
Symtab->addAbsolute(mangle("__guard_fids_table"), 0); symtab->addAbsolute(mangle("__guard_fids_table"), 0);
Symtab->addAbsolute(mangle("__guard_flags"), 0); symtab->addAbsolute(mangle("__guard_flags"), 0);
Symtab->addAbsolute(mangle("__guard_iat_count"), 0); symtab->addAbsolute(mangle("__guard_iat_count"), 0);
Symtab->addAbsolute(mangle("__guard_iat_table"), 0); symtab->addAbsolute(mangle("__guard_iat_table"), 0);
Symtab->addAbsolute(mangle("__guard_longjmp_count"), 0); symtab->addAbsolute(mangle("__guard_longjmp_count"), 0);
Symtab->addAbsolute(mangle("__guard_longjmp_table"), 0); symtab->addAbsolute(mangle("__guard_longjmp_table"), 0);
// Needed for MSVC 2017 15.5 CRT. // Needed for MSVC 2017 15.5 CRT.
Symtab->addAbsolute(mangle("__enclave_config"), 0); symtab->addAbsolute(mangle("__enclave_config"), 0);
if (Config->MinGW) { if (config->mingw) {
Symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST__"), 0); symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST__"), 0);
Symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST_END__"), 0); symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST_END__"), 0);
Symtab->addAbsolute(mangle("__CTOR_LIST__"), 0); symtab->addAbsolute(mangle("__CTOR_LIST__"), 0);
Symtab->addAbsolute(mangle("__DTOR_LIST__"), 0); symtab->addAbsolute(mangle("__DTOR_LIST__"), 0);
} }
// This code may add new undefined symbols to the link, which may enqueue more // This code may add new undefined symbols to the link, which may enqueue more
// symbol resolution tasks, so we need to continue executing tasks until we // symbol resolution tasks, so we need to continue executing tasks until we
// converge. // converge.
do { do {
// Windows specific -- if entry point is not found, // Windows specific -- if entry point is not found,
// search for its mangled names. // search for its mangled names.
if (Config->Entry) if (config->entry)
mangleMaybe(Config->Entry); mangleMaybe(config->entry);
// Windows specific -- Make sure we resolve all dllexported symbols. // Windows specific -- Make sure we resolve all dllexported symbols.
for (Export &E : Config->Exports) { for (Export &e : config->exports) {
if (!E.ForwardTo.empty()) if (!e.forwardTo.empty())
continue; continue;
E.Sym = addUndefined(E.Name); e.sym = addUndefined(e.name);
if (!E.Directives) if (!e.directives)
E.SymbolName = mangleMaybe(E.Sym); e.symbolName = mangleMaybe(e.sym);
} }
// Add weak aliases. Weak aliases is a mechanism to give remaining // Add weak aliases. Weak aliases is a mechanism to give remaining
// undefined symbols final chance to be resolved successfully. // undefined symbols final chance to be resolved successfully.
for (auto Pair : Config->AlternateNames) { for (auto pair : config->alternateNames) {
StringRef From = Pair.first; StringRef from = pair.first;
StringRef To = Pair.second; StringRef to = pair.second;
Symbol *Sym = Symtab->find(From); Symbol *sym = symtab->find(from);
if (!Sym) if (!sym)
continue; continue;
if (auto *U = dyn_cast<Undefined>(Sym)) if (auto *u = dyn_cast<Undefined>(sym))
if (!U->WeakAlias) if (!u->weakAlias)
U->WeakAlias = Symtab->addUndefined(To); u->weakAlias = symtab->addUndefined(to);
} }
// Windows specific -- if __load_config_used can be resolved, resolve it. // Windows specific -- if __load_config_used can be resolved, resolve it.
if (Symtab->findUnderscore("_load_config_used")) if (symtab->findUnderscore("_load_config_used"))
addUndefined(mangle("_load_config_used")); addUndefined(mangle("_load_config_used"));
} while (run()); } while (run());
if (errorCount()) if (errorCount())
return; return;
// Do LTO by compiling bitcode input files to a set of native COFF files then // Do LTO by compiling bitcode input files to a set of native COFF files then
// link those files. // link those files.
Symtab->addCombinedLTOObjects(); symtab->addCombinedLTOObjects();
run(); run();
if (Args.hasArg(OPT_include_optional)) { if (args.hasArg(OPT_include_optional)) {
// Handle /includeoptional // Handle /includeoptional
for (auto *Arg : Args.filtered(OPT_include_optional)) for (auto *arg : args.filtered(OPT_include_optional))
if (dyn_cast_or_null<Lazy>(Symtab->find(Arg->getValue()))) if (dyn_cast_or_null<Lazy>(symtab->find(arg->getValue())))
addUndefined(Arg->getValue()); addUndefined(arg->getValue());
while (run()); while (run());
} }
if (Config->MinGW) { if (config->mingw) {
// Load any further object files that might be needed for doing automatic // Load any further object files that might be needed for doing automatic
// imports. // imports.
// //
// For cases with no automatically imported symbols, this iterates once // For cases with no automatically imported symbols, this iterates once
// over the symbol table and doesn't do anything. // over the symbol table and doesn't do anything.
// //
// For the normal case with a few automatically imported symbols, this // For the normal case with a few automatically imported symbols, this
// should only need to be run once, since each new object file imported // should only need to be run once, since each new object file imported
// is an import library and wouldn't add any new undefined references, // is an import library and wouldn't add any new undefined references,
// but there's nothing stopping the __imp_ symbols from coming from a // but there's nothing stopping the __imp_ symbols from coming from a
// normal object file as well (although that won't be used for the // normal object file as well (although that won't be used for the
// actual autoimport later on). If this pass adds new undefined references, // actual autoimport later on). If this pass adds new undefined references,
// we won't iterate further to resolve them. // we won't iterate further to resolve them.
Symtab->loadMinGWAutomaticImports(); symtab->loadMinGWAutomaticImports();
run(); run();
} }
// Make sure we have resolved all symbols. // Make sure we have resolved all symbols.
Symtab->reportRemainingUndefines(); symtab->reportRemainingUndefines();
if (errorCount()) if (errorCount())
return; return;
// Handle /safeseh. // Handle /safeseh.
if (Args.hasFlag(OPT_safeseh, OPT_safeseh_no, false)) { if (args.hasFlag(OPT_safeseh, OPT_safeseh_no, false)) {
for (ObjFile *File : ObjFile::Instances) for (ObjFile *file : ObjFile::instances)
if (!File->hasSafeSEH()) if (!file->hasSafeSEH())
error("/safeseh: " + File->getName() + " is not compatible with SEH"); error("/safeseh: " + file->getName() + " is not compatible with SEH");
if (errorCount()) if (errorCount())
return; return;
} }
if (Config->MinGW) { if (config->mingw) {
// In MinGW, all symbols are automatically exported if no symbols // In MinGW, all symbols are automatically exported if no symbols
// are chosen to be exported. // are chosen to be exported.
maybeExportMinGWSymbols(Args); maybeExportMinGWSymbols(args);
// Make sure the crtend.o object is the last object file. This object // Make sure the crtend.o object is the last object file. This object
// file can contain terminating section chunks that need to be placed // file can contain terminating section chunks that need to be placed
// last. GNU ld processes files and static libraries explicitly in the // last. GNU ld processes files and static libraries explicitly in the
// order provided on the command line, while lld will pull in needed // order provided on the command line, while lld will pull in needed
// files from static libraries only after the last object file on the // files from static libraries only after the last object file on the
// command line. // command line.
for (auto I = ObjFile::Instances.begin(), E = ObjFile::Instances.end(); for (auto i = ObjFile::instances.begin(), e = ObjFile::instances.end();
I != E; I++) { i != e; i++) {
ObjFile *File = *I; ObjFile *file = *i;
if (isCrtend(File->getName())) { if (isCrtend(file->getName())) {
ObjFile::Instances.erase(I); ObjFile::instances.erase(i);
ObjFile::Instances.push_back(File); ObjFile::instances.push_back(file);
break; break;
} }
} }
} }
// Windows specific -- when we are creating a .dll file, we also // Windows specific -- when we are creating a .dll file, we also
// need to create a .lib file. // need to create a .lib file.
if (!Config->Exports.empty() || Config->DLL) { if (!config->exports.empty() || config->dll) {
fixupExports(); fixupExports();
createImportLibrary(/*AsLib=*/false); createImportLibrary(/*AsLib=*/false);
assignExportOrdinals(); assignExportOrdinals();
} }
// Handle /output-def (MinGW specific). // Handle /output-def (MinGW specific).
if (auto *Arg = Args.getLastArg(OPT_output_def)) if (auto *arg = args.getLastArg(OPT_output_def))
writeDefFile(Arg->getValue()); writeDefFile(arg->getValue());
// Set extra alignment for .comm symbols // Set extra alignment for .comm symbols
for (auto Pair : Config->AlignComm) { for (auto pair : config->alignComm) {
StringRef Name = Pair.first; StringRef name = pair.first;
uint32_t Alignment = Pair.second; uint32_t alignment = pair.second;
Symbol *Sym = Symtab->find(Name); Symbol *sym = symtab->find(name);
if (!Sym) { if (!sym) {
warn("/aligncomm symbol " + Name + " not found"); warn("/aligncomm symbol " + name + " not found");
continue; continue;
} }
// If the symbol isn't common, it must have been replaced with a regular // If the symbol isn't common, it must have been replaced with a regular
// symbol, which will carry its own alignment. // symbol, which will carry its own alignment.
auto *DC = dyn_cast<DefinedCommon>(Sym); auto *dc = dyn_cast<DefinedCommon>(sym);
if (!DC) if (!dc)
continue; continue;
CommonChunk *C = DC->getChunk(); CommonChunk *c = dc->getChunk();
C->setAlignment(std::max(C->getAlignment(), Alignment)); c->setAlignment(std::max(c->getAlignment(), alignment));
} }
// Windows specific -- Create a side-by-side manifest file. // Windows specific -- Create a side-by-side manifest file.
if (Config->Manifest == Configuration::SideBySide) if (config->manifest == Configuration::SideBySide)
createSideBySideManifest(); createSideBySideManifest();
// Handle /order. We want to do this at this moment because we // Handle /order. We want to do this at this moment because we
// need a complete list of comdat sections to warn on nonexistent // need a complete list of comdat sections to warn on nonexistent
// functions. // functions.
if (auto *Arg = Args.getLastArg(OPT_order)) if (auto *arg = args.getLastArg(OPT_order))
parseOrderFile(Arg->getValue()); parseOrderFile(arg->getValue());
// Identify unreferenced COMDAT sections. // Identify unreferenced COMDAT sections.
if (Config->DoGC) if (config->doGC)
markLive(Symtab->getChunks()); markLive(symtab->getChunks());
// Needs to happen after the last call to addFile(). // Needs to happen after the last call to addFile().
diagnoseMultipleResourceObjFiles(); diagnoseMultipleResourceObjFiles();
// Identify identical COMDAT sections to merge them. // Identify identical COMDAT sections to merge them.
if (Config->DoICF) { if (config->doICF) {
findKeepUniqueSections(); findKeepUniqueSections();
doICF(Symtab->getChunks()); doICF(symtab->getChunks());
} }
// Write the result. // Write the result.
writeResult(); writeResult();
// Stop early so we can print the results. // Stop early so we can print the results.
Timer::root().stop(); Timer::root().stop();
if (Config->ShowTiming) if (config->showTiming)
Timer::root().print(); Timer::root().print();
} }
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld

lld/trunk/COFF/DriverUtils.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
namespace coff { namespace coff {
namespace { namespace {
const uint16_t SUBLANG_ENGLISH_US = 0x0409; const uint16_t SUBLANG_ENGLISH_US = 0x0409;
const uint16_t RT_MANIFEST = 24; const uint16_t RT_MANIFEST = 24;
class Executor { class Executor {
public: public:
explicit Executor(StringRef S) : Prog(Saver.save(S)) {} explicit Executor(StringRef s) : prog(saver.save(s)) {}
void add(StringRef S) { Args.push_back(Saver.save(S)); } void add(StringRef s) { args.push_back(saver.save(s)); }
void add(std::string &S) { Args.push_back(Saver.save(S)); } void add(std::string &s) { args.push_back(saver.save(s)); }
void add(Twine S) { Args.push_back(Saver.save(S)); } void add(Twine s) { args.push_back(saver.save(s)); }
void add(const char *S) { Args.push_back(Saver.save(S)); } void add(const char *s) { args.push_back(saver.save(s)); }
void run() { void run() {
ErrorOr<std::string> ExeOrErr = sys::findProgramByName(Prog); ErrorOr<std::string> exeOrErr = sys::findProgramByName(prog);
if (auto EC = ExeOrErr.getError()) if (auto ec = exeOrErr.getError())
fatal("unable to find " + Prog + " in PATH: " + EC.message()); fatal("unable to find " + prog + " in PATH: " + ec.message());
StringRef Exe = Saver.save(*ExeOrErr); StringRef exe = saver.save(*exeOrErr);
Args.insert(Args.begin(), Exe); args.insert(args.begin(), exe);
if (sys::ExecuteAndWait(Args[0], Args) != 0) if (sys::ExecuteAndWait(args[0], args) != 0)
fatal("ExecuteAndWait failed: " + fatal("ExecuteAndWait failed: " +
llvm::join(Args.begin(), Args.end(), " ")); llvm::join(args.begin(), args.end(), " "));
} }
private: private:
StringRef Prog; StringRef prog;
std::vector<StringRef> Args; std::vector<StringRef> args;
}; };
} // anonymous namespace } // anonymous namespace
// Parses a string in the form of "<integer>[,<integer>]". // Parses a string in the form of "<integer>[,<integer>]".
void parseNumbers(StringRef Arg, uint64_t *Addr, uint64_t *Size) { void parseNumbers(StringRef arg, uint64_t *addr, uint64_t *size) {
StringRef S1, S2; StringRef s1, s2;
std::tie(S1, S2) = Arg.split(','); std::tie(s1, s2) = arg.split(',');
if (S1.getAsInteger(0, *Addr)) if (s1.getAsInteger(0, *addr))
fatal("invalid number: " + S1); fatal("invalid number: " + s1);
if (Size && !S2.empty() && S2.getAsInteger(0, *Size)) if (size && !s2.empty() && s2.getAsInteger(0, *size))
fatal("invalid number: " + S2); fatal("invalid number: " + s2);
} }
// Parses a string in the form of "<integer>[.<integer>]". // Parses a string in the form of "<integer>[.<integer>]".
// If second number is not present, Minor is set to 0. // If second number is not present, Minor is set to 0.
void parseVersion(StringRef Arg, uint32_t *Major, uint32_t *Minor) { void parseVersion(StringRef arg, uint32_t *major, uint32_t *minor) {
StringRef S1, S2; StringRef s1, s2;
std::tie(S1, S2) = Arg.split('.'); std::tie(s1, s2) = arg.split('.');
if (S1.getAsInteger(0, *Major)) if (s1.getAsInteger(0, *major))
fatal("invalid number: " + S1); fatal("invalid number: " + s1);
*Minor = 0; *minor = 0;
if (!S2.empty() && S2.getAsInteger(0, *Minor)) if (!s2.empty() && s2.getAsInteger(0, *minor))
fatal("invalid number: " + S2); fatal("invalid number: " + s2);
} }
void parseGuard(StringRef FullArg) { void parseGuard(StringRef fullArg) {
SmallVector<StringRef, 1> SplitArgs; SmallVector<StringRef, 1> splitArgs;
FullArg.split(SplitArgs, ","); fullArg.split(splitArgs, ",");
for (StringRef Arg : SplitArgs) { for (StringRef arg : splitArgs) {
if (Arg.equals_lower("no")) if (arg.equals_lower("no"))
Config->GuardCF = GuardCFLevel::Off; config->guardCF = GuardCFLevel::Off;
else if (Arg.equals_lower("nolongjmp")) else if (arg.equals_lower("nolongjmp"))
Config->GuardCF = GuardCFLevel::NoLongJmp; config->guardCF = GuardCFLevel::NoLongJmp;
else if (Arg.equals_lower("cf") || Arg.equals_lower("longjmp")) else if (arg.equals_lower("cf") || arg.equals_lower("longjmp"))
Config->GuardCF = GuardCFLevel::Full; config->guardCF = GuardCFLevel::Full;
else else
fatal("invalid argument to /guard: " + Arg); fatal("invalid argument to /guard: " + arg);
} }
} }
// Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]". // Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]".
void parseSubsystem(StringRef Arg, WindowsSubsystem *Sys, uint32_t *Major, void parseSubsystem(StringRef arg, WindowsSubsystem *sys, uint32_t *major,
uint32_t *Minor) { uint32_t *minor) {
StringRef SysStr, Ver; StringRef sysStr, ver;
std::tie(SysStr, Ver) = Arg.split(','); std::tie(sysStr, ver) = arg.split(',');
std::string SysStrLower = SysStr.lower(); std::string sysStrLower = sysStr.lower();
*Sys = StringSwitch<WindowsSubsystem>(SysStrLower) *sys = StringSwitch<WindowsSubsystem>(sysStrLower)
.Case("boot_application", IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION) .Case("boot_application", IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION)
.Case("console", IMAGE_SUBSYSTEM_WINDOWS_CUI) .Case("console", IMAGE_SUBSYSTEM_WINDOWS_CUI)
.Case("default", IMAGE_SUBSYSTEM_UNKNOWN) .Case("default", IMAGE_SUBSYSTEM_UNKNOWN)
.Case("efi_application", IMAGE_SUBSYSTEM_EFI_APPLICATION) .Case("efi_application", IMAGE_SUBSYSTEM_EFI_APPLICATION)
.Case("efi_boot_service_driver", IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER) .Case("efi_boot_service_driver", IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER)
.Case("efi_rom", IMAGE_SUBSYSTEM_EFI_ROM) .Case("efi_rom", IMAGE_SUBSYSTEM_EFI_ROM)
.Case("efi_runtime_driver", IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER) .Case("efi_runtime_driver", IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER)
.Case("native", IMAGE_SUBSYSTEM_NATIVE) .Case("native", IMAGE_SUBSYSTEM_NATIVE)
.Case("posix", IMAGE_SUBSYSTEM_POSIX_CUI) .Case("posix", IMAGE_SUBSYSTEM_POSIX_CUI)
.Case("windows", IMAGE_SUBSYSTEM_WINDOWS_GUI) .Case("windows", IMAGE_SUBSYSTEM_WINDOWS_GUI)
.Default(IMAGE_SUBSYSTEM_UNKNOWN); .Default(IMAGE_SUBSYSTEM_UNKNOWN);
if (*Sys == IMAGE_SUBSYSTEM_UNKNOWN && SysStrLower != "default") if (*sys == IMAGE_SUBSYSTEM_UNKNOWN && sysStrLower != "default")
fatal("unknown subsystem: " + SysStr); fatal("unknown subsystem: " + sysStr);
if (!Ver.empty()) if (!ver.empty())
parseVersion(Ver, Major, Minor); parseVersion(ver, major, minor);
} }
// Parse a string of the form of "<from>=<to>". // Parse a string of the form of "<from>=<to>".
// Results are directly written to Config. // Results are directly written to Config.
void parseAlternateName(StringRef S) { void parseAlternateName(StringRef s) {
StringRef From, To; StringRef from, to;
std::tie(From, To) = S.split('='); std::tie(from, to) = s.split('=');
if (From.empty() || To.empty()) if (from.empty() || to.empty())
fatal("/alternatename: invalid argument: " + S); fatal("/alternatename: invalid argument: " + s);
auto It = Config->AlternateNames.find(From); auto it = config->alternateNames.find(from);
if (It != Config->AlternateNames.end() && It->second != To) if (it != config->alternateNames.end() && it->second != to)
fatal("/alternatename: conflicts: " + S); fatal("/alternatename: conflicts: " + s);
Config->AlternateNames.insert(It, std::make_pair(From, To)); config->alternateNames.insert(it, std::make_pair(from, to));
} }
// Parse a string of the form of "<from>=<to>". // Parse a string of the form of "<from>=<to>".
// Results are directly written to Config. // Results are directly written to Config.
void parseMerge(StringRef S) { void parseMerge(StringRef s) {
StringRef From, To; StringRef from, to;
std::tie(From, To) = S.split('='); std::tie(from, to) = s.split('=');
if (From.empty() || To.empty()) if (from.empty() || to.empty())
fatal("/merge: invalid argument: " + S); fatal("/merge: invalid argument: " + s);
if (From == ".rsrc" || To == ".rsrc") if (from == ".rsrc" || to == ".rsrc")
fatal("/merge: cannot merge '.rsrc' with any section"); fatal("/merge: cannot merge '.rsrc' with any section");
if (From == ".reloc" || To == ".reloc") if (from == ".reloc" || to == ".reloc")
fatal("/merge: cannot merge '.reloc' with any section"); fatal("/merge: cannot merge '.reloc' with any section");
auto Pair = Config->Merge.insert(std::make_pair(From, To)); auto pair = config->merge.insert(std::make_pair(from, to));
bool Inserted = Pair.second; bool inserted = pair.second;
if (!Inserted) { if (!inserted) {
StringRef Existing = Pair.first->second; StringRef existing = pair.first->second;
if (Existing != To) if (existing != to)
warn(S + ": already merged into " + Existing); warn(s + ": already merged into " + existing);
} }
} }
static uint32_t parseSectionAttributes(StringRef S) { static uint32_t parseSectionAttributes(StringRef s) {
uint32_t Ret = 0; uint32_t ret = 0;
for (char C : S.lower()) { for (char c : s.lower()) {
switch (C) { switch (c) {
case 'd': case 'd':
Ret |= IMAGE_SCN_MEM_DISCARDABLE; ret |= IMAGE_SCN_MEM_DISCARDABLE;
break; break;
case 'e': case 'e':
Ret |= IMAGE_SCN_MEM_EXECUTE; ret |= IMAGE_SCN_MEM_EXECUTE;
break; break;
case 'k': case 'k':
Ret |= IMAGE_SCN_MEM_NOT_CACHED; ret |= IMAGE_SCN_MEM_NOT_CACHED;
break; break;
case 'p': case 'p':
Ret |= IMAGE_SCN_MEM_NOT_PAGED; ret |= IMAGE_SCN_MEM_NOT_PAGED;
break; break;
case 'r': case 'r':
Ret |= IMAGE_SCN_MEM_READ; ret |= IMAGE_SCN_MEM_READ;
break; break;
case 's': case 's':
Ret |= IMAGE_SCN_MEM_SHARED; ret |= IMAGE_SCN_MEM_SHARED;
break; break;
case 'w': case 'w':
Ret |= IMAGE_SCN_MEM_WRITE; ret |= IMAGE_SCN_MEM_WRITE;
break; break;
default: default:
fatal("/section: invalid argument: " + S); fatal("/section: invalid argument: " + s);
} }
} }
return Ret; return ret;
} }
// Parses /section option argument. // Parses /section option argument.
void parseSection(StringRef S) { void parseSection(StringRef s) {
StringRef Name, Attrs; StringRef name, attrs;
std::tie(Name, Attrs) = S.split(','); std::tie(name, attrs) = s.split(',');
if (Name.empty() || Attrs.empty()) if (name.empty() || attrs.empty())
fatal("/section: invalid argument: " + S); fatal("/section: invalid argument: " + s);
Config->Section[Name] = parseSectionAttributes(Attrs); config->section[name] = parseSectionAttributes(attrs);
} }
// Parses /aligncomm option argument. // Parses /aligncomm option argument.
void parseAligncomm(StringRef S) { void parseAligncomm(StringRef s) {
StringRef Name, Align; StringRef name, align;
std::tie(Name, Align) = S.split(','); std::tie(name, align) = s.split(',');
if (Name.empty() || Align.empty()) { if (name.empty() || align.empty()) {
error("/aligncomm: invalid argument: " + S); error("/aligncomm: invalid argument: " + s);
return; return;
} }
int V; int v;
if (Align.getAsInteger(0, V)) { if (align.getAsInteger(0, v)) {
error("/aligncomm: invalid argument: " + S); error("/aligncomm: invalid argument: " + s);
return; return;
} }
Config->AlignComm[Name] = std::max(Config->AlignComm[Name], 1 << V); config->alignComm[name] = std::max(config->alignComm[name], 1 << v);
} }
// Parses /functionpadmin option argument. // Parses /functionpadmin option argument.
void parseFunctionPadMin(llvm::opt::Arg *A, llvm::COFF::MachineTypes Machine) { void parseFunctionPadMin(llvm::opt::Arg *a, llvm::COFF::MachineTypes machine) {
StringRef Arg = A->getNumValues() ? A->getValue() : ""; StringRef arg = a->getNumValues() ? a->getValue() : "";
if (!Arg.empty()) { if (!arg.empty()) {
// Optional padding in bytes is given. // Optional padding in bytes is given.
if (Arg.getAsInteger(0, Config->FunctionPadMin)) if (arg.getAsInteger(0, config->functionPadMin))
error("/functionpadmin: invalid argument: " + Arg); error("/functionpadmin: invalid argument: " + arg);
return; return;
} }
// No optional argument given. // No optional argument given.
// Set default padding based on machine, similar to link.exe. // Set default padding based on machine, similar to link.exe.
// There is no default padding for ARM platforms. // There is no default padding for ARM platforms.
if (Machine == I386) { if (machine == I386) {
Config->FunctionPadMin = 5; config->functionPadMin = 5;
} else if (Machine == AMD64) { } else if (machine == AMD64) {
Config->FunctionPadMin = 6; config->functionPadMin = 6;
} else { } else {
error("/functionpadmin: invalid argument for this machine: " + Arg); error("/functionpadmin: invalid argument for this machine: " + arg);
} }
} }
// Parses a string in the form of "EMBED[,=<integer>]|NO". // Parses a string in the form of "EMBED[,=<integer>]|NO".
// Results are directly written to Config. // Results are directly written to Config.
void parseManifest(StringRef Arg) { void parseManifest(StringRef arg) {
if (Arg.equals_lower("no")) { if (arg.equals_lower("no")) {
Config->Manifest = Configuration::No; config->manifest = Configuration::No;
return; return;
} }
if (!Arg.startswith_lower("embed")) if (!arg.startswith_lower("embed"))
fatal("invalid option " + Arg); fatal("invalid option " + arg);
Config->Manifest = Configuration::Embed; config->manifest = Configuration::Embed;
Arg = Arg.substr(strlen("embed")); arg = arg.substr(strlen("embed"));
if (Arg.empty()) if (arg.empty())
return; return;
if (!Arg.startswith_lower(",id=")) if (!arg.startswith_lower(",id="))
fatal("invalid option " + Arg); fatal("invalid option " + arg);
Arg = Arg.substr(strlen(",id=")); arg = arg.substr(strlen(",id="));
if (Arg.getAsInteger(0, Config->ManifestID)) if (arg.getAsInteger(0, config->manifestID))
fatal("invalid option " + Arg); fatal("invalid option " + arg);
} }
// Parses a string in the form of "level=<string>|uiAccess=<string>|NO". // Parses a string in the form of "level=<string>|uiAccess=<string>|NO".
// Results are directly written to Config. // Results are directly written to Config.
void parseManifestUAC(StringRef Arg) { void parseManifestUAC(StringRef arg) {
if (Arg.equals_lower("no")) { if (arg.equals_lower("no")) {
Config->ManifestUAC = false; config->manifestUAC = false;
return; return;
} }
for (;;) { for (;;) {
Arg = Arg.ltrim(); arg = arg.ltrim();
if (Arg.empty()) if (arg.empty())
return; return;
if (Arg.startswith_lower("level=")) { if (arg.startswith_lower("level=")) {
Arg = Arg.substr(strlen("level=")); arg = arg.substr(strlen("level="));
std::tie(Config->ManifestLevel, Arg) = Arg.split(" "); std::tie(config->manifestLevel, arg) = arg.split(" ");
continue; continue;
} }
if (Arg.startswith_lower("uiaccess=")) { if (arg.startswith_lower("uiaccess=")) {
Arg = Arg.substr(strlen("uiaccess=")); arg = arg.substr(strlen("uiaccess="));
std::tie(Config->ManifestUIAccess, Arg) = Arg.split(" "); std::tie(config->manifestUIAccess, arg) = arg.split(" ");
continue; continue;
} }
fatal("invalid option " + Arg); fatal("invalid option " + arg);
} }
} }
// Parses a string in the form of "cd|net[,(cd|net)]*" // Parses a string in the form of "cd|net[,(cd|net)]*"
// Results are directly written to Config. // Results are directly written to Config.
void parseSwaprun(StringRef Arg) { void parseSwaprun(StringRef arg) {
do { do {
StringRef Swaprun, NewArg; StringRef swaprun, newArg;
std::tie(Swaprun, NewArg) = Arg.split(','); std::tie(swaprun, newArg) = arg.split(',');
if (Swaprun.equals_lower("cd")) if (swaprun.equals_lower("cd"))
Config->SwaprunCD = true; config->swaprunCD = true;
else if (Swaprun.equals_lower("net")) else if (swaprun.equals_lower("net"))
Config->SwaprunNet = true; config->swaprunNet = true;
else if (Swaprun.empty()) else if (swaprun.empty())
error("/swaprun: missing argument"); error("/swaprun: missing argument");
else else
error("/swaprun: invalid argument: " + Swaprun); error("/swaprun: invalid argument: " + swaprun);
// To catch trailing commas, e.g. `/spawrun:cd,` // To catch trailing commas, e.g. `/spawrun:cd,`
if (NewArg.empty() && Arg.endswith(",")) if (newArg.empty() && arg.endswith(","))
error("/swaprun: missing argument"); error("/swaprun: missing argument");
Arg = NewArg; arg = newArg;
} while (!Arg.empty()); } while (!arg.empty());
} }
// An RAII temporary file class that automatically removes a temporary file. // An RAII temporary file class that automatically removes a temporary file.
namespace { namespace {
class TemporaryFile { class TemporaryFile {
public: public:
TemporaryFile(StringRef Prefix, StringRef Extn, StringRef Contents = "") { TemporaryFile(StringRef prefix, StringRef extn, StringRef contents = "") {
SmallString<128> S; SmallString<128> s;
if (auto EC = sys::fs::createTemporaryFile("lld-" + Prefix, Extn, S)) if (auto ec = sys::fs::createTemporaryFile("lld-" + prefix, extn, s))
fatal("cannot create a temporary file: " + EC.message()); fatal("cannot create a temporary file: " + ec.message());
Path = S.str(); path = s.str();
if (!Contents.empty()) { if (!contents.empty()) {
std::error_code EC; std::error_code ec;
raw_fd_ostream OS(Path, EC, sys::fs::F_None); raw_fd_ostream os(path, ec, sys::fs::F_None);
if (EC) if (ec)
fatal("failed to open " + Path + ": " + EC.message()); fatal("failed to open " + path + ": " + ec.message());
OS << Contents; os << contents;
} }
} }
TemporaryFile(TemporaryFile &&Obj) { TemporaryFile(TemporaryFile &&obj) {
std::swap(Path, Obj.Path); std::swap(path, obj.path);
} }
~TemporaryFile() { ~TemporaryFile() {
if (Path.empty()) if (path.empty())
return; return;
if (sys::fs::remove(Path)) if (sys::fs::remove(path))
fatal("failed to remove " + Path); fatal("failed to remove " + path);
} }
// Returns a memory buffer of this temporary file. // Returns a memory buffer of this temporary file.
// Note that this function does not leave the file open, // Note that this function does not leave the file open,
// so it is safe to remove the file immediately after this function // so it is safe to remove the file immediately after this function
// is called (you cannot remove an opened file on Windows.) // is called (you cannot remove an opened file on Windows.)
std::unique_ptr<MemoryBuffer> getMemoryBuffer() { std::unique_ptr<MemoryBuffer> getMemoryBuffer() {
// IsVolatileSize=true forces MemoryBuffer to not use mmap(). // IsVolatileSize=true forces MemoryBuffer to not use mmap().
return CHECK(MemoryBuffer::getFile(Path, /*FileSize=*/-1, return CHECK(MemoryBuffer::getFile(path, /*FileSize=*/-1,
/*RequiresNullTerminator=*/false, /*RequiresNullTerminator=*/false,
/*IsVolatileSize=*/true), /*IsVolatileSize=*/true),
"could not open " + Path); "could not open " + path);
} }
std::string Path; std::string path;
}; };
} }
static std::string createDefaultXml() { static std::string createDefaultXml() {
std::string Ret; std::string ret;
raw_string_ostream OS(Ret); raw_string_ostream os(ret);
// Emit the XML. Note that we do *not* verify that the XML attributes are // Emit the XML. Note that we do *not* verify that the XML attributes are
// syntactically correct. This is intentional for link.exe compatibility. // syntactically correct. This is intentional for link.exe compatibility.
OS << "<?xml version=\"1.0\" standalone=\"yes\"?>\n" os << "<?xml version=\"1.0\" standalone=\"yes\"?>\n"
<< "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\"\n" << "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\"\n"
<< " manifestVersion=\"1.0\">\n"; << " manifestVersion=\"1.0\">\n";
if (Config->ManifestUAC) { if (config->manifestUAC) {
OS << " <trustInfo>\n" os << " <trustInfo>\n"
<< " <security>\n" << " <security>\n"
<< " <requestedPrivileges>\n" << " <requestedPrivileges>\n"
<< " <requestedExecutionLevel level=" << Config->ManifestLevel << " <requestedExecutionLevel level=" << config->manifestLevel
<< " uiAccess=" << Config->ManifestUIAccess << "/>\n" << " uiAccess=" << config->manifestUIAccess << "/>\n"
<< " </requestedPrivileges>\n" << " </requestedPrivileges>\n"
<< " </security>\n" << " </security>\n"
<< " </trustInfo>\n"; << " </trustInfo>\n";
} }
if (!Config->ManifestDependency.empty()) { if (!config->manifestDependency.empty()) {
OS << " <dependency>\n" os << " <dependency>\n"
<< " <dependentAssembly>\n" << " <dependentAssembly>\n"
<< " <assemblyIdentity " << Config->ManifestDependency << " />\n" << " <assemblyIdentity " << config->manifestDependency << " />\n"
<< " </dependentAssembly>\n" << " </dependentAssembly>\n"
<< " </dependency>\n"; << " </dependency>\n";
} }
OS << "</assembly>\n"; os << "</assembly>\n";
return OS.str(); return os.str();
} }
static std::string createManifestXmlWithInternalMt(StringRef DefaultXml) { static std::string createManifestXmlWithInternalMt(StringRef defaultXml) {
std::unique_ptr<MemoryBuffer> DefaultXmlCopy = std::unique_ptr<MemoryBuffer> defaultXmlCopy =
MemoryBuffer::getMemBufferCopy(DefaultXml); MemoryBuffer::getMemBufferCopy(defaultXml);
windows_manifest::WindowsManifestMerger Merger; windows_manifest::WindowsManifestMerger merger;
if (auto E = Merger.merge(*DefaultXmlCopy.get())) if (auto e = merger.merge(*defaultXmlCopy.get()))
fatal("internal manifest tool failed on default xml: " + fatal("internal manifest tool failed on default xml: " +
toString(std::move(E))); toString(std::move(e)));
for (StringRef Filename : Config->ManifestInput) { for (StringRef filename : config->manifestInput) {
std::unique_ptr<MemoryBuffer> Manifest = std::unique_ptr<MemoryBuffer> manifest =
check(MemoryBuffer::getFile(Filename)); check(MemoryBuffer::getFile(filename));
if (auto E = Merger.merge(*Manifest.get())) if (auto e = merger.merge(*manifest.get()))
fatal("internal manifest tool failed on file " + Filename + ": " + fatal("internal manifest tool failed on file " + filename + ": " +
toString(std::move(E))); toString(std::move(e)));
} }
return Merger.getMergedManifest().get()->getBuffer(); return merger.getMergedManifest().get()->getBuffer();
} }
static std::string createManifestXmlWithExternalMt(StringRef DefaultXml) { static std::string createManifestXmlWithExternalMt(StringRef defaultXml) {
// Create the default manifest file as a temporary file. // Create the default manifest file as a temporary file.
TemporaryFile Default("defaultxml", "manifest"); TemporaryFile Default("defaultxml", "manifest");
std::error_code EC; std::error_code ec;
raw_fd_ostream OS(Default.Path, EC, sys::fs::F_Text); raw_fd_ostream os(Default.path, ec, sys::fs::F_Text);
if (EC) if (ec)
fatal("failed to open " + Default.Path + ": " + EC.message()); fatal("failed to open " + Default.path + ": " + ec.message());
OS << DefaultXml; os << defaultXml;
OS.close(); os.close();
// Merge user-supplied manifests if they are given. Since libxml2 is not // Merge user-supplied manifests if they are given. Since libxml2 is not
// enabled, we must shell out to Microsoft's mt.exe tool. // enabled, we must shell out to Microsoft's mt.exe tool.
TemporaryFile User("user", "manifest"); TemporaryFile user("user", "manifest");
Executor E("mt.exe"); Executor e("mt.exe");
E.add("/manifest"); e.add("/manifest");
E.add(Default.Path); e.add(Default.path);
for (StringRef Filename : Config->ManifestInput) { for (StringRef filename : config->manifestInput) {
E.add("/manifest"); e.add("/manifest");
E.add(Filename); e.add(filename);
} }
E.add("/nologo"); e.add("/nologo");
E.add("/out:" + StringRef(User.Path)); e.add("/out:" + StringRef(user.path));
E.run(); e.run();
return CHECK(MemoryBuffer::getFile(User.Path), "could not open " + User.Path) return CHECK(MemoryBuffer::getFile(user.path), "could not open " + user.path)
.get() .get()
->getBuffer(); ->getBuffer();
} }
static std::string createManifestXml() { static std::string createManifestXml() {
std::string DefaultXml = createDefaultXml(); std::string defaultXml = createDefaultXml();
if (Config->ManifestInput.empty()) if (config->manifestInput.empty())
return DefaultXml; return defaultXml;
if (windows_manifest::isAvailable()) if (windows_manifest::isAvailable())
return createManifestXmlWithInternalMt(DefaultXml); return createManifestXmlWithInternalMt(defaultXml);
return createManifestXmlWithExternalMt(DefaultXml); return createManifestXmlWithExternalMt(defaultXml);
} }
static std::unique_ptr<WritableMemoryBuffer> static std::unique_ptr<WritableMemoryBuffer>
createMemoryBufferForManifestRes(size_t ManifestSize) { createMemoryBufferForManifestRes(size_t manifestSize) {
size_t ResSize = alignTo( size_t resSize = alignTo(
object::WIN_RES_MAGIC_SIZE + object::WIN_RES_NULL_ENTRY_SIZE + object::WIN_RES_MAGIC_SIZE + object::WIN_RES_NULL_ENTRY_SIZE +
sizeof(object::WinResHeaderPrefix) + sizeof(object::WinResIDs) + sizeof(object::WinResHeaderPrefix) + sizeof(object::WinResIDs) +
sizeof(object::WinResHeaderSuffix) + ManifestSize, sizeof(object::WinResHeaderSuffix) + manifestSize,
object::WIN_RES_DATA_ALIGNMENT); object::WIN_RES_DATA_ALIGNMENT);
return WritableMemoryBuffer::getNewMemBuffer(ResSize, Config->OutputFile + return WritableMemoryBuffer::getNewMemBuffer(resSize, config->outputFile +
".manifest.res"); ".manifest.res");
} }
static void writeResFileHeader(char *&Buf) { static void writeResFileHeader(char *&buf) {
memcpy(Buf, COFF::WinResMagic, sizeof(COFF::WinResMagic)); memcpy(buf, COFF::WinResMagic, sizeof(COFF::WinResMagic));
Buf += sizeof(COFF::WinResMagic); buf += sizeof(COFF::WinResMagic);
memset(Buf, 0, object::WIN_RES_NULL_ENTRY_SIZE); memset(buf, 0, object::WIN_RES_NULL_ENTRY_SIZE);
Buf += object::WIN_RES_NULL_ENTRY_SIZE; buf += object::WIN_RES_NULL_ENTRY_SIZE;
} }
static void writeResEntryHeader(char *&Buf, size_t ManifestSize) { static void writeResEntryHeader(char *&buf, size_t manifestSize) {
// Write the prefix. // Write the prefix.
auto *Prefix = reinterpret_cast<object::WinResHeaderPrefix *>(Buf); auto *prefix = reinterpret_cast<object::WinResHeaderPrefix *>(buf);
Prefix->DataSize = ManifestSize; prefix->DataSize = manifestSize;
Prefix->HeaderSize = sizeof(object::WinResHeaderPrefix) + prefix->HeaderSize = sizeof(object::WinResHeaderPrefix) +
sizeof(object::WinResIDs) + sizeof(object::WinResIDs) +
sizeof(object::WinResHeaderSuffix); sizeof(object::WinResHeaderSuffix);
Buf += sizeof(object::WinResHeaderPrefix); buf += sizeof(object::WinResHeaderPrefix);
// Write the Type/Name IDs. // Write the Type/Name IDs.
auto *IDs = reinterpret_cast<object::WinResIDs *>(Buf); auto *iDs = reinterpret_cast<object::WinResIDs *>(buf);
IDs->setType(RT_MANIFEST); iDs->setType(RT_MANIFEST);
IDs->setName(Config->ManifestID); iDs->setName(config->manifestID);
Buf += sizeof(object::WinResIDs); buf += sizeof(object::WinResIDs);
// Write the suffix. // Write the suffix.
auto *Suffix = reinterpret_cast<object::WinResHeaderSuffix *>(Buf); auto *suffix = reinterpret_cast<object::WinResHeaderSuffix *>(buf);
Suffix->DataVersion = 0; suffix->DataVersion = 0;
Suffix->MemoryFlags = object::WIN_RES_PURE_MOVEABLE; suffix->MemoryFlags = object::WIN_RES_PURE_MOVEABLE;
Suffix->Language = SUBLANG_ENGLISH_US; suffix->Language = SUBLANG_ENGLISH_US;
Suffix->Version = 0; suffix->Version = 0;
Suffix->Characteristics = 0; suffix->Characteristics = 0;
Buf += sizeof(object::WinResHeaderSuffix); buf += sizeof(object::WinResHeaderSuffix);
} }
// Create a resource file containing a manifest XML. // Create a resource file containing a manifest XML.
std::unique_ptr<MemoryBuffer> createManifestRes() { std::unique_ptr<MemoryBuffer> createManifestRes() {
std::string Manifest = createManifestXml(); std::string manifest = createManifestXml();
std::unique_ptr<WritableMemoryBuffer> Res = std::unique_ptr<WritableMemoryBuffer> res =
createMemoryBufferForManifestRes(Manifest.size()); createMemoryBufferForManifestRes(manifest.size());
char *Buf = Res->getBufferStart(); char *buf = res->getBufferStart();
writeResFileHeader(Buf); writeResFileHeader(buf);
writeResEntryHeader(Buf, Manifest.size()); writeResEntryHeader(buf, manifest.size());
// Copy the manifest data into the .res file. // Copy the manifest data into the .res file.
std::copy(Manifest.begin(), Manifest.end(), Buf); std::copy(manifest.begin(), manifest.end(), buf);
return std::move(Res); return std::move(res);
} }
void createSideBySideManifest() { void createSideBySideManifest() {
std::string Path = Config->ManifestFile; std::string path = config->manifestFile;
if (Path == "") if (path == "")
Path = Config->OutputFile + ".manifest"; path = config->outputFile + ".manifest";
std::error_code EC; std::error_code ec;
raw_fd_ostream Out(Path, EC, sys::fs::F_Text); raw_fd_ostream out(path, ec, sys::fs::F_Text);
if (EC) if (ec)
fatal("failed to create manifest: " + EC.message()); fatal("failed to create manifest: " + ec.message());
Out << createManifestXml(); out << createManifestXml();
} }
// Parse a string in the form of // Parse a string in the form of
// "<name>[=<internalname>][,@ordinal[,NONAME]][,DATA][,PRIVATE]" // "<name>[=<internalname>][,@ordinal[,NONAME]][,DATA][,PRIVATE]"
// or "<name>=<dllname>.<name>". // or "<name>=<dllname>.<name>".
// Used for parsing /export arguments. // Used for parsing /export arguments.
Export parseExport(StringRef Arg) { Export parseExport(StringRef arg) {
Export E; Export e;
StringRef Rest; StringRef rest;
std::tie(E.Name, Rest) = Arg.split(","); std::tie(e.name, rest) = arg.split(",");
if (E.Name.empty()) if (e.name.empty())
goto err; goto err;
if (E.Name.contains('=')) { if (e.name.contains('=')) {
StringRef X, Y; StringRef x, y;
std::tie(X, Y) = E.Name.split("="); std::tie(x, y) = e.name.split("=");
// If "<name>=<dllname>.<name>". // If "<name>=<dllname>.<name>".
if (Y.contains(".")) { if (y.contains(".")) {
E.Name = X; e.name = x;
E.ForwardTo = Y; e.forwardTo = y;
return E; return e;
} }
E.ExtName = X; e.extName = x;
E.Name = Y; e.name = y;
if (E.Name.empty()) if (e.name.empty())
goto err; goto err;
} }
// If "<name>=<internalname>[,@ordinal[,NONAME]][,DATA][,PRIVATE]" // If "<name>=<internalname>[,@ordinal[,NONAME]][,DATA][,PRIVATE]"
while (!Rest.empty()) { while (!rest.empty()) {
StringRef Tok; StringRef tok;
std::tie(Tok, Rest) = Rest.split(","); std::tie(tok, rest) = rest.split(",");
if (Tok.equals_lower("noname")) { if (tok.equals_lower("noname")) {
if (E.Ordinal == 0) if (e.ordinal == 0)
goto err; goto err;
E.Noname = true; e.noname = true;
continue; continue;
} }
if (Tok.equals_lower("data")) { if (tok.equals_lower("data")) {
E.Data = true; e.data = true;
continue; continue;
} }
if (Tok.equals_lower("constant")) { if (tok.equals_lower("constant")) {
E.Constant = true; e.constant = true;
continue; continue;
} }
if (Tok.equals_lower("private")) { if (tok.equals_lower("private")) {
E.Private = true; e.isPrivate = true;
continue; continue;
} }
if (Tok.startswith("@")) { if (tok.startswith("@")) {
int32_t Ord; int32_t ord;
if (Tok.substr(1).getAsInteger(0, Ord)) if (tok.substr(1).getAsInteger(0, ord))
goto err; goto err;
if (Ord <= 0 || 65535 < Ord) if (ord <= 0 || 65535 < ord)
goto err; goto err;
E.Ordinal = Ord; e.ordinal = ord;
continue; continue;
} }
goto err; goto err;
} }
return E; return e;
err: err:
fatal("invalid /export: " + Arg); fatal("invalid /export: " + arg);
} }
static StringRef undecorate(StringRef Sym) { static StringRef undecorate(StringRef sym) {
if (Config->Machine != I386) if (config->machine != I386)
return Sym; return sym;
// In MSVC mode, a fully decorated stdcall function is exported // In MSVC mode, a fully decorated stdcall function is exported
// as-is with the leading underscore (with type IMPORT_NAME). // as-is with the leading underscore (with type IMPORT_NAME).
// In MinGW mode, a decorated stdcall function gets the underscore // In MinGW mode, a decorated stdcall function gets the underscore
// removed, just like normal cdecl functions. // removed, just like normal cdecl functions.
if (Sym.startswith("_") && Sym.contains('@') && !Config->MinGW) if (sym.startswith("_") && sym.contains('@') && !config->mingw)
return Sym; return sym;
return Sym.startswith("_") ? Sym.substr(1) : Sym; return sym.startswith("_") ? sym.substr(1) : sym;
} }
// Convert stdcall/fastcall style symbols into unsuffixed symbols, // Convert stdcall/fastcall style symbols into unsuffixed symbols,
// with or without a leading underscore. (MinGW specific.) // with or without a leading underscore. (MinGW specific.)
static StringRef killAt(StringRef Sym, bool Prefix) { static StringRef killAt(StringRef sym, bool prefix) {
if (Sym.empty()) if (sym.empty())
return Sym; return sym;
// Strip any trailing stdcall suffix // Strip any trailing stdcall suffix
Sym = Sym.substr(0, Sym.find('@', 1)); sym = sym.substr(0, sym.find('@', 1));
if (!Sym.startswith("@")) { if (!sym.startswith("@")) {
if (Prefix && !Sym.startswith("_")) if (prefix && !sym.startswith("_"))
return Saver.save("_" + Sym); return saver.save("_" + sym);
return Sym; return sym;
} }
// For fastcall, remove the leading @ and replace it with an // For fastcall, remove the leading @ and replace it with an
// underscore, if prefixes are used. // underscore, if prefixes are used.
Sym = Sym.substr(1); sym = sym.substr(1);
if (Prefix) if (prefix)
Sym = Saver.save("_" + Sym); sym = saver.save("_" + sym);
return Sym; return sym;
} }
// Performs error checking on all /export arguments. // Performs error checking on all /export arguments.
// It also sets ordinals. // It also sets ordinals.
void fixupExports() { void fixupExports() {
// Symbol ordinals must be unique. // Symbol ordinals must be unique.
std::set<uint16_t> Ords; std::set<uint16_t> ords;
for (Export &E : Config->Exports) { for (Export &e : config->exports) {
if (E.Ordinal == 0) if (e.ordinal == 0)
continue; continue;
if (!Ords.insert(E.Ordinal).second) if (!ords.insert(e.ordinal).second)
fatal("duplicate export ordinal: " + E.Name); fatal("duplicate export ordinal: " + e.name);
} }
for (Export &E : Config->Exports) { for (Export &e : config->exports) {
if (!E.ForwardTo.empty()) { if (!e.forwardTo.empty()) {
E.ExportName = undecorate(E.Name); e.exportName = undecorate(e.name);
} else { } else {
E.ExportName = undecorate(E.ExtName.empty() ? E.Name : E.ExtName); e.exportName = undecorate(e.extName.empty() ? e.name : e.extName);
} }
} }
if (Config->KillAt && Config->Machine == I386) { if (config->killAt && config->machine == I386) {
for (Export &E : Config->Exports) { for (Export &e : config->exports) {
E.Name = killAt(E.Name, true); e.name = killAt(e.name, true);
E.ExportName = killAt(E.ExportName, false); e.exportName = killAt(e.exportName, false);
E.ExtName = killAt(E.ExtName, true); e.extName = killAt(e.extName, true);
E.SymbolName = killAt(E.SymbolName, true); e.symbolName = killAt(e.symbolName, true);
} }
} }
// Uniquefy by name. // Uniquefy by name.
DenseMap<StringRef, Export *> Map(Config->Exports.size()); DenseMap<StringRef, Export *> map(config->exports.size());
std::vector<Export> V; std::vector<Export> v;
for (Export &E : Config->Exports) { for (Export &e : config->exports) {
auto Pair = Map.insert(std::make_pair(E.ExportName, &E)); auto pair = map.insert(std::make_pair(e.exportName, &e));
bool Inserted = Pair.second; bool inserted = pair.second;
if (Inserted) { if (inserted) {
V.push_back(E); v.push_back(e);
continue; continue;
} }
Export *Existing = Pair.first->second; Export *existing = pair.first->second;
if (E == *Existing || E.Name != Existing->Name) if (e == *existing || e.name != existing->name)
continue; continue;
warn("duplicate /export option: " + E.Name); warn("duplicate /export option: " + e.name);
} }
Config->Exports = std::move(V); config->exports = std::move(v);
// Sort by name. // Sort by name.
std::sort(Config->Exports.begin(), Config->Exports.end(), std::sort(config->exports.begin(), config->exports.end(),
[](const Export &A, const Export &B) { [](const Export &a, const Export &b) {
return A.ExportName < B.ExportName; return a.exportName < b.exportName;
}); });
} }
void assignExportOrdinals() { void assignExportOrdinals() {
// Assign unique ordinals if default (= 0). // Assign unique ordinals if default (= 0).
uint16_t Max = 0; uint16_t max = 0;
for (Export &E : Config->Exports) for (Export &e : config->exports)
Max = std::max(Max, E.Ordinal); max = std::max(max, e.ordinal);
for (Export &E : Config->Exports) for (Export &e : config->exports)
if (E.Ordinal == 0) if (e.ordinal == 0)
E.Ordinal = ++Max; e.ordinal = ++max;
} }
// Parses a string in the form of "key=value" and check // Parses a string in the form of "key=value" and check
// if value matches previous values for the same key. // if value matches previous values for the same key.
void checkFailIfMismatch(StringRef Arg, InputFile *Source) { void checkFailIfMismatch(StringRef arg, InputFile *source) {
StringRef K, V; StringRef k, v;
std::tie(K, V) = Arg.split('='); std::tie(k, v) = arg.split('=');
if (K.empty() || V.empty()) if (k.empty() || v.empty())
fatal("/failifmismatch: invalid argument: " + Arg); fatal("/failifmismatch: invalid argument: " + arg);
std::pair<StringRef, InputFile *> Existing = Config->MustMatch[K]; std::pair<StringRef, InputFile *> existing = config->mustMatch[k];
if (!Existing.first.empty() && V != Existing.first) { if (!existing.first.empty() && v != existing.first) {
std::string SourceStr = Source ? toString(Source) : "cmd-line"; std::string sourceStr = source ? toString(source) : "cmd-line";
std::string ExistingStr = std::string existingStr =
Existing.second ? toString(Existing.second) : "cmd-line"; existing.second ? toString(existing.second) : "cmd-line";
fatal("/failifmismatch: mismatch detected for '" + K + "':\n>>> " + fatal("/failifmismatch: mismatch detected for '" + k + "':\n>>> " +
ExistingStr + " has value " + Existing.first + "\n>>> " + SourceStr + existingStr + " has value " + existing.first + "\n>>> " + sourceStr +
" has value " + V); " has value " + v);
} }
Config->MustMatch[K] = {V, Source}; config->mustMatch[k] = {v, source};
} }
// Convert Windows resource files (.res files) to a .obj file. // Convert Windows resource files (.res files) to a .obj file.
// Does what cvtres.exe does, but in-process and cross-platform. // Does what cvtres.exe does, but in-process and cross-platform.
MemoryBufferRef convertResToCOFF(ArrayRef<MemoryBufferRef> MBs) { MemoryBufferRef convertResToCOFF(ArrayRef<MemoryBufferRef> mbs) {
object::WindowsResourceParser Parser; object::WindowsResourceParser parser;
for (MemoryBufferRef MB : MBs) { for (MemoryBufferRef mb : mbs) {
std::unique_ptr<object::Binary> Bin = check(object::createBinary(MB)); std::unique_ptr<object::Binary> bin = check(object::createBinary(mb));
object::WindowsResource *RF = dyn_cast<object::WindowsResource>(Bin.get()); object::WindowsResource *rf = dyn_cast<object::WindowsResource>(bin.get());
if (!RF) if (!rf)
fatal("cannot compile non-resource file as resource"); fatal("cannot compile non-resource file as resource");
std::vector<std::string> Duplicates; std::vector<std::string> duplicates;
if (auto EC = Parser.parse(RF, Duplicates)) if (auto ec = parser.parse(rf, duplicates))
fatal(toString(std::move(EC))); fatal(toString(std::move(ec)));
for (const auto &DupeDiag : Duplicates) for (const auto &dupeDiag : duplicates)
if (Config->ForceMultipleRes) if (config->forceMultipleRes)
warn(DupeDiag); warn(dupeDiag);
else else
error(DupeDiag); error(dupeDiag);
} }
Expected<std::unique_ptr<MemoryBuffer>> E = Expected<std::unique_ptr<MemoryBuffer>> e =
llvm::object::writeWindowsResourceCOFF(Config->Machine, Parser, llvm::object::writeWindowsResourceCOFF(config->machine, parser,
Config->Timestamp); config->timestamp);
if (!E) if (!e)
fatal("failed to write .res to COFF: " + toString(E.takeError())); fatal("failed to write .res to COFF: " + toString(e.takeError()));
MemoryBufferRef MBRef = **E; MemoryBufferRef mbref = **e;
make<std::unique_ptr<MemoryBuffer>>(std::move(*E)); // take ownership make<std::unique_ptr<MemoryBuffer>>(std::move(*e)); // take ownership
return MBRef; return mbref;
} }
// Create OptTable // Create OptTable
// Create prefix string literals used in Options.td // Create prefix string literals used in Options.td
#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE; #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
#include "Options.inc" #include "Options.inc"
#undef PREFIX #undef PREFIX
// Create table mapping all options defined in Options.td // Create table mapping all options defined in Options.td
static const llvm::opt::OptTable::Info InfoTable[] = { static const llvm::opt::OptTable::Info infoTable[] = {
#define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12) \ #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12) \
{X1, X2, X10, X11, OPT_##ID, llvm::opt::Option::KIND##Class, \ {X1, X2, X10, X11, OPT_##ID, llvm::opt::Option::KIND##Class, \
X9, X8, OPT_##GROUP, OPT_##ALIAS, X7, X12}, X9, X8, OPT_##GROUP, OPT_##ALIAS, X7, X12},
#include "Options.inc" #include "Options.inc"
#undef OPTION #undef OPTION
}; };
COFFOptTable::COFFOptTable() : OptTable(InfoTable, true) {} COFFOptTable::COFFOptTable() : OptTable(infoTable, true) {}
// Set color diagnostics according to --color-diagnostics={auto,always,never} // Set color diagnostics according to --color-diagnostics={auto,always,never}
// or --no-color-diagnostics flags. // or --no-color-diagnostics flags.
static void handleColorDiagnostics(opt::InputArgList &Args) { static void handleColorDiagnostics(opt::InputArgList &args) {
auto *Arg = Args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq, auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
OPT_no_color_diagnostics); OPT_no_color_diagnostics);
if (!Arg) if (!arg)
return; return;
if (Arg->getOption().getID() == OPT_color_diagnostics) { if (arg->getOption().getID() == OPT_color_diagnostics) {
errorHandler().ColorDiagnostics = true; errorHandler().colorDiagnostics = true;
} else if (Arg->getOption().getID() == OPT_no_color_diagnostics) { } else if (arg->getOption().getID() == OPT_no_color_diagnostics) {
errorHandler().ColorDiagnostics = false; errorHandler().colorDiagnostics = false;
} else { } else {
StringRef S = Arg->getValue(); StringRef s = arg->getValue();
if (S == "always") if (s == "always")
errorHandler().ColorDiagnostics = true; errorHandler().colorDiagnostics = true;
else if (S == "never") else if (s == "never")
errorHandler().ColorDiagnostics = false; errorHandler().colorDiagnostics = false;
else if (S != "auto") else if (s != "auto")
error("unknown option: --color-diagnostics=" + S); error("unknown option: --color-diagnostics=" + s);
} }
} }
static cl::TokenizerCallback getQuotingStyle(opt::InputArgList &Args) { static cl::TokenizerCallback getQuotingStyle(opt::InputArgList &args) {
if (auto *Arg = Args.getLastArg(OPT_rsp_quoting)) { if (auto *arg = args.getLastArg(OPT_rsp_quoting)) {
StringRef S = Arg->getValue(); StringRef s = arg->getValue();
if (S != "windows" && S != "posix") if (s != "windows" && s != "posix")
error("invalid response file quoting: " + S); error("invalid response file quoting: " + s);
if (S == "windows") if (s == "windows")
return cl::TokenizeWindowsCommandLine; return cl::TokenizeWindowsCommandLine;
return cl::TokenizeGNUCommandLine; return cl::TokenizeGNUCommandLine;
} }
// The COFF linker always defaults to Windows quoting. // The COFF linker always defaults to Windows quoting.
return cl::TokenizeWindowsCommandLine; return cl::TokenizeWindowsCommandLine;
} }
// Parses a given list of options. // Parses a given list of options.
opt::InputArgList ArgParser::parse(ArrayRef<const char *> Argv) { opt::InputArgList ArgParser::parse(ArrayRef<const char *> argv) {
// Make InputArgList from string vectors. // Make InputArgList from string vectors.
unsigned MissingIndex; unsigned missingIndex;
unsigned MissingCount; unsigned missingCount;
// We need to get the quoting style for response files before parsing all // We need to get the quoting style for response files before parsing all
// options so we parse here before and ignore all the options but // options so we parse here before and ignore all the options but
// --rsp-quoting. // --rsp-quoting.
opt::InputArgList Args = Table.ParseArgs(Argv, MissingIndex, MissingCount); opt::InputArgList args = table.ParseArgs(argv, missingIndex, missingCount);
// Expand response files (arguments in the form of @<filename>) // Expand response files (arguments in the form of @<filename>)
// and then parse the argument again. // and then parse the argument again.
SmallVector<const char *, 256> ExpandedArgv(Argv.data(), SmallVector<const char *, 256> expandedArgv(argv.data(),
Argv.data() + Argv.size()); argv.data() + argv.size());
cl::ExpandResponseFiles(Saver, getQuotingStyle(Args), ExpandedArgv); cl::ExpandResponseFiles(saver, getQuotingStyle(args), expandedArgv);
Args = Table.ParseArgs(makeArrayRef(ExpandedArgv).drop_front(), MissingIndex, args = table.ParseArgs(makeArrayRef(expandedArgv).drop_front(), missingIndex,
MissingCount); missingCount);
// Print the real command line if response files are expanded. // Print the real command line if response files are expanded.
if (Args.hasArg(OPT_verbose) && Argv.size() != ExpandedArgv.size()) { if (args.hasArg(OPT_verbose) && argv.size() != expandedArgv.size()) {
std::string Msg = "Command line:"; std::string msg = "Command line:";
for (const char *S : ExpandedArgv) for (const char *s : expandedArgv)
Msg += " " + std::string(S); msg += " " + std::string(s);
message(Msg); message(msg);
} }
// Save the command line after response file expansion so we can write it to // Save the command line after response file expansion so we can write it to
// the PDB if necessary. // the PDB if necessary.
Config->Argv = {ExpandedArgv.begin(), ExpandedArgv.end()}; config->argv = {expandedArgv.begin(), expandedArgv.end()};
// Handle /WX early since it converts missing argument warnings to errors. // Handle /WX early since it converts missing argument warnings to errors.
errorHandler().FatalWarnings = Args.hasFlag(OPT_WX, OPT_WX_no, false); errorHandler().fatalWarnings = args.hasFlag(OPT_WX, OPT_WX_no, false);
if (MissingCount) if (missingCount)
fatal(Twine(Args.getArgString(MissingIndex)) + ": missing argument"); fatal(Twine(args.getArgString(missingIndex)) + ": missing argument");
handleColorDiagnostics(Args); handleColorDiagnostics(args);
for (auto *Arg : Args.filtered(OPT_UNKNOWN)) { for (auto *arg : args.filtered(OPT_UNKNOWN)) {
std::string Nearest; std::string nearest;
if (Table.findNearest(Arg->getAsString(Args), Nearest) > 1) if (table.findNearest(arg->getAsString(args), nearest) > 1)
warn("ignoring unknown argument '" + Arg->getAsString(Args) + "'"); warn("ignoring unknown argument '" + arg->getAsString(args) + "'");
else else
warn("ignoring unknown argument '" + Arg->getAsString(Args) + warn("ignoring unknown argument '" + arg->getAsString(args) +
"', did you mean '" + Nearest + "'"); "', did you mean '" + nearest + "'");
} }
if (Args.hasArg(OPT_lib)) if (args.hasArg(OPT_lib))
warn("ignoring /lib since it's not the first argument"); warn("ignoring /lib since it's not the first argument");
return Args; return args;
} }
// Tokenizes and parses a given string as command line in .drective section. // Tokenizes and parses a given string as command line in .drective section.
// /EXPORT options are processed in fastpath. // /EXPORT options are processed in fastpath.
std::pair<opt::InputArgList, std::vector<StringRef>> std::pair<opt::InputArgList, std::vector<StringRef>>
ArgParser::parseDirectives(StringRef S) { ArgParser::parseDirectives(StringRef s) {
std::vector<StringRef> Exports; std::vector<StringRef> exports;
SmallVector<const char *, 16> Rest; SmallVector<const char *, 16> rest;
for (StringRef Tok : tokenize(S)) { for (StringRef tok : tokenize(s)) {
if (Tok.startswith_lower("/export:") || Tok.startswith_lower("-export:")) if (tok.startswith_lower("/export:") || tok.startswith_lower("-export:"))
Exports.push_back(Tok.substr(strlen("/export:"))); exports.push_back(tok.substr(strlen("/export:")));
else else
Rest.push_back(Tok.data()); rest.push_back(tok.data());
} }
// Make InputArgList from unparsed string vectors. // Make InputArgList from unparsed string vectors.
unsigned MissingIndex; unsigned missingIndex;
unsigned MissingCount; unsigned missingCount;
opt::InputArgList Args = Table.ParseArgs(Rest, MissingIndex, MissingCount); opt::InputArgList args = table.ParseArgs(rest, missingIndex, missingCount);
if (MissingCount) if (missingCount)
fatal(Twine(Args.getArgString(MissingIndex)) + ": missing argument"); fatal(Twine(args.getArgString(missingIndex)) + ": missing argument");
for (auto *Arg : Args.filtered(OPT_UNKNOWN)) for (auto *arg : args.filtered(OPT_UNKNOWN))
warn("ignoring unknown argument: " + Arg->getAsString(Args)); warn("ignoring unknown argument: " + arg->getAsString(args));
return {std::move(Args), std::move(Exports)}; return {std::move(args), std::move(exports)};
} }
// link.exe has an interesting feature. If LINK or _LINK_ environment // link.exe has an interesting feature. If LINK or _LINK_ environment
// variables exist, their contents are handled as command line strings. // variables exist, their contents are handled as command line strings.
// So you can pass extra arguments using them. // So you can pass extra arguments using them.
opt::InputArgList ArgParser::parseLINK(std::vector<const char *> Argv) { opt::InputArgList ArgParser::parseLINK(std::vector<const char *> argv) {
// Concatenate LINK env and command line arguments, and then parse them. // Concatenate LINK env and command line arguments, and then parse them.
if (Optional<std::string> S = Process::GetEnv("LINK")) { if (Optional<std::string> s = Process::GetEnv("LINK")) {
std::vector<const char *> V = tokenize(*S); std::vector<const char *> v = tokenize(*s);
Argv.insert(std::next(Argv.begin()), V.begin(), V.end()); argv.insert(std::next(argv.begin()), v.begin(), v.end());
} }
if (Optional<std::string> S = Process::GetEnv("_LINK_")) { if (Optional<std::string> s = Process::GetEnv("_LINK_")) {
std::vector<const char *> V = tokenize(*S); std::vector<const char *> v = tokenize(*s);
Argv.insert(std::next(Argv.begin()), V.begin(), V.end()); argv.insert(std::next(argv.begin()), v.begin(), v.end());
} }
return parse(Argv); return parse(argv);
} }
std::vector<const char *> ArgParser::tokenize(StringRef S) { std::vector<const char *> ArgParser::tokenize(StringRef s) {
SmallVector<const char *, 16> Tokens; SmallVector<const char *, 16> tokens;
cl::TokenizeWindowsCommandLine(S, Saver, Tokens); cl::TokenizeWindowsCommandLine(s, saver, tokens);
return std::vector<const char *>(Tokens.begin(), Tokens.end()); return std::vector<const char *>(tokens.begin(), tokens.end());
} }
void printHelp(const char *Argv0) { void printHelp(const char *argv0) {
COFFOptTable().PrintHelp(outs(), COFFOptTable().PrintHelp(outs(),
(std::string(Argv0) + " [options] file...").c_str(), (std::string(argv0) + " [options] file...").c_str(),
"LLVM Linker", false); "LLVM Linker", false);
} }
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld

lld/trunk/COFF/ICF.h

Show All 11 Lines
#include "lld/Common/LLVM.h" #include "lld/Common/LLVM.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
namespace lld { namespace lld {
namespace coff { namespace coff {
class Chunk; class Chunk;
void doICF(ArrayRef<Chunk *> Chunks); void doICF(ArrayRef<Chunk *> chunks);
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/COFF/ICF.cpp

Show All 31 Lines
#include <atomic> #include <atomic>
#include <vector> #include <vector>
using namespace llvm; using namespace llvm;
namespace lld { namespace lld {
namespace coff { namespace coff {
static Timer ICFTimer("ICF", Timer::root()); static Timer icfTimer("ICF", Timer::root());
class ICF { class ICF {
public: public:
void run(ArrayRef<Chunk *> V); void run(ArrayRef<Chunk *> v);
private: private:
void segregate(size_t Begin, size_t End, bool Constant); void segregate(size_t begin, size_t end, bool constant);
bool assocEquals(const SectionChunk *A, const SectionChunk *B); bool assocEquals(const SectionChunk *a, const SectionChunk *b);
bool equalsConstant(const SectionChunk *A, const SectionChunk *B); bool equalsConstant(const SectionChunk *a, const SectionChunk *b);
bool equalsVariable(const SectionChunk *A, const SectionChunk *B); bool equalsVariable(const SectionChunk *a, const SectionChunk *b);
bool isEligible(SectionChunk *C); bool isEligible(SectionChunk *c);
size_t findBoundary(size_t Begin, size_t End); size_t findBoundary(size_t begin, size_t end);
void forEachClassRange(size_t Begin, size_t End, void forEachClassRange(size_t begin, size_t end,
std::function<void(size_t, size_t)> Fn); std::function<void(size_t, size_t)> fn);
void forEachClass(std::function<void(size_t, size_t)> Fn); void forEachClass(std::function<void(size_t, size_t)> fn);
std::vector<SectionChunk *> Chunks; std::vector<SectionChunk *> chunks;
int Cnt = 0; int cnt = 0;
std::atomic<bool> Repeat = {false}; std::atomic<bool> repeat = {false};
}; };
// Returns true if section S is subject of ICF. // Returns true if section S is subject of ICF.
// //
// Microsoft's documentation // Microsoft's documentation
// (https://msdn.microsoft.com/en-us/library/bxwfs976.aspx; visited April // (https://msdn.microsoft.com/en-us/library/bxwfs976.aspx; visited April
// 2017) says that /opt:icf folds both functions and read-only data. // 2017) says that /opt:icf folds both functions and read-only data.
// Despite that, the MSVC linker folds only functions. We found // Despite that, the MSVC linker folds only functions. We found
// a few instances of programs that are not safe for data merging. // a few instances of programs that are not safe for data merging.
// Therefore, we merge only functions just like the MSVC tool. However, we also // Therefore, we merge only functions just like the MSVC tool. However, we also
// merge read-only sections in a couple of cases where the address of the // merge read-only sections in a couple of cases where the address of the
// section is insignificant to the user program and the behaviour matches that // section is insignificant to the user program and the behaviour matches that
// of the Visual C++ linker. // of the Visual C++ linker.
bool ICF::isEligible(SectionChunk *C) { bool ICF::isEligible(SectionChunk *c) {
// Non-comdat chunks, dead chunks, and writable chunks are not elegible. // Non-comdat chunks, dead chunks, and writable chunks are not elegible.
bool Writable = C->getOutputCharacteristics() & llvm::COFF::IMAGE_SCN_MEM_WRITE; bool writable = c->getOutputCharacteristics() & llvm::COFF::IMAGE_SCN_MEM_WRITE;
if (!C->isCOMDAT() || !C->Live || Writable) if (!c->isCOMDAT() || !c->live || writable)
return false; return false;
// Code sections are eligible. // Code sections are eligible.
if (C->getOutputCharacteristics() & llvm::COFF::IMAGE_SCN_MEM_EXECUTE) if (c->getOutputCharacteristics() & llvm::COFF::IMAGE_SCN_MEM_EXECUTE)
return true; return true;
// .pdata and .xdata unwind info sections are eligible. // .pdata and .xdata unwind info sections are eligible.
StringRef OutSecName = C->getSectionName().split('$').first; StringRef outSecName = c->getSectionName().split('$').first;
if (OutSecName == ".pdata" || OutSecName == ".xdata") if (outSecName == ".pdata" || outSecName == ".xdata")
return true; return true;
// So are vtables. // So are vtables.
if (C->Sym && C->Sym->getName().startswith("??_7")) if (c->sym && c->sym->getName().startswith("??_7"))
return true; return true;
// Anything else not in an address-significance table is eligible. // Anything else not in an address-significance table is eligible.
return !C->KeepUnique; return !c->keepUnique;
} }
// Split an equivalence class into smaller classes. // Split an equivalence class into smaller classes.
void ICF::segregate(size_t Begin, size_t End, bool Constant) { void ICF::segregate(size_t begin, size_t end, bool constant) {
while (Begin < End) { while (begin < end) {
// Divide [Begin, End) into two. Let Mid be the start index of the // Divide [Begin, End) into two. Let Mid be the start index of the
// second group. // second group.
auto Bound = std::stable_partition( auto bound = std::stable_partition(
Chunks.begin() + Begin + 1, Chunks.begin() + End, [&](SectionChunk *S) { chunks.begin() + begin + 1, chunks.begin() + end, [&](SectionChunk *s) {
if (Constant) if (constant)
return equalsConstant(Chunks[Begin], S); return equalsConstant(chunks[begin], s);
return equalsVariable(Chunks[Begin], S); return equalsVariable(chunks[begin], s);
}); });
size_t Mid = Bound - Chunks.begin(); size_t mid = bound - chunks.begin();
// Split [Begin, End) into [Begin, Mid) and [Mid, End). We use Mid as an // Split [Begin, End) into [Begin, Mid) and [Mid, End). We use Mid as an
// equivalence class ID because every group ends with a unique index. // equivalence class ID because every group ends with a unique index.
for (size_t I = Begin; I < Mid; ++I) for (size_t i = begin; i < mid; ++i)
Chunks[I]->Class[(Cnt + 1) % 2] = Mid; chunks[i]->eqClass[(cnt + 1) % 2] = mid;
// If we created a group, we need to iterate the main loop again. // If we created a group, we need to iterate the main loop again.
if (Mid != End) if (mid != end)
Repeat = true; repeat = true;
Begin = Mid; begin = mid;
} }
} }
// Returns true if two sections' associative children are equal. // Returns true if two sections' associative children are equal.
bool ICF::assocEquals(const SectionChunk *A, const SectionChunk *B) { bool ICF::assocEquals(const SectionChunk *a, const SectionChunk *b) {
auto ChildClasses = [&](const SectionChunk *SC) { auto childClasses = [&](const SectionChunk *sc) {
std::vector<uint32_t> Classes; std::vector<uint32_t> classes;
for (const SectionChunk &C : SC->children()) for (const SectionChunk &c : sc->children())
if (!C.getSectionName().startswith(".debug") && if (!c.getSectionName().startswith(".debug") &&
C.getSectionName() != ".gfids$y" && C.getSectionName() != ".gljmp$y") c.getSectionName() != ".gfids$y" && c.getSectionName() != ".gljmp$y")
Classes.push_back(C.Class[Cnt % 2]); classes.push_back(c.eqClass[cnt % 2]);
return Classes; return classes;
}; };
return ChildClasses(A) == ChildClasses(B); return childClasses(a) == childClasses(b);
} }
// Compare "non-moving" part of two sections, namely everything // Compare "non-moving" part of two sections, namely everything
// except relocation targets. // except relocation targets.
bool ICF::equalsConstant(const SectionChunk *A, const SectionChunk *B) { bool ICF::equalsConstant(const SectionChunk *a, const SectionChunk *b) {
if (A->RelocsSize != B->RelocsSize) if (a->relocsSize != b->relocsSize)
return false; return false;
// Compare relocations. // Compare relocations.
auto Eq = [&](const coff_relocation &R1, const coff_relocation &R2) { auto eq = [&](const coff_relocation &r1, const coff_relocation &r2) {
if (R1.Type != R2.Type || if (r1.Type != r2.Type ||
R1.VirtualAddress != R2.VirtualAddress) { r1.VirtualAddress != r2.VirtualAddress) {
return false; return false;
} }
Symbol *B1 = A->File->getSymbol(R1.SymbolTableIndex); Symbol *b1 = a->file->getSymbol(r1.SymbolTableIndex);
Symbol *B2 = B->File->getSymbol(R2.SymbolTableIndex); Symbol *b2 = b->file->getSymbol(r2.SymbolTableIndex);
if (B1 == B2) if (b1 == b2)
return true; return true;
if (auto *D1 = dyn_cast<DefinedRegular>(B1)) if (auto *d1 = dyn_cast<DefinedRegular>(b1))
if (auto *D2 = dyn_cast<DefinedRegular>(B2)) if (auto *d2 = dyn_cast<DefinedRegular>(b2))
return D1->getValue() == D2->getValue() && return d1->getValue() == d2->getValue() &&
D1->getChunk()->Class[Cnt % 2] == D2->getChunk()->Class[Cnt % 2]; d1->getChunk()->eqClass[cnt % 2] == d2->getChunk()->eqClass[cnt % 2];
return false; return false;
}; };
if (!std::equal(A->getRelocs().begin(), A->getRelocs().end(), if (!std::equal(a->getRelocs().begin(), a->getRelocs().end(),
B->getRelocs().begin(), Eq)) b->getRelocs().begin(), eq))
return false; return false;
// Compare section attributes and contents. // Compare section attributes and contents.
return A->getOutputCharacteristics() == B->getOutputCharacteristics() && return a->getOutputCharacteristics() == b->getOutputCharacteristics() &&
A->getSectionName() == B->getSectionName() && a->getSectionName() == b->getSectionName() &&
A->Header->SizeOfRawData == B->Header->SizeOfRawData && a->header->SizeOfRawData == b->header->SizeOfRawData &&
A->Checksum == B->Checksum && A->getContents() == B->getContents() && a->checksum == b->checksum && a->getContents() == b->getContents() &&
assocEquals(A, B); assocEquals(a, b);
} }
// Compare "moving" part of two sections, namely relocation targets. // Compare "moving" part of two sections, namely relocation targets.
bool ICF::equalsVariable(const SectionChunk *A, const SectionChunk *B) { bool ICF::equalsVariable(const SectionChunk *a, const SectionChunk *b) {
// Compare relocations. // Compare relocations.
auto Eq = [&](const coff_relocation &R1, const coff_relocation &R2) { auto eq = [&](const coff_relocation &r1, const coff_relocation &r2) {
Symbol *B1 = A->File->getSymbol(R1.SymbolTableIndex); Symbol *b1 = a->file->getSymbol(r1.SymbolTableIndex);
Symbol *B2 = B->File->getSymbol(R2.SymbolTableIndex); Symbol *b2 = b->file->getSymbol(r2.SymbolTableIndex);
if (B1 == B2) if (b1 == b2)
return true; return true;
if (auto *D1 = dyn_cast<DefinedRegular>(B1)) if (auto *d1 = dyn_cast<DefinedRegular>(b1))
if (auto *D2 = dyn_cast<DefinedRegular>(B2)) if (auto *d2 = dyn_cast<DefinedRegular>(b2))
return D1->getChunk()->Class[Cnt % 2] == D2->getChunk()->Class[Cnt % 2]; return d1->getChunk()->eqClass[cnt % 2] == d2->getChunk()->eqClass[cnt % 2];
return false; return false;
}; };
return std::equal(A->getRelocs().begin(), A->getRelocs().end(), return std::equal(a->getRelocs().begin(), a->getRelocs().end(),
B->getRelocs().begin(), Eq) && b->getRelocs().begin(), eq) &&
assocEquals(A, B); assocEquals(a, b);
} }
// Find the first Chunk after Begin that has a different class from Begin. // Find the first Chunk after Begin that has a different class from Begin.
size_t ICF::findBoundary(size_t Begin, size_t End) { size_t ICF::findBoundary(size_t begin, size_t end) {
for (size_t I = Begin + 1; I < End; ++I) for (size_t i = begin + 1; i < end; ++i)
if (Chunks[Begin]->Class[Cnt % 2] != Chunks[I]->Class[Cnt % 2]) if (chunks[begin]->eqClass[cnt % 2] != chunks[i]->eqClass[cnt % 2])
return I; return i;
return End; return end;
} }
void ICF::forEachClassRange(size_t Begin, size_t End, void ICF::forEachClassRange(size_t begin, size_t end,
std::function<void(size_t, size_t)> Fn) { std::function<void(size_t, size_t)> fn) {
while (Begin < End) { while (begin < end) {
size_t Mid = findBoundary(Begin, End); size_t mid = findBoundary(begin, end);
Fn(Begin, Mid); fn(begin, mid);
Begin = Mid; begin = mid;
} }
} }
// Call Fn on each class group. // Call Fn on each class group.
void ICF::forEachClass(std::function<void(size_t, size_t)> Fn) { void ICF::forEachClass(std::function<void(size_t, size_t)> fn) {
// If the number of sections are too small to use threading, // If the number of sections are too small to use threading,
// call Fn sequentially. // call Fn sequentially.
if (Chunks.size() < 1024) { if (chunks.size() < 1024) {
forEachClassRange(0, Chunks.size(), Fn); forEachClassRange(0, chunks.size(), fn);
++Cnt; ++cnt;
return; return;
} }
// Shard into non-overlapping intervals, and call Fn in parallel. // Shard into non-overlapping intervals, and call Fn in parallel.
// The sharding must be completed before any calls to Fn are made // The sharding must be completed before any calls to Fn are made
// so that Fn can modify the Chunks in its shard without causing data // so that Fn can modify the Chunks in its shard without causing data
// races. // races.
const size_t NumShards = 256; const size_t numShards = 256;
size_t Step = Chunks.size() / NumShards; size_t step = chunks.size() / numShards;
size_t Boundaries[NumShards + 1]; size_t boundaries[numShards + 1];
Boundaries[0] = 0; boundaries[0] = 0;
Boundaries[NumShards] = Chunks.size(); boundaries[numShards] = chunks.size();
parallelForEachN(1, NumShards, [&](size_t I) { parallelForEachN(1, numShards, [&](size_t i) {
Boundaries[I] = findBoundary((I - 1) * Step, Chunks.size()); boundaries[i] = findBoundary((i - 1) * step, chunks.size());
}); });
parallelForEachN(1, NumShards + 1, [&](size_t I) { parallelForEachN(1, numShards + 1, [&](size_t i) {
if (Boundaries[I - 1] < Boundaries[I]) { if (boundaries[i - 1] < boundaries[i]) {
forEachClassRange(Boundaries[I - 1], Boundaries[I], Fn); forEachClassRange(boundaries[i - 1], boundaries[i], fn);
} }
}); });
++Cnt; ++cnt;
} }
// Merge identical COMDAT sections. // Merge identical COMDAT sections.
// Two sections are considered the same if their section headers, // Two sections are considered the same if their section headers,
// contents and relocations are all the same. // contents and relocations are all the same.
void ICF::run(ArrayRef<Chunk *> Vec) { void ICF::run(ArrayRef<Chunk *> vec) {
ScopedTimer T(ICFTimer); ScopedTimer t(icfTimer);
// Collect only mergeable sections and group by hash value. // Collect only mergeable sections and group by hash value.
uint32_t NextId = 1; uint32_t nextId = 1;
for (Chunk *C : Vec) { for (Chunk *c : vec) {
if (auto *SC = dyn_cast<SectionChunk>(C)) { if (auto *sc = dyn_cast<SectionChunk>(c)) {
if (isEligible(SC)) if (isEligible(sc))
Chunks.push_back(SC); chunks.push_back(sc);
else else
SC->Class[0] = NextId++; sc->eqClass[0] = nextId++;
} }
} }
// Make sure that ICF doesn't merge sections that are being handled by string // Make sure that ICF doesn't merge sections that are being handled by string
// tail merging. // tail merging.
for (MergeChunk *MC : MergeChunk::Instances) for (MergeChunk *mc : MergeChunk::instances)
if (MC) if (mc)
for (SectionChunk *SC : MC->Sections) for (SectionChunk *sc : mc->sections)
SC->Class[0] = NextId++; sc->eqClass[0] = nextId++;
// Initially, we use hash values to partition sections. // Initially, we use hash values to partition sections.
parallelForEach(Chunks, [&](SectionChunk *SC) { parallelForEach(chunks, [&](SectionChunk *sc) {
SC->Class[0] = xxHash64(SC->getContents()); sc->eqClass[0] = xxHash64(sc->getContents());
}); });
// Combine the hashes of the sections referenced by each section into its // Combine the hashes of the sections referenced by each section into its
// hash. // hash.
for (unsigned Cnt = 0; Cnt != 2; ++Cnt) { for (unsigned cnt = 0; cnt != 2; ++cnt) {
parallelForEach(Chunks, [&](SectionChunk *SC) { parallelForEach(chunks, [&](SectionChunk *sc) {
uint32_t Hash = SC->Class[Cnt % 2]; uint32_t hash = sc->eqClass[cnt % 2];
for (Symbol *B : SC->symbols()) for (Symbol *b : sc->symbols())
if (auto *Sym = dyn_cast_or_null<DefinedRegular>(B)) if (auto *sym = dyn_cast_or_null<DefinedRegular>(b))
Hash += Sym->getChunk()->Class[Cnt % 2]; hash += sym->getChunk()->eqClass[cnt % 2];
// Set MSB to 1 to avoid collisions with non-hash classs. // Set MSB to 1 to avoid collisions with non-hash classs.
SC->Class[(Cnt + 1) % 2] = Hash | (1U << 31); sc->eqClass[(cnt + 1) % 2] = hash | (1U << 31);
}); });
} }
// From now on, sections in Chunks are ordered so that sections in // From now on, sections in Chunks are ordered so that sections in
// the same group are consecutive in the vector. // the same group are consecutive in the vector.
llvm::stable_sort(Chunks, [](const SectionChunk *A, const SectionChunk *B) { llvm::stable_sort(chunks, [](const SectionChunk *a, const SectionChunk *b) {
return A->Class[0] < B->Class[0]; return a->eqClass[0] < b->eqClass[0];
}); });
// Compare static contents and assign unique IDs for each static content. // Compare static contents and assign unique IDs for each static content.
forEachClass([&](size_t Begin, size_t End) { segregate(Begin, End, true); }); forEachClass([&](size_t begin, size_t end) { segregate(begin, end, true); });
// Split groups by comparing relocations until convergence is obtained. // Split groups by comparing relocations until convergence is obtained.
do { do {
Repeat = false; repeat = false;
forEachClass( forEachClass(
[&](size_t Begin, size_t End) { segregate(Begin, End, false); }); [&](size_t begin, size_t end) { segregate(begin, end, false); });
} while (Repeat); } while (repeat);
log("ICF needed " + Twine(Cnt) + " iterations"); log("ICF needed " + Twine(cnt) + " iterations");
// Merge sections in the same classs. // Merge sections in the same classs.
forEachClass([&](size_t Begin, size_t End) { forEachClass([&](size_t begin, size_t end) {
if (End - Begin == 1) if (end - begin == 1)
return; return;
log("Selected " + Chunks[Begin]->getDebugName()); log("Selected " + chunks[begin]->getDebugName());
for (size_t I = Begin + 1; I < End; ++I) { for (size_t i = begin + 1; i < end; ++i) {
log(" Removed " + Chunks[I]->getDebugName()); log(" Removed " + chunks[i]->getDebugName());
Chunks[Begin]->replace(Chunks[I]); chunks[begin]->replace(chunks[i]);
} }
}); });
} }
// Entry point to ICF. // Entry point to ICF.
void doICF(ArrayRef<Chunk *> Chunks) { ICF().run(Chunks); } void doICF(ArrayRef<Chunk *> chunks) { ICF().run(chunks); }
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld

lld/trunk/COFF/InputFiles.h

Show All 26 Lines
namespace pdb { namespace pdb {
class DbiModuleDescriptorBuilder; class DbiModuleDescriptorBuilder;
} }
} }
namespace lld { namespace lld {
namespace coff { namespace coff {
std::vector<MemoryBufferRef> getArchiveMembers(llvm::object::Archive *File); std::vector<MemoryBufferRef> getArchiveMembers(llvm::object::Archive *file);
using llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN; using llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN;
using llvm::COFF::MachineTypes; using llvm::COFF::MachineTypes;
using llvm::object::Archive; using llvm::object::Archive;
using llvm::object::COFFObjectFile; using llvm::object::COFFObjectFile;
using llvm::object::COFFSymbolRef; using llvm::object::COFFSymbolRef;
using llvm::object::coff_import_header; using llvm::object::coff_import_header;
using llvm::object::coff_section; using llvm::object::coff_section;
class Chunk; class Chunk;
class Defined; class Defined;
class DefinedImportData; class DefinedImportData;
class DefinedImportThunk; class DefinedImportThunk;
class DefinedRegular; class DefinedRegular;
class Lazy; class Lazy;
class SectionChunk; class SectionChunk;
class Symbol; class Symbol;
class Undefined; class Undefined;
class TpiSource; class TpiSource;
// The root class of input files. // The root class of input files.
class InputFile { class InputFile {
public: public:
enum Kind { ArchiveKind, ObjectKind, ImportKind, BitcodeKind }; enum Kind { ArchiveKind, ObjectKind, ImportKind, BitcodeKind };
Kind kind() const { return FileKind; } Kind kind() const { return fileKind; }
virtual ~InputFile() {} virtual ~InputFile() {}
// Returns the filename. // Returns the filename.
StringRef getName() const { return MB.getBufferIdentifier(); } StringRef getName() const { return mb.getBufferIdentifier(); }
// Reads a file (the constructor doesn't do that). // Reads a file (the constructor doesn't do that).
virtual void parse() = 0; virtual void parse() = 0;
// Returns the CPU type this file was compiled to. // Returns the CPU type this file was compiled to.
virtual MachineTypes getMachineType() { return IMAGE_FILE_MACHINE_UNKNOWN; } virtual MachineTypes getMachineType() { return IMAGE_FILE_MACHINE_UNKNOWN; }
MemoryBufferRef MB; MemoryBufferRef mb;
// An archive file name if this file is created from an archive. // An archive file name if this file is created from an archive.
StringRef ParentName; StringRef parentName;
// Returns .drectve section contents if exist. // Returns .drectve section contents if exist.
StringRef getDirectives() { return Directives; } StringRef getDirectives() { return directives; }
protected: protected:
InputFile(Kind K, MemoryBufferRef M) : MB(M), FileKind(K) {} InputFile(Kind k, MemoryBufferRef m) : mb(m), fileKind(k) {}
StringRef Directives; StringRef directives;
private: private:
const Kind FileKind; const Kind fileKind;
}; };
// .lib or .a file. // .lib or .a file.
class ArchiveFile : public InputFile { class ArchiveFile : public InputFile {
public: public:
explicit ArchiveFile(MemoryBufferRef M); explicit ArchiveFile(MemoryBufferRef m);
static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; } static bool classof(const InputFile *f) { return f->kind() == ArchiveKind; }
void parse() override; void parse() override;
// Enqueues an archive member load for the given symbol. If we've already // Enqueues an archive member load for the given symbol. If we've already
// enqueued a load for the same archive member, this function does nothing, // enqueued a load for the same archive member, this function does nothing,
// which ensures that we don't load the same member more than once. // which ensures that we don't load the same member more than once.
void addMember(const Archive::Symbol *Sym); void addMember(const Archive::Symbol *sym);
private: private:
std::unique_ptr<Archive> File; std::unique_ptr<Archive> file;
llvm::DenseSet<uint64_t> Seen; llvm::DenseSet<uint64_t> seen;
}; };
// .obj or .o file. This may be a member of an archive file. // .obj or .o file. This may be a member of an archive file.
class ObjFile : public InputFile { class ObjFile : public InputFile {
public: public:
explicit ObjFile(MemoryBufferRef M) : InputFile(ObjectKind, M) {} explicit ObjFile(MemoryBufferRef m) : InputFile(ObjectKind, m) {}
static bool classof(const InputFile *F) { return F->kind() == ObjectKind; } static bool classof(const InputFile *f) { return f->kind() == ObjectKind; }
void parse() override; void parse() override;
MachineTypes getMachineType() override; MachineTypes getMachineType() override;
ArrayRef<Chunk *> getChunks() { return Chunks; } ArrayRef<Chunk *> getChunks() { return chunks; }
ArrayRef<SectionChunk *> getDebugChunks() { return DebugChunks; } ArrayRef<SectionChunk *> getDebugChunks() { return debugChunks; }
ArrayRef<SectionChunk *> getSXDataChunks() { return SXDataChunks; } ArrayRef<SectionChunk *> getSXDataChunks() { return sXDataChunks; }
ArrayRef<SectionChunk *> getGuardFidChunks() { return GuardFidChunks; } ArrayRef<SectionChunk *> getGuardFidChunks() { return guardFidChunks; }
ArrayRef<SectionChunk *> getGuardLJmpChunks() { return GuardLJmpChunks; } ArrayRef<SectionChunk *> getGuardLJmpChunks() { return guardLJmpChunks; }
ArrayRef<Symbol *> getSymbols() { return Symbols; } ArrayRef<Symbol *> getSymbols() { return symbols; }
ArrayRef<uint8_t> getDebugSection(StringRef SecName); ArrayRef<uint8_t> getDebugSection(StringRef secName);
// Returns a Symbol object for the SymbolIndex'th symbol in the // Returns a Symbol object for the SymbolIndex'th symbol in the
// underlying object file. // underlying object file.
Symbol *getSymbol(uint32_t SymbolIndex) { Symbol *getSymbol(uint32_t symbolIndex) {
return Symbols[SymbolIndex]; return symbols[symbolIndex];
} }
// Returns the underlying COFF file. // Returns the underlying COFF file.
COFFObjectFile *getCOFFObj() { return COFFObj.get(); } COFFObjectFile *getCOFFObj() { return coffObj.get(); }
// Add a symbol for a range extension thunk. Return the new symbol table // Add a symbol for a range extension thunk. Return the new symbol table
// index. This index can be used to modify a relocation. // index. This index can be used to modify a relocation.
uint32_t addRangeThunkSymbol(Symbol *Thunk) { uint32_t addRangeThunkSymbol(Symbol *thunk) {
Symbols.push_back(Thunk); symbols.push_back(thunk);
return Symbols.size() - 1; return symbols.size() - 1;
} }
static std::vector<ObjFile *> Instances; static std::vector<ObjFile *> instances;
// Flags in the absolute @feat.00 symbol if it is present. These usually // Flags in the absolute @feat.00 symbol if it is present. These usually
// indicate if an object was compiled with certain security features enabled // indicate if an object was compiled with certain security features enabled
// like stack guard, safeseh, /guard:cf, or other things. // like stack guard, safeseh, /guard:cf, or other things.
uint32_t Feat00Flags = 0; uint32_t feat00Flags = 0;
// True if this object file is compatible with SEH. COFF-specific and // True if this object file is compatible with SEH. COFF-specific and
// x86-only. COFF spec 5.10.1. The .sxdata section. // x86-only. COFF spec 5.10.1. The .sxdata section.
bool hasSafeSEH() { return Feat00Flags & 0x1; } bool hasSafeSEH() { return feat00Flags & 0x1; }
// True if this file was compiled with /guard:cf. // True if this file was compiled with /guard:cf.
bool hasGuardCF() { return Feat00Flags & 0x800; } bool hasGuardCF() { return feat00Flags & 0x800; }
// Pointer to the PDB module descriptor builder. Various debug info records // Pointer to the PDB module descriptor builder. Various debug info records
// will reference object files by "module index", which is here. Things like // will reference object files by "module index", which is here. Things like
// source files and section contributions are also recorded here. Will be null // source files and section contributions are also recorded here. Will be null
// if we are not producing a PDB. // if we are not producing a PDB.
llvm::pdb::DbiModuleDescriptorBuilder *ModuleDBI = nullptr; llvm::pdb::DbiModuleDescriptorBuilder *moduleDBI = nullptr;
const coff_section *AddrsigSec = nullptr; const coff_section *addrsigSec = nullptr;
// When using Microsoft precompiled headers, this is the PCH's key. // When using Microsoft precompiled headers, this is the PCH's key.
// The same key is used by both the precompiled object, and objects using the // The same key is used by both the precompiled object, and objects using the
// precompiled object. Any difference indicates out-of-date objects. // precompiled object. Any difference indicates out-of-date objects.
llvm::Optional<uint32_t> PCHSignature; llvm::Optional<uint32_t> pchSignature;
// Whether this is an object file created from .res files. // Whether this is an object file created from .res files.
bool IsResourceObjFile = false; bool isResourceObjFile = false;
// Whether this file was compiled with /hotpatch. // Whether this file was compiled with /hotpatch.
bool HotPatchable = false; bool hotPatchable = false;
// Whether the object was already merged into the final PDB. // Whether the object was already merged into the final PDB.
bool MergedIntoPDB = false; bool mergedIntoPDB = false;
// If the OBJ has a .debug$T stream, this tells how it will be handled. // If the OBJ has a .debug$T stream, this tells how it will be handled.
TpiSource *DebugTypesObj = nullptr; TpiSource *debugTypesObj = nullptr;
// The .debug$T stream if there's one. // The .debug$T stream if there's one.
llvm::Optional<llvm::codeview::CVTypeArray> DebugTypes; llvm::Optional<llvm::codeview::CVTypeArray> debugTypes;
private: private:
const coff_section* getSection(uint32_t I); const coff_section* getSection(uint32_t i);
const coff_section *getSection(COFFSymbolRef Sym) { const coff_section *getSection(COFFSymbolRef sym) {
return getSection(Sym.getSectionNumber()); return getSection(sym.getSectionNumber());
} }
void initializeChunks(); void initializeChunks();
void initializeSymbols(); void initializeSymbols();
void initializeFlags(); void initializeFlags();
void initializeDependencies(); void initializeDependencies();
SectionChunk * SectionChunk *
readSection(uint32_t SectionNumber, readSection(uint32_t sectionNumber,
const llvm::object::coff_aux_section_definition *Def, const llvm::object::coff_aux_section_definition *def,
StringRef LeaderName); StringRef leaderName);
void readAssociativeDefinition( void readAssociativeDefinition(
COFFSymbolRef COFFSym, COFFSymbolRef coffSym,
const llvm::object::coff_aux_section_definition *Def); const llvm::object::coff_aux_section_definition *def);
void readAssociativeDefinition( void readAssociativeDefinition(
COFFSymbolRef COFFSym, COFFSymbolRef coffSym,
const llvm::object::coff_aux_section_definition *Def, const llvm::object::coff_aux_section_definition *def,
uint32_t ParentSection); uint32_t parentSection);
void recordPrevailingSymbolForMingw( void recordPrevailingSymbolForMingw(
COFFSymbolRef COFFSym, COFFSymbolRef coffSym,
llvm::DenseMap<StringRef, uint32_t> &PrevailingSectionMap); llvm::DenseMap<StringRef, uint32_t> &prevailingSectionMap);
void maybeAssociateSEHForMingw( void maybeAssociateSEHForMingw(
COFFSymbolRef Sym, const llvm::object::coff_aux_section_definition *Def, COFFSymbolRef sym, const llvm::object::coff_aux_section_definition *def,
const llvm::DenseMap<StringRef, uint32_t> &PrevailingSectionMap); const llvm::DenseMap<StringRef, uint32_t> &prevailingSectionMap);
// Given a new symbol Sym with comdat selection Selection, if the new // Given a new symbol Sym with comdat selection Selection, if the new
// symbol is not (yet) Prevailing and the existing comdat leader set to // symbol is not (yet) Prevailing and the existing comdat leader set to
// Leader, emits a diagnostic if the new symbol and its selection doesn't // Leader, emits a diagnostic if the new symbol and its selection doesn't
// match the existing symbol and its selection. If either old or new // match the existing symbol and its selection. If either old or new
// symbol have selection IMAGE_COMDAT_SELECT_LARGEST, Sym might replace // symbol have selection IMAGE_COMDAT_SELECT_LARGEST, Sym might replace
// the existing leader. In that case, Prevailing is set to true. // the existing leader. In that case, Prevailing is set to true.
void handleComdatSelection(COFFSymbolRef Sym, void handleComdatSelection(COFFSymbolRef sym,
llvm::COFF::COMDATType &Selection, llvm::COFF::COMDATType &selection,
bool &Prevailing, DefinedRegular *Leader); bool &prevailing, DefinedRegular *leader);
llvm::Optional<Symbol *> llvm::Optional<Symbol *>
createDefined(COFFSymbolRef Sym, createDefined(COFFSymbolRef sym,
std::vector<const llvm::object::coff_aux_section_definition *> std::vector<const llvm::object::coff_aux_section_definition *>
&ComdatDefs, &comdatDefs,
bool &PrevailingComdat); bool &prevailingComdat);
Symbol *createRegular(COFFSymbolRef Sym); Symbol *createRegular(COFFSymbolRef sym);
Symbol *createUndefined(COFFSymbolRef Sym); Symbol *createUndefined(COFFSymbolRef sym);
std::unique_ptr<COFFObjectFile> COFFObj; std::unique_ptr<COFFObjectFile> coffObj;
// List of all chunks defined by this file. This includes both section // List of all chunks defined by this file. This includes both section
// chunks and non-section chunks for common symbols. // chunks and non-section chunks for common symbols.
std::vector<Chunk *> Chunks; std::vector<Chunk *> chunks;
// CodeView debug info sections. // CodeView debug info sections.
std::vector<SectionChunk *> DebugChunks; std::vector<SectionChunk *> debugChunks;
// Chunks containing symbol table indices of exception handlers. Only used for // Chunks containing symbol table indices of exception handlers. Only used for
// 32-bit x86. // 32-bit x86.
std::vector<SectionChunk *> SXDataChunks; std::vector<SectionChunk *> sXDataChunks;
// Chunks containing symbol table indices of address taken symbols and longjmp // Chunks containing symbol table indices of address taken symbols and longjmp
// targets. These are not linked into the final binary when /guard:cf is set. // targets. These are not linked into the final binary when /guard:cf is set.
std::vector<SectionChunk *> GuardFidChunks; std::vector<SectionChunk *> guardFidChunks;
std::vector<SectionChunk *> GuardLJmpChunks; std::vector<SectionChunk *> guardLJmpChunks;
// This vector contains the same chunks as Chunks, but they are // This vector contains the same chunks as Chunks, but they are
// indexed such that you can get a SectionChunk by section index. // indexed such that you can get a SectionChunk by section index.
// Nonexistent section indices are filled with null pointers. // Nonexistent section indices are filled with null pointers.
// (Because section number is 1-based, the first slot is always a // (Because section number is 1-based, the first slot is always a
// null pointer.) // null pointer.)
std::vector<SectionChunk *> SparseChunks; std::vector<SectionChunk *> sparseChunks;
// This vector contains a list of all symbols defined or referenced by this // This vector contains a list of all symbols defined or referenced by this
// file. They are indexed such that you can get a Symbol by symbol // file. They are indexed such that you can get a Symbol by symbol
// index. Nonexistent indices (which are occupied by auxiliary // index. Nonexistent indices (which are occupied by auxiliary
// symbols in the real symbol table) are filled with null pointers. // symbols in the real symbol table) are filled with null pointers.
std::vector<Symbol *> Symbols; std::vector<Symbol *> symbols;
}; };
// This type represents import library members that contain DLL names // This type represents import library members that contain DLL names
// and symbols exported from the DLLs. See Microsoft PE/COFF spec. 7 // and symbols exported from the DLLs. See Microsoft PE/COFF spec. 7
// for details about the format. // for details about the format.
class ImportFile : public InputFile { class ImportFile : public InputFile {
public: public:
explicit ImportFile(MemoryBufferRef M) : InputFile(ImportKind, M) {} explicit ImportFile(MemoryBufferRef m) : InputFile(ImportKind, m) {}
static bool classof(const InputFile *F) { return F->kind() == ImportKind; } static bool classof(const InputFile *f) { return f->kind() == ImportKind; }
static std::vector<ImportFile *> Instances; static std::vector<ImportFile *> instances;
Symbol *ImpSym = nullptr; Symbol *impSym = nullptr;
Symbol *ThunkSym = nullptr; Symbol *thunkSym = nullptr;
std::string DLLName; std::string dllName;
private: private:
void parse() override; void parse() override;
public: public:
StringRef ExternalName; StringRef externalName;
const coff_import_header *Hdr; const coff_import_header *hdr;
Chunk *Location = nullptr; Chunk *location = nullptr;
// We want to eliminate dllimported symbols if no one actually refers them. // We want to eliminate dllimported symbols if no one actually refers them.
// These "Live" bits are used to keep track of which import library members // These "Live" bits are used to keep track of which import library members
// are actually in use. // are actually in use.
// //
// If the Live bit is turned off by MarkLive, Writer will ignore dllimported // If the Live bit is turned off by MarkLive, Writer will ignore dllimported
// symbols provided by this import library member. We also track whether the // symbols provided by this import library member. We also track whether the
// imported symbol is used separately from whether the thunk is used in order // imported symbol is used separately from whether the thunk is used in order
// to avoid creating unnecessary thunks. // to avoid creating unnecessary thunks.
bool Live = !Config->DoGC; bool live = !config->doGC;
bool ThunkLive = !Config->DoGC; bool thunkLive = !config->doGC;
}; };
// Used for LTO. // Used for LTO.
class BitcodeFile : public InputFile { class BitcodeFile : public InputFile {
public: public:
BitcodeFile(MemoryBufferRef MB, StringRef ArchiveName, BitcodeFile(MemoryBufferRef mb, StringRef archiveName,
uint64_t OffsetInArchive); uint64_t offsetInArchive);
static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; } static bool classof(const InputFile *f) { return f->kind() == BitcodeKind; }
ArrayRef<Symbol *> getSymbols() { return Symbols; } ArrayRef<Symbol *> getSymbols() { return symbols; }
MachineTypes getMachineType() override; MachineTypes getMachineType() override;
static std::vector<BitcodeFile *> Instances; static std::vector<BitcodeFile *> instances;
std::unique_ptr<llvm::lto::InputFile> Obj; std::unique_ptr<llvm::lto::InputFile> obj;
private: private:
void parse() override; void parse() override;
std::vector<Symbol *> Symbols; std::vector<Symbol *> symbols;
}; };
} // namespace coff } // namespace coff
std::string toString(const coff::InputFile *File); std::string toString(const coff::InputFile *file);
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/COFF/InputFiles.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
using namespace llvm::support::endian; using namespace llvm::support::endian;
using llvm::Triple; using llvm::Triple;
using llvm::support::ulittle32_t; using llvm::support::ulittle32_t;
namespace lld { namespace lld {
namespace coff { namespace coff {
std::vector<ObjFile *> ObjFile::Instances; std::vector<ObjFile *> ObjFile::instances;
std::vector<ImportFile *> ImportFile::Instances; std::vector<ImportFile *> ImportFile::instances;
std::vector<BitcodeFile *> BitcodeFile::Instances; std::vector<BitcodeFile *> BitcodeFile::instances;
/// Checks that Source is compatible with being a weak alias to Target. /// Checks that Source is compatible with being a weak alias to Target.
/// If Source is Undefined and has no weak alias set, makes it a weak /// If Source is Undefined and has no weak alias set, makes it a weak
/// alias to Target. /// alias to Target.
static void checkAndSetWeakAlias(SymbolTable *Symtab, InputFile *F, static void checkAndSetWeakAlias(SymbolTable *symtab, InputFile *f,
Symbol *Source, Symbol *Target) { Symbol *source, Symbol *target) {
if (auto *U = dyn_cast<Undefined>(Source)) { if (auto *u = dyn_cast<Undefined>(source)) {
if (U->WeakAlias && U->WeakAlias != Target) { if (u->weakAlias && u->weakAlias != target) {
// Weak aliases as produced by GCC are named in the form // Weak aliases as produced by GCC are named in the form
// .weak.<weaksymbol>.<othersymbol>, where <othersymbol> is the name // .weak.<weaksymbol>.<othersymbol>, where <othersymbol> is the name
// of another symbol emitted near the weak symbol. // of another symbol emitted near the weak symbol.
// Just use the definition from the first object file that defined // Just use the definition from the first object file that defined
// this weak symbol. // this weak symbol.
if (Config->MinGW) if (config->mingw)
return; return;
Symtab->reportDuplicate(Source, F); symtab->reportDuplicate(source, f);
} }
U->WeakAlias = Target; u->weakAlias = target;
} }
} }
ArchiveFile::ArchiveFile(MemoryBufferRef M) : InputFile(ArchiveKind, M) {} ArchiveFile::ArchiveFile(MemoryBufferRef m) : InputFile(ArchiveKind, m) {}
void ArchiveFile::parse() { void ArchiveFile::parse() {
// Parse a MemoryBufferRef as an archive file. // Parse a MemoryBufferRef as an archive file.
File = CHECK(Archive::create(MB), this); file = CHECK(Archive::create(mb), this);
// Read the symbol table to construct Lazy objects. // Read the symbol table to construct Lazy objects.
for (const Archive::Symbol &Sym : File->symbols()) for (const Archive::Symbol &sym : file->symbols())
Symtab->addLazy(this, Sym); symtab->addLazy(this, sym);
} }
// Returns a buffer pointing to a member file containing a given symbol. // Returns a buffer pointing to a member file containing a given symbol.
void ArchiveFile::addMember(const Archive::Symbol *Sym) { void ArchiveFile::addMember(const Archive::Symbol *sym) {
const Archive::Child &C = const Archive::Child &c =
CHECK(Sym->getMember(), CHECK(sym->getMember(),
"could not get the member for symbol " + Sym->getName()); "could not get the member for symbol " + sym->getName());
// Return an empty buffer if we have already returned the same buffer. // Return an empty buffer if we have already returned the same buffer.
if (!Seen.insert(C.getChildOffset()).second) if (!seen.insert(c.getChildOffset()).second)
return; return;
Driver->enqueueArchiveMember(C, Sym->getName(), getName()); driver->enqueueArchiveMember(c, sym->getName(), getName());
} }
std::vector<MemoryBufferRef> getArchiveMembers(Archive *File) { std::vector<MemoryBufferRef> getArchiveMembers(Archive *file) {
std::vector<MemoryBufferRef> V; std::vector<MemoryBufferRef> v;
Error Err = Error::success(); Error err = Error::success();
for (const ErrorOr<Archive::Child> &COrErr : File->children(Err)) { for (const ErrorOr<Archive::Child> &cOrErr : file->children(err)) {
Archive::Child C = Archive::Child c =
CHECK(COrErr, CHECK(cOrErr,
File->getFileName() + ": could not get the child of the archive"); file->getFileName() + ": could not get the child of the archive");
MemoryBufferRef MBRef = MemoryBufferRef mbref =
CHECK(C.getMemoryBufferRef(), CHECK(c.getMemoryBufferRef(),
File->getFileName() + file->getFileName() +
": could not get the buffer for a child of the archive"); ": could not get the buffer for a child of the archive");
V.push_back(MBRef); v.push_back(mbref);
} }
if (Err) if (err)
fatal(File->getFileName() + fatal(file->getFileName() +
": Archive::children failed: " + toString(std::move(Err))); ": Archive::children failed: " + toString(std::move(err)));
return V; return v;
} }
void ObjFile::parse() { void ObjFile::parse() {
// Parse a memory buffer as a COFF file. // Parse a memory buffer as a COFF file.
std::unique_ptr<Binary> Bin = CHECK(createBinary(MB), this); std::unique_ptr<Binary> bin = CHECK(createBinary(mb), this);
if (auto *Obj = dyn_cast<COFFObjectFile>(Bin.get())) { if (auto *obj = dyn_cast<COFFObjectFile>(bin.get())) {
Bin.release(); bin.release();
COFFObj.reset(Obj); coffObj.reset(obj);
} else { } else {
fatal(toString(this) + " is not a COFF file"); fatal(toString(this) + " is not a COFF file");
} }
// Read section and symbol tables. // Read section and symbol tables.
initializeChunks(); initializeChunks();
initializeSymbols(); initializeSymbols();
initializeFlags(); initializeFlags();
initializeDependencies(); initializeDependencies();
} }
const coff_section* ObjFile::getSection(uint32_t I) { const coff_section* ObjFile::getSection(uint32_t i) {
const coff_section *Sec; const coff_section *sec;
if (auto EC = COFFObj->getSection(I, Sec)) if (auto ec = coffObj->getSection(i, sec))
fatal("getSection failed: #" + Twine(I) + ": " + EC.message()); fatal("getSection failed: #" + Twine(i) + ": " + ec.message());
return Sec; return sec;
} }
// We set SectionChunk pointers in the SparseChunks vector to this value // We set SectionChunk pointers in the SparseChunks vector to this value
// temporarily to mark comdat sections as having an unknown resolution. As we // temporarily to mark comdat sections as having an unknown resolution. As we
// walk the object file's symbol table, once we visit either a leader symbol or // walk the object file's symbol table, once we visit either a leader symbol or
// an associative section definition together with the parent comdat's leader, // an associative section definition together with the parent comdat's leader,
// we set the pointer to either nullptr (to mark the section as discarded) or a // we set the pointer to either nullptr (to mark the section as discarded) or a
// valid SectionChunk for that section. // valid SectionChunk for that section.
static SectionChunk *const PendingComdat = reinterpret_cast<SectionChunk *>(1); static SectionChunk *const pendingComdat = reinterpret_cast<SectionChunk *>(1);
void ObjFile::initializeChunks() { void ObjFile::initializeChunks() {
uint32_t NumSections = COFFObj->getNumberOfSections(); uint32_t numSections = coffObj->getNumberOfSections();
Chunks.reserve(NumSections); chunks.reserve(numSections);
SparseChunks.resize(NumSections + 1); sparseChunks.resize(numSections + 1);
for (uint32_t I = 1; I < NumSections + 1; ++I) { for (uint32_t i = 1; i < numSections + 1; ++i) {
const coff_section *Sec = getSection(I); const coff_section *sec = getSection(i);
if (Sec->Characteristics & IMAGE_SCN_LNK_COMDAT) if (sec->Characteristics & IMAGE_SCN_LNK_COMDAT)
SparseChunks[I] = PendingComdat; sparseChunks[i] = pendingComdat;
else else
SparseChunks[I] = readSection(I, nullptr, ""); sparseChunks[i] = readSection(i, nullptr, "");
} }
} }
SectionChunk *ObjFile::readSection(uint32_t SectionNumber, SectionChunk *ObjFile::readSection(uint32_t sectionNumber,
const coff_aux_section_definition *Def, const coff_aux_section_definition *def,
StringRef LeaderName) { StringRef leaderName) {
const coff_section *Sec = getSection(SectionNumber); const coff_section *sec = getSection(sectionNumber);
StringRef Name; StringRef name;
if (Expected<StringRef> E = COFFObj->getSectionName(Sec)) if (Expected<StringRef> e = coffObj->getSectionName(sec))
Name = *E; name = *e;
else else
fatal("getSectionName failed: #" + Twine(SectionNumber) + ": " + fatal("getSectionName failed: #" + Twine(sectionNumber) + ": " +
toString(E.takeError())); toString(e.takeError()));
if (Name == ".drectve") { if (name == ".drectve") {
ArrayRef<uint8_t> Data; ArrayRef<uint8_t> data;
cantFail(COFFObj->getSectionContents(Sec, Data)); cantFail(coffObj->getSectionContents(sec, data));
Directives = StringRef((const char *)Data.data(), Data.size()); directives = StringRef((const char *)data.data(), data.size());
return nullptr; return nullptr;
} }
if (Name == ".llvm_addrsig") { if (name == ".llvm_addrsig") {
AddrsigSec = Sec; addrsigSec = sec;
return nullptr; return nullptr;
} }
// Object files may have DWARF debug info or MS CodeView debug info // Object files may have DWARF debug info or MS CodeView debug info
// (or both). // (or both).
// //
// DWARF sections don't need any special handling from the perspective // DWARF sections don't need any special handling from the perspective
// of the linker; they are just a data section containing relocations. // of the linker; they are just a data section containing relocations.
// We can just link them to complete debug info. // We can just link them to complete debug info.
// //
// CodeView needs linker support. We need to interpret debug info, // CodeView needs linker support. We need to interpret debug info,
// and then write it to a separate .pdb file. // and then write it to a separate .pdb file.
// Ignore DWARF debug info unless /debug is given. // Ignore DWARF debug info unless /debug is given.
if (!Config->Debug && Name.startswith(".debug_")) if (!config->debug && name.startswith(".debug_"))
return nullptr; return nullptr;
if (Sec->Characteristics & llvm::COFF::IMAGE_SCN_LNK_REMOVE) if (sec->Characteristics & llvm::COFF::IMAGE_SCN_LNK_REMOVE)
return nullptr; return nullptr;
auto *C = make<SectionChunk>(this, Sec); auto *c = make<SectionChunk>(this, sec);
if (Def) if (def)
C->Checksum = Def->CheckSum; c->checksum = def->CheckSum;
// link.exe uses the presence of .rsrc$01 for LNK4078, so match that. // link.exe uses the presence of .rsrc$01 for LNK4078, so match that.
if (Name == ".rsrc$01") if (name == ".rsrc$01")
IsResourceObjFile = true; isResourceObjFile = true;
// CodeView sections are stored to a different vector because they are not // CodeView sections are stored to a different vector because they are not
// linked in the regular manner. // linked in the regular manner.
if (C->isCodeView()) if (c->isCodeView())
DebugChunks.push_back(C); debugChunks.push_back(c);
else if (Name == ".gfids$y") else if (name == ".gfids$y")
GuardFidChunks.push_back(C); guardFidChunks.push_back(c);
else if (Name == ".gljmp$y") else if (name == ".gljmp$y")
GuardLJmpChunks.push_back(C); guardLJmpChunks.push_back(c);
else if (Name == ".sxdata") else if (name == ".sxdata")
SXDataChunks.push_back(C); sXDataChunks.push_back(c);
else if (Config->TailMerge && Sec->NumberOfRelocations == 0 && else if (config->tailMerge && sec->NumberOfRelocations == 0 &&
Name == ".rdata" && LeaderName.startswith("??_C@")) name == ".rdata" && leaderName.startswith("??_C@"))
// COFF sections that look like string literal sections (i.e. no // COFF sections that look like string literal sections (i.e. no
// relocations, in .rdata, leader symbol name matches the MSVC name mangling // relocations, in .rdata, leader symbol name matches the MSVC name mangling
// for string literals) are subject to string tail merging. // for string literals) are subject to string tail merging.
MergeChunk::addSection(C); MergeChunk::addSection(c);
else else
Chunks.push_back(C); chunks.push_back(c);
return C; return c;
} }
void ObjFile::readAssociativeDefinition( void ObjFile::readAssociativeDefinition(
COFFSymbolRef Sym, const coff_aux_section_definition *Def) { COFFSymbolRef sym, const coff_aux_section_definition *def) {
readAssociativeDefinition(Sym, Def, Def->getNumber(Sym.isBigObj())); readAssociativeDefinition(sym, def, def->getNumber(sym.isBigObj()));
} }
void ObjFile::readAssociativeDefinition(COFFSymbolRef Sym, void ObjFile::readAssociativeDefinition(COFFSymbolRef sym,
const coff_aux_section_definition *Def, const coff_aux_section_definition *def,
uint32_t ParentIndex) { uint32_t parentIndex) {
SectionChunk *Parent = SparseChunks[ParentIndex]; SectionChunk *parent = sparseChunks[parentIndex];
int32_t SectionNumber = Sym.getSectionNumber(); int32_t sectionNumber = sym.getSectionNumber();
auto Diag = [&]() { auto diag = [&]() {
StringRef Name, ParentName; StringRef name, parentName;
COFFObj->getSymbolName(Sym, Name); coffObj->getSymbolName(sym, name);
const coff_section *ParentSec = getSection(ParentIndex); const coff_section *parentSec = getSection(parentIndex);
if (Expected<StringRef> E = COFFObj->getSectionName(ParentSec)) if (Expected<StringRef> e = coffObj->getSectionName(parentSec))
ParentName = *E; parentName = *e;
error(toString(this) + ": associative comdat " + Name + " (sec " + error(toString(this) + ": associative comdat " + name + " (sec " +
Twine(SectionNumber) + ") has invalid reference to section " + Twine(sectionNumber) + ") has invalid reference to section " +
ParentName + " (sec " + Twine(ParentIndex) + ")"); parentName + " (sec " + Twine(parentIndex) + ")");
}; };
if (Parent == PendingComdat) { if (parent == pendingComdat) {
// This can happen if an associative comdat refers to another associative // This can happen if an associative comdat refers to another associative
// comdat that appears after it (invalid per COFF spec) or to a section // comdat that appears after it (invalid per COFF spec) or to a section
// without any symbols. // without any symbols.
Diag(); diag();
return; return;
} }
// Check whether the parent is prevailing. If it is, so are we, and we read // Check whether the parent is prevailing. If it is, so are we, and we read
// the section; otherwise mark it as discarded. // the section; otherwise mark it as discarded.
if (Parent) { if (parent) {
SectionChunk *C = readSection(SectionNumber, Def, ""); SectionChunk *c = readSection(sectionNumber, def, "");
SparseChunks[SectionNumber] = C; sparseChunks[sectionNumber] = c;
if (C) { if (c) {
C->Selection = IMAGE_COMDAT_SELECT_ASSOCIATIVE; c->selection = IMAGE_COMDAT_SELECT_ASSOCIATIVE;
Parent->addAssociative(C); parent->addAssociative(c);
} }
} else { } else {
SparseChunks[SectionNumber] = nullptr; sparseChunks[sectionNumber] = nullptr;
} }
} }
void ObjFile::recordPrevailingSymbolForMingw( void ObjFile::recordPrevailingSymbolForMingw(
COFFSymbolRef Sym, DenseMap<StringRef, uint32_t> &PrevailingSectionMap) { COFFSymbolRef sym, DenseMap<StringRef, uint32_t> &prevailingSectionMap) {
// For comdat symbols in executable sections, where this is the copy // For comdat symbols in executable sections, where this is the copy
// of the section chunk we actually include instead of discarding it, // of the section chunk we actually include instead of discarding it,
// add the symbol to a map to allow using it for implicitly // add the symbol to a map to allow using it for implicitly
// associating .[px]data$<func> sections to it. // associating .[px]data$<func> sections to it.
int32_t SectionNumber = Sym.getSectionNumber(); int32_t sectionNumber = sym.getSectionNumber();
SectionChunk *SC = SparseChunks[SectionNumber]; SectionChunk *sc = sparseChunks[sectionNumber];
if (SC && SC->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE) { if (sc && sc->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE) {
StringRef Name; StringRef name;
COFFObj->getSymbolName(Sym, Name); coffObj->getSymbolName(sym, name);
if (getMachineType() == I386) if (getMachineType() == I386)
Name.consume_front("_"); name.consume_front("_");
PrevailingSectionMap[Name] = SectionNumber; prevailingSectionMap[name] = sectionNumber;
} }
} }
void ObjFile::maybeAssociateSEHForMingw( void ObjFile::maybeAssociateSEHForMingw(
COFFSymbolRef Sym, const coff_aux_section_definition *Def, COFFSymbolRef sym, const coff_aux_section_definition *def,
const DenseMap<StringRef, uint32_t> &PrevailingSectionMap) { const DenseMap<StringRef, uint32_t> &prevailingSectionMap) {
StringRef Name; StringRef name;
COFFObj->getSymbolName(Sym, Name); coffObj->getSymbolName(sym, name);
if (Name.consume_front(".pdata$") || Name.consume_front(".xdata$") || if (name.consume_front(".pdata$") || name.consume_front(".xdata$") ||
Name.consume_front(".eh_frame$")) { name.consume_front(".eh_frame$")) {
// For MinGW, treat .[px]data$<func> and .eh_frame$<func> as implicitly // For MinGW, treat .[px]data$<func> and .eh_frame$<func> as implicitly
// associative to the symbol <func>. // associative to the symbol <func>.
auto ParentSym = PrevailingSectionMap.find(Name); auto parentSym = prevailingSectionMap.find(name);
if (ParentSym != PrevailingSectionMap.end()) if (parentSym != prevailingSectionMap.end())
readAssociativeDefinition(Sym, Def, ParentSym->second); readAssociativeDefinition(sym, def, parentSym->second);
} }
} }
Symbol *ObjFile::createRegular(COFFSymbolRef Sym) { Symbol *ObjFile::createRegular(COFFSymbolRef sym) {
SectionChunk *SC = SparseChunks[Sym.getSectionNumber()]; SectionChunk *sc = sparseChunks[sym.getSectionNumber()];
if (Sym.isExternal()) { if (sym.isExternal()) {
StringRef Name; StringRef name;
COFFObj->getSymbolName(Sym, Name); coffObj->getSymbolName(sym, name);
if (SC) if (sc)
return Symtab->addRegular(this, Name, Sym.getGeneric(), SC); return symtab->addRegular(this, name, sym.getGeneric(), sc);
// For MinGW symbols named .weak.* that point to a discarded section, // For MinGW symbols named .weak.* that point to a discarded section,
// don't create an Undefined symbol. If nothing ever refers to the symbol, // don't create an Undefined symbol. If nothing ever refers to the symbol,
// everything should be fine. If something actually refers to the symbol // everything should be fine. If something actually refers to the symbol
// (e.g. the undefined weak alias), linking will fail due to undefined // (e.g. the undefined weak alias), linking will fail due to undefined
// references at the end. // references at the end.
if (Config->MinGW && Name.startswith(".weak.")) if (config->mingw && name.startswith(".weak."))
return nullptr; return nullptr;
return Symtab->addUndefined(Name, this, false); return symtab->addUndefined(name, this, false);
} }
if (SC) if (sc)
return make<DefinedRegular>(this, /*Name*/ "", /*IsCOMDAT*/ false, return make<DefinedRegular>(this, /*Name*/ "", /*IsCOMDAT*/ false,
/*IsExternal*/ false, Sym.getGeneric(), SC); /*IsExternal*/ false, sym.getGeneric(), sc);
return nullptr; return nullptr;
} }
void ObjFile::initializeSymbols() { void ObjFile::initializeSymbols() {
uint32_t NumSymbols = COFFObj->getNumberOfSymbols(); uint32_t numSymbols = coffObj->getNumberOfSymbols();
Symbols.resize(NumSymbols); symbols.resize(numSymbols);
SmallVector<std::pair<Symbol *, uint32_t>, 8> WeakAliases; SmallVector<std::pair<Symbol *, uint32_t>, 8> weakAliases;
std::vector<uint32_t> PendingIndexes; std::vector<uint32_t> pendingIndexes;
PendingIndexes.reserve(NumSymbols); pendingIndexes.reserve(numSymbols);
DenseMap<StringRef, uint32_t> PrevailingSectionMap; DenseMap<StringRef, uint32_t> prevailingSectionMap;
std::vector<const coff_aux_section_definition *> ComdatDefs( std::vector<const coff_aux_section_definition *> comdatDefs(
COFFObj->getNumberOfSections() + 1); coffObj->getNumberOfSections() + 1);
for (uint32_t I = 0; I < NumSymbols; ++I) { for (uint32_t i = 0; i < numSymbols; ++i) {
COFFSymbolRef COFFSym = check(COFFObj->getSymbol(I)); COFFSymbolRef coffSym = check(coffObj->getSymbol(i));
bool PrevailingComdat; bool prevailingComdat;
if (COFFSym.isUndefined()) { if (coffSym.isUndefined()) {
Symbols[I] = createUndefined(COFFSym); symbols[i] = createUndefined(coffSym);
} else if (COFFSym.isWeakExternal()) { } else if (coffSym.isWeakExternal()) {
Symbols[I] = createUndefined(COFFSym); symbols[i] = createUndefined(coffSym);
uint32_t TagIndex = COFFSym.getAux<coff_aux_weak_external>()->TagIndex; uint32_t tagIndex = coffSym.getAux<coff_aux_weak_external>()->TagIndex;
WeakAliases.emplace_back(Symbols[I], TagIndex); weakAliases.emplace_back(symbols[i], tagIndex);
} else if (Optional<Symbol *> OptSym = } else if (Optional<Symbol *> optSym =
createDefined(COFFSym, ComdatDefs, PrevailingComdat)) { createDefined(coffSym, comdatDefs, prevailingComdat)) {
Symbols[I] = *OptSym; symbols[i] = *optSym;
if (Config->MinGW && PrevailingComdat) if (config->mingw && prevailingComdat)
recordPrevailingSymbolForMingw(COFFSym, PrevailingSectionMap); recordPrevailingSymbolForMingw(coffSym, prevailingSectionMap);
} else { } else {
// createDefined() returns None if a symbol belongs to a section that // createDefined() returns None if a symbol belongs to a section that
// was pending at the point when the symbol was read. This can happen in // was pending at the point when the symbol was read. This can happen in
// two cases: // two cases:
// 1) section definition symbol for a comdat leader; // 1) section definition symbol for a comdat leader;
// 2) symbol belongs to a comdat section associated with another section. // 2) symbol belongs to a comdat section associated with another section.
// In both of these cases, we can expect the section to be resolved by // In both of these cases, we can expect the section to be resolved by
// the time we finish visiting the remaining symbols in the symbol // the time we finish visiting the remaining symbols in the symbol
// table. So we postpone the handling of this symbol until that time. // table. So we postpone the handling of this symbol until that time.
PendingIndexes.push_back(I); pendingIndexes.push_back(i);
} }
I += COFFSym.getNumberOfAuxSymbols(); i += coffSym.getNumberOfAuxSymbols();
} }
for (uint32_t I : PendingIndexes) { for (uint32_t i : pendingIndexes) {
COFFSymbolRef Sym = check(COFFObj->getSymbol(I)); COFFSymbolRef sym = check(coffObj->getSymbol(i));
if (const coff_aux_section_definition *Def = Sym.getSectionDefinition()) { if (const coff_aux_section_definition *def = sym.getSectionDefinition()) {
if (Def->Selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE) if (def->Selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE)
readAssociativeDefinition(Sym, Def); readAssociativeDefinition(sym, def);
else if (Config->MinGW) else if (config->mingw)
maybeAssociateSEHForMingw(Sym, Def, PrevailingSectionMap); maybeAssociateSEHForMingw(sym, def, prevailingSectionMap);
} }
if (SparseChunks[Sym.getSectionNumber()] == PendingComdat) { if (sparseChunks[sym.getSectionNumber()] == pendingComdat) {
StringRef Name; StringRef name;
COFFObj->getSymbolName(Sym, Name); coffObj->getSymbolName(sym, name);
log("comdat section " + Name + log("comdat section " + name +
" without leader and unassociated, discarding"); " without leader and unassociated, discarding");
continue; continue;
} }
Symbols[I] = createRegular(Sym); symbols[i] = createRegular(sym);
} }
for (auto &KV : WeakAliases) { for (auto &kv : weakAliases) {
Symbol *Sym = KV.first; Symbol *sym = kv.first;
uint32_t Idx = KV.second; uint32_t idx = kv.second;
checkAndSetWeakAlias(Symtab, this, Sym, Symbols[Idx]); checkAndSetWeakAlias(symtab, this, sym, symbols[idx]);
} }
} }
Symbol *ObjFile::createUndefined(COFFSymbolRef Sym) { Symbol *ObjFile::createUndefined(COFFSymbolRef sym) {
StringRef Name; StringRef name;
COFFObj->getSymbolName(Sym, Name); coffObj->getSymbolName(sym, name);
return Symtab->addUndefined(Name, this, Sym.isWeakExternal()); return symtab->addUndefined(name, this, sym.isWeakExternal());
} }
void ObjFile::handleComdatSelection(COFFSymbolRef Sym, COMDATType &Selection, void ObjFile::handleComdatSelection(COFFSymbolRef sym, COMDATType &selection,
bool &Prevailing, DefinedRegular *Leader) { bool &prevailing, DefinedRegular *leader) {
if (Prevailing) if (prevailing)
return; return;
// There's already an existing comdat for this symbol: `Leader`. // There's already an existing comdat for this symbol: `Leader`.
// Use the comdats's selection field to determine if the new // Use the comdats's selection field to determine if the new
// symbol in `Sym` should be discarded, produce a duplicate symbol // symbol in `Sym` should be discarded, produce a duplicate symbol
// error, etc. // error, etc.
SectionChunk *LeaderChunk = nullptr; SectionChunk *leaderChunk = nullptr;
COMDATType LeaderSelection = IMAGE_COMDAT_SELECT_ANY; COMDATType leaderSelection = IMAGE_COMDAT_SELECT_ANY;
if (Leader->Data) { if (leader->data) {
LeaderChunk = Leader->getChunk(); leaderChunk = leader->getChunk();
LeaderSelection = LeaderChunk->Selection; leaderSelection = leaderChunk->selection;
} else { } else {
// FIXME: comdats from LTO files don't know their selection; treat them // FIXME: comdats from LTO files don't know their selection; treat them
// as "any". // as "any".
Selection = LeaderSelection; selection = leaderSelection;
} }
if ((Selection == IMAGE_COMDAT_SELECT_ANY && if ((selection == IMAGE_COMDAT_SELECT_ANY &&
LeaderSelection == IMAGE_COMDAT_SELECT_LARGEST) || leaderSelection == IMAGE_COMDAT_SELECT_LARGEST) ||
(Selection == IMAGE_COMDAT_SELECT_LARGEST && (selection == IMAGE_COMDAT_SELECT_LARGEST &&
LeaderSelection == IMAGE_COMDAT_SELECT_ANY)) { leaderSelection == IMAGE_COMDAT_SELECT_ANY)) {
// cl.exe picks "any" for vftables when building with /GR- and // cl.exe picks "any" for vftables when building with /GR- and
// "largest" when building with /GR. To be able to link object files // "largest" when building with /GR. To be able to link object files
// compiled with each flag, "any" and "largest" are merged as "largest". // compiled with each flag, "any" and "largest" are merged as "largest".
LeaderSelection = Selection = IMAGE_COMDAT_SELECT_LARGEST; leaderSelection = selection = IMAGE_COMDAT_SELECT_LARGEST;
} }
// Other than that, comdat selections must match. This is a bit more // Other than that, comdat selections must match. This is a bit more
// strict than link.exe which allows merging "any" and "largest" if "any" // strict than link.exe which allows merging "any" and "largest" if "any"
// is the first symbol the linker sees, and it allows merging "largest" // is the first symbol the linker sees, and it allows merging "largest"
// with everything (!) if "largest" is the first symbol the linker sees. // with everything (!) if "largest" is the first symbol the linker sees.
// Making this symmetric independent of which selection is seen first // Making this symmetric independent of which selection is seen first
// seems better though. // seems better though.
// (This behavior matches ModuleLinker::getComdatResult().) // (This behavior matches ModuleLinker::getComdatResult().)
if (Selection != LeaderSelection) { if (selection != leaderSelection) {
log(("conflicting comdat type for " + toString(*Leader) + ": " + log(("conflicting comdat type for " + toString(*leader) + ": " +
Twine((int)LeaderSelection) + " in " + toString(Leader->getFile()) + Twine((int)leaderSelection) + " in " + toString(leader->getFile()) +
" and " + Twine((int)Selection) + " in " + toString(this)) " and " + Twine((int)selection) + " in " + toString(this))
.str()); .str());
Symtab->reportDuplicate(Leader, this); symtab->reportDuplicate(leader, this);
return; return;
} }
switch (Selection) { switch (selection) {
case IMAGE_COMDAT_SELECT_NODUPLICATES: case IMAGE_COMDAT_SELECT_NODUPLICATES:
Symtab->reportDuplicate(Leader, this); symtab->reportDuplicate(leader, this);
break; break;
case IMAGE_COMDAT_SELECT_ANY: case IMAGE_COMDAT_SELECT_ANY:
// Nothing to do. // Nothing to do.
break; break;
case IMAGE_COMDAT_SELECT_SAME_SIZE: case IMAGE_COMDAT_SELECT_SAME_SIZE:
if (LeaderChunk->getSize() != getSection(Sym)->SizeOfRawData) if (leaderChunk->getSize() != getSection(sym)->SizeOfRawData)
Symtab->reportDuplicate(Leader, this); symtab->reportDuplicate(leader, this);
break; break;
case IMAGE_COMDAT_SELECT_EXACT_MATCH: { case IMAGE_COMDAT_SELECT_EXACT_MATCH: {
SectionChunk NewChunk(this, getSection(Sym)); SectionChunk newChunk(this, getSection(sym));
// link.exe only compares section contents here and doesn't complain // link.exe only compares section contents here and doesn't complain
// if the two comdat sections have e.g. different alignment. // if the two comdat sections have e.g. different alignment.
// Match that. // Match that.
if (LeaderChunk->getContents() != NewChunk.getContents()) if (leaderChunk->getContents() != newChunk.getContents())
Symtab->reportDuplicate(Leader, this); symtab->reportDuplicate(leader, this);
break; break;
} }
case IMAGE_COMDAT_SELECT_ASSOCIATIVE: case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
// createDefined() is never called for IMAGE_COMDAT_SELECT_ASSOCIATIVE. // createDefined() is never called for IMAGE_COMDAT_SELECT_ASSOCIATIVE.
// (This means lld-link doesn't produce duplicate symbol errors for // (This means lld-link doesn't produce duplicate symbol errors for
// associative comdats while link.exe does, but associate comdats // associative comdats while link.exe does, but associate comdats
// are never extern in practice.) // are never extern in practice.)
llvm_unreachable("createDefined not called for associative comdats"); llvm_unreachable("createDefined not called for associative comdats");
case IMAGE_COMDAT_SELECT_LARGEST: case IMAGE_COMDAT_SELECT_LARGEST:
if (LeaderChunk->getSize() < getSection(Sym)->SizeOfRawData) { if (leaderChunk->getSize() < getSection(sym)->SizeOfRawData) {
// Replace the existing comdat symbol with the new one. // Replace the existing comdat symbol with the new one.
StringRef Name; StringRef name;
COFFObj->getSymbolName(Sym, Name); coffObj->getSymbolName(sym, name);
// FIXME: This is incorrect: With /opt:noref, the previous sections // FIXME: This is incorrect: With /opt:noref, the previous sections
// make it into the final executable as well. Correct handling would // make it into the final executable as well. Correct handling would
// be to undo reading of the whole old section that's being replaced, // be to undo reading of the whole old section that's being replaced,
// or doing one pass that determines what the final largest comdat // or doing one pass that determines what the final largest comdat
// is for all IMAGE_COMDAT_SELECT_LARGEST comdats and then reading // is for all IMAGE_COMDAT_SELECT_LARGEST comdats and then reading
// only the largest one. // only the largest one.
replaceSymbol<DefinedRegular>(Leader, this, Name, /*IsCOMDAT*/ true, replaceSymbol<DefinedRegular>(leader, this, name, /*IsCOMDAT*/ true,
/*IsExternal*/ true, Sym.getGeneric(), /*IsExternal*/ true, sym.getGeneric(),
nullptr); nullptr);
Prevailing = true; prevailing = true;
} }
break; break;
case IMAGE_COMDAT_SELECT_NEWEST: case IMAGE_COMDAT_SELECT_NEWEST:
llvm_unreachable("should have been rejected earlier"); llvm_unreachable("should have been rejected earlier");
} }
} }
Optional<Symbol *> ObjFile::createDefined( Optional<Symbol *> ObjFile::createDefined(
COFFSymbolRef Sym, COFFSymbolRef sym,
std::vector<const coff_aux_section_definition *> &ComdatDefs, std::vector<const coff_aux_section_definition *> &comdatDefs,
bool &Prevailing) { bool &prevailing) {
Prevailing = false; prevailing = false;
auto GetName = [&]() { auto getName = [&]() {
StringRef S; StringRef s;
COFFObj->getSymbolName(Sym, S); coffObj->getSymbolName(sym, s);
return S; return s;
}; };
if (Sym.isCommon()) { if (sym.isCommon()) {
auto *C = make<CommonChunk>(Sym); auto *c = make<CommonChunk>(sym);
Chunks.push_back(C); chunks.push_back(c);
return Symtab->addCommon(this, GetName(), Sym.getValue(), Sym.getGeneric(), return symtab->addCommon(this, getName(), sym.getValue(), sym.getGeneric(),
C); c);
} }
if (Sym.isAbsolute()) { if (sym.isAbsolute()) {
StringRef Name = GetName(); StringRef name = getName();
// Skip special symbols. // Skip special symbols.
if (Name == "@comp.id") if (name == "@comp.id")
return nullptr; return nullptr;
if (Name == "@feat.00") { if (name == "@feat.00") {
Feat00Flags = Sym.getValue(); feat00Flags = sym.getValue();
return nullptr; return nullptr;
} }
if (Sym.isExternal()) if (sym.isExternal())
return Symtab->addAbsolute(Name, Sym); return symtab->addAbsolute(name, sym);
return make<DefinedAbsolute>(Name, Sym); return make<DefinedAbsolute>(name, sym);
} }
int32_t SectionNumber = Sym.getSectionNumber(); int32_t sectionNumber = sym.getSectionNumber();
if (SectionNumber == llvm::COFF::IMAGE_SYM_DEBUG) if (sectionNumber == llvm::COFF::IMAGE_SYM_DEBUG)
return nullptr; return nullptr;
if (llvm::COFF::isReservedSectionNumber(SectionNumber)) if (llvm::COFF::isReservedSectionNumber(sectionNumber))
fatal(toString(this) + ": " + GetName() + fatal(toString(this) + ": " + getName() +
" should not refer to special section " + Twine(SectionNumber)); " should not refer to special section " + Twine(sectionNumber));
if ((uint32_t)SectionNumber >= SparseChunks.size()) if ((uint32_t)sectionNumber >= sparseChunks.size())
fatal(toString(this) + ": " + GetName() + fatal(toString(this) + ": " + getName() +
" should not refer to non-existent section " + Twine(SectionNumber)); " should not refer to non-existent section " + Twine(sectionNumber));
// Comdat handling. // Comdat handling.
// A comdat symbol consists of two symbol table entries. // A comdat symbol consists of two symbol table entries.
// The first symbol entry has the name of the section (e.g. .text), fixed // The first symbol entry has the name of the section (e.g. .text), fixed
// values for the other fields, and one auxilliary record. // values for the other fields, and one auxilliary record.
// The second symbol entry has the name of the comdat symbol, called the // The second symbol entry has the name of the comdat symbol, called the
// "comdat leader". // "comdat leader".
// When this function is called for the first symbol entry of a comdat, // When this function is called for the first symbol entry of a comdat,
// it sets ComdatDefs and returns None, and when it's called for the second // it sets ComdatDefs and returns None, and when it's called for the second
// symbol entry it reads ComdatDefs and then sets it back to nullptr. // symbol entry it reads ComdatDefs and then sets it back to nullptr.
// Handle comdat leader. // Handle comdat leader.
if (const coff_aux_section_definition *Def = ComdatDefs[SectionNumber]) { if (const coff_aux_section_definition *def = comdatDefs[sectionNumber]) {
ComdatDefs[SectionNumber] = nullptr; comdatDefs[sectionNumber] = nullptr;
DefinedRegular *Leader; DefinedRegular *leader;
if (Sym.isExternal()) { if (sym.isExternal()) {
std::tie(Leader, Prevailing) = std::tie(leader, prevailing) =
Symtab->addComdat(this, GetName(), Sym.getGeneric()); symtab->addComdat(this, getName(), sym.getGeneric());
} else { } else {
Leader = make<DefinedRegular>(this, /*Name*/ "", /*IsCOMDAT*/ false, leader = make<DefinedRegular>(this, /*Name*/ "", /*IsCOMDAT*/ false,
/*IsExternal*/ false, Sym.getGeneric()); /*IsExternal*/ false, sym.getGeneric());
Prevailing = true; prevailing = true;
} }
if (Def->Selection < (int)IMAGE_COMDAT_SELECT_NODUPLICATES || if (def->Selection < (int)IMAGE_COMDAT_SELECT_NODUPLICATES ||
// Intentionally ends at IMAGE_COMDAT_SELECT_LARGEST: link.exe // Intentionally ends at IMAGE_COMDAT_SELECT_LARGEST: link.exe
// doesn't understand IMAGE_COMDAT_SELECT_NEWEST either. // doesn't understand IMAGE_COMDAT_SELECT_NEWEST either.
Def->Selection > (int)IMAGE_COMDAT_SELECT_LARGEST) { def->Selection > (int)IMAGE_COMDAT_SELECT_LARGEST) {
fatal("unknown comdat type " + std::to_string((int)Def->Selection) + fatal("unknown comdat type " + std::to_string((int)def->Selection) +
" for " + GetName() + " in " + toString(this)); " for " + getName() + " in " + toString(this));
} }
COMDATType Selection = (COMDATType)Def->Selection; COMDATType selection = (COMDATType)def->Selection;
if (Leader->IsCOMDAT) if (leader->isCOMDAT)
handleComdatSelection(Sym, Selection, Prevailing, Leader); handleComdatSelection(sym, selection, prevailing, leader);
if (Prevailing) { if (prevailing) {
SectionChunk *C = readSection(SectionNumber, Def, GetName()); SectionChunk *c = readSection(sectionNumber, def, getName());
SparseChunks[SectionNumber] = C; sparseChunks[sectionNumber] = c;
C->Sym = cast<DefinedRegular>(Leader); c->sym = cast<DefinedRegular>(leader);
C->Selection = Selection; c->selection = selection;
cast<DefinedRegular>(Leader)->Data = &C->Repl; cast<DefinedRegular>(leader)->data = &c->repl;
} else { } else {
SparseChunks[SectionNumber] = nullptr; sparseChunks[sectionNumber] = nullptr;
} }
return Leader; return leader;
} }
// Prepare to handle the comdat leader symbol by setting the section's // Prepare to handle the comdat leader symbol by setting the section's
// ComdatDefs pointer if we encounter a non-associative comdat. // ComdatDefs pointer if we encounter a non-associative comdat.
if (SparseChunks[SectionNumber] == PendingComdat) { if (sparseChunks[sectionNumber] == pendingComdat) {
if (const coff_aux_section_definition *Def = Sym.getSectionDefinition()) { if (const coff_aux_section_definition *def = sym.getSectionDefinition()) {
if (Def->Selection != IMAGE_COMDAT_SELECT_ASSOCIATIVE) if (def->Selection != IMAGE_COMDAT_SELECT_ASSOCIATIVE)
ComdatDefs[SectionNumber] = Def; comdatDefs[sectionNumber] = def;
} }
return None; return None;
} }
return createRegular(Sym); return createRegular(sym);
} }
MachineTypes ObjFile::getMachineType() { MachineTypes ObjFile::getMachineType() {
if (COFFObj) if (coffObj)
return static_cast<MachineTypes>(COFFObj->getMachine()); return static_cast<MachineTypes>(coffObj->getMachine());
return IMAGE_FILE_MACHINE_UNKNOWN; return IMAGE_FILE_MACHINE_UNKNOWN;
} }
ArrayRef<uint8_t> ObjFile::getDebugSection(StringRef SecName) { ArrayRef<uint8_t> ObjFile::getDebugSection(StringRef secName) {
if (SectionChunk *Sec = SectionChunk::findByName(DebugChunks, SecName)) if (SectionChunk *sec = SectionChunk::findByName(debugChunks, secName))
return Sec->consumeDebugMagic(); return sec->consumeDebugMagic();
return {}; return {};
} }
// OBJ files systematically store critical informations in a .debug$S stream, // OBJ files systematically store critical informations in a .debug$S stream,
// even if the TU was compiled with no debug info. At least two records are // even if the TU was compiled with no debug info. At least two records are
// always there. S_OBJNAME stores a 32-bit signature, which is loaded into the // always there. S_OBJNAME stores a 32-bit signature, which is loaded into the
// PCHSignature member. S_COMPILE3 stores compile-time cmd-line flags. This is // PCHSignature member. S_COMPILE3 stores compile-time cmd-line flags. This is
// currently used to initialize the HotPatchable member. // currently used to initialize the HotPatchable member.
void ObjFile::initializeFlags() { void ObjFile::initializeFlags() {
ArrayRef<uint8_t> Data = getDebugSection(".debug$S"); ArrayRef<uint8_t> data = getDebugSection(".debug$S");
if (Data.empty()) if (data.empty())
return; return;
DebugSubsectionArray Subsections; DebugSubsectionArray subsections;
BinaryStreamReader Reader(Data, support::little); BinaryStreamReader reader(data, support::little);
ExitOnError ExitOnErr; ExitOnError exitOnErr;
ExitOnErr(Reader.readArray(Subsections, Data.size())); exitOnErr(reader.readArray(subsections, data.size()));
for (const DebugSubsectionRecord &SS : Subsections) { for (const DebugSubsectionRecord &ss : subsections) {
if (SS.kind() != DebugSubsectionKind::Symbols) if (ss.kind() != DebugSubsectionKind::Symbols)
continue; continue;
unsigned Offset = 0; unsigned offset = 0;
// Only parse the first two records. We are only looking for S_OBJNAME // Only parse the first two records. We are only looking for S_OBJNAME
// and S_COMPILE3, and they usually appear at the beginning of the // and S_COMPILE3, and they usually appear at the beginning of the
// stream. // stream.
for (unsigned I = 0; I < 2; ++I) { for (unsigned i = 0; i < 2; ++i) {
Expected<CVSymbol> Sym = readSymbolFromStream(SS.getRecordData(), Offset); Expected<CVSymbol> sym = readSymbolFromStream(ss.getRecordData(), offset);
if (!Sym) { if (!sym) {
consumeError(Sym.takeError()); consumeError(sym.takeError());
return; return;
} }
if (Sym->kind() == SymbolKind::S_COMPILE3) { if (sym->kind() == SymbolKind::S_COMPILE3) {
auto CS = auto cs =
cantFail(SymbolDeserializer::deserializeAs<Compile3Sym>(Sym.get())); cantFail(SymbolDeserializer::deserializeAs<Compile3Sym>(sym.get()));
HotPatchable = hotPatchable =
(CS.Flags & CompileSym3Flags::HotPatch) != CompileSym3Flags::None; (cs.Flags & CompileSym3Flags::HotPatch) != CompileSym3Flags::None;
} }
if (Sym->kind() == SymbolKind::S_OBJNAME) { if (sym->kind() == SymbolKind::S_OBJNAME) {
auto ObjName = cantFail(SymbolDeserializer::deserializeAs<ObjNameSym>( auto objName = cantFail(SymbolDeserializer::deserializeAs<ObjNameSym>(
Sym.get())); sym.get()));
PCHSignature = ObjName.Signature; pchSignature = objName.Signature;
} }
Offset += Sym->length(); offset += sym->length();
} }
} }
} }
// Depending on the compilation flags, OBJs can refer to external files, // Depending on the compilation flags, OBJs can refer to external files,
// necessary to merge this OBJ into the final PDB. We currently support two // necessary to merge this OBJ into the final PDB. We currently support two
// types of external files: Precomp/PCH OBJs, when compiling with /Yc and /Yu. // types of external files: Precomp/PCH OBJs, when compiling with /Yc and /Yu.
// And PDB type servers, when compiling with /Zi. This function extracts these // And PDB type servers, when compiling with /Zi. This function extracts these
// dependencies and makes them available as a TpiSource interface (see // dependencies and makes them available as a TpiSource interface (see
// DebugTypes.h). Both cases only happen with cl.exe: clang-cl produces regular // DebugTypes.h). Both cases only happen with cl.exe: clang-cl produces regular
// output even with /Yc and /Yu and with /Zi. // output even with /Yc and /Yu and with /Zi.
void ObjFile::initializeDependencies() { void ObjFile::initializeDependencies() {
if (!Config->Debug) if (!config->debug)
return; return;
bool IsPCH = false; bool isPCH = false;
ArrayRef<uint8_t> Data = getDebugSection(".debug$P"); ArrayRef<uint8_t> data = getDebugSection(".debug$P");
if (!Data.empty()) if (!data.empty())
IsPCH = true; isPCH = true;
else else
Data = getDebugSection(".debug$T"); data = getDebugSection(".debug$T");
if (Data.empty()) if (data.empty())
return; return;
CVTypeArray Types; CVTypeArray types;
BinaryStreamReader Reader(Data, support::little); BinaryStreamReader reader(data, support::little);
cantFail(Reader.readArray(Types, Reader.getLength())); cantFail(reader.readArray(types, reader.getLength()));
CVTypeArray::Iterator FirstType = Types.begin(); CVTypeArray::Iterator firstType = types.begin();
if (FirstType == Types.end()) if (firstType == types.end())
return; return;
DebugTypes.emplace(Types); debugTypes.emplace(types);
if (IsPCH) { if (isPCH) {
DebugTypesObj = makePrecompSource(this); debugTypesObj = makePrecompSource(this);
return; return;
} }
if (FirstType->kind() == LF_TYPESERVER2) { if (firstType->kind() == LF_TYPESERVER2) {
TypeServer2Record TS = cantFail( TypeServer2Record ts = cantFail(
TypeDeserializer::deserializeAs<TypeServer2Record>(FirstType->data())); TypeDeserializer::deserializeAs<TypeServer2Record>(firstType->data()));
DebugTypesObj = makeUseTypeServerSource(this, &TS); debugTypesObj = makeUseTypeServerSource(this, &ts);
return; return;
} }
if (FirstType->kind() == LF_PRECOMP) { if (firstType->kind() == LF_PRECOMP) {
PrecompRecord Precomp = cantFail( PrecompRecord precomp = cantFail(
TypeDeserializer::deserializeAs<PrecompRecord>(FirstType->data())); TypeDeserializer::deserializeAs<PrecompRecord>(firstType->data()));
DebugTypesObj = makeUsePrecompSource(this, &Precomp); debugTypesObj = makeUsePrecompSource(this, &precomp);
return; return;
} }
DebugTypesObj = makeTpiSource(this); debugTypesObj = makeTpiSource(this);
} }
StringRef ltrim1(StringRef S, const char *Chars) { StringRef ltrim1(StringRef s, const char *chars) {
if (!S.empty() && strchr(Chars, S[0])) if (!s.empty() && strchr(chars, s[0]))
return S.substr(1); return s.substr(1);
return S; return s;
} }
void ImportFile::parse() { void ImportFile::parse() {
const char *Buf = MB.getBufferStart(); const char *buf = mb.getBufferStart();
const auto *Hdr = reinterpret_cast<const coff_import_header *>(Buf); const auto *hdr = reinterpret_cast<const coff_import_header *>(buf);
// Check if the total size is valid. // Check if the total size is valid.
if (MB.getBufferSize() != sizeof(*Hdr) + Hdr->SizeOfData) if (mb.getBufferSize() != sizeof(*hdr) + hdr->SizeOfData)
fatal("broken import library"); fatal("broken import library");
// Read names and create an __imp_ symbol. // Read names and create an __imp_ symbol.
StringRef Name = Saver.save(StringRef(Buf + sizeof(*Hdr))); StringRef name = saver.save(StringRef(buf + sizeof(*hdr)));
StringRef ImpName = Saver.save("__imp_" + Name); StringRef impName = saver.save("__imp_" + name);
const char *NameStart = Buf + sizeof(coff_import_header) + Name.size() + 1; const char *nameStart = buf + sizeof(coff_import_header) + name.size() + 1;
DLLName = StringRef(NameStart); dllName = StringRef(nameStart);
StringRef ExtName; StringRef extName;
switch (Hdr->getNameType()) { switch (hdr->getNameType()) {
case IMPORT_ORDINAL: case IMPORT_ORDINAL:
ExtName = ""; extName = "";
break; break;
case IMPORT_NAME: case IMPORT_NAME:
ExtName = Name; extName = name;
break; break;
case IMPORT_NAME_NOPREFIX: case IMPORT_NAME_NOPREFIX:
ExtName = ltrim1(Name, "?@_"); extName = ltrim1(name, "?@_");
break; break;
case IMPORT_NAME_UNDECORATE: case IMPORT_NAME_UNDECORATE:
ExtName = ltrim1(Name, "?@_"); extName = ltrim1(name, "?@_");
ExtName = ExtName.substr(0, ExtName.find('@')); extName = extName.substr(0, extName.find('@'));
break; break;
} }
this->Hdr = Hdr; this->hdr = hdr;
ExternalName = ExtName; externalName = extName;
ImpSym = Symtab->addImportData(ImpName, this); impSym = symtab->addImportData(impName, this);
// If this was a duplicate, we logged an error but may continue; // If this was a duplicate, we logged an error but may continue;
// in this case, ImpSym is nullptr. // in this case, ImpSym is nullptr.
if (!ImpSym) if (!impSym)
return; return;
if (Hdr->getType() == llvm::COFF::IMPORT_CONST) if (hdr->getType() == llvm::COFF::IMPORT_CONST)
static_cast<void>(Symtab->addImportData(Name, this)); static_cast<void>(symtab->addImportData(name, this));
// If type is function, we need to create a thunk which jump to an // If type is function, we need to create a thunk which jump to an
// address pointed by the __imp_ symbol. (This allows you to call // address pointed by the __imp_ symbol. (This allows you to call
// DLL functions just like regular non-DLL functions.) // DLL functions just like regular non-DLL functions.)
if (Hdr->getType() == llvm::COFF::IMPORT_CODE) if (hdr->getType() == llvm::COFF::IMPORT_CODE)
ThunkSym = Symtab->addImportThunk( thunkSym = symtab->addImportThunk(
Name, cast_or_null<DefinedImportData>(ImpSym), Hdr->Machine); name, cast_or_null<DefinedImportData>(impSym), hdr->Machine);
} }
BitcodeFile::BitcodeFile(MemoryBufferRef MB, StringRef ArchiveName, BitcodeFile::BitcodeFile(MemoryBufferRef mb, StringRef archiveName,
uint64_t OffsetInArchive) uint64_t offsetInArchive)
: InputFile(BitcodeKind, MB) { : InputFile(BitcodeKind, mb) {
std::string Path = MB.getBufferIdentifier().str(); std::string path = mb.getBufferIdentifier().str();
// ThinLTO assumes that all MemoryBufferRefs given to it have a unique // ThinLTO assumes that all MemoryBufferRefs given to it have a unique
// name. If two archives define two members with the same name, this // name. If two archives define two members with the same name, this
// causes a collision which result in only one of the objects being taken // causes a collision which result in only one of the objects being taken
// into consideration at LTO time (which very likely causes undefined // into consideration at LTO time (which very likely causes undefined
// symbols later in the link stage). So we append file offset to make // symbols later in the link stage). So we append file offset to make
// filename unique. // filename unique.
MemoryBufferRef MBRef( MemoryBufferRef mbref(
MB.getBuffer(), mb.getBuffer(),
Saver.save(ArchiveName + Path + saver.save(archiveName + path +
(ArchiveName.empty() ? "" : utostr(OffsetInArchive)))); (archiveName.empty() ? "" : utostr(offsetInArchive))));
Obj = check(lto::InputFile::create(MBRef)); obj = check(lto::InputFile::create(mbref));
} }
void BitcodeFile::parse() { void BitcodeFile::parse() {
std::vector<std::pair<Symbol *, bool>> Comdat(Obj->getComdatTable().size()); std::vector<std::pair<Symbol *, bool>> comdat(obj->getComdatTable().size());
for (size_t I = 0; I != Obj->getComdatTable().size(); ++I) for (size_t i = 0; i != obj->getComdatTable().size(); ++i)
// FIXME: lto::InputFile doesn't keep enough data to do correct comdat // FIXME: lto::InputFile doesn't keep enough data to do correct comdat
// selection handling. // selection handling.
Comdat[I] = Symtab->addComdat(this, Saver.save(Obj->getComdatTable()[I])); comdat[i] = symtab->addComdat(this, saver.save(obj->getComdatTable()[i]));
for (const lto::InputFile::Symbol &ObjSym : Obj->symbols()) { for (const lto::InputFile::Symbol &objSym : obj->symbols()) {
StringRef SymName = Saver.save(ObjSym.getName()); StringRef symName = saver.save(objSym.getName());
int ComdatIndex = ObjSym.getComdatIndex(); int comdatIndex = objSym.getComdatIndex();
Symbol *Sym; Symbol *sym;
if (ObjSym.isUndefined()) { if (objSym.isUndefined()) {
Sym = Symtab->addUndefined(SymName, this, false); sym = symtab->addUndefined(symName, this, false);
} else if (ObjSym.isCommon()) { } else if (objSym.isCommon()) {
Sym = Symtab->addCommon(this, SymName, ObjSym.getCommonSize()); sym = symtab->addCommon(this, symName, objSym.getCommonSize());
} else if (ObjSym.isWeak() && ObjSym.isIndirect()) { } else if (objSym.isWeak() && objSym.isIndirect()) {
// Weak external. // Weak external.
Sym = Symtab->addUndefined(SymName, this, true); sym = symtab->addUndefined(symName, this, true);
std::string Fallback = ObjSym.getCOFFWeakExternalFallback(); std::string fallback = objSym.getCOFFWeakExternalFallback();
Symbol *Alias = Symtab->addUndefined(Saver.save(Fallback)); Symbol *alias = symtab->addUndefined(saver.save(fallback));
checkAndSetWeakAlias(Symtab, this, Sym, Alias); checkAndSetWeakAlias(symtab, this, sym, alias);
} else if (ComdatIndex != -1) { } else if (comdatIndex != -1) {
if (SymName == Obj->getComdatTable()[ComdatIndex]) if (symName == obj->getComdatTable()[comdatIndex])
Sym = Comdat[ComdatIndex].first; sym = comdat[comdatIndex].first;
else if (Comdat[ComdatIndex].second) else if (comdat[comdatIndex].second)
Sym = Symtab->addRegular(this, SymName); sym = symtab->addRegular(this, symName);
else else
Sym = Symtab->addUndefined(SymName, this, false); sym = symtab->addUndefined(symName, this, false);
} else { } else {
Sym = Symtab->addRegular(this, SymName); sym = symtab->addRegular(this, symName);
} }
Symbols.push_back(Sym); symbols.push_back(sym);
if (ObjSym.isUsed()) if (objSym.isUsed())
Config->GCRoot.push_back(Sym); config->gCRoot.push_back(sym);
} }
Directives = Obj->getCOFFLinkerOpts(); directives = obj->getCOFFLinkerOpts();
} }
MachineTypes BitcodeFile::getMachineType() { MachineTypes BitcodeFile::getMachineType() {
switch (Triple(Obj->getTargetTriple()).getArch()) { switch (Triple(obj->getTargetTriple()).getArch()) {
case Triple::x86_64: case Triple::x86_64:
return AMD64; return AMD64;
case Triple::x86: case Triple::x86:
return I386; return I386;
case Triple::arm: case Triple::arm:
return ARMNT; return ARMNT;
case Triple::aarch64: case Triple::aarch64:
return ARM64; return ARM64;
default: default:
return IMAGE_FILE_MACHINE_UNKNOWN; return IMAGE_FILE_MACHINE_UNKNOWN;
} }
} }
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
// Returns the last element of a path, which is supposed to be a filename. // Returns the last element of a path, which is supposed to be a filename.
static StringRef getBasename(StringRef Path) { static StringRef getBasename(StringRef path) {
return sys::path::filename(Path, sys::path::Style::windows); return sys::path::filename(path, sys::path::Style::windows);
} }
// Returns a string in the format of "foo.obj" or "foo.obj(bar.lib)". // Returns a string in the format of "foo.obj" or "foo.obj(bar.lib)".
std::string lld::toString(const coff::InputFile *File) { std::string lld::toString(const coff::InputFile *file) {
if (!File) if (!file)
return "<internal>"; return "<internal>";
if (File->ParentName.empty() || File->kind() == coff::InputFile::ImportKind) if (file->parentName.empty() || file->kind() == coff::InputFile::ImportKind)
return File->getName(); return file->getName();
return (getBasename(File->ParentName) + "(" + getBasename(File->getName()) + return (getBasename(file->parentName) + "(" + getBasename(file->getName()) +
")") ")")
.str(); .str();
} }

lld/trunk/COFF/LTO.h

Show All 36 Lines
class BitcodeFile; class BitcodeFile;
class InputFile; class InputFile;
class BitcodeCompiler { class BitcodeCompiler {
public: public:
BitcodeCompiler(); BitcodeCompiler();
~BitcodeCompiler(); ~BitcodeCompiler();
void add(BitcodeFile &F); void add(BitcodeFile &f);
std::vector<StringRef> compile(); std::vector<StringRef> compile();
private: private:
std::unique_ptr<llvm::lto::LTO> LTOObj; std::unique_ptr<llvm::lto::LTO> ltoObj;
std::vector<SmallString<0>> Buf; std::vector<SmallString<0>> buf;
std::vector<std::unique_ptr<MemoryBuffer>> Files; std::vector<std::unique_ptr<MemoryBuffer>> files;
}; };
} }
} }
#endif #endif

lld/trunk/COFF/LTO.cpp

Show All 36 Lines
using namespace llvm; using namespace llvm;
using namespace llvm::object; using namespace llvm::object;
using namespace lld; using namespace lld;
using namespace lld::coff; using namespace lld::coff;
static std::unique_ptr<lto::LTO> createLTO() { static std::unique_ptr<lto::LTO> createLTO() {
lto::Config C; lto::Config c;
C.Options = initTargetOptionsFromCodeGenFlags(); c.Options = initTargetOptionsFromCodeGenFlags();
// Always emit a section per function/datum with LTO. LLVM LTO should get most // Always emit a section per function/datum with LTO. LLVM LTO should get most
// of the benefit of linker GC, but there are still opportunities for ICF. // of the benefit of linker GC, but there are still opportunities for ICF.
C.Options.FunctionSections = true; c.Options.FunctionSections = true;
C.Options.DataSections = true; c.Options.DataSections = true;
// Use static reloc model on 32-bit x86 because it usually results in more // Use static reloc model on 32-bit x86 because it usually results in more
// compact code, and because there are also known code generation bugs when // compact code, and because there are also known code generation bugs when
// using the PIC model (see PR34306). // using the PIC model (see PR34306).
if (Config->Machine == COFF::IMAGE_FILE_MACHINE_I386) if (config->machine == COFF::IMAGE_FILE_MACHINE_I386)
C.RelocModel = Reloc::Static; c.RelocModel = Reloc::Static;
else else
C.RelocModel = Reloc::PIC_; c.RelocModel = Reloc::PIC_;
C.DisableVerify = true; c.DisableVerify = true;
C.DiagHandler = diagnosticHandler; c.DiagHandler = diagnosticHandler;
C.OptLevel = Config->LTOO; c.OptLevel = config->ltoo;
C.CPU = getCPUStr(); c.CPU = getCPUStr();
C.MAttrs = getMAttrs(); c.MAttrs = getMAttrs();
C.CGOptLevel = args::getCGOptLevel(Config->LTOO); c.CGOptLevel = args::getCGOptLevel(config->ltoo);
if (Config->SaveTemps) if (config->saveTemps)
checkError(C.addSaveTemps(std::string(Config->OutputFile) + ".", checkError(c.addSaveTemps(std::string(config->outputFile) + ".",
/*UseInputModulePath*/ true)); /*UseInputModulePath*/ true));
lto::ThinBackend Backend; lto::ThinBackend backend;
if (Config->ThinLTOJobs != 0) if (config->thinLTOJobs != 0)
Backend = lto::createInProcessThinBackend(Config->ThinLTOJobs); backend = lto::createInProcessThinBackend(config->thinLTOJobs);
return llvm::make_unique<lto::LTO>(std::move(C), Backend, return llvm::make_unique<lto::LTO>(std::move(c), backend,
Config->LTOPartitions); config->ltoPartitions);
} }
BitcodeCompiler::BitcodeCompiler() : LTOObj(createLTO()) {} BitcodeCompiler::BitcodeCompiler() : ltoObj(createLTO()) {}
BitcodeCompiler::~BitcodeCompiler() = default; BitcodeCompiler::~BitcodeCompiler() = default;
static void undefine(Symbol *S) { replaceSymbol<Undefined>(S, S->getName()); } static void undefine(Symbol *s) { replaceSymbol<Undefined>(s, s->getName()); }
void BitcodeCompiler::add(BitcodeFile &F) { void BitcodeCompiler::add(BitcodeFile &f) {
lto::InputFile &Obj = *F.Obj; lto::InputFile &obj = *f.obj;
unsigned SymNum = 0; unsigned symNum = 0;
std::vector<Symbol *> SymBodies = F.getSymbols(); std::vector<Symbol *> symBodies = f.getSymbols();
std::vector<lto::SymbolResolution> Resols(SymBodies.size()); std::vector<lto::SymbolResolution> resols(symBodies.size());
// Provide a resolution to the LTO API for each symbol. // Provide a resolution to the LTO API for each symbol.
for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) { for (const lto::InputFile::Symbol &objSym : obj.symbols()) {
Symbol *Sym = SymBodies[SymNum]; Symbol *sym = symBodies[symNum];
lto::SymbolResolution &R = Resols[SymNum]; lto::SymbolResolution &r = resols[symNum];
++SymNum; ++symNum;
// Ideally we shouldn't check for SF_Undefined but currently IRObjectFile // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile
// reports two symbols for module ASM defined. Without this check, lld // reports two symbols for module ASM defined. Without this check, lld
// flags an undefined in IR with a definition in ASM as prevailing. // flags an undefined in IR with a definition in ASM as prevailing.
// Once IRObjectFile is fixed to report only one symbol this hack can // Once IRObjectFile is fixed to report only one symbol this hack can
// be removed. // be removed.
R.Prevailing = !ObjSym.isUndefined() && Sym->getFile() == &F; r.Prevailing = !objSym.isUndefined() && sym->getFile() == &f;
R.VisibleToRegularObj = Sym->IsUsedInRegularObj; r.VisibleToRegularObj = sym->isUsedInRegularObj;
if (R.Prevailing) if (r.Prevailing)
undefine(Sym); undefine(sym);
} }
checkError(LTOObj->add(std::move(F.Obj), Resols)); checkError(ltoObj->add(std::move(f.obj), resols));
} }
// Merge all the bitcode files we have seen, codegen the result // Merge all the bitcode files we have seen, codegen the result
// and return the resulting objects. // and return the resulting objects.
std::vector<StringRef> BitcodeCompiler::compile() { std::vector<StringRef> BitcodeCompiler::compile() {
unsigned MaxTasks = LTOObj->getMaxTasks(); unsigned maxTasks = ltoObj->getMaxTasks();
Buf.resize(MaxTasks); buf.resize(maxTasks);
Files.resize(MaxTasks); files.resize(maxTasks);
// The /lldltocache option specifies the path to a directory in which to cache // The /lldltocache option specifies the path to a directory in which to cache
// native object files for ThinLTO incremental builds. If a path was // native object files for ThinLTO incremental builds. If a path was
// specified, configure LTO to use it as the cache directory. // specified, configure LTO to use it as the cache directory.
lto::NativeObjectCache Cache; lto::NativeObjectCache cache;
if (!Config->LTOCache.empty()) if (!config->ltoCache.empty())
Cache = check(lto::localCache( cache = check(lto::localCache(
Config->LTOCache, [&](size_t Task, std::unique_ptr<MemoryBuffer> MB) { config->ltoCache, [&](size_t task, std::unique_ptr<MemoryBuffer> mb) {
Files[Task] = std::move(MB); files[task] = std::move(mb);
})); }));
checkError(LTOObj->run( checkError(ltoObj->run(
[&](size_t Task) { [&](size_t task) {
return llvm::make_unique<lto::NativeObjectStream>( return llvm::make_unique<lto::NativeObjectStream>(
llvm::make_unique<raw_svector_ostream>(Buf[Task])); llvm::make_unique<raw_svector_ostream>(buf[task]));
}, },
Cache)); cache));
if (!Config->LTOCache.empty()) if (!config->ltoCache.empty())
pruneCache(Config->LTOCache, Config->LTOCachePolicy); pruneCache(config->ltoCache, config->ltoCachePolicy);
std::vector<StringRef> Ret; std::vector<StringRef> ret;
for (unsigned I = 0; I != MaxTasks; ++I) { for (unsigned i = 0; i != maxTasks; ++i) {
if (Buf[I].empty()) if (buf[i].empty())
continue; continue;
if (Config->SaveTemps) { if (config->saveTemps) {
if (I == 0) if (i == 0)
saveBuffer(Buf[I], Config->OutputFile + ".lto.obj"); saveBuffer(buf[i], config->outputFile + ".lto.obj");
else else
saveBuffer(Buf[I], Config->OutputFile + Twine(I) + ".lto.obj"); saveBuffer(buf[i], config->outputFile + Twine(i) + ".lto.obj");
} }
Ret.emplace_back(Buf[I].data(), Buf[I].size()); ret.emplace_back(buf[i].data(), buf[i].size());
} }
for (std::unique_ptr<MemoryBuffer> &File : Files) for (std::unique_ptr<MemoryBuffer> &file : files)
if (File) if (file)
Ret.push_back(File->getBuffer()); ret.push_back(file->getBuffer());
return Ret; return ret;
} }

lld/trunk/COFF/MapFile.h

//===- MapFile.h ------------------------------------------------*- C++ -*-===// //===- MapFile.h ------------------------------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLD_COFF_MAPFILE_H #ifndef LLD_COFF_MAPFILE_H
#define LLD_COFF_MAPFILE_H #define LLD_COFF_MAPFILE_H
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
namespace lld { namespace lld {
namespace coff { namespace coff {
class OutputSection; class OutputSection;
void writeMapFile(llvm::ArrayRef<OutputSection *> OutputSections); void writeMapFile(llvm::ArrayRef<OutputSection *> outputSections);
} }
} }
#endif #endif

lld/trunk/COFF/MapFile.cpp

Show All 29 Lines
using namespace llvm::object; using namespace llvm::object;
using namespace lld; using namespace lld;
using namespace lld::coff; using namespace lld::coff;
using SymbolMapTy = using SymbolMapTy =
DenseMap<const SectionChunk *, SmallVector<DefinedRegular *, 4>>; DenseMap<const SectionChunk *, SmallVector<DefinedRegular *, 4>>;
static const std::string Indent8 = " "; // 8 spaces static const std::string indent8 = " "; // 8 spaces
static const std::string Indent16 = " "; // 16 spaces static const std::string indent16 = " "; // 16 spaces
// Print out the first three columns of a line. // Print out the first three columns of a line.
static void writeHeader(raw_ostream &OS, uint64_t Addr, uint64_t Size, static void writeHeader(raw_ostream &os, uint64_t addr, uint64_t size,
uint64_t Align) { uint64_t align) {
OS << format("%08llx %08llx %5lld ", Addr, Size, Align); os << format("%08llx %08llx %5lld ", addr, size, align);
} }
// Returns a list of all symbols that we want to print out. // Returns a list of all symbols that we want to print out.
static std::vector<DefinedRegular *> getSymbols() { static std::vector<DefinedRegular *> getSymbols() {
std::vector<DefinedRegular *> V; std::vector<DefinedRegular *> v;
for (ObjFile *File : ObjFile::Instances) for (ObjFile *file : ObjFile::instances)
for (Symbol *B : File->getSymbols()) for (Symbol *b : file->getSymbols())
if (auto *Sym = dyn_cast_or_null<DefinedRegular>(B)) if (auto *sym = dyn_cast_or_null<DefinedRegular>(b))
if (Sym && !Sym->getCOFFSymbol().isSectionDefinition()) if (sym && !sym->getCOFFSymbol().isSectionDefinition())
V.push_back(Sym); v.push_back(sym);
return V; return v;
} }
// Returns a map from sections to their symbols. // Returns a map from sections to their symbols.
static SymbolMapTy getSectionSyms(ArrayRef<DefinedRegular *> Syms) { static SymbolMapTy getSectionSyms(ArrayRef<DefinedRegular *> syms) {
SymbolMapTy Ret; SymbolMapTy ret;
for (DefinedRegular *S : Syms) for (DefinedRegular *s : syms)
Ret[S->getChunk()].push_back(S); ret[s->getChunk()].push_back(s);
// Sort symbols by address. // Sort symbols by address.
for (auto &It : Ret) { for (auto &it : ret) {
SmallVectorImpl<DefinedRegular *> &V = It.second; SmallVectorImpl<DefinedRegular *> &v = it.second;
std::sort(V.begin(), V.end(), [](DefinedRegular *A, DefinedRegular *B) { std::sort(v.begin(), v.end(), [](DefinedRegular *a, DefinedRegular *b) {
return A->getRVA() < B->getRVA(); return a->getRVA() < b->getRVA();
}); });
} }
return Ret; return ret;
} }
// Construct a map from symbols to their stringified representations. // Construct a map from symbols to their stringified representations.
static DenseMap<DefinedRegular *, std::string> static DenseMap<DefinedRegular *, std::string>
getSymbolStrings(ArrayRef<DefinedRegular *> Syms) { getSymbolStrings(ArrayRef<DefinedRegular *> syms) {
std::vector<std::string> Str(Syms.size()); std::vector<std::string> str(syms.size());
parallelForEachN((size_t)0, Syms.size(), [&](size_t I) { parallelForEachN((size_t)0, syms.size(), [&](size_t i) {
raw_string_ostream OS(Str[I]); raw_string_ostream os(str[i]);
writeHeader(OS, Syms[I]->getRVA(), 0, 0); writeHeader(os, syms[i]->getRVA(), 0, 0);
OS << Indent16 << toString(*Syms[I]); os << indent16 << toString(*syms[i]);
}); });
DenseMap<DefinedRegular *, std::string> Ret; DenseMap<DefinedRegular *, std::string> ret;
for (size_t I = 0, E = Syms.size(); I < E; ++I) for (size_t i = 0, e = syms.size(); i < e; ++i)
Ret[Syms[I]] = std::move(Str[I]); ret[syms[i]] = std::move(str[i]);
return Ret; return ret;
} }
void coff::writeMapFile(ArrayRef<OutputSection *> OutputSections) { void coff::writeMapFile(ArrayRef<OutputSection *> outputSections) {
if (Config->MapFile.empty()) if (config->mapFile.empty())
return; return;
std::error_code EC; std::error_code ec;
raw_fd_ostream OS(Config->MapFile, EC, sys::fs::F_None); raw_fd_ostream os(config->mapFile, ec, sys::fs::F_None);
if (EC) if (ec)
fatal("cannot open " + Config->MapFile + ": " + EC.message()); fatal("cannot open " + config->mapFile + ": " + ec.message());
// Collect symbol info that we want to print out. // Collect symbol info that we want to print out.
std::vector<DefinedRegular *> Syms = getSymbols(); std::vector<DefinedRegular *> syms = getSymbols();
SymbolMapTy SectionSyms = getSectionSyms(Syms); SymbolMapTy sectionSyms = getSectionSyms(syms);
DenseMap<DefinedRegular *, std::string> SymStr = getSymbolStrings(Syms); DenseMap<DefinedRegular *, std::string> symStr = getSymbolStrings(syms);
// Print out the header line. // Print out the header line.
OS << "Address Size Align Out In Symbol\n"; os << "Address Size Align Out In Symbol\n";
// Print out file contents. // Print out file contents.
for (OutputSection *Sec : OutputSections) { for (OutputSection *sec : outputSections) {
writeHeader(OS, Sec->getRVA(), Sec->getVirtualSize(), /*Align=*/PageSize); writeHeader(os, sec->getRVA(), sec->getVirtualSize(), /*Align=*/pageSize);
OS << Sec->Name << '\n'; os << sec->name << '\n';
for (Chunk *C : Sec->Chunks) { for (Chunk *c : sec->chunks) {
auto *SC = dyn_cast<SectionChunk>(C); auto *sc = dyn_cast<SectionChunk>(c);
if (!SC) if (!sc)
continue; continue;
writeHeader(OS, SC->getRVA(), SC->getSize(), SC->getAlignment()); writeHeader(os, sc->getRVA(), sc->getSize(), sc->getAlignment());
OS << Indent8 << SC->File->getName() << ":(" << SC->getSectionName() os << indent8 << sc->file->getName() << ":(" << sc->getSectionName()
<< ")\n"; << ")\n";
for (DefinedRegular *Sym : SectionSyms[SC]) for (DefinedRegular *sym : sectionSyms[sc])
OS << SymStr[Sym] << '\n'; os << symStr[sym] << '\n';
} }
} }
} }

lld/trunk/COFF/MarkLive.h

Show All 11 Lines
#include "lld/Common/LLVM.h" #include "lld/Common/LLVM.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
namespace lld { namespace lld {
namespace coff { namespace coff {
class Chunk; class Chunk;
void markLive(ArrayRef<Chunk *> Chunks); void markLive(ArrayRef<Chunk *> chunks);
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
#endif // LLD_COFF_MARKLIVE_H #endif // LLD_COFF_MARKLIVE_H

lld/trunk/COFF/MarkLive.cpp

Show All 9 Lines
#include "Symbols.h" #include "Symbols.h"
#include "lld/Common/Timer.h" #include "lld/Common/Timer.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include <vector> #include <vector>
namespace lld { namespace lld {
namespace coff { namespace coff {
static Timer GCTimer("GC", Timer::root()); static Timer gCTimer("GC", Timer::root());
// Set live bit on for each reachable chunk. Unmarked (unreachable) // Set live bit on for each reachable chunk. Unmarked (unreachable)
// COMDAT chunks will be ignored by Writer, so they will be excluded // COMDAT chunks will be ignored by Writer, so they will be excluded
// from the final output. // from the final output.
void markLive(ArrayRef<Chunk *> Chunks) { void markLive(ArrayRef<Chunk *> chunks) {
ScopedTimer T(GCTimer); ScopedTimer t(gCTimer);
// We build up a worklist of sections which have been marked as live. We only // We build up a worklist of sections which have been marked as live. We only
// push into the worklist when we discover an unmarked section, and we mark // push into the worklist when we discover an unmarked section, and we mark
// as we push, so sections never appear twice in the list. // as we push, so sections never appear twice in the list.
SmallVector<SectionChunk *, 256> Worklist; SmallVector<SectionChunk *, 256> worklist;
// COMDAT section chunks are dead by default. Add non-COMDAT chunks. // COMDAT section chunks are dead by default. Add non-COMDAT chunks.
for (Chunk *C : Chunks) for (Chunk *c : chunks)
if (auto *SC = dyn_cast<SectionChunk>(C)) if (auto *sc = dyn_cast<SectionChunk>(c))
if (SC->Live) if (sc->live)
Worklist.push_back(SC); worklist.push_back(sc);
auto Enqueue = [&](SectionChunk *C) { auto enqueue = [&](SectionChunk *c) {
if (C->Live) if (c->live)
return; return;
C->Live = true; c->live = true;
Worklist.push_back(C); worklist.push_back(c);
}; };
auto AddSym = [&](Symbol *B) { auto addSym = [&](Symbol *b) {
if (auto *Sym = dyn_cast<DefinedRegular>(B)) if (auto *sym = dyn_cast<DefinedRegular>(b))
Enqueue(Sym->getChunk()); enqueue(sym->getChunk());
else if (auto *Sym = dyn_cast<DefinedImportData>(B)) else if (auto *sym = dyn_cast<DefinedImportData>(b))
Sym->File->Live = true; sym->file->live = true;
else if (auto *Sym = dyn_cast<DefinedImportThunk>(B)) else if (auto *sym = dyn_cast<DefinedImportThunk>(b))
Sym->WrappedSym->File->Live = Sym->WrappedSym->File->ThunkLive = true; sym->wrappedSym->file->live = sym->wrappedSym->file->thunkLive = true;
}; };
// Add GC root chunks. // Add GC root chunks.
for (Symbol *B : Config->GCRoot) for (Symbol *b : config->gCRoot)
AddSym(B); addSym(b);
while (!Worklist.empty()) { while (!worklist.empty()) {
SectionChunk *SC = Worklist.pop_back_val(); SectionChunk *sc = worklist.pop_back_val();
assert(SC->Live && "We mark as live when pushing onto the worklist!"); assert(sc->live && "We mark as live when pushing onto the worklist!");
// Mark all symbols listed in the relocation table for this section. // Mark all symbols listed in the relocation table for this section.
for (Symbol *B : SC->symbols()) for (Symbol *b : sc->symbols())
if (B) if (b)
AddSym(B); addSym(b);
// Mark associative sections if any. // Mark associative sections if any.
for (SectionChunk &C : SC->children()) for (SectionChunk &c : sc->children())
Enqueue(&C); enqueue(&c);
} }
} }
} }
} }

lld/trunk/COFF/MinGW.h

Show All 16 Lines
namespace coff { namespace coff {
// Logic for deciding what symbols to export, when exporting all // Logic for deciding what symbols to export, when exporting all
// symbols for MinGW. // symbols for MinGW.
class AutoExporter { class AutoExporter {
public: public:
AutoExporter(); AutoExporter();
void addWholeArchive(StringRef Path); void addWholeArchive(StringRef path);
llvm::StringSet<> ExcludeSymbols; llvm::StringSet<> excludeSymbols;
llvm::StringSet<> ExcludeSymbolPrefixes; llvm::StringSet<> excludeSymbolPrefixes;
llvm::StringSet<> ExcludeSymbolSuffixes; llvm::StringSet<> excludeSymbolSuffixes;
llvm::StringSet<> ExcludeLibs; llvm::StringSet<> excludeLibs;
llvm::StringSet<> ExcludeObjects; llvm::StringSet<> excludeObjects;
bool shouldExport(Defined *Sym) const; bool shouldExport(Defined *sym) const;
}; };
void writeDefFile(StringRef Name); void writeDefFile(StringRef name);
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/COFF/MinGW.cpp

Show All 13 Lines
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
using namespace lld; using namespace lld;
using namespace lld::coff; using namespace lld::coff;
using namespace llvm; using namespace llvm;
using namespace llvm::COFF; using namespace llvm::COFF;
AutoExporter::AutoExporter() { AutoExporter::AutoExporter() {
ExcludeLibs = { excludeLibs = {
"libgcc", "libgcc",
"libgcc_s", "libgcc_s",
"libstdc++", "libstdc++",
"libmingw32", "libmingw32",
"libmingwex", "libmingwex",
"libg2c", "libg2c",
"libsupc++", "libsupc++",
"libobjc", "libobjc",
"libgcj", "libgcj",
"libclang_rt.builtins", "libclang_rt.builtins",
"libclang_rt.builtins-aarch64", "libclang_rt.builtins-aarch64",
"libclang_rt.builtins-arm", "libclang_rt.builtins-arm",
"libclang_rt.builtins-i386", "libclang_rt.builtins-i386",
"libclang_rt.builtins-x86_64", "libclang_rt.builtins-x86_64",
"libc++", "libc++",
"libc++abi", "libc++abi",
"libunwind", "libunwind",
"libmsvcrt", "libmsvcrt",
"libucrtbase", "libucrtbase",
}; };
ExcludeObjects = { excludeObjects = {
"crt0.o", "crt1.o", "crt1u.o", "crt2.o", "crt2u.o", "dllcrt1.o", "crt0.o", "crt1.o", "crt1u.o", "crt2.o", "crt2u.o", "dllcrt1.o",
"dllcrt2.o", "gcrt0.o", "gcrt1.o", "gcrt2.o", "crtbegin.o", "crtend.o", "dllcrt2.o", "gcrt0.o", "gcrt1.o", "gcrt2.o", "crtbegin.o", "crtend.o",
}; };
ExcludeSymbolPrefixes = { excludeSymbolPrefixes = {
// Import symbols // Import symbols
"__imp_", "__imp_",
"__IMPORT_DESCRIPTOR_", "__IMPORT_DESCRIPTOR_",
// Extra import symbols from GNU import libraries // Extra import symbols from GNU import libraries
"__nm_", "__nm_",
// C++ symbols // C++ symbols
"__rtti_", "__rtti_",
"__builtin_", "__builtin_",
// Artifical symbols such as .refptr // Artifical symbols such as .refptr
".", ".",
}; };
ExcludeSymbolSuffixes = { excludeSymbolSuffixes = {
"_iname", "_iname",
"_NULL_THUNK_DATA", "_NULL_THUNK_DATA",
}; };
if (Config->Machine == I386) { if (config->machine == I386) {
ExcludeSymbols = { excludeSymbols = {
"__NULL_IMPORT_DESCRIPTOR", "__NULL_IMPORT_DESCRIPTOR",
"__pei386_runtime_relocator", "__pei386_runtime_relocator",
"_do_pseudo_reloc", "_do_pseudo_reloc",
"_impure_ptr", "_impure_ptr",
"__impure_ptr", "__impure_ptr",
"__fmode", "__fmode",
"_environ", "_environ",
"___dso_handle", "___dso_handle",
// These are the MinGW names that differ from the standard // These are the MinGW names that differ from the standard
// ones (lacking an extra underscore). // ones (lacking an extra underscore).
"_DllMain@12", "_DllMain@12",
"_DllEntryPoint@12", "_DllEntryPoint@12",
"_DllMainCRTStartup@12", "_DllMainCRTStartup@12",
}; };
ExcludeSymbolPrefixes.insert("__head_"); excludeSymbolPrefixes.insert("__head_");
} else { } else {
ExcludeSymbols = { excludeSymbols = {
"__NULL_IMPORT_DESCRIPTOR", "__NULL_IMPORT_DESCRIPTOR",
"_pei386_runtime_relocator", "_pei386_runtime_relocator",
"do_pseudo_reloc", "do_pseudo_reloc",
"impure_ptr", "impure_ptr",
"_impure_ptr", "_impure_ptr",
"_fmode", "_fmode",
"environ", "environ",
"__dso_handle", "__dso_handle",
// These are the MinGW names that differ from the standard // These are the MinGW names that differ from the standard
// ones (lacking an extra underscore). // ones (lacking an extra underscore).
"DllMain", "DllMain",
"DllEntryPoint", "DllEntryPoint",
"DllMainCRTStartup", "DllMainCRTStartup",
}; };
ExcludeSymbolPrefixes.insert("_head_"); excludeSymbolPrefixes.insert("_head_");
} }
} }
void AutoExporter::addWholeArchive(StringRef Path) { void AutoExporter::addWholeArchive(StringRef path) {
StringRef LibName = sys::path::filename(Path); StringRef libName = sys::path::filename(path);
// Drop the file extension, to match the processing below. // Drop the file extension, to match the processing below.
LibName = LibName.substr(0, LibName.rfind('.')); libName = libName.substr(0, libName.rfind('.'));
ExcludeLibs.erase(LibName); excludeLibs.erase(libName);
} }
bool AutoExporter::shouldExport(Defined *Sym) const { bool AutoExporter::shouldExport(Defined *sym) const {
if (!Sym || !Sym->isLive() || !Sym->getChunk()) if (!sym || !sym->isLive() || !sym->getChunk())
return false; return false;
// Only allow the symbol kinds that make sense to export; in particular, // Only allow the symbol kinds that make sense to export; in particular,
// disallow import symbols. // disallow import symbols.
if (!isa<DefinedRegular>(Sym) && !isa<DefinedCommon>(Sym)) if (!isa<DefinedRegular>(sym) && !isa<DefinedCommon>(sym))
return false; return false;
if (ExcludeSymbols.count(Sym->getName())) if (excludeSymbols.count(sym->getName()))
return false; return false;
for (StringRef Prefix : ExcludeSymbolPrefixes.keys()) for (StringRef prefix : excludeSymbolPrefixes.keys())
if (Sym->getName().startswith(Prefix)) if (sym->getName().startswith(prefix))
return false; return false;
for (StringRef Suffix : ExcludeSymbolSuffixes.keys()) for (StringRef suffix : excludeSymbolSuffixes.keys())
if (Sym->getName().endswith(Suffix)) if (sym->getName().endswith(suffix))
return false; return false;
// If a corresponding __imp_ symbol exists and is defined, don't export it. // If a corresponding __imp_ symbol exists and is defined, don't export it.
if (Symtab->find(("__imp_" + Sym->getName()).str())) if (symtab->find(("__imp_" + sym->getName()).str()))
return false; return false;
// Check that file is non-null before dereferencing it, symbols not // Check that file is non-null before dereferencing it, symbols not
// originating in regular object files probably shouldn't be exported. // originating in regular object files probably shouldn't be exported.
if (!Sym->getFile()) if (!sym->getFile())
return false; return false;
StringRef LibName = sys::path::filename(Sym->getFile()->ParentName); StringRef libName = sys::path::filename(sym->getFile()->parentName);
// Drop the file extension. // Drop the file extension.
LibName = LibName.substr(0, LibName.rfind('.')); libName = libName.substr(0, libName.rfind('.'));
if (!LibName.empty()) if (!libName.empty())
return !ExcludeLibs.count(LibName); return !excludeLibs.count(libName);
StringRef FileName = sys::path::filename(Sym->getFile()->getName()); StringRef fileName = sys::path::filename(sym->getFile()->getName());
return !ExcludeObjects.count(FileName); return !excludeObjects.count(fileName);
} }
void coff::writeDefFile(StringRef Name) { void coff::writeDefFile(StringRef name) {
std::error_code EC; std::error_code ec;
raw_fd_ostream OS(Name, EC, sys::fs::F_None); raw_fd_ostream os(name, ec, sys::fs::F_None);
if (EC) if (ec)
fatal("cannot open " + Name + ": " + EC.message()); fatal("cannot open " + name + ": " + ec.message());
OS << "EXPORTS\n"; os << "EXPORTS\n";
for (Export &E : Config->Exports) { for (Export &e : config->exports) {
OS << " " << E.ExportName << " " os << " " << e.exportName << " "
<< "@" << E.Ordinal; << "@" << e.ordinal;
if (auto *Def = dyn_cast_or_null<Defined>(E.Sym)) { if (auto *def = dyn_cast_or_null<Defined>(e.sym)) {
if (Def && Def->getChunk() && if (def && def->getChunk() &&
!(Def->getChunk()->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE)) !(def->getChunk()->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE))
OS << " DATA"; os << " DATA";
} }
OS << "\n"; os << "\n";
} }
} }

lld/trunk/COFF/PDB.h

Show All 18 Lines
} }
namespace lld { namespace lld {
namespace coff { namespace coff {
class OutputSection; class OutputSection;
class SectionChunk; class SectionChunk;
class SymbolTable; class SymbolTable;
void createPDB(SymbolTable *Symtab, void createPDB(SymbolTable *symtab,
llvm::ArrayRef<OutputSection *> OutputSections, llvm::ArrayRef<OutputSection *> outputSections,
llvm::ArrayRef<uint8_t> SectionTable, llvm::ArrayRef<uint8_t> sectionTable,
llvm::codeview::DebugInfo *BuildId); llvm::codeview::DebugInfo *buildId);
std::pair<llvm::StringRef, uint32_t> getFileLine(const SectionChunk *C, std::pair<llvm::StringRef, uint32_t> getFileLine(const SectionChunk *c,
uint32_t Addr); uint32_t addr);
} }
} }
#endif #endif

lld/trunk/COFF/PDB.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
using namespace lld; using namespace lld;
using namespace lld::coff; using namespace lld::coff;
using namespace llvm; using namespace llvm;
using namespace llvm::codeview; using namespace llvm::codeview;
using llvm::object::coff_section; using llvm::object::coff_section;
static ExitOnError ExitOnErr; static ExitOnError exitOnErr;
static Timer TotalPdbLinkTimer("PDB Emission (Cumulative)", Timer::root()); static Timer totalPdbLinkTimer("PDB Emission (Cumulative)", Timer::root());
static Timer AddObjectsTimer("Add Objects", TotalPdbLinkTimer); static Timer addObjectsTimer("Add Objects", totalPdbLinkTimer);
static Timer TypeMergingTimer("Type Merging", AddObjectsTimer); static Timer typeMergingTimer("Type Merging", addObjectsTimer);
static Timer SymbolMergingTimer("Symbol Merging", AddObjectsTimer); static Timer symbolMergingTimer("Symbol Merging", addObjectsTimer);
static Timer GlobalsLayoutTimer("Globals Stream Layout", TotalPdbLinkTimer); static Timer globalsLayoutTimer("Globals Stream Layout", totalPdbLinkTimer);
static Timer TpiStreamLayoutTimer("TPI Stream Layout", TotalPdbLinkTimer); static Timer tpiStreamLayoutTimer("TPI Stream Layout", totalPdbLinkTimer);
static Timer DiskCommitTimer("Commit to Disk", TotalPdbLinkTimer); static Timer diskCommitTimer("Commit to Disk", totalPdbLinkTimer);
namespace { namespace {
class DebugSHandler; class DebugSHandler;
class PDBLinker { class PDBLinker {
friend DebugSHandler; friend DebugSHandler;
public: public:
PDBLinker(SymbolTable *Symtab) PDBLinker(SymbolTable *symtab)
: Alloc(), Symtab(Symtab), Builder(Alloc), TMerger(Alloc) { : alloc(), symtab(symtab), builder(alloc), tMerger(alloc) {
// This isn't strictly necessary, but link.exe usually puts an empty string // This isn't strictly necessary, but link.exe usually puts an empty string
// as the first "valid" string in the string table, so we do the same in // as the first "valid" string in the string table, so we do the same in
// order to maintain as much byte-for-byte compatibility as possible. // order to maintain as much byte-for-byte compatibility as possible.
PDBStrTab.insert(""); pdbStrTab.insert("");
} }
/// Emit the basic PDB structure: initial streams, headers, etc. /// Emit the basic PDB structure: initial streams, headers, etc.
void initialize(llvm::codeview::DebugInfo *BuildId); void initialize(llvm::codeview::DebugInfo *buildId);
/// Add natvis files specified on the command line. /// Add natvis files specified on the command line.
void addNatvisFiles(); void addNatvisFiles();
/// Link CodeView from each object file in the symbol table into the PDB. /// Link CodeView from each object file in the symbol table into the PDB.
void addObjectsToPDB(); void addObjectsToPDB();
/// Link info for each import file in the symbol table into the PDB. /// Link info for each import file in the symbol table into the PDB.
void addImportFilesToPDB(ArrayRef<OutputSection *> OutputSections); void addImportFilesToPDB(ArrayRef<OutputSection *> outputSections);
/// Link CodeView from a single object file into the target (output) PDB. /// Link CodeView from a single object file into the target (output) PDB.
/// When a precompiled headers object is linked, its TPI map might be provided /// When a precompiled headers object is linked, its TPI map might be provided
/// externally. /// externally.
void addObjFile(ObjFile *File, CVIndexMap *ExternIndexMap = nullptr); void addObjFile(ObjFile *file, CVIndexMap *externIndexMap = nullptr);
/// Produce a mapping from the type and item indices used in the object /// Produce a mapping from the type and item indices used in the object
/// file to those in the destination PDB. /// file to those in the destination PDB.
/// ///
/// If the object file uses a type server PDB (compiled with /Zi), merge TPI /// If the object file uses a type server PDB (compiled with /Zi), merge TPI
/// and IPI from the type server PDB and return a map for it. Each unique type /// and IPI from the type server PDB and return a map for it. Each unique type
/// server PDB is merged at most once, so this may return an existing index /// server PDB is merged at most once, so this may return an existing index
/// mapping. /// mapping.
/// ///
/// If the object does not use a type server PDB (compiled with /Z7), we merge /// If the object does not use a type server PDB (compiled with /Z7), we merge
/// all the type and item records from the .debug$S stream and fill in the /// all the type and item records from the .debug$S stream and fill in the
/// caller-provided ObjectIndexMap. /// caller-provided ObjectIndexMap.
Expected<const CVIndexMap &> mergeDebugT(ObjFile *File, Expected<const CVIndexMap &> mergeDebugT(ObjFile *file,
CVIndexMap *ObjectIndexMap); CVIndexMap *objectIndexMap);
/// Reads and makes available a PDB. /// Reads and makes available a PDB.
Expected<const CVIndexMap &> maybeMergeTypeServerPDB(ObjFile *File); Expected<const CVIndexMap &> maybeMergeTypeServerPDB(ObjFile *file);
/// Merges a precompiled headers TPI map into the current TPI map. The /// Merges a precompiled headers TPI map into the current TPI map. The
/// precompiled headers object will also be loaded and remapped in the /// precompiled headers object will also be loaded and remapped in the
/// process. /// process.
Error mergeInPrecompHeaderObj(ObjFile *File, CVIndexMap *ObjectIndexMap); Error mergeInPrecompHeaderObj(ObjFile *file, CVIndexMap *objectIndexMap);
/// Reads and makes available a precompiled headers object. /// Reads and makes available a precompiled headers object.
/// ///
/// This is a requirement for objects compiled with cl.exe /Yu. In that /// This is a requirement for objects compiled with cl.exe /Yu. In that
/// case, the referenced object (which was compiled with /Yc) has to be loaded /// case, the referenced object (which was compiled with /Yc) has to be loaded
/// first. This is mainly because the current object's TPI stream has external /// first. This is mainly because the current object's TPI stream has external
/// references to the precompiled headers object. /// references to the precompiled headers object.
/// ///
/// If the precompiled headers object was already loaded, this function will /// If the precompiled headers object was already loaded, this function will
/// simply return its (remapped) TPI map. /// simply return its (remapped) TPI map.
Expected<const CVIndexMap &> aquirePrecompObj(ObjFile *File); Expected<const CVIndexMap &> aquirePrecompObj(ObjFile *file);
/// Adds a precompiled headers object signature -> TPI mapping. /// Adds a precompiled headers object signature -> TPI mapping.
std::pair<CVIndexMap &, bool /*already there*/> std::pair<CVIndexMap &, bool /*already there*/>
registerPrecompiledHeaders(uint32_t Signature); registerPrecompiledHeaders(uint32_t signature);
void mergeSymbolRecords(ObjFile *File, const CVIndexMap &IndexMap, void mergeSymbolRecords(ObjFile *file, const CVIndexMap &indexMap,
std::vector<ulittle32_t *> &StringTableRefs, std::vector<ulittle32_t *> &stringTableRefs,
BinaryStreamRef SymData); BinaryStreamRef symData);
/// Add the section map and section contributions to the PDB. /// Add the section map and section contributions to the PDB.
void addSections(ArrayRef<OutputSection *> OutputSections, void addSections(ArrayRef<OutputSection *> outputSections,
ArrayRef<uint8_t> SectionTable); ArrayRef<uint8_t> sectionTable);
/// Write the PDB to disk and store the Guid generated for it in *Guid. /// Write the PDB to disk and store the Guid generated for it in *Guid.
void commit(codeview::GUID *Guid); void commit(codeview::GUID *guid);
// Print statistics regarding the final PDB // Print statistics regarding the final PDB
void printStats(); void printStats();
private: private:
BumpPtrAllocator Alloc; BumpPtrAllocator alloc;
SymbolTable *Symtab; SymbolTable *symtab;
pdb::PDBFileBuilder Builder; pdb::PDBFileBuilder builder;
TypeMerger TMerger; TypeMerger tMerger;
/// PDBs use a single global string table for filenames in the file checksum /// PDBs use a single global string table for filenames in the file checksum
/// table. /// table.
DebugStringTableSubsection PDBStrTab; DebugStringTableSubsection pdbStrTab;
llvm::SmallString<128> NativePath; llvm::SmallString<128> nativePath;
std::vector<pdb::SecMapEntry> SectionMap; std::vector<pdb::SecMapEntry> sectionMap;
/// Type index mappings of type server PDBs that we've loaded so far. /// Type index mappings of type server PDBs that we've loaded so far.
std::map<codeview::GUID, CVIndexMap> TypeServerIndexMappings; std::map<codeview::GUID, CVIndexMap> typeServerIndexMappings;
/// Type index mappings of precompiled objects type map that we've loaded so /// Type index mappings of precompiled objects type map that we've loaded so
/// far. /// far.
std::map<uint32_t, CVIndexMap> PrecompTypeIndexMappings; std::map<uint32_t, CVIndexMap> precompTypeIndexMappings;
// For statistics // For statistics
uint64_t GlobalSymbols = 0; uint64_t globalSymbols = 0;
uint64_t ModuleSymbols = 0; uint64_t moduleSymbols = 0;
uint64_t PublicSymbols = 0; uint64_t publicSymbols = 0;
}; };
class DebugSHandler { class DebugSHandler {
PDBLinker &Linker; PDBLinker &linker;
/// The object file whose .debug$S sections we're processing. /// The object file whose .debug$S sections we're processing.
ObjFile &File; ObjFile &file;
/// The result of merging type indices. /// The result of merging type indices.
const CVIndexMap &IndexMap; const CVIndexMap &indexMap;
/// The DEBUG_S_STRINGTABLE subsection. These strings are referred to by /// The DEBUG_S_STRINGTABLE subsection. These strings are referred to by
/// index from other records in the .debug$S section. All of these strings /// index from other records in the .debug$S section. All of these strings
/// need to be added to the global PDB string table, and all references to /// need to be added to the global PDB string table, and all references to
/// these strings need to have their indices re-written to refer to the /// these strings need to have their indices re-written to refer to the
/// global PDB string table. /// global PDB string table.
DebugStringTableSubsectionRef CVStrTab; DebugStringTableSubsectionRef cVStrTab;
/// The DEBUG_S_FILECHKSMS subsection. As above, these are referred to /// The DEBUG_S_FILECHKSMS subsection. As above, these are referred to
/// by other records in the .debug$S section and need to be merged into the /// by other records in the .debug$S section and need to be merged into the
/// PDB. /// PDB.
DebugChecksumsSubsectionRef Checksums; DebugChecksumsSubsectionRef checksums;
/// The DEBUG_S_INLINEELINES subsection. There can be only one of these per /// The DEBUG_S_INLINEELINES subsection. There can be only one of these per
/// object file. /// object file.
DebugInlineeLinesSubsectionRef InlineeLines; DebugInlineeLinesSubsectionRef inlineeLines;
/// The DEBUG_S_FRAMEDATA subsection(s). There can be more than one of /// The DEBUG_S_FRAMEDATA subsection(s). There can be more than one of
/// these and they need not appear in any specific order. However, they /// these and they need not appear in any specific order. However, they
/// contain string table references which need to be re-written, so we /// contain string table references which need to be re-written, so we
/// collect them all here and re-write them after all subsections have been /// collect them all here and re-write them after all subsections have been
/// discovered and processed. /// discovered and processed.
std::vector<DebugFrameDataSubsectionRef> NewFpoFrames; std::vector<DebugFrameDataSubsectionRef> newFpoFrames;
/// Pointers to raw memory that we determine have string table references /// Pointers to raw memory that we determine have string table references
/// that need to be re-written. We first process all .debug$S subsections /// that need to be re-written. We first process all .debug$S subsections
/// to ensure that we can handle subsections written in any order, building /// to ensure that we can handle subsections written in any order, building
/// up this list as we go. At the end, we use the string table (which must /// up this list as we go. At the end, we use the string table (which must
/// have been discovered by now else it is an error) to re-write these /// have been discovered by now else it is an error) to re-write these
/// references. /// references.
std::vector<ulittle32_t *> StringTableReferences; std::vector<ulittle32_t *> stringTableReferences;
public: public:
DebugSHandler(PDBLinker &Linker, ObjFile &File, const CVIndexMap &IndexMap) DebugSHandler(PDBLinker &linker, ObjFile &file, const CVIndexMap &indexMap)
: Linker(Linker), File(File), IndexMap(IndexMap) {} : linker(linker), file(file), indexMap(indexMap) {}
void handleDebugS(lld::coff::SectionChunk &DebugS); void handleDebugS(lld::coff::SectionChunk &debugS);
std::shared_ptr<DebugInlineeLinesSubsection> std::shared_ptr<DebugInlineeLinesSubsection>
mergeInlineeLines(DebugChecksumsSubsection *NewChecksums); mergeInlineeLines(DebugChecksumsSubsection *newChecksums);
void finish(); void finish();
}; };
} }
// Visual Studio's debugger requires absolute paths in various places in the // Visual Studio's debugger requires absolute paths in various places in the
// PDB to work without additional configuration: // PDB to work without additional configuration:
// https://docs.microsoft.com/en-us/visualstudio/debugger/debug-source-files-common-properties-solution-property-pages-dialog-box // https://docs.microsoft.com/en-us/visualstudio/debugger/debug-source-files-common-properties-solution-property-pages-dialog-box
static void pdbMakeAbsolute(SmallVectorImpl<char> &FileName) { static void pdbMakeAbsolute(SmallVectorImpl<char> &fileName) {
// The default behavior is to produce paths that are valid within the context // The default behavior is to produce paths that are valid within the context
// of the machine that you perform the link on. If the linker is running on // of the machine that you perform the link on. If the linker is running on
// a POSIX system, we will output absolute POSIX paths. If the linker is // a POSIX system, we will output absolute POSIX paths. If the linker is
// running on a Windows system, we will output absolute Windows paths. If the // running on a Windows system, we will output absolute Windows paths. If the
// user desires any other kind of behavior, they should explicitly pass // user desires any other kind of behavior, they should explicitly pass
// /pdbsourcepath, in which case we will treat the exact string the user // /pdbsourcepath, in which case we will treat the exact string the user
// passed in as the gospel and not normalize, canonicalize it. // passed in as the gospel and not normalize, canonicalize it.
if (sys::path::is_absolute(FileName, sys::path::Style::windows) || if (sys::path::is_absolute(fileName, sys::path::Style::windows) ||
sys::path::is_absolute(FileName, sys::path::Style::posix)) sys::path::is_absolute(fileName, sys::path::Style::posix))
return; return;
// It's not absolute in any path syntax. Relative paths necessarily refer to // It's not absolute in any path syntax. Relative paths necessarily refer to
// the local file system, so we can make it native without ending up with a // the local file system, so we can make it native without ending up with a
// nonsensical path. // nonsensical path.
if (Config->PDBSourcePath.empty()) { if (config->pdbSourcePath.empty()) {
sys::path::native(FileName); sys::path::native(fileName);
sys::fs::make_absolute(FileName); sys::fs::make_absolute(fileName);
return; return;
} }
// Try to guess whether /PDBSOURCEPATH is a unix path or a windows path. // Try to guess whether /PDBSOURCEPATH is a unix path or a windows path.
// Since PDB's are more of a Windows thing, we make this conservative and only // Since PDB's are more of a Windows thing, we make this conservative and only
// decide that it's a unix path if we're fairly certain. Specifically, if // decide that it's a unix path if we're fairly certain. Specifically, if
// it starts with a forward slash. // it starts with a forward slash.
SmallString<128> AbsoluteFileName = Config->PDBSourcePath; SmallString<128> absoluteFileName = config->pdbSourcePath;
sys::path::Style GuessedStyle = AbsoluteFileName.startswith("/") sys::path::Style guessedStyle = absoluteFileName.startswith("/")
? sys::path::Style::posix ? sys::path::Style::posix
: sys::path::Style::windows; : sys::path::Style::windows;
sys::path::append(AbsoluteFileName, GuessedStyle, FileName); sys::path::append(absoluteFileName, guessedStyle, fileName);
sys::path::native(AbsoluteFileName, GuessedStyle); sys::path::native(absoluteFileName, guessedStyle);
sys::path::remove_dots(AbsoluteFileName, true, GuessedStyle); sys::path::remove_dots(absoluteFileName, true, guessedStyle);
FileName = std::move(AbsoluteFileName); fileName = std::move(absoluteFileName);
} }
// A COFF .debug$H section is currently a clang extension. This function checks // A COFF .debug$H section is currently a clang extension. This function checks
// if a .debug$H section is in a format that we expect / understand, so that we // if a .debug$H section is in a format that we expect / understand, so that we
// can ignore any sections which are coincidentally also named .debug$H but do // can ignore any sections which are coincidentally also named .debug$H but do
// not contain a format we recognize. // not contain a format we recognize.
static bool canUseDebugH(ArrayRef<uint8_t> DebugH) { static bool canUseDebugH(ArrayRef<uint8_t> debugH) {
if (DebugH.size() < sizeof(object::debug_h_header)) if (debugH.size() < sizeof(object::debug_h_header))
return false; return false;
auto *Header = auto *header =
reinterpret_cast<const object::debug_h_header *>(DebugH.data()); reinterpret_cast<const object::debug_h_header *>(debugH.data());
DebugH = DebugH.drop_front(sizeof(object::debug_h_header)); debugH = debugH.drop_front(sizeof(object::debug_h_header));
return Header->Magic == COFF::DEBUG_HASHES_SECTION_MAGIC && return header->Magic == COFF::DEBUG_HASHES_SECTION_MAGIC &&
Header->Version == 0 && header->Version == 0 &&
Header->HashAlgorithm == uint16_t(GlobalTypeHashAlg::SHA1_8) && header->HashAlgorithm == uint16_t(GlobalTypeHashAlg::SHA1_8) &&
(DebugH.size() % 8 == 0); (debugH.size() % 8 == 0);
} }
static Optional<ArrayRef<uint8_t>> getDebugH(ObjFile *File) { static Optional<ArrayRef<uint8_t>> getDebugH(ObjFile *file) {
SectionChunk *Sec = SectionChunk *sec =
SectionChunk::findByName(File->getDebugChunks(), ".debug$H"); SectionChunk::findByName(file->getDebugChunks(), ".debug$H");
if (!Sec) if (!sec)
return llvm::None; return llvm::None;
ArrayRef<uint8_t> Contents = Sec->getContents(); ArrayRef<uint8_t> contents = sec->getContents();
if (!canUseDebugH(Contents)) if (!canUseDebugH(contents))
return None; return None;
return Contents; return contents;
} }
static ArrayRef<GloballyHashedType> static ArrayRef<GloballyHashedType>
getHashesFromDebugH(ArrayRef<uint8_t> DebugH) { getHashesFromDebugH(ArrayRef<uint8_t> debugH) {
assert(canUseDebugH(DebugH)); assert(canUseDebugH(debugH));
DebugH = DebugH.drop_front(sizeof(object::debug_h_header)); debugH = debugH.drop_front(sizeof(object::debug_h_header));
uint32_t Count = DebugH.size() / sizeof(GloballyHashedType); uint32_t count = debugH.size() / sizeof(GloballyHashedType);
return {reinterpret_cast<const GloballyHashedType *>(DebugH.data()), Count}; return {reinterpret_cast<const GloballyHashedType *>(debugH.data()), count};
} }
static void addTypeInfo(pdb::TpiStreamBuilder &TpiBuilder, static void addTypeInfo(pdb::TpiStreamBuilder &tpiBuilder,
TypeCollection &TypeTable) { TypeCollection &typeTable) {
// Start the TPI or IPI stream header. // Start the TPI or IPI stream header.
TpiBuilder.setVersionHeader(pdb::PdbTpiV80); tpiBuilder.setVersionHeader(pdb::PdbTpiV80);
// Flatten the in memory type table and hash each type. // Flatten the in memory type table and hash each type.
TypeTable.ForEachRecord([&](TypeIndex TI, const CVType &Type) { typeTable.ForEachRecord([&](TypeIndex ti, const CVType &type) {
auto Hash = pdb::hashTypeRecord(Type); auto hash = pdb::hashTypeRecord(type);
if (auto E = Hash.takeError()) if (auto e = hash.takeError())
fatal("type hashing error"); fatal("type hashing error");
TpiBuilder.addTypeRecord(Type.RecordData, *Hash); tpiBuilder.addTypeRecord(type.RecordData, *hash);
}); });
} }
Expected<const CVIndexMap &> Expected<const CVIndexMap &>
PDBLinker::mergeDebugT(ObjFile *File, CVIndexMap *ObjectIndexMap) { PDBLinker::mergeDebugT(ObjFile *file, CVIndexMap *objectIndexMap) {
ScopedTimer T(TypeMergingTimer); ScopedTimer t(typeMergingTimer);
if (!File->DebugTypesObj) if (!file->debugTypesObj)
return *ObjectIndexMap; // no Types stream return *objectIndexMap; // no Types stream
// Precompiled headers objects need to save the index map for further // Precompiled headers objects need to save the index map for further
// reference by other objects which use the precompiled headers. // reference by other objects which use the precompiled headers.
if (File->DebugTypesObj->Kind == TpiSource::PCH) { if (file->debugTypesObj->kind == TpiSource::PCH) {
uint32_t PCHSignature = File->PCHSignature.getValueOr(0); uint32_t pchSignature = file->pchSignature.getValueOr(0);
if (PCHSignature == 0) if (pchSignature == 0)
fatal("No signature found for the precompiled headers OBJ (" + fatal("No signature found for the precompiled headers OBJ (" +
File->getName() + ")"); file->getName() + ")");
// When a precompiled headers object comes first on the command-line, we // When a precompiled headers object comes first on the command-line, we
// update the mapping here. Otherwise, if an object referencing the // update the mapping here. Otherwise, if an object referencing the
// precompiled headers object comes first, the mapping is created in // precompiled headers object comes first, the mapping is created in
// aquirePrecompObj(), thus we would skip this block. // aquirePrecompObj(), thus we would skip this block.
if (!ObjectIndexMap->IsPrecompiledTypeMap) { if (!objectIndexMap->isPrecompiledTypeMap) {
auto R = registerPrecompiledHeaders(PCHSignature); auto r = registerPrecompiledHeaders(pchSignature);
if (R.second) if (r.second)
fatal( fatal(
"A precompiled headers OBJ with the same signature was already " "A precompiled headers OBJ with the same signature was already "
"provided! (" + "provided! (" +
File->getName() + ")"); file->getName() + ")");
ObjectIndexMap = &R.first; objectIndexMap = &r.first;
} }
} }
if (File->DebugTypesObj->Kind == TpiSource::UsingPDB) { if (file->debugTypesObj->kind == TpiSource::UsingPDB) {
// Look through type servers. If we've already seen this type server, // Look through type servers. If we've already seen this type server,
// don't merge any type information. // don't merge any type information.
return maybeMergeTypeServerPDB(File); return maybeMergeTypeServerPDB(file);
} }
CVTypeArray &Types = *File->DebugTypes; CVTypeArray &types = *file->debugTypes;
if (File->DebugTypesObj->Kind == TpiSource::UsingPCH) { if (file->debugTypesObj->kind == TpiSource::UsingPCH) {
// This object was compiled with /Yu, so process the corresponding // This object was compiled with /Yu, so process the corresponding
// precompiled headers object (/Yc) first. Some type indices in the current // precompiled headers object (/Yc) first. Some type indices in the current
// object are referencing data in the precompiled headers object, so we need // object are referencing data in the precompiled headers object, so we need
// both to be loaded. // both to be loaded.
Error E = mergeInPrecompHeaderObj(File, ObjectIndexMap); Error e = mergeInPrecompHeaderObj(file, objectIndexMap);
if (E) if (e)
return std::move(E); return std::move(e);
// Drop LF_PRECOMP record from the input stream, as it has been replaced // Drop LF_PRECOMP record from the input stream, as it has been replaced
// with the precompiled headers Type stream in the mergeInPrecompHeaderObj() // with the precompiled headers Type stream in the mergeInPrecompHeaderObj()
// call above. Note that we can't just call Types.drop_front(), as we // call above. Note that we can't just call Types.drop_front(), as we
// explicitly want to rebase the stream. // explicitly want to rebase the stream.
CVTypeArray::Iterator FirstType = Types.begin(); CVTypeArray::Iterator firstType = types.begin();
Types.setUnderlyingStream( types.setUnderlyingStream(
Types.getUnderlyingStream().drop_front(FirstType->RecordData.size())); types.getUnderlyingStream().drop_front(firstType->RecordData.size()));
} }
// Fill in the temporary, caller-provided ObjectIndexMap. // Fill in the temporary, caller-provided ObjectIndexMap.
if (Config->DebugGHashes) { if (config->debugGHashes) {
ArrayRef<GloballyHashedType> Hashes; ArrayRef<GloballyHashedType> hashes;
std::vector<GloballyHashedType> OwnedHashes; std::vector<GloballyHashedType> ownedHashes;
if (Optional<ArrayRef<uint8_t>> DebugH = getDebugH(File)) if (Optional<ArrayRef<uint8_t>> debugH = getDebugH(file))
Hashes = getHashesFromDebugH(*DebugH); hashes = getHashesFromDebugH(*debugH);
else { else {
OwnedHashes = GloballyHashedType::hashTypes(Types); ownedHashes = GloballyHashedType::hashTypes(types);
Hashes = OwnedHashes; hashes = ownedHashes;
} }
if (auto Err = mergeTypeAndIdRecords( if (auto err = mergeTypeAndIdRecords(
TMerger.GlobalIDTable, TMerger.GlobalTypeTable, tMerger.globalIDTable, tMerger.globalTypeTable,
ObjectIndexMap->TPIMap, Types, Hashes, File->PCHSignature)) objectIndexMap->tpiMap, types, hashes, file->pchSignature))
fatal("codeview::mergeTypeAndIdRecords failed: " + fatal("codeview::mergeTypeAndIdRecords failed: " +
toString(std::move(Err))); toString(std::move(err)));
} else { } else {
if (auto Err = mergeTypeAndIdRecords(TMerger.IDTable, TMerger.TypeTable, if (auto err = mergeTypeAndIdRecords(tMerger.iDTable, tMerger.typeTable,
ObjectIndexMap->TPIMap, Types, objectIndexMap->tpiMap, types,
File->PCHSignature)) file->pchSignature))
fatal("codeview::mergeTypeAndIdRecords failed: " + fatal("codeview::mergeTypeAndIdRecords failed: " +
toString(std::move(Err))); toString(std::move(err)));
} }
return *ObjectIndexMap; return *objectIndexMap;
} }
Expected<const CVIndexMap &> PDBLinker::maybeMergeTypeServerPDB(ObjFile *File) { Expected<const CVIndexMap &> PDBLinker::maybeMergeTypeServerPDB(ObjFile *file) {
Expected<llvm::pdb::NativeSession *> PDBSession = findTypeServerSource(File); Expected<llvm::pdb::NativeSession *> pdbSession = findTypeServerSource(file);
if (!PDBSession) if (!pdbSession)
return PDBSession.takeError(); return pdbSession.takeError();
pdb::PDBFile &PDBFile = PDBSession.get()->getPDBFile(); pdb::PDBFile &pdbFile = pdbSession.get()->getPDBFile();
pdb::InfoStream &Info = cantFail(PDBFile.getPDBInfoStream()); pdb::InfoStream &info = cantFail(pdbFile.getPDBInfoStream());
auto It = TypeServerIndexMappings.emplace(Info.getGuid(), CVIndexMap()); auto it = typeServerIndexMappings.emplace(info.getGuid(), CVIndexMap());
CVIndexMap &IndexMap = It.first->second; CVIndexMap &indexMap = it.first->second;
if (!It.second) if (!it.second)
return IndexMap; // already merged return indexMap; // already merged
// Mark this map as a type server map. // Mark this map as a type server map.
IndexMap.IsTypeServerMap = true; indexMap.isTypeServerMap = true;
Expected<pdb::TpiStream &> ExpectedTpi = PDBFile.getPDBTpiStream(); Expected<pdb::TpiStream &> expectedTpi = pdbFile.getPDBTpiStream();
if (auto E = ExpectedTpi.takeError()) if (auto e = expectedTpi.takeError())
fatal("Type server does not have TPI stream: " + toString(std::move(E))); fatal("Type server does not have TPI stream: " + toString(std::move(e)));
pdb::TpiStream *MaybeIpi = nullptr; pdb::TpiStream *maybeIpi = nullptr;
if (PDBFile.hasPDBIpiStream()) { if (pdbFile.hasPDBIpiStream()) {
Expected<pdb::TpiStream &> ExpectedIpi = PDBFile.getPDBIpiStream(); Expected<pdb::TpiStream &> expectedIpi = pdbFile.getPDBIpiStream();
if (auto E = ExpectedIpi.takeError()) if (auto e = expectedIpi.takeError())
fatal("Error getting type server IPI stream: " + toString(std::move(E))); fatal("Error getting type server IPI stream: " + toString(std::move(e)));
MaybeIpi = &*ExpectedIpi; maybeIpi = &*expectedIpi;
} }
if (Config->DebugGHashes) { if (config->debugGHashes) {
// PDBs do not actually store global hashes, so when merging a type server // PDBs do not actually store global hashes, so when merging a type server
// PDB we have to synthesize global hashes. To do this, we first synthesize // PDB we have to synthesize global hashes. To do this, we first synthesize
// global hashes for the TPI stream, since it is independent, then we // global hashes for the TPI stream, since it is independent, then we
// synthesize hashes for the IPI stream, using the hashes for the TPI stream // synthesize hashes for the IPI stream, using the hashes for the TPI stream
// as inputs. // as inputs.
auto TpiHashes = GloballyHashedType::hashTypes(ExpectedTpi->typeArray()); auto tpiHashes = GloballyHashedType::hashTypes(expectedTpi->typeArray());
Optional<uint32_t> EndPrecomp; Optional<uint32_t> endPrecomp;
// Merge TPI first, because the IPI stream will reference type indices. // Merge TPI first, because the IPI stream will reference type indices.
if (auto Err = if (auto err =
mergeTypeRecords(TMerger.GlobalTypeTable, IndexMap.TPIMap, mergeTypeRecords(tMerger.globalTypeTable, indexMap.tpiMap,
ExpectedTpi->typeArray(), TpiHashes, EndPrecomp)) expectedTpi->typeArray(), tpiHashes, endPrecomp))
fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err))); fatal("codeview::mergeTypeRecords failed: " + toString(std::move(err)));
// Merge IPI. // Merge IPI.
if (MaybeIpi) { if (maybeIpi) {
auto IpiHashes = auto ipiHashes =
GloballyHashedType::hashIds(MaybeIpi->typeArray(), TpiHashes); GloballyHashedType::hashIds(maybeIpi->typeArray(), tpiHashes);
if (auto Err = if (auto err =
mergeIdRecords(TMerger.GlobalIDTable, IndexMap.TPIMap, mergeIdRecords(tMerger.globalIDTable, indexMap.tpiMap,
IndexMap.IPIMap, MaybeIpi->typeArray(), IpiHashes)) indexMap.ipiMap, maybeIpi->typeArray(), ipiHashes))
fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err))); fatal("codeview::mergeIdRecords failed: " + toString(std::move(err)));
} }
} else { } else {
// Merge TPI first, because the IPI stream will reference type indices. // Merge TPI first, because the IPI stream will reference type indices.
if (auto Err = mergeTypeRecords(TMerger.TypeTable, IndexMap.TPIMap, if (auto err = mergeTypeRecords(tMerger.typeTable, indexMap.tpiMap,
ExpectedTpi->typeArray())) expectedTpi->typeArray()))
fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err))); fatal("codeview::mergeTypeRecords failed: " + toString(std::move(err)));
// Merge IPI. // Merge IPI.
if (MaybeIpi) { if (maybeIpi) {
if (auto Err = mergeIdRecords(TMerger.IDTable, IndexMap.TPIMap, if (auto err = mergeIdRecords(tMerger.iDTable, indexMap.tpiMap,
IndexMap.IPIMap, MaybeIpi->typeArray())) indexMap.ipiMap, maybeIpi->typeArray()))
fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err))); fatal("codeview::mergeIdRecords failed: " + toString(std::move(err)));
} }
} }
return IndexMap; return indexMap;
} }
Error PDBLinker::mergeInPrecompHeaderObj(ObjFile *File, Error PDBLinker::mergeInPrecompHeaderObj(ObjFile *file,
CVIndexMap *ObjectIndexMap) { CVIndexMap *objectIndexMap) {
const PrecompRecord &Precomp = const PrecompRecord &precomp =
retrieveDependencyInfo<PrecompRecord>(File->DebugTypesObj); retrieveDependencyInfo<PrecompRecord>(file->debugTypesObj);
Expected<const CVIndexMap &> E = aquirePrecompObj(File); Expected<const CVIndexMap &> e = aquirePrecompObj(file);
if (!E) if (!e)
return E.takeError(); return e.takeError();
const CVIndexMap &PrecompIndexMap = *E; const CVIndexMap &precompIndexMap = *e;
assert(PrecompIndexMap.IsPrecompiledTypeMap); assert(precompIndexMap.isPrecompiledTypeMap);
if (PrecompIndexMap.TPIMap.empty()) if (precompIndexMap.tpiMap.empty())
return Error::success(); return Error::success();
assert(Precomp.getStartTypeIndex() == TypeIndex::FirstNonSimpleIndex); assert(precomp.getStartTypeIndex() == TypeIndex::FirstNonSimpleIndex);
assert(Precomp.getTypesCount() <= PrecompIndexMap.TPIMap.size()); assert(precomp.getTypesCount() <= precompIndexMap.tpiMap.size());
// Use the previously remapped index map from the precompiled headers. // Use the previously remapped index map from the precompiled headers.
ObjectIndexMap->TPIMap.append(PrecompIndexMap.TPIMap.begin(), objectIndexMap->tpiMap.append(precompIndexMap.tpiMap.begin(),
PrecompIndexMap.TPIMap.begin() + precompIndexMap.tpiMap.begin() +
Precomp.getTypesCount()); precomp.getTypesCount());
return Error::success(); return Error::success();
} }
static bool equals_path(StringRef path1, StringRef path2) { static bool equals_path(StringRef path1, StringRef path2) {
#if defined(_WIN32) #if defined(_WIN32)
return path1.equals_lower(path2); return path1.equals_lower(path2);
#else #else
return path1.equals(path2); return path1.equals(path2);
#endif #endif
} }
// Find by name an OBJ provided on the command line // Find by name an OBJ provided on the command line
static ObjFile *findObjByName(StringRef FileNameOnly) { static ObjFile *findObjByName(StringRef fileNameOnly) {
SmallString<128> CurrentPath; SmallString<128> currentPath;
for (ObjFile *F : ObjFile::Instances) { for (ObjFile *f : ObjFile::instances) {
StringRef CurrentFileName = sys::path::filename(F->getName()); StringRef currentFileName = sys::path::filename(f->getName());
// Compare based solely on the file name (link.exe behavior) // Compare based solely on the file name (link.exe behavior)
if (equals_path(CurrentFileName, FileNameOnly)) if (equals_path(currentFileName, fileNameOnly))
return F; return f;
} }
return nullptr; return nullptr;
} }
std::pair<CVIndexMap &, bool /*already there*/> std::pair<CVIndexMap &, bool /*already there*/>
PDBLinker::registerPrecompiledHeaders(uint32_t Signature) { PDBLinker::registerPrecompiledHeaders(uint32_t signature) {
auto Insertion = PrecompTypeIndexMappings.insert({Signature, CVIndexMap()}); auto insertion = precompTypeIndexMappings.insert({signature, CVIndexMap()});
CVIndexMap &IndexMap = Insertion.first->second; CVIndexMap &indexMap = insertion.first->second;
if (!Insertion.second) if (!insertion.second)
return {IndexMap, true}; return {indexMap, true};
// Mark this map as a precompiled types map. // Mark this map as a precompiled types map.
IndexMap.IsPrecompiledTypeMap = true; indexMap.isPrecompiledTypeMap = true;
return {IndexMap, false}; return {indexMap, false};
} }
Expected<const CVIndexMap &> PDBLinker::aquirePrecompObj(ObjFile *File) { Expected<const CVIndexMap &> PDBLinker::aquirePrecompObj(ObjFile *file) {
const PrecompRecord &Precomp = const PrecompRecord &precomp =
retrieveDependencyInfo<PrecompRecord>(File->DebugTypesObj); retrieveDependencyInfo<PrecompRecord>(file->debugTypesObj);
// First, check if we already loaded the precompiled headers object with this // First, check if we already loaded the precompiled headers object with this
// signature. Return the type index mapping if we've already seen it. // signature. Return the type index mapping if we've already seen it.
auto R = registerPrecompiledHeaders(Precomp.getSignature()); auto r = registerPrecompiledHeaders(precomp.getSignature());
if (R.second) if (r.second)
return R.first; return r.first;
CVIndexMap &IndexMap = R.first; CVIndexMap &indexMap = r.first;
// Cross-compile warning: given that Clang doesn't generate LF_PRECOMP // Cross-compile warning: given that Clang doesn't generate LF_PRECOMP
// records, we assume the OBJ comes from a Windows build of cl.exe. Thusly, // records, we assume the OBJ comes from a Windows build of cl.exe. Thusly,
// the paths embedded in the OBJs are in the Windows format. // the paths embedded in the OBJs are in the Windows format.
SmallString<128> PrecompFileName = sys::path::filename( SmallString<128> precompFileName = sys::path::filename(
Precomp.getPrecompFilePath(), sys::path::Style::windows); precomp.getPrecompFilePath(), sys::path::Style::windows);
// link.exe requires that a precompiled headers object must always be provided // link.exe requires that a precompiled headers object must always be provided
// on the command-line, even if that's not necessary. // on the command-line, even if that's not necessary.
auto PrecompFile = findObjByName(PrecompFileName); auto precompFile = findObjByName(precompFileName);
if (!PrecompFile) if (!precompFile)
return createFileError( return createFileError(
PrecompFileName.str(), precompFileName.str(),
make_error<pdb::PDBError>(pdb::pdb_error_code::external_cmdline_ref)); make_error<pdb::PDBError>(pdb::pdb_error_code::external_cmdline_ref));
addObjFile(PrecompFile, &IndexMap); addObjFile(precompFile, &indexMap);
if (!PrecompFile->PCHSignature) if (!precompFile->pchSignature)
fatal(PrecompFile->getName() + " is not a precompiled headers object"); fatal(precompFile->getName() + " is not a precompiled headers object");
if (Precomp.getSignature() != PrecompFile->PCHSignature.getValueOr(0)) if (precomp.getSignature() != precompFile->pchSignature.getValueOr(0))
return createFileError( return createFileError(
Precomp.getPrecompFilePath().str(), precomp.getPrecompFilePath().str(),
make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date)); make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date));
return IndexMap; return indexMap;
} }
static bool remapTypeIndex(TypeIndex &TI, ArrayRef<TypeIndex> TypeIndexMap) { static bool remapTypeIndex(TypeIndex &ti, ArrayRef<TypeIndex> typeIndexMap) {
if (TI.isSimple()) if (ti.isSimple())
return true; return true;
if (TI.toArrayIndex() >= TypeIndexMap.size()) if (ti.toArrayIndex() >= typeIndexMap.size())
return false; return false;
TI = TypeIndexMap[TI.toArrayIndex()]; ti = typeIndexMap[ti.toArrayIndex()];
return true; return true;
} }
static void remapTypesInSymbolRecord(ObjFile *File, SymbolKind SymKind, static void remapTypesInSymbolRecord(ObjFile *file, SymbolKind symKind,
MutableArrayRef<uint8_t> RecordBytes, MutableArrayRef<uint8_t> recordBytes,
const CVIndexMap &IndexMap, const CVIndexMap &indexMap,
ArrayRef<TiReference> TypeRefs) { ArrayRef<TiReference> typeRefs) {
MutableArrayRef<uint8_t> Contents = MutableArrayRef<uint8_t> contents =
RecordBytes.drop_front(sizeof(RecordPrefix)); recordBytes.drop_front(sizeof(RecordPrefix));
for (const TiReference &Ref : TypeRefs) { for (const TiReference &ref : typeRefs) {
unsigned ByteSize = Ref.Count * sizeof(TypeIndex); unsigned byteSize = ref.Count * sizeof(TypeIndex);
if (Contents.size() < Ref.Offset + ByteSize) if (contents.size() < ref.Offset + byteSize)
fatal("symbol record too short"); fatal("symbol record too short");
// This can be an item index or a type index. Choose the appropriate map. // This can be an item index or a type index. Choose the appropriate map.
ArrayRef<TypeIndex> TypeOrItemMap = IndexMap.TPIMap; ArrayRef<TypeIndex> typeOrItemMap = indexMap.tpiMap;
bool IsItemIndex = Ref.Kind == TiRefKind::IndexRef; bool isItemIndex = ref.Kind == TiRefKind::IndexRef;
if (IsItemIndex && IndexMap.IsTypeServerMap) if (isItemIndex && indexMap.isTypeServerMap)
TypeOrItemMap = IndexMap.IPIMap; typeOrItemMap = indexMap.ipiMap;
MutableArrayRef<TypeIndex> TIs( MutableArrayRef<TypeIndex> tIs(
reinterpret_cast<TypeIndex *>(Contents.data() + Ref.Offset), Ref.Count); reinterpret_cast<TypeIndex *>(contents.data() + ref.Offset), ref.Count);
for (TypeIndex &TI : TIs) { for (TypeIndex &ti : tIs) {
if (!remapTypeIndex(TI, TypeOrItemMap)) { if (!remapTypeIndex(ti, typeOrItemMap)) {
log("ignoring symbol record of kind 0x" + utohexstr(SymKind) + " in " + log("ignoring symbol record of kind 0x" + utohexstr(symKind) + " in " +
File->getName() + " with bad " + (IsItemIndex ? "item" : "type") + file->getName() + " with bad " + (isItemIndex ? "item" : "type") +
" index 0x" + utohexstr(TI.getIndex())); " index 0x" + utohexstr(ti.getIndex()));
TI = TypeIndex(SimpleTypeKind::NotTranslated); ti = TypeIndex(SimpleTypeKind::NotTranslated);
continue; continue;
} }
} }
} }
} }
static void static void
recordStringTableReferenceAtOffset(MutableArrayRef<uint8_t> Contents, recordStringTableReferenceAtOffset(MutableArrayRef<uint8_t> contents,
uint32_t Offset, uint32_t offset,
std::vector<ulittle32_t *> &StrTableRefs) { std::vector<ulittle32_t *> &strTableRefs) {
Contents = contents =
Contents.drop_front(Offset).take_front(sizeof(support::ulittle32_t)); contents.drop_front(offset).take_front(sizeof(support::ulittle32_t));
ulittle32_t *Index = reinterpret_cast<ulittle32_t *>(Contents.data()); ulittle32_t *index = reinterpret_cast<ulittle32_t *>(contents.data());
StrTableRefs.push_back(Index); strTableRefs.push_back(index);
} }
static void static void
recordStringTableReferences(SymbolKind Kind, MutableArrayRef<uint8_t> Contents, recordStringTableReferences(SymbolKind kind, MutableArrayRef<uint8_t> contents,
std::vector<ulittle32_t *> &StrTableRefs) { std::vector<ulittle32_t *> &strTableRefs) {
// For now we only handle S_FILESTATIC, but we may need the same logic for // For now we only handle S_FILESTATIC, but we may need the same logic for
// S_DEFRANGE and S_DEFRANGE_SUBFIELD. However, I cannot seem to generate any // S_DEFRANGE and S_DEFRANGE_SUBFIELD. However, I cannot seem to generate any
// PDBs that contain these types of records, so because of the uncertainty // PDBs that contain these types of records, so because of the uncertainty
// they are omitted here until we can prove that it's necessary. // they are omitted here until we can prove that it's necessary.
switch (Kind) { switch (kind) {
case SymbolKind::S_FILESTATIC: case SymbolKind::S_FILESTATIC:
// FileStaticSym::ModFileOffset // FileStaticSym::ModFileOffset
recordStringTableReferenceAtOffset(Contents, 8, StrTableRefs); recordStringTableReferenceAtOffset(contents, 8, strTableRefs);
break; break;
case SymbolKind::S_DEFRANGE: case SymbolKind::S_DEFRANGE:
case SymbolKind::S_DEFRANGE_SUBFIELD: case SymbolKind::S_DEFRANGE_SUBFIELD:
log("Not fixing up string table reference in S_DEFRANGE / " log("Not fixing up string table reference in S_DEFRANGE / "
"S_DEFRANGE_SUBFIELD record"); "S_DEFRANGE_SUBFIELD record");
break; break;
default: default:
break; break;
} }
} }
static SymbolKind symbolKind(ArrayRef<uint8_t> RecordData) { static SymbolKind symbolKind(ArrayRef<uint8_t> recordData) {
const RecordPrefix *Prefix = const RecordPrefix *prefix =
reinterpret_cast<const RecordPrefix *>(RecordData.data()); reinterpret_cast<const RecordPrefix *>(recordData.data());
return static_cast<SymbolKind>(uint16_t(Prefix->RecordKind)); return static_cast<SymbolKind>(uint16_t(prefix->RecordKind));
} }
/// MSVC translates S_PROC_ID_END to S_END, and S_[LG]PROC32_ID to S_[LG]PROC32 /// MSVC translates S_PROC_ID_END to S_END, and S_[LG]PROC32_ID to S_[LG]PROC32
static void translateIdSymbols(MutableArrayRef<uint8_t> &RecordData, static void translateIdSymbols(MutableArrayRef<uint8_t> &recordData,
TypeCollection &IDTable) { TypeCollection &iDTable) {
RecordPrefix *Prefix = reinterpret_cast<RecordPrefix *>(RecordData.data()); RecordPrefix *prefix = reinterpret_cast<RecordPrefix *>(recordData.data());
SymbolKind Kind = symbolKind(RecordData); SymbolKind kind = symbolKind(recordData);
if (Kind == SymbolKind::S_PROC_ID_END) { if (kind == SymbolKind::S_PROC_ID_END) {
Prefix->RecordKind = SymbolKind::S_END; prefix->RecordKind = SymbolKind::S_END;
return; return;
} }
// In an object file, GPROC32_ID has an embedded reference which refers to the // In an object file, GPROC32_ID has an embedded reference which refers to the
// single object file type index namespace. This has already been translated // single object file type index namespace. This has already been translated
// to the PDB file's ID stream index space, but we need to convert this to a // to the PDB file's ID stream index space, but we need to convert this to a
// symbol that refers to the type stream index space. So we remap again from // symbol that refers to the type stream index space. So we remap again from
// ID index space to type index space. // ID index space to type index space.
if (Kind == SymbolKind::S_GPROC32_ID || Kind == SymbolKind::S_LPROC32_ID) { if (kind == SymbolKind::S_GPROC32_ID || kind == SymbolKind::S_LPROC32_ID) {
SmallVector<TiReference, 1> Refs; SmallVector<TiReference, 1> refs;
auto Content = RecordData.drop_front(sizeof(RecordPrefix)); auto content = recordData.drop_front(sizeof(RecordPrefix));
CVSymbol Sym(RecordData); CVSymbol sym(recordData);
discoverTypeIndicesInSymbol(Sym, Refs); discoverTypeIndicesInSymbol(sym, refs);
assert(Refs.size() == 1); assert(refs.size() == 1);
assert(Refs.front().Count == 1); assert(refs.front().Count == 1);
TypeIndex *TI = TypeIndex *ti =
reinterpret_cast<TypeIndex *>(Content.data() + Refs[0].Offset); reinterpret_cast<TypeIndex *>(content.data() + refs[0].Offset);
// `TI` is the index of a FuncIdRecord or MemberFuncIdRecord which lives in // `TI` is the index of a FuncIdRecord or MemberFuncIdRecord which lives in
// the IPI stream, whose `FunctionType` member refers to the TPI stream. // the IPI stream, whose `FunctionType` member refers to the TPI stream.
// Note that LF_FUNC_ID and LF_MEMFUNC_ID have the same record layout, and // Note that LF_FUNC_ID and LF_MEMFUNC_ID have the same record layout, and
// in both cases we just need the second type index. // in both cases we just need the second type index.
if (!TI->isSimple() && !TI->isNoneType()) { if (!ti->isSimple() && !ti->isNoneType()) {
CVType FuncIdData = IDTable.getType(*TI); CVType funcIdData = iDTable.getType(*ti);
SmallVector<TypeIndex, 2> Indices; SmallVector<TypeIndex, 2> indices;
discoverTypeIndices(FuncIdData, Indices); discoverTypeIndices(funcIdData, indices);
assert(Indices.size() == 2); assert(indices.size() == 2);
*TI = Indices[1]; *ti = indices[1];
} }
Kind = (Kind == SymbolKind::S_GPROC32_ID) ? SymbolKind::S_GPROC32 kind = (kind == SymbolKind::S_GPROC32_ID) ? SymbolKind::S_GPROC32
: SymbolKind::S_LPROC32; : SymbolKind::S_LPROC32;
Prefix->RecordKind = uint16_t(Kind); prefix->RecordKind = uint16_t(kind);
} }
} }
/// Copy the symbol record. In a PDB, symbol records must be 4 byte aligned. /// Copy the symbol record. In a PDB, symbol records must be 4 byte aligned.
/// The object file may not be aligned. /// The object file may not be aligned.
static MutableArrayRef<uint8_t> static MutableArrayRef<uint8_t>
copyAndAlignSymbol(const CVSymbol &Sym, MutableArrayRef<uint8_t> &AlignedMem) { copyAndAlignSymbol(const CVSymbol &sym, MutableArrayRef<uint8_t> &alignedMem) {
size_t Size = alignTo(Sym.length(), alignOf(CodeViewContainer::Pdb)); size_t size = alignTo(sym.length(), alignOf(CodeViewContainer::Pdb));
assert(Size >= 4 && "record too short"); assert(size >= 4 && "record too short");
assert(Size <= MaxRecordLength && "record too long"); assert(size <= MaxRecordLength && "record too long");
assert(AlignedMem.size() >= Size && "didn't preallocate enough"); assert(alignedMem.size() >= size && "didn't preallocate enough");
// Copy the symbol record and zero out any padding bytes. // Copy the symbol record and zero out any padding bytes.
MutableArrayRef<uint8_t> NewData = AlignedMem.take_front(Size); MutableArrayRef<uint8_t> newData = alignedMem.take_front(size);
AlignedMem = AlignedMem.drop_front(Size); alignedMem = alignedMem.drop_front(size);
memcpy(NewData.data(), Sym.data().data(), Sym.length()); memcpy(newData.data(), sym.data().data(), sym.length());
memset(NewData.data() + Sym.length(), 0, Size - Sym.length()); memset(newData.data() + sym.length(), 0, size - sym.length());
// Update the record prefix length. It should point to the beginning of the // Update the record prefix length. It should point to the beginning of the
// next record. // next record.
auto *Prefix = reinterpret_cast<RecordPrefix *>(NewData.data()); auto *prefix = reinterpret_cast<RecordPrefix *>(newData.data());
Prefix->RecordLen = Size - 2; prefix->RecordLen = size - 2;
return NewData; return newData;
} }
struct ScopeRecord { struct ScopeRecord {
ulittle32_t PtrParent; ulittle32_t ptrParent;
ulittle32_t PtrEnd; ulittle32_t ptrEnd;
}; };
struct SymbolScope { struct SymbolScope {
ScopeRecord *OpeningRecord; ScopeRecord *openingRecord;
uint32_t ScopeOffset; uint32_t scopeOffset;
}; };
static void scopeStackOpen(SmallVectorImpl<SymbolScope> &Stack, static void scopeStackOpen(SmallVectorImpl<SymbolScope> &stack,
uint32_t CurOffset, CVSymbol &Sym) { uint32_t curOffset, CVSymbol &sym) {
assert(symbolOpensScope(Sym.kind())); assert(symbolOpensScope(sym.kind()));
SymbolScope S; SymbolScope s;
S.ScopeOffset = CurOffset; s.scopeOffset = curOffset;
S.OpeningRecord = const_cast<ScopeRecord *>( s.openingRecord = const_cast<ScopeRecord *>(
reinterpret_cast<const ScopeRecord *>(Sym.content().data())); reinterpret_cast<const ScopeRecord *>(sym.content().data()));
S.OpeningRecord->PtrParent = Stack.empty() ? 0 : Stack.back().ScopeOffset; s.openingRecord->ptrParent = stack.empty() ? 0 : stack.back().scopeOffset;
Stack.push_back(S); stack.push_back(s);
} }
static void scopeStackClose(SmallVectorImpl<SymbolScope> &Stack, static void scopeStackClose(SmallVectorImpl<SymbolScope> &stack,
uint32_t CurOffset, InputFile *File) { uint32_t curOffset, InputFile *file) {
if (Stack.empty()) { if (stack.empty()) {
warn("symbol scopes are not balanced in " + File->getName()); warn("symbol scopes are not balanced in " + file->getName());
return; return;
} }
SymbolScope S = Stack.pop_back_val(); SymbolScope s = stack.pop_back_val();
S.OpeningRecord->PtrEnd = CurOffset; s.openingRecord->ptrEnd = curOffset;
} }
static bool symbolGoesInModuleStream(const CVSymbol &Sym, bool IsGlobalScope) { static bool symbolGoesInModuleStream(const CVSymbol &sym, bool isGlobalScope) {
switch (Sym.kind()) { switch (sym.kind()) {
case SymbolKind::S_GDATA32: case SymbolKind::S_GDATA32:
case SymbolKind::S_CONSTANT: case SymbolKind::S_CONSTANT:
// We really should not be seeing S_PROCREF and S_LPROCREF in the first place // We really should not be seeing S_PROCREF and S_LPROCREF in the first place
// since they are synthesized by the linker in response to S_GPROC32 and // since they are synthesized by the linker in response to S_GPROC32 and
// S_LPROC32, but if we do see them, don't put them in the module stream I // S_LPROC32, but if we do see them, don't put them in the module stream I
// guess. // guess.
case SymbolKind::S_PROCREF: case SymbolKind::S_PROCREF:
case SymbolKind::S_LPROCREF: case SymbolKind::S_LPROCREF:
return false; return false;
// S_UDT records go in the module stream if it is not a global S_UDT. // S_UDT records go in the module stream if it is not a global S_UDT.
case SymbolKind::S_UDT: case SymbolKind::S_UDT:
return !IsGlobalScope; return !isGlobalScope;
// S_GDATA32 does not go in the module stream, but S_LDATA32 does. // S_GDATA32 does not go in the module stream, but S_LDATA32 does.
case SymbolKind::S_LDATA32: case SymbolKind::S_LDATA32:
default: default:
return true; return true;
} }
} }
static bool symbolGoesInGlobalsStream(const CVSymbol &Sym, bool IsGlobalScope) { static bool symbolGoesInGlobalsStream(const CVSymbol &sym, bool isGlobalScope) {
switch (Sym.kind()) { switch (sym.kind()) {
case SymbolKind::S_CONSTANT: case SymbolKind::S_CONSTANT:
case SymbolKind::S_GDATA32: case SymbolKind::S_GDATA32:
// S_LDATA32 goes in both the module stream and the globals stream. // S_LDATA32 goes in both the module stream and the globals stream.
case SymbolKind::S_LDATA32: case SymbolKind::S_LDATA32:
case SymbolKind::S_GPROC32: case SymbolKind::S_GPROC32:
case SymbolKind::S_LPROC32: case SymbolKind::S_LPROC32:
// We really should not be seeing S_PROCREF and S_LPROCREF in the first place // We really should not be seeing S_PROCREF and S_LPROCREF in the first place
// since they are synthesized by the linker in response to S_GPROC32 and // since they are synthesized by the linker in response to S_GPROC32 and
// S_LPROC32, but if we do see them, copy them straight through. // S_LPROC32, but if we do see them, copy them straight through.
case SymbolKind::S_PROCREF: case SymbolKind::S_PROCREF:
case SymbolKind::S_LPROCREF: case SymbolKind::S_LPROCREF:
return true; return true;
// S_UDT records go in the globals stream if it is a global S_UDT. // S_UDT records go in the globals stream if it is a global S_UDT.
case SymbolKind::S_UDT: case SymbolKind::S_UDT:
return IsGlobalScope; return isGlobalScope;
default: default:
return false; return false;
} }
} }
static void addGlobalSymbol(pdb::GSIStreamBuilder &Builder, uint16_t ModIndex, static void addGlobalSymbol(pdb::GSIStreamBuilder &builder, uint16_t modIndex,
unsigned SymOffset, const CVSymbol &Sym) { unsigned symOffset, const CVSymbol &sym) {
switch (Sym.kind()) { switch (sym.kind()) {
case SymbolKind::S_CONSTANT: case SymbolKind::S_CONSTANT:
case SymbolKind::S_UDT: case SymbolKind::S_UDT:
case SymbolKind::S_GDATA32: case SymbolKind::S_GDATA32:
case SymbolKind::S_LDATA32: case SymbolKind::S_LDATA32:
case SymbolKind::S_PROCREF: case SymbolKind::S_PROCREF:
case SymbolKind::S_LPROCREF: case SymbolKind::S_LPROCREF:
Builder.addGlobalSymbol(Sym); builder.addGlobalSymbol(sym);
break; break;
case SymbolKind::S_GPROC32: case SymbolKind::S_GPROC32:
case SymbolKind::S_LPROC32: { case SymbolKind::S_LPROC32: {
SymbolRecordKind K = SymbolRecordKind::ProcRefSym; SymbolRecordKind k = SymbolRecordKind::ProcRefSym;
if (Sym.kind() == SymbolKind::S_LPROC32) if (sym.kind() == SymbolKind::S_LPROC32)
K = SymbolRecordKind::LocalProcRef; k = SymbolRecordKind::LocalProcRef;
ProcRefSym PS(K); ProcRefSym ps(k);
PS.Module = ModIndex; ps.Module = modIndex;
// For some reason, MSVC seems to add one to this value. // For some reason, MSVC seems to add one to this value.
++PS.Module; ++ps.Module;
PS.Name = getSymbolName(Sym); ps.Name = getSymbolName(sym);
PS.SumName = 0; ps.SumName = 0;
PS.SymOffset = SymOffset; ps.SymOffset = symOffset;
Builder.addGlobalSymbol(PS); builder.addGlobalSymbol(ps);
break; break;
} }
default: default:
llvm_unreachable("Invalid symbol kind!"); llvm_unreachable("Invalid symbol kind!");
} }
} }
void PDBLinker::mergeSymbolRecords(ObjFile *File, const CVIndexMap &IndexMap, void PDBLinker::mergeSymbolRecords(ObjFile *file, const CVIndexMap &indexMap,
std::vector<ulittle32_t *> &StringTableRefs, std::vector<ulittle32_t *> &stringTableRefs,
BinaryStreamRef SymData) { BinaryStreamRef symData) {
ArrayRef<uint8_t> SymsBuffer; ArrayRef<uint8_t> symsBuffer;
cantFail(SymData.readBytes(0, SymData.getLength(), SymsBuffer)); cantFail(symData.readBytes(0, symData.getLength(), symsBuffer));
SmallVector<SymbolScope, 4> Scopes; SmallVector<SymbolScope, 4> scopes;
// Iterate every symbol to check if any need to be realigned, and if so, how // Iterate every symbol to check if any need to be realigned, and if so, how
// much space we need to allocate for them. // much space we need to allocate for them.
bool NeedsRealignment = false; bool needsRealignment = false;
unsigned TotalRealignedSize = 0; unsigned totalRealignedSize = 0;
auto EC = forEachCodeViewRecord<CVSymbol>( auto ec = forEachCodeViewRecord<CVSymbol>(
SymsBuffer, [&](CVSymbol Sym) -> llvm::Error { symsBuffer, [&](CVSymbol sym) -> llvm::Error {
unsigned RealignedSize = unsigned realignedSize =
alignTo(Sym.length(), alignOf(CodeViewContainer::Pdb)); alignTo(sym.length(), alignOf(CodeViewContainer::Pdb));
NeedsRealignment |= RealignedSize != Sym.length(); needsRealignment |= realignedSize != sym.length();
TotalRealignedSize += RealignedSize; totalRealignedSize += realignedSize;
return Error::success(); return Error::success();
}); });
// If any of the symbol record lengths was corrupt, ignore them all, warn // If any of the symbol record lengths was corrupt, ignore them all, warn
// about it, and move on. // about it, and move on.
if (EC) { if (ec) {
warn("corrupt symbol records in " + File->getName()); warn("corrupt symbol records in " + file->getName());
consumeError(std::move(EC)); consumeError(std::move(ec));
return; return;
} }
// If any symbol needed realignment, allocate enough contiguous memory for // If any symbol needed realignment, allocate enough contiguous memory for
// them all. Typically symbol subsections are small enough that this will not // them all. Typically symbol subsections are small enough that this will not
// cause fragmentation. // cause fragmentation.
MutableArrayRef<uint8_t> AlignedSymbolMem; MutableArrayRef<uint8_t> alignedSymbolMem;
if (NeedsRealignment) { if (needsRealignment) {
void *AlignedData = void *alignedData =
Alloc.Allocate(TotalRealignedSize, alignOf(CodeViewContainer::Pdb)); alloc.Allocate(totalRealignedSize, alignOf(CodeViewContainer::Pdb));
AlignedSymbolMem = makeMutableArrayRef( alignedSymbolMem = makeMutableArrayRef(
reinterpret_cast<uint8_t *>(AlignedData), TotalRealignedSize); reinterpret_cast<uint8_t *>(alignedData), totalRealignedSize);
} }
// Iterate again, this time doing the real work. // Iterate again, this time doing the real work.
unsigned CurSymOffset = File->ModuleDBI->getNextSymbolOffset(); unsigned curSymOffset = file->moduleDBI->getNextSymbolOffset();
ArrayRef<uint8_t> BulkSymbols; ArrayRef<uint8_t> bulkSymbols;
cantFail(forEachCodeViewRecord<CVSymbol>( cantFail(forEachCodeViewRecord<CVSymbol>(
SymsBuffer, [&](CVSymbol Sym) -> llvm::Error { symsBuffer, [&](CVSymbol sym) -> llvm::Error {
// Align the record if required. // Align the record if required.
MutableArrayRef<uint8_t> RecordBytes; MutableArrayRef<uint8_t> recordBytes;
if (NeedsRealignment) { if (needsRealignment) {
RecordBytes = copyAndAlignSymbol(Sym, AlignedSymbolMem); recordBytes = copyAndAlignSymbol(sym, alignedSymbolMem);
Sym = CVSymbol(RecordBytes); sym = CVSymbol(recordBytes);
} else { } else {
// Otherwise, we can actually mutate the symbol directly, since we // Otherwise, we can actually mutate the symbol directly, since we
// copied it to apply relocations. // copied it to apply relocations.
RecordBytes = makeMutableArrayRef( recordBytes = makeMutableArrayRef(
const_cast<uint8_t *>(Sym.data().data()), Sym.length()); const_cast<uint8_t *>(sym.data().data()), sym.length());
} }
// Discover type index references in the record. Skip it if we don't // Discover type index references in the record. Skip it if we don't
// know where they are. // know where they are.
SmallVector<TiReference, 32> TypeRefs; SmallVector<TiReference, 32> typeRefs;
if (!discoverTypeIndicesInSymbol(Sym, TypeRefs)) { if (!discoverTypeIndicesInSymbol(sym, typeRefs)) {
log("ignoring unknown symbol record with kind 0x" + log("ignoring unknown symbol record with kind 0x" +
utohexstr(Sym.kind())); utohexstr(sym.kind()));
return Error::success(); return Error::success();
} }
// Re-map all the type index references. // Re-map all the type index references.
remapTypesInSymbolRecord(File, Sym.kind(), RecordBytes, IndexMap, remapTypesInSymbolRecord(file, sym.kind(), recordBytes, indexMap,
TypeRefs); typeRefs);
// An object file may have S_xxx_ID symbols, but these get converted to // An object file may have S_xxx_ID symbols, but these get converted to
// "real" symbols in a PDB. // "real" symbols in a PDB.
translateIdSymbols(RecordBytes, TMerger.getIDTable()); translateIdSymbols(recordBytes, tMerger.getIDTable());
Sym = CVSymbol(RecordBytes); sym = CVSymbol(recordBytes);
// If this record refers to an offset in the object file's string table, // If this record refers to an offset in the object file's string table,
// add that item to the global PDB string table and re-write the index. // add that item to the global PDB string table and re-write the index.
recordStringTableReferences(Sym.kind(), RecordBytes, StringTableRefs); recordStringTableReferences(sym.kind(), recordBytes, stringTableRefs);
// Fill in "Parent" and "End" fields by maintaining a stack of scopes. // Fill in "Parent" and "End" fields by maintaining a stack of scopes.
if (symbolOpensScope(Sym.kind())) if (symbolOpensScope(sym.kind()))
scopeStackOpen(Scopes, CurSymOffset, Sym); scopeStackOpen(scopes, curSymOffset, sym);
else if (symbolEndsScope(Sym.kind())) else if (symbolEndsScope(sym.kind()))
scopeStackClose(Scopes, CurSymOffset, File); scopeStackClose(scopes, curSymOffset, file);
// Add the symbol to the globals stream if necessary. Do this before // Add the symbol to the globals stream if necessary. Do this before
// adding the symbol to the module since we may need to get the next // adding the symbol to the module since we may need to get the next
// symbol offset, and writing to the module's symbol stream will update // symbol offset, and writing to the module's symbol stream will update
// that offset. // that offset.
if (symbolGoesInGlobalsStream(Sym, Scopes.empty())) { if (symbolGoesInGlobalsStream(sym, scopes.empty())) {
addGlobalSymbol(Builder.getGsiBuilder(), addGlobalSymbol(builder.getGsiBuilder(),
File->ModuleDBI->getModuleIndex(), CurSymOffset, Sym); file->moduleDBI->getModuleIndex(), curSymOffset, sym);
++GlobalSymbols; ++globalSymbols;
} }
if (symbolGoesInModuleStream(Sym, Scopes.empty())) { if (symbolGoesInModuleStream(sym, scopes.empty())) {
// Add symbols to the module in bulk. If this symbol is contiguous // Add symbols to the module in bulk. If this symbol is contiguous
// with the previous run of symbols to add, combine the ranges. If // with the previous run of symbols to add, combine the ranges. If
// not, close the previous range of symbols and start a new one. // not, close the previous range of symbols and start a new one.
if (Sym.data().data() == BulkSymbols.end()) { if (sym.data().data() == bulkSymbols.end()) {
BulkSymbols = makeArrayRef(BulkSymbols.data(), bulkSymbols = makeArrayRef(bulkSymbols.data(),
BulkSymbols.size() + Sym.length()); bulkSymbols.size() + sym.length());
} else { } else {
File->ModuleDBI->addSymbolsInBulk(BulkSymbols); file->moduleDBI->addSymbolsInBulk(bulkSymbols);
BulkSymbols = RecordBytes; bulkSymbols = recordBytes;
} }
CurSymOffset += Sym.length(); curSymOffset += sym.length();
++ModuleSymbols; ++moduleSymbols;
} }
return Error::success(); return Error::success();
})); }));
// Add any remaining symbols we've accumulated. // Add any remaining symbols we've accumulated.
File->ModuleDBI->addSymbolsInBulk(BulkSymbols); file->moduleDBI->addSymbolsInBulk(bulkSymbols);
} }
// Allocate memory for a .debug$S / .debug$F section and relocate it. // Allocate memory for a .debug$S / .debug$F section and relocate it.
static ArrayRef<uint8_t> relocateDebugChunk(BumpPtrAllocator &Alloc, static ArrayRef<uint8_t> relocateDebugChunk(BumpPtrAllocator &alloc,
SectionChunk &DebugChunk) { SectionChunk &debugChunk) {
uint8_t *Buffer = Alloc.Allocate<uint8_t>(DebugChunk.getSize()); uint8_t *buffer = alloc.Allocate<uint8_t>(debugChunk.getSize());
assert(DebugChunk.getOutputSectionIdx() == 0 && assert(debugChunk.getOutputSectionIdx() == 0 &&
"debug sections should not be in output sections"); "debug sections should not be in output sections");
DebugChunk.writeTo(Buffer); debugChunk.writeTo(buffer);
return makeArrayRef(Buffer, DebugChunk.getSize()); return makeArrayRef(buffer, debugChunk.getSize());
} }
static pdb::SectionContrib createSectionContrib(const Chunk *C, uint32_t Modi) { static pdb::SectionContrib createSectionContrib(const Chunk *c, uint32_t modi) {
OutputSection *OS = C ? C->getOutputSection() : nullptr; OutputSection *os = c ? c->getOutputSection() : nullptr;
pdb::SectionContrib SC; pdb::SectionContrib sc;
memset(&SC, 0, sizeof(SC)); memset(&sc, 0, sizeof(sc));
SC.ISect = OS ? OS->SectionIndex : llvm::pdb::kInvalidStreamIndex; sc.ISect = os ? os->sectionIndex : llvm::pdb::kInvalidStreamIndex;
SC.Off = C && OS ? C->getRVA() - OS->getRVA() : 0; sc.Off = c && os ? c->getRVA() - os->getRVA() : 0;
SC.Size = C ? C->getSize() : -1; sc.Size = c ? c->getSize() : -1;
if (auto *SecChunk = dyn_cast_or_null<SectionChunk>(C)) { if (auto *secChunk = dyn_cast_or_null<SectionChunk>(c)) {
SC.Characteristics = SecChunk->Header->Characteristics; sc.Characteristics = secChunk->header->Characteristics;
SC.Imod = SecChunk->File->ModuleDBI->getModuleIndex(); sc.Imod = secChunk->file->moduleDBI->getModuleIndex();
ArrayRef<uint8_t> Contents = SecChunk->getContents(); ArrayRef<uint8_t> contents = secChunk->getContents();
JamCRC CRC(0); JamCRC crc(0);
ArrayRef<char> CharContents = makeArrayRef( ArrayRef<char> charContents = makeArrayRef(
reinterpret_cast<const char *>(Contents.data()), Contents.size()); reinterpret_cast<const char *>(contents.data()), contents.size());
CRC.update(CharContents); crc.update(charContents);
SC.DataCrc = CRC.getCRC(); sc.DataCrc = crc.getCRC();
} else { } else {
SC.Characteristics = OS ? OS->Header.Characteristics : 0; sc.Characteristics = os ? os->header.Characteristics : 0;
SC.Imod = Modi; sc.Imod = modi;
} }
SC.RelocCrc = 0; // FIXME sc.RelocCrc = 0; // FIXME
return SC; return sc;
} }
static uint32_t static uint32_t
translateStringTableIndex(uint32_t ObjIndex, translateStringTableIndex(uint32_t objIndex,
const DebugStringTableSubsectionRef &ObjStrTable, const DebugStringTableSubsectionRef &objStrTable,
DebugStringTableSubsection &PdbStrTable) { DebugStringTableSubsection &pdbStrTable) {
auto ExpectedString = ObjStrTable.getString(ObjIndex); auto expectedString = objStrTable.getString(objIndex);
if (!ExpectedString) { if (!expectedString) {
warn("Invalid string table reference"); warn("Invalid string table reference");
consumeError(ExpectedString.takeError()); consumeError(expectedString.takeError());
return 0; return 0;
} }
return PdbStrTable.insert(*ExpectedString); return pdbStrTable.insert(*expectedString);
} }
void DebugSHandler::handleDebugS(lld::coff::SectionChunk &DebugS) { void DebugSHandler::handleDebugS(lld::coff::SectionChunk &debugS) {
DebugSubsectionArray Subsections; DebugSubsectionArray subsections;
ArrayRef<uint8_t> RelocatedDebugContents = SectionChunk::consumeDebugMagic( ArrayRef<uint8_t> relocatedDebugContents = SectionChunk::consumeDebugMagic(
relocateDebugChunk(Linker.Alloc, DebugS), DebugS.getSectionName()); relocateDebugChunk(linker.alloc, debugS), debugS.getSectionName());
BinaryStreamReader Reader(RelocatedDebugContents, support::little); BinaryStreamReader reader(relocatedDebugContents, support::little);
ExitOnErr(Reader.readArray(Subsections, RelocatedDebugContents.size())); exitOnErr(reader.readArray(subsections, relocatedDebugContents.size()));
for (const DebugSubsectionRecord &SS : Subsections) { for (const DebugSubsectionRecord &ss : subsections) {
// Ignore subsections with the 'ignore' bit. Some versions of the Visual C++ // Ignore subsections with the 'ignore' bit. Some versions of the Visual C++
// runtime have subsections with this bit set. // runtime have subsections with this bit set.
if (uint32_t(SS.kind()) & codeview::SubsectionIgnoreFlag) if (uint32_t(ss.kind()) & codeview::SubsectionIgnoreFlag)
continue; continue;
switch (SS.kind()) { switch (ss.kind()) {
case DebugSubsectionKind::StringTable: { case DebugSubsectionKind::StringTable: {
assert(!CVStrTab.valid() && assert(!cVStrTab.valid() &&
"Encountered multiple string table subsections!"); "Encountered multiple string table subsections!");
ExitOnErr(CVStrTab.initialize(SS.getRecordData())); exitOnErr(cVStrTab.initialize(ss.getRecordData()));
break; break;
} }
case DebugSubsectionKind::FileChecksums: case DebugSubsectionKind::FileChecksums:
assert(!Checksums.valid() && assert(!checksums.valid() &&
"Encountered multiple checksum subsections!"); "Encountered multiple checksum subsections!");
ExitOnErr(Checksums.initialize(SS.getRecordData())); exitOnErr(checksums.initialize(ss.getRecordData()));
break; break;
case DebugSubsectionKind::Lines: case DebugSubsectionKind::Lines:
// We can add the relocated line table directly to the PDB without // We can add the relocated line table directly to the PDB without
// modification because the file checksum offsets will stay the same. // modification because the file checksum offsets will stay the same.
File.ModuleDBI->addDebugSubsection(SS); file.moduleDBI->addDebugSubsection(ss);
break; break;
case DebugSubsectionKind::InlineeLines: case DebugSubsectionKind::InlineeLines:
assert(!InlineeLines.valid() && assert(!inlineeLines.valid() &&
"Encountered multiple inlinee lines subsections!"); "Encountered multiple inlinee lines subsections!");
ExitOnErr(InlineeLines.initialize(SS.getRecordData())); exitOnErr(inlineeLines.initialize(ss.getRecordData()));
break; break;
case DebugSubsectionKind::FrameData: { case DebugSubsectionKind::FrameData: {
// We need to re-write string table indices here, so save off all // We need to re-write string table indices here, so save off all
// frame data subsections until we've processed the entire list of // frame data subsections until we've processed the entire list of
// subsections so that we can be sure we have the string table. // subsections so that we can be sure we have the string table.
DebugFrameDataSubsectionRef FDS; DebugFrameDataSubsectionRef fds;
ExitOnErr(FDS.initialize(SS.getRecordData())); exitOnErr(fds.initialize(ss.getRecordData()));
NewFpoFrames.push_back(std::move(FDS)); newFpoFrames.push_back(std::move(fds));
break; break;
} }
case DebugSubsectionKind::Symbols: { case DebugSubsectionKind::Symbols: {
Linker.mergeSymbolRecords(&File, IndexMap, StringTableReferences, linker.mergeSymbolRecords(&file, indexMap, stringTableReferences,
SS.getRecordData()); ss.getRecordData());
break; break;
} }
case DebugSubsectionKind::CrossScopeImports: case DebugSubsectionKind::CrossScopeImports:
case DebugSubsectionKind::CrossScopeExports: case DebugSubsectionKind::CrossScopeExports:
// These appear to relate to cross-module optimization, so we might use // These appear to relate to cross-module optimization, so we might use
// these for ThinLTO. // these for ThinLTO.
break; break;
case DebugSubsectionKind::ILLines: case DebugSubsectionKind::ILLines:
case DebugSubsectionKind::FuncMDTokenMap: case DebugSubsectionKind::FuncMDTokenMap:
case DebugSubsectionKind::TypeMDTokenMap: case DebugSubsectionKind::TypeMDTokenMap:
case DebugSubsectionKind::MergedAssemblyInput: case DebugSubsectionKind::MergedAssemblyInput:
// These appear to relate to .Net assembly info. // These appear to relate to .Net assembly info.
break; break;
case DebugSubsectionKind::CoffSymbolRVA: case DebugSubsectionKind::CoffSymbolRVA:
// Unclear what this is for. // Unclear what this is for.
break; break;
default: default:
warn("ignoring unknown debug$S subsection kind 0x" + warn("ignoring unknown debug$S subsection kind 0x" +
utohexstr(uint32_t(SS.kind())) + " in file " + toString(&File)); utohexstr(uint32_t(ss.kind())) + " in file " + toString(&file));
break; break;
} }
} }
} }
static Expected<StringRef> static Expected<StringRef>
getFileName(const DebugStringTableSubsectionRef &Strings, getFileName(const DebugStringTableSubsectionRef &strings,
const DebugChecksumsSubsectionRef &Checksums, uint32_t FileID) { const DebugChecksumsSubsectionRef &checksums, uint32_t fileID) {
auto Iter = Checksums.getArray().at(FileID); auto iter = checksums.getArray().at(fileID);
if (Iter == Checksums.getArray().end()) if (iter == checksums.getArray().end())
return make_error<CodeViewError>(cv_error_code::no_records); return make_error<CodeViewError>(cv_error_code::no_records);
uint32_t Offset = Iter->FileNameOffset; uint32_t offset = iter->FileNameOffset;
return Strings.getString(Offset); return strings.getString(offset);
} }
std::shared_ptr<DebugInlineeLinesSubsection> std::shared_ptr<DebugInlineeLinesSubsection>
DebugSHandler::mergeInlineeLines(DebugChecksumsSubsection *NewChecksums) { DebugSHandler::mergeInlineeLines(DebugChecksumsSubsection *newChecksums) {
auto NewInlineeLines = std::make_shared<DebugInlineeLinesSubsection>( auto newInlineeLines = std::make_shared<DebugInlineeLinesSubsection>(
*NewChecksums, InlineeLines.hasExtraFiles()); *newChecksums, inlineeLines.hasExtraFiles());
for (const InlineeSourceLine &Line : InlineeLines) { for (const InlineeSourceLine &line : inlineeLines) {
TypeIndex Inlinee = Line.Header->Inlinee; TypeIndex inlinee = line.Header->Inlinee;
uint32_t FileID = Line.Header->FileID; uint32_t fileID = line.Header->FileID;
uint32_t SourceLine = Line.Header->SourceLineNum; uint32_t sourceLine = line.Header->SourceLineNum;
ArrayRef<TypeIndex> TypeOrItemMap = ArrayRef<TypeIndex> typeOrItemMap =
IndexMap.IsTypeServerMap ? IndexMap.IPIMap : IndexMap.TPIMap; indexMap.isTypeServerMap ? indexMap.ipiMap : indexMap.tpiMap;
if (!remapTypeIndex(Inlinee, TypeOrItemMap)) { if (!remapTypeIndex(inlinee, typeOrItemMap)) {
log("ignoring inlinee line record in " + File.getName() + log("ignoring inlinee line record in " + file.getName() +
" with bad inlinee index 0x" + utohexstr(Inlinee.getIndex())); " with bad inlinee index 0x" + utohexstr(inlinee.getIndex()));
continue; continue;
} }
SmallString<128> Filename = SmallString<128> filename =
ExitOnErr(getFileName(CVStrTab, Checksums, FileID)); exitOnErr(getFileName(cVStrTab, checksums, fileID));
pdbMakeAbsolute(Filename); pdbMakeAbsolute(filename);
NewInlineeLines->addInlineSite(Inlinee, Filename, SourceLine); newInlineeLines->addInlineSite(inlinee, filename, sourceLine);
if (InlineeLines.hasExtraFiles()) { if (inlineeLines.hasExtraFiles()) {
for (uint32_t ExtraFileId : Line.ExtraFiles) { for (uint32_t extraFileId : line.ExtraFiles) {
Filename = ExitOnErr(getFileName(CVStrTab, Checksums, ExtraFileId)); filename = exitOnErr(getFileName(cVStrTab, checksums, extraFileId));
pdbMakeAbsolute(Filename); pdbMakeAbsolute(filename);
NewInlineeLines->addExtraFile(Filename); newInlineeLines->addExtraFile(filename);
} }
} }
} }
return NewInlineeLines; return newInlineeLines;
} }
void DebugSHandler::finish() { void DebugSHandler::finish() {
pdb::DbiStreamBuilder &DbiBuilder = Linker.Builder.getDbiBuilder(); pdb::DbiStreamBuilder &dbiBuilder = linker.builder.getDbiBuilder();
// We should have seen all debug subsections across the entire object file now // We should have seen all debug subsections across the entire object file now
// which means that if a StringTable subsection and Checksums subsection were // which means that if a StringTable subsection and Checksums subsection were
// present, now is the time to handle them. // present, now is the time to handle them.
if (!CVStrTab.valid()) { if (!cVStrTab.valid()) {
if (Checksums.valid()) if (checksums.valid())
fatal(".debug$S sections with a checksums subsection must also contain a " fatal(".debug$S sections with a checksums subsection must also contain a "
"string table subsection"); "string table subsection");
if (!StringTableReferences.empty()) if (!stringTableReferences.empty())
warn("No StringTable subsection was encountered, but there are string " warn("No StringTable subsection was encountered, but there are string "
"table references"); "table references");
return; return;
} }
// Rewrite string table indices in the Fpo Data and symbol records to refer to // Rewrite string table indices in the Fpo Data and symbol records to refer to
// the global PDB string table instead of the object file string table. // the global PDB string table instead of the object file string table.
for (DebugFrameDataSubsectionRef &FDS : NewFpoFrames) { for (DebugFrameDataSubsectionRef &fds : newFpoFrames) {
const ulittle32_t *Reloc = FDS.getRelocPtr(); const ulittle32_t *reloc = fds.getRelocPtr();
for (codeview::FrameData FD : FDS) { for (codeview::FrameData fd : fds) {
FD.RvaStart += *Reloc; fd.RvaStart += *reloc;
FD.FrameFunc = fd.FrameFunc =
translateStringTableIndex(FD.FrameFunc, CVStrTab, Linker.PDBStrTab); translateStringTableIndex(fd.FrameFunc, cVStrTab, linker.pdbStrTab);
DbiBuilder.addNewFpoData(FD); dbiBuilder.addNewFpoData(fd);
} }
} }
for (ulittle32_t *Ref : StringTableReferences) for (ulittle32_t *ref : stringTableReferences)
*Ref = translateStringTableIndex(*Ref, CVStrTab, Linker.PDBStrTab); *ref = translateStringTableIndex(*ref, cVStrTab, linker.pdbStrTab);
// Make a new file checksum table that refers to offsets in the PDB-wide // Make a new file checksum table that refers to offsets in the PDB-wide
// string table. Generally the string table subsection appears after the // string table. Generally the string table subsection appears after the
// checksum table, so we have to do this after looping over all the // checksum table, so we have to do this after looping over all the
// subsections. // subsections.
auto NewChecksums = make_unique<DebugChecksumsSubsection>(Linker.PDBStrTab); auto newChecksums = make_unique<DebugChecksumsSubsection>(linker.pdbStrTab);
for (FileChecksumEntry &FC : Checksums) { for (FileChecksumEntry &fc : checksums) {
SmallString<128> Filename = SmallString<128> filename =
ExitOnErr(CVStrTab.getString(FC.FileNameOffset)); exitOnErr(cVStrTab.getString(fc.FileNameOffset));
pdbMakeAbsolute(Filename); pdbMakeAbsolute(filename);
ExitOnErr(DbiBuilder.addModuleSourceFile(*File.ModuleDBI, Filename)); exitOnErr(dbiBuilder.addModuleSourceFile(*file.moduleDBI, filename));
NewChecksums->addChecksum(Filename, FC.Kind, FC.Checksum); newChecksums->addChecksum(filename, fc.Kind, fc.Checksum);
} }
// Rewrite inlinee item indices if present. // Rewrite inlinee item indices if present.
if (InlineeLines.valid()) if (inlineeLines.valid())
File.ModuleDBI->addDebugSubsection(mergeInlineeLines(NewChecksums.get())); file.moduleDBI->addDebugSubsection(mergeInlineeLines(newChecksums.get()));
File.ModuleDBI->addDebugSubsection(std::move(NewChecksums)); file.moduleDBI->addDebugSubsection(std::move(newChecksums));
} }
void PDBLinker::addObjFile(ObjFile *File, CVIndexMap *ExternIndexMap) { void PDBLinker::addObjFile(ObjFile *file, CVIndexMap *externIndexMap) {
if (File->MergedIntoPDB) if (file->mergedIntoPDB)
return; return;
File->MergedIntoPDB = true; file->mergedIntoPDB = true;
// Before we can process symbol substreams from .debug$S, we need to process // Before we can process symbol substreams from .debug$S, we need to process
// type information, file checksums, and the string table. Add type info to // type information, file checksums, and the string table. Add type info to
// the PDB first, so that we can get the map from object file type and item // the PDB first, so that we can get the map from object file type and item
// indices to PDB type and item indices. // indices to PDB type and item indices.
CVIndexMap ObjectIndexMap; CVIndexMap objectIndexMap;
auto IndexMapResult = auto indexMapResult =
mergeDebugT(File, ExternIndexMap ? ExternIndexMap : &ObjectIndexMap); mergeDebugT(file, externIndexMap ? externIndexMap : &objectIndexMap);
// If the .debug$T sections fail to merge, assume there is no debug info. // If the .debug$T sections fail to merge, assume there is no debug info.
if (!IndexMapResult) { if (!indexMapResult) {
if (!Config->WarnDebugInfoUnusable) { if (!config->warnDebugInfoUnusable) {
consumeError(IndexMapResult.takeError()); consumeError(indexMapResult.takeError());
return; return;
} }
warn("Cannot use debug info for '" + toString(File) + "' [LNK4099]\n" + warn("Cannot use debug info for '" + toString(file) + "' [LNK4099]\n" +
">>> failed to load reference " + ">>> failed to load reference " +
StringRef(toString(IndexMapResult.takeError()))); StringRef(toString(indexMapResult.takeError())));
return; return;
} }
ScopedTimer T(SymbolMergingTimer); ScopedTimer t(symbolMergingTimer);
pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder(); pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder();
DebugSHandler DSH(*this, *File, *IndexMapResult); DebugSHandler dsh(*this, *file, *indexMapResult);
// Now do all live .debug$S and .debug$F sections. // Now do all live .debug$S and .debug$F sections.
for (SectionChunk *DebugChunk : File->getDebugChunks()) { for (SectionChunk *debugChunk : file->getDebugChunks()) {
if (!DebugChunk->Live || DebugChunk->getSize() == 0) if (!debugChunk->live || debugChunk->getSize() == 0)
continue; continue;
if (DebugChunk->getSectionName() == ".debug$S") { if (debugChunk->getSectionName() == ".debug$S") {
DSH.handleDebugS(*DebugChunk); dsh.handleDebugS(*debugChunk);
continue; continue;
} }
if (DebugChunk->getSectionName() == ".debug$F") { if (debugChunk->getSectionName() == ".debug$F") {
ArrayRef<uint8_t> RelocatedDebugContents = ArrayRef<uint8_t> relocatedDebugContents =
relocateDebugChunk(Alloc, *DebugChunk); relocateDebugChunk(alloc, *debugChunk);
FixedStreamArray<object::FpoData> FpoRecords; FixedStreamArray<object::FpoData> fpoRecords;
BinaryStreamReader Reader(RelocatedDebugContents, support::little); BinaryStreamReader reader(relocatedDebugContents, support::little);
uint32_t Count = RelocatedDebugContents.size() / sizeof(object::FpoData); uint32_t count = relocatedDebugContents.size() / sizeof(object::FpoData);
ExitOnErr(Reader.readArray(FpoRecords, Count)); exitOnErr(reader.readArray(fpoRecords, count));
// These are already relocated and don't refer to the string table, so we // These are already relocated and don't refer to the string table, so we
// can just copy it. // can just copy it.
for (const object::FpoData &FD : FpoRecords) for (const object::FpoData &fd : fpoRecords)
DbiBuilder.addOldFpoData(FD); dbiBuilder.addOldFpoData(fd);
continue; continue;
} }
} }
// Do any post-processing now that all .debug$S sections have been processed. // Do any post-processing now that all .debug$S sections have been processed.
DSH.finish(); dsh.finish();
} }
// Add a module descriptor for every object file. We need to put an absolute // Add a module descriptor for every object file. We need to put an absolute
// path to the object into the PDB. If this is a plain object, we make its // path to the object into the PDB. If this is a plain object, we make its
// path absolute. If it's an object in an archive, we make the archive path // path absolute. If it's an object in an archive, we make the archive path
// absolute. // absolute.
static void createModuleDBI(pdb::PDBFileBuilder &Builder) { static void createModuleDBI(pdb::PDBFileBuilder &builder) {
pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder(); pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder();
SmallString<128> ObjName; SmallString<128> objName;
for (ObjFile *File : ObjFile::Instances) { for (ObjFile *file : ObjFile::instances) {
bool InArchive = !File->ParentName.empty(); bool inArchive = !file->parentName.empty();
ObjName = InArchive ? File->ParentName : File->getName(); objName = inArchive ? file->parentName : file->getName();
pdbMakeAbsolute(ObjName); pdbMakeAbsolute(objName);
StringRef ModName = InArchive ? File->getName() : StringRef(ObjName); StringRef modName = inArchive ? file->getName() : StringRef(objName);
File->ModuleDBI = &ExitOnErr(DbiBuilder.addModuleInfo(ModName)); file->moduleDBI = &exitOnErr(dbiBuilder.addModuleInfo(modName));
File->ModuleDBI->setObjFileName(ObjName); file->moduleDBI->setObjFileName(objName);
ArrayRef<Chunk *> Chunks = File->getChunks(); ArrayRef<Chunk *> chunks = file->getChunks();
uint32_t Modi = File->ModuleDBI->getModuleIndex(); uint32_t modi = file->moduleDBI->getModuleIndex();
for (Chunk *C : Chunks) { for (Chunk *c : chunks) {
auto *SecChunk = dyn_cast<SectionChunk>(C); auto *secChunk = dyn_cast<SectionChunk>(c);
if (!SecChunk || !SecChunk->Live) if (!secChunk || !secChunk->live)
continue; continue;
pdb::SectionContrib SC = createSectionContrib(SecChunk, Modi); pdb::SectionContrib sc = createSectionContrib(secChunk, modi);
File->ModuleDBI->setFirstSectionContrib(SC); file->moduleDBI->setFirstSectionContrib(sc);
break; break;
} }
} }
} }
static PublicSym32 createPublic(Defined *Def) { static PublicSym32 createPublic(Defined *def) {
PublicSym32 Pub(SymbolKind::S_PUB32); PublicSym32 pub(SymbolKind::S_PUB32);
Pub.Name = Def->getName(); pub.Name = def->getName();
if (auto *D = dyn_cast<DefinedCOFF>(Def)) { if (auto *d = dyn_cast<DefinedCOFF>(def)) {
if (D->getCOFFSymbol().isFunctionDefinition()) if (d->getCOFFSymbol().isFunctionDefinition())
Pub.Flags = PublicSymFlags::Function; pub.Flags = PublicSymFlags::Function;
} else if (isa<DefinedImportThunk>(Def)) { } else if (isa<DefinedImportThunk>(def)) {
Pub.Flags = PublicSymFlags::Function; pub.Flags = PublicSymFlags::Function;
} }
OutputSection *OS = Def->getChunk()->getOutputSection(); OutputSection *os = def->getChunk()->getOutputSection();
assert(OS && "all publics should be in final image"); assert(os && "all publics should be in final image");
Pub.Offset = Def->getRVA() - OS->getRVA(); pub.Offset = def->getRVA() - os->getRVA();
Pub.Segment = OS->SectionIndex; pub.Segment = os->sectionIndex;
return Pub; return pub;
} }
// Add all object files to the PDB. Merge .debug$T sections into IpiData and // Add all object files to the PDB. Merge .debug$T sections into IpiData and
// TpiData. // TpiData.
void PDBLinker::addObjectsToPDB() { void PDBLinker::addObjectsToPDB() {
ScopedTimer T1(AddObjectsTimer); ScopedTimer t1(addObjectsTimer);
createModuleDBI(Builder); createModuleDBI(builder);
for (ObjFile *File : ObjFile::Instances) for (ObjFile *file : ObjFile::instances)
addObjFile(File); addObjFile(file);
Builder.getStringTableBuilder().setStrings(PDBStrTab); builder.getStringTableBuilder().setStrings(pdbStrTab);
T1.stop(); t1.stop();
// Construct TPI and IPI stream contents. // Construct TPI and IPI stream contents.
ScopedTimer T2(TpiStreamLayoutTimer); ScopedTimer t2(tpiStreamLayoutTimer);
addTypeInfo(Builder.getTpiBuilder(), TMerger.getTypeTable()); addTypeInfo(builder.getTpiBuilder(), tMerger.getTypeTable());
addTypeInfo(Builder.getIpiBuilder(), TMerger.getIDTable()); addTypeInfo(builder.getIpiBuilder(), tMerger.getIDTable());
T2.stop(); t2.stop();
ScopedTimer T3(GlobalsLayoutTimer); ScopedTimer t3(globalsLayoutTimer);
// Compute the public and global symbols. // Compute the public and global symbols.
auto &GsiBuilder = Builder.getGsiBuilder(); auto &gsiBuilder = builder.getGsiBuilder();
std::vector<PublicSym32> Publics; std::vector<PublicSym32> publics;
Symtab->forEachSymbol([&Publics](Symbol *S) { symtab->forEachSymbol([&publics](Symbol *s) {
// Only emit defined, live symbols that have a chunk. // Only emit defined, live symbols that have a chunk.
auto *Def = dyn_cast<Defined>(S); auto *def = dyn_cast<Defined>(s);
if (Def && Def->isLive() && Def->getChunk()) if (def && def->isLive() && def->getChunk())
Publics.push_back(createPublic(Def)); publics.push_back(createPublic(def));
}); });
if (!Publics.empty()) { if (!publics.empty()) {
PublicSymbols = Publics.size(); publicSymbols = publics.size();
// Sort the public symbols and add them to the stream. // Sort the public symbols and add them to the stream.
parallelSort(Publics, [](const PublicSym32 &L, const PublicSym32 &R) { parallelSort(publics, [](const PublicSym32 &l, const PublicSym32 &r) {
return L.Name < R.Name; return l.Name < r.Name;
}); });
for (const PublicSym32 &Pub : Publics) for (const PublicSym32 &pub : publics)
GsiBuilder.addPublicSymbol(Pub); gsiBuilder.addPublicSymbol(pub);
} }
} }
void PDBLinker::printStats() { void PDBLinker::printStats() {
if (!Config->ShowSummary) if (!config->showSummary)
return; return;
SmallString<256> Buffer; SmallString<256> buffer;
raw_svector_ostream Stream(Buffer); raw_svector_ostream stream(buffer);
Stream << center_justify("Summary", 80) << '\n' stream << center_justify("Summary", 80) << '\n'
<< std::string(80, '-') << '\n'; << std::string(80, '-') << '\n';
auto Print = [&](uint64_t V, StringRef S) { auto print = [&](uint64_t v, StringRef s) {
Stream << format_decimal(V, 15) << " " << S << '\n'; stream << format_decimal(v, 15) << " " << s << '\n';
}; };
Print(ObjFile::Instances.size(), print(ObjFile::instances.size(),
"Input OBJ files (expanded from all cmd-line inputs)"); "Input OBJ files (expanded from all cmd-line inputs)");
Print(TypeServerIndexMappings.size(), "PDB type server dependencies"); print(typeServerIndexMappings.size(), "PDB type server dependencies");
Print(PrecompTypeIndexMappings.size(), "Precomp OBJ dependencies"); print(precompTypeIndexMappings.size(), "Precomp OBJ dependencies");
Print(TMerger.getTypeTable().size() + TMerger.getIDTable().size(), print(tMerger.getTypeTable().size() + tMerger.getIDTable().size(),
"Merged TPI records"); "Merged TPI records");
Print(PDBStrTab.size(), "Output PDB strings"); print(pdbStrTab.size(), "Output PDB strings");
Print(GlobalSymbols, "Global symbol records"); print(globalSymbols, "Global symbol records");
Print(ModuleSymbols, "Module symbol records"); print(moduleSymbols, "Module symbol records");
Print(PublicSymbols, "Public symbol records"); print(publicSymbols, "Public symbol records");
message(Buffer); message(buffer);
} }
void PDBLinker::addNatvisFiles() { void PDBLinker::addNatvisFiles() {
for (StringRef File : Config->NatvisFiles) { for (StringRef file : config->natvisFiles) {
ErrorOr<std::unique_ptr<MemoryBuffer>> DataOrErr = ErrorOr<std::unique_ptr<MemoryBuffer>> dataOrErr =
MemoryBuffer::getFile(File); MemoryBuffer::getFile(file);
if (!DataOrErr) { if (!dataOrErr) {
warn("Cannot open input file: " + File); warn("Cannot open input file: " + file);
continue; continue;
} }
Builder.addInjectedSource(File, std::move(*DataOrErr)); builder.addInjectedSource(file, std::move(*dataOrErr));
} }
} }
static codeview::CPUType toCodeViewMachine(COFF::MachineTypes Machine) { static codeview::CPUType toCodeViewMachine(COFF::MachineTypes machine) {
switch (Machine) { switch (machine) {
case COFF::IMAGE_FILE_MACHINE_AMD64: case COFF::IMAGE_FILE_MACHINE_AMD64:
return codeview::CPUType::X64; return codeview::CPUType::X64;
case COFF::IMAGE_FILE_MACHINE_ARM: case COFF::IMAGE_FILE_MACHINE_ARM:
return codeview::CPUType::ARM7; return codeview::CPUType::ARM7;
case COFF::IMAGE_FILE_MACHINE_ARM64: case COFF::IMAGE_FILE_MACHINE_ARM64:
return codeview::CPUType::ARM64; return codeview::CPUType::ARM64;
case COFF::IMAGE_FILE_MACHINE_ARMNT: case COFF::IMAGE_FILE_MACHINE_ARMNT:
return codeview::CPUType::ARMNT; return codeview::CPUType::ARMNT;
case COFF::IMAGE_FILE_MACHINE_I386: case COFF::IMAGE_FILE_MACHINE_I386:
return codeview::CPUType::Intel80386; return codeview::CPUType::Intel80386;
default: default:
llvm_unreachable("Unsupported CPU Type"); llvm_unreachable("Unsupported CPU Type");
} }
} }
// Mimic MSVC which surrounds arguments containing whitespace with quotes. // Mimic MSVC which surrounds arguments containing whitespace with quotes.
// Double double-quotes are handled, so that the resulting string can be // Double double-quotes are handled, so that the resulting string can be
// executed again on the cmd-line. // executed again on the cmd-line.
static std::string quote(ArrayRef<StringRef> Args) { static std::string quote(ArrayRef<StringRef> args) {
std::string R; std::string r;
R.reserve(256); r.reserve(256);
for (StringRef A : Args) { for (StringRef a : args) {
if (!R.empty()) if (!r.empty())
R.push_back(' '); r.push_back(' ');
bool HasWS = A.find(' ') != StringRef::npos; bool hasWS = a.find(' ') != StringRef::npos;
bool HasQ = A.find('"') != StringRef::npos; bool hasQ = a.find('"') != StringRef::npos;
if (HasWS || HasQ) if (hasWS || hasQ)
R.push_back('"'); r.push_back('"');
if (HasQ) { if (hasQ) {
SmallVector<StringRef, 4> S; SmallVector<StringRef, 4> s;
A.split(S, '"'); a.split(s, '"');
R.append(join(S, "\"\"")); r.append(join(s, "\"\""));
} else { } else {
R.append(A); r.append(a);
} }
if (HasWS || HasQ) if (hasWS || hasQ)
R.push_back('"'); r.push_back('"');
} }
return R; return r;
} }
static void fillLinkerVerRecord(Compile3Sym &CS) { static void fillLinkerVerRecord(Compile3Sym &cs) {
CS.Machine = toCodeViewMachine(Config->Machine); cs.Machine = toCodeViewMachine(config->machine);
// Interestingly, if we set the string to 0.0.0.0, then when trying to view // Interestingly, if we set the string to 0.0.0.0, then when trying to view
// local variables WinDbg emits an error that private symbols are not present. // local variables WinDbg emits an error that private symbols are not present.
// By setting this to a valid MSVC linker version string, local variables are // By setting this to a valid MSVC linker version string, local variables are
// displayed properly. As such, even though it is not representative of // displayed properly. As such, even though it is not representative of
// LLVM's version information, we need this for compatibility. // LLVM's version information, we need this for compatibility.
CS.Flags = CompileSym3Flags::None; cs.Flags = CompileSym3Flags::None;
CS.VersionBackendBuild = 25019; cs.VersionBackendBuild = 25019;
CS.VersionBackendMajor = 14; cs.VersionBackendMajor = 14;
CS.VersionBackendMinor = 10; cs.VersionBackendMinor = 10;
CS.VersionBackendQFE = 0; cs.VersionBackendQFE = 0;
// MSVC also sets the frontend to 0.0.0.0 since this is specifically for the // MSVC also sets the frontend to 0.0.0.0 since this is specifically for the
// linker module (which is by definition a backend), so we don't need to do // linker module (which is by definition a backend), so we don't need to do
// anything here. Also, it seems we can use "LLVM Linker" for the linker name // anything here. Also, it seems we can use "LLVM Linker" for the linker name
// without any problems. Only the backend version has to be hardcoded to a // without any problems. Only the backend version has to be hardcoded to a
// magic number. // magic number.
CS.VersionFrontendBuild = 0; cs.VersionFrontendBuild = 0;
CS.VersionFrontendMajor = 0; cs.VersionFrontendMajor = 0;
CS.VersionFrontendMinor = 0; cs.VersionFrontendMinor = 0;
CS.VersionFrontendQFE = 0; cs.VersionFrontendQFE = 0;
CS.Version = "LLVM Linker"; cs.Version = "LLVM Linker";
CS.setLanguage(SourceLanguage::Link); cs.setLanguage(SourceLanguage::Link);
} }
static void addCommonLinkerModuleSymbols(StringRef Path, static void addCommonLinkerModuleSymbols(StringRef path,
pdb::DbiModuleDescriptorBuilder &Mod, pdb::DbiModuleDescriptorBuilder &mod,
BumpPtrAllocator &Allocator) { BumpPtrAllocator &allocator) {
ObjNameSym ONS(SymbolRecordKind::ObjNameSym); ObjNameSym ons(SymbolRecordKind::ObjNameSym);
EnvBlockSym EBS(SymbolRecordKind::EnvBlockSym); EnvBlockSym ebs(SymbolRecordKind::EnvBlockSym);
Compile3Sym CS(SymbolRecordKind::Compile3Sym); Compile3Sym cs(SymbolRecordKind::Compile3Sym);
fillLinkerVerRecord(CS); fillLinkerVerRecord(cs);
ONS.Name = "* Linker *"; ons.Name = "* Linker *";
ONS.Signature = 0; ons.Signature = 0;
ArrayRef<StringRef> Args = makeArrayRef(Config->Argv).drop_front(); ArrayRef<StringRef> args = makeArrayRef(config->argv).drop_front();
std::string ArgStr = quote(Args); std::string argStr = quote(args);
EBS.Fields.push_back("cwd"); ebs.Fields.push_back("cwd");
SmallString<64> cwd; SmallString<64> cwd;
if (Config->PDBSourcePath.empty()) if (config->pdbSourcePath.empty())
sys::fs::current_path(cwd); sys::fs::current_path(cwd);
else else
cwd = Config->PDBSourcePath; cwd = config->pdbSourcePath;
EBS.Fields.push_back(cwd); ebs.Fields.push_back(cwd);
EBS.Fields.push_back("exe"); ebs.Fields.push_back("exe");
SmallString<64> exe = Config->Argv[0]; SmallString<64> exe = config->argv[0];
pdbMakeAbsolute(exe); pdbMakeAbsolute(exe);
EBS.Fields.push_back(exe); ebs.Fields.push_back(exe);
EBS.Fields.push_back("pdb"); ebs.Fields.push_back("pdb");
EBS.Fields.push_back(Path); ebs.Fields.push_back(path);
EBS.Fields.push_back("cmd"); ebs.Fields.push_back("cmd");
EBS.Fields.push_back(ArgStr); ebs.Fields.push_back(argStr);
Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol( mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
ONS, Allocator, CodeViewContainer::Pdb)); ons, allocator, CodeViewContainer::Pdb));
Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol( mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
CS, Allocator, CodeViewContainer::Pdb)); cs, allocator, CodeViewContainer::Pdb));
Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol( mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
EBS, Allocator, CodeViewContainer::Pdb)); ebs, allocator, CodeViewContainer::Pdb));
} }
static void addLinkerModuleCoffGroup(PartialSection *Sec, static void addLinkerModuleCoffGroup(PartialSection *sec,
pdb::DbiModuleDescriptorBuilder &Mod, pdb::DbiModuleDescriptorBuilder &mod,
OutputSection &OS, OutputSection &os,
BumpPtrAllocator &Allocator) { BumpPtrAllocator &allocator) {
// If there's a section, there's at least one chunk // If there's a section, there's at least one chunk
assert(!Sec->Chunks.empty()); assert(!sec->chunks.empty());
const Chunk *firstChunk = *Sec->Chunks.begin(); const Chunk *firstChunk = *sec->chunks.begin();
const Chunk *lastChunk = *Sec->Chunks.rbegin(); const Chunk *lastChunk = *sec->chunks.rbegin();
// Emit COFF group // Emit COFF group
CoffGroupSym CGS(SymbolRecordKind::CoffGroupSym); CoffGroupSym cgs(SymbolRecordKind::CoffGroupSym);
CGS.Name = Sec->Name; cgs.Name = sec->name;
CGS.Segment = OS.SectionIndex; cgs.Segment = os.sectionIndex;
CGS.Offset = firstChunk->getRVA() - OS.getRVA(); cgs.Offset = firstChunk->getRVA() - os.getRVA();
CGS.Size = lastChunk->getRVA() + lastChunk->getSize() - firstChunk->getRVA(); cgs.Size = lastChunk->getRVA() + lastChunk->getSize() - firstChunk->getRVA();
CGS.Characteristics = Sec->Characteristics; cgs.Characteristics = sec->characteristics;
// Somehow .idata sections & sections groups in the debug symbol stream have // Somehow .idata sections & sections groups in the debug symbol stream have
// the "write" flag set. However the section header for the corresponding // the "write" flag set. However the section header for the corresponding
// .idata section doesn't have it. // .idata section doesn't have it.
if (CGS.Name.startswith(".idata")) if (cgs.Name.startswith(".idata"))
CGS.Characteristics |= llvm::COFF::IMAGE_SCN_MEM_WRITE; cgs.Characteristics |= llvm::COFF::IMAGE_SCN_MEM_WRITE;
Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol( mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
CGS, Allocator, CodeViewContainer::Pdb)); cgs, allocator, CodeViewContainer::Pdb));
} }
static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &Mod, static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &mod,
OutputSection &OS, OutputSection &os,
BumpPtrAllocator &Allocator) { BumpPtrAllocator &allocator) {
SectionSym Sym(SymbolRecordKind::SectionSym); SectionSym sym(SymbolRecordKind::SectionSym);
Sym.Alignment = 12; // 2^12 = 4KB sym.Alignment = 12; // 2^12 = 4KB
Sym.Characteristics = OS.Header.Characteristics; sym.Characteristics = os.header.Characteristics;
Sym.Length = OS.getVirtualSize(); sym.Length = os.getVirtualSize();
Sym.Name = OS.Name; sym.Name = os.name;
Sym.Rva = OS.getRVA(); sym.Rva = os.getRVA();
Sym.SectionNumber = OS.SectionIndex; sym.SectionNumber = os.sectionIndex;
Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol( mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
Sym, Allocator, CodeViewContainer::Pdb)); sym, allocator, CodeViewContainer::Pdb));
// Skip COFF groups in MinGW because it adds a significant footprint to the // Skip COFF groups in MinGW because it adds a significant footprint to the
// PDB, due to each function being in its own section // PDB, due to each function being in its own section
if (Config->MinGW) if (config->mingw)
return; return;
// Output COFF groups for individual chunks of this section. // Output COFF groups for individual chunks of this section.
for (PartialSection *Sec : OS.ContribSections) { for (PartialSection *sec : os.contribSections) {
addLinkerModuleCoffGroup(Sec, Mod, OS, Allocator); addLinkerModuleCoffGroup(sec, mod, os, allocator);
} }
} }
// Add all import files as modules to the PDB. // Add all import files as modules to the PDB.
void PDBLinker::addImportFilesToPDB(ArrayRef<OutputSection *> OutputSections) { void PDBLinker::addImportFilesToPDB(ArrayRef<OutputSection *> outputSections) {
if (ImportFile::Instances.empty()) if (ImportFile::instances.empty())
return; return;
std::map<std::string, llvm::pdb::DbiModuleDescriptorBuilder *> DllToModuleDbi; std::map<std::string, llvm::pdb::DbiModuleDescriptorBuilder *> dllToModuleDbi;
for (ImportFile *File : ImportFile::Instances) { for (ImportFile *file : ImportFile::instances) {
if (!File->Live) if (!file->live)
continue; continue;
if (!File->ThunkSym) if (!file->thunkSym)
continue; continue;
if (!File->ThunkLive) if (!file->thunkLive)
continue; continue;
std::string DLL = StringRef(File->DLLName).lower(); std::string dll = StringRef(file->dllName).lower();
llvm::pdb::DbiModuleDescriptorBuilder *&Mod = DllToModuleDbi[DLL]; llvm::pdb::DbiModuleDescriptorBuilder *&mod = dllToModuleDbi[dll];
if (!Mod) { if (!mod) {
pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder(); pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder();
SmallString<128> LibPath = File->ParentName; SmallString<128> libPath = file->parentName;
pdbMakeAbsolute(LibPath); pdbMakeAbsolute(libPath);
sys::path::native(LibPath); sys::path::native(libPath);
// Name modules similar to MSVC's link.exe. // Name modules similar to MSVC's link.exe.
// The first module is the simple dll filename // The first module is the simple dll filename
llvm::pdb::DbiModuleDescriptorBuilder &FirstMod = llvm::pdb::DbiModuleDescriptorBuilder &firstMod =
ExitOnErr(DbiBuilder.addModuleInfo(File->DLLName)); exitOnErr(dbiBuilder.addModuleInfo(file->dllName));
FirstMod.setObjFileName(LibPath); firstMod.setObjFileName(libPath);
pdb::SectionContrib SC = pdb::SectionContrib sc =
createSectionContrib(nullptr, llvm::pdb::kInvalidStreamIndex); createSectionContrib(nullptr, llvm::pdb::kInvalidStreamIndex);
FirstMod.setFirstSectionContrib(SC); firstMod.setFirstSectionContrib(sc);
// The second module is where the import stream goes. // The second module is where the import stream goes.
Mod = &ExitOnErr(DbiBuilder.addModuleInfo("Import:" + File->DLLName)); mod = &exitOnErr(dbiBuilder.addModuleInfo("Import:" + file->dllName));
Mod->setObjFileName(LibPath); mod->setObjFileName(libPath);
} }
DefinedImportThunk *Thunk = cast<DefinedImportThunk>(File->ThunkSym); DefinedImportThunk *thunk = cast<DefinedImportThunk>(file->thunkSym);
Chunk *ThunkChunk = Thunk->getChunk(); Chunk *thunkChunk = thunk->getChunk();
OutputSection *ThunkOS = ThunkChunk->getOutputSection(); OutputSection *thunkOS = thunkChunk->getOutputSection();
ObjNameSym ONS(SymbolRecordKind::ObjNameSym); ObjNameSym ons(SymbolRecordKind::ObjNameSym);
Compile3Sym CS(SymbolRecordKind::Compile3Sym); Compile3Sym cs(SymbolRecordKind::Compile3Sym);
Thunk32Sym TS(SymbolRecordKind::Thunk32Sym); Thunk32Sym ts(SymbolRecordKind::Thunk32Sym);
ScopeEndSym ES(SymbolRecordKind::ScopeEndSym); ScopeEndSym es(SymbolRecordKind::ScopeEndSym);
ONS.Name = File->DLLName; ons.Name = file->dllName;
ONS.Signature = 0; ons.Signature = 0;
fillLinkerVerRecord(CS); fillLinkerVerRecord(cs);
TS.Name = Thunk->getName(); ts.Name = thunk->getName();
TS.Parent = 0; ts.Parent = 0;
TS.End = 0; ts.End = 0;
TS.Next = 0; ts.Next = 0;
TS.Thunk = ThunkOrdinal::Standard; ts.Thunk = ThunkOrdinal::Standard;
TS.Length = ThunkChunk->getSize(); ts.Length = thunkChunk->getSize();
TS.Segment = ThunkOS->SectionIndex; ts.Segment = thunkOS->sectionIndex;
TS.Offset = ThunkChunk->getRVA() - ThunkOS->getRVA(); ts.Offset = thunkChunk->getRVA() - thunkOS->getRVA();
Mod->addSymbol(codeview::SymbolSerializer::writeOneSymbol( mod->addSymbol(codeview::SymbolSerializer::writeOneSymbol(
ONS, Alloc, CodeViewContainer::Pdb)); ons, alloc, CodeViewContainer::Pdb));
Mod->addSymbol(codeview::SymbolSerializer::writeOneSymbol( mod->addSymbol(codeview::SymbolSerializer::writeOneSymbol(
CS, Alloc, CodeViewContainer::Pdb)); cs, alloc, CodeViewContainer::Pdb));
SmallVector<SymbolScope, 4> Scopes; SmallVector<SymbolScope, 4> scopes;
CVSymbol NewSym = codeview::SymbolSerializer::writeOneSymbol( CVSymbol newSym = codeview::SymbolSerializer::writeOneSymbol(
TS, Alloc, CodeViewContainer::Pdb); ts, alloc, CodeViewContainer::Pdb);
scopeStackOpen(Scopes, Mod->getNextSymbolOffset(), NewSym); scopeStackOpen(scopes, mod->getNextSymbolOffset(), newSym);
Mod->addSymbol(NewSym); mod->addSymbol(newSym);
NewSym = codeview::SymbolSerializer::writeOneSymbol(ES, Alloc, newSym = codeview::SymbolSerializer::writeOneSymbol(es, alloc,
CodeViewContainer::Pdb); CodeViewContainer::Pdb);
scopeStackClose(Scopes, Mod->getNextSymbolOffset(), File); scopeStackClose(scopes, mod->getNextSymbolOffset(), file);
Mod->addSymbol(NewSym); mod->addSymbol(newSym);
pdb::SectionContrib SC = pdb::SectionContrib sc =
createSectionContrib(Thunk->getChunk(), Mod->getModuleIndex()); createSectionContrib(thunk->getChunk(), mod->getModuleIndex());
Mod->setFirstSectionContrib(SC); mod->setFirstSectionContrib(sc);
} }
} }
// Creates a PDB file. // Creates a PDB file.
void coff::createPDB(SymbolTable *Symtab, void coff::createPDB(SymbolTable *symtab,
ArrayRef<OutputSection *> OutputSections, ArrayRef<OutputSection *> outputSections,
ArrayRef<uint8_t> SectionTable, ArrayRef<uint8_t> sectionTable,
llvm::codeview::DebugInfo *BuildId) { llvm::codeview::DebugInfo *buildId) {
ScopedTimer T1(TotalPdbLinkTimer); ScopedTimer t1(totalPdbLinkTimer);
PDBLinker PDB(Symtab); PDBLinker pdb(symtab);
PDB.initialize(BuildId); pdb.initialize(buildId);
PDB.addObjectsToPDB(); pdb.addObjectsToPDB();
PDB.addImportFilesToPDB(OutputSections); pdb.addImportFilesToPDB(outputSections);
PDB.addSections(OutputSections, SectionTable); pdb.addSections(outputSections, sectionTable);
PDB.addNatvisFiles(); pdb.addNatvisFiles();
ScopedTimer T2(DiskCommitTimer); ScopedTimer t2(diskCommitTimer);
codeview::GUID Guid; codeview::GUID guid;
PDB.commit(&Guid); pdb.commit(&guid);
memcpy(&BuildId->PDB70.Signature, &Guid, 16); memcpy(&buildId->PDB70.Signature, &guid, 16);
T2.stop(); t2.stop();
T1.stop(); t1.stop();
PDB.printStats(); pdb.printStats();
} }
void PDBLinker::initialize(llvm::codeview::DebugInfo *BuildId) { void PDBLinker::initialize(llvm::codeview::DebugInfo *buildId) {
ExitOnErr(Builder.initialize(4096)); // 4096 is blocksize exitOnErr(builder.initialize(4096)); // 4096 is blocksize
BuildId->Signature.CVSignature = OMF::Signature::PDB70; buildId->Signature.CVSignature = OMF::Signature::PDB70;
// Signature is set to a hash of the PDB contents when the PDB is done. // Signature is set to a hash of the PDB contents when the PDB is done.
memset(BuildId->PDB70.Signature, 0, 16); memset(buildId->PDB70.Signature, 0, 16);
BuildId->PDB70.Age = 1; buildId->PDB70.Age = 1;
// Create streams in MSF for predefined streams, namely // Create streams in MSF for predefined streams, namely
// PDB, TPI, DBI and IPI. // PDB, TPI, DBI and IPI.
for (int I = 0; I < (int)pdb::kSpecialStreamCount; ++I) for (int i = 0; i < (int)pdb::kSpecialStreamCount; ++i)
ExitOnErr(Builder.getMsfBuilder().addStream(0)); exitOnErr(builder.getMsfBuilder().addStream(0));
// Add an Info stream. // Add an Info stream.
auto &InfoBuilder = Builder.getInfoBuilder(); auto &infoBuilder = builder.getInfoBuilder();
InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70); infoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);
InfoBuilder.setHashPDBContentsToGUID(true); infoBuilder.setHashPDBContentsToGUID(true);
// Add an empty DBI stream. // Add an empty DBI stream.
pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder(); pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder();
DbiBuilder.setAge(BuildId->PDB70.Age); dbiBuilder.setAge(buildId->PDB70.Age);
DbiBuilder.setVersionHeader(pdb::PdbDbiV70); dbiBuilder.setVersionHeader(pdb::PdbDbiV70);
DbiBuilder.setMachineType(Config->Machine); dbiBuilder.setMachineType(config->machine);
// Technically we are not link.exe 14.11, but there are known cases where // Technically we are not link.exe 14.11, but there are known cases where
// debugging tools on Windows expect Microsoft-specific version numbers or // debugging tools on Windows expect Microsoft-specific version numbers or
// they fail to work at all. Since we know we produce PDBs that are // they fail to work at all. Since we know we produce PDBs that are
// compatible with LINK 14.11, we set that version number here. // compatible with LINK 14.11, we set that version number here.
DbiBuilder.setBuildNumber(14, 11); dbiBuilder.setBuildNumber(14, 11);
} }
void PDBLinker::addSections(ArrayRef<OutputSection *> OutputSections, void PDBLinker::addSections(ArrayRef<OutputSection *> outputSections,
ArrayRef<uint8_t> SectionTable) { ArrayRef<uint8_t> sectionTable) {
// It's not entirely clear what this is, but the * Linker * module uses it. // It's not entirely clear what this is, but the * Linker * module uses it.
pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder(); pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder();
NativePath = Config->PDBPath; nativePath = config->pdbPath;
pdbMakeAbsolute(NativePath); pdbMakeAbsolute(nativePath);
uint32_t PdbFilePathNI = DbiBuilder.addECName(NativePath); uint32_t pdbFilePathNI = dbiBuilder.addECName(nativePath);
auto &LinkerModule = ExitOnErr(DbiBuilder.addModuleInfo("* Linker *")); auto &linkerModule = exitOnErr(dbiBuilder.addModuleInfo("* Linker *"));
LinkerModule.setPdbFilePathNI(PdbFilePathNI); linkerModule.setPdbFilePathNI(pdbFilePathNI);
addCommonLinkerModuleSymbols(NativePath, LinkerModule, Alloc); addCommonLinkerModuleSymbols(nativePath, linkerModule, alloc);
// Add section contributions. They must be ordered by ascending RVA. // Add section contributions. They must be ordered by ascending RVA.
for (OutputSection *OS : OutputSections) { for (OutputSection *os : outputSections) {
addLinkerModuleSectionSymbol(LinkerModule, *OS, Alloc); addLinkerModuleSectionSymbol(linkerModule, *os, alloc);
for (Chunk *C : OS->Chunks) { for (Chunk *c : os->chunks) {
pdb::SectionContrib SC = pdb::SectionContrib sc =
createSectionContrib(C, LinkerModule.getModuleIndex()); createSectionContrib(c, linkerModule.getModuleIndex());
Builder.getDbiBuilder().addSectionContrib(SC); builder.getDbiBuilder().addSectionContrib(sc);
} }
} }
// The * Linker * first section contrib is only used along with /INCREMENTAL, // The * Linker * first section contrib is only used along with /INCREMENTAL,
// to provide trampolines thunks for incremental function patching. Set this // to provide trampolines thunks for incremental function patching. Set this
// as "unused" because LLD doesn't support /INCREMENTAL link. // as "unused" because LLD doesn't support /INCREMENTAL link.
pdb::SectionContrib SC = pdb::SectionContrib sc =
createSectionContrib(nullptr, llvm::pdb::kInvalidStreamIndex); createSectionContrib(nullptr, llvm::pdb::kInvalidStreamIndex);
LinkerModule.setFirstSectionContrib(SC); linkerModule.setFirstSectionContrib(sc);
// Add Section Map stream. // Add Section Map stream.
ArrayRef<object::coff_section> Sections = { ArrayRef<object::coff_section> sections = {
(const object::coff_section *)SectionTable.data(), (const object::coff_section *)sectionTable.data(),
SectionTable.size() / sizeof(object::coff_section)}; sectionTable.size() / sizeof(object::coff_section)};
SectionMap = pdb::DbiStreamBuilder::createSectionMap(Sections); sectionMap = pdb::DbiStreamBuilder::createSectionMap(sections);
DbiBuilder.setSectionMap(SectionMap); dbiBuilder.setSectionMap(sectionMap);
// Add COFF section header stream. // Add COFF section header stream.
ExitOnErr( exitOnErr(
DbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, SectionTable)); dbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, sectionTable));
} }
void PDBLinker::commit(codeview::GUID *Guid) { void PDBLinker::commit(codeview::GUID *guid) {
// Write to a file. // Write to a file.
ExitOnErr(Builder.commit(Config->PDBPath, Guid)); exitOnErr(builder.commit(config->pdbPath, guid));
} }
static uint32_t getSecrelReloc() { static uint32_t getSecrelReloc() {
switch (Config->Machine) { switch (config->machine) {
case AMD64: case AMD64:
return COFF::IMAGE_REL_AMD64_SECREL; return COFF::IMAGE_REL_AMD64_SECREL;
case I386: case I386:
return COFF::IMAGE_REL_I386_SECREL; return COFF::IMAGE_REL_I386_SECREL;
case ARMNT: case ARMNT:
return COFF::IMAGE_REL_ARM_SECREL; return COFF::IMAGE_REL_ARM_SECREL;
case ARM64: case ARM64:
return COFF::IMAGE_REL_ARM64_SECREL; return COFF::IMAGE_REL_ARM64_SECREL;
default: default:
llvm_unreachable("unknown machine type"); llvm_unreachable("unknown machine type");
} }
} }
// Try to find a line table for the given offset Addr into the given chunk C. // Try to find a line table for the given offset Addr into the given chunk C.
// If a line table was found, the line table, the string and checksum tables // If a line table was found, the line table, the string and checksum tables
// that are used to interpret the line table, and the offset of Addr in the line // that are used to interpret the line table, and the offset of Addr in the line
// table are stored in the output arguments. Returns whether a line table was // table are stored in the output arguments. Returns whether a line table was
// found. // found.
static bool findLineTable(const SectionChunk *C, uint32_t Addr, static bool findLineTable(const SectionChunk *c, uint32_t addr,
DebugStringTableSubsectionRef &CVStrTab, DebugStringTableSubsectionRef &cVStrTab,
DebugChecksumsSubsectionRef &Checksums, DebugChecksumsSubsectionRef &checksums,
DebugLinesSubsectionRef &Lines, DebugLinesSubsectionRef &lines,
uint32_t &OffsetInLinetable) { uint32_t &offsetInLinetable) {
ExitOnError ExitOnErr; ExitOnError exitOnErr;
uint32_t SecrelReloc = getSecrelReloc(); uint32_t secrelReloc = getSecrelReloc();
for (SectionChunk *DbgC : C->File->getDebugChunks()) { for (SectionChunk *dbgC : c->file->getDebugChunks()) {
if (DbgC->getSectionName() != ".debug$S") if (dbgC->getSectionName() != ".debug$S")
continue; continue;
// Build a mapping of SECREL relocations in DbgC that refer to C. // Build a mapping of SECREL relocations in DbgC that refer to C.
DenseMap<uint32_t, uint32_t> Secrels; DenseMap<uint32_t, uint32_t> secrels;
for (const coff_relocation &R : DbgC->getRelocs()) { for (const coff_relocation &r : dbgC->getRelocs()) {
if (R.Type != SecrelReloc) if (r.Type != secrelReloc)
continue; continue;
if (auto *S = dyn_cast_or_null<DefinedRegular>( if (auto *s = dyn_cast_or_null<DefinedRegular>(
C->File->getSymbols()[R.SymbolTableIndex])) c->file->getSymbols()[r.SymbolTableIndex]))
if (S->getChunk() == C) if (s->getChunk() == c)
Secrels[R.VirtualAddress] = S->getValue(); secrels[r.VirtualAddress] = s->getValue();
} }
ArrayRef<uint8_t> Contents = ArrayRef<uint8_t> contents =
SectionChunk::consumeDebugMagic(DbgC->getContents(), ".debug$S"); SectionChunk::consumeDebugMagic(dbgC->getContents(), ".debug$S");
DebugSubsectionArray Subsections; DebugSubsectionArray subsections;
BinaryStreamReader Reader(Contents, support::little); BinaryStreamReader reader(contents, support::little);
ExitOnErr(Reader.readArray(Subsections, Contents.size())); exitOnErr(reader.readArray(subsections, contents.size()));
for (const DebugSubsectionRecord &SS : Subsections) { for (const DebugSubsectionRecord &ss : subsections) {
switch (SS.kind()) { switch (ss.kind()) {
case DebugSubsectionKind::StringTable: { case DebugSubsectionKind::StringTable: {
assert(!CVStrTab.valid() && assert(!cVStrTab.valid() &&
"Encountered multiple string table subsections!"); "Encountered multiple string table subsections!");
ExitOnErr(CVStrTab.initialize(SS.getRecordData())); exitOnErr(cVStrTab.initialize(ss.getRecordData()));
break; break;
} }
case DebugSubsectionKind::FileChecksums: case DebugSubsectionKind::FileChecksums:
assert(!Checksums.valid() && assert(!checksums.valid() &&
"Encountered multiple checksum subsections!"); "Encountered multiple checksum subsections!");
ExitOnErr(Checksums.initialize(SS.getRecordData())); exitOnErr(checksums.initialize(ss.getRecordData()));
break; break;
case DebugSubsectionKind::Lines: { case DebugSubsectionKind::Lines: {
ArrayRef<uint8_t> Bytes; ArrayRef<uint8_t> bytes;
auto Ref = SS.getRecordData(); auto ref = ss.getRecordData();
ExitOnErr(Ref.readLongestContiguousChunk(0, Bytes)); exitOnErr(ref.readLongestContiguousChunk(0, bytes));
size_t OffsetInDbgC = Bytes.data() - DbgC->getContents().data(); size_t offsetInDbgC = bytes.data() - dbgC->getContents().data();
// Check whether this line table refers to C. // Check whether this line table refers to C.
auto I = Secrels.find(OffsetInDbgC); auto i = secrels.find(offsetInDbgC);
if (I == Secrels.end()) if (i == secrels.end())
break; break;
// Check whether this line table covers Addr in C. // Check whether this line table covers Addr in C.
DebugLinesSubsectionRef LinesTmp; DebugLinesSubsectionRef linesTmp;
ExitOnErr(LinesTmp.initialize(BinaryStreamReader(Ref))); exitOnErr(linesTmp.initialize(BinaryStreamReader(ref)));
uint32_t OffsetInC = I->second + LinesTmp.header()->RelocOffset; uint32_t offsetInC = i->second + linesTmp.header()->RelocOffset;
if (Addr < OffsetInC || Addr >= OffsetInC + LinesTmp.header()->CodeSize) if (addr < offsetInC || addr >= offsetInC + linesTmp.header()->CodeSize)
break; break;
assert(!Lines.header() && assert(!lines.header() &&
"Encountered multiple line tables for function!"); "Encountered multiple line tables for function!");
ExitOnErr(Lines.initialize(BinaryStreamReader(Ref))); exitOnErr(lines.initialize(BinaryStreamReader(ref)));
OffsetInLinetable = Addr - OffsetInC; offsetInLinetable = addr - offsetInC;
break; break;
} }
default: default:
break; break;
} }
if (CVStrTab.valid() && Checksums.valid() && Lines.header()) if (cVStrTab.valid() && checksums.valid() && lines.header())
return true; return true;
} }
} }
return false; return false;
} }
// Use CodeView line tables to resolve a file and line number for the given // Use CodeView line tables to resolve a file and line number for the given
// offset into the given chunk and return them, or {"", 0} if a line table was // offset into the given chunk and return them, or {"", 0} if a line table was
// not found. // not found.
std::pair<StringRef, uint32_t> coff::getFileLine(const SectionChunk *C, std::pair<StringRef, uint32_t> coff::getFileLine(const SectionChunk *c,
uint32_t Addr) { uint32_t addr) {
ExitOnError ExitOnErr; ExitOnError exitOnErr;
DebugStringTableSubsectionRef CVStrTab; DebugStringTableSubsectionRef cVStrTab;
DebugChecksumsSubsectionRef Checksums; DebugChecksumsSubsectionRef checksums;
DebugLinesSubsectionRef Lines; DebugLinesSubsectionRef lines;
uint32_t OffsetInLinetable; uint32_t offsetInLinetable;
if (!findLineTable(C, Addr, CVStrTab, Checksums, Lines, OffsetInLinetable)) if (!findLineTable(c, addr, cVStrTab, checksums, lines, offsetInLinetable))
return {"", 0}; return {"", 0};
Optional<uint32_t> NameIndex; Optional<uint32_t> nameIndex;
Optional<uint32_t> LineNumber; Optional<uint32_t> lineNumber;
for (LineColumnEntry &Entry : Lines) { for (LineColumnEntry &entry : lines) {
for (const LineNumberEntry &LN : Entry.LineNumbers) { for (const LineNumberEntry &ln : entry.LineNumbers) {
LineInfo LI(LN.Flags); LineInfo li(ln.Flags);
if (LN.Offset > OffsetInLinetable) { if (ln.Offset > offsetInLinetable) {
if (!NameIndex) { if (!nameIndex) {
NameIndex = Entry.NameIndex; nameIndex = entry.NameIndex;
LineNumber = LI.getStartLine(); lineNumber = li.getStartLine();
} }
StringRef Filename = StringRef filename =
ExitOnErr(getFileName(CVStrTab, Checksums, *NameIndex)); exitOnErr(getFileName(cVStrTab, checksums, *nameIndex));
return {Filename, *LineNumber}; return {filename, *lineNumber};
} }
NameIndex = Entry.NameIndex; nameIndex = entry.NameIndex;
LineNumber = LI.getStartLine(); lineNumber = li.getStartLine();
} }
} }
if (!NameIndex) if (!nameIndex)
return {"", 0}; return {"", 0};
StringRef Filename = ExitOnErr(getFileName(CVStrTab, Checksums, *NameIndex)); StringRef filename = exitOnErr(getFileName(cVStrTab, checksums, *nameIndex));
return {Filename, *LineNumber}; return {filename, *lineNumber};
} }

lld/trunk/COFF/SymbolTable.h

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
// conflicts. For example, obviously, a defined symbol is better than // conflicts. For example, obviously, a defined symbol is better than
// an undefined symbol. Or, if there's a conflict between a lazy and a // an undefined symbol. Or, if there's a conflict between a lazy and a
// undefined, it'll read an archive member to read a real definition // undefined, it'll read an archive member to read a real definition
// to replace the lazy symbol. The logic is implemented in the // to replace the lazy symbol. The logic is implemented in the
// add*() functions, which are called by input files as they are parsed. // add*() functions, which are called by input files as they are parsed.
// There is one add* function per symbol type. // There is one add* function per symbol type.
class SymbolTable { class SymbolTable {
public: public:
void addFile(InputFile *File); void addFile(InputFile *file);
// Try to resolve any undefined symbols and update the symbol table // Try to resolve any undefined symbols and update the symbol table
// accordingly, then print an error message for any remaining undefined // accordingly, then print an error message for any remaining undefined
// symbols. // symbols.
void reportRemainingUndefines(); void reportRemainingUndefines();
void loadMinGWAutomaticImports(); void loadMinGWAutomaticImports();
bool handleMinGWAutomaticImport(Symbol *Sym, StringRef Name); bool handleMinGWAutomaticImport(Symbol *sym, StringRef name);
// Returns a list of chunks of selected symbols. // Returns a list of chunks of selected symbols.
std::vector<Chunk *> getChunks(); std::vector<Chunk *> getChunks();
// Returns a symbol for a given name. Returns a nullptr if not found. // Returns a symbol for a given name. Returns a nullptr if not found.
Symbol *find(StringRef Name); Symbol *find(StringRef name);
Symbol *findUnderscore(StringRef Name); Symbol *findUnderscore(StringRef name);
// Occasionally we have to resolve an undefined symbol to its // Occasionally we have to resolve an undefined symbol to its
// mangled symbol. This function tries to find a mangled name // mangled symbol. This function tries to find a mangled name
// for U from the symbol table, and if found, set the symbol as // for U from the symbol table, and if found, set the symbol as
// a weak alias for U. // a weak alias for U.
Symbol *findMangle(StringRef Name); Symbol *findMangle(StringRef name);
// Build a set of COFF objects representing the combined contents of // Build a set of COFF objects representing the combined contents of
// BitcodeFiles and add them to the symbol table. Called after all files are // BitcodeFiles and add them to the symbol table. Called after all files are
// added and before the writer writes results to a file. // added and before the writer writes results to a file.
void addCombinedLTOObjects(); void addCombinedLTOObjects();
std::vector<StringRef> compileBitcodeFiles(); std::vector<StringRef> compileBitcodeFiles();
// Creates an Undefined symbol for a given name. // Creates an Undefined symbol for a given name.
Symbol *addUndefined(StringRef Name); Symbol *addUndefined(StringRef name);
Symbol *addSynthetic(StringRef N, Chunk *C); Symbol *addSynthetic(StringRef n, Chunk *c);
Symbol *addAbsolute(StringRef N, uint64_t VA); Symbol *addAbsolute(StringRef n, uint64_t va);
Symbol *addUndefined(StringRef Name, InputFile *F, bool IsWeakAlias); Symbol *addUndefined(StringRef name, InputFile *f, bool isWeakAlias);
void addLazy(ArchiveFile *F, const Archive::Symbol Sym); void addLazy(ArchiveFile *f, const Archive::Symbol sym);
Symbol *addAbsolute(StringRef N, COFFSymbolRef S); Symbol *addAbsolute(StringRef n, COFFSymbolRef s);
Symbol *addRegular(InputFile *F, StringRef N, Symbol *addRegular(InputFile *f, StringRef n,
const llvm::object::coff_symbol_generic *S = nullptr, const llvm::object::coff_symbol_generic *s = nullptr,
SectionChunk *C = nullptr); SectionChunk *c = nullptr);
std::pair<DefinedRegular *, bool> std::pair<DefinedRegular *, bool>
addComdat(InputFile *F, StringRef N, addComdat(InputFile *f, StringRef n,
const llvm::object::coff_symbol_generic *S = nullptr); const llvm::object::coff_symbol_generic *s = nullptr);
Symbol *addCommon(InputFile *F, StringRef N, uint64_t Size, Symbol *addCommon(InputFile *f, StringRef n, uint64_t size,
const llvm::object::coff_symbol_generic *S = nullptr, const llvm::object::coff_symbol_generic *s = nullptr,
CommonChunk *C = nullptr); CommonChunk *c = nullptr);
Symbol *addImportData(StringRef N, ImportFile *F); Symbol *addImportData(StringRef n, ImportFile *f);
Symbol *addImportThunk(StringRef Name, DefinedImportData *S, Symbol *addImportThunk(StringRef name, DefinedImportData *s,
uint16_t Machine); uint16_t machine);
void reportDuplicate(Symbol *Existing, InputFile *NewFile); void reportDuplicate(Symbol *existing, InputFile *newFile);
// A list of chunks which to be added to .rdata. // A list of chunks which to be added to .rdata.
std::vector<Chunk *> LocalImportChunks; std::vector<Chunk *> localImportChunks;
// Iterates symbols in non-determinstic hash table order. // Iterates symbols in non-determinstic hash table order.
template <typename T> void forEachSymbol(T Callback) { template <typename T> void forEachSymbol(T callback) {
for (auto &Pair : SymMap) for (auto &pair : symMap)
Callback(Pair.second); callback(pair.second);
} }
private: private:
/// Inserts symbol if not already present. /// Inserts symbol if not already present.
std::pair<Symbol *, bool> insert(StringRef Name); std::pair<Symbol *, bool> insert(StringRef name);
/// Same as insert(Name), but also sets IsUsedInRegularObj. /// Same as insert(Name), but also sets IsUsedInRegularObj.
std::pair<Symbol *, bool> insert(StringRef Name, InputFile *F); std::pair<Symbol *, bool> insert(StringRef name, InputFile *f);
std::vector<Symbol *> getSymsWithPrefix(StringRef Prefix); std::vector<Symbol *> getSymsWithPrefix(StringRef prefix);
llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> SymMap; llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> symMap;
std::unique_ptr<BitcodeCompiler> LTO; std::unique_ptr<BitcodeCompiler> lto;
}; };
extern SymbolTable *Symtab; extern SymbolTable *symtab;
std::vector<std::string> getSymbolLocations(ObjFile *File, uint32_t SymIndex); std::vector<std::string> getSymbolLocations(ObjFile *file, uint32_t symIndex);
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/COFF/SymbolTable.cpp

Show All 20 Lines
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <utility> #include <utility>
using namespace llvm; using namespace llvm;
namespace lld { namespace lld {
namespace coff { namespace coff {
static Timer LTOTimer("LTO", Timer::root()); static Timer ltoTimer("LTO", Timer::root());
SymbolTable *Symtab; SymbolTable *symtab;
void SymbolTable::addFile(InputFile *File) { void SymbolTable::addFile(InputFile *file) {
log("Reading " + toString(File)); log("Reading " + toString(file));
File->parse(); file->parse();
MachineTypes MT = File->getMachineType(); MachineTypes mt = file->getMachineType();
if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) { if (config->machine == IMAGE_FILE_MACHINE_UNKNOWN) {
Config->Machine = MT; config->machine = mt;
} else if (MT != IMAGE_FILE_MACHINE_UNKNOWN && Config->Machine != MT) { } else if (mt != IMAGE_FILE_MACHINE_UNKNOWN && config->machine != mt) {
error(toString(File) + ": machine type " + machineToStr(MT) + error(toString(file) + ": machine type " + machineToStr(mt) +
" conflicts with " + machineToStr(Config->Machine)); " conflicts with " + machineToStr(config->machine));
return; return;
} }
if (auto *F = dyn_cast<ObjFile>(File)) { if (auto *f = dyn_cast<ObjFile>(file)) {
ObjFile::Instances.push_back(F); ObjFile::instances.push_back(f);
} else if (auto *F = dyn_cast<BitcodeFile>(File)) { } else if (auto *f = dyn_cast<BitcodeFile>(file)) {
BitcodeFile::Instances.push_back(F); BitcodeFile::instances.push_back(f);
} else if (auto *F = dyn_cast<ImportFile>(File)) { } else if (auto *f = dyn_cast<ImportFile>(file)) {
ImportFile::Instances.push_back(F); ImportFile::instances.push_back(f);
} }
Driver->parseDirectives(File); driver->parseDirectives(file);
} }
static void errorOrWarn(const Twine &S) { static void errorOrWarn(const Twine &s) {
if (Config->ForceUnresolved) if (config->forceUnresolved)
warn(S); warn(s);
else else
error(S); error(s);
} }
// Returns the symbol in SC whose value is <= Addr that is closest to Addr. // Returns the symbol in SC whose value is <= Addr that is closest to Addr.
// This is generally the global variable or function whose definition contains // This is generally the global variable or function whose definition contains
// Addr. // Addr.
static Symbol *getSymbol(SectionChunk *SC, uint32_t Addr) { static Symbol *getSymbol(SectionChunk *sc, uint32_t addr) {
DefinedRegular *Candidate = nullptr; DefinedRegular *candidate = nullptr;
for (Symbol *S : SC->File->getSymbols()) { for (Symbol *s : sc->file->getSymbols()) {
auto *D = dyn_cast_or_null<DefinedRegular>(S); auto *d = dyn_cast_or_null<DefinedRegular>(s);
if (!D || D->getChunk() != SC || D->getValue() > Addr || if (!d || d->getChunk() != sc || d->getValue() > addr ||
(Candidate && D->getValue() < Candidate->getValue())) (candidate && d->getValue() < candidate->getValue()))
continue; continue;
Candidate = D; candidate = d;
} }
return Candidate; return candidate;
} }
// Given a file and the index of a symbol in that file, returns a description // Given a file and the index of a symbol in that file, returns a description
// of all references to that symbol from that file. If no debug information is // of all references to that symbol from that file. If no debug information is
// available, returns just the name of the file, else one string per actual // available, returns just the name of the file, else one string per actual
// reference as described in the debug info. // reference as described in the debug info.
std::vector<std::string> getSymbolLocations(ObjFile *File, uint32_t SymIndex) { std::vector<std::string> getSymbolLocations(ObjFile *file, uint32_t symIndex) {
struct Location { struct Location {
Symbol *Sym; Symbol *sym;
std::pair<StringRef, uint32_t> FileLine; std::pair<StringRef, uint32_t> fileLine;
}; };
std::vector<Location> Locations; std::vector<Location> locations;
for (Chunk *C : File->getChunks()) { for (Chunk *c : file->getChunks()) {
auto *SC = dyn_cast<SectionChunk>(C); auto *sc = dyn_cast<SectionChunk>(c);
if (!SC) if (!sc)
continue; continue;
for (const coff_relocation &R : SC->getRelocs()) { for (const coff_relocation &r : sc->getRelocs()) {
if (R.SymbolTableIndex != SymIndex) if (r.SymbolTableIndex != symIndex)
continue; continue;
std::pair<StringRef, uint32_t> FileLine = std::pair<StringRef, uint32_t> fileLine =
getFileLine(SC, R.VirtualAddress); getFileLine(sc, r.VirtualAddress);
Symbol *Sym = getSymbol(SC, R.VirtualAddress); Symbol *sym = getSymbol(sc, r.VirtualAddress);
if (!FileLine.first.empty() || Sym) if (!fileLine.first.empty() || sym)
Locations.push_back({Sym, FileLine}); locations.push_back({sym, fileLine});
} }
} }
if (Locations.empty()) if (locations.empty())
return std::vector<std::string>({"\n>>> referenced by " + toString(File)}); return std::vector<std::string>({"\n>>> referenced by " + toString(file)});
std::vector<std::string> SymbolLocations(Locations.size()); std::vector<std::string> symbolLocations(locations.size());
size_t I = 0; size_t i = 0;
for (Location Loc : Locations) { for (Location loc : locations) {
llvm::raw_string_ostream OS(SymbolLocations[I++]); llvm::raw_string_ostream os(symbolLocations[i++]);
OS << "\n>>> referenced by "; os << "\n>>> referenced by ";
if (!Loc.FileLine.first.empty()) if (!loc.fileLine.first.empty())
OS << Loc.FileLine.first << ":" << Loc.FileLine.second os << loc.fileLine.first << ":" << loc.fileLine.second
<< "\n>>> "; << "\n>>> ";
OS << toString(File); os << toString(file);
if (Loc.Sym) if (loc.sym)
OS << ":(" << toString(*Loc.Sym) << ')'; os << ":(" << toString(*loc.sym) << ')';
} }
return SymbolLocations; return symbolLocations;
} }
// For an undefined symbol, stores all files referencing it and the index of // For an undefined symbol, stores all files referencing it and the index of
// the undefined symbol in each file. // the undefined symbol in each file.
struct UndefinedDiag { struct UndefinedDiag {
Symbol *Sym; Symbol *sym;
struct File { struct File {
ObjFile *OFile; ObjFile *oFile;
uint64_t SymIndex; uint64_t symIndex;
}; };
std::vector<File> Files; std::vector<File> files;
}; };
static void reportUndefinedSymbol(const UndefinedDiag &UndefDiag) { static void reportUndefinedSymbol(const UndefinedDiag &undefDiag) {
std::string Out; std::string out;
llvm::raw_string_ostream OS(Out); llvm::raw_string_ostream os(out);
OS << "undefined symbol: " << toString(*UndefDiag.Sym); os << "undefined symbol: " << toString(*undefDiag.sym);
const size_t MaxUndefReferences = 10; const size_t maxUndefReferences = 10;
size_t I = 0, NumRefs = 0; size_t i = 0, numRefs = 0;
for (const UndefinedDiag::File &Ref : UndefDiag.Files) { for (const UndefinedDiag::File &ref : undefDiag.files) {
std::vector<std::string> SymbolLocations = std::vector<std::string> symbolLocations =
getSymbolLocations(Ref.OFile, Ref.SymIndex); getSymbolLocations(ref.oFile, ref.symIndex);
NumRefs += SymbolLocations.size(); numRefs += symbolLocations.size();
for (const std::string &S : SymbolLocations) { for (const std::string &s : symbolLocations) {
if (I >= MaxUndefReferences) if (i >= maxUndefReferences)
break; break;
OS << S; os << s;
I++; i++;
} }
} }
if (I < NumRefs) if (i < numRefs)
OS << "\n>>> referenced " << NumRefs - I << " more times"; os << "\n>>> referenced " << numRefs - i << " more times";
errorOrWarn(OS.str()); errorOrWarn(os.str());
} }
void SymbolTable::loadMinGWAutomaticImports() { void SymbolTable::loadMinGWAutomaticImports() {
for (auto &I : SymMap) { for (auto &i : symMap) {
Symbol *Sym = I.second; Symbol *sym = i.second;
auto *Undef = dyn_cast<Undefined>(Sym); auto *undef = dyn_cast<Undefined>(sym);
if (!Undef) if (!undef)
continue; continue;
if (!Sym->IsUsedInRegularObj) if (!sym->isUsedInRegularObj)
continue; continue;
StringRef Name = Undef->getName(); StringRef name = undef->getName();
if (Name.startswith("__imp_")) if (name.startswith("__imp_"))
continue; continue;
// If we have an undefined symbol, but we have a Lazy representing a // If we have an undefined symbol, but we have a Lazy representing a
// symbol we could load from file, make sure to load that. // symbol we could load from file, make sure to load that.
Lazy *L = dyn_cast_or_null<Lazy>(find(("__imp_" + Name).str())); Lazy *l = dyn_cast_or_null<Lazy>(find(("__imp_" + name).str()));
if (!L || L->PendingArchiveLoad) if (!l || l->pendingArchiveLoad)
continue; continue;
log("Loading lazy " + L->getName() + " from " + L->File->getName() + log("Loading lazy " + l->getName() + " from " + l->file->getName() +
" for automatic import"); " for automatic import");
L->PendingArchiveLoad = true; l->pendingArchiveLoad = true;
L->File->addMember(&L->Sym); l->file->addMember(&l->sym);
} }
} }
bool SymbolTable::handleMinGWAutomaticImport(Symbol *Sym, StringRef Name) { bool SymbolTable::handleMinGWAutomaticImport(Symbol *sym, StringRef name) {
if (Name.startswith("__imp_")) if (name.startswith("__imp_"))
return false; return false;
Defined *Imp = dyn_cast_or_null<Defined>(find(("__imp_" + Name).str())); Defined *imp = dyn_cast_or_null<Defined>(find(("__imp_" + name).str()));
if (!Imp) if (!imp)
return false; return false;
// Replace the reference directly to a variable with a reference // Replace the reference directly to a variable with a reference
// to the import address table instead. This obviously isn't right, // to the import address table instead. This obviously isn't right,
// but we mark the symbol as IsRuntimePseudoReloc, and a later pass // but we mark the symbol as IsRuntimePseudoReloc, and a later pass
// will add runtime pseudo relocations for every relocation against // will add runtime pseudo relocations for every relocation against
// this Symbol. The runtime pseudo relocation framework expects the // this Symbol. The runtime pseudo relocation framework expects the
// reference itself to point at the IAT entry. // reference itself to point at the IAT entry.
size_t ImpSize = 0; size_t impSize = 0;
if (isa<DefinedImportData>(Imp)) { if (isa<DefinedImportData>(imp)) {
log("Automatically importing " + Name + " from " + log("Automatically importing " + name + " from " +
cast<DefinedImportData>(Imp)->getDLLName()); cast<DefinedImportData>(imp)->getDLLName());
ImpSize = sizeof(DefinedImportData); impSize = sizeof(DefinedImportData);
} else if (isa<DefinedRegular>(Imp)) { } else if (isa<DefinedRegular>(imp)) {
log("Automatically importing " + Name + " from " + log("Automatically importing " + name + " from " +
toString(cast<DefinedRegular>(Imp)->File)); toString(cast<DefinedRegular>(imp)->file));
ImpSize = sizeof(DefinedRegular); impSize = sizeof(DefinedRegular);
} else { } else {
warn("unable to automatically import " + Name + " from " + Imp->getName() + warn("unable to automatically import " + name + " from " + imp->getName() +
" from " + toString(cast<DefinedRegular>(Imp)->File) + " from " + toString(cast<DefinedRegular>(imp)->file) +
"; unexpected symbol type"); "; unexpected symbol type");
return false; return false;
} }
Sym->replaceKeepingName(Imp, ImpSize); sym->replaceKeepingName(imp, impSize);
Sym->IsRuntimePseudoReloc = true; sym->isRuntimePseudoReloc = true;
// There may exist symbols named .refptr.<name> which only consist // There may exist symbols named .refptr.<name> which only consist
// of a single pointer to <name>. If it turns out <name> is // of a single pointer to <name>. If it turns out <name> is
// automatically imported, we don't need to keep the .refptr.<name> // automatically imported, we don't need to keep the .refptr.<name>
// pointer at all, but redirect all accesses to it to the IAT entry // pointer at all, but redirect all accesses to it to the IAT entry
// for __imp_<name> instead, and drop the whole .refptr.<name> chunk. // for __imp_<name> instead, and drop the whole .refptr.<name> chunk.
DefinedRegular *Refptr = DefinedRegular *refptr =
dyn_cast_or_null<DefinedRegular>(find((".refptr." + Name).str())); dyn_cast_or_null<DefinedRegular>(find((".refptr." + name).str()));
if (Refptr && Refptr->getChunk()->getSize() == Config->Wordsize) { if (refptr && refptr->getChunk()->getSize() == config->wordsize) {
SectionChunk *SC = dyn_cast_or_null<SectionChunk>(Refptr->getChunk()); SectionChunk *sc = dyn_cast_or_null<SectionChunk>(refptr->getChunk());
if (SC && SC->getRelocs().size() == 1 && *SC->symbols().begin() == Sym) { if (sc && sc->getRelocs().size() == 1 && *sc->symbols().begin() == sym) {
log("Replacing .refptr." + Name + " with " + Imp->getName()); log("Replacing .refptr." + name + " with " + imp->getName());
Refptr->getChunk()->Live = false; refptr->getChunk()->live = false;
Refptr->replaceKeepingName(Imp, ImpSize); refptr->replaceKeepingName(imp, impSize);
} }
} }
return true; return true;
} }
void SymbolTable::reportRemainingUndefines() { void SymbolTable::reportRemainingUndefines() {
SmallPtrSet<Symbol *, 8> Undefs; SmallPtrSet<Symbol *, 8> undefs;
DenseMap<Symbol *, Symbol *> LocalImports; DenseMap<Symbol *, Symbol *> localImports;
for (auto &I : SymMap) { for (auto &i : symMap) {
Symbol *Sym = I.second; Symbol *sym = i.second;
auto *Undef = dyn_cast<Undefined>(Sym); auto *undef = dyn_cast<Undefined>(sym);
if (!Undef) if (!undef)
continue; continue;
if (!Sym->IsUsedInRegularObj) if (!sym->isUsedInRegularObj)
continue; continue;
StringRef Name = Undef->getName(); StringRef name = undef->getName();
// A weak alias may have been resolved, so check for that. // A weak alias may have been resolved, so check for that.
if (Defined *D = Undef->getWeakAlias()) { if (Defined *d = undef->getWeakAlias()) {
// We want to replace Sym with D. However, we can't just blindly // We want to replace Sym with D. However, we can't just blindly
// copy sizeof(SymbolUnion) bytes from D to Sym because D may be an // copy sizeof(SymbolUnion) bytes from D to Sym because D may be an
// internal symbol, and internal symbols are stored as "unparented" // internal symbol, and internal symbols are stored as "unparented"
// Symbols. For that reason we need to check which type of symbol we // Symbols. For that reason we need to check which type of symbol we
// are dealing with and copy the correct number of bytes. // are dealing with and copy the correct number of bytes.
if (isa<DefinedRegular>(D)) if (isa<DefinedRegular>(d))
memcpy(Sym, D, sizeof(DefinedRegular)); memcpy(sym, d, sizeof(DefinedRegular));
else if (isa<DefinedAbsolute>(D)) else if (isa<DefinedAbsolute>(d))
memcpy(Sym, D, sizeof(DefinedAbsolute)); memcpy(sym, d, sizeof(DefinedAbsolute));
else else
memcpy(Sym, D, sizeof(SymbolUnion)); memcpy(sym, d, sizeof(SymbolUnion));
continue; continue;
} }
// If we can resolve a symbol by removing __imp_ prefix, do that. // If we can resolve a symbol by removing __imp_ prefix, do that.
// This odd rule is for compatibility with MSVC linker. // This odd rule is for compatibility with MSVC linker.
if (Name.startswith("__imp_")) { if (name.startswith("__imp_")) {
Symbol *Imp = find(Name.substr(strlen("__imp_"))); Symbol *imp = find(name.substr(strlen("__imp_")));
if (Imp && isa<Defined>(Imp)) { if (imp && isa<Defined>(imp)) {
auto *D = cast<Defined>(Imp); auto *d = cast<Defined>(imp);
replaceSymbol<DefinedLocalImport>(Sym, Name, D); replaceSymbol<DefinedLocalImport>(sym, name, d);
LocalImportChunks.push_back(cast<DefinedLocalImport>(Sym)->getChunk()); localImportChunks.push_back(cast<DefinedLocalImport>(sym)->getChunk());
LocalImports[Sym] = D; localImports[sym] = d;
continue; continue;
} }
} }
// We don't want to report missing Microsoft precompiled headers symbols. // We don't want to report missing Microsoft precompiled headers symbols.
// A proper message will be emitted instead in PDBLinker::aquirePrecompObj // A proper message will be emitted instead in PDBLinker::aquirePrecompObj
if (Name.contains("_PchSym_")) if (name.contains("_PchSym_"))
continue; continue;
if (Config->MinGW && handleMinGWAutomaticImport(Sym, Name)) if (config->mingw && handleMinGWAutomaticImport(sym, name))
continue; continue;
// Remaining undefined symbols are not fatal if /force is specified. // Remaining undefined symbols are not fatal if /force is specified.
// They are replaced with dummy defined symbols. // They are replaced with dummy defined symbols.
if (Config->ForceUnresolved) if (config->forceUnresolved)
replaceSymbol<DefinedAbsolute>(Sym, Name, 0); replaceSymbol<DefinedAbsolute>(sym, name, 0);
Undefs.insert(Sym); undefs.insert(sym);
} }
if (Undefs.empty() && LocalImports.empty()) if (undefs.empty() && localImports.empty())
return; return;
for (Symbol *B : Config->GCRoot) { for (Symbol *b : config->gCRoot) {
if (Undefs.count(B)) if (undefs.count(b))
errorOrWarn("<root>: undefined symbol: " + toString(*B)); errorOrWarn("<root>: undefined symbol: " + toString(*b));
if (Config->WarnLocallyDefinedImported) if (config->warnLocallyDefinedImported)
if (Symbol *Imp = LocalImports.lookup(B)) if (Symbol *imp = localImports.lookup(b))
warn("<root>: locally defined symbol imported: " + toString(*Imp) + warn("<root>: locally defined symbol imported: " + toString(*imp) +
" (defined in " + toString(Imp->getFile()) + ") [LNK4217]"); " (defined in " + toString(imp->getFile()) + ") [LNK4217]");
} }
std::vector<UndefinedDiag> UndefDiags; std::vector<UndefinedDiag> undefDiags;
DenseMap<Symbol *, int> FirstDiag; DenseMap<Symbol *, int> firstDiag;
for (ObjFile *File : ObjFile::Instances) { for (ObjFile *file : ObjFile::instances) {
size_t SymIndex = (size_t)-1; size_t symIndex = (size_t)-1;
for (Symbol *Sym : File->getSymbols()) { for (Symbol *sym : file->getSymbols()) {
++SymIndex; ++symIndex;
if (!Sym) if (!sym)
continue; continue;
if (Undefs.count(Sym)) { if (undefs.count(sym)) {
auto it = FirstDiag.find(Sym); auto it = firstDiag.find(sym);
if (it == FirstDiag.end()) { if (it == firstDiag.end()) {
FirstDiag[Sym] = UndefDiags.size(); firstDiag[sym] = undefDiags.size();
UndefDiags.push_back({Sym, {{File, SymIndex}}}); undefDiags.push_back({sym, {{file, symIndex}}});
} else { } else {
UndefDiags[it->second].Files.push_back({File, SymIndex}); undefDiags[it->second].files.push_back({file, symIndex});
} }
} }
if (Config->WarnLocallyDefinedImported) if (config->warnLocallyDefinedImported)
if (Symbol *Imp = LocalImports.lookup(Sym)) if (Symbol *imp = localImports.lookup(sym))
warn(toString(File) + warn(toString(file) +
": locally defined symbol imported: " + toString(*Imp) + ": locally defined symbol imported: " + toString(*imp) +
" (defined in " + toString(Imp->getFile()) + ") [LNK4217]"); " (defined in " + toString(imp->getFile()) + ") [LNK4217]");
} }
} }
for (const UndefinedDiag& UndefDiag : UndefDiags) for (const UndefinedDiag& undefDiag : undefDiags)
reportUndefinedSymbol(UndefDiag); reportUndefinedSymbol(undefDiag);
} }
std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name) { std::pair<Symbol *, bool> SymbolTable::insert(StringRef name) {
bool Inserted = false; bool inserted = false;
Symbol *&Sym = SymMap[CachedHashStringRef(Name)]; Symbol *&sym = symMap[CachedHashStringRef(name)];
if (!Sym) { if (!sym) {
Sym = reinterpret_cast<Symbol *>(make<SymbolUnion>()); sym = reinterpret_cast<Symbol *>(make<SymbolUnion>());
Sym->IsUsedInRegularObj = false; sym->isUsedInRegularObj = false;
Sym->PendingArchiveLoad = false; sym->pendingArchiveLoad = false;
Inserted = true; inserted = true;
} }
return {Sym, Inserted}; return {sym, inserted};
} }
std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name, InputFile *File) { std::pair<Symbol *, bool> SymbolTable::insert(StringRef name, InputFile *file) {
std::pair<Symbol *, bool> Result = insert(Name); std::pair<Symbol *, bool> result = insert(name);
if (!File || !isa<BitcodeFile>(File)) if (!file || !isa<BitcodeFile>(file))
Result.first->IsUsedInRegularObj = true; result.first->isUsedInRegularObj = true;
return Result; return result;
} }
Symbol *SymbolTable::addUndefined(StringRef Name, InputFile *F, Symbol *SymbolTable::addUndefined(StringRef name, InputFile *f,
bool IsWeakAlias) { bool isWeakAlias) {
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(Name, F); std::tie(s, wasInserted) = insert(name, f);
if (WasInserted || (isa<Lazy>(S) && IsWeakAlias)) { if (wasInserted || (isa<Lazy>(s) && isWeakAlias)) {
replaceSymbol<Undefined>(S, Name); replaceSymbol<Undefined>(s, name);
return S; return s;
} }
if (auto *L = dyn_cast<Lazy>(S)) { if (auto *l = dyn_cast<Lazy>(s)) {
if (!S->PendingArchiveLoad) { if (!s->pendingArchiveLoad) {
S->PendingArchiveLoad = true; s->pendingArchiveLoad = true;
L->File->addMember(&L->Sym); l->file->addMember(&l->sym);
} }
} }
return S; return s;
} }
void SymbolTable::addLazy(ArchiveFile *F, const Archive::Symbol Sym) { void SymbolTable::addLazy(ArchiveFile *f, const Archive::Symbol sym) {
StringRef Name = Sym.getName(); StringRef name = sym.getName();
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(Name); std::tie(s, wasInserted) = insert(name);
if (WasInserted) { if (wasInserted) {
replaceSymbol<Lazy>(S, F, Sym); replaceSymbol<Lazy>(s, f, sym);
return; return;
} }
auto *U = dyn_cast<Undefined>(S); auto *u = dyn_cast<Undefined>(s);
if (!U || U->WeakAlias || S->PendingArchiveLoad) if (!u || u->weakAlias || s->pendingArchiveLoad)
return; return;
S->PendingArchiveLoad = true; s->pendingArchiveLoad = true;
F->addMember(&Sym); f->addMember(&sym);
} }
void SymbolTable::reportDuplicate(Symbol *Existing, InputFile *NewFile) { void SymbolTable::reportDuplicate(Symbol *existing, InputFile *newFile) {
std::string Msg = "duplicate symbol: " + toString(*Existing) + " in " + std::string msg = "duplicate symbol: " + toString(*existing) + " in " +
toString(Existing->getFile()) + " and in " + toString(existing->getFile()) + " and in " +
toString(NewFile); toString(newFile);
if (Config->ForceMultiple) if (config->forceMultiple)
warn(Msg); warn(msg);
else else
error(Msg); error(msg);
} }
Symbol *SymbolTable::addAbsolute(StringRef N, COFFSymbolRef Sym) { Symbol *SymbolTable::addAbsolute(StringRef n, COFFSymbolRef sym) {
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(N, nullptr); std::tie(s, wasInserted) = insert(n, nullptr);
S->IsUsedInRegularObj = true; s->isUsedInRegularObj = true;
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S)) if (wasInserted || isa<Undefined>(s) || isa<Lazy>(s))
replaceSymbol<DefinedAbsolute>(S, N, Sym); replaceSymbol<DefinedAbsolute>(s, n, sym);
else if (!isa<DefinedCOFF>(S)) else if (!isa<DefinedCOFF>(s))
reportDuplicate(S, nullptr); reportDuplicate(s, nullptr);
return S; return s;
} }
Symbol *SymbolTable::addAbsolute(StringRef N, uint64_t VA) { Symbol *SymbolTable::addAbsolute(StringRef n, uint64_t va) {
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(N, nullptr); std::tie(s, wasInserted) = insert(n, nullptr);
S->IsUsedInRegularObj = true; s->isUsedInRegularObj = true;
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S)) if (wasInserted || isa<Undefined>(s) || isa<Lazy>(s))
replaceSymbol<DefinedAbsolute>(S, N, VA); replaceSymbol<DefinedAbsolute>(s, n, va);
else if (!isa<DefinedCOFF>(S)) else if (!isa<DefinedCOFF>(s))
reportDuplicate(S, nullptr); reportDuplicate(s, nullptr);
return S; return s;
} }
Symbol *SymbolTable::addSynthetic(StringRef N, Chunk *C) { Symbol *SymbolTable::addSynthetic(StringRef n, Chunk *c) {
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(N, nullptr); std::tie(s, wasInserted) = insert(n, nullptr);
S->IsUsedInRegularObj = true; s->isUsedInRegularObj = true;
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S)) if (wasInserted || isa<Undefined>(s) || isa<Lazy>(s))
replaceSymbol<DefinedSynthetic>(S, N, C); replaceSymbol<DefinedSynthetic>(s, n, c);
else if (!isa<DefinedCOFF>(S)) else if (!isa<DefinedCOFF>(s))
reportDuplicate(S, nullptr); reportDuplicate(s, nullptr);
return S; return s;
} }
Symbol *SymbolTable::addRegular(InputFile *F, StringRef N, Symbol *SymbolTable::addRegular(InputFile *f, StringRef n,
const coff_symbol_generic *Sym, const coff_symbol_generic *sym,
SectionChunk *C) { SectionChunk *c) {
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(N, F); std::tie(s, wasInserted) = insert(n, f);
if (WasInserted || !isa<DefinedRegular>(S)) if (wasInserted || !isa<DefinedRegular>(s))
replaceSymbol<DefinedRegular>(S, F, N, /*IsCOMDAT*/ false, replaceSymbol<DefinedRegular>(s, f, n, /*IsCOMDAT*/ false,
/*IsExternal*/ true, Sym, C); /*IsExternal*/ true, sym, c);
else else
reportDuplicate(S, F); reportDuplicate(s, f);
return S; return s;
} }
std::pair<DefinedRegular *, bool> std::pair<DefinedRegular *, bool>
SymbolTable::addComdat(InputFile *F, StringRef N, SymbolTable::addComdat(InputFile *f, StringRef n,
const coff_symbol_generic *Sym) { const coff_symbol_generic *sym) {
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(N, F); std::tie(s, wasInserted) = insert(n, f);
if (WasInserted || !isa<DefinedRegular>(S)) { if (wasInserted || !isa<DefinedRegular>(s)) {
replaceSymbol<DefinedRegular>(S, F, N, /*IsCOMDAT*/ true, replaceSymbol<DefinedRegular>(s, f, n, /*IsCOMDAT*/ true,
/*IsExternal*/ true, Sym, nullptr); /*IsExternal*/ true, sym, nullptr);
return {cast<DefinedRegular>(S), true}; return {cast<DefinedRegular>(s), true};
} }
auto *ExistingSymbol = cast<DefinedRegular>(S); auto *existingSymbol = cast<DefinedRegular>(s);
if (!ExistingSymbol->IsCOMDAT) if (!existingSymbol->isCOMDAT)
reportDuplicate(S, F); reportDuplicate(s, f);
return {ExistingSymbol, false}; return {existingSymbol, false};
} }
Symbol *SymbolTable::addCommon(InputFile *F, StringRef N, uint64_t Size, Symbol *SymbolTable::addCommon(InputFile *f, StringRef n, uint64_t size,
const coff_symbol_generic *Sym, CommonChunk *C) { const coff_symbol_generic *sym, CommonChunk *c) {
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(N, F); std::tie(s, wasInserted) = insert(n, f);
if (WasInserted || !isa<DefinedCOFF>(S)) if (wasInserted || !isa<DefinedCOFF>(s))
replaceSymbol<DefinedCommon>(S, F, N, Size, Sym, C); replaceSymbol<DefinedCommon>(s, f, n, size, sym, c);
else if (auto *DC = dyn_cast<DefinedCommon>(S)) else if (auto *dc = dyn_cast<DefinedCommon>(s))
if (Size > DC->getSize()) if (size > dc->getSize())
replaceSymbol<DefinedCommon>(S, F, N, Size, Sym, C); replaceSymbol<DefinedCommon>(s, f, n, size, sym, c);
return S; return s;
} }
Symbol *SymbolTable::addImportData(StringRef N, ImportFile *F) { Symbol *SymbolTable::addImportData(StringRef n, ImportFile *f) {
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(N, nullptr); std::tie(s, wasInserted) = insert(n, nullptr);
S->IsUsedInRegularObj = true; s->isUsedInRegularObj = true;
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S)) { if (wasInserted || isa<Undefined>(s) || isa<Lazy>(s)) {
replaceSymbol<DefinedImportData>(S, N, F); replaceSymbol<DefinedImportData>(s, n, f);
return S; return s;
} }
reportDuplicate(S, F); reportDuplicate(s, f);
return nullptr; return nullptr;
} }
Symbol *SymbolTable::addImportThunk(StringRef Name, DefinedImportData *ID, Symbol *SymbolTable::addImportThunk(StringRef name, DefinedImportData *id,
uint16_t Machine) { uint16_t machine) {
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(Name, nullptr); std::tie(s, wasInserted) = insert(name, nullptr);
S->IsUsedInRegularObj = true; s->isUsedInRegularObj = true;
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S)) { if (wasInserted || isa<Undefined>(s) || isa<Lazy>(s)) {
replaceSymbol<DefinedImportThunk>(S, Name, ID, Machine); replaceSymbol<DefinedImportThunk>(s, name, id, machine);
return S; return s;
} }
reportDuplicate(S, ID->File); reportDuplicate(s, id->file);
return nullptr; return nullptr;
} }
std::vector<Chunk *> SymbolTable::getChunks() { std::vector<Chunk *> SymbolTable::getChunks() {
std::vector<Chunk *> Res; std::vector<Chunk *> res;
for (ObjFile *File : ObjFile::Instances) { for (ObjFile *file : ObjFile::instances) {
ArrayRef<Chunk *> V = File->getChunks(); ArrayRef<Chunk *> v = file->getChunks();
Res.insert(Res.end(), V.begin(), V.end()); res.insert(res.end(), v.begin(), v.end());
} }
return Res; return res;
} }
Symbol *SymbolTable::find(StringRef Name) { Symbol *SymbolTable::find(StringRef name) {
return SymMap.lookup(CachedHashStringRef(Name)); return symMap.lookup(CachedHashStringRef(name));
} }
Symbol *SymbolTable::findUnderscore(StringRef Name) { Symbol *SymbolTable::findUnderscore(StringRef name) {
if (Config->Machine == I386) if (config->machine == I386)
return find(("_" + Name).str()); return find(("_" + name).str());
return find(Name); return find(name);
} }
// Return all symbols that start with Prefix, possibly ignoring the first // Return all symbols that start with Prefix, possibly ignoring the first
// character of Prefix or the first character symbol. // character of Prefix or the first character symbol.
std::vector<Symbol *> SymbolTable::getSymsWithPrefix(StringRef Prefix) { std::vector<Symbol *> SymbolTable::getSymsWithPrefix(StringRef prefix) {
std::vector<Symbol *> Syms; std::vector<Symbol *> syms;
for (auto Pair : SymMap) { for (auto pair : symMap) {
StringRef Name = Pair.first.val(); StringRef name = pair.first.val();
if (Name.startswith(Prefix) || Name.startswith(Prefix.drop_front()) || if (name.startswith(prefix) || name.startswith(prefix.drop_front()) ||
Name.drop_front().startswith(Prefix) || name.drop_front().startswith(prefix) ||
Name.drop_front().startswith(Prefix.drop_front())) { name.drop_front().startswith(prefix.drop_front())) {
Syms.push_back(Pair.second); syms.push_back(pair.second);
} }
} }
return Syms; return syms;
} }
Symbol *SymbolTable::findMangle(StringRef Name) { Symbol *SymbolTable::findMangle(StringRef name) {
if (Symbol *Sym = find(Name)) if (Symbol *sym = find(name))
if (!isa<Undefined>(Sym)) if (!isa<Undefined>(sym))
return Sym; return sym;
// Efficient fuzzy string lookup is impossible with a hash table, so iterate // Efficient fuzzy string lookup is impossible with a hash table, so iterate
// the symbol table once and collect all possibly matching symbols into this // the symbol table once and collect all possibly matching symbols into this
// vector. Then compare each possibly matching symbol with each possible // vector. Then compare each possibly matching symbol with each possible
// mangling. // mangling.
std::vector<Symbol *> Syms = getSymsWithPrefix(Name); std::vector<Symbol *> syms = getSymsWithPrefix(name);
auto FindByPrefix = [&Syms](const Twine &T) -> Symbol * { auto findByPrefix = [&syms](const Twine &t) -> Symbol * {
std::string Prefix = T.str(); std::string prefix = t.str();
for (auto *S : Syms) for (auto *s : syms)
if (S->getName().startswith(Prefix)) if (s->getName().startswith(prefix))
return S; return s;
return nullptr; return nullptr;
}; };
// For non-x86, just look for C++ functions. // For non-x86, just look for C++ functions.
if (Config->Machine != I386) if (config->machine != I386)
return FindByPrefix("?" + Name + "@@Y"); return findByPrefix("?" + name + "@@Y");
if (!Name.startswith("_")) if (!name.startswith("_"))
return nullptr; return nullptr;
// Search for x86 stdcall function. // Search for x86 stdcall function.
if (Symbol *S = FindByPrefix(Name + "@")) if (Symbol *s = findByPrefix(name + "@"))
return S; return s;
// Search for x86 fastcall function. // Search for x86 fastcall function.
if (Symbol *S = FindByPrefix("@" + Name.substr(1) + "@")) if (Symbol *s = findByPrefix("@" + name.substr(1) + "@"))
return S; return s;
// Search for x86 vectorcall function. // Search for x86 vectorcall function.
if (Symbol *S = FindByPrefix(Name.substr(1) + "@@")) if (Symbol *s = findByPrefix(name.substr(1) + "@@"))
return S; return s;
// Search for x86 C++ non-member function. // Search for x86 C++ non-member function.
return FindByPrefix("?" + Name.substr(1) + "@@Y"); return findByPrefix("?" + name.substr(1) + "@@Y");
} }
Symbol *SymbolTable::addUndefined(StringRef Name) { Symbol *SymbolTable::addUndefined(StringRef name) {
return addUndefined(Name, nullptr, false); return addUndefined(name, nullptr, false);
} }
std::vector<StringRef> SymbolTable::compileBitcodeFiles() { std::vector<StringRef> SymbolTable::compileBitcodeFiles() {
LTO.reset(new BitcodeCompiler); lto.reset(new BitcodeCompiler);
for (BitcodeFile *F : BitcodeFile::Instances) for (BitcodeFile *f : BitcodeFile::instances)
LTO->add(*F); lto->add(*f);
return LTO->compile(); return lto->compile();
} }
void SymbolTable::addCombinedLTOObjects() { void SymbolTable::addCombinedLTOObjects() {
if (BitcodeFile::Instances.empty()) if (BitcodeFile::instances.empty())
return; return;
ScopedTimer T(LTOTimer); ScopedTimer t(ltoTimer);
for (StringRef Object : compileBitcodeFiles()) { for (StringRef object : compileBitcodeFiles()) {
auto *Obj = make<ObjFile>(MemoryBufferRef(Object, "lto.tmp")); auto *obj = make<ObjFile>(MemoryBufferRef(object, "lto.tmp"));
Obj->parse(); obj->parse();
ObjFile::Instances.push_back(Obj); ObjFile::instances.push_back(obj);
} }
} }
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld

lld/trunk/COFF/Symbols.h

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines enum Kind {
UndefinedKind, UndefinedKind,
LazyKind, LazyKind,
LastDefinedCOFFKind = DefinedCommonKind, LastDefinedCOFFKind = DefinedCommonKind,
LastDefinedKind = DefinedSyntheticKind, LastDefinedKind = DefinedSyntheticKind,
}; };
Kind kind() const { return static_cast<Kind>(SymbolKind); } Kind kind() const { return static_cast<Kind>(symbolKind); }
// Returns the symbol name. // Returns the symbol name.
StringRef getName(); StringRef getName();
void replaceKeepingName(Symbol *Other, size_t Size); void replaceKeepingName(Symbol *other, size_t size);
// Returns the file from which this symbol was created. // Returns the file from which this symbol was created.
InputFile *getFile(); InputFile *getFile();
// Indicates that this symbol will be included in the final image. Only valid // Indicates that this symbol will be included in the final image. Only valid
// after calling markLive. // after calling markLive.
bool isLive() const; bool isLive() const;
protected: protected:
friend SymbolTable; friend SymbolTable;
explicit Symbol(Kind K, StringRef N = "") explicit Symbol(Kind k, StringRef n = "")
: SymbolKind(K), IsExternal(true), IsCOMDAT(false), : symbolKind(k), isExternal(true), isCOMDAT(false),
WrittenToSymtab(false), PendingArchiveLoad(false), IsGCRoot(false), writtenToSymtab(false), pendingArchiveLoad(false), isGCRoot(false),
IsRuntimePseudoReloc(false), NameSize(N.size()), isRuntimePseudoReloc(false), nameSize(n.size()),
NameData(N.empty() ? nullptr : N.data()) {} nameData(n.empty() ? nullptr : n.data()) {}
const unsigned SymbolKind : 8; const unsigned symbolKind : 8;
unsigned IsExternal : 1; unsigned isExternal : 1;
public: public:
// This bit is used by the \c DefinedRegular subclass. // This bit is used by the \c DefinedRegular subclass.
unsigned IsCOMDAT : 1; unsigned isCOMDAT : 1;
// This bit is used by Writer::createSymbolAndStringTable() to prevent // This bit is used by Writer::createSymbolAndStringTable() to prevent
// symbols from being written to the symbol table more than once. // symbols from being written to the symbol table more than once.
unsigned WrittenToSymtab : 1; unsigned writtenToSymtab : 1;
// True if this symbol was referenced by a regular (non-bitcode) object. // True if this symbol was referenced by a regular (non-bitcode) object.
unsigned IsUsedInRegularObj : 1; unsigned isUsedInRegularObj : 1;
// True if we've seen both a lazy and an undefined symbol with this symbol // True if we've seen both a lazy and an undefined symbol with this symbol
// name, which means that we have enqueued an archive member load and should // name, which means that we have enqueued an archive member load and should
// not load any more archive members to resolve the same symbol. // not load any more archive members to resolve the same symbol.
unsigned PendingArchiveLoad : 1; unsigned pendingArchiveLoad : 1;
/// True if we've already added this symbol to the list of GC roots. /// True if we've already added this symbol to the list of GC roots.
unsigned IsGCRoot : 1; unsigned isGCRoot : 1;
unsigned IsRuntimePseudoReloc : 1; unsigned isRuntimePseudoReloc : 1;
protected: protected:
// Symbol name length. Assume symbol lengths fit in a 32-bit integer. // Symbol name length. Assume symbol lengths fit in a 32-bit integer.
uint32_t NameSize; uint32_t nameSize;
const char *NameData; const char *nameData;
}; };
// The base class for any defined symbols, including absolute symbols, // The base class for any defined symbols, including absolute symbols,
// etc. // etc.
class Defined : public Symbol { class Defined : public Symbol {
public: public:
Defined(Kind K, StringRef N) : Symbol(K, N) {} Defined(Kind k, StringRef n) : Symbol(k, n) {}
static bool classof(const Symbol *S) { return S->kind() <= LastDefinedKind; } static bool classof(const Symbol *s) { return s->kind() <= LastDefinedKind; }
// Returns the RVA (relative virtual address) of this symbol. The // Returns the RVA (relative virtual address) of this symbol. The
// writer sets and uses RVAs. // writer sets and uses RVAs.
uint64_t getRVA(); uint64_t getRVA();
// Returns the chunk containing this symbol. Absolute symbols and __ImageBase // Returns the chunk containing this symbol. Absolute symbols and __ImageBase
// do not have chunks, so this may return null. // do not have chunks, so this may return null.
Chunk *getChunk(); Chunk *getChunk();
}; };
// Symbols defined via a COFF object file or bitcode file. For COFF files, this // Symbols defined via a COFF object file or bitcode file. For COFF files, this
// stores a coff_symbol_generic*, and names of internal symbols are lazily // stores a coff_symbol_generic*, and names of internal symbols are lazily
// loaded through that. For bitcode files, Sym is nullptr and the name is stored // loaded through that. For bitcode files, Sym is nullptr and the name is stored
// as a decomposed StringRef. // as a decomposed StringRef.
class DefinedCOFF : public Defined { class DefinedCOFF : public Defined {
friend Symbol; friend Symbol;
public: public:
DefinedCOFF(Kind K, InputFile *F, StringRef N, const coff_symbol_generic *S) DefinedCOFF(Kind k, InputFile *f, StringRef n, const coff_symbol_generic *s)
: Defined(K, N), File(F), Sym(S) {} : Defined(k, n), file(f), sym(s) {}
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() <= LastDefinedCOFFKind; return s->kind() <= LastDefinedCOFFKind;
} }
InputFile *getFile() { return File; } InputFile *getFile() { return file; }
COFFSymbolRef getCOFFSymbol(); COFFSymbolRef getCOFFSymbol();
InputFile *File; InputFile *file;
protected: protected:
const coff_symbol_generic *Sym; const coff_symbol_generic *sym;
}; };
// Regular defined symbols read from object file symbol tables. // Regular defined symbols read from object file symbol tables.
class DefinedRegular : public DefinedCOFF { class DefinedRegular : public DefinedCOFF {
public: public:
DefinedRegular(InputFile *F, StringRef N, bool IsCOMDAT, DefinedRegular(InputFile *f, StringRef n, bool isCOMDAT,
bool IsExternal = false, bool isExternal = false,
const coff_symbol_generic *S = nullptr, const coff_symbol_generic *s = nullptr,
SectionChunk *C = nullptr) SectionChunk *c = nullptr)
: DefinedCOFF(DefinedRegularKind, F, N, S), Data(C ? &C->Repl : nullptr) { : DefinedCOFF(DefinedRegularKind, f, n, s), data(c ? &c->repl : nullptr) {
this->IsExternal = IsExternal; this->isExternal = isExternal;
this->IsCOMDAT = IsCOMDAT; this->isCOMDAT = isCOMDAT;
} }
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == DefinedRegularKind; return s->kind() == DefinedRegularKind;
} }
uint64_t getRVA() const { return (*Data)->getRVA() + Sym->Value; } uint64_t getRVA() const { return (*data)->getRVA() + sym->Value; }
SectionChunk *getChunk() const { return *Data; } SectionChunk *getChunk() const { return *data; }
uint32_t getValue() const { return Sym->Value; } uint32_t getValue() const { return sym->Value; }
SectionChunk **Data; SectionChunk **data;
}; };
class DefinedCommon : public DefinedCOFF { class DefinedCommon : public DefinedCOFF {
public: public:
DefinedCommon(InputFile *F, StringRef N, uint64_t Size, DefinedCommon(InputFile *f, StringRef n, uint64_t size,
const coff_symbol_generic *S = nullptr, const coff_symbol_generic *s = nullptr,
CommonChunk *C = nullptr) CommonChunk *c = nullptr)
: DefinedCOFF(DefinedCommonKind, F, N, S), Data(C), Size(Size) { : DefinedCOFF(DefinedCommonKind, f, n, s), data(c), size(size) {
this->IsExternal = true; this->isExternal = true;
} }
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == DefinedCommonKind; return s->kind() == DefinedCommonKind;
} }
uint64_t getRVA() { return Data->getRVA(); } uint64_t getRVA() { return data->getRVA(); }
CommonChunk *getChunk() { return Data; } CommonChunk *getChunk() { return data; }
private: private:
friend SymbolTable; friend SymbolTable;
uint64_t getSize() const { return Size; } uint64_t getSize() const { return size; }
CommonChunk *Data; CommonChunk *data;
uint64_t Size; uint64_t size;
}; };
// Absolute symbols. // Absolute symbols.
class DefinedAbsolute : public Defined { class DefinedAbsolute : public Defined {
public: public:
DefinedAbsolute(StringRef N, COFFSymbolRef S) DefinedAbsolute(StringRef n, COFFSymbolRef s)
: Defined(DefinedAbsoluteKind, N), VA(S.getValue()) { : Defined(DefinedAbsoluteKind, n), va(s.getValue()) {
IsExternal = S.isExternal(); isExternal = s.isExternal();
} }
DefinedAbsolute(StringRef N, uint64_t V) DefinedAbsolute(StringRef n, uint64_t v)
: Defined(DefinedAbsoluteKind, N), VA(V) {} : Defined(DefinedAbsoluteKind, n), va(v) {}
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == DefinedAbsoluteKind; return s->kind() == DefinedAbsoluteKind;
} }
uint64_t getRVA() { return VA - Config->ImageBase; } uint64_t getRVA() { return va - config->imageBase; }
void setVA(uint64_t V) { VA = V; } void setVA(uint64_t v) { va = v; }
// Section index relocations against absolute symbols resolve to // Section index relocations against absolute symbols resolve to
// this 16 bit number, and it is the largest valid section index // this 16 bit number, and it is the largest valid section index
// plus one. This variable keeps it. // plus one. This variable keeps it.
static uint16_t NumOutputSections; static uint16_t numOutputSections;
private: private:
uint64_t VA; uint64_t va;
}; };
// This symbol is used for linker-synthesized symbols like __ImageBase and // This symbol is used for linker-synthesized symbols like __ImageBase and
// __safe_se_handler_table. // __safe_se_handler_table.
class DefinedSynthetic : public Defined { class DefinedSynthetic : public Defined {
public: public:
explicit DefinedSynthetic(StringRef Name, Chunk *C) explicit DefinedSynthetic(StringRef name, Chunk *c)
: Defined(DefinedSyntheticKind, Name), C(C) {} : Defined(DefinedSyntheticKind, name), c(c) {}
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == DefinedSyntheticKind; return s->kind() == DefinedSyntheticKind;
} }
// A null chunk indicates that this is __ImageBase. Otherwise, this is some // A null chunk indicates that this is __ImageBase. Otherwise, this is some
// other synthesized chunk, like SEHTableChunk. // other synthesized chunk, like SEHTableChunk.
uint32_t getRVA() { return C ? C->getRVA() : 0; } uint32_t getRVA() { return c ? c->getRVA() : 0; }
Chunk *getChunk() { return C; } Chunk *getChunk() { return c; }
private: private:
Chunk *C; Chunk *c;
}; };
// This class represents a symbol defined in an archive file. It is // This class represents a symbol defined in an archive file. It is
// created from an archive file header, and it knows how to load an // created from an archive file header, and it knows how to load an
// object file from an archive to replace itself with a defined // object file from an archive to replace itself with a defined
// symbol. If the resolver finds both Undefined and Lazy for // symbol. If the resolver finds both Undefined and Lazy for
// the same name, it will ask the Lazy to load a file. // the same name, it will ask the Lazy to load a file.
class Lazy : public Symbol { class Lazy : public Symbol {
public: public:
Lazy(ArchiveFile *F, const Archive::Symbol S) Lazy(ArchiveFile *f, const Archive::Symbol s)
: Symbol(LazyKind, S.getName()), File(F), Sym(S) {} : Symbol(LazyKind, s.getName()), file(f), sym(s) {}
static bool classof(const Symbol *S) { return S->kind() == LazyKind; } static bool classof(const Symbol *s) { return s->kind() == LazyKind; }
ArchiveFile *File; ArchiveFile *file;
private: private:
friend SymbolTable; friend SymbolTable;
private: private:
const Archive::Symbol Sym; const Archive::Symbol sym;
}; };
// Undefined symbols. // Undefined symbols.
class Undefined : public Symbol { class Undefined : public Symbol {
public: public:
explicit Undefined(StringRef N) : Symbol(UndefinedKind, N) {} explicit Undefined(StringRef n) : Symbol(UndefinedKind, n) {}
static bool classof(const Symbol *S) { return S->kind() == UndefinedKind; } static bool classof(const Symbol *s) { return s->kind() == UndefinedKind; }
// An undefined symbol can have a fallback symbol which gives an // An undefined symbol can have a fallback symbol which gives an
// undefined symbol a second chance if it would remain undefined. // undefined symbol a second chance if it would remain undefined.
// If it remains undefined, it'll be replaced with whatever the // If it remains undefined, it'll be replaced with whatever the
// Alias pointer points to. // Alias pointer points to.
Symbol *WeakAlias = nullptr; Symbol *weakAlias = nullptr;
// If this symbol is external weak, try to resolve it to a defined // If this symbol is external weak, try to resolve it to a defined
// symbol by searching the chain of fallback symbols. Returns the symbol if // symbol by searching the chain of fallback symbols. Returns the symbol if
// successful, otherwise returns null. // successful, otherwise returns null.
Defined *getWeakAlias(); Defined *getWeakAlias();
}; };
// Windows-specific classes. // Windows-specific classes.
// This class represents a symbol imported from a DLL. This has two // This class represents a symbol imported from a DLL. This has two
// names for internal use and external use. The former is used for // names for internal use and external use. The former is used for
// name resolution, and the latter is used for the import descriptor // name resolution, and the latter is used for the import descriptor
// table in an output. The former has "__imp_" prefix. // table in an output. The former has "__imp_" prefix.
class DefinedImportData : public Defined { class DefinedImportData : public Defined {
public: public:
DefinedImportData(StringRef N, ImportFile *F) DefinedImportData(StringRef n, ImportFile *f)
: Defined(DefinedImportDataKind, N), File(F) { : Defined(DefinedImportDataKind, n), file(f) {
} }
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == DefinedImportDataKind; return s->kind() == DefinedImportDataKind;
} }
uint64_t getRVA() { return File->Location->getRVA(); } uint64_t getRVA() { return file->location->getRVA(); }
Chunk *getChunk() { return File->Location; } Chunk *getChunk() { return file->location; }
void setLocation(Chunk *AddressTable) { File->Location = AddressTable; } void setLocation(Chunk *addressTable) { file->location = addressTable; }
StringRef getDLLName() { return File->DLLName; } StringRef getDLLName() { return file->dllName; }
StringRef getExternalName() { return File->ExternalName; } StringRef getExternalName() { return file->externalName; }
uint16_t getOrdinal() { return File->Hdr->OrdinalHint; } uint16_t getOrdinal() { return file->hdr->OrdinalHint; }
ImportFile *File; ImportFile *file;
}; };
// This class represents a symbol for a jump table entry which jumps // This class represents a symbol for a jump table entry which jumps
// to a function in a DLL. Linker are supposed to create such symbols // to a function in a DLL. Linker are supposed to create such symbols
// without "__imp_" prefix for all function symbols exported from // without "__imp_" prefix for all function symbols exported from
// DLLs, so that you can call DLL functions as regular functions with // DLLs, so that you can call DLL functions as regular functions with
// a regular name. A function pointer is given as a DefinedImportData. // a regular name. A function pointer is given as a DefinedImportData.
class DefinedImportThunk : public Defined { class DefinedImportThunk : public Defined {
public: public:
DefinedImportThunk(StringRef Name, DefinedImportData *S, uint16_t Machine); DefinedImportThunk(StringRef name, DefinedImportData *s, uint16_t machine);
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == DefinedImportThunkKind; return s->kind() == DefinedImportThunkKind;
} }
uint64_t getRVA() { return Data->getRVA(); } uint64_t getRVA() { return data->getRVA(); }
Chunk *getChunk() { return Data; } Chunk *getChunk() { return data; }
DefinedImportData *WrappedSym; DefinedImportData *wrappedSym;
private: private:
Chunk *Data; Chunk *data;
}; };
// If you have a symbol "foo" in your object file, a symbol name // If you have a symbol "foo" in your object file, a symbol name
// "__imp_foo" becomes automatically available as a pointer to "foo". // "__imp_foo" becomes automatically available as a pointer to "foo".
// This class is for such automatically-created symbols. // This class is for such automatically-created symbols.
// Yes, this is an odd feature. We didn't intend to implement that. // Yes, this is an odd feature. We didn't intend to implement that.
// This is here just for compatibility with MSVC. // This is here just for compatibility with MSVC.
class DefinedLocalImport : public Defined { class DefinedLocalImport : public Defined {
public: public:
DefinedLocalImport(StringRef N, Defined *S) DefinedLocalImport(StringRef n, Defined *s)
: Defined(DefinedLocalImportKind, N), Data(make<LocalImportChunk>(S)) {} : Defined(DefinedLocalImportKind, n), data(make<LocalImportChunk>(s)) {}
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == DefinedLocalImportKind; return s->kind() == DefinedLocalImportKind;
} }
uint64_t getRVA() { return Data->getRVA(); } uint64_t getRVA() { return data->getRVA(); }
Chunk *getChunk() { return Data; } Chunk *getChunk() { return data; }
private: private:
LocalImportChunk *Data; LocalImportChunk *data;
}; };
inline uint64_t Defined::getRVA() { inline uint64_t Defined::getRVA() {
switch (kind()) { switch (kind()) {
case DefinedAbsoluteKind: case DefinedAbsoluteKind:
return cast<DefinedAbsolute>(this)->getRVA(); return cast<DefinedAbsolute>(this)->getRVA();
case DefinedSyntheticKind: case DefinedSyntheticKind:
return cast<DefinedSynthetic>(this)->getRVA(); return cast<DefinedSynthetic>(this)->getRVA();
Show All 36 Linesinline Chunk *Defined::getChunk() {
} }
llvm_unreachable("unknown symbol kind"); llvm_unreachable("unknown symbol kind");
} }
// A buffer class that is large enough to hold any Symbol-derived // A buffer class that is large enough to hold any Symbol-derived
// object. We allocate memory using this class and instantiate a symbol // object. We allocate memory using this class and instantiate a symbol
// using the placement new. // using the placement new.
union SymbolUnion { union SymbolUnion {
alignas(DefinedRegular) char A[sizeof(DefinedRegular)]; alignas(DefinedRegular) char a[sizeof(DefinedRegular)];
alignas(DefinedCommon) char B[sizeof(DefinedCommon)]; alignas(DefinedCommon) char b[sizeof(DefinedCommon)];
alignas(DefinedAbsolute) char C[sizeof(DefinedAbsolute)]; alignas(DefinedAbsolute) char c[sizeof(DefinedAbsolute)];
alignas(DefinedSynthetic) char D[sizeof(DefinedSynthetic)]; alignas(DefinedSynthetic) char d[sizeof(DefinedSynthetic)];
alignas(Lazy) char E[sizeof(Lazy)]; alignas(Lazy) char e[sizeof(Lazy)];
alignas(Undefined) char F[sizeof(Undefined)]; alignas(Undefined) char f[sizeof(Undefined)];
alignas(DefinedImportData) char G[sizeof(DefinedImportData)]; alignas(DefinedImportData) char g[sizeof(DefinedImportData)];
alignas(DefinedImportThunk) char H[sizeof(DefinedImportThunk)]; alignas(DefinedImportThunk) char h[sizeof(DefinedImportThunk)];
alignas(DefinedLocalImport) char I[sizeof(DefinedLocalImport)]; alignas(DefinedLocalImport) char i[sizeof(DefinedLocalImport)];
}; };
template <typename T, typename... ArgT> template <typename T, typename... ArgT>
void replaceSymbol(Symbol *S, ArgT &&... Arg) { void replaceSymbol(Symbol *s, ArgT &&... arg) {
static_assert(std::is_trivially_destructible<T>(), static_assert(std::is_trivially_destructible<T>(),
"Symbol types must be trivially destructible"); "Symbol types must be trivially destructible");
static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small"); static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small");
static_assert(alignof(T) <= alignof(SymbolUnion), static_assert(alignof(T) <= alignof(SymbolUnion),
"SymbolUnion not aligned enough"); "SymbolUnion not aligned enough");
assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr && assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr &&
"Not a Symbol"); "Not a Symbol");
new (S) T(std::forward<ArgT>(Arg)...); new (s) T(std::forward<ArgT>(arg)...);
} }
} // namespace coff } // namespace coff
std::string toString(coff::Symbol &B); std::string toString(coff::Symbol &b);
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/COFF/Symbols.cpp

Show All 18 Lines
using namespace llvm::object; using namespace llvm::object;
using namespace lld::coff; using namespace lld::coff;
static_assert(sizeof(SymbolUnion) <= 48, static_assert(sizeof(SymbolUnion) <= 48,
"symbols should be optimized for memory usage"); "symbols should be optimized for memory usage");
// Returns a symbol name for an error message. // Returns a symbol name for an error message.
std::string lld::toString(coff::Symbol &B) { std::string lld::toString(coff::Symbol &b) {
if (Config->Demangle) if (config->demangle)
if (Optional<std::string> S = lld::demangleMSVC(B.getName())) if (Optional<std::string> s = lld::demangleMSVC(b.getName()))
return *S; return *s;
return B.getName(); return b.getName();
} }
namespace lld { namespace lld {
namespace coff { namespace coff {
StringRef Symbol::getName() { StringRef Symbol::getName() {
// COFF symbol names are read lazily for a performance reason. // COFF symbol names are read lazily for a performance reason.
// Non-external symbol names are never used by the linker except for logging // Non-external symbol names are never used by the linker except for logging
// or debugging. Their internal references are resolved not by name but by // or debugging. Their internal references are resolved not by name but by
// symbol index. And because they are not external, no one can refer them by // symbol index. And because they are not external, no one can refer them by
// name. Object files contain lots of non-external symbols, and creating // name. Object files contain lots of non-external symbols, and creating
// StringRefs for them (which involves lots of strlen() on the string table) // StringRefs for them (which involves lots of strlen() on the string table)
// is a waste of time. // is a waste of time.
if (NameData == nullptr) { if (nameData == nullptr) {
auto *D = cast<DefinedCOFF>(this); auto *d = cast<DefinedCOFF>(this);
StringRef NameStr; StringRef nameStr;
cast<ObjFile>(D->File)->getCOFFObj()->getSymbolName(D->Sym, NameStr); cast<ObjFile>(d->file)->getCOFFObj()->getSymbolName(d->sym, nameStr);
NameData = NameStr.data(); nameData = nameStr.data();
NameSize = NameStr.size(); nameSize = nameStr.size();
assert(NameSize == NameStr.size() && "name length truncated"); assert(nameSize == nameStr.size() && "name length truncated");
} }
return StringRef(NameData, NameSize); return StringRef(nameData, nameSize);
} }
InputFile *Symbol::getFile() { InputFile *Symbol::getFile() {
if (auto *Sym = dyn_cast<DefinedCOFF>(this)) if (auto *sym = dyn_cast<DefinedCOFF>(this))
return Sym->File; return sym->file;
if (auto *Sym = dyn_cast<Lazy>(this)) if (auto *sym = dyn_cast<Lazy>(this))
return Sym->File; return sym->file;
return nullptr; return nullptr;
} }
bool Symbol::isLive() const { bool Symbol::isLive() const {
if (auto *R = dyn_cast<DefinedRegular>(this)) if (auto *r = dyn_cast<DefinedRegular>(this))
return R->getChunk()->Live; return r->getChunk()->live;
if (auto *Imp = dyn_cast<DefinedImportData>(this)) if (auto *imp = dyn_cast<DefinedImportData>(this))
return Imp->File->Live; return imp->file->live;
if (auto *Imp = dyn_cast<DefinedImportThunk>(this)) if (auto *imp = dyn_cast<DefinedImportThunk>(this))
return Imp->WrappedSym->File->ThunkLive; return imp->wrappedSym->file->thunkLive;
// Assume any other kind of symbol is live. // Assume any other kind of symbol is live.
return true; return true;
} }
// MinGW specific. // MinGW specific.
void Symbol::replaceKeepingName(Symbol *Other, size_t Size) { void Symbol::replaceKeepingName(Symbol *other, size_t size) {
StringRef OrigName = getName(); StringRef origName = getName();
memcpy(this, Other, Size); memcpy(this, other, size);
NameData = OrigName.data(); nameData = origName.data();
NameSize = OrigName.size(); nameSize = origName.size();
} }
COFFSymbolRef DefinedCOFF::getCOFFSymbol() { COFFSymbolRef DefinedCOFF::getCOFFSymbol() {
size_t SymSize = cast<ObjFile>(File)->getCOFFObj()->getSymbolTableEntrySize(); size_t symSize = cast<ObjFile>(file)->getCOFFObj()->getSymbolTableEntrySize();
if (SymSize == sizeof(coff_symbol16)) if (symSize == sizeof(coff_symbol16))
return COFFSymbolRef(reinterpret_cast<const coff_symbol16 *>(Sym)); return COFFSymbolRef(reinterpret_cast<const coff_symbol16 *>(sym));
assert(SymSize == sizeof(coff_symbol32)); assert(symSize == sizeof(coff_symbol32));
return COFFSymbolRef(reinterpret_cast<const coff_symbol32 *>(Sym)); return COFFSymbolRef(reinterpret_cast<const coff_symbol32 *>(sym));
} }
uint16_t DefinedAbsolute::NumOutputSections; uint16_t DefinedAbsolute::numOutputSections;
static Chunk *makeImportThunk(DefinedImportData *S, uint16_t Machine) { static Chunk *makeImportThunk(DefinedImportData *s, uint16_t machine) {
if (Machine == AMD64) if (machine == AMD64)
return make<ImportThunkChunkX64>(S); return make<ImportThunkChunkX64>(s);
if (Machine == I386) if (machine == I386)
return make<ImportThunkChunkX86>(S); return make<ImportThunkChunkX86>(s);
if (Machine == ARM64) if (machine == ARM64)
return make<ImportThunkChunkARM64>(S); return make<ImportThunkChunkARM64>(s);
assert(Machine == ARMNT); assert(machine == ARMNT);
return make<ImportThunkChunkARM>(S); return make<ImportThunkChunkARM>(s);
} }
DefinedImportThunk::DefinedImportThunk(StringRef Name, DefinedImportData *S, DefinedImportThunk::DefinedImportThunk(StringRef name, DefinedImportData *s,
uint16_t Machine) uint16_t machine)
: Defined(DefinedImportThunkKind, Name), WrappedSym(S), : Defined(DefinedImportThunkKind, name), wrappedSym(s),
Data(makeImportThunk(S, Machine)) {} data(makeImportThunk(s, machine)) {}
Defined *Undefined::getWeakAlias() { Defined *Undefined::getWeakAlias() {
// A weak alias may be a weak alias to another symbol, so check recursively. // A weak alias may be a weak alias to another symbol, so check recursively.
for (Symbol *A = WeakAlias; A; A = cast<Undefined>(A)->WeakAlias) for (Symbol *a = weakAlias; a; a = cast<Undefined>(a)->weakAlias)
if (auto *D = dyn_cast<Defined>(A)) if (auto *d = dyn_cast<Defined>(a))
return D; return d;
return nullptr; return nullptr;
} }
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld

lld/trunk/COFF/TypeMerger.h

Show All 13 Lines
#include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h" #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
#include "llvm/Support/Allocator.h" #include "llvm/Support/Allocator.h"
namespace lld { namespace lld {
namespace coff { namespace coff {
class TypeMerger { class TypeMerger {
public: public:
TypeMerger(llvm::BumpPtrAllocator &Alloc) TypeMerger(llvm::BumpPtrAllocator &alloc)
: TypeTable(Alloc), IDTable(Alloc), GlobalTypeTable(Alloc), : typeTable(alloc), iDTable(alloc), globalTypeTable(alloc),
GlobalIDTable(Alloc) {} globalIDTable(alloc) {}
/// Get the type table or the global type table if /DEBUG:GHASH is enabled. /// Get the type table or the global type table if /DEBUG:GHASH is enabled.
inline llvm::codeview::TypeCollection &getTypeTable() { inline llvm::codeview::TypeCollection &getTypeTable() {
if (Config->DebugGHashes) if (config->debugGHashes)
return GlobalTypeTable; return globalTypeTable;
return TypeTable; return typeTable;
} }
/// Get the ID table or the global ID table if /DEBUG:GHASH is enabled. /// Get the ID table or the global ID table if /DEBUG:GHASH is enabled.
inline llvm::codeview::TypeCollection &getIDTable() { inline llvm::codeview::TypeCollection &getIDTable() {
if (Config->DebugGHashes) if (config->debugGHashes)
return GlobalIDTable; return globalIDTable;
return IDTable; return iDTable;
} }
/// Type records that will go into the PDB TPI stream. /// Type records that will go into the PDB TPI stream.
llvm::codeview::MergingTypeTableBuilder TypeTable; llvm::codeview::MergingTypeTableBuilder typeTable;
/// Item records that will go into the PDB IPI stream. /// Item records that will go into the PDB IPI stream.
llvm::codeview::MergingTypeTableBuilder IDTable; llvm::codeview::MergingTypeTableBuilder iDTable;
/// Type records that will go into the PDB TPI stream (for /DEBUG:GHASH) /// Type records that will go into the PDB TPI stream (for /DEBUG:GHASH)
llvm::codeview::GlobalTypeTableBuilder GlobalTypeTable; llvm::codeview::GlobalTypeTableBuilder globalTypeTable;
/// Item records that will go into the PDB IPI stream (for /DEBUG:GHASH) /// Item records that will go into the PDB IPI stream (for /DEBUG:GHASH)
llvm::codeview::GlobalTypeTableBuilder GlobalIDTable; llvm::codeview::GlobalTypeTableBuilder globalIDTable;
}; };
/// Map from type index and item index in a type server PDB to the /// Map from type index and item index in a type server PDB to the
/// corresponding index in the destination PDB. /// corresponding index in the destination PDB.
struct CVIndexMap { struct CVIndexMap {
llvm::SmallVector<llvm::codeview::TypeIndex, 0> TPIMap; llvm::SmallVector<llvm::codeview::TypeIndex, 0> tpiMap;
llvm::SmallVector<llvm::codeview::TypeIndex, 0> IPIMap; llvm::SmallVector<llvm::codeview::TypeIndex, 0> ipiMap;
bool IsTypeServerMap = false; bool isTypeServerMap = false;
bool IsPrecompiledTypeMap = false; bool isPrecompiledTypeMap = false;
}; };
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
#endif #endif
No newline at end of file No newline at end of file

lld/trunk/COFF/Writer.h

Show All 12 Lines
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Object/COFF.h" #include "llvm/Object/COFF.h"
#include <chrono> #include <chrono>
#include <cstdint> #include <cstdint>
#include <vector> #include <vector>
namespace lld { namespace lld {
namespace coff { namespace coff {
static const int PageSize = 4096; static const int pageSize = 4096;
void writeResult(); void writeResult();
class PartialSection { class PartialSection {
public: public:
PartialSection(StringRef N, uint32_t Chars) PartialSection(StringRef n, uint32_t chars)
: Name(N), Characteristics(Chars) {} : name(n), characteristics(chars) {}
StringRef Name; StringRef name;
unsigned Characteristics; unsigned characteristics;
std::vector<Chunk *> Chunks; std::vector<Chunk *> chunks;
}; };
// OutputSection represents a section in an output file. It's a // OutputSection represents a section in an output file. It's a
// container of chunks. OutputSection and Chunk are 1:N relationship. // container of chunks. OutputSection and Chunk are 1:N relationship.
// Chunks cannot belong to more than one OutputSections. The writer // Chunks cannot belong to more than one OutputSections. The writer
// creates multiple OutputSections and assign them unique, // creates multiple OutputSections and assign them unique,
// non-overlapping file offsets and RVAs. // non-overlapping file offsets and RVAs.
class OutputSection { class OutputSection {
public: public:
OutputSection(llvm::StringRef N, uint32_t Chars) : Name(N) { OutputSection(llvm::StringRef n, uint32_t chars) : name(n) {
Header.Characteristics = Chars; header.Characteristics = chars;
} }
void addChunk(Chunk *C); void addChunk(Chunk *c);
void insertChunkAtStart(Chunk *C); void insertChunkAtStart(Chunk *c);
void merge(OutputSection *Other); void merge(OutputSection *other);
void setPermissions(uint32_t C); void setPermissions(uint32_t c);
uint64_t getRVA() { return Header.VirtualAddress; } uint64_t getRVA() { return header.VirtualAddress; }
uint64_t getFileOff() { return Header.PointerToRawData; } uint64_t getFileOff() { return header.PointerToRawData; }
void writeHeaderTo(uint8_t *Buf); void writeHeaderTo(uint8_t *buf);
void addContributingPartialSection(PartialSection *Sec); void addContributingPartialSection(PartialSection *sec);
// Returns the size of this section in an executable memory image. // Returns the size of this section in an executable memory image.
// This may be smaller than the raw size (the raw size is multiple // This may be smaller than the raw size (the raw size is multiple
// of disk sector size, so there may be padding at end), or may be // of disk sector size, so there may be padding at end), or may be
// larger (if that's the case, the loader reserves spaces after end // larger (if that's the case, the loader reserves spaces after end
// of raw data). // of raw data).
uint64_t getVirtualSize() { return Header.VirtualSize; } uint64_t getVirtualSize() { return header.VirtualSize; }
// Returns the size of the section in the output file. // Returns the size of the section in the output file.
uint64_t getRawSize() { return Header.SizeOfRawData; } uint64_t getRawSize() { return header.SizeOfRawData; }
// Set offset into the string table storing this section name. // Set offset into the string table storing this section name.
// Used only when the name is longer than 8 bytes. // Used only when the name is longer than 8 bytes.
void setStringTableOff(uint32_t V) { StringTableOff = V; } void setStringTableOff(uint32_t v) { stringTableOff = v; }
// N.B. The section index is one based. // N.B. The section index is one based.
uint32_t SectionIndex = 0; uint32_t sectionIndex = 0;
llvm::StringRef Name; llvm::StringRef name;
llvm::object::coff_section Header = {}; llvm::object::coff_section header = {};
std::vector<Chunk *> Chunks; std::vector<Chunk *> chunks;
std::vector<Chunk *> OrigChunks; std::vector<Chunk *> origChunks;
std::vector<PartialSection *> ContribSections; std::vector<PartialSection *> contribSections;
private: private:
uint32_t StringTableOff = 0; uint32_t stringTableOff = 0;
}; };
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/COFF/Writer.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Linesorg 0
mov ax, 0x4C01 mov ax, 0x4C01
int 0x21 int 0x21
str: str:
db 'This program cannot be run in DOS mode.$' db 'This program cannot be run in DOS mode.$'
align 8, db 0 align 8, db 0
$ nasm -fbin /tmp/DOSProgram.asm -o /tmp/DOSProgram.bin $ nasm -fbin /tmp/DOSProgram.asm -o /tmp/DOSProgram.bin
$ xxd -i /tmp/DOSProgram.bin $ xxd -i /tmp/DOSProgram.bin
*/ */
static unsigned char DOSProgram[] = { static unsigned char dosProgram[] = {
0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd, 0x21, 0xb8, 0x01, 0x4c, 0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd, 0x21, 0xb8, 0x01, 0x4c,
0xcd, 0x21, 0x54, 0x68, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72, 0xcd, 0x21, 0x54, 0x68, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72,
0x61, 0x6d, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x61, 0x6d, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65,
0x20, 0x72, 0x75, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x44, 0x4f, 0x53, 0x20, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x44, 0x4f, 0x53, 0x20,
0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x24, 0x00, 0x00 0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x24, 0x00, 0x00
}; };
static_assert(sizeof(DOSProgram) % 8 == 0, static_assert(sizeof(dosProgram) % 8 == 0,
"DOSProgram size must be multiple of 8"); "DOSProgram size must be multiple of 8");
static const int DOSStubSize = sizeof(dos_header) + sizeof(DOSProgram); static const int dosStubSize = sizeof(dos_header) + sizeof(dosProgram);
static_assert(DOSStubSize % 8 == 0, "DOSStub size must be multiple of 8"); static_assert(dosStubSize % 8 == 0, "DOSStub size must be multiple of 8");
static const int NumberOfDataDirectory = 16; static const int numberOfDataDirectory = 16;
// Global vector of all output sections. After output sections are finalized, // Global vector of all output sections. After output sections are finalized,
// this can be indexed by Chunk::getOutputSection. // this can be indexed by Chunk::getOutputSection.
static std::vector<OutputSection *> OutputSections; static std::vector<OutputSection *> outputSections;
OutputSection *Chunk::getOutputSection() const { OutputSection *Chunk::getOutputSection() const {
return OSIdx == 0 ? nullptr : OutputSections[OSIdx - 1]; return osidx == 0 ? nullptr : outputSections[osidx - 1];
} }
namespace { namespace {
class DebugDirectoryChunk : public NonSectionChunk { class DebugDirectoryChunk : public NonSectionChunk {
public: public:
DebugDirectoryChunk(const std::vector<Chunk *> &R, bool WriteRepro) DebugDirectoryChunk(const std::vector<Chunk *> &r, bool writeRepro)
: Records(R), WriteRepro(WriteRepro) {} : records(r), writeRepro(writeRepro) {}
size_t getSize() const override { size_t getSize() const override {
return (Records.size() + int(WriteRepro)) * sizeof(debug_directory); return (records.size() + int(writeRepro)) * sizeof(debug_directory);
} }
void writeTo(uint8_t *B) const override { void writeTo(uint8_t *b) const override {
auto *D = reinterpret_cast<debug_directory *>(B); auto *d = reinterpret_cast<debug_directory *>(b);
for (const Chunk *Record : Records) { for (const Chunk *record : records) {
OutputSection *OS = Record->getOutputSection(); OutputSection *os = record->getOutputSection();
uint64_t Offs = OS->getFileOff() + (Record->getRVA() - OS->getRVA()); uint64_t offs = os->getFileOff() + (record->getRVA() - os->getRVA());
fillEntry(D, COFF::IMAGE_DEBUG_TYPE_CODEVIEW, Record->getSize(), fillEntry(d, COFF::IMAGE_DEBUG_TYPE_CODEVIEW, record->getSize(),
Record->getRVA(), Offs); record->getRVA(), offs);
++D; ++d;
} }
if (WriteRepro) { if (writeRepro) {
// FIXME: The COFF spec allows either a 0-sized entry to just say // FIXME: The COFF spec allows either a 0-sized entry to just say
// "the timestamp field is really a hash", or a 4-byte size field // "the timestamp field is really a hash", or a 4-byte size field
// followed by that many bytes containing a longer hash (with the // followed by that many bytes containing a longer hash (with the
// lowest 4 bytes usually being the timestamp in little-endian order). // lowest 4 bytes usually being the timestamp in little-endian order).
// Consider storing the full 8 bytes computed by xxHash64 here. // Consider storing the full 8 bytes computed by xxHash64 here.
fillEntry(D, COFF::IMAGE_DEBUG_TYPE_REPRO, 0, 0, 0); fillEntry(d, COFF::IMAGE_DEBUG_TYPE_REPRO, 0, 0, 0);
} }
} }
void setTimeDateStamp(uint32_t TimeDateStamp) { void setTimeDateStamp(uint32_t timeDateStamp) {
for (support::ulittle32_t *TDS : TimeDateStamps) for (support::ulittle32_t *tds : timeDateStamps)
*TDS = TimeDateStamp; *tds = timeDateStamp;
} }
private: private:
void fillEntry(debug_directory *D, COFF::DebugType DebugType, size_t Size, void fillEntry(debug_directory *d, COFF::DebugType debugType, size_t size,
uint64_t RVA, uint64_t Offs) const { uint64_t rva, uint64_t offs) const {
D->Characteristics = 0; d->Characteristics = 0;
D->TimeDateStamp = 0; d->TimeDateStamp = 0;
D->MajorVersion = 0; d->MajorVersion = 0;
D->MinorVersion = 0; d->MinorVersion = 0;
D->Type = DebugType; d->Type = debugType;
D->SizeOfData = Size; d->SizeOfData = size;
D->AddressOfRawData = RVA; d->AddressOfRawData = rva;
D->PointerToRawData = Offs; d->PointerToRawData = offs;
TimeDateStamps.push_back(&D->TimeDateStamp); timeDateStamps.push_back(&d->TimeDateStamp);
} }
mutable std::vector<support::ulittle32_t *> TimeDateStamps; mutable std::vector<support::ulittle32_t *> timeDateStamps;
const std::vector<Chunk *> &Records; const std::vector<Chunk *> &records;
bool WriteRepro; bool writeRepro;
}; };
class CVDebugRecordChunk : public NonSectionChunk { class CVDebugRecordChunk : public NonSectionChunk {
public: public:
size_t getSize() const override { size_t getSize() const override {
return sizeof(codeview::DebugInfo) + Config->PDBAltPath.size() + 1; return sizeof(codeview::DebugInfo) + config->pdbAltPath.size() + 1;
} }
void writeTo(uint8_t *B) const override { void writeTo(uint8_t *b) const override {
// Save off the DebugInfo entry to backfill the file signature (build id) // Save off the DebugInfo entry to backfill the file signature (build id)
// in Writer::writeBuildId // in Writer::writeBuildId
BuildId = reinterpret_cast<codeview::DebugInfo *>(B); buildId = reinterpret_cast<codeview::DebugInfo *>(b);
// variable sized field (PDB Path) // variable sized field (PDB Path)
char *P = reinterpret_cast<char *>(B + sizeof(*BuildId)); char *p = reinterpret_cast<char *>(b + sizeof(*buildId));
if (!Config->PDBAltPath.empty()) if (!config->pdbAltPath.empty())
memcpy(P, Config->PDBAltPath.data(), Config->PDBAltPath.size()); memcpy(p, config->pdbAltPath.data(), config->pdbAltPath.size());
P[Config->PDBAltPath.size()] = '\0'; p[config->pdbAltPath.size()] = '\0';
} }
mutable codeview::DebugInfo *BuildId = nullptr; mutable codeview::DebugInfo *buildId = nullptr;
}; };
// PartialSection represents a group of chunks that contribute to an // PartialSection represents a group of chunks that contribute to an
// OutputSection. Collating a collection of PartialSections of same name and // OutputSection. Collating a collection of PartialSections of same name and
// characteristics constitutes the OutputSection. // characteristics constitutes the OutputSection.
class PartialSectionKey { class PartialSectionKey {
public: public:
StringRef Name; StringRef name;
unsigned Characteristics; unsigned characteristics;
bool operator<(const PartialSectionKey &Other) const { bool operator<(const PartialSectionKey &other) const {
int C = Name.compare(Other.Name); int c = name.compare(other.name);
if (C == 1) if (c == 1)
return false; return false;
if (C == 0) if (c == 0)
return Characteristics < Other.Characteristics; return characteristics < other.characteristics;
return true; return true;
} }
}; };
// The writer writes a SymbolTable result to a file. // The writer writes a SymbolTable result to a file.
class Writer { class Writer {
public: public:
Writer() : Buffer(errorHandler().OutputBuffer) {} Writer() : buffer(errorHandler().outputBuffer) {}
void run(); void run();
private: private:
void createSections(); void createSections();
void createMiscChunks(); void createMiscChunks();
void createImportTables(); void createImportTables();
void appendImportThunks(); void appendImportThunks();
void locateImportTables(); void locateImportTables();
void createExportTable(); void createExportTable();
void mergeSections(); void mergeSections();
void removeUnusedSections(); void removeUnusedSections();
void assignAddresses(); void assignAddresses();
void finalizeAddresses(); void finalizeAddresses();
void removeEmptySections(); void removeEmptySections();
void assignOutputSectionIndices(); void assignOutputSectionIndices();
void createSymbolAndStringTable(); void createSymbolAndStringTable();
void openFile(StringRef OutputPath); void openFile(StringRef outputPath);
template <typename PEHeaderTy> void writeHeader(); template <typename PEHeaderTy> void writeHeader();
void createSEHTable(); void createSEHTable();
void createRuntimePseudoRelocs(); void createRuntimePseudoRelocs();
void insertCtorDtorSymbols(); void insertCtorDtorSymbols();
void createGuardCFTables(); void createGuardCFTables();
void markSymbolsForRVATable(ObjFile *File, void markSymbolsForRVATable(ObjFile *file,
ArrayRef<SectionChunk *> SymIdxChunks, ArrayRef<SectionChunk *> symIdxChunks,
SymbolRVASet &TableSymbols); SymbolRVASet &tableSymbols);
void maybeAddRVATable(SymbolRVASet TableSymbols, StringRef TableSym, void maybeAddRVATable(SymbolRVASet tableSymbols, StringRef tableSym,
StringRef CountSym); StringRef countSym);
void setSectionPermissions(); void setSectionPermissions();
void writeSections(); void writeSections();
void writeBuildId(); void writeBuildId();
void sortExceptionTable(); void sortExceptionTable();
void sortCRTSectionChunks(std::vector<Chunk *> &Chunks); void sortCRTSectionChunks(std::vector<Chunk *> &chunks);
void addSyntheticIdata(); void addSyntheticIdata();
void fixPartialSectionChars(StringRef Name, uint32_t Chars); void fixPartialSectionChars(StringRef name, uint32_t chars);
bool fixGnuImportChunks(); bool fixGnuImportChunks();
PartialSection *createPartialSection(StringRef Name, uint32_t OutChars); PartialSection *createPartialSection(StringRef name, uint32_t outChars);
PartialSection *findPartialSection(StringRef Name, uint32_t OutChars); PartialSection *findPartialSection(StringRef name, uint32_t outChars);
llvm::Optional<coff_symbol16> createSymbol(Defined *D); llvm::Optional<coff_symbol16> createSymbol(Defined *d);
size_t addEntryToStringTable(StringRef Str); size_t addEntryToStringTable(StringRef str);
OutputSection *findSection(StringRef Name); OutputSection *findSection(StringRef name);
void addBaserels(); void addBaserels();
void addBaserelBlocks(std::vector<Baserel> &V); void addBaserelBlocks(std::vector<Baserel> &v);
uint32_t getSizeOfInitializedData(); uint32_t getSizeOfInitializedData();
std::unique_ptr<FileOutputBuffer> &Buffer; std::unique_ptr<FileOutputBuffer> &buffer;
std::map<PartialSectionKey, PartialSection *> PartialSections; std::map<PartialSectionKey, PartialSection *> partialSections;
std::vector<char> Strtab; std::vector<char> strtab;
std::vector<llvm::object::coff_symbol16> OutputSymtab; std::vector<llvm::object::coff_symbol16> outputSymtab;
IdataContents Idata; IdataContents idata;
Chunk *ImportTableStart = nullptr; Chunk *importTableStart = nullptr;
uint64_t ImportTableSize = 0; uint64_t importTableSize = 0;
Chunk *IATStart = nullptr; Chunk *iatStart = nullptr;
uint64_t IATSize = 0; uint64_t iatSize = 0;
DelayLoadContents DelayIdata; DelayLoadContents delayIdata;
EdataContents Edata; EdataContents edata;
bool SetNoSEHCharacteristic = false; bool setNoSEHCharacteristic = false;
DebugDirectoryChunk *DebugDirectory = nullptr; DebugDirectoryChunk *debugDirectory = nullptr;
std::vector<Chunk *> DebugRecords; std::vector<Chunk *> debugRecords;
CVDebugRecordChunk *BuildId = nullptr; CVDebugRecordChunk *buildId = nullptr;
ArrayRef<uint8_t> SectionTable; ArrayRef<uint8_t> sectionTable;
uint64_t FileSize; uint64_t fileSize;
uint32_t PointerToSymbolTable = 0; uint32_t pointerToSymbolTable = 0;
uint64_t SizeOfImage; uint64_t sizeOfImage;
uint64_t SizeOfHeaders; uint64_t sizeOfHeaders;
OutputSection *TextSec; OutputSection *textSec;
OutputSection *RdataSec; OutputSection *rdataSec;
OutputSection *BuildidSec; OutputSection *buildidSec;
OutputSection *DataSec; OutputSection *dataSec;
OutputSection *PdataSec; OutputSection *pdataSec;
OutputSection *IdataSec; OutputSection *idataSec;
OutputSection *EdataSec; OutputSection *edataSec;
OutputSection *DidatSec; OutputSection *didatSec;
OutputSection *RsrcSec; OutputSection *rsrcSec;
OutputSection *RelocSec; OutputSection *relocSec;
OutputSection *CtorsSec; OutputSection *ctorsSec;
OutputSection *DtorsSec; OutputSection *dtorsSec;
// The first and last .pdata sections in the output file. // The first and last .pdata sections in the output file.
// //
// We need to keep track of the location of .pdata in whichever section it // We need to keep track of the location of .pdata in whichever section it
// gets merged into so that we can sort its contents and emit a correct data // gets merged into so that we can sort its contents and emit a correct data
// directory entry for the exception table. This is also the case for some // directory entry for the exception table. This is also the case for some
// other sections (such as .edata) but because the contents of those sections // other sections (such as .edata) but because the contents of those sections
// are entirely linker-generated we can keep track of their locations using // are entirely linker-generated we can keep track of their locations using
// the chunks that the linker creates. All .pdata chunks come from input // the chunks that the linker creates. All .pdata chunks come from input
// files, so we need to keep track of them separately. // files, so we need to keep track of them separately.
Chunk *FirstPdata = nullptr; Chunk *firstPdata = nullptr;
Chunk *LastPdata; Chunk *lastPdata;
}; };
} // anonymous namespace } // anonymous namespace
namespace lld { namespace lld {
namespace coff { namespace coff {
static Timer CodeLayoutTimer("Code Layout", Timer::root()); static Timer codeLayoutTimer("Code Layout", Timer::root());
static Timer DiskCommitTimer("Commit Output File", Timer::root()); static Timer diskCommitTimer("Commit Output File", Timer::root());
void writeResult() { Writer().run(); } void writeResult() { Writer().run(); }
void OutputSection::addChunk(Chunk *C) { void OutputSection::addChunk(Chunk *c) {
Chunks.push_back(C); chunks.push_back(c);
} }
void OutputSection::insertChunkAtStart(Chunk *C) { void OutputSection::insertChunkAtStart(Chunk *c) {
Chunks.insert(Chunks.begin(), C); chunks.insert(chunks.begin(), c);
} }
void OutputSection::setPermissions(uint32_t C) { void OutputSection::setPermissions(uint32_t c) {
Header.Characteristics &= ~PermMask; header.Characteristics &= ~permMask;
Header.Characteristics |= C; header.Characteristics |= c;
} }
void OutputSection::merge(OutputSection *Other) { void OutputSection::merge(OutputSection *other) {
Chunks.insert(Chunks.end(), Other->Chunks.begin(), Other->Chunks.end()); chunks.insert(chunks.end(), other->chunks.begin(), other->chunks.end());
Other->Chunks.clear(); other->chunks.clear();
ContribSections.insert(ContribSections.end(), Other->ContribSections.begin(), contribSections.insert(contribSections.end(), other->contribSections.begin(),
Other->ContribSections.end()); other->contribSections.end());
Other->ContribSections.clear(); other->contribSections.clear();
} }
// Write the section header to a given buffer. // Write the section header to a given buffer.
void OutputSection::writeHeaderTo(uint8_t *Buf) { void OutputSection::writeHeaderTo(uint8_t *buf) {
auto *Hdr = reinterpret_cast<coff_section *>(Buf); auto *hdr = reinterpret_cast<coff_section *>(buf);
*Hdr = Header; *hdr = header;
if (StringTableOff) { if (stringTableOff) {
// If name is too long, write offset into the string table as a name. // If name is too long, write offset into the string table as a name.
sprintf(Hdr->Name, "/%d", StringTableOff); sprintf(hdr->Name, "/%d", stringTableOff);
} else { } else {
assert(!Config->Debug || Name.size() <= COFF::NameSize || assert(!config->debug || name.size() <= COFF::NameSize ||
(Hdr->Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0); (hdr->Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0);
strncpy(Hdr->Name, Name.data(), strncpy(hdr->Name, name.data(),
std::min(Name.size(), (size_t)COFF::NameSize)); std::min(name.size(), (size_t)COFF::NameSize));
} }
} }
void OutputSection::addContributingPartialSection(PartialSection *Sec) { void OutputSection::addContributingPartialSection(PartialSection *sec) {
ContribSections.push_back(Sec); contribSections.push_back(sec);
} }
} // namespace coff } // namespace coff
} // namespace lld } // namespace lld
// Check whether the target address S is in range from a relocation // Check whether the target address S is in range from a relocation
// of type RelType at address P. // of type RelType at address P.
static bool isInRange(uint16_t RelType, uint64_t S, uint64_t P, int Margin) { static bool isInRange(uint16_t relType, uint64_t s, uint64_t p, int margin) {
if (Config->Machine == ARMNT) { if (config->machine == ARMNT) {
int64_t Diff = AbsoluteDifference(S, P + 4) + Margin; int64_t diff = AbsoluteDifference(s, p + 4) + margin;
switch (RelType) { switch (relType) {
case IMAGE_REL_ARM_BRANCH20T: case IMAGE_REL_ARM_BRANCH20T:
return isInt<21>(Diff); return isInt<21>(diff);
case IMAGE_REL_ARM_BRANCH24T: case IMAGE_REL_ARM_BRANCH24T:
case IMAGE_REL_ARM_BLX23T: case IMAGE_REL_ARM_BLX23T:
return isInt<25>(Diff); return isInt<25>(diff);
default: default:
return true; return true;
} }
} else if (Config->Machine == ARM64) { } else if (config->machine == ARM64) {
int64_t Diff = AbsoluteDifference(S, P) + Margin; int64_t diff = AbsoluteDifference(s, p) + margin;
switch (RelType) { switch (relType) {
case IMAGE_REL_ARM64_BRANCH26: case IMAGE_REL_ARM64_BRANCH26:
return isInt<28>(Diff); return isInt<28>(diff);
case IMAGE_REL_ARM64_BRANCH19: case IMAGE_REL_ARM64_BRANCH19:
return isInt<21>(Diff); return isInt<21>(diff);
case IMAGE_REL_ARM64_BRANCH14: case IMAGE_REL_ARM64_BRANCH14:
return isInt<16>(Diff); return isInt<16>(diff);
default: default:
return true; return true;
} }
} else { } else {
llvm_unreachable("Unexpected architecture"); llvm_unreachable("Unexpected architecture");
} }
} }
// Return the last thunk for the given target if it is in range, // Return the last thunk for the given target if it is in range,
// or create a new one. // or create a new one.
static std::pair<Defined *, bool> static std::pair<Defined *, bool>
getThunk(DenseMap<uint64_t, Defined *> &LastThunks, Defined *Target, uint64_t P, getThunk(DenseMap<uint64_t, Defined *> &lastThunks, Defined *target, uint64_t p,
uint16_t Type, int Margin) { uint16_t type, int margin) {
Defined *&LastThunk = LastThunks[Target->getRVA()]; Defined *&lastThunk = lastThunks[target->getRVA()];
if (LastThunk && isInRange(Type, LastThunk->getRVA(), P, Margin)) if (lastThunk && isInRange(type, lastThunk->getRVA(), p, margin))
return {LastThunk, false}; return {lastThunk, false};
Chunk *C; Chunk *c;
switch (Config->Machine) { switch (config->machine) {
case ARMNT: case ARMNT:
C = make<RangeExtensionThunkARM>(Target); c = make<RangeExtensionThunkARM>(target);
break; break;
case ARM64: case ARM64:
C = make<RangeExtensionThunkARM64>(Target); c = make<RangeExtensionThunkARM64>(target);
break; break;
default: default:
llvm_unreachable("Unexpected architecture"); llvm_unreachable("Unexpected architecture");
} }
Defined *D = make<DefinedSynthetic>("", C); Defined *d = make<DefinedSynthetic>("", c);
LastThunk = D; lastThunk = d;
return {D, true}; return {d, true};
} }
// This checks all relocations, and for any relocation which isn't in range // This checks all relocations, and for any relocation which isn't in range
// it adds a thunk after the section chunk that contains the relocation. // it adds a thunk after the section chunk that contains the relocation.
// If the latest thunk for the specific target is in range, that is used // If the latest thunk for the specific target is in range, that is used
// instead of creating a new thunk. All range checks are done with the // instead of creating a new thunk. All range checks are done with the
// specified margin, to make sure that relocations that originally are in // specified margin, to make sure that relocations that originally are in
// range, but only barely, also get thunks - in case other added thunks makes // range, but only barely, also get thunks - in case other added thunks makes
// the target go out of range. // the target go out of range.
// //
// After adding thunks, we verify that all relocations are in range (with // After adding thunks, we verify that all relocations are in range (with
// no extra margin requirements). If this failed, we restart (throwing away // no extra margin requirements). If this failed, we restart (throwing away
// the previously created thunks) and retry with a wider margin. // the previously created thunks) and retry with a wider margin.
static bool createThunks(OutputSection *OS, int Margin) { static bool createThunks(OutputSection *os, int margin) {
bool AddressesChanged = false; bool addressesChanged = false;
DenseMap<uint64_t, Defined *> LastThunks; DenseMap<uint64_t, Defined *> lastThunks;
DenseMap<std::pair<ObjFile *, Defined *>, uint32_t> ThunkSymtabIndices; DenseMap<std::pair<ObjFile *, Defined *>, uint32_t> thunkSymtabIndices;
size_t ThunksSize = 0; size_t thunksSize = 0;
// Recheck Chunks.size() each iteration, since we can insert more // Recheck Chunks.size() each iteration, since we can insert more
// elements into it. // elements into it.
for (size_t I = 0; I != OS->Chunks.size(); ++I) { for (size_t i = 0; i != os->chunks.size(); ++i) {
SectionChunk *SC = dyn_cast_or_null<SectionChunk>(OS->Chunks[I]); SectionChunk *sc = dyn_cast_or_null<SectionChunk>(os->chunks[i]);
if (!SC) if (!sc)
continue; continue;
size_t ThunkInsertionSpot = I + 1; size_t thunkInsertionSpot = i + 1;
// Try to get a good enough estimate of where new thunks will be placed. // Try to get a good enough estimate of where new thunks will be placed.
// Offset this by the size of the new thunks added so far, to make the // Offset this by the size of the new thunks added so far, to make the
// estimate slightly better. // estimate slightly better.
size_t ThunkInsertionRVA = SC->getRVA() + SC->getSize() + ThunksSize; size_t thunkInsertionRVA = sc->getRVA() + sc->getSize() + thunksSize;
ObjFile *File = SC->File; ObjFile *file = sc->file;
std::vector<std::pair<uint32_t, uint32_t>> RelocReplacements; std::vector<std::pair<uint32_t, uint32_t>> relocReplacements;
ArrayRef<coff_relocation> OriginalRelocs = ArrayRef<coff_relocation> originalRelocs =
File->getCOFFObj()->getRelocations(SC->Header); file->getCOFFObj()->getRelocations(sc->header);
for (size_t J = 0, E = OriginalRelocs.size(); J < E; ++J) { for (size_t j = 0, e = originalRelocs.size(); j < e; ++j) {
const coff_relocation &Rel = OriginalRelocs[J]; const coff_relocation &rel = originalRelocs[j];
Symbol *RelocTarget = File->getSymbol(Rel.SymbolTableIndex); Symbol *relocTarget = file->getSymbol(rel.SymbolTableIndex);
// The estimate of the source address P should be pretty accurate, // The estimate of the source address P should be pretty accurate,
// but we don't know whether the target Symbol address should be // but we don't know whether the target Symbol address should be
// offset by ThunkSize or not (or by some of ThunksSize but not all of // offset by ThunkSize or not (or by some of ThunksSize but not all of
// it), giving us some uncertainty once we have added one thunk. // it), giving us some uncertainty once we have added one thunk.
uint64_t P = SC->getRVA() + Rel.VirtualAddress + ThunksSize; uint64_t p = sc->getRVA() + rel.VirtualAddress + thunksSize;
Defined *Sym = dyn_cast_or_null<Defined>(RelocTarget); Defined *sym = dyn_cast_or_null<Defined>(relocTarget);
if (!Sym) if (!sym)
continue; continue;
uint64_t S = Sym->getRVA(); uint64_t s = sym->getRVA();
if (isInRange(Rel.Type, S, P, Margin)) if (isInRange(rel.Type, s, p, margin))
continue; continue;
// If the target isn't in range, hook it up to an existing or new // If the target isn't in range, hook it up to an existing or new
// thunk. // thunk.
Defined *Thunk; Defined *thunk;
bool WasNew; bool wasNew;
std::tie(Thunk, WasNew) = getThunk(LastThunks, Sym, P, Rel.Type, Margin); std::tie(thunk, wasNew) = getThunk(lastThunks, sym, p, rel.Type, margin);
if (WasNew) { if (wasNew) {
Chunk *ThunkChunk = Thunk->getChunk(); Chunk *thunkChunk = thunk->getChunk();
ThunkChunk->setRVA( thunkChunk->setRVA(
ThunkInsertionRVA); // Estimate of where it will be located. thunkInsertionRVA); // Estimate of where it will be located.
OS->Chunks.insert(OS->Chunks.begin() + ThunkInsertionSpot, ThunkChunk); os->chunks.insert(os->chunks.begin() + thunkInsertionSpot, thunkChunk);
ThunkInsertionSpot++; thunkInsertionSpot++;
ThunksSize += ThunkChunk->getSize(); thunksSize += thunkChunk->getSize();
ThunkInsertionRVA += ThunkChunk->getSize(); thunkInsertionRVA += thunkChunk->getSize();
AddressesChanged = true; addressesChanged = true;
} }
// To redirect the relocation, add a symbol to the parent object file's // To redirect the relocation, add a symbol to the parent object file's
// symbol table, and replace the relocation symbol table index with the // symbol table, and replace the relocation symbol table index with the
// new index. // new index.
auto Insertion = ThunkSymtabIndices.insert({{File, Thunk}, ~0U}); auto insertion = thunkSymtabIndices.insert({{file, thunk}, ~0U});
uint32_t &ThunkSymbolIndex = Insertion.first->second; uint32_t &thunkSymbolIndex = insertion.first->second;
if (Insertion.second) if (insertion.second)
ThunkSymbolIndex = File->addRangeThunkSymbol(Thunk); thunkSymbolIndex = file->addRangeThunkSymbol(thunk);
RelocReplacements.push_back({J, ThunkSymbolIndex}); relocReplacements.push_back({j, thunkSymbolIndex});
} }
// Get a writable copy of this section's relocations so they can be // Get a writable copy of this section's relocations so they can be
// modified. If the relocations point into the object file, allocate new // modified. If the relocations point into the object file, allocate new
// memory. Otherwise, this must be previously allocated memory that can be // memory. Otherwise, this must be previously allocated memory that can be
// modified in place. // modified in place.
ArrayRef<coff_relocation> CurRelocs = SC->getRelocs(); ArrayRef<coff_relocation> curRelocs = sc->getRelocs();
MutableArrayRef<coff_relocation> NewRelocs; MutableArrayRef<coff_relocation> newRelocs;
if (OriginalRelocs.data() == CurRelocs.data()) { if (originalRelocs.data() == curRelocs.data()) {
NewRelocs = makeMutableArrayRef( newRelocs = makeMutableArrayRef(
BAlloc.Allocate<coff_relocation>(OriginalRelocs.size()), bAlloc.Allocate<coff_relocation>(originalRelocs.size()),
OriginalRelocs.size()); originalRelocs.size());
} else { } else {
NewRelocs = makeMutableArrayRef( newRelocs = makeMutableArrayRef(
const_cast<coff_relocation *>(CurRelocs.data()), CurRelocs.size()); const_cast<coff_relocation *>(curRelocs.data()), curRelocs.size());
} }
// Copy each relocation, but replace the symbol table indices which need // Copy each relocation, but replace the symbol table indices which need
// thunks. // thunks.
auto NextReplacement = RelocReplacements.begin(); auto nextReplacement = relocReplacements.begin();
auto EndReplacement = RelocReplacements.end(); auto endReplacement = relocReplacements.end();
for (size_t I = 0, E = OriginalRelocs.size(); I != E; ++I) { for (size_t i = 0, e = originalRelocs.size(); i != e; ++i) {
NewRelocs[I] = OriginalRelocs[I]; newRelocs[i] = originalRelocs[i];
if (NextReplacement != EndReplacement && NextReplacement->first == I) { if (nextReplacement != endReplacement && nextReplacement->first == i) {
NewRelocs[I].SymbolTableIndex = NextReplacement->second; newRelocs[i].SymbolTableIndex = nextReplacement->second;
++NextReplacement; ++nextReplacement;
} }
} }
SC->setRelocs(NewRelocs); sc->setRelocs(newRelocs);
} }
return AddressesChanged; return addressesChanged;
} }
// Verify that all relocations are in range, with no extra margin requirements. // Verify that all relocations are in range, with no extra margin requirements.
static bool verifyRanges(const std::vector<Chunk *> Chunks) { static bool verifyRanges(const std::vector<Chunk *> chunks) {
for (Chunk *C : Chunks) { for (Chunk *c : chunks) {
SectionChunk *SC = dyn_cast_or_null<SectionChunk>(C); SectionChunk *sc = dyn_cast_or_null<SectionChunk>(c);
if (!SC) if (!sc)
continue; continue;
ArrayRef<coff_relocation> Relocs = SC->getRelocs(); ArrayRef<coff_relocation> relocs = sc->getRelocs();
for (size_t J = 0, E = Relocs.size(); J < E; ++J) { for (size_t j = 0, e = relocs.size(); j < e; ++j) {
const coff_relocation &Rel = Relocs[J]; const coff_relocation &rel = relocs[j];
Symbol *RelocTarget = SC->File->getSymbol(Rel.SymbolTableIndex); Symbol *relocTarget = sc->file->getSymbol(rel.SymbolTableIndex);
Defined *Sym = dyn_cast_or_null<Defined>(RelocTarget); Defined *sym = dyn_cast_or_null<Defined>(relocTarget);
if (!Sym) if (!sym)
continue; continue;
uint64_t P = SC->getRVA() + Rel.VirtualAddress; uint64_t p = sc->getRVA() + rel.VirtualAddress;
uint64_t S = Sym->getRVA(); uint64_t s = sym->getRVA();
if (!isInRange(Rel.Type, S, P, 0)) if (!isInRange(rel.Type, s, p, 0))
return false; return false;
} }
} }
return true; return true;
} }
// Assign addresses and add thunks if necessary. // Assign addresses and add thunks if necessary.
void Writer::finalizeAddresses() { void Writer::finalizeAddresses() {
assignAddresses(); assignAddresses();
if (Config->Machine != ARMNT && Config->Machine != ARM64) if (config->machine != ARMNT && config->machine != ARM64)
return; return;
size_t OrigNumChunks = 0; size_t origNumChunks = 0;
for (OutputSection *Sec : OutputSections) { for (OutputSection *sec : outputSections) {
Sec->OrigChunks = Sec->Chunks; sec->origChunks = sec->chunks;
OrigNumChunks += Sec->Chunks.size(); origNumChunks += sec->chunks.size();
} }
int Pass = 0; int pass = 0;
int Margin = 1024 * 100; int margin = 1024 * 100;
while (true) { while (true) {
// First check whether we need thunks at all, or if the previous pass of // First check whether we need thunks at all, or if the previous pass of
// adding them turned out ok. // adding them turned out ok.
bool RangesOk = true; bool rangesOk = true;
size_t NumChunks = 0; size_t numChunks = 0;
for (OutputSection *Sec : OutputSections) { for (OutputSection *sec : outputSections) {
if (!verifyRanges(Sec->Chunks)) { if (!verifyRanges(sec->chunks)) {
RangesOk = false; rangesOk = false;
break; break;
} }
NumChunks += Sec->Chunks.size(); numChunks += sec->chunks.size();
} }
if (RangesOk) { if (rangesOk) {
if (Pass > 0) if (pass > 0)
log("Added " + Twine(NumChunks - OrigNumChunks) + " thunks with " + log("Added " + Twine(numChunks - origNumChunks) + " thunks with " +
"margin " + Twine(Margin) + " in " + Twine(Pass) + " passes"); "margin " + Twine(margin) + " in " + Twine(pass) + " passes");
return; return;
} }
if (Pass >= 10) if (pass >= 10)
fatal("adding thunks hasn't converged after " + Twine(Pass) + " passes"); fatal("adding thunks hasn't converged after " + Twine(pass) + " passes");
if (Pass > 0) { if (pass > 0) {
// If the previous pass didn't work out, reset everything back to the // If the previous pass didn't work out, reset everything back to the
// original conditions before retrying with a wider margin. This should // original conditions before retrying with a wider margin. This should
// ideally never happen under real circumstances. // ideally never happen under real circumstances.
for (OutputSection *Sec : OutputSections) for (OutputSection *sec : outputSections)
Sec->Chunks = Sec->OrigChunks; sec->chunks = sec->origChunks;
Margin *= 2; margin *= 2;
} }
// Try adding thunks everywhere where it is needed, with a margin // Try adding thunks everywhere where it is needed, with a margin
// to avoid things going out of range due to the added thunks. // to avoid things going out of range due to the added thunks.
bool AddressesChanged = false; bool addressesChanged = false;
for (OutputSection *Sec : OutputSections) for (OutputSection *sec : outputSections)
AddressesChanged |= createThunks(Sec, Margin); addressesChanged |= createThunks(sec, margin);
// If the verification above thought we needed thunks, we should have // If the verification above thought we needed thunks, we should have
// added some. // added some.
assert(AddressesChanged); assert(addressesChanged);
// Recalculate the layout for the whole image (and verify the ranges at // Recalculate the layout for the whole image (and verify the ranges at
// the start of the next round). // the start of the next round).
assignAddresses(); assignAddresses();
Pass++; pass++;
} }
} }
// The main function of the writer. // The main function of the writer.
void Writer::run() { void Writer::run() {
ScopedTimer T1(CodeLayoutTimer); ScopedTimer t1(codeLayoutTimer);
createImportTables(); createImportTables();
createSections(); createSections();
createMiscChunks(); createMiscChunks();
appendImportThunks(); appendImportThunks();
createExportTable(); createExportTable();
mergeSections(); mergeSections();
removeUnusedSections(); removeUnusedSections();
finalizeAddresses(); finalizeAddresses();
removeEmptySections(); removeEmptySections();
assignOutputSectionIndices(); assignOutputSectionIndices();
setSectionPermissions(); setSectionPermissions();
createSymbolAndStringTable(); createSymbolAndStringTable();
if (FileSize > UINT32_MAX) if (fileSize > UINT32_MAX)
fatal("image size (" + Twine(FileSize) + ") " + fatal("image size (" + Twine(fileSize) + ") " +
"exceeds maximum allowable size (" + Twine(UINT32_MAX) + ")"); "exceeds maximum allowable size (" + Twine(UINT32_MAX) + ")");
openFile(Config->OutputFile); openFile(config->outputFile);
if (Config->is64()) { if (config->is64()) {
writeHeader<pe32plus_header>(); writeHeader<pe32plus_header>();
} else { } else {
writeHeader<pe32_header>(); writeHeader<pe32_header>();
} }
writeSections(); writeSections();
sortExceptionTable(); sortExceptionTable();
T1.stop(); t1.stop();
if (!Config->PDBPath.empty() && Config->Debug) { if (!config->pdbPath.empty() && config->debug) {
assert(BuildId); assert(buildId);
createPDB(Symtab, OutputSections, SectionTable, BuildId->BuildId); createPDB(symtab, outputSections, sectionTable, buildId->buildId);
} }
writeBuildId(); writeBuildId();
writeMapFile(OutputSections); writeMapFile(outputSections);
ScopedTimer T2(DiskCommitTimer); ScopedTimer t2(diskCommitTimer);
if (auto E = Buffer->commit()) if (auto e = buffer->commit())
fatal("failed to write the output file: " + toString(std::move(E))); fatal("failed to write the output file: " + toString(std::move(e)));
} }
static StringRef getOutputSectionName(StringRef Name) { static StringRef getOutputSectionName(StringRef name) {
StringRef S = Name.split('$').first; StringRef s = name.split('$').first;
// Treat a later period as a separator for MinGW, for sections like // Treat a later period as a separator for MinGW, for sections like
// ".ctors.01234". // ".ctors.01234".
return S.substr(0, S.find('.', 1)); return s.substr(0, s.find('.', 1));
} }
// For /order. // For /order.
static void sortBySectionOrder(std::vector<Chunk *> &Chunks) { static void sortBySectionOrder(std::vector<Chunk *> &chunks) {
auto GetPriority = [](const Chunk *C) { auto getPriority = [](const Chunk *c) {
if (auto *Sec = dyn_cast<SectionChunk>(C)) if (auto *sec = dyn_cast<SectionChunk>(c))
if (Sec->Sym) if (sec->sym)
return Config->Order.lookup(Sec->Sym->getName()); return config->order.lookup(sec->sym->getName());
return 0; return 0;
}; };
llvm::stable_sort(Chunks, [=](const Chunk *A, const Chunk *B) { llvm::stable_sort(chunks, [=](const Chunk *a, const Chunk *b) {
return GetPriority(A) < GetPriority(B); return getPriority(a) < getPriority(b);
}); });
} }
// Change the characteristics of existing PartialSections that belong to the // Change the characteristics of existing PartialSections that belong to the
// section Name to Chars. // section Name to Chars.
void Writer::fixPartialSectionChars(StringRef Name, uint32_t Chars) { void Writer::fixPartialSectionChars(StringRef name, uint32_t chars) {
for (auto It : PartialSections) { for (auto it : partialSections) {
PartialSection *PSec = It.second; PartialSection *pSec = it.second;
StringRef CurName = PSec->Name; StringRef curName = pSec->name;
if (!CurName.consume_front(Name) || if (!curName.consume_front(name) ||
(!CurName.empty() && !CurName.startswith("$"))) (!curName.empty() && !curName.startswith("$")))
continue; continue;
if (PSec->Characteristics == Chars) if (pSec->characteristics == chars)
continue; continue;
PartialSection *DestSec = createPartialSection(PSec->Name, Chars); PartialSection *destSec = createPartialSection(pSec->name, chars);
DestSec->Chunks.insert(DestSec->Chunks.end(), PSec->Chunks.begin(), destSec->chunks.insert(destSec->chunks.end(), pSec->chunks.begin(),
PSec->Chunks.end()); pSec->chunks.end());
PSec->Chunks.clear(); pSec->chunks.clear();
} }
} }
// Sort concrete section chunks from GNU import libraries. // Sort concrete section chunks from GNU import libraries.
// //
// GNU binutils doesn't use short import files, but instead produces import // GNU binutils doesn't use short import files, but instead produces import
// libraries that consist of object files, with section chunks for the .idata$* // libraries that consist of object files, with section chunks for the .idata$*
// sections. These are linked just as regular static libraries. Each import // sections. These are linked just as regular static libraries. Each import
// library consists of one header object, one object file for every imported // library consists of one header object, one object file for every imported
// symbol, and one trailer object. In order for the .idata tables/lists to // symbol, and one trailer object. In order for the .idata tables/lists to
// be formed correctly, the section chunks within each .idata$* section need // be formed correctly, the section chunks within each .idata$* section need
// to be grouped by library, and sorted alphabetically within each library // to be grouped by library, and sorted alphabetically within each library
// (which makes sure the header comes first and the trailer last). // (which makes sure the header comes first and the trailer last).
bool Writer::fixGnuImportChunks() { bool Writer::fixGnuImportChunks() {
uint32_t RDATA = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ; uint32_t rdata = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
// Make sure all .idata$* section chunks are mapped as RDATA in order to // Make sure all .idata$* section chunks are mapped as RDATA in order to
// be sorted into the same sections as our own synthesized .idata chunks. // be sorted into the same sections as our own synthesized .idata chunks.
fixPartialSectionChars(".idata", RDATA); fixPartialSectionChars(".idata", rdata);
bool HasIdata = false; bool hasIdata = false;
// Sort all .idata$* chunks, grouping chunks from the same library, // Sort all .idata$* chunks, grouping chunks from the same library,
// with alphabetical ordering of the object fils within a library. // with alphabetical ordering of the object fils within a library.
for (auto It : PartialSections) { for (auto it : partialSections) {
PartialSection *PSec = It.second; PartialSection *pSec = it.second;
if (!PSec->Name.startswith(".idata")) if (!pSec->name.startswith(".idata"))
continue; continue;
if (!PSec->Chunks.empty()) if (!pSec->chunks.empty())
HasIdata = true; hasIdata = true;
llvm::stable_sort(PSec->Chunks, [&](Chunk *S, Chunk *T) { llvm::stable_sort(pSec->chunks, [&](Chunk *s, Chunk *t) {
SectionChunk *SC1 = dyn_cast_or_null<SectionChunk>(S); SectionChunk *sc1 = dyn_cast_or_null<SectionChunk>(s);
SectionChunk *SC2 = dyn_cast_or_null<SectionChunk>(T); SectionChunk *sc2 = dyn_cast_or_null<SectionChunk>(t);
if (!SC1 || !SC2) { if (!sc1 || !sc2) {
// if SC1, order them ascending. If SC2 or both null, // if SC1, order them ascending. If SC2 or both null,
// S is not less than T. // S is not less than T.
return SC1 != nullptr; return sc1 != nullptr;
} }
// Make a string with "libraryname/objectfile" for sorting, achieving // Make a string with "libraryname/objectfile" for sorting, achieving
// both grouping by library and sorting of objects within a library, // both grouping by library and sorting of objects within a library,
// at once. // at once.
std::string Key1 = std::string key1 =
(SC1->File->ParentName + "/" + SC1->File->getName()).str(); (sc1->file->parentName + "/" + sc1->file->getName()).str();
std::string Key2 = std::string key2 =
(SC2->File->ParentName + "/" + SC2->File->getName()).str(); (sc2->file->parentName + "/" + sc2->file->getName()).str();
return Key1 < Key2; return key1 < key2;
}); });
} }
return HasIdata; return hasIdata;
} }
// Add generated idata chunks, for imported symbols and DLLs, and a // Add generated idata chunks, for imported symbols and DLLs, and a
// terminator in .idata$2. // terminator in .idata$2.
void Writer::addSyntheticIdata() { void Writer::addSyntheticIdata() {
uint32_t RDATA = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ; uint32_t rdata = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
Idata.create(); idata.create();
// Add the .idata content in the right section groups, to allow // Add the .idata content in the right section groups, to allow
// chunks from other linked in object files to be grouped together. // chunks from other linked in object files to be grouped together.
// See Microsoft PE/COFF spec 5.4 for details. // See Microsoft PE/COFF spec 5.4 for details.
auto Add = [&](StringRef N, std::vector<Chunk *> &V) { auto add = [&](StringRef n, std::vector<Chunk *> &v) {
PartialSection *PSec = createPartialSection(N, RDATA); PartialSection *pSec = createPartialSection(n, rdata);
PSec->Chunks.insert(PSec->Chunks.end(), V.begin(), V.end()); pSec->chunks.insert(pSec->chunks.end(), v.begin(), v.end());
}; };
// The loader assumes a specific order of data. // The loader assumes a specific order of data.
// Add each type in the correct order. // Add each type in the correct order.
Add(".idata$2", Idata.Dirs); add(".idata$2", idata.dirs);
Add(".idata$4", Idata.Lookups); add(".idata$4", idata.lookups);
Add(".idata$5", Idata.Addresses); add(".idata$5", idata.addresses);
Add(".idata$6", Idata.Hints); add(".idata$6", idata.hints);
Add(".idata$7", Idata.DLLNames); add(".idata$7", idata.dllNames);
} }
// Locate the first Chunk and size of the import directory list and the // Locate the first Chunk and size of the import directory list and the
// IAT. // IAT.
void Writer::locateImportTables() { void Writer::locateImportTables() {
uint32_t RDATA = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ; uint32_t rdata = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
if (PartialSection *ImportDirs = findPartialSection(".idata$2", RDATA)) { if (PartialSection *importDirs = findPartialSection(".idata$2", rdata)) {
if (!ImportDirs->Chunks.empty()) if (!importDirs->chunks.empty())
ImportTableStart = ImportDirs->Chunks.front(); importTableStart = importDirs->chunks.front();
for (Chunk *C : ImportDirs->Chunks) for (Chunk *c : importDirs->chunks)
ImportTableSize += C->getSize(); importTableSize += c->getSize();
} }
if (PartialSection *ImportAddresses = findPartialSection(".idata$5", RDATA)) { if (PartialSection *importAddresses = findPartialSection(".idata$5", rdata)) {
if (!ImportAddresses->Chunks.empty()) if (!importAddresses->chunks.empty())
IATStart = ImportAddresses->Chunks.front(); iatStart = importAddresses->chunks.front();
for (Chunk *C : ImportAddresses->Chunks) for (Chunk *c : importAddresses->chunks)
IATSize += C->getSize(); iatSize += c->getSize();
} }
} }
// Create output section objects and add them to OutputSections. // Create output section objects and add them to OutputSections.
void Writer::createSections() { void Writer::createSections() {
// First, create the builtin sections. // First, create the builtin sections.
const uint32_t DATA = IMAGE_SCN_CNT_INITIALIZED_DATA; const uint32_t data = IMAGE_SCN_CNT_INITIALIZED_DATA;
const uint32_t BSS = IMAGE_SCN_CNT_UNINITIALIZED_DATA; const uint32_t bss = IMAGE_SCN_CNT_UNINITIALIZED_DATA;
const uint32_t CODE = IMAGE_SCN_CNT_CODE; const uint32_t code = IMAGE_SCN_CNT_CODE;
const uint32_t DISCARDABLE = IMAGE_SCN_MEM_DISCARDABLE; const uint32_t discardable = IMAGE_SCN_MEM_DISCARDABLE;
const uint32_t R = IMAGE_SCN_MEM_READ; const uint32_t r = IMAGE_SCN_MEM_READ;
const uint32_t W = IMAGE_SCN_MEM_WRITE; const uint32_t w = IMAGE_SCN_MEM_WRITE;
const uint32_t X = IMAGE_SCN_MEM_EXECUTE; const uint32_t x = IMAGE_SCN_MEM_EXECUTE;
SmallDenseMap<std::pair<StringRef, uint32_t>, OutputSection *> Sections; SmallDenseMap<std::pair<StringRef, uint32_t>, OutputSection *> sections;
auto CreateSection = [&](StringRef Name, uint32_t OutChars) { auto createSection = [&](StringRef name, uint32_t outChars) {
OutputSection *&Sec = Sections[{Name, OutChars}]; OutputSection *&sec = sections[{name, outChars}];
if (!Sec) { if (!sec) {
Sec = make<OutputSection>(Name, OutChars); sec = make<OutputSection>(name, outChars);
OutputSections.push_back(Sec); outputSections.push_back(sec);
} }
return Sec; return sec;
}; };
// Try to match the section order used by link.exe. // Try to match the section order used by link.exe.
TextSec = CreateSection(".text", CODE | R | X); textSec = createSection(".text", code | r | x);
CreateSection(".bss", BSS | R | W); createSection(".bss", bss | r | w);
RdataSec = CreateSection(".rdata", DATA | R); rdataSec = createSection(".rdata", data | r);
BuildidSec = CreateSection(".buildid", DATA | R); buildidSec = createSection(".buildid", data | r);
DataSec = CreateSection(".data", DATA | R | W); dataSec = createSection(".data", data | r | w);
PdataSec = CreateSection(".pdata", DATA | R); pdataSec = createSection(".pdata", data | r);
IdataSec = CreateSection(".idata", DATA | R); idataSec = createSection(".idata", data | r);
EdataSec = CreateSection(".edata", DATA | R); edataSec = createSection(".edata", data | r);
DidatSec = CreateSection(".didat", DATA | R); didatSec = createSection(".didat", data | r);
RsrcSec = CreateSection(".rsrc", DATA | R); rsrcSec = createSection(".rsrc", data | r);
RelocSec = CreateSection(".reloc", DATA | DISCARDABLE | R); relocSec = createSection(".reloc", data | discardable | r);
CtorsSec = CreateSection(".ctors", DATA | R | W); ctorsSec = createSection(".ctors", data | r | w);
DtorsSec = CreateSection(".dtors", DATA | R | W); dtorsSec = createSection(".dtors", data | r | w);
// Then bin chunks by name and output characteristics. // Then bin chunks by name and output characteristics.
for (Chunk *C : Symtab->getChunks()) { for (Chunk *c : symtab->getChunks()) {
auto *SC = dyn_cast<SectionChunk>(C); auto *sc = dyn_cast<SectionChunk>(c);
if (SC && !SC->Live) { if (sc && !sc->live) {
if (Config->Verbose) if (config->verbose)
SC->printDiscardedMessage(); sc->printDiscardedMessage();
continue; continue;
} }
StringRef Name = C->getSectionName(); StringRef name = c->getSectionName();
// On MinGW, comdat groups are formed by putting the comdat group name // On MinGW, comdat groups are formed by putting the comdat group name
// after the '$' in the section name. Such a section name suffix shouldn't // after the '$' in the section name. Such a section name suffix shouldn't
// imply separate alphabetical sorting of those section chunks though. // imply separate alphabetical sorting of those section chunks though.
if (Config->MinGW && SC && SC->isCOMDAT()) if (config->mingw && sc && sc->isCOMDAT())
Name = Name.split('$').first; name = name.split('$').first;
PartialSection *PSec = createPartialSection(Name, PartialSection *pSec = createPartialSection(name,
C->getOutputCharacteristics()); c->getOutputCharacteristics());
PSec->Chunks.push_back(C); pSec->chunks.push_back(c);
} }
fixPartialSectionChars(".rsrc", DATA | R); fixPartialSectionChars(".rsrc", data | r);
// Even in non MinGW cases, we might need to link against GNU import // Even in non MinGW cases, we might need to link against GNU import
// libraries. // libraries.
bool HasIdata = fixGnuImportChunks(); bool hasIdata = fixGnuImportChunks();
if (!Idata.empty()) if (!idata.empty())
HasIdata = true; hasIdata = true;
if (HasIdata) if (hasIdata)
addSyntheticIdata(); addSyntheticIdata();
// Process an /order option. // Process an /order option.
if (!Config->Order.empty()) if (!config->order.empty())
for (auto It : PartialSections) for (auto it : partialSections)
sortBySectionOrder(It.second->Chunks); sortBySectionOrder(it.second->chunks);
if (HasIdata) if (hasIdata)
locateImportTables(); locateImportTables();
// Then create an OutputSection for each section. // Then create an OutputSection for each section.
// '$' and all following characters in input section names are // '$' and all following characters in input section names are
// discarded when determining output section. So, .text$foo // discarded when determining output section. So, .text$foo
// contributes to .text, for example. See PE/COFF spec 3.2. // contributes to .text, for example. See PE/COFF spec 3.2.
for (auto It : PartialSections) { for (auto it : partialSections) {
PartialSection *PSec = It.second; PartialSection *pSec = it.second;
StringRef Name = getOutputSectionName(PSec->Name); StringRef name = getOutputSectionName(pSec->name);
uint32_t OutChars = PSec->Characteristics; uint32_t outChars = pSec->characteristics;
if (Name == ".CRT") { if (name == ".CRT") {
// In link.exe, there is a special case for the I386 target where .CRT // In link.exe, there is a special case for the I386 target where .CRT
// sections are treated as if they have output characteristics DATA | R if // sections are treated as if they have output characteristics DATA | R if
// their characteristics are DATA | R | W. This implements the same // their characteristics are DATA | R | W. This implements the same
// special case for all architectures. // special case for all architectures.
OutChars = DATA | R; outChars = data | r;
log("Processing section " + PSec->Name + " -> " + Name); log("Processing section " + pSec->name + " -> " + name);
sortCRTSectionChunks(PSec->Chunks); sortCRTSectionChunks(pSec->chunks);
} }
OutputSection *Sec = CreateSection(Name, OutChars); OutputSection *sec = createSection(name, outChars);
for (Chunk *C : PSec->Chunks) for (Chunk *c : pSec->chunks)
Sec->addChunk(C); sec->addChunk(c);
Sec->addContributingPartialSection(PSec); sec->addContributingPartialSection(pSec);
} }
// Finally, move some output sections to the end. // Finally, move some output sections to the end.
auto SectionOrder = [&](const OutputSection *S) { auto sectionOrder = [&](const OutputSection *s) {
// Move DISCARDABLE (or non-memory-mapped) sections to the end of file // Move DISCARDABLE (or non-memory-mapped) sections to the end of file
// because the loader cannot handle holes. Stripping can remove other // because the loader cannot handle holes. Stripping can remove other
// discardable ones than .reloc, which is first of them (created early). // discardable ones than .reloc, which is first of them (created early).
if (S->Header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE) if (s->header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE)
return 2; return 2;
// .rsrc should come at the end of the non-discardable sections because its // .rsrc should come at the end of the non-discardable sections because its
// size may change by the Win32 UpdateResources() function, causing // size may change by the Win32 UpdateResources() function, causing
// subsequent sections to move (see https://crbug.com/827082). // subsequent sections to move (see https://crbug.com/827082).
if (S == RsrcSec) if (s == rsrcSec)
return 1; return 1;
return 0; return 0;
}; };
llvm::stable_sort(OutputSections, llvm::stable_sort(outputSections,
[&](const OutputSection *S, const OutputSection *T) { [&](const OutputSection *s, const OutputSection *t) {
return SectionOrder(S) < SectionOrder(T); return sectionOrder(s) < sectionOrder(t);
}); });
} }
void Writer::createMiscChunks() { void Writer::createMiscChunks() {
for (MergeChunk *P : MergeChunk::Instances) { for (MergeChunk *p : MergeChunk::instances) {
if (P) { if (p) {
P->finalizeContents(); p->finalizeContents();
RdataSec->addChunk(P); rdataSec->addChunk(p);
} }
} }
// Create thunks for locally-dllimported symbols. // Create thunks for locally-dllimported symbols.
if (!Symtab->LocalImportChunks.empty()) { if (!symtab->localImportChunks.empty()) {
for (Chunk *C : Symtab->LocalImportChunks) for (Chunk *c : symtab->localImportChunks)
RdataSec->addChunk(C); rdataSec->addChunk(c);
} }
// Create Debug Information Chunks // Create Debug Information Chunks
OutputSection *DebugInfoSec = Config->MinGW ? BuildidSec : RdataSec; OutputSection *debugInfoSec = config->mingw ? buildidSec : rdataSec;
if (Config->Debug || Config->Repro) { if (config->debug || config->repro) {
DebugDirectory = make<DebugDirectoryChunk>(DebugRecords, Config->Repro); debugDirectory = make<DebugDirectoryChunk>(debugRecords, config->repro);
DebugInfoSec->addChunk(DebugDirectory); debugInfoSec->addChunk(debugDirectory);
} }
if (Config->Debug) { if (config->debug) {
// Make a CVDebugRecordChunk even when /DEBUG:CV is not specified. We // Make a CVDebugRecordChunk even when /DEBUG:CV is not specified. We
// output a PDB no matter what, and this chunk provides the only means of // output a PDB no matter what, and this chunk provides the only means of
// allowing a debugger to match a PDB and an executable. So we need it even // allowing a debugger to match a PDB and an executable. So we need it even
// if we're ultimately not going to write CodeView data to the PDB. // if we're ultimately not going to write CodeView data to the PDB.
BuildId = make<CVDebugRecordChunk>(); buildId = make<CVDebugRecordChunk>();
DebugRecords.push_back(BuildId); debugRecords.push_back(buildId);
for (Chunk *C : DebugRecords) for (Chunk *c : debugRecords)
DebugInfoSec->addChunk(C); debugInfoSec->addChunk(c);
} }
// Create SEH table. x86-only. // Create SEH table. x86-only.
if (Config->Machine == I386) if (config->machine == I386)
createSEHTable(); createSEHTable();
// Create /guard:cf tables if requested. // Create /guard:cf tables if requested.
if (Config->GuardCF != GuardCFLevel::Off) if (config->guardCF != GuardCFLevel::Off)
createGuardCFTables(); createGuardCFTables();
if (Config->MinGW) { if (config->mingw) {
createRuntimePseudoRelocs(); createRuntimePseudoRelocs();
insertCtorDtorSymbols(); insertCtorDtorSymbols();
} }
} }
// Create .idata section for the DLL-imported symbol table. // Create .idata section for the DLL-imported symbol table.
// The format of this section is inherently Windows-specific. // The format of this section is inherently Windows-specific.
// IdataContents class abstracted away the details for us, // IdataContents class abstracted away the details for us,
// so we just let it create chunks and add them to the section. // so we just let it create chunks and add them to the section.
void Writer::createImportTables() { void Writer::createImportTables() {
// Initialize DLLOrder so that import entries are ordered in // Initialize DLLOrder so that import entries are ordered in
// the same order as in the command line. (That affects DLL // the same order as in the command line. (That affects DLL
// initialization order, and this ordering is MSVC-compatible.) // initialization order, and this ordering is MSVC-compatible.)
for (ImportFile *File : ImportFile::Instances) { for (ImportFile *file : ImportFile::instances) {
if (!File->Live) if (!file->live)
continue; continue;
std::string DLL = StringRef(File->DLLName).lower(); std::string dll = StringRef(file->dllName).lower();
if (Config->DLLOrder.count(DLL) == 0) if (config->dllOrder.count(dll) == 0)
Config->DLLOrder[DLL] = Config->DLLOrder.size(); config->dllOrder[dll] = config->dllOrder.size();
if (File->ImpSym && !isa<DefinedImportData>(File->ImpSym)) if (file->impSym && !isa<DefinedImportData>(file->impSym))
fatal(toString(*File->ImpSym) + " was replaced"); fatal(toString(*file->impSym) + " was replaced");
DefinedImportData *ImpSym = cast_or_null<DefinedImportData>(File->ImpSym); DefinedImportData *impSym = cast_or_null<DefinedImportData>(file->impSym);
if (Config->DelayLoads.count(StringRef(File->DLLName).lower())) { if (config->delayLoads.count(StringRef(file->dllName).lower())) {
if (!File->ThunkSym) if (!file->thunkSym)
fatal("cannot delay-load " + toString(File) + fatal("cannot delay-load " + toString(file) +
" due to import of data: " + toString(*ImpSym)); " due to import of data: " + toString(*impSym));
DelayIdata.add(ImpSym); delayIdata.add(impSym);
} else { } else {
Idata.add(ImpSym); idata.add(impSym);
} }
} }
} }
void Writer::appendImportThunks() { void Writer::appendImportThunks() {
if (ImportFile::Instances.empty()) if (ImportFile::instances.empty())
return; return;
for (ImportFile *File : ImportFile::Instances) { for (ImportFile *file : ImportFile::instances) {
if (!File->Live) if (!file->live)
continue; continue;
if (!File->ThunkSym) if (!file->thunkSym)
continue; continue;
if (!isa<DefinedImportThunk>(File->ThunkSym)) if (!isa<DefinedImportThunk>(file->thunkSym))
fatal(toString(*File->ThunkSym) + " was replaced"); fatal(toString(*file->thunkSym) + " was replaced");
DefinedImportThunk *Thunk = cast<DefinedImportThunk>(File->ThunkSym); DefinedImportThunk *thunk = cast<DefinedImportThunk>(file->thunkSym);
if (File->ThunkLive) if (file->thunkLive)
TextSec->addChunk(Thunk->getChunk()); textSec->addChunk(thunk->getChunk());
} }
if (!DelayIdata.empty()) { if (!delayIdata.empty()) {
Defined *Helper = cast<Defined>(Config->DelayLoadHelper); Defined *helper = cast<Defined>(config->delayLoadHelper);
DelayIdata.create(Helper); delayIdata.create(helper);
for (Chunk *C : DelayIdata.getChunks()) for (Chunk *c : delayIdata.getChunks())
DidatSec->addChunk(C); didatSec->addChunk(c);
for (Chunk *C : DelayIdata.getDataChunks()) for (Chunk *c : delayIdata.getDataChunks())
DataSec->addChunk(C); dataSec->addChunk(c);
for (Chunk *C : DelayIdata.getCodeChunks()) for (Chunk *c : delayIdata.getCodeChunks())
TextSec->addChunk(C); textSec->addChunk(c);
} }
} }
void Writer::createExportTable() { void Writer::createExportTable() {
if (Config->Exports.empty()) if (config->exports.empty())
return; return;
for (Chunk *C : Edata.Chunks) for (Chunk *c : edata.chunks)
EdataSec->addChunk(C); edataSec->addChunk(c);
} }
void Writer::removeUnusedSections() { void Writer::removeUnusedSections() {
// Remove sections that we can be sure won't get content, to avoid // Remove sections that we can be sure won't get content, to avoid
// allocating space for their section headers. // allocating space for their section headers.
auto IsUnused = [this](OutputSection *S) { auto isUnused = [this](OutputSection *s) {
if (S == RelocSec) if (s == relocSec)
return false; // This section is populated later. return false; // This section is populated later.
// MergeChunks have zero size at this point, as their size is finalized // MergeChunks have zero size at this point, as their size is finalized
// later. Only remove sections that have no Chunks at all. // later. Only remove sections that have no Chunks at all.
return S->Chunks.empty(); return s->chunks.empty();
}; };
OutputSections.erase( outputSections.erase(
std::remove_if(OutputSections.begin(), OutputSections.end(), IsUnused), std::remove_if(outputSections.begin(), outputSections.end(), isUnused),
OutputSections.end()); outputSections.end());
} }
// The Windows loader doesn't seem to like empty sections, // The Windows loader doesn't seem to like empty sections,
// so we remove them if any. // so we remove them if any.
void Writer::removeEmptySections() { void Writer::removeEmptySections() {
auto IsEmpty = [](OutputSection *S) { return S->getVirtualSize() == 0; }; auto isEmpty = [](OutputSection *s) { return s->getVirtualSize() == 0; };
OutputSections.erase( outputSections.erase(
std::remove_if(OutputSections.begin(), OutputSections.end(), IsEmpty), std::remove_if(outputSections.begin(), outputSections.end(), isEmpty),
OutputSections.end()); outputSections.end());
} }
void Writer::assignOutputSectionIndices() { void Writer::assignOutputSectionIndices() {
// Assign final output section indices, and assign each chunk to its output // Assign final output section indices, and assign each chunk to its output
// section. // section.
uint32_t Idx = 1; uint32_t idx = 1;
for (OutputSection *OS : OutputSections) { for (OutputSection *os : outputSections) {
OS->SectionIndex = Idx; os->sectionIndex = idx;
for (Chunk *C : OS->Chunks) for (Chunk *c : os->chunks)
C->setOutputSectionIdx(Idx); c->setOutputSectionIdx(idx);
++Idx; ++idx;
} }
// Merge chunks are containers of chunks, so assign those an output section // Merge chunks are containers of chunks, so assign those an output section
// too. // too.
for (MergeChunk *MC : MergeChunk::Instances) for (MergeChunk *mc : MergeChunk::instances)
if (MC) if (mc)
for (SectionChunk *SC : MC->Sections) for (SectionChunk *sc : mc->sections)
if (SC && SC->Live) if (sc && sc->live)
SC->setOutputSectionIdx(MC->getOutputSectionIdx()); sc->setOutputSectionIdx(mc->getOutputSectionIdx());
} }
size_t Writer::addEntryToStringTable(StringRef Str) { size_t Writer::addEntryToStringTable(StringRef str) {
assert(Str.size() > COFF::NameSize); assert(str.size() > COFF::NameSize);
size_t OffsetOfEntry = Strtab.size() + 4; // +4 for the size field size_t offsetOfEntry = strtab.size() + 4; // +4 for the size field
Strtab.insert(Strtab.end(), Str.begin(), Str.end()); strtab.insert(strtab.end(), str.begin(), str.end());
Strtab.push_back('\0'); strtab.push_back('\0');
return OffsetOfEntry; return offsetOfEntry;
} }
Optional<coff_symbol16> Writer::createSymbol(Defined *Def) { Optional<coff_symbol16> Writer::createSymbol(Defined *def) {
coff_symbol16 Sym; coff_symbol16 sym;
switch (Def->kind()) { switch (def->kind()) {
case Symbol::DefinedAbsoluteKind: case Symbol::DefinedAbsoluteKind:
Sym.Value = Def->getRVA(); sym.Value = def->getRVA();
Sym.SectionNumber = IMAGE_SYM_ABSOLUTE; sym.SectionNumber = IMAGE_SYM_ABSOLUTE;
break; break;
case Symbol::DefinedSyntheticKind: case Symbol::DefinedSyntheticKind:
// Relative symbols are unrepresentable in a COFF symbol table. // Relative symbols are unrepresentable in a COFF symbol table.
return None; return None;
default: { default: {
// Don't write symbols that won't be written to the output to the symbol // Don't write symbols that won't be written to the output to the symbol
// table. // table.
Chunk *C = Def->getChunk(); Chunk *c = def->getChunk();
if (!C) if (!c)
return None; return None;
OutputSection *OS = C->getOutputSection(); OutputSection *os = c->getOutputSection();
if (!OS) if (!os)
return None; return None;
Sym.Value = Def->getRVA() - OS->getRVA(); sym.Value = def->getRVA() - os->getRVA();
Sym.SectionNumber = OS->SectionIndex; sym.SectionNumber = os->sectionIndex;
break; break;
} }
} }
StringRef Name = Def->getName(); StringRef name = def->getName();
if (Name.size() > COFF::NameSize) { if (name.size() > COFF::NameSize) {
Sym.Name.Offset.Zeroes = 0; sym.Name.Offset.Zeroes = 0;
Sym.Name.Offset.Offset = addEntryToStringTable(Name); sym.Name.Offset.Offset = addEntryToStringTable(name);
} else { } else {
memset(Sym.Name.ShortName, 0, COFF::NameSize); memset(sym.Name.ShortName, 0, COFF::NameSize);
memcpy(Sym.Name.ShortName, Name.data(), Name.size()); memcpy(sym.Name.ShortName, name.data(), name.size());
} }
if (auto *D = dyn_cast<DefinedCOFF>(Def)) { if (auto *d = dyn_cast<DefinedCOFF>(def)) {
COFFSymbolRef Ref = D->getCOFFSymbol(); COFFSymbolRef ref = d->getCOFFSymbol();
Sym.Type = Ref.getType(); sym.Type = ref.getType();
Sym.StorageClass = Ref.getStorageClass(); sym.StorageClass = ref.getStorageClass();
} else { } else {
Sym.Type = IMAGE_SYM_TYPE_NULL; sym.Type = IMAGE_SYM_TYPE_NULL;
Sym.StorageClass = IMAGE_SYM_CLASS_EXTERNAL; sym.StorageClass = IMAGE_SYM_CLASS_EXTERNAL;
} }
Sym.NumberOfAuxSymbols = 0; sym.NumberOfAuxSymbols = 0;
return Sym; return sym;
} }
void Writer::createSymbolAndStringTable() { void Writer::createSymbolAndStringTable() {
// PE/COFF images are limited to 8 byte section names. Longer names can be // PE/COFF images are limited to 8 byte section names. Longer names can be
// supported by writing a non-standard string table, but this string table is // supported by writing a non-standard string table, but this string table is
// not mapped at runtime and the long names will therefore be inaccessible. // not mapped at runtime and the long names will therefore be inaccessible.
// link.exe always truncates section names to 8 bytes, whereas binutils always // link.exe always truncates section names to 8 bytes, whereas binutils always
// preserves long section names via the string table. LLD adopts a hybrid // preserves long section names via the string table. LLD adopts a hybrid
// solution where discardable sections have long names preserved and // solution where discardable sections have long names preserved and
// non-discardable sections have their names truncated, to ensure that any // non-discardable sections have their names truncated, to ensure that any
// section which is mapped at runtime also has its name mapped at runtime. // section which is mapped at runtime also has its name mapped at runtime.
for (OutputSection *Sec : OutputSections) { for (OutputSection *sec : outputSections) {
if (Sec->Name.size() <= COFF::NameSize) if (sec->name.size() <= COFF::NameSize)
continue; continue;
if ((Sec->Header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0) if ((sec->header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0)
continue; continue;
Sec->setStringTableOff(addEntryToStringTable(Sec->Name)); sec->setStringTableOff(addEntryToStringTable(sec->name));
} }
if (Config->DebugDwarf || Config->DebugSymtab) { if (config->debugDwarf || config->debugSymtab) {
for (ObjFile *File : ObjFile::Instances) { for (ObjFile *file : ObjFile::instances) {
for (Symbol *B : File->getSymbols()) { for (Symbol *b : file->getSymbols()) {
auto *D = dyn_cast_or_null<Defined>(B); auto *d = dyn_cast_or_null<Defined>(b);
if (!D || D->WrittenToSymtab) if (!d || d->writtenToSymtab)
continue; continue;
D->WrittenToSymtab = true; d->writtenToSymtab = true;
if (Optional<coff_symbol16> Sym = createSymbol(D)) if (Optional<coff_symbol16> sym = createSymbol(d))
OutputSymtab.push_back(*Sym); outputSymtab.push_back(*sym);
} }
} }
} }
if (OutputSymtab.empty() && Strtab.empty()) if (outputSymtab.empty() && strtab.empty())
return; return;
// We position the symbol table to be adjacent to the end of the last section. // We position the symbol table to be adjacent to the end of the last section.
uint64_t FileOff = FileSize; uint64_t fileOff = fileSize;
PointerToSymbolTable = FileOff; pointerToSymbolTable = fileOff;
FileOff += OutputSymtab.size() * sizeof(coff_symbol16); fileOff += outputSymtab.size() * sizeof(coff_symbol16);
FileOff += 4 + Strtab.size(); fileOff += 4 + strtab.size();
FileSize = alignTo(FileOff, Config->FileAlign); fileSize = alignTo(fileOff, config->fileAlign);
} }
void Writer::mergeSections() { void Writer::mergeSections() {
if (!PdataSec->Chunks.empty()) { if (!pdataSec->chunks.empty()) {
FirstPdata = PdataSec->Chunks.front(); firstPdata = pdataSec->chunks.front();
LastPdata = PdataSec->Chunks.back(); lastPdata = pdataSec->chunks.back();
} }
for (auto &P : Config->Merge) { for (auto &p : config->merge) {
StringRef ToName = P.second; StringRef toName = p.second;
if (P.first == ToName) if (p.first == toName)
continue; continue;
StringSet<> Names; StringSet<> names;
while (1) { while (1) {
if (!Names.insert(ToName).second) if (!names.insert(toName).second)
fatal("/merge: cycle found for section '" + P.first + "'"); fatal("/merge: cycle found for section '" + p.first + "'");
auto I = Config->Merge.find(ToName); auto i = config->merge.find(toName);
if (I == Config->Merge.end()) if (i == config->merge.end())
break; break;
ToName = I->second; toName = i->second;
} }
OutputSection *From = findSection(P.first); OutputSection *from = findSection(p.first);
OutputSection *To = findSection(ToName); OutputSection *to = findSection(toName);
if (!From) if (!from)
continue; continue;
if (!To) { if (!to) {
From->Name = ToName; from->name = toName;
continue; continue;
} }
To->merge(From); to->merge(from);
} }
} }
// Visits all sections to assign incremental, non-overlapping RVAs and // Visits all sections to assign incremental, non-overlapping RVAs and
// file offsets. // file offsets.
void Writer::assignAddresses() { void Writer::assignAddresses() {
SizeOfHeaders = DOSStubSize + sizeof(PEMagic) + sizeof(coff_file_header) + sizeOfHeaders = dosStubSize + sizeof(PEMagic) + sizeof(coff_file_header) +
sizeof(data_directory) * NumberOfDataDirectory + sizeof(data_directory) * numberOfDataDirectory +
sizeof(coff_section) * OutputSections.size(); sizeof(coff_section) * outputSections.size();
SizeOfHeaders += sizeOfHeaders +=
Config->is64() ? sizeof(pe32plus_header) : sizeof(pe32_header); config->is64() ? sizeof(pe32plus_header) : sizeof(pe32_header);
SizeOfHeaders = alignTo(SizeOfHeaders, Config->FileAlign); sizeOfHeaders = alignTo(sizeOfHeaders, config->fileAlign);
uint64_t RVA = PageSize; // The first page is kept unmapped. uint64_t rva = pageSize; // The first page is kept unmapped.
FileSize = SizeOfHeaders; fileSize = sizeOfHeaders;
for (OutputSection *Sec : OutputSections) { for (OutputSection *sec : outputSections) {
if (Sec == RelocSec) if (sec == relocSec)
addBaserels(); addBaserels();
uint64_t RawSize = 0, VirtualSize = 0; uint64_t rawSize = 0, virtualSize = 0;
Sec->Header.VirtualAddress = RVA; sec->header.VirtualAddress = rva;
// If /FUNCTIONPADMIN is used, functions are padded in order to create a // If /FUNCTIONPADMIN is used, functions are padded in order to create a
// hotpatchable image. // hotpatchable image.
const bool IsCodeSection = const bool isCodeSection =
(Sec->Header.Characteristics & IMAGE_SCN_CNT_CODE) && (sec->header.Characteristics & IMAGE_SCN_CNT_CODE) &&
(Sec->Header.Characteristics & IMAGE_SCN_MEM_READ) && (sec->header.Characteristics & IMAGE_SCN_MEM_READ) &&
(Sec->Header.Characteristics & IMAGE_SCN_MEM_EXECUTE); (sec->header.Characteristics & IMAGE_SCN_MEM_EXECUTE);
uint32_t Padding = IsCodeSection ? Config->FunctionPadMin : 0; uint32_t padding = isCodeSection ? config->functionPadMin : 0;
for (Chunk *C : Sec->Chunks) { for (Chunk *c : sec->chunks) {
if (Padding && C->isHotPatchable()) if (padding && c->isHotPatchable())
VirtualSize += Padding; virtualSize += padding;
VirtualSize = alignTo(VirtualSize, C->getAlignment()); virtualSize = alignTo(virtualSize, c->getAlignment());
C->setRVA(RVA + VirtualSize); c->setRVA(rva + virtualSize);
VirtualSize += C->getSize(); virtualSize += c->getSize();
if (C->HasData) if (c->hasData)
RawSize = alignTo(VirtualSize, Config->FileAlign); rawSize = alignTo(virtualSize, config->fileAlign);
} }
if (VirtualSize > UINT32_MAX) if (virtualSize > UINT32_MAX)
error("section larger than 4 GiB: " + Sec->Name); error("section larger than 4 GiB: " + sec->name);
Sec->Header.VirtualSize = VirtualSize; sec->header.VirtualSize = virtualSize;
Sec->Header.SizeOfRawData = RawSize; sec->header.SizeOfRawData = rawSize;
if (RawSize != 0) if (rawSize != 0)
Sec->Header.PointerToRawData = FileSize; sec->header.PointerToRawData = fileSize;
RVA += alignTo(VirtualSize, PageSize); rva += alignTo(virtualSize, pageSize);
FileSize += alignTo(RawSize, Config->FileAlign); fileSize += alignTo(rawSize, config->fileAlign);
} }
SizeOfImage = alignTo(RVA, PageSize); sizeOfImage = alignTo(rva, pageSize);
// Assign addresses to sections in MergeChunks. // Assign addresses to sections in MergeChunks.
for (MergeChunk *MC : MergeChunk::Instances) for (MergeChunk *mc : MergeChunk::instances)
if (MC) if (mc)
MC->assignSubsectionRVAs(); mc->assignSubsectionRVAs();
} }
template <typename PEHeaderTy> void Writer::writeHeader() { template <typename PEHeaderTy> void Writer::writeHeader() {
// Write DOS header. For backwards compatibility, the first part of a PE/COFF // Write DOS header. For backwards compatibility, the first part of a PE/COFF
// executable consists of an MS-DOS MZ executable. If the executable is run // executable consists of an MS-DOS MZ executable. If the executable is run
// under DOS, that program gets run (usually to just print an error message). // under DOS, that program gets run (usually to just print an error message).
// When run under Windows, the loader looks at AddressOfNewExeHeader and uses // When run under Windows, the loader looks at AddressOfNewExeHeader and uses
// the PE header instead. // the PE header instead.
uint8_t *Buf = Buffer->getBufferStart(); uint8_t *buf = buffer->getBufferStart();
auto *DOS = reinterpret_cast<dos_header *>(Buf); auto *dos = reinterpret_cast<dos_header *>(buf);
Buf += sizeof(dos_header); buf += sizeof(dos_header);
DOS->Magic[0] = 'M'; dos->Magic[0] = 'M';
DOS->Magic[1] = 'Z'; dos->Magic[1] = 'Z';
DOS->UsedBytesInTheLastPage = DOSStubSize % 512; dos->UsedBytesInTheLastPage = dosStubSize % 512;
DOS->FileSizeInPages = divideCeil(DOSStubSize, 512); dos->FileSizeInPages = divideCeil(dosStubSize, 512);
DOS->HeaderSizeInParagraphs = sizeof(dos_header) / 16; dos->HeaderSizeInParagraphs = sizeof(dos_header) / 16;
DOS->AddressOfRelocationTable = sizeof(dos_header); dos->AddressOfRelocationTable = sizeof(dos_header);
DOS->AddressOfNewExeHeader = DOSStubSize; dos->AddressOfNewExeHeader = dosStubSize;
// Write DOS program. // Write DOS program.
memcpy(Buf, DOSProgram, sizeof(DOSProgram)); memcpy(buf, dosProgram, sizeof(dosProgram));
Buf += sizeof(DOSProgram); buf += sizeof(dosProgram);
// Write PE magic // Write PE magic
memcpy(Buf, PEMagic, sizeof(PEMagic)); memcpy(buf, PEMagic, sizeof(PEMagic));
Buf += sizeof(PEMagic); buf += sizeof(PEMagic);
// Write COFF header // Write COFF header
auto *COFF = reinterpret_cast<coff_file_header *>(Buf); auto *coff = reinterpret_cast<coff_file_header *>(buf);
Buf += sizeof(*COFF); buf += sizeof(*coff);
COFF->Machine = Config->Machine; coff->Machine = config->machine;
COFF->NumberOfSections = OutputSections.size(); coff->NumberOfSections = outputSections.size();
COFF->Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE; coff->Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE;
if (Config->LargeAddressAware) if (config->largeAddressAware)
COFF->Characteristics |= IMAGE_FILE_LARGE_ADDRESS_AWARE; coff->Characteristics |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
if (!Config->is64()) if (!config->is64())
COFF->Characteristics |= IMAGE_FILE_32BIT_MACHINE; coff->Characteristics |= IMAGE_FILE_32BIT_MACHINE;
if (Config->DLL) if (config->dll)
COFF->Characteristics |= IMAGE_FILE_DLL; coff->Characteristics |= IMAGE_FILE_DLL;
if (!Config->Relocatable) if (!config->relocatable)
COFF->Characteristics |= IMAGE_FILE_RELOCS_STRIPPED; coff->Characteristics |= IMAGE_FILE_RELOCS_STRIPPED;
if (Config->SwaprunCD) if (config->swaprunCD)
COFF->Characteristics |= IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP; coff->Characteristics |= IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP;
if (Config->SwaprunNet) if (config->swaprunNet)
COFF->Characteristics |= IMAGE_FILE_NET_RUN_FROM_SWAP; coff->Characteristics |= IMAGE_FILE_NET_RUN_FROM_SWAP;
COFF->SizeOfOptionalHeader = coff->SizeOfOptionalHeader =
sizeof(PEHeaderTy) + sizeof(data_directory) * NumberOfDataDirectory; sizeof(PEHeaderTy) + sizeof(data_directory) * numberOfDataDirectory;
// Write PE header // Write PE header
auto *PE = reinterpret_cast<PEHeaderTy *>(Buf); auto *pe = reinterpret_cast<PEHeaderTy *>(buf);
Buf += sizeof(*PE); buf += sizeof(*pe);
PE->Magic = Config->is64() ? PE32Header::PE32_PLUS : PE32Header::PE32; pe->Magic = config->is64() ? PE32Header::PE32_PLUS : PE32Header::PE32;
// If {Major,Minor}LinkerVersion is left at 0.0, then for some // If {Major,Minor}LinkerVersion is left at 0.0, then for some
// reason signing the resulting PE file with Authenticode produces a // reason signing the resulting PE file with Authenticode produces a
// signature that fails to validate on Windows 7 (but is OK on 10). // signature that fails to validate on Windows 7 (but is OK on 10).
// Set it to 14.0, which is what VS2015 outputs, and which avoids // Set it to 14.0, which is what VS2015 outputs, and which avoids
// that problem. // that problem.
PE->MajorLinkerVersion = 14; pe->MajorLinkerVersion = 14;
PE->MinorLinkerVersion = 0; pe->MinorLinkerVersion = 0;
PE->ImageBase = Config->ImageBase; pe->ImageBase = config->imageBase;
PE->SectionAlignment = PageSize; pe->SectionAlignment = pageSize;
PE->FileAlignment = Config->FileAlign; pe->FileAlignment = config->fileAlign;
PE->MajorImageVersion = Config->MajorImageVersion; pe->MajorImageVersion = config->majorImageVersion;
PE->MinorImageVersion = Config->MinorImageVersion; pe->MinorImageVersion = config->minorImageVersion;
PE->MajorOperatingSystemVersion = Config->MajorOSVersion; pe->MajorOperatingSystemVersion = config->majorOSVersion;
PE->MinorOperatingSystemVersion = Config->MinorOSVersion; pe->MinorOperatingSystemVersion = config->minorOSVersion;
PE->MajorSubsystemVersion = Config->MajorOSVersion; pe->MajorSubsystemVersion = config->majorOSVersion;
PE->MinorSubsystemVersion = Config->MinorOSVersion; pe->MinorSubsystemVersion = config->minorOSVersion;
PE->Subsystem = Config->Subsystem; pe->Subsystem = config->subsystem;
PE->SizeOfImage = SizeOfImage; pe->SizeOfImage = sizeOfImage;
PE->SizeOfHeaders = SizeOfHeaders; pe->SizeOfHeaders = sizeOfHeaders;
if (!Config->NoEntry) { if (!config->noEntry) {
Defined *Entry = cast<Defined>(Config->Entry); Defined *entry = cast<Defined>(config->entry);
PE->AddressOfEntryPoint = Entry->getRVA(); pe->AddressOfEntryPoint = entry->getRVA();
// Pointer to thumb code must have the LSB set, so adjust it. // Pointer to thumb code must have the LSB set, so adjust it.
if (Config->Machine == ARMNT) if (config->machine == ARMNT)
PE->AddressOfEntryPoint |= 1; pe->AddressOfEntryPoint |= 1;
} }
PE->SizeOfStackReserve = Config->StackReserve; pe->SizeOfStackReserve = config->stackReserve;
PE->SizeOfStackCommit = Config->StackCommit; pe->SizeOfStackCommit = config->stackCommit;
PE->SizeOfHeapReserve = Config->HeapReserve; pe->SizeOfHeapReserve = config->heapReserve;
PE->SizeOfHeapCommit = Config->HeapCommit; pe->SizeOfHeapCommit = config->heapCommit;
if (Config->AppContainer) if (config->appContainer)
PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_APPCONTAINER; pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_APPCONTAINER;
if (Config->DynamicBase) if (config->dynamicBase)
PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE; pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE;
if (Config->HighEntropyVA) if (config->highEntropyVA)
PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA; pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA;
if (!Config->AllowBind) if (!config->allowBind)
PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_BIND; pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_BIND;
if (Config->NxCompat) if (config->nxCompat)
PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT; pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
if (!Config->AllowIsolation) if (!config->allowIsolation)
PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_ISOLATION; pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_ISOLATION;
if (Config->GuardCF != GuardCFLevel::Off) if (config->guardCF != GuardCFLevel::Off)
PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_GUARD_CF; pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_GUARD_CF;
if (Config->IntegrityCheck) if (config->integrityCheck)
PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY; pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY;
if (SetNoSEHCharacteristic) if (setNoSEHCharacteristic)
PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_SEH; pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_SEH;
if (Config->TerminalServerAware) if (config->terminalServerAware)
PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE; pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE;
PE->NumberOfRvaAndSize = NumberOfDataDirectory; pe->NumberOfRvaAndSize = numberOfDataDirectory;
if (TextSec->getVirtualSize()) { if (textSec->getVirtualSize()) {
PE->BaseOfCode = TextSec->getRVA(); pe->BaseOfCode = textSec->getRVA();
PE->SizeOfCode = TextSec->getRawSize(); pe->SizeOfCode = textSec->getRawSize();
} }
PE->SizeOfInitializedData = getSizeOfInitializedData(); pe->SizeOfInitializedData = getSizeOfInitializedData();
// Write data directory // Write data directory
auto *Dir = reinterpret_cast<data_directory *>(Buf); auto *dir = reinterpret_cast<data_directory *>(buf);
Buf += sizeof(*Dir) * NumberOfDataDirectory; buf += sizeof(*dir) * numberOfDataDirectory;
if (!Config->Exports.empty()) { if (!config->exports.empty()) {
Dir[EXPORT_TABLE].RelativeVirtualAddress = Edata.getRVA(); dir[EXPORT_TABLE].RelativeVirtualAddress = edata.getRVA();
Dir[EXPORT_TABLE].Size = Edata.getSize(); dir[EXPORT_TABLE].Size = edata.getSize();
} }
if (ImportTableStart) { if (importTableStart) {
Dir[IMPORT_TABLE].RelativeVirtualAddress = ImportTableStart->getRVA(); dir[IMPORT_TABLE].RelativeVirtualAddress = importTableStart->getRVA();
Dir[IMPORT_TABLE].Size = ImportTableSize; dir[IMPORT_TABLE].Size = importTableSize;
} }
if (IATStart) { if (iatStart) {
Dir[IAT].RelativeVirtualAddress = IATStart->getRVA(); dir[IAT].RelativeVirtualAddress = iatStart->getRVA();
Dir[IAT].Size = IATSize; dir[IAT].Size = iatSize;
} }
if (RsrcSec->getVirtualSize()) { if (rsrcSec->getVirtualSize()) {
Dir[RESOURCE_TABLE].RelativeVirtualAddress = RsrcSec->getRVA(); dir[RESOURCE_TABLE].RelativeVirtualAddress = rsrcSec->getRVA();
Dir[RESOURCE_TABLE].Size = RsrcSec->getVirtualSize(); dir[RESOURCE_TABLE].Size = rsrcSec->getVirtualSize();
} }
if (FirstPdata) { if (firstPdata) {
Dir[EXCEPTION_TABLE].RelativeVirtualAddress = FirstPdata->getRVA(); dir[EXCEPTION_TABLE].RelativeVirtualAddress = firstPdata->getRVA();
Dir[EXCEPTION_TABLE].Size = dir[EXCEPTION_TABLE].Size =
LastPdata->getRVA() + LastPdata->getSize() - FirstPdata->getRVA(); lastPdata->getRVA() + lastPdata->getSize() - firstPdata->getRVA();
} }
if (RelocSec->getVirtualSize()) { if (relocSec->getVirtualSize()) {
Dir[BASE_RELOCATION_TABLE].RelativeVirtualAddress = RelocSec->getRVA(); dir[BASE_RELOCATION_TABLE].RelativeVirtualAddress = relocSec->getRVA();
Dir[BASE_RELOCATION_TABLE].Size = RelocSec->getVirtualSize(); dir[BASE_RELOCATION_TABLE].Size = relocSec->getVirtualSize();
} }
if (Symbol *Sym = Symtab->findUnderscore("_tls_used")) { if (Symbol *sym = symtab->findUnderscore("_tls_used")) {
if (Defined *B = dyn_cast<Defined>(Sym)) { if (Defined *b = dyn_cast<Defined>(sym)) {
Dir[TLS_TABLE].RelativeVirtualAddress = B->getRVA(); dir[TLS_TABLE].RelativeVirtualAddress = b->getRVA();
Dir[TLS_TABLE].Size = Config->is64() dir[TLS_TABLE].Size = config->is64()
? sizeof(object::coff_tls_directory64) ? sizeof(object::coff_tls_directory64)
: sizeof(object::coff_tls_directory32); : sizeof(object::coff_tls_directory32);
} }
} }
if (DebugDirectory) { if (debugDirectory) {
Dir[DEBUG_DIRECTORY].RelativeVirtualAddress = DebugDirectory->getRVA(); dir[DEBUG_DIRECTORY].RelativeVirtualAddress = debugDirectory->getRVA();
Dir[DEBUG_DIRECTORY].Size = DebugDirectory->getSize(); dir[DEBUG_DIRECTORY].Size = debugDirectory->getSize();
} }
if (Symbol *Sym = Symtab->findUnderscore("_load_config_used")) { if (Symbol *sym = symtab->findUnderscore("_load_config_used")) {
if (auto *B = dyn_cast<DefinedRegular>(Sym)) { if (auto *b = dyn_cast<DefinedRegular>(sym)) {
SectionChunk *SC = B->getChunk(); SectionChunk *sc = b->getChunk();
assert(B->getRVA() >= SC->getRVA()); assert(b->getRVA() >= sc->getRVA());
uint64_t OffsetInChunk = B->getRVA() - SC->getRVA(); uint64_t offsetInChunk = b->getRVA() - sc->getRVA();
if (!SC->HasData || OffsetInChunk + 4 > SC->getSize()) if (!sc->hasData || offsetInChunk + 4 > sc->getSize())
fatal("_load_config_used is malformed"); fatal("_load_config_used is malformed");
ArrayRef<uint8_t> SecContents = SC->getContents(); ArrayRef<uint8_t> secContents = sc->getContents();
uint32_t LoadConfigSize = uint32_t loadConfigSize =
*reinterpret_cast<const ulittle32_t *>(&SecContents[OffsetInChunk]); *reinterpret_cast<const ulittle32_t *>(&secContents[offsetInChunk]);
if (OffsetInChunk + LoadConfigSize > SC->getSize()) if (offsetInChunk + loadConfigSize > sc->getSize())
fatal("_load_config_used is too large"); fatal("_load_config_used is too large");
Dir[LOAD_CONFIG_TABLE].RelativeVirtualAddress = B->getRVA(); dir[LOAD_CONFIG_TABLE].RelativeVirtualAddress = b->getRVA();
Dir[LOAD_CONFIG_TABLE].Size = LoadConfigSize; dir[LOAD_CONFIG_TABLE].Size = loadConfigSize;
} }
} }
if (!DelayIdata.empty()) { if (!delayIdata.empty()) {
Dir[DELAY_IMPORT_DESCRIPTOR].RelativeVirtualAddress = dir[DELAY_IMPORT_DESCRIPTOR].RelativeVirtualAddress =
DelayIdata.getDirRVA(); delayIdata.getDirRVA();
Dir[DELAY_IMPORT_DESCRIPTOR].Size = DelayIdata.getDirSize(); dir[DELAY_IMPORT_DESCRIPTOR].Size = delayIdata.getDirSize();
} }
// Write section table // Write section table
for (OutputSection *Sec : OutputSections) { for (OutputSection *sec : outputSections) {
Sec->writeHeaderTo(Buf); sec->writeHeaderTo(buf);
Buf += sizeof(coff_section); buf += sizeof(coff_section);
} }
SectionTable = ArrayRef<uint8_t>( sectionTable = ArrayRef<uint8_t>(
Buf - OutputSections.size() * sizeof(coff_section), Buf); buf - outputSections.size() * sizeof(coff_section), buf);
if (OutputSymtab.empty() && Strtab.empty()) if (outputSymtab.empty() && strtab.empty())
return; return;
COFF->PointerToSymbolTable = PointerToSymbolTable; coff->PointerToSymbolTable = pointerToSymbolTable;
uint32_t NumberOfSymbols = OutputSymtab.size(); uint32_t numberOfSymbols = outputSymtab.size();
COFF->NumberOfSymbols = NumberOfSymbols; coff->NumberOfSymbols = numberOfSymbols;
auto *SymbolTable = reinterpret_cast<coff_symbol16 *>( auto *symbolTable = reinterpret_cast<coff_symbol16 *>(
Buffer->getBufferStart() + COFF->PointerToSymbolTable); buffer->getBufferStart() + coff->PointerToSymbolTable);
for (size_t I = 0; I != NumberOfSymbols; ++I) for (size_t i = 0; i != numberOfSymbols; ++i)
SymbolTable[I] = OutputSymtab[I]; symbolTable[i] = outputSymtab[i];
// Create the string table, it follows immediately after the symbol table. // Create the string table, it follows immediately after the symbol table.
// The first 4 bytes is length including itself. // The first 4 bytes is length including itself.
Buf = reinterpret_cast<uint8_t *>(&SymbolTable[NumberOfSymbols]); buf = reinterpret_cast<uint8_t *>(&symbolTable[numberOfSymbols]);
write32le(Buf, Strtab.size() + 4); write32le(buf, strtab.size() + 4);
if (!Strtab.empty()) if (!strtab.empty())
memcpy(Buf + 4, Strtab.data(), Strtab.size()); memcpy(buf + 4, strtab.data(), strtab.size());
} }
void Writer::openFile(StringRef Path) { void Writer::openFile(StringRef path) {
Buffer = CHECK( buffer = CHECK(
FileOutputBuffer::create(Path, FileSize, FileOutputBuffer::F_executable), FileOutputBuffer::create(path, fileSize, FileOutputBuffer::F_executable),
"failed to open " + Path); "failed to open " + path);
} }
void Writer::createSEHTable() { void Writer::createSEHTable() {
// Set the no SEH characteristic on x86 binaries unless we find exception // Set the no SEH characteristic on x86 binaries unless we find exception
// handlers. // handlers.
SetNoSEHCharacteristic = true; setNoSEHCharacteristic = true;
SymbolRVASet Handlers; SymbolRVASet handlers;
for (ObjFile *File : ObjFile::Instances) { for (ObjFile *file : ObjFile::instances) {
// FIXME: We should error here instead of earlier unless /safeseh:no was // FIXME: We should error here instead of earlier unless /safeseh:no was
// passed. // passed.
if (!File->hasSafeSEH()) if (!file->hasSafeSEH())
return; return;
markSymbolsForRVATable(File, File->getSXDataChunks(), Handlers); markSymbolsForRVATable(file, file->getSXDataChunks(), handlers);
} }
// Remove the "no SEH" characteristic if all object files were built with // Remove the "no SEH" characteristic if all object files were built with
// safeseh, we found some exception handlers, and there is a load config in // safeseh, we found some exception handlers, and there is a load config in
// the object. // the object.
SetNoSEHCharacteristic = setNoSEHCharacteristic =
Handlers.empty() || !Symtab->findUnderscore("_load_config_used"); handlers.empty() || !symtab->findUnderscore("_load_config_used");
maybeAddRVATable(std::move(Handlers), "__safe_se_handler_table", maybeAddRVATable(std::move(handlers), "__safe_se_handler_table",
"__safe_se_handler_count"); "__safe_se_handler_count");
} }
// Add a symbol to an RVA set. Two symbols may have the same RVA, but an RVA set // Add a symbol to an RVA set. Two symbols may have the same RVA, but an RVA set
// cannot contain duplicates. Therefore, the set is uniqued by Chunk and the // cannot contain duplicates. Therefore, the set is uniqued by Chunk and the
// symbol's offset into that Chunk. // symbol's offset into that Chunk.
static void addSymbolToRVASet(SymbolRVASet &RVASet, Defined *S) { static void addSymbolToRVASet(SymbolRVASet &rvaSet, Defined *s) {
Chunk *C = S->getChunk(); Chunk *c = s->getChunk();
if (auto *SC = dyn_cast<SectionChunk>(C)) if (auto *sc = dyn_cast<SectionChunk>(c))
C = SC->Repl; // Look through ICF replacement. c = sc->repl; // Look through ICF replacement.
uint32_t Off = S->getRVA() - (C ? C->getRVA() : 0); uint32_t off = s->getRVA() - (c ? c->getRVA() : 0);
RVASet.insert({C, Off}); rvaSet.insert({c, off});
} }
// Given a symbol, add it to the GFIDs table if it is a live, defined, function // Given a symbol, add it to the GFIDs table if it is a live, defined, function
// symbol in an executable section. // symbol in an executable section.
static void maybeAddAddressTakenFunction(SymbolRVASet &AddressTakenSyms, static void maybeAddAddressTakenFunction(SymbolRVASet &addressTakenSyms,
Symbol *S) { Symbol *s) {
if (!S) if (!s)
return; return;
switch (S->kind()) { switch (s->kind()) {
case Symbol::DefinedLocalImportKind: case Symbol::DefinedLocalImportKind:
case Symbol::DefinedImportDataKind: case Symbol::DefinedImportDataKind:
// Defines an __imp_ pointer, so it is data, so it is ignored. // Defines an __imp_ pointer, so it is data, so it is ignored.
break; break;
case Symbol::DefinedCommonKind: case Symbol::DefinedCommonKind:
// Common is always data, so it is ignored. // Common is always data, so it is ignored.
break; break;
case Symbol::DefinedAbsoluteKind: case Symbol::DefinedAbsoluteKind:
case Symbol::DefinedSyntheticKind: case Symbol::DefinedSyntheticKind:
// Absolute is never code, synthetic generally isn't and usually isn't // Absolute is never code, synthetic generally isn't and usually isn't
// determinable. // determinable.
break; break;
case Symbol::LazyKind: case Symbol::LazyKind:
case Symbol::UndefinedKind: case Symbol::UndefinedKind:
// Undefined symbols resolve to zero, so they don't have an RVA. Lazy // Undefined symbols resolve to zero, so they don't have an RVA. Lazy
// symbols shouldn't have relocations. // symbols shouldn't have relocations.
break; break;
case Symbol::DefinedImportThunkKind: case Symbol::DefinedImportThunkKind:
// Thunks are always code, include them. // Thunks are always code, include them.
addSymbolToRVASet(AddressTakenSyms, cast<Defined>(S)); addSymbolToRVASet(addressTakenSyms, cast<Defined>(s));
break; break;
case Symbol::DefinedRegularKind: { case Symbol::DefinedRegularKind: {
// This is a regular, defined, symbol from a COFF file. Mark the symbol as // This is a regular, defined, symbol from a COFF file. Mark the symbol as
// address taken if the symbol type is function and it's in an executable // address taken if the symbol type is function and it's in an executable
// section. // section.
auto *D = cast<DefinedRegular>(S); auto *d = cast<DefinedRegular>(s);
if (D->getCOFFSymbol().getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION) { if (d->getCOFFSymbol().getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION) {
SectionChunk *SC = dyn_cast<SectionChunk>(D->getChunk()); SectionChunk *sc = dyn_cast<SectionChunk>(d->getChunk());
if (SC && SC->Live && if (sc && sc->live &&
SC->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE) sc->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE)
addSymbolToRVASet(AddressTakenSyms, D); addSymbolToRVASet(addressTakenSyms, d);
} }
break; break;
} }
} }
} }
// Visit all relocations from all section contributions of this object file and // Visit all relocations from all section contributions of this object file and
// mark the relocation target as address-taken. // mark the relocation target as address-taken.
static void markSymbolsWithRelocations(ObjFile *File, static void markSymbolsWithRelocations(ObjFile *file,
SymbolRVASet &UsedSymbols) { SymbolRVASet &usedSymbols) {
for (Chunk *C : File->getChunks()) { for (Chunk *c : file->getChunks()) {
// We only care about live section chunks. Common chunks and other chunks // We only care about live section chunks. Common chunks and other chunks
// don't generally contain relocations. // don't generally contain relocations.
SectionChunk *SC = dyn_cast<SectionChunk>(C); SectionChunk *sc = dyn_cast<SectionChunk>(c);
if (!SC || !SC->Live) if (!sc || !sc->live)
continue; continue;
for (const coff_relocation &Reloc : SC->getRelocs()) { for (const coff_relocation &reloc : sc->getRelocs()) {
if (Config->Machine == I386 && Reloc.Type == COFF::IMAGE_REL_I386_REL32) if (config->machine == I386 && reloc.Type == COFF::IMAGE_REL_I386_REL32)
// Ignore relative relocations on x86. On x86_64 they can't be ignored // Ignore relative relocations on x86. On x86_64 they can't be ignored
// since they're also used to compute absolute addresses. // since they're also used to compute absolute addresses.
continue; continue;
Symbol *Ref = SC->File->getSymbol(Reloc.SymbolTableIndex); Symbol *ref = sc->file->getSymbol(reloc.SymbolTableIndex);
maybeAddAddressTakenFunction(UsedSymbols, Ref); maybeAddAddressTakenFunction(usedSymbols, ref);
} }
} }
} }
// Create the guard function id table. This is a table of RVAs of all // Create the guard function id table. This is a table of RVAs of all
// address-taken functions. It is sorted and uniqued, just like the safe SEH // address-taken functions. It is sorted and uniqued, just like the safe SEH
// table. // table.
void Writer::createGuardCFTables() { void Writer::createGuardCFTables() {
SymbolRVASet AddressTakenSyms; SymbolRVASet addressTakenSyms;
SymbolRVASet LongJmpTargets; SymbolRVASet longJmpTargets;
for (ObjFile *File : ObjFile::Instances) { for (ObjFile *file : ObjFile::instances) {
// If the object was compiled with /guard:cf, the address taken symbols // If the object was compiled with /guard:cf, the address taken symbols
// are in .gfids$y sections, and the longjmp targets are in .gljmp$y // are in .gfids$y sections, and the longjmp targets are in .gljmp$y
// sections. If the object was not compiled with /guard:cf, we assume there // sections. If the object was not compiled with /guard:cf, we assume there
// were no setjmp targets, and that all code symbols with relocations are // were no setjmp targets, and that all code symbols with relocations are
// possibly address-taken. // possibly address-taken.
if (File->hasGuardCF()) { if (file->hasGuardCF()) {
markSymbolsForRVATable(File, File->getGuardFidChunks(), AddressTakenSyms); markSymbolsForRVATable(file, file->getGuardFidChunks(), addressTakenSyms);
markSymbolsForRVATable(File, File->getGuardLJmpChunks(), LongJmpTargets); markSymbolsForRVATable(file, file->getGuardLJmpChunks(), longJmpTargets);
} else { } else {
markSymbolsWithRelocations(File, AddressTakenSyms); markSymbolsWithRelocations(file, addressTakenSyms);
} }
} }
// Mark the image entry as address-taken. // Mark the image entry as address-taken.
if (Config->Entry) if (config->entry)
maybeAddAddressTakenFunction(AddressTakenSyms, Config->Entry); maybeAddAddressTakenFunction(addressTakenSyms, config->entry);
// Mark exported symbols in executable sections as address-taken. // Mark exported symbols in executable sections as address-taken.
for (Export &E : Config->Exports) for (Export &e : config->exports)
maybeAddAddressTakenFunction(AddressTakenSyms, E.Sym); maybeAddAddressTakenFunction(addressTakenSyms, e.sym);
// Ensure sections referenced in the gfid table are 16-byte aligned. // Ensure sections referenced in the gfid table are 16-byte aligned.
for (const ChunkAndOffset &C : AddressTakenSyms) for (const ChunkAndOffset &c : addressTakenSyms)
if (C.InputChunk->getAlignment() < 16) if (c.inputChunk->getAlignment() < 16)
C.InputChunk->setAlignment(16); c.inputChunk->setAlignment(16);
maybeAddRVATable(std::move(AddressTakenSyms), "__guard_fids_table", maybeAddRVATable(std::move(addressTakenSyms), "__guard_fids_table",
"__guard_fids_count"); "__guard_fids_count");
// Add the longjmp target table unless the user told us not to. // Add the longjmp target table unless the user told us not to.
if (Config->GuardCF == GuardCFLevel::Full) if (config->guardCF == GuardCFLevel::Full)
maybeAddRVATable(std::move(LongJmpTargets), "__guard_longjmp_table", maybeAddRVATable(std::move(longJmpTargets), "__guard_longjmp_table",
"__guard_longjmp_count"); "__guard_longjmp_count");
// Set __guard_flags, which will be used in the load config to indicate that // Set __guard_flags, which will be used in the load config to indicate that
// /guard:cf was enabled. // /guard:cf was enabled.
uint32_t GuardFlags = uint32_t(coff_guard_flags::CFInstrumented) | uint32_t guardFlags = uint32_t(coff_guard_flags::CFInstrumented) |
uint32_t(coff_guard_flags::HasFidTable); uint32_t(coff_guard_flags::HasFidTable);
if (Config->GuardCF == GuardCFLevel::Full) if (config->guardCF == GuardCFLevel::Full)
GuardFlags |= uint32_t(coff_guard_flags::HasLongJmpTable); guardFlags |= uint32_t(coff_guard_flags::HasLongJmpTable);
Symbol *FlagSym = Symtab->findUnderscore("__guard_flags"); Symbol *flagSym = symtab->findUnderscore("__guard_flags");
cast<DefinedAbsolute>(FlagSym)->setVA(GuardFlags); cast<DefinedAbsolute>(flagSym)->setVA(guardFlags);
} }
// Take a list of input sections containing symbol table indices and add those // Take a list of input sections containing symbol table indices and add those
// symbols to an RVA table. The challenge is that symbol RVAs are not known and // symbols to an RVA table. The challenge is that symbol RVAs are not known and
// depend on the table size, so we can't directly build a set of integers. // depend on the table size, so we can't directly build a set of integers.
void Writer::markSymbolsForRVATable(ObjFile *File, void Writer::markSymbolsForRVATable(ObjFile *file,
ArrayRef<SectionChunk *> SymIdxChunks, ArrayRef<SectionChunk *> symIdxChunks,
SymbolRVASet &TableSymbols) { SymbolRVASet &tableSymbols) {
for (SectionChunk *C : SymIdxChunks) { for (SectionChunk *c : symIdxChunks) {
// Skip sections discarded by linker GC. This comes up when a .gfids section // Skip sections discarded by linker GC. This comes up when a .gfids section
// is associated with something like a vtable and the vtable is discarded. // is associated with something like a vtable and the vtable is discarded.
// In this case, the associated gfids section is discarded, and we don't // In this case, the associated gfids section is discarded, and we don't
// mark the virtual member functions as address-taken by the vtable. // mark the virtual member functions as address-taken by the vtable.
if (!C->Live) if (!c->live)
continue; continue;
// Validate that the contents look like symbol table indices. // Validate that the contents look like symbol table indices.
ArrayRef<uint8_t> Data = C->getContents(); ArrayRef<uint8_t> data = c->getContents();
if (Data.size() % 4 != 0) { if (data.size() % 4 != 0) {
warn("ignoring " + C->getSectionName() + warn("ignoring " + c->getSectionName() +
" symbol table index section in object " + toString(File)); " symbol table index section in object " + toString(file));
continue; continue;
} }
// Read each symbol table index and check if that symbol was included in the // Read each symbol table index and check if that symbol was included in the
// final link. If so, add it to the table symbol set. // final link. If so, add it to the table symbol set.
ArrayRef<ulittle32_t> SymIndices( ArrayRef<ulittle32_t> symIndices(
reinterpret_cast<const ulittle32_t *>(Data.data()), Data.size() / 4); reinterpret_cast<const ulittle32_t *>(data.data()), data.size() / 4);
ArrayRef<Symbol *> ObjSymbols = File->getSymbols(); ArrayRef<Symbol *> objSymbols = file->getSymbols();
for (uint32_t SymIndex : SymIndices) { for (uint32_t symIndex : symIndices) {
if (SymIndex >= ObjSymbols.size()) { if (symIndex >= objSymbols.size()) {
warn("ignoring invalid symbol table index in section " + warn("ignoring invalid symbol table index in section " +
C->getSectionName() + " in object " + toString(File)); c->getSectionName() + " in object " + toString(file));
continue; continue;
} }
if (Symbol *S = ObjSymbols[SymIndex]) { if (Symbol *s = objSymbols[symIndex]) {
if (S->isLive()) if (s->isLive())
addSymbolToRVASet(TableSymbols, cast<Defined>(S)); addSymbolToRVASet(tableSymbols, cast<Defined>(s));
} }
} }
} }
} }
// Replace the absolute table symbol with a synthetic symbol pointing to // Replace the absolute table symbol with a synthetic symbol pointing to
// TableChunk so that we can emit base relocations for it and resolve section // TableChunk so that we can emit base relocations for it and resolve section
// relative relocations. // relative relocations.
void Writer::maybeAddRVATable(SymbolRVASet TableSymbols, StringRef TableSym, void Writer::maybeAddRVATable(SymbolRVASet tableSymbols, StringRef tableSym,
StringRef CountSym) { StringRef countSym) {
if (TableSymbols.empty()) if (tableSymbols.empty())
return; return;
RVATableChunk *TableChunk = make<RVATableChunk>(std::move(TableSymbols)); RVATableChunk *tableChunk = make<RVATableChunk>(std::move(tableSymbols));
RdataSec->addChunk(TableChunk); rdataSec->addChunk(tableChunk);
Symbol *T = Symtab->findUnderscore(TableSym); Symbol *t = symtab->findUnderscore(tableSym);
Symbol *C = Symtab->findUnderscore(CountSym); Symbol *c = symtab->findUnderscore(countSym);
replaceSymbol<DefinedSynthetic>(T, T->getName(), TableChunk); replaceSymbol<DefinedSynthetic>(t, t->getName(), tableChunk);
cast<DefinedAbsolute>(C)->setVA(TableChunk->getSize() / 4); cast<DefinedAbsolute>(c)->setVA(tableChunk->getSize() / 4);
} }
// MinGW specific. Gather all relocations that are imported from a DLL even // MinGW specific. Gather all relocations that are imported from a DLL even
// though the code didn't expect it to, produce the table that the runtime // though the code didn't expect it to, produce the table that the runtime
// uses for fixing them up, and provide the synthetic symbols that the // uses for fixing them up, and provide the synthetic symbols that the
// runtime uses for finding the table. // runtime uses for finding the table.
void Writer::createRuntimePseudoRelocs() { void Writer::createRuntimePseudoRelocs() {
std::vector<RuntimePseudoReloc> Rels; std::vector<RuntimePseudoReloc> rels;
for (Chunk *C : Symtab->getChunks()) { for (Chunk *c : symtab->getChunks()) {
auto *SC = dyn_cast<SectionChunk>(C); auto *sc = dyn_cast<SectionChunk>(c);
if (!SC || !SC->Live) if (!sc || !sc->live)
continue; continue;
SC->getRuntimePseudoRelocs(Rels); sc->getRuntimePseudoRelocs(rels);
} }
if (!Rels.empty()) if (!rels.empty())
log("Writing " + Twine(Rels.size()) + " runtime pseudo relocations"); log("Writing " + Twine(rels.size()) + " runtime pseudo relocations");
PseudoRelocTableChunk *Table = make<PseudoRelocTableChunk>(Rels); PseudoRelocTableChunk *table = make<PseudoRelocTableChunk>(rels);
RdataSec->addChunk(Table); rdataSec->addChunk(table);
EmptyChunk *EndOfList = make<EmptyChunk>(); EmptyChunk *endOfList = make<EmptyChunk>();
RdataSec->addChunk(EndOfList); rdataSec->addChunk(endOfList);
Symbol *HeadSym = Symtab->findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST__"); Symbol *headSym = symtab->findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST__");
Symbol *EndSym = Symtab->findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST_END__"); Symbol *endSym = symtab->findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST_END__");
replaceSymbol<DefinedSynthetic>(HeadSym, HeadSym->getName(), Table); replaceSymbol<DefinedSynthetic>(headSym, headSym->getName(), table);
replaceSymbol<DefinedSynthetic>(EndSym, EndSym->getName(), EndOfList); replaceSymbol<DefinedSynthetic>(endSym, endSym->getName(), endOfList);
} }
// MinGW specific. // MinGW specific.
// The MinGW .ctors and .dtors lists have sentinels at each end; // The MinGW .ctors and .dtors lists have sentinels at each end;
// a (uintptr_t)-1 at the start and a (uintptr_t)0 at the end. // a (uintptr_t)-1 at the start and a (uintptr_t)0 at the end.
// There's a symbol pointing to the start sentinel pointer, __CTOR_LIST__ // There's a symbol pointing to the start sentinel pointer, __CTOR_LIST__
// and __DTOR_LIST__ respectively. // and __DTOR_LIST__ respectively.
void Writer::insertCtorDtorSymbols() { void Writer::insertCtorDtorSymbols() {
AbsolutePointerChunk *CtorListHead = make<AbsolutePointerChunk>(-1); AbsolutePointerChunk *ctorListHead = make<AbsolutePointerChunk>(-1);
AbsolutePointerChunk *CtorListEnd = make<AbsolutePointerChunk>(0); AbsolutePointerChunk *ctorListEnd = make<AbsolutePointerChunk>(0);
AbsolutePointerChunk *DtorListHead = make<AbsolutePointerChunk>(-1); AbsolutePointerChunk *dtorListHead = make<AbsolutePointerChunk>(-1);
AbsolutePointerChunk *DtorListEnd = make<AbsolutePointerChunk>(0); AbsolutePointerChunk *dtorListEnd = make<AbsolutePointerChunk>(0);
CtorsSec->insertChunkAtStart(CtorListHead); ctorsSec->insertChunkAtStart(ctorListHead);
CtorsSec->addChunk(CtorListEnd); ctorsSec->addChunk(ctorListEnd);
DtorsSec->insertChunkAtStart(DtorListHead); dtorsSec->insertChunkAtStart(dtorListHead);
DtorsSec->addChunk(DtorListEnd); dtorsSec->addChunk(dtorListEnd);
Symbol *CtorListSym = Symtab->findUnderscore("__CTOR_LIST__"); Symbol *ctorListSym = symtab->findUnderscore("__CTOR_LIST__");
Symbol *DtorListSym = Symtab->findUnderscore("__DTOR_LIST__"); Symbol *dtorListSym = symtab->findUnderscore("__DTOR_LIST__");
replaceSymbol<DefinedSynthetic>(CtorListSym, CtorListSym->getName(), replaceSymbol<DefinedSynthetic>(ctorListSym, ctorListSym->getName(),
CtorListHead); ctorListHead);
replaceSymbol<DefinedSynthetic>(DtorListSym, DtorListSym->getName(), replaceSymbol<DefinedSynthetic>(dtorListSym, dtorListSym->getName(),
DtorListHead); dtorListHead);
} }
// Handles /section options to allow users to overwrite // Handles /section options to allow users to overwrite
// section attributes. // section attributes.
void Writer::setSectionPermissions() { void Writer::setSectionPermissions() {
for (auto &P : Config->Section) { for (auto &p : config->section) {
StringRef Name = P.first; StringRef name = p.first;
uint32_t Perm = P.second; uint32_t perm = p.second;
for (OutputSection *Sec : OutputSections) for (OutputSection *sec : outputSections)
if (Sec->Name == Name) if (sec->name == name)
Sec->setPermissions(Perm); sec->setPermissions(perm);
} }
} }
// Write section contents to a mmap'ed file. // Write section contents to a mmap'ed file.
void Writer::writeSections() { void Writer::writeSections() {
// Record the number of sections to apply section index relocations // Record the number of sections to apply section index relocations
// against absolute symbols. See applySecIdx in Chunks.cpp.. // against absolute symbols. See applySecIdx in Chunks.cpp..
DefinedAbsolute::NumOutputSections = OutputSections.size(); DefinedAbsolute::numOutputSections = outputSections.size();
uint8_t *Buf = Buffer->getBufferStart(); uint8_t *buf = buffer->getBufferStart();
for (OutputSection *Sec : OutputSections) { for (OutputSection *sec : outputSections) {
uint8_t *SecBuf = Buf + Sec->getFileOff(); uint8_t *secBuf = buf + sec->getFileOff();
// Fill gaps between functions in .text with INT3 instructions // Fill gaps between functions in .text with INT3 instructions
// instead of leaving as NUL bytes (which can be interpreted as // instead of leaving as NUL bytes (which can be interpreted as
// ADD instructions). // ADD instructions).
if (Sec->Header.Characteristics & IMAGE_SCN_CNT_CODE) if (sec->header.Characteristics & IMAGE_SCN_CNT_CODE)
memset(SecBuf, 0xCC, Sec->getRawSize()); memset(secBuf, 0xCC, sec->getRawSize());
parallelForEach(Sec->Chunks, [&](Chunk *C) { parallelForEach(sec->chunks, [&](Chunk *c) {
C->writeTo(SecBuf + C->getRVA() - Sec->getRVA()); c->writeTo(secBuf + c->getRVA() - sec->getRVA());
}); });
} }
} }
void Writer::writeBuildId() { void Writer::writeBuildId() {
// There are two important parts to the build ID. // There are two important parts to the build ID.
// 1) If building with debug info, the COFF debug directory contains a // 1) If building with debug info, the COFF debug directory contains a
// timestamp as well as a Guid and Age of the PDB. // timestamp as well as a Guid and Age of the PDB.
// 2) In all cases, the PE COFF file header also contains a timestamp. // 2) In all cases, the PE COFF file header also contains a timestamp.
// For reproducibility, instead of a timestamp we want to use a hash of the // For reproducibility, instead of a timestamp we want to use a hash of the
// PE contents. // PE contents.
if (Config->Debug) { if (config->debug) {
assert(BuildId && "BuildId is not set!"); assert(buildId && "BuildId is not set!");
// BuildId->BuildId was filled in when the PDB was written. // BuildId->BuildId was filled in when the PDB was written.
} }
// At this point the only fields in the COFF file which remain unset are the // At this point the only fields in the COFF file which remain unset are the
// "timestamp" in the COFF file header, and the ones in the coff debug // "timestamp" in the COFF file header, and the ones in the coff debug
// directory. Now we can hash the file and write that hash to the various // directory. Now we can hash the file and write that hash to the various
// timestamp fields in the file. // timestamp fields in the file.
StringRef OutputFileData( StringRef outputFileData(
reinterpret_cast<const char *>(Buffer->getBufferStart()), reinterpret_cast<const char *>(buffer->getBufferStart()),
Buffer->getBufferSize()); buffer->getBufferSize());
uint32_t Timestamp = Config->Timestamp; uint32_t timestamp = config->timestamp;
uint64_t Hash = 0; uint64_t hash = 0;
bool GenerateSyntheticBuildId = bool generateSyntheticBuildId =
Config->MinGW && Config->Debug && Config->PDBPath.empty(); config->mingw && config->debug && config->pdbPath.empty();
if (Config->Repro || GenerateSyntheticBuildId) if (config->repro || generateSyntheticBuildId)
Hash = xxHash64(OutputFileData); hash = xxHash64(outputFileData);
if (Config->Repro) if (config->repro)
Timestamp = static_cast<uint32_t>(Hash); timestamp = static_cast<uint32_t>(hash);
if (GenerateSyntheticBuildId) { if (generateSyntheticBuildId) {
// For MinGW builds without a PDB file, we still generate a build id // For MinGW builds without a PDB file, we still generate a build id
// to allow associating a crash dump to the executable. // to allow associating a crash dump to the executable.
BuildId->BuildId->PDB70.CVSignature = OMF::Signature::PDB70; buildId->buildId->PDB70.CVSignature = OMF::Signature::PDB70;
BuildId->BuildId->PDB70.Age = 1; buildId->buildId->PDB70.Age = 1;
memcpy(BuildId->BuildId->PDB70.Signature, &Hash, 8); memcpy(buildId->buildId->PDB70.Signature, &hash, 8);
// xxhash only gives us 8 bytes, so put some fixed data in the other half. // xxhash only gives us 8 bytes, so put some fixed data in the other half.
memcpy(&BuildId->BuildId->PDB70.Signature[8], "LLD PDB.", 8); memcpy(&buildId->buildId->PDB70.Signature[8], "LLD PDB.", 8);
} }
if (DebugDirectory) if (debugDirectory)
DebugDirectory->setTimeDateStamp(Timestamp); debugDirectory->setTimeDateStamp(timestamp);
uint8_t *Buf = Buffer->getBufferStart(); uint8_t *buf = buffer->getBufferStart();
Buf += DOSStubSize + sizeof(PEMagic); buf += dosStubSize + sizeof(PEMagic);
object::coff_file_header *CoffHeader = object::coff_file_header *coffHeader =
reinterpret_cast<coff_file_header *>(Buf); reinterpret_cast<coff_file_header *>(buf);
CoffHeader->TimeDateStamp = Timestamp; coffHeader->TimeDateStamp = timestamp;
} }
// Sort .pdata section contents according to PE/COFF spec 5.5. // Sort .pdata section contents according to PE/COFF spec 5.5.
void Writer::sortExceptionTable() { void Writer::sortExceptionTable() {
if (!FirstPdata) if (!firstPdata)
return; return;
// We assume .pdata contains function table entries only. // We assume .pdata contains function table entries only.
auto BufAddr = [&](Chunk *C) { auto bufAddr = [&](Chunk *c) {
OutputSection *OS = C->getOutputSection(); OutputSection *os = c->getOutputSection();
return Buffer->getBufferStart() + OS->getFileOff() + C->getRVA() - return buffer->getBufferStart() + os->getFileOff() + c->getRVA() -
OS->getRVA(); os->getRVA();
}; };
uint8_t *Begin = BufAddr(FirstPdata); uint8_t *begin = bufAddr(firstPdata);
uint8_t *End = BufAddr(LastPdata) + LastPdata->getSize(); uint8_t *end = bufAddr(lastPdata) + lastPdata->getSize();
if (Config->Machine == AMD64) { if (config->machine == AMD64) {
struct Entry { ulittle32_t Begin, End, Unwind; }; struct Entry { ulittle32_t begin, end, unwind; };
parallelSort( parallelSort(
MutableArrayRef<Entry>((Entry *)Begin, (Entry *)End), MutableArrayRef<Entry>((Entry *)begin, (Entry *)end),
[](const Entry &A, const Entry &B) { return A.Begin < B.Begin; }); [](const Entry &a, const Entry &b) { return a.begin < b.begin; });
return; return;
} }
if (Config->Machine == ARMNT || Config->Machine == ARM64) { if (config->machine == ARMNT || config->machine == ARM64) {
struct Entry { ulittle32_t Begin, Unwind; }; struct Entry { ulittle32_t begin, unwind; };
parallelSort( parallelSort(
MutableArrayRef<Entry>((Entry *)Begin, (Entry *)End), MutableArrayRef<Entry>((Entry *)begin, (Entry *)end),
[](const Entry &A, const Entry &B) { return A.Begin < B.Begin; }); [](const Entry &a, const Entry &b) { return a.begin < b.begin; });
return; return;
} }
errs() << "warning: don't know how to handle .pdata.\n"; errs() << "warning: don't know how to handle .pdata.\n";
} }
// The CRT section contains, among other things, the array of function // The CRT section contains, among other things, the array of function
// pointers that initialize every global variable that is not trivially // pointers that initialize every global variable that is not trivially
// constructed. The CRT calls them one after the other prior to invoking // constructed. The CRT calls them one after the other prior to invoking
// main(). // main().
// //
// As per C++ spec, 3.6.2/2.3, // As per C++ spec, 3.6.2/2.3,
// "Variables with ordered initialization defined within a single // "Variables with ordered initialization defined within a single
// translation unit shall be initialized in the order of their definitions // translation unit shall be initialized in the order of their definitions
// in the translation unit" // in the translation unit"
// //
// It is therefore critical to sort the chunks containing the function // It is therefore critical to sort the chunks containing the function
// pointers in the order that they are listed in the object file (top to // pointers in the order that they are listed in the object file (top to
// bottom), otherwise global objects might not be initialized in the // bottom), otherwise global objects might not be initialized in the
// correct order. // correct order.
void Writer::sortCRTSectionChunks(std::vector<Chunk *> &Chunks) { void Writer::sortCRTSectionChunks(std::vector<Chunk *> &chunks) {
auto SectionChunkOrder = [](const Chunk *A, const Chunk *B) { auto sectionChunkOrder = [](const Chunk *a, const Chunk *b) {
auto SA = dyn_cast<SectionChunk>(A); auto sa = dyn_cast<SectionChunk>(a);
auto SB = dyn_cast<SectionChunk>(B); auto sb = dyn_cast<SectionChunk>(b);
assert(SA && SB && "Non-section chunks in CRT section!"); assert(sa && sb && "Non-section chunks in CRT section!");
StringRef SAObj = SA->File->MB.getBufferIdentifier(); StringRef sAObj = sa->file->mb.getBufferIdentifier();
StringRef SBObj = SB->File->MB.getBufferIdentifier(); StringRef sBObj = sb->file->mb.getBufferIdentifier();
return SAObj == SBObj && SA->getSectionNumber() < SB->getSectionNumber(); return sAObj == sBObj && sa->getSectionNumber() < sb->getSectionNumber();
}; };
llvm::stable_sort(Chunks, SectionChunkOrder); llvm::stable_sort(chunks, sectionChunkOrder);
if (Config->Verbose) { if (config->verbose) {
for (auto &C : Chunks) { for (auto &c : chunks) {
auto SC = dyn_cast<SectionChunk>(C); auto sc = dyn_cast<SectionChunk>(c);
log(" " + SC->File->MB.getBufferIdentifier().str() + log(" " + sc->file->mb.getBufferIdentifier().str() +
", SectionID: " + Twine(SC->getSectionNumber())); ", SectionID: " + Twine(sc->getSectionNumber()));
} }
} }
} }
OutputSection *Writer::findSection(StringRef Name) { OutputSection *Writer::findSection(StringRef name) {
for (OutputSection *Sec : OutputSections) for (OutputSection *sec : outputSections)
if (Sec->Name == Name) if (sec->name == name)
return Sec; return sec;
return nullptr; return nullptr;
} }
uint32_t Writer::getSizeOfInitializedData() { uint32_t Writer::getSizeOfInitializedData() {
uint32_t Res = 0; uint32_t res = 0;
for (OutputSection *S : OutputSections) for (OutputSection *s : outputSections)
if (S->Header.Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA) if (s->header.Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
Res += S->getRawSize(); res += s->getRawSize();
return Res; return res;
} }
// Add base relocations to .reloc section. // Add base relocations to .reloc section.
void Writer::addBaserels() { void Writer::addBaserels() {
if (!Config->Relocatable) if (!config->relocatable)
return; return;
RelocSec->Chunks.clear(); relocSec->chunks.clear();
std::vector<Baserel> V; std::vector<Baserel> v;
for (OutputSection *Sec : OutputSections) { for (OutputSection *sec : outputSections) {
if (Sec->Header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE) if (sec->header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE)
continue; continue;
// Collect all locations for base relocations. // Collect all locations for base relocations.
for (Chunk *C : Sec->Chunks) for (Chunk *c : sec->chunks)
C->getBaserels(&V); c->getBaserels(&v);
// Add the addresses to .reloc section. // Add the addresses to .reloc section.
if (!V.empty()) if (!v.empty())
addBaserelBlocks(V); addBaserelBlocks(v);
V.clear(); v.clear();
} }
} }
// Add addresses to .reloc section. Note that addresses are grouped by page. // Add addresses to .reloc section. Note that addresses are grouped by page.
void Writer::addBaserelBlocks(std::vector<Baserel> &V) { void Writer::addBaserelBlocks(std::vector<Baserel> &v) {
const uint32_t Mask = ~uint32_t(PageSize - 1); const uint32_t mask = ~uint32_t(pageSize - 1);
uint32_t Page = V[0].RVA & Mask; uint32_t page = v[0].rva & mask;
size_t I = 0, J = 1; size_t i = 0, j = 1;
for (size_t E = V.size(); J < E; ++J) { for (size_t e = v.size(); j < e; ++j) {
uint32_t P = V[J].RVA & Mask; uint32_t p = v[j].rva & mask;
if (P == Page) if (p == page)
continue; continue;
RelocSec->addChunk(make<BaserelChunk>(Page, &V[I], &V[0] + J)); relocSec->addChunk(make<BaserelChunk>(page, &v[i], &v[0] + j));
I = J; i = j;
Page = P; page = p;
} }
if (I == J) if (i == j)
return; return;
RelocSec->addChunk(make<BaserelChunk>(Page, &V[I], &V[0] + J)); relocSec->addChunk(make<BaserelChunk>(page, &v[i], &v[0] + j));
} }
PartialSection *Writer::createPartialSection(StringRef Name, PartialSection *Writer::createPartialSection(StringRef name,
uint32_t OutChars) { uint32_t outChars) {
PartialSection *&PSec = PartialSections[{Name, OutChars}]; PartialSection *&pSec = partialSections[{name, outChars}];
if (PSec) if (pSec)
return PSec; return pSec;
PSec = make<PartialSection>(Name, OutChars); pSec = make<PartialSection>(name, outChars);
return PSec; return pSec;
} }
PartialSection *Writer::findPartialSection(StringRef Name, uint32_t OutChars) { PartialSection *Writer::findPartialSection(StringRef name, uint32_t outChars) {
auto It = PartialSections.find({Name, OutChars}); auto it = partialSections.find({name, outChars});
if (It != PartialSections.end()) if (it != partialSections.end())
return It->second; return it->second;
return nullptr; return nullptr;
} }

lld/trunk/Common/Args.cpp

Show All 13 Lines
#include "llvm/Option/ArgList.h" #include "llvm/Option/ArgList.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
using namespace llvm; using namespace llvm;
using namespace lld; using namespace lld;
// TODO(sbc): Remove this once CGOptLevel can be set completely based on bitcode // TODO(sbc): Remove this once CGOptLevel can be set completely based on bitcode
// function metadata. // function metadata.
CodeGenOpt::Level lld::args::getCGOptLevel(int OptLevelLTO) { CodeGenOpt::Level lld::args::getCGOptLevel(int optLevelLTO) {
if (OptLevelLTO == 3) if (optLevelLTO == 3)
return CodeGenOpt::Aggressive; return CodeGenOpt::Aggressive;
assert(OptLevelLTO < 3); assert(optLevelLTO < 3);
return CodeGenOpt::Default; return CodeGenOpt::Default;
} }
int64_t lld::args::getInteger(opt::InputArgList &Args, unsigned Key, int64_t lld::args::getInteger(opt::InputArgList &args, unsigned key,
int64_t Default) { int64_t Default) {
auto *A = Args.getLastArg(Key); auto *a = args.getLastArg(key);
if (!A) if (!a)
return Default; return Default;
int64_t V; int64_t v;
if (to_integer(A->getValue(), V, 10)) if (to_integer(a->getValue(), v, 10))
return V; return v;
StringRef Spelling = Args.getArgString(A->getIndex()); StringRef spelling = args.getArgString(a->getIndex());
error(Spelling + ": number expected, but got '" + A->getValue() + "'"); error(spelling + ": number expected, but got '" + a->getValue() + "'");
return 0; return 0;
} }
std::vector<StringRef> lld::args::getStrings(opt::InputArgList &Args, int Id) { std::vector<StringRef> lld::args::getStrings(opt::InputArgList &args, int id) {
std::vector<StringRef> V; std::vector<StringRef> v;
for (auto *Arg : Args.filtered(Id)) for (auto *arg : args.filtered(id))
V.push_back(Arg->getValue()); v.push_back(arg->getValue());
return V; return v;
} }
uint64_t lld::args::getZOptionValue(opt::InputArgList &Args, int Id, uint64_t lld::args::getZOptionValue(opt::InputArgList &args, int id,
StringRef Key, uint64_t Default) { StringRef key, uint64_t Default) {
for (auto *Arg : Args.filtered_reverse(Id)) { for (auto *arg : args.filtered_reverse(id)) {
std::pair<StringRef, StringRef> KV = StringRef(Arg->getValue()).split('='); std::pair<StringRef, StringRef> kv = StringRef(arg->getValue()).split('=');
if (KV.first == Key) { if (kv.first == key) {
uint64_t Result = Default; uint64_t result = Default;
if (!to_integer(KV.second, Result)) if (!to_integer(kv.second, result))
error("invalid " + Key + ": " + KV.second); error("invalid " + key + ": " + kv.second);
return Result; return result;
} }
} }
return Default; return Default;
} }
std::vector<StringRef> lld::args::getLines(MemoryBufferRef MB) { std::vector<StringRef> lld::args::getLines(MemoryBufferRef mb) {
SmallVector<StringRef, 0> Arr; SmallVector<StringRef, 0> arr;
MB.getBuffer().split(Arr, '\n'); mb.getBuffer().split(arr, '\n');
std::vector<StringRef> Ret; std::vector<StringRef> ret;
for (StringRef S : Arr) { for (StringRef s : arr) {
S = S.trim(); s = s.trim();
if (!S.empty() && S[0] != '#') if (!s.empty() && s[0] != '#')
Ret.push_back(S); ret.push_back(s);
} }
return Ret; return ret;
} }
StringRef lld::args::getFilenameWithoutExe(StringRef Path) { StringRef lld::args::getFilenameWithoutExe(StringRef path) {
if (Path.endswith_lower(".exe")) if (path.endswith_lower(".exe"))
return sys::path::stem(Path); return sys::path::stem(path);
return sys::path::filename(Path); return sys::path::filename(path);
} }

lld/trunk/Common/ErrorHandler.cpp

Show All 20 Lines
#include <unistd.h> #include <unistd.h>
#endif #endif
using namespace llvm; using namespace llvm;
using namespace lld; using namespace lld;
// The functions defined in this file can be called from multiple threads, // The functions defined in this file can be called from multiple threads,
// but outs() or errs() are not thread-safe. We protect them using a mutex. // but outs() or errs() are not thread-safe. We protect them using a mutex.
static std::mutex Mu; static std::mutex mu;
// Prints "\n" or does nothing, depending on Msg contents of // Prints "\n" or does nothing, depending on Msg contents of
// the previous call of this function. // the previous call of this function.
static void newline(raw_ostream *ErrorOS, const Twine &Msg) { static void newline(raw_ostream *errorOS, const Twine &msg) {
// True if the previous error message contained "\n". // True if the previous error message contained "\n".
// We want to separate multi-line error messages with a newline. // We want to separate multi-line error messages with a newline.
static bool Flag; static bool flag;
if (Flag) if (flag)
*ErrorOS << "\n"; *errorOS << "\n";
Flag = StringRef(Msg.str()).contains('\n'); flag = StringRef(msg.str()).contains('\n');
} }
ErrorHandler &lld::errorHandler() { ErrorHandler &lld::errorHandler() {
static ErrorHandler Handler; static ErrorHandler handler;
return Handler; return handler;
} }
void lld::exitLld(int Val) { void lld::exitLld(int val) {
// Delete any temporary file, while keeping the memory mapping open. // Delete any temporary file, while keeping the memory mapping open.
if (errorHandler().OutputBuffer) if (errorHandler().outputBuffer)
errorHandler().OutputBuffer->discard(); errorHandler().outputBuffer->discard();
// Dealloc/destroy ManagedStatic variables before calling // Dealloc/destroy ManagedStatic variables before calling
// _exit(). In a non-LTO build, this is a nop. In an LTO // _exit(). In a non-LTO build, this is a nop. In an LTO
// build allows us to get the output of -time-passes. // build allows us to get the output of -time-passes.
llvm_shutdown(); llvm_shutdown();
outs().flush(); outs().flush();
errs().flush(); errs().flush();
_exit(Val); _exit(val);
} }
void lld::diagnosticHandler(const DiagnosticInfo &DI) { void lld::diagnosticHandler(const DiagnosticInfo &di) {
SmallString<128> S; SmallString<128> s;
raw_svector_ostream OS(S); raw_svector_ostream os(s);
DiagnosticPrinterRawOStream DP(OS); DiagnosticPrinterRawOStream dp(os);
DI.print(DP); di.print(dp);
switch (DI.getSeverity()) { switch (di.getSeverity()) {
case DS_Error: case DS_Error:
error(S); error(s);
break; break;
case DS_Warning: case DS_Warning:
warn(S); warn(s);
break; break;
case DS_Remark: case DS_Remark:
case DS_Note: case DS_Note:
message(S); message(s);
break; break;
} }
} }
void lld::checkError(Error E) { void lld::checkError(Error e) {
handleAllErrors(std::move(E), handleAllErrors(std::move(e),
[&](ErrorInfoBase &EIB) { error(EIB.message()); }); [&](ErrorInfoBase &eib) { error(eib.message()); });
} }
void ErrorHandler::print(StringRef S, raw_ostream::Colors C) { void ErrorHandler::print(StringRef s, raw_ostream::Colors c) {
*ErrorOS << LogName << ": "; *errorOS << logName << ": ";
if (ColorDiagnostics) { if (colorDiagnostics) {
ErrorOS->changeColor(C, true); errorOS->changeColor(c, true);
*ErrorOS << S; *errorOS << s;
ErrorOS->resetColor(); errorOS->resetColor();
} else { } else {
*ErrorOS << S; *errorOS << s;
} }
} }
void ErrorHandler::log(const Twine &Msg) { void ErrorHandler::log(const Twine &msg) {
if (Verbose) { if (verbose) {
std::lock_guard<std::mutex> Lock(Mu); std::lock_guard<std::mutex> lock(mu);
*ErrorOS << LogName << ": " << Msg << "\n"; *errorOS << logName << ": " << msg << "\n";
} }
} }
void ErrorHandler::message(const Twine &Msg) { void ErrorHandler::message(const Twine &msg) {
std::lock_guard<std::mutex> Lock(Mu); std::lock_guard<std::mutex> lock(mu);
outs() << Msg << "\n"; outs() << msg << "\n";
outs().flush(); outs().flush();
} }
void ErrorHandler::warn(const Twine &Msg) { void ErrorHandler::warn(const Twine &msg) {
if (FatalWarnings) { if (fatalWarnings) {
error(Msg); error(msg);
return; return;
} }
std::lock_guard<std::mutex> Lock(Mu); std::lock_guard<std::mutex> lock(mu);
newline(ErrorOS, Msg); newline(errorOS, msg);
print("warning: ", raw_ostream::MAGENTA); print("warning: ", raw_ostream::MAGENTA);
*ErrorOS << Msg << "\n"; *errorOS << msg << "\n";
} }
void ErrorHandler::error(const Twine &Msg) { void ErrorHandler::error(const Twine &msg) {
std::lock_guard<std::mutex> Lock(Mu); std::lock_guard<std::mutex> lock(mu);
newline(ErrorOS, Msg); newline(errorOS, msg);
if (ErrorLimit == 0 || ErrorCount < ErrorLimit) { if (errorLimit == 0 || errorCount < errorLimit) {
print("error: ", raw_ostream::RED); print("error: ", raw_ostream::RED);
*ErrorOS << Msg << "\n"; *errorOS << msg << "\n";
} else if (ErrorCount == ErrorLimit) { } else if (errorCount == errorLimit) {
print("error: ", raw_ostream::RED); print("error: ", raw_ostream::RED);
*ErrorOS << ErrorLimitExceededMsg << "\n"; *errorOS << errorLimitExceededMsg << "\n";
if (ExitEarly) if (exitEarly)
exitLld(1); exitLld(1);
} }
++ErrorCount; ++errorCount;
} }
void ErrorHandler::fatal(const Twine &Msg) { void ErrorHandler::fatal(const Twine &msg) {
error(Msg); error(msg);
exitLld(1); exitLld(1);
} }

lld/trunk/Common/Filesystem.cpp

Show All 32 Lines
// To create a new result file, we first remove existing file. So, if // To create a new result file, we first remove existing file. So, if
// you repeatedly link a 1 GB program in a regular compile-link-debug // you repeatedly link a 1 GB program in a regular compile-link-debug
// cycle, every cycle wastes 250 milliseconds only to remove a file. // cycle, every cycle wastes 250 milliseconds only to remove a file.
// Since LLD can link a 1 GB binary in about 5 seconds, that waste // Since LLD can link a 1 GB binary in about 5 seconds, that waste
// actually counts. // actually counts.
// //
// This function spawns a background thread to remove the file. // This function spawns a background thread to remove the file.
// The calling thread returns almost immediately. // The calling thread returns almost immediately.
void lld::unlinkAsync(StringRef Path) { void lld::unlinkAsync(StringRef path) {
// Removing a file is async on windows. // Removing a file is async on windows.
#if defined(_WIN32) #if defined(_WIN32)
sys::fs::remove(Path); sys::fs::remove(Path);
#else #else
if (!ThreadsEnabled || !sys::fs::exists(Path) || if (!threadsEnabled || !sys::fs::exists(path) ||
!sys::fs::is_regular_file(Path)) !sys::fs::is_regular_file(path))
return; return;
// We cannot just remove path from a different thread because we are now going // We cannot just remove path from a different thread because we are now going
// to create path as a new file. // to create path as a new file.
// Instead we open the file and unlink it on this thread. The unlink is fast // Instead we open the file and unlink it on this thread. The unlink is fast
// since the open fd guarantees that it is not removing the last reference. // since the open fd guarantees that it is not removing the last reference.
int FD; int fd;
std::error_code EC = sys::fs::openFileForRead(Path, FD); std::error_code ec = sys::fs::openFileForRead(path, fd);
sys::fs::remove(Path); sys::fs::remove(path);
if (EC) if (ec)
return; return;
// close and therefore remove TempPath in background. // close and therefore remove TempPath in background.
std::mutex M; std::mutex m;
std::condition_variable CV; std::condition_variable cv;
bool Started = false; bool started = false;
std::thread([&, FD] { std::thread([&, fd] {
{ {
std::lock_guard<std::mutex> L(M); std::lock_guard<std::mutex> l(m);
Started = true; started = true;
CV.notify_all(); cv.notify_all();
} }
::close(FD); ::close(fd);
}).detach(); }).detach();
// GLIBC 2.26 and earlier have race condition that crashes an entire process // GLIBC 2.26 and earlier have race condition that crashes an entire process
// if the main thread calls exit(2) while other thread is starting up. // if the main thread calls exit(2) while other thread is starting up.
std::unique_lock<std::mutex> L(M); std::unique_lock<std::mutex> l(m);
CV.wait(L, [&] { return Started; }); cv.wait(l, [&] { return started; });
#endif #endif
} }
// Simulate file creation to see if Path is writable. // Simulate file creation to see if Path is writable.
// //
// Determining whether a file is writable or not is amazingly hard, // Determining whether a file is writable or not is amazingly hard,
// and after all the only reliable way of doing that is to actually // and after all the only reliable way of doing that is to actually
// create a file. But we don't want to do that in this function // create a file. But we don't want to do that in this function
// because LLD shouldn't update any file if it will end in a failure. // because LLD shouldn't update any file if it will end in a failure.
// We also don't want to reimplement heuristics to determine if a // We also don't want to reimplement heuristics to determine if a
// file is writable. So we'll let FileOutputBuffer do the work. // file is writable. So we'll let FileOutputBuffer do the work.
// //
// FileOutputBuffer doesn't touch a desitnation file until commit() // FileOutputBuffer doesn't touch a desitnation file until commit()
// is called. We use that class without calling commit() to predict // is called. We use that class without calling commit() to predict
// if the given file is writable. // if the given file is writable.
std::error_code lld::tryCreateFile(StringRef Path) { std::error_code lld::tryCreateFile(StringRef path) {
if (Path.empty()) if (path.empty())
return std::error_code(); return std::error_code();
if (Path == "-") if (path == "-")
return std::error_code(); return std::error_code();
return errorToErrorCode(FileOutputBuffer::create(Path, 1).takeError()); return errorToErrorCode(FileOutputBuffer::create(path, 1).takeError());
} }

lld/trunk/Common/Memory.cpp

//===- Memory.cpp ---------------------------------------------------------===// //===- Memory.cpp ---------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lld/Common/Memory.h" #include "lld/Common/Memory.h"
using namespace llvm; using namespace llvm;
using namespace lld; using namespace lld;
BumpPtrAllocator lld::BAlloc; BumpPtrAllocator lld::bAlloc;
StringSaver lld::Saver{BAlloc}; StringSaver lld::saver{bAlloc};
std::vector<SpecificAllocBase *> lld::SpecificAllocBase::Instances; std::vector<SpecificAllocBase *> lld::SpecificAllocBase::instances;
void lld::freeArena() { void lld::freeArena() {
for (SpecificAllocBase *Alloc : SpecificAllocBase::Instances) for (SpecificAllocBase *alloc : SpecificAllocBase::instances)
Alloc->reset(); alloc->reset();
BAlloc.Reset(); bAlloc.Reset();
} }

lld/trunk/Common/Reproduce.cpp

Show All 15 Lines
using namespace llvm; using namespace llvm;
using namespace llvm::sys; using namespace llvm::sys;
// Makes a given pathname an absolute path first, and then remove // Makes a given pathname an absolute path first, and then remove
// beginning /. For example, "../foo.o" is converted to "home/john/foo.o", // beginning /. For example, "../foo.o" is converted to "home/john/foo.o",
// assuming that the current directory is "/home/john/bar". // assuming that the current directory is "/home/john/bar".
// Returned string is a forward slash separated path even on Windows to avoid // Returned string is a forward slash separated path even on Windows to avoid
// a mess with backslash-as-escape and backslash-as-path-separator. // a mess with backslash-as-escape and backslash-as-path-separator.
std::string lld::relativeToRoot(StringRef Path) { std::string lld::relativeToRoot(StringRef path) {
SmallString<128> Abs = Path; SmallString<128> abs = path;
if (fs::make_absolute(Abs)) if (fs::make_absolute(abs))
return Path; return path;
path::remove_dots(Abs, /*remove_dot_dot=*/true); path::remove_dots(abs, /*remove_dot_dot=*/true);
// This is Windows specific. root_name() returns a drive letter // This is Windows specific. root_name() returns a drive letter
// (e.g. "c:") or a UNC name (//net). We want to keep it as part // (e.g. "c:") or a UNC name (//net). We want to keep it as part
// of the result. // of the result.
SmallString<128> Res; SmallString<128> res;
StringRef Root = path::root_name(Abs); StringRef root = path::root_name(abs);
if (Root.endswith(":")) if (root.endswith(":"))
Res = Root.drop_back(); res = root.drop_back();
else if (Root.startswith("//")) else if (root.startswith("//"))
Res = Root.substr(2); res = root.substr(2);
path::append(Res, path::relative_path(Abs)); path::append(res, path::relative_path(abs));
return path::convert_to_slash(Res); return path::convert_to_slash(res);
} }
// Quote a given string if it contains a space character. // Quote a given string if it contains a space character.
std::string lld::quote(StringRef S) { std::string lld::quote(StringRef s) {
if (S.contains(' ')) if (s.contains(' '))
return ("\"" + S + "\"").str(); return ("\"" + s + "\"").str();
return S; return s;
} }
// Converts an Arg to a string representation suitable for a response file. // Converts an Arg to a string representation suitable for a response file.
// To show an Arg in a diagnostic, use Arg::getAsString() instead. // To show an Arg in a diagnostic, use Arg::getAsString() instead.
std::string lld::toString(const opt::Arg &Arg) { std::string lld::toString(const opt::Arg &arg) {
std::string K = Arg.getSpelling(); std::string k = arg.getSpelling();
if (Arg.getNumValues() == 0) if (arg.getNumValues() == 0)
return K; return k;
std::string V = quote(Arg.getValue()); std::string v = quote(arg.getValue());
if (Arg.getOption().getRenderStyle() == opt::Option::RenderJoinedStyle) if (arg.getOption().getRenderStyle() == opt::Option::RenderJoinedStyle)
return K + V; return k + v;
return K + " " + V; return k + " " + v;
} }

lld/trunk/Common/Strings.cpp

Show All 13 Lines
#include <algorithm> #include <algorithm>
#include <mutex> #include <mutex>
#include <vector> #include <vector>
using namespace llvm; using namespace llvm;
using namespace lld; using namespace lld;
// Returns the demangled C++ symbol name for Name. // Returns the demangled C++ symbol name for Name.
Optional<std::string> lld::demangleItanium(StringRef Name) { Optional<std::string> lld::demangleItanium(StringRef name) {
// itaniumDemangle can be used to demangle strings other than symbol // itaniumDemangle can be used to demangle strings other than symbol
// names which do not necessarily start with "_Z". Name can be // names which do not necessarily start with "_Z". Name can be
// either a C or C++ symbol. Don't call itaniumDemangle if the name // either a C or C++ symbol. Don't call itaniumDemangle if the name
// does not look like a C++ symbol name to avoid getting unexpected // does not look like a C++ symbol name to avoid getting unexpected
// result for a C symbol that happens to match a mangled type name. // result for a C symbol that happens to match a mangled type name.
if (!Name.startswith("_Z")) if (!name.startswith("_Z"))
return None; return None;
char *Buf = itaniumDemangle(Name.str().c_str(), nullptr, nullptr, nullptr); char *buf = itaniumDemangle(name.str().c_str(), nullptr, nullptr, nullptr);
if (!Buf) if (!buf)
return None; return None;
std::string S(Buf); std::string s(buf);
free(Buf); free(buf);
return S; return s;
} }
Optional<std::string> lld::demangleMSVC(StringRef Name) { Optional<std::string> lld::demangleMSVC(StringRef name) {
std::string Prefix; std::string prefix;
if (Name.consume_front("__imp_")) if (name.consume_front("__imp_"))
Prefix = "__declspec(dllimport) "; prefix = "__declspec(dllimport) ";
// Demangle only C++ names. // Demangle only C++ names.
if (!Name.startswith("?")) if (!name.startswith("?"))
return None; return None;
char *Buf = microsoftDemangle(Name.str().c_str(), nullptr, nullptr, nullptr); char *buf = microsoftDemangle(name.str().c_str(), nullptr, nullptr, nullptr);
if (!Buf) if (!buf)
return None; return None;
std::string S(Buf); std::string s(buf);
free(Buf); free(buf);
return Prefix + S; return prefix + s;
} }
StringMatcher::StringMatcher(ArrayRef<StringRef> Pat) { StringMatcher::StringMatcher(ArrayRef<StringRef> pat) {
for (StringRef S : Pat) { for (StringRef s : pat) {
Expected<GlobPattern> Pat = GlobPattern::create(S); Expected<GlobPattern> pat = GlobPattern::create(s);
if (!Pat) if (!pat)
error(toString(Pat.takeError())); error(toString(pat.takeError()));
else else
Patterns.push_back(*Pat); patterns.push_back(*pat);
} }
} }
bool StringMatcher::match(StringRef S) const { bool StringMatcher::match(StringRef s) const {
for (const GlobPattern &Pat : Patterns) for (const GlobPattern &pat : patterns)
if (Pat.match(S)) if (pat.match(s))
return true; return true;
return false; return false;
} }
// Converts a hex string (e.g. "deadbeef") to a vector. // Converts a hex string (e.g. "deadbeef") to a vector.
std::vector<uint8_t> lld::parseHex(StringRef S) { std::vector<uint8_t> lld::parseHex(StringRef s) {
std::vector<uint8_t> Hex; std::vector<uint8_t> hex;
while (!S.empty()) { while (!s.empty()) {
StringRef B = S.substr(0, 2); StringRef b = s.substr(0, 2);
S = S.substr(2); s = s.substr(2);
uint8_t H; uint8_t h;
if (!to_integer(B, H, 16)) { if (!to_integer(b, h, 16)) {
error("not a hexadecimal value: " + B); error("not a hexadecimal value: " + b);
return {}; return {};
} }
Hex.push_back(H); hex.push_back(h);
} }
return Hex; return hex;
} }
// Returns true if S is valid as a C language identifier. // Returns true if S is valid as a C language identifier.
bool lld::isValidCIdentifier(StringRef S) { bool lld::isValidCIdentifier(StringRef s) {
return !S.empty() && (isAlpha(S[0]) || S[0] == '_') && return !s.empty() && (isAlpha(s[0]) || s[0] == '_') &&
std::all_of(S.begin() + 1, S.end(), std::all_of(s.begin() + 1, s.end(),
[](char C) { return C == '_' || isAlnum(C); }); [](char c) { return c == '_' || isAlnum(c); });
} }
// Write the contents of the a buffer to a file // Write the contents of the a buffer to a file
void lld::saveBuffer(StringRef Buffer, const Twine &Path) { void lld::saveBuffer(StringRef buffer, const Twine &path) {
std::error_code EC; std::error_code ec;
raw_fd_ostream OS(Path.str(), EC, sys::fs::OpenFlags::F_None); raw_fd_ostream os(path.str(), ec, sys::fs::OpenFlags::F_None);
if (EC) if (ec)
error("cannot create " + Path + ": " + EC.message()); error("cannot create " + path + ": " + ec.message());
OS << Buffer; os << buffer;
} }

lld/trunk/Common/Threads.cpp

//===- Threads.cpp --------------------------------------------------------===// //===- Threads.cpp --------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lld/Common/Threads.h" #include "lld/Common/Threads.h"
bool lld::ThreadsEnabled = true; bool lld::threadsEnabled = true;

lld/trunk/Common/Timer.cpp

//===- Timer.cpp ----------------------------------------------------------===// //===- Timer.cpp ----------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lld/Common/Timer.h" #include "lld/Common/Timer.h"
#include "lld/Common/ErrorHandler.h" #include "lld/Common/ErrorHandler.h"
#include "llvm/Support/Format.h" #include "llvm/Support/Format.h"
using namespace lld; using namespace lld;
using namespace llvm; using namespace llvm;
ScopedTimer::ScopedTimer(Timer &T) : T(&T) { T.start(); } ScopedTimer::ScopedTimer(Timer &t) : t(&t) { t.start(); }
void ScopedTimer::stop() { void ScopedTimer::stop() {
if (!T) if (!t)
return; return;
T->stop(); t->stop();
T = nullptr; t = nullptr;
} }
ScopedTimer::~ScopedTimer() { stop(); } ScopedTimer::~ScopedTimer() { stop(); }
Timer::Timer(llvm::StringRef Name) : Name(Name), Parent(nullptr) {} Timer::Timer(llvm::StringRef name) : name(name), parent(nullptr) {}
Timer::Timer(llvm::StringRef Name, Timer &Parent) Timer::Timer(llvm::StringRef name, Timer &parent)
: Name(Name), Parent(&Parent) {} : name(name), parent(&parent) {}
void Timer::start() { void Timer::start() {
if (Parent && Total.count() == 0) if (parent && total.count() == 0)
Parent->Children.push_back(this); parent->children.push_back(this);
StartTime = std::chrono::high_resolution_clock::now(); startTime = std::chrono::high_resolution_clock::now();
} }
void Timer::stop() { void Timer::stop() {
Total += (std::chrono::high_resolution_clock::now() - StartTime); total += (std::chrono::high_resolution_clock::now() - startTime);
} }
Timer &Timer::root() { Timer &Timer::root() {
static Timer RootTimer("Total Link Time"); static Timer rootTimer("Total Link Time");
return RootTimer; return rootTimer;
} }
void Timer::print() { void Timer::print() {
double TotalDuration = static_cast<double>(root().millis()); double totalDuration = static_cast<double>(root().millis());
// We want to print the grand total under all the intermediate phases, so we // We want to print the grand total under all the intermediate phases, so we
// print all children first, then print the total under that. // print all children first, then print the total under that.
for (const auto &Child : Children) for (const auto &child : children)
Child->print(1, TotalDuration); child->print(1, totalDuration);
message(std::string(49, '-')); message(std::string(49, '-'));
root().print(0, root().millis(), false); root().print(0, root().millis(), false);
} }
double Timer::millis() const { double Timer::millis() const {
return std::chrono::duration_cast<std::chrono::duration<double, std::milli>>( return std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(
Total) total)
.count(); .count();
} }
void Timer::print(int Depth, double TotalDuration, bool Recurse) const { void Timer::print(int depth, double totalDuration, bool recurse) const {
double P = 100.0 * millis() / TotalDuration; double p = 100.0 * millis() / totalDuration;
SmallString<32> Str; SmallString<32> str;
llvm::raw_svector_ostream Stream(Str); llvm::raw_svector_ostream stream(str);
std::string S = std::string(Depth * 2, ' ') + Name + std::string(":"); std::string s = std::string(depth * 2, ' ') + name + std::string(":");
Stream << format("%-30s%5d ms (%5.1f%%)", S.c_str(), (int)millis(), P); stream << format("%-30s%5d ms (%5.1f%%)", s.c_str(), (int)millis(), p);
message(Str); message(str);
if (Recurse) { if (recurse) {
for (const auto &Child : Children) for (const auto &child : children)
Child->print(Depth + 1, TotalDuration); child->print(depth + 1, totalDuration);
} }
} }

lld/trunk/ELF/AArch64ErrataFix.cpp

Show First 20 Lines • Show All 392 Lines • ▼ Show 20 Lines
}; };
lld::elf::Patch843419Section::Patch843419Section(InputSection *p, uint64_t off) lld::elf::Patch843419Section::Patch843419Section(InputSection *p, uint64_t off)
: SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS, 4, : SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS, 4,
".text.patch"), ".text.patch"),
patchee(p), patcheeOffset(off) { patchee(p), patcheeOffset(off) {
this->parent = p->getParent(); this->parent = p->getParent();
patchSym = addSyntheticLocal( patchSym = addSyntheticLocal(
Saver.save("__CortexA53843419_" + utohexstr(getLDSTAddr())), STT_FUNC, 0, saver.save("__CortexA53843419_" + utohexstr(getLDSTAddr())), STT_FUNC, 0,
getSize(), *this); getSize(), *this);
addSyntheticLocal(Saver.save("$x"), STT_NOTYPE, 0, 0, *this); addSyntheticLocal(saver.save("$x"), STT_NOTYPE, 0, 0, *this);
} }
uint64_t lld::elf::Patch843419Section::getLDSTAddr() const { uint64_t lld::elf::Patch843419Section::getLDSTAddr() const {
return patchee->getVA(patcheeOffset); return patchee->getVA(patcheeOffset);
} }
void lld::elf::Patch843419Section::writeTo(uint8_t *buf) { void lld::elf::Patch843419Section::writeTo(uint8_t *buf) {
// Copy the instruction that we will be replacing with a branch in the // Copy the instruction that we will be replacing with a branch in the
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
// Insert the PatchSections we have created back into the // Insert the PatchSections we have created back into the
// InputSectionDescription. As inserting patches alters the addresses of // InputSectionDescription. As inserting patches alters the addresses of
// InputSections that follow them, we try and place the patches after all the // InputSections that follow them, we try and place the patches after all the
// executable sections, although we may need to insert them earlier if the // executable sections, although we may need to insert them earlier if the
// InputSectionDescription is larger than the maximum branch range. // InputSectionDescription is larger than the maximum branch range.
void AArch64Err843419Patcher::insertPatches( void AArch64Err843419Patcher::insertPatches(
InputSectionDescription &isd, std::vector<Patch843419Section *> &patches) { InputSectionDescription &isd, std::vector<Patch843419Section *> &patches) {
uint64_t isecLimit; uint64_t isecLimit;
uint64_t prevISLimit = isd.sections.front()->outSecOff; uint64_t prevIsecLimit = isd.sections.front()->outSecOff;
uint64_t patchUpperBound = prevISLimit + target->getThunkSectionSpacing(); uint64_t patchUpperBound = prevIsecLimit + target->getThunkSectionSpacing();
uint64_t outSecAddr = isd.sections.front()->getParent()->addr; uint64_t outSecAddr = isd.sections.front()->getParent()->addr;
// Set the OutSecOff of patches to the place where we want to insert them. // Set the OutSecOff of patches to the place where we want to insert them.
// We use a similar strategy to Thunk placement. Place patches roughly // We use a similar strategy to Thunk placement. Place patches roughly
// every multiple of maximum branch range. // every multiple of maximum branch range.
auto patchIt = patches.begin(); auto patchIt = patches.begin();
auto patchEnd = patches.end(); auto patchEnd = patches.end();
for (const InputSection *isec : isd.sections) { for (const InputSection *isec : isd.sections) {
isecLimit = isec->outSecOff + isec->getSize(); isecLimit = isec->outSecOff + isec->getSize();
if (isecLimit > patchUpperBound) { if (isecLimit > patchUpperBound) {
while (patchIt != patchEnd) { while (patchIt != patchEnd) {
if ((*patchIt)->getLDSTAddr() - outSecAddr >= prevISLimit) if ((*patchIt)->getLDSTAddr() - outSecAddr >= prevIsecLimit)
break; break;
(*patchIt)->outSecOff = prevISLimit; (*patchIt)->outSecOff = prevIsecLimit;
++patchIt; ++patchIt;
} }
patchUpperBound = prevISLimit + target->getThunkSectionSpacing(); patchUpperBound = prevIsecLimit + target->getThunkSectionSpacing();
} }
prevISLimit = isecLimit; prevIsecLimit = isecLimit;
} }
for (; patchIt != patchEnd; ++patchIt) { for (; patchIt != patchEnd; ++patchIt) {
(*patchIt)->outSecOff = isecLimit; (*patchIt)->outSecOff = isecLimit;
} }
// merge all patch sections. We use the OutSecOff assigned above to // merge all patch sections. We use the OutSecOff assigned above to
// determine the insertion point. This is ok as we only merge into an // determine the insertion point. This is ok as we only merge into an
// InputSectionDescription once per pass, and at the end of the pass // InputSectionDescription once per pass, and at the end of the pass
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

lld/trunk/ELF/Driver.cpp

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
Configuration *elf::config; Configuration *elf::config;
LinkerDriver *elf::driver; LinkerDriver *elf::driver;
static void setConfigs(opt::InputArgList &args); static void setConfigs(opt::InputArgList &args);
static void readConfigs(opt::InputArgList &args); static void readConfigs(opt::InputArgList &args);
bool elf::link(ArrayRef<const char *> args, bool canExitEarly, bool elf::link(ArrayRef<const char *> args, bool canExitEarly,
raw_ostream &error) { raw_ostream &error) {
errorHandler().LogName = args::getFilenameWithoutExe(args[0]); errorHandler().logName = args::getFilenameWithoutExe(args[0]);
errorHandler().ErrorLimitExceededMsg = errorHandler().errorLimitExceededMsg =
"too many errors emitted, stopping now (use " "too many errors emitted, stopping now (use "
"-error-limit=0 to see all errors)"; "-error-limit=0 to see all errors)";
errorHandler().ErrorOS = &error; errorHandler().errorOS = &error;
errorHandler().ExitEarly = canExitEarly; errorHandler().exitEarly = canExitEarly;
errorHandler().ColorDiagnostics = error.has_colors(); errorHandler().colorDiagnostics = error.has_colors();
inputSections.clear(); inputSections.clear();
outputSections.clear(); outputSections.clear();
binaryFiles.clear(); binaryFiles.clear();
bitcodeFiles.clear(); bitcodeFiles.clear();
objectFiles.clear(); objectFiles.clear();
sharedFiles.clear(); sharedFiles.clear();
▲ Show 20 Lines • Show All 300 Lines • ▼ Show 20 Lines if (!isKnownZFlag(arg->getValue()))
error("unknown -z value: " + StringRef(arg->getValue())); error("unknown -z value: " + StringRef(arg->getValue()));
} }
void LinkerDriver::main(ArrayRef<const char *> argsArr) { void LinkerDriver::main(ArrayRef<const char *> argsArr) {
ELFOptTable parser; ELFOptTable parser;
opt::InputArgList args = parser.parse(argsArr.slice(1)); opt::InputArgList args = parser.parse(argsArr.slice(1));
// Interpret this flag early because error() depends on them. // Interpret this flag early because error() depends on them.
errorHandler().ErrorLimit = args::getInteger(args, OPT_error_limit, 20); errorHandler().errorLimit = args::getInteger(args, OPT_error_limit, 20);
checkZOptions(args); checkZOptions(args);
// Handle -help // Handle -help
if (args.hasArg(OPT_help)) { if (args.hasArg(OPT_help)) {
printHelp(); printHelp();
return; return;
} }
▲ Show 20 Lines • Show All 367 Lines • ▼ Show 20 Linesstatic void parseClangOption(StringRef opt, const Twine &msg) {
if (cl::ParseCommandLineOptions(2, argv, "", &os)) if (cl::ParseCommandLineOptions(2, argv, "", &os))
return; return;
os.flush(); os.flush();
error(msg + ": " + StringRef(err).trim()); error(msg + ": " + StringRef(err).trim());
} }
// Initializes Config members by the command line options. // Initializes Config members by the command line options.
static void readConfigs(opt::InputArgList &args) { static void readConfigs(opt::InputArgList &args) {
errorHandler().Verbose = args.hasArg(OPT_verbose); errorHandler().verbose = args.hasArg(OPT_verbose);
errorHandler().FatalWarnings = errorHandler().fatalWarnings =
args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false); args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
ThreadsEnabled = args.hasFlag(OPT_threads, OPT_no_threads, true); threadsEnabled = args.hasFlag(OPT_threads, OPT_no_threads, true);
config->allowMultipleDefinition = config->allowMultipleDefinition =
args.hasFlag(OPT_allow_multiple_definition, args.hasFlag(OPT_allow_multiple_definition,
OPT_no_allow_multiple_definition, false) || OPT_no_allow_multiple_definition, false) ||
hasZOption(args, "muldefs"); hasZOption(args, "muldefs");
config->allowShlibUndefined = config->allowShlibUndefined =
args.hasFlag(OPT_allow_shlib_undefined, OPT_no_allow_shlib_undefined, args.hasFlag(OPT_allow_shlib_undefined, OPT_no_allow_shlib_undefined,
args.hasArg(OPT_shared)); args.hasArg(OPT_shared));
▲ Show 20 Lines • Show All 136 Lines • ▼ Show 20 Linesstatic void readConfigs(opt::InputArgList &args) {
config->zRetpolineplt = hasZOption(args, "retpolineplt"); config->zRetpolineplt = hasZOption(args, "retpolineplt");
config->zRodynamic = hasZOption(args, "rodynamic"); config->zRodynamic = hasZOption(args, "rodynamic");
config->zStackSize = args::getZOptionValue(args, OPT_z, "stack-size", 0); config->zStackSize = args::getZOptionValue(args, OPT_z, "stack-size", 0);
config->zText = getZFlag(args, "text", "notext", true); config->zText = getZFlag(args, "text", "notext", true);
config->zWxneeded = hasZOption(args, "wxneeded"); config->zWxneeded = hasZOption(args, "wxneeded");
// Parse LTO options. // Parse LTO options.
if (auto *arg = args.getLastArg(OPT_plugin_opt_mcpu_eq)) if (auto *arg = args.getLastArg(OPT_plugin_opt_mcpu_eq))
parseClangOption(Saver.save("-mcpu=" + StringRef(arg->getValue())), parseClangOption(saver.save("-mcpu=" + StringRef(arg->getValue())),
arg->getSpelling()); arg->getSpelling());
for (auto *arg : args.filtered(OPT_plugin_opt)) for (auto *arg : args.filtered(OPT_plugin_opt))
parseClangOption(arg->getValue(), arg->getSpelling()); parseClangOption(arg->getValue(), arg->getSpelling());
// Parse -mllvm options. // Parse -mllvm options.
for (auto *arg : args.filtered(OPT_mllvm)) for (auto *arg : args.filtered(OPT_mllvm))
parseClangOption(arg->getValue(), arg->getSpelling()); parseClangOption(arg->getValue(), arg->getSpelling());
▲ Show 20 Lines • Show All 623 Lines • ▼ Show 20 Lines for (auto *arg : args.filtered(OPT_wrap)) {
StringRef name = arg->getValue(); StringRef name = arg->getValue();
if (!seen.insert(name).second) if (!seen.insert(name).second)
continue; continue;
Symbol *sym = symtab->find(name); Symbol *sym = symtab->find(name);
if (!sym) if (!sym)
continue; continue;
Symbol *real = addUndefined(Saver.save("__real_" + name)); Symbol *real = addUndefined(saver.save("__real_" + name));
Symbol *wrap = addUndefined(Saver.save("__wrap_" + name)); Symbol *wrap = addUndefined(saver.save("__wrap_" + name));
v.push_back({sym, real, wrap}); v.push_back({sym, real, wrap});
// We want to tell LTO not to inline symbols to be overwritten // We want to tell LTO not to inline symbols to be overwritten
// because LTO doesn't know the final symbol contents after renaming. // because LTO doesn't know the final symbol contents after renaming.
real->canInline = false; real->canInline = false;
sym->canInline = false; sym->canInline = false;
// Tell LTO not to eliminate these symbols. // Tell LTO not to eliminate these symbols.
▲ Show 20 Lines • Show All 318 Lines • Show Last 20 Lines

lld/trunk/ELF/DriverUtils.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
// Set color diagnostics according to -color-diagnostics={auto,always,never} // Set color diagnostics according to -color-diagnostics={auto,always,never}
// or -no-color-diagnostics flags. // or -no-color-diagnostics flags.
static void handleColorDiagnostics(opt::InputArgList &args) { static void handleColorDiagnostics(opt::InputArgList &args) {
auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq, auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
OPT_no_color_diagnostics); OPT_no_color_diagnostics);
if (!arg) if (!arg)
return; return;
if (arg->getOption().getID() == OPT_color_diagnostics) { if (arg->getOption().getID() == OPT_color_diagnostics) {
errorHandler().ColorDiagnostics = true; errorHandler().colorDiagnostics = true;
} else if (arg->getOption().getID() == OPT_no_color_diagnostics) { } else if (arg->getOption().getID() == OPT_no_color_diagnostics) {
errorHandler().ColorDiagnostics = false; errorHandler().colorDiagnostics = false;
} else { } else {
StringRef s = arg->getValue(); StringRef s = arg->getValue();
if (s == "always") if (s == "always")
errorHandler().ColorDiagnostics = true; errorHandler().colorDiagnostics = true;
else if (s == "never") else if (s == "never")
errorHandler().ColorDiagnostics = false; errorHandler().colorDiagnostics = false;
else if (s != "auto") else if (s != "auto")
error("unknown option: --color-diagnostics=" + s); error("unknown option: --color-diagnostics=" + s);
} }
} }
static cl::TokenizerCallback getQuotingStyle(opt::InputArgList &args) { static cl::TokenizerCallback getQuotingStyle(opt::InputArgList &args) {
if (auto *arg = args.getLastArg(OPT_rsp_quoting)) { if (auto *arg = args.getLastArg(OPT_rsp_quoting)) {
StringRef s = arg->getValue(); StringRef s = arg->getValue();
Show All 17 Lines
// `--plugin-opt <foo>` is converted to `--plugin-opt=<foo>`. This is a // `--plugin-opt <foo>` is converted to `--plugin-opt=<foo>`. This is a
// bit hacky, but looks like it is still better than handling --plugin-opt // bit hacky, but looks like it is still better than handling --plugin-opt
// options by hand. // options by hand.
static void concatLTOPluginOptions(SmallVectorImpl<const char *> &args) { static void concatLTOPluginOptions(SmallVectorImpl<const char *> &args) {
SmallVector<const char *, 256> v; SmallVector<const char *, 256> v;
for (size_t i = 0, e = args.size(); i != e; ++i) { for (size_t i = 0, e = args.size(); i != e; ++i) {
StringRef s = args[i]; StringRef s = args[i];
if ((s == "-plugin-opt" || s == "--plugin-opt") && i + 1 != e) { if ((s == "-plugin-opt" || s == "--plugin-opt") && i + 1 != e) {
v.push_back(Saver.save(s + "=" + args[i + 1]).data()); v.push_back(saver.save(s + "=" + args[i + 1]).data());
++i; ++i;
} else { } else {
v.push_back(args[i]); v.push_back(args[i]);
} }
} }
args = std::move(v); args = std::move(v);
} }
// Parses a given list of options. // Parses a given list of options.
opt::InputArgList ELFOptTable::parse(ArrayRef<const char *> argv) { opt::InputArgList ELFOptTable::parse(ArrayRef<const char *> argv) {
// Make InputArgList from string vectors. // Make InputArgList from string vectors.
unsigned missingIndex; unsigned missingIndex;
unsigned missingCount; unsigned missingCount;
SmallVector<const char *, 256> vec(argv.data(), argv.data() + argv.size()); SmallVector<const char *, 256> vec(argv.data(), argv.data() + argv.size());
// We need to get the quoting style for response files before parsing all // We need to get the quoting style for response files before parsing all
// options so we parse here before and ignore all the options but // options so we parse here before and ignore all the options but
// --rsp-quoting. // --rsp-quoting.
opt::InputArgList args = this->ParseArgs(vec, missingIndex, missingCount); opt::InputArgList args = this->ParseArgs(vec, missingIndex, missingCount);
// Expand response files (arguments in the form of @<filename>) // Expand response files (arguments in the form of @<filename>)
// and then parse the argument again. // and then parse the argument again.
cl::ExpandResponseFiles(Saver, getQuotingStyle(args), vec); cl::ExpandResponseFiles(saver, getQuotingStyle(args), vec);
concatLTOPluginOptions(vec); concatLTOPluginOptions(vec);
args = this->ParseArgs(vec, missingIndex, missingCount); args = this->ParseArgs(vec, missingIndex, missingCount);
handleColorDiagnostics(args); handleColorDiagnostics(args);
if (missingCount) if (missingCount)
error(Twine(args.getArgString(missingIndex)) + ": missing argument"); error(Twine(args.getArgString(missingIndex)) + ": missing argument");
for (auto *arg : args.filtered(OPT_UNKNOWN)) { for (auto *arg : args.filtered(OPT_UNKNOWN)) {
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

lld/trunk/ELF/ICF.cpp

Show First 20 Lines • Show All 386 Lines • ▼ Show 20 Linesvoid ICF<ELFT>::forEachClassRange(size_t begin, size_t end,
} }
} }
// Call Fn on each equivalence class. // Call Fn on each equivalence class.
template <class ELFT> template <class ELFT>
void ICF<ELFT>::forEachClass(llvm::function_ref<void(size_t, size_t)> fn) { void ICF<ELFT>::forEachClass(llvm::function_ref<void(size_t, size_t)> fn) {
// If threading is disabled or the number of sections are // If threading is disabled or the number of sections are
// too small to use threading, call Fn sequentially. // too small to use threading, call Fn sequentially.
if (!ThreadsEnabled || sections.size() < 1024) { if (!threadsEnabled || sections.size() < 1024) {
forEachClassRange(0, sections.size(), fn); forEachClassRange(0, sections.size(), fn);
++cnt; ++cnt;
return; return;
} }
current = cnt % 2; current = cnt % 2;
next = (cnt + 1) % 2; next = (cnt + 1) % 2;
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

lld/trunk/ELF/InputFiles.cpp

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 LinesInputFile::InputFile(Kind k, MemoryBufferRef m)
if (!isInGroup) if (!isInGroup)
++nextGroupId; ++nextGroupId;
} }
Optional<MemoryBufferRef> elf::readFile(StringRef path) { Optional<MemoryBufferRef> elf::readFile(StringRef path) {
// The --chroot option changes our virtual root directory. // The --chroot option changes our virtual root directory.
// This is useful when you are dealing with files created by --reproduce. // This is useful when you are dealing with files created by --reproduce.
if (!config->chroot.empty() && path.startswith("/")) if (!config->chroot.empty() && path.startswith("/"))
path = Saver.save(config->chroot + path); path = saver.save(config->chroot + path);
log(path); log(path);
auto mbOrErr = MemoryBuffer::getFile(path, -1, false); auto mbOrErr = MemoryBuffer::getFile(path, -1, false);
if (auto ec = mbOrErr.getError()) { if (auto ec = mbOrErr.getError()) {
error("cannot open " + path + ": " + ec.message()); error("cannot open " + path + ": " + ec.message());
return None; return None;
} }
▲ Show 20 Lines • Show All 1,257 Lines • ▼ Show 20 Lines if (idx >= verdefs.size() || idx == VER_NDX_LOCAL) {
continue; continue;
} }
StringRef verName = StringRef verName =
this->stringTable.data() + this->stringTable.data() +
reinterpret_cast<const Elf_Verdef *>(verdefs[idx])->getAux()->vda_name; reinterpret_cast<const Elf_Verdef *>(verdefs[idx])->getAux()->vda_name;
versionedNameBuffer.clear(); versionedNameBuffer.clear();
name = (name + "@" + verName).toStringRef(versionedNameBuffer); name = (name + "@" + verName).toStringRef(versionedNameBuffer);
symtab->addSymbol(SharedSymbol{*this, Saver.save(name), sym.getBinding(), symtab->addSymbol(SharedSymbol{*this, saver.save(name), sym.getBinding(),
sym.st_other, sym.getType(), sym.st_value, sym.st_other, sym.getType(), sym.st_value,
sym.st_size, alignment, idx}); sym.st_size, alignment, idx});
} }
} }
static ELFKind getBitcodeELFKind(const Triple &t) { static ELFKind getBitcodeELFKind(const Triple &t) {
if (t.isLittleEndian()) if (t.isLittleEndian())
return t.isArch64Bit() ? ELF64LEKind : ELF32LEKind; return t.isArch64Bit() ? ELF64LEKind : ELF32LEKind;
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 LinesBitcodeFile::BitcodeFile(MemoryBufferRef mb, StringRef archiveName,
// ThinLTO assumes that all MemoryBufferRefs given to it have a unique // ThinLTO assumes that all MemoryBufferRefs given to it have a unique
// name. If two archives define two members with the same name, this // name. If two archives define two members with the same name, this
// causes a collision which result in only one of the objects being taken // causes a collision which result in only one of the objects being taken
// into consideration at LTO time (which very likely causes undefined // into consideration at LTO time (which very likely causes undefined
// symbols later in the link stage). So we append file offset to make // symbols later in the link stage). So we append file offset to make
// filename unique. // filename unique.
StringRef name = archiveName.empty() StringRef name = archiveName.empty()
? Saver.save(path) ? saver.save(path)
: Saver.save(archiveName + "(" + path + " at " + : saver.save(archiveName + "(" + path + " at " +
utostr(offsetInArchive) + ")"); utostr(offsetInArchive) + ")");
MemoryBufferRef mbref(mb.getBuffer(), name); MemoryBufferRef mbref(mb.getBuffer(), name);
obj = CHECK(lto::InputFile::create(mbref), this); obj = CHECK(lto::InputFile::create(mbref), this);
Triple t(obj->getTargetTriple()); Triple t(obj->getTargetTriple());
ekind = getBitcodeELFKind(t); ekind = getBitcodeELFKind(t);
emachine = getBitcodeMachineKind(mb.getBufferIdentifier(), t); emachine = getBitcodeMachineKind(mb.getBufferIdentifier(), t);
Show All 10 Linesstatic uint8_t mapVisibility(GlobalValue::VisibilityTypes gvVisibility) {
} }
llvm_unreachable("unknown visibility"); llvm_unreachable("unknown visibility");
} }
template <class ELFT> template <class ELFT>
static Symbol *createBitcodeSymbol(const std::vector<bool> &keptComdats, static Symbol *createBitcodeSymbol(const std::vector<bool> &keptComdats,
const lto::InputFile::Symbol &objSym, const lto::InputFile::Symbol &objSym,
BitcodeFile &f) { BitcodeFile &f) {
StringRef name = Saver.save(objSym.getName()); StringRef name = saver.save(objSym.getName());
uint8_t binding = objSym.isWeak() ? STB_WEAK : STB_GLOBAL; uint8_t binding = objSym.isWeak() ? STB_WEAK : STB_GLOBAL;
uint8_t type = objSym.isTLS() ? STT_TLS : STT_NOTYPE; uint8_t type = objSym.isTLS() ? STT_TLS : STT_NOTYPE;
uint8_t visibility = mapVisibility(objSym.getVisibility()); uint8_t visibility = mapVisibility(objSym.getVisibility());
bool canOmitFromDynSym = objSym.canBeOmittedFromSymbolTable(); bool canOmitFromDynSym = objSym.canBeOmittedFromSymbolTable();
int c = objSym.getComdatIndex(); int c = objSym.getComdatIndex();
if (objSym.isUndefined() || (c != -1 && !keptComdats[c])) { if (objSym.isUndefined() || (c != -1 && !keptComdats[c])) {
Undefined New(&f, name, binding, visibility, type); Undefined New(&f, name, binding, visibility, type);
Show All 36 Linesvoid BinaryFile::parse() {
// blob, we define _binary_foo_{start,end,size} symbols, so that // blob, we define _binary_foo_{start,end,size} symbols, so that
// user programs can access blobs by name. Non-alphanumeric // user programs can access blobs by name. Non-alphanumeric
// characters in a filename are replaced with underscore. // characters in a filename are replaced with underscore.
std::string s = "_binary_" + mb.getBufferIdentifier().str(); std::string s = "_binary_" + mb.getBufferIdentifier().str();
for (size_t i = 0; i < s.size(); ++i) for (size_t i = 0; i < s.size(); ++i)
if (!isAlnum(s[i])) if (!isAlnum(s[i]))
s[i] = '_'; s[i] = '_';
symtab->addSymbol(Defined{nullptr, Saver.save(s + "_start"), STB_GLOBAL, symtab->addSymbol(Defined{nullptr, saver.save(s + "_start"), STB_GLOBAL,
STV_DEFAULT, STT_OBJECT, 0, 0, section}); STV_DEFAULT, STT_OBJECT, 0, 0, section});
symtab->addSymbol(Defined{nullptr, Saver.save(s + "_end"), STB_GLOBAL, symtab->addSymbol(Defined{nullptr, saver.save(s + "_end"), STB_GLOBAL,
STV_DEFAULT, STT_OBJECT, data.size(), 0, section}); STV_DEFAULT, STT_OBJECT, data.size(), 0, section});
symtab->addSymbol(Defined{nullptr, Saver.save(s + "_size"), STB_GLOBAL, symtab->addSymbol(Defined{nullptr, saver.save(s + "_size"), STB_GLOBAL,
STV_DEFAULT, STT_OBJECT, data.size(), 0, nullptr}); STV_DEFAULT, STT_OBJECT, data.size(), 0, nullptr});
} }
InputFile *elf::createObjectFile(MemoryBufferRef mb, StringRef archiveName, InputFile *elf::createObjectFile(MemoryBufferRef mb, StringRef archiveName,
uint64_t offsetInArchive) { uint64_t offsetInArchive) {
if (isBitcode(mb)) if (isBitcode(mb))
return make<BitcodeFile>(mb, archiveName, offsetInArchive); return make<BitcodeFile>(mb, archiveName, offsetInArchive);
Show All 32 Linestemplate <class ELFT> void LazyObjFile::parse() {
// A lazy object file wraps either a bitcode file or an ELF file. // A lazy object file wraps either a bitcode file or an ELF file.
if (isBitcode(this->mb)) { if (isBitcode(this->mb)) {
std::unique_ptr<lto::InputFile> obj = std::unique_ptr<lto::InputFile> obj =
CHECK(lto::InputFile::create(this->mb), this); CHECK(lto::InputFile::create(this->mb), this);
for (const lto::InputFile::Symbol &sym : obj->symbols()) { for (const lto::InputFile::Symbol &sym : obj->symbols()) {
if (sym.isUndefined()) if (sym.isUndefined())
continue; continue;
symtab->addSymbol(LazyObject{*this, Saver.save(sym.getName())}); symtab->addSymbol(LazyObject{*this, saver.save(sym.getName())});
} }
return; return;
} }
if (getELFKind(this->mb, archiveName) != config->ekind) { if (getELFKind(this->mb, archiveName) != config->ekind) {
error("incompatible file: " + this->mb.getBufferIdentifier()); error("incompatible file: " + this->mb.getBufferIdentifier());
return; return;
} }
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

lld/trunk/ELF/InputSection.cpp

Show First 20 Lines • Show All 142 Lines • ▼ Show 20 Lines
} }
void InputSectionBase::uncompress() const { void InputSectionBase::uncompress() const {
size_t size = uncompressedSize; size_t size = uncompressedSize;
char *uncompressedBuf; char *uncompressedBuf;
{ {
static std::mutex mu; static std::mutex mu;
std::lock_guard<std::mutex> lock(mu); std::lock_guard<std::mutex> lock(mu);
uncompressedBuf = BAlloc.Allocate<char>(size); uncompressedBuf = bAlloc.Allocate<char>(size);
} }
if (Error e = zlib::uncompress(toStringRef(rawData), uncompressedBuf, size)) if (Error e = zlib::uncompress(toStringRef(rawData), uncompressedBuf, size))
fatal(toString(this) + fatal(toString(this) +
": uncompress failed: " + llvm::toString(std::move(e))); ": uncompress failed: " + llvm::toString(std::move(e)));
rawData = makeArrayRef((uint8_t *)uncompressedBuf, size); rawData = makeArrayRef((uint8_t *)uncompressedBuf, size);
uncompressedSize = -1; uncompressedSize = -1;
} }
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines if (rawData.size() < 8) {
return; return;
} }
uncompressedSize = read64be(rawData.data()); uncompressedSize = read64be(rawData.data());
rawData = rawData.slice(8); rawData = rawData.slice(8);
// Restore the original section name. // Restore the original section name.
// (e.g. ".zdebug_info" -> ".debug_info") // (e.g. ".zdebug_info" -> ".debug_info")
name = Saver.save("." + name.substr(2)); name = saver.save("." + name.substr(2));
return; return;
} }
assert(flags & SHF_COMPRESSED); assert(flags & SHF_COMPRESSED);
flags &= ~(uint64_t)SHF_COMPRESSED; flags &= ~(uint64_t)SHF_COMPRESSED;
// New-style 64-bit header // New-style 64-bit header
if (config->is64) { if (config->is64) {
▲ Show 20 Lines • Show All 1,094 Lines • Show Last 20 Lines

lld/trunk/ELF/MarkLive.cpp

Show First 20 Lines • Show All 254 Lines • ▼ Show 20 Lines for (InputSectionBase *sec : inputSections) {
} }
if (sec->flags & SHF_LINK_ORDER) if (sec->flags & SHF_LINK_ORDER)
continue; continue;
if (isReserved(sec) || script->shouldKeep(sec)) { if (isReserved(sec) || script->shouldKeep(sec)) {
enqueue(sec, 0); enqueue(sec, 0);
} else if (isValidCIdentifier(sec->name)) { } else if (isValidCIdentifier(sec->name)) {
cNamedSections[Saver.save("__start_" + sec->name)].push_back(sec); cNamedSections[saver.save("__start_" + sec->name)].push_back(sec);
cNamedSections[Saver.save("__stop_" + sec->name)].push_back(sec); cNamedSections[saver.save("__stop_" + sec->name)].push_back(sec);
} }
} }
mark(); mark();
} }
template <class ELFT> void MarkLive<ELFT>::mark() { template <class ELFT> void MarkLive<ELFT>::mark() {
// Mark all reachable sections. // Mark all reachable sections.
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

lld/trunk/ELF/Relocations.cpp

Show First 20 Lines • Show All 1,633 Lines • ▼ Show 20 Lines forEachInputSectionDescription(
uint32_t isdBegin = isd->sections.front()->outSecOff; uint32_t isdBegin = isd->sections.front()->outSecOff;
uint32_t isdEnd = uint32_t isdEnd =
isd->sections.back()->outSecOff + isd->sections.back()->getSize(); isd->sections.back()->outSecOff + isd->sections.back()->getSize();
uint32_t lastThunkLowerBound = -1; uint32_t lastThunkLowerBound = -1;
if (isdEnd - isdBegin > thunkSectionSpacing * 2) if (isdEnd - isdBegin > thunkSectionSpacing * 2)
lastThunkLowerBound = isdEnd - thunkSectionSpacing; lastThunkLowerBound = isdEnd - thunkSectionSpacing;
uint32_t isecLimit; uint32_t isecLimit;
uint32_t prevISLimit = isdBegin; uint32_t prevIsecLimit = isdBegin;
uint32_t thunkUpperBound = isdBegin + thunkSectionSpacing; uint32_t thunkUpperBound = isdBegin + thunkSectionSpacing;
for (const InputSection *isec : isd->sections) { for (const InputSection *isec : isd->sections) {
isecLimit = isec->outSecOff + isec->getSize(); isecLimit = isec->outSecOff + isec->getSize();
if (isecLimit > thunkUpperBound) { if (isecLimit > thunkUpperBound) {
addThunkSection(os, isd, prevISLimit); addThunkSection(os, isd, prevIsecLimit);
thunkUpperBound = prevISLimit + thunkSectionSpacing; thunkUpperBound = prevIsecLimit + thunkSectionSpacing;
} }
if (isecLimit > lastThunkLowerBound) if (isecLimit > lastThunkLowerBound)
break; break;
prevISLimit = isecLimit; prevIsecLimit = isecLimit;
} }
addThunkSection(os, isd, isecLimit); addThunkSection(os, isd, isecLimit);
}); });
} }
ThunkSection *ThunkCreator::addThunkSection(OutputSection *os, ThunkSection *ThunkCreator::addThunkSection(OutputSection *os,
InputSectionDescription *isd, InputSectionDescription *isd,
uint64_t off) { uint64_t off) {
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

lld/trunk/ELF/ScriptParser.cpp

Show First 20 Lines • Show All 274 Lines • ▼ Show 20 Linesvoid ScriptParser::readDefsym(StringRef name) {
script->sectionCommands.push_back(cmd); script->sectionCommands.push_back(cmd);
} }
void ScriptParser::addFile(StringRef s) { void ScriptParser::addFile(StringRef s) {
if (isUnderSysroot && s.startswith("/")) { if (isUnderSysroot && s.startswith("/")) {
SmallString<128> pathData; SmallString<128> pathData;
StringRef path = (config->sysroot + s).toStringRef(pathData); StringRef path = (config->sysroot + s).toStringRef(pathData);
if (sys::fs::exists(path)) { if (sys::fs::exists(path)) {
driver->addFile(Saver.save(path), /*WithLOption=*/false); driver->addFile(saver.save(path), /*WithLOption=*/false);
return; return;
} }
} }
if (s.startswith("/")) { if (s.startswith("/")) {
driver->addFile(s, /*WithLOption=*/false); driver->addFile(s, /*WithLOption=*/false);
} else if (s.startswith("=")) { } else if (s.startswith("=")) {
if (config->sysroot.empty()) if (config->sysroot.empty())
driver->addFile(s.substr(1), /*WithLOption=*/false); driver->addFile(s.substr(1), /*WithLOption=*/false);
else else
driver->addFile(Saver.save(config->sysroot + "/" + s.substr(1)), driver->addFile(saver.save(config->sysroot + "/" + s.substr(1)),
/*WithLOption=*/false); /*WithLOption=*/false);
} else if (s.startswith("-l")) { } else if (s.startswith("-l")) {
driver->addLibrary(s.substr(2)); driver->addLibrary(s.substr(2));
} else if (sys::fs::exists(s)) { } else if (sys::fs::exists(s)) {
driver->addFile(s, /*WithLOption=*/false); driver->addFile(s, /*WithLOption=*/false);
} else { } else {
if (Optional<std::string> path = findFromSearchPaths(s)) if (Optional<std::string> path = findFromSearchPaths(s))
driver->addFile(Saver.save(*path), /*WithLOption=*/true); driver->addFile(saver.save(*path), /*WithLOption=*/true);
else else
setError("unable to find " + s); setError("unable to find " + s);
} }
} }
void ScriptParser::readAsNeeded() { void ScriptParser::readAsNeeded() {
expect("("); expect("(");
bool orig = config->asNeeded; bool orig = config->asNeeded;
▲ Show 20 Lines • Show All 1,232 Lines • Show Last 20 Lines

lld/trunk/ELF/SyntheticSections.cpp

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
// Returns an LLD version string. // Returns an LLD version string.
static ArrayRef<uint8_t> getVersion() { static ArrayRef<uint8_t> getVersion() {
// Check LLD_VERSION first for ease of testing. // Check LLD_VERSION first for ease of testing.
// You can get consistent output by using the environment variable. // You can get consistent output by using the environment variable.
// This is only for testing. // This is only for testing.
StringRef s = getenv("LLD_VERSION"); StringRef s = getenv("LLD_VERSION");
if (s.empty()) if (s.empty())
s = Saver.save(Twine("Linker: ") + getLLDVersion()); s = saver.save(Twine("Linker: ") + getLLDVersion());
// +1 to include the terminating '\0'. // +1 to include the terminating '\0'.
return {(const uint8_t *)s.data(), s.size() + 1}; return {(const uint8_t *)s.data(), s.size() + 1};
} }
// Creates a .comment section containing LLD version info. // Creates a .comment section containing LLD version info.
// With this feature, you can identify LLD-generated binaries easily // With this feature, you can identify LLD-generated binaries easily
// by "readelf --string-dump .comment <file>". // by "readelf --string-dump .comment <file>".
▲ Show 20 Lines • Show All 165 Lines • ▼ Show 20 Lines for (InputSectionBase *sec : sections) {
sec->getFile<ELFT>()->mipsGp0 = r->ri_gp_value; sec->getFile<ELFT>()->mipsGp0 = r->ri_gp_value;
}; };
return make<MipsReginfoSection<ELFT>>(reginfo); return make<MipsReginfoSection<ELFT>>(reginfo);
} }
InputSection *elf::createInterpSection() { InputSection *elf::createInterpSection() {
// StringSaver guarantees that the returned string ends with '\0'. // StringSaver guarantees that the returned string ends with '\0'.
StringRef s = Saver.save(config->dynamicLinker); StringRef s = saver.save(config->dynamicLinker);
ArrayRef<uint8_t> contents = {(const uint8_t *)s.data(), s.size() + 1}; ArrayRef<uint8_t> contents = {(const uint8_t *)s.data(), s.size() + 1};
auto *sec = make<InputSection>(nullptr, SHF_ALLOC, SHT_PROGBITS, 1, contents, auto *sec = make<InputSection>(nullptr, SHF_ALLOC, SHT_PROGBITS, 1, contents,
".interp"); ".interp");
sec->markLive(); sec->markLive();
return sec; return sec;
} }
▲ Show 20 Lines • Show All 2,259 Lines • ▼ Show 20 Lines for (uint32_t i = 0, e = chunks.size(); i != e; ++i) {
cuIdx += chunks[i].compilationUnits.size(); cuIdx += chunks[i].compilationUnits.size();
} }
// The number of symbols we will handle in this function is of the order // The number of symbols we will handle in this function is of the order
// of millions for very large executables, so we use multi-threading to // of millions for very large executables, so we use multi-threading to
// speed it up. // speed it up.
size_t numShards = 32; size_t numShards = 32;
size_t concurrency = 1; size_t concurrency = 1;
if (ThreadsEnabled) if (threadsEnabled)
concurrency = concurrency =
std::min<size_t>(PowerOf2Floor(hardware_concurrency()), numShards); std::min<size_t>(PowerOf2Floor(hardware_concurrency()), numShards);
// A sharded map to uniquify symbols by name. // A sharded map to uniquify symbols by name.
std::vector<DenseMap<CachedHashStringRef, size_t>> map(numShards); std::vector<DenseMap<CachedHashStringRef, size_t>> map(numShards);
size_t shift = 32 - countTrailingZeros(numShards); size_t shift = 32 - countTrailingZeros(numShards);
// Instantiate GdbSymbols while uniqufying them by name. // Instantiate GdbSymbols while uniqufying them by name.
▲ Show 20 Lines • Show All 426 Lines • ▼ Show 20 Lines
void MergeNoTailSection::finalizeContents() { void MergeNoTailSection::finalizeContents() {
// Initializes string table builders. // Initializes string table builders.
for (size_t i = 0; i < numShards; ++i) for (size_t i = 0; i < numShards; ++i)
shards.emplace_back(StringTableBuilder::RAW, alignment); shards.emplace_back(StringTableBuilder::RAW, alignment);
// Concurrency level. Must be a power of 2 to avoid expensive modulo // Concurrency level. Must be a power of 2 to avoid expensive modulo
// operations in the following tight loop. // operations in the following tight loop.
size_t concurrency = 1; size_t concurrency = 1;
if (ThreadsEnabled) if (threadsEnabled)
concurrency = concurrency =
std::min<size_t>(PowerOf2Floor(hardware_concurrency()), numShards); std::min<size_t>(PowerOf2Floor(hardware_concurrency()), numShards);
// Add section pieces to the builders. // Add section pieces to the builders.
parallelForEachN(0, concurrency, [&](size_t threadId) { parallelForEachN(0, concurrency, [&](size_t threadId) {
for (MergeInputSection *sec : sections) { for (MergeInputSection *sec : sections) {
for (size_t i = 0, e = sec->pieces.size(); i != e; ++i) { for (size_t i = 0, e = sec->pieces.size(); i != e; ++i) {
if (!sec->pieces[i].live) if (!sec->pieces[i].live)
▲ Show 20 Lines • Show All 636 Lines • Show Last 20 Lines

lld/trunk/ELF/Thunks.cpp

Show First 20 Lines • Show All 344 Lines • ▼ Show 20 Lines const uint8_t data[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}; };
uint64_t s = getAArch64ThunkDestVA(destination); uint64_t s = getAArch64ThunkDestVA(destination);
memcpy(buf, data, sizeof(data)); memcpy(buf, data, sizeof(data));
target->relocateOne(buf + 8, R_AARCH64_ABS64, s); target->relocateOne(buf + 8, R_AARCH64_ABS64, s);
} }
void AArch64ABSLongThunk::addSymbols(ThunkSection &isec) { void AArch64ABSLongThunk::addSymbols(ThunkSection &isec) {
addSymbol(Saver.save("__AArch64AbsLongThunk_" + destination.getName()), addSymbol(saver.save("__AArch64AbsLongThunk_" + destination.getName()),
STT_FUNC, 0, isec); STT_FUNC, 0, isec);
addSymbol("$x", STT_NOTYPE, 0, isec); addSymbol("$x", STT_NOTYPE, 0, isec);
addSymbol("$d", STT_NOTYPE, 8, isec); addSymbol("$d", STT_NOTYPE, 8, isec);
} }
// This Thunk has a maximum range of 4Gb, this is sufficient for all programs // This Thunk has a maximum range of 4Gb, this is sufficient for all programs
// using the small code model, including pc-relative ones. At time of writing // using the small code model, including pc-relative ones. At time of writing
// clang and gcc do not support the large code model for position independent // clang and gcc do not support the large code model for position independent
Show All 9 Linesvoid AArch64ADRPThunk::writeTo(uint8_t *buf) {
uint64_t p = getThunkTargetSym()->getVA(); uint64_t p = getThunkTargetSym()->getVA();
memcpy(buf, data, sizeof(data)); memcpy(buf, data, sizeof(data));
target->relocateOne(buf, R_AARCH64_ADR_PREL_PG_HI21, target->relocateOne(buf, R_AARCH64_ADR_PREL_PG_HI21,
getAArch64Page(s) - getAArch64Page(p)); getAArch64Page(s) - getAArch64Page(p));
target->relocateOne(buf + 4, R_AARCH64_ADD_ABS_LO12_NC, s); target->relocateOne(buf + 4, R_AARCH64_ADD_ABS_LO12_NC, s);
} }
void AArch64ADRPThunk::addSymbols(ThunkSection &isec) { void AArch64ADRPThunk::addSymbols(ThunkSection &isec) {
addSymbol(Saver.save("__AArch64ADRPThunk_" + destination.getName()), STT_FUNC, addSymbol(saver.save("__AArch64ADRPThunk_" + destination.getName()), STT_FUNC,
0, isec); 0, isec);
addSymbol("$x", STT_NOTYPE, 0, isec); addSymbol("$x", STT_NOTYPE, 0, isec);
} }
// ARM Target Thunks // ARM Target Thunks
static uint64_t getARMThunkDestVA(const Symbol &s) { static uint64_t getARMThunkDestVA(const Symbol &s) {
uint64_t v = s.isInPlt() ? s.getPltVA() : s.getVA(); uint64_t v = s.isInPlt() ? s.getPltVA() : s.getVA();
return SignExtend64<32>(v); return SignExtend64<32>(v);
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Linesvoid ARMV7ABSLongThunk::writeLong(uint8_t *buf) {
}; };
uint64_t s = getARMThunkDestVA(destination); uint64_t s = getARMThunkDestVA(destination);
memcpy(buf, data, sizeof(data)); memcpy(buf, data, sizeof(data));
target->relocateOne(buf, R_ARM_MOVW_ABS_NC, s); target->relocateOne(buf, R_ARM_MOVW_ABS_NC, s);
target->relocateOne(buf + 4, R_ARM_MOVT_ABS, s); target->relocateOne(buf + 4, R_ARM_MOVT_ABS, s);
} }
void ARMV7ABSLongThunk::addSymbols(ThunkSection &isec) { void ARMV7ABSLongThunk::addSymbols(ThunkSection &isec) {
addSymbol(Saver.save("__ARMv7ABSLongThunk_" + destination.getName()), addSymbol(saver.save("__ARMv7ABSLongThunk_" + destination.getName()),
STT_FUNC, 0, isec); STT_FUNC, 0, isec);
addSymbol("$a", STT_NOTYPE, 0, isec); addSymbol("$a", STT_NOTYPE, 0, isec);
} }
void ThumbV7ABSLongThunk::writeLong(uint8_t *buf) { void ThumbV7ABSLongThunk::writeLong(uint8_t *buf) {
const uint8_t data[] = { const uint8_t data[] = {
0x40, 0xf2, 0x00, 0x0c, // movw ip, :lower16:S 0x40, 0xf2, 0x00, 0x0c, // movw ip, :lower16:S
0xc0, 0xf2, 0x00, 0x0c, // movt ip, :upper16:S 0xc0, 0xf2, 0x00, 0x0c, // movt ip, :upper16:S
0x60, 0x47, // bx ip 0x60, 0x47, // bx ip
}; };
uint64_t s = getARMThunkDestVA(destination); uint64_t s = getARMThunkDestVA(destination);
memcpy(buf, data, sizeof(data)); memcpy(buf, data, sizeof(data));
target->relocateOne(buf, R_ARM_THM_MOVW_ABS_NC, s); target->relocateOne(buf, R_ARM_THM_MOVW_ABS_NC, s);
target->relocateOne(buf + 4, R_ARM_THM_MOVT_ABS, s); target->relocateOne(buf + 4, R_ARM_THM_MOVT_ABS, s);
} }
void ThumbV7ABSLongThunk::addSymbols(ThunkSection &isec) { void ThumbV7ABSLongThunk::addSymbols(ThunkSection &isec) {
addSymbol(Saver.save("__Thumbv7ABSLongThunk_" + destination.getName()), addSymbol(saver.save("__Thumbv7ABSLongThunk_" + destination.getName()),
STT_FUNC, 1, isec); STT_FUNC, 1, isec);
addSymbol("$t", STT_NOTYPE, 0, isec); addSymbol("$t", STT_NOTYPE, 0, isec);
} }
void ARMV7PILongThunk::writeLong(uint8_t *buf) { void ARMV7PILongThunk::writeLong(uint8_t *buf) {
const uint8_t data[] = { const uint8_t data[] = {
0xf0, 0xcf, 0x0f, 0xe3, // P: movw ip,:lower16:S - (P + (L1-P) + 8) 0xf0, 0xcf, 0x0f, 0xe3, // P: movw ip,:lower16:S - (P + (L1-P) + 8)
0x00, 0xc0, 0x40, 0xe3, // movt ip,:upper16:S - (P + (L1-P) + 8) 0x00, 0xc0, 0x40, 0xe3, // movt ip,:upper16:S - (P + (L1-P) + 8)
0x0f, 0xc0, 0x8c, 0xe0, // L1: add ip, ip, pc 0x0f, 0xc0, 0x8c, 0xe0, // L1: add ip, ip, pc
0x1c, 0xff, 0x2f, 0xe1, // bx ip 0x1c, 0xff, 0x2f, 0xe1, // bx ip
}; };
uint64_t s = getARMThunkDestVA(destination); uint64_t s = getARMThunkDestVA(destination);
uint64_t p = getThunkTargetSym()->getVA(); uint64_t p = getThunkTargetSym()->getVA();
int64_t offset = s - p - 16; int64_t offset = s - p - 16;
memcpy(buf, data, sizeof(data)); memcpy(buf, data, sizeof(data));
target->relocateOne(buf, R_ARM_MOVW_PREL_NC, offset); target->relocateOne(buf, R_ARM_MOVW_PREL_NC, offset);
target->relocateOne(buf + 4, R_ARM_MOVT_PREL, offset); target->relocateOne(buf + 4, R_ARM_MOVT_PREL, offset);
} }
void ARMV7PILongThunk::addSymbols(ThunkSection &isec) { void ARMV7PILongThunk::addSymbols(ThunkSection &isec) {
addSymbol(Saver.save("__ARMV7PILongThunk_" + destination.getName()), STT_FUNC, addSymbol(saver.save("__ARMV7PILongThunk_" + destination.getName()), STT_FUNC,
0, isec); 0, isec);
addSymbol("$a", STT_NOTYPE, 0, isec); addSymbol("$a", STT_NOTYPE, 0, isec);
} }
void ThumbV7PILongThunk::writeLong(uint8_t *buf) { void ThumbV7PILongThunk::writeLong(uint8_t *buf) {
const uint8_t data[] = { const uint8_t data[] = {
0x4f, 0xf6, 0xf4, 0x7c, // P: movw ip,:lower16:S - (P + (L1-P) + 4) 0x4f, 0xf6, 0xf4, 0x7c, // P: movw ip,:lower16:S - (P + (L1-P) + 4)
0xc0, 0xf2, 0x00, 0x0c, // movt ip,:upper16:S - (P + (L1-P) + 4) 0xc0, 0xf2, 0x00, 0x0c, // movt ip,:upper16:S - (P + (L1-P) + 4)
0xfc, 0x44, // L1: add ip, pc 0xfc, 0x44, // L1: add ip, pc
0x60, 0x47, // bx ip 0x60, 0x47, // bx ip
}; };
uint64_t s = getARMThunkDestVA(destination); uint64_t s = getARMThunkDestVA(destination);
uint64_t p = getThunkTargetSym()->getVA() & ~0x1; uint64_t p = getThunkTargetSym()->getVA() & ~0x1;
int64_t offset = s - p - 12; int64_t offset = s - p - 12;
memcpy(buf, data, sizeof(data)); memcpy(buf, data, sizeof(data));
target->relocateOne(buf, R_ARM_THM_MOVW_PREL_NC, offset); target->relocateOne(buf, R_ARM_THM_MOVW_PREL_NC, offset);
target->relocateOne(buf + 4, R_ARM_THM_MOVT_PREL, offset); target->relocateOne(buf + 4, R_ARM_THM_MOVT_PREL, offset);
} }
void ThumbV7PILongThunk::addSymbols(ThunkSection &isec) { void ThumbV7PILongThunk::addSymbols(ThunkSection &isec) {
addSymbol(Saver.save("__ThumbV7PILongThunk_" + destination.getName()), addSymbol(saver.save("__ThumbV7PILongThunk_" + destination.getName()),
STT_FUNC, 1, isec); STT_FUNC, 1, isec);
addSymbol("$t", STT_NOTYPE, 0, isec); addSymbol("$t", STT_NOTYPE, 0, isec);
} }
void ARMV5ABSLongThunk::writeLong(uint8_t *buf) { void ARMV5ABSLongThunk::writeLong(uint8_t *buf) {
const uint8_t data[] = { const uint8_t data[] = {
0x04, 0xf0, 0x1f, 0xe5, // ldr pc, [pc,#-4] ; L1 0x04, 0xf0, 0x1f, 0xe5, // ldr pc, [pc,#-4] ; L1
0x00, 0x00, 0x00, 0x00, // L1: .word S 0x00, 0x00, 0x00, 0x00, // L1: .word S
}; };
memcpy(buf, data, sizeof(data)); memcpy(buf, data, sizeof(data));
target->relocateOne(buf + 4, R_ARM_ABS32, getARMThunkDestVA(destination)); target->relocateOne(buf + 4, R_ARM_ABS32, getARMThunkDestVA(destination));
} }
void ARMV5ABSLongThunk::addSymbols(ThunkSection &isec) { void ARMV5ABSLongThunk::addSymbols(ThunkSection &isec) {
addSymbol(Saver.save("__ARMv5ABSLongThunk_" + destination.getName()), addSymbol(saver.save("__ARMv5ABSLongThunk_" + destination.getName()),
STT_FUNC, 0, isec); STT_FUNC, 0, isec);
addSymbol("$a", STT_NOTYPE, 0, isec); addSymbol("$a", STT_NOTYPE, 0, isec);
addSymbol("$d", STT_NOTYPE, 4, isec); addSymbol("$d", STT_NOTYPE, 4, isec);
} }
bool ARMV5ABSLongThunk::isCompatibleWith(const InputSection &isec, bool ARMV5ABSLongThunk::isCompatibleWith(const InputSection &isec,
const Relocation &rel) const { const Relocation &rel) const {
// Thumb branch relocations can't use BLX // Thumb branch relocations can't use BLX
Show All 9 Linesvoid ARMV5PILongThunk::writeLong(uint8_t *buf) {
}; };
uint64_t s = getARMThunkDestVA(destination); uint64_t s = getARMThunkDestVA(destination);
uint64_t p = getThunkTargetSym()->getVA() & ~0x1; uint64_t p = getThunkTargetSym()->getVA() & ~0x1;
memcpy(buf, data, sizeof(data)); memcpy(buf, data, sizeof(data));
target->relocateOne(buf + 12, R_ARM_REL32, s - p - 12); target->relocateOne(buf + 12, R_ARM_REL32, s - p - 12);
} }
void ARMV5PILongThunk::addSymbols(ThunkSection &isec) { void ARMV5PILongThunk::addSymbols(ThunkSection &isec) {
addSymbol(Saver.save("__ARMV5PILongThunk_" + destination.getName()), STT_FUNC, addSymbol(saver.save("__ARMV5PILongThunk_" + destination.getName()), STT_FUNC,
0, isec); 0, isec);
addSymbol("$a", STT_NOTYPE, 0, isec); addSymbol("$a", STT_NOTYPE, 0, isec);
addSymbol("$d", STT_NOTYPE, 12, isec); addSymbol("$d", STT_NOTYPE, 12, isec);
} }
bool ARMV5PILongThunk::isCompatibleWith(const InputSection &isec, bool ARMV5PILongThunk::isCompatibleWith(const InputSection &isec,
const Relocation &rel) const { const Relocation &rel) const {
// Thumb branch relocations can't use BLX // Thumb branch relocations can't use BLX
Show All 13 Lines const uint8_t data[] = {
0x00, 0x00, 0x00, 0x00 // L1: .word S 0x00, 0x00, 0x00, 0x00 // L1: .word S
}; };
uint64_t s = getARMThunkDestVA(destination); uint64_t s = getARMThunkDestVA(destination);
memcpy(buf, data, sizeof(data)); memcpy(buf, data, sizeof(data));
target->relocateOne(buf + 8, R_ARM_ABS32, s); target->relocateOne(buf + 8, R_ARM_ABS32, s);
} }
void ThumbV6MABSLongThunk::addSymbols(ThunkSection &isec) { void ThumbV6MABSLongThunk::addSymbols(ThunkSection &isec) {
addSymbol(Saver.save("__Thumbv6MABSLongThunk_" + destination.getName()), addSymbol(saver.save("__Thumbv6MABSLongThunk_" + destination.getName()),
STT_FUNC, 1, isec); STT_FUNC, 1, isec);
addSymbol("$t", STT_NOTYPE, 0, isec); addSymbol("$t", STT_NOTYPE, 0, isec);
addSymbol("$d", STT_NOTYPE, 8, isec); addSymbol("$d", STT_NOTYPE, 8, isec);
} }
void ThumbV6MPILongThunk::writeLong(uint8_t *buf) { void ThumbV6MPILongThunk::writeLong(uint8_t *buf) {
// Most Thumb instructions cannot access the high registers r8 - r15. As the // Most Thumb instructions cannot access the high registers r8 - r15. As the
// only register we can corrupt is ip (r12) we must instead spill a low // only register we can corrupt is ip (r12) we must instead spill a low
Show All 9 Linesvoid ThumbV6MPILongThunk::writeLong(uint8_t *buf) {
}; };
uint64_t s = getARMThunkDestVA(destination); uint64_t s = getARMThunkDestVA(destination);
uint64_t p = getThunkTargetSym()->getVA() & ~0x1; uint64_t p = getThunkTargetSym()->getVA() & ~0x1;
memcpy(buf, data, sizeof(data)); memcpy(buf, data, sizeof(data));
target->relocateOne(buf + 12, R_ARM_REL32, s - p - 12); target->relocateOne(buf + 12, R_ARM_REL32, s - p - 12);
} }
void ThumbV6MPILongThunk::addSymbols(ThunkSection &isec) { void ThumbV6MPILongThunk::addSymbols(ThunkSection &isec) {
addSymbol(Saver.save("__Thumbv6MPILongThunk_" + destination.getName()), addSymbol(saver.save("__Thumbv6MPILongThunk_" + destination.getName()),
STT_FUNC, 1, isec); STT_FUNC, 1, isec);
addSymbol("$t", STT_NOTYPE, 0, isec); addSymbol("$t", STT_NOTYPE, 0, isec);
addSymbol("$d", STT_NOTYPE, 12, isec); addSymbol("$d", STT_NOTYPE, 12, isec);
} }
// Write MIPS LA25 thunk code to call PIC function from the non-PIC one. // Write MIPS LA25 thunk code to call PIC function from the non-PIC one.
void MipsThunk::writeTo(uint8_t *buf) { void MipsThunk::writeTo(uint8_t *buf) {
uint64_t s = destination.getVA(); uint64_t s = destination.getVA();
write32(buf, 0x3c190000); // lui $25, %hi(func) write32(buf, 0x3c190000); // lui $25, %hi(func)
write32(buf + 4, 0x08000000 | (s >> 2)); // j func write32(buf + 4, 0x08000000 | (s >> 2)); // j func
write32(buf + 8, 0x27390000); // addiu $25, $25, %lo(func) write32(buf + 8, 0x27390000); // addiu $25, $25, %lo(func)
write32(buf + 12, 0x00000000); // nop write32(buf + 12, 0x00000000); // nop
target->relocateOne(buf, R_MIPS_HI16, s); target->relocateOne(buf, R_MIPS_HI16, s);
target->relocateOne(buf + 8, R_MIPS_LO16, s); target->relocateOne(buf + 8, R_MIPS_LO16, s);
} }
void MipsThunk::addSymbols(ThunkSection &isec) { void MipsThunk::addSymbols(ThunkSection &isec) {
addSymbol(Saver.save("__LA25Thunk_" + destination.getName()), STT_FUNC, 0, addSymbol(saver.save("__LA25Thunk_" + destination.getName()), STT_FUNC, 0,
isec); isec);
} }
InputSection *MipsThunk::getTargetInputSection() const { InputSection *MipsThunk::getTargetInputSection() const {
auto &dr = cast<Defined>(destination); auto &dr = cast<Defined>(destination);
return dyn_cast<InputSection>(dr.section); return dyn_cast<InputSection>(dr.section);
} }
// Write microMIPS R2-R5 LA25 thunk code // Write microMIPS R2-R5 LA25 thunk code
// to call PIC function from the non-PIC one. // to call PIC function from the non-PIC one.
void MicroMipsThunk::writeTo(uint8_t *buf) { void MicroMipsThunk::writeTo(uint8_t *buf) {
uint64_t s = destination.getVA(); uint64_t s = destination.getVA();
write16(buf, 0x41b9); // lui $25, %hi(func) write16(buf, 0x41b9); // lui $25, %hi(func)
write16(buf + 4, 0xd400); // j func write16(buf + 4, 0xd400); // j func
write16(buf + 8, 0x3339); // addiu $25, $25, %lo(func) write16(buf + 8, 0x3339); // addiu $25, $25, %lo(func)
write16(buf + 12, 0x0c00); // nop write16(buf + 12, 0x0c00); // nop
target->relocateOne(buf, R_MICROMIPS_HI16, s); target->relocateOne(buf, R_MICROMIPS_HI16, s);
target->relocateOne(buf + 4, R_MICROMIPS_26_S1, s); target->relocateOne(buf + 4, R_MICROMIPS_26_S1, s);
target->relocateOne(buf + 8, R_MICROMIPS_LO16, s); target->relocateOne(buf + 8, R_MICROMIPS_LO16, s);
} }
void MicroMipsThunk::addSymbols(ThunkSection &isec) { void MicroMipsThunk::addSymbols(ThunkSection &isec) {
Defined *d = addSymbol( Defined *d = addSymbol(
Saver.save("__microLA25Thunk_" + destination.getName()), STT_FUNC, 0, isec); saver.save("__microLA25Thunk_" + destination.getName()), STT_FUNC, 0, isec);
d->stOther |= STO_MIPS_MICROMIPS; d->stOther |= STO_MIPS_MICROMIPS;
} }
InputSection *MicroMipsThunk::getTargetInputSection() const { InputSection *MicroMipsThunk::getTargetInputSection() const {
auto &dr = cast<Defined>(destination); auto &dr = cast<Defined>(destination);
return dyn_cast<InputSection>(dr.section); return dyn_cast<InputSection>(dr.section);
} }
// Write microMIPS R6 LA25 thunk code // Write microMIPS R6 LA25 thunk code
// to call PIC function from the non-PIC one. // to call PIC function from the non-PIC one.
void MicroMipsR6Thunk::writeTo(uint8_t *buf) { void MicroMipsR6Thunk::writeTo(uint8_t *buf) {
uint64_t s = destination.getVA(); uint64_t s = destination.getVA();
uint64_t p = getThunkTargetSym()->getVA(); uint64_t p = getThunkTargetSym()->getVA();
write16(buf, 0x1320); // lui $25, %hi(func) write16(buf, 0x1320); // lui $25, %hi(func)
write16(buf + 4, 0x3339); // addiu $25, $25, %lo(func) write16(buf + 4, 0x3339); // addiu $25, $25, %lo(func)
write16(buf + 8, 0x9400); // bc func write16(buf + 8, 0x9400); // bc func
target->relocateOne(buf, R_MICROMIPS_HI16, s); target->relocateOne(buf, R_MICROMIPS_HI16, s);
target->relocateOne(buf + 4, R_MICROMIPS_LO16, s); target->relocateOne(buf + 4, R_MICROMIPS_LO16, s);
target->relocateOne(buf + 8, R_MICROMIPS_PC26_S1, s - p - 12); target->relocateOne(buf + 8, R_MICROMIPS_PC26_S1, s - p - 12);
} }
void MicroMipsR6Thunk::addSymbols(ThunkSection &isec) { void MicroMipsR6Thunk::addSymbols(ThunkSection &isec) {
Defined *d = addSymbol( Defined *d = addSymbol(
Saver.save("__microLA25Thunk_" + destination.getName()), STT_FUNC, 0, isec); saver.save("__microLA25Thunk_" + destination.getName()), STT_FUNC, 0, isec);
d->stOther |= STO_MIPS_MICROMIPS; d->stOther |= STO_MIPS_MICROMIPS;
} }
InputSection *MicroMipsR6Thunk::getTargetInputSection() const { InputSection *MicroMipsR6Thunk::getTargetInputSection() const {
auto &dr = cast<Defined>(destination); auto &dr = cast<Defined>(destination);
return dyn_cast<InputSection>(dr.section); return dyn_cast<InputSection>(dr.section);
} }
Show All 38 Linesvoid PPC32PltCallStub::addSymbols(ThunkSection &isec) {
os << format_hex_no_prefix(addend, 8); os << format_hex_no_prefix(addend, 8);
if (!config->isPic) if (!config->isPic)
os << ".plt_call32."; os << ".plt_call32.";
else if (addend >= 0x8000) else if (addend >= 0x8000)
os << ".got2.plt_pic32."; os << ".got2.plt_pic32.";
else else
os << ".plt_pic32."; os << ".plt_pic32.";
os << destination.getName(); os << destination.getName();
addSymbol(Saver.save(os.str()), STT_FUNC, 0, isec); addSymbol(saver.save(os.str()), STT_FUNC, 0, isec);
} }
bool PPC32PltCallStub::isCompatibleWith(const InputSection &isec, bool PPC32PltCallStub::isCompatibleWith(const InputSection &isec,
const Relocation &rel) const { const Relocation &rel) const {
return !config->isPic || (isec.file == file && rel.addend == addend); return !config->isPic || (isec.file == file && rel.addend == addend);
} }
static void writePPCLoadAndBranch(uint8_t *buf, int64_t offset) { static void writePPCLoadAndBranch(uint8_t *buf, int64_t offset) {
Show All 9 Lines
void PPC64PltCallStub::writeTo(uint8_t *buf) { void PPC64PltCallStub::writeTo(uint8_t *buf) {
int64_t offset = destination.getGotPltVA() - getPPC64TocBase(); int64_t offset = destination.getGotPltVA() - getPPC64TocBase();
// Save the TOC pointer to the save-slot reserved in the call frame. // Save the TOC pointer to the save-slot reserved in the call frame.
write32(buf + 0, 0xf8410018); // std r2,24(r1) write32(buf + 0, 0xf8410018); // std r2,24(r1)
writePPCLoadAndBranch(buf + 4, offset); writePPCLoadAndBranch(buf + 4, offset);
} }
void PPC64PltCallStub::addSymbols(ThunkSection &isec) { void PPC64PltCallStub::addSymbols(ThunkSection &isec) {
Defined *s = addSymbol(Saver.save("__plt_" + destination.getName()), STT_FUNC, Defined *s = addSymbol(saver.save("__plt_" + destination.getName()), STT_FUNC,
0, isec); 0, isec);
s->needsTocRestore = true; s->needsTocRestore = true;
} }
void PPC64LongBranchThunk::writeTo(uint8_t *buf) { void PPC64LongBranchThunk::writeTo(uint8_t *buf) {
int64_t offset = destination.getPPC64LongBranchTableVA() - getPPC64TocBase(); int64_t offset = destination.getPPC64LongBranchTableVA() - getPPC64TocBase();
writePPCLoadAndBranch(buf, offset); writePPCLoadAndBranch(buf, offset);
} }
void PPC64LongBranchThunk::addSymbols(ThunkSection &isec) { void PPC64LongBranchThunk::addSymbols(ThunkSection &isec) {
addSymbol(Saver.save("__long_branch_" + destination.getName()), STT_FUNC, 0, addSymbol(saver.save("__long_branch_" + destination.getName()), STT_FUNC, 0,
isec); isec);
} }
Thunk::Thunk(Symbol &d) : destination(d), offset(0) {} Thunk::Thunk(Symbol &d) : destination(d), offset(0) {}
Thunk::~Thunk() = default; Thunk::~Thunk() = default;
static Thunk *addThunkAArch64(RelType type, Symbol &s) { static Thunk *addThunkAArch64(RelType type, Symbol &s) {
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

lld/trunk/ELF/Writer.cpp

Show All 36 Lines
using namespace lld; using namespace lld;
using namespace lld::elf; using namespace lld::elf;
namespace { namespace {
// The writer writes a SymbolTable result to a file. // The writer writes a SymbolTable result to a file.
template <class ELFT> class Writer { template <class ELFT> class Writer {
public: public:
Writer() : buffer(errorHandler().OutputBuffer) {} Writer() : buffer(errorHandler().outputBuffer) {}
using Elf_Shdr = typename ELFT::Shdr; using Elf_Shdr = typename ELFT::Shdr;
using Elf_Ehdr = typename ELFT::Ehdr; using Elf_Ehdr = typename ELFT::Ehdr;
using Elf_Phdr = typename ELFT::Phdr; using Elf_Phdr = typename ELFT::Phdr;
void run(); void run();
private: private:
void copyLocalSymbols(); void copyLocalSymbols();
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 LinesStringRef elf::getOutputSectionName(const InputSectionBase *s) {
// This is for --emit-relocs. If .text.foo is emitted as .text.bar, we want // This is for --emit-relocs. If .text.foo is emitted as .text.bar, we want
// to emit .rela.text.foo as .rela.text.bar for consistency (this is not // to emit .rela.text.foo as .rela.text.bar for consistency (this is not
// technically required, but not doing it is odd). This code guarantees that. // technically required, but not doing it is odd). This code guarantees that.
if (auto *isec = dyn_cast<InputSection>(s)) { if (auto *isec = dyn_cast<InputSection>(s)) {
if (InputSectionBase *rel = isec->getRelocatedSection()) { if (InputSectionBase *rel = isec->getRelocatedSection()) {
OutputSection *out = rel->getOutputSection(); OutputSection *out = rel->getOutputSection();
if (s->type == SHT_RELA) if (s->type == SHT_RELA)
return Saver.save(".rela" + out->name); return saver.save(".rela" + out->name);
return Saver.save(".rel" + out->name); return saver.save(".rel" + out->name);
} }
} }
// This check is for -z keep-text-section-prefix. This option separates text // This check is for -z keep-text-section-prefix. This option separates text
// sections with prefix ".text.hot", ".text.unlikely", ".text.startup" or // sections with prefix ".text.hot", ".text.unlikely", ".text.startup" or
// ".text.exit". // ".text.exit".
// When enabled, this allows identifying the hot code region (.text.hot) in // When enabled, this allows identifying the hot code region (.text.hot) in
// the final binary which can be selectively mapped to huge pages or mlocked, // the final binary which can be selectively mapped to huge pages or mlocked,
▲ Show 20 Lines • Show All 1,885 Lines • ▼ Show 20 Lines
// __stop_<secname> symbols. They are at beginning and end of the section, // __stop_<secname> symbols. They are at beginning and end of the section,
// respectively. This is not requested by the ELF standard, but GNU ld and // respectively. This is not requested by the ELF standard, but GNU ld and
// gold provide the feature, and used by many programs. // gold provide the feature, and used by many programs.
template <class ELFT> template <class ELFT>
void Writer<ELFT>::addStartStopSymbols(OutputSection *sec) { void Writer<ELFT>::addStartStopSymbols(OutputSection *sec) {
StringRef s = sec->name; StringRef s = sec->name;
if (!isValidCIdentifier(s)) if (!isValidCIdentifier(s))
return; return;
addOptionalRegular(Saver.save("__start_" + s), sec, 0, STV_PROTECTED); addOptionalRegular(saver.save("__start_" + s), sec, 0, STV_PROTECTED);
addOptionalRegular(Saver.save("__stop_" + s), sec, -1, STV_PROTECTED); addOptionalRegular(saver.save("__stop_" + s), sec, -1, STV_PROTECTED);
} }
static bool needsPtLoad(OutputSection *sec) { static bool needsPtLoad(OutputSection *sec) {
if (!(sec->flags & SHF_ALLOC) || sec->noload) if (!(sec->flags & SHF_ALLOC) || sec->noload)
return false; return false;
// Don't allocate VA space for TLS NOBITS sections. The PT_TLS PHDR is // Don't allocate VA space for TLS NOBITS sections. The PT_TLS PHDR is
// responsible for allocating space for them, not the PT_LOAD that // responsible for allocating space for them, not the PT_LOAD that
▲ Show 20 Lines • Show All 690 Lines • Show Last 20 Lines

lld/trunk/MinGW/Driver.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
}; };
// Create prefix string literals used in Options.td // Create prefix string literals used in Options.td
#define PREFIX(NAME, VALUE) static const char *const NAME[] = VALUE; #define PREFIX(NAME, VALUE) static const char *const NAME[] = VALUE;
#include "Options.inc" #include "Options.inc"
#undef PREFIX #undef PREFIX
// Create table mapping all options defined in Options.td // Create table mapping all options defined in Options.td
static const opt::OptTable::Info InfoTable[] = { static const opt::OptTable::Info infoTable[] = {
#define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12) \ #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12) \
{X1, X2, X10, X11, OPT_##ID, opt::Option::KIND##Class, \ {X1, X2, X10, X11, OPT_##ID, opt::Option::KIND##Class, \
X9, X8, OPT_##GROUP, OPT_##ALIAS, X7, X12}, X9, X8, OPT_##GROUP, OPT_##ALIAS, X7, X12},
#include "Options.inc" #include "Options.inc"
#undef OPTION #undef OPTION
}; };
namespace { namespace {
class MinGWOptTable : public opt::OptTable { class MinGWOptTable : public opt::OptTable {
public: public:
MinGWOptTable() : OptTable(InfoTable, false) {} MinGWOptTable() : OptTable(infoTable, false) {}
opt::InputArgList parse(ArrayRef<const char *> Argv); opt::InputArgList parse(ArrayRef<const char *> argv);
}; };
} // namespace } // namespace
static void printHelp(const char *Argv0) { static void printHelp(const char *argv0) {
MinGWOptTable().PrintHelp( MinGWOptTable().PrintHelp(
outs(), (std::string(Argv0) + " [options] file...").c_str(), "lld", outs(), (std::string(argv0) + " [options] file...").c_str(), "lld",
false /*ShowHidden*/, true /*ShowAllAliases*/); false /*ShowHidden*/, true /*ShowAllAliases*/);
outs() << "\n"; outs() << "\n";
} }
static cl::TokenizerCallback getQuotingStyle() { static cl::TokenizerCallback getQuotingStyle() {
if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32) if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32)
return cl::TokenizeWindowsCommandLine; return cl::TokenizeWindowsCommandLine;
return cl::TokenizeGNUCommandLine; return cl::TokenizeGNUCommandLine;
} }
opt::InputArgList MinGWOptTable::parse(ArrayRef<const char *> Argv) { opt::InputArgList MinGWOptTable::parse(ArrayRef<const char *> argv) {
unsigned MissingIndex; unsigned missingIndex;
unsigned MissingCount; unsigned missingCount;
SmallVector<const char *, 256> Vec(Argv.data(), Argv.data() + Argv.size()); SmallVector<const char *, 256> vec(argv.data(), argv.data() + argv.size());
cl::ExpandResponseFiles(Saver, getQuotingStyle(), Vec); cl::ExpandResponseFiles(saver, getQuotingStyle(), vec);
opt::InputArgList Args = this->ParseArgs(Vec, MissingIndex, MissingCount); opt::InputArgList args = this->ParseArgs(vec, missingIndex, missingCount);
if (MissingCount) if (missingCount)
fatal(StringRef(Args.getArgString(MissingIndex)) + ": missing argument"); fatal(StringRef(args.getArgString(missingIndex)) + ": missing argument");
for (auto *Arg : Args.filtered(OPT_UNKNOWN)) for (auto *arg : args.filtered(OPT_UNKNOWN))
fatal("unknown argument: " + Arg->getAsString(Args)); fatal("unknown argument: " + arg->getAsString(args));
return Args; return args;
} }
// Find a file by concatenating given paths. // Find a file by concatenating given paths.
static Optional<std::string> findFile(StringRef Path1, const Twine &Path2) { static Optional<std::string> findFile(StringRef path1, const Twine &path2) {
SmallString<128> S; SmallString<128> s;
sys::path::append(S, Path1, Path2); sys::path::append(s, path1, path2);
if (sys::fs::exists(S)) if (sys::fs::exists(s))
return S.str().str(); return s.str().str();
return None; return None;
} }
// This is for -lfoo. We'll look for libfoo.dll.a or libfoo.a from search paths. // This is for -lfoo. We'll look for libfoo.dll.a or libfoo.a from search paths.
static std::string static std::string
searchLibrary(StringRef Name, ArrayRef<StringRef> SearchPaths, bool BStatic) { searchLibrary(StringRef name, ArrayRef<StringRef> searchPaths, bool bStatic) {
if (Name.startswith(":")) { if (name.startswith(":")) {
for (StringRef Dir : SearchPaths) for (StringRef dir : searchPaths)
if (Optional<std::string> S = findFile(Dir, Name.substr(1))) if (Optional<std::string> s = findFile(dir, name.substr(1)))
return *S; return *s;
fatal("unable to find library -l" + Name); fatal("unable to find library -l" + name);
} }
for (StringRef Dir : SearchPaths) { for (StringRef dir : searchPaths) {
if (!BStatic) if (!bStatic)
if (Optional<std::string> S = findFile(Dir, "lib" + Name + ".dll.a")) if (Optional<std::string> s = findFile(dir, "lib" + name + ".dll.a"))
return *S; return *s;
if (Optional<std::string> S = findFile(Dir, "lib" + Name + ".a")) if (Optional<std::string> s = findFile(dir, "lib" + name + ".a"))
return *S; return *s;
} }
fatal("unable to find library -l" + Name); fatal("unable to find library -l" + name);
} }
// Convert Unix-ish command line arguments to Windows-ish ones and // Convert Unix-ish command line arguments to Windows-ish ones and
// then call coff::link. // then call coff::link.
bool mingw::link(ArrayRef<const char *> ArgsArr, raw_ostream &Diag) { bool mingw::link(ArrayRef<const char *> argsArr, raw_ostream &diag) {
MinGWOptTable Parser; MinGWOptTable parser;
opt::InputArgList Args = Parser.parse(ArgsArr.slice(1)); opt::InputArgList args = parser.parse(argsArr.slice(1));
if (Args.hasArg(OPT_help)) { if (args.hasArg(OPT_help)) {
printHelp(ArgsArr[0]); printHelp(argsArr[0]);
return true; return true;
} }
// A note about "compatible with GNU linkers" message: this is a hack for // A note about "compatible with GNU linkers" message: this is a hack for
// scripts generated by GNU Libtool 2.4.6 (released in February 2014 and // scripts generated by GNU Libtool 2.4.6 (released in February 2014 and
// still the newest version in March 2017) or earlier to recognize LLD as // still the newest version in March 2017) or earlier to recognize LLD as
// a GNU compatible linker. As long as an output for the -v option // a GNU compatible linker. As long as an output for the -v option
// contains "GNU" or "with BFD", they recognize us as GNU-compatible. // contains "GNU" or "with BFD", they recognize us as GNU-compatible.
if (Args.hasArg(OPT_v) || Args.hasArg(OPT_version)) if (args.hasArg(OPT_v) || args.hasArg(OPT_version))
message(getLLDVersion() + " (compatible with GNU linkers)"); message(getLLDVersion() + " (compatible with GNU linkers)");
// The behavior of -v or --version is a bit strange, but this is // The behavior of -v or --version is a bit strange, but this is
// needed for compatibility with GNU linkers. // needed for compatibility with GNU linkers.
if (Args.hasArg(OPT_v) && !Args.hasArg(OPT_INPUT) && !Args.hasArg(OPT_l)) if (args.hasArg(OPT_v) && !args.hasArg(OPT_INPUT) && !args.hasArg(OPT_l))
return true; return true;
if (Args.hasArg(OPT_version)) if (args.hasArg(OPT_version))
return true; return true;
if (!Args.hasArg(OPT_INPUT) && !Args.hasArg(OPT_l)) if (!args.hasArg(OPT_INPUT) && !args.hasArg(OPT_l))
fatal("no input files"); fatal("no input files");
std::vector<std::string> LinkArgs; std::vector<std::string> linkArgs;
auto Add = [&](const Twine &S) { LinkArgs.push_back(S.str()); }; auto add = [&](const Twine &s) { linkArgs.push_back(s.str()); };
Add("lld-link"); add("lld-link");
Add("-lldmingw"); add("-lldmingw");
if (auto *A = Args.getLastArg(OPT_entry)) { if (auto *a = args.getLastArg(OPT_entry)) {
StringRef S = A->getValue(); StringRef s = a->getValue();
if (Args.getLastArgValue(OPT_m) == "i386pe" && S.startswith("_")) if (args.getLastArgValue(OPT_m) == "i386pe" && s.startswith("_"))
Add("-entry:" + S.substr(1)); add("-entry:" + s.substr(1));
else else
Add("-entry:" + S); add("-entry:" + s);
} }
if (Args.hasArg(OPT_major_os_version, OPT_minor_os_version, if (args.hasArg(OPT_major_os_version, OPT_minor_os_version,
OPT_major_subsystem_version, OPT_minor_subsystem_version)) { OPT_major_subsystem_version, OPT_minor_subsystem_version)) {
auto *MajOSVer = Args.getLastArg(OPT_major_os_version); auto *majOSVer = args.getLastArg(OPT_major_os_version);
auto *MinOSVer = Args.getLastArg(OPT_minor_os_version); auto *minOSVer = args.getLastArg(OPT_minor_os_version);
auto *MajSubSysVer = Args.getLastArg(OPT_major_subsystem_version); auto *majSubSysVer = args.getLastArg(OPT_major_subsystem_version);
auto *MinSubSysVer = Args.getLastArg(OPT_minor_subsystem_version); auto *minSubSysVer = args.getLastArg(OPT_minor_subsystem_version);
if (MajOSVer && MajSubSysVer && if (majOSVer && majSubSysVer &&
StringRef(MajOSVer->getValue()) != StringRef(MajSubSysVer->getValue())) StringRef(majOSVer->getValue()) != StringRef(majSubSysVer->getValue()))
warn("--major-os-version and --major-subsystem-version set to differing " warn("--major-os-version and --major-subsystem-version set to differing "
"versions, not supported"); "versions, not supported");
if (MinOSVer && MinSubSysVer && if (minOSVer && minSubSysVer &&
StringRef(MinOSVer->getValue()) != StringRef(MinSubSysVer->getValue())) StringRef(minOSVer->getValue()) != StringRef(minSubSysVer->getValue()))
warn("--minor-os-version and --minor-subsystem-version set to differing " warn("--minor-os-version and --minor-subsystem-version set to differing "
"versions, not supported"); "versions, not supported");
StringRef SubSys = Args.getLastArgValue(OPT_subs, "default"); StringRef subSys = args.getLastArgValue(OPT_subs, "default");
StringRef Major = MajOSVer ? MajOSVer->getValue() StringRef major = majOSVer ? majOSVer->getValue()
: MajSubSysVer ? MajSubSysVer->getValue() : "6"; : majSubSysVer ? majSubSysVer->getValue() : "6";
StringRef Minor = MinOSVer ? MinOSVer->getValue() StringRef minor = minOSVer ? minOSVer->getValue()
: MinSubSysVer ? MinSubSysVer->getValue() : ""; : minSubSysVer ? minSubSysVer->getValue() : "";
StringRef Sep = Minor.empty() ? "" : "."; StringRef sep = minor.empty() ? "" : ".";
Add("-subsystem:" + SubSys + "," + Major + Sep + Minor); add("-subsystem:" + subSys + "," + major + sep + minor);
} else if (auto *A = Args.getLastArg(OPT_subs)) { } else if (auto *a = args.getLastArg(OPT_subs)) {
Add("-subsystem:" + StringRef(A->getValue())); add("-subsystem:" + StringRef(a->getValue()));
} }
if (auto *A = Args.getLastArg(OPT_out_implib)) if (auto *a = args.getLastArg(OPT_out_implib))
Add("-implib:" + StringRef(A->getValue())); add("-implib:" + StringRef(a->getValue()));
if (auto *A = Args.getLastArg(OPT_stack)) if (auto *a = args.getLastArg(OPT_stack))
Add("-stack:" + StringRef(A->getValue())); add("-stack:" + StringRef(a->getValue()));
if (auto *A = Args.getLastArg(OPT_output_def)) if (auto *a = args.getLastArg(OPT_output_def))
Add("-output-def:" + StringRef(A->getValue())); add("-output-def:" + StringRef(a->getValue()));
if (auto *A = Args.getLastArg(OPT_image_base)) if (auto *a = args.getLastArg(OPT_image_base))
Add("-base:" + StringRef(A->getValue())); add("-base:" + StringRef(a->getValue()));
if (auto *A = Args.getLastArg(OPT_map)) if (auto *a = args.getLastArg(OPT_map))
Add("-lldmap:" + StringRef(A->getValue())); add("-lldmap:" + StringRef(a->getValue()));
if (auto *A = Args.getLastArg(OPT_o)) if (auto *a = args.getLastArg(OPT_o))
Add("-out:" + StringRef(A->getValue())); add("-out:" + StringRef(a->getValue()));
else if (Args.hasArg(OPT_shared)) else if (args.hasArg(OPT_shared))
Add("-out:a.dll"); add("-out:a.dll");
else else
Add("-out:a.exe"); add("-out:a.exe");
if (auto *A = Args.getLastArg(OPT_pdb)) { if (auto *a = args.getLastArg(OPT_pdb)) {
Add("-debug"); add("-debug");
StringRef V = A->getValue(); StringRef v = a->getValue();
if (!V.empty()) if (!v.empty())
Add("-pdb:" + V); add("-pdb:" + v);
} else if (Args.hasArg(OPT_strip_debug)) { } else if (args.hasArg(OPT_strip_debug)) {
Add("-debug:symtab"); add("-debug:symtab");
} else if (!Args.hasArg(OPT_strip_all)) { } else if (!args.hasArg(OPT_strip_all)) {
Add("-debug:dwarf"); add("-debug:dwarf");
} }
if (Args.hasArg(OPT_shared)) if (args.hasArg(OPT_shared))
Add("-dll"); add("-dll");
if (Args.hasArg(OPT_verbose)) if (args.hasArg(OPT_verbose))
Add("-verbose"); add("-verbose");
if (Args.hasArg(OPT_exclude_all_symbols)) if (args.hasArg(OPT_exclude_all_symbols))
Add("-exclude-all-symbols"); add("-exclude-all-symbols");
if (Args.hasArg(OPT_export_all_symbols)) if (args.hasArg(OPT_export_all_symbols))
Add("-export-all-symbols"); add("-export-all-symbols");
if (Args.hasArg(OPT_large_address_aware)) if (args.hasArg(OPT_large_address_aware))
Add("-largeaddressaware"); add("-largeaddressaware");
if (Args.hasArg(OPT_kill_at)) if (args.hasArg(OPT_kill_at))
Add("-kill-at"); add("-kill-at");
if (Args.hasArg(OPT_appcontainer)) if (args.hasArg(OPT_appcontainer))
Add("-appcontainer"); add("-appcontainer");
if (Args.getLastArgValue(OPT_m) != "thumb2pe" && if (args.getLastArgValue(OPT_m) != "thumb2pe" &&
Args.getLastArgValue(OPT_m) != "arm64pe" && !Args.hasArg(OPT_dynamicbase)) args.getLastArgValue(OPT_m) != "arm64pe" && !args.hasArg(OPT_dynamicbase))
Add("-dynamicbase:no"); add("-dynamicbase:no");
if (Args.hasFlag(OPT_no_insert_timestamp, OPT_insert_timestamp, false)) if (args.hasFlag(OPT_no_insert_timestamp, OPT_insert_timestamp, false))
Add("-timestamp:0"); add("-timestamp:0");
if (Args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, false)) if (args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, false))
Add("-opt:ref"); add("-opt:ref");
else else
Add("-opt:noref"); add("-opt:noref");
if (auto *A = Args.getLastArg(OPT_icf)) { if (auto *a = args.getLastArg(OPT_icf)) {
StringRef S = A->getValue(); StringRef s = a->getValue();
if (S == "all") if (s == "all")
Add("-opt:icf"); add("-opt:icf");
else if (S == "safe" || S == "none") else if (s == "safe" || s == "none")
Add("-opt:noicf"); add("-opt:noicf");
else else
fatal("unknown parameter: --icf=" + S); fatal("unknown parameter: --icf=" + s);
} else { } else {
Add("-opt:noicf"); add("-opt:noicf");
} }
if (auto *A = Args.getLastArg(OPT_m)) { if (auto *a = args.getLastArg(OPT_m)) {
StringRef S = A->getValue(); StringRef s = a->getValue();
if (S == "i386pe") if (s == "i386pe")
Add("-machine:x86"); add("-machine:x86");
else if (S == "i386pep") else if (s == "i386pep")
Add("-machine:x64"); add("-machine:x64");
else if (S == "thumb2pe") else if (s == "thumb2pe")
Add("-machine:arm"); add("-machine:arm");
else if (S == "arm64pe") else if (s == "arm64pe")
Add("-machine:arm64"); add("-machine:arm64");
else else
fatal("unknown parameter: -m" + S); fatal("unknown parameter: -m" + s);
} }
for (auto *A : Args.filtered(OPT_mllvm)) for (auto *a : args.filtered(OPT_mllvm))
Add("-mllvm:" + StringRef(A->getValue())); add("-mllvm:" + StringRef(a->getValue()));
for (auto *A : Args.filtered(OPT_Xlink)) for (auto *a : args.filtered(OPT_Xlink))
Add(A->getValue()); add(a->getValue());
if (Args.getLastArgValue(OPT_m) == "i386pe") if (args.getLastArgValue(OPT_m) == "i386pe")
Add("-alternatename:__image_base__=___ImageBase"); add("-alternatename:__image_base__=___ImageBase");
else else
Add("-alternatename:__image_base__=__ImageBase"); add("-alternatename:__image_base__=__ImageBase");
for (auto *A : Args.filtered(OPT_require_defined)) for (auto *a : args.filtered(OPT_require_defined))
Add("-include:" + StringRef(A->getValue())); add("-include:" + StringRef(a->getValue()));
for (auto *A : Args.filtered(OPT_undefined)) for (auto *a : args.filtered(OPT_undefined))
Add("-includeoptional:" + StringRef(A->getValue())); add("-includeoptional:" + StringRef(a->getValue()));
std::vector<StringRef> SearchPaths; std::vector<StringRef> searchPaths;
for (auto *A : Args.filtered(OPT_L)) { for (auto *a : args.filtered(OPT_L)) {
SearchPaths.push_back(A->getValue()); searchPaths.push_back(a->getValue());
Add("-libpath:" + StringRef(A->getValue())); add("-libpath:" + StringRef(a->getValue()));
} }
StringRef Prefix = ""; StringRef prefix = "";
bool Static = false; bool isStatic = false;
for (auto *A : Args) { for (auto *a : args) {
switch (A->getOption().getID()) { switch (a->getOption().getID()) {
case OPT_INPUT: case OPT_INPUT:
if (StringRef(A->getValue()).endswith_lower(".def")) if (StringRef(a->getValue()).endswith_lower(".def"))
Add("-def:" + StringRef(A->getValue())); add("-def:" + StringRef(a->getValue()));
else else
Add(Prefix + StringRef(A->getValue())); add(prefix + StringRef(a->getValue()));
break; break;
case OPT_l: case OPT_l:
Add(Prefix + searchLibrary(A->getValue(), SearchPaths, Static)); add(prefix + searchLibrary(a->getValue(), searchPaths, isStatic));
break; break;
case OPT_whole_archive: case OPT_whole_archive:
Prefix = "-wholearchive:"; prefix = "-wholearchive:";
break; break;
case OPT_no_whole_archive: case OPT_no_whole_archive:
Prefix = ""; prefix = "";
break; break;
case OPT_Bstatic: case OPT_Bstatic:
Static = true; isStatic = true;
break; break;
case OPT_Bdynamic: case OPT_Bdynamic:
Static = false; isStatic = false;
break; break;
} }
} }
if (Args.hasArg(OPT_verbose) || Args.hasArg(OPT__HASH_HASH_HASH)) if (args.hasArg(OPT_verbose) || args.hasArg(OPT__HASH_HASH_HASH))
outs() << llvm::join(LinkArgs, " ") << "\n"; outs() << llvm::join(linkArgs, " ") << "\n";
if (Args.hasArg(OPT__HASH_HASH_HASH)) if (args.hasArg(OPT__HASH_HASH_HASH))
return true; return true;
// Repack vector of strings to vector of const char pointers for coff::link. // Repack vector of strings to vector of const char pointers for coff::link.
std::vector<const char *> Vec; std::vector<const char *> vec;
for (const std::string &S : LinkArgs) for (const std::string &s : linkArgs)
Vec.push_back(S.c_str()); vec.push_back(s.c_str());
return coff::link(Vec, true); return coff::link(vec, true);
} }

lld/trunk/include/lld/Common/Args.h

Show All 17 Lines
namespace opt { namespace opt {
class InputArgList; class InputArgList;
} }
} // namespace llvm } // namespace llvm
namespace lld { namespace lld {
namespace args { namespace args {
llvm::CodeGenOpt::Level getCGOptLevel(int OptLevelLTO); llvm::CodeGenOpt::Level getCGOptLevel(int optLevelLTO);
int64_t getInteger(llvm::opt::InputArgList &Args, unsigned Key, int64_t getInteger(llvm::opt::InputArgList &args, unsigned key,
int64_t Default); int64_t Default);
std::vector<StringRef> getStrings(llvm::opt::InputArgList &Args, int Id); std::vector<StringRef> getStrings(llvm::opt::InputArgList &args, int id);
uint64_t getZOptionValue(llvm::opt::InputArgList &Args, int Id, StringRef Key, uint64_t getZOptionValue(llvm::opt::InputArgList &args, int id, StringRef key,
uint64_t Default); uint64_t Default);
std::vector<StringRef> getLines(MemoryBufferRef MB); std::vector<StringRef> getLines(MemoryBufferRef mb);
StringRef getFilenameWithoutExe(StringRef Path); StringRef getFilenameWithoutExe(StringRef path);
} // namespace args } // namespace args
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/include/lld/Common/Driver.h

//===- lld/Common/Driver.h - Linker Driver Emulator -----------------------===// //===- lld/Common/Driver.h - Linker Driver Emulator -----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLD_COMMON_DRIVER_H #ifndef LLD_COMMON_DRIVER_H
#define LLD_COMMON_DRIVER_H #define LLD_COMMON_DRIVER_H
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
namespace lld { namespace lld {
namespace coff { namespace coff {
bool link(llvm::ArrayRef<const char *> Args, bool CanExitEarly, bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
llvm::raw_ostream &Diag = llvm::errs()); llvm::raw_ostream &diag = llvm::errs());
} }
namespace mingw { namespace mingw {
bool link(llvm::ArrayRef<const char *> Args, bool link(llvm::ArrayRef<const char *> args,
llvm::raw_ostream &Diag = llvm::errs()); llvm::raw_ostream &diag = llvm::errs());
} }
namespace elf { namespace elf {
bool link(llvm::ArrayRef<const char *> Args, bool CanExitEarly, bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
llvm::raw_ostream &Diag = llvm::errs()); llvm::raw_ostream &diag = llvm::errs());
} }
namespace mach_o { namespace mach_o {
bool link(llvm::ArrayRef<const char *> Args, bool CanExitEarly, bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
llvm::raw_ostream &Diag = llvm::errs()); llvm::raw_ostream &diag = llvm::errs());
} }
namespace wasm { namespace wasm {
bool link(llvm::ArrayRef<const char *> Args, bool CanExitEarly, bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
llvm::raw_ostream &Diag = llvm::errs()); llvm::raw_ostream &diag = llvm::errs());
} }
} }
#endif #endif

lld/trunk/include/lld/Common/ErrorHandler.h

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
namespace llvm { namespace llvm {
class DiagnosticInfo; class DiagnosticInfo;
} }
namespace lld { namespace lld {
class ErrorHandler { class ErrorHandler {
public: public:
uint64_t ErrorCount = 0; uint64_t errorCount = 0;
uint64_t ErrorLimit = 20; uint64_t errorLimit = 20;
StringRef ErrorLimitExceededMsg = "too many errors emitted, stopping now"; StringRef errorLimitExceededMsg = "too many errors emitted, stopping now";
StringRef LogName = "lld"; StringRef logName = "lld";
llvm::raw_ostream *ErrorOS = &llvm::errs(); llvm::raw_ostream *errorOS = &llvm::errs();
bool ColorDiagnostics = llvm::errs().has_colors(); bool colorDiagnostics = llvm::errs().has_colors();
bool ExitEarly = true; bool exitEarly = true;
bool FatalWarnings = false; bool fatalWarnings = false;
bool Verbose = false; bool verbose = false;
void error(const Twine &Msg); void error(const Twine &msg);
LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &Msg); LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &msg);
void log(const Twine &Msg); void log(const Twine &msg);
void message(const Twine &Msg); void message(const Twine &msg);
void warn(const Twine &Msg); void warn(const Twine &msg);
std::unique_ptr<llvm::FileOutputBuffer> OutputBuffer; std::unique_ptr<llvm::FileOutputBuffer> outputBuffer;
private: private:
void print(StringRef S, raw_ostream::Colors C); void print(StringRef s, raw_ostream::Colors c);
}; };
/// Returns the default error handler. /// Returns the default error handler.
ErrorHandler &errorHandler(); ErrorHandler &errorHandler();
inline void error(const Twine &Msg) { errorHandler().error(Msg); } inline void error(const Twine &msg) { errorHandler().error(msg); }
inline LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &Msg) { inline LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &msg) {
errorHandler().fatal(Msg); errorHandler().fatal(msg);
} }
inline void log(const Twine &Msg) { errorHandler().log(Msg); } inline void log(const Twine &msg) { errorHandler().log(msg); }
inline void message(const Twine &Msg) { errorHandler().message(Msg); } inline void message(const Twine &msg) { errorHandler().message(msg); }
inline void warn(const Twine &Msg) { errorHandler().warn(Msg); } inline void warn(const Twine &msg) { errorHandler().warn(msg); }
inline uint64_t errorCount() { return errorHandler().ErrorCount; } inline uint64_t errorCount() { return errorHandler().errorCount; }
LLVM_ATTRIBUTE_NORETURN void exitLld(int Val); LLVM_ATTRIBUTE_NORETURN void exitLld(int val);
void diagnosticHandler(const llvm::DiagnosticInfo &DI); void diagnosticHandler(const llvm::DiagnosticInfo &di);
void checkError(Error E); void checkError(Error e);
// check functions are convenient functions to strip errors // check functions are convenient functions to strip errors
// from error-or-value objects. // from error-or-value objects.
template <class T> T check(ErrorOr<T> E) { template <class T> T check(ErrorOr<T> e) {
if (auto EC = E.getError()) if (auto ec = e.getError())
fatal(EC.message()); fatal(ec.message());
return std::move(*E); return std::move(*e);
} }
template <class T> T check(Expected<T> E) { template <class T> T check(Expected<T> e) {
if (!E) if (!e)
fatal(llvm::toString(E.takeError())); fatal(llvm::toString(e.takeError()));
return std::move(*E); return std::move(*e);
} }
template <class T> template <class T>
T check2(ErrorOr<T> E, llvm::function_ref<std::string()> Prefix) { T check2(ErrorOr<T> e, llvm::function_ref<std::string()> prefix) {
if (auto EC = E.getError()) if (auto ec = e.getError())
fatal(Prefix() + ": " + EC.message()); fatal(prefix() + ": " + ec.message());
return std::move(*E); return std::move(*e);
} }
template <class T> template <class T>
T check2(Expected<T> E, llvm::function_ref<std::string()> Prefix) { T check2(Expected<T> e, llvm::function_ref<std::string()> prefix) {
if (!E) if (!e)
fatal(Prefix() + ": " + toString(E.takeError())); fatal(prefix() + ": " + toString(e.takeError()));
return std::move(*E); return std::move(*e);
} }
inline std::string toString(const Twine &S) { return S.str(); } inline std::string toString(const Twine &s) { return s.str(); }
// To evaluate the second argument lazily, we use C macro. // To evaluate the second argument lazily, we use C macro.
#define CHECK(E, S) check2((E), [&] { return toString(S); }) #define CHECK(E, S) check2((E), [&] { return toString(S); })
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/include/lld/Common/Filesystem.h

//===- Filesystem.h ---------------------------------------------*- C++ -*-===// //===- Filesystem.h ---------------------------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLD_FILESYSTEM_H #ifndef LLD_FILESYSTEM_H
#define LLD_FILESYSTEM_H #define LLD_FILESYSTEM_H
#include "lld/Common/LLVM.h" #include "lld/Common/LLVM.h"
#include <system_error> #include <system_error>
namespace lld { namespace lld {
void unlinkAsync(StringRef Path); void unlinkAsync(StringRef path);
std::error_code tryCreateFile(StringRef Path); std::error_code tryCreateFile(StringRef path);
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/include/lld/Common/Memory.h

Show All 22 Lines
#include "llvm/Support/Allocator.h" #include "llvm/Support/Allocator.h"
#include "llvm/Support/StringSaver.h" #include "llvm/Support/StringSaver.h"
#include <vector> #include <vector>
namespace lld { namespace lld {
// Use this arena if your object doesn't have a destructor. // Use this arena if your object doesn't have a destructor.
extern llvm::BumpPtrAllocator BAlloc; extern llvm::BumpPtrAllocator bAlloc;
extern llvm::StringSaver Saver; extern llvm::StringSaver saver;
void freeArena(); void freeArena();
// These two classes are hack to keep track of all // These two classes are hack to keep track of all
// SpecificBumpPtrAllocator instances. // SpecificBumpPtrAllocator instances.
struct SpecificAllocBase { struct SpecificAllocBase {
SpecificAllocBase() { Instances.push_back(this); } SpecificAllocBase() { instances.push_back(this); }
virtual ~SpecificAllocBase() = default; virtual ~SpecificAllocBase() = default;
virtual void reset() = 0; virtual void reset() = 0;
static std::vector<SpecificAllocBase *> Instances; static std::vector<SpecificAllocBase *> instances;
}; };
template <class T> struct SpecificAlloc : public SpecificAllocBase { template <class T> struct SpecificAlloc : public SpecificAllocBase {
void reset() override { Alloc.DestroyAll(); } void reset() override { alloc.DestroyAll(); }
llvm::SpecificBumpPtrAllocator<T> Alloc; llvm::SpecificBumpPtrAllocator<T> alloc;
}; };
// Use this arena if your object has a destructor. // Use this arena if your object has a destructor.
// Your destructor will be invoked from freeArena(). // Your destructor will be invoked from freeArena().
template <typename T, typename... U> T *make(U &&... Args) { template <typename T, typename... U> T *make(U &&... args) {
static SpecificAlloc<T> Alloc; static SpecificAlloc<T> alloc;
return new (Alloc.Alloc.Allocate()) T(std::forward<U>(Args)...); return new (alloc.alloc.Allocate()) T(std::forward<U>(args)...);
} }
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/include/lld/Common/Reproduce.h

Show All 16 Lines
namespace opt { class Arg; } namespace opt { class Arg; }
} }
namespace lld { namespace lld {
// Makes a given pathname an absolute path first, and then remove // Makes a given pathname an absolute path first, and then remove
// beginning /. For example, "../foo.o" is converted to "home/john/foo.o", // beginning /. For example, "../foo.o" is converted to "home/john/foo.o",
// assuming that the current directory is "/home/john/bar". // assuming that the current directory is "/home/john/bar".
std::string relativeToRoot(StringRef Path); std::string relativeToRoot(StringRef path);
// Quote a given string if it contains a space character. // Quote a given string if it contains a space character.
std::string quote(StringRef S); std::string quote(StringRef s);
// Returns the string form of the given argument. // Returns the string form of the given argument.
std::string toString(const llvm::opt::Arg &Arg); std::string toString(const llvm::opt::Arg &arg);
} }
#endif #endif

lld/trunk/include/lld/Common/Strings.h

Show All 13 Lines
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/GlobPattern.h" #include "llvm/Support/GlobPattern.h"
#include <string> #include <string>
#include <vector> #include <vector>
namespace lld { namespace lld {
// Returns a demangled C++ symbol name. If Name is not a mangled // Returns a demangled C++ symbol name. If Name is not a mangled
// name, it returns Optional::None. // name, it returns Optional::None.
llvm::Optional<std::string> demangleItanium(llvm::StringRef Name); llvm::Optional<std::string> demangleItanium(llvm::StringRef name);
llvm::Optional<std::string> demangleMSVC(llvm::StringRef S); llvm::Optional<std::string> demangleMSVC(llvm::StringRef s);
std::vector<uint8_t> parseHex(llvm::StringRef S); std::vector<uint8_t> parseHex(llvm::StringRef s);
bool isValidCIdentifier(llvm::StringRef S); bool isValidCIdentifier(llvm::StringRef s);
// Write the contents of the a buffer to a file // Write the contents of the a buffer to a file
void saveBuffer(llvm::StringRef Buffer, const llvm::Twine &Path); void saveBuffer(llvm::StringRef buffer, const llvm::Twine &path);
// This class represents multiple glob patterns. // This class represents multiple glob patterns.
class StringMatcher { class StringMatcher {
public: public:
StringMatcher() = default; StringMatcher() = default;
explicit StringMatcher(llvm::ArrayRef<llvm::StringRef> Pat); explicit StringMatcher(llvm::ArrayRef<llvm::StringRef> pat);
bool match(llvm::StringRef S) const; bool match(llvm::StringRef s) const;
private: private:
std::vector<llvm::GlobPattern> Patterns; std::vector<llvm::GlobPattern> patterns;
}; };
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/include/lld/Common/Threads.h

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
#ifndef LLD_COMMON_THREADS_H #ifndef LLD_COMMON_THREADS_H
#define LLD_COMMON_THREADS_H #define LLD_COMMON_THREADS_H
#include "llvm/Support/Parallel.h" #include "llvm/Support/Parallel.h"
#include <functional> #include <functional>
namespace lld { namespace lld {
extern bool ThreadsEnabled; extern bool threadsEnabled;
template <typename R, class FuncTy> void parallelForEach(R &&Range, FuncTy Fn) { template <typename R, class FuncTy> void parallelForEach(R &&range, FuncTy fn) {
if (ThreadsEnabled) if (threadsEnabled)
for_each(llvm::parallel::par, std::begin(Range), std::end(Range), Fn); for_each(llvm::parallel::par, std::begin(range), std::end(range), fn);
else else
for_each(llvm::parallel::seq, std::begin(Range), std::end(Range), Fn); for_each(llvm::parallel::seq, std::begin(range), std::end(range), fn);
} }
inline void parallelForEachN(size_t Begin, size_t End, inline void parallelForEachN(size_t begin, size_t end,
llvm::function_ref<void(size_t)> Fn) { llvm::function_ref<void(size_t)> fn) {
if (ThreadsEnabled) if (threadsEnabled)
for_each_n(llvm::parallel::par, Begin, End, Fn); for_each_n(llvm::parallel::par, begin, end, fn);
else else
for_each_n(llvm::parallel::seq, Begin, End, Fn); for_each_n(llvm::parallel::seq, begin, end, fn);
} }
template <typename R, class FuncTy> void parallelSort(R &&Range, FuncTy Fn) { template <typename R, class FuncTy> void parallelSort(R &&range, FuncTy fn) {
if (ThreadsEnabled) if (threadsEnabled)
sort(llvm::parallel::par, std::begin(Range), std::end(Range), Fn); sort(llvm::parallel::par, std::begin(range), std::end(range), fn);
else else
sort(llvm::parallel::seq, std::begin(Range), std::end(Range), Fn); sort(llvm::parallel::seq, std::begin(range), std::end(range), fn);
} }
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/include/lld/Common/Timer.h

Show All 15 Lines
#include <map> #include <map>
#include <memory> #include <memory>
namespace lld { namespace lld {
class Timer; class Timer;
struct ScopedTimer { struct ScopedTimer {
explicit ScopedTimer(Timer &T); explicit ScopedTimer(Timer &t);
~ScopedTimer(); ~ScopedTimer();
void stop(); void stop();
Timer *T = nullptr; Timer *t = nullptr;
}; };
class Timer { class Timer {
public: public:
Timer(llvm::StringRef Name, Timer &Parent); Timer(llvm::StringRef name, Timer &parent);
static Timer &root(); static Timer &root();
void start(); void start();
void stop(); void stop();
void print(); void print();
double millis() const; double millis() const;
private: private:
explicit Timer(llvm::StringRef Name); explicit Timer(llvm::StringRef name);
void print(int Depth, double TotalDuration, bool Recurse = true) const; void print(int depth, double totalDuration, bool recurse = true) const;
std::chrono::time_point<std::chrono::high_resolution_clock> StartTime; std::chrono::time_point<std::chrono::high_resolution_clock> startTime;
std::chrono::nanoseconds Total; std::chrono::nanoseconds total;
std::vector<Timer *> Children; std::vector<Timer *> children;
std::string Name; std::string name;
Timer *Parent; Timer *parent;
}; };
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/lib/Driver/DarwinLdDriver.cpp

Show First 20 Lines • Show All 327 Lines • ▼ Show 20 Lines if (missingCount) {
return false; return false;
} }
for (auto unknownArg : parsedArgs.filtered(OPT_UNKNOWN)) { for (auto unknownArg : parsedArgs.filtered(OPT_UNKNOWN)) {
warn("ignoring unknown argument: " + warn("ignoring unknown argument: " +
Twine(unknownArg->getAsString(parsedArgs))); Twine(unknownArg->getAsString(parsedArgs)));
} }
errorHandler().Verbose = parsedArgs.hasArg(OPT_v); errorHandler().verbose = parsedArgs.hasArg(OPT_v);
errorHandler().ErrorLimit = args::getInteger(parsedArgs, OPT_error_limit, 20); errorHandler().errorLimit = args::getInteger(parsedArgs, OPT_error_limit, 20);
// Figure out output kind ( -dylib, -r, -bundle, -preload, or -static ) // Figure out output kind ( -dylib, -r, -bundle, -preload, or -static )
llvm::MachO::HeaderFileType fileType = llvm::MachO::MH_EXECUTE; llvm::MachO::HeaderFileType fileType = llvm::MachO::MH_EXECUTE;
bool isStaticExecutable = false; bool isStaticExecutable = false;
if (llvm::opt::Arg *kind = parsedArgs.getLastArg( if (llvm::opt::Arg *kind = parsedArgs.getLastArg(
OPT_dylib, OPT_relocatable, OPT_bundle, OPT_static, OPT_preload)) { OPT_dylib, OPT_relocatable, OPT_bundle, OPT_static, OPT_preload)) {
switch (kind->getOption().getID()) { switch (kind->getOption().getID()) {
case OPT_dylib: case OPT_dylib:
▲ Show 20 Lines • Show All 286 Lines • ▼ Show 20 Lines if (!parsedArgs.hasArg(OPT_Z)) {
ctx.addModifiedSearchDir("/usr/lib", true); ctx.addModifiedSearchDir("/usr/lib", true);
ctx.addModifiedSearchDir("/usr/local/lib", true); ctx.addModifiedSearchDir("/usr/local/lib", true);
ctx.addFrameworkSearchDir("/Library/Frameworks", true); ctx.addFrameworkSearchDir("/Library/Frameworks", true);
ctx.addFrameworkSearchDir("/System/Library/Frameworks", true); ctx.addFrameworkSearchDir("/System/Library/Frameworks", true);
} }
// Now that we've constructed the final set of search paths, print out those // Now that we've constructed the final set of search paths, print out those
// search paths in verbose mode. // search paths in verbose mode.
if (errorHandler().Verbose) { if (errorHandler().verbose) {
message("Library search paths:"); message("Library search paths:");
for (auto path : ctx.searchDirs()) { for (auto path : ctx.searchDirs()) {
message(" " + path); message(" " + path);
} }
message("Framework search paths:"); message("Framework search paths:");
for (auto path : ctx.frameworkDirs()) { for (auto path : ctx.frameworkDirs()) {
message(" " + path); message(" " + path);
} }
▲ Show 20 Lines • Show All 491 Lines • ▼ Show 20 Lines for (auto i = Files.rbegin(), e = Files.rend(); i != e; ++i) {
auto &members = ctx.getNodes(); auto &members = ctx.getNodes();
members.insert(members.begin(), llvm::make_unique<FileNode>(std::move(*i))); members.insert(members.begin(), llvm::make_unique<FileNode>(std::move(*i)));
} }
} }
/// This is where the link is actually performed. /// This is where the link is actually performed.
bool link(llvm::ArrayRef<const char *> args, bool CanExitEarly, bool link(llvm::ArrayRef<const char *> args, bool CanExitEarly,
raw_ostream &Error) { raw_ostream &Error) {
errorHandler().LogName = args::getFilenameWithoutExe(args[0]); errorHandler().logName = args::getFilenameWithoutExe(args[0]);
errorHandler().ErrorLimitExceededMsg = errorHandler().errorLimitExceededMsg =
"too many errors emitted, stopping now (use " "too many errors emitted, stopping now (use "
"'-error-limit 0' to see all errors)"; "'-error-limit 0' to see all errors)";
errorHandler().ErrorOS = &Error; errorHandler().errorOS = &Error;
errorHandler().ExitEarly = CanExitEarly; errorHandler().exitEarly = CanExitEarly;
errorHandler().ColorDiagnostics = Error.has_colors(); errorHandler().colorDiagnostics = Error.has_colors();
MachOLinkingContext ctx; MachOLinkingContext ctx;
if (!parse(args, ctx)) if (!parse(args, ctx))
return false; return false;
if (ctx.doNothing()) if (ctx.doNothing())
return true; return true;
if (ctx.getNodes().empty()) if (ctx.getNodes().empty())
return false; return false;
Show All 28 Linesbool link(llvm::ArrayRef<const char *> args, bool CanExitEarly,
// Run passes on linked atoms. // Run passes on linked atoms.
ScopedTask passTask(getDefaultDomain(), "Passes"); ScopedTask passTask(getDefaultDomain(), "Passes");
PassManager pm; PassManager pm;
ctx.addPasses(pm); ctx.addPasses(pm);
if (auto ec = pm.runOnFile(*merged)) { if (auto ec = pm.runOnFile(*merged)) {
// FIXME: This should be passed to logAllUnhandledErrors but it needs // FIXME: This should be passed to logAllUnhandledErrors but it needs
// to be passed a Twine instead of a string. // to be passed a Twine instead of a string.
*errorHandler().ErrorOS << "Failed to run passes on file '" *errorHandler().errorOS << "Failed to run passes on file '"
<< ctx.outputPath() << "': "; << ctx.outputPath() << "': ";
logAllUnhandledErrors(std::move(ec), *errorHandler().ErrorOS, logAllUnhandledErrors(std::move(ec), *errorHandler().errorOS,
std::string()); std::string());
return false; return false;
} }
passTask.end(); passTask.end();
// Give linked atoms to Writer to generate output file. // Give linked atoms to Writer to generate output file.
ScopedTask writeTask(getDefaultDomain(), "Write"); ScopedTask writeTask(getDefaultDomain(), "Write");
if (auto ec = ctx.writeFile(*merged)) { if (auto ec = ctx.writeFile(*merged)) {
// FIXME: This should be passed to logAllUnhandledErrors but it needs // FIXME: This should be passed to logAllUnhandledErrors but it needs
// to be passed a Twine instead of a string. // to be passed a Twine instead of a string.
*errorHandler().ErrorOS << "Failed to write file '" << ctx.outputPath() *errorHandler().errorOS << "Failed to write file '" << ctx.outputPath()
<< "': "; << "': ";
logAllUnhandledErrors(std::move(ec), *errorHandler().ErrorOS, logAllUnhandledErrors(std::move(ec), *errorHandler().errorOS,
std::string()); std::string());
return false; return false;
} }
// Call exit() if we can to avoid calling destructors. // Call exit() if we can to avoid calling destructors.
if (CanExitEarly) if (CanExitEarly)
exitLld(errorCount() ? 1 : 0); exitLld(errorCount() ? 1 : 0);
return true; return true;
} }
} // end namespace mach_o } // end namespace mach_o
} // end namespace lld } // end namespace lld

lld/trunk/tools/lld/lld.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
enum Flavor { enum Flavor {
Invalid, Invalid,
Gnu, // -flavor gnu Gnu, // -flavor gnu
WinLink, // -flavor link WinLink, // -flavor link
Darwin, // -flavor darwin Darwin, // -flavor darwin
Wasm, // -flavor wasm Wasm, // -flavor wasm
}; };
LLVM_ATTRIBUTE_NORETURN static void die(const Twine &S) { LLVM_ATTRIBUTE_NORETURN static void die(const Twine &s) {
errs() << S << "\n"; errs() << s << "\n";
exit(1); exit(1);
} }
static Flavor getFlavor(StringRef S) { static Flavor getFlavor(StringRef s) {
return StringSwitch<Flavor>(S) return StringSwitch<Flavor>(s)
.CasesLower("ld", "ld.lld", "gnu", Gnu) .CasesLower("ld", "ld.lld", "gnu", Gnu)
.CasesLower("wasm", "ld-wasm", Wasm) .CasesLower("wasm", "ld-wasm", Wasm)
.CaseLower("link", WinLink) .CaseLower("link", WinLink)
.CasesLower("ld64", "ld64.lld", "darwin", Darwin) .CasesLower("ld64", "ld64.lld", "darwin", Darwin)
.Default(Invalid); .Default(Invalid);
} }
static cl::TokenizerCallback getDefaultQuotingStyle() { static cl::TokenizerCallback getDefaultQuotingStyle() {
if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32) if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32)
return cl::TokenizeWindowsCommandLine; return cl::TokenizeWindowsCommandLine;
return cl::TokenizeGNUCommandLine; return cl::TokenizeGNUCommandLine;
} }
static bool isPETargetName(StringRef S) { static bool isPETargetName(StringRef s) {
return S == "i386pe" || S == "i386pep" || S == "thumb2pe" || S == "arm64pe"; return s == "i386pe" || s == "i386pep" || s == "thumb2pe" || s == "arm64pe";
} }
static bool isPETarget(std::vector<const char *> &V) { static bool isPETarget(std::vector<const char *> &v) {
for (auto It = V.begin(); It + 1 != V.end(); ++It) { for (auto it = v.begin(); it + 1 != v.end(); ++it) {
if (StringRef(*It) != "-m") if (StringRef(*it) != "-m")
continue; continue;
return isPETargetName(*(It + 1)); return isPETargetName(*(it + 1));
} }
// Expand response files (arguments in the form of @<filename>) // Expand response files (arguments in the form of @<filename>)
// to allow detecting the -m argument from arguments in them. // to allow detecting the -m argument from arguments in them.
SmallVector<const char *, 256> ExpandedArgs(V.data(), V.data() + V.size()); SmallVector<const char *, 256> expandedArgs(v.data(), v.data() + v.size());
cl::ExpandResponseFiles(Saver, getDefaultQuotingStyle(), ExpandedArgs); cl::ExpandResponseFiles(saver, getDefaultQuotingStyle(), expandedArgs);
for (auto It = ExpandedArgs.begin(); It + 1 != ExpandedArgs.end(); ++It) { for (auto it = expandedArgs.begin(); it + 1 != expandedArgs.end(); ++it) {
if (StringRef(*It) != "-m") if (StringRef(*it) != "-m")
continue; continue;
return isPETargetName(*(It + 1)); return isPETargetName(*(it + 1));
} }
return false; return false;
} }
static Flavor parseProgname(StringRef Progname) { static Flavor parseProgname(StringRef progname) {
#if __APPLE__ #if __APPLE__
// Use Darwin driver for "ld" on Darwin. // Use Darwin driver for "ld" on Darwin.
if (Progname == "ld") if (Progname == "ld")
return Darwin; return Darwin;
#endif #endif
#if LLVM_ON_UNIX #if LLVM_ON_UNIX
// Use GNU driver for "ld" on other Unix-like system. // Use GNU driver for "ld" on other Unix-like system.
if (Progname == "ld") if (progname == "ld")
return Gnu; return Gnu;
#endif #endif
// Progname may be something like "lld-gnu". Parse it. // Progname may be something like "lld-gnu". Parse it.
SmallVector<StringRef, 3> V; SmallVector<StringRef, 3> v;
Progname.split(V, "-"); progname.split(v, "-");
for (StringRef S : V) for (StringRef s : v)
if (Flavor F = getFlavor(S)) if (Flavor f = getFlavor(s))
return F; return f;
return Invalid; return Invalid;
} }
static Flavor parseFlavor(std::vector<const char *> &V) { static Flavor parseFlavor(std::vector<const char *> &v) {
// Parse -flavor option. // Parse -flavor option.
if (V.size() > 1 && V[1] == StringRef("-flavor")) { if (v.size() > 1 && v[1] == StringRef("-flavor")) {
if (V.size() <= 2) if (v.size() <= 2)
die("missing arg value for '-flavor'"); die("missing arg value for '-flavor'");
Flavor F = getFlavor(V[2]); Flavor f = getFlavor(v[2]);
if (F == Invalid) if (f == Invalid)
die("Unknown flavor: " + StringRef(V[2])); die("Unknown flavor: " + StringRef(v[2]));
V.erase(V.begin() + 1, V.begin() + 3); v.erase(v.begin() + 1, v.begin() + 3);
return F; return f;
} }
// Deduct the flavor from argv[0]. // Deduct the flavor from argv[0].
StringRef Arg0 = path::filename(V[0]); StringRef arg0 = path::filename(v[0]);
if (Arg0.endswith_lower(".exe")) if (arg0.endswith_lower(".exe"))
Arg0 = Arg0.drop_back(4); arg0 = arg0.drop_back(4);
return parseProgname(Arg0); return parseProgname(arg0);
} }
// If this function returns true, lld calls _exit() so that it quickly // If this function returns true, lld calls _exit() so that it quickly
// exits without invoking destructors of globally allocated objects. // exits without invoking destructors of globally allocated objects.
// //
// We don't want to do that if we are running tests though, because // We don't want to do that if we are running tests though, because
// doing that breaks leak sanitizer. So, lit sets this environment variable, // doing that breaks leak sanitizer. So, lit sets this environment variable,
// and we use it to detect whether we are running tests or not. // and we use it to detect whether we are running tests or not.
static bool canExitEarly() { return StringRef(getenv("LLD_IN_TEST")) != "1"; } static bool canExitEarly() { return StringRef(getenv("LLD_IN_TEST")) != "1"; }
/// Universal linker main(). This linker emulates the gnu, darwin, or /// Universal linker main(). This linker emulates the gnu, darwin, or
/// windows linker based on the argv[0] or -flavor option. /// windows linker based on the argv[0] or -flavor option.
int main(int Argc, const char **Argv) { int main(int argc, const char **argv) {
InitLLVM X(Argc, Argv); InitLLVM x(argc, argv);
std::vector<const char *> Args(Argv, Argv + Argc); std::vector<const char *> args(argv, argv + argc);
switch (parseFlavor(Args)) { switch (parseFlavor(args)) {
case Gnu: case Gnu:
if (isPETarget(Args)) if (isPETarget(args))
return !mingw::link(Args); return !mingw::link(args);
return !elf::link(Args, canExitEarly()); return !elf::link(args, canExitEarly());
case WinLink: case WinLink:
return !coff::link(Args, canExitEarly()); return !coff::link(args, canExitEarly());
case Darwin: case Darwin:
return !mach_o::link(Args, canExitEarly()); return !mach_o::link(args, canExitEarly());
case Wasm: case Wasm:
return !wasm::link(Args, canExitEarly()); return !wasm::link(args, canExitEarly());
default: default:
die("lld is a generic driver.\n" die("lld is a generic driver.\n"
"Invoke ld.lld (Unix), ld64.lld (macOS), lld-link (Windows), wasm-ld" "Invoke ld.lld (Unix), ld64.lld (macOS), lld-link (Windows), wasm-ld"
" (WebAssembly) instead"); " (WebAssembly) instead");
} }
} }

lld/trunk/wasm/Config.h

Show All 16 Lines
namespace lld { namespace lld {
namespace wasm { namespace wasm {
// This struct contains the global configuration for the linker. // This struct contains the global configuration for the linker.
// Most fields are direct mapping from the command line options // Most fields are direct mapping from the command line options
// and such fields have the same name as the corresponding options. // and such fields have the same name as the corresponding options.
// Most fields are initialized by the driver. // Most fields are initialized by the driver.
struct Configuration { struct Configuration {
bool AllowUndefined; bool allowUndefined;
bool CheckFeatures; bool checkFeatures;
bool CompressRelocations; bool compressRelocations;
bool Demangle; bool demangle;
bool DisableVerify; bool disableVerify;
bool EmitRelocs; bool emitRelocs;
bool ExportAll; bool exportAll;
bool ExportDynamic; bool exportDynamic;
bool ExportTable; bool exportTable;
bool GcSections; bool gcSections;
bool ImportMemory; bool importMemory;
bool SharedMemory; bool sharedMemory;
bool PassiveSegments; bool passiveSegments;
bool ImportTable; bool importTable;
bool MergeDataSegments; bool mergeDataSegments;
bool Pie; bool pie;
bool PrintGcSections; bool printGcSections;
bool Relocatable; bool relocatable;
bool SaveTemps; bool saveTemps;
bool Shared; bool shared;
bool StripAll; bool stripAll;
bool StripDebug; bool stripDebug;
bool StackFirst; bool stackFirst;
bool Trace; bool trace;
uint32_t GlobalBase; uint32_t globalBase;
uint32_t InitialMemory; uint32_t initialMemory;
uint32_t MaxMemory; uint32_t maxMemory;
uint32_t ZStackSize; uint32_t zStackSize;
unsigned LTOPartitions; unsigned ltoPartitions;
unsigned LTOO; unsigned ltoo;
unsigned Optimize; unsigned optimize;
unsigned ThinLTOJobs; unsigned thinLTOJobs;
llvm::StringRef Entry; llvm::StringRef entry;
llvm::StringRef OutputFile; llvm::StringRef outputFile;
llvm::StringRef ThinLTOCacheDir; llvm::StringRef thinLTOCacheDir;
llvm::StringSet<> AllowUndefinedSymbols; llvm::StringSet<> allowUndefinedSymbols;
llvm::StringSet<> ExportedSymbols; llvm::StringSet<> exportedSymbols;
std::vector<llvm::StringRef> SearchPaths; std::vector<llvm::StringRef> searchPaths;
llvm::CachePruningPolicy ThinLTOCachePolicy; llvm::CachePruningPolicy thinLTOCachePolicy;
llvm::Optional<std::vector<std::string>> Features; llvm::Optional<std::vector<std::string>> features;
// The following config options do not directly correspond to any // The following config options do not directly correspond to any
// particualr command line options. // particualr command line options.
// True if we are creating position-independent code. // True if we are creating position-independent code.
bool Pic; bool isPic;
}; };
// The only instance of Configuration struct. // The only instance of Configuration struct.
extern Configuration *Config; extern Configuration *config;
} // namespace wasm } // namespace wasm
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/wasm/Driver.cpp

Show All 34 Lines
using namespace llvm; using namespace llvm;
using namespace llvm::object; using namespace llvm::object;
using namespace llvm::sys; using namespace llvm::sys;
using namespace llvm::wasm; using namespace llvm::wasm;
using namespace lld; using namespace lld;
using namespace lld::wasm; using namespace lld::wasm;
Configuration *lld::wasm::Config; Configuration *lld::wasm::config;
namespace { namespace {
// Create enum with OPT_xxx values for each option in Options.td // Create enum with OPT_xxx values for each option in Options.td
enum { enum {
OPT_INVALID = 0, OPT_INVALID = 0,
#define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID, #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
#include "Options.inc" #include "Options.inc"
#undef OPTION #undef OPTION
}; };
// This function is called on startup. We need this for LTO since // This function is called on startup. We need this for LTO since
// LTO calls LLVM functions to compile bitcode files to native code. // LTO calls LLVM functions to compile bitcode files to native code.
// Technically this can be delayed until we read bitcode files, but // Technically this can be delayed until we read bitcode files, but
// we don't bother to do lazily because the initialization is fast. // we don't bother to do lazily because the initialization is fast.
static void initLLVM() { static void initLLVM() {
InitializeAllTargets(); InitializeAllTargets();
InitializeAllTargetMCs(); InitializeAllTargetMCs();
InitializeAllAsmPrinters(); InitializeAllAsmPrinters();
InitializeAllAsmParsers(); InitializeAllAsmParsers();
} }
class LinkerDriver { class LinkerDriver {
public: public:
void link(ArrayRef<const char *> ArgsArr); void link(ArrayRef<const char *> argsArr);
private: private:
void createFiles(opt::InputArgList &Args); void createFiles(opt::InputArgList &args);
void addFile(StringRef Path); void addFile(StringRef path);
void addLibrary(StringRef Name); void addLibrary(StringRef name);
// True if we are in --whole-archive and --no-whole-archive. // True if we are in --whole-archive and --no-whole-archive.
bool InWholeArchive = false; bool inWholeArchive = false;
std::vector<InputFile *> Files; std::vector<InputFile *> files;
}; };
} // anonymous namespace } // anonymous namespace
bool lld::wasm::link(ArrayRef<const char *> Args, bool CanExitEarly, bool lld::wasm::link(ArrayRef<const char *> args, bool canExitEarly,
raw_ostream &Error) { raw_ostream &error) {
errorHandler().LogName = args::getFilenameWithoutExe(Args[0]); errorHandler().logName = args::getFilenameWithoutExe(args[0]);
errorHandler().ErrorOS = &Error; errorHandler().errorOS = &error;
errorHandler().ColorDiagnostics = Error.has_colors(); errorHandler().colorDiagnostics = error.has_colors();
errorHandler().ErrorLimitExceededMsg = errorHandler().errorLimitExceededMsg =
"too many errors emitted, stopping now (use " "too many errors emitted, stopping now (use "
"-error-limit=0 to see all errors)"; "-error-limit=0 to see all errors)";
Config = make<Configuration>(); config = make<Configuration>();
Symtab = make<SymbolTable>(); symtab = make<SymbolTable>();
initLLVM(); initLLVM();
LinkerDriver().link(Args); LinkerDriver().link(args);
// Exit immediately if we don't need to return to the caller. // Exit immediately if we don't need to return to the caller.
// This saves time because the overhead of calling destructors // This saves time because the overhead of calling destructors
// for all globally-allocated objects is not negligible. // for all globally-allocated objects is not negligible.
if (CanExitEarly) if (canExitEarly)
exitLld(errorCount() ? 1 : 0); exitLld(errorCount() ? 1 : 0);
freeArena(); freeArena();
return !errorCount(); return !errorCount();
} }
// Create prefix string literals used in Options.td // Create prefix string literals used in Options.td
#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE; #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
#include "Options.inc" #include "Options.inc"
#undef PREFIX #undef PREFIX
// Create table mapping all options defined in Options.td // Create table mapping all options defined in Options.td
static const opt::OptTable::Info OptInfo[] = { static const opt::OptTable::Info optInfo[] = {
#define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12) \ #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12) \
{X1, X2, X10, X11, OPT_##ID, opt::Option::KIND##Class, \ {X1, X2, X10, X11, OPT_##ID, opt::Option::KIND##Class, \
X9, X8, OPT_##GROUP, OPT_##ALIAS, X7, X12}, X9, X8, OPT_##GROUP, OPT_##ALIAS, X7, X12},
#include "Options.inc" #include "Options.inc"
#undef OPTION #undef OPTION
}; };
namespace { namespace {
class WasmOptTable : public llvm::opt::OptTable { class WasmOptTable : public llvm::opt::OptTable {
public: public:
WasmOptTable() : OptTable(OptInfo) {} WasmOptTable() : OptTable(optInfo) {}
opt::InputArgList parse(ArrayRef<const char *> Argv); opt::InputArgList parse(ArrayRef<const char *> argv);
}; };
} // namespace } // namespace
// Set color diagnostics according to -color-diagnostics={auto,always,never} // Set color diagnostics according to -color-diagnostics={auto,always,never}
// or -no-color-diagnostics flags. // or -no-color-diagnostics flags.
static void handleColorDiagnostics(opt::InputArgList &Args) { static void handleColorDiagnostics(opt::InputArgList &args) {
auto *Arg = Args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq, auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
OPT_no_color_diagnostics); OPT_no_color_diagnostics);
if (!Arg) if (!arg)
return; return;
if (Arg->getOption().getID() == OPT_color_diagnostics) { if (arg->getOption().getID() == OPT_color_diagnostics) {
errorHandler().ColorDiagnostics = true; errorHandler().colorDiagnostics = true;
} else if (Arg->getOption().getID() == OPT_no_color_diagnostics) { } else if (arg->getOption().getID() == OPT_no_color_diagnostics) {
errorHandler().ColorDiagnostics = false; errorHandler().colorDiagnostics = false;
} else { } else {
StringRef S = Arg->getValue(); StringRef s = arg->getValue();
if (S == "always") if (s == "always")
errorHandler().ColorDiagnostics = true; errorHandler().colorDiagnostics = true;
else if (S == "never") else if (s == "never")
errorHandler().ColorDiagnostics = false; errorHandler().colorDiagnostics = false;
else if (S != "auto") else if (s != "auto")
error("unknown option: --color-diagnostics=" + S); error("unknown option: --color-diagnostics=" + s);
} }
} }
// Find a file by concatenating given paths. // Find a file by concatenating given paths.
static Optional<std::string> findFile(StringRef Path1, const Twine &Path2) { static Optional<std::string> findFile(StringRef path1, const Twine &path2) {
SmallString<128> S; SmallString<128> s;
path::append(S, Path1, Path2); path::append(s, path1, path2);
if (fs::exists(S)) if (fs::exists(s))
return S.str().str(); return s.str().str();
return None; return None;
} }
opt::InputArgList WasmOptTable::parse(ArrayRef<const char *> Argv) { opt::InputArgList WasmOptTable::parse(ArrayRef<const char *> argv) {
SmallVector<const char *, 256> Vec(Argv.data(), Argv.data() + Argv.size()); SmallVector<const char *, 256> vec(argv.data(), argv.data() + argv.size());
unsigned MissingIndex; unsigned missingIndex;
unsigned MissingCount; unsigned missingCount;
// Expand response files (arguments in the form of @<filename>) // Expand response files (arguments in the form of @<filename>)
cl::ExpandResponseFiles(Saver, cl::TokenizeGNUCommandLine, Vec); cl::ExpandResponseFiles(saver, cl::TokenizeGNUCommandLine, vec);
opt::InputArgList Args = this->ParseArgs(Vec, MissingIndex, MissingCount); opt::InputArgList args = this->ParseArgs(vec, missingIndex, missingCount);
handleColorDiagnostics(Args); handleColorDiagnostics(args);
for (auto *Arg : Args.filtered(OPT_UNKNOWN)) for (auto *arg : args.filtered(OPT_UNKNOWN))
error("unknown argument: " + Arg->getAsString(Args)); error("unknown argument: " + arg->getAsString(args));
return Args; return args;
} }
// Currently we allow a ".imports" to live alongside a library. This can // Currently we allow a ".imports" to live alongside a library. This can
// be used to specify a list of symbols which can be undefined at link // be used to specify a list of symbols which can be undefined at link
// time (imported from the environment. For example libc.a include an // time (imported from the environment. For example libc.a include an
// import file that lists the syscall functions it relies on at runtime. // import file that lists the syscall functions it relies on at runtime.
// In the long run this information would be better stored as a symbol // In the long run this information would be better stored as a symbol
// attribute/flag in the object file itself. // attribute/flag in the object file itself.
// See: https://github.com/WebAssembly/tool-conventions/issues/35 // See: https://github.com/WebAssembly/tool-conventions/issues/35
static void readImportFile(StringRef Filename) { static void readImportFile(StringRef filename) {
if (Optional<MemoryBufferRef> Buf = readFile(Filename)) if (Optional<MemoryBufferRef> buf = readFile(filename))
for (StringRef Sym : args::getLines(*Buf)) for (StringRef sym : args::getLines(*buf))
Config->AllowUndefinedSymbols.insert(Sym); config->allowUndefinedSymbols.insert(sym);
} }
// Returns slices of MB by parsing MB as an archive file. // Returns slices of MB by parsing MB as an archive file.
// Each slice consists of a member file in the archive. // Each slice consists of a member file in the archive.
std::vector<MemoryBufferRef> static getArchiveMembers(MemoryBufferRef MB) { std::vector<MemoryBufferRef> static getArchiveMembers(MemoryBufferRef mb) {
std::unique_ptr<Archive> File = std::unique_ptr<Archive> file =
CHECK(Archive::create(MB), CHECK(Archive::create(mb),
MB.getBufferIdentifier() + ": failed to parse archive"); mb.getBufferIdentifier() + ": failed to parse archive");
std::vector<MemoryBufferRef> V; std::vector<MemoryBufferRef> v;
Error Err = Error::success(); Error err = Error::success();
for (const ErrorOr<Archive::Child> &COrErr : File->children(Err)) { for (const ErrorOr<Archive::Child> &cOrErr : file->children(err)) {
Archive::Child C = Archive::Child c =
CHECK(COrErr, MB.getBufferIdentifier() + CHECK(cOrErr, mb.getBufferIdentifier() +
": could not get the child of the archive"); ": could not get the child of the archive");
MemoryBufferRef MBRef = MemoryBufferRef mbref =
CHECK(C.getMemoryBufferRef(), CHECK(c.getMemoryBufferRef(),
MB.getBufferIdentifier() + mb.getBufferIdentifier() +
": could not get the buffer for a child of the archive"); ": could not get the buffer for a child of the archive");
V.push_back(MBRef); v.push_back(mbref);
} }
if (Err) if (err)
fatal(MB.getBufferIdentifier() + fatal(mb.getBufferIdentifier() +
": Archive::children failed: " + toString(std::move(Err))); ": Archive::children failed: " + toString(std::move(err)));
// Take ownership of memory buffers created for members of thin archives. // Take ownership of memory buffers created for members of thin archives.
for (std::unique_ptr<MemoryBuffer> &MB : File->takeThinBuffers()) for (std::unique_ptr<MemoryBuffer> &mb : file->takeThinBuffers())
make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); make<std::unique_ptr<MemoryBuffer>>(std::move(mb));
return V; return v;
} }
void LinkerDriver::addFile(StringRef Path) { void LinkerDriver::addFile(StringRef path) {
Optional<MemoryBufferRef> Buffer = readFile(Path); Optional<MemoryBufferRef> buffer = readFile(path);
if (!Buffer.hasValue()) if (!buffer.hasValue())
return; return;
MemoryBufferRef MBRef = *Buffer; MemoryBufferRef mbref = *buffer;
switch (identify_magic(MBRef.getBuffer())) { switch (identify_magic(mbref.getBuffer())) {
case file_magic::archive: { case file_magic::archive: {
SmallString<128> ImportFile = Path; SmallString<128> importFile = path;
path::replace_extension(ImportFile, ".imports"); path::replace_extension(importFile, ".imports");
if (fs::exists(ImportFile)) if (fs::exists(importFile))
readImportFile(ImportFile.str()); readImportFile(importFile.str());
// Handle -whole-archive. // Handle -whole-archive.
if (InWholeArchive) { if (inWholeArchive) {
for (MemoryBufferRef &M : getArchiveMembers(MBRef)) for (MemoryBufferRef &m : getArchiveMembers(mbref))
Files.push_back(createObjectFile(M, Path)); files.push_back(createObjectFile(m, path));
return; return;
} }
std::unique_ptr<Archive> File = std::unique_ptr<Archive> file =
CHECK(Archive::create(MBRef), Path + ": failed to parse archive"); CHECK(Archive::create(mbref), path + ": failed to parse archive");
if (!File->isEmpty() && !File->hasSymbolTable()) { if (!file->isEmpty() && !file->hasSymbolTable()) {
error(MBRef.getBufferIdentifier() + error(mbref.getBufferIdentifier() +
": archive has no index; run ranlib to add one"); ": archive has no index; run ranlib to add one");
} }
Files.push_back(make<ArchiveFile>(MBRef)); files.push_back(make<ArchiveFile>(mbref));
return; return;
} }
case file_magic::bitcode: case file_magic::bitcode:
case file_magic::wasm_object: case file_magic::wasm_object:
Files.push_back(createObjectFile(MBRef)); files.push_back(createObjectFile(mbref));
break; break;
default: default:
error("unknown file type: " + MBRef.getBufferIdentifier()); error("unknown file type: " + mbref.getBufferIdentifier());
} }
} }
// Add a given library by searching it from input search paths. // Add a given library by searching it from input search paths.
void LinkerDriver::addLibrary(StringRef Name) { void LinkerDriver::addLibrary(StringRef name) {
for (StringRef Dir : Config->SearchPaths) { for (StringRef dir : config->searchPaths) {
if (Optional<std::string> S = findFile(Dir, "lib" + Name + ".a")) { if (Optional<std::string> s = findFile(dir, "lib" + name + ".a")) {
addFile(*S); addFile(*s);
return; return;
} }
} }
error("unable to find library -l" + Name); error("unable to find library -l" + name);
} }
void LinkerDriver::createFiles(opt::InputArgList &Args) { void LinkerDriver::createFiles(opt::InputArgList &args) {
for (auto *Arg : Args) { for (auto *arg : args) {
switch (Arg->getOption().getID()) { switch (arg->getOption().getID()) {
case OPT_l: case OPT_l:
addLibrary(Arg->getValue()); addLibrary(arg->getValue());
break; break;
case OPT_INPUT: case OPT_INPUT:
addFile(Arg->getValue()); addFile(arg->getValue());
break; break;
case OPT_whole_archive: case OPT_whole_archive:
InWholeArchive = true; inWholeArchive = true;
break; break;
case OPT_no_whole_archive: case OPT_no_whole_archive:
InWholeArchive = false; inWholeArchive = false;
break; break;
} }
} }
} }
static StringRef getEntry(opt::InputArgList &Args) { static StringRef getEntry(opt::InputArgList &args) {
auto *Arg = Args.getLastArg(OPT_entry, OPT_no_entry); auto *arg = args.getLastArg(OPT_entry, OPT_no_entry);
if (!Arg) { if (!arg) {
if (Args.hasArg(OPT_relocatable)) if (args.hasArg(OPT_relocatable))
return ""; return "";
if (Args.hasArg(OPT_shared)) if (args.hasArg(OPT_shared))
return "__wasm_call_ctors"; return "__wasm_call_ctors";
return "_start"; return "_start";
} }
if (Arg->getOption().getID() == OPT_no_entry) if (arg->getOption().getID() == OPT_no_entry)
return ""; return "";
return Arg->getValue(); return arg->getValue();
} }
// Initializes Config members by the command line options. // Initializes Config members by the command line options.
static void readConfigs(opt::InputArgList &Args) { static void readConfigs(opt::InputArgList &args) {
Config->AllowUndefined = Args.hasArg(OPT_allow_undefined); config->allowUndefined = args.hasArg(OPT_allow_undefined);
Config->CheckFeatures = config->checkFeatures =
Args.hasFlag(OPT_check_features, OPT_no_check_features, true); args.hasFlag(OPT_check_features, OPT_no_check_features, true);
Config->CompressRelocations = Args.hasArg(OPT_compress_relocations); config->compressRelocations = args.hasArg(OPT_compress_relocations);
Config->Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, true); config->demangle = args.hasFlag(OPT_demangle, OPT_no_demangle, true);
Config->DisableVerify = Args.hasArg(OPT_disable_verify); config->disableVerify = args.hasArg(OPT_disable_verify);
Config->EmitRelocs = Args.hasArg(OPT_emit_relocs); config->emitRelocs = args.hasArg(OPT_emit_relocs);
Config->Entry = getEntry(Args); config->entry = getEntry(args);
Config->ExportAll = Args.hasArg(OPT_export_all); config->exportAll = args.hasArg(OPT_export_all);
Config->ExportDynamic = Args.hasFlag(OPT_export_dynamic, config->exportDynamic = args.hasFlag(OPT_export_dynamic,
OPT_no_export_dynamic, false); OPT_no_export_dynamic, false);
Config->ExportTable = Args.hasArg(OPT_export_table); config->exportTable = args.hasArg(OPT_export_table);
errorHandler().FatalWarnings = errorHandler().fatalWarnings =
Args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false); args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
Config->ImportMemory = Args.hasArg(OPT_import_memory); config->importMemory = args.hasArg(OPT_import_memory);
Config->SharedMemory = Args.hasArg(OPT_shared_memory); config->sharedMemory = args.hasArg(OPT_shared_memory);
// TODO: Make passive segments the default with shared memory // TODO: Make passive segments the default with shared memory
Config->PassiveSegments = config->passiveSegments =
Args.hasFlag(OPT_passive_segments, OPT_active_segments, false); args.hasFlag(OPT_passive_segments, OPT_active_segments, false);
Config->ImportTable = Args.hasArg(OPT_import_table); config->importTable = args.hasArg(OPT_import_table);
Config->LTOO = args::getInteger(Args, OPT_lto_O, 2); config->ltoo = args::getInteger(args, OPT_lto_O, 2);
Config->LTOPartitions = args::getInteger(Args, OPT_lto_partitions, 1); config->ltoPartitions = args::getInteger(args, OPT_lto_partitions, 1);
Config->Optimize = args::getInteger(Args, OPT_O, 0); config->optimize = args::getInteger(args, OPT_O, 0);
Config->OutputFile = Args.getLastArgValue(OPT_o); config->outputFile = args.getLastArgValue(OPT_o);
Config->Relocatable = Args.hasArg(OPT_relocatable); config->relocatable = args.hasArg(OPT_relocatable);
Config->GcSections = config->gcSections =
Args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, !Config->Relocatable); args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, !config->relocatable);
Config->MergeDataSegments = config->mergeDataSegments =
Args.hasFlag(OPT_merge_data_segments, OPT_no_merge_data_segments, args.hasFlag(OPT_merge_data_segments, OPT_no_merge_data_segments,
!Config->Relocatable); !config->relocatable);
Config->Pie = Args.hasFlag(OPT_pie, OPT_no_pie, false); config->pie = args.hasFlag(OPT_pie, OPT_no_pie, false);
Config->PrintGcSections = config->printGcSections =
Args.hasFlag(OPT_print_gc_sections, OPT_no_print_gc_sections, false); args.hasFlag(OPT_print_gc_sections, OPT_no_print_gc_sections, false);
Config->SaveTemps = Args.hasArg(OPT_save_temps); config->saveTemps = args.hasArg(OPT_save_temps);
Config->SearchPaths = args::getStrings(Args, OPT_L); config->searchPaths = args::getStrings(args, OPT_L);
Config->Shared = Args.hasArg(OPT_shared); config->shared = args.hasArg(OPT_shared);
Config->StripAll = Args.hasArg(OPT_strip_all); config->stripAll = args.hasArg(OPT_strip_all);
Config->StripDebug = Args.hasArg(OPT_strip_debug); config->stripDebug = args.hasArg(OPT_strip_debug);
Config->StackFirst = Args.hasArg(OPT_stack_first); config->stackFirst = args.hasArg(OPT_stack_first);
Config->Trace = Args.hasArg(OPT_trace); config->trace = args.hasArg(OPT_trace);
Config->ThinLTOCacheDir = Args.getLastArgValue(OPT_thinlto_cache_dir); config->thinLTOCacheDir = args.getLastArgValue(OPT_thinlto_cache_dir);
Config->ThinLTOCachePolicy = CHECK( config->thinLTOCachePolicy = CHECK(
parseCachePruningPolicy(Args.getLastArgValue(OPT_thinlto_cache_policy)), parseCachePruningPolicy(args.getLastArgValue(OPT_thinlto_cache_policy)),
"--thinlto-cache-policy: invalid cache policy"); "--thinlto-cache-policy: invalid cache policy");
Config->ThinLTOJobs = args::getInteger(Args, OPT_thinlto_jobs, -1u); config->thinLTOJobs = args::getInteger(args, OPT_thinlto_jobs, -1u);
errorHandler().Verbose = Args.hasArg(OPT_verbose); errorHandler().verbose = args.hasArg(OPT_verbose);
LLVM_DEBUG(errorHandler().Verbose = true); LLVM_DEBUG(errorHandler().verbose = true);
ThreadsEnabled = Args.hasFlag(OPT_threads, OPT_no_threads, true); threadsEnabled = args.hasFlag(OPT_threads, OPT_no_threads, true);
Config->InitialMemory = args::getInteger(Args, OPT_initial_memory, 0); config->initialMemory = args::getInteger(args, OPT_initial_memory, 0);
Config->GlobalBase = args::getInteger(Args, OPT_global_base, 1024); config->globalBase = args::getInteger(args, OPT_global_base, 1024);
Config->MaxMemory = args::getInteger(Args, OPT_max_memory, 0); config->maxMemory = args::getInteger(args, OPT_max_memory, 0);
Config->ZStackSize = config->zStackSize =
args::getZOptionValue(Args, OPT_z, "stack-size", WasmPageSize); args::getZOptionValue(args, OPT_z, "stack-size", WasmPageSize);
if (auto *Arg = Args.getLastArg(OPT_features)) { if (auto *arg = args.getLastArg(OPT_features)) {
Config->Features = config->features =
llvm::Optional<std::vector<std::string>>(std::vector<std::string>()); llvm::Optional<std::vector<std::string>>(std::vector<std::string>());
for (StringRef S : Arg->getValues()) for (StringRef s : arg->getValues())
Config->Features->push_back(S); config->features->push_back(s);
} }
} }
// Some Config members do not directly correspond to any particular // Some Config members do not directly correspond to any particular
// command line options, but computed based on other Config values. // command line options, but computed based on other Config values.
// This function initialize such members. See Config.h for the details // This function initialize such members. See Config.h for the details
// of these values. // of these values.
static void setConfigs() { static void setConfigs() {
Config->Pic = Config->Pie || Config->Shared; config->isPic = config->pie || config->shared;
if (Config->Pic) { if (config->isPic) {
if (Config->ExportTable) if (config->exportTable)
error("-shared/-pie is incompatible with --export-table"); error("-shared/-pie is incompatible with --export-table");
Config->ImportTable = true; config->importTable = true;
} }
if (Config->Shared) { if (config->shared) {
Config->ImportMemory = true; config->importMemory = true;
Config->ExportDynamic = true; config->exportDynamic = true;
Config->AllowUndefined = true; config->allowUndefined = true;
} }
} }
// Some command line options or some combinations of them are not allowed. // Some command line options or some combinations of them are not allowed.
// This function checks for such errors. // This function checks for such errors.
static void checkOptions(opt::InputArgList &Args) { static void checkOptions(opt::InputArgList &args) {
if (!Config->StripDebug && !Config->StripAll && Config->CompressRelocations) if (!config->stripDebug && !config->stripAll && config->compressRelocations)
error("--compress-relocations is incompatible with output debug" error("--compress-relocations is incompatible with output debug"
" information. Please pass --strip-debug or --strip-all"); " information. Please pass --strip-debug or --strip-all");
if (Config->LTOO > 3) if (config->ltoo > 3)
error("invalid optimization level for LTO: " + Twine(Config->LTOO)); error("invalid optimization level for LTO: " + Twine(config->ltoo));
if (Config->LTOPartitions == 0) if (config->ltoPartitions == 0)
error("--lto-partitions: number of threads must be > 0"); error("--lto-partitions: number of threads must be > 0");
if (Config->ThinLTOJobs == 0) if (config->thinLTOJobs == 0)
error("--thinlto-jobs: number of threads must be > 0"); error("--thinlto-jobs: number of threads must be > 0");
if (Config->Pie && Config->Shared) if (config->pie && config->shared)
error("-shared and -pie may not be used together"); error("-shared and -pie may not be used together");
if (Config->OutputFile.empty()) if (config->outputFile.empty())
error("no output file specified"); error("no output file specified");
if (Config->ImportTable && Config->ExportTable) if (config->importTable && config->exportTable)
error("--import-table and --export-table may not be used together"); error("--import-table and --export-table may not be used together");
if (Config->Relocatable) { if (config->relocatable) {
if (!Config->Entry.empty()) if (!config->entry.empty())
error("entry point specified for relocatable output file"); error("entry point specified for relocatable output file");
if (Config->GcSections) if (config->gcSections)
error("-r and --gc-sections may not be used together"); error("-r and --gc-sections may not be used together");
if (Config->CompressRelocations) if (config->compressRelocations)
error("-r -and --compress-relocations may not be used together"); error("-r -and --compress-relocations may not be used together");
if (Args.hasArg(OPT_undefined)) if (args.hasArg(OPT_undefined))
error("-r -and --undefined may not be used together"); error("-r -and --undefined may not be used together");
if (Config->Pie) if (config->pie)
error("-r and -pie may not be used together"); error("-r and -pie may not be used together");
} }
} }
// Force Sym to be entered in the output. Used for -u or equivalent. // Force Sym to be entered in the output. Used for -u or equivalent.
static Symbol *handleUndefined(StringRef Name) { static Symbol *handleUndefined(StringRef name) {
Symbol *Sym = Symtab->find(Name); Symbol *sym = symtab->find(name);
if (!Sym) if (!sym)
return nullptr; return nullptr;
// Since symbol S may not be used inside the program, LTO may // Since symbol S may not be used inside the program, LTO may
// eliminate it. Mark the symbol as "used" to prevent it. // eliminate it. Mark the symbol as "used" to prevent it.
Sym->IsUsedInRegularObj = true; sym->isUsedInRegularObj = true;
if (auto *LazySym = dyn_cast<LazySymbol>(Sym)) if (auto *lazySym = dyn_cast<LazySymbol>(sym))
LazySym->fetch(); lazySym->fetch();
return Sym; return sym;
} }
static UndefinedGlobal * static UndefinedGlobal *
createUndefinedGlobal(StringRef Name, llvm::wasm::WasmGlobalType *Type) { createUndefinedGlobal(StringRef name, llvm::wasm::WasmGlobalType *type) {
auto *Sym = auto *sym =
cast<UndefinedGlobal>(Symtab->addUndefinedGlobal(Name, Name, cast<UndefinedGlobal>(symtab->addUndefinedGlobal(name, name,
DefaultModule, 0, defaultModule, 0,
nullptr, Type)); nullptr, type));
Config->AllowUndefinedSymbols.insert(Sym->getName()); config->allowUndefinedSymbols.insert(sym->getName());
Sym->IsUsedInRegularObj = true; sym->isUsedInRegularObj = true;
return Sym; return sym;
} }
// Create ABI-defined synthetic symbols // Create ABI-defined synthetic symbols
static void createSyntheticSymbols() { static void createSyntheticSymbols() {
static WasmSignature NullSignature = {{}, {}}; static WasmSignature nullSignature = {{}, {}};
static llvm::wasm::WasmGlobalType GlobalTypeI32 = {WASM_TYPE_I32, false}; static llvm::wasm::WasmGlobalType globalTypeI32 = {WASM_TYPE_I32, false};
static llvm::wasm::WasmGlobalType MutableGlobalTypeI32 = {WASM_TYPE_I32, static llvm::wasm::WasmGlobalType mutableGlobalTypeI32 = {WASM_TYPE_I32,
true}; true};
if (!Config->Relocatable) { if (!config->relocatable) {
WasmSym::CallCtors = Symtab->addSyntheticFunction( WasmSym::callCtors = symtab->addSyntheticFunction(
"__wasm_call_ctors", WASM_SYMBOL_VISIBILITY_HIDDEN, "__wasm_call_ctors", WASM_SYMBOL_VISIBILITY_HIDDEN,
make<SyntheticFunction>(NullSignature, "__wasm_call_ctors")); make<SyntheticFunction>(nullSignature, "__wasm_call_ctors"));
if (Config->PassiveSegments) { if (config->passiveSegments) {
// Passive segments are used to avoid memory being reinitialized on each // Passive segments are used to avoid memory being reinitialized on each
// thread's instantiation. These passive segments are initialized and // thread's instantiation. These passive segments are initialized and
// dropped in __wasm_init_memory, which is the first function called from // dropped in __wasm_init_memory, which is the first function called from
// __wasm_call_ctors. // __wasm_call_ctors.
WasmSym::InitMemory = Symtab->addSyntheticFunction( WasmSym::initMemory = symtab->addSyntheticFunction(
"__wasm_init_memory", WASM_SYMBOL_VISIBILITY_HIDDEN, "__wasm_init_memory", WASM_SYMBOL_VISIBILITY_HIDDEN,
make<SyntheticFunction>(NullSignature, "__wasm_init_memory")); make<SyntheticFunction>(nullSignature, "__wasm_init_memory"));
} }
if (Config->Pic) { if (config->isPic) {
// For PIC code we create a synthetic function __wasm_apply_relocs which // For PIC code we create a synthetic function __wasm_apply_relocs which
// is called from __wasm_call_ctors before the user-level constructors. // is called from __wasm_call_ctors before the user-level constructors.
WasmSym::ApplyRelocs = Symtab->addSyntheticFunction( WasmSym::applyRelocs = symtab->addSyntheticFunction(
"__wasm_apply_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN, "__wasm_apply_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
make<SyntheticFunction>(NullSignature, "__wasm_apply_relocs")); make<SyntheticFunction>(nullSignature, "__wasm_apply_relocs"));
} }
} }
// The __stack_pointer is imported in the shared library case, and exported // The __stack_pointer is imported in the shared library case, and exported
// in the non-shared (executable) case. // in the non-shared (executable) case.
if (Config->Shared) { if (config->shared) {
WasmSym::StackPointer = WasmSym::stackPointer =
createUndefinedGlobal("__stack_pointer", &MutableGlobalTypeI32); createUndefinedGlobal("__stack_pointer", &mutableGlobalTypeI32);
} else { } else {
llvm::wasm::WasmGlobal Global; llvm::wasm::WasmGlobal global;
Global.Type = {WASM_TYPE_I32, true}; global.Type = {WASM_TYPE_I32, true};
Global.InitExpr.Value.Int32 = 0; global.InitExpr.Value.Int32 = 0;
Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST; global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
Global.SymbolName = "__stack_pointer"; global.SymbolName = "__stack_pointer";
auto *StackPointer = make<InputGlobal>(Global, nullptr); auto *stackPointer = make<InputGlobal>(global, nullptr);
StackPointer->Live = true; stackPointer->live = true;
// For non-PIC code // For non-PIC code
// TODO(sbc): Remove WASM_SYMBOL_VISIBILITY_HIDDEN when the mutable global // TODO(sbc): Remove WASM_SYMBOL_VISIBILITY_HIDDEN when the mutable global
// spec proposal is implemented in all major browsers. // spec proposal is implemented in all major browsers.
// See: https://github.com/WebAssembly/mutable-global // See: https://github.com/WebAssembly/mutable-global
WasmSym::StackPointer = Symtab->addSyntheticGlobal( WasmSym::stackPointer = symtab->addSyntheticGlobal(
"__stack_pointer", WASM_SYMBOL_VISIBILITY_HIDDEN, StackPointer); "__stack_pointer", WASM_SYMBOL_VISIBILITY_HIDDEN, stackPointer);
WasmSym::DataEnd = Symtab->addOptionalDataSymbol("__data_end"); WasmSym::dataEnd = symtab->addOptionalDataSymbol("__data_end");
WasmSym::GlobalBase = Symtab->addOptionalDataSymbol("__global_base"); WasmSym::globalBase = symtab->addOptionalDataSymbol("__global_base");
WasmSym::HeapBase = Symtab->addOptionalDataSymbol("__heap_base"); WasmSym::heapBase = symtab->addOptionalDataSymbol("__heap_base");
} }
if (Config->Pic) { if (config->isPic) {
// For PIC code, we import two global variables (__memory_base and // For PIC code, we import two global variables (__memory_base and
// __table_base) from the environment and use these as the offset at // __table_base) from the environment and use these as the offset at
// which to load our static data and function table. // which to load our static data and function table.
// See: // See:
// https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md // https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
WasmSym::MemoryBase = WasmSym::memoryBase =
createUndefinedGlobal("__memory_base", &GlobalTypeI32); createUndefinedGlobal("__memory_base", &globalTypeI32);
WasmSym::TableBase = createUndefinedGlobal("__table_base", &GlobalTypeI32); WasmSym::tableBase = createUndefinedGlobal("__table_base", &globalTypeI32);
WasmSym::MemoryBase->markLive(); WasmSym::memoryBase->markLive();
WasmSym::TableBase->markLive(); WasmSym::tableBase->markLive();
} }
WasmSym::DsoHandle = Symtab->addSyntheticDataSymbol( WasmSym::dsoHandle = symtab->addSyntheticDataSymbol(
"__dso_handle", WASM_SYMBOL_VISIBILITY_HIDDEN); "__dso_handle", WASM_SYMBOL_VISIBILITY_HIDDEN);
} }
// Reconstructs command line arguments so that so that you can re-run // Reconstructs command line arguments so that so that you can re-run
// the same command with the same inputs. This is for --reproduce. // the same command with the same inputs. This is for --reproduce.
static std::string createResponseFile(const opt::InputArgList &Args) { static std::string createResponseFile(const opt::InputArgList &args) {
SmallString<0> Data; SmallString<0> data;
raw_svector_ostream OS(Data); raw_svector_ostream os(data);
// Copy the command line to the output while rewriting paths. // Copy the command line to the output while rewriting paths.
for (auto *Arg : Args) { for (auto *arg : args) {
switch (Arg->getOption().getID()) { switch (arg->getOption().getID()) {
case OPT_reproduce: case OPT_reproduce:
break; break;
case OPT_INPUT: case OPT_INPUT:
OS << quote(relativeToRoot(Arg->getValue())) << "\n"; os << quote(relativeToRoot(arg->getValue())) << "\n";
break; break;
case OPT_o: case OPT_o:
// If -o path contains directories, "lld @response.txt" will likely // If -o path contains directories, "lld @response.txt" will likely
// fail because the archive we are creating doesn't contain empty // fail because the archive we are creating doesn't contain empty
// directories for the output path (-o doesn't create directories). // directories for the output path (-o doesn't create directories).
// Strip directories to prevent the issue. // Strip directories to prevent the issue.
OS << "-o " << quote(sys::path::filename(Arg->getValue())) << "\n"; os << "-o " << quote(sys::path::filename(arg->getValue())) << "\n";
break; break;
default: default:
OS << toString(*Arg) << "\n"; os << toString(*arg) << "\n";
} }
} }
return Data.str(); return data.str();
} }
// The --wrap option is a feature to rename symbols so that you can write // The --wrap option is a feature to rename symbols so that you can write
// wrappers for existing functions. If you pass `-wrap=foo`, all // wrappers for existing functions. If you pass `-wrap=foo`, all
// occurrences of symbol `foo` are resolved to `wrap_foo` (so, you are // occurrences of symbol `foo` are resolved to `wrap_foo` (so, you are
// expected to write `wrap_foo` function as a wrapper). The original // expected to write `wrap_foo` function as a wrapper). The original
// symbol becomes accessible as `real_foo`, so you can call that from your // symbol becomes accessible as `real_foo`, so you can call that from your
// wrapper. // wrapper.
// //
// This data structure is instantiated for each -wrap option. // This data structure is instantiated for each -wrap option.
struct WrappedSymbol { struct WrappedSymbol {
Symbol *Sym; Symbol *sym;
Symbol *Real; Symbol *real;
Symbol *Wrap; Symbol *wrap;
}; };
static Symbol *addUndefined(StringRef Name) { static Symbol *addUndefined(StringRef name) {
return Symtab->addUndefinedFunction(Name, "", "", 0, nullptr, nullptr, false); return symtab->addUndefinedFunction(name, "", "", 0, nullptr, nullptr, false);
} }
// Handles -wrap option. // Handles -wrap option.
// //
// This function instantiates wrapper symbols. At this point, they seem // This function instantiates wrapper symbols. At this point, they seem
// like they are not being used at all, so we explicitly set some flags so // like they are not being used at all, so we explicitly set some flags so
// that LTO won't eliminate them. // that LTO won't eliminate them.
static std::vector<WrappedSymbol> addWrappedSymbols(opt::InputArgList &Args) { static std::vector<WrappedSymbol> addWrappedSymbols(opt::InputArgList &args) {
std::vector<WrappedSymbol> V; std::vector<WrappedSymbol> v;
DenseSet<StringRef> Seen; DenseSet<StringRef> seen;
for (auto *Arg : Args.filtered(OPT_wrap)) { for (auto *arg : args.filtered(OPT_wrap)) {
StringRef Name = Arg->getValue(); StringRef name = arg->getValue();
if (!Seen.insert(Name).second) if (!seen.insert(name).second)
continue; continue;
Symbol *Sym = Symtab->find(Name); Symbol *sym = symtab->find(name);
if (!Sym) if (!sym)
continue; continue;
Symbol *Real = addUndefined(Saver.save("__real_" + Name)); Symbol *real = addUndefined(saver.save("__real_" + name));
Symbol *Wrap = addUndefined(Saver.save("__wrap_" + Name)); Symbol *wrap = addUndefined(saver.save("__wrap_" + name));
V.push_back({Sym, Real, Wrap}); v.push_back({sym, real, wrap});
// We want to tell LTO not to inline symbols to be overwritten // We want to tell LTO not to inline symbols to be overwritten
// because LTO doesn't know the final symbol contents after renaming. // because LTO doesn't know the final symbol contents after renaming.
Real->CanInline = false; real->canInline = false;
Sym->CanInline = false; sym->canInline = false;
// Tell LTO not to eliminate these symbols. // Tell LTO not to eliminate these symbols.
Sym->IsUsedInRegularObj = true; sym->isUsedInRegularObj = true;
Wrap->IsUsedInRegularObj = true; wrap->isUsedInRegularObj = true;
Real->IsUsedInRegularObj = false; real->isUsedInRegularObj = false;
} }
return V; return v;
} }
// Do renaming for -wrap by updating pointers to symbols. // Do renaming for -wrap by updating pointers to symbols.
// //
// When this function is executed, only InputFiles and symbol table // When this function is executed, only InputFiles and symbol table
// contain pointers to symbol objects. We visit them to replace pointers, // contain pointers to symbol objects. We visit them to replace pointers,
// so that wrapped symbols are swapped as instructed by the command line. // so that wrapped symbols are swapped as instructed by the command line.
static void wrapSymbols(ArrayRef<WrappedSymbol> Wrapped) { static void wrapSymbols(ArrayRef<WrappedSymbol> wrapped) {
DenseMap<Symbol *, Symbol *> Map; DenseMap<Symbol *, Symbol *> map;
for (const WrappedSymbol &W : Wrapped) { for (const WrappedSymbol &w : wrapped) {
Map[W.Sym] = W.Wrap; map[w.sym] = w.wrap;
Map[W.Real] = W.Sym; map[w.real] = w.sym;
} }
// Update pointers in input files. // Update pointers in input files.
parallelForEach(Symtab->ObjectFiles, [&](InputFile *File) { parallelForEach(symtab->objectFiles, [&](InputFile *file) {
MutableArrayRef<Symbol *> Syms = File->getMutableSymbols(); MutableArrayRef<Symbol *> syms = file->getMutableSymbols();
for (size_t I = 0, E = Syms.size(); I != E; ++I) for (size_t i = 0, e = syms.size(); i != e; ++i)
if (Symbol *S = Map.lookup(Syms[I])) if (Symbol *s = map.lookup(syms[i]))
Syms[I] = S; syms[i] = s;
}); });
// Update pointers in the symbol table. // Update pointers in the symbol table.
for (const WrappedSymbol &W : Wrapped) for (const WrappedSymbol &w : wrapped)
Symtab->wrap(W.Sym, W.Real, W.Wrap); symtab->wrap(w.sym, w.real, w.wrap);
} }
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) { void LinkerDriver::link(ArrayRef<const char *> argsArr) {
WasmOptTable Parser; WasmOptTable parser;
opt::InputArgList Args = Parser.parse(ArgsArr.slice(1)); opt::InputArgList args = parser.parse(argsArr.slice(1));
// Handle --help // Handle --help
if (Args.hasArg(OPT_help)) { if (args.hasArg(OPT_help)) {
Parser.PrintHelp(outs(), parser.PrintHelp(outs(),
(std::string(ArgsArr[0]) + " [options] file...").c_str(), (std::string(argsArr[0]) + " [options] file...").c_str(),
"LLVM Linker", false); "LLVM Linker", false);
return; return;
} }
// Handle --version // Handle --version
if (Args.hasArg(OPT_version) || Args.hasArg(OPT_v)) { if (args.hasArg(OPT_version) || args.hasArg(OPT_v)) {
outs() << getLLDVersion() << "\n"; outs() << getLLDVersion() << "\n";
return; return;
} }
// Handle --reproduce // Handle --reproduce
if (auto *Arg = Args.getLastArg(OPT_reproduce)) { if (auto *arg = args.getLastArg(OPT_reproduce)) {
StringRef Path = Arg->getValue(); StringRef path = arg->getValue();
Expected<std::unique_ptr<TarWriter>> ErrOrWriter = Expected<std::unique_ptr<TarWriter>> errOrWriter =
TarWriter::create(Path, path::stem(Path)); TarWriter::create(path, path::stem(path));
if (ErrOrWriter) { if (errOrWriter) {
Tar = std::move(*ErrOrWriter); tar = std::move(*errOrWriter);
Tar->append("response.txt", createResponseFile(Args)); tar->append("response.txt", createResponseFile(args));
Tar->append("version.txt", getLLDVersion() + "\n"); tar->append("version.txt", getLLDVersion() + "\n");
} else { } else {
error("--reproduce: " + toString(ErrOrWriter.takeError())); error("--reproduce: " + toString(errOrWriter.takeError()));
} }
} }
// Parse and evaluate -mllvm options. // Parse and evaluate -mllvm options.
std::vector<const char *> V; std::vector<const char *> v;
V.push_back("wasm-ld (LLVM option parsing)"); v.push_back("wasm-ld (LLVM option parsing)");
for (auto *Arg : Args.filtered(OPT_mllvm)) for (auto *arg : args.filtered(OPT_mllvm))
V.push_back(Arg->getValue()); v.push_back(arg->getValue());
cl::ParseCommandLineOptions(V.size(), V.data()); cl::ParseCommandLineOptions(v.size(), v.data());
errorHandler().ErrorLimit = args::getInteger(Args, OPT_error_limit, 20); errorHandler().errorLimit = args::getInteger(args, OPT_error_limit, 20);
readConfigs(Args); readConfigs(args);
setConfigs(); setConfigs();
checkOptions(Args); checkOptions(args);
if (auto *Arg = Args.getLastArg(OPT_allow_undefined_file)) if (auto *arg = args.getLastArg(OPT_allow_undefined_file))
readImportFile(Arg->getValue()); readImportFile(arg->getValue());
if (!Args.hasArg(OPT_INPUT)) { if (!args.hasArg(OPT_INPUT)) {
error("no input files"); error("no input files");
return; return;
} }
// Handle --trace-symbol. // Handle --trace-symbol.
for (auto *Arg : Args.filtered(OPT_trace_symbol)) for (auto *arg : args.filtered(OPT_trace_symbol))
Symtab->trace(Arg->getValue()); symtab->trace(arg->getValue());
for (auto *Arg : Args.filtered(OPT_export)) for (auto *arg : args.filtered(OPT_export))
Config->ExportedSymbols.insert(Arg->getValue()); config->exportedSymbols.insert(arg->getValue());
if (!Config->Relocatable) if (!config->relocatable)
createSyntheticSymbols(); createSyntheticSymbols();
createFiles(Args); createFiles(args);
if (errorCount()) if (errorCount())
return; return;
// Add all files to the symbol table. This will add almost all // Add all files to the symbol table. This will add almost all
// symbols that we need to the symbol table. // symbols that we need to the symbol table.
for (InputFile *F : Files) for (InputFile *f : files)
Symtab->addFile(F); symtab->addFile(f);
if (errorCount()) if (errorCount())
return; return;
// Handle the `--undefined <sym>` options. // Handle the `--undefined <sym>` options.
for (auto *Arg : Args.filtered(OPT_undefined)) for (auto *arg : args.filtered(OPT_undefined))
handleUndefined(Arg->getValue()); handleUndefined(arg->getValue());
// Handle the `--export <sym>` options // Handle the `--export <sym>` options
// This works like --undefined but also exports the symbol if its found // This works like --undefined but also exports the symbol if its found
for (auto *Arg : Args.filtered(OPT_export)) for (auto *arg : args.filtered(OPT_export))
handleUndefined(Arg->getValue()); handleUndefined(arg->getValue());
Symbol *EntrySym = nullptr; Symbol *entrySym = nullptr;
if (!Config->Relocatable && !Config->Entry.empty()) { if (!config->relocatable && !config->entry.empty()) {
EntrySym = handleUndefined(Config->Entry); entrySym = handleUndefined(config->entry);
if (EntrySym && EntrySym->isDefined()) if (entrySym && entrySym->isDefined())
EntrySym->ForceExport = true; entrySym->forceExport = true;
else else
error("entry symbol not defined (pass --no-entry to supress): " + error("entry symbol not defined (pass --no-entry to supress): " +
Config->Entry); config->entry);
} }
if (errorCount()) if (errorCount())
return; return;
// Create wrapped symbols for -wrap option. // Create wrapped symbols for -wrap option.
std::vector<WrappedSymbol> Wrapped = addWrappedSymbols(Args); std::vector<WrappedSymbol> wrapped = addWrappedSymbols(args);
// Do link-time optimization if given files are LLVM bitcode files. // Do link-time optimization if given files are LLVM bitcode files.
// This compiles bitcode files into real object files. // This compiles bitcode files into real object files.
Symtab->addCombinedLTOObject(); symtab->addCombinedLTOObject();
if (errorCount()) if (errorCount())
return; return;
// Resolve any variant symbols that were created due to signature // Resolve any variant symbols that were created due to signature
// mismatchs. // mismatchs.
Symtab->handleSymbolVariants(); symtab->handleSymbolVariants();
if (errorCount()) if (errorCount())
return; return;
// Apply symbol renames for -wrap. // Apply symbol renames for -wrap.
if (!Wrapped.empty()) if (!wrapped.empty())
wrapSymbols(Wrapped); wrapSymbols(wrapped);
for (auto *Arg : Args.filtered(OPT_export)) { for (auto *arg : args.filtered(OPT_export)) {
Symbol *Sym = Symtab->find(Arg->getValue()); Symbol *sym = symtab->find(arg->getValue());
if (Sym && Sym->isDefined()) if (sym && sym->isDefined())
Sym->ForceExport = true; sym->forceExport = true;
else if (!Config->AllowUndefined) else if (!config->allowUndefined)
error(Twine("symbol exported via --export not found: ") + error(Twine("symbol exported via --export not found: ") +
Arg->getValue()); arg->getValue());
} }
if (!Config->Relocatable) { if (!config->relocatable) {
// Add synthetic dummies for weak undefined functions. Must happen // Add synthetic dummies for weak undefined functions. Must happen
// after LTO otherwise functions may not yet have signatures. // after LTO otherwise functions may not yet have signatures.
Symtab->handleWeakUndefines(); symtab->handleWeakUndefines();
} }
if (EntrySym) if (entrySym)
EntrySym->setHidden(false); entrySym->setHidden(false);
if (errorCount()) if (errorCount())
return; return;
// Do size optimizations: garbage collection // Do size optimizations: garbage collection
markLive(); markLive();
// Write the result to the file. // Write the result to the file.
writeResult(); writeResult();
} }

lld/trunk/wasm/InputChunks.h

Show All 31 Lines
class ObjFile; class ObjFile;
class OutputSegment; class OutputSegment;
class OutputSection; class OutputSection;
class InputChunk { class InputChunk {
public: public:
enum Kind { DataSegment, Function, SyntheticFunction, Section }; enum Kind { DataSegment, Function, SyntheticFunction, Section };
Kind kind() const { return SectionKind; } Kind kind() const { return sectionKind; }
virtual uint32_t getSize() const { return data().size(); } virtual uint32_t getSize() const { return data().size(); }
virtual uint32_t getInputSize() const { return getSize(); }; virtual uint32_t getInputSize() const { return getSize(); };
virtual void writeTo(uint8_t *SectionStart) const; virtual void writeTo(uint8_t *sectionStart) const;
ArrayRef<WasmRelocation> getRelocations() const { return Relocations; } ArrayRef<WasmRelocation> getRelocations() const { return relocations; }
void setRelocations(ArrayRef<WasmRelocation> Rs) { Relocations = Rs; } void setRelocations(ArrayRef<WasmRelocation> rs) { relocations = rs; }
virtual StringRef getName() const = 0; virtual StringRef getName() const = 0;
virtual StringRef getDebugName() const = 0; virtual StringRef getDebugName() const = 0;
virtual uint32_t getComdat() const = 0; virtual uint32_t getComdat() const = 0;
StringRef getComdatName() const; StringRef getComdatName() const;
virtual uint32_t getInputSectionOffset() const = 0; virtual uint32_t getInputSectionOffset() const = 0;
size_t getNumRelocations() const { return Relocations.size(); } size_t getNumRelocations() const { return relocations.size(); }
void writeRelocations(llvm::raw_ostream &OS) const; void writeRelocations(llvm::raw_ostream &os) const;
ObjFile *File; ObjFile *file;
int32_t OutputOffset = 0; int32_t outputOffset = 0;
// Signals that the section is part of the output. The garbage collector, // Signals that the section is part of the output. The garbage collector,
// and COMDAT handling can set a sections' Live bit. // and COMDAT handling can set a sections' Live bit.
// If GC is disabled, all sections start out as live by default. // If GC is disabled, all sections start out as live by default.
unsigned Live : 1; unsigned live : 1;
// Signals the chunk was discarded by COMDAT handling. // Signals the chunk was discarded by COMDAT handling.
unsigned Discarded : 1; unsigned discarded : 1;
protected: protected:
InputChunk(ObjFile *F, Kind K) InputChunk(ObjFile *f, Kind k)
: File(F), Live(!Config->GcSections), Discarded(false), SectionKind(K) {} : file(f), live(!config->gcSections), discarded(false), sectionKind(k) {}
virtual ~InputChunk() = default; virtual ~InputChunk() = default;
virtual ArrayRef<uint8_t> data() const = 0; virtual ArrayRef<uint8_t> data() const = 0;
// Verifies the existing data at relocation targets matches our expectations. // Verifies the existing data at relocation targets matches our expectations.
// This is performed only debug builds as an extra sanity check. // This is performed only debug builds as an extra sanity check.
void verifyRelocTargets() const; void verifyRelocTargets() const;
ArrayRef<WasmRelocation> Relocations; ArrayRef<WasmRelocation> relocations;
Kind SectionKind; Kind sectionKind;
}; };
// Represents a WebAssembly data segment which can be included as part of // Represents a WebAssembly data segment which can be included as part of
// an output data segments. Note that in WebAssembly, unlike ELF and other // an output data segments. Note that in WebAssembly, unlike ELF and other
// formats, used the term "data segment" to refer to the continous regions of // formats, used the term "data segment" to refer to the continous regions of
// memory that make on the data section. See: // memory that make on the data section. See:
// https://webassembly.github.io/spec/syntax/modules.html#syntax-data // https://webassembly.github.io/spec/syntax/modules.html#syntax-data
// //
// For example, by default, clang will produce a separate data section for // For example, by default, clang will produce a separate data section for
// each global variable. // each global variable.
class InputSegment : public InputChunk { class InputSegment : public InputChunk {
public: public:
InputSegment(const WasmSegment &Seg, ObjFile *F) InputSegment(const WasmSegment &seg, ObjFile *f)
: InputChunk(F, InputChunk::DataSegment), Segment(Seg) {} : InputChunk(f, InputChunk::DataSegment), segment(seg) {}
static bool classof(const InputChunk *C) { return C->kind() == DataSegment; } static bool classof(const InputChunk *c) { return c->kind() == DataSegment; }
void generateRelocationCode(raw_ostream &OS) const; void generateRelocationCode(raw_ostream &os) const;
uint32_t getAlignment() const { return Segment.Data.Alignment; } uint32_t getAlignment() const { return segment.Data.Alignment; }
StringRef getName() const override { return Segment.Data.Name; } StringRef getName() const override { return segment.Data.Name; }
StringRef getDebugName() const override { return StringRef(); } StringRef getDebugName() const override { return StringRef(); }
uint32_t getComdat() const override { return Segment.Data.Comdat; } uint32_t getComdat() const override { return segment.Data.Comdat; }
uint32_t getInputSectionOffset() const override { uint32_t getInputSectionOffset() const override {
return Segment.SectionOffset; return segment.SectionOffset;
} }
const OutputSegment *OutputSeg = nullptr; const OutputSegment *outputSeg = nullptr;
int32_t OutputSegmentOffset = 0; int32_t outputSegmentOffset = 0;
protected: protected:
ArrayRef<uint8_t> data() const override { return Segment.Data.Content; } ArrayRef<uint8_t> data() const override { return segment.Data.Content; }
const WasmSegment &Segment; const WasmSegment &segment;
}; };
// Represents a single wasm function within and input file. These are // Represents a single wasm function within and input file. These are
// combined to create the final output CODE section. // combined to create the final output CODE section.
class InputFunction : public InputChunk { class InputFunction : public InputChunk {
public: public:
InputFunction(const WasmSignature &S, const WasmFunction *Func, ObjFile *F) InputFunction(const WasmSignature &s, const WasmFunction *func, ObjFile *f)
: InputChunk(F, InputChunk::Function), Signature(S), Function(Func) {} : InputChunk(f, InputChunk::Function), signature(s), function(func) {}
static bool classof(const InputChunk *C) { static bool classof(const InputChunk *c) {
return C->kind() == InputChunk::Function || return c->kind() == InputChunk::Function ||
C->kind() == InputChunk::SyntheticFunction; c->kind() == InputChunk::SyntheticFunction;
} }
void writeTo(uint8_t *SectionStart) const override; void writeTo(uint8_t *sectionStart) const override;
StringRef getName() const override { return Function->SymbolName; } StringRef getName() const override { return function->SymbolName; }
StringRef getDebugName() const override { return Function->DebugName; } StringRef getDebugName() const override { return function->DebugName; }
uint32_t getComdat() const override { return Function->Comdat; } uint32_t getComdat() const override { return function->Comdat; }
uint32_t getFunctionInputOffset() const { return getInputSectionOffset(); } uint32_t getFunctionInputOffset() const { return getInputSectionOffset(); }
uint32_t getFunctionCodeOffset() const { return Function->CodeOffset; } uint32_t getFunctionCodeOffset() const { return function->CodeOffset; }
uint32_t getSize() const override { uint32_t getSize() const override {
if (Config->CompressRelocations && File) { if (config->compressRelocations && file) {
assert(CompressedSize); assert(compressedSize);
return CompressedSize; return compressedSize;
} }
return data().size(); return data().size();
} }
uint32_t getInputSize() const override { return Function->Size; } uint32_t getInputSize() const override { return function->Size; }
uint32_t getFunctionIndex() const { return FunctionIndex.getValue(); } uint32_t getFunctionIndex() const { return functionIndex.getValue(); }
bool hasFunctionIndex() const { return FunctionIndex.hasValue(); } bool hasFunctionIndex() const { return functionIndex.hasValue(); }
void setFunctionIndex(uint32_t Index); void setFunctionIndex(uint32_t index);
uint32_t getInputSectionOffset() const override { uint32_t getInputSectionOffset() const override {
return Function->CodeSectionOffset; return function->CodeSectionOffset;
} }
uint32_t getTableIndex() const { return TableIndex.getValue(); } uint32_t getTableIndex() const { return tableIndex.getValue(); }
bool hasTableIndex() const { return TableIndex.hasValue(); } bool hasTableIndex() const { return tableIndex.hasValue(); }
void setTableIndex(uint32_t Index); void setTableIndex(uint32_t index);
// The size of a given input function can depend on the values of the // The size of a given input function can depend on the values of the
// LEB relocations within it. This finalizeContents method is called after // LEB relocations within it. This finalizeContents method is called after
// all the symbol values have be calcualted but before getSize() is ever // all the symbol values have be calcualted but before getSize() is ever
// called. // called.
void calculateSize(); void calculateSize();
const WasmSignature &Signature; const WasmSignature &signature;
protected: protected:
ArrayRef<uint8_t> data() const override { ArrayRef<uint8_t> data() const override {
assert(!Config->CompressRelocations); assert(!config->compressRelocations);
return File->CodeSection->Content.slice(getInputSectionOffset(), return file->codeSection->Content.slice(getInputSectionOffset(),
Function->Size); function->Size);
} }
const WasmFunction *Function; const WasmFunction *function;
llvm::Optional<uint32_t> FunctionIndex; llvm::Optional<uint32_t> functionIndex;
llvm::Optional<uint32_t> TableIndex; llvm::Optional<uint32_t> tableIndex;
uint32_t CompressedFuncSize = 0; uint32_t compressedFuncSize = 0;
uint32_t CompressedSize = 0; uint32_t compressedSize = 0;
}; };
class SyntheticFunction : public InputFunction { class SyntheticFunction : public InputFunction {
public: public:
SyntheticFunction(const WasmSignature &S, StringRef Name, SyntheticFunction(const WasmSignature &s, StringRef name,
StringRef DebugName = {}) StringRef debugName = {})
: InputFunction(S, nullptr, nullptr), Name(Name), DebugName(DebugName) { : InputFunction(s, nullptr, nullptr), name(name), debugName(debugName) {
SectionKind = InputChunk::SyntheticFunction; sectionKind = InputChunk::SyntheticFunction;
} }
static bool classof(const InputChunk *C) { static bool classof(const InputChunk *c) {
return C->kind() == InputChunk::SyntheticFunction; return c->kind() == InputChunk::SyntheticFunction;
} }
StringRef getName() const override { return Name; } StringRef getName() const override { return name; }
StringRef getDebugName() const override { return DebugName; } StringRef getDebugName() const override { return debugName; }
uint32_t getComdat() const override { return UINT32_MAX; } uint32_t getComdat() const override { return UINT32_MAX; }
void setBody(ArrayRef<uint8_t> Body_) { Body = Body_; } void setBody(ArrayRef<uint8_t> body_) { body = body_; }
protected: protected:
ArrayRef<uint8_t> data() const override { return Body; } ArrayRef<uint8_t> data() const override { return body; }
StringRef Name; StringRef name;
StringRef DebugName; StringRef debugName;
ArrayRef<uint8_t> Body; ArrayRef<uint8_t> body;
}; };
// Represents a single Wasm Section within an input file. // Represents a single Wasm Section within an input file.
class InputSection : public InputChunk { class InputSection : public InputChunk {
public: public:
InputSection(const WasmSection &S, ObjFile *F) InputSection(const WasmSection &s, ObjFile *f)
: InputChunk(F, InputChunk::Section), Section(S) { : InputChunk(f, InputChunk::Section), section(s) {
assert(Section.Type == llvm::wasm::WASM_SEC_CUSTOM); assert(section.Type == llvm::wasm::WASM_SEC_CUSTOM);
} }
StringRef getName() const override { return Section.Name; } StringRef getName() const override { return section.Name; }
StringRef getDebugName() const override { return StringRef(); } StringRef getDebugName() const override { return StringRef(); }
uint32_t getComdat() const override { return UINT32_MAX; } uint32_t getComdat() const override { return UINT32_MAX; }
OutputSection *OutputSec = nullptr; OutputSection *outputSec = nullptr;
protected: protected:
ArrayRef<uint8_t> data() const override { return Section.Content; } ArrayRef<uint8_t> data() const override { return section.Content; }
// Offset within the input section. This is only zero since this chunk // Offset within the input section. This is only zero since this chunk
// type represents an entire input section, not part of one. // type represents an entire input section, not part of one.
uint32_t getInputSectionOffset() const override { return 0; } uint32_t getInputSectionOffset() const override { return 0; }
const WasmSection &Section; const WasmSection &section;
}; };
} // namespace wasm } // namespace wasm
std::string toString(const wasm::InputChunk *); std::string toString(const wasm::InputChunk *);
StringRef relocTypeToString(uint8_t RelocType); StringRef relocTypeToString(uint8_t relocType);
} // namespace lld } // namespace lld
#endif // LLD_WASM_INPUT_CHUNKS_H #endif // LLD_WASM_INPUT_CHUNKS_H

lld/trunk/wasm/InputChunks.cpp

Show All 16 Lines
#define DEBUG_TYPE "lld" #define DEBUG_TYPE "lld"
using namespace llvm; using namespace llvm;
using namespace llvm::wasm; using namespace llvm::wasm;
using namespace llvm::support::endian; using namespace llvm::support::endian;
using namespace lld; using namespace lld;
using namespace lld::wasm; using namespace lld::wasm;
StringRef lld::relocTypeToString(uint8_t RelocType) { StringRef lld::relocTypeToString(uint8_t relocType) {
switch (RelocType) { switch (relocType) {
#define WASM_RELOC(NAME, REL) \ #define WASM_RELOC(NAME, REL) \
case REL: \ case REL: \
return #NAME; return #NAME;
#include "llvm/BinaryFormat/WasmRelocs.def" #include "llvm/BinaryFormat/WasmRelocs.def"
#undef WASM_RELOC #undef WASM_RELOC
} }
llvm_unreachable("unknown reloc type"); llvm_unreachable("unknown reloc type");
} }
std::string lld::toString(const InputChunk *C) { std::string lld::toString(const InputChunk *c) {
return (toString(C->File) + ":(" + C->getName() + ")").str(); return (toString(c->file) + ":(" + c->getName() + ")").str();
} }
StringRef InputChunk::getComdatName() const { StringRef InputChunk::getComdatName() const {
uint32_t Index = getComdat(); uint32_t index = getComdat();
if (Index == UINT32_MAX) if (index == UINT32_MAX)
return StringRef(); return StringRef();
return File->getWasmObj()->linkingData().Comdats[Index]; return file->getWasmObj()->linkingData().Comdats[index];
} }
void InputChunk::verifyRelocTargets() const { void InputChunk::verifyRelocTargets() const {
for (const WasmRelocation &Rel : Relocations) { for (const WasmRelocation &rel : relocations) {
uint32_t ExistingValue; uint32_t existingValue;
unsigned BytesRead = 0; unsigned bytesRead = 0;
uint32_t Offset = Rel.Offset - getInputSectionOffset(); uint32_t offset = rel.Offset - getInputSectionOffset();
const uint8_t *Loc = data().data() + Offset; const uint8_t *loc = data().data() + offset;
switch (Rel.Type) { switch (rel.Type) {
case R_WASM_TYPE_INDEX_LEB: case R_WASM_TYPE_INDEX_LEB:
case R_WASM_FUNCTION_INDEX_LEB: case R_WASM_FUNCTION_INDEX_LEB:
case R_WASM_GLOBAL_INDEX_LEB: case R_WASM_GLOBAL_INDEX_LEB:
case R_WASM_EVENT_INDEX_LEB: case R_WASM_EVENT_INDEX_LEB:
case R_WASM_MEMORY_ADDR_LEB: case R_WASM_MEMORY_ADDR_LEB:
ExistingValue = decodeULEB128(Loc, &BytesRead); existingValue = decodeULEB128(loc, &bytesRead);
break; break;
case R_WASM_TABLE_INDEX_SLEB: case R_WASM_TABLE_INDEX_SLEB:
case R_WASM_TABLE_INDEX_REL_SLEB: case R_WASM_TABLE_INDEX_REL_SLEB:
case R_WASM_MEMORY_ADDR_SLEB: case R_WASM_MEMORY_ADDR_SLEB:
case R_WASM_MEMORY_ADDR_REL_SLEB: case R_WASM_MEMORY_ADDR_REL_SLEB:
ExistingValue = static_cast<uint32_t>(decodeSLEB128(Loc, &BytesRead)); existingValue = static_cast<uint32_t>(decodeSLEB128(loc, &bytesRead));
break; break;
case R_WASM_TABLE_INDEX_I32: case R_WASM_TABLE_INDEX_I32:
case R_WASM_MEMORY_ADDR_I32: case R_WASM_MEMORY_ADDR_I32:
case R_WASM_FUNCTION_OFFSET_I32: case R_WASM_FUNCTION_OFFSET_I32:
case R_WASM_SECTION_OFFSET_I32: case R_WASM_SECTION_OFFSET_I32:
ExistingValue = static_cast<uint32_t>(read32le(Loc)); existingValue = static_cast<uint32_t>(read32le(loc));
break; break;
default: default:
llvm_unreachable("unknown relocation type"); llvm_unreachable("unknown relocation type");
} }
if (BytesRead && BytesRead != 5) if (bytesRead && bytesRead != 5)
warn("expected LEB at relocation site be 5-byte padded"); warn("expected LEB at relocation site be 5-byte padded");
if (Rel.Type != R_WASM_GLOBAL_INDEX_LEB) { if (rel.Type != R_WASM_GLOBAL_INDEX_LEB) {
uint32_t ExpectedValue = File->calcExpectedValue(Rel); uint32_t expectedValue = file->calcExpectedValue(rel);
if (ExpectedValue != ExistingValue) if (expectedValue != existingValue)
warn("unexpected existing value for " + relocTypeToString(Rel.Type) + warn("unexpected existing value for " + relocTypeToString(rel.Type) +
": existing=" + Twine(ExistingValue) + ": existing=" + Twine(existingValue) +
" expected=" + Twine(ExpectedValue)); " expected=" + Twine(expectedValue));
} }
} }
} }
// Copy this input chunk to an mmap'ed output file and apply relocations. // Copy this input chunk to an mmap'ed output file and apply relocations.
void InputChunk::writeTo(uint8_t *Buf) const { void InputChunk::writeTo(uint8_t *buf) const {
// Copy contents // Copy contents
memcpy(Buf + OutputOffset, data().data(), data().size()); memcpy(buf + outputOffset, data().data(), data().size());
// Apply relocations // Apply relocations
if (Relocations.empty()) if (relocations.empty())
return; return;
#ifndef NDEBUG #ifndef NDEBUG
verifyRelocTargets(); verifyRelocTargets();
#endif #endif
LLVM_DEBUG(dbgs() << "applying relocations: " << getName() LLVM_DEBUG(dbgs() << "applying relocations: " << getName()
<< " count=" << Relocations.size() << "\n"); << " count=" << relocations.size() << "\n");
int32_t Off = OutputOffset - getInputSectionOffset(); int32_t off = outputOffset - getInputSectionOffset();
for (const WasmRelocation &Rel : Relocations) { for (const WasmRelocation &rel : relocations) {
uint8_t *Loc = Buf + Rel.Offset + Off; uint8_t *loc = buf + rel.Offset + off;
uint32_t Value = File->calcNewValue(Rel); uint32_t value = file->calcNewValue(rel);
LLVM_DEBUG(dbgs() << "apply reloc: type=" << relocTypeToString(Rel.Type)); LLVM_DEBUG(dbgs() << "apply reloc: type=" << relocTypeToString(rel.Type));
if (Rel.Type != R_WASM_TYPE_INDEX_LEB) if (rel.Type != R_WASM_TYPE_INDEX_LEB)
LLVM_DEBUG(dbgs() << " sym=" << File->getSymbols()[Rel.Index]->getName()); LLVM_DEBUG(dbgs() << " sym=" << file->getSymbols()[rel.Index]->getName());
LLVM_DEBUG(dbgs() << " addend=" << Rel.Addend << " index=" << Rel.Index LLVM_DEBUG(dbgs() << " addend=" << rel.Addend << " index=" << rel.Index
<< " value=" << Value << " offset=" << Rel.Offset << " value=" << value << " offset=" << rel.Offset
<< "\n"); << "\n");
switch (Rel.Type) { switch (rel.Type) {
case R_WASM_TYPE_INDEX_LEB: case R_WASM_TYPE_INDEX_LEB:
case R_WASM_FUNCTION_INDEX_LEB: case R_WASM_FUNCTION_INDEX_LEB:
case R_WASM_GLOBAL_INDEX_LEB: case R_WASM_GLOBAL_INDEX_LEB:
case R_WASM_EVENT_INDEX_LEB: case R_WASM_EVENT_INDEX_LEB:
case R_WASM_MEMORY_ADDR_LEB: case R_WASM_MEMORY_ADDR_LEB:
encodeULEB128(Value, Loc, 5); encodeULEB128(value, loc, 5);
break; break;
case R_WASM_TABLE_INDEX_SLEB: case R_WASM_TABLE_INDEX_SLEB:
case R_WASM_TABLE_INDEX_REL_SLEB: case R_WASM_TABLE_INDEX_REL_SLEB:
case R_WASM_MEMORY_ADDR_SLEB: case R_WASM_MEMORY_ADDR_SLEB:
case R_WASM_MEMORY_ADDR_REL_SLEB: case R_WASM_MEMORY_ADDR_REL_SLEB:
encodeSLEB128(static_cast<int32_t>(Value), Loc, 5); encodeSLEB128(static_cast<int32_t>(value), loc, 5);
break; break;
case R_WASM_TABLE_INDEX_I32: case R_WASM_TABLE_INDEX_I32:
case R_WASM_MEMORY_ADDR_I32: case R_WASM_MEMORY_ADDR_I32:
case R_WASM_FUNCTION_OFFSET_I32: case R_WASM_FUNCTION_OFFSET_I32:
case R_WASM_SECTION_OFFSET_I32: case R_WASM_SECTION_OFFSET_I32:
write32le(Loc, Value); write32le(loc, value);
break; break;
default: default:
llvm_unreachable("unknown relocation type"); llvm_unreachable("unknown relocation type");
} }
} }
} }
// Copy relocation entries to a given output stream. // Copy relocation entries to a given output stream.
// This function is used only when a user passes "-r". For a regular link, // This function is used only when a user passes "-r". For a regular link,
// we consume relocations instead of copying them to an output file. // we consume relocations instead of copying them to an output file.
void InputChunk::writeRelocations(raw_ostream &OS) const { void InputChunk::writeRelocations(raw_ostream &os) const {
if (Relocations.empty()) if (relocations.empty())
return; return;
int32_t Off = OutputOffset - getInputSectionOffset(); int32_t off = outputOffset - getInputSectionOffset();
LLVM_DEBUG(dbgs() << "writeRelocations: " << File->getName() LLVM_DEBUG(dbgs() << "writeRelocations: " << file->getName()
<< " offset=" << Twine(Off) << "\n"); << " offset=" << Twine(off) << "\n");
for (const WasmRelocation &Rel : Relocations) { for (const WasmRelocation &rel : relocations) {
writeUleb128(OS, Rel.Type, "reloc type"); writeUleb128(os, rel.Type, "reloc type");
writeUleb128(OS, Rel.Offset + Off, "reloc offset"); writeUleb128(os, rel.Offset + off, "reloc offset");
writeUleb128(OS, File->calcNewIndex(Rel), "reloc index"); writeUleb128(os, file->calcNewIndex(rel), "reloc index");
if (relocTypeHasAddend(Rel.Type)) if (relocTypeHasAddend(rel.Type))
writeSleb128(OS, File->calcNewAddend(Rel), "reloc addend"); writeSleb128(os, file->calcNewAddend(rel), "reloc addend");
} }
} }
void InputFunction::setFunctionIndex(uint32_t Index) { void InputFunction::setFunctionIndex(uint32_t index) {
LLVM_DEBUG(dbgs() << "InputFunction::setFunctionIndex: " << getName() LLVM_DEBUG(dbgs() << "InputFunction::setFunctionIndex: " << getName()
<< " -> " << Index << "\n"); << " -> " << index << "\n");
assert(!hasFunctionIndex()); assert(!hasFunctionIndex());
FunctionIndex = Index; functionIndex = index;
} }
void InputFunction::setTableIndex(uint32_t Index) { void InputFunction::setTableIndex(uint32_t index) {
LLVM_DEBUG(dbgs() << "InputFunction::setTableIndex: " << getName() << " -> " LLVM_DEBUG(dbgs() << "InputFunction::setTableIndex: " << getName() << " -> "
<< Index << "\n"); << index << "\n");
assert(!hasTableIndex()); assert(!hasTableIndex());
TableIndex = Index; tableIndex = index;
} }
// Write a relocation value without padding and return the number of bytes // Write a relocation value without padding and return the number of bytes
// witten. // witten.
static unsigned writeCompressedReloc(uint8_t *Buf, const WasmRelocation &Rel, static unsigned writeCompressedReloc(uint8_t *buf, const WasmRelocation &rel,
uint32_t Value) { uint32_t value) {
switch (Rel.Type) { switch (rel.Type) {
case R_WASM_TYPE_INDEX_LEB: case R_WASM_TYPE_INDEX_LEB:
case R_WASM_FUNCTION_INDEX_LEB: case R_WASM_FUNCTION_INDEX_LEB:
case R_WASM_GLOBAL_INDEX_LEB: case R_WASM_GLOBAL_INDEX_LEB:
case R_WASM_EVENT_INDEX_LEB: case R_WASM_EVENT_INDEX_LEB:
case R_WASM_MEMORY_ADDR_LEB: case R_WASM_MEMORY_ADDR_LEB:
return encodeULEB128(Value, Buf); return encodeULEB128(value, buf);
case R_WASM_TABLE_INDEX_SLEB: case R_WASM_TABLE_INDEX_SLEB:
case R_WASM_MEMORY_ADDR_SLEB: case R_WASM_MEMORY_ADDR_SLEB:
return encodeSLEB128(static_cast<int32_t>(Value), Buf); return encodeSLEB128(static_cast<int32_t>(value), buf);
default: default:
llvm_unreachable("unexpected relocation type"); llvm_unreachable("unexpected relocation type");
} }
} }
static unsigned getRelocWidthPadded(const WasmRelocation &Rel) { static unsigned getRelocWidthPadded(const WasmRelocation &rel) {
switch (Rel.Type) { switch (rel.Type) {
case R_WASM_TYPE_INDEX_LEB: case R_WASM_TYPE_INDEX_LEB:
case R_WASM_FUNCTION_INDEX_LEB: case R_WASM_FUNCTION_INDEX_LEB:
case R_WASM_GLOBAL_INDEX_LEB: case R_WASM_GLOBAL_INDEX_LEB:
case R_WASM_EVENT_INDEX_LEB: case R_WASM_EVENT_INDEX_LEB:
case R_WASM_MEMORY_ADDR_LEB: case R_WASM_MEMORY_ADDR_LEB:
case R_WASM_TABLE_INDEX_SLEB: case R_WASM_TABLE_INDEX_SLEB:
case R_WASM_MEMORY_ADDR_SLEB: case R_WASM_MEMORY_ADDR_SLEB:
return 5; return 5;
default: default:
llvm_unreachable("unexpected relocation type"); llvm_unreachable("unexpected relocation type");
} }
} }
static unsigned getRelocWidth(const WasmRelocation &Rel, uint32_t Value) { static unsigned getRelocWidth(const WasmRelocation &rel, uint32_t value) {
uint8_t Buf[5]; uint8_t buf[5];
return writeCompressedReloc(Buf, Rel, Value); return writeCompressedReloc(buf, rel, value);
} }
// Relocations of type LEB and SLEB in the code section are padded to 5 bytes // Relocations of type LEB and SLEB in the code section are padded to 5 bytes
// so that a fast linker can blindly overwrite them without needing to worry // so that a fast linker can blindly overwrite them without needing to worry
// about the number of bytes needed to encode the values. // about the number of bytes needed to encode the values.
// However, for optimal output the code section can be compressed to remove // However, for optimal output the code section can be compressed to remove
// the padding then outputting non-relocatable files. // the padding then outputting non-relocatable files.
// In this case we need to perform a size calculation based on the value at each // In this case we need to perform a size calculation based on the value at each
// relocation. At best we end up saving 4 bytes for each relocation entry. // relocation. At best we end up saving 4 bytes for each relocation entry.
// //
// This function only computes the final output size. It must be called // This function only computes the final output size. It must be called
// before getSize() is used to calculate of layout of the code section. // before getSize() is used to calculate of layout of the code section.
void InputFunction::calculateSize() { void InputFunction::calculateSize() {
if (!File || !Config->CompressRelocations) if (!file || !config->compressRelocations)
return; return;
LLVM_DEBUG(dbgs() << "calculateSize: " << getName() << "\n"); LLVM_DEBUG(dbgs() << "calculateSize: " << getName() << "\n");
const uint8_t *SecStart = File->CodeSection->Content.data(); const uint8_t *secStart = file->codeSection->Content.data();
const uint8_t *FuncStart = SecStart + getInputSectionOffset(); const uint8_t *funcStart = secStart + getInputSectionOffset();
uint32_t FunctionSizeLength; uint32_t functionSizeLength;
decodeULEB128(FuncStart, &FunctionSizeLength); decodeULEB128(funcStart, &functionSizeLength);
uint32_t Start = getInputSectionOffset(); uint32_t start = getInputSectionOffset();
uint32_t End = Start + Function->Size; uint32_t end = start + function->Size;
uint32_t LastRelocEnd = Start + FunctionSizeLength; uint32_t lastRelocEnd = start + functionSizeLength;
for (const WasmRelocation &Rel : Relocations) { for (const WasmRelocation &rel : relocations) {
LLVM_DEBUG(dbgs() << " region: " << (Rel.Offset - LastRelocEnd) << "\n"); LLVM_DEBUG(dbgs() << " region: " << (rel.Offset - lastRelocEnd) << "\n");
CompressedFuncSize += Rel.Offset - LastRelocEnd; compressedFuncSize += rel.Offset - lastRelocEnd;
CompressedFuncSize += getRelocWidth(Rel, File->calcNewValue(Rel)); compressedFuncSize += getRelocWidth(rel, file->calcNewValue(rel));
LastRelocEnd = Rel.Offset + getRelocWidthPadded(Rel); lastRelocEnd = rel.Offset + getRelocWidthPadded(rel);
} }
LLVM_DEBUG(dbgs() << " final region: " << (End - LastRelocEnd) << "\n"); LLVM_DEBUG(dbgs() << " final region: " << (end - lastRelocEnd) << "\n");
CompressedFuncSize += End - LastRelocEnd; compressedFuncSize += end - lastRelocEnd;
// Now we know how long the resulting function is we can add the encoding // Now we know how long the resulting function is we can add the encoding
// of its length // of its length
uint8_t Buf[5]; uint8_t buf[5];
CompressedSize = CompressedFuncSize + encodeULEB128(CompressedFuncSize, Buf); compressedSize = compressedFuncSize + encodeULEB128(compressedFuncSize, buf);
LLVM_DEBUG(dbgs() << " calculateSize orig: " << Function->Size << "\n"); LLVM_DEBUG(dbgs() << " calculateSize orig: " << function->Size << "\n");
LLVM_DEBUG(dbgs() << " calculateSize new: " << CompressedSize << "\n"); LLVM_DEBUG(dbgs() << " calculateSize new: " << compressedSize << "\n");
} }
// Override the default writeTo method so that we can (optionally) write the // Override the default writeTo method so that we can (optionally) write the
// compressed version of the function. // compressed version of the function.
void InputFunction::writeTo(uint8_t *Buf) const { void InputFunction::writeTo(uint8_t *buf) const {
if (!File || !Config->CompressRelocations) if (!file || !config->compressRelocations)
return InputChunk::writeTo(Buf); return InputChunk::writeTo(buf);
Buf += OutputOffset; buf += outputOffset;
uint8_t *Orig = Buf; uint8_t *orig = buf;
(void)Orig; (void)orig;
const uint8_t *SecStart = File->CodeSection->Content.data(); const uint8_t *secStart = file->codeSection->Content.data();
const uint8_t *FuncStart = SecStart + getInputSectionOffset(); const uint8_t *funcStart = secStart + getInputSectionOffset();
const uint8_t *End = FuncStart + Function->Size; const uint8_t *end = funcStart + function->Size;
uint32_t Count; uint32_t count;
decodeULEB128(FuncStart, &Count); decodeULEB128(funcStart, &count);
FuncStart += Count; funcStart += count;
LLVM_DEBUG(dbgs() << "write func: " << getName() << "\n"); LLVM_DEBUG(dbgs() << "write func: " << getName() << "\n");
Buf += encodeULEB128(CompressedFuncSize, Buf); buf += encodeULEB128(compressedFuncSize, buf);
const uint8_t *LastRelocEnd = FuncStart; const uint8_t *lastRelocEnd = funcStart;
for (const WasmRelocation &Rel : Relocations) { for (const WasmRelocation &rel : relocations) {
unsigned ChunkSize = (SecStart + Rel.Offset) - LastRelocEnd; unsigned chunkSize = (secStart + rel.Offset) - lastRelocEnd;
LLVM_DEBUG(dbgs() << " write chunk: " << ChunkSize << "\n"); LLVM_DEBUG(dbgs() << " write chunk: " << chunkSize << "\n");
memcpy(Buf, LastRelocEnd, ChunkSize); memcpy(buf, lastRelocEnd, chunkSize);
Buf += ChunkSize; buf += chunkSize;
Buf += writeCompressedReloc(Buf, Rel, File->calcNewValue(Rel)); buf += writeCompressedReloc(buf, rel, file->calcNewValue(rel));
LastRelocEnd = SecStart + Rel.Offset + getRelocWidthPadded(Rel); lastRelocEnd = secStart + rel.Offset + getRelocWidthPadded(rel);
} }
unsigned ChunkSize = End - LastRelocEnd; unsigned chunkSize = end - lastRelocEnd;
LLVM_DEBUG(dbgs() << " write final chunk: " << ChunkSize << "\n"); LLVM_DEBUG(dbgs() << " write final chunk: " << chunkSize << "\n");
memcpy(Buf, LastRelocEnd, ChunkSize); memcpy(buf, lastRelocEnd, chunkSize);
LLVM_DEBUG(dbgs() << " total: " << (Buf + ChunkSize - Orig) << "\n"); LLVM_DEBUG(dbgs() << " total: " << (buf + chunkSize - orig) << "\n");
} }
// Generate code to apply relocations to the data section at runtime. // Generate code to apply relocations to the data section at runtime.
// This is only called when generating shared libaries (PIC) where address are // This is only called when generating shared libaries (PIC) where address are
// not known at static link time. // not known at static link time.
void InputSegment::generateRelocationCode(raw_ostream &OS) const { void InputSegment::generateRelocationCode(raw_ostream &os) const {
LLVM_DEBUG(dbgs() << "generating runtime relocations: " << getName() LLVM_DEBUG(dbgs() << "generating runtime relocations: " << getName()
<< " count=" << Relocations.size() << "\n"); << " count=" << relocations.size() << "\n");
// TODO(sbc): Encode the relocations in the data section and write a loop // TODO(sbc): Encode the relocations in the data section and write a loop
// here to apply them. // here to apply them.
uint32_t SegmentVA = OutputSeg->StartVA + OutputSegmentOffset; uint32_t segmentVA = outputSeg->startVA + outputSegmentOffset;
for (const WasmRelocation &Rel : Relocations) { for (const WasmRelocation &rel : relocations) {
uint32_t Offset = Rel.Offset - getInputSectionOffset(); uint32_t offset = rel.Offset - getInputSectionOffset();
uint32_t OutputOffset = SegmentVA + Offset; uint32_t outputOffset = segmentVA + offset;
LLVM_DEBUG(dbgs() << "gen reloc: type=" << relocTypeToString(Rel.Type) LLVM_DEBUG(dbgs() << "gen reloc: type=" << relocTypeToString(rel.Type)
<< " addend=" << Rel.Addend << " index=" << Rel.Index << " addend=" << rel.Addend << " index=" << rel.Index
<< " output offset=" << OutputOffset << "\n"); << " output offset=" << outputOffset << "\n");
// Get __memory_base // Get __memory_base
writeU8(OS, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET"); writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
writeUleb128(OS, WasmSym::MemoryBase->getGlobalIndex(), "memory_base"); writeUleb128(os, WasmSym::memoryBase->getGlobalIndex(), "memory_base");
// Add the offset of the relocation // Add the offset of the relocation
writeU8(OS, WASM_OPCODE_I32_CONST, "I32_CONST"); writeU8(os, WASM_OPCODE_I32_CONST, "I32_CONST");
writeSleb128(OS, OutputOffset, "offset"); writeSleb128(os, outputOffset, "offset");
writeU8(OS, WASM_OPCODE_I32_ADD, "ADD"); writeU8(os, WASM_OPCODE_I32_ADD, "ADD");
Symbol *Sym = File->getSymbol(Rel); Symbol *sym = file->getSymbol(rel);
// Now figure out what we want to store // Now figure out what we want to store
if (Sym->hasGOTIndex()) { if (sym->hasGOTIndex()) {
writeU8(OS, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET"); writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
writeUleb128(OS, Sym->getGOTIndex(), "global index"); writeUleb128(os, sym->getGOTIndex(), "global index");
if (Rel.Addend) { if (rel.Addend) {
writeU8(OS, WASM_OPCODE_I32_CONST, "CONST"); writeU8(os, WASM_OPCODE_I32_CONST, "CONST");
writeSleb128(OS, Rel.Addend, "addend"); writeSleb128(os, rel.Addend, "addend");
writeU8(OS, WASM_OPCODE_I32_ADD, "ADD"); writeU8(os, WASM_OPCODE_I32_ADD, "ADD");
} }
} else { } else {
const GlobalSymbol* BaseSymbol = WasmSym::MemoryBase; const GlobalSymbol* baseSymbol = WasmSym::memoryBase;
if (Rel.Type == R_WASM_TABLE_INDEX_I32) if (rel.Type == R_WASM_TABLE_INDEX_I32)
BaseSymbol = WasmSym::TableBase; baseSymbol = WasmSym::tableBase;
writeU8(OS, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET"); writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
writeUleb128(OS, BaseSymbol->getGlobalIndex(), "base"); writeUleb128(os, baseSymbol->getGlobalIndex(), "base");
writeU8(OS, WASM_OPCODE_I32_CONST, "CONST"); writeU8(os, WASM_OPCODE_I32_CONST, "CONST");
writeSleb128(OS, File->calcNewValue(Rel), "offset"); writeSleb128(os, file->calcNewValue(rel), "offset");
writeU8(OS, WASM_OPCODE_I32_ADD, "ADD"); writeU8(os, WASM_OPCODE_I32_ADD, "ADD");
} }
// Store that value at the virtual address // Store that value at the virtual address
writeU8(OS, WASM_OPCODE_I32_STORE, "I32_STORE"); writeU8(os, WASM_OPCODE_I32_STORE, "I32_STORE");
writeUleb128(OS, 2, "align"); writeUleb128(os, 2, "align");
writeUleb128(OS, 0, "offset"); writeUleb128(os, 0, "offset");
} }
} }

lld/trunk/wasm/InputEvent.h

Show All 22 Lines
namespace lld { namespace lld {
namespace wasm { namespace wasm {
// Represents a single Wasm Event within an input file. These are combined to // Represents a single Wasm Event within an input file. These are combined to
// form the final EVENTS section. // form the final EVENTS section.
class InputEvent { class InputEvent {
public: public:
InputEvent(const WasmSignature &S, const WasmEvent &E, ObjFile *F) InputEvent(const WasmSignature &s, const WasmEvent &e, ObjFile *f)
: File(F), Event(E), Signature(S), Live(!Config->GcSections) {} : file(f), event(e), signature(s), live(!config->gcSections) {}
StringRef getName() const { return Event.SymbolName; } StringRef getName() const { return event.SymbolName; }
const WasmEventType &getType() const { return Event.Type; } const WasmEventType &getType() const { return event.Type; }
uint32_t getEventIndex() const { return EventIndex.getValue(); } uint32_t getEventIndex() const { return eventIndex.getValue(); }
bool hasEventIndex() const { return EventIndex.hasValue(); } bool hasEventIndex() const { return eventIndex.hasValue(); }
void setEventIndex(uint32_t Index) { void setEventIndex(uint32_t index) {
assert(!hasEventIndex()); assert(!hasEventIndex());
EventIndex = Index; eventIndex = index;
} }
ObjFile *File; ObjFile *file;
WasmEvent Event; WasmEvent event;
const WasmSignature &Signature; const WasmSignature &signature;
bool Live = false; bool live = false;
protected: protected:
llvm::Optional<uint32_t> EventIndex; llvm::Optional<uint32_t> eventIndex;
}; };
} // namespace wasm } // namespace wasm
inline std::string toString(const wasm::InputEvent *E) { inline std::string toString(const wasm::InputEvent *e) {
return (toString(E->File) + ":(" + E->getName() + ")").str(); return (toString(e->file) + ":(" + e->getName() + ")").str();
} }
} // namespace lld } // namespace lld
#endif // LLD_WASM_INPUT_EVENT_H #endif // LLD_WASM_INPUT_EVENT_H

lld/trunk/wasm/InputFiles.h

Show All 29 Lines
class InputFunction; class InputFunction;
class InputSegment; class InputSegment;
class InputGlobal; class InputGlobal;
class InputEvent; class InputEvent;
class InputSection; class InputSection;
// If --reproduce option is given, all input files are written // If --reproduce option is given, all input files are written
// to this tar archive. // to this tar archive.
extern std::unique_ptr<llvm::TarWriter> Tar; extern std::unique_ptr<llvm::TarWriter> tar;
class InputFile { class InputFile {
public: public:
enum Kind { enum Kind {
ObjectKind, ObjectKind,
SharedKind, SharedKind,
ArchiveKind, ArchiveKind,
BitcodeKind, BitcodeKind,
}; };
virtual ~InputFile() {} virtual ~InputFile() {}
// Returns the filename. // Returns the filename.
StringRef getName() const { return MB.getBufferIdentifier(); } StringRef getName() const { return mb.getBufferIdentifier(); }
Kind kind() const { return FileKind; } Kind kind() const { return fileKind; }
// An archive file name if this file is created from an archive. // An archive file name if this file is created from an archive.
StringRef ArchiveName; StringRef archiveName;
ArrayRef<Symbol *> getSymbols() const { return Symbols; } ArrayRef<Symbol *> getSymbols() const { return symbols; }
MutableArrayRef<Symbol *> getMutableSymbols() { return Symbols; } MutableArrayRef<Symbol *> getMutableSymbols() { return symbols; }
protected: protected:
InputFile(Kind K, MemoryBufferRef M) : MB(M), FileKind(K) {} InputFile(Kind k, MemoryBufferRef m) : mb(m), fileKind(k) {}
MemoryBufferRef MB; MemoryBufferRef mb;
// List of all symbols referenced or defined by this file. // List of all symbols referenced or defined by this file.
std::vector<Symbol *> Symbols; std::vector<Symbol *> symbols;
private: private:
const Kind FileKind; const Kind fileKind;
}; };
// .a file (ar archive) // .a file (ar archive)
class ArchiveFile : public InputFile { class ArchiveFile : public InputFile {
public: public:
explicit ArchiveFile(MemoryBufferRef M) : InputFile(ArchiveKind, M) {} explicit ArchiveFile(MemoryBufferRef m) : InputFile(ArchiveKind, m) {}
static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; } static bool classof(const InputFile *f) { return f->kind() == ArchiveKind; }
void addMember(const llvm::object::Archive::Symbol *Sym); void addMember(const llvm::object::Archive::Symbol *sym);
void parse(); void parse();
private: private:
std::unique_ptr<llvm::object::Archive> File; std::unique_ptr<llvm::object::Archive> file;
llvm::DenseSet<uint64_t> Seen; llvm::DenseSet<uint64_t> seen;
}; };
// .o file (wasm object file) // .o file (wasm object file)
class ObjFile : public InputFile { class ObjFile : public InputFile {
public: public:
explicit ObjFile(MemoryBufferRef M, StringRef ArchiveName) explicit ObjFile(MemoryBufferRef m, StringRef archiveName)
: InputFile(ObjectKind, M) { : InputFile(ObjectKind, m) {
this->ArchiveName = ArchiveName; this->archiveName = archiveName;
} }
static bool classof(const InputFile *F) { return F->kind() == ObjectKind; } static bool classof(const InputFile *f) { return f->kind() == ObjectKind; }
void parse(bool IgnoreComdats = false); void parse(bool ignoreComdats = false);
// Returns the underlying wasm file. // Returns the underlying wasm file.
const WasmObjectFile *getWasmObj() const { return WasmObj.get(); } const WasmObjectFile *getWasmObj() const { return wasmObj.get(); }
void dumpInfo() const; void dumpInfo() const;
uint32_t calcNewIndex(const WasmRelocation &Reloc) const; uint32_t calcNewIndex(const WasmRelocation &reloc) const;
uint32_t calcNewValue(const WasmRelocation &Reloc) const; uint32_t calcNewValue(const WasmRelocation &reloc) const;
uint32_t calcNewAddend(const WasmRelocation &Reloc) const; uint32_t calcNewAddend(const WasmRelocation &reloc) const;
uint32_t calcExpectedValue(const WasmRelocation &Reloc) const; uint32_t calcExpectedValue(const WasmRelocation &reloc) const;
Symbol *getSymbol(const WasmRelocation &Reloc) const { Symbol *getSymbol(const WasmRelocation &reloc) const {
return Symbols[Reloc.Index]; return symbols[reloc.Index];
}; };
const WasmSection *CodeSection = nullptr; const WasmSection *codeSection = nullptr;
const WasmSection *DataSection = nullptr; const WasmSection *dataSection = nullptr;
// Maps input type indices to output type indices // Maps input type indices to output type indices
std::vector<uint32_t> TypeMap; std::vector<uint32_t> typeMap;
std::vector<bool> TypeIsUsed; std::vector<bool> typeIsUsed;
// Maps function indices to table indices // Maps function indices to table indices
std::vector<uint32_t> TableEntries; std::vector<uint32_t> tableEntries;
std::vector<bool> KeptComdats; std::vector<bool> keptComdats;
std::vector<InputSegment *> Segments; std::vector<InputSegment *> segments;
std::vector<InputFunction *> Functions; std::vector<InputFunction *> functions;
std::vector<InputGlobal *> Globals; std::vector<InputGlobal *> globals;
std::vector<InputEvent *> Events; std::vector<InputEvent *> events;
std::vector<InputSection *> CustomSections; std::vector<InputSection *> customSections;
llvm::DenseMap<uint32_t, InputSection *> CustomSectionsByIndex; llvm::DenseMap<uint32_t, InputSection *> customSectionsByIndex;
Symbol *getSymbol(uint32_t Index) const { return Symbols[Index]; } Symbol *getSymbol(uint32_t index) const { return symbols[index]; }
FunctionSymbol *getFunctionSymbol(uint32_t Index) const; FunctionSymbol *getFunctionSymbol(uint32_t index) const;
DataSymbol *getDataSymbol(uint32_t Index) const; DataSymbol *getDataSymbol(uint32_t index) const;
GlobalSymbol *getGlobalSymbol(uint32_t Index) const; GlobalSymbol *getGlobalSymbol(uint32_t index) const;
SectionSymbol *getSectionSymbol(uint32_t Index) const; SectionSymbol *getSectionSymbol(uint32_t index) const;
EventSymbol *getEventSymbol(uint32_t Index) const; EventSymbol *getEventSymbol(uint32_t index) const;
private: private:
Symbol *createDefined(const WasmSymbol &Sym); Symbol *createDefined(const WasmSymbol &sym);
Symbol *createUndefined(const WasmSymbol &Sym, bool IsCalledDirectly); Symbol *createUndefined(const WasmSymbol &sym, bool isCalledDirectly);
bool isExcludedByComdat(InputChunk *Chunk) const; bool isExcludedByComdat(InputChunk *chunk) const;
std::unique_ptr<WasmObjectFile> WasmObj; std::unique_ptr<WasmObjectFile> wasmObj;
}; };
// .so file. // .so file.
class SharedFile : public InputFile { class SharedFile : public InputFile {
public: public:
explicit SharedFile(MemoryBufferRef M) : InputFile(SharedKind, M) {} explicit SharedFile(MemoryBufferRef m) : InputFile(SharedKind, m) {}
static bool classof(const InputFile *F) { return F->kind() == SharedKind; } static bool classof(const InputFile *f) { return f->kind() == SharedKind; }
}; };
// .bc file // .bc file
class BitcodeFile : public InputFile { class BitcodeFile : public InputFile {
public: public:
explicit BitcodeFile(MemoryBufferRef M, StringRef ArchiveName) explicit BitcodeFile(MemoryBufferRef m, StringRef archiveName)
: InputFile(BitcodeKind, M) { : InputFile(BitcodeKind, m) {
this->ArchiveName = ArchiveName; this->archiveName = archiveName;
} }
static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; } static bool classof(const InputFile *f) { return f->kind() == BitcodeKind; }
void parse(); void parse();
std::unique_ptr<llvm::lto::InputFile> Obj; std::unique_ptr<llvm::lto::InputFile> obj;
}; };
// Will report a fatal() error if the input buffer is not a valid bitcode // Will report a fatal() error if the input buffer is not a valid bitcode
// or wasm object file. // or wasm object file.
InputFile *createObjectFile(MemoryBufferRef MB, StringRef ArchiveName = ""); InputFile *createObjectFile(MemoryBufferRef mb, StringRef archiveName = "");
// Opens a given file. // Opens a given file.
llvm::Optional<MemoryBufferRef> readFile(StringRef Path); llvm::Optional<MemoryBufferRef> readFile(StringRef path);
} // namespace wasm } // namespace wasm
std::string toString(const wasm::InputFile *File); std::string toString(const wasm::InputFile *file);
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/wasm/InputFiles.cpp

Show All 23 Lines
using namespace lld; using namespace lld;
using namespace lld::wasm; using namespace lld::wasm;
using namespace llvm; using namespace llvm;
using namespace llvm::object; using namespace llvm::object;
using namespace llvm::wasm; using namespace llvm::wasm;
std::unique_ptr<llvm::TarWriter> lld::wasm::Tar; std::unique_ptr<llvm::TarWriter> lld::wasm::tar;
Optional<MemoryBufferRef> lld::wasm::readFile(StringRef Path) { Optional<MemoryBufferRef> lld::wasm::readFile(StringRef path) {
log("Loading: " + Path); log("Loading: " + path);
auto MBOrErr = MemoryBuffer::getFile(Path); auto mbOrErr = MemoryBuffer::getFile(path);
if (auto EC = MBOrErr.getError()) { if (auto ec = mbOrErr.getError()) {
error("cannot open " + Path + ": " + EC.message()); error("cannot open " + path + ": " + ec.message());
return None; return None;
} }
std::unique_ptr<MemoryBuffer> &MB = *MBOrErr; std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
MemoryBufferRef MBRef = MB->getMemBufferRef(); MemoryBufferRef mbref = mb->getMemBufferRef();
make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take MB ownership make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take MB ownership
if (Tar) if (tar)
Tar->append(relativeToRoot(Path), MBRef.getBuffer()); tar->append(relativeToRoot(path), mbref.getBuffer());
return MBRef; return mbref;
} }
InputFile *lld::wasm::createObjectFile(MemoryBufferRef MB, InputFile *lld::wasm::createObjectFile(MemoryBufferRef mb,
StringRef ArchiveName) { StringRef archiveName) {
file_magic Magic = identify_magic(MB.getBuffer()); file_magic magic = identify_magic(mb.getBuffer());
if (Magic == file_magic::wasm_object) { if (magic == file_magic::wasm_object) {
std::unique_ptr<Binary> Bin = std::unique_ptr<Binary> bin =
CHECK(createBinary(MB), MB.getBufferIdentifier()); CHECK(createBinary(mb), mb.getBufferIdentifier());
auto *Obj = cast<WasmObjectFile>(Bin.get()); auto *obj = cast<WasmObjectFile>(bin.get());
if (Obj->isSharedObject()) if (obj->isSharedObject())
return make<SharedFile>(MB); return make<SharedFile>(mb);
return make<ObjFile>(MB, ArchiveName); return make<ObjFile>(mb, archiveName);
} }
if (Magic == file_magic::bitcode) if (magic == file_magic::bitcode)
return make<BitcodeFile>(MB, ArchiveName); return make<BitcodeFile>(mb, archiveName);
fatal("unknown file type: " + MB.getBufferIdentifier()); fatal("unknown file type: " + mb.getBufferIdentifier());
} }
void ObjFile::dumpInfo() const { void ObjFile::dumpInfo() const {
log("info for: " + toString(this) + log("info for: " + toString(this) +
"\n Symbols : " + Twine(Symbols.size()) + "\n Symbols : " + Twine(symbols.size()) +
"\n Function Imports : " + Twine(WasmObj->getNumImportedFunctions()) + "\n Function Imports : " + Twine(wasmObj->getNumImportedFunctions()) +
"\n Global Imports : " + Twine(WasmObj->getNumImportedGlobals()) + "\n Global Imports : " + Twine(wasmObj->getNumImportedGlobals()) +
"\n Event Imports : " + Twine(WasmObj->getNumImportedEvents())); "\n Event Imports : " + Twine(wasmObj->getNumImportedEvents()));
} }
// Relocations contain either symbol or type indices. This function takes a // Relocations contain either symbol or type indices. This function takes a
// relocation and returns relocated index (i.e. translates from the input // relocation and returns relocated index (i.e. translates from the input
// symbol/type space to the output symbol/type space). // symbol/type space to the output symbol/type space).
uint32_t ObjFile::calcNewIndex(const WasmRelocation &Reloc) const { uint32_t ObjFile::calcNewIndex(const WasmRelocation &reloc) const {
if (Reloc.Type == R_WASM_TYPE_INDEX_LEB) { if (reloc.Type == R_WASM_TYPE_INDEX_LEB) {
assert(TypeIsUsed[Reloc.Index]); assert(typeIsUsed[reloc.Index]);
return TypeMap[Reloc.Index]; return typeMap[reloc.Index];
} }
const Symbol *Sym = Symbols[Reloc.Index]; const Symbol *sym = symbols[reloc.Index];
if (auto *SS = dyn_cast<SectionSymbol>(Sym)) if (auto *ss = dyn_cast<SectionSymbol>(sym))
Sym = SS->getOutputSectionSymbol(); sym = ss->getOutputSectionSymbol();
return Sym->getOutputSymbolIndex(); return sym->getOutputSymbolIndex();
} }
// Relocations can contain addend for combined sections. This function takes a // Relocations can contain addend for combined sections. This function takes a
// relocation and returns updated addend by offset in the output section. // relocation and returns updated addend by offset in the output section.
uint32_t ObjFile::calcNewAddend(const WasmRelocation &Reloc) const { uint32_t ObjFile::calcNewAddend(const WasmRelocation &reloc) const {
switch (Reloc.Type) { switch (reloc.Type) {
case R_WASM_MEMORY_ADDR_LEB: case R_WASM_MEMORY_ADDR_LEB:
case R_WASM_MEMORY_ADDR_SLEB: case R_WASM_MEMORY_ADDR_SLEB:
case R_WASM_MEMORY_ADDR_REL_SLEB: case R_WASM_MEMORY_ADDR_REL_SLEB:
case R_WASM_MEMORY_ADDR_I32: case R_WASM_MEMORY_ADDR_I32:
case R_WASM_FUNCTION_OFFSET_I32: case R_WASM_FUNCTION_OFFSET_I32:
return Reloc.Addend; return reloc.Addend;
case R_WASM_SECTION_OFFSET_I32: case R_WASM_SECTION_OFFSET_I32:
return getSectionSymbol(Reloc.Index)->Section->OutputOffset + Reloc.Addend; return getSectionSymbol(reloc.Index)->section->outputOffset + reloc.Addend;
default: default:
llvm_unreachable("unexpected relocation type"); llvm_unreachable("unexpected relocation type");
} }
} }
// Calculate the value we expect to find at the relocation location. // Calculate the value we expect to find at the relocation location.
// This is used as a sanity check before applying a relocation to a given // This is used as a sanity check before applying a relocation to a given
// location. It is useful for catching bugs in the compiler and linker. // location. It is useful for catching bugs in the compiler and linker.
uint32_t ObjFile::calcExpectedValue(const WasmRelocation &Reloc) const { uint32_t ObjFile::calcExpectedValue(const WasmRelocation &reloc) const {
switch (Reloc.Type) { switch (reloc.Type) {
case R_WASM_TABLE_INDEX_I32: case R_WASM_TABLE_INDEX_I32:
case R_WASM_TABLE_INDEX_SLEB: case R_WASM_TABLE_INDEX_SLEB:
case R_WASM_TABLE_INDEX_REL_SLEB: { case R_WASM_TABLE_INDEX_REL_SLEB: {
const WasmSymbol &Sym = WasmObj->syms()[Reloc.Index]; const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
return TableEntries[Sym.Info.ElementIndex]; return tableEntries[sym.Info.ElementIndex];
} }
case R_WASM_MEMORY_ADDR_SLEB: case R_WASM_MEMORY_ADDR_SLEB:
case R_WASM_MEMORY_ADDR_I32: case R_WASM_MEMORY_ADDR_I32:
case R_WASM_MEMORY_ADDR_LEB: case R_WASM_MEMORY_ADDR_LEB:
case R_WASM_MEMORY_ADDR_REL_SLEB: { case R_WASM_MEMORY_ADDR_REL_SLEB: {
const WasmSymbol &Sym = WasmObj->syms()[Reloc.Index]; const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
if (Sym.isUndefined()) if (sym.isUndefined())
return 0; return 0;
const WasmSegment &Segment = const WasmSegment &segment =
WasmObj->dataSegments()[Sym.Info.DataRef.Segment]; wasmObj->dataSegments()[sym.Info.DataRef.Segment];
return Segment.Data.Offset.Value.Int32 + Sym.Info.DataRef.Offset + return segment.Data.Offset.Value.Int32 + sym.Info.DataRef.Offset +
Reloc.Addend; reloc.Addend;
} }
case R_WASM_FUNCTION_OFFSET_I32: { case R_WASM_FUNCTION_OFFSET_I32: {
const WasmSymbol &Sym = WasmObj->syms()[Reloc.Index]; const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
InputFunction *F = InputFunction *f =
Functions[Sym.Info.ElementIndex - WasmObj->getNumImportedFunctions()]; functions[sym.Info.ElementIndex - wasmObj->getNumImportedFunctions()];
return F->getFunctionInputOffset() + F->getFunctionCodeOffset() + return f->getFunctionInputOffset() + f->getFunctionCodeOffset() +
Reloc.Addend; reloc.Addend;
} }
case R_WASM_SECTION_OFFSET_I32: case R_WASM_SECTION_OFFSET_I32:
return Reloc.Addend; return reloc.Addend;
case R_WASM_TYPE_INDEX_LEB: case R_WASM_TYPE_INDEX_LEB:
return Reloc.Index; return reloc.Index;
case R_WASM_FUNCTION_INDEX_LEB: case R_WASM_FUNCTION_INDEX_LEB:
case R_WASM_GLOBAL_INDEX_LEB: case R_WASM_GLOBAL_INDEX_LEB:
case R_WASM_EVENT_INDEX_LEB: { case R_WASM_EVENT_INDEX_LEB: {
const WasmSymbol &Sym = WasmObj->syms()[Reloc.Index]; const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
return Sym.Info.ElementIndex; return sym.Info.ElementIndex;
} }
default: default:
llvm_unreachable("unknown relocation type"); llvm_unreachable("unknown relocation type");
} }
} }
// Translate from the relocation's index into the final linked output value. // Translate from the relocation's index into the final linked output value.
uint32_t ObjFile::calcNewValue(const WasmRelocation &Reloc) const { uint32_t ObjFile::calcNewValue(const WasmRelocation &reloc) const {
const Symbol* Sym = nullptr; const Symbol* sym = nullptr;
if (Reloc.Type != R_WASM_TYPE_INDEX_LEB) { if (reloc.Type != R_WASM_TYPE_INDEX_LEB) {
Sym = Symbols[Reloc.Index]; sym = symbols[reloc.Index];
// We can end up with relocations against non-live symbols. For example // We can end up with relocations against non-live symbols. For example
// in debug sections. // in debug sections.
if ((isa<FunctionSymbol>(Sym) || isa<DataSymbol>(Sym)) && !Sym->isLive()) if ((isa<FunctionSymbol>(sym) || isa<DataSymbol>(sym)) && !sym->isLive())
return 0; return 0;
} }
switch (Reloc.Type) { switch (reloc.Type) {
case R_WASM_TABLE_INDEX_I32: case R_WASM_TABLE_INDEX_I32:
case R_WASM_TABLE_INDEX_SLEB: case R_WASM_TABLE_INDEX_SLEB:
case R_WASM_TABLE_INDEX_REL_SLEB: case R_WASM_TABLE_INDEX_REL_SLEB:
if (Config->Pic && !getFunctionSymbol(Reloc.Index)->hasTableIndex()) if (config->isPic && !getFunctionSymbol(reloc.Index)->hasTableIndex())
return 0; return 0;
return getFunctionSymbol(Reloc.Index)->getTableIndex(); return getFunctionSymbol(reloc.Index)->getTableIndex();
case R_WASM_MEMORY_ADDR_SLEB: case R_WASM_MEMORY_ADDR_SLEB:
case R_WASM_MEMORY_ADDR_I32: case R_WASM_MEMORY_ADDR_I32:
case R_WASM_MEMORY_ADDR_LEB: case R_WASM_MEMORY_ADDR_LEB:
case R_WASM_MEMORY_ADDR_REL_SLEB: case R_WASM_MEMORY_ADDR_REL_SLEB:
if (isa<UndefinedData>(Sym)) if (isa<UndefinedData>(sym))
return 0; return 0;
return cast<DefinedData>(Sym)->getVirtualAddress() + Reloc.Addend; return cast<DefinedData>(sym)->getVirtualAddress() + reloc.Addend;
case R_WASM_TYPE_INDEX_LEB: case R_WASM_TYPE_INDEX_LEB:
return TypeMap[Reloc.Index]; return typeMap[reloc.Index];
case R_WASM_FUNCTION_INDEX_LEB: case R_WASM_FUNCTION_INDEX_LEB:
return getFunctionSymbol(Reloc.Index)->getFunctionIndex(); return getFunctionSymbol(reloc.Index)->getFunctionIndex();
case R_WASM_GLOBAL_INDEX_LEB: case R_WASM_GLOBAL_INDEX_LEB:
if (auto GS = dyn_cast<GlobalSymbol>(Sym)) if (auto gs = dyn_cast<GlobalSymbol>(sym))
return GS->getGlobalIndex(); return gs->getGlobalIndex();
return Sym->getGOTIndex(); return sym->getGOTIndex();
case R_WASM_EVENT_INDEX_LEB: case R_WASM_EVENT_INDEX_LEB:
return getEventSymbol(Reloc.Index)->getEventIndex(); return getEventSymbol(reloc.Index)->getEventIndex();
case R_WASM_FUNCTION_OFFSET_I32: { case R_WASM_FUNCTION_OFFSET_I32: {
auto *F = cast<DefinedFunction>(Sym); auto *f = cast<DefinedFunction>(sym);
return F->Function->OutputOffset + F->Function->getFunctionCodeOffset() + return f->function->outputOffset + f->function->getFunctionCodeOffset() +
Reloc.Addend; reloc.Addend;
} }
case R_WASM_SECTION_OFFSET_I32: case R_WASM_SECTION_OFFSET_I32:
return getSectionSymbol(Reloc.Index)->Section->OutputOffset + Reloc.Addend; return getSectionSymbol(reloc.Index)->section->outputOffset + reloc.Addend;
default: default:
llvm_unreachable("unknown relocation type"); llvm_unreachable("unknown relocation type");
} }
} }
template <class T> template <class T>
static void setRelocs(const std::vector<T *> &Chunks, static void setRelocs(const std::vector<T *> &chunks,
const WasmSection *Section) { const WasmSection *section) {
if (!Section) if (!section)
return; return;
ArrayRef<WasmRelocation> Relocs = Section->Relocations; ArrayRef<WasmRelocation> relocs = section->Relocations;
assert(std::is_sorted(Relocs.begin(), Relocs.end(), assert(std::is_sorted(relocs.begin(), relocs.end(),
[](const WasmRelocation &R1, const WasmRelocation &R2) { [](const WasmRelocation &r1, const WasmRelocation &r2) {
return R1.Offset < R2.Offset; return r1.Offset < r2.Offset;
})); }));
assert(std::is_sorted( assert(std::is_sorted(
Chunks.begin(), Chunks.end(), [](InputChunk *C1, InputChunk *C2) { chunks.begin(), chunks.end(), [](InputChunk *c1, InputChunk *c2) {
return C1->getInputSectionOffset() < C2->getInputSectionOffset(); return c1->getInputSectionOffset() < c2->getInputSectionOffset();
})); }));
auto RelocsNext = Relocs.begin(); auto relocsNext = relocs.begin();
auto RelocsEnd = Relocs.end(); auto relocsEnd = relocs.end();
auto RelocLess = [](const WasmRelocation &R, uint32_t Val) { auto relocLess = [](const WasmRelocation &r, uint32_t val) {
return R.Offset < Val; return r.Offset < val;
}; };
for (InputChunk *C : Chunks) { for (InputChunk *c : chunks) {
auto RelocsStart = std::lower_bound(RelocsNext, RelocsEnd, auto relocsStart = std::lower_bound(relocsNext, relocsEnd,
C->getInputSectionOffset(), RelocLess); c->getInputSectionOffset(), relocLess);
RelocsNext = std::lower_bound( relocsNext = std::lower_bound(
RelocsStart, RelocsEnd, C->getInputSectionOffset() + C->getInputSize(), relocsStart, relocsEnd, c->getInputSectionOffset() + c->getInputSize(),
RelocLess); relocLess);
C->setRelocations(ArrayRef<WasmRelocation>(RelocsStart, RelocsNext)); c->setRelocations(ArrayRef<WasmRelocation>(relocsStart, relocsNext));
} }
} }
void ObjFile::parse(bool IgnoreComdats) { void ObjFile::parse(bool ignoreComdats) {
// Parse a memory buffer as a wasm file. // Parse a memory buffer as a wasm file.
LLVM_DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n"); LLVM_DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
std::unique_ptr<Binary> Bin = CHECK(createBinary(MB), toString(this)); std::unique_ptr<Binary> bin = CHECK(createBinary(mb), toString(this));
auto *Obj = dyn_cast<WasmObjectFile>(Bin.get()); auto *obj = dyn_cast<WasmObjectFile>(bin.get());
if (!Obj) if (!obj)
fatal(toString(this) + ": not a wasm file"); fatal(toString(this) + ": not a wasm file");
if (!Obj->isRelocatableObject()) if (!obj->isRelocatableObject())
fatal(toString(this) + ": not a relocatable wasm file"); fatal(toString(this) + ": not a relocatable wasm file");
Bin.release(); bin.release();
WasmObj.reset(Obj); wasmObj.reset(obj);
// Build up a map of function indices to table indices for use when // Build up a map of function indices to table indices for use when
// verifying the existing table index relocations // verifying the existing table index relocations
uint32_t TotalFunctions = uint32_t totalFunctions =
WasmObj->getNumImportedFunctions() + WasmObj->functions().size(); wasmObj->getNumImportedFunctions() + wasmObj->functions().size();
TableEntries.resize(TotalFunctions); tableEntries.resize(totalFunctions);
for (const WasmElemSegment &Seg : WasmObj->elements()) { for (const WasmElemSegment &seg : wasmObj->elements()) {
if (Seg.Offset.Opcode != WASM_OPCODE_I32_CONST) if (seg.Offset.Opcode != WASM_OPCODE_I32_CONST)
fatal(toString(this) + ": invalid table elements"); fatal(toString(this) + ": invalid table elements");
uint32_t Offset = Seg.Offset.Value.Int32; uint32_t offset = seg.Offset.Value.Int32;
for (uint32_t Index = 0; Index < Seg.Functions.size(); Index++) { for (uint32_t index = 0; index < seg.Functions.size(); index++) {
uint32_t FunctionIndex = Seg.Functions[Index]; uint32_t functionIndex = seg.Functions[index];
TableEntries[FunctionIndex] = Offset + Index; tableEntries[functionIndex] = offset + index;
} }
} }
uint32_t SectionIndex = 0; uint32_t sectionIndex = 0;
// Bool for each symbol, true if called directly. This allows us to implement // Bool for each symbol, true if called directly. This allows us to implement
// a weaker form of signature checking where undefined functions that are not // a weaker form of signature checking where undefined functions that are not
// called directly (i.e. only address taken) don't have to match the defined // called directly (i.e. only address taken) don't have to match the defined
// function's signature. We cannot do this for directly called functions // function's signature. We cannot do this for directly called functions
// because those signatures are checked at validation times. // because those signatures are checked at validation times.
// See https://bugs.llvm.org/show_bug.cgi?id=40412 // See https://bugs.llvm.org/show_bug.cgi?id=40412
std::vector<bool> IsCalledDirectly(WasmObj->getNumberOfSymbols(), false); std::vector<bool> isCalledDirectly(wasmObj->getNumberOfSymbols(), false);
for (const SectionRef &Sec : WasmObj->sections()) { for (const SectionRef &sec : wasmObj->sections()) {
const WasmSection &Section = WasmObj->getWasmSection(Sec); const WasmSection &section = wasmObj->getWasmSection(sec);
// Wasm objects can have at most one code and one data section. // Wasm objects can have at most one code and one data section.
if (Section.Type == WASM_SEC_CODE) { if (section.Type == WASM_SEC_CODE) {
assert(!CodeSection); assert(!codeSection);
CodeSection = &Section; codeSection = &section;
} else if (Section.Type == WASM_SEC_DATA) { } else if (section.Type == WASM_SEC_DATA) {
assert(!DataSection); assert(!dataSection);
DataSection = &Section; dataSection = &section;
} else if (Section.Type == WASM_SEC_CUSTOM) { } else if (section.Type == WASM_SEC_CUSTOM) {
CustomSections.emplace_back(make<InputSection>(Section, this)); customSections.emplace_back(make<InputSection>(section, this));
CustomSections.back()->setRelocations(Section.Relocations); customSections.back()->setRelocations(section.Relocations);
CustomSectionsByIndex[SectionIndex] = CustomSections.back(); customSectionsByIndex[sectionIndex] = customSections.back();
} }
SectionIndex++; sectionIndex++;
// Scans relocations to dermine determine if a function symbol is called // Scans relocations to dermine determine if a function symbol is called
// directly // directly
for (const WasmRelocation &Reloc : Section.Relocations) for (const WasmRelocation &reloc : section.Relocations)
if (Reloc.Type == R_WASM_FUNCTION_INDEX_LEB) if (reloc.Type == R_WASM_FUNCTION_INDEX_LEB)
IsCalledDirectly[Reloc.Index] = true; isCalledDirectly[reloc.Index] = true;
} }
TypeMap.resize(getWasmObj()->types().size()); typeMap.resize(getWasmObj()->types().size());
TypeIsUsed.resize(getWasmObj()->types().size(), false); typeIsUsed.resize(getWasmObj()->types().size(), false);
ArrayRef<StringRef> Comdats = WasmObj->linkingData().Comdats; ArrayRef<StringRef> comdats = wasmObj->linkingData().Comdats;
for (StringRef Comdat : Comdats) { for (StringRef comdat : comdats) {
bool IsNew = IgnoreComdats || Symtab->addComdat(Comdat); bool isNew = ignoreComdats || symtab->addComdat(comdat);
KeptComdats.push_back(IsNew); keptComdats.push_back(isNew);
} }
// Populate `Segments`. // Populate `Segments`.
for (const WasmSegment &S : WasmObj->dataSegments()) { for (const WasmSegment &s : wasmObj->dataSegments()) {
auto* Seg = make<InputSegment>(S, this); auto* seg = make<InputSegment>(s, this);
Seg->Discarded = isExcludedByComdat(Seg); seg->discarded = isExcludedByComdat(seg);
Segments.emplace_back(Seg); segments.emplace_back(seg);
} }
setRelocs(Segments, DataSection); setRelocs(segments, dataSection);
// Populate `Functions`. // Populate `Functions`.
ArrayRef<WasmFunction> Funcs = WasmObj->functions(); ArrayRef<WasmFunction> funcs = wasmObj->functions();
ArrayRef<uint32_t> FuncTypes = WasmObj->functionTypes(); ArrayRef<uint32_t> funcTypes = wasmObj->functionTypes();
ArrayRef<WasmSignature> Types = WasmObj->types(); ArrayRef<WasmSignature> types = wasmObj->types();
Functions.reserve(Funcs.size()); functions.reserve(funcs.size());
for (size_t I = 0, E = Funcs.size(); I != E; ++I) { for (size_t i = 0, e = funcs.size(); i != e; ++i) {
auto* Func = make<InputFunction>(Types[FuncTypes[I]], &Funcs[I], this); auto* func = make<InputFunction>(types[funcTypes[i]], &funcs[i], this);
Func->Discarded = isExcludedByComdat(Func); func->discarded = isExcludedByComdat(func);
Functions.emplace_back(Func); functions.emplace_back(func);
} }
setRelocs(Functions, CodeSection); setRelocs(functions, codeSection);
// Populate `Globals`. // Populate `Globals`.
for (const WasmGlobal &G : WasmObj->globals()) for (const WasmGlobal &g : wasmObj->globals())
Globals.emplace_back(make<InputGlobal>(G, this)); globals.emplace_back(make<InputGlobal>(g, this));
// Populate `Events`. // Populate `Events`.
for (const WasmEvent &E : WasmObj->events()) for (const WasmEvent &e : wasmObj->events())
Events.emplace_back(make<InputEvent>(Types[E.Type.SigIndex], E, this)); events.emplace_back(make<InputEvent>(types[e.Type.SigIndex], e, this));
// Populate `Symbols` based on the WasmSymbols in the object. // Populate `Symbols` based on the WasmSymbols in the object.
Symbols.reserve(WasmObj->getNumberOfSymbols()); symbols.reserve(wasmObj->getNumberOfSymbols());
for (const SymbolRef &Sym : WasmObj->symbols()) { for (const SymbolRef &sym : wasmObj->symbols()) {
const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl()); const WasmSymbol &wasmSym = wasmObj->getWasmSymbol(sym.getRawDataRefImpl());
if (WasmSym.isDefined()) { if (wasmSym.isDefined()) {
// createDefined may fail if the symbol is comdat excluded in which case // createDefined may fail if the symbol is comdat excluded in which case
// we fall back to creating an undefined symbol // we fall back to creating an undefined symbol
if (Symbol *D = createDefined(WasmSym)) { if (Symbol *d = createDefined(wasmSym)) {
Symbols.push_back(D); symbols.push_back(d);
continue; continue;
} }
} }
size_t Idx = Symbols.size(); size_t idx = symbols.size();
Symbols.push_back(createUndefined(WasmSym, IsCalledDirectly[Idx])); symbols.push_back(createUndefined(wasmSym, isCalledDirectly[idx]));
} }
} }
bool ObjFile::isExcludedByComdat(InputChunk *Chunk) const { bool ObjFile::isExcludedByComdat(InputChunk *chunk) const {
uint32_t C = Chunk->getComdat(); uint32_t c = chunk->getComdat();
if (C == UINT32_MAX) if (c == UINT32_MAX)
return false; return false;
return !KeptComdats[C]; return !keptComdats[c];
} }
FunctionSymbol *ObjFile::getFunctionSymbol(uint32_t Index) const { FunctionSymbol *ObjFile::getFunctionSymbol(uint32_t index) const {
return cast<FunctionSymbol>(Symbols[Index]); return cast<FunctionSymbol>(symbols[index]);
} }
GlobalSymbol *ObjFile::getGlobalSymbol(uint32_t Index) const { GlobalSymbol *ObjFile::getGlobalSymbol(uint32_t index) const {
return cast<GlobalSymbol>(Symbols[Index]); return cast<GlobalSymbol>(symbols[index]);
} }
EventSymbol *ObjFile::getEventSymbol(uint32_t Index) const { EventSymbol *ObjFile::getEventSymbol(uint32_t index) const {
return cast<EventSymbol>(Symbols[Index]); return cast<EventSymbol>(symbols[index]);
} }
SectionSymbol *ObjFile::getSectionSymbol(uint32_t Index) const { SectionSymbol *ObjFile::getSectionSymbol(uint32_t index) const {
return cast<SectionSymbol>(Symbols[Index]); return cast<SectionSymbol>(symbols[index]);
} }
DataSymbol *ObjFile::getDataSymbol(uint32_t Index) const { DataSymbol *ObjFile::getDataSymbol(uint32_t index) const {
return cast<DataSymbol>(Symbols[Index]); return cast<DataSymbol>(symbols[index]);
} }
Symbol *ObjFile::createDefined(const WasmSymbol &Sym) { Symbol *ObjFile::createDefined(const WasmSymbol &sym) {
StringRef Name = Sym.Info.Name; StringRef name = sym.Info.Name;
uint32_t Flags = Sym.Info.Flags; uint32_t flags = sym.Info.Flags;
switch (Sym.Info.Kind) { switch (sym.Info.Kind) {
case WASM_SYMBOL_TYPE_FUNCTION: { case WASM_SYMBOL_TYPE_FUNCTION: {
InputFunction *Func = InputFunction *func =
Functions[Sym.Info.ElementIndex - WasmObj->getNumImportedFunctions()]; functions[sym.Info.ElementIndex - wasmObj->getNumImportedFunctions()];
if (Func->Discarded) if (func->discarded)
return nullptr; return nullptr;
if (Sym.isBindingLocal()) if (sym.isBindingLocal())
return make<DefinedFunction>(Name, Flags, this, Func); return make<DefinedFunction>(name, flags, this, func);
return Symtab->addDefinedFunction(Name, Flags, this, Func); return symtab->addDefinedFunction(name, flags, this, func);
} }
case WASM_SYMBOL_TYPE_DATA: { case WASM_SYMBOL_TYPE_DATA: {
InputSegment *Seg = Segments[Sym.Info.DataRef.Segment]; InputSegment *seg = segments[sym.Info.DataRef.Segment];
if (Seg->Discarded) if (seg->discarded)
return nullptr; return nullptr;
uint32_t Offset = Sym.Info.DataRef.Offset; uint32_t offset = sym.Info.DataRef.Offset;
uint32_t Size = Sym.Info.DataRef.Size; uint32_t size = sym.Info.DataRef.Size;
if (Sym.isBindingLocal()) if (sym.isBindingLocal())
return make<DefinedData>(Name, Flags, this, Seg, Offset, Size); return make<DefinedData>(name, flags, this, seg, offset, size);
return Symtab->addDefinedData(Name, Flags, this, Seg, Offset, Size); return symtab->addDefinedData(name, flags, this, seg, offset, size);
} }
case WASM_SYMBOL_TYPE_GLOBAL: { case WASM_SYMBOL_TYPE_GLOBAL: {
InputGlobal *Global = InputGlobal *global =
Globals[Sym.Info.ElementIndex - WasmObj->getNumImportedGlobals()]; globals[sym.Info.ElementIndex - wasmObj->getNumImportedGlobals()];
if (Sym.isBindingLocal()) if (sym.isBindingLocal())
return make<DefinedGlobal>(Name, Flags, this, Global); return make<DefinedGlobal>(name, flags, this, global);
return Symtab->addDefinedGlobal(Name, Flags, this, Global); return symtab->addDefinedGlobal(name, flags, this, global);
} }
case WASM_SYMBOL_TYPE_SECTION: { case WASM_SYMBOL_TYPE_SECTION: {
InputSection *Section = CustomSectionsByIndex[Sym.Info.ElementIndex]; InputSection *section = customSectionsByIndex[sym.Info.ElementIndex];
assert(Sym.isBindingLocal()); assert(sym.isBindingLocal());
return make<SectionSymbol>(Flags, Section, this); return make<SectionSymbol>(flags, section, this);
} }
case WASM_SYMBOL_TYPE_EVENT: { case WASM_SYMBOL_TYPE_EVENT: {
InputEvent *Event = InputEvent *event =
Events[Sym.Info.ElementIndex - WasmObj->getNumImportedEvents()]; events[sym.Info.ElementIndex - wasmObj->getNumImportedEvents()];
if (Sym.isBindingLocal()) if (sym.isBindingLocal())
return make<DefinedEvent>(Name, Flags, this, Event); return make<DefinedEvent>(name, flags, this, event);
return Symtab->addDefinedEvent(Name, Flags, this, Event); return symtab->addDefinedEvent(name, flags, this, event);
} }
} }
llvm_unreachable("unknown symbol kind"); llvm_unreachable("unknown symbol kind");
} }
Symbol *ObjFile::createUndefined(const WasmSymbol &Sym, bool IsCalledDirectly) { Symbol *ObjFile::createUndefined(const WasmSymbol &sym, bool isCalledDirectly) {
StringRef Name = Sym.Info.Name; StringRef name = sym.Info.Name;
uint32_t Flags = Sym.Info.Flags; uint32_t flags = sym.Info.Flags;
switch (Sym.Info.Kind) { switch (sym.Info.Kind) {
case WASM_SYMBOL_TYPE_FUNCTION: case WASM_SYMBOL_TYPE_FUNCTION:
if (Sym.isBindingLocal()) if (sym.isBindingLocal())
return make<UndefinedFunction>(Name, Sym.Info.ImportName, return make<UndefinedFunction>(name, sym.Info.ImportName,
Sym.Info.ImportModule, Flags, this, sym.Info.ImportModule, flags, this,
Sym.Signature, IsCalledDirectly); sym.Signature, isCalledDirectly);
return Symtab->addUndefinedFunction(Name, Sym.Info.ImportName, return symtab->addUndefinedFunction(name, sym.Info.ImportName,
Sym.Info.ImportModule, Flags, this, sym.Info.ImportModule, flags, this,
Sym.Signature, IsCalledDirectly); sym.Signature, isCalledDirectly);
case WASM_SYMBOL_TYPE_DATA: case WASM_SYMBOL_TYPE_DATA:
if (Sym.isBindingLocal()) if (sym.isBindingLocal())
return make<UndefinedData>(Name, Flags, this); return make<UndefinedData>(name, flags, this);
return Symtab->addUndefinedData(Name, Flags, this); return symtab->addUndefinedData(name, flags, this);
case WASM_SYMBOL_TYPE_GLOBAL: case WASM_SYMBOL_TYPE_GLOBAL:
if (Sym.isBindingLocal()) if (sym.isBindingLocal())
return make<UndefinedGlobal>(Name, Sym.Info.ImportName, return make<UndefinedGlobal>(name, sym.Info.ImportName,
Sym.Info.ImportModule, Flags, this, sym.Info.ImportModule, flags, this,
Sym.GlobalType); sym.GlobalType);
return Symtab->addUndefinedGlobal(Name, Sym.Info.ImportName, return symtab->addUndefinedGlobal(name, sym.Info.ImportName,
Sym.Info.ImportModule, Flags, this, sym.Info.ImportModule, flags, this,
Sym.GlobalType); sym.GlobalType);
case WASM_SYMBOL_TYPE_SECTION: case WASM_SYMBOL_TYPE_SECTION:
llvm_unreachable("section symbols cannot be undefined"); llvm_unreachable("section symbols cannot be undefined");
} }
llvm_unreachable("unknown symbol kind"); llvm_unreachable("unknown symbol kind");
} }
void ArchiveFile::parse() { void ArchiveFile::parse() {
// Parse a MemoryBufferRef as an archive file. // Parse a MemoryBufferRef as an archive file.
LLVM_DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n"); LLVM_DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
File = CHECK(Archive::create(MB), toString(this)); file = CHECK(Archive::create(mb), toString(this));
// Read the symbol table to construct Lazy symbols. // Read the symbol table to construct Lazy symbols.
int Count = 0; int count = 0;
for (const Archive::Symbol &Sym : File->symbols()) { for (const Archive::Symbol &sym : file->symbols()) {
Symtab->addLazy(this, &Sym); symtab->addLazy(this, &sym);
++Count; ++count;
} }
LLVM_DEBUG(dbgs() << "Read " << Count << " symbols\n"); LLVM_DEBUG(dbgs() << "Read " << count << " symbols\n");
} }
void ArchiveFile::addMember(const Archive::Symbol *Sym) { void ArchiveFile::addMember(const Archive::Symbol *sym) {
const Archive::Child &C = const Archive::Child &c =
CHECK(Sym->getMember(), CHECK(sym->getMember(),
"could not get the member for symbol " + Sym->getName()); "could not get the member for symbol " + sym->getName());
// Don't try to load the same member twice (this can happen when members // Don't try to load the same member twice (this can happen when members
// mutually reference each other). // mutually reference each other).
if (!Seen.insert(C.getChildOffset()).second) if (!seen.insert(c.getChildOffset()).second)
return; return;
LLVM_DEBUG(dbgs() << "loading lazy: " << Sym->getName() << "\n"); LLVM_DEBUG(dbgs() << "loading lazy: " << sym->getName() << "\n");
LLVM_DEBUG(dbgs() << "from archive: " << toString(this) << "\n"); LLVM_DEBUG(dbgs() << "from archive: " << toString(this) << "\n");
MemoryBufferRef MB = MemoryBufferRef mb =
CHECK(C.getMemoryBufferRef(), CHECK(c.getMemoryBufferRef(),
"could not get the buffer for the member defining symbol " + "could not get the buffer for the member defining symbol " +
Sym->getName()); sym->getName());
InputFile *Obj = createObjectFile(MB, getName()); InputFile *obj = createObjectFile(mb, getName());
Symtab->addFile(Obj); symtab->addFile(obj);
} }
static uint8_t mapVisibility(GlobalValue::VisibilityTypes GvVisibility) { static uint8_t mapVisibility(GlobalValue::VisibilityTypes gvVisibility) {
switch (GvVisibility) { switch (gvVisibility) {
case GlobalValue::DefaultVisibility: case GlobalValue::DefaultVisibility:
return WASM_SYMBOL_VISIBILITY_DEFAULT; return WASM_SYMBOL_VISIBILITY_DEFAULT;
case GlobalValue::HiddenVisibility: case GlobalValue::HiddenVisibility:
case GlobalValue::ProtectedVisibility: case GlobalValue::ProtectedVisibility:
return WASM_SYMBOL_VISIBILITY_HIDDEN; return WASM_SYMBOL_VISIBILITY_HIDDEN;
} }
llvm_unreachable("unknown visibility"); llvm_unreachable("unknown visibility");
} }
static Symbol *createBitcodeSymbol(const std::vector<bool> &KeptComdats, static Symbol *createBitcodeSymbol(const std::vector<bool> &keptComdats,
const lto::InputFile::Symbol &ObjSym, const lto::InputFile::Symbol &objSym,
BitcodeFile &F) { BitcodeFile &f) {
StringRef Name = Saver.save(ObjSym.getName()); StringRef name = saver.save(objSym.getName());
uint32_t Flags = ObjSym.isWeak() ? WASM_SYMBOL_BINDING_WEAK : 0; uint32_t flags = objSym.isWeak() ? WASM_SYMBOL_BINDING_WEAK : 0;
Flags |= mapVisibility(ObjSym.getVisibility()); flags |= mapVisibility(objSym.getVisibility());
int C = ObjSym.getComdatIndex(); int c = objSym.getComdatIndex();
bool ExcludedByComdat = C != -1 && !KeptComdats[C]; bool excludedByComdat = c != -1 && !keptComdats[c];
if (ObjSym.isUndefined() || ExcludedByComdat) { if (objSym.isUndefined() || excludedByComdat) {
if (ObjSym.isExecutable()) if (objSym.isExecutable())
return Symtab->addUndefinedFunction(Name, Name, DefaultModule, Flags, &F, return symtab->addUndefinedFunction(name, name, defaultModule, flags, &f,
nullptr, true); nullptr, true);
return Symtab->addUndefinedData(Name, Flags, &F); return symtab->addUndefinedData(name, flags, &f);
} }
if (ObjSym.isExecutable()) if (objSym.isExecutable())
return Symtab->addDefinedFunction(Name, Flags, &F, nullptr); return symtab->addDefinedFunction(name, flags, &f, nullptr);
return Symtab->addDefinedData(Name, Flags, &F, nullptr, 0, 0); return symtab->addDefinedData(name, flags, &f, nullptr, 0, 0);
} }
void BitcodeFile::parse() { void BitcodeFile::parse() {
Obj = check(lto::InputFile::create(MemoryBufferRef( obj = check(lto::InputFile::create(MemoryBufferRef(
MB.getBuffer(), Saver.save(ArchiveName + MB.getBufferIdentifier())))); mb.getBuffer(), saver.save(archiveName + mb.getBufferIdentifier()))));
Triple T(Obj->getTargetTriple()); Triple t(obj->getTargetTriple());
if (T.getArch() != Triple::wasm32) { if (t.getArch() != Triple::wasm32) {
error(toString(MB.getBufferIdentifier()) + ": machine type must be wasm32"); error(toString(mb.getBufferIdentifier()) + ": machine type must be wasm32");
return; return;
} }
std::vector<bool> KeptComdats; std::vector<bool> keptComdats;
for (StringRef S : Obj->getComdatTable()) for (StringRef s : obj->getComdatTable())
KeptComdats.push_back(Symtab->addComdat(S)); keptComdats.push_back(symtab->addComdat(s));
for (const lto::InputFile::Symbol &ObjSym : Obj->symbols()) for (const lto::InputFile::Symbol &objSym : obj->symbols())
Symbols.push_back(createBitcodeSymbol(KeptComdats, ObjSym, *this)); symbols.push_back(createBitcodeSymbol(keptComdats, objSym, *this));
} }
// Returns a string in the format of "foo.o" or "foo.a(bar.o)". // Returns a string in the format of "foo.o" or "foo.a(bar.o)".
std::string lld::toString(const wasm::InputFile *File) { std::string lld::toString(const wasm::InputFile *file) {
if (!File) if (!file)
return "<internal>"; return "<internal>";
if (File->ArchiveName.empty()) if (file->archiveName.empty())
return File->getName(); return file->getName();
return (File->ArchiveName + "(" + File->getName() + ")").str(); return (file->archiveName + "(" + file->getName() + ")").str();
} }

lld/trunk/wasm/InputGlobal.h

Show All 16 Lines
namespace lld { namespace lld {
namespace wasm { namespace wasm {
// Represents a single Wasm Global Variable within an input file. These are // Represents a single Wasm Global Variable within an input file. These are
// combined to form the final GLOBALS section. // combined to form the final GLOBALS section.
class InputGlobal { class InputGlobal {
public: public:
InputGlobal(const WasmGlobal &G, ObjFile *F) InputGlobal(const WasmGlobal &g, ObjFile *f)
: File(F), Global(G), Live(!Config->GcSections) {} : file(f), global(g), live(!config->gcSections) {}
StringRef getName() const { return Global.SymbolName; } StringRef getName() const { return global.SymbolName; }
const WasmGlobalType &getType() const { return Global.Type; } const WasmGlobalType &getType() const { return global.Type; }
uint32_t getGlobalIndex() const { return GlobalIndex.getValue(); } uint32_t getGlobalIndex() const { return globalIndex.getValue(); }
bool hasGlobalIndex() const { return GlobalIndex.hasValue(); } bool hasGlobalIndex() const { return globalIndex.hasValue(); }
void setGlobalIndex(uint32_t Index) { void setGlobalIndex(uint32_t index) {
assert(!hasGlobalIndex()); assert(!hasGlobalIndex());
GlobalIndex = Index; globalIndex = index;
} }
ObjFile *File; ObjFile *file;
WasmGlobal Global; WasmGlobal global;
bool Live = false; bool live = false;
protected: protected:
llvm::Optional<uint32_t> GlobalIndex; llvm::Optional<uint32_t> globalIndex;
}; };
} // namespace wasm } // namespace wasm
inline std::string toString(const wasm::InputGlobal *G) { inline std::string toString(const wasm::InputGlobal *g) {
return (toString(G->File) + ":(" + G->getName() + ")").str(); return (toString(g->file) + ":(" + g->getName() + ")").str();
} }
} // namespace lld } // namespace lld
#endif // LLD_WASM_INPUT_GLOBAL_H #endif // LLD_WASM_INPUT_GLOBAL_H

lld/trunk/wasm/LTO.h

Show All 37 Lines
class BitcodeFile; class BitcodeFile;
class InputFile; class InputFile;
class BitcodeCompiler { class BitcodeCompiler {
public: public:
BitcodeCompiler(); BitcodeCompiler();
~BitcodeCompiler(); ~BitcodeCompiler();
void add(BitcodeFile &F); void add(BitcodeFile &f);
std::vector<StringRef> compile(); std::vector<StringRef> compile();
private: private:
std::unique_ptr<llvm::lto::LTO> LTOObj; std::unique_ptr<llvm::lto::LTO> ltoObj;
std::vector<SmallString<0>> Buf; std::vector<SmallString<0>> buf;
std::vector<std::unique_ptr<MemoryBuffer>> Files; std::vector<std::unique_ptr<MemoryBuffer>> files;
}; };
} // namespace wasm } // namespace wasm
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/wasm/LTO.cpp

Show All 34 Lines
#include <system_error> #include <system_error>
#include <vector> #include <vector>
using namespace llvm; using namespace llvm;
using namespace lld; using namespace lld;
using namespace lld::wasm; using namespace lld::wasm;
static std::unique_ptr<lto::LTO> createLTO() { static std::unique_ptr<lto::LTO> createLTO() {
lto::Config C; lto::Config c;
C.Options = initTargetOptionsFromCodeGenFlags(); c.Options = initTargetOptionsFromCodeGenFlags();
// Always emit a section per function/data with LTO. // Always emit a section per function/data with LTO.
C.Options.FunctionSections = true; c.Options.FunctionSections = true;
C.Options.DataSections = true; c.Options.DataSections = true;
C.DisableVerify = Config->DisableVerify; c.DisableVerify = config->disableVerify;
C.DiagHandler = diagnosticHandler; c.DiagHandler = diagnosticHandler;
C.OptLevel = Config->LTOO; c.OptLevel = config->ltoo;
C.MAttrs = getMAttrs(); c.MAttrs = getMAttrs();
C.CGOptLevel = args::getCGOptLevel(Config->LTOO); c.CGOptLevel = args::getCGOptLevel(config->ltoo);
if (Config->Relocatable) if (config->relocatable)
C.RelocModel = None; c.RelocModel = None;
else if (Config->Pic) else if (config->isPic)
C.RelocModel = Reloc::PIC_; c.RelocModel = Reloc::PIC_;
else else
C.RelocModel = Reloc::Static; c.RelocModel = Reloc::Static;
if (Config->SaveTemps) if (config->saveTemps)
checkError(C.addSaveTemps(Config->OutputFile.str() + ".", checkError(c.addSaveTemps(config->outputFile.str() + ".",
/*UseInputModulePath*/ true)); /*UseInputModulePath*/ true));
lto::ThinBackend Backend; lto::ThinBackend backend;
if (Config->ThinLTOJobs != -1U) if (config->thinLTOJobs != -1U)
Backend = lto::createInProcessThinBackend(Config->ThinLTOJobs); backend = lto::createInProcessThinBackend(config->thinLTOJobs);
return llvm::make_unique<lto::LTO>(std::move(C), Backend, return llvm::make_unique<lto::LTO>(std::move(c), backend,
Config->LTOPartitions); config->ltoPartitions);
} }
BitcodeCompiler::BitcodeCompiler() : LTOObj(createLTO()) {} BitcodeCompiler::BitcodeCompiler() : ltoObj(createLTO()) {}
BitcodeCompiler::~BitcodeCompiler() = default; BitcodeCompiler::~BitcodeCompiler() = default;
static void undefine(Symbol *S) { static void undefine(Symbol *s) {
if (auto F = dyn_cast<DefinedFunction>(S)) if (auto f = dyn_cast<DefinedFunction>(s))
replaceSymbol<UndefinedFunction>(F, F->getName(), F->getName(), replaceSymbol<UndefinedFunction>(f, f->getName(), f->getName(),
DefaultModule, 0, defaultModule, 0,
F->getFile(), F->Signature); f->getFile(), f->signature);
else if (isa<DefinedData>(S)) else if (isa<DefinedData>(s))
replaceSymbol<UndefinedData>(S, S->getName(), 0, S->getFile()); replaceSymbol<UndefinedData>(s, s->getName(), 0, s->getFile());
else else
llvm_unreachable("unexpected symbol kind"); llvm_unreachable("unexpected symbol kind");
} }
void BitcodeCompiler::add(BitcodeFile &F) { void BitcodeCompiler::add(BitcodeFile &f) {
lto::InputFile &Obj = *F.Obj; lto::InputFile &obj = *f.obj;
unsigned SymNum = 0; unsigned symNum = 0;
ArrayRef<Symbol *> Syms = F.getSymbols(); ArrayRef<Symbol *> syms = f.getSymbols();
std::vector<lto::SymbolResolution> Resols(Syms.size()); std::vector<lto::SymbolResolution> resols(syms.size());
// Provide a resolution to the LTO API for each symbol. // Provide a resolution to the LTO API for each symbol.
for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) { for (const lto::InputFile::Symbol &objSym : obj.symbols()) {
Symbol *Sym = Syms[SymNum]; Symbol *sym = syms[symNum];
lto::SymbolResolution &R = Resols[SymNum]; lto::SymbolResolution &r = resols[symNum];
++SymNum; ++symNum;
// Ideally we shouldn't check for SF_Undefined but currently IRObjectFile // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile
// reports two symbols for module ASM defined. Without this check, lld // reports two symbols for module ASM defined. Without this check, lld
// flags an undefined in IR with a definition in ASM as prevailing. // flags an undefined in IR with a definition in ASM as prevailing.
// Once IRObjectFile is fixed to report only one symbol this hack can // Once IRObjectFile is fixed to report only one symbol this hack can
// be removed. // be removed.
R.Prevailing = !ObjSym.isUndefined() && Sym->getFile() == &F; r.Prevailing = !objSym.isUndefined() && sym->getFile() == &f;
R.VisibleToRegularObj = Config->Relocatable || Sym->IsUsedInRegularObj || r.VisibleToRegularObj = config->relocatable || sym->isUsedInRegularObj ||
(R.Prevailing && Sym->isExported()); (r.Prevailing && sym->isExported());
if (R.Prevailing) if (r.Prevailing)
undefine(Sym); undefine(sym);
// We tell LTO to not apply interprocedural optimization for wrapped // We tell LTO to not apply interprocedural optimization for wrapped
// (with --wrap) symbols because otherwise LTO would inline them while // (with --wrap) symbols because otherwise LTO would inline them while
// their values are still not final. // their values are still not final.
R.LinkerRedefined = !Sym->CanInline; r.LinkerRedefined = !sym->canInline;
} }
checkError(LTOObj->add(std::move(F.Obj), Resols)); checkError(ltoObj->add(std::move(f.obj), resols));
} }
// Merge all the bitcode files we have seen, codegen the result // Merge all the bitcode files we have seen, codegen the result
// and return the resulting objects. // and return the resulting objects.
std::vector<StringRef> BitcodeCompiler::compile() { std::vector<StringRef> BitcodeCompiler::compile() {
unsigned MaxTasks = LTOObj->getMaxTasks(); unsigned maxTasks = ltoObj->getMaxTasks();
Buf.resize(MaxTasks); buf.resize(maxTasks);
Files.resize(MaxTasks); files.resize(maxTasks);
// The --thinlto-cache-dir option specifies the path to a directory in which // The --thinlto-cache-dir option specifies the path to a directory in which
// to cache native object files for ThinLTO incremental builds. If a path was // to cache native object files for ThinLTO incremental builds. If a path was
// specified, configure LTO to use it as the cache directory. // specified, configure LTO to use it as the cache directory.
lto::NativeObjectCache Cache; lto::NativeObjectCache cache;
if (!Config->ThinLTOCacheDir.empty()) if (!config->thinLTOCacheDir.empty())
Cache = check( cache = check(
lto::localCache(Config->ThinLTOCacheDir, lto::localCache(config->thinLTOCacheDir,
[&](size_t Task, std::unique_ptr<MemoryBuffer> MB) { [&](size_t task, std::unique_ptr<MemoryBuffer> mb) {
Files[Task] = std::move(MB); files[task] = std::move(mb);
})); }));
checkError(LTOObj->run( checkError(ltoObj->run(
[&](size_t Task) { [&](size_t task) {
return llvm::make_unique<lto::NativeObjectStream>( return llvm::make_unique<lto::NativeObjectStream>(
llvm::make_unique<raw_svector_ostream>(Buf[Task])); llvm::make_unique<raw_svector_ostream>(buf[task]));
}, },
Cache)); cache));
if (!Config->ThinLTOCacheDir.empty()) if (!config->thinLTOCacheDir.empty())
pruneCache(Config->ThinLTOCacheDir, Config->ThinLTOCachePolicy); pruneCache(config->thinLTOCacheDir, config->thinLTOCachePolicy);
std::vector<StringRef> Ret; std::vector<StringRef> ret;
for (unsigned I = 0; I != MaxTasks; ++I) { for (unsigned i = 0; i != maxTasks; ++i) {
if (Buf[I].empty()) if (buf[i].empty())
continue; continue;
if (Config->SaveTemps) { if (config->saveTemps) {
if (I == 0) if (i == 0)
saveBuffer(Buf[I], Config->OutputFile + ".lto.o"); saveBuffer(buf[i], config->outputFile + ".lto.o");
else else
saveBuffer(Buf[I], Config->OutputFile + Twine(I) + ".lto.o"); saveBuffer(buf[i], config->outputFile + Twine(i) + ".lto.o");
} }
Ret.emplace_back(Buf[I].data(), Buf[I].size()); ret.emplace_back(buf[i].data(), buf[i].size());
} }
for (std::unique_ptr<MemoryBuffer> &File : Files) for (std::unique_ptr<MemoryBuffer> &file : files)
if (File) if (file)
Ret.push_back(File->getBuffer()); ret.push_back(file->getBuffer());
return Ret; return ret;
} }

lld/trunk/wasm/MarkLive.cpp

Show All 26 Lines
#include "Symbols.h" #include "Symbols.h"
#define DEBUG_TYPE "lld" #define DEBUG_TYPE "lld"
using namespace llvm; using namespace llvm;
using namespace llvm::wasm; using namespace llvm::wasm;
void lld::wasm::markLive() { void lld::wasm::markLive() {
if (!Config->GcSections) if (!config->gcSections)
return; return;
LLVM_DEBUG(dbgs() << "markLive\n"); LLVM_DEBUG(dbgs() << "markLive\n");
SmallVector<InputChunk *, 256> Q; SmallVector<InputChunk *, 256> q;
std::function<void(Symbol*)> Enqueue = [&](Symbol *Sym) { std::function<void(Symbol*)> enqueue = [&](Symbol *sym) {
if (!Sym || Sym->isLive()) if (!sym || sym->isLive())
return; return;
LLVM_DEBUG(dbgs() << "markLive: " << Sym->getName() << "\n"); LLVM_DEBUG(dbgs() << "markLive: " << sym->getName() << "\n");
Sym->markLive(); sym->markLive();
if (InputChunk *Chunk = Sym->getChunk()) if (InputChunk *chunk = sym->getChunk())
Q.push_back(Chunk); q.push_back(chunk);
// The ctor functions are all referenced by the synthetic CallCtors // The ctor functions are all referenced by the synthetic CallCtors
// function. However, this function does not contain relocations so we // function. However, this function does not contain relocations so we
// have to manually mark the ctors as live if CallCtors itself is live. // have to manually mark the ctors as live if CallCtors itself is live.
if (Sym == WasmSym::CallCtors) { if (sym == WasmSym::callCtors) {
if (Config->PassiveSegments) if (config->passiveSegments)
Enqueue(WasmSym::InitMemory); enqueue(WasmSym::initMemory);
if (Config->Pic) if (config->isPic)
Enqueue(WasmSym::ApplyRelocs); enqueue(WasmSym::applyRelocs);
for (const ObjFile *Obj : Symtab->ObjectFiles) { for (const ObjFile *obj : symtab->objectFiles) {
const WasmLinkingData &L = Obj->getWasmObj()->linkingData(); const WasmLinkingData &l = obj->getWasmObj()->linkingData();
for (const WasmInitFunc &F : L.InitFunctions) { for (const WasmInitFunc &f : l.InitFunctions) {
auto* InitSym = Obj->getFunctionSymbol(F.Symbol); auto* initSym = obj->getFunctionSymbol(f.Symbol);
if (!InitSym->isDiscarded()) if (!initSym->isDiscarded())
Enqueue(InitSym); enqueue(initSym);
} }
} }
} }
}; };
// Add GC root symbols. // Add GC root symbols.
if (!Config->Entry.empty()) if (!config->entry.empty())
Enqueue(Symtab->find(Config->Entry)); enqueue(symtab->find(config->entry));
// We need to preserve any exported symbol // We need to preserve any exported symbol
for (Symbol *Sym : Symtab->getSymbols()) for (Symbol *sym : symtab->getSymbols())
if (Sym->isExported()) if (sym->isExported())
Enqueue(Sym); enqueue(sym);
// For relocatable output, we need to preserve all the ctor functions // For relocatable output, we need to preserve all the ctor functions
if (Config->Relocatable) { if (config->relocatable) {
for (const ObjFile *Obj : Symtab->ObjectFiles) { for (const ObjFile *obj : symtab->objectFiles) {
const WasmLinkingData &L = Obj->getWasmObj()->linkingData(); const WasmLinkingData &l = obj->getWasmObj()->linkingData();
for (const WasmInitFunc &F : L.InitFunctions) for (const WasmInitFunc &f : l.InitFunctions)
Enqueue(Obj->getFunctionSymbol(F.Symbol)); enqueue(obj->getFunctionSymbol(f.Symbol));
} }
} }
if (Config->Pic) if (config->isPic)
Enqueue(WasmSym::CallCtors); enqueue(WasmSym::callCtors);
// Follow relocations to mark all reachable chunks. // Follow relocations to mark all reachable chunks.
while (!Q.empty()) { while (!q.empty()) {
InputChunk *C = Q.pop_back_val(); InputChunk *c = q.pop_back_val();
for (const WasmRelocation Reloc : C->getRelocations()) { for (const WasmRelocation reloc : c->getRelocations()) {
if (Reloc.Type == R_WASM_TYPE_INDEX_LEB) if (reloc.Type == R_WASM_TYPE_INDEX_LEB)
continue; continue;
Symbol *Sym = C->File->getSymbol(Reloc.Index); Symbol *sym = c->file->getSymbol(reloc.Index);
// If the function has been assigned the special index zero in the table, // If the function has been assigned the special index zero in the table,
// the relocation doesn't pull in the function body, since the function // the relocation doesn't pull in the function body, since the function
// won't actually go in the table (the runtime will trap attempts to call // won't actually go in the table (the runtime will trap attempts to call
// that index, since we don't use it). A function with a table index of // that index, since we don't use it). A function with a table index of
// zero is only reachable via "call", not via "call_indirect". The stub // zero is only reachable via "call", not via "call_indirect". The stub
// functions used for weak-undefined symbols have this behaviour (compare // functions used for weak-undefined symbols have this behaviour (compare
// equal to null pointer, only reachable via direct call). // equal to null pointer, only reachable via direct call).
if (Reloc.Type == R_WASM_TABLE_INDEX_SLEB || if (reloc.Type == R_WASM_TABLE_INDEX_SLEB ||
Reloc.Type == R_WASM_TABLE_INDEX_I32) { reloc.Type == R_WASM_TABLE_INDEX_I32) {
auto *FuncSym = cast<FunctionSymbol>(Sym); auto *funcSym = cast<FunctionSymbol>(sym);
if (FuncSym->hasTableIndex() && FuncSym->getTableIndex() == 0) if (funcSym->hasTableIndex() && funcSym->getTableIndex() == 0)
continue; continue;
} }
Enqueue(Sym); enqueue(sym);
} }
} }
// Report garbage-collected sections. // Report garbage-collected sections.
if (Config->PrintGcSections) { if (config->printGcSections) {
for (const ObjFile *Obj : Symtab->ObjectFiles) { for (const ObjFile *obj : symtab->objectFiles) {
for (InputChunk *C : Obj->Functions) for (InputChunk *c : obj->functions)
if (!C->Live) if (!c->live)
message("removing unused section " + toString(C)); message("removing unused section " + toString(c));
for (InputChunk *C : Obj->Segments) for (InputChunk *c : obj->segments)
if (!C->Live) if (!c->live)
message("removing unused section " + toString(C)); message("removing unused section " + toString(c));
for (InputGlobal *G : Obj->Globals) for (InputGlobal *g : obj->globals)
if (!G->Live) if (!g->live)
message("removing unused section " + toString(G)); message("removing unused section " + toString(g));
for (InputEvent *E : Obj->Events) for (InputEvent *e : obj->events)
if (!E->Live) if (!e->live)
message("removing unused section " + toString(E)); message("removing unused section " + toString(e));
} }
for (InputChunk *C : Symtab->SyntheticFunctions) for (InputChunk *c : symtab->syntheticFunctions)
if (!C->Live) if (!c->live)
message("removing unused section " + toString(C)); message("removing unused section " + toString(c));
for (InputGlobal *G : Symtab->SyntheticGlobals) for (InputGlobal *g : symtab->syntheticGlobals)
if (!G->Live) if (!g->live)
message("removing unused section " + toString(G)); message("removing unused section " + toString(g));
} }
} }

lld/trunk/wasm/OutputSections.h

Show All 14 Lines
#include "lld/Common/LLVM.h" #include "lld/Common/LLVM.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
namespace lld { namespace lld {
namespace wasm { namespace wasm {
class OutputSection; class OutputSection;
} }
std::string toString(const wasm::OutputSection &Section); std::string toString(const wasm::OutputSection &section);
namespace wasm { namespace wasm {
class OutputSegment; class OutputSegment;
class OutputSection { class OutputSection {
public: public:
OutputSection(uint32_t Type, std::string Name = "") OutputSection(uint32_t type, std::string name = "")
: Type(Type), Name(Name) {} : type(type), name(name) {}
virtual ~OutputSection() = default; virtual ~OutputSection() = default;
StringRef getSectionName() const; StringRef getSectionName() const;
void setOffset(size_t NewOffset) { void setOffset(size_t newOffset) {
log("setOffset: " + toString(*this) + ": " + Twine(NewOffset)); log("setOffset: " + toString(*this) + ": " + Twine(newOffset));
Offset = NewOffset; offset = newOffset;
} }
void createHeader(size_t BodySize); void createHeader(size_t bodySize);
virtual bool isNeeded() const { return true; } virtual bool isNeeded() const { return true; }
virtual size_t getSize() const = 0; virtual size_t getSize() const = 0;
virtual void writeTo(uint8_t *Buf) = 0; virtual void writeTo(uint8_t *buf) = 0;
virtual void finalizeContents() = 0; virtual void finalizeContents() = 0;
virtual uint32_t getNumRelocations() const { return 0; } virtual uint32_t getNumRelocations() const { return 0; }
virtual void writeRelocations(raw_ostream &OS) const {} virtual void writeRelocations(raw_ostream &os) const {}
std::string Header; std::string header;
uint32_t Type; uint32_t type;
uint32_t SectionIndex = UINT32_MAX; uint32_t sectionIndex = UINT32_MAX;
std::string Name; std::string name;
OutputSectionSymbol *SectionSym = nullptr; OutputSectionSymbol *sectionSym = nullptr;
protected: protected:
size_t Offset = 0; size_t offset = 0;
}; };
class CodeSection : public OutputSection { class CodeSection : public OutputSection {
public: public:
explicit CodeSection(ArrayRef<InputFunction *> Functions) explicit CodeSection(ArrayRef<InputFunction *> functions)
: OutputSection(llvm::wasm::WASM_SEC_CODE), Functions(Functions) {} : OutputSection(llvm::wasm::WASM_SEC_CODE), functions(functions) {}
size_t getSize() const override { return Header.size() + BodySize; } size_t getSize() const override { return header.size() + bodySize; }
void writeTo(uint8_t *Buf) override; void writeTo(uint8_t *buf) override;
uint32_t getNumRelocations() const override; uint32_t getNumRelocations() const override;
void writeRelocations(raw_ostream &OS) const override; void writeRelocations(raw_ostream &os) const override;
bool isNeeded() const override { return Functions.size() > 0; } bool isNeeded() const override { return functions.size() > 0; }
void finalizeContents() override; void finalizeContents() override;
protected: protected:
ArrayRef<InputFunction *> Functions; ArrayRef<InputFunction *> functions;
std::string CodeSectionHeader; std::string codeSectionHeader;
size_t BodySize = 0; size_t bodySize = 0;
}; };
class DataSection : public OutputSection { class DataSection : public OutputSection {
public: public:
explicit DataSection(ArrayRef<OutputSegment *> Segments) explicit DataSection(ArrayRef<OutputSegment *> segments)
: OutputSection(llvm::wasm::WASM_SEC_DATA), Segments(Segments) {} : OutputSection(llvm::wasm::WASM_SEC_DATA), segments(segments) {}
size_t getSize() const override { return Header.size() + BodySize; } size_t getSize() const override { return header.size() + bodySize; }
void writeTo(uint8_t *Buf) override; void writeTo(uint8_t *buf) override;
uint32_t getNumRelocations() const override; uint32_t getNumRelocations() const override;
void writeRelocations(raw_ostream &OS) const override; void writeRelocations(raw_ostream &os) const override;
bool isNeeded() const override { return Segments.size() > 0; } bool isNeeded() const override { return segments.size() > 0; }
void finalizeContents() override; void finalizeContents() override;
protected: protected:
ArrayRef<OutputSegment *> Segments; ArrayRef<OutputSegment *> segments;
std::string DataSectionHeader; std::string dataSectionHeader;
size_t BodySize = 0; size_t bodySize = 0;
}; };
// Represents a custom section in the output file. Wasm custom sections are // Represents a custom section in the output file. Wasm custom sections are
// used for storing user-defined metadata. Unlike the core sections types // used for storing user-defined metadata. Unlike the core sections types
// they are identified by their string name. // they are identified by their string name.
// The linker combines custom sections that have the same name by simply // The linker combines custom sections that have the same name by simply
// concatenating them. // concatenating them.
// Note that some custom sections such as "name" and "linking" are handled // Note that some custom sections such as "name" and "linking" are handled
// separately and are instead synthesized by the linker. // separately and are instead synthesized by the linker.
class CustomSection : public OutputSection { class CustomSection : public OutputSection {
public: public:
CustomSection(std::string Name, ArrayRef<InputSection *> InputSections) CustomSection(std::string name, ArrayRef<InputSection *> inputSections)
: OutputSection(llvm::wasm::WASM_SEC_CUSTOM, Name), : OutputSection(llvm::wasm::WASM_SEC_CUSTOM, name),
InputSections(InputSections) {} inputSections(inputSections) {}
size_t getSize() const override { size_t getSize() const override {
return Header.size() + NameData.size() + PayloadSize; return header.size() + nameData.size() + payloadSize;
} }
void writeTo(uint8_t *Buf) override; void writeTo(uint8_t *buf) override;
uint32_t getNumRelocations() const override; uint32_t getNumRelocations() const override;
void writeRelocations(raw_ostream &OS) const override; void writeRelocations(raw_ostream &os) const override;
void finalizeContents() override; void finalizeContents() override;
protected: protected:
size_t PayloadSize = 0; size_t payloadSize = 0;
ArrayRef<InputSection *> InputSections; ArrayRef<InputSection *> inputSections;
std::string NameData; std::string nameData;
}; };
} // namespace wasm } // namespace wasm
} // namespace lld } // namespace lld
#endif // LLD_WASM_OUTPUT_SECTIONS_H #endif // LLD_WASM_OUTPUT_SECTIONS_H

lld/trunk/wasm/OutputSections.cpp

Show All 17 Lines
#define DEBUG_TYPE "lld" #define DEBUG_TYPE "lld"
using namespace llvm; using namespace llvm;
using namespace llvm::wasm; using namespace llvm::wasm;
using namespace lld; using namespace lld;
using namespace lld::wasm; using namespace lld::wasm;
static StringRef sectionTypeToString(uint32_t SectionType) { static StringRef sectionTypeToString(uint32_t sectionType) {
switch (SectionType) { switch (sectionType) {
case WASM_SEC_CUSTOM: case WASM_SEC_CUSTOM:
return "CUSTOM"; return "CUSTOM";
case WASM_SEC_TYPE: case WASM_SEC_TYPE:
return "TYPE"; return "TYPE";
case WASM_SEC_IMPORT: case WASM_SEC_IMPORT:
return "IMPORT"; return "IMPORT";
case WASM_SEC_FUNCTION: case WASM_SEC_FUNCTION:
return "FUNCTION"; return "FUNCTION";
Show All 18 Linesstatic StringRef sectionTypeToString(uint32_t sectionType) {
case WASM_SEC_DATACOUNT: case WASM_SEC_DATACOUNT:
return "DATACOUNT"; return "DATACOUNT";
default: default:
fatal("invalid section type"); fatal("invalid section type");
} }
} }
// Returns a string, e.g. "FUNCTION(.text)". // Returns a string, e.g. "FUNCTION(.text)".
std::string lld::toString(const OutputSection &Sec) { std::string lld::toString(const OutputSection &sec) {
if (!Sec.Name.empty()) if (!sec.name.empty())
return (Sec.getSectionName() + "(" + Sec.Name + ")").str(); return (sec.getSectionName() + "(" + sec.name + ")").str();
return Sec.getSectionName(); return sec.getSectionName();
} }
StringRef OutputSection::getSectionName() const { StringRef OutputSection::getSectionName() const {
return sectionTypeToString(Type); return sectionTypeToString(type);
} }
void OutputSection::createHeader(size_t BodySize) { void OutputSection::createHeader(size_t bodySize) {
raw_string_ostream OS(Header); raw_string_ostream os(header);
debugWrite(OS.tell(), "section type [" + getSectionName() + "]"); debugWrite(os.tell(), "section type [" + getSectionName() + "]");
encodeULEB128(Type, OS); encodeULEB128(type, os);
writeUleb128(OS, BodySize, "section size"); writeUleb128(os, bodySize, "section size");
OS.flush(); os.flush();
log("createHeader: " + toString(*this) + " body=" + Twine(BodySize) + log("createHeader: " + toString(*this) + " body=" + Twine(bodySize) +
" total=" + Twine(getSize())); " total=" + Twine(getSize()));
} }
void CodeSection::finalizeContents() { void CodeSection::finalizeContents() {
raw_string_ostream OS(CodeSectionHeader); raw_string_ostream os(codeSectionHeader);
writeUleb128(OS, Functions.size(), "function count"); writeUleb128(os, functions.size(), "function count");
OS.flush(); os.flush();
BodySize = CodeSectionHeader.size(); bodySize = codeSectionHeader.size();
for (InputFunction *Func : Functions) { for (InputFunction *func : functions) {
Func->OutputOffset = BodySize; func->outputOffset = bodySize;
Func->calculateSize(); func->calculateSize();
BodySize += Func->getSize(); bodySize += func->getSize();
} }
createHeader(BodySize); createHeader(bodySize);
} }
void CodeSection::writeTo(uint8_t *Buf) { void CodeSection::writeTo(uint8_t *buf) {
log("writing " + toString(*this)); log("writing " + toString(*this));
log(" size=" + Twine(getSize())); log(" size=" + Twine(getSize()));
log(" headersize=" + Twine(Header.size())); log(" headersize=" + Twine(header.size()));
log(" codeheadersize=" + Twine(CodeSectionHeader.size())); log(" codeheadersize=" + Twine(codeSectionHeader.size()));
Buf += Offset; buf += offset;
// Write section header // Write section header
memcpy(Buf, Header.data(), Header.size()); memcpy(buf, header.data(), header.size());
Buf += Header.size(); buf += header.size();
// Write code section headers // Write code section headers
memcpy(Buf, CodeSectionHeader.data(), CodeSectionHeader.size()); memcpy(buf, codeSectionHeader.data(), codeSectionHeader.size());
// Write code section bodies // Write code section bodies
for (const InputChunk *Chunk : Functions) for (const InputChunk *chunk : functions)
Chunk->writeTo(Buf); chunk->writeTo(buf);
} }
uint32_t CodeSection::getNumRelocations() const { uint32_t CodeSection::getNumRelocations() const {
uint32_t Count = 0; uint32_t count = 0;
for (const InputChunk *Func : Functions) for (const InputChunk *func : functions)
Count += Func->getNumRelocations(); count += func->getNumRelocations();
return Count; return count;
} }
void CodeSection::writeRelocations(raw_ostream &OS) const { void CodeSection::writeRelocations(raw_ostream &os) const {
for (const InputChunk *C : Functions) for (const InputChunk *c : functions)
C->writeRelocations(OS); c->writeRelocations(os);
} }
void DataSection::finalizeContents() { void DataSection::finalizeContents() {
raw_string_ostream OS(DataSectionHeader); raw_string_ostream os(dataSectionHeader);
writeUleb128(OS, Segments.size(), "data segment count"); writeUleb128(os, segments.size(), "data segment count");
OS.flush(); os.flush();
BodySize = DataSectionHeader.size(); bodySize = dataSectionHeader.size();
assert((!Config->Pic || Segments.size() <= 1) && assert((!config->isPic || segments.size() <= 1) &&
"Currenly only a single data segment is supported in PIC mode"); "Currenly only a single data segment is supported in PIC mode");
for (OutputSegment *Segment : Segments) { for (OutputSegment *segment : segments) {
raw_string_ostream OS(Segment->Header); raw_string_ostream os(segment->header);
writeUleb128(OS, Segment->InitFlags, "init flags"); writeUleb128(os, segment->initFlags, "init flags");
if (Segment->InitFlags & WASM_SEGMENT_HAS_MEMINDEX) if (segment->initFlags & WASM_SEGMENT_HAS_MEMINDEX)
writeUleb128(OS, 0, "memory index"); writeUleb128(os, 0, "memory index");
if ((Segment->InitFlags & WASM_SEGMENT_IS_PASSIVE) == 0) { if ((segment->initFlags & WASM_SEGMENT_IS_PASSIVE) == 0) {
WasmInitExpr InitExpr; WasmInitExpr initExpr;
if (Config->Pic) { if (config->isPic) {
InitExpr.Opcode = WASM_OPCODE_GLOBAL_GET; initExpr.Opcode = WASM_OPCODE_GLOBAL_GET;
InitExpr.Value.Global = WasmSym::MemoryBase->getGlobalIndex(); initExpr.Value.Global = WasmSym::memoryBase->getGlobalIndex();
} else { } else {
InitExpr.Opcode = WASM_OPCODE_I32_CONST; initExpr.Opcode = WASM_OPCODE_I32_CONST;
InitExpr.Value.Int32 = Segment->StartVA; initExpr.Value.Int32 = segment->startVA;
} }
writeInitExpr(OS, InitExpr); writeInitExpr(os, initExpr);
} }
writeUleb128(OS, Segment->Size, "segment size"); writeUleb128(os, segment->size, "segment size");
OS.flush(); os.flush();
Segment->SectionOffset = BodySize; segment->sectionOffset = bodySize;
BodySize += Segment->Header.size() + Segment->Size; bodySize += segment->header.size() + segment->size;
log("Data segment: size=" + Twine(Segment->Size) + ", startVA=" + log("Data segment: size=" + Twine(segment->size) + ", startVA=" +
Twine::utohexstr(Segment->StartVA) + ", name=" + Segment->Name); Twine::utohexstr(segment->startVA) + ", name=" + segment->name);
for (InputSegment *InputSeg : Segment->InputSegments) for (InputSegment *inputSeg : segment->inputSegments)
InputSeg->OutputOffset = Segment->SectionOffset + Segment->Header.size() + inputSeg->outputOffset = segment->sectionOffset + segment->header.size() +
InputSeg->OutputSegmentOffset; inputSeg->outputSegmentOffset;
} }
createHeader(BodySize); createHeader(bodySize);
} }
void DataSection::writeTo(uint8_t *Buf) { void DataSection::writeTo(uint8_t *buf) {
log("writing " + toString(*this) + " size=" + Twine(getSize()) + log("writing " + toString(*this) + " size=" + Twine(getSize()) +
" body=" + Twine(BodySize)); " body=" + Twine(bodySize));
Buf += Offset; buf += offset;
// Write section header // Write section header
memcpy(Buf, Header.data(), Header.size()); memcpy(buf, header.data(), header.size());
Buf += Header.size(); buf += header.size();
// Write data section headers // Write data section headers
memcpy(Buf, DataSectionHeader.data(), DataSectionHeader.size()); memcpy(buf, dataSectionHeader.data(), dataSectionHeader.size());
for (const OutputSegment *Segment : Segments) { for (const OutputSegment *segment : segments) {
// Write data segment header // Write data segment header
uint8_t *SegStart = Buf + Segment->SectionOffset; uint8_t *segStart = buf + segment->sectionOffset;
memcpy(SegStart, Segment->Header.data(), Segment->Header.size()); memcpy(segStart, segment->header.data(), segment->header.size());
// Write segment data payload // Write segment data payload
for (const InputChunk *Chunk : Segment->InputSegments) for (const InputChunk *chunk : segment->inputSegments)
Chunk->writeTo(Buf); chunk->writeTo(buf);
} }
} }
uint32_t DataSection::getNumRelocations() const { uint32_t DataSection::getNumRelocations() const {
uint32_t Count = 0; uint32_t count = 0;
for (const OutputSegment *Seg : Segments) for (const OutputSegment *seg : segments)
for (const InputChunk *InputSeg : Seg->InputSegments) for (const InputChunk *inputSeg : seg->inputSegments)
Count += InputSeg->getNumRelocations(); count += inputSeg->getNumRelocations();
return Count; return count;
} }
void DataSection::writeRelocations(raw_ostream &OS) const { void DataSection::writeRelocations(raw_ostream &os) const {
for (const OutputSegment *Seg : Segments) for (const OutputSegment *seg : segments)
for (const InputChunk *C : Seg->InputSegments) for (const InputChunk *c : seg->inputSegments)
C->writeRelocations(OS); c->writeRelocations(os);
} }
void CustomSection::finalizeContents() { void CustomSection::finalizeContents() {
raw_string_ostream OS(NameData); raw_string_ostream os(nameData);
encodeULEB128(Name.size(), OS); encodeULEB128(name.size(), os);
OS << Name; os << name;
OS.flush(); os.flush();
for (InputSection *Section : InputSections) { for (InputSection *section : inputSections) {
Section->OutputOffset = PayloadSize; section->outputOffset = payloadSize;
Section->OutputSec = this; section->outputSec = this;
PayloadSize += Section->getSize(); payloadSize += section->getSize();
} }
createHeader(PayloadSize + NameData.size()); createHeader(payloadSize + nameData.size());
} }
void CustomSection::writeTo(uint8_t *Buf) { void CustomSection::writeTo(uint8_t *buf) {
log("writing " + toString(*this) + " size=" + Twine(getSize()) + log("writing " + toString(*this) + " size=" + Twine(getSize()) +
" chunks=" + Twine(InputSections.size())); " chunks=" + Twine(inputSections.size()));
assert(Offset); assert(offset);
Buf += Offset; buf += offset;
// Write section header // Write section header
memcpy(Buf, Header.data(), Header.size()); memcpy(buf, header.data(), header.size());
Buf += Header.size(); buf += header.size();
memcpy(Buf, NameData.data(), NameData.size()); memcpy(buf, nameData.data(), nameData.size());
Buf += NameData.size(); buf += nameData.size();
// Write custom sections payload // Write custom sections payload
for (const InputSection *Section : InputSections) for (const InputSection *section : inputSections)
Section->writeTo(Buf); section->writeTo(buf);
} }
uint32_t CustomSection::getNumRelocations() const { uint32_t CustomSection::getNumRelocations() const {
uint32_t Count = 0; uint32_t count = 0;
for (const InputSection *InputSect : InputSections) for (const InputSection *inputSect : inputSections)
Count += InputSect->getNumRelocations(); count += inputSect->getNumRelocations();
return Count; return count;
} }
void CustomSection::writeRelocations(raw_ostream &OS) const { void CustomSection::writeRelocations(raw_ostream &os) const {
for (const InputSection *S : InputSections) for (const InputSection *s : inputSections)
S->writeRelocations(OS); s->writeRelocations(os);
} }

lld/trunk/wasm/OutputSegment.h

Show All 14 Lines
namespace lld { namespace lld {
namespace wasm { namespace wasm {
class InputSegment; class InputSegment;
class OutputSegment { class OutputSegment {
public: public:
OutputSegment(StringRef N, uint32_t Index) : Name(N), Index(Index) {} OutputSegment(StringRef n, uint32_t index) : name(n), index(index) {}
void addInputSegment(InputSegment *InSeg) { void addInputSegment(InputSegment *inSeg) {
Alignment = std::max(Alignment, InSeg->getAlignment()); alignment = std::max(alignment, inSeg->getAlignment());
InputSegments.push_back(InSeg); inputSegments.push_back(inSeg);
Size = llvm::alignTo(Size, 1ULL << InSeg->getAlignment()); size = llvm::alignTo(size, 1ULL << inSeg->getAlignment());
InSeg->OutputSeg = this; inSeg->outputSeg = this;
InSeg->OutputSegmentOffset = Size; inSeg->outputSegmentOffset = size;
Size += InSeg->getSize(); size += inSeg->getSize();
} }
StringRef Name; StringRef name;
const uint32_t Index; const uint32_t index;
uint32_t InitFlags = 0; uint32_t initFlags = 0;
uint32_t SectionOffset = 0; uint32_t sectionOffset = 0;
uint32_t Alignment = 0; uint32_t alignment = 0;
uint32_t StartVA = 0; uint32_t startVA = 0;
std::vector<InputSegment *> InputSegments; std::vector<InputSegment *> inputSegments;
// Sum of the size of the all the input segments // Sum of the size of the all the input segments
uint32_t Size = 0; uint32_t size = 0;
// Segment header // Segment header
std::string Header; std::string header;
}; };
} // namespace wasm } // namespace wasm
} // namespace lld } // namespace lld
#endif // LLD_WASM_OUTPUT_SEGMENT_H #endif // LLD_WASM_OUTPUT_SEGMENT_H

lld/trunk/wasm/Relocations.h

//===- Relocations.h -------------------------------------------*- C++ -*-===// //===- Relocations.h -------------------------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLD_WASM_RELOCATIONS_H #ifndef LLD_WASM_RELOCATIONS_H
#define LLD_WASM_RELOCATIONS_H #define LLD_WASM_RELOCATIONS_H
namespace lld { namespace lld {
namespace wasm { namespace wasm {
class InputChunk; class InputChunk;
void scanRelocations(InputChunk *Chunk); void scanRelocations(InputChunk *chunk);
} // namespace wasm } // namespace wasm
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/wasm/Relocations.cpp

Show All 11 Lines
#include "SyntheticSections.h" #include "SyntheticSections.h"
using namespace llvm; using namespace llvm;
using namespace llvm::wasm; using namespace llvm::wasm;
using namespace lld; using namespace lld;
using namespace lld::wasm; using namespace lld::wasm;
static bool requiresGOTAccess(const Symbol *Sym) { static bool requiresGOTAccess(const Symbol *sym) {
return Config->Pic && !Sym->isHidden() && !Sym->isLocal(); return config->isPic && !sym->isHidden() && !sym->isLocal();
} }
static bool allowUndefined(const Symbol* Sym) { static bool allowUndefined(const Symbol* sym) {
// Historically --allow-undefined doesn't work for data symbols since we don't // Historically --allow-undefined doesn't work for data symbols since we don't
// have any way to represent these as imports in the final binary. The idea // have any way to represent these as imports in the final binary. The idea
// behind allowing undefined symbols is to allow importing these symbols from // behind allowing undefined symbols is to allow importing these symbols from
// the embedder and we can't do this for data symbols (at least not without // the embedder and we can't do this for data symbols (at least not without
// compiling with -fPIC) // compiling with -fPIC)
if (isa<DataSymbol>(Sym)) if (isa<DataSymbol>(sym))
return false; return false;
return (Config->AllowUndefined || return (config->allowUndefined ||
Config->AllowUndefinedSymbols.count(Sym->getName()) != 0); config->allowUndefinedSymbols.count(sym->getName()) != 0);
} }
static void reportUndefined(const Symbol* Sym) { static void reportUndefined(const Symbol* sym) {
assert(Sym->isUndefined()); assert(sym->isUndefined());
assert(!Sym->isWeak()); assert(!sym->isWeak());
if (!allowUndefined(Sym)) if (!allowUndefined(sym))
error(toString(Sym->getFile()) + ": undefined symbol: " + toString(*Sym)); error(toString(sym->getFile()) + ": undefined symbol: " + toString(*sym));
} }
void lld::wasm::scanRelocations(InputChunk *Chunk) { void lld::wasm::scanRelocations(InputChunk *chunk) {
if (!Chunk->Live) if (!chunk->live)
return; return;
ObjFile *File = Chunk->File; ObjFile *file = chunk->file;
ArrayRef<WasmSignature> Types = File->getWasmObj()->types(); ArrayRef<WasmSignature> types = file->getWasmObj()->types();
for (const WasmRelocation &Reloc : Chunk->getRelocations()) { for (const WasmRelocation &reloc : chunk->getRelocations()) {
if (Reloc.Type == R_WASM_TYPE_INDEX_LEB) { if (reloc.Type == R_WASM_TYPE_INDEX_LEB) {
// Mark target type as live // Mark target type as live
File->TypeMap[Reloc.Index] = file->typeMap[reloc.Index] =
Out.TypeSec->registerType(Types[Reloc.Index]); out.typeSec->registerType(types[reloc.Index]);
File->TypeIsUsed[Reloc.Index] = true; file->typeIsUsed[reloc.Index] = true;
continue; continue;
} }
// Other relocation types all have a corresponding symbol // Other relocation types all have a corresponding symbol
Symbol *Sym = File->getSymbols()[Reloc.Index]; Symbol *sym = file->getSymbols()[reloc.Index];
switch (Reloc.Type) { switch (reloc.Type) {
case R_WASM_TABLE_INDEX_I32: case R_WASM_TABLE_INDEX_I32:
case R_WASM_TABLE_INDEX_SLEB: case R_WASM_TABLE_INDEX_SLEB:
case R_WASM_TABLE_INDEX_REL_SLEB: case R_WASM_TABLE_INDEX_REL_SLEB:
if (requiresGOTAccess(Sym)) if (requiresGOTAccess(sym))
break; break;
Out.ElemSec->addEntry(cast<FunctionSymbol>(Sym)); out.elemSec->addEntry(cast<FunctionSymbol>(sym));
break; break;
case R_WASM_GLOBAL_INDEX_LEB: case R_WASM_GLOBAL_INDEX_LEB:
if (!isa<GlobalSymbol>(Sym)) if (!isa<GlobalSymbol>(sym))
Out.ImportSec->addGOTEntry(Sym); out.importSec->addGOTEntry(sym);
break; break;
} }
if (Config->Pic) { if (config->isPic) {
switch (Reloc.Type) { switch (reloc.Type) {
case R_WASM_TABLE_INDEX_SLEB: case R_WASM_TABLE_INDEX_SLEB:
case R_WASM_MEMORY_ADDR_SLEB: case R_WASM_MEMORY_ADDR_SLEB:
case R_WASM_MEMORY_ADDR_LEB: case R_WASM_MEMORY_ADDR_LEB:
// Certain relocation types can't be used when building PIC output, // Certain relocation types can't be used when building PIC output,
// since they would require absolute symbol addresses at link time. // since they would require absolute symbol addresses at link time.
error(toString(File) + ": relocation " + relocTypeToString(Reloc.Type) + error(toString(file) + ": relocation " + relocTypeToString(reloc.Type) +
" cannot be used against symbol " + toString(*Sym) + " cannot be used against symbol " + toString(*sym) +
"; recompile with -fPIC"); "; recompile with -fPIC");
break; break;
case R_WASM_TABLE_INDEX_I32: case R_WASM_TABLE_INDEX_I32:
case R_WASM_MEMORY_ADDR_I32: case R_WASM_MEMORY_ADDR_I32:
// These relocation types are only present in the data section and // These relocation types are only present in the data section and
// will be converted into code by `generateRelocationCode`. This code // will be converted into code by `generateRelocationCode`. This code
// requires the symbols to have GOT entires. // requires the symbols to have GOT entires.
if (requiresGOTAccess(Sym)) if (requiresGOTAccess(sym))
Out.ImportSec->addGOTEntry(Sym); out.importSec->addGOTEntry(sym);
break; break;
} }
} else { } else {
// Report undefined symbols // Report undefined symbols
if (Sym->isUndefined() && !Config->Relocatable && !Sym->isWeak()) if (sym->isUndefined() && !config->relocatable && !sym->isWeak())
reportUndefined(Sym); reportUndefined(sym);
} }
} }
} }

lld/trunk/wasm/SymbolTable.h

Show All 29 Lines
// conflicts. For example, obviously, a defined symbol is better than // conflicts. For example, obviously, a defined symbol is better than
// an undefined symbol. Or, if there's a conflict between a lazy and a // an undefined symbol. Or, if there's a conflict between a lazy and a
// undefined, it'll read an archive member to read a real definition // undefined, it'll read an archive member to read a real definition
// to replace the lazy symbol. The logic is implemented in the // to replace the lazy symbol. The logic is implemented in the
// add*() functions, which are called by input files as they are parsed. // add*() functions, which are called by input files as they are parsed.
// There is one add* function per symbol type. // There is one add* function per symbol type.
class SymbolTable { class SymbolTable {
public: public:
void wrap(Symbol *Sym, Symbol *Real, Symbol *Wrap); void wrap(Symbol *sym, Symbol *real, Symbol *wrap);
void addFile(InputFile *File); void addFile(InputFile *file);
void addCombinedLTOObject(); void addCombinedLTOObject();
ArrayRef<Symbol *> getSymbols() const { return SymVector; } ArrayRef<Symbol *> getSymbols() const { return symVector; }
Symbol *find(StringRef Name); Symbol *find(StringRef name);
void replace(StringRef Name, Symbol* Sym); void replace(StringRef name, Symbol* sym);
void trace(StringRef Name); void trace(StringRef name);
Symbol *addDefinedFunction(StringRef Name, uint32_t Flags, InputFile *File, Symbol *addDefinedFunction(StringRef name, uint32_t flags, InputFile *file,
InputFunction *Function); InputFunction *function);
Symbol *addDefinedData(StringRef Name, uint32_t Flags, InputFile *File, Symbol *addDefinedData(StringRef name, uint32_t flags, InputFile *file,
InputSegment *Segment, uint32_t Address, InputSegment *segment, uint32_t address,
uint32_t Size); uint32_t size);
Symbol *addDefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File, Symbol *addDefinedGlobal(StringRef name, uint32_t flags, InputFile *file,
InputGlobal *G); InputGlobal *g);
Symbol *addDefinedEvent(StringRef Name, uint32_t Flags, InputFile *File, Symbol *addDefinedEvent(StringRef name, uint32_t flags, InputFile *file,
InputEvent *E); InputEvent *e);
Symbol *addUndefinedFunction(StringRef Name, StringRef ImportName, Symbol *addUndefinedFunction(StringRef name, StringRef importName,
StringRef ImportModule, uint32_t Flags, StringRef importModule, uint32_t flags,
InputFile *File, const WasmSignature *Signature, InputFile *file, const WasmSignature *signature,
bool IsCalledDirectly); bool isCalledDirectly);
Symbol *addUndefinedData(StringRef Name, uint32_t Flags, InputFile *File); Symbol *addUndefinedData(StringRef name, uint32_t flags, InputFile *file);
Symbol *addUndefinedGlobal(StringRef Name, StringRef ImportName, Symbol *addUndefinedGlobal(StringRef name, StringRef importName,
StringRef ImportModule, uint32_t Flags, StringRef importModule, uint32_t flags,
InputFile *File, const WasmGlobalType *Type); InputFile *file, const WasmGlobalType *type);
void addLazy(ArchiveFile *F, const llvm::object::Archive::Symbol *Sym); void addLazy(ArchiveFile *f, const llvm::object::Archive::Symbol *sym);
bool addComdat(StringRef Name); bool addComdat(StringRef name);
DefinedData *addSyntheticDataSymbol(StringRef Name, uint32_t Flags); DefinedData *addSyntheticDataSymbol(StringRef name, uint32_t flags);
DefinedGlobal *addSyntheticGlobal(StringRef Name, uint32_t Flags, DefinedGlobal *addSyntheticGlobal(StringRef name, uint32_t flags,
InputGlobal *Global); InputGlobal *global);
DefinedFunction *addSyntheticFunction(StringRef Name, uint32_t Flags, DefinedFunction *addSyntheticFunction(StringRef name, uint32_t flags,
InputFunction *Function); InputFunction *function);
DefinedData *addOptionalDataSymbol(StringRef Name, uint32_t Value = 0, DefinedData *addOptionalDataSymbol(StringRef name, uint32_t value = 0,
uint32_t Flags = 0); uint32_t flags = 0);
void handleSymbolVariants(); void handleSymbolVariants();
void handleWeakUndefines(); void handleWeakUndefines();
std::vector<ObjFile *> ObjectFiles; std::vector<ObjFile *> objectFiles;
std::vector<SharedFile *> SharedFiles; std::vector<SharedFile *> sharedFiles;
std::vector<BitcodeFile *> BitcodeFiles; std::vector<BitcodeFile *> bitcodeFiles;
std::vector<InputFunction *> SyntheticFunctions; std::vector<InputFunction *> syntheticFunctions;
std::vector<InputGlobal *> SyntheticGlobals; std::vector<InputGlobal *> syntheticGlobals;
private: private:
std::pair<Symbol *, bool> insert(StringRef Name, const InputFile *File); std::pair<Symbol *, bool> insert(StringRef name, const InputFile *file);
std::pair<Symbol *, bool> insertName(StringRef Name); std::pair<Symbol *, bool> insertName(StringRef name);
bool getFunctionVariant(Symbol* Sym, const WasmSignature *Sig, bool getFunctionVariant(Symbol* sym, const WasmSignature *sig,
const InputFile *File, Symbol **Out); const InputFile *file, Symbol **out);
InputFunction *replaceWithUnreachable(Symbol *Sym, const WasmSignature &Sig, InputFunction *replaceWithUnreachable(Symbol *sym, const WasmSignature &sig,
StringRef DebugName); StringRef debugName);
// Maps symbol names to index into the SymVector. -1 means that symbols // Maps symbol names to index into the SymVector. -1 means that symbols
// is to not yet in the vector but it should have tracing enabled if it is // is to not yet in the vector but it should have tracing enabled if it is
// ever added. // ever added.
llvm::DenseMap<llvm::CachedHashStringRef, int> SymMap; llvm::DenseMap<llvm::CachedHashStringRef, int> symMap;
std::vector<Symbol *> SymVector; std::vector<Symbol *> symVector;
// For certain symbols types, e.g. function symbols, we allow for muliple // For certain symbols types, e.g. function symbols, we allow for muliple
// variants of the same symbol with different signatures. // variants of the same symbol with different signatures.
llvm::DenseMap<llvm::CachedHashStringRef, std::vector<Symbol *>> SymVariants; llvm::DenseMap<llvm::CachedHashStringRef, std::vector<Symbol *>> symVariants;
// Comdat groups define "link once" sections. If two comdat groups have the // Comdat groups define "link once" sections. If two comdat groups have the
// same name, only one of them is linked, and the other is ignored. This set // same name, only one of them is linked, and the other is ignored. This set
// is used to uniquify them. // is used to uniquify them.
llvm::DenseSet<llvm::CachedHashStringRef> ComdatGroups; llvm::DenseSet<llvm::CachedHashStringRef> comdatGroups;
// For LTO. // For LTO.
std::unique_ptr<BitcodeCompiler> LTO; std::unique_ptr<BitcodeCompiler> lto;
}; };
extern SymbolTable *Symtab; extern SymbolTable *symtab;
} // namespace wasm } // namespace wasm
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/wasm/SymbolTable.cpp

Show All 18 Lines
#define DEBUG_TYPE "lld" #define DEBUG_TYPE "lld"
using namespace llvm; using namespace llvm;
using namespace llvm::wasm; using namespace llvm::wasm;
using namespace llvm::object; using namespace llvm::object;
using namespace lld; using namespace lld;
using namespace lld::wasm; using namespace lld::wasm;
SymbolTable *lld::wasm::Symtab; SymbolTable *lld::wasm::symtab;
void SymbolTable::addFile(InputFile *File) { void SymbolTable::addFile(InputFile *file) {
log("Processing: " + toString(File)); log("Processing: " + toString(file));
// .a file // .a file
if (auto *F = dyn_cast<ArchiveFile>(File)) { if (auto *f = dyn_cast<ArchiveFile>(file)) {
F->parse(); f->parse();
return; return;
} }
// .so file // .so file
if (auto *F = dyn_cast<SharedFile>(File)) { if (auto *f = dyn_cast<SharedFile>(file)) {
SharedFiles.push_back(F); sharedFiles.push_back(f);
return; return;
} }
if (Config->Trace) if (config->trace)
message(toString(File)); message(toString(file));
// LLVM bitcode file // LLVM bitcode file
if (auto *F = dyn_cast<BitcodeFile>(File)) { if (auto *f = dyn_cast<BitcodeFile>(file)) {
F->parse(); f->parse();
BitcodeFiles.push_back(F); bitcodeFiles.push_back(f);
return; return;
} }
// Regular object file // Regular object file
auto *F = cast<ObjFile>(File); auto *f = cast<ObjFile>(file);
F->parse(false); f->parse(false);
ObjectFiles.push_back(F); objectFiles.push_back(f);
} }
// This function is where all the optimizations of link-time // This function is where all the optimizations of link-time
// optimization happens. When LTO is in use, some input files are // optimization happens. When LTO is in use, some input files are
// not in native object file format but in the LLVM bitcode format. // not in native object file format but in the LLVM bitcode format.
// This function compiles bitcode files into a few big native files // This function compiles bitcode files into a few big native files
// using LLVM functions and replaces bitcode symbols with the results. // using LLVM functions and replaces bitcode symbols with the results.
// Because all bitcode files that the program consists of are passed // Because all bitcode files that the program consists of are passed
// to the compiler at once, it can do whole-program optimization. // to the compiler at once, it can do whole-program optimization.
void SymbolTable::addCombinedLTOObject() { void SymbolTable::addCombinedLTOObject() {
if (BitcodeFiles.empty()) if (bitcodeFiles.empty())
return; return;
// Compile bitcode files and replace bitcode symbols. // Compile bitcode files and replace bitcode symbols.
LTO.reset(new BitcodeCompiler); lto.reset(new BitcodeCompiler);
for (BitcodeFile *F : BitcodeFiles) for (BitcodeFile *f : bitcodeFiles)
LTO->add(*F); lto->add(*f);
for (StringRef Filename : LTO->compile()) { for (StringRef filename : lto->compile()) {
auto *Obj = make<ObjFile>(MemoryBufferRef(Filename, "lto.tmp"), ""); auto *obj = make<ObjFile>(MemoryBufferRef(filename, "lto.tmp"), "");
Obj->parse(true); obj->parse(true);
ObjectFiles.push_back(Obj); objectFiles.push_back(obj);
} }
} }
Symbol *SymbolTable::find(StringRef Name) { Symbol *SymbolTable::find(StringRef name) {
auto It = SymMap.find(CachedHashStringRef(Name)); auto it = symMap.find(CachedHashStringRef(name));
if (It == SymMap.end() || It->second == -1) if (it == symMap.end() || it->second == -1)
return nullptr; return nullptr;
return SymVector[It->second]; return symVector[it->second];
} }
void SymbolTable::replace(StringRef Name, Symbol* Sym) { void SymbolTable::replace(StringRef name, Symbol* sym) {
auto It = SymMap.find(CachedHashStringRef(Name)); auto it = symMap.find(CachedHashStringRef(name));
SymVector[It->second] = Sym; symVector[it->second] = sym;
} }
std::pair<Symbol *, bool> SymbolTable::insertName(StringRef Name) { std::pair<Symbol *, bool> SymbolTable::insertName(StringRef name) {
bool Trace = false; bool trace = false;
auto P = SymMap.insert({CachedHashStringRef(Name), (int)SymVector.size()}); auto p = symMap.insert({CachedHashStringRef(name), (int)symVector.size()});
int &SymIndex = P.first->second; int &symIndex = p.first->second;
bool IsNew = P.second; bool isNew = p.second;
if (SymIndex == -1) { if (symIndex == -1) {
SymIndex = SymVector.size(); symIndex = symVector.size();
Trace = true; trace = true;
IsNew = true; isNew = true;
} }
if (!IsNew) if (!isNew)
return {SymVector[SymIndex], false}; return {symVector[symIndex], false};
Symbol *Sym = reinterpret_cast<Symbol *>(make<SymbolUnion>()); Symbol *sym = reinterpret_cast<Symbol *>(make<SymbolUnion>());
Sym->IsUsedInRegularObj = false; sym->isUsedInRegularObj = false;
Sym->CanInline = true; sym->canInline = true;
Sym->Traced = Trace; sym->traced = trace;
SymVector.emplace_back(Sym); symVector.emplace_back(sym);
return {Sym, true}; return {sym, true};
} }
std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name, std::pair<Symbol *, bool> SymbolTable::insert(StringRef name,
const InputFile *File) { const InputFile *file) {
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insertName(Name); std::tie(s, wasInserted) = insertName(name);
if (!File || File->kind() == InputFile::ObjectKind) if (!file || file->kind() == InputFile::ObjectKind)
S->IsUsedInRegularObj = true; s->isUsedInRegularObj = true;
return {S, WasInserted}; return {s, wasInserted};
} }
static void reportTypeError(const Symbol *Existing, const InputFile *File, static void reportTypeError(const Symbol *existing, const InputFile *file,
llvm::wasm::WasmSymbolType Type) { llvm::wasm::WasmSymbolType type) {
error("symbol type mismatch: " + toString(*Existing) + "\n>>> defined as " + error("symbol type mismatch: " + toString(*existing) + "\n>>> defined as " +
toString(Existing->getWasmType()) + " in " + toString(existing->getWasmType()) + " in " +
toString(Existing->getFile()) + "\n>>> defined as " + toString(Type) + toString(existing->getFile()) + "\n>>> defined as " + toString(type) +
" in " + toString(File)); " in " + toString(file));
} }
// Check the type of new symbol matches that of the symbol is replacing. // Check the type of new symbol matches that of the symbol is replacing.
// Returns true if the function types match, false is there is a singature // Returns true if the function types match, false is there is a singature
// mismatch. // mismatch.
static bool signatureMatches(FunctionSymbol *Existing, static bool signatureMatches(FunctionSymbol *existing,
const WasmSignature *NewSig) { const WasmSignature *newSig) {
const WasmSignature *OldSig = Existing->Signature; const WasmSignature *oldSig = existing->signature;
// If either function is missing a signature (this happend for bitcode // If either function is missing a signature (this happend for bitcode
// symbols) then assume they match. Any mismatch will be reported later // symbols) then assume they match. Any mismatch will be reported later
// when the LTO objects are added. // when the LTO objects are added.
if (!NewSig || !OldSig) if (!newSig || !oldSig)
return true; return true;
return *NewSig == *OldSig; return *newSig == *oldSig;
} }
static void checkGlobalType(const Symbol *Existing, const InputFile *File, static void checkGlobalType(const Symbol *existing, const InputFile *file,
const WasmGlobalType *NewType) { const WasmGlobalType *newType) {
if (!isa<GlobalSymbol>(Existing)) { if (!isa<GlobalSymbol>(existing)) {
reportTypeError(Existing, File, WASM_SYMBOL_TYPE_GLOBAL); reportTypeError(existing, file, WASM_SYMBOL_TYPE_GLOBAL);
return; return;
} }
const WasmGlobalType *OldType = cast<GlobalSymbol>(Existing)->getGlobalType(); const WasmGlobalType *oldType = cast<GlobalSymbol>(existing)->getGlobalType();
if (*NewType != *OldType) { if (*newType != *oldType) {
error("Global type mismatch: " + Existing->getName() + "\n>>> defined as " + error("Global type mismatch: " + existing->getName() + "\n>>> defined as " +
toString(*OldType) + " in " + toString(Existing->getFile()) + toString(*oldType) + " in " + toString(existing->getFile()) +
"\n>>> defined as " + toString(*NewType) + " in " + toString(File)); "\n>>> defined as " + toString(*newType) + " in " + toString(file));
} }
} }
static void checkEventType(const Symbol *Existing, const InputFile *File, static void checkEventType(const Symbol *existing, const InputFile *file,
const WasmEventType *NewType, const WasmEventType *newType,
const WasmSignature *NewSig) { const WasmSignature *newSig) {
auto ExistingEvent = dyn_cast<EventSymbol>(Existing); auto existingEvent = dyn_cast<EventSymbol>(existing);
if (!isa<EventSymbol>(Existing)) { if (!isa<EventSymbol>(existing)) {
reportTypeError(Existing, File, WASM_SYMBOL_TYPE_EVENT); reportTypeError(existing, file, WASM_SYMBOL_TYPE_EVENT);
return; return;
} }
const WasmEventType *OldType = cast<EventSymbol>(Existing)->getEventType(); const WasmEventType *oldType = cast<EventSymbol>(existing)->getEventType();
const WasmSignature *OldSig = ExistingEvent->Signature; const WasmSignature *oldSig = existingEvent->signature;
if (NewType->Attribute != OldType->Attribute) if (newType->Attribute != oldType->Attribute)
error("Event type mismatch: " + Existing->getName() + "\n>>> defined as " + error("Event type mismatch: " + existing->getName() + "\n>>> defined as " +
toString(*OldType) + " in " + toString(Existing->getFile()) + toString(*oldType) + " in " + toString(existing->getFile()) +
"\n>>> defined as " + toString(*NewType) + " in " + toString(File)); "\n>>> defined as " + toString(*newType) + " in " + toString(file));
if (*NewSig != *OldSig) if (*newSig != *oldSig)
warn("Event signature mismatch: " + Existing->getName() + warn("Event signature mismatch: " + existing->getName() +
"\n>>> defined as " + toString(*OldSig) + " in " + "\n>>> defined as " + toString(*oldSig) + " in " +
toString(Existing->getFile()) + "\n>>> defined as " + toString(existing->getFile()) + "\n>>> defined as " +
toString(*NewSig) + " in " + toString(File)); toString(*newSig) + " in " + toString(file));
} }
static void checkDataType(const Symbol *Existing, const InputFile *File) { static void checkDataType(const Symbol *existing, const InputFile *file) {
if (!isa<DataSymbol>(Existing)) if (!isa<DataSymbol>(existing))
reportTypeError(Existing, File, WASM_SYMBOL_TYPE_DATA); reportTypeError(existing, file, WASM_SYMBOL_TYPE_DATA);
} }
DefinedFunction *SymbolTable::addSyntheticFunction(StringRef Name, DefinedFunction *SymbolTable::addSyntheticFunction(StringRef name,
uint32_t Flags, uint32_t flags,
InputFunction *Function) { InputFunction *function) {
LLVM_DEBUG(dbgs() << "addSyntheticFunction: " << Name << "\n"); LLVM_DEBUG(dbgs() << "addSyntheticFunction: " << name << "\n");
assert(!find(Name)); assert(!find(name));
SyntheticFunctions.emplace_back(Function); syntheticFunctions.emplace_back(function);
return replaceSymbol<DefinedFunction>(insertName(Name).first, Name, return replaceSymbol<DefinedFunction>(insertName(name).first, name,
Flags, nullptr, Function); flags, nullptr, function);
} }
// Adds an optional, linker generated, data symbols. The symbol will only be // Adds an optional, linker generated, data symbols. The symbol will only be
// added if there is an undefine reference to it, or if it is explictly exported // added if there is an undefine reference to it, or if it is explictly exported
// via the --export flag. Otherwise we don't add the symbol and return nullptr. // via the --export flag. Otherwise we don't add the symbol and return nullptr.
DefinedData *SymbolTable::addOptionalDataSymbol(StringRef Name, uint32_t Value, DefinedData *SymbolTable::addOptionalDataSymbol(StringRef name, uint32_t value,
uint32_t Flags) { uint32_t flags) {
Symbol *S = find(Name); Symbol *s = find(name);
if (!S && (Config->ExportAll || Config->ExportedSymbols.count(Name) != 0)) if (!s && (config->exportAll || config->exportedSymbols.count(name) != 0))
S = insertName(Name).first; s = insertName(name).first;
else if (!S || S->isDefined()) else if (!s || s->isDefined())
return nullptr; return nullptr;
LLVM_DEBUG(dbgs() << "addOptionalDataSymbol: " << Name << "\n"); LLVM_DEBUG(dbgs() << "addOptionalDataSymbol: " << name << "\n");
auto *rtn = replaceSymbol<DefinedData>(S, Name, Flags); auto *rtn = replaceSymbol<DefinedData>(s, name, flags);
rtn->setVirtualAddress(Value); rtn->setVirtualAddress(value);
rtn->Referenced = true; rtn->referenced = true;
return rtn; return rtn;
} }
DefinedData *SymbolTable::addSyntheticDataSymbol(StringRef Name, DefinedData *SymbolTable::addSyntheticDataSymbol(StringRef name,
uint32_t Flags) { uint32_t flags) {
LLVM_DEBUG(dbgs() << "addSyntheticDataSymbol: " << Name << "\n"); LLVM_DEBUG(dbgs() << "addSyntheticDataSymbol: " << name << "\n");
assert(!find(Name)); assert(!find(name));
return replaceSymbol<DefinedData>(insertName(Name).first, Name, Flags); return replaceSymbol<DefinedData>(insertName(name).first, name, flags);
} }
DefinedGlobal *SymbolTable::addSyntheticGlobal(StringRef Name, uint32_t Flags, DefinedGlobal *SymbolTable::addSyntheticGlobal(StringRef name, uint32_t flags,
InputGlobal *Global) { InputGlobal *global) {
LLVM_DEBUG(dbgs() << "addSyntheticGlobal: " << Name << " -> " << Global LLVM_DEBUG(dbgs() << "addSyntheticGlobal: " << name << " -> " << global
<< "\n"); << "\n");
assert(!find(Name)); assert(!find(name));
SyntheticGlobals.emplace_back(Global); syntheticGlobals.emplace_back(global);
return replaceSymbol<DefinedGlobal>(insertName(Name).first, Name, Flags, return replaceSymbol<DefinedGlobal>(insertName(name).first, name, flags,
nullptr, Global); nullptr, global);
} }
static bool shouldReplace(const Symbol *Existing, InputFile *NewFile, static bool shouldReplace(const Symbol *existing, InputFile *newFile,
uint32_t NewFlags) { uint32_t newFlags) {
// If existing symbol is undefined, replace it. // If existing symbol is undefined, replace it.
if (!Existing->isDefined()) { if (!existing->isDefined()) {
LLVM_DEBUG(dbgs() << "resolving existing undefined symbol: " LLVM_DEBUG(dbgs() << "resolving existing undefined symbol: "
<< Existing->getName() << "\n"); << existing->getName() << "\n");
return true; return true;
} }
// Now we have two defined symbols. If the new one is weak, we can ignore it. // Now we have two defined symbols. If the new one is weak, we can ignore it.
if ((NewFlags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK) { if ((newFlags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK) {
LLVM_DEBUG(dbgs() << "existing symbol takes precedence\n"); LLVM_DEBUG(dbgs() << "existing symbol takes precedence\n");
return false; return false;
} }
// If the existing symbol is weak, we should replace it. // If the existing symbol is weak, we should replace it.
if (Existing->isWeak()) { if (existing->isWeak()) {
LLVM_DEBUG(dbgs() << "replacing existing weak symbol\n"); LLVM_DEBUG(dbgs() << "replacing existing weak symbol\n");
return true; return true;
} }
// Neither symbol is week. They conflict. // Neither symbol is week. They conflict.
error("duplicate symbol: " + toString(*Existing) + "\n>>> defined in " + error("duplicate symbol: " + toString(*existing) + "\n>>> defined in " +
toString(Existing->getFile()) + "\n>>> defined in " + toString(existing->getFile()) + "\n>>> defined in " +
toString(NewFile)); toString(newFile));
return true; return true;
} }
Symbol *SymbolTable::addDefinedFunction(StringRef Name, uint32_t Flags, Symbol *SymbolTable::addDefinedFunction(StringRef name, uint32_t flags,
InputFile *File, InputFile *file,
InputFunction *Function) { InputFunction *function) {
LLVM_DEBUG(dbgs() << "addDefinedFunction: " << Name << " [" LLVM_DEBUG(dbgs() << "addDefinedFunction: " << name << " ["
<< (Function ? toString(Function->Signature) : "none") << (function ? toString(function->signature) : "none")
<< "]\n"); << "]\n");
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(Name, File); std::tie(s, wasInserted) = insert(name, file);
auto ReplaceSym = [&](Symbol *Sym) { auto replaceSym = [&](Symbol *sym) {
// If the new defined function doesn't have signture (i.e. bitcode // If the new defined function doesn't have signture (i.e. bitcode
// functions) but the old symbol does, then preserve the old signature // functions) but the old symbol does, then preserve the old signature
const WasmSignature *OldSig = S->getSignature(); const WasmSignature *oldSig = s->getSignature();
auto* NewSym = replaceSymbol<DefinedFunction>(Sym, Name, Flags, File, Function); auto* newSym = replaceSymbol<DefinedFunction>(sym, name, flags, file, function);
if (!NewSym->Signature) if (!newSym->signature)
NewSym->Signature = OldSig; newSym->signature = oldSig;
}; };
if (WasInserted || S->isLazy()) { if (wasInserted || s->isLazy()) {
ReplaceSym(S); replaceSym(s);
return S; return s;
} }
auto ExistingFunction = dyn_cast<FunctionSymbol>(S); auto existingFunction = dyn_cast<FunctionSymbol>(s);
if (!ExistingFunction) { if (!existingFunction) {
reportTypeError(S, File, WASM_SYMBOL_TYPE_FUNCTION); reportTypeError(s, file, WASM_SYMBOL_TYPE_FUNCTION);
return S; return s;
} }
bool CheckSig = true; bool checkSig = true;
if (auto UD = dyn_cast<UndefinedFunction>(ExistingFunction)) if (auto ud = dyn_cast<UndefinedFunction>(existingFunction))
CheckSig = UD->IsCalledDirectly; checkSig = ud->isCalledDirectly;
if (CheckSig && Function && !signatureMatches(ExistingFunction, &Function->Signature)) { if (checkSig && function && !signatureMatches(existingFunction, &function->signature)) {
Symbol* Variant; Symbol* variant;
if (getFunctionVariant(S, &Function->Signature, File, &Variant)) if (getFunctionVariant(s, &function->signature, file, &variant))
// New variant, always replace // New variant, always replace
ReplaceSym(Variant); replaceSym(variant);
else if (shouldReplace(S, File, Flags)) else if (shouldReplace(s, file, flags))
// Variant already exists, replace it after checking shouldReplace // Variant already exists, replace it after checking shouldReplace
ReplaceSym(Variant); replaceSym(variant);
// This variant we found take the place in the symbol table as the primary // This variant we found take the place in the symbol table as the primary
// variant. // variant.
replace(Name, Variant); replace(name, variant);
return Variant; return variant;
} }
// Existing function with matching signature. // Existing function with matching signature.
if (shouldReplace(S, File, Flags)) if (shouldReplace(s, file, flags))
ReplaceSym(S); replaceSym(s);
return S; return s;
} }
Symbol *SymbolTable::addDefinedData(StringRef Name, uint32_t Flags, Symbol *SymbolTable::addDefinedData(StringRef name, uint32_t flags,
InputFile *File, InputSegment *Segment, InputFile *file, InputSegment *segment,
uint32_t Address, uint32_t Size) { uint32_t address, uint32_t size) {
LLVM_DEBUG(dbgs() << "addDefinedData:" << Name << " addr:" << Address LLVM_DEBUG(dbgs() << "addDefinedData:" << name << " addr:" << address
<< "\n"); << "\n");
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(Name, File); std::tie(s, wasInserted) = insert(name, file);
auto ReplaceSym = [&]() { auto replaceSym = [&]() {
replaceSymbol<DefinedData>(S, Name, Flags, File, Segment, Address, Size); replaceSymbol<DefinedData>(s, name, flags, file, segment, address, size);
}; };
if (WasInserted || S->isLazy()) { if (wasInserted || s->isLazy()) {
ReplaceSym(); replaceSym();
return S; return s;
} }
checkDataType(S, File); checkDataType(s, file);
if (shouldReplace(S, File, Flags)) if (shouldReplace(s, file, flags))
ReplaceSym(); replaceSym();
return S; return s;
} }
Symbol *SymbolTable::addDefinedGlobal(StringRef Name, uint32_t Flags, Symbol *SymbolTable::addDefinedGlobal(StringRef name, uint32_t flags,
InputFile *File, InputGlobal *Global) { InputFile *file, InputGlobal *global) {
LLVM_DEBUG(dbgs() << "addDefinedGlobal:" << Name << "\n"); LLVM_DEBUG(dbgs() << "addDefinedGlobal:" << name << "\n");
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(Name, File); std::tie(s, wasInserted) = insert(name, file);
auto ReplaceSym = [&]() { auto replaceSym = [&]() {
replaceSymbol<DefinedGlobal>(S, Name, Flags, File, Global); replaceSymbol<DefinedGlobal>(s, name, flags, file, global);
}; };
if (WasInserted || S->isLazy()) { if (wasInserted || s->isLazy()) {
ReplaceSym(); replaceSym();
return S; return s;
} }
checkGlobalType(S, File, &Global->getType()); checkGlobalType(s, file, &global->getType());
if (shouldReplace(S, File, Flags)) if (shouldReplace(s, file, flags))
ReplaceSym(); replaceSym();
return S; return s;
} }
Symbol *SymbolTable::addDefinedEvent(StringRef Name, uint32_t Flags, Symbol *SymbolTable::addDefinedEvent(StringRef name, uint32_t flags,
InputFile *File, InputEvent *Event) { InputFile *file, InputEvent *event) {
LLVM_DEBUG(dbgs() << "addDefinedEvent:" << Name << "\n"); LLVM_DEBUG(dbgs() << "addDefinedEvent:" << name << "\n");
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(Name, File); std::tie(s, wasInserted) = insert(name, file);
auto ReplaceSym = [&]() { auto replaceSym = [&]() {
replaceSymbol<DefinedEvent>(S, Name, Flags, File, Event); replaceSymbol<DefinedEvent>(s, name, flags, file, event);
}; };
if (WasInserted || S->isLazy()) { if (wasInserted || s->isLazy()) {
ReplaceSym(); replaceSym();
return S; return s;
} }
checkEventType(S, File, &Event->getType(), &Event->Signature); checkEventType(s, file, &event->getType(), &event->signature);
if (shouldReplace(S, File, Flags)) if (shouldReplace(s, file, flags))
ReplaceSym(); replaceSym();
return S; return s;
} }
Symbol *SymbolTable::addUndefinedFunction(StringRef Name, StringRef ImportName, Symbol *SymbolTable::addUndefinedFunction(StringRef name, StringRef importName,
StringRef ImportModule, StringRef importModule,
uint32_t Flags, InputFile *File, uint32_t flags, InputFile *file,
const WasmSignature *Sig, const WasmSignature *sig,
bool IsCalledDirectly) { bool isCalledDirectly) {
LLVM_DEBUG(dbgs() << "addUndefinedFunction: " << Name << " [" LLVM_DEBUG(dbgs() << "addUndefinedFunction: " << name << " ["
<< (Sig ? toString(*Sig) : "none") << (sig ? toString(*sig) : "none")
<< "] IsCalledDirectly:" << IsCalledDirectly << "\n"); << "] IsCalledDirectly:" << isCalledDirectly << "\n");
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(Name, File); std::tie(s, wasInserted) = insert(name, file);
if (S->Traced) if (s->traced)
printTraceSymbolUndefined(Name, File); printTraceSymbolUndefined(name, file);
auto ReplaceSym = [&]() { auto replaceSym = [&]() {
replaceSymbol<UndefinedFunction>(S, Name, ImportName, ImportModule, Flags, replaceSymbol<UndefinedFunction>(s, name, importName, importModule, flags,
File, Sig, IsCalledDirectly); file, sig, isCalledDirectly);
}; };
if (WasInserted) if (wasInserted)
ReplaceSym(); replaceSym();
else if (auto *Lazy = dyn_cast<LazySymbol>(S)) else if (auto *lazy = dyn_cast<LazySymbol>(s))
Lazy->fetch(); lazy->fetch();
else { else {
auto ExistingFunction = dyn_cast<FunctionSymbol>(S); auto existingFunction = dyn_cast<FunctionSymbol>(s);
if (!ExistingFunction) { if (!existingFunction) {
reportTypeError(S, File, WASM_SYMBOL_TYPE_FUNCTION); reportTypeError(s, file, WASM_SYMBOL_TYPE_FUNCTION);
return S; return s;
} }
if (!ExistingFunction->Signature && Sig) if (!existingFunction->signature && sig)
ExistingFunction->Signature = Sig; existingFunction->signature = sig;
if (IsCalledDirectly && !signatureMatches(ExistingFunction, Sig)) if (isCalledDirectly && !signatureMatches(existingFunction, sig))
if (getFunctionVariant(S, Sig, File, &S)) if (getFunctionVariant(s, sig, file, &s))
ReplaceSym(); replaceSym();
} }
return S; return s;
} }
Symbol *SymbolTable::addUndefinedData(StringRef Name, uint32_t Flags, Symbol *SymbolTable::addUndefinedData(StringRef name, uint32_t flags,
InputFile *File) { InputFile *file) {
LLVM_DEBUG(dbgs() << "addUndefinedData: " << Name << "\n"); LLVM_DEBUG(dbgs() << "addUndefinedData: " << name << "\n");
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(Name, File); std::tie(s, wasInserted) = insert(name, file);
if (S->Traced) if (s->traced)
printTraceSymbolUndefined(Name, File); printTraceSymbolUndefined(name, file);
if (WasInserted) if (wasInserted)
replaceSymbol<UndefinedData>(S, Name, Flags, File); replaceSymbol<UndefinedData>(s, name, flags, file);
else if (auto *Lazy = dyn_cast<LazySymbol>(S)) else if (auto *lazy = dyn_cast<LazySymbol>(s))
Lazy->fetch(); lazy->fetch();
else if (S->isDefined()) else if (s->isDefined())
checkDataType(S, File); checkDataType(s, file);
return S; return s;
} }
Symbol *SymbolTable::addUndefinedGlobal(StringRef Name, StringRef ImportName, Symbol *SymbolTable::addUndefinedGlobal(StringRef name, StringRef importName,
StringRef ImportModule, uint32_t Flags, StringRef importModule, uint32_t flags,
InputFile *File, InputFile *file,
const WasmGlobalType *Type) { const WasmGlobalType *type) {
LLVM_DEBUG(dbgs() << "addUndefinedGlobal: " << Name << "\n"); LLVM_DEBUG(dbgs() << "addUndefinedGlobal: " << name << "\n");
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insert(Name, File); std::tie(s, wasInserted) = insert(name, file);
if (S->Traced) if (s->traced)
printTraceSymbolUndefined(Name, File); printTraceSymbolUndefined(name, file);
if (WasInserted) if (wasInserted)
replaceSymbol<UndefinedGlobal>(S, Name, ImportName, ImportModule, Flags, replaceSymbol<UndefinedGlobal>(s, name, importName, importModule, flags,
File, Type); file, type);
else if (auto *Lazy = dyn_cast<LazySymbol>(S)) else if (auto *lazy = dyn_cast<LazySymbol>(s))
Lazy->fetch(); lazy->fetch();
else if (S->isDefined()) else if (s->isDefined())
checkGlobalType(S, File, Type); checkGlobalType(s, file, type);
return S; return s;
} }
void SymbolTable::addLazy(ArchiveFile *File, const Archive::Symbol *Sym) { void SymbolTable::addLazy(ArchiveFile *file, const Archive::Symbol *sym) {
LLVM_DEBUG(dbgs() << "addLazy: " << Sym->getName() << "\n"); LLVM_DEBUG(dbgs() << "addLazy: " << sym->getName() << "\n");
StringRef Name = Sym->getName(); StringRef name = sym->getName();
Symbol *S; Symbol *s;
bool WasInserted; bool wasInserted;
std::tie(S, WasInserted) = insertName(Name); std::tie(s, wasInserted) = insertName(name);
if (WasInserted) { if (wasInserted) {
replaceSymbol<LazySymbol>(S, Name, 0, File, *Sym); replaceSymbol<LazySymbol>(s, name, 0, file, *sym);
return; return;
} }
if (!S->isUndefined()) if (!s->isUndefined())
return; return;
// The existing symbol is undefined, load a new one from the archive, // The existing symbol is undefined, load a new one from the archive,
// unless the the existing symbol is weak in which case replace the undefined // unless the the existing symbol is weak in which case replace the undefined
// symbols with a LazySymbol. // symbols with a LazySymbol.
if (S->isWeak()) { if (s->isWeak()) {
const WasmSignature *OldSig = nullptr; const WasmSignature *oldSig = nullptr;
// In the case of an UndefinedFunction we need to preserve the expected // In the case of an UndefinedFunction we need to preserve the expected
// signature. // signature.
if (auto *F = dyn_cast<UndefinedFunction>(S)) if (auto *f = dyn_cast<UndefinedFunction>(s))
OldSig = F->Signature; oldSig = f->signature;
LLVM_DEBUG(dbgs() << "replacing existing weak undefined symbol\n"); LLVM_DEBUG(dbgs() << "replacing existing weak undefined symbol\n");
auto NewSym = replaceSymbol<LazySymbol>(S, Name, WASM_SYMBOL_BINDING_WEAK, auto newSym = replaceSymbol<LazySymbol>(s, name, WASM_SYMBOL_BINDING_WEAK,
File, *Sym); file, *sym);
NewSym->Signature = OldSig; newSym->signature = oldSig;
return; return;
} }
LLVM_DEBUG(dbgs() << "replacing existing undefined\n"); LLVM_DEBUG(dbgs() << "replacing existing undefined\n");
File->addMember(Sym); file->addMember(sym);
} }
bool SymbolTable::addComdat(StringRef Name) { bool SymbolTable::addComdat(StringRef name) {
return ComdatGroups.insert(CachedHashStringRef(Name)).second; return comdatGroups.insert(CachedHashStringRef(name)).second;
} }
// The new signature doesn't match. Create a variant to the symbol with the // The new signature doesn't match. Create a variant to the symbol with the
// signature encoded in the name and return that instead. These symbols are // signature encoded in the name and return that instead. These symbols are
// then unified later in handleSymbolVariants. // then unified later in handleSymbolVariants.
bool SymbolTable::getFunctionVariant(Symbol* Sym, const WasmSignature *Sig, bool SymbolTable::getFunctionVariant(Symbol* sym, const WasmSignature *sig,
const InputFile *File, Symbol **Out) { const InputFile *file, Symbol **out) {
LLVM_DEBUG(dbgs() << "getFunctionVariant: " << Sym->getName() << " -> " LLVM_DEBUG(dbgs() << "getFunctionVariant: " << sym->getName() << " -> "
<< " " << toString(*Sig) << "\n"); << " " << toString(*sig) << "\n");
Symbol *Variant = nullptr; Symbol *variant = nullptr;
// Linear search through symbol variants. Should never be more than two // Linear search through symbol variants. Should never be more than two
// or three entries here. // or three entries here.
auto &Variants = SymVariants[CachedHashStringRef(Sym->getName())]; auto &variants = symVariants[CachedHashStringRef(sym->getName())];
if (Variants.empty()) if (variants.empty())
Variants.push_back(Sym); variants.push_back(sym);
for (Symbol* V : Variants) { for (Symbol* v : variants) {
if (*V->getSignature() == *Sig) { if (*v->getSignature() == *sig) {
Variant = V; variant = v;
break; break;
} }
} }
bool WasAdded = !Variant; bool wasAdded = !variant;
if (WasAdded) { if (wasAdded) {
// Create a new variant; // Create a new variant;
LLVM_DEBUG(dbgs() << "added new variant\n"); LLVM_DEBUG(dbgs() << "added new variant\n");
Variant = reinterpret_cast<Symbol *>(make<SymbolUnion>()); variant = reinterpret_cast<Symbol *>(make<SymbolUnion>());
Variants.push_back(Variant); variants.push_back(variant);
} else { } else {
LLVM_DEBUG(dbgs() << "variant already exists: " << toString(*Variant) << "\n"); LLVM_DEBUG(dbgs() << "variant already exists: " << toString(*variant) << "\n");
assert(*Variant->getSignature() == *Sig); assert(*variant->getSignature() == *sig);
} }
*Out = Variant; *out = variant;
return WasAdded; return wasAdded;
} }
// Set a flag for --trace-symbol so that we can print out a log message // Set a flag for --trace-symbol so that we can print out a log message
// if a new symbol with the same name is inserted into the symbol table. // if a new symbol with the same name is inserted into the symbol table.
void SymbolTable::trace(StringRef Name) { void SymbolTable::trace(StringRef name) {
SymMap.insert({CachedHashStringRef(Name), -1}); symMap.insert({CachedHashStringRef(name), -1});
} }
void SymbolTable::wrap(Symbol *Sym, Symbol *Real, Symbol *Wrap) { void SymbolTable::wrap(Symbol *sym, Symbol *real, Symbol *wrap) {
// Swap symbols as instructed by -wrap. // Swap symbols as instructed by -wrap.
int &OrigIdx = SymMap[CachedHashStringRef(Sym->getName())]; int &origIdx = symMap[CachedHashStringRef(sym->getName())];
int &RealIdx= SymMap[CachedHashStringRef(Real->getName())]; int &realIdx= symMap[CachedHashStringRef(real->getName())];
int &WrapIdx = SymMap[CachedHashStringRef(Wrap->getName())]; int &wrapIdx = symMap[CachedHashStringRef(wrap->getName())];
LLVM_DEBUG(dbgs() << "wrap: " << Sym->getName() << "\n"); LLVM_DEBUG(dbgs() << "wrap: " << sym->getName() << "\n");
// Anyone looking up __real symbols should get the original // Anyone looking up __real symbols should get the original
RealIdx = OrigIdx; realIdx = origIdx;
// Anyone looking up the original should get the __wrap symbol // Anyone looking up the original should get the __wrap symbol
OrigIdx = WrapIdx; origIdx = wrapIdx;
} }
static const uint8_t UnreachableFn[] = { static const uint8_t unreachableFn[] = {
0x03 /* ULEB length */, 0x00 /* ULEB num locals */, 0x03 /* ULEB length */, 0x00 /* ULEB num locals */,
0x00 /* opcode unreachable */, 0x0b /* opcode end */ 0x00 /* opcode unreachable */, 0x0b /* opcode end */
}; };
// Replace the given symbol body with an unreachable function. // Replace the given symbol body with an unreachable function.
// This is used by handleWeakUndefines in order to generate a callable // This is used by handleWeakUndefines in order to generate a callable
// equivalent of an undefined function and also handleSymbolVariants for // equivalent of an undefined function and also handleSymbolVariants for
// undefined functions that don't match the signature of the definition. // undefined functions that don't match the signature of the definition.
InputFunction *SymbolTable::replaceWithUnreachable(Symbol *Sym, InputFunction *SymbolTable::replaceWithUnreachable(Symbol *sym,
const WasmSignature &Sig, const WasmSignature &sig,
StringRef DebugName) { StringRef debugName) {
auto *Func = make<SyntheticFunction>(Sig, Sym->getName(), DebugName); auto *func = make<SyntheticFunction>(sig, sym->getName(), debugName);
Func->setBody(UnreachableFn); func->setBody(unreachableFn);
SyntheticFunctions.emplace_back(Func); syntheticFunctions.emplace_back(func);
replaceSymbol<DefinedFunction>(Sym, Sym->getName(), Sym->getFlags(), nullptr, replaceSymbol<DefinedFunction>(sym, sym->getName(), sym->getFlags(), nullptr,
Func); func);
return Func; return func;
} }
// For weak undefined functions, there may be "call" instructions that reference // For weak undefined functions, there may be "call" instructions that reference
// the symbol. In this case, we need to synthesise a dummy/stub function that // the symbol. In this case, we need to synthesise a dummy/stub function that
// will abort at runtime, so that relocations can still provided an operand to // will abort at runtime, so that relocations can still provided an operand to
// the call instruction that passes Wasm validation. // the call instruction that passes Wasm validation.
void SymbolTable::handleWeakUndefines() { void SymbolTable::handleWeakUndefines() {
for (Symbol *Sym : getSymbols()) { for (Symbol *sym : getSymbols()) {
if (!Sym->isUndefWeak()) if (!sym->isUndefWeak())
continue; continue;
const WasmSignature *Sig = Sym->getSignature(); const WasmSignature *sig = sym->getSignature();
if (!Sig) { if (!sig) {
// It is possible for undefined functions not to have a signature (eg. if // It is possible for undefined functions not to have a signature (eg. if
// added via "--undefined"), but weak undefined ones do have a signature. // added via "--undefined"), but weak undefined ones do have a signature.
// Lazy symbols may not be functions and therefore Sig can still be null // Lazy symbols may not be functions and therefore Sig can still be null
// in some circumstantce. // in some circumstantce.
assert(!isa<FunctionSymbol>(Sym)); assert(!isa<FunctionSymbol>(sym));
continue; continue;
} }
// Add a synthetic dummy for weak undefined functions. These dummies will // Add a synthetic dummy for weak undefined functions. These dummies will
// be GC'd if not used as the target of any "call" instructions. // be GC'd if not used as the target of any "call" instructions.
StringRef DebugName = Saver.save("undefined:" + toString(*Sym)); StringRef debugName = saver.save("undefined:" + toString(*sym));
InputFunction* Func = replaceWithUnreachable(Sym, *Sig, DebugName); InputFunction* func = replaceWithUnreachable(sym, *sig, debugName);
// Ensure it compares equal to the null pointer, and so that table relocs // Ensure it compares equal to the null pointer, and so that table relocs
// don't pull in the stub body (only call-operand relocs should do that). // don't pull in the stub body (only call-operand relocs should do that).
Func->setTableIndex(0); func->setTableIndex(0);
// Hide our dummy to prevent export. // Hide our dummy to prevent export.
Sym->setHidden(true); sym->setHidden(true);
} }
} }
static void reportFunctionSignatureMismatch(StringRef SymName, static void reportFunctionSignatureMismatch(StringRef symName,
FunctionSymbol *A, FunctionSymbol *a,
FunctionSymbol *B, bool IsError) { FunctionSymbol *b, bool isError) {
std::string msg = ("function signature mismatch: " + SymName + std::string msg = ("function signature mismatch: " + symName +
"\n>>> defined as " + toString(*A->Signature) + " in " + "\n>>> defined as " + toString(*a->signature) + " in " +
toString(A->getFile()) + "\n>>> defined as " + toString(a->getFile()) + "\n>>> defined as " +
toString(*B->Signature) + " in " + toString(B->getFile())) toString(*b->signature) + " in " + toString(b->getFile()))
.str(); .str();
if (IsError) if (isError)
error(msg); error(msg);
else else
warn(msg); warn(msg);
} }
// Remove any variant symbols that were created due to function signature // Remove any variant symbols that were created due to function signature
// mismatches. // mismatches.
void SymbolTable::handleSymbolVariants() { void SymbolTable::handleSymbolVariants() {
for (auto Pair : SymVariants) { for (auto pair : symVariants) {
// Push the initial symbol onto the list of variants. // Push the initial symbol onto the list of variants.
StringRef SymName = Pair.first.val(); StringRef symName = pair.first.val();
std::vector<Symbol *> &Variants = Pair.second; std::vector<Symbol *> &variants = pair.second;
#ifndef NDEBUG #ifndef NDEBUG
LLVM_DEBUG(dbgs() << "symbol with (" << Variants.size() LLVM_DEBUG(dbgs() << "symbol with (" << variants.size()
<< ") variants: " << SymName << "\n"); << ") variants: " << symName << "\n");
for (auto *S: Variants) { for (auto *s: variants) {
auto *F = cast<FunctionSymbol>(S); auto *f = cast<FunctionSymbol>(s);
LLVM_DEBUG(dbgs() << " variant: " + F->getName() << " " LLVM_DEBUG(dbgs() << " variant: " + f->getName() << " "
<< toString(*F->Signature) << "\n"); << toString(*f->signature) << "\n");
} }
#endif #endif
// Find the one definition. // Find the one definition.
DefinedFunction *Defined = nullptr; DefinedFunction *defined = nullptr;
for (auto *Symbol : Variants) { for (auto *symbol : variants) {
if (auto F = dyn_cast<DefinedFunction>(Symbol)) { if (auto f = dyn_cast<DefinedFunction>(symbol)) {
Defined = F; defined = f;
break; break;
} }
} }
// If there are no definitions, and the undefined symbols disagree on // If there are no definitions, and the undefined symbols disagree on
// the signature, there is not we can do since we don't know which one // the signature, there is not we can do since we don't know which one
// to use as the signature on the import. // to use as the signature on the import.
if (!Defined) { if (!defined) {
reportFunctionSignatureMismatch(SymName, reportFunctionSignatureMismatch(symName,
cast<FunctionSymbol>(Variants[0]), cast<FunctionSymbol>(variants[0]),
cast<FunctionSymbol>(Variants[1]), true); cast<FunctionSymbol>(variants[1]), true);
return; return;
} }
for (auto *Symbol : Variants) { for (auto *symbol : variants) {
if (Symbol != Defined) { if (symbol != defined) {
auto *F = cast<FunctionSymbol>(Symbol); auto *f = cast<FunctionSymbol>(symbol);
reportFunctionSignatureMismatch(SymName, F, Defined, false); reportFunctionSignatureMismatch(symName, f, defined, false);
StringRef DebugName = Saver.save("unreachable:" + toString(*F)); StringRef debugName = saver.save("unreachable:" + toString(*f));
replaceWithUnreachable(F, *F->Signature, DebugName); replaceWithUnreachable(f, *f->signature, debugName);
} }
} }
} }
} }

lld/trunk/wasm/Symbols.h

Show All 14 Lines
#include "llvm/Object/Wasm.h" #include "llvm/Object/Wasm.h"
namespace lld { namespace lld {
namespace wasm { namespace wasm {
// Shared string constants // Shared string constants
// The default module name to use for symbol imports. // The default module name to use for symbol imports.
extern const char *DefaultModule; extern const char *defaultModule;
// The name under which to import or export the wasm table. // The name under which to import or export the wasm table.
extern const char *FunctionTableName; extern const char *functionTableName;
using llvm::wasm::WasmSymbolType; using llvm::wasm::WasmSymbolType;
class InputFile; class InputFile;
class InputChunk; class InputChunk;
class InputSegment; class InputSegment;
class InputFunction; class InputFunction;
class InputGlobal; class InputGlobal;
Show All 14 Lines enum Kind : uint8_t {
SectionKind, SectionKind,
OutputSectionKind, OutputSectionKind,
UndefinedFunctionKind, UndefinedFunctionKind,
UndefinedDataKind, UndefinedDataKind,
UndefinedGlobalKind, UndefinedGlobalKind,
LazyKind, LazyKind,
}; };
Kind kind() const { return SymbolKind; } Kind kind() const { return symbolKind; }
bool isDefined() const { return !isLazy() && !isUndefined(); } bool isDefined() const { return !isLazy() && !isUndefined(); }
bool isUndefined() const { bool isUndefined() const {
return SymbolKind == UndefinedFunctionKind || return symbolKind == UndefinedFunctionKind ||
SymbolKind == UndefinedDataKind || SymbolKind == UndefinedGlobalKind; symbolKind == UndefinedDataKind || symbolKind == UndefinedGlobalKind;
} }
bool isLazy() const { return SymbolKind == LazyKind; } bool isLazy() const { return symbolKind == LazyKind; }
bool isLocal() const; bool isLocal() const;
bool isWeak() const; bool isWeak() const;
bool isHidden() const; bool isHidden() const;
// Returns true if this symbol exists in a discarded (due to COMDAT) section // Returns true if this symbol exists in a discarded (due to COMDAT) section
bool isDiscarded() const; bool isDiscarded() const;
// True if this is an undefined weak symbol. This only works once // True if this is an undefined weak symbol. This only works once
// all input files have been added. // all input files have been added.
bool isUndefWeak() const { bool isUndefWeak() const {
// See comment on lazy symbols for details. // See comment on lazy symbols for details.
return isWeak() && (isUndefined() || isLazy()); return isWeak() && (isUndefined() || isLazy());
} }
// Returns the symbol name. // Returns the symbol name.
StringRef getName() const { return Name; } StringRef getName() const { return name; }
// Returns the file from which this symbol was created. // Returns the file from which this symbol was created.
InputFile *getFile() const { return File; } InputFile *getFile() const { return file; }
uint32_t getFlags() const { return Flags; } uint32_t getFlags() const { return flags; }
InputChunk *getChunk() const; InputChunk *getChunk() const;
// Indicates that the section or import for this symbol will be included in // Indicates that the section or import for this symbol will be included in
// the final image. // the final image.
bool isLive() const; bool isLive() const;
// Marks the symbol's InputChunk as Live, so that it will be included in the // Marks the symbol's InputChunk as Live, so that it will be included in the
// final image. // final image.
void markLive(); void markLive();
void setHidden(bool IsHidden); void setHidden(bool isHidden);
// Get/set the index in the output symbol table. This is only used for // Get/set the index in the output symbol table. This is only used for
// relocatable output. // relocatable output.
uint32_t getOutputSymbolIndex() const; uint32_t getOutputSymbolIndex() const;
void setOutputSymbolIndex(uint32_t Index); void setOutputSymbolIndex(uint32_t index);
WasmSymbolType getWasmType() const; WasmSymbolType getWasmType() const;
bool isExported() const; bool isExported() const;
const WasmSignature* getSignature() const; const WasmSignature* getSignature() const;
bool isInGOT() const { return GOTIndex != INVALID_INDEX; } bool isInGOT() const { return gotIndex != INVALID_INDEX; }
uint32_t getGOTIndex() const { uint32_t getGOTIndex() const {
assert(GOTIndex != INVALID_INDEX); assert(gotIndex != INVALID_INDEX);
return GOTIndex; return gotIndex;
} }
void setGOTIndex(uint32_t Index); void setGOTIndex(uint32_t index);
bool hasGOTIndex() const { return GOTIndex != INVALID_INDEX; } bool hasGOTIndex() const { return gotIndex != INVALID_INDEX; }
protected: protected:
Symbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F) Symbol(StringRef name, Kind k, uint32_t flags, InputFile *f)
: Name(Name), File(F), Flags(Flags), SymbolKind(K), : name(name), file(f), flags(flags), symbolKind(k),
Referenced(!Config->GcSections), IsUsedInRegularObj(false), referenced(!config->gcSections), isUsedInRegularObj(false),
ForceExport(false), CanInline(false), Traced(false) {} forceExport(false), canInline(false), traced(false) {}
StringRef Name; StringRef name;
InputFile *File; InputFile *file;
uint32_t Flags; uint32_t flags;
uint32_t OutputSymbolIndex = INVALID_INDEX; uint32_t outputSymbolIndex = INVALID_INDEX;
uint32_t GOTIndex = INVALID_INDEX; uint32_t gotIndex = INVALID_INDEX;
Kind SymbolKind; Kind symbolKind;
public: public:
bool Referenced : 1; bool referenced : 1;
// True if the symbol was used for linking and thus need to be added to the // True if the symbol was used for linking and thus need to be added to the
// output file's symbol table. This is true for all symbols except for // output file's symbol table. This is true for all symbols except for
// unreferenced DSO symbols, lazy (archive) symbols, and bitcode symbols that // unreferenced DSO symbols, lazy (archive) symbols, and bitcode symbols that
// are unreferenced except by other bitcode objects. // are unreferenced except by other bitcode objects.
bool IsUsedInRegularObj : 1; bool isUsedInRegularObj : 1;
// True if ths symbol is explicity marked for export (i.e. via the -e/--export // True if ths symbol is explicity marked for export (i.e. via the -e/--export
// command line flag) // command line flag)
bool ForceExport : 1; bool forceExport : 1;
// False if LTO shouldn't inline whatever this symbol points to. If a symbol // False if LTO shouldn't inline whatever this symbol points to. If a symbol
// is overwritten after LTO, LTO shouldn't inline the symbol because it // is overwritten after LTO, LTO shouldn't inline the symbol because it
// doesn't know the final contents of the symbol. // doesn't know the final contents of the symbol.
bool CanInline : 1; bool canInline : 1;
// True if this symbol is specified by --trace-symbol option. // True if this symbol is specified by --trace-symbol option.
bool Traced : 1; bool traced : 1;
}; };
class FunctionSymbol : public Symbol { class FunctionSymbol : public Symbol {
public: public:
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == DefinedFunctionKind || return s->kind() == DefinedFunctionKind ||
S->kind() == UndefinedFunctionKind; s->kind() == UndefinedFunctionKind;
} }
// Get/set the table index // Get/set the table index
void setTableIndex(uint32_t Index); void setTableIndex(uint32_t index);
uint32_t getTableIndex() const; uint32_t getTableIndex() const;
bool hasTableIndex() const; bool hasTableIndex() const;
// Get/set the function index // Get/set the function index
uint32_t getFunctionIndex() const; uint32_t getFunctionIndex() const;
void setFunctionIndex(uint32_t Index); void setFunctionIndex(uint32_t index);
bool hasFunctionIndex() const; bool hasFunctionIndex() const;
const WasmSignature *Signature; const WasmSignature *signature;
protected: protected:
FunctionSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F, FunctionSymbol(StringRef name, Kind k, uint32_t flags, InputFile *f,
const WasmSignature *Sig) const WasmSignature *sig)
: Symbol(Name, K, Flags, F), Signature(Sig) {} : Symbol(name, k, flags, f), signature(sig) {}
uint32_t TableIndex = INVALID_INDEX; uint32_t tableIndex = INVALID_INDEX;
uint32_t FunctionIndex = INVALID_INDEX; uint32_t functionIndex = INVALID_INDEX;
}; };
class DefinedFunction : public FunctionSymbol { class DefinedFunction : public FunctionSymbol {
public: public:
DefinedFunction(StringRef Name, uint32_t Flags, InputFile *F, DefinedFunction(StringRef name, uint32_t flags, InputFile *f,
InputFunction *Function); InputFunction *function);
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == DefinedFunctionKind; return s->kind() == DefinedFunctionKind;
} }
InputFunction *Function; InputFunction *function;
}; };
class UndefinedFunction : public FunctionSymbol { class UndefinedFunction : public FunctionSymbol {
public: public:
UndefinedFunction(StringRef Name, StringRef ImportName, UndefinedFunction(StringRef name, StringRef importName,
StringRef ImportModule, uint32_t Flags, StringRef importModule, uint32_t flags,
InputFile *File = nullptr, InputFile *file = nullptr,
const WasmSignature *Type = nullptr, const WasmSignature *type = nullptr,
bool IsCalledDirectly = true) bool isCalledDirectly = true)
: FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, Type), : FunctionSymbol(name, UndefinedFunctionKind, flags, file, type),
ImportName(ImportName), ImportModule(ImportModule), IsCalledDirectly(IsCalledDirectly) {} importName(importName), importModule(importModule), isCalledDirectly(isCalledDirectly) {}
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == UndefinedFunctionKind; return s->kind() == UndefinedFunctionKind;
} }
StringRef ImportName; StringRef importName;
StringRef ImportModule; StringRef importModule;
bool IsCalledDirectly; bool isCalledDirectly;
}; };
// Section symbols for output sections are different from those for input // Section symbols for output sections are different from those for input
// section. These are generated by the linker and point the OutputSection // section. These are generated by the linker and point the OutputSection
// rather than an InputSection. // rather than an InputSection.
class OutputSectionSymbol : public Symbol { class OutputSectionSymbol : public Symbol {
public: public:
OutputSectionSymbol(const OutputSection *S) OutputSectionSymbol(const OutputSection *s)
: Symbol("", OutputSectionKind, llvm::wasm::WASM_SYMBOL_BINDING_LOCAL, : Symbol("", OutputSectionKind, llvm::wasm::WASM_SYMBOL_BINDING_LOCAL,
nullptr), nullptr),
Section(S) {} section(s) {}
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == OutputSectionKind; return s->kind() == OutputSectionKind;
} }
const OutputSection *Section; const OutputSection *section;
}; };
class SectionSymbol : public Symbol { class SectionSymbol : public Symbol {
public: public:
SectionSymbol(uint32_t Flags, const InputSection *S, InputFile *F = nullptr) SectionSymbol(uint32_t flags, const InputSection *s, InputFile *f = nullptr)
: Symbol("", SectionKind, Flags, F), Section(S) {} : Symbol("", SectionKind, flags, f), section(s) {}
static bool classof(const Symbol *S) { return S->kind() == SectionKind; } static bool classof(const Symbol *s) { return s->kind() == SectionKind; }
const OutputSectionSymbol *getOutputSectionSymbol() const; const OutputSectionSymbol *getOutputSectionSymbol() const;
const InputSection *Section; const InputSection *section;
}; };
class DataSymbol : public Symbol { class DataSymbol : public Symbol {
public: public:
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == DefinedDataKind || S->kind() == UndefinedDataKind; return s->kind() == DefinedDataKind || s->kind() == UndefinedDataKind;
} }
protected: protected:
DataSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F) DataSymbol(StringRef name, Kind k, uint32_t flags, InputFile *f)
: Symbol(Name, K, Flags, F) {} : Symbol(name, k, flags, f) {}
}; };
class DefinedData : public DataSymbol { class DefinedData : public DataSymbol {
public: public:
// Constructor for regular data symbols originating from input files. // Constructor for regular data symbols originating from input files.
DefinedData(StringRef Name, uint32_t Flags, InputFile *F, DefinedData(StringRef name, uint32_t flags, InputFile *f,
InputSegment *Segment, uint32_t Offset, uint32_t Size) InputSegment *segment, uint32_t offset, uint32_t size)
: DataSymbol(Name, DefinedDataKind, Flags, F), Segment(Segment), : DataSymbol(name, DefinedDataKind, flags, f), segment(segment),
Offset(Offset), Size(Size) {} offset(offset), size(size) {}
// Constructor for linker synthetic data symbols. // Constructor for linker synthetic data symbols.
DefinedData(StringRef Name, uint32_t Flags) DefinedData(StringRef name, uint32_t flags)
: DataSymbol(Name, DefinedDataKind, Flags, nullptr) {} : DataSymbol(name, DefinedDataKind, flags, nullptr) {}
static bool classof(const Symbol *S) { return S->kind() == DefinedDataKind; } static bool classof(const Symbol *s) { return s->kind() == DefinedDataKind; }
// Returns the output virtual address of a defined data symbol. // Returns the output virtual address of a defined data symbol.
uint32_t getVirtualAddress() const; uint32_t getVirtualAddress() const;
void setVirtualAddress(uint32_t VA); void setVirtualAddress(uint32_t va);
// Returns the offset of a defined data symbol within its OutputSegment. // Returns the offset of a defined data symbol within its OutputSegment.
uint32_t getOutputSegmentOffset() const; uint32_t getOutputSegmentOffset() const;
uint32_t getOutputSegmentIndex() const; uint32_t getOutputSegmentIndex() const;
uint32_t getSize() const { return Size; } uint32_t getSize() const { return size; }
InputSegment *Segment = nullptr; InputSegment *segment = nullptr;
protected: protected:
uint32_t Offset = 0; uint32_t offset = 0;
uint32_t Size = 0; uint32_t size = 0;
}; };
class UndefinedData : public DataSymbol { class UndefinedData : public DataSymbol {
public: public:
UndefinedData(StringRef Name, uint32_t Flags, InputFile *File = nullptr) UndefinedData(StringRef name, uint32_t flags, InputFile *file = nullptr)
: DataSymbol(Name, UndefinedDataKind, Flags, File) {} : DataSymbol(name, UndefinedDataKind, flags, file) {}
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == UndefinedDataKind; return s->kind() == UndefinedDataKind;
} }
}; };
class GlobalSymbol : public Symbol { class GlobalSymbol : public Symbol {
public: public:
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == DefinedGlobalKind || S->kind() == UndefinedGlobalKind; return s->kind() == DefinedGlobalKind || s->kind() == UndefinedGlobalKind;
} }
const WasmGlobalType *getGlobalType() const { return GlobalType; } const WasmGlobalType *getGlobalType() const { return globalType; }
// Get/set the global index // Get/set the global index
uint32_t getGlobalIndex() const; uint32_t getGlobalIndex() const;
void setGlobalIndex(uint32_t Index); void setGlobalIndex(uint32_t index);
bool hasGlobalIndex() const; bool hasGlobalIndex() const;
protected: protected:
GlobalSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F, GlobalSymbol(StringRef name, Kind k, uint32_t flags, InputFile *f,
const WasmGlobalType *GlobalType) const WasmGlobalType *globalType)
: Symbol(Name, K, Flags, F), GlobalType(GlobalType) {} : Symbol(name, k, flags, f), globalType(globalType) {}
const WasmGlobalType *GlobalType; const WasmGlobalType *globalType;
uint32_t GlobalIndex = INVALID_INDEX; uint32_t globalIndex = INVALID_INDEX;
}; };
class DefinedGlobal : public GlobalSymbol { class DefinedGlobal : public GlobalSymbol {
public: public:
DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File, DefinedGlobal(StringRef name, uint32_t flags, InputFile *file,
InputGlobal *Global); InputGlobal *global);
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == DefinedGlobalKind; return s->kind() == DefinedGlobalKind;
} }
InputGlobal *Global; InputGlobal *global;
}; };
class UndefinedGlobal : public GlobalSymbol { class UndefinedGlobal : public GlobalSymbol {
public: public:
UndefinedGlobal(StringRef Name, StringRef ImportName, StringRef ImportModule, UndefinedGlobal(StringRef name, StringRef importName, StringRef importModule,
uint32_t Flags, InputFile *File = nullptr, uint32_t flags, InputFile *file = nullptr,
const WasmGlobalType *Type = nullptr) const WasmGlobalType *type = nullptr)
: GlobalSymbol(Name, UndefinedGlobalKind, Flags, File, Type), : GlobalSymbol(name, UndefinedGlobalKind, flags, file, type),
ImportName(ImportName), ImportModule(ImportModule) {} importName(importName), importModule(importModule) {}
static bool classof(const Symbol *S) { static bool classof(const Symbol *s) {
return S->kind() == UndefinedGlobalKind; return s->kind() == UndefinedGlobalKind;
} }
StringRef ImportName; StringRef importName;
StringRef ImportModule; StringRef importModule;
}; };
// Wasm events are features that suspend the current execution and transfer the // Wasm events are features that suspend the current execution and transfer the
// control flow to a corresponding handler. Currently the only supported event // control flow to a corresponding handler. Currently the only supported event
// kind is exceptions. // kind is exceptions.
// //
// Event tags are values to distinguish different events. For exceptions, they // Event tags are values to distinguish different events. For exceptions, they
// can be used to distinguish different language's exceptions, i.e., all C++ // can be used to distinguish different language's exceptions, i.e., all C++
// exceptions have the same tag. Wasm can generate code capable of doing // exceptions have the same tag. Wasm can generate code capable of doing
// different handling actions based on the tag of caught exceptions. // different handling actions based on the tag of caught exceptions.
// //
// A single EventSymbol object represents a single tag. C++ exception event // A single EventSymbol object represents a single tag. C++ exception event
// symbol is a weak symbol generated in every object file in which exceptions // symbol is a weak symbol generated in every object file in which exceptions
// are used, and has name '__cpp_exception' for linking. // are used, and has name '__cpp_exception' for linking.
class EventSymbol : public Symbol { class EventSymbol : public Symbol {
public: public:
static bool classof(const Symbol *S) { return S->kind() == DefinedEventKind; } static bool classof(const Symbol *s) { return s->kind() == DefinedEventKind; }
const WasmEventType *getEventType() const { return EventType; } const WasmEventType *getEventType() const { return eventType; }
// Get/set the event index // Get/set the event index
uint32_t getEventIndex() const; uint32_t getEventIndex() const;
void setEventIndex(uint32_t Index); void setEventIndex(uint32_t index);
bool hasEventIndex() const; bool hasEventIndex() const;
const WasmSignature *Signature; const WasmSignature *signature;
protected: protected:
EventSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F, EventSymbol(StringRef name, Kind k, uint32_t flags, InputFile *f,
const WasmEventType *EventType, const WasmSignature *Sig) const WasmEventType *eventType, const WasmSignature *sig)
: Symbol(Name, K, Flags, F), Signature(Sig), EventType(EventType) {} : Symbol(name, k, flags, f), signature(sig), eventType(eventType) {}
const WasmEventType *EventType; const WasmEventType *eventType;
uint32_t EventIndex = INVALID_INDEX; uint32_t eventIndex = INVALID_INDEX;
}; };
class DefinedEvent : public EventSymbol { class DefinedEvent : public EventSymbol {
public: public:
DefinedEvent(StringRef Name, uint32_t Flags, InputFile *File, DefinedEvent(StringRef name, uint32_t flags, InputFile *file,
InputEvent *Event); InputEvent *event);
static bool classof(const Symbol *S) { return S->kind() == DefinedEventKind; } static bool classof(const Symbol *s) { return s->kind() == DefinedEventKind; }
InputEvent *Event; InputEvent *event;
}; };
// LazySymbol represents a symbol that is not yet in the link, but we know where // LazySymbol represents a symbol that is not yet in the link, but we know where
// to find it if needed. If the resolver finds both Undefined and Lazy for the // to find it if needed. If the resolver finds both Undefined and Lazy for the
// same name, it will ask the Lazy to load a file. // same name, it will ask the Lazy to load a file.
// //
// A special complication is the handling of weak undefined symbols. They should // A special complication is the handling of weak undefined symbols. They should
// not load a file, but we have to remember we have seen both the weak undefined // not load a file, but we have to remember we have seen both the weak undefined
// and the lazy. We represent that with a lazy symbol with a weak binding. This // and the lazy. We represent that with a lazy symbol with a weak binding. This
// means that code looking for undefined symbols normally also has to take lazy // means that code looking for undefined symbols normally also has to take lazy
// symbols into consideration. // symbols into consideration.
class LazySymbol : public Symbol { class LazySymbol : public Symbol {
public: public:
LazySymbol(StringRef Name, uint32_t Flags, InputFile *File, LazySymbol(StringRef name, uint32_t flags, InputFile *file,
const llvm::object::Archive::Symbol &Sym) const llvm::object::Archive::Symbol &sym)
: Symbol(Name, LazyKind, Flags, File), ArchiveSymbol(Sym) {} : Symbol(name, LazyKind, flags, file), archiveSymbol(sym) {}
static bool classof(const Symbol *S) { return S->kind() == LazyKind; } static bool classof(const Symbol *s) { return s->kind() == LazyKind; }
void fetch(); void fetch();
// Lazy symbols can have a signature because they can replace an // Lazy symbols can have a signature because they can replace an
// UndefinedFunction which which case we need to be able to preserve the // UndefinedFunction which which case we need to be able to preserve the
// signture. // signture.
// TODO(sbc): This repetition of the signature field is inelegant. Revisit // TODO(sbc): This repetition of the signature field is inelegant. Revisit
// the use of class hierarchy to represent symbol taxonomy. // the use of class hierarchy to represent symbol taxonomy.
const WasmSignature *Signature = nullptr; const WasmSignature *signature = nullptr;
private: private:
llvm::object::Archive::Symbol ArchiveSymbol; llvm::object::Archive::Symbol archiveSymbol;
}; };
// linker-generated symbols // linker-generated symbols
struct WasmSym { struct WasmSym {
// __global_base // __global_base
// Symbol marking the start of the global section. // Symbol marking the start of the global section.
static DefinedData *GlobalBase; static DefinedData *globalBase;
// __stack_pointer // __stack_pointer
// Global that holds the address of the top of the explicit value stack in // Global that holds the address of the top of the explicit value stack in
// linear memory. // linear memory.
static GlobalSymbol *StackPointer; static GlobalSymbol *stackPointer;
// __data_end // __data_end
// Symbol marking the end of the data and bss. // Symbol marking the end of the data and bss.
static DefinedData *DataEnd; static DefinedData *dataEnd;
// __heap_base // __heap_base
// Symbol marking the end of the data, bss and explicit stack. Any linear // Symbol marking the end of the data, bss and explicit stack. Any linear
// memory following this address is not used by the linked code and can // memory following this address is not used by the linked code and can
// therefore be used as a backing store for brk()/malloc() implementations. // therefore be used as a backing store for brk()/malloc() implementations.
static DefinedData *HeapBase; static DefinedData *heapBase;
// __wasm_call_ctors // __wasm_call_ctors
// Function that directly calls all ctors in priority order. // Function that directly calls all ctors in priority order.
static DefinedFunction *CallCtors; static DefinedFunction *callCtors;
// __wasm_init_memory // __wasm_init_memory
// Function that initializes passive data segments post-instantiation. // Function that initializes passive data segments post-instantiation.
static DefinedFunction *InitMemory; static DefinedFunction *initMemory;
// __wasm_apply_relocs // __wasm_apply_relocs
// Function that applies relocations to data segment post-instantiation. // Function that applies relocations to data segment post-instantiation.
static DefinedFunction *ApplyRelocs; static DefinedFunction *applyRelocs;
// __dso_handle // __dso_handle
// Symbol used in calls to __cxa_atexit to determine current DLL // Symbol used in calls to __cxa_atexit to determine current DLL
static DefinedData *DsoHandle; static DefinedData *dsoHandle;
// __table_base // __table_base
// Used in PIC code for offset of indirect function table // Used in PIC code for offset of indirect function table
static UndefinedGlobal *TableBase; static UndefinedGlobal *tableBase;
// __memory_base // __memory_base
// Used in PIC code for offset of global data // Used in PIC code for offset of global data
static UndefinedGlobal *MemoryBase; static UndefinedGlobal *memoryBase;
}; };
// A buffer class that is large enough to hold any Symbol-derived // A buffer class that is large enough to hold any Symbol-derived
// object. We allocate memory using this class and instantiate a symbol // object. We allocate memory using this class and instantiate a symbol
// using the placement new. // using the placement new.
union SymbolUnion { union SymbolUnion {
alignas(DefinedFunction) char A[sizeof(DefinedFunction)]; alignas(DefinedFunction) char a[sizeof(DefinedFunction)];
alignas(DefinedData) char B[sizeof(DefinedData)]; alignas(DefinedData) char b[sizeof(DefinedData)];
alignas(DefinedGlobal) char C[sizeof(DefinedGlobal)]; alignas(DefinedGlobal) char c[sizeof(DefinedGlobal)];
alignas(DefinedEvent) char D[sizeof(DefinedEvent)]; alignas(DefinedEvent) char d[sizeof(DefinedEvent)];
alignas(LazySymbol) char E[sizeof(LazySymbol)]; alignas(LazySymbol) char e[sizeof(LazySymbol)];
alignas(UndefinedFunction) char F[sizeof(UndefinedFunction)]; alignas(UndefinedFunction) char f[sizeof(UndefinedFunction)];
alignas(UndefinedData) char G[sizeof(UndefinedData)]; alignas(UndefinedData) char g[sizeof(UndefinedData)];
alignas(UndefinedGlobal) char H[sizeof(UndefinedGlobal)]; alignas(UndefinedGlobal) char h[sizeof(UndefinedGlobal)];
alignas(SectionSymbol) char I[sizeof(SectionSymbol)]; alignas(SectionSymbol) char i[sizeof(SectionSymbol)];
}; };
// It is important to keep the size of SymbolUnion small for performance and // It is important to keep the size of SymbolUnion small for performance and
// memory usage reasons. 96 bytes is a soft limit based on the size of // memory usage reasons. 96 bytes is a soft limit based on the size of
// UndefinedFunction on a 64-bit system. // UndefinedFunction on a 64-bit system.
static_assert(sizeof(SymbolUnion) <= 96, "SymbolUnion too large"); static_assert(sizeof(SymbolUnion) <= 96, "SymbolUnion too large");
void printTraceSymbol(Symbol *Sym); void printTraceSymbol(Symbol *sym);
void printTraceSymbolUndefined(StringRef Name, const InputFile* File); void printTraceSymbolUndefined(StringRef name, const InputFile* file);
template <typename T, typename... ArgT> template <typename T, typename... ArgT>
T *replaceSymbol(Symbol *S, ArgT &&... Arg) { T *replaceSymbol(Symbol *s, ArgT &&... arg) {
static_assert(std::is_trivially_destructible<T>(), static_assert(std::is_trivially_destructible<T>(),
"Symbol types must be trivially destructible"); "Symbol types must be trivially destructible");
static_assert(sizeof(T) <= sizeof(SymbolUnion), "SymbolUnion too small"); static_assert(sizeof(T) <= sizeof(SymbolUnion), "SymbolUnion too small");
static_assert(alignof(T) <= alignof(SymbolUnion), static_assert(alignof(T) <= alignof(SymbolUnion),
"SymbolUnion not aligned enough"); "SymbolUnion not aligned enough");
assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr && assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr &&
"Not a Symbol"); "Not a Symbol");
Symbol SymCopy = *S; Symbol symCopy = *s;
T *S2 = new (S) T(std::forward<ArgT>(Arg)...); T *s2 = new (s) T(std::forward<ArgT>(arg)...);
S2->IsUsedInRegularObj = SymCopy.IsUsedInRegularObj; s2->isUsedInRegularObj = symCopy.isUsedInRegularObj;
S2->ForceExport = SymCopy.ForceExport; s2->forceExport = symCopy.forceExport;
S2->CanInline = SymCopy.CanInline; s2->canInline = symCopy.canInline;
S2->Traced = SymCopy.Traced; s2->traced = symCopy.traced;
// Print out a log message if --trace-symbol was specified. // Print out a log message if --trace-symbol was specified.
// This is for debugging. // This is for debugging.
if (S2->Traced) if (s2->traced)
printTraceSymbol(S2); printTraceSymbol(s2);
return S2; return s2;
} }
} // namespace wasm } // namespace wasm
// Returns a symbol name for an error message. // Returns a symbol name for an error message.
std::string toString(const wasm::Symbol &Sym); std::string toString(const wasm::Symbol &sym);
std::string toString(wasm::Symbol::Kind Kind); std::string toString(wasm::Symbol::Kind kind);
std::string maybeDemangleSymbol(StringRef Name); std::string maybeDemangleSymbol(StringRef name);
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/wasm/Symbols.cpp

Show All 18 Lines
#define DEBUG_TYPE "lld" #define DEBUG_TYPE "lld"
using namespace llvm; using namespace llvm;
using namespace llvm::wasm; using namespace llvm::wasm;
using namespace lld; using namespace lld;
using namespace lld::wasm; using namespace lld::wasm;
DefinedFunction *WasmSym::CallCtors; DefinedFunction *WasmSym::callCtors;
DefinedFunction *WasmSym::InitMemory; DefinedFunction *WasmSym::initMemory;
DefinedFunction *WasmSym::ApplyRelocs; DefinedFunction *WasmSym::applyRelocs;
DefinedData *WasmSym::DsoHandle; DefinedData *WasmSym::dsoHandle;
DefinedData *WasmSym::DataEnd; DefinedData *WasmSym::dataEnd;
DefinedData *WasmSym::GlobalBase; DefinedData *WasmSym::globalBase;
DefinedData *WasmSym::HeapBase; DefinedData *WasmSym::heapBase;
GlobalSymbol *WasmSym::StackPointer; GlobalSymbol *WasmSym::stackPointer;
UndefinedGlobal *WasmSym::TableBase; UndefinedGlobal *WasmSym::tableBase;
UndefinedGlobal *WasmSym::MemoryBase; UndefinedGlobal *WasmSym::memoryBase;
WasmSymbolType Symbol::getWasmType() const { WasmSymbolType Symbol::getWasmType() const {
if (isa<FunctionSymbol>(this)) if (isa<FunctionSymbol>(this))
return WASM_SYMBOL_TYPE_FUNCTION; return WASM_SYMBOL_TYPE_FUNCTION;
if (isa<DataSymbol>(this)) if (isa<DataSymbol>(this))
return WASM_SYMBOL_TYPE_DATA; return WASM_SYMBOL_TYPE_DATA;
if (isa<GlobalSymbol>(this)) if (isa<GlobalSymbol>(this))
return WASM_SYMBOL_TYPE_GLOBAL; return WASM_SYMBOL_TYPE_GLOBAL;
if (isa<EventSymbol>(this)) if (isa<EventSymbol>(this))
return WASM_SYMBOL_TYPE_EVENT; return WASM_SYMBOL_TYPE_EVENT;
if (isa<SectionSymbol>(this) || isa<OutputSectionSymbol>(this)) if (isa<SectionSymbol>(this) || isa<OutputSectionSymbol>(this))
return WASM_SYMBOL_TYPE_SECTION; return WASM_SYMBOL_TYPE_SECTION;
llvm_unreachable("invalid symbol kind"); llvm_unreachable("invalid symbol kind");
} }
const WasmSignature *Symbol::getSignature() const { const WasmSignature *Symbol::getSignature() const {
if (auto* F = dyn_cast<FunctionSymbol>(this)) if (auto* f = dyn_cast<FunctionSymbol>(this))
return F->Signature; return f->signature;
if (auto *L = dyn_cast<LazySymbol>(this)) if (auto *l = dyn_cast<LazySymbol>(this))
return L->Signature; return l->signature;
return nullptr; return nullptr;
} }
InputChunk *Symbol::getChunk() const { InputChunk *Symbol::getChunk() const {
if (auto *F = dyn_cast<DefinedFunction>(this)) if (auto *f = dyn_cast<DefinedFunction>(this))
return F->Function; return f->function;
if (auto *D = dyn_cast<DefinedData>(this)) if (auto *d = dyn_cast<DefinedData>(this))
return D->Segment; return d->segment;
return nullptr; return nullptr;
} }
bool Symbol::isDiscarded() const { bool Symbol::isDiscarded() const {
if (InputChunk *C = getChunk()) if (InputChunk *c = getChunk())
return C->Discarded; return c->discarded;
return false; return false;
} }
bool Symbol::isLive() const { bool Symbol::isLive() const {
if (auto *G = dyn_cast<DefinedGlobal>(this)) if (auto *g = dyn_cast<DefinedGlobal>(this))
return G->Global->Live; return g->global->live;
if (auto *E = dyn_cast<DefinedEvent>(this)) if (auto *e = dyn_cast<DefinedEvent>(this))
return E->Event->Live; return e->event->live;
if (InputChunk *C = getChunk()) if (InputChunk *c = getChunk())
return C->Live; return c->live;
return Referenced; return referenced;
} }
void Symbol::markLive() { void Symbol::markLive() {
assert(!isDiscarded()); assert(!isDiscarded());
if (auto *G = dyn_cast<DefinedGlobal>(this)) if (auto *g = dyn_cast<DefinedGlobal>(this))
G->Global->Live = true; g->global->live = true;
if (auto *E = dyn_cast<DefinedEvent>(this)) if (auto *e = dyn_cast<DefinedEvent>(this))
E->Event->Live = true; e->event->live = true;
if (InputChunk *C = getChunk()) if (InputChunk *c = getChunk())
C->Live = true; c->live = true;
Referenced = true; referenced = true;
} }
uint32_t Symbol::getOutputSymbolIndex() const { uint32_t Symbol::getOutputSymbolIndex() const {
assert(OutputSymbolIndex != INVALID_INDEX); assert(outputSymbolIndex != INVALID_INDEX);
return OutputSymbolIndex; return outputSymbolIndex;
} }
void Symbol::setOutputSymbolIndex(uint32_t Index) { void Symbol::setOutputSymbolIndex(uint32_t index) {
LLVM_DEBUG(dbgs() << "setOutputSymbolIndex " << Name << " -> " << Index LLVM_DEBUG(dbgs() << "setOutputSymbolIndex " << name << " -> " << index
<< "\n"); << "\n");
assert(OutputSymbolIndex == INVALID_INDEX); assert(outputSymbolIndex == INVALID_INDEX);
OutputSymbolIndex = Index; outputSymbolIndex = index;
} }
void Symbol::setGOTIndex(uint32_t Index) { void Symbol::setGOTIndex(uint32_t index) {
LLVM_DEBUG(dbgs() << "setGOTIndex " << Name << " -> " << Index << "\n"); LLVM_DEBUG(dbgs() << "setGOTIndex " << name << " -> " << index << "\n");
assert(GOTIndex == INVALID_INDEX); assert(gotIndex == INVALID_INDEX);
// Any symbol that is assigned a GOT entry must be exported othewise the // Any symbol that is assigned a GOT entry must be exported othewise the
// dynamic linker won't be able create the entry that contains it. // dynamic linker won't be able create the entry that contains it.
ForceExport = true; forceExport = true;
GOTIndex = Index; gotIndex = index;
} }
bool Symbol::isWeak() const { bool Symbol::isWeak() const {
return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK; return (flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK;
} }
bool Symbol::isLocal() const { bool Symbol::isLocal() const {
return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_LOCAL; return (flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_LOCAL;
} }
bool Symbol::isHidden() const { bool Symbol::isHidden() const {
return (Flags & WASM_SYMBOL_VISIBILITY_MASK) == WASM_SYMBOL_VISIBILITY_HIDDEN; return (flags & WASM_SYMBOL_VISIBILITY_MASK) == WASM_SYMBOL_VISIBILITY_HIDDEN;
} }
void Symbol::setHidden(bool IsHidden) { void Symbol::setHidden(bool isHidden) {
LLVM_DEBUG(dbgs() << "setHidden: " << Name << " -> " << IsHidden << "\n"); LLVM_DEBUG(dbgs() << "setHidden: " << name << " -> " << isHidden << "\n");
Flags &= ~WASM_SYMBOL_VISIBILITY_MASK; flags &= ~WASM_SYMBOL_VISIBILITY_MASK;
if (IsHidden) if (isHidden)
Flags |= WASM_SYMBOL_VISIBILITY_HIDDEN; flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
else else
Flags |= WASM_SYMBOL_VISIBILITY_DEFAULT; flags |= WASM_SYMBOL_VISIBILITY_DEFAULT;
} }
bool Symbol::isExported() const { bool Symbol::isExported() const {
if (!isDefined() || isLocal()) if (!isDefined() || isLocal())
return false; return false;
if (ForceExport || Config->ExportAll) if (forceExport || config->exportAll)
return true; return true;
if (Config->ExportDynamic && !isHidden()) if (config->exportDynamic && !isHidden())
return true; return true;
return Flags & WASM_SYMBOL_EXPORTED; return flags & WASM_SYMBOL_EXPORTED;
} }
uint32_t FunctionSymbol::getFunctionIndex() const { uint32_t FunctionSymbol::getFunctionIndex() const {
if (auto *F = dyn_cast<DefinedFunction>(this)) if (auto *f = dyn_cast<DefinedFunction>(this))
return F->Function->getFunctionIndex(); return f->function->getFunctionIndex();
assert(FunctionIndex != INVALID_INDEX); assert(functionIndex != INVALID_INDEX);
return FunctionIndex; return functionIndex;
} }
void FunctionSymbol::setFunctionIndex(uint32_t Index) { void FunctionSymbol::setFunctionIndex(uint32_t index) {
LLVM_DEBUG(dbgs() << "setFunctionIndex " << Name << " -> " << Index << "\n"); LLVM_DEBUG(dbgs() << "setFunctionIndex " << name << " -> " << index << "\n");
assert(FunctionIndex == INVALID_INDEX); assert(functionIndex == INVALID_INDEX);
FunctionIndex = Index; functionIndex = index;
} }
bool FunctionSymbol::hasFunctionIndex() const { bool FunctionSymbol::hasFunctionIndex() const {
if (auto *F = dyn_cast<DefinedFunction>(this)) if (auto *f = dyn_cast<DefinedFunction>(this))
return F->Function->hasFunctionIndex(); return f->function->hasFunctionIndex();
return FunctionIndex != INVALID_INDEX; return functionIndex != INVALID_INDEX;
} }
uint32_t FunctionSymbol::getTableIndex() const { uint32_t FunctionSymbol::getTableIndex() const {
if (auto *F = dyn_cast<DefinedFunction>(this)) if (auto *f = dyn_cast<DefinedFunction>(this))
return F->Function->getTableIndex(); return f->function->getTableIndex();
assert(TableIndex != INVALID_INDEX); assert(tableIndex != INVALID_INDEX);
return TableIndex; return tableIndex;
} }
bool FunctionSymbol::hasTableIndex() const { bool FunctionSymbol::hasTableIndex() const {
if (auto *F = dyn_cast<DefinedFunction>(this)) if (auto *f = dyn_cast<DefinedFunction>(this))
return F->Function->hasTableIndex(); return f->function->hasTableIndex();
return TableIndex != INVALID_INDEX; return tableIndex != INVALID_INDEX;
} }
void FunctionSymbol::setTableIndex(uint32_t Index) { void FunctionSymbol::setTableIndex(uint32_t index) {
// For imports, we set the table index here on the Symbol; for defined // For imports, we set the table index here on the Symbol; for defined
// functions we set the index on the InputFunction so that we don't export // functions we set the index on the InputFunction so that we don't export
// the same thing twice (keeps the table size down). // the same thing twice (keeps the table size down).
if (auto *F = dyn_cast<DefinedFunction>(this)) { if (auto *f = dyn_cast<DefinedFunction>(this)) {
F->Function->setTableIndex(Index); f->function->setTableIndex(index);
return; return;
} }
LLVM_DEBUG(dbgs() << "setTableIndex " << Name << " -> " << Index << "\n"); LLVM_DEBUG(dbgs() << "setTableIndex " << name << " -> " << index << "\n");
assert(TableIndex == INVALID_INDEX); assert(tableIndex == INVALID_INDEX);
TableIndex = Index; tableIndex = index;
} }
DefinedFunction::DefinedFunction(StringRef Name, uint32_t Flags, InputFile *F, DefinedFunction::DefinedFunction(StringRef name, uint32_t flags, InputFile *f,
InputFunction *Function) InputFunction *function)
: FunctionSymbol(Name, DefinedFunctionKind, Flags, F, : FunctionSymbol(name, DefinedFunctionKind, flags, f,
Function ? &Function->Signature : nullptr), function ? &function->signature : nullptr),
Function(Function) {} function(function) {}
uint32_t DefinedData::getVirtualAddress() const { uint32_t DefinedData::getVirtualAddress() const {
LLVM_DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n"); LLVM_DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
if (Segment) if (segment)
return Segment->OutputSeg->StartVA + Segment->OutputSegmentOffset + Offset; return segment->outputSeg->startVA + segment->outputSegmentOffset + offset;
return Offset; return offset;
} }
void DefinedData::setVirtualAddress(uint32_t Value) { void DefinedData::setVirtualAddress(uint32_t value) {
LLVM_DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n"); LLVM_DEBUG(dbgs() << "setVirtualAddress " << name << " -> " << value << "\n");
assert(!Segment); assert(!segment);
Offset = Value; offset = value;
} }
uint32_t DefinedData::getOutputSegmentOffset() const { uint32_t DefinedData::getOutputSegmentOffset() const {
LLVM_DEBUG(dbgs() << "getOutputSegmentOffset: " << getName() << "\n"); LLVM_DEBUG(dbgs() << "getOutputSegmentOffset: " << getName() << "\n");
return Segment->OutputSegmentOffset + Offset; return segment->outputSegmentOffset + offset;
} }
uint32_t DefinedData::getOutputSegmentIndex() const { uint32_t DefinedData::getOutputSegmentIndex() const {
LLVM_DEBUG(dbgs() << "getOutputSegmentIndex: " << getName() << "\n"); LLVM_DEBUG(dbgs() << "getOutputSegmentIndex: " << getName() << "\n");
return Segment->OutputSeg->Index; return segment->outputSeg->index;
} }
uint32_t GlobalSymbol::getGlobalIndex() const { uint32_t GlobalSymbol::getGlobalIndex() const {
if (auto *F = dyn_cast<DefinedGlobal>(this)) if (auto *f = dyn_cast<DefinedGlobal>(this))
return F->Global->getGlobalIndex(); return f->global->getGlobalIndex();
assert(GlobalIndex != INVALID_INDEX); assert(globalIndex != INVALID_INDEX);
return GlobalIndex; return globalIndex;
} }
void GlobalSymbol::setGlobalIndex(uint32_t Index) { void GlobalSymbol::setGlobalIndex(uint32_t index) {
LLVM_DEBUG(dbgs() << "setGlobalIndex " << Name << " -> " << Index << "\n"); LLVM_DEBUG(dbgs() << "setGlobalIndex " << name << " -> " << index << "\n");
assert(GlobalIndex == INVALID_INDEX); assert(globalIndex == INVALID_INDEX);
GlobalIndex = Index; globalIndex = index;
} }
bool GlobalSymbol::hasGlobalIndex() const { bool GlobalSymbol::hasGlobalIndex() const {
if (auto *F = dyn_cast<DefinedGlobal>(this)) if (auto *f = dyn_cast<DefinedGlobal>(this))
return F->Global->hasGlobalIndex(); return f->global->hasGlobalIndex();
return GlobalIndex != INVALID_INDEX; return globalIndex != INVALID_INDEX;
} }
DefinedGlobal::DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File, DefinedGlobal::DefinedGlobal(StringRef name, uint32_t flags, InputFile *file,
InputGlobal *Global) InputGlobal *global)
: GlobalSymbol(Name, DefinedGlobalKind, Flags, File, : GlobalSymbol(name, DefinedGlobalKind, flags, file,
Global ? &Global->getType() : nullptr), global ? &global->getType() : nullptr),
Global(Global) {} global(global) {}
uint32_t EventSymbol::getEventIndex() const { uint32_t EventSymbol::getEventIndex() const {
if (auto *F = dyn_cast<DefinedEvent>(this)) if (auto *f = dyn_cast<DefinedEvent>(this))
return F->Event->getEventIndex(); return f->event->getEventIndex();
assert(EventIndex != INVALID_INDEX); assert(eventIndex != INVALID_INDEX);
return EventIndex; return eventIndex;
} }
void EventSymbol::setEventIndex(uint32_t Index) { void EventSymbol::setEventIndex(uint32_t index) {
LLVM_DEBUG(dbgs() << "setEventIndex " << Name << " -> " << Index << "\n"); LLVM_DEBUG(dbgs() << "setEventIndex " << name << " -> " << index << "\n");
assert(EventIndex == INVALID_INDEX); assert(eventIndex == INVALID_INDEX);
EventIndex = Index; eventIndex = index;
} }
bool EventSymbol::hasEventIndex() const { bool EventSymbol::hasEventIndex() const {
if (auto *F = dyn_cast<DefinedEvent>(this)) if (auto *f = dyn_cast<DefinedEvent>(this))
return F->Event->hasEventIndex(); return f->event->hasEventIndex();
return EventIndex != INVALID_INDEX; return eventIndex != INVALID_INDEX;
} }
DefinedEvent::DefinedEvent(StringRef Name, uint32_t Flags, InputFile *File, DefinedEvent::DefinedEvent(StringRef name, uint32_t flags, InputFile *file,
InputEvent *Event) InputEvent *event)
: EventSymbol(Name, DefinedEventKind, Flags, File, : EventSymbol(name, DefinedEventKind, flags, file,
Event ? &Event->getType() : nullptr, event ? &event->getType() : nullptr,
Event ? &Event->Signature : nullptr), event ? &event->signature : nullptr),
Event(Event) {} event(event) {}
const OutputSectionSymbol *SectionSymbol::getOutputSectionSymbol() const { const OutputSectionSymbol *SectionSymbol::getOutputSectionSymbol() const {
assert(Section->OutputSec && Section->OutputSec->SectionSym); assert(section->outputSec && section->outputSec->sectionSym);
return Section->OutputSec->SectionSym; return section->outputSec->sectionSym;
} }
void LazySymbol::fetch() { cast<ArchiveFile>(File)->addMember(&ArchiveSymbol); } void LazySymbol::fetch() { cast<ArchiveFile>(file)->addMember(&archiveSymbol); }
std::string lld::toString(const wasm::Symbol &Sym) { std::string lld::toString(const wasm::Symbol &sym) {
return lld::maybeDemangleSymbol(Sym.getName()); return lld::maybeDemangleSymbol(sym.getName());
} }
std::string lld::maybeDemangleSymbol(StringRef Name) { std::string lld::maybeDemangleSymbol(StringRef name) {
if (Config->Demangle) if (config->demangle)
if (Optional<std::string> S = demangleItanium(Name)) if (Optional<std::string> s = demangleItanium(name))
return *S; return *s;
return Name; return name;
} }
std::string lld::toString(wasm::Symbol::Kind Kind) { std::string lld::toString(wasm::Symbol::Kind kind) {
switch (Kind) { switch (kind) {
case wasm::Symbol::DefinedFunctionKind: case wasm::Symbol::DefinedFunctionKind:
return "DefinedFunction"; return "DefinedFunction";
case wasm::Symbol::DefinedDataKind: case wasm::Symbol::DefinedDataKind:
return "DefinedData"; return "DefinedData";
case wasm::Symbol::DefinedGlobalKind: case wasm::Symbol::DefinedGlobalKind:
return "DefinedGlobal"; return "DefinedGlobal";
case wasm::Symbol::DefinedEventKind: case wasm::Symbol::DefinedEventKind:
return "DefinedEvent"; return "DefinedEvent";
Show All 9 Lines case wasm::Symbol::SectionKind:
return "SectionKind"; return "SectionKind";
case wasm::Symbol::OutputSectionKind: case wasm::Symbol::OutputSectionKind:
return "OutputSectionKind"; return "OutputSectionKind";
} }
llvm_unreachable("invalid symbol kind"); llvm_unreachable("invalid symbol kind");
} }
void lld::wasm::printTraceSymbolUndefined(StringRef Name, const InputFile* File) { void lld::wasm::printTraceSymbolUndefined(StringRef name, const InputFile* file) {
message(toString(File) + ": reference to " + Name); message(toString(file) + ": reference to " + name);
} }
// Print out a log message for --trace-symbol. // Print out a log message for --trace-symbol.
void lld::wasm::printTraceSymbol(Symbol *Sym) { void lld::wasm::printTraceSymbol(Symbol *sym) {
// Undefined symbols are traced via printTraceSymbolUndefined // Undefined symbols are traced via printTraceSymbolUndefined
if (Sym->isUndefined()) if (sym->isUndefined())
return; return;
std::string S; std::string s;
if (Sym->isLazy()) if (sym->isLazy())
S = ": lazy definition of "; s = ": lazy definition of ";
else else
S = ": definition of "; s = ": definition of ";
message(toString(Sym->getFile()) + S + Sym->getName()); message(toString(sym->getFile()) + s + sym->getName());
} }
const char *lld::wasm::DefaultModule = "env"; const char *lld::wasm::defaultModule = "env";
const char *lld::wasm::FunctionTableName = "__indirect_function_table"; const char *lld::wasm::functionTableName = "__indirect_function_table";

lld/trunk/wasm/SyntheticSections.h

Show All 23 Lines
#define DEBUG_TYPE "lld" #define DEBUG_TYPE "lld"
namespace lld { namespace lld {
namespace wasm { namespace wasm {
// An init entry to be written to either the synthetic init func or the // An init entry to be written to either the synthetic init func or the
// linking metadata. // linking metadata.
struct WasmInitEntry { struct WasmInitEntry {
const FunctionSymbol *Sym; const FunctionSymbol *sym;
uint32_t Priority; uint32_t priority;
}; };
class SyntheticSection : public OutputSection { class SyntheticSection : public OutputSection {
public: public:
SyntheticSection(uint32_t Type, std::string Name = "") SyntheticSection(uint32_t type, std::string name = "")
: OutputSection(Type, Name), BodyOutputStream(Body) { : OutputSection(type, name), bodyOutputStream(body) {
if (!Name.empty()) if (!name.empty())
writeStr(BodyOutputStream, Name, "section name"); writeStr(bodyOutputStream, name, "section name");
} }
void writeTo(uint8_t *Buf) override { void writeTo(uint8_t *buf) override {
assert(Offset); assert(offset);
log("writing " + toString(*this)); log("writing " + toString(*this));
memcpy(Buf + Offset, Header.data(), Header.size()); memcpy(buf + offset, header.data(), header.size());
memcpy(Buf + Offset + Header.size(), Body.data(), Body.size()); memcpy(buf + offset + header.size(), body.data(), body.size());
} }
size_t getSize() const override { return Header.size() + Body.size(); } size_t getSize() const override { return header.size() + body.size(); }
virtual void writeBody() {} virtual void writeBody() {}
void finalizeContents() override { void finalizeContents() override {
writeBody(); writeBody();
BodyOutputStream.flush(); bodyOutputStream.flush();
createHeader(Body.size()); createHeader(body.size());
} }
raw_ostream &getStream() { return BodyOutputStream; } raw_ostream &getStream() { return bodyOutputStream; }
std::string Body; std::string body;
protected: protected:
llvm::raw_string_ostream BodyOutputStream; llvm::raw_string_ostream bodyOutputStream;
}; };
// Create the custom "dylink" section containing information for the dynamic // Create the custom "dylink" section containing information for the dynamic
// linker. // linker.
// See // See
// https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md // https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
class DylinkSection : public SyntheticSection { class DylinkSection : public SyntheticSection {
public: public:
DylinkSection() : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "dylink") {} DylinkSection() : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "dylink") {}
bool isNeeded() const override { return Config->Pic; } bool isNeeded() const override { return config->isPic; }
void writeBody() override; void writeBody() override;
uint32_t MemAlign = 0; uint32_t memAlign = 0;
uint32_t MemSize = 0; uint32_t memSize = 0;
}; };
class TypeSection : public SyntheticSection { class TypeSection : public SyntheticSection {
public: public:
TypeSection() : SyntheticSection(llvm::wasm::WASM_SEC_TYPE) {} TypeSection() : SyntheticSection(llvm::wasm::WASM_SEC_TYPE) {}
bool isNeeded() const override { return Types.size() > 0; }; bool isNeeded() const override { return types.size() > 0; };
void writeBody() override; void writeBody() override;
uint32_t registerType(const WasmSignature &Sig); uint32_t registerType(const WasmSignature &sig);
uint32_t lookupType(const WasmSignature &Sig); uint32_t lookupType(const WasmSignature &sig);
protected: protected:
std::vector<const WasmSignature *> Types; std::vector<const WasmSignature *> types;
llvm::DenseMap<WasmSignature, int32_t> TypeIndices; llvm::DenseMap<WasmSignature, int32_t> typeIndices;
}; };
class ImportSection : public SyntheticSection { class ImportSection : public SyntheticSection {
public: public:
ImportSection() : SyntheticSection(llvm::wasm::WASM_SEC_IMPORT) {} ImportSection() : SyntheticSection(llvm::wasm::WASM_SEC_IMPORT) {}
bool isNeeded() const override { return getNumImports() > 0; } bool isNeeded() const override { return getNumImports() > 0; }
void writeBody() override; void writeBody() override;
void addImport(Symbol *Sym); void addImport(Symbol *sym);
void addGOTEntry(Symbol *Sym); void addGOTEntry(Symbol *sym);
void seal() { IsSealed = true; } void seal() { isSealed = true; }
uint32_t getNumImports() const; uint32_t getNumImports() const;
uint32_t getNumImportedGlobals() const { uint32_t getNumImportedGlobals() const {
assert(IsSealed); assert(isSealed);
return NumImportedGlobals; return numImportedGlobals;
} }
uint32_t getNumImportedFunctions() const { uint32_t getNumImportedFunctions() const {
assert(IsSealed); assert(isSealed);
return NumImportedFunctions; return numImportedFunctions;
} }
uint32_t getNumImportedEvents() const { uint32_t getNumImportedEvents() const {
assert(IsSealed); assert(isSealed);
return NumImportedEvents; return numImportedEvents;
} }
std::vector<const Symbol *> ImportedSymbols; std::vector<const Symbol *> importedSymbols;
protected: protected:
bool IsSealed = false; bool isSealed = false;
unsigned NumImportedGlobals = 0; unsigned numImportedGlobals = 0;
unsigned NumImportedFunctions = 0; unsigned numImportedFunctions = 0;
unsigned NumImportedEvents = 0; unsigned numImportedEvents = 0;
std::vector<const Symbol *> GOTSymbols; std::vector<const Symbol *> gotSymbols;
}; };
class FunctionSection : public SyntheticSection { class FunctionSection : public SyntheticSection {
public: public:
FunctionSection() : SyntheticSection(llvm::wasm::WASM_SEC_FUNCTION) {} FunctionSection() : SyntheticSection(llvm::wasm::WASM_SEC_FUNCTION) {}
bool isNeeded() const override { return InputFunctions.size() > 0; }; bool isNeeded() const override { return inputFunctions.size() > 0; };
void writeBody() override; void writeBody() override;
void addFunction(InputFunction *Func); void addFunction(InputFunction *func);
std::vector<InputFunction *> InputFunctions; std::vector<InputFunction *> inputFunctions;
protected: protected:
}; };
class MemorySection : public SyntheticSection { class MemorySection : public SyntheticSection {
public: public:
MemorySection() : SyntheticSection(llvm::wasm::WASM_SEC_MEMORY) {} MemorySection() : SyntheticSection(llvm::wasm::WASM_SEC_MEMORY) {}
bool isNeeded() const override { return !Config->ImportMemory; } bool isNeeded() const override { return !config->importMemory; }
void writeBody() override; void writeBody() override;
uint32_t NumMemoryPages = 0; uint32_t numMemoryPages = 0;
uint32_t MaxMemoryPages = 0; uint32_t maxMemoryPages = 0;
}; };
class TableSection : public SyntheticSection { class TableSection : public SyntheticSection {
public: public:
TableSection() : SyntheticSection(llvm::wasm::WASM_SEC_TABLE) {} TableSection() : SyntheticSection(llvm::wasm::WASM_SEC_TABLE) {}
bool isNeeded() const override { bool isNeeded() const override {
// Always output a table section (or table import), even if there are no // Always output a table section (or table import), even if there are no
// indirect calls. There are two reasons for this: // indirect calls. There are two reasons for this:
// 1. For executables it is useful to have an empty table slot at 0 // 1. For executables it is useful to have an empty table slot at 0
// which can be filled with a null function call handler. // which can be filled with a null function call handler.
// 2. If we don't do this, any program that contains a call_indirect but // 2. If we don't do this, any program that contains a call_indirect but
// no address-taken function will fail at validation time since it is // no address-taken function will fail at validation time since it is
// a validation error to include a call_indirect instruction if there // a validation error to include a call_indirect instruction if there
// is not table. // is not table.
return !Config->ImportTable; return !config->importTable;
} }
void writeBody() override; void writeBody() override;
}; };
class GlobalSection : public SyntheticSection { class GlobalSection : public SyntheticSection {
public: public:
GlobalSection() : SyntheticSection(llvm::wasm::WASM_SEC_GLOBAL) {} GlobalSection() : SyntheticSection(llvm::wasm::WASM_SEC_GLOBAL) {}
uint32_t numGlobals() const { uint32_t numGlobals() const {
return InputGlobals.size() + DefinedFakeGlobals.size(); return inputGlobals.size() + definedFakeGlobals.size();
} }
bool isNeeded() const override { return numGlobals() > 0; } bool isNeeded() const override { return numGlobals() > 0; }
void writeBody() override; void writeBody() override;
void addGlobal(InputGlobal *Global); void addGlobal(InputGlobal *global);
std::vector<const DefinedData *> DefinedFakeGlobals; std::vector<const DefinedData *> definedFakeGlobals;
std::vector<InputGlobal *> InputGlobals; std::vector<InputGlobal *> inputGlobals;
}; };
// The event section contains a list of declared wasm events associated with the // The event section contains a list of declared wasm events associated with the
// module. Currently the only supported event kind is exceptions. A single event // module. Currently the only supported event kind is exceptions. A single event
// entry represents a single event with an event tag. All C++ exceptions are // entry represents a single event with an event tag. All C++ exceptions are
// represented by a single event. An event entry in this section contains // represented by a single event. An event entry in this section contains
// information on what kind of event it is (e.g. exception) and the type of // information on what kind of event it is (e.g. exception) and the type of
// values contained in a single event object. (In wasm, an event can contain // values contained in a single event object. (In wasm, an event can contain
// multiple values of primitive types. But for C++ exceptions, we just throw a // multiple values of primitive types. But for C++ exceptions, we just throw a
// pointer which is an i32 value (for wasm32 architecture), so the signature of // pointer which is an i32 value (for wasm32 architecture), so the signature of
// C++ exception is (i32)->(void), because all event types are assumed to have // C++ exception is (i32)->(void), because all event types are assumed to have
// void return type to share WasmSignature with functions.) // void return type to share WasmSignature with functions.)
class EventSection : public SyntheticSection { class EventSection : public SyntheticSection {
public: public:
EventSection() : SyntheticSection(llvm::wasm::WASM_SEC_EVENT) {} EventSection() : SyntheticSection(llvm::wasm::WASM_SEC_EVENT) {}
void writeBody() override; void writeBody() override;
bool isNeeded() const override { return InputEvents.size() > 0; } bool isNeeded() const override { return inputEvents.size() > 0; }
void addEvent(InputEvent *Event); void addEvent(InputEvent *event);
std::vector<InputEvent *> InputEvents; std::vector<InputEvent *> inputEvents;
}; };
class ExportSection : public SyntheticSection { class ExportSection : public SyntheticSection {
public: public:
ExportSection() : SyntheticSection(llvm::wasm::WASM_SEC_EXPORT) {} ExportSection() : SyntheticSection(llvm::wasm::WASM_SEC_EXPORT) {}
bool isNeeded() const override { return Exports.size() > 0; } bool isNeeded() const override { return exports.size() > 0; }
void writeBody() override; void writeBody() override;
std::vector<llvm::wasm::WasmExport> Exports; std::vector<llvm::wasm::WasmExport> exports;
}; };
class ElemSection : public SyntheticSection { class ElemSection : public SyntheticSection {
public: public:
ElemSection(uint32_t Offset) ElemSection(uint32_t offset)
: SyntheticSection(llvm::wasm::WASM_SEC_ELEM), ElemOffset(Offset) {} : SyntheticSection(llvm::wasm::WASM_SEC_ELEM), elemOffset(offset) {}
bool isNeeded() const override { return IndirectFunctions.size() > 0; }; bool isNeeded() const override { return indirectFunctions.size() > 0; };
void writeBody() override; void writeBody() override;
void addEntry(FunctionSymbol *Sym); void addEntry(FunctionSymbol *sym);
uint32_t numEntries() const { return IndirectFunctions.size(); } uint32_t numEntries() const { return indirectFunctions.size(); }
uint32_t ElemOffset; uint32_t elemOffset;
protected: protected:
std::vector<const FunctionSymbol *> IndirectFunctions; std::vector<const FunctionSymbol *> indirectFunctions;
}; };
class DataCountSection : public SyntheticSection { class DataCountSection : public SyntheticSection {
public: public:
DataCountSection(uint32_t NumSegments) DataCountSection(uint32_t numSegments)
: SyntheticSection(llvm::wasm::WASM_SEC_DATACOUNT), : SyntheticSection(llvm::wasm::WASM_SEC_DATACOUNT),
NumSegments(NumSegments) {} numSegments(numSegments) {}
bool isNeeded() const override; bool isNeeded() const override;
void writeBody() override; void writeBody() override;
protected: protected:
uint32_t NumSegments; uint32_t numSegments;
}; };
// Create the custom "linking" section containing linker metadata. // Create the custom "linking" section containing linker metadata.
// This is only created when relocatable output is requested. // This is only created when relocatable output is requested.
class LinkingSection : public SyntheticSection { class LinkingSection : public SyntheticSection {
public: public:
LinkingSection(const std::vector<WasmInitEntry> &InitFunctions, LinkingSection(const std::vector<WasmInitEntry> &initFunctions,
const std::vector<OutputSegment *> &DataSegments) const std::vector<OutputSegment *> &dataSegments)
: SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "linking"), : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "linking"),
InitFunctions(InitFunctions), DataSegments(DataSegments) {} initFunctions(initFunctions), dataSegments(dataSegments) {}
bool isNeeded() const override { bool isNeeded() const override {
return Config->Relocatable || Config->EmitRelocs; return config->relocatable || config->emitRelocs;
} }
void writeBody() override; void writeBody() override;
void addToSymtab(Symbol *Sym); void addToSymtab(Symbol *sym);
protected: protected:
std::vector<const Symbol *> SymtabEntries; std::vector<const Symbol *> symtabEntries;
llvm::StringMap<uint32_t> SectionSymbolIndices; llvm::StringMap<uint32_t> sectionSymbolIndices;
const std::vector<WasmInitEntry> &InitFunctions; const std::vector<WasmInitEntry> &initFunctions;
const std::vector<OutputSegment *> &DataSegments; const std::vector<OutputSegment *> &dataSegments;
}; };
// Create the custom "name" section containing debug symbol names. // Create the custom "name" section containing debug symbol names.
class NameSection : public SyntheticSection { class NameSection : public SyntheticSection {
public: public:
NameSection() : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "name") {} NameSection() : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "name") {}
bool isNeeded() const override { bool isNeeded() const override {
return !Config->StripDebug && !Config->StripAll && numNames() > 0; return !config->stripDebug && !config->stripAll && numNames() > 0;
} }
void writeBody() override; void writeBody() override;
unsigned numNames() const; unsigned numNames() const;
}; };
class ProducersSection : public SyntheticSection { class ProducersSection : public SyntheticSection {
public: public:
ProducersSection() ProducersSection()
: SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "producers") {} : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "producers") {}
bool isNeeded() const override { bool isNeeded() const override {
return !Config->StripAll && fieldCount() > 0; return !config->stripAll && fieldCount() > 0;
} }
void writeBody() override; void writeBody() override;
void addInfo(const llvm::wasm::WasmProducerInfo &Info); void addInfo(const llvm::wasm::WasmProducerInfo &info);
protected: protected:
int fieldCount() const { int fieldCount() const {
return int(!Languages.empty()) + int(!Tools.empty()) + int(!SDKs.empty()); return int(!languages.empty()) + int(!tools.empty()) + int(!sDKs.empty());
} }
SmallVector<std::pair<std::string, std::string>, 8> Languages; SmallVector<std::pair<std::string, std::string>, 8> languages;
SmallVector<std::pair<std::string, std::string>, 8> Tools; SmallVector<std::pair<std::string, std::string>, 8> tools;
SmallVector<std::pair<std::string, std::string>, 8> SDKs; SmallVector<std::pair<std::string, std::string>, 8> sDKs;
}; };
class TargetFeaturesSection : public SyntheticSection { class TargetFeaturesSection : public SyntheticSection {
public: public:
TargetFeaturesSection() TargetFeaturesSection()
: SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "target_features") {} : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "target_features") {}
bool isNeeded() const override { bool isNeeded() const override {
return !Config->StripAll && Features.size() > 0; return !config->stripAll && features.size() > 0;
} }
void writeBody() override; void writeBody() override;
llvm::SmallSet<std::string, 8> Features; llvm::SmallSet<std::string, 8> features;
}; };
class RelocSection : public SyntheticSection { class RelocSection : public SyntheticSection {
public: public:
RelocSection(StringRef Name, OutputSection *Sec) RelocSection(StringRef name, OutputSection *sec)
: SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, Name), Sec(Sec) {} : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, name), sec(sec) {}
void writeBody() override; void writeBody() override;
bool isNeeded() const override { return Sec->getNumRelocations() > 0; }; bool isNeeded() const override { return sec->getNumRelocations() > 0; };
protected: protected:
OutputSection *Sec; OutputSection *sec;
}; };
// Linker generated output sections // Linker generated output sections
struct OutStruct { struct OutStruct {
DylinkSection *DylinkSec; DylinkSection *dylinkSec;
TypeSection *TypeSec; TypeSection *typeSec;
FunctionSection *FunctionSec; FunctionSection *functionSec;
ImportSection *ImportSec; ImportSection *importSec;
TableSection *TableSec; TableSection *tableSec;
MemorySection *MemorySec; MemorySection *memorySec;
GlobalSection *GlobalSec; GlobalSection *globalSec;
EventSection *EventSec; EventSection *eventSec;
ExportSection *ExportSec; ExportSection *exportSec;
ElemSection *ElemSec; ElemSection *elemSec;
DataCountSection *DataCountSec; DataCountSection *dataCountSec;
LinkingSection *LinkingSec; LinkingSection *linkingSec;
NameSection *NameSec; NameSection *nameSec;
ProducersSection *ProducersSec; ProducersSection *producersSec;
TargetFeaturesSection *TargetFeaturesSec; TargetFeaturesSection *targetFeaturesSec;
}; };
extern OutStruct Out; extern OutStruct out;
} // namespace wasm } // namespace wasm
} // namespace lld } // namespace lld
#endif #endif

lld/trunk/wasm/SyntheticSections.cpp

Show All 19 Lines
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
using namespace llvm; using namespace llvm;
using namespace llvm::wasm; using namespace llvm::wasm;
using namespace lld; using namespace lld;
using namespace lld::wasm; using namespace lld::wasm;
OutStruct lld::wasm::Out; OutStruct lld::wasm::out;
namespace { namespace {
// Some synthetic sections (e.g. "name" and "linking") have subsections. // Some synthetic sections (e.g. "name" and "linking") have subsections.
// Just like the synthetic sections themselves these need to be created before // Just like the synthetic sections themselves these need to be created before
// they can be written out (since they are preceded by their length). This // they can be written out (since they are preceded by their length). This
// class is used to create subsections and then write them into the stream // class is used to create subsections and then write them into the stream
// of the parent section. // of the parent section.
class SubSection { class SubSection {
public: public:
explicit SubSection(uint32_t Type) : Type(Type) {} explicit SubSection(uint32_t type) : type(type) {}
void writeTo(raw_ostream &To) { void writeTo(raw_ostream &to) {
OS.flush(); os.flush();
writeUleb128(To, Type, "subsection type"); writeUleb128(to, type, "subsection type");
writeUleb128(To, Body.size(), "subsection size"); writeUleb128(to, body.size(), "subsection size");
To.write(Body.data(), Body.size()); to.write(body.data(), body.size());
} }
private: private:
uint32_t Type; uint32_t type;
std::string Body; std::string body;
public: public:
raw_string_ostream OS{Body}; raw_string_ostream os{body};
}; };
} // namespace } // namespace
void DylinkSection::writeBody() { void DylinkSection::writeBody() {
raw_ostream &OS = BodyOutputStream; raw_ostream &os = bodyOutputStream;
writeUleb128(OS, MemSize, "MemSize"); writeUleb128(os, memSize, "MemSize");
writeUleb128(OS, MemAlign, "MemAlign"); writeUleb128(os, memAlign, "MemAlign");
writeUleb128(OS, Out.ElemSec->numEntries(), "TableSize"); writeUleb128(os, out.elemSec->numEntries(), "TableSize");
writeUleb128(OS, 0, "TableAlign"); writeUleb128(os, 0, "TableAlign");
writeUleb128(OS, Symtab->SharedFiles.size(), "Needed"); writeUleb128(os, symtab->sharedFiles.size(), "Needed");
for (auto *SO : Symtab->SharedFiles) for (auto *so : symtab->sharedFiles)
writeStr(OS, llvm::sys::path::filename(SO->getName()), "so name"); writeStr(os, llvm::sys::path::filename(so->getName()), "so name");
} }
uint32_t TypeSection::registerType(const WasmSignature &Sig) { uint32_t TypeSection::registerType(const WasmSignature &sig) {
auto Pair = TypeIndices.insert(std::make_pair(Sig, Types.size())); auto pair = typeIndices.insert(std::make_pair(sig, types.size()));
if (Pair.second) { if (pair.second) {
LLVM_DEBUG(llvm::dbgs() << "type " << toString(Sig) << "\n"); LLVM_DEBUG(llvm::dbgs() << "type " << toString(sig) << "\n");
Types.push_back(&Sig); types.push_back(&sig);
} }
return Pair.first->second; return pair.first->second;
} }
uint32_t TypeSection::lookupType(const WasmSignature &Sig) { uint32_t TypeSection::lookupType(const WasmSignature &sig) {
auto It = TypeIndices.find(Sig); auto it = typeIndices.find(sig);
if (It == TypeIndices.end()) { if (it == typeIndices.end()) {
error("type not found: " + toString(Sig)); error("type not found: " + toString(sig));
return 0; return 0;
} }
return It->second; return it->second;
} }
void TypeSection::writeBody() { void TypeSection::writeBody() {
writeUleb128(BodyOutputStream, Types.size(), "type count"); writeUleb128(bodyOutputStream, types.size(), "type count");
for (const WasmSignature *Sig : Types) for (const WasmSignature *sig : types)
writeSig(BodyOutputStream, *Sig); writeSig(bodyOutputStream, *sig);
} }
uint32_t ImportSection::getNumImports() const { uint32_t ImportSection::getNumImports() const {
assert(IsSealed); assert(isSealed);
uint32_t NumImports = ImportedSymbols.size() + GOTSymbols.size(); uint32_t numImports = importedSymbols.size() + gotSymbols.size();
if (Config->ImportMemory) if (config->importMemory)
++NumImports; ++numImports;
if (Config->ImportTable) if (config->importTable)
++NumImports; ++numImports;
return NumImports; return numImports;
} }
void ImportSection::addGOTEntry(Symbol *Sym) { void ImportSection::addGOTEntry(Symbol *sym) {
assert(!IsSealed); assert(!isSealed);
if (Sym->hasGOTIndex()) if (sym->hasGOTIndex())
return; return;
Sym->setGOTIndex(NumImportedGlobals++); sym->setGOTIndex(numImportedGlobals++);
GOTSymbols.push_back(Sym); gotSymbols.push_back(sym);
} }
void ImportSection::addImport(Symbol *Sym) { void ImportSection::addImport(Symbol *sym) {
assert(!IsSealed); assert(!isSealed);
ImportedSymbols.emplace_back(Sym); importedSymbols.emplace_back(sym);
if (auto *F = dyn_cast<FunctionSymbol>(Sym)) if (auto *f = dyn_cast<FunctionSymbol>(sym))
F->setFunctionIndex(NumImportedFunctions++); f->setFunctionIndex(numImportedFunctions++);
else if (auto *G = dyn_cast<GlobalSymbol>(Sym)) else if (auto *g = dyn_cast<GlobalSymbol>(sym))
G->setGlobalIndex(NumImportedGlobals++); g->setGlobalIndex(numImportedGlobals++);
else else
cast<EventSymbol>(Sym)->setEventIndex(NumImportedEvents++); cast<EventSymbol>(sym)->setEventIndex(numImportedEvents++);
} }
void ImportSection::writeBody() { void ImportSection::writeBody() {
raw_ostream &OS = BodyOutputStream; raw_ostream &os = bodyOutputStream;
writeUleb128(OS, getNumImports(), "import count"); writeUleb128(os, getNumImports(), "import count");
if (Config->ImportMemory) { if (config->importMemory) {
WasmImport Import; WasmImport import;
Import.Module = DefaultModule; import.Module = defaultModule;
Import.Field = "memory"; import.Field = "memory";
Import.Kind = WASM_EXTERNAL_MEMORY; import.Kind = WASM_EXTERNAL_MEMORY;
Import.Memory.Flags = 0; import.Memory.Flags = 0;
Import.Memory.Initial = Out.MemorySec->NumMemoryPages; import.Memory.Initial = out.memorySec->numMemoryPages;
if (Out.MemorySec->MaxMemoryPages != 0 || Config->SharedMemory) { if (out.memorySec->maxMemoryPages != 0 || config->sharedMemory) {
Import.Memory.Flags |= WASM_LIMITS_FLAG_HAS_MAX; import.Memory.Flags |= WASM_LIMITS_FLAG_HAS_MAX;
Import.Memory.Maximum = Out.MemorySec->MaxMemoryPages; import.Memory.Maximum = out.memorySec->maxMemoryPages;
} }
if (Config->SharedMemory) if (config->sharedMemory)
Import.Memory.Flags |= WASM_LIMITS_FLAG_IS_SHARED; import.Memory.Flags |= WASM_LIMITS_FLAG_IS_SHARED;
writeImport(OS, Import); writeImport(os, import);
} }
if (Config->ImportTable) { if (config->importTable) {
uint32_t TableSize = Out.ElemSec->ElemOffset + Out.ElemSec->numEntries(); uint32_t tableSize = out.elemSec->elemOffset + out.elemSec->numEntries();
WasmImport Import; WasmImport import;
Import.Module = DefaultModule; import.Module = defaultModule;
Import.Field = FunctionTableName; import.Field = functionTableName;
Import.Kind = WASM_EXTERNAL_TABLE; import.Kind = WASM_EXTERNAL_TABLE;
Import.Table.ElemType = WASM_TYPE_FUNCREF; import.Table.ElemType = WASM_TYPE_FUNCREF;
Import.Table.Limits = {0, TableSize, 0}; import.Table.Limits = {0, tableSize, 0};
writeImport(OS, Import); writeImport(os, import);
} }
for (const Symbol *Sym : ImportedSymbols) { for (const Symbol *sym : importedSymbols) {
WasmImport Import; WasmImport import;
if (auto *F = dyn_cast<UndefinedFunction>(Sym)) { if (auto *f = dyn_cast<UndefinedFunction>(sym)) {
Import.Field = F->ImportName; import.Field = f->importName;
Import.Module = F->ImportModule; import.Module = f->importModule;
} else if (auto *G = dyn_cast<UndefinedGlobal>(Sym)) { } else if (auto *g = dyn_cast<UndefinedGlobal>(sym)) {
Import.Field = G->ImportName; import.Field = g->importName;
Import.Module = G->ImportModule; import.Module = g->importModule;
} else { } else {
Import.Field = Sym->getName(); import.Field = sym->getName();
Import.Module = DefaultModule; import.Module = defaultModule;
} }
if (auto *FunctionSym = dyn_cast<FunctionSymbol>(Sym)) { if (auto *functionSym = dyn_cast<FunctionSymbol>(sym)) {
Import.Kind = WASM_EXTERNAL_FUNCTION; import.Kind = WASM_EXTERNAL_FUNCTION;
Import.SigIndex = Out.TypeSec->lookupType(*FunctionSym->Signature); import.SigIndex = out.typeSec->lookupType(*functionSym->signature);
} else if (auto *GlobalSym = dyn_cast<GlobalSymbol>(Sym)) { } else if (auto *globalSym = dyn_cast<GlobalSymbol>(sym)) {
Import.Kind = WASM_EXTERNAL_GLOBAL; import.Kind = WASM_EXTERNAL_GLOBAL;
Import.Global = *GlobalSym->getGlobalType(); import.Global = *globalSym->getGlobalType();
} else { } else {
auto *EventSym = cast<EventSymbol>(Sym); auto *eventSym = cast<EventSymbol>(sym);
Import.Kind = WASM_EXTERNAL_EVENT; import.Kind = WASM_EXTERNAL_EVENT;
Import.Event.Attribute = EventSym->getEventType()->Attribute; import.Event.Attribute = eventSym->getEventType()->Attribute;
Import.Event.SigIndex = Out.TypeSec->lookupType(*EventSym->Signature); import.Event.SigIndex = out.typeSec->lookupType(*eventSym->signature);
} }
writeImport(OS, Import); writeImport(os, import);
} }
for (const Symbol *Sym : GOTSymbols) { for (const Symbol *sym : gotSymbols) {
WasmImport Import; WasmImport import;
Import.Kind = WASM_EXTERNAL_GLOBAL; import.Kind = WASM_EXTERNAL_GLOBAL;
Import.Global = {WASM_TYPE_I32, true}; import.Global = {WASM_TYPE_I32, true};
if (isa<DataSymbol>(Sym)) if (isa<DataSymbol>(sym))
Import.Module = "GOT.mem"; import.Module = "GOT.mem";
else else
Import.Module = "GOT.func"; import.Module = "GOT.func";
Import.Field = Sym->getName(); import.Field = sym->getName();
writeImport(OS, Import); writeImport(os, import);
} }
} }
void FunctionSection::writeBody() { void FunctionSection::writeBody() {
raw_ostream &OS = BodyOutputStream; raw_ostream &os = bodyOutputStream;
writeUleb128(OS, InputFunctions.size(), "function count"); writeUleb128(os, inputFunctions.size(), "function count");
for (const InputFunction *Func : InputFunctions) for (const InputFunction *func : inputFunctions)
writeUleb128(OS, Out.TypeSec->lookupType(Func->Signature), "sig index"); writeUleb128(os, out.typeSec->lookupType(func->signature), "sig index");
} }
void FunctionSection::addFunction(InputFunction *Func) { void FunctionSection::addFunction(InputFunction *func) {
if (!Func->Live) if (!func->live)
return; return;
uint32_t FunctionIndex = uint32_t functionIndex =
Out.ImportSec->getNumImportedFunctions() + InputFunctions.size(); out.importSec->getNumImportedFunctions() + inputFunctions.size();
InputFunctions.emplace_back(Func); inputFunctions.emplace_back(func);
Func->setFunctionIndex(FunctionIndex); func->setFunctionIndex(functionIndex);
} }
void TableSection::writeBody() { void TableSection::writeBody() {
uint32_t TableSize = Out.ElemSec->ElemOffset + Out.ElemSec->numEntries(); uint32_t tableSize = out.elemSec->elemOffset + out.elemSec->numEntries();
raw_ostream &OS = BodyOutputStream; raw_ostream &os = bodyOutputStream;
writeUleb128(OS, 1, "table count"); writeUleb128(os, 1, "table count");
WasmLimits Limits = {WASM_LIMITS_FLAG_HAS_MAX, TableSize, TableSize}; WasmLimits limits = {WASM_LIMITS_FLAG_HAS_MAX, tableSize, tableSize};
writeTableType(OS, WasmTable{WASM_TYPE_FUNCREF, Limits}); writeTableType(os, WasmTable{WASM_TYPE_FUNCREF, limits});
} }
void MemorySection::writeBody() { void MemorySection::writeBody() {
raw_ostream &OS = BodyOutputStream; raw_ostream &os = bodyOutputStream;
bool HasMax = MaxMemoryPages != 0 || Config->SharedMemory; bool hasMax = maxMemoryPages != 0 || config->sharedMemory;
writeUleb128(OS, 1, "memory count"); writeUleb128(os, 1, "memory count");
unsigned Flags = 0; unsigned flags = 0;
if (HasMax) if (hasMax)
Flags |= WASM_LIMITS_FLAG_HAS_MAX; flags |= WASM_LIMITS_FLAG_HAS_MAX;
if (Config->SharedMemory) if (config->sharedMemory)
Flags |= WASM_LIMITS_FLAG_IS_SHARED; flags |= WASM_LIMITS_FLAG_IS_SHARED;
writeUleb128(OS, Flags, "memory limits flags"); writeUleb128(os, flags, "memory limits flags");
writeUleb128(OS, NumMemoryPages, "initial pages"); writeUleb128(os, numMemoryPages, "initial pages");
if (HasMax) if (hasMax)
writeUleb128(OS, MaxMemoryPages, "max pages"); writeUleb128(os, maxMemoryPages, "max pages");
} }
void GlobalSection::writeBody() { void GlobalSection::writeBody() {
raw_ostream &OS = BodyOutputStream; raw_ostream &os = bodyOutputStream;
writeUleb128(OS, numGlobals(), "global count"); writeUleb128(os, numGlobals(), "global count");
for (const InputGlobal *G : InputGlobals) for (const InputGlobal *g : inputGlobals)
writeGlobal(OS, G->Global); writeGlobal(os, g->global);
for (const DefinedData *Sym : DefinedFakeGlobals) { for (const DefinedData *sym : definedFakeGlobals) {
WasmGlobal Global; WasmGlobal global;
Global.Type = {WASM_TYPE_I32, false}; global.Type = {WASM_TYPE_I32, false};
Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST; global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
Global.InitExpr.Value.Int32 = Sym->getVirtualAddress(); global.InitExpr.Value.Int32 = sym->getVirtualAddress();
writeGlobal(OS, Global); writeGlobal(os, global);
} }
} }
void GlobalSection::addGlobal(InputGlobal *Global) { void GlobalSection::addGlobal(InputGlobal *global) {
if (!Global->Live) if (!global->live)
return; return;
uint32_t GlobalIndex = uint32_t globalIndex =
Out.ImportSec->getNumImportedGlobals() + InputGlobals.size(); out.importSec->getNumImportedGlobals() + inputGlobals.size();
LLVM_DEBUG(dbgs() << "addGlobal: " << GlobalIndex << "\n"); LLVM_DEBUG(dbgs() << "addGlobal: " << globalIndex << "\n");
Global->setGlobalIndex(GlobalIndex); global->setGlobalIndex(globalIndex);
Out.GlobalSec->InputGlobals.push_back(Global); out.globalSec->inputGlobals.push_back(global);
} }
void EventSection::writeBody() { void EventSection::writeBody() {
raw_ostream &OS = BodyOutputStream; raw_ostream &os = bodyOutputStream;
writeUleb128(OS, InputEvents.size(), "event count"); writeUleb128(os, inputEvents.size(), "event count");
for (InputEvent *E : InputEvents) { for (InputEvent *e : inputEvents) {
E->Event.Type.SigIndex = Out.TypeSec->lookupType(E->Signature); e->event.Type.SigIndex = out.typeSec->lookupType(e->signature);
writeEvent(OS, E->Event); writeEvent(os, e->event);
} }
} }
void EventSection::addEvent(InputEvent *Event) { void EventSection::addEvent(InputEvent *event) {
if (!Event->Live) if (!event->live)
return; return;
uint32_t EventIndex = uint32_t eventIndex =
Out.ImportSec->getNumImportedEvents() + InputEvents.size(); out.importSec->getNumImportedEvents() + inputEvents.size();
LLVM_DEBUG(dbgs() << "addEvent: " << EventIndex << "\n"); LLVM_DEBUG(dbgs() << "addEvent: " << eventIndex << "\n");
Event->setEventIndex(EventIndex); event->setEventIndex(eventIndex);
InputEvents.push_back(Event); inputEvents.push_back(event);
} }
void ExportSection::writeBody() { void ExportSection::writeBody() {
raw_ostream &OS = BodyOutputStream; raw_ostream &os = bodyOutputStream;
writeUleb128(OS, Exports.size(), "export count"); writeUleb128(os, exports.size(), "export count");
for (const WasmExport &Export : Exports) for (const WasmExport &export_ : exports)
writeExport(OS, Export); writeExport(os, export_);
} }
void ElemSection::addEntry(FunctionSymbol *Sym) { void ElemSection::addEntry(FunctionSymbol *sym) {
if (Sym->hasTableIndex()) if (sym->hasTableIndex())
return; return;
Sym->setTableIndex(ElemOffset + IndirectFunctions.size()); sym->setTableIndex(elemOffset + indirectFunctions.size());
IndirectFunctions.emplace_back(Sym); indirectFunctions.emplace_back(sym);
} }
void ElemSection::writeBody() { void ElemSection::writeBody() {
raw_ostream &OS = BodyOutputStream; raw_ostream &os = bodyOutputStream;
writeUleb128(OS, 1, "segment count"); writeUleb128(os, 1, "segment count");
writeUleb128(OS, 0, "table index"); writeUleb128(os, 0, "table index");
WasmInitExpr InitExpr; WasmInitExpr initExpr;
if (Config->Pic) { if (config->isPic) {
InitExpr.Opcode = WASM_OPCODE_GLOBAL_GET; initExpr.Opcode = WASM_OPCODE_GLOBAL_GET;
InitExpr.Value.Global = WasmSym::TableBase->getGlobalIndex(); initExpr.Value.Global = WasmSym::tableBase->getGlobalIndex();
} else { } else {
InitExpr.Opcode = WASM_OPCODE_I32_CONST; initExpr.Opcode = WASM_OPCODE_I32_CONST;
InitExpr.Value.Int32 = ElemOffset; initExpr.Value.Int32 = elemOffset;
} }
writeInitExpr(OS, InitExpr); writeInitExpr(os, initExpr);
writeUleb128(OS, IndirectFunctions.size(), "elem count"); writeUleb128(os, indirectFunctions.size(), "elem count");
uint32_t TableIndex = ElemOffset; uint32_t tableIndex = elemOffset;
for (const FunctionSymbol *Sym : IndirectFunctions) { for (const FunctionSymbol *sym : indirectFunctions) {
assert(Sym->getTableIndex() == TableIndex); assert(sym->getTableIndex() == tableIndex);
writeUleb128(OS, Sym->getFunctionIndex(), "function index"); writeUleb128(os, sym->getFunctionIndex(), "function index");
++TableIndex; ++tableIndex;
} }
} }
void DataCountSection::writeBody() { void DataCountSection::writeBody() {
writeUleb128(BodyOutputStream, NumSegments, "data count"); writeUleb128(bodyOutputStream, numSegments, "data count");
} }
bool DataCountSection::isNeeded() const { bool DataCountSection::isNeeded() const {
return NumSegments && Config->PassiveSegments; return numSegments && config->passiveSegments;
} }
static uint32_t getWasmFlags(const Symbol *Sym) { static uint32_t getWasmFlags(const Symbol *sym) {
uint32_t Flags = 0; uint32_t flags = 0;
if (Sym->isLocal()) if (sym->isLocal())
Flags |= WASM_SYMBOL_BINDING_LOCAL; flags |= WASM_SYMBOL_BINDING_LOCAL;
if (Sym->isWeak()) if (sym->isWeak())
Flags |= WASM_SYMBOL_BINDING_WEAK; flags |= WASM_SYMBOL_BINDING_WEAK;
if (Sym->isHidden()) if (sym->isHidden())
Flags |= WASM_SYMBOL_VISIBILITY_HIDDEN; flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
if (Sym->isUndefined()) if (sym->isUndefined())
Flags |= WASM_SYMBOL_UNDEFINED; flags |= WASM_SYMBOL_UNDEFINED;
if (auto *F = dyn_cast<UndefinedFunction>(Sym)) { if (auto *f = dyn_cast<UndefinedFunction>(sym)) {
if (F->getName() != F->ImportName) if (f->getName() != f->importName)
Flags |= WASM_SYMBOL_EXPLICIT_NAME; flags |= WASM_SYMBOL_EXPLICIT_NAME;
} else if (auto *G = dyn_cast<UndefinedGlobal>(Sym)) { } else if (auto *g = dyn_cast<UndefinedGlobal>(sym)) {
if (G->getName() != G->ImportName) if (g->getName() != g->importName)
Flags |= WASM_SYMBOL_EXPLICIT_NAME; flags |= WASM_SYMBOL_EXPLICIT_NAME;
} }
return Flags; return flags;
} }
void LinkingSection::writeBody() { void LinkingSection::writeBody() {
raw_ostream &OS = BodyOutputStream; raw_ostream &os = bodyOutputStream;
writeUleb128(OS, WasmMetadataVersion, "Version"); writeUleb128(os, WasmMetadataVersion, "Version");
if (!SymtabEntries.empty()) { if (!symtabEntries.empty()) {
SubSection Sub(WASM_SYMBOL_TABLE); SubSection sub(WASM_SYMBOL_TABLE);
writeUleb128(Sub.OS, SymtabEntries.size(), "num symbols"); writeUleb128(sub.os, symtabEntries.size(), "num symbols");
for (const Symbol *Sym : SymtabEntries) { for (const Symbol *sym : symtabEntries) {
assert(Sym->isDefined() || Sym->isUndefined()); assert(sym->isDefined() || sym->isUndefined());
WasmSymbolType Kind = Sym->getWasmType(); WasmSymbolType kind = sym->getWasmType();
uint32_t Flags = getWasmFlags(Sym); uint32_t flags = getWasmFlags(sym);
writeU8(Sub.OS, Kind, "sym kind"); writeU8(sub.os, kind, "sym kind");
writeUleb128(Sub.OS, Flags, "sym flags"); writeUleb128(sub.os, flags, "sym flags");
if (auto *F = dyn_cast<FunctionSymbol>(Sym)) { if (auto *f = dyn_cast<FunctionSymbol>(sym)) {
writeUleb128(Sub.OS, F->getFunctionIndex(), "index"); writeUleb128(sub.os, f->getFunctionIndex(), "index");
if (Sym->isDefined() || (Flags & WASM_SYMBOL_EXPLICIT_NAME) != 0) if (sym->isDefined() || (flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
writeStr(Sub.OS, Sym->getName(), "sym name"); writeStr(sub.os, sym->getName(), "sym name");
} else if (auto *G = dyn_cast<GlobalSymbol>(Sym)) { } else if (auto *g = dyn_cast<GlobalSymbol>(sym)) {
writeUleb128(Sub.OS, G->getGlobalIndex(), "index"); writeUleb128(sub.os, g->getGlobalIndex(), "index");
if (Sym->isDefined() || (Flags & WASM_SYMBOL_EXPLICIT_NAME) != 0) if (sym->isDefined() || (flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
writeStr(Sub.OS, Sym->getName(), "sym name"); writeStr(sub.os, sym->getName(), "sym name");
} else if (auto *E = dyn_cast<EventSymbol>(Sym)) { } else if (auto *e = dyn_cast<EventSymbol>(sym)) {
writeUleb128(Sub.OS, E->getEventIndex(), "index"); writeUleb128(sub.os, e->getEventIndex(), "index");
if (Sym->isDefined() || (Flags & WASM_SYMBOL_EXPLICIT_NAME) != 0) if (sym->isDefined() || (flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
writeStr(Sub.OS, Sym->getName(), "sym name"); writeStr(sub.os, sym->getName(), "sym name");
} else if (isa<DataSymbol>(Sym)) { } else if (isa<DataSymbol>(sym)) {
writeStr(Sub.OS, Sym->getName(), "sym name"); writeStr(sub.os, sym->getName(), "sym name");
if (auto *DataSym = dyn_cast<DefinedData>(Sym)) { if (auto *dataSym = dyn_cast<DefinedData>(sym)) {
writeUleb128(Sub.OS, DataSym->getOutputSegmentIndex(), "index"); writeUleb128(sub.os, dataSym->getOutputSegmentIndex(), "index");
writeUleb128(Sub.OS, DataSym->getOutputSegmentOffset(), writeUleb128(sub.os, dataSym->getOutputSegmentOffset(),
"data offset"); "data offset");
writeUleb128(Sub.OS, DataSym->getSize(), "data size"); writeUleb128(sub.os, dataSym->getSize(), "data size");
} }
} else { } else {
auto *S = cast<OutputSectionSymbol>(Sym); auto *s = cast<OutputSectionSymbol>(sym);
writeUleb128(Sub.OS, S->Section->SectionIndex, "sym section index"); writeUleb128(sub.os, s->section->sectionIndex, "sym section index");
} }
} }
Sub.writeTo(OS); sub.writeTo(os);
} }
if (DataSegments.size()) { if (dataSegments.size()) {
SubSection Sub(WASM_SEGMENT_INFO); SubSection sub(WASM_SEGMENT_INFO);
writeUleb128(Sub.OS, DataSegments.size(), "num data segments"); writeUleb128(sub.os, dataSegments.size(), "num data segments");
for (const OutputSegment *S : DataSegments) { for (const OutputSegment *s : dataSegments) {
writeStr(Sub.OS, S->Name, "segment name"); writeStr(sub.os, s->name, "segment name");
writeUleb128(Sub.OS, S->Alignment, "alignment"); writeUleb128(sub.os, s->alignment, "alignment");
writeUleb128(Sub.OS, 0, "flags"); writeUleb128(sub.os, 0, "flags");
} }
Sub.writeTo(OS); sub.writeTo(os);
} }
if (!InitFunctions.empty()) { if (!initFunctions.empty()) {
SubSection Sub(WASM_INIT_FUNCS); SubSection sub(WASM_INIT_FUNCS);
writeUleb128(Sub.OS, InitFunctions.size(), "num init functions"); writeUleb128(sub.os, initFunctions.size(), "num init functions");
for (const WasmInitEntry &F : InitFunctions) { for (const WasmInitEntry &f : initFunctions) {
writeUleb128(Sub.OS, F.Priority, "priority"); writeUleb128(sub.os, f.priority, "priority");
writeUleb128(Sub.OS, F.Sym->getOutputSymbolIndex(), "function index"); writeUleb128(sub.os, f.sym->getOutputSymbolIndex(), "function index");
} }
Sub.writeTo(OS); sub.writeTo(os);
} }
struct ComdatEntry { struct ComdatEntry {
unsigned Kind; unsigned kind;
uint32_t Index; uint32_t index;
}; };
std::map<StringRef, std::vector<ComdatEntry>> Comdats; std::map<StringRef, std::vector<ComdatEntry>> comdats;
for (const InputFunction *F : Out.FunctionSec->InputFunctions) { for (const InputFunction *f : out.functionSec->inputFunctions) {
StringRef Comdat = F->getComdatName(); StringRef comdat = f->getComdatName();
if (!Comdat.empty()) if (!comdat.empty())
Comdats[Comdat].emplace_back( comdats[comdat].emplace_back(
ComdatEntry{WASM_COMDAT_FUNCTION, F->getFunctionIndex()}); ComdatEntry{WASM_COMDAT_FUNCTION, f->getFunctionIndex()});
} }
for (uint32_t I = 0; I < DataSegments.size(); ++I) { for (uint32_t i = 0; i < dataSegments.size(); ++i) {
const auto &InputSegments = DataSegments[I]->InputSegments; const auto &inputSegments = dataSegments[i]->inputSegments;
if (InputSegments.empty()) if (inputSegments.empty())
continue; continue;
StringRef Comdat = InputSegments[0]->getComdatName(); StringRef comdat = inputSegments[0]->getComdatName();
#ifndef NDEBUG #ifndef NDEBUG
for (const InputSegment *IS : InputSegments) for (const InputSegment *isec : inputSegments)
assert(IS->getComdatName() == Comdat); assert(isec->getComdatName() == comdat);
#endif #endif
if (!Comdat.empty()) if (!comdat.empty())
Comdats[Comdat].emplace_back(ComdatEntry{WASM_COMDAT_DATA, I}); comdats[comdat].emplace_back(ComdatEntry{WASM_COMDAT_DATA, i});
} }
if (!Comdats.empty()) { if (!comdats.empty()) {
SubSection Sub(WASM_COMDAT_INFO); SubSection sub(WASM_COMDAT_INFO);
writeUleb128(Sub.OS, Comdats.size(), "num comdats"); writeUleb128(sub.os, comdats.size(), "num comdats");
for (const auto &C : Comdats) { for (const auto &c : comdats) {
writeStr(Sub.OS, C.first, "comdat name"); writeStr(sub.os, c.first, "comdat name");
writeUleb128(Sub.OS, 0, "comdat flags"); // flags for future use writeUleb128(sub.os, 0, "comdat flags"); // flags for future use
writeUleb128(Sub.OS, C.second.size(), "num entries"); writeUleb128(sub.os, c.second.size(), "num entries");
for (const ComdatEntry &Entry : C.second) { for (const ComdatEntry &entry : c.second) {
writeU8(Sub.OS, Entry.Kind, "entry kind"); writeU8(sub.os, entry.kind, "entry kind");
writeUleb128(Sub.OS, Entry.Index, "entry index"); writeUleb128(sub.os, entry.index, "entry index");
} }
} }
Sub.writeTo(OS); sub.writeTo(os);
} }
} }
void LinkingSection::addToSymtab(Symbol *Sym) { void LinkingSection::addToSymtab(Symbol *sym) {
Sym->setOutputSymbolIndex(SymtabEntries.size()); sym->setOutputSymbolIndex(symtabEntries.size());
SymtabEntries.emplace_back(Sym); symtabEntries.emplace_back(sym);
} }
unsigned NameSection::numNames() const { unsigned NameSection::numNames() const {
unsigned NumNames = Out.ImportSec->getNumImportedFunctions(); unsigned numNames = out.importSec->getNumImportedFunctions();
for (const InputFunction *F : Out.FunctionSec->InputFunctions) for (const InputFunction *f : out.functionSec->inputFunctions)
if (!F->getName().empty() || !F->getDebugName().empty()) if (!f->getName().empty() || !f->getDebugName().empty())
++NumNames; ++numNames;
return NumNames; return numNames;
} }
// Create the custom "name" section containing debug symbol names. // Create the custom "name" section containing debug symbol names.
void NameSection::writeBody() { void NameSection::writeBody() {
SubSection Sub(WASM_NAMES_FUNCTION); SubSection sub(WASM_NAMES_FUNCTION);
writeUleb128(Sub.OS, numNames(), "name count"); writeUleb128(sub.os, numNames(), "name count");
// Names must appear in function index order. As it happens ImportedSymbols // Names must appear in function index order. As it happens ImportedSymbols
// and InputFunctions are numbered in order with imported functions coming // and InputFunctions are numbered in order with imported functions coming
// first. // first.
for (const Symbol *S : Out.ImportSec->ImportedSymbols) { for (const Symbol *s : out.importSec->importedSymbols) {
if (auto *F = dyn_cast<FunctionSymbol>(S)) { if (auto *f = dyn_cast<FunctionSymbol>(s)) {
writeUleb128(Sub.OS, F->getFunctionIndex(), "func index"); writeUleb128(sub.os, f->getFunctionIndex(), "func index");
writeStr(Sub.OS, toString(*S), "symbol name"); writeStr(sub.os, toString(*s), "symbol name");
} }
} }
for (const InputFunction *F : Out.FunctionSec->InputFunctions) { for (const InputFunction *f : out.functionSec->inputFunctions) {
if (!F->getName().empty()) { if (!f->getName().empty()) {
writeUleb128(Sub.OS, F->getFunctionIndex(), "func index"); writeUleb128(sub.os, f->getFunctionIndex(), "func index");
if (!F->getDebugName().empty()) { if (!f->getDebugName().empty()) {
writeStr(Sub.OS, F->getDebugName(), "symbol name"); writeStr(sub.os, f->getDebugName(), "symbol name");
} else { } else {
writeStr(Sub.OS, maybeDemangleSymbol(F->getName()), "symbol name"); writeStr(sub.os, maybeDemangleSymbol(f->getName()), "symbol name");
} }
} }
} }
Sub.writeTo(BodyOutputStream); sub.writeTo(bodyOutputStream);
} }
void ProducersSection::addInfo(const WasmProducerInfo &Info) { void ProducersSection::addInfo(const WasmProducerInfo &info) {
for (auto &Producers : for (auto &producers :
{std::make_pair(&Info.Languages, &Languages), {std::make_pair(&info.Languages, &languages),
std::make_pair(&Info.Tools, &Tools), std::make_pair(&Info.SDKs, &SDKs)}) std::make_pair(&info.Tools, &tools), std::make_pair(&info.SDKs, &sDKs)})
for (auto &Producer : *Producers.first) for (auto &producer : *producers.first)
if (Producers.second->end() == if (producers.second->end() ==
llvm::find_if(*Producers.second, llvm::find_if(*producers.second,
[&](std::pair<std::string, std::string> Seen) { [&](std::pair<std::string, std::string> seen) {
return Seen.first == Producer.first; return seen.first == producer.first;
})) }))
Producers.second->push_back(Producer); producers.second->push_back(producer);
} }
void ProducersSection::writeBody() { void ProducersSection::writeBody() {
auto &OS = BodyOutputStream; auto &os = bodyOutputStream;
writeUleb128(OS, fieldCount(), "field count"); writeUleb128(os, fieldCount(), "field count");
for (auto &Field : for (auto &field :
{std::make_pair("language", Languages), {std::make_pair("language", languages),
std::make_pair("processed-by", Tools), std::make_pair("sdk", SDKs)}) { std::make_pair("processed-by", tools), std::make_pair("sdk", sDKs)}) {
if (Field.second.empty()) if (field.second.empty())
continue; continue;
writeStr(OS, Field.first, "field name"); writeStr(os, field.first, "field name");
writeUleb128(OS, Field.second.size(), "number of entries"); writeUleb128(os, field.second.size(), "number of entries");
for (auto &Entry : Field.second) { for (auto &entry : field.second) {
writeStr(OS, Entry.first, "producer name"); writeStr(os, entry.first, "producer name");
writeStr(OS, Entry.second, "producer version"); writeStr(os, entry.second, "producer version");
} }
} }
} }
void TargetFeaturesSection::writeBody() { void TargetFeaturesSection::writeBody() {
SmallVector<std::string, 8> Emitted(Features.begin(), Features.end()); SmallVector<std::string, 8> emitted(features.begin(), features.end());
llvm::sort(Emitted); llvm::sort(emitted);
auto &OS = BodyOutputStream; auto &os = bodyOutputStream;
writeUleb128(OS, Emitted.size(), "feature count"); writeUleb128(os, emitted.size(), "feature count");
for (auto &Feature : Emitted) { for (auto &feature : emitted) {
writeU8(OS, WASM_FEATURE_PREFIX_USED, "feature used prefix"); writeU8(os, WASM_FEATURE_PREFIX_USED, "feature used prefix");
writeStr(OS, Feature, "feature name"); writeStr(os, feature, "feature name");
} }
} }
void RelocSection::writeBody() { void RelocSection::writeBody() {
uint32_t Count = Sec->getNumRelocations(); uint32_t count = sec->getNumRelocations();
assert(Sec->SectionIndex != UINT32_MAX); assert(sec->sectionIndex != UINT32_MAX);
writeUleb128(BodyOutputStream, Sec->SectionIndex, "reloc section"); writeUleb128(bodyOutputStream, sec->sectionIndex, "reloc section");
writeUleb128(BodyOutputStream, Count, "reloc count"); writeUleb128(bodyOutputStream, count, "reloc count");
Sec->writeRelocations(BodyOutputStream); sec->writeRelocations(bodyOutputStream);
} }

lld/trunk/wasm/Writer.cpp

Show All 36 Lines
#define DEBUG_TYPE "lld" #define DEBUG_TYPE "lld"
using namespace llvm; using namespace llvm;
using namespace llvm::wasm; using namespace llvm::wasm;
using namespace lld; using namespace lld;
using namespace lld::wasm; using namespace lld::wasm;
static constexpr int StackAlignment = 16; static constexpr int stackAlignment = 16;
namespace { namespace {
// The writer writes a SymbolTable result to a file. // The writer writes a SymbolTable result to a file.
class Writer { class Writer {
public: public:
void run(); void run();
Show All 12 Linesprivate:
void calculateImports(); void calculateImports();
void calculateExports(); void calculateExports();
void calculateCustomSections(); void calculateCustomSections();
void calculateTypes(); void calculateTypes();
void createOutputSegments(); void createOutputSegments();
void layoutMemory(); void layoutMemory();
void createHeader(); void createHeader();
void addSection(OutputSection *Sec); void addSection(OutputSection *sec);
void addSections(); void addSections();
void createCustomSections(); void createCustomSections();
void createSyntheticSections(); void createSyntheticSections();
void finalizeSections(); void finalizeSections();
// Custom sections // Custom sections
void createRelocSections(); void createRelocSections();
void writeHeader(); void writeHeader();
void writeSections(); void writeSections();
uint64_t FileSize = 0; uint64_t fileSize = 0;
uint32_t TableBase = 0; uint32_t tableBase = 0;
std::vector<WasmInitEntry> InitFunctions; std::vector<WasmInitEntry> initFunctions;
llvm::StringMap<std::vector<InputSection *>> CustomSectionMapping; llvm::StringMap<std::vector<InputSection *>> customSectionMapping;
// Elements that are used to construct the final output // Elements that are used to construct the final output
std::string Header; std::string header;
std::vector<OutputSection *> OutputSections; std::vector<OutputSection *> outputSections;
std::unique_ptr<FileOutputBuffer> Buffer; std::unique_ptr<FileOutputBuffer> buffer;
std::vector<OutputSegment *> Segments; std::vector<OutputSegment *> segments;
llvm::SmallDenseMap<StringRef, OutputSegment *> SegmentMap; llvm::SmallDenseMap<StringRef, OutputSegment *> segmentMap;
}; };
} // anonymous namespace } // anonymous namespace
void Writer::calculateCustomSections() { void Writer::calculateCustomSections() {
log("calculateCustomSections"); log("calculateCustomSections");
bool StripDebug = Config->StripDebug || Config->StripAll; bool stripDebug = config->stripDebug || config->stripAll;
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *file : symtab->objectFiles) {
for (InputSection *Section : File->CustomSections) { for (InputSection *section : file->customSections) {
StringRef Name = Section->getName(); StringRef name = section->getName();
// These custom sections are known the linker and synthesized rather than // These custom sections are known the linker and synthesized rather than
// blindly copied // blindly copied
if (Name == "linking" || Name == "name" || Name == "producers" || if (name == "linking" || name == "name" || name == "producers" ||
Name == "target_features" || Name.startswith("reloc.")) name == "target_features" || name.startswith("reloc."))
continue; continue;
// .. or it is a debug section // .. or it is a debug section
if (StripDebug && Name.startswith(".debug_")) if (stripDebug && name.startswith(".debug_"))
continue; continue;
CustomSectionMapping[Name].push_back(Section); customSectionMapping[name].push_back(section);
} }
} }
} }
void Writer::createCustomSections() { void Writer::createCustomSections() {
log("createCustomSections"); log("createCustomSections");
for (auto &Pair : CustomSectionMapping) { for (auto &pair : customSectionMapping) {
StringRef Name = Pair.first(); StringRef name = pair.first();
LLVM_DEBUG(dbgs() << "createCustomSection: " << Name << "\n"); LLVM_DEBUG(dbgs() << "createCustomSection: " << name << "\n");
OutputSection *Sec = make<CustomSection>(Name, Pair.second); OutputSection *sec = make<CustomSection>(name, pair.second);
if (Config->Relocatable || Config->EmitRelocs) { if (config->relocatable || config->emitRelocs) {
auto *Sym = make<OutputSectionSymbol>(Sec); auto *sym = make<OutputSectionSymbol>(sec);
Out.LinkingSec->addToSymtab(Sym); out.linkingSec->addToSymtab(sym);
Sec->SectionSym = Sym; sec->sectionSym = sym;
} }
addSection(Sec); addSection(sec);
} }
} }
// Create relocations sections in the final output. // Create relocations sections in the final output.
// These are only created when relocatable output is requested. // These are only created when relocatable output is requested.
void Writer::createRelocSections() { void Writer::createRelocSections() {
log("createRelocSections"); log("createRelocSections");
// Don't use iterator here since we are adding to OutputSection // Don't use iterator here since we are adding to OutputSection
size_t OrigSize = OutputSections.size(); size_t origSize = outputSections.size();
for (size_t I = 0; I < OrigSize; I++) { for (size_t i = 0; i < origSize; i++) {
LLVM_DEBUG(dbgs() << "check section " << I << "\n"); LLVM_DEBUG(dbgs() << "check section " << i << "\n");
OutputSection *Sec = OutputSections[I]; OutputSection *sec = outputSections[i];
// Count the number of needed sections. // Count the number of needed sections.
uint32_t Count = Sec->getNumRelocations(); uint32_t count = sec->getNumRelocations();
if (!Count) if (!count)
continue; continue;
StringRef Name; StringRef name;
if (Sec->Type == WASM_SEC_DATA) if (sec->type == WASM_SEC_DATA)
Name = "reloc.DATA"; name = "reloc.DATA";
else if (Sec->Type == WASM_SEC_CODE) else if (sec->type == WASM_SEC_CODE)
Name = "reloc.CODE"; name = "reloc.CODE";
else if (Sec->Type == WASM_SEC_CUSTOM) else if (sec->type == WASM_SEC_CUSTOM)
Name = Saver.save("reloc." + Sec->Name); name = saver.save("reloc." + sec->name);
else else
llvm_unreachable( llvm_unreachable(
"relocations only supported for code, data, or custom sections"); "relocations only supported for code, data, or custom sections");
addSection(make<RelocSection>(Name, Sec)); addSection(make<RelocSection>(name, sec));
} }
} }
void Writer::populateProducers() { void Writer::populateProducers() {
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *file : symtab->objectFiles) {
const WasmProducerInfo &Info = File->getWasmObj()->getProducerInfo(); const WasmProducerInfo &info = file->getWasmObj()->getProducerInfo();
Out.ProducersSec->addInfo(Info); out.producersSec->addInfo(info);
} }
} }
void Writer::writeHeader() { void Writer::writeHeader() {
memcpy(Buffer->getBufferStart(), Header.data(), Header.size()); memcpy(buffer->getBufferStart(), header.data(), header.size());
} }
void Writer::writeSections() { void Writer::writeSections() {
uint8_t *Buf = Buffer->getBufferStart(); uint8_t *buf = buffer->getBufferStart();
parallelForEach(OutputSections, [Buf](OutputSection *S) { parallelForEach(outputSections, [buf](OutputSection *s) {
assert(S->isNeeded()); assert(s->isNeeded());
S->writeTo(Buf); s->writeTo(buf);
}); });
} }
// Fix the memory layout of the output binary. This assigns memory offsets // Fix the memory layout of the output binary. This assigns memory offsets
// to each of the input data sections as well as the explicit stack region. // to each of the input data sections as well as the explicit stack region.
// The default memory layout is as follows, from low to high. // The default memory layout is as follows, from low to high.
// //
// - initialized data (starting at Config->GlobalBase) // - initialized data (starting at Config->GlobalBase)
// - BSS data (not currently implemented in llvm) // - BSS data (not currently implemented in llvm)
// - explicit stack (Config->ZStackSize) // - explicit stack (Config->ZStackSize)
// - heap start / unallocated // - heap start / unallocated
// //
// The --stack-first option means that stack is placed before any static data. // The --stack-first option means that stack is placed before any static data.
// This can be useful since it means that stack overflow traps immediately // This can be useful since it means that stack overflow traps immediately
// rather than overwriting global data, but also increases code size since all // rather than overwriting global data, but also increases code size since all
// static data loads and stores requires larger offsets. // static data loads and stores requires larger offsets.
void Writer::layoutMemory() { void Writer::layoutMemory() {
uint32_t MemoryPtr = 0; uint32_t memoryPtr = 0;
auto PlaceStack = [&]() { auto placeStack = [&]() {
if (Config->Relocatable || Config->Shared) if (config->relocatable || config->shared)
return; return;
MemoryPtr = alignTo(MemoryPtr, StackAlignment); memoryPtr = alignTo(memoryPtr, stackAlignment);
if (Config->ZStackSize != alignTo(Config->ZStackSize, StackAlignment)) if (config->zStackSize != alignTo(config->zStackSize, stackAlignment))
error("stack size must be " + Twine(StackAlignment) + "-byte aligned"); error("stack size must be " + Twine(stackAlignment) + "-byte aligned");
log("mem: stack size = " + Twine(Config->ZStackSize)); log("mem: stack size = " + Twine(config->zStackSize));
log("mem: stack base = " + Twine(MemoryPtr)); log("mem: stack base = " + Twine(memoryPtr));
MemoryPtr += Config->ZStackSize; memoryPtr += config->zStackSize;
auto *SP = cast<DefinedGlobal>(WasmSym::StackPointer); auto *sp = cast<DefinedGlobal>(WasmSym::stackPointer);
SP->Global->Global.InitExpr.Value.Int32 = MemoryPtr; sp->global->global.InitExpr.Value.Int32 = memoryPtr;
log("mem: stack top = " + Twine(MemoryPtr)); log("mem: stack top = " + Twine(memoryPtr));
}; };
if (Config->StackFirst) { if (config->stackFirst) {
PlaceStack(); placeStack();
} else { } else {
MemoryPtr = Config->GlobalBase; memoryPtr = config->globalBase;
log("mem: global base = " + Twine(Config->GlobalBase)); log("mem: global base = " + Twine(config->globalBase));
} }
if (WasmSym::GlobalBase) if (WasmSym::globalBase)
WasmSym::GlobalBase->setVirtualAddress(Config->GlobalBase); WasmSym::globalBase->setVirtualAddress(config->globalBase);
uint32_t DataStart = MemoryPtr; uint32_t dataStart = memoryPtr;
// Arbitrarily set __dso_handle handle to point to the start of the data // Arbitrarily set __dso_handle handle to point to the start of the data
// segments. // segments.
if (WasmSym::DsoHandle) if (WasmSym::dsoHandle)
WasmSym::DsoHandle->setVirtualAddress(DataStart); WasmSym::dsoHandle->setVirtualAddress(dataStart);
Out.DylinkSec->MemAlign = 0; out.dylinkSec->memAlign = 0;
for (OutputSegment *Seg : Segments) { for (OutputSegment *seg : segments) {
Out.DylinkSec->MemAlign = std::max(Out.DylinkSec->MemAlign, Seg->Alignment); out.dylinkSec->memAlign = std::max(out.dylinkSec->memAlign, seg->alignment);
MemoryPtr = alignTo(MemoryPtr, 1ULL << Seg->Alignment); memoryPtr = alignTo(memoryPtr, 1ULL << seg->alignment);
Seg->StartVA = MemoryPtr; seg->startVA = memoryPtr;
log(formatv("mem: {0,-15} offset={1,-8} size={2,-8} align={3}", Seg->Name, log(formatv("mem: {0,-15} offset={1,-8} size={2,-8} align={3}", seg->name,
MemoryPtr, Seg->Size, Seg->Alignment)); memoryPtr, seg->size, seg->alignment));
MemoryPtr += Seg->Size; memoryPtr += seg->size;
} }
// TODO: Add .bss space here. // TODO: Add .bss space here.
if (WasmSym::DataEnd) if (WasmSym::dataEnd)
WasmSym::DataEnd->setVirtualAddress(MemoryPtr); WasmSym::dataEnd->setVirtualAddress(memoryPtr);
log("mem: static data = " + Twine(MemoryPtr - DataStart)); log("mem: static data = " + Twine(memoryPtr - dataStart));
if (Config->Shared) { if (config->shared) {
Out.DylinkSec->MemSize = MemoryPtr; out.dylinkSec->memSize = memoryPtr;
return; return;
} }
if (!Config->StackFirst) if (!config->stackFirst)
PlaceStack(); placeStack();
// Set `__heap_base` to directly follow the end of the stack or global data. // Set `__heap_base` to directly follow the end of the stack or global data.
// The fact that this comes last means that a malloc/brk implementation // The fact that this comes last means that a malloc/brk implementation
// can grow the heap at runtime. // can grow the heap at runtime.
log("mem: heap base = " + Twine(MemoryPtr)); log("mem: heap base = " + Twine(memoryPtr));
if (WasmSym::HeapBase) if (WasmSym::heapBase)
WasmSym::HeapBase->setVirtualAddress(MemoryPtr); WasmSym::heapBase->setVirtualAddress(memoryPtr);
if (Config->InitialMemory != 0) { if (config->initialMemory != 0) {
if (Config->InitialMemory != alignTo(Config->InitialMemory, WasmPageSize)) if (config->initialMemory != alignTo(config->initialMemory, WasmPageSize))
error("initial memory must be " + Twine(WasmPageSize) + "-byte aligned"); error("initial memory must be " + Twine(WasmPageSize) + "-byte aligned");
if (MemoryPtr > Config->InitialMemory) if (memoryPtr > config->initialMemory)
error("initial memory too small, " + Twine(MemoryPtr) + " bytes needed"); error("initial memory too small, " + Twine(memoryPtr) + " bytes needed");
else else
MemoryPtr = Config->InitialMemory; memoryPtr = config->initialMemory;
} }
Out.DylinkSec->MemSize = MemoryPtr; out.dylinkSec->memSize = memoryPtr;
Out.MemorySec->NumMemoryPages = out.memorySec->numMemoryPages =
alignTo(MemoryPtr, WasmPageSize) / WasmPageSize; alignTo(memoryPtr, WasmPageSize) / WasmPageSize;
log("mem: total pages = " + Twine(Out.MemorySec->NumMemoryPages)); log("mem: total pages = " + Twine(out.memorySec->numMemoryPages));
// Check max if explicitly supplied or required by shared memory // Check max if explicitly supplied or required by shared memory
if (Config->MaxMemory != 0 || Config->SharedMemory) { if (config->maxMemory != 0 || config->sharedMemory) {
if (Config->MaxMemory != alignTo(Config->MaxMemory, WasmPageSize)) if (config->maxMemory != alignTo(config->maxMemory, WasmPageSize))
error("maximum memory must be " + Twine(WasmPageSize) + "-byte aligned"); error("maximum memory must be " + Twine(WasmPageSize) + "-byte aligned");
if (MemoryPtr > Config->MaxMemory) if (memoryPtr > config->maxMemory)
error("maximum memory too small, " + Twine(MemoryPtr) + " bytes needed"); error("maximum memory too small, " + Twine(memoryPtr) + " bytes needed");
Out.MemorySec->MaxMemoryPages = Config->MaxMemory / WasmPageSize; out.memorySec->maxMemoryPages = config->maxMemory / WasmPageSize;
log("mem: max pages = " + Twine(Out.MemorySec->MaxMemoryPages)); log("mem: max pages = " + Twine(out.memorySec->maxMemoryPages));
} }
} }
void Writer::addSection(OutputSection *Sec) { void Writer::addSection(OutputSection *sec) {
if (!Sec->isNeeded()) if (!sec->isNeeded())
return; return;
log("addSection: " + toString(*Sec)); log("addSection: " + toString(*sec));
Sec->SectionIndex = OutputSections.size(); sec->sectionIndex = outputSections.size();
OutputSections.push_back(Sec); outputSections.push_back(sec);
} }
// If a section name is valid as a C identifier (which is rare because of // If a section name is valid as a C identifier (which is rare because of
// the leading '.'), linkers are expected to define __start_<secname> and // the leading '.'), linkers are expected to define __start_<secname> and
// __stop_<secname> symbols. They are at beginning and end of the section, // __stop_<secname> symbols. They are at beginning and end of the section,
// respectively. This is not requested by the ELF standard, but GNU ld and // respectively. This is not requested by the ELF standard, but GNU ld and
// gold provide the feature, and used by many programs. // gold provide the feature, and used by many programs.
static void addStartStopSymbols(const OutputSegment *Seg) { static void addStartStopSymbols(const OutputSegment *seg) {
StringRef Name = Seg->Name; StringRef name = seg->name;
if (!isValidCIdentifier(Name)) if (!isValidCIdentifier(name))
return; return;
LLVM_DEBUG(dbgs() << "addStartStopSymbols: " << Name << "\n"); LLVM_DEBUG(dbgs() << "addStartStopSymbols: " << name << "\n");
uint32_t Start = Seg->StartVA; uint32_t start = seg->startVA;
uint32_t Stop = Start + Seg->Size; uint32_t stop = start + seg->size;
Symtab->addOptionalDataSymbol(Saver.save("__start_" + Name), Start); symtab->addOptionalDataSymbol(saver.save("__start_" + name), start);
Symtab->addOptionalDataSymbol(Saver.save("__stop_" + Name), Stop); symtab->addOptionalDataSymbol(saver.save("__stop_" + name), stop);
} }
void Writer::addSections() { void Writer::addSections() {
addSection(Out.DylinkSec); addSection(out.dylinkSec);
addSection(Out.TypeSec); addSection(out.typeSec);
addSection(Out.ImportSec); addSection(out.importSec);
addSection(Out.FunctionSec); addSection(out.functionSec);
addSection(Out.TableSec); addSection(out.tableSec);
addSection(Out.MemorySec); addSection(out.memorySec);
addSection(Out.GlobalSec); addSection(out.globalSec);
addSection(Out.EventSec); addSection(out.eventSec);
addSection(Out.ExportSec); addSection(out.exportSec);
addSection(Out.ElemSec); addSection(out.elemSec);
addSection(Out.DataCountSec); addSection(out.dataCountSec);
addSection(make<CodeSection>(Out.FunctionSec->InputFunctions)); addSection(make<CodeSection>(out.functionSec->inputFunctions));
addSection(make<DataSection>(Segments)); addSection(make<DataSection>(segments));
createCustomSections(); createCustomSections();
addSection(Out.LinkingSec); addSection(out.linkingSec);
if (Config->EmitRelocs || Config->Relocatable) { if (config->emitRelocs || config->relocatable) {
createRelocSections(); createRelocSections();
} }
addSection(Out.NameSec); addSection(out.nameSec);
addSection(Out.ProducersSec); addSection(out.producersSec);
addSection(Out.TargetFeaturesSec); addSection(out.targetFeaturesSec);
} }
void Writer::finalizeSections() { void Writer::finalizeSections() {
for (OutputSection *S : OutputSections) { for (OutputSection *s : outputSections) {
S->setOffset(FileSize); s->setOffset(fileSize);
S->finalizeContents(); s->finalizeContents();
FileSize += S->getSize(); fileSize += s->getSize();
} }
} }
void Writer::populateTargetFeatures() { void Writer::populateTargetFeatures() {
StringMap<std::string> Used; StringMap<std::string> used;
StringMap<std::string> Required; StringMap<std::string> required;
StringMap<std::string> Disallowed; StringMap<std::string> disallowed;
// Only infer used features if user did not specify features // Only infer used features if user did not specify features
bool InferFeatures = !Config->Features.hasValue(); bool inferFeatures = !config->features.hasValue();
if (!InferFeatures) { if (!inferFeatures) {
for (auto &Feature : Config->Features.getValue()) for (auto &feature : config->features.getValue())
Out.TargetFeaturesSec->Features.insert(Feature); out.targetFeaturesSec->features.insert(feature);
// No need to read or check features // No need to read or check features
if (!Config->CheckFeatures) if (!config->checkFeatures)
return; return;
} }
// Find the sets of used, required, and disallowed features // Find the sets of used, required, and disallowed features
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *file : symtab->objectFiles) {
StringRef FileName(File->getName()); StringRef fileName(file->getName());
for (auto &Feature : File->getWasmObj()->getTargetFeatures()) { for (auto &feature : file->getWasmObj()->getTargetFeatures()) {
switch (Feature.Prefix) { switch (feature.Prefix) {
case WASM_FEATURE_PREFIX_USED: case WASM_FEATURE_PREFIX_USED:
Used.insert({Feature.Name, FileName}); used.insert({feature.Name, fileName});
break; break;
case WASM_FEATURE_PREFIX_REQUIRED: case WASM_FEATURE_PREFIX_REQUIRED:
Used.insert({Feature.Name, FileName}); used.insert({feature.Name, fileName});
Required.insert({Feature.Name, FileName}); required.insert({feature.Name, fileName});
break; break;
case WASM_FEATURE_PREFIX_DISALLOWED: case WASM_FEATURE_PREFIX_DISALLOWED:
Disallowed.insert({Feature.Name, FileName}); disallowed.insert({feature.Name, fileName});
break; break;
default: default:
error("Unrecognized feature policy prefix " + error("Unrecognized feature policy prefix " +
std::to_string(Feature.Prefix)); std::to_string(feature.Prefix));
} }
} }
} }
if (InferFeatures) if (inferFeatures)
Out.TargetFeaturesSec->Features.insert(Used.keys().begin(), out.targetFeaturesSec->features.insert(used.keys().begin(),
Used.keys().end()); used.keys().end());
if (Out.TargetFeaturesSec->Features.count("atomics") && if (out.targetFeaturesSec->features.count("atomics") &&
!Config->SharedMemory) { !config->sharedMemory) {
if (InferFeatures) if (inferFeatures)
error(Twine("'atomics' feature is used by ") + Used["atomics"] + error(Twine("'atomics' feature is used by ") + used["atomics"] +
", so --shared-memory must be used"); ", so --shared-memory must be used");
else else
error("'atomics' feature is used, so --shared-memory must be used"); error("'atomics' feature is used, so --shared-memory must be used");
} }
if (!Config->CheckFeatures) if (!config->checkFeatures)
return; return;
if (Disallowed.count("atomics") && Config->SharedMemory) if (disallowed.count("atomics") && config->sharedMemory)
error("'atomics' feature is disallowed by " + Disallowed["atomics"] + error("'atomics' feature is disallowed by " + disallowed["atomics"] +
", so --shared-memory must not be used"); ", so --shared-memory must not be used");
if (!Used.count("bulk-memory") && Config->PassiveSegments) if (!used.count("bulk-memory") && config->passiveSegments)
error("'bulk-memory' feature must be used in order to emit passive " error("'bulk-memory' feature must be used in order to emit passive "
"segments"); "segments");
// Validate that used features are allowed in output // Validate that used features are allowed in output
if (!InferFeatures) { if (!inferFeatures) {
for (auto &Feature : Used.keys()) { for (auto &feature : used.keys()) {
if (!Out.TargetFeaturesSec->Features.count(Feature)) if (!out.targetFeaturesSec->features.count(feature))
error(Twine("Target feature '") + Feature + "' used by " + error(Twine("Target feature '") + feature + "' used by " +
Used[Feature] + " is not allowed."); used[feature] + " is not allowed.");
} }
} }
// Validate the required and disallowed constraints for each file // Validate the required and disallowed constraints for each file
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *file : symtab->objectFiles) {
StringRef FileName(File->getName()); StringRef fileName(file->getName());
SmallSet<std::string, 8> ObjectFeatures; SmallSet<std::string, 8> objectFeatures;
for (auto &Feature : File->getWasmObj()->getTargetFeatures()) { for (auto &feature : file->getWasmObj()->getTargetFeatures()) {
if (Feature.Prefix == WASM_FEATURE_PREFIX_DISALLOWED) if (feature.Prefix == WASM_FEATURE_PREFIX_DISALLOWED)
continue; continue;
ObjectFeatures.insert(Feature.Name); objectFeatures.insert(feature.Name);
if (Disallowed.count(Feature.Name)) if (disallowed.count(feature.Name))
error(Twine("Target feature '") + Feature.Name + "' used in " + error(Twine("Target feature '") + feature.Name + "' used in " +
FileName + " is disallowed by " + Disallowed[Feature.Name] + fileName + " is disallowed by " + disallowed[feature.Name] +
". Use --no-check-features to suppress."); ". Use --no-check-features to suppress.");
} }
for (auto &Feature : Required.keys()) { for (auto &feature : required.keys()) {
if (!ObjectFeatures.count(Feature)) if (!objectFeatures.count(feature))
error(Twine("Missing target feature '") + Feature + "' in " + FileName + error(Twine("Missing target feature '") + feature + "' in " + fileName +
", required by " + Required[Feature] + ", required by " + required[feature] +
". Use --no-check-features to suppress."); ". Use --no-check-features to suppress.");
} }
} }
} }
void Writer::calculateImports() { void Writer::calculateImports() {
for (Symbol *Sym : Symtab->getSymbols()) { for (Symbol *sym : symtab->getSymbols()) {
if (!Sym->isUndefined()) if (!sym->isUndefined())
continue; continue;
if (Sym->isWeak() && !Config->Relocatable) if (sym->isWeak() && !config->relocatable)
continue; continue;
if (!Sym->isLive()) if (!sym->isLive())
continue; continue;
if (!Sym->IsUsedInRegularObj) if (!sym->isUsedInRegularObj)
continue; continue;
// We don't generate imports for data symbols. They however can be imported // We don't generate imports for data symbols. They however can be imported
// as GOT entries. // as GOT entries.
if (isa<DataSymbol>(Sym)) if (isa<DataSymbol>(sym))
continue; continue;
LLVM_DEBUG(dbgs() << "import: " << Sym->getName() << "\n"); LLVM_DEBUG(dbgs() << "import: " << sym->getName() << "\n");
Out.ImportSec->addImport(Sym); out.importSec->addImport(sym);
} }
} }
void Writer::calculateExports() { void Writer::calculateExports() {
if (Config->Relocatable) if (config->relocatable)
return; return;
if (!Config->Relocatable && !Config->ImportMemory) if (!config->relocatable && !config->importMemory)
Out.ExportSec->Exports.push_back( out.exportSec->exports.push_back(
WasmExport{"memory", WASM_EXTERNAL_MEMORY, 0}); WasmExport{"memory", WASM_EXTERNAL_MEMORY, 0});
if (!Config->Relocatable && Config->ExportTable) if (!config->relocatable && config->exportTable)
Out.ExportSec->Exports.push_back( out.exportSec->exports.push_back(
WasmExport{FunctionTableName, WASM_EXTERNAL_TABLE, 0}); WasmExport{functionTableName, WASM_EXTERNAL_TABLE, 0});
unsigned FakeGlobalIndex = Out.ImportSec->getNumImportedGlobals() + unsigned fakeGlobalIndex = out.importSec->getNumImportedGlobals() +
Out.GlobalSec->InputGlobals.size(); out.globalSec->inputGlobals.size();
for (Symbol *Sym : Symtab->getSymbols()) { for (Symbol *sym : symtab->getSymbols()) {
if (!Sym->isExported()) if (!sym->isExported())
continue; continue;
if (!Sym->isLive()) if (!sym->isLive())
continue; continue;
StringRef Name = Sym->getName(); StringRef name = sym->getName();
WasmExport Export; WasmExport export_;
if (auto *F = dyn_cast<DefinedFunction>(Sym)) { if (auto *f = dyn_cast<DefinedFunction>(sym)) {
Export = {Name, WASM_EXTERNAL_FUNCTION, F->getFunctionIndex()}; export_ = {name, WASM_EXTERNAL_FUNCTION, f->getFunctionIndex()};
} else if (auto *G = dyn_cast<DefinedGlobal>(Sym)) { } else if (auto *g = dyn_cast<DefinedGlobal>(sym)) {
// TODO(sbc): Remove this check once to mutable global proposal is // TODO(sbc): Remove this check once to mutable global proposal is
// implement in all major browsers. // implement in all major browsers.
// See: https://github.com/WebAssembly/mutable-global // See: https://github.com/WebAssembly/mutable-global
if (G->getGlobalType()->Mutable) { if (g->getGlobalType()->Mutable) {
// Only the __stack_pointer should ever be create as mutable. // Only the __stack_pointer should ever be create as mutable.
assert(G == WasmSym::StackPointer); assert(g == WasmSym::stackPointer);
continue; continue;
} }
Export = {Name, WASM_EXTERNAL_GLOBAL, G->getGlobalIndex()}; export_ = {name, WASM_EXTERNAL_GLOBAL, g->getGlobalIndex()};
} else if (auto *E = dyn_cast<DefinedEvent>(Sym)) { } else if (auto *e = dyn_cast<DefinedEvent>(sym)) {
Export = {Name, WASM_EXTERNAL_EVENT, E->getEventIndex()}; export_ = {name, WASM_EXTERNAL_EVENT, e->getEventIndex()};
} else { } else {
auto *D = cast<DefinedData>(Sym); auto *d = cast<DefinedData>(sym);
Out.GlobalSec->DefinedFakeGlobals.emplace_back(D); out.globalSec->definedFakeGlobals.emplace_back(d);
Export = {Name, WASM_EXTERNAL_GLOBAL, FakeGlobalIndex++}; export_ = {name, WASM_EXTERNAL_GLOBAL, fakeGlobalIndex++};
} }
LLVM_DEBUG(dbgs() << "Export: " << Name << "\n"); LLVM_DEBUG(dbgs() << "Export: " << name << "\n");
Out.ExportSec->Exports.push_back(Export); out.exportSec->exports.push_back(export_);
} }
} }
void Writer::populateSymtab() { void Writer::populateSymtab() {
if (!Config->Relocatable && !Config->EmitRelocs) if (!config->relocatable && !config->emitRelocs)
return; return;
for (Symbol *Sym : Symtab->getSymbols()) for (Symbol *sym : symtab->getSymbols())
if (Sym->IsUsedInRegularObj && Sym->isLive()) if (sym->isUsedInRegularObj && sym->isLive())
Out.LinkingSec->addToSymtab(Sym); out.linkingSec->addToSymtab(sym);
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *file : symtab->objectFiles) {
LLVM_DEBUG(dbgs() << "Local symtab entries: " << File->getName() << "\n"); LLVM_DEBUG(dbgs() << "Local symtab entries: " << file->getName() << "\n");
for (Symbol *Sym : File->getSymbols()) for (Symbol *sym : file->getSymbols())
if (Sym->isLocal() && !isa<SectionSymbol>(Sym) && Sym->isLive()) if (sym->isLocal() && !isa<SectionSymbol>(sym) && sym->isLive())
Out.LinkingSec->addToSymtab(Sym); out.linkingSec->addToSymtab(sym);
} }
} }
void Writer::calculateTypes() { void Writer::calculateTypes() {
// The output type section is the union of the following sets: // The output type section is the union of the following sets:
// 1. Any signature used in the TYPE relocation // 1. Any signature used in the TYPE relocation
// 2. The signatures of all imported functions // 2. The signatures of all imported functions
// 3. The signatures of all defined functions // 3. The signatures of all defined functions
// 4. The signatures of all imported events // 4. The signatures of all imported events
// 5. The signatures of all defined events // 5. The signatures of all defined events
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *file : symtab->objectFiles) {
ArrayRef<WasmSignature> Types = File->getWasmObj()->types(); ArrayRef<WasmSignature> types = file->getWasmObj()->types();
for (uint32_t I = 0; I < Types.size(); I++) for (uint32_t i = 0; i < types.size(); i++)
if (File->TypeIsUsed[I]) if (file->typeIsUsed[i])
File->TypeMap[I] = Out.TypeSec->registerType(Types[I]); file->typeMap[i] = out.typeSec->registerType(types[i]);
} }
for (const Symbol *Sym : Out.ImportSec->ImportedSymbols) { for (const Symbol *sym : out.importSec->importedSymbols) {
if (auto *F = dyn_cast<FunctionSymbol>(Sym)) if (auto *f = dyn_cast<FunctionSymbol>(sym))
Out.TypeSec->registerType(*F->Signature); out.typeSec->registerType(*f->signature);
else if (auto *E = dyn_cast<EventSymbol>(Sym)) else if (auto *e = dyn_cast<EventSymbol>(sym))
Out.TypeSec->registerType(*E->Signature); out.typeSec->registerType(*e->signature);
} }
for (const InputFunction *F : Out.FunctionSec->InputFunctions) for (const InputFunction *f : out.functionSec->inputFunctions)
Out.TypeSec->registerType(F->Signature); out.typeSec->registerType(f->signature);
for (const InputEvent *E : Out.EventSec->InputEvents) for (const InputEvent *e : out.eventSec->inputEvents)
Out.TypeSec->registerType(E->Signature); out.typeSec->registerType(e->signature);
} }
static void scanRelocations() { static void scanRelocations() {
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *file : symtab->objectFiles) {
LLVM_DEBUG(dbgs() << "scanRelocations: " << File->getName() << "\n"); LLVM_DEBUG(dbgs() << "scanRelocations: " << file->getName() << "\n");
for (InputChunk *Chunk : File->Functions) for (InputChunk *chunk : file->functions)
scanRelocations(Chunk); scanRelocations(chunk);
for (InputChunk *Chunk : File->Segments) for (InputChunk *chunk : file->segments)
scanRelocations(Chunk); scanRelocations(chunk);
for (auto &P : File->CustomSections) for (auto &p : file->customSections)
scanRelocations(P); scanRelocations(p);
} }
} }
void Writer::assignIndexes() { void Writer::assignIndexes() {
// Seal the import section, since other index spaces such as function and // Seal the import section, since other index spaces such as function and
// global are effected by the number of imports. // global are effected by the number of imports.
Out.ImportSec->seal(); out.importSec->seal();
for (InputFunction *Func : Symtab->SyntheticFunctions) for (InputFunction *func : symtab->syntheticFunctions)
Out.FunctionSec->addFunction(Func); out.functionSec->addFunction(func);
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *file : symtab->objectFiles) {
LLVM_DEBUG(dbgs() << "Functions: " << File->getName() << "\n"); LLVM_DEBUG(dbgs() << "Functions: " << file->getName() << "\n");
for (InputFunction *Func : File->Functions) for (InputFunction *func : file->functions)
Out.FunctionSec->addFunction(Func); out.functionSec->addFunction(func);
} }
for (InputGlobal *Global : Symtab->SyntheticGlobals) for (InputGlobal *global : symtab->syntheticGlobals)
Out.GlobalSec->addGlobal(Global); out.globalSec->addGlobal(global);
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *file : symtab->objectFiles) {
LLVM_DEBUG(dbgs() << "Globals: " << File->getName() << "\n"); LLVM_DEBUG(dbgs() << "Globals: " << file->getName() << "\n");
for (InputGlobal *Global : File->Globals) for (InputGlobal *global : file->globals)
Out.GlobalSec->addGlobal(Global); out.globalSec->addGlobal(global);
} }
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *file : symtab->objectFiles) {
LLVM_DEBUG(dbgs() << "Events: " << File->getName() << "\n"); LLVM_DEBUG(dbgs() << "Events: " << file->getName() << "\n");
for (InputEvent *Event : File->Events) for (InputEvent *event : file->events)
Out.EventSec->addEvent(Event); out.eventSec->addEvent(event);
} }
} }
static StringRef getOutputDataSegmentName(StringRef Name) { static StringRef getOutputDataSegmentName(StringRef name) {
// With PIC code we currently only support a single data segment since // With PIC code we currently only support a single data segment since
// we only have a single __memory_base to use as our base address. // we only have a single __memory_base to use as our base address.
if (Config->Pic) if (config->isPic)
return ".data"; return ".data";
if (!Config->MergeDataSegments) if (!config->mergeDataSegments)
return Name; return name;
if (Name.startswith(".text.")) if (name.startswith(".text."))
return ".text"; return ".text";
if (Name.startswith(".data.")) if (name.startswith(".data."))
return ".data"; return ".data";
if (Name.startswith(".bss.")) if (name.startswith(".bss."))
return ".bss"; return ".bss";
if (Name.startswith(".rodata.")) if (name.startswith(".rodata."))
return ".rodata"; return ".rodata";
return Name; return name;
} }
void Writer::createOutputSegments() { void Writer::createOutputSegments() {
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *file : symtab->objectFiles) {
for (InputSegment *Segment : File->Segments) { for (InputSegment *segment : file->segments) {
if (!Segment->Live) if (!segment->live)
continue; continue;
StringRef Name = getOutputDataSegmentName(Segment->getName()); StringRef name = getOutputDataSegmentName(segment->getName());
OutputSegment *&S = SegmentMap[Name]; OutputSegment *&s = segmentMap[name];
if (S == nullptr) { if (s == nullptr) {
LLVM_DEBUG(dbgs() << "new segment: " << Name << "\n"); LLVM_DEBUG(dbgs() << "new segment: " << name << "\n");
S = make<OutputSegment>(Name, Segments.size()); s = make<OutputSegment>(name, segments.size());
if (Config->PassiveSegments) if (config->passiveSegments)
S->InitFlags = WASM_SEGMENT_IS_PASSIVE; s->initFlags = WASM_SEGMENT_IS_PASSIVE;
Segments.push_back(S); segments.push_back(s);
} }
S->addInputSegment(Segment); s->addInputSegment(segment);
LLVM_DEBUG(dbgs() << "added data: " << Name << ": " << S->Size << "\n"); LLVM_DEBUG(dbgs() << "added data: " << name << ": " << s->size << "\n");
} }
} }
} }
static void createFunction(DefinedFunction *Func, StringRef BodyContent) { static void createFunction(DefinedFunction *func, StringRef bodyContent) {
std::string FunctionBody; std::string functionBody;
{ {
raw_string_ostream OS(FunctionBody); raw_string_ostream os(functionBody);
writeUleb128(OS, BodyContent.size(), "function size"); writeUleb128(os, bodyContent.size(), "function size");
OS << BodyContent; os << bodyContent;
} }
ArrayRef<uint8_t> Body = arrayRefFromStringRef(Saver.save(FunctionBody)); ArrayRef<uint8_t> body = arrayRefFromStringRef(saver.save(functionBody));
cast<SyntheticFunction>(Func->Function)->setBody(Body); cast<SyntheticFunction>(func->function)->setBody(body);
} }
void Writer::createInitMemoryFunction() { void Writer::createInitMemoryFunction() {
LLVM_DEBUG(dbgs() << "createInitMemoryFunction\n"); LLVM_DEBUG(dbgs() << "createInitMemoryFunction\n");
std::string BodyContent; std::string bodyContent;
{ {
raw_string_ostream OS(BodyContent); raw_string_ostream os(bodyContent);
writeUleb128(OS, 0, "num locals"); writeUleb128(os, 0, "num locals");
// initialize passive data segments // initialize passive data segments
for (const OutputSegment *S : Segments) { for (const OutputSegment *s : segments) {
if (S->InitFlags & WASM_SEGMENT_IS_PASSIVE) { if (s->initFlags & WASM_SEGMENT_IS_PASSIVE) {
// destination address // destination address
writeU8(OS, WASM_OPCODE_I32_CONST, "i32.const"); writeU8(os, WASM_OPCODE_I32_CONST, "i32.const");
writeUleb128(OS, S->StartVA, "destination address"); writeUleb128(os, s->startVA, "destination address");
// source segment offset // source segment offset
writeU8(OS, WASM_OPCODE_I32_CONST, "i32.const"); writeU8(os, WASM_OPCODE_I32_CONST, "i32.const");
writeUleb128(OS, 0, "segment offset"); writeUleb128(os, 0, "segment offset");
// memory region size // memory region size
writeU8(OS, WASM_OPCODE_I32_CONST, "i32.const"); writeU8(os, WASM_OPCODE_I32_CONST, "i32.const");
writeUleb128(OS, S->Size, "memory region size"); writeUleb128(os, s->size, "memory region size");
// memory.init instruction // memory.init instruction
writeU8(OS, WASM_OPCODE_MISC_PREFIX, "bulk-memory prefix"); writeU8(os, WASM_OPCODE_MISC_PREFIX, "bulk-memory prefix");
writeUleb128(OS, WASM_OPCODE_MEMORY_INIT, "MEMORY.INIT"); writeUleb128(os, WASM_OPCODE_MEMORY_INIT, "MEMORY.INIT");
writeUleb128(OS, S->Index, "segment index immediate"); writeUleb128(os, s->index, "segment index immediate");
writeU8(OS, 0, "memory index immediate"); writeU8(os, 0, "memory index immediate");
// data.drop instruction // data.drop instruction
writeU8(OS, WASM_OPCODE_MISC_PREFIX, "bulk-memory prefix"); writeU8(os, WASM_OPCODE_MISC_PREFIX, "bulk-memory prefix");
writeUleb128(OS, WASM_OPCODE_DATA_DROP, "DATA.DROP"); writeUleb128(os, WASM_OPCODE_DATA_DROP, "DATA.DROP");
writeUleb128(OS, S->Index, "segment index immediate"); writeUleb128(os, s->index, "segment index immediate");
} }
} }
writeU8(OS, WASM_OPCODE_END, "END"); writeU8(os, WASM_OPCODE_END, "END");
} }
createFunction(WasmSym::InitMemory, BodyContent); createFunction(WasmSym::initMemory, bodyContent);
} }
// For -shared (PIC) output, we create create a synthetic function which will // For -shared (PIC) output, we create create a synthetic function which will
// apply any relocations to the data segments on startup. This function is // apply any relocations to the data segments on startup. This function is
// called __wasm_apply_relocs and is added at the beginning of __wasm_call_ctors // called __wasm_apply_relocs and is added at the beginning of __wasm_call_ctors
// before any of the constructors run. // before any of the constructors run.
void Writer::createApplyRelocationsFunction() { void Writer::createApplyRelocationsFunction() {
LLVM_DEBUG(dbgs() << "createApplyRelocationsFunction\n"); LLVM_DEBUG(dbgs() << "createApplyRelocationsFunction\n");
// First write the body's contents to a string. // First write the body's contents to a string.
std::string BodyContent; std::string bodyContent;
{ {
raw_string_ostream OS(BodyContent); raw_string_ostream os(bodyContent);
writeUleb128(OS, 0, "num locals"); writeUleb128(os, 0, "num locals");
for (const OutputSegment *Seg : Segments) for (const OutputSegment *seg : segments)
for (const InputSegment *InSeg : Seg->InputSegments) for (const InputSegment *inSeg : seg->inputSegments)
InSeg->generateRelocationCode(OS); inSeg->generateRelocationCode(os);
writeU8(OS, WASM_OPCODE_END, "END"); writeU8(os, WASM_OPCODE_END, "END");
} }
createFunction(WasmSym::ApplyRelocs, BodyContent); createFunction(WasmSym::applyRelocs, bodyContent);
} }
// Create synthetic "__wasm_call_ctors" function based on ctor functions // Create synthetic "__wasm_call_ctors" function based on ctor functions
// in input object. // in input object.
void Writer::createCallCtorsFunction() { void Writer::createCallCtorsFunction() {
if (!WasmSym::CallCtors->isLive()) if (!WasmSym::callCtors->isLive())
return; return;
// First write the body's contents to a string. // First write the body's contents to a string.
std::string BodyContent; std::string bodyContent;
{ {
raw_string_ostream OS(BodyContent); raw_string_ostream os(bodyContent);
writeUleb128(OS, 0, "num locals"); writeUleb128(os, 0, "num locals");
if (Config->PassiveSegments) { if (config->passiveSegments) {
writeU8(OS, WASM_OPCODE_CALL, "CALL"); writeU8(os, WASM_OPCODE_CALL, "CALL");
writeUleb128(OS, WasmSym::InitMemory->getFunctionIndex(), writeUleb128(os, WasmSym::initMemory->getFunctionIndex(),
"function index"); "function index");
} }
if (Config->Pic) { if (config->isPic) {
writeU8(OS, WASM_OPCODE_CALL, "CALL"); writeU8(os, WASM_OPCODE_CALL, "CALL");
writeUleb128(OS, WasmSym::ApplyRelocs->getFunctionIndex(), writeUleb128(os, WasmSym::applyRelocs->getFunctionIndex(),
"function index"); "function index");
} }
// Call constructors // Call constructors
for (const WasmInitEntry &F : InitFunctions) { for (const WasmInitEntry &f : initFunctions) {
writeU8(OS, WASM_OPCODE_CALL, "CALL"); writeU8(os, WASM_OPCODE_CALL, "CALL");
writeUleb128(OS, F.Sym->getFunctionIndex(), "function index"); writeUleb128(os, f.sym->getFunctionIndex(), "function index");
} }
writeU8(OS, WASM_OPCODE_END, "END"); writeU8(os, WASM_OPCODE_END, "END");
} }
createFunction(WasmSym::CallCtors, BodyContent); createFunction(WasmSym::callCtors, bodyContent);
} }
// Populate InitFunctions vector with init functions from all input objects. // Populate InitFunctions vector with init functions from all input objects.
// This is then used either when creating the output linking section or to // This is then used either when creating the output linking section or to
// synthesize the "__wasm_call_ctors" function. // synthesize the "__wasm_call_ctors" function.
void Writer::calculateInitFunctions() { void Writer::calculateInitFunctions() {
if (!Config->Relocatable && !WasmSym::CallCtors->isLive()) if (!config->relocatable && !WasmSym::callCtors->isLive())
return; return;
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *file : symtab->objectFiles) {
const WasmLinkingData &L = File->getWasmObj()->linkingData(); const WasmLinkingData &l = file->getWasmObj()->linkingData();
for (const WasmInitFunc &F : L.InitFunctions) { for (const WasmInitFunc &f : l.InitFunctions) {
FunctionSymbol *Sym = File->getFunctionSymbol(F.Symbol); FunctionSymbol *sym = file->getFunctionSymbol(f.Symbol);
// comdat exclusions can cause init functions be discarded. // comdat exclusions can cause init functions be discarded.
if (Sym->isDiscarded()) if (sym->isDiscarded())
continue; continue;
assert(Sym->isLive()); assert(sym->isLive());
if (*Sym->Signature != WasmSignature{{}, {}}) if (*sym->signature != WasmSignature{{}, {}})
error("invalid signature for init func: " + toString(*Sym)); error("invalid signature for init func: " + toString(*sym));
InitFunctions.emplace_back(WasmInitEntry{Sym, F.Priority}); initFunctions.emplace_back(WasmInitEntry{sym, f.Priority});
} }
} }
// Sort in order of priority (lowest first) so that they are called // Sort in order of priority (lowest first) so that they are called
// in the correct order. // in the correct order.
llvm::stable_sort(InitFunctions, llvm::stable_sort(initFunctions,
[](const WasmInitEntry &L, const WasmInitEntry &R) { [](const WasmInitEntry &l, const WasmInitEntry &r) {
return L.Priority < R.Priority; return l.priority < r.priority;
}); });
} }
void Writer::createSyntheticSections() { void Writer::createSyntheticSections() {
Out.DylinkSec = make<DylinkSection>(); out.dylinkSec = make<DylinkSection>();
Out.TypeSec = make<TypeSection>(); out.typeSec = make<TypeSection>();
Out.ImportSec = make<ImportSection>(); out.importSec = make<ImportSection>();
Out.FunctionSec = make<FunctionSection>(); out.functionSec = make<FunctionSection>();
Out.TableSec = make<TableSection>(); out.tableSec = make<TableSection>();
Out.MemorySec = make<MemorySection>(); out.memorySec = make<MemorySection>();
Out.GlobalSec = make<GlobalSection>(); out.globalSec = make<GlobalSection>();
Out.EventSec = make<EventSection>(); out.eventSec = make<EventSection>();
Out.ExportSec = make<ExportSection>(); out.exportSec = make<ExportSection>();
Out.ElemSec = make<ElemSection>(TableBase); out.elemSec = make<ElemSection>(tableBase);
Out.DataCountSec = make<DataCountSection>(Segments.size()); out.dataCountSec = make<DataCountSection>(segments.size());
Out.LinkingSec = make<LinkingSection>(InitFunctions, Segments); out.linkingSec = make<LinkingSection>(initFunctions, segments);
Out.NameSec = make<NameSection>(); out.nameSec = make<NameSection>();
Out.ProducersSec = make<ProducersSection>(); out.producersSec = make<ProducersSection>();
Out.TargetFeaturesSec = make<TargetFeaturesSection>(); out.targetFeaturesSec = make<TargetFeaturesSection>();
} }
void Writer::run() { void Writer::run() {
if (Config->Relocatable || Config->Pic) if (config->relocatable || config->isPic)
Config->GlobalBase = 0; config->globalBase = 0;
// For PIC code the table base is assigned dynamically by the loader. // For PIC code the table base is assigned dynamically by the loader.
// For non-PIC, we start at 1 so that accessing table index 0 always traps. // For non-PIC, we start at 1 so that accessing table index 0 always traps.
if (!Config->Pic) if (!config->isPic)
TableBase = 1; tableBase = 1;
log("-- createOutputSegments"); log("-- createOutputSegments");
createOutputSegments(); createOutputSegments();
log("-- createSyntheticSections"); log("-- createSyntheticSections");
createSyntheticSections(); createSyntheticSections();
log("-- populateProducers"); log("-- populateProducers");
populateProducers(); populateProducers();
log("-- populateTargetFeatures"); log("-- populateTargetFeatures");
populateTargetFeatures(); populateTargetFeatures();
log("-- calculateImports"); log("-- calculateImports");
calculateImports(); calculateImports();
log("-- layoutMemory"); log("-- layoutMemory");
layoutMemory(); layoutMemory();
if (!Config->Relocatable) { if (!config->relocatable) {
// Create linker synthesized __start_SECNAME/__stop_SECNAME symbols // Create linker synthesized __start_SECNAME/__stop_SECNAME symbols
// This has to be done after memory layout is performed. // This has to be done after memory layout is performed.
for (const OutputSegment *Seg : Segments) for (const OutputSegment *seg : segments)
addStartStopSymbols(Seg); addStartStopSymbols(seg);
} }
log("-- scanRelocations"); log("-- scanRelocations");
scanRelocations(); scanRelocations();
log("-- assignIndexes"); log("-- assignIndexes");
assignIndexes(); assignIndexes();
log("-- calculateInitFunctions"); log("-- calculateInitFunctions");
calculateInitFunctions(); calculateInitFunctions();
if (!Config->Relocatable) { if (!config->relocatable) {
// Create linker synthesized functions // Create linker synthesized functions
if (Config->PassiveSegments) if (config->passiveSegments)
createInitMemoryFunction(); createInitMemoryFunction();
if (Config->Pic) if (config->isPic)
createApplyRelocationsFunction(); createApplyRelocationsFunction();
createCallCtorsFunction(); createCallCtorsFunction();
} }
log("-- calculateTypes"); log("-- calculateTypes");
calculateTypes(); calculateTypes();
log("-- calculateExports"); log("-- calculateExports");
calculateExports(); calculateExports();
log("-- calculateCustomSections"); log("-- calculateCustomSections");
calculateCustomSections(); calculateCustomSections();
log("-- populateSymtab"); log("-- populateSymtab");
populateSymtab(); populateSymtab();
log("-- addSections"); log("-- addSections");
addSections(); addSections();
if (errorHandler().Verbose) { if (errorHandler().verbose) {
log("Defined Functions: " + Twine(Out.FunctionSec->InputFunctions.size())); log("Defined Functions: " + Twine(out.functionSec->inputFunctions.size()));
log("Defined Globals : " + Twine(Out.GlobalSec->InputGlobals.size())); log("Defined Globals : " + Twine(out.globalSec->inputGlobals.size()));
log("Defined Events : " + Twine(Out.EventSec->InputEvents.size())); log("Defined Events : " + Twine(out.eventSec->inputEvents.size()));
log("Function Imports : " + log("Function Imports : " +
Twine(Out.ImportSec->getNumImportedFunctions())); Twine(out.importSec->getNumImportedFunctions()));
log("Global Imports : " + Twine(Out.ImportSec->getNumImportedGlobals())); log("Global Imports : " + Twine(out.importSec->getNumImportedGlobals()));
log("Event Imports : " + Twine(Out.ImportSec->getNumImportedEvents())); log("Event Imports : " + Twine(out.importSec->getNumImportedEvents()));
for (ObjFile *File : Symtab->ObjectFiles) for (ObjFile *file : symtab->objectFiles)
File->dumpInfo(); file->dumpInfo();
} }
createHeader(); createHeader();
log("-- finalizeSections"); log("-- finalizeSections");
finalizeSections(); finalizeSections();
log("-- openFile"); log("-- openFile");
openFile(); openFile();
if (errorCount()) if (errorCount())
return; return;
writeHeader(); writeHeader();
log("-- writeSections"); log("-- writeSections");
writeSections(); writeSections();
if (errorCount()) if (errorCount())
return; return;
if (Error E = Buffer->commit()) if (Error e = buffer->commit())
fatal("failed to write the output file: " + toString(std::move(E))); fatal("failed to write the output file: " + toString(std::move(e)));
} }
// Open a result file. // Open a result file.
void Writer::openFile() { void Writer::openFile() {
log("writing: " + Config->OutputFile); log("writing: " + config->outputFile);
Expected<std::unique_ptr<FileOutputBuffer>> BufferOrErr = Expected<std::unique_ptr<FileOutputBuffer>> bufferOrErr =
FileOutputBuffer::create(Config->OutputFile, FileSize, FileOutputBuffer::create(config->outputFile, fileSize,
FileOutputBuffer::F_executable); FileOutputBuffer::F_executable);
if (!BufferOrErr) if (!bufferOrErr)
error("failed to open " + Config->OutputFile + ": " + error("failed to open " + config->outputFile + ": " +
toString(BufferOrErr.takeError())); toString(bufferOrErr.takeError()));
else else
Buffer = std::move(*BufferOrErr); buffer = std::move(*bufferOrErr);
} }
void Writer::createHeader() { void Writer::createHeader() {
raw_string_ostream OS(Header); raw_string_ostream os(header);
writeBytes(OS, WasmMagic, sizeof(WasmMagic), "wasm magic"); writeBytes(os, WasmMagic, sizeof(WasmMagic), "wasm magic");
writeU32(OS, WasmVersion, "wasm version"); writeU32(os, WasmVersion, "wasm version");
OS.flush(); os.flush();
FileSize += Header.size(); fileSize += header.size();
} }
void lld::wasm::writeResult() { Writer().run(); } void lld::wasm::writeResult() { Writer().run(); }

lld/trunk/wasm/WriterUtils.h

Show All 10 Lines
#include "lld/Common/LLVM.h" #include "lld/Common/LLVM.h"
#include "llvm/ADT/Twine.h" #include "llvm/ADT/Twine.h"
#include "llvm/Object/Wasm.h" #include "llvm/Object/Wasm.h"
namespace lld { namespace lld {
namespace wasm { namespace wasm {
void debugWrite(uint64_t Offset, const Twine &Msg); void debugWrite(uint64_t offset, const Twine &msg);
void writeUleb128(raw_ostream &OS, uint32_t Number, const Twine &Msg); void writeUleb128(raw_ostream &os, uint32_t number, const Twine &msg);
void writeSleb128(raw_ostream &OS, int32_t Number, const Twine &Msg); void writeSleb128(raw_ostream &os, int32_t number, const Twine &msg);
void writeBytes(raw_ostream &OS, const char *Bytes, size_t count, void writeBytes(raw_ostream &os, const char *bytes, size_t count,
const Twine &Msg); const Twine &msg);
void writeStr(raw_ostream &OS, StringRef String, const Twine &Msg); void writeStr(raw_ostream &os, StringRef string, const Twine &msg);
void writeU8(raw_ostream &OS, uint8_t byte, const Twine &Msg); void writeU8(raw_ostream &os, uint8_t byte, const Twine &msg);
void writeU32(raw_ostream &OS, uint32_t Number, const Twine &Msg); void writeU32(raw_ostream &os, uint32_t number, const Twine &msg);
void writeValueType(raw_ostream &OS, llvm::wasm::ValType Type, void writeValueType(raw_ostream &os, llvm::wasm::ValType type,
const Twine &Msg); const Twine &msg);
void writeSig(raw_ostream &OS, const llvm::wasm::WasmSignature &Sig); void writeSig(raw_ostream &os, const llvm::wasm::WasmSignature &sig);
void writeInitExpr(raw_ostream &OS, const llvm::wasm::WasmInitExpr &InitExpr); void writeInitExpr(raw_ostream &os, const llvm::wasm::WasmInitExpr &initExpr);
void writeLimits(raw_ostream &OS, const llvm::wasm::WasmLimits &Limits); void writeLimits(raw_ostream &os, const llvm::wasm::WasmLimits &limits);
void writeGlobalType(raw_ostream &OS, const llvm::wasm::WasmGlobalType &Type); void writeGlobalType(raw_ostream &os, const llvm::wasm::WasmGlobalType &type);
void writeGlobal(raw_ostream &OS, const llvm::wasm::WasmGlobal &Global); void writeGlobal(raw_ostream &os, const llvm::wasm::WasmGlobal &global);
void writeEventType(raw_ostream &OS, const llvm::wasm::WasmEventType &Type); void writeEventType(raw_ostream &os, const llvm::wasm::WasmEventType &type);
void writeEvent(raw_ostream &OS, const llvm::wasm::WasmEvent &Event); void writeEvent(raw_ostream &os, const llvm::wasm::WasmEvent &event);
void writeTableType(raw_ostream &OS, const llvm::wasm::WasmTable &Type); void writeTableType(raw_ostream &os, const llvm::wasm::WasmTable &type);
void writeImport(raw_ostream &OS, const llvm::wasm::WasmImport &Import); void writeImport(raw_ostream &os, const llvm::wasm::WasmImport &import);
void writeExport(raw_ostream &OS, const llvm::wasm::WasmExport &Export); void writeExport(raw_ostream &os, const llvm::wasm::WasmExport &export_);
} // namespace wasm } // namespace wasm
std::string toString(llvm::wasm::ValType Type); std::string toString(llvm::wasm::ValType type);
std::string toString(const llvm::wasm::WasmSignature &Sig); std::string toString(const llvm::wasm::WasmSignature &sig);
std::string toString(const llvm::wasm::WasmGlobalType &Type); std::string toString(const llvm::wasm::WasmGlobalType &type);
std::string toString(const llvm::wasm::WasmEventType &Type); std::string toString(const llvm::wasm::WasmEventType &type);
} // namespace lld } // namespace lld
#endif // LLD_WASM_WRITERUTILS_H #endif // LLD_WASM_WRITERUTILS_H

lld/trunk/wasm/WriterUtils.cpp

Show All 13 Lines
#define DEBUG_TYPE "lld" #define DEBUG_TYPE "lld"
using namespace llvm; using namespace llvm;
using namespace llvm::wasm; using namespace llvm::wasm;
namespace lld { namespace lld {
void wasm::debugWrite(uint64_t Offset, const Twine &Msg) { void wasm::debugWrite(uint64_t offset, const Twine &msg) {
LLVM_DEBUG(dbgs() << format(" | %08lld: ", Offset) << Msg << "\n"); LLVM_DEBUG(dbgs() << format(" | %08lld: ", offset) << msg << "\n");
} }
void wasm::writeUleb128(raw_ostream &OS, uint32_t Number, const Twine &Msg) { void wasm::writeUleb128(raw_ostream &os, uint32_t number, const Twine &msg) {
debugWrite(OS.tell(), Msg + "[" + utohexstr(Number) + "]"); debugWrite(os.tell(), msg + "[" + utohexstr(number) + "]");
encodeULEB128(Number, OS); encodeULEB128(number, os);
} }
void wasm::writeSleb128(raw_ostream &OS, int32_t Number, const Twine &Msg) { void wasm::writeSleb128(raw_ostream &os, int32_t number, const Twine &msg) {
debugWrite(OS.tell(), Msg + "[" + utohexstr(Number) + "]"); debugWrite(os.tell(), msg + "[" + utohexstr(number) + "]");
encodeSLEB128(Number, OS); encodeSLEB128(number, os);
} }
void wasm::writeBytes(raw_ostream &OS, const char *Bytes, size_t Count, void wasm::writeBytes(raw_ostream &os, const char *bytes, size_t count,
const Twine &Msg) { const Twine &msg) {
debugWrite(OS.tell(), Msg + " [data[" + Twine(Count) + "]]"); debugWrite(os.tell(), msg + " [data[" + Twine(count) + "]]");
OS.write(Bytes, Count); os.write(bytes, count);
} }
void wasm::writeStr(raw_ostream &OS, StringRef String, const Twine &Msg) { void wasm::writeStr(raw_ostream &os, StringRef string, const Twine &msg) {
debugWrite(OS.tell(), debugWrite(os.tell(),
Msg + " [str[" + Twine(String.size()) + "]: " + String + "]"); msg + " [str[" + Twine(string.size()) + "]: " + string + "]");
encodeULEB128(String.size(), OS); encodeULEB128(string.size(), os);
OS.write(String.data(), String.size()); os.write(string.data(), string.size());
} }
void wasm::writeU8(raw_ostream &OS, uint8_t Byte, const Twine &Msg) { void wasm::writeU8(raw_ostream &os, uint8_t byte, const Twine &msg) {
debugWrite(OS.tell(), Msg + " [0x" + utohexstr(Byte) + "]"); debugWrite(os.tell(), msg + " [0x" + utohexstr(byte) + "]");
OS << Byte; os << byte;
} }
void wasm::writeU32(raw_ostream &OS, uint32_t Number, const Twine &Msg) { void wasm::writeU32(raw_ostream &os, uint32_t number, const Twine &msg) {
debugWrite(OS.tell(), Msg + "[0x" + utohexstr(Number) + "]"); debugWrite(os.tell(), msg + "[0x" + utohexstr(number) + "]");
support::endian::write(OS, Number, support::little); support::endian::write(os, number, support::little);
} }
void wasm::writeValueType(raw_ostream &OS, ValType Type, const Twine &Msg) { void wasm::writeValueType(raw_ostream &os, ValType type, const Twine &msg) {
writeU8(OS, static_cast<uint8_t>(Type), writeU8(os, static_cast<uint8_t>(type),
Msg + "[type: " + toString(Type) + "]"); msg + "[type: " + toString(type) + "]");
} }
void wasm::writeSig(raw_ostream &OS, const WasmSignature &Sig) { void wasm::writeSig(raw_ostream &os, const WasmSignature &sig) {
writeU8(OS, WASM_TYPE_FUNC, "signature type"); writeU8(os, WASM_TYPE_FUNC, "signature type");
writeUleb128(OS, Sig.Params.size(), "param Count"); writeUleb128(os, sig.Params.size(), "param Count");
for (ValType ParamType : Sig.Params) { for (ValType paramType : sig.Params) {
writeValueType(OS, ParamType, "param type"); writeValueType(os, paramType, "param type");
} }
writeUleb128(OS, Sig.Returns.size(), "result Count"); writeUleb128(os, sig.Returns.size(), "result Count");
if (Sig.Returns.size()) { if (sig.Returns.size()) {
writeValueType(OS, Sig.Returns[0], "result type"); writeValueType(os, sig.Returns[0], "result type");
} }
} }
void wasm::writeInitExpr(raw_ostream &OS, const WasmInitExpr &InitExpr) { void wasm::writeInitExpr(raw_ostream &os, const WasmInitExpr &initExpr) {
writeU8(OS, InitExpr.Opcode, "opcode"); writeU8(os, initExpr.Opcode, "opcode");
switch (InitExpr.Opcode) { switch (initExpr.Opcode) {
case WASM_OPCODE_I32_CONST: case WASM_OPCODE_I32_CONST:
writeSleb128(OS, InitExpr.Value.Int32, "literal (i32)"); writeSleb128(os, initExpr.Value.Int32, "literal (i32)");
break; break;
case WASM_OPCODE_I64_CONST: case WASM_OPCODE_I64_CONST:
writeSleb128(OS, InitExpr.Value.Int64, "literal (i64)"); writeSleb128(os, initExpr.Value.Int64, "literal (i64)");
break; break;
case WASM_OPCODE_GLOBAL_GET: case WASM_OPCODE_GLOBAL_GET:
writeUleb128(OS, InitExpr.Value.Global, "literal (global index)"); writeUleb128(os, initExpr.Value.Global, "literal (global index)");
break; break;
default: default:
fatal("unknown opcode in init expr: " + Twine(InitExpr.Opcode)); fatal("unknown opcode in init expr: " + Twine(initExpr.Opcode));
} }
writeU8(OS, WASM_OPCODE_END, "opcode:end"); writeU8(os, WASM_OPCODE_END, "opcode:end");
} }
void wasm::writeLimits(raw_ostream &OS, const WasmLimits &Limits) { void wasm::writeLimits(raw_ostream &os, const WasmLimits &limits) {
writeU8(OS, Limits.Flags, "limits flags"); writeU8(os, limits.Flags, "limits flags");
writeUleb128(OS, Limits.Initial, "limits initial"); writeUleb128(os, limits.Initial, "limits initial");
if (Limits.Flags & WASM_LIMITS_FLAG_HAS_MAX) if (limits.Flags & WASM_LIMITS_FLAG_HAS_MAX)
writeUleb128(OS, Limits.Maximum, "limits max"); writeUleb128(os, limits.Maximum, "limits max");
} }
void wasm::writeGlobalType(raw_ostream &OS, const WasmGlobalType &Type) { void wasm::writeGlobalType(raw_ostream &os, const WasmGlobalType &type) {
// TODO: Update WasmGlobalType to use ValType and remove this cast. // TODO: Update WasmGlobalType to use ValType and remove this cast.
writeValueType(OS, ValType(Type.Type), "global type"); writeValueType(os, ValType(type.Type), "global type");
writeU8(OS, Type.Mutable, "global mutable"); writeU8(os, type.Mutable, "global mutable");
} }
void wasm::writeGlobal(raw_ostream &OS, const WasmGlobal &Global) { void wasm::writeGlobal(raw_ostream &os, const WasmGlobal &global) {
writeGlobalType(OS, Global.Type); writeGlobalType(os, global.Type);
writeInitExpr(OS, Global.InitExpr); writeInitExpr(os, global.InitExpr);
} }
void wasm::writeEventType(raw_ostream &OS, const WasmEventType &Type) { void wasm::writeEventType(raw_ostream &os, const WasmEventType &type) {
writeUleb128(OS, Type.Attribute, "event attribute"); writeUleb128(os, type.Attribute, "event attribute");
writeUleb128(OS, Type.SigIndex, "sig index"); writeUleb128(os, type.SigIndex, "sig index");
} }
void wasm::writeEvent(raw_ostream &OS, const WasmEvent &Event) { void wasm::writeEvent(raw_ostream &os, const WasmEvent &event) {
writeEventType(OS, Event.Type); writeEventType(os, event.Type);
} }
void wasm::writeTableType(raw_ostream &OS, const llvm::wasm::WasmTable &Type) { void wasm::writeTableType(raw_ostream &os, const llvm::wasm::WasmTable &type) {
writeU8(OS, WASM_TYPE_FUNCREF, "table type"); writeU8(os, WASM_TYPE_FUNCREF, "table type");
writeLimits(OS, Type.Limits); writeLimits(os, type.Limits);
} }
void wasm::writeImport(raw_ostream &OS, const WasmImport &Import) { void wasm::writeImport(raw_ostream &os, const WasmImport &import) {
writeStr(OS, Import.Module, "import module name"); writeStr(os, import.Module, "import module name");
writeStr(OS, Import.Field, "import field name"); writeStr(os, import.Field, "import field name");
writeU8(OS, Import.Kind, "import kind"); writeU8(os, import.Kind, "import kind");
switch (Import.Kind) { switch (import.Kind) {
case WASM_EXTERNAL_FUNCTION: case WASM_EXTERNAL_FUNCTION:
writeUleb128(OS, Import.SigIndex, "import sig index"); writeUleb128(os, import.SigIndex, "import sig index");
break; break;
case WASM_EXTERNAL_GLOBAL: case WASM_EXTERNAL_GLOBAL:
writeGlobalType(OS, Import.Global); writeGlobalType(os, import.Global);
break; break;
case WASM_EXTERNAL_EVENT: case WASM_EXTERNAL_EVENT:
writeEventType(OS, Import.Event); writeEventType(os, import.Event);
break; break;
case WASM_EXTERNAL_MEMORY: case WASM_EXTERNAL_MEMORY:
writeLimits(OS, Import.Memory); writeLimits(os, import.Memory);
break; break;
case WASM_EXTERNAL_TABLE: case WASM_EXTERNAL_TABLE:
writeTableType(OS, Import.Table); writeTableType(os, import.Table);
break; break;
default: default:
fatal("unsupported import type: " + Twine(Import.Kind)); fatal("unsupported import type: " + Twine(import.Kind));
} }
} }
void wasm::writeExport(raw_ostream &OS, const WasmExport &Export) { void wasm::writeExport(raw_ostream &os, const WasmExport &export_) {
writeStr(OS, Export.Name, "export name"); writeStr(os, export_.Name, "export name");
writeU8(OS, Export.Kind, "export kind"); writeU8(os, export_.Kind, "export kind");
switch (Export.Kind) { switch (export_.Kind) {
case WASM_EXTERNAL_FUNCTION: case WASM_EXTERNAL_FUNCTION:
writeUleb128(OS, Export.Index, "function index"); writeUleb128(os, export_.Index, "function index");
break; break;
case WASM_EXTERNAL_GLOBAL: case WASM_EXTERNAL_GLOBAL:
writeUleb128(OS, Export.Index, "global index"); writeUleb128(os, export_.Index, "global index");
break; break;
case WASM_EXTERNAL_MEMORY: case WASM_EXTERNAL_MEMORY:
writeUleb128(OS, Export.Index, "memory index"); writeUleb128(os, export_.Index, "memory index");
break; break;
case WASM_EXTERNAL_TABLE: case WASM_EXTERNAL_TABLE:
writeUleb128(OS, Export.Index, "table index"); writeUleb128(os, export_.Index, "table index");
break; break;
default: default:
fatal("unsupported export type: " + Twine(Export.Kind)); fatal("unsupported export type: " + Twine(export_.Kind));
} }
} }
} // namespace lld } // namespace lld
std::string lld::toString(ValType Type) { std::string lld::toString(ValType type) {
switch (Type) { switch (type) {
case ValType::I32: case ValType::I32:
return "i32"; return "i32";
case ValType::I64: case ValType::I64:
return "i64"; return "i64";
case ValType::F32: case ValType::F32:
return "f32"; return "f32";
case ValType::F64: case ValType::F64:
return "f64"; return "f64";
case ValType::V128: case ValType::V128:
return "v128"; return "v128";
case ValType::EXCEPT_REF: case ValType::EXCEPT_REF:
return "except_ref"; return "except_ref";
} }
llvm_unreachable("Invalid wasm::ValType"); llvm_unreachable("Invalid wasm::ValType");
} }
std::string lld::toString(const WasmSignature &Sig) { std::string lld::toString(const WasmSignature &sig) {
SmallString<128> S("("); SmallString<128> s("(");
for (ValType Type : Sig.Params) { for (ValType type : sig.Params) {
if (S.size() != 1) if (s.size() != 1)
S += ", "; s += ", ";
S += toString(Type); s += toString(type);
} }
S += ") -> "; s += ") -> ";
if (Sig.Returns.empty()) if (sig.Returns.empty())
S += "void"; s += "void";
else else
S += toString(Sig.Returns[0]); s += toString(sig.Returns[0]);
return S.str(); return s.str();
} }
std::string lld::toString(const WasmGlobalType &Type) { std::string lld::toString(const WasmGlobalType &type) {
return (Type.Mutable ? "var " : "const ") + return (type.Mutable ? "var " : "const ") +
toString(static_cast<ValType>(Type.Type)); toString(static_cast<ValType>(type.Type));
} }
std::string lld::toString(const WasmEventType &Type) { std::string lld::toString(const WasmEventType &type) {
if (Type.Attribute == WASM_EVENT_ATTRIBUTE_EXCEPTION) if (type.Attribute == WASM_EVENT_ATTRIBUTE_EXCEPTION)
return "exception"; return "exception";
return "unknown"; return "unknown";
} }