diff options
Diffstat (limited to 'gcc/testsuite/gcc.target/mips/mips.exp')
| -rw-r--r-- | gcc/testsuite/gcc.target/mips/mips.exp | 1196 |
1 files changed, 1196 insertions, 0 deletions
diff --git a/gcc/testsuite/gcc.target/mips/mips.exp b/gcc/testsuite/gcc.target/mips/mips.exp new file mode 100644 index 000000000..0535c48f5 --- /dev/null +++ b/gcc/testsuite/gcc.target/mips/mips.exp @@ -0,0 +1,1196 @@ +# Copyright (C) 1997, 2007, 2008, 2009, 2010 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|-mflip-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 + relax-pic-calls + mcount-ra-address +} { + 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 options described by UPSTATUS require MIPS16 support. +proc mips_using_mips16_p { upstatus } { + upvar $upstatus status + + return [expr { [mips_have_option_p status "-mips16"] + || [mips_have_option_p status "-mflip-mips16"] }] +} + +# 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/-mflip-mips16 -mno-mips16 +# | | +# -mips3d -mno-mips3d +# | | +# -mpaired-single -mno-paired-single +# | | +# -mfp64 -mfp32 +# | | +# -mhard-float -msoft-float +# | | +# -mno-sym32 -msym32 +# | | +# -mrelax-pic-calls -mno-relax-pic-calls +# | | +# -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 "-mrelax-pic-calls" "-mno-plt" + mips_option_dependency options "-mrelax-pic-calls" "-mabicalls" + mips_option_dependency options "-mrelax-pic-calls" "-mexplicit-relocs" + 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_using_mips16_p options] + && ![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_using_mips16_p options] + && ![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 |