From patchwork Tue Jun 18 15:08:15 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Malcolm X-Patchwork-Id: 1949228 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=Qn/4RX+Z; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=8.43.85.97; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.sourceware.org (server2.sourceware.org [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4W3VXB0CvQz20KL for ; Wed, 19 Jun 2024 01:09:13 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 3AEF6388451A for ; Tue, 18 Jun 2024 15:09:12 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id 9FCC7388300A for ; Tue, 18 Jun 2024 15:08:29 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 9FCC7388300A Authentication-Results: sourceware.org; dmarc=pass (p=none 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 9FCC7388300A 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=1718723314; cv=none; b=fdz+8Ku2nMNPzNvUSX1m3jIOJElZKRGZiVvo5uZfeADlQYcKRuWRJKFCZcv6cTqrxRHKuDALIJ1wXav6gWXm/urjyJxMmOKe/TnDzviD7deXZm5Ryv6PHMHdgJkvD6OKcab05xqbA9Yrj0SKUtMcQk4DJchTsAw9xJxnIGLKeTQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1718723314; c=relaxed/simple; bh=I88fUa5F1YTz60q26UYI1VMIsWCfBaxIp1cNoUpscc4=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=foD42vzeUvUPZpCTWpz+JFlH6tjwx0ErNXMbJRvXsBXtNlGy44vAlKNaJJJufyBRwbIZ4bxZSJusPwRUxRwYKxlUN/8kxx28MWhAM98vNOB5YI7nc7zEGYKo+wF2UQvWboNWpzVidW9irOJG4voNbQVv17mEuzoI/KM1dt/dONQ= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1718723309; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=AbQLLrUKlgES8xlV3ZLCV+A5r2OYyz/LnXoO9MOigsY=; b=Qn/4RX+Z/FU1+V8qxVyrqTTuMWDnYUexaccoeGgzIyGW7+C/IhorTb25Tq7LZCsXuxQOK5 7+YJbdFKPBBHpyqOguLcCskaw1pENJalUDGdthSnxbl7f9iMgcQYLhFjUf8sdmacwOSDy9 yesuhatW5XmyuxfeWCLY9op1KpagVOA= Received: from mx-prod-mc-01.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-392-LAHWdcVoMSS5OGNcBpLvsA-1; Tue, 18 Jun 2024 11:08:27 -0400 X-MC-Unique: LAHWdcVoMSS5OGNcBpLvsA-1 Received: from mx-prod-int-05.mail-002.prod.us-west-2.aws.redhat.com (mx-prod-int-05.mail-002.prod.us-west-2.aws.redhat.com [10.30.177.17]) (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-01.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTPS id 482C31956050 for ; Tue, 18 Jun 2024 15:08:26 +0000 (UTC) Received: from t14s.localdomain.com (unknown [10.22.10.107]) by mx-prod-int-05.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTP id 3D0A91956048; Tue, 18 Jun 2024 15:08:25 +0000 (UTC) From: David Malcolm To: gcc-patches@gcc.gnu.org Cc: David Malcolm Subject: [PATCH 3/7] diagnostics: remove tree usage from tree-diagnostic-path.cc Date: Tue, 18 Jun 2024 11:08:15 -0400 Message-Id: <20240618150819.946820-4-dmalcolm@redhat.com> In-Reply-To: <20240618150819.946820-1-dmalcolm@redhat.com> References: <20240618150819.946820-1-dmalcolm@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.0 on 10.30.177.17 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-10.4 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, RCVD_IN_SBL_CSS, SPF_HELO_NONE, SPF_NONE, 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: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org No functional change intended. gcc/ChangeLog: * Makefile.in (OBJS): Add selftest-diagnostic-path.o and selftest-logical-location.o. * logical-location.h: Include "label-text.h". (class logical_location): Update leading comment. * selftest-diagnostic-path.cc: New file, adapted from simple-diagnostic-path.cc and from material in tree-diagnostic-path.cc. * selftest-diagnostic-path.h: New file, adapted from simple-diagnostic-path.h and from material in tree-diagnostic-path.cc. * selftest-logical-location.cc: New file. * selftest-logical-location.h: New file. * tree-diagnostic-path.cc: Remove includes of "tree-pretty-print.h", "langhooks.h", and "simple-diagnostic-path.h". Add include of "selftest-diagnostic-path.h". (class test_diagnostic_path): Delete, in favor of new implementation in selftest-diagnostic-path.{h,cc}, which is directly derived from diagnostic_path, rather than from simple_diagnostic_path. (selftest::test_intraprocedural_path): Eliminate tree usage, via change to test_diagnostic_path, using strings rather than function_decls for identifying functions in the test. (selftest::test_interprocedural_path_1): Likewise. (selftest::test_interprocedural_path_2): Likewise. (selftest::test_recursion): Likewise. (selftest::test_control_flow_1): Likewise. (selftest::test_control_flow_2): Likewise. (selftest::test_control_flow_3): Likewise. (selftest::assert_cfg_edge_path_streq): Likewise. (selftest::test_control_flow_5): Likewise. (selftest::test_control_flow_6): Likewise. Signed-off-by: David Malcolm --- gcc/Makefile.in | 2 + gcc/logical-location.h | 5 +- gcc/selftest-diagnostic-path.cc | 233 +++++++++++++++++++++++++++++++ gcc/selftest-diagnostic-path.h | 163 +++++++++++++++++++++ gcc/selftest-logical-location.cc | 71 ++++++++++ gcc/selftest-logical-location.h | 58 ++++++++ gcc/tree-diagnostic-path.cc | 161 +++++++-------------- 7 files changed, 580 insertions(+), 113 deletions(-) create mode 100644 gcc/selftest-diagnostic-path.cc create mode 100644 gcc/selftest-diagnostic-path.h create mode 100644 gcc/selftest-logical-location.cc create mode 100644 gcc/selftest-logical-location.h diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 35f259da858..a2799b8d826 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1700,6 +1700,8 @@ OBJS = \ ubsan.o \ sanopt.o \ sancov.o \ + selftest-diagnostic-path.o \ + selftest-logical-location.o \ simple-diagnostic-path.o \ tree-call-cdce.o \ tree-cfg.o \ diff --git a/gcc/logical-location.h b/gcc/logical-location.h index c3b72081135..bba21087786 100644 --- a/gcc/logical-location.h +++ b/gcc/logical-location.h @@ -21,6 +21,8 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_LOGICAL_LOCATION_H #define GCC_LOGICAL_LOCATION_H +#include "label-text.h" + /* An enum for discriminating between different kinds of logical location for a diagnostic. @@ -46,7 +48,8 @@ enum logical_location_kind - "within function 'foo'", or - "within method 'bar'", but *without* requiring knowledge of trees - (see tree-logical-location.h for subclasses relating to trees). */ + (see tree-logical-location.h for concrete subclasses relating to trees, + and selftest-logical-location.h for a concrete subclass for selftests). */ class logical_location { diff --git a/gcc/selftest-diagnostic-path.cc b/gcc/selftest-diagnostic-path.cc new file mode 100644 index 00000000000..6d21f2e5599 --- /dev/null +++ b/gcc/selftest-diagnostic-path.cc @@ -0,0 +1,233 @@ +/* Concrete classes for selftests involving diagnostic paths. + Copyright (C) 2019-2024 Free Software Foundation, Inc. + Contributed by David Malcolm + +This file is part of GCC. + +GCC 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, or (at your option) any later +version. + +GCC 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 GCC; see the file COPYING3. If not see +. */ + + +#include "config.h" +#define INCLUDE_VECTOR +#include "system.h" +#include "coretypes.h" +#include "version.h" +#include "demangle.h" +#include "backtrace.h" +#include "diagnostic.h" +#include "selftest-diagnostic-path.h" + +#if CHECKING_P + +namespace selftest { + +/* class test_diagnostic_path : public diagnostic_path. */ + +test_diagnostic_path::test_diagnostic_path (pretty_printer *event_pp) +: m_event_pp (event_pp) +{ + add_thread ("main"); +} + +/* Implementation of diagnostic_path::num_events vfunc for + test_diagnostic_path: simply get the number of events in the vec. */ + +unsigned +test_diagnostic_path::num_events () const +{ + return m_events.length (); +} + +/* Implementation of diagnostic_path::get_event vfunc for + test_diagnostic_path: simply return the event in the vec. */ + +const diagnostic_event & +test_diagnostic_path::get_event (int idx) const +{ + return *m_events[idx]; +} + +unsigned +test_diagnostic_path::num_threads () const +{ + return m_threads.length (); +} + +const diagnostic_thread & +test_diagnostic_path::get_thread (diagnostic_thread_id_t idx) const +{ + return *m_threads[idx]; +} + +bool +test_diagnostic_path::same_function_p (int event_idx_a, + int event_idx_b) const +{ + const char *name_a = m_events[event_idx_a]->get_function_name (); + const char *name_b = m_events[event_idx_b]->get_function_name (); + + if (name_a && name_b) + return 0 == strcmp (name_a, name_b); + return name_a == name_b; +} + +diagnostic_thread_id_t +test_diagnostic_path::add_thread (const char *name) +{ + m_threads.safe_push (new test_diagnostic_thread (name)); + return m_threads.length () - 1; +} + +/* Add an event to this path at LOC within function FNDECL at + stack depth DEPTH. + + Use m_context's printer to format FMT, as the text of the new + event. + + Return the id of the new event. */ + +diagnostic_event_id_t +test_diagnostic_path::add_event (location_t loc, + const char *funcname, + int depth, + const char *fmt, ...) +{ + pretty_printer *pp = m_event_pp; + pp_clear_output_area (pp); + + rich_location rich_loc (line_table, UNKNOWN_LOCATION); + + va_list ap; + + va_start (ap, fmt); + + /* No localization is done on FMT. */ + text_info ti (fmt, &ap, 0, nullptr, &rich_loc); + pp_format (pp, &ti); + pp_output_formatted_text (pp); + + va_end (ap); + + test_diagnostic_event *new_event + = new test_diagnostic_event (loc, funcname, depth, pp_formatted_text (pp)); + m_events.safe_push (new_event); + + pp_clear_output_area (pp); + + return diagnostic_event_id_t (m_events.length () - 1); +} + +diagnostic_event_id_t +test_diagnostic_path::add_thread_event (diagnostic_thread_id_t thread_id, + location_t loc, + const char *funcname, + int depth, + const char *fmt, ...) +{ + pretty_printer *pp = m_event_pp; + pp_clear_output_area (pp); + + rich_location rich_loc (line_table, UNKNOWN_LOCATION); + + va_list ap; + + va_start (ap, fmt); + + /* No localization is done on FMT. */ + text_info ti (fmt, &ap, 0, nullptr, &rich_loc); + + pp_format (pp, &ti); + pp_output_formatted_text (pp); + + va_end (ap); + + test_diagnostic_event *new_event + = new test_diagnostic_event (loc, funcname, depth, pp_formatted_text (pp), + thread_id); + m_events.safe_push (new_event); + + pp_clear_output_area (pp); + + return diagnostic_event_id_t (m_events.length () - 1); +} + +/* Mark the most recent event on this path (which must exist) as being + connected to the next one to be added. */ + +void +test_diagnostic_path::connect_to_next_event () +{ + gcc_assert (m_events.length () > 0); + m_events[m_events.length () - 1]->connect_to_next_event (); +} + +void +test_diagnostic_path::add_entry (const char *callee_name, + int stack_depth, + diagnostic_thread_id_t thread_id) +{ + add_thread_event (thread_id, UNKNOWN_LOCATION, callee_name, stack_depth, + "entering %qs", callee_name); +} + +void +test_diagnostic_path::add_return (const char *caller_name, + int stack_depth, + diagnostic_thread_id_t thread_id) +{ + add_thread_event (thread_id, UNKNOWN_LOCATION, caller_name, stack_depth, + "returning to %qs", caller_name); +} + +void +test_diagnostic_path::add_call (const char *caller_name, + int caller_stack_depth, + const char *callee_name, + diagnostic_thread_id_t thread_id) +{ + add_thread_event (thread_id, UNKNOWN_LOCATION, + caller_name, caller_stack_depth, + "calling %qs", callee_name); + add_entry (callee_name, caller_stack_depth + 1, thread_id); +} + +/* struct test_diagnostic_event. */ + +/* test_diagnostic_event's ctor. */ + +test_diagnostic_event:: +test_diagnostic_event (location_t loc, + const char *funcname, + int depth, + const char *desc, + diagnostic_thread_id_t thread_id) +: m_loc (loc), + m_logical_loc (LOGICAL_LOCATION_KIND_FUNCTION, funcname), + m_depth (depth), m_desc (xstrdup (desc)), + m_connected_to_next_event (false), + m_thread_id (thread_id) +{ +} + +/* test_diagnostic_event's dtor. */ + +test_diagnostic_event::~test_diagnostic_event () +{ + free (m_desc); +} + +} // namespace selftest + +#endif /* #if CHECKING_P */ diff --git a/gcc/selftest-diagnostic-path.h b/gcc/selftest-diagnostic-path.h new file mode 100644 index 00000000000..51786a0f589 --- /dev/null +++ b/gcc/selftest-diagnostic-path.h @@ -0,0 +1,163 @@ +/* Concrete classes for selftests involving diagnostic paths. + Copyright (C) 2019-2024 Free Software Foundation, Inc. + Contributed by David Malcolm + +This file is part of GCC. + +GCC 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, or (at your option) any later +version. + +GCC 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 GCC; see the file COPYING3. If not see +. */ + +#ifndef GCC_SELFTEST_DIAGNOSTIC_PATH_H +#define GCC_SELFTEST_DIAGNOSTIC_PATH_H + +#include "diagnostic-path.h" +#include "selftest-logical-location.h" + +/* The selftest code should entirely disappear in a production + configuration, hence we guard all of it with #if CHECKING_P. */ + +#if CHECKING_P + +namespace selftest { + +/* Concrete subclasses of the abstract base classes + declared in diagnostic-path.h for use in selftests. + + This code should have no dependency on "tree". */ + +/* An implementation of diagnostic_event. */ + +class test_diagnostic_event : public diagnostic_event +{ + public: + test_diagnostic_event (location_t loc, const char *funcname, int depth, + const char *desc, + diagnostic_thread_id_t thread_id = 0); + ~test_diagnostic_event (); + + location_t get_location () const final override { return m_loc; } + int get_stack_depth () const final override { return m_depth; } + label_text get_desc (bool) const final override + { + return label_text::borrow (m_desc); + } + const logical_location *get_logical_location () const final override + { + if (m_logical_loc.get_name ()) + return &m_logical_loc; + else + return nullptr; + } + meaning get_meaning () const final override + { + return meaning (); + } + bool connect_to_next_event_p () const final override + { + return m_connected_to_next_event; + } + diagnostic_thread_id_t get_thread_id () const final override + { + return m_thread_id; + } + + void connect_to_next_event () + { + m_connected_to_next_event = true; + } + + const char *get_function_name () const + { + return m_logical_loc.get_name (); + } + + private: + location_t m_loc; + test_logical_location m_logical_loc; + int m_depth; + char *m_desc; // has been formatted; doesn't get i18n-ed + bool m_connected_to_next_event; + diagnostic_thread_id_t m_thread_id; +}; + +/* A simple implementation of diagnostic_thread. */ + +class test_diagnostic_thread : public diagnostic_thread +{ +public: + test_diagnostic_thread (const char *name) : m_name (name) {} + label_text get_name (bool) const final override + { + return label_text::borrow (m_name); + } + +private: + const char *m_name; // has been i18n-ed and formatted +}; + +/* A concrete subclass of diagnostic_path for implementing selftests + - a vector of test_diagnostic_event instances + - adds member functions for adding test event + - does no translation of its events + - has no dependency on "tree". */ + +class test_diagnostic_path : public diagnostic_path +{ + public: + test_diagnostic_path (pretty_printer *event_pp); + + unsigned num_events () const final override; + const diagnostic_event & get_event (int idx) const final override; + unsigned num_threads () const final override; + const diagnostic_thread & + get_thread (diagnostic_thread_id_t) const final override; + bool + same_function_p (int event_idx_a, + int event_idx_b) const final override; + + diagnostic_thread_id_t add_thread (const char *name); + + diagnostic_event_id_t add_event (location_t loc, const char *funcname, int depth, + const char *fmt, ...) + ATTRIBUTE_GCC_DIAG(5,6); + diagnostic_event_id_t + add_thread_event (diagnostic_thread_id_t thread_id, + location_t loc, const char *funcname, int depth, + const char *fmt, ...) + ATTRIBUTE_GCC_DIAG(6,7); + + void connect_to_next_event (); + + void add_entry (const char *callee_name, int stack_depth, + diagnostic_thread_id_t thread_id = 0); + void add_return (const char *caller_name, int stack_depth, + diagnostic_thread_id_t thread_id = 0); + void add_call (const char *caller_name, + int caller_stack_depth, + const char *callee_name, + diagnostic_thread_id_t thread_id = 0); + + private: + auto_delete_vec m_threads; + auto_delete_vec m_events; + + /* (for use by add_event). */ + pretty_printer *m_event_pp; +}; + +} // namespace selftest + +#endif /* #if CHECKING_P */ + +#endif /* ! GCC_SELFTEST_DIAGNOSTIC_PATH_H */ diff --git a/gcc/selftest-logical-location.cc b/gcc/selftest-logical-location.cc new file mode 100644 index 00000000000..8017672afa7 --- /dev/null +++ b/gcc/selftest-logical-location.cc @@ -0,0 +1,71 @@ +/* Concrete subclass of logical_location for use in selftests. + Copyright (C) 2024 Free Software Foundation, Inc. + Contributed by David Malcolm . + +This file is part of GCC. + +GCC 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, or (at your option) any later +version. + +GCC 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 GCC; see the file COPYING3. If not see +. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "selftest-logical-location.h" + +#if CHECKING_P + +namespace selftest { + +/* class test_logical_location : public logical_location. */ + +test_logical_location::test_logical_location (enum logical_location_kind kind, + const char *name) +: m_kind (kind), + m_name (name) +{ +} + +const char * +test_logical_location::get_short_name () const +{ + return m_name; +} + +const char * +test_logical_location::get_name_with_scope () const +{ + return m_name; +} + +const char * +test_logical_location::get_internal_name () const +{ + return m_name; +} + +enum logical_location_kind +test_logical_location::get_kind () const +{ + return m_kind; +} + +label_text +test_logical_location::get_name_for_path_output () const +{ + return label_text::borrow (m_name); +} + +} // namespace selftest + +#endif /* #if CHECKING_P */ diff --git a/gcc/selftest-logical-location.h b/gcc/selftest-logical-location.h new file mode 100644 index 00000000000..819e111851e --- /dev/null +++ b/gcc/selftest-logical-location.h @@ -0,0 +1,58 @@ +/* Concrete subclass of logical_location for use in selftests. + Copyright (C) 2024 Free Software Foundation, Inc. + Contributed by David Malcolm . + +This file is part of GCC. + +GCC 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, or (at your option) any later +version. + +GCC 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 GCC; see the file COPYING3. If not see +. */ + +#ifndef GCC_SELFTEST_LOGICAL_LOCATION_H +#define GCC_SELFTEST_LOGICAL_LOCATION_H + +#include "logical-location.h" + +/* The selftest code should entirely disappear in a production + configuration, hence we guard all of it with #if CHECKING_P. */ + +#if CHECKING_P + +namespace selftest { + +/* Concrete subclass of logical_location for use in selftests. */ + +class test_logical_location : public logical_location +{ +public: + test_logical_location (enum logical_location_kind kind, + const char *name); + virtual const char *get_short_name () const final override; + virtual const char *get_name_with_scope () const final override; + virtual const char *get_internal_name () const final override; + virtual enum logical_location_kind get_kind () const final override; + virtual label_text get_name_for_path_output () const final override; + + const char *get_name () const { return m_name; } + + private: + enum logical_location_kind m_kind; + const char *m_name; +}; + +} // namespace selftest + +#endif /* #if CHECKING_P */ + + +#endif /* GCC_SELFTEST_LOGICAL_LOCATION_H. */ diff --git a/gcc/tree-diagnostic-path.cc b/gcc/tree-diagnostic-path.cc index 4287b90d5dd..39a85d33015 100644 --- a/gcc/tree-diagnostic-path.cc +++ b/gcc/tree-diagnostic-path.cc @@ -27,13 +27,9 @@ along with GCC; see the file COPYING3. If not see #include "coretypes.h" #include "tree.h" #include "diagnostic.h" -#include "tree-pretty-print.h" -#include "gimple-pretty-print.h" #include "tree-diagnostic.h" -#include "langhooks.h" #include "intl.h" #include "diagnostic-path.h" -#include "simple-diagnostic-path.h" #include "json.h" #include "gcc-rich-location.h" #include "diagnostic-color.h" @@ -41,6 +37,7 @@ along with GCC; see the file COPYING3. If not see #include "diagnostic-label-effects.h" #include "selftest.h" #include "selftest-diagnostic.h" +#include "selftest-diagnostic-path.h" #include "text-art/theme.h" /* Disable warnings about missing quoting in GCC diagnostics for the print @@ -1013,38 +1010,6 @@ path_events_have_column_data_p (const diagnostic_path &path) return true; } -/* A subclass of simple_diagnostic_path that adds member functions - for adding test events and suppresses translation of these events. */ - -class test_diagnostic_path : public simple_diagnostic_path -{ - public: - test_diagnostic_path (pretty_printer *event_pp) - : simple_diagnostic_path (event_pp) - { - disable_event_localization (); - } - - void add_entry (tree fndecl, int stack_depth) - { - add_event (UNKNOWN_LOCATION, fndecl, stack_depth, - "entering %qE", fndecl); - } - - void add_return (tree fndecl, int stack_depth) - { - add_event (UNKNOWN_LOCATION, fndecl, stack_depth, - "returning to %qE", fndecl); - } - - void add_call (tree caller, int caller_stack_depth, tree callee) - { - add_event (UNKNOWN_LOCATION, caller, caller_stack_depth, - "calling %qE", callee); - add_entry (callee, caller_stack_depth + 1); - } -}; - /* Verify that empty paths are handled gracefully. */ static void @@ -1067,13 +1032,10 @@ test_empty_path (pretty_printer *event_pp) static void test_intraprocedural_path (pretty_printer *event_pp) { - tree fntype_void_void - = build_function_type_array (void_type_node, 0, NULL); - tree fndecl_foo = build_fn_decl ("foo", fntype_void_void); - test_diagnostic_path path (event_pp); - path.add_event (UNKNOWN_LOCATION, fndecl_foo, 0, "first %qs", "free"); - path.add_event (UNKNOWN_LOCATION, fndecl_foo, 0, "double %qs", "free"); + const char *const funcname = "foo"; + path.add_event (UNKNOWN_LOCATION, funcname, 0, "first %qs", "free"); + path.add_event (UNKNOWN_LOCATION, funcname, 0, "double %qs", "free"); ASSERT_FALSE (path.interprocedural_p ()); @@ -1093,33 +1055,20 @@ test_intraprocedural_path (pretty_printer *event_pp) static void test_interprocedural_path_1 (pretty_printer *event_pp) { - /* Build fndecls. The types aren't quite right, but that - doesn't matter for the purposes of this test. */ - tree fntype_void_void - = build_function_type_array (void_type_node, 0, NULL); - tree fndecl_test = build_fn_decl ("test", fntype_void_void); - tree fndecl_make_boxed_int - = build_fn_decl ("make_boxed_int", fntype_void_void); - tree fndecl_wrapped_malloc - = build_fn_decl ("wrapped_malloc", fntype_void_void); - tree fndecl_free_boxed_int - = build_fn_decl ("free_boxed_int", fntype_void_void); - tree fndecl_wrapped_free - = build_fn_decl ("wrapped_free", fntype_void_void); - test_diagnostic_path path (event_pp); - path.add_entry (fndecl_test, 0); - path.add_call (fndecl_test, 0, fndecl_make_boxed_int); - path.add_call (fndecl_make_boxed_int, 1, fndecl_wrapped_malloc); - path.add_event (UNKNOWN_LOCATION, fndecl_wrapped_malloc, 2, "calling malloc"); - path.add_return (fndecl_test, 0); - path.add_call (fndecl_test, 0, fndecl_free_boxed_int); - path.add_call (fndecl_free_boxed_int, 1, fndecl_wrapped_free); - path.add_event (UNKNOWN_LOCATION, fndecl_wrapped_free, 2, "calling free"); - path.add_return (fndecl_test, 0); - path.add_call (fndecl_test, 0, fndecl_free_boxed_int); - path.add_call (fndecl_free_boxed_int, 1, fndecl_wrapped_free); - path.add_event (UNKNOWN_LOCATION, fndecl_wrapped_free, 2, "calling free"); + path.add_entry ("test", 0); + path.add_call ("test", 0, "make_boxed_int"); + path.add_call ("make_boxed_int", 1, "wrapped_malloc"); + path.add_event (UNKNOWN_LOCATION, + "wrapped_malloc", 2, "calling malloc"); + path.add_return ("test", 0); + path.add_call ("test", 0, "free_boxed_int"); + path.add_call ("free_boxed_int", 1, "wrapped_free"); + path.add_event (UNKNOWN_LOCATION, "wrapped_free", 2, "calling free"); + path.add_return ("test", 0); + path.add_call ("test", 0, "free_boxed_int"); + path.add_call ("free_boxed_int", 1, "wrapped_free"); + path.add_event (UNKNOWN_LOCATION, "wrapped_free", 2, "calling free"); ASSERT_EQ (path.num_events (), 18); ASSERT_TRUE (path.interprocedural_p ()); @@ -1248,20 +1197,12 @@ test_interprocedural_path_1 (pretty_printer *event_pp) static void test_interprocedural_path_2 (pretty_printer *event_pp) { - /* Build fndecls. The types aren't quite right, but that - doesn't matter for the purposes of this test. */ - tree fntype_void_void - = build_function_type_array (void_type_node, 0, NULL); - tree fndecl_foo = build_fn_decl ("foo", fntype_void_void); - tree fndecl_bar = build_fn_decl ("bar", fntype_void_void); - tree fndecl_baz = build_fn_decl ("baz", fntype_void_void); - test_diagnostic_path path (event_pp); - path.add_entry (fndecl_foo, 0); - path.add_call (fndecl_foo, 0, fndecl_bar); - path.add_call (fndecl_bar, 1, fndecl_baz); - path.add_return (fndecl_bar, 1); - path.add_call (fndecl_bar, 1, fndecl_baz); + path.add_entry ("foo", 0); + path.add_call ("foo", 0, "bar"); + path.add_call ("bar", 1, "baz"); + path.add_return ("bar", 1); + path.add_call ("bar", 1, "baz"); ASSERT_EQ (path.num_events (), 8); ASSERT_TRUE (path.interprocedural_p ()); @@ -1341,14 +1282,10 @@ test_interprocedural_path_2 (pretty_printer *event_pp) static void test_recursion (pretty_printer *event_pp) { - tree fntype_void_void - = build_function_type_array (void_type_node, 0, NULL); - tree fndecl_factorial = build_fn_decl ("factorial", fntype_void_void); - test_diagnostic_path path (event_pp); - path.add_entry (fndecl_factorial, 0); + path.add_entry ("factorial", 0); for (int depth = 0; depth < 3; depth++) - path.add_call (fndecl_factorial, depth, fndecl_factorial); + path.add_call ("factorial", depth, "factorial"); ASSERT_EQ (path.num_events (), 7); ASSERT_TRUE (path.interprocedural_p ()); @@ -1485,14 +1422,14 @@ test_control_flow_1 (const line_table_case &case_, const location_t cfg_dest = t.get_line_and_column (5, 10); test_diagnostic_path path (event_pp); - path.add_event (conditional, NULL_TREE, 0, + path.add_event (conditional, nullptr, 0, "following %qs branch (when %qs is NULL)...", "false", "p"); path.connect_to_next_event (); - path.add_event (cfg_dest, NULL_TREE, 0, + path.add_event (cfg_dest, nullptr, 0, "...to here"); - path.add_event (cfg_dest, NULL_TREE, 0, + path.add_event (cfg_dest, nullptr, 0, "dereference of NULL %qs", "p"); @@ -1665,17 +1602,17 @@ test_control_flow_2 (const line_table_case &case_, const location_t loop_body_end = t.get_line_and_columns (5, 5, 9, 17); test_diagnostic_path path (event_pp); - path.add_event (iter_test, NULL_TREE, 0, "infinite loop here"); + path.add_event (iter_test, nullptr, 0, "infinite loop here"); - path.add_event (iter_test, NULL_TREE, 0, "looping from here..."); + path.add_event (iter_test, nullptr, 0, "looping from here..."); path.connect_to_next_event (); - path.add_event (loop_body_start, NULL_TREE, 0, "...to here"); + path.add_event (loop_body_start, nullptr, 0, "...to here"); - path.add_event (loop_body_end, NULL_TREE, 0, "looping back..."); + path.add_event (loop_body_end, nullptr, 0, "looping back..."); path.connect_to_next_event (); - path.add_event (iter_test, NULL_TREE, 0, "...to here"); + path.add_event (iter_test, nullptr, 0, "...to here"); if (!path_events_have_column_data_p (path)) return; @@ -1751,17 +1688,17 @@ test_control_flow_3 (const line_table_case &case_, const location_t iter_next = t.get_line_and_columns (3, 22, 24); test_diagnostic_path path (event_pp); - path.add_event (iter_test, NULL_TREE, 0, "infinite loop here"); + path.add_event (iter_test, nullptr, 0, "infinite loop here"); - path.add_event (iter_test, NULL_TREE, 0, "looping from here..."); + path.add_event (iter_test, nullptr, 0, "looping from here..."); path.connect_to_next_event (); - path.add_event (iter_next, NULL_TREE, 0, "...to here"); + path.add_event (iter_next, nullptr, 0, "...to here"); - path.add_event (iter_next, NULL_TREE, 0, "looping back..."); + path.add_event (iter_next, nullptr, 0, "looping back..."); path.connect_to_next_event (); - path.add_event (iter_test, NULL_TREE, 0, "...to here"); + path.add_event (iter_test, nullptr, 0, "...to here"); if (!path_events_have_column_data_p (path)) return; @@ -1816,10 +1753,10 @@ assert_cfg_edge_path_streq (const location &loc, const char *expected_str) { test_diagnostic_path path (event_pp); - path.add_event (src_loc, NULL_TREE, 0, "from here..."); + path.add_event (src_loc, nullptr, 0, "from here..."); path.connect_to_next_event (); - path.add_event (dst_loc, NULL_TREE, 0, "...to here"); + path.add_event (dst_loc, nullptr, 0, "...to here"); if (!path_events_have_column_data_p (path)) return; @@ -2120,27 +2057,27 @@ test_control_flow_5 (const line_table_case &case_, test_diagnostic_path path (event_pp); /* (1) */ - path.add_event (t.get_line_and_column (1, 6), NULL_TREE, 0, + path.add_event (t.get_line_and_column (1, 6), nullptr, 0, "following %qs branch (when %qs is non-NULL)...", "false", "arr"); path.connect_to_next_event (); /* (2) */ - path.add_event (t.get_line_and_columns (4, 8, 10, 12), NULL_TREE, 0, + path.add_event (t.get_line_and_columns (4, 8, 10, 12), nullptr, 0, "...to here"); /* (3) */ - path.add_event (t.get_line_and_columns (4, 15, 17, 19), NULL_TREE, 0, + path.add_event (t.get_line_and_columns (4, 15, 17, 19), nullptr, 0, "following %qs branch (when %qs)...", "true", "i < n"); path.connect_to_next_event (); /* (4) */ - path.add_event (t.get_line_and_column (5, 13), NULL_TREE, 0, + path.add_event (t.get_line_and_column (5, 13), nullptr, 0, "...to here"); /* (5) */ - path.add_event (t.get_line_and_columns (5, 33, 58), NULL_TREE, 0, + path.add_event (t.get_line_and_columns (5, 33, 58), nullptr, 0, "allocated here"); if (!path_events_have_column_data_p (path)) @@ -2208,27 +2145,27 @@ test_control_flow_6 (const line_table_case &case_, test_diagnostic_path path (event_pp); /* (1) */ - path.add_event (t.get_line_and_columns (6, 25, 35), NULL_TREE, 0, + path.add_event (t.get_line_and_columns (6, 25, 35), nullptr, 0, "allocated here"); /* (2) */ - path.add_event (t.get_line_and_columns (8, 13, 14, 17), NULL_TREE, 0, + path.add_event (t.get_line_and_columns (8, 13, 14, 17), nullptr, 0, "following %qs branch (when %qs)...", "true", "i <= 254"); path.connect_to_next_event (); /* (3) */ - path.add_event (t.get_line_and_columns (9, 5, 15, 17), NULL_TREE, 0, + path.add_event (t.get_line_and_columns (9, 5, 15, 17), nullptr, 0, "...to here"); /* (4) */ - path.add_event (t.get_line_and_columns (8, 13, 14, 17), NULL_TREE, 0, + path.add_event (t.get_line_and_columns (8, 13, 14, 17), nullptr, 0, "following %qs branch (when %qs)...", "true", "i <= 254"); path.connect_to_next_event (); /* (5) */ - path.add_event (t.get_line_and_columns (9, 5, 15, 17), NULL_TREE, 0, + path.add_event (t.get_line_and_columns (9, 5, 15, 17), nullptr, 0, "...to here"); if (!path_events_have_column_data_p (path))