From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 12019 invoked by alias); 8 May 2014 01:20:49 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 11983 invoked by uid 89); 8 May 2014 01:20:48 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=1.0 required=5.0 tests=AWL,BAYES_99,BAYES_999,KAM_STOCKGEN,RP_MATCHES_RCVD autolearn=no version=3.3.2 X-HELO: smtp.mozilla.org Received: from mx2.corp.phx1.mozilla.com (HELO smtp.mozilla.org) (63.245.216.70) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 08 May 2014 01:20:45 +0000 Received: from tsaunders-iceball.corp.tor1.mozilla.com (unknown [64.213.68.131]) (Authenticated sender: tsaunders@mozilla.com) by mx2.mail.corp.phx1.mozilla.com (Postfix) with ESMTPSA id 8CB6CF25B1; Wed, 7 May 2014 18:20:41 -0700 (PDT) Date: Thu, 08 May 2014 01:20:00 -0000 From: Trevor Saunders To: gcc-patches@gcc.gnu.org, rdsandiford@googlemail.com Subject: Re: RFC: Faster for_each_rtx-like iterators Message-ID: <20140508012130.GA9795@tsaunders-iceball.corp.tor1.mozilla.com> References: <87k39x48gu.fsf@talisman.default> MIME-Version: 1.0 Content-Type: multipart/signed; micalg=pgp-sha1; protocol="application/pgp-signature"; boundary="ReaqsoxgOBHFXBhH" Content-Disposition: inline In-Reply-To: <87k39x48gu.fsf@talisman.default> User-Agent: Mutt/1.5.23 (2014-03-12) X-IsSubscribed: yes X-SW-Source: 2014-05/txt/msg00450.txt.bz2 --ReaqsoxgOBHFXBhH Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Content-Transfer-Encoding: quoted-printable Content-length: 22675 On Wed, May 07, 2014 at 09:52:49PM +0100, Richard Sandiford wrote: > I noticed for_each_rtx showing up in profiles and thought I'd have a go > at using worklist-based iterators instead. So far I have three: >=20 > FOR_EACH_SUBRTX: iterates over const_rtx subrtxes of a const_rtx > FOR_EACH_SUBRTX_VAR: iterates over rtx subrtxes of an rtx > FOR_EACH_SUBRTX_PTR: iterates over subrtx pointers of an rtx * >=20 > with FOR_EACH_SUBRTX_PTR being the direct for_each_rtx replacement. >=20 > I made FOR_EACH_SUBRTX the "default" (unsuffixed) version because > most walks really don't modify the structure. I think we should > encourage const_rtxes to be used whereever possible. E.g. it might > make it easier to have non-GC storage for temporary rtxes in future. >=20 > I've locally replaced all for_each_rtx calls in the generic code with > these iterators and they make things reproducably faster. The speed-up > on full --enable-checking=3Drelease ./cc1 and ./cc1plus times is only abo= ut 1%, > but maybe that's enough to justify the churn. seems pretty nice, and it seems like it'll make code a little more readable too :) > Implementation-wise, the main observation is that most subrtxes are part > of a single contiguous sequence of "e" fields. E.g. when compiling an > oldish combine.ii on x86_64-linux-gnu with -O2, we iterate over the > subrtxes of 7,636,542 rtxes. Of those: >=20 > (A) 4,459,135 (58.4%) are leaf rtxes with no "e" or "E" fields, > (B) 3,133,875 (41.0%) are rtxes with a single block of "e" fields and > no "E" fields, and > (C) 43,532 (00.6%) are more complicated. >=20 > (A) is really a special case of (B) in which the block has zero length. > Those are the only two cases that really need to be handled inline. > The implementation does this by having a mapping from an rtx code to the > bounds of its "e" sequence, in the form of a start index and count. >=20 > Out of (C), the vast majority (43,509) are PARALLELs. However, as you'd > probably expect, bloating the inline code with that case made things > slower rather than faster. >=20 > The vast majority (in fact all in the combine.ii run above) of iterations > can be done with a 16-element stack worklist. We obviously still need a > heap fallback for the pathological cases though. >=20 > I spent a bit of time trying different iterator implementations and > seeing which produced the best code. Specific results from that were: >=20 > - The storage used for the worklist is separate from the iterator, > in order to avoid capturing iterator fields. >=20 > - Although the natural type of the storage would be auto_vec <..., 16>, > that produced some overhead compared with a separate stack array and he= ap > vector pointer. With the heap vector pointer, the only overhead is an > assignment in the constructor and an "if (x) release (x)"-style sequence > in the destructor. I think the extra complication over auto_vec is wor= th > it because in this case the heap version is so very rarely needed. hm, where does the overhead come from exactly? it seems like if its faster to use vec *foo; we should fix something about vectors since this isn't the only place it could matter. does it matter if you use vec * or vec ? the second is basically just a wrapper around the former I'd expect has no effect. I'm not saying you're doing the wrong thing here, but if we can make generic vectors faster we probably should ;) or is the issue the __builtin_expect()s you can add? > - Several existing for_each_rtx callbacks have something like: >=20 > if (GET_CODE (x) =3D=3D CONST) > return -1; >=20 > or: >=20 > if (CONSTANT_P (x)) > return -1; >=20 > to avoid walking subrtxes of constants. That can be done without > extra code checks and branches by having a separate code->bound > mapping in which all constants are treated as leaf rtxes. This usage > should be common enough to outweigh the cache penalty of two arrays. >=20 > The choice between iterating over constants or not is given in the > final parameter of the FOR_EACH_* iterator. less repitition \O/ > - The maximum number of fields in (B)-type rtxes is 3. We get better > code by making that explicit rather than having a general loop. >=20 > - (C) codes map to an "e" count of UCHAR_MAX, so we can use a single > check to test for that and for cases where the stack worklist is > too small. can we use uint8_t? > To give an example: >=20 > /* Callback for for_each_rtx, that returns 1 upon encountering a VALUE > whose UID is greater than the int uid that D points to. */ >=20 > static int > refs_newer_value_cb (rtx *x, void *d) > { > if (GET_CODE (*x) =3D=3D VALUE && CSELIB_VAL_PTR (*x)->uid > *(int *)d) > return 1; >=20 > return 0; > } >=20 > /* Return TRUE if EXPR refers to a VALUE whose uid is greater than > that of V. */ >=20 > static bool > refs_newer_value_p (rtx expr, rtx v) > { > int minuid =3D CSELIB_VAL_PTR (v)->uid; >=20 > return for_each_rtx (&expr, refs_newer_value_cb, &minuid); > } >=20 > becomes: >=20 > /* Return TRUE if EXPR refers to a VALUE whose uid is greater than > that of V. */ >=20 > static bool > refs_newer_value_p (const_rtx expr, rtx v) > { > int minuid =3D CSELIB_VAL_PTR (v)->uid; > subrtx_iterator::array_type array; some reason to not hide it in the macro? > FOR_EACH_SUBRTX (iter, array, expr, NONCONST) > if (GET_CODE (*iter) =3D=3D VALUE && CSELIB_VAL_PTR (*iter)->uid > mi= nuid) > return true; > return false; > } >=20 > The iterator also allows subrtxes of a specific rtx to be skipped; > this is the equivalent of returning -1 from a for_each_rtx callback. > It also allows the current rtx to be replaced in the worklist by > another. E.g.: >=20 > static void > mark_constants_in_pattern (rtx insn) > { > subrtx_iterator::array_type array; > FOR_EACH_SUBRTX (iter, array, PATTERN (insn), ALL) > { > const_rtx x =3D *iter; > if (GET_CODE (x) =3D=3D SYMBOL_REF) > { > if (CONSTANT_POOL_ADDRESS_P (x)) > { > struct constant_descriptor_rtx *desc =3D SYMBOL_REF_CONSTANT (x); > if (desc->mark =3D=3D 0) > { > desc->mark =3D 1; > iter.substitute (desc->constant); > } > } > else if (TREE_CONSTANT_POOL_ADDRESS_P (x)) > { > tree decl =3D SYMBOL_REF_DECL (x); > if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl))) > { > n_deferred_constants--; > output_constant_def_contents (CONST_CAST_RTX (x)); > } > } > } > } > } >=20 > where the iter.substitute avoids a recursive walk. (The CONST_CAST_RTX > is "temporary".) >=20 > Does this look like it's worth pursuing? If so, is it OK to start > submitting now or should it wait until 4.9.1 is out? If it is OK, > I plan to convert the ports too and get rid of for_each_rtx. >=20 > Thanks, > Richard >=20 >=20 > diff --git a/gcc/rtl-iter.h b/gcc/rtl-iter.h > new file mode 100644 > index 0000000..1bc171d > --- /dev/null > +++ b/gcc/rtl-iter.h > @@ -0,0 +1,293 @@ > +/* RTL iterators > + Copyright (C) 2014 Free Software Foundation, Inc. > + > +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 > +. */ > + > +/* This structure describes the subrtxes of an rtx as follows: > + > + - if the rtx has no subrtxes, START and COUNT are both 0. > + > + - if all the subrtxes of an rtx are stored in a contiguous block > + of XEXPs ("e"s), START is the index of the first XEXP and COUNT > + is the number of them. > + > + - otherwise START is arbitrary and COUNT is UCHAR_MAX. */ > +struct rtx_subrtx_bound_info { > + unsigned char start; > + unsigned char count; > +}; > +extern rtx_subrtx_bound_info rtx_all_subrtx_bounds[]; > +extern rtx_subrtx_bound_info rtx_nonconst_subrtx_bounds[]; > + > +/* Return true if CODE has no subrtxes. */ > + > +static inline bool > +leaf_code_p (enum rtx_code code) > +{ > + return rtx_all_subrtx_bounds[code].count =3D=3D 0; > +} > + > +/* Used to iterate over subrtxes of an rtx. T abstracts the type of > + access. */ > +template > +class generic_subrtx_iterator > +{ > + static const size_t LOCAL_ELEMS =3D 16; > + typedef typename T::value_type value_type; > + typedef typename T::rtx_type rtx_type; > + typedef typename T::rtunion_type rtunion_type; > + > +public: > + struct array_type > + { > + array_type (); > + ~array_type (); > + value_type stack[LOCAL_ELEMS]; > + vec *heap; > + }; > + generic_subrtx_iterator (array_type &, value_type, > + const rtx_subrtx_bound_info *); > + ~generic_subrtx_iterator (); > + > + value_type operator * () const; > + bool at_end () const; > + void next (); > + void skip_subrtxes (); > + void substitute (value_type); > + > +private: > + /* The bounds to use for iterating over subrtxes. */ > + const rtx_subrtx_bound_info *m_bounds; > + > + /* The storage used for the worklist. */ > + array_type &m_array; > + > + /* The current rtx. */ > + value_type m_current; > + > + /* The base of the current worklist. */ > + value_type *m_base; > + > + /* The number of subrtxes in M_BASE. */ > + size_t m_end; > + > + /* The following booleans shouldn't end up in registers or memory > + but just direct control flow. */ > + > + /* True if the iteration is over. */ > + bool m_done; > + > + /* True if we should skip the subrtxes of M_CURRENT. */ > + bool m_skip; > + > + /* True if M_CURRENT has been replaced with a different rtx. */ > + bool m_substitute; > + > + static void free_array (array_type &); > + static size_t add_subrtxes_to_queue (array_type &, value_type *, size_= t, > + rtx_type); > + static value_type *add_single_to_queue (array_type &, value_type *, si= ze_t, > + value_type); > +}; > + > +template > +inline generic_subrtx_iterator ::array_type::array_type () : heap (0)= {} > + > +template > +inline generic_subrtx_iterator ::array_type::~array_type () > +{ > + if (__builtin_expect (heap !=3D 0, false)) > + free_array (*this); > +} > + > +/* Iterate over X and its subrtxes, in arbitrary order. Use ARRAY to > + store the worklist. We use an external array in order to avoid > + capturing the fields of this structure when taking the address of > + the array. Use BOUNDS to find the bounds of simple "e"-string codes.= */ > + > +template > +inline generic_subrtx_iterator :: > +generic_subrtx_iterator (array_type &array, value_type x, > + const rtx_subrtx_bound_info *bounds) > + : m_bounds (bounds), > + m_array (array), > + m_current (x), > + m_base (m_array.stack), > + m_end (0), > + m_done (false), > + m_skip (false), > + m_substitute (false) > +{ > +} > + > +template > +inline generic_subrtx_iterator ::~generic_subrtx_iterator () > +{ > +} What's wrong with just letting the compiler generate that for you? > +/* Return the current subrtx. */ > + > +template > +inline typename T::value_type > +generic_subrtx_iterator ::operator * () const > +{ > + return m_current; > +} > + > +/* Return true if the iteration has finished. */ > + > +template > +inline bool > +generic_subrtx_iterator ::at_end () const > +{ > + return m_done; > +} > + > +/* Move on to the next subrtx. */ > + > +template > +inline void > +generic_subrtx_iterator ::next () > +{ > + if (m_substitute) > + { > + m_substitute =3D false; > + m_skip =3D false; > + return; > + } > + if (!m_skip) > + { > + /* Add the subrtxes of M_CURRENT. */ > + rtx_type x =3D T::get_rtx (m_current); > + if (__builtin_expect (x !=3D 0, true)) > + { > + enum rtx_code code =3D GET_CODE (x); > + ssize_t count =3D m_bounds[code].count; > + if (count > 0) > + { > + /* Handle the simple case of a single "e" block that is known > + to fit into the current array. */ > + if (__builtin_expect (m_end + count <=3D LOCAL_ELEMS + 1, true)) > + { > + /* Set M_CURRENT to the first subrtx and queue the rest. */ > + ssize_t start =3D m_bounds[code].start; > + rtunion_type *src =3D &x->u.fld[start]; > + if (__builtin_expect (count > 2, false)) > + m_base[m_end++] =3D T::get_value (src[2].rt_rtx); > + if (count > 1) > + m_base[m_end++] =3D T::get_value (src[1].rt_rtx); > + m_current =3D T::get_value (src[0].rt_rtx); > + return; > + } > + /* Handle cases which aren't simple "e" sequences or where > + the sequence might overrun M_BASE. */ > + count =3D add_subrtxes_to_queue (m_array, m_base, m_end, x); > + if (count > 0) > + { > + m_end +=3D count; > + if (m_end > LOCAL_ELEMS) > + m_base =3D m_array.heap->address (); > + m_current =3D m_base[--m_end]; > + return; > + } > + } > + } > + } > + else > + m_skip =3D false; > + if (m_end =3D=3D 0) > + m_done =3D true; > + else > + m_current =3D m_base[--m_end]; > +} > + > +/* Skip the subrtxes of the current rtx. */ > + > +template > +inline void > +generic_subrtx_iterator ::skip_subrtxes () > +{ > + m_skip =3D true; > +} > + > +/* Ignore the subrtxes of the current rtx and look at X instead. */ > + > +template > +inline void > +generic_subrtx_iterator ::substitute (value_type x) > +{ > + m_substitute =3D true; > + m_current =3D x; > +} > + > +/* Iterators for const_rtx. */ > +struct const_rtx_accessor > +{ > + typedef const_rtx value_type; > + typedef const_rtx rtx_type; > + typedef const rtunion rtunion_type; > + static rtx_type get_rtx (value_type x) { return x; } > + static value_type get_value (rtx_type x) { return x; } > +}; > +typedef generic_subrtx_iterator subrtx_iterator; > + > +/* Iterators for non-constant rtx. */ > +struct rtx_var_accessor > +{ > + typedef rtx value_type; > + typedef rtx rtx_type; > + typedef rtunion rtunion_type; > + static rtx_type get_rtx (value_type x) { return x; } > + static value_type get_value (rtx_type x) { return x; } > +}; > +typedef generic_subrtx_iterator subrtx_var_iterator; > + > +/* Iterators for rtx *. */ > +struct rtx_ptr_accessor > +{ > + typedef rtx *value_type; > + typedef rtx rtx_type; > + typedef rtunion rtunion_type; > + static rtx_type get_rtx (value_type ptr) { return *ptr; } > + static value_type get_value (rtx_type &x) { return &x; } > +}; > +typedef generic_subrtx_iterator subrtx_ptr_iterator; > + > +#define ALL_BOUNDS rtx_all_subrtx_bounds > +#define NONCONST_BOUNDS rtx_nonconst_subrtx_bounds > + > +/* Use ITER to iterate over const_rtx X and its recursive subrtxes, > + using subrtx_iterator::array ARRAY as the storage for the worklist. > + ARRAY can be reused for multiple consecutive iterations but shouldn't > + be shared by two concurrent iterations. TYPE is ALL if all subrtxes > + are of interest or NONCONST if it is safe to ignore subrtxes of > + constants. */ > +#define FOR_EACH_SUBRTX(ITER, ARRAY, X, TYPE) \ > + for (subrtx_iterator ITER (ARRAY, X, TYPE##_BOUNDS); !ITER.at_end (); \ > + ITER.next ()) > + > +/* Like FOR_EACH_SUBRTX, but iterate over subrtxes of an rtx X. */ > +#define FOR_EACH_SUBRTX_VAR(ITER, ARRAY, X, TYPE) \ > + for (subrtx_var_iterator ITER (ARRAY, X, TYPE##_BOUNDS); !ITER.at_end = (); \ > + ITER.next ()) > + > +/* Like FOR_EACH_SUBRTX, but iterate over subrtx pointers of rtx pointer= X. > + For example, if X is &PATTERN (insn) and the pattern is a SET, iterate > + over &PATTERN (insn), &SET_DEST (PATTERN (insn)), etc. */ > +#define FOR_EACH_SUBRTX_PTR(ITER, ARRAY, X, TYPE) \ > + for (subrtx_ptr_iterator ITER (ARRAY, X, TYPE##_BOUNDS); !ITER.at_end = (); \ > + ITER.next ()) > diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c > index f3471b1..df52788 100644 > --- a/gcc/rtlanal.c > +++ b/gcc/rtlanal.c > @@ -37,6 +37,7 @@ along with GCC; see the file COPYING3. If not see > #include "tree.h" > #include "emit-rtl.h" /* FIXME: Can go away once crtl is moved to rtl.h= . */ > #include "addresses.h" > +#include "rtl-iter.h" >=20=20 > /* Forward declarations */ > static void set_of_1 (rtx, const_rtx, void *); > @@ -62,6 +63,9 @@ static unsigned int num_sign_bit_copies1 (const_rtx, en= um machine_mode, const_rt > -1 if a code has no such operand. */ > static int non_rtx_starting_operands[NUM_RTX_CODE]; >=20=20 > +rtx_subrtx_bound_info rtx_all_subrtx_bounds[NUM_RTX_CODE]; > +rtx_subrtx_bound_info rtx_nonconst_subrtx_bounds[NUM_RTX_CODE]; > + > /* Truncation narrows the mode from SOURCE mode to DESTINATION mode. > If TARGET_MODE_REP_EXTENDED (DESTINATION, DESTINATION_REP) is > SIGN_EXTEND then while narrowing we also have to enforce the > @@ -78,6 +82,93 @@ static int non_rtx_starting_operands[NUM_RTX_CODE]; > static unsigned int > num_sign_bit_copies_in_rep[MAX_MODE_INT + 1][MAX_MODE_INT + 1]; > =0C > +/* Store X into index I of ARRAY. ARRAY is known to have at least I > + elements. Return the new base of ARRAY. */ > + > +template > +typename T::value_type * > +generic_subrtx_iterator ::add_single_to_queue (array_type &array, > + value_type *base, > + size_t i, value_type x) > +{ > + if (base =3D=3D array.stack) > + { > + if (i < LOCAL_ELEMS) > + { > + base[i] =3D x; > + return base; > + } it seems like this first little bit might be worth inlining, but I guess you tested and it wasn't. > + gcc_checking_assert (i =3D=3D LOCAL_ELEMS); > + vec_safe_grow (array.heap, i + 1); > + base =3D array.heap->address (); > + memcpy (base, array.stack, sizeof (array.stack)); that threw me for a sec until I realized it was just manually doing what auto_vec does in this case. > + base[LOCAL_ELEMS] =3D x; > + return base; > + } > + unsigned int length =3D array.heap->length (); > + if (length > i) > + { > + gcc_checking_assert (base =3D=3D array.heap->address ()); > + base[i] =3D x; > + return base; > + } > + else > + { > + gcc_checking_assert (i =3D=3D length); > + vec_safe_push (array.heap, x); > + return array.heap->address (); this chunk seems redundant with what vec_safe_push does do you actually need to pass in |i| at all? > + } > +} > + > +/* Add the subrtxes of X to worklist ARRAY, starting at END. Return the > + number of elements added to the worklist. */ > + > +template > +size_t > +generic_subrtx_iterator ::add_subrtxes_to_queue (array_type &array, > + value_type *base, > + size_t end, rtx_type x) > +{ > + const char *format =3D GET_RTX_FORMAT (GET_CODE (x)); > + size_t orig_end =3D end; > + for (int i =3D 0; format[i]; ++i) > + if (format[i] =3D=3D 'e') > + { > + value_type subx =3D T::get_value (x->u.fld[i].rt_rtx); > + if (__builtin_expect (end < LOCAL_ELEMS, true)) > + base[end++] =3D subx; > + else > + base =3D add_single_to_queue (array, base, end++, subx); > + } > + else if (format[i] =3D=3D 'E') > + { > + int length =3D GET_NUM_ELEM (x->u.fld[i].rt_rtvec); > + rtx *vec =3D x->u.fld[i].rt_rtvec->elem; > + if (__builtin_expect (end + length <=3D LOCAL_ELEMS, true)) > + for (int j =3D 0; j < length; j++) > + base[end++] =3D T::get_value (vec[j]); > + else > + for (int j =3D 0; j < length; j++) > + base =3D add_single_to_queue (array, base, end++, > + T::get_value (vec[j])); > + } > + return end - orig_end; > +} > + > +template > +void > +generic_subrtx_iterator ::free_array (array_type &array) > +{ > + vec_free (array.heap); > +} > + > +template > +const size_t generic_subrtx_iterator ::LOCAL_ELEMS; > + > +template class generic_subrtx_iterator ; > +template class generic_subrtx_iterator ; > +template class generic_subrtx_iterator ; > + > /* Return 1 if the value of X is unstable > (would be different at a different point in the program). > The frame pointer, arg pointer, etc. are considered stable > @@ -5324,8 +5415,42 @@ truncated_to_mode (enum machine_mode mode, const_r= tx x) > return false; > } > =0C > +/* Return true if RTX code CODE has a single sequence of zero or more > + "e" operands and no rtvec operands. Initialize its rtx_all_subrtx_bo= unds > + entry in that case. */ > + > +static bool > +setup_reg_subrtx_bounds (unsigned int code) > +{ > + const char *format =3D GET_RTX_FORMAT ((enum rtx_code) code); > + unsigned int i =3D 0; > + for (; format[i] !=3D 'e'; ++i) > + { > + if (!format[i]) > + /* No subrtxes. Leave start and count as 0. */ > + return true; > + if (format[i] =3D=3D 'E' || format[i] =3D=3D 'V') > + return false; > + } > + > + /* Record the sequence of 'e's. */ > + rtx_all_subrtx_bounds[code].start =3D i; > + do > + ++i; > + while (format[i] =3D=3D 'e'); > + rtx_all_subrtx_bounds[code].count =3D i - rtx_all_subrtx_bounds[code].= start; > + /* rtl-iter.h relies on this. */ > + gcc_checking_assert (rtx_all_subrtx_bounds[code].count <=3D 3); > + > + for (; format[i]; ++i) > + if (format[i] =3D=3D 'E' || format[i] =3D=3D 'V' || format[i] =3D=3D= 'e') > + return false; > + > + return true; > +} > + > /* Initialize non_rtx_starting_operands, which is used to speed up > - for_each_rtx. */ > + for_each_rtx, and rtx_all_subrtx_bounds. */ > void > init_rtlanal (void) > { > @@ -5335,6 +5460,10 @@ init_rtlanal (void) > const char *format =3D GET_RTX_FORMAT (i); > const char *first =3D strpbrk (format, "eEV"); > non_rtx_starting_operands[i] =3D first ? first - format : -1; > + if (!setup_reg_subrtx_bounds (i)) > + rtx_all_subrtx_bounds[i].count =3D UCHAR_MAX; > + if (GET_RTX_CLASS (i) !=3D RTX_CONST_OBJ) > + rtx_nonconst_subrtx_bounds[i] =3D rtx_all_subrtx_bounds[i]; > } >=20=20 > init_num_sign_bit_copies_in_rep (); --ReaqsoxgOBHFXBhH Content-Type: application/pgp-signature; name="signature.asc" Content-Description: Digital signature Content-length: 819 -----BEGIN PGP SIGNATURE----- Version: GnuPG v1 iQIcBAEBAgAGBQJTatwaAAoJEB+OKtVG4HCU+nQQAItKNk0+FMcVdojgtwemh+A0 kzoRsXnJO0HpR83YjKFp4J128BwYLFtTKTNRPwNGYg3jMpaJig/N0mNru9lW5/ZC FHcdnVzPKskn/ZgyZuvSPFEz5Je8TFoIY8cUDdLFQvbBZfcV3K4kq7UMoKKAXvGH 9c6ycA0FQUDg3WP+ZhRDaWl3OUjfHaUiDwYjSENxWZ+KYIW2GVcZ9B4O3SNUlmd6 Woqu4/Vwebz1Pu6eiIM1SxYSRLU2Oag8VwDFuOC+W6xgMnYp5tuGs8/s5rHYiXIN K7Mflm8OahX1DXIiN297SHfl645xRpOtlWg77EJiXZWfYTZPn2WylkwtYvWR3ymp JXkGB56xZM3HzyYuvQcvo57CdROtKTuJf1q7G2I8ng+j6MmpZWeUYtNqque8c29X jfiJSoiR3sB8YzxvFvU/lhrciw/lYaKU4Mm4CsYdn7GNF1yOn25CXrapYHarJfEZ m85VU8HkL82w28JViS4cWBPhN/PpD63BnMBKCk98kaPES8wV6+dnoRKyrB7op4UJ 4fVzyPKh2auFvLzYdXwKsZ1rbl+R+WBAsieIdgj+QqlukRoqqphpQFZNqL8SJWIs toIOxSGyep87gWHSqLr74Mh7IywveSrHSC8stEeCUJSADfphOV1KZNioNJo0q2vc ohy1i+s9o6Y+MctVW0dJ =gsOX -----END PGP SIGNATURE----- --ReaqsoxgOBHFXBhH--