forked from Imagelibrary/binutils-gdb
b55f906577
Currently, gnat-llvm does not ship a shared libgnat. This patch changes the relevant test to check whether linking with -shared actually works.
301 lines
8.9 KiB
Plaintext
301 lines
8.9 KiB
Plaintext
# Copyright 2004-2024 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 this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
# A wrapper for foreach_with_prefix that applies suitable
|
|
# -fgnat-encodings arguments to a command line. SCENARIO_ARG is the
|
|
# name of a loop variable that will hold the scenario currently being
|
|
# evaluated. FLAGS_ARG will be set to the appropriate compiler flags
|
|
# (if any) for this scenario. LIST is the list of desired scenarios
|
|
# to run, and BODY is what actually does the work.
|
|
|
|
proc foreach_gnat_encoding {scenario_arg flags_arg list body} {
|
|
# gnat-llvm does not understand -fgnat-encodings at all. However,
|
|
# some tests examine the precise setting of the scenario -- so
|
|
# pretend we support minimal. What is going on here is that for
|
|
# gnat-llvm, there are no "GNAT encodings", only minimal
|
|
# encodings, aka, real DWARF.
|
|
set has_flag [ada_minimal_encodings]
|
|
if {!$has_flag} {
|
|
set list minimal
|
|
}
|
|
|
|
upvar 1 $scenario_arg scenario
|
|
upvar 1 $flags_arg flags
|
|
foreach_with_prefix scenario $list {
|
|
set flags {}
|
|
if {$scenario != "none" && $has_flag} {
|
|
lappend flags additional_flags=-fgnat-encodings=$scenario
|
|
}
|
|
uplevel 1 $body
|
|
}
|
|
}
|
|
|
|
# Call target_compile with SOURCE DEST TYPE and OPTIONS as argument,
|
|
# after having temporarily changed the current working directory to
|
|
# BUILDDIR.
|
|
|
|
proc target_compile_ada_from_dir {builddir source dest type options} {
|
|
global board
|
|
set board [target_info name]
|
|
set save_multilib_flag [board_info $board multilib_flags]
|
|
set multilib_flag ""
|
|
foreach op $save_multilib_flag {
|
|
if { $op == "-pie" || $op == "-no-pie" } {
|
|
# Pretend gnatmake supports -pie/-no-pie, route it to
|
|
# linker.
|
|
append multilib_flag " -largs $op -margs"
|
|
} else {
|
|
append multilib_flag " $op"
|
|
}
|
|
}
|
|
if { $multilib_flag != "" } {
|
|
unset_board_info "multilib_flags"
|
|
set_board_info multilib_flags "$multilib_flag"
|
|
}
|
|
|
|
catch {
|
|
with_cwd $builddir {
|
|
return [target_compile $source $dest $type $options]
|
|
}
|
|
} result options
|
|
|
|
if { $save_multilib_flag != "" } {
|
|
unset_board_info "multilib_flags"
|
|
set_board_info multilib_flags $save_multilib_flag
|
|
}
|
|
|
|
return -options $options $result
|
|
}
|
|
|
|
# Compile some Ada code. Return "" if the compile was successful.
|
|
# OPTIONS are as for target_compile, but with this addition:
|
|
# "no-force" - do not pass -f to gnatmake. By default -f is
|
|
# used, forcing a full recompilation.
|
|
|
|
proc gdb_compile_ada_1 {source dest type options} {
|
|
|
|
set srcdir [file dirname $source]
|
|
set gprdir [file dirname $srcdir]
|
|
set objdir [file dirname $dest]
|
|
|
|
file delete $dest
|
|
|
|
# Although strictly not necessary, we force the recompilation
|
|
# of all units (additional_flags=-f). This is what is done
|
|
# when using GCC to build programs in the other languages,
|
|
# and it avoids using a stray objfile file from a long-past
|
|
# run, for instance.
|
|
append options " ada"
|
|
if {[lsearch -exact $options no-force] == -1} {
|
|
append options " additional_flags=-f"
|
|
}
|
|
append options " additional_flags=-I$srcdir"
|
|
|
|
set result [target_compile_ada_from_dir \
|
|
$objdir [file tail $source] $dest $type $options]
|
|
|
|
# The Ada build always produces some output, even when the build
|
|
# succeeds. Thus, we can not use the output the same way we do in
|
|
# gdb_compile to determine whether the build has succeeded or not.
|
|
# We therefore simply check whether the dest file has been created
|
|
# or not. Unless not present, the build has succeeded.
|
|
if [file exists $dest] { set result "" }
|
|
return $result
|
|
}
|
|
|
|
# Compile some Ada code. Generate "PASS: foo.exp: compilation SOURCE" if the
|
|
# compile was successful.
|
|
|
|
proc gdb_compile_ada {source dest type options} {
|
|
set result [gdb_compile_ada_1 $source $dest $type $options]
|
|
|
|
gdb_compile_test $source $result
|
|
return $result
|
|
}
|
|
|
|
# Like standard_testfile, but for Ada. Historically the Ada tests
|
|
# used a different naming convention from many of the other gdb tests,
|
|
# and this difference was preserved during the conversion to
|
|
# standard_testfile. DIR defaults to the base name of the test case;
|
|
# but can be overridden to find sources in a different subdirectory of
|
|
# gdb.ada.
|
|
|
|
proc standard_ada_testfile {base_file {dir ""}} {
|
|
global gdb_test_file_name srcdir subdir
|
|
global testdir testfile srcfile binfile
|
|
|
|
if {$dir == ""} {
|
|
set testdir $gdb_test_file_name
|
|
} else {
|
|
set testdir $dir
|
|
}
|
|
|
|
set testfile $base_file
|
|
set srcfile $srcdir/$subdir/$testdir/$testfile.adb
|
|
set binfile [standard_output_file $testfile]
|
|
}
|
|
|
|
# A helper function to find the appropriate version of a tool.
|
|
# TOOL is the tool's name, e.g., "gnatbind" or "gnatlink".
|
|
|
|
proc find_ada_tool {tool} {
|
|
set upper [string toupper $tool]
|
|
|
|
set targname ${upper}_FOR_TARGET
|
|
global $targname
|
|
if {[info exists $targname]} {
|
|
return $targname
|
|
}
|
|
|
|
global tool_root_dir
|
|
set root "$tool_root_dir/gcc"
|
|
set result ""
|
|
|
|
if {![is_remote host]} {
|
|
set result [lookfor_file $root $tool]
|
|
if { $result != "" && $tool == "gnatlink" } {
|
|
set result "$result --GCC=$root/xgcc -B$root"
|
|
}
|
|
}
|
|
|
|
if {$result == ""} {
|
|
set result [transform $tool]
|
|
}
|
|
|
|
return $result
|
|
}
|
|
|
|
# Compare the GNAT version against L2 using version_compare. If the
|
|
# compiler does not appear to be GCC, this will always return false.
|
|
|
|
proc gnat_version_compare {op l2} {
|
|
set gccvers [gcc_major_version]
|
|
if {$gccvers == -1} {
|
|
return 0
|
|
}
|
|
|
|
return [version_compare [split $gccvers .] $op $l2]
|
|
}
|
|
|
|
# Return 1 if the GNAT runtime appears to have debug info.
|
|
|
|
proc gnat_runtime_has_debug_info_1 { shared } {
|
|
if { ![allow_ada_tests] } {
|
|
return 0
|
|
}
|
|
|
|
global srcdir
|
|
|
|
set src "$srcdir/lib/gnat_debug_info_test.adb"
|
|
set dst [standard_output_file "gnat_debug_info_test"]
|
|
|
|
set opts {}
|
|
lappend opts debug
|
|
if { $shared } {
|
|
# Make sure we link against the shared GNAT run time.
|
|
set gnatbind_options [list -bargs -shared -margs]
|
|
|
|
foreach option $gnatbind_options {
|
|
lappend opts [concat "additional_flags=" $option]
|
|
}
|
|
}
|
|
|
|
if { [gdb_compile_ada_1 $src $dst executable $opts] != "" } {
|
|
return 0
|
|
}
|
|
|
|
clean_restart $dst
|
|
|
|
if { ! [runto "GNAT_Debug_Info_Test"] } {
|
|
return 0
|
|
}
|
|
|
|
set has_debug_info 0
|
|
|
|
gdb_test_multiple "whatis __gnat_debug_raise_exception" "" {
|
|
-re -wrap "type = <text variable, no debug info>" { }
|
|
-re -wrap "type = void" {
|
|
set has_debug_info 1
|
|
}
|
|
default {
|
|
# Some other unexpected output...
|
|
fail $gdb_test_name
|
|
}
|
|
}
|
|
|
|
gdb_exit
|
|
|
|
return $has_debug_info
|
|
}
|
|
|
|
# Return 1 if the static GNAT runtime appears to have debug info.
|
|
|
|
gdb_caching_proc gnat_runtime_has_debug_info {} {
|
|
return [gnat_runtime_has_debug_info_1 0]
|
|
}
|
|
|
|
# Return 1 if the shared GNAT runtime appears to have debug info.
|
|
|
|
gdb_caching_proc shared_gnat_runtime_has_debug_info {} {
|
|
return [gnat_runtime_has_debug_info_1 1]
|
|
}
|
|
|
|
# A helper that writes an Ada source file, then tries to compile it
|
|
# with the given compiler options (a list like one accepted by
|
|
# gdb_compile_ada). Returns 1 if the flags are supported, 0
|
|
# otherwise.
|
|
proc ada_simple_compile {name options} {
|
|
set src [standard_temp_file $name.adb]
|
|
set dest [standard_temp_file $name.x]
|
|
set f [open $src w]
|
|
puts $f "procedure $name is"
|
|
puts $f "begin"
|
|
puts $f " null;"
|
|
puts $f "end $name;"
|
|
close $f
|
|
|
|
# Note that we create an executable here. For -fvar-tracking, at
|
|
# least, the option is supported and ignored by llvm-gnatmake --
|
|
# but then is passed to clang during further compilation, and this
|
|
# fails. So to detect it we can't just stop with a .o file.
|
|
set output [gdb_compile_ada_1 $src $dest executable $options]
|
|
return [expr {[gdb_compile_test_nofail $output] == 1}]
|
|
}
|
|
|
|
# Return 1 if GNAT supports -fvar-tracking.
|
|
gdb_caching_proc ada_fvar_tracking {} {
|
|
return [ada_simple_compile fvar_tracking additional_flags=-fvar-tracking]
|
|
}
|
|
|
|
# Return 1 if GNAT supports the minimal encodings option.
|
|
gdb_caching_proc ada_minimal_encodings {} {
|
|
return [ada_simple_compile minimal_encodings \
|
|
additional_flags=-fgnat-encodings=minimal]
|
|
}
|
|
|
|
# Return 1 if GNAT supports -Og.
|
|
gdb_caching_proc ada_og {} {
|
|
return [ada_simple_compile gnat_og additional_flags=-Og]
|
|
}
|
|
|
|
# Return 1 if GNAT can link with -shared.
|
|
gdb_caching_proc ada_shared_link {} {
|
|
return [ada_simple_compile ada_shared_link {
|
|
additional_flags=-bargs
|
|
additional_flags=-shared
|
|
additional_flags=-margs
|
|
}]
|
|
}
|