# function, making it read one byte at a time. Running the testsuite

# with this catches racy tests.

read1.so: lib/read1.c

# Build the readmore.so preload library. This overrides the `read'

# function, making it try harder to read more at a time. Running the

# testsuite with this catches racy tests.

readmore.so: lib/read1.c

$(ECHO_CC) $(CC) -o $@ ${srcdir}/lib/read1.c -Wall -g -shared -fPIC \

# Build the read1 machinery.

.PHONY: read1 readmore

def parse_sum_line(line: str, dic: dict[str, set[str]]):

"""Parse a single LINE from a sumfile, and store the results in the

dictionary referenced by DIC."""

line = line.rstrip()

m = re.match(sum_matcher, line)

"""Read the sumfiles (passed as a list in the FILES variable), and

process each one, filling the FILES_AND_TESTS global dictionary with

information about them."""

for x in files:

with open(x, "r") as f:

This function does that for all sets (PASS, FAIL, KPASS, KFAIL, etc.),

and then print a sorted list (without duplicates) of all the tests

that were found to be racy."""

# First, construct two dictionaries that will hold one set of

# testcases for each state (PASS, FAIL, etc.).

-- along with this program. If not, see <http://www.gnu.org/licenses/>.

procedure P is

function Create (I : Integer) return Table is

begin

end Create;

A : Table := Create (7);

for {set i 0} {$i < 4} {incr i} {

with_test_prefix "iteration $i" {

gdb_test "continue" \

"stopped in read_small"

}

}

# This only started working in GCC 11.

if {$scenario == "minimal" && [gnat_version_compare >= 11]} {

gdb_test "print fp5_var" " = 3e-19"

}

# This failed before GCC 10.

for Another_Type'size use 64;

Another_Fixed : Another_Type := Another_Delta * 5;

begin

Base_Object := 1.0/16.0; -- Set breakpoint here

Subtype_Object := 1.0/16.0;

Do_Nothing (FP4_Var'Address);

Do_Nothing (FP5_Var'Address);

Do_Nothing (Another_Fixed'Address);

end Fixed_Points;

-- You should have received a copy of the GNU General Public License

-- along with this program. If not, see <http://www.gnu.org/licenses/>.

procedure Foo is

type R_Type is null record;

U_Ptr : U_P_T := null;

begin

end Foo;

load_lib "ada.exp"

standard_ada_testfile crash

Rec_Type_Size : Integer := Rec'Object_Size;

begin

Do_Nothing (Static_Blob'Address);

Do_Nothing (Dynamic_Blob'Address);

null; -- STOP

untested "$testfile.exp"

return -1

}

if { [prepare_for_testing "failed to prepare" $testfile $srcfile {debug build-id}] } {

return -1

# Test for a syntax error in the middle of an expression.

gdb_test "print v_short =}{= 3" \

"A syntax error in expression, near `\\}\\{= 3'\\."

# This file was written by Michael Snyder (msnyder@redhat.com)

# This is a test for the gdb command "generate-core-file".

standard_testfile

gdb_continue_to_breakpoint "break here 1"

# Confirm that the two expected functions are available.

gdb_test "info function ^jit_function" \

[multi_line \

"File \[^\r\n\]+jit-elf-solib.c:" \

# Capture the addresses of each JIT symfile.

set symfile_addrs {}

#error "Must define the FUNCTION_NAME macro to set a jited function name"

#endif

gdb_test_no_output "maint print msymbols"

gdb_test_no_output "maint print psymbols"

gdb_exit

# just checking whether GDB recognizes the option and auto-appends a

# space.

proc test_completer_recognizes {res input_line} {

check_completion_result $res $input_line

}

# Test the "print symbol-loading" option.

standard_testfile print-symbol-loading-main.c

set libfile print-symbol-loading-lib

fail "ptype $id (compiler doesn't emit prototyped types)"

}

-re "type = $overprototyped\[\r\n\]+$gdb_prompt $" {

}

}

}

# Test solib-search-path, and in the case of solib-svr4.c whether l_addr_p

# is properly reset when the path is changed.

require {!is_remote target}

# Build "wrong" and "right" versions of the libraries in separate directories.

"The \033\\\[38;2;254;210;16;48;5;255;22;27m.*\".*version.*\".*style.*\033\\\[m foreground color is: #FED210" \

"Version's TrueColor foreground style"

}

}

}

xfail "ptype T5<int> (obsolescent gcc or gdb)"

}

-re "type = class T5<int> \{${ws}public:${ws}static int X;${ws}int x;${ws}int val;${ws}void T5\\(int\\);${ws}void T5\\((T5<int> const|const T5<int>) ?&\\);${ws}~T5\\(\\);${ws}static void \\* operator new\\((size_t|unsigned( int| long|))\\);${ws}static void operator delete\\(void ?\\*\\);${ws}int value\\((void|)\\);${ws}\}\r\n$gdb_prompt $" {

# These are really:

# http://sourceware.org/bugzilla/show_bug.cgi?id=8216

# http://sourceware.org/bugzilla/show_bug.cgi?id=8218

xfail "ptype t5i (obsolescent gcc or gdb) -- without size_t"

}

-re "type = class T5<int> \{${ws}public:${ws}static int X;${ws}int x;${ws}int val;${ws}void T5\\(int\\);${ws}void T5\\((T5<int> const|const T5<int>) ?&\\);${ws}~T5\\(\\);${ws}static void \\* operator new\\((size_t|unsigned( int| long|))\\);${ws}static void operator delete\\(void ?\\*\\);${ws}int value\\((void|)\\);${ws}\}\r\n$gdb_prompt $" {

# These are really:

# http://sourceware.org/bugzilla/show_bug.cgi?id=8216

# http://sourceware.org/bugzilla/show_bug.cgi?id=8218

"constructor breakpoint"

}

-re "0. cancel.*\[\r\n\]*.1. all.*\[\r\n\]*.2. T5 at .*\[\r\n\]*.3. T5 at .*\[\r\n\]*> $" {

gdb_test "0" \

"nonsense intended to insure that this test fails" \

"constructor breakpoint"

}

-re "the class `T5<int>' does not have destructor defined\r\nHint: try 'T5<int>::~T5<TAB> or 'T5<int>::~T5<ESC-\\?>\r\n\\(Note leading single quote.\\)\r\n$gdb_prompt $"

{

}

}

}

-re "type = class Foo<int> \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*int t;\r\n\r\n\[ \t\]*int foo\\(int, int\\);\r\n\\}\r\n$gdb_prompt $" {

# GCC 3.1, DWARF-2 output.

}

-re "No symbol \"Foo\" in current context.\r\n$gdb_prompt $" {

# GCC 2.95.3, stabs+ output.

# ptype Foo<volatile char *>

gdb_test_multiple "ptype/r fvpchar" "ptype fvpchar" {

pass "ptype fvpchar"

}

-re "type = (class |)Foo<char volatile ?\\*> \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*.*char.*\\*t;\r\n\r\n\[ \t\]*.*char \\* foo\\(int,.*char.*\\*\\);\r\n\\}\r\n$gdb_prompt $" {

}

}

# print a function from Foo<volatile char *>

# This test is sensitive to whitespace matching, so we'll do it twice,

gdb_test_multiple "print Foo<volatile char *>::foo" "print Foo<volatile char *>::foo" {

-re "\\$\[0-9\]* = \\{.*char \\*\\((class |)Foo<(volatile char|char volatile) ?\\*> \\*(| const), int, .*char \\*\\)\\} $hex <Foo<.*char.*\\*>::foo\\(int, .*char.*\\*\\)>\r\n$gdb_prompt $" {

pass "print Foo<volatile char *>::foo"

}

-re "No symbol \"Foo<volatile char \\*>\" in current context.\r\n$gdb_prompt $" {

fail "print Foo<volatile char *>::foo"

}

}

pass "print Foo<volatile char*>::foo"

}

-re "No symbol \"Foo<volatile char\\*>\" in current context.\r\n$gdb_prompt $" {

fail "print Foo<volatile char*>::foo"

}

}

}

-re "ptype Bar\r\ntype = class Bar<int, ?33> {\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*int t;\r\n\r\n\[ \t\]*int bar\\(int, int\\);\r\n}\r\n$gdb_prompt $" {

# GCC 3.1, DWARF-2 output.

}

-re "No symbol \"Bar\" in current context.\r\n$gdb_prompt $" {

# GCC 2.95.3, stabs+ output.

}

-re "type = class Baz<int, ?'s'> {\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*int t;\r\n\r\n\[ \t\]*int baz\\(int, int\\);\r\n}\r\n$gdb_prompt $" {

# GCC 3.1, DWARF-2 output.

}

-re "type = class Baz<int, ?(\\(char\\))?115> {\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*int t;\r\n\r\n\[ \t\]*int baz\\(int, int\\);\r\n}\r\n$gdb_prompt $" {

}

-re "No symbol \"Baz\" in current context.\r\n$gdb_prompt $" {

# GCC 2.95.3, stabs+ output.

}

-re "type = class Qux<char, ?&string> {\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*char t;\r\n\r\n\[ \t\]*char qux\\(int, char\\);\r\n}\r\n$gdb_prompt $" {

# GCC 3.1, DWARF-2 output.

}

-re "type = class Qux<char, ?&\\(string\\)> {\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*char t;\r\n\r\n\[ \t\]*char qux\\(int, char\\);\r\n}\r\n$gdb_prompt $" {

}

-re "No symbol \"Qux\" in current context.\r\n$gdb_prompt $" {

# GCC 2.95.3, stabs+ output.

pass "ptype quxint"

}

-re "type = class Qux<int, ?& ?\\(string\\)> \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*int t;\r\n\r\n\[ \t\]*int qux\\(int, int\\);.*\r\n\\}\r\n$gdb_prompt $" {

}

}

}

-re "type = class Spec<int, ?char> {\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\r\n\[ \t\]*int spec\\(char\\);\r\n}\r\n$gdb_prompt $" {

# GCC 3.1, DWARF-2 output.

}

-re "No symbol \"Spec\" in current context.\r\n$gdb_prompt $" {

# GCC 2.95.3, stabs+ output.

# First test that reading symbols fails.

gdb_test "file $host_binfile" \

"file $testfile"

# We can't use proc readnow, because the PR makes it return 0.

here, to catch any situation where gdb tries to use the memory. */

unsigned char u32_0[4] = { 0xff, 0xff, 0xff, 0xff };

int

main (void)

{

{DW_AT_language @DW_LANG_C_plus_plus}

} {

declare_labels i7_type u1_type u17_type u31_type \

i7_type: DW_TAG_base_type {

{DW_AT_encoding @DW_ATE_signed}

{DW_AT_location {DW_OP_addr [gdb_target_symbol "u32_0"]}

SPECIAL_expr}

}

}

}

}

gdb_test "print v_be30_1_off" "= 1"

gdb_test "print v_be30_1_off = 7" " = 7"

gdb_test "x/4xb &v_be30_1_off" ":\t0x00\t0x00\t0x00\t0x0e"

require allow_guile_tests

gdb_install_guile_utils

gdb_install_guile_module

"\033\\\[31m\033\\\[42mred on green\033\\\[49m red on default\033\\\[39m" \

"escape sequences"

# You should have received a copy of the GNU General Public License

# along with this program. If not, see <http://www.gnu.org/licenses/>.

import gdb_leak_detector

require allow_python_tests

gdb_test_no_output "python get_color_attrs = lambda c: \"%s %s %s %s %s\" % (str(c), c.colorspace, c.is_none, c.is_indexed, c.is_direct)" \

"get_color_attrs helper"

"\033\\\[31m\033\\\[42mred on green\033\\\[49m red on default\033\\\[39m" \

"escape sequences using keyword arguments"

gdb_test_multiline "Try to sub-class gdb.Color" \

"python" "" \

"class my_color(gdb.Color):" "" \

# You should have received a copy of the GNU General Public License

# along with this program. If not, see <http://www.gnu.org/licenses/>.

import re

import gdb_leak_detector

# executable (when EXEC_LOADED is true) and/or the library (when LIB_LOADED

# is true).

proc check_loaded_debug { exec_loaded lib_loaded } {

if { $exec_loaded } {

gdb_test "whatis global_exec_var" "^type = volatile struct exec_type"

static int __attribute__ ((used)) static_var = 50;

int

{

int some_var = 0;

return 0;

gdb_test "python print (sep_objfile.owner.username)" "${testfile}2" \

"Test user-name of owner of separate debug file"

"print main with debug info"

# Separate debug files are not findable.

# You should have received a copy of the GNU General Public License

# along with this program. If not, see <http://www.gnu.org/licenses/>.

import gdb_leak_detector

#

require supports_reverse

standard_testfile

return

}

}

gdb_test "break marker2" \

"set breakpoint at marker2"

# Show how many instructions we've recorded.

gdb_test "info record" "Active record target: .*"

# If the variable was recorded properly, the old contents (-1)

# will be remembered. If not, new contents (current time) will be

# You should have received a copy of the GNU General Public License

# along with this program. If not, see <http://www.gnu.org/licenses/>.

load_lib mi-support.exp

set MIFLAGS "-i=mi"

standard_testfile .cpp

# Start GDB. Ensure we are in non-stop mode as we need to read from

# the inferior while it is running.

save_vars {GDBFLAGS} {

clean_restart $binfile

}

gdb_breakpoint breakpt

gdb_continue_to_breakpoint "first breakpt call"

# Check we can see a single thread to begin with.

# We don't want thread events, it makes it harder to match GDB's

# output.

gdb_test_no_output "set print thread-events off"

# Continue the program in the background.

# Read the 'stage' flag from the inferior. This is initially 0, but

# will be set to 1 once the extra thread has been created, and then 2

set failure_count 0

set cmd "print /d stage"

set stage_flag 0

gdb_test_multiple "$cmd" "wait for 'stage' flag to be $num" {

fail "$gdb_test_name (can't read asynchronously)"

gdb_test_no_output "interrupt"

}

}

set stage_flag $expect_out(1,string)

if {$stage_flag != $num} {

set stage_flag 0

if {[target_info exists gdb_protocol]

&& ([target_info gdb_protocol] == "remote"

|| [target_info gdb_protocol] == "extended-remote")} {

} else {

set new_thread_re ""

set exit_thread_re ""

# This is the test we actually care about. Check that the

# $_inferior_thread_count convenience variable shows the correct

# thread count; the new thread should be visible.

# Set a variable in the inferior, this will cause the second thread to

# exit.

}

# Check that the second thread has gone away.

# Set a variable in the inferior, this will cause the second thread to

# exit.

"set 'spin' flag to allow main thread to exit"

# When the second thread exits, the main thread joins with it, and

# then proceeds to hit the breakpt function again.

gdb_test_multiple "" "wait for main thread to stop" {

pass $gdb_test_name

}

}

#

# Ref.: https://bugzilla.redhat.com/show_bug.cgi?id=1765117

tuiterm_env

standard_testfile tui-layout.c

return -1

}

set tui_asm_window_width 90

Term::clean_restart 24 ${tui_asm_window_width} $testfile

return

}

# This puts us into TUI mode, and should display the ASM window.

Term::command_no_prompt_prefix "layout asm"

Term::check_box_contents "check asm box contents" 0 0 ${tui_asm_window_width} 15 "<main>"

# Scroll the ASM window down using the down arrow key. In an ideal

# world we'd like to use PageDown here, but currently our terminal

# library doesn't support such advanced things.

# below will just timeout. So for now we avoid testing the edge

# case.

if {[regexp -- "^\\| +\\|$" $line]} {

break

}

# Send the down key to GDB.

send_gdb "\033\[B"

incr down_count

if {[Term::wait_for $re_line] \

# We scrolled successfully.

} else {

fail "$testname (scroll failed)"

Term::dump_screen

break

}

break

}

}

}

}

close $fd

}

proc _quote {string} {

DW_FORM_indirect -

DW_FORM_exprloc -

DW_FORM_strx -

DW_FORM_strx1 -

DW_FORM_strx2 -

debug_names_end:

}

# The top-level interface to the DWARF assembler.

# OPTIONS is a list with an even number of elements containing

# option-name and option-value pairs.

return -1

}

# Invoke "gcore". CORE is the name of the core file to write. TEST

# is the name of the test case. This will return 1 if the core file

# was created, 0 otherwise. If this fails to make a core file because