aboutsummaryrefslogtreecommitdiff
path: root/ld/testsuite/ld-elfcomm/elfcomm.exp
blob: daed58b90b0dd198262dbf8cd46762a10c9e9dc2 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
# Expect script for common symbol tests
#   Copyright 2003, 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 H.J. Lu (hjl@gnu.org)
#

# Make sure that ld correctly handles common symbols in ELF.

# This test can only be run on ELF platforms.
if ![is_elf_format] {
    return
}

proc test_sort_common {} {
    global exec_output
    global objdump
    global srcdir
    global subdir
    global as
    global ld
  
    set test "--sort-common (descending)"
  
    verbose "Check to see that --sort-common sorts in descending alignment"

    # We do not run the sort common tests for the DLX target because we know that the linker
    # will seg-fault.  The built-in DLX linker script requires that there be something in the
    # .text section and our sort-common.s file does not provide anything.
    if [istarget dlx-*-*] {
	untested "$test"
	return 0
    }
    
    if { ![ld_assemble $as $srcdir/$subdir/sort-common.s tmpdir/sort-common.o] } {
	unresolved "$test"
	return 0
    }

    if { ![ld_simple_link $ld tmpdir/sort-common.dx "--sort-common=descending tmpdir/sort-common.o"] } {
	fail "$test"
	return 0
    }

    send_log "$objdump --syms tmpdir/sort-common.dx | grep var | sort\n"
    set exec_output [run_host_cmd "$objdump" "--syms tmpdir/sort-common.dx | grep var | sort"]

    # Don't know why, but the CR ports fail this test.
    setup_xfail "cr16-*-*" "crx-*-*"

    # Note: The second regexp is for targets which put small commons in a .sbss
    #  section and large commons in a .bss section.
    if {   ![regexp ".*var_16.*var_8.*var_4.*var_2.*var_1.*" $exec_output]
        && ![regexp ".*sbss.*var_8.*var_4.*var_2.*var_1.*bss.*var_16.*" $exec_output] } {      
	fail $test
    } else {
	pass $test
    }

    set test "--sort-common (ascending)"
  
    verbose "Check to see that --sort-common=ascending sorts in ascending alignment"

    if { ![ld_simple_link $ld tmpdir/sort-common.ax "--sort-common=ascending tmpdir/sort-common.o"] } {
	fail "$test"
	return 0
    }

    send_log "$objdump --syms tmpdir/sort-common.ax | grep var | sort\n"
    set exec_output [run_host_cmd "$objdump" "--syms tmpdir/sort-common.ax | grep var | sort"]

    if {![regexp ".*var_1.*var_2.*var_4.*var_8.*var_16.*" $exec_output]} {      
	fail $test
	return 0
    }

    pass $test
    return 1
}

test_sort_common

set test1	"size/aligment change of common symbols"
set test1w1	"$test1 (warning 1)"
set test1w2	"$test1 (warning 2)"
set test1c1	"$test1 (change 1)"
set test1c2	"$test1 (change 2)"

if { ![is_remote host] && [which $CC] == 0 } {
    untested $test1w1
    untested $test1w2
    untested $test1c1
    untested $test1c2
    return
}
if { [istarget score-*-*] } {
    untested $test1w1
    untested $test1w2
    untested $test1c1
    untested $test1c2
    return
}

proc dump_common1 { testname } {
    global exec_output
    global READELF

    send_log "$READELF --syms tmpdir/common1.o | grep foo\n"
    set exec_output [run_host_cmd "$READELF" "--syms tmpdir/common1.o | grep foo"]

    if {   ![regexp "(\[ 	\]*)(\[0-9\]+):(\[ 	\]*)(\[0\]*)80(\[ 	\]+)4(\[ 	\]+)(COMMON|OBJECT)(\[ 	\]+)GLOBAL(\[ 	\]+)DEFAULT(\[ 	\]+)(PRC\\\[0xff03\\\]|COM|SCOM)(\[ 	\]+)_?foo2" $exec_output]
	|| ![regexp "(\[ 	\]*)(\[0-9\]+):(\[ 	\]*)(\[0-9\]+)(\[ 	\]+)21(\[ 	\]+)OBJECT(\[ 	\]+)GLOBAL(\[ 	\]+)DEFAULT(\[ 	\]+)(\[0-9\]+)(\[ 	\]+)_?foo1" $exec_output] } {
	verbose $exec_output
	fail $testname
	return 0
    }

    return 1
}

proc stt_common_test { options testname } {
    global exec_output
    global READELF
    global ld

    set options "$options tmpdir/common1a.o"

    if { ! [ld_simple_link $ld tmpdir/common.exe $options] } {
      unresolved $testname
      return 0
    }

    send_log "$READELF --syms tmpdir/common.exe | grep foo\n"
    set exec_output [run_host_cmd "$READELF" "--syms tmpdir/common.exe | grep foo"]

    if {![regexp "(\[ 	\]*)(\[0-9\]+):(\[ 	\]*)(\[0-9\]+)(\[ 	\]+)(\[0-9\]+)(\[ 	\]+)COMMON(\[ 	\]+)GLOBAL(\[ 	\]+)DEFAULT(\[ 	\]+)(\[0-9\]+)(\[ 	\]+)_?foo2" $exec_output] } {
	fail $testname
	return 0
    }

    pass $testname
    return 1
}

# Check to see if the assembler is generating symbols with the STT_COMMON type.
proc assembler_generates_commons {} {
    global exec_output
    global READELF

    verbose "Check to see if STT_COMMON symbols are being generated:"
    set exec_output [run_host_cmd "$READELF" "--syms tmpdir/common1a.o | grep foo"]

    if { ![regexp "(\[ 	\]*)(\[0-9\]+):(\[ 	\]*)(\[0\]*)80(\[ 	\]+).(\[ 	\]+)COMMON(\[ 	\]+)GLOBAL(\[ 	\]+)DEFAULT(\[ 	\]+)(PRC\\\[0xff03\\\]|COM|SCOM)(\[ 	\]+)_?foo2" $exec_output] } {
	verbose "STT_COMMON not generated"
	return 0
    }

    verbose "STT_COMMON's are generated"
    return 1
}


if {   ![ld_compile "$CC $CFLAGS" $srcdir/$subdir/common1a.c tmpdir/common1a.o]
    || ![ld_compile "$CC $CFLAGS" $srcdir/$subdir/common1b.c tmpdir/common1b.o] } {
    unresolved $test1
    return
}

global ld
global link_output

if { [ld_simple_link $ld tmpdir/common1.o "-r tmpdir/common1a.o tmpdir/common1b.o"] } {
    unresolved $test1w1
    return
}

# This test fails on MIPS because the backend sets type_change_ok.
# The size change warning is suppressed.
if {[istarget mips*-*-*]} {
    if { ![regexp "Warning: alignment (\[0-9\]+) of symbol \`_?foo1\' in tmpdir/common1b.o is smaller than 64 in tmpdir/common1a.o" $link_output] } {
        fail $test1w1
    } else {
        pass $test1w1
    }
} else {
    if { ![regexp "Warning: alignment (\[0-9\]+) of symbol \`_?foo1\' in tmpdir/common1b.o is smaller than 64 in tmpdir/common1a.o" $link_output]
         || ![regexp "Warning: size of symbol \`_?foo1\' changed from 2 in tmpdir/common1a.o to 21 in tmpdir/common1b.o" $link_output] } {
        fail $test1w1
    } else {
        pass $test1w1
    }
}

if { [dump_common1 $test1c1] } {
    pass $test1c1
}

if { [ld_simple_link $ld tmpdir/common1.o "-r tmpdir/common1b.o tmpdir/common1a.o"] } {
    unresolved $test1w2
    return
}

if { ![regexp "Warning: alignment (\[0-9\]+) of symbol \`_?foo1\' in tmpdir/common1b.o is smaller than 64 in tmpdir/common1a.o" $link_output] } {
    fail $test1w2
} else {
    pass $test1w2
}

if { [dump_common1 $test1c2] } {
    pass $test1c2
}

#
# The following tests are for when we are generating STT_COMMON symbols only.
#

if { ![assembler_generates_commons] } {
    return
}

stt_common_test "-static -e 0" "static link of common symbols"
stt_common_test "-shared"      "shared link of common symbols"
stt_common_test "-pie"         "position independent link of common symbols"