From patchwork Thu Jul 27 12:39:53 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 108831 Delivered-To: patch@linaro.org Received: by 10.140.101.44 with SMTP id t41csp1987521qge; Thu, 27 Jul 2017 05:40:20 -0700 (PDT) X-Received: by 10.84.231.15 with SMTP id f15mr4413489plk.253.1501159220657; Thu, 27 Jul 2017 05:40:20 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1501159220; cv=none; d=google.com; s=arc-20160816; b=qjO1l4wDKkKoyYJF+W7AifAJxbyj5b5u/azDwujDZBpF+ZE4fgxTWIBAnbXzYNcYDU sUAh4VeyF5CHt1upni2svQipuBe9fEMX6lIb/rSqm37yjvrSROOOIzQfePWbqCMIhpCh y/bUt8cP4KEU733PqI5Ctme6/y3wpB62ol5PBDjkprJvTgMcJF9wMlgdPyMFlPKpzEKX e9VoiO493hfvR9Vu4VlywBG8JjJU+KXdUtvE2oKbdG7rWneX8p32FhW+kp64caTtm7XB CEu754URCOVwdrhd9Mgp1EJXu58LRjJYCoTiQnSOg5mhljjNhitNcX0GkouDW7ErE8a2 jOeQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=mime-version:user-agent:message-id:date:subject:mail-followup-to:to :from:delivered-to:sender:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:mailing-list:dkim-signature :domainkey-signature:arc-authentication-results; bh=BGISj0TwLt1Mr4Dtsoff8s7K1ztiPbuuHwbfZJ5/fmI=; b=JiBopZAanWTbZptivpsABWblB5Ms81IogqN7t6ZK28bU3l6Y/5ju+bvj4AYATQ87EF Du34DfkrkAt2Jzum0TdZovyGbTvP0zQTFKG2ddjN5t/D9qtCSCEi4geZGpT2w83wTEUb 1zLQEFOeCqhW54QUe8iz0CIMFNRxbkC+P4mr88T+pHoISSmD+Alh09whDIS2ayKk4o9a OtPVvenrNFYhxO5rSbr9nZ4iExWuiibUWh2yp/LhMn5NtLUhajogIMTFqvSkkUnjXA7o Tn3RhZn/z3ESpY6g9rA4Cq+2ssmYO4ZJtegL6B0qr9zL1+X0YTPmq21C4HoLw+NycUAJ DThg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.b=nJvVFYvP; spf=pass (google.com: domain of gcc-patches-return-459158-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=gcc-patches-return-459158-patch=linaro.org@gcc.gnu.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id l33si825670pld.392.2017.07.27.05.40.20 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 27 Jul 2017 05:40:20 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-return-459158-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.b=nJvVFYvP; spf=pass (google.com: domain of gcc-patches-return-459158-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=gcc-patches-return-459158-patch=linaro.org@gcc.gnu.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:date:message-id:mime-version:content-type; q=dns; s= default; b=jXQyIOdFQ3Hj9s9vV9QUufFIj/FXJjuiS5P6ix0BWvPasPZhHjJNL I0WMzsbYn21Ds3Jsj0w0XS3F5s6LQpIXgx4RgieEA9RjtQ6u7xhXjejlckJxNZIS +vo46Js2CrMYqjaxgmMAxfULba5MUYvtmeFeJhlBMdko6zDbBQgl88= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:date:message-id:mime-version:content-type; s= default; bh=fu9IJlvulSQLmfi9aKN4VmAI6yg=; b=nJvVFYvP7MLyvkbR0XlX oGimxjnIAW/qKak9gvE34zbu0h/g+f92TK5diGhEEB2uVwFW70+r4Op4R6htrPh1 Detz//QC92NCBkYud8Ofu+tVIOCxn9kS1vJPfh3hL6qi2ViPLfQEGln/g/I8P7bv m7Bz07GapqoVTZ6rKO9A3Gk= Received: (qmail 89231 invoked by alias); 27 Jul 2017 12:40:06 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 89186 invoked by uid 89); 27 Jul 2017 12:40:04 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-11.1 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.2 spammy=Relations X-HELO: mail-wm0-f46.google.com Received: from mail-wm0-f46.google.com (HELO mail-wm0-f46.google.com) (74.125.82.46) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 27 Jul 2017 12:39:59 +0000 Received: by mail-wm0-f46.google.com with SMTP id c184so105977315wmd.0 for ; Thu, 27 Jul 2017 05:39:59 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:mail-followup-to:subject:date:message-id :user-agent:mime-version; bh=BGISj0TwLt1Mr4Dtsoff8s7K1ztiPbuuHwbfZJ5/fmI=; b=RqWvskP9myhIWEhZkboa5zWFSMoYETH12dX2JPqvKvQDEpSLAj5CVJHY2zWXar1JYR mnU0zursOhr/0ECb3bBCUV2U9jg2ioOmuZTs47W5w99+Vn/vK4Td5iij6Iixr40CehWA 3yPe+M3S9Kd9waD+Ozbu3XeXcfN/9xVLBFBiOKCe/fLem52l53wDcVbVWVhd+OjNO+E9 VllK9AyA6Er/YrHjDOAG03VOIIJFi1q+zDtam+slNjyubxqdkHFHmDs8pXfQbzXKMaqj jd1WwGNN7kzMDal3850YXl7/FXTMKiGkihV9hC79bSFM2pQbNQDRtXdBSxFSfUq3vJBn 1rZg== X-Gm-Message-State: AIVw113LkJ+EemsnpdBnDFQ2E/YL3eP44INjbI60wM/X2S91yXHhH91O CdQWytvnqW10eTbvd78YaA== X-Received: by 10.28.21.21 with SMTP id 21mr3321809wmv.82.1501159196812; Thu, 27 Jul 2017 05:39:56 -0700 (PDT) Received: from localhost (92.40.249.175.threembb.co.uk. [92.40.249.175]) by smtp.gmail.com with ESMTPSA id 195sm2118819wms.47.2017.07.27.05.39.55 for (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Thu, 27 Jul 2017 05:39:55 -0700 (PDT) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@linaro.org Subject: C++-ify vec_info structures Date: Thu, 27 Jul 2017 13:39:53 +0100 Message-ID: <87r2x2rr3a.fsf@linaro.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/25.2 (gnu/linux) MIME-Version: 1.0 [ Needed to unblock https://gcc.gnu.org/ml/gcc-patches/2017-07/msg00198.html ] This patch uses new, delete, constructors and desctructors to manage vec_info. This includes making ~vec_info free all the data shared by bb_vec_info and loop_vec_info, whereas previously the code was duplicated in destroy_bb_vec_info and destroy_loop_vec_info. This in turn meant changing the order of: FOR_EACH_VEC_ELT (slp_instances, i, instance) vect_free_slp_instance (instance); and: gimple_set_uid (stmt, -1); in destroy_bb_vec_info/~_bb_vec_info, so that now vect_free_slp_instance could see a uid of -1 as well as 0. The patch updates vinfo_for_stmt so that it returns NULL for a uid of -1. Tested on aarch64-linux-gnu and x86_64-linux-gnu. OK to install? Richard 2017-07-27 Richard Sandiford gcc/ * tree-vectorizer.h (vec_info): Add a constructor and destructor. Add an explicit name for the enum. Use auto_vec for slp_instances and grouped_stores. (_loop_vec_info): Add a constructor and destructor. Use auto_vec for all vectors. (_bb_vec_info): Add a constructor and destructor. (vinfo_for_stmt): Return NULL for uids of -1 as well. (destroy_loop_vec_info): Delete. (vect_destroy_datarefs): Likewise. * tree-vectorizer.c (vect_destroy_datarefs): Delete. (vec_info::vec_info): New function. (vec_info::~vec_info): Likewise. (vectorize_loops): Use delete instead of destroy_loop_vec_info. * tree-parloops.c (gather_scalar_reductions): Use delete instead of destroy_loop_vec_info. * tree-vect-loop.c (new_loop_vec_info): Replace with... (_loop_vec_info::_loop_vec_info): ...this. (destroy_loop_vec_info): Replace with... (_loop_vec_info::~_loop_vec_info): ...this. Unconditionally delete the stmt_vec_infos. Leave handling of vec_info information to its destructor. Remove explicit vector releases. (vect_analyze_loop_form): Use new instead of new_loop_vec_info. (vect_analyze_loop): Use delete instead of destroy_loop_vec_info. * tree-vect-slp.c (new_bb_vec_info): Replace with... (_bb_vec_info::_bb_vec_info): ...this. Don't reserve space in BB_VINFO_GROUPED_STORES or BB_VINFO_SLP_INSTANCES. (destroy_bb_vec_info): Replace with... (_bb_vec_info::~_bb_vec_info): ...this. Leave handling of vec_info information to its destructor. (vect_slp_analyze_bb_1): Use new and delete instead of new_bb_vec_info and destroy_bb_vec_info. (vect_slp_bb): Replace 2 calls to destroy_bb_vec_info with a single delete. Index: gcc/tree-vectorizer.h =================================================================== --- gcc/tree-vectorizer.h 2017-07-27 13:25:33.934530189 +0100 +++ gcc/tree-vectorizer.h 2017-07-27 13:25:42.989783339 +0100 @@ -155,20 +155,27 @@ typedef std::pair vec_object /* Vectorizer state common between loop and basic-block vectorization. */ struct vec_info { - enum { bb, loop } kind; + enum vec_kind { bb, loop }; + + vec_info (vec_kind, void *); + ~vec_info (); + + /* The type of vectorization. */ + vec_kind kind; /* All SLP instances. */ - vec slp_instances; + auto_vec slp_instances; - /* All data references. */ + /* All data references. Freed by free_data_refs, so not an auto_vec. */ vec datarefs; - /* All data dependences. */ + /* All data dependences. Freed by free_dependence_relations, so not + an auto_vec. */ vec ddrs; /* All interleaving chains of stores, represented by the first stmt in the chain. */ - vec grouped_stores; + auto_vec grouped_stores; /* Cost data used by the target cost model. */ void *target_cost_data; @@ -198,6 +205,8 @@ is_a_helper <_bb_vec_info *>::test (vec_ /* Info on vectorized loops. */ /*-----------------------------------------------------------------*/ typedef struct _loop_vec_info : public vec_info { + _loop_vec_info (struct loop *); + ~_loop_vec_info (); /* The loop to which this info struct refers to. */ struct loop *loop; @@ -239,32 +248,32 @@ typedef struct _loop_vec_info : public v int ptr_mask; /* The loop nest in which the data dependences are computed. */ - vec loop_nest; + auto_vec loop_nest; /* Data Dependence Relations defining address ranges that are candidates for a run-time aliasing check. */ - vec may_alias_ddrs; + auto_vec may_alias_ddrs; /* Data Dependence Relations defining address ranges together with segment lengths from which the run-time aliasing check is built. */ - vec comp_alias_ddrs; + auto_vec comp_alias_ddrs; /* Check that the addresses of each pair of objects is unequal. */ - vec check_unequal_addrs; + auto_vec check_unequal_addrs; /* Statements in the loop that have data references that are candidates for a runtime (loop versioning) misalignment check. */ - vec may_misalign_stmts; + auto_vec may_misalign_stmts; /* Reduction cycles detected in the loop. Used in loop-aware SLP. */ - vec reductions; + auto_vec reductions; /* All reduction chains in the loop, represented by the first stmt in the chain. */ - vec reduction_chains; + auto_vec reduction_chains; /* Cost vector for a single scalar iteration. */ - vec scalar_cost_vec; + auto_vec scalar_cost_vec; /* The unrolling factor needed to SLP the loop. In case of that pure SLP is applied to the loop, i.e., no unrolling is needed, this is 1. */ @@ -399,6 +408,9 @@ nested_in_vect_loop_p (struct loop *loop typedef struct _bb_vec_info : public vec_info { + _bb_vec_info (gimple_stmt_iterator, gimple_stmt_iterator); + ~_bb_vec_info (); + basic_block bb; gimple_stmt_iterator region_begin; gimple_stmt_iterator region_end; @@ -802,8 +814,8 @@ void free_stmt_vec_info_vec (void); static inline stmt_vec_info vinfo_for_stmt (gimple *stmt) { - unsigned int uid = gimple_uid (stmt); - if (uid == 0) + int uid = gimple_uid (stmt); + if (uid <= 0) return NULL; return stmt_vec_info_vec[uid - 1]; @@ -1177,7 +1189,6 @@ extern tree vect_create_addr_base_for_ve /* In tree-vect-loop.c. */ /* FORNOW: Used in tree-parloops.c. */ -extern void destroy_loop_vec_info (loop_vec_info, bool); extern gimple *vect_force_simple_reduction (loop_vec_info, gimple *, bool *, bool); /* Drive for loop analysis stage. */ @@ -1226,7 +1237,6 @@ void vect_pattern_recog (vec_info *); /* In tree-vectorizer.c. */ unsigned vectorize_loops (void); -void vect_destroy_datarefs (vec_info *); bool vect_stmt_in_region_p (vec_info *, gimple *); void vect_free_loop_info_assumptions (struct loop *); Index: gcc/tree-vectorizer.c =================================================================== --- gcc/tree-vectorizer.c 2017-07-27 13:23:27.073925971 +0100 +++ gcc/tree-vectorizer.c 2017-07-27 13:25:42.988783310 +0100 @@ -354,22 +354,36 @@ note_simd_array_uses (hash_tabledatarefs, i, dr) + FOR_EACH_VEC_ELT (datarefs, i, dr) if (dr->aux) { free (dr->aux); dr->aux = NULL; } - free_data_refs (vinfo->datarefs); + FOR_EACH_VEC_ELT (slp_instances, i, instance) + vect_free_slp_instance (instance); + + free_data_refs (datarefs); + free_dependence_relations (ddrs); + destroy_cost_data (target_cost_data); } /* A helper function to free scev and LOOP niter information, as well as @@ -830,7 +844,7 @@ vectorize_loops (void) has_mask_store = false; if (loop_vinfo) has_mask_store = LOOP_VINFO_HAS_MASK_STORE (loop_vinfo); - destroy_loop_vec_info (loop_vinfo, true); + delete loop_vinfo; if (has_mask_store) optimize_mask_stores (loop); loop->aux = NULL; Index: gcc/tree-parloops.c =================================================================== --- gcc/tree-parloops.c 2017-07-27 13:23:27.073925971 +0100 +++ gcc/tree-parloops.c 2017-07-27 13:25:42.987783282 +0100 @@ -2561,7 +2561,7 @@ gather_scalar_reductions (loop_p loop, r build_new_reduction (reduction_list, reduc_stmt, phi); } - destroy_loop_vec_info (simple_loop_info, true); + delete simple_loop_info; if (!double_reduc_phis.is_empty ()) { @@ -2597,7 +2597,7 @@ gather_scalar_reductions (loop_p loop, r build_new_reduction (reduction_list, double_reduc_stmts[i], phi); } - destroy_loop_vec_info (simple_loop_info, true); + delete simple_loop_info; } } Index: gcc/tree-vect-loop.c =================================================================== --- gcc/tree-vect-loop.c 2017-07-27 13:25:33.934530189 +0100 +++ gcc/tree-vect-loop.c 2017-07-27 13:25:42.988783310 +0100 @@ -1098,112 +1098,77 @@ bb_in_loop_p (const_basic_block bb, cons } -/* Function new_loop_vec_info. +/* Create and initialize a new loop_vec_info struct for LOOP_IN, as well as + stmt_vec_info structs for all the stmts in LOOP_IN. */ - Create and initialize a new loop_vec_info struct for LOOP, as well as - stmt_vec_info structs for all the stmts in LOOP. */ - -static loop_vec_info -new_loop_vec_info (struct loop *loop) +_loop_vec_info::_loop_vec_info (struct loop *loop_in) + : vec_info (vec_info::loop, init_cost (loop_in)), + loop (loop_in), + bbs (XCNEWVEC (basic_block, loop->num_nodes)), + num_itersm1 (NULL_TREE), + num_iters (NULL_TREE), + num_iters_unchanged (NULL_TREE), + num_iters_assumptions (NULL_TREE), + th (0), + vectorization_factor (0), + unaligned_dr (NULL), + peeling_for_alignment (0), + ptr_mask (0), + slp_unrolling_factor (1), + single_scalar_iteration_cost (0), + vectorizable (false), + peeling_for_gaps (false), + peeling_for_niter (false), + operands_swapped (false), + no_data_dependencies (false), + has_mask_store (false), + scalar_loop (NULL), + orig_loop_info (NULL) { - loop_vec_info res; - basic_block *bbs; - gimple_stmt_iterator si; - unsigned int i, nbbs; - - res = (loop_vec_info) xcalloc (1, sizeof (struct _loop_vec_info)); - res->kind = vec_info::loop; - LOOP_VINFO_LOOP (res) = loop; - - bbs = get_loop_body (loop); - /* Create/Update stmt_info for all stmts in the loop. */ - for (i = 0; i < loop->num_nodes; i++) + basic_block *body = get_loop_body (loop); + for (unsigned int i = 0; i < loop->num_nodes; i++) { - basic_block bb = bbs[i]; + basic_block bb = body[i]; + gimple_stmt_iterator si; for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si)) { gimple *phi = gsi_stmt (si); gimple_set_uid (phi, 0); - set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, res)); + set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, this)); } for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) { gimple *stmt = gsi_stmt (si); gimple_set_uid (stmt, 0); - set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, res)); + set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, this)); } } + free (body); /* CHECKME: We want to visit all BBs before their successors (except for latch blocks, for which this assertion wouldn't hold). In the simple case of the loop forms we allow, a dfs order of the BBs would the same as reversed postorder traversal, so we are safe. */ - free (bbs); - bbs = XCNEWVEC (basic_block, loop->num_nodes); - nbbs = dfs_enumerate_from (loop->header, 0, bb_in_loop_p, - bbs, loop->num_nodes, loop); - gcc_assert (nbbs == loop->num_nodes); - - LOOP_VINFO_BBS (res) = bbs; - LOOP_VINFO_NITERSM1 (res) = NULL; - LOOP_VINFO_NITERS (res) = NULL; - LOOP_VINFO_NITERS_UNCHANGED (res) = NULL; - LOOP_VINFO_NITERS_ASSUMPTIONS (res) = NULL; - LOOP_VINFO_COST_MODEL_THRESHOLD (res) = 0; - LOOP_VINFO_VECTORIZABLE_P (res) = 0; - LOOP_VINFO_PEELING_FOR_ALIGNMENT (res) = 0; - LOOP_VINFO_VECT_FACTOR (res) = 0; - LOOP_VINFO_LOOP_NEST (res) = vNULL; - LOOP_VINFO_DATAREFS (res) = vNULL; - LOOP_VINFO_DDRS (res) = vNULL; - LOOP_VINFO_UNALIGNED_DR (res) = NULL; - LOOP_VINFO_MAY_MISALIGN_STMTS (res) = vNULL; - LOOP_VINFO_MAY_ALIAS_DDRS (res) = vNULL; - LOOP_VINFO_GROUPED_STORES (res) = vNULL; - LOOP_VINFO_REDUCTIONS (res) = vNULL; - LOOP_VINFO_REDUCTION_CHAINS (res) = vNULL; - LOOP_VINFO_SLP_INSTANCES (res) = vNULL; - LOOP_VINFO_SLP_UNROLLING_FACTOR (res) = 1; - LOOP_VINFO_TARGET_COST_DATA (res) = init_cost (loop); - LOOP_VINFO_PEELING_FOR_GAPS (res) = false; - LOOP_VINFO_PEELING_FOR_NITER (res) = false; - LOOP_VINFO_OPERANDS_SWAPPED (res) = false; - LOOP_VINFO_ORIG_LOOP_INFO (res) = NULL; - - return res; + unsigned int nbbs = dfs_enumerate_from (loop->header, 0, bb_in_loop_p, + bbs, loop->num_nodes, loop); + gcc_assert (nbbs == loop->num_nodes); } -/* Function destroy_loop_vec_info. - - Free LOOP_VINFO struct, as well as all the stmt_vec_info structs of all the - stmts in the loop. */ +/* Free all memory used by the _loop_vec_info, as well as all the + stmt_vec_info structs of all the stmts in the loop. */ -void -destroy_loop_vec_info (loop_vec_info loop_vinfo, bool clean_stmts) +_loop_vec_info::~_loop_vec_info () { - struct loop *loop; - basic_block *bbs; int nbbs; gimple_stmt_iterator si; int j; - vec slp_instances; - slp_instance instance; - bool swapped; - - if (!loop_vinfo) - return; - - loop = LOOP_VINFO_LOOP (loop_vinfo); - - bbs = LOOP_VINFO_BBS (loop_vinfo); - nbbs = clean_stmts ? loop->num_nodes : 0; - swapped = LOOP_VINFO_OPERANDS_SWAPPED (loop_vinfo); + nbbs = loop->num_nodes; for (j = 0; j < nbbs; j++) { basic_block bb = bbs[j]; @@ -1216,7 +1181,7 @@ destroy_loop_vec_info (loop_vec_info loo /* We may have broken canonical form by moving a constant into RHS1 of a commutative op. Fix such occurrences. */ - if (swapped && is_gimple_assign (stmt)) + if (operands_swapped && is_gimple_assign (stmt)) { enum tree_code code = gimple_assign_rhs_code (stmt); @@ -1256,28 +1221,8 @@ destroy_loop_vec_info (loop_vec_info loo } } - free (LOOP_VINFO_BBS (loop_vinfo)); - vect_destroy_datarefs (loop_vinfo); - free_dependence_relations (LOOP_VINFO_DDRS (loop_vinfo)); - LOOP_VINFO_LOOP_NEST (loop_vinfo).release (); - LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo).release (); - LOOP_VINFO_COMP_ALIAS_DDRS (loop_vinfo).release (); - LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo).release (); - slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo); - FOR_EACH_VEC_ELT (slp_instances, j, instance) - vect_free_slp_instance (instance); - - LOOP_VINFO_SLP_INSTANCES (loop_vinfo).release (); - LOOP_VINFO_GROUPED_STORES (loop_vinfo).release (); - LOOP_VINFO_REDUCTIONS (loop_vinfo).release (); - LOOP_VINFO_REDUCTION_CHAINS (loop_vinfo).release (); - - destroy_cost_data (LOOP_VINFO_TARGET_COST_DATA (loop_vinfo)); - loop_vinfo->scalar_cost_vec.release (); - - LOOP_VINFO_CHECK_UNEQUAL_ADDRS (loop_vinfo).release (); + free (bbs); - free (loop_vinfo); loop->aux = NULL; } @@ -1564,7 +1509,7 @@ vect_analyze_loop_form (struct loop *loo &number_of_iterations, &inner_loop_cond)) return NULL; - loop_vec_info loop_vinfo = new_loop_vec_info (loop); + loop_vec_info loop_vinfo = new _loop_vec_info (loop); LOOP_VINFO_NITERSM1 (loop_vinfo) = number_of_iterationsm1; LOOP_VINFO_NITERS (loop_vinfo) = number_of_iterations; LOOP_VINFO_NITERS_UNCHANGED (loop_vinfo) = number_of_iterations; @@ -2412,7 +2357,7 @@ vect_analyze_loop (struct loop *loop, lo return loop_vinfo; } - destroy_loop_vec_info (loop_vinfo, true); + delete loop_vinfo; vector_sizes &= ~current_vector_size; if (fatal Index: gcc/tree-vect-slp.c =================================================================== --- gcc/tree-vect-slp.c 2017-07-27 13:23:27.073925971 +0100 +++ gcc/tree-vect-slp.c 2017-07-27 13:25:42.988783310 +0100 @@ -2362,62 +2362,37 @@ vect_detect_hybrid_slp (loop_vec_info lo } -/* Create and initialize a new bb_vec_info struct for BB, as well as - stmt_vec_info structs for all the stmts in it. */ +/* Initialize a bb_vec_info struct for the statements between + REGION_BEGIN_IN (inclusive) and REGION_END_IN (exclusive). */ -static bb_vec_info -new_bb_vec_info (gimple_stmt_iterator region_begin, - gimple_stmt_iterator region_end) +_bb_vec_info::_bb_vec_info (gimple_stmt_iterator region_begin_in, + gimple_stmt_iterator region_end_in) + : vec_info (vec_info::bb, init_cost (NULL)), + bb (gsi_bb (region_begin_in)), + region_begin (region_begin_in), + region_end (region_end_in) { - basic_block bb = gsi_bb (region_begin); - bb_vec_info res = NULL; gimple_stmt_iterator gsi; - res = (bb_vec_info) xcalloc (1, sizeof (struct _bb_vec_info)); - res->kind = vec_info::bb; - BB_VINFO_BB (res) = bb; - res->region_begin = region_begin; - res->region_end = region_end; - for (gsi = region_begin; gsi_stmt (gsi) != gsi_stmt (region_end); gsi_next (&gsi)) { gimple *stmt = gsi_stmt (gsi); gimple_set_uid (stmt, 0); - set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, res)); + set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, this)); } - BB_VINFO_GROUPED_STORES (res).create (10); - BB_VINFO_SLP_INSTANCES (res).create (2); - BB_VINFO_TARGET_COST_DATA (res) = init_cost (NULL); - - bb->aux = res; - return res; + bb->aux = this; } /* Free BB_VINFO struct, as well as all the stmt_vec_info structs of all the stmts in the basic block. */ -static void -destroy_bb_vec_info (bb_vec_info bb_vinfo) +_bb_vec_info::~_bb_vec_info () { - slp_instance instance; - unsigned i; - - if (!bb_vinfo) - return; - - vect_destroy_datarefs (bb_vinfo); - free_dependence_relations (BB_VINFO_DDRS (bb_vinfo)); - BB_VINFO_GROUPED_STORES (bb_vinfo).release (); - FOR_EACH_VEC_ELT (BB_VINFO_SLP_INSTANCES (bb_vinfo), i, instance) - vect_free_slp_instance (instance); - BB_VINFO_SLP_INSTANCES (bb_vinfo).release (); - destroy_cost_data (BB_VINFO_TARGET_COST_DATA (bb_vinfo)); - - for (gimple_stmt_iterator si = bb_vinfo->region_begin; - gsi_stmt (si) != gsi_stmt (bb_vinfo->region_end); gsi_next (&si)) + for (gimple_stmt_iterator si = region_begin; + gsi_stmt (si) != gsi_stmt (region_end); gsi_next (&si)) { gimple *stmt = gsi_stmt (si); stmt_vec_info stmt_info = vinfo_for_stmt (stmt); @@ -2430,8 +2405,7 @@ destroy_bb_vec_info (bb_vec_info bb_vinf gimple_set_uid (stmt, -1); } - BB_VINFO_BB (bb_vinfo)->aux = NULL; - free (bb_vinfo); + bb->aux = NULL; } @@ -2713,7 +2687,7 @@ vect_slp_analyze_bb_1 (gimple_stmt_itera return NULL; } - bb_vinfo = new_bb_vec_info (region_begin, region_end); + bb_vinfo = new _bb_vec_info (region_begin, region_end); if (!bb_vinfo) return NULL; @@ -2728,7 +2702,7 @@ vect_slp_analyze_bb_1 (gimple_stmt_itera "not vectorized: unhandled data-ref in basic " "block.\n"); - destroy_bb_vec_info (bb_vinfo); + delete bb_vinfo; return NULL; } @@ -2739,7 +2713,7 @@ vect_slp_analyze_bb_1 (gimple_stmt_itera "not vectorized: not enough data-refs in " "basic block.\n"); - destroy_bb_vec_info (bb_vinfo); + delete bb_vinfo; return NULL; } @@ -2750,7 +2724,7 @@ vect_slp_analyze_bb_1 (gimple_stmt_itera "not vectorized: unhandled data access in " "basic block.\n"); - destroy_bb_vec_info (bb_vinfo); + delete bb_vinfo; return NULL; } @@ -2764,7 +2738,7 @@ vect_slp_analyze_bb_1 (gimple_stmt_itera "not vectorized: no grouped stores in " "basic block.\n"); - destroy_bb_vec_info (bb_vinfo); + delete bb_vinfo; return NULL; } @@ -2786,7 +2760,7 @@ vect_slp_analyze_bb_1 (gimple_stmt_itera "in basic block.\n"); } - destroy_bb_vec_info (bb_vinfo); + delete bb_vinfo; return NULL; } @@ -2816,7 +2790,7 @@ vect_slp_analyze_bb_1 (gimple_stmt_itera } if (! BB_VINFO_SLP_INSTANCES (bb_vinfo).length ()) { - destroy_bb_vec_info (bb_vinfo); + delete bb_vinfo; return NULL; } @@ -2827,7 +2801,7 @@ vect_slp_analyze_bb_1 (gimple_stmt_itera dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, "not vectorized: bad operation in basic block.\n"); - destroy_bb_vec_info (bb_vinfo); + delete bb_vinfo; return NULL; } @@ -2840,7 +2814,7 @@ vect_slp_analyze_bb_1 (gimple_stmt_itera "not vectorized: vectorization is not " "profitable.\n"); - destroy_bb_vec_info (bb_vinfo); + delete bb_vinfo; return NULL; } @@ -2920,12 +2894,9 @@ vect_slp_bb (basic_block bb) dump_printf_loc (MSG_NOTE, vect_location, "basic block part vectorized\n"); - destroy_bb_vec_info (bb_vinfo); - vectorized = true; } - else - destroy_bb_vec_info (bb_vinfo); + delete bb_vinfo; any_vectorized |= vectorized;