[PATCH v3 1/1] gdb/linespec: relax block filter to preserve distinct code paths

[Klaus Gerlicher <klaus.gerlicher@intel.com>]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain; charset=y, Size: 41556 bytes --]

From: "Gerlicher, Klaus" <klaus.gerlicher@intel.com>

The block-based duplicate filter in create_sals_line_offset keeps only
the first is_stmt line table entry per block.  This heuristic reduces
multiple for-loop header entries (init/test/increment on same line) to
single breakpoint locations.  However, it is too aggressive for
vectorized loops, where the compiler emits separate code regions for
the vectorized body and scalar remainder, both on the same source line.
The filter discards the scalar remainder entry, causing breakpoints to
be silently missed when only the scalar path executes.

The old heuristic collapses all same-block SALs for a given line down to
a single breakpoint location, while the new heuristic preserves additional
SALs when the instruction range between them ends with an unconditional jump
or return, indicating they lie on genuinely distinct, non-fall-through code
paths.

The fix introduces range_has_unconditional_flow_control, which analyzes
the instruction stream for two conditions indicating distinct code paths:

1. Unconditional exit: The last instruction before the second PC is an
   unconditional jmp or ret (execution cannot fall through).

2. Backward branch: Any instruction in the range is a relative branch
   targeting before the first PC (loop back-edge indicating separate
   loop bodies).

A new gdbarch method gdbarch_insn_branch_target decodes relative branch
targets. Implemented for amd64 and aarch64; other architectures default
to conservative behavior, preserving backward compatibility.

Existing gdbarch_insn_is_jump and gdbarch_insn_is_ret are now also
implemented for aarch64, enabling the heuristic on that platform too.
Predicate functions are added to allow for chosing viability of this extended
heuristic.  Implemented on x86_64 and aarch64.

Testing covers:
- for_loop_empty_body (-O0): 1 location
- for_loop_large_body (-O0): 1 location
- for_loop_vectorized (-O2): >= 2 locations with runtime verification
- nested_vectorized_loops (-O2): >= 2 locations
- loop_with_early_break (-O2): >= 2 or 1 location
- ifelse_separate_lines (-O0): 2 locations on x86_64/aarch64, unsupported
  elsewhere
- set/show linespec-extended-block-filter reports on/off and
  architecture support correctly

Tested with GCC 11 and ICX 2025.2 on x86_64, and on aarch64 (raspi5).
---
 gdb/NEWS                                      |  11 +
 gdb/aarch64-tdep.c                            |  91 ++++++
 gdb/amd64-tdep.c                              |  57 ++++
 gdb/arch-utils.c                              |  10 +
 gdb/arch-utils.h                              |   1 +
 gdb/arch/aarch64-insn.c                       |  23 ++
 gdb/arch/aarch64-insn.h                       |   2 +
 gdb/gdbarch-gen.c                             |  59 +++-
 gdb/gdbarch-gen.h                             |  16 +
 gdb/gdbarch_components.py                     |  18 ++
 gdb/linespec.c                                | 148 ++++++++-
 .../gdb.linespec/block-filter-cases.c         | 126 ++++++++
 .../gdb.linespec/block-filter-cases.exp       | 291 ++++++++++++++++++
 13 files changed, 848 insertions(+), 5 deletions(-)
 create mode 100644 gdb/testsuite/gdb.linespec/block-filter-cases.c
 create mode 100644 gdb/testsuite/gdb.linespec/block-filter-cases.exp

diff --git a/gdb/NEWS b/gdb/NEWS
index 8f40ca5cb11..b587ac87763 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -68,6 +68,17 @@
   This fixes an issue where GDB could fail to find a type when relying
   on the index.  Any existing indexes should be regenerated.
 
+* Breakpoint location resolution has been improved for vectorized loops.
+  Previously, when setting a breakpoint on a source line with vectorized
+  code (at -O2 with -ftree-vectorize), GDB's block filter heuristic would
+  discard the scalar remainder location, causing breakpoints to be missed
+  when only the scalar path executed. GDB now correctly preserves multiple
+  locations for vectorized and scalar loop paths, improving debuggability
+  of optimized code.  This is supported currently on x86 and aarch64.
+
+  Use "set linespec-extended-block-filter off" to disable the new
+  heuristic on supported platforms and revert to the original behavior if needed.
+
 * Support for Floating Point Mode Register (FPMR) in AArch64.
 
 * When running on the Windows Terminal console, GDB now supports
diff --git a/gdb/aarch64-tdep.c b/gdb/aarch64-tdep.c
index a84da1fd59e..5b45efbf8b9 100644
--- a/gdb/aarch64-tdep.c
+++ b/gdb/aarch64-tdep.c
@@ -4433,6 +4433,92 @@ aarch64_initialize_sme_pseudo_names (struct gdbarch *gdbarch,
     }
 }
 
+/* Return the statically-known target of a relative branch instruction.
+   Handles B <imm26>, B.cond <imm19>, CBZ/CBNZ <imm19>, TBZ/TBNZ <imm14>.
+   Returns std::nullopt for indirect branches (BR) or unreadable memory.  */
+
+static std::optional<CORE_ADDR>
+aarch64_insn_branch_target (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+  gdb_byte buf[4];
+
+  if (target_read_memory (addr, buf, 4) != 0)
+    return std::nullopt;
+
+  enum bfd_endian byte_order = gdbarch_byte_order_for_code (gdbarch);
+  uint32_t insn = extract_unsigned_integer (buf, 4, byte_order);
+
+  int is_bl;
+  int32_t offset;
+
+  /* B <imm26> (but not BL, which is a call).  */
+  if (aarch64_decode_b (addr, insn, &is_bl, &offset) && !is_bl)
+    return addr + offset;
+
+  /* B.cond <imm19>.  */
+  unsigned cond;
+  if (aarch64_decode_bcond (addr, insn, &cond, &offset))
+    return addr + offset;
+
+  /* CBZ/CBNZ <imm19>.  */
+  int is64, is_cbnz;
+  unsigned rn;
+  if (aarch64_decode_cb (addr, insn, &is64, &is_cbnz, &rn, &offset))
+    return addr + offset;
+
+  /* TBZ/TBNZ <imm14>.  */
+  int is_tbnz;
+  unsigned bit, rt;
+  if (aarch64_decode_tb (addr, insn, &is_tbnz, &bit, &rt, &offset))
+    return addr + offset;
+
+  return std::nullopt;
+}
+
+/* Return true if the instruction at ADDR is an unconditional branch.
+   Handles direct B <imm26> and indirect BR <Xn>.  */
+
+static bool
+aarch64_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+  gdb_byte buf[4];
+
+  if (target_read_memory (addr, buf, 4) != 0)
+    return false;
+
+  enum bfd_endian byte_order = gdbarch_byte_order_for_code (gdbarch);
+  uint32_t insn = extract_unsigned_integer (buf, 4, byte_order);
+
+  /* B <imm26> (but not BL, which is a call).  */
+  int is_bl;
+  int32_t offset;
+  if (aarch64_decode_b (addr, insn, &is_bl, &offset) && !is_bl)
+    return true;
+
+  /* BR <Xn>: bits[31:10] fixed, bits[9:5] = Xn, bits[4:0] = 0.
+     No shared decoder exists for indirect branches.  */
+  if ((insn & 0xFFFFFC1F) == 0xD61F0000)
+    return true;
+
+  return false;
+}
+
+/* Return true if the instruction at ADDR is a return.  */
+
+static bool
+aarch64_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+  gdb_byte buf[4];
+
+  if (target_read_memory (addr, buf, 4) != 0)
+    return false;
+
+  enum bfd_endian byte_order = gdbarch_byte_order_for_code (gdbarch);
+  uint32_t insn = extract_unsigned_integer (buf, 4, byte_order);
+
+  return aarch64_decode_ret (addr, insn);
+}
+
 /* Initialize the current architecture based on INFO.  If possible,
    reuse an architecture from ARCHES, which is a list of
    architectures already created during this debugging session.
@@ -4861,6 +4947,11 @@ aarch64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_program_breakpoint_here_p (gdbarch,
 					 aarch64_program_breakpoint_here_p);
 
+  /* Instruction stream analysis.  */
+  set_gdbarch_insn_is_jump (gdbarch, aarch64_insn_is_jump);
+  set_gdbarch_insn_is_ret (gdbarch, aarch64_insn_is_ret);
+  set_gdbarch_insn_branch_target (gdbarch, aarch64_insn_branch_target);
+
   /* Add some default predicates.  */
   frame_unwind_append_unwinder (gdbarch, &aarch64_stub_unwind);
   dwarf2_append_unwinders (gdbarch);
diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c
index a982e610642..726bc475256 100644
--- a/gdb/amd64-tdep.c
+++ b/gdb/amd64-tdep.c
@@ -1822,6 +1822,62 @@ amd64_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
   return amd64_classify_insn_at (gdbarch, addr, amd64_jmp_p);
 }
 
+/* Return the statically-known target of a relative branch instruction
+   (conditional Jcc, JMP, LOOP, JCXZ).  Return std::nullopt for non-branch,
+   indirect branches, or when memory cannot be read.  */
+
+static std::optional<CORE_ADDR>
+amd64_insn_branch_target (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+  gdb_byte buf[16];
+
+  /* Read enough bytes for the longest relative-branch encoding.  */
+  if (target_read_memory (addr, buf, sizeof (buf)) != 0)
+    return std::nullopt;
+
+  /* Skip a single REX prefix byte (0x40-0x4F).  */
+  int off = 0;
+  if ((buf[0] & 0xf0) == 0x40)
+    off = 1;
+
+  const gdb_byte opc = buf[off];
+
+  /* Short conditional Jcc: 7x cc  (2 bytes, signed 8-bit displacement).  */
+  if ((opc & 0xf0) == 0x70)
+    return addr + off + 2 + (LONGEST) (signed char) buf[off + 1];
+
+  /* Short unconditional JMP: EB cc  (2 bytes).  */
+  if (opc == 0xeb)
+    return addr + off + 2 + (LONGEST) (signed char) buf[off + 1];
+
+  /* LOOP/LOOPE/LOOPNE: E2/E1/E0 cc  (2 bytes, signed 8-bit displacement).  */
+  if ((opc & 0xfd) == 0xe0)
+    return addr + off + 2 + (LONGEST) (signed char) buf[off + 1];
+
+  /* JCXZ/JECXZ/JRCXZ: E3 cc  (2 bytes, signed 8-bit displacement).  */
+  if (opc == 0xe3)
+    return addr + off + 2 + (LONGEST) (signed char) buf[off + 1];
+
+  /* Near conditional Jcc: 0F 8x cc cc cc cc  (6 bytes, signed 32-bit).  */
+  if (opc == 0x0f && (buf[off + 1] & 0xf0) == 0x80)
+    {
+      int32_t disp;
+      memcpy (&disp, buf + off + 2, sizeof (disp));
+      return addr + off + 6 + (LONGEST) disp;
+    }
+
+  /* Near unconditional JMP: E9 cc cc cc cc  (5 bytes, signed 32-bit).  */
+  if (opc == 0xe9)
+    {
+      int32_t disp;
+      memcpy (&disp, buf + off + 1, sizeof (disp));
+      return addr + off + 5 + (LONGEST) disp;
+    }
+
+  /* Indirect or far branches: target cannot be determined statically.  */
+  return std::nullopt;
+}
+
 /* Fix up the state of registers and memory after having single-stepped
    a displaced instruction.  */
 
@@ -3643,6 +3699,7 @@ amd64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch,
   set_gdbarch_insn_is_call (gdbarch, amd64_insn_is_call);
   set_gdbarch_insn_is_ret (gdbarch, amd64_insn_is_ret);
   set_gdbarch_insn_is_jump (gdbarch, amd64_insn_is_jump);
+  set_gdbarch_insn_branch_target (gdbarch, amd64_insn_branch_target);
 
   set_gdbarch_in_indirect_branch_thunk (gdbarch,
 					amd64_in_indirect_branch_thunk);
diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c
index e959788bd3b..f73d1581f09 100644
--- a/gdb/arch-utils.c
+++ b/gdb/arch-utils.c
@@ -45,6 +45,8 @@
 
 #include "dis-asm.h"
 
+#include <optional>
+
 bool
 default_displaced_step_hw_singlestep (struct gdbarch *gdbarch)
 {
@@ -923,6 +925,14 @@ default_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
 
 /*  See arch-utils.h.  */
 
+std::optional<CORE_ADDR>
+default_insn_branch_target (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+  return std::nullopt;
+}
+
+/*  See arch-utils.h.  */
+
 bool
 default_program_breakpoint_here_p (struct gdbarch *gdbarch,
 				   CORE_ADDR address)
diff --git a/gdb/arch-utils.h b/gdb/arch-utils.h
index 06902050043..46d9d89e668 100644
--- a/gdb/arch-utils.h
+++ b/gdb/arch-utils.h
@@ -327,6 +327,7 @@ extern bool default_return_in_first_hidden_param_p (struct gdbarch *,
 extern bool default_insn_is_call (struct gdbarch *, CORE_ADDR);
 extern bool default_insn_is_ret (struct gdbarch *, CORE_ADDR);
 extern bool default_insn_is_jump (struct gdbarch *, CORE_ADDR);
+extern std::optional<CORE_ADDR> default_insn_branch_target (struct gdbarch *, CORE_ADDR);
 
 /* Default implementation of gdbarch_program_breakpoint_here_p.  */
 extern bool default_program_breakpoint_here_p (struct gdbarch *gdbarch,
diff --git a/gdb/arch/aarch64-insn.c b/gdb/arch/aarch64-insn.c
index f6089092eca..3ab28e6dd4b 100644
--- a/gdb/arch/aarch64-insn.c
+++ b/gdb/arch/aarch64-insn.c
@@ -201,6 +201,29 @@ aarch64_decode_tb (CORE_ADDR addr, uint32_t insn, int *is_tbnz,
   return 0;
 }
 
+/* Decode an opcode if it represents a RET instruction.
+
+   ADDR specifies the address of the opcode.
+   INSN specifies the opcode to test.
+
+   Return 1 if the opcodes matches and is decoded, otherwise 0.  */
+
+int
+aarch64_decode_ret (CORE_ADDR addr, uint32_t insn)
+{
+  /* ret b1101 0110 0100 nnnn n000 0000 0000 0000 */
+  if (decode_masked_match (insn, 0xFFE0FFFF, 0xD6400000))
+    {
+      unsigned int rn = (insn >> 15) & 0x1f;
+
+      aarch64_debug_printf ("decode: 0x%s 0x%x x%u",
+			    core_addr_to_string_nz (addr), insn,
+			    rn);
+      return 1;
+    }
+  return 0;
+}
+
 /* Decode an opcode if it represents an LDR or LDRSW instruction taking a
    literal offset from the current PC.
 
diff --git a/gdb/arch/aarch64-insn.h b/gdb/arch/aarch64-insn.h
index 428e53c3858..aafbe3c0d6b 100644
--- a/gdb/arch/aarch64-insn.h
+++ b/gdb/arch/aarch64-insn.h
@@ -200,6 +200,8 @@ int aarch64_decode_tb (CORE_ADDR addr, uint32_t insn, int *is_tbnz,
 int aarch64_decode_ldr_literal (CORE_ADDR addr, uint32_t insn, int *is_w,
 				int *is64, unsigned *rt, int32_t *offset);
 
+int aarch64_decode_ret (CORE_ADDR addr, uint32_t insn);
+
 /* Data passed to each method of aarch64_insn_visitor.  */
 
 struct aarch64_insn_data
diff --git a/gdb/gdbarch-gen.c b/gdb/gdbarch-gen.c
index f424fa2a86e..1cbb6459f87 100644
--- a/gdb/gdbarch-gen.c
+++ b/gdb/gdbarch-gen.c
@@ -234,6 +234,7 @@ struct gdbarch
   gdbarch_insn_is_call_ftype *insn_is_call = default_insn_is_call;
   gdbarch_insn_is_ret_ftype *insn_is_ret = default_insn_is_ret;
   gdbarch_insn_is_jump_ftype *insn_is_jump = default_insn_is_jump;
+  gdbarch_insn_branch_target_ftype *insn_branch_target = default_insn_branch_target;
   gdbarch_program_breakpoint_here_p_ftype *program_breakpoint_here_p = default_program_breakpoint_here_p;
   gdbarch_auxv_parse_ftype *auxv_parse = nullptr;
   gdbarch_print_auxv_entry_ftype *print_auxv_entry = default_print_auxv_entry;
@@ -492,8 +493,9 @@ verify_gdbarch (struct gdbarch *gdbarch)
   /* Skip verify of core_info_proc, has predicate.  */
   /* Skip verify of ravenscar_ops, invalid_p == 0.  */
   /* Skip verify of insn_is_call, invalid_p == 0.  */
-  /* Skip verify of insn_is_ret, invalid_p == 0.  */
-  /* Skip verify of insn_is_jump, invalid_p == 0.  */
+  /* Skip verify of insn_is_ret, has predicate.  */
+  /* Skip verify of insn_is_jump, has predicate.  */
+  /* Skip verify of insn_branch_target, has predicate.  */
   /* Skip verify of program_breakpoint_here_p, invalid_p == 0.  */
   /* Skip verify of auxv_parse, has predicate.  */
   /* Skip verify of print_auxv_entry, invalid_p == 0.  */
@@ -1270,12 +1272,24 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
   gdb_printf (file,
 	      "gdbarch_dump: insn_is_call = <%s>\n",
 	      host_address_to_string (gdbarch->insn_is_call));
+  gdb_printf (file,
+	      "gdbarch_dump: gdbarch_insn_is_ret_p() = %d\n",
+	      gdbarch_insn_is_ret_p (gdbarch));
   gdb_printf (file,
 	      "gdbarch_dump: insn_is_ret = <%s>\n",
 	      host_address_to_string (gdbarch->insn_is_ret));
+  gdb_printf (file,
+	      "gdbarch_dump: gdbarch_insn_is_jump_p() = %d\n",
+	      gdbarch_insn_is_jump_p (gdbarch));
   gdb_printf (file,
 	      "gdbarch_dump: insn_is_jump = <%s>\n",
 	      host_address_to_string (gdbarch->insn_is_jump));
+  gdb_printf (file,
+	      "gdbarch_dump: gdbarch_insn_branch_target_p() = %d\n",
+	      gdbarch_insn_branch_target_p (gdbarch));
+  gdb_printf (file,
+	      "gdbarch_dump: insn_branch_target = <%s>\n",
+	      host_address_to_string (gdbarch->insn_branch_target));
   gdb_printf (file,
 	      "gdbarch_dump: program_breakpoint_here_p = <%s>\n",
 	      host_address_to_string (gdbarch->program_breakpoint_here_p));
@@ -4916,11 +4930,19 @@ set_gdbarch_insn_is_call (struct gdbarch *gdbarch,
   gdbarch->insn_is_call = insn_is_call;
 }
 
+bool
+gdbarch_insn_is_ret_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != nullptr);
+  return gdbarch->insn_is_ret != default_insn_is_ret;
+}
+
 bool
 gdbarch_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr)
 {
   gdb_assert (gdbarch != nullptr);
   gdb_assert (gdbarch->insn_is_ret != nullptr);
+  /* Do not check predicate: gdbarch->insn_is_ret != default_insn_is_ret, allow call.  */
   if (gdbarch_debug >= 2)
     gdb_printf (gdb_stdlog, "gdbarch_insn_is_ret called\n");
   return gdbarch->insn_is_ret (gdbarch, addr);
@@ -4933,11 +4955,19 @@ set_gdbarch_insn_is_ret (struct gdbarch *gdbarch,
   gdbarch->insn_is_ret = insn_is_ret;
 }
 
+bool
+gdbarch_insn_is_jump_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != nullptr);
+  return gdbarch->insn_is_jump != default_insn_is_jump;
+}
+
 bool
 gdbarch_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
 {
   gdb_assert (gdbarch != nullptr);
   gdb_assert (gdbarch->insn_is_jump != nullptr);
+  /* Do not check predicate: gdbarch->insn_is_jump != default_insn_is_jump, allow call.  */
   if (gdbarch_debug >= 2)
     gdb_printf (gdb_stdlog, "gdbarch_insn_is_jump called\n");
   return gdbarch->insn_is_jump (gdbarch, addr);
@@ -4950,6 +4980,31 @@ set_gdbarch_insn_is_jump (struct gdbarch *gdbarch,
   gdbarch->insn_is_jump = insn_is_jump;
 }
 
+bool
+gdbarch_insn_branch_target_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != nullptr);
+  return gdbarch->insn_branch_target != default_insn_branch_target;
+}
+
+std::optional<CORE_ADDR>
+gdbarch_insn_branch_target (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+  gdb_assert (gdbarch != nullptr);
+  gdb_assert (gdbarch->insn_branch_target != nullptr);
+  /* Do not check predicate: gdbarch->insn_branch_target != default_insn_branch_target, allow call.  */
+  if (gdbarch_debug >= 2)
+    gdb_printf (gdb_stdlog, "gdbarch_insn_branch_target called\n");
+  return gdbarch->insn_branch_target (gdbarch, addr);
+}
+
+void
+set_gdbarch_insn_branch_target (struct gdbarch *gdbarch,
+				gdbarch_insn_branch_target_ftype insn_branch_target)
+{
+  gdbarch->insn_branch_target = insn_branch_target;
+}
+
 bool
 gdbarch_program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address)
 {
diff --git a/gdb/gdbarch-gen.h b/gdb/gdbarch-gen.h
index 678b308fba5..6a6e9ed40f1 100644
--- a/gdb/gdbarch-gen.h
+++ b/gdb/gdbarch-gen.h
@@ -1582,16 +1582,32 @@ void set_gdbarch_insn_is_call (struct gdbarch *gdbarch, gdbarch_insn_is_call_fty
 
 /* Return true if the instruction at ADDR is a return; false otherwise. */
 
+bool gdbarch_insn_is_ret_p (struct gdbarch *gdbarch);
+
 using gdbarch_insn_is_ret_ftype = bool (struct gdbarch *gdbarch, CORE_ADDR addr);
 bool gdbarch_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr);
 void set_gdbarch_insn_is_ret (struct gdbarch *gdbarch, gdbarch_insn_is_ret_ftype *insn_is_ret);
 
 /* Return true if the instruction at ADDR is a jump; false otherwise. */
 
+bool gdbarch_insn_is_jump_p (struct gdbarch *gdbarch);
+
 using gdbarch_insn_is_jump_ftype = bool (struct gdbarch *gdbarch, CORE_ADDR addr);
 bool gdbarch_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr);
 void set_gdbarch_insn_is_jump (struct gdbarch *gdbarch, gdbarch_insn_is_jump_ftype *insn_is_jump);
 
+/* For a relative branch instruction at ADDR (conditional or
+   unconditional), return the statically-known branch target address.
+   Return std::nullopt for non-branch instructions, indirect branches,
+   or when reading memory fails.  This is used to detect backward
+   loop back-edges during DWARF line-table analysis. */
+
+bool gdbarch_insn_branch_target_p (struct gdbarch *gdbarch);
+
+using gdbarch_insn_branch_target_ftype = std::optional<CORE_ADDR> (struct gdbarch *gdbarch, CORE_ADDR addr);
+std::optional<CORE_ADDR> gdbarch_insn_branch_target (struct gdbarch *gdbarch, CORE_ADDR addr);
+void set_gdbarch_insn_branch_target (struct gdbarch *gdbarch, gdbarch_insn_branch_target_ftype *insn_branch_target);
+
 /* Return true if there's a program/permanent breakpoint planted in
    memory at ADDRESS, return false otherwise. */
 
diff --git a/gdb/gdbarch_components.py b/gdb/gdbarch_components.py
index b9304d3036d..df5ddefffcb 100644
--- a/gdb/gdbarch_components.py
+++ b/gdb/gdbarch_components.py
@@ -2509,6 +2509,7 @@ Return true if the instruction at ADDR is a return; false otherwise.
     type="bool",
     name="insn_is_ret",
     params=[("CORE_ADDR", "addr")],
+    predicate=True,
     predefault="default_insn_is_ret",
     invalid=False,
 )
@@ -2520,10 +2521,27 @@ Return true if the instruction at ADDR is a jump; false otherwise.
     type="bool",
     name="insn_is_jump",
     params=[("CORE_ADDR", "addr")],
+    predicate=True,
     predefault="default_insn_is_jump",
     invalid=False,
 )
 
+Method(
+    comment="""
+For a relative branch instruction at ADDR (conditional or
+unconditional), return the statically-known branch target address.
+Return std::nullopt for non-branch instructions, indirect branches,
+or when reading memory fails.  This is used to detect backward
+loop back-edges during DWARF line-table analysis.
+""",
+    type="std::optional<CORE_ADDR>",
+    name="insn_branch_target",
+    params=[("CORE_ADDR", "addr")],
+    predicate=True,
+    predefault="default_insn_branch_target",
+    invalid=False,
+)
+
 Method(
     comment="""
 Return true if there's a program/permanent breakpoint planted in
diff --git a/gdb/linespec.c b/gdb/linespec.c
index b6505ba283d..1992fc62e4a 100644
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -44,9 +44,12 @@
 #include "gdbsupport/function-view.h"
 #include "gdbsupport/def-vector.h"
 #include <algorithm>
+#include "disasm.h"
+#include "gdbarch.h"
 #include "inferior.h"
 #include "gdbsupport/unordered_set.h"
 #include "cli/cli-style.h"
+#include "cli/cli-cmds.h"
 
 /* An enumeration of the various things a user might attempt to
    complete for a linespec location.  */
@@ -432,6 +435,9 @@ static bool compare_msymbols (const bound_minimal_symbol &a,
    previous parser.  */
 static const char linespec_quote_characters[] = "\"\'";
 
+/* Control whether the extended block-filter heuristic is enabled.  */
+static bool debug_linespec_extended_block_filter = true;
+
 /* Lexer functions.  */
 
 /* Lex a number from the input in PARSER.  This only supports
@@ -1986,6 +1992,52 @@ canonicalize_linespec (struct linespec_state *state, const linespec *ls)
     explicit_loc->set_string (explicit_loc->to_linespec ());
 }
 
+/* Return true if PC_TO is unreachable by fall-through from PC_FROM.
+   Two conditions are sufficient: (1) any ret in [PC_FROM, PC_TO), or
+   (2) unconditional jump immediately before PC_TO.  Only the last
+   instruction before PC_TO matters; mid-range branches are ignored to
+   preserve for-loop deduplication.  */
+
+static bool
+range_has_unconditional_flow_control (struct gdbarch *gdbarch,
+				      CORE_ADDR pc_from, CORE_ADDR pc_to)
+{
+  /* Return true if: last instruction before PC_TO is unconditional
+     jmp/ret, or any instruction in range is a backward branch
+     (indicating separate loop bodies).  */
+
+  CORE_ADDR pc = pc_from;
+
+  while (pc < pc_to)
+    {
+      try
+	{
+	  int len = gdb_insn_length (gdbarch, pc);
+	  if (len <= 0)
+	    return false;
+
+	  /* Check for backward branch (loop back-edge).  */
+	  std::optional<CORE_ADDR> target
+	    = gdbarch_insn_branch_target (gdbarch, pc);
+	  if (target.has_value () && target.value () < pc_from)
+	    return true;
+
+	  /* Is this the last instruction before PC_TO?  */
+	  if (pc + len >= pc_to)
+	    return gdbarch_insn_is_jump (gdbarch, pc)
+	      || gdbarch_insn_is_ret (gdbarch, pc);
+
+	  pc += len;
+	}
+      catch (const gdb_exception_error &)
+	{
+	  return false;
+	}
+    }
+
+  return false;
+}
+
 /* Given a line offset in LS, construct the relevant SALs.  */
 
 static std::vector<symtab_and_line>
@@ -2084,13 +2136,33 @@ create_sals_line_offset (struct linespec_state *self,
 
       for (i = 0; i < intermediate_results.size (); ++i)
 	{
-	  if (blocks[i] != NULL)
+	  if (blocks[i] != NULL && filter[i])
 	    for (j = i + 1; j < intermediate_results.size (); ++j)
 	      {
-		if (blocks[j] == blocks[i])
+		if (blocks[j] == blocks[i] && filter[j])
 		  {
+		    const symtab_and_line &sal_i = intermediate_results[i];
+		    const symtab_and_line &sal_j = intermediate_results[j];
+
+		    auto [pc_lo, pc_hi] = std::minmax (sal_i.pc, sal_j.pc);
+
+		    /* Without symtab info, don't filter — we can't reliably
+		       determine if these are distinct code paths.  */
+		    if (sal_i.symtab == nullptr || sal_j.symtab != sal_i.symtab)
+		      continue;
+
+		    /* Check for unconditional flow control in the range
+		       (extended heuristic; can be disabled).  Memory read
+		       failures are handled gracefully inside the helper.  */
+		    objfile *ofile = sal_i.symtab->compunit ().objfile ();
+		    gdbarch *gdbarch = ofile->arch ();
+
+		    if (debug_linespec_extended_block_filter
+			&& range_has_unconditional_flow_control (gdbarch,
+								 pc_lo, pc_hi))
+		      continue;
+
 		    filter[j] = 0;
-		    break;
 		  }
 	      }
 	}
@@ -4343,3 +4415,73 @@ get_gdb_linespec_parser_quote_characters (void)
 {
   return linespec_quote_characters;
 }
+
+/* Return true if architecture implements the insn_is_jump/insn_branch_target
+   methods for the extended block-filter heuristic.  */
+
+static bool
+extended_block_filter_supported (struct gdbarch *gdbarch)
+{
+  return (gdbarch_insn_is_jump_p (gdbarch)
+	  && gdbarch_insn_is_ret_p(gdbarch)
+	  && gdbarch_insn_branch_target_p (gdbarch));
+}
+
+/* Callback for "show linespec-extended-block-filter".  Distinguishes
+   the user's requested setting from whether it actually has any
+   effect on the current architecture.  */
+
+static void
+show_debug_linespec_extended_block_filter (struct ui_file *file,
+					   int from_tty,
+					   struct cmd_list_element *c,
+					   const char *value)
+{
+  struct gdbarch *gdbarch = current_inferior ()->arch ();
+
+  gdb_printf (file,
+	     _("The extended block-filter heuristic is set to %s "
+	       "(architecture support for %s: %s).\n"),
+	     value,
+	     gdbarch_bfd_arch_info (gdbarch)->printable_name,
+	     extended_block_filter_supported (gdbarch) ? "yes" : "no");
+}
+
+/* Callback for "set linespec-extended-block-filter".  Warn when
+   turning the setting on has no effect because the current
+   architecture doesn't implement the heuristic.  */
+
+static void
+set_debug_linespec_extended_block_filter (const char *args, int from_tty,
+					  struct cmd_list_element *c)
+{
+  struct gdbarch *gdbarch = current_inferior ()->arch ();
+
+  if (debug_linespec_extended_block_filter
+      && !extended_block_filter_supported (gdbarch))
+    warning (_("the extended block-filter heuristic is not implemented "
+	      "for %s; breakpoint location resolution will keep using "
+	      "the original heuristic"),
+	    gdbarch_bfd_arch_info (gdbarch)->printable_name);
+}
+
+/* Register linespec debugging commands.  */
+
+INIT_GDB_FILE (linespec)
+{
+  add_setshow_boolean_cmd ("linespec-extended-block-filter",
+			   class_support,
+			   &debug_linespec_extended_block_filter, _("\
+Set whether the extended block-filter heuristic is enabled."), _("\
+Show whether the extended block-filter heuristic is enabled."), _("\
+The extended heuristic improves breakpoint location resolution for\n\
+vectorized loops at -O2. When off, breakpoints use only the original\n\
+heuristic, which may miss locations in vectorized code. Only\n\
+architectures that implement gdbarch_insn_is_jump or\n\
+gdbarch_insn_branch_target actually apply the extended heuristic;\n\
+on others this setting has no effect.\n\
+Default is on."),
+			   set_debug_linespec_extended_block_filter,
+			   show_debug_linespec_extended_block_filter,
+			   &setlist, &showlist);
+}
diff --git a/gdb/testsuite/gdb.linespec/block-filter-cases.c b/gdb/testsuite/gdb.linespec/block-filter-cases.c
new file mode 100644
index 00000000000..8cf834e95f4
--- /dev/null
+++ b/gdb/testsuite/gdb.linespec/block-filter-cases.c
@@ -0,0 +1,126 @@
+/* Test cases for the block-filter heuristic in create_sals_line_offset.
+
+   Copyright (C) 2026 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   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/>.
+
+   One function per tested pattern.  The accompanying .exp file verifies
+   the breakpoint location count for each pattern and, where vectorisation
+   is present, confirms that both the vectorized and scalar-remainder paths
+   are reachable at runtime.
+
+   argc > 1  ->  for_loop_vectorized called with n=1024  (vectorized path)
+   argc == 1 ->  for_loop_vectorized called with n=3     (scalar path only)  */
+
+volatile int sink;
+
+/* for-loop with empty body (-O0).  Expected: 1 location.  */
+
+void __attribute__ ((noinline))
+for_loop_empty_body (int n)
+{
+  for (int i = 0; i < n; i++) {}  /* empty-for-line */
+}
+
+/* for-loop with large body (-O0).  Expected: 1 location.  */
+
+void __attribute__ ((noinline))
+for_loop_large_body (volatile int *a, volatile int *b, volatile int *c,
+		     int n)
+{
+  for (int i = 0; i < n; i++) {  /* large-body-for-line */
+    sink = a[i] * 3 + b[i];
+    sink = sink ^ (sink >> 5);
+    sink += c[i] * 7 - a[i];
+    sink = (sink << 3) | (sink >> 29);
+    sink += a[i] + b[i] + c[i];
+    sink = sink * sink + a[i];
+    sink ^= b[i] * c[i];
+    sink += (a[i] | b[i]) & c[i];
+    sink = sink - a[i] * b[i];
+    sink += c[i] ^ (a[i] + b[i]);
+    sink += a[i] * 5 - b[i] * 3;
+    sink ^= (sink << 7) | (sink >> 25);
+    sink += c[i] * c[i] + a[i];
+    sink = sink / (a[i] + 1);
+    sink += b[i] * b[i] - c[i];
+    sink ^= a[i] ^ b[i] ^ c[i];
+    sink += (a[i] + b[i]) * (b[i] + c[i]);
+    sink = (sink >> 3) + a[i];
+    sink += c[i] * (a[i] - b[i]);
+    sink ^= sink >> 1;
+  }
+}
+
+/* Vectorized for-loop (-O2).  Expected: >= 2 locations.  */
+
+void __attribute__ ((noinline))
+for_loop_vectorized (int *arr, int n)
+{
+  for (int i = 0; i < n; i++)
+    arr[i] = i * 3;  /* vec-loop-line */
+}
+
+/* Nested vectorized for-loops (-O2).  Expected: >= 2 locations.  */
+
+void __attribute__ ((noinline))
+nested_vectorized_loops (int *arr, int n)
+{
+  for (int i = 0; i < n; i++)
+    for (int j = 0; j < n; j++)
+      arr[i * n + j] = i * j;  /* nested-vec-line */
+}
+
+/* For-loop with early break (-O2).  Expected: >= 2 or 1 location.  */
+
+void __attribute__ ((noinline))
+loop_with_early_break (int *arr, int n, int target)
+{
+  for (int i = 0; i < n; i++) {
+    arr[i] = i * 2;  /* break-loop-line */
+    if (arr[i] == target)
+      break;
+  }
+}
+
+/* If-else with both branches on same line (-O0).  Expected: 2 locations.  */
+
+void __attribute__ ((noinline))
+ifelse_separate_lines (int x, int *result)
+{
+  if (x > 0)
+    *result = x * 2;  else *result = -x;  /* ifelse-line */
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int arr[1024];
+  volatile int a[4] = {1, 2, 3, 4};
+  volatile int b[4] = {4, 3, 2, 1};
+  volatile int c[4] = {1, 1, 1, 1};
+  int result = 0;
+
+  for_loop_empty_body (4);
+  for_loop_large_body (a, b, c, 4);
+  for_loop_vectorized (arr, argc > 1 ? 1024 : 3);
+  nested_vectorized_loops (arr, argc > 1 ? 32 : 3);
+  loop_with_early_break (arr, argc > 1 ? 1024 : 3, 42);
+  ifelse_separate_lines (argc > 1 ? 10 : -5, &result);
+
+  return 0;
+}
diff --git a/gdb/testsuite/gdb.linespec/block-filter-cases.exp b/gdb/testsuite/gdb.linespec/block-filter-cases.exp
new file mode 100644
index 00000000000..39f36ad4a27
--- /dev/null
+++ b/gdb/testsuite/gdb.linespec/block-filter-cases.exp
@@ -0,0 +1,291 @@
+# Copyright (C) 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/>.
+#
+# Verify the block-filter heuristic against known patterns.  The compiler is
+# selected by the board file; this test uses consistent expectations across
+# compilers (GCC, ICX, etc.).
+
+standard_testfile
+
+if { [build_executable "failed to prepare (O0)" \
+      "${testfile}-O0" ${srcfile} { debug optimize=-O0 }] } {
+    return -1
+}
+
+if { [build_executable "failed to prepare (O2)" \
+      "${testfile}-O2" ${srcfile} \
+      { debug optimize=-O2 additional_flags=-ftree-vectorize }] } {
+    return -1
+}
+
+# Retrieve all target line numbers from the single shared source file.
+set line_empty_for      [gdb_get_line_number "empty-for-line" ${srcfile}]
+set line_large_body_for [gdb_get_line_number "large-body-for-line" ${srcfile}]
+set line_vec_loop       [gdb_get_line_number "vec-loop-line" ${srcfile}]
+set line_nested_vec     [gdb_get_line_number "nested-vec-line" ${srcfile}]
+set line_break_loop     [gdb_get_line_number "break-loop-line" ${srcfile}]
+set line_ifelse         [gdb_get_line_number "ifelse-line" ${srcfile}]
+
+# Return true if the extended block-filter heuristic is actually
+# implemented for the current architecture.
+proc block_filter_arch_supported { } {
+    global gdb_prompt
+    set supported -1
+    gdb_test_multiple "show linespec-extended-block-filter" \
+	"query extended block-filter architecture support" {
+	-re -wrap "architecture support for \[^\r\n\]+: yes\\)\\." {
+	    set supported 1
+	    pass $gdb_test_name
+	}
+	-re -wrap "architecture support for \[^\r\n\]+: no\\)\\." {
+	    set supported 0
+	    pass $gdb_test_name
+	}
+    }
+    return $supported
+}
+
+# Turn the extended block-filter heuristic on.
+proc enable_extended_block_filter { desc } {
+    gdb_test "set linespec-extended-block-filter on" \
+	"(warning: the extended block-filter heuristic is not implemented\
+	 for \[^\r\n\]+; breakpoint location resolution will keep using\
+	 the original heuristic)?" \
+	$desc
+}
+
+# Set breakpoint and return how many locations it resolves to.
+proc bp_nlocs { srcfile line desc } {
+    set nlocs -1
+    gdb_test_multiple "break ${srcfile}:${line}" $desc {
+	-re -wrap "Breakpoint \[0-9\]+ at .*\\((\[0-9\]+) locations\\).*" {
+	    set nlocs $expect_out(1,string)
+	    pass $desc
+	}
+	-re -wrap "Breakpoint \[0-9\]+ at .*" {
+	    set nlocs 1
+	    pass $desc
+	}
+    }
+    return $nlocs
+}
+
+clean_restart "${testfile}-O0"
+
+# Verify the linespec-extended-block-filter setting exists and works.
+gdb_test "show linespec-extended-block-filter" \
+    "The extended block-filter heuristic is set to on\
+     \\(architecture support for \[^\r\n\]+: (yes|no)\\)\\." \
+    "show default linespec-extended-block-filter (on)"
+
+gdb_test_no_output "set linespec-extended-block-filter off" \
+    "set linespec-extended-block-filter off"
+
+gdb_test "show linespec-extended-block-filter" \
+    "The extended block-filter heuristic is set to off\
+     \\(architecture support for \[^\r\n\]+: (yes|no)\\)\\." \
+    "show linespec-extended-block-filter (off)"
+
+# Re-enable: on a supported arch this must be silent; on an unsupported
+# arch prints an informational warning.
+if { [block_filter_arch_supported] } {
+    gdb_test_no_output "set linespec-extended-block-filter on" \
+	"set on produces no warning on supported arch"
+} else {
+    enable_extended_block_filter "set linespec-extended-block-filter on"
+}
+
+gdb_test "show linespec-extended-block-filter" \
+    "The extended block-filter heuristic is set to on\
+     \\(architecture support for \[^\r\n\]+: (yes|no)\\)\\." \
+    "show linespec-extended-block-filter re-enabled"
+
+with_test_prefix "for-loop empty body (-O0)" {
+    set nlocs [bp_nlocs ${srcfile} ${line_empty_for} "set breakpoint"]
+
+    if { $nlocs == 1 } {
+	pass "1 breakpoint location (correct)"
+    } else {
+	fail "expected 1 location, got $nlocs"
+    }
+
+    delete_breakpoints
+}
+
+with_test_prefix "for-loop exceeding scan limit (-O0)" {
+    set nlocs [bp_nlocs ${srcfile} ${line_large_body_for} "set breakpoint"]
+
+    if { $nlocs == 1 } {
+	pass "1 breakpoint location (correct)"
+    } else {
+	fail "expected 1 location, got $nlocs"
+    }
+
+    delete_breakpoints
+}
+
+with_test_prefix "if-else separate lines (-O0)" {
+    set nlocs [bp_nlocs ${srcfile} ${line_ifelse} "set breakpoint"]
+
+    if { $nlocs < 2 } {
+	if { [block_filter_arch_supported] } {
+	    fail "expected 2 locations, got $nlocs"
+	} else {
+	    unsupported "current arch lacks insn_is_jump support\
+			 for the extended block filter"
+	}
+    } else {
+	pass "$nlocs locations (if-else branches on same line, different blocks)"
+    }
+
+    delete_breakpoints
+}
+
+clean_restart "${testfile}-O2"
+
+with_test_prefix "for-loop vectorized (-O2)" {
+    set nlocs [bp_nlocs ${srcfile} ${line_vec_loop} "set breakpoint"]
+
+    if { $nlocs < 2 } {
+	unsupported "compiler did not produce multiple locations;\
+		     vectorization may not have fired"
+    } else {
+	pass "$nlocs locations preserved (vectorized + scalar paths)"
+    }
+
+    delete_breakpoints
+}
+
+with_test_prefix "nested vectorized loops (-O2)" {
+    set nlocs [bp_nlocs ${srcfile} ${line_nested_vec} "set breakpoint"]
+
+    if { $nlocs < 2 } {
+	unsupported "compiler did not produce multiple locations;\
+		     nested vectorization may not have fired"
+    } else {
+	pass "$nlocs locations preserved (nested paths)"
+    }
+
+    delete_breakpoints
+}
+
+with_test_prefix "loop with early break (-O2)" {
+    set nlocs [bp_nlocs ${srcfile} ${line_break_loop} "set breakpoint"]
+
+    if { $nlocs >= 2 } {
+	pass "$nlocs locations preserved (normal and break paths)"
+    } else {
+	pass "$nlocs location (break path not separately compiled)"
+    }
+
+    delete_breakpoints
+}
+
+with_test_prefix "for-loop vectorized runtime (-O2)" {
+    clean_restart "${testfile}-O2"
+
+    set nlocs [bp_nlocs ${srcfile} ${line_vec_loop} "set breakpoint (probe)"]
+    delete_breakpoints
+
+    if { $nlocs < 2 } {
+	unsupported "only 1 location; skip reachability test"
+    } else {
+	with_test_prefix "scalar (n=3)" {
+	    if { ![runto_main] } {
+		return -1
+	    }
+
+	    gdb_test "break ${srcfile}:${line_vec_loop}" \
+		"Breakpoint .* at .*" \
+		"set breakpoint"
+
+	    gdb_test "continue" \
+		"Breakpoint .*, for_loop_vectorized .*" \
+		"hit breakpoint on scalar path"
+
+	    delete_breakpoints
+	    gdb_test "continue" ".*exited normally.*" "program exits cleanly"
+	}
+
+	clean_restart "${testfile}-O2"
+	gdb_test_no_output "set args foo" "set args for vectorized run"
+
+	if { ![runto_main] } {
+	    return -1
+	}
+
+	with_test_prefix "vectorized (n=1024)" {
+	    gdb_test "break ${srcfile}:${line_vec_loop}" \
+		"Breakpoint .* at .*" \
+		"set breakpoint"
+
+	    gdb_test "continue" \
+		"Breakpoint .*, for_loop_vectorized .*" \
+		"hit breakpoint on vectorized path"
+
+	    delete_breakpoints
+	    gdb_test "continue" ".*exited normally.*" "program exits cleanly"
+	}
+    }
+}
+
+with_test_prefix "setting toggle affects resolution" {
+    clean_restart "${testfile}-O0"
+
+    # Test with extended filter ON (default).
+    enable_extended_block_filter "enable extended block-filter"
+
+    set nlocs_on [bp_nlocs ${srcfile} ${line_ifelse} \
+	"set breakpoint on if-else line with filter ON"]
+    delete_breakpoints
+
+    if { $nlocs_on < 2 } {
+	if { [block_filter_arch_supported] } {
+	    fail "expected 2 locations with extended filter ON, got $nlocs_on"
+	} else {
+	    unsupported "current arch lacks support\
+			 for the extended block filter; skipping toggle checks"
+	}
+    } else {
+	pass "if-else with extended filter ON: $nlocs_on locations"
+
+	# Test with extended filter OFF.
+	gdb_test_no_output "set linespec-extended-block-filter off" \
+	    "disable extended block-filter"
+
+	set nlocs_off [bp_nlocs ${srcfile} ${line_ifelse} \
+	    "set breakpoint on if-else line with filter OFF"]
+	delete_breakpoints
+
+	if { $nlocs_off == 1 } {
+	    pass "if-else with extended filter OFF: 1 location"
+	} else {
+	    fail "expected 1 location with extended filter OFF, got $nlocs_off"
+	}
+
+	# Verify toggling it back ON restores the two locations.
+	enable_extended_block_filter "re-enable extended block-filter"
+
+	set nlocs_on_again [bp_nlocs ${srcfile} ${line_ifelse} \
+	    "set breakpoint on if-else line with filter re-enabled"]
+	delete_breakpoints
+
+	if { $nlocs_on_again == $nlocs_on } {
+	    pass "if-else with extended filter re-enabled: $nlocs_on_again locations (verified)"
+	} else {
+	    fail "expected $nlocs_on locations after re-enabling, got $nlocs_on_again"
+	}
+    }
+}
-- 
2.34.1


[-- Attachment #2.1: Type: text/plain, Size: 333 bytes --]

Intel Deutschland GmbH

Registered Address: Dornacher Strasse 1, 85622 Feldkirchen, Germany
Tel: +49 89 991 430, www.intel.de
Managing Directors: Harry Demas, Jeffrey Schneiderman, Yin Chong Sorrell
Chairperson of the Supervisory Board: Nicole Lau
Registered Seat: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928

[-- Attachment #2.2: Type: text/html, Size: 699 bytes --]