gdb/testsuite/gdb.hp/gdb.base-hp/so-thresh.exp - binutils-gdb - Git at Google

 #   Copyright (C) 1997, 1998 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 2 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, write to the Free Software
 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

 # Please email any bugs, comments, and/or additions to this file to:
 # bug-gdb@prep.ai.mit.edu

 if $tracelevel then {
 	strace $tracelevel
 	}

 set prms_id 0
 set bug_id 0

 if { [skip_hp_tests] } then { continue }

 set testfile "so-thresh"
 set binfile ${objdir}/${subdir}/${testfile}

 if [get_compiler_info ${binfile}] {
     return -1
 }

 # This testcase is relatively large, and therefore can take awhile to
 # load.  We'd best set the timeout to something suitable, or we may
 # seem to fail...
 #
 set timeout 60

 # Build procedure for this testcase:
 #    ${srcdir}/${subdir}/so-thresh.sh ${subdir}
 #        which calls,
 #        make -f ${srcdir}/${subdir}/so-thresh.mk <targets> <macros>
 #            which builds,
 #                genso-thresh (from genso-thresh.c)
 #                    which generates,
 #                        lib00-so-thresh.c
 #                        lib01-so-thresh.c
 #                        lib02-so-thresh.c
 #                        so-thresh.lopt (link options file)
 #                lib0*-so-thresh.sl (from .c files above)
 #                so-thresh (from so-thresh.c)
 #                    using lib0*-so-thresh.sl and so-thresh.lopt
 #
 # Since so-thresh.mk requires SRCDIR and OBJDIR macro definitions,
 # and SRCDIR / OBJDIR could be in relative path format, we use
 # so-thresh.sh script to pin down SRCDIR / OBJDIR (using $PWD/ prefix
 # when detected relative path values for srcdir / objdir), before the
 # 'cd $subdir' call (when this can be done in TCL here, we can call
 # make directly instead).
 #
 # remote_exec build "sh -c \\\"cd ${objdir}/${subdir}\\; make -v -f ${srcdir}/${subdir}/${testfile}.mk clean require_shlibs all SRCDIR=${srcdir}/${subdir} OBJDIR=${objdir}/${subdir}\\\""

 remote_exec build "${srcdir}/${subdir}/${testfile}.sh $subdir"

 # Only HP-UX (and any other platforms using SOM shared libraries, I
 # guess) interprets the auto-solib-limit variable as a threshhold,
 # rather than a boolean that strictly enables or disables automatic
 # loading of shlib symbol tables.
 #
 # On HP-UX, it is the size threshhold (in megabytes) at which to
 # stop auto loading of symbol tables.
 #
 if ![istarget "hppa*-hp-hpux*"] then {
    setup_xfail "*-*-*"
 }

 # Start with a fresh gdb
 #
 gdb_exit
 gdb_start
 gdb_reinitialize_dir $srcdir/$subdir
 gdb_load ${binfile}

 # This is a test of gdb's ability on HP-UX to stop automatically
 # loading symbols of shared libraries, when the total size of the
 # debugger's symbol table reaches a specified threshhold.
 #

 # On HP-UX, the help text for auto-solib-limit mentions that it
 # serves as a threshhold.
 #
 send_gdb "help set auto-solib-limit\n"
 gdb_expect {
   -re "Set threshold .in Mb. for autoloading shared library symbols.*
 When shared library autoloading is enabled, new libraries will be loaded.*
 only until the total size of shared library symbols exceeds this.*
 threshold in megabytes.  Is ignored when using .sharedlibrary.*$gdb_prompt $"\
           {pass "help set auto-solib-limit"}
   -re "$gdb_prompt $"\
           {fail "help set auto-solib-limit"}
   timeout {fail "(timeout) help set auto-solib-limit"}
 }

 # On HP-UX, the threshhold is by default set to 50, which means
 # 50 megabytes.
 #
 send_gdb "show auto-solib-limit\n"
 gdb_expect {
   -re "Threshold .in Mb. for autoloading shared library symbols is $decimal.*$gdb_prompt $"\
           {pass "show auto-solib-limit "}
   -re "$gdb_prompt $"\
           {fail "show auto-solib-limit "}
   timeout {fail "(timeout) show auto-solib-limit "}
 }

 send_gdb "set auto-solib-limit 1\n"
 gdb_expect {
    -re ".*$gdb_prompt $"
             {pass "set auto-solib-limit to 1"}
    -re ".*$gdb_prompt $"
             {fail "set auto-solib-limit to 1"}
    timeout {fail "(timeout) set auto-solib-limit to 1"}
 }


 # We have manually verified that our testcase exceeds 1 Mbytes
 # of heap space in GDB to hold the symbols for the main program
 # and all associated linked-against libraries.  Thus, when we
 # run to the program's main, and therefore notice all the linked-
 # against shlibs, we expect to hit the threshhold.
 #
 # (Note that we're not using the expect [runto main] function here,
 # 'cause we want to match on output from the run command.
 #
 send_gdb "break main\n"
 gdb_expect {
   -re "Breakpoint \[0-9\]* at.*$gdb_prompt $"\
           {pass "1 set break at main"}
   -re "$gdb_prompt $"\
           {fail "1 set break at main"}
   timeout {fail "(timeout) 1 set break at main"}
 }

 send_gdb "run\n"
 gdb_expect {
   -re ".*warning. Symbols for some libraries have not been loaded, because.*
 doing so would exceed the size threshold specified by auto-solib-limit.*
 To manually load symbols, use the 'sharedlibrary' command.*
 To raise the threshold, set auto-solib-limit to a larger value and rerun.*
 the program.*$gdb_prompt $"\
           {pass "run to main hit auto-solib-limit threshold"}
   -re "$gdb_prompt $"\
           {fail "run to main hit auto-solib-limit threshold"}
   timeout {fail "(timeout) run to main hit auto-solib-limit threshold"}
 }

 # Verify that "info share" mentions something about libraries whose
 # symbols weren't loaded.
 #
 # We'll assume that at least the last two shlib's symbols weren't
 # loaded.  As a side-effect of matching this pattern, the text start
 # address of the last one is captured in expect_out(1,string).
 # (we'll need it for the 'add-symbol-file' command in a nonce...)
 #
 send_gdb "info sharedlibrary\n"
 gdb_expect {
   -re ".*lib01_$testfile.sl .*symbols not loaded.*0x\[0-9\]*  (0x\[0-9a-fA-F\]*).*$gdb_prompt $"\
           { send_gdb "add-symbol-file lib02_$testfile.sl $expect_out(1,string)\n"
             gdb_expect {
               -re "add symbol table.*y or n.*$"\
                       {send_gdb "y\n"
                        gdb_expect {
                          -re "$gdb_prompt $" {pass "add-symbol-file and info sharedlib"}
                          timeout {fail "(timeout) add-symbol-file and info sharedlib"}
                        }}
               -re "$gdb_prompt $"\
                       {fail "add-symbol-file and info sharedlib"}
               timeout {fail "(timeout) add-symbol-file and info sharedlib"}
             }
           }
   -re "$gdb_prompt $" {
 	setup_xfail hppa*-*-* CHFts24108
 	fail "info sharedlibrary shows shlibs with unloaded symbols"
     }
   timeout {fail "(timeout) info sharedlibrary shows shlibs with unloaded symbols"}
 }

 # Verify that we can manually load the symbol table of a library
 # whose symbols weren't loaded.  (We'll pick the last one.)
 #

 # I moved this test inside the one above, because the expect_out array is not ok if the
 # previous test has failed, and expect would error out (elz)
 #
 #send_gdb "add-symbol-file lib02_$testfile.sl $expect_out(1,string)\n"
 #gdb_expect {
 #  -re "add symbol table.*y or n.*$"\
 #          {send_gdb "y\n"
 #           gdb_expect {
 #             -re "$gdb_prompt $" {pass "add-symbol-file"}
 #             timeout {fail "(timeout) add-symbol-file"}
 #           }}
 #  -re "$gdb_prompt $"\
 #          {fail "add-symbol-file"}
 #  timeout {fail "(timeout) add-symbol-file"}
 #}

 # Verify that we can manually load the symbols for all libraries
 # which weren't already loaded.
 #
 # Warning!  On a machine with little free swap space, this may
 # fail!
 #
 send_gdb "sharedlibrary\n"
 gdb_expect {
   -re "Reading symbols from.*done.*$gdb_prompt $"\
           {pass "sharedlibrary"}
   -re "$gdb_prompt $" {
 	setup_xfail hppa*-*-* CHFts24108
 	fail "sharedlibrary"
     }
   timeout {fail "(timeout) sharedlibrary"}
 }

 # Rerun the program, this time verifying that we can set the
 # threshhold high enough to avoid hitting it.
 #
 # It appears that gdb isn't freeing memory when rerunning, as one
 # would expect.  To avoid potentially hitting a virtual memory
 # ceiling, start with a fresh gdb.
 #
 gdb_exit
 gdb_start
 gdb_reinitialize_dir $srcdir/$subdir
 gdb_load ${binfile}

 send_gdb "break main\n"
 gdb_expect {
   -re "Breakpoint \[0-9\]* at.*$gdb_prompt $"\
           {pass "2 set break at main"}
   -re "$gdb_prompt $"\
           {fail "2 set break at main"}
   timeout {fail "(timeout) 2 set break at main"}
 }

 send_gdb "set auto-solib-limit 9999\n"
 gdb_expect {
   -re "$gdb_prompt $"\
           {pass "set auto-solib-limit threshold to practical infinity"}
   timeout {fail "(timeout) set auto-solib-limit threshold to practical infinity"}
 }
 send_gdb "run\n"
 gdb_expect {
   -re ".*warning. Symbols for some libraries have not been loaded, because.*
 doing so would exceed the size threshold specified by auto-solib-limit.*
 To manually load symbols, use the 'sharedlibrary' command.*
 To raise the threshold, set auto-solib-limit to a larger value and rerun.*
 the program.*$gdb_prompt $"\
           {fail "rerun threshold at practical infinity (still hit threshold)"}
   -re "$gdb_prompt $"\
           {pass "rerun with threshold at practical infinity"}
   timeout {fail "(timeout) rerun with threshold at practical infinity"}
 }

 # Rerun the program, this time altogether disabling the auto loading
 # feature.  There should be no information at all about shared
 # libraries now.
 #
 # ??rehrauer: Personally, I'd call that a bug, since it doesn't give
 # you the ability to manually load single shlibs (you need the text
 # start address that 'info share' normall gives you).  On the other
 # hand, one can easily choose to load them all...
 #
 # It appears that gdb isn't freeing memory when rerunning, as one
 # would expect.  To avoid potentially hitting a virtual memory
 # ceiling, start with a fresh gdb.
 #
 gdb_exit
 gdb_start
 gdb_reinitialize_dir $srcdir/$subdir
 gdb_load ${binfile}

 send_gdb "break main\n"
 gdb_expect {
   -re "Breakpoint \[0-9\]* at.*$gdb_prompt $"\
           {pass "3 set break at main"}
   -re "$gdb_prompt $"\
           {fail "3 set break at main"}
   timeout {fail "(timeout) 3 set break at main"}
 }

 send_gdb "set auto-solib-limit 0\n"
 gdb_expect {
   -re "$gdb_prompt $"\
           {pass "set auto-solib-limit threshold to 0"}
   timeout {fail "(timeout) set auto-solib-limit threshold to 0"}
 }
 send_gdb "run\n"
 gdb_expect {
   -re ".*warning. Symbols for some libraries have not been loaded, because.*
 doing so would exceed the size threshold specified by auto-solib-limit.*
 To manually load symbols, use the 'sharedlibrary' command.*
 To raise the threshold, set auto-solib-limit to a larger value and rerun.*
 the program.*$gdb_prompt $"\
           {fail "rerun threshold at 0 (still hit threshold)"}
   -re "$gdb_prompt $"\
           {pass "rerun with threshold at 0"}
   timeout {fail "(timeout) rerun with threshold at 0"}
 }

 # Verify that we can still manually load symbols for all libraries.
 # (We'll assume that if the last shlib's symbols are loaded, that
 # all of them were.)
 #
 # Note that we set the GDB "height" variable to prevent GDB from
 # prompting
 #
 # Warning!  On a machine with little free swap space, this may
 # fail!
 #
 send_gdb "set height 9999\n"
 gdb_expect {
   -re "$gdb_prompt $"\
           {pass "set screen page height to practical infinity"}
   timeout {fail "(timeout) set screen page height to practical infinity"}
 }
 send_gdb "sharedlibrary\n"
 gdb_expect {
   -re ".*Reading symbols from .*/lib02-so-thresh\\.sl\\.\\.\\.done\\..*$gdb_prompt $"\
           {pass "manually load all symbols"}
   -re "$gdb_prompt $" {
 	setup_xfail hppa*-*-* CHFts24108
 	fail "manually load all symbols (CHFts24108)"
     }
   timeout {fail "(timeout) manually load all symbols"}
 }

 return 0
	# Copyright (C) 1997, 1998 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 2 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, write to the Free Software
	# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */

	# Please email any bugs, comments, and/or additions to this file to:
	# bug-gdb@prep.ai.mit.edu

	if $tracelevel then {
	strace $tracelevel
	}

	set prms_id 0
	set bug_id 0

	if { [skip_hp_tests] } then { continue }

	set testfile "so-thresh"
	set binfile ${objdir}/${subdir}/${testfile}

	if [get_compiler_info ${binfile}] {
	return -1
	}

	# This testcase is relatively large, and therefore can take awhile to
	# load. We'd best set the timeout to something suitable, or we may
	# seem to fail...
	#
	set timeout 60

	# Build procedure for this testcase:
	# ${srcdir}/${subdir}/so-thresh.sh ${subdir}
	# which calls,
	# make -f ${srcdir}/${subdir}/so-thresh.mk <targets> <macros>
	# which builds,
	# genso-thresh (from genso-thresh.c)
	# which generates,
	# lib00-so-thresh.c
	# lib01-so-thresh.c
	# lib02-so-thresh.c
	# so-thresh.lopt (link options file)
	# lib0*-so-thresh.sl (from .c files above)
	# so-thresh (from so-thresh.c)
	# using lib0*-so-thresh.sl and so-thresh.lopt
	#
	# Since so-thresh.mk requires SRCDIR and OBJDIR macro definitions,
	# and SRCDIR / OBJDIR could be in relative path format, we use
	# so-thresh.sh script to pin down SRCDIR / OBJDIR (using $PWD/ prefix
	# when detected relative path values for srcdir / objdir), before the
	# 'cd $subdir' call (when this can be done in TCL here, we can call
	# make directly instead).
	#
	# remote_exec build "sh -c \\\"cd ${objdir}/${subdir}\\; make -v -f ${srcdir}/${subdir}/${testfile}.mk clean require_shlibs all SRCDIR=${srcdir}/${subdir} OBJDIR=${objdir}/${subdir}\\\""

	remote_exec build "${srcdir}/${subdir}/${testfile}.sh $subdir"

	# Only HP-UX (and any other platforms using SOM shared libraries, I
	# guess) interprets the auto-solib-limit variable as a threshhold,
	# rather than a boolean that strictly enables or disables automatic
	# loading of shlib symbol tables.
	#
	# On HP-UX, it is the size threshhold (in megabytes) at which to
	# stop auto loading of symbol tables.
	#
	if ![istarget "hppa-hp-hpux"] then {
	setup_xfail "--*"
	}

	# Start with a fresh gdb
	#
	gdb_exit
	gdb_start
	gdb_reinitialize_dir $srcdir/$subdir
	gdb_load ${binfile}

	# This is a test of gdb's ability on HP-UX to stop automatically
	# loading symbols of shared libraries, when the total size of the
	# debugger's symbol table reaches a specified threshhold.
	#

	# On HP-UX, the help text for auto-solib-limit mentions that it
	# serves as a threshhold.
	#
	send_gdb "help set auto-solib-limit\n"
	gdb_expect {
	-re "Set threshold .in Mb. for autoloading shared library symbols.*
	When shared library autoloading is enabled, new libraries will be loaded.*
	only until the total size of shared library symbols exceeds this.*
	threshold in megabytes. Is ignored when using .sharedlibrary.*$gdb_prompt $"\
	{pass "help set auto-solib-limit"}
	-re "$gdb_prompt $"\
	{fail "help set auto-solib-limit"}
	timeout {fail "(timeout) help set auto-solib-limit"}
	}

	# On HP-UX, the threshhold is by default set to 50, which means
	# 50 megabytes.
	#
	send_gdb "show auto-solib-limit\n"
	gdb_expect {
	-re "Threshold .in Mb. for autoloading shared library symbols is $decimal.*$gdb_prompt $"\
	{pass "show auto-solib-limit "}
	-re "$gdb_prompt $"\
	{fail "show auto-solib-limit "}
	timeout {fail "(timeout) show auto-solib-limit "}
	}

	send_gdb "set auto-solib-limit 1\n"
	gdb_expect {
	-re ".*$gdb_prompt $"
	{pass "set auto-solib-limit to 1"}
	-re ".*$gdb_prompt $"
	{fail "set auto-solib-limit to 1"}
	timeout {fail "(timeout) set auto-solib-limit to 1"}
	}


	# We have manually verified that our testcase exceeds 1 Mbytes
	# of heap space in GDB to hold the symbols for the main program
	# and all associated linked-against libraries. Thus, when we
	# run to the program's main, and therefore notice all the linked-
	# against shlibs, we expect to hit the threshhold.
	#
	# (Note that we're not using the expect [runto main] function here,
	# 'cause we want to match on output from the run command.
	#
	send_gdb "break main\n"
	gdb_expect {
	-re "Breakpoint \[0-9\]* at.*$gdb_prompt $"\
	{pass "1 set break at main"}
	-re "$gdb_prompt $"\
	{fail "1 set break at main"}
	timeout {fail "(timeout) 1 set break at main"}
	}

	send_gdb "run\n"
	gdb_expect {
	-re ".warning. Symbols for some libraries have not been loaded, because.
	doing so would exceed the size threshold specified by auto-solib-limit.*
	To manually load symbols, use the 'sharedlibrary' command.*
	To raise the threshold, set auto-solib-limit to a larger value and rerun.*
	the program.*$gdb_prompt $"\
	{pass "run to main hit auto-solib-limit threshold"}
	-re "$gdb_prompt $"\
	{fail "run to main hit auto-solib-limit threshold"}
	timeout {fail "(timeout) run to main hit auto-solib-limit threshold"}
	}

	# Verify that "info share" mentions something about libraries whose
	# symbols weren't loaded.
	#
	# We'll assume that at least the last two shlib's symbols weren't
	# loaded. As a side-effect of matching this pattern, the text start
	# address of the last one is captured in expect_out(1,string).
	# (we'll need it for the 'add-symbol-file' command in a nonce...)
	#
	send_gdb "info sharedlibrary\n"
	gdb_expect {
	-re ".lib01_$testfile.sl .symbols not loaded.0x\[0-9\] (0x\[0-9a-fA-F\]).$gdb_prompt $"\
	{ send_gdb "add-symbol-file lib02_$testfile.sl $expect_out(1,string)\n"
	gdb_expect {
	-re "add symbol table.y or n.$"\
	{send_gdb "y\n"
	gdb_expect {
	-re "$gdb_prompt $" {pass "add-symbol-file and info sharedlib"}
	timeout {fail "(timeout) add-symbol-file and info sharedlib"}
	}}
	-re "$gdb_prompt $"\
	{fail "add-symbol-file and info sharedlib"}
	timeout {fail "(timeout) add-symbol-file and info sharedlib"}
	}
	}
	-re "$gdb_prompt $" {
	setup_xfail hppa--* CHFts24108
	fail "info sharedlibrary shows shlibs with unloaded symbols"
	}
	timeout {fail "(timeout) info sharedlibrary shows shlibs with unloaded symbols"}
	}

	# Verify that we can manually load the symbol table of a library
	# whose symbols weren't loaded. (We'll pick the last one.)
	#

	# I moved this test inside the one above, because the expect_out array is not ok if the
	# previous test has failed, and expect would error out (elz)
	#
	#send_gdb "add-symbol-file lib02_$testfile.sl $expect_out(1,string)\n"
	#gdb_expect {
	# -re "add symbol table.y or n.$"\
	# {send_gdb "y\n"
	# gdb_expect {
	# -re "$gdb_prompt $" {pass "add-symbol-file"}
	# timeout {fail "(timeout) add-symbol-file"}
	# }}
	# -re "$gdb_prompt $"\
	# {fail "add-symbol-file"}
	# timeout {fail "(timeout) add-symbol-file"}
	#}

	# Verify that we can manually load the symbols for all libraries
	# which weren't already loaded.
	#
	# Warning! On a machine with little free swap space, this may
	# fail!
	#
	send_gdb "sharedlibrary\n"
	gdb_expect {
	-re "Reading symbols from.done.$gdb_prompt $"\
	{pass "sharedlibrary"}
	-re "$gdb_prompt $" {
	setup_xfail hppa--* CHFts24108
	fail "sharedlibrary"
	}
	timeout {fail "(timeout) sharedlibrary"}
	}

	# Rerun the program, this time verifying that we can set the
	# threshhold high enough to avoid hitting it.
	#
	# It appears that gdb isn't freeing memory when rerunning, as one
	# would expect. To avoid potentially hitting a virtual memory
	# ceiling, start with a fresh gdb.
	#
	gdb_exit
	gdb_start
	gdb_reinitialize_dir $srcdir/$subdir
	gdb_load ${binfile}

	send_gdb "break main\n"
	gdb_expect {
	-re "Breakpoint \[0-9\]* at.*$gdb_prompt $"\
	{pass "2 set break at main"}
	-re "$gdb_prompt $"\
	{fail "2 set break at main"}
	timeout {fail "(timeout) 2 set break at main"}
	}

	send_gdb "set auto-solib-limit 9999\n"
	gdb_expect {
	-re "$gdb_prompt $"\
	{pass "set auto-solib-limit threshold to practical infinity"}
	timeout {fail "(timeout) set auto-solib-limit threshold to practical infinity"}
	}
	send_gdb "run\n"
	gdb_expect {
	-re ".warning. Symbols for some libraries have not been loaded, because.
	doing so would exceed the size threshold specified by auto-solib-limit.*
	To manually load symbols, use the 'sharedlibrary' command.*
	To raise the threshold, set auto-solib-limit to a larger value and rerun.*
	the program.*$gdb_prompt $"\
	{fail "rerun threshold at practical infinity (still hit threshold)"}
	-re "$gdb_prompt $"\
	{pass "rerun with threshold at practical infinity"}
	timeout {fail "(timeout) rerun with threshold at practical infinity"}
	}

	# Rerun the program, this time altogether disabling the auto loading
	# feature. There should be no information at all about shared
	# libraries now.
	#
	# ??rehrauer: Personally, I'd call that a bug, since it doesn't give
	# you the ability to manually load single shlibs (you need the text
	# start address that 'info share' normall gives you). On the other
	# hand, one can easily choose to load them all...
	#
	# It appears that gdb isn't freeing memory when rerunning, as one
	# would expect. To avoid potentially hitting a virtual memory
	# ceiling, start with a fresh gdb.
	#
	gdb_exit
	gdb_start
	gdb_reinitialize_dir $srcdir/$subdir
	gdb_load ${binfile}

	send_gdb "break main\n"
	gdb_expect {
	-re "Breakpoint \[0-9\]* at.*$gdb_prompt $"\
	{pass "3 set break at main"}
	-re "$gdb_prompt $"\
	{fail "3 set break at main"}
	timeout {fail "(timeout) 3 set break at main"}
	}

	send_gdb "set auto-solib-limit 0\n"
	gdb_expect {
	-re "$gdb_prompt $"\
	{pass "set auto-solib-limit threshold to 0"}
	timeout {fail "(timeout) set auto-solib-limit threshold to 0"}
	}
	send_gdb "run\n"
	gdb_expect {
	-re ".warning. Symbols for some libraries have not been loaded, because.
	doing so would exceed the size threshold specified by auto-solib-limit.*
	To manually load symbols, use the 'sharedlibrary' command.*
	To raise the threshold, set auto-solib-limit to a larger value and rerun.*
	the program.*$gdb_prompt $"\
	{fail "rerun threshold at 0 (still hit threshold)"}
	-re "$gdb_prompt $"\
	{pass "rerun with threshold at 0"}
	timeout {fail "(timeout) rerun with threshold at 0"}
	}

	# Verify that we can still manually load symbols for all libraries.
	# (We'll assume that if the last shlib's symbols are loaded, that
	# all of them were.)
	#
	# Note that we set the GDB "height" variable to prevent GDB from
	# prompting
	#
	# Warning! On a machine with little free swap space, this may
	# fail!
	#
	send_gdb "set height 9999\n"
	gdb_expect {
	-re "$gdb_prompt $"\
	{pass "set screen page height to practical infinity"}
	timeout {fail "(timeout) set screen page height to practical infinity"}
	}
	send_gdb "sharedlibrary\n"
	gdb_expect {
	-re ".Reading symbols from ./lib02-so-thresh\\.sl\\.\\.\\.done\\..*$gdb_prompt $"\
	{pass "manually load all symbols"}
	-re "$gdb_prompt $" {
	setup_xfail hppa--* CHFts24108
	fail "manually load all symbols (CHFts24108)"
	}
	timeout {fail "(timeout) manually load all symbols"}
	}

	return 0