# REQUIRES: x86, llvm-64-bits
# RUN: rm -rf %t; split-file %s %t
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/basics.s -o %t/basics.o
## Check that .private_extern symbols are marked as local in the symbol table
## and aren't in the export trie.
# RUN: %lld -lSystem -dead_strip -map %t/map -u _ref_private_extern_u \
# RUN: %t/basics.o -o %t/basics
# RUN: llvm-objdump --syms --section-headers %t/basics | \
# RUN: FileCheck --check-prefix=EXEC --implicit-check-not _unref %s
# RUN: llvm-objdump --macho --section=__DATA,__ref_section \
# RUN: --exports-trie --indirect-symbols %t/basics | \
# RUN: FileCheck --check-prefix=EXECDATA --implicit-check-not _unref %s
# RUN: llvm-otool -l %t/basics | grep -q 'segname __PAGEZERO'
# EXEC-LABEL: Sections:
# EXEC-LABEL: Name
# EXEC-NEXT: __text
# EXEC-NEXT: __got
# EXEC-NEXT: __ref_section
# EXEC-NEXT: __common
# EXEC-LABEL: SYMBOL TABLE:
# EXEC-DAG: l {{.*}} _ref_data
# EXEC-DAG: l {{.*}} _ref_local
# EXEC-DAG: l {{.*}} _ref_from_no_dead_strip_globl
# EXEC-DAG: l {{.*}} _no_dead_strip_local
# EXEC-DAG: l {{.*}} _ref_from_no_dead_strip_local
# EXEC-DAG: l {{.*}} _ref_private_extern_u
# EXEC-DAG: l {{.*}} _main
# EXEC-DAG: l {{.*}} _ref_private_extern
# EXEC-DAG: g {{.*}} _no_dead_strip_globl
# EXEC-DAG: g {{.*}} _ref_com
# EXEC-DAG: g {{.*}} __mh_execute_header
# EXECDATA-LABEL: Indirect symbols
# EXECDATA-NEXT: name
# EXECDATA-NEXT: LOCAL
# EXECDATA-LABEL: Contents of (__DATA,__ref_section) section
# EXECDATA-NEXT: 04 00 00 00 00 00 00 00 05 00 00 00 00 00 00 00
# EXECDATA-LABEL: Exports trie:
# EXECDATA-DAG: _ref_com
# EXECDATA-DAG: _no_dead_strip_globl
# EXECDATA-DAG: __mh_execute_header
## Check that dead stripped symbols get listed properly.
# RUN: FileCheck --check-prefix=MAP %s < %t/map
# MAP: _main
# MAP-LABEL: Dead Stripped Symbols
# MAP-DAG: <<dead>> 0x00000001 [ 2] _unref_com
# MAP-DAG: <<dead>> 0x00000008 [ 2] _unref_data
# MAP-DAG: <<dead>> 0x00000006 [ 2] _unref_extern
# MAP-DAG: <<dead>> 0x00000001 [ 2] _unref_local
# MAP-DAG: <<dead>> 0x00000007 [ 2] _unref_private_extern
# MAP-DAG: <<dead>> 0x00000008 [ 2] l_unref_data
## Run dead stripping on code without any dead symbols.
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/no-dead-symbols.s -o %t/no-dead-symbols.o
# RUN: %lld -lSystem -dead_strip -map %t/no-dead-symbols-map \
# RUN: %t/no-dead-symbols.o -o %t/no-dead-symbols
## Mark the end of the file with a string.
# RUN: FileCheck --check-prefix=NODEADSYMBOLS %s < %t/no-dead-symbols-map
# NODEADSYMBOLS-LABEL: # Symbols:
# NODEADSYMBOLS-NEXT: # Address Size File Name
# NODEADSYMBOLS-NEXT: _main
# NODEADSYMBOLS-LABEL: # Dead Stripped Symbols:
# NODEADSYMBOLS-NEXT: # Size File Name
# NODEADSYMBOLS-EMPTY:
# RUN: %lld -dylib -dead_strip -u _ref_private_extern_u %t/basics.o -o %t/basics.dylib
# RUN: llvm-objdump --syms %t/basics.dylib | \
# RUN: FileCheck --check-prefix=DYLIB --implicit-check-not _unref %s
# RUN: %lld -bundle -dead_strip -u _ref_private_extern_u %t/basics.o -o %t/basics.dylib
# RUN: llvm-objdump --syms %t/basics.dylib | \
# RUN: FileCheck --check-prefix=DYLIB --implicit-check-not _unref %s
# DYLIB-LABEL: SYMBOL TABLE:
# DYLIB-DAG: l {{.*}} _ref_data
# DYLIB-DAG: l {{.*}} _ref_local
# DYLIB-DAG: l {{.*}} _ref_from_no_dead_strip_globl
# DYLIB-DAG: l {{.*}} _no_dead_strip_local
# DYLIB-DAG: l {{.*}} _ref_from_no_dead_strip_local
# DYLIB-DAG: l {{.*}} _ref_private_extern_u
# DYLIB-DAG: l {{.*}} _ref_private_extern
# DYLIB-DAG: g {{.*}} _ref_com
# DYLIB-DAG: g {{.*}} _unref_com
# DYLIB-DAG: g {{.*}} _unref_extern
# DYLIB-DAG: g {{.*}} _no_dead_strip_globl
## Extern symbols aren't stripped from executables with -export_dynamic
# RUN: %lld -lSystem -dead_strip -export_dynamic -u _ref_private_extern_u \
# RUN: %t/basics.o -o %t/basics-export-dyn
# RUN: llvm-objdump --syms --section-headers %t/basics-export-dyn | \
# RUN: FileCheck --check-prefix=EXECDYN %s
# EXECDYN-LABEL: Sections:
# EXECDYN-LABEL: Name
# EXECDYN-NEXT: __text
# EXECDYN-NEXT: __got
# EXECDYN-NEXT: __ref_section
# EXECDYN-NEXT: __common
# EXECDYN-LABEL: SYMBOL TABLE:
# EXECDYN-DAG: l {{.*}} _ref_data
# EXECDYN-DAG: l {{.*}} _ref_local
# EXECDYN-DAG: l {{.*}} _ref_from_no_dead_strip_globl
# EXECDYN-DAG: l {{.*}} _no_dead_strip_local
# EXECDYN-DAG: l {{.*}} _ref_from_no_dead_strip_local
# EXECDYN-DAG: l {{.*}} _ref_private_extern_u
# EXECDYN-DAG: l {{.*}} _main
# EXECDYN-DAG: l {{.*}} _ref_private_extern
# EXECDYN-DAG: g {{.*}} _ref_com
# EXECDYN-DAG: g {{.*}} _unref_com
# EXECDYN-DAG: g {{.*}} _unref_extern
# EXECDYN-DAG: g {{.*}} _no_dead_strip_globl
# EXECDYN-DAG: g {{.*}} __mh_execute_header
## Absolute symbol handling.
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/abs.s -o %t/abs.o
# RUN: %lld -lSystem -dead_strip %t/abs.o -o %t/abs
# RUN: llvm-objdump --macho --syms --exports-trie %t/abs | \
# RUN: FileCheck --check-prefix=ABS %s
#ABS-LABEL: SYMBOL TABLE:
#ABS-NEXT: g {{.*}} _main
#ABS-NEXT: g *ABS* _abs1
#ABS-NEXT: g {{.*}} __mh_execute_header
#ABS-LABEL: Exports trie:
#ABS-NEXT: __mh_execute_header
#ABS-NEXT: _main
#ABS-NEXT: _abs1 [absolute]
## Check that symbols from -exported_symbol(s_list) are preserved.
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/exported-symbol.s -o %t/exported-symbol.o
# RUN: %lld -lSystem -dead_strip -exported_symbol _my_exported_symbol \
# RUN: %t/exported-symbol.o -o %t/exported-symbol
# RUN: llvm-objdump --syms %t/exported-symbol | \
# RUN: FileCheck --check-prefix=EXPORTEDSYMBOL --implicit-check-not _unref %s
# EXPORTEDSYMBOL-LABEL: SYMBOL TABLE:
# EXPORTEDSYMBOL-NEXT: l {{.*}} _main
# EXPORTEDSYMBOL-NEXT: l {{.*}} __mh_execute_header
# EXPORTEDSYMBOL-NEXT: g {{.*}} _my_exported_symbol
## Check that mod_init_funcs and mod_term_funcs are not stripped.
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/mod-funcs.s -o %t/mod-funcs.o
# RUN: %lld -lSystem -dead_strip %t/mod-funcs.o -o %t/mod-funcs
# RUN: llvm-objdump --syms %t/mod-funcs | \
# RUN: FileCheck --check-prefix=MODFUNCS --implicit-check-not _unref %s
# MODFUNCS-LABEL: SYMBOL TABLE:
# MODFUNCS-NEXT: l {{.*}} _ref_from_init
# MODFUNCS-NEXT: l {{.*}} _ref_init
# MODFUNCS-NEXT: l {{.*}} _ref_from_term
# MODFUNCS-NEXT: l {{.*}} _ref_term
# MODFUNCS-NEXT: g {{.*}} _main
# MODFUNCS-NEXT: g {{.*}} __mh_execute_header
## Check that DylibSymbols in dead subsections are stripped: They should
## not be in the import table and should have no import stubs.
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/dylib.s -o %t/dylib.o
# RUN: %lld -dylib -dead_strip %t/dylib.o -o %t/dylib.dylib
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/strip-dylib-ref.s -o %t/strip-dylib-ref.o
# RUN: %lld -lSystem -dead_strip %t/strip-dylib-ref.o %t/dylib.dylib \
# RUN: -o %t/strip-dylib-ref -U _ref_undef_fun -U _unref_undef_fun
# RUN: llvm-objdump --syms --bind --lazy-bind --weak-bind %t/strip-dylib-ref | \
# RUN: FileCheck --check-prefix=STRIPDYLIB --implicit-check-not _unref %s
# STRIPDYLIB: SYMBOL TABLE:
# STRIPDYLIB-NEXT: l {{.*}} __dyld_private
# STRIPDYLIB-NEXT: g {{.*}} _main
# STRIPDYLIB-NEXT: g {{.*}} __mh_execute_header
# STRIPDYLIB-NEXT: *UND* dyld_stub_binder
# STRIPDYLIB-NEXT: *UND* _ref_dylib_fun
# STRIPDYLIB-NEXT: *UND* _ref_undef_fun
# STRIPDYLIB: Bind table:
# STRIPDYLIB: Lazy bind table:
# STRIPDYLIB: __DATA __la_symbol_ptr {{.*}} flat-namespace _ref_undef_fun
# STRIPDYLIB: __DATA __la_symbol_ptr {{.*}} dylib _ref_dylib_fun
# STRIPDYLIB: Weak bind table:
## Stubs smoke check: There should be two stubs entries, not four, but we
## don't verify that they belong to _ref_undef_fun and _ref_dylib_fun.
# RUN: llvm-objdump -d --section=__stubs --section=__stub_helper \
# RUN: %t/strip-dylib-ref |FileCheck --check-prefix=STUBS %s
# STUBS-LABEL: <__stubs>:
# STUBS-NEXT: jmpq
# STUBS-NEXT: jmpq
# STUBS-NOT: jmpq
# STUBS-LABEL: <__stub_helper>:
# STUBS: pushq $0
# STUBS: jmp
# STUBS: jmp
# STUBS-NOT: jmp
## An undefined symbol referenced from a dead-stripped function shouldn't
## produce a diagnostic:
# RUN: %lld -lSystem -dead_strip %t/strip-dylib-ref.o %t/dylib.dylib \
# RUN: -o %t/strip-dylib-ref -U _ref_undef_fun
## Check that referenced undefs are kept with -undefined dynamic_lookup.
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/ref-undef.s -o %t/ref-undef.o
# RUN: %lld -lSystem -dead_strip %t/ref-undef.o \
# RUN: -o %t/ref-undef -undefined dynamic_lookup
# RUN: llvm-objdump --syms --lazy-bind %t/ref-undef | \
# RUN: FileCheck --check-prefix=STRIPDYNLOOKUP %s
# STRIPDYNLOOKUP: SYMBOL TABLE:
# STRIPDYNLOOKUP: *UND* _ref_undef_fun
# STRIPDYNLOOKUP: Lazy bind table:
# STRIPDYNLOOKUP: __DATA __la_symbol_ptr {{.*}} flat-namespace _ref_undef_fun
## S_ATTR_LIVE_SUPPORT tests.
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/live-support.s -o %t/live-support.o
# RUN: %lld -lSystem -dead_strip %t/live-support.o %t/dylib.dylib \
# RUN: -U _ref_undef_fun -U _unref_undef_fun -o %t/live-support
# RUN: llvm-objdump --syms %t/live-support | \
# RUN: FileCheck --check-prefix=LIVESUPP --implicit-check-not _unref %s
# LIVESUPP-LABEL: SYMBOL TABLE:
# LIVESUPP-NEXT: l {{.*}} _ref_ls_fun_fw
# LIVESUPP-NEXT: l {{.*}} _ref_ls_fun_bw
# LIVESUPP-NEXT: l {{.*}} _ref_ls_dylib_fun
# LIVESUPP-NEXT: l {{.*}} _ref_ls_undef_fun
# LIVESUPP-NEXT: l {{.*}} __dyld_private
# LIVESUPP-NEXT: g {{.*}} _main
# LIVESUPP-NEXT: g {{.*}} _bar
# LIVESUPP-NEXT: g {{.*}} _foo
# LIVESUPP-NEXT: g {{.*}} __mh_execute_header
# LIVESUPP-NEXT: *UND* dyld_stub_binder
# LIVESUPP-NEXT: *UND* _ref_dylib_fun
# LIVESUPP-NEXT: *UND* _ref_undef_fun
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/live-support-iterations.s -o %t/live-support-iterations.o
# RUN: %lld -lSystem -dead_strip %t/live-support-iterations.o \
# RUN: -o %t/live-support-iterations
# RUN: llvm-objdump --syms %t/live-support-iterations | \
# RUN: FileCheck --check-prefix=LIVESUPP2 --implicit-check-not _unref %s
# LIVESUPP2-LABEL: SYMBOL TABLE:
# LIVESUPP2-NEXT: l {{.*}} _bar
# LIVESUPP2-NEXT: l {{.*}} _foo_refd
# LIVESUPP2-NEXT: l {{.*}} _bar_refd
# LIVESUPP2-NEXT: l {{.*}} _baz
# LIVESUPP2-NEXT: l {{.*}} _baz_refd
# LIVESUPP2-NEXT: l {{.*}} _foo
# LIVESUPP2-NEXT: g {{.*}} _main
# LIVESUPP2-NEXT: g {{.*}} __mh_execute_header
## Dead stripping should not remove the __TEXT,__unwind_info
## and __TEXT,__gcc_except_tab functions, but it should still
## remove the unreferenced function __Z5unref.
## The reference to ___gxx_personality_v0 should also not be
## stripped.
## (Need to use darwin19.0.0 to make -mc emit __LD,__compact_unwind.)
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 \
# RUN: %t/unwind.s -o %t/unwind.o
# RUN: %lld -lc++ -lSystem -dead_strip %t/unwind.o -o %t/unwind
# RUN: llvm-objdump --syms %t/unwind | \
# RUN: FileCheck --check-prefix=UNWIND --implicit-check-not unref %s
# RUN: llvm-otool -l %t/unwind | FileCheck --check-prefix=UNWINDSECT %s
# UNWINDSECT-DAG: sectname __unwind_info
# UNWINDSECT-DAG: sectname __gcc_except_tab
# UNWIND-LABEL: SYMBOL TABLE:
# UNWIND-NEXT: l O __TEXT,__gcc_except_tab GCC_except_table1
# UNWIND-NEXT: l O __DATA,__data __dyld_private
# UNWIND-NEXT: g F __TEXT,__text _main
# UNWIND-NEXT: g F __TEXT,__text __mh_execute_header
# UNWIND-NEXT: *UND* dyld_stub_binder
# UNWIND-NEXT: *UND* __ZTIi
# UNWIND-NEXT: *UND* ___cxa_allocate_exception
# UNWIND-NEXT: *UND* ___cxa_begin_catch
# UNWIND-NEXT: *UND* ___cxa_end_catch
# UNWIND-NEXT: *UND* ___cxa_throw
# UNWIND-NEXT: *UND* ___gxx_personality_v0
# UNWIND-NOT: GCC_except_table0
## If a dead stripped function has a strong ref to a dylib symbol but
## a live function only a weak ref, the dylib is still not a WEAK_DYLIB.
## This matches ld64.
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/weak-ref.s -o %t/weak-ref.o
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/strong-dead-ref.s -o %t/strong-dead-ref.o
# RUN: %lld -lSystem -dead_strip %t/weak-ref.o %t/strong-dead-ref.o \
# RUN: %t/dylib.dylib -o %t/weak-ref
# RUN: llvm-otool -l %t/weak-ref | FileCheck -DDIR=%t --check-prefix=WEAK %s
# WEAK: cmd LC_LOAD_DYLIB
# WEAK-NEXT: cmdsize
# WEAK-NEXT: name /usr/lib/libSystem.dylib
# WEAK: cmd LC_LOAD_DYLIB
# WEAK-NEXT: cmdsize
# WEAK-NEXT: name [[DIR]]/dylib.dylib
## A strong symbol that would override a weak import does not emit the
## "this overrides a weak import" opcode if it is dead-stripped.
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/weak-dylib.s -o %t/weak-dylib.o
# RUN: %lld -dylib -dead_strip %t/weak-dylib.o -o %t/weak-dylib.dylib
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/dead-weak-override.s -o %t/dead-weak-override.o
# RUN: %lld -dead_strip %t/dead-weak-override.o %t/weak-dylib.dylib \
# RUN: -o %t/dead-weak-override
# RUN: llvm-objdump --macho --weak-bind --private-header \
# RUN: %t/dead-weak-override | FileCheck --check-prefix=DEADWEAK %s
# DEADWEAK-NOT: WEAK_DEFINES
# DEADWEAK: Weak bind table:
# DEADWEAK: segment section address type addend symbol
# DEADWEAK-NOT: strong _weak_in_dylib
## Stripped symbols should not be in the debug info stabs entries.
# RUN: llvm-mc -g -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/debug.s -o %t/debug.o
# RUN: %lld -lSystem -dead_strip %t/debug.o -o %t/debug
# RUN: dsymutil -s %t/debug | FileCheck --check-prefix=EXECSTABS %s
# EXECSTABS-NOT: N_FUN {{.*}} '_unref'
# EXECSTABS: N_FUN {{.*}} '_main'
# EXECSTABS-NOT: N_FUN {{.*}} '_unref'
# RUN: llvm-mc -g -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/literals.s -o %t/literals.o
# RUN: %lld -dylib -dead_strip %t/literals.o -o %t/literals
# RUN: llvm-objdump --macho --section="__TEXT,__cstring" --section="__DATA,str_ptrs" \
# RUN: --section="__TEXT,__literals" %t/literals | FileCheck %s --check-prefix=LIT
# LIT: Contents of (__TEXT,__cstring) section
# LIT-NEXT: foobar
# LIT-NEXT: Contents of (__DATA,str_ptrs) section
# LIT-NEXT: __TEXT:__cstring:bar
# LIT-NEXT: __TEXT:__cstring:bar
# LIT-NEXT: Contents of (__TEXT,__literals) section
# LIT-NEXT: ef be ad de {{$}}
## Ensure that addrsig metadata does not keep unreferenced functions alive.
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/addrsig.s -o %t/addrsig.o
# RUN: %lld -lSystem -dead_strip --icf=safe %t/addrsig.o -o %t/addrsig
# RUN: llvm-objdump --syms %t/addrsig | \
# RUN: FileCheck --check-prefix=ADDSIG --implicit-check-not _addrsig %s
# ADDSIG-LABEL: SYMBOL TABLE:
# ADDSIG-NEXT: g F __TEXT,__text _main
# ADDSIG-NEXT: g F __TEXT,__text __mh_execute_header
# ADDSIG-NEXT: *UND* dyld_stub_binder
## Duplicate symbols that will be dead stripped later should not fail when using
## the --dead-stripped-duplicates flag
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/duplicate1.s -o %t/duplicate1.o
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
# RUN: %t/duplicate2.s -o %t/duplicate2.o
# RUN: %lld -lSystem -dead_strip --dead-strip-duplicates -map %t/stripped-duplicate-map \
# RUN: %t/duplicate1.o %t/duplicate2.o -o %t/duplicate
# RUN: llvm-objdump --syms %t/duplicate | FileCheck %s --check-prefix=DUP
# DUP-LABEL: SYMBOL TABLE:
# DUP-NEXT: g F __TEXT,__text _main
# DUP-NEXT: g F __TEXT,__text __mh_execute_header
# DUP-NEXT: *UND* dyld_stub_binder
## Check that the duplicate dead stripped symbols get listed properly.
# RUN: FileCheck --check-prefix=DUPMAP %s < %t/stripped-duplicate-map
# DUPMAP: _main
# DUPMAP-LABEL: Dead Stripped Symbols
# DUPMAP: <<dead>> 0x00000001 [ 3] _foo
#--- duplicate1.s
.text
.globl _main, _foo
_foo:
retq
_main:
retq
.subsections_via_symbols
#--- duplicate2.s
.text
.globl _foo
_foo:
retq
.subsections_via_symbols
#--- basics.s
.comm _ref_com, 1
.comm _unref_com, 1
.section __DATA,__unref_section
_unref_data:
.quad 4
l_unref_data:
.quad 5
## Referenced by no_dead_strip == S_ATTR_NO_DEAD_STRIP
.section __DATA,__ref_section,regular,no_dead_strip
## Referenced because in no_dead_strip section.
_ref_data:
.quad 4
## This is a local symbol so it's not in the symbol table, but
## it is still in the section data.
l_ref_data:
.quad 5
.text
# Exported symbols should not be stripped from dylibs
# or bundles, but they should be stripped from executables.
.globl _unref_extern
_unref_extern:
callq _ref_local
retq
# Unreferenced local symbols should be stripped.
_unref_local:
retq
# Same for unreferenced private externs.
.globl _unref_private_extern
.private_extern _unref_private_extern
_unref_private_extern:
# This shouldn't create an indirect symbol since it's
# a reference from a dead function.
movb _unref_com@GOTPCREL(%rip), %al
retq
# Referenced local symbols should not be stripped.
_ref_local:
callq _ref_private_extern
retq
# Same for referenced private externs.
# This one is referenced by a relocation.
.globl _ref_private_extern
.private_extern _ref_private_extern
_ref_private_extern:
retq
# This one is referenced by a -u flag.
.globl _ref_private_extern_u
.private_extern _ref_private_extern_u
_ref_private_extern_u:
retq
# Entry point should not be stripped for executables, even if hidden.
# For shared libraries this is stripped since it's just a regular hidden
# symbol there.
.globl _main
.private_extern _main
_main:
movb _ref_com@GOTPCREL(%rip), %al
callq _ref_local
retq
# Things marked no_dead_strip should not be stripped either.
# (clang emits this e.g. for `__attribute__((used))` globals.)
# Both for .globl symbols...
.globl _no_dead_strip_globl
.no_dead_strip _no_dead_strip_globl
_no_dead_strip_globl:
callq _ref_from_no_dead_strip_globl
retq
_ref_from_no_dead_strip_globl:
retq
# ...and for locals.
.no_dead_strip _no_dead_strip_local
_no_dead_strip_local:
callq _ref_from_no_dead_strip_local
retq
_ref_from_no_dead_strip_local:
retq
.subsections_via_symbols
#--- exported-symbol.s
.text
.globl _unref_symbol
_unref_symbol:
retq
.globl _my_exported_symbol
_my_exported_symbol:
retq
.globl _main
_main:
retq
.subsections_via_symbols
#--- abs.s
.globl _abs1, _abs2, _abs3
.no_dead_strip _abs1
_abs1 = 1
_abs2 = 2
_abs3 = 3
.section __DATA,__foo,regular,no_dead_strip
# Absolute symbols are not in a section, so the no_dead_strip
# on the section above has no effect.
.globl _abs4
_abs4 = 4
.text
.globl _main
_main:
# This is relaxed away, so there's no relocation here and
# _abs3 isn't in the exported symbol table.
mov _abs3, %rax
retq
.subsections_via_symbols
#--- mod-funcs.s
## Roughly based on `clang -O2 -S` output for `struct A { A(); ~A(); }; A a;`
## for mod_init_funcs. mod_term_funcs then similar to that.
.section __TEXT,__StaticInit,regular,pure_instructions
__unref:
retq
_ref_from_init:
retq
_ref_init:
callq _ref_from_init
retq
_ref_from_term:
retq
_ref_term:
callq _ref_from_term
retq
.globl _main
_main:
retq
.section __DATA,__mod_init_func,mod_init_funcs
.quad _ref_init
.section __DATA,__mod_term_func,mod_term_funcs
.quad _ref_term
.subsections_via_symbols
#--- dylib.s
.text
.globl _ref_dylib_fun
_ref_dylib_fun:
retq
.globl _unref_dylib_fun
_unref_dylib_fun:
retq
.subsections_via_symbols
#--- strip-dylib-ref.s
.text
_unref:
callq _ref_dylib_fun
callq _unref_dylib_fun
callq _ref_undef_fun
callq _unref_undef_fun
retq
.globl _main
_main:
callq _ref_dylib_fun
callq _ref_undef_fun
retq
.subsections_via_symbols
#--- live-support.s
## In practice, live_support is used for instruction profiling
## data and asan. (Also for __eh_frame, but that needs special handling
## in the linker anyways.)
## This test isn't based on anything happening in real code though.
.section __TEXT,__ref_ls_fw,regular,live_support
_ref_ls_fun_fw:
# This is called by _main and is kept alive by normal
# forward liveness propagation, The live_support attribute
# does nothing in this case.
retq
.section __TEXT,__unref_ls_fw,regular,live_support
_unref_ls_fun_fw:
retq
.section __TEXT,__ref_ls_bw,regular,live_support
_ref_ls_fun_bw:
# This _calls_ something that's alive but isn't referenced itself. This is
# kept alive only due to this being in a live_support section.
callq _foo
# _bar on the other hand is kept alive since it's called from here.
callq _bar
retq
## Kept alive by a live symbol form a dynamic library.
_ref_ls_dylib_fun:
callq _ref_dylib_fun
retq
## Kept alive by a live undefined symbol.
_ref_ls_undef_fun:
callq _ref_undef_fun
retq
## All symbols in this live_support section reference dead symbols
## and are hence dead themselves.
.section __TEXT,__unref_ls_bw,regular,live_support
_unref_ls_fun_bw:
callq _unref
retq
_unref_ls_dylib_fun_bw:
callq _unref_dylib_fun
retq
_unref_ls_undef_fun_bw:
callq _unref_undef_fun
retq
.text
.globl _unref
_unref:
retq
.globl _bar
_bar:
retq
.globl _foo
_foo:
callq _ref_ls_fun_fw
retq
.globl _main
_main:
callq _ref_ls_fun_fw
callq _foo
callq _ref_dylib_fun
callq _ref_undef_fun
retq
.subsections_via_symbols
#--- live-support-iterations.s
.section __TEXT,_ls,regular,live_support
## This is a live_support subsection that only becomes
## live after _foo below is processed. This means the algorithm of
## 1. mark things reachable from gc roots live
## 2. go through live sections and mark the ones live pointing to
## live symbols or sections
## needs more than one iteration, since _bar won't be live when step 2
## runs for the first time.
## (ld64 gets this wrong -- it has different output based on if _bar is
## before _foo or after it.)
_bar:
callq _foo_refd
callq _bar_refd
retq
## Same here. This is maybe more interesting since it references a live_support
## symbol instead of a "normal" symbol.
_baz:
callq _foo_refd
callq _baz_refd
retq
_foo:
callq _main
callq _foo_refd
retq
## Test no_dead_strip on a symbol in a live_support section.
## ld64 ignores this, but that doesn't look intentional. So lld honors it.
.no_dead_strip
_quux:
retq
.text
.globl _main
_main:
movq $0, %rax
retq
_foo_refd:
retq
_bar_refd:
retq
_baz_refd:
retq
.subsections_via_symbols
#--- unwind.s
## This is the output of `clang -O2 -S throw.cc` where throw.cc
## looks like this:
## int unref() {
## try {
## throw 0;
## } catch (int i) {
## return i + 1;
## }
## }
## int main() {
## try {
## throw 0;
## } catch (int i) {
## return i;
## }
## }
.section __TEXT,__text,regular,pure_instructions
.globl __Z5unrefv ## -- Begin function _Z5unrefv
.p2align 4, 0x90
__Z5unrefv: ## @_Z5unrefv
Lfunc_begin0:
.cfi_startproc
.cfi_personality 155, ___gxx_personality_v0
.cfi_lsda 16, Lexception0
## %bb.0:
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset %rbp, -16
movq %rsp, %rbp
.cfi_def_cfa_register %rbp
subq $16, %rsp
movl $4, %edi
callq ___cxa_allocate_exception
movl $0, (%rax)
Ltmp0:
movq __ZTIi@GOTPCREL(%rip), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq ___cxa_throw
Ltmp1:
## %bb.1:
ud2
LBB0_2:
Ltmp2:
leaq -4(%rbp), %rcx
movq %rax, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq __Z5unrefv.cold.1
movl -4(%rbp), %eax
addq $16, %rsp
popq %rbp
retq
Lfunc_end0:
.cfi_endproc
.section __TEXT,__gcc_except_tab
.p2align 2
GCC_except_table0:
Lexception0:
.byte 255 ## @LPStart Encoding = omit
.byte 155 ## @TType Encoding = indirect pcrel sdata4
.uleb128 Lttbase0-Lttbaseref0
Lttbaseref0:
.byte 1 ## Call site Encoding = uleb128
.uleb128 Lcst_end0-Lcst_begin0
Lcst_begin0:
.uleb128 Lfunc_begin0-Lfunc_begin0 ## >> Call Site 1 <<
.uleb128 Ltmp0-Lfunc_begin0 ## Call between Lfunc_begin0 and Ltmp0
.byte 0 ## has no landing pad
.byte 0 ## On action: cleanup
.uleb128 Ltmp0-Lfunc_begin0 ## >> Call Site 2 <<
.uleb128 Ltmp1-Ltmp0 ## Call between Ltmp0 and Ltmp1
.uleb128 Ltmp2-Lfunc_begin0 ## jumps to Ltmp2
.byte 1 ## On action: 1
.uleb128 Ltmp1-Lfunc_begin0 ## >> Call Site 3 <<
.uleb128 Lfunc_end0-Ltmp1 ## Call between Ltmp1 and Lfunc_end0
.byte 0 ## has no landing pad
.byte 0 ## On action: cleanup
Lcst_end0:
.byte 1 ## >> Action Record 1 <<
## Catch TypeInfo 1
.byte 0 ## No further actions
.p2align 2
## >> Catch TypeInfos <<
.long __ZTIi@GOTPCREL+4 ## TypeInfo 1
Lttbase0:
.p2align 2
## -- End function
.section __TEXT,__text,regular,pure_instructions
.globl _main ## -- Begin function main
.p2align 4, 0x90
_main: ## @main
Lfunc_begin1:
.cfi_startproc
.cfi_personality 155, ___gxx_personality_v0
.cfi_lsda 16, Lexception1
## %bb.0:
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset %rbp, -16
movq %rsp, %rbp
.cfi_def_cfa_register %rbp
pushq %rbx
pushq %rax
.cfi_offset %rbx, -24
movl $4, %edi
callq ___cxa_allocate_exception
movl $0, (%rax)
Ltmp3:
movq __ZTIi@GOTPCREL(%rip), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq ___cxa_throw
Ltmp4:
## %bb.1:
ud2
LBB1_2:
Ltmp5:
movq %rax, %rdi
callq ___cxa_begin_catch
movl (%rax), %ebx
callq ___cxa_end_catch
movl %ebx, %eax
addq $8, %rsp
popq %rbx
popq %rbp
retq
Lfunc_end1:
.cfi_endproc
.section __TEXT,__gcc_except_tab
.p2align 2
GCC_except_table1:
Lexception1:
.byte 255 ## @LPStart Encoding = omit
.byte 155 ## @TType Encoding = indirect pcrel sdata4
.uleb128 Lttbase1-Lttbaseref1
Lttbaseref1:
.byte 1 ## Call site Encoding = uleb128
.uleb128 Lcst_end1-Lcst_begin1
Lcst_begin1:
.uleb128 Lfunc_begin1-Lfunc_begin1 ## >> Call Site 1 <<
.uleb128 Ltmp3-Lfunc_begin1 ## Call between Lfunc_begin1 and Ltmp3
.byte 0 ## has no landing pad
.byte 0 ## On action: cleanup
.uleb128 Ltmp3-Lfunc_begin1 ## >> Call Site 2 <<
.uleb128 Ltmp4-Ltmp3 ## Call between Ltmp3 and Ltmp4
.uleb128 Ltmp5-Lfunc_begin1 ## jumps to Ltmp5
.byte 1 ## On action: 1
.uleb128 Ltmp4-Lfunc_begin1 ## >> Call Site 3 <<
.uleb128 Lfunc_end1-Ltmp4 ## Call between Ltmp4 and Lfunc_end1
.byte 0 ## has no landing pad
.byte 0 ## On action: cleanup
Lcst_end1:
.byte 1 ## >> Action Record 1 <<
## Catch TypeInfo 1
.byte 0 ## No further actions
.p2align 2
## >> Catch TypeInfos <<
.long __ZTIi@GOTPCREL+4 ## TypeInfo 1
Lttbase1:
.p2align 2
## -- End function
.section __TEXT,__text,regular,pure_instructions
.p2align 4, 0x90 ## -- Begin function _Z5unrefv.cold.1
__Z5unrefv.cold.1: ## @_Z5unrefv.cold.1
.cfi_startproc
## %bb.0:
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset %rbp, -16
movq %rsp, %rbp
.cfi_def_cfa_register %rbp
pushq %rbx
pushq %rax
.cfi_offset %rbx, -24
movq %rdx, %rbx
callq ___cxa_begin_catch
movl (%rax), %eax
incl %eax
movl %eax, (%rbx)
addq $8, %rsp
popq %rbx
popq %rbp
jmp ___cxa_end_catch ## TAILCALL
.cfi_endproc
## -- End function
.subsections_via_symbols
#--- weak-ref.s
.text
.weak_reference _ref_dylib_fun
.globl _main
_main:
callq _ref_dylib_fun
retq
.subsections_via_symbols
#--- strong-dead-ref.s
.text
.globl _unref_dylib_fun
_unref:
callq _unref_dylib_fun
retq
.subsections_via_symbols
#--- weak-dylib.s
.text
.globl _weak_in_dylib
.weak_definition _weak_in_dylib
_weak_in_dylib:
retq
.subsections_via_symbols
#--- dead-weak-override.s
## Overrides the _weak_in_dylib symbol in weak-dylib, but is dead stripped.
.text
#.no_dead_strip _weak_in_dylib
.globl _weak_in_dylib
_weak_in_dylib:
retq
.globl _main
_main:
retq
.subsections_via_symbols
#--- debug.s
.text
.globl _unref
_unref:
retq
.globl _main
_main:
retq
.subsections_via_symbols
#--- no-dead-symbols.s
.text
.globl _main
_main:
retq
#--- literals.s
.cstring
_unref_foo:
.ascii "foo"
_bar:
Lbar:
.asciz "bar"
_unref_baz:
.asciz "baz"
.literal4
.p2align 2
L._foo4:
.long 0xdeadbeef
L._bar4:
.long 0xdeadbeef
L._unref:
.long 0xfeedface
.section __DATA,str_ptrs,literal_pointers
.globl _data
_data:
.quad _bar
.quad Lbar
## The output binary has these integer literals put into a section that isn't
## marked with a S_*BYTE_LITERALS flag, so we don't mark word_ptrs with the
## S_LITERAL_POINTERS flag in order not to confuse llvm-objdump.
.section __DATA,word_ptrs
.globl _more_data
_more_data:
.quad L._foo4
.quad L._bar4
.subsections_via_symbols
#--- ref-undef.s
.globl _main
_main:
callq _ref_undef_fun
.subsections_via_symbols
#--- addrsig.s
.globl _main, _addrsig
_main:
retq
_addrsig:
retq
.subsections_via_symbols
.addrsig
.addrsig_sym _addrsig
Codebase Browser
llvm