From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id uX6zGneGxWk1pDoAWB0awg (envelope-from ) for ; Thu, 26 Mar 2026 15:18:15 -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=bDHKaH0+; dkim-atps=neutral Received: by simark.ca (Postfix, from userid 112) id 5D0AC1E0BC; Thu, 26 Mar 2026 15:18:15 -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 A3C801E08C for ; Thu, 26 Mar 2026 15:18:13 -0400 (EDT) Received: from vm01.sourceware.org (localhost [127.0.0.1]) by sourceware.org (Postfix) with ESMTP id DD4094B9DB57 for ; Thu, 26 Mar 2026 19:18:12 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org DD4094B9DB57 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=bDHKaH0+ 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 EDA454BA23F6 for ; Thu, 26 Mar 2026 19:17:36 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org EDA454BA23F6 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 EDA454BA23F6 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=1774552657; cv=none; b=sgi4nzfLoLSi1GqUfj7buz2ZVvS7iYHSNWFsPR3weXCDsbB+q6LLQMXJKYqdVGNixmWoaZ+xMg11b+/mu+ExK5gcZZaazA1VzK7tEUMLgg/wTTNvIGj2tnV5TpFIvmmjceYzCecMaClqlPCpPmq1+ZhkNVF2h4pOMkpjj/59H2I= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1774552657; c=relaxed/simple; bh=9DkIacH6X3s+qJqg42NSVrnKNw/zijvnicYaydkDFDI=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=ZBFPCF+a0KSlPWOv70pDddv5UYggWMeEfgat9EcWf2Dkzi6cIIyXioLKeCLfG/TgKm1TM7nmIS43Mf5NVW2a0m6egelSnf/OVZJwQnb1gvhOKNr/THglF4yJ5CYz6mZorA81CSZ5C4YFNbqMR2cbC14fr5YnYbYGdXupP/i+yF0= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org EDA454BA23F6 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1774552656; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=Ar4ZFtlwLf5Sh13D7JBryjkUB+nHHpx9v5mtcZv2ZRc=; b=bDHKaH0+NjhhslY7HYtYPkcUeFKNyrhLfTI3R/mbxN3VwwPwEsRi8tFedjloq9NIeXK/Hf MS1Ib9Xl+wgm95O75Y73C/XEO+hglDxO2VeRaY/YE4CbXTqBLN4tpiYJKDOvE9IG8pKvst AFPVaIaQJbYo5/LgfjP80Vwi14GZils= Received: from mx-prod-mc-03.mail-002.prod.us-west-2.aws.redhat.com (ec2-54-186-198-63.us-west-2.compute.amazonaws.com [54.186.198.63]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-480--SespNIVMaeAGAx8ZEkfhg-1; Thu, 26 Mar 2026 15:17:34 -0400 X-MC-Unique: -SespNIVMaeAGAx8ZEkfhg-1 X-Mimecast-MFC-AGG-ID: -SespNIVMaeAGAx8ZEkfhg_1774552654 Received: from mx-prod-int-03.mail-002.prod.us-west-2.aws.redhat.com (mx-prod-int-03.mail-002.prod.us-west-2.aws.redhat.com [10.30.177.12]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mx-prod-mc-03.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTPS id 75E69195604F for ; Thu, 26 Mar 2026 19:17:33 +0000 (UTC) Received: from keiths-thinkpadp1gen7.rmtuswa.csb (unknown [10.22.81.196]) by mx-prod-int-03.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTP id 328B219560B1; Thu, 26 Mar 2026 19:17:28 +0000 (UTC) From: Keith Seitz To: gdb-patches@sourceware.org Subject: [PATCH] Add infcall support for C++ constructor-style expressions Date: Thu, 26 Mar 2026 12:17:20 -0700 Message-ID: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.0 on 10.30.177.12 X-Mimecast-Spam-Score: 0 X-Mimecast-MFC-PROC-ID: E6HKXAkj0GUiTgaoVdar_5hONwLt2lrgnXOUGsFNjec_1774552654 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset=UTF-8 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 This patch adds an initial try at teaching the expression parser/evaluator to construct temporary objects requiring construction during an inferior function call. To accomplish this, I've chosen the route of modifying the parser to teach it that `Type(args)' is a function call when `Type' names a class/struct/union and is immediately followed by '(', that is, via look- ahead). A new parser token and grammar rule have been added to deal with this new production. The real work is dispatched to `type_operation::evaluate_funcall', allocating memory for the temporary and finding the most suitable constructor with `find_overload_match'. It then runs the inferior call, returning the newly constructed object. I've included many tests covering as many corner cases as I could invent, and these tests are clang clean. They also introduce no regressions on x86-64 Fedora 43 with GCC 15.2.1 and RHEL 9.4 with GCC 11.5.0. Example: Consider a C++ frame where 'struct S { int x; S(int); ... }' is in scope Before: (gdb) print S(42) ❌️ A syntax error in expression, near `10)'. After: (gdb) print S(42) $1 = {x = 42} Note that no attempt has been made to deal with templates. Hopefully a follow-on patch can address that. --- gdb/NEWS | 5 + gdb/c-exp.y | 86 +++++++++-- gdb/eval.c | 55 ++++++++ gdb/expop.h | 5 + gdb/testsuite/gdb.cp/infcall-ctors.cc | 128 +++++++++++++++++ gdb/testsuite/gdb.cp/infcall-ctors.exp | 188 +++++++++++++++++++++++++ 6 files changed, 457 insertions(+), 10 deletions(-) create mode 100644 gdb/testsuite/gdb.cp/infcall-ctors.cc create mode 100644 gdb/testsuite/gdb.cp/infcall-ctors.exp diff --git a/gdb/NEWS b/gdb/NEWS index 03f46df5400..c04727d342d 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -66,6 +66,11 @@ automatically set to UTF-8. (Users can use the Windows 'chcp' command to change the output codepage of the console.) +* In C++ GDB now accepts constructor-style expressions "TYPE (ARGS)" + when TYPE names a class, struct, or union in the current expression + context. This allows objects to be constructed directly during + expression evalution. + * New targets GNU/Linux/MicroBlaze (gdbserver) microblazeel-*linux* diff --git a/gdb/c-exp.y b/gdb/c-exp.y index a4a910df712..e17ee2d3c12 100644 --- a/gdb/c-exp.y +++ b/gdb/c-exp.y @@ -199,7 +199,7 @@ static void c_print_token (FILE *file, int type, YYSTYPE value); #endif %} -%type exp exp1 type_exp start variable qualified_name lcurly function_method +%type exp exp1 type_exp start variable qualified_name lcurly function_method typename_for_ctor %type rcurly %type type typebase scalar_type tag_name_or_complete %type nonempty_typelist func_mod parameter_typelist @@ -230,7 +230,7 @@ static void c_print_token (FILE *file, int type, YYSTYPE value); %token NAME /* BLOCKNAME defined below to give it higher precedence. */ %token UNKNOWN_CPP_NAME %token COMPLETE -%token TYPENAME +%token TYPENAME TYPENAME_CTOR %token CLASSNAME /* ObjC Class name */ %type name %type qual_field_name field_name field_name_or_complete @@ -533,6 +533,26 @@ msgarg : name ':' exp { add_msglist(0, 0); } ; +exp : typename_for_ctor '(' + { pstate->start_arglist (); } + arglist ')' %prec ARROW + { + std::vector args + = pstate->pop_vector (pstate->end_arglist ()); + operation_up type_op = pstate->pop (); + pstate->push_new + (std::move (type_op), std::move (args)); + } + ; + +exp : typename_for_ctor '(' ')' %prec ARROW + { + operation_up type_op = pstate->pop (); + pstate->push_new + (std::move (type_op), std::vector ()); + } + ; + exp : exp '(' /* This is to save the value of arglist_len being accumulated by an outer function call. */ @@ -1471,6 +1491,12 @@ scalar_type: "int"); } ; +/* Constructor-style calls. */ +typename_for_ctor + : TYPENAME_CTOR + { pstate->push_new ($1.type); } + ; + /* Implements (approximately): (type-qualifier)* type-specifier. When type-specifier is only ever a single word, like 'float' then these @@ -3114,6 +3140,34 @@ static int popping; built up. */ static auto_obstack name_obstack; +/* Return TYPENAME_CTOR only when the next token is '(', so this + token is used solely for constructor calls. Otherwise return TYPENAME. + NAME_END is the character just past the name (e.g. yylval.sval.ptr + + yylval.sval.length). */ + +static int +typename_token_for (struct parser_state *par_state, struct type *type, + const char *name_end) +{ + if (type == nullptr + || par_state->language ()->la_language != language_cplus) + return TYPENAME; + type = check_typedef (type); + if (type->code () != TYPE_CODE_STRUCT && type->code () != TYPE_CODE_UNION) + return TYPENAME; + /* Only return TYPENAME_CTOR when followed by '('. */ + if (name_end == nullptr) + return TYPENAME; + { + const char *p = name_end; + while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r') + ++p; + if (*p != '(') + return TYPENAME; + } + return TYPENAME_CTOR; +} + /* Classify a NAME token. The contents of the token are in `yylval'. Updates yylval and returns the new token type. BLOCK is the block in which lookups start; this can be NULL to mean the global scope. @@ -3157,7 +3211,8 @@ classify_name (struct parser_state *par_state, const struct block *block, if (bsym.symbol != NULL) { yylval.tsym.type = bsym.symbol->type (); - return TYPENAME; + return typename_token_for (par_state, yylval.tsym.type, + yylval.sval.ptr + yylval.sval.length); } } @@ -3184,7 +3239,8 @@ classify_name (struct parser_state *par_state, const struct block *block, if (bsym.symbol && bsym.symbol->loc_class () == LOC_TYPEDEF) { yylval.tsym.type = bsym.symbol->type (); - return TYPENAME; + return typename_token_for (par_state, yylval.tsym.type, + yylval.sval.ptr + yylval.sval.length); } /* See if it's an ObjC classname. */ @@ -3270,7 +3326,9 @@ classify_inner_name (struct parser_state *par_state, if (base_type != NULL) { yylval.tsym.type = base_type; - return TYPENAME; + return typename_token_for (par_state, yylval.tsym.type, + yylval.ssym.stoken.ptr + + yylval.ssym.stoken.length); } return ERROR; @@ -3290,14 +3348,18 @@ classify_inner_name (struct parser_state *par_state, if (base_type != NULL) { yylval.tsym.type = base_type; - return TYPENAME; + return typename_token_for (par_state, yylval.tsym.type, + yylval.ssym.stoken.ptr + + yylval.ssym.stoken.length); } } return ERROR; case LOC_TYPEDEF: yylval.tsym.type = yylval.ssym.sym.symbol->type (); - return TYPENAME; + return typename_token_for (par_state, yylval.tsym.type, + yylval.ssym.stoken.ptr + + yylval.ssym.stoken.length); default: return NAME; @@ -3332,7 +3394,7 @@ handle_qualified_field_name (qualified_name_token token) int kind = classify_inner_name (pstate, pstate->expression_context_block, type); - if (kind != TYPENAME) + if (kind != TYPENAME && kind != TYPENAME_CTOR) error (_("could not find type '%s'"), accum.c_str ()); type = yylval.tsym.type; @@ -3384,7 +3446,8 @@ yylex (void) current.token = classify_name (pstate, pstate->expression_context_block, is_quoted_name, last_lex_was_structop); if (pstate->language ()->la_language != language_cplus - || (current.token != TYPENAME && current.token != COLONCOLON + || (current.token != TYPENAME && current.token != TYPENAME_CTOR + && current.token != COLONCOLON && current.token != FILENAME && (cpstate->assume_classification == TYPE_CODE_UNDEF || current.token != NAME)) @@ -3430,6 +3493,7 @@ yylex (void) else { gdb_assert (current.token == TYPENAME + || current.token == TYPENAME_CTOR || cpstate->assume_classification != TYPE_CODE_UNDEF); search_block = pstate->expression_context_block; obstack_grow (&name_obstack, current.value.sval.ptr, @@ -3460,7 +3524,8 @@ yylex (void) context_type); /* We keep going until we either run out of names, or until we have a qualified name which is not a type. */ - if (classification != TYPENAME && classification != NAME) + if (classification != TYPENAME && classification != TYPENAME_CTOR + && classification != NAME) break; /* Accept up to this token. */ @@ -3591,6 +3656,7 @@ c_print_token (FILE *file, int type, YYSTYPE value) break; case TYPENAME: + case TYPENAME_CTOR: parser_fprintf (file, "tsym", value.tsym.type->safe_name (), copy_name (value.tsym.stoken).c_str ()); diff --git a/gdb/eval.c b/gdb/eval.c index 7beff554ed4..e988b954059 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -1869,6 +1869,61 @@ type_operation::evaluate (struct type *expect_type, struct expression *exp, error (_("Attempt to use a type name as an expression")); } +value * +type_operation::evaluate_funcall (struct type *expect_type, + struct expression *exp, + enum noside noside, + const std::vector &args) +{ + struct type *type = std::get<0> (m_storage); + type = check_typedef (type); + + /* Constructor-style call Type(args) is only for C++ aggregate types. */ + gdb_assert (exp->language_defn->la_language == language_cplus); + + const char *name = type->name (); + if (name == nullptr) + error (_("Cannot call constructor of unnamed type")); + + /* Get the constructor name from the type name. */ + gdb::unique_xmalloc_ptr ctor_name_ptr = cp_func_name (name); + const char *ctor_name = (ctor_name_ptr != nullptr) ? ctor_name_ptr.get () : name; + + if (!overload_resolution) + return operation::evaluate_funcall (expect_type, exp, noside, args); + + std::vector argvec (1 + args.size ()); + value *this_ptr; + if (noside == EVAL_AVOID_SIDE_EFFECTS) + this_ptr = value::zero (lookup_pointer_type (type), lval_memory); + else + { + value *alloc_val = value_allocate_space_in_inferior (type->length ()); + this_ptr = value_from_pointer (lookup_pointer_type (type), + value_as_long (alloc_val)); + } + argvec[0] = this_ptr; + for (size_t i = 0; i < args.size (); ++i) + argvec[i + 1] = args[i]->evaluate_with_coercion (exp, noside); + gdb::array_view arg_view = argvec; + + value *callee = nullptr; + int static_memfuncp; + find_overload_match (arg_view, ctor_name, METHOD, + &argvec[0], nullptr, &callee, nullptr, + &static_memfuncp, 0, noside); + if (callee == nullptr) + error (_("Cannot resolve constructor %s to any overloaded instance"), + name); + + if (noside == EVAL_AVOID_SIDE_EFFECTS) + return value::zero (type, not_lval); + + evaluate_subexp_do_call (exp, noside, callee, arg_view, + nullptr, expect_type); + return value_ind (this_ptr); +} + } /* A helper function for BINOP_ASSIGN_MODIFY. */ diff --git a/gdb/expop.h b/gdb/expop.h index c58a8d7ac37..9839e3bffa9 100644 --- a/gdb/expop.h +++ b/gdb/expop.h @@ -1597,6 +1597,11 @@ class type_operation struct expression *exp, enum noside noside) override; + value *evaluate_funcall (struct type *expect_type, + struct expression *exp, + enum noside noside, + const std::vector &args) override; + enum exp_opcode opcode () const override { return OP_TYPE; } diff --git a/gdb/testsuite/gdb.cp/infcall-ctors.cc b/gdb/testsuite/gdb.cp/infcall-ctors.cc new file mode 100644 index 00000000000..053542ec5ea --- /dev/null +++ b/gdb/testsuite/gdb.cp/infcall-ctors.cc @@ -0,0 +1,128 @@ +/* This testcase is part of GDB, the GNU debugger. + + 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 . */ + +struct S { + int x; + explicit S (int n = 0) : x (n) {} + S operator+ (int n) const { return S (x + n); } +}; + +typedef S S_td; +using S_u = S; + +static int add (const struct S &s1, const struct S &s2) { + return s1.x + s2.x; +} + +/* Non-trivially copyable: copy-constructing swaps the two members. */ +struct swapcopy { + int lo; + int hi; + swapcopy (int l, int h) : lo (l), hi (h) {} + swapcopy (const swapcopy &o) : lo (o.hi), hi (o.lo) {} +}; + +/* Pass swapcopy by value so the call must copy-construct the argument. */ + +static int +swapcopy_first_byval (swapcopy c) +{ + return c.lo; +} + +struct Base { + int x; + Base () : x (0) {} + explicit Base (int n) : x (n) {} + Base (const Base &other) : x (other.x) {} +}; + +typedef Base Base_td; +using Base_u = Base; + +namespace NS { +class Derived : public Base { +public: + int y; + Derived () : Base (), y (0) {} + Derived (int a, int b) : Base (a), y (b) {} +}; + +typedef Base NsBaseTd; +using NsBaseU = Base; +typedef Derived Derived_td; +using Derived_u = Derived; + +union U { + int a; + U () : a (0) {} + explicit U (int n) : a (n) {} +}; + +typedef U Nu_td; +} + +union U { + int x; + U () : x (0) {} + explicit U (int n) : x (n) {} +}; + +typedef U U_td; + +static int plus_one (U u) +{ + return u.x + 1; +} + +int +main (void) +{ + S s0; /* default: x = 0 */ + S s1 (42); /* x = 42 */ + S s2 (s1 + 2); /* x = 44 */ + S s3 = s1; + NS::Derived d; /* Base part x=0, Derived part y=0 */ + NS::Derived d1 (10, 20); /* Base part x=10, Derived part y=20 */ + Base b; /* x=0 */ + Base b1 (5); /* x=5 */ + Base b2 (d1); /* x=10 */ + U u0; /* default: x = 0 */ + U u1 (42); /* x = 42 */ + NS::U uv0; /* default: a = 0 */ + NS::U uv1 (7); /* a = 7 */ + S_td s_td = S_td (11); + S_u s_u = S_u (12); + Base_td b_td = Base_td (8); + Base_u b_u = Base_u (9); + NS::NsBaseTd nsb_td = NS::NsBaseTd (13); + NS::NsBaseU nsb_u = NS::NsBaseU (14); + NS::Derived_td d_td = NS::Derived_td (2, 3); + NS::Derived_u d_u = NS::Derived_u (4, 5); + U_td u_td = U_td (15); + NS::Nu_td nu_u = NS::Nu_td (16); + swapcopy swp (30, 40); + int result = add (s1, s2); + return result + d.x + d.y + b.x + b1.x + b2.x + d.x + d.y \ + + d1.x + d1.y + plus_one (u0) + u1.x + uv0.a + uv1.a \ + + s_td.x + s_u.x + b_td.x + b_u.x + nsb_td.x + nsb_u.x \ + + d_td.x + d_td.y + d_u.x + d_u.y + u_td.x + nu_u.a \ + + swapcopy_first_byval (swapcopy (100, 200)) \ + + swapcopy_first_byval (swp); /* stop-here */ +} diff --git a/gdb/testsuite/gdb.cp/infcall-ctors.exp b/gdb/testsuite/gdb.cp/infcall-ctors.exp new file mode 100644 index 00000000000..88297018b28 --- /dev/null +++ b/gdb/testsuite/gdb.cp/infcall-ctors.exp @@ -0,0 +1,188 @@ +# 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 . + +# This file is part of the gdb testsuite. + +# Test constructor calls and casting via inferior function calls: +# - Simple struct S with constructor (int, default 0). +# - Base and Derived; cast derived to base, construct Base from Derived. +# - Typedef and using aliases: ctor resolution must use the class ctor even +# when the expression names a typedef or alias (DWARF may name types +# differently from the underlying class tag). +# - swapcopy: two ints with a user-defined copy ctor that swaps them +# (non-trivially copyable); pass-by-value in inferior calls must run it. + +require allow_cplus_tests + +standard_testfile .cc + +if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} { + return -1 +} + +if {![runto_main]} { + return +} + +# Run to stop-here to ensure all locals are initialized. +gdb_breakpoint [gdb_get_line_number "stop-here"] +gdb_continue_to_breakpoint "stop-here" + +# Simple tests involving "struct S". +gdb_test "ptype S" [multi_line \ + {type = struct S \{} \ + { int x;} \ + "" \ + { S\(int\);} \ + { S operator\+\(int\) const;} \ + {\}}] + +gdb_test "print s0" " = \\{x = 0\\}" "print s0 default ctor" +gdb_test "print s1" " = \\{x = 42\\}" "print s1 with 42" +gdb_test "print S(99)" " = \\{x = 99\\}" "construct S(99) via inferior function call" + +gdb_test "ptype swapcopy" [multi_line \ + {type = struct swapcopy \{} \ + { int lo;} \ + { int hi;} \ + "" \ + { swapcopy\(int, int\);} \ + { swapcopy\(const swapcopy ?&\);} \ + {\}}] +gdb_test "print swapcopy(1, 2)" { = \{lo = 1, hi = 2\}} \ + "construct swapcopy via inferior function call" +gdb_test {print swapcopy($)} {= \{lo = 2, hi = 1\}} \ + "call copy ctor on object via history" +gdb_test "print swapcopy_first_byval(swapcopy(10, 20))" "= 20" \ + "pass-by-value copy ctor swaps members" +gdb_test "print swapcopy_first_byval(swp)" "= 40" \ + "swapcopy local passed by value uses copy ctor" + +gdb_test "print S_td(33)" " = \\{x = 33\\}" \ + "construct S via typedef name (not underlying struct tag)" +gdb_test "print S_u(34)" " = \\{x = 34\\}" "construct S via using alias" +gdb_test "print Base_td(8)" { = \{x = 8\}} "construct Base via typedef name" +gdb_test "print Base_u(9)" { = \{x = 9\}} "construct Base via using alias" +gdb_test "print NS::NsBaseTd(5)" { = \{x = 5\}} \ + "construct Base via typedef in namespace" +gdb_test "print NS::NsBaseU(6)" { = \{x = 6\}} \ + "construct Base via using alias in namespace" +gdb_test "print NS::Derived_td(1, 2)" { = \{ = \{x = 1\}, y = 2\}} \ + "construct NS::Derived via typedef name" +gdb_test "print NS::Derived_u(3, 4)" { = \{ = \{x = 3\}, y = 4\}} \ + "construct NS::Derived via using alias" +gdb_test "print U_td(55)" { = \{x = 55\}} \ + "construct global union U via typedef name" +gdb_test "print NS::Nu_td(66)" { = \{a = 66\}} \ + "construct NS::U via typedef name" + +# Tests involving "Base" and "Derived". +set base_re [multi_line \ + {type = struct Base \{} \ + { int x;} \ + "" \ + { Base\(void\);} \ + { Base\(int\);} \ + { Base\(const Base ?&\);} \ + {\}}] +gdb_test "ptype Base" $base_re + +set derived_re [multi_line \ + {type = class NS::Derived : public Base \{} \ + { public:} \ + { int y;} \ + "" \ + { Derived\(void\);} \ + { Derived\(int, int\);} \ + {\}}] +gdb_test "ptype NS::Derived" $derived_re + +gdb_test "print d" { = \{ = \{x = 0\}, y = 0\}} +gdb_test "print d1" { = \{ = \{x = 10\}, y = 20\}} +gdb_test "print b" { = \{x = 0\}} +gdb_test "print b1" { = \{x = 5\}} +gdb_test "print b2" { = \{x = 10\}} +gdb_test "print (Base)(d1)" { = \{x = 10\}} "cast (Base)(d1) slices to Base" +gdb_test "print Base(d1)" { = \{x = 10\}} "construct Base(d1) from Derived" +gdb_test "print Base()" { = \{x = 0\}} "construct Base() default" +gdb_test "print Base(7)" { = \{x = 7\}} "construct Base(7) with argument" +gdb_test "print NS::Derived()" { = \{ = \{x = 0\}, y = 0\}} \ + "construct NS::Derived() via inferior function call" +gdb_test "print NS::Derived().y" " = 0" "construct NS::Derived() and access .y" +gdb_test "print NS::Derived(1, 2)" { = \{ = \{x = 1\}, y = 2\}} \ + "construct NS::Derived(1, 2) via inferior function call" +gdb_test "print NS::Derived(1, 2).y" " = 2" \ + "construct NS::Derived(1, 2) and access .y" +gdb_test "print ((Base)d1).x" " = 10" "cast ((Base)d1).x" + +# Print the types of these "temporary" objects. +gdb_test "ptype Base()" $base_re "ptype of Base temporary" +gdb_test "ptype NS::Derived(15, 25)" $derived_re \ + "ptype of NS::Derived temporary" + +# Tests involving unions. +gdb_test "ptype U" [multi_line \ + {type = union U \{} \ + { int x;} \ + "" \ + { U\(void\);} \ + { U\(int\);} \ + {\}}] \ + "ptype U" + +gdb_test "ptype NS::U" [multi_line \ + {type = union NS::U \{} \ + { int a;} \ + "" \ + { U\(void\);} \ + { U\(int\);} \ + {\}}] \ + "ptype NS::U" + +gdb_test "print u0" { = \{x = 0\}} +gdb_test "print u1" { = \{x = 42\}} +gdb_test "print uv0" { = \{a = 0\}} +gdb_test "print uv1" { = \{a = 7\}} +gdb_test "print U()" { = \{x = 0\}} "construct U() via inferior function call" +gdb_test "print U(99)" { = \{x = 99\}} "construct U(99) via inferior function call" +gdb_test "print U(99).x" " = 99" "construct U(99) and access .x" +gdb_test "print NS::U()" { = \{a = 0\}} \ + "construct NS::U() via inferior function call" +gdb_test "print NS::U(13)" { = \{a = 13\}} \ + "construct NS::U(13) via inferior function call" +gdb_test "print NS::U(13).a" " = 13" \ + "construct NS::U(13) and access .a" + +set u_re [multi_line \ + {type = union U \{} \ + { int x;} \ + "" \ + { U\(void\);} \ + { U\(int\);} \ + {\}}] +set ns_u_re [multi_line \ + {type = union NS::U \{} \ + { int a;} \ + "" \ + { U\(void\);} \ + { U\(int\);} \ + {\}}] +gdb_test "ptype U()" $u_re "ptype of U temporary" +gdb_test "ptype NS::U(99)" $ns_u_re "ptype of NS::U temporary" + +gdb_test "p plus_one(U(42))" "= 43" "temporary in function call" +gdb_test "p add(S(1), S(20))" "= 21" "add two temporaries of S" +gdb_test "p plus_one(U(add (S(4), S(6))))" "= 11" \ + "nested function call using temporaries" base-commit: 07519d531b1e858f665ff011d7f1002f38111ec8 -- 2.53.0