From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx0a-001b2d01.pphosted.com (mx0b-001b2d01.pphosted.com [148.163.158.5]) by sourceware.org (Postfix) with ESMTPS id 8B2F93857C6A for ; Wed, 22 Jul 2020 15:48:23 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 8B2F93857C6A Received: from pps.filterd (m0098413.ppops.net [127.0.0.1]) by mx0b-001b2d01.pphosted.com (8.16.0.42/8.16.0.42) with SMTP id 06MFVtQQ104561; Wed, 22 Jul 2020 11:48:21 -0400 Received: from pps.reinject (localhost [127.0.0.1]) by mx0b-001b2d01.pphosted.com with ESMTP id 32equj96fc-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 22 Jul 2020 11:48:20 -0400 Received: from m0098413.ppops.net (m0098413.ppops.net [127.0.0.1]) by pps.reinject (8.16.0.36/8.16.0.36) with SMTP id 06MFW5Pq105454; Wed, 22 Jul 2020 11:48:20 -0400 Received: from ppma06ams.nl.ibm.com (66.31.33a9.ip4.static.sl-reverse.com [169.51.49.102]) by mx0b-001b2d01.pphosted.com with ESMTP id 32equj96en-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 22 Jul 2020 11:48:19 -0400 Received: from pps.filterd (ppma06ams.nl.ibm.com [127.0.0.1]) by ppma06ams.nl.ibm.com (8.16.0.42/8.16.0.42) with SMTP id 06MFVvax023740; Wed, 22 Jul 2020 15:48:16 GMT Received: from b06cxnps3074.portsmouth.uk.ibm.com (d06relay09.portsmouth.uk.ibm.com [9.149.109.194]) by ppma06ams.nl.ibm.com with ESMTP id 32brbh53xh-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 22 Jul 2020 15:48:16 +0000 Received: from d06av22.portsmouth.uk.ibm.com (d06av22.portsmouth.uk.ibm.com [9.149.105.58]) by b06cxnps3074.portsmouth.uk.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 06MFmEGi29557232 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Wed, 22 Jul 2020 15:48:14 GMT Received: from d06av22.portsmouth.uk.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 0D1B04C044; Wed, 22 Jul 2020 15:48:14 +0000 (GMT) Received: from d06av22.portsmouth.uk.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 62CFE4C040; Wed, 22 Jul 2020 15:48:11 +0000 (GMT) Received: from KewenLins-MacBook-Pro.local (unknown [9.197.238.225]) by d06av22.portsmouth.uk.ibm.com (Postfix) with ESMTP; Wed, 22 Jul 2020 15:48:11 +0000 (GMT) Subject: [PATCH v3] vect/rs6000: Support vector with length cost modeling To: GCC Patches , richard.sandiford@arm.com References: <419f1fad-05be-115c-1a53-cb710ae7b2dc@linux.ibm.com> Cc: Richard Biener , Bill Schmidt , Segher Boessenkool From: "Kewen.Lin" Message-ID: <1aeabdc7-0cf4-055b-a3ec-74c283053cf5@linux.ibm.com> Date: Wed, 22 Jul 2020 23:48:09 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:68.0) Gecko/20100101 Thunderbird/68.9.0 MIME-Version: 1.0 In-Reply-To: Content-Type: multipart/mixed; boundary="------------E4757AAFECC34F766E6FC998" Content-Language: en-US X-TM-AS-GCONF: 00 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.235, 18.0.687 definitions=2020-07-22_09:2020-07-22, 2020-07-22 signatures=0 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 phishscore=0 mlxlogscore=999 clxscore=1015 adultscore=0 mlxscore=0 spamscore=0 malwarescore=0 bulkscore=0 suspectscore=0 priorityscore=1501 impostorscore=0 lowpriorityscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2006250000 definitions=main-2007220105 X-Spam-Status: No, score=-11.2 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_STATUS, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 22 Jul 2020 15:48:26 -0000 This is a multi-part message in MIME format. --------------E4757AAFECC34F766E6FC998 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Hi Richard, Thanks for the review! on 2020/7/22 下午5:11, Richard Sandiford wrote: > "Kewen.Lin" writes: >> - else if (LOOP_VINFO_FULLY_WITH_LENGTH_P (loop_vinfo)) >> - { >> - peel_iters_prologue = 0; >> - peel_iters_epilogue = 0; >> + if (LOOP_VINFO_FULLY_MASKED_P (loop_vinfo)) >> + { >> + /* Calculate how many masks we need to generate. */ >> + unsigned int num_masks = 0; >> + rgroup_controls *rgm; >> + unsigned int num_vectors_m1; >> + FOR_EACH_VEC_ELT (LOOP_VINFO_MASKS (loop_vinfo), num_vectors_m1, rgm) >> + if (rgm->type) >> + num_masks += num_vectors_m1 + 1; >> + gcc_assert (num_masks > 0); >> + >> + /* In the worst case, we need to generate each mask in the prologue >> + and in the loop body. One of the loop body mask instructions >> + replaces the comparison in the scalar loop, and since we don't >> + count the scalar comparison against the scalar body, we shouldn't >> + count that vector instruction against the vector body either. >> + >> + Sometimes we can use unpacks instead of generating prologue >> + masks and sometimes the prologue mask will fold to a constant, >> + so the actual prologue cost might be smaller. However, it's >> + simpler and safer to use the worst-case cost; if this ends up >> + being the tie-breaker between vectorizing or not, then it's >> + probably better not to vectorize. */ >> + (void) add_stmt_cost (loop_vinfo, target_cost_data, num_masks, >> + vector_stmt, NULL, NULL_TREE, 0, vect_prologue); >> + (void) add_stmt_cost (loop_vinfo, target_cost_data, num_masks - 1, >> + vector_stmt, NULL, NULL_TREE, 0, vect_body); >> + } >> + else >> + { >> + gcc_assert (LOOP_VINFO_FULLY_WITH_LENGTH_P (loop_vinfo)); >> + >> + /* Consider cost for LOOP_VINFO_PEELING_FOR_ALIGNMENT. */ >> + if (npeel < 0) >> + { >> + peel_iters_prologue = assumed_vf / 2; >> + /* See below, if peeled iterations are unknown, count a taken >> + branch and a not taken branch per peeled loop. */ >> + (void) add_stmt_cost (loop_vinfo, target_cost_data, 1, >> + cond_branch_taken, NULL, NULL_TREE, 0, >> + vect_prologue); >> + (void) add_stmt_cost (loop_vinfo, target_cost_data, 1, >> + cond_branch_not_taken, NULL, NULL_TREE, 0, >> + vect_prologue); >> + } >> + else >> + { >> + peel_iters_prologue = npeel; >> + if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)) >> + /* See vect_get_known_peeling_cost, if peeled iterations are >> + known but number of scalar loop iterations are unknown, count >> + a taken branch per peeled loop. */ >> + (void) add_stmt_cost (loop_vinfo, target_cost_data, 1, >> + cond_branch_taken, NULL, NULL_TREE, 0, >> + vect_prologue); >> + } > > I think it'd be good to avoid duplicating this. How about the > following structure? > > if (vect_use_loop_mask_for_alignment_p (…)) > { > peel_iters_prologue = 0; > peel_iters_epilogue = 0; > } > else if (npeel < 0) > { > … // A > } > else > { > …vect_get_known_peeling_cost stuff… > } > > but in A and vect_get_known_peeling_cost, set peel_iters_epilogue to: > > LOOP_VINFO_PEELING_FOR_GAPS (loop_vinfo) ? 1 : 0 > > for LOOP_VINFO_USING_PARTIAL_VECTORS_P, instead of setting it to > whatever value we'd normally use. Then wrap: > > (void) add_stmt_cost (loop_vinfo, target_cost_data, 1, cond_branch_taken, > NULL, NULL_TREE, 0, vect_epilogue); > (void) add_stmt_cost (loop_vinfo, > target_cost_data, 1, cond_branch_not_taken, > NULL, NULL_TREE, 0, vect_epilogue); > > in !LOOP_VINFO_USING_PARTIAL_VECTORS_P and make the other vect_epilogue > stuff in A conditional on peel_iters_epilogue != 0. > > This will also remove the need for the existing LOOP_VINFO_FULLY_MASKED_P > code: > > if (LOOP_VINFO_PEELING_FOR_GAPS (loop_vinfo)) > { > /* We need to peel exactly one iteration. */ > peel_iters_epilogue += 1; > stmt_info_for_cost *si; > int j; > FOR_EACH_VEC_ELT (LOOP_VINFO_SCALAR_ITERATION_COST (loop_vinfo), > j, si) > (void) add_stmt_cost (loop_vinfo, target_cost_data, si->count, > si->kind, si->stmt_info, si->vectype, > si->misalign, vect_epilogue); > } > > Then, after the above, have: > > if (LOOP_VINFO_FULLY_MASKED_P (loop_vinfo)) > …add costs for mask overhead… > else if (LOOP_VINFO_FULLY_WITH_LENGTH_P (loop_vinfo)) > …add costs for lengths overhead… > > So we'd have one block of code for estimating the prologue and epilogue > peeling cost, and a separate block of code for the loop control overhead. > It's a great idea, by following your subsequent suggestion to make the structure like: - calculate peel_iters_prologue - calculate peel_iters_epilogue - add costs associated with peel_iters_prologue - add costs associated with peel_iters_epilogue - add costs related to branch taken/not_taken. the updated v3 is attached. Just bootstrapped/regtested on powerpc64le-linux-gnu (P9) with explicit param vect-partial-vector-usage=1, I'll test it without partial vectors setting, also on aarch64 later. BR, Kewen ----- gcc/ChangeLog: * config/rs6000/rs6000.c (adjust_vect_cost_per_loop): New function. (rs6000_finish_cost): Call adjust_vect_cost_per_loop. * tree-vect-loop.c (vect_get_known_peeling_cost): Factor out some code to determine peel_iters_epilogue to function ... (vect_get_peel_iters_epilogue): ... this. New function. (vect_estimate_min_profitable_iters): Add cost modeling for vector with length, refactor cost calculation on peel_iters_prologue and peel_iters_epilogue. --------------E4757AAFECC34F766E6FC998 Content-Type: text/plain; charset=UTF-8; x-mac-type="0"; x-mac-creator="0"; name="cost_v3.diff" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="cost_v3.diff" ZGlmZiAtLWdpdCBhL2djYy9jb25maWcvcnM2MDAwL3JzNjAwMC5jIGIvZ2NjL2NvbmZpZy9y czYwMDAvcnM2MDAwLmMKaW5kZXggMDA5YWZjNWY4OTQuLmQ3MWYyYmYxYzE2IDEwMDY0NAot LS0gYS9nY2MvY29uZmlnL3JzNjAwMC9yczYwMDAuYworKysgYi9nY2MvY29uZmlnL3JzNjAw MC9yczYwMDAuYwpAQCAtNTE3Nyw2ICs1MTc3LDM0IEBAIHJzNjAwMF9hZGRfc3RtdF9jb3N0 IChjbGFzcyB2ZWNfaW5mbyAqdmluZm8sIHZvaWQgKmRhdGEsIGludCBjb3VudCwKICAgcmV0 dXJuIHJldHZhbDsKIH0KIAorLyogRm9yIHNvbWUgdGFyZ2V0IHNwZWNpZmljIHZlY3Rvcml6 YXRpb24gY29zdCB3aGljaCBjYW4ndCBiZSBoYW5kbGVkIHBlciBzdG10LAorICAgd2UgY2hl Y2sgdGhlIHJlcXVpc2l0ZSBjb25kaXRpb25zIGFuZCBhZGp1c3QgdGhlIHZlY3Rvcml6YXRp b24gY29zdAorICAgYWNjb3JkaW5nbHkgaWYgc2F0aXNmaWVkLiAgT25lIHR5cGljYWwgZXhh bXBsZSBpcyB0byBtb2RlbCBzaGlmdCBjb3N0IGZvcgorICAgdmVjdG9yIHdpdGggbGVuZ3Ro IGJ5IGNvdW50aW5nIG51bWJlciBvZiByZXF1aXJlZCBsZW5ndGhzIHVuZGVyIGNvbmRpdGlv bgorICAgTE9PUF9WSU5GT19GVUxMWV9XSVRIX0xFTkdUSF9QLiAgKi8KKworc3RhdGljIHZv aWQKK2FkanVzdF92ZWN0X2Nvc3RfcGVyX2xvb3AgKHJzNjAwMF9jb3N0X2RhdGEgKmRhdGEp Cit7CisgIHN0cnVjdCBsb29wICpsb29wID0gZGF0YS0+bG9vcF9pbmZvOworICBnY2NfYXNz ZXJ0IChsb29wKTsKKyAgbG9vcF92ZWNfaW5mbyBsb29wX3ZpbmZvID0gbG9vcF92ZWNfaW5m b19mb3JfbG9vcCAobG9vcCk7CisKKyAgaWYgKExPT1BfVklORk9fRlVMTFlfV0lUSF9MRU5H VEhfUCAobG9vcF92aW5mbykpCisgICAgeworICAgICAgcmdyb3VwX2NvbnRyb2xzICpyZ2M7 CisgICAgICB1bnNpZ25lZCBpbnQgbnVtX3ZlY3RvcnNfbTE7CisgICAgICB1bnNpZ25lZCBp bnQgc2hpZnRfY250ID0gMDsKKyAgICAgIEZPUl9FQUNIX1ZFQ19FTFQgKExPT1BfVklORk9f TEVOUyAobG9vcF92aW5mbyksIG51bV92ZWN0b3JzX20xLCByZ2MpCisJaWYgKHJnYy0+dHlw ZSkKKwkgIC8qIEVhY2ggbGVuZ3RoIG5lZWRzIG9uZSBzaGlmdCB0byBmaWxsIGludG8gYml0 cyAwLTcuICAqLworCSAgc2hpZnRfY250ICs9IChudW1fdmVjdG9yc19tMSArIDEpOworCisg ICAgICByczYwMDBfYWRkX3N0bXRfY29zdCAobG9vcF92aW5mbywgKHZvaWQgKikgZGF0YSwg c2hpZnRfY250LCBzY2FsYXJfc3RtdCwKKwkJCSAgICBOVUxMLCBOVUxMX1RSRUUsIDAsIHZl Y3RfYm9keSk7CisgICAgfQorfQorCiAvKiBJbXBsZW1lbnQgdGFyZ2V0bS52ZWN0b3JpemUu ZmluaXNoX2Nvc3QuICAqLwogCiBzdGF0aWMgdm9pZApAQCAtNTE4Niw3ICs1MjE0LDEwIEBA IHJzNjAwMF9maW5pc2hfY29zdCAodm9pZCAqZGF0YSwgdW5zaWduZWQgKnByb2xvZ3VlX2Nv c3QsCiAgIHJzNjAwMF9jb3N0X2RhdGEgKmNvc3RfZGF0YSA9IChyczYwMDBfY29zdF9kYXRh KikgZGF0YTsKIAogICBpZiAoY29zdF9kYXRhLT5sb29wX2luZm8pCi0gICAgcnM2MDAwX2Rl bnNpdHlfdGVzdCAoY29zdF9kYXRhKTsKKyAgICB7CisgICAgICBhZGp1c3RfdmVjdF9jb3N0 X3Blcl9sb29wIChjb3N0X2RhdGEpOworICAgICAgcnM2MDAwX2RlbnNpdHlfdGVzdCAoY29z dF9kYXRhKTsKKyAgICB9CiAKICAgLyogRG9uJ3QgdmVjdG9yaXplIG1pbmltdW0tdmVjdG9y aXphdGlvbi1mYWN0b3IsIHNpbXBsZSBjb3B5IGxvb3BzCiAgICAgIHRoYXQgcmVxdWlyZSB2 ZXJzaW9uaW5nIGZvciBhbnkgcmVhc29uLiAgVGhlIHZlY3Rvcml6YXRpb24gaXMgYXQKZGlm ZiAtLWdpdCBhL2djYy90cmVlLXZlY3QtbG9vcC5jIGIvZ2NjL3RyZWUtdmVjdC1sb29wLmMK aW5kZXggZTkzMzQ0MWI5MjIuLmM4NWIzZWExMzkzIDEwMDY0NAotLS0gYS9nY2MvdHJlZS12 ZWN0LWxvb3AuYworKysgYi9nY2MvdHJlZS12ZWN0LWxvb3AuYwpAQCAtMzQ3NCw0MiArMzQ3 NCw1NiBAQCB2ZWN0X2lzX3NpbXBsZV9yZWR1Y3Rpb24gKGxvb3BfdmVjX2luZm8gbG9vcF9p bmZvLCBzdG10X3ZlY19pbmZvIHBoaV9pbmZvLAogICByZXR1cm4gTlVMTDsKIH0KIAotLyog Q2FsY3VsYXRlIGNvc3Qgb2YgcGVlbGluZyB0aGUgbG9vcCBQRUVMX0lURVJTX1BST0xPR1VF IHRpbWVzLiAgKi8KLWludAotdmVjdF9nZXRfa25vd25fcGVlbGluZ19jb3N0IChsb29wX3Zl Y19pbmZvIGxvb3BfdmluZm8sIGludCBwZWVsX2l0ZXJzX3Byb2xvZ3VlLAotICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBpbnQgKnBlZWxfaXRlcnNfZXBpbG9ndWUsCi0gICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHN0bXRfdmVjdG9yX2Zvcl9jb3N0ICpzY2FsYXJfY29z dF92ZWMsCi0JCQkgICAgIHN0bXRfdmVjdG9yX2Zvcl9jb3N0ICpwcm9sb2d1ZV9jb3N0X3Zl YywKLQkJCSAgICAgc3RtdF92ZWN0b3JfZm9yX2Nvc3QgKmVwaWxvZ3VlX2Nvc3RfdmVjKQor LyogQ2FsY3VsYXRlIGhvdyBtYW55IGl0ZXJhdGlvbnMgcGVlbGVkIGZvciBlcGlsb2d1ZSB3 aXRoIGluZm9ybWF0aW9uIExPT1BfVklORk8KKyAgIGFuZCBQRUVMX0lURVJTX1BST0xPR1VF LiAgKi8KKworc3RhdGljIGludAordmVjdF9nZXRfcGVlbF9pdGVyc19lcGlsb2d1ZSAobG9v cF92ZWNfaW5mbyBsb29wX3ZpbmZvLCBpbnQgcGVlbF9pdGVyc19wcm9sb2d1ZSkKIHsKLSAg aW50IHJldHZhbCA9IDA7CiAgIGludCBhc3N1bWVkX3ZmID0gdmVjdF92Zl9mb3JfY29zdCAo bG9vcF92aW5mbyk7Ci0KICAgaWYgKCFMT09QX1ZJTkZPX05JVEVSU19LTk9XTl9QIChsb29w X3ZpbmZvKSkKICAgICB7Ci0gICAgICAqcGVlbF9pdGVyc19lcGlsb2d1ZSA9IGFzc3VtZWRf dmYgLyAyOwogICAgICAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQotICAgICAgICBkdW1wX3By aW50Zl9sb2MgKE1TR19OT1RFLCB2ZWN0X2xvY2F0aW9uLAorCWR1bXBfcHJpbnRmX2xvYyAo TVNHX05PVEUsIHZlY3RfbG9jYXRpb24sCiAJCQkgImNvc3QgbW9kZWw6IGVwaWxvZ3VlIHBl ZWwgaXRlcnMgc2V0IHRvIHZmLzIgIgogCQkJICJiZWNhdXNlIGxvb3AgaXRlcmF0aW9ucyBh cmUgdW5rbm93biAuXG4iKTsKLQotICAgICAgLyogSWYgcGVlbGVkIGl0ZXJhdGlvbnMgYXJl IGtub3duIGJ1dCBudW1iZXIgb2Ygc2NhbGFyIGxvb3AKLSAgICAgICAgIGl0ZXJhdGlvbnMg YXJlIHVua25vd24sIGNvdW50IGEgdGFrZW4gYnJhbmNoIHBlciBwZWVsZWQgbG9vcC4gICov Ci0gICAgICByZXR2YWwgPSByZWNvcmRfc3RtdF9jb3N0IChwcm9sb2d1ZV9jb3N0X3ZlYywg MSwgY29uZF9icmFuY2hfdGFrZW4sCi0JCQkJIE5VTEwsIE5VTExfVFJFRSwgMCwgdmVjdF9w cm9sb2d1ZSk7Ci0gICAgICByZXR2YWwgKz0gcmVjb3JkX3N0bXRfY29zdCAoZXBpbG9ndWVf Y29zdF92ZWMsIDEsIGNvbmRfYnJhbmNoX3Rha2VuLAotCQkJCSAgTlVMTCwgTlVMTF9UUkVF LCAwLCB2ZWN0X2VwaWxvZ3VlKTsKKyAgICAgIHJldHVybiBhc3N1bWVkX3ZmIC8gMjsKICAg ICB9CiAgIGVsc2UKICAgICB7CiAgICAgICBpbnQgbml0ZXJzID0gTE9PUF9WSU5GT19JTlRf TklURVJTIChsb29wX3ZpbmZvKTsKLSAgICAgIHBlZWxfaXRlcnNfcHJvbG9ndWUgPSBuaXRl cnMgPCBwZWVsX2l0ZXJzX3Byb2xvZ3VlID8KLSAgICAgICAgICAgICAgICAgICAgICAgICAg ICBuaXRlcnMgOiBwZWVsX2l0ZXJzX3Byb2xvZ3VlOwotICAgICAgKnBlZWxfaXRlcnNfZXBp bG9ndWUgPSAobml0ZXJzIC0gcGVlbF9pdGVyc19wcm9sb2d1ZSkgJSBhc3N1bWVkX3ZmOwor ICAgICAgaW50IG5wZWVsX3Byb2wKKwk9IG5pdGVycyA8IHBlZWxfaXRlcnNfcHJvbG9ndWUg PyBuaXRlcnMgOiBwZWVsX2l0ZXJzX3Byb2xvZ3VlOworICAgICAgaW50IG5wZWVsX2VwaWwg PSAobml0ZXJzIC0gbnBlZWxfcHJvbCkgJSBhc3N1bWVkX3ZmOwogICAgICAgLyogSWYgd2Ug bmVlZCB0byBwZWVsIGZvciBnYXBzLCBidXQgbm8gcGVlbGluZyBpcyByZXF1aXJlZCwgd2Ug aGF2ZSB0bwogCSBwZWVsIFZGIGl0ZXJhdGlvbnMuICAqLwotICAgICAgaWYgKExPT1BfVklO Rk9fUEVFTElOR19GT1JfR0FQUyAobG9vcF92aW5mbykgJiYgISpwZWVsX2l0ZXJzX2VwaWxv Z3VlKQotCSpwZWVsX2l0ZXJzX2VwaWxvZ3VlID0gYXNzdW1lZF92ZjsKKyAgICAgIGlmIChM T09QX1ZJTkZPX1BFRUxJTkdfRk9SX0dBUFMgKGxvb3BfdmluZm8pICYmICFucGVlbF9lcGls KQorCW5wZWVsX2VwaWwgPSBhc3N1bWVkX3ZmOworICAgICAgcmV0dXJuIG5wZWVsX2VwaWw7 CisgICAgfQorfQorCisvKiBDYWxjdWxhdGUgY29zdCBvZiBwZWVsaW5nIHRoZSBsb29wIFBF RUxfSVRFUlNfUFJPTE9HVUUgdGltZXMuICAqLworaW50Cit2ZWN0X2dldF9rbm93bl9wZWVs aW5nX2Nvc3QgKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywgaW50IHBlZWxfaXRlcnNfcHJv bG9ndWUsCisJCQkgICAgIGludCAqcGVlbF9pdGVyc19lcGlsb2d1ZSwKKwkJCSAgICAgc3Rt dF92ZWN0b3JfZm9yX2Nvc3QgKnNjYWxhcl9jb3N0X3ZlYywKKwkJCSAgICAgc3RtdF92ZWN0 b3JfZm9yX2Nvc3QgKnByb2xvZ3VlX2Nvc3RfdmVjLAorCQkJICAgICBzdG10X3ZlY3Rvcl9m b3JfY29zdCAqZXBpbG9ndWVfY29zdF92ZWMpCit7CisgIGludCByZXR2YWwgPSAwOworCisg ICpwZWVsX2l0ZXJzX2VwaWxvZ3VlCisgICAgPSB2ZWN0X2dldF9wZWVsX2l0ZXJzX2VwaWxv Z3VlIChsb29wX3ZpbmZvLCBwZWVsX2l0ZXJzX3Byb2xvZ3VlKTsKKworICBpZiAoIUxPT1Bf VklORk9fTklURVJTX0tOT1dOX1AgKGxvb3BfdmluZm8pKQorICAgIHsKKyAgICAgIC8qIElm IHBlZWxlZCBpdGVyYXRpb25zIGFyZSBrbm93biBidXQgbnVtYmVyIG9mIHNjYWxhciBsb29w CisJIGl0ZXJhdGlvbnMgYXJlIHVua25vd24sIGNvdW50IGEgdGFrZW4gYnJhbmNoIHBlciBw ZWVsZWQgbG9vcC4gICovCisgICAgICByZXR2YWwgPSByZWNvcmRfc3RtdF9jb3N0IChwcm9s b2d1ZV9jb3N0X3ZlYywgMSwgY29uZF9icmFuY2hfdGFrZW4sIE5VTEwsCisJCQkJIE5VTExf VFJFRSwgMCwgdmVjdF9wcm9sb2d1ZSk7CisgICAgICByZXR2YWwgKz0gcmVjb3JkX3N0bXRf Y29zdCAoZXBpbG9ndWVfY29zdF92ZWMsIDEsIGNvbmRfYnJhbmNoX3Rha2VuLCBOVUxMLAor CQkJCSAgTlVMTF9UUkVFLCAwLCB2ZWN0X2VwaWxvZ3VlKTsKICAgICB9CiAKICAgc3RtdF9p bmZvX2Zvcl9jb3N0ICpzaTsKQEAgLTM2NTIsMjQgKzM2NjYsMTA2IEBAIHZlY3RfZXN0aW1h dGVfbWluX3Byb2ZpdGFibGVfaXRlcnMgKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywKICAg ICAgVE9ETzogQnVpbGQgYW4gZXhwcmVzc2lvbiB0aGF0IHJlcHJlc2VudHMgcGVlbF9pdGVy cyBmb3IgcHJvbG9ndWUgYW5kCiAgICAgIGVwaWxvZ3VlIHRvIGJlIHVzZWQgaW4gYSBydW4t dGltZSB0ZXN0LiAgKi8KIAotICBpZiAoTE9PUF9WSU5GT19GVUxMWV9NQVNLRURfUCAobG9v cF92aW5mbykpCisgIGJvb2wgcHJvbF9uZWVkX2JyX3Rha2VuX2Nvc3QgPSBmYWxzZTsKKyAg Ym9vbCBwcm9sX25lZWRfYnJfbm90X3Rha2VuX2Nvc3QgPSBmYWxzZTsKKworICAvKiBDYWxj dWxhdGUgcGVlbF9pdGVyc19wcm9sb2d1ZS4gICovCisgIGlmICh2ZWN0X3VzZV9sb29wX21h c2tfZm9yX2FsaWdubWVudF9wIChsb29wX3ZpbmZvKSkKKyAgICBwZWVsX2l0ZXJzX3Byb2xv Z3VlID0gMDsKKyAgZWxzZSBpZiAobnBlZWwgPCAwKQogICAgIHsKLSAgICAgIHBlZWxfaXRl cnNfcHJvbG9ndWUgPSAwOwotICAgICAgcGVlbF9pdGVyc19lcGlsb2d1ZSA9IDA7CisgICAg ICBwZWVsX2l0ZXJzX3Byb2xvZ3VlID0gYXNzdW1lZF92ZiAvIDI7CisgICAgICBpZiAoZHVt cF9lbmFibGVkX3AgKCkpCisJZHVtcF9wcmludGYgKE1TR19OT1RFLCAiY29zdCBtb2RlbDog IgorCQkJICAgICAgICJwcm9sb2d1ZSBwZWVsIGl0ZXJzIHNldCB0byB2Zi8yLlxuIik7CiAK LSAgICAgIGlmIChMT09QX1ZJTkZPX1BFRUxJTkdfRk9SX0dBUFMgKGxvb3BfdmluZm8pKQor ICAgICAgLyogSWYgcGVlbGVkIGl0ZXJhdGlvbnMgYXJlIHVua25vd24sIGNvdW50IGEgdGFr ZW4gYnJhbmNoIGFuZCBhIG5vdCB0YWtlbgorCSBicmFuY2ggcGVyIHBlZWxlZCBsb29wLiBF dmVuIGlmIHNjYWxhciBsb29wIGl0ZXJhdGlvbnMgYXJlIGtub3duLAorCSB2ZWN0b3IgaXRl cmF0aW9ucyBhcmUgbm90IGtub3duIHNpbmNlIHBlZWxlZCBwcm9sb2d1ZSBpdGVyYXRpb25z IGFyZQorCSBub3Qga25vd24uIEhlbmNlIGd1YXJkcyByZW1haW4gdGhlIHNhbWUuICAqLwor ICAgICAgcHJvbF9uZWVkX2JyX3Rha2VuX2Nvc3QgPSB0cnVlOworICAgICAgcHJvbF9uZWVk X2JyX25vdF90YWtlbl9jb3N0ID0gdHJ1ZTsKKyAgICB9CisgIGVsc2UKKyAgICBwZWVsX2l0 ZXJzX3Byb2xvZ3VlID0gbnBlZWw7CisKKyAgYm9vbCBlcGlsX25lZWRfYnJfdGFrZW5fY29z dCA9IGZhbHNlOworICBib29sIGVwaWxfbmVlZF9icl9ub3RfdGFrZW5fY29zdCA9IGZhbHNl OworCisgIC8qIENhbGN1bGF0ZSBwZWVsX2l0ZXJzX2VwaWxvZ3VlLiAgKi8KKyAgaWYgKExP T1BfVklORk9fVVNJTkdfUEFSVElBTF9WRUNUT1JTX1AgKGxvb3BfdmluZm8pKQorICAgIC8q IFdlIG5lZWQgdG8gcGVlbCBleGFjdGx5IG9uZSBpdGVyYXRpb24gZm9yIGdhcHMuICAqLwor ICAgIHBlZWxfaXRlcnNfZXBpbG9ndWUgPSBMT09QX1ZJTkZPX1BFRUxJTkdfRk9SX0dBUFMg KGxvb3BfdmluZm8pID8gMSA6IDA7CisgIGVsc2UgaWYgKG5wZWVsIDwgMCkKKyAgICB7Cisg ICAgICAvKiBJZiBwZWVsaW5nIGZvciBhbGlnbm1lbnQgaXMgdW5rbm93biwgbG9vcCBib3Vu ZCBvZiBtYWluIGxvb3AKKwkgYmVjb21lcyB1bmtub3duLiAgKi8KKyAgICAgIHBlZWxfaXRl cnNfZXBpbG9ndWUgPSBhc3N1bWVkX3ZmIC8gMjsKKyAgICAgIGlmIChkdW1wX2VuYWJsZWRf cCAoKSkKKwlkdW1wX3ByaW50ZiAoTVNHX05PVEUsICJjb3N0IG1vZGVsOiAiCisJCQkgICAg ICAgImVwaWxvZ3VlIHBlZWwgaXRlcnMgc2V0IHRvIHZmLzIgYmVjYXVzZSAiCisJCQkgICAg ICAgInBlZWxpbmcgZm9yIGFsaWdubWVudCBpcyB1bmtub3duLlxuIik7CisKKyAgICAgIC8q IFNlZSB0aGUgc2FtZSByZWFzb24gYWJvdmUgaW4gcGVlbF9pdGVyc19wcm9sb2d1ZSBjYWxj dWxhdGlvbi4gICovCisgICAgICBlcGlsX25lZWRfYnJfdGFrZW5fY29zdCA9IHRydWU7Cisg ICAgICBlcGlsX25lZWRfYnJfbm90X3Rha2VuX2Nvc3QgPSB0cnVlOworICAgIH0KKyAgZWxz ZQorICAgIHsKKyAgICAgIHBlZWxfaXRlcnNfZXBpbG9ndWUgPSB2ZWN0X2dldF9wZWVsX2l0 ZXJzX2VwaWxvZ3VlIChsb29wX3ZpbmZvLCBucGVlbCk7CisgICAgICBpZiAoIUxPT1BfVklO Rk9fTklURVJTX0tOT1dOX1AgKGxvb3BfdmluZm8pKQogCXsKLQkgIC8qIFdlIG5lZWQgdG8g cGVlbCBleGFjdGx5IG9uZSBpdGVyYXRpb24uICAqLwotCSAgcGVlbF9pdGVyc19lcGlsb2d1 ZSArPSAxOwotCSAgc3RtdF9pbmZvX2Zvcl9jb3N0ICpzaTsKLQkgIGludCBqOwotCSAgRk9S X0VBQ0hfVkVDX0VMVCAoTE9PUF9WSU5GT19TQ0FMQVJfSVRFUkFUSU9OX0NPU1QgKGxvb3Bf dmluZm8pLAotCQkJICAgIGosIHNpKQotCSAgICAodm9pZCkgYWRkX3N0bXRfY29zdCAobG9v cF92aW5mbywgdGFyZ2V0X2Nvc3RfZGF0YSwgc2ktPmNvdW50LAotCQkJCSAgc2ktPmtpbmQs IHNpLT5zdG10X2luZm8sIHNpLT52ZWN0eXBlLAotCQkJCSAgc2ktPm1pc2FsaWduLCB2ZWN0 X2VwaWxvZ3VlKTsKKwkgIC8qIElmIHBlZWxlZCBpdGVyYXRpb25zIGFyZSBrbm93biBidXQg bnVtYmVyIG9mIHNjYWxhciBsb29wCisJICAgICBpdGVyYXRpb25zIGFyZSB1bmtub3duLCBj b3VudCBhIHRha2VuIGJyYW5jaCBwZXIgcGVlbGVkIGxvb3AuICAqLworCSAgcHJvbF9uZWVk X2JyX3Rha2VuX2Nvc3QgPSB0cnVlOworCSAgZXBpbF9uZWVkX2JyX3Rha2VuX2Nvc3QgPSB0 cnVlOwogCX0KKyAgICB9CisKKyAgc3RtdF9pbmZvX2Zvcl9jb3N0ICpzaTsKKyAgaW50IGo7 CisgIC8qIEFkZCBjb3N0cyBhc3NvY2lhdGVkIHdpdGggcGVlbF9pdGVyc19wcm9sb2d1ZS4g ICovCisgIGlmIChwZWVsX2l0ZXJzX3Byb2xvZ3VlKQorICAgIEZPUl9FQUNIX1ZFQ19FTFQg KExPT1BfVklORk9fU0NBTEFSX0lURVJBVElPTl9DT1NUIChsb29wX3ZpbmZvKSwgaiwgc2kp CisgICAgICB7CisJKHZvaWQpIGFkZF9zdG10X2Nvc3QgKGxvb3BfdmluZm8sIHRhcmdldF9j b3N0X2RhdGEsCisJCQkgICAgICBzaS0+Y291bnQgKiBwZWVsX2l0ZXJzX3Byb2xvZ3VlLCBz aS0+a2luZCwKKwkJCSAgICAgIHNpLT5zdG10X2luZm8sIHNpLT52ZWN0eXBlLCBzaS0+bWlz YWxpZ24sCisJCQkgICAgICB2ZWN0X3Byb2xvZ3VlKTsKKyAgICAgIH0KKworICAvKiBBZGQg Y29zdHMgYXNzb2NpYXRlZCB3aXRoIHBlZWxfaXRlcnNfcHJvbG9ndWUuICAqLworICBpZiAo cGVlbF9pdGVyc19lcGlsb2d1ZSkKKyAgICBGT1JfRUFDSF9WRUNfRUxUIChMT09QX1ZJTkZP X1NDQUxBUl9JVEVSQVRJT05fQ09TVCAobG9vcF92aW5mbyksIGosIHNpKQorICAgICAgewor CSh2b2lkKSBhZGRfc3RtdF9jb3N0IChsb29wX3ZpbmZvLCB0YXJnZXRfY29zdF9kYXRhLAor CQkJICAgICAgc2ktPmNvdW50ICogcGVlbF9pdGVyc19lcGlsb2d1ZSwgc2ktPmtpbmQsCisJ CQkgICAgICBzaS0+c3RtdF9pbmZvLCBzaS0+dmVjdHlwZSwgc2ktPm1pc2FsaWduLAorCQkJ ICAgICAgdmVjdF9lcGlsb2d1ZSk7CisgICAgICB9CisKKyAgLyogQWRkIHBvc3NpYmxlIGNv bmRfYnJhbmNoX3Rha2VuL2NvbmRfYnJhbmNoX25vdF90YWtlbiBjb3N0LiAgKi8KKyAgaWYg KHByb2xfbmVlZF9icl90YWtlbl9jb3N0KQorICAgICh2b2lkKSBhZGRfc3RtdF9jb3N0IChs b29wX3ZpbmZvLCB0YXJnZXRfY29zdF9kYXRhLCAxLCBjb25kX2JyYW5jaF90YWtlbiwKKwkJ CSAgTlVMTCwgTlVMTF9UUkVFLCAwLCB2ZWN0X3Byb2xvZ3VlKTsKIAorICBpZiAocHJvbF9u ZWVkX2JyX25vdF90YWtlbl9jb3N0KQorICAgICh2b2lkKSBhZGRfc3RtdF9jb3N0IChsb29w X3ZpbmZvLCB0YXJnZXRfY29zdF9kYXRhLCAxLAorCQkJICBjb25kX2JyYW5jaF9ub3RfdGFr ZW4sIE5VTEwsIE5VTExfVFJFRSwgMCwKKwkJCSAgdmVjdF9wcm9sb2d1ZSk7CisKKyAgaWYg KGVwaWxfbmVlZF9icl90YWtlbl9jb3N0KQorICAgICh2b2lkKSBhZGRfc3RtdF9jb3N0IChs b29wX3ZpbmZvLCB0YXJnZXRfY29zdF9kYXRhLCAxLCBjb25kX2JyYW5jaF90YWtlbiwKKwkJ CSAgTlVMTCwgTlVMTF9UUkVFLCAwLCB2ZWN0X2VwaWxvZ3VlKTsKKworICBpZiAoZXBpbF9u ZWVkX2JyX25vdF90YWtlbl9jb3N0KQorICAgICh2b2lkKSBhZGRfc3RtdF9jb3N0IChsb29w X3ZpbmZvLCB0YXJnZXRfY29zdF9kYXRhLCAxLAorCQkJICBjb25kX2JyYW5jaF9ub3RfdGFr ZW4sIE5VTEwsIE5VTExfVFJFRSwgMCwKKwkJCSAgdmVjdF9lcGlsb2d1ZSk7CisKKyAgLyog VGFrZSBjYXJlIG9mIHNwZWNpYWwgY29zdHMgZm9yIHJncm91cCBjb250cm9scyBvZiBwYXJ0 aWFsIHZlY3RvcnMuICAqLworICBpZiAoTE9PUF9WSU5GT19GVUxMWV9NQVNLRURfUCAobG9v cF92aW5mbykpCisgICAgewogICAgICAgLyogQ2FsY3VsYXRlIGhvdyBtYW55IG1hc2tzIHdl IG5lZWQgdG8gZ2VuZXJhdGUuICAqLwogICAgICAgdW5zaWduZWQgaW50IG51bV9tYXNrcyA9 IDA7CiAgICAgICByZ3JvdXBfY29udHJvbHMgKnJnbTsKQEAgLTM2OTEsOTMgKzM3ODcsNzkg QEAgdmVjdF9lc3RpbWF0ZV9taW5fcHJvZml0YWJsZV9pdGVycyAobG9vcF92ZWNfaW5mbyBs b29wX3ZpbmZvLAogCSBzaW1wbGVyIGFuZCBzYWZlciB0byB1c2UgdGhlIHdvcnN0LWNhc2Ug Y29zdDsgaWYgdGhpcyBlbmRzIHVwCiAJIGJlaW5nIHRoZSB0aWUtYnJlYWtlciBiZXR3ZWVu IHZlY3Rvcml6aW5nIG9yIG5vdCwgdGhlbiBpdCdzCiAJIHByb2JhYmx5IGJldHRlciBub3Qg dG8gdmVjdG9yaXplLiAgKi8KLSAgICAgICh2b2lkKSBhZGRfc3RtdF9jb3N0IChsb29wX3Zp bmZvLAotCQkJICAgIHRhcmdldF9jb3N0X2RhdGEsIG51bV9tYXNrcywgdmVjdG9yX3N0bXQs Ci0JCQkgICAgTlVMTCwgTlVMTF9UUkVFLCAwLCB2ZWN0X3Byb2xvZ3VlKTsKLSAgICAgICh2 b2lkKSBhZGRfc3RtdF9jb3N0IChsb29wX3ZpbmZvLAotCQkJICAgIHRhcmdldF9jb3N0X2Rh dGEsIG51bV9tYXNrcyAtIDEsIHZlY3Rvcl9zdG10LAotCQkJICAgIE5VTEwsIE5VTExfVFJF RSwgMCwgdmVjdF9ib2R5KTsKKyAgICAgICh2b2lkKSBhZGRfc3RtdF9jb3N0IChsb29wX3Zp bmZvLCB0YXJnZXRfY29zdF9kYXRhLCBudW1fbWFza3MsCisJCQkgICAgdmVjdG9yX3N0bXQs IE5VTEwsIE5VTExfVFJFRSwgMCwgdmVjdF9wcm9sb2d1ZSk7CisgICAgICAodm9pZCkgYWRk X3N0bXRfY29zdCAobG9vcF92aW5mbywgdGFyZ2V0X2Nvc3RfZGF0YSwgbnVtX21hc2tzIC0g MSwKKwkJCSAgICB2ZWN0b3Jfc3RtdCwgTlVMTCwgTlVMTF9UUkVFLCAwLCB2ZWN0X2JvZHkp OwogICAgIH0KICAgZWxzZSBpZiAoTE9PUF9WSU5GT19GVUxMWV9XSVRIX0xFTkdUSF9QIChs b29wX3ZpbmZvKSkKICAgICB7Ci0gICAgICBwZWVsX2l0ZXJzX3Byb2xvZ3VlID0gMDsKLSAg ICAgIHBlZWxfaXRlcnNfZXBpbG9ndWUgPSAwOwotICAgIH0KLSAgZWxzZSBpZiAobnBlZWwg PCAwKQotICAgIHsKLSAgICAgIHBlZWxfaXRlcnNfcHJvbG9ndWUgPSBhc3N1bWVkX3ZmIC8g MjsKLSAgICAgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKLQlkdW1wX3ByaW50ZiAoTVNHX05P VEUsICJjb3N0IG1vZGVsOiAiCi0JCSAgICAgInByb2xvZ3VlIHBlZWwgaXRlcnMgc2V0IHRv IHZmLzIuXG4iKTsKLQotICAgICAgLyogSWYgcGVlbGluZyBmb3IgYWxpZ25tZW50IGlzIHVu a25vd24sIGxvb3AgYm91bmQgb2YgbWFpbiBsb29wIGJlY29tZXMKLSAgICAgICAgIHVua25v d24uICAqLwotICAgICAgcGVlbF9pdGVyc19lcGlsb2d1ZSA9IGFzc3VtZWRfdmYgLyAyOwot ICAgICAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQotCWR1bXBfcHJpbnRmIChNU0dfTk9URSwg ImNvc3QgbW9kZWw6ICIKLQkJICAgICAiZXBpbG9ndWUgcGVlbCBpdGVycyBzZXQgdG8gdmYv MiBiZWNhdXNlICIKLQkJICAgICAicGVlbGluZyBmb3IgYWxpZ25tZW50IGlzIHVua25vd24u XG4iKTsKKyAgICAgIC8qIFJlZmVyIHRvIHRoZSBmdW5jdGlvbnMgdmVjdF9zZXRfbG9vcF9j b25kaXRpb25fcGFydGlhbF92ZWN0b3JzCisJIGFuZCB2ZWN0X3NldF9sb29wX2NvbnRyb2xz X2RpcmVjdGx5LCB3ZSBuZWVkIHRvIGdlbmVyYXRlIGVhY2gKKwkgbGVuZ3RoIGluIHRoZSBw cm9sb2d1ZSBhbmQgaW4gdGhlIGxvb3AgYm9keSBpZiByZXF1aXJlZC4gQWx0aG91Z2gKKwkg dGhlcmUgYXJlIHNvbWUgcG9zc2libGUgb3B0aW1pemF0aW9uLCB3ZSBjb25zaWRlciB0aGUg d29yc3QgY2FzZQorCSBoZXJlLiAgKi8KKworICAgICAgLyogRm9yIG5vdyB3ZSBvbmx5IG9w ZXJhdGUgbGVuZ3RoLWJhc2VkIHBhcnRpYWwgdmVjdG9ycyBvbiBQb3dlciwKKwkgd2hpY2gg aGFzIGNvbnN0YW50IFZGIGFsbCB0aGUgdGltZSwgd2UgbmVlZCBzb21lIHR3ZWFraW5ncyBi ZWxvdworCSBpZiBpdCBkb2Vzbid0IGhvbGQgaW4gZnV0dXJlLiAgKi8KKyAgICAgIGdjY19h c3NlcnQgKExPT1BfVklORk9fVkVDVF9GQUNUT1IgKGxvb3BfdmluZm8pLmlzX2NvbnN0YW50 ICgpKTsKKworICAgICAgLyogRm9yIHdyYXAgYXJvdW5kIGNoZWNraW5nLiAgKi8KKyAgICAg IHRyZWUgY29tcGFyZV90eXBlID0gTE9PUF9WSU5GT19SR1JPVVBfQ09NUEFSRV9UWVBFIChs b29wX3ZpbmZvKTsKKyAgICAgIHVuc2lnbmVkIGludCBjb21wYXJlX3ByZWNpc2lvbiA9IFRZ UEVfUFJFQ0lTSU9OIChjb21wYXJlX3R5cGUpOworICAgICAgd2lkZXN0X2ludCBpdl9saW1p dCA9IHZlY3RfaXZfbGltaXRfZm9yX3BhcnRpYWxfdmVjdG9ycyAobG9vcF92aW5mbyk7CisK KyAgICAgIGJvb2wgbml0ZXJzX2tub3duX3AgPSBMT09QX1ZJTkZPX05JVEVSU19LTk9XTl9Q IChsb29wX3ZpbmZvKTsKKyAgICAgIGJvb2wgbmVlZF9pdGVyYXRlX3AKKwk9ICghTE9PUF9W SU5GT19FUElMT0dVRV9QIChsb29wX3ZpbmZvKQorCSAgICYmICF2ZWN0X2tub3duX25pdGVy c19zbWFsbGVyX3RoYW5fdmYgKGxvb3BfdmluZm8pKTsKKworICAgICAgLyogSW5pdCBtaW4v bWF4LCBzaGlmdCBhbmQgbWludXMgY29zdCByZWxhdGl2ZSB0byBzaW5nbGUKKwkgc2NhbGFy X3N0bXQuIEZvciBub3cgd2Ugb25seSB1c2UgbGVuZ3RoLWJhc2VkIHBhcnRpYWwgdmVjdG9y cyBvbgorCSBQb3dlciwgdGFyZ2V0IHNwZWNpZmljIGNvc3QgdHdlYWtpbmcgbWF5IGJlIG5l ZWRlZCBmb3Igb3RoZXIKKwkgcG9ydHMgaW4gZnV0dXJlLiAgKi8KKyAgICAgIHVuc2lnbmVk IGludCBtaW5fbWF4X2Nvc3QgPSAyOworICAgICAgdW5zaWduZWQgaW50IHNoaWZ0X2Nvc3Qg PSAxLCBtaW51c19jb3N0ID0gMTsKKworICAgICAgLyogSW5pdCBjb3N0IHJlbGF0aXZlIHRv IHNpbmdsZSBzY2FsYXJfc3RtdC4gICovCisgICAgICB1bnNpZ25lZCBpbnQgcHJvbF9jbnQg PSAwOworICAgICAgdW5zaWduZWQgaW50IGJvZHlfY250ID0gMDsKKworICAgICAgcmdyb3Vw X2NvbnRyb2xzICpyZ2M7CisgICAgICB1bnNpZ25lZCBpbnQgbnVtX3ZlY3RvcnNfbTE7Cisg ICAgICBGT1JfRUFDSF9WRUNfRUxUIChMT09QX1ZJTkZPX0xFTlMgKGxvb3BfdmluZm8pLCBu dW1fdmVjdG9yc19tMSwgcmdjKQorCWlmIChyZ2MtPnR5cGUpCisJICB7CisJICAgIHVuc2ln bmVkIG5pdGVtcyA9IHJnYy0+bWF4X25zY2FsYXJzX3Blcl9pdGVyICogcmdjLT5mYWN0b3I7 CiAKLSAgICAgIC8qIElmIHBlZWxlZCBpdGVyYXRpb25zIGFyZSB1bmtub3duLCBjb3VudCBh IHRha2VuIGJyYW5jaCBhbmQgYSBub3QgdGFrZW4KLSAgICAgICAgIGJyYW5jaCBwZXIgcGVl bGVkIGxvb3AuIEV2ZW4gaWYgc2NhbGFyIGxvb3AgaXRlcmF0aW9ucyBhcmUga25vd24sCi0g ICAgICAgICB2ZWN0b3IgaXRlcmF0aW9ucyBhcmUgbm90IGtub3duIHNpbmNlIHBlZWxlZCBw cm9sb2d1ZSBpdGVyYXRpb25zIGFyZQotICAgICAgICAgbm90IGtub3duLiBIZW5jZSBndWFy ZHMgcmVtYWluIHRoZSBzYW1lLiAgKi8KLSAgICAgICh2b2lkKSBhZGRfc3RtdF9jb3N0IChs b29wX3ZpbmZvLCB0YXJnZXRfY29zdF9kYXRhLCAxLCBjb25kX2JyYW5jaF90YWtlbiwKLQkJ CSAgICBOVUxMLCBOVUxMX1RSRUUsIDAsIHZlY3RfcHJvbG9ndWUpOwotICAgICAgKHZvaWQp IGFkZF9zdG10X2Nvc3QgKGxvb3BfdmluZm8sCi0JCQkgICAgdGFyZ2V0X2Nvc3RfZGF0YSwg MSwgY29uZF9icmFuY2hfbm90X3Rha2VuLAotCQkJICAgIE5VTEwsIE5VTExfVFJFRSwgMCwg dmVjdF9wcm9sb2d1ZSk7Ci0gICAgICAodm9pZCkgYWRkX3N0bXRfY29zdCAobG9vcF92aW5m bywgdGFyZ2V0X2Nvc3RfZGF0YSwgMSwgY29uZF9icmFuY2hfdGFrZW4sCi0JCQkgICAgTlVM TCwgTlVMTF9UUkVFLCAwLCB2ZWN0X2VwaWxvZ3VlKTsKLSAgICAgICh2b2lkKSBhZGRfc3Rt dF9jb3N0IChsb29wX3ZpbmZvLAotCQkJICAgIHRhcmdldF9jb3N0X2RhdGEsIDEsIGNvbmRf YnJhbmNoX25vdF90YWtlbiwKLQkJCSAgICBOVUxMLCBOVUxMX1RSRUUsIDAsIHZlY3RfZXBp bG9ndWUpOwotICAgICAgc3RtdF9pbmZvX2Zvcl9jb3N0ICpzaTsKLSAgICAgIGludCBqOwot ICAgICAgRk9SX0VBQ0hfVkVDX0VMVCAoTE9PUF9WSU5GT19TQ0FMQVJfSVRFUkFUSU9OX0NP U1QgKGxvb3BfdmluZm8pLCBqLCBzaSkKLQl7Ci0JICAodm9pZCkgYWRkX3N0bXRfY29zdCAo bG9vcF92aW5mbywgdGFyZ2V0X2Nvc3RfZGF0YSwKLQkJCQlzaS0+Y291bnQgKiBwZWVsX2l0 ZXJzX3Byb2xvZ3VlLAotCQkJCXNpLT5raW5kLCBzaS0+c3RtdF9pbmZvLCBzaS0+dmVjdHlw ZSwKLQkJCQlzaS0+bWlzYWxpZ24sCi0JCQkJdmVjdF9wcm9sb2d1ZSk7Ci0JICAodm9pZCkg YWRkX3N0bXRfY29zdCAobG9vcF92aW5mbywgdGFyZ2V0X2Nvc3RfZGF0YSwKLQkJCQlzaS0+ Y291bnQgKiBwZWVsX2l0ZXJzX2VwaWxvZ3VlLAotCQkJCXNpLT5raW5kLCBzaS0+c3RtdF9p bmZvLCBzaS0+dmVjdHlwZSwKLQkJCQlzaS0+bWlzYWxpZ24sCi0JCQkJdmVjdF9lcGlsb2d1 ZSk7Ci0JfQotICAgIH0KLSAgZWxzZQotICAgIHsKLSAgICAgIHN0bXRfdmVjdG9yX2Zvcl9j b3N0IHByb2xvZ3VlX2Nvc3RfdmVjLCBlcGlsb2d1ZV9jb3N0X3ZlYzsKLSAgICAgIHN0bXRf aW5mb19mb3JfY29zdCAqc2k7Ci0gICAgICBpbnQgajsKLSAgICAgIHZvaWQgKmRhdGEgPSBM T09QX1ZJTkZPX1RBUkdFVF9DT1NUX0RBVEEgKGxvb3BfdmluZm8pOworCSAgICAvKiBOZWVk IG9uZSBzaGlmdCBmb3Igbml0ZXJzX3RvdGFsIGNvbXB1dGF0aW9uLiAgKi8KKwkgICAgaWYg KCFuaXRlcnNfa25vd25fcCAmJiBuaXRlbXMgIT0gMSkKKwkgICAgICBwcm9sX2NudCArPSBz aGlmdF9jb3N0OwogCi0gICAgICBwcm9sb2d1ZV9jb3N0X3ZlYy5jcmVhdGUgKDIpOwotICAg ICAgZXBpbG9ndWVfY29zdF92ZWMuY3JlYXRlICgyKTsKLSAgICAgIHBlZWxfaXRlcnNfcHJv bG9ndWUgPSBucGVlbDsKKwkgICAgLyogTmVlZCB0byBoYW5kbGUgd3JhcCBhcm91bmQuICAq LworCSAgICBpZiAoaXZfbGltaXQgPT0gLTEKKwkJfHwgKHdpOjptaW5fcHJlY2lzaW9uIChp dl9saW1pdCAqIG5pdGVtcywgVU5TSUdORUQpCisJCSAgICA+IGNvbXBhcmVfcHJlY2lzaW9u KSkKKwkgICAgICBwcm9sX2NudCArPSAobWluX21heF9jb3N0ICsgbWludXNfY29zdCk7CiAK LSAgICAgICh2b2lkKSB2ZWN0X2dldF9rbm93bl9wZWVsaW5nX2Nvc3QgKGxvb3BfdmluZm8s IHBlZWxfaXRlcnNfcHJvbG9ndWUsCi0JCQkJCSAgJnBlZWxfaXRlcnNfZXBpbG9ndWUsCi0J CQkJCSAgJkxPT1BfVklORk9fU0NBTEFSX0lURVJBVElPTl9DT1NUCi0JCQkJCSAgICAobG9v cF92aW5mbyksCi0JCQkJCSAgJnByb2xvZ3VlX2Nvc3RfdmVjLAotCQkJCQkgICZlcGlsb2d1 ZV9jb3N0X3ZlYyk7CisJICAgIC8qIE5lZWQgdG8gaGFuZGxlIGJhdGNoIGxpbWl0IGV4Y2Vw dGluZyBmb3IgdGhlIDFzdCBvbmUuICAqLworCSAgICBwcm9sX2NudCArPSAobWluX21heF9j b3N0ICsgbWludXNfY29zdCkgKiBudW1fdmVjdG9yc19tMTsKIAotICAgICAgRk9SX0VBQ0hf VkVDX0VMVCAocHJvbG9ndWVfY29zdF92ZWMsIGosIHNpKQotCSh2b2lkKSBhZGRfc3RtdF9j b3N0IChsb29wX3ZpbmZvLAotCQkJICAgICAgZGF0YSwgc2ktPmNvdW50LCBzaS0+a2luZCwg c2ktPnN0bXRfaW5mbywKLQkJCSAgICAgIHNpLT52ZWN0eXBlLCBzaS0+bWlzYWxpZ24sIHZl Y3RfcHJvbG9ndWUpOworCSAgICB1bnNpZ25lZCBpbnQgbnVtX3ZlY3RvcnMgPSBudW1fdmVj dG9yc19tMSArIDE7CisJICAgIC8qIE5lZWQgdG8gc2V0IHVwIGxlbmd0aHMgaW4gcHJvbG9n dWUsIG9ubHkgb25lIE1JTiByZXF1aXJlZAorCSAgICAgICBzaW5jZSBzdGFydCBpbmRleCBp cyB6ZXJvLiAgKi8KKwkgICAgcHJvbF9jbnQgKz0gbWluX21heF9jb3N0ICogbnVtX3ZlY3Rv cnM7CiAKLSAgICAgIEZPUl9FQUNIX1ZFQ19FTFQgKGVwaWxvZ3VlX2Nvc3RfdmVjLCBqLCBz aSkKLQkodm9pZCkgYWRkX3N0bXRfY29zdCAobG9vcF92aW5mbywKLQkJCSAgICAgIGRhdGEs IHNpLT5jb3VudCwgc2ktPmtpbmQsIHNpLT5zdG10X2luZm8sCi0JCQkgICAgICBzaS0+dmVj dHlwZSwgc2ktPm1pc2FsaWduLCB2ZWN0X2VwaWxvZ3VlKTsKKwkgICAgLyogTmVlZCB0byB1 cGRhdGUgbGVuZ3RocyBpbiBib2R5IGZvciBuZXh0IGl0ZXJhdGlvbi4gICovCisJICAgIGlm IChuZWVkX2l0ZXJhdGVfcCkKKwkgICAgICBib2R5X2NudCArPSAoMiAqIG1pbl9tYXhfY29z dCArIG1pbnVzX2Nvc3QpICogbnVtX3ZlY3RvcnM7CisJICB9CiAKLSAgICAgIHByb2xvZ3Vl X2Nvc3RfdmVjLnJlbGVhc2UgKCk7Ci0gICAgICBlcGlsb2d1ZV9jb3N0X3ZlYy5yZWxlYXNl ICgpOworICAgICAgKHZvaWQpIGFkZF9zdG10X2Nvc3QgKGxvb3BfdmluZm8sIHRhcmdldF9j b3N0X2RhdGEsIHByb2xfY250LCBzY2FsYXJfc3RtdCwKKwkJCSAgICBOVUxMLCBOVUxMX1RS RUUsIDAsIHZlY3RfcHJvbG9ndWUpOworICAgICAgKHZvaWQpIGFkZF9zdG10X2Nvc3QgKGxv b3BfdmluZm8sIHRhcmdldF9jb3N0X2RhdGEsIGJvZHlfY250LCBzY2FsYXJfc3RtdCwKKwkJ CSAgICBOVUxMLCBOVUxMX1RSRUUsIDAsIHZlY3RfYm9keSk7CiAgICAgfQogCiAgIC8qIEZP Uk5PVzogVGhlIHNjYWxhciBvdXRzaWRlIGNvc3QgaXMgaW5jcmVtZW50ZWQgaW4gb25lIG9m IHRoZQpAQCAtMzkxMyw4ICszOTk1LDggQEAgdmVjdF9lc3RpbWF0ZV9taW5fcHJvZml0YWJs ZV9pdGVycyAobG9vcF92ZWNfaW5mbyBsb29wX3ZpbmZvLAogICAgIH0KIAogICAvKiA/Pz8g VGhlICJpZiIgYXJtIGlzIHdyaXR0ZW4gdG8gaGFuZGxlIGFsbCBjYXNlczsgc2VlIGJlbG93 IGZvciB3aGF0Ci0gICAgIHdlIHdvdWxkIGRvIGZvciAhTE9PUF9WSU5GT19GVUxMWV9NQVNL RURfUC4gICovCi0gIGlmIChMT09QX1ZJTkZPX0ZVTExZX01BU0tFRF9QIChsb29wX3ZpbmZv KSkKKyAgICAgd2Ugd291bGQgZG8gZm9yICFMT09QX1ZJTkZPX1VTSU5HX1BBUlRJQUxfVkVD VE9SU19QLiAgKi8KKyAgaWYgKExPT1BfVklORk9fVVNJTkdfUEFSVElBTF9WRUNUT1JTX1Ag KGxvb3BfdmluZm8pKQogICAgIHsKICAgICAgIC8qIFJld3JpdGluZyB0aGUgY29uZGl0aW9u IGFib3ZlIGluIHRlcm1zIG9mIHRoZSBudW1iZXIgb2YKIAkgdmVjdG9yIGl0ZXJhdGlvbnMg KHZuaXRlcnMpIHJhdGhlciB0aGFuIHRoZSBudW1iZXIgb2YKQEAgLTM5NDEsNyArNDAyMyw3 IEBAIHZlY3RfZXN0aW1hdGVfbWluX3Byb2ZpdGFibGVfaXRlcnMgKGxvb3BfdmVjX2luZm8g bG9vcF92aW5mbywKIAlkdW1wX3ByaW50ZiAoTVNHX05PVEUsICIgIE1pbmltdW0gbnVtYmVy IG9mIHZlY3RvciBpdGVyYXRpb25zOiAlZFxuIiwKIAkJICAgICBtaW5fdmVjX25pdGVycyk7 CiAKLSAgICAgIGlmIChMT09QX1ZJTkZPX0ZVTExZX01BU0tFRF9QIChsb29wX3ZpbmZvKSkK KyAgICAgIGlmIChMT09QX1ZJTkZPX1VTSU5HX1BBUlRJQUxfVkVDVE9SU19QIChsb29wX3Zp bmZvKSkKIAl7CiAJICAvKiBOb3cgdGhhdCB3ZSBrbm93IHRoZSBtaW5pbXVtIG51bWJlciBv ZiB2ZWN0b3IgaXRlcmF0aW9ucywKIAkgICAgIGZpbmQgdGhlIG1pbmltdW0gbml0ZXJzIGZv ciB3aGljaCB0aGUgc2NhbGFyIGNvc3QgaXMgbGFyZ2VyOgpAQCAtMzk5Niw2ICs0MDc4LDEw IEBAIHZlY3RfZXN0aW1hdGVfbWluX3Byb2ZpdGFibGVfaXRlcnMgKGxvb3BfdmVjX2luZm8g bG9vcF92aW5mbywKICAgICAgICYmIG1pbl9wcm9maXRhYmxlX2l0ZXJzIDwgKGFzc3VtZWRf dmYgKyBwZWVsX2l0ZXJzX3Byb2xvZ3VlKSkKICAgICAvKiBXZSB3YW50IHRoZSB2ZWN0b3Jp emVkIGxvb3AgdG8gZXhlY3V0ZSBhdCBsZWFzdCBvbmNlLiAgKi8KICAgICBtaW5fcHJvZml0 YWJsZV9pdGVycyA9IGFzc3VtZWRfdmYgKyBwZWVsX2l0ZXJzX3Byb2xvZ3VlOworICBlbHNl IGlmIChtaW5fcHJvZml0YWJsZV9pdGVycyA8IHBlZWxfaXRlcnNfcHJvbG9ndWUpCisgICAg LyogRm9yIExPT1BfVklORk9fVVNJTkdfUEFSVElBTF9WRUNUT1JTX1AsIHdlIG5lZWQgdG8g ZW5zdXJlIHRoZQorICAgICAgIHZlY3Rvcml6ZWQgbG9vcCB0byBleGVjdXRlIGF0IGxlYXN0 IG9uY2UuICAqLworICAgIG1pbl9wcm9maXRhYmxlX2l0ZXJzID0gcGVlbF9pdGVyc19wcm9s b2d1ZTsKIAogICBpZiAoZHVtcF9lbmFibGVkX3AgKCkpCiAgICAgZHVtcF9wcmludGZfbG9j IChNU0dfTk9URSwgdmVjdF9sb2NhdGlvbiwKQEAgLTQwMTMsNyArNDA5OSw3IEBAIHZlY3Rf ZXN0aW1hdGVfbWluX3Byb2ZpdGFibGVfaXRlcnMgKGxvb3BfdmVjX2luZm8gbG9vcF92aW5m bywKIAogICBpZiAodmVjX291dHNpZGVfY29zdCA8PSAwKQogICAgIG1pbl9wcm9maXRhYmxl X2VzdGltYXRlID0gMDsKLSAgZWxzZSBpZiAoTE9PUF9WSU5GT19GVUxMWV9NQVNLRURfUCAo bG9vcF92aW5mbykpCisgIGVsc2UgaWYgKExPT1BfVklORk9fVVNJTkdfUEFSVElBTF9WRUNU T1JTX1AgKGxvb3BfdmluZm8pKQogICAgIHsKICAgICAgIC8qIFRoaXMgaXMgYSByZXBlYXQg b2YgdGhlIGNvZGUgYWJvdmUsIGJ1dCB3aXRoICsgU09DIHJhdGhlcgogCSB0aGFuIC0gU09D LiAgKi8KQEAgLTQwMjUsNyArNDExMSw3IEBAIHZlY3RfZXN0aW1hdGVfbWluX3Byb2ZpdGFi bGVfaXRlcnMgKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywKICAgICAgIGlmIChvdXRzaWRl X292ZXJoZWFkID4gMCkKIAltaW5fdmVjX25pdGVycyA9IG91dHNpZGVfb3ZlcmhlYWQgLyBz YXZpbmdfcGVyX3ZpdGVyICsgMTsKIAotICAgICAgaWYgKExPT1BfVklORk9fRlVMTFlfTUFT S0VEX1AgKGxvb3BfdmluZm8pKQorICAgICAgaWYgKExPT1BfVklORk9fVVNJTkdfUEFSVElB TF9WRUNUT1JTX1AgKGxvb3BfdmluZm8pKQogCXsKIAkgIGludCB0aHJlc2hvbGQgPSAodmVj X2luc2lkZV9jb3N0ICogbWluX3ZlY19uaXRlcnMKIAkJCSAgICsgdmVjX291dHNpZGVfY29z dAo= --------------E4757AAFECC34F766E6FC998--