diff options
Diffstat (limited to 'binutils-2.21/ld/testsuite/ld-elfvsb')
20 files changed, 1631 insertions, 0 deletions
diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/common.c b/binutils-2.21/ld/testsuite/ld-elfvsb/common.c new file mode 100644 index 0000000..7d05eb7 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/common.c @@ -0,0 +1,14 @@ +int foo; +asm (".hidden foo"); + +int +_start (void) +{ + return foo; +} + +int +__start (void) +{ + return _start (); +} diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/define.s b/binutils-2.21/ld/testsuite/ld-elfvsb/define.s new file mode 100644 index 0000000..b38e3e0 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/define.s @@ -0,0 +1,10 @@ + .data + .globl protected + .type protected,"object" +protected: + .globl hidden + .type hidden,"object" +hidden: + .globl internal + .type internal,"object" +internal: diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/elf-offset.ld b/binutils-2.21/ld/testsuite/ld-elfvsb/elf-offset.ld new file mode 100644 index 0000000..7c64824 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/elf-offset.ld @@ -0,0 +1,173 @@ +SECTIONS +{ + /* Read-only sections, merged into text segment: */ + . = 0x100000; + .hash : { *(.hash) } + .dynsym : { *(.dynsym) } + .dynstr : { *(.dynstr) } + .gnu.version : { *(.gnu.version) } + .gnu.version_d : { *(.gnu.version_d) } + .gnu.version_r : { *(.gnu.version_r) } + .rel.text : + { + *(.rel.text) + *(.rel.text.*) + *(.rel.gnu.linkonce.t*) + } + .rela.text : + { + *(.rela.text) + *(.rela.text.*) + *(.rela.gnu.linkonce.t*) + } + .rel.data : + { + *(.rel.data) + *(.rel.data.*) + *(.rel.gnu.linkonce.d*) + } + .rela.data : + { + *(.rela.data) + *(.rela.data.*) + *(.rela.gnu.linkonce.d*) + } + .rel.rodata : + { + *(.rel.rodata) + *(.rel.rodata.*) + *(.rel.gnu.linkonce.r*) + } + .rela.rodata : + { + *(.rela.rodata) + *(.rela.rodata.*) + *(.rela.gnu.linkonce.r*) + } + .rel.got : { *(.rel.got) } + .rela.got : { *(.rela.got) } + .rel.toc : { *(.rel.toc) } + .rela.toc : { *(.rela.toc) } + .rel.ctors : { *(.rel.ctors) } + .rela.ctors : { *(.rela.ctors) } + .rel.dtors : { *(.rel.dtors) } + .rela.dtors : { *(.rela.dtors) } + .rel.init : { *(.rel.init) } + .rela.init : { *(.rela.init) } + .rel.fini : { *(.rel.fini) } + .rela.fini : { *(.rela.fini) } + .rel.bss : { *(.rel.bss) } + .rela.bss : { *(.rela.bss) } + .rel.plt : { *(.rel.plt) } + .rela.plt : { *(.rela.plt) } + .rel.eh_frame : { *(.rel.eh_frame) } + .rela.eh_frame : { *(.rela.eh_frame) } + .init : { KEEP (*(.init)) } + .plt : { *(.plt) } + .text : + { + *(.text) + *(.text.*) + *(.stub) + /* .gnu.warning sections are handled specially by elf32.em. */ + *(.gnu.warning) + *(.gnu.linkonce.t*) + } + _etext = .; + PROVIDE (etext = .); + .fini : { KEEP (*(.fini)) } =0x9090 + .rodata : + { + *(.rodata) + *(.rodata.*) + *(.gnu.linkonce.r*) + } + .rodata1 : { *(.rodata1) } + /* Adjust the address for the data segment. We want to adjust up to + the same address within the page on the next page up. */ + . = ALIGN(0x1000) + (. & (0x1000 - 1)); + .data : + { + *(.data) + *(.data.*) + *(.gnu.linkonce.d*) + SORT(CONSTRUCTORS) + } + .data1 : { *(.data1) } + .ctors : + { + /* gcc uses crtbegin.o to find the start of the constructors, so + we make sure it is first. Because this is a wildcard, it + doesn't matter if the user does not actually link against + crtbegin.o; the linker won't look for a file to match a + wildcard. The wildcard also means that it doesn't matter which + directory crtbegin.o is in. */ + KEEP (*crtbegin.o(.ctors)) + KEEP (*(SORT(.ctors.*))) + KEEP (*(.ctors)) + } + .dtors : + { + KEEP (*crtbegin.o(.dtors)) + KEEP (*(SORT(.dtors.*))) + KEEP (*(.dtors)) + } + .got : { *(.got.plt) *(.got) } + .toc : { *(.toc) } + .dynamic : { *(.dynamic) } + /* We want the small data sections together, so single-instruction offsets + can access them all, and initialized data all before uninitialized, so + we can shorten the on-disk segment size. */ + .sdata : { *(.sdata) *(.sdata.*) } + _edata = .; + PROVIDE (edata = .); + __bss_start = .; + .sbss : { *(.sbss) *(.scommon) } + .bss : + { + *(.dynbss) + *(.bss) + *(COMMON) + /* Align here to ensure that the .bss section occupies space up to + _end. Align after .bss to ensure correct alignment even if the + .bss section disappears because there are no input sections. */ + . = ALIGN(32 / 8); + } + . = ALIGN(32 / 8); + _end = . ; + PROVIDE (end = .); + /* Stabs debugging sections. */ + .stab 0 : { *(.stab) } + .stabstr 0 : { *(.stabstr) } + .stab.excl 0 : { *(.stab.excl) } + .stab.exclstr 0 : { *(.stab.exclstr) } + .stab.index 0 : { *(.stab.index) } + .stab.indexstr 0 : { *(.stab.indexstr) } + .comment 0 : { *(.comment) } + /* DWARF debug sections. + Symbols in the DWARF debugging sections are relative to the beginning + of the section so we begin them at 0. */ + /* DWARF 1 */ + .debug 0 : { *(.debug) } + .line 0 : { *(.line) } + /* GNU DWARF 1 extensions */ + .debug_srcinfo 0 : { *(.debug_srcinfo) } + .debug_sfnames 0 : { *(.debug_sfnames) } + /* DWARF 1.1 and DWARF 2 */ + .debug_aranges 0 : { *(.debug_aranges) } + .debug_pubnames 0 : { *(.debug_pubnames) } + /* DWARF 2 */ + .debug_info 0 : { *(.debug_info) } + .debug_abbrev 0 : { *(.debug_abbrev) } + .debug_line 0 : { *(.debug_line) } + .debug_frame 0 : { *(.debug_frame) } + .debug_str 0 : { *(.debug_str) } + .debug_loc 0 : { *(.debug_loc) } + .debug_macinfo 0 : { *(.debug_macinfo) } + /* SGI/MIPS DWARF 2 extensions */ + .debug_weaknames 0 : { *(.debug_weaknames) } + .debug_funcnames 0 : { *(.debug_funcnames) } + .debug_typenames 0 : { *(.debug_typenames) } + .debug_varnames 0 : { *(.debug_varnames) } + /* These must appear regardless of . */ +} diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/elfvsb.dat b/binutils-2.21/ld/testsuite/ld-elfvsb/elfvsb.dat new file mode 100644 index 0000000..bad3b1e --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/elfvsb.dat @@ -0,0 +1,26 @@ +mainvar == 1 +overriddenvar == 2 +shlibvar1 == 3 +shlib_mainvar () == 1 +shlib_overriddenvar () == 2 +shlib_shlibvar1 () == 3 +shlib_shlibvar2 () == 4 +shlib_shlibcall () == 5 +shlib_shlibcall2 () == 8 +shlib_maincall () == 6 +main_called () == 6 +shlib_checkfunptr1 (shlib_shlibvar1) == 1 +shlib_checkfunptr2 (main_called) == 1 +shlib_getfunptr1 () == shlib_shlibvar1 +shlib_getfunptr2 () == main_called +shlib_check () == 1 +visibility_check () == 1 +visibility_checkfunptr () == 1 +main_visibility_check () == 1 +visibility_checkvar () == 1 +visibility_checkvarptr () == 1 +main_visibility_checkvar () == 1 +main_visibility_checkcom () == 1 +shlib_visibility_checkcom () == 1 +main_visibility_checkweak () == 1 +shlib_visibility_checkweak () == 1 diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/elfvsb.exp b/binutils-2.21/ld/testsuite/ld-elfvsb/elfvsb.exp new file mode 100644 index 0000000..1a18822 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/elfvsb.exp @@ -0,0 +1,508 @@ +# Expect script for ld-visibility tests +# Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 +# Free Software Foundation, Inc. +# +# This file is part of the GNU Binutils. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, +# MA 02110-1301, USA. +# +# Written by Ian Lance Taylor (ian@cygnus.com) +# and H.J. Lu (hjl@gnu.org) +# + +# Make sure that ld can generate ELF shared libraries with visibility. + +# This test can only be run on a couple of ELF platforms. +# Square bracket expressions seem to confuse istarget. +if { ![istarget hppa*64*-*-hpux*] \ + && ![istarget hppa*-*-linux*] \ + && ![istarget i?86-*-linux*] \ + && ![istarget ia64-*-linux*] \ + && ![istarget m68k-*-linux*] \ + && ![istarget mips*-*-linux*] \ + && ![istarget powerpc*-*-linux*] \ + && ![istarget arm*-*-linux*] \ + && ![istarget alpha*-*-linux*] \ + && ![istarget sparc*-*-linux*] \ + && ![istarget s390*-*-linux*] \ + && ![istarget sh\[34\]*-*-linux*] \ + && ![istarget x86_64-*-linux*] } { + return +} + +if { [istarget *-*-linux*aout*] \ + || [istarget *-*-linux*oldld*] } { + return +} + +set test_list [lsort [glob -nocomplain $srcdir/$subdir/*.d]] +foreach t $test_list { + # We need to strip the ".d", but can leave the dirname. + verbose [file rootname $t] + run_dump_test [file rootname $t] +} + +# The remaining tests can only be run if ld generates native executables. +if ![isnative] then {return} + +set tmpdir tmpdir +set SHCFLAG "" +set shared_needs_pic "no" + +if { [istarget rs6000*-*-aix*] || [istarget powerpc*-*-aix*] } { + + # AIX shared libraries do not seem to support useful features, + # like overriding the shared library function or letting the + # shared library refer to objects defined in the main program. We + # avoid testing those features. + set SHCFLAG "-DXCOFF_TEST" + + # The AIX 3.2.5 loader appears to randomly fail when loading + # shared libraries from NSF mounted partitions, so we avoid any + # potential problems by using a local directory. + catch {exec /bin/sh -c "echo $$"} pid + set tmpdir /usr/tmp/ld.$pid + catch "exec mkdir $tmpdir" exec_status + + # On AIX, we need to explicitly export the symbols the shared + # library is going to provide, and need. + set file [open $tmpdir/xcoff.exp w] + puts $file shlibvar1 + puts $file shlibvar2 + puts $file shlib_shlibvar1 + puts $file shlib_shlibvar2 + puts $file shlib_shlibcall + puts $file shlib_shlibcalled + puts $file shlib_checkfunptr1 + puts $file shlib_getfunptr1 + puts $file shlib_check + close $file +} + +if [istarget arm*-*-linux*] { + # On ARM section anchors can change the symbol pre-emptability for + # non-PIC shared libraries, causing these tests to fail. Turn section + # anchors off. + set SHCFLAG "-fno-section-anchors" + + # On targets that have MOVW the compiler will emit relocations which + # the linker doesn't support when compiling -shared without -fpic. The + # test to find out whether we want to XFAIL the non-PIC tests requires + # a compile - so we pre-calculate it here. We also note that this can + # only affect arm*-*-*eabi targets as the old ABI doesn't support v7. + if [istarget arm*-*-*eabi] { + set file [open $tmpdir/movw-detect.c w] + puts $file "void foo(void) { __asm (\"movw r0, #0\"); }" + close $file + if [run_host_cmd_yesno "$CC" "$CFLAGS -c $tmpdir/movw-detect.c -o $tmpdir/movw-detect.o"] { + set shared_needs_pic "yes" + } + } +} + +set support_protected "no" + +if [istarget *-*-linux*] { + if [ld_compile "$CC -g $CFLAGS -DPROTECTED_CHECK" $srcdir/$subdir/main.c $tmpdir/main.o] { + if [ld_simple_link $CC $tmpdir/main "$tmpdir/main.o"] { + catch "exec $tmpdir/main" support_protected + } + } +} + +# The test procedure. +proc visibility_test { visibility progname testname main sh1 sh2 dat args } { + global CC + global srcdir + global subdir + global exec_output + global link_output + global host_triplet + global tmpdir + + if [llength $args] { set shldflags [lindex $args 0] } else { set shldflags "" } + + # Build the shared library. + # On AIX, we need to use an export file. + set shared -shared + if { [istarget rs6000*-*-aix*] || [istarget powerpc*-*-aix*] } { + set shared "-bM:SRE -bE:$tmpdir/xcoff.exp" + } + if {![ld_simple_link $CC $tmpdir/$progname.so "$shared $shldflags $tmpdir/$sh1 $tmpdir/$sh2"]} { + if { [ string match $visibility "hidden_undef" ] + && [regexp "undefined reference to \`\.?visibility\'" $link_output] + && [regexp "undefined reference to \`visibility_var\'" $link_output] } { + pass "$testname" + } else { if { [ string match $visibility "protected_undef" ] + && [regexp "undefined reference to \`\.?visibility\'" $link_output] + && [regexp "undefined reference to \`visibility_var\'" $link_output] } { + pass "$testname" + } else { + fail "$testname" + }} + return + } + + # Link against the shared library. Use -rpath so that the + # dynamic linker can locate the shared library at runtime. + # On AIX, we must include /lib in -rpath, as otherwise the loader + # can not find -lc. + set rpath $tmpdir + if { [istarget rs6000*-*-aix*] || [istarget powerpc*-*-aix*] } { + set rpath /lib:$tmpdir + } + if ![ld_simple_link $CC $tmpdir/$progname "-Wl,-rpath,$rpath $tmpdir/$main $tmpdir/$progname.so"] { + if { [ string match $visibility "hidden" ] + && [regexp "undefined reference to \`\.?visibility\'" $link_output] + && [regexp "undefined reference to \`visibility_var\'" $link_output] } { + pass "$testname" + } else { if { [ string match $visibility "hidden_undef_def" ] + && [regexp "undefined reference to \`\.?visibility\'" $link_output] + && [regexp "undefined reference to \`visibility_def\'" $link_output] + && [regexp "undefined reference to \`\.?visibility_func\'" $link_output] + && [regexp "undefined reference to \`visibility_var\'" $link_output] } { + pass "$testname" + } else { + fail "$testname" + }} + return + } + + if { [ string match $visibility "hidden" ] + || [ string match $visibility "hidden_undef" ] + || [ string match $visibility "protected_undef" ] } { + fail "$testname" + } + + # Run the resulting program + send_log "$tmpdir/$progname >$tmpdir/$progname.out\n" + verbose "$tmpdir/$progname >$tmpdir/$progname.out" + catch "exec $tmpdir/$progname >$tmpdir/$progname.out" exec_output + if ![string match "" $exec_output] then { + send_log "$exec_output\n" + verbose "$exec_output" + fail "$testname" + return + } + + send_log "diff $tmpdir/$progname.out $srcdir/$subdir/$dat.dat\n" + verbose "diff $tmpdir/$progname.out $srcdir/$subdir/$dat.dat" + catch "exec diff $tmpdir/$progname.out $srcdir/$subdir/$dat.dat" exec_output + set exec_output [prune_warnings $exec_output] + + if {![string match "" $exec_output]} then { + send_log "$exec_output\n" + verbose "$exec_output" + fail "$testname" + return + } + + pass "$testname" +} + +proc visibility_run {visibility} { + global CC + global CFLAGS + global SHCFLAG + global srcdir + global subdir + global tmpdir + global picflag + global target_triplet + global support_protected + global shared_needs_pic + + if [ string match $visibility "hidden" ] { + set VSBCFLAG "-DHIDDEN_TEST" + } else { if [ string match $visibility "hidden_normal" ] { + set VSBCFLAG "-DHIDDEN_NORMAL_TEST" + } else { if [ string match $visibility "hidden_undef" ] { + set VSBCFLAG "-DHIDDEN_UNDEF_TEST" + } else { if [ string match $visibility "hidden_undef_def" ] { + set VSBCFLAG "-DHIDDEN_UNDEF_TEST -DDSO_DEFINE_TEST" + } else { if [ string match $visibility "hidden_weak" ] { + set VSBCFLAG "-DHIDDEN_WEAK_TEST" + } else { if [ string match $visibility "protected" ] { + set VSBCFLAG "-DPROTECTED_TEST" + } else { if [ string match $visibility "protected_undef" ] { + set VSBCFLAG "-DPROTECTED_UNDEF_TEST" + } else { if [ string match $visibility "protected_undef_def" ] { + set VSBCFLAG "-DPROTECTED_UNDEF_TEST -DDSO_DEFINE_TEST" + } else { if [ string match $visibility "protected_weak" ] { + set VSBCFLAG "-DPROTECTED_WEAK_TEST" + } else { + set VSBCFLAG "" + }}}}}}}}} + + # Compile the main program. + if ![ld_compile "$CC -g $CFLAGS $SHCFLAG $VSBCFLAG" $srcdir/$subdir/main.c $tmpdir/mainnp.o] { + unresolved "visibility ($visibility) (non PIC)" + unresolved "visibility ($visibility)" + } else { + # The shared library is composed of two files. First compile them + # without using -fpic. That should work on an ELF system, + # although it will be less efficient because the dynamic linker + # will need to do more relocation work. However, note that not + # using -fpic will cause some of the tests to return different + # results. + if { ![ld_compile "$CC -g $CFLAGS $SHCFLAG $VSBCFLAG" $srcdir/$subdir/sh1.c $tmpdir/sh1np.o] + || ![ld_compile "$CC -g $CFLAGS $SHCFLAG $VSBCFLAG" $srcdir/$subdir/sh2.c $tmpdir/sh2np.o] } { + unresolved "visibility ($visibility) (non PIC)" + } else { if { [istarget rs6000*-*-aix*] || [istarget powerpc*-*-aix*] } { + visibility_test $visibility vnp "visibility ($visibility) (non PIC)" mainnp.o sh1np.o sh2np.o xcoff + } else { + # SunOS non PIC shared libraries don't permit some cases of + # overriding. + if { [ string match $visibility "protected" ] + || [ string match $visibility "protected_undef_def" ] } { + if [ string match $support_protected "no" ] { + setup_xfail $target_triplet + } + } else { + setup_xfail "*-*-sunos4*" + } + + # Non-pic code uses name binding rules for applications to + # reference variables by gp-relative relocs, which can't be + # used with overridable symbols. + if { ![ string match $visibility "hidden_undef" ] + && ![ string match $visibility "protected_undef" ] } { + setup_xfail "ia64-*-linux*" + setup_xfail "alpha*-*-linux*" + } + if { ![ string match $visibility "hidden" ] + && ![ string match $visibility "hidden_undef" ] + && ![ string match $visibility "hidden_undef_def" ] + && ![ string match $visibility "protected_undef" ] } { + setup_xfail "s390x-*-linux*" + if { [istarget sparc*-*-linux*] && [is_elf64 $tmpdir/mainnp.o] } { + setup_xfail "sparc*-*-linux*" + } + } + setup_xfail "x86_64-*-linux*" + if { ![istarget hppa*64*-*-linux*] } { + setup_xfail "hppa*-*-linux*" + } + if [ string match $shared_needs_pic "yes" ] { + setup_xfail "arm*-*-linux*" + } + + visibility_test $visibility vnp "visibility ($visibility) (non PIC)" mainnp.o sh1np.o sh2np.o elfvsb + + # Test ELF shared library relocations with a non-zero load + # address for the library. Near as I can tell, the R_*_RELATIVE + # relocations for various targets are broken in the case where + # the load address is not zero (which is the default). + if { [ string match $visibility "protected" ] + || [ string match $visibility "protected_undef_def" ] } { + if [ string match $support_protected "no" ] { + setup_xfail $target_triplet + } + } else { + setup_xfail "*-*-sunos4*" + setup_xfail "*-*-linux*libc1" + } + if { [ string match $visibility "hidden_normal" ] + || [ string match $visibility "hidden_weak" ] + || [ string match $visibility "protected" ] + || [ string match $visibility "protected_undef_def" ] + || [ string match $visibility "protected_weak" ] + || [ string match $visibility "normal" ] } { + setup_xfail "powerpc-*-linux*" + setup_xfail "s390x-*-linux*" + if { [istarget sparc*-*-linux*] && [is_elf64 $tmpdir/mainnp.o] } { + setup_xfail "sparc*-*-linux*" + } + } + if { ![ string match $visibility "hidden_undef" ] + && ![ string match $visibility "protected_undef" ] } { + setup_xfail "ia64-*-linux*" + setup_xfail "alpha*-*-linux*" + setup_xfail "mips*-*-linux*" + } + setup_xfail "x86_64-*-linux*" + if { ![istarget hppa*64*-*-linux*] } { + setup_xfail "hppa*-*-linux*" + } + if [ string match $shared_needs_pic "yes" ] { + setup_xfail "arm*-*-linux*" + } + + visibility_test $visibility vnp "visibility ($visibility) (non PIC, load offset)" \ + mainnp.o sh1np.o sh2np.o elfvsb \ + "-T $srcdir/$subdir/elf-offset.ld" + } } + + # Now compile the code using -fpic. + + if { ![ld_compile "$CC -g $CFLAGS $SHCFLAG $VSBCFLAG -DSHARED $picflag" $srcdir/$subdir/sh1.c $tmpdir/sh1p.o] + || ![ld_compile "$CC -g $CFLAGS $SHCFLAG $VSBCFLAG -DSHARED $picflag" $srcdir/$subdir/sh2.c $tmpdir/sh2p.o] } { + unresolved "visibility ($visibility)" + } else { + if { [ string match $visibility "protected" ] + || [ string match $visibility "protected_undef_def" ] } { + if [ string match $support_protected "no" ] { + setup_xfail $target_triplet + } + } + # SunOS can not compare function pointers correctly + if [istarget "*-*-sunos4*"] { + visibility_test $visibility vp "visibility ($visibility)" mainnp.o sh1p.o sh2p.o sun4 + } else { if { [istarget rs6000*-*-aix*] || [istarget powerpc*-*-aix*] } { + visibility_test $visibility vp "visibility ($visibility)" mainnp.o sh1p.o sh2p.o xcoff + } else { + visibility_test $visibility vp "visibility ($visibility)" mainnp.o sh1p.o sh2p.o elfvsb + } } + } + } + + # Now do the same tests again, but this time compile main.c PIC. + if ![ld_compile "$CC -g $CFLAGS $SHCFLAG $VSBCFLAG -DSHARED $picflag" $srcdir/$subdir/main.c $tmpdir/mainp.o] { + unresolved "visibility ($visibility) (PIC main, non PIC so)" + unresolved "visibility ($visibility) (PIC main)" + } else { + if { [file exists $tmpdir/sh1np.o ] && [ file exists $tmpdir/sh2np.o ] } { + if { [istarget rs6000*-*-aix*] || [istarget powerpc*-*-aix*] } { + visibility_test $visibility vmpnp "visibility ($visibility) (PIC main, non PIC so)" mainp.o sh1np.o sh2np.o xcoff + } else { + # SunOS non PIC shared libraries don't permit some cases of + # overriding. + if { [ string match $visibility "protected" ] + || [ string match $visibility "protected_undef_def" ] } { + if [ string match $support_protected "no" ] { + setup_xfail $target_triplet + } + } else { + setup_xfail "*-*-sunos4*" + } + if { ![ string match $visibility "hidden_undef" ] + && ![ string match $visibility "protected_undef" ] } { + setup_xfail "ia64-*-linux*" + setup_xfail "alpha*-*-linux*" + } + if { ![ string match $visibility "hidden" ] + && ![ string match $visibility "hidden_undef" ] + && ![ string match $visibility "hidden_undef_def" ] + && ![ string match $visibility "protected_undef" ] } { + setup_xfail "s390x-*-linux*" + if { [istarget sparc*-*-linux*] && [is_elf64 $tmpdir/mainp.o] } { + setup_xfail "sparc*-*-linux*" + } + } + setup_xfail "x86_64-*-linux*" + if { ![istarget hppa*64*-*-linux*] } { + setup_xfail "hppa*-*-linux*" + } + if [ string match $shared_needs_pic "yes" ] { + setup_xfail "arm*-*-linux*" + } + + visibility_test $visibility vmpnp "visibility ($visibility) (PIC main, non PIC so)" mainp.o sh1np.o sh2np.o elfvsb + } + } else { + unresolved "visibility (PIC main, non PIC so)" + } + + if { [file exists $tmpdir/sh1p.o ] && [ file exists $tmpdir/sh2p.o ] } { + if { [ string match $visibility "protected" ] + || [ string match $visibility "protected_undef_def" ] } { + if [ string match $support_protected "no" ] { + setup_xfail $target_triplet + } + } + if { [istarget rs6000*-*-aix*] || [istarget powerpc*-*-aix*] } { + visibility_test $visibility vmpp "visibility ($visibility) (PIC main)" mainp.o sh1p.o sh2p.o xcoff + } else { + visibility_test $visibility vmpp "visibility ($visibility) (PIC main)" mainp.o sh1p.o sh2p.o elfvsb + } + } else { + unresolved "visibility ($visibility) (PIC main)" + } + } +} + +if [istarget mips*-*-*] { + set picflag "" +} else { + # Unfortunately, the gcc argument is -fpic and the cc argument is + # -KPIC. We have to try both. + set picflag "-fpic" + send_log "$CC $picflag\n" + verbose "$CC $picflag" + catch "exec $CC $picflag" exec_output + send_log "$exec_output\n" + verbose "--" "$exec_output" + if { [string match "*illegal option*" $exec_output] \ + || [string match "*option ignored*" $exec_output] \ + || [string match "*unrecognized option*" $exec_output] \ + || [string match "*passed to ld*" $exec_output] } { + if [istarget *-*-sunos4*] { + set picflag "-pic" + } else { + set picflag "-KPIC" + } + } +} +verbose "Using $picflag to compile PIC code" + +visibility_run hidden +visibility_run hidden_normal +visibility_run hidden_undef +visibility_run hidden_undef_def +visibility_run hidden_weak +visibility_run protected +visibility_run protected_undef +visibility_run protected_undef_def +visibility_run protected_weak +visibility_run normal + +if { ![ld_compile "$CC -g $CFLAGS" $srcdir/$subdir/common.c tmpdir/common.o] } { + unresolved "common hidden symbol" +} else { + if ![ld_simple_link $ld tmpdir/common "tmpdir/common.o"] { + fail "common hidden symbol" + } else { + pass "common hidden symbol" + } +} + +if { ![ld_compile "$CC -g $CFLAGS" $srcdir/$subdir/test.c tmpdir/test.o] } { + unresolved "weak hidden symbol" +} else { + if { ![ld_compile "$CC -g $CFLAGS -DSHARED $picflag" $srcdir/$subdir/sh3.c tmpdir/sh3.o] } { + unresolved "weak hidden symbol" + } else { + if ![ld_simple_link $ld tmpdir/sh3.so "-shared tmpdir/sh3.o"] { + fail "weak hidden symbol" + } else { + if ![ld_simple_link $ld tmpdir/weak "tmpdir/test.o tmpdir/sh3.o"] { + fail "weak hidden symbol DSO last" + } else { + pass "weak hidden symbol DSO last" + } + if ![ld_simple_link $ld tmpdir/weak "tmpdir/sh3.so tmpdir/test.o"] { + fail "weak hidden symbol DSO first" + } else { + pass "weak hidden symbol DSO first" + } + } + } +} + +if { [istarget rs6000*-*-aix*] || [istarget powerpc*-*-aix*] } { + # Remove the temporary directory. + catch "exec rm -rf $tmpdir" exec_status +} diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/hidden0.d b/binutils-2.21/ld/testsuite/ld-elfvsb/hidden0.d new file mode 100644 index 0000000..abd26a2 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/hidden0.d @@ -0,0 +1,9 @@ +#source: define.s +#source: undef.s +#ld: -r +#readelf: -s + +Symbol table '.symtab' contains .* entries: +#... +[ ]*[0-9]+: [0-9a-fA-F]* +0 +OBJECT +GLOBAL +HIDDEN +. hidden +#pass diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/hidden1.d b/binutils-2.21/ld/testsuite/ld-elfvsb/hidden1.d new file mode 100644 index 0000000..7820c21 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/hidden1.d @@ -0,0 +1,8 @@ +#source: undef.s +#ld: -r +#readelf: -s + +Symbol table '.symtab' contains .* entries: +#... +[ ]*[0-9]+: [0-9a-fA-F]* +0 +NOTYPE +GLOBAL +HIDDEN +UND hidden +#pass diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/hidden2.d b/binutils-2.21/ld/testsuite/ld-elfvsb/hidden2.d new file mode 100644 index 0000000..2996277 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/hidden2.d @@ -0,0 +1,9 @@ +#source: hidden2.s +#ld: -shared -T hidden2.ld +#readelf: -Ds +# It is also ok to remove this symbol, but we currently make it local. + +Symbol table for image: +#... +[ ]*[0-9]+ +[0-9]+: [0-9a-fA-F]* +0 +OBJECT +LOCAL +DEFAULT +ABS foo +#pass diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/hidden2.ld b/binutils-2.21/ld/testsuite/ld-elfvsb/hidden2.ld new file mode 100644 index 0000000..3c414db --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/hidden2.ld @@ -0,0 +1,7 @@ +SECTIONS +{ + . = 0x1000; + PROVIDE (foo = .); + .data : { *(.data) } + .dynamic : { *(.dynamic) } +} diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/hidden2.s b/binutils-2.21/ld/testsuite/ld-elfvsb/hidden2.s new file mode 100644 index 0000000..62f1107 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/hidden2.s @@ -0,0 +1,5 @@ + .data + .hidden foo + .global foo + .type foo,%object + .dc.a foo diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/internal0.d b/binutils-2.21/ld/testsuite/ld-elfvsb/internal0.d new file mode 100644 index 0000000..9d37ae8 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/internal0.d @@ -0,0 +1,10 @@ +#source: define.s +#source: undef.s +#ld: -r +#readelf: -s + +Symbol table '.symtab' contains .* entries: + +Num: +Value +Size +Type +Bind +Vis +Ndx +Name +#... + +[0-9]+: [0-9a-fA-F]+ +0 +OBJECT +GLOBAL +INTERNAL +. internal +#pass diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/internal1.d b/binutils-2.21/ld/testsuite/ld-elfvsb/internal1.d new file mode 100644 index 0000000..5cacdaf --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/internal1.d @@ -0,0 +1,9 @@ +#source: undef.s +#ld: -r +#readelf: -s + +Symbol table '.symtab' contains .* entries: + +Num: +Value +Size +Type +Bind +Vis +Ndx +Name +#... + +[0-9]+: [0-9a-fA-F]+ +0 +NOTYPE +GLOBAL +INTERNAL +UND internal +#pass diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/main.c b/binutils-2.21/ld/testsuite/ld-elfvsb/main.c new file mode 100644 index 0000000..b498d43 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/main.c @@ -0,0 +1,306 @@ +#ifdef PROTECTED_CHECK +#include <features.h> +#include <stdio.h> + +int +main (void) +{ +#if defined (__GLIBC__) && (__GLIBC__ > 2 \ + || (__GLIBC__ == 2 \ + && __GLIBC_MINOR__ >= 2)) + puts ("yes"); +#else + puts ("no"); +#endif + return 0; +} +#else +/* This is the main program for the shared library test. */ + +#include <stdio.h> + +int mainvar = 1; +int overriddenvar = 2; +extern int shlibvar1; + +extern int shlib_mainvar (); +extern int shlib_overriddenvar (); +extern int shlib_shlibvar1 (); +extern int shlib_shlibvar2 (); +extern int shlib_shlibcall (); +extern int shlib_maincall (); +extern int shlib_checkfunptr1 (); +extern int shlib_checkfunptr2 (); +extern int (*shlib_getfunptr1 ()) (); +extern int (*shlib_getfunptr2 ()) (); +extern int shlib_check (); +extern int shlib_shlibcall2 (); +extern int visibility_check (); +extern int visibility_checkfunptr (); +extern void *visibility_funptr (); +extern int visibility_checkvar (); +extern int visibility_checkvarptr (); +extern int visibility_varval (); +extern void *visibility_varptr (); +extern int shlib_visibility_checkcom (); +extern int shlib_visibility_checkweak (); + +int shlib_visibility_com = 1; + +int shlib_visibility_var_weak = 1; + +int +shlib_visibility_func_weak () +{ + return 1; +} + +#ifdef HIDDEN_WEAK_TEST +#define WEAK_TEST +#endif + +#ifdef PROTECTED_WEAK_TEST +#define WEAK_TEST +#endif + +#ifdef PROTECTED_UNDEF_TEST +#define PROTECTED_TEST +#endif + +#ifndef WEAK_TEST +extern int visibility (); +extern int visibility_var; +#endif + +#if !defined (HIDDEN_TEST) && defined (PROTECTED_TEST) +int +visibility (void) +{ + return 1; +} + +static int +main_visibility_check (void) +{ + return ((int (*) (void)) visibility_funptr ()) != visibility; +} + +int visibility_var = 1; + +static int +main_visibility_checkvar (void) +{ + return visibility_varval () != visibility_var + && visibility_varptr () != &visibility_var; +} + +#ifndef PROTECTED_UNDEF_TEST +int shared_data = 1; +asm (".protected shared_data"); + +int +shared_func (void) +{ + return 1; +} + +asm (".protected shared_func"); + +extern int * shared_data_p (); +typedef int (*func) (); +extern func shared_func_p (); +#endif +#else +static int +main_visibility_check (void) +{ +#ifdef WEAK_TEST + return visibility_funptr () == NULL; +#else + return ((int (*) (void)) visibility_funptr ()) == visibility; +#endif +} + +static int +main_visibility_checkvar (void) +{ +#ifdef WEAK_TEST + return visibility_varval () == 0 + && visibility_varptr () == NULL; +#else + return visibility_varval () == visibility_var + && visibility_varptr () == &visibility_var; +#endif +} +#endif + +/* This function is called by the shared library. */ + +int +main_called (void) +{ + return 6; +} + +/* This function overrides a function in the shared library. */ + +int +shlib_overriddencall2 (void) +{ + return 8; +} + +#ifdef HIDDEN_NORMAL_TEST +int visibility_com; +asm (".hidden visibility_com"); + +int +main_visibility_checkcom (void) +{ + return visibility_com == 0; +} + +int +main_visibility_checkweak (void) +{ + return 1; +} +#elif defined (HIDDEN_WEAK_TEST) +int +main_visibility_checkcom (void) +{ + return 1; +} + +#pragma weak visibility_undef_var_weak +extern int visibility_undef_var_weak; +asm (".hidden visibility_undef_var_weak"); + +#pragma weak visibility_undef_func_weak +extern int visibility_undef_func_weak (); +asm (".hidden visibility_undef_func_weak"); + +#pragma weak visibility_var_weak +extern int visibility_var_weak; +asm (".hidden visibility_var_weak"); + +#pragma weak visibility_func_weak +extern int visibility_func_weak (); +asm (".hidden visibility_func_weak"); + +int +main_visibility_checkweak () +{ + return &visibility_undef_var_weak == NULL + && &visibility_undef_func_weak == NULL + && &visibility_func_weak == NULL + && &visibility_var_weak == NULL; +} +#elif defined (HIDDEN_UNDEF_TEST) +extern int visibility_def; +asm (".hidden visibility_def"); +extern int visibility_func (); +asm (".hidden visibility_func"); + +int +main_visibility_checkcom (void) +{ + return & visibility_def != NULL && visibility_def == 2; +} + +int +main_visibility_checkweak (void) +{ + return & visibility_func != NULL && visibility_func () == 2; +} +#else +int +main_visibility_checkcom (void) +{ + return 1; +} + +int +main_visibility_checkweak (void) +{ + return 1; +} +#endif + +int +main (void) +{ + int (*p) (); + int ret = 0; + + printf ("mainvar == %d\n", mainvar); + printf ("overriddenvar == %d\n", overriddenvar); + printf ("shlibvar1 == %d\n", shlibvar1); +#ifndef XCOFF_TEST + printf ("shlib_mainvar () == %d\n", shlib_mainvar ()); + printf ("shlib_overriddenvar () == %d\n", shlib_overriddenvar ()); +#endif + printf ("shlib_shlibvar1 () == %d\n", shlib_shlibvar1 ()); + printf ("shlib_shlibvar2 () == %d\n", shlib_shlibvar2 ()); + printf ("shlib_shlibcall () == %d\n", shlib_shlibcall ()); +#ifndef XCOFF_TEST + printf ("shlib_shlibcall2 () == %d\n", shlib_shlibcall2 ()); + printf ("shlib_maincall () == %d\n", shlib_maincall ()); +#endif + printf ("main_called () == %d\n", main_called ()); + printf ("shlib_checkfunptr1 (shlib_shlibvar1) == %d\n", + shlib_checkfunptr1 (shlib_shlibvar1)); +#ifndef XCOFF_TEST + printf ("shlib_checkfunptr2 (main_called) == %d\n", + shlib_checkfunptr2 (main_called)); +#endif + p = shlib_getfunptr1 (); + printf ("shlib_getfunptr1 () "); + if (p == shlib_shlibvar1) + printf ("=="); + else + printf ("!="); + printf (" shlib_shlibvar1\n"); +#ifndef XCOFF_TEST + p = shlib_getfunptr2 (); + printf ("shlib_getfunptr2 () "); + if (p == main_called) + printf ("=="); + else + printf ("!="); + printf (" main_called\n"); +#endif + printf ("shlib_check () == %d\n", shlib_check ()); + printf ("visibility_check () == %d\n", visibility_check ()); + printf ("visibility_checkfunptr () == %d\n", + visibility_checkfunptr ()); + printf ("main_visibility_check () == %d\n", main_visibility_check ()); + printf ("visibility_checkvar () == %d\n", visibility_checkvar ()); + printf ("visibility_checkvarptr () == %d\n", + visibility_checkvarptr ()); + printf ("main_visibility_checkvar () == %d\n", + main_visibility_checkvar ()); + printf ("main_visibility_checkcom () == %d\n", + main_visibility_checkcom ()); + printf ("shlib_visibility_checkcom () == %d\n", + shlib_visibility_checkcom ()); + printf ("main_visibility_checkweak () == %d\n", + main_visibility_checkweak ()); + printf ("shlib_visibility_checkweak () == %d\n", + shlib_visibility_checkweak ()); + +#if !defined (PROTECTED_UNDEF_TEST) && defined (PROTECTED_TEST) + if (&shared_data != shared_data_p ()) + ret = 1; + p = shared_func_p (); + if (shared_func != p) + ret = 1; + if (shared_data != *shared_data_p ()) + ret = 1; + if (shared_func () != (*p) () ) + ret = 1; +#endif + + return ret; +} +#endif diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/protected0.d b/binutils-2.21/ld/testsuite/ld-elfvsb/protected0.d new file mode 100644 index 0000000..ea781dd --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/protected0.d @@ -0,0 +1,10 @@ +#source: define.s +#source: undef.s +#ld: -r +#readelf: -s + +Symbol table '.symtab' contains .* entries: + +Num: +Value +Size +Type +Bind +Vis +Ndx +Name +#... + +[0-9]+: [0-9a-fA-F]* +0 +OBJECT +GLOBAL +PROTECTED +. protected +#pass diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/protected1.d b/binutils-2.21/ld/testsuite/ld-elfvsb/protected1.d new file mode 100644 index 0000000..235db00 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/protected1.d @@ -0,0 +1,9 @@ +#source: undef.s +#ld: -r +#readelf: -s + +Symbol table '.symtab' contains .* entries: + +Num: +Value +Size Type +Bind +Vis +Ndx +Name +#... + +[0-9]+: [0-9a-fA-F]* +0 +NOTYPE +GLOBAL +PROTECTED +UND protected +#pass diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/sh1.c b/binutils-2.21/ld/testsuite/ld-elfvsb/sh1.c new file mode 100644 index 0000000..b275424 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/sh1.c @@ -0,0 +1,421 @@ +#ifndef NULL +#define NULL ((void *) 0) +#endif + +/* This is part of the shared library ld test. This file becomes part + of a shared library. */ + +/* This variable is supplied by the main program. */ +#ifndef XCOFF_TEST +extern int mainvar; +#endif + +/* This variable is defined in the shared library, and overridden by + the main program. */ +#ifndef XCOFF_TEST +#ifdef SHARED +/* SHARED is defined if we are compiling with -fpic/-fPIC. */ +int overriddenvar = -1; +#else +/* Without -fpic, newer versions of gcc assume that we are not + compiling for a shared library, and thus that overriddenvar is + local. */ +extern int overriddenvar; +#endif +#endif + +/* This variable is defined in the shared library. */ +int shlibvar1 = 3; + +/* This variable is defined by another object in the shared library. */ +extern int shlibvar2; + +/* These functions return the values of the above variables as seen in + the shared library. */ + +#ifndef XCOFF_TEST +int +shlib_mainvar () +{ + return mainvar; +} +#endif + +#ifndef XCOFF_TEST +int +shlib_overriddenvar () +{ + return overriddenvar; +} +#endif + +int +shlib_shlibvar1 () +{ + return shlibvar1; +} + +int +shlib_shlibvar2 () +{ + return shlibvar2; +} + +/* This function calls a function defined by another object in the + shared library. */ + +extern int shlib_shlibcalled (); + +int +shlib_shlibcall () +{ + return shlib_shlibcalled (); +} + +#ifndef XCOFF_TEST +/* This function calls a function defined in this object in the shared + library. The main program will override the called function. */ + +extern int shlib_overriddencall2 (); + +int +shlib_shlibcall2 () +{ + return shlib_overriddencall2 (); +} + +#ifdef SHARED +int +shlib_overriddencall2 () +{ + return 7; +} +#endif +#endif + +/* This function calls a function defined by the main program. */ + +#ifndef XCOFF_TEST +extern int main_called (); + +int +shlib_maincall () +{ + return main_called (); +} +#endif + +/* This function is passed a function pointer to shlib_mainvar. It + confirms that the pointer compares equally. */ + +int +shlib_checkfunptr1 (p) + int (*p) (); +{ + return p == shlib_shlibvar1; +} + +/* This function is passed a function pointer to main_called. It + confirms that the pointer compares equally. */ + +#ifndef XCOFF_TEST +int +shlib_checkfunptr2 (p) + int (*p) (); +{ + return p == main_called; +} +#endif + +/* This function returns a pointer to shlib_mainvar. */ + +int +(*shlib_getfunptr1 ()) () +{ + return shlib_shlibvar1; +} + +/* This function returns a pointer to main_called. */ + +#ifndef XCOFF_TEST +int +(*shlib_getfunptr2 ()) () +{ + return main_called; +} +#endif + +/* This function makes sure that constant data and local functions + work. */ + +#ifndef __STDC__ +#define const +#endif + +static int i = 6; +static const char *str = "Hello, world\n"; + +int +shlib_check () +{ + const char *s1, *s2; + + if (i != 6) + return 0; + + /* To isolate the test, don't rely on any external functions, such + as strcmp. */ + s1 = "Hello, world\n"; + s2 = str; + while (*s1 != '\0') + if (*s1++ != *s2++) + return 0; + if (*s2 != '\0') + return 0; + + if (shlib_shlibvar1 () != 3) + return 0; + + return 1; +} + +#ifdef HIDDEN_WEAK_TEST +#define HIDDEN_UNDEF_TEST +#define WEAK_TEST +#endif + +#ifdef PROTECTED_WEAK_TEST +#define PROTECTED_UNDEF_TEST +#define WEAK_TEST +#endif + +#if defined (HIDDEN_UNDEF_TEST) || defined (PROTECTED_UNDEF_TEST) +#ifdef WEAK_TEST +#pragma weak visibility +#endif +extern int visibility (); +#else +int +visibility () +{ + return 2; +} +#endif + +#ifdef HIDDEN_NORMAL_TEST +asm (".hidden visibility_normal"); + +int +visibility_normal () +{ + return 2; +} +#endif + +int +visibility_checkfunptr () +{ +#ifdef WEAK_TEST + return 1; +#else +#ifdef HIDDEN_NORMAL_TEST + int (*v) () = visibility_normal; +#else + int (*v) () = visibility; +#endif + return (*v) () == 2; +#endif +} + +int +visibility_check () +{ +#ifdef WEAK_TEST + if (&visibility) + return visibility () == 1; + else + return 1; +#else +#ifdef HIDDEN_NORMAL_TEST + return visibility_normal () == 2; +#else + return visibility () == 2; +#endif +#endif +} + +void * +visibility_funptr () +{ +#ifdef WEAK_TEST + if (&visibility == NULL) + return NULL; + else +#endif + return visibility; +} + +#if defined (HIDDEN_UNDEF_TEST) || defined (PROTECTED_UNDEF_TEST) +#ifdef WEAK_TEST +#pragma weak visibility_var +#endif +extern int visibility_var; +#else +int visibility_var = 2; +#endif + +#ifdef HIDDEN_NORMAL_TEST +asm (".hidden visibility_var_normal"); + +int visibility_var_normal = 2; +#endif + +int +visibility_checkvarptr () +{ +#ifdef WEAK_TEST + if (&visibility_var) + return visibility_var == 1; + else + return 1; +#else +#ifdef HIDDEN_NORMAL_TEST + int *v = &visibility_var_normal; +#else + int *v = &visibility_var; +#endif + return *v == 2; +#endif +} + +int +visibility_checkvar () +{ +#ifdef WEAK_TEST + return 1; +#else +#ifdef HIDDEN_NORMAL_TEST + return visibility_var_normal == 2; +#else + return visibility_var == 2; +#endif +#endif +} + +void * +visibility_varptr () +{ +#ifdef WEAK_TEST + if (&visibility_var == NULL) + return NULL; + else +#endif + return &visibility_var; +} + +int +visibility_varval () +{ +#ifdef WEAK_TEST + if (&visibility_var == NULL) + return 0; + else +#endif + return visibility_var; +} + +#if defined (HIDDEN_TEST) || defined (HIDDEN_UNDEF_TEST) +asm (".hidden visibility"); +asm (".hidden visibility_var"); +#else +#if defined (PROTECTED_TEST) || defined (PROTECTED_UNDEF_TEST) || defined (PROTECTED_WEAK_TEST) +asm (".protected visibility"); +asm (".protected visibility_var"); +#endif +#endif + +#ifdef HIDDEN_NORMAL_TEST +int shlib_visibility_com; +asm (".hidden shlib_visibility_com"); + +int +shlib_visibility_checkcom () +{ + return shlib_visibility_com == 0; +} + +int +shlib_visibility_checkweak () +{ + return 1; +} +#elif defined (HIDDEN_WEAK_TEST) +#pragma weak shlib_visibility_undef_var_weak +extern int shlib_visibility_undef_var_weak; +asm (".hidden shlib_visibility_undef_var_weak"); + +#pragma weak shlib_visibility_undef_func_weak +extern int shlib_visibility_undef_func_weak (); +asm (".hidden shlib_visibility_undef_func_weak"); + +#pragma weak shlib_visibility_var_weak +extern int shlib_visibility_var_weak; +asm (".hidden shlib_visibility_var_weak"); + +#pragma weak shlib_visibility_func_weak +extern int shlib_visibility_func_weak (); +asm (".hidden shlib_visibility_func_weak"); + +int +shlib_visibility_checkcom () +{ + return 1; +} + +int +shlib_visibility_checkweak () +{ + return &shlib_visibility_undef_var_weak == NULL + && &shlib_visibility_undef_func_weak == NULL + && &shlib_visibility_func_weak == NULL + && &shlib_visibility_var_weak == NULL; +} +#else +int +shlib_visibility_checkcom () +{ + return 1; +} + +int +shlib_visibility_checkweak () +{ + return 1; +} +#endif + +#ifdef PROTECTED_TEST +#ifdef SHARED +int shared_data = 100; +#else +extern int shared_data; +#endif + +int * +shared_data_p () +{ + return &shared_data; +} + +int +shared_func () +{ + return 100; +} + +void * +shared_func_p () +{ + return shared_func; +} +#endif diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/sh2.c b/binutils-2.21/ld/testsuite/ld-elfvsb/sh2.c new file mode 100644 index 0000000..e9a9687 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/sh2.c @@ -0,0 +1,61 @@ +/* This is part of the shared library ld test. This file becomes part + of a shared library. */ + +/* This variable is defined here, and referenced by another file in + the shared library. */ +int shlibvar2 = 4; + +/* This variable is defined here, and shouldn't be used to resolve a + reference with non-default visibility in another shared library. */ +int visibility_com = 2; + +/* This function is called by another file in the shared library. */ + +int +shlib_shlibcalled () +{ + return 5; +} + +#ifdef DSO_DEFINE_TEST +int +visibility () +{ + return 2; +} + +int visibility_var = 2; + +int visibility_def = 2; + +int +visibility_func () +{ + return 2; +} +#endif + +#ifdef HIDDEN_WEAK_TEST +int visibility_var_weak = 2; + +int +visibility_func_weak () +{ + return 2; +} +#endif + +#ifndef SHARED +# ifndef XCOFF_TEST +int overriddenvar = -1; + +int +shlib_overriddencall2 () +{ + return 7; +} +# endif +# ifdef PROTECTED_TEST +int shared_data = 100; +# endif +#endif diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/sh3.c b/binutils-2.21/ld/testsuite/ld-elfvsb/sh3.c new file mode 100644 index 0000000..a6d5dc8 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/sh3.c @@ -0,0 +1,7 @@ +int main_hidden_data = 1; + +int +main_hidden_func () +{ + return 1; +} diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/test.c b/binutils-2.21/ld/testsuite/ld-elfvsb/test.c new file mode 100644 index 0000000..ca23d38 --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/test.c @@ -0,0 +1,26 @@ +#pragma weak main_hidden_data +extern int main_hidden_data; +asm (".hidden main_hidden_data"); + +#pragma weak main_hidden_func +extern int main_hidden_func (); +asm (".hidden main_hidden_func"); + +int +_start (void) +{ + int ret = 0; + + if (&main_hidden_data != 0) + ret = 1; + if (main_hidden_func != 0) + ret = 1; + + return ret; +} + +int +__start (void) +{ + return _start (); +} diff --git a/binutils-2.21/ld/testsuite/ld-elfvsb/undef.s b/binutils-2.21/ld/testsuite/ld-elfvsb/undef.s new file mode 100644 index 0000000..5b99d6f --- /dev/null +++ b/binutils-2.21/ld/testsuite/ld-elfvsb/undef.s @@ -0,0 +1,3 @@ + .protected protected + .hidden hidden + .internal internal |