From patchwork Wed Aug 2 16:20:14 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Eric Feng X-Patchwork-Id: 129933 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:9f41:0:b0:3e4:2afc:c1 with SMTP id v1csp573266vqx; Wed, 2 Aug 2023 09:22:22 -0700 (PDT) X-Google-Smtp-Source: APBJJlGQbQUMO8rBgoTMiWaOS7smKkyiYZHuYFH2E5vJ1kDcggKHGNULnxbfeNecGe1C34r97lYF X-Received: by 2002:a17:906:3f1b:b0:99b:d0dc:7e68 with SMTP id c27-20020a1709063f1b00b0099bd0dc7e68mr4819268ejj.72.1690993342495; Wed, 02 Aug 2023 09:22:22 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1690993342; cv=none; d=google.com; s=arc-20160816; b=OmLY5L62o8ooRiNcVGRJXclbqv0xPkMRUgTi/4nPq1OWG+sRbautNRcvPr7ALKdifP G1thgraOI7Fj/yonGBrl8Edzlt5K7l8dxsohpQcZDI/9QQJNYhjOrngJ/k31huBpQgq0 mkdl5jUxurvSNWw5dP8+ikeG7BxcSsihTtEgbkCJjca/YWSKHVg3s/RkXwEoQg57jOkE pwtv7fCN0qSuGlJJ8EMEGx6908qoorFV9F1pO5QRsyROOimVk0h815Dv0569pvYCb8Hs 0qPwv8CTUIPo+rZ+vx7y9oHKPBC21K8L1VnAxi66al0inQHkdi3jyVROYULbiFtHa/pZ altw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:from:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:dmarc-filter:delivered-to :dkim-signature:dkim-filter; bh=/PbSsw+CS6InQbTId0A4n71EaQjmgHbr0sTdy19ZsqQ=; fh=HDoW+45ykAa9BWp/TI5sYzmA0EY2v68lQDnLdSdi1fA=; b=bDLl6LOM7yUnHxz6rKCX6eXhSiqXsEkT76NUVnvgVG+22fU6jtQLCWWLv4g1FmRYtu NoOau3pl8JBdGYq/XfeQjZd+A5NXp0CQXt68LnrgAf/kKMHaLVLcy+Qy6WuzGBx16JJ6 SIjqxmSQCICx4Vh1UeyrsTCONRw7mow+YooWCZM/nkD7VIBRtbmHfd/U3WsNOv5vnlOD 2MJLeZdibWSgUZsYoFFtLl8uD4foiQURY8yJ4Ftsuld+lgW0Y09PIuY8Ix3H8HTmcuW2 isIH+3fEGYbTKiaSI0JbsxHltXYatixiexnrmJE1TfxE9E7C349RfdHsDoDfha0zC4y0 jK8Q== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=RUeAqGDN; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from server2.sourceware.org (ip-8-43-85-97.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id o26-20020a1709062e9a00b0099454cbf77csi6607938eji.750.2023.08.02.09.22.22 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 02 Aug 2023 09:22:22 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) client-ip=8.43.85.97; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=RUeAqGDN; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 4C91F3858C54 for ; Wed, 2 Aug 2023 16:22:21 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 4C91F3858C54 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1690993341; bh=/PbSsw+CS6InQbTId0A4n71EaQjmgHbr0sTdy19ZsqQ=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=RUeAqGDNIu+inMUahaZyAYYUMvnpJ6HHsCVXTOlb7WboLUEnxUp3so/1Wy5ycBSKE 685ZdnBP4UyIHx1Din61vKhL2whorNhPNaU03UVT6hvnPCww+LlUQCSqdM7oYu9n6D /lYX4kdB+nP5WJnoBVPYeBvT6ktcChCPTXzO2YcU= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mx0b-00364e01.pphosted.com (mx0b-00364e01.pphosted.com [148.163.139.74]) by sourceware.org (Postfix) with ESMTPS id A12BF3858D20 for ; Wed, 2 Aug 2023 16:21:36 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org A12BF3858D20 Received: from pps.filterd (m0167077.ppops.net [127.0.0.1]) by mx0b-00364e01.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 372FWCl8006036 for ; Wed, 2 Aug 2023 12:21:36 -0400 Received: from mail-qk1-f197.google.com (mail-qk1-f197.google.com [209.85.222.197]) by mx0b-00364e01.pphosted.com (PPS) with ESMTPS id 3s7qpu1nh7-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Wed, 02 Aug 2023 12:21:35 -0400 Received: by mail-qk1-f197.google.com with SMTP id af79cd13be357-7656a0f8565so75133685a.1 for ; Wed, 02 Aug 2023 09:21:35 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1690993295; x=1691598095; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=/PbSsw+CS6InQbTId0A4n71EaQjmgHbr0sTdy19ZsqQ=; b=kLsa2B90isb7i7aLuDPy5FDbCrLeKhkzN2oJbdJlgLIIguqFppJktih8g0OAcn0O33 3FXjuHsXNNM2qm+Uqu42VUd4hj7S9p7TI2qH154F9VKih1YGolhXci2q1Yj8PomAp88h iu/muQQnNaG1uUeW8quCwUMoeHmgtrYOkBCehEKo2tbyq0h5tc6h9qa7L7+i2FldwSBw CSsAo/maDwiNXEkxXWCDVncT/ZNj8QOEcwb0mjdguyFWoAduWveDTAAbdVcjHwx5zk/T tGRJ+3MBpxPqEzteewxDW9nCMWPluCzTC6V65wm5alz+m8+FdjpVLVRcrZMf3iA1tvHR qdxw== X-Gm-Message-State: ABy/qLZfI3lo+XtbFXOok1X3DQo2Xp1iXvYzB5eKOoJCqDoAhh8sAL03 DV5QpJLKvGpC63+KXSvNuz+lGVylrMNCb0hvUOrOAP/HuO0Piq2QfKv8Vr3SW8cTGffc6bZbyEQ cpXxiOGCunsaHyWw= X-Received: by 2002:a05:620a:2902:b0:76c:cf97:51a4 with SMTP id m2-20020a05620a290200b0076ccf9751a4mr2980347qkp.18.1690993295162; Wed, 02 Aug 2023 09:21:35 -0700 (PDT) X-Received: by 2002:a05:620a:2902:b0:76c:cf97:51a4 with SMTP id m2-20020a05620a290200b0076ccf9751a4mr2980323qkp.18.1690993294691; Wed, 02 Aug 2023 09:21:34 -0700 (PDT) Received: from Ericcs-MBP.cable.rcn.com (207-38-164-63.s9254.c3-0.43d-cbr1.qens-43d.ny.cable.rcncustomer.com. [207.38.164.63]) by smtp.gmail.com with ESMTPSA id u11-20020a05622a17cb00b004053dc8365esm5379030qtk.23.2023.08.02.09.21.34 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Wed, 02 Aug 2023 09:21:34 -0700 (PDT) To: dmalcolm@redhat.com Cc: gcc-patches@gcc.gnu.org, joseph@codesourcery.com, polacek@redhat.com, Eric Feng Subject: [PATCH v2] analyzer: stash values for CPython plugin [PR107646] Date: Wed, 2 Aug 2023 12:20:14 -0400 Message-Id: <20230802162014.24756-1-ef2648@columbia.edu> X-Mailer: git-send-email 2.32.0 (Apple Git-132) In-Reply-To: References: MIME-Version: 1.0 X-Proofpoint-GUID: TQmbAI5mvrTxdlphzkETIq2Yq7h9H8Cl X-Proofpoint-ORIG-GUID: TQmbAI5mvrTxdlphzkETIq2Yq7h9H8Cl X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.957,Hydra:6.0.591,FMLib:17.11.176.26 definitions=2023-08-02_10,2023-08-01_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 malwarescore=0 mlxscore=0 phishscore=0 adultscore=0 mlxlogscore=999 impostorscore=10 clxscore=1015 priorityscore=1501 spamscore=0 suspectscore=0 bulkscore=10 lowpriorityscore=10 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2306200000 definitions=main-2308020129 X-Spam-Status: No, score=-11.0 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, 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.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Eric Feng via Gcc-patches From: Eric Feng Reply-To: Eric Feng Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org Sender: "Gcc-patches" X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1773035131353915662 X-GMAIL-MSGID: 1773135035300257950 Revised: -- Fix indentation problems -- Add more detail to Changelog -- Add new test on handling non-CPython code case -- Turn off debugging inform by default -- Make on_finish_translation_unit() static -- Remove superfluous null checks in init_py_structs() Changes have been bootstrapped and tested against trunk on aarch64-unknown-linux-gnu. --- This patch adds a hook to the end of ana::on_finish_translation_unit which calls relevant stashing-related callbacks registered during plugin initialization. This feature is used to stash named types and global variables for a CPython analyzer plugin [PR107646]. gcc/analyzer/ChangeLog: PR analyzer/107646 * analyzer-language.cc (run_callbacks): New function. (on_finish_translation_unit): New function. * analyzer-language.h (GCC_ANALYZER_LANGUAGE_H): New include. (class translation_unit): New vfuncs. gcc/c/ChangeLog: PR analyzer/107646 * c-parser.cc: New functions on stashing values for the analyzer. gcc/testsuite/ChangeLog: PR analyzer/107646 * gcc.dg/plugin/plugin.exp: Add new plugin and test. * gcc.dg/plugin/analyzer_cpython_plugin.c: New plugin. * gcc.dg/plugin/cpython-plugin-test-1.c: New test. Signed-off-by: Eric Feng --- gcc/analyzer/analyzer-language.cc | 22 ++ gcc/analyzer/analyzer-language.h | 9 + gcc/c/c-parser.cc | 26 ++ .../gcc.dg/plugin/analyzer_cpython_plugin.c | 230 ++++++++++++++++++ .../gcc.dg/plugin/cpython-plugin-test-1.c | 8 + gcc/testsuite/gcc.dg/plugin/plugin.exp | 2 + 6 files changed, 297 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/plugin/analyzer_cpython_plugin.c create mode 100644 gcc/testsuite/gcc.dg/plugin/cpython-plugin-test-1.c diff --git a/gcc/analyzer/analyzer-language.cc b/gcc/analyzer/analyzer-language.cc index 2c8910906ee..85400288a93 100644 --- a/gcc/analyzer/analyzer-language.cc +++ b/gcc/analyzer/analyzer-language.cc @@ -35,6 +35,26 @@ static GTY (()) hash_map *analyzer_stashed_constants; #if ENABLE_ANALYZER namespace ana { +static vec + *finish_translation_unit_callbacks; + +void +register_finish_translation_unit_callback ( + finish_translation_unit_callback callback) +{ + if (!finish_translation_unit_callbacks) + vec_alloc (finish_translation_unit_callbacks, 1); + finish_translation_unit_callbacks->safe_push (callback); +} + +static void +run_callbacks (logger *logger, const translation_unit &tu) +{ + for (auto const &cb : finish_translation_unit_callbacks) + { + cb (logger, tu); + } +} /* Call into TU to try to find a value for NAME. If found, stash its value within analyzer_stashed_constants. */ @@ -102,6 +122,8 @@ on_finish_translation_unit (const translation_unit &tu) the_logger.set_logger (new logger (logfile, 0, 0, *global_dc->printer)); stash_named_constants (the_logger.get_logger (), tu); + + run_callbacks (the_logger.get_logger (), tu); } /* Lookup NAME in the named constants stashed when the frontend TU finished. diff --git a/gcc/analyzer/analyzer-language.h b/gcc/analyzer/analyzer-language.h index 00f85aba041..8deea52d627 100644 --- a/gcc/analyzer/analyzer-language.h +++ b/gcc/analyzer/analyzer-language.h @@ -21,6 +21,8 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_ANALYZER_LANGUAGE_H #define GCC_ANALYZER_LANGUAGE_H +#include "analyzer/analyzer-logging.h" + #if ENABLE_ANALYZER namespace ana { @@ -35,8 +37,15 @@ class translation_unit have been seen). If it is defined and an integer (e.g. either as a macro or enum), return the INTEGER_CST value, otherwise return NULL. */ virtual tree lookup_constant_by_id (tree id) const = 0; + virtual tree lookup_type_by_id (tree id) const = 0; + virtual tree lookup_global_var_by_id (tree id) const = 0; }; +typedef void (*finish_translation_unit_callback) + (logger *, const translation_unit &); +void register_finish_translation_unit_callback ( + finish_translation_unit_callback callback); + /* Analyzer hook for frontends to call at the end of the TU. */ void on_finish_translation_unit (const translation_unit &tu); diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc index cf82b0306d1..617111b0f0a 100644 --- a/gcc/c/c-parser.cc +++ b/gcc/c/c-parser.cc @@ -1695,6 +1695,32 @@ public: return NULL_TREE; } + tree + lookup_type_by_id (tree id) const final override + { + if (tree type_decl = lookup_name (id)) + { + if (TREE_CODE (type_decl) == TYPE_DECL) + { + tree record_type = TREE_TYPE (type_decl); + if (TREE_CODE (record_type) == RECORD_TYPE) + return record_type; + } + } + + return NULL_TREE; + } + + tree + lookup_global_var_by_id (tree id) const final override + { + if (tree var_decl = lookup_name (id)) + if (TREE_CODE (var_decl) == VAR_DECL) + return var_decl; + + return NULL_TREE; + } + private: /* Attempt to get an INTEGER_CST from MACRO. Only handle the simplest cases: where MACRO's definition is a single diff --git a/gcc/testsuite/gcc.dg/plugin/analyzer_cpython_plugin.c b/gcc/testsuite/gcc.dg/plugin/analyzer_cpython_plugin.c new file mode 100644 index 00000000000..72375cfd879 --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/analyzer_cpython_plugin.c @@ -0,0 +1,230 @@ +/* -fanalyzer plugin for CPython extension modules */ +/* { dg-options "-g" } */ + +#define INCLUDE_MEMORY +#include "gcc-plugin.h" +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tree.h" +#include "function.h" +#include "basic-block.h" +#include "gimple.h" +#include "gimple-iterator.h" +#include "diagnostic-core.h" +#include "graphviz.h" +#include "options.h" +#include "cgraph.h" +#include "tree-dfa.h" +#include "stringpool.h" +#include "convert.h" +#include "target.h" +#include "fold-const.h" +#include "tree-pretty-print.h" +#include "diagnostic-color.h" +#include "diagnostic-metadata.h" +#include "tristate.h" +#include "bitmap.h" +#include "selftest.h" +#include "function.h" +#include "json.h" +#include "analyzer/analyzer.h" +#include "analyzer/analyzer-language.h" +#include "analyzer/analyzer-logging.h" +#include "ordered-hash-map.h" +#include "options.h" +#include "cgraph.h" +#include "cfg.h" +#include "digraph.h" +#include "analyzer/supergraph.h" +#include "sbitmap.h" +#include "analyzer/call-string.h" +#include "analyzer/program-point.h" +#include "analyzer/store.h" +#include "analyzer/region-model.h" +#include "analyzer/call-details.h" +#include "analyzer/call-info.h" +#include "make-unique.h" + +int plugin_is_GPL_compatible; + +#if ENABLE_ANALYZER +static GTY (()) hash_map *analyzer_stashed_types; +static GTY (()) hash_map *analyzer_stashed_globals; + +namespace ana +{ +static tree pyobj_record = NULL_TREE; +static tree varobj_record = NULL_TREE; +static tree pylistobj_record = NULL_TREE; +static tree pylongobj_record = NULL_TREE; +static tree pylongtype_vardecl = NULL_TREE; +static tree pylisttype_vardecl = NULL_TREE; + +static tree +get_field_by_name (tree type, const char *name) +{ + for (tree field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) + { + if (TREE_CODE (field) == FIELD_DECL) + { + const char *field_name = IDENTIFIER_POINTER (DECL_NAME (field)); + if (strcmp (field_name, name) == 0) + return field; + } + } + return NULL_TREE; +} + +static void +maybe_stash_named_type (logger *logger, const translation_unit &tu, + const char *name) +{ + LOG_FUNC_1 (logger, "name: %qs", name); + if (!analyzer_stashed_types) + analyzer_stashed_types = hash_map::create_ggc (); + + tree id = get_identifier (name); + if (tree t = tu.lookup_type_by_id (id)) + { + gcc_assert (TREE_CODE (t) == RECORD_TYPE); + analyzer_stashed_types->put (id, t); + if (logger) + logger->log ("found %qs: %qE", name, t); + } + else + { + if (logger) + logger->log ("%qs: not found", name); + } +} + +static void +maybe_stash_global_var (logger *logger, const translation_unit &tu, + const char *name) +{ + LOG_FUNC_1 (logger, "name: %qs", name); + if (!analyzer_stashed_globals) + analyzer_stashed_globals = hash_map::create_ggc (); + + tree id = get_identifier (name); + if (tree t = tu.lookup_global_var_by_id (id)) + { + gcc_assert (TREE_CODE (t) == VAR_DECL); + analyzer_stashed_globals->put (id, t); + if (logger) + logger->log ("found %qs: %qE", name, t); + } + else + { + if (logger) + logger->log ("%qs: not found", name); + } +} + +static void +stash_named_types (logger *logger, const translation_unit &tu) +{ + LOG_SCOPE (logger); + + maybe_stash_named_type (logger, tu, "PyObject"); + maybe_stash_named_type (logger, tu, "PyListObject"); + maybe_stash_named_type (logger, tu, "PyVarObject"); + maybe_stash_named_type (logger, tu, "PyLongObject"); +} + +static void +stash_global_vars (logger *logger, const translation_unit &tu) +{ + LOG_SCOPE (logger); + + maybe_stash_global_var (logger, tu, "PyLong_Type"); + maybe_stash_global_var (logger, tu, "PyList_Type"); +} + +static tree +get_stashed_type_by_name (const char *name) +{ + if (!analyzer_stashed_types) + return NULL_TREE; + tree id = get_identifier (name); + if (tree *slot = analyzer_stashed_types->get (id)) + { + gcc_assert (TREE_CODE (*slot) == RECORD_TYPE); + return *slot; + } + return NULL_TREE; +} + +static tree +get_stashed_global_var_by_name (const char *name) +{ + if (!analyzer_stashed_globals) + return NULL_TREE; + tree id = get_identifier (name); + if (tree *slot = analyzer_stashed_globals->get (id)) + { + gcc_assert (TREE_CODE (*slot) == VAR_DECL); + return *slot; + } + return NULL_TREE; +} + +static void +init_py_structs () +{ + pyobj_record = get_stashed_type_by_name ("PyObject"); + varobj_record = get_stashed_type_by_name ("PyVarObject"); + pylistobj_record = get_stashed_type_by_name ("PyListObject"); + pylongobj_record = get_stashed_type_by_name ("PyLongObject"); + pylongtype_vardecl = get_stashed_global_var_by_name ("PyLong_Type"); + pylisttype_vardecl = get_stashed_global_var_by_name ("PyList_Type"); +} + +void +sorry_no_cpython_plugin () +{ + sorry ("%qs definitions not found." + " Please ensure to %qs. Exiting.)", + "Python/C API", "#include "); +} + +static void +cpython_analyzer_init_cb (void *gcc_data, void * /*user_data */) +{ + ana::plugin_analyzer_init_iface *iface + = (ana::plugin_analyzer_init_iface *)gcc_data; + LOG_SCOPE (iface->get_logger ()); + if (0) + inform (input_location, "got here: cpython_analyzer_init_cb"); + + init_py_structs (); + + if (pyobj_record == NULL_TREE) + { + sorry_no_cpython_plugin (); + return; + } +} +} // namespace ana + +#endif /* #if ENABLE_ANALYZER */ + +int +plugin_init (struct plugin_name_args *plugin_info, + struct plugin_gcc_version *version) +{ +#if ENABLE_ANALYZER + const char *plugin_name = plugin_info->base_name; + if (0) + inform (input_location, "got here; %qs", plugin_name); + ana::register_finish_translation_unit_callback (&stash_named_types); + ana::register_finish_translation_unit_callback (&stash_global_vars); + register_callback (plugin_info->base_name, PLUGIN_ANALYZER_INIT, + ana::cpython_analyzer_init_cb, + NULL); /* void *user_data */ +#else + sorry_no_analyzer (); +#endif + return 0; +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/plugin/cpython-plugin-test-1.c b/gcc/testsuite/gcc.dg/plugin/cpython-plugin-test-1.c new file mode 100644 index 00000000000..30f17355711 --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/cpython-plugin-test-1.c @@ -0,0 +1,8 @@ +/* { dg-do compile } */ +/* { dg-options "-fanalyzer" } */ +/* { dg-require-effective-target analyzer } */ +/* { dg-message "'Python/C API' definitions not found. Please ensure to '#include '. Exiting." "" { target *-*-* } 0 } */ + +void test_no_python_plugin () +{ +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/plugin/plugin.exp b/gcc/testsuite/gcc.dg/plugin/plugin.exp index 60723a20eda..09c45394b1f 100644 --- a/gcc/testsuite/gcc.dg/plugin/plugin.exp +++ b/gcc/testsuite/gcc.dg/plugin/plugin.exp @@ -160,6 +160,8 @@ set plugin_test_list [list \ taint-CVE-2011-0521-5-fixed.c \ taint-CVE-2011-0521-6.c \ taint-antipatterns-1.c } \ + { analyzer_cpython_plugin.c \ + cpython-plugin-test-1.c } \ ] foreach plugin_test $plugin_test_list {