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 F16AD3834E75 for ; Wed, 1 Jun 2022 09:02:11 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org F16AD3834E75 Received: from mail-oa1-f71.google.com (mail-oa1-f71.google.com [209.85.160.71]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-62-DBSltEZPPv6i_1rqS5V2Ig-1; Wed, 01 Jun 2022 05:02:08 -0400 X-MC-Unique: DBSltEZPPv6i_1rqS5V2Ig-1 Received: by mail-oa1-f71.google.com with SMTP id 586e51a60fabf-f31b1fc69bso933121fac.3 for ; Wed, 01 Jun 2022 02:02:08 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=BzjNZlQT/HidSOVNgySKpwqGMzwOwIWSu/tnkLlGwGI=; b=pTdDvdYvBJLpguBQV3C6073KlvjFZ8b/P4xfq1ogdqEwQPnAPRJMIM8HqYnQTABSgJ 4ww300KR5/b/Zz/7JmFLjyGrBQouAmy6H34VoO91YQ1Fvv741/HxxAFxvgJxkmjmp84i 6zzId+Pc5coO6bgG/EdqksnbEi4uWcadLJpin6kzaawZ0GIeComqkJRqhlwsHofCcaLd J2vWdEX050ZbCC3Yc4NC3ZWxgNtTIWt+CW+LKEYdzBmhjWMIfBz9qTngoMVxFEJ1IXrv XYgnED8+srh4Cqs0FMImsliYZBtDH0MZUPcORwTpIOjRQoK5LFOEptllK3kGG8uvffX8 CaMg== X-Gm-Message-State: AOAM531qh58YaMfE3EYgDyLP5Acjp8dT6W3+QYOJEEYvRK2uk0duMRrJ arC0BRXAJK+hRobUuS+h0gVxgFlrpzySXS/lyx2RLw93Y8dl2Pf/ZOuW5YPpfjxXpT75+VSeQ5O Oe5Xr+5I42CBez1/TCNRiiMQvfzpnZh2HPA== X-Received: by 2002:a05:6870:c38e:b0:ed:f230:1494 with SMTP id g14-20020a056870c38e00b000edf2301494mr15928351oao.36.1654074127028; Wed, 01 Jun 2022 02:02:07 -0700 (PDT) X-Google-Smtp-Source: ABdhPJxsZEDNn54nAcSv6SKs6bhZDnhmbByBDqxNeFdjBY1IOVDdP9GxSKro4HHjsC3K9ShU2WnI2GRFxk7ebljWadg= X-Received: by 2002:a05:6870:c38e:b0:ed:f230:1494 with SMTP id g14-20020a056870c38e00b000edf2301494mr15928298oao.36.1654074125928; Wed, 01 Jun 2022 02:02:05 -0700 (PDT) MIME-Version: 1.0 References: <20220530132751.1752112-1-aldyh@redhat.com> <20220530132751.1752112-3-aldyh@redhat.com> In-Reply-To: <20220530132751.1752112-3-aldyh@redhat.com> From: Aldy Hernandez Date: Wed, 1 Jun 2022 11:01:54 +0200 Message-ID: Subject: Re: [PATCH 3/5] Convert range-op.* to vrange. To: GCC patches X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: multipart/mixed; boundary="000000000000b58e2405e05f2484" X-Spam-Status: No, score=-11.9 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, 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 X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 01 Jun 2022 09:02:20 -0000 --000000000000b58e2405e05f2484 Content-Type: text/plain; charset="UTF-8" Final patch committed. Re-tested on x86-64 Linux. On Mon, May 30, 2022 at 3:28 PM Aldy Hernandez wrote: > > This patch provides the infrastructure to make range-ops type agnostic. > > First, the range_op_handler function has been replaced with an object > of the same name. It's coded in such a way to minimize changes to the > code base, and to encapsulate the dispatch code. > > Instead of: > > range_operator *op = range_op_handler (code, type); > if (op) > op->fold_range (...); > > We now do: > range_op_handler op (code, type); > if (op) > op->fold_range (...); > > I've folded gimple_range_handler into the range_op_handler class, > since it's also a query into the range operators. > > Instead of: > > range_operator *handler = gimple_range_handler (stmt); > > We now do: > > range_op_handler handler (stmt); > > This all has the added benefit of moving all the dispatch code into an > independent class and avoid polluting range_operator (which we'll > further split later when frange and prange come live). > > There's this annoying "using" keyword that's been added to each > operator due to hiding rules in C++. The issue is that we will have > different virtual versions of fold_range() for each combination of > operands. For example: > > // Traditional binary op on irange's. > fold_range (irange &lhs, const irange &op1, const irange &op2); > // For POINTER_DIFF_EXPR: > fold_range (irange &lhs, const prange &op1, const prange &op2); > // Cast from irange to prange. > fold_range (prange &lhs, const irange &op1, const irange &op2); > > Overloading virtuals when there are multiple same named methods causes > hidden virtuals warnings from -Woverloaded-virtual, thus the using > keyword. An alternative would be to have different names: > fold_range_III, fold_range_IPP, fold_range_PII, but that's uglier > still. > > Tested on x86-64 & ppc64le Linux. > > gcc/ChangeLog: > > * gimple-range-edge.cc (gimple_outgoing_range_stmt_p): Adjust for > vrange and convert range_op_handler function calls to use the > identically named object. > * gimple-range-fold.cc (gimple_range_operand1): Same. > (gimple_range_operand2): Same. > (fold_using_range::fold_stmt): Same. > (fold_using_range::range_of_range_op): Same. > (fold_using_range::range_of_builtin_ubsan_call): Same. > (fold_using_range::relation_fold_and_or): Same. > (fur_source::register_outgoing_edges): Same. > * gimple-range-fold.h (gimple_range_handler): Remove. > * gimple-range-gori.cc (gimple_range_calc_op1): Adjust for vrange. > (gimple_range_calc_op2): Same. > (range_def_chain::get_def_chain): Same. > (gori_compute::compute_operand_range): Same. > (gori_compute::condexpr_adjust): Same. > * gimple-range.cc (gimple_ranger::prefill_name): Same. > (gimple_ranger::prefill_stmt_dependencies): Same. > * range-op.cc (get_bool_state): Same. > (class operator_equal): Add using clause. > (class operator_not_equal): Same. > (class operator_lt): Same. > (class operator_le): Same. > (class operator_gt): Same. > (class operator_ge): Same. > (class operator_plus): Same. > (class operator_minus): Same. > (class operator_mult): Same. > (class operator_exact_divide): Same. > (class operator_lshift): Same. > (class operator_rshift): Same. > (class operator_cast): Same. > (class operator_logical_and): Same. > (class operator_bitwise_and): Same. > (class operator_logical_or): Same. > (class operator_bitwise_or): Same. > (class operator_bitwise_xor): Same. > (class operator_trunc_mod): Same. > (class operator_logical_not): Same. > (class operator_bitwise_not): Same. > (class operator_cst): Same. > (class operator_identity): Same. > (class operator_unknown): Same. > (class operator_abs): Same. > (class operator_negate): Same. > (class operator_addr_expr): Same. > (class pointer_or_operator): Same. > (operator_plus::op1_range): Adjust for vrange. > (operator_minus::op1_range): Same. > (operator_mult::op1_range): Same. > (operator_cast::op1_range): Same. > (operator_bitwise_not::fold_range): Same. > (operator_negate::fold_range): Same. > (range_op_handler): Rename to... > (get_handler): ...this. > (range_op_handler::range_op_handler): New. > (range_op_handler::fold_range): New. > (range_op_handler::op1_range): New. > (range_op_handler::op2_range): New. > (range_op_handler::lhs_op1_relation): New. > (range_op_handler::lhs_op2_relation): New. > (range_op_handler::op1_op2_relation): New. > (range_cast): Adjust for vrange. > * range-op.h (range_op_handler): Remove function. > (range_cast): Adjust for vrange. > (class range_op_handler): New. > (get_bool_state): Adjust for vrange. > (empty_range_varying): Same. > (relop_early_resolve): Same. > * tree-data-ref.cc (compute_distributive_range): Same. > * tree-vrp.cc (get_range_op_handler): Remove. > (range_fold_binary_symbolics_p): Use range_op_handler class > instead of get_range_op_handler. > (range_fold_unary_symbolics_p): Same. > (range_fold_binary_expr): Same. > (range_fold_unary_expr): Same. > * value-query.cc (range_query::get_tree_range): Adjust for vrange. > --- > gcc/gimple-range-edge.cc | 2 +- > gcc/gimple-range-fold.cc | 43 ++++---- > gcc/gimple-range-fold.h | 15 --- > gcc/gimple-range-gori.cc | 41 ++++---- > gcc/gimple-range.cc | 6 +- > gcc/range-op.cc | 215 ++++++++++++++++++++++++++++++++++----- > gcc/range-op.h | 45 ++++++-- > gcc/tree-data-ref.cc | 8 +- > gcc/tree-vrp.cc | 44 ++++---- > gcc/value-query.cc | 8 +- > 10 files changed, 303 insertions(+), 124 deletions(-) > > diff --git a/gcc/gimple-range-edge.cc b/gcc/gimple-range-edge.cc > index 0bee38ba770..5bbe23ae03d 100644 > --- a/gcc/gimple-range-edge.cc > +++ b/gcc/gimple-range-edge.cc > @@ -42,7 +42,7 @@ gimple_outgoing_range_stmt_p (basic_block bb) > if (!gsi_end_p (gsi)) > { > gimple *s = gsi_stmt (gsi); > - if (is_a (s) && gimple_range_handler (s)) > + if (is_a (s) && range_op_handler (s)) > return gsi_stmt (gsi); > gswitch *sw = dyn_cast (s); > if (sw && irange::supports_type_p (TREE_TYPE (gimple_switch_index (sw)))) > diff --git a/gcc/gimple-range-fold.cc b/gcc/gimple-range-fold.cc > index 0a947c16c58..c53d2863d5e 100644 > --- a/gcc/gimple-range-fold.cc > +++ b/gcc/gimple-range-fold.cc > @@ -482,7 +482,7 @@ gimple_range_base_of_assignment (const gimple *stmt) > tree > gimple_range_operand1 (const gimple *stmt) > { > - gcc_checking_assert (gimple_range_handler (stmt)); > + gcc_checking_assert (range_op_handler (stmt)); > > switch (gimple_code (stmt)) > { > @@ -515,7 +515,7 @@ gimple_range_operand1 (const gimple *stmt) > tree > gimple_range_operand2 (const gimple *stmt) > { > - gcc_checking_assert (gimple_range_handler (stmt)); > + gcc_checking_assert (range_op_handler (stmt)); > > switch (gimple_code (stmt)) > { > @@ -551,7 +551,7 @@ fold_using_range::fold_stmt (irange &r, gimple *s, fur_source &src, tree name) > && gimple_assign_rhs_code (s) == ADDR_EXPR) > return range_of_address (r, s, src); > > - if (gimple_range_handler (s)) > + if (range_op_handler (s)) > res = range_of_range_op (r, s, src); > else if (is_a(s)) > res = range_of_phi (r, as_a (s), src); > @@ -593,7 +593,7 @@ fold_using_range::range_of_range_op (irange &r, gimple *s, fur_source &src) > tree type = gimple_range_type (s); > if (!type) > return false; > - range_operator *handler = gimple_range_handler (s); > + range_op_handler handler (s); > gcc_checking_assert (handler); > > tree lhs = gimple_get_lhs (s); > @@ -606,13 +606,13 @@ fold_using_range::range_of_range_op (irange &r, gimple *s, fur_source &src) > { > // Fold range, and register any dependency if available. > int_range<2> r2 (type); > - handler->fold_range (r, type, range1, r2); > + handler.fold_range (r, type, range1, r2); > if (lhs && gimple_range_ssa_p (op1)) > { > if (src.gori ()) > src.gori ()->register_dependency (lhs, op1); > relation_kind rel; > - rel = handler->lhs_op1_relation (r, range1, range1); > + rel = handler.lhs_op1_relation (r, range1, range1); > if (rel != VREL_VARYING) > src.register_relation (s, rel, lhs, op1); > } > @@ -629,7 +629,7 @@ fold_using_range::range_of_range_op (irange &r, gimple *s, fur_source &src) > fputc ('\n', dump_file); > } > // Fold range, and register any dependency if available. > - handler->fold_range (r, type, range1, range2, rel); > + handler.fold_range (r, type, range1, range2, rel); > relation_fold_and_or (r, s, src); > if (lhs) > { > @@ -640,13 +640,13 @@ fold_using_range::range_of_range_op (irange &r, gimple *s, fur_source &src) > } > if (gimple_range_ssa_p (op1)) > { > - rel = handler->lhs_op1_relation (r, range1, range2, rel); > + rel = handler.lhs_op1_relation (r, range1, range2, rel); > if (rel != VREL_VARYING) > src.register_relation (s, rel, lhs, op1); > } > if (gimple_range_ssa_p (op2)) > { > - rel= handler->lhs_op2_relation (r, range1, range2, rel); > + rel= handler.lhs_op2_relation (r, range1, range2, rel); > if (rel != VREL_VARYING) > src.register_relation (s, rel, lhs, op2); > } > @@ -921,7 +921,7 @@ fold_using_range::range_of_builtin_ubsan_call (irange &r, gcall *call, > gcc_checking_assert (code == PLUS_EXPR || code == MINUS_EXPR > || code == MULT_EXPR); > tree type = gimple_range_type (call); > - range_operator *op = range_op_handler (code, type); > + range_op_handler op (code, type); > gcc_checking_assert (op); > int_range_max ir0, ir1; > tree arg0 = gimple_call_arg (call, 0); > @@ -935,7 +935,7 @@ fold_using_range::range_of_builtin_ubsan_call (irange &r, gcall *call, > // Pretend the arithmetic is wrapping. If there is any overflow, > // we'll complain, but will actually do wrapping operation. > flag_wrapv = 1; > - op->fold_range (r, type, ir0, ir1, relation); > + op.fold_range (r, type, ir0, ir1, relation); > flag_wrapv = saved_flag_wrapv; > > // If for both arguments vrp_valueize returned non-NULL, this should > @@ -1391,8 +1391,8 @@ fold_using_range::relation_fold_and_or (irange& lhs_range, gimple *s, > else if (ssa1_dep1 != ssa2_dep2 || ssa1_dep2 != ssa2_dep1) > return; > > - range_operator *handler1 = gimple_range_handler (SSA_NAME_DEF_STMT (ssa1)); > - range_operator *handler2 = gimple_range_handler (SSA_NAME_DEF_STMT (ssa2)); > + range_op_handler handler1 (SSA_NAME_DEF_STMT (ssa1)); > + range_op_handler handler2 (SSA_NAME_DEF_STMT (ssa2)); > > // If either handler is not present, no relation is found. > if (!handler1 || !handler2) > @@ -1400,8 +1400,8 @@ fold_using_range::relation_fold_and_or (irange& lhs_range, gimple *s, > > int_range<2> bool_one (boolean_true_node, boolean_true_node); > > - relation_kind relation1 = handler1->op1_op2_relation (bool_one); > - relation_kind relation2 = handler2->op1_op2_relation (bool_one); > + relation_kind relation1 = handler1.op1_op2_relation (bool_one); > + relation_kind relation2 = handler2.op1_op2_relation (bool_one); > if (relation1 == VREL_VARYING || relation2 == VREL_VARYING) > return; > > @@ -1441,7 +1441,6 @@ fur_source::register_outgoing_edges (gcond *s, irange &lhs_range, edge e0, edge > int_range_max r; > int_range<2> e0_range, e1_range; > tree name; > - range_operator *handler; > basic_block bb = gimple_bb (s); > > if (e0) > @@ -1472,17 +1471,17 @@ fur_source::register_outgoing_edges (gcond *s, irange &lhs_range, edge e0, edge > tree ssa2 = gimple_range_ssa_p (gimple_range_operand2 (s)); > if (ssa1 && ssa2) > { > - handler = gimple_range_handler (s); > + range_op_handler handler (s); > gcc_checking_assert (handler); > if (e0) > { > - relation_kind relation = handler->op1_op2_relation (e0_range); > + relation_kind relation = handler.op1_op2_relation (e0_range); > if (relation != VREL_VARYING) > register_relation (e0, relation, ssa1, ssa2); > } > if (e1) > { > - relation_kind relation = handler->op1_op2_relation (e1_range); > + relation_kind relation = handler.op1_op2_relation (e1_range); > if (relation != VREL_VARYING) > register_relation (e1, relation, ssa1, ssa2); > } > @@ -1501,7 +1500,7 @@ fur_source::register_outgoing_edges (gcond *s, irange &lhs_range, edge e0, edge > if (TREE_CODE (TREE_TYPE (name)) != BOOLEAN_TYPE) > continue; > gimple *stmt = SSA_NAME_DEF_STMT (name); > - handler = gimple_range_handler (stmt); > + range_op_handler handler (stmt); > if (!handler) > continue; > tree ssa1 = gimple_range_ssa_p (gimple_range_operand1 (stmt)); > @@ -1511,14 +1510,14 @@ fur_source::register_outgoing_edges (gcond *s, irange &lhs_range, edge e0, edge > if (e0 && gori ()->outgoing_edge_range_p (r, e0, name, *m_query) > && r.singleton_p ()) > { > - relation_kind relation = handler->op1_op2_relation (r); > + relation_kind relation = handler.op1_op2_relation (r); > if (relation != VREL_VARYING) > register_relation (e0, relation, ssa1, ssa2); > } > if (e1 && gori ()->outgoing_edge_range_p (r, e1, name, *m_query) > && r.singleton_p ()) > { > - relation_kind relation = handler->op1_op2_relation (r); > + relation_kind relation = handler.op1_op2_relation (r); > if (relation != VREL_VARYING) > register_relation (e1, relation, ssa1, ssa2); > } > diff --git a/gcc/gimple-range-fold.h b/gcc/gimple-range-fold.h > index 20cb73dabb9..4b5d4b6e0b8 100644 > --- a/gcc/gimple-range-fold.h > +++ b/gcc/gimple-range-fold.h > @@ -41,21 +41,6 @@ bool fold_range (irange &r, gimple *s, irange &r1); > bool fold_range (irange &r, gimple *s, irange &r1, irange &r2); > bool fold_range (irange &r, gimple *s, unsigned num_elements, irange *vector); > > -// Return the range_operator pointer for this statement. This routine > -// can also be used to gate whether a routine is range-ops enabled. > - > -static inline range_operator * > -gimple_range_handler (const gimple *s) > -{ > - if (const gassign *ass = dyn_cast (s)) > - return range_op_handler (gimple_assign_rhs_code (ass), > - TREE_TYPE (gimple_assign_lhs (ass))); > - if (const gcond *cond = dyn_cast (s)) > - return range_op_handler (gimple_cond_code (cond), > - TREE_TYPE (gimple_cond_lhs (cond))); > - return NULL; > -} > - > // Return the type of range which statement S calculates. If the type is > // unsupported or no type can be determined, return NULL_TREE. > > diff --git a/gcc/gimple-range-gori.cc b/gcc/gimple-range-gori.cc > index 3e15eb5192d..0e0cf2128e7 100644 > --- a/gcc/gimple-range-gori.cc > +++ b/gcc/gimple-range-gori.cc > @@ -44,9 +44,9 @@ gimple_range_calc_op1 (irange &r, const gimple *stmt, const irange &lhs_range) > // Unary operations require the type of the first operand in the > // second range position. > tree type = TREE_TYPE (gimple_range_operand1 (stmt)); > - int_range<2> type_range (type); > - return gimple_range_handler (stmt)->op1_range (r, type, lhs_range, > - type_range); > + tmp_range type_range (type); > + type_range.set_varying (type); > + return range_op_handler (stmt).op1_range (r, type, lhs_range, type_range); > } > > // Calculate what we can determine of the range of this statement's > @@ -72,12 +72,12 @@ gimple_range_calc_op1 (irange &r, const gimple *stmt, > // This is sometimes invoked on single operand stmts. > if (gimple_num_ops (stmt) < 3) > return false; > - int_range<2> trange (TREE_TYPE (gimple_range_operand2 (stmt))); > - return gimple_range_handler (stmt)->op1_range (r, type, lhs_range, > - trange); > + tree op2_type = TREE_TYPE (gimple_range_operand2 (stmt)); > + tmp_range trange (op2_type); > + trange.set_varying (op2_type); > + return range_op_handler (stmt).op1_range (r, type, lhs_range, trange); > } > - return gimple_range_handler (stmt)->op1_range (r, type, lhs_range, > - op2_range); > + return range_op_handler (stmt).op1_range (r, type, lhs_range, op2_range); > } > > // Calculate what we can determine of the range of this statement's > @@ -97,12 +97,13 @@ gimple_range_calc_op2 (irange &r, const gimple *stmt, > // If op1 is undefined, solve as if it is varying. > if (op1_range.undefined_p ()) > { > - int_range<2> trange (TREE_TYPE (gimple_range_operand1 (stmt))); > - return gimple_range_handler (stmt)->op2_range (r, type, lhs_range, > - trange); > + tree op1_type = TREE_TYPE (gimple_range_operand1 (stmt)); > + tmp_range trange (op1_type); > + trange.set_varying (op1_type); > + return range_op_handler (stmt).op2_range (r, type, lhs_range, trange); > } > - return gimple_range_handler (stmt)->op2_range (r, type, lhs_range, > - op1_range); > + return range_op_handler (stmt).op2_range (r, type, lhs_range, > + op1_range); > } > > // Return TRUE if GS is a logical && or || expression. > @@ -346,7 +347,7 @@ range_def_chain::get_def_chain (tree name) > } > > gimple *stmt = SSA_NAME_DEF_STMT (name); > - if (gimple_range_handler (stmt)) > + if (range_op_handler (stmt)) > { > ssa1 = gimple_range_ssa_p (gimple_range_operand1 (stmt)); > ssa2 = gimple_range_ssa_p (gimple_range_operand2 (stmt)); > @@ -707,7 +708,7 @@ gori_compute::compute_operand_range (irange &r, gimple *stmt, > if (is_a (stmt)) > return compute_operand_range_switch (r, as_a (stmt), lhs, name, > src); > - if (!gimple_range_handler (stmt)) > + if (!range_op_handler (stmt)) > return false; > > tree op1 = gimple_range_ssa_p (gimple_range_operand1 (stmt)); > @@ -1328,7 +1329,7 @@ gori_compute::condexpr_adjust (irange &r1, irange &r2, gimple *, tree cond, > tree type = TREE_TYPE (gimple_assign_rhs1 (cond_def)); > if (!range_compatible_p (type, TREE_TYPE (gimple_assign_rhs2 (cond_def)))) > return false; > - range_operator *hand = range_op_handler (gimple_assign_rhs_code (cond_def), type); > + range_op_handler hand (gimple_assign_rhs_code (cond_def), type); > if (!hand) > return false; > > @@ -1351,18 +1352,18 @@ gori_compute::condexpr_adjust (irange &r1, irange &r2, gimple *, tree cond, > // the op1 or op2 routines based on its location. > if (c1) > { > - if (!hand->op1_range (cond_false, type, m_bool_zero, cr)) > + if (!hand.op1_range (cond_false, type, m_bool_zero, cr)) > return false; > - if (!hand->op1_range (cond_true, type, m_bool_one, cr)) > + if (!hand.op1_range (cond_true, type, m_bool_one, cr)) > return false; > cond_false.intersect (cl); > cond_true.intersect (cl); > } > else > { > - if (!hand->op2_range (cond_false, type, m_bool_zero, cl)) > + if (!hand.op2_range (cond_false, type, m_bool_zero, cl)) > return false; > - if (!hand->op2_range (cond_true, type, m_bool_one, cl)) > + if (!hand.op2_range (cond_true, type, m_bool_one, cl)) > return false; > cond_false.intersect (cr); > cond_true.intersect (cr); > diff --git a/gcc/gimple-range.cc b/gcc/gimple-range.cc > index f5e9e77bc71..32d57c9e3db 100644 > --- a/gcc/gimple-range.cc > +++ b/gcc/gimple-range.cc > @@ -339,7 +339,7 @@ gimple_ranger::prefill_name (irange &r, tree name) > if (!gimple_range_ssa_p (name)) > return; > gimple *stmt = SSA_NAME_DEF_STMT (name); > - if (!gimple_range_handler (stmt) && !is_a (stmt)) > + if (!range_op_handler (stmt) && !is_a (stmt)) > return; > > bool current; > @@ -363,7 +363,7 @@ gimple_ranger::prefill_stmt_dependencies (tree ssa) > gcc_checking_assert (stmt && gimple_bb (stmt)); > > // Only pre-process range-ops and phis. > - if (!gimple_range_handler (stmt) && !is_a (stmt)) > + if (!range_op_handler (stmt) && !is_a (stmt)) > return; > > // Mark where on the stack we are starting. > @@ -419,7 +419,7 @@ gimple_ranger::prefill_stmt_dependencies (tree ssa) > } > else > { > - gcc_checking_assert (gimple_range_handler (stmt)); > + gcc_checking_assert (range_op_handler (stmt)); > tree op = gimple_range_operand2 (stmt); > if (op) > prefill_name (r, op); > diff --git a/gcc/range-op.cc b/gcc/range-op.cc > index c88da8caa6c..6f6d2da573a 100644 > --- a/gcc/range-op.cc > +++ b/gcc/range-op.cc > @@ -420,7 +420,7 @@ create_possibly_reversed_range (irange &r, tree type, > // return the equivalent range for TYPE in R; if FALSE/TRUE, do nothing. > > bool_range_state > -get_bool_state (irange &r, const irange &lhs, tree val_type) > +get_bool_state (vrange &r, const vrange &lhs, tree val_type) > { > // If there is no result, then this is unexecutable. > if (lhs.undefined_p ()) > @@ -446,6 +446,9 @@ get_bool_state (irange &r, const irange &lhs, tree val_type) > > class operator_equal : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &op1, > @@ -562,6 +565,9 @@ operator_equal::op2_range (irange &r, tree type, > > class operator_not_equal : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &op1, > @@ -738,6 +744,9 @@ build_ge (irange &r, tree type, const wide_int &val) > > class operator_lt : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &op1, > @@ -846,6 +855,9 @@ operator_lt::op2_range (irange &r, tree type, > > class operator_le : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &op1, > @@ -954,6 +966,9 @@ operator_le::op2_range (irange &r, tree type, > > class operator_gt : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &op1, > @@ -1061,6 +1076,9 @@ operator_gt::op2_range (irange &r, tree type, > > class operator_ge : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &op1, > @@ -1169,6 +1187,10 @@ operator_ge::op2_range (irange &r, tree type, > > class operator_plus : public range_operator > { > + using range_operator::op1_range; > + using range_operator::op2_range; > + using range_operator::lhs_op1_relation; > + using range_operator::lhs_op2_relation; > public: > virtual bool op1_range (irange &r, tree type, > const irange &lhs, > @@ -1286,7 +1308,7 @@ operator_plus::op1_range (irange &r, tree type, > const irange &op2, > relation_kind rel ATTRIBUTE_UNUSED) const > { > - return range_op_handler (MINUS_EXPR, type)->fold_range (r, type, lhs, op2); > + return range_op_handler (MINUS_EXPR, type).fold_range (r, type, lhs, op2); > } > > bool > @@ -1295,12 +1317,15 @@ operator_plus::op2_range (irange &r, tree type, > const irange &op1, > relation_kind rel ATTRIBUTE_UNUSED) const > { > - return range_op_handler (MINUS_EXPR, type)->fold_range (r, type, lhs, op1); > + return range_op_handler (MINUS_EXPR, type).fold_range (r, type, lhs, op1); > } > > > class operator_minus : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual bool op1_range (irange &r, tree type, > const irange &lhs, > @@ -1445,7 +1470,7 @@ operator_minus::op1_range (irange &r, tree type, > const irange &op2, > relation_kind rel ATTRIBUTE_UNUSED) const > { > - return range_op_handler (PLUS_EXPR, type)->fold_range (r, type, lhs, op2); > + return range_op_handler (PLUS_EXPR, type).fold_range (r, type, lhs, op2); > } > > bool > @@ -1597,6 +1622,8 @@ cross_product_operator::wi_cross_product (irange &r, tree type, > > class operator_mult : public cross_product_operator > { > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual void wi_fold (irange &r, tree type, > const wide_int &lh_lb, > @@ -1629,8 +1656,8 @@ operator_mult::op1_range (irange &r, tree type, > return false; > > if (op2.singleton_p (&offset) && !integer_zerop (offset)) > - return range_op_handler (TRUNC_DIV_EXPR, type)->fold_range (r, type, > - lhs, op2); > + return range_op_handler (TRUNC_DIV_EXPR, type).fold_range (r, type, > + lhs, op2); > return false; > } > > @@ -1857,6 +1884,7 @@ operator_div op_ceil_div (CEIL_DIV_EXPR); > > class operator_exact_divide : public operator_div > { > + using range_operator::op1_range; > public: > operator_exact_divide () : operator_div (TRUNC_DIV_EXPR) { } > virtual bool op1_range (irange &r, tree type, > @@ -1881,13 +1909,15 @@ operator_exact_divide::op1_range (irange &r, tree type, > // If op2 is a multiple of 2, we would be able to set some non-zero bits. > if (op2.singleton_p (&offset) > && !integer_zerop (offset)) > - return range_op_handler (MULT_EXPR, type)->fold_range (r, type, lhs, op2); > + return range_op_handler (MULT_EXPR, type).fold_range (r, type, lhs, op2); > return false; > } > > > class operator_lshift : public cross_product_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > public: > virtual bool op1_range (irange &r, tree type, > const irange &lhs, > @@ -1909,6 +1939,9 @@ public: > > class operator_rshift : public cross_product_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > + using range_operator::lhs_op1_relation; > public: > virtual bool fold_range (irange &r, tree type, > const irange &op1, > @@ -2248,6 +2281,8 @@ operator_rshift::wi_fold (irange &r, tree type, > > class operator_cast: public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &op1, > @@ -2417,10 +2452,9 @@ operator_cast::op1_range (irange &r, tree type, > // Add this to the unsigned LHS range(s). > int_range_max lim_range (type, lim, lim); > int_range_max lhs_neg; > - range_op_handler (PLUS_EXPR, type)->fold_range (lhs_neg, > - type, > - converted_lhs, > - lim_range); > + range_op_handler (PLUS_EXPR, type).fold_range (lhs_neg, type, > + converted_lhs, > + lim_range); > // lhs_neg now has all the negative versions of the LHS. > // Now union in all the values from SIGNED MIN (0x80000) to > // lim-1 in order to fill in all the ranges with the upper > @@ -2469,6 +2503,9 @@ operator_cast::op1_range (irange &r, tree type, > > class operator_logical_and : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &lh, > @@ -2542,6 +2579,9 @@ operator_logical_and::op2_range (irange &r, tree type, > > class operator_bitwise_and : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &lh, > @@ -2988,6 +3028,9 @@ operator_bitwise_and::op2_range (irange &r, tree type, > > class operator_logical_or : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &lh, > @@ -3051,6 +3094,8 @@ operator_logical_or::op2_range (irange &r, tree type, > > class operator_bitwise_or : public range_operator > { > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual bool op1_range (irange &r, tree type, > const irange &lhs, > @@ -3155,6 +3200,8 @@ operator_bitwise_or::op2_range (irange &r, tree type, > > class operator_bitwise_xor : public range_operator > { > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual void wi_fold (irange &r, tree type, > const wide_int &lh_lb, > @@ -3296,6 +3343,8 @@ operator_bitwise_xor::op2_range (irange &r, tree type, > > class operator_trunc_mod : public range_operator > { > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual void wi_fold (irange &r, tree type, > const wide_int &lh_lb, > @@ -3432,6 +3481,8 @@ operator_trunc_mod::op2_range (irange &r, tree type, > > class operator_logical_not : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &lh, > @@ -3487,6 +3538,8 @@ operator_logical_not::op1_range (irange &r, > > class operator_bitwise_not : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &lh, > @@ -3513,8 +3566,7 @@ operator_bitwise_not::fold_range (irange &r, tree type, > // ~X is simply -1 - X. > int_range<1> minusone (type, wi::minus_one (TYPE_PRECISION (type)), > wi::minus_one (TYPE_PRECISION (type))); > - return range_op_handler (MINUS_EXPR, type)->fold_range (r, type, minusone, > - lh); > + return range_op_handler (MINUS_EXPR, type).fold_range (r, type, minusone, lh); > } > > bool > @@ -3533,6 +3585,7 @@ operator_bitwise_not::op1_range (irange &r, tree type, > > class operator_cst : public range_operator > { > + using range_operator::fold_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &op1, > @@ -3553,6 +3606,9 @@ operator_cst::fold_range (irange &r, tree type ATTRIBUTE_UNUSED, > > class operator_identity : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > + using range_operator::lhs_op1_relation; > public: > virtual bool fold_range (irange &r, tree type, > const irange &op1, > @@ -3605,6 +3661,7 @@ operator_identity::op1_range (irange &r, tree type ATTRIBUTE_UNUSED, > > class operator_unknown : public range_operator > { > + using range_operator::fold_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &op1, > @@ -3625,6 +3682,7 @@ operator_unknown::fold_range (irange &r, tree type, > > class operator_abs : public range_operator > { > + using range_operator::op1_range; > public: > virtual void wi_fold (irange &r, tree type, > const wide_int &lh_lb, > @@ -3790,6 +3848,8 @@ operator_absu::wi_fold (irange &r, tree type, > > class operator_negate : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &op1, > @@ -3810,9 +3870,8 @@ operator_negate::fold_range (irange &r, tree type, > if (empty_range_varying (r, type, lh, rh)) > return true; > // -X is simply 0 - X. > - return range_op_handler (MINUS_EXPR, type)->fold_range (r, type, > - range_zero (type), > - lh); > + return range_op_handler (MINUS_EXPR, type).fold_range (r, type, > + range_zero (type), lh); > } > > bool > @@ -3828,6 +3887,8 @@ operator_negate::op1_range (irange &r, tree type, > > class operator_addr_expr : public range_operator > { > + using range_operator::fold_range; > + using range_operator::op1_range; > public: > virtual bool fold_range (irange &r, tree type, > const irange &op1, > @@ -3978,6 +4039,8 @@ pointer_and_operator::wi_fold (irange &r, tree type, > > class pointer_or_operator : public range_operator > { > + using range_operator::op1_range; > + using range_operator::op2_range; > public: > virtual bool op1_range (irange &r, tree type, > const irange &lhs, > @@ -4139,8 +4202,8 @@ pointer_table::pointer_table () > > // The tables are hidden and accessed via a simple extern function. > > -range_operator * > -range_op_handler (enum tree_code code, tree type) > +static inline range_operator * > +get_handler (enum tree_code code, tree type) > { > // First check if there is a pointer specialization. > if (POINTER_TYPE_P (type)) > @@ -4150,16 +4213,120 @@ range_op_handler (enum tree_code code, tree type) > return NULL; > } > > +range_op_handler::range_op_handler (tree_code code, tree type) > +{ > + m_op = get_handler (code, type); > +} > + > +range_op_handler::range_op_handler (const gimple *s) > +{ > + if (const gassign *ass = dyn_cast (s)) > + { > + enum tree_code code = gimple_assign_rhs_code (ass); > + // The LHS of a comparison is always an int, so we must look at > + // the operands. > + if (TREE_CODE_CLASS (code) == tcc_comparison) > + m_op = get_handler (code, TREE_TYPE (gimple_assign_rhs1 (ass))); > + else > + m_op = get_handler (code, TREE_TYPE (gimple_assign_lhs (ass))); > + } > + else if (const gcond *cond = dyn_cast (s)) > + m_op = get_handler (gimple_cond_code (cond), > + TREE_TYPE (gimple_cond_lhs (cond))); > + else > + m_op = NULL; > +} > + > +bool > +range_op_handler::fold_range (vrange &r, tree type, > + const vrange &lh, > + const vrange &rh, > + relation_kind rel) const > +{ > + if (is_a (lh)) > + return m_op->fold_range (as_a (r), type, > + as_a (lh), > + as_a (rh), rel); > + gcc_unreachable (); > + return false; > +} > + > +bool > +range_op_handler::op1_range (vrange &r, tree type, > + const vrange &lhs, > + const vrange &op2, > + relation_kind rel) const > +{ > + if (is_a (r)) > + return m_op->op1_range (as_a (r), type, > + as_a (lhs), > + as_a (op2), rel); > + gcc_unreachable (); > + return false; > +} > + > +bool > +range_op_handler::op2_range (vrange &r, tree type, > + const vrange &lhs, > + const vrange &op1, > + relation_kind rel) const > +{ > + if (is_a (r)) > + return m_op->op2_range (as_a (r), type, > + as_a (lhs), > + as_a (op1), rel); > + gcc_unreachable (); > + return false; > +} > + > +relation_kind > +range_op_handler::lhs_op1_relation (const vrange &lhs, > + const vrange &op1, > + const vrange &op2, > + relation_kind rel) const > +{ > + if (is_a (op1)) > + return m_op->lhs_op1_relation (as_a (lhs), > + as_a (op1), as_a (op2), rel); > + gcc_unreachable (); > + return VREL_VARYING; > +} > + > +relation_kind > +range_op_handler::lhs_op2_relation (const vrange &lhs, > + const vrange &op1, > + const vrange &op2, > + relation_kind rel) const > +{ > + if (is_a (op1)) > + return m_op->lhs_op2_relation (as_a (lhs), > + as_a (op1), as_a (op2), rel); > + gcc_unreachable (); > + return VREL_VARYING; > +} > + > +relation_kind > +range_op_handler::op1_op2_relation (const vrange &lhs) const > +{ > + return m_op->op1_op2_relation (as_a (lhs)); > +} > + > // Cast the range in R to TYPE. > > -void > -range_cast (irange &r, tree type) > +bool > +range_cast (vrange &r, tree type) > { > - int_range_max tmp = r; > - range_operator *op = range_op_handler (CONVERT_EXPR, type); > + tmp_range tmp (r); > + tmp_range varying (type); > + varying.set_varying (type); > + range_op_handler op (CONVERT_EXPR, type); > // Call op_convert, if it fails, the result is varying. > - if (!op->fold_range (r, type, tmp, int_range<1> (type))) > - r.set_varying (type); > + if (!op || !op.fold_range (r, type, tmp, varying)) > + { > + r.set_varying (type); > + return false; > + } > + return true; > } > > #if CHECKING_P > diff --git a/gcc/range-op.h b/gcc/range-op.h > index 5fdda326d4b..d0f50689897 100644 > --- a/gcc/range-op.h > +++ b/gcc/range-op.h > @@ -108,8 +108,39 @@ protected: > const wide_int &rh_ub) const; > }; > > -extern range_operator *range_op_handler (enum tree_code code, tree type); > -extern void range_cast (irange &, tree type); > +class range_op_handler > +{ > +public: > + range_op_handler (enum tree_code code, tree type); > + range_op_handler (const gimple *s); > + operator bool () const { return m_op; } > + > + bool fold_range (vrange &r, tree type, > + const vrange &lh, > + const vrange &rh, > + relation_kind rel = VREL_VARYING) const; > + bool op1_range (vrange &r, tree type, > + const vrange &lhs, > + const vrange &op2, > + relation_kind rel = VREL_VARYING) const; > + bool op2_range (vrange &r, tree type, > + const vrange &lhs, > + const vrange &op1, > + relation_kind rel = VREL_VARYING) const; > + relation_kind lhs_op1_relation (const vrange &lhs, > + const vrange &op1, > + const vrange &op2, > + relation_kind = VREL_VARYING) const; > + relation_kind lhs_op2_relation (const vrange &lhs, > + const vrange &op1, > + const vrange &op2, > + relation_kind = VREL_VARYING) const; > + relation_kind op1_op2_relation (const vrange &lhs) const; > +private: > + range_operator *m_op; > +}; > + > +extern bool range_cast (vrange &, tree type); > extern void wi_set_zero_nonzero_bits (tree type, > const wide_int &, const wide_int &, > wide_int &maybe_nonzero, > @@ -124,7 +155,7 @@ relation_kind gt_op1_op2_relation (const irange &lhs); > relation_kind ge_op1_op2_relation (const irange &lhs); > > enum bool_range_state { BRS_FALSE, BRS_TRUE, BRS_EMPTY, BRS_FULL }; > -bool_range_state get_bool_state (irange &r, const irange &lhs, tree val_type); > +bool_range_state get_bool_state (vrange &r, const vrange &lhs, tree val_type); > > // If the range of either op1 or op2 is undefined, set the result to > // varying and return TRUE. If the caller truely cares about a result, > @@ -132,8 +163,8 @@ bool_range_state get_bool_state (irange &r, const irange &lhs, tree val_type); > // treated as a varying. > > inline bool > -empty_range_varying (irange &r, tree type, > - const irange &op1, const irange & op2) > +empty_range_varying (vrange &r, tree type, > + const vrange &op1, const vrange & op2) > { > if (op1.undefined_p () || op2.undefined_p ()) > { > @@ -150,8 +181,8 @@ empty_range_varying (irange &r, tree type, > // return false. > > inline bool > -relop_early_resolve (irange &r, tree type, const irange &op1, > - const irange &op2, relation_kind rel, > +relop_early_resolve (irange &r, tree type, const vrange &op1, > + const vrange &op2, relation_kind rel, > relation_kind my_rel) > { > // If known relation is a complete subset of this relation, always true. > diff --git a/gcc/tree-data-ref.cc b/gcc/tree-data-ref.cc > index 397792c3584..ae05fe74b95 100644 > --- a/gcc/tree-data-ref.cc > +++ b/gcc/tree-data-ref.cc > @@ -593,8 +593,8 @@ compute_distributive_range (tree type, value_range &op0_range, > gcc_assert (INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_TRAPS (type)); > if (result_range) > { > - range_operator *op = range_op_handler (code, type); > - op->fold_range (*result_range, type, op0_range, op1_range); > + range_op_handler op (code, type); > + op.fold_range (*result_range, type, op0_range, op1_range); > } > > /* The distributive property guarantees that if TYPE is no narrower > @@ -639,10 +639,10 @@ compute_distributive_range (tree type, value_range &op0_range, > range_cast (op0_range, ssizetype); > range_cast (op1_range, ssizetype); > value_range wide_range; > - range_operator *op = range_op_handler (code, ssizetype); > + range_op_handler op (code, ssizetype); > bool saved_flag_wrapv = flag_wrapv; > flag_wrapv = 1; > - op->fold_range (wide_range, ssizetype, op0_range, op1_range); > + op.fold_range (wide_range, ssizetype, op0_range, op1_range); > flag_wrapv = saved_flag_wrapv; > if (wide_range.num_pairs () != 1 || !range_int_cst_p (&wide_range)) > return false; > diff --git a/gcc/tree-vrp.cc b/gcc/tree-vrp.cc > index 0784d658567..3c7b5af4737 100644 > --- a/gcc/tree-vrp.cc > +++ b/gcc/tree-vrp.cc > @@ -924,20 +924,6 @@ extract_range_from_plus_minus_expr (value_range *vr, > vr->set (min, max, kind); > } > > -/* Return the range-ops handler for CODE and EXPR_TYPE. If no > - suitable operator is found, return NULL and set VR to VARYING. */ > - > -static const range_operator * > -get_range_op_handler (value_range *vr, > - enum tree_code code, > - tree expr_type) > -{ > - const range_operator *op = range_op_handler (code, expr_type); > - if (!op) > - vr->set_varying (expr_type); > - return op; > -} > - > /* If the types passed are supported, return TRUE, otherwise set VR to > VARYING and return FALSE. */ > > @@ -1005,10 +991,12 @@ range_fold_binary_symbolics_p (value_range *vr, > &vr0, &vr1); > return true; > } > - const range_operator *op = get_range_op_handler (vr, code, expr_type); > + range_op_handler op (code, expr_type); > + if (!op) > + vr->set_varying (expr_type); > vr0.normalize_symbolics (); > vr1.normalize_symbolics (); > - return op->fold_range (*vr, expr_type, vr0, vr1); > + return op.fold_range (*vr, expr_type, vr0, vr1); > } > return false; > } > @@ -1040,10 +1028,12 @@ range_fold_unary_symbolics_p (value_range *vr, > range_fold_binary_expr (vr, MINUS_EXPR, expr_type, &minusone, vr0); > return true; > } > - const range_operator *op = get_range_op_handler (vr, code, expr_type); > + range_op_handler op (code, expr_type); > + if (!op) > + vr->set_varying (expr_type); > value_range vr0_cst (*vr0); > vr0_cst.normalize_symbolics (); > - return op->fold_range (*vr, expr_type, vr0_cst, value_range (expr_type)); > + return op.fold_range (*vr, expr_type, vr0_cst, value_range (expr_type)); > } > return false; > } > @@ -1060,9 +1050,12 @@ range_fold_binary_expr (value_range *vr, > if (!supported_types_p (vr, expr_type) > || !defined_ranges_p (vr, vr0_, vr1_)) > return; > - const range_operator *op = get_range_op_handler (vr, code, expr_type); > + range_op_handler op (code, expr_type); > if (!op) > - return; > + { > + vr->set_varying (expr_type); > + return; > + } > > if (range_fold_binary_symbolics_p (vr, code, expr_type, vr0_, vr1_)) > return; > @@ -1075,7 +1068,7 @@ range_fold_binary_expr (value_range *vr, > vr1.set_varying (expr_type); > vr0.normalize_addresses (); > vr1.normalize_addresses (); > - op->fold_range (*vr, expr_type, vr0, vr1); > + op.fold_range (*vr, expr_type, vr0, vr1); > } > > /* Perform a unary operation on a range. */ > @@ -1089,16 +1082,19 @@ range_fold_unary_expr (value_range *vr, > if (!supported_types_p (vr, expr_type, vr0_type) > || !defined_ranges_p (vr, vr0)) > return; > - const range_operator *op = get_range_op_handler (vr, code, expr_type); > + range_op_handler op (code, expr_type); > if (!op) > - return; > + { > + vr->set_varying (expr_type); > + return; > + } > > if (range_fold_unary_symbolics_p (vr, code, expr_type, vr0)) > return; > > value_range vr0_cst (*vr0); > vr0_cst.normalize_addresses (); > - op->fold_range (*vr, expr_type, vr0_cst, value_range (expr_type)); > + op.fold_range (*vr, expr_type, vr0_cst, value_range (expr_type)); > } > > /* If the range of values taken by OP can be inferred after STMT executes, > diff --git a/gcc/value-query.cc b/gcc/value-query.cc > index 26e3858103b..31e56eeae53 100644 > --- a/gcc/value-query.cc > +++ b/gcc/value-query.cc > @@ -234,13 +234,13 @@ range_query::get_tree_range (irange &r, tree expr, gimple *stmt) > } > if (BINARY_CLASS_P (expr)) > { > - range_operator *op = range_op_handler (TREE_CODE (expr), type); > + range_op_handler op (TREE_CODE (expr), type); > if (op) > { > int_range_max r0, r1; > range_of_expr (r0, TREE_OPERAND (expr, 0), stmt); > range_of_expr (r1, TREE_OPERAND (expr, 1), stmt); > - op->fold_range (r, type, r0, r1); > + op.fold_range (r, type, r0, r1); > } > else > r.set_varying (type); > @@ -248,13 +248,13 @@ range_query::get_tree_range (irange &r, tree expr, gimple *stmt) > } > if (UNARY_CLASS_P (expr)) > { > - range_operator *op = range_op_handler (TREE_CODE (expr), type); > + range_op_handler op (TREE_CODE (expr), type); > tree op0_type = TREE_TYPE (TREE_OPERAND (expr, 0)); > if (op && irange::supports_type_p (op0_type)) > { > int_range_max r0; > range_of_expr (r0, TREE_OPERAND (expr, 0), stmt); > - op->fold_range (r, type, r0, int_range<1> (type)); > + op.fold_range (r, type, r0, int_range<1> (type)); > } > else > r.set_varying (type); > -- > 2.36.1 > --000000000000b58e2405e05f2484 Content-Type: text/x-patch; charset="US-ASCII"; name="0003-Convert-range-op.-to-vrange.patch" Content-Disposition: attachment; filename="0003-Convert-range-op.-to-vrange.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_l3vd0etb0 RnJvbSBjZjViZWE3NmY5ZDg0ZjYyMThmMGE1MDg1ZGI2M2E1MGFlZDlkOTVhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbGR5IEhlcm5hbmRleiA8YWxkeWhAcmVkaGF0LmNvbT4KRGF0 ZTogTW9uLCAxNCBNYXIgMjAyMiAxMzozMToxOCArMDEwMApTdWJqZWN0OiBbUEFUQ0hdIENvbnZl cnQgcmFuZ2Utb3AuKiB0byB2cmFuZ2UuCgpUaGlzIHBhdGNoIHByb3ZpZGVzIHRoZSBpbmZyYXN0 cnVjdHVyZSB0byBtYWtlIHJhbmdlLW9wcyB0eXBlIGFnbm9zdGljLgoKRmlyc3QsIHRoZSByYW5n ZV9vcF9oYW5kbGVyIGZ1bmN0aW9uIGhhcyBiZWVuIHJlcGxhY2VkIHdpdGggYW4gb2JqZWN0Cm9m IHRoZSBzYW1lIG5hbWUuICBJdCdzIGNvZGVkIGluIHN1Y2ggYSB3YXkgdG8gbWluaW1pemUgY2hh bmdlcyB0byB0aGUKY29kZSBiYXNlLCBhbmQgdG8gZW5jYXBzdWxhdGUgdGhlIGRpc3BhdGNoIGNv ZGUuCgpJbnN0ZWFkIG9mOgoKCXJhbmdlX29wZXJhdG9yICpvcCA9IHJhbmdlX29wX2hhbmRsZXIg KGNvZGUsIHR5cGUpOwoJaWYgKG9wKQoJICBvcC0+Zm9sZF9yYW5nZSAoLi4uKTsKCldlIG5vdyBk bzoKCXJhbmdlX29wX2hhbmRsZXIgb3AgKGNvZGUsIHR5cGUpOwoJaWYgKG9wKQoJICBvcC0+Zm9s ZF9yYW5nZSAoLi4uKTsKCkkndmUgZm9sZGVkIGdpbXBsZV9yYW5nZV9oYW5kbGVyIGludG8gdGhl IHJhbmdlX29wX2hhbmRsZXIgY2xhc3MsCnNpbmNlIGl0J3MgYWxzbyBhIHF1ZXJ5IGludG8gdGhl IHJhbmdlIG9wZXJhdG9ycy4KCkluc3RlYWQgb2Y6CgoJcmFuZ2Vfb3BlcmF0b3IgKmhhbmRsZXIg PSBnaW1wbGVfcmFuZ2VfaGFuZGxlciAoc3RtdCk7CgpXZSBub3cgZG86CgoJcmFuZ2Vfb3BfaGFu ZGxlciBoYW5kbGVyIChzdG10KTsKClRoaXMgYWxsIGhhcyB0aGUgYWRkZWQgYmVuZWZpdCBvZiBt b3ZpbmcgYWxsIHRoZSBkaXNwYXRjaCBjb2RlIGludG8gYW4KaW5kZXBlbmRlbnQgY2xhc3MgYW5k IGF2b2lkIHBvbGx1dGluZyByYW5nZV9vcGVyYXRvciAod2hpY2ggd2UnbGwKZnVydGhlciBzcGxp dCBsYXRlciB3aGVuIGZyYW5nZSBhbmQgcHJhbmdlIGNvbWUgbGl2ZSkuCgpUaGVyZSdzIHRoaXMg YW5ub3lpbmcgInVzaW5nIiBrZXl3b3JkIHRoYXQncyBiZWVuIGFkZGVkIHRvIGVhY2gKb3BlcmF0 b3IgZHVlIHRvIGhpZGluZyBydWxlcyBpbiBDKysuICBUaGUgaXNzdWUgaXMgdGhhdCB3ZSB3aWxs IGhhdmUKZGlmZmVyZW50IHZpcnR1YWwgdmVyc2lvbnMgb2YgZm9sZF9yYW5nZSgpIGZvciBlYWNo IGNvbWJpbmF0aW9uIG9mCm9wZXJhbmRzLiAgRm9yIGV4YW1wbGU6CgoJLy8gVHJhZGl0aW9uYWwg YmluYXJ5IG9wIG9uIGlyYW5nZSdzLgoJZm9sZF9yYW5nZSAoaXJhbmdlICZsaHMsIGNvbnN0IGly YW5nZSAmb3AxLCBjb25zdCBpcmFuZ2UgJm9wMik7CgkvLyBGb3IgUE9JTlRFUl9ESUZGX0VYUFI6 Cglmb2xkX3JhbmdlIChpcmFuZ2UgJmxocywgY29uc3QgcHJhbmdlICZvcDEsIGNvbnN0IHByYW5n ZSAmb3AyKTsKCS8vIENhc3QgZnJvbSBpcmFuZ2UgdG8gcHJhbmdlLgoJZm9sZF9yYW5nZSAocHJh bmdlICZsaHMsIGNvbnN0IGlyYW5nZSAmb3AxLCBjb25zdCBpcmFuZ2UgJm9wMik7CgpPdmVybG9h ZGluZyB2aXJ0dWFscyB3aGVuIHRoZXJlIGFyZSBtdWx0aXBsZSBzYW1lIG5hbWVkIG1ldGhvZHMg Y2F1c2VzCmhpZGRlbiB2aXJ0dWFscyB3YXJuaW5ncyBmcm9tIC1Xb3ZlcmxvYWRlZC12aXJ0dWFs LCB0aHVzIHRoZSB1c2luZwprZXl3b3JkLiAgQW4gYWx0ZXJuYXRpdmUgd291bGQgYmUgdG8gaGF2 ZSBkaWZmZXJlbnQgbmFtZXM6CmZvbGRfcmFuZ2VfSUlJLCBmb2xkX3JhbmdlX0lQUCwgZm9sZF9y YW5nZV9QSUksIGJ1dCB0aGF0J3MgdWdsaWVyCnN0aWxsLgoKVGVzdGVkIG9uIHg4Ni02NCAmIHBw YzY0bGUgTGludXguCgpnY2MvQ2hhbmdlTG9nOgoKCSogZ2ltcGxlLXJhbmdlLWVkZ2UuY2MgKGdp bXBsZV9vdXRnb2luZ19yYW5nZV9zdG10X3ApOiBBZGp1c3QgZm9yCgl2cmFuZ2UgYW5kIGNvbnZl cnQgcmFuZ2Vfb3BfaGFuZGxlciBmdW5jdGlvbiBjYWxscyB0byB1c2UgdGhlCglpZGVudGljYWxs eSBuYW1lZCBvYmplY3QuCgkqIGdpbXBsZS1yYW5nZS1mb2xkLmNjIChnaW1wbGVfcmFuZ2Vfb3Bl cmFuZDEpOiBTYW1lLgoJKGdpbXBsZV9yYW5nZV9vcGVyYW5kMik6IFNhbWUuCgkoZm9sZF91c2lu Z19yYW5nZTo6Zm9sZF9zdG10KTogU2FtZS4KCShmb2xkX3VzaW5nX3JhbmdlOjpyYW5nZV9vZl9y YW5nZV9vcCk6IFNhbWUuCgkoZm9sZF91c2luZ19yYW5nZTo6cmFuZ2Vfb2ZfYnVpbHRpbl91YnNh bl9jYWxsKTogU2FtZS4KCShmb2xkX3VzaW5nX3JhbmdlOjpyZWxhdGlvbl9mb2xkX2FuZF9vcik6 IFNhbWUuCgkoZnVyX3NvdXJjZTo6cmVnaXN0ZXJfb3V0Z29pbmdfZWRnZXMpOiBTYW1lLgoJKiBn aW1wbGUtcmFuZ2UtZm9sZC5oIChnaW1wbGVfcmFuZ2VfaGFuZGxlcik6IFJlbW92ZS4KCSogZ2lt cGxlLXJhbmdlLWdvcmkuY2MgKGdpbXBsZV9yYW5nZV9jYWxjX29wMSk6IEFkanVzdCBmb3IgdnJh bmdlLgoJKGdpbXBsZV9yYW5nZV9jYWxjX29wMik6IFNhbWUuCgkocmFuZ2VfZGVmX2NoYWluOjpn ZXRfZGVmX2NoYWluKTogU2FtZS4KCShnb3JpX2NvbXB1dGU6OmNvbXB1dGVfb3BlcmFuZF9yYW5n ZSk6IFNhbWUuCgkoZ29yaV9jb21wdXRlOjpjb25kZXhwcl9hZGp1c3QpOiBTYW1lLgoJKiBnaW1w bGUtcmFuZ2UuY2MgKGdpbXBsZV9yYW5nZXI6OnByZWZpbGxfbmFtZSk6IFNhbWUuCgkoZ2ltcGxl X3Jhbmdlcjo6cHJlZmlsbF9zdG10X2RlcGVuZGVuY2llcyk6IFNhbWUuCgkqIHJhbmdlLW9wLmNj IChnZXRfYm9vbF9zdGF0ZSk6IFNhbWUuCgkoY2xhc3Mgb3BlcmF0b3JfZXF1YWwpOiBBZGQgdXNp bmcgY2xhdXNlLgoJKGNsYXNzIG9wZXJhdG9yX25vdF9lcXVhbCk6IFNhbWUuCgkoY2xhc3Mgb3Bl cmF0b3JfbHQpOiBTYW1lLgoJKGNsYXNzIG9wZXJhdG9yX2xlKTogU2FtZS4KCShjbGFzcyBvcGVy YXRvcl9ndCk6IFNhbWUuCgkoY2xhc3Mgb3BlcmF0b3JfZ2UpOiBTYW1lLgoJKGNsYXNzIG9wZXJh dG9yX3BsdXMpOiBTYW1lLgoJKGNsYXNzIG9wZXJhdG9yX21pbnVzKTogU2FtZS4KCShjbGFzcyBv cGVyYXRvcl9tdWx0KTogU2FtZS4KCShjbGFzcyBvcGVyYXRvcl9leGFjdF9kaXZpZGUpOiBTYW1l LgoJKGNsYXNzIG9wZXJhdG9yX2xzaGlmdCk6IFNhbWUuCgkoY2xhc3Mgb3BlcmF0b3JfcnNoaWZ0 KTogU2FtZS4KCShjbGFzcyBvcGVyYXRvcl9jYXN0KTogU2FtZS4KCShjbGFzcyBvcGVyYXRvcl9s b2dpY2FsX2FuZCk6IFNhbWUuCgkoY2xhc3Mgb3BlcmF0b3JfYml0d2lzZV9hbmQpOiBTYW1lLgoJ KGNsYXNzIG9wZXJhdG9yX2xvZ2ljYWxfb3IpOiBTYW1lLgoJKGNsYXNzIG9wZXJhdG9yX2JpdHdp c2Vfb3IpOiBTYW1lLgoJKGNsYXNzIG9wZXJhdG9yX2JpdHdpc2VfeG9yKTogU2FtZS4KCShjbGFz cyBvcGVyYXRvcl90cnVuY19tb2QpOiBTYW1lLgoJKGNsYXNzIG9wZXJhdG9yX2xvZ2ljYWxfbm90 KTogU2FtZS4KCShjbGFzcyBvcGVyYXRvcl9iaXR3aXNlX25vdCk6IFNhbWUuCgkoY2xhc3Mgb3Bl cmF0b3JfY3N0KTogU2FtZS4KCShjbGFzcyBvcGVyYXRvcl9pZGVudGl0eSk6IFNhbWUuCgkoY2xh c3Mgb3BlcmF0b3JfdW5rbm93bik6IFNhbWUuCgkoY2xhc3Mgb3BlcmF0b3JfYWJzKTogU2FtZS4K CShjbGFzcyBvcGVyYXRvcl9uZWdhdGUpOiBTYW1lLgoJKGNsYXNzIG9wZXJhdG9yX2FkZHJfZXhw cik6IFNhbWUuCgkoY2xhc3MgcG9pbnRlcl9vcl9vcGVyYXRvcik6IFNhbWUuCgkob3BlcmF0b3Jf cGx1czo6b3AxX3JhbmdlKTogQWRqdXN0IGZvciB2cmFuZ2UuCgkob3BlcmF0b3JfbWludXM6Om9w MV9yYW5nZSk6IFNhbWUuCgkob3BlcmF0b3JfbXVsdDo6b3AxX3JhbmdlKTogU2FtZS4KCShvcGVy YXRvcl9jYXN0OjpvcDFfcmFuZ2UpOiBTYW1lLgoJKG9wZXJhdG9yX2JpdHdpc2Vfbm90Ojpmb2xk X3JhbmdlKTogU2FtZS4KCShvcGVyYXRvcl9uZWdhdGU6OmZvbGRfcmFuZ2UpOiBTYW1lLgoJKHJh bmdlX29wX2hhbmRsZXIpOiBSZW5hbWUgdG8uLi4KCShnZXRfaGFuZGxlcik6IC4uLnRoaXMuCgko cmFuZ2Vfb3BfaGFuZGxlcjo6cmFuZ2Vfb3BfaGFuZGxlcik6IE5ldy4KCShyYW5nZV9vcF9oYW5k bGVyOjpmb2xkX3JhbmdlKTogTmV3LgoJKHJhbmdlX29wX2hhbmRsZXI6Om9wMV9yYW5nZSk6IE5l dy4KCShyYW5nZV9vcF9oYW5kbGVyOjpvcDJfcmFuZ2UpOiBOZXcuCgkocmFuZ2Vfb3BfaGFuZGxl cjo6bGhzX29wMV9yZWxhdGlvbik6IE5ldy4KCShyYW5nZV9vcF9oYW5kbGVyOjpsaHNfb3AyX3Jl bGF0aW9uKTogTmV3LgoJKHJhbmdlX29wX2hhbmRsZXI6Om9wMV9vcDJfcmVsYXRpb24pOiBOZXcu CgkocmFuZ2VfY2FzdCk6IEFkanVzdCBmb3IgdnJhbmdlLgoJKiByYW5nZS1vcC5oIChyYW5nZV9v cF9oYW5kbGVyKTogUmVtb3ZlIGZ1bmN0aW9uLgoJKHJhbmdlX2Nhc3QpOiBBZGp1c3QgZm9yIHZy YW5nZS4KCShjbGFzcyByYW5nZV9vcF9oYW5kbGVyKTogTmV3LgoJKGdldF9ib29sX3N0YXRlKTog QWRqdXN0IGZvciB2cmFuZ2UuCgkoZW1wdHlfcmFuZ2VfdmFyeWluZyk6IFNhbWUuCgkocmVsb3Bf ZWFybHlfcmVzb2x2ZSk6IFNhbWUuCgkqIHRyZWUtZGF0YS1yZWYuY2MgKGNvbXB1dGVfZGlzdHJp YnV0aXZlX3JhbmdlKTogU2FtZS4KCSogdHJlZS12cnAuY2MgKGdldF9yYW5nZV9vcF9oYW5kbGVy KTogUmVtb3ZlLgoJKHJhbmdlX2ZvbGRfYmluYXJ5X3N5bWJvbGljc19wKTogVXNlIHJhbmdlX29w X2hhbmRsZXIgY2xhc3MKCWluc3RlYWQgb2YgZ2V0X3JhbmdlX29wX2hhbmRsZXIuCgkocmFuZ2Vf Zm9sZF91bmFyeV9zeW1ib2xpY3NfcCk6IFNhbWUuCgkocmFuZ2VfZm9sZF9iaW5hcnlfZXhwcik6 IFNhbWUuCgkocmFuZ2VfZm9sZF91bmFyeV9leHByKTogU2FtZS4KCSogdmFsdWUtcXVlcnkuY2Mg KHJhbmdlX3F1ZXJ5OjpnZXRfdHJlZV9yYW5nZSk6IEFkanVzdCBmb3IgdnJhbmdlLgotLS0KIGdj Yy9naW1wbGUtcmFuZ2UtZWRnZS5jYyB8ICAgMiArLQogZ2NjL2dpbXBsZS1yYW5nZS1mb2xkLmNj IHwgIDQzICsrKystLS0tCiBnY2MvZ2ltcGxlLXJhbmdlLWZvbGQuaCAgfCAgMTUgLS0tCiBnY2Mv Z2ltcGxlLXJhbmdlLWdvcmkuY2MgfCAgNDEgKysrKy0tLS0KIGdjYy9naW1wbGUtcmFuZ2UuY2Mg ICAgICB8ICAgNiArLQogZ2NjL3JhbmdlLW9wLmNjICAgICAgICAgIHwgMjE1ICsrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKystLS0tLQogZ2NjL3JhbmdlLW9wLmggICAgICAgICAgIHwg IDQ1ICsrKysrKy0tCiBnY2MvdHJlZS1kYXRhLXJlZi5jYyAgICAgfCAgIDggKy0KIGdjYy90cmVl LXZycC5jYyAgICAgICAgICB8ICA0NCArKysrLS0tLQogZ2NjL3ZhbHVlLXF1ZXJ5LmNjICAgICAg IHwgICA4ICstCiAxMCBmaWxlcyBjaGFuZ2VkLCAzMDMgaW5zZXJ0aW9ucygrKSwgMTI0IGRlbGV0 aW9ucygtKQoKZGlmZiAtLWdpdCBhL2djYy9naW1wbGUtcmFuZ2UtZWRnZS5jYyBiL2djYy9naW1w bGUtcmFuZ2UtZWRnZS5jYwppbmRleCAwYmVlMzhiYTc3MC4uNWJiZTIzYWUwM2QgMTAwNjQ0Ci0t LSBhL2djYy9naW1wbGUtcmFuZ2UtZWRnZS5jYworKysgYi9nY2MvZ2ltcGxlLXJhbmdlLWVkZ2Uu Y2MKQEAgLTQyLDcgKzQyLDcgQEAgZ2ltcGxlX291dGdvaW5nX3JhbmdlX3N0bXRfcCAoYmFzaWNf YmxvY2sgYmIpCiAgIGlmICghZ3NpX2VuZF9wIChnc2kpKQogICAgIHsKICAgICAgIGdpbXBsZSAq cyA9IGdzaV9zdG10IChnc2kpOwotICAgICAgaWYgKGlzX2E8Z2NvbmQgKj4gKHMpICYmIGdpbXBs ZV9yYW5nZV9oYW5kbGVyIChzKSkKKyAgICAgIGlmIChpc19hPGdjb25kICo+IChzKSAmJiByYW5n ZV9vcF9oYW5kbGVyIChzKSkKIAlyZXR1cm4gZ3NpX3N0bXQgKGdzaSk7CiAgICAgICBnc3dpdGNo ICpzdyA9IGR5bl9jYXN0PGdzd2l0Y2ggKj4gKHMpOwogICAgICAgaWYgKHN3ICYmIGlyYW5nZTo6 c3VwcG9ydHNfdHlwZV9wIChUUkVFX1RZUEUgKGdpbXBsZV9zd2l0Y2hfaW5kZXggKHN3KSkpKQpk aWZmIC0tZ2l0IGEvZ2NjL2dpbXBsZS1yYW5nZS1mb2xkLmNjIGIvZ2NjL2dpbXBsZS1yYW5nZS1m b2xkLmNjCmluZGV4IDBhOTQ3YzE2YzU4Li5jNTNkMjg2M2Q1ZSAxMDA2NDQKLS0tIGEvZ2NjL2dp bXBsZS1yYW5nZS1mb2xkLmNjCisrKyBiL2djYy9naW1wbGUtcmFuZ2UtZm9sZC5jYwpAQCAtNDgy LDcgKzQ4Miw3IEBAIGdpbXBsZV9yYW5nZV9iYXNlX29mX2Fzc2lnbm1lbnQgKGNvbnN0IGdpbXBs ZSAqc3RtdCkKIHRyZWUKIGdpbXBsZV9yYW5nZV9vcGVyYW5kMSAoY29uc3QgZ2ltcGxlICpzdG10 KQogewotICBnY2NfY2hlY2tpbmdfYXNzZXJ0IChnaW1wbGVfcmFuZ2VfaGFuZGxlciAoc3RtdCkp OworICBnY2NfY2hlY2tpbmdfYXNzZXJ0IChyYW5nZV9vcF9oYW5kbGVyIChzdG10KSk7CiAKICAg c3dpdGNoIChnaW1wbGVfY29kZSAoc3RtdCkpCiAgICAgewpAQCAtNTE1LDcgKzUxNSw3IEBAIGdp bXBsZV9yYW5nZV9vcGVyYW5kMSAoY29uc3QgZ2ltcGxlICpzdG10KQogdHJlZQogZ2ltcGxlX3Jh bmdlX29wZXJhbmQyIChjb25zdCBnaW1wbGUgKnN0bXQpCiB7Ci0gIGdjY19jaGVja2luZ19hc3Nl cnQgKGdpbXBsZV9yYW5nZV9oYW5kbGVyIChzdG10KSk7CisgIGdjY19jaGVja2luZ19hc3NlcnQg KHJhbmdlX29wX2hhbmRsZXIgKHN0bXQpKTsKIAogICBzd2l0Y2ggKGdpbXBsZV9jb2RlIChzdG10 KSkKICAgICB7CkBAIC01NTEsNyArNTUxLDcgQEAgZm9sZF91c2luZ19yYW5nZTo6Zm9sZF9zdG10 IChpcmFuZ2UgJnIsIGdpbXBsZSAqcywgZnVyX3NvdXJjZSAmc3JjLCB0cmVlIG5hbWUpCiAgICAg ICAmJiBnaW1wbGVfYXNzaWduX3Joc19jb2RlIChzKSA9PSBBRERSX0VYUFIpCiAgICAgcmV0dXJu IHJhbmdlX29mX2FkZHJlc3MgKHIsIHMsIHNyYyk7CiAKLSAgaWYgKGdpbXBsZV9yYW5nZV9oYW5k bGVyIChzKSkKKyAgaWYgKHJhbmdlX29wX2hhbmRsZXIgKHMpKQogICAgIHJlcyA9IHJhbmdlX29m X3JhbmdlX29wIChyLCBzLCBzcmMpOwogICBlbHNlIGlmIChpc19hPGdwaGkgKj4ocykpCiAgICAg cmVzID0gcmFuZ2Vfb2ZfcGhpIChyLCBhc19hPGdwaGkgKj4gKHMpLCBzcmMpOwpAQCAtNTkzLDcg KzU5Myw3IEBAIGZvbGRfdXNpbmdfcmFuZ2U6OnJhbmdlX29mX3JhbmdlX29wIChpcmFuZ2UgJnIs IGdpbXBsZSAqcywgZnVyX3NvdXJjZSAmc3JjKQogICB0cmVlIHR5cGUgPSBnaW1wbGVfcmFuZ2Vf dHlwZSAocyk7CiAgIGlmICghdHlwZSkKICAgICByZXR1cm4gZmFsc2U7Ci0gIHJhbmdlX29wZXJh dG9yICpoYW5kbGVyID0gZ2ltcGxlX3JhbmdlX2hhbmRsZXIgKHMpOworICByYW5nZV9vcF9oYW5k bGVyIGhhbmRsZXIgKHMpOwogICBnY2NfY2hlY2tpbmdfYXNzZXJ0IChoYW5kbGVyKTsKIAogICB0 cmVlIGxocyA9IGdpbXBsZV9nZXRfbGhzIChzKTsKQEAgLTYwNiwxMyArNjA2LDEzIEBAIGZvbGRf dXNpbmdfcmFuZ2U6OnJhbmdlX29mX3JhbmdlX29wIChpcmFuZ2UgJnIsIGdpbXBsZSAqcywgZnVy X3NvdXJjZSAmc3JjKQogCXsKIAkgIC8vIEZvbGQgcmFuZ2UsIGFuZCByZWdpc3RlciBhbnkgZGVw ZW5kZW5jeSBpZiBhdmFpbGFibGUuCiAJICBpbnRfcmFuZ2U8Mj4gcjIgKHR5cGUpOwotCSAgaGFu ZGxlci0+Zm9sZF9yYW5nZSAociwgdHlwZSwgcmFuZ2UxLCByMik7CisJICBoYW5kbGVyLmZvbGRf cmFuZ2UgKHIsIHR5cGUsIHJhbmdlMSwgcjIpOwogCSAgaWYgKGxocyAmJiBnaW1wbGVfcmFuZ2Vf c3NhX3AgKG9wMSkpCiAJICAgIHsKIAkgICAgICBpZiAoc3JjLmdvcmkgKCkpCiAJCXNyYy5nb3Jp ICgpLT5yZWdpc3Rlcl9kZXBlbmRlbmN5IChsaHMsIG9wMSk7CiAJICAgICAgcmVsYXRpb25fa2lu ZCByZWw7Ci0JICAgICAgcmVsID0gaGFuZGxlci0+bGhzX29wMV9yZWxhdGlvbiAociwgcmFuZ2Ux LCByYW5nZTEpOworCSAgICAgIHJlbCA9IGhhbmRsZXIubGhzX29wMV9yZWxhdGlvbiAociwgcmFu Z2UxLCByYW5nZTEpOwogCSAgICAgIGlmIChyZWwgIT0gVlJFTF9WQVJZSU5HKQogCQlzcmMucmVn aXN0ZXJfcmVsYXRpb24gKHMsIHJlbCwgbGhzLCBvcDEpOwogCSAgICB9CkBAIC02MjksNyArNjI5 LDcgQEAgZm9sZF91c2luZ19yYW5nZTo6cmFuZ2Vfb2ZfcmFuZ2Vfb3AgKGlyYW5nZSAmciwgZ2lt cGxlICpzLCBmdXJfc291cmNlICZzcmMpCiAJICAgICAgZnB1dGMgKCdcbicsIGR1bXBfZmlsZSk7 CiAJICAgIH0KIAkgIC8vIEZvbGQgcmFuZ2UsIGFuZCByZWdpc3RlciBhbnkgZGVwZW5kZW5jeSBp ZiBhdmFpbGFibGUuCi0JICBoYW5kbGVyLT5mb2xkX3JhbmdlIChyLCB0eXBlLCByYW5nZTEsIHJh bmdlMiwgcmVsKTsKKwkgIGhhbmRsZXIuZm9sZF9yYW5nZSAociwgdHlwZSwgcmFuZ2UxLCByYW5n ZTIsIHJlbCk7CiAJICByZWxhdGlvbl9mb2xkX2FuZF9vciAociwgcywgc3JjKTsKIAkgIGlmIChs aHMpCiAJICAgIHsKQEAgLTY0MCwxMyArNjQwLDEzIEBAIGZvbGRfdXNpbmdfcmFuZ2U6OnJhbmdl X29mX3JhbmdlX29wIChpcmFuZ2UgJnIsIGdpbXBsZSAqcywgZnVyX3NvdXJjZSAmc3JjKQogCQl9 CiAJICAgICAgaWYgKGdpbXBsZV9yYW5nZV9zc2FfcCAob3AxKSkKIAkJewotCQkgIHJlbCA9IGhh bmRsZXItPmxoc19vcDFfcmVsYXRpb24gKHIsIHJhbmdlMSwgcmFuZ2UyLCByZWwpOworCQkgIHJl bCA9IGhhbmRsZXIubGhzX29wMV9yZWxhdGlvbiAociwgcmFuZ2UxLCByYW5nZTIsIHJlbCk7CiAJ CSAgaWYgKHJlbCAhPSBWUkVMX1ZBUllJTkcpCiAJCSAgICBzcmMucmVnaXN0ZXJfcmVsYXRpb24g KHMsIHJlbCwgbGhzLCBvcDEpOwogCQl9CiAJICAgICAgaWYgKGdpbXBsZV9yYW5nZV9zc2FfcCAo b3AyKSkKIAkJewotCQkgIHJlbD0gaGFuZGxlci0+bGhzX29wMl9yZWxhdGlvbiAociwgcmFuZ2Ux LCByYW5nZTIsIHJlbCk7CisJCSAgcmVsPSBoYW5kbGVyLmxoc19vcDJfcmVsYXRpb24gKHIsIHJh bmdlMSwgcmFuZ2UyLCByZWwpOwogCQkgIGlmIChyZWwgIT0gVlJFTF9WQVJZSU5HKQogCQkgICAg c3JjLnJlZ2lzdGVyX3JlbGF0aW9uIChzLCByZWwsIGxocywgb3AyKTsKIAkJfQpAQCAtOTIxLDcg KzkyMSw3IEBAIGZvbGRfdXNpbmdfcmFuZ2U6OnJhbmdlX29mX2J1aWx0aW5fdWJzYW5fY2FsbCAo aXJhbmdlICZyLCBnY2FsbCAqY2FsbCwKICAgZ2NjX2NoZWNraW5nX2Fzc2VydCAoY29kZSA9PSBQ TFVTX0VYUFIgfHwgY29kZSA9PSBNSU5VU19FWFBSCiAJCSAgICAgICB8fCBjb2RlID09IE1VTFRf RVhQUik7CiAgIHRyZWUgdHlwZSA9IGdpbXBsZV9yYW5nZV90eXBlIChjYWxsKTsKLSAgcmFuZ2Vf b3BlcmF0b3IgKm9wID0gcmFuZ2Vfb3BfaGFuZGxlciAoY29kZSwgdHlwZSk7CisgIHJhbmdlX29w X2hhbmRsZXIgb3AgKGNvZGUsIHR5cGUpOwogICBnY2NfY2hlY2tpbmdfYXNzZXJ0IChvcCk7CiAg IGludF9yYW5nZV9tYXggaXIwLCBpcjE7CiAgIHRyZWUgYXJnMCA9IGdpbXBsZV9jYWxsX2FyZyAo Y2FsbCwgMCk7CkBAIC05MzUsNyArOTM1LDcgQEAgZm9sZF91c2luZ19yYW5nZTo6cmFuZ2Vfb2Zf YnVpbHRpbl91YnNhbl9jYWxsIChpcmFuZ2UgJnIsIGdjYWxsICpjYWxsLAogICAvLyBQcmV0ZW5k IHRoZSBhcml0aG1ldGljIGlzIHdyYXBwaW5nLiAgSWYgdGhlcmUgaXMgYW55IG92ZXJmbG93LAog ICAvLyB3ZSdsbCBjb21wbGFpbiwgYnV0IHdpbGwgYWN0dWFsbHkgZG8gd3JhcHBpbmcgb3BlcmF0 aW9uLgogICBmbGFnX3dyYXB2ID0gMTsKLSAgb3AtPmZvbGRfcmFuZ2UgKHIsIHR5cGUsIGlyMCwg aXIxLCByZWxhdGlvbik7CisgIG9wLmZvbGRfcmFuZ2UgKHIsIHR5cGUsIGlyMCwgaXIxLCByZWxh dGlvbik7CiAgIGZsYWdfd3JhcHYgPSBzYXZlZF9mbGFnX3dyYXB2OwogCiAgIC8vIElmIGZvciBi b3RoIGFyZ3VtZW50cyB2cnBfdmFsdWVpemUgcmV0dXJuZWQgbm9uLU5VTEwsIHRoaXMgc2hvdWxk CkBAIC0xMzkxLDggKzEzOTEsOCBAQCBmb2xkX3VzaW5nX3JhbmdlOjpyZWxhdGlvbl9mb2xkX2Fu ZF9vciAoaXJhbmdlJiBsaHNfcmFuZ2UsIGdpbXBsZSAqcywKICAgZWxzZSBpZiAoc3NhMV9kZXAx ICE9IHNzYTJfZGVwMiB8fCBzc2ExX2RlcDIgIT0gc3NhMl9kZXAxKQogICAgIHJldHVybjsKIAot ICByYW5nZV9vcGVyYXRvciAqaGFuZGxlcjEgPSBnaW1wbGVfcmFuZ2VfaGFuZGxlciAoU1NBX05B TUVfREVGX1NUTVQgKHNzYTEpKTsKLSAgcmFuZ2Vfb3BlcmF0b3IgKmhhbmRsZXIyID0gZ2ltcGxl X3JhbmdlX2hhbmRsZXIgKFNTQV9OQU1FX0RFRl9TVE1UIChzc2EyKSk7CisgIHJhbmdlX29wX2hh bmRsZXIgaGFuZGxlcjEgKFNTQV9OQU1FX0RFRl9TVE1UIChzc2ExKSk7CisgIHJhbmdlX29wX2hh bmRsZXIgaGFuZGxlcjIgKFNTQV9OQU1FX0RFRl9TVE1UIChzc2EyKSk7CiAKICAgLy8gSWYgZWl0 aGVyIGhhbmRsZXIgaXMgbm90IHByZXNlbnQsIG5vIHJlbGF0aW9uIGlzIGZvdW5kLgogICBpZiAo IWhhbmRsZXIxIHx8ICFoYW5kbGVyMikKQEAgLTE0MDAsOCArMTQwMCw4IEBAIGZvbGRfdXNpbmdf cmFuZ2U6OnJlbGF0aW9uX2ZvbGRfYW5kX29yIChpcmFuZ2UmIGxoc19yYW5nZSwgZ2ltcGxlICpz LAogCiAgIGludF9yYW5nZTwyPiBib29sX29uZSAoYm9vbGVhbl90cnVlX25vZGUsIGJvb2xlYW5f dHJ1ZV9ub2RlKTsKIAotICByZWxhdGlvbl9raW5kIHJlbGF0aW9uMSA9IGhhbmRsZXIxLT5vcDFf b3AyX3JlbGF0aW9uIChib29sX29uZSk7Ci0gIHJlbGF0aW9uX2tpbmQgcmVsYXRpb24yID0gaGFu ZGxlcjItPm9wMV9vcDJfcmVsYXRpb24gKGJvb2xfb25lKTsKKyAgcmVsYXRpb25fa2luZCByZWxh dGlvbjEgPSBoYW5kbGVyMS5vcDFfb3AyX3JlbGF0aW9uIChib29sX29uZSk7CisgIHJlbGF0aW9u X2tpbmQgcmVsYXRpb24yID0gaGFuZGxlcjIub3AxX29wMl9yZWxhdGlvbiAoYm9vbF9vbmUpOwog ICBpZiAocmVsYXRpb24xID09IFZSRUxfVkFSWUlORyB8fCByZWxhdGlvbjIgPT0gVlJFTF9WQVJZ SU5HKQogICAgIHJldHVybjsKIApAQCAtMTQ0MSw3ICsxNDQxLDYgQEAgZnVyX3NvdXJjZTo6cmVn aXN0ZXJfb3V0Z29pbmdfZWRnZXMgKGdjb25kICpzLCBpcmFuZ2UgJmxoc19yYW5nZSwgZWRnZSBl MCwgZWRnZQogICBpbnRfcmFuZ2VfbWF4IHI7CiAgIGludF9yYW5nZTwyPiBlMF9yYW5nZSwgZTFf cmFuZ2U7CiAgIHRyZWUgbmFtZTsKLSAgcmFuZ2Vfb3BlcmF0b3IgKmhhbmRsZXI7CiAgIGJhc2lj X2Jsb2NrIGJiID0gZ2ltcGxlX2JiIChzKTsKIAogICBpZiAoZTApCkBAIC0xNDcyLDE3ICsxNDcx LDE3IEBAIGZ1cl9zb3VyY2U6OnJlZ2lzdGVyX291dGdvaW5nX2VkZ2VzIChnY29uZCAqcywgaXJh bmdlICZsaHNfcmFuZ2UsIGVkZ2UgZTAsIGVkZ2UKICAgdHJlZSBzc2EyID0gZ2ltcGxlX3Jhbmdl X3NzYV9wIChnaW1wbGVfcmFuZ2Vfb3BlcmFuZDIgKHMpKTsKICAgaWYgKHNzYTEgJiYgc3NhMikK ICAgICB7Ci0gICAgICBoYW5kbGVyID0gZ2ltcGxlX3JhbmdlX2hhbmRsZXIgKHMpOworICAgICAg cmFuZ2Vfb3BfaGFuZGxlciBoYW5kbGVyIChzKTsKICAgICAgIGdjY19jaGVja2luZ19hc3NlcnQg KGhhbmRsZXIpOwogICAgICAgaWYgKGUwKQogCXsKLQkgIHJlbGF0aW9uX2tpbmQgcmVsYXRpb24g PSBoYW5kbGVyLT5vcDFfb3AyX3JlbGF0aW9uIChlMF9yYW5nZSk7CisJICByZWxhdGlvbl9raW5k IHJlbGF0aW9uID0gaGFuZGxlci5vcDFfb3AyX3JlbGF0aW9uIChlMF9yYW5nZSk7CiAJICBpZiAo cmVsYXRpb24gIT0gVlJFTF9WQVJZSU5HKQogCSAgICByZWdpc3Rlcl9yZWxhdGlvbiAoZTAsIHJl bGF0aW9uLCBzc2ExLCBzc2EyKTsKIAl9CiAgICAgICBpZiAoZTEpCiAJewotCSAgcmVsYXRpb25f a2luZCByZWxhdGlvbiA9IGhhbmRsZXItPm9wMV9vcDJfcmVsYXRpb24gKGUxX3JhbmdlKTsKKwkg IHJlbGF0aW9uX2tpbmQgcmVsYXRpb24gPSBoYW5kbGVyLm9wMV9vcDJfcmVsYXRpb24gKGUxX3Jh bmdlKTsKIAkgIGlmIChyZWxhdGlvbiAhPSBWUkVMX1ZBUllJTkcpCiAJICAgIHJlZ2lzdGVyX3Jl bGF0aW9uIChlMSwgcmVsYXRpb24sIHNzYTEsIHNzYTIpOwogCX0KQEAgLTE1MDEsNyArMTUwMCw3 IEBAIGZ1cl9zb3VyY2U6OnJlZ2lzdGVyX291dGdvaW5nX2VkZ2VzIChnY29uZCAqcywgaXJhbmdl ICZsaHNfcmFuZ2UsIGVkZ2UgZTAsIGVkZ2UKICAgICAgIGlmIChUUkVFX0NPREUgKFRSRUVfVFlQ RSAobmFtZSkpICE9IEJPT0xFQU5fVFlQRSkKIAljb250aW51ZTsKICAgICAgIGdpbXBsZSAqc3Rt dCA9IFNTQV9OQU1FX0RFRl9TVE1UIChuYW1lKTsKLSAgICAgIGhhbmRsZXIgPSBnaW1wbGVfcmFu Z2VfaGFuZGxlciAoc3RtdCk7CisgICAgICByYW5nZV9vcF9oYW5kbGVyIGhhbmRsZXIgKHN0bXQp OwogICAgICAgaWYgKCFoYW5kbGVyKQogCWNvbnRpbnVlOwogICAgICAgdHJlZSBzc2ExID0gZ2lt cGxlX3JhbmdlX3NzYV9wIChnaW1wbGVfcmFuZ2Vfb3BlcmFuZDEgKHN0bXQpKTsKQEAgLTE1MTEs MTQgKzE1MTAsMTQgQEAgZnVyX3NvdXJjZTo6cmVnaXN0ZXJfb3V0Z29pbmdfZWRnZXMgKGdjb25k ICpzLCBpcmFuZ2UgJmxoc19yYW5nZSwgZWRnZSBlMCwgZWRnZQogCSAgaWYgKGUwICYmIGdvcmkg KCktPm91dGdvaW5nX2VkZ2VfcmFuZ2VfcCAociwgZTAsIG5hbWUsICptX3F1ZXJ5KQogCSAgICAg ICYmIHIuc2luZ2xldG9uX3AgKCkpCiAJICAgIHsKLQkgICAgICByZWxhdGlvbl9raW5kIHJlbGF0 aW9uID0gaGFuZGxlci0+b3AxX29wMl9yZWxhdGlvbiAocik7CisJICAgICAgcmVsYXRpb25fa2lu ZCByZWxhdGlvbiA9IGhhbmRsZXIub3AxX29wMl9yZWxhdGlvbiAocik7CiAJICAgICAgaWYgKHJl bGF0aW9uICE9IFZSRUxfVkFSWUlORykKIAkJcmVnaXN0ZXJfcmVsYXRpb24gKGUwLCByZWxhdGlv biwgc3NhMSwgc3NhMik7CiAJICAgIH0KIAkgIGlmIChlMSAmJiBnb3JpICgpLT5vdXRnb2luZ19l ZGdlX3JhbmdlX3AgKHIsIGUxLCBuYW1lLCAqbV9xdWVyeSkKIAkgICAgICAmJiByLnNpbmdsZXRv bl9wICgpKQogCSAgICB7Ci0JICAgICAgcmVsYXRpb25fa2luZCByZWxhdGlvbiA9IGhhbmRsZXIt Pm9wMV9vcDJfcmVsYXRpb24gKHIpOworCSAgICAgIHJlbGF0aW9uX2tpbmQgcmVsYXRpb24gPSBo YW5kbGVyLm9wMV9vcDJfcmVsYXRpb24gKHIpOwogCSAgICAgIGlmIChyZWxhdGlvbiAhPSBWUkVM X1ZBUllJTkcpCiAJCXJlZ2lzdGVyX3JlbGF0aW9uIChlMSwgcmVsYXRpb24sIHNzYTEsIHNzYTIp OwogCSAgICB9CmRpZmYgLS1naXQgYS9nY2MvZ2ltcGxlLXJhbmdlLWZvbGQuaCBiL2djYy9naW1w bGUtcmFuZ2UtZm9sZC5oCmluZGV4IDIwY2I3M2RhYmI5Li40YjVkNGI2ZTBiOCAxMDA2NDQKLS0t IGEvZ2NjL2dpbXBsZS1yYW5nZS1mb2xkLmgKKysrIGIvZ2NjL2dpbXBsZS1yYW5nZS1mb2xkLmgK QEAgLTQxLDIxICs0MSw2IEBAIGJvb2wgZm9sZF9yYW5nZSAoaXJhbmdlICZyLCBnaW1wbGUgKnMs IGlyYW5nZSAmcjEpOwogYm9vbCBmb2xkX3JhbmdlIChpcmFuZ2UgJnIsIGdpbXBsZSAqcywgaXJh bmdlICZyMSwgaXJhbmdlICZyMik7CiBib29sIGZvbGRfcmFuZ2UgKGlyYW5nZSAmciwgZ2ltcGxl ICpzLCB1bnNpZ25lZCBudW1fZWxlbWVudHMsIGlyYW5nZSAqdmVjdG9yKTsKIAotLy8gUmV0dXJu IHRoZSByYW5nZV9vcGVyYXRvciBwb2ludGVyIGZvciB0aGlzIHN0YXRlbWVudC4gIFRoaXMgcm91 dGluZQotLy8gY2FuIGFsc28gYmUgdXNlZCB0byBnYXRlIHdoZXRoZXIgYSByb3V0aW5lIGlzIHJh bmdlLW9wcyBlbmFibGVkLgotCi1zdGF0aWMgaW5saW5lIHJhbmdlX29wZXJhdG9yICoKLWdpbXBs ZV9yYW5nZV9oYW5kbGVyIChjb25zdCBnaW1wbGUgKnMpCi17Ci0gIGlmIChjb25zdCBnYXNzaWdu ICphc3MgPSBkeW5fY2FzdDxjb25zdCBnYXNzaWduICo+IChzKSkKLSAgICByZXR1cm4gcmFuZ2Vf b3BfaGFuZGxlciAoZ2ltcGxlX2Fzc2lnbl9yaHNfY29kZSAoYXNzKSwKLQkJCSAgICAgVFJFRV9U WVBFIChnaW1wbGVfYXNzaWduX2xocyAoYXNzKSkpOwotICBpZiAoY29uc3QgZ2NvbmQgKmNvbmQg PSBkeW5fY2FzdDxjb25zdCBnY29uZCAqPiAocykpCi0gICAgcmV0dXJuIHJhbmdlX29wX2hhbmRs ZXIgKGdpbXBsZV9jb25kX2NvZGUgKGNvbmQpLAotCQkJICAgICBUUkVFX1RZUEUgKGdpbXBsZV9j b25kX2xocyAoY29uZCkpKTsKLSAgcmV0dXJuIE5VTEw7Ci19Ci0KIC8vIFJldHVybiB0aGUgdHlw ZSBvZiByYW5nZSB3aGljaCBzdGF0ZW1lbnQgUyBjYWxjdWxhdGVzLiAgSWYgdGhlIHR5cGUgaXMK IC8vIHVuc3VwcG9ydGVkIG9yIG5vIHR5cGUgY2FuIGJlIGRldGVybWluZWQsIHJldHVybiBOVUxM X1RSRUUuCiAKZGlmZiAtLWdpdCBhL2djYy9naW1wbGUtcmFuZ2UtZ29yaS5jYyBiL2djYy9naW1w bGUtcmFuZ2UtZ29yaS5jYwppbmRleCAzZTE1ZWI1MTkyZC4uNzIwMzIxMzJjYWMgMTAwNjQ0Ci0t LSBhL2djYy9naW1wbGUtcmFuZ2UtZ29yaS5jYworKysgYi9nY2MvZ2ltcGxlLXJhbmdlLWdvcmku Y2MKQEAgLTQ0LDkgKzQ0LDkgQEAgZ2ltcGxlX3JhbmdlX2NhbGNfb3AxIChpcmFuZ2UgJnIsIGNv bnN0IGdpbXBsZSAqc3RtdCwgY29uc3QgaXJhbmdlICZsaHNfcmFuZ2UpCiAgIC8vIFVuYXJ5IG9w ZXJhdGlvbnMgcmVxdWlyZSB0aGUgdHlwZSBvZiB0aGUgZmlyc3Qgb3BlcmFuZCBpbiB0aGUKICAg Ly8gc2Vjb25kIHJhbmdlIHBvc2l0aW9uLgogICB0cmVlIHR5cGUgPSBUUkVFX1RZUEUgKGdpbXBs ZV9yYW5nZV9vcGVyYW5kMSAoc3RtdCkpOwotICBpbnRfcmFuZ2U8Mj4gdHlwZV9yYW5nZSAodHlw ZSk7Ci0gIHJldHVybiBnaW1wbGVfcmFuZ2VfaGFuZGxlciAoc3RtdCktPm9wMV9yYW5nZSAociwg dHlwZSwgbGhzX3JhbmdlLAotCQkJCQkJIHR5cGVfcmFuZ2UpOworICBWYWx1ZV9SYW5nZSB0eXBl X3JhbmdlICh0eXBlKTsKKyAgdHlwZV9yYW5nZS5zZXRfdmFyeWluZyAodHlwZSk7CisgIHJldHVy biByYW5nZV9vcF9oYW5kbGVyIChzdG10KS5vcDFfcmFuZ2UgKHIsIHR5cGUsIGxoc19yYW5nZSwg dHlwZV9yYW5nZSk7CiB9CiAKIC8vIENhbGN1bGF0ZSB3aGF0IHdlIGNhbiBkZXRlcm1pbmUgb2Yg dGhlIHJhbmdlIG9mIHRoaXMgc3RhdGVtZW50J3MKQEAgLTcyLDEyICs3MiwxMiBAQCBnaW1wbGVf cmFuZ2VfY2FsY19vcDEgKGlyYW5nZSAmciwgY29uc3QgZ2ltcGxlICpzdG10LAogICAgICAgLy8g VGhpcyBpcyBzb21ldGltZXMgaW52b2tlZCBvbiBzaW5nbGUgb3BlcmFuZCBzdG10cy4KICAgICAg IGlmIChnaW1wbGVfbnVtX29wcyAoc3RtdCkgPCAzKQogCXJldHVybiBmYWxzZTsKLSAgICAgIGlu dF9yYW5nZTwyPiB0cmFuZ2UgKFRSRUVfVFlQRSAoZ2ltcGxlX3JhbmdlX29wZXJhbmQyIChzdG10 KSkpOwotICAgICAgcmV0dXJuIGdpbXBsZV9yYW5nZV9oYW5kbGVyIChzdG10KS0+b3AxX3Jhbmdl IChyLCB0eXBlLCBsaHNfcmFuZ2UsCi0JCQkJCQkgICAgIHRyYW5nZSk7CisgICAgICB0cmVlIG9w Ml90eXBlID0gVFJFRV9UWVBFIChnaW1wbGVfcmFuZ2Vfb3BlcmFuZDIgKHN0bXQpKTsKKyAgICAg IFZhbHVlX1JhbmdlIHRyYW5nZSAob3AyX3R5cGUpOworICAgICAgdHJhbmdlLnNldF92YXJ5aW5n IChvcDJfdHlwZSk7CisgICAgICByZXR1cm4gcmFuZ2Vfb3BfaGFuZGxlciAoc3RtdCkub3AxX3Jh bmdlIChyLCB0eXBlLCBsaHNfcmFuZ2UsIHRyYW5nZSk7CiAgICAgfQotICByZXR1cm4gZ2ltcGxl X3JhbmdlX2hhbmRsZXIgKHN0bXQpLT5vcDFfcmFuZ2UgKHIsIHR5cGUsIGxoc19yYW5nZSwKLQkJ CQkJCSBvcDJfcmFuZ2UpOworICByZXR1cm4gcmFuZ2Vfb3BfaGFuZGxlciAoc3RtdCkub3AxX3Jh bmdlIChyLCB0eXBlLCBsaHNfcmFuZ2UsIG9wMl9yYW5nZSk7CiB9CiAKIC8vIENhbGN1bGF0ZSB3 aGF0IHdlIGNhbiBkZXRlcm1pbmUgb2YgdGhlIHJhbmdlIG9mIHRoaXMgc3RhdGVtZW50J3MKQEAg LTk3LDEyICs5NywxMyBAQCBnaW1wbGVfcmFuZ2VfY2FsY19vcDIgKGlyYW5nZSAmciwgY29uc3Qg Z2ltcGxlICpzdG10LAogICAvLyBJZiBvcDEgaXMgdW5kZWZpbmVkLCBzb2x2ZSBhcyBpZiBpdCBp cyB2YXJ5aW5nLgogICBpZiAob3AxX3JhbmdlLnVuZGVmaW5lZF9wICgpKQogICAgIHsKLSAgICAg IGludF9yYW5nZTwyPiB0cmFuZ2UgKFRSRUVfVFlQRSAoZ2ltcGxlX3JhbmdlX29wZXJhbmQxIChz dG10KSkpOwotICAgICAgcmV0dXJuIGdpbXBsZV9yYW5nZV9oYW5kbGVyIChzdG10KS0+b3AyX3Jh bmdlIChyLCB0eXBlLCBsaHNfcmFuZ2UsCi0JCQkJCQkgICAgIHRyYW5nZSk7CisgICAgICB0cmVl IG9wMV90eXBlID0gVFJFRV9UWVBFIChnaW1wbGVfcmFuZ2Vfb3BlcmFuZDEgKHN0bXQpKTsKKyAg ICAgIFZhbHVlX1JhbmdlIHRyYW5nZSAob3AxX3R5cGUpOworICAgICAgdHJhbmdlLnNldF92YXJ5 aW5nIChvcDFfdHlwZSk7CisgICAgICByZXR1cm4gcmFuZ2Vfb3BfaGFuZGxlciAoc3RtdCkub3Ay X3JhbmdlIChyLCB0eXBlLCBsaHNfcmFuZ2UsIHRyYW5nZSk7CiAgICAgfQotICByZXR1cm4gZ2lt cGxlX3JhbmdlX2hhbmRsZXIgKHN0bXQpLT5vcDJfcmFuZ2UgKHIsIHR5cGUsIGxoc19yYW5nZSwK LQkJCQkJCSBvcDFfcmFuZ2UpOworICByZXR1cm4gcmFuZ2Vfb3BfaGFuZGxlciAoc3RtdCkub3Ay X3JhbmdlIChyLCB0eXBlLCBsaHNfcmFuZ2UsCisJCQkJCSAgICBvcDFfcmFuZ2UpOwogfQogCiAv LyBSZXR1cm4gVFJVRSBpZiBHUyBpcyBhIGxvZ2ljYWwgJiYgb3IgfHwgZXhwcmVzc2lvbi4KQEAg LTM0Niw3ICszNDcsNyBAQCByYW5nZV9kZWZfY2hhaW46OmdldF9kZWZfY2hhaW4gKHRyZWUgbmFt ZSkKICAgICB9CiAKICAgZ2ltcGxlICpzdG10ID0gU1NBX05BTUVfREVGX1NUTVQgKG5hbWUpOwot ICBpZiAoZ2ltcGxlX3JhbmdlX2hhbmRsZXIgKHN0bXQpKQorICBpZiAocmFuZ2Vfb3BfaGFuZGxl ciAoc3RtdCkpCiAgICAgewogICAgICAgc3NhMSA9IGdpbXBsZV9yYW5nZV9zc2FfcCAoZ2ltcGxl X3JhbmdlX29wZXJhbmQxIChzdG10KSk7CiAgICAgICBzc2EyID0gZ2ltcGxlX3JhbmdlX3NzYV9w IChnaW1wbGVfcmFuZ2Vfb3BlcmFuZDIgKHN0bXQpKTsKQEAgLTcwNyw3ICs3MDgsNyBAQCBnb3Jp X2NvbXB1dGU6OmNvbXB1dGVfb3BlcmFuZF9yYW5nZSAoaXJhbmdlICZyLCBnaW1wbGUgKnN0bXQs CiAgIGlmIChpc19hPGdzd2l0Y2ggKj4gKHN0bXQpKQogICAgIHJldHVybiBjb21wdXRlX29wZXJh bmRfcmFuZ2Vfc3dpdGNoIChyLCBhc19hPGdzd2l0Y2ggKj4gKHN0bXQpLCBsaHMsIG5hbWUsCiAJ CQkJCSBzcmMpOwotICBpZiAoIWdpbXBsZV9yYW5nZV9oYW5kbGVyIChzdG10KSkKKyAgaWYgKCFy YW5nZV9vcF9oYW5kbGVyIChzdG10KSkKICAgICByZXR1cm4gZmFsc2U7CiAKICAgdHJlZSBvcDEg PSBnaW1wbGVfcmFuZ2Vfc3NhX3AgKGdpbXBsZV9yYW5nZV9vcGVyYW5kMSAoc3RtdCkpOwpAQCAt MTMyOCw3ICsxMzI5LDcgQEAgZ29yaV9jb21wdXRlOjpjb25kZXhwcl9hZGp1c3QgKGlyYW5nZSAm cjEsIGlyYW5nZSAmcjIsIGdpbXBsZSAqLCB0cmVlIGNvbmQsCiAgIHRyZWUgdHlwZSA9IFRSRUVf VFlQRSAoZ2ltcGxlX2Fzc2lnbl9yaHMxIChjb25kX2RlZikpOwogICBpZiAoIXJhbmdlX2NvbXBh dGlibGVfcCAodHlwZSwgVFJFRV9UWVBFIChnaW1wbGVfYXNzaWduX3JoczIgKGNvbmRfZGVmKSkp KQogICAgIHJldHVybiBmYWxzZTsKLSAgcmFuZ2Vfb3BlcmF0b3IgKmhhbmQgPSByYW5nZV9vcF9o YW5kbGVyIChnaW1wbGVfYXNzaWduX3Joc19jb2RlIChjb25kX2RlZiksIHR5cGUpOworICByYW5n ZV9vcF9oYW5kbGVyIGhhbmQgKGdpbXBsZV9hc3NpZ25fcmhzX2NvZGUgKGNvbmRfZGVmKSwgdHlw ZSk7CiAgIGlmICghaGFuZCkKICAgICByZXR1cm4gZmFsc2U7CiAKQEAgLTEzNTEsMTggKzEzNTIs MTggQEAgZ29yaV9jb21wdXRlOjpjb25kZXhwcl9hZGp1c3QgKGlyYW5nZSAmcjEsIGlyYW5nZSAm cjIsIGdpbXBsZSAqLCB0cmVlIGNvbmQsCiAgIC8vIHRoZSBvcDEgb3Igb3AyIHJvdXRpbmVzIGJh c2VkIG9uIGl0cyBsb2NhdGlvbi4KICAgaWYgKGMxKQogICAgIHsKLSAgICAgIGlmICghaGFuZC0+ b3AxX3JhbmdlIChjb25kX2ZhbHNlLCB0eXBlLCBtX2Jvb2xfemVybywgY3IpKQorICAgICAgaWYg KCFoYW5kLm9wMV9yYW5nZSAoY29uZF9mYWxzZSwgdHlwZSwgbV9ib29sX3plcm8sIGNyKSkKIAly ZXR1cm4gZmFsc2U7Ci0gICAgICBpZiAoIWhhbmQtPm9wMV9yYW5nZSAoY29uZF90cnVlLCB0eXBl LCBtX2Jvb2xfb25lLCBjcikpCisgICAgICBpZiAoIWhhbmQub3AxX3JhbmdlIChjb25kX3RydWUs IHR5cGUsIG1fYm9vbF9vbmUsIGNyKSkKIAlyZXR1cm4gZmFsc2U7CiAgICAgICBjb25kX2ZhbHNl LmludGVyc2VjdCAoY2wpOwogICAgICAgY29uZF90cnVlLmludGVyc2VjdCAoY2wpOwogICAgIH0K ICAgZWxzZQogICAgIHsKLSAgICAgIGlmICghaGFuZC0+b3AyX3JhbmdlIChjb25kX2ZhbHNlLCB0 eXBlLCBtX2Jvb2xfemVybywgY2wpKQorICAgICAgaWYgKCFoYW5kLm9wMl9yYW5nZSAoY29uZF9m YWxzZSwgdHlwZSwgbV9ib29sX3plcm8sIGNsKSkKIAlyZXR1cm4gZmFsc2U7Ci0gICAgICBpZiAo IWhhbmQtPm9wMl9yYW5nZSAoY29uZF90cnVlLCB0eXBlLCBtX2Jvb2xfb25lLCBjbCkpCisgICAg ICBpZiAoIWhhbmQub3AyX3JhbmdlIChjb25kX3RydWUsIHR5cGUsIG1fYm9vbF9vbmUsIGNsKSkK IAlyZXR1cm4gZmFsc2U7CiAgICAgICBjb25kX2ZhbHNlLmludGVyc2VjdCAoY3IpOwogICAgICAg Y29uZF90cnVlLmludGVyc2VjdCAoY3IpOwpkaWZmIC0tZ2l0IGEvZ2NjL2dpbXBsZS1yYW5nZS5j YyBiL2djYy9naW1wbGUtcmFuZ2UuY2MKaW5kZXggNTNmNDg2NWFmM2IuLjBhOTk3ODdmYzc1IDEw MDY0NAotLS0gYS9nY2MvZ2ltcGxlLXJhbmdlLmNjCisrKyBiL2djYy9naW1wbGUtcmFuZ2UuY2MK QEAgLTMzOSw3ICszMzksNyBAQCBnaW1wbGVfcmFuZ2VyOjpwcmVmaWxsX25hbWUgKGlyYW5nZSAm ciwgdHJlZSBuYW1lKQogICBpZiAoIWdpbXBsZV9yYW5nZV9zc2FfcCAobmFtZSkpCiAgICAgcmV0 dXJuOwogICBnaW1wbGUgKnN0bXQgPSBTU0FfTkFNRV9ERUZfU1RNVCAobmFtZSk7Ci0gIGlmICgh Z2ltcGxlX3JhbmdlX2hhbmRsZXIgKHN0bXQpICYmICFpc19hPGdwaGkgKj4gKHN0bXQpKQorICBp ZiAoIXJhbmdlX29wX2hhbmRsZXIgKHN0bXQpICYmICFpc19hPGdwaGkgKj4gKHN0bXQpKQogICAg IHJldHVybjsKIAogICBib29sIGN1cnJlbnQ7CkBAIC0zNjMsNyArMzYzLDcgQEAgZ2ltcGxlX3Jh bmdlcjo6cHJlZmlsbF9zdG10X2RlcGVuZGVuY2llcyAodHJlZSBzc2EpCiAgIGdjY19jaGVja2lu Z19hc3NlcnQgKHN0bXQgJiYgZ2ltcGxlX2JiIChzdG10KSk7CiAKICAgLy8gT25seSBwcmUtcHJv Y2VzcyByYW5nZS1vcHMgYW5kIHBoaXMuCi0gIGlmICghZ2ltcGxlX3JhbmdlX2hhbmRsZXIgKHN0 bXQpICYmICFpc19hPGdwaGkgKj4gKHN0bXQpKQorICBpZiAoIXJhbmdlX29wX2hhbmRsZXIgKHN0 bXQpICYmICFpc19hPGdwaGkgKj4gKHN0bXQpKQogICAgIHJldHVybjsKIAogICAvLyBNYXJrIHdo ZXJlIG9uIHRoZSBzdGFjayB3ZSBhcmUgc3RhcnRpbmcuCkBAIC00MTksNyArNDE5LDcgQEAgZ2lt cGxlX3Jhbmdlcjo6cHJlZmlsbF9zdG10X2RlcGVuZGVuY2llcyAodHJlZSBzc2EpCiAJfQogICAg ICAgZWxzZQogCXsKLQkgIGdjY19jaGVja2luZ19hc3NlcnQgKGdpbXBsZV9yYW5nZV9oYW5kbGVy IChzdG10KSk7CisJICBnY2NfY2hlY2tpbmdfYXNzZXJ0IChyYW5nZV9vcF9oYW5kbGVyIChzdG10 KSk7CiAJICB0cmVlIG9wID0gZ2ltcGxlX3JhbmdlX29wZXJhbmQyIChzdG10KTsKIAkgIGlmIChv cCkKIAkgICAgcHJlZmlsbF9uYW1lIChyLCBvcCk7CmRpZmYgLS1naXQgYS9nY2MvcmFuZ2Utb3Au Y2MgYi9nY2MvcmFuZ2Utb3AuY2MKaW5kZXggYzg4ZGE4Y2FhNmMuLjAyOGI0YjcyMzdjIDEwMDY0 NAotLS0gYS9nY2MvcmFuZ2Utb3AuY2MKKysrIGIvZ2NjL3JhbmdlLW9wLmNjCkBAIC00MjAsNyAr NDIwLDcgQEAgY3JlYXRlX3Bvc3NpYmx5X3JldmVyc2VkX3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUg dHlwZSwKIC8vIHJldHVybiB0aGUgZXF1aXZhbGVudCByYW5nZSBmb3IgVFlQRSBpbiBSOyBpZiBG QUxTRS9UUlVFLCBkbyBub3RoaW5nLgogCiBib29sX3JhbmdlX3N0YXRlCi1nZXRfYm9vbF9zdGF0 ZSAoaXJhbmdlICZyLCBjb25zdCBpcmFuZ2UgJmxocywgdHJlZSB2YWxfdHlwZSkKK2dldF9ib29s X3N0YXRlICh2cmFuZ2UgJnIsIGNvbnN0IHZyYW5nZSAmbGhzLCB0cmVlIHZhbF90eXBlKQogewog ICAvLyBJZiB0aGVyZSBpcyBubyByZXN1bHQsIHRoZW4gdGhpcyBpcyB1bmV4ZWN1dGFibGUuCiAg IGlmIChsaHMudW5kZWZpbmVkX3AgKCkpCkBAIC00NDYsNiArNDQ2LDkgQEAgZ2V0X2Jvb2xfc3Rh dGUgKGlyYW5nZSAmciwgY29uc3QgaXJhbmdlICZsaHMsIHRyZWUgdmFsX3R5cGUpCiAKIGNsYXNz IG9wZXJhdG9yX2VxdWFsIDogcHVibGljIHJhbmdlX29wZXJhdG9yCiB7CisgIHVzaW5nIHJhbmdl X29wZXJhdG9yOjpmb2xkX3JhbmdlOworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6b3AxX3Jhbmdl OworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6b3AyX3JhbmdlOwogcHVibGljOgogICB2aXJ0dWFs IGJvb2wgZm9sZF9yYW5nZSAoaXJhbmdlICZyLCB0cmVlIHR5cGUsCiAJCQkgICBjb25zdCBpcmFu Z2UgJm9wMSwKQEAgLTU2Miw2ICs1NjUsOSBAQCBvcGVyYXRvcl9lcXVhbDo6b3AyX3JhbmdlIChp cmFuZ2UgJnIsIHRyZWUgdHlwZSwKIAogY2xhc3Mgb3BlcmF0b3Jfbm90X2VxdWFsIDogcHVibGlj IHJhbmdlX29wZXJhdG9yCiB7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpmb2xkX3JhbmdlOwor ICB1c2luZyByYW5nZV9vcGVyYXRvcjo6b3AxX3JhbmdlOworICB1c2luZyByYW5nZV9vcGVyYXRv cjo6b3AyX3JhbmdlOwogcHVibGljOgogICB2aXJ0dWFsIGJvb2wgZm9sZF9yYW5nZSAoaXJhbmdl ICZyLCB0cmVlIHR5cGUsCiAJCQkgICBjb25zdCBpcmFuZ2UgJm9wMSwKQEAgLTczOCw2ICs3NDQs OSBAQCBidWlsZF9nZSAoaXJhbmdlICZyLCB0cmVlIHR5cGUsIGNvbnN0IHdpZGVfaW50ICZ2YWwp CiAKIGNsYXNzIG9wZXJhdG9yX2x0IDogIHB1YmxpYyByYW5nZV9vcGVyYXRvcgogeworICB1c2lu ZyByYW5nZV9vcGVyYXRvcjo6Zm9sZF9yYW5nZTsKKyAgdXNpbmcgcmFuZ2Vfb3BlcmF0b3I6Om9w MV9yYW5nZTsKKyAgdXNpbmcgcmFuZ2Vfb3BlcmF0b3I6Om9wMl9yYW5nZTsKIHB1YmxpYzoKICAg dmlydHVhbCBib29sIGZvbGRfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSB0eXBlLAogCQkJICAgY29u c3QgaXJhbmdlICZvcDEsCkBAIC04NDYsNiArODU1LDkgQEAgb3BlcmF0b3JfbHQ6Om9wMl9yYW5n ZSAoaXJhbmdlICZyLCB0cmVlIHR5cGUsCiAKIGNsYXNzIG9wZXJhdG9yX2xlIDogIHB1YmxpYyBy YW5nZV9vcGVyYXRvcgogeworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6Zm9sZF9yYW5nZTsKKyAg dXNpbmcgcmFuZ2Vfb3BlcmF0b3I6Om9wMV9yYW5nZTsKKyAgdXNpbmcgcmFuZ2Vfb3BlcmF0b3I6 Om9wMl9yYW5nZTsKIHB1YmxpYzoKICAgdmlydHVhbCBib29sIGZvbGRfcmFuZ2UgKGlyYW5nZSAm ciwgdHJlZSB0eXBlLAogCQkJICAgY29uc3QgaXJhbmdlICZvcDEsCkBAIC05NTQsNiArOTY2LDkg QEAgb3BlcmF0b3JfbGU6Om9wMl9yYW5nZSAoaXJhbmdlICZyLCB0cmVlIHR5cGUsCiAKIGNsYXNz IG9wZXJhdG9yX2d0IDogIHB1YmxpYyByYW5nZV9vcGVyYXRvcgogeworICB1c2luZyByYW5nZV9v cGVyYXRvcjo6Zm9sZF9yYW5nZTsKKyAgdXNpbmcgcmFuZ2Vfb3BlcmF0b3I6Om9wMV9yYW5nZTsK KyAgdXNpbmcgcmFuZ2Vfb3BlcmF0b3I6Om9wMl9yYW5nZTsKIHB1YmxpYzoKICAgdmlydHVhbCBi b29sIGZvbGRfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSB0eXBlLAogCQkJICAgY29uc3QgaXJhbmdl ICZvcDEsCkBAIC0xMDYxLDYgKzEwNzYsOSBAQCBvcGVyYXRvcl9ndDo6b3AyX3JhbmdlIChpcmFu Z2UgJnIsIHRyZWUgdHlwZSwKIAogY2xhc3Mgb3BlcmF0b3JfZ2UgOiAgcHVibGljIHJhbmdlX29w ZXJhdG9yCiB7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpmb2xkX3JhbmdlOworICB1c2luZyBy YW5nZV9vcGVyYXRvcjo6b3AxX3JhbmdlOworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6b3AyX3Jh bmdlOwogcHVibGljOgogICB2aXJ0dWFsIGJvb2wgZm9sZF9yYW5nZSAoaXJhbmdlICZyLCB0cmVl IHR5cGUsCiAJCQkgICBjb25zdCBpcmFuZ2UgJm9wMSwKQEAgLTExNjksNiArMTE4NywxMCBAQCBv cGVyYXRvcl9nZTo6b3AyX3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgdHlwZSwKIAogY2xhc3Mgb3Bl cmF0b3JfcGx1cyA6IHB1YmxpYyByYW5nZV9vcGVyYXRvcgogeworICB1c2luZyByYW5nZV9vcGVy YXRvcjo6b3AxX3JhbmdlOworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6b3AyX3JhbmdlOworICB1 c2luZyByYW5nZV9vcGVyYXRvcjo6bGhzX29wMV9yZWxhdGlvbjsKKyAgdXNpbmcgcmFuZ2Vfb3Bl cmF0b3I6Omxoc19vcDJfcmVsYXRpb247CiBwdWJsaWM6CiAgIHZpcnR1YWwgYm9vbCBvcDFfcmFu Z2UgKGlyYW5nZSAmciwgdHJlZSB0eXBlLAogCQkJICBjb25zdCBpcmFuZ2UgJmxocywKQEAgLTEy ODYsNyArMTMwOCw3IEBAIG9wZXJhdG9yX3BsdXM6Om9wMV9yYW5nZSAoaXJhbmdlICZyLCB0cmVl IHR5cGUsCiAJCQkgIGNvbnN0IGlyYW5nZSAmb3AyLAogCQkJICByZWxhdGlvbl9raW5kIHJlbCBB VFRSSUJVVEVfVU5VU0VEKSBjb25zdAogewotICByZXR1cm4gcmFuZ2Vfb3BfaGFuZGxlciAoTUlO VVNfRVhQUiwgdHlwZSktPmZvbGRfcmFuZ2UgKHIsIHR5cGUsIGxocywgb3AyKTsKKyAgcmV0dXJu IHJhbmdlX29wX2hhbmRsZXIgKE1JTlVTX0VYUFIsIHR5cGUpLmZvbGRfcmFuZ2UgKHIsIHR5cGUs IGxocywgb3AyKTsKIH0KIAogYm9vbApAQCAtMTI5NSwxMiArMTMxNywxNSBAQCBvcGVyYXRvcl9w bHVzOjpvcDJfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSB0eXBlLAogCQkJICBjb25zdCBpcmFuZ2Ug Jm9wMSwKIAkJCSAgcmVsYXRpb25fa2luZCByZWwgQVRUUklCVVRFX1VOVVNFRCkgY29uc3QKIHsK LSAgcmV0dXJuIHJhbmdlX29wX2hhbmRsZXIgKE1JTlVTX0VYUFIsIHR5cGUpLT5mb2xkX3Jhbmdl IChyLCB0eXBlLCBsaHMsIG9wMSk7CisgIHJldHVybiByYW5nZV9vcF9oYW5kbGVyIChNSU5VU19F WFBSLCB0eXBlKS5mb2xkX3JhbmdlIChyLCB0eXBlLCBsaHMsIG9wMSk7CiB9CiAKIAogY2xhc3Mg b3BlcmF0b3JfbWludXMgOiBwdWJsaWMgcmFuZ2Vfb3BlcmF0b3IKIHsKKyAgdXNpbmcgcmFuZ2Vf b3BlcmF0b3I6OmZvbGRfcmFuZ2U7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpvcDFfcmFuZ2U7 CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpvcDJfcmFuZ2U7CiBwdWJsaWM6CiAgIHZpcnR1YWwg Ym9vbCBvcDFfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSB0eXBlLAogCQkJICBjb25zdCBpcmFuZ2Ug JmxocywKQEAgLTE0NDUsNyArMTQ3MCw3IEBAIG9wZXJhdG9yX21pbnVzOjpvcDFfcmFuZ2UgKGly YW5nZSAmciwgdHJlZSB0eXBlLAogCQkJICAgY29uc3QgaXJhbmdlICZvcDIsCiAJCQkgICByZWxh dGlvbl9raW5kIHJlbCBBVFRSSUJVVEVfVU5VU0VEKSBjb25zdAogewotICByZXR1cm4gcmFuZ2Vf b3BfaGFuZGxlciAoUExVU19FWFBSLCB0eXBlKS0+Zm9sZF9yYW5nZSAociwgdHlwZSwgbGhzLCBv cDIpOworICByZXR1cm4gcmFuZ2Vfb3BfaGFuZGxlciAoUExVU19FWFBSLCB0eXBlKS5mb2xkX3Jh bmdlIChyLCB0eXBlLCBsaHMsIG9wMik7CiB9CiAKIGJvb2wKQEAgLTE1OTcsNiArMTYyMiw4IEBA IGNyb3NzX3Byb2R1Y3Rfb3BlcmF0b3I6OndpX2Nyb3NzX3Byb2R1Y3QgKGlyYW5nZSAmciwgdHJl ZSB0eXBlLAogCiBjbGFzcyBvcGVyYXRvcl9tdWx0IDogcHVibGljIGNyb3NzX3Byb2R1Y3Rfb3Bl cmF0b3IKIHsKKyAgdXNpbmcgcmFuZ2Vfb3BlcmF0b3I6Om9wMV9yYW5nZTsKKyAgdXNpbmcgcmFu Z2Vfb3BlcmF0b3I6Om9wMl9yYW5nZTsKIHB1YmxpYzoKICAgdmlydHVhbCB2b2lkIHdpX2ZvbGQg KGlyYW5nZSAmciwgdHJlZSB0eXBlLAogCQkgICAgICAgIGNvbnN0IHdpZGVfaW50ICZsaF9sYiwK QEAgLTE2MjksOCArMTY1Niw4IEBAIG9wZXJhdG9yX211bHQ6Om9wMV9yYW5nZSAoaXJhbmdlICZy LCB0cmVlIHR5cGUsCiAgICAgcmV0dXJuIGZhbHNlOwogCiAgIGlmIChvcDIuc2luZ2xldG9uX3Ag KCZvZmZzZXQpICYmICFpbnRlZ2VyX3plcm9wIChvZmZzZXQpKQotICAgIHJldHVybiByYW5nZV9v cF9oYW5kbGVyIChUUlVOQ19ESVZfRVhQUiwgdHlwZSktPmZvbGRfcmFuZ2UgKHIsIHR5cGUsCi0J CQkJCQkJCWxocywgb3AyKTsKKyAgICByZXR1cm4gcmFuZ2Vfb3BfaGFuZGxlciAoVFJVTkNfRElW X0VYUFIsIHR5cGUpLmZvbGRfcmFuZ2UgKHIsIHR5cGUsCisJCQkJCQkJICAgICAgIGxocywgb3Ay KTsKICAgcmV0dXJuIGZhbHNlOwogfQogCkBAIC0xODU3LDYgKzE4ODQsNyBAQCBvcGVyYXRvcl9k aXYgb3BfY2VpbF9kaXYgKENFSUxfRElWX0VYUFIpOwogCiBjbGFzcyBvcGVyYXRvcl9leGFjdF9k aXZpZGUgOiBwdWJsaWMgb3BlcmF0b3JfZGl2CiB7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpv cDFfcmFuZ2U7CiBwdWJsaWM6CiAgIG9wZXJhdG9yX2V4YWN0X2RpdmlkZSAoKSA6IG9wZXJhdG9y X2RpdiAoVFJVTkNfRElWX0VYUFIpIHsgfQogICB2aXJ0dWFsIGJvb2wgb3AxX3JhbmdlIChpcmFu Z2UgJnIsIHRyZWUgdHlwZSwKQEAgLTE4ODEsMTMgKzE5MDksMTUgQEAgb3BlcmF0b3JfZXhhY3Rf ZGl2aWRlOjpvcDFfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSB0eXBlLAogICAvLyBJZiBvcDIgaXMg YSBtdWx0aXBsZSBvZiAyLCB3ZSB3b3VsZCBiZSBhYmxlIHRvIHNldCBzb21lIG5vbi16ZXJvIGJp dHMuCiAgIGlmIChvcDIuc2luZ2xldG9uX3AgKCZvZmZzZXQpCiAgICAgICAmJiAhaW50ZWdlcl96 ZXJvcCAob2Zmc2V0KSkKLSAgICByZXR1cm4gcmFuZ2Vfb3BfaGFuZGxlciAoTVVMVF9FWFBSLCB0 eXBlKS0+Zm9sZF9yYW5nZSAociwgdHlwZSwgbGhzLCBvcDIpOworICAgIHJldHVybiByYW5nZV9v cF9oYW5kbGVyIChNVUxUX0VYUFIsIHR5cGUpLmZvbGRfcmFuZ2UgKHIsIHR5cGUsIGxocywgb3Ay KTsKICAgcmV0dXJuIGZhbHNlOwogfQogCiAKIGNsYXNzIG9wZXJhdG9yX2xzaGlmdCA6IHB1Ymxp YyBjcm9zc19wcm9kdWN0X29wZXJhdG9yCiB7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpmb2xk X3JhbmdlOworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6b3AxX3JhbmdlOwogcHVibGljOgogICB2 aXJ0dWFsIGJvb2wgb3AxX3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgdHlwZSwKIAkJCSAgY29uc3Qg aXJhbmdlICZsaHMsCkBAIC0xOTA5LDYgKzE5MzksOSBAQCBwdWJsaWM6CiAKIGNsYXNzIG9wZXJh dG9yX3JzaGlmdCA6IHB1YmxpYyBjcm9zc19wcm9kdWN0X29wZXJhdG9yCiB7CisgIHVzaW5nIHJh bmdlX29wZXJhdG9yOjpmb2xkX3JhbmdlOworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6b3AxX3Jh bmdlOworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6bGhzX29wMV9yZWxhdGlvbjsKIHB1YmxpYzoK ICAgdmlydHVhbCBib29sIGZvbGRfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSB0eXBlLAogCQkJICAg Y29uc3QgaXJhbmdlICZvcDEsCkBAIC0yMjQ4LDYgKzIyODEsOCBAQCBvcGVyYXRvcl9yc2hpZnQ6 OndpX2ZvbGQgKGlyYW5nZSAmciwgdHJlZSB0eXBlLAogCiBjbGFzcyBvcGVyYXRvcl9jYXN0OiBw dWJsaWMgcmFuZ2Vfb3BlcmF0b3IKIHsKKyAgdXNpbmcgcmFuZ2Vfb3BlcmF0b3I6OmZvbGRfcmFu Z2U7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpvcDFfcmFuZ2U7CiBwdWJsaWM6CiAgIHZpcnR1 YWwgYm9vbCBmb2xkX3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgdHlwZSwKIAkJCSAgIGNvbnN0IGly YW5nZSAmb3AxLApAQCAtMjQxNywxMCArMjQ1Miw5IEBAIG9wZXJhdG9yX2Nhc3Q6Om9wMV9yYW5n ZSAoaXJhbmdlICZyLCB0cmVlIHR5cGUsCiAJICAvLyBBZGQgdGhpcyB0byB0aGUgdW5zaWduZWQg TEhTIHJhbmdlKHMpLgogCSAgaW50X3JhbmdlX21heCBsaW1fcmFuZ2UgKHR5cGUsIGxpbSwgbGlt KTsKIAkgIGludF9yYW5nZV9tYXggbGhzX25lZzsKLQkgIHJhbmdlX29wX2hhbmRsZXIgKFBMVVNf RVhQUiwgdHlwZSktPmZvbGRfcmFuZ2UgKGxoc19uZWcsCi0JCQkJCQkJICB0eXBlLAotCQkJCQkJ CSAgY29udmVydGVkX2xocywKLQkJCQkJCQkgIGxpbV9yYW5nZSk7CisJICByYW5nZV9vcF9oYW5k bGVyIChQTFVTX0VYUFIsIHR5cGUpLmZvbGRfcmFuZ2UgKGxoc19uZWcsIHR5cGUsCisJCQkJCQkJ IGNvbnZlcnRlZF9saHMsCisJCQkJCQkJIGxpbV9yYW5nZSk7CiAJICAvLyBsaHNfbmVnIG5vdyBo YXMgYWxsIHRoZSBuZWdhdGl2ZSB2ZXJzaW9ucyBvZiB0aGUgTEhTLgogCSAgLy8gTm93IHVuaW9u IGluIGFsbCB0aGUgdmFsdWVzIGZyb20gU0lHTkVEIE1JTiAoMHg4MDAwMCkgdG8KIAkgIC8vIGxp bS0xIGluIG9yZGVyIHRvIGZpbGwgaW4gYWxsIHRoZSByYW5nZXMgd2l0aCB0aGUgdXBwZXIKQEAg LTI0NjksNiArMjUwMyw5IEBAIG9wZXJhdG9yX2Nhc3Q6Om9wMV9yYW5nZSAoaXJhbmdlICZyLCB0 cmVlIHR5cGUsCiAKIGNsYXNzIG9wZXJhdG9yX2xvZ2ljYWxfYW5kIDogcHVibGljIHJhbmdlX29w ZXJhdG9yCiB7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpmb2xkX3JhbmdlOworICB1c2luZyBy YW5nZV9vcGVyYXRvcjo6b3AxX3JhbmdlOworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6b3AyX3Jh bmdlOwogcHVibGljOgogICB2aXJ0dWFsIGJvb2wgZm9sZF9yYW5nZSAoaXJhbmdlICZyLCB0cmVl IHR5cGUsCiAJCQkgICBjb25zdCBpcmFuZ2UgJmxoLApAQCAtMjU0Miw2ICsyNTc5LDkgQEAgb3Bl cmF0b3JfbG9naWNhbF9hbmQ6Om9wMl9yYW5nZSAoaXJhbmdlICZyLCB0cmVlIHR5cGUsCiAKIGNs YXNzIG9wZXJhdG9yX2JpdHdpc2VfYW5kIDogcHVibGljIHJhbmdlX29wZXJhdG9yCiB7CisgIHVz aW5nIHJhbmdlX29wZXJhdG9yOjpmb2xkX3JhbmdlOworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6 b3AxX3JhbmdlOworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6b3AyX3JhbmdlOwogcHVibGljOgog ICB2aXJ0dWFsIGJvb2wgZm9sZF9yYW5nZSAoaXJhbmdlICZyLCB0cmVlIHR5cGUsCiAJCQkgICBj b25zdCBpcmFuZ2UgJmxoLApAQCAtMjk4OCw2ICszMDI4LDkgQEAgb3BlcmF0b3JfYml0d2lzZV9h bmQ6Om9wMl9yYW5nZSAoaXJhbmdlICZyLCB0cmVlIHR5cGUsCiAKIGNsYXNzIG9wZXJhdG9yX2xv Z2ljYWxfb3IgOiBwdWJsaWMgcmFuZ2Vfb3BlcmF0b3IKIHsKKyAgdXNpbmcgcmFuZ2Vfb3BlcmF0 b3I6OmZvbGRfcmFuZ2U7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpvcDFfcmFuZ2U7CisgIHVz aW5nIHJhbmdlX29wZXJhdG9yOjpvcDJfcmFuZ2U7CiBwdWJsaWM6CiAgIHZpcnR1YWwgYm9vbCBm b2xkX3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgdHlwZSwKIAkJCSAgIGNvbnN0IGlyYW5nZSAmbGgs CkBAIC0zMDUxLDYgKzMwOTQsOCBAQCBvcGVyYXRvcl9sb2dpY2FsX29yOjpvcDJfcmFuZ2UgKGly YW5nZSAmciwgdHJlZSB0eXBlLAogCiBjbGFzcyBvcGVyYXRvcl9iaXR3aXNlX29yIDogcHVibGlj IHJhbmdlX29wZXJhdG9yCiB7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpvcDFfcmFuZ2U7Cisg IHVzaW5nIHJhbmdlX29wZXJhdG9yOjpvcDJfcmFuZ2U7CiBwdWJsaWM6CiAgIHZpcnR1YWwgYm9v bCBvcDFfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSB0eXBlLAogCQkJICBjb25zdCBpcmFuZ2UgJmxo cywKQEAgLTMxNTUsNiArMzIwMCw4IEBAIG9wZXJhdG9yX2JpdHdpc2Vfb3I6Om9wMl9yYW5nZSAo aXJhbmdlICZyLCB0cmVlIHR5cGUsCiAKIGNsYXNzIG9wZXJhdG9yX2JpdHdpc2VfeG9yIDogcHVi bGljIHJhbmdlX29wZXJhdG9yCiB7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpvcDFfcmFuZ2U7 CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpvcDJfcmFuZ2U7CiBwdWJsaWM6CiAgIHZpcnR1YWwg dm9pZCB3aV9mb2xkIChpcmFuZ2UgJnIsIHRyZWUgdHlwZSwKIAkJICAgICAgICBjb25zdCB3aWRl X2ludCAmbGhfbGIsCkBAIC0zMjk2LDYgKzMzNDMsOCBAQCBvcGVyYXRvcl9iaXR3aXNlX3hvcjo6 b3AyX3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgdHlwZSwKIAogY2xhc3Mgb3BlcmF0b3JfdHJ1bmNf bW9kIDogcHVibGljIHJhbmdlX29wZXJhdG9yCiB7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpv cDFfcmFuZ2U7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpvcDJfcmFuZ2U7CiBwdWJsaWM6CiAg IHZpcnR1YWwgdm9pZCB3aV9mb2xkIChpcmFuZ2UgJnIsIHRyZWUgdHlwZSwKIAkJICAgICAgICBj b25zdCB3aWRlX2ludCAmbGhfbGIsCkBAIC0zNDMyLDYgKzM0ODEsOCBAQCBvcGVyYXRvcl90cnVu Y19tb2Q6Om9wMl9yYW5nZSAoaXJhbmdlICZyLCB0cmVlIHR5cGUsCiAKIGNsYXNzIG9wZXJhdG9y X2xvZ2ljYWxfbm90IDogcHVibGljIHJhbmdlX29wZXJhdG9yCiB7CisgIHVzaW5nIHJhbmdlX29w ZXJhdG9yOjpmb2xkX3JhbmdlOworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6b3AxX3JhbmdlOwog cHVibGljOgogICB2aXJ0dWFsIGJvb2wgZm9sZF9yYW5nZSAoaXJhbmdlICZyLCB0cmVlIHR5cGUs CiAJCQkgICBjb25zdCBpcmFuZ2UgJmxoLApAQCAtMzQ4Nyw2ICszNTM4LDggQEAgb3BlcmF0b3Jf bG9naWNhbF9ub3Q6Om9wMV9yYW5nZSAoaXJhbmdlICZyLAogCiBjbGFzcyBvcGVyYXRvcl9iaXR3 aXNlX25vdCA6IHB1YmxpYyByYW5nZV9vcGVyYXRvcgogeworICB1c2luZyByYW5nZV9vcGVyYXRv cjo6Zm9sZF9yYW5nZTsKKyAgdXNpbmcgcmFuZ2Vfb3BlcmF0b3I6Om9wMV9yYW5nZTsKIHB1Ymxp YzoKICAgdmlydHVhbCBib29sIGZvbGRfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSB0eXBlLAogCQkJ ICAgY29uc3QgaXJhbmdlICZsaCwKQEAgLTM1MTMsOCArMzU2Niw3IEBAIG9wZXJhdG9yX2JpdHdp c2Vfbm90Ojpmb2xkX3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgdHlwZSwKICAgLy8gflggaXMgc2lt cGx5IC0xIC0gWC4KICAgaW50X3JhbmdlPDE+IG1pbnVzb25lICh0eXBlLCB3aTo6bWludXNfb25l IChUWVBFX1BSRUNJU0lPTiAodHlwZSkpLAogCQkJIHdpOjptaW51c19vbmUgKFRZUEVfUFJFQ0lT SU9OICh0eXBlKSkpOwotICByZXR1cm4gcmFuZ2Vfb3BfaGFuZGxlciAoTUlOVVNfRVhQUiwgdHlw ZSktPmZvbGRfcmFuZ2UgKHIsIHR5cGUsIG1pbnVzb25lLAotCQkJCQkJCSAgbGgpOworICByZXR1 cm4gcmFuZ2Vfb3BfaGFuZGxlciAoTUlOVVNfRVhQUiwgdHlwZSkuZm9sZF9yYW5nZSAociwgdHlw ZSwgbWludXNvbmUsIGxoKTsKIH0KIAogYm9vbApAQCAtMzUzMyw2ICszNTg1LDcgQEAgb3BlcmF0 b3JfYml0d2lzZV9ub3Q6Om9wMV9yYW5nZSAoaXJhbmdlICZyLCB0cmVlIHR5cGUsCiAKIGNsYXNz IG9wZXJhdG9yX2NzdCA6IHB1YmxpYyByYW5nZV9vcGVyYXRvcgogeworICB1c2luZyByYW5nZV9v cGVyYXRvcjo6Zm9sZF9yYW5nZTsKIHB1YmxpYzoKICAgdmlydHVhbCBib29sIGZvbGRfcmFuZ2Ug KGlyYW5nZSAmciwgdHJlZSB0eXBlLAogCQkJICAgY29uc3QgaXJhbmdlICZvcDEsCkBAIC0zNTUz LDYgKzM2MDYsOSBAQCBvcGVyYXRvcl9jc3Q6OmZvbGRfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSB0 eXBlIEFUVFJJQlVURV9VTlVTRUQsCiAKIGNsYXNzIG9wZXJhdG9yX2lkZW50aXR5IDogcHVibGlj IHJhbmdlX29wZXJhdG9yCiB7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpmb2xkX3JhbmdlOwor ICB1c2luZyByYW5nZV9vcGVyYXRvcjo6b3AxX3JhbmdlOworICB1c2luZyByYW5nZV9vcGVyYXRv cjo6bGhzX29wMV9yZWxhdGlvbjsKIHB1YmxpYzoKICAgdmlydHVhbCBib29sIGZvbGRfcmFuZ2Ug KGlyYW5nZSAmciwgdHJlZSB0eXBlLAogCQkJICAgY29uc3QgaXJhbmdlICZvcDEsCkBAIC0zNjA1 LDYgKzM2NjEsNyBAQCBvcGVyYXRvcl9pZGVudGl0eTo6b3AxX3JhbmdlIChpcmFuZ2UgJnIsIHRy ZWUgdHlwZSBBVFRSSUJVVEVfVU5VU0VELAogCiBjbGFzcyBvcGVyYXRvcl91bmtub3duIDogcHVi bGljIHJhbmdlX29wZXJhdG9yCiB7CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpmb2xkX3Jhbmdl OwogcHVibGljOgogICB2aXJ0dWFsIGJvb2wgZm9sZF9yYW5nZSAoaXJhbmdlICZyLCB0cmVlIHR5 cGUsCiAJCQkgICBjb25zdCBpcmFuZ2UgJm9wMSwKQEAgLTM2MjUsNiArMzY4Miw3IEBAIG9wZXJh dG9yX3Vua25vd246OmZvbGRfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSB0eXBlLAogCiBjbGFzcyBv cGVyYXRvcl9hYnMgOiBwdWJsaWMgcmFuZ2Vfb3BlcmF0b3IKIHsKKyAgdXNpbmcgcmFuZ2Vfb3Bl cmF0b3I6Om9wMV9yYW5nZTsKICBwdWJsaWM6CiAgIHZpcnR1YWwgdm9pZCB3aV9mb2xkIChpcmFu Z2UgJnIsIHRyZWUgdHlwZSwKIAkJICAgICAgICBjb25zdCB3aWRlX2ludCAmbGhfbGIsCkBAIC0z NzkwLDYgKzM4NDgsOCBAQCBvcGVyYXRvcl9hYnN1Ojp3aV9mb2xkIChpcmFuZ2UgJnIsIHRyZWUg dHlwZSwKIAogY2xhc3Mgb3BlcmF0b3JfbmVnYXRlIDogcHVibGljIHJhbmdlX29wZXJhdG9yCiB7 CisgIHVzaW5nIHJhbmdlX29wZXJhdG9yOjpmb2xkX3JhbmdlOworICB1c2luZyByYW5nZV9vcGVy YXRvcjo6b3AxX3JhbmdlOwogIHB1YmxpYzoKICAgdmlydHVhbCBib29sIGZvbGRfcmFuZ2UgKGly YW5nZSAmciwgdHJlZSB0eXBlLAogCQkJICAgY29uc3QgaXJhbmdlICZvcDEsCkBAIC0zODEwLDkg KzM4NzAsOCBAQCBvcGVyYXRvcl9uZWdhdGU6OmZvbGRfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSB0 eXBlLAogICBpZiAoZW1wdHlfcmFuZ2VfdmFyeWluZyAociwgdHlwZSwgbGgsIHJoKSkKICAgICBy ZXR1cm4gdHJ1ZTsKICAgLy8gLVggaXMgc2ltcGx5IDAgLSBYLgotICByZXR1cm4gcmFuZ2Vfb3Bf aGFuZGxlciAoTUlOVVNfRVhQUiwgdHlwZSktPmZvbGRfcmFuZ2UgKHIsIHR5cGUsCi0JCQkJCQkJ ICByYW5nZV96ZXJvICh0eXBlKSwKLQkJCQkJCQkgIGxoKTsKKyAgcmV0dXJuIHJhbmdlX29wX2hh bmRsZXIgKE1JTlVTX0VYUFIsIHR5cGUpLmZvbGRfcmFuZ2UgKHIsIHR5cGUsCisJCQkJCQkJIHJh bmdlX3plcm8gKHR5cGUpLCBsaCk7CiB9CiAKIGJvb2wKQEAgLTM4MjgsNiArMzg4Nyw4IEBAIG9w ZXJhdG9yX25lZ2F0ZTo6b3AxX3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgdHlwZSwKIAogY2xhc3Mg b3BlcmF0b3JfYWRkcl9leHByIDogcHVibGljIHJhbmdlX29wZXJhdG9yCiB7CisgIHVzaW5nIHJh bmdlX29wZXJhdG9yOjpmb2xkX3JhbmdlOworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6b3AxX3Jh bmdlOwogcHVibGljOgogICB2aXJ0dWFsIGJvb2wgZm9sZF9yYW5nZSAoaXJhbmdlICZyLCB0cmVl IHR5cGUsCiAJCQkgICBjb25zdCBpcmFuZ2UgJm9wMSwKQEAgLTM5NzgsNiArNDAzOSw4IEBAIHBv aW50ZXJfYW5kX29wZXJhdG9yOjp3aV9mb2xkIChpcmFuZ2UgJnIsIHRyZWUgdHlwZSwKIAogY2xh c3MgcG9pbnRlcl9vcl9vcGVyYXRvciA6IHB1YmxpYyByYW5nZV9vcGVyYXRvcgogeworICB1c2lu ZyByYW5nZV9vcGVyYXRvcjo6b3AxX3JhbmdlOworICB1c2luZyByYW5nZV9vcGVyYXRvcjo6b3Ay X3JhbmdlOwogcHVibGljOgogICB2aXJ0dWFsIGJvb2wgb3AxX3JhbmdlIChpcmFuZ2UgJnIsIHRy ZWUgdHlwZSwKIAkJCSAgY29uc3QgaXJhbmdlICZsaHMsCkBAIC00MTM5LDggKzQyMDIsOCBAQCBw b2ludGVyX3RhYmxlOjpwb2ludGVyX3RhYmxlICgpCiAKIC8vIFRoZSB0YWJsZXMgYXJlIGhpZGRl biBhbmQgYWNjZXNzZWQgdmlhIGEgc2ltcGxlIGV4dGVybiBmdW5jdGlvbi4KIAotcmFuZ2Vfb3Bl cmF0b3IgKgotcmFuZ2Vfb3BfaGFuZGxlciAoZW51bSB0cmVlX2NvZGUgY29kZSwgdHJlZSB0eXBl KQorc3RhdGljIGlubGluZSByYW5nZV9vcGVyYXRvciAqCitnZXRfaGFuZGxlciAoZW51bSB0cmVl X2NvZGUgY29kZSwgdHJlZSB0eXBlKQogewogICAvLyBGaXJzdCBjaGVjayBpZiB0aGVyZSBpcyBh IHBvaW50ZXIgc3BlY2lhbGl6YXRpb24uCiAgIGlmIChQT0lOVEVSX1RZUEVfUCAodHlwZSkpCkBA IC00MTUwLDE2ICs0MjEzLDEyMCBAQCByYW5nZV9vcF9oYW5kbGVyIChlbnVtIHRyZWVfY29kZSBj b2RlLCB0cmVlIHR5cGUpCiAgIHJldHVybiBOVUxMOwogfQogCityYW5nZV9vcF9oYW5kbGVyOjpy YW5nZV9vcF9oYW5kbGVyICh0cmVlX2NvZGUgY29kZSwgdHJlZSB0eXBlKQoreworICBtX29wID0g Z2V0X2hhbmRsZXIgKGNvZGUsIHR5cGUpOworfQorCityYW5nZV9vcF9oYW5kbGVyOjpyYW5nZV9v cF9oYW5kbGVyIChjb25zdCBnaW1wbGUgKnMpCit7CisgIGlmIChjb25zdCBnYXNzaWduICphc3Mg PSBkeW5fY2FzdDxjb25zdCBnYXNzaWduICo+IChzKSkKKyAgICB7CisgICAgICBlbnVtIHRyZWVf Y29kZSBjb2RlID0gZ2ltcGxlX2Fzc2lnbl9yaHNfY29kZSAoYXNzKTsKKyAgICAgIC8vIFRoZSBM SFMgb2YgYSBjb21wYXJpc29uIGlzIGFsd2F5cyBhbiBpbnQsIHNvIHdlIG11c3QgbG9vayBhdAor ICAgICAgLy8gdGhlIG9wZXJhbmRzLgorICAgICAgaWYgKFRSRUVfQ09ERV9DTEFTUyAoY29kZSkg PT0gdGNjX2NvbXBhcmlzb24pCisJbV9vcCA9IGdldF9oYW5kbGVyIChjb2RlLCBUUkVFX1RZUEUg KGdpbXBsZV9hc3NpZ25fcmhzMSAoYXNzKSkpOworICAgICAgZWxzZQorCW1fb3AgPSBnZXRfaGFu ZGxlciAoY29kZSwgVFJFRV9UWVBFIChnaW1wbGVfYXNzaWduX2xocyAoYXNzKSkpOworICAgIH0K KyAgZWxzZSBpZiAoY29uc3QgZ2NvbmQgKmNvbmQgPSBkeW5fY2FzdDxjb25zdCBnY29uZCAqPiAo cykpCisgICAgbV9vcCA9IGdldF9oYW5kbGVyIChnaW1wbGVfY29uZF9jb2RlIChjb25kKSwKKwkJ CVRSRUVfVFlQRSAoZ2ltcGxlX2NvbmRfbGhzIChjb25kKSkpOworICBlbHNlCisgICAgbV9vcCA9 IE5VTEw7Cit9CisKK2Jvb2wKK3JhbmdlX29wX2hhbmRsZXI6OmZvbGRfcmFuZ2UgKHZyYW5nZSAm ciwgdHJlZSB0eXBlLAorCQkJICAgICAgY29uc3QgdnJhbmdlICZsaCwKKwkJCSAgICAgIGNvbnN0 IHZyYW5nZSAmcmgsCisJCQkgICAgICByZWxhdGlvbl9raW5kIHJlbCkgY29uc3QKK3sKKyAgaWYg KGlzX2EgPGlyYW5nZT4gKGxoKSkKKyAgICByZXR1cm4gbV9vcC0+Zm9sZF9yYW5nZSAoYXNfYSA8 aXJhbmdlPiAociksIHR5cGUsCisJCQkgICAgIGFzX2EgPGlyYW5nZT4gKGxoKSwKKwkJCSAgICAg YXNfYSA8aXJhbmdlPiAocmgpLCByZWwpOworICBnY2NfdW5yZWFjaGFibGUgKCk7CisgIHJldHVy biBmYWxzZTsKK30KKworYm9vbAorcmFuZ2Vfb3BfaGFuZGxlcjo6b3AxX3JhbmdlICh2cmFuZ2Ug JnIsIHRyZWUgdHlwZSwKKwkJCSAgICAgY29uc3QgdnJhbmdlICZsaHMsCisJCQkgICAgIGNvbnN0 IHZyYW5nZSAmb3AyLAorCQkJICAgICByZWxhdGlvbl9raW5kIHJlbCkgY29uc3QKK3sKKyAgaWYg KGlzX2EgPGlyYW5nZT4gKHIpKQorICAgIHJldHVybiBtX29wLT5vcDFfcmFuZ2UgKGFzX2EgPGly YW5nZT4gKHIpLCB0eXBlLAorCQkJICAgIGFzX2EgPGlyYW5nZT4gKGxocyksCisJCQkgICAgYXNf YSA8aXJhbmdlPiAob3AyKSwgcmVsKTsKKyAgZ2NjX3VucmVhY2hhYmxlICgpOworICByZXR1cm4g ZmFsc2U7Cit9CisKK2Jvb2wKK3JhbmdlX29wX2hhbmRsZXI6Om9wMl9yYW5nZSAodnJhbmdlICZy LCB0cmVlIHR5cGUsCisJCQkgICAgIGNvbnN0IHZyYW5nZSAmbGhzLAorCQkJICAgICBjb25zdCB2 cmFuZ2UgJm9wMSwKKwkJCSAgICAgcmVsYXRpb25fa2luZCByZWwpIGNvbnN0Cit7CisgIGlmIChp c19hIDxpcmFuZ2U+IChyKSkKKyAgICByZXR1cm4gbV9vcC0+b3AyX3JhbmdlIChhc19hIDxpcmFu Z2U+IChyKSwgdHlwZSwKKwkJCSAgICBhc19hIDxpcmFuZ2U+IChsaHMpLAorCQkJICAgIGFzX2Eg PGlyYW5nZT4gKG9wMSksIHJlbCk7CisgIGdjY191bnJlYWNoYWJsZSAoKTsKKyAgcmV0dXJuIGZh bHNlOworfQorCityZWxhdGlvbl9raW5kCityYW5nZV9vcF9oYW5kbGVyOjpsaHNfb3AxX3JlbGF0 aW9uIChjb25zdCB2cmFuZ2UgJmxocywKKwkJCQkgICAgY29uc3QgdnJhbmdlICZvcDEsCisJCQkJ ICAgIGNvbnN0IHZyYW5nZSAmb3AyLAorCQkJCSAgICByZWxhdGlvbl9raW5kIHJlbCkgY29uc3QK K3sKKyAgaWYgKGlzX2EgPGlyYW5nZT4gKG9wMSkpCisgICAgcmV0dXJuIG1fb3AtPmxoc19vcDFf cmVsYXRpb24gKGFzX2EgPGlyYW5nZT4gKGxocyksCisJCQkJICAgYXNfYSA8aXJhbmdlPiAob3Ax KSwgYXNfYSA8aXJhbmdlPiAob3AyKSwgcmVsKTsKKyAgZ2NjX3VucmVhY2hhYmxlICgpOworICBy ZXR1cm4gVlJFTF9WQVJZSU5HOworfQorCityZWxhdGlvbl9raW5kCityYW5nZV9vcF9oYW5kbGVy OjpsaHNfb3AyX3JlbGF0aW9uIChjb25zdCB2cmFuZ2UgJmxocywKKwkJCQkgICAgY29uc3QgdnJh bmdlICZvcDEsCisJCQkJICAgIGNvbnN0IHZyYW5nZSAmb3AyLAorCQkJCSAgICByZWxhdGlvbl9r aW5kIHJlbCkgY29uc3QKK3sKKyAgaWYgKGlzX2EgPGlyYW5nZT4gKG9wMSkpCisgICAgcmV0dXJu IG1fb3AtPmxoc19vcDJfcmVsYXRpb24gKGFzX2EgPGlyYW5nZT4gKGxocyksCisJCQkJICAgYXNf YSA8aXJhbmdlPiAob3AxKSwgYXNfYSA8aXJhbmdlPiAob3AyKSwgcmVsKTsKKyAgZ2NjX3VucmVh Y2hhYmxlICgpOworICByZXR1cm4gVlJFTF9WQVJZSU5HOworfQorCityZWxhdGlvbl9raW5kCity YW5nZV9vcF9oYW5kbGVyOjpvcDFfb3AyX3JlbGF0aW9uIChjb25zdCB2cmFuZ2UgJmxocykgY29u c3QKK3sKKyAgcmV0dXJuIG1fb3AtPm9wMV9vcDJfcmVsYXRpb24gKGFzX2EgPGlyYW5nZT4gKGxo cykpOworfQorCiAvLyBDYXN0IHRoZSByYW5nZSBpbiBSIHRvIFRZUEUuCiAKLXZvaWQKLXJhbmdl X2Nhc3QgKGlyYW5nZSAmciwgdHJlZSB0eXBlKQorYm9vbAorcmFuZ2VfY2FzdCAodnJhbmdlICZy LCB0cmVlIHR5cGUpCiB7Ci0gIGludF9yYW5nZV9tYXggdG1wID0gcjsKLSAgcmFuZ2Vfb3BlcmF0 b3IgKm9wID0gcmFuZ2Vfb3BfaGFuZGxlciAoQ09OVkVSVF9FWFBSLCB0eXBlKTsKKyAgVmFsdWVf UmFuZ2UgdG1wIChyKTsKKyAgVmFsdWVfUmFuZ2UgdmFyeWluZyAodHlwZSk7CisgIHZhcnlpbmcu c2V0X3ZhcnlpbmcgKHR5cGUpOworICByYW5nZV9vcF9oYW5kbGVyIG9wIChDT05WRVJUX0VYUFIs IHR5cGUpOwogICAvLyBDYWxsIG9wX2NvbnZlcnQsIGlmIGl0IGZhaWxzLCB0aGUgcmVzdWx0IGlz IHZhcnlpbmcuCi0gIGlmICghb3AtPmZvbGRfcmFuZ2UgKHIsIHR5cGUsIHRtcCwgaW50X3Jhbmdl PDE+ICh0eXBlKSkpCi0gICAgci5zZXRfdmFyeWluZyAodHlwZSk7CisgIGlmICghb3AgfHwgIW9w LmZvbGRfcmFuZ2UgKHIsIHR5cGUsIHRtcCwgdmFyeWluZykpCisgICAgeworICAgICAgci5zZXRf dmFyeWluZyAodHlwZSk7CisgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorICByZXR1cm4gdHJ1 ZTsKIH0KIAogI2lmIENIRUNLSU5HX1AKZGlmZiAtLWdpdCBhL2djYy9yYW5nZS1vcC5oIGIvZ2Nj L3JhbmdlLW9wLmgKaW5kZXggMzAwOTc0ZmJiNzguLjI2MmM3OTYxODBkIDEwMDY0NAotLS0gYS9n Y2MvcmFuZ2Utb3AuaAorKysgYi9nY2MvcmFuZ2Utb3AuaApAQCAtMTA4LDggKzEwOCwzOSBAQCBw cm90ZWN0ZWQ6CiAJCQkgY29uc3Qgd2lkZV9pbnQgJnJoX3ViKSBjb25zdDsKIH07CiAKLWV4dGVy biByYW5nZV9vcGVyYXRvciAqcmFuZ2Vfb3BfaGFuZGxlciAoZW51bSB0cmVlX2NvZGUgY29kZSwg dHJlZSB0eXBlKTsKLWV4dGVybiB2b2lkIHJhbmdlX2Nhc3QgKGlyYW5nZSAmLCB0cmVlIHR5cGUp OworY2xhc3MgcmFuZ2Vfb3BfaGFuZGxlcgoreworcHVibGljOgorICByYW5nZV9vcF9oYW5kbGVy IChlbnVtIHRyZWVfY29kZSBjb2RlLCB0cmVlIHR5cGUpOworICByYW5nZV9vcF9oYW5kbGVyIChj b25zdCBnaW1wbGUgKnMpOworICBvcGVyYXRvciBib29sICgpIGNvbnN0IHsgcmV0dXJuIG1fb3A7 IH0KKworICBib29sIGZvbGRfcmFuZ2UgKHZyYW5nZSAmciwgdHJlZSB0eXBlLAorCQkgICBjb25z dCB2cmFuZ2UgJmxoLAorCQkgICBjb25zdCB2cmFuZ2UgJnJoLAorCQkgICByZWxhdGlvbl9raW5k IHJlbCA9IFZSRUxfVkFSWUlORykgY29uc3Q7CisgIGJvb2wgb3AxX3JhbmdlICh2cmFuZ2UgJnIs IHRyZWUgdHlwZSwKKwkJICBjb25zdCB2cmFuZ2UgJmxocywKKwkJICBjb25zdCB2cmFuZ2UgJm9w MiwKKwkJICByZWxhdGlvbl9raW5kIHJlbCA9IFZSRUxfVkFSWUlORykgY29uc3Q7CisgIGJvb2wg b3AyX3JhbmdlICh2cmFuZ2UgJnIsIHRyZWUgdHlwZSwKKwkJICBjb25zdCB2cmFuZ2UgJmxocywK KwkJICBjb25zdCB2cmFuZ2UgJm9wMSwKKwkJICByZWxhdGlvbl9raW5kIHJlbCA9IFZSRUxfVkFS WUlORykgY29uc3Q7CisgIHJlbGF0aW9uX2tpbmQgbGhzX29wMV9yZWxhdGlvbiAoY29uc3QgdnJh bmdlICZsaHMsCisJCQkJICBjb25zdCB2cmFuZ2UgJm9wMSwKKwkJCQkgIGNvbnN0IHZyYW5nZSAm b3AyLAorCQkJCSAgcmVsYXRpb25fa2luZCA9IFZSRUxfVkFSWUlORykgY29uc3Q7CisgIHJlbGF0 aW9uX2tpbmQgbGhzX29wMl9yZWxhdGlvbiAoY29uc3QgdnJhbmdlICZsaHMsCisJCQkJICBjb25z dCB2cmFuZ2UgJm9wMSwKKwkJCQkgIGNvbnN0IHZyYW5nZSAmb3AyLAorCQkJCSAgcmVsYXRpb25f a2luZCA9IFZSRUxfVkFSWUlORykgY29uc3Q7CisgIHJlbGF0aW9uX2tpbmQgb3AxX29wMl9yZWxh dGlvbiAoY29uc3QgdnJhbmdlICZsaHMpIGNvbnN0OworcHJpdmF0ZToKKyAgcmFuZ2Vfb3BlcmF0 b3IgKm1fb3A7Cit9OworCitleHRlcm4gYm9vbCByYW5nZV9jYXN0ICh2cmFuZ2UgJiwgdHJlZSB0 eXBlKTsKIGV4dGVybiB2b2lkIHdpX3NldF96ZXJvX25vbnplcm9fYml0cyAodHJlZSB0eXBlLAog CQkJCSAgICAgIGNvbnN0IHdpZGVfaW50ICYsIGNvbnN0IHdpZGVfaW50ICYsCiAJCQkJICAgICAg d2lkZV9pbnQgJm1heWJlX25vbnplcm8sCkBAIC0xMjQsNyArMTU1LDcgQEAgcmVsYXRpb25fa2lu ZCBndF9vcDFfb3AyX3JlbGF0aW9uIChjb25zdCBpcmFuZ2UgJmxocyk7CiByZWxhdGlvbl9raW5k IGdlX29wMV9vcDJfcmVsYXRpb24gKGNvbnN0IGlyYW5nZSAmbGhzKTsKIAogZW51bSBib29sX3Jh bmdlX3N0YXRlIHsgQlJTX0ZBTFNFLCBCUlNfVFJVRSwgQlJTX0VNUFRZLCBCUlNfRlVMTCB9Owot Ym9vbF9yYW5nZV9zdGF0ZSBnZXRfYm9vbF9zdGF0ZSAoaXJhbmdlICZyLCBjb25zdCBpcmFuZ2Ug JmxocywgdHJlZSB2YWxfdHlwZSk7Citib29sX3JhbmdlX3N0YXRlIGdldF9ib29sX3N0YXRlICh2 cmFuZ2UgJnIsIGNvbnN0IHZyYW5nZSAmbGhzLCB0cmVlIHZhbF90eXBlKTsKIAogLy8gSWYgdGhl IHJhbmdlIG9mIGVpdGhlciBvcDEgb3Igb3AyIGlzIHVuZGVmaW5lZCwgc2V0IHRoZSByZXN1bHQg dG8KIC8vIHZhcnlpbmcgYW5kIHJldHVybiBUUlVFLiAgSWYgdGhlIGNhbGxlciB0cnVlbHkgY2Fy ZXMgYWJvdXQgYSByZXN1bHQsCkBAIC0xMzIsOCArMTYzLDggQEAgYm9vbF9yYW5nZV9zdGF0ZSBn ZXRfYm9vbF9zdGF0ZSAoaXJhbmdlICZyLCBjb25zdCBpcmFuZ2UgJmxocywgdHJlZSB2YWxfdHlw ZSk7CiAvLyB0cmVhdGVkIGFzIGEgdmFyeWluZy4KIAogaW5saW5lIGJvb2wKLWVtcHR5X3Jhbmdl X3ZhcnlpbmcgKGlyYW5nZSAmciwgdHJlZSB0eXBlLAotCQkgICAgIGNvbnN0IGlyYW5nZSAmb3Ax LCBjb25zdCBpcmFuZ2UgJiBvcDIpCitlbXB0eV9yYW5nZV92YXJ5aW5nICh2cmFuZ2UgJnIsIHRy ZWUgdHlwZSwKKwkJICAgICBjb25zdCB2cmFuZ2UgJm9wMSwgY29uc3QgdnJhbmdlICYgb3AyKQog ewogICBpZiAob3AxLnVuZGVmaW5lZF9wICgpIHx8IG9wMi51bmRlZmluZWRfcCAoKSkKICAgICB7 CkBAIC0xNTAsOCArMTgxLDggQEAgZW1wdHlfcmFuZ2VfdmFyeWluZyAoaXJhbmdlICZyLCB0cmVl IHR5cGUsCiAvLyByZXR1cm4gZmFsc2UuCiAKIGlubGluZSBib29sCi1yZWxvcF9lYXJseV9yZXNv bHZlIChpcmFuZ2UgJnIsIHRyZWUgdHlwZSwgY29uc3QgaXJhbmdlICZvcDEsCi0JCSAgICAgY29u c3QgaXJhbmdlICZvcDIsIHJlbGF0aW9uX2tpbmQgcmVsLAorcmVsb3BfZWFybHlfcmVzb2x2ZSAo aXJhbmdlICZyLCB0cmVlIHR5cGUsIGNvbnN0IHZyYW5nZSAmb3AxLAorCQkgICAgIGNvbnN0IHZy YW5nZSAmb3AyLCByZWxhdGlvbl9raW5kIHJlbCwKIAkJICAgICByZWxhdGlvbl9raW5kIG15X3Jl bCkKIHsKICAgLy8gSWYga25vd24gcmVsYXRpb24gaXMgYSBjb21wbGV0ZSBzdWJzZXQgb2YgdGhp cyByZWxhdGlvbiwgYWx3YXlzIHRydWUuCmRpZmYgLS1naXQgYS9nY2MvdHJlZS1kYXRhLXJlZi5j YyBiL2djYy90cmVlLWRhdGEtcmVmLmNjCmluZGV4IDM5Nzc5MmMzNTg0Li5hZTA1ZmU3NGI5NSAx MDA2NDQKLS0tIGEvZ2NjL3RyZWUtZGF0YS1yZWYuY2MKKysrIGIvZ2NjL3RyZWUtZGF0YS1yZWYu Y2MKQEAgLTU5Myw4ICs1OTMsOCBAQCBjb21wdXRlX2Rpc3RyaWJ1dGl2ZV9yYW5nZSAodHJlZSB0 eXBlLCB2YWx1ZV9yYW5nZSAmb3AwX3JhbmdlLAogICBnY2NfYXNzZXJ0IChJTlRFR1JBTF9UWVBF X1AgKHR5cGUpICYmICFUWVBFX09WRVJGTE9XX1RSQVBTICh0eXBlKSk7CiAgIGlmIChyZXN1bHRf cmFuZ2UpCiAgICAgewotICAgICAgcmFuZ2Vfb3BlcmF0b3IgKm9wID0gcmFuZ2Vfb3BfaGFuZGxl ciAoY29kZSwgdHlwZSk7Ci0gICAgICBvcC0+Zm9sZF9yYW5nZSAoKnJlc3VsdF9yYW5nZSwgdHlw ZSwgb3AwX3JhbmdlLCBvcDFfcmFuZ2UpOworICAgICAgcmFuZ2Vfb3BfaGFuZGxlciBvcCAoY29k ZSwgdHlwZSk7CisgICAgICBvcC5mb2xkX3JhbmdlICgqcmVzdWx0X3JhbmdlLCB0eXBlLCBvcDBf cmFuZ2UsIG9wMV9yYW5nZSk7CiAgICAgfQogCiAgIC8qIFRoZSBkaXN0cmlidXRpdmUgcHJvcGVy dHkgZ3VhcmFudGVlcyB0aGF0IGlmIFRZUEUgaXMgbm8gbmFycm93ZXIKQEAgLTYzOSwxMCArNjM5 LDEwIEBAIGNvbXB1dGVfZGlzdHJpYnV0aXZlX3JhbmdlICh0cmVlIHR5cGUsIHZhbHVlX3Jhbmdl ICZvcDBfcmFuZ2UsCiAgIHJhbmdlX2Nhc3QgKG9wMF9yYW5nZSwgc3NpemV0eXBlKTsKICAgcmFu Z2VfY2FzdCAob3AxX3JhbmdlLCBzc2l6ZXR5cGUpOwogICB2YWx1ZV9yYW5nZSB3aWRlX3Jhbmdl OwotICByYW5nZV9vcGVyYXRvciAqb3AgPSByYW5nZV9vcF9oYW5kbGVyIChjb2RlLCBzc2l6ZXR5 cGUpOworICByYW5nZV9vcF9oYW5kbGVyIG9wIChjb2RlLCBzc2l6ZXR5cGUpOwogICBib29sIHNh dmVkX2ZsYWdfd3JhcHYgPSBmbGFnX3dyYXB2OwogICBmbGFnX3dyYXB2ID0gMTsKLSAgb3AtPmZv bGRfcmFuZ2UgKHdpZGVfcmFuZ2UsIHNzaXpldHlwZSwgb3AwX3JhbmdlLCBvcDFfcmFuZ2UpOwor ICBvcC5mb2xkX3JhbmdlICh3aWRlX3JhbmdlLCBzc2l6ZXR5cGUsIG9wMF9yYW5nZSwgb3AxX3Jh bmdlKTsKICAgZmxhZ193cmFwdiA9IHNhdmVkX2ZsYWdfd3JhcHY7CiAgIGlmICh3aWRlX3Jhbmdl Lm51bV9wYWlycyAoKSAhPSAxIHx8ICFyYW5nZV9pbnRfY3N0X3AgKCZ3aWRlX3JhbmdlKSkKICAg ICByZXR1cm4gZmFsc2U7CmRpZmYgLS1naXQgYS9nY2MvdHJlZS12cnAuY2MgYi9nY2MvdHJlZS12 cnAuY2MKaW5kZXggNjJhZTVhOTY3ZjMuLjc0Mjc3NjE3YjY2IDEwMDY0NAotLS0gYS9nY2MvdHJl ZS12cnAuY2MKKysrIGIvZ2NjL3RyZWUtdnJwLmNjCkBAIC05MjQsMjAgKzkyNCw2IEBAIGV4dHJh Y3RfcmFuZ2VfZnJvbV9wbHVzX21pbnVzX2V4cHIgKHZhbHVlX3JhbmdlICp2ciwKICAgICB2ci0+ c2V0IChtaW4sIG1heCwga2luZCk7CiB9CiAKLS8qIFJldHVybiB0aGUgcmFuZ2Utb3BzIGhhbmRs ZXIgZm9yIENPREUgYW5kIEVYUFJfVFlQRS4gIElmIG5vCi0gICBzdWl0YWJsZSBvcGVyYXRvciBp cyBmb3VuZCwgcmV0dXJuIE5VTEwgYW5kIHNldCBWUiB0byBWQVJZSU5HLiAgKi8KLQotc3RhdGlj IGNvbnN0IHJhbmdlX29wZXJhdG9yICoKLWdldF9yYW5nZV9vcF9oYW5kbGVyICh2YWx1ZV9yYW5n ZSAqdnIsCi0JCSAgICAgIGVudW0gdHJlZV9jb2RlIGNvZGUsCi0JCSAgICAgIHRyZWUgZXhwcl90 eXBlKQotewotICBjb25zdCByYW5nZV9vcGVyYXRvciAqb3AgPSByYW5nZV9vcF9oYW5kbGVyIChj b2RlLCBleHByX3R5cGUpOwotICBpZiAoIW9wKQotICAgIHZyLT5zZXRfdmFyeWluZyAoZXhwcl90 eXBlKTsKLSAgcmV0dXJuIG9wOwotfQotCiAvKiBJZiB0aGUgdHlwZXMgcGFzc2VkIGFyZSBzdXBw b3J0ZWQsIHJldHVybiBUUlVFLCBvdGhlcndpc2Ugc2V0IFZSIHRvCiAgICBWQVJZSU5HIGFuZCBy ZXR1cm4gRkFMU0UuICAqLwogCkBAIC0xMDA1LDEwICs5OTEsMTIgQEAgcmFuZ2VfZm9sZF9iaW5h cnlfc3ltYm9saWNzX3AgKHZhbHVlX3JhbmdlICp2ciwKIAkJCQkJCSZ2cjAsICZ2cjEpOwogCSAg cmV0dXJuIHRydWU7CiAJfQotICAgICAgY29uc3QgcmFuZ2Vfb3BlcmF0b3IgKm9wID0gZ2V0X3Jh bmdlX29wX2hhbmRsZXIgKHZyLCBjb2RlLCBleHByX3R5cGUpOworICAgICAgcmFuZ2Vfb3BfaGFu ZGxlciBvcCAoY29kZSwgZXhwcl90eXBlKTsKKyAgICAgIGlmICghb3ApCisJdnItPnNldF92YXJ5 aW5nIChleHByX3R5cGUpOwogICAgICAgdnIwLm5vcm1hbGl6ZV9zeW1ib2xpY3MgKCk7CiAgICAg ICB2cjEubm9ybWFsaXplX3N5bWJvbGljcyAoKTsKLSAgICAgIHJldHVybiBvcC0+Zm9sZF9yYW5n ZSAoKnZyLCBleHByX3R5cGUsIHZyMCwgdnIxKTsKKyAgICAgIHJldHVybiBvcC5mb2xkX3Jhbmdl ICgqdnIsIGV4cHJfdHlwZSwgdnIwLCB2cjEpOwogICAgIH0KICAgcmV0dXJuIGZhbHNlOwogfQpA QCAtMTA0MCwxMCArMTAyOCwxMiBAQCByYW5nZV9mb2xkX3VuYXJ5X3N5bWJvbGljc19wICh2YWx1 ZV9yYW5nZSAqdnIsCiAJICByYW5nZV9mb2xkX2JpbmFyeV9leHByICh2ciwgTUlOVVNfRVhQUiwg ZXhwcl90eXBlLCAmbWludXNvbmUsIHZyMCk7CiAJICByZXR1cm4gdHJ1ZTsKIAl9Ci0gICAgICBj b25zdCByYW5nZV9vcGVyYXRvciAqb3AgPSBnZXRfcmFuZ2Vfb3BfaGFuZGxlciAodnIsIGNvZGUs IGV4cHJfdHlwZSk7CisgICAgICByYW5nZV9vcF9oYW5kbGVyIG9wIChjb2RlLCBleHByX3R5cGUp OworICAgICAgaWYgKCFvcCkKKwl2ci0+c2V0X3ZhcnlpbmcgKGV4cHJfdHlwZSk7CiAgICAgICB2 YWx1ZV9yYW5nZSB2cjBfY3N0ICgqdnIwKTsKICAgICAgIHZyMF9jc3Qubm9ybWFsaXplX3N5bWJv bGljcyAoKTsKLSAgICAgIHJldHVybiBvcC0+Zm9sZF9yYW5nZSAoKnZyLCBleHByX3R5cGUsIHZy MF9jc3QsIHZhbHVlX3JhbmdlIChleHByX3R5cGUpKTsKKyAgICAgIHJldHVybiBvcC5mb2xkX3Jh bmdlICgqdnIsIGV4cHJfdHlwZSwgdnIwX2NzdCwgdmFsdWVfcmFuZ2UgKGV4cHJfdHlwZSkpOwog ICAgIH0KICAgcmV0dXJuIGZhbHNlOwogfQpAQCAtMTA2MCw5ICsxMDUwLDEyIEBAIHJhbmdlX2Zv bGRfYmluYXJ5X2V4cHIgKHZhbHVlX3JhbmdlICp2ciwKICAgaWYgKCFzdXBwb3J0ZWRfdHlwZXNf cCAodnIsIGV4cHJfdHlwZSkKICAgICAgIHx8ICFkZWZpbmVkX3Jhbmdlc19wICh2ciwgdnIwXywg dnIxXykpCiAgICAgcmV0dXJuOwotICBjb25zdCByYW5nZV9vcGVyYXRvciAqb3AgPSBnZXRfcmFu Z2Vfb3BfaGFuZGxlciAodnIsIGNvZGUsIGV4cHJfdHlwZSk7CisgIHJhbmdlX29wX2hhbmRsZXIg b3AgKGNvZGUsIGV4cHJfdHlwZSk7CiAgIGlmICghb3ApCi0gICAgcmV0dXJuOworICAgIHsKKyAg ICAgIHZyLT5zZXRfdmFyeWluZyAoZXhwcl90eXBlKTsKKyAgICAgIHJldHVybjsKKyAgICB9CiAK ICAgaWYgKHJhbmdlX2ZvbGRfYmluYXJ5X3N5bWJvbGljc19wICh2ciwgY29kZSwgZXhwcl90eXBl LCB2cjBfLCB2cjFfKSkKICAgICByZXR1cm47CkBAIC0xMDc1LDcgKzEwNjgsNyBAQCByYW5nZV9m b2xkX2JpbmFyeV9leHByICh2YWx1ZV9yYW5nZSAqdnIsCiAgICAgdnIxLnNldF92YXJ5aW5nIChl eHByX3R5cGUpOwogICB2cjAubm9ybWFsaXplX2FkZHJlc3NlcyAoKTsKICAgdnIxLm5vcm1hbGl6 ZV9hZGRyZXNzZXMgKCk7Ci0gIG9wLT5mb2xkX3JhbmdlICgqdnIsIGV4cHJfdHlwZSwgdnIwLCB2 cjEpOworICBvcC5mb2xkX3JhbmdlICgqdnIsIGV4cHJfdHlwZSwgdnIwLCB2cjEpOwogfQogCiAv KiBQZXJmb3JtIGEgdW5hcnkgb3BlcmF0aW9uIG9uIGEgcmFuZ2UuICAqLwpAQCAtMTA4OSwxNiAr MTA4MiwxOSBAQCByYW5nZV9mb2xkX3VuYXJ5X2V4cHIgKHZhbHVlX3JhbmdlICp2ciwKICAgaWYg KCFzdXBwb3J0ZWRfdHlwZXNfcCAodnIsIGV4cHJfdHlwZSwgdnIwX3R5cGUpCiAgICAgICB8fCAh ZGVmaW5lZF9yYW5nZXNfcCAodnIsIHZyMCkpCiAgICAgcmV0dXJuOwotICBjb25zdCByYW5nZV9v cGVyYXRvciAqb3AgPSBnZXRfcmFuZ2Vfb3BfaGFuZGxlciAodnIsIGNvZGUsIGV4cHJfdHlwZSk7 CisgIHJhbmdlX29wX2hhbmRsZXIgb3AgKGNvZGUsIGV4cHJfdHlwZSk7CiAgIGlmICghb3ApCi0g ICAgcmV0dXJuOworICAgIHsKKyAgICAgIHZyLT5zZXRfdmFyeWluZyAoZXhwcl90eXBlKTsKKyAg ICAgIHJldHVybjsKKyAgICB9CiAKICAgaWYgKHJhbmdlX2ZvbGRfdW5hcnlfc3ltYm9saWNzX3Ag KHZyLCBjb2RlLCBleHByX3R5cGUsIHZyMCkpCiAgICAgcmV0dXJuOwogCiAgIHZhbHVlX3Jhbmdl IHZyMF9jc3QgKCp2cjApOwogICB2cjBfY3N0Lm5vcm1hbGl6ZV9hZGRyZXNzZXMgKCk7Ci0gIG9w LT5mb2xkX3JhbmdlICgqdnIsIGV4cHJfdHlwZSwgdnIwX2NzdCwgdmFsdWVfcmFuZ2UgKGV4cHJf dHlwZSkpOworICBvcC5mb2xkX3JhbmdlICgqdnIsIGV4cHJfdHlwZSwgdnIwX2NzdCwgdmFsdWVf cmFuZ2UgKGV4cHJfdHlwZSkpOwogfQogCiAvKiBJZiB0aGUgcmFuZ2Ugb2YgdmFsdWVzIHRha2Vu IGJ5IE9QIGNhbiBiZSBpbmZlcnJlZCBhZnRlciBTVE1UIGV4ZWN1dGVzLApkaWZmIC0tZ2l0IGEv Z2NjL3ZhbHVlLXF1ZXJ5LmNjIGIvZ2NjL3ZhbHVlLXF1ZXJ5LmNjCmluZGV4IDI2ZTM4NTgxMDNi Li4zMWU1NmVlYWU1MyAxMDA2NDQKLS0tIGEvZ2NjL3ZhbHVlLXF1ZXJ5LmNjCisrKyBiL2djYy92 YWx1ZS1xdWVyeS5jYwpAQCAtMjM0LDEzICsyMzQsMTMgQEAgcmFuZ2VfcXVlcnk6OmdldF90cmVl X3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgZXhwciwgZ2ltcGxlICpzdG10KQogICAgIH0KICAgaWYg KEJJTkFSWV9DTEFTU19QIChleHByKSkKICAgICB7Ci0gICAgICByYW5nZV9vcGVyYXRvciAqb3Ag PSByYW5nZV9vcF9oYW5kbGVyIChUUkVFX0NPREUgKGV4cHIpLCB0eXBlKTsKKyAgICAgIHJhbmdl X29wX2hhbmRsZXIgb3AgKFRSRUVfQ09ERSAoZXhwciksIHR5cGUpOwogICAgICAgaWYgKG9wKQog CXsKIAkgIGludF9yYW5nZV9tYXggcjAsIHIxOwogCSAgcmFuZ2Vfb2ZfZXhwciAocjAsIFRSRUVf T1BFUkFORCAoZXhwciwgMCksIHN0bXQpOwogCSAgcmFuZ2Vfb2ZfZXhwciAocjEsIFRSRUVfT1BF UkFORCAoZXhwciwgMSksIHN0bXQpOwotCSAgb3AtPmZvbGRfcmFuZ2UgKHIsIHR5cGUsIHIwLCBy MSk7CisJICBvcC5mb2xkX3JhbmdlIChyLCB0eXBlLCByMCwgcjEpOwogCX0KICAgICAgIGVsc2UK IAlyLnNldF92YXJ5aW5nICh0eXBlKTsKQEAgLTI0OCwxMyArMjQ4LDEzIEBAIHJhbmdlX3F1ZXJ5 OjpnZXRfdHJlZV9yYW5nZSAoaXJhbmdlICZyLCB0cmVlIGV4cHIsIGdpbXBsZSAqc3RtdCkKICAg ICB9CiAgIGlmIChVTkFSWV9DTEFTU19QIChleHByKSkKICAgICB7Ci0gICAgICByYW5nZV9vcGVy YXRvciAqb3AgPSByYW5nZV9vcF9oYW5kbGVyIChUUkVFX0NPREUgKGV4cHIpLCB0eXBlKTsKKyAg ICAgIHJhbmdlX29wX2hhbmRsZXIgb3AgKFRSRUVfQ09ERSAoZXhwciksIHR5cGUpOwogICAgICAg dHJlZSBvcDBfdHlwZSA9IFRSRUVfVFlQRSAoVFJFRV9PUEVSQU5EIChleHByLCAwKSk7CiAgICAg ICBpZiAob3AgJiYgaXJhbmdlOjpzdXBwb3J0c190eXBlX3AgKG9wMF90eXBlKSkKIAl7CiAJICBp bnRfcmFuZ2VfbWF4IHIwOwogCSAgcmFuZ2Vfb2ZfZXhwciAocjAsIFRSRUVfT1BFUkFORCAoZXhw ciwgMCksIHN0bXQpOwotCSAgb3AtPmZvbGRfcmFuZ2UgKHIsIHR5cGUsIHIwLCBpbnRfcmFuZ2U8 MT4gKHR5cGUpKTsKKwkgIG9wLmZvbGRfcmFuZ2UgKHIsIHR5cGUsIHIwLCBpbnRfcmFuZ2U8MT4g KHR5cGUpKTsKIAl9CiAgICAgICBlbHNlCiAJci5zZXRfdmFyeWluZyAodHlwZSk7Ci0tIAoyLjM2 LjEKCg== --000000000000b58e2405e05f2484--