gcc/testsuite/

[pf3gnuchains/gcc-fork.git] / gcc / testsuite / gcc.target / mips / mips.exp

# Copyright (C) 1997, 2007, 2008, 2009 Free Software Foundation, Inc.

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with GCC; see the file COPYING3.  If not see
# <http://www.gnu.org/licenses/>.

# A MIPS version of the GCC dg.exp driver.
#
# There are many MIPS features that we want to test, and many of those
# features are specific to certain architectures, certain ABIs and so on.
# There are therefore many cases in which we want to test something that
# is incompatible with the user's chosen test options.
#
# In most dg testsuites, the options added by dg-options have a lower
# priority than the options chosen by the user.  For example, if a test
# specifies:
#
#    { dg-options "-mips1" }
#
# and the user passes the following option to runtest:
#
#    --target_board unix/-mips3
#
# the test would be compiled as MIPS III rather than MIPS I.  If the
# test really wouldn't work with -mips3, normal practice would be to
# have something like:
#
#    { dg-do compile { target can_force_mips1 } }
#
# so that the test is skipped when an option like -mips3 is passed.
#
# Sticking to the same approach here would cause us to skip many tests,
# even though the toolchain can generate the required code.  For example,
# there are 6 MIPS ABIs, plus variants.  Some configurations support
# more than one ABI, so it is natural to use something like:
#
#    --target_board unix{-mabi=n32,-mabi=32,-mabi=64}
#
# when testing them.  But these -mabi=* options would normally prevent any
# EABI and o64 tests from running.
#
# This testsuite therefore defines a local version of dg-options that
# overrides any user options that are incompatible with the test options.
# It tries to keep the other user options intact.
#
#
# Most of the tests in this testsuite are scan-assembler tests, but
# sometimes we need a link test instead.  In these cases, we must not
# try to link code with options that are incompatible with the current
# multilib, because xgcc is passed -L and -B options that are specific
# to that multilib.
#
# Normal GCC practice would be to skip incompatible link tests as
# unsupported, but in this particular case, it seems better to downgrade
# them to an assemble test instead.  At least that way we get some
# test-for-ICE and code-sanity coverage.
#
# The same problem applies to run tests.  If a test requires runtime
# support for a particular feature, and if the current target does not
# provide that support, normal practice would be to skip the test.
# But in this case it seems better to downgrade it to a link test instead.
# (We might then have to downgrade it to an assembler test according to
# the constraints just mentioned.)
#
# The local dg-options therefore checks whether the new options are
# link-compatiable with the user's options.  If not, it automatically
# downgrades link tests to assemble tests.  It does the same for run
# tests, but in addition, it downgrades run tests to link tests if the
# target does not provide runtime support for a required feature or ASE.
#
#
# Another problem is that many of the options we want to test require
# certain other features.  For example, -mips3d requires both 64-bit
# FPRs and a MIPS32 or MIPS64 target; -mfix-r10000 requires branch-
# likely instructions; and so on.  We could handle this by specifying
# a set of options that are guaranteed to give us what we want, such as:
#
#   dg-options "-mips3d -mpaired-single -mhard-float -mgp64 -mfp64 -mabi=n32 -march=mips64 -mips64"
#
# With the new dg-options semantics, this would override any troublesome
# user options like -mips3, -march=vr4100, -mfp32, -mgp32, -msoft-float,
# -mno-paired-single and so on.  But there are three major problems with
# this:
#
#   - It is easy to forget options.
#
#   - If a new option is added, all tests that are incompatible with that
#     option must be updated.
#
#   - We want to be able to test MIPS-3D with things like -march=mips32,
#     -march=mips64r2, -march=sb1, and so on.
#
# The local version of dg-options therefore works out the requirements
# of each test option.  As with the test options themselves, the local
# dg-options overrides any user options that incompatible with these
# requirements, but it keeps the other user options the same.
#
# For example, if the user passes -mips3, a MIPS-3D test will choose
# a different architecture like -mips64 instead.  But if the user
# passes -march=sb1, MIPS-3D tests will be run with that option.
#
#
# Sometimes it is useful to say "I want an environment that is compatible
# with option X, but I don't want to pass option X itself".  The main example
# of this is -mips16: we want to be able to test __attribute__((mips16))
# without requiring the test itself to be compiled as -mips16.  The local
# version of dg-options lets you do this by putting X in parentheses.
# For example:
#
#   { dg-options "(-mips16)" }
#
# selects a MIPS16-compatible target without passing -mips16 itself.
#
# It is also useful to say "any architecture within this ISA range is fine".
# This can be done using special pseudo-options of the form:
#
#   PROP=VALUE PROP<=VALUE PROP>=VALUE
#
# where PROP can be:
#
#   isa:
#       the value of the __mips macro.
#
#   isa_rev:
#       the value of the __mips_isa_rev macro, or 0 if it isn't defined.
#
# For example, "isa_rev>=1" selects a MIPS32 or MIPS64 processor,
# "isa=4" selects a MIPS IV processor, and so on.
#
# There are also the following special pseudo-options:
#
#   isa=loongson
#       select a Loongson processor
#
#   addressing=absolute
#       force absolute addresses to be used
#
#   forbid_cpu=REGEXP
#       forbid processors that match the given regexp; choose a
#       generic ISA instead.
#
#
# In summary:
#
#   (1) Try to avoid { target ... } requirements wherever possible.
#       Specify the requirements as dg-options instead.
#
#   (2) Don't worry about the consequences of (1) for link and run tests.
#       If the test uses { dg-do link } or { dg-do run }, and its
#       dg-options are incompatible with the current target, the
#       testsuite will downgrade them where necessary.
#
#   (3) Try to use the bare minimum of options and leave dg-options
#       to work out the dependencies.  For example, if you want
#       a MIPS-3D test, you should generally just specify -mips3d.
#       Don't specify an architecture option like -mips64 unless
#       the test really doesn't work with -mips32r2, -mips64r2,
#       -march=sb1, etc.
#
#   (4) If you want something compatible with a particular option,
#       but don't want to pass the option itself, wrap that option
#       in parentheses.  In particular, pass '(-mips16)' if you
#       want to use "mips16" attributes.
#
#   (5) When testing a feature of a generic ISA (as opposed to a
#       processor-specific extension), try to use the "isa" and
#       "isa_rev" pseudo-options instead of specific architecture
#       options.  For example, if the feature is present on revision 2
#       processors and above, try to use "isa_rev>=2" instead of
#       "-mips32r2" or "-mips64r2".
#
#   (6) If you need to disable processor-specific extensions use
#       forbid_cpu=REGEXP instead of forcing a generic ISA.
#
#
# Terminology
#
#   Option group or just group:
#      See comment before mips_option_groups.
#
#   Test options:
#      The options specified in dg-options.
#
#   Explicit options:
#      The options that were either passed to runtest as "multilib" options
#      (e.g. -mips4 in --target_board=mips-sim-idt/-mips4) or specified as
#      test options.  Note that options in parenthesis (i.e. (-mips16)) are
#      not explicit and can be omitted depending on the base options.
#
#   Base options:
#      Options that are on by default without being specified in dg-options,
#      e.g. -march=mips64r2 for mipsisa64r2-elf or because they've been
#      passed to runtest as "multilib" options.
#
#   Option array:
#      Many functions in this file work with option arrays.  These are
#      two-dimensional Tcl arrays where the first dimension can have three
#      values: option, explicit_p or test_option_p.  The second dimension is
#      the name of the option group.  "option" contains the name of the
#      option that is in effect from this group.  If no option is active it
#      contains the empty string.  The flags "explicit_p" and "test_option_p"
#      are set for explicit and test options.

# Exit immediately if this isn't a MIPS target.
if ![istarget mips*-*-*] {
    return
}

# Load support procs.
load_lib gcc-dg.exp

# A list of GROUP REGEXP pairs.  Each GROUP represents a logical group of
# options from which only one option should be chosen.  REGEXP matches all
# the options in that group; it is implicitly wrapped in "^(...)$".
set mips_option_groups {
    abi "-mabi=.*"
    addressing "addressing=.*"
    arch "-mips([1-5]|32.*|64.*)|-march=.*|isa(|_rev)(=|<=|>=).*"
    dump_pattern "-dp"
    endianness "-E(L|B)|-me(l|b)"
    float "-m(hard|soft)-float"
    forbid_cpu "forbid_cpu=.*"
    fp "-mfp(32|64)"
    gp "-mgp(32|64)"
    long "-mlong(32|64)"
    mips16 "-mips16|-mno-mips16"
    mips3d "-mips3d|-mno-mips3d"
    optimization "-O(|[0-3s])"
    pic "-f(no-|)(pic|PIC)"
    profiling "-pg"
    small-data "-G[0-9]+"
    warnings "-w"
}

# Add -mfoo/-mno-foo options to mips_option_groups.
foreach option {
    abicalls
    branch-likely
    dsp
    dspr2
    explicit-relocs
    extern-sdata
    fix-r4000
    fix-r10000
    fix-vr4130
    gpopt
    local-sdata
    long-calls
    paired-single
    plt
    shared
    smartmips
    sym32
    synci
} {
    lappend mips_option_groups $option "-m(no-|)$option"
}

# Add -mfoo= options to mips_option_groups.
foreach option {
    branch-cost
    code-readable
    r10k-cache-barrier
    tune
} {
    lappend mips_option_groups $option "-m$option=.*"
}

# Add -ffoo/-fno-foo options to mips_option_groups.
foreach option {
    delayed-branch
    fast-math
    finite-math-only
    fixed-hi
    fixed-lo
    lax-vector-conversions
    split-wide-types
    tree-vectorize
} {
    lappend mips_option_groups $option "-f(no-|)$option"
}

# A list of option groups that have an impact on the ABI.
set mips_abi_groups {
    abi
    abicalls
    arch
    endianness
    float
    fp
    gp
    gpopt
    long
    pic
    small-data
}

# mips_option_tests(OPTION) is some assembly code that will run to completion
# on a target that supports OPTION.
set mips_option_tests(-mips16) {
    move $2,$31
    bal 1f
    .set mips16
    jr $31
    .set nomips16
    .align 2
1:
    ori $3,$31,1
    jalr $3
    move $31,$2
}
set mips_option_tests(-mpaired-single) {
    .set mips64
    lui $2,0x3f80
    mtc1 $2,$f0
    cvt.ps.s $f2,$f0,$f0
}
set mips_option_tests(-mips3d) {
    .set mips64
    .set mips3d
    lui $2,0x3f80
    mtc1 $2,$f0
    cvt.ps.s $f2,$f0,$f0
    mulr.ps $f2,$f2,$f2
    rsqrt1.s $f2,$f0
    mul.s $f4,$f2,$f0
    rsqrt2.s $f4,$f4,$f2
    madd.s $f4,$f2,$f2,$f4
}
set mips_option_tests(-mdsp) {
    .set mips64r2
    .set dsp
    addsc $2,$2,$2
}
set mips_option_tests(-mdspr2) {
    .set mips64r2
    .set dspr2
    prepend $2,$3,11
}

# Canonicalize command-line option OPTION.
proc mips_canonicalize_option { option } {
    regsub {^-mips([1-5]|32*|64*)$} $option {-march=mips\1} option

    regsub {^-mel$} $option {-EL} option
    regsub {^-meb$} $option {-EB} option

    regsub {^-O$} $option {-O1} option

    # MIPS doesn't use -fpic and -fPIC to distinguish between code models.
    regsub {^-f(no-|)PIC} $option {-f\1pic} option

    return $option
}

# Return true if OPTION1 and OPTION2 represent the same command-line option.
proc mips_same_option_p { option1 option2 } {
    return [string equal \
                [mips_canonicalize_option $option1] \
                [mips_canonicalize_option $option2]]
}

# Preprocess CODE using target_compile options OPTIONS.  Return the
# compiler output.
proc mips_preprocess { options code } {
    global tool

    set src dummy[pid].c
    set f [open $src "w"]
    puts $f $code
    close $f
    set output [${tool}_target_compile $src "" preprocess $options]
    file delete $src

    return $output
}

# Set the target board's command-line options to NEW_OPTIONS, storing the
# old values in UPVAR.
proc mips_push_test_options { upvar new_options } {
    upvar $upvar var
    global board_info

    array unset var
    set var(name) board_info([target_info name],multilib_flags)
    if { [info exists $var(name)] } {
        set var(old_options) [set $var(name)]
        set $var(name) [join $new_options " "]
    }
}

# Undo the effects of [mips_push_test_options UPVAR ...]
proc mips_pop_test_options { upvar } {
    upvar $upvar var
    global board_info

    if { [info exists var(old_options)] } {
        set $var(name) $var(old_options)
    }
}

# Return property PROP for architecture option ARCH (which belongs to
# the "arch" group in mips_option_groups).  See the comment at the
# top of the file for the valid property names.
#
# Cache the results in mips_arch_info (which can be reused between test
# variants).
proc mips_arch_info { arch prop } {
    global mips_arch_info
    global board_info

    set arch [mips_canonicalize_option $arch]
    if { ![info exists mips_arch_info($arch,$prop)] } {
        mips_push_test_options saved_options {}
        set output [mips_preprocess [list "additional_flags=$arch -mabi=32"] {
            int isa = __mips;
            #ifdef __mips_isa_rev
            int isa_rev = __mips_isa_rev;
            #else
            int isa_rev = 0;
            #endif
        }]
        foreach lhs { isa isa_rev } {
            regsub ".*$lhs = (\[^;\]*).*" $output {\1} rhs
            verbose -log "Architecture $arch has $lhs $rhs"
            set mips_arch_info($arch,$lhs) $rhs
        }
        mips_pop_test_options saved_options
    }
    return $mips_arch_info($arch,$prop)
}

# Return the option group associated with OPTION, or "" if none.
proc mips_option_maybe_group { option } {
    global mips_option_groups

    foreach { group regexp } $mips_option_groups {
        if { [regexp -- "^($regexp)\$" $option] } {
            return $group
        }
    }
    return ""
}

# Return the option group associated with OPTION.  Raise an error if
# there is none.
proc mips_option_group { option } {
    set group [mips_option_maybe_group $option]
    if { [string equal $group ""] } {
        error "Unrecognised option: $option"
    }
    return $group
}

# Return the option for option group GROUP, or "" if no option in that
# group has been chosen.  UPSTATUS describes the option status.
proc mips_option { upstatus group } {
    upvar $upstatus status

    return $status(option,$group)
}

# If the base options for this test run include an option in group GROUP,
# return that option, otherwise return "".
proc mips_original_option { group } {
    global mips_base_options

    return [mips_option mips_base_options $group]
}

# Return true if the test described by UPSTATUS requires a specific
# option in group GROUP.  UPSTATUS describes the option status.
proc mips_test_option_p { upstatus group } {
    upvar $upstatus status

    return $status(test_option_p,$group)
}

# If the test described by UPSTATUS requires a particular option in group
# GROUP, return that option, otherwise return "".
proc mips_test_option { upstatus group } {
    upvar $upstatus status

    if { [mips_test_option_p status $group] } {
        return [mips_option status $group]
    } else {
        return ""
    }
}

# Return true if the options described by UPSTATUS include OPTION.
proc mips_have_option_p { upstatus option } {
    upvar $upstatus status

    return [mips_same_option_p \
                [mips_option status [mips_option_group $option]] \
                $option]
}

# Return true if the test described by UPSTATUS requires option OPTION.
proc mips_have_test_option_p { upstatus option } {
    upvar $upstatus status

    set group [mips_option_group $option]
    return [mips_same_option_p [mips_test_option status $group] $option]
}

# If the test described by UPSTATUS does not specify an option in
# OPTION's group, act as though it had specified OPTION.
#
# The first optional argument indicates whether the option should be
# treated as though it were wrapped in parentheses; see the comment at
# the top of the file for details about this convention.  The default is 0.
proc mips_make_test_option { upstatus option args } {
    upvar $upstatus status

    set group [mips_option_group $option]
    if { ![mips_test_option_p status $group] } {
        set status(option,$group) $option
        set status(test_option_p,$group) 1
        if { [llength $args] == 0 || ![lindex $args 0] } {
            set status(explicit_p,$group) 1
        }
    }
}

# If the test described by UPSTATUS requires option FROM, assume that
# it implicitly requires option TO.
proc mips_option_dependency { upstatus from to } {
    upvar $upstatus status

    if { [mips_have_test_option_p status $from] } {
        mips_make_test_option status $to
    }
}

# Return true if the given arch-group option specifies a 32-bit ISA.
proc mips_32bit_arch_p { option } {
    set isa [mips_arch_info $option isa]
    return [expr { $isa < 3 || $isa == 32 }]
}

# Return true if the given arch-group option specifies a 64-bit ISA.
proc mips_64bit_arch_p { option } {
    return [expr { ![mips_32bit_arch_p $option] }]
}

# Return true if the given abi-group option implicitly requires -mgp32.
proc mips_32bit_abi_p { option } {
    switch -glob -- $option {
        -mabi=32 {
            return 1
        }
    }
    return 0
}

# Return true if the given abi-group option implicitly requires -mgp64.
proc mips_64bit_abi_p { option } {
    switch -glob -- $option {
        -mabi=o64 -
        -mabi=n32 -
        -mabi=64 {
            return 1
        }
    }
    return 0
}

# Check whether the current target supports all the options that the
# current test requires.  Return "" if so, otherwise return one of
# the incompatible options.  UPSTATUS describes the option status.
proc mips_first_unsupported_option { upstatus } {
    global mips_option_tests
    upvar $upstatus status

    foreach { option code } [array get mips_option_tests] {
        if { [mips_have_test_option_p status $option] } {
            regsub -all "\n" $code "\\n\\\n" asm
            # Use check_runtime from target-supports.exp, which caches
            # the result for us.
            if { ![check_runtime mips_option_$option [subst {
                __attribute__((nomips16)) int
                main (void)
                {
                    asm (".set push\
                    $asm\
                    .set pop");
                    return 0;
                }
            }]] } {
                return $option
            }
        }
    }
    return ""
}

# Initialize this testsuite for a new test variant.
proc mips-dg-init {} {
    # Invariant information.
    global mips_option_groups

    # Internally-generated information about this run.
    global mips_base_options
    global mips_extra_options

    # Override dg-options with our mips-dg-options routine.
    rename dg-options mips-old-dg-options
    rename mips-dg-options dg-options

    # Start with a fresh option status.
    array unset mips_base_options
    foreach { group regexp } $mips_option_groups {
        set mips_base_options(option,$group) ""
        set mips_base_options(explicit_p,$group) 0
        set mips_base_options(test_option_p,$group) 0
    }

    # Use preprocessor macros to work out as many implicit options as we can.
    set output [mips_preprocess "" {
        const char *options[] = {
            #if !defined _MIPS_SIM
            "-mabi=eabi",
            #elif _MIPS_SIM==_ABIO32
            "-mabi=32",
            #elif _MIPS_SIM==_ABIO64
            "-mabi=o64",
            #elif _MIPS_SIM==_ABIN32
            "-mabi=n32",
            #else
            "-mabi=64",
            #endif

            "-march=" _MIPS_ARCH,

            #ifdef _MIPSEB
            "-EB",
            #else
            "-EL",
            #endif

            #ifdef __mips_hard_float
            "-mhard-float",
            #else
            "-msoft-float",
            #endif

            #if __mips_fpr == 64
            "-mfp64",
            #else
            "-mfp32",
            #endif

            #ifdef __mips64
            "-mgp64",
            #else
            "-mgp32",
            #endif

            #if _MIPS_SZLONG == 64
            "-mlong64",
            #else
            "-mlong32",
            #endif

            #ifdef __mips16
            "-mips16",
            #else
            "-mno-mips16",
            #endif

            #ifdef __mips3d
            "-mips3d",
            #else
            "-mno-mips3d",
            #endif

            #ifdef __mips_paired_single_float
            "-mpaired-single",
            #else
            "-mno-paired-single",
            #endif

            #if __mips_abicalls
            "-mabicalls",
            #else
            "-mno-abicalls",
            #endif

            #if __mips_dsp_rev >= 2
            "-mdspr2",
            #else
            "-mno-dspr2",
            #endif

            #if __mips_dsp_rev >= 1
            "-mdsp",
            #else
            "-mno-dsp",
            #endif

            #ifndef __PIC__
            "addressing=absolute",
            #endif

            #ifdef __mips_smartmips
            "-msmartmips",
            #else
            "-mno-smartmips",
            #endif

            0
        };
    }]
    foreach line [split $output "\r\n"] {
        # Poor man's string concatenation.
        regsub -all {" "} $line "" line
        if { [regexp {"(.*)",} $line dummy option] } {
            set group [mips_option_group $option]
            set mips_base_options(option,$group) $option
        }
    }

    # Process the target's multilib options, saving any unrecognized
    # ones in mips_extra_options.
    set mips_extra_options {}
    foreach option [split [board_info target multilib_flags]] {
        set group [mips_option_maybe_group $option]
        if { ![string equal $group ""] } {
            set mips_base_options(option,$group) $option
            set mips_base_options(explicit_p,$group) 1
        } else {
            lappend mips_extra_options $option
        }
    }
}

# Finish a test run started by mips-dg-init.
proc mips-dg-finish {} {
    rename dg-options mips-dg-options
    rename mips-old-dg-options dg-options
}

# Override dg-options so that we can do some MIPS-specific processing.
# All options used in this testsuite must appear in mips_option_groups.
#
# Test options override multilib options.  Certain test options can
# also imply other test options, which also override multilib options.
# These dependencies are ordered as follows:
#
#          START                        END
#            |                           |
#         -mips16                     -mno-mips16
#            |                           |
#         -mips3d                     -mno-mips3d
#            |                           |
#         -mpaired-single             -mno-paired-single
#            |                           |
#         -mfp64                      -mfp32
#            |                           |
#         -mhard-float                -msoft-float
#            |                           |
#         -mno-sym32                  -msym32
#            |                           |
#         -fpic                       -fno-pic
#            |                           |
#         -mshared                    -mno-shared
#            |                           |
#         -mno-plt                    -mplt
#            |                           |
#         addressing=unknown          addressing=absolute
#            |                           |
#         -mabicalls                  -mno-abicalls
#            |                           |
#         -G0                         <other value>
#            |                           |
#         <other value>               -mr10k-cache-barrier=none
#            |                           |
#         -mfix-r10000                -mno-fix-r10000
#            |                           |
#         -mbranch-likely             -mno-branch-likely
#            |                           |
#         -msmartmips                 -mno-smartmips
#            |                           |
#         -mno-gpopt                  -mgpopt
#            |                           |
#         -mexplicit-relocs           -mno-explicit-relocs
#            |                           |
#            +-- gp, abi & arch ---------+
#
# For these purposes, the "gp", "abi" & "arch" option groups are treated
# as a single node.
proc mips-dg-options { args } {
    # dg.exp variables.
    upvar dg-extra-tool-flags extra_tool_flags
    upvar dg-do-what do_what

    # Invariant information.
    global mips_option_groups
    global mips_abi_groups

    # Information about this run.
    global mips_base_options

    # Start out with the default option state.
    array set options [array get mips_base_options]

    # Record the options that this test explicitly needs.
    foreach option [lindex $args 1] {
        set all_but_p [regexp {^\((.*)\)$} $option dummy option]
        set group [mips_option_group $option]
        if { [mips_test_option_p options $group] } {
            set old [mips_option options $group]
            error "Inconsistent $group option: $old vs. $option"
        } else {
            mips_make_test_option options $option $all_but_p
        }
    }

    # Handle dependencies between options on the left of the
    # dependency diagram.
    mips_option_dependency options "-mips3d" "-mpaired-single"
    mips_option_dependency options "-mpaired-single" "-mfp64"
    mips_option_dependency options "-mfp64" "-mhard-float"
    mips_option_dependency options "-fpic" "-mshared"
    mips_option_dependency options "-mshared" "-mno-plt"
    mips_option_dependency options "-mno-plt" "addressing=unknown"
    mips_option_dependency options "-mabicalls" "-G0"
    mips_option_dependency options "-mno-gpopt" "-mexplicit-relocs"

    # Work out information about the current ABI.
    set abi_test_option_p [mips_test_option_p options abi]
    set abi [mips_option options abi]
    set eabi_p [mips_same_option_p $abi "-mabi=eabi"]

    # If the test forces a particular ABI, set the register size
    # accordingly.
    if { $abi_test_option_p } {
        if { [mips_32bit_abi_p $abi] } {
            mips_make_test_option options "-mgp32"
        } elseif { [mips_64bit_abi_p $abi] } {
            mips_make_test_option options "-mgp64"
        }
    }

    # See whether forbid_cpu forces us to choose a new architecture.
    set arch [mips_option mips_base_options arch]
    set force_generic_isa_p [expr {
        [regexp "forbid_cpu=(.*)" [mips_option options forbid_cpu] dummy spec]
        && [regexp -- "^-march=$spec\$" $arch]
    }]

    # Interpret the special "isa" and "isa_rev" options.  If we have
    # a choice of a 32-bit or a 64-bit architecture, prefer to keep
    # the -mgp setting the same.
    set spec [mips_option options arch]
    if { [regexp {^[^-]} $spec] } {
        if { [string equal $spec "isa=loongson"] } {
            if { ![regexp {^-march=loongson} $arch] } {
                set arch "-march=loongson2f"
            }
        } else {
            if { ![regexp {^(isa(?:|_rev))(=|<=|>=)([0-9]*)$} \
                       $spec dummy prop relation value nocpus] } {
                error "Unrecognized isa specification: $spec"
            }
            set current [mips_arch_info $arch $prop]
            if { $force_generic_isa_p
                 || ($current < $value && ![string equal $relation "<="])
                 || ($current > $value && ![string equal $relation ">="])
                 || ([mips_have_test_option_p options "-mgp64"]
                     && [mips_32bit_arch_p $arch]) } {
                # The current setting is out of range; it cannot
                # possibly be used.  Find a replacement that can.
                if { [string equal $prop "isa"] } {
                    set arch "-mips$value"
                } elseif { $value == 0 } {
                    set arch "-mips4"
                } else {
                    if { [mips_have_option_p options "-mgp32"] } {
                        set arch "-mips32"
                    } else {
                        set arch "-mips64"
                    }
                    if { $value > 1 } {
                        append arch "r$value"
                    }
                }
            }
        }
        set options(option,arch) $arch
    }

    # Work out information about the current architecture.
    set arch_test_option_p [mips_test_option_p options arch]
    set arch [mips_option options arch]
    set isa [mips_arch_info $arch isa]
    set isa_rev [mips_arch_info $arch isa_rev]

    # If the test forces a 32-bit architecture, force -mgp32.
    # Force the current -mgp setting otherwise; if we don't,
    # some configurations would make a 64-bit architecture
    # imply -mgp64.
    if { $arch_test_option_p } {
        if { [mips_32bit_arch_p $arch] } {
            mips_make_test_option options "-mgp32"
        } else {
            mips_make_test_option options [mips_option options gp]
        }
    }

    # We've now fixed the GP register size.  Make it easily available.
    set gp_size [expr { [mips_have_option_p options "-mgp32"] ? 32 : 64 }]

    # Handle dependencies between the pre-arch options and the arch option.
    # This should mirror the arch and post-arch code below.
    if { !$arch_test_option_p } {
        # We need a revision 2 or better ISA for:
        #
        #   - the combination of -mgp32 -mfp64
        #   - the DSP ASE
        if { $isa_rev < 2
             && (($gp_size == 32 && [mips_have_test_option_p options "-mfp64"])
                 || [mips_have_test_option_p options "-mdsp"]
                 || [mips_have_test_option_p options "-mdspr2"]) } {
            if { $gp_size == 32 } {
                mips_make_test_option options "-mips32r2"
            } else {
                mips_make_test_option options "-mips64r2"
            }
        # We need a MIPS32 or MIPS64 ISA for:
        #
        #   - paired-single instructions(*)
        #
        # (*) Note that we don't support MIPS V at the moment.
        } elseif { $isa_rev < 1
                   && [mips_have_test_option_p options "-mpaired-single"] } {
            if { $gp_size == 32 } {
                mips_make_test_option options "-mips32"
            } else {
                mips_make_test_option options "-mips64"
            }
        # We need MIPS III or higher for:
        #
        #   - the "cache" instruction
        } elseif { $isa < 3
                   && ([mips_have_test_option_p options \
                            "-mr10k-cache-barrier=load-store"]
                       || [mips_have_test_option_p options \
                               "-mr10k-cache-barrier=store"]) } {
            mips_make_test_option options "-mips3"
        # We need MIPS II or higher for:
        #
        #   - branch-likely instructions(*)
        #
        # (*) needed by both -mbranch-likely and -mfix-r10000
        } elseif { $isa < 2
                   && ([mips_have_test_option_p options "-mbranch-likely"]
                       || [mips_have_test_option_p options "-mfix-r10000"]) } {
            mips_make_test_option options "-mips2"
        # Check whether we need to switch from a 32-bit processor to the
        # "nearest" 64-bit processor.
        } elseif { $gp_size == 64 && [mips_32bit_arch_p $arch] } {
            if { $isa_rev == 0 } {
                mips_make_test_option options "-mips3"
            } elseif { $isa_rev == 1 } {
                mips_make_test_option options "-mips64"
            } else {
                mips_make_test_option options "-mips64r$isa_rev"
            }
        # Otherwise, if the current choice of architecture is unacceptable,
        # choose the equivalent generic architecture.
        } elseif { $force_generic_isa_p } {
            set arch "-mips[mips_arch_info $arch isa]"
            if { $isa_rev > 1 } {
                append arch "r$isa_rev"
            }
            mips_make_test_option options $arch
        }
        unset arch
        unset isa
        unset isa_rev
    }

    # Set an appropriate ABI, handling dependencies between the pre-abi
    # options and the abi options.  This should mirror the abi and post-abi
    # code below.
    if { !$abi_test_option_p } {
        if { ($eabi_p
              && ([mips_have_option_p options "-mabicalls"]
                  || ($gp_size == 32
                      && [mips_have_option_p options "-mfp64"]))) } {
            # EABI doesn't support -mabicalls.
            # EABI doesn't support the combination -mgp32 -mfp64.
            set force_abi 1
        } elseif { [mips_have_option_p options "-mips16"]
                   && ![mips_same_option_p $abi "-mabi=32"]
                   && ![mips_same_option_p $abi "-mabi=o64"]
                   && (![mips_have_option_p options "addressing=absolute"]
                       || [mips_have_option_p options "-mhard-float"]) } {
            # -mips16 -mhard-float requires o32 or o64.
            # -mips16 PIC requires o32 or o64.
            set force_abi 1
        } else {
            set force_abi 0
        }
        if { $gp_size == 32 } {
            if { $force_abi || [mips_64bit_abi_p $abi] } {
                mips_make_test_option options "-mabi=32"
            }
        } else {
            if { $force_abi || [mips_32bit_abi_p $abi] } {
                # All configurations should have an assembler that
                # supports o64, since it requires the same BFD target
                # vector as o32.  In contrast, many assembler
                # configurations do not have n32 or n64 support.
                mips_make_test_option options "-mabi=o64"
            }
        }
        unset abi
        unset eabi_p
    }

    # Handle dependencies between the abi options and the post-abi options.
    # This should mirror the abi and pre-abi code above.
    if { $abi_test_option_p } {
        if { $eabi_p } {
            mips_make_test_option options "-mno-abicalls"
            if { $gp_size == 32 } {
                mips_make_test_option options "-mfp32"
            }
        }
        if { [mips_have_option_p options "-mips16"]
             && ![mips_same_option_p $abi "-mabi=32"]
             && ![mips_same_option_p $abi "-mabi=o64"]
             && (![mips_have_option_p options "addressing=absolute"]
                 || [mips_have_option_p options "-mhard-float"]) } {
            if { [mips_test_option_p options mips16] } {
                mips_make_test_option options "addressing=absolute"
                mips_make_test_option options "-msoft-float"
            } else {
                mips_make_test_option options "-mno-mips16"
            }
        }
        unset abi
        unset eabi_p
    }

    # Handle dependencies between the arch option and the post-arch options.
    # This should mirror the arch and pre-arch code above.
    if { $arch_test_option_p } {
        if { $isa < 2 } {
            mips_make_test_option options "-mno-branch-likely"
            mips_make_test_option options "-mno-fix-r10000"
        }
        if { $isa < 3 } {
            mips_make_test_option options "-mr10k-cache-barrier=none"
        }
        if { $isa_rev < 1 } {
            mips_make_test_option options "-mno-paired-single"
        }
        if { $isa_rev < 2 } {
            if { $gp_size == 32 } {
                mips_make_test_option options "-mfp32"
            }
            mips_make_test_option options "-mno-dsp"
            mips_make_test_option options "-mno-dspr2"
        }
        unset arch
        unset isa
        unset isa_rev
    }

    # Handle dependencies between options on the right of the diagram.
    mips_option_dependency options "-mno-explicit-relocs" "-mgpopt"
    switch -- [mips_test_option options small-data] {
        "" -
        -G0 {}
        default {
            mips_make_test_option options "-mno-abicalls"
        }
    }
    if { [mips_have_option_p options "-mabicalls"] } {
        mips_option_dependency options "addressing=absolute" "-mplt"
    }
    mips_option_dependency options "-mplt" "-msym32"
    mips_option_dependency options "-mplt" "-mno-shared"
    mips_option_dependency options "-mno-shared" "-fno-pic"
    mips_option_dependency options "-mfp32" "-mno-paired-single"
    mips_option_dependency options "-msoft-float" "-mno-paired-single"
    mips_option_dependency options "-mno-paired-single" "-mno-mips3d"

    # If the test requires an unsupported option, change run tests
    # to link tests.

    switch -- [lindex $do_what 0] {
        run {
            set option [mips_first_unsupported_option options]
            if { ![string equal $option ""] } {
                set do_what [lreplace $do_what 0 0 link]
                verbose -log "Downgraded to a 'link' test due to unsupported option '$option'"
            }
        }
    }

    # If the test has overridden a option that changes the ABI,
    # downgrade a link or execution test to an assembler test.
    foreach group $mips_abi_groups {
        set old_option [mips_original_option $group]
        set new_option [mips_option options $group]
        if { ![mips_same_option_p $old_option $new_option] } {
            switch -- [lindex $do_what 0] {
                link -
                run {
                    set do_what [lreplace $do_what 0 0 assemble]
                    verbose -log "Downgraded to an 'assemble' test due to incompatible $group option ($old_option changed to $new_option)"
                }
            }
            break
        }
    }

    # Add all options to the dg variable.
    set options(explicit_p,addressing) 0
    set options(explicit_p,forbid_cpu) 0
    foreach { group regexp } $mips_option_groups {
        if { $options(explicit_p,$group) } {
            append extra_tool_flags " " $options(option,$group)
        }
    }

    # If the test is MIPS16-compatible, provide a counterpart to the
    # NOMIPS16 convenience macro.
    if { [mips_have_test_option_p options "-mips16"] } {
        append extra_tool_flags " -DMIPS16=__attribute__((mips16))"
    }

    # Use our version of gcc-dg-test for this test.
    if { ![string equal [info procs "mips-gcc-dg-test"] ""] } {
        rename gcc-dg-test mips-old-gcc-dg-test
        rename mips-gcc-dg-test gcc-dg-test
    }
}

# A version of gcc-dg-test that is used by dg-options tests.
proc mips-gcc-dg-test { prog do_what extra_tool_flags } {
    global board_info
    global mips_extra_options

    # Override the user's chosen test options with the combined test/user
    # version.
    mips_push_test_options saved_options $mips_extra_options
    set result [gcc-dg-test-1 gcc_target_compile $prog \
                    $do_what $extra_tool_flags]
    mips_pop_test_options saved_options

    # Restore the usual gcc-dg-test.
    rename gcc-dg-test mips-gcc-dg-test
    rename mips-old-gcc-dg-test gcc-dg-test

    return $result
}

dg-init
mips-dg-init
# MIPS16 is defined by "-mips16" or "(-mips16)" in dg-options.
dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.c]] "" \
    "-DNOMIPS16=__attribute__((nomips16))"
mips-dg-finish
dg-finish