From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 8766 invoked by alias); 26 Mar 2014 23:44:24 -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 8751 invoked by uid 89); 26 Mar 2014 23:44:23 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.8 required=5.0 tests=AWL,BAYES_50,RCVD_IN_DNSWL_LOW,RP_MATCHES_RCVD,SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-qa0-f47.google.com Received: from mail-qa0-f47.google.com (HELO mail-qa0-f47.google.com) (209.85.216.47) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-SHA encrypted) ESMTPS; Wed, 26 Mar 2014 23:44:18 +0000 Received: by mail-qa0-f47.google.com with SMTP id w5so3082198qac.34 for ; Wed, 26 Mar 2014 16:44:16 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:date:message-id:subject:from:to:cc :content-type; bh=A9RZGx6wji9Qp+QpLiSdsqoTzy1ki8UqhysnXDMTAUY=; b=NzWPa/A/t21UUBit6LkuSa73kCy6+FpmVxyJZaCHbgLmiRXR4ShhTSM0p6w/Xw7qTh 9Cf40/kPyddiDpCc+BODElUI8gSs+DHCMsThmrvCIYCFHiUH7/bs/dgIJlPQmCB8E/Sn 1FrhileEY7OIav6BjhO5BZ624QDJqQor7MosMnDKRrKlFS9nzMsR18TMbBdl7Vfa7VDm 11gU5TjXtkgHCUk/M7L5GWXcpfaoQzmKr9ItSm4xykphoXMZoaOwWeQu0waIdX7faOO/ NHtcHa+bPux13GKjZw2d1a2i832ru+2hCu+W8F+8wgBED2tnT0p4uvQyO2/orHRW6f1G 0Gbg== X-Gm-Message-State: ALoCoQmNI08dl4BGGdXtmlpbljBA0obQKkIzAJR0I0oFFAgtPgIt2JSJ1RjVU4sBDeuffj3iVOBKuZ5X5IDMK2Dquohj6l7aRh3K54yxNoasQe0iFfZ0ECXeVgImlYb9uV84TEnYNvA1DSzgYSe3Ja7XMQcg4zEO5/MNRGQNlAgvsTByV42MXjG1xyHNEKD8oSLHroWfTq3gw5GsltWQy9DmT74gqkE6QQ== MIME-Version: 1.0 X-Received: by 10.140.97.137 with SMTP id m9mr5765756qge.95.1395877456166; Wed, 26 Mar 2014 16:44:16 -0700 (PDT) Received: by 10.229.167.129 with HTTP; Wed, 26 Mar 2014 16:44:16 -0700 (PDT) Date: Wed, 26 Mar 2014 23:57:00 -0000 Message-ID: Subject: [PATCH] Redesign jump threading profile updates From: Teresa Johnson To: "gcc-patches@gcc.gnu.org" , Jan Hubicka , Jeff Law Cc: David Li Content-Type: multipart/mixed; boundary=001a113a2b7aed0fec04f58b0b43 X-IsSubscribed: yes X-SW-Source: 2014-03/txt/msg01485.txt.bz2 --001a113a2b7aed0fec04f58b0b43 Content-Type: text/plain; charset=UTF-8 Content-length: 33319 Recently I discovered that the profile updates being performed by jump threading were incorrect in many cases, particularly in the case where the threading path contains a joiner. Some of the duplicated blocks/edges were not getting any counts, leading to incorrect function splitting and other downstream optimizations, and there were other insanities as well. After making a few attempts to fix the handling I ended up completely redesigning the profile update code, removing a few places throughout the code where it was attempting to do some updates. The biggest complication (see the large comment and example above the new routine compute_path_counts) is that we duplicate a conditional jump in the joiner case, possibly multiple times for multiple jump thread paths through that joiner, and it isn't trivial to figure out what probability to assign each of the duplicated successor edges (and the original after threading). Each jump thread path may need to have a different probability of staying on path through the joiner in order to keep the counts going out of the threading path sane. The patch below was bootstrapped and tested on x86_64-unknown-linux-gnu, and also tested with a profiledbootstrap. I additionally tested with cpu2006, confirming that the amount of resulting cycle samples in the split cold sections reduced, and through manual inspection that many different cases were now correct. I also measured performance with cpu2006, running each benchmark multiple times on a Westmere and see some speedups (453.povray 1-2%, 403.gcc 1-1.5%, and noisy but positive speedups in 471.omnetpp and 483.xalancbmk). Looks like my mailer is corrupting the spacing, which makes it harder to look at the CFG examples in the big header comment block I added. So I have also included the patch as an attachment. Ok for stage 1? Thanks, Teresa 2014-03-26 Teresa Johnson * tree-ssa-threadupdate.c (struct ssa_local_info_t): New duplicate_blocks bitmap. (remove_ctrl_stmt_and_useless_edges): Ditto. (create_block_for_threading): Ditto. (compute_path_counts): New function. (update_profile): Ditto. (deduce_freq): Ditto. (recompute_probabilities): Ditto. (update_joiner_offpath_counts): Ditto. (ssa_fix_duplicate_block_edges): Update profile info. (ssa_create_duplicates): Pass new parameter. (ssa_redirect_edges): Remove old profile update. (thread_block_1): New duplicate_blocks bitmap, remove old profile update. (thread_single_edge): Pass new parameter. Index: tree-ssa-threadupdate.c =================================================================== --- tree-ssa-threadupdate.c (revision 208491) +++ tree-ssa-threadupdate.c (working copy) @@ -229,6 +229,9 @@ struct ssa_local_info_t /* TRUE if we thread one or more jumps, FALSE otherwise. */ bool jumps_threaded; + + /* Blocks duplicated for the thread. */ + bitmap duplicate_blocks; }; /* Passes which use the jump threading code register jump threading @@ -292,7 +295,8 @@ remove_ctrl_stmt_and_useless_edges (basic_block bb static void create_block_for_threading (basic_block bb, struct redirection_data *rd, - unsigned int count) + unsigned int count, + bitmap *duplicate_blocks) { edge_iterator ei; edge e; @@ -307,6 +311,8 @@ create_block_for_threading (basic_block bb, /* Zero out the profile, since the block is unreachable for now. */ rd->dup_blocks[count]->frequency = 0; rd->dup_blocks[count]->count = 0; + if (duplicate_blocks) + bitmap_set_bit (*duplicate_blocks, rd->dup_blocks[count]->index); } /* Main data structure to hold information for duplicates of BB. */ @@ -495,17 +501,457 @@ any_remaining_duplicated_blocks (vec J -> Son -> D (path 1) + C -> J -> Son -> E (path 2) + + Note that the control flow could be more complicated: + - Each jump threading path may have more than one incoming edge. I.e. A and + Ea could represent multiple incoming blocks/edges that are included in + path 1. + - There could be EDGE_NO_COPY_SRC_BLOCK edges after the joiner (either + before or after the "normal" copy block). These are not duplicated onto + the jump threading path, as they are single-successor. + - Any of the blocks along the path may have other incoming edges that + are not part of any jump threading path, but add profile counts along + the path. + + In the aboe example, after all jump threading is complete, we will + end up with the following control flow: + + A B C + | | | + Ea| |Eb |Ec + | | | + v v v + Ja J Jc + / \ / \Eon' / \ + Eona/ \ ---/---\-------- \Eonc + / \ / / \ \ + v v v v v + Sona Soff Son Sonc + \ /\ / + \___________ / \ _____/ + \ / \/ + vv v + D E + + The main issue to notice here is that when we are processing path 1 + (A->J->Son->D) we need to figure out the outgoing edge weights to + the duplicated edges Ja->Sona and Ja->Soff, while ensuring that the + sum of the incoming weights to D remain Ed. The problem with simply + assuming that Ja (and Jc when processing path 2) has the same outgoing + probabilities to its successors as the original block J, is that after + all paths are processed and other edges/counts removed (e.g. none + of Ec will reach D after processing path 2), we may end up with not + enough count flowing along duplicated edge Sona->D. + + Therefore, in the case of a joiner, we keep track of all counts + coming in along the current path, as well as from predecessors not + on any jump threading path (Eb in the above example). While we + first assume that the duplicated Eona for Ja->Sona has the same + probability as the original, we later compensate for other jump + threading paths that may eliminate edges. We do that by keep track + of all counts coming into the original path that are not in a jump + thread (Eb in the above example, but as noted earlier, there could + be other predecessors incoming to the path at various points, such + as at Son). Call this cumulative non-path count coming into the path + before D as Enonpath. We then ensure that the count from Sona->D is as at + least as big as (Ed - Enonpath), but no bigger than the minimum + weight along the jump threading path. The probabilities of both the + original and duplicated joiner block J and Ja will be adjusted + accordingly after the updates. */ + +static bool +compute_path_counts (struct redirection_data *rd, + ssa_local_info_t *local_info, + gcov_type *path_in_count_ptr, + gcov_type *path_out_count_ptr, + int *path_in_freq_ptr) +{ + edge e = rd->incoming_edges->e; + vec *path = THREAD_PATH (e); + edge elast = path->last ()->e; + gcov_type nonpath_count = 0; + bool has_joiner = false; + gcov_type path_in_count = 0; + int path_in_freq = 0; + + /* Start by accumulating incoming edge counts to the path's first bb + into a couple buckets: + path_in_count: total count of incoming edges that flow into the + current path. + nonpath_count: total count of incoming edges that are not + flowing along *any* path. These are the counts + that will still flow along the original path after + all path duplication is done by potentially multiple + calls to this routine. + (any other incoming edge counts are for a different jump threading + path that will be handled by a later call to this routine.) + To make this easier, start by recording all incoming edges that flow into + the current path in a bitmap. We could add up the path's incoming edge + counts here, but we still need to walk all the first bb's incoming edges + below to add up the counts of the other edges not included in this jump + threading path. */ + struct el *next, *el; + bitmap in_edge_srcs = BITMAP_ALLOC (NULL); + for (el = rd->incoming_edges; el; el = next) + { + next = el->next; + bitmap_set_bit (in_edge_srcs, el->e->src->index); + } + edge ein; + edge_iterator ei; + FOR_EACH_EDGE (ein, ei, e->dest->preds) + { + vec *ein_path = THREAD_PATH (ein); + /* Simply check the incoming edge src against the set captured above. */ + if (ein_path + && bitmap_bit_p (in_edge_srcs, (*ein_path)[0]->e->src->index)) + { + /* It is necessary but not sufficient that the last path edges + are identical. There may be different paths that share the + same last path edge in the case where the last edge has a nocopy + source block. */ + gcc_assert (ein_path->last ()->e == elast); + path_in_count += ein->count; + path_in_freq += EDGE_FREQUENCY (ein); + } + else if (!ein_path) + { + /* Keep track of the incoming edges that are not on any jump-threading + path. These counts will still flow out of original path after all + jump threading is complete. */ + nonpath_count += ein->count; + } + } + BITMAP_FREE (in_edge_srcs); + + /* Now compute the fraction of the total count coming into the first + path bb that is from the current threading path. */ + gcov_type total_count = e->dest->count; + /* Handle incoming profile insanities. */ + if (total_count < path_in_count) + path_in_count = total_count; + int onpath_scale = GCOV_COMPUTE_SCALE (path_in_count, total_count); + + /* Walk the entire path to do some more computation in order to estimate + how much of the path_in_count will flow out of the duplicated threading + path. In the non-joiner case this is straightforward (it should be + the same as path_in_count, although we will handle incoming profile + insanities by setting it equal to the minimum count along the path). + + In the joiner case, we need to estimate how much of the path_in_count + will stay on the threading path after the joiner's conditional branch. + We don't really know for sure how much of the counts + associated with this path go to each successor of the joiner, but we'll + estimate based on the fraction of the total count coming into the path + bb was from the threading paths (computed above in onpath_scale). + Afterwards, we will need to do some fixup to account for other threading + paths and possible profile insanities. + + In order to estimate the joiner case's counts we also need to update + nonpath_count with any additional counts coming into the path. Other + blocks along the path may have additional predecessors from outside + the path. */ + gcov_type path_out_count = path_in_count; + gcov_type min_path_count = path_in_count; + for (unsigned int i = 1; i < path->length (); i++) + { + edge epath = (*path)[i]->e; + gcov_type cur_count = epath->count; + if ((*path)[i]->type == EDGE_COPY_SRC_JOINER_BLOCK) + { + has_joiner = true; + cur_count = apply_probability (cur_count, onpath_scale); + } + /* In the joiner case we need to update nonpath_count for any edges + coming into the path that will contribute to the count flowing + into the path successor. */ + if (has_joiner && epath != elast) + { + /* Look for other incoming edges after joiner. */ + FOR_EACH_EDGE (ein, ei, epath->dest->preds) + { + if (ein != epath + /* Ignore in edges from blocks we have duplicated for a + threading path, which have duplicated edge counts until + they are redirected by an invocation of this routine. */ + && !bitmap_bit_p (local_info->duplicate_blocks, + ein->src->index)) + nonpath_count += ein->count; + } + } + if (cur_count < path_out_count) + path_out_count = cur_count; + if (epath->count < min_path_count) + min_path_count = epath->count; + } + + /* We computed path_out_count above assuming that this path targeted + the joiner's on-path successor with the same likelihood as it + reached the joiner. However, other thread paths through the joiner + may take a different path through the normal copy source block + (i.e. they have a different elast), meaning that they do not + contribute any counts to this path's elast. As a result, it may + turn out that this path must have more count flowing to the on-path + successor of the joiner. Essentially, all of this path's elast + count must be contributed by this path and any nonpath counts + (since any path through the joiner with a different elast will not + include a copy of this elast in its duplicated path). + So ensure that this path's path_out_count is at least the + difference between elast->count and nonpath_count. Otherwise the edge + counts after threading will not be sane. */ + if (has_joiner && path_out_count < elast->count - nonpath_count) + { + path_out_count = elast->count - nonpath_count; + /* But neither can we go above the minimum count along the path + we are duplicating. This can be an issue due to profile + insanities coming in to this pass. */ + if (path_out_count > min_path_count) + path_out_count = min_path_count; + } + + *path_in_count_ptr = path_in_count; + *path_out_count_ptr = path_out_count; + *path_in_freq_ptr = path_in_freq; + return has_joiner; +} + + +/* Update the counts and frequencies for both an original path + edge EPATH and its duplicate EDUP. The duplicate source block + will get a count/frequency of PATH_IN_COUNT and PATH_IN_FREQ, + and the duplicate edge EDUP will have a count of PATH_OUT_COUNT. */ +static void +update_profile (edge epath, edge edup, gcov_type path_in_count, + gcov_type path_out_count, int path_in_freq) +{ + + /* First update the duplicated block's count / frequency. */ + if (edup) + { + basic_block dup_block = edup->src; + gcc_assert (dup_block->count == 0); + gcc_assert (dup_block->frequency == 0); + dup_block->count = path_in_count; + dup_block->frequency = path_in_freq; + } + + /* Now update the original block's count and frequency in the + opposite manner - remove the counts/freq that will flow + into the duplicated block. Handle underflow due to precision/ + rounding issues. */ + epath->src->count -= path_in_count; + if (epath->src->count < 0) + epath->src->count = 0; + epath->src->frequency -= path_in_freq; + if (epath->src->frequency < 0) + epath->src->frequency = 0; + + /* Next update this path edge's original and duplicated counts. We know + that the duplicated path will have path_out_count flowing + out of it (in the joiner case this is the count along the duplicated path + out of the duplicated joiner). This count can then be removed from the + original path edge. */ + if (edup) + edup->count = path_out_count; + epath->count -= path_out_count; + gcc_assert (epath->count >= 0); +} + + +/* This routine will determine what frequency is needed by an edge E + to ensure that its destination block meets its current block frequency. + This is used when we don't know E's probability. */ + +static int +deduce_freq (edge e) +{ + edge_iterator ei; + edge epred; + int freq = e->dest->frequency; + FOR_EACH_EDGE (epred, ei, e->dest->preds) + { + if (epred == e) + continue; + freq -= EDGE_FREQUENCY (epred); + } + if (freq < 0) + freq = 0; + return freq; +} + + +/* The duplicate and original joiner blocks may end up with different + probabilities (different from both the original and from each other). + Recompute the probabilities here once we have updated the edge + counts and frequencies. */ + +static void +recompute_probabilities (basic_block bb) +{ + edge esucc; + edge_iterator ei; + FOR_EACH_EDGE (esucc, ei, bb->succs) + { + if (bb->count) + esucc->probability = GCOV_COMPUTE_SCALE (esucc->count, + bb->count); + else if (bb->frequency) + esucc->probability = GCOV_COMPUTE_SCALE (deduce_freq (esucc), + bb->frequency); + if (esucc->probability > REG_BR_PROB_BASE) + { + /* Can happen with missing/guessed probabilities, since we + may determine that more is flowing along duplicated + path than joiner succ probabilities allowed. + Counts and freqs will be insane after jump threading, + at least make sure probability is sane or we will + get a flow verification error. + Not much we can do to make counts/freqs sane without + redoing the profile estimation. */ + esucc->probability = REG_BR_PROB_BASE; + } + } +} + + +/* Update the counts of the original and duplicated edges from a joiner + that go off path, given that we have already determined that the + duplicate joiner DUP_BB has incoming count PATH_IN_COUNT and + outgoing count along the path PATH_OUT_COUNT. The original (on-)path + edge from joiner is EPATH. */ + +static void +update_joiner_offpath_counts (edge epath, basic_block dup_bb, + gcov_type path_in_count, + gcov_type path_out_count) +{ + /* Compute the count that currently flows off path from the joiner. + In other words, the total count of joiner's out edges other than + epath. Compute this by walking the successors instead of + subtracting epath's count from the joiner bb count, since there + are sometimes slight insanities where the total out edge count is + larger than the bb count (possibly due to rounding/truncation + errors). */ + gcov_type total_orig_off_path_count = 0; + edge enonpath; + edge_iterator ei; + FOR_EACH_EDGE (enonpath, ei, epath->src->succs) + { + if (enonpath == epath) + continue; + total_orig_off_path_count += enonpath->count; + } + + /* For the path that we are duplicating, the amount that will flow + off path from the duplicated joiner is the delta between the + path's cumulative in count and the portion of that count we + estimated above as flowing from the joiner along the duplicated + path. */ + gcov_type total_dup_off_path_count = path_in_count - path_out_count; + + /* Now do the actual updates of the off-path edges. */ + FOR_EACH_EDGE (enonpath, ei, epath->src->succs) + { + /* Look for edges going off of the threading path. */ + if (enonpath == epath) + continue; + + /* Find the corresponding edge out of the duplicated joiner. */ + edge enonpathdup = find_edge (dup_bb, enonpath->dest); + gcc_assert (enonpathdup); + + /* We can't use the original probability of the joiner's out + edges, since the probabilities of the original branch + and the duplicated branches may vary after all threading is + complete. But apportion the duplicated joiner's off-path + total edge count computed earlier (total_dup_off_path_count) + among the duplicated off-path edges based on their original + ratio to the full off-path count (total_orig_off_path_count). + */ + int scale = GCOV_COMPUTE_SCALE (enonpath->count, + total_orig_off_path_count); + /* Give the duplicated offpath edge a portion of the duplicated + total. */ + enonpathdup->count = apply_scale (scale, + total_dup_off_path_count); + /* Now update the original offpath edge count, handling underflow + due to rounding errors. */ + enonpath->count -= enonpathdup->count; + if (enonpath->count < 0) + enonpath->count = 0; + } +} + /* Wire up the outgoing edges from the duplicate blocks and - update any PHIs as needed. */ + update any PHIs as needed. Also update the profile counts + on the original and duplicate blocks and edges. */ void ssa_fix_duplicate_block_edges (struct redirection_data *rd, ssa_local_info_t *local_info) { edge e = rd->incoming_edges->e; vec *path = THREAD_PATH (e); + edge elast = path->last ()->e; + gcov_type path_in_count = 0; + gcov_type path_out_count = 0; + int path_in_freq = 0; + /* First determine how much profile count to move from original + path to the duplicate path. This is tricky in the presence of + a joiner (see comments for compute_path_counts), where some portion + of the path's counts will flow off-path from the joiner. In the + non-joiner case the path_in_count and path_out_count should be the + same. */ + bool has_joiner = compute_path_counts (rd, local_info, + &path_in_count, &path_out_count, + &path_in_freq); + + int cur_path_freq = path_in_freq; for (unsigned int count = 0, i = 1; i < path->length (); i++) { + edge epath = (*path)[i]->e; + /* If we were threading through an joiner block, then we want to keep its control statement and redirect an outgoing edge. Else we want to remove the control statement & edges, then create @@ -515,6 +961,8 @@ ssa_fix_duplicate_block_edges (struct redirection_ edge victim; edge e2; + gcc_assert (has_joiner); + /* This updates the PHIs at the destination of the duplicate block. */ update_destination_phis (local_info->bb, rd->dup_blocks[count]); @@ -528,14 +976,13 @@ ssa_fix_duplicate_block_edges (struct redirection_ threading path. */ if (!any_remaining_duplicated_blocks (path, i)) { - e2 = redirect_edge_and_branch (victim, path->last ()->e->dest); - e2->count = path->last ()->e->count; + e2 = redirect_edge_and_branch (victim, elast->dest); /* If we redirected the edge, then we need to copy PHI arguments at the target. If the edge already existed (e2 != victim case), then the PHIs in the target already have the correct arguments. */ if (e2 == victim) - copy_phi_args (e2->dest, path->last ()->e, e2); + copy_phi_args (e2->dest, elast, e2); } else { @@ -562,7 +1009,31 @@ ssa_fix_duplicate_block_edges (struct redirection_ } } } - count++; + + /* Update the counts and frequency of both the original block + and path edge, and the duplicates. The path duplicate's + incoming count and frequency are the totals for all edges + incoming to this jump threading path computed earlier. + And we know that the duplicated path will have path_out_count + flowing out of it (i.e. along the duplicated path out of the + duplicated joiner). */ + update_profile (epath, e2, path_in_count, path_out_count, + path_in_freq); + + /* Next we need to update the counts of the original and duplicated + edges from the joiner that go off path. */ + update_joiner_offpath_counts (epath, e2->src, path_in_count, + path_out_count); + + /* Finally, we need to set the probabilities on the duplicated + edges out of the duplicated joiner (e2->src). The probabilities + along the original path will all be updated below after we finish + processing the whole path. */ + recompute_probabilities (e2->src); + + /* Record the frequency flowing to the downstream duplicated + path blocks. */ + cur_path_freq = EDGE_FREQUENCY (e2); } else if ((*path)[i]->type == EDGE_COPY_SRC_BLOCK) { @@ -570,9 +1041,55 @@ ssa_fix_duplicate_block_edges (struct redirection_ create_edge_and_update_destination_phis (rd, rd->dup_blocks[count]); if (count == 1) single_succ_edge (rd->dup_blocks[1])->aux = NULL; + + /* Update the counts and frequency of both the original block + and path edge, and the duplicates. Since we are now after + any joiner that may have existed on the path, the count + flowing along the duplicated threaded path is path_out_count. + If we didn't have a joiner, then cur_path_freq was the sum + of the total frequencies along all incoming edges to the + thread path (path_in_freq). If we had a joiner, it would have + been updated at the end of that handling to the edge frequency + along the duplicated joiner path edge. */ + update_profile (epath, EDGE_SUCC (rd->dup_blocks[count], 0), + path_out_count, path_out_count, + cur_path_freq); + } + else + { + /* No copy case. In this case we don't have an equivalent block + on the duplicated thread path to update, but we do need + to remove the portion of the counts/freqs that were moved + to the duplicated path from the counts/freqs flowing through + this block on the original path. Since all the no-copy edges + are after any joiner, the removed count is the same as + path_out_count. + + If we didn't have a joiner, then cur_path_freq was the sum + of the total frequencies along all incoming edges to the + thread path (path_in_freq). If we had a joiner, it would have + been updated at the end of that handling to the edge frequency + along the duplicated joiner path edge. */ + update_profile (epath, NULL, path_out_count, path_out_count, + cur_path_freq); + } + + /* Increment the index into the duplicated path when we processed + a duplicated block. */ + if ((*path)[i]->type == EDGE_COPY_SRC_JOINER_BLOCK + || (*path)[i]->type == EDGE_COPY_SRC_BLOCK) + { count++; - } + } } + + /* Now walk orig blocks and update their probabilities, since the + counts and freqs should be updated properly by above loop. */ + for (unsigned int i = 1; i < path->length (); i++) + { + edge epath = (*path)[i]->e; + recompute_probabilities (epath->src); + } } /* Hash table traversal callback routine to create duplicate blocks. */ @@ -598,7 +1115,8 @@ ssa_create_duplicates (struct redirection_data **s if ((*path)[i]->type == EDGE_COPY_SRC_BLOCK || (*path)[i]->type == EDGE_COPY_SRC_JOINER_BLOCK) { - create_block_for_threading ((*path)[i]->e->src, rd, 1); + create_block_for_threading ((*path)[i]->e->src, rd, 1, + &local_info->duplicate_blocks); break; } } @@ -607,7 +1125,8 @@ ssa_create_duplicates (struct redirection_data **s use the template to create a new block. */ if (local_info->template_block == NULL) { - create_block_for_threading ((*path)[1]->e->src, rd, 0); + create_block_for_threading ((*path)[1]->e->src, rd, 0, + &local_info->duplicate_blocks); local_info->template_block = rd->dup_blocks[0]; /* We do not create any outgoing edges for the template. We will @@ -616,7 +1135,8 @@ ssa_create_duplicates (struct redirection_data **s } else { - create_block_for_threading (local_info->template_block, rd, 0); + create_block_for_threading (local_info->template_block, rd, 0, + &local_info->duplicate_blocks); /* Go ahead and wire up outgoing edges and update PHIs for the duplicate block. */ @@ -686,19 +1206,6 @@ ssa_redirect_edges (struct redirection_data **slot fprintf (dump_file, " Threaded jump %d --> %d to %d\n", e->src->index, e->dest->index, rd->dup_blocks[0]->index); - rd->dup_blocks[0]->count += e->count; - - /* Excessive jump threading may make frequencies large enough so - the computation overflows. */ - if (rd->dup_blocks[0]->frequency < BB_FREQ_MAX * 2) - rd->dup_blocks[0]->frequency += EDGE_FREQUENCY (e); - - /* In the case of threading through a joiner block, the outgoing - edges from the duplicate block were updated when they were - redirected during ssa_fix_duplicate_block_edges. */ - if ((*path)[1]->type != EDGE_COPY_SRC_JOINER_BLOCK) - EDGE_SUCC (rd->dup_blocks[0], 0)->count += e->count; - /* Redirect the incoming edge (possibly to the joiner block) to the appropriate duplicate block. */ e2 = redirect_edge_and_branch (e, rd->dup_blocks[0]); @@ -781,6 +1288,8 @@ thread_block_1 (basic_block bb, bool noloop_only, ssa_local_info_t local_info; struct loop *loop = bb->loop_father; + local_info.duplicate_blocks = BITMAP_ALLOC (NULL); + /* To avoid scanning a linear array for the element we need we instead use a hash table. For normal code there should be no noticeable difference. However, if we have a block with a large number of @@ -865,10 +1374,6 @@ thread_block_1 (basic_block bb, bool noloop_only, continue; } - if (e->dest == e2->src) - update_bb_profile_for_threading (e->dest, EDGE_FREQUENCY (e), - e->count, (*THREAD_PATH (e))[1]->e); - /* Insert the outgoing edge into the hash table if it is not already in the hash table. */ lookup_redirection_data (e, INSERT); @@ -921,6 +1426,9 @@ thread_block_1 (basic_block bb, bool noloop_only, && bb == bb->loop_father->header) set_loop_copy (bb->loop_father, NULL); + BITMAP_FREE (local_info.duplicate_blocks); + local_info.duplicate_blocks = NULL; + /* Indicate to our caller whether or not any jumps were threaded. */ return local_info.jumps_threaded; } @@ -987,7 +1495,7 @@ thread_single_edge (edge e) npath->safe_push (x); rd.path = npath; - create_block_for_threading (bb, &rd, 0); + create_block_for_threading (bb, &rd, 0, NULL); remove_ctrl_stmt_and_useless_edges (rd.dup_blocks[0], NULL); create_edge_and_update_destination_phis (&rd, rd.dup_blocks[0]); -- Teresa Johnson | Software Engineer | tejohnson@google.com | 408-460-2413 --001a113a2b7aed0fec04f58b0b43 Content-Type: text/plain; charset=US-ASCII; name="patch.diff" Content-Disposition: attachment; filename="patch.diff" Content-Transfer-Encoding: base64 X-Attachment-Id: f_ht99dn0q0 Content-length: 41119 MjAxNC0wMy0yNiAgVGVyZXNhIEpvaG5zb24gIDx0ZWpvaG5zb25AZ29vZ2xl LmNvbT4KCgkqIHRyZWUtc3NhLXRocmVhZHVwZGF0ZS5jIChzdHJ1Y3Qgc3Nh X2xvY2FsX2luZm9fdCk6IE5ldwoJZHVwbGljYXRlX2Jsb2NrcyBiaXRtYXAu CgkocmVtb3ZlX2N0cmxfc3RtdF9hbmRfdXNlbGVzc19lZGdlcyk6IERpdHRv LgoJKGNyZWF0ZV9ibG9ja19mb3JfdGhyZWFkaW5nKTogRGl0dG8uCgkoY29t cHV0ZV9wYXRoX2NvdW50cyk6IE5ldyBmdW5jdGlvbi4KCSh1cGRhdGVfcHJv ZmlsZSk6IERpdHRvLgoJKGRlZHVjZV9mcmVxKTogRGl0dG8uCgkocmVjb21w dXRlX3Byb2JhYmlsaXRpZXMpOiBEaXR0by4KCSh1cGRhdGVfam9pbmVyX29m ZnBhdGhfY291bnRzKTogRGl0dG8uCgkoc3NhX2ZpeF9kdXBsaWNhdGVfYmxv Y2tfZWRnZXMpOiBVcGRhdGUgcHJvZmlsZSBpbmZvLgoJKHNzYV9jcmVhdGVf ZHVwbGljYXRlcyk6IFBhc3MgbmV3IHBhcmFtZXRlci4KCShzc2FfcmVkaXJl Y3RfZWRnZXMpOiBSZW1vdmUgb2xkIHByb2ZpbGUgdXBkYXRlLgoJKHRocmVh ZF9ibG9ja18xKTogTmV3IGR1cGxpY2F0ZV9ibG9ja3MgYml0bWFwLAoJcmVt b3ZlIG9sZCBwcm9maWxlIHVwZGF0ZS4KCSh0aHJlYWRfc2luZ2xlX2VkZ2Up OiBQYXNzIG5ldyBwYXJhbWV0ZXIuCgpJbmRleDogdHJlZS1zc2EtdGhyZWFk dXBkYXRlLmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gdHJlZS1zc2Et dGhyZWFkdXBkYXRlLmMJKHJldmlzaW9uIDIwODQ5MSkKKysrIHRyZWUtc3Nh LXRocmVhZHVwZGF0ZS5jCSh3b3JraW5nIGNvcHkpCkBAIC0yMjksNiArMjI5 LDkgQEAgc3RydWN0IHNzYV9sb2NhbF9pbmZvX3QKIAogICAvKiBUUlVFIGlm IHdlIHRocmVhZCBvbmUgb3IgbW9yZSBqdW1wcywgRkFMU0Ugb3RoZXJ3aXNl LiAgKi8KICAgYm9vbCBqdW1wc190aHJlYWRlZDsKKworICAvKiBCbG9ja3Mg ZHVwbGljYXRlZCBmb3IgdGhlIHRocmVhZC4gICovCisgIGJpdG1hcCBkdXBs aWNhdGVfYmxvY2tzOwogfTsKIAogLyogUGFzc2VzIHdoaWNoIHVzZSB0aGUg anVtcCB0aHJlYWRpbmcgY29kZSByZWdpc3RlciBqdW1wIHRocmVhZGluZwpA QCAtMjkyLDcgKzI5NSw4IEBAIHJlbW92ZV9jdHJsX3N0bXRfYW5kX3VzZWxl c3NfZWRnZXMgKGJhc2ljX2Jsb2NrIGJiCiBzdGF0aWMgdm9pZAogY3JlYXRl X2Jsb2NrX2Zvcl90aHJlYWRpbmcgKGJhc2ljX2Jsb2NrIGJiLAogCQkJICAg IHN0cnVjdCByZWRpcmVjdGlvbl9kYXRhICpyZCwKLQkJCSAgICB1bnNpZ25l ZCBpbnQgY291bnQpCisJCQkgICAgdW5zaWduZWQgaW50IGNvdW50LAorCQkJ ICAgIGJpdG1hcCAqZHVwbGljYXRlX2Jsb2NrcykKIHsKICAgZWRnZV9pdGVy YXRvciBlaTsKICAgZWRnZSBlOwpAQCAtMzA3LDYgKzMxMSw4IEBAIGNyZWF0 ZV9ibG9ja19mb3JfdGhyZWFkaW5nIChiYXNpY19ibG9jayBiYiwKICAgLyog WmVybyBvdXQgdGhlIHByb2ZpbGUsIHNpbmNlIHRoZSBibG9jayBpcyB1bnJl YWNoYWJsZSBmb3Igbm93LiAgKi8KICAgcmQtPmR1cF9ibG9ja3NbY291bnRd LT5mcmVxdWVuY3kgPSAwOwogICByZC0+ZHVwX2Jsb2Nrc1tjb3VudF0tPmNv dW50ID0gMDsKKyAgaWYgKGR1cGxpY2F0ZV9ibG9ja3MpCisgICAgYml0bWFw X3NldF9iaXQgKCpkdXBsaWNhdGVfYmxvY2tzLCByZC0+ZHVwX2Jsb2Nrc1tj b3VudF0tPmluZGV4KTsKIH0KIAogLyogTWFpbiBkYXRhIHN0cnVjdHVyZSB0 byBob2xkIGluZm9ybWF0aW9uIGZvciBkdXBsaWNhdGVzIG9mIEJCLiAgKi8K QEAgLTQ5NSwxNyArNTAxLDQ1NyBAQCBhbnlfcmVtYWluaW5nX2R1cGxpY2F0 ZWRfYmxvY2tzICh2ZWM8anVtcF90aHJlYWRfZQogICByZXR1cm4gZmFsc2U7 CiB9CiAKKworLyogQ29tcHV0ZSB0aGUgYW1vdW50IG9mIHByb2ZpbGUgY291 bnQvZnJlcXVlbmN5IGNvbWluZyBpbnRvIHRoZSBqdW1wIHRocmVhZGluZwor ICAgcGF0aCBzdG9yZWQgaW4gUkQgdGhhdCB3ZSBhcmUgZHVwbGljYXRpbmcs IHJldHVybmVkIGluIFBBVEhfSU5fQ09VTlRfUFRSIGFuZAorICAgUEFUSF9J Tl9GUkVRX1BUUiwgYXMgd2VsbCBhcyB0aGUgYW1vdW50IG9mIGNvdW50cyBm bG93aW5nIG91dCBvZiB0aGUKKyAgIGR1cGxpY2F0ZWQgcGF0aCwgcmV0dXJu ZWQgaW4gUEFUSF9PVVRfQ09VTlRfUFRSLiAgTE9DQUxfSU5GTyBpcyB1c2Vk IHRvCisgICBpZGVudGlmeSBibG9ja3MgZHVwbGljYXRlZCBmb3IganVtcCB0 aHJlYWRpbmcsIHdoaWNoIGhhdmUgZHVwbGljYXRlZAorICAgZWRnZXMgdGhh dCBuZWVkIHRvIGJlIGlnbm9yZWQgaW4gdGhlIGFuYWx5c2lzLiAgUmV0dXJu IHRydWUgaWYgcGF0aCBjb250YWlucworICAgYSBqb2luZXIsIGZhbHNlIG90 aGVyd2lzZS4KKworICAgSW4gdGhlIG5vbi1qb2luZXIgY2FzZSwgdGhpcyBp cyBzdHJhaWdodGZvcndhcmQgLSBhbGwgdGhlIGNvdW50cy9mcmVxdWVuY3kK KyAgIGZsb3dpbmcgaW50byB0aGUganVtcCB0aHJlYWRpbmcgcGF0aCBzaG91 bGQgZmxvdyB0aHJvdWdoIHRoZSBkdXBsaWNhdGVkCisgICBibG9jayBhbmQg b3V0IG9mIHRoZSBkdXBsaWNhdGVkIHBhdGguCisKKyAgIEluIHRoZSBqb2lu ZXIgY2FzZSwgaXQgaXMgdmVyeSB0cmlja3kuICBTb21lIG9mIHRoZSBjb3Vu dHMgZmxvd2luZyBpbnRvCisgICB0aGUgb3JpZ2luYWwgcGF0aCBnbyBvZmZw YXRoIGF0IHRoZSBqb2luZXIuICBUaGUgcHJvYmxlbSBpcyB0aGF0IHdoaWxl CisgICB3ZSBrbm93IGhvdyBtdWNoIHRvdGFsIGNvdW50IGdvZXMgb2ZmLXBh dGggaW4gdGhlIG9yaWdpbmFsIGNvbnRyb2wgZmxvdywKKyAgIHdlIGRvbid0 IGtub3cgaG93IG1hbnkgb2YgdGhlIGNvdW50cyBjb3JyZXNwb25kaW5nIHRv IGp1c3QgdGhlIGp1bXAKKyAgIHRocmVhZGluZyBwYXRoIGdvIG9mZnBhdGgg YXQgdGhlIGpvaW5lci4KKworICAgRm9yIGV4YW1wbGUsIGFzc3VtZSB3ZSBo YXZlIHRoZSBmb2xsb3dpbmcgY29udHJvbCBmbG93IGFuZCBpZGVudGlmaWVk CisgICBqdW1wIHRocmVhZGluZyBwYXRoczoKKworICAgICAgICAgICAgICAg IEEgICAgIEIgICAgIEMKKyAgICAgICAgICAgICAgICAgXCAgICB8ICAgIC8K KyAgICAgICAgICAgICAgIEVhIFwgICB8RWIgLyBFYworICAgICAgICAgICAg ICAgICAgIFwgIHwgIC8KKyAgICAgICAgICAgICAgICAgICAgdiB2IHYKKyAg ICAgICAgICAgICAgICAgICAgICBKICAgICAgIDwtLSBKb2luZXIKKyAgICAg ICAgICAgICAgICAgICAgIC8gXAorICAgICAgICAgICAgICAgIEVvZmYvICAg XEVvbgorICAgICAgICAgICAgICAgICAgIC8gICAgIFwKKyAgICAgICAgICAg ICAgICAgIHYgICAgICAgdgorICAgICAgICAgICAgICAgIFNvZmYgICAgIFNv biAgPC0tLSBOb3JtYWwKKyAgICAgICAgICAgICAgICAgICAgICAgICAvXAor ICAgICAgICAgICAgICAgICAgICAgIEVkLyAgXCBFZQorICAgICAgICAgICAg ICAgICAgICAgICAvICAgIFwKKyAgICAgICAgICAgICAgICAgICAgICB2ICAg ICB2CisgICAgICAgICAgICAgICAgICAgICAgRCAgICAgIEUKKworICAgICAg ICAgICAgSnVtcCB0aHJlYWRpbmcgcGF0aHM6IEEgLT4gSiAtPiBTb24gLT4g RCAocGF0aCAxKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IEMgLT4gSiAtPiBTb24gLT4gRSAocGF0aCAyKQorCisgICBOb3RlIHRoYXQg dGhlIGNvbnRyb2wgZmxvdyBjb3VsZCBiZSBtb3JlIGNvbXBsaWNhdGVkOgor ICAgLSBFYWNoIGp1bXAgdGhyZWFkaW5nIHBhdGggbWF5IGhhdmUgbW9yZSB0 aGFuIG9uZSBpbmNvbWluZyBlZGdlLiAgSS5lLiBBIGFuZAorICAgRWEgY291 bGQgcmVwcmVzZW50IG11bHRpcGxlIGluY29taW5nIGJsb2Nrcy9lZGdlcyB0 aGF0IGFyZSBpbmNsdWRlZCBpbgorICAgcGF0aCAxLgorICAgLSBUaGVyZSBj b3VsZCBiZSBFREdFX05PX0NPUFlfU1JDX0JMT0NLIGVkZ2VzIGFmdGVyIHRo ZSBqb2luZXIgKGVpdGhlcgorICAgYmVmb3JlIG9yIGFmdGVyIHRoZSAibm9y bWFsIiBjb3B5IGJsb2NrKS4gIFRoZXNlIGFyZSBub3QgZHVwbGljYXRlZCBv bnRvCisgICB0aGUganVtcCB0aHJlYWRpbmcgcGF0aCwgYXMgdGhleSBhcmUg c2luZ2xlLXN1Y2Nlc3Nvci4KKyAgIC0gQW55IG9mIHRoZSBibG9ja3MgYWxv bmcgdGhlIHBhdGggbWF5IGhhdmUgb3RoZXIgaW5jb21pbmcgZWRnZXMgdGhh dAorICAgYXJlIG5vdCBwYXJ0IG9mIGFueSBqdW1wIHRocmVhZGluZyBwYXRo LCBidXQgYWRkIHByb2ZpbGUgY291bnRzIGFsb25nCisgICB0aGUgcGF0aC4K KworICAgSW4gdGhlIGFib2UgZXhhbXBsZSwgYWZ0ZXIgYWxsIGp1bXAgdGhy ZWFkaW5nIGlzIGNvbXBsZXRlLCB3ZSB3aWxsCisgICBlbmQgdXAgd2l0aCB0 aGUgZm9sbG93aW5nIGNvbnRyb2wgZmxvdzoKKworICAgICAgICAgICAgICAg IEEgICAgICAgICAgQiAgICAgICAgICAgIEMKKyAgICAgICAgICAgICAgICB8 ICAgICAgICAgIHwgICAgICAgICAgICB8CisgICAgICAgICAgICAgIEVhfCAg ICAgICAgICB8RWIgICAgICAgICAgfEVjCisgICAgICAgICAgICAgICAgfCAg ICAgICAgICB8ICAgICAgICAgICAgfAorICAgICAgICAgICAgICAgIHYgICAg ICAgICAgdiAgICAgICAgICAgIHYKKyAgICAgICAgICAgICAgIEphICAgICAg ICAgIEogICAgICAgICAgIEpjCisgICAgICAgICAgICAgICAvIFwgICAgICAg IC8gXEVvbicgICAgIC8gXAorICAgICAgICAgIEVvbmEvICAgXCAgIC0tLS8t LS1cLS0tLS0tLS0gICBcRW9uYworICAgICAgICAgICAgIC8gICAgIFwgLyAg LyAgICAgXCAgICAgICAgICAgXAorICAgICAgICAgICAgdiAgICAgICB2ICB2 ICAgICAgIHYgICAgICAgICAgdgorICAgICAgICAgICBTb25hICAgICBTb2Zm ICAgICAgU29uICAgICAgICBTb25jCisgICAgICAgICAgICAgXCAgICAgICAg ICAgICAgICAgL1wgICAgICAgICAvCisgICAgICAgICAgICAgIFxfX19fX19f X19fXyAgICAvICBcICBfX19fXy8KKyAgICAgICAgICAgICAgICAgICAgICAg ICAgXCAgLyAgICBcLworICAgICAgICAgICAgICAgICAgICAgICAgICAgdnYg ICAgICB2CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgRCAgICAgIEUK KworICAgVGhlIG1haW4gaXNzdWUgdG8gbm90aWNlIGhlcmUgaXMgdGhhdCB3 aGVuIHdlIGFyZSBwcm9jZXNzaW5nIHBhdGggMQorICAgKEEtPkotPlNvbi0+ RCkgd2UgbmVlZCB0byBmaWd1cmUgb3V0IHRoZSBvdXRnb2luZyBlZGdlIHdl aWdodHMgdG8KKyAgIHRoZSBkdXBsaWNhdGVkIGVkZ2VzIEphLT5Tb25hIGFu ZCBKYS0+U29mZiwgd2hpbGUgZW5zdXJpbmcgdGhhdCB0aGUKKyAgIHN1bSBv ZiB0aGUgaW5jb21pbmcgd2VpZ2h0cyB0byBEIHJlbWFpbiBFZC4gIFRoZSBw cm9ibGVtIHdpdGggc2ltcGx5CisgICBhc3N1bWluZyB0aGF0IEphIChhbmQg SmMgd2hlbiBwcm9jZXNzaW5nIHBhdGggMikgaGFzIHRoZSBzYW1lIG91dGdv aW5nCisgICBwcm9iYWJpbGl0aWVzIHRvIGl0cyBzdWNjZXNzb3JzIGFzIHRo ZSBvcmlnaW5hbCBibG9jayBKLCBpcyB0aGF0IGFmdGVyCisgICBhbGwgcGF0 aHMgYXJlIHByb2Nlc3NlZCBhbmQgb3RoZXIgZWRnZXMvY291bnRzIHJlbW92 ZWQgKGUuZy4gbm9uZQorICAgb2YgRWMgd2lsbCByZWFjaCBEIGFmdGVyIHBy b2Nlc3NpbmcgcGF0aCAyKSwgd2UgbWF5IGVuZCB1cCB3aXRoIG5vdAorICAg ZW5vdWdoIGNvdW50IGZsb3dpbmcgYWxvbmcgZHVwbGljYXRlZCBlZGdlIFNv bmEtPkQuCisKKyAgIFRoZXJlZm9yZSwgaW4gdGhlIGNhc2Ugb2YgYSBqb2lu ZXIsIHdlIGtlZXAgdHJhY2sgb2YgYWxsIGNvdW50cworICAgY29taW5nIGlu IGFsb25nIHRoZSBjdXJyZW50IHBhdGgsIGFzIHdlbGwgYXMgZnJvbSBwcmVk ZWNlc3NvcnMgbm90CisgICBvbiBhbnkganVtcCB0aHJlYWRpbmcgcGF0aCAo RWIgaW4gdGhlIGFib3ZlIGV4YW1wbGUpLiAgV2hpbGUgd2UKKyAgIGZpcnN0 IGFzc3VtZSB0aGF0IHRoZSBkdXBsaWNhdGVkIEVvbmEgZm9yIEphLT5Tb25h IGhhcyB0aGUgc2FtZQorICAgcHJvYmFiaWxpdHkgYXMgdGhlIG9yaWdpbmFs LCB3ZSBsYXRlciBjb21wZW5zYXRlIGZvciBvdGhlciBqdW1wCisgICB0aHJl YWRpbmcgcGF0aHMgdGhhdCBtYXkgZWxpbWluYXRlIGVkZ2VzLiAgV2UgZG8g dGhhdCBieSBrZWVwIHRyYWNrCisgICBvZiBhbGwgY291bnRzIGNvbWluZyBp bnRvIHRoZSBvcmlnaW5hbCBwYXRoIHRoYXQgYXJlIG5vdCBpbiBhIGp1bXAK KyAgIHRocmVhZCAoRWIgaW4gdGhlIGFib3ZlIGV4YW1wbGUsIGJ1dCBhcyBu b3RlZCBlYXJsaWVyLCB0aGVyZSBjb3VsZAorICAgYmUgb3RoZXIgcHJlZGVj ZXNzb3JzIGluY29taW5nIHRvIHRoZSBwYXRoIGF0IHZhcmlvdXMgcG9pbnRz LCBzdWNoCisgICBhcyBhdCBTb24pLiAgQ2FsbCB0aGlzIGN1bXVsYXRpdmUg bm9uLXBhdGggY291bnQgY29taW5nIGludG8gdGhlIHBhdGgKKyAgIGJlZm9y ZSBEIGFzIEVub25wYXRoLiAgV2UgdGhlbiBlbnN1cmUgdGhhdCB0aGUgY291 bnQgZnJvbSBTb25hLT5EIGlzIGFzIGF0CisgICBsZWFzdCBhcyBiaWcgYXMg KEVkIC0gRW5vbnBhdGgpLCBidXQgbm8gYmlnZ2VyIHRoYW4gdGhlIG1pbmlt dW0KKyAgIHdlaWdodCBhbG9uZyB0aGUganVtcCB0aHJlYWRpbmcgcGF0aC4g IFRoZSBwcm9iYWJpbGl0aWVzIG9mIGJvdGggdGhlCisgICBvcmlnaW5hbCBh bmQgZHVwbGljYXRlZCBqb2luZXIgYmxvY2sgSiBhbmQgSmEgd2lsbCBiZSBh ZGp1c3RlZAorICAgYWNjb3JkaW5nbHkgYWZ0ZXIgdGhlIHVwZGF0ZXMuICAq LworCitzdGF0aWMgYm9vbAorY29tcHV0ZV9wYXRoX2NvdW50cyAoc3RydWN0 IHJlZGlyZWN0aW9uX2RhdGEgKnJkLAorICAgICAgICAgICAgICAgICAgICAg c3NhX2xvY2FsX2luZm9fdCAqbG9jYWxfaW5mbywKKyAgICAgICAgICAgICAg ICAgICAgIGdjb3ZfdHlwZSAqcGF0aF9pbl9jb3VudF9wdHIsCisgICAgICAg ICAgICAgICAgICAgICBnY292X3R5cGUgKnBhdGhfb3V0X2NvdW50X3B0ciwK KyAgICAgICAgICAgICAgICAgICAgIGludCAqcGF0aF9pbl9mcmVxX3B0cikK K3sKKyAgZWRnZSBlID0gcmQtPmluY29taW5nX2VkZ2VzLT5lOworICB2ZWM8 anVtcF90aHJlYWRfZWRnZSAqPiAqcGF0aCA9IFRIUkVBRF9QQVRIIChlKTsK KyAgZWRnZSBlbGFzdCA9IHBhdGgtPmxhc3QgKCktPmU7CisgIGdjb3ZfdHlw ZSBub25wYXRoX2NvdW50ID0gMDsKKyAgYm9vbCBoYXNfam9pbmVyID0gZmFs c2U7CisgIGdjb3ZfdHlwZSBwYXRoX2luX2NvdW50ID0gMDsKKyAgaW50IHBh dGhfaW5fZnJlcSA9IDA7CisKKyAgLyogU3RhcnQgYnkgYWNjdW11bGF0aW5n IGluY29taW5nIGVkZ2UgY291bnRzIHRvIHRoZSBwYXRoJ3MgZmlyc3QgYmIK KyAgICAgaW50byBhIGNvdXBsZSBidWNrZXRzOgorICAgICAgICBwYXRoX2lu X2NvdW50OiB0b3RhbCBjb3VudCBvZiBpbmNvbWluZyBlZGdlcyB0aGF0IGZs b3cgaW50byB0aGUKKyAgICAgICAgICAgICAgICAgIGN1cnJlbnQgcGF0aC4K KyAgICAgICAgbm9ucGF0aF9jb3VudDogdG90YWwgY291bnQgb2YgaW5jb21p bmcgZWRnZXMgdGhhdCBhcmUgbm90CisgICAgICAgICAgICAgICAgICBmbG93 aW5nIGFsb25nICphbnkqIHBhdGguICBUaGVzZSBhcmUgdGhlIGNvdW50cwor ICAgICAgICAgICAgICAgICAgdGhhdCB3aWxsIHN0aWxsIGZsb3cgYWxvbmcg dGhlIG9yaWdpbmFsIHBhdGggYWZ0ZXIKKyAgICAgICAgICAgICAgICAgIGFs bCBwYXRoIGR1cGxpY2F0aW9uIGlzIGRvbmUgYnkgcG90ZW50aWFsbHkgbXVs dGlwbGUKKyAgICAgICAgICAgICAgICAgIGNhbGxzIHRvIHRoaXMgcm91dGlu ZS4KKyAgICAgKGFueSBvdGhlciBpbmNvbWluZyBlZGdlIGNvdW50cyBhcmUg Zm9yIGEgZGlmZmVyZW50IGp1bXAgdGhyZWFkaW5nCisgICAgIHBhdGggdGhh dCB3aWxsIGJlIGhhbmRsZWQgYnkgYSBsYXRlciBjYWxsIHRvIHRoaXMgcm91 dGluZS4pCisgICAgIFRvIG1ha2UgdGhpcyBlYXNpZXIsIHN0YXJ0IGJ5IHJl Y29yZGluZyBhbGwgaW5jb21pbmcgZWRnZXMgdGhhdCBmbG93IGludG8KKyAg ICAgdGhlIGN1cnJlbnQgcGF0aCBpbiBhIGJpdG1hcC4gIFdlIGNvdWxkIGFk ZCB1cCB0aGUgcGF0aCdzIGluY29taW5nIGVkZ2UKKyAgICAgY291bnRzIGhl cmUsIGJ1dCB3ZSBzdGlsbCBuZWVkIHRvIHdhbGsgYWxsIHRoZSBmaXJzdCBi YidzIGluY29taW5nIGVkZ2VzCisgICAgIGJlbG93IHRvIGFkZCB1cCB0aGUg Y291bnRzIG9mIHRoZSBvdGhlciBlZGdlcyBub3QgaW5jbHVkZWQgaW4gdGhp cyBqdW1wCisgICAgIHRocmVhZGluZyBwYXRoLiAgKi8KKyAgc3RydWN0IGVs ICpuZXh0LCAqZWw7CisgIGJpdG1hcCBpbl9lZGdlX3NyY3MgPSBCSVRNQVBf QUxMT0MgKE5VTEwpOworICBmb3IgKGVsID0gcmQtPmluY29taW5nX2VkZ2Vz OyBlbDsgZWwgPSBuZXh0KQorICAgIHsKKyAgICAgIG5leHQgPSBlbC0+bmV4 dDsKKyAgICAgIGJpdG1hcF9zZXRfYml0IChpbl9lZGdlX3NyY3MsIGVsLT5l LT5zcmMtPmluZGV4KTsKKyAgICB9CisgIGVkZ2UgZWluOworICBlZGdlX2l0 ZXJhdG9yIGVpOworICBGT1JfRUFDSF9FREdFIChlaW4sIGVpLCBlLT5kZXN0 LT5wcmVkcykKKyAgICB7CisgICAgICB2ZWM8anVtcF90aHJlYWRfZWRnZSAq PiAqZWluX3BhdGggPSBUSFJFQURfUEFUSCAoZWluKTsKKyAgICAgIC8qIFNp bXBseSBjaGVjayB0aGUgaW5jb21pbmcgZWRnZSBzcmMgYWdhaW5zdCB0aGUg c2V0IGNhcHR1cmVkIGFib3ZlLiAgKi8KKyAgICAgIGlmIChlaW5fcGF0aAor ICAgICAgICAgICYmIGJpdG1hcF9iaXRfcCAoaW5fZWRnZV9zcmNzLCAoKmVp bl9wYXRoKVswXS0+ZS0+c3JjLT5pbmRleCkpCisgICAgICAgIHsKKyAgICAg ICAgICAvKiBJdCBpcyBuZWNlc3NhcnkgYnV0IG5vdCBzdWZmaWNpZW50IHRo YXQgdGhlIGxhc3QgcGF0aCBlZGdlcworICAgICAgICAgICAgIGFyZSBpZGVu dGljYWwuICBUaGVyZSBtYXkgYmUgZGlmZmVyZW50IHBhdGhzIHRoYXQgc2hh cmUgdGhlCisgICAgICAgICAgICAgc2FtZSBsYXN0IHBhdGggZWRnZSBpbiB0 aGUgY2FzZSB3aGVyZSB0aGUgbGFzdCBlZGdlIGhhcyBhIG5vY29weQorICAg ICAgICAgICAgIHNvdXJjZSBibG9jay4gICovCisgICAgICAgICAgZ2NjX2Fz c2VydCAoZWluX3BhdGgtPmxhc3QgKCktPmUgPT0gZWxhc3QpOworICAgICAg ICAgIHBhdGhfaW5fY291bnQgKz0gZWluLT5jb3VudDsKKyAgICAgICAgICBw YXRoX2luX2ZyZXEgKz0gRURHRV9GUkVRVUVOQ1kgKGVpbik7CisgICAgICAg IH0KKyAgICAgIGVsc2UgaWYgKCFlaW5fcGF0aCkKKyAgICAgICAgeworICAg ICAgICAgIC8qIEtlZXAgdHJhY2sgb2YgdGhlIGluY29taW5nIGVkZ2VzIHRo YXQgYXJlIG5vdCBvbiBhbnkganVtcC10aHJlYWRpbmcKKyAgICAgICAgICAg ICBwYXRoLiAgVGhlc2UgY291bnRzIHdpbGwgc3RpbGwgZmxvdyBvdXQgb2Yg b3JpZ2luYWwgcGF0aCBhZnRlciBhbGwKKyAgICAgICAgICAgICBqdW1wIHRo cmVhZGluZyBpcyBjb21wbGV0ZS4gICovCisgICAgICAgICAgICBub25wYXRo X2NvdW50ICs9IGVpbi0+Y291bnQ7CisgICAgICAgIH0KKyAgICB9CisgIEJJ VE1BUF9GUkVFIChpbl9lZGdlX3NyY3MpOworCisgIC8qIE5vdyBjb21wdXRl IHRoZSBmcmFjdGlvbiBvZiB0aGUgdG90YWwgY291bnQgY29taW5nIGludG8g dGhlIGZpcnN0CisgICAgIHBhdGggYmIgdGhhdCBpcyBmcm9tIHRoZSBjdXJy ZW50IHRocmVhZGluZyBwYXRoLiAgKi8KKyAgZ2Nvdl90eXBlIHRvdGFsX2Nv dW50ID0gZS0+ZGVzdC0+Y291bnQ7CisgIC8qIEhhbmRsZSBpbmNvbWluZyBw cm9maWxlIGluc2FuaXRpZXMuICAqLworICBpZiAodG90YWxfY291bnQgPCBw YXRoX2luX2NvdW50KQorICAgIHBhdGhfaW5fY291bnQgPSB0b3RhbF9jb3Vu dDsKKyAgaW50IG9ucGF0aF9zY2FsZSA9IEdDT1ZfQ09NUFVURV9TQ0FMRSAo cGF0aF9pbl9jb3VudCwgdG90YWxfY291bnQpOworCisgIC8qIFdhbGsgdGhl IGVudGlyZSBwYXRoIHRvIGRvIHNvbWUgbW9yZSBjb21wdXRhdGlvbiBpbiBv cmRlciB0byBlc3RpbWF0ZQorICAgICBob3cgbXVjaCBvZiB0aGUgcGF0aF9p bl9jb3VudCB3aWxsIGZsb3cgb3V0IG9mIHRoZSBkdXBsaWNhdGVkIHRocmVh ZGluZworICAgICBwYXRoLiAgSW4gdGhlIG5vbi1qb2luZXIgY2FzZSB0aGlz IGlzIHN0cmFpZ2h0Zm9yd2FyZCAoaXQgc2hvdWxkIGJlCisgICAgIHRoZSBz YW1lIGFzIHBhdGhfaW5fY291bnQsIGFsdGhvdWdoIHdlIHdpbGwgaGFuZGxl IGluY29taW5nIHByb2ZpbGUKKyAgICAgaW5zYW5pdGllcyBieSBzZXR0aW5n IGl0IGVxdWFsIHRvIHRoZSBtaW5pbXVtIGNvdW50IGFsb25nIHRoZSBwYXRo KS4KKworICAgICBJbiB0aGUgam9pbmVyIGNhc2UsIHdlIG5lZWQgdG8gZXN0 aW1hdGUgaG93IG11Y2ggb2YgdGhlIHBhdGhfaW5fY291bnQKKyAgICAgd2ls bCBzdGF5IG9uIHRoZSB0aHJlYWRpbmcgcGF0aCBhZnRlciB0aGUgam9pbmVy J3MgY29uZGl0aW9uYWwgYnJhbmNoLgorICAgICBXZSBkb24ndCByZWFsbHkg a25vdyBmb3Igc3VyZSBob3cgbXVjaCBvZiB0aGUgY291bnRzCisgICAgIGFz c29jaWF0ZWQgd2l0aCB0aGlzIHBhdGggZ28gdG8gZWFjaCBzdWNjZXNzb3Ig b2YgdGhlIGpvaW5lciwgYnV0IHdlJ2xsCisgICAgIGVzdGltYXRlIGJhc2Vk IG9uIHRoZSBmcmFjdGlvbiBvZiB0aGUgdG90YWwgY291bnQgY29taW5nIGlu dG8gdGhlIHBhdGgKKyAgICAgYmIgd2FzIGZyb20gdGhlIHRocmVhZGluZyBw YXRocyAoY29tcHV0ZWQgYWJvdmUgaW4gb25wYXRoX3NjYWxlKS4KKyAgICAg QWZ0ZXJ3YXJkcywgd2Ugd2lsbCBuZWVkIHRvIGRvIHNvbWUgZml4dXAgdG8g YWNjb3VudCBmb3Igb3RoZXIgdGhyZWFkaW5nCisgICAgIHBhdGhzIGFuZCBw b3NzaWJsZSBwcm9maWxlIGluc2FuaXRpZXMuCisKKyAgICAgSW4gb3JkZXIg dG8gZXN0aW1hdGUgdGhlIGpvaW5lciBjYXNlJ3MgY291bnRzIHdlIGFsc28g bmVlZCB0byB1cGRhdGUKKyAgICAgbm9ucGF0aF9jb3VudCB3aXRoIGFueSBh ZGRpdGlvbmFsIGNvdW50cyBjb21pbmcgaW50byB0aGUgcGF0aC4gIE90aGVy CisgICAgIGJsb2NrcyBhbG9uZyB0aGUgcGF0aCBtYXkgaGF2ZSBhZGRpdGlv bmFsIHByZWRlY2Vzc29ycyBmcm9tIG91dHNpZGUKKyAgICAgdGhlIHBhdGgu ICAqLworICBnY292X3R5cGUgcGF0aF9vdXRfY291bnQgPSBwYXRoX2luX2Nv dW50OworICBnY292X3R5cGUgbWluX3BhdGhfY291bnQgPSBwYXRoX2luX2Nv dW50OworICBmb3IgKHVuc2lnbmVkIGludCBpID0gMTsgaSA8IHBhdGgtPmxl bmd0aCAoKTsgaSsrKQorICAgIHsKKyAgICAgIGVkZ2UgZXBhdGggPSAoKnBh dGgpW2ldLT5lOworICAgICAgZ2Nvdl90eXBlIGN1cl9jb3VudCA9IGVwYXRo LT5jb3VudDsKKyAgICAgIGlmICgoKnBhdGgpW2ldLT50eXBlID09IEVER0Vf Q09QWV9TUkNfSk9JTkVSX0JMT0NLKQorICAgICAgICB7CisgICAgICAgICAg aGFzX2pvaW5lciA9IHRydWU7CisgICAgICAgICAgY3VyX2NvdW50ID0gYXBw bHlfcHJvYmFiaWxpdHkgKGN1cl9jb3VudCwgb25wYXRoX3NjYWxlKTsKKyAg ICAgICAgfQorICAgICAgLyogSW4gdGhlIGpvaW5lciBjYXNlIHdlIG5lZWQg dG8gdXBkYXRlIG5vbnBhdGhfY291bnQgZm9yIGFueSBlZGdlcworICAgICAg ICAgY29taW5nIGludG8gdGhlIHBhdGggdGhhdCB3aWxsIGNvbnRyaWJ1dGUg dG8gdGhlIGNvdW50IGZsb3dpbmcKKyAgICAgICAgIGludG8gdGhlIHBhdGgg c3VjY2Vzc29yLiAgKi8KKyAgICAgIGlmIChoYXNfam9pbmVyICYmIGVwYXRo ICE9IGVsYXN0KQorICAgICAgeworICAgICAgICAvKiBMb29rIGZvciBvdGhl ciBpbmNvbWluZyBlZGdlcyBhZnRlciBqb2luZXIuICAqLworICAgICAgICBG T1JfRUFDSF9FREdFIChlaW4sIGVpLCBlcGF0aC0+ZGVzdC0+cHJlZHMpCisg ICAgICAgICAgeworICAgICAgICAgICAgaWYgKGVpbiAhPSBlcGF0aAorICAg ICAgICAgICAgICAgIC8qIElnbm9yZSBpbiBlZGdlcyBmcm9tIGJsb2NrcyB3 ZSBoYXZlIGR1cGxpY2F0ZWQgZm9yIGEKKyAgICAgICAgICAgICAgICAgICB0 aHJlYWRpbmcgcGF0aCwgd2hpY2ggaGF2ZSBkdXBsaWNhdGVkIGVkZ2UgY291 bnRzIHVudGlsCisgICAgICAgICAgICAgICAgICAgdGhleSBhcmUgcmVkaXJl Y3RlZCBieSBhbiBpbnZvY2F0aW9uIG9mIHRoaXMgcm91dGluZS4gICovCisg ICAgICAgICAgICAgICAgJiYgIWJpdG1hcF9iaXRfcCAobG9jYWxfaW5mby0+ ZHVwbGljYXRlX2Jsb2NrcywKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBlaW4tPnNyYy0+aW5kZXgpKQorICAgICAgICAgICAgICBub25w YXRoX2NvdW50ICs9IGVpbi0+Y291bnQ7CisgICAgICAgICAgfQorICAgICAg fQorICAgICAgaWYgKGN1cl9jb3VudCA8IHBhdGhfb3V0X2NvdW50KQorICAg ICAgICBwYXRoX291dF9jb3VudCA9IGN1cl9jb3VudDsKKyAgICAgIGlmIChl cGF0aC0+Y291bnQgPCBtaW5fcGF0aF9jb3VudCkKKyAgICAgICAgbWluX3Bh dGhfY291bnQgPSBlcGF0aC0+Y291bnQ7CisgICAgfQorCisgIC8qIFdlIGNv bXB1dGVkIHBhdGhfb3V0X2NvdW50IGFib3ZlIGFzc3VtaW5nIHRoYXQgdGhp cyBwYXRoIHRhcmdldGVkCisgICAgIHRoZSBqb2luZXIncyBvbi1wYXRoIHN1 Y2Nlc3NvciB3aXRoIHRoZSBzYW1lIGxpa2VsaWhvb2QgYXMgaXQKKyAgICAg cmVhY2hlZCB0aGUgam9pbmVyLiAgSG93ZXZlciwgb3RoZXIgdGhyZWFkIHBh dGhzIHRocm91Z2ggdGhlIGpvaW5lcgorICAgICBtYXkgdGFrZSBhIGRpZmZl cmVudCBwYXRoIHRocm91Z2ggdGhlIG5vcm1hbCBjb3B5IHNvdXJjZSBibG9j aworICAgICAoaS5lLiB0aGV5IGhhdmUgYSBkaWZmZXJlbnQgZWxhc3QpLCBt ZWFuaW5nIHRoYXQgdGhleSBkbyBub3QKKyAgICAgY29udHJpYnV0ZSBhbnkg Y291bnRzIHRvIHRoaXMgcGF0aCdzIGVsYXN0LiAgQXMgYSByZXN1bHQsIGl0 IG1heQorICAgICB0dXJuIG91dCB0aGF0IHRoaXMgcGF0aCBtdXN0IGhhdmUg bW9yZSBjb3VudCBmbG93aW5nIHRvIHRoZSBvbi1wYXRoCisgICAgIHN1Y2Nl c3NvciBvZiB0aGUgam9pbmVyLiAgRXNzZW50aWFsbHksIGFsbCBvZiB0aGlz IHBhdGgncyBlbGFzdAorICAgICBjb3VudCBtdXN0IGJlIGNvbnRyaWJ1dGVk IGJ5IHRoaXMgcGF0aCBhbmQgYW55IG5vbnBhdGggY291bnRzCisgICAgIChz aW5jZSBhbnkgcGF0aCB0aHJvdWdoIHRoZSBqb2luZXIgd2l0aCBhIGRpZmZl cmVudCBlbGFzdCB3aWxsIG5vdAorICAgICBpbmNsdWRlIGEgY29weSBvZiB0 aGlzIGVsYXN0IGluIGl0cyBkdXBsaWNhdGVkIHBhdGgpLgorICAgICBTbyBl bnN1cmUgdGhhdCB0aGlzIHBhdGgncyBwYXRoX291dF9jb3VudCBpcyBhdCBs ZWFzdCB0aGUKKyAgICAgZGlmZmVyZW5jZSBiZXR3ZWVuIGVsYXN0LT5jb3Vu dCBhbmQgbm9ucGF0aF9jb3VudC4gIE90aGVyd2lzZSB0aGUgZWRnZQorICAg ICBjb3VudHMgYWZ0ZXIgdGhyZWFkaW5nIHdpbGwgbm90IGJlIHNhbmUuICAq LworICBpZiAoaGFzX2pvaW5lciAmJiBwYXRoX291dF9jb3VudCA8IGVsYXN0 LT5jb3VudCAtIG5vbnBhdGhfY291bnQpCisgIHsKKyAgICBwYXRoX291dF9j b3VudCA9IGVsYXN0LT5jb3VudCAtIG5vbnBhdGhfY291bnQ7CisgICAgLyog QnV0IG5laXRoZXIgY2FuIHdlIGdvIGFib3ZlIHRoZSBtaW5pbXVtIGNvdW50 IGFsb25nIHRoZSBwYXRoCisgICAgICAgd2UgYXJlIGR1cGxpY2F0aW5nLiAg VGhpcyBjYW4gYmUgYW4gaXNzdWUgZHVlIHRvIHByb2ZpbGUKKyAgICAgICBp bnNhbml0aWVzIGNvbWluZyBpbiB0byB0aGlzIHBhc3MuICAqLworICAgIGlm IChwYXRoX291dF9jb3VudCA+IG1pbl9wYXRoX2NvdW50KQorICAgICAgcGF0 aF9vdXRfY291bnQgPSBtaW5fcGF0aF9jb3VudDsKKyAgfQorCisgICpwYXRo X2luX2NvdW50X3B0ciA9IHBhdGhfaW5fY291bnQ7CisgICpwYXRoX291dF9j b3VudF9wdHIgPSBwYXRoX291dF9jb3VudDsKKyAgKnBhdGhfaW5fZnJlcV9w dHIgPSBwYXRoX2luX2ZyZXE7CisgIHJldHVybiBoYXNfam9pbmVyOworfQor CisKKy8qIFVwZGF0ZSB0aGUgY291bnRzIGFuZCBmcmVxdWVuY2llcyBmb3Ig Ym90aCBhbiBvcmlnaW5hbCBwYXRoCisgICBlZGdlIEVQQVRIIGFuZCBpdHMg ZHVwbGljYXRlIEVEVVAuICBUaGUgZHVwbGljYXRlIHNvdXJjZSBibG9jawor ICAgd2lsbCBnZXQgYSBjb3VudC9mcmVxdWVuY3kgb2YgUEFUSF9JTl9DT1VO VCBhbmQgUEFUSF9JTl9GUkVRLAorICAgYW5kIHRoZSBkdXBsaWNhdGUgZWRn ZSBFRFVQIHdpbGwgaGF2ZSBhIGNvdW50IG9mIFBBVEhfT1VUX0NPVU5ULiAg Ki8KK3N0YXRpYyB2b2lkCit1cGRhdGVfcHJvZmlsZSAoZWRnZSBlcGF0aCwg ZWRnZSBlZHVwLCBnY292X3R5cGUgcGF0aF9pbl9jb3VudCwKKyAgICAgICAg ICAgICAgICBnY292X3R5cGUgcGF0aF9vdXRfY291bnQsIGludCBwYXRoX2lu X2ZyZXEpCit7CisKKyAgLyogRmlyc3QgdXBkYXRlIHRoZSBkdXBsaWNhdGVk IGJsb2NrJ3MgY291bnQgLyBmcmVxdWVuY3kuICAqLworICBpZiAoZWR1cCkK KyAgICB7CisgICAgICBiYXNpY19ibG9jayBkdXBfYmxvY2sgPSBlZHVwLT5z cmM7CisgICAgICBnY2NfYXNzZXJ0IChkdXBfYmxvY2stPmNvdW50ID09IDAp OworICAgICAgZ2NjX2Fzc2VydCAoZHVwX2Jsb2NrLT5mcmVxdWVuY3kgPT0g MCk7CisgICAgICBkdXBfYmxvY2stPmNvdW50ID0gcGF0aF9pbl9jb3VudDsK KyAgICAgIGR1cF9ibG9jay0+ZnJlcXVlbmN5ID0gcGF0aF9pbl9mcmVxOwor ICAgIH0KKworICAvKiBOb3cgdXBkYXRlIHRoZSBvcmlnaW5hbCBibG9jaydz IGNvdW50IGFuZCBmcmVxdWVuY3kgaW4gdGhlCisgICAgIG9wcG9zaXRlIG1h bm5lciAtIHJlbW92ZSB0aGUgY291bnRzL2ZyZXEgdGhhdCB3aWxsIGZsb3cK KyAgICAgaW50byB0aGUgZHVwbGljYXRlZCBibG9jay4gIEhhbmRsZSB1bmRl cmZsb3cgZHVlIHRvIHByZWNpc2lvbi8KKyAgICAgcm91bmRpbmcgaXNzdWVz LiAgKi8KKyAgZXBhdGgtPnNyYy0+Y291bnQgLT0gcGF0aF9pbl9jb3VudDsK KyAgaWYgKGVwYXRoLT5zcmMtPmNvdW50IDwgMCkKKyAgICBlcGF0aC0+c3Jj LT5jb3VudCA9IDA7CisgIGVwYXRoLT5zcmMtPmZyZXF1ZW5jeSAtPSBwYXRo X2luX2ZyZXE7CisgIGlmIChlcGF0aC0+c3JjLT5mcmVxdWVuY3kgPCAwKQor ICAgIGVwYXRoLT5zcmMtPmZyZXF1ZW5jeSA9IDA7CisKKyAgLyogTmV4dCB1 cGRhdGUgdGhpcyBwYXRoIGVkZ2UncyBvcmlnaW5hbCBhbmQgZHVwbGljYXRl ZCBjb3VudHMuICBXZSBrbm93CisgICAgIHRoYXQgdGhlIGR1cGxpY2F0ZWQg cGF0aCB3aWxsIGhhdmUgcGF0aF9vdXRfY291bnQgZmxvd2luZworICAgICBv dXQgb2YgaXQgKGluIHRoZSBqb2luZXIgY2FzZSB0aGlzIGlzIHRoZSBjb3Vu dCBhbG9uZyB0aGUgZHVwbGljYXRlZCBwYXRoCisgICAgIG91dCBvZiB0aGUg ZHVwbGljYXRlZCBqb2luZXIpLiAgVGhpcyBjb3VudCBjYW4gdGhlbiBiZSBy ZW1vdmVkIGZyb20gdGhlCisgICAgIG9yaWdpbmFsIHBhdGggZWRnZS4gICov CisgIGlmIChlZHVwKQorICAgIGVkdXAtPmNvdW50ID0gcGF0aF9vdXRfY291 bnQ7CisgIGVwYXRoLT5jb3VudCAtPSBwYXRoX291dF9jb3VudDsKKyAgZ2Nj X2Fzc2VydCAoZXBhdGgtPmNvdW50ID49IDApOworfQorCisKKy8qIFRoaXMg cm91dGluZSB3aWxsIGRldGVybWluZSB3aGF0IGZyZXF1ZW5jeSBpcyBuZWVk ZWQgYnkgYW4gZWRnZSBFCisgICB0byBlbnN1cmUgdGhhdCBpdHMgZGVzdGlu YXRpb24gYmxvY2sgbWVldHMgaXRzIGN1cnJlbnQgYmxvY2sgZnJlcXVlbmN5 LgorICAgVGhpcyBpcyB1c2VkIHdoZW4gd2UgZG9uJ3Qga25vdyBFJ3MgcHJv YmFiaWxpdHkuICAqLworCitzdGF0aWMgaW50CitkZWR1Y2VfZnJlcSAoZWRn ZSBlKQoreworICBlZGdlX2l0ZXJhdG9yIGVpOworICBlZGdlIGVwcmVkOwor ICBpbnQgZnJlcSA9IGUtPmRlc3QtPmZyZXF1ZW5jeTsKKyAgRk9SX0VBQ0hf RURHRSAoZXByZWQsIGVpLCBlLT5kZXN0LT5wcmVkcykKKyAgICB7CisgICAg ICBpZiAoZXByZWQgPT0gZSkKKyAgICAgICAgY29udGludWU7CisgICAgICBm cmVxIC09IEVER0VfRlJFUVVFTkNZIChlcHJlZCk7CisgICAgfQorICBpZiAo ZnJlcSA8IDApCisgICAgZnJlcSA9IDA7CisgIHJldHVybiBmcmVxOworfQor CisKKy8qIFRoZSBkdXBsaWNhdGUgYW5kIG9yaWdpbmFsIGpvaW5lciBibG9j a3MgbWF5IGVuZCB1cCB3aXRoIGRpZmZlcmVudAorICAgcHJvYmFiaWxpdGll cyAoZGlmZmVyZW50IGZyb20gYm90aCB0aGUgb3JpZ2luYWwgYW5kIGZyb20g ZWFjaCBvdGhlcikuCisgICBSZWNvbXB1dGUgdGhlIHByb2JhYmlsaXRpZXMg aGVyZSBvbmNlIHdlIGhhdmUgdXBkYXRlZCB0aGUgZWRnZQorICAgY291bnRz IGFuZCBmcmVxdWVuY2llcy4gICovCisKK3N0YXRpYyB2b2lkCityZWNvbXB1 dGVfcHJvYmFiaWxpdGllcyAoYmFzaWNfYmxvY2sgYmIpCit7CisgIGVkZ2Ug ZXN1Y2M7CisgIGVkZ2VfaXRlcmF0b3IgZWk7CisgIEZPUl9FQUNIX0VER0Ug KGVzdWNjLCBlaSwgYmItPnN1Y2NzKQorICAgIHsKKyAgICAgIGlmIChiYi0+ Y291bnQpCisgICAgICAgIGVzdWNjLT5wcm9iYWJpbGl0eSA9IEdDT1ZfQ09N UFVURV9TQ0FMRSAoZXN1Y2MtPmNvdW50LAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJiLT5jb3VudCk7Cisg ICAgICBlbHNlIGlmIChiYi0+ZnJlcXVlbmN5KQorICAgICAgICBlc3VjYy0+ cHJvYmFiaWxpdHkgPSBHQ09WX0NPTVBVVEVfU0NBTEUgKGRlZHVjZV9mcmVx IChlc3VjYyksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgYmItPmZyZXF1ZW5jeSk7CisgICAgICBpZiAoZXN1 Y2MtPnByb2JhYmlsaXR5ID4gUkVHX0JSX1BST0JfQkFTRSkKKyAgICAgICAg eworCSAgLyogQ2FuIGhhcHBlbiB3aXRoIG1pc3NpbmcvZ3Vlc3NlZCBwcm9i YWJpbGl0aWVzLCBzaW5jZSB3ZQorCSAgICAgbWF5IGRldGVybWluZSB0aGF0 IG1vcmUgaXMgZmxvd2luZyBhbG9uZyBkdXBsaWNhdGVkCisJICAgICBwYXRo IHRoYW4gam9pbmVyIHN1Y2MgcHJvYmFiaWxpdGllcyBhbGxvd2VkLgorCSAg ICAgQ291bnRzIGFuZCBmcmVxcyB3aWxsIGJlIGluc2FuZSBhZnRlciBqdW1w IHRocmVhZGluZywKKwkgICAgIGF0IGxlYXN0IG1ha2Ugc3VyZSBwcm9iYWJp bGl0eSBpcyBzYW5lIG9yIHdlIHdpbGwKKwkgICAgIGdldCBhIGZsb3cgdmVy aWZpY2F0aW9uIGVycm9yLgorCSAgICAgTm90IG11Y2ggd2UgY2FuIGRvIHRv IG1ha2UgY291bnRzL2ZyZXFzIHNhbmUgd2l0aG91dAorCSAgICAgcmVkb2lu ZyB0aGUgcHJvZmlsZSBlc3RpbWF0aW9uLiAgKi8KKwkgIGVzdWNjLT5wcm9i YWJpbGl0eSA9IFJFR19CUl9QUk9CX0JBU0U7CisJfQorICAgIH0KK30KKwor CisvKiBVcGRhdGUgdGhlIGNvdW50cyBvZiB0aGUgb3JpZ2luYWwgYW5kIGR1 cGxpY2F0ZWQgZWRnZXMgZnJvbSBhIGpvaW5lcgorICAgdGhhdCBnbyBvZmYg cGF0aCwgZ2l2ZW4gdGhhdCB3ZSBoYXZlIGFscmVhZHkgZGV0ZXJtaW5lZCB0 aGF0IHRoZQorICAgZHVwbGljYXRlIGpvaW5lciBEVVBfQkIgaGFzIGluY29t aW5nIGNvdW50IFBBVEhfSU5fQ09VTlQgYW5kCisgICBvdXRnb2luZyBjb3Vu dCBhbG9uZyB0aGUgcGF0aCBQQVRIX09VVF9DT1VOVC4gIFRoZSBvcmlnaW5h bCAob24tKXBhdGgKKyAgIGVkZ2UgZnJvbSBqb2luZXIgaXMgRVBBVEguICAq LworCitzdGF0aWMgdm9pZAordXBkYXRlX2pvaW5lcl9vZmZwYXRoX2NvdW50 cyAoZWRnZSBlcGF0aCwgYmFzaWNfYmxvY2sgZHVwX2JiLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgZ2Nvdl90eXBlIHBhdGhfaW5fY291bnQs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnY292X3R5cGUgcGF0 aF9vdXRfY291bnQpCit7CisgIC8qIENvbXB1dGUgdGhlIGNvdW50IHRoYXQg Y3VycmVudGx5IGZsb3dzIG9mZiBwYXRoIGZyb20gdGhlIGpvaW5lci4KKyAg ICAgSW4gb3RoZXIgd29yZHMsIHRoZSB0b3RhbCBjb3VudCBvZiBqb2luZXIn cyBvdXQgZWRnZXMgb3RoZXIgdGhhbgorICAgICBlcGF0aC4gIENvbXB1dGUg dGhpcyBieSB3YWxraW5nIHRoZSBzdWNjZXNzb3JzIGluc3RlYWQgb2YKKyAg ICAgc3VidHJhY3RpbmcgZXBhdGgncyBjb3VudCBmcm9tIHRoZSBqb2luZXIg YmIgY291bnQsIHNpbmNlIHRoZXJlCisgICAgIGFyZSBzb21ldGltZXMgc2xp Z2h0IGluc2FuaXRpZXMgd2hlcmUgdGhlIHRvdGFsIG91dCBlZGdlIGNvdW50 IGlzCisgICAgIGxhcmdlciB0aGFuIHRoZSBiYiBjb3VudCAocG9zc2libHkg ZHVlIHRvIHJvdW5kaW5nL3RydW5jYXRpb24KKyAgICAgZXJyb3JzKS4gICov CisgIGdjb3ZfdHlwZSB0b3RhbF9vcmlnX29mZl9wYXRoX2NvdW50ID0gMDsK KyAgZWRnZSBlbm9ucGF0aDsKKyAgZWRnZV9pdGVyYXRvciBlaTsKKyAgRk9S X0VBQ0hfRURHRSAoZW5vbnBhdGgsIGVpLCBlcGF0aC0+c3JjLT5zdWNjcykK KyAgICB7CisgICAgICBpZiAoZW5vbnBhdGggPT0gZXBhdGgpCisgICAgICAg IGNvbnRpbnVlOworICAgICAgdG90YWxfb3JpZ19vZmZfcGF0aF9jb3VudCAr PSBlbm9ucGF0aC0+Y291bnQ7CisgICAgfQorCisgIC8qIEZvciB0aGUgcGF0 aCB0aGF0IHdlIGFyZSBkdXBsaWNhdGluZywgdGhlIGFtb3VudCB0aGF0IHdp bGwgZmxvdworICAgICBvZmYgcGF0aCBmcm9tIHRoZSBkdXBsaWNhdGVkIGpv aW5lciBpcyB0aGUgZGVsdGEgYmV0d2VlbiB0aGUKKyAgICAgcGF0aCdzIGN1 bXVsYXRpdmUgaW4gY291bnQgYW5kIHRoZSBwb3J0aW9uIG9mIHRoYXQgY291 bnQgd2UKKyAgICAgZXN0aW1hdGVkIGFib3ZlIGFzIGZsb3dpbmcgZnJvbSB0 aGUgam9pbmVyIGFsb25nIHRoZSBkdXBsaWNhdGVkCisgICAgIHBhdGguICAq LworICBnY292X3R5cGUgdG90YWxfZHVwX29mZl9wYXRoX2NvdW50ID0gcGF0 aF9pbl9jb3VudCAtIHBhdGhfb3V0X2NvdW50OworCisgIC8qIE5vdyBkbyB0 aGUgYWN0dWFsIHVwZGF0ZXMgb2YgdGhlIG9mZi1wYXRoIGVkZ2VzLiAgKi8K KyAgRk9SX0VBQ0hfRURHRSAoZW5vbnBhdGgsIGVpLCBlcGF0aC0+c3JjLT5z dWNjcykKKyAgICB7CisgICAgICAvKiBMb29rIGZvciBlZGdlcyBnb2luZyBv ZmYgb2YgdGhlIHRocmVhZGluZyBwYXRoLiAgKi8KKyAgICAgIGlmIChlbm9u cGF0aCA9PSBlcGF0aCkKKyAgICAgICAgY29udGludWU7CisKKyAgICAgIC8q IEZpbmQgdGhlIGNvcnJlc3BvbmRpbmcgZWRnZSBvdXQgb2YgdGhlIGR1cGxp Y2F0ZWQgam9pbmVyLiAgKi8KKyAgICAgIGVkZ2UgZW5vbnBhdGhkdXAgPSBm aW5kX2VkZ2UgKGR1cF9iYiwgZW5vbnBhdGgtPmRlc3QpOworICAgICAgZ2Nj X2Fzc2VydCAoZW5vbnBhdGhkdXApOworCisgICAgICAvKiBXZSBjYW4ndCB1 c2UgdGhlIG9yaWdpbmFsIHByb2JhYmlsaXR5IG9mIHRoZSBqb2luZXIncyBv dXQKKyAgICAgICAgIGVkZ2VzLCBzaW5jZSB0aGUgcHJvYmFiaWxpdGllcyBv ZiB0aGUgb3JpZ2luYWwgYnJhbmNoCisgICAgICAgICBhbmQgdGhlIGR1cGxp Y2F0ZWQgYnJhbmNoZXMgbWF5IHZhcnkgYWZ0ZXIgYWxsIHRocmVhZGluZyBp cworICAgICAgICAgY29tcGxldGUuICBCdXQgYXBwb3J0aW9uIHRoZSBkdXBs aWNhdGVkIGpvaW5lcidzIG9mZi1wYXRoCisgICAgICAgICB0b3RhbCBlZGdl IGNvdW50IGNvbXB1dGVkIGVhcmxpZXIgKHRvdGFsX2R1cF9vZmZfcGF0aF9j b3VudCkKKyAgICAgICAgIGFtb25nIHRoZSBkdXBsaWNhdGVkIG9mZi1wYXRo IGVkZ2VzIGJhc2VkIG9uIHRoZWlyIG9yaWdpbmFsCisgICAgICAgICByYXRp byB0byB0aGUgZnVsbCBvZmYtcGF0aCBjb3VudCAodG90YWxfb3JpZ19vZmZf cGF0aF9jb3VudCkuCisgICAgICAgICAqLworICAgICAgaW50IHNjYWxlID0g R0NPVl9DT01QVVRFX1NDQUxFIChlbm9ucGF0aC0+Y291bnQsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRvdGFsX29yaWdfb2Zm X3BhdGhfY291bnQpOworICAgICAgLyogR2l2ZSB0aGUgZHVwbGljYXRlZCBv ZmZwYXRoIGVkZ2UgYSBwb3J0aW9uIG9mIHRoZSBkdXBsaWNhdGVkCisgICAg ICAgICB0b3RhbC4gICovCisgICAgICBlbm9ucGF0aGR1cC0+Y291bnQgPSBh cHBseV9zY2FsZSAoc2NhbGUsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgdG90YWxfZHVwX29mZl9wYXRoX2NvdW50KTsKKyAg ICAgIC8qIE5vdyB1cGRhdGUgdGhlIG9yaWdpbmFsIG9mZnBhdGggZWRnZSBj b3VudCwgaGFuZGxpbmcgdW5kZXJmbG93CisgICAgICAgICBkdWUgdG8gcm91 bmRpbmcgZXJyb3JzLiAgKi8KKyAgICAgIGVub25wYXRoLT5jb3VudCAtPSBl bm9ucGF0aGR1cC0+Y291bnQ7CisgICAgICBpZiAoZW5vbnBhdGgtPmNvdW50 IDwgMCkKKyAgICAgICAgZW5vbnBhdGgtPmNvdW50ID0gMDsKKyAgICB9Cit9 CisKIC8qIFdpcmUgdXAgdGhlIG91dGdvaW5nIGVkZ2VzIGZyb20gdGhlIGR1 cGxpY2F0ZSBibG9ja3MgYW5kCi0gICB1cGRhdGUgYW55IFBISXMgYXMgbmVl ZGVkLiAgKi8KKyAgIHVwZGF0ZSBhbnkgUEhJcyBhcyBuZWVkZWQuICBBbHNv IHVwZGF0ZSB0aGUgcHJvZmlsZSBjb3VudHMKKyAgIG9uIHRoZSBvcmlnaW5h bCBhbmQgZHVwbGljYXRlIGJsb2NrcyBhbmQgZWRnZXMuICAqLwogdm9pZAog c3NhX2ZpeF9kdXBsaWNhdGVfYmxvY2tfZWRnZXMgKHN0cnVjdCByZWRpcmVj dGlvbl9kYXRhICpyZCwKIAkJCSAgICAgICBzc2FfbG9jYWxfaW5mb190ICps b2NhbF9pbmZvKQogewogICBlZGdlIGUgPSByZC0+aW5jb21pbmdfZWRnZXMt PmU7CiAgIHZlYzxqdW1wX3RocmVhZF9lZGdlICo+ICpwYXRoID0gVEhSRUFE X1BBVEggKGUpOworICBlZGdlIGVsYXN0ID0gcGF0aC0+bGFzdCAoKS0+ZTsK KyAgZ2Nvdl90eXBlIHBhdGhfaW5fY291bnQgPSAwOworICBnY292X3R5cGUg cGF0aF9vdXRfY291bnQgPSAwOworICBpbnQgcGF0aF9pbl9mcmVxID0gMDsK IAorICAvKiBGaXJzdCBkZXRlcm1pbmUgaG93IG11Y2ggcHJvZmlsZSBjb3Vu dCB0byBtb3ZlIGZyb20gb3JpZ2luYWwKKyAgICAgcGF0aCB0byB0aGUgZHVw bGljYXRlIHBhdGguICBUaGlzIGlzIHRyaWNreSBpbiB0aGUgcHJlc2VuY2Ug b2YKKyAgICAgYSBqb2luZXIgKHNlZSBjb21tZW50cyBmb3IgY29tcHV0ZV9w YXRoX2NvdW50cyksIHdoZXJlIHNvbWUgcG9ydGlvbgorICAgICBvZiB0aGUg cGF0aCdzIGNvdW50cyB3aWxsIGZsb3cgb2ZmLXBhdGggZnJvbSB0aGUgam9p bmVyLiAgSW4gdGhlCisgICAgIG5vbi1qb2luZXIgY2FzZSB0aGUgcGF0aF9p bl9jb3VudCBhbmQgcGF0aF9vdXRfY291bnQgc2hvdWxkIGJlIHRoZQorICAg ICBzYW1lLiAgKi8KKyAgYm9vbCBoYXNfam9pbmVyID0gY29tcHV0ZV9wYXRo X2NvdW50cyAocmQsIGxvY2FsX2luZm8sCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICZwYXRoX2luX2NvdW50LCAmcGF0aF9v dXRfY291bnQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICZwYXRoX2luX2ZyZXEpOworCisgIGludCBjdXJfcGF0aF9mcmVx ID0gcGF0aF9pbl9mcmVxOwogICBmb3IgKHVuc2lnbmVkIGludCBjb3VudCA9 IDAsIGkgPSAxOyBpIDwgcGF0aC0+bGVuZ3RoICgpOyBpKyspCiAgICAgewor ICAgICAgZWRnZSBlcGF0aCA9ICgqcGF0aClbaV0tPmU7CisKICAgICAgIC8q IElmIHdlIHdlcmUgdGhyZWFkaW5nIHRocm91Z2ggYW4gam9pbmVyIGJsb2Nr LCB0aGVuIHdlIHdhbnQKIAkgdG8ga2VlcCBpdHMgY29udHJvbCBzdGF0ZW1l bnQgYW5kIHJlZGlyZWN0IGFuIG91dGdvaW5nIGVkZ2UuCiAJIEVsc2Ugd2Ug d2FudCB0byByZW1vdmUgdGhlIGNvbnRyb2wgc3RhdGVtZW50ICYgZWRnZXMs IHRoZW4gY3JlYXRlCkBAIC01MTUsNiArOTYxLDggQEAgc3NhX2ZpeF9kdXBs aWNhdGVfYmxvY2tfZWRnZXMgKHN0cnVjdCByZWRpcmVjdGlvbl8KIAkgIGVk Z2UgdmljdGltOwogCSAgZWRnZSBlMjsKIAorICAgICAgICAgIGdjY19hc3Nl cnQgKGhhc19qb2luZXIpOworCiAJICAvKiBUaGlzIHVwZGF0ZXMgdGhlIFBI SXMgYXQgdGhlIGRlc3RpbmF0aW9uIG9mIHRoZSBkdXBsaWNhdGUKIAkgICAg IGJsb2NrLiAgKi8KIAkgIHVwZGF0ZV9kZXN0aW5hdGlvbl9waGlzIChsb2Nh bF9pbmZvLT5iYiwgcmQtPmR1cF9ibG9ja3NbY291bnRdKTsKQEAgLTUyOCwx NCArOTc2LDEzIEBAIHNzYV9maXhfZHVwbGljYXRlX2Jsb2NrX2VkZ2VzIChz dHJ1Y3QgcmVkaXJlY3Rpb25fCiAJICAgICB0aHJlYWRpbmcgcGF0aC4gICov CiAJICBpZiAoIWFueV9yZW1haW5pbmdfZHVwbGljYXRlZF9ibG9ja3MgKHBh dGgsIGkpKQogCSAgICB7Ci0JICAgICAgZTIgPSByZWRpcmVjdF9lZGdlX2Fu ZF9icmFuY2ggKHZpY3RpbSwgcGF0aC0+bGFzdCAoKS0+ZS0+ZGVzdCk7Ci0J ICAgICAgZTItPmNvdW50ID0gcGF0aC0+bGFzdCAoKS0+ZS0+Y291bnQ7CisJ ICAgICAgZTIgPSByZWRpcmVjdF9lZGdlX2FuZF9icmFuY2ggKHZpY3RpbSwg ZWxhc3QtPmRlc3QpOwogCSAgICAgIC8qIElmIHdlIHJlZGlyZWN0ZWQgdGhl IGVkZ2UsIHRoZW4gd2UgbmVlZCB0byBjb3B5IFBISSBhcmd1bWVudHMKIAkJ IGF0IHRoZSB0YXJnZXQuICBJZiB0aGUgZWRnZSBhbHJlYWR5IGV4aXN0ZWQg KGUyICE9IHZpY3RpbQogCQkgY2FzZSksIHRoZW4gdGhlIFBISXMgaW4gdGhl IHRhcmdldCBhbHJlYWR5IGhhdmUgdGhlIGNvcnJlY3QKIAkJIGFyZ3VtZW50 cy4gICovCiAJICAgICAgaWYgKGUyID09IHZpY3RpbSkKLQkJY29weV9waGlf YXJncyAoZTItPmRlc3QsIHBhdGgtPmxhc3QgKCktPmUsIGUyKTsKKwkJY29w eV9waGlfYXJncyAoZTItPmRlc3QsIGVsYXN0LCBlMik7CiAJICAgIH0KIAkg IGVsc2UKIAkgICAgewpAQCAtNTYyLDcgKzEwMDksMzEgQEAgc3NhX2ZpeF9k dXBsaWNhdGVfYmxvY2tfZWRnZXMgKHN0cnVjdCByZWRpcmVjdGlvbl8KIAkJ ICAgIH0KIAkJfQogCSAgICB9Ci0JICBjb3VudCsrOworCisJICAvKiBVcGRh dGUgdGhlIGNvdW50cyBhbmQgZnJlcXVlbmN5IG9mIGJvdGggdGhlIG9yaWdp bmFsIGJsb2NrCisJICAgICBhbmQgcGF0aCBlZGdlLCBhbmQgdGhlIGR1cGxp Y2F0ZXMuICBUaGUgcGF0aCBkdXBsaWNhdGUncworCSAgICAgaW5jb21pbmcg Y291bnQgYW5kIGZyZXF1ZW5jeSBhcmUgdGhlIHRvdGFscyBmb3IgYWxsIGVk Z2VzCisJICAgICBpbmNvbWluZyB0byB0aGlzIGp1bXAgdGhyZWFkaW5nIHBh dGggY29tcHV0ZWQgZWFybGllci4KKwkgICAgIEFuZCB3ZSBrbm93IHRoYXQg dGhlIGR1cGxpY2F0ZWQgcGF0aCB3aWxsIGhhdmUgcGF0aF9vdXRfY291bnQK KwkgICAgIGZsb3dpbmcgb3V0IG9mIGl0IChpLmUuIGFsb25nIHRoZSBkdXBs aWNhdGVkIHBhdGggb3V0IG9mIHRoZQorCSAgICAgZHVwbGljYXRlZCBqb2lu ZXIpLiAgKi8KKwkgIHVwZGF0ZV9wcm9maWxlIChlcGF0aCwgZTIsIHBhdGhf aW5fY291bnQsIHBhdGhfb3V0X2NvdW50LAorCQkJICBwYXRoX2luX2ZyZXEp OworCisJICAvKiBOZXh0IHdlIG5lZWQgdG8gdXBkYXRlIHRoZSBjb3VudHMg b2YgdGhlIG9yaWdpbmFsIGFuZCBkdXBsaWNhdGVkCisJICAgICBlZGdlcyBm cm9tIHRoZSBqb2luZXIgdGhhdCBnbyBvZmYgcGF0aC4gICovCisJICB1cGRh dGVfam9pbmVyX29mZnBhdGhfY291bnRzIChlcGF0aCwgZTItPnNyYywgcGF0 aF9pbl9jb3VudCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBwYXRoX291dF9jb3VudCk7CisKKwkgIC8qIEZpbmFsbHksIHdl IG5lZWQgdG8gc2V0IHRoZSBwcm9iYWJpbGl0aWVzIG9uIHRoZSBkdXBsaWNh dGVkCisJICAgICBlZGdlcyBvdXQgb2YgdGhlIGR1cGxpY2F0ZWQgam9pbmVy IChlMi0+c3JjKS4gIFRoZSBwcm9iYWJpbGl0aWVzCisJICAgICBhbG9uZyB0 aGUgb3JpZ2luYWwgcGF0aCB3aWxsIGFsbCBiZSB1cGRhdGVkIGJlbG93IGFm dGVyIHdlIGZpbmlzaAorCSAgICAgcHJvY2Vzc2luZyB0aGUgd2hvbGUgcGF0 aC4gICovCisJICByZWNvbXB1dGVfcHJvYmFiaWxpdGllcyAoZTItPnNyYyk7 CisKKwkgIC8qIFJlY29yZCB0aGUgZnJlcXVlbmN5IGZsb3dpbmcgdG8gdGhl IGRvd25zdHJlYW0gZHVwbGljYXRlZAorCSAgICAgcGF0aCBibG9ja3MuICAq LworCSAgY3VyX3BhdGhfZnJlcSA9IEVER0VfRlJFUVVFTkNZIChlMik7CiAJ fQogICAgICAgZWxzZSBpZiAoKCpwYXRoKVtpXS0+dHlwZSA9PSBFREdFX0NP UFlfU1JDX0JMT0NLKQogCXsKQEAgLTU3MCw5ICsxMDQxLDU1IEBAIHNzYV9m aXhfZHVwbGljYXRlX2Jsb2NrX2VkZ2VzIChzdHJ1Y3QgcmVkaXJlY3Rpb25f CiAJICBjcmVhdGVfZWRnZV9hbmRfdXBkYXRlX2Rlc3RpbmF0aW9uX3BoaXMg KHJkLCByZC0+ZHVwX2Jsb2Nrc1tjb3VudF0pOwogCSAgaWYgKGNvdW50ID09 IDEpCiAJICAgIHNpbmdsZV9zdWNjX2VkZ2UgKHJkLT5kdXBfYmxvY2tzWzFd KS0+YXV4ID0gTlVMTDsKKworCSAgLyogVXBkYXRlIHRoZSBjb3VudHMgYW5k IGZyZXF1ZW5jeSBvZiBib3RoIHRoZSBvcmlnaW5hbCBibG9jaworCSAgICAg YW5kIHBhdGggZWRnZSwgYW5kIHRoZSBkdXBsaWNhdGVzLiAgU2luY2Ugd2Ug YXJlIG5vdyBhZnRlcgorCSAgICAgYW55IGpvaW5lciB0aGF0IG1heSBoYXZl IGV4aXN0ZWQgb24gdGhlIHBhdGgsIHRoZSBjb3VudAorCSAgICAgZmxvd2lu ZyBhbG9uZyB0aGUgZHVwbGljYXRlZCB0aHJlYWRlZCBwYXRoIGlzIHBhdGhf b3V0X2NvdW50LgorCSAgICAgSWYgd2UgZGlkbid0IGhhdmUgYSBqb2luZXIs IHRoZW4gY3VyX3BhdGhfZnJlcSB3YXMgdGhlIHN1bQorCSAgICAgb2YgdGhl IHRvdGFsIGZyZXF1ZW5jaWVzIGFsb25nIGFsbCBpbmNvbWluZyBlZGdlcyB0 byB0aGUKKwkgICAgIHRocmVhZCBwYXRoIChwYXRoX2luX2ZyZXEpLiAgSWYg d2UgaGFkIGEgam9pbmVyLCBpdCB3b3VsZCBoYXZlCisJICAgICBiZWVuIHVw ZGF0ZWQgYXQgdGhlIGVuZCBvZiB0aGF0IGhhbmRsaW5nIHRvIHRoZSBlZGdl IGZyZXF1ZW5jeQorCSAgICAgYWxvbmcgdGhlIGR1cGxpY2F0ZWQgam9pbmVy IHBhdGggZWRnZS4gICovCisJICB1cGRhdGVfcHJvZmlsZSAoZXBhdGgsIEVE R0VfU1VDQyAocmQtPmR1cF9ibG9ja3NbY291bnRdLCAwKSwKKwkJCSAgcGF0 aF9vdXRfY291bnQsIHBhdGhfb3V0X2NvdW50LAorCQkJICBjdXJfcGF0aF9m cmVxKTsKKwl9CisgICAgICBlbHNlCisgICAgICAgIHsKKwkgIC8qIE5vIGNv cHkgY2FzZS4gIEluIHRoaXMgY2FzZSB3ZSBkb24ndCBoYXZlIGFuIGVxdWl2 YWxlbnQgYmxvY2sKKwkgICAgIG9uIHRoZSBkdXBsaWNhdGVkIHRocmVhZCBw YXRoIHRvIHVwZGF0ZSwgYnV0IHdlIGRvIG5lZWQKKwkgICAgIHRvIHJlbW92 ZSB0aGUgcG9ydGlvbiBvZiB0aGUgY291bnRzL2ZyZXFzIHRoYXQgd2VyZSBt b3ZlZAorCSAgICAgdG8gdGhlIGR1cGxpY2F0ZWQgcGF0aCBmcm9tIHRoZSBj b3VudHMvZnJlcXMgZmxvd2luZyB0aHJvdWdoCisJICAgICB0aGlzIGJsb2Nr IG9uIHRoZSBvcmlnaW5hbCBwYXRoLiAgU2luY2UgYWxsIHRoZSBuby1jb3B5 IGVkZ2VzCisJICAgICBhcmUgYWZ0ZXIgYW55IGpvaW5lciwgdGhlIHJlbW92 ZWQgY291bnQgaXMgdGhlIHNhbWUgYXMKKwkgICAgIHBhdGhfb3V0X2NvdW50 LgorCisJICAgICBJZiB3ZSBkaWRuJ3QgaGF2ZSBhIGpvaW5lciwgdGhlbiBj dXJfcGF0aF9mcmVxIHdhcyB0aGUgc3VtCisJICAgICBvZiB0aGUgdG90YWwg ZnJlcXVlbmNpZXMgYWxvbmcgYWxsIGluY29taW5nIGVkZ2VzIHRvIHRoZQor CSAgICAgdGhyZWFkIHBhdGggKHBhdGhfaW5fZnJlcSkuICBJZiB3ZSBoYWQg YSBqb2luZXIsIGl0IHdvdWxkIGhhdmUKKwkgICAgIGJlZW4gdXBkYXRlZCBh dCB0aGUgZW5kIG9mIHRoYXQgaGFuZGxpbmcgdG8gdGhlIGVkZ2UgZnJlcXVl bmN5CisJICAgICBhbG9uZyB0aGUgZHVwbGljYXRlZCBqb2luZXIgcGF0aCBl ZGdlLiAgKi8KKwkgICAgIHVwZGF0ZV9wcm9maWxlIChlcGF0aCwgTlVMTCwg cGF0aF9vdXRfY291bnQsIHBhdGhfb3V0X2NvdW50LAorCQkJICAgICBjdXJf cGF0aF9mcmVxKTsKKwl9CisKKyAgICAgIC8qIEluY3JlbWVudCB0aGUgaW5k ZXggaW50byB0aGUgZHVwbGljYXRlZCBwYXRoIHdoZW4gd2UgcHJvY2Vzc2Vk CisgICAgICAgICBhIGR1cGxpY2F0ZWQgYmxvY2suICAqLworICAgICAgaWYg KCgqcGF0aClbaV0tPnR5cGUgPT0gRURHRV9DT1BZX1NSQ19KT0lORVJfQkxP Q0sKKyAgICAgICAgICB8fCAoKnBhdGgpW2ldLT50eXBlID09IEVER0VfQ09Q WV9TUkNfQkxPQ0spCisgICAgICB7CiAJICBjb3VudCsrOwotCX0KKyAgICAg IH0KICAgICB9CisKKyAgLyogTm93IHdhbGsgb3JpZyBibG9ja3MgYW5kIHVw ZGF0ZSB0aGVpciBwcm9iYWJpbGl0aWVzLCBzaW5jZSB0aGUKKyAgICAgY291 bnRzIGFuZCBmcmVxcyBzaG91bGQgYmUgdXBkYXRlZCBwcm9wZXJseSBieSBh Ym92ZSBsb29wLiAgKi8KKyAgZm9yICh1bnNpZ25lZCBpbnQgaSA9IDE7IGkg PCBwYXRoLT5sZW5ndGggKCk7IGkrKykKKyAgICB7CisgICAgICBlZGdlIGVw YXRoID0gKCpwYXRoKVtpXS0+ZTsKKyAgICAgIHJlY29tcHV0ZV9wcm9iYWJp bGl0aWVzIChlcGF0aC0+c3JjKTsKKyAgICB9CiB9CiAKIC8qIEhhc2ggdGFi bGUgdHJhdmVyc2FsIGNhbGxiYWNrIHJvdXRpbmUgdG8gY3JlYXRlIGR1cGxp Y2F0ZSBibG9ja3MuICAqLwpAQCAtNTk4LDcgKzExMTUsOCBAQCBzc2FfY3Jl YXRlX2R1cGxpY2F0ZXMgKHN0cnVjdCByZWRpcmVjdGlvbl9kYXRhICoqcwog ICAgICAgaWYgKCgqcGF0aClbaV0tPnR5cGUgPT0gRURHRV9DT1BZX1NSQ19C TE9DSwogCSAgfHwgKCpwYXRoKVtpXS0+dHlwZSA9PSBFREdFX0NPUFlfU1JD X0pPSU5FUl9CTE9DSykKIAl7Ci0JICBjcmVhdGVfYmxvY2tfZm9yX3RocmVh ZGluZyAoKCpwYXRoKVtpXS0+ZS0+c3JjLCByZCwgMSk7CisJICBjcmVhdGVf YmxvY2tfZm9yX3RocmVhZGluZyAoKCpwYXRoKVtpXS0+ZS0+c3JjLCByZCwg MSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJmxv Y2FsX2luZm8tPmR1cGxpY2F0ZV9ibG9ja3MpOwogCSAgYnJlYWs7CiAJfQog ICAgIH0KQEAgLTYwNyw3ICsxMTI1LDggQEAgc3NhX2NyZWF0ZV9kdXBsaWNh dGVzIChzdHJ1Y3QgcmVkaXJlY3Rpb25fZGF0YSAqKnMKICAgICAgdXNlIHRo ZSB0ZW1wbGF0ZSB0byBjcmVhdGUgYSBuZXcgYmxvY2suICAqLwogICBpZiAo bG9jYWxfaW5mby0+dGVtcGxhdGVfYmxvY2sgPT0gTlVMTCkKICAgICB7Ci0g ICAgICBjcmVhdGVfYmxvY2tfZm9yX3RocmVhZGluZyAoKCpwYXRoKVsxXS0+ ZS0+c3JjLCByZCwgMCk7CisgICAgICBjcmVhdGVfYmxvY2tfZm9yX3RocmVh ZGluZyAoKCpwYXRoKVsxXS0+ZS0+c3JjLCByZCwgMCwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAmbG9jYWxfaW5mby0+ZHVwbGljYXRl X2Jsb2Nrcyk7CiAgICAgICBsb2NhbF9pbmZvLT50ZW1wbGF0ZV9ibG9jayA9 IHJkLT5kdXBfYmxvY2tzWzBdOwogCiAgICAgICAvKiBXZSBkbyBub3QgY3Jl YXRlIGFueSBvdXRnb2luZyBlZGdlcyBmb3IgdGhlIHRlbXBsYXRlLiAgV2Ug d2lsbApAQCAtNjE2LDcgKzExMzUsOCBAQCBzc2FfY3JlYXRlX2R1cGxpY2F0 ZXMgKHN0cnVjdCByZWRpcmVjdGlvbl9kYXRhICoqcwogICAgIH0KICAgZWxz ZQogICAgIHsKLSAgICAgIGNyZWF0ZV9ibG9ja19mb3JfdGhyZWFkaW5nIChs b2NhbF9pbmZvLT50ZW1wbGF0ZV9ibG9jaywgcmQsIDApOworICAgICAgY3Jl YXRlX2Jsb2NrX2Zvcl90aHJlYWRpbmcgKGxvY2FsX2luZm8tPnRlbXBsYXRl X2Jsb2NrLCByZCwgMCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAmbG9jYWxfaW5mby0+ZHVwbGljYXRlX2Jsb2Nrcyk7CiAKICAgICAg IC8qIEdvIGFoZWFkIGFuZCB3aXJlIHVwIG91dGdvaW5nIGVkZ2VzIGFuZCB1 cGRhdGUgUEhJcyBmb3IgdGhlIGR1cGxpY2F0ZQogCSBibG9jay4gICAqLwpA QCAtNjg2LDE5ICsxMjA2LDYgQEAgc3NhX3JlZGlyZWN0X2VkZ2VzIChzdHJ1 Y3QgcmVkaXJlY3Rpb25fZGF0YSAqKnNsb3QKIAkgICAgZnByaW50ZiAoZHVt cF9maWxlLCAiICBUaHJlYWRlZCBqdW1wICVkIC0tPiAlZCB0byAlZFxuIiwK IAkJICAgICBlLT5zcmMtPmluZGV4LCBlLT5kZXN0LT5pbmRleCwgcmQtPmR1 cF9ibG9ja3NbMF0tPmluZGV4KTsKIAotCSAgcmQtPmR1cF9ibG9ja3NbMF0t PmNvdW50ICs9IGUtPmNvdW50OwotCi0JICAvKiBFeGNlc3NpdmUganVtcCB0 aHJlYWRpbmcgbWF5IG1ha2UgZnJlcXVlbmNpZXMgbGFyZ2UgZW5vdWdoIHNv Ci0JICAgICB0aGUgY29tcHV0YXRpb24gb3ZlcmZsb3dzLiAgKi8KLQkgIGlm IChyZC0+ZHVwX2Jsb2Nrc1swXS0+ZnJlcXVlbmN5IDwgQkJfRlJFUV9NQVgg KiAyKQotCSAgICByZC0+ZHVwX2Jsb2Nrc1swXS0+ZnJlcXVlbmN5ICs9IEVE R0VfRlJFUVVFTkNZIChlKTsKLQotCSAgLyogSW4gdGhlIGNhc2Ugb2YgdGhy ZWFkaW5nIHRocm91Z2ggYSBqb2luZXIgYmxvY2ssIHRoZSBvdXRnb2luZwot CSAgICAgZWRnZXMgZnJvbSB0aGUgZHVwbGljYXRlIGJsb2NrIHdlcmUgdXBk YXRlZCB3aGVuIHRoZXkgd2VyZQotCSAgICAgcmVkaXJlY3RlZCBkdXJpbmcg c3NhX2ZpeF9kdXBsaWNhdGVfYmxvY2tfZWRnZXMuICAqLwotCSAgaWYgKCgq cGF0aClbMV0tPnR5cGUgIT0gRURHRV9DT1BZX1NSQ19KT0lORVJfQkxPQ0sp Ci0JICAgIEVER0VfU1VDQyAocmQtPmR1cF9ibG9ja3NbMF0sIDApLT5jb3Vu dCArPSBlLT5jb3VudDsKLQogCSAgLyogUmVkaXJlY3QgdGhlIGluY29taW5n IGVkZ2UgKHBvc3NpYmx5IHRvIHRoZSBqb2luZXIgYmxvY2spIHRvIHRoZQog CSAgICAgYXBwcm9wcmlhdGUgZHVwbGljYXRlIGJsb2NrLiAgKi8KIAkgIGUy ID0gcmVkaXJlY3RfZWRnZV9hbmRfYnJhbmNoIChlLCByZC0+ZHVwX2Jsb2Nr c1swXSk7CkBAIC03ODEsNiArMTI4OCw4IEBAIHRocmVhZF9ibG9ja18xIChi YXNpY19ibG9jayBiYiwgYm9vbCBub2xvb3Bfb25seSwKICAgc3NhX2xvY2Fs X2luZm9fdCBsb2NhbF9pbmZvOwogICBzdHJ1Y3QgbG9vcCAqbG9vcCA9IGJi LT5sb29wX2ZhdGhlcjsKIAorICBsb2NhbF9pbmZvLmR1cGxpY2F0ZV9ibG9j a3MgPSBCSVRNQVBfQUxMT0MgKE5VTEwpOworCiAgIC8qIFRvIGF2b2lkIHNj YW5uaW5nIGEgbGluZWFyIGFycmF5IGZvciB0aGUgZWxlbWVudCB3ZSBuZWVk IHdlIGluc3RlYWQKICAgICAgdXNlIGEgaGFzaCB0YWJsZS4gIEZvciBub3Jt YWwgY29kZSB0aGVyZSBzaG91bGQgYmUgbm8gbm90aWNlYWJsZQogICAgICBk aWZmZXJlbmNlLiAgSG93ZXZlciwgaWYgd2UgaGF2ZSBhIGJsb2NrIHdpdGgg YSBsYXJnZSBudW1iZXIgb2YKQEAgLTg2NSwxMCArMTM3NCw2IEBAIHRocmVh ZF9ibG9ja18xIChiYXNpY19ibG9jayBiYiwgYm9vbCBub2xvb3Bfb25seSwK IAkgICAgY29udGludWU7CiAJfQogCi0gICAgICBpZiAoZS0+ZGVzdCA9PSBl Mi0+c3JjKQotCXVwZGF0ZV9iYl9wcm9maWxlX2Zvcl90aHJlYWRpbmcgKGUt PmRlc3QsIEVER0VfRlJFUVVFTkNZIChlKSwKLQkJCQkJIGUtPmNvdW50LCAo KlRIUkVBRF9QQVRIIChlKSlbMV0tPmUpOwotCiAgICAgICAvKiBJbnNlcnQg dGhlIG91dGdvaW5nIGVkZ2UgaW50byB0aGUgaGFzaCB0YWJsZSBpZiBpdCBp cyBub3QKIAkgYWxyZWFkeSBpbiB0aGUgaGFzaCB0YWJsZS4gICovCiAgICAg ICBsb29rdXBfcmVkaXJlY3Rpb25fZGF0YSAoZSwgSU5TRVJUKTsKQEAgLTky MSw2ICsxNDI2LDkgQEAgdGhyZWFkX2Jsb2NrXzEgKGJhc2ljX2Jsb2NrIGJi LCBib29sIG5vbG9vcF9vbmx5LAogICAgICAgJiYgYmIgPT0gYmItPmxvb3Bf ZmF0aGVyLT5oZWFkZXIpCiAgICAgc2V0X2xvb3BfY29weSAoYmItPmxvb3Bf ZmF0aGVyLCBOVUxMKTsKIAorICBCSVRNQVBfRlJFRSAobG9jYWxfaW5mby5k dXBsaWNhdGVfYmxvY2tzKTsKKyAgbG9jYWxfaW5mby5kdXBsaWNhdGVfYmxv Y2tzID0gTlVMTDsKKwogICAvKiBJbmRpY2F0ZSB0byBvdXIgY2FsbGVyIHdo ZXRoZXIgb3Igbm90IGFueSBqdW1wcyB3ZXJlIHRocmVhZGVkLiAgKi8KICAg cmV0dXJuIGxvY2FsX2luZm8uanVtcHNfdGhyZWFkZWQ7CiB9CkBAIC05ODcs NyArMTQ5NSw3IEBAIHRocmVhZF9zaW5nbGVfZWRnZSAoZWRnZSBlKQogICBu cGF0aC0+c2FmZV9wdXNoICh4KTsKICAgcmQucGF0aCA9IG5wYXRoOwogCi0g IGNyZWF0ZV9ibG9ja19mb3JfdGhyZWFkaW5nIChiYiwgJnJkLCAwKTsKKyAg Y3JlYXRlX2Jsb2NrX2Zvcl90aHJlYWRpbmcgKGJiLCAmcmQsIDAsIE5VTEwp OwogICByZW1vdmVfY3RybF9zdG10X2FuZF91c2VsZXNzX2VkZ2VzIChyZC5k dXBfYmxvY2tzWzBdLCBOVUxMKTsKICAgY3JlYXRlX2VkZ2VfYW5kX3VwZGF0 ZV9kZXN0aW5hdGlvbl9waGlzICgmcmQsIHJkLmR1cF9ibG9ja3NbMF0pOwog Cg== --001a113a2b7aed0fec04f58b0b43--