From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id pnKIBzdhuWlphS0AWB0awg (envelope-from ) for ; Tue, 17 Mar 2026 10:12:07 -0400 Authentication-Results: simark.ca; dkim=pass (1024-bit key; unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=aaaQQ1T1; dkim-atps=neutral Received: by simark.ca (Postfix, from userid 112) id 0E3291E0BC; Tue, 17 Mar 2026 10:12:07 -0400 (EDT) X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-25) on simark.ca X-Spam-Level: X-Spam-Status: No, score=-3.4 required=5.0 tests=ARC_SIGNED,ARC_VALID,BAYES_00, DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,MAILING_LIST_MULTI, RCVD_IN_DNSWL_MED,RCVD_IN_VALIDITY_CERTIFIED_BLOCKED, RCVD_IN_VALIDITY_RPBL_BLOCKED,RCVD_IN_VALIDITY_SAFE_BLOCKED autolearn=ham autolearn_force=no version=4.0.1 Received: from vm01.sourceware.org (vm01.sourceware.org [38.145.34.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 86A7E1E08C for ; Tue, 17 Mar 2026 10:12:05 -0400 (EDT) Received: from vm01.sourceware.org (localhost [127.0.0.1]) by sourceware.org (Postfix) with ESMTP id C99524BA23FE for ; Tue, 17 Mar 2026 14:12:04 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org C99524BA23FE Authentication-Results: sourceware.org; dkim=pass (1024-bit key, unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=aaaQQ1T1 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTP id 8CED74BB58DD for ; Tue, 17 Mar 2026 14:10:08 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 8CED74BB58DD Authentication-Results: sourceware.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 8CED74BB58DD Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1773756608; cv=none; b=tRq0wPhGxxWJejxy+jKTNlToP6xpn8cjLq0n+51WKs1siMOToTHBBaOfcHSD/hR+IMjbNao3kGoiOpcUxht4+NSP10xvADUnFiZuYryl1uQOeDNeGDgr0UHkkUTF37XeE6rHrl91FxYFmOTuyAhSpsBrVNyEFJCcjk8SOelnlNk= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1773756608; c=relaxed/simple; bh=+ggoaDX/5ibi0kgpPVfZeCJXqa/WWrum4LOEBXvCO9M=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=j5ODzLKD+K3q5IXPjKLmUcrcfunVCn+wsyRVsqkvujaTBkT3MzyF7Y0SXIXv52h9J0AoBijuFTtE7dA1uh+PCqNkdEpJHw6VlA+o4pYccwPxt9KWJOPHUGBpDrI8jAOU0QzopEdKLdZeO+16qjcibR0WUk1mxc8gEb+eZ80AXdU= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 8CED74BB58DD DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1773756608; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references; bh=tJJbVXyfGYgwMzksl15WaGguC93aAq/0Vjpgu69dg84=; b=aaaQQ1T13AFbtQZRjoc6LtHB2OQ9VKgqYGOy8W59Gf1e6Tc1AigJNG4Fvw1slmMAbK1Rbi LGrK1vZ7oA5Lp1TSsz1Dujqtv/vxxpVWibVa5bZ15iNyaDOjTBnLpwB2Fig1ceHXb7ApEa eJtBXfC6KYaPNN9+CSWdchoMncyX6M8= Received: from mail-wr1-f70.google.com (mail-wr1-f70.google.com [209.85.221.70]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-286-g96RHWeuOZ6LllqMLtr2YQ-1; Tue, 17 Mar 2026 10:10:06 -0400 X-MC-Unique: g96RHWeuOZ6LllqMLtr2YQ-1 X-Mimecast-MFC-AGG-ID: g96RHWeuOZ6LllqMLtr2YQ_1773756605 Received: by mail-wr1-f70.google.com with SMTP id ffacd0b85a97d-43b40c22eaeso1632045f8f.2 for ; Tue, 17 Mar 2026 07:10:06 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1773756605; x=1774361405; h=mime-version:message-id:date:references:in-reply-to:subject:to:from :x-gm-gg:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=tJJbVXyfGYgwMzksl15WaGguC93aAq/0Vjpgu69dg84=; b=ByH2Fkf1bd/khlJZElRO+FRDbLQLhr9ndkRj/S9mdtWlY8FpP+H3KhOlLU1xseF+xh rVRH4uq4fvrKKaDgU/cZ2l0J9gOUtSrEz6aXsTyUw7zrMTN5M3+i8hq8ChEYRI/57yV8 ObwxMcOANzdlKoybYbrKHao6sJ2jIB4jFEuTf9kaJ9nG9ewPciD0FjcnBPYUHkZgqZHE EaYjFDKuKl927kBzcwe2ikF3Sj4EaNHiioJesctbc4I6D3oSDxMgasAgbgEc9HhQmdTW SFwDgATxdoI1JVb52qGzkMAbjYH2kTiT9XNJ5eSvrVjwExZgXpHWwGcCEc3WlP1aXVHK svWQ== X-Forwarded-Encrypted: i=1; AJvYcCULe4euvQOrwJmjmZlagOvjzIz+rzpL+DL6vbgMyH3Wp5Cw8TgVADVo3a+dv0ATI5wbmUhcACkXKlTZyQ==@sourceware.org X-Gm-Message-State: AOJu0YzCgZ+ZTudHGyGbvWXZPcF8p+Kab3KufZEQ3vBsRJ6g5RGAVppa /0i1jtj8T+/llJRHGeUI2SuVyULByFsnxnA+QX64PEeDj4nefWlDMPsUMbGEPEEkjbtn5yZzezF u/RIiwpWiyaRId8IwAOyoB+ZdgxfPPQcMAIYOeLuAmWbXXetI53CpYSQ46vQ78E0= X-Gm-Gg: ATEYQzz2kXQzRGf4eYZNUoMpv4+at1F9tPymcxdCSzgk6bRmM4sjGODgoQ9fiT/xAU7 56Ghh0gAwv4BFcDT+iQfXq1uMCp5NyYBCiKyzg0StV0mJxqqTdFvwb/d3i1hH5CSPvvUbd3oOZN mfsXfC4tfMT28TXw16Kblt8Y8xDPY1C7au2xWYY7ZEAJUfNriBhnK5qW7hWryjWzm9kRl03Tsyv +keP92E9oUl7Olas/dTZjaxC2I33bmToIA+PbHXyV8NC6ZmtyRGmPPwVfaIDdEfZAowB8NaIgwk sQgy/Czb58gSE/zX1vDs22iE9menqpxti+Xy5WuDbZaJp9oJRe5mAAHA8aZNzbtDwc9h82wP7eo kzY/9rWUveRfobWgm X-Received: by 2002:a05:6000:2483:b0:43b:5095:b81c with SMTP id ffacd0b85a97d-43b5095be3amr2314362f8f.17.1773756604790; Tue, 17 Mar 2026 07:10:04 -0700 (PDT) X-Received: by 2002:a05:6000:2483:b0:43b:5095:b81c with SMTP id ffacd0b85a97d-43b5095be3amr2314260f8f.17.1773756604115; Tue, 17 Mar 2026 07:10:04 -0700 (PDT) Received: from localhost ([31.111.84.232]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-43b3a09e453sm29209238f8f.0.2026.03.17.07.10.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 17 Mar 2026 07:10:03 -0700 (PDT) From: Andrew Burgess To: Keith Seitz , gdb-patches@sourceware.org Subject: Re: [PATCH v6] infcall: Add support for integer literals as reference function parameters In-Reply-To: References: <92575c2eb6805095b41ebbe62ba99b81e4e5dd63.1760629738.git.keiths@redhat.com> Date: Tue, 17 Mar 2026 14:10:02 +0000 Message-ID: <878qbq7dj9.fsf@redhat.com> MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-MFC-PROC-ID: cDGIOyayG4aLPAhrdfnir7XEsgv0uZs0ge-nOyoSyWQ_1773756605 X-Mimecast-Originator: redhat.com Content-Type: text/plain 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 Keith Seitz writes: > [With apologies for all the typos in v5...] > > This is v6 of my attempt to add simple integer literal support for reference > parameters in inferior function calls. The goal here is to take a step toward > a better user experience when working with standard containers such as std::map. > > While hacking at the parser to add new related functionality, I've come to realize > that heap allocation is much safer than using the stack. We just really cannot know > how a user (or their program) handles any of these values. > > I've looked at c++/32365, and this patch does not address that issue. I have been > working on a patch to add construction to the parser which will address some of > the issues in that bug, but it relies on this patch. [That is, "p d[var(0)]" > works with my work-in-progress parser patch.] > > Keith > > Changes in v6 > - Fix a bunch of typos > - Revert some missed stack-related changes from v4 I took a look through, and this all looks great. Approved-By: Andrew Burgess thanks, Andrew > > Changes in v5 > - Return to heap allocation > > Changes in v4 > - Allocate to stack instead of heap > - Use value::force_lval to simply copying to inferior memory > - Add some addition tests > > Changes in v3 > - Move logic to value_arg_coerce > - Add some attempt to limit copying to trivially copyable types > > ----- > > This patch attempts to mitigate the shortcomings of passing literals > to inferior function calls requiring references. The specific use case here > is std::map's operator[]: > > std::map int_map; > int_map[1] = 10; > (gdb) print int_map[1] > Attempt to take address of value not located in memory. > > This is occurring because while value_coerce_to_target understands > that some values need to be allocated and copied to the inferior's > memory, it only considers the actual parsed type of the argument value, > ignoring the actual type of the function parameter. That is, > in this specific case, the value's parsed type is TYPE_CODE_INT, but > the function requires TYPE_CODE_REF. We need to account for the > reference. > > In value_arg_coerce, we have special handling for references, but it > has not specifically dealt with this case. It now checks if the > reference is in memory, and if it isn't, it copies it, if the type > is trivially copyable. > > As a result of this patch, the last remaining failure in c++/15372 is now > fixed, and that bug can be closed. > > With this patch, we can now print map entries with integer keys: > > (gdb) print int_map[1] > $1 = (std::map, std::allocator > >::mapped_type &) @0x41f2d4: 10 > > Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=15372 > Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=25957 > --- > gdb/infcall.c | 16 +- > gdb/testsuite/gdb.cp/ref-params.cc | 95 +++++++++++- > gdb/testsuite/gdb.cp/ref-params.exp | 146 +++++++++++++++++++ > gdb/testsuite/gdb.cp/rvalue-ref-overload.exp | 1 - > 4 files changed, 253 insertions(+), 5 deletions(-) > > diff --git a/gdb/infcall.c b/gdb/infcall.c > index 51636ff5403..941b0a95c5b 100644 > --- a/gdb/infcall.c > +++ b/gdb/infcall.c > @@ -276,10 +276,20 @@ value_arg_coerce (struct gdbarch *gdbarch, struct value *arg, > return value_cast_pointers (type, arg, 0); > > /* Cast the value to the reference's target type, and then > - convert it back to a reference. This will issue an error > - if the value was not previously in memory - in some cases > - we should clearly be allowing this, but how? */ > + convert it back to a reference. If the value is not already > + in memory (e.g., a literal), we need to allocate space in the > + inferior and copy it there. */ > new_value = value_cast (type->target_type (), arg); > + if (new_value->lval () != lval_memory > + && (language_pass_by_reference (new_value->type ()) > + .trivially_copyable)) > + { > + LONGEST length = check_typedef (new_value->type ())->length (); > + struct value *addr_val = value_allocate_space_in_inferior (length); > + CORE_ADDR addr = value_as_address (addr_val); > + new_value->force_lval (addr); > + } > + > new_value = value_ref (new_value, type->code ()); > return new_value; > } > diff --git a/gdb/testsuite/gdb.cp/ref-params.cc b/gdb/testsuite/gdb.cp/ref-params.cc > index 12e2716b435..3c1aa82396a 100644 > --- a/gdb/testsuite/gdb.cp/ref-params.cc > +++ b/gdb/testsuite/gdb.cp/ref-params.cc > @@ -60,6 +60,68 @@ int mf2(MultiChild& C) > return mf1(C); > } > > +/* A class to be used by functions and methods exercising c++/25957. */ > +class TestClass > +{ > + public: > + int value; > + > + TestClass (int v) : value (v) {} > + > + int > + const_ref_method (const int &x) const > + { > + return value + x; > + } > + > + int > + const_ref_method (const TestClass &obj) const > + { > + return value + obj.value; > + } > + > + int > + ref_method (int &x) > + { > + return value + 2 * x; > + } > + > + int > + ref_method (TestClass &obj) > + { > + return value + 2 * obj.value; > + } > +}; > + > +/* Define globals to be used by functions and methods exercising c++/25957. */ > +int global_int = 42; > +TestClass global_obj (10); > + > +/* Helper functions to test reference parameter behavior for c++/25957. */ > +int > +const_ref_func (const int &x) > +{ > + return x * 2; > +} > + > +int > +const_ref_func (const TestClass &obj) > +{ > + return obj.value * 2; > +} > + > +int > +ref_func (int &x) > +{ > + return x + 1; > +} > + > +int > +ref_func (TestClass &obj) > +{ > + return obj.value + 1; > +} > + > int main(void) > { > Child Q(42); > @@ -76,5 +138,36 @@ int main(void) > > mf2(MQ); /* Set breakpoint MQ here. */ > > - return 0; > + TestClass obj (5); > + int local_var = 15; > + > + /* Prevent compiler from optimizing away the function and method calls. */ > + int dummy_int = 99; > + (void) const_ref_func (dummy_int); > + (void) const_ref_func (global_int); > + (void) const_ref_func (obj); > + (void) const_ref_func (global_obj); > + (void) ref_func (dummy_int); > + (void) ref_func (global_int); > + (void) ref_func (obj); > + (void) ref_func (global_obj); > + (void) obj.const_ref_method (dummy_int); > + (void) obj.const_ref_method (global_int); > + (void) obj.const_ref_method (obj); > + (void) obj.const_ref_method (global_obj); > + (void) obj.ref_method (dummy_int); > + (void) obj.ref_method (global_int); > + (void) obj.ref_method (obj); > + (void) obj.ref_method (global_obj); > + (void) global_obj.const_ref_method (dummy_int); > + (void) global_obj.const_ref_method (global_int); > + (void) global_obj.const_ref_method (obj); > + (void) global_obj.const_ref_method (global_obj); > + (void) global_obj.ref_method (dummy_int); > + (void) global_obj.ref_method (global_int); > + (void) global_obj.ref_method (obj); > + (void) global_obj.ref_method (global_obj); > + > + /* Breakpoint here for c++/25957 testing. */ > + return 0; /* breakpoint-here */ > } > diff --git a/gdb/testsuite/gdb.cp/ref-params.exp b/gdb/testsuite/gdb.cp/ref-params.exp > index b61055e9f50..31144fcba21 100644 > --- a/gdb/testsuite/gdb.cp/ref-params.exp > +++ b/gdb/testsuite/gdb.cp/ref-params.exp > @@ -63,3 +63,149 @@ gdb_test "print f1(MQR)" ".* = 53" > gdb_test "print mf1(MQR)" ".* = 106" > gdb_test "print mf2(MQR)" ".* = 106" > gdb_test "print f3(Q.id)" ".* = 42" > + > +# Inferior function call tests which have reference arguments. > +# https://sourceware.org/bugzilla/show_bug.cgi?id=25957 > +gdb_start_again "breakpoint-here" > + > +# Test functions taking const reference parameter. > +gdb_test "print const_ref_func(10)" \ > + "= 20" \ > + "call function with const ref param and literal" > + > +gdb_test "print const_ref_func(global_int)" \ > + "= 84" \ > + "call function with const ref param and global variable" > + > +gdb_test "print const_ref_func(local_var)" \ > + "= 30" \ > + "call function with const ref param and local variable" > + > +gdb_test "print const_ref_func(obj)" \ > + "= 10" \ > + "call function with const ref param and object" > + > +gdb_test "print const_ref_func(global_obj)" \ > + "= 20" \ > + "call function with const ref param and global object" > + > +gdb_test "print const_ref_func((TestClass) {42})" \ > + "= 84" \ > + "call function with const ref param and literal object" > + > +# Test functions taking non-const reference parameter. > +gdb_test "print ref_func(10)" \ > + "Cannot resolve function ref_func to any overloaded instance" \ > + "call function with non-const ref param and literal" > + > +gdb_test "print ref_func(global_int)" \ > + " = 43" \ > + "call function with non-const ref param and global variable" > + > +gdb_test "print ref_func(local_var)" \ > + " = 16" \ > + "call function with non-const ref param and local variable" > + > +gdb_test "print ref_func(obj)" \ > + "= 6" \ > + "call function with non-const ref param and object" > + > +gdb_test "print ref_func(global_obj)" \ > + "= 11" \ > + "call function with non-const ref param and global object" > + > +gdb_test "print ref_func((TestClass) {42})" \ > + "Cannot resolve function ref_func to any overloaded instance" \ > + "call function with ref param and literal object" > + > +# Test methods taking constant reference parameter. > +gdb_test "print obj.const_ref_method(5)" \ > + "= 10" \ > + "call const method with const ref param and literal" > + > +gdb_test "print obj.const_ref_method(global_int)" \ > + "= 47" \ > + "call const method with const ref param and global variable" > + > +gdb_test "print obj.const_ref_method(local_var)" \ > + "= 20" \ > + "call const method with const ref param and local variable" > + > +gdb_test "print obj.const_ref_method(obj)" \ > + "= 10" \ > + "call method with const ref param and object" > + > +gdb_test "print obj.const_ref_method((TestClass) {42})" \ > + "= 47" \ > + "call method with const ref param and literal object" > + > +# Test methods taking non-const reference parameters. > +gdb_test "print obj.ref_method(5)" \ > + "Cannot resolve method TestClass::ref_method to any overloaded instance" \ > + "call method with non-const ref param and literal" > + > +gdb_test "print obj.ref_method(global_int)" \ > + "= 89" \ > + "cal method with non-const ref param and global variable" > + > +gdb_test "print obj.ref_method(local_var)" \ > + " = 35" \ > + "call method with non-const ref param and local variable" > + > +gdb_test "print obj.ref_method(obj)" \ > + "= 15" \ > + "call method with non-const ref param and object" > + > +gdb_test "print obj.ref_method((TestClass) {42})" \ > + "Cannot resolve method TestClass::ref_method to any overloaded instance" \ > + "call method with non-const ref param and literal object" > + > +# Test global_obj methods taking constant reference parameter. > +gdb_test "print global_obj.const_ref_method(5)" \ > + "= 15" \ > + "call global const method with const ref param and literal" > + > +gdb_test "print global_obj.const_ref_method(global_int)" \ > + "= 52" \ > + "call global const method with const ref param and global variable" > + > +gdb_test "print global_obj.const_ref_method(local_var)" \ > + "= 25" \ > + "call global const method with const ref param and local variable" > + > +gdb_test "print global_obj.const_ref_method(obj)" \ > + "= 15" \ > + "call global method with const ref param and object" > + > +gdb_test "print global_obj.const_ref_method(global_obj)" \ > + "= 20" \ > + "call global method with const ref param and global object" > + > +gdb_test "print global_obj.const_ref_method((TestClass) {42})" \ > + "= 52" \ > + "call global method with const ref param and literal object" > + > +# Test global_obj methods taking non-const reference parameters. > +gdb_test "print global_obj.ref_method(5)" \ > + "Cannot resolve method TestClass::ref_method to any overloaded instance" \ > + "call global method with non-const ref param and literal" > + > +gdb_test "print global_obj.ref_method(global_int)" \ > + "= 94" \ > + "call global method with non-const ref param and global variable" > + > +gdb_test "print global_obj.ref_method(local_var)" \ > + "= 40" \ > + "call global method with non-const ref param and local variable" > + > +gdb_test "print global_obj.ref_method(obj)" \ > + "= 20" \ > + "call global method with non-const ref param and object" > + > +gdb_test "print global_obj.ref_method(global_obj)" \ > + "= 30" \ > + "call global method with non-const ref param and global object" > + > +gdb_test "print global_obj.ref_method ((TestClass) {42})" \ > + "Cannot resolve method TestClass::ref_method to any overloaded instance" \ > + "call global method with non-const ref param and literal object" > diff --git a/gdb/testsuite/gdb.cp/rvalue-ref-overload.exp b/gdb/testsuite/gdb.cp/rvalue-ref-overload.exp > index bd6933673db..b9da32c244e 100644 > --- a/gdb/testsuite/gdb.cp/rvalue-ref-overload.exp > +++ b/gdb/testsuite/gdb.cp/rvalue-ref-overload.exp > @@ -64,7 +64,6 @@ gdb_test "print f (i)" "1" "lvalue reference overload" > > gdb_test "print f (ci)" "2" "lvalue reference to const overload" > > -setup_kfail "c++/15372" "*-*-*" > gdb_test "print f (3)" "3" "rvalue reference overload" > > gdb_test "print g (i)" \ > > base-commit: 71f898443500ba572511579cf699994828542c96 > -- > 2.53.0