OSDN Git Service

PR go/50656
[pf3gnuchains/gcc-fork.git] / gcc / testsuite / go.test / go-test.exp
1 #   Copyright (C) 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
2 #   Written by Ian Lance Taylor <iant@google.com>.
3
4 # This program is free software; you can redistribute it and/or modify
5 # it under the terms of the GNU General Public License as published by
6 # the Free Software Foundation; either version 3 of the License, or
7 # (at your option) any later version.
8 #
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 # GNU General Public License for more details.
13 #
14 # You should have received a copy of the GNU General Public License
15 # along with GCC; see the file COPYING3.  If not see
16 # <http://www.gnu.org/licenses/>.
17
18
19 # Test using the testsuite for the gc Go compiler.  In these tests the
20 # first line is a shell script to run.  That line expects the
21 # following environment variables to be set:
22 #   A   The file extension of the object file and the name of the executable
23 #   G   The name of the compiler
24 #   L   The name of the linker
25 #   F   The basename of the test
26 #   D   The directory of the test.
27 #
28 # Typical command lines:
29 # // $G $D/$F.go && $L $F.$A && ./$A.out
30 # // $G $D/$F.go && $L $F.$A || echo BUG: known to fail incorrectly
31 # // $G $D/$F.go && echo BUG: compilation succeeds incorrectly
32 # // $G $D/$F.go || echo BUG: compilation should succeed
33
34 load_lib go-dg.exp
35 load_lib go-torture.exp
36
37 # Implement errchk
38 proc errchk { test opts } {
39     global dg-do-what-default
40     global DEFAULT_GOCFLAGS
41     global runtests
42
43     set saved-dg-do-what-default ${dg-do-what-default}
44     set dg-do-what-default compile
45     set filename [file tail $test]
46     if { "$filename" == "$test" } {
47         set filename "errchk-$filename"
48     }
49     set fdin [open $test r]
50     fconfigure $fdin -encoding binary
51     set fdout [open $filename w]
52     fconfigure $fdout -encoding binary
53     while { [gets $fdin copy_line] >= 0 } {
54         if [string match "*////*" $copy_line] {
55             puts $fdout $copy_line
56             continue
57         }
58         regsub "// \(GCCGO_\)?ERROR \"\(\[^\"\]*\)\".*$" $copy_line "// \{ dg-error \"\\2\" \}" out_line
59         if [string match "*dg-error*.\**" $out_line] {
60             # I worked out the right number of backslashes by
61             # experimentation, not analysis.
62             regsub -all "\\.\\*" $out_line "\\\\\[ -~\\\\\]*" out_line
63         }
64         if [string match "*dg-error*\\\[?\\\]*" $out_line] {
65             set index [string first "dg-error" $out_line]
66             regsub -all "\\\[\(.\)\\\]" $out_line "\\\\\[\\1\\\\\]" out_line
67         }
68         if [string match "*dg-error*\{*" $out_line] {
69             set index [string first "dg-error" $out_line]
70             regsub -start $index -all "\(\[^\\\\]\)\{" $out_line "\\1\\\\\[\\\{\\\\\]" out_line
71         }
72         if [string match "*dg-error*\}*\}" $out_line] {
73             set index [string first "dg-error" $out_line]
74             regsub -start $index -all "\(\[^\\\\]\)\}\(.\)" $out_line "\\1\\\\\[\\\}\\\\\]\\2" out_line
75         }
76         if [string match "*dg-error*\(*" $out_line] {
77             set index [string first "dg-error" $out_line]
78             regsub -start $index -all "\\\\\\\(" $out_line "\\\\\[\\\(\\\\\]" out_line
79         }
80         if [string match "*dg-error*\)*\}" $out_line] {
81             set index [string first "dg-error" $out_line]
82             regsub -start $index -all "\\\\\\\)\(.\)" $out_line "\\\\\[\\\)\\\\\]\\1" out_line
83         }
84         # Special case for bug332, in which the error message wants to
85         # match the file name, which is not what dg-error expects.
86         if [string match "*dg-error*bug332*" $out_line] {
87             set index [string first "dg-error" $out_line]
88             regsub -start $index "bug332" $out_line "undefined type" out_line
89         }
90         puts $fdout $out_line
91     }
92     close $fdin
93     close $fdout
94
95     set hold_runtests $runtests
96     set runtests "go-test.exp"
97     go-dg-runtest $filename "-fno-show-column $DEFAULT_GOCFLAGS $opts"
98     set runtests $hold_runtests
99
100     file delete $filename
101     set dg-do-what-default ${saved-dg-do-what-default}
102 }
103
104 # This is an execution test which should fail.
105 proc go-execute-xfail { test } {
106     global DEFAULT_GOCFLAGS
107     global runtests
108
109     set filename [file tail $test]
110     set fdin [open $test r]
111     set fdout [open $filename w]
112     puts $fdout "// { dg-do run { xfail *-*-* } }"
113     while { [gets $fdin copy_line] >= 0 } {
114         puts $fdout $copy_line
115     }
116     close $fdin
117     close $fdout
118
119     set hold_runtests $runtests
120     set runtests "go-test.exp"
121     go-dg-runtest $filename "-w $DEFAULT_GOCFLAGS"
122     set runtests $hold_runtests
123
124     file delete $filename
125 }
126
127 # N.B. Keep in sync with libgo/configure.ac.
128 proc go-set-goarch { } {
129     global target_triplet
130
131     switch -glob $target_triplet {
132         "alpha*-*-*" {
133             set goarch "alpha"
134         }
135         "arm*-*-*" -
136         "ep9312*-*-*" -
137         "strongarm*-*-*" -
138         "xscale-*-*" {
139             set goarch "arm"
140         }
141         "i?86-*-*" -
142         "x86_64-*-*" {
143             if [check_effective_target_ia32] {
144                 set goarch "386"
145             } else {
146                 set goarch "amd64"
147             }
148         }
149         "mips*-*-*" {
150             if [check_no_compiler_messages mipso32 assembly {
151                 #if _MIPS_SIM != _ABIO32
152                 #error FOO
153                 #endif
154             }] {
155                 set goarch "mipso32"
156             } elseif [check_no_compiler_messages mipsn32 assembly {
157                 #if _MIPS_SIM != _ABIN32
158                 #error FOO
159                 #endif
160             }] {
161                 set goarch "mipsn32"
162             } elseif [check_no_compiler_messages mipsn64 assembly {
163                 #if _MIPS_SIM != _ABI64
164                 #error FOO
165                 #endif
166             }] {
167                 set goarch "mipsn64"
168             } elseif [check_no_compiler_messages mipso64 assembly {
169                 #if _MIPS_SIM != _ABIO64
170                 #error FOO
171                 #endif
172             }] {
173                 set goarch "mipso64"
174             } else {
175                 perror "$target_triplet: unrecognized MIPS ABI"
176                 return ""
177             }
178         }
179         "sparc*-*-*" {
180             if [check_effective_target_ilp32] {
181                 set goarch "sparc"
182             } else {
183                 set goarch "sparc64"
184             }
185         }
186         default {
187             perror "$target_triplet: unhandled architecture"
188             return ""
189         }       
190     }
191     verbose -log "Setting GOARCH=$goarch" 1
192     setenv GOARCH $goarch
193 }
194
195 proc go-gc-tests { } {
196     global srcdir subdir
197     global runtests
198     global GCC_UNDER_TEST
199     global TOOL_OPTIONS
200     global TORTURE_OPTIONS
201     global dg-do-what-default
202     global go_execute_args
203     global target_triplet
204
205     # If a testcase doesn't have special options, use these.
206     global DEFAULT_GOCFLAGS
207     if ![info exists DEFAULT_GOCFLAGS] {
208         set DEFAULT_GOCFLAGS " -pedantic-errors"
209     }
210
211     # Set GOARCH for tests that need it.
212     go-set-goarch
213
214     # Running all the torture options takes too long and, since the
215     # frontend ignores the standard options, it doesn't significantly
216     # improve testing.
217     set saved_torture_options $TORTURE_OPTIONS
218     set TORTURE_OPTIONS [ list { -O2 -g }]
219
220     set saved-dg-do-what-default ${dg-do-what-default}
221
222     set testdir [pwd]
223
224     set tests [lsort [find $srcdir/$subdir *.go]]
225     foreach test $tests {
226         if ![runtest_file_p $runtests $test] {
227             continue
228         }
229
230         # Skip the files in bench and garbage; they are not tests.
231         if [string match "*go.test/test/bench/*" $test] {
232             continue
233         }
234         if [string match "*go.test/test/garbage/*" $test] {
235             continue
236         }
237
238         # Skip files in sub-subdirectories: they are components of
239         # other tests.
240         if [string match "*go.test/test/*/*/*" $test] {
241             continue
242         }
243
244         set name [dg-trim-dirname $srcdir $test]
245
246         # Skip certain tests if target is RTEMS OS.
247         if [istarget "*-*-rtems*"] {
248             if { [string match "*go.test/test/args.go" \
249                    $test] \
250                  || [string match "*go.test/test/env.go" \
251                    $test] } {
252                     untested "$name: uses the command-line or environment variables"
253                     continue
254             }
255
256             if { [string match "*go.test/test/stack.go" \
257                    $test] \
258                  || [string match "*go.test/test/peano.go" \
259                    $test] \
260                  || [string match "*go.test/test/chan/goroutines.go" \
261                    $test] } {
262                     untested "$name: has very high memory requirement"
263                     continue
264             }
265         }
266
267         if { [string match "*bug347*" $test] \
268                  || [string match "*bug348*" $test] } {
269             # These bugs rely on runtime.Caller which currently fails.
270             untested $name
271             continue
272         }
273
274         set fd [open $test r]
275
276         set lines_ok 1
277
278         while 1 {
279             if { [gets $fd test_line] < 0 } {
280                 close $fd
281                 clone_output "$test: could not read first line"
282                 unresolved $name
283                 set lines_ok 0
284                 break
285             }
286
287             if { [ string match "*nacl*exit 0*" $test_line ] \
288                      || [ string match "*exit 0*nacl*" $test_line ] \
289                      || [ string match "*Android*exit 0*" $test_line ] \
290                      || [ string match "*exit 0*Android*" $test_line ] } {
291                 continue
292             }
293
294             break
295         }
296
297         if { $lines_ok == 0 } {
298             continue
299         }
300
301         set lineno 1
302         set test_line1 $test_line
303
304         while { [eval "string match \"//*&&\" \${test_line$lineno}"] } {
305             set lineno [expr $lineno + 1]
306             if { [eval "gets \$fd test_line$lineno"] < 0 } {
307                 close $fd
308                 clone_output "$test: could not read line $lineno"
309                 unresolved $name
310                 set lines_ok 0
311                 break
312             }
313         }
314         if { $lines_ok == 0 } {
315             continue
316         }
317
318         close $fd
319
320         set go_execute_args ""
321         if { [regexp ".*\\\$A.out (\[^|&>\].*)\$" $test_line match progargs] } {
322             set go_execute_args $progargs
323             verbose -log "$test: go_execute_args is $go_execute_args"
324             set index [string last " $progargs" $test_line]
325             set test_line [string replace $test_line $index end]
326         } elseif { [string match "*go.test/test/chan/goroutines.go" $test] \
327                    && [getenv GCCGO_RUN_ALL_TESTS] == "" } {
328             # goroutines.go spawns by default 10000 threads, which is too much
329             # for many OSes.
330             if { [getenv GCC_TEST_RUN_EXPENSIVE] == "" } {
331                 set go_execute_args 64
332             } elseif { ![is_remote host] && ![is_remote target] } {
333                 # When using low ulimit -u limit, use maximum of
334                 # a quarter of that limit and 10000 even when running expensive
335                 # tests, otherwise parallel tests might fail after fork failures.
336                 set nproc [lindex [remote_exec host {sh -c ulimit\ -u}] 1]
337                 if { [string is integer -strict $nproc] } {
338                         set nproc [expr $nproc / 4]
339                         if { $nproc > 10000 } { set nproc 10000 }
340                         if { $nproc < 16 } { set nproc 16 }
341                         set go_execute_args $nproc
342                 }
343             }
344             if { "$go_execute_args" != "" } {
345                 verbose -log "$test: go_execute_args is $go_execute_args"
346             }
347         }
348
349         if { $test_line == "// \$G \$D/\$F\.go && \$L \$F\.\$A && \./\$A\.out >tmp.go &&" \
350              && $test_line2 == "// \$G tmp\.go && \$L tmp\.\$A && \./\$A\.out || echo BUG: 64bit" } {
351             # 64bit.go is a special case.
352             set go_execute_args ""
353             set hold_runtests $runtests
354             set runtests "go-test.exp"
355             set dg-do-what-default "link"
356             dg-test -keep-output $test "-O" "-w $DEFAULT_GOCFLAGS"
357             set output_file "./[file rootname [file tail $test]].exe"
358             set base "[file rootname [file tail $test]]"
359             if [isnative] {
360                 if { [catch "exec $output_file >$base-out.go"] != 0 } {
361                     fail "$name execution"
362                 } else {
363                     pass "$name execution"
364                     file delete $base-out.x
365                     go-torture-execute "./$base-out.go"
366                 }
367                 file delete $base-out.go
368             }
369             file delete $output_file
370             set runtests $hold_runtests
371         } elseif { $test_line == "// \$G \$D/\$F.go && \$L \$F.\$A && ./\$A.out" \
372                    || $test_line == "// \$G \$F.go && \$L \$F.\$A && ./\$A.out" \
373                    || $test_line == "// \$G \$F.go && \$L \$F.\$A &&./\$A.out" \
374                    || $test_line == "// \$G \$D/\$F.go && \$L \$F.\$A && \$A.out" \
375                    || [string match \
376                            "// \$G \$D/\$F.go && \$L \$F.\$A && ./\$A.out || echo BUG*" \
377                            $test_line]
378                    || [string match \
379                            "// \$G \$F.go && \$L \$F.\$A && (./\$A.out || echo BUG*" \
380                            $test_line]
381                    || [string match \
382                            "// \$G \$D/\$F.go && \$L \$F.\$A && (./\$A.out || echo BUG*" \
383                            $test_line]
384                    || [string match \
385                            "// \$G \$F.go && \$L \$F.\$A && GOMAXPROCS=* ./\$A.out" \
386                            $test_line]
387                    || [string match \
388                            "// \$G \$D/\$F.go && \$L \$F.\$A && ./\$A.out >* || echo BUG*" \
389                            $test_line] } {
390             # This is a vanilla execution test.
391             go-torture-execute $test
392             file delete core [glob -nocomplain core.*]
393         } elseif { [string match \
394                         "// \$G \$D/\$F.go && \$L \$F.\$A || echo BUG*" \
395                         $test_line] \
396                    || [string match "// \$G \$F.go && \$L \$F.\$A  #*" \
397                            $test_line]
398                    || $test_line == "// \$G \$D/\$F.go && \$L \$F.\$A" } {
399             # This is a vanilla compile and link test.
400             set dg-do-what-default "link"
401             go-dg-runtest $test "-w $DEFAULT_GOCFLAGS"
402         } elseif { [string match "// \$G \$D/\$F.go" $test_line] \
403                    || [string match "// \$G \$D/\$F.go || echo BUG*" \
404                            $test_line] \
405                    || [string match "// \$G \$F.go || echo BUG*" \
406                            $test_line] \
407                    || [string match "// ! \$G \$D/\$F.go && echo BUG*" \
408                            $test_line] } {
409             # This is a vanilla compile test.
410             set dg-do-what-default "assemble"
411             go-dg-runtest $test "-w $DEFAULT_GOCFLAGS"
412         } elseif { [string match "// \$G \$D/\$F.go && echo BUG*" \
413                         $test_line] \
414                    || $test_line == "// ! \$G \$D/\$F.go >/dev/null" \
415                    || $test_line == "// ! \$G \$D/\$F.go" \
416                    || $test_line == "// ! \$G \$F.go" \
417                    || [string match "// ! \$G \$D/\$F.go || echo BUG*" \
418                         $test_line] } {
419             # This is a compile test which should fail.
420             set dg-do-what-default "assemble"
421             setup_xfail "*-*-*"
422             go-dg-runtest $test "-w $DEFAULT_GOCFLAGS"
423         } elseif { [string match "// \$G \$D/\$F.go && \$L \$F.\$A && ! ./\$A.out" \
424                         $test_line] \
425                    || [string match "// \$G \$D/\$F.go && \$L \$F.\$A && ! ./\$A.out || echo BUG: *" \
426                         $test_line] \
427                    || [string match "// \$G \$D/\$F.go && \$L \$F.\$A && (! ./\$A.out || echo BUG: *" \
428                         $test_line] \
429                    || ($test_line == "// \$G \$D/\$F.go && \$L \$F.\$A &&"
430                        && $test_line2 == "//    ((! sh -c ./\$A.out) >/dev/null 2>&1 || echo BUG: should fail)") } {
431             go-execute-xfail $test
432         } elseif { [string match "// errchk \$G \$F.go" $test_line] \
433                     || [string match "// errchk \$G -e \$F.go" $test_line] \
434                     || [string match "// errchk \$G \$D/\$F.go" $test_line] \
435                     || [string match "//errchk \$G \$D/\$F.go" $test_line] \
436                     || [string match "// errchk \$G -e \$D/\$F.go" \
437                             $test_line] \
438                     || [string match "// ! errchk \$G \$D/\$F.go" $test_line] \
439                     || [string match "// ! errchk \$G -e \$D/\$F.go" \
440                             $test_line] \
441                     || [string match "// errchk \$G \$F.go || true" \
442                             $test_line] \
443                     || [string match "// errchk \$G \$D/\$F.go || true" \
444                             $test_line] \
445                     || [string match "// errchk \$G -e \$D/\$F.go || true" \
446                             $test_line] \
447                     || [string match "// errchk \$G \$D/\$F.go || echo BUG*" \
448                             $test_line] } {
449             errchk $test ""
450         } elseif { [string match \
451                         "// \$G \$D/\$F.dir/bug0.go && \$G \$D/\$F.dir/bug1.go || echo BUG*" \
452                         $test_line] } {
453             set hold_runtests $runtests
454             set runtests "go-test.exp"
455             set dg-do-what-default "assemble"
456             regsub "\\.go$" $test ".dir/bug0.go" file1
457             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
458             regsub "\\.go$" $test ".dir/bug1.go" file2
459             dg-test $file2 "-O" "-w $DEFAULT_GOCFLAGS"
460             file delete "[file rootname [file tail $file1]].o"
461             set runtests $hold_runtests
462         } elseif { [string match \
463                         "// \$G \$D/\$F.dir/bug0.go && errchk \$G \$D/\$F.dir/bug1.go" \
464                         $test_line] \
465                        || [string match \
466                                "// \$G \$D/\$F.dir/p1.go && \$G \$D/\$F.dir/p2.go" \
467                                $test_line] \
468                        || [string match \
469                                "// \$G \$D/\$F.dir/b.go && \$G \$D/\$F.dir/a.go" \
470                                $test_line] \
471                        || [string match \
472                                "// \$G \$D/\$F.dir/io.go && errchk \$G -e \$D/\$F.dir/main.go" \
473                                $test_line] } {
474             if { [string match \
475                       "// \$G \$D/\$F.dir/bug0.go && errchk \$G \$D/\$F.dir/bug1.go" \
476                       $test_line] } {
477                 set name1 "bug0.go"
478                 set name2 "bug1.go"
479             } elseif { [string match \
480                             "// \$G \$D/\$F.dir/p1.go && \$G \$D/\$F.dir/p2.go" \
481                             $test_line] } {
482                 set name1 "p1.go"
483                 set name2 "p2.go"
484             } elseif { [string match \
485                             "// \$G \$D/\$F.dir/b.go && \$G \$D/\$F.dir/a.go" \
486                             $test_line] } {
487                 set name1 "b.go"
488                 set name2 "a.go"
489             } elseif { [string match \
490                             "// \$G \$D/\$F.dir/io.go && errchk \$G -e \$D/\$F.dir/main.go" \
491                             $test_line] } {
492                 set name1 "io.go"
493                 set name2 "main.go"
494             }
495             set hold_runtests $runtests
496             set runtests "go-test.exp"
497             set dg-do-what-default "assemble"
498             regsub "\\.go$" $test ".dir/$name1" file1
499             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
500             regsub "\\.go$" $test ".dir/$name2" file2
501             errchk $file2 ""
502             file delete "[file rootname [file tail $file1]].o"
503             set runtests $hold_runtests
504         } elseif { [string match \
505                         "// \$G \$D/\${F}1.go && errchk \$G \$D/\$F.go" \
506                         $test_line ] } {
507             set hold_runtests $runtests
508             set runtests "go-test.exp"
509             set dg-do-what-default "assemble"
510             regsub "\\.go$" $test "1.go" file1
511             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
512             errchk $test ""
513             file delete "[file rootname [file tail $file1]].o"
514             set runtests $hold_runtests
515         } elseif { [string match \
516                         "// \$G \$D/\$F.dir/bug0.go && (! \$G \$D/\$F.dir/bug1.go || echo BUG*" \
517                         $test_line] } {
518             set hold_runtests $runtests
519             set runtests "go-test.exp"
520             set dg-do-what-default "assemble"
521             regsub "\\.go$" $test ".dir/bug0.go" file1
522             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
523             regsub "\\.go$" $test ".dir/bug1.go" file2
524             setup_xfail "*-*-*"
525             dg-test $file2 "-O" "-w $DEFAULT_GOCFLAGS"
526             file delete "[file rootname [file tail $file1]].o"
527             set runtests $hold_runtests
528         } elseif { [string match \
529                         "// \$G \$D/\$F.dir/bug0.go && \$G \$D/\$F.dir/bug1.go && (! \$G \$D/\$F.dir/bug2.go || echo BUG*" \
530                         $test_line] } {
531             set hold_runtests $runtests
532             set runtests "go-test.exp"
533             set dg-do-what-default "assemble"
534             regsub "\\.go$" $test ".dir/bug0.go" file1
535             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
536             regsub "\\.go$" $test ".dir/bug1.go" file2
537             dg-test -keep-output $file2 "-O" "-w $DEFAULT_GOCFLAGS"
538             regsub "\\.go$" $test ".dir/bug2.go" file3
539             setup_xfail "*-*-*"
540             dg-test $file3 "-O" "-w $DEFAULT_GOCFLAGS"
541             file delete "[file rootname [file tail $file1]].o"
542             file delete "[file rootname [file tail $file2]].o"
543             set runtests $hold_runtests
544         } elseif { [string match \
545                         "// \$G \$D/\$F.dir/bug0.go && \$G \$D/\$F.dir/bug1.go && errchk \$G \$D/\$F.dir/bug2.go" \
546                         $test_line] } {
547             set hold_runtests $runtests
548             set runtests "go-test.exp"
549             set dg-do-what-default "assemble"
550             regsub "\\.go$" $test ".dir/bug0.go" file1
551             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
552             regsub "\\.go$" $test ".dir/bug1.go" file2
553             dg-test -keep-output $file2 "-O" "-w $DEFAULT_GOCFLAGS"
554             regsub "\\.go$" $test ".dir/bug2.go" file3
555             errchk $file3 ""
556             file delete "[file rootname [file tail $file1]].o"
557             file delete "[file rootname [file tail $file2]].o"
558             set runtests $hold_runtests
559         } elseif { [string match \
560                         "// \$G \$D/bug160.dir/x.go && \$G \$D/bug160.dir/y.go && \$L y.\$A && ./\$A.out" \
561                         $test_line] \
562                        || [string match \
563                                "// \$G \$D/\$F.dir/p.go && \$G \$D/\$F.dir/main.go && \$L main.\$A && ./\$A.out" \
564                                $test_line] } {
565             if { [string match \
566                         "// \$G \$D/bug160.dir/x.go && \$G \$D/bug160.dir/y.go && \$L y.\$A && ./\$A.out" \
567                       $test_line] } {
568                 set name1 "x.go"
569                 set name2 "y.go"
570             } elseif { [string match \
571                            "// \$G \$D/\$F.dir/p.go && \$G \$D/\$F.dir/main.go && \$L main.\$A && ./\$A.out" \
572                             $test_line] } {
573                 set name1 "p.go"
574                 set name2 "main.go"
575             }
576             set hold_runtests $runtests
577             set runtests "go-test.exp"
578             set dg-do-what-default "assemble"
579             regsub "\\.go$" $test ".dir/$name1" file1
580             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
581             set ofile1 "[file rootname [file tail $file1]].o"
582             regsub "\\.go$" $test ".dir/$name2" file2
583             dg-test -keep-output $file2 "-O" "-w $DEFAULT_GOCFLAGS"
584             set ofile2 "[file rootname [file tail $file2]].o"
585             set dg-do-what-default "link"
586             set output_file "./[file rootname [file tail $test]].exe"
587             set comp_output [go_target_compile "$ofile1 $ofile2" \
588                                  $output_file "executable" "$DEFAULT_GOCFLAGS"]
589             set comp_output [go-dg-prune $target_triplet $comp_output]
590             verbose -log $comp_output
591             set result [go_load "$output_file" "" ""]
592             set status [lindex $result 0]
593             $status $name
594             file delete $ofile1 $ofile2 $output_file
595             set runtests $hold_runtests
596         } elseif { [string match \
597                         "// \$G \$D/bug191.dir/a.go && \$G \$D/bug191.dir/b.go && \$G \$D/\$F.go && \$L \$F.\$A" \
598                         $test_line] } {
599             set hold_runtests $runtests
600             set runtests "go-test.exp"
601             set dg-do-what-default "assemble"
602             regsub "\\.go$" $test ".dir/a.go" file1
603             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
604             set ofile1 "[file rootname [file tail $file1]].o"
605             regsub "\\.go$" $test ".dir/b.go" file2
606             dg-test -keep-output $file2 "-O" "-w $DEFAULT_GOCFLAGS"
607             set ofile2 "[file rootname [file tail $file2]].o"
608             dg-test -keep-output "$test" "-O" "-w $DEFAULT_GOCFLAGS"
609             set ofile3 "[file rootname [file tail $test]].o"
610             set dg-do-what-default "link"
611             set output_file "./[file rootname [file tail $test]].exe"
612             set comp_output [go_target_compile "$ofile1 $ofile2 $ofile3" \
613                                  $output_file "executable" "$DEFAULT_GOCFLAGS"]
614             set comp_output [go-dg-prune $target_triplet $comp_output]
615             if [string match "" $comp_output] {
616                 pass $name
617             } else {
618                 verbose -log $comp_output
619                 fail $name
620             }
621             file delete $ofile1 $ofile2 $ofile3 $output_file
622             set runtests $hold_runtests
623         } elseif { [string match \
624                         "// \$G \$D/embed0.go && \$G \$D/\$F.go && \$L \$F.\$A && ./\$A.out" \
625                         $test_line ] } {
626             set hold_runtests $runtests
627             set runtests "go-test.exp"
628             set dg-do-what-default "assemble"
629             regsub "/\[^/\]*$" $test "/embed0.go" file1
630             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
631             set ofile1 "[file rootname [file tail $file1]].o"
632             dg-test -keep-output $test "-O" "-w $DEFAULT_GOCFLAGS"
633             set ofile2 "[file rootname [file tail $test]].o"
634             set output_file "./[file rootname [file tail $test]].exe"
635             set comp_output [go_target_compile "$ofile1 $ofile2" \
636                                  $output_file "executable" "$DEFAULT_GOCFLAGS"]
637             set comp_output [go-dg-prune $target_triplet $comp_output]
638             if [string match "" $comp_output] {
639                 set result [go_load "$output_file" "" ""]
640                 set status [lindex $result 0]
641                 $status $name
642             } else {
643                 verbose -log $comp_output
644                 fail $name
645             }
646             file delete $ofile1 $ofile2 $output_file
647             set runtests $hold_runtests
648         } elseif { [string match \
649                         "// \$G \$D/\$F.dir/lib.go && \$G \$D/\$F.dir/main.go && \$L main.\$A && ./\$A.out || echo BUG*" \
650                         $test_line ] } {
651             set hold_runtests $runtests
652             set runtests "go-test.exp"
653             set dg-do-what-default "assemble"
654             regsub "\\.go$" $test ".dir/lib.go" file1
655             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
656             set ofile1 "[file rootname [file tail $file1]].o"
657             regsub "\\.go$" $test ".dir/main.go" file2
658             dg-test -keep-output $file2 "-O" "-w $DEFAULT_GOCFLAGS"
659             set ofile2 "[file rootname [file tail $file2]].o"
660             set dg-do-what-default "link"
661             set output_file "./[file rootname [file tail $file2]].exe"
662             set comp_output [go_target_compile "$ofile1 $ofile2" \
663                                  $output_file "executable" "$DEFAULT_GOCFLAGS"]
664             set comp_output [go-dg-prune $target_triplet $comp_output]
665             if [string match "" $comp_output] {
666                 set result [go_load "$output_file" "" ""]
667                 set status [lindex $result 0]
668                 $status $name
669             } else {
670                 verbose -log $comp_output
671                 fail $name
672             }
673             file delete $ofile1 $ofile2 $output_file
674             set runtests $hold_runtests
675         } elseif { [string match \
676                         "// \$G \$D/\$F.dir/chanbug.go && \$G -I. \$D/\$F.dir/chanbug2.go" \
677                         $test_line] } {
678             set hold_runtests $runtests
679             set runtests "go-test.exp"
680             set dg-do-what-default "assemble"
681             regsub "\\.go$" $test ".dir/chanbug.go" file1
682             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
683             regsub "\\.go$" $test ".dir/chanbug2.go" file2
684             dg-test $file2 "-O" "-w $DEFAULT_GOCFLAGS"
685             file delete "[file rootname [file tail $file1]].o"
686             set runtests $hold_runtests
687         } elseif { [string match \
688                         "// (! \$G \$D/\$F.go) | grep 'initialization loop' *" \
689                         $test_line] } {
690             set dg-do-what-default "assemble"
691             setup_xfail "*-*-*"
692             go-dg-runtest $test "-w $DEFAULT_GOCFLAGS"
693         } elseif { [string match \
694                         "// \$G \$D/\$F.dir/x.go && errchk \$G \$D/\$F.dir/y.go" \
695                         $test_line] } {
696             set hold_runtests $runtests
697             set runtests "go-test.exp"
698             set dg-do-what-default "assemble"
699             regsub "\\.go$" $test ".dir/x.go" file1
700             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
701             regsub "\\.go$" $test ".dir/y.go" file2
702             errchk $file2 ""
703             file delete "[file rootname [file tail $file1]].o"
704             set runtests $hold_runtests
705         } elseif { [string match "// true*" $test_line] } {
706             # Not a real test, just ignore.
707         } elseif { $test_line == "// \$G \$D/\$F.dir/bug0.go &&" \
708                        && $test_line2 == "// \$G \$D/\$F.dir/bug1.go &&" \
709                        && $test_line3 == "// \$G \$D/\$F.dir/bug2.go &&" \
710                        && $test_line4 == "// errchk \$G -e \$D/\$F.dir/bug3.go &&" \
711                        && $test_line5 == "// \$L bug2.\$A &&" \
712                        && [string match "// ./\$A.out || echo BUG*" $test_line6] } {
713             set hold_runtests $runtests
714             set runtests "go-test.exp"
715             set dg-do-what-default "assemble"
716             regsub "\\.go$" $test ".dir/bug0.go" file0
717             dg-test -keep-output $file0 "-O -fgo-prefix=bug0" "-w $DEFAULT_GOCFLAGS"
718             set ofile0 "[file rootname [file tail $file0]].o"
719             regsub "\\.go$" $test ".dir/bug1.go" file1
720             dg-test -keep-output $file1 "-O -fgo-prefix=bug1" "-w $DEFAULT_GOCFLAGS"
721             set ofile1 "[file rootname [file tail $file1]].o"
722             regsub "\\.go$" $test ".dir/bug2.go" file2
723             dg-test -keep-output $file2 "-O" "-w $DEFAULT_GOCFLAGS"
724             set ofile2 "[file rootname [file tail $file2]].o"
725             regsub "\\.go$" $test ".dir/bug3.go" file3
726             errchk $file3 ""
727             set output_file "./[file rootname [file tail $test]].exe"
728             set comp_output [go_target_compile "$ofile0 $ofile1 $ofile2" \
729                                  $output_file "executable" "$DEFAULT_GOCFLAGS"]
730             set comp-output [go-dg-prune $target_triplet $comp_output]
731             if [string match "" $comp_output] {
732                 set result [go_load "$output_file" "" ""]
733                 set status [lindex $result 0]
734                 $status $name
735             } else {
736                 verbose -log $comp_output
737                 fail $name
738             }
739             file delete $ofile0 $ofile1 $ofile2 $output_file
740             set runtests $hold_runtests
741         } elseif { $test_line == "// \$G \$D/import2.go && \$G \$D/\$F\.go" } {
742             set hold_runtests $runtests
743             set runtests "go-test.exp"
744             set dg-do-what-default "assemble"
745             regsub "/\[^/\]*$" $test "/import2.go" file1
746             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
747             set ofile1 "[file rootname [file tail $file1]].o"
748             dg-test $test "-O" "-w $DEFAULT_GOCFLAGS"
749             file delete $ofile1
750             set runtests $hold_runtests
751         } elseif { $test_line == "// \$G \$D/ddd2.go && \$G \$D/\$F.go && \$L \$F.\$A && ./\$A.out" } {
752             set hold_runtests $runtests
753             set runtests "go-test.exp"
754             set dg-do-what-default "assemble"
755             regsub "/\[^/\]*$" $test "/ddd2.go" file1
756             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
757             set ofile1 "[file rootname [file tail $file1]].o"
758             dg-test -keep-output $test "-O" "-w $DEFAULT_GOCFLAGS"
759             set ofile2 "[file rootname [file tail $test]].o"
760             set output_file "./[file rootname [file tail $test]].exe"
761             set comp_output [go_target_compile "$ofile1 $ofile2" \
762                                  $output_file "executable" "$DEFAULT_GOCFLAGS"]
763             set comp_output [go-dg-prune $target_triplet $comp_output]
764             if [string match "" $comp_output] {
765                 set result [go_load "$output_file" "" ""]
766                 set status [lindex $result 0]
767                 $status $name
768             } else {
769                 verbose -log $comp_output
770                 fail $name
771             }
772             file delete $ofile1 $ofile2 $output_file
773             set runtests $hold_runtests
774         } elseif { $test_line == "// \$G \$D/\$F.go \$D/cmplxdivide1.go && \$L \$D/\$F.\$A && ./\$A.out" } {
775             regsub "/\[^/\]*$" $test "/cmplxdivide1.go" test2
776             set output_file "./[file rootname [file tail $test]].o"
777             set comp_output [go_target_compile "$test $test2" \
778                              $output_file "executable" "$DEFAULT_GOCFLAGS"]
779             set comp_output [go-dg-prune $target_triplet $comp_output]
780             if [string match "" $comp_output] {
781                 set result [go_load "$output_file" "" ""]
782                 set status [lindex $result 0]
783                 $status $name
784             } else {
785                 verbose -log $comp_output
786                 fail $name
787             }
788             file delete $output_file
789         } elseif { $test_line == "// \$G \$D/\$F.go && \$L \$F.\$A &&" \
790                        && $test_line2 == "// ./\$A.out -pass 0 >tmp.go && \$G tmp.go && \$L -o \$A.out1 tmp.\$A && ./\$A.out1 &&" \
791                        && $test_line3 == "// ./\$A.out -pass 1 >tmp.go && errchk \$G -e tmp.go &&" \
792                        && $test_line4 == "// ./\$A.out -pass 2 >tmp.go && errchk \$G -e tmp.go" } {
793             set go_execute_args ""
794             set hold_runtests $runtests
795             set runtests "go-test.exp"
796             set dg-do-what-default "link"
797             dg-test -keep-output $test "-O" "-w $DEFAULT_GOCFLAGS"
798             set output_file "./[file rootname [file tail $test]].exe"
799             if [isnative] {
800                 if { [catch "exec $output_file -pass 0 >tmp.go"] != 0 } {
801                     fail "$name execution 0"
802                 } else {
803                     pass "$name execution 0"
804                     file delete tmp.x
805                     go-torture-execute "./tmp.go"
806                 }
807                 if { [catch "exec $output_file -pass 1 >tmp.go"] != 0 } {
808                     fail "$name execution 1"
809                 } else {
810                     pass "$name execution 1"
811                     errchk tmp.go ""
812                 }
813                 if { [catch "exec $output_file -pass 2 >tmp.go"] != 0 } {
814                     fail "$name execution 2"
815                 } else {
816                     pass "$name execution 2"
817                     errchk tmp.go ""
818                 }
819                 file delete tmp.go
820             }
821             file delete $output_file
822             set runtests $hold_runtests
823         } elseif { $test_line == "// \$G \$D/\$F.go && \$L \$F.\$A && ./\$A.out >tmp.go &&" \
824                         && $test_line2 == "// errchk \$G -e tmp.go" } {
825             set go_execute_args ""
826             set hold_runtests $runtests
827             set runtests "go-test.exp"
828             set dg-do-what-default "link"
829             dg-test -keep-output $test "-O" "-w $DEFAULT_GOCFLAGS"
830             set output_file "./[file rootname [file tail $test]].exe"
831             if [isnative] {
832                 if { [catch "exec $output_file >tmp.go"] != 0 } {
833                     fail "$name execution"
834                 } else {
835                     pass "$name execution"
836                     file delete tmp.x
837                     errchk tmp.go ""
838                 }
839             }
840             file delete $output_file
841             set runtests $hold_runtests
842         } elseif { [string match \
843                         "// \$G \$D/\$F.dir/p.go && \$G \$D/\$F.dir/main.go && \$L main.\$A && ! ./\$A.out || echo BUG*" \
844                         $test_line] } {
845             set hold_runtests $runtests
846             set runtests "go-test.exp"
847             set dg-do-what-default "assemble"
848             regsub "\\.go$" $test ".dir/p.go" file1
849             dg-test -keep-output $file1 "-O" "-w $DEFAULT_GOCFLAGS"
850             set ofile1 "[file rootname [file tail $file1]].o"
851             regsub "\\.go$" $test ".dir/main.go" file2
852             dg-test -keep-output $file2 "-O" "-w $DEFAULT_GOCFLAGS"
853             set ofile2 "[file rootname [file tail $file2]].o"
854             set output_file "./[file rootname [file tail $test]].exe"
855             set comp_output [go_target_compile "$ofile1 $ofile2" \
856                                  $output_file "executable" "$DEFAULT_GOCFLAGS"]
857             set comp_output [go-dg-prune $target_triplet $comp_output]
858             if [string match "" $comp_output] {
859                 setup_xfail "*-*-*"
860                 set result [go_load "$output_file" "" ""]
861                 set status [lindex $result 0]
862                 $status $name
863             } else {
864                 verbose -log $comp_output
865                 fail $name
866             }
867             file delete $ofile1 $ofile2 $output_file
868             set runtests $hold_runtests
869         } elseif { $test_line == "// \$G \$D/\$F.go && \$L \$F.\$A && ./\$A.out >tmp.go &&"
870                    && $test_line2 == "// \$G tmp.go && \$L tmp.\$A && ./\$A.out || echo BUG: select5" } {
871             set go_execute_args ""
872             set hold_runtests $runtests
873             set runtests "go-test.exp"
874             set dg-do-what-default "link"
875             dg-test -keep-output $test "-O" "-w $DEFAULT_GOCFLAGS"
876             set output_file "./[file rootname [file tail $test]].exe"
877             set base "[file rootname [file tail $test]]"
878             if [isnative] {
879                 if { [catch "exec $output_file > $base-out.go"] != 0 } {
880                     fail "$name execution"
881                 } else {
882                     pass "$name execution"
883                     file delete $base-out.x
884                     go-torture-execute "./$base-out.go"
885                 }
886                 # file delete $base-out.go
887             }
888             file delete $output_file
889             set runtests $hold_runtests
890         } elseif { $test_line == "// errchk \$G -e \$D/\$F.dir/\[ab\].go" } {
891             regsub "\\.go$" $test ".dir/a.go" file1
892             regsub "\\.go$" $test ".dir/b.go" file2
893             errchk "$file1" "$file2"
894         } elseif { $test_line == "// # generated by cmplxdivide.c" } {
895             # Ignore.
896         } elseif { $test_line == "// \$G \$D/bug302.dir/p.go && gopack grc pp.a p.\$A && \$G \$D/bug302.dir/main.go" \
897                    || $test_line == "// \$G \$D/empty.go && errchk \$G \$D/\$F.go" } {
898             # These tests import the same package under two different
899             # names, which gccgo does not support.
900         } elseif { $test_line == "// \$G -S \$D/\$F.go | egrep initdone >/dev/null && echo FAIL || true" } {
901             # This tests whether initializers are written out
902             # statically.  gccgo does not provide a way to test that,
903             # as an initializer will be generated for any code which
904             # has global variables which need to be registered as GC
905             # roots.
906         } else {
907             clone_output "$name: unrecognized test line: $test_line"
908             unsupported $name
909         }
910
911         set go_execute_args ""
912     }
913
914     set dg-do-what-default ${saved-dg-do-what-default}
915     set TORTURE_OPTIONS $saved_torture_options
916 }
917
918 go-gc-tests