From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id uVloK8IyNGph4Q0AWB0awg (envelope-from ) for ; Thu, 18 Jun 2026 14:02:42 -0400 Authentication-Results: simark.ca; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20251104 header.b=ijZAwi/K; dkim-atps=neutral Received: by simark.ca (Postfix, from userid 112) id AD2BB1E098; Thu, 18 Jun 2026 14:02:42 -0400 (EDT) X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-25) on simark.ca X-Spam-Level: X-Spam-Status: No, score=-5.4 required=5.0 tests=ARC_SIGNED,ARC_VALID,BAYES_00, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FROM,MAILING_LIST_MULTI, RCVD_IN_DNSWL_MED autolearn=ham autolearn_force=no version=4.0.1 Received: from vm01.sourceware.org (vm01.sourceware.org [IPv6:2620:52:6:3111::32]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange x25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by simark.ca (Postfix) with ESMTPS id 42BD01E070 for ; Thu, 18 Jun 2026 14:02:41 -0400 (EDT) Received: from vm01.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 5C7DF4BA79AB for ; Thu, 18 Jun 2026 18:02:40 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 5C7DF4BA79AB Authentication-Results: sourceware.org; dkim=pass (2048-bit key, unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20251104 header.b=ijZAwi/K Received: from mail-pg1-x52d.google.com (mail-pg1-x52d.google.com [IPv6:2607:f8b0:4864:20::52d]) by sourceware.org (Postfix) with ESMTPS id 71D964BA2E0D for ; Thu, 18 Jun 2026 18:02:12 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 71D964BA2E0D Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 71D964BA2E0D Authentication-Results: sourceware.org; arc=none smtp.remote-ip=2607:f8b0:4864:20::52d ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1781805732; cv=none; b=tYDop0bcoxug73YFQrqV1C2bw1OYx1+hVAXgkMGw6r5VVFHz732CWByohmPTuvoR0NZV++k+FgrTFIDZQklNu9Jv895ET40hozWIw1SRzKeepy6DUFgDGxzMa+d0EuZ+ynnr/qJVR2R43gma2WOYWV3cJbIPopd5UsLchT8NZJI= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1781805732; c=relaxed/simple; bh=g2r75+T4aJZXwUDUJkkTJQ4Y3kW2+rnNPUD7gcpYGNg=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=Xx+v/UCsX9wObHg6ALYU6H7pdvI/voHyIPEaLyC6s9bktoS1EM4/l8FakBpMmwI1IaAD6P5St2HFTYHvwDVL+W7JisnMuwxxFNxKIX5ry1RF9QkOthuLvTAfEwwzkMBs4AR33vFyNCWHpn9PnPhMd9IyVoLY1soEt4H/rPRRkgk= ARC-Authentication-Results: i=1; sourceware.org; dkim=pass (2048-bit key, unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20251104 header.b=ijZAwi/K DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 71D964BA2E0D Received: by mail-pg1-x52d.google.com with SMTP id 41be03b00d2f7-c8612812170so42899a12.2 for ; Thu, 18 Jun 2026 11:02:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1781805731; x=1782410531; darn=sourceware.org; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:from:to:cc:subject:date:message-id:reply-to; bh=lH1cbvgk7yupdsK5fvGG0u3N6JAOoHsgOmnUvLHeGNI=; b=ijZAwi/Kxoux41Alb/rIVVywf997GjSnNxKF9kKYtftN01aNTj6DLGWtZPxSscBgA7 2yzoyxEzvSzjrayPo1VVoE5xNcHVHLk8hiHgSDDFcFUgsxqcSYhNOKbiTfKRvBAXlTuk rkooXz9OxxLZYushZmUjClUjTlZEv0+qMt6mJvoXdWK0K8IXnrW5B08BiKJ5PYG9Llw5 jHoWHO84769qT1+Aie2xaweDTW6tvL8IDRGQxB3IWtIX0DSxWi/O7gCQC6xz67hdI8Vg 0qkw8NRq4G2H7PC/Qs6ZsGvymD/6y8/XJTvGdoIYoZ/9iuo2uRuNubFOZ48qYPjLWZeR lMVA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1781805731; x=1782410531; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:x-gm-gg:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=lH1cbvgk7yupdsK5fvGG0u3N6JAOoHsgOmnUvLHeGNI=; b=hNawQAvuPHRcegZjNzq+4gkRWgVuvAKP8f5uVW2UEj7fJ5wt4mQdvBZ7SmiRrgGva/ Cnbfja2tRGpVaapiLPAgz+h9Fa1K79pZm181MuKvwRC90csl+reAWlTRKUUbMyTAypyc Je8ktocCuB23Z/BfUCY4iJoJQm9rm7f4OH0J1EjzUHkc+lTxeRhAuAkG3iz1MiZRIyfM ZAjJu+PueLQKVZ5+LTm9CERqr/p7Aukr/lTMS7EmqKuCFiZl7r5hOVCDD0CGsVy9rkH9 NuqxEYsPUg4bX2bxO+WdtbMA4gp+ZkdPNUpyYOUjWNIvb/Ft6Riz3MlnkMMs6GrwRtXx xpXA== X-Gm-Message-State: AOJu0YznXa86QNjDE7m5Lc2/C7PCaW4e8Jn3zo0uMfxgN89nLgoAmfug qC3OthT9b7ANVKW+kkSD0eZoxAKIN2MYpmly6ud4B2LIq+G3f+giYliABposGwZvPIM= X-Gm-Gg: AfdE7cktwoUYuRMt0P+UlRcC66wCKArsGt0+2cVbrYsKpISwyQgFlEXOeGLTbNNHAjE ABDd8gtlmWjjGoLmKzm0RHSDvrZ83AZXUNPkG+L5yeEPfHh8SuQkauvXHFzZzF6MT0SNKQf2amF LAAOOPEWi1Bc5qseNjjlW/3M8OSJtsJPZmTPiyt8ijVDzTGBlfgVLyKMoJXzHaoqe0dr3OAEZD2 O4PKsARGbJ9R64svK5lSm8MlJLF/PbeEnPfH7nFk2/tks81AXRHYe6ErCp8SvvPXCKa7GgL9HAS VC8eNmWj5pw4RPiYGTfL0dYC3T8yZ9/sUtIMzzGK/9J/R4v8+FKxXW7G/yFU4cE6l/DRNJpD7UX Dm2Xu8lDXqa5GrSC0IEOltwDsTLF9khktTJ+r5QKF8+bBe3SzAAKxw1Ydl+VMhfbRQOG+i4j97N 9CNoJl9Z2947lWvZfZn28xPuN/EuHVzfOK9bMRU/ygezhY1LlK5J020XyCM87CzQm8F5wRwBfTN ZFY X-Received: by 2002:a05:6a00:1802:b0:842:6fec:12a1 with SMTP id d2e1a72fcca58-8453b270ed1mr2830009b3a.7.1781805731069; Thu, 18 Jun 2026 11:02:11 -0700 (PDT) Received: from poweredge.r760.114.212.189.32.r760.114.212.189.32 ([188.253.121.104]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-845353d096dsm4604268b3a.59.2026.06.18.11.02.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Jun 2026 11:02:10 -0700 (PDT) From: Jielun Wu To: gdb-patches@sourceware.org Cc: Jielun Wu Subject: [PATCH][PR gdb/34239][PR gdb/34299] gdb: Check bounds before reading DWARF expression operands Date: Fri, 19 Jun 2026 02:01:58 +0800 Message-Id: <20260618180158.2893540-1-firmiana402@gmail.com> X-Mailer: git-send-email 2.34.1 MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces~public-inbox=simark.ca@sourceware.org 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 --- 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; } - + +/* 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; +} + +/* 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; +} /* 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 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 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 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 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); + 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 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 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 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; /* 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 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 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; + } CORE_ADDR addr = fetch_address (0); struct type *type; @@ -2249,8 +2305,8 @@ dwarf_expr_context::execute_stack_op (gdb::array_view 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; goto no_push; @@ -2258,8 +2314,8 @@ dwarf_expr_context::execute_stack_op (gdb::array_view 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 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 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 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 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 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 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 . + +# 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 { + gdb_test "print $var" \ + ".*DWARF expression error: ran off end of buffer reading .*" + } +} -- 2.34.1