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.133.124]) by sourceware.org (Postfix) with ESMTPS id 439D83858C54 for ; Wed, 7 Jun 2023 10:18:09 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 439D83858C54 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=1686133088; 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=i5LVX+xam/vYoghueQ5/gnvMcpqepZTS3xPI6vMRuaI=; b=BM89PIsbjlOOYlaBy1QGhoSYYnPjjxWU0CI3K5rA2WamW2hROwAHq/WkWm8cJf6ZHZ02/U kyGDvhcAY3oEQ28dc/n5WnDqGxJbK8/2H9OeuzIZSZDp8xA6wtP/VNPey+zjcFZiv9MH96 WGto1z9MAANMrsTua0nRaKd52hkzdE4= Received: from mail-wm1-f71.google.com (mail-wm1-f71.google.com [209.85.128.71]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-26-s2vPtKQKMIepbGZ8Ft7UWw-1; Wed, 07 Jun 2023 06:18:07 -0400 X-MC-Unique: s2vPtKQKMIepbGZ8Ft7UWw-1 Received: by mail-wm1-f71.google.com with SMTP id 5b1f17b1804b1-3f5fc8581a9so36049075e9.0 for ; Wed, 07 Jun 2023 03:18:07 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1686133086; x=1688725086; h=in-reply-to:from:references:cc:to:content-language:subject :user-agent:mime-version:date:message-id:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=Svc1ZjHhsl/t2xfH/cyYUXyXx6iQWhsdpG/2bWJxu34=; b=YhSWrxx1W66yKyNJyjdPpHXAtL5SYx3IqTk2dMmbjk1aK1pFK8iTO1Bmb5qgZTlV+t 5fO9Y+0DY69xjMH43jFrfjfXCrcbZmtUs5Z1H72DO1u266ev7VKQl4cWnnd6XkbPHlIr TDfcx9EfsLL+mP48PwiZZyYT38CZuBx5ax+Oezd+HwwBIuyU/VB/I9I5clQHRoM0UOJ4 BXYLGB26/sp1hYj3cN5LuhrFVFH1oKzg8Hr+kUqntH/6dfYPL8Mjr6PBpe2lXd4DdlyQ lAWy7kgxL5IjsOmW8EAyJFTHEwdeUQ0AQ1hd+G6OZmpsq8FgRBTaP5HNqUh8g/WHvp8I JK7g== X-Gm-Message-State: AC+VfDwTJXjYBr5lmOQjmf5DH/PMTspmVvt6bTSJtRaTytQTRr79axT7 DjqDTWwTdptVOGQKG8QcYP5fs+yycUDn0D4nXg1sFchU5PiFZ59fusrz5cTLkcOevDSmm/MocYB jbcIUzv2gDOMfqa6pQw== X-Received: by 2002:a5d:564a:0:b0:309:3b8d:16af with SMTP id j10-20020a5d564a000000b003093b8d16afmr4400894wrw.49.1686133086014; Wed, 07 Jun 2023 03:18:06 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ4+pLYKPo84hQ452ogtUtJDIuHT25RmrBJ5tPlucSQFItnp2AIf1JpFghZnLQeoI7zD9Br5cQ== X-Received: by 2002:a5d:564a:0:b0:309:3b8d:16af with SMTP id j10-20020a5d564a000000b003093b8d16afmr4400860wrw.49.1686133085472; Wed, 07 Jun 2023 03:18:05 -0700 (PDT) Received: from [192.168.1.201] ([139.47.42.170]) by smtp.gmail.com with ESMTPSA id u4-20020a5d5144000000b003062b2c5255sm15061152wrt.40.2023.06.07.03.18.04 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Wed, 07 Jun 2023 03:18:05 -0700 (PDT) Message-ID: <7a17934c-4ac4-f776-0980-1333c46a4aff@redhat.com> Date: Wed, 7 Jun 2023 12:18:04 +0200 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Thunderbird/102.10.0 Subject: Re: [PATCH] Convert ipcp_vr_lattice to type agnostic framework. To: Martin Jambor Cc: Andrew MacLeod , GCC patches References: From: Aldy Hernandez In-Reply-To: X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: multipart/mixed; boundary="------------BAnkGXH6jS85B0YrZ6BGbVy5" Content-Language: en-US X-Spam-Status: No, score=-10.1 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,NICE_REPLY_A,RCVD_IN_BARRACUDACENTRAL,RCVD_IN_DNSWL_NONE,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: This is a multi-part message in MIME format. --------------BAnkGXH6jS85B0YrZ6BGbVy5 Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit On 5/26/23 18:17, Martin Jambor wrote: > Hello, > > On Mon, May 22 2023, Aldy Hernandez wrote: >> 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 PM Aldy Hernandez wrote: >>> >>> 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. > > It is quite confusing for an unsuspecting reader indeed. > >>> >>> OK for trunk? > > I guess I need to rely on that you know what you are doing :-) I wouldn't go that far ;-). > I have seen in other messages that you measure the compile time > effects of your patches, do you look at memory use as well? As per my message yesterday, the memory usage seems reasonable. > > I am happy with the overall approach, I just have the following > comments, questions and a few concerns: > > >>> >>> 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); > > Requiring a type when setting a lattice to bottom makes for a weird > interface, can't we set the underlying Value_Range to whatever... > >>> + 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. > > ...this does? > > All users of the lattice check it for not being bottom first, so it > should be safe. > > If it is not possible for some reason, then I guess we should add a bool > flag to ipcp_vr_lattice instead, rather than looking up types of > unusable lattices. ipcp_vr_lattices don't live for long. The type was my least favorite part of this work. And yes, your suggestion would work. I have tweaked the patch to force a VARYING for an unsupported range which seems to do the trick. It looks much cleaner. Thanks. > >>> +} >>> + >>> /* Structure containing lattices for a parameter itself and for pieces of >>> aggregates that are passed in the parameter or by a reference in a parameter >>> 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_lattices *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 VR >>> 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 = m_vr.union_ (*other_vr); >>> + Value_Range save (m_vr); >>> + res = m_vr.union_ (other_vr); >>> gcc_assert (res == (m_vr != save)); >>> } >>> else >>> - res = m_vr.union_ (*other_vr); >>> + res = 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 &elts, >>> 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) >>> { > > ...then functions like these would not need the extra parameter either. > >>> bool ret; >>> ret = plats->itself.set_contains_variable (); >>> ret |= plats->ctxlat.set_contains_variable (); >>> ret |= set_agg_lats_contain_variable (plats); >>> ret |= plats->bits_lattice.set_to_bottom (); >>> - ret |= plats->m_value_range.set_to_bottom (); >>> + ret |= plats->m_value_range.set_to_bottom (type); >>> return ret; >>> } >>> >>> @@ -1653,6 +1657,7 @@ initialize_node_lattices (struct cgraph_node *node) >>> for (i = 0; i < ipa_get_param_count (info); i++) >>> { >>> ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i); >>> + tree type = ipa_get_type (info, i); >>> if (disable >>> || !ipa_get_type (info, i) >>> || (pre_modified && (surviving_params.length () <= (unsigned) i >>> @@ -1662,14 +1667,14 @@ initialize_node_lattices (struct cgraph_node *node) >>> plats->ctxlat.set_to_bottom (); >>> set_agg_lats_to_bottom (plats); >>> plats->bits_lattice.set_to_bottom (); >>> - plats->m_value_range.m_vr = 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, cgraph_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 *dst_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 node 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) > > I assume that you decided to return the value in a parameter passed by > reference instead of in return value for a good reason but then can we > at least... vrange is an abstract type, plus it can be any size (int_range<3> has 3 sub-ranges, legacy value_range has 2 sub-ranges, frange is a totally different object, etc). Throughout all of ranger, returning a range is done by passing by reference. This has the added benefit that sometimes we can set a return range by twiddling a few bits (foo.set_undefined()) instead of having to copy a full range back and forth. > > >>> { >>> - 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; > > ...make sure that whenever the function intends to return a varying VR > it actually does so instead of not touching it at all? Good catch. The original "value_range vr;" definition would default vr to UNDEFINED, which would no longer happen with my patch. I have added a vr.set_undefined() at the original definition site, which would make everything work. > >>> if (jfunc->type == 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; > > Likewise. > >>> >>> idx = ipa_get_jf_pass_through_formal_id (jfunc); >>> >>> if (!(*sum->m_vr)[idx].known_p ()) >>> - return vr; >>> + return; > > Likewise. > >>> tree vr_type = 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 = ipa_get_jf_pass_through_operation (jfunc); >>> >>> if (TREE_CODE_CLASS (operation) == 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); > > Here we also now make assumptions about the state of vr which we did not > before, should we perhaps assign res into vr instead? With the initialization of vr to UNDEFINED, this should be OK as both of these initialize "res" to UNDEFINED: >>> - value_range res; >>> + Value_Range res (vr_type); So vr and res both have the same default as before. > >>> } >>> else >>> { >>> - value_range op_res, res; >>> + Value_Range op_res (vr_type); >>> + Value_Range res (vr_type); >>> tree op = 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); > > Likewise. > >>> } >>> } >>> - return vr; >>> } >>> >>> /* Determine whether ITEM, jump function for an aggregate part, evaluates 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 == IPA_JF_PASS_THROUGH) >>> { >>> @@ -2751,12 +2760,12 @@ propagate_vr_across_jump_function (cgraph_edge *cs, ipa_jump_func *jfunc, >>> tree operand_type = 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) == 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 = 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 *cs, 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 == IPA_JF_CONST) >>> @@ -2805,20 +2814,19 @@ propagate_vr_across_jump_function (cgraph_edge *cs, ipa_jump_func *jfunc, >>> if (TREE_OVERFLOW_P (val)) >>> val = 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 matches >>> @@ -3209,7 +3217,8 @@ propagate_constants_across_call (struct cgraph_edge *cs) >>> { >>> for (i = 0; i < parms_count; i++) >>> ret |= set_all_contains_variable (ipa_get_parm_lattices (callee_info, >>> - i)); >>> + i), >>> + ipa_get_type (callee_info, i)); > > I have complained about it above but this another example where making > ipcp_vr_lattice::set_to_bottom not require a type which is not really > needed could even save a tiny bit of compile time. > >>> return ret; >>> } >>> args_count = 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 |= set_all_contains_variable (ipa_get_parm_lattices (callee_info, >>> - 0)); >>> + 0), >>> + ipa_get_type (callee_info, 0)); >>> i = 1; >>> } >>> else >>> @@ -3234,7 +3244,7 @@ propagate_constants_across_call (struct cgraph_edge *cs) >>> >>> dest_plats = ipa_get_parm_lattices (callee_info, i); >>> if (availability == AVAIL_INTERPOSABLE) >>> - ret |= set_all_contains_variable (dest_plats); >>> + ret |= set_all_contains_variable (dest_plats, param_type); >>> else >>> { >>> ret |= propagate_scalar_across_jump_function (cs, jump_func, >>> @@ -3251,11 +3261,12 @@ propagate_constants_across_call (struct cgraph_edge *cs) >>> ret |= propagate_vr_across_jump_function (cs, jump_func, >>> dest_plats, param_type); >>> else >>> - ret |= dest_plats->m_value_range.set_to_bottom (); >>> + ret |= dest_plats->m_value_range.set_to_bottom (param_type); >>> } >>> } >>> for (; i < parms_count; i++) >>> - ret |= set_all_contains_variable (ipa_get_parm_lattices (callee_info, i)); >>> + ret |= set_all_contains_variable (ipa_get_parm_lattices (callee_info, 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_node *node, >>> && !c->agg_contents >>> && (!val || TREE_CODE (val) != INTEGER_CST)) >>> { >>> - value_range vr = 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) == 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 = ipa_value_from_jfunc (caller_parms_info, jf, >>> - ipa_get_type (callee_pi, i)); >>> + tree type = ipa_get_type (callee_pi, i); >>> + tree cst = 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 >>> - = 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)); > > I guess that the ipa_get_type call can also be replaced with "type" now. Done. > >>> 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 = 0; i < count; ++i) >>> new (&avals->m_known_value_ranges[i]) >>> - value_range (); >>> + Value_Range (); >>> } >>> avals->m_known_value_ranges[i] = vr; >>> } > > Thanks for working on this and sorry that it takes me so long to review. > > Martin > How's this? Aldy --------------BAnkGXH6jS85B0YrZ6BGbVy5 Content-Type: text/x-patch; charset=UTF-8; name="0001-Convert-ipcp_vr_lattice-to-type-agnostic-framework.patch" Content-Disposition: attachment; filename*0="0001-Convert-ipcp_vr_lattice-to-type-agnostic-framework.patc"; filename*1="h" Content-Transfer-Encoding: base64 RnJvbSAyZmQwYWU0N2FhMDk0Njc1YTAyNzYzZTcyZDdiYjc0MDRlZDkzMzRiIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbGR5IEhlcm5hbmRleiA8YWxkeWhAcmVkaGF0LmNvbT4KRGF0 ZTogV2VkLCAxNyBNYXkgMjAyMyAxMToyOTozNCArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIENvbnZl cnQgaXBjcF92cl9sYXR0aWNlIHRvIHR5cGUgYWdub3N0aWMgZnJhbWV3b3JrLgoKVGhpcyBjb252 ZXJ0cyB0aGUgbGF0dGljZSB0byBzdG9yZSByYW5nZXMgaW4gVmFsdWVfUmFuZ2UgaW5zdGVhZCBv Zgp2YWx1ZV9yYW5nZSAoKikgdG8gbWFrZSBpdCB0eXBlIGFnbm9zdGljLCBhbmQgYWRqdXN0IGFs bCB1c2VycwphY2NvcmRpbmdseS4KCkkndmUgYmVlbiBjYXJlZnVsIHRvIG1ha2Ugc3VyZSBWYWx1 ZV9SYW5nZSBuZXZlciBlbmRzIHVwIG9uIEdDLCBzaW5jZQppdCBjb250YWlucyBhbiBpbnRfcmFu Z2VfbWF4IGFuZCBjYW4gZXhwYW5kIG9uLWRlbWFuZCBvbnRvIHRoZSBoZWFwLgpMb25nZXIgdGVy bSBzdG9yYWdlIGZvciByYW5nZXMgc2hvdWxkIGJlIGRvbmUgd2l0aCB2cmFuZ2Vfc3RvcmFnZSwg YXMKcGVyIHRoZSBwcmV2aW91cyBwYXRjaCAoIlByb3ZpZGUgYW4gQVBJIGZvciBpcGFfdnIiKS4K CmdjYy9DaGFuZ2VMb2c6CgoJKiBpcGEtY3AuY2MgKGlwY3BfdnJfbGF0dGljZTo6aW5pdCk6IFRh a2UgdHlwZSBhcmd1bWVudC4KCShpcGNwX3ZyX2xhdHRpY2U6OnByaW50KTogQ2FsbCBkdW1wIG1l dGhvZC4KCShpcGNwX3ZyX2xhdHRpY2U6Om1lZXRfd2l0aCk6IEFkanVzdCBmb3IgbV92ciBiZWlu ZyBhCiAgICAgICAgVmFsdWVfUmFuZ2UuCgkoaXBjcF92cl9sYXR0aWNlOjptZWV0X3dpdGhfMSk6 IE1ha2UgYXJndW1lbnQgYSByZWZlcmVuY2UuCgkoaXBjcF92cl9sYXR0aWNlOjpzZXRfdG9fYm90 dG9tKTogU2V0IHZhcnlpbmcgZm9yIGFuIHVuc3VwcG9ydGVkCglyYW5nZS4KCShpbml0aWFsaXpl X25vZGVfbGF0dGljZXMpOiBQYXNzIHR5cGUgd2hlbiBhcHByb3ByaWF0ZS4KCShpcGFfdnJfb3Bl cmF0aW9uX2FuZF90eXBlX2VmZmVjdHMpOiBNYWtlIHR5cGUgYWdub3N0aWMuCgkoaXBhX3ZhbHVl X3JhbmdlX2Zyb21famZ1bmMpOiBTYW1lLgoJKHByb3BhZ2F0ZV92cl9hY3Jvc3NfanVtcF9mdW5j dGlvbik6IFNhbWUuCgkqIGlwYS1mbnN1bW1hcnkuY2MgKGV2YWx1YXRlX2NvbmRpdGlvbnNfZm9y X2tub3duX2FyZ3MpOiBTYW1lLgoJKGV2YWx1YXRlX3Byb3BlcnRpZXNfZm9yX2VkZ2UpOiBTYW1l LgoJKiBpcGEtcHJvcC5jYyAoaXBhX3ZyOjpnZXRfdnJhbmdlKTogU2FtZS4KCShpcGNwX3VwZGF0 ZV92cik6IFNhbWUuCgkqIGlwYS1wcm9wLmggKGlwYV92YWx1ZV9yYW5nZV9mcm9tX2pmdW5jKTog U2FtZS4KCShpcGFfcmFuZ2Vfc2V0X2FuZF9ub3JtYWxpemUpOiBTYW1lLgotLS0KIGdjYy9pcGEt Y3AuY2MgICAgICAgIHwgMTQ4ICsrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0t LS0tLS0KIGdjYy9pcGEtZm5zdW1tYXJ5LmNjIHwgIDE1ICsrLS0tCiBnY2MvaXBhLXByb3AuY2Mg ICAgICB8ICAgNSArLQogZ2NjL2lwYS1wcm9wLmggICAgICAgfCAgMjEgKysrLS0tCiA0IGZpbGVz IGNoYW5nZWQsIDEwMSBpbnNlcnRpb25zKCspLCA4OCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQg YS9nY2MvaXBhLWNwLmNjIGIvZ2NjL2lwYS1jcC5jYwppbmRleCAwZjM3YmI1ZTMzNi4uZDc3Yjll YWIyNDkgMTAwNjQ0Ci0tLSBhL2djYy9pcGEtY3AuY2MKKysrIGIvZ2NjL2lwYS1jcC5jYwpAQCAt MzQzLDIwICszNDMsMjkgQEAgcHJpdmF0ZToKIGNsYXNzIGlwY3BfdnJfbGF0dGljZQogewogcHVi bGljOgotICB2YWx1ZV9yYW5nZSBtX3ZyOworICBWYWx1ZV9SYW5nZSBtX3ZyOwogCiAgIGlubGlu ZSBib29sIGJvdHRvbV9wICgpIGNvbnN0OwogICBpbmxpbmUgYm9vbCB0b3BfcCAoKSBjb25zdDsK ICAgaW5saW5lIGJvb2wgc2V0X3RvX2JvdHRvbSAoKTsKLSAgYm9vbCBtZWV0X3dpdGggKGNvbnN0 IHZhbHVlX3JhbmdlICpwX3ZyKTsKKyAgYm9vbCBtZWV0X3dpdGggKGNvbnN0IHZyYW5nZSAmcF92 cik7CiAgIGJvb2wgbWVldF93aXRoIChjb25zdCBpcGNwX3ZyX2xhdHRpY2UgJm90aGVyKTsKLSAg dm9pZCBpbml0ICgpIHsgZ2NjX2Fzc2VydCAobV92ci51bmRlZmluZWRfcCAoKSk7IH0KKyAgdm9p ZCBpbml0ICh0cmVlIHR5cGUpOwogICB2b2lkIHByaW50IChGSUxFICogZik7CiAKIHByaXZhdGU6 Ci0gIGJvb2wgbWVldF93aXRoXzEgKGNvbnN0IHZhbHVlX3JhbmdlICpvdGhlcl92cik7CisgIGJv b2wgbWVldF93aXRoXzEgKGNvbnN0IHZyYW5nZSAmb3RoZXJfdnIpOwogfTsKIAoraW5saW5lIHZv aWQKK2lwY3BfdnJfbGF0dGljZTo6aW5pdCAodHJlZSB0eXBlKQoreworICBpZiAodHlwZSkKKyAg ICBtX3ZyLnNldF90eXBlICh0eXBlKTsKKworICAvLyBPdGhlcndpc2UgbV92ciB3aWxsIGRlZmF1 bHQgdG8gdW5zdXBwb3J0ZWRfcmFuZ2UuCit9CisKIC8qIFN0cnVjdHVyZSBjb250YWluaW5nIGxh dHRpY2VzIGZvciBhIHBhcmFtZXRlciBpdHNlbGYgYW5kIGZvciBwaWVjZXMgb2YKICAgIGFnZ3Jl Z2F0ZXMgdGhhdCBhcmUgcGFzc2VkIGluIHRoZSBwYXJhbWV0ZXIgb3IgYnkgYSByZWZlcmVuY2Ug aW4gYSBwYXJhbWV0ZXIKICAgIHBsdXMgc29tZSBvdGhlciB1c2VmdWwgZmxhZ3MuICAqLwpAQCAt NTg1LDcgKzU5NCw3IEBAIGlwY3BfYml0c19sYXR0aWNlOjpwcmludCAoRklMRSAqZikKIHZvaWQK IGlwY3BfdnJfbGF0dGljZTo6cHJpbnQgKEZJTEUgKiBmKQogewotICBkdW1wX3ZhbHVlX3Jhbmdl IChmLCAmbV92cik7CisgIG1fdnIuZHVtcCAoZik7CiB9CiAKIC8qIFByaW50IGFsbCBpcGNwX2xh dHRpY2VzIG9mIGFsbCBmdW5jdGlvbnMgdG8gRi4gICovCkBAIC0xMDE2LDM5ICsxMDI1LDM5IEBA IHNldF9hZ2dfbGF0c19jb250YWluX3ZhcmlhYmxlIChjbGFzcyBpcGNwX3BhcmFtX2xhdHRpY2Vz ICpwbGF0cykKIGJvb2wKIGlwY3BfdnJfbGF0dGljZTo6bWVldF93aXRoIChjb25zdCBpcGNwX3Zy X2xhdHRpY2UgJm90aGVyKQogewotICByZXR1cm4gbWVldF93aXRoXzEgKCZvdGhlci5tX3ZyKTsK KyAgcmV0dXJuIG1lZXRfd2l0aF8xIChvdGhlci5tX3ZyKTsKIH0KIAotLyogTWVldCB0aGUgY3Vy cmVudCB2YWx1ZSBvZiB0aGUgbGF0dGljZSB3aXRoIHZhbHVlIHJhbmdlIGRlc2NyaWJlZCBieSBW UgotICAgbGF0dGljZS4gICovCisvKiBNZWV0IHRoZSBjdXJyZW50IHZhbHVlIG9mIHRoZSBsYXR0 aWNlIHdpdGggdGhlIHJhbmdlIGRlc2NyaWJlZCBieQorICAgUF9WUi4gICovCiAKIGJvb2wKLWlw Y3BfdnJfbGF0dGljZTo6bWVldF93aXRoIChjb25zdCB2YWx1ZV9yYW5nZSAqcF92cikKK2lwY3Bf dnJfbGF0dGljZTo6bWVldF93aXRoIChjb25zdCB2cmFuZ2UgJnBfdnIpCiB7CiAgIHJldHVybiBt ZWV0X3dpdGhfMSAocF92cik7CiB9CiAKLS8qIE1lZXQgdGhlIGN1cnJlbnQgdmFsdWUgb2YgdGhl IGxhdHRpY2Ugd2l0aCB2YWx1ZSByYW5nZSBkZXNjcmliZWQgYnkKLSAgIE9USEVSX1ZSIGxhdHRp Y2UuICBSZXR1cm4gVFJVRSBpZiBhbnl0aGluZyBjaGFuZ2VkLiAgKi8KKy8qIE1lZXQgdGhlIGN1 cnJlbnQgdmFsdWUgb2YgdGhlIGxhdHRpY2Ugd2l0aCB0aGUgcmFuZ2UgZGVzY3JpYmVkIGJ5Cisg ICBPVEhFUl9WUi4gIFJldHVybiBUUlVFIGlmIGFueXRoaW5nIGNoYW5nZWQuICAqLwogCiBib29s Ci1pcGNwX3ZyX2xhdHRpY2U6Om1lZXRfd2l0aF8xIChjb25zdCB2YWx1ZV9yYW5nZSAqb3RoZXJf dnIpCitpcGNwX3ZyX2xhdHRpY2U6Om1lZXRfd2l0aF8xIChjb25zdCB2cmFuZ2UgJm90aGVyX3Zy KQogewogICBpZiAoYm90dG9tX3AgKCkpCiAgICAgcmV0dXJuIGZhbHNlOwogCi0gIGlmIChvdGhl cl92ci0+dmFyeWluZ19wICgpKQorICBpZiAob3RoZXJfdnIudmFyeWluZ19wICgpKQogICAgIHJl dHVybiBzZXRfdG9fYm90dG9tICgpOwogCiAgIGJvb2wgcmVzOwogICBpZiAoZmxhZ19jaGVja2lu ZykKICAgICB7Ci0gICAgICB2YWx1ZV9yYW5nZSBzYXZlIChtX3ZyKTsKLSAgICAgIHJlcyA9IG1f dnIudW5pb25fICgqb3RoZXJfdnIpOworICAgICAgVmFsdWVfUmFuZ2Ugc2F2ZSAobV92cik7Cisg ICAgICByZXMgPSBtX3ZyLnVuaW9uXyAob3RoZXJfdnIpOwogICAgICAgZ2NjX2Fzc2VydCAocmVz ID09IChtX3ZyICE9IHNhdmUpKTsKICAgICB9CiAgIGVsc2UKLSAgICByZXMgPSBtX3ZyLnVuaW9u XyAoKm90aGVyX3ZyKTsKKyAgICByZXMgPSBtX3ZyLnVuaW9uXyAob3RoZXJfdnIpOwogICByZXR1 cm4gcmVzOwogfQogCkBAIC0xMDc3LDEyICsxMDg2LDE1IEBAIGlwY3BfdnJfbGF0dGljZTo6c2V0 X3RvX2JvdHRvbSAoKQogewogICBpZiAobV92ci52YXJ5aW5nX3AgKCkpCiAgICAgcmV0dXJuIGZh bHNlOwotICAvKiA/PyBXZSBjcmVhdGUgYWxsIHNvcnRzIG9mIFZBUllJTkcgcmFuZ2VzIGZvciBm bG9hdHMsIHN0cnVjdHVyZXMsCi0gICAgIGFuZCBvdGhlciB0eXBlcyB3aGljaCB3ZSBjYW5ub3Qg aGFuZGxlIGFzIHJhbmdlcy4gIFdlIHNob3VsZAotICAgICBwcm9iYWJseSBhdm9pZCBoYW5kbGlu ZyB0aGVtIHRocm91Z2hvdXQgdGhlIHBhc3MsIGJ1dCBpdCdzIGVhc2llcgotICAgICB0byBjcmVh dGUgYSBzZW5zaWJsZSBWQVJZSU5HIGhlcmUgYW5kIGxldCB0aGUgbGF0dGljZQotICAgICBwcm9w YWdhdGUuICAqLwotICBtX3ZyLnNldF92YXJ5aW5nIChpbnRlZ2VyX3R5cGVfbm9kZSk7CisKKyAg LyogU2V0dGluZyBhbiB1bnN1cHBvcnRlZCB0eXBlIGhlcmUgZm9yY2VzIHRoZSB0ZW1wb3Jhcnkg dG8gZGVmYXVsdAorICAgICB0byB1bnN1cHBvcnRlZF9yYW5nZSwgd2hpY2ggY2FuIGhhbmRsZSBW QVJZSU5HL0RFRklORUQgcmFuZ2VzLAorICAgICBidXQgbm90aGluZyBlbHNlICh1bmlvbiwgaW50 ZXJzZWN0LCBldGMpLiAgVGhpcyBhbGxvd3MgdXMgdG8gc2V0CisgICAgIGJvdHRvbXMgb24gYW55 IHJhbmdlcywgYW5kIGlzIHNhZmUgYXMgYWxsIHVzZXJzIG9mIHRoZSBsYXR0aWNlCisgICAgIGNo ZWNrIGZvciBib3R0b20gZmlyc3QuICAqLworICBtX3ZyLnNldF90eXBlICh2b2lkX3R5cGVfbm9k ZSk7CisgIG1fdnIuc2V0X3ZhcnlpbmcgKHZvaWRfdHlwZV9ub2RlKTsKKwogICByZXR1cm4gdHJ1 ZTsKIH0KIApAQCAtMTY1Myw2ICsxNjY1LDcgQEAgaW5pdGlhbGl6ZV9ub2RlX2xhdHRpY2VzIChz dHJ1Y3QgY2dyYXBoX25vZGUgKm5vZGUpCiAgIGZvciAoaSA9IDA7IGkgPCBpcGFfZ2V0X3BhcmFt X2NvdW50IChpbmZvKTsgaSsrKQogICAgIHsKICAgICAgIGlwY3BfcGFyYW1fbGF0dGljZXMgKnBs YXRzID0gaXBhX2dldF9wYXJtX2xhdHRpY2VzIChpbmZvLCBpKTsKKyAgICAgIHRyZWUgdHlwZSA9 IGlwYV9nZXRfdHlwZSAoaW5mbywgaSk7CiAgICAgICBpZiAoZGlzYWJsZQogCSAgfHwgIWlwYV9n ZXRfdHlwZSAoaW5mbywgaSkKIAkgIHx8IChwcmVfbW9kaWZpZWQgJiYgKHN1cnZpdmluZ19wYXJh bXMubGVuZ3RoICgpIDw9ICh1bnNpZ25lZCkgaQpAQCAtMTY2MiwxMiArMTY3NSwxMiBAQCBpbml0 aWFsaXplX25vZGVfbGF0dGljZXMgKHN0cnVjdCBjZ3JhcGhfbm9kZSAqbm9kZSkKIAkgIHBsYXRz LT5jdHhsYXQuc2V0X3RvX2JvdHRvbSAoKTsKIAkgIHNldF9hZ2dfbGF0c190b19ib3R0b20gKHBs YXRzKTsKIAkgIHBsYXRzLT5iaXRzX2xhdHRpY2Uuc2V0X3RvX2JvdHRvbSAoKTsKLQkgIHBsYXRz LT5tX3ZhbHVlX3JhbmdlLm1fdnIgPSB2YWx1ZV9yYW5nZSAoKTsKKwkgIHBsYXRzLT5tX3ZhbHVl X3JhbmdlLmluaXQgKHR5cGUpOwogCSAgcGxhdHMtPm1fdmFsdWVfcmFuZ2Uuc2V0X3RvX2JvdHRv bSAoKTsKIAl9CiAgICAgICBlbHNlCiAJewotCSAgcGxhdHMtPm1fdmFsdWVfcmFuZ2UuaW5pdCAo KTsKKwkgIHBsYXRzLT5tX3ZhbHVlX3JhbmdlLmluaXQgKHR5cGUpOwogCSAgaWYgKHZhcmlhYmxl KQogCSAgICBzZXRfYWxsX2NvbnRhaW5zX3ZhcmlhYmxlIChwbGF0cyk7CiAJfQpAQCAtMTkwMCwx MSArMTkxMywxMSBAQCBpcGFfY29udGV4dF9mcm9tX2pmdW5jIChpcGFfbm9kZV9wYXJhbXMgKmlu Zm8sIGNncmFwaF9lZGdlICpjcywgaW50IGNzaWR4LAogCiAvKiBFbXVsYXRlIGVmZmVjdHMgb2Yg dW5hcnkgT1BFUkFUSU9OIGFuZC9vciBjb252ZXJzaW9uIGZyb20gU1JDX1RZUEUgdG8KICAgIERT VF9UWVBFIG9uIHZhbHVlIHJhbmdlIGluIFNSQ19WUiBhbmQgc3RvcmUgaXQgdG8gRFNUX1ZSLiAg UmV0dXJuIHRydWUgaWYKLSAgIHRoZSByZXN1bHQgaXMgYSByYW5nZSBvciBhbiBhbnRpLXJhbmdl LiAgKi8KKyAgIHRoZSByZXN1bHQgaXMgYSByYW5nZSB0aGF0IGlzIG5vdCBWQVJZSU5HIG5vciBV TkRFRklORUQuICAqLwogCiBzdGF0aWMgYm9vbAotaXBhX3ZyX29wZXJhdGlvbl9hbmRfdHlwZV9l ZmZlY3RzICh2YWx1ZV9yYW5nZSAqZHN0X3ZyLAotCQkJCSAgIHZhbHVlX3JhbmdlICpzcmNfdnIs CitpcGFfdnJfb3BlcmF0aW9uX2FuZF90eXBlX2VmZmVjdHMgKHZyYW5nZSAmZHN0X3ZyLAorCQkJ CSAgIGNvbnN0IHZyYW5nZSAmc3JjX3ZyLAogCQkJCSAgIGVudW0gdHJlZV9jb2RlIG9wZXJhdGlv biwKIAkJCQkgICB0cmVlIGRzdF90eXBlLCB0cmVlIHNyY190eXBlKQogewpAQCAtMTkxMiwyOSAr MTkyNSwzNSBAQCBpcGFfdnJfb3BlcmF0aW9uX2FuZF90eXBlX2VmZmVjdHMgKHZhbHVlX3Jhbmdl ICpkc3RfdnIsCiAgICAgcmV0dXJuIGZhbHNlOwogCiAgIHJhbmdlX29wX2hhbmRsZXIgaGFuZGxl ciAob3BlcmF0aW9uLCBkc3RfdHlwZSk7Ci0gIHJldHVybiAoaGFuZGxlcgotCSAgJiYgaGFuZGxl ci5mb2xkX3JhbmdlICgqZHN0X3ZyLCBkc3RfdHlwZSwKLQkJCQkgKnNyY192ciwgdmFsdWVfcmFu Z2UgKGRzdF90eXBlKSkKLQkgICYmICFkc3RfdnItPnZhcnlpbmdfcCAoKQotCSAgJiYgIWRzdF92 ci0+dW5kZWZpbmVkX3AgKCkpOworICBpZiAoIWhhbmRsZXIpCisgICAgcmV0dXJuIGZhbHNlOwor CisgIFZhbHVlX1JhbmdlIHZhcnlpbmcgKGRzdF90eXBlKTsKKyAgdmFyeWluZy5zZXRfdmFyeWlu ZyAoZHN0X3R5cGUpOworCisgIHJldHVybiAoaGFuZGxlci5mb2xkX3JhbmdlIChkc3RfdnIsIGRz dF90eXBlLCBzcmNfdnIsIHZhcnlpbmcpCisJICAmJiAhZHN0X3ZyLnZhcnlpbmdfcCAoKQorCSAg JiYgIWRzdF92ci51bmRlZmluZWRfcCAoKSk7CiB9CiAKIC8qIERldGVybWluZSByYW5nZSBvZiBK RlVOQyBnaXZlbiB0aGF0IElORk8gZGVzY3JpYmVzIHRoZSBjYWxsZXIgbm9kZSBvcgogICAgdGhl IG9uZSBpdCBpcyBpbmxpbmVkIHRvLCBDUyBpcyB0aGUgY2FsbCBncmFwaCBlZGdlIGNvcnJlc3Bv bmRpbmcgdG8gSkZVTkMKICAgIGFuZCBQQVJNX1RZUEUgb2YgdGhlIHBhcmFtZXRlci4gICovCiAK LXZhbHVlX3JhbmdlCi1pcGFfdmFsdWVfcmFuZ2VfZnJvbV9qZnVuYyAoaXBhX25vZGVfcGFyYW1z ICppbmZvLCBjZ3JhcGhfZWRnZSAqY3MsCit2b2lkCitpcGFfdmFsdWVfcmFuZ2VfZnJvbV9qZnVu YyAodnJhbmdlICZ2ciwKKwkJCSAgICBpcGFfbm9kZV9wYXJhbXMgKmluZm8sIGNncmFwaF9lZGdl ICpjcywKIAkJCSAgICBpcGFfanVtcF9mdW5jICpqZnVuYywgdHJlZSBwYXJtX3R5cGUpCiB7Ci0g IHZhbHVlX3JhbmdlIHZyOworICB2ci5zZXRfdW5kZWZpbmVkICgpOworCiAgIGlmIChqZnVuYy0+ bV92cikKLSAgICBpcGFfdnJfb3BlcmF0aW9uX2FuZF90eXBlX2VmZmVjdHMgKCZ2ciwKLQkJCQkg ICAgICAgamZ1bmMtPm1fdnIsCisgICAgaXBhX3ZyX29wZXJhdGlvbl9hbmRfdHlwZV9lZmZlY3Rz ICh2ciwKKwkJCQkgICAgICAgKmpmdW5jLT5tX3ZyLAogCQkJCSAgICAgICBOT1BfRVhQUiwgcGFy bV90eXBlLAogCQkJCSAgICAgICBqZnVuYy0+bV92ci0+dHlwZSAoKSk7CiAgIGlmICh2ci5zaW5n bGV0b25fcCAoKSkKLSAgICByZXR1cm4gdnI7CisgICAgcmV0dXJuOwogICBpZiAoamZ1bmMtPnR5 cGUgPT0gSVBBX0pGX1BBU1NfVEhST1VHSCkKICAgICB7CiAgICAgICBpbnQgaWR4OwpAQCAtMTk0 MywzMyArMTk2MiwzNCBAQCBpcGFfdmFsdWVfcmFuZ2VfZnJvbV9qZnVuYyAoaXBhX25vZGVfcGFy YW1zICppbmZvLCBjZ3JhcGhfZWRnZSAqY3MsCiAJCQkJCSAgID8gY3MtPmNhbGxlci0+aW5saW5l ZF90bwogCQkJCQkgICA6IGNzLT5jYWxsZXIpOwogICAgICAgaWYgKCFzdW0gfHwgIXN1bS0+bV92 cikKLQlyZXR1cm4gdnI7CisJcmV0dXJuOwogCiAgICAgICBpZHggPSBpcGFfZ2V0X2pmX3Bhc3Nf dGhyb3VnaF9mb3JtYWxfaWQgKGpmdW5jKTsKIAogICAgICAgaWYgKCEoKnN1bS0+bV92cilbaWR4 XS5rbm93bl9wICgpKQotCXJldHVybiB2cjsKKwlyZXR1cm47CiAgICAgICB0cmVlIHZyX3R5cGUg PSBpcGFfZ2V0X3R5cGUgKGluZm8sIGlkeCk7Ci0gICAgICB2YWx1ZV9yYW5nZSBzcmN2cjsKKyAg ICAgIFZhbHVlX1JhbmdlIHNyY3ZyOwogICAgICAgKCpzdW0tPm1fdnIpW2lkeF0uZ2V0X3ZyYW5n ZSAoc3JjdnIpOwogCiAgICAgICBlbnVtIHRyZWVfY29kZSBvcGVyYXRpb24gPSBpcGFfZ2V0X2pm X3Bhc3NfdGhyb3VnaF9vcGVyYXRpb24gKGpmdW5jKTsKIAogICAgICAgaWYgKFRSRUVfQ09ERV9D TEFTUyAob3BlcmF0aW9uKSA9PSB0Y2NfdW5hcnkpCiAJewotCSAgdmFsdWVfcmFuZ2UgcmVzOwor CSAgVmFsdWVfUmFuZ2UgcmVzICh2cl90eXBlKTsKIAotCSAgaWYgKGlwYV92cl9vcGVyYXRpb25f YW5kX3R5cGVfZWZmZWN0cyAoJnJlcywKLQkJCQkJCSAmc3JjdnIsCisJICBpZiAoaXBhX3ZyX29w ZXJhdGlvbl9hbmRfdHlwZV9lZmZlY3RzIChyZXMsCisJCQkJCQkgc3JjdnIsCiAJCQkJCQkgb3Bl cmF0aW9uLCBwYXJtX3R5cGUsCiAJCQkJCQkgdnJfdHlwZSkpCiAJICAgIHZyLmludGVyc2VjdCAo cmVzKTsKIAl9CiAgICAgICBlbHNlCiAJewotCSAgdmFsdWVfcmFuZ2Ugb3BfcmVzLCByZXM7CisJ ICBWYWx1ZV9SYW5nZSBvcF9yZXMgKHZyX3R5cGUpOworCSAgVmFsdWVfUmFuZ2UgcmVzICh2cl90 eXBlKTsKIAkgIHRyZWUgb3AgPSBpcGFfZ2V0X2pmX3Bhc3NfdGhyb3VnaF9vcGVyYW5kIChqZnVu Yyk7Ci0JICB2YWx1ZV9yYW5nZSBvcF92cjsKKwkgIFZhbHVlX1JhbmdlIG9wX3ZyICh2cl90eXBl KTsKIAkgIHJhbmdlX29wX2hhbmRsZXIgaGFuZGxlciAob3BlcmF0aW9uLCB2cl90eXBlKTsKIAog CSAgaXBhX3JhbmdlX3NldF9hbmRfbm9ybWFsaXplIChvcF92ciwgb3ApOwpAQCAtMTk3OSwxNCAr MTk5OSwxMyBAQCBpcGFfdmFsdWVfcmFuZ2VfZnJvbV9qZnVuYyAoaXBhX25vZGVfcGFyYW1zICpp bmZvLCBjZ3JhcGhfZWRnZSAqY3MsCiAJICAgICAgfHwgIWhhbmRsZXIuZm9sZF9yYW5nZSAob3Bf cmVzLCB2cl90eXBlLCBzcmN2ciwgb3BfdnIpKQogCSAgICBvcF9yZXMuc2V0X3ZhcnlpbmcgKHZy X3R5cGUpOwogCi0JICBpZiAoaXBhX3ZyX29wZXJhdGlvbl9hbmRfdHlwZV9lZmZlY3RzICgmcmVz LAotCQkJCQkJICZvcF9yZXMsCisJICBpZiAoaXBhX3ZyX29wZXJhdGlvbl9hbmRfdHlwZV9lZmZl Y3RzIChyZXMsCisJCQkJCQkgb3BfcmVzLAogCQkJCQkJIE5PUF9FWFBSLCBwYXJtX3R5cGUsCiAJ CQkJCQkgdnJfdHlwZSkpCiAJICAgIHZyLmludGVyc2VjdCAocmVzKTsKIAl9CiAgICAgfQotICBy ZXR1cm4gdnI7CiB9CiAKIC8qIERldGVybWluZSB3aGV0aGVyIElURU0sIGp1bXAgZnVuY3Rpb24g Zm9yIGFuIGFnZ3JlZ2F0ZSBwYXJ0LCBldmFsdWF0ZXMgdG8gYQpAQCAtMjc1MywxMCArMjc3Miwx MCBAQCBwcm9wYWdhdGVfdnJfYWNyb3NzX2p1bXBfZnVuY3Rpb24gKGNncmFwaF9lZGdlICpjcywg aXBhX2p1bXBfZnVuYyAqamZ1bmMsCiAgICAgICBpZiAoc3JjX2xhdHMtPm1fdmFsdWVfcmFuZ2Uu Ym90dG9tX3AgKCkpCiAJcmV0dXJuIGRlc3RfbGF0LT5zZXRfdG9fYm90dG9tICgpOwogCi0gICAg ICB2YWx1ZV9yYW5nZSB2cjsKKyAgICAgIFZhbHVlX1JhbmdlIHZyIChvcGVyYW5kX3R5cGUpOwog ICAgICAgaWYgKFRSRUVfQ09ERV9DTEFTUyAob3BlcmF0aW9uKSA9PSB0Y2NfdW5hcnkpCi0JaXBh X3ZyX29wZXJhdGlvbl9hbmRfdHlwZV9lZmZlY3RzICgmdnIsCi0JCQkJCSAgICZzcmNfbGF0cy0+ bV92YWx1ZV9yYW5nZS5tX3ZyLAorCWlwYV92cl9vcGVyYXRpb25fYW5kX3R5cGVfZWZmZWN0cyAo dnIsCisJCQkJCSAgIHNyY19sYXRzLT5tX3ZhbHVlX3JhbmdlLm1fdnIsCiAJCQkJCSAgIG9wZXJh dGlvbiwgcGFyYW1fdHlwZSwKIAkJCQkJICAgb3BlcmFuZF90eXBlKTsKICAgICAgIC8qIEEgY3J1 ZGUgd2F5IHRvIHByZXZlbnQgdW5ib3VuZGVkIG51bWJlciBvZiB2YWx1ZSByYW5nZSB1cGRhdGVz CkBAIC0yNzY1LDggKzI3ODQsOCBAQCBwcm9wYWdhdGVfdnJfYWNyb3NzX2p1bXBfZnVuY3Rpb24g KGNncmFwaF9lZGdlICpjcywgaXBhX2p1bXBfZnVuYyAqamZ1bmMsCiAgICAgICBlbHNlIGlmICgh aXBhX2VkZ2Vfd2l0aGluX3NjYyAoY3MpKQogCXsKIAkgIHRyZWUgb3AgPSBpcGFfZ2V0X2pmX3Bh c3NfdGhyb3VnaF9vcGVyYW5kIChqZnVuYyk7Ci0JICB2YWx1ZV9yYW5nZSBvcF92cjsKLQkgIHZh bHVlX3JhbmdlIG9wX3JlcyxyZXM7CisJICBWYWx1ZV9SYW5nZSBvcF92ciAoVFJFRV9UWVBFIChv cCkpOworCSAgVmFsdWVfUmFuZ2Ugb3BfcmVzIChvcGVyYW5kX3R5cGUpOwogCSAgcmFuZ2Vfb3Bf aGFuZGxlciBoYW5kbGVyIChvcGVyYXRpb24sIG9wZXJhbmRfdHlwZSk7CiAKIAkgIGlwYV9yYW5n ZV9zZXRfYW5kX25vcm1hbGl6ZSAob3BfdnIsIG9wKTsKQEAgLTI3NzcsOCArMjc5Niw4IEBAIHBy b3BhZ2F0ZV92cl9hY3Jvc3NfanVtcF9mdW5jdGlvbiAoY2dyYXBoX2VkZ2UgKmNzLCBpcGFfanVt cF9mdW5jICpqZnVuYywKIAkJCQkgICAgICBzcmNfbGF0cy0+bV92YWx1ZV9yYW5nZS5tX3ZyLCBv cF92cikpCiAJICAgIG9wX3Jlcy5zZXRfdmFyeWluZyAob3BlcmFuZF90eXBlKTsKIAotCSAgaXBh X3ZyX29wZXJhdGlvbl9hbmRfdHlwZV9lZmZlY3RzICgmdnIsCi0JCQkJCSAgICAgJm9wX3JlcywK KwkgIGlwYV92cl9vcGVyYXRpb25fYW5kX3R5cGVfZWZmZWN0cyAodnIsCisJCQkJCSAgICAgb3Bf cmVzLAogCQkJCQkgICAgIE5PUF9FWFBSLCBwYXJhbV90eXBlLAogCQkJCQkgICAgIG9wZXJhbmRf dHlwZSk7CiAJfQpAQCAtMjc4NiwxNCArMjgwNSwxNCBAQCBwcm9wYWdhdGVfdnJfYWNyb3NzX2p1 bXBfZnVuY3Rpb24gKGNncmFwaF9lZGdlICpjcywgaXBhX2p1bXBfZnVuYyAqamZ1bmMsCiAJewog CSAgaWYgKGpmdW5jLT5tX3ZyKQogCSAgICB7Ci0JICAgICAgdmFsdWVfcmFuZ2UganZyOwotCSAg ICAgIGlmIChpcGFfdnJfb3BlcmF0aW9uX2FuZF90eXBlX2VmZmVjdHMgKCZqdnIsIGpmdW5jLT5t X3ZyLAorCSAgICAgIFZhbHVlX1JhbmdlIGp2ciAocGFyYW1fdHlwZSk7CisJICAgICAgaWYgKGlw YV92cl9vcGVyYXRpb25fYW5kX3R5cGVfZWZmZWN0cyAoanZyLCAqamZ1bmMtPm1fdnIsCiAJCQkJ CQkgICAgIE5PUF9FWFBSLAogCQkJCQkJICAgICBwYXJhbV90eXBlLAogCQkJCQkJICAgICBqZnVu Yy0+bV92ci0+dHlwZSAoKSkpCiAJCXZyLmludGVyc2VjdCAoanZyKTsKIAkgICAgfQotCSAgcmV0 dXJuIGRlc3RfbGF0LT5tZWV0X3dpdGggKCZ2cik7CisJICByZXR1cm4gZGVzdF9sYXQtPm1lZXRf d2l0aCAodnIpOwogCX0KICAgICB9CiAgIGVsc2UgaWYgKGpmdW5jLT50eXBlID09IElQQV9KRl9D T05TVCkKQEAgLTI4MDUsMTggKzI4MjQsMTcgQEAgcHJvcGFnYXRlX3ZyX2Fjcm9zc19qdW1wX2Z1 bmN0aW9uIChjZ3JhcGhfZWRnZSAqY3MsIGlwYV9qdW1wX2Z1bmMgKmpmdW5jLAogCSAgaWYgKFRS RUVfT1ZFUkZMT1dfUCAodmFsKSkKIAkgICAgdmFsID0gZHJvcF90cmVlX292ZXJmbG93ICh2YWwp OwogCi0JICB2YWx1ZV9yYW5nZSB0bXB2ciAoVFJFRV9UWVBFICh2YWwpLAotCQkJICAgICB3aTo6 dG9fd2lkZSAodmFsKSwgd2k6OnRvX3dpZGUgKHZhbCkpOwotCSAgcmV0dXJuIGRlc3RfbGF0LT5t ZWV0X3dpdGggKCZ0bXB2cik7CisJICBWYWx1ZV9SYW5nZSB0bXB2ciAodmFsLCB2YWwpOworCSAg cmV0dXJuIGRlc3RfbGF0LT5tZWV0X3dpdGggKHRtcHZyKTsKIAl9CiAgICAgfQogCi0gIHZhbHVl X3JhbmdlIHZyOworICBWYWx1ZV9SYW5nZSB2ciAocGFyYW1fdHlwZSk7CiAgIGlmIChqZnVuYy0+ bV92cgotICAgICAgJiYgaXBhX3ZyX29wZXJhdGlvbl9hbmRfdHlwZV9lZmZlY3RzICgmdnIsIGpm dW5jLT5tX3ZyLCBOT1BfRVhQUiwKKyAgICAgICYmIGlwYV92cl9vcGVyYXRpb25fYW5kX3R5cGVf ZWZmZWN0cyAodnIsICpqZnVuYy0+bV92ciwgTk9QX0VYUFIsCiAJCQkJCSAgICBwYXJhbV90eXBl LAogCQkJCQkgICAgamZ1bmMtPm1fdnItPnR5cGUgKCkpKQotICAgIHJldHVybiBkZXN0X2xhdC0+ bWVldF93aXRoICgmdnIpOworICAgIHJldHVybiBkZXN0X2xhdC0+bWVldF93aXRoICh2cik7CiAg IGVsc2UKICAgICByZXR1cm4gZGVzdF9sYXQtPnNldF90b19ib3R0b20gKCk7CiB9CmRpZmYgLS1n aXQgYS9nY2MvaXBhLWZuc3VtbWFyeS5jYyBiL2djYy9pcGEtZm5zdW1tYXJ5LmNjCmluZGV4IGIz MjhiYjhjZTE0Li5jZjQxNjIwMjkyMCAxMDA2NDQKLS0tIGEvZ2NjL2lwYS1mbnN1bW1hcnkuY2MK KysrIGIvZ2NjL2lwYS1mbnN1bW1hcnkuY2MKQEAgLTQ3NSw3ICs0NzUsNyBAQCBldmFsdWF0ZV9j b25kaXRpb25zX2Zvcl9rbm93bl9hcmdzIChzdHJ1Y3QgY2dyYXBoX25vZGUgKm5vZGUsCiAJICAm JiAhYy0+YWdnX2NvbnRlbnRzCiAJICAmJiAoIXZhbCB8fCBUUkVFX0NPREUgKHZhbCkgIT0gSU5U RUdFUl9DU1QpKQogCXsKLQkgIHZhbHVlX3JhbmdlIHZyID0gYXZhbHMtPm1fa25vd25fdmFsdWVf cmFuZ2VzW2MtPm9wZXJhbmRfbnVtXTsKKwkgIFZhbHVlX1JhbmdlIHZyIChhdmFscy0+bV9rbm93 bl92YWx1ZV9yYW5nZXNbYy0+b3BlcmFuZF9udW1dKTsKIAkgIGlmICghdnIudW5kZWZpbmVkX3Ag KCkKIAkgICAgICAmJiAhdnIudmFyeWluZ19wICgpCiAJICAgICAgJiYgKFRZUEVfU0laRSAoYy0+ dHlwZSkgPT0gVFlQRV9TSVpFICh2ci50eXBlICgpKSkpCkBAIC02MzAsOCArNjMwLDggQEAgZXZh bHVhdGVfcHJvcGVydGllc19mb3JfZWRnZSAoc3RydWN0IGNncmFwaF9lZGdlICplLCBib29sIGlu bGluZV9wLAogCQl8fCBpcGFfaXNfcGFyYW1fdXNlZF9ieV9pcGFfcHJlZGljYXRlcyAoY2FsbGVl X3BpLCBpKSkKIAkgICAgICB7CiAJCS8qIERldGVybWluZSBpZiB3ZSBrbm93IGNvbnN0YW50IHZh bHVlIG9mIHRoZSBwYXJhbWV0ZXIuICAqLwotCQl0cmVlIGNzdCA9IGlwYV92YWx1ZV9mcm9tX2pm dW5jIChjYWxsZXJfcGFybXNfaW5mbywgamYsCi0JCQkJCQkgaXBhX2dldF90eXBlIChjYWxsZWVf cGksIGkpKTsKKwkJdHJlZSB0eXBlID0gaXBhX2dldF90eXBlIChjYWxsZWVfcGksIGkpOworCQl0 cmVlIGNzdCA9IGlwYV92YWx1ZV9mcm9tX2pmdW5jIChjYWxsZXJfcGFybXNfaW5mbywgamYsIHR5 cGUpOwogCiAJCWlmICghY3N0ICYmIGUtPmNhbGxfc3RtdAogCQkgICAgJiYgaSA8IChpbnQpZ2lt cGxlX2NhbGxfbnVtX2FyZ3MgKGUtPmNhbGxfc3RtdCkpCkBAIC02NTksMTAgKzY1OSw5IEBAIGV2 YWx1YXRlX3Byb3BlcnRpZXNfZm9yX2VkZ2UgKHN0cnVjdCBjZ3JhcGhfZWRnZSAqZSwgYm9vbCBp bmxpbmVfcCwKIAkJICAgICYmIHZycF93aWxsX3J1bl9wIChjYWxsZXIpCiAJCSAgICAmJiBpcGFf aXNfcGFyYW1fdXNlZF9ieV9pcGFfcHJlZGljYXRlcyAoY2FsbGVlX3BpLCBpKSkKIAkJICB7Ci0J CSAgICB2YWx1ZV9yYW5nZSB2cgotCQkgICAgICAgPSBpcGFfdmFsdWVfcmFuZ2VfZnJvbV9qZnVu YyAoY2FsbGVyX3Bhcm1zX2luZm8sIGUsIGpmLAotCQkJCQkJICAgICBpcGFfZ2V0X3R5cGUgKGNh bGxlZV9waSwKLQkJCQkJCQkJICAgaSkpOworCQkgICAgVmFsdWVfUmFuZ2UgdnIgKHR5cGUpOwor CisJCSAgICBpcGFfdmFsdWVfcmFuZ2VfZnJvbV9qZnVuYyAodnIsIGNhbGxlcl9wYXJtc19pbmZv LCBlLCBqZiwgdHlwZSk7CiAJCSAgICBpZiAoIXZyLnVuZGVmaW5lZF9wICgpICYmICF2ci52YXJ5 aW5nX3AgKCkpCiAJCSAgICAgIHsKIAkJCWlmICghYXZhbHMtPm1fa25vd25fdmFsdWVfcmFuZ2Vz Lmxlbmd0aCAoKSkKQEAgLTY3MCw3ICs2NjksNyBAQCBldmFsdWF0ZV9wcm9wZXJ0aWVzX2Zvcl9l ZGdlIChzdHJ1Y3QgY2dyYXBoX2VkZ2UgKmUsIGJvb2wgaW5saW5lX3AsCiAJCQkgICAgYXZhbHMt Pm1fa25vd25fdmFsdWVfcmFuZ2VzLnNhZmVfZ3JvdyAoY291bnQsIHRydWUpOwogCQkJICAgIGZv ciAoaW50IGkgPSAwOyBpIDwgY291bnQ7ICsraSkKIAkJCSAgICAgIG5ldyAoJmF2YWxzLT5tX2tu b3duX3ZhbHVlX3Jhbmdlc1tpXSkKLQkJCQl2YWx1ZV9yYW5nZSAoKTsKKwkJCQlWYWx1ZV9SYW5n ZSAoKTsKIAkJCSAgfQogCQkJYXZhbHMtPm1fa25vd25fdmFsdWVfcmFuZ2VzW2ldID0gdnI7CiAJ CSAgICAgIH0KZGlmZiAtLWdpdCBhL2djYy9pcGEtcHJvcC5jYyBiL2djYy9pcGEtcHJvcC5jYwpp bmRleCBhYjZkZTlmMTBkYS4uYmJmZTBmOGFhNDUgMTAwNjQ0Ci0tLSBhL2djYy9pcGEtcHJvcC5j YworKysgYi9nY2MvaXBhLXByb3AuY2MKQEAgLTE5OCw4ICsxOTgsOSBAQCBpcGFfdnI6OmVxdWFs X3AgKGNvbnN0IHZyYW5nZSAmcikgY29uc3QKIH0KIAogdm9pZAotaXBhX3ZyOjpnZXRfdnJhbmdl ICh2cmFuZ2UgJnIpIGNvbnN0CitpcGFfdnI6OmdldF92cmFuZ2UgKFZhbHVlX1JhbmdlICZyKSBj b25zdAogeworICByLnNldF90eXBlIChtX3R5cGUpOwogICBtX3N0b3JhZ2UtPmdldF92cmFuZ2Ug KHIsIG1fdHlwZSk7CiB9CiAKQEAgLTU5NjMsNyArNTk2NCw3IEBAIGlwY3BfdXBkYXRlX3ZyIChz dHJ1Y3QgY2dyYXBoX25vZGUgKm5vZGUpCiAKICAgICAgIGlmICh2cltpXS5rbm93bl9wICgpKQog CXsKLQkgIHZhbHVlX3JhbmdlIHRtcDsKKwkgIFZhbHVlX1JhbmdlIHRtcDsKIAkgIHZyW2ldLmdl dF92cmFuZ2UgKHRtcCk7CiAKIAkgIGlmICghdG1wLnVuZGVmaW5lZF9wICgpICYmICF0bXAudmFy eWluZ19wICgpKQpkaWZmIC0tZ2l0IGEvZ2NjL2lwYS1wcm9wLmggYi9nY2MvaXBhLXByb3AuaApp bmRleCBmMzA2ZjhhMzc3ZS4uM2E1OTFhOGY0NGQgMTAwNjQ0Ci0tLSBhL2djYy9pcGEtcHJvcC5o CisrKyBiL2djYy9pcGEtcHJvcC5oCkBAIC0zMTQsNyArMzE0LDcgQEAgcHVibGljOgogICB2b2lk IHNldF91bmtub3duICgpOwogICBib29sIGtub3duX3AgKCkgY29uc3QgeyByZXR1cm4gbV9zdG9y YWdlICE9IE5VTEw7IH0KICAgdHJlZSB0eXBlICgpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZTsgfQot ICB2b2lkIGdldF92cmFuZ2UgKHZyYW5nZSAmKSBjb25zdDsKKyAgdm9pZCBnZXRfdnJhbmdlIChW YWx1ZV9SYW5nZSAmKSBjb25zdDsKICAgYm9vbCBlcXVhbF9wIChjb25zdCB2cmFuZ2UgJikgY29u c3Q7CiAgIGNvbnN0IHZyYW5nZV9zdG9yYWdlICpzdG9yYWdlICgpIGNvbnN0IHsgcmV0dXJuIG1f c3RvcmFnZTsgfQogICB2b2lkIHN0cmVhbWVyX3JlYWQgKGx0b19pbnB1dF9ibG9jayAqLCBkYXRh X2luICopOwpAQCAtNTMwLDcgKzUzMCw3IEBAIHB1YmxpYzoKICAgYXV0b192ZWM8aXBhX2FyZ2Fn Z192YWx1ZSwgMzI+IG1fa25vd25fYWdnczsKIAogICAvKiBWZWN0b3IgZGVzY3JpYmluZyBrbm93 biB2YWx1ZSByYW5nZXMgb2YgYXJndW1lbnRzLiAgKi8KLSAgYXV0b192ZWM8dmFsdWVfcmFuZ2Us IDMyPiBtX2tub3duX3ZhbHVlX3JhbmdlczsKKyAgYXV0b192ZWM8VmFsdWVfUmFuZ2UsIDMyPiBt X2tub3duX3ZhbHVlX3JhbmdlczsKIH07CiAKIGlubGluZQpAQCAtNTgyLDcgKzU4Miw3IEBAIHB1 YmxpYzoKICAgdmVjPGlwYV9hcmdhZ2dfdmFsdWU+IG1fa25vd25fYWdncyA9IHZOVUxMOwogCiAg IC8qIFZlY3RvciBkZXNjcmliaW5nIGtub3duIHZhbHVlIHJhbmdlcyBvZiBhcmd1bWVudHMuICAq LwotICB2ZWM8dmFsdWVfcmFuZ2U+IG1fa25vd25fdmFsdWVfcmFuZ2VzID0gdk5VTEw7CisgIHZl YzxWYWx1ZV9SYW5nZT4gbV9rbm93bl92YWx1ZV9yYW5nZXMgPSB2TlVMTDsKIH07CiAKIGlubGlu ZQpAQCAtMTE5NCw4ICsxMTk0LDggQEAgaXBhX3BvbHltb3JwaGljX2NhbGxfY29udGV4dCBpcGFf Y29udGV4dF9mcm9tX2pmdW5jIChpcGFfbm9kZV9wYXJhbXMgKiwKIAkJCQkJCSAgICAgY2dyYXBo X2VkZ2UgKiwKIAkJCQkJCSAgICAgaW50LAogCQkJCQkJICAgICBpcGFfanVtcF9mdW5jICopOwot dmFsdWVfcmFuZ2UgaXBhX3ZhbHVlX3JhbmdlX2Zyb21famZ1bmMgKGlwYV9ub2RlX3BhcmFtcyAq LCBjZ3JhcGhfZWRnZSAqLAotCQkJCQlpcGFfanVtcF9mdW5jICosIHRyZWUpOwordm9pZCBpcGFf dmFsdWVfcmFuZ2VfZnJvbV9qZnVuYyAodnJhbmdlICYsIGlwYV9ub2RlX3BhcmFtcyAqLCBjZ3Jh cGhfZWRnZSAqLAorCQkJCSBpcGFfanVtcF9mdW5jICosIHRyZWUpOwogdm9pZCBpcGFfcHVzaF9h Z2dfdmFsdWVzX2Zyb21famZ1bmMgKGlwYV9ub2RlX3BhcmFtcyAqaW5mbywgY2dyYXBoX25vZGUg Km5vZGUsCiAJCQkJICAgICBpcGFfYWdnX2p1bXBfZnVuY3Rpb24gKmFnZ19qZnVuYywKIAkJCQkg ICAgIHVuc2lnbmVkIGRzdF9pbmRleCwKQEAgLTEyMTgsMTcgKzEyMTgsMTIgQEAgdm9pZCBpcGFf Y3BfY2NfZmluYWxpemUgKHZvaWQpOwogICAgbm9uLXplcm8uICAqLwogCiBpbmxpbmUgdm9pZAot aXBhX3JhbmdlX3NldF9hbmRfbm9ybWFsaXplIChpcmFuZ2UgJnIsIHRyZWUgdmFsKQoraXBhX3Jh bmdlX3NldF9hbmRfbm9ybWFsaXplICh2cmFuZ2UgJnIsIHRyZWUgdmFsKQogewotICBpZiAoVFJF RV9DT0RFICh2YWwpID09IElOVEVHRVJfQ1NUKQotICAgIHsKLSAgICAgIHdpZGVfaW50IHcgPSB3 aTo6dG9fd2lkZSAodmFsKTsKLSAgICAgIHIuc2V0IChUUkVFX1RZUEUgKHZhbCksIHcsIHcpOwot ICAgIH0KLSAgZWxzZSBpZiAoVFJFRV9DT0RFICh2YWwpID09IEFERFJfRVhQUikKKyAgaWYgKFRS RUVfQ09ERSAodmFsKSA9PSBBRERSX0VYUFIpCiAgICAgci5zZXRfbm9uemVybyAoVFJFRV9UWVBF ICh2YWwpKTsKICAgZWxzZQotICAgIHIuc2V0X3ZhcnlpbmcgKFRSRUVfVFlQRSAodmFsKSk7Cisg ICAgci5zZXQgKHZhbCwgdmFsKTsKIH0KIAogI2VuZGlmIC8qIElQQV9QUk9QX0ggKi8KLS0gCjIu NDAuMQoK --------------BAnkGXH6jS85B0YrZ6BGbVy5--