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
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
|
# Test code for libgccjit.so
#
# We will compile each of jit.dg/test-*.c into an executable
# dynamically linked against libgccjit.so, and then run each
# such executable.
#
# These executables call into the libgccjit.so API to create
# code, compile it, and run it, verifying that the results
# are as expected. See harness.h for shared code used by all
# such executables.
#
# The executables call into DejaGnu's unit testing C API to
# report PASS/FAIL results, which this script gathers back
# up into the Tcl world, reporting a summary of all results
# across all of the executables.
# Kludge alert:
# We need g++_init so that it can find the stdlib include path.
#
# g++_init (in lib/g++.exp) uses g++_maybe_build_wrapper,
# which normally comes from the definition of
# ${tool}_maybe_build_wrapper within lib/wrapper.exp.
#
# However, for us, ${tool} is "jit".
# Hence we load wrapper.exp with tool == "g++", so that
# g++_maybe_build_wrapper is defined.
set tool g++
load_lib wrapper.exp
set tool jit
load_lib dg.exp
load_lib prune.exp
load_lib target-supports.exp
load_lib gcc-defs.exp
load_lib timeout.exp
load_lib target-libpath.exp
load_lib gcc.exp
load_lib g++.exp
load_lib dejagnu.exp
# Look for lines of the form:
# definitely lost: 11,316 bytes in 235 blocks
# indirectly lost: 352 bytes in 4 blocks
# Ideally these would report zero bytes lost (which is a PASS);
# for now, report non-zero leaks as XFAILs.
proc report_leak {kind name logfile line} {
set match [regexp "$kind lost: .*" $line result]
if $match {
verbose "Saw \"$result\" within \"$line\"" 4
# Extract bytes and blocks.
# These can contain commas as well as numerals,
# but we only care about whether we have zero.
regexp "$kind lost: (.+) bytes in (.+) blocks" \
$result -> bytes blocks
verbose "bytes: '$bytes'" 4
verbose "blocks: '$blocks'" 4
if { $bytes == 0 } {
pass "$name: $logfile: $result"
} else {
xfail "$name: $logfile: $result"
}
}
}
proc parse_valgrind_logfile {name logfile} {
verbose "parse_valgrind_logfile: $logfile" 2
if [catch {set f [open $logfile]}] {
fail "$name: unable to read $logfile"
return
}
while { [gets $f line] >= 0 } {
# Strip off the PID prefix e.g. ==7675==
set line [regsub "==\[0-9\]*== " $line ""]
verbose $line 2
report_leak "definitely" $name $logfile $line
report_leak "indirectly" $name $logfile $line
}
close $f
}
# Given WRES, the result from "wait", issue a PASS
# if the spawnee exited cleanly, or a FAIL for various kinds of
# unexpected exits.
proc verify_exit_status { executable wres } {
lassign $wres pid spawnid os_error_flag value
verbose "pid: $pid" 3
verbose "spawnid: $spawnid" 3
verbose "os_error_flag: $os_error_flag" 3
verbose "value: $value" 3
# Detect segfaults etc:
if { [llength $wres] > 4 } {
if { [lindex $wres 4] == "CHILDKILLED" } {
fail "$executable killed: $wres"
return
}
}
if { $os_error_flag != 0 } {
fail "$executable: OS error: $wres"
return
}
if { $value != 0 } {
fail "$executable: non-zero exit code: $wres"
return
}
pass "$executable exited cleanly"
}
# This is host_execute from dejagnu.exp commit
# 126a089777158a7891ff975473939f08c0e31a1c
# with the following patch applied, and renaming to "fixed_host_execute".
# See the discussion at
# http://lists.gnu.org/archive/html/dejagnu/2014-10/msg00000.html
#
# --- /usr/share/dejagnu/dejagnu.exp.old 2014-10-08 13:38:57.274068541 -0400
# +++ /usr/share/dejagnu/dejagnu.exp 2014-10-10 12:27:51.113813659 -0400
# @@ -113,8 +113,6 @@ proc host_execute {args} {
# set timetol 0
# set arguments ""
#
# - expect_before buffer_full { perror "Buffer full" }
# -
# if { [llength $args] == 0} {
# set executable $args
# } else {
# Execute the executable file, and anaylyse the output for the
# test state keywords.
# Returns:
# A "" (empty) string if everything worked, or an error message
# if there was a problem.
#
proc fixed_host_execute {args} {
global env
global text
global spawn_id
set timeoutmsg "Timed out: Never got started, "
set timeout 100
set file all
set timetol 0
set arguments ""
if { [llength $args] == 0} {
set executable $args
} else {
set executable [string trimleft [lindex [split $args " "] 0] "\{"]
set params [string trimleft [lindex [split $args " "] 1] "\{"]
set params [string trimright $params "\}"]
}
verbose "The executable is $executable" 2
if {![file exists ${executable}]} {
perror "The executable, \"$executable\" is missing" 0
return "No source file found"
}
# spawn the executable and look for the DejaGnu output messages from the
# test case.
# spawn -noecho -open [open "|./${executable}" "r"]
# Run under valgrind if RUN_UNDER_VALGRIND is present in the environment.
# Note that it's best to configure gcc with --enable-valgrind-annotations
# when testing under valgrind.
set run_under_valgrind [info exists env(RUN_UNDER_VALGRIND)]
if $run_under_valgrind {
set valgrind_logfile "${executable}.valgrind.txt"
set valgrind_params {"valgrind"}
lappend valgrind_params "--leak-check=full"
lappend valgrind_params "--log-file=${valgrind_logfile}"
} else {
set valgrind_params {}
}
verbose "valgrind_params: $valgrind_params" 2
set args ${valgrind_params}
lappend args "./${executable}"
set args [concat $args ${params}]
verbose "args: $args" 2
eval spawn -noecho $args
expect_after full_buffer { error "got full_buffer" }
set prefix "\[^\r\n\]*"
expect {
-re "^$prefix\[0-9\]\[0-9\]:..:..:${text}*\r\n" {
regsub "\[\n\r\t\]*NOTE: $text\r\n" $expect_out(0,string) "" output
verbose "$output" 3
set timetol 0
exp_continue
}
-re "^$prefix\tNOTE:${text}*" {
regsub "\[\n\r\t\]*NOTE: $text\r\n" $expect_out(0,string) "" output
set output [string range $output 6 end]
verbose "$output" 2
set timetol 0
exp_continue
}
-re "^$prefix\tPASSED:${text}*" {
regsub "\[\n\r\t\]*PASSED: $text\r\n" $expect_out(0,string) "" output
set output [string range $output 8 end]
pass "$output"
set timetol 0
exp_continue
}
-re "^$prefix\tFAILED:${text}*" {
regsub "\[\n\r\t\]*FAILED: $text\r\n" $expect_out(0,string) "" output
set output [string range $output 8 end]
fail "$output"
set timetol 0
exp_continue
}
-re "^$prefix\tUNTESTED:${text}*" {
regsub "\[\n\r\t\]*TESTED: $text\r\n" $expect_out(0,string) "" output
set output [string range $output 8 end]
untested "$output"
set timetol 0
exp_continue
}
-re "^$prefix\tUNRESOLVED:${text}*" {
regsub "\[\n\r\t\]*UNRESOLVED: $text\r\n" $expect_out(0,string) "" output
set output [string range $output 8 end]
unresolved "$output"
set timetol 0
exp_continue
}
-re "^Totals" {
verbose "All done" 2
}
eof {
# unresolved "${executable} died prematurely"
# catch close
# return "${executable} died prematurely"
}
timeout {
warning "Timed out executing test case"
if { $timetol <= 2 } {
incr timetol
exp_continue
} else {
catch close
return "Timed out executing test case"
}
}
-re "^$prefix\r\n" {
exp_continue
}
}
# Use "wait" before "close": valgrind might not have finished
# writing the log out before we parse it, so we need to wait for
# the spawnee to finish.
catch wait wres
verbose "wres: $wres" 2
verify_exit_status $executable $wres
if $run_under_valgrind {
upvar 2 name name
parse_valgrind_logfile $name $valgrind_logfile
}
# force a close of the executable to be safe.
catch close
return ""
}
# (end of code from dejagnu.exp)
# GCC_UNDER_TEST is needed by gcc_target_compile
global GCC_UNDER_TEST
if ![info exists GCC_UNDER_TEST] {
set GCC_UNDER_TEST "[find_gcc]"
}
g++_init
# Initialize dg.
dg-init
# Gather a list of all tests.
# C tests within the testsuite: gcc/testsuite/jit.dg/test-*.c
set tests [find $srcdir/$subdir test-*.c]
# C++ tests within the testsuite: gcc/testsuite/jit.dg/test-*.cc
set tests [concat $tests [find $srcdir/$subdir test-*.cc]]
# We also test the examples within the documentation, to ensure that
# they compile:
set tests [concat $tests [find $srcdir/../jit/docs/examples *.c]]
set tests [concat $tests [find $srcdir/../jit/docs/examples *.cc]]
set tests [lsort $tests]
verbose "tests: $tests"
# Is testcase NAME meant to generate a reproducer?
proc is_testcase_meant_to_generate_a_reproducer {name} {
# We expect most testcases to generate a reproducer.
# The exceptions are the tutorials (which don't have a "test-"
# prefix), and test-threads.c (which is unique).
verbose "is_testcase_meant_to_generate_a_reproducer: $name"
if { [string match "*test-*" $name] } {
if { [string match "*test-threads.c" $name] } {
return 0
}
return 1
}
return 0
}
# libgloss has found the driver (as "xgcc" or "gcc) and stored
# its full path as GCC_UNDER_TEST.
proc get_path_of_driver {} {
global GCC_UNDER_TEST
verbose "GCC_UNDER_TEST: $GCC_UNDER_TEST"
set binary [lindex $GCC_UNDER_TEST 0]
verbose "binary: $binary"
return [file dirname $binary]
}
proc jit-dg-test { prog do_what extra_tool_flags } {
verbose "within jit-dg-test..."
verbose " prog: $prog"
verbose " do_what: $do_what"
verbose " extra_tool_flags: $extra_tool_flags"
# test-threads.c needs to be linked against pthreads
if {[string match "*test-threads.c" $prog]} {
append extra_tool_flags " -lpthread"
}
# Determine what to name the built executable.
#
# We simply append .exe to the filename, e.g.
# "test-foo.c.exe"
# since some testcases exist in both
# "test-foo.c" and
# "test-foo.cc"
# variants, and we don't want them to clobber each other's
# executables.
#
# This also ensures that the source name makes it into the
# pass/fail output, so that we can distinguish e.g. which test-foo
# is failing.
set output_file "[file tail $prog].exe"
verbose "output_file: $output_file"
# Create the test executable:
set extension [file extension $prog]
if {$extension == ".cc"} {
set compilation_function "g++_target_compile"
set options "{additional_flags=$extra_tool_flags}"
} else {
set compilation_function "gcc_target_compile"
# Until recently, <dejagnu.h> assumed -fgnu89-inline
# Ideally we should fixincludes it (PR other/63613), but
# for now add -fgnu89-inline when compiling C JIT testcases.
# See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63613
# and http://lists.gnu.org/archive/html/dejagnu/2014-10/msg00011.html
set options "{additional_flags=$extra_tool_flags -fgnu89-inline}"
}
verbose "compilation_function=$compilation_function"
verbose "options=$options"
set comp_output [$compilation_function $prog $output_file \
"executable" $options]
upvar 1 name name
if ![jit_check_compile "$name" "initial compilation" \
$output_file $comp_output] then {
return
}
# Most of the test cases use gcc_jit_context_dump_reproducer_to_file
# as they run to write out a .c file that reproduces their behavior,
# exercising that API.
set generated_reproducer "${output_file}.reproducer.c"
# Delete any such generated .c file from a previous run.
catch "exec rm -f $generated_reproducer"
# Run the test executable, capturing the PASS/FAIL textual output
# from the C API, converting it into the Tcl API.
# We need to set LD_LIBRARY_PATH so that the test files can find
# libgccjit.so
# Do this using set_ld_library_path_env_vars from target-libpath.exp
# We will restore the old value later using
# restore_ld_library_path_env_vars.
# Unfortunately this API only supports a single saved value, rather
# than a stack, and g++_init has already called into this API,
# injecting the appropriate value for LD_LIBRARY_PATH for finding
# the built copy of libstdc++.
# Hence the call to restore_ld_library_path_env_vars would restore
# the *initial* value of LD_LIBRARY_PATH, and attempts to run
# a C++ testcase after running any prior testcases would thus look
# in the wrong place for libstdc++. This led to failures at startup
# of the form:
# ./tut01-hello-world.cc.exe: /lib64/libstdc++.so.6: version `GLIBCXX_3.4.21' not found (required by ./tut01-hello-world.cc.exe)
# when the built libstdc++ is more recent that the system libstdc++.
#
# As a workaround, reset the variable "orig_environment_saved" within
# target-libpath.exp, so that the {set|restore}_ld_library_path_env_vars
# API saves/restores the current value of LD_LIBRARY_PATH (as set up
# by g++_init).
global orig_environment_saved
set orig_environment_saved 0
global ld_library_path
global base_dir
set ld_library_path "$base_dir/../../"
set_ld_library_path_env_vars
# libgccjit uses the driver to convert .s files to .so libraries
# via its *installed* name, FULL_DRIVER_NAME
# ${target_noncanonical}-gcc-${gcc_BASEVER}${exeext}
# e.g. "x86_64-unknown-linux-gnu-gcc-5.0.0"
# looking for it on PATH. Hence we need to prepend the location of
# that executable to PATH when running the tests
set dir_containing_driver [get_path_of_driver ]
verbose "dir_containing_driver: $dir_containing_driver"
global env
set old_path $env(PATH)
setenv "PATH" $dir_containing_driver:$old_path
verbose -log "PATH=[getenv PATH]"
# We have:
# test-executables
# linked to -> libgccjit.so
# -> invokes driver:
# -> invokes the assembler
# -> invokes the linker
# We want to be able to run this from the builddir without installing
# but the linker needs to be able to locate various libraries, or we
# get:
# ld: cannot find crtbeginS.o: No such file or directory
# ld: cannot find -lgcc
# ld: cannot find -lgcc_s
# These can be found in the "gcc" subdir of the build.
# Hence to be able to run the testsuite without installing, we need
# to set or prepend the "gcc" subdir of the build to LIBRARY_PATH:
if { [info exists env(LIBRARY_PATH) ] } {
set old_library_path $env(LIBRARY_PATH)
setenv "LIBRARY_PATH" $dir_containing_driver:$old_library_path
} else {
setenv "LIBRARY_PATH" $dir_containing_driver
}
verbose -log "LIBRARY_PATH=[getenv LIBRARY_PATH]"
# dejagnu.exp's host_execute has code to scrape out test results
# from the DejaGnu C API and bring back into the tcl world, so we
# use that to invoke the built code.
# However, it appears to be buggy; see:
# http://lists.gnu.org/archive/html/dejagnu/2014-10/msg00000.html
# We instead call a patched local copy, "fixed_host_execute", defined
# above.
set result [fixed_host_execute $output_file]
verbose "result: $result"
# Restore PATH
setenv "PATH" $old_path
# Restore LIBRARY_PATH
if { [info exists old_library_path] } {
setenv "LIBRARY_PATH" $old_library_path
} else {
unsetenv "LIBRARY_PATH"
}
restore_ld_library_path_env_vars
# Most of the test cases use gcc_jit_context_dump_reproducer_to_file
# as they run to write out a .c file that reproduces their behavior,
# exercising that API.
if { [is_testcase_meant_to_generate_a_reproducer $name] } {
verbose "$name is meant to generate a reproducer"
# Verify that a reproducer was generated
if { [file exists $generated_reproducer] == 1} {
pass "found generated reproducer: $generated_reproducer"
set output_file "${generated_reproducer}.exe"
# (this overwrites output_file)
# Try to compile the generated reproducer
verbose "compilation_function=$compilation_function"
# The .c file written by gcc_jit_context_dump_reproducer_to_file
# assigns the result of each API call to a unique variable, and not
# all are necessarily used, so we need -Wno-unused-variable.
set options \
"{additional_flags=$extra_tool_flags -Wno-unused-variable}"
verbose "options=$options"
set comp_output2 [$compilation_function $generated_reproducer \
$output_file "executable" $options]
if ![jit_check_compile "generated reproducer from $name" "initial compilation" \
$output_file $comp_output2] then {
return
}
# The caller, dg-test, will verify comp_output, which contains
# the output from compiling the testcase and will issue a fail
# if it's non-empty (e.g. containing warnings, the
# "test for excess errors").
#
# Append the output from compiling the reproducer, so that this is also
# verified:
append comp_output $comp_output2
# TODO: we should try to run the built executable
# It's not quite a quine, since it embeds ptrs which could change
# from run to run.
} else {
fail "did not find a generated reproducer: $generated_reproducer"
}
} else {
verbose "$name is not meant to generate a reproducer"
}
return [list $comp_output $output_file]
}
# We need to link with --export-dynamic for test-calling-external-function.c
# so that the JIT-built code can call into functions from the main program.
set DEFAULT_CFLAGS "-I$srcdir/../jit -lgccjit -g -Wall -Werror -Wl,--export-dynamic"
# Main loop. This will invoke jig-dg-test on each test-*.c file.
dg-runtest $tests "" $DEFAULT_CFLAGS
# All done.
dg-finish
|