From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id BD7363858431 for ; Mon, 22 May 2023 18:43:44 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org BD7363858431 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1684781024; 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: in-reply-to:in-reply-to:references:references; bh=ZwFFrCr5xii3+xJY7XWkV9KT4CnKER4bKmahH6RgCds=; b=ViQ9cFdm6+BhszhUHWu0WHjSKhNRQA4NmevtVceFvfYEGi9xejgfo8O39paUbany2wfuS9 OQDSW9leZ6a3L7kV4S8BYa11S3ZJu6WwkuNEgOEuK7TkVP3cm2jl/8TGjsvlB3MRedPoqu KufSdB9OfHeIrpnesJ3oIOCAM3ib5cg= Received: from mail-ed1-f70.google.com (mail-ed1-f70.google.com [209.85.208.70]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-641-cAQcUrT9PB-pvOhAYlC2MA-1; Mon, 22 May 2023 14:43:42 -0400 X-MC-Unique: cAQcUrT9PB-pvOhAYlC2MA-1 Received: by mail-ed1-f70.google.com with SMTP id 4fb4d7f45d1cf-50bc57d7967so7449487a12.2 for ; Mon, 22 May 2023 11:43:42 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1684781021; x=1687373021; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=ZwFFrCr5xii3+xJY7XWkV9KT4CnKER4bKmahH6RgCds=; b=XRUyc0f/80d1iRmv1CsVmSBGj8vjBAneiGJbD5/lwq7Rj9q0UOMG7FbWzxbv9FAaTw AvuSWz0MW1IPg/qiLHurs8tXMc8rUsO98i4bx+s9kQaku5OFw6SQKhvxXqosPXninU1h gIPnaGgZXaToFTi5YFMDrQRlKJhHtcAGwRJ6U9uOk4nw9+JT063XwLanGwsaQI+2HKVB fVqMxZeus5qcd1RkWCNLg/PmuBqOsVWAZAQP3c11SKP8so1XSXFiWQeCqsMHEpyC/RpK YZkB12FFLczqHpA2Qfo/Oanz5s6qAXIYPjX3CS1kt7IVr7XaTW/+OeUpoa5l6MR0Y0Lg aZ6w== X-Gm-Message-State: AC+VfDyilDzc/QDorgixbvk7588aSDqeCnUswkDMEdfNc0we+vx7VsM5 sbPeYvbbpjbyjEtqHII4lG9jxAC4e+RXz8lxYp9K+vH0/71i3x81lY5HaPDjFv9cNSBcKOqsTCP pQ5jjmY3QcbAxYAB5mZ22xfqedbdpkIIFqIxfA7qjhUm/ X-Received: by 2002:aa7:ce02:0:b0:50b:cff8:ff1f with SMTP id d2-20020aa7ce02000000b0050bcff8ff1fmr8958837edv.42.1684781021297; Mon, 22 May 2023 11:43:41 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ6+Vt9yYn9RHumvl50AxLlCExMa0FUdBaEk0y4R9teY6xunm8RggIQx+Z6d4ZUxgREIFivSQ1hJC7PHULtqic0= X-Received: by 2002:aa7:ce02:0:b0:50b:cff8:ff1f with SMTP id d2-20020aa7ce02000000b0050bcff8ff1fmr8958819edv.42.1684781020774; Mon, 22 May 2023 11:43:40 -0700 (PDT) MIME-Version: 1.0 References: <20230517143030.465081-1-aldyh@redhat.com> In-Reply-To: <20230517143030.465081-1-aldyh@redhat.com> From: Aldy Hernandez Date: Mon, 22 May 2023 20:43:29 +0200 Message-ID: Subject: Re: [PATCH] Convert ipcp_vr_lattice to type agnostic framework. To: GCC patches Cc: Andrew MacLeod , Martin Jambor X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: multipart/mixed; boundary="00000000000044accc05fc4ca66f" X-Spam-Status: No, score=-11.4 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,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 List-Id: --00000000000044accc05fc4ca66f Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable I've adjusted the patch with some minor cleanups that came up when I implemented the rest of the IPA revamp. Rested. OK? On Wed, May 17, 2023 at 4:31=E2=80=AFPM Aldy Hernandez w= rote: > > This converts the lattice to store ranges in Value_Range instead of > value_range (*) to make it type agnostic, and adjust all users > accordingly. > > I think it is a good example on converting from static ranges to more > general, type agnostic ones. > > I've been careful to make sure Value_Range never ends up on GC, since > it contains an int_range_max and can expand on-demand onto the heap. > Longer term storage for ranges should be done with vrange_storage, as > per the previous patch ("Provide an API for ipa_vr"). > > (*) I do know the Value_Range naming versus value_range is quite > annoying, but it was a judgement call last release for the eventual > migration to having "value_range" be a type agnostic range object. We > will ultimately rename Value_Range to value_range. > > OK for trunk? > > gcc/ChangeLog: > > * ipa-cp.cc (ipcp_vr_lattice::init): Take type argument. > (ipcp_vr_lattice::print): Call dump method. > (ipcp_vr_lattice::meet_with): Adjust for m_vr being a > Value_Range. > (ipcp_vr_lattice::meet_with_1): Make argument a reference. > (ipcp_vr_lattice::set_to_bottom): Add type argument. > (set_all_contains_variable): Same. > (initialize_node_lattices): Pass type when appropriate. > (ipa_vr_operation_and_type_effects): Make type agnostic. > (ipa_value_range_from_jfunc): Same. > (propagate_vr_across_jump_function): Same. > (propagate_constants_across_call): Same. > * ipa-fnsummary.cc (evaluate_conditions_for_known_args): Same. > (evaluate_properties_for_edge): Same. > * ipa-prop.cc (ipcp_update_vr): Same. > * ipa-prop.h (ipa_value_range_from_jfunc): Same. > (ipa_range_set_and_normalize): Same. > --- > gcc/ipa-cp.cc | 159 +++++++++++++++++++++++-------------------- > gcc/ipa-fnsummary.cc | 16 ++--- > gcc/ipa-prop.cc | 2 +- > gcc/ipa-prop.h | 19 ++---- > 4 files changed, 101 insertions(+), 95 deletions(-) > > diff --git a/gcc/ipa-cp.cc b/gcc/ipa-cp.cc > index d4b9d4ac27e..bd5b1da17b2 100644 > --- a/gcc/ipa-cp.cc > +++ b/gcc/ipa-cp.cc > @@ -343,20 +343,29 @@ private: > class ipcp_vr_lattice > { > public: > - value_range m_vr; > + Value_Range m_vr; > > inline bool bottom_p () const; > inline bool top_p () const; > - inline bool set_to_bottom (); > - bool meet_with (const value_range *p_vr); > + inline bool set_to_bottom (tree type); > + bool meet_with (const vrange &p_vr); > bool meet_with (const ipcp_vr_lattice &other); > - void init () { gcc_assert (m_vr.undefined_p ()); } > + void init (tree type); > void print (FILE * f); > > private: > - bool meet_with_1 (const value_range *other_vr); > + bool meet_with_1 (const vrange &other_vr); > }; > > +inline void > +ipcp_vr_lattice::init (tree type) > +{ > + if (type) > + m_vr.set_type (type); > + > + // Otherwise m_vr will default to unsupported_range. > +} > + > /* Structure containing lattices for a parameter itself and for pieces o= f > aggregates that are passed in the parameter or by a reference in a pa= rameter > plus some other useful flags. */ > @@ -585,7 +594,7 @@ ipcp_bits_lattice::print (FILE *f) > void > ipcp_vr_lattice::print (FILE * f) > { > - dump_value_range (f, &m_vr); > + m_vr.dump (f); > } > > /* Print all ipcp_lattices of all functions to F. */ > @@ -1016,14 +1025,14 @@ set_agg_lats_contain_variable (class ipcp_param_l= attices *plats) > bool > ipcp_vr_lattice::meet_with (const ipcp_vr_lattice &other) > { > - return meet_with_1 (&other.m_vr); > + return meet_with_1 (other.m_vr); > } > > /* Meet the current value of the lattice with value range described by V= R > lattice. */ > > bool > -ipcp_vr_lattice::meet_with (const value_range *p_vr) > +ipcp_vr_lattice::meet_with (const vrange &p_vr) > { > return meet_with_1 (p_vr); > } > @@ -1032,23 +1041,23 @@ ipcp_vr_lattice::meet_with (const value_range *p_= vr) > OTHER_VR lattice. Return TRUE if anything changed. */ > > bool > -ipcp_vr_lattice::meet_with_1 (const value_range *other_vr) > +ipcp_vr_lattice::meet_with_1 (const vrange &other_vr) > { > if (bottom_p ()) > return false; > > - if (other_vr->varying_p ()) > - return set_to_bottom (); > + if (other_vr.varying_p ()) > + return set_to_bottom (other_vr.type ()); > > bool res; > if (flag_checking) > { > - value_range save (m_vr); > - res =3D m_vr.union_ (*other_vr); > + Value_Range save (m_vr); > + res =3D m_vr.union_ (other_vr); > gcc_assert (res =3D=3D (m_vr !=3D save)); > } > else > - res =3D m_vr.union_ (*other_vr); > + res =3D m_vr.union_ (other_vr); > return res; > } > > @@ -1073,16 +1082,11 @@ ipcp_vr_lattice::bottom_p () const > previously was in a different state. */ > > bool > -ipcp_vr_lattice::set_to_bottom () > +ipcp_vr_lattice::set_to_bottom (tree type) > { > if (m_vr.varying_p ()) > return false; > - /* ?? We create all sorts of VARYING ranges for floats, structures, > - and other types which we cannot handle as ranges. We should > - probably avoid handling them throughout the pass, but it's easier > - to create a sensible VARYING here and let the lattice > - propagate. */ > - m_vr.set_varying (integer_type_node); > + m_vr.set_varying (type); > return true; > } > > @@ -1518,14 +1522,14 @@ intersect_argaggs_with (vec &el= ts, > return true is any of them has not been marked as such so far. */ > > static inline bool > -set_all_contains_variable (class ipcp_param_lattices *plats) > +set_all_contains_variable (class ipcp_param_lattices *plats, tree type) > { > bool ret; > ret =3D plats->itself.set_contains_variable (); > ret |=3D plats->ctxlat.set_contains_variable (); > ret |=3D set_agg_lats_contain_variable (plats); > ret |=3D plats->bits_lattice.set_to_bottom (); > - ret |=3D plats->m_value_range.set_to_bottom (); > + ret |=3D plats->m_value_range.set_to_bottom (type); > return ret; > } > > @@ -1653,6 +1657,7 @@ initialize_node_lattices (struct cgraph_node *node) > for (i =3D 0; i < ipa_get_param_count (info); i++) > { > ipcp_param_lattices *plats =3D ipa_get_parm_lattices (info, i); > + tree type =3D ipa_get_type (info, i); > if (disable > || !ipa_get_type (info, i) > || (pre_modified && (surviving_params.length () <=3D (unsigned)= i > @@ -1662,14 +1667,14 @@ initialize_node_lattices (struct cgraph_node *nod= e) > plats->ctxlat.set_to_bottom (); > set_agg_lats_to_bottom (plats); > plats->bits_lattice.set_to_bottom (); > - plats->m_value_range.m_vr =3D value_range (); > - plats->m_value_range.set_to_bottom (); > + plats->m_value_range.init (type); > + plats->m_value_range.set_to_bottom (type); > } > else > { > - plats->m_value_range.init (); > + plats->m_value_range.init (type); > if (variable) > - set_all_contains_variable (plats); > + set_all_contains_variable (plats, type); > } > } > > @@ -1903,8 +1908,8 @@ ipa_context_from_jfunc (ipa_node_params *info, cgra= ph_edge *cs, int csidx, > the result is a range or an anti-range. */ > > static bool > -ipa_vr_operation_and_type_effects (value_range *dst_vr, > - value_range *src_vr, > +ipa_vr_operation_and_type_effects (vrange &dst_vr, > + const vrange &src_vr, > enum tree_code operation, > tree dst_type, tree src_type) > { > @@ -1912,29 +1917,33 @@ ipa_vr_operation_and_type_effects (value_range *d= st_vr, > return false; > > range_op_handler handler (operation, dst_type); > - return (handler > - && handler.fold_range (*dst_vr, dst_type, > - *src_vr, value_range (dst_type)) > - && !dst_vr->varying_p () > - && !dst_vr->undefined_p ()); > + if (!handler) > + return false; > + > + Value_Range varying (dst_type); > + varying.set_varying (dst_type); > + > + return (handler.fold_range (dst_vr, dst_type, src_vr, varying) > + && !dst_vr.varying_p () > + && !dst_vr.undefined_p ()); > } > > /* Determine value_range of JFUNC given that INFO describes the caller n= ode or > the one it is inlined to, CS is the call graph edge corresponding to = JFUNC > and PARM_TYPE of the parameter. */ > > -value_range > -ipa_value_range_from_jfunc (ipa_node_params *info, cgraph_edge *cs, > +void > +ipa_value_range_from_jfunc (vrange &vr, > + ipa_node_params *info, cgraph_edge *cs, > ipa_jump_func *jfunc, tree parm_type) > { > - value_range vr; > if (jfunc->m_vr) > - ipa_vr_operation_and_type_effects (&vr, > - jfunc->m_vr, > + ipa_vr_operation_and_type_effects (vr, > + *jfunc->m_vr, > NOP_EXPR, parm_type, > jfunc->m_vr->type ()); > if (vr.singleton_p ()) > - return vr; > + return; > if (jfunc->type =3D=3D IPA_JF_PASS_THROUGH) > { > int idx; > @@ -1943,33 +1952,34 @@ ipa_value_range_from_jfunc (ipa_node_params *info= , cgraph_edge *cs, > ? cs->caller->inlined_to > : cs->caller); > if (!sum || !sum->m_vr) > - return vr; > + return; > > idx =3D ipa_get_jf_pass_through_formal_id (jfunc); > > if (!(*sum->m_vr)[idx].known_p ()) > - return vr; > + return; > tree vr_type =3D ipa_get_type (info, idx); > - value_range srcvr; > + Value_Range srcvr (vr_type); > (*sum->m_vr)[idx].get_vrange (srcvr, vr_type); > > enum tree_code operation =3D ipa_get_jf_pass_through_operation (jf= unc); > > if (TREE_CODE_CLASS (operation) =3D=3D tcc_unary) > { > - value_range res; > + Value_Range res (vr_type); > > - if (ipa_vr_operation_and_type_effects (&res, > - &srcvr, > + if (ipa_vr_operation_and_type_effects (res, > + srcvr, > operation, parm_type, > vr_type)) > vr.intersect (res); > } > else > { > - value_range op_res, res; > + Value_Range op_res (vr_type); > + Value_Range res (vr_type); > tree op =3D ipa_get_jf_pass_through_operand (jfunc); > - value_range op_vr; > + Value_Range op_vr (vr_type); > range_op_handler handler (operation, vr_type); > > ipa_range_set_and_normalize (op_vr, op); > @@ -1979,14 +1989,13 @@ ipa_value_range_from_jfunc (ipa_node_params *info= , cgraph_edge *cs, > || !handler.fold_range (op_res, vr_type, srcvr, op_vr)) > op_res.set_varying (vr_type); > > - if (ipa_vr_operation_and_type_effects (&res, > - &op_res, > + if (ipa_vr_operation_and_type_effects (res, > + op_res, > NOP_EXPR, parm_type, > vr_type)) > vr.intersect (res); > } > } > - return vr; > } > > /* Determine whether ITEM, jump function for an aggregate part, evaluate= s to a > @@ -2739,7 +2748,7 @@ propagate_vr_across_jump_function (cgraph_edge *cs,= ipa_jump_func *jfunc, > if (!param_type > || (!INTEGRAL_TYPE_P (param_type) > && !POINTER_TYPE_P (param_type))) > - return dest_lat->set_to_bottom (); > + return dest_lat->set_to_bottom (param_type); > > if (jfunc->type =3D=3D IPA_JF_PASS_THROUGH) > { > @@ -2751,12 +2760,12 @@ propagate_vr_across_jump_function (cgraph_edge *c= s, ipa_jump_func *jfunc, > tree operand_type =3D ipa_get_type (caller_info, src_idx); > > if (src_lats->m_value_range.bottom_p ()) > - return dest_lat->set_to_bottom (); > + return dest_lat->set_to_bottom (operand_type); > > - value_range vr; > + Value_Range vr (operand_type); > if (TREE_CODE_CLASS (operation) =3D=3D tcc_unary) > - ipa_vr_operation_and_type_effects (&vr, > - &src_lats->m_value_range.m_vr, > + ipa_vr_operation_and_type_effects (vr, > + src_lats->m_value_range.m_vr, > operation, param_type, > operand_type); > /* A crude way to prevent unbounded number of value range updates > @@ -2765,8 +2774,8 @@ propagate_vr_across_jump_function (cgraph_edge *cs,= ipa_jump_func *jfunc, > else if (!ipa_edge_within_scc (cs)) > { > tree op =3D ipa_get_jf_pass_through_operand (jfunc); > - value_range op_vr; > - value_range op_res,res; > + Value_Range op_vr (TREE_TYPE (op)); > + Value_Range op_res (operand_type); > range_op_handler handler (operation, operand_type); > > ipa_range_set_and_normalize (op_vr, op); > @@ -2777,8 +2786,8 @@ propagate_vr_across_jump_function (cgraph_edge *cs,= ipa_jump_func *jfunc, > src_lats->m_value_range.m_vr, op_vr= )) > op_res.set_varying (operand_type); > > - ipa_vr_operation_and_type_effects (&vr, > - &op_res, > + ipa_vr_operation_and_type_effects (vr, > + op_res, > NOP_EXPR, param_type, > operand_type); > } > @@ -2786,14 +2795,14 @@ propagate_vr_across_jump_function (cgraph_edge *c= s, ipa_jump_func *jfunc, > { > if (jfunc->m_vr) > { > - value_range jvr; > - if (ipa_vr_operation_and_type_effects (&jvr, jfunc->m_vr, > + Value_Range jvr (param_type); > + if (ipa_vr_operation_and_type_effects (jvr, *jfunc->m_vr, > NOP_EXPR, > param_type, > jfunc->m_vr->type ()= )) > vr.intersect (jvr); > } > - return dest_lat->meet_with (&vr); > + return dest_lat->meet_with (vr); > } > } > else if (jfunc->type =3D=3D IPA_JF_CONST) > @@ -2805,20 +2814,19 @@ propagate_vr_across_jump_function (cgraph_edge *c= s, ipa_jump_func *jfunc, > if (TREE_OVERFLOW_P (val)) > val =3D drop_tree_overflow (val); > > - value_range tmpvr (TREE_TYPE (val), > - wi::to_wide (val), wi::to_wide (val)); > - return dest_lat->meet_with (&tmpvr); > + Value_Range tmpvr (val, val); > + return dest_lat->meet_with (tmpvr); > } > } > > value_range vr; > if (jfunc->m_vr > - && ipa_vr_operation_and_type_effects (&vr, jfunc->m_vr, NOP_EXPR, > + && ipa_vr_operation_and_type_effects (vr, *jfunc->m_vr, NOP_EXPR, > param_type, > jfunc->m_vr->type ())) > - return dest_lat->meet_with (&vr); > + return dest_lat->meet_with (vr); > else > - return dest_lat->set_to_bottom (); > + return dest_lat->set_to_bottom (param_type); > } > > /* If DEST_PLATS already has aggregate items, check that aggs_by_ref mat= ches > @@ -3209,7 +3217,8 @@ propagate_constants_across_call (struct cgraph_edge= *cs) > { > for (i =3D 0; i < parms_count; i++) > ret |=3D set_all_contains_variable (ipa_get_parm_lattices (callee= _info, > - i)); > + i), > + ipa_get_type (callee_info, i)); > return ret; > } > args_count =3D ipa_get_cs_argument_count (args); > @@ -3220,7 +3229,8 @@ propagate_constants_across_call (struct cgraph_edge= *cs) > if (call_passes_through_thunk (cs)) > { > ret |=3D set_all_contains_variable (ipa_get_parm_lattices (callee_= info, > - 0)); > + 0), > + ipa_get_type (callee_info, 0)); > i =3D 1; > } > else > @@ -3234,7 +3244,7 @@ propagate_constants_across_call (struct cgraph_edge= *cs) > > dest_plats =3D ipa_get_parm_lattices (callee_info, i); > if (availability =3D=3D AVAIL_INTERPOSABLE) > - ret |=3D set_all_contains_variable (dest_plats); > + ret |=3D set_all_contains_variable (dest_plats, param_type); > else > { > ret |=3D propagate_scalar_across_jump_function (cs, jump_func, > @@ -3251,11 +3261,12 @@ propagate_constants_across_call (struct cgraph_ed= ge *cs) > ret |=3D propagate_vr_across_jump_function (cs, jump_func, > dest_plats, param_t= ype); > else > - ret |=3D dest_plats->m_value_range.set_to_bottom (); > + ret |=3D dest_plats->m_value_range.set_to_bottom (param_type)= ; > } > } > for (; i < parms_count; i++) > - ret |=3D set_all_contains_variable (ipa_get_parm_lattices (callee_in= fo, i)); > + ret |=3D set_all_contains_variable (ipa_get_parm_lattices (callee_in= fo, i), > + ipa_get_type (callee_info, i)); > > return ret; > } > diff --git a/gcc/ipa-fnsummary.cc b/gcc/ipa-fnsummary.cc > index b328bb8ce14..0474af8991e 100644 > --- a/gcc/ipa-fnsummary.cc > +++ b/gcc/ipa-fnsummary.cc > @@ -475,7 +475,7 @@ evaluate_conditions_for_known_args (struct cgraph_nod= e *node, > && !c->agg_contents > && (!val || TREE_CODE (val) !=3D INTEGER_CST)) > { > - value_range vr =3D avals->m_known_value_ranges[c->operand_num]; > + Value_Range vr (avals->m_known_value_ranges[c->operand_num]); > if (!vr.undefined_p () > && !vr.varying_p () > && (TYPE_SIZE (c->type) =3D=3D TYPE_SIZE (vr.type ()))) > @@ -630,8 +630,8 @@ evaluate_properties_for_edge (struct cgraph_edge *e, = bool inline_p, > || ipa_is_param_used_by_ipa_predicates (callee_pi, i)) > { > /* Determine if we know constant value of the parameter. = */ > - tree cst =3D ipa_value_from_jfunc (caller_parms_info, jf, > - ipa_get_type (callee_pi,= i)); > + tree type =3D ipa_get_type (callee_pi, i); > + tree cst =3D ipa_value_from_jfunc (caller_parms_info, jf,= type); > > if (!cst && e->call_stmt > && i < (int)gimple_call_num_args (e->call_stmt)) > @@ -659,10 +659,10 @@ evaluate_properties_for_edge (struct cgraph_edge *e= , bool inline_p, > && vrp_will_run_p (caller) > && ipa_is_param_used_by_ipa_predicates (callee_pi, i)= ) > { > - value_range vr > - =3D ipa_value_range_from_jfunc (caller_parms_info,= e, jf, > - ipa_get_type (callee= _pi, > - i)); > + Value_Range vr (type); > + > + ipa_value_range_from_jfunc (vr, caller_parms_info, e,= jf, > + ipa_get_type (callee_pi, = i)); > if (!vr.undefined_p () && !vr.varying_p ()) > { > if (!avals->m_known_value_ranges.length ()) > @@ -670,7 +670,7 @@ evaluate_properties_for_edge (struct cgraph_edge *e, = bool inline_p, > avals->m_known_value_ranges.safe_grow (count,= true); > for (int i =3D 0; i < count; ++i) > new (&avals->m_known_value_ranges[i]) > - value_range (); > + Value_Range (); > } > avals->m_known_value_ranges[i] =3D vr; > } > diff --git a/gcc/ipa-prop.cc b/gcc/ipa-prop.cc > index 4ace410de49..1a71d7969ea 100644 > --- a/gcc/ipa-prop.cc > +++ b/gcc/ipa-prop.cc > @@ -5939,7 +5939,7 @@ ipcp_update_vr (struct cgraph_node *node) > if (vr[i].known_p ()) > { > tree type =3D TREE_TYPE (ddef); > - value_range tmp; > + Value_Range tmp (type); > vr[i].get_vrange (tmp, type); > > if (!tmp.undefined_p () && !tmp.varying_p ()) > diff --git a/gcc/ipa-prop.h b/gcc/ipa-prop.h > index 3b580ebb903..3921e33940d 100644 > --- a/gcc/ipa-prop.h > +++ b/gcc/ipa-prop.h > @@ -530,7 +530,7 @@ public: > auto_vec m_known_aggs; > > /* Vector describing known value ranges of arguments. */ > - auto_vec m_known_value_ranges; > + auto_vec m_known_value_ranges; > }; > > inline > @@ -582,7 +582,7 @@ public: > vec m_known_aggs =3D vNULL; > > /* Vector describing known value ranges of arguments. */ > - vec m_known_value_ranges =3D vNULL; > + vec m_known_value_ranges =3D vNULL; > }; > > inline > @@ -1194,8 +1194,8 @@ ipa_polymorphic_call_context ipa_context_from_jfunc= (ipa_node_params *, > cgraph_edge *, > int, > ipa_jump_func *); > -value_range ipa_value_range_from_jfunc (ipa_node_params *, cgraph_edge *= , > - ipa_jump_func *, tree); > +void ipa_value_range_from_jfunc (vrange &, ipa_node_params *, cgraph_edg= e *, > + ipa_jump_func *, tree); > void ipa_push_agg_values_from_jfunc (ipa_node_params *info, cgraph_node = *node, > ipa_agg_jump_function *agg_jfunc, > unsigned dst_index, > @@ -1218,17 +1218,12 @@ void ipa_cp_cc_finalize (void); > non-zero. */ > > inline void > -ipa_range_set_and_normalize (irange &r, tree val) > +ipa_range_set_and_normalize (vrange &r, tree val) > { > - if (TREE_CODE (val) =3D=3D INTEGER_CST) > - { > - wide_int w =3D wi::to_wide (val); > - r.set (TREE_TYPE (val), w, w); > - } > - else if (TREE_CODE (val) =3D=3D ADDR_EXPR) > + if (TREE_CODE (val) =3D=3D ADDR_EXPR) > r.set_nonzero (TREE_TYPE (val)); > else > - r.set_varying (TREE_TYPE (val)); > + r.set (val, val); > } > > #endif /* IPA_PROP_H */ > -- > 2.40.0 > --00000000000044accc05fc4ca66f Content-Type: text/x-patch; charset="US-ASCII"; name="0002-Convert-ipcp_vr_lattice-to-type-agnostic-framework.patch" Content-Disposition: attachment; filename="0002-Convert-ipcp_vr_lattice-to-type-agnostic-framework.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lhz73sbm0 RnJvbSA5ZGFhZTAwOTA4YjVlNDdjYWU2YmQwZGFkN2JkNGRkMDM5ZmMyYjY0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbGR5IEhlcm5hbmRleiA8YWxkeWhAcmVkaGF0LmNvbT4KRGF0 ZTogV2VkLCAxNyBNYXkgMjAyMyAxMToyOTozNCArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIENvbnZl cnQgaXBjcF92cl9sYXR0aWNlIHRvIHR5cGUgYWdub3N0aWMgZnJhbWV3b3JrLgoKVGhpcyBjb252 ZXJ0cyB0aGUgbGF0dGljZSB0byBzdG9yZSByYW5nZXMgaW4gVmFsdWVfUmFuZ2UgaW5zdGVhZCBv Zgp2YWx1ZV9yYW5nZSAoKikgdG8gbWFrZSBpdCB0eXBlIGFnbm9zdGljLCBhbmQgYWRqdXN0IGFs bCB1c2VycwphY2NvcmRpbmdseS4KCkkgdGhpbmsgaXQgaXMgYSBnb29kIGV4YW1wbGUgb24gY29u dmVydGluZyBmcm9tIHN0YXRpYyByYW5nZXMgdG8gbW9yZQpnZW5lcmFsLCB0eXBlIGFnbm9zdGlj IG9uZXMuCgpJJ3ZlIGJlZW4gY2FyZWZ1bCB0byBtYWtlIHN1cmUgVmFsdWVfUmFuZ2UgbmV2ZXIg ZW5kcyB1cCBvbiBHQywgc2luY2UKaXQgY29udGFpbnMgYW4gaW50X3JhbmdlX21heCBhbmQgY2Fu IGV4cGFuZCBvbi1kZW1hbmQgb250byB0aGUgaGVhcC4KTG9uZ2VyIHRlcm0gc3RvcmFnZSBmb3Ig cmFuZ2VzIHNob3VsZCBiZSBkb25lIHdpdGggdnJhbmdlX3N0b3JhZ2UsIGFzCnBlciB0aGUgcHJl dmlvdXMgcGF0Y2ggKCJQcm92aWRlIGFuIEFQSSBmb3IgaXBhX3ZyIikuCgooKikgSSBkbyBrbm93 IHRoZSBWYWx1ZV9SYW5nZSBuYW1pbmcgdmVyc3VzIHZhbHVlX3JhbmdlIGlzIHF1aXRlCmFubm95 aW5nLCBidXQgaXQgd2FzIGEganVkZ2VtZW50IGNhbGwgbGFzdCByZWxlYXNlIGZvciB0aGUgZXZl bnR1YWwKbWlncmF0aW9uIHRvIGhhdmluZyAidmFsdWVfcmFuZ2UiIGJlIGEgdHlwZSBhZ25vc3Rp YyByYW5nZSBvYmplY3QuICBXZQp3aWxsIHVsdGltYXRlbHkgcmVuYW1lIFZhbHVlX1JhbmdlIHRv IHZhbHVlX3JhbmdlLgoKZ2NjL0NoYW5nZUxvZzoKCgkqIGlwYS1jcC5jYyAoaXBjcF92cl9sYXR0 aWNlOjppbml0KTogVGFrZSB0eXBlIGFyZ3VtZW50LgoJKGlwY3BfdnJfbGF0dGljZTo6cHJpbnQp OiBDYWxsIGR1bXAgbWV0aG9kLgoJKGlwY3BfdnJfbGF0dGljZTo6bWVldF93aXRoKTogQWRqdXN0 IGZvciBtX3ZyIGJlaW5nIGEKCVZhbHVlX1JhbmdlLgoJKGlwY3BfdnJfbGF0dGljZTo6bWVldF93 aXRoXzEpOiBNYWtlIGFyZ3VtZW50IGEgcmVmZXJlbmNlLgoJKGlwY3BfdnJfbGF0dGljZTo6c2V0 X3RvX2JvdHRvbSk6IEFkZCB0eXBlIGFyZ3VtZW50LgoJKHNldF9hbGxfY29udGFpbnNfdmFyaWFi bGUpOiBTYW1lLgoJKGluaXRpYWxpemVfbm9kZV9sYXR0aWNlcyk6IFBhc3MgdHlwZSB3aGVuIGFw cHJvcHJpYXRlLgoJKGlwYV92cl9vcGVyYXRpb25fYW5kX3R5cGVfZWZmZWN0cyk6IE1ha2UgdHlw ZSBhZ25vc3RpYy4KCShpcGFfdmFsdWVfcmFuZ2VfZnJvbV9qZnVuYyk6IFNhbWUuCgkocHJvcGFn YXRlX3ZyX2Fjcm9zc19qdW1wX2Z1bmN0aW9uKTogU2FtZS4KCShwcm9wYWdhdGVfY29uc3RhbnRz X2Fjcm9zc19jYWxsKTogU2FtZS4KCSogaXBhLWZuc3VtbWFyeS5jYyAoZXZhbHVhdGVfY29uZGl0 aW9uc19mb3Jfa25vd25fYXJncyk6IFNhbWUuCgkoZXZhbHVhdGVfcHJvcGVydGllc19mb3JfZWRn ZSk6IFNhbWUuCgkqIGlwYS1wcm9wLmNjIChpcGNwX3VwZGF0ZV92cik6IFNhbWUuCgkqIGlwYS1w cm9wLmggKGlwYV92YWx1ZV9yYW5nZV9mcm9tX2pmdW5jKTogU2FtZS4KCShpcGFfcmFuZ2Vfc2V0 X2FuZF9ub3JtYWxpemUpOiBTYW1lLgotLS0KIGdjYy9pcGEtY3AuY2MgICAgICAgIHwgMTcxICsr KysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGdjYy9pcGEtZm5zdW1t YXJ5LmNjIHwgIDE2ICsrLS0KIGdjYy9pcGEtcHJvcC5jYyAgICAgIHwgICA1ICstCiBnY2MvaXBh LXByb3AuaCAgICAgICB8ICAyMSArKy0tLS0KIDQgZmlsZXMgY2hhbmdlZCwgMTEwIGluc2VydGlv bnMoKyksIDEwMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9nY2MvaXBhLWNwLmNjIGIvZ2Nj L2lwYS1jcC5jYwppbmRleCAwZjM3YmI1ZTMzNi4uYmRiYzIxODRiNWYgMTAwNjQ0Ci0tLSBhL2dj Yy9pcGEtY3AuY2MKKysrIGIvZ2NjL2lwYS1jcC5jYwpAQCAtMzQzLDIwICszNDMsMjkgQEAgcHJp dmF0ZToKIGNsYXNzIGlwY3BfdnJfbGF0dGljZQogewogcHVibGljOgotICB2YWx1ZV9yYW5nZSBt X3ZyOworICBWYWx1ZV9SYW5nZSBtX3ZyOwogCiAgIGlubGluZSBib29sIGJvdHRvbV9wICgpIGNv bnN0OwogICBpbmxpbmUgYm9vbCB0b3BfcCAoKSBjb25zdDsKLSAgaW5saW5lIGJvb2wgc2V0X3Rv X2JvdHRvbSAoKTsKLSAgYm9vbCBtZWV0X3dpdGggKGNvbnN0IHZhbHVlX3JhbmdlICpwX3ZyKTsK KyAgaW5saW5lIGJvb2wgc2V0X3RvX2JvdHRvbSAodHJlZSB0eXBlKTsKKyAgYm9vbCBtZWV0X3dp dGggKGNvbnN0IHZyYW5nZSAmcF92cik7CiAgIGJvb2wgbWVldF93aXRoIChjb25zdCBpcGNwX3Zy X2xhdHRpY2UgJm90aGVyKTsKLSAgdm9pZCBpbml0ICgpIHsgZ2NjX2Fzc2VydCAobV92ci51bmRl ZmluZWRfcCAoKSk7IH0KKyAgdm9pZCBpbml0ICh0cmVlIHR5cGUpOwogICB2b2lkIHByaW50IChG SUxFICogZik7CiAKIHByaXZhdGU6Ci0gIGJvb2wgbWVldF93aXRoXzEgKGNvbnN0IHZhbHVlX3Jh bmdlICpvdGhlcl92cik7CisgIGJvb2wgbWVldF93aXRoXzEgKGNvbnN0IHZyYW5nZSAmb3RoZXJf dnIpOwogfTsKIAoraW5saW5lIHZvaWQKK2lwY3BfdnJfbGF0dGljZTo6aW5pdCAodHJlZSB0eXBl KQoreworICBpZiAodHlwZSkKKyAgICBtX3ZyLnNldF90eXBlICh0eXBlKTsKKworICAvLyBPdGhl cndpc2UgbV92ciB3aWxsIGRlZmF1bHQgdG8gdW5zdXBwb3J0ZWRfcmFuZ2UuCit9CisKIC8qIFN0 cnVjdHVyZSBjb250YWluaW5nIGxhdHRpY2VzIGZvciBhIHBhcmFtZXRlciBpdHNlbGYgYW5kIGZv ciBwaWVjZXMgb2YKICAgIGFnZ3JlZ2F0ZXMgdGhhdCBhcmUgcGFzc2VkIGluIHRoZSBwYXJhbWV0 ZXIgb3IgYnkgYSByZWZlcmVuY2UgaW4gYSBwYXJhbWV0ZXIKICAgIHBsdXMgc29tZSBvdGhlciB1 c2VmdWwgZmxhZ3MuICAqLwpAQCAtNTg1LDcgKzU5NCw3IEBAIGlwY3BfYml0c19sYXR0aWNlOjpw cmludCAoRklMRSAqZikKIHZvaWQKIGlwY3BfdnJfbGF0dGljZTo6cHJpbnQgKEZJTEUgKiBmKQog ewotICBkdW1wX3ZhbHVlX3JhbmdlIChmLCAmbV92cik7CisgIG1fdnIuZHVtcCAoZik7CiB9CiAK IC8qIFByaW50IGFsbCBpcGNwX2xhdHRpY2VzIG9mIGFsbCBmdW5jdGlvbnMgdG8gRi4gICovCkBA IC0xMDE2LDM5ICsxMDI1LDM5IEBAIHNldF9hZ2dfbGF0c19jb250YWluX3ZhcmlhYmxlIChjbGFz cyBpcGNwX3BhcmFtX2xhdHRpY2VzICpwbGF0cykKIGJvb2wKIGlwY3BfdnJfbGF0dGljZTo6bWVl dF93aXRoIChjb25zdCBpcGNwX3ZyX2xhdHRpY2UgJm90aGVyKQogewotICByZXR1cm4gbWVldF93 aXRoXzEgKCZvdGhlci5tX3ZyKTsKKyAgcmV0dXJuIG1lZXRfd2l0aF8xIChvdGhlci5tX3ZyKTsK IH0KIAotLyogTWVldCB0aGUgY3VycmVudCB2YWx1ZSBvZiB0aGUgbGF0dGljZSB3aXRoIHZhbHVl IHJhbmdlIGRlc2NyaWJlZCBieSBWUgotICAgbGF0dGljZS4gICovCisvKiBNZWV0IHRoZSBjdXJy ZW50IHZhbHVlIG9mIHRoZSBsYXR0aWNlIHdpdGggdGhlIHJhbmdlIGRlc2NyaWJlZCBieQorICAg UF9WUi4gICovCiAKIGJvb2wKLWlwY3BfdnJfbGF0dGljZTo6bWVldF93aXRoIChjb25zdCB2YWx1 ZV9yYW5nZSAqcF92cikKK2lwY3BfdnJfbGF0dGljZTo6bWVldF93aXRoIChjb25zdCB2cmFuZ2Ug JnBfdnIpCiB7CiAgIHJldHVybiBtZWV0X3dpdGhfMSAocF92cik7CiB9CiAKLS8qIE1lZXQgdGhl IGN1cnJlbnQgdmFsdWUgb2YgdGhlIGxhdHRpY2Ugd2l0aCB2YWx1ZSByYW5nZSBkZXNjcmliZWQg YnkKLSAgIE9USEVSX1ZSIGxhdHRpY2UuICBSZXR1cm4gVFJVRSBpZiBhbnl0aGluZyBjaGFuZ2Vk LiAgKi8KKy8qIE1lZXQgdGhlIGN1cnJlbnQgdmFsdWUgb2YgdGhlIGxhdHRpY2Ugd2l0aCB0aGUg cmFuZ2UgZGVzY3JpYmVkIGJ5CisgICBPVEhFUl9WUi4gIFJldHVybiBUUlVFIGlmIGFueXRoaW5n IGNoYW5nZWQuICAqLwogCiBib29sCi1pcGNwX3ZyX2xhdHRpY2U6Om1lZXRfd2l0aF8xIChjb25z dCB2YWx1ZV9yYW5nZSAqb3RoZXJfdnIpCitpcGNwX3ZyX2xhdHRpY2U6Om1lZXRfd2l0aF8xIChj b25zdCB2cmFuZ2UgJm90aGVyX3ZyKQogewogICBpZiAoYm90dG9tX3AgKCkpCiAgICAgcmV0dXJu IGZhbHNlOwogCi0gIGlmIChvdGhlcl92ci0+dmFyeWluZ19wICgpKQotICAgIHJldHVybiBzZXRf dG9fYm90dG9tICgpOworICBpZiAob3RoZXJfdnIudmFyeWluZ19wICgpKQorICAgIHJldHVybiBz ZXRfdG9fYm90dG9tIChvdGhlcl92ci50eXBlICgpKTsKIAogICBib29sIHJlczsKICAgaWYgKGZs YWdfY2hlY2tpbmcpCiAgICAgewotICAgICAgdmFsdWVfcmFuZ2Ugc2F2ZSAobV92cik7Ci0gICAg ICByZXMgPSBtX3ZyLnVuaW9uXyAoKm90aGVyX3ZyKTsKKyAgICAgIFZhbHVlX1JhbmdlIHNhdmUg KG1fdnIpOworICAgICAgcmVzID0gbV92ci51bmlvbl8gKG90aGVyX3ZyKTsKICAgICAgIGdjY19h c3NlcnQgKHJlcyA9PSAobV92ciAhPSBzYXZlKSk7CiAgICAgfQogICBlbHNlCi0gICAgcmVzID0g bV92ci51bmlvbl8gKCpvdGhlcl92cik7CisgICAgcmVzID0gbV92ci51bmlvbl8gKG90aGVyX3Zy KTsKICAgcmV0dXJuIHJlczsKIH0KIApAQCAtMTA3MywxNiArMTA4MiwxMSBAQCBpcGNwX3ZyX2xh dHRpY2U6OmJvdHRvbV9wICgpIGNvbnN0CiAgICBwcmV2aW91c2x5IHdhcyBpbiBhIGRpZmZlcmVu dCBzdGF0ZS4gICovCiAKIGJvb2wKLWlwY3BfdnJfbGF0dGljZTo6c2V0X3RvX2JvdHRvbSAoKQor aXBjcF92cl9sYXR0aWNlOjpzZXRfdG9fYm90dG9tICh0cmVlIHR5cGUpCiB7CiAgIGlmIChtX3Zy LnZhcnlpbmdfcCAoKSkKICAgICByZXR1cm4gZmFsc2U7Ci0gIC8qID8/IFdlIGNyZWF0ZSBhbGwg c29ydHMgb2YgVkFSWUlORyByYW5nZXMgZm9yIGZsb2F0cywgc3RydWN0dXJlcywKLSAgICAgYW5k IG90aGVyIHR5cGVzIHdoaWNoIHdlIGNhbm5vdCBoYW5kbGUgYXMgcmFuZ2VzLiAgV2Ugc2hvdWxk Ci0gICAgIHByb2JhYmx5IGF2b2lkIGhhbmRsaW5nIHRoZW0gdGhyb3VnaG91dCB0aGUgcGFzcywg YnV0IGl0J3MgZWFzaWVyCi0gICAgIHRvIGNyZWF0ZSBhIHNlbnNpYmxlIFZBUllJTkcgaGVyZSBh bmQgbGV0IHRoZSBsYXR0aWNlCi0gICAgIHByb3BhZ2F0ZS4gICovCi0gIG1fdnIuc2V0X3Zhcnlp bmcgKGludGVnZXJfdHlwZV9ub2RlKTsKKyAgbV92ci5zZXRfdmFyeWluZyAodHlwZSk7CiAgIHJl dHVybiB0cnVlOwogfQogCkBAIC0xNTE4LDE0ICsxNTIyLDE0IEBAIGludGVyc2VjdF9hcmdhZ2dz X3dpdGggKHZlYzxpcGFfYXJnYWdnX3ZhbHVlPiAmZWx0cywKICAgIHJldHVybiB0cnVlIGlzIGFu eSBvZiB0aGVtIGhhcyBub3QgYmVlbiBtYXJrZWQgYXMgc3VjaCBzbyBmYXIuICAqLwogCiBzdGF0 aWMgaW5saW5lIGJvb2wKLXNldF9hbGxfY29udGFpbnNfdmFyaWFibGUgKGNsYXNzIGlwY3BfcGFy YW1fbGF0dGljZXMgKnBsYXRzKQorc2V0X2FsbF9jb250YWluc192YXJpYWJsZSAoY2xhc3MgaXBj cF9wYXJhbV9sYXR0aWNlcyAqcGxhdHMsIHRyZWUgdHlwZSkKIHsKICAgYm9vbCByZXQ7CiAgIHJl dCA9IHBsYXRzLT5pdHNlbGYuc2V0X2NvbnRhaW5zX3ZhcmlhYmxlICgpOwogICByZXQgfD0gcGxh dHMtPmN0eGxhdC5zZXRfY29udGFpbnNfdmFyaWFibGUgKCk7CiAgIHJldCB8PSBzZXRfYWdnX2xh dHNfY29udGFpbl92YXJpYWJsZSAocGxhdHMpOwogICByZXQgfD0gcGxhdHMtPmJpdHNfbGF0dGlj ZS5zZXRfdG9fYm90dG9tICgpOwotICByZXQgfD0gcGxhdHMtPm1fdmFsdWVfcmFuZ2Uuc2V0X3Rv X2JvdHRvbSAoKTsKKyAgcmV0IHw9IHBsYXRzLT5tX3ZhbHVlX3JhbmdlLnNldF90b19ib3R0b20g KHR5cGUpOwogICByZXR1cm4gcmV0OwogfQogCkBAIC0xNjUzLDYgKzE2NTcsNyBAQCBpbml0aWFs aXplX25vZGVfbGF0dGljZXMgKHN0cnVjdCBjZ3JhcGhfbm9kZSAqbm9kZSkKICAgZm9yIChpID0g MDsgaSA8IGlwYV9nZXRfcGFyYW1fY291bnQgKGluZm8pOyBpKyspCiAgICAgewogICAgICAgaXBj cF9wYXJhbV9sYXR0aWNlcyAqcGxhdHMgPSBpcGFfZ2V0X3Bhcm1fbGF0dGljZXMgKGluZm8sIGkp OworICAgICAgdHJlZSB0eXBlID0gaXBhX2dldF90eXBlIChpbmZvLCBpKTsKICAgICAgIGlmIChk aXNhYmxlCiAJICB8fCAhaXBhX2dldF90eXBlIChpbmZvLCBpKQogCSAgfHwgKHByZV9tb2RpZmll ZCAmJiAoc3Vydml2aW5nX3BhcmFtcy5sZW5ndGggKCkgPD0gKHVuc2lnbmVkKSBpCkBAIC0xNjYy LDE0ICsxNjY3LDE0IEBAIGluaXRpYWxpemVfbm9kZV9sYXR0aWNlcyAoc3RydWN0IGNncmFwaF9u b2RlICpub2RlKQogCSAgcGxhdHMtPmN0eGxhdC5zZXRfdG9fYm90dG9tICgpOwogCSAgc2V0X2Fn Z19sYXRzX3RvX2JvdHRvbSAocGxhdHMpOwogCSAgcGxhdHMtPmJpdHNfbGF0dGljZS5zZXRfdG9f Ym90dG9tICgpOwotCSAgcGxhdHMtPm1fdmFsdWVfcmFuZ2UubV92ciA9IHZhbHVlX3JhbmdlICgp OwotCSAgcGxhdHMtPm1fdmFsdWVfcmFuZ2Uuc2V0X3RvX2JvdHRvbSAoKTsKKwkgIHBsYXRzLT5t X3ZhbHVlX3JhbmdlLmluaXQgKHR5cGUpOworCSAgcGxhdHMtPm1fdmFsdWVfcmFuZ2Uuc2V0X3Rv X2JvdHRvbSAodHlwZSk7CiAJfQogICAgICAgZWxzZQogCXsKLQkgIHBsYXRzLT5tX3ZhbHVlX3Jh bmdlLmluaXQgKCk7CisJICBwbGF0cy0+bV92YWx1ZV9yYW5nZS5pbml0ICh0eXBlKTsKIAkgIGlm ICh2YXJpYWJsZSkKLQkgICAgc2V0X2FsbF9jb250YWluc192YXJpYWJsZSAocGxhdHMpOworCSAg ICBzZXRfYWxsX2NvbnRhaW5zX3ZhcmlhYmxlIChwbGF0cywgdHlwZSk7CiAJfQogICAgIH0KIApA QCAtMTkwMCwxMSArMTkwNSwxMSBAQCBpcGFfY29udGV4dF9mcm9tX2pmdW5jIChpcGFfbm9kZV9w YXJhbXMgKmluZm8sIGNncmFwaF9lZGdlICpjcywgaW50IGNzaWR4LAogCiAvKiBFbXVsYXRlIGVm ZmVjdHMgb2YgdW5hcnkgT1BFUkFUSU9OIGFuZC9vciBjb252ZXJzaW9uIGZyb20gU1JDX1RZUEUg dG8KICAgIERTVF9UWVBFIG9uIHZhbHVlIHJhbmdlIGluIFNSQ19WUiBhbmQgc3RvcmUgaXQgdG8g RFNUX1ZSLiAgUmV0dXJuIHRydWUgaWYKLSAgIHRoZSByZXN1bHQgaXMgYSByYW5nZSBvciBhbiBh bnRpLXJhbmdlLiAgKi8KKyAgIHRoZSByZXN1bHQgaXMgYSByYW5nZSB0aGF0IGlzIG5vdCBWQVJZ SU5HIG5vciBVTkRFRklORUQuICAqLwogCiBzdGF0aWMgYm9vbAotaXBhX3ZyX29wZXJhdGlvbl9h bmRfdHlwZV9lZmZlY3RzICh2YWx1ZV9yYW5nZSAqZHN0X3ZyLAotCQkJCSAgIHZhbHVlX3Jhbmdl ICpzcmNfdnIsCitpcGFfdnJfb3BlcmF0aW9uX2FuZF90eXBlX2VmZmVjdHMgKHZyYW5nZSAmZHN0 X3ZyLAorCQkJCSAgIGNvbnN0IHZyYW5nZSAmc3JjX3ZyLAogCQkJCSAgIGVudW0gdHJlZV9jb2Rl IG9wZXJhdGlvbiwKIAkJCQkgICB0cmVlIGRzdF90eXBlLCB0cmVlIHNyY190eXBlKQogewpAQCAt MTkxMiwyOSArMTkxNywzMyBAQCBpcGFfdnJfb3BlcmF0aW9uX2FuZF90eXBlX2VmZmVjdHMgKHZh bHVlX3JhbmdlICpkc3RfdnIsCiAgICAgcmV0dXJuIGZhbHNlOwogCiAgIHJhbmdlX29wX2hhbmRs ZXIgaGFuZGxlciAob3BlcmF0aW9uLCBkc3RfdHlwZSk7Ci0gIHJldHVybiAoaGFuZGxlcgotCSAg JiYgaGFuZGxlci5mb2xkX3JhbmdlICgqZHN0X3ZyLCBkc3RfdHlwZSwKLQkJCQkgKnNyY192ciwg dmFsdWVfcmFuZ2UgKGRzdF90eXBlKSkKLQkgICYmICFkc3RfdnItPnZhcnlpbmdfcCAoKQotCSAg JiYgIWRzdF92ci0+dW5kZWZpbmVkX3AgKCkpOworICBpZiAoIWhhbmRsZXIpCisgICAgcmV0dXJu IGZhbHNlOworCisgIFZhbHVlX1JhbmdlIHZhcnlpbmcgKGRzdF90eXBlKTsKKyAgdmFyeWluZy5z ZXRfdmFyeWluZyAoZHN0X3R5cGUpOworCisgIHJldHVybiAoaGFuZGxlci5mb2xkX3JhbmdlIChk c3RfdnIsIGRzdF90eXBlLCBzcmNfdnIsIHZhcnlpbmcpCisJICAmJiAhZHN0X3ZyLnZhcnlpbmdf cCAoKQorCSAgJiYgIWRzdF92ci51bmRlZmluZWRfcCAoKSk7CiB9CiAKIC8qIERldGVybWluZSBy YW5nZSBvZiBKRlVOQyBnaXZlbiB0aGF0IElORk8gZGVzY3JpYmVzIHRoZSBjYWxsZXIgbm9kZSBv cgogICAgdGhlIG9uZSBpdCBpcyBpbmxpbmVkIHRvLCBDUyBpcyB0aGUgY2FsbCBncmFwaCBlZGdl IGNvcnJlc3BvbmRpbmcgdG8gSkZVTkMKICAgIGFuZCBQQVJNX1RZUEUgb2YgdGhlIHBhcmFtZXRl ci4gICovCiAKLXZhbHVlX3JhbmdlCi1pcGFfdmFsdWVfcmFuZ2VfZnJvbV9qZnVuYyAoaXBhX25v ZGVfcGFyYW1zICppbmZvLCBjZ3JhcGhfZWRnZSAqY3MsCit2b2lkCitpcGFfdmFsdWVfcmFuZ2Vf ZnJvbV9qZnVuYyAodnJhbmdlICZ2ciwKKwkJCSAgICBpcGFfbm9kZV9wYXJhbXMgKmluZm8sIGNn cmFwaF9lZGdlICpjcywKIAkJCSAgICBpcGFfanVtcF9mdW5jICpqZnVuYywgdHJlZSBwYXJtX3R5 cGUpCiB7Ci0gIHZhbHVlX3JhbmdlIHZyOwogICBpZiAoamZ1bmMtPm1fdnIpCi0gICAgaXBhX3Zy X29wZXJhdGlvbl9hbmRfdHlwZV9lZmZlY3RzICgmdnIsCi0JCQkJICAgICAgIGpmdW5jLT5tX3Zy LAorICAgIGlwYV92cl9vcGVyYXRpb25fYW5kX3R5cGVfZWZmZWN0cyAodnIsCisJCQkJICAgICAg ICpqZnVuYy0+bV92ciwKIAkJCQkgICAgICAgTk9QX0VYUFIsIHBhcm1fdHlwZSwKIAkJCQkgICAg ICAgamZ1bmMtPm1fdnItPnR5cGUgKCkpOwogICBpZiAodnIuc2luZ2xldG9uX3AgKCkpCi0gICAg cmV0dXJuIHZyOworICAgIHJldHVybjsKICAgaWYgKGpmdW5jLT50eXBlID09IElQQV9KRl9QQVNT X1RIUk9VR0gpCiAgICAgewogICAgICAgaW50IGlkeDsKQEAgLTE5NDMsMzMgKzE5NTIsMzQgQEAg aXBhX3ZhbHVlX3JhbmdlX2Zyb21famZ1bmMgKGlwYV9ub2RlX3BhcmFtcyAqaW5mbywgY2dyYXBo X2VkZ2UgKmNzLAogCQkJCQkgICA/IGNzLT5jYWxsZXItPmlubGluZWRfdG8KIAkJCQkJICAgOiBj cy0+Y2FsbGVyKTsKICAgICAgIGlmICghc3VtIHx8ICFzdW0tPm1fdnIpCi0JcmV0dXJuIHZyOwor CXJldHVybjsKIAogICAgICAgaWR4ID0gaXBhX2dldF9qZl9wYXNzX3Rocm91Z2hfZm9ybWFsX2lk IChqZnVuYyk7CiAKICAgICAgIGlmICghKCpzdW0tPm1fdnIpW2lkeF0ua25vd25fcCAoKSkKLQly ZXR1cm4gdnI7CisJcmV0dXJuOwogICAgICAgdHJlZSB2cl90eXBlID0gaXBhX2dldF90eXBlIChp bmZvLCBpZHgpOwotICAgICAgdmFsdWVfcmFuZ2Ugc3JjdnI7CisgICAgICBWYWx1ZV9SYW5nZSBz cmN2cjsKICAgICAgICgqc3VtLT5tX3ZyKVtpZHhdLmdldF92cmFuZ2UgKHNyY3ZyKTsKIAogICAg ICAgZW51bSB0cmVlX2NvZGUgb3BlcmF0aW9uID0gaXBhX2dldF9qZl9wYXNzX3Rocm91Z2hfb3Bl cmF0aW9uIChqZnVuYyk7CiAKICAgICAgIGlmIChUUkVFX0NPREVfQ0xBU1MgKG9wZXJhdGlvbikg PT0gdGNjX3VuYXJ5KQogCXsKLQkgIHZhbHVlX3JhbmdlIHJlczsKKwkgIFZhbHVlX1JhbmdlIHJl cyAodnJfdHlwZSk7CiAKLQkgIGlmIChpcGFfdnJfb3BlcmF0aW9uX2FuZF90eXBlX2VmZmVjdHMg KCZyZXMsCi0JCQkJCQkgJnNyY3ZyLAorCSAgaWYgKGlwYV92cl9vcGVyYXRpb25fYW5kX3R5cGVf ZWZmZWN0cyAocmVzLAorCQkJCQkJIHNyY3ZyLAogCQkJCQkJIG9wZXJhdGlvbiwgcGFybV90eXBl LAogCQkJCQkJIHZyX3R5cGUpKQogCSAgICB2ci5pbnRlcnNlY3QgKHJlcyk7CiAJfQogICAgICAg ZWxzZQogCXsKLQkgIHZhbHVlX3JhbmdlIG9wX3JlcywgcmVzOworCSAgVmFsdWVfUmFuZ2Ugb3Bf cmVzICh2cl90eXBlKTsKKwkgIFZhbHVlX1JhbmdlIHJlcyAodnJfdHlwZSk7CiAJICB0cmVlIG9w ID0gaXBhX2dldF9qZl9wYXNzX3Rocm91Z2hfb3BlcmFuZCAoamZ1bmMpOwotCSAgdmFsdWVfcmFu Z2Ugb3BfdnI7CisJICBWYWx1ZV9SYW5nZSBvcF92ciAodnJfdHlwZSk7CiAJICByYW5nZV9vcF9o YW5kbGVyIGhhbmRsZXIgKG9wZXJhdGlvbiwgdnJfdHlwZSk7CiAKIAkgIGlwYV9yYW5nZV9zZXRf YW5kX25vcm1hbGl6ZSAob3BfdnIsIG9wKTsKQEAgLTE5NzksMTQgKzE5ODksMTMgQEAgaXBhX3Zh bHVlX3JhbmdlX2Zyb21famZ1bmMgKGlwYV9ub2RlX3BhcmFtcyAqaW5mbywgY2dyYXBoX2VkZ2Ug KmNzLAogCSAgICAgIHx8ICFoYW5kbGVyLmZvbGRfcmFuZ2UgKG9wX3JlcywgdnJfdHlwZSwgc3Jj dnIsIG9wX3ZyKSkKIAkgICAgb3BfcmVzLnNldF92YXJ5aW5nICh2cl90eXBlKTsKIAotCSAgaWYg KGlwYV92cl9vcGVyYXRpb25fYW5kX3R5cGVfZWZmZWN0cyAoJnJlcywKLQkJCQkJCSAmb3BfcmVz LAorCSAgaWYgKGlwYV92cl9vcGVyYXRpb25fYW5kX3R5cGVfZWZmZWN0cyAocmVzLAorCQkJCQkJ IG9wX3JlcywKIAkJCQkJCSBOT1BfRVhQUiwgcGFybV90eXBlLAogCQkJCQkJIHZyX3R5cGUpKQog CSAgICB2ci5pbnRlcnNlY3QgKHJlcyk7CiAJfQogICAgIH0KLSAgcmV0dXJuIHZyOwogfQogCiAv KiBEZXRlcm1pbmUgd2hldGhlciBJVEVNLCBqdW1wIGZ1bmN0aW9uIGZvciBhbiBhZ2dyZWdhdGUg cGFydCwgZXZhbHVhdGVzIHRvIGEKQEAgLTI3MzksNyArMjc0OCw3IEBAIHByb3BhZ2F0ZV92cl9h Y3Jvc3NfanVtcF9mdW5jdGlvbiAoY2dyYXBoX2VkZ2UgKmNzLCBpcGFfanVtcF9mdW5jICpqZnVu YywKICAgaWYgKCFwYXJhbV90eXBlCiAgICAgICB8fCAoIUlOVEVHUkFMX1RZUEVfUCAocGFyYW1f dHlwZSkKIAkgICYmICFQT0lOVEVSX1RZUEVfUCAocGFyYW1fdHlwZSkpKQotICAgIHJldHVybiBk ZXN0X2xhdC0+c2V0X3RvX2JvdHRvbSAoKTsKKyAgICByZXR1cm4gZGVzdF9sYXQtPnNldF90b19i b3R0b20gKHBhcmFtX3R5cGUpOwogCiAgIGlmIChqZnVuYy0+dHlwZSA9PSBJUEFfSkZfUEFTU19U SFJPVUdIKQogICAgIHsKQEAgLTI3NTEsMTIgKzI3NjAsMTIgQEAgcHJvcGFnYXRlX3ZyX2Fjcm9z c19qdW1wX2Z1bmN0aW9uIChjZ3JhcGhfZWRnZSAqY3MsIGlwYV9qdW1wX2Z1bmMgKmpmdW5jLAog ICAgICAgdHJlZSBvcGVyYW5kX3R5cGUgPSBpcGFfZ2V0X3R5cGUgKGNhbGxlcl9pbmZvLCBzcmNf aWR4KTsKIAogICAgICAgaWYgKHNyY19sYXRzLT5tX3ZhbHVlX3JhbmdlLmJvdHRvbV9wICgpKQot CXJldHVybiBkZXN0X2xhdC0+c2V0X3RvX2JvdHRvbSAoKTsKKwlyZXR1cm4gZGVzdF9sYXQtPnNl dF90b19ib3R0b20gKG9wZXJhbmRfdHlwZSk7CiAKLSAgICAgIHZhbHVlX3JhbmdlIHZyOworICAg ICAgVmFsdWVfUmFuZ2UgdnIgKG9wZXJhbmRfdHlwZSk7CiAgICAgICBpZiAoVFJFRV9DT0RFX0NM QVNTIChvcGVyYXRpb24pID09IHRjY191bmFyeSkKLQlpcGFfdnJfb3BlcmF0aW9uX2FuZF90eXBl X2VmZmVjdHMgKCZ2ciwKLQkJCQkJICAgJnNyY19sYXRzLT5tX3ZhbHVlX3JhbmdlLm1fdnIsCisJ aXBhX3ZyX29wZXJhdGlvbl9hbmRfdHlwZV9lZmZlY3RzICh2ciwKKwkJCQkJICAgc3JjX2xhdHMt Pm1fdmFsdWVfcmFuZ2UubV92ciwKIAkJCQkJICAgb3BlcmF0aW9uLCBwYXJhbV90eXBlLAogCQkJ CQkgICBvcGVyYW5kX3R5cGUpOwogICAgICAgLyogQSBjcnVkZSB3YXkgdG8gcHJldmVudCB1bmJv dW5kZWQgbnVtYmVyIG9mIHZhbHVlIHJhbmdlIHVwZGF0ZXMKQEAgLTI3NjUsOCArMjc3NCw4IEBA IHByb3BhZ2F0ZV92cl9hY3Jvc3NfanVtcF9mdW5jdGlvbiAoY2dyYXBoX2VkZ2UgKmNzLCBpcGFf anVtcF9mdW5jICpqZnVuYywKICAgICAgIGVsc2UgaWYgKCFpcGFfZWRnZV93aXRoaW5fc2NjIChj cykpCiAJewogCSAgdHJlZSBvcCA9IGlwYV9nZXRfamZfcGFzc190aHJvdWdoX29wZXJhbmQgKGpm dW5jKTsKLQkgIHZhbHVlX3JhbmdlIG9wX3ZyOwotCSAgdmFsdWVfcmFuZ2Ugb3BfcmVzLHJlczsK KwkgIFZhbHVlX1JhbmdlIG9wX3ZyIChUUkVFX1RZUEUgKG9wKSk7CisJICBWYWx1ZV9SYW5nZSBv cF9yZXMgKG9wZXJhbmRfdHlwZSk7CiAJICByYW5nZV9vcF9oYW5kbGVyIGhhbmRsZXIgKG9wZXJh dGlvbiwgb3BlcmFuZF90eXBlKTsKIAogCSAgaXBhX3JhbmdlX3NldF9hbmRfbm9ybWFsaXplIChv cF92ciwgb3ApOwpAQCAtMjc3Nyw4ICsyNzg2LDggQEAgcHJvcGFnYXRlX3ZyX2Fjcm9zc19qdW1w X2Z1bmN0aW9uIChjZ3JhcGhfZWRnZSAqY3MsIGlwYV9qdW1wX2Z1bmMgKmpmdW5jLAogCQkJCSAg ICAgIHNyY19sYXRzLT5tX3ZhbHVlX3JhbmdlLm1fdnIsIG9wX3ZyKSkKIAkgICAgb3BfcmVzLnNl dF92YXJ5aW5nIChvcGVyYW5kX3R5cGUpOwogCi0JICBpcGFfdnJfb3BlcmF0aW9uX2FuZF90eXBl X2VmZmVjdHMgKCZ2ciwKLQkJCQkJICAgICAmb3BfcmVzLAorCSAgaXBhX3ZyX29wZXJhdGlvbl9h bmRfdHlwZV9lZmZlY3RzICh2ciwKKwkJCQkJICAgICBvcF9yZXMsCiAJCQkJCSAgICAgTk9QX0VY UFIsIHBhcmFtX3R5cGUsCiAJCQkJCSAgICAgb3BlcmFuZF90eXBlKTsKIAl9CkBAIC0yNzg2LDE0 ICsyNzk1LDE0IEBAIHByb3BhZ2F0ZV92cl9hY3Jvc3NfanVtcF9mdW5jdGlvbiAoY2dyYXBoX2Vk Z2UgKmNzLCBpcGFfanVtcF9mdW5jICpqZnVuYywKIAl7CiAJICBpZiAoamZ1bmMtPm1fdnIpCiAJ ICAgIHsKLQkgICAgICB2YWx1ZV9yYW5nZSBqdnI7Ci0JICAgICAgaWYgKGlwYV92cl9vcGVyYXRp b25fYW5kX3R5cGVfZWZmZWN0cyAoJmp2ciwgamZ1bmMtPm1fdnIsCisJICAgICAgVmFsdWVfUmFu Z2UganZyIChwYXJhbV90eXBlKTsKKwkgICAgICBpZiAoaXBhX3ZyX29wZXJhdGlvbl9hbmRfdHlw ZV9lZmZlY3RzIChqdnIsICpqZnVuYy0+bV92ciwKIAkJCQkJCSAgICAgTk9QX0VYUFIsCiAJCQkJ CQkgICAgIHBhcmFtX3R5cGUsCiAJCQkJCQkgICAgIGpmdW5jLT5tX3ZyLT50eXBlICgpKSkKIAkJ dnIuaW50ZXJzZWN0IChqdnIpOwogCSAgICB9Ci0JICByZXR1cm4gZGVzdF9sYXQtPm1lZXRfd2l0 aCAoJnZyKTsKKwkgIHJldHVybiBkZXN0X2xhdC0+bWVldF93aXRoICh2cik7CiAJfQogICAgIH0K ICAgZWxzZSBpZiAoamZ1bmMtPnR5cGUgPT0gSVBBX0pGX0NPTlNUKQpAQCAtMjgwNSwyMCArMjgx NCwxOSBAQCBwcm9wYWdhdGVfdnJfYWNyb3NzX2p1bXBfZnVuY3Rpb24gKGNncmFwaF9lZGdlICpj cywgaXBhX2p1bXBfZnVuYyAqamZ1bmMsCiAJICBpZiAoVFJFRV9PVkVSRkxPV19QICh2YWwpKQog CSAgICB2YWwgPSBkcm9wX3RyZWVfb3ZlcmZsb3cgKHZhbCk7CiAKLQkgIHZhbHVlX3JhbmdlIHRt cHZyIChUUkVFX1RZUEUgKHZhbCksCi0JCQkgICAgIHdpOjp0b193aWRlICh2YWwpLCB3aTo6dG9f d2lkZSAodmFsKSk7Ci0JICByZXR1cm4gZGVzdF9sYXQtPm1lZXRfd2l0aCAoJnRtcHZyKTsKKwkg IFZhbHVlX1JhbmdlIHRtcHZyICh2YWwsIHZhbCk7CisJICByZXR1cm4gZGVzdF9sYXQtPm1lZXRf d2l0aCAodG1wdnIpOwogCX0KICAgICB9CiAKLSAgdmFsdWVfcmFuZ2UgdnI7CisgIFZhbHVlX1Jh bmdlIHZyIChwYXJhbV90eXBlKTsKICAgaWYgKGpmdW5jLT5tX3ZyCi0gICAgICAmJiBpcGFfdnJf b3BlcmF0aW9uX2FuZF90eXBlX2VmZmVjdHMgKCZ2ciwgamZ1bmMtPm1fdnIsIE5PUF9FWFBSLAor ICAgICAgJiYgaXBhX3ZyX29wZXJhdGlvbl9hbmRfdHlwZV9lZmZlY3RzICh2ciwgKmpmdW5jLT5t X3ZyLCBOT1BfRVhQUiwKIAkJCQkJICAgIHBhcmFtX3R5cGUsCiAJCQkJCSAgICBqZnVuYy0+bV92 ci0+dHlwZSAoKSkpCi0gICAgcmV0dXJuIGRlc3RfbGF0LT5tZWV0X3dpdGggKCZ2cik7CisgICAg cmV0dXJuIGRlc3RfbGF0LT5tZWV0X3dpdGggKHZyKTsKICAgZWxzZQotICAgIHJldHVybiBkZXN0 X2xhdC0+c2V0X3RvX2JvdHRvbSAoKTsKKyAgICByZXR1cm4gZGVzdF9sYXQtPnNldF90b19ib3R0 b20gKHBhcmFtX3R5cGUpOwogfQogCiAvKiBJZiBERVNUX1BMQVRTIGFscmVhZHkgaGFzIGFnZ3Jl Z2F0ZSBpdGVtcywgY2hlY2sgdGhhdCBhZ2dzX2J5X3JlZiBtYXRjaGVzCkBAIC0zMjA5LDcgKzMy MTcsOCBAQCBwcm9wYWdhdGVfY29uc3RhbnRzX2Fjcm9zc19jYWxsIChzdHJ1Y3QgY2dyYXBoX2Vk Z2UgKmNzKQogICAgIHsKICAgICAgIGZvciAoaSA9IDA7IGkgPCBwYXJtc19jb3VudDsgaSsrKQog CXJldCB8PSBzZXRfYWxsX2NvbnRhaW5zX3ZhcmlhYmxlIChpcGFfZ2V0X3Bhcm1fbGF0dGljZXMg KGNhbGxlZV9pbmZvLAotCQkJCQkJCQkgaSkpOworCQkJCQkJCQkgaSksCisJCQkJCSAgaXBhX2dl dF90eXBlIChjYWxsZWVfaW5mbywgaSkpOwogICAgICAgcmV0dXJuIHJldDsKICAgICB9CiAgIGFy Z3NfY291bnQgPSBpcGFfZ2V0X2NzX2FyZ3VtZW50X2NvdW50IChhcmdzKTsKQEAgLTMyMjAsNyAr MzIyOSw4IEBAIHByb3BhZ2F0ZV9jb25zdGFudHNfYWNyb3NzX2NhbGwgKHN0cnVjdCBjZ3JhcGhf ZWRnZSAqY3MpCiAgIGlmIChjYWxsX3Bhc3Nlc190aHJvdWdoX3RodW5rIChjcykpCiAgICAgewog ICAgICAgcmV0IHw9IHNldF9hbGxfY29udGFpbnNfdmFyaWFibGUgKGlwYV9nZXRfcGFybV9sYXR0 aWNlcyAoY2FsbGVlX2luZm8sCi0JCQkJCQkJICAgICAgIDApKTsKKwkJCQkJCQkgICAgICAgMCks CisJCQkJCWlwYV9nZXRfdHlwZSAoY2FsbGVlX2luZm8sIDApKTsKICAgICAgIGkgPSAxOwogICAg IH0KICAgZWxzZQpAQCAtMzIzNCw3ICszMjQ0LDcgQEAgcHJvcGFnYXRlX2NvbnN0YW50c19hY3Jv c3NfY2FsbCAoc3RydWN0IGNncmFwaF9lZGdlICpjcykKIAogICAgICAgZGVzdF9wbGF0cyA9IGlw YV9nZXRfcGFybV9sYXR0aWNlcyAoY2FsbGVlX2luZm8sIGkpOwogICAgICAgaWYgKGF2YWlsYWJp bGl0eSA9PSBBVkFJTF9JTlRFUlBPU0FCTEUpCi0JcmV0IHw9IHNldF9hbGxfY29udGFpbnNfdmFy aWFibGUgKGRlc3RfcGxhdHMpOworCXJldCB8PSBzZXRfYWxsX2NvbnRhaW5zX3ZhcmlhYmxlIChk ZXN0X3BsYXRzLCBwYXJhbV90eXBlKTsKICAgICAgIGVsc2UKIAl7CiAJICByZXQgfD0gcHJvcGFn YXRlX3NjYWxhcl9hY3Jvc3NfanVtcF9mdW5jdGlvbiAoY3MsIGp1bXBfZnVuYywKQEAgLTMyNTEs MTEgKzMyNjEsMTIgQEAgcHJvcGFnYXRlX2NvbnN0YW50c19hY3Jvc3NfY2FsbCAoc3RydWN0IGNn cmFwaF9lZGdlICpjcykKIAkgICAgcmV0IHw9IHByb3BhZ2F0ZV92cl9hY3Jvc3NfanVtcF9mdW5j dGlvbiAoY3MsIGp1bXBfZnVuYywKIAkJCQkJCSAgICAgIGRlc3RfcGxhdHMsIHBhcmFtX3R5cGUp OwogCSAgZWxzZQotCSAgICByZXQgfD0gZGVzdF9wbGF0cy0+bV92YWx1ZV9yYW5nZS5zZXRfdG9f Ym90dG9tICgpOworCSAgICByZXQgfD0gZGVzdF9wbGF0cy0+bV92YWx1ZV9yYW5nZS5zZXRfdG9f Ym90dG9tIChwYXJhbV90eXBlKTsKIAl9CiAgICAgfQogICBmb3IgKDsgaSA8IHBhcm1zX2NvdW50 OyBpKyspCi0gICAgcmV0IHw9IHNldF9hbGxfY29udGFpbnNfdmFyaWFibGUgKGlwYV9nZXRfcGFy bV9sYXR0aWNlcyAoY2FsbGVlX2luZm8sIGkpKTsKKyAgICByZXQgfD0gc2V0X2FsbF9jb250YWlu c192YXJpYWJsZSAoaXBhX2dldF9wYXJtX2xhdHRpY2VzIChjYWxsZWVfaW5mbywgaSksCisJCQkJ ICAgICAgaXBhX2dldF90eXBlIChjYWxsZWVfaW5mbywgaSkpOwogCiAgIHJldHVybiByZXQ7CiB9 CmRpZmYgLS1naXQgYS9nY2MvaXBhLWZuc3VtbWFyeS5jYyBiL2djYy9pcGEtZm5zdW1tYXJ5LmNj CmluZGV4IGIzMjhiYjhjZTE0Li4wNDc0YWY4OTkxZSAxMDA2NDQKLS0tIGEvZ2NjL2lwYS1mbnN1 bW1hcnkuY2MKKysrIGIvZ2NjL2lwYS1mbnN1bW1hcnkuY2MKQEAgLTQ3NSw3ICs0NzUsNyBAQCBl dmFsdWF0ZV9jb25kaXRpb25zX2Zvcl9rbm93bl9hcmdzIChzdHJ1Y3QgY2dyYXBoX25vZGUgKm5v ZGUsCiAJICAmJiAhYy0+YWdnX2NvbnRlbnRzCiAJICAmJiAoIXZhbCB8fCBUUkVFX0NPREUgKHZh bCkgIT0gSU5URUdFUl9DU1QpKQogCXsKLQkgIHZhbHVlX3JhbmdlIHZyID0gYXZhbHMtPm1fa25v d25fdmFsdWVfcmFuZ2VzW2MtPm9wZXJhbmRfbnVtXTsKKwkgIFZhbHVlX1JhbmdlIHZyIChhdmFs cy0+bV9rbm93bl92YWx1ZV9yYW5nZXNbYy0+b3BlcmFuZF9udW1dKTsKIAkgIGlmICghdnIudW5k ZWZpbmVkX3AgKCkKIAkgICAgICAmJiAhdnIudmFyeWluZ19wICgpCiAJICAgICAgJiYgKFRZUEVf U0laRSAoYy0+dHlwZSkgPT0gVFlQRV9TSVpFICh2ci50eXBlICgpKSkpCkBAIC02MzAsOCArNjMw LDggQEAgZXZhbHVhdGVfcHJvcGVydGllc19mb3JfZWRnZSAoc3RydWN0IGNncmFwaF9lZGdlICpl LCBib29sIGlubGluZV9wLAogCQl8fCBpcGFfaXNfcGFyYW1fdXNlZF9ieV9pcGFfcHJlZGljYXRl cyAoY2FsbGVlX3BpLCBpKSkKIAkgICAgICB7CiAJCS8qIERldGVybWluZSBpZiB3ZSBrbm93IGNv bnN0YW50IHZhbHVlIG9mIHRoZSBwYXJhbWV0ZXIuICAqLwotCQl0cmVlIGNzdCA9IGlwYV92YWx1 ZV9mcm9tX2pmdW5jIChjYWxsZXJfcGFybXNfaW5mbywgamYsCi0JCQkJCQkgaXBhX2dldF90eXBl IChjYWxsZWVfcGksIGkpKTsKKwkJdHJlZSB0eXBlID0gaXBhX2dldF90eXBlIChjYWxsZWVfcGks IGkpOworCQl0cmVlIGNzdCA9IGlwYV92YWx1ZV9mcm9tX2pmdW5jIChjYWxsZXJfcGFybXNfaW5m bywgamYsIHR5cGUpOwogCiAJCWlmICghY3N0ICYmIGUtPmNhbGxfc3RtdAogCQkgICAgJiYgaSA8 IChpbnQpZ2ltcGxlX2NhbGxfbnVtX2FyZ3MgKGUtPmNhbGxfc3RtdCkpCkBAIC02NTksMTAgKzY1 OSwxMCBAQCBldmFsdWF0ZV9wcm9wZXJ0aWVzX2Zvcl9lZGdlIChzdHJ1Y3QgY2dyYXBoX2VkZ2Ug KmUsIGJvb2wgaW5saW5lX3AsCiAJCSAgICAmJiB2cnBfd2lsbF9ydW5fcCAoY2FsbGVyKQogCQkg ICAgJiYgaXBhX2lzX3BhcmFtX3VzZWRfYnlfaXBhX3ByZWRpY2F0ZXMgKGNhbGxlZV9waSwgaSkp CiAJCSAgewotCQkgICAgdmFsdWVfcmFuZ2UgdnIKLQkJICAgICAgID0gaXBhX3ZhbHVlX3Jhbmdl X2Zyb21famZ1bmMgKGNhbGxlcl9wYXJtc19pbmZvLCBlLCBqZiwKLQkJCQkJCSAgICAgaXBhX2dl dF90eXBlIChjYWxsZWVfcGksCi0JCQkJCQkJCSAgIGkpKTsKKwkJICAgIFZhbHVlX1JhbmdlIHZy ICh0eXBlKTsKKworCQkgICAgaXBhX3ZhbHVlX3JhbmdlX2Zyb21famZ1bmMgKHZyLCBjYWxsZXJf cGFybXNfaW5mbywgZSwgamYsCisJCQkJCQlpcGFfZ2V0X3R5cGUgKGNhbGxlZV9waSwgaSkpOwog CQkgICAgaWYgKCF2ci51bmRlZmluZWRfcCAoKSAmJiAhdnIudmFyeWluZ19wICgpKQogCQkgICAg ICB7CiAJCQlpZiAoIWF2YWxzLT5tX2tub3duX3ZhbHVlX3Jhbmdlcy5sZW5ndGggKCkpCkBAIC02 NzAsNyArNjcwLDcgQEAgZXZhbHVhdGVfcHJvcGVydGllc19mb3JfZWRnZSAoc3RydWN0IGNncmFw aF9lZGdlICplLCBib29sIGlubGluZV9wLAogCQkJICAgIGF2YWxzLT5tX2tub3duX3ZhbHVlX3Jh bmdlcy5zYWZlX2dyb3cgKGNvdW50LCB0cnVlKTsKIAkJCSAgICBmb3IgKGludCBpID0gMDsgaSA8 IGNvdW50OyArK2kpCiAJCQkgICAgICBuZXcgKCZhdmFscy0+bV9rbm93bl92YWx1ZV9yYW5nZXNb aV0pCi0JCQkJdmFsdWVfcmFuZ2UgKCk7CisJCQkJVmFsdWVfUmFuZ2UgKCk7CiAJCQkgIH0KIAkJ CWF2YWxzLT5tX2tub3duX3ZhbHVlX3Jhbmdlc1tpXSA9IHZyOwogCQkgICAgICB9CmRpZmYgLS1n aXQgYS9nY2MvaXBhLXByb3AuY2MgYi9nY2MvaXBhLXByb3AuY2MKaW5kZXggYWI2ZGU5ZjEwZGEu LmJiZmUwZjhhYTQ1IDEwMDY0NAotLS0gYS9nY2MvaXBhLXByb3AuY2MKKysrIGIvZ2NjL2lwYS1w cm9wLmNjCkBAIC0xOTgsOCArMTk4LDkgQEAgaXBhX3ZyOjplcXVhbF9wIChjb25zdCB2cmFuZ2Ug JnIpIGNvbnN0CiB9CiAKIHZvaWQKLWlwYV92cjo6Z2V0X3ZyYW5nZSAodnJhbmdlICZyKSBjb25z dAoraXBhX3ZyOjpnZXRfdnJhbmdlIChWYWx1ZV9SYW5nZSAmcikgY29uc3QKIHsKKyAgci5zZXRf dHlwZSAobV90eXBlKTsKICAgbV9zdG9yYWdlLT5nZXRfdnJhbmdlIChyLCBtX3R5cGUpOwogfQog CkBAIC01OTYzLDcgKzU5NjQsNyBAQCBpcGNwX3VwZGF0ZV92ciAoc3RydWN0IGNncmFwaF9ub2Rl ICpub2RlKQogCiAgICAgICBpZiAodnJbaV0ua25vd25fcCAoKSkKIAl7Ci0JICB2YWx1ZV9yYW5n ZSB0bXA7CisJICBWYWx1ZV9SYW5nZSB0bXA7CiAJICB2cltpXS5nZXRfdnJhbmdlICh0bXApOwog CiAJICBpZiAoIXRtcC51bmRlZmluZWRfcCAoKSAmJiAhdG1wLnZhcnlpbmdfcCAoKSkKZGlmZiAt LWdpdCBhL2djYy9pcGEtcHJvcC5oIGIvZ2NjL2lwYS1wcm9wLmgKaW5kZXggNjU4YmUyZjU5NTIu LmY4N2U4YTU5NmMxIDEwMDY0NAotLS0gYS9nY2MvaXBhLXByb3AuaAorKysgYi9nY2MvaXBhLXBy b3AuaApAQCAtMzE0LDcgKzMxNCw3IEBAIHB1YmxpYzoKICAgdm9pZCBzZXRfdW5rbm93biAoKTsK ICAgYm9vbCBrbm93bl9wICgpIGNvbnN0IHsgcmV0dXJuIG1fc3RvcmFnZSAhPSBOVUxMOyB9CiAg IHRyZWUgdHlwZSAoKSBjb25zdCB7IHJldHVybiBtX3R5cGU7IH0KLSAgdm9pZCBnZXRfdnJhbmdl ICh2cmFuZ2UgJikgY29uc3Q7CisgIHZvaWQgZ2V0X3ZyYW5nZSAoVmFsdWVfUmFuZ2UgJikgY29u c3Q7CiAgIGJvb2wgZXF1YWxfcCAoY29uc3QgdnJhbmdlICYpIGNvbnN0OwogICBjb25zdCB2cmFu Z2Vfc3RvcmFnZSAqc3RvcmFnZSAoKSBjb25zdCB7IHJldHVybiBtX3N0b3JhZ2U7IH0KICAgdm9p ZCBzdHJlYW1lcl9yZWFkIChsdG9faW5wdXRfYmxvY2sgKiwgZGF0YV9pbiAqKTsKQEAgLTUzNCw3 ICs1MzQsNyBAQCBwdWJsaWM6CiAgIGF1dG9fdmVjPGlwYV9hcmdhZ2dfdmFsdWUsIDMyPiBtX2tu b3duX2FnZ3M7CiAKICAgLyogVmVjdG9yIGRlc2NyaWJpbmcga25vd24gdmFsdWUgcmFuZ2VzIG9m IGFyZ3VtZW50cy4gICovCi0gIGF1dG9fdmVjPHZhbHVlX3JhbmdlLCAzMj4gbV9rbm93bl92YWx1 ZV9yYW5nZXM7CisgIGF1dG9fdmVjPFZhbHVlX1JhbmdlLCAzMj4gbV9rbm93bl92YWx1ZV9yYW5n ZXM7CiB9OwogCiBpbmxpbmUKQEAgLTU4Niw3ICs1ODYsNyBAQCBwdWJsaWM6CiAgIHZlYzxpcGFf YXJnYWdnX3ZhbHVlPiBtX2tub3duX2FnZ3MgPSB2TlVMTDsKIAogICAvKiBWZWN0b3IgZGVzY3Jp YmluZyBrbm93biB2YWx1ZSByYW5nZXMgb2YgYXJndW1lbnRzLiAgKi8KLSAgdmVjPHZhbHVlX3Jh bmdlPiBtX2tub3duX3ZhbHVlX3JhbmdlcyA9IHZOVUxMOworICB2ZWM8VmFsdWVfUmFuZ2U+IG1f a25vd25fdmFsdWVfcmFuZ2VzID0gdk5VTEw7CiB9OwogCiBpbmxpbmUKQEAgLTExOTgsOCArMTE5 OCw4IEBAIGlwYV9wb2x5bW9ycGhpY19jYWxsX2NvbnRleHQgaXBhX2NvbnRleHRfZnJvbV9qZnVu YyAoaXBhX25vZGVfcGFyYW1zICosCiAJCQkJCQkgICAgIGNncmFwaF9lZGdlICosCiAJCQkJCQkg ICAgIGludCwKIAkJCQkJCSAgICAgaXBhX2p1bXBfZnVuYyAqKTsKLXZhbHVlX3JhbmdlIGlwYV92 YWx1ZV9yYW5nZV9mcm9tX2pmdW5jIChpcGFfbm9kZV9wYXJhbXMgKiwgY2dyYXBoX2VkZ2UgKiwK LQkJCQkJaXBhX2p1bXBfZnVuYyAqLCB0cmVlKTsKK3ZvaWQgaXBhX3ZhbHVlX3JhbmdlX2Zyb21f amZ1bmMgKHZyYW5nZSAmLCBpcGFfbm9kZV9wYXJhbXMgKiwgY2dyYXBoX2VkZ2UgKiwKKwkJCQkg aXBhX2p1bXBfZnVuYyAqLCB0cmVlKTsKIHZvaWQgaXBhX3B1c2hfYWdnX3ZhbHVlc19mcm9tX2pm dW5jIChpcGFfbm9kZV9wYXJhbXMgKmluZm8sIGNncmFwaF9ub2RlICpub2RlLAogCQkJCSAgICAg aXBhX2FnZ19qdW1wX2Z1bmN0aW9uICphZ2dfamZ1bmMsCiAJCQkJICAgICB1bnNpZ25lZCBkc3Rf aW5kZXgsCkBAIC0xMjIyLDE3ICsxMjIyLDEyIEBAIHZvaWQgaXBhX2NwX2NjX2ZpbmFsaXplICh2 b2lkKTsKICAgIG5vbi16ZXJvLiAgKi8KIAogaW5saW5lIHZvaWQKLWlwYV9yYW5nZV9zZXRfYW5k X25vcm1hbGl6ZSAoaXJhbmdlICZyLCB0cmVlIHZhbCkKK2lwYV9yYW5nZV9zZXRfYW5kX25vcm1h bGl6ZSAodnJhbmdlICZyLCB0cmVlIHZhbCkKIHsKLSAgaWYgKFRSRUVfQ09ERSAodmFsKSA9PSBJ TlRFR0VSX0NTVCkKLSAgICB7Ci0gICAgICB3aWRlX2ludCB3ID0gd2k6OnRvX3dpZGUgKHZhbCk7 Ci0gICAgICByLnNldCAoVFJFRV9UWVBFICh2YWwpLCB3LCB3KTsKLSAgICB9Ci0gIGVsc2UgaWYg KFRSRUVfQ09ERSAodmFsKSA9PSBBRERSX0VYUFIpCisgIGlmIChUUkVFX0NPREUgKHZhbCkgPT0g QUREUl9FWFBSKQogICAgIHIuc2V0X25vbnplcm8gKFRSRUVfVFlQRSAodmFsKSk7CiAgIGVsc2UK LSAgICByLnNldF92YXJ5aW5nIChUUkVFX1RZUEUgKHZhbCkpOworICAgIHIuc2V0ICh2YWwsIHZh bCk7CiB9CiAKICNlbmRpZiAvKiBJUEFfUFJPUF9IICovCi0tIAoyLjQwLjEKCg== --00000000000044accc05fc4ca66f--