Re: [PATCH][PR gdb/34239][PR gdb/34299] gdb: Check bounds before reading DWARF expression operands

[Guinevere Larsen <guinevere@redhat.com>]

On 6/18/26 3:01 PM, Jielun Wu wrote:
> Some DWARF expression opcodes read fixed-width operands or block payloads
> from the expression buffer before checking that the bytes are available.
> With a malformed expression, this can read past the end of the expression
> buffer.
>
> Add helpers that validate fixed-width integer reads and block payload
> skips, and use them in dwarf_expr_context::execute_stack_op.  Also guard
> the nested DW_OP_entry_value parser before reading the following opcode.
>
> Add a DWARF assembler test that exercises truncated operands for these
> opcodes.
>
> Tested on x86_64-linux.
>
> Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=34239
> Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=34299
> ---

Hi! Thanks for working on this!

I'm not too familiar with the dwarf parser, so I can only do a 
superficial review. Most of my comments are questions and nitpicks, I 
don't think you necessarily need to send a new version just from this 
review.

I have tested this and see no regressions, so feel free to add my test 
tag to the git trailers

Tested-By: Guinevere Larsen <guinevere@redhat.com>

>   gdb/dwarf2/expr.c                             | 166 +++++++++------
>   .../gdb.dwarf2/dw2-bad-dwarf-expr-bounds.exp  | 190 ++++++++++++++++++
>   2 files changed, 300 insertions(+), 56 deletions(-)
>   create mode 100644 gdb/testsuite/gdb.dwarf2/dw2-bad-dwarf-expr-bounds.exp
>
> diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c
> index c71d4725b03..ead918388a4 100644
> --- a/gdb/dwarf2/expr.c
> +++ b/gdb/dwarf2/expr.c
> @@ -1370,7 +1370,45 @@ safe_skip_leb128 (const gdb_byte *buf, const gdb_byte *buf_end)
>       error (_("DWARF expression error: ran off end of buffer reading leb128 value"));
>     return buf;
>   }
> -\f
> +
> +/* Helper to skip BYTES bytes or throw an error.  */
> +
> +static const gdb_byte *
> +safe_skip_bytes (const gdb_byte *buf, const gdb_byte *buf_end,
> +		 ULONGEST bytes)
> +{
> +  if (buf > buf_end || bytes > (ULONGEST) (buf_end - buf))
> +    error (_("DWARF expression error: ran off end of buffer reading bytes"));
> +  return buf + bytes;
> +}
> +
> +/* Helper to read a fixed-width unsigned integer or throw an error.  */
> +
> +static const gdb_byte *
> +safe_read_unsigned_integer (const gdb_byte *buf, const gdb_byte *buf_end,
> +			    int len, bfd_endian byte_order, uint64_t *r)
> +{
> +  gdb_assert (len >= 0);
> +
> +  const gdb_byte *data = buf;
> +  buf = safe_skip_bytes (buf, buf_end, len);
> +  *r = extract_unsigned_integer (data, len, byte_order);
> +  return buf;

Oh, ok, it took me a while of thinking but I think I now understand why 
you wrote it like this.

You advance the buffer first to use that as a check that it is possible 
to read that many bytes from the buffer, instead of needing to double up 
on the if condition, right?

If so, I think it would be nice to have a comment explaining it, because 
I went through 2 incorrect explanations before reaching that conclusion.

> +}
> +
> +/* Helper to read a fixed-width signed integer or throw an error.  */
> +
> +static const gdb_byte *
> +safe_read_signed_integer (const gdb_byte *buf, const gdb_byte *buf_end,
> +			  int len, bfd_endian byte_order, int64_t *r)
> +{
> +  gdb_assert (len >= 0);
> +
> +  const gdb_byte *data = buf;
> +  buf = safe_skip_bytes (buf, buf_end, len);
> +  *r = extract_signed_integer (data, len, byte_order);
> +  return buf;
Similar comment as above
> +}
>   
>   /* Check that the current operator is either at the end of an
>      expression, or that it is followed by a composition operator or by
> @@ -1478,7 +1516,7 @@ dwarf_block_to_dwarf_reg_deref (gdb::array_view<const gdb_byte> block,
>         if (buf == NULL)
>   	return -1;
>         if ((int) dwarf_reg != dwarf_reg)
> -       return -1;
> +	return -1;
>       }
>     else
>       return -1;
> @@ -1488,6 +1526,8 @@ dwarf_block_to_dwarf_reg_deref (gdb::array_view<const gdb_byte> block,
>       return -1;
>     if (offset != 0)
>       return -1;
> +  if (buf >= buf_end)
> +    return -1;
>   
>     if (*buf == DW_OP_deref)
>       {
> @@ -1498,7 +1538,7 @@ dwarf_block_to_dwarf_reg_deref (gdb::array_view<const gdb_byte> block,
>       {
>         buf++;
>         if (buf >= buf_end)
> -       return -1;
> +	return -1;
>         *deref_size_return = *buf++;
>       }
>     else
> @@ -1688,9 +1728,10 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   	  break;
>   
>   	case DW_OP_addr:
> -	  result = extract_unsigned_integer (op_ptr,
> -					     this->m_addr_size, byte_order);
> -	  op_ptr += this->m_addr_size;
> +	  op_ptr = safe_read_unsigned_integer (op_ptr, op_end,
> +					       this->m_addr_size,
> +					       byte_order, &uoffset);

Why not just send "&result" as the parameter here, instead of &uoffset

Same question for all the occurrences below

> +	  result = uoffset;
>   	  /* Some versions of GCC emit DW_OP_addr before
>   	     DW_OP_GNU_push_tls_address.  In this case the value is an
>   	     index, not an address.  We don't support things like
> @@ -1723,44 +1764,52 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   	  break;
>   
>   	case DW_OP_const1u:
> -	  result = extract_unsigned_integer (op_ptr, 1, byte_order);
> +	  op_ptr = safe_read_unsigned_integer (op_ptr, op_end, 1,
> +					       byte_order, &uoffset);
> +	  result = uoffset;
>   	  result_val = value_from_ulongest (address_type, result);
> -	  op_ptr += 1;
>   	  break;
>   	case DW_OP_const1s:
> -	  result = extract_signed_integer (op_ptr, 1, byte_order);
> +	  op_ptr = safe_read_signed_integer (op_ptr, op_end, 1,
> +					     byte_order, &offset);
> +	  result = offset;
>   	  result_val = value_from_ulongest (address_type, result);
> -	  op_ptr += 1;
>   	  break;
>   	case DW_OP_const2u:
> -	  result = extract_unsigned_integer (op_ptr, 2, byte_order);
> +	  op_ptr = safe_read_unsigned_integer (op_ptr, op_end, 2,
> +					       byte_order, &uoffset);
> +	  result = uoffset;
>   	  result_val = value_from_ulongest (address_type, result);
> -	  op_ptr += 2;
>   	  break;
>   	case DW_OP_const2s:
> -	  result = extract_signed_integer (op_ptr, 2, byte_order);
> +	  op_ptr = safe_read_signed_integer (op_ptr, op_end, 2,
> +					     byte_order, &offset);
> +	  result = offset;
>   	  result_val = value_from_ulongest (address_type, result);
> -	  op_ptr += 2;
>   	  break;
>   	case DW_OP_const4u:
> -	  result = extract_unsigned_integer (op_ptr, 4, byte_order);
> +	  op_ptr = safe_read_unsigned_integer (op_ptr, op_end, 4,
> +					       byte_order, &uoffset);
> +	  result = uoffset;
>   	  result_val = value_from_ulongest (address_type, result);
> -	  op_ptr += 4;
>   	  break;
>   	case DW_OP_const4s:
> -	  result = extract_signed_integer (op_ptr, 4, byte_order);
> +	  op_ptr = safe_read_signed_integer (op_ptr, op_end, 4,
> +					     byte_order, &offset);
> +	  result = offset;
>   	  result_val = value_from_ulongest (address_type, result);
> -	  op_ptr += 4;
>   	  break;
>   	case DW_OP_const8u:
> -	  result = extract_unsigned_integer (op_ptr, 8, byte_order);
> +	  op_ptr = safe_read_unsigned_integer (op_ptr, op_end, 8,
> +					       byte_order, &uoffset);
> +	  result = uoffset;
>   	  result_val = value_from_ulongest (address_type, result);
> -	  op_ptr += 8;
>   	  break;
>   	case DW_OP_const8s:
> -	  result = extract_signed_integer (op_ptr, 8, byte_order);
> +	  op_ptr = safe_read_signed_integer (op_ptr, op_end, 8,
> +					     byte_order, &offset);
> +	  result = offset;
>   	  result_val = value_from_ulongest (address_type, result);
> -	  op_ptr += 8;
>   	  break;
>   	case DW_OP_constu:
>   	  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
> @@ -1836,12 +1885,10 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   	    uint64_t len;
>   
>   	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
> -	    if (op_ptr + len > op_end)
> -	      error (_("DW_OP_implicit_value: too few bytes available."));
>   	    this->m_len = len;
>   	    this->m_data = op_ptr;
>   	    this->m_location = DWARF_VALUE_LITERAL;
> -	    op_ptr += len;
> +	    op_ptr = safe_skip_bytes (op_ptr, op_end, len);
>   	    dwarf_expr_require_composition (op_ptr, op_end,
>   					    "DW_OP_implicit_value");
>   	  }
> @@ -1861,9 +1908,10 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   	    int ref_addr_size = this->m_per_cu->ref_addr_size ();
>   
>   	    /* The referred-to DIE of sect_offset kind.  */
> -	    this->m_len = extract_unsigned_integer (op_ptr, ref_addr_size,
> -						  byte_order);
> -	    op_ptr += ref_addr_size;
> +	    op_ptr = safe_read_unsigned_integer (op_ptr, op_end,
> +						 ref_addr_size, byte_order,
> +						 &uoffset);
> +	    this->m_len = uoffset;
Again, why not send "&this->m_len" ?
>   
>   	    /* The byte offset into the data.  */
>   	    op_ptr = safe_read_sleb128 (op_ptr, op_end, &len);
> @@ -1972,7 +2020,9 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   	  goto no_push;
>   
>   	case DW_OP_pick:
> -	  offset = *op_ptr++;
> +	  op_ptr = safe_read_unsigned_integer (op_ptr, op_end, 1,
> +					       byte_order, &uoffset);
> +	  offset = uoffset;
>   	  result_val = fetch (offset);
>   	  in_stack_memory = fetch_in_stack_memory (offset);
>   	  break;
> @@ -2016,7 +2066,13 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   	case DW_OP_deref_type:
>   	case DW_OP_GNU_deref_type:
>   	  {
> -	    int addr_size = (op == DW_OP_deref ? this->m_addr_size : *op_ptr++);
> +	    int addr_size = this->m_addr_size;
> +	    if (op != DW_OP_deref)
> +	      {
> +		op_ptr = safe_read_unsigned_integer (op_ptr, op_end, 1,
> +						     byte_order, &uoffset);
> +		addr_size = uoffset;

Maybe I'm missing something, but this seems like an incorrect change?

It seems like you should call safe_skip_bytes instead of 
read_unsigned_integer, and assign addr_size to *op_ptr?

> +	      }
>   	    CORE_ADDR addr = fetch_address (0);
>   	    struct type *type;
>   
> @@ -2249,8 +2305,8 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   	  break;
>   
>   	case DW_OP_skip:
> -	  offset = extract_signed_integer (op_ptr, 2, byte_order);
> -	  op_ptr += 2;
> +	  op_ptr = safe_read_signed_integer (op_ptr, op_end, 2, byte_order,
> +					     &offset);
>   	  op_ptr += offset;
This should also use safe_skip_bytes
>   	  goto no_push;
>   
> @@ -2258,8 +2314,8 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   	  {
>   	    struct value *val;
>   
> -	    offset = extract_signed_integer (op_ptr, 2, byte_order);
> -	    op_ptr += 2;
> +	    op_ptr = safe_read_signed_integer (op_ptr, op_end, 2, byte_order,
> +					       &offset);
>   	    val = fetch (0);
>   	    dwarf_require_integral (val->type ());
>   	    if (value_as_long (val) != 0)
> @@ -2313,18 +2369,18 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   
>   	case DW_OP_call2:
>   	  {
> -	    cu_offset cu_off
> -	      = (cu_offset) extract_unsigned_integer (op_ptr, 2, byte_order);
> -	    op_ptr += 2;
> +	    op_ptr = safe_read_unsigned_integer (op_ptr, op_end, 2,
> +						 byte_order, &uoffset);
> +	    cu_offset cu_off = (cu_offset) uoffset;
>   	    this->dwarf_call (cu_off);
>   	  }
>   	  goto no_push;
>   
>   	case DW_OP_call4:
>   	  {
> -	    cu_offset cu_off
> -	      = (cu_offset) extract_unsigned_integer (op_ptr, 4, byte_order);
> -	    op_ptr += 4;
> +	    op_ptr = safe_read_unsigned_integer (op_ptr, op_end, 4,
> +						 byte_order, &uoffset);
> +	    cu_offset cu_off = (cu_offset) uoffset;
>   	    this->dwarf_call (cu_off);
>   	  }
>   	  goto no_push;
> @@ -2334,11 +2390,10 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   	    ensure_have_per_cu (this->m_per_cu, "DW_OP_GNU_variable_value");
>   	    int ref_addr_size = this->m_per_cu->ref_addr_size ();
>   
> -	    sect_offset sect_off
> -	      = (sect_offset) extract_unsigned_integer (op_ptr,
> -							ref_addr_size,
> -							byte_order);
> -	    op_ptr += ref_addr_size;
> +	    op_ptr = safe_read_unsigned_integer (op_ptr, op_end,
> +						 ref_addr_size, byte_order,
> +						 &uoffset);
> +	    sect_offset sect_off = (sect_offset) uoffset;
>   	    result_val = sect_variable_value (sect_off, this->m_per_cu,
>   					      this->m_per_objfile);
>   	    result_val = value_cast (address_type, result_val);
> @@ -2353,15 +2408,13 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   	    union call_site_parameter_u kind_u;
>   
>   	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
> -	    if (op_ptr + len > op_end)
> -	      error (_("DW_OP_entry_value: too few bytes available."));
> +	    const gdb_byte *expr_ptr = op_ptr;
> +	    op_ptr = safe_skip_bytes (op_ptr, op_end, len);
>   
> -	    auto entry_value_expr = gdb::make_array_view (op_ptr, len);
> +	    auto entry_value_expr = gdb::make_array_view (expr_ptr, len);
>   	    kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (entry_value_expr);
>   	    if (kind_u.dwarf_reg != -1)
>   	      {
> -		op_ptr += len;
> -
>   		if (trivial_entry_value (this->m_frame))
>   		  {
>   		    /* We can assume that DW_OP_entry_value (expr) == expr.
> @@ -2384,7 +2437,6 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   	      {
>   		if (deref_size == -1)
>   		  deref_size = this->m_addr_size;
> -		op_ptr += len;
>   
>   		if (trivial_entry_value (this->m_frame))
>   		  {
> @@ -2410,9 +2462,9 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   	  {
>   	    union call_site_parameter_u kind_u;
>   
> -	    kind_u.param_cu_off
> -	      = (cu_offset) extract_unsigned_integer (op_ptr, 4, byte_order);
> -	    op_ptr += 4;
> +	    op_ptr = safe_read_unsigned_integer (op_ptr, op_end, 4,
> +						 byte_order, &uoffset);
> +	    kind_u.param_cu_off = (cu_offset) uoffset;
>   	    this->push_dwarf_reg_entry_value (CALL_SITE_PARAMETER_PARAM_OFFSET,
>   					      kind_u,
>   					      -1 /* deref_size */);
> @@ -2429,9 +2481,11 @@ dwarf_expr_context::execute_stack_op (gdb::array_view<const gdb_byte> expr)
>   	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
>   	    cu_offset type_die_cu_off = (cu_offset) uoffset;
>   
> -	    n = *op_ptr++;
> +	    op_ptr = safe_read_unsigned_integer (op_ptr, op_end, 1, byte_order,
> +						 &uoffset);
> +	    n = uoffset;
>   	    data = op_ptr;
> -	    op_ptr += n;
> +	    op_ptr = safe_skip_bytes (op_ptr, op_end, n);
>   
>   	    type = get_base_type (type_die_cu_off);
>   
> diff --git a/gdb/testsuite/gdb.dwarf2/dw2-bad-dwarf-expr-bounds.exp b/gdb/testsuite/gdb.dwarf2/dw2-bad-dwarf-expr-bounds.exp
> new file mode 100644
> index 00000000000..7f5fa22388d
> --- /dev/null
> +++ b/gdb/testsuite/gdb.dwarf2/dw2-bad-dwarf-expr-bounds.exp
> @@ -0,0 +1,190 @@
> +# Copyright 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/>.
> +
> +# Test malformed DWARF expressions whose opcodes have truncated operands.
> +
> +load_lib dwarf.exp
> +
> +require dwarf2_support
> +
> +standard_testfile main.c -dw.S
> +
> +set asm_file [standard_output_file $srcfile2]
> +Dwarf::assemble $asm_file {
> +    global srcfile
> +
> +    declare_labels int_label
> +
> +    cu {label cu_label} {
> +	DW_TAG_compile_unit {
> +	    DW_AT_name $srcfile
> +	    DW_AT_language @DW_LANG_C
> +	} {
> +	    int_label: DW_TAG_base_type {
> +		DW_AT_name "int"
> +		DW_AT_encoding @DW_ATE_signed
> +		DW_AT_byte_size 4 DW_FORM_sdata
> +	    }
> +
> +	    foreach {var op} {
> +		truncated_addr DW_OP_addr
> +		truncated_const1u DW_OP_const1u
> +		truncated_const1s DW_OP_const1s
> +		truncated_const2u DW_OP_const2u
> +		truncated_const2s DW_OP_const2s
> +		truncated_const4u DW_OP_const4u
> +		truncated_const4s DW_OP_const4s
> +		truncated_const8u DW_OP_const8u
> +		truncated_const8s DW_OP_const8s
> +		truncated_implicit_pointer DW_OP_implicit_pointer
> +		truncated_gnu_implicit_pointer DW_OP_GNU_implicit_pointer
> +		truncated_pick DW_OP_pick
> +		truncated_deref_size DW_OP_deref_size
> +		truncated_deref_type DW_OP_deref_type
> +		truncated_gnu_deref_type DW_OP_GNU_deref_type
> +		truncated_skip DW_OP_skip
> +		truncated_bra DW_OP_bra
> +		truncated_parameter_ref DW_OP_GNU_parameter_ref
> +	    } {
> +		DW_TAG_variable {
> +		    DW_AT_name $var
> +		    DW_AT_type :$int_label
> +		    DW_AT_location {
> +			_op .byte $Dwarf::_constants($op) $op
> +		    } SPECIAL_expr
> +		}
> +	    }
> +
> +	    DW_TAG_variable {
> +		DW_AT_name "truncated_implicit_value"
> +		DW_AT_type :$int_label
> +		DW_AT_location {
> +		    _op .byte $Dwarf::_constants(DW_OP_implicit_value) \
> +			DW_OP_implicit_value
> +		    _op .uleb128 4 "implicit value length"
> +		    _op .2byte 0 "truncated implicit value bytes"
> +		} SPECIAL_expr
> +	    }
> +
> +	    DW_TAG_variable {
> +		DW_AT_name "truncated_entry_value"
> +		DW_AT_type :$int_label
> +		DW_AT_location {
> +		    _op .byte $Dwarf::_constants(DW_OP_entry_value) \
> +			DW_OP_entry_value
> +		    _op .uleb128 4 "entry value expression length"
> +		    _op .2byte 0 "truncated entry value expression"
> +		} SPECIAL_expr
> +	    }
> +
> +	    DW_TAG_variable {
> +		DW_AT_name "truncated_gnu_entry_value"
> +		DW_AT_type :$int_label
> +		DW_AT_location {
> +		    _op .byte $Dwarf::_constants(DW_OP_GNU_entry_value) \
> +			DW_OP_GNU_entry_value
> +		    _op .uleb128 4 "entry value expression length"
> +		    _op .2byte 0 "truncated entry value expression"
> +		} SPECIAL_expr
> +	    }
> +
> +	    DW_TAG_variable {
> +		DW_AT_name "truncated_const_type_size"
> +		DW_AT_type :$int_label
> +		DW_AT_location {
> +		    _op .byte $Dwarf::_constants(DW_OP_const_type) \
> +			DW_OP_const_type
> +		    _op .uleb128 "$int_label - $cu_label" "type DIE offset"
> +		} SPECIAL_expr
> +	    }
> +
> +	    DW_TAG_variable {
> +		DW_AT_name "truncated_const_type_payload"
> +		DW_AT_type :$int_label
> +		DW_AT_location {
> +		    _op .byte $Dwarf::_constants(DW_OP_const_type) \
> +			DW_OP_const_type
> +		    _op .uleb128 "$int_label - $cu_label" "type DIE offset"
> +		    _op .byte 4 "constant block length"
> +		    _op .2byte 0 "truncated constant block"
> +		} SPECIAL_expr
> +	    }
> +
> +	    DW_TAG_variable {
> +		DW_AT_name "truncated_gnu_const_type_size"
> +		DW_AT_type :$int_label
> +		DW_AT_location {
> +		    _op .byte $Dwarf::_constants(DW_OP_GNU_const_type) \
> +			DW_OP_GNU_const_type
> +		    _op .uleb128 "$int_label - $cu_label" "type DIE offset"
> +		} SPECIAL_expr
> +	    }
> +
> +	    DW_TAG_variable {
> +		DW_AT_name "truncated_gnu_const_type_payload"
> +		DW_AT_type :$int_label
> +		DW_AT_location {
> +		    _op .byte $Dwarf::_constants(DW_OP_GNU_const_type) \
> +			DW_OP_GNU_const_type
> +		    _op .uleb128 "$int_label - $cu_label" "type DIE offset"
> +		    _op .byte 4 "constant block length"
> +		    _op .2byte 0 "truncated constant block"
> +		} SPECIAL_expr
> +	    }
> +	}
> +    }
> +}
> +
> +if {[prepare_for_testing "failed to prepare" ${testfile} \
> +	 [list $srcfile $asm_file] nodebug]} {
> +    return
> +}
> +
> +if {![runto_main]} {
> +    return
> +}
> +
> +foreach var {
> +    truncated_addr
> +    truncated_const1u
> +    truncated_const1s
> +    truncated_const2u
> +    truncated_const2s
> +    truncated_const4u
> +    truncated_const4s
> +    truncated_const8u
> +    truncated_const8s
> +    truncated_implicit_value
> +    truncated_implicit_pointer
> +    truncated_gnu_implicit_pointer
> +    truncated_pick
> +    truncated_deref_size
> +    truncated_deref_type
> +    truncated_gnu_deref_type
> +    truncated_skip
> +    truncated_bra
> +    truncated_entry_value
> +    truncated_gnu_entry_value
> +    truncated_parameter_ref
> +    truncated_const_type_size
> +    truncated_const_type_payload
> +    truncated_gnu_const_type_size
> +    truncated_gnu_const_type_payload
> +} {
> +    with_test_prefix $var {
There exists a "foreach_with_prefix", that does basically what you did 
here.
> +	gdb_test "print $var" \
> +	    ".*DWARF expression error: ran off end of buffer reading .*"
> +    }
> +}


-- 
Cheers,
Guinevere Larsen
it/its
she/her (deprecated)