[1/2] gdb: handle empty ranges for inline subroutines

diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 995abf1405d..83ec2cbd6f7 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -10688,6 +10688,17 @@  read_variable (struct die_info *die, struct dwarf2_cu *cu)
     }
 }
 
+/* Return true if an empty range associated with an entry of type TAG in
+   CU should be "fixed", that is, converted to a single byte, non-empty
+   range.  */
+
+static bool
+dwarf_fixup_empty_range (struct dwarf2_cu *cu, dwarf_tag tag)
+{
+  return (tag == DW_TAG_inlined_subroutine
+	  && producer_is_gcc (cu->producer, nullptr, nullptr));
+}
+
 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
    reading .debug_rnglists.
    Callback's type should be:
@@ -10850,7 +10861,12 @@  dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
 
       /* Empty range entries have no effect.  */
       if (range_beginning == range_end)
-	continue;
+	{
+	  if (dwarf_fixup_empty_range (cu, tag))
+	    range_end = (unrelocated_addr) ((CORE_ADDR) range_end + 1);
+	  else
+	    continue;
+	}
 
       /* Only DW_RLE_offset_pair needs the base address added.  */
       if (rlet == DW_RLE_offset_pair)
@@ -10972,7 +10988,12 @@  dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu, dwarf_tag tag,
 
       /* Empty range entries have no effect.  */
       if (range_beginning == range_end)
-	continue;
+	{
+	  if (dwarf_fixup_empty_range (cu, tag))
+	    range_end = (unrelocated_addr) ((CORE_ADDR) range_end + 1);
+	  else
+	    continue;
+	}
 
       range_beginning = (unrelocated_addr) ((CORE_ADDR) range_beginning
 					    + (CORE_ADDR) *base);
@@ -11195,9 +11216,24 @@  dwarf2_get_pc_bounds (struct die_info *die, unrelocated_addr *lowpc,
   if (ret == PC_BOUNDS_NOT_PRESENT || ret == PC_BOUNDS_INVALID)
     return ret;
 
-  /* partial_die_info::read has also the strict LOW < HIGH requirement.  */
+  /* These LOW and HIGH values will be used to create a block.  A block's
+     high address is the first address after the block's address range, so
+     if 'high <= low' then the block has no code associated with it.  */
   if (high <= low)
-    return PC_BOUNDS_INVALID;
+    {
+      /* In some cases though, when the blocks LOW / HIGH were defined with
+	 the DW_AT_low_pc and DW_AT_high_pc, we see some compilers create
+	 an empty block when we can provide a better debug experience by
+	 having a non-empty block.  We do this by "fixing" the block to be
+	 a single byte in length.  See dwarf_fixup_empty_range for when
+	 this fixup is performed.  */
+      if (high == low
+	  && ret == PC_BOUNDS_HIGH_LOW
+	  && dwarf_fixup_empty_range (cu, die->tag))
+	high = (unrelocated_addr) (((ULONGEST) low) + 1);
+      else
+	return PC_BOUNDS_INVALID;
+    }
 
   /* When using the GNU linker, .gnu.linkonce. sections are used to
      eliminate duplicate copies of functions and vtables and such.
@@ -11465,7 +11501,31 @@  dwarf2_record_block_ranges (struct die_info *die, struct block *block,
 
 	  CORE_ADDR low = per_objfile->relocate (unrel_low);
 	  CORE_ADDR high = per_objfile->relocate (unrel_high);
-	  cu->get_builder ()->record_block_range (block, low, high - 1);
+
+	  /* Blocks where 'high < low' should be rejected earlier in the
+	     process, e.g. see dwarf2_get_pc_bounds.  */
+	  gdb_assert (high >= low);
+
+	  /* The value of HIGH is the first address past the end, but
+	     GDB stores ranges with the high value as last inclusive
+	     address, so in most cases we need to decrement HIGH here.
+
+	     Blocks where 'high == low' represent an empty block (i.e. a
+	     block with no associated code).
+
+	     When 'high == low' and dwarf_fixup_empty_range returns true we
+	     "fix" the empty range into a single byte range, which we can
+	     do by leaving HIGH untouched.  Otherwise we decrement HIGH,
+	     which might result in 'high < low'.  */
+	  if (high > low || !dwarf_fixup_empty_range (cu, die->tag))
+	    high -= 1;
+
+	  /* If the above decrement resulted in 'high < low' then this
+	     represents an empty range.  There's little point storing this
+	     in GDB's internal structures, it's just more to search
+	     through, and it will never match any address.  */
+	  if (high >= low)
+	    cu->get_builder ()->record_block_range (block, low, high);
 	}
     }
 
diff --git a/gdb/testsuite/gdb.cp/step-and-next-inline.exp b/gdb/testsuite/gdb.cp/step-and-next-inline.exp
index e16c2cca82d..8a1c4399da0 100644
--- a/gdb/testsuite/gdb.cp/step-and-next-inline.exp
+++ b/gdb/testsuite/gdb.cp/step-and-next-inline.exp
@@ -86,18 +86,16 @@  proc do_test { use_header } {
     }
 
     gdb_test "bt" "\\s*\\#0\\s+main.*" "in main"
-    set line1 {\t\{}
-    set line2 {\t  if \(t != NULL}
-    gdb_test_multiple "step" "step into get_alias_set" {
-	-re -wrap $line1 {
-	    gdb_test "next" $line2 $gdb_test_name
-	}
-	-re -wrap $line2 {
-	    pass $gdb_test_name
-	}
-    }
+    gdb_test "step" \
+	[multi_line \
+	     "get_alias_set \\(t=\[^\r\n\]+\\) at \[^\r\n\]+:$::decimal" \
+	     "$::decimal\\s+if \\(t != NULL\\s*"] \
+	"step into get_alias_set"
     gdb_test "bt" "\\s*\\#0\\s+get_alias_set\[^\r\]*${srcfile}:.*" \
 	"not in inline 1"
+    gdb_test "next" ".*TREE_TYPE.*" "next step 1"
+    gdb_test "bt" "#0\\s+get_alias_set\[^\r\n\]*${srcfile}:.*" \
+	"not in inline 2"
 
     # It's possible that this first failure (when not using a header
     # file) is GCC's fault, though the remaining failures would best
@@ -107,27 +105,6 @@  proc do_test { use_header } {
     # having location view support, so for now it is tagged as such.
     set have_kfail [expr [test_compiler_info gcc*] && !$use_header]
 
-    set ok 1
-    gdb_test_multiple "next" "next step 1" {
-	-re -wrap "if \\(t->x != i\\)" {
-	    set ok 0
-	    send_gdb "next\n"
-	    exp_continue
-	}
-	-re -wrap ".*TREE_TYPE.* != 1" {
-	    if { $ok } {
-		pass $gdb_test_name
-	    } else {
-		if { $have_kfail } {
-		    setup_kfail "*-*-*" symtab/25507
-		}
-		fail $gdb_test_name
-	    }
-	}
-    }
-    gdb_test "bt" "\\s*\\#0\\s+get_alias_set\[^\r\]*${srcfile}:.*" \
-	"not in inline 2"
-
     set ok 1
     gdb_test_multiple "next" "next step 2" {
 	-re -wrap "return x;" {
@@ -196,14 +173,6 @@  proc do_test { use_header } {
 	"\\s*\\#0\\s+(main|get_alias_set)\[^\r\]*${srcfile}:.*" \
 	"not in inline 5"
 
-    if {!$use_header} {
-	# With the debug from GCC 10.x (and earlier) GDB is currently
-	# unable to successfully complete the following tests when we
-	# are not using a header file.
-	kfail symtab/25507 "stepping tests"
-	return
-    }
-
     clean_restart ${executable}
 
     if ![runto_main] {
@@ -211,7 +180,11 @@  proc do_test { use_header } {
     }
 
     gdb_test "bt" "\\s*\\#0\\s+main.*" "in main pass 2"
-    gdb_test "step" ".*" "step into get_alias_set pass 2"
+    gdb_test "step" \
+	[multi_line \
+	     "get_alias_set \\(t=\[^\r\n\]+\\) at \[^\r\n\]+:$::decimal" \
+	     "$::decimal\\s+if \\(t != NULL\\s*"] \
+	"step into get_alias_set, pass 2"
     gdb_test "bt" "\\s*\\#0\\s+get_alias_set\[^\r\]*${srcfile}:.*" \
 	"in get_alias_set pass 2"
     gdb_test "step" ".*TREE_TYPE.*" "step 1"
@@ -220,22 +193,57 @@  proc do_test { use_header } {
     gdb_test "step" ".*if \\(t->x != i\\).*" "step 2"
     gdb_test "bt" "\\s*\\#0\\s+\[^\r\]*tree_check\[^\r\]*${hdrfile}:.*" \
 	"in inline 1 pass 2"
-    gdb_test "step" ".*TREE_TYPE.*" "step 3"
+    gdb_test "step" ".*return x.*" "step 3"
+    gdb_test "step" ".*TREE_TYPE.*" "step 4"
     gdb_test "bt" "\\s*\\#0\\s+get_alias_set\[^\r\]*${srcfile}:.*" \
 	"not in inline 2 pass 2"
-    gdb_test "step" ".*if \\(t->x != i\\).*" "step 4"
+    gdb_test "step" ".*if \\(t->x != i\\).*" "step 5"
     gdb_test "bt" "\\s*\\#0\\s+\[^\r\]*tree_check\[^\r\]*${hdrfile}:.*" \
 	"in inline 2 pass 2"
-    gdb_test "step" ".*TREE_TYPE.*" "step 5"
+    gdb_test "step" ".*return x.*" "step 6"
+    gdb_test "step" ".*TREE_TYPE.*" "step 7"
     gdb_test "bt" "\\s*\\#0\\s+get_alias_set\[^\r\]*${srcfile}:.*" \
 	"not in inline 3 pass 2"
-    gdb_test "step" ".*if \\(t->x != i\\).*" "step 6"
+    gdb_test "step" ".*if \\(t->x != i\\).*" "step 8"
     gdb_test "bt" "\\s*\\#0\\s+\[^\r\]*tree_check\[^\r\]*${hdrfile}:.*" \
 	"in inline 3 pass 2"
-    gdb_test "step" "return 0.*" "step 7"
+    gdb_test "step" "return x.*" "step 9"
+    gdb_test "step" "return 0.*" "step 10"
     gdb_test "bt" \
 	"\\s*\\#0\\s+(main|get_alias_set)\[^\r\]*${srcfile}:.*" \
 	"not in inline 4 pass 2"
+
+    clean_restart ${executable}
+
+    if ![runto_main] {
+	return
+    }
+
+    gdb_test "bt" "#0\\s+main.*" "in main pass 3"
+    gdb_test "step" \
+	[multi_line \
+	     "get_alias_set \\(t=\[^\r\n\]+\\) at \[^\r\n\]+:$::decimal" \
+	     "$::decimal\\s+if \\(t != NULL\\s*"] \
+	"step into get_alias_set, pass 3"
+    gdb_test "bt" "#0\\s+get_alias_set\[^\r\n\]*${srcfile}:.*" \
+	"in get_alias_set pass 3"
+    gdb_test "step" ".*TREE_TYPE.*" "step 1 pass 3"
+    gdb_test "bt" "#0\\s+get_alias_set\[^\r\n\]*${srcfile}:.*" \
+	"not in inline 1 pass 3"
+    gdb_test "step" ".*if \\(t->x != i\\).*" "step 2 pass 3"
+    gdb_test "bt" "#0\\s+\[^\r\n\]*tree_check\[^\r\n\]*${hdrfile}:.*" \
+	"in inline 1 pass 3"
+    gdb_test_multiple "p t->x = 2" "change value pass 3" {
+	-re ".*value has been optimized out.*$::gdb_prompt $" {
+	    gdb_test "p xx.x = 2" ".* = 2.*" $gdb_test_name
+	}
+	-re ".* = 2.*$::gdb_prompt $" {
+	    pass $gdb_test_name
+	}
+    }
+    gdb_test "step" ".*abort.*" "step 3, pass 3"
+    gdb_test "bt" "#0\\s+\[^\r\n\]*tree_check\[^\r\n\]*${hdrfile}:.*" \
+	"abort from inline 1 pass 3"
     }
 }
 
diff --git a/gdb/testsuite/gdb.dwarf2/dw2-empty-inline-low-high.c b/gdb/testsuite/gdb.dwarf2/dw2-empty-inline-low-high.c
new file mode 100644
index 00000000000..335995b48f3
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/dw2-empty-inline-low-high.c
@@ -0,0 +1,39 @@ 
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 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/>.  */
+
+volatile int global_var = 0;
+
+int
+main (void)
+{		/* main decl line */
+  asm ("main_label: .globl main_label");
+  ++global_var;
+
+  asm ("main_0: .globl main_0");
+  ++global_var;
+
+  asm ("main_1: .globl main_1");
+  ++global_var;		/* foo call line */
+
+  asm ("main_2: .globl main_2");
+  ++global_var;
+
+  asm ("main_3: .globl main_3");
+  ++global_var;
+
+  return 0;
+}
diff --git a/gdb/testsuite/gdb.dwarf2/dw2-empty-inline-low-high.exp b/gdb/testsuite/gdb.dwarf2/dw2-empty-inline-low-high.exp
new file mode 100644
index 00000000000..4b13ced9780
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/dw2-empty-inline-low-high.exp
@@ -0,0 +1,128 @@ 
+# Copyright 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/>.
+
+# Define an inline function `foo` within the function `main`.  The
+# function `foo` uses DW_AT_low_pc and DW_AT_high_pc to define its
+# range, except that DW_AT_high_pc is the constant 0.
+#
+# This should indicate that there is no code associated with `foo`,
+# however, with gcc versions at least between 8.x and 14.x (latest at
+# the time of writing this comment), it is observed that when these
+# empty inline functions are created, if GDB stops at the address
+# given in DW_AT_low_pc, then locals associated with the inline
+# function can usually be read.
+#
+# At the very least, stopping at the location of the inline function
+# means that the user can place a breakpoint on the inline function
+# and have GDB stop in a suitable location, that alone is helpful.
+#
+# This test defines an inline function, places a breakpoint, and then
+# runs and expects GDB to stop, and report the stop as being inside
+# the inline function.
+#
+# We then check that the next outer frame is `main` as expected, and
+# that the block for `foo` has been extended to a single byte, which
+# is how GDB gives the previously empty block some range.
+
+load_lib dwarf.exp
+
+require dwarf2_support
+
+standard_testfile .c .S
+
+# Lines we reference in the generated DWARF.
+set main_decl_line [gdb_get_line_number "main decl line"]
+set foo_call_line [gdb_get_line_number "foo call line"]
+
+get_func_info main
+
+set asm_file [standard_output_file $srcfile2]
+Dwarf::assemble $asm_file {
+    upvar entry_label entry_label
+
+    declare_labels lines_table inline_func
+
+    cu { } {
+	compile_unit {
+	    {producer "GNU C 14.1.0"}
+	    {language @DW_LANG_C}
+	    {name $::srcfile}
+	    {comp_dir /tmp}
+	    {low_pc 0 addr}
+	    {DW_AT_stmt_list $lines_table DW_FORM_sec_offset}
+	} {
+	    inline_func: subprogram {
+		{name foo}
+		{inline @DW_INL_declared_inlined}
+	    }
+	    subprogram {
+		{name main}
+		{decl_file 1 data1}
+		{decl_line $::main_decl_line data1}
+		{decl_column 1 data1}
+		{low_pc $::main_start addr}
+		{high_pc $::main_len data4}
+		{external 1 flag}
+	    } {
+		inlined_subroutine {
+		    {abstract_origin %$inline_func}
+		    {call_file 1 data1}
+		    {call_line $::foo_call_line data1}
+		    {low_pc main_1 addr}
+		    {high_pc 0 data4}
+		}
+	    }
+	}
+    }
+
+    lines {version 2} lines_table {
+	include_dir "$::srcdir/$::subdir"
+	file_name "$::srcfile" 1
+    }
+}
+
+if {[prepare_for_testing "failed to prepare" $testfile \
+	 [list $srcfile $asm_file] {nodebug}]} {
+    return
+}
+
+if {![runto_main]} {
+    return
+}
+
+gdb_breakpoint foo
+gdb_test "continue" \
+    "Breakpoint $decimal, $hex in foo \\(\\)" \
+    "continue to b/p in foo"
+
+set foo_start [get_hexadecimal_valueof "&main_1" "*UNKNOWN*" \
+		   "get address of foo start"]
+set foo_end [get_hexadecimal_valueof "&main_1 + 1" "*UNKNOWN*" \
+		   "get address of foo end"]
+
+gdb_test "maintenance info blocks" \
+    [multi_line \
+	 "\\\[\\(block \\*\\) $hex\\\] $foo_start\\.\\.$foo_end" \
+	 "  entry pc: $foo_start" \
+	 "  inline function: foo" \
+	 "  symbol count: $decimal" \
+	 "  is contiguous"] \
+    "block for foo has some content"
+
+gdb_test "frame 1" \
+    [multi_line \
+	 "#1  main \\(\\) at \[^\r\n\]+/$srcfile:$foo_call_line" \
+	 "$foo_call_line\\s+\[^\r\n\]+/\\* foo call line \\*/"] \
+    "frame 1 is for main"
diff --git a/gdb/testsuite/gdb.dwarf2/dw2-empty-inline-ranges.c b/gdb/testsuite/gdb.dwarf2/dw2-empty-inline-ranges.c
new file mode 100644
index 00000000000..80462b7bad2
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/dw2-empty-inline-ranges.c
@@ -0,0 +1,54 @@ 
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 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/>.  */
+
+volatile int global_var = 0;
+
+int
+main (void)
+{		/* main decl line */
+  asm ("main_label: .globl main_label");
+  ++global_var;
+
+  asm ("main_0: .globl main_0");
+  ++global_var;
+
+  asm ("main_1: .globl main_1");
+  ++global_var;		/* foo call line */
+
+  asm ("main_2: .globl main_2");
+  ++global_var;
+
+  asm ("main_3: .globl main_3");
+  ++global_var;
+
+  asm ("main_4: .globl main_4");
+  ++global_var;
+
+  asm ("main_5: .globl main_5");
+  ++global_var;
+
+  asm ("main_6: .globl main_6");
+  ++global_var;
+
+  asm ("main_7: .globl main_7");
+  ++global_var;
+
+  asm ("main_8: .globl main_9");
+  ++global_var;
+
+  return 0;
+}
diff --git a/gdb/testsuite/gdb.dwarf2/dw2-empty-inline-ranges.exp b/gdb/testsuite/gdb.dwarf2/dw2-empty-inline-ranges.exp
new file mode 100644
index 00000000000..59c988a1099
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/dw2-empty-inline-ranges.exp
@@ -0,0 +1,260 @@ 
+# Copyright 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/>.
+
+# Define an inline function `foo` within the function `main`.  The
+# function `foo` uses DW_AT_ranges to define its ranges.  One of the
+# sub-ranges for foo will be empty.
+#
+# An empty sub-rnage should indicate that there is no code associated
+# with `foo` at that address, however, with gcc versions at least
+# between 8.x and 14.x (latest at the time of writing this comment),
+# it is observed that when these empty sub-ranges are created for an
+# inline function, if GDB treats the sub-range as non-empty, and stops
+# at that location, then this generally gives a better debug
+# experience.  It is often still possible to read local variables at
+# that address.
+#
+# This function defines an inline function, places a breakpoint on its
+# entry-pc, and then runs and expects GDB to stop, and report the stop
+# as being inside the inline function.
+#
+# We then check that the next outer frame is `main` as expected, and
+# that the block for `foo` has the expected sub-ranges.
+#
+# We compile a variety of different configurations, broadly there are
+# two variables, the location of the empty sub-range, and whether the
+# entry-pc points at the empty sub-range or not.
+#
+# The the empty sub-range location, the empty sub-range can be the
+# sub-range at the lowest address, highest address, or can be
+# somewhere between a blocks low and high addresses.
+
+load_lib dwarf.exp
+
+require dwarf2_support
+
+standard_testfile .c .S
+
+# Lines we reference in the generated DWARF.
+set main_decl_line [gdb_get_line_number "main decl line"]
+set foo_call_line [gdb_get_line_number "foo call line"]
+
+get_func_info main
+
+# Compile the source file and load the executable into GDB so we can
+# extract some addresses needed for creating the DWARF.
+if { [prepare_for_testing "failed to prepare" ${testfile} \
+	  [list ${srcfile}]] } {
+    return -1
+}
+
+if {![runto_main]} {
+    return -1
+}
+
+# Some addresses that we need when generating the DWARF.
+for { set i 0 } { $i < 9 } { incr i } {
+    set main_$i [get_hexadecimal_valueof "&main_$i" "UNKNOWN" \
+		     "get address for main_$i"]
+}
+
+# Create the DWARF assembler file into ASM_FILE.  Using DWARF_VERSION
+# to define which style of ranges to create.  FUNC_RANGES is a list of
+# 6 entries, each of which is an address, used to create the ranges
+# for the inline function DIE.  The ENTRY_PC is also an address and is
+# used for the DW_AT_entry_pc of the inlined function.
+proc write_asm_file { asm_file dwarf_version func_ranges entry_pc } {
+    Dwarf::assemble $asm_file {
+	upvar entry_label entry_label
+	upvar dwarf_version dwarf_version
+	upvar func_ranges func_ranges
+	upvar entry_pc entry_pc
+
+	declare_labels lines_table inline_func ranges_label
+
+	cu { version $dwarf_version } {
+	    compile_unit {
+		{producer "GNU C 14.1.0"}
+		{language @DW_LANG_C}
+		{name $::srcfile}
+		{comp_dir /tmp}
+		{low_pc 0 addr}
+		{DW_AT_stmt_list $lines_table DW_FORM_sec_offset}
+	    } {
+		inline_func: subprogram {
+		    {name foo}
+		    {inline @DW_INL_declared_inlined}
+		}
+		subprogram {
+		    {name main}
+		    {decl_file 1 data1}
+		    {decl_line $::main_decl_line data1}
+		    {decl_column 1 data1}
+		    {low_pc $::main_start addr}
+		    {high_pc $::main_len data4}
+		    {external 1 flag}
+		} {
+		    inlined_subroutine {
+			{abstract_origin %$inline_func}
+			{call_file 1 data1}
+			{call_line $::foo_call_line data1}
+			{entry_pc $entry_pc addr}
+			{ranges $ranges_label DW_FORM_sec_offset}
+		    }
+		}
+	    }
+	}
+
+	lines {version 2} lines_table {
+	    include_dir "$::srcdir/$::subdir"
+	    file_name "$::srcfile" 1
+	}
+
+	if { $dwarf_version == 5 } {
+	    rnglists {} {
+		table {} {
+		    ranges_label: list_ {
+			start_end [lindex $func_ranges 0] [lindex $func_ranges 1]
+			start_end [lindex $func_ranges 2] [lindex $func_ranges 3]
+			start_end [lindex $func_ranges 4] [lindex $func_ranges 5]
+		    }
+		}
+	    }
+	} else {
+	    ranges { } {
+		ranges_label: sequence {
+		    range [lindex $func_ranges 0] [lindex $func_ranges 1]
+		    range [lindex $func_ranges 2] [lindex $func_ranges 3]
+		    range [lindex $func_ranges 4] [lindex $func_ranges 5]
+		}
+	    }
+	}
+    }
+}
+
+# Gobal used to give each generated binary a unique name.
+set test_id 0
+
+proc run_test { dwarf_version empty_loc entry_pc_type } {
+    incr ::test_id
+
+    set this_testfile $::testfile-$::test_id
+
+    set asm_file [standard_output_file $this_testfile.S]
+
+    if { $empty_loc eq "start" } {
+	set ranges [list \
+			$::main_1 $::main_1 \
+			$::main_3 $::main_4 \
+			$::main_6 $::main_7]
+	set entry_pc_choices [list $::main_1 $::main_3]
+    } elseif { $empty_loc eq "middle" } {
+	set ranges [list \
+			$::main_1 $::main_2 \
+			$::main_4 $::main_4 \
+			$::main_6 $::main_7]
+	set entry_pc_choices [list $::main_4 $::main_1]
+    } elseif { $empty_loc eq "end" } {
+	set ranges [list \
+			$::main_1 $::main_2 \
+			$::main_4 $::main_5 \
+			$::main_7 $::main_7]
+	set entry_pc_choices [list $::main_7 $::main_1]
+    } else {
+	error "unknown location for empty range '$empty_loc'"
+    }
+
+    if { $entry_pc_type eq "empty" } {
+	set entry_pc [lindex $entry_pc_choices 0]
+    } elseif { $entry_pc_type eq "non_empty" } {
+	set entry_pc [lindex $entry_pc_choices 1]
+    } else {
+	error "unknown entry-pc type '$entry_pc_type'"
+    }
+
+    write_asm_file $asm_file $dwarf_version $ranges $entry_pc
+
+    if {[prepare_for_testing "failed to prepare" $this_testfile \
+	     [list $::srcfile $asm_file] {nodebug}]} {
+	return
+    }
+
+    if {![runto_main]} {
+	return
+    }
+
+    # Continue until we stop in 'foo'.
+    gdb_breakpoint foo
+    gdb_test "continue" \
+	"Breakpoint $::decimal, $::hex in foo \\(\\)" \
+	"continue to b/p in foo"
+
+    # Check we stopped at the entry-pc.
+    set pc [get_hexadecimal_valueof "\$pc" "*UNKNOWN*" \
+		"get \$pc at breakpoint"]
+    gdb_assert { $pc == $entry_pc } "stopped at entry-pc"
+
+    # The block's expected overall low/high addresses.
+    set block_start [lindex $ranges 0]
+    set block_end [lindex $ranges 5]
+
+    # Setup variables r{0,1,2}s, r{0,1,2}e, to represent ranges start
+    # and end addresses.  These are extracted from the RANGES
+    # variable.  However, RANGES includes the empty ranges, so spot
+    # the empty ranges and update the end address as GDB does.
+    #
+    # Also, if the empty range is at the end of the block, then the
+    # block's overall end address also needs adjusting.
+    for { set i 0 } { $i < 3 } { incr i } {
+	set start [lindex $ranges [expr $i * 2]]
+	set end [lindex $ranges [expr $i * 2 + 1]]
+	if { $start == $end } {
+	    set end [format "0x%x" [expr $end + 1]]
+	}
+	if { $block_end == $start } {
+	    set block_end $end
+	}
+	set r${i}s $start
+	set r${i}e $end
+    }
+
+    # Check the block 'foo' has the expected ranges.
+    gdb_test "maintenance info blocks" \
+	[multi_line \
+	     "\\\[\\(block \\*\\) $::hex\\\] $block_start\\.\\.$block_end" \
+	     "  entry pc: $entry_pc" \
+	     "  inline function: foo" \
+	     "  symbol count: $::decimal" \
+	     "  address ranges:" \
+	     "    $r0s\\.\\.$r0e" \
+	     "    $r1s\\.\\.$r1e" \
+	     "    $r2s\\.\\.$r2e"] \
+	"block for foo has some content"
+
+    # Check the outer frame is 'main' as expected.
+    gdb_test "frame 1" \
+	[multi_line \
+	     "#1  main \\(\\) at \[^\r\n\]+/$::srcfile:$::foo_call_line" \
+	     "$::foo_call_line\\s+\[^\r\n\]+/\\* foo call line \\*/"] \
+	"frame 1 is for main"
+}
+
+foreach_with_prefix dwarf_version { 4 5 } {
+    foreach_with_prefix empty_loc { start middle end } {
+	foreach_with_prefix entry_pc_type { empty non_empty } {
+	    run_test $dwarf_version $empty_loc $entry_pc_type
+	}
+    }
+}
diff --git a/gdb/testsuite/gdb.dwarf2/dw2-unexpected-entry-pc.exp b/gdb/testsuite/gdb.dwarf2/dw2-unexpected-entry-pc.exp
index 69e1ce67cb9..8a77d209f95 100644
--- a/gdb/testsuite/gdb.dwarf2/dw2-unexpected-entry-pc.exp
+++ b/gdb/testsuite/gdb.dwarf2/dw2-unexpected-entry-pc.exp
@@ -56,6 +56,9 @@  foreach foo {foo_1 foo_2 foo_3 foo_4 foo_5 foo_6} {
 		  "get address for $foo label"]
 }
 
+set foo_3_end [get_hexadecimal_valueof "&foo_3 + 1" "UNKNOWN" \
+		   "get address for 'foo_3 + 1'"]
+
 # Some line numbers needed in the generated DWARF.
 set foo_decl_line [gdb_get_line_number "foo decl line"]
 set bar_call_line [gdb_get_line_number "bar call line"]
@@ -85,24 +88,40 @@  if [is_ilp32_target] {
 # generated which covers some parts of the inlined function.  This
 # makes most sense when being tested with the 'foo_6' label, as that
 # label is all about handling the end of the inline function case.
-
-proc run_test { entry_label dwarf_version with_line_table } {
-    set dw_testname "${::testfile}-${dwarf_version}-${entry_label}"
+#
+# The PRODUCER is the string used to control the DW_AT_producer string
+# in the CU.  When PRODUCER is 'gcc' then a string is used that
+# represents the gcc compiler.  When PRODUCER is 'other' then a string
+# that will not be interpreted as gcc is used.  The gcc compiler will
+# sometimes generate empty ranges for inline functions (from at least
+# gcc 8.x through to the currently latest release 14.x), and so GDB
+# has code in place to convert empty ranges to non-empty.  This fix is
+# not applied to other compilers at this time.
+
+proc run_test { producer entry_label dwarf_version with_line_table } {
+    set dw_testname "${::testfile}-${producer}-${dwarf_version}-${entry_label}"
 
     if { $with_line_table } {
 	set dw_testname ${dw_testname}-lt
     }
 
+    if { $producer eq "other" } {
+	set producer_str "ACME C 1.0.0"
+    } else {
+	set producer_str "GNU C 10.0.0"
+    }
+
     set asm_file [standard_output_file "${dw_testname}.S"]
     Dwarf::assemble $asm_file {
 	upvar dwarf_version dwarf_version
 	upvar entry_label entry_label
+	upvar producer_str producer_str
 
 	declare_labels lines_table inline_func ranges_label
 
 	cu { version $dwarf_version } {
 	    compile_unit {
-		{producer "gcc"}
+		{producer $producer_str}
 		{language @DW_LANG_C}
 		{name $::srcfile}
 		{comp_dir /tmp}
@@ -157,6 +176,10 @@  proc run_test { entry_label dwarf_version with_line_table } {
 		    line 2
 		    DW_LNS_copy
 
+		    DW_LNE_set_address foo_3
+		    line 3
+		    DW_LNS_copy
+
 		    DW_LNE_set_address foo_6
 		    line 10
 		    DW_LNS_copy
@@ -206,6 +229,16 @@  proc run_test { entry_label dwarf_version with_line_table } {
 	return false
     }
 
+    if { $producer eq "gcc" } {
+	set entry_pc $::foo_3
+	set empty_range_re "\r\n    $::foo_3\\.\\.$::foo_3_end"
+	set line_num 3
+    } else {
+	set entry_pc $::foo_1
+	set empty_range_re ""
+	set line_num 1
+    }
+
     # Place a breakpoint on `bar` and run to the breakpoint.  Use
     # gdb_test as we want full pattern matching against the stop
     # location.
@@ -215,8 +248,8 @@  proc run_test { entry_label dwarf_version with_line_table } {
     if { $with_line_table } {
 	set re \
 	    [multi_line \
-		 "Breakpoint $::decimal, bar \\(\\) at \[^\r\n\]+/$::srcfile:1" \
-		 "1\\s+\[^\r\n\]+"]
+		 "Breakpoint $::decimal, bar \\(\\) at \[^\r\n\]+/$::srcfile:$line_num" \
+		 "$line_num\\s+\[^\r\n\]+"]
     } else {
 	set re "Breakpoint $::decimal, $::hex in bar \\(\\)"
     }
@@ -230,21 +263,23 @@  proc run_test { entry_label dwarf_version with_line_table } {
     gdb_test "maint info blocks" \
 	[multi_line \
 	     "\\\[\\(block \\*\\) $::hex\\\] $::foo_1\\.\\.$::foo_6" \
-	     "  entry pc: $::foo_1" \
+	     "  entry pc: $entry_pc" \
 	     "  inline function: bar" \
 	     "  symbol count: $::decimal" \
-	     "  address ranges:" \
+	     "  address ranges:$empty_range_re" \
 	     "    $::foo_1\\.\\.$::foo_2" \
 	     "    $::foo_5\\.\\.$::foo_6"]
 }
 
-foreach_with_prefix dwarf_version { 4 5 } {
-    # Test various labels without any line table present.
-    foreach_with_prefix entry_label { foo_3 foo_4 foo_2 foo_6 } {
-	run_test $entry_label $dwarf_version false
-    }
+foreach_with_prefix producer { other gcc } {
+    foreach_with_prefix dwarf_version { 4 5 } {
+	# Test various labels without any line table present.
+	foreach_with_prefix entry_label { foo_3 foo_4 foo_2 foo_6 } {
+	    run_test $producer $entry_label $dwarf_version false
+	}
 
-    # Now test what happens if we use the end address of the block,
-    # but also supply a line table.  Does GDB do anything different?
-    run_test foo_6 $dwarf_version true
+	# Now test what happens if we use the end address of the block,
+	# but also supply a line table.  Does GDB do anything different?
+	run_test $producer foo_6 $dwarf_version true
+    }
 }
diff --git a/gdb/testsuite/gdb.opt/empty-inline-cxx.cc b/gdb/testsuite/gdb.opt/empty-inline-cxx.cc
new file mode 100644
index 00000000000..ca36424989d
--- /dev/null
+++ b/gdb/testsuite/gdb.opt/empty-inline-cxx.cc
@@ -0,0 +1,65 @@ 
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 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/>.  */
+
+#include "attributes.h"
+
+/* A global to do some work on.  This being volatile is important.  Without
+   this the compiler might optimise the whole program away.  */
+volatile int global = 0;
+
+__attribute__((noinline)) ATTRIBUTE_NOCLONE void
+breakpt ()
+{
+  /* Some filler work.  */
+  global++;
+}
+
+struct MyClass;
+
+struct ptr
+{
+  /* The following line is a single line to aid matching in the test
+     script.  Sometimes the DWARF will point GDB at the '{' and sometimes
+     at the body of the function.  We don't really care for this test, so
+     placing everything on one line removes this variability.  */
+  MyClass* get_myclass () { return t; }
+
+  MyClass* t;
+};
+
+struct MyClass
+{
+  void call();
+};
+
+void
+MyClass::call ()
+{
+  breakpt ();	/* Final breakpoint.  */
+}
+
+static void
+intermediate (ptr p)
+{
+  p.get_myclass ()->call ();
+}
+
+int
+main ()
+{
+  intermediate (ptr {new MyClass});
+}
diff --git a/gdb/testsuite/gdb.opt/empty-inline-cxx.exp b/gdb/testsuite/gdb.opt/empty-inline-cxx.exp
new file mode 100644
index 00000000000..1de41428f38
--- /dev/null
+++ b/gdb/testsuite/gdb.opt/empty-inline-cxx.exp
@@ -0,0 +1,96 @@ 
+# Copyright 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/>.
+
+standard_testfile .cc
+
+require {expr ![test_compiler_info gcc* c++] \
+	     || [supports_statement_frontiers] }
+
+set options {c++ debug optimize=-Og}
+lappend_include_file options $srcdir/lib/attributes.h
+if {[supports_statement_frontiers]} {
+    lappend options additional_flags=-gstatement-frontiers
+}
+
+# Some line numbers we need for the test.
+set get_myclass_line [gdb_get_line_number "MyClass* get_myclass ()"]
+set call_get_line [gdb_get_line_number "p.get_myclass ()"]
+set final_bp_line [gdb_get_line_number "Final breakpoint"]
+
+# Build the test executable adding "-OPT_LEVEL" to the compilation
+# flags.  The break on the small function which is likely to have been
+# inlined, check we stop where we expect, and that the backtrace looks
+# correct.
+#
+# Then return from the inline function and call to another function,
+# check the backtrace from this second function also looks good,
+# specifically, we're checking that the backtrace doesn't incorrectly
+# place frame #1 on the line for the inline function.
+proc run_test { opt_level } {
+
+    set opts $::options
+    lappend opts "additional_flags=-${opt_level}"
+
+    if { [prepare_for_testing "failed to prepare" "$::testfile-$opt_level" \
+	      $::srcfile $opts] } {
+	return
+    }
+
+    if { ![runto_main] } {
+	return
+    }
+
+    gdb_test "bt" "#0\\s+main \\(\\) \[^\r\n\]+/$::srcfile:$::decimal" \
+	"backtrace in main"
+
+    # Break at the empty inline function ptr::get_myclass.
+    gdb_breakpoint get_myclass
+    gdb_continue_to_breakpoint "continue to get_myclass" \
+	[multi_line \
+	     ".*/$::srcfile:$::get_myclass_line" \
+	     "$::get_myclass_line\\s+MyClass\\* get_myclass \\(\\) \[^\r\n\]+"]
+
+    # Backtrace.
+    gdb_test "bt" \
+	[multi_line \
+	     "#0\\s+ptr::get_myclass\[^\r\n\]+/$::srcfile:$::get_myclass_line" \
+	     "#1\\s+intermediate\[^\r\n\]+/$::srcfile:$::call_get_line" \
+	     "#2\\s+\[^\r\n\]+main \\(\\) \[^\r\n\]+/$::srcfile:$::decimal"] \
+	"at get_myclass"
+
+    # Print a class member variable, this should be in scope, but is often
+    # reported as optimised out.
+    gdb_test "p t" \
+	"(?:\\\$1 = \\(MyClass \\*\\) $::hex|value has been optimized out)" \
+	"print ptr::t"
+
+    gdb_breakpoint $::srcfile:$::final_bp_line
+    gdb_continue_to_breakpoint "continue to final breakpoint"
+
+    # Backtrace.  Check frame #1 looks right.  Bug gdb/25987 would report
+    # frame #1 as being the correct function, but would report the line for
+    # ptr::get_myclass(), which is not correct.
+    setup_xfail *-*-* gdb/25987
+    gdb_test "bt" \
+	[multi_line \
+	     "#0\\s+MyClass::call\[^\r\n\]+/$::srcfile:$::final_bp_line" \
+	     "#1\\s+\[^\r\n\]+ intermediate\[^\r\n\]+/$::srcfile:$::call_get_line" \
+	     "#2\\s+\[^\r\n\]+ main \\(\\) \[^\r\n\]+/$::srcfile:$::decimal"] \
+	"at call"
+}
+
+foreach_with_prefix opt_level { Og O0 O1 O2 } {
+    run_test ${opt_level}
+}
diff --git a/gdb/testsuite/gdb.opt/empty-inline.c b/gdb/testsuite/gdb.opt/empty-inline.c
new file mode 100644
index 00000000000..595cb9c322f
--- /dev/null
+++ b/gdb/testsuite/gdb.opt/empty-inline.c
@@ -0,0 +1,40 @@ 
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 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/>.  */
+
+#include "attributes.h"
+
+static int
+test0 (void)
+{
+  asm (""); /* First line of test0.  */
+  return 1; /* Second line of test0.  */
+}
+
+int __attribute__((noinline)) ATTRIBUTE_NOCLONE
+test1 (int x)
+{
+  asm ("");
+  return x + 1; /* Second line of test1.  */
+}
+
+int
+main (void)
+{
+  test1 (test0 ()); /* First line of main.  */
+  test1 (test0 ()); /* Second line of main.  */
+  return 0;         /* Third line of main.  */
+}
diff --git a/gdb/testsuite/gdb.opt/empty-inline.exp b/gdb/testsuite/gdb.opt/empty-inline.exp
new file mode 100644
index 00000000000..0e9d76e4283
--- /dev/null
+++ b/gdb/testsuite/gdb.opt/empty-inline.exp
@@ -0,0 +1,111 @@ 
+# Copyright 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/>.
+
+standard_testfile
+
+require {expr ![test_compiler_info gcc* c++] \
+	     || [supports_statement_frontiers] }
+
+set options {debug nowarnings optimize=-O2}
+lappend_include_file options $srcdir/lib/attributes.h
+if {[supports_statement_frontiers]} {
+    lappend options additional_flags=-gstatement-frontiers
+}
+
+# Some line numbers we need.
+set lineno_main_1 [gdb_get_line_number "First line of main"]
+set lineno_main_2 [gdb_get_line_number "Second line of main"]
+set lineno_main_3 [gdb_get_line_number "Third line of main"]
+set lineno_test0_1 [gdb_get_line_number "First line of test0"]
+set lineno_test0_2 [gdb_get_line_number "Second line of test0"]
+set lineno_test1_2 [gdb_get_line_number "Second line of test1"]
+
+# ...
+proc run_test { opt_level } {
+
+    set opts $::options
+    lappend opts "additional_flags=-${opt_level}"
+
+    if { [prepare_for_testing "failed to prepare" "$::testfile-$opt_level" \
+	      $::srcfile $opts] } {
+	return
+    }
+
+    if { ![runto_main] } {
+	return
+    }
+
+    gdb_test "frame 0" \
+	[multi_line \
+	     "#0\\s+main \[^\r\n\]+/$::srcfile:$::lineno_main_1" \
+	     "$::lineno_main_1\\s+\[^\r\n\]+"] \
+	"frame 0 while in main"
+
+    gdb_test_multiple "step" "step into test0" {
+	-re -wrap ".*test0.*$::srcfile:$::lineno_test0_1.*" {
+	    gdb_test "step" ".*line $::lineno_test0_2.*" $gdb_test_name
+	}
+	-re -wrap ".*test0.*$::srcfile:$::lineno_test0_2.*" {
+	    pass $gdb_test_name
+	}
+    }
+
+    gdb_test "frame 1" \
+	[multi_line \
+	     "#1\\s+main \[^\r\n\]+/$::srcfile:$::lineno_main_1" \
+	     "$::lineno_main_1\\s+\[^\r\n\]+"] \
+	"inspect frame 1, main"
+
+    # Step into test1() function.
+    gdb_test "step" \
+	[multi_line \
+	     "test1 \\(\[^)\]+\\) at \[^\r\n\]+/$::srcfile:$::lineno_test1_2" \
+	     "$::lineno_test1_2\\s+\[^\r\n\]+"] \
+	"step into test1"
+
+    # Check frame #1 looks right.  Bug gdb/25987 would report frame #1 as
+    # being the correct function, but would report the line for a nearby
+    # inlined function.
+    setup_xfail *-*-* gdb/25987
+    gdb_test "frame 1" \
+	[multi_line \
+	     "#1\\s+\[^\r\n\]*main \\(\\) \[^\r\n\]+/$::srcfile:$::lineno_main_1" \
+	     "$::lineno_main_1\\s+\[^\r\n\]+"] \
+	"inspect frame 1 again, still main"
+
+    # Step from the last line of test1 back into main.
+    gdb_test "step" \
+	[multi_line \
+	     "main \\(\\) at \[^\r\n\]+/$::srcfile:$::lineno_main_2" \
+	     "$::lineno_main_2\\s+\[^\r\n\]+"] \
+	"step back to main"
+
+    # Use next to step to the last line of main.  This skips over the inline
+    # call to test0, and the non-inline call to test1.
+    gdb_test "next" \
+	"$::lineno_main_3\\s+return 0;\\s+\[^\r\n\]+" \
+	"step over test0+1"
+
+    # Sanity check that we are in main like we expect.
+    gdb_test "frame 0" \
+	[multi_line \
+	     "#0\\s+main \[^\r\n\]+/$::srcfile:$::lineno_main_3" \
+	     "$::lineno_main_3\\s+return 0;\\s+\[^\r\n\]+"] \
+	"confirm expected frame in main"
+}
+
+foreach_with_prefix opt_level { Og O0 O1 O2 } {
+    run_test ${opt_level}
+}