gdb/testsuite/gdb.python/py-corefile.exp - binutils-gdb - Git at Google

 # Copyright (C) 2025-2026 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/>.

 # This file is part of the GDB testsuite.  It tests the core file
 # support in Python.

 require isnative
 require {!is_remote host}

 load_lib gdb-python.exp

 require allow_python_tests

 standard_testfile

 if {[build_executable "build executable" $testfile $srcfile] == -1} {
     return
 }

 set remote_python_file \
     [gdb_remote_download host ${srcdir}/${subdir}/${testfile}.py]

 set corefile [core_find $binfile]
 if {$corefile == ""} {
     unsupported "couldn't create or find corefile"
     return
 }

 # Helper proc to run the 'core-file' command.  Takes optional arguments:
 #
 #   -corefile FILENAME : Load FILENAME as the new core file.  If this
 #                        argument is not given then the current core
 #                        file will be unloaded.
 #
 #   -inferior NUM : The inferior in which the corefile is being changed.
 #                   This is used to match the corefile_changed events
 #                   that will be emitted.
 #
 #   -prefix STRING : A test prefix, to make test names unique.
 #
 #   -replacement : There's already a core file loaded when this command
 #                  is being run.
 proc core_file_cmd { args } {
     parse_some_args {
 	{corefile ""}
 	{inferior 1}
 	{prefix ""}
 	{replacement}
     }

     if { $prefix eq "" } {
 	if { $corefile eq "" } {
 	    set prefix "unload corefile"
 	} else {
 	    set prefix "load corefile"
 	}
     }

     with_test_prefix $prefix {
 	gdb_test "events corefile_changed check" \
 	    "^No corefile_changed event has been seen\\." \
 	    "no corefile event has been seen"

 	gdb_test "events exited check" \
 	    "^No exited event has been seen\\." \
 	    "no exited event has been seen"

 	if { $corefile eq "" } {
 	    gdb_test "core-file" "^No core file now\\." "unload current core file"

 	    gdb_test "events corefile_changed check" \
 		"Event 1/1, Inferior $inferior, Corefile None" \
 		"expected corefile event has been seen"

 	    gdb_test "events exited check" \
 		"Event 1/1, Inferior $inferior, Exit Code None" \
 		"expected exited event has been seen"
 	} else {
 	    gdb_test "core-file $corefile" ".*" "load core file"

 	    if { $replacement } {
 		gdb_test "events corefile_changed check" \
 		    [multi_line \
 			 "Event 1/2, Inferior $inferior, Corefile None" \
 			 "Event 2/2, Inferior $inferior, Corefile [string_to_regexp $corefile]"] \
 		    "expected corefile event has been seen"

 		gdb_test "events exited check" \
 		    "Event 1/1, Inferior $inferior, Exit Code None" \
 		    "expected exited event has been seen"
 	    } else {
 		gdb_test "events corefile_changed check" \
 		    "Event 1/1, Inferior $inferior, Corefile [string_to_regexp $corefile]" \
 		    "expected corefile event has been seen"

 		gdb_test "events exited check" \
 		    "^No exited event has been seen\\." \
 		    "no exited event was emitted"
 	    }
 	}
     }

     gdb_test_no_output -nopass "events corefile_changed reset"
     gdb_test_no_output -nopass "events exited reset"
 }

 # A helper proc runs clean_restart passing through ARGS, and then loads the
 # test's Python script.
 proc clean_restart_and_load_py_script { args } {
     clean_restart {*}$args

     # Load the Python script into GDB.
     gdb_test "source $::remote_python_file" "^Success" \
 	"source python script"
 }

 # Create a copy of the corefile.
 set other_corefile [standard_output_file ${testfile}-other.core]
 remote_exec build "cp $corefile $other_corefile"

 clean_restart_and_load_py_script

 gdb_test_no_output "python inf = gdb.selected_inferior()" \
     "capture current inferior"

 gdb_test "python print(inf.corefile)" "^None" \
     "Inferior.corefile is None before loading a core file"

 core_file_cmd -corefile $corefile

 set file_re [string_to_regexp $corefile]
 gdb_test "python print(inf.corefile)" "^<gdb\\.Corefile inferior=1 filename='$file_re'>" \
     "Inferior.corefile is a valid object after loading a core file"

 gdb_test_no_output "python core1=inf.corefile" "capture gdb.Corefile object"

 gdb_test "python print(core1.__dict__)" "^\\{\\}" \
     "print Corefile.__dict__ when empty"

 gdb_test_no_output "python core1._my_attribute = \"Hello\"" \
     "write new attribute into Corefile object"

 gdb_test "python print(core1._my_attribute)" "^Hello" \
     "immediately read new attribute"

 gdb_test "python print(core1.__dict__)" "^\\{'_my_attribute': 'Hello'\\}" \
     "print Corefile.__dict__ after adding an attribute"

 gdb_test "python print(core1.filename)" "^$file_re" \
     "Corefile.filename attribute works as expected"

 gdb_test "python print(core1.is_valid())" "^True" \
     "Corefile.is_valid() is True while corefile is loaded"

 core_file_cmd

 gdb_test "python print(core1.is_valid())" "^False" \
     "Corefile.is_valid() is False after corefile is unloaded"

 gdb_test "python print(core1.__dict__)" "^\\{'_my_attribute': 'Hello'\\}" \
     "print Corefile.__dict__ with attribute when invalid"

 gdb_test "python print(core1)" "^<gdb\\.Corefile \\(invalid\\)>" \
     "print an invalid gdb.Corefile object"

 gdb_test "python print(core1.filename)" \
     [multi_line \
 	 "Python Exception <class 'RuntimeError'>: Corefile no longer exists\\." \
 	 "Error occurred in Python: Corefile no longer exists\\."] \
     "error when reading filename from invalid Corefile"

 gdb_test "python print(inf.corefile)" "^None" \
     "Inferior.corefile is None again after corefile unload"

 gdb_test "python print(core1._my_attribute)" "^Hello" \
     "read new attribute from invalid core file"

 # Create a second inferior.
 gdb_test "add-inferior"
 gdb_test "inferior 2"

 with_test_prefix "in second inferior" {
     core_file_cmd -corefile $corefile -inferior 2

     gdb_test "python print(inf.corefile)" "^None" \
 	"first inferior still has no core file"

     gdb_test_no_output "python core2=gdb.selected_inferior().corefile" \
 	"capture gdb.Corefile object"

     # The _my_attribute was added to CORE1, not CORE2.  Check it
     # doesn't somehow appear on CORE2.
     gdb_test "python print(core2._my_attribute)" \
 	"AttributeError.*: 'gdb\\.Corefile' object has no attribute '_my_attribute'" \
 	"try to read attribute that doesn't exist"

     gdb_test "python print(core2.filename)" "^$file_re" \
 	"Corefile.filename attribute works as expected"

     gdb_test "inferior 1"
 }

 # Read the name of the core file from the second program space while
 # the current program space is the first one.
 gdb_test "python print(core2.filename)" "^$file_re" \
     "Corefile.filename attribute works from different progspace"

 # Load the other corefile into the first inferior.
 core_file_cmd -corefile $other_corefile \
     -prefix "load other corefile into inferior 1"

 # Delete the second inferior.  We need to switch to the second
 # inferior and unload its corefile before we can do that.  Then,
 # switch back to the first inferior, delete the second, and try to
 # read the filename of the core file from the (now deleted) second
 # inferior.  We should get an error about the gdb.Corefile being
 # invalid.
 with_test_prefix "remove second inferior" {
     gdb_test "inferior 2"

     gdb_test "python print(inf.corefile.filename)" \
 	"^[string_to_regexp $other_corefile]" \
 	"read inferior 1 corefile when in inferior 2"

     gdb_test_no_output "python core1=inf.corefile" \
 	"capture inferior 1 gdb.Corefile while in inferior 2"

     # This is a new CORE1 object, check that _my_attribute is gone.
     gdb_test "python print(core1._my_attribute)" \
 	"AttributeError.*: 'gdb\\.Corefile' object has no attribute '_my_attribute'" \
 	"try to read attribute that doesn't exist"

     core_file_cmd -inferior 2

     gdb_test "python print(core2.filename)" \
 	[multi_line \
 	     "Python Exception <class 'RuntimeError'>: Corefile no longer exists\\." \
 	     "Error occurred in Python: Corefile no longer exists\\."] \
 	"error when reading filename from invalid Corefile"

     gdb_test "inferior 1"

     gdb_test "remove-inferiors 2"

     gdb_test "python print(core2.is_valid())" "^False" \
 	"Corefile.is_valid() is False after corefile is unloaded, and Progspace is deleted"

     gdb_test "python print(core2.filename)" \
 	[multi_line \
 	     "Python Exception <class 'RuntimeError'>: Corefile no longer exists\\." \
 	     "Error occurred in Python: Corefile no longer exists\\."] \
 	"error when reading filename of an invalid Corefile, from deleted program space"

     gdb_test "python print(core1.is_valid())" "^True" \
 	"check inferior 1 core file is still valid"
 }

 # Test the Corefile.mapped_files() API.  The Python script that is
 # sourced here implements 'info proc mappings' in Python using the
 # mapped_files API.  The output from the built-in command, and the
 # Python command should be identical.
 with_test_prefix "test mapped files data" {
     clean_restart_and_load_py_script

     # Load the core file.
     core_file_cmd -corefile $corefile

     # Two files to write the output to.
     set out_1 [standard_output_file ${gdb_test_file_name}-out-1.txt]
     set out_2 [standard_output_file ${gdb_test_file_name}-out-2.txt]

     # Run the built-in command, then the new Python command, capture
     # the output.
     gdb_test "pipe info proc mappings | tee $out_1" ".*" \
 	"capture built-in mappings output"
     gdb_test "pipe info proc py-mappings | tee $out_2" ".*" \
 	"capture Python based mappings data"

     # Check the output is identical.
     gdb_test "shell diff -s $out_1 $out_2" \
 	"Files \[^\r\n\]+-out-1.txt and \[^\r\n\]+-out-2.txt are identical" \
 	"diff input and output one"

     # Check build-ids within the core file mapping data.  I'm only
     # aware of GNU/Linux placing the first page of each mapped ELF
     # into the generated core file so that the build-id can be found.
     if {[istarget *-*-linux*]} {
 	set results [list]
 	gdb_test_multiple "show-build-ids" "" {
 	    -re "^show-build-ids\r\n" {
 		exp_continue
 	    }
 	    -re "^Objfile Build-Id\\s+Core File Build-Id\\s+File Name\\s*\r\n" {
 		exp_continue
 	    }
 	    -re "^(\\S+)\\s+(\\S+)\\s+(\[^\r\n\]+)\r\n" {
 		set objfile_build_id $expect_out(1,string)
 		set core_file_build_id $expect_out(2,string)
 		set file_name $expect_out(3,string)
 		lappend results [list $objfile_build_id \
 				      $core_file_build_id \
 				      $file_name]
 		exp_continue
 	    }
 	    -re "^$gdb_prompt " {
 		pass $gdb_test_name
 	    }
 	}

 	set bad_count 0
 	foreach entry $results {
 	    set objfile_build_id [lindex $entry 0]
 	    set core_file_build_id [lindex $entry 1]
 	    set file_name [lindex $entry 2]
 	    if { $objfile_build_id ne $core_file_build_id } {
 		if { $core_file_build_id ne "None" } {
 		    verbose -log "Mismatched build-ids $objfile_build_id vs $core_file_build_id for $file_name"
 		    incr bad_count
 		} elseif { [expect_build_id_in_core_file $file_name] } {
 		    verbose -log "Failed to find build-id for $file_name"
 		    incr bad_count
 		} else {
 		    verbose -log "This build-id was likely not in the core file"
 		}
 	    }
 	}

 	gdb_assert { $bad_count == 0 } \
 	    "found expected build-ids in core file"
     }

     # Check the is_main_executable flag in the mapping data.
     gdb_test "check-main-executable" "^PASS"

     # Check that the mapped files "list" is actually an immutable
     # tuple.
     gdb_test_no_output "python core = gdb.selected_inferior().corefile"
     gdb_test_no_output "python mapped_files = core.mapped_files()"
     gdb_test "python print(type(mapped_files))" \
 	"^<class 'tuple'>"
     gdb_test "python mapped_files\[0\] = None" \
 	"'tuple' object does not support item assignment"
     gdb_test "python print(mapped_files\[0\] is None)" "^False"

     # And same for the list of regions for a mapped file.
     gdb_test_no_output "python regions = mapped_files\[0\].regions"
     gdb_test "python print(type(regions))" \
 	"^<class 'tuple'>"
     gdb_test "python regions\[0\] = None" \
 	"'tuple' object does not support item assignment"
 }

 # Load a core file.  GDB should figure out which file is being debugged.
 # Then use 'start' to run this executable, this will replace the core file
 # target.  At least on Linux, this replacement is done without calling
 # target_detach.  This test checks that the expected core file changed and
 # inferior exited events are still seen.
 with_test_prefix "start from corefile" {
     if { [gdb_protocol_is_native] } {
 	clean_restart_and_load_py_script

 	# Load the core file.
 	core_file_cmd -corefile $corefile

 	# Check GDB figured out the executable.
 	gdb_test "info inferiors 1" \
 	    [multi_line \
 		 "\[^\r\n\]+[string_to_regexp $binfile]\\s*" \
 		 "\[^\r\n\]+[string_to_regexp $corefile]\\s*"] \
 	    "check executable was detected correctly"

 	gdb_test "start" \
 	    "Temporary breakpoint $::decimal, main \\(\\).*" \

 	gdb_test "events corefile_changed check" \
 	    "Event 1/1, Inferior 1, Corefile None" \
 	    "expected corefile event has been seen"

 	gdb_test "events exited check" \
 	    "Event 1/1, Inferior 1, Exit Code None" \
 	    "expected exited event has been seen"

 	gdb_test_no_output -nopass "events corefile_changed reset"
 	gdb_test_no_output -nopass "events exited reset"
     }
 }

 # Load a core file, then load a different core file to replace it.
 # Check that the events that are emitted are as expected.
 with_test_prefix "load one core file over another" {
     clean_restart_and_load_py_script

     # Load the core file.
     core_file_cmd -corefile $corefile \
 	-prefix "load first corefile"

     core_file_cmd -corefile $other_corefile \
 	-prefix "load second corefile" \
 	-replacement
 }
	# Copyright (C) 2025-2026 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/>.

	# This file is part of the GDB testsuite. It tests the core file
	# support in Python.

	require isnative
	require {!is_remote host}

	load_lib gdb-python.exp

	require allow_python_tests

	standard_testfile

	if {[build_executable "build executable" $testfile $srcfile] == -1} {
	return
	}

	set remote_python_file \
	[gdb_remote_download host ${srcdir}/${subdir}/${testfile}.py]

	set corefile [core_find $binfile]
	if {$corefile == ""} {
	unsupported "couldn't create or find corefile"
	return
	}

	# Helper proc to run the 'core-file' command. Takes optional arguments:
	#
	# -corefile FILENAME : Load FILENAME as the new core file. If this
	# argument is not given then the current core
	# file will be unloaded.
	#
	# -inferior NUM : The inferior in which the corefile is being changed.
	# This is used to match the corefile_changed events
	# that will be emitted.
	#
	# -prefix STRING : A test prefix, to make test names unique.
	#
	# -replacement : There's already a core file loaded when this command
	# is being run.
	proc core_file_cmd { args } {
	parse_some_args {
	{corefile ""}
	{inferior 1}
	{prefix ""}
	{replacement}
	}

	if { $prefix eq "" } {
	if { $corefile eq "" } {
	set prefix "unload corefile"
	} else {
	set prefix "load corefile"
	}
	}

	with_test_prefix $prefix {
	gdb_test "events corefile_changed check" \
	"^No corefile_changed event has been seen\\." \
	"no corefile event has been seen"

	gdb_test "events exited check" \
	"^No exited event has been seen\\." \
	"no exited event has been seen"

	if { $corefile eq "" } {
	gdb_test "core-file" "^No core file now\\." "unload current core file"

	gdb_test "events corefile_changed check" \
	"Event 1/1, Inferior $inferior, Corefile None" \
	"expected corefile event has been seen"

	gdb_test "events exited check" \
	"Event 1/1, Inferior $inferior, Exit Code None" \
	"expected exited event has been seen"
	} else {
	gdb_test "core-file $corefile" ".*" "load core file"

	if { $replacement } {
	gdb_test "events corefile_changed check" \
	[multi_line \
	"Event 1/2, Inferior $inferior, Corefile None" \
	"Event 2/2, Inferior $inferior, Corefile [string_to_regexp $corefile]"] \
	"expected corefile event has been seen"

	gdb_test "events exited check" \
	"Event 1/1, Inferior $inferior, Exit Code None" \
	"expected exited event has been seen"
	} else {
	gdb_test "events corefile_changed check" \
	"Event 1/1, Inferior $inferior, Corefile [string_to_regexp $corefile]" \
	"expected corefile event has been seen"

	gdb_test "events exited check" \
	"^No exited event has been seen\\." \
	"no exited event was emitted"
	}
	}
	}

	gdb_test_no_output -nopass "events corefile_changed reset"
	gdb_test_no_output -nopass "events exited reset"
	}

	# A helper proc runs clean_restart passing through ARGS, and then loads the
	# test's Python script.
	proc clean_restart_and_load_py_script { args } {
	clean_restart {*}$args

	# Load the Python script into GDB.
	gdb_test "source $::remote_python_file" "^Success" \
	"source python script"
	}

	# Create a copy of the corefile.
	set other_corefile [standard_output_file ${testfile}-other.core]
	remote_exec build "cp $corefile $other_corefile"

	clean_restart_and_load_py_script

	gdb_test_no_output "python inf = gdb.selected_inferior()" \
	"capture current inferior"

	gdb_test "python print(inf.corefile)" "^None" \
	"Inferior.corefile is None before loading a core file"

	core_file_cmd -corefile $corefile

	set file_re [string_to_regexp $corefile]
	gdb_test "python print(inf.corefile)" "^<gdb\\.Corefile inferior=1 filename='$file_re'>" \
	"Inferior.corefile is a valid object after loading a core file"

	gdb_test_no_output "python core1=inf.corefile" "capture gdb.Corefile object"

	gdb_test "python print(core1.__dict__)" "^\\{\\}" \
	"print Corefile.__dict__ when empty"

	gdb_test_no_output "python core1._my_attribute = \"Hello\"" \
	"write new attribute into Corefile object"

	gdb_test "python print(core1._my_attribute)" "^Hello" \
	"immediately read new attribute"

	gdb_test "python print(core1.__dict__)" "^\\{'_my_attribute': 'Hello'\\}" \
	"print Corefile.__dict__ after adding an attribute"

	gdb_test "python print(core1.filename)" "^$file_re" \
	"Corefile.filename attribute works as expected"

	gdb_test "python print(core1.is_valid())" "^True" \
	"Corefile.is_valid() is True while corefile is loaded"

	core_file_cmd

	gdb_test "python print(core1.is_valid())" "^False" \
	"Corefile.is_valid() is False after corefile is unloaded"

	gdb_test "python print(core1.__dict__)" "^\\{'_my_attribute': 'Hello'\\}" \
	"print Corefile.__dict__ with attribute when invalid"

	gdb_test "python print(core1)" "^<gdb\\.Corefile \\(invalid\\)>" \
	"print an invalid gdb.Corefile object"

	gdb_test "python print(core1.filename)" \
	[multi_line \
	"Python Exception <class 'RuntimeError'>: Corefile no longer exists\\." \
	"Error occurred in Python: Corefile no longer exists\\."] \
	"error when reading filename from invalid Corefile"

	gdb_test "python print(inf.corefile)" "^None" \
	"Inferior.corefile is None again after corefile unload"

	gdb_test "python print(core1._my_attribute)" "^Hello" \
	"read new attribute from invalid core file"

	# Create a second inferior.
	gdb_test "add-inferior"
	gdb_test "inferior 2"

	with_test_prefix "in second inferior" {
	core_file_cmd -corefile $corefile -inferior 2

	gdb_test "python print(inf.corefile)" "^None" \
	"first inferior still has no core file"

	gdb_test_no_output "python core2=gdb.selected_inferior().corefile" \
	"capture gdb.Corefile object"

	# The _my_attribute was added to CORE1, not CORE2. Check it
	# doesn't somehow appear on CORE2.
	gdb_test "python print(core2._my_attribute)" \
	"AttributeError.*: 'gdb\\.Corefile' object has no attribute '_my_attribute'" \
	"try to read attribute that doesn't exist"

	gdb_test "python print(core2.filename)" "^$file_re" \
	"Corefile.filename attribute works as expected"

	gdb_test "inferior 1"
	}

	# Read the name of the core file from the second program space while
	# the current program space is the first one.
	gdb_test "python print(core2.filename)" "^$file_re" \
	"Corefile.filename attribute works from different progspace"

	# Load the other corefile into the first inferior.
	core_file_cmd -corefile $other_corefile \
	-prefix "load other corefile into inferior 1"

	# Delete the second inferior. We need to switch to the second
	# inferior and unload its corefile before we can do that. Then,
	# switch back to the first inferior, delete the second, and try to
	# read the filename of the core file from the (now deleted) second
	# inferior. We should get an error about the gdb.Corefile being
	# invalid.
	with_test_prefix "remove second inferior" {
	gdb_test "inferior 2"

	gdb_test "python print(inf.corefile.filename)" \
	"^[string_to_regexp $other_corefile]" \
	"read inferior 1 corefile when in inferior 2"

	gdb_test_no_output "python core1=inf.corefile" \
	"capture inferior 1 gdb.Corefile while in inferior 2"

	# This is a new CORE1 object, check that _my_attribute is gone.
	gdb_test "python print(core1._my_attribute)" \
	"AttributeError.*: 'gdb\\.Corefile' object has no attribute '_my_attribute'" \
	"try to read attribute that doesn't exist"

	core_file_cmd -inferior 2

	gdb_test "python print(core2.filename)" \
	[multi_line \
	"Python Exception <class 'RuntimeError'>: Corefile no longer exists\\." \
	"Error occurred in Python: Corefile no longer exists\\."] \
	"error when reading filename from invalid Corefile"

	gdb_test "inferior 1"

	gdb_test "remove-inferiors 2"

	gdb_test "python print(core2.is_valid())" "^False" \
	"Corefile.is_valid() is False after corefile is unloaded, and Progspace is deleted"

	gdb_test "python print(core2.filename)" \
	[multi_line \
	"Python Exception <class 'RuntimeError'>: Corefile no longer exists\\." \
	"Error occurred in Python: Corefile no longer exists\\."] \
	"error when reading filename of an invalid Corefile, from deleted program space"

	gdb_test "python print(core1.is_valid())" "^True" \
	"check inferior 1 core file is still valid"
	}

	# Test the Corefile.mapped_files() API. The Python script that is
	# sourced here implements 'info proc mappings' in Python using the
	# mapped_files API. The output from the built-in command, and the
	# Python command should be identical.
	with_test_prefix "test mapped files data" {
	clean_restart_and_load_py_script

	# Load the core file.
	core_file_cmd -corefile $corefile

	# Two files to write the output to.
	set out_1 [standard_output_file ${gdb_test_file_name}-out-1.txt]
	set out_2 [standard_output_file ${gdb_test_file_name}-out-2.txt]

	# Run the built-in command, then the new Python command, capture
	# the output.
	gdb_test "pipe info proc mappings \| tee $out_1" ".*" \
	"capture built-in mappings output"
	gdb_test "pipe info proc py-mappings \| tee $out_2" ".*" \
	"capture Python based mappings data"

	# Check the output is identical.
	gdb_test "shell diff -s $out_1 $out_2" \
	"Files \[^\r\n\]+-out-1.txt and \[^\r\n\]+-out-2.txt are identical" \
	"diff input and output one"

	# Check build-ids within the core file mapping data. I'm only
	# aware of GNU/Linux placing the first page of each mapped ELF
	# into the generated core file so that the build-id can be found.
	if {[istarget --linux*]} {
	set results [list]
	gdb_test_multiple "show-build-ids" "" {
	-re "^show-build-ids\r\n" {
	exp_continue
	}
	-re "^Objfile Build-Id\\s+Core File Build-Id\\s+File Name\\s*\r\n" {
	exp_continue
	}
	-re "^(\\S+)\\s+(\\S+)\\s+(\[^\r\n\]+)\r\n" {
	set objfile_build_id $expect_out(1,string)
	set core_file_build_id $expect_out(2,string)
	set file_name $expect_out(3,string)
	lappend results [list $objfile_build_id \
	$core_file_build_id \
	$file_name]
	exp_continue
	}
	-re "^$gdb_prompt " {
	pass $gdb_test_name
	}
	}

	set bad_count 0
	foreach entry $results {
	set objfile_build_id [lindex $entry 0]
	set core_file_build_id [lindex $entry 1]
	set file_name [lindex $entry 2]
	if { $objfile_build_id ne $core_file_build_id } {
	if { $core_file_build_id ne "None" } {
	verbose -log "Mismatched build-ids $objfile_build_id vs $core_file_build_id for $file_name"
	incr bad_count
	} elseif { [expect_build_id_in_core_file $file_name] } {
	verbose -log "Failed to find build-id for $file_name"
	incr bad_count
	} else {
	verbose -log "This build-id was likely not in the core file"
	}
	}
	}

	gdb_assert { $bad_count == 0 } \
	"found expected build-ids in core file"
	}

	# Check the is_main_executable flag in the mapping data.
	gdb_test "check-main-executable" "^PASS"

	# Check that the mapped files "list" is actually an immutable
	# tuple.
	gdb_test_no_output "python core = gdb.selected_inferior().corefile"
	gdb_test_no_output "python mapped_files = core.mapped_files()"
	gdb_test "python print(type(mapped_files))" \
	"^<class 'tuple'>"
	gdb_test "python mapped_files\[0\] = None" \
	"'tuple' object does not support item assignment"
	gdb_test "python print(mapped_files\[0\] is None)" "^False"

	# And same for the list of regions for a mapped file.
	gdb_test_no_output "python regions = mapped_files\[0\].regions"
	gdb_test "python print(type(regions))" \
	"^<class 'tuple'>"
	gdb_test "python regions\[0\] = None" \
	"'tuple' object does not support item assignment"
	}

	# Load a core file. GDB should figure out which file is being debugged.
	# Then use 'start' to run this executable, this will replace the core file
	# target. At least on Linux, this replacement is done without calling
	# target_detach. This test checks that the expected core file changed and
	# inferior exited events are still seen.
	with_test_prefix "start from corefile" {
	if { [gdb_protocol_is_native] } {
	clean_restart_and_load_py_script

	# Load the core file.
	core_file_cmd -corefile $corefile

	# Check GDB figured out the executable.
	gdb_test "info inferiors 1" \
	[multi_line \
	"\[^\r\n\]+[string_to_regexp $binfile]\\s*" \
	"\[^\r\n\]+[string_to_regexp $corefile]\\s*"] \
	"check executable was detected correctly"

	gdb_test "start" \
	"Temporary breakpoint $::decimal, main \\(\\).*" \

	gdb_test "events corefile_changed check" \
	"Event 1/1, Inferior 1, Corefile None" \
	"expected corefile event has been seen"

	gdb_test "events exited check" \
	"Event 1/1, Inferior 1, Exit Code None" \
	"expected exited event has been seen"

	gdb_test_no_output -nopass "events corefile_changed reset"
	gdb_test_no_output -nopass "events exited reset"
	}
	}

	# Load a core file, then load a different core file to replace it.
	# Check that the events that are emitted are as expected.
	with_test_prefix "load one core file over another" {
	clean_restart_and_load_py_script

	# Load the core file.
	core_file_cmd -corefile $corefile \
	-prefix "load first corefile"

	core_file_cmd -corefile $other_corefile \
	-prefix "load second corefile" \
	-replacement
	}