From f273e38ccc48a6f9aa012b442006eb6cf35b9770 Mon Sep 17 00:00:00 2001 From: David Taylor Date: Mon, 11 Jan 1999 15:52:01 +0000 Subject: [PATCH] new files -- part of HP merge project. --- gdb/testsuite/gdb.base/gen_solib_threshold.c | 229 +++++++++++ gdb/testsuite/gdb.base/solib_threshold.build | 12 + gdb/testsuite/gdb.base/solib_threshold.exp | 361 ++++++++++++++++++ .../gdb.base/solib_threshold.link_opts | 4 + gdb/testsuite/gdb.base/solib_threshold.mk | 73 ++++ 5 files changed, 679 insertions(+) create mode 100644 gdb/testsuite/gdb.base/gen_solib_threshold.c create mode 100755 gdb/testsuite/gdb.base/solib_threshold.build create mode 100644 gdb/testsuite/gdb.base/solib_threshold.exp create mode 100644 gdb/testsuite/gdb.base/solib_threshold.link_opts create mode 100644 gdb/testsuite/gdb.base/solib_threshold.mk diff --git a/gdb/testsuite/gdb.base/gen_solib_threshold.c b/gdb/testsuite/gdb.base/gen_solib_threshold.c new file mode 100644 index 0000000000..d8352f95f0 --- /dev/null +++ b/gdb/testsuite/gdb.base/gen_solib_threshold.c @@ -0,0 +1,229 @@ +/* + * Program to generate the auto_solib_add_threshhold testcase, + * including associated linked-against shared libraries. + * Build as: + * + * cc -g -o gen_auto_solib_add_threshhold gen_auto_solib_add_threshhold.c + * + * Invoke as: + * + * gen_auto_solib_add_threshhold + * + * It will put all the code in the current directory ("."). + * + * A makefile can also be generated if the -makemake option is used. + * To use the makefile: + * + * make -f auto_solib_add_threshhold.mk all + * + * The name of the application is + * + * auto_solib_add_threshhold + * + * (Revised from a program by John Bishop. --rehrauer) + */ + +#include +#include +#include + +int main (argc, argv) +int argc; +char **argv; +{ +#define NUMBER_OF_INT_VARS 1500 +#define NUMBER_OF_LIBS 3 + int lib_num = NUMBER_OF_LIBS; + int i; + int i2; + FILE *main_file; + FILE *lib_file; + FILE *make_file; + FILE *link_file; + + char testcase_name [1000]; + char linkfile_name [1000]; + char makefile_name [1000]; + char mainfile_name [1000]; + + char file_name[100]; + /* + * 0123456789 <-- length of field + * "./fil0000000002.c"; <-- typical filename + * 12345678901234567890 <-- length of string + * 10 20 + * ^where null goes + */ + char file_name_core[100]; + + /* Verify input. + */ + if ((argc < 1) || (argc > 2) || (argv == NULL) || + ((argc == 2) && (strcmp (argv[1], "-makemake") != 0))) + { + printf ("** Syntax: %s [-makemake]\n", argv[0]); + return; + } + + if (strncmp (argv[0], "gen_", 4) != 0) + { + printf ("** This tool expected to be named \"gen_something\"\n"); + return; + } + strcpy (testcase_name, argv[0]+4); + + strcpy (linkfile_name, testcase_name); + strcat (linkfile_name, ".link_opts"); + link_file = fopen (linkfile_name, "w"); + fprintf (link_file, "# Linker options for %s test\n", testcase_name); + + /* Generate the makefile, if requested. + */ + if (argc == 2) + { + strcpy (makefile_name, testcase_name); + strcat (makefile_name, ".mk.new"); + make_file = fopen (makefile_name, "w"); + printf (" Note: New makefile (%s) generated.\n", makefile_name); + printf (" May want to update existing makefile, if any.\n"); + fprintf (make_file, "# Generated automatically by %s\n", argv[0]); + fprintf (make_file, "# Make file for %s test\n", testcase_name); + fprintf (make_file, "\n"); + fprintf (make_file, "CFLAGS = +DA1.1 -g\n"); + fprintf (make_file, "\n"); + fprintf (make_file, "# This is how to build this generator.\n"); + fprintf (make_file, "%s.o: %s.c\n", argv[0], argv[0]); + fprintf (make_file, "\t$(CC) $(CFLAGS) -o %s.o -c %s.c\n", argv[0], argv[0]); + fprintf (make_file, "%s: %s.o\n", argv[0], argv[0]); + fprintf (make_file, "\t$(CC) $(CFLAGS) -o %s %s.o\n", argv[0], argv[0]); + fprintf (make_file, "\n"); + fprintf (make_file, "# This is how to run this generator.\n"); + fprintf (make_file, "# This target should be made before the 'all' target,\n"); + fprintf (make_file, "# to ensure that the shlib sources are all available.\n"); + fprintf (make_file, "require_shlibs: %s\n", argv[0]); + for (i=0; i < lib_num; i++) + { + fprintf (make_file, "\tif ! [ -a lib%2.2d_%s.c ] ; then \\\n", i, testcase_name); + fprintf (make_file, "\t %s ; \\\n", argv[0]); + fprintf (make_file, "\tfi\n"); + } + fprintf (make_file, "\n"); + fprintf (make_file, "# This is how to build all the shlibs.\n"); + fprintf (make_file, "# Be sure to first make the require_shlibs target!\n"); + for (i=0; i < lib_num; i++) + { + fprintf (make_file, "lib%2.2d_%s.o: lib%2.2d_%s.c\n", i, testcase_name, i, testcase_name); + fprintf (make_file, "\t$(CC) $(CFLAGS) +Z -o lib%2.2d_%s.o -c lib%2.2d_%s.c\n", i, testcase_name, i, testcase_name); + fprintf (make_file, "lib%2.2d_%s.sl: lib%2.2d_%s.o\n", i, testcase_name, i, testcase_name); + fprintf (make_file, "\t$(LD) $(LDFLAGS) -b -o lib%2.2d_%s.sl lib%2.2d_%s.o\n", i, testcase_name, i, testcase_name); + } + fprintf (make_file, "\n"); +fprintf (make_file, "# For convenience, here's names for all pieces of all shlibs.\n"); + fprintf (make_file, "SHLIB_SOURCES = \\\n"); + for (i=0; i < lib_num-1; i++) + fprintf (make_file, "\tlib%2.2d_%s.c \\\n", i, testcase_name); + fprintf (make_file, "\tlib%2.2d_%s.c\n", lib_num-1, testcase_name); + fprintf (make_file, "SHLIB_OBJECTS = $(SHLIB_SOURCES:.c=.o)\n"); + fprintf (make_file, "SHLIBS = $(SHLIB_SOURCES:.c=.sl)\n"); + fprintf (make_file, "SHLIB_NAMES = $(SHLIB_SOURCES:.c=)\n"); + fprintf (make_file, "EXECUTABLES = $(SHLIBS) %s %s\n", argv[0], testcase_name); + fprintf (make_file, "OBJECT_FILES = $(SHLIB_OBJECTS) %s.o %s.o\n", argv[0], testcase_name); + fprintf (make_file, "\n"); + fprintf (make_file, "shlib_objects: $(SHLIB_OBJECTS)\n"); + fprintf (make_file, "shlibs: $(SHLIBS)\n"); + fprintf (make_file, "\n"); + fprintf (make_file, "# This is how to build the debuggable testcase that uses the shlibs.\n"); + fprintf (make_file, "%s.o: %s.c\n", testcase_name, testcase_name); + fprintf (make_file, "\t$(CC) $(CFLAGS) -o %s.o -c %s.c\n", testcase_name, testcase_name); + fprintf (make_file, "%s: shlibs %s.o\n", testcase_name, testcase_name); + fprintf (make_file, "\t$(LD) $(LDFLAGS) -o %s -lc -L. ", testcase_name); + fprintf (make_file, "-c %s /opt/langtools/lib/end.o /lib/crt0.o %s.o\n", linkfile_name, testcase_name); + fprintf (make_file, "\n"); + fprintf (make_file, "# Yeah, but you should first make the require_shlibs target!\n"); + fprintf (make_file, "all: %s %s\n", testcase_name, argv[0]); + fprintf (make_file, "\n"); + fprintf (make_file, "# To remove everything built via this makefile...\n"); + fprintf (make_file, "clean:\n"); + /* Do this carefully, to avoid hitting silly HP-UX ARG_MAX limits... */ + fprintf (make_file, "\trm -f lib0*_%s.*\n", testcase_name); + fprintf (make_file, "\trm -f lib1*_%s.*\n", testcase_name); + fprintf (make_file, "\trm -f lib2*_%s.*\n", testcase_name); + fprintf (make_file, "\trm -f lib3*_%s.*\n", testcase_name); + fprintf (make_file, "\trm -f lib4*_%s.*\n", testcase_name); + fprintf (make_file, "\trm -f lib5*_%s.*\n", testcase_name); + fprintf (make_file, "\trm -f lib6*_%s.*\n", testcase_name); + fprintf (make_file, "\trm -f lib7*_%s.*\n", testcase_name); + fprintf (make_file, "\trm -f lib8*_%s.*\n", testcase_name); + fprintf (make_file, "\trm -f lib9*_%s.*\n", testcase_name); + fprintf (make_file, "\trm -f %s %s %s %s.c\n", argv[0], testcase_name, linkfile_name, testcase_name); + fprintf (make_file, "\n"); + fclose (make_file); + } + + /* Generate the code for the libraries. + */ + for (i=0; i < lib_num; i++) { + + /* Generate the names for the library. + */ + sprintf (file_name, "lib%2.2d_%s.c", i, testcase_name); + sprintf (file_name_core, "lib%2.2d_%s", i, testcase_name); + + /* Generate the source code. + */ + lib_file = fopen (file_name, "w"); + fprintf (lib_file, "/* Shared library file number %d */\n", i); + fprintf (lib_file, "#include \n\n"); + fprintf (lib_file, "/* The following variables largely exist to bloat this library's debug info. */\n"); + fprintf (lib_file, "static char c_static_buf_%d [100];\n", i); + for (i2=0; i2\n\n"); + + for (i = 0; i < lib_num; i++) { + fprintf (main_file, "extern int r_%d();\n", i); + } + + fprintf (main_file, "\n"); + fprintf (main_file, "int main()\n"); + fprintf (main_file, "{\n"); + fprintf (main_file, " int accum;\n"); + fprintf (main_file, " int lib_num = %d;\n", lib_num); + + for (i = 0; i < lib_num; i++) { + fprintf (main_file, " accum += r_%d();\n", i); + } + + fprintf (main_file, " printf( \"Final value: %%d, should be %%d\\n\", accum, lib_num );\n\n"); + fprintf (main_file, " return 0;\n"); + fprintf (main_file, "}\n\n"); + fprintf (main_file, "/* end of generated file */\n"); + fclose (main_file); + + /* Finish up the link file and the build file + */ + fclose (link_file); +} + +/* End of file */ diff --git a/gdb/testsuite/gdb.base/solib_threshold.build b/gdb/testsuite/gdb.base/solib_threshold.build new file mode 100755 index 0000000000..e95478df39 --- /dev/null +++ b/gdb/testsuite/gdb.base/solib_threshold.build @@ -0,0 +1,12 @@ +#!/bin/ksh +# +# This script is a "wrapper" to use the auto_solib_add_threshold.mk +# Makefile. See the comments in auto_solib_add_threshold.exp +# regarding why this script exists. +# + +#set -o xtrace +#set -o verbose + +MAKEFLAGS= +make -f solib_threshold.mk require_shlibs all diff --git a/gdb/testsuite/gdb.base/solib_threshold.exp b/gdb/testsuite/gdb.base/solib_threshold.exp new file mode 100644 index 0000000000..33abcfdd1f --- /dev/null +++ b/gdb/testsuite/gdb.base/solib_threshold.exp @@ -0,0 +1,361 @@ +# 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 + +# are we on a target board +if ![isnative] then { + return +} + +set testfile "solib_threshold" +set srcfile ${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile}] { + return -1 +} + +# This testcase is automatically generated, via the +# gen_solib_threshold program, which also should +# live in this same directory. +# +# The generator produces: +# - solib_threshhold.c +# - 3 .c files named solib_threshold_libXX.c +# - a makefile named solib_threshold.mk with a +# target named "solib_threshold" that will compile +# and link the testcase +# +# Making with solib_threshold.mk produces: +# - solib_threshold +# - 3 shared libraries that are linked against, named +# solib_threshhold_libXX.sl +# +# We build gen_solib_threshhold, run it, and then make with +# the makefile it produces. +# +set genfile gen_${testfile} +set gen_srcfile ${genfile}.c +set gen_binfile ${genfile} +set gen_makefile ${testfile}.mk + +# 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 + +# It's easiest to build and run the testcase in this directory. (Linking +# against shlibs puts relative paths to them in the a.out, so it's best +# if we remain in this directory for the entire test run.) +# +#cd gdb.base + +# Ensure that the testcase is built. This may cause the generator to +# be built & run. +# +# Warning! The final link of this testcase is not for the +# faint-hearted nor under-disked machine! +# +# ??rehrauer: I tried for a very long time to get make invoked +# directly here, rather than invoking a script to do it. I +# finally gave up in frustration; I'm not sure why it wouldn't +# work that way, but this method DOES work, albeit clumsily. +# + +send_user "Making with ${testfile}.mk ...\n" +remote_exec build "sh -c \\\"cd ${objdir}/${subdir}\\; make -f ${srcdir}/${subdir}/${testfile}.mk clean require_shlibs all SRCDIR=${srcdir}/${subdir} OBJDIR=${objdir}/${subdir}\\\"" + +# Only HP-UX (and any other platforms using SOM shared libraries, I +# guess) interprets the auto-solib-add 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-add mentions that it +# serves as a threshhold. +# +send_gdb "help set auto-solib-add\n" +gdb_expect { + -re "Set autoloading size threshold .in megabytes. of shared library symbols.* +If nonzero, symbols from all shared object libraries will be loaded.* +automatically when the inferior begins execution or when the dynamic linker.* +informs gdb that a new library has been loaded, until the symbol table.* +of the program and libraries exceeds this threshold.* +Otherwise, symbols must be loaded manually, using `sharedlibrary'.*$gdb_prompt $"\ + {pass "help set auto-solib-add"} + -re "$gdb_prompt $"\ + {fail "help set auto-solib-add"} + timeout {fail "(timeout) help set auto-solib-add"} +} + +# On HP-UX, the threshhold is by default set to 50, which means +# 50 megabytes. +# +send_gdb "show auto-solib-add\n" +gdb_expect { + -re "Autoloading size threshold .in megabytes. of shared library symbols is 100.*$gdb_prompt $"\ + {pass "show auto-solib-add (default is 100)"} + -re "$gdb_prompt $"\ + {fail "show auto-solib-add (default is 100)"} + timeout {fail "(timeout) show auto-solib-add (default is 100)"} +} + +send_gdb "set auto-solib-add 1\n" +gdb_expect { + -re ".*$gdb_prompt $" + {pass "set auto-solib-add to 1"} + -re ".*$gdb_prompt $" + {fail "set auto-solib-add to 1"} + timeout {fail "(timeout) set auto-solib-add 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 "set break at main"} + -re "$gdb_prompt $"\ + {fail "set break at main"} + timeout {fail "(timeout) 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-add.* +To manually load symbols, use the 'sharedlibrary' command.* +To raise the threshold, set auto-solib-add to a larger value and rerun.* +the program.*$gdb_prompt $"\ + {pass "run to main hit auto-solib-add threshold"} + -re "$gdb_prompt $"\ + {fail "run to main hit auto-solib-add threshold"} + timeout {fail "(timeout) run to main hit auto-solib-add 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 $"\ + {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 $"\ + {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 "set break at main"} + -re "$gdb_prompt $"\ + {fail "set break at main"} + timeout {fail "(timeout) set break at main"} +} + +send_gdb "set auto-solib-add 9999\n" +gdb_expect { + -re "$gdb_prompt $"\ + {pass "set auto-solib-add threshold to practical infinity"} + timeout {fail "(timeout) set auto-solib-add 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-add.* +To manually load symbols, use the 'sharedlibrary' command.* +To raise the threshold, set auto-solib-add 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 "set break at main"} + -re "$gdb_prompt $"\ + {fail "set break at main"} + timeout {fail "(timeout) set break at main"} +} + +send_gdb "set auto-solib-add 0\n" +gdb_expect { + -re "$gdb_prompt $"\ + {pass "set auto-solib-add threshold to 0"} + timeout {fail "(timeout) set auto-solib-add 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-add.* +To manually load symbols, use the 'sharedlibrary' command.* +To raise the threshold, set auto-solib-add 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_solib_threshold\\.sl\\.\\.\\.done\\..*$gdb_prompt $"\ + {pass "manually load all symbols"} + -re "$gdb_prompt $"\ + {fail "manually load all symbols"} + timeout {fail "(timeout) manually load all symbols"} +} + +#cd .. +return 0 diff --git a/gdb/testsuite/gdb.base/solib_threshold.link_opts b/gdb/testsuite/gdb.base/solib_threshold.link_opts new file mode 100644 index 0000000000..bbf874ae56 --- /dev/null +++ b/gdb/testsuite/gdb.base/solib_threshold.link_opts @@ -0,0 +1,4 @@ +# Linker options for solib_threshold test +-l00_solib_threshold +-l01_solib_threshold +-l02_solib_threshold diff --git a/gdb/testsuite/gdb.base/solib_threshold.mk b/gdb/testsuite/gdb.base/solib_threshold.mk new file mode 100644 index 0000000000..83a6956cf4 --- /dev/null +++ b/gdb/testsuite/gdb.base/solib_threshold.mk @@ -0,0 +1,73 @@ +# Make file for solib_threshold test + +OBJDIR=. +SRCDIR=. +CFLAGS = +DA1.1 -g + +# This is how to build this generator. +gen_solib_threshold.o: ${SRCDIR}/gen_solib_threshold.c + $(CC) $(CFLAGS) -o gen_solib_threshold.o -c ${SRCDIR}/gen_solib_threshold.c +gen_solib_threshold: gen_solib_threshold.o + $(CC) $(CFLAGS) -o gen_solib_threshold gen_solib_threshold.o + +# This is how to run this generator. +# This target should be made before the 'all' target, +# to ensure that the shlib sources are all available. +require_shlibs: gen_solib_threshold + if ! [ -a lib00_solib_threshold.c ] ; then \ + gen_solib_threshold ; \ + fi + if ! [ -a lib01_solib_threshold.c ] ; then \ + gen_solib_threshold ; \ + fi + if ! [ -a lib02_solib_threshold.c ] ; then \ + gen_solib_threshold ; \ + fi + +# This is how to build all the shlibs. +# Be sure to first make the require_shlibs target! +lib00_solib_threshold.o: lib00_solib_threshold.c + $(CC) $(CFLAGS) +Z -o lib00_solib_threshold.o -c lib00_solib_threshold.c +lib00_solib_threshold.sl: lib00_solib_threshold.o + $(LD) $(LDFLAGS) -b -o lib00_solib_threshold.sl lib00_solib_threshold.o +lib01_solib_threshold.o: lib01_solib_threshold.c + $(CC) $(CFLAGS) +Z -o lib01_solib_threshold.o -c lib01_solib_threshold.c +lib01_solib_threshold.sl: lib01_solib_threshold.o + $(LD) $(LDFLAGS) -b -o lib01_solib_threshold.sl lib01_solib_threshold.o +lib02_solib_threshold.o: lib02_solib_threshold.c + $(CC) $(CFLAGS) +Z -o lib02_solib_threshold.o -c lib02_solib_threshold.c +lib02_solib_threshold.sl: lib02_solib_threshold.o + $(LD) $(LDFLAGS) -b -o lib02_solib_threshold.sl lib02_solib_threshold.o + + + + +# For convenience, here's names for all pieces of all shlibs. +SHLIB_SOURCES = \ + lib00_solib_threshold.c \ + lib01_solib_threshold.c \ + lib02_solib_threshold.c + +SHLIB_OBJECTS = $(SHLIB_SOURCES:.c=.o) +SHLIBS = $(SHLIB_SOURCES:.c=.sl) +SHLIB_NAMES = $(SHLIB_SOURCES:.c=) +EXECUTABLES = $(SHLIBS) gen_solib_threshold solib_threshold +OBJECT_FILES = $(SHLIB_OBJECTS) gen_solib_threshold.o solib_threshold.o + +shlib_objects: $(SHLIB_OBJECTS) +shlibs: $(SHLIBS) + +# This is how to build the debuggable testcase that uses the shlibs. +solib_threshold.o: solib_threshold.c + $(CC) $(CFLAGS) -o solib_threshold.o -c solib_threshold.c +solib_threshold: shlibs solib_threshold.o + $(LD) $(LDFLAGS) -o solib_threshold -lc -L${OBJDIR} -c solib_threshold.link_opts /opt/langtools/lib/end.o /lib/crt0.o solib_threshold.o + +# Yeah, but you should first make the require_shlibs target! +all: solib_threshold gen_solib_threshold + +# To remove everything built via this makefile... +clean: + rm -f lib0*_solib_threshold.* + rm -f *.o gen_solib_threshold solib_threshold.link_opts solib_threshold.c + rm -f solib_threshold