OSDN Git Service

* libjava.loader/loader.exp (gcj_loader_test_one): Use
[pf3gnuchains/gcc-fork.git] / libjava / testsuite / lib / libjava.exp
1 # Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation
2
3 load_lib "libgloss.exp"
4
5 # GCJ_UNDER_TEST is the compiler under test.
6
7 global tmpdir
8
9 if ![info exists tmpdir] {
10     set tmpdir "/tmp"
11 }
12
13 # This is like `prune_warnings', but it also prunes away a warning
14 # from the bytecode front end that we don't care about.
15 proc libjava_prune_warnings {text} {
16     set text [prune_warnings $text]
17     set tlist [split $text \n]
18     set len [llength $tlist]
19     for {set i [expr {$len - 1}]} {$i >= 2} {incr i -1} {
20         if {[string match "*unreachable bytecode*" [lindex $tlist $i]]} {
21             # Delete this line and the previous two lines.
22             set tlist [lreplace $tlist [expr {$i - 2}] $i]
23             incr i -2
24         }
25     }
26     return [join $tlist \n]
27 }
28
29 # This is like `target_compile' but it does some surgery to work
30 # around stupid DejaGNU bugs.  In particular DejaGNU has very poor
31 # quoting, so for instance a `$' will be re-evaluated at spawn time.
32 # We don't want that.
33 proc libjava_tcompile {source destfile type options} {
34     # This strange-looking expression really does quote the `$'.
35     regsub -all -- {\$} $source {\$} source
36     regsub -all -- {\$} $destfile {\$} destfile
37     return [target_compile $source $destfile $type $options]
38 }
39
40 # Read an `xfail' file if it exists.  Returns a list of xfail tokens.
41 proc libjava_read_xfail {file} {
42     if {! [file exists $file]} {
43         return ""
44     }
45     set fd [open $file r]
46     set tokens [string trim [read $fd]]
47     close $fd
48     return $tokens
49 }
50
51 # Find a particular executable.  FIXME: this relies on DejaGnu
52 # internals.  These should probably be exposed in a better way.
53 proc libjava_find_program {prog} {
54     global tool_root_dir
55
56     set file [lookfor_file $tool_root_dir $prog]
57     if { $file == "" } {
58         set file [lookfor_file $tool_root_dir gcc/$prog];
59     }
60     if {$file == ""} {
61         set file $prog
62     }
63     return $file
64 }
65
66 # Find `jv-scan'.
67 proc find_jvscan {} {
68     return [libjava_find_program jv-scan]
69 }
70
71 # Find `gcjh'.
72 proc find_gcjh {} {
73     return [libjava_find_program gcjh]
74 }
75
76 proc find_javac {} {
77     global SUN_JAVAC GCJ_UNDER_TEST env
78     # If JDK doesn't run on your platform but some other
79     # JDK-compatible javac does, you may set SUN_JAVAC to point to it.
80     # One of the most important properties of a SUN_JAVAC is that it
81     # must create class-files even for classes that have not been
82     # specified in the command line, but that were needed to compile
83     # those that have.  For example, Pizza won't do it, but you can
84     # use `kaffe sun.tools.javac.Main', if you have Sun's classes.zip
85     # in the kaffe's default search path.
86     if {![info exists SUN_JAVAC]} {
87         if {[info exists env(SUN_JAVAC)]} {
88             set SUN_JAVAC $env(SUN_JAVAC)
89         } else {
90             set SUN_JAVAC "$GCJ_UNDER_TEST -C"
91         }
92     }
93     return $SUN_JAVAC
94 }
95
96 proc bytecompile_file { file objdir {classpath {}} } {
97     global env
98     set dirname [file dirname $file]
99
100     set javac [find_javac]
101     if {$classpath != ""} then {
102         set env(CLASSPATH) $classpath
103     }
104     set here [pwd]
105     cd $dirname
106     if {[catch {
107         set q [eval exec "$javac [list $file] -d $objdir 2>@ stdout"]
108     } msg]} then {
109         verbose "couldn't compile $file: $msg"
110         set r 0
111     } else {
112         set r 1
113     }
114     cd $here
115     return $r
116 }
117
118 set libjava_initialized 0
119
120 #
121 # Build the status wrapper library as needed.
122 #
123 proc libjava_init { args } {
124     global wrapper_file;
125     global wrap_compile_flags;
126     global libjava_initialized libjava_uses_threads
127     global GCJ_UNDER_TEST
128     global TOOL_EXECUTABLE
129     global original_ld_library_path
130     global env objdir
131     global env libgcj_jar
132     global tool_root_dir
133     global libjava_libgcc_s_path
134
135     if { $libjava_initialized == 1 } { return; }
136
137     if ![info exists GCJ_UNDER_TEST] {
138         if [info exists TOOL_EXECUTABLE] {
139             set GCJ_UNDER_TEST $TOOL_EXECUTABLE;
140         } else {
141             if [info exists env(GCJ)] {
142                 set GCJ_UNDER_TEST $env(GCJ)
143             } else {
144                 set GCJ_UNDER_TEST "[find_gcj]"
145             }
146         }
147     }
148
149     # Find the libgcj jar file.
150     set libgcj_jar [glob $objdir/../libgcj-*.jar]
151     verbose "jar file is $libgcj_jar"
152
153     # FIXME: This finds libgcj.spec for the default multilib.
154     # If thread models differ between multilibs, this has to be moved
155     # to libjava_arguments
156     set specdir [libjava_find_spec]
157
158     # The -B is so we find libgcj.spec.
159     set text [eval exec "$GCJ_UNDER_TEST -B$specdir -v 2>@ stdout"]
160     regexp -- "Thread model: (\[^\n\]+)\n" $text ignore model
161     set libjava_uses_threads [expr {! ($model == "no"
162                                        || $model == "none"
163                                        || $model == "single")}]
164
165     # Always set encoding used by gcj.
166     append GCJ_UNDER_TEST " --encoding=UTF-8"
167
168     if [info exists env(LD_LIBRARY_PATH)] {
169         set original_ld_library_path $env(LD_LIBRARY_PATH)
170     } else {
171         if [info exists env(SHLIB_PATH)] {
172             set original_ld_library_path $env(SHLIB_PATH)
173         } else {
174             set original_ld_library_path ""
175         }
176     }
177
178     set wrapper_file "";
179     set wrap_compile_flags "";
180     if [target_info exists needs_status_wrapper] {
181         set result [build_wrapper "testglue.o"];
182         if { $result != "" } {
183             set wrapper_file [lindex $result 0];
184             set wrap_compile_flags [lindex $result 1];
185         } else {
186             warning "Status wrapper failed to build."
187         }
188     }
189
190     # Finally, add the gcc build directory so that we can find the
191     # shared libgcc.  This, like much of dejagnu, is hideous.
192     set libjava_libgcc_s_path {}
193     set gccdir [lookfor_file $tool_root_dir gcc/libgcc_s.so]
194     if {$gccdir != ""} {
195         set gccdir [file dirname $gccdir]
196         lappend libjava_libgcc_s_path $gccdir
197         set compiler ${gccdir}/xgcc
198         if { [is_remote host] == 0 && [which $compiler] != 0 } {
199             foreach i "[exec $compiler --print-multi-lib]" {
200                 set mldir ""
201                 regexp -- "\[a-z0-9=/\.-\]*;" $i mldir
202                 set mldir [string trimright $mldir "\;@"]
203                 if { "$mldir" == "." } {
204                     continue
205                 }
206                 if { [llength [glob -nocomplain ${gccdir}/${mldir}/libgcc_s*.so.*]] == 1 } {
207                     lappend libjava_libgcc_s_path "${gccdir}/${mldir}"
208                 }
209             }
210         }
211     }
212
213     set libjava_initialized 1
214 }
215
216 # Find a library.  We know where libtool puts the actual libraries,
217 # and we look there.  The implementation is fairly hacky.  We can't
218 # compile with -nodefaultlibs, because that will also eliminate the
219 # system libraries we need.  In order to have gcj still work, it must
220 # find the appropriate libraries so we must add -L options for their
221 # paths.  However we can't simply use those libraries; we still need
222 # libtool for linking.
223 # Don't return the the lib${name}.la files here, since this causes the
224 # libraries to be linked twice: once as lib${name}.so and another time
225 # via gcj's implicit -l${name}.  This is both unnecessary and causes the
226 # Solaris ld to warn: attempted multiple inclusion of file.  This warning
227 # is not ignored by the dejagnu framework and cannot be disabled.
228 proc libjava_find_lib {dir name} {
229     global base_dir
230     set gp [get_multilibs]
231     foreach sub {.libs _libs} {
232         if {$gp != ""} {
233             if {[file exists $gp/$dir/$sub/lib${name}.a]} then {
234                 # Just return the `-L' option.  The library itself
235                 # will be picked up via the spec file.
236                 return "-L$gp/$dir/$sub"
237             }
238         }
239         # Just return the `-L' option.  The library itself will be
240         # picked up via the spec file.
241         set lib [findfile $base_dir/../../$dir/$sub/lib${name}.a \
242                    "-L$base_dir/../../$dir/$sub" \
243                    ""]
244         if {$lib != ""} {
245             return $lib
246         }
247     }
248     return ""
249 }
250
251 # Find libgcj.spec.  We need to use the file corresponding to the multilib
252 # under test since they might differ.  Append a trailing slash since this
253 # is used with -B.
254 proc libjava_find_spec {} {
255     global objdir
256     set gp [get_multilibs]
257
258     if {[file exists $gp/libjava/libgcj.spec]} then {
259         return "$gp/libjava/"
260     }
261     return "$objdir/../"
262 }
263
264 # Find `gij'.
265 proc libjava_find_gij {} {
266     global base_dir
267     set gp [get_multilibs]
268     if {$gp != ""} {
269         set file $gp/libjava/gij
270     } else {
271         set file $base_dir/../gij
272     }
273
274     if {[file exists $file]} {
275         return $file
276     }
277     return gij
278 }
279
280 # Remove a bunch of files.
281 proc gcj_cleanup {args} {
282     foreach file $args {
283         if {[string match *.o $file]} {
284             verbose "removing [file rootname $file].lo"
285             file delete -force [file rootname $file].lo
286         }
287         file delete -force -- $file
288         verbose "removing $file"
289     }
290     # It is simplest to do this instead of trying to figure out what
291     # bits in .libs ought to be removed.
292     catch {system "rm -rf .libs"}
293 }
294
295 # Compute arguments needed for compiler.  MODE is a libtool mode:
296 # either compile or link.
297 proc libjava_arguments {{mode compile}} {
298     global base_dir
299     global LIBJAVA
300     global LIBGC
301     global LIBQTHREADS
302     global LIBZ
303     global srcdir subdir objdir
304     global TOOL_OPTIONS
305     global GCJ_UNDER_TEST
306     global tmpdir
307     global runtests
308     global env
309     global tool_root_dir
310     global libgcj_jar
311     global libjava_libgcc_s_path
312
313     if [info exists LIBJAVA] {
314         set libjava $LIBJAVA;
315     } else {
316         set libjava [libjava_find_lib libjava gcj]
317     }
318
319     if [info exists LIBGC] {
320         set libgc $LIBGC;
321     } else {
322         set libgc [libjava_find_lib boehm-gc gcjgc]
323     }
324
325     if [info exists LIBQTHREADS] {
326         set libqthreads $LIBQTHREADS
327     } else {
328         set libqthreads [libjava_find_lib qthreads gcjcoop]
329     }
330
331     if [info exists LIBZ] {
332         set libz $LIBZ
333     } else {
334         set libz [libjava_find_lib zlib zgcj]
335     }
336
337     # FIXME: there's no way to determine whether -lpthread is
338     # required.  We should get this info from configure, or it should
339     # just be in the compiler driver.
340
341     verbose "using LIBJAVA = $libjava" 2
342     verbose "using LIBGC = $libgc" 2
343     verbose "using LIBQTHREADS = $libqthreads" 2
344     verbose "using LIBZ = $libz" 2
345     set args ""
346
347     # Basically we want to build up a colon separated path list from
348     # the value of $libjava.
349
350     set lpath {}
351     foreach dir [list $libjava $libgc $libz] {
352         foreach item [split $dir " "] {
353             switch -glob -- $item {
354                 "-L*" {
355                     lappend lpath [string range $item 2 end]
356                 }
357             }
358         }
359     }
360
361     set lpath [concat $lpath $libjava_libgcc_s_path]
362     set ld_library_path [join $lpath :]
363
364     # That's enough to make things work for the normal case.
365     # If we wanted to handle an arbitrary value of libjava,
366     # then we'd have to do a lot more work.
367
368     # Set variables the dynamic linker looks at.
369     global original_ld_library_path
370     setenv LD_LIBRARY_PATH "$ld_library_path:$original_ld_library_path"
371     setenv SHLIB_PATH "$ld_library_path:$original_ld_library_path"
372
373     verbose "LD_LIBRARY_PATH = $env(LD_LIBRARY_PATH)"
374
375     # Set the CLASSPATH environment variable
376     verbose "CLASSPATH is .:$srcdir/$subdir:$objdir:$libgcj_jar"
377     global env
378     set env(CLASSPATH) ".:$srcdir/$subdir:$objdir:$libgcj_jar"
379
380     if {$mode == "link"} {
381         global wrapper_file wrap_compile_flags;
382         lappend args "additional_flags=$wrap_compile_flags";
383         lappend args "libs=$wrapper_file";
384         lappend args "libs=$libjava";
385         lappend args "libs=$libgc";
386         lappend args "libs=$libqthreads"
387         lappend args "libs=$libz"
388         lappend args debug
389     }
390
391     if { [target_info needs_status_wrapper]!="" && [info exists gluefile] } {
392         lappend args "libs=${gluefile}"
393         lappend args "ldflags=$wrap_flags"
394     }
395
396     if [info exists TOOL_OPTIONS] {
397         lappend args "additional_flags=$TOOL_OPTIONS"
398     }
399
400     # Determine libgcj.spec corresponding to multilib under test.
401     set specdir [libjava_find_spec]
402
403     # Search for libtool.  We need it to link.
404     set found_compiler 0
405     set d [absolute $objdir]
406     foreach x {. .. ../.. ../../..} {
407         if {[file exists $d/$x/libtool]} then {
408             # We have to run silently to avoid DejaGNU lossage.
409             lappend args \
410               "compiler=$d/$x/libtool --silent --tag=GCJ --mode=$mode $GCJ_UNDER_TEST -B$specdir"
411             set found_compiler 1
412             break
413         }
414     }
415     if {! $found_compiler} {
416         # Append -B$specdir so that we find libgcj.spec before it
417         # is installed.
418         lappend args "compiler=$GCJ_UNDER_TEST -B$specdir"
419     }
420
421     # Avoid libtool wrapper scripts when possible.
422     # but not if libtool warnings results in FAILs
423     if {$mode == "link"} {
424         if {! [istarget "*-*-cygwin*"] && ! [istarget "*-*-mingw*"] } {
425             lappend args "additional_flags=-no-install"
426         }
427     }
428
429     return $args
430 }
431
432 # Link a bunch of objects into a program.  MAIN is the name of the
433 # class holding `main'.  Return 0 on failure.
434 proc gcj_link {program main files {options {}}} {
435     set arguments [libjava_arguments link]
436     if {[llength $options]} {
437         eval lappend arguments $options
438     }
439     lappend arguments "additional_flags=--main=$main"
440     set x [libjava_prune_warnings \
441              [libjava_tcompile $files $program executable $arguments]]
442     if {$x != ""} {
443         verbose "link failure: $x" 2
444         fail "linking $program"
445         setup_xfail "*-*-*"
446         fail "running $program"
447         return 0
448     }
449
450     pass "linking $program"
451     return 1
452 }
453
454 # Invoke a program and check its output.  EXECUTABLE is the program;
455 # ARGS are the arguments to the program.  Returns 1 if tests passed
456 # (or things were left untested), 0 otherwise.
457 proc libjava_invoke {errname testName optName executable inpfile resultfile args} {
458     upvar $optName opts
459
460     if {[info exists opts(no-exec)]} {
461         if {[info exists opts(need-threads)]} {
462             # This means we wanted to try to run it but we couldn't
463             # because threads aren't supported.  So we have to
464             # generate an `untested'.
465             untested "$errname execution - $testName"
466             untested "$errname output - $testName"
467         }
468         return 1
469     }
470
471     set result [libjava_load $executable $args "$inpfile"]
472     set status [lindex $result 0]
473     set output [lindex $result 1]
474     if {[info exists opts(xfail-exec)]} then {
475         setup_xfail *-*-*
476     }
477     $status "$errname execution - $testName"
478     if { $status != "pass" } {
479         untested "$errname output - $testName"
480         return 0
481     }
482
483     verbose "resultfile is $resultfile"
484     set id [open $resultfile r]
485     set expected ""
486     append expected [read $id]
487     regsub -all "\r" "$output" "" output
488     regsub "\n*$" $expected "" expected
489     regsub "\n*$" $output "" output
490     regsub "^\n*" $expected "" expected
491     regsub "^\n*" $output "" output
492     regsub -all "\[ \t\]\[ \t\]*" $expected " " expected
493     regsub -all "\[ \t\]*\n\n*" $expected "\n" expected
494     regsub -all "\[ \t\]\[ \t\]*" $output " " output
495     regsub -all "\[ \t\]*\n\n*" $output "\n" output
496     verbose "expected is $expected"
497     verbose "actual is $output"
498     set passed 0
499     if {[info exists opts(regexp_match)]} {
500         if [regexp $expected $output] {
501             set passed 1
502         }
503     } else {
504         if { $expected == $output } {
505             set passed 1
506         }
507     }
508     if {[info exists opts(xfail-output)]} {
509         setup_xfail *-*-*
510     }
511     if { $passed == 1 } {
512         pass "$errname output - $testName"
513     } else {
514         fail "$errname output - $testName"
515     }
516     close $id
517
518     return $passed
519 }
520
521 #
522 # Run the test specified by srcfile and resultfile. compile_args and
523 # exec_args are options telling this proc how to work.
524 #
525 proc test_libjava_from_source { options srcfile compile_args inpfile resultfile exec_args } {
526     global base_dir
527     global LIBJAVA
528     global LIBGC
529     global srcdir subdir objdir
530     global TOOL_OPTIONS
531     global GCJ_UNDER_TEST
532     global tmpdir
533     global runtests
534
535     # Make opts into an array.
536     set opts(_) x
537     unset opts(_)
538     foreach item $exec_args {
539         set opts($item) x
540     }
541
542     # If we need threads and we don't have them then set the `no-exec'
543     # flag.  This is case is also handled specially later.
544     if {[info exists opts(need-threads)]} {
545         global libjava_uses_threads
546         if {! $libjava_uses_threads} {
547             set opts(no-exec) x
548         }
549     }
550
551     set errname [file rootname [file tail $srcfile]]
552     if {! [runtest_file_p $runtests $errname]} {
553         return
554     }
555
556     if {[info exists opts(no-link)]} {
557         set mode compile
558     } else {
559         set mode link
560     }
561     set args [libjava_arguments $mode]
562     if {! [info exists opts(no-link)]} {
563         # Add the --main flag
564         lappend args "additional_flags=--main=[file rootname [file tail $srcfile]]"
565         if { $compile_args != "" } {
566             lappend args "additional_flags=$compile_args"
567         }
568     }
569
570     regsub "^.*/(\[^/.\]+)\[.\]\[^/]*$" "$srcfile" "\\1" out
571     set executable "${objdir}/$out"
572     if {[info exists opts(no-link)]} {
573         append executable ".o"
574         set target object
575     } else {
576         # DOS/win32 targets default to .exe if no suffix is given
577         # We then try to delete a file that doesn't exist.  It is
578         # simpler to add the suffix everywhere.
579         append executable ".exe"
580         set target executable
581     }
582     if { $compile_args != "" } {
583         set errname "$errname $compile_args"
584     }
585
586     set removeList [list $executable]
587
588     set x [libjava_prune_warnings \
589              [libjava_tcompile $srcfile "$executable" $target $args]]
590     if {[info exists opts(xfail-gcj)]} {
591         setup_xfail *-*-*
592     }
593     if { $x != "" } {
594         verbose "target_compile failed: $x" 2
595
596         if {[info exists opts(shouldfail)]} {
597             pass "$errname compilation from source"
598             eval gcj_cleanup $removeList
599             return
600         }
601
602         fail "$errname compilation from source"
603         if {[info exists opts(xfail-gcj)]
604             || ! [info exists opts(no-exec)]
605             || [info exists opts(need-threads)]} {
606             untested "$errname execution from source compiled test"
607             untested "$errname output from source compiled test"
608         }
609         return
610     }
611     if {[info exists opts(shouldfail)]} {
612         fail "$errname compilation from source"
613         return
614     }
615     pass "$errname compilation from source"
616
617     # Set up the options the way they are expected by libjava_invoke.
618     if {[info exists opts(xfail-source-output)]} {
619         set opts(xfail-output) x
620     }
621     if {[libjava_invoke $errname "source compiled test" opts $executable \
622            $inpfile $resultfile]} {
623         # Everything ok, so clean up.
624         eval gcj_cleanup $removeList
625     }
626 }
627
628 #
629 # Run the test specified by srcfile and resultfile. compile_args and
630 # exec_args are options telling this proc how to work.
631 #
632 proc test_libjava_from_javac { options srcfile compile_args inpfile resultfile exec_args } {
633     global base_dir
634     global LIBJAVA
635     global LIBGC
636     global srcdir subdir objdir
637     global TOOL_OPTIONS
638     global GCJ_UNDER_TEST
639     global tmpdir
640     global runtests
641     global INTERPRETER
642
643     # Make opts into an array.
644     set opts(_) x
645     unset opts(_)
646     foreach item $exec_args {
647         set opts($item) x
648     }
649
650     # If we need threads and we don't have them then set the `no-exec'
651     # flag.  This is case is also handled specially later.
652     if {[info exists opts(need-threads)]} {
653         global libjava_uses_threads
654         if {! $libjava_uses_threads} {
655             set opts(no-exec) x
656         }
657     }
658     set errname [file rootname [file tail $srcfile]]
659     if {! [runtest_file_p $runtests $errname]} {
660         return
661     }
662
663     # bytecompile files with Sun's compiler for now.
664     set bc_ok [bytecompile_file $srcfile $objdir]
665
666     set javac [find_javac]
667     # This is an ugly heuristic but it will have to do.
668     if {[string match *gcj* $javac]} {
669         set tag gcjC
670     } else {
671         set tag javac
672     }
673     if {[info exists opts(xfail-$tag)]} {
674         setup_xfail *-*-*
675     }
676     if {! $bc_ok} then {
677         if {[info exists opts(shouldfail)]} {
678             pass "$errname byte compilation"
679             return
680         }
681         fail "$errname byte compilation"
682         untested "$errname compilation from bytecode"
683         if {! [info exists opts(no-exec)]
684             || [info exists opts(need-threads)]} {
685             untested "$errname execution from bytecode->native test"
686             untested "$errname output from bytecode->native test"
687         }
688         return
689     }
690     if {[info exists opts(shouldfail)]} {
691         fail "$errname byte compilation"
692         return
693     }
694     pass "$errname byte compilation"
695
696     set removeList {}
697
698     # Find name to use for --main, and name of all class files.
699     set jvscan [find_jvscan]
700     verbose "jvscan is $jvscan"
701     set main_name [string trim \
702                      [libjava_prune_warnings \
703                         [lindex [local_exec "$jvscan --encoding=UTF-8 $srcfile --print-main" "" "" 300] 1]]]
704     verbose "main name is $main_name"
705     set class_out [string trim \
706                      [libjava_prune_warnings \
707                         [lindex [local_exec "$jvscan --encoding=UTF-8 $srcfile --list-class" "" "" 300] 1]]]
708     verbose "class list is $class_out"
709
710     if {[string match "*parse error*" $main_name]
711         || [string match "*parse error*" $class_out]} {
712         untested "$errname compilation from bytecode"
713         if {! [info exists opts(no-exec)]
714             || [info exists opts(need-threads)]} {
715             untested "$errname execution from bytecode->native test"
716             untested "$errname output from bytecode->native test"
717         }
718         return
719     }
720
721     # Turn "a b" into "a.class b.class".
722     # Also, turn "foo.bar" into "foo/bar.class".
723     set class_files {}
724     foreach file [split [string trim $class_out]] {
725         set file [join [split $file .] /]
726         lappend class_files $objdir/$file.class
727     }
728
729     eval lappend removeList $class_files
730
731     # Usually it is an error for a test program not to have a `main'
732     # method.  However, for no-exec tests it is ok.  Treat no-link
733     # like no-exec here.
734     if {[info exists opts(no-link)]} {
735         set opts(no-exec) x
736     }
737     set largs {}
738
739     if {[info exists opts(no-exec)]} {
740         set type object
741         set mode compile
742     } elseif {$main_name == ""} {
743         perror "No `main' given in program $errname"
744         return
745     } else {
746         set type executable
747         lappend largs "additional_flags=--main=$main_name"
748         # DOS/win32 targets default to .exe if no suffix is given
749         # We then try to delete a file that doesn't exist.  It is
750         # simpler to add the suffix everywhere.
751         set executable "${objdir}/${main_name}.exe"
752         set mode link
753     }
754
755     # We purposely ignore errors here; we still want to run the other
756     # appropriate tests.
757     set gij [libjava_find_gij]
758     # libjava_find_gij will return `gij' if it couldn't find the
759     # program; in this case we want to skip the test.
760     if {$INTERPRETER == "yes" && $gij != "gij"} {
761         libjava_invoke $errname "gij test" opts $gij \
762           $inpfile $resultfile $main_name
763     }
764
765     # Initial arguments.
766     set args [libjava_arguments $mode]
767     eval lappend args $largs
768
769     if { $compile_args != "" } {
770         lappend args "additional_flags=$compile_args"
771     }
772
773     if { $compile_args != "" } {
774         set errname "$errname $compile_args"
775     }
776
777     verbose "compilation command = $args" 2
778     # When compiling and not linking, we have to build each .o
779     # separately.  We do this because DejaGNU's target_compile won't
780     # accept an empty "destfile" argument when the mode is "compile".
781     if {$mode == "compile"} {
782         foreach c_file $class_files {
783             set executable [file rootname [file tail $c_file]].o
784             set x [libjava_prune_warnings \
785                      [libjava_tcompile $c_file "$executable" $type $args]]
786             lappend removeList $executable
787             if {$x != ""} {
788                 break
789             }
790         }
791     } else {
792         # This is so evil: we de-listify CLASS_FILES so that we can
793         # turn around and quote the `$' in it for the shell.  I really
794         # hate DejaGNU.  It is so !@#$!@# unpredictable.
795         set hack ""
796         foreach stupid $class_files {
797             set hack "$hack $stupid"
798         }
799         lappend removeList $executable
800         set x [libjava_prune_warnings \
801                  [libjava_tcompile $hack "$executable" $type $args]]
802     }
803     if {[info exists opts(xfail-byte)]} {
804         setup_xfail *-*-*
805     }
806     if { $x != "" } {
807         verbose "target_compile failed: $x" 2
808         fail "$errname compilation from bytecode"
809         if {! [info exists opts(no-exec)]
810             || [info exists opts(need-threads)]} {
811             untested "$errname execution from bytecode->native test"
812             untested "$errname output from bytecode->native test"
813         }
814         return;
815     }
816     pass "$errname compilation from bytecode"
817
818     # Set up the options the way they are expected by libjava_invoke.
819     if {[info exists opts(xfail-byte-output)]} {
820         set opts(xfail-output) x
821     }
822     if {[libjava_invoke $errname "bytecode->native test" opts $executable \
823            $inpfile $resultfile]} {
824         # Everything ok, so clean up.
825         eval gcj_cleanup $removeList
826     }
827 }
828
829 #
830 # Run the test specified by srcfile and resultfile. compile_args and
831 # exec_args are options telling this proc how to work.
832 #   `no-link'     don't try to link the program
833 #   `no-exec'     don't try to run the test
834 #   `xfail-gcj'   compilation from source will fail
835 #   `xfail-javac' compilation with javac will fail
836 #   `xfail-gcjC'  compilation with gcj -C will fail
837 #   `shouldfail'  compilation from source is supposed to fail
838 #                 This is different from xfail, which marks a known
839 #                 failure that we just haven't fixed.
840 #                 A compilation marked this way should fail with any
841 #                 front end.
842 #   `xfail-byte'  compilation from bytecode will fail
843 #   `xfail-exec'  exec will fail
844 #   `xfail-output'
845 #                 output will be wrong
846 #   `xfail-byte-output'
847 #                 output will be wrong when compiled from bytecode
848 #   `xfail-source-output'
849 #                 output will be wrong when compiled from source code
850 #   `need-threads'
851 #                 test relies on thread support
852 #
853 proc test_libjava { options srcfile compile_args inpfile resultfile exec_args } {
854     test_libjava_from_source $options $srcfile $compile_args $inpfile $resultfile $exec_args
855     test_libjava_from_javac $options $srcfile $compile_args $inpfile $resultfile $exec_args
856  }
857
858 #
859 # libjava_version -- extract and print the version number of libjavap
860 #
861 proc default_libjava_version {} {
862 }
863
864 proc default_libjava_start { } {
865 }
866
867 # On IRIX 6, we have to set variables akin to LD_LIBRARY_PATH, but
868 # called LD_LIBRARYN32_PATH (for the N32 ABI) and LD_LIBRARY64_PATH
869 # (for the 64-bit ABI).  The right way to do this would be to modify
870 # unix.exp -- but that's not an option since it's part of DejaGNU
871 # proper, so we do it here, by trickery.  We really only need to do 
872 # this on IRIX, but it shouldn't hurt to do it anywhere else.
873
874 proc ${tool}_set_ld_library_path { name element op } {
875   setenv LD_LIBRARYN32_PATH [getenv LD_LIBRARY_PATH]
876   setenv LD_LIBRARY64_PATH [getenv LD_LIBRARY_PATH]
877 }
878
879 trace variable env(LD_LIBRARY_PATH) w ${tool}_set_ld_library_path
880
881 # Local Variables:
882 # tcl-indent-level:4
883 # End: