| # Copyright (C) 1992-2019, 2020 Free Software Foundation, Inc. | |
| # | |
| # This file is part of DejaGnu. | |
| # | |
| # DejaGnu 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. | |
| # | |
| # DejaGnu 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 DejaGnu. If not, see <http://www.gnu.org/licenses/>. | |
| # This file was written by Rob Savoye <rob@welcomehome.org>. | |
| # this contains a list of gcc options and their respective directories. | |
| # Find the pieces of libgloss for testing the GNU development tools | |
| # needed to link a set of object files into an executable. | |
| # This usually means setting the -L and -B paths correctly. | |
| # | |
| proc libgloss_link_flags { args } { | |
| global target_cpu | |
| global srcdir | |
| # libgloss doesn't work native | |
| if {[isnative]} { | |
| return "" | |
| } | |
| # if we're on a remote host, we can't search for the file, so we can only | |
| # use an installed compiler, so we don't add any paths here. | |
| if {[isremote host]} { | |
| return "" | |
| } | |
| set gccpath "[get_multilibs]" | |
| # map the target_cpu to the proper libgloss directory. unfortunately, these | |
| # directory names are hardcoded into libgloss. | |
| switch -glob -- $target_cpu { | |
| "sparc86x" { | |
| set cpu sparc | |
| } | |
| "sparclite" { | |
| set cpu sparc | |
| } | |
| "sparclet" { | |
| set cpu sparc | |
| } | |
| "sparc64*" { | |
| set cpu sparc | |
| } | |
| "hppa*" { | |
| set cpu pa | |
| } | |
| "mips*" { | |
| set cpu mips | |
| } | |
| "powerpc*" { | |
| set cpu rs6000 | |
| } | |
| "d10v*" { | |
| set cpu libnosys | |
| } | |
| "xscale*" { | |
| set cpu arm | |
| } | |
| "aarch64*" { | |
| set cpu aarch64 | |
| } | |
| default { | |
| set cpu $target_cpu | |
| } | |
| } | |
| set gloss_srcdir "" | |
| # look for the libgloss srcdir sp we can find the linker scripts | |
| set gloss_srcdir [lookfor_file $srcdir libgloss/$cpu] | |
| # set the proper paths for gcc if the target subdir exists, else assume we | |
| # have no libgloss support for this target. | |
| if { $gloss_srcdir eq "" } { | |
| return "" | |
| } | |
| if {[file exists [file join $gccpath libgloss $cpu]]} { | |
| verbose "Libgloss path is $gccpath/libgloss/$cpu" 2 | |
| return "-B$gccpath/libgloss/$cpu/ -L$gccpath/libgloss/$cpu -L$gloss_srcdir" | |
| } else { | |
| verbose -log "No libgloss support for this target." 2 | |
| return "" | |
| } | |
| } | |
| # There aren't any, but we'll be orthogonal here. | |
| # | |
| proc libgloss_include_flags { args } { | |
| return "" | |
| } | |
| # Find the newlib libraries in the current source tree. | |
| # | |
| proc newlib_link_flags { args } { | |
| global tool_root_dir | |
| # libgloss doesn't work native | |
| if {[isnative]} { | |
| return "" | |
| } | |
| # if we're on a remote host, we can't search for the file, so we can only | |
| # use an installed compiler, so we don't add any paths here. | |
| if {[isremote host]} { | |
| return "" | |
| } | |
| set ld_script_path [lookfor_file $tool_root_dir "ld/ldscripts"] | |
| if { $ld_script_path ne "" } { | |
| set result "-L[file dirname $ld_script_path]" | |
| } else { | |
| set result "" | |
| } | |
| set gccpath "[get_multilibs]" | |
| verbose "Looking for $gccpath/newlib" | |
| if {[file exists [file join $gccpath newlib]]} { | |
| verbose "Newlib path is $gccpath/newlib" | |
| return "$result -B$gccpath/newlib/ -L$gccpath/newlib" | |
| } else { | |
| verbose "No newlib support for this target" | |
| return $result | |
| } | |
| } | |
| proc newlib_include_flags { args } { | |
| global srcdir | |
| if {[isnative]} { | |
| return "" | |
| } | |
| if {[isremote host]} { | |
| return "" | |
| } | |
| set gccpath "[get_multilibs]" | |
| if {[file exists [file join $gccpath newlib]]} { | |
| verbose "Newlib path is $gccpath/newlib" | |
| set newlib_dir [lookfor_file $srcdir newlib/libc/include/assert.h] | |
| if { $newlib_dir ne "" } { | |
| set newlib_dir [file dirname $newlib_dir] | |
| } | |
| # Note - we use -isystem rather than -I because newlib contains | |
| # system header files. This is especially important for the | |
| # limits.h header which makes use of the #include_next directive. | |
| # #include_next will generate error messages from GCC if compiling | |
| # in strict ANSI mode or if another limits.h header cannot be found. | |
| # When it is included via -isystem these things do not happen. | |
| return " -isystem $gccpath/newlib/targ-include -isystem $newlib_dir" | |
| } else { | |
| verbose "No newlib support for this target" | |
| } | |
| } | |
| proc libio_include_flags { args } { | |
| global srcdir | |
| global tool_root_dir | |
| if {[isremote host]} { | |
| return "" | |
| } | |
| set gccpath "[get_multilibs]" | |
| if { $gccpath eq "" } { | |
| set gccpath $tool_root_dir | |
| } | |
| set libio_bin_dir [lookfor_file $gccpath libio/_G_config.h] | |
| # linux doesn't build _G_config.h and the test above fails, so | |
| # we search for iostream.list too. | |
| if { $libio_bin_dir eq "" } { | |
| set libio_bin_dir [lookfor_file $gccpath libio/iostream.list] | |
| } | |
| set libio_src_dir [lookfor_file $srcdir libio/Makefile.in] | |
| if { $libio_bin_dir ne "" && $libio_src_dir ne "" } { | |
| set libio_src_dir [file dirname $libio_src_dir] | |
| set libio_bin_dir [file dirname $libio_bin_dir] | |
| # Note - unlike the newlib_include_flags proc above we use the -I | |
| # switch to specify the include paths. This is because these headers | |
| # are not system headers, and if -isystem were to be used GCC would | |
| # generate an implicit extern "C" { ... } surrounding them. This | |
| # will break targets which do not define NO_IMPLICIT_EXTERN_C. | |
| return " -I$libio_src_dir -I$libio_bin_dir" | |
| } else { | |
| return "" | |
| } | |
| } | |
| proc libio_link_flags { args } { | |
| if {[isremote host]} { | |
| return "" | |
| } | |
| set gccpath "[get_multilibs]" | |
| set libio_dir [lookfor_file $gccpath libio/libio.a] | |
| if { $libio_dir ne "" } { | |
| return "-L[file dirname $libio_dir]" | |
| } else { | |
| return "" | |
| } | |
| } | |
| proc g++_include_flags { args } { | |
| global srcdir | |
| global target_alias | |
| if {[isremote host]} { | |
| return "" | |
| } | |
| set gccpath [get_multilibs] | |
| set libio_dir "" | |
| set flags "" | |
| set dir [lookfor_file $srcdir libg++] | |
| if { $dir ne "" } { | |
| # See comment in libio_include_flags about using -I. | |
| append flags " -I$dir -I$dir/src" | |
| } | |
| set dir [lookfor_file $srcdir libstdc++-v3] | |
| if { $dir ne "" } { | |
| append flags " -I$dir/include -I$dir/include/std -I$dir/include/c_std -I$dir/libsupc++" | |
| } | |
| set dir [lookfor_file $gccpath libstdc++-v3] | |
| if { $dir ne "" } { | |
| append flags " -I$dir/include -I$dir/include/$target_alias" | |
| } | |
| set dir [lookfor_file $srcdir libstdc++] | |
| if { $dir ne "" } { | |
| append flags " -I$dir -I$dir/stl" | |
| } | |
| return $flags | |
| } | |
| proc g++_link_flags { args } { | |
| global srcdir | |
| global ld_library_path | |
| set gccpath [get_multilibs] | |
| set libio_dir "" | |
| set flags "" | |
| set ld_library_path "." | |
| if { $gccpath ne "" } { | |
| if {[file exists [file join $gccpath lib libstdc++.a]]} { | |
| append ld_library_path ":$gccpath/lib" | |
| } | |
| if {[file exists [file join $gccpath libg++ libg++.a]]} { | |
| append flags "-L$gccpath/libg++ " | |
| append ld_library_path ":$gccpath/libg++" | |
| } | |
| if {[file exists [file join $gccpath libstdc++ libstdc++.a]]} { | |
| append flags "-L$gccpath/libstdc++ " | |
| append ld_library_path ":$gccpath/libstdc++" | |
| } | |
| if {[file exists [file join $gccpath libstdc++-v3 src .libs libstdc++.a]]} { | |
| append flags "-L$gccpath/libstdc++-v3/src/.libs " | |
| append ld_library_path ":$gccpath/libstdc++-v3/src/.libs" | |
| } | |
| if {[file exists [file join $gccpath libiberty libiberty.a]]} { | |
| append flags "-L$gccpath/libiberty " | |
| } | |
| if {[file exists [file join $gccpath librx librx.a]]} { | |
| append flags "-L$gccpath/librx " | |
| } | |
| } else { | |
| global tool_root_dir | |
| set libgpp [lookfor_file $tool_root_dir libg++] | |
| if { $libgpp ne "" } { | |
| append flags "-L$libgpp " | |
| append ld_library_path ":$libgpp" | |
| } | |
| set libstdcpp [lookfor_file $tool_root_dir libstdc++] | |
| if { $libstdcpp ne "" } { | |
| append flags "-L$libstdcpp " | |
| append ld_library_path ":$libstdcpp" | |
| } | |
| set libiberty [lookfor_file $tool_root_dir libiberty] | |
| if { $libiberty ne "" } { | |
| append flags "-L$libiberty " | |
| } | |
| set librx [lookfor_file $tool_root_dir librx] | |
| if { $librx ne "" } { | |
| append flags "-L$librx " | |
| } | |
| } | |
| return $flags | |
| } | |
| proc libstdc++_include_flags { args } { | |
| global srcdir | |
| global target_alias | |
| if {[isremote host]} { | |
| return "" | |
| } | |
| set gccpath [get_multilibs] | |
| set libio_dir "" | |
| set flags "" | |
| set dir [lookfor_file $srcdir libstdc++-v3] | |
| if { $dir ne "" } { | |
| # See comment in libio_include_flags about using -I. | |
| append flags " -I$dir/include -I$dir/include/std -I$dir/include/c_std -I$dir/libsupc++" | |
| } | |
| set gccpath [get_multilibs] | |
| set dir [lookfor_file $gccpath libstdc++-v3] | |
| if { $dir ne "" } { | |
| append flags " -I$dir/include -I$dir/include/$target_alias" | |
| } | |
| set dir [lookfor_file $srcdir libstdc++] | |
| if { $dir ne "" } { | |
| append flags " -I$dir -I$dir/stl" | |
| } | |
| return $flags | |
| } | |
| proc libstdc++_link_flags { args } { | |
| global srcdir | |
| global ld_library_path | |
| set gccpath [get_multilibs] | |
| set libio_dir "" | |
| set flags "" | |
| if { $gccpath ne "" } { | |
| if {[file exists [file join $gccpath libstdc++ libstdc++.a]]} { | |
| append flags "-L$gccpath/libstdc++ " | |
| append ld_library_path ":$gccpath/libstdc++" | |
| } | |
| if {[file exists [file join $gccpath libiberty libiberty.a]]} { | |
| append flags "-L$gccpath/libiberty " | |
| } | |
| if {[file exists [file join $gccpath librx librx.a]]} { | |
| append flags "-L$gccpath/librx " | |
| } | |
| } else { | |
| global tool_root_dir | |
| set libstdcpp [lookfor_file $tool_root_dir libstdc++] | |
| if { $libstdcpp ne "" } { | |
| append flags "-L$libstdcpp " | |
| append ld_library_path ":$libstdcpp" | |
| } | |
| set libiberty [lookfor_file $tool_root_dir libiberty] | |
| if { $libiberty ne "" } { | |
| append flags "-L$libiberty " | |
| } | |
| set librx [lookfor_file $tool_root_dir librx] | |
| if { $librx ne "" } { | |
| append flags "-L$librx " | |
| } | |
| } | |
| return $flags | |
| } | |
| # Get the list of directories and -m options for gcc. This is kinda bogus that | |
| # generic testing software needs support for gcc hardwired in, but to make | |
| # testing the GNU tools work right, there didn't seem to be any other way. | |
| # | |
| proc get_multilibs { args } { | |
| global target_alias | |
| global board | |
| global board_info | |
| # if we're on a remote host, we can't search for the file, so we can only | |
| # use an installed compiler, so we don't add any paths here. | |
| if {[isremote host]} { | |
| return "" | |
| } | |
| if {[info exists board]} { | |
| set target_board $board | |
| } else { | |
| set target_board [target_info name] | |
| } | |
| if { [llength $args] == 0 } { | |
| if {[board_info $target_board exists multitop]} { | |
| return "[board_info $target_board multitop]" | |
| } | |
| set board_info($target_board,multitop) "" | |
| } | |
| if { [board_info $target_board exists compiler] } { | |
| set compiler [board_info $target_board compiler] | |
| } else { | |
| set compiler [find_gcc] | |
| } | |
| if { $compiler eq "" } { | |
| return "" | |
| } | |
| foreach x $compiler { | |
| if {[regexp "^-B" $x]} { | |
| regsub "^-B" $x "" comp_base_dir | |
| set comp_base_dir [file dirname $comp_base_dir] | |
| break | |
| } | |
| } | |
| regexp "/.* " $compiler compiler | |
| set compiler [string trimright $compiler " "] | |
| verbose "compiler is $compiler" | |
| if { [which $compiler] == 0 } { | |
| return "" | |
| } | |
| if { [llength $args] > 0 } { | |
| set mopts [lindex $args 0] | |
| } else { | |
| if { [board_info $target_board exists multilib_flags] } { | |
| set mopts [board_info $target_board multilib_flags] | |
| } else { | |
| set mopts "" | |
| } | |
| } | |
| set default_multilib [exec $compiler --print-multi-lib] | |
| set default_multilib [lindex $default_multilib 0] | |
| set extra [string trimleft $default_multilib ".;@@"] | |
| # extract the options and their directory names as know by gcc | |
| foreach i "[exec $compiler --print-multi-lib]" { | |
| if {$extra ne ""} { | |
| # string trimright would do the wrong thing if we included | |
| # the leading @@ in $extra | |
| set i [string trimright $i $extra] | |
| set i [string trimright $i "@@"] | |
| } | |
| set opts "" | |
| set dir "" | |
| regexp -- "\[a-z0-9=/\.-\]*;" $i dir | |
| set dir [string trimright $dir "\;@"] | |
| regexp -- "\;@*\[\@a-zA-Z0-9=/\.-\]*" $i opts | |
| set opts [split [string trimleft $opts "\;@@"] "@@"] | |
| lappend multilibs "$dir {$opts }" | |
| # If args contains arguments don't use the first one as | |
| # multilib option unless it qualifies as a multilib option. | |
| if { [llength $args] > 0 } { | |
| set override_opt [lindex $args 0] | |
| foreach j $opts { | |
| if {$j == $override_opt} { | |
| set mopts $override_opt | |
| } | |
| } | |
| } | |
| } | |
| regsub "^-" $mopts "" moptions | |
| regsub -all " -" $moptions " " dirty_moptions | |
| set moptions "" | |
| foreach x [split $dirty_moptions " "] { | |
| if { $x ne "" && [lsearch -exact $moptions $x] < 0 } { | |
| lappend moptions $x | |
| } | |
| } | |
| if {![info exists comp_base_dir]} { | |
| set comp_base_dir [file dirname [file dirname [file dirname [file dirname [file dirname [exec $compiler --print-prog-name=cc1]]]]]] | |
| } | |
| # search for the top level multilib directory | |
| set multitop [lookfor_file $comp_base_dir $target_alias] | |
| if { $multitop eq "" } { | |
| set multitop [lookfor_file $comp_base_dir "libraries"] | |
| if { $multitop eq "" } { | |
| set multitop "[lookfor_file $comp_base_dir gcc/xgcc]" | |
| if { $multitop ne "" } { | |
| set multitop [file dirname [file dirname $multitop]] | |
| } else { | |
| return "" | |
| } | |
| } | |
| } | |
| set gccpath [eval exec $compiler --print-multi-directory $mopts] | |
| set gccpath [lindex $gccpath 0] | |
| if { $gccpath ne "" } { | |
| verbose "GCC path is $gccpath" | |
| if { [llength $args] == 0 } { | |
| set board_info($target_board,multitop) $multitop/$gccpath | |
| } | |
| return $multitop/$gccpath | |
| } | |
| # extract the MULTILIB_MATCHES from dumpspecs | |
| set multimatches "" | |
| set lines [split [exec $compiler -dumpspecs] "\n"] | |
| for {set i 0} {$i <= [llength $lines] - 1} {incr i 1} { | |
| if {"*multilib_matches:" eq "[lindex $lines $i]"} { | |
| set multimatches [lindex $lines [expr {$i + 1}]] | |
| break | |
| } | |
| } | |
| # if we find some | |
| if {$multimatches ne ""} { | |
| # Split it into a list of pairs. If an moptions are the first | |
| # of a pair, then replace it with the second. If an moption | |
| # is not in multimatches, we assume it's not a multilib option | |
| set splitmatches [split $multimatches ";"] | |
| set multimatches "" | |
| foreach i $splitmatches { | |
| lappend multimatches [split $i " "] | |
| } | |
| verbose "multimatches: $multimatches" 3 | |
| verbose "options before multimatches: $moptions" 3 | |
| set toptions $moptions | |
| set moptions "" | |
| foreach i $toptions { | |
| foreach j $multimatches { | |
| verbose "comparing [lindex $j 0] == $i" 3 | |
| if {[lindex $j 0] == $i} { | |
| lappend moptions [lindex $j 1] | |
| } | |
| } | |
| } | |
| verbose "options after multimatches: $moptions" 3 | |
| } | |
| # make a list of -m<foo> options from the various compiler config variables | |
| set gccpath "" | |
| # compare the lists of gcc options with the list of support multilibs | |
| verbose "Supported multilibs are: $multilibs" 3 | |
| set best 0 | |
| foreach i $multilibs { | |
| set hits 0 | |
| set opts [lindex $i 1] | |
| if { [llength $opts] <= [llength $moptions] } { | |
| foreach j $moptions { | |
| # see if all the -m<foo> options match any of the multilibs | |
| verbose "Looking in $i for $j" 3 | |
| if { [lsearch -exact $opts $j] >= 0 } { | |
| incr hits | |
| } | |
| } | |
| if { $hits > $best } { | |
| verbose "[lindex $i 0] is better, using as gcc path" 2 | |
| set gccpath "[lindex $i 0]" | |
| set best $hits | |
| } | |
| } | |
| } | |
| if {![info exists multitop]} { | |
| return "" | |
| } | |
| verbose "gccpath is $gccpath" 3 | |
| if {[file exists [file join $multitop $gccpath]]} { | |
| verbose "GCC path is $multitop/$gccpath" 3 | |
| if { [llength $args] == 0 } { | |
| set board_info($target_board,multitop) $multitop/$gccpath | |
| } | |
| return $multitop/$gccpath | |
| } else { | |
| verbose "GCC path is $multitop" 3 | |
| if { [llength $args] == 0 } { | |
| set board_info($target_board,multitop) $multitop | |
| } | |
| return $multitop | |
| } | |
| } | |
| proc find_binutils_prog { name } { | |
| global tool_root_dir | |
| if {![isremote host]} { | |
| set file [lookfor_file $tool_root_dir $name] | |
| if { $file eq "" } { | |
| set file [lookfor_file $tool_root_dir $name-new] | |
| } | |
| if { $file eq "" } { | |
| set file [lookfor_file $tool_root_dir binutils/$name] | |
| } | |
| if { $file eq "" } { | |
| set file [lookfor_file $tool_root_dir binutils/$name-new] | |
| } | |
| if { $file ne "" } { | |
| set NAME $file | |
| } else { | |
| set NAME [transform $name] | |
| } | |
| } else { | |
| set NAME [transform $name] | |
| } | |
| return $NAME | |
| } | |
| proc find_gcc {} { | |
| global tool_root_dir | |
| if {![isremote host]} { | |
| set file [lookfor_file $tool_root_dir xgcc] | |
| if { $file eq "" } { | |
| set file [lookfor_file $tool_root_dir gcc/xgcc] | |
| } | |
| if { $file ne "" } { | |
| set CC "$file -B[file dirname $file]/" | |
| } else { | |
| set CC [transform gcc] | |
| } | |
| } else { | |
| set CC [transform gcc] | |
| } | |
| return $CC | |
| } | |
| proc find_gcj {} { | |
| global tool_root_dir | |
| if {![isremote host]} { | |
| set file [lookfor_file $tool_root_dir gcj] | |
| if { $file eq "" } { | |
| set file [lookfor_file $tool_root_dir gcc/gcj] | |
| } | |
| if { $file ne "" } { | |
| set CC "$file -B[file dirname $file]/" | |
| } else { | |
| set CC [transform gcj] | |
| } | |
| } else { | |
| set CC [transform gcj] | |
| } | |
| return $CC | |
| } | |
| proc find_g++ {} { | |
| global tool_root_dir | |
| if {![isremote host]} { | |
| set file [lookfor_file $tool_root_dir xg++] | |
| if { $file eq "" } { | |
| set file [lookfor_file $tool_root_dir gcc/xg++] | |
| } | |
| if { $file eq "" } { | |
| set file [lookfor_file $tool_root_dir g++] | |
| } | |
| if { $file ne "" } { | |
| set CC "$file -B[file dirname $file]/" | |
| } else { | |
| set CC [transform g++] | |
| } | |
| } else { | |
| set CC [transform g++] | |
| } | |
| return $CC | |
| } | |
| proc find_gdc {} { | |
| global tool_root_dir | |
| if {![isremote host]} { | |
| set file [lookfor_file $tool_root_dir gdc] | |
| if { $file eq "" } { | |
| set file [lookfor_file $tool_root_dir gcc/gdc] | |
| } | |
| if { $file ne "" } { | |
| set CC "$file -B[file dirname $file]/" | |
| } else { | |
| set CC [transform gdc] | |
| } | |
| } else { | |
| set CC [transform gdc] | |
| } | |
| return $CC | |
| } | |
| proc find_g77 {} { | |
| global tool_root_dir | |
| if {![isremote host]} { | |
| set file [lookfor_file $tool_root_dir g77] | |
| if { $file eq "" } { | |
| set file [lookfor_file $tool_root_dir gcc/g77] | |
| } | |
| if { $file ne "" } { | |
| set CC "$file -B[file dirname $file]/" | |
| } else { | |
| set CC [transform g77] | |
| } | |
| } else { | |
| set CC [transform g77] | |
| } | |
| return $CC | |
| } | |
| proc find_gfortran {} { | |
| global tool_root_dir | |
| if {![isremote host]} { | |
| set file [lookfor_file $tool_root_dir gfortran] | |
| if { $file eq "" } { | |
| set file [lookfor_file $tool_root_dir gcc/gfortran] | |
| } | |
| if { $file ne "" } { | |
| set CC "$file -B[file dirname $file]/" | |
| } else { | |
| set CC [transform gfortran] | |
| } | |
| } else { | |
| set CC [transform gfortran] | |
| } | |
| return $CC | |
| } | |
| proc find_gnatmake {} { | |
| global tool_root_dir | |
| if {![isremote host]} { | |
| set file [lookfor_file $tool_root_dir gnatmake] | |
| if { $file eq "" } { | |
| set file [lookfor_file $tool_root_dir gcc/gnatmake] | |
| } | |
| if { $file ne "" } { | |
| set root [file dirname $file] | |
| set CC "$file -I$root/ada/rts --GCC=$root/xgcc --GNATBIND=$root/gnatbind --GNATLINK=$root/gnatlink -cargs -B$root -largs --GCC=$root/xgcc -B$root -margs" | |
| } else { | |
| set CC [transform gnatmake] | |
| } | |
| } else { | |
| set CC [transform gnatmake] | |
| } | |
| return $CC | |
| } | |
| proc find_go {} { | |
| global tool_root_dir | |
| set GO "" | |
| if {![is_remote host]} { | |
| set file [lookfor_file $tool_root_dir gccgo] | |
| if { $file ne "" } { | |
| set root [file dirname $file] | |
| set GO "$file -B$root/gcc/" | |
| } | |
| } | |
| if { $GO eq "" } { | |
| set GO [transform gccgo] | |
| } | |
| return $GO | |
| } | |
| proc find_go_linker {} { | |
| return [find_go] | |
| } | |
| proc find_rustc {} { | |
| global tool_root_dir | |
| if {![is_remote host]} { | |
| set rustc [lookfor_file $tool_root_dir rustc] | |
| if {$rustc eq ""} { | |
| set rustc rustc | |
| } | |
| } else { | |
| set rustc "" | |
| } | |
| if {$rustc ne ""} { | |
| append rustc " --color never" | |
| } | |
| return $rustc | |
| } | |
| proc find_nm {} { | |
| global tool_root_dir | |
| set NM "" | |
| if {![isremote host]} { | |
| set NM [lookfor_file $tool_root_dir nm-new] | |
| if {$NM eq ""} { | |
| set NM [lookfor_file $tool_root_dir binutils/nm-new] | |
| } | |
| } | |
| if { $NM eq ""} { | |
| set NM [transform nm] | |
| } | |
| return $NM | |
| } | |
| proc process_multilib_options { args } { | |
| global board | |
| global board_variant_list | |
| global is_gdb_remote | |
| set is_gdb_remote 0 | |
| if {[board_info $board exists multilib_flags]} { | |
| return | |
| } | |
| eval add_multilib_option $args | |
| set multilib_flags "" | |
| foreach x $board_variant_list { | |
| regsub -all "^\[ \t\]*" $x "" x | |
| regsub -all "\[ \t\]*$" $x "" x | |
| if { $x eq "" } { | |
| continue | |
| } | |
| switch -glob -- $x { | |
| "aout" { | |
| set_board_info obj_format "a.out" | |
| } | |
| "elf" { | |
| set_board_info obj_format "elf" | |
| } | |
| "pe" { | |
| set_board_info obj_format "pe" | |
| } | |
| "ecoff" { | |
| set_board_info obj_format "ecoff" | |
| } | |
| "stabs" { | |
| set_board_info debug_flags "-gstabs" | |
| } | |
| "dwarf2" { | |
| set_board_info debug_flags "-gdwarf2" | |
| } | |
| "gdb:*=*" { | |
| regsub "^gdb:\[^=\]*=(.*)$" $x "\\1" value | |
| regsub "^gdb:(\[^=\]*)=.*$" $x "\\1" variable | |
| set_board_info $variable $value | |
| } | |
| "gdb*remote" { | |
| set is_gdb_remote 1 | |
| } | |
| "little*endian" - | |
| "el" - | |
| "EL" { | |
| append multilib_flags " -EL" | |
| } | |
| "big*endian" - | |
| "eb" - | |
| "EB" { | |
| append multilib_flags " -EB" | |
| } | |
| "soft*float" { | |
| append multilib_flags " -msoft-float" | |
| } | |
| "-*" { | |
| append multilib_flags " $x" | |
| } | |
| default { | |
| append multilib_flags " -m$x" | |
| } | |
| } | |
| } | |
| set_board_info multilib_flags $multilib_flags | |
| } | |
| proc add_multilib_option { args } { | |
| global board_variant_list | |
| if {![info exists board_variant_list]} { | |
| set board_variant_list "" | |
| } | |
| set board_variant_list [concat $args $board_variant_list] | |
| } | |
| proc find_gas { } { | |
| global tool_root_dir | |
| set AS "" | |
| if {![isremote host]} { | |
| set AS [lookfor_file $tool_root_dir as-new] | |
| if { $AS eq "" } { | |
| set AS [lookfor_file $tool_root_dir gas/as-new] | |
| } | |
| } | |
| if { $AS eq "" } { | |
| set AS [transform as] | |
| } | |
| return $AS | |
| } | |
| proc find_ld { } { | |
| global tool_root_dir | |
| set LD "" | |
| if {![isremote host]} { | |
| set LD [lookfor_file $tool_root_dir ld-new] | |
| if { $LD eq "" } { | |
| set LD [lookfor_file $tool_root_dir ld/ld-new] | |
| } | |
| } | |
| if { $LD eq "" } { | |
| set LD [transform ld] | |
| } | |
| return $LD | |
| } | |
| proc build_wrapper { gluefile } { | |
| global libdir | |
| global tool | |
| if {[target_info exists wrap_m68k_aout]} { | |
| set flags "additional_flags=-DWRAP_M68K_AOUT" | |
| set result "" | |
| } elseif {[target_info exists uses_underscores]} { | |
| set flags "additional_flags=-DUNDERSCORES" | |
| set result "-Wl,-wrap,_exit -Wl,-wrap,__exit -Wl,-wrap,_main -Wl,-wrap,_abort" | |
| } else { | |
| set flags "" | |
| if {[target_info exists is_vxworks]} { | |
| set flags "additional_flags=-DVXWORKS" | |
| set result "-Wl,-wrap,exit -Wl,-wrap,_exit -Wl,-wrap,main -Wl,-wrap,abort" | |
| } else { | |
| set result "-Wl,-wrap,exit -Wl,-wrap,_exit -Wl,-wrap,main -Wl,-wrap,abort" | |
| } | |
| } | |
| if {[target_info exists wrap_compile_flags]} { | |
| lappend flags "additional_flags=[target_info wrap_compile_flags]" | |
| } | |
| if { [target_compile $libdir/testglue.c $gluefile object $flags] eq "" } { | |
| set gluefile [remote_download host $gluefile ${tool}_tg.o] | |
| return [list $gluefile $result] | |
| } else { | |
| return "" | |
| } | |
| } | |
| proc winsup_include_flags { args } { | |
| global srcdir | |
| if {[isnative]} { | |
| return "" | |
| } | |
| if {[isremote host]} { | |
| return "" | |
| } | |
| set gccpath "[get_multilibs]" | |
| if {[file exists [file join $gccpath winsup]]} { | |
| verbose "Winsup path is $gccpath/winsup" | |
| set winsup_dir [lookfor_file $srcdir winsup/include/windows.h] | |
| if { $winsup_dir ne "" } { | |
| set winsup_dir [file dirname $winsup_dir] | |
| # See comment in libio_include_flags about using -I. | |
| return " -I$winsup_dir" | |
| } | |
| } | |
| verbose "No winsup support for this target" | |
| } | |
| # Find the winsup libraries in the current source tree. | |
| # | |
| proc winsup_link_flags { args } { | |
| # libgloss doesn't work native | |
| if {[isnative]} { | |
| return "" | |
| } | |
| # if we're on a remote host, we can't search for the file, so we can only | |
| # use an installed compiler, so we don't add any paths here. | |
| if {[isremote host]} { | |
| return "" | |
| } | |
| set gccpath "[get_multilibs]" | |
| verbose "Looking for $gccpath/winsup" | |
| if {[file exists [file join $gccpath winsup]]} { | |
| verbose "Winsup path is $gccpath/newlib" | |
| return "-B$gccpath/winsup/ -L$gccpath/winsup" | |
| } else { | |
| verbose "No winsup support for this target" | |
| return "" | |
| } | |
| } |