maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lld/test/MachO/symtab.s

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

174 lines
5.1 KiB
ArmAsm
Raw Normal View History

[lld-macho][reland] Add basic symbol table output This diff implements basic support for writing a symbol table. Attributes are loosely supported for extern symbols and not at all for other types. Initial version by Kellie Medlin <kelliem@fb.com> Originally committed in a3d95a50ee33 and reverted in fbae153ca583 due to UBSAN erroring over unaligned writes. That has been fixed in the current diff with the following changes: ``` diff --git a/lld/MachO/SyntheticSections.cpp b/lld/MachO/SyntheticSections.cpp --- a/lld/MachO/SyntheticSections.cpp +++ b/lld/MachO/SyntheticSections.cpp @@ -133,6 +133,9 @@ SymtabSection::SymtabSection(StringTableSection &stringTableSection) : stringTableSection(stringTableSection) { segname = segment_names::linkEdit; name = section_names::symbolTable; + // TODO: When we introduce the SyntheticSections superclass, we should make + // all synthetic sections aligned to WordSize by default. + align = WordSize; } size_t SymtabSection::getSize() const { diff --git a/lld/MachO/Writer.cpp b/lld/MachO/Writer.cpp --- a/lld/MachO/Writer.cpp +++ b/lld/MachO/Writer.cpp @@ -371,6 +371,7 @@ void Writer::assignAddresses(OutputSegment *seg) { ArrayRef<InputSection *> sections = p.second; for (InputSection *isec : sections) { addr = alignTo(addr, isec->align); + // We must align the file offsets too to avoid misaligned writes of + // structs. + fileOff = alignTo(fileOff, isec->align); isec->addr = addr; addr += isec->getSize(); fileOff += isec->getFileSize(); @@ -396,6 +397,7 @@ void Writer::writeSections() { uint64_t fileOff = seg->fileOff; for (auto &sect : seg->getSections()) { for (InputSection *isec : sect.second) { + fileOff = alignTo(fileOff, isec->align); isec->writeTo(buf + fileOff); fileOff += isec->getFileSize(); } ``` I don't think it's easy to write a test for alignment (that doesn't involve brittly hard-coding file offsets), so there isn't one... but UBSAN builds pass now. Differential Revision: https://reviews.llvm.org/D79050
2020-04-29 07:58:19 +08:00
# REQUIRES: x86
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# RUN: rm -rf %t && split-file %s %t
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test.s -o %t/test.o
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test2.s -o %t/test2.o
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/libfoo.s -o %t/libfoo.o
# RUN: %lld -dylib %t/libfoo.o -o %t/libfoo.dylib
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
# RUN: %lld -lSystem %t/test.o %t/test2.o %t/libfoo.dylib -o %t/test
[lld-macho][reland] Add basic symbol table output This diff implements basic support for writing a symbol table. Attributes are loosely supported for extern symbols and not at all for other types. Initial version by Kellie Medlin <kelliem@fb.com> Originally committed in a3d95a50ee33 and reverted in fbae153ca583 due to UBSAN erroring over unaligned writes. That has been fixed in the current diff with the following changes: ``` diff --git a/lld/MachO/SyntheticSections.cpp b/lld/MachO/SyntheticSections.cpp --- a/lld/MachO/SyntheticSections.cpp +++ b/lld/MachO/SyntheticSections.cpp @@ -133,6 +133,9 @@ SymtabSection::SymtabSection(StringTableSection &stringTableSection) : stringTableSection(stringTableSection) { segname = segment_names::linkEdit; name = section_names::symbolTable; + // TODO: When we introduce the SyntheticSections superclass, we should make + // all synthetic sections aligned to WordSize by default. + align = WordSize; } size_t SymtabSection::getSize() const { diff --git a/lld/MachO/Writer.cpp b/lld/MachO/Writer.cpp --- a/lld/MachO/Writer.cpp +++ b/lld/MachO/Writer.cpp @@ -371,6 +371,7 @@ void Writer::assignAddresses(OutputSegment *seg) { ArrayRef<InputSection *> sections = p.second; for (InputSection *isec : sections) { addr = alignTo(addr, isec->align); + // We must align the file offsets too to avoid misaligned writes of + // structs. + fileOff = alignTo(fileOff, isec->align); isec->addr = addr; addr += isec->getSize(); fileOff += isec->getFileSize(); @@ -396,6 +397,7 @@ void Writer::writeSections() { uint64_t fileOff = seg->fileOff; for (auto &sect : seg->getSections()) { for (InputSection *isec : sect.second) { + fileOff = alignTo(fileOff, isec->align); isec->writeTo(buf + fileOff); fileOff += isec->getFileSize(); } ``` I don't think it's easy to write a test for alignment (that doesn't involve brittly hard-coding file offsets), so there isn't one... but UBSAN builds pass now. Differential Revision: https://reviews.llvm.org/D79050
2020-04-29 07:58:19 +08:00
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# RUN: llvm-readobj --syms --sort-symbols=type,name --macho-dysymtab %t/test | FileCheck %s
[lld-macho][reland] Add basic symbol table output This diff implements basic support for writing a symbol table. Attributes are loosely supported for extern symbols and not at all for other types. Initial version by Kellie Medlin <kelliem@fb.com> Originally committed in a3d95a50ee33 and reverted in fbae153ca583 due to UBSAN erroring over unaligned writes. That has been fixed in the current diff with the following changes: ``` diff --git a/lld/MachO/SyntheticSections.cpp b/lld/MachO/SyntheticSections.cpp --- a/lld/MachO/SyntheticSections.cpp +++ b/lld/MachO/SyntheticSections.cpp @@ -133,6 +133,9 @@ SymtabSection::SymtabSection(StringTableSection &stringTableSection) : stringTableSection(stringTableSection) { segname = segment_names::linkEdit; name = section_names::symbolTable; + // TODO: When we introduce the SyntheticSections superclass, we should make + // all synthetic sections aligned to WordSize by default. + align = WordSize; } size_t SymtabSection::getSize() const { diff --git a/lld/MachO/Writer.cpp b/lld/MachO/Writer.cpp --- a/lld/MachO/Writer.cpp +++ b/lld/MachO/Writer.cpp @@ -371,6 +371,7 @@ void Writer::assignAddresses(OutputSegment *seg) { ArrayRef<InputSection *> sections = p.second; for (InputSection *isec : sections) { addr = alignTo(addr, isec->align); + // We must align the file offsets too to avoid misaligned writes of + // structs. + fileOff = alignTo(fileOff, isec->align); isec->addr = addr; addr += isec->getSize(); fileOff += isec->getFileSize(); @@ -396,6 +397,7 @@ void Writer::writeSections() { uint64_t fileOff = seg->fileOff; for (auto &sect : seg->getSections()) { for (InputSection *isec : sect.second) { + fileOff = alignTo(fileOff, isec->align); isec->writeTo(buf + fileOff); fileOff += isec->getFileSize(); } ``` I don't think it's easy to write a test for alignment (that doesn't involve brittly hard-coding file offsets), so there isn't one... but UBSAN builds pass now. Differential Revision: https://reviews.llvm.org/D79050
2020-04-29 07:58:19 +08:00
# CHECK: Symbols [
# CHECK-NEXT: Symbol {
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Name: _dynamic
# CHECK-NEXT: Extern
# CHECK-NEXT: Type: Undef (0x0)
# CHECK-NEXT: Section: (0x0)
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: RefType: UndefinedNonLazy (0x0)
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Flags [ (0x200)
# CHECK-NEXT: AltEntry (0x200)
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: ]
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Value: 0x0
# CHECK-NEXT: }
# CHECK-NEXT: Symbol {
# CHECK-NEXT: Name: dyld_stub_binder
# CHECK-NEXT: Extern
# CHECK-NEXT: Type: Undef (0x0)
# CHECK-NEXT: Section: (0x0)
# CHECK-NEXT: RefType: UndefinedNonLazy (0x0)
# CHECK-NEXT: Flags [ (0x100)
# CHECK-NEXT: SymbolResolver (0x100)
# CHECK-NEXT: ]
# CHECK-NEXT: Value: 0x0
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: }
# CHECK-NEXT: Symbol {
[lld/mac] Implement support for private extern symbols Private extern symbols are used for things scoped to the linkage unit. They cause duplicate symbol errors (so they're in the symbol table, unlike TU-scoped truly local symbols), but they don't make it into the export trie. They are created e.g. by compiling with -fvisibility=hidden. If two weak symbols have differing privateness, the combined symbol is non-private external. (Example: inline functions and some TUs that include the header defining it were built with -fvisibility-inlines-hidden and some weren't). A weak private external symbol implicitly has its "weak" dropped and behaves like a regular strong private external symbol: Weak is an export trie concept, and private symbols are not in the export trie. If a weak and a strong symbol have different privateness, the strong symbol wins. If two common symbols have differing privateness, the larger symbol wins. If they have the same size, the privateness of the symbol seen later during the link wins (!) -- this is a bit lame, but it matches ld64 and this behavior takes 2 lines less to implement than the less surprising "result is non-private external), so match ld64. (Example: `int a` in two .c files, both built with -fcommon, one built with -fvisibility=hidden and one without.) This also makes `__dyld_private` a true TU-local symbol, matching ld64. To make this work, make the `const char*` StringRefZ ctor to correctly set `size` (without this, writing the string table crashed when calling getName() on the __dyld_private symbol). Mention in CommonSymbol's comment that common symbols are now disabled by default in clang. Mention in -keep_private_externs's HelpText that the flag only has an effect with `-r` (which we don't implement yet -- so this patch here doesn't regress any behavior around -r + -keep_private_externs)). ld64 doesn't explicitly document it, but the commit text of http://reviews.llvm.org/rL216146 does, and ld64's OutputFile::buildSymbolTable() checks `_options.outputKind() == Options::kObjectFile` before calling `_options.keepPrivateExterns()` (the only reference to that function). Fixes PR48536. Differential Revision: https://reviews.llvm.org/D93609
2020-12-18 02:30:18 +08:00
# CHECK-NEXT: Name: __dyld_private
[lld-macho][reland] Add basic symbol table output This diff implements basic support for writing a symbol table. Attributes are loosely supported for extern symbols and not at all for other types. Initial version by Kellie Medlin <kelliem@fb.com> Originally committed in a3d95a50ee33 and reverted in fbae153ca583 due to UBSAN erroring over unaligned writes. That has been fixed in the current diff with the following changes: ``` diff --git a/lld/MachO/SyntheticSections.cpp b/lld/MachO/SyntheticSections.cpp --- a/lld/MachO/SyntheticSections.cpp +++ b/lld/MachO/SyntheticSections.cpp @@ -133,6 +133,9 @@ SymtabSection::SymtabSection(StringTableSection &stringTableSection) : stringTableSection(stringTableSection) { segname = segment_names::linkEdit; name = section_names::symbolTable; + // TODO: When we introduce the SyntheticSections superclass, we should make + // all synthetic sections aligned to WordSize by default. + align = WordSize; } size_t SymtabSection::getSize() const { diff --git a/lld/MachO/Writer.cpp b/lld/MachO/Writer.cpp --- a/lld/MachO/Writer.cpp +++ b/lld/MachO/Writer.cpp @@ -371,6 +371,7 @@ void Writer::assignAddresses(OutputSegment *seg) { ArrayRef<InputSection *> sections = p.second; for (InputSection *isec : sections) { addr = alignTo(addr, isec->align); + // We must align the file offsets too to avoid misaligned writes of + // structs. + fileOff = alignTo(fileOff, isec->align); isec->addr = addr; addr += isec->getSize(); fileOff += isec->getFileSize(); @@ -396,6 +397,7 @@ void Writer::writeSections() { uint64_t fileOff = seg->fileOff; for (auto &sect : seg->getSections()) { for (InputSection *isec : sect.second) { + fileOff = alignTo(fileOff, isec->align); isec->writeTo(buf + fileOff); fileOff += isec->getFileSize(); } ``` I don't think it's easy to write a test for alignment (that doesn't involve brittly hard-coding file offsets), so there isn't one... but UBSAN builds pass now. Differential Revision: https://reviews.llvm.org/D79050
2020-04-29 07:58:19 +08:00
# CHECK-NEXT: Type: Section (0xE)
[lld-macho] Fix alignment & layout to match ld64 and satisfy kernel & codesign The Mach kernel & codesign on arm64 macOS has strict requirements for alignment and sequence of segments and sections. Dyld probably is just as picky, though kernel & codesign reject malformed Mach-O files before dyld ever has a chance. I developed this diff by incrementally changing alignments & sequences to match the output of ld64. I stopped when my hello-world test program started working: `codesign --verify` succeded, and `execve(2)` didn't immediately fail with `errno == EBADMACHO` = `"Malformed Mach-O file"`. Differential Revision: https://reviews.llvm.org/D94935
2021-01-03 02:31:55 +08:00
# CHECK-NEXT: Section: __data
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: RefType: UndefinedNonLazy (0x0)
# CHECK-NEXT: Flags [ (0x0)
# CHECK-NEXT: ]
# CHECK-NEXT: Value: 0x1{{[0-9a-f]*}}
# CHECK-NEXT: }
# CHECK-NEXT: Symbol {
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Name: _local
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
# CHECK-NEXT: Type: Section (0xE)
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Section: __data
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
# CHECK-NEXT: RefType: UndefinedNonLazy (0x0)
# CHECK-NEXT: Flags [ (0x0)
# CHECK-NEXT: ]
# CHECK-NEXT: Value: 0x1{{[0-9a-f]*}}
# CHECK-NEXT: }
# CHECK-NEXT: Symbol {
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Name: __mh_execute_header
# CHECK-NEXT: Extern
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
# CHECK-NEXT: Type: Section (0xE)
# CHECK-NEXT: Section: __text (0x1)
# CHECK-NEXT: RefType: UndefinedNonLazy (0x0)
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Flags [ (0x10)
# CHECK-NEXT: ReferencedDynamically (0x10)
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
# CHECK-NEXT: ]
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Value: 0x100000000
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
# CHECK-NEXT: }
# CHECK-NEXT: Symbol {
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Name: _external
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: Extern
# CHECK-NEXT: Type: Section (0xE)
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Section: __data
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: RefType: UndefinedNonLazy (0x0)
[lld-macho][reland] Add basic symbol table output This diff implements basic support for writing a symbol table. Attributes are loosely supported for extern symbols and not at all for other types. Initial version by Kellie Medlin <kelliem@fb.com> Originally committed in a3d95a50ee33 and reverted in fbae153ca583 due to UBSAN erroring over unaligned writes. That has been fixed in the current diff with the following changes: ``` diff --git a/lld/MachO/SyntheticSections.cpp b/lld/MachO/SyntheticSections.cpp --- a/lld/MachO/SyntheticSections.cpp +++ b/lld/MachO/SyntheticSections.cpp @@ -133,6 +133,9 @@ SymtabSection::SymtabSection(StringTableSection &stringTableSection) : stringTableSection(stringTableSection) { segname = segment_names::linkEdit; name = section_names::symbolTable; + // TODO: When we introduce the SyntheticSections superclass, we should make + // all synthetic sections aligned to WordSize by default. + align = WordSize; } size_t SymtabSection::getSize() const { diff --git a/lld/MachO/Writer.cpp b/lld/MachO/Writer.cpp --- a/lld/MachO/Writer.cpp +++ b/lld/MachO/Writer.cpp @@ -371,6 +371,7 @@ void Writer::assignAddresses(OutputSegment *seg) { ArrayRef<InputSection *> sections = p.second; for (InputSection *isec : sections) { addr = alignTo(addr, isec->align); + // We must align the file offsets too to avoid misaligned writes of + // structs. + fileOff = alignTo(fileOff, isec->align); isec->addr = addr; addr += isec->getSize(); fileOff += isec->getFileSize(); @@ -396,6 +397,7 @@ void Writer::writeSections() { uint64_t fileOff = seg->fileOff; for (auto &sect : seg->getSections()) { for (InputSection *isec : sect.second) { + fileOff = alignTo(fileOff, isec->align); isec->writeTo(buf + fileOff); fileOff += isec->getFileSize(); } ``` I don't think it's easy to write a test for alignment (that doesn't involve brittly hard-coding file offsets), so there isn't one... but UBSAN builds pass now. Differential Revision: https://reviews.llvm.org/D79050
2020-04-29 07:58:19 +08:00
# CHECK-NEXT: Flags [ (0x0)
# CHECK-NEXT: ]
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: Value: 0x1{{[0-9a-f]*}}
[lld-macho][reland] Add basic symbol table output This diff implements basic support for writing a symbol table. Attributes are loosely supported for extern symbols and not at all for other types. Initial version by Kellie Medlin <kelliem@fb.com> Originally committed in a3d95a50ee33 and reverted in fbae153ca583 due to UBSAN erroring over unaligned writes. That has been fixed in the current diff with the following changes: ``` diff --git a/lld/MachO/SyntheticSections.cpp b/lld/MachO/SyntheticSections.cpp --- a/lld/MachO/SyntheticSections.cpp +++ b/lld/MachO/SyntheticSections.cpp @@ -133,6 +133,9 @@ SymtabSection::SymtabSection(StringTableSection &stringTableSection) : stringTableSection(stringTableSection) { segname = segment_names::linkEdit; name = section_names::symbolTable; + // TODO: When we introduce the SyntheticSections superclass, we should make + // all synthetic sections aligned to WordSize by default. + align = WordSize; } size_t SymtabSection::getSize() const { diff --git a/lld/MachO/Writer.cpp b/lld/MachO/Writer.cpp --- a/lld/MachO/Writer.cpp +++ b/lld/MachO/Writer.cpp @@ -371,6 +371,7 @@ void Writer::assignAddresses(OutputSegment *seg) { ArrayRef<InputSection *> sections = p.second; for (InputSection *isec : sections) { addr = alignTo(addr, isec->align); + // We must align the file offsets too to avoid misaligned writes of + // structs. + fileOff = alignTo(fileOff, isec->align); isec->addr = addr; addr += isec->getSize(); fileOff += isec->getFileSize(); @@ -396,6 +397,7 @@ void Writer::writeSections() { uint64_t fileOff = seg->fileOff; for (auto &sect : seg->getSections()) { for (InputSection *isec : sect.second) { + fileOff = alignTo(fileOff, isec->align); isec->writeTo(buf + fileOff); fileOff += isec->getFileSize(); } ``` I don't think it's easy to write a test for alignment (that doesn't involve brittly hard-coding file offsets), so there isn't one... but UBSAN builds pass now. Differential Revision: https://reviews.llvm.org/D79050
2020-04-29 07:58:19 +08:00
# CHECK-NEXT: }
[lld-macho] Implement basic export trie Build the trie by performing a three-way radix quicksort: We start by sorting the strings by their first characters, then sort the strings with the same first characters by their second characters, and so on recursively. Each time the prefixes diverge, we add a node to the trie. Thanks to @ruiu for the idea. I used llvm-mc's radix quicksort implementation as a starting point. The trie offset fixpoint code was taken from MachONormalizedFileBinaryWriter.cpp. Differential Revision: https://reviews.llvm.org/D76977
2020-04-30 06:42:19 +08:00
# CHECK-NEXT: Symbol {
[lld-macho] Fix & refactor symbol size calculations I noticed two problems with the previous implementation: * N_ALT_ENTRY symbols weren't being handled correctly -- they should determine the size of the previous symbol, even though they don't cause a new section to be created * The last symbol in a section had its size calculated wrongly; the first subsection's size was used instead of the last one I decided to take the opportunity to refactor things as well, mainly to realize my observation [here](https://reviews.llvm.org/D98837#inline-931511) that we could avoid doing a binary search to match symbols with subsections. I think the resulting code is a bit simpler too. N Min Max Median Avg Stddev x 20 4.31 4.43 4.37 4.3775 0.034162922 + 20 4.32 4.43 4.38 4.3755 0.02799906 No difference proven at 95.0% confidence Reviewed By: #lld-macho, alexshap Differential Revision: https://reviews.llvm.org/D99972
2021-04-07 03:09:14 +08:00
# CHECK-NEXT: Name: _external_weak
[lld-macho] Implement basic export trie Build the trie by performing a three-way radix quicksort: We start by sorting the strings by their first characters, then sort the strings with the same first characters by their second characters, and so on recursively. Each time the prefixes diverge, we add a node to the trie. Thanks to @ruiu for the idea. I used llvm-mc's radix quicksort implementation as a starting point. The trie offset fixpoint code was taken from MachONormalizedFileBinaryWriter.cpp. Differential Revision: https://reviews.llvm.org/D76977
2020-04-30 06:42:19 +08:00
# CHECK-NEXT: Extern
# CHECK-NEXT: Type: Section (0xE)
[lld-macho] Fix & refactor symbol size calculations I noticed two problems with the previous implementation: * N_ALT_ENTRY symbols weren't being handled correctly -- they should determine the size of the previous symbol, even though they don't cause a new section to be created * The last symbol in a section had its size calculated wrongly; the first subsection's size was used instead of the last one I decided to take the opportunity to refactor things as well, mainly to realize my observation [here](https://reviews.llvm.org/D98837#inline-931511) that we could avoid doing a binary search to match symbols with subsections. I think the resulting code is a bit simpler too. N Min Max Median Avg Stddev x 20 4.31 4.43 4.37 4.3775 0.034162922 + 20 4.32 4.43 4.38 4.3755 0.02799906 No difference proven at 95.0% confidence Reviewed By: #lld-macho, alexshap Differential Revision: https://reviews.llvm.org/D99972
2021-04-07 03:09:14 +08:00
# CHECK-NEXT: Section: __text (0x1)
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: RefType: UndefinedNonLazy (0x0)
[lld-macho] Fix & refactor symbol size calculations I noticed two problems with the previous implementation: * N_ALT_ENTRY symbols weren't being handled correctly -- they should determine the size of the previous symbol, even though they don't cause a new section to be created * The last symbol in a section had its size calculated wrongly; the first subsection's size was used instead of the last one I decided to take the opportunity to refactor things as well, mainly to realize my observation [here](https://reviews.llvm.org/D98837#inline-931511) that we could avoid doing a binary search to match symbols with subsections. I think the resulting code is a bit simpler too. N Min Max Median Avg Stddev x 20 4.31 4.43 4.37 4.3775 0.034162922 + 20 4.32 4.43 4.38 4.3755 0.02799906 No difference proven at 95.0% confidence Reviewed By: #lld-macho, alexshap Differential Revision: https://reviews.llvm.org/D99972
2021-04-07 03:09:14 +08:00
# CHECK-NEXT: Flags [ (0x80)
# CHECK-NEXT: WeakDef (0x80)
[lld-macho] Implement basic export trie Build the trie by performing a three-way radix quicksort: We start by sorting the strings by their first characters, then sort the strings with the same first characters by their second characters, and so on recursively. Each time the prefixes diverge, we add a node to the trie. Thanks to @ruiu for the idea. I used llvm-mc's radix quicksort implementation as a starting point. The trie offset fixpoint code was taken from MachONormalizedFileBinaryWriter.cpp. Differential Revision: https://reviews.llvm.org/D76977
2020-04-30 06:42:19 +08:00
# CHECK-NEXT: ]
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: Value: 0x1{{[0-9a-f]*}}
[lld-macho] Implement basic export trie Build the trie by performing a three-way radix quicksort: We start by sorting the strings by their first characters, then sort the strings with the same first characters by their second characters, and so on recursively. Each time the prefixes diverge, we add a node to the trie. Thanks to @ruiu for the idea. I used llvm-mc's radix quicksort implementation as a starting point. The trie offset fixpoint code was taken from MachONormalizedFileBinaryWriter.cpp. Differential Revision: https://reviews.llvm.org/D76977
2020-04-30 06:42:19 +08:00
# CHECK-NEXT: }
# CHECK-NEXT: Symbol {
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Name: _main
[lld-macho] Implement basic export trie Build the trie by performing a three-way radix quicksort: We start by sorting the strings by their first characters, then sort the strings with the same first characters by their second characters, and so on recursively. Each time the prefixes diverge, we add a node to the trie. Thanks to @ruiu for the idea. I used llvm-mc's radix quicksort implementation as a starting point. The trie offset fixpoint code was taken from MachONormalizedFileBinaryWriter.cpp. Differential Revision: https://reviews.llvm.org/D76977
2020-04-30 06:42:19 +08:00
# CHECK-NEXT: Extern
# CHECK-NEXT: Type: Section (0xE)
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Section: __text (0x1)
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: RefType: UndefinedNonLazy (0x0)
[lld-macho] Fix & refactor symbol size calculations I noticed two problems with the previous implementation: * N_ALT_ENTRY symbols weren't being handled correctly -- they should determine the size of the previous symbol, even though they don't cause a new section to be created * The last symbol in a section had its size calculated wrongly; the first subsection's size was used instead of the last one I decided to take the opportunity to refactor things as well, mainly to realize my observation [here](https://reviews.llvm.org/D98837#inline-931511) that we could avoid doing a binary search to match symbols with subsections. I think the resulting code is a bit simpler too. N Min Max Median Avg Stddev x 20 4.31 4.43 4.37 4.3775 0.034162922 + 20 4.32 4.43 4.38 4.3755 0.02799906 No difference proven at 95.0% confidence Reviewed By: #lld-macho, alexshap Differential Revision: https://reviews.llvm.org/D99972
2021-04-07 03:09:14 +08:00
# CHECK-NEXT: Flags [ (0x0)
[lld-macho] Implement basic export trie Build the trie by performing a three-way radix quicksort: We start by sorting the strings by their first characters, then sort the strings with the same first characters by their second characters, and so on recursively. Each time the prefixes diverge, we add a node to the trie. Thanks to @ruiu for the idea. I used llvm-mc's radix quicksort implementation as a starting point. The trie offset fixpoint code was taken from MachONormalizedFileBinaryWriter.cpp. Differential Revision: https://reviews.llvm.org/D76977
2020-04-30 06:42:19 +08:00
# CHECK-NEXT: ]
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: Value: 0x1{{[0-9a-f]*}}
# CHECK-NEXT: }
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
# CHECK-NEXT: Symbol {
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Name: _private_external
# CHECK-NEXT: PrivateExtern
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
# CHECK-NEXT: Type: Section (0xE)
# CHECK-NEXT: Section: __text (0x1)
# CHECK-NEXT: RefType: UndefinedNonLazy (0x0)
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Flags [ (0x0)
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: ]
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Value: 0x1{{[0-9a-f]*}}
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: }
# CHECK-NEXT: Symbol {
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Name: _private_external_weak
# CHECK-NEXT: PrivateExtern
# CHECK-NEXT: Type: Section (0xE)
# CHECK-NEXT: Section: __text (0x1)
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: RefType: UndefinedNonLazy (0x0)
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Flags [ (0x0)
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: ]
[lld][macho]Fix test to sort symbol table before dumping Details: The test previously expected a specific order of those symbols, which is not guaranteed (could change simply due to hashing changes, etc). So we change it to explicitly sort the symbols before checking contents. PR/53026 Differential Revision: https://reviews.llvm.org/D116813
2022-04-11 23:58:31 +08:00
# CHECK-NEXT: Value: 0x1{{[0-9a-f]*}}
[lld-macho] Implement basic export trie Build the trie by performing a three-way radix quicksort: We start by sorting the strings by their first characters, then sort the strings with the same first characters by their second characters, and so on recursively. Each time the prefixes diverge, we add a node to the trie. Thanks to @ruiu for the idea. I used llvm-mc's radix quicksort implementation as a starting point. The trie offset fixpoint code was taken from MachONormalizedFileBinaryWriter.cpp. Differential Revision: https://reviews.llvm.org/D76977
2020-04-30 06:42:19 +08:00
# CHECK-NEXT: }
[lld-macho][reland] Add basic symbol table output This diff implements basic support for writing a symbol table. Attributes are loosely supported for extern symbols and not at all for other types. Initial version by Kellie Medlin <kelliem@fb.com> Originally committed in a3d95a50ee33 and reverted in fbae153ca583 due to UBSAN erroring over unaligned writes. That has been fixed in the current diff with the following changes: ``` diff --git a/lld/MachO/SyntheticSections.cpp b/lld/MachO/SyntheticSections.cpp --- a/lld/MachO/SyntheticSections.cpp +++ b/lld/MachO/SyntheticSections.cpp @@ -133,6 +133,9 @@ SymtabSection::SymtabSection(StringTableSection &stringTableSection) : stringTableSection(stringTableSection) { segname = segment_names::linkEdit; name = section_names::symbolTable; + // TODO: When we introduce the SyntheticSections superclass, we should make + // all synthetic sections aligned to WordSize by default. + align = WordSize; } size_t SymtabSection::getSize() const { diff --git a/lld/MachO/Writer.cpp b/lld/MachO/Writer.cpp --- a/lld/MachO/Writer.cpp +++ b/lld/MachO/Writer.cpp @@ -371,6 +371,7 @@ void Writer::assignAddresses(OutputSegment *seg) { ArrayRef<InputSection *> sections = p.second; for (InputSection *isec : sections) { addr = alignTo(addr, isec->align); + // We must align the file offsets too to avoid misaligned writes of + // structs. + fileOff = alignTo(fileOff, isec->align); isec->addr = addr; addr += isec->getSize(); fileOff += isec->getFileSize(); @@ -396,6 +397,7 @@ void Writer::writeSections() { uint64_t fileOff = seg->fileOff; for (auto &sect : seg->getSections()) { for (InputSection *isec : sect.second) { + fileOff = alignTo(fileOff, isec->align); isec->writeTo(buf + fileOff); fileOff += isec->getFileSize(); } ``` I don't think it's easy to write a test for alignment (that doesn't involve brittly hard-coding file offsets), so there isn't one... but UBSAN builds pass now. Differential Revision: https://reviews.llvm.org/D79050
2020-04-29 07:58:19 +08:00
# CHECK-NEXT: ]
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: Dysymtab {
# CHECK-NEXT: ilocalsym: 0
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
# CHECK-NEXT: nlocalsym: 4
# CHECK-NEXT: iextdefsym: 4
[lld-macho] Define __mh_*_header synthetic symbols. Bug: https://bugs.llvm.org/show_bug.cgi?id=49290 Differential Revision: https://reviews.llvm.org/D97007
2021-03-19 06:49:45 +08:00
# CHECK-NEXT: nextdefsym: 4
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
# CHECK-NEXT: iundefsym: 8
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
# CHECK-NEXT: nundefsym: 2
glld/mac] Don't add names of unreferenced symbols to string table Before this, a hello world program would contain many many unnecessary entries in its string table. No behavior change, just makes the string table in the output smaller and more like ld64's. Differential Revision: https://reviews.llvm.org/D93711
2020-12-23 00:00:57 +08:00
## Verify that the first entry in the StringTable is a space, and that
## unreferenced symbols aren't emitted.
[lld-macho] Emit empty string as first entry of string table ld64 emits string tables which start with a space and a zero byte. We match its behavior here since some tools depend on it. Similar rationale as {D89561}. Reviewed By: #lld-macho, smeenai Differential Revision: https://reviews.llvm.org/D89639
2020-12-02 06:45:10 +08:00
# RUN: obj2yaml %t/test | FileCheck %s --check-prefix=YAML
# YAML: StringTable:
# YAML-NEXT: ' '
glld/mac] Don't add names of unreferenced symbols to string table Before this, a hello world program would contain many many unnecessary entries in its string table. No behavior change, just makes the string table in the output smaller and more like ld64's. Differential Revision: https://reviews.llvm.org/D93711
2020-12-23 00:00:57 +08:00
# YAML-NOT: _unreferenced
[lld-macho] Emit empty string as first entry of string table ld64 emits string tables which start with a space and a zero byte. We match its behavior here since some tools depend on it. Similar rationale as {D89561}. Reviewed By: #lld-macho, smeenai Differential Revision: https://reviews.llvm.org/D89639
2020-12-02 06:45:10 +08:00
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
#--- libfoo.s
.globl _dynamic
_dynamic:
#--- test.s
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
.globl _main, _external, _private_external, _external_weak, _private_external_weak, _unreferenced
[lld-macho][reland] Add basic symbol table output This diff implements basic support for writing a symbol table. Attributes are loosely supported for extern symbols and not at all for other types. Initial version by Kellie Medlin <kelliem@fb.com> Originally committed in a3d95a50ee33 and reverted in fbae153ca583 due to UBSAN erroring over unaligned writes. That has been fixed in the current diff with the following changes: ``` diff --git a/lld/MachO/SyntheticSections.cpp b/lld/MachO/SyntheticSections.cpp --- a/lld/MachO/SyntheticSections.cpp +++ b/lld/MachO/SyntheticSections.cpp @@ -133,6 +133,9 @@ SymtabSection::SymtabSection(StringTableSection &stringTableSection) : stringTableSection(stringTableSection) { segname = segment_names::linkEdit; name = section_names::symbolTable; + // TODO: When we introduce the SyntheticSections superclass, we should make + // all synthetic sections aligned to WordSize by default. + align = WordSize; } size_t SymtabSection::getSize() const { diff --git a/lld/MachO/Writer.cpp b/lld/MachO/Writer.cpp --- a/lld/MachO/Writer.cpp +++ b/lld/MachO/Writer.cpp @@ -371,6 +371,7 @@ void Writer::assignAddresses(OutputSegment *seg) { ArrayRef<InputSection *> sections = p.second; for (InputSection *isec : sections) { addr = alignTo(addr, isec->align); + // We must align the file offsets too to avoid misaligned writes of + // structs. + fileOff = alignTo(fileOff, isec->align); isec->addr = addr; addr += isec->getSize(); fileOff += isec->getFileSize(); @@ -396,6 +397,7 @@ void Writer::writeSections() { uint64_t fileOff = seg->fileOff; for (auto &sect : seg->getSections()) { for (InputSection *isec : sect.second) { + fileOff = alignTo(fileOff, isec->align); isec->writeTo(buf + fileOff); fileOff += isec->getFileSize(); } ``` I don't think it's easy to write a test for alignment (that doesn't involve brittly hard-coding file offsets), so there isn't one... but UBSAN builds pass now. Differential Revision: https://reviews.llvm.org/D79050
2020-04-29 07:58:19 +08:00
[lld-macho] Implement basic export trie Build the trie by performing a three-way radix quicksort: We start by sorting the strings by their first characters, then sort the strings with the same first characters by their second characters, and so on recursively. Each time the prefixes diverge, we add a node to the trie. Thanks to @ruiu for the idea. I used llvm-mc's radix quicksort implementation as a starting point. The trie offset fixpoint code was taken from MachONormalizedFileBinaryWriter.cpp. Differential Revision: https://reviews.llvm.org/D76977
2020-04-30 06:42:19 +08:00
.data
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
_external:
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
.space 1
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
_local:
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
.space 1
[lld-macho] Implement basic export trie Build the trie by performing a three-way radix quicksort: We start by sorting the strings by their first characters, then sort the strings with the same first characters by their second characters, and so on recursively. Each time the prefixes diverge, we add a node to the trie. Thanks to @ruiu for the idea. I used llvm-mc's radix quicksort implementation as a starting point. The trie offset fixpoint code was taken from MachONormalizedFileBinaryWriter.cpp. Differential Revision: https://reviews.llvm.org/D76977
2020-04-30 06:42:19 +08:00
.text
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
.weak_definition _external_weak
_external_weak:
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
.space 1
.private_extern _private_external
_private_external:
.space 1
.weak_definition _private_external_weak
.private_extern _private_external_weak
_private_external_weak:
.space 1
[lld-macho][reland] Add basic symbol table output This diff implements basic support for writing a symbol table. Attributes are loosely supported for extern symbols and not at all for other types. Initial version by Kellie Medlin <kelliem@fb.com> Originally committed in a3d95a50ee33 and reverted in fbae153ca583 due to UBSAN erroring over unaligned writes. That has been fixed in the current diff with the following changes: ``` diff --git a/lld/MachO/SyntheticSections.cpp b/lld/MachO/SyntheticSections.cpp --- a/lld/MachO/SyntheticSections.cpp +++ b/lld/MachO/SyntheticSections.cpp @@ -133,6 +133,9 @@ SymtabSection::SymtabSection(StringTableSection &stringTableSection) : stringTableSection(stringTableSection) { segname = segment_names::linkEdit; name = section_names::symbolTable; + // TODO: When we introduce the SyntheticSections superclass, we should make + // all synthetic sections aligned to WordSize by default. + align = WordSize; } size_t SymtabSection::getSize() const { diff --git a/lld/MachO/Writer.cpp b/lld/MachO/Writer.cpp --- a/lld/MachO/Writer.cpp +++ b/lld/MachO/Writer.cpp @@ -371,6 +371,7 @@ void Writer::assignAddresses(OutputSegment *seg) { ArrayRef<InputSection *> sections = p.second; for (InputSection *isec : sections) { addr = alignTo(addr, isec->align); + // We must align the file offsets too to avoid misaligned writes of + // structs. + fileOff = alignTo(fileOff, isec->align); isec->addr = addr; addr += isec->getSize(); fileOff += isec->getFileSize(); @@ -396,6 +397,7 @@ void Writer::writeSections() { uint64_t fileOff = seg->fileOff; for (auto &sect : seg->getSections()) { for (InputSection *isec : sect.second) { + fileOff = alignTo(fileOff, isec->align); isec->writeTo(buf + fileOff); fileOff += isec->getFileSize(); } ``` I don't think it's easy to write a test for alignment (that doesn't involve brittly hard-coding file offsets), so there isn't one... but UBSAN builds pass now. Differential Revision: https://reviews.llvm.org/D79050
2020-04-29 07:58:19 +08:00
_main:
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
callq _private_external
[lld-macho] Emit local symbols in symtab; record metadata in LC_DYSYMTAB Symbols of the same type must be laid out contiguously: following ld64's lead, we choose to emit all local symbols first, then external symbols, and finally undefined symbols. For each symbol type, the LC_DYSYMTAB load command will record the range (start index and total number) of those symbols in the symbol table. This work was motivated by the fact that LLDB won't search for debug info if LC_DYSYMTAB says there are no local symbols (since STABS symbols are all local symbols). With this change, LLDB is now able to display the source lines at a given breakpoint when debugging our binaries. Some tests had to be updated due to local symbol names now appearing in `llvm-objdump`'s output. Reviewed By: #lld-macho, smeenai, clayborg Differential Revision: https://reviews.llvm.org/D89285
2020-12-02 06:45:09 +08:00
callq _dynamic
[lld-macho][reland] Add basic symbol table output This diff implements basic support for writing a symbol table. Attributes are loosely supported for extern symbols and not at all for other types. Initial version by Kellie Medlin <kelliem@fb.com> Originally committed in a3d95a50ee33 and reverted in fbae153ca583 due to UBSAN erroring over unaligned writes. That has been fixed in the current diff with the following changes: ``` diff --git a/lld/MachO/SyntheticSections.cpp b/lld/MachO/SyntheticSections.cpp --- a/lld/MachO/SyntheticSections.cpp +++ b/lld/MachO/SyntheticSections.cpp @@ -133,6 +133,9 @@ SymtabSection::SymtabSection(StringTableSection &stringTableSection) : stringTableSection(stringTableSection) { segname = segment_names::linkEdit; name = section_names::symbolTable; + // TODO: When we introduce the SyntheticSections superclass, we should make + // all synthetic sections aligned to WordSize by default. + align = WordSize; } size_t SymtabSection::getSize() const { diff --git a/lld/MachO/Writer.cpp b/lld/MachO/Writer.cpp --- a/lld/MachO/Writer.cpp +++ b/lld/MachO/Writer.cpp @@ -371,6 +371,7 @@ void Writer::assignAddresses(OutputSegment *seg) { ArrayRef<InputSection *> sections = p.second; for (InputSection *isec : sections) { addr = alignTo(addr, isec->align); + // We must align the file offsets too to avoid misaligned writes of + // structs. + fileOff = alignTo(fileOff, isec->align); isec->addr = addr; addr += isec->getSize(); fileOff += isec->getFileSize(); @@ -396,6 +397,7 @@ void Writer::writeSections() { uint64_t fileOff = seg->fileOff; for (auto &sect : seg->getSections()) { for (InputSection *isec : sect.second) { + fileOff = alignTo(fileOff, isec->align); isec->writeTo(buf + fileOff); fileOff += isec->getFileSize(); } ``` I don't think it's easy to write a test for alignment (that doesn't involve brittly hard-coding file offsets), so there isn't one... but UBSAN builds pass now. Differential Revision: https://reviews.llvm.org/D79050
2020-04-29 07:58:19 +08:00
mov $0, %rax
ret
[lld/mac] Correctly set nextdefsym In LC_DYSYMTAB, private externs were still emitted as exported symbols instead of as locals. Fixes PR50373. See bug for details. Differential Revision: https://reviews.llvm.org/D102662
2021-05-18 01:49:17 +08:00
#--- test2.s
## These are both already in test.s and should make it into the symbol table
## just once.
.globl _external_weak, _private_external_weak
.text
.weak_definition _external_weak
_external_weak:
.space 1
.weak_definition _private_external_weak
.private_extern _private_external_weak
_private_external_weak:
.space 1