URL
https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk
Subversion Repositories openrisc_2011-10-31
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/trunk/gnu-src/binutils-2.18.50/ld/testsuite/ld-elfvsb
- from Rev 38 to Rev 156
- ↔ Reverse comparison
Rev 38 → Rev 156
/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 |
/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 . */ |
} |
/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 |
/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: |
/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 |
/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 |
/hidden0.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 HIDDEN . hidden |
#pass |
/hidden1.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 HIDDEN UND hidden |
#pass |
/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 HIDDEN +ABS foo |
#pass |
/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 (); |
} |
/undef.s
0,0 → 1,3
.protected protected |
.hidden hidden |
.internal internal |
/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 |
/common.c
0,0 → 1,14
int foo; |
asm (".hidden foo"); |
|
int |
_start (void) |
{ |
return foo; |
} |
|
int |
__start (void) |
{ |
return _start (); |
} |
/hidden2.ld
0,0 → 1,7
SECTIONS |
{ |
. = 0x1000; |
PROVIDE (foo = .); |
.data : { *(.data) } |
.dynamic : { *(.dynamic) } |
} |
/elfvsb.exp
0,0 → 1,475
# Expect script for ld-visibility tests |
# Copyright 2000, 2001, 2002, 2003, 2004, 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 "" |
|
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 |
} |
|
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 |
|
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*" |
} |
|
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*" |
} |
|
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*" |
} |
|
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 |
} |
/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 |
/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 |
/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 |
/hidden2.s
0,0 → 1,5
.data |
.hidden foo |
.global foo |
.type foo,%object |
.dc.a foo |
/sh3.c
0,0 → 1,7
int main_hidden_data = 1; |
|
int |
main_hidden_func () |
{ |
return 1; |
} |