From patchwork Wed May 24 16:36:59 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Tromey X-Patchwork-Id: 69968 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id AAE43384B81B for ; Wed, 24 May 2023 16:38:40 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org AAE43384B81B DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1684946320; bh=lQHNz5o5QXMI3C0lc/NQTYDDvimJRWkmHw35d4iibhQ=; h=Date:Subject:References:In-Reply-To:To:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=cSxOWwX3RlD7B6/bCYbljaI0Ikmy+u0Rx9Vr8KnnQ9qoXCiuLUvKzq+BJyvzw/eE6 rbCbsJ78y9zkCfPPM0A/hZR5L/8bmhPdZOSD4qvxHgCRSms7EMORUT5SiqS9lntodN OH7pvv4ifMA8gSarMTkEq6GveXYMSF/UkgAY0i04= X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from mail-io1-xd30.google.com (mail-io1-xd30.google.com [IPv6:2607:f8b0:4864:20::d30]) by sourceware.org (Postfix) with ESMTPS id 95C173857720 for ; Wed, 24 May 2023 16:37:29 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 95C173857720 Received: by mail-io1-xd30.google.com with SMTP id ca18e2360f4ac-7748edd6c87so33105639f.0 for ; Wed, 24 May 2023 09:37:29 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1684946249; x=1687538249; h=to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=lQHNz5o5QXMI3C0lc/NQTYDDvimJRWkmHw35d4iibhQ=; b=ilKPavR+5n9aDT3VOO9jzXWmjul8ukgpPMHt5cJCMWpoXRntHzH/giEdL6+SYQi24g t9W7vYTS/fp7zzF2++OPqvh/of0OxCbF1RzNTsWOT7Btrbq0SP0hbNcUN2PtxqQ75TP5 oqCugY5UZXib7C8FluAeWlEybZlosefjbtFUyiyjSNScocmZU9N3m5NOsJ4e02fkjkgh 0rHTzO0p60RQtSFRjXTT+PqoHSCUTMHdJuOQgBrQwHjiHhEO7Q0lN+ZIroKTMeLDeAQC atnQNBCj/8dH9JazZ32dYIGcx67mBp0sZ1CQouevhyBT3bSU+w/kRcO7sccsZIgC7N+Z pxhw== X-Gm-Message-State: AC+VfDz467rV18FnqiJXYkyGHx6XMICLH6d1KCpWJlXyJ7f47lzS/ml1 CTGWDiOQqa3pl2qEQfFPuAaP/K0OQ8Hw+Fwcn8CxTQ== X-Google-Smtp-Source: ACHHUZ4hVhP459ePgLNoHWbHdIJK9R/NfLC4nynpIIGaDzd2XS8U+JbJIuVo7picX0BuRjHMVbakQw== X-Received: by 2002:a5e:a907:0:b0:774:91f6:9530 with SMTP id c7-20020a5ea907000000b0077491f69530mr1849159iod.9.1684946248758; Wed, 24 May 2023 09:37:28 -0700 (PDT) Received: from localhost.localdomain (71-211-130-244.hlrn.qwest.net. [71.211.130.244]) by smtp.gmail.com with ESMTPSA id o22-20020a6bcf16000000b0076c81bf2731sm3397266ioa.20.2023.05.24.09.37.28 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 May 2023 09:37:28 -0700 (PDT) Date: Wed, 24 May 2023 10:36:59 -0600 Subject: [PATCH 08/25] Don't require inferior execution for Ada catchpoints MIME-Version: 1.0 Message-Id: <20230427-ada-catch-exception-v1-8-947caa9905e3@adacore.com> References: <20230427-ada-catch-exception-v1-0-947caa9905e3@adacore.com> In-Reply-To: <20230427-ada-catch-exception-v1-0-947caa9905e3@adacore.com> To: gdb-patches@sourceware.org X-Mailer: b4 0.12.2 X-Spam-Status: No, score=-11.7 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Tom Tromey via Gdb-patches From: Tom Tromey Reply-To: Tom Tromey Errors-To: gdb-patches-bounces+patchwork=sourceware.org@sourceware.org Sender: "Gdb-patches" Currently, Ada catchpoints require that the inferior be running. However, there's no deep reason for this -- for example, C++ exception catchpoints do not have this requirement. Instead, those work like ordinary breakpoints: they are pending until the needed runtime locations are seen. This patch changes Ada catchpoints to work the same way. --- gdb/ada-lang.c | 115 +++++++++++++++------------------------------------------ 1 file changed, 29 insertions(+), 86 deletions(-) diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 6ee507147cb..f9d5965f055 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -790,18 +790,6 @@ ada_get_decoded_type (struct type *type) /* Language Selection */ -/* If the main program is in Ada, return language_ada, otherwise return LANG - (the main program is in Ada iif the adainit symbol is found). */ - -static enum language -ada_update_initial_language (enum language lang) -{ - if (lookup_minimal_symbol ("adainit", NULL, NULL).minsym != NULL) - return language_ada; - - return lang; -} - /* If the main procedure is written in Ada, then return its name. The result is good until the next call. Return NULL if the main procedure doesn't appear to be in Ada. */ @@ -11827,31 +11815,8 @@ ada_exception_support_info_sniffer (void) return; } - /* Sometimes, it is normal for us to not be able to find the routine - we are looking for. This happens when the program is linked with - the shared version of the GNAT runtime, and the program has not been - started yet. Inform the user of these two possible causes if - applicable. */ - - if (ada_update_initial_language (language_unknown) != language_ada) - error (_("Unable to insert catchpoint. Is this an Ada main program?")); - - /* If the symbol does not exist, then check that the program is - already started, to make sure that shared libraries have been - loaded. If it is not started, this may mean that the symbol is - in a shared library. */ - - if (inferior_ptid.pid () == 0) - error (_("Unable to insert catchpoint. Try to start the program first.")); - - /* At this point, we know that we are debugging an Ada program and - that the inferior has been started, but we still are not able to - find the run-time symbols. That can mean that we are in - configurable run time mode, or that a-except as been optimized - out by the linker... In any case, at this point it is not worth - supporting this feature. */ - - error (_("Cannot insert Ada exception catchpoints in this configuration.")); + throw_error (NOT_FOUND_ERROR, + _("Could not find Ada runtime exception support")); } /* True iff FRAME is very likely to be that of a function that is @@ -12135,44 +12100,19 @@ struct ada_catchpoint : public code_breakpoint { ada_catchpoint (struct gdbarch *gdbarch_, enum ada_exception_catchpoint_kind kind, - struct symtab_and_line sal, - const char *addr_string_, + const char *cond_string, bool tempflag, bool enabled, bool from_tty, std::string &&excep_string_) - : code_breakpoint (gdbarch_, bp_catchpoint, tempflag), + : code_breakpoint (gdbarch_, bp_catchpoint, tempflag, cond_string), m_excep_string (std::move (excep_string_)), m_kind (kind) { - add_location (sal); - /* Unlike most code_breakpoint types, Ada catchpoints are pspace-specific. */ - gdb_assert (sal.pspace != nullptr); - this->pspace = sal.pspace; - - if (from_tty) - { - struct gdbarch *loc_gdbarch = get_sal_arch (sal); - if (!loc_gdbarch) - loc_gdbarch = gdbarch; - - describe_other_breakpoints (loc_gdbarch, - sal.pspace, sal.pc, sal.section, -1); - /* FIXME: brobecker/2006-12-28: Actually, re-implement a special - version for exception catchpoints, because two catchpoints - used for different exception names will use the same address. - In this case, a "breakpoint ... also set at..." warning is - unproductive. Besides, the warning phrasing is also a bit - inappropriate, we should use the word catchpoint, and tell - the user what type of catchpoint it is. The above is good - enough for now, though. */ - } - + pspace = current_program_space; enable_state = enabled ? bp_enabled : bp_disabled; - locspec = string_to_location_spec (&addr_string_, - language_def (language_ada)); language = language_ada; re_set (); @@ -12217,15 +12157,29 @@ class ada_catchpoint_location : public bp_location expression_up excep_cond_expr; }; +static struct symtab_and_line ada_exception_sal + (enum ada_exception_catchpoint_kind ex); + /* Implement the RE_SET method in the structure for all exception catchpoint kinds. */ void ada_catchpoint::re_set () { - /* Call the base class's method. This updates the catchpoint's - locations. */ - this->code_breakpoint::re_set (); + std::vector sals; + try + { + struct symtab_and_line sal = ada_exception_sal (m_kind); + sals.push_back (sal); + } + catch (const gdb_exception_error &ex) + { + /* For NOT_FOUND_ERROR, the breakpoint will be pending. */ + if (ex.error != NOT_FOUND_ERROR) + throw; + } + + update_breakpoint_locations (this, pspace, sals, {}); /* Reparse the exception conditional expressions. One for each location. */ @@ -12756,16 +12710,11 @@ ada_exception_catchpoint_cond_string (const char *excep_string, return result; } -/* Return the symtab_and_line that should be used to insert an exception - catchpoint of the TYPE kind. - - ADDR_STRING returns the name of the function where the real - breakpoint that implements the catchpoints is set, depending on the - type of catchpoint we need to create. */ +/* Return the symtab_and_line that should be used to insert an + exception catchpoint of the TYPE kind. */ static struct symtab_and_line -ada_exception_sal (enum ada_exception_catchpoint_kind ex, - std::string *addr_string) +ada_exception_sal (enum ada_exception_catchpoint_kind ex) { const char *sym_name; struct symbol *sym; @@ -12779,14 +12728,12 @@ ada_exception_sal (enum ada_exception_catchpoint_kind ex, sym = standard_lookup (sym_name, NULL, VAR_DOMAIN); if (sym == NULL) - error (_("Catchpoint symbol not found: %s"), sym_name); + throw_error (NOT_FOUND_ERROR, _("Catchpoint symbol not found: %s"), + sym_name); if (sym->aclass () != LOC_BLOCK) error (_("Unable to insert catchpoint. %s is not a function."), sym_name); - /* Set ADDR_STRING. */ - *addr_string = sym_name; - return find_function_start_sal (sym, 1); } @@ -12814,15 +12761,11 @@ create_ada_exception_catchpoint (struct gdbarch *gdbarch, int enabled, int from_tty) { - std::string addr_string; - struct symtab_and_line sal = ada_exception_sal (ex_kind, &addr_string); - std::unique_ptr c - (new ada_catchpoint (gdbarch, ex_kind, sal, addr_string.c_str (), + (new ada_catchpoint (gdbarch, ex_kind, + cond_string.empty () ? nullptr : cond_string.c_str (), tempflag, enabled, from_tty, std::move (excep_string))); - if (!cond_string.empty ()) - set_breakpoint_condition (c.get (), cond_string.c_str (), from_tty, false); install_breakpoint (0, std::move (c), 1); }