From patchwork Wed Apr 22 18:39:58 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Belinassi X-Patchwork-Id: 1275366 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=8.43.85.97; helo=sourceware.org; envelope-from=gcc-patches-bounces@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=gcc.gnu.org Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=LbDnVaOc; dkim-atps=neutral Received: from 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 RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 496q4F6j1hz9sPF for ; Thu, 23 Apr 2020 04:40:11 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 66EE7394742E; Wed, 22 Apr 2020 18:40:08 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 66EE7394742E DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1587580808; bh=uWoDkK6/K27JS0mOePgGGyleLhvQyYPevhkxAwr2tSQ=; h=Date:To:Subject:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=LbDnVaOcB4zGTCynDFGF+WQpZGaG7KQTqOaBYbC++VJqfquO/qTTS1rUKde07WWyb lwn5VUvdSoLWy6thVbQSwfUbR56Vxknw0xbNExBikv1YBEfnmSWNOMA9pYoIKu9vjF G21hK4/LrC94n3Ljog2vJydbP0/I/6hkRD/yx0mU= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-qt1-x831.google.com (mail-qt1-x831.google.com [IPv6:2607:f8b0:4864:20::831]) by sourceware.org (Postfix) with ESMTPS id 8A4FA3858D33 for ; Wed, 22 Apr 2020 18:40:03 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 8A4FA3858D33 Received: by mail-qt1-x831.google.com with SMTP id 92so2590299qtg.0 for ; Wed, 22 Apr 2020 11:40:03 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:mime-version :content-disposition; bh=uWoDkK6/K27JS0mOePgGGyleLhvQyYPevhkxAwr2tSQ=; b=tdc3m8pX+51YPesBC32UzBV+/M18YjTWDOyVpxCqSqrbFZkpjmVlS0ta6WOOnx3rhS W4NyIzrWySdpmJDpgqsrLR9ai/gSB2rTbHG+syOq+rzk8YxO/BijuL3TgFKTihjk9avi /8FEcseRyq1B2aFNpdGM+wIOC0eJNPeXZos6O2mxvOiNZRqShj2rsaKgM7niVIds6RG5 AkSQ3PXhlfr6j1IJy6CEUQeF9zi8JI9WSurj3UIk2Wer86ChrLOavLvaRResVd0IjVVL NJluDyoCdQW5qli0VLLeUuUdJsTkOKnkixj9rIZCeQdC0401KR/YC2gm355bVHBs5Np3 8HNQ== X-Gm-Message-State: AGi0PuYAvTKWoqMJNEksl9jR2lZeGUQn9cuWNMe4PplE+pyHpho6Pj+Z EsYX6MYAVZEhr5zQzrl1OQZebv8/7Ig= X-Google-Smtp-Source: APiQypICaEGVdsoIvLpRQUXhwd0Nd6JIlYwYpWJFdwq3c8g6HGL7tIcXRs3jnxUMYtT9sJt0AWqRLA== X-Received: by 2002:ac8:4650:: with SMTP id f16mr2741295qto.168.1587580802515; Wed, 22 Apr 2020 11:40:02 -0700 (PDT) Received: from smtp.gmail.com ([2804:14d:90a6:82e9:ead0:fcff:fee1:3ed1]) by smtp.gmail.com with ESMTPSA id z2sm4404149qkc.28.2020.04.22.11.40.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 22 Apr 2020 11:40:01 -0700 (PDT) Date: Wed, 22 Apr 2020 15:39:58 -0300 To: gcc-patches@gcc.gnu.org Subject: [PATCH] [Stage1] Refactor tree-ssa-operands.c Message-ID: <20200422183958.tbdu77enaazwpqxx@smtp.gmail.com> MIME-Version: 1.0 Content-Disposition: inline X-Spam-Status: No, score=-24.0 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) 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: Giuliano Belinassi via Gcc-patches From: Giuliano Belinassi Reply-To: Giuliano Belinassi Errors-To: gcc-patches-bounces@gcc.gnu.org Sender: "Gcc-patches" This patch refactors tree-ssa-operands.c by wrapping the global variables into a class, and also removes unused code. Just sending this for when Stage1 is back again. I ran the testsuite and bootstraped in a x86_64 linux machine and found no issues. gcc/ChangeLog: 2020-04-22 Giuliano Belinassi * tree-ssa-operands.c (build_virtual_operands): New class. (operands_bitmap_obstack): Remove. (n_initialized): Remove. (build_uses): Move to build_virtual_operands class. (build_vuse): Same as above. (build_vdef): Same as above. (verify_ssa_operands): Same as above. (finalize_ssa_uses): Same as above. (cleanup_build_arrays): Same as above. (finalize_ssa_stmt_operands): Same as above. (start_ssa_stmt_operands): Same as above. (append_use): Same as above. (append_vdef): Same as above. (add_virtual_operand): Same as above. (add_stmt_operand): Same as above. (get_mem_ref_operands): Same as above. (get_tmr_operands): Same as above. (maybe_add_call_vops): Same as above. (get_asm_stmt_operands): Same as above. (get_expr_operands): Same as above. (parse_ssa_operands): Same as above. (finalize_ssa_defs): Same as above. (build_ssa_operands): Same as above, plus create a C-like wrapper. (update_stmt_operands): Create an instance of build_virtual_operands. From b860b39045e1b90319caa7c75ad189514e4a5641 Mon Sep 17 00:00:00 2001 From: Giuliano Belinassi Date: Tue, 21 Apr 2020 19:38:37 -0300 Subject: [PATCH] [Stage1] Refactor tree-ssa-operands.c Refactor tree-ssa-operands.c by wrapping the global variables into a class, and also removes unused code. gcc/ChangeLog: 2020-04-22 Giuliano Belinassi * tree-ssa-operands.c (build_virtual_operands): New class. (operands_bitmap_obstack): Remove. (n_initialized): Remove. (build_uses): Move to build_virtual_operands class. (build_vuse): Same as above. (build_vdef): Same as above. (verify_ssa_operands): Same as above. (finalize_ssa_uses): Same as above. (cleanup_build_arrays): Same as above. (finalize_ssa_stmt_operands): Same as above. (start_ssa_stmt_operands): Same as above. (append_use): Same as above. (append_vdef): Same as above. (add_virtual_operand): Same as above. (add_stmt_operand): Same as above. (get_mem_ref_operands): Same as above. (get_tmr_operands): Same as above. (maybe_add_call_vops): Same as above. (get_asm_stmt_operands): Same as above. (get_expr_operands): Same as above. (parse_ssa_operands): Same as above. (finalize_ssa_defs): Same as above. (build_ssa_operands): Same as above, plus create a C-like wrapper. (update_stmt_operands): Create an instance of build_virtual_operands. --- gcc/tree-ssa-operands.c | 218 +++++++++++++++++++++++++++------------- 1 file changed, 150 insertions(+), 68 deletions(-) diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c index b525ee318a4..ae8734d17e2 100644 --- a/gcc/tree-ssa-operands.c +++ b/gcc/tree-ssa-operands.c @@ -99,23 +99,111 @@ along with GCC; see the file COPYING3. If not see /* Operand is having its address taken. */ #define opf_address_taken (1 << 5) -/* Array for building all the use operands. */ -static vec build_uses; +/* Class containing temporary per-stmt state. */ -/* The built VDEF operand. */ -static tree build_vdef; +class build_virtual_operands +{ + public: + build_virtual_operands () + { + build_uses.create (10); + build_vuse = NULL_TREE; + build_vdef = NULL_TREE; + } + + ~build_virtual_operands () + { + cleanup_build_arrays (); + build_uses.release (); + } + + /* Create an operands cache for STMT. */ + void build_ssa_operands (struct function *fn, gimple *stmt); + + /* Verifies SSA statement operands. */ + DEBUG_FUNCTION bool verify_ssa_operands (struct function *fn, gimple *stmt); + + private: + /* Array for building all the use operands. */ + vec build_uses; + + /* The built VDEF operand. */ + tree build_vdef; + + /* The built VUSE operand. */ + tree build_vuse; + + /* Takes elements from build_uses and turns them into use operands of STMT. */ + inline void finalize_ssa_uses (struct function *fn, gimple *stmt); + + /* Clear the in_list bits and empty the build array for VDEFs and + VUSEs. */ + inline void cleanup_build_arrays (void); + + /* Finalize all the build vectors, fill the new ones into INFO. */ + inline void finalize_ssa_stmt_operands (struct function *fn, gimple *stmt); + + /* Start the process of building up operands vectors in INFO. */ + inline void start_ssa_stmt_operands (void); + + /* Add USE_P to the list of pointers to operands. */ + inline void append_use (tree *use_p); -/* The built VUSE operand. */ -static tree build_vuse; + /* Add VAR to the set of variables that require a VDEF operator. */ + inline void append_vdef (tree var); -/* Bitmap obstack for our datastructures that needs to survive across - compilations of multiple functions. */ -static bitmap_obstack operands_bitmap_obstack; + /* Add VAR to the set of variables that require a VUSE operator. */ + inline void append_vuse (tree var); -static void get_expr_operands (struct function *, gimple *, tree *, int); + /* Add virtual operands for STMT. FLAGS is as in get_expr_operands. */ + void add_virtual_operand (struct function *fn, gimple *stmt ATTRIBUTE_UNUSED, + int flags); -/* Number of functions with initialized ssa_operands. */ -static int n_initialized = 0; + + /* Add *VAR_P to the appropriate operand array for statement STMT. + FLAGS is as in get_expr_operands. If *VAR_P is a GIMPLE register, + it will be added to the statement's real operands, otherwise it is + added to virtual operands. */ + void add_stmt_operand (struct function *fn, tree *var_p, gimple *stmt, + int flags); + + /* A subroutine of get_expr_operands to handle MEM_REF. + + STMT is the statement being processed, EXPR is the MEM_REF + that got us here. + + FLAGS is as in get_expr_operands. */ + void get_mem_ref_operands (struct function *fn, gimple *stmt, tree expr, + int flags); + + /* A subroutine of get_expr_operands to handle TARGET_MEM_REF. */ + void get_tmr_operands (struct function *fn, gimple *stmt, tree expr, + int flags); + + + /* If STMT is a call that may clobber globals and other symbols that + escape, add them to the VDEF/VUSE lists for it. */ + void maybe_add_call_vops (struct function *fn, gcall *stmt); + + /* Scan operands in the ASM_EXPR stmt referred to in INFO. */ + void get_asm_stmt_operands (struct function *fn, gasm *stmt); + + + /* Recursively scan the expression pointed to by EXPR_P in statement + STMT. FLAGS is one of the OPF_* constants modifying how to + interpret the operands found. */ + void get_expr_operands (struct function *fn, gimple *stmt, tree *expr_p, + int flags); + + /* Parse STMT looking for operands. When finished, the various + build_* operand vectors will have potential operands in them. */ + void parse_ssa_operands (struct function *fn, gimple *stmt); + + + /* Takes elements from build_defs and turns them into def operands of STMT. + TODO -- Make build_defs vec of tree *. */ + inline void finalize_ssa_defs (struct function *fn, gimple *stmt); +}; /* Accessor to tree-ssa-operands.c caches. */ static inline struct ssa_operands * @@ -181,14 +269,6 @@ create_vop_var (struct function *fn) void init_ssa_operands (struct function *fn) { - if (!n_initialized++) - { - build_uses.create (10); - build_vuse = NULL_TREE; - build_vdef = NULL_TREE; - bitmap_obstack_initialize (&operands_bitmap_obstack); - } - gcc_assert (gimple_ssa_operands (fn)->operand_memory == NULL); gimple_ssa_operands (fn)->operand_memory_index = gimple_ssa_operands (fn)->ssa_operand_mem_size; @@ -205,13 +285,6 @@ fini_ssa_operands (struct function *fn) { struct ssa_operand_memory_d *ptr; - if (!--n_initialized) - { - build_uses.release (); - build_vdef = NULL_TREE; - build_vuse = NULL_TREE; - } - gimple_ssa_operands (fn)->free_uses = NULL; while ((ptr = gimple_ssa_operands (fn)->operand_memory) != NULL) @@ -223,9 +296,6 @@ fini_ssa_operands (struct function *fn) gimple_ssa_operands (fn)->ops_active = false; - if (!n_initialized) - bitmap_obstack_release (&operands_bitmap_obstack); - fn->gimple_df->vop = NULL_TREE; } @@ -315,8 +385,8 @@ add_use_op (struct function *fn, gimple *stmt, tree *op, use_optype_p last) /* Takes elements from build_defs and turns them into def operands of STMT. TODO -- Make build_defs vec of tree *. */ -static inline void -finalize_ssa_defs (struct function *fn, gimple *stmt) +inline void +build_virtual_operands::finalize_ssa_defs (struct function *fn, gimple *stmt) { /* Pre-pend the vdef we may have built. */ if (build_vdef != NULL_TREE) @@ -353,8 +423,8 @@ finalize_ssa_defs (struct function *fn, gimple *stmt) /* Takes elements from build_uses and turns them into use operands of STMT. */ -static inline void -finalize_ssa_uses (struct function *fn, gimple *stmt) +inline void +build_virtual_operands::finalize_ssa_uses (struct function *fn, gimple *stmt) { unsigned new_i; struct use_optype_d new_list; @@ -418,8 +488,8 @@ finalize_ssa_uses (struct function *fn, gimple *stmt) /* Clear the in_list bits and empty the build array for VDEFs and VUSEs. */ -static inline void -cleanup_build_arrays (void) +inline void +build_virtual_operands::cleanup_build_arrays (void) { build_vdef = NULL_TREE; build_vuse = NULL_TREE; @@ -429,8 +499,8 @@ cleanup_build_arrays (void) /* Finalize all the build vectors, fill the new ones into INFO. */ -static inline void -finalize_ssa_stmt_operands (struct function *fn, gimple *stmt) +inline void +build_virtual_operands::finalize_ssa_stmt_operands (struct function *fn, gimple *stmt) { finalize_ssa_defs (fn, stmt); finalize_ssa_uses (fn, stmt); @@ -440,8 +510,8 @@ finalize_ssa_stmt_operands (struct function *fn, gimple *stmt) /* Start the process of building up operands vectors in INFO. */ -static inline void -start_ssa_stmt_operands (void) +inline void +build_virtual_operands::start_ssa_stmt_operands (void) { gcc_assert (build_uses.length () == 0); gcc_assert (build_vuse == NULL_TREE); @@ -451,8 +521,8 @@ start_ssa_stmt_operands (void) /* Add USE_P to the list of pointers to operands. */ -static inline void -append_use (tree *use_p) +inline void +build_virtual_operands::append_use (tree *use_p) { build_uses.safe_push (use_p); } @@ -460,8 +530,8 @@ append_use (tree *use_p) /* Add VAR to the set of variables that require a VDEF operator. */ -static inline void -append_vdef (tree var) +inline void +build_virtual_operands::append_vdef (tree var) { gcc_assert ((build_vdef == NULL_TREE || build_vdef == var) @@ -475,8 +545,8 @@ append_vdef (tree var) /* Add VAR to the set of variables that require a VUSE operator. */ -static inline void -append_vuse (tree var) +inline void +build_virtual_operands::append_vuse (tree var) { gcc_assert (build_vuse == NULL_TREE || build_vuse == var); @@ -486,9 +556,10 @@ append_vuse (tree var) /* Add virtual operands for STMT. FLAGS is as in get_expr_operands. */ -static void -add_virtual_operand (struct function *fn, - gimple *stmt ATTRIBUTE_UNUSED, int flags) +void +build_virtual_operands::add_virtual_operand (struct function *fn, + gimple *stmt ATTRIBUTE_UNUSED, + int flags) { /* Add virtual operands to the stmt, unless the caller has specifically requested not to do that (used when adding operands inside an @@ -510,8 +581,9 @@ add_virtual_operand (struct function *fn, it will be added to the statement's real operands, otherwise it is added to virtual operands. */ -static void -add_stmt_operand (struct function *fn, tree *var_p, gimple *stmt, int flags) +void +build_virtual_operands::add_stmt_operand (struct function *fn, tree *var_p, + gimple *stmt, int flags) { tree var = *var_p; @@ -576,9 +648,9 @@ mark_address_taken (tree ref) FLAGS is as in get_expr_operands. */ -static void -get_mem_ref_operands (struct function *fn, - gimple *stmt, tree expr, int flags) +void +build_virtual_operands::get_mem_ref_operands (struct function *fn, + gimple *stmt, tree expr, int flags) { tree *pptr = &TREE_OPERAND (expr, 0); @@ -598,8 +670,9 @@ get_mem_ref_operands (struct function *fn, /* A subroutine of get_expr_operands to handle TARGET_MEM_REF. */ -static void -get_tmr_operands (struct function *fn, gimple *stmt, tree expr, int flags) +void +build_virtual_operands::get_tmr_operands (struct function *fn, gimple *stmt, + tree expr, int flags) { if (!(flags & opf_no_vops) && TREE_THIS_VOLATILE (expr)) @@ -620,8 +693,8 @@ get_tmr_operands (struct function *fn, gimple *stmt, tree expr, int flags) /* If STMT is a call that may clobber globals and other symbols that escape, add them to the VDEF/VUSE lists for it. */ -static void -maybe_add_call_vops (struct function *fn, gcall *stmt) +void +build_virtual_operands::maybe_add_call_vops (struct function *fn, gcall *stmt) { int call_flags = gimple_call_flags (stmt); @@ -641,8 +714,8 @@ maybe_add_call_vops (struct function *fn, gcall *stmt) /* Scan operands in the ASM_EXPR stmt referred to in INFO. */ -static void -get_asm_stmt_operands (struct function *fn, gasm *stmt) +void +build_virtual_operands::get_asm_stmt_operands (struct function *fn, gasm *stmt) { size_t i, noutputs; const char **oconstraints; @@ -699,8 +772,9 @@ get_asm_stmt_operands (struct function *fn, gasm *stmt) STMT. FLAGS is one of the OPF_* constants modifying how to interpret the operands found. */ -static void -get_expr_operands (struct function *fn, gimple *stmt, tree *expr_p, int flags) +void +build_virtual_operands::get_expr_operands (struct function *fn, gimple *stmt, + tree *expr_p, int flags) { enum tree_code code; enum tree_code_class codeclass; @@ -889,8 +963,8 @@ get_expr_operands (struct function *fn, gimple *stmt, tree *expr_p, int flags) /* Parse STMT looking for operands. When finished, the various build_* operand vectors will have potential operands in them. */ -static void -parse_ssa_operands (struct function *fn, gimple *stmt) +void +build_virtual_operands::parse_ssa_operands (struct function *fn, gimple *stmt) { enum gimple_code code = gimple_code (stmt); size_t i, n, start = 0; @@ -939,8 +1013,8 @@ parse_ssa_operands (struct function *fn, gimple *stmt) /* Create an operands cache for STMT. */ -static void -build_ssa_operands (struct function *fn, gimple *stmt) +void +build_virtual_operands::build_ssa_operands (struct function *fn, gimple *stmt) { /* Initially assume that the statement has no volatile operands. */ gimple_set_has_volatile_ops (stmt, false); @@ -953,7 +1027,7 @@ build_ssa_operands (struct function *fn, gimple *stmt) /* Verifies SSA statement operands. */ DEBUG_FUNCTION bool -verify_ssa_operands (struct function *fn, gimple *stmt) +build_virtual_operands::verify_ssa_operands (struct function *fn, gimple *stmt) { use_operand_p use_p; def_operand_p def_p; @@ -1040,6 +1114,14 @@ verify_ssa_operands (struct function *fn, gimple *stmt) return false; } +/* Interface for external use. */ + +DEBUG_FUNCTION bool +verify_ssa_operands (struct function *fn, gimple *stmt) +{ + return build_virtual_operands ().verify_ssa_operands (fn, stmt); +} + /* Releases the operands of STMT back to their freelists, and clears the stmt operand lists. */ @@ -1080,7 +1162,7 @@ update_stmt_operands (struct function *fn, gimple *stmt) timevar_push (TV_TREE_OPS); gcc_assert (gimple_modified_p (stmt)); - build_ssa_operands (fn, stmt); + build_virtual_operands ().build_ssa_operands (fn, stmt); gimple_set_modified (stmt, false); timevar_pop (TV_TREE_OPS); -- 2.26.2