| # Simulator dejagnu utilities. |
| # TODO: Switch to using dg-xxx helpers rather than parsing the files directly. |
| |
| # Communicate simulator path from sim_init to sim_version. |
| # For some reason [board_info target sim] doesn't work in sim_version. |
| # [Presumubly because the target has been "popped" by then. Odd though.] |
| set sim_path "unknown-run" |
| |
| # Find the simulator arch. |
| |
| proc sim_arch {} { |
| global subdir |
| set arch "$subdir" |
| while { [file dirname $arch] != "." } { |
| set arch [file dirname $arch] |
| } |
| return "$arch" |
| } |
| |
| # Initialize the testrun. |
| # |
| # Normally dejagnu will execute ${tool}_init automatically, but since we set |
| # --tool '' (for a simpler testsuite/ layout), we have each test call this |
| # itself. |
| |
| proc sim_init { args } { |
| global builddir |
| global subdir |
| global sim_path |
| |
| # Find the path to the simulator for executing. |
| set sim_path "$builddir/[sim_arch]/run" |
| |
| # As gross as it is, we unset the linker script specified by the target |
| # board. The simulator board file mips-sim.exp, sets ldscript to the |
| # MIPS libgloss linker scripts which include libgcc (and possibly other |
| # libraries), which the linker (used to link these tests rather than the |
| # compiler) can't necessarily find. Similarly iq2000-sim.exp and |
| # m68hc11-sim.exp. So, we make it a common rule to clear the slate for |
| # all simulators. |
| unset_currtarget_info ldscript |
| |
| sim_init_toolchain |
| |
| # Need to return an empty string. This tells dejagnu to *not* re-run us |
| # with the exact test that we're about to run. |
| return "" |
| } |
| |
| # Initialize the toolchain settings for this port. |
| # Needs to be called once per-port. |
| |
| proc sim_init_toolchain {} { |
| global objdir |
| global srcdir |
| global cpu_option |
| global cpu_option_sep |
| global ASFLAGS_FOR_TARGET |
| global CFLAGS_FOR_TARGET |
| global LDFLAGS_FOR_TARGET |
| global SIMFLAGS_FOR_TARGET |
| global global_as_works |
| global global_cpp_works |
| global global_cc_works |
| global global_cc_os |
| global CFLAGS_FOR_TARGET_init |
| |
| # Reset all the toolchain settings. This provides a clean slate when |
| # starting the next set of tests. |
| set ASFLAGS_FOR_TARGET "" |
| set CFLAGS_FOR_TARGET "" |
| set LDFLAGS_FOR_TARGET "" |
| set SIMFLAGS_FOR_TARGET "" |
| unset -nocomplain cpu_option cpu_option_sep |
| |
| # The configure script created XXX_FOR_TARGET_$ARCH for us, so merge those |
| # into plain XXX_FOR_TARGET for this particular arch run. |
| global SIM_PRIMARY_TARGET |
| set arch [sim_arch] |
| set ARCH [string map {- _} [string toupper $arch]] |
| foreach var {AS LD CC} { |
| set var_for_target "${var}_FOR_TARGET" |
| global $var_for_target |
| set var_for_target_arch "${var_for_target}_${ARCH}" |
| global $var_for_target_arch |
| |
| if [info exists $var_for_target_arch] { |
| set $var_for_target [set $var_for_target_arch] |
| } else { |
| set $var_for_target "" |
| } |
| |
| if { [set $var_for_target] == "" } { |
| # If building for the primary target, use the default settings. |
| if { $arch == $SIM_PRIMARY_TARGET } { |
| unset -nocomplain $var_for_target |
| } { |
| set $var_for_target false |
| } |
| } |
| } |
| |
| # See if an assembler is available. |
| if { $arch != $SIM_PRIMARY_TARGET && $AS_FOR_TARGET == "false" } { |
| verbose -log "Can't find a compatible assembler" |
| set global_as_works 0 |
| } { |
| verbose -log "Found a compatible assembler" |
| set global_as_works 1 |
| } |
| |
| # Merge per-test settings if available. |
| if ![info exists CFLAGS_FOR_TARGET_init] { |
| set CFLAGS_FOR_TARGET_init "" |
| } |
| set cc_options [list "additional_flags=$CFLAGS_FOR_TARGET_init"] |
| |
| # See if we have a preprocessor available. |
| set result [target_compile $srcdir/lib/compilercheck.c \ |
| $objdir/compilercheck.x "preprocess" $cc_options] |
| set global_cpp_works [string equal "" "$result"] |
| |
| # See if we have a compiler available, and which environment it's targeting. |
| set global_cc_os "" |
| set global_cc_works 0 |
| if { $arch != $SIM_PRIMARY_TARGET && $CC_FOR_TARGET == "false" } { |
| verbose -log "Can't find a compatible C compiler" |
| } elseif { [target_compile $srcdir/lib/newlibcheck.c \ |
| $objdir/compilercheck.x "executable" $cc_options] == "" } { |
| verbose -log "Found newlib C compiler" |
| set global_cc_works 1 |
| set global_cc_os "newlib" |
| } elseif { [target_compile $srcdir/lib/linuxcheck.c \ |
| $objdir/compilercheck.x "executable" $cc_options] == "" } { |
| verbose -log "Found Linux C compiler" |
| set global_cc_works 1 |
| set global_cc_os "linux" |
| } elseif { [target_compile $srcdir/lib/compilercheck.c \ |
| $objdir/compilercheck.x "executable" $cc_options] == "" } { |
| verbose -log "Found C compiler, but unknown OS" |
| set global_cc_works 1 |
| } { |
| verbose -log "Can't execute C compiler" |
| } |
| |
| file delete $objdir/compilercheck.x |
| |
| unset CFLAGS_FOR_TARGET_init |
| } |
| |
| # Print the version of the simulator being tested. |
| # Required by dejagnu. |
| |
| proc sim_version {} { |
| global sim_path |
| set version 0.5 |
| clone_output "$sim_path $version\n" |
| } |
| |
| # Run a program on the simulator. |
| # Required by dejagnu (at least ${tool}_run used to be). |
| # |
| # SIM_OPTS are options for the simulator. |
| # PROG_OPTS are options passed to the simulated program. |
| # At present REDIR must be "" or "> foo". |
| # OPTIONS is a list of options internal to this routine. |
| # This is modelled after target_compile. We want to be able to add new |
| # options without having to update all our users. |
| # Currently: |
| # env(foo)=val - set environment variable foo to val for this run |
| # timeout=val - set the timeout to val for this run |
| # |
| # The result is a list of two elements. |
| # The first is the program's exit status (0/1/etc...). |
| # The second is the program's output. |
| # |
| # This is different than the sim_load routine provided by |
| # dejagnu/config/sim.exp. It's not clear how to pass arguments to the |
| # simulator (not the simulated program, the simulator) with sim_load. |
| |
| proc sim_run { prog sim_opts prog_opts redir options } { |
| global sim_path |
| |
| # Set the default value of the timeout. |
| # FIXME: The timeout value we actually want is a function of |
| # host, target, and testcase. |
| set testcase_timeout [board_info target sim_time_limit] |
| if { "$testcase_timeout" == "" } { |
| set testcase_timeout [board_info host testcase_timeout] |
| } |
| if { "$testcase_timeout" == "" } { |
| set testcase_timeout 240 ;# 240 same as in dejagnu/config/sim.exp. |
| } |
| |
| # Initial the environment we pass to the testcase. |
| set testcase_env "" |
| |
| # Process OPTIONS ... |
| foreach o $options { |
| if [regexp {^env\((.*)\)=(.*)} $o full var val] { |
| set testcase_env "$testcase_env $var=$val" |
| } elseif [regexp {^timeout=(.*)} $o full val] { |
| set testcase_timeout $val |
| } |
| |
| } |
| |
| verbose "testcase timeout is set to $testcase_timeout" 1 |
| |
| set sim $sim_path |
| |
| if [is_remote host] { |
| set prog [remote_download host $prog] |
| if { $prog == "" } { |
| error "download failed" |
| return -1 |
| } |
| } |
| |
| set board [target_info name] |
| if [board_info $board exists sim,options] { |
| set always_opts [board_info $board sim,options] |
| } else { |
| set always_opts "" |
| } |
| |
| # FIXME: this works for UNIX only |
| if { "$testcase_env" != "" } { |
| set sim "env $testcase_env $sim" |
| } |
| |
| if { [board_info target sim,protocol] == "sid" } { |
| set cmd "" |
| set sim_opts "$sim_opts -e \"set cpu-loader file [list ${prog}]\"" |
| } else { |
| set cmd "$prog" |
| } |
| |
| send_log "$sim $always_opts $sim_opts $cmd $prog_opts\n" |
| |
| if { "$redir" == "" } { |
| remote_spawn host "$sim $always_opts $sim_opts $cmd $prog_opts" |
| } else { |
| remote_spawn host "$sim $always_opts $sim_opts $cmd $prog_opts $redir" writeonly |
| } |
| set result [remote_wait host $testcase_timeout] |
| |
| set return_code [lindex $result 0] |
| set output [lindex $result 1] |
| # Remove the \r part of "\r\n" so we don't break all the patterns |
| # we want to match. |
| regsub -all -- "\r" $output "" output |
| |
| if [is_remote host] { |
| # clean up after ourselves. |
| remote_file host delete $prog |
| } |
| |
| return [list $return_code $output] |
| } |
| |
| # Support function for "#requires: simoption <xx>": |
| # Looks in "run --help" output for <xx>, returns 1 iff <xx> is mentioned |
| # there and looks like an option name, otherwise 0. |
| |
| proc sim_check_requires_simoption { optname } { |
| global sim_path |
| set testrun "$sim_path --help" |
| verbose -log "Checking for simoption `$optname'" 3 |
| remote_spawn host $testrun |
| set result [remote_wait host 240] |
| |
| set return_code [lindex $result 0] |
| if { $return_code != 0 } { |
| perror "Can't execute `$testrun' to check for `$optname'" |
| return 0 |
| } |
| |
| set output [lindex $result 1] |
| # Remove \r as for regular runs. |
| regsub -all -- "\r" $output "" output |
| |
| # The option output format for --help for each line where an |
| # option name is mentioned, is assumed to be two space followed |
| # by the option name followed by a space or left square bracket, |
| # like in (optname=--foo): " --foo " or " --foo[this|that]". |
| # Beware not to match " --foo-bar" nor " --foobar". |
| if [string match "*\n $optname\[\[ \]*" $output] { |
| verbose -log "Found `$optname'" 3 |
| return 1 |
| } |
| verbose -log "Did not find `$optname'" 3 |
| |
| return 0 |
| } |
| |
| # Run testcase NAME. |
| # NAME is either a fully specified file name, or just the file name in which |
| # case $srcdir/$subdir will be prepended. |
| # REQUESTED_MACHS is a list of machines to run the testcase on. If NAME isn't |
| # for the specified machine(s), it is ignored. |
| # Typically REQUESTED_MACHS contains just one element, it is up to the caller |
| # to iterate over the desired machine variants. |
| # |
| # The file can contain options in the form "# option(mach list): value". |
| # Possibilities: |
| # mach: [all | machine names] |
| # as[(mach-list)]: <assembler options> |
| # ld[(mach-list)]: <linker options> |
| # cc[(mach-list)]: <compiler options> |
| # sim[(mach-list)]: <simulator options> |
| # progopts: <arguments to the program being simulated> |
| # progos: OS required for the test |
| # status: program exit status to treat as "pass" |
| # output: program output pattern to match with string-match |
| # xerror: program is expected to return with a "failure" exit code |
| # xfail: <PRMS-opt> <target-triplets-where-test-fails> |
| # kfail: <PRMS> <target-triplets-where-test-fails> |
| # If `output' is not specified, the program must output "pass" if !xerror or |
| # "fail" if xerror. |
| # The parens in "optname()" are optional if the specification is for all machs. |
| # Multiple "output", "xfail" and "kfail" options concatenate. |
| # The xfail and kfail arguments are space-separated target triplets and PRIDs. |
| # There must be a PRMS (bug report ID) specified for kfail, while it's |
| # optional for xfail. |
| |
| proc run_sim_test { name requested_machs } { |
| global subdir srcdir objdir |
| global sim_path |
| global opts |
| global cpu_option |
| global cpu_option_sep |
| global SIMFLAGS_FOR_TARGET |
| global global_as_works |
| global global_cpp_works |
| global global_cc_works |
| global global_cc_os |
| |
| if ![file exists $sim_path] { |
| unsupported "$name: missing simulator $sim_path" |
| return |
| } |
| |
| if [string match "*/*" $name] { |
| set file $name |
| set name [file tail $name] |
| } else { |
| set file "$srcdir/$subdir/$name" |
| } |
| |
| set opt_array [slurp_options "${file}"] |
| if { $opt_array == -1 } { |
| unresolved $subdir/$name |
| return |
| } |
| # Clear default options |
| set opts(as) "" |
| set opts(ld) "" |
| set opts(cc) "" |
| set opts(progopts) "" |
| set opts(progos) "" |
| set opts(requires) {} |
| set opts(sim) "" |
| set opts(status) "0" |
| set opts(output) "" |
| set opts(mach) "" |
| set opts(timeout) "" |
| set opts(xerror) "no" |
| set opts(xfail) "" |
| set opts(kfail) "" |
| set seen_output 0 |
| |
| if ![info exists SIMFLAGS_FOR_TARGET] { |
| set SIMFLAGS_FOR_TARGET "" |
| } |
| |
| # Clear any machine specific options specified in a previous test case |
| foreach m $requested_machs { |
| if [info exists opts(as,$m)] { |
| unset opts(as,$m) |
| } |
| if [info exists opts(ld,$m)] { |
| unset opts(ld,$m) |
| } |
| if [info exists opts(cc,$m)] { |
| unset opts(cc,$m) |
| } |
| if [info exists opts(sim,$m)] { |
| unset opts(sim,$m) |
| } |
| } |
| |
| foreach i $opt_array { |
| set opt_name [lindex $i 0] |
| set opt_machs [lindex $i 1] |
| set opt_val [lindex $i 2] |
| if ![info exists opts($opt_name)] { |
| perror "unknown option $opt_name in file $file" |
| unresolved $subdir/$name |
| return |
| } |
| # Multiple "output" specifications concatenate, they don't override. |
| if { $opt_name == "output" } { |
| set opt_val "$opts(output)$opt_val" |
| set seen_output 1 |
| } |
| # Similar with "xfail" and "kfail", but arguments are space-separated. |
| if { $opt_name == "xfail" || $opt_name == "kfail" } { |
| set opt_val "$opts($opt_name) $opt_val" |
| } |
| |
| # Similar for "requires", except we append a pair to a list, and |
| # that doesn't match the processing in the rest of the loop, so we |
| # "continue" early. |
| if { $opt_name == "requires" } { |
| lappend opts($opt_name) [split $opt_val " "] |
| continue |
| } |
| |
| foreach m $opt_machs { |
| set opts($opt_name,$m) $opt_val |
| } |
| if { "$opt_machs" == "" } { |
| set opts($opt_name) $opt_val |
| } |
| } |
| |
| if { $opts(progos) != "" && $opts(progos) != $global_cc_os } { |
| untested $subdir/$name |
| return |
| } |
| |
| set testname $name |
| set sourcefile $file |
| if { $seen_output == 0 } { |
| if { "$opts(xerror)" == "no" } { |
| set opts(output) "pass\n" |
| } else { |
| set opts(output) "fail\n" |
| } |
| } |
| # Change \n sequences to newline chars. |
| regsub -all "\\\\n" $opts(output) "\n" opts(output) |
| |
| set testcase_machs $opts(mach) |
| if { "$testcase_machs" == "all" } { |
| set testcase_machs $requested_machs |
| } |
| |
| foreach mach $testcase_machs { |
| if { [lsearch $requested_machs $mach] < 0 } { |
| verbose -log "Skipping $mach version of $name, not requested." |
| continue |
| } |
| |
| verbose -log "Testing $name on machine $mach." |
| |
| # Time to setup xfailures and kfailures. |
| if { "$opts(xfail)" != "" } { |
| verbose -log "xfail: $opts(xfail)" |
| # Using eval to make $opts(xfail) appear as individual |
| # arguments. |
| eval setup_xfail $opts(xfail) |
| } |
| if { "$opts(kfail)" != "" } { |
| verbose -log "kfail: $opts(kfail)" |
| eval setup_kfail $opts(kfail) |
| } |
| |
| if ![info exists opts(as,$mach)] { |
| set opts(as,$mach) $opts(as) |
| } |
| |
| set as_options "$opts(as,$mach) -I$srcdir/$subdir" |
| if [info exists cpu_option] { |
| if ![info exists cpu_option_sep] { |
| set sep "=" |
| } { |
| set sep $cpu_option_sep |
| } |
| set as_options "$as_options $cpu_option$sep$mach" |
| } |
| regsub {(^ *| +)([^ ]+)} "$as_options" { -Wa,\2} c_as_options |
| |
| if ![info exists opts(ld,$mach)] { |
| set opts(ld,$mach) $opts(ld) |
| } |
| regsub {(^ *| +)([^ ]+)} "$opts(ld,$mach)" { -Wl,\2} c_ld_options |
| |
| if ![info exists opts(cc,$mach)] { |
| set opts(cc,$mach) $opts(cc) |
| } |
| |
| foreach req $opts(requires) { |
| set what [lindex $req 0] |
| set what_opt [lindex $req 1] |
| verbose -log "requires: <$what> <$what_opt>" |
| if { [info procs sim_check_requires_${what}] != [list] } { |
| if ![sim_check_requires_${what} $what_opt] { |
| untested $subdir/$name |
| return |
| } |
| } { |
| perror "unknown requirement `requires: $what' in file $file" |
| unresolved $subdir/$name |
| return |
| } |
| } |
| |
| if [string match "*.c" $sourcefile] { |
| # If we don't have a compiler available, skip tests :(. |
| if { $global_cc_works == 0 } { |
| untested $subdir/$name |
| return |
| } |
| |
| set comp_output [target_compile $sourcefile $objdir/${name}.x "executable" \ |
| [list "incdir=$srcdir/$subdir" "additional_flags=$c_as_options $c_ld_options $opts(cc,$mach)"]] |
| set method "compiling/linking" |
| } else { |
| # If we don't have an assembler available, skip tests :(. |
| if { $global_as_works == 0 } { |
| untested $subdir/$name |
| return |
| } |
| |
| if [string match "*.S" $sourcefile] { |
| # If we don't have a preprocessor available, skip tests :(. |
| if { $global_cpp_works == 0 } { |
| untested $subdir/$name |
| return |
| } |
| |
| set comp_output [target_compile $sourcefile $objdir/${name}.o "object" \ |
| [list "incdir=$srcdir/$subdir" "additional_flags=$c_as_options"]] |
| set method "compiling" |
| } else { |
| set comp_output [target_assemble $sourcefile $objdir/${name}.o "$as_options"] |
| set method "assembling" |
| } |
| |
| if ![string match "" $comp_output] { |
| verbose -log "$comp_output" 3 |
| fail "$mach $testname (${method})" |
| continue |
| } |
| |
| set comp_output [target_link $objdir/${name}.o $objdir/${name}.x "$opts(ld,$mach)"] |
| set method "linking" |
| } |
| |
| if ![string match "" $comp_output] { |
| verbose -log "$comp_output" 3 |
| fail "$mach $testname (${method})" |
| continue |
| } |
| |
| # If no machine specific options, default to the general version. |
| if ![info exists opts(sim,$mach)] { |
| set opts(sim,$mach) $opts(sim) |
| } |
| |
| # Build the options argument. |
| set options "" |
| if { "$opts(timeout)" != "" } { |
| set options "$options timeout=$opts(timeout)" |
| } |
| |
| set result [sim_run $objdir/${name}.x "$opts(sim,$mach) $SIMFLAGS_FOR_TARGET" "$opts(progopts)" "" "$options"] |
| set return_code [lindex $result 0] |
| set output [lindex $result 1] |
| |
| set status fail |
| if { $return_code == 77 } { |
| set status unsupported |
| } elseif { $return_code == $opts(status) } { |
| set status pass |
| } |
| |
| if { "$status" == "pass" } { |
| if { "$opts(xerror)" == "no" } { |
| if [string match $opts(output) $output] { |
| pass "$mach $testname" |
| file delete $objdir/${name}.o $objdir/${name}.x |
| } else { |
| verbose -log "status: $return_code" 3 |
| verbose -log "output: $output" 3 |
| verbose -log "pattern: $opts(output)" 3 |
| fail "$mach $testname (execution)" |
| } |
| } else { |
| verbose -log "`pass' return code when expecting failure" 3 |
| fail "$mach $testname (execution)" |
| } |
| } elseif { "$status" == "fail" } { |
| if { "$opts(xerror)" == "no" } { |
| fail "$mach $testname (execution)" |
| } else { |
| if [string match $opts(output) $output] { |
| pass "$mach $testname" |
| file delete $objdir/${name}.o $objdir/${name}.x |
| } else { |
| verbose -log "status: $return_code" 3 |
| verbose -log "output: $output" 3 |
| verbose -log "pattern: $opts(output)" 3 |
| fail "$mach $testname (execution)" |
| } |
| } |
| } else { |
| $status "$mach $testname" |
| } |
| } |
| } |
| |
| # Subroutine of run_sim_test to process options in FILE. |
| |
| proc slurp_options { file } { |
| global subdir srcdir |
| if [catch { set f [open $file r] } x] { |
| #perror "couldn't open `$file': $x" |
| perror "$x" |
| return -1 |
| } |
| set opt_array {} |
| # whitespace expression |
| set ws {[ ]*} |
| set nws {[^ ]*} |
| # whitespace is ignored anywhere except within the options list; |
| # option names are alphabetic only |
| set pat "^#${ws}(\[a-zA-Z\]*)\\(?(\[^):\]*)\\)?$ws:${ws}(.*)$ws\$" |
| # Allow arbitrary lines until the first option is seen. |
| set seen_opt 0 |
| while { [gets $f line] != -1 } { |
| set line [string trim $line] |
| # Whitespace here is space-tab. |
| if [regexp $pat $line xxx opt_name opt_machs opt_val] { |
| # match! |
| set opt_val [string map [list \ |
| {$pwd} [pwd] \ |
| {$srcdir} "$srcdir" \ |
| {$subdir} "$subdir" \ |
| ] "$opt_val"] |
| lappend opt_array [list $opt_name $opt_machs $opt_val] |
| set seen_opt 1 |
| } else { |
| if { $seen_opt } { |
| break |
| } |
| } |
| } |
| close $f |
| return $opt_array |
| } |