From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id D216C3858D28 for ; Thu, 18 Aug 2022 07:58:46 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org D216C3858D28 Received: from mail-oa1-f69.google.com (mail-oa1-f69.google.com [209.85.160.69]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_128_GCM_SHA256) id us-mta-185-A8RsJ0qgMTyefNGm3-eKzg-1; Thu, 18 Aug 2022 03:58:44 -0400 X-MC-Unique: A8RsJ0qgMTyefNGm3-eKzg-1 Received: by mail-oa1-f69.google.com with SMTP id 586e51a60fabf-117b96393f3so481006fac.9 for ; Thu, 18 Aug 2022 00:58:44 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-message-state:from:to:cc; bh=R5sZPihKVC0Itx+7xh3u4lvWUJ2mgF/YwULCXC4nZU4=; b=3x4k7XDLgmvgs/EbS/Hw+ul+Q1KuV7Zygwjuo7edh5TO9LiPqrHsKoNFfXohvtRcED 05cFoeHWC5YNdj3uDREowM70NCZHAtYug/J3Qzmt4LuC9YOoCfNXEryydys1YnAO8UIA j8XrfchGNx4WMoZsP/SqKgBqX+73sIMR35DY9QuB2Vwc19NW7LaG48unN2s8BpuRt3sW EGlO01/BDY3KvEcqNFxgCas2+XtSDb87eKfBP9/jRSGYIuVM0jQiYqybQMCcPNf5VC5D w9jKvztktJ98fvtFVZN6XcMbSWr+gZXG+gx+B2ZEY87Hd9kP7+88IUjgBxxW2IuIuO+6 FJTA== X-Gm-Message-State: ACgBeo3k3FRvYPveCyODs3yJJqmMbiIB5Zij0Yq2mqPTc1Yqk8bGHGYW JABwQ6a+B6qn3d4vLU2vzYdxM2qQfqsPS6AZOZqT3fUVN0Us7m6a9CnZ4TyIR2HarumpTR1/f1v XhBRB9ND4+6WoizQuxr2YHnubnRmVMDqPZA== X-Received: by 2002:a05:6808:f07:b0:344:7739:8e7b with SMTP id m7-20020a0568080f0700b0034477398e7bmr780300oiw.265.1660809523817; Thu, 18 Aug 2022 00:58:43 -0700 (PDT) X-Google-Smtp-Source: AA6agR43LPnuRp0jIoeShOqe2UmGIzdAB98oLr7xjpMZXxCB3ZvsKPDg/Y/DdmN888T+vQMz1DNXrMzC+KWX+s9dASE= X-Received: by 2002:a05:6808:f07:b0:344:7739:8e7b with SMTP id m7-20020a0568080f0700b0034477398e7bmr780291oiw.265.1660809523258; Thu, 18 Aug 2022 00:58:43 -0700 (PDT) MIME-Version: 1.0 References: <20220817115848.512165-1-aldyh@redhat.com> In-Reply-To: <20220817115848.512165-1-aldyh@redhat.com> From: Aldy Hernandez Date: Thu, 18 Aug 2022 09:58:31 +0200 Message-ID: Subject: Re: [PATCH] Make path_range_query standalone and add reset_path. To: Richard Biener Cc: Andrew MacLeod , GCC patches X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: multipart/mixed; boundary="000000000000acc21105e67f59bd" X-Spam-Status: No, score=-11.4 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_ASCII_DIVIDERS, RCVD_IN_DNSWL_LOW, 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: Thu, 18 Aug 2022 07:58:52 -0000 --000000000000acc21105e67f59bd Content-Type: text/plain; charset="UTF-8" FWIW, here is a rebased version with the latest trunk. There are no regressions, or differences in threading counts, and the performance change is negligible. Aldy On Wed, Aug 17, 2022 at 1:59 PM Aldy Hernandez wrote: > > These are a bunch of cleanups inspired by Richi's suggestion of making > path_range_query standalone, instead of having to call > compute_ranges() for each path. > > I've made the ranger need explicit, and moved the responsibility for > its creation to the caller. > > I've also investigated and documented why the forward threader needs its > own compute exit dependencies variant. I can't wait for it to go away > :-/. > > I've also added constructors that take a path and dependencies, and > made compute_ranges() private. Unfortunately, reinstantiating > path_range_query in the forward threader caused a 14% performance > regression in DOM, because the old threader calls it over and over on > the same path to simplify statements (some of which not even in the > IL, but that's old news). > > In the meantime, I've left the ability to reset a path, but this time > appropriately called reset_path(). > > I've moved the verify_marked_backedges call to the threader. Is this > ok? > > Interestingly, comparing the thread counts for the patch yielded more > threads. I narrowed this down to a bug in the path oracle reset code > that's not cleaning things up as expected. I'll fix that before > committing this, but figured I'd post for comments in the meantime. > > Thoughts? > > gcc/ChangeLog: > > * gimple-range-path.cc (path_range_query::path_range_query): Add > various constructors to take a path. > (path_range_query::~path_range_query): Remove m_alloced_ranger. > (path_range_query::range_on_path_entry): Adjust for m_ranger being > a reference. > (path_range_query::set_path): Rename to... > (path_range_query::reset_path): ...this and call compute_ranges. > (path_range_query::ssa_range_in_phi): Adjust for m_ranger > reference. > (path_range_query::range_defined_in_block): Same. > (path_range_query::compute_ranges_in_block): Same. > (path_range_query::adjust_for_non_null_uses): Same. > (path_range_query::compute_exit_dependencies): Use m_path instead > of argument. > (path_range_query::compute_ranges): Remove path argument. > (path_range_query::range_of_stmt): Adjust for m_ranger reference. > (path_range_query::compute_outgoing_relations): Same. > * gimple-range-path.h (class path_range_query): Add various > constructors. > Make compute_ranges and compute_exit_dependencies private. > Rename set_path to reset_path. > Make m_ranger a reference. > Remove m_alloced_ranger. > * tree-ssa-dom.cc (pass_dominator::execute): Adjust constructor to > path_range_query. > * tree-ssa-loop-ch.cc (entry_loop_condition_is_static): Take a > ranger and instantiate a new path_range_query every time. > (ch_base::copy_headers): Pass ranger instead of path_range_query. > * tree-ssa-threadbackward.cc (class back_threader): Remove m_solver. > (back_threader::~back_threader): Remove m_solver. > (back_threader::find_taken_edge_switch): Adjust for m_ranger > reference. > (back_threader::find_taken_edge_cond): Same. > (back_threader::dump): Remove m_solver. > (back_threader::back_threader): Move verify_marked_backedges > here from the path_range_query constructor. > * tree-ssa-threadedge.cc (hybrid_jt_simplifier::simplify): Move > some code from compute_ranges_from_state here. > (hybrid_jt_simplifier::compute_ranges_from_state): Rename... > (hybrid_jt_simplifier::compute_exit_dependencies): ...to this. > * tree-ssa-threadedge.h (class hybrid_jt_simplifier): Rename > compute_ranges_from_state to compute_exit_dependencies. > Remove m_path. > --- > gcc/gimple-range-path.cc | 112 +++++++++++++++++---------------- > gcc/gimple-range-path.h | 22 +++---- > gcc/tree-ssa-dom.cc | 2 +- > gcc/tree-ssa-loop-ch.cc | 12 ++-- > gcc/tree-ssa-threadbackward.cc | 27 ++++---- > gcc/tree-ssa-threadedge.cc | 30 +++++---- > gcc/tree-ssa-threadedge.h | 5 +- > 7 files changed, 111 insertions(+), 99 deletions(-) > > diff --git a/gcc/gimple-range-path.cc b/gcc/gimple-range-path.cc > index c99d77dd340..d37605f4539 100644 > --- a/gcc/gimple-range-path.cc > +++ b/gcc/gimple-range-path.cc > @@ -36,33 +36,52 @@ along with GCC; see the file COPYING3. If not see > // Internal construct to help facilitate debugging of solver. > #define DEBUG_SOLVER (dump_file && (param_threader_debug == THREADER_DEBUG_ALL)) > > -path_range_query::path_range_query (bool resolve, gimple_ranger *ranger) > +path_range_query::path_range_query (gimple_ranger &ranger, > + const vec &path, > + const bitmap_head *dependencies, > + bool resolve) > : m_cache (new ssa_global_cache), > m_has_cache_entry (BITMAP_ALLOC (NULL)), > - m_resolve (resolve), > - m_alloced_ranger (!ranger) > + m_ranger (ranger), > + m_resolve (resolve) > { > - if (m_alloced_ranger) > - m_ranger = new gimple_ranger; > - else > - m_ranger = ranger; > + m_oracle = new path_oracle (m_ranger.oracle ()); > + > + reset_path (path, dependencies); > +} > > - m_oracle = new path_oracle (m_ranger->oracle ()); > +path_range_query::path_range_query (gimple_ranger &ranger, bool resolve) > + : m_cache (new ssa_global_cache), > + m_has_cache_entry (BITMAP_ALLOC (NULL)), > + m_ranger (ranger), > + m_resolve (resolve) > +{ > + m_oracle = new path_oracle (m_ranger.oracle ()); > +} > > - if (m_resolve && flag_checking) > - verify_marked_backedges (cfun); > +path_range_query::path_range_query (gimple_ranger &ranger, > + edge e, > + bool resolve) > + : m_cache (new ssa_global_cache), > + m_has_cache_entry (BITMAP_ALLOC (NULL)), > + m_ranger (ranger), > + m_resolve (resolve) > +{ > + m_oracle = new path_oracle (m_ranger.oracle ()); > + auto_vec bbs (2); > + bbs.quick_push (e->dest); > + bbs.quick_push (e->src); > + reset_path (bbs, NULL); > } > > path_range_query::~path_range_query () > { > delete m_oracle; > - if (m_alloced_ranger) > - delete m_ranger; > BITMAP_FREE (m_has_cache_entry); > delete m_cache; > } > > -// Return TRUE if NAME is an exit depenency for the path. > +// Return TRUE if NAME is an exit dependency for the path. > > bool > path_range_query::exit_dependency_p (tree name) > @@ -153,7 +172,7 @@ path_range_query::range_on_path_entry (vrange &r, tree name) > { > gcc_checking_assert (defined_outside_path (name)); > basic_block entry = entry_bb (); > - m_ranger->range_on_entry (r, entry, name); > + m_ranger.range_on_entry (r, entry, name); > } > > // Return the range of NAME at the end of the path being analyzed. > @@ -211,19 +230,19 @@ path_range_query::unreachable_path_p () > return m_undefined_path; > } > > -// Initialize the current path to PATH. The current block is set to > -// the entry block to the path. > -// > -// Note that the blocks are in reverse order, so the exit block is > -// path[0]. > +// Reset the current path to PATH. > > void > -path_range_query::set_path (const vec &path) > +path_range_query::reset_path (const vec &path, > + const bitmap_head *dependencies) > { > gcc_checking_assert (path.length () > 1); > m_path = path.copy (); > m_pos = m_path.length () - 1; > + m_undefined_path = false; > bitmap_clear (m_has_cache_entry); > + > + compute_ranges (dependencies); > } > > bool > @@ -248,7 +267,7 @@ path_range_query::ssa_range_in_phi (vrange &r, gphi *phi) > > if (at_entry ()) > { > - if (m_resolve && m_ranger->range_of_expr (r, name, phi)) > + if (m_resolve && m_ranger.range_of_expr (r, name, phi)) > return; > > // Try to fold the phi exclusively with global or cached values. > @@ -290,7 +309,7 @@ path_range_query::ssa_range_in_phi (vrange &r, gphi *phi) > range_on_path_entry (r, arg); > else > r.set_varying (TREE_TYPE (name)); > - m_ranger->range_on_edge (tmp, e_in, arg); > + m_ranger.range_on_edge (tmp, e_in, arg); > r.intersect (tmp); > return; > } > @@ -325,7 +344,7 @@ path_range_query::range_defined_in_block (vrange &r, tree name, basic_block bb) > } > > if (bb && POINTER_TYPE_P (TREE_TYPE (name))) > - m_ranger->m_cache.m_exit.maybe_adjust_range (r, name, bb); > + m_ranger.m_cache.m_exit.maybe_adjust_range (r, name, bb); > > if (DEBUG_SOLVER && (bb || !r.varying_p ())) > { > @@ -442,7 +461,7 @@ path_range_query::compute_ranges_in_block (basic_block bb) > p->set_root_oracle (nullptr); > } > > - gori_compute &g = m_ranger->gori (); > + gori_compute &g = m_ranger.gori (); > bitmap exports = g.exports (bb); > EXECUTE_IF_AND_IN_BITMAP (m_exit_dependencies, exports, 0, i, bi) > { > @@ -496,7 +515,7 @@ path_range_query::adjust_for_non_null_uses (basic_block bb) > else > r.set_varying (TREE_TYPE (name)); > > - if (m_ranger->m_cache.m_exit.maybe_adjust_range (r, name, bb)) > + if (m_ranger.m_cache.m_exit.maybe_adjust_range (r, name, bb)) > set_cache (r, name); > } > } > @@ -516,12 +535,11 @@ path_range_query::add_to_exit_dependencies (tree name, bitmap dependencies) > // SSA names used to calculate the final conditional along the path. > > void > -path_range_query::compute_exit_dependencies (bitmap dependencies, > - const vec &path) > +path_range_query::compute_exit_dependencies (bitmap dependencies) > { > // Start with the imports from the exit block... > - basic_block exit = path[0]; > - gori_compute &gori = m_ranger->gori (); > + basic_block exit = m_path[0]; > + gori_compute &gori = m_ranger.gori (); > bitmap_copy (dependencies, gori.imports (exit)); > > auto_vec worklist (bitmap_count_bits (dependencies)); > @@ -539,7 +557,7 @@ path_range_query::compute_exit_dependencies (bitmap dependencies, > tree name = worklist.pop (); > gimple *def_stmt = SSA_NAME_DEF_STMT (name); > if (SSA_NAME_IS_DEFAULT_DEF (name) > - || !path.contains (gimple_bb (def_stmt))) > + || !m_path.contains (gimple_bb (def_stmt))) > continue; > > if (gphi *phi = dyn_cast (def_stmt)) > @@ -550,7 +568,7 @@ path_range_query::compute_exit_dependencies (bitmap dependencies, > tree arg = gimple_phi_arg (phi, i)->def; > > if (TREE_CODE (arg) == SSA_NAME > - && path.contains (e->src) > + && m_path.contains (e->src) > && bitmap_set_bit (dependencies, SSA_NAME_VERSION (arg))) > worklist.safe_push (arg); > } > @@ -582,9 +600,9 @@ path_range_query::compute_exit_dependencies (bitmap dependencies, > } > // Exported booleans along the path, may help conditionals. > if (m_resolve) > - for (i = 0; i < path.length (); ++i) > + for (i = 0; i < m_path.length (); ++i) > { > - basic_block bb = path[i]; > + basic_block bb = m_path[i]; > tree name; > FOR_EACH_GORI_EXPORT_NAME (gori, bb, name) > if (TREE_CODE (TREE_TYPE (name)) == BOOLEAN_TYPE) > @@ -600,19 +618,15 @@ path_range_query::compute_exit_dependencies (bitmap dependencies, > // calculated from the final conditional in the path. > > void > -path_range_query::compute_ranges (const vec &path, > - const bitmap_head *dependencies) > +path_range_query::compute_ranges (const bitmap_head *dependencies) > { > if (DEBUG_SOLVER) > fprintf (dump_file, "\n==============================================\n"); > > - set_path (path); > - m_undefined_path = false; > - > if (dependencies) > bitmap_copy (m_exit_dependencies, dependencies); > else > - compute_exit_dependencies (m_exit_dependencies, m_path); > + compute_exit_dependencies (m_exit_dependencies); > > if (m_resolve) > get_path_oracle ()->reset_path (); > @@ -620,9 +634,9 @@ path_range_query::compute_ranges (const vec &path, > if (DEBUG_SOLVER) > { > fprintf (dump_file, "path_range_query: compute_ranges for path: "); > - for (unsigned i = path.length (); i > 0; --i) > + for (unsigned i = m_path.length (); i > 0; --i) > { > - basic_block bb = path[i - 1]; > + basic_block bb = m_path[i - 1]; > fprintf (dump_file, "%d", bb->index); > if (i > 1) > fprintf (dump_file, "->"); > @@ -650,18 +664,6 @@ path_range_query::compute_ranges (const vec &path, > } > } > > -// Convenience function to compute ranges along a path consisting of > -// E->SRC and E->DEST. > - > -void > -path_range_query::compute_ranges (edge e) > -{ > - auto_vec bbs (2); > - bbs.quick_push (e->dest); > - bbs.quick_push (e->src); > - compute_ranges (bbs); > -} > - > // A folding aid used to register and query relations along a path. > // When queried, it returns relations as they would appear on exit to > // the path. > @@ -744,7 +746,7 @@ path_range_query::range_of_stmt (vrange &r, gimple *stmt, tree) > if (m_resolve) > { > fold_using_range f; > - jt_fur_source src (stmt, this, &m_ranger->gori (), m_path); > + jt_fur_source src (stmt, this, &m_ranger.gori (), m_path); > if (!f.fold_stmt (r, stmt, src)) > r.set_varying (type); > } > @@ -834,7 +836,7 @@ path_range_query::compute_outgoing_relations (basic_block bb, basic_block next) > else > gcc_unreachable (); > > - jt_fur_source src (NULL, this, &m_ranger->gori (), m_path); > + jt_fur_source src (NULL, this, &m_ranger.gori (), m_path); > src.register_outgoing_edges (cond, r, e0, e1); > } > } > diff --git a/gcc/gimple-range-path.h b/gcc/gimple-range-path.h > index 3cb794e34a9..483fde0d431 100644 > --- a/gcc/gimple-range-path.h > +++ b/gcc/gimple-range-path.h > @@ -32,13 +32,14 @@ along with GCC; see the file COPYING3. If not see > class path_range_query : public range_query > { > public: > - path_range_query (bool resolve = true, class gimple_ranger *ranger = NULL); > + path_range_query (class gimple_ranger &ranger, > + const vec &path, > + const bitmap_head *dependencies = NULL, > + bool resolve = true); > + path_range_query (gimple_ranger &ranger, bool resolve = true); > + path_range_query (gimple_ranger &ranger, edge e, bool resolve = true); > virtual ~path_range_query (); > - void compute_ranges (const vec &, > - const bitmap_head *dependencies = NULL); > - void compute_ranges (edge e); > - void compute_exit_dependencies (bitmap dependencies, > - const vec &); > + void reset_path (const vec &, const bitmap_head *dependencies); > bool range_of_expr (vrange &r, tree name, gimple * = NULL) override; > bool range_of_stmt (vrange &r, gimple *, tree name = NULL) override; > bool unreachable_path_p (); > @@ -47,6 +48,8 @@ public: > > private: > bool internal_range_of_expr (vrange &r, tree name, gimple *); > + void compute_ranges (const bitmap_head *dependencies); > + void compute_exit_dependencies (bitmap_head *dependencies); > bool defined_outside_path (tree name); > void range_on_path_entry (vrange &r, tree name); > path_oracle *get_path_oracle () { return (path_oracle *)m_oracle; } > @@ -71,7 +74,6 @@ private: > bool relations_may_be_invalidated (edge); > > // Path navigation. > - void set_path (const vec &); > basic_block entry_bb () { return m_path[m_path.length () - 1]; } > basic_block exit_bb () { return m_path[0]; } > basic_block curr_bb () { return m_path[m_pos]; } > @@ -99,7 +101,7 @@ private: > > // A ranger used to resolve ranges for SSA names whose values come > // from outside the path. > - gimple_ranger *m_ranger; > + gimple_ranger &m_ranger; > > // Current path position. > unsigned m_pos; > @@ -109,10 +111,6 @@ private: > > // Set if there were any undefined expressions while pre-calculating path. > bool m_undefined_path; > - > - // True if m_ranger was allocated in this class and must be freed at > - // destruction. > - bool m_alloced_ranger; > }; > > #endif // GCC_TREE_SSA_THREADSOLVER_H > diff --git a/gcc/tree-ssa-dom.cc b/gcc/tree-ssa-dom.cc > index 44dc27b464c..513e0c88254 100644 > --- a/gcc/tree-ssa-dom.cc > +++ b/gcc/tree-ssa-dom.cc > @@ -798,7 +798,7 @@ pass_dominator::execute (function *fun) > > /* Recursively walk the dominator tree optimizing statements. */ > gimple_ranger *ranger = enable_ranger (fun); > - path_range_query path_query (/*resolve=*/true, ranger); > + path_range_query path_query (*ranger); > dom_jt_simplifier simplifier (avail_exprs_stack, ranger, &path_query); > dom_jt_state state (const_and_copies, avail_exprs_stack); > jump_threader threader (&simplifier, &state); > diff --git a/gcc/tree-ssa-loop-ch.cc b/gcc/tree-ssa-loop-ch.cc > index 3b91a89eaf5..96816b89287 100644 > --- a/gcc/tree-ssa-loop-ch.cc > +++ b/gcc/tree-ssa-loop-ch.cc > @@ -49,7 +49,7 @@ along with GCC; see the file COPYING3. If not see > be statically determined. */ > > static bool > -entry_loop_condition_is_static (class loop *l, path_range_query *query) > +entry_loop_condition_is_static (class loop *l, gimple_ranger *ranger) > { > edge e = loop_preheader_edge (l); > gcond *last = safe_dyn_cast (last_stmt (e->dest)); > @@ -72,8 +72,8 @@ entry_loop_condition_is_static (class loop *l, path_range_query *query) > desired_static_value = boolean_true_node; > > int_range<2> r; > - query->compute_ranges (e); > - query->range_of_stmt (r, last); > + path_range_query query (*ranger, e); > + query.range_of_stmt (r, last); > return r == int_range<2> (desired_static_value, desired_static_value); > } > > @@ -385,7 +385,7 @@ ch_base::copy_headers (function *fun) > auto_vec > copied; > > mark_dfs_back_edges (); > - path_range_query *query = new path_range_query; > + gimple_ranger *ranger = new gimple_ranger; > for (auto loop : loops_list (cfun, 0)) > { > int initial_limit = param_max_loop_header_insns; > @@ -409,7 +409,7 @@ ch_base::copy_headers (function *fun) > iteration. */ > if (optimize_loop_for_size_p (loop) > && !loop->force_vectorize > - && !entry_loop_condition_is_static (loop, query)) > + && !entry_loop_condition_is_static (loop, ranger)) > { > if (dump_file && (dump_flags & TDF_DETAILS)) > fprintf (dump_file, > @@ -422,7 +422,7 @@ ch_base::copy_headers (function *fun) > candidates.safe_push (loop); > } > /* Do not use ranger after we change the IL and not have updated SSA. */ > - delete query; > + delete ranger; > > for (auto loop : candidates) > { > diff --git a/gcc/tree-ssa-threadbackward.cc b/gcc/tree-ssa-threadbackward.cc > index b886027fccf..22748b9ec08 100644 > --- a/gcc/tree-ssa-threadbackward.cc > +++ b/gcc/tree-ssa-threadbackward.cc > @@ -99,7 +99,6 @@ private: > > back_threader_registry m_registry; > back_threader_profitability m_profit; > - path_range_query *m_solver; > > // Current path being analyzed. > auto_vec m_path; > @@ -119,6 +118,8 @@ private: > // with the ranger. Otherwise, unknown SSA names are assumed to be > // VARYING. Setting to true is more precise but slower. > function *m_fun; > + // Ranger for the path solver. > + gimple_ranger *m_ranger; > unsigned m_flags; > // Set to TRUE for the first of each thread[12] pass or the first of > // each threadfull[12] pass. This is used to differentiate between > @@ -145,14 +146,19 @@ back_threader::back_threader (function *fun, unsigned flags, bool first) > > // The path solver needs EDGE_DFS_BACK in resolving mode. > if (flags & BT_RESOLVE) > - mark_dfs_back_edges (); > - m_solver = new path_range_query (flags & BT_RESOLVE); > + { > + mark_dfs_back_edges (); > + > + if (flag_checking) > + verify_marked_backedges (fun); > + } > + > + m_ranger = new gimple_ranger; > } > > back_threader::~back_threader () > { > - delete m_solver; > - > + delete m_ranger; > loop_optimizer_finalize (); > } > > @@ -290,8 +296,8 @@ back_threader::find_taken_edge_switch (const vec &path, > tree name = gimple_switch_index (sw); > int_range_max r; > > - m_solver->compute_ranges (path, m_imports); > - m_solver->range_of_expr (r, name, sw); > + path_range_query solver (*m_ranger, path, m_imports, m_flags & BT_RESOLVE); > + solver.range_of_expr (r, name, sw); > > if (r.undefined_p ()) > return UNREACHABLE_EDGE; > @@ -314,10 +320,10 @@ back_threader::find_taken_edge_cond (const vec &path, > { > int_range_max r; > > - m_solver->compute_ranges (path, m_imports); > - m_solver->range_of_stmt (r, cond); > + path_range_query solver (*m_ranger, path, m_imports, m_flags & BT_RESOLVE); > + solver.range_of_stmt (r, cond); > > - if (m_solver->unreachable_path_p ()) > + if (solver.unreachable_path_p ()) > return UNREACHABLE_EDGE; > > int_range<2> true_range (boolean_true_node, boolean_true_node); > @@ -588,7 +594,6 @@ debug (const vec &path) > void > back_threader::dump (FILE *out) > { > - m_solver->dump (out); > fprintf (out, "\nCandidates for pre-computation:\n"); > fprintf (out, "===================================\n"); > > diff --git a/gcc/tree-ssa-threadedge.cc b/gcc/tree-ssa-threadedge.cc > index e64e4f209f7..905a98c8c68 100644 > --- a/gcc/tree-ssa-threadedge.cc > +++ b/gcc/tree-ssa-threadedge.cc > @@ -1399,7 +1399,6 @@ jt_state::register_equivs_stmt (gimple *stmt, basic_block bb, > > // Hybrid threader implementation. > > - > hybrid_jt_simplifier::hybrid_jt_simplifier (gimple_ranger *r, > path_range_query *q) > { > @@ -1411,7 +1410,12 @@ tree > hybrid_jt_simplifier::simplify (gimple *stmt, gimple *, basic_block, > jt_state *state) > { > - compute_ranges_from_state (stmt, state); > + auto_bitmap dependencies; > + auto_vec path; > + > + state->get_path (path); > + compute_exit_dependencies (dependencies, path, stmt); > + m_query->reset_path (path, dependencies); > > if (gimple_code (stmt) == GIMPLE_COND > || gimple_code (stmt) == GIMPLE_ASSIGN) > @@ -1432,22 +1436,25 @@ hybrid_jt_simplifier::simplify (gimple *stmt, gimple *, basic_block, > return NULL; > } > > -// Use STATE to generate the list of imports needed for the solver, > -// and calculate the ranges along the path. > +// Calculate the set of exit dependencies for a path and statement to > +// be simplified. This is different than the > +// compute_exit_dependencies in the path solver because the forward > +// threader asks questions about statements not necessarily in the > +// path. Using the default compute_exit_dependencies in the path > +// solver gets noticeably less threads. > > void > -hybrid_jt_simplifier::compute_ranges_from_state (gimple *stmt, jt_state *state) > +hybrid_jt_simplifier::compute_exit_dependencies (bitmap dependencies, > + const vec &path, > + gimple *stmt) > { > - auto_bitmap imports; > gori_compute &gori = m_ranger->gori (); > > - state->get_path (m_path); > - > // Start with the imports to the final conditional. > - bitmap_copy (imports, gori.imports (m_path[0])); > + bitmap_copy (dependencies, gori.imports (path[0])); > > // Add any other interesting operands we may have missed. > - if (gimple_bb (stmt) != m_path[0]) > + if (gimple_bb (stmt) != path[0]) > { > for (unsigned i = 0; i < gimple_num_ops (stmt); ++i) > { > @@ -1455,8 +1462,7 @@ hybrid_jt_simplifier::compute_ranges_from_state (gimple *stmt, jt_state *state) > if (op > && TREE_CODE (op) == SSA_NAME > && Value_Range::supports_type_p (TREE_TYPE (op))) > - bitmap_set_bit (imports, SSA_NAME_VERSION (op)); > + bitmap_set_bit (dependencies, SSA_NAME_VERSION (op)); > } > } > - m_query->compute_ranges (m_path, imports); > } > diff --git a/gcc/tree-ssa-threadedge.h b/gcc/tree-ssa-threadedge.h > index ca70b33f5ed..790ac2ea538 100644 > --- a/gcc/tree-ssa-threadedge.h > +++ b/gcc/tree-ssa-threadedge.h > @@ -69,11 +69,12 @@ public: > tree simplify (gimple *stmt, gimple *, basic_block, jt_state *) override; > > private: > - void compute_ranges_from_state (gimple *stmt, jt_state *); > + void compute_exit_dependencies (bitmap dependencies, > + const vec &path, > + gimple *stmt); > > gimple_ranger *m_ranger; > path_range_query *m_query; > - auto_vec m_path; > }; > > // This is the high level threader. The entry point is > -- > 2.37.1 > --000000000000acc21105e67f59bd Content-Type: text/x-patch; charset="US-ASCII"; name="0001-Make-path_range_query-standalone-and-add-reset_path.patch" Content-Disposition: attachment; filename="0001-Make-path_range_query-standalone-and-add-reset_path.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_l6yr161a0 RnJvbSBmNWRhZDg4YTNlOWU3ZTkxMzJmOTY5MWIxZDM4OWM3Mzg4YjE5NGNjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbGR5IEhlcm5hbmRleiA8YWxkeWhAcmVkaGF0LmNvbT4KRGF0 ZTogV2VkLCAxNyBBdWcgMjAyMiAxMzoxODowMSArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIE1ha2Ug cGF0aF9yYW5nZV9xdWVyeSBzdGFuZGFsb25lIGFuZCBhZGQgcmVzZXRfcGF0aC4KCiVjaGFuZ2Ug ZnJvbSBjbGVhbiB0byB0YWludGVkIGlzIC0wLjAxJQolY2hhbmdlIGZyb20gY2xlYW4gdG8gdGFp bnRlZCBpcyAwLjIyJQolY2hhbmdlIGZyb20gY2xlYW4gdG8gdGFpbnRlZCBpcyAwLjQ3JQoKVGhl c2UgYXJlIGEgYnVuY2ggb2YgY2xlYW51cHMgaW5zcGlyZWQgYnkgUmljaGkncyBzdWdnZXN0aW9u IG9mIG1ha2luZwpwYXRoX3JhbmdlX3F1ZXJ5IHN0YW5kYWxvbmUsIGluc3RlYWQgb2YgaGF2aW5n IHRvIGNhbGwKY29tcHV0ZV9yYW5nZXMoKSBmb3IgZWFjaCBwYXRoLgoKSSd2ZSBtYWRlIHRoZSBy YW5nZXIgbmVlZCBleHBsaWNpdCwgYW5kIG1vdmVkIHRoZSByZXNwb25zaWJpbGl0eSBmb3IKaXRz IGNyZWF0aW9uIHRvIHRoZSBjYWxsZXIuCgpJJ3ZlIGFsc28gaW52ZXN0aWdhdGVkIGFuZCBkb2N1 bWVudGVkIHdoeSB0aGUgZm9yd2FyZCB0aHJlYWRlciBuZWVkcyBpdHMKb3duIGNvbXB1dGUgZXhp dCBkZXBlbmRlbmNpZXMgdmFyaWFudC4gIEkgY2FuJ3Qgd2FpdCBmb3IgaXQgdG8gZ28gYXdheQo6 LS8uCgpJJ3ZlIGFsc28gYWRkZWQgY29uc3RydWN0b3JzIHRoYXQgdGFrZSBhIHBhdGggYW5kIGRl cGVuZGVuY2llcywgYW5kCm1hZGUgY29tcHV0ZV9yYW5nZXMoKSBwcml2YXRlLiAgVW5mb3J0dW5h dGVseSwgcmVpbnN0YW50aWF0aW5nCnBhdGhfcmFuZ2VfcXVlcnkgaW4gdGhlIGZvcndhcmQgdGhy ZWFkZXIgY2F1c2VkIGEgMTQlIHBlcmZvcm1hbmNlCnJlZ3Jlc3Npb24gaW4gRE9NLCBiZWNhdXNl IHRoZSBvbGQgdGhyZWFkZXIgY2FsbHMgaXQgb3ZlciBhbmQgb3ZlciBvbgp0aGUgc2FtZSBwYXRo IHRvIHNpbXBsaWZ5IHN0YXRlbWVudHMgKHNvbWUgb2Ygd2hpY2ggbm90IGV2ZW4gaW4gdGhlCklM LCBidXQgdGhhdCdzIG9sZCBuZXdzKS4KCkluIHRoZSBtZWFudGltZSwgSSd2ZSBsZWZ0IHRoZSBh YmlsaXR5IHRvIHJlc2V0IGEgcGF0aCwgYnV0IHRoaXMgdGltZQphcHByb3ByaWF0ZWx5IGNhbGxl ZCByZXNldF9wYXRoKCkuCgpUZXN0ZWQsIGJlbmNobWFya2VkLCBhbmQgdGhyZWFkIGNvdW50ZWQg b24geDg2LTY0IExpbnV4LgoKZ2NjL0NoYW5nZUxvZzoKCgkqIGdpbXBsZS1yYW5nZS1wYXRoLmNj IChwYXRoX3JhbmdlX3F1ZXJ5OjpwYXRoX3JhbmdlX3F1ZXJ5KTogQWRkCgl2YXJpb3VzIGNvbnN0 cnVjdG9ycyB0byB0YWtlIGEgcGF0aC4KCShwYXRoX3JhbmdlX3F1ZXJ5Ojp+cGF0aF9yYW5nZV9x dWVyeSk6IFJlbW92ZSBtX2FsbG9jZWRfcmFuZ2VyLgoJKHBhdGhfcmFuZ2VfcXVlcnk6OnJhbmdl X29uX3BhdGhfZW50cnkpOiBBZGp1c3QgZm9yIG1fcmFuZ2VyIGJlaW5nCglhIHJlZmVyZW5jZS4K CShwYXRoX3JhbmdlX3F1ZXJ5OjpzZXRfcGF0aCk6IFJlbmFtZSB0by4uLgoJKHBhdGhfcmFuZ2Vf cXVlcnk6OnJlc2V0X3BhdGgpOiAuLi50aGlzIGFuZCBjYWxsIGNvbXB1dGVfcmFuZ2VzLgoJKHBh dGhfcmFuZ2VfcXVlcnk6OnNzYV9yYW5nZV9pbl9waGkpOiBBZGp1c3QgZm9yIG1fcmFuZ2VyCgly ZWZlcmVuY2UuCgkocGF0aF9yYW5nZV9xdWVyeTo6cmFuZ2VfZGVmaW5lZF9pbl9ibG9jayk6IFNh bWUuCgkocGF0aF9yYW5nZV9xdWVyeTo6Y29tcHV0ZV9yYW5nZXNfaW5fYmxvY2spOiBTYW1lLgoJ KHBhdGhfcmFuZ2VfcXVlcnk6OmFkanVzdF9mb3Jfbm9uX251bGxfdXNlcyk6IFNhbWUuCgkocGF0 aF9yYW5nZV9xdWVyeTo6Y29tcHV0ZV9leGl0X2RlcGVuZGVuY2llcyk6IFVzZSBtX3BhdGggaW5z dGVhZAoJb2YgYXJndW1lbnQuCgkocGF0aF9yYW5nZV9xdWVyeTo6Y29tcHV0ZV9yYW5nZXMpOiBS ZW1vdmUgcGF0aCBhcmd1bWVudC4KCShwYXRoX3JhbmdlX3F1ZXJ5OjpyYW5nZV9vZl9zdG10KTog QWRqdXN0IGZvciBtX3JhbmdlciByZWZlcmVuY2UuCgkocGF0aF9yYW5nZV9xdWVyeTo6Y29tcHV0 ZV9vdXRnb2luZ19yZWxhdGlvbnMpOiBTYW1lLgoJKiBnaW1wbGUtcmFuZ2UtcGF0aC5oIChjbGFz cyBwYXRoX3JhbmdlX3F1ZXJ5KTogQWRkIHZhcmlvdXMKCWNvbnN0cnVjdG9ycy4KCU1ha2UgY29t cHV0ZV9yYW5nZXMgYW5kIGNvbXB1dGVfZXhpdF9kZXBlbmRlbmNpZXMgcHJpdmF0ZS4KCVJlbmFt ZSBzZXRfcGF0aCB0byByZXNldF9wYXRoLgoJTWFrZSBtX3JhbmdlciBhIHJlZmVyZW5jZS4KCVJl bW92ZSBtX2FsbG9jZWRfcmFuZ2VyLgoJKiB0cmVlLXNzYS1kb20uY2MgKHBhc3NfZG9taW5hdG9y OjpleGVjdXRlKTogQWRqdXN0IGNvbnN0cnVjdG9yIHRvCglwYXRoX3JhbmdlX3F1ZXJ5LgoJKiB0 cmVlLXNzYS1sb29wLWNoLmNjIChlbnRyeV9sb29wX2NvbmRpdGlvbl9pc19zdGF0aWMpOiBUYWtl IGEKCXJhbmdlciBhbmQgaW5zdGFudGlhdGUgYSBuZXcgcGF0aF9yYW5nZV9xdWVyeSBldmVyeSB0 aW1lLgoJKGNoX2Jhc2U6OmNvcHlfaGVhZGVycyk6IFBhc3MgcmFuZ2VyIGluc3RlYWQgb2YgcGF0 aF9yYW5nZV9xdWVyeS4KCSogdHJlZS1zc2EtdGhyZWFkYmFja3dhcmQuY2MgKGNsYXNzIGJhY2tf dGhyZWFkZXIpOiBSZW1vdmUgbV9zb2x2ZXIuCgkoYmFja190aHJlYWRlcjo6fmJhY2tfdGhyZWFk ZXIpOiBSZW1vdmUgbV9zb2x2ZXIuCgkoYmFja190aHJlYWRlcjo6ZmluZF90YWtlbl9lZGdlX3N3 aXRjaCk6IEFkanVzdCBmb3IgbV9yYW5nZXIKCXJlZmVyZW5jZS4KCShiYWNrX3RocmVhZGVyOjpm aW5kX3Rha2VuX2VkZ2VfY29uZCk6IFNhbWUuCgkoYmFja190aHJlYWRlcjo6ZHVtcCk6IFJlbW92 ZSBtX3NvbHZlci4KCShiYWNrX3RocmVhZGVyOjpiYWNrX3RocmVhZGVyKTogTW92ZSB2ZXJpZnlf bWFya2VkX2JhY2tlZGdlcwoJaGVyZSBmcm9tIHRoZSBwYXRoX3JhbmdlX3F1ZXJ5IGNvbnN0cnVj dG9yLgoJKiB0cmVlLXNzYS10aHJlYWRlZGdlLmNjIChoeWJyaWRfanRfc2ltcGxpZmllcjo6c2lt cGxpZnkpOiBNb3ZlCglzb21lIGNvZGUgZnJvbSBjb21wdXRlX3Jhbmdlc19mcm9tX3N0YXRlIGhl cmUuCgkoaHlicmlkX2p0X3NpbXBsaWZpZXI6OmNvbXB1dGVfcmFuZ2VzX2Zyb21fc3RhdGUpOiBS ZW5hbWUuLi4KCShoeWJyaWRfanRfc2ltcGxpZmllcjo6Y29tcHV0ZV9leGl0X2RlcGVuZGVuY2ll cyk6IC4uLnRvIHRoaXMuCgkqIHRyZWUtc3NhLXRocmVhZGVkZ2UuaCAoY2xhc3MgaHlicmlkX2p0 X3NpbXBsaWZpZXIpOiBSZW5hbWUKCWNvbXB1dGVfcmFuZ2VzX2Zyb21fc3RhdGUgdG8gY29tcHV0 ZV9leGl0X2RlcGVuZGVuY2llcy4KCVJlbW92ZSBtX3BhdGguCi0tLQogZ2NjL2dpbXBsZS1yYW5n ZS1wYXRoLmNjICAgICAgIHwgMTE0ICsrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLQog Z2NjL2dpbXBsZS1yYW5nZS1wYXRoLmggICAgICAgIHwgIDIyICsrKy0tLS0KIGdjYy90cmVlLXNz YS1kb20uY2MgICAgICAgICAgICB8ICAgMiArLQogZ2NjL3RyZWUtc3NhLWxvb3AtY2guY2MgICAg ICAgIHwgIDEyICsrLS0KIGdjYy90cmVlLXNzYS10aHJlYWRiYWNrd2FyZC5jYyB8ICAyNyArKysr LS0tLQogZ2NjL3RyZWUtc3NhLXRocmVhZGVkZ2UuY2MgICAgIHwgIDMwICsrKysrLS0tLQogZ2Nj L3RyZWUtc3NhLXRocmVhZGVkZ2UuaCAgICAgIHwgICA1ICstCiA3IGZpbGVzIGNoYW5nZWQsIDEx MiBpbnNlcnRpb25zKCspLCAxMDAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZ2NjL2dpbXBs ZS1yYW5nZS1wYXRoLmNjIGIvZ2NjL2dpbXBsZS1yYW5nZS1wYXRoLmNjCmluZGV4IGZmOTkxYjdh ZTFiLi5iYTdjMmVkOWI0NyAxMDA2NDQKLS0tIGEvZ2NjL2dpbXBsZS1yYW5nZS1wYXRoLmNjCisr KyBiL2djYy9naW1wbGUtcmFuZ2UtcGF0aC5jYwpAQCAtMzYsMzMgKzM2LDUyIEBAIGFsb25nIHdp dGggR0NDOyBzZWUgdGhlIGZpbGUgQ09QWUlORzMuICBJZiBub3Qgc2VlCiAvLyBJbnRlcm5hbCBj b25zdHJ1Y3QgdG8gaGVscCBmYWNpbGl0YXRlIGRlYnVnZ2luZyBvZiBzb2x2ZXIuCiAjZGVmaW5l IERFQlVHX1NPTFZFUiAoZHVtcF9maWxlICYmIChwYXJhbV90aHJlYWRlcl9kZWJ1ZyA9PSBUSFJF QURFUl9ERUJVR19BTEwpKQogCi1wYXRoX3JhbmdlX3F1ZXJ5OjpwYXRoX3JhbmdlX3F1ZXJ5IChi b29sIHJlc29sdmUsIGdpbXBsZV9yYW5nZXIgKnJhbmdlcikKK3BhdGhfcmFuZ2VfcXVlcnk6OnBh dGhfcmFuZ2VfcXVlcnkgKGdpbXBsZV9yYW5nZXIgJnJhbmdlciwKKwkJCQkgICAgY29uc3QgdmVj PGJhc2ljX2Jsb2NrPiAmcGF0aCwKKwkJCQkgICAgY29uc3QgYml0bWFwX2hlYWQgKmRlcGVuZGVu Y2llcywKKwkJCQkgICAgYm9vbCByZXNvbHZlKQogICA6IG1fY2FjaGUgKG5ldyBzc2FfZ2xvYmFs X2NhY2hlKSwKICAgICBtX2hhc19jYWNoZV9lbnRyeSAoQklUTUFQX0FMTE9DIChOVUxMKSksCi0g ICAgbV9yZXNvbHZlIChyZXNvbHZlKSwKLSAgICBtX2FsbG9jZWRfcmFuZ2VyICghcmFuZ2VyKQor ICAgIG1fcmFuZ2VyIChyYW5nZXIpLAorICAgIG1fcmVzb2x2ZSAocmVzb2x2ZSkKIHsKLSAgaWYg KG1fYWxsb2NlZF9yYW5nZXIpCi0gICAgbV9yYW5nZXIgPSBuZXcgZ2ltcGxlX3JhbmdlcjsKLSAg ZWxzZQotICAgIG1fcmFuZ2VyID0gcmFuZ2VyOworICBtX29yYWNsZSA9IG5ldyBwYXRoX29yYWNs ZSAobV9yYW5nZXIub3JhY2xlICgpKTsKKworICByZXNldF9wYXRoIChwYXRoLCBkZXBlbmRlbmNp ZXMpOworfQogCi0gIG1fb3JhY2xlID0gbmV3IHBhdGhfb3JhY2xlIChtX3Jhbmdlci0+b3JhY2xl ICgpKTsKK3BhdGhfcmFuZ2VfcXVlcnk6OnBhdGhfcmFuZ2VfcXVlcnkgKGdpbXBsZV9yYW5nZXIg JnJhbmdlciwgYm9vbCByZXNvbHZlKQorICA6IG1fY2FjaGUgKG5ldyBzc2FfZ2xvYmFsX2NhY2hl KSwKKyAgICBtX2hhc19jYWNoZV9lbnRyeSAoQklUTUFQX0FMTE9DIChOVUxMKSksCisgICAgbV9y YW5nZXIgKHJhbmdlciksCisgICAgbV9yZXNvbHZlIChyZXNvbHZlKQoreworICBtX29yYWNsZSA9 IG5ldyBwYXRoX29yYWNsZSAobV9yYW5nZXIub3JhY2xlICgpKTsKK30KIAotICBpZiAobV9yZXNv bHZlICYmIGZsYWdfY2hlY2tpbmcpCi0gICAgdmVyaWZ5X21hcmtlZF9iYWNrZWRnZXMgKGNmdW4p OworcGF0aF9yYW5nZV9xdWVyeTo6cGF0aF9yYW5nZV9xdWVyeSAoZ2ltcGxlX3JhbmdlciAmcmFu Z2VyLAorCQkJCSAgICBlZGdlIGUsCisJCQkJICAgIGJvb2wgcmVzb2x2ZSkKKyAgOiBtX2NhY2hl IChuZXcgc3NhX2dsb2JhbF9jYWNoZSksCisgICAgbV9oYXNfY2FjaGVfZW50cnkgKEJJVE1BUF9B TExPQyAoTlVMTCkpLAorICAgIG1fcmFuZ2VyIChyYW5nZXIpLAorICAgIG1fcmVzb2x2ZSAocmVz b2x2ZSkKK3sKKyAgbV9vcmFjbGUgPSBuZXcgcGF0aF9vcmFjbGUgKG1fcmFuZ2VyLm9yYWNsZSAo KSk7CisgIGF1dG9fdmVjPGJhc2ljX2Jsb2NrPiBiYnMgKDIpOworICBiYnMucXVpY2tfcHVzaCAo ZS0+ZGVzdCk7CisgIGJicy5xdWlja19wdXNoIChlLT5zcmMpOworICByZXNldF9wYXRoIChiYnMs IE5VTEwpOwogfQogCiBwYXRoX3JhbmdlX3F1ZXJ5Ojp+cGF0aF9yYW5nZV9xdWVyeSAoKQogewog ICBkZWxldGUgbV9vcmFjbGU7Ci0gIGlmIChtX2FsbG9jZWRfcmFuZ2VyKQotICAgIGRlbGV0ZSBt X3JhbmdlcjsKICAgQklUTUFQX0ZSRUUgKG1faGFzX2NhY2hlX2VudHJ5KTsKICAgZGVsZXRlIG1f Y2FjaGU7CiB9CiAKLS8vIFJldHVybiBUUlVFIGlmIE5BTUUgaXMgYW4gZXhpdCBkZXBlbmVuY3kg Zm9yIHRoZSBwYXRoLgorLy8gUmV0dXJuIFRSVUUgaWYgTkFNRSBpcyBhbiBleGl0IGRlcGVuZGVu Y3kgZm9yIHRoZSBwYXRoLgogCiBib29sCiBwYXRoX3JhbmdlX3F1ZXJ5OjpleGl0X2RlcGVuZGVu Y3lfcCAodHJlZSBuYW1lKQpAQCAtMTUzLDcgKzE3Miw3IEBAIHBhdGhfcmFuZ2VfcXVlcnk6OnJh bmdlX29uX3BhdGhfZW50cnkgKHZyYW5nZSAmciwgdHJlZSBuYW1lKQogewogICBnY2NfY2hlY2tp bmdfYXNzZXJ0IChkZWZpbmVkX291dHNpZGVfcGF0aCAobmFtZSkpOwogICBiYXNpY19ibG9jayBl bnRyeSA9IGVudHJ5X2JiICgpOwotICBtX3Jhbmdlci0+cmFuZ2Vfb25fZW50cnkgKHIsIGVudHJ5 LCBuYW1lKTsKKyAgbV9yYW5nZXIucmFuZ2Vfb25fZW50cnkgKHIsIGVudHJ5LCBuYW1lKTsKIH0K IAogLy8gUmV0dXJuIHRoZSByYW5nZSBvZiBOQU1FIGF0IHRoZSBlbmQgb2YgdGhlIHBhdGggYmVp bmcgYW5hbHl6ZWQuCkBAIC0yMTEsMTkgKzIzMCwxOSBAQCBwYXRoX3JhbmdlX3F1ZXJ5Ojp1bnJl YWNoYWJsZV9wYXRoX3AgKCkKICAgcmV0dXJuIG1fdW5kZWZpbmVkX3BhdGg7CiB9CiAKLS8vIElu aXRpYWxpemUgdGhlIGN1cnJlbnQgcGF0aCB0byBQQVRILiAgVGhlIGN1cnJlbnQgYmxvY2sgaXMg c2V0IHRvCi0vLyB0aGUgZW50cnkgYmxvY2sgdG8gdGhlIHBhdGguCi0vLwotLy8gTm90ZSB0aGF0 IHRoZSBibG9ja3MgYXJlIGluIHJldmVyc2Ugb3JkZXIsIHNvIHRoZSBleGl0IGJsb2NrIGlzCi0v LyBwYXRoWzBdLgorLy8gUmVzZXQgdGhlIGN1cnJlbnQgcGF0aCB0byBQQVRILgogCiB2b2lkCi1w YXRoX3JhbmdlX3F1ZXJ5OjpzZXRfcGF0aCAoY29uc3QgdmVjPGJhc2ljX2Jsb2NrPiAmcGF0aCkK K3BhdGhfcmFuZ2VfcXVlcnk6OnJlc2V0X3BhdGggKGNvbnN0IHZlYzxiYXNpY19ibG9jaz4gJnBh dGgsCisJCQkgICAgICBjb25zdCBiaXRtYXBfaGVhZCAqZGVwZW5kZW5jaWVzKQogewogICBnY2Nf Y2hlY2tpbmdfYXNzZXJ0IChwYXRoLmxlbmd0aCAoKSA+IDEpOwogICBtX3BhdGggPSBwYXRoLmNv cHkgKCk7CiAgIG1fcG9zID0gbV9wYXRoLmxlbmd0aCAoKSAtIDE7CisgIG1fdW5kZWZpbmVkX3Bh dGggPSBmYWxzZTsKICAgYml0bWFwX2NsZWFyIChtX2hhc19jYWNoZV9lbnRyeSk7CisKKyAgY29t cHV0ZV9yYW5nZXMgKGRlcGVuZGVuY2llcyk7CiB9CiAKIGJvb2wKQEAgLTI0OCw3ICsyNjcsNyBA QCBwYXRoX3JhbmdlX3F1ZXJ5Ojpzc2FfcmFuZ2VfaW5fcGhpICh2cmFuZ2UgJnIsIGdwaGkgKnBo aSkKIAogICBpZiAoYXRfZW50cnkgKCkpCiAgICAgewotICAgICAgaWYgKG1fcmVzb2x2ZSAmJiBt X3Jhbmdlci0+cmFuZ2Vfb2ZfZXhwciAociwgbmFtZSwgcGhpKSkKKyAgICAgIGlmIChtX3Jlc29s dmUgJiYgbV9yYW5nZXIucmFuZ2Vfb2ZfZXhwciAociwgbmFtZSwgcGhpKSkKIAlyZXR1cm47CiAK ICAgICAgIC8vIFRyeSB0byBmb2xkIHRoZSBwaGkgZXhjbHVzaXZlbHkgd2l0aCBnbG9iYWwgb3Ig Y2FjaGVkIHZhbHVlcy4KQEAgLTI5MCw3ICszMDksNyBAQCBwYXRoX3JhbmdlX3F1ZXJ5Ojpzc2Ff cmFuZ2VfaW5fcGhpICh2cmFuZ2UgJnIsIGdwaGkgKnBoaSkKIAkgICAgcmFuZ2Vfb25fcGF0aF9l bnRyeSAociwgYXJnKTsKIAkgIGVsc2UKIAkgICAgci5zZXRfdmFyeWluZyAoVFJFRV9UWVBFIChu YW1lKSk7Ci0JICBtX3Jhbmdlci0+cmFuZ2Vfb25fZWRnZSAodG1wLCBlX2luLCBhcmcpOworCSAg bV9yYW5nZXIucmFuZ2Vfb25fZWRnZSAodG1wLCBlX2luLCBhcmcpOwogCSAgci5pbnRlcnNlY3Qg KHRtcCk7CiAJICByZXR1cm47CiAJfQpAQCAtMzI1LDcgKzM0NCw3IEBAIHBhdGhfcmFuZ2VfcXVl cnk6OnJhbmdlX2RlZmluZWRfaW5fYmxvY2sgKHZyYW5nZSAmciwgdHJlZSBuYW1lLCBiYXNpY19i bG9jayBiYikKICAgICB9CiAKICAgaWYgKGJiICYmIFBPSU5URVJfVFlQRV9QIChUUkVFX1RZUEUg KG5hbWUpKSkKLSAgICBtX3Jhbmdlci0+bV9jYWNoZS5tX2V4aXQubWF5YmVfYWRqdXN0X3Jhbmdl IChyLCBuYW1lLCBiYik7CisgICAgbV9yYW5nZXIubV9jYWNoZS5tX2V4aXQubWF5YmVfYWRqdXN0 X3JhbmdlIChyLCBuYW1lLCBiYik7CiAKICAgaWYgKERFQlVHX1NPTFZFUiAmJiAoYmIgfHwgIXIu dmFyeWluZ19wICgpKSkKICAgICB7CkBAIC00NDEsNyArNDYwLDcgQEAgcGF0aF9yYW5nZV9xdWVy eTo6Y29tcHV0ZV9yYW5nZXNfaW5fYmxvY2sgKGJhc2ljX2Jsb2NrIGJiKQogICAgICAgcC0+cmVz ZXRfcGF0aCAoKTsKICAgICB9CiAKLSAgZ29yaV9jb21wdXRlICZnID0gbV9yYW5nZXItPmdvcmkg KCk7CisgIGdvcmlfY29tcHV0ZSAmZyA9IG1fcmFuZ2VyLmdvcmkgKCk7CiAgIGJpdG1hcCBleHBv cnRzID0gZy5leHBvcnRzIChiYik7CiAgIEVYRUNVVEVfSUZfQU5EX0lOX0JJVE1BUCAobV9leGl0 X2RlcGVuZGVuY2llcywgZXhwb3J0cywgMCwgaSwgYmkpCiAgICAgewpAQCAtNDk1LDcgKzUxNCw3 IEBAIHBhdGhfcmFuZ2VfcXVlcnk6OmFkanVzdF9mb3Jfbm9uX251bGxfdXNlcyAoYmFzaWNfYmxv Y2sgYmIpCiAgICAgICBlbHNlCiAJci5zZXRfdmFyeWluZyAoVFJFRV9UWVBFIChuYW1lKSk7CiAK LSAgICAgIGlmIChtX3Jhbmdlci0+bV9jYWNoZS5tX2V4aXQubWF5YmVfYWRqdXN0X3JhbmdlIChy LCBuYW1lLCBiYikpCisgICAgICBpZiAobV9yYW5nZXIubV9jYWNoZS5tX2V4aXQubWF5YmVfYWRq dXN0X3JhbmdlIChyLCBuYW1lLCBiYikpCiAJc2V0X2NhY2hlIChyLCBuYW1lKTsKICAgICB9CiB9 CkBAIC01MTUsMTIgKzUzNCwxMSBAQCBwYXRoX3JhbmdlX3F1ZXJ5OjphZGRfdG9fZXhpdF9kZXBl bmRlbmNpZXMgKHRyZWUgbmFtZSwgYml0bWFwIGRlcGVuZGVuY2llcykKIC8vIFNTQSBuYW1lcyB1 c2VkIHRvIGNhbGN1bGF0ZSB0aGUgZmluYWwgY29uZGl0aW9uYWwgYWxvbmcgdGhlIHBhdGguCiAK IHZvaWQKLXBhdGhfcmFuZ2VfcXVlcnk6OmNvbXB1dGVfZXhpdF9kZXBlbmRlbmNpZXMgKGJpdG1h cCBkZXBlbmRlbmNpZXMsCi0JCQkJCSAgICAgY29uc3QgdmVjPGJhc2ljX2Jsb2NrPiAmcGF0aCkK K3BhdGhfcmFuZ2VfcXVlcnk6OmNvbXB1dGVfZXhpdF9kZXBlbmRlbmNpZXMgKGJpdG1hcCBkZXBl bmRlbmNpZXMpCiB7CiAgIC8vIFN0YXJ0IHdpdGggdGhlIGltcG9ydHMgZnJvbSB0aGUgZXhpdCBi bG9jay4uLgotICBiYXNpY19ibG9jayBleGl0ID0gcGF0aFswXTsKLSAgZ29yaV9jb21wdXRlICZn b3JpID0gbV9yYW5nZXItPmdvcmkgKCk7CisgIGJhc2ljX2Jsb2NrIGV4aXQgPSBtX3BhdGhbMF07 CisgIGdvcmlfY29tcHV0ZSAmZ29yaSA9IG1fcmFuZ2VyLmdvcmkgKCk7CiAgIGJpdG1hcF9jb3B5 IChkZXBlbmRlbmNpZXMsIGdvcmkuaW1wb3J0cyAoZXhpdCkpOwogCiAgIGF1dG9fdmVjPHRyZWU+ IHdvcmtsaXN0IChiaXRtYXBfY291bnRfYml0cyAoZGVwZW5kZW5jaWVzKSk7CkBAIC01MzgsNyAr NTU2LDcgQEAgcGF0aF9yYW5nZV9xdWVyeTo6Y29tcHV0ZV9leGl0X2RlcGVuZGVuY2llcyAoYml0 bWFwIGRlcGVuZGVuY2llcywKICAgICAgIHRyZWUgbmFtZSA9IHdvcmtsaXN0LnBvcCAoKTsKICAg ICAgIGdpbXBsZSAqZGVmX3N0bXQgPSBTU0FfTkFNRV9ERUZfU1RNVCAobmFtZSk7CiAgICAgICBp ZiAoU1NBX05BTUVfSVNfREVGQVVMVF9ERUYgKG5hbWUpCi0JICB8fCAhcGF0aC5jb250YWlucyAo Z2ltcGxlX2JiIChkZWZfc3RtdCkpKQorCSAgfHwgIW1fcGF0aC5jb250YWlucyAoZ2ltcGxlX2Ji IChkZWZfc3RtdCkpKQogCWNvbnRpbnVlOwogCiAgICAgICBpZiAoZ3BoaSAqcGhpID0gZHluX2Nh c3QgPGdwaGkgKj4gKGRlZl9zdG10KSkKQEAgLTU0OSw3ICs1NjcsNyBAQCBwYXRoX3JhbmdlX3F1 ZXJ5Ojpjb21wdXRlX2V4aXRfZGVwZW5kZW5jaWVzIChiaXRtYXAgZGVwZW5kZW5jaWVzLAogCSAg ICAgIHRyZWUgYXJnID0gZ2ltcGxlX3BoaV9hcmcgKHBoaSwgaSktPmRlZjsKIAogCSAgICAgIGlm IChUUkVFX0NPREUgKGFyZykgPT0gU1NBX05BTUUKLQkJICAmJiBwYXRoLmNvbnRhaW5zIChlLT5z cmMpCisJCSAgJiYgbV9wYXRoLmNvbnRhaW5zIChlLT5zcmMpCiAJCSAgJiYgYml0bWFwX3NldF9i aXQgKGRlcGVuZGVuY2llcywgU1NBX05BTUVfVkVSU0lPTiAoYXJnKSkpCiAJCXdvcmtsaXN0LnNh ZmVfcHVzaCAoYXJnKTsKIAkgICAgfQpAQCAtNTY1LDkgKzU4Myw5IEBAIHBhdGhfcmFuZ2VfcXVl cnk6OmNvbXB1dGVfZXhpdF9kZXBlbmRlbmNpZXMgKGJpdG1hcCBkZXBlbmRlbmNpZXMsCiAgICAg fQogICAvLyBFeHBvcnRlZCBib29sZWFucyBhbG9uZyB0aGUgcGF0aCwgbWF5IGhlbHAgY29uZGl0 aW9uYWxzLgogICBpZiAobV9yZXNvbHZlKQotICAgIGZvciAoaSA9IDA7IGkgPCBwYXRoLmxlbmd0 aCAoKTsgKytpKQorICAgIGZvciAoaSA9IDA7IGkgPCBtX3BhdGgubGVuZ3RoICgpOyArK2kpCiAg ICAgICB7Ci0JYmFzaWNfYmxvY2sgYmIgPSBwYXRoW2ldOworCWJhc2ljX2Jsb2NrIGJiID0gbV9w YXRoW2ldOwogCXRyZWUgbmFtZTsKIAlGT1JfRUFDSF9HT1JJX0VYUE9SVF9OQU1FIChnb3JpLCBi YiwgbmFtZSkKIAkgIGlmIChUUkVFX0NPREUgKFRSRUVfVFlQRSAobmFtZSkpID09IEJPT0xFQU5f VFlQRSkKQEAgLTU4MywzMiArNjAxLDI4IEBAIHBhdGhfcmFuZ2VfcXVlcnk6OmNvbXB1dGVfZXhp dF9kZXBlbmRlbmNpZXMgKGJpdG1hcCBkZXBlbmRlbmNpZXMsCiAvLyBjYWxjdWxhdGVkIGZyb20g dGhlIGZpbmFsIGNvbmRpdGlvbmFsIGluIHRoZSBwYXRoLgogCiB2b2lkCi1wYXRoX3JhbmdlX3F1 ZXJ5Ojpjb21wdXRlX3JhbmdlcyAoY29uc3QgdmVjPGJhc2ljX2Jsb2NrPiAmcGF0aCwKLQkJCQkg IGNvbnN0IGJpdG1hcF9oZWFkICpkZXBlbmRlbmNpZXMpCitwYXRoX3JhbmdlX3F1ZXJ5Ojpjb21w dXRlX3JhbmdlcyAoY29uc3QgYml0bWFwX2hlYWQgKmRlcGVuZGVuY2llcykKIHsKICAgaWYgKERF QlVHX1NPTFZFUikKICAgICBmcHJpbnRmIChkdW1wX2ZpbGUsICJcbj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT1cbiIpOwogCi0gIHNldF9wYXRoIChwYXRoKTsK LSAgbV91bmRlZmluZWRfcGF0aCA9IGZhbHNlOwotCiAgIGlmIChkZXBlbmRlbmNpZXMpCiAgICAg Yml0bWFwX2NvcHkgKG1fZXhpdF9kZXBlbmRlbmNpZXMsIGRlcGVuZGVuY2llcyk7CiAgIGVsc2UK LSAgICBjb21wdXRlX2V4aXRfZGVwZW5kZW5jaWVzIChtX2V4aXRfZGVwZW5kZW5jaWVzLCBtX3Bh dGgpOworICAgIGNvbXB1dGVfZXhpdF9kZXBlbmRlbmNpZXMgKG1fZXhpdF9kZXBlbmRlbmNpZXMp OwogCiAgIGlmIChtX3Jlc29sdmUpCiAgICAgewogICAgICAgcGF0aF9vcmFjbGUgKnAgPSBnZXRf cGF0aF9vcmFjbGUgKCk7Ci0gICAgICBwLT5yZXNldF9wYXRoIChtX3Jhbmdlci0+b3JhY2xlICgp KTsKKyAgICAgIHAtPnJlc2V0X3BhdGggKG1fcmFuZ2VyLm9yYWNsZSAoKSk7CiAgICAgfQogCiAg IGlmIChERUJVR19TT0xWRVIpCiAgICAgewogICAgICAgZnByaW50ZiAoZHVtcF9maWxlLCAicGF0 aF9yYW5nZV9xdWVyeTogY29tcHV0ZV9yYW5nZXMgZm9yIHBhdGg6ICIpOwotICAgICAgZm9yICh1 bnNpZ25lZCBpID0gcGF0aC5sZW5ndGggKCk7IGkgPiAwOyAtLWkpCisgICAgICBmb3IgKHVuc2ln bmVkIGkgPSBtX3BhdGgubGVuZ3RoICgpOyBpID4gMDsgLS1pKQogCXsKLQkgIGJhc2ljX2Jsb2Nr IGJiID0gcGF0aFtpIC0gMV07CisJICBiYXNpY19ibG9jayBiYiA9IG1fcGF0aFtpIC0gMV07CiAJ ICBmcHJpbnRmIChkdW1wX2ZpbGUsICIlZCIsIGJiLT5pbmRleCk7CiAJICBpZiAoaSA+IDEpCiAJ ICAgIGZwcmludGYgKGR1bXBfZmlsZSwgIi0+Iik7CkBAIC02MzYsMTggKzY1MCw2IEBAIHBhdGhf cmFuZ2VfcXVlcnk6OmNvbXB1dGVfcmFuZ2VzIChjb25zdCB2ZWM8YmFzaWNfYmxvY2s+ICZwYXRo LAogICAgIH0KIH0KIAotLy8gQ29udmVuaWVuY2UgZnVuY3Rpb24gdG8gY29tcHV0ZSByYW5nZXMg YWxvbmcgYSBwYXRoIGNvbnNpc3Rpbmcgb2YKLS8vIEUtPlNSQyBhbmQgRS0+REVTVC4KLQotdm9p ZAotcGF0aF9yYW5nZV9xdWVyeTo6Y29tcHV0ZV9yYW5nZXMgKGVkZ2UgZSkKLXsKLSAgYXV0b192 ZWM8YmFzaWNfYmxvY2s+IGJicyAoMik7Ci0gIGJicy5xdWlja19wdXNoIChlLT5kZXN0KTsKLSAg YmJzLnF1aWNrX3B1c2ggKGUtPnNyYyk7Ci0gIGNvbXB1dGVfcmFuZ2VzIChiYnMpOwotfQotCiAv LyBBIGZvbGRpbmcgYWlkIHVzZWQgdG8gcmVnaXN0ZXIgYW5kIHF1ZXJ5IHJlbGF0aW9ucyBhbG9u ZyBhIHBhdGguCiAvLyBXaGVuIHF1ZXJpZWQsIGl0IHJldHVybnMgcmVsYXRpb25zIGFzIHRoZXkg d291bGQgYXBwZWFyIG9uIGV4aXQgdG8KIC8vIHRoZSBwYXRoLgpAQCAtNzMwLDcgKzczMiw3IEBA IHBhdGhfcmFuZ2VfcXVlcnk6OnJhbmdlX29mX3N0bXQgKHZyYW5nZSAmciwgZ2ltcGxlICpzdG10 LCB0cmVlKQogICBpZiAobV9yZXNvbHZlKQogICAgIHsKICAgICAgIGZvbGRfdXNpbmdfcmFuZ2Ug ZjsKLSAgICAgIGp0X2Z1cl9zb3VyY2Ugc3JjIChzdG10LCB0aGlzLCAmbV9yYW5nZXItPmdvcmkg KCksIG1fcGF0aCk7CisgICAgICBqdF9mdXJfc291cmNlIHNyYyAoc3RtdCwgdGhpcywgJm1fcmFu Z2VyLmdvcmkgKCksIG1fcGF0aCk7CiAgICAgICBpZiAoIWYuZm9sZF9zdG10IChyLCBzdG10LCBz cmMpKQogCXIuc2V0X3ZhcnlpbmcgKHR5cGUpOwogICAgIH0KQEAgLTgyMCw3ICs4MjIsNyBAQCBw YXRoX3JhbmdlX3F1ZXJ5Ojpjb21wdXRlX291dGdvaW5nX3JlbGF0aW9ucyAoYmFzaWNfYmxvY2sg YmIsIGJhc2ljX2Jsb2NrIG5leHQpCiAgICAgICBlbHNlCiAJZ2NjX3VucmVhY2hhYmxlICgpOwog Ci0gICAgICBqdF9mdXJfc291cmNlIHNyYyAoTlVMTCwgdGhpcywgJm1fcmFuZ2VyLT5nb3JpICgp LCBtX3BhdGgpOworICAgICAganRfZnVyX3NvdXJjZSBzcmMgKE5VTEwsIHRoaXMsICZtX3Jhbmdl ci5nb3JpICgpLCBtX3BhdGgpOwogICAgICAgc3JjLnJlZ2lzdGVyX291dGdvaW5nX2VkZ2VzIChj b25kLCByLCBlMCwgZTEpOwogICAgIH0KIH0KZGlmZiAtLWdpdCBhL2djYy9naW1wbGUtcmFuZ2Ut cGF0aC5oIGIvZ2NjL2dpbXBsZS1yYW5nZS1wYXRoLmgKaW5kZXggM2NiNzk0ZTM0YTkuLjQ4M2Zk ZTBkNDMxIDEwMDY0NAotLS0gYS9nY2MvZ2ltcGxlLXJhbmdlLXBhdGguaAorKysgYi9nY2MvZ2lt cGxlLXJhbmdlLXBhdGguaApAQCAtMzIsMTMgKzMyLDE0IEBAIGFsb25nIHdpdGggR0NDOyBzZWUg dGhlIGZpbGUgQ09QWUlORzMuICBJZiBub3Qgc2VlCiBjbGFzcyBwYXRoX3JhbmdlX3F1ZXJ5IDog cHVibGljIHJhbmdlX3F1ZXJ5CiB7CiBwdWJsaWM6Ci0gIHBhdGhfcmFuZ2VfcXVlcnkgKGJvb2wg cmVzb2x2ZSA9IHRydWUsIGNsYXNzIGdpbXBsZV9yYW5nZXIgKnJhbmdlciA9IE5VTEwpOworICBw YXRoX3JhbmdlX3F1ZXJ5IChjbGFzcyBnaW1wbGVfcmFuZ2VyICZyYW5nZXIsCisJCSAgICBjb25z dCB2ZWM8YmFzaWNfYmxvY2s+ICZwYXRoLAorCQkgICAgY29uc3QgYml0bWFwX2hlYWQgKmRlcGVu ZGVuY2llcyA9IE5VTEwsCisJCSAgICBib29sIHJlc29sdmUgPSB0cnVlKTsKKyAgcGF0aF9yYW5n ZV9xdWVyeSAoZ2ltcGxlX3JhbmdlciAmcmFuZ2VyLCBib29sIHJlc29sdmUgPSB0cnVlKTsKKyAg cGF0aF9yYW5nZV9xdWVyeSAoZ2ltcGxlX3JhbmdlciAmcmFuZ2VyLCBlZGdlIGUsIGJvb2wgcmVz b2x2ZSA9IHRydWUpOwogICB2aXJ0dWFsIH5wYXRoX3JhbmdlX3F1ZXJ5ICgpOwotICB2b2lkIGNv bXB1dGVfcmFuZ2VzIChjb25zdCB2ZWM8YmFzaWNfYmxvY2s+ICYsCi0JCSAgICAgICBjb25zdCBi aXRtYXBfaGVhZCAqZGVwZW5kZW5jaWVzID0gTlVMTCk7Ci0gIHZvaWQgY29tcHV0ZV9yYW5nZXMg KGVkZ2UgZSk7Ci0gIHZvaWQgY29tcHV0ZV9leGl0X2RlcGVuZGVuY2llcyAoYml0bWFwIGRlcGVu ZGVuY2llcywKLQkJCQkgIGNvbnN0IHZlYzxiYXNpY19ibG9jaz4gJik7CisgIHZvaWQgcmVzZXRf cGF0aCAoY29uc3QgdmVjPGJhc2ljX2Jsb2NrPiAmLCBjb25zdCBiaXRtYXBfaGVhZCAqZGVwZW5k ZW5jaWVzKTsKICAgYm9vbCByYW5nZV9vZl9leHByICh2cmFuZ2UgJnIsIHRyZWUgbmFtZSwgZ2lt cGxlICogPSBOVUxMKSBvdmVycmlkZTsKICAgYm9vbCByYW5nZV9vZl9zdG10ICh2cmFuZ2UgJnIs IGdpbXBsZSAqLCB0cmVlIG5hbWUgPSBOVUxMKSBvdmVycmlkZTsKICAgYm9vbCB1bnJlYWNoYWJs ZV9wYXRoX3AgKCk7CkBAIC00Nyw2ICs0OCw4IEBAIHB1YmxpYzoKIAogcHJpdmF0ZToKICAgYm9v bCBpbnRlcm5hbF9yYW5nZV9vZl9leHByICh2cmFuZ2UgJnIsIHRyZWUgbmFtZSwgZ2ltcGxlICop OworICB2b2lkIGNvbXB1dGVfcmFuZ2VzIChjb25zdCBiaXRtYXBfaGVhZCAqZGVwZW5kZW5jaWVz KTsKKyAgdm9pZCBjb21wdXRlX2V4aXRfZGVwZW5kZW5jaWVzIChiaXRtYXBfaGVhZCAqZGVwZW5k ZW5jaWVzKTsKICAgYm9vbCBkZWZpbmVkX291dHNpZGVfcGF0aCAodHJlZSBuYW1lKTsKICAgdm9p ZCByYW5nZV9vbl9wYXRoX2VudHJ5ICh2cmFuZ2UgJnIsIHRyZWUgbmFtZSk7CiAgIHBhdGhfb3Jh Y2xlICpnZXRfcGF0aF9vcmFjbGUgKCkgeyByZXR1cm4gKHBhdGhfb3JhY2xlICopbV9vcmFjbGU7 IH0KQEAgLTcxLDcgKzc0LDYgQEAgcHJpdmF0ZToKICAgYm9vbCByZWxhdGlvbnNfbWF5X2JlX2lu dmFsaWRhdGVkIChlZGdlKTsKIAogICAvLyBQYXRoIG5hdmlnYXRpb24uCi0gIHZvaWQgc2V0X3Bh dGggKGNvbnN0IHZlYzxiYXNpY19ibG9jaz4gJik7CiAgIGJhc2ljX2Jsb2NrIGVudHJ5X2JiICgp IHsgcmV0dXJuIG1fcGF0aFttX3BhdGgubGVuZ3RoICgpIC0gMV07IH0KICAgYmFzaWNfYmxvY2sg ZXhpdF9iYiAoKSAgeyByZXR1cm4gbV9wYXRoWzBdOyB9CiAgIGJhc2ljX2Jsb2NrIGN1cnJfYmIg KCkgIHsgcmV0dXJuIG1fcGF0aFttX3Bvc107IH0KQEAgLTk5LDcgKzEwMSw3IEBAIHByaXZhdGU6 CiAKICAgLy8gQSByYW5nZXIgdXNlZCB0byByZXNvbHZlIHJhbmdlcyBmb3IgU1NBIG5hbWVzIHdo b3NlIHZhbHVlcyBjb21lCiAgIC8vIGZyb20gb3V0c2lkZSB0aGUgcGF0aC4KLSAgZ2ltcGxlX3Jh bmdlciAqbV9yYW5nZXI7CisgIGdpbXBsZV9yYW5nZXIgJm1fcmFuZ2VyOwogCiAgIC8vIEN1cnJl bnQgcGF0aCBwb3NpdGlvbi4KICAgdW5zaWduZWQgbV9wb3M7CkBAIC0xMDksMTAgKzExMSw2IEBA IHByaXZhdGU6CiAKICAgLy8gU2V0IGlmIHRoZXJlIHdlcmUgYW55IHVuZGVmaW5lZCBleHByZXNz aW9ucyB3aGlsZSBwcmUtY2FsY3VsYXRpbmcgcGF0aC4KICAgYm9vbCBtX3VuZGVmaW5lZF9wYXRo OwotCi0gIC8vIFRydWUgaWYgbV9yYW5nZXIgd2FzIGFsbG9jYXRlZCBpbiB0aGlzIGNsYXNzIGFu ZCBtdXN0IGJlIGZyZWVkIGF0Ci0gIC8vIGRlc3RydWN0aW9uLgotICBib29sIG1fYWxsb2NlZF9y YW5nZXI7CiB9OwogCiAjZW5kaWYgLy8gR0NDX1RSRUVfU1NBX1RIUkVBRFNPTFZFUl9ICmRpZmYg LS1naXQgYS9nY2MvdHJlZS1zc2EtZG9tLmNjIGIvZ2NjL3RyZWUtc3NhLWRvbS5jYwppbmRleCA0 NGRjMjdiNDY0Yy4uNTEzZTBjODgyNTQgMTAwNjQ0Ci0tLSBhL2djYy90cmVlLXNzYS1kb20uY2MK KysrIGIvZ2NjL3RyZWUtc3NhLWRvbS5jYwpAQCAtNzk4LDcgKzc5OCw3IEBAIHBhc3NfZG9taW5h dG9yOjpleGVjdXRlIChmdW5jdGlvbiAqZnVuKQogCiAgIC8qIFJlY3Vyc2l2ZWx5IHdhbGsgdGhl IGRvbWluYXRvciB0cmVlIG9wdGltaXppbmcgc3RhdGVtZW50cy4gICovCiAgIGdpbXBsZV9yYW5n ZXIgKnJhbmdlciA9IGVuYWJsZV9yYW5nZXIgKGZ1bik7Ci0gIHBhdGhfcmFuZ2VfcXVlcnkgcGF0 aF9xdWVyeSAoLypyZXNvbHZlPSovdHJ1ZSwgcmFuZ2VyKTsKKyAgcGF0aF9yYW5nZV9xdWVyeSBw YXRoX3F1ZXJ5ICgqcmFuZ2VyKTsKICAgZG9tX2p0X3NpbXBsaWZpZXIgc2ltcGxpZmllciAoYXZh aWxfZXhwcnNfc3RhY2ssIHJhbmdlciwgJnBhdGhfcXVlcnkpOwogICBkb21fanRfc3RhdGUgc3Rh dGUgKGNvbnN0X2FuZF9jb3BpZXMsIGF2YWlsX2V4cHJzX3N0YWNrKTsKICAganVtcF90aHJlYWRl ciB0aHJlYWRlciAoJnNpbXBsaWZpZXIsICZzdGF0ZSk7CmRpZmYgLS1naXQgYS9nY2MvdHJlZS1z c2EtbG9vcC1jaC5jYyBiL2djYy90cmVlLXNzYS1sb29wLWNoLmNjCmluZGV4IDNiOTFhODllYWY1 Li45NjgxNmI4OTI4NyAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUtc3NhLWxvb3AtY2guY2MKKysrIGIv Z2NjL3RyZWUtc3NhLWxvb3AtY2guY2MKQEAgLTQ5LDcgKzQ5LDcgQEAgYWxvbmcgd2l0aCBHQ0M7 IHNlZSB0aGUgZmlsZSBDT1BZSU5HMy4gIElmIG5vdCBzZWUKICAgIGJlIHN0YXRpY2FsbHkgZGV0 ZXJtaW5lZC4gICovCiAKIHN0YXRpYyBib29sCi1lbnRyeV9sb29wX2NvbmRpdGlvbl9pc19zdGF0 aWMgKGNsYXNzIGxvb3AgKmwsIHBhdGhfcmFuZ2VfcXVlcnkgKnF1ZXJ5KQorZW50cnlfbG9vcF9j b25kaXRpb25faXNfc3RhdGljIChjbGFzcyBsb29wICpsLCBnaW1wbGVfcmFuZ2VyICpyYW5nZXIp CiB7CiAgIGVkZ2UgZSA9IGxvb3BfcHJlaGVhZGVyX2VkZ2UgKGwpOwogICBnY29uZCAqbGFzdCA9 IHNhZmVfZHluX2Nhc3QgPGdjb25kICo+IChsYXN0X3N0bXQgKGUtPmRlc3QpKTsKQEAgLTcyLDgg KzcyLDggQEAgZW50cnlfbG9vcF9jb25kaXRpb25faXNfc3RhdGljIChjbGFzcyBsb29wICpsLCBw YXRoX3JhbmdlX3F1ZXJ5ICpxdWVyeSkKICAgICBkZXNpcmVkX3N0YXRpY192YWx1ZSA9IGJvb2xl YW5fdHJ1ZV9ub2RlOwogCiAgIGludF9yYW5nZTwyPiByOwotICBxdWVyeS0+Y29tcHV0ZV9yYW5n ZXMgKGUpOwotICBxdWVyeS0+cmFuZ2Vfb2Zfc3RtdCAociwgbGFzdCk7CisgIHBhdGhfcmFuZ2Vf cXVlcnkgcXVlcnkgKCpyYW5nZXIsIGUpOworICBxdWVyeS5yYW5nZV9vZl9zdG10IChyLCBsYXN0 KTsKICAgcmV0dXJuIHIgPT0gaW50X3JhbmdlPDI+IChkZXNpcmVkX3N0YXRpY192YWx1ZSwgZGVz aXJlZF9zdGF0aWNfdmFsdWUpOwogfQogCkBAIC0zODUsNyArMzg1LDcgQEAgY2hfYmFzZTo6Y29w eV9oZWFkZXJzIChmdW5jdGlvbiAqZnVuKQogICBhdXRvX3ZlYzxzdGQ6OnBhaXI8ZWRnZSwgbG9v cF9wPiA+IGNvcGllZDsKIAogICBtYXJrX2Rmc19iYWNrX2VkZ2VzICgpOwotICBwYXRoX3Jhbmdl X3F1ZXJ5ICpxdWVyeSA9IG5ldyBwYXRoX3JhbmdlX3F1ZXJ5OworICBnaW1wbGVfcmFuZ2VyICpy YW5nZXIgPSBuZXcgZ2ltcGxlX3JhbmdlcjsKICAgZm9yIChhdXRvIGxvb3AgOiBsb29wc19saXN0 IChjZnVuLCAwKSkKICAgICB7CiAgICAgICBpbnQgaW5pdGlhbF9saW1pdCA9IHBhcmFtX21heF9s b29wX2hlYWRlcl9pbnNuczsKQEAgLTQwOSw3ICs0MDksNyBAQCBjaF9iYXNlOjpjb3B5X2hlYWRl cnMgKGZ1bmN0aW9uICpmdW4pCiAJIGl0ZXJhdGlvbi4gICovCiAgICAgICBpZiAob3B0aW1pemVf bG9vcF9mb3Jfc2l6ZV9wIChsb29wKQogCSAgJiYgIWxvb3AtPmZvcmNlX3ZlY3Rvcml6ZQotCSAg JiYgIWVudHJ5X2xvb3BfY29uZGl0aW9uX2lzX3N0YXRpYyAobG9vcCwgcXVlcnkpKQorCSAgJiYg IWVudHJ5X2xvb3BfY29uZGl0aW9uX2lzX3N0YXRpYyAobG9vcCwgcmFuZ2VyKSkKIAl7CiAJICBp ZiAoZHVtcF9maWxlICYmIChkdW1wX2ZsYWdzICYgVERGX0RFVEFJTFMpKQogCSAgICBmcHJpbnRm IChkdW1wX2ZpbGUsCkBAIC00MjIsNyArNDIyLDcgQEAgY2hfYmFzZTo6Y29weV9oZWFkZXJzIChm dW5jdGlvbiAqZnVuKQogCWNhbmRpZGF0ZXMuc2FmZV9wdXNoIChsb29wKTsKICAgICB9CiAgIC8q IERvIG5vdCB1c2UgcmFuZ2VyIGFmdGVyIHdlIGNoYW5nZSB0aGUgSUwgYW5kIG5vdCBoYXZlIHVw ZGF0ZWQgU1NBLiAgKi8KLSAgZGVsZXRlIHF1ZXJ5OworICBkZWxldGUgcmFuZ2VyOwogCiAgIGZv ciAoYXV0byBsb29wIDogY2FuZGlkYXRlcykKICAgICB7CmRpZmYgLS1naXQgYS9nY2MvdHJlZS1z c2EtdGhyZWFkYmFja3dhcmQuY2MgYi9nY2MvdHJlZS1zc2EtdGhyZWFkYmFja3dhcmQuY2MKaW5k ZXggNzY5OGUxZjhiMTEuLjVhYjI2YjQ5MzdhIDEwMDY0NAotLS0gYS9nY2MvdHJlZS1zc2EtdGhy ZWFkYmFja3dhcmQuY2MKKysrIGIvZ2NjL3RyZWUtc3NhLXRocmVhZGJhY2t3YXJkLmNjCkBAIC0x MTYsNyArMTE2LDYgQEAgcHJpdmF0ZToKICAgdmlydHVhbCB2b2lkIGR1bXAgKEZJTEUgKm91dCk7 CiAKICAgYmFja190aHJlYWRlcl9yZWdpc3RyeSBtX3JlZ2lzdHJ5OwotICBwYXRoX3JhbmdlX3F1 ZXJ5ICptX3NvbHZlcjsKIAogICAvLyBDdXJyZW50IHBhdGggYmVpbmcgYW5hbHl6ZWQuCiAgIGF1 dG9fdmVjPGJhc2ljX2Jsb2NrPiBtX3BhdGg7CkBAIC0xMzYsNiArMTM1LDggQEAgcHJpdmF0ZToK ICAgLy8gd2l0aCB0aGUgcmFuZ2VyLiAgT3RoZXJ3aXNlLCB1bmtub3duIFNTQSBuYW1lcyBhcmUg YXNzdW1lZCB0byBiZQogICAvLyBWQVJZSU5HLiAgU2V0dGluZyB0byB0cnVlIGlzIG1vcmUgcHJl Y2lzZSBidXQgc2xvd2VyLgogICBmdW5jdGlvbiAqbV9mdW47CisgIC8vIFJhbmdlciBmb3IgdGhl IHBhdGggc29sdmVyLgorICBnaW1wbGVfcmFuZ2VyICptX3JhbmdlcjsKICAgdW5zaWduZWQgbV9m bGFnczsKICAgLy8gU2V0IHRvIFRSVUUgZm9yIHRoZSBmaXJzdCBvZiBlYWNoIHRocmVhZFsxMl0g cGFzcyBvciB0aGUgZmlyc3Qgb2YKICAgLy8gZWFjaCB0aHJlYWRmdWxsWzEyXSBwYXNzLiAgVGhp cyBpcyB1c2VkIHRvIGRpZmZlcmVudGlhdGUgYmV0d2VlbgpAQCAtMTYxLDE0ICsxNjIsMTkgQEAg YmFja190aHJlYWRlcjo6YmFja190aHJlYWRlciAoZnVuY3Rpb24gKmZ1biwgdW5zaWduZWQgZmxh Z3MsIGJvb2wgZmlyc3QpCiAKICAgLy8gVGhlIHBhdGggc29sdmVyIG5lZWRzIEVER0VfREZTX0JB Q0sgaW4gcmVzb2x2aW5nIG1vZGUuCiAgIGlmIChmbGFncyAmIEJUX1JFU09MVkUpCi0gICAgbWFy a19kZnNfYmFja19lZGdlcyAoKTsKLSAgbV9zb2x2ZXIgPSBuZXcgcGF0aF9yYW5nZV9xdWVyeSAo ZmxhZ3MgJiBCVF9SRVNPTFZFKTsKKyAgICB7CisgICAgICBtYXJrX2Rmc19iYWNrX2VkZ2VzICgp OworCisgICAgICBpZiAoZmxhZ19jaGVja2luZykKKwl2ZXJpZnlfbWFya2VkX2JhY2tlZGdlcyAo ZnVuKTsKKyAgICB9CisKKyAgbV9yYW5nZXIgPSBuZXcgZ2ltcGxlX3JhbmdlcjsKIH0KIAogYmFj a190aHJlYWRlcjo6fmJhY2tfdGhyZWFkZXIgKCkKIHsKLSAgZGVsZXRlIG1fc29sdmVyOwotCisg IGRlbGV0ZSBtX3JhbmdlcjsKICAgbG9vcF9vcHRpbWl6ZXJfZmluYWxpemUgKCk7CiB9CiAKQEAg LTMwNSw4ICszMTEsOCBAQCBiYWNrX3RocmVhZGVyOjpmaW5kX3Rha2VuX2VkZ2Vfc3dpdGNoIChj b25zdCB2ZWM8YmFzaWNfYmxvY2s+ICZwYXRoLAogICB0cmVlIG5hbWUgPSBnaW1wbGVfc3dpdGNo X2luZGV4IChzdyk7CiAgIGludF9yYW5nZV9tYXggcjsKIAotICBtX3NvbHZlci0+Y29tcHV0ZV9y YW5nZXMgKHBhdGgsIG1faW1wb3J0cyk7Ci0gIG1fc29sdmVyLT5yYW5nZV9vZl9leHByIChyLCBu YW1lLCBzdyk7CisgIHBhdGhfcmFuZ2VfcXVlcnkgc29sdmVyICgqbV9yYW5nZXIsIHBhdGgsIG1f aW1wb3J0cywgbV9mbGFncyAmIEJUX1JFU09MVkUpOworICBzb2x2ZXIucmFuZ2Vfb2ZfZXhwciAo ciwgbmFtZSwgc3cpOwogCiAgIGlmIChyLnVuZGVmaW5lZF9wICgpKQogICAgIHJldHVybiBVTlJF QUNIQUJMRV9FREdFOwpAQCAtMzI5LDEwICszMzUsMTAgQEAgYmFja190aHJlYWRlcjo6ZmluZF90 YWtlbl9lZGdlX2NvbmQgKGNvbnN0IHZlYzxiYXNpY19ibG9jaz4gJnBhdGgsCiB7CiAgIGludF9y YW5nZV9tYXggcjsKIAotICBtX3NvbHZlci0+Y29tcHV0ZV9yYW5nZXMgKHBhdGgsIG1faW1wb3J0 cyk7Ci0gIG1fc29sdmVyLT5yYW5nZV9vZl9zdG10IChyLCBjb25kKTsKKyAgcGF0aF9yYW5nZV9x dWVyeSBzb2x2ZXIgKCptX3JhbmdlciwgcGF0aCwgbV9pbXBvcnRzLCBtX2ZsYWdzICYgQlRfUkVT T0xWRSk7CisgIHNvbHZlci5yYW5nZV9vZl9zdG10IChyLCBjb25kKTsKIAotICBpZiAobV9zb2x2 ZXItPnVucmVhY2hhYmxlX3BhdGhfcCAoKSkKKyAgaWYgKHNvbHZlci51bnJlYWNoYWJsZV9wYXRo X3AgKCkpCiAgICAgcmV0dXJuIFVOUkVBQ0hBQkxFX0VER0U7CiAKICAgaW50X3JhbmdlPDI+IHRy dWVfcmFuZ2UgKGJvb2xlYW5fdHJ1ZV9ub2RlLCBib29sZWFuX3RydWVfbm9kZSk7CkBAIC01ODMs NyArNTg5LDYgQEAgZGVidWcgKGNvbnN0IHZlYyA8YmFzaWNfYmxvY2s+ICZwYXRoKQogdm9pZAog YmFja190aHJlYWRlcjo6ZHVtcCAoRklMRSAqb3V0KQogewotICBtX3NvbHZlci0+ZHVtcCAob3V0 KTsKICAgZnByaW50ZiAob3V0LCAiXG5DYW5kaWRhdGVzIGZvciBwcmUtY29tcHV0YXRpb246XG4i KTsKICAgZnByaW50ZiAob3V0LCAiPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT1c biIpOwogCmRpZmYgLS1naXQgYS9nY2MvdHJlZS1zc2EtdGhyZWFkZWRnZS5jYyBiL2djYy90cmVl LXNzYS10aHJlYWRlZGdlLmNjCmluZGV4IGU2NGU0ZjIwOWY3Li45MDVhOThjOGM2OCAxMDA2NDQK LS0tIGEvZ2NjL3RyZWUtc3NhLXRocmVhZGVkZ2UuY2MKKysrIGIvZ2NjL3RyZWUtc3NhLXRocmVh ZGVkZ2UuY2MKQEAgLTEzOTksNyArMTM5OSw2IEBAIGp0X3N0YXRlOjpyZWdpc3Rlcl9lcXVpdnNf c3RtdCAoZ2ltcGxlICpzdG10LCBiYXNpY19ibG9jayBiYiwKIAogLy8gSHlicmlkIHRocmVhZGVy IGltcGxlbWVudGF0aW9uLgogCi0KIGh5YnJpZF9qdF9zaW1wbGlmaWVyOjpoeWJyaWRfanRfc2lt cGxpZmllciAoZ2ltcGxlX3JhbmdlciAqciwKIAkJCQkJICAgIHBhdGhfcmFuZ2VfcXVlcnkgKnEp CiB7CkBAIC0xNDExLDcgKzE0MTAsMTIgQEAgdHJlZQogaHlicmlkX2p0X3NpbXBsaWZpZXI6OnNp bXBsaWZ5IChnaW1wbGUgKnN0bXQsIGdpbXBsZSAqLCBiYXNpY19ibG9jaywKIAkJCQlqdF9zdGF0 ZSAqc3RhdGUpCiB7Ci0gIGNvbXB1dGVfcmFuZ2VzX2Zyb21fc3RhdGUgKHN0bXQsIHN0YXRlKTsK KyAgYXV0b19iaXRtYXAgZGVwZW5kZW5jaWVzOworICBhdXRvX3ZlYzxiYXNpY19ibG9jaz4gcGF0 aDsKKworICBzdGF0ZS0+Z2V0X3BhdGggKHBhdGgpOworICBjb21wdXRlX2V4aXRfZGVwZW5kZW5j aWVzIChkZXBlbmRlbmNpZXMsIHBhdGgsIHN0bXQpOworICBtX3F1ZXJ5LT5yZXNldF9wYXRoIChw YXRoLCBkZXBlbmRlbmNpZXMpOwogCiAgIGlmIChnaW1wbGVfY29kZSAoc3RtdCkgPT0gR0lNUExF X0NPTkQKICAgICAgIHx8IGdpbXBsZV9jb2RlIChzdG10KSA9PSBHSU1QTEVfQVNTSUdOKQpAQCAt MTQzMiwyMiArMTQzNiwyNSBAQCBoeWJyaWRfanRfc2ltcGxpZmllcjo6c2ltcGxpZnkgKGdpbXBs ZSAqc3RtdCwgZ2ltcGxlICosIGJhc2ljX2Jsb2NrLAogICByZXR1cm4gTlVMTDsKIH0KIAotLy8g VXNlIFNUQVRFIHRvIGdlbmVyYXRlIHRoZSBsaXN0IG9mIGltcG9ydHMgbmVlZGVkIGZvciB0aGUg c29sdmVyLAotLy8gYW5kIGNhbGN1bGF0ZSB0aGUgcmFuZ2VzIGFsb25nIHRoZSBwYXRoLgorLy8g Q2FsY3VsYXRlIHRoZSBzZXQgb2YgZXhpdCBkZXBlbmRlbmNpZXMgZm9yIGEgcGF0aCBhbmQgc3Rh dGVtZW50IHRvCisvLyBiZSBzaW1wbGlmaWVkLiAgVGhpcyBpcyBkaWZmZXJlbnQgdGhhbiB0aGUK Ky8vIGNvbXB1dGVfZXhpdF9kZXBlbmRlbmNpZXMgaW4gdGhlIHBhdGggc29sdmVyIGJlY2F1c2Ug dGhlIGZvcndhcmQKKy8vIHRocmVhZGVyIGFza3MgcXVlc3Rpb25zIGFib3V0IHN0YXRlbWVudHMg bm90IG5lY2Vzc2FyaWx5IGluIHRoZQorLy8gcGF0aC4gIFVzaW5nIHRoZSBkZWZhdWx0IGNvbXB1 dGVfZXhpdF9kZXBlbmRlbmNpZXMgaW4gdGhlIHBhdGgKKy8vIHNvbHZlciBnZXRzIG5vdGljZWFi bHkgbGVzcyB0aHJlYWRzLgogCiB2b2lkCi1oeWJyaWRfanRfc2ltcGxpZmllcjo6Y29tcHV0ZV9y YW5nZXNfZnJvbV9zdGF0ZSAoZ2ltcGxlICpzdG10LCBqdF9zdGF0ZSAqc3RhdGUpCitoeWJyaWRf anRfc2ltcGxpZmllcjo6Y29tcHV0ZV9leGl0X2RlcGVuZGVuY2llcyAoYml0bWFwIGRlcGVuZGVu Y2llcywKKwkJCQkJCSBjb25zdCB2ZWM8YmFzaWNfYmxvY2s+ICZwYXRoLAorCQkJCQkJIGdpbXBs ZSAqc3RtdCkKIHsKLSAgYXV0b19iaXRtYXAgaW1wb3J0czsKICAgZ29yaV9jb21wdXRlICZnb3Jp ID0gbV9yYW5nZXItPmdvcmkgKCk7CiAKLSAgc3RhdGUtPmdldF9wYXRoIChtX3BhdGgpOwotCiAg IC8vIFN0YXJ0IHdpdGggdGhlIGltcG9ydHMgdG8gdGhlIGZpbmFsIGNvbmRpdGlvbmFsLgotICBi aXRtYXBfY29weSAoaW1wb3J0cywgZ29yaS5pbXBvcnRzIChtX3BhdGhbMF0pKTsKKyAgYml0bWFw X2NvcHkgKGRlcGVuZGVuY2llcywgZ29yaS5pbXBvcnRzIChwYXRoWzBdKSk7CiAKICAgLy8gQWRk IGFueSBvdGhlciBpbnRlcmVzdGluZyBvcGVyYW5kcyB3ZSBtYXkgaGF2ZSBtaXNzZWQuCi0gIGlm IChnaW1wbGVfYmIgKHN0bXQpICE9IG1fcGF0aFswXSkKKyAgaWYgKGdpbXBsZV9iYiAoc3RtdCkg IT0gcGF0aFswXSkKICAgICB7CiAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgZ2ltcGxl X251bV9vcHMgKHN0bXQpOyArK2kpCiAJewpAQCAtMTQ1NSw4ICsxNDYyLDcgQEAgaHlicmlkX2p0 X3NpbXBsaWZpZXI6OmNvbXB1dGVfcmFuZ2VzX2Zyb21fc3RhdGUgKGdpbXBsZSAqc3RtdCwganRf c3RhdGUgKnN0YXRlKQogCSAgaWYgKG9wCiAJICAgICAgJiYgVFJFRV9DT0RFIChvcCkgPT0gU1NB X05BTUUKIAkgICAgICAmJiBWYWx1ZV9SYW5nZTo6c3VwcG9ydHNfdHlwZV9wIChUUkVFX1RZUEUg KG9wKSkpCi0JICAgIGJpdG1hcF9zZXRfYml0IChpbXBvcnRzLCBTU0FfTkFNRV9WRVJTSU9OIChv cCkpOworCSAgICBiaXRtYXBfc2V0X2JpdCAoZGVwZW5kZW5jaWVzLCBTU0FfTkFNRV9WRVJTSU9O IChvcCkpOwogCX0KICAgICB9Ci0gIG1fcXVlcnktPmNvbXB1dGVfcmFuZ2VzIChtX3BhdGgsIGlt cG9ydHMpOwogfQpkaWZmIC0tZ2l0IGEvZ2NjL3RyZWUtc3NhLXRocmVhZGVkZ2UuaCBiL2djYy90 cmVlLXNzYS10aHJlYWRlZGdlLmgKaW5kZXggY2E3MGIzM2Y1ZWQuLjc5MGFjMmVhNTM4IDEwMDY0 NAotLS0gYS9nY2MvdHJlZS1zc2EtdGhyZWFkZWRnZS5oCisrKyBiL2djYy90cmVlLXNzYS10aHJl YWRlZGdlLmgKQEAgLTY5LDExICs2OSwxMiBAQCBwdWJsaWM6CiAgIHRyZWUgc2ltcGxpZnkgKGdp bXBsZSAqc3RtdCwgZ2ltcGxlICosIGJhc2ljX2Jsb2NrLCBqdF9zdGF0ZSAqKSBvdmVycmlkZTsK IAogcHJpdmF0ZToKLSAgdm9pZCBjb21wdXRlX3Jhbmdlc19mcm9tX3N0YXRlIChnaW1wbGUgKnN0 bXQsIGp0X3N0YXRlICopOworICB2b2lkIGNvbXB1dGVfZXhpdF9kZXBlbmRlbmNpZXMgKGJpdG1h cCBkZXBlbmRlbmNpZXMsCisJCQkJICBjb25zdCB2ZWM8YmFzaWNfYmxvY2s+ICZwYXRoLAorCQkJ CSAgZ2ltcGxlICpzdG10KTsKIAogICBnaW1wbGVfcmFuZ2VyICptX3JhbmdlcjsKICAgcGF0aF9y YW5nZV9xdWVyeSAqbV9xdWVyeTsKLSAgYXV0b192ZWM8YmFzaWNfYmxvY2s+IG1fcGF0aDsKIH07 CiAKIC8vIFRoaXMgaXMgdGhlIGhpZ2ggbGV2ZWwgdGhyZWFkZXIuICBUaGUgZW50cnkgcG9pbnQg aXMKLS0gCjIuMzcuMQoK --000000000000acc21105e67f59bd--