From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 14787 invoked by alias); 1 Aug 2013 16:32:53 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 14768 invoked by uid 89); 1 Aug 2013 16:32:52 -0000 X-Spam-SWARE-Status: No, score=-1.5 required=5.0 tests=AWL,BAYES_50,RCVD_IN_DNSWL_LOW,RCVD_IN_HOSTKARMA_YE,RDNS_NONE,SPF_PASS autolearn=no version=3.3.1 Received: from Unknown (HELO mail-qc0-f179.google.com) (209.85.216.179) by sourceware.org (qpsmtpd/0.84/v0.84-167-ge50287c) with ESMTP; Thu, 01 Aug 2013 16:32:50 +0000 Received: by mail-qc0-f179.google.com with SMTP id n10so1149281qcx.10 for ; Thu, 01 Aug 2013 09:32:43 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=mime-version:date:message-id:subject:from:to:cc:content-type :x-gm-message-state; bh=eF46Pcmt5tZ62du35Ks7ssPJZMrFpgBwUKuR1r1Qmno=; b=XyRbNx2o1MhrGX0XwTIkrmVrFtvCU0PH80zrOk4TgMn5SRyuZiKUCoh831Ud+PZ/LM PpHJuigSfSMleT18umveZStD58fE2dM+Plu2R+37F2HvOAiTtsEyX8Bh/gVtdNC3VmxX /Jr+SRXWapVjIkFTOdbDhkMbDT3SB5x1VyirjyTAU8Sjmdm/FJn0trFBD+MPUM4WkaLi s8UnV1kTjinAC2DsE5aT6r1vwa7lAz+5HDWpV7drAMXLTBQ5tDVKYx5WBzdhDxkB25TS yDxqZ3n3dMqL2X0NkzuJAkVzKpNEbsLF0GQEJCvekd86WnVSJNY7FXatkSr4M/II53Fj Pa7w== MIME-Version: 1.0 X-Received: by 10.224.124.137 with SMTP id u9mr5414624qar.91.1375374762861; Thu, 01 Aug 2013 09:32:42 -0700 (PDT) Received: by 10.49.71.69 with HTTP; Thu, 1 Aug 2013 09:32:42 -0700 (PDT) Date: Thu, 01 Aug 2013 16:32:00 -0000 Message-ID: Subject: [PATCH] Sanitize block partitioning under -freorder-blocks-and-partition From: Teresa Johnson To: "gcc-patches@gcc.gnu.org" Cc: Steven Bosscher , Jan Hubicka , Jeff Law Content-Type: multipart/mixed; boundary=001a11c2a42c2c922a04e2e564ee X-Gm-Message-State: ALoCoQl0xru6bQd7gwzG7+/wrRb8gl/ephtVNaWWV213AtkIAXNU5IfQh6uoGWm1LLR2bCwrry+/5ArtIPOUqhmBs1DLUa73hJEXKR3bcXvwPD6JdutbVuYU39v5YlzgjGRiqOyhOLBNqVei1MOmV94HfXQ1T7LH9S1dju+zYV0UbYEkzfWBsWnH0sTBYeiqEwhBIyHX88Ge8bTdVPFLdCgp0porGc9m2g== X-Virus-Found: No X-SW-Source: 2013-08/txt/msg00039.txt.bz2 --001a11c2a42c2c922a04e2e564ee Content-Type: text/plain; charset=ISO-8859-1 Content-length: 14587 Patch 3 of 3 split out from the patch I sent in May that fixes problems with -freorder-blocks-and-partition, with changes/fixes discussed in that thread. See http://gcc.gnu.org/ml/gcc-patches/2013-05/threads.html#00388 for context. This patch sanitizes the partitioning to address issues such as edge weight insanities that sometimes occur due to upstream optimizations, and ensures that hot blocks are not dominated by cold blocks. This needs to be resanitized after certain cfg optimizations that may cause hot blocks previously reached via both hot and cold paths to only be reached by cold paths. The verification code in sanitize_dominator_hotness was contributed by Steven Bosscher. Bootstrapped and tested on x86-64-unknown-linux-gnu. Also ensured that a profiledbootstrap passed with -freorder-blocks-and-partition enabled (and with the dwarf version changed to 2 to work around PR57451). Ok for trunk? (I also included the patch as an attachment since my mailer invariably messes up the formatting in the pasted version.) Thanks, Teresa 2013-08-01 Teresa Johnson Steven Bosscher * cfgrtl.c (fixup_bb_partition): New routine. (commit_edge_insertions): Invoke fixup_partitions. (find_partition_fixes): New routine. (fixup_partitions): Ditto. (verify_hot_cold_block_grouping): Update comments. (rtl_verify_edges): Invoke find_partition_fixes. (rtl_verify_bb_pointers): Update comments. (rtl_verify_bb_layout): Ditto. * basic-block.h (fixup_partitions): Declare. * cfgcleanup.c (try_optimize_cfg): Invoke fixup_partitions. * bb-reorder.c (sanitize_dominator_hotness): New function. (find_rarely_executed_basic_blocks_and_crossing_edges): Invoke sanitize_dominator_hotness. Index: cfgrtl.c =================================================================== --- cfgrtl.c (revision 201281) +++ cfgrtl.c (working copy) @@ -1341,6 +1341,34 @@ fixup_partition_crossing (edge e) } } +/* Called when block BB has been reassigned to a different partition, + to ensure that the region crossing attributes are updated. */ + +static void +fixup_bb_partition (basic_block bb) +{ + edge e; + edge_iterator ei; + + /* Now need to make bb's pred edges non-region crossing. */ + FOR_EACH_EDGE (e, ei, bb->preds) + { + fixup_partition_crossing (e); + } + + /* Possibly need to make bb's successor edges region crossing, + or remove stale region crossing. */ + FOR_EACH_EDGE (e, ei, bb->succs) + { + if ((e->flags & EDGE_FALLTHRU) + && BB_PARTITION (bb) != BB_PARTITION (e->dest) + && e->dest != EXIT_BLOCK_PTR) + force_nonfallthru (e); + else + fixup_partition_crossing (e); + } +} + /* Attempt to change code to redirect edge E to TARGET. Don't do that on expense of adding new instructions or reordering basic blocks. @@ -1979,6 +2007,14 @@ commit_edge_insertions (void) { basic_block bb; + /* Optimization passes that invoke this routine can cause hot blocks + previously reached by both hot and cold blocks to become dominated only + by cold blocks. This will cause the verification below to fail, + and lead to now cold code in the hot section. In some cases this + may only be visible after newly unreachable blocks are deleted, + which will be done by fixup_partitions. */ + fixup_partitions (); + #ifdef ENABLE_CHECKING verify_flow_info (); #endif @@ -2173,6 +2209,101 @@ get_last_bb_insn (basic_block bb) return end; } +/* Sanity check partition hotness to ensure that basic blocks in + the cold partition don't dominate basic blocks in the hot partition. + If FLAG_ONLY is true, report violations as errors. Otherwise + re-mark the dominated blocks as cold, since this is run after + cfg optimizations that may make hot blocks previously reached + by both hot and cold blocks now only reachable along cold paths. */ + +vec +find_partition_fixes (bool flag_only) +{ + basic_block bb; + vec bbs_in_cold_partition = vNULL; + vec bbs_to_fix = vNULL; + + if (!crtl->has_bb_partition) + return vNULL; + + FOR_EACH_BB (bb) + if ((BB_PARTITION (bb) == BB_COLD_PARTITION)) + bbs_in_cold_partition.safe_push (bb); + + if (bbs_in_cold_partition.is_empty ()) + return vNULL; + + bool dom_calculated_here = !dom_info_available_p (CDI_DOMINATORS); + + if (dom_calculated_here) + calculate_dominance_info (CDI_DOMINATORS); + + while (! bbs_in_cold_partition.is_empty ()) + { + bb = bbs_in_cold_partition.pop (); + /* Any blocks dominated by a block in the cold section + must also be cold. */ + basic_block son; + for (son = first_dom_son (CDI_DOMINATORS, bb); + son; + son = next_dom_son (CDI_DOMINATORS, son)) + { + /* If son is not yet cold, then mark it cold here and + enqueue it for further processing. */ + if ((BB_PARTITION (son) != BB_COLD_PARTITION)) + { + if (flag_only) + error ("non-cold basic block %d dominated " + "by a block in the cold partition", son->index); + else + BB_SET_PARTITION (son, BB_COLD_PARTITION); + bbs_to_fix.safe_push (son); + bbs_in_cold_partition.safe_push (son); + } + } + } + + if (dom_calculated_here) + free_dominance_info (CDI_DOMINATORS); + + return bbs_to_fix; +} + +/* Perform cleanup on the hot/cold bb partitioning after optimization + passes that modify the cfg. */ + +void +fixup_partitions (void) +{ + basic_block bb; + + if (!crtl->has_bb_partition) + return; + + /* Delete any blocks that became unreachable and weren't + already cleaned up, for example during edge forwarding + and convert_jumps_to_returns. This will expose more + opportunities for fixing the partition boundaries here. + Also, the calculation of the dominance graph during verification + will assert if there are unreachable nodes. */ + delete_unreachable_blocks (); + + /* If there are partitions, do a sanity check on them: A basic block in + a cold partition cannot dominate a basic block in a hot partition. + Fixup any that now violate this requirement, as a result of edge + forwarding and unreachable block deletion. */ + vec bbs_to_fix = find_partition_fixes (false); + + /* Do the partition fixup after all necessary blocks have been converted to + cold, so that we only update the region crossings the minimum number of + places, which can require forcing edges to be non fallthru. */ + while (! bbs_to_fix.is_empty ()) + { + bb = bbs_to_fix.pop (); + fixup_bb_partition (bb); + } +} + /* Verify, in the basic block chain, that there is at most one switch between hot/cold partitions. This condition will not be true until after reorder_basic_blocks is called. */ @@ -2219,7 +2350,8 @@ verify_hot_cold_block_grouping (void) /* Perform several checks on the edges out of each block, such as the consistency of the branch probabilities, the correctness of hot/cold partition crossing edges, and the number of expected - successor edges. */ + successor edges. Also verify that the dominance relationship + between hot/cold blocks is sane. */ static int rtl_verify_edges (void) @@ -2382,6 +2514,14 @@ rtl_verify_edges (void) } } + /* If there are partitions, do a sanity check on them: A basic block in + a cold partition cannot dominate a basic block in a hot partition. */ + if (crtl->has_bb_partition && !err) + { + vec bbs_to_fix = find_partition_fixes (true); + err = !bbs_to_fix.is_empty (); + } + /* Clean up. */ return err; } @@ -2515,7 +2655,7 @@ rtl_verify_bb_pointers (void) and NOTE_INSN_BASIC_BLOCK - verify that no fall_thru edge crosses hot/cold partition boundaries - verify that there are no pending RTL branch predictions - - verify that there is a single hot/cold partition boundary after bbro + - verify that hot blocks are not dominated by cold blocks In future it can be extended check a lot of other stuff as well (reachability of basic blocks, life information, etc. etc.). */ @@ -2761,7 +2901,8 @@ rtl_verify_bb_layout (void) - check that all insns are in the basic blocks (except the switch handling code, barriers and notes) - check that all returns are followed by barriers - - check that all fallthru edge points to the adjacent blocks. */ + - check that all fallthru edge points to the adjacent blocks + - verify that there is a single hot/cold partition boundary after bbro */ static int rtl_verify_flow_info (void) Index: basic-block.h =================================================================== --- basic-block.h (revision 201281) +++ basic-block.h (working copy) @@ -797,6 +797,7 @@ extern bool contains_no_active_insn_p (const_basic extern bool forwarder_block_p (const_basic_block); extern bool can_fallthru (basic_block, basic_block); extern void emit_barrier_after_bb (basic_block bb); +extern void fixup_partitions (void); /* In cfgbuild.c. */ extern void find_many_sub_basic_blocks (sbitmap); Index: cfgcleanup.c =================================================================== --- cfgcleanup.c (revision 201281) +++ cfgcleanup.c (working copy) @@ -2807,10 +2807,21 @@ try_optimize_cfg (int mode) df_analyze (); } + if (changed) + { + /* Edge forwarding in particular can cause hot blocks previously + reached by both hot and cold blocks to become dominated only + by cold blocks. This will cause the verification below to fail, + and lead to now cold code in the hot section. This is not easy + to detect and fix during edge forwarding, and in some cases + is only visible after newly unreachable blocks are deleted, + which will be done in fixup_partitions. */ + fixup_partitions (); + #ifdef ENABLE_CHECKING - if (changed) - verify_flow_info (); + verify_flow_info (); #endif + } changed_overall |= changed; first_pass = false; Index: bb-reorder.c =================================================================== --- bb-reorder.c (revision 201281) +++ bb-reorder.c (working copy) @@ -1444,6 +1444,55 @@ fix_up_crossing_landing_pad (eh_landing_pad old_lp ei_next (&ei); } + +/* Ensure that no cold bbs dominate hot bbs along the dominance or + post-dominance DIR, for example as a result of edge weight insanities. + Returns the updated value of COLD_BB_COUNT and adds newly-hot bbs + to BBS_IN_HOT_PARTITION. */ + +static unsigned int +sanitize_dominator_hotness (enum cdi_direction dir, unsigned int cold_bb_count, + vec *bbs_in_hot_partition) +{ + if (!cold_bb_count) + return 0; + + bool dom_calculated_here = !dom_info_available_p (dir); + + if (dom_calculated_here) + calculate_dominance_info (dir); + + /* Keep examining hot bbs until we have either checked them all, or + re-marked all cold bbs as hot. */ + vec hot_bbs_to_check = bbs_in_hot_partition->copy (); + while (! hot_bbs_to_check.is_empty () + && cold_bb_count) + { + basic_block bb = hot_bbs_to_check.pop (); + basic_block dom_bb = get_immediate_dominator (dir, bb); + + /* If bb's immediate dominator is also hot then it is ok. */ + if (BB_PARTITION (dom_bb) != BB_COLD_PARTITION) + continue; + + /* We have a hot bb with an immediate dominator that is cold. + The dominator needs to be re-marked hot. */ + BB_SET_PARTITION (dom_bb, BB_HOT_PARTITION); + cold_bb_count--; + + /* Now we need to examine newly-hot dom_bb to see if it is also + dominated by a cold bb. */ + bbs_in_hot_partition->safe_push (dom_bb); + hot_bbs_to_check.safe_push (dom_bb); + } + + if (dom_calculated_here) + free_dominance_info (dir); + + return cold_bb_count; +} + + /* Find the basic blocks that are rarely executed and need to be moved to a separate section of the .o file (to cut down on paging and improve cache locality). Return a vector of all edges that cross. */ @@ -1455,16 +1504,42 @@ find_rarely_executed_basic_blocks_and_crossing_edg basic_block bb; edge e; edge_iterator ei; + unsigned int cold_bb_count = 0; + vec bbs_in_hot_partition = vNULL; /* Mark which partition (hot/cold) each basic block belongs in. */ FOR_EACH_BB (bb) { if (probably_never_executed_bb_p (cfun, bb)) - BB_SET_PARTITION (bb, BB_COLD_PARTITION); + { + BB_SET_PARTITION (bb, BB_COLD_PARTITION); + cold_bb_count++; + } else - BB_SET_PARTITION (bb, BB_HOT_PARTITION); + { + BB_SET_PARTITION (bb, BB_HOT_PARTITION); + bbs_in_hot_partition.safe_push (bb); + } } + /* Ensure that no cold bbs dominate hot bbs. This could happen as a result of + several different possibilities. One is that there are edge weight insanities + due to optimization phases that do not properly update basic block profile + counts. The second is that the entry of the function may not be hot, because + it is entered fewer times than the number of profile training runs, but there + is a loop inside the function that causes blocks within the function to be + above the threshold for hotness. Then do the same along the post-dominator + tree (which could have additional changes required after fixing up + dominators). */ + if (cold_bb_count) + cold_bb_count = sanitize_dominator_hotness (CDI_DOMINATORS, + cold_bb_count, + &bbs_in_hot_partition); + if (cold_bb_count) + cold_bb_count = sanitize_dominator_hotness (CDI_POST_DOMINATORS, + cold_bb_count, + &bbs_in_hot_partition); + /* The format of .gcc_except_table does not allow landing pads to be in a different partition as the throw. Fix this by either moving or duplicating the landing pads. */ -- Teresa Johnson | Software Engineer | tejohnson@google.com | 408-460-2413 --001a11c2a42c2c922a04e2e564ee Content-Type: application/octet-stream; name="patch.diff" Content-Disposition: attachment; filename="patch.diff" Content-Transfer-Encoding: base64 X-Attachment-Id: f_hju6kpsz0 Content-length: 19435 UGF0Y2ggMyBvZiAzIHNwbGl0IG91dCBmcm9tIHRoZSBwYXRjaCBJIHNlbnQg aW4gTWF5IHRoYXQgZml4ZXMgcHJvYmxlbXMgd2l0aAotZnJlb3JkZXItYmxv Y2tzLWFuZC1wYXJ0aXRpb24sIHdpdGggY2hhbmdlcy9maXhlcyBkaXNjdXNz ZWQgaW4gdGhhdCB0aHJlYWQuCgpTZWUgaHR0cDovL2djYy5nbnUub3JnL21s L2djYy1wYXRjaGVzLzIwMTMtMDUvdGhyZWFkcy5odG1sIzAwMzg4IGZvciBj b250ZXh0LgoKVGhpcyBwYXRjaCBzYW5pdGl6ZXMgdGhlIHBhcnRpdGlvbmlu ZyB0byBhZGRyZXNzIGlzc3VlcyBzdWNoIGFzIGVkZ2UKd2VpZ2h0IGluc2Fu aXRpZXMgdGhhdCBzb21ldGltZXMgb2NjdXIgZHVlIHRvIHVwc3RyZWFtIG9w dGltaXphdGlvbnMsCmFuZCBlbnN1cmVzIHRoYXQgaG90IGJsb2NrcyBhcmUg bm90IGRvbWluYXRlZCBieSBjb2xkIGJsb2Nrcy4gVGhpcwpuZWVkcyB0byBi ZSByZXNhbml0aXplZCBhZnRlciBjZXJ0YWluIGNmZyBvcHRpbWl6YXRpb25z IHRoYXQgbWF5CmNhdXNlIGhvdCBibG9ja3MgcHJldmlvdXNseSByZWFjaGVk IHZpYSBib3RoIGhvdCBhbmQgY29sZCBwYXRocyB0bwpvbmx5IGJlIHJlYWNo ZWQgYnkgY29sZCBwYXRocy4KClRoZSB2ZXJpZmljYXRpb24gY29kZSBpbiBz YW5pdGl6ZV9kb21pbmF0b3JfaG90bmVzcyB3YXMgY29udHJpYnV0ZWQgYnkK U3RldmVuIEJvc3NjaGVyLgoKQm9vdHN0cmFwcGVkIGFuZCB0ZXN0ZWQgb24g eDg2LTY0LXVua25vd24tbGludXgtZ251LiBBbHNvIGVuc3VyZWQgdGhhdAph IHByb2ZpbGVkYm9vdHN0cmFwIHBhc3NlZCB3aXRoIC1mcmVvcmRlci1ibG9j a3MtYW5kLXBhcnRpdGlvbiBlbmFibGVkCihhbmQgd2l0aCB0aGUgZHdhcmYg dmVyc2lvbiBjaGFuZ2VkIHRvIDIgdG8gd29yayBhcm91bmQgUFI1NzQ1MSku CgpPayBmb3IgdHJ1bms/CgpUaGFua3MsClRlcmVzYQoKMjAxMy0wOC0wMSAg VGVyZXNhIEpvaG5zb24gIDx0ZWpvaG5zb25AZ29vZ2xlLmNvbT4KICAgICAg ICAgICAgU3RldmVuIEJvc3NjaGVyICA8c3RldmVuQGdjYy5nbnUub3JnPgoK CSogY2ZncnRsLmMgKGZpeHVwX2JiX3BhcnRpdGlvbik6IE5ldyByb3V0aW5l LgoJKGNvbW1pdF9lZGdlX2luc2VydGlvbnMpOiBJbnZva2UgZml4dXBfcGFy dGl0aW9ucy4KCShmaW5kX3BhcnRpdGlvbl9maXhlcyk6IE5ldyByb3V0aW5l LgoJKGZpeHVwX3BhcnRpdGlvbnMpOiBEaXR0by4KCSh2ZXJpZnlfaG90X2Nv bGRfYmxvY2tfZ3JvdXBpbmcpOiBVcGRhdGUgY29tbWVudHMuCgkocnRsX3Zl cmlmeV9lZGdlcyk6IEludm9rZSBmaW5kX3BhcnRpdGlvbl9maXhlcy4KCShy dGxfdmVyaWZ5X2JiX3BvaW50ZXJzKTogVXBkYXRlIGNvbW1lbnRzLgoJKHJ0 bF92ZXJpZnlfYmJfbGF5b3V0KTogRGl0dG8uCgkqIGJhc2ljLWJsb2NrLmgg KGZpeHVwX3BhcnRpdGlvbnMpOiBEZWNsYXJlLgoJKiBjZmdjbGVhbnVwLmMg KHRyeV9vcHRpbWl6ZV9jZmcpOiBJbnZva2UgZml4dXBfcGFydGl0aW9ucy4K CSogYmItcmVvcmRlci5jIChzYW5pdGl6ZV9kb21pbmF0b3JfaG90bmVzcyk6 IE5ldyBmdW5jdGlvbi4KICAgICAgICAoZmluZF9yYXJlbHlfZXhlY3V0ZWRf YmFzaWNfYmxvY2tzX2FuZF9jcm9zc2luZ19lZGdlcyk6IEludm9rZQogICAg ICAgIHNhbml0aXplX2RvbWluYXRvcl9ob3RuZXNzLgoKSW5kZXg6IGNmZ3J0 bC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGNmZ3J0bC5jCShyZXZp c2lvbiAyMDEyODEpCisrKyBjZmdydGwuYwkod29ya2luZyBjb3B5KQpAQCAt MTM0MSw2ICsxMzQxLDM0IEBAIGZpeHVwX3BhcnRpdGlvbl9jcm9zc2luZyAo ZWRnZSBlKQogICAgIH0KIH0KIAorLyogQ2FsbGVkIHdoZW4gYmxvY2sgQkIg aGFzIGJlZW4gcmVhc3NpZ25lZCB0byBhIGRpZmZlcmVudCBwYXJ0aXRpb24s CisgICB0byBlbnN1cmUgdGhhdCB0aGUgcmVnaW9uIGNyb3NzaW5nIGF0dHJp YnV0ZXMgYXJlIHVwZGF0ZWQuICAqLworCitzdGF0aWMgdm9pZAorZml4dXBf YmJfcGFydGl0aW9uIChiYXNpY19ibG9jayBiYikKK3sKKyAgZWRnZSBlOwor ICBlZGdlX2l0ZXJhdG9yIGVpOworCisgIC8qIE5vdyBuZWVkIHRvIG1ha2Ug YmIncyBwcmVkIGVkZ2VzIG5vbi1yZWdpb24gY3Jvc3NpbmcuICAqLworICBG T1JfRUFDSF9FREdFIChlLCBlaSwgYmItPnByZWRzKQorICAgIHsKKyAgICAg IGZpeHVwX3BhcnRpdGlvbl9jcm9zc2luZyAoZSk7CisgICAgfQorCisgIC8q IFBvc3NpYmx5IG5lZWQgdG8gbWFrZSBiYidzIHN1Y2Nlc3NvciBlZGdlcyBy ZWdpb24gY3Jvc3NpbmcsCisgICAgIG9yIHJlbW92ZSBzdGFsZSByZWdpb24g Y3Jvc3NpbmcuICAqLworICBGT1JfRUFDSF9FREdFIChlLCBlaSwgYmItPnN1 Y2NzKQorICAgIHsKKyAgICAgIGlmICgoZS0+ZmxhZ3MgJiBFREdFX0ZBTExU SFJVKQorICAgICAgICAgICYmIEJCX1BBUlRJVElPTiAoYmIpICE9IEJCX1BB UlRJVElPTiAoZS0+ZGVzdCkKKyAgICAgICAgICAmJiBlLT5kZXN0ICE9IEVY SVRfQkxPQ0tfUFRSKQorICAgICAgICBmb3JjZV9ub25mYWxsdGhydSAoZSk7 CisgICAgICBlbHNlCisgICAgICAgIGZpeHVwX3BhcnRpdGlvbl9jcm9zc2lu ZyAoZSk7CisgICAgfQorfQorCiAvKiBBdHRlbXB0IHRvIGNoYW5nZSBjb2Rl IHRvIHJlZGlyZWN0IGVkZ2UgRSB0byBUQVJHRVQuICBEb24ndCBkbyB0aGF0 IG9uCiAgICBleHBlbnNlIG9mIGFkZGluZyBuZXcgaW5zdHJ1Y3Rpb25zIG9y IHJlb3JkZXJpbmcgYmFzaWMgYmxvY2tzLgogCkBAIC0xOTc5LDYgKzIwMDcs MTQgQEAgY29tbWl0X2VkZ2VfaW5zZXJ0aW9ucyAodm9pZCkKIHsKICAgYmFz aWNfYmxvY2sgYmI7CiAKKyAgLyogT3B0aW1pemF0aW9uIHBhc3NlcyB0aGF0 IGludm9rZSB0aGlzIHJvdXRpbmUgY2FuIGNhdXNlIGhvdCBibG9ja3MKKyAg ICAgcHJldmlvdXNseSByZWFjaGVkIGJ5IGJvdGggaG90IGFuZCBjb2xkIGJs b2NrcyB0byBiZWNvbWUgZG9taW5hdGVkIG9ubHkKKyAgICAgYnkgY29sZCBi bG9ja3MuIFRoaXMgd2lsbCBjYXVzZSB0aGUgdmVyaWZpY2F0aW9uIGJlbG93 IHRvIGZhaWwsCisgICAgIGFuZCBsZWFkIHRvIG5vdyBjb2xkIGNvZGUgaW4g dGhlIGhvdCBzZWN0aW9uLiBJbiBzb21lIGNhc2VzIHRoaXMKKyAgICAgbWF5 IG9ubHkgYmUgdmlzaWJsZSBhZnRlciBuZXdseSB1bnJlYWNoYWJsZSBibG9j a3MgYXJlIGRlbGV0ZWQsCisgICAgIHdoaWNoIHdpbGwgYmUgZG9uZSBieSBm aXh1cF9wYXJ0aXRpb25zLiAgKi8KKyAgZml4dXBfcGFydGl0aW9ucyAoKTsK KwogI2lmZGVmIEVOQUJMRV9DSEVDS0lORwogICB2ZXJpZnlfZmxvd19pbmZv ICgpOwogI2VuZGlmCkBAIC0yMTczLDYgKzIyMDksMTAxIEBAIGdldF9sYXN0 X2JiX2luc24gKGJhc2ljX2Jsb2NrIGJiKQogICByZXR1cm4gZW5kOwogfQog CisvKiBTYW5pdHkgY2hlY2sgcGFydGl0aW9uIGhvdG5lc3MgdG8gZW5zdXJl IHRoYXQgYmFzaWMgYmxvY2tzIGluCisgwqAgdGhlIGNvbGQgcGFydGl0aW9u IGRvbid0IGRvbWluYXRlIGJhc2ljIGJsb2NrcyBpbiB0aGUgaG90IHBhcnRp dGlvbi4KKyAgIElmIEZMQUdfT05MWSBpcyB0cnVlLCByZXBvcnQgdmlvbGF0 aW9ucyBhcyBlcnJvcnMuIE90aGVyd2lzZQorICAgcmUtbWFyayB0aGUgZG9t aW5hdGVkIGJsb2NrcyBhcyBjb2xkLCBzaW5jZSB0aGlzIGlzIHJ1biBhZnRl cgorICAgY2ZnIG9wdGltaXphdGlvbnMgdGhhdCBtYXkgbWFrZSBob3QgYmxv Y2tzIHByZXZpb3VzbHkgcmVhY2hlZAorICAgYnkgYm90aCBob3QgYW5kIGNv bGQgYmxvY2tzIG5vdyBvbmx5IHJlYWNoYWJsZSBhbG9uZyBjb2xkIHBhdGhz LiAgKi8KKwordmVjPGJhc2ljX2Jsb2NrPgorZmluZF9wYXJ0aXRpb25fZml4 ZXMgKGJvb2wgZmxhZ19vbmx5KQoreworICBiYXNpY19ibG9jayBiYjsKKyAg dmVjPGJhc2ljX2Jsb2NrPiBiYnNfaW5fY29sZF9wYXJ0aXRpb24gPSB2TlVM TDsKKyAgdmVjPGJhc2ljX2Jsb2NrPiBiYnNfdG9fZml4ID0gdk5VTEw7CisK KyAgaWYgKCFjcnRsLT5oYXNfYmJfcGFydGl0aW9uKQorICAgIHJldHVybiB2 TlVMTDsKKworICBGT1JfRUFDSF9CQiAoYmIpCisgICAgaWYgKChCQl9QQVJU SVRJT04gKGJiKSA9PSBCQl9DT0xEX1BBUlRJVElPTikpCisgICAgICBiYnNf aW5fY29sZF9wYXJ0aXRpb24uc2FmZV9wdXNoIChiYik7CisKKyAgaWYgKGJi c19pbl9jb2xkX3BhcnRpdGlvbi5pc19lbXB0eSAoKSkKKyAgICByZXR1cm4g dk5VTEw7CisKKyAgYm9vbCBkb21fY2FsY3VsYXRlZF9oZXJlID0gIWRvbV9p bmZvX2F2YWlsYWJsZV9wIChDRElfRE9NSU5BVE9SUyk7CisKKyAgaWYgKGRv bV9jYWxjdWxhdGVkX2hlcmUpCisgICAgY2FsY3VsYXRlX2RvbWluYW5jZV9p bmZvIChDRElfRE9NSU5BVE9SUyk7CisKKyAgd2hpbGUgKCEgYmJzX2luX2Nv bGRfcGFydGl0aW9uLmlzX2VtcHR5ICAoKSkKKyAgICB7CisgICAgICBiYiA9 IGJic19pbl9jb2xkX3BhcnRpdGlvbi5wb3AgKCk7CisgICAgICAvKiBBbnkg YmxvY2tzIGRvbWluYXRlZCBieSBhIGJsb2NrIGluIHRoZSBjb2xkIHNlY3Rp b24KKyAgICAgICAgIG11c3QgYWxzbyBiZSBjb2xkLiAgKi8KKyAgICAgIGJh c2ljX2Jsb2NrIHNvbjsKKyAgICAgIGZvciAoc29uID0gZmlyc3RfZG9tX3Nv biAoQ0RJX0RPTUlOQVRPUlMsIGJiKTsKKyAgICAgICAgICAgc29uOworICAg ICAgICAgICBzb24gPSBuZXh0X2RvbV9zb24gKENESV9ET01JTkFUT1JTLCBz b24pKQorICAgICAgICB7CisgICAgICAgICAgLyogSWYgc29uIGlzIG5vdCB5 ZXQgY29sZCwgdGhlbiBtYXJrIGl0IGNvbGQgaGVyZSBhbmQKKyAgICAgICAg ICAgICBlbnF1ZXVlIGl0IGZvciBmdXJ0aGVyIHByb2Nlc3NpbmcuICAqLwor ICAgICAgICAgIGlmICgoQkJfUEFSVElUSU9OIChzb24pICE9IEJCX0NPTERf UEFSVElUSU9OKSkKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgaWYg KGZsYWdfb25seSkKKyAgICAgICAgICAgICAgICBlcnJvciAoIm5vbi1jb2xk IGJhc2ljIGJsb2NrICVkIGRvbWluYXRlZCAiCisgICAgICAgICAgICAgICAg ICAgICAgICJieSBhIGJsb2NrIGluIHRoZSBjb2xkIHBhcnRpdGlvbiIsIHNv bi0+aW5kZXgpOworICAgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAg ICAgQkJfU0VUX1BBUlRJVElPTiAoc29uLCBCQl9DT0xEX1BBUlRJVElPTik7 CisgICAgICAgICAgICAgIGJic190b19maXguc2FmZV9wdXNoIChzb24pOwor ICAgICAgICAgICAgICBiYnNfaW5fY29sZF9wYXJ0aXRpb24uc2FmZV9wdXNo IChzb24pOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorCisg IGlmIChkb21fY2FsY3VsYXRlZF9oZXJlKQorICAgIGZyZWVfZG9taW5hbmNl X2luZm8gKENESV9ET01JTkFUT1JTKTsKKworICByZXR1cm4gYmJzX3RvX2Zp eDsKK30KKworLyogUGVyZm9ybSBjbGVhbnVwIG9uIHRoZSBob3QvY29sZCBi YiBwYXJ0aXRpb25pbmcgYWZ0ZXIgb3B0aW1pemF0aW9uCisgICBwYXNzZXMg dGhhdCBtb2RpZnkgdGhlIGNmZy4gICovCisKK3ZvaWQKK2ZpeHVwX3BhcnRp dGlvbnMgKHZvaWQpCit7CisgIGJhc2ljX2Jsb2NrIGJiOworCisgIGlmICgh Y3J0bC0+aGFzX2JiX3BhcnRpdGlvbikKKyAgICByZXR1cm47CisKKyAgLyog RGVsZXRlIGFueSBibG9ja3MgdGhhdCBiZWNhbWUgdW5yZWFjaGFibGUgYW5k IHdlcmVuJ3QKKyAgICAgYWxyZWFkeSBjbGVhbmVkIHVwLCBmb3IgZXhhbXBs ZSBkdXJpbmcgZWRnZSBmb3J3YXJkaW5nCisgICAgIGFuZCBjb252ZXJ0X2p1 bXBzX3RvX3JldHVybnMuIFRoaXMgd2lsbCBleHBvc2UgbW9yZQorICAgICBv cHBvcnR1bml0aWVzIGZvciBmaXhpbmcgdGhlIHBhcnRpdGlvbiBib3VuZGFy aWVzIGhlcmUuCisgICAgIEFsc28sIHRoZSBjYWxjdWxhdGlvbiBvZiB0aGUg ZG9taW5hbmNlIGdyYXBoIGR1cmluZyB2ZXJpZmljYXRpb24KKyAgICAgd2ls bCBhc3NlcnQgaWYgdGhlcmUgYXJlIHVucmVhY2hhYmxlIG5vZGVzLiAgKi8K KyAgZGVsZXRlX3VucmVhY2hhYmxlX2Jsb2NrcyAoKTsKKworICAvKiBJZiB0 aGVyZSBhcmUgcGFydGl0aW9ucywgZG8gYSBzYW5pdHkgY2hlY2sgb24gdGhl bTogQSBiYXNpYyBibG9jayBpbgorICAgwqAgYSBjb2xkIHBhcnRpdGlvbiBj YW5ub3QgZG9taW5hdGUgYSBiYXNpYyBibG9jayBpbiBhIGhvdCBwYXJ0aXRp b24uCisgICAgIEZpeHVwIGFueSB0aGF0IG5vdyB2aW9sYXRlIHRoaXMgcmVx dWlyZW1lbnQsIGFzIGEgcmVzdWx0IG9mIGVkZ2UKKyAgICAgZm9yd2FyZGlu ZyBhbmQgdW5yZWFjaGFibGUgYmxvY2sgZGVsZXRpb24uIMKgKi8KKyAgdmVj PGJhc2ljX2Jsb2NrPiBiYnNfdG9fZml4ID0gZmluZF9wYXJ0aXRpb25fZml4 ZXMgKGZhbHNlKTsKKworICAvKiBEbyB0aGUgcGFydGl0aW9uIGZpeHVwIGFm dGVyIGFsbCBuZWNlc3NhcnkgYmxvY2tzIGhhdmUgYmVlbiBjb252ZXJ0ZWQg dG8KKyAgICAgY29sZCwgc28gdGhhdCB3ZSBvbmx5IHVwZGF0ZSB0aGUgcmVn aW9uIGNyb3NzaW5ncyB0aGUgbWluaW11bSBudW1iZXIgb2YKKyAgICAgcGxh Y2VzLCB3aGljaCBjYW4gcmVxdWlyZSBmb3JjaW5nIGVkZ2VzIHRvIGJlIG5v biBmYWxsdGhydS4gICovCisgIHdoaWxlICghIGJic190b19maXguaXNfZW1w dHkgKCkpCisgICAgeworICAgICAgYmIgPSBiYnNfdG9fZml4LnBvcCAoKTsK KyAgICAgIGZpeHVwX2JiX3BhcnRpdGlvbiAoYmIpOworICAgIH0KK30KKwog LyogVmVyaWZ5LCBpbiB0aGUgYmFzaWMgYmxvY2sgY2hhaW4sIHRoYXQgdGhl cmUgaXMgYXQgbW9zdCBvbmUgc3dpdGNoCiAgICBiZXR3ZWVuIGhvdC9jb2xk IHBhcnRpdGlvbnMuIFRoaXMgY29uZGl0aW9uIHdpbGwgbm90IGJlIHRydWUg dW50aWwKICAgIGFmdGVyIHJlb3JkZXJfYmFzaWNfYmxvY2tzIGlzIGNhbGxl ZC4gICovCkBAIC0yMjE5LDcgKzIzNTAsOCBAQCB2ZXJpZnlfaG90X2NvbGRf YmxvY2tfZ3JvdXBpbmcgKHZvaWQpCiAvKiBQZXJmb3JtIHNldmVyYWwgY2hl Y2tzIG9uIHRoZSBlZGdlcyBvdXQgb2YgZWFjaCBibG9jaywgc3VjaCBhcwog ICAgdGhlIGNvbnNpc3RlbmN5IG9mIHRoZSBicmFuY2ggcHJvYmFiaWxpdGll cywgdGhlIGNvcnJlY3RuZXNzCiAgICBvZiBob3QvY29sZCBwYXJ0aXRpb24g Y3Jvc3NpbmcgZWRnZXMsIGFuZCB0aGUgbnVtYmVyIG9mIGV4cGVjdGVkCi0g ICBzdWNjZXNzb3IgZWRnZXMuICAqLworICAgc3VjY2Vzc29yIGVkZ2VzLiAg QWxzbyB2ZXJpZnkgdGhhdCB0aGUgZG9taW5hbmNlIHJlbGF0aW9uc2hpcAor ICAgYmV0d2VlbiBob3QvY29sZCBibG9ja3MgaXMgc2FuZS4gICovCiAKIHN0 YXRpYyBpbnQKIHJ0bF92ZXJpZnlfZWRnZXMgKHZvaWQpCkBAIC0yMzgyLDYg KzI1MTQsMTQgQEAgcnRsX3ZlcmlmeV9lZGdlcyAodm9pZCkKIAl9CiAgICAg fQogCisgIC8qIElmIHRoZXJlIGFyZSBwYXJ0aXRpb25zLCBkbyBhIHNhbml0 eSBjaGVjayBvbiB0aGVtOiBBIGJhc2ljIGJsb2NrIGluCisgICDCoCBhIGNv bGQgcGFydGl0aW9uIGNhbm5vdCBkb21pbmF0ZSBhIGJhc2ljIGJsb2NrIGlu IGEgaG90IHBhcnRpdGlvbi4gwqAqLworICBpZiAoY3J0bC0+aGFzX2JiX3Bh cnRpdGlvbiAmJiAhZXJyKQorICAgIHsKKyAgICAgIHZlYzxiYXNpY19ibG9j az4gYmJzX3RvX2ZpeCA9IGZpbmRfcGFydGl0aW9uX2ZpeGVzICh0cnVlKTsK KyAgICAgIGVyciA9ICFiYnNfdG9fZml4LmlzX2VtcHR5ICgpOworICAgIH0K KwogICAvKiBDbGVhbiB1cC4gICovCiAgIHJldHVybiBlcnI7CiB9CkBAIC0y NTE1LDcgKzI2NTUsNyBAQCBydGxfdmVyaWZ5X2JiX3BvaW50ZXJzICh2b2lk KQogICAgICBhbmQgTk9URV9JTlNOX0JBU0lDX0JMT0NLCiAgICAtIHZlcmlm eSB0aGF0IG5vIGZhbGxfdGhydSBlZGdlIGNyb3NzZXMgaG90L2NvbGQgcGFy dGl0aW9uIGJvdW5kYXJpZXMKICAgIC0gdmVyaWZ5IHRoYXQgdGhlcmUgYXJl IG5vIHBlbmRpbmcgUlRMIGJyYW5jaCBwcmVkaWN0aW9ucwotICAgLSB2ZXJp ZnkgdGhhdCB0aGVyZSBpcyBhIHNpbmdsZSBob3QvY29sZCBwYXJ0aXRpb24g Ym91bmRhcnkgYWZ0ZXIgYmJybworICAgLSB2ZXJpZnkgdGhhdCBob3QgYmxv Y2tzIGFyZSBub3QgZG9taW5hdGVkIGJ5IGNvbGQgYmxvY2tzCiAKICAgIElu IGZ1dHVyZSBpdCBjYW4gYmUgZXh0ZW5kZWQgY2hlY2sgYSBsb3Qgb2Ygb3Ro ZXIgc3R1ZmYgYXMgd2VsbAogICAgKHJlYWNoYWJpbGl0eSBvZiBiYXNpYyBi bG9ja3MsIGxpZmUgaW5mb3JtYXRpb24sIGV0Yy4gZXRjLikuICAqLwpAQCAt Mjc2MSw3ICsyOTAxLDggQEAgcnRsX3ZlcmlmeV9iYl9sYXlvdXQgKHZvaWQp CiAgICAtIGNoZWNrIHRoYXQgYWxsIGluc25zIGFyZSBpbiB0aGUgYmFzaWMg YmxvY2tzCiAgICAgIChleGNlcHQgdGhlIHN3aXRjaCBoYW5kbGluZyBjb2Rl LCBiYXJyaWVycyBhbmQgbm90ZXMpCiAgICAtIGNoZWNrIHRoYXQgYWxsIHJl dHVybnMgYXJlIGZvbGxvd2VkIGJ5IGJhcnJpZXJzCi0gICAtIGNoZWNrIHRo YXQgYWxsIGZhbGx0aHJ1IGVkZ2UgcG9pbnRzIHRvIHRoZSBhZGphY2VudCBi bG9ja3MuICAqLworICAgLSBjaGVjayB0aGF0IGFsbCBmYWxsdGhydSBlZGdl IHBvaW50cyB0byB0aGUgYWRqYWNlbnQgYmxvY2tzCisgICAtIHZlcmlmeSB0 aGF0IHRoZXJlIGlzIGEgc2luZ2xlIGhvdC9jb2xkIHBhcnRpdGlvbiBib3Vu ZGFyeSBhZnRlciBiYnJvICAqLwogCiBzdGF0aWMgaW50CiBydGxfdmVyaWZ5 X2Zsb3dfaW5mbyAodm9pZCkKSW5kZXg6IGJhc2ljLWJsb2NrLmgKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gYmFzaWMtYmxvY2suaAkocmV2aXNpb24g MjAxMjgxKQorKysgYmFzaWMtYmxvY2suaAkod29ya2luZyBjb3B5KQpAQCAt Nzk3LDYgKzc5Nyw3IEBAIGV4dGVybiBib29sIGNvbnRhaW5zX25vX2FjdGl2 ZV9pbnNuX3AgKGNvbnN0X2Jhc2ljCiBleHRlcm4gYm9vbCBmb3J3YXJkZXJf YmxvY2tfcCAoY29uc3RfYmFzaWNfYmxvY2spOwogZXh0ZXJuIGJvb2wgY2Fu X2ZhbGx0aHJ1IChiYXNpY19ibG9jaywgYmFzaWNfYmxvY2spOwogZXh0ZXJu IHZvaWQgZW1pdF9iYXJyaWVyX2FmdGVyX2JiIChiYXNpY19ibG9jayBiYik7 CitleHRlcm4gdm9pZCBmaXh1cF9wYXJ0aXRpb25zICh2b2lkKTsKIAogLyog SW4gY2ZnYnVpbGQuYy4gICovCiBleHRlcm4gdm9pZCBmaW5kX21hbnlfc3Vi X2Jhc2ljX2Jsb2NrcyAoc2JpdG1hcCk7CkluZGV4OiBjZmdjbGVhbnVwLmMK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gY2ZnY2xlYW51cC5jCShyZXZp c2lvbiAyMDEyODEpCisrKyBjZmdjbGVhbnVwLmMJKHdvcmtpbmcgY29weSkK QEAgLTI4MDcsMTAgKzI4MDcsMjEgQEAgdHJ5X29wdGltaXplX2NmZyAoaW50 IG1vZGUpCiAJICAgICAgZGZfYW5hbHl6ZSAoKTsKIAkgICAgfQogCisJICBp ZiAoY2hhbmdlZCkKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgLyog RWRnZSBmb3J3YXJkaW5nIGluIHBhcnRpY3VsYXIgY2FuIGNhdXNlIGhvdCBi bG9ja3MgcHJldmlvdXNseQorICAgICAgICAgICAgICAgICByZWFjaGVkIGJ5 IGJvdGggaG90IGFuZCBjb2xkIGJsb2NrcyB0byBiZWNvbWUgZG9taW5hdGVk IG9ubHkKKyAgICAgICAgICAgICAgICAgYnkgY29sZCBibG9ja3MuIFRoaXMg d2lsbCBjYXVzZSB0aGUgdmVyaWZpY2F0aW9uIGJlbG93IHRvIGZhaWwsCisg ICAgICAgICAgICAgICAgIGFuZCBsZWFkIHRvIG5vdyBjb2xkIGNvZGUgaW4g dGhlIGhvdCBzZWN0aW9uLiBUaGlzIGlzIG5vdCBlYXN5CisgICAgICAgICAg ICAgICAgIHRvIGRldGVjdCBhbmQgZml4IGR1cmluZyBlZGdlIGZvcndhcmRp bmcsIGFuZCBpbiBzb21lIGNhc2VzCisgICAgICAgICAgICAgICAgIGlzIG9u bHkgdmlzaWJsZSBhZnRlciBuZXdseSB1bnJlYWNoYWJsZSBibG9ja3MgYXJl IGRlbGV0ZWQsCisgICAgICAgICAgICAgICAgIHdoaWNoIHdpbGwgYmUgZG9u ZSBpbiBmaXh1cF9wYXJ0aXRpb25zLiAgKi8KKyAgICAgICAgICAgICAgZml4 dXBfcGFydGl0aW9ucyAoKTsKKwogI2lmZGVmIEVOQUJMRV9DSEVDS0lORwot CSAgaWYgKGNoYW5nZWQpCi0JICAgIHZlcmlmeV9mbG93X2luZm8gKCk7Cisg ICAgICAgICAgICAgIHZlcmlmeV9mbG93X2luZm8gKCk7CiAjZW5kaWYKKyAg ICAgICAgICAgIH0KIAogCSAgY2hhbmdlZF9vdmVyYWxsIHw9IGNoYW5nZWQ7 CiAJICBmaXJzdF9wYXNzID0gZmFsc2U7CkluZGV4OiBiYi1yZW9yZGVyLmMK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gYmItcmVvcmRlci5jCShyZXZp c2lvbiAyMDEyODEpCisrKyBiYi1yZW9yZGVyLmMJKHdvcmtpbmcgY29weSkK QEAgLTE0NDQsNiArMTQ0NCw1NSBAQCBmaXhfdXBfY3Jvc3NpbmdfbGFuZGlu Z19wYWQgKGVoX2xhbmRpbmdfcGFkIG9sZF9scAogICAgICAgZWlfbmV4dCAo JmVpKTsKIH0KIAorCisvKiBFbnN1cmUgdGhhdCBubyBjb2xkIGJicyBkb21p bmF0ZSBob3QgYmJzIGFsb25nIHRoZSBkb21pbmFuY2Ugb3IKKyAgIHBvc3Qt ZG9taW5hbmNlIERJUiwgZm9yIGV4YW1wbGUgYXMgYSByZXN1bHQgb2YgZWRn ZSB3ZWlnaHQgaW5zYW5pdGllcy4KKyAgIFJldHVybnMgdGhlIHVwZGF0ZWQg dmFsdWUgb2YgQ09MRF9CQl9DT1VOVCBhbmQgYWRkcyBuZXdseS1ob3QgYmJz CisgICB0byBCQlNfSU5fSE9UX1BBUlRJVElPTi4gICovCisKK3N0YXRpYyB1 bnNpZ25lZCBpbnQKK3Nhbml0aXplX2RvbWluYXRvcl9ob3RuZXNzIChlbnVt IGNkaV9kaXJlY3Rpb24gZGlyLCB1bnNpZ25lZCBpbnQgY29sZF9iYl9jb3Vu dCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICB2ZWM8YmFzaWNfYmxv Y2s+ICpiYnNfaW5faG90X3BhcnRpdGlvbikKK3sKKyAgaWYgKCFjb2xkX2Ji X2NvdW50KQorICAgIHJldHVybiAwOworCisgIGJvb2wgZG9tX2NhbGN1bGF0 ZWRfaGVyZSA9ICFkb21faW5mb19hdmFpbGFibGVfcCAoZGlyKTsKKworICBp ZiAoZG9tX2NhbGN1bGF0ZWRfaGVyZSkKKyAgICBjYWxjdWxhdGVfZG9taW5h bmNlX2luZm8gKGRpcik7CisKKyAgLyogS2VlcCBleGFtaW5pbmcgaG90IGJi cyB1bnRpbCB3ZSBoYXZlIGVpdGhlciBjaGVja2VkIHRoZW0gYWxsLCBvcgor ICAgICByZS1tYXJrZWQgYWxsIGNvbGQgYmJzIGFzIGhvdC4gICovCisgIHZl YzxiYXNpY19ibG9jaz4gaG90X2Jic190b19jaGVjayA9IGJic19pbl9ob3Rf cGFydGl0aW9uLT5jb3B5ICgpOworICB3aGlsZSAoISBob3RfYmJzX3RvX2No ZWNrLmlzX2VtcHR5ICgpCisgICAgICAgICAmJiBjb2xkX2JiX2NvdW50KQor ICAgIHsKKyAgICAgIGJhc2ljX2Jsb2NrIGJiID0gaG90X2Jic190b19jaGVj ay5wb3AgKCk7CisgICAgICBiYXNpY19ibG9jayBkb21fYmIgPSBnZXRfaW1t ZWRpYXRlX2RvbWluYXRvciAoZGlyLCBiYik7CisKKyAgICAgIC8qIElmIGJi J3MgaW1tZWRpYXRlIGRvbWluYXRvciBpcyBhbHNvIGhvdCB0aGVuIGl0IGlz IG9rLiAgKi8KKyAgICAgIGlmIChCQl9QQVJUSVRJT04gKGRvbV9iYikgIT0g QkJfQ09MRF9QQVJUSVRJT04pCisgICAgICAgIGNvbnRpbnVlOworCisgICAg ICAvKiBXZSBoYXZlIGEgaG90IGJiIHdpdGggYW4gaW1tZWRpYXRlIGRvbWlu YXRvciB0aGF0IGlzIGNvbGQuCisgICAgICAgICBUaGUgZG9taW5hdG9yIG5l ZWRzIHRvIGJlIHJlLW1hcmtlZCBob3QuICAqLworICAgICAgQkJfU0VUX1BB UlRJVElPTiAoZG9tX2JiLCBCQl9IT1RfUEFSVElUSU9OKTsKKyAgICAgIGNv bGRfYmJfY291bnQtLTsKKworICAgICAgLyogTm93IHdlIG5lZWQgdG8gZXhh bWluZSBuZXdseS1ob3QgZG9tX2JiIHRvIHNlZSBpZiBpdCBpcyBhbHNvCisg ICAgICAgICBkb21pbmF0ZWQgYnkgYSBjb2xkIGJiLiAgKi8KKyAgICAgIGJi c19pbl9ob3RfcGFydGl0aW9uLT5zYWZlX3B1c2ggKGRvbV9iYik7CisgICAg ICBob3RfYmJzX3RvX2NoZWNrLnNhZmVfcHVzaCAoZG9tX2JiKTsKKyAgICB9 CisKKyAgaWYgKGRvbV9jYWxjdWxhdGVkX2hlcmUpCisgICAgZnJlZV9kb21p bmFuY2VfaW5mbyAoZGlyKTsKKworICByZXR1cm4gY29sZF9iYl9jb3VudDsK K30KKworCiAvKiBGaW5kIHRoZSBiYXNpYyBibG9ja3MgdGhhdCBhcmUgcmFy ZWx5IGV4ZWN1dGVkIGFuZCBuZWVkIHRvIGJlIG1vdmVkIHRvCiAgICBhIHNl cGFyYXRlIHNlY3Rpb24gb2YgdGhlIC5vIGZpbGUgKHRvIGN1dCBkb3duIG9u IHBhZ2luZyBhbmQgaW1wcm92ZQogICAgY2FjaGUgbG9jYWxpdHkpLiAgUmV0 dXJuIGEgdmVjdG9yIG9mIGFsbCBlZGdlcyB0aGF0IGNyb3NzLiAgKi8KQEAg LTE0NTUsMTYgKzE1MDQsNDIgQEAgZmluZF9yYXJlbHlfZXhlY3V0ZWRfYmFz aWNfYmxvY2tzX2FuZF9jcm9zc2luZ19lZGcKICAgYmFzaWNfYmxvY2sgYmI7 CiAgIGVkZ2UgZTsKICAgZWRnZV9pdGVyYXRvciBlaTsKKyAgdW5zaWduZWQg aW50IGNvbGRfYmJfY291bnQgPSAwOworICB2ZWM8YmFzaWNfYmxvY2s+IGJi c19pbl9ob3RfcGFydGl0aW9uID0gdk5VTEw7CiAKICAgLyogTWFyayB3aGlj aCBwYXJ0aXRpb24gKGhvdC9jb2xkKSBlYWNoIGJhc2ljIGJsb2NrIGJlbG9u Z3MgaW4uICAqLwogICBGT1JfRUFDSF9CQiAoYmIpCiAgICAgewogICAgICAg aWYgKHByb2JhYmx5X25ldmVyX2V4ZWN1dGVkX2JiX3AgKGNmdW4sIGJiKSkK LQlCQl9TRVRfUEFSVElUSU9OIChiYiwgQkJfQ09MRF9QQVJUSVRJT04pOwor ICAgICAgICB7CisgICAgICAgICAgQkJfU0VUX1BBUlRJVElPTiAoYmIsIEJC X0NPTERfUEFSVElUSU9OKTsKKyAgICAgICAgICBjb2xkX2JiX2NvdW50Kys7 CisgICAgICAgIH0KICAgICAgIGVsc2UKLQlCQl9TRVRfUEFSVElUSU9OIChi YiwgQkJfSE9UX1BBUlRJVElPTik7CisgICAgICAgIHsKKyAgICAgICAgICBC Ql9TRVRfUEFSVElUSU9OIChiYiwgQkJfSE9UX1BBUlRJVElPTik7CisgICAg ICAgICAgYmJzX2luX2hvdF9wYXJ0aXRpb24uc2FmZV9wdXNoIChiYik7Cisg ICAgICAgIH0KICAgICB9CiAKKyAgLyogRW5zdXJlIHRoYXQgbm8gY29sZCBi YnMgZG9taW5hdGUgaG90IGJicy4gVGhpcyBjb3VsZCBoYXBwZW4gYXMgYSBy ZXN1bHQgb2YKKyAgICAgc2V2ZXJhbCBkaWZmZXJlbnQgcG9zc2liaWxpdGll cy4gT25lIGlzIHRoYXQgdGhlcmUgYXJlIGVkZ2Ugd2VpZ2h0IGluc2FuaXRp ZXMKKyAgICAgZHVlIHRvIG9wdGltaXphdGlvbiBwaGFzZXMgdGhhdCBkbyBu b3QgcHJvcGVybHkgdXBkYXRlIGJhc2ljIGJsb2NrIHByb2ZpbGUKKyAgICAg Y291bnRzLiBUaGUgc2Vjb25kIGlzIHRoYXQgdGhlIGVudHJ5IG9mIHRoZSBm dW5jdGlvbiBtYXkgbm90IGJlIGhvdCwgYmVjYXVzZQorICAgICBpdCBpcyBl bnRlcmVkIGZld2VyIHRpbWVzIHRoYW4gdGhlIG51bWJlciBvZiBwcm9maWxl IHRyYWluaW5nIHJ1bnMsIGJ1dCB0aGVyZQorICAgICBpcyBhIGxvb3AgaW5z aWRlIHRoZSBmdW5jdGlvbiB0aGF0IGNhdXNlcyBibG9ja3Mgd2l0aGluIHRo ZSBmdW5jdGlvbiB0byBiZQorICAgICBhYm92ZSB0aGUgdGhyZXNob2xkIGZv ciBob3RuZXNzLiBUaGVuIGRvIHRoZSBzYW1lIGFsb25nIHRoZSBwb3N0LWRv bWluYXRvcgorICAgICB0cmVlICh3aGljaCBjb3VsZCBoYXZlIGFkZGl0aW9u YWwgY2hhbmdlcyByZXF1aXJlZCBhZnRlciBmaXhpbmcgdXAKKyAgICAgZG9t aW5hdG9ycykuICAqLworICBpZiAoY29sZF9iYl9jb3VudCkKKyAgICBjb2xk X2JiX2NvdW50ID0gc2FuaXRpemVfZG9taW5hdG9yX2hvdG5lc3MgKENESV9E T01JTkFUT1JTLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgY29sZF9iYl9jb3VudCwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZiYnNfaW5faG90 X3BhcnRpdGlvbik7CisgIGlmIChjb2xkX2JiX2NvdW50KQorICAgIGNvbGRf YmJfY291bnQgPSBzYW5pdGl6ZV9kb21pbmF0b3JfaG90bmVzcyAoQ0RJX1BP U1RfRE9NSU5BVE9SUywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGNvbGRfYmJfY291bnQsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmYmJzX2lu X2hvdF9wYXJ0aXRpb24pOworCiAgIC8qIFRoZSBmb3JtYXQgb2YgLmdjY19l eGNlcHRfdGFibGUgZG9lcyBub3QgYWxsb3cgbGFuZGluZyBwYWRzIHRvCiAg ICAgIGJlIGluIGEgZGlmZmVyZW50IHBhcnRpdGlvbiBhcyB0aGUgdGhyb3cu ICBGaXggdGhpcyBieSBlaXRoZXIKICAgICAgbW92aW5nIG9yIGR1cGxpY2F0 aW5nIHRoZSBsYW5kaW5nIHBhZHMuICAqLwo= --001a11c2a42c2c922a04e2e564ee--