From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 36432 invoked by alias); 6 Jul 2015 13:05:32 -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 36417 invoked by uid 89); 6 Jul 2015 13:05:30 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.2 required=5.0 tests=AWL,BAYES_50,RCVD_IN_DNSWL_NONE,SPF_HELO_PASS,SPF_PASS autolearn=ham version=3.3.2 X-HELO: na01-bn1-obe.outbound.protection.outlook.com Received: from mail-bn1bon0058.outbound.protection.outlook.com (HELO na01-bn1-obe.outbound.protection.outlook.com) (157.56.111.58) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-SHA256 encrypted) ESMTPS; Mon, 06 Jul 2015 13:05:28 +0000 Received: from BN1AFFO11FD034.protection.gbl (10.58.52.33) by BN1AFFO11HUB037.protection.gbl (10.58.52.148) with Microsoft SMTP Server (TLS) id 15.1.201.10; Mon, 6 Jul 2015 13:05:25 +0000 Authentication-Results: spf=pass (sender IP is 149.199.60.100) smtp.mailfrom=xilinx.com; gcc.gnu.org; dkim=none (message not signed) header.d=none; Received-SPF: Pass (protection.outlook.com: domain of xilinx.com designates 149.199.60.100 as permitted sender) receiver=protection.outlook.com; client-ip=149.199.60.100; helo=xsj-pvapsmtpgw02; Received: from xsj-pvapsmtpgw02 (149.199.60.100) by BN1AFFO11FD034.mail.protection.outlook.com (10.58.52.158) with Microsoft SMTP Server (TLS) id 15.1.201.10 via Frontend Transport; Mon, 6 Jul 2015 13:05:23 +0000 Received: from unknown-38-66.xilinx.com ([149.199.38.66]:35171 helo=xsj-pvapsmtp01) by xsj-pvapsmtpgw02 with esmtp (Exim 4.63) (envelope-from ) id 1ZC65K-0001i0-93 for gcc-patches@gcc.gnu.org; Mon, 06 Jul 2015 06:05:22 -0700 Received: from [127.0.0.1] (helo=xsj-smtp-dlp1.xlnx.xilinx.com) by xsj-pvapsmtp01 with esmtp (Exim 4.63) (envelope-from ) id 1ZC65K-0003Oc-3Y for gcc-patches@gcc.gnu.org; Mon, 06 Jul 2015 06:05:22 -0700 Received: from xsj-pvapsmtp01 (xsj-smtp.xilinx.com [149.199.38.66]) by xsj-smtp-dlp1.xlnx.xilinx.com (8.13.8/8.13.1) with ESMTP id t66D4twS001311 for ; Mon, 6 Jul 2015 06:04:56 -0700 Received: from [172.22.159.25] (helo=XAP-PVEXCAS01.xlnx.xilinx.com) by xsj-pvapsmtp01 with esmtp (Exim 4.63) (envelope-from ) id 1ZC65I-0003Nz-Tf for gcc-patches@gcc.gnu.org; Mon, 06 Jul 2015 06:05:21 -0700 Received: from XAP-PVEXMBX02.xlnx.xilinx.com ([fe80::6c95:7dae:8014:5ca1]) by XAP-PVEXCAS01.xlnx.xilinx.com ([::1]) with mapi id 14.03.0195.001; Mon, 6 Jul 2015 21:05:19 +0800 From: Ajit Kumar Agarwal To: GCC Patches CC: Vinod Kathail , Shail Aditya Gupta , Vidhumouli Hunsigida , "Nagaraju Mekala" Subject: [Patch,microblaze]: Optimized usage of reserved stack space for function arguments. Date: Mon, 06 Jul 2015 13:05:00 -0000 Message-ID: <37378DC5BCD0EE48BA4B082E0B55DFAA41F41AB7@XAP-PVEXMBX02.xlnx.xilinx.com> Content-Type: multipart/mixed; boundary="_002_37378DC5BCD0EE48BA4B082E0B55DFAA41F41AB7XAPPVEXMBX02xln_" MIME-Version: 1.0 X-RCIS-Action: ALLOW X-EOPAttributedMessage: 0 X-Microsoft-Exchange-Diagnostics: 1;BN1AFFO11FD034;1:P23lKP4ms7aL+mnHsSjjSF5Eto9KZdPGehxcks/wxFpFlUOwrTbzbmAteuc2HogqgZyaELmvMUPKmjlmNh8uuCs6hwg8MTJf7n/J1zxEBCxqHrmzhHRLaU8gUvTFMomKLNkw49VO3fJBjlcuLCRQzre+FT1107BwXoXdx+SxfoGVk505XIXsfHaCF/P46ssCaQ9WoNrRkzi8h3SxrFJ1CD7+HtM/meKVun8pjmyHEqq6TQgRsTCkT6HpY6FXmdWnaIPSiaq3r46OOg1FyMo+NQ== X-Forefront-Antispam-Report: CIP:149.199.60.100;CTRY:US;IPV:NLI;EFV:NLI;SFV:NSPM;SFS:(10009020)(6009001)(2980300002)(438002)(189002)(199003)(377424004)(54534003)(54356999)(55846006)(84326002)(87936001)(86362001)(2656002)(19580405001)(63266004)(46102003)(92566002)(99936001)(50986999)(4610100001)(512954002)(106466001)(110136002)(5001960100002)(107886002)(568964001)(189998001)(5890100001)(5001920100001)(229853001)(5003600100002)(62966003)(102836002)(77156002)(33656002)(19580395003)(450100001)(5260100001)(6806004)(2930100002)(5250100002)(2900100001)(107986001)(142933001)(4001430100001);DIR:OUT;SFP:1101;SCL:1;SRVR:BN1AFFO11HUB037;H:xsj-pvapsmtpgw02;FPR:;SPF:Pass;MLV:sfv;MX:1;A:1;LANG:en; X-Microsoft-Exchange-Diagnostics: 1;BN1AFFO11HUB037;2:7DRqekVrcDuLBYaprNWtdwzpZcX0TORzSRLGkroIOw8+33LVwPF2kpljyf/ukXK2;3:c4w7F+fxK1+/OIqH4rE5E0HT0QCPrqKKtY4f8uDIEbpPmXYfxYyghux/hPQVAIl4pEOnXoQEy+NbkD+fyjcuokVPtn7nQyN+d2bV8i/yXCw9zSLXNoeF6EDP7/em5R+aPzJc9KcT+ny5QGl+9VuWZ/yxHgDsfedN86jFq2Wm6g54ZQfkoRX6DBuUAc5bmUFELjsj14X7JcmvqV4W4wsuY/lmEuGEOOBYZhaGwTp7zY4rXekiBBfdZeX3sUnOU6k6;20:eQM9gb24B8f+a/Mb3PpCx5mLE3fr4uPNInoLnmiCEawcpMmR5RHn9dlsKvaUagIChGJcV4tEy1g2HCPzkbnBy8evG40EZN6gQTxqdQvSqu0nOxYiYhAXTRHWUjAAd78gNjxK/GXgLjVd5Mn6IuUsyJOnMmoQwPqfUSXC5LLbuvi3UX5cy7KrbdfYcxCB/ZSKLdWZj2yQL9lkY0loZNnX7IZl6uWl/Wip9x3tnlPQ7Kk8fe7YQoa8nxrzw8G+DF82Kis3YQ6Y3OfZRW1bJem8XCCfXkXrCZ6aEta5giqjYkj+Lmp4TeMWZJIjlLxYTQCOSSa8Ei1vhz+i5dbvZuFAKIdh2Ery72HHbUEGIqROhBlS8xgWzj44hYSJ/W/weAHzGDwPREF8e8Z7ACFkNzD2qtXtExhqm1uE+8pjMUXu/nkoI849SZIs76KsU4jLbg+B9Wmyscjl58EJY38CjFtLIoqxU8CY5gp98OluKRQmjS4gMnkHHZ4U2Oy9b9nGXyZ4 X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:;SRVR:BN1AFFO11HUB037; X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0;PCL:0;RULEID:(601004)(5005006)(3002001);SRVR:BN1AFFO11HUB037;BCL:0;PCL:0;RULEID:;SRVR:BN1AFFO11HUB037; X-Microsoft-Exchange-Diagnostics: 1;BN1AFFO11HUB037;4:qikNPJgN7CTFQcnAIFjSz+k9DI5sMy9RvbRfrV8QU8FxLVdQ6WZPlNK1ceor10T0t1BrDo8WLWaHUylFOjMtXG8egATHNqrhudgAoclYITFRrziqnvjiTRpyu0NGjzeKjlbUcutRxsHzqr6g/oamnfJ+8/mvfRiskfHWqv/7fw8wd+/OR3z79FwNpLjt0aB5neYV7fGbknB4DQHi8AR2yvLFWsNIkN2qI3w+XsPCAmDDFNZK68zUIz4GeQYrrsIo4bVgzfL2Dlpux3rMeX5uXru5d27XbW4ztBIPrA8/zDw= X-Forefront-PRVS: 06290ECA9D X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1;BN1AFFO11HUB037;23:iHmD1TmHAICxGpcgISobUsNK9+V2j9nl8ADGtvo?= =?us-ascii?Q?OIEwttBM8qFgpK7XPOkxudIImMN5aHti7cUdi0isTIexad935aCRzWSdwk8D?= =?us-ascii?Q?QBExnIrftiGZIAHWJO8T4Dc3yPqrOpqfxVSRNZVEdw9kPZeNfpVn46U4O/Mo?= =?us-ascii?Q?V8PQxLohP0xoXpJe3PrgkkSpWMGXIkUNp01YRLLQ2h+LmvmVgu7utEgrklYJ?= =?us-ascii?Q?snRFyJf/7/UTaNBIYlXFqTy/BPnPd/pGOsd82HgMnJqpSEQ4t0gKvAwHYyKx?= =?us-ascii?Q?Fz8y/rmJvnGV9xE2dJ8ztSeGt9Oj7tlTH5Wiqi6+2FYrx0bP7M+G84Zr6PjN?= =?us-ascii?Q?0fRrzw1BKeGMLVHLpEJ/BcVAmXqafS2n4aqEaMwaz4AlOiLsNvxlpnYlknkz?= =?us-ascii?Q?pPwUtsvHSvEEh+BeexHrLaDEe3TqADm448/xojNOkgdydSe9epzav5ZkodEI?= =?us-ascii?Q?0rLbU2+cvAm73Ya9op/0yS0gMlbLOgXnALvy/4LaIQn+UK/KVTji7RvMOWHH?= =?us-ascii?Q?o6YCSqj1YTwKambH61iDLVPa9taAFu5DRW9GA6xTbpTs4+bsb91tkjlg0iPQ?= =?us-ascii?Q?Y85yoBQw9cMorNyNMogMlkPOuKrr9NG87iAkOjAiiMQo6ykOJrlleqOu5D2t?= =?us-ascii?Q?Xt1bQik1szhtLz4saVNgycZmpcqNnZd3tiVkm4EBHxv9htqQdr9EXADeeSM9?= =?us-ascii?Q?tqQg+YG9rpCJWrHH3bf8urFize/cxKyZVo+cBm2iXFHKKBanIXBNw1LXUK83?= =?us-ascii?Q?w+qOW1nwkeNRdGYEIluxvK24Bhjtopy15s6b5dwubZDmF8Jus4w7AdisLM+e?= =?us-ascii?Q?GCXu2b5DGOJqwWRUWuKcZ2fDR/p+buLMxBNASEfaMOWuH4+Uakx57kwpfOyF?= =?us-ascii?Q?Z+0UHidR8M0LME0WbO4uuq2eXt9wd54sKppTb03o7ExWDj+EwPEIo3IDBiyz?= =?us-ascii?Q?SAB95riJD4Fz3zJdBlUbIP4OSc2VUZgBLDIai4QxRGcYWs91S7HebYMqmgWP?= =?us-ascii?Q?MhLFpmP3pPMkYBzoIlaIH3ZfvogIOBHqQeuZPiqHBghQFixxIeVfks2h5aEI?= =?us-ascii?Q?0lhsK67zasH57dY3y8UQg+276/9UnsLb3MNCT9ZhNLWXXn27rH2NCPJqIuqC?= =?us-ascii?Q?TwxGkNkK71D0Il8pkDmzaPEYlyZIdoM/UtPRnyd9R5QqeXB8gl/DJkudl4/A?= =?us-ascii?Q?Jp6XPG09UIOncE/8ZxrsI7vMjQ0yZdomGa5QG?= X-Microsoft-Exchange-Diagnostics: 1;BN1AFFO11HUB037;5:0TeyfceQ6r2eoLCAlmep1Alfx1tSPU1/n3vpm2nHRbl6QYTk9+/JFkfpqsxYKHvMDzz6lVENzFQZ3HEH61CP4Y+RdtKOXoF/6ipC4LCfu0MfBawhOKUZdK8SUL379Xiu+0FPbsovd1euWyAmwz53gQ==;24:dOh4L1i1/EhYqzVhF297XMnAJ+1wdG8fvsG1p8C2vffo1+YiKeP3LEb3q1hJa02MP+emYYLVcwP0WcMty+gVQZiJeOOxQO0qGwLsUv+fb88= X-OriginatorOrg: xilinx.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 06 Jul 2015 13:05:23.1948 (UTC) X-MS-Exchange-CrossTenant-Id: 657af505-d5df-48d0-8300-c31994686c5c X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=657af505-d5df-48d0-8300-c31994686c5c;Ip=[149.199.60.100];Helo=[xsj-pvapsmtpgw02] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BN1AFFO11HUB037 X-SW-Source: 2015-07/txt/msg00331.txt.bz2 --_002_37378DC5BCD0EE48BA4B082E0B55DFAA41F41AB7XAPPVEXMBX02xln_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Content-length: 7469 All: The below patch optimized the usage of the reserved stack space for functio= n arguments. The stack space is reserved if=20 the function is a libcall, variable number of arguments, aggregate data typ= es, and some parameter are reserved in registers=20 and some parameters is reserved in the stack. Along with the above conditio= ns the stack space is not reserved if no arguments=20 are passed. No regressions is seen in Deja GNU tests for microblaze. [Patch,microblaze]: Optimized usage of reserved stack space for functio= n arguments. =20=20=20=20 The changes are made in the patch for optimized usage of reserved stack space for arguments. The stack space is reserved if the function is a libcall, variable number of arguments, aggregate data types, and some parameter are reserved in registers and some parameters is reserved in the stack. Along with the above conditions the stack space is not reserved if no arguments are passed. =20=20=20=20 ChangeLog: 2015-07-06 Ajit Agarwal =20=20=20=20 * config/microblaze/microblaze.c (microblaze_parm_needs_stack): New. (microblaze_function_parms_need_stack): New. (microblaze_reg_parm_stack_space): New. * config/microblaze/microblaze.h (REG_PARM_STACK_SPACE): Modify the macro. * config/microblaze/microblaze-protos.h (microblaze_reg_parm_stack_space): Declare. =20=20=20=20 Signed-off-by:Ajit Agarwal ajitkum@xilinx.com --- gcc/config/microblaze/microblaze-protos.h | 1 + gcc/config/microblaze/microblaze.c | 140 +++++++++++++++++++++++++= ++++ gcc/config/microblaze/microblaze.h | 2 +- 3 files changed, 142 insertions(+), 1 deletions(-) diff --git a/gcc/config/microblaze/microblaze-protos.h b/gcc/config/microbl= aze/microblaze-protos.h index 57879b1..d27d3e1 100644 --- a/gcc/config/microblaze/microblaze-protos.h +++ b/gcc/config/microblaze/microblaze-protos.h @@ -56,6 +56,7 @@ extern bool microblaze_tls_referenced_p (rtx); extern int symbol_mentioned_p (rtx); extern int label_mentioned_p (rtx); extern bool microblaze_cannot_force_const_mem (machine_mode, rtx); +extern int microblaze_reg_parm_stack_space(tree fun); #endif /* RTX_CODE */ =20 /* Declare functions in microblaze-c.c. */ diff --git a/gcc/config/microblaze/microblaze.c b/gcc/config/microblaze/mic= roblaze.c index 566b78c..0eae4cd 100644 --- a/gcc/config/microblaze/microblaze.c +++ b/gcc/config/microblaze/microblaze.c @@ -3592,7 +3592,147 @@ microblaze_legitimate_constant_p (machine_mode mode= ATTRIBUTE_UNUSED, rtx x) =20 return true; } +/* Heuristics and criteria for having param needs stack. */ =20 +static bool +microblaze_parm_needs_stack (cumulative_args_t args_so_far, tree type) +{ + enum machine_mode mode; + int unsignedp; + rtx entry_parm; + + /* Catch errors. */ + if (type =3D=3D NULL || type =3D=3D error_mark_node) + return true; + + /* Handle types with no storage requirement. */ + if (TYPE_MODE (type) =3D=3D VOIDmode) + return false; + + /* Handle complex types. */ + if (TREE_CODE (type) =3D=3D COMPLEX_TYPE) + return (microblaze_parm_needs_stack (args_so_far, TREE_TYPE (type)) + || microblaze_parm_needs_stack (args_so_far, TREE_TYPE (type)= )); + + /* Handle transparent aggregates. */ + if ((TREE_CODE (type) =3D=3D UNION_TYPE || TREE_CODE (type) =3D=3D RECOR= D_TYPE) + && TYPE_TRANSPARENT_AGGR (type)) + type =3D TREE_TYPE (first_field (type)); + + /* See if this arg was passed by invisible reference. */ + if (pass_by_reference (get_cumulative_args (args_so_far), + TYPE_MODE (type), type, true)) + type =3D build_pointer_type (type); + + /* Find mode as it is passed by the ABI. */ + unsignedp =3D TYPE_UNSIGNED (type); + mode =3D promote_mode (type, TYPE_MODE (type), &unsignedp); + + /* If there is no incoming register, we need a stack. */ + entry_parm =3D microblaze_function_arg (args_so_far, mode, type, true); + + if (entry_parm =3D=3D NULL) + return true; + + /* Likewise if we need to pass both in registers and on the stack. */ + if (GET_CODE (entry_parm) =3D=3D PARALLEL + && XEXP (XVECEXP (entry_parm, 0, 0), 0) =3D=3D NULL_RTX) + return true; + + /* Also true if we're partially in registers and partially not. */ + if (function_arg_partial_bytes (args_so_far, mode, type, true) !=3D 0) + return true; + + /* Update info on where next arg arrives in registers. */ + microblaze_function_arg_advance (args_so_far, mode, type, true); + + return false; +} + +/* Function need stack for param if + 1. The function is a libcall. + 2. Variable number of arguments. + 3. If the param is aggregate data types. + 4. If partially some param in registers and some in the stack. */ + +static bool +microblaze_function_parms_need_stack (tree fun, bool incoming) +{ + tree fntype, result; + CUMULATIVE_ARGS args_so_far_v; + cumulative_args_t args_so_far; + int num_of_args =3D 0; + + /* Must be a libcall, all of which only use reg parms. */ + if (!fun) + return true; + + fntype =3D fun; + if (!TYPE_P (fun)) + fntype =3D TREE_TYPE (fun); + + /* Varargs functions need the parameter save area. */ + if ((!incoming && !prototype_p (fntype)) || stdarg_p (fntype)) + return true; + + INIT_CUMULATIVE_ARGS(args_so_far_v, fntype, NULL_RTX,0,0); + args_so_far =3D pack_cumulative_args (&args_so_far_v); + + if (incoming) + { + gcc_assert (DECL_P (fun)); + result =3D DECL_RESULT (fun); + } + else + result =3D TREE_TYPE (fntype); + + if (result && aggregate_value_p (result, fntype)) + { + if (!TYPE_P (result)) + result =3D build_pointer_type (result); + microblaze_parm_needs_stack (args_so_far, result); + } + + if (incoming) + { + tree parm; + for (parm =3D DECL_ARGUMENTS (fun); + parm && parm !=3D void_list_node; + parm =3D TREE_CHAIN (parm)) + if (microblaze_parm_needs_stack (args_so_far, TREE_TYPE (parm))) + return true; + } + else + { + function_args_iterator args_iter; + tree arg_type; + + FOREACH_FUNCTION_ARGS (fntype, arg_type, args_iter) + { + num_of_args++; + if (microblaze_parm_needs_stack (args_so_far, arg_type)) + return true; + } + } + + if (num_of_args > 1) + return true; + + return false; +} + +/* This function defines REG_PARM_STACK_SPACE macro.If + the Param needs stack returns the number of words to + be reserved. Otherwise return 0. */ + +int +microblaze_reg_parm_stack_space(tree fun) +{ + if (microblaze_function_parms_need_stack (fun, false)) + return MAX_ARGS_IN_REGISTERS * UNITS_PER_WORD; + else + return 0; +} =20 #undef TARGET_ENCODE_SECTION_INFO #define TARGET_ENCODE_SECTION_INFO microblaze_encode_section_info diff --git a/gcc/config/microblaze/microblaze.h b/gcc/config/microblaze/mic= roblaze.h index faeb780..69fbd89 100644 --- a/gcc/config/microblaze/microblaze.h +++ b/gcc/config/microblaze/microblaze.h @@ -451,7 +451,7 @@ extern struct microblaze_frame_info current_frame_info; =20 #define ARG_POINTER_CFA_OFFSET(FNDECL) 0 =20 -#define REG_PARM_STACK_SPACE(FNDECL) (MAX_ARGS_IN_REGISTERS * UNITS_PER= _WORD) +#define REG_PARM_STACK_SPACE(FNDECL) microblaze_reg_parm_stack_space (F= NDECL) =20 #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1 =20 --=20 1.7.1 --_002_37378DC5BCD0EE48BA4B082E0B55DFAA41F41AB7XAPPVEXMBX02xln_ Content-Type: application/octet-stream; name="0001-Patch-microblaze-Optimized-usage-of-reserved-stack-s.patch" Content-Description: 0001-Patch-microblaze-Optimized-usage-of-reserved-stack-s.patch Content-Disposition: attachment; filename="0001-Patch-microblaze-Optimized-usage-of-reserved-stack-s.patch"; size=6932; creation-date="Mon, 06 Jul 2015 12:54:45 GMT"; modification-date="Mon, 06 Jul 2015 12:50:22 GMT" Content-Transfer-Encoding: base64 Content-length: 9399 RnJvbSAzZTQyMTE2ZWIyOTQxZTBkYjI5NjRlZGI3N2Y1MWQ3NjJmMTU3M2Rl IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBaml0IEt1bWFyIEFn YXJ3YWwgPGFqaXRrdW1AeGhkc3BkZ251Lihub25lKT4KRGF0ZTogTW9uLCA2 IEp1bCAyMDE1IDE4OjE1OjAyICswNTMwClN1YmplY3Q6IFtQQVRDSF0gW1Bh dGNoLG1pY3JvYmxhemVdOiBPcHRpbWl6ZWQgdXNhZ2Ugb2YgcmVzZXJ2ZWQg c3RhY2sgc3BhY2UgZm9yIGZ1bmN0aW9uIGFyZ3VtZW50cy4KClRoZSBjaGFu Z2VzIGFyZSBtYWRlIGluIHRoZSBwYXRjaCBmb3Igb3B0aW1pemVkIHVzYWdl IG9mCnJlc2VydmVkIHN0YWNrIHNwYWNlIGZvciBhcmd1bWVudHMuIFRoZSBz dGFjayBzcGFjZSBpcwpyZXNlcnZlZCBpZiB0aGUgZnVuY3Rpb24gaXMgYSBs aWJjYWxsLCB2YXJpYWJsZSBudW1iZXIgb2YKYXJndW1lbnRzLCBhZ2dyZWdh dGUgZGF0YSB0eXBlcywgYW5kIHNvbWUgcGFyYW1ldGVyIGFyZQpyZXNlcnZl ZCBpbiByZWdpc3RlcnMgYW5kIHNvbWUgcGFyYW1ldGVycyBpcyByZXNlcnZl ZCBpbiB0aGUKc3RhY2suIEFsb25nIHdpdGggdGhlIGFib3ZlIGNvbmRpdGlv bnMgdGhlIHN0YWNrIHNwYWNlIGlzIG5vdApyZXNlcnZlZCBpZiBubyBhcmd1 bWVudHMgYXJlIHBhc3NlZC4KCkNoYW5nZUxvZzoKMjAxNS0wNy0wNiAgQWpp dCBBZ2Fyd2FsICA8YWppdGt1bUB4aWxpbnguY29tPgoKCSogY29uZmlnL21p Y3JvYmxhemUvbWljcm9ibGF6ZS5jCgkobWljcm9ibGF6ZV9wYXJtX25lZWRz X3N0YWNrKTogTmV3LgoJKG1pY3JvYmxhemVfZnVuY3Rpb25fcGFybXNfbmVl ZF9zdGFjayk6IE5ldy4KCShtaWNyb2JsYXplX3JlZ19wYXJtX3N0YWNrX3Nw YWNlKTogTmV3LgoJKiBjb25maWcvbWljcm9ibGF6ZS9taWNyb2JsYXplLmgK CShSRUdfUEFSTV9TVEFDS19TUEFDRSk6IE1vZGlmeSB0aGUgbWFjcm8uCgkq IGNvbmZpZy9taWNyb2JsYXplL21pY3JvYmxhemUtcHJvdG9zLmgKCShtaWNy b2JsYXplX3JlZ19wYXJtX3N0YWNrX3NwYWNlKTogRGVjbGFyZS4KClNpZ25l ZC1vZmYtYnk6QWppdCBBZ2Fyd2FsIGFqaXRrdW1AeGlsaW54LmNvbQotLS0K IGdjYy9jb25maWcvbWljcm9ibGF6ZS9taWNyb2JsYXplLXByb3Rvcy5oIHwg ICAgMSArCiBnY2MvY29uZmlnL21pY3JvYmxhemUvbWljcm9ibGF6ZS5jICAg ICAgICB8ICAxNDAgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGdj Yy9jb25maWcvbWljcm9ibGF6ZS9taWNyb2JsYXplLmggICAgICAgIHwgICAg MiArLQogMyBmaWxlcyBjaGFuZ2VkLCAxNDIgaW5zZXJ0aW9ucygrKSwgMSBk ZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9nY2MvY29uZmlnL21pY3JvYmxh emUvbWljcm9ibGF6ZS1wcm90b3MuaCBiL2djYy9jb25maWcvbWljcm9ibGF6 ZS9taWNyb2JsYXplLXByb3Rvcy5oCmluZGV4IDU3ODc5YjEuLmQyN2QzZTEg MTAwNjQ0Ci0tLSBhL2djYy9jb25maWcvbWljcm9ibGF6ZS9taWNyb2JsYXpl LXByb3Rvcy5oCisrKyBiL2djYy9jb25maWcvbWljcm9ibGF6ZS9taWNyb2Js YXplLXByb3Rvcy5oCkBAIC01Niw2ICs1Niw3IEBAIGV4dGVybiBib29sIG1p Y3JvYmxhemVfdGxzX3JlZmVyZW5jZWRfcCAocnR4KTsKIGV4dGVybiBpbnQg c3ltYm9sX21lbnRpb25lZF9wIChydHgpOwogZXh0ZXJuIGludCBsYWJlbF9t ZW50aW9uZWRfcCAocnR4KTsKIGV4dGVybiBib29sIG1pY3JvYmxhemVfY2Fu bm90X2ZvcmNlX2NvbnN0X21lbSAobWFjaGluZV9tb2RlLCBydHgpOworZXh0 ZXJuIGludCAgbWljcm9ibGF6ZV9yZWdfcGFybV9zdGFja19zcGFjZSh0cmVl IGZ1bik7CiAjZW5kaWYgIC8qIFJUWF9DT0RFICovCiAKIC8qIERlY2xhcmUg ZnVuY3Rpb25zIGluIG1pY3JvYmxhemUtYy5jLiAgKi8KZGlmZiAtLWdpdCBh L2djYy9jb25maWcvbWljcm9ibGF6ZS9taWNyb2JsYXplLmMgYi9nY2MvY29u ZmlnL21pY3JvYmxhemUvbWljcm9ibGF6ZS5jCmluZGV4IDU2NmI3OGMuLjBl YWU0Y2QgMTAwNjQ0Ci0tLSBhL2djYy9jb25maWcvbWljcm9ibGF6ZS9taWNy b2JsYXplLmMKKysrIGIvZ2NjL2NvbmZpZy9taWNyb2JsYXplL21pY3JvYmxh emUuYwpAQCAtMzU5Miw3ICszNTkyLDE0NyBAQCBtaWNyb2JsYXplX2xlZ2l0 aW1hdGVfY29uc3RhbnRfcCAobWFjaGluZV9tb2RlIG1vZGUgQVRUUklCVVRF X1VOVVNFRCwgcnR4IHgpCiAKICAgcmV0dXJuIHRydWU7CiB9CisvKiBIZXVy aXN0aWNzIGFuZCBjcml0ZXJpYSBmb3IgaGF2aW5nIHBhcmFtIG5lZWRzIHN0 YWNrLiAgKi8KIAorc3RhdGljIGJvb2wKK21pY3JvYmxhemVfcGFybV9uZWVk c19zdGFjayAoY3VtdWxhdGl2ZV9hcmdzX3QgYXJnc19zb19mYXIsIHRyZWUg dHlwZSkKK3sKKyAgZW51bSBtYWNoaW5lX21vZGUgbW9kZTsKKyAgaW50IHVu c2lnbmVkcDsKKyAgcnR4IGVudHJ5X3Bhcm07CisKKyAgLyogQ2F0Y2ggZXJy b3JzLiAgKi8KKyAgaWYgKHR5cGUgPT0gTlVMTCB8fCB0eXBlID09IGVycm9y X21hcmtfbm9kZSkKKyAgICByZXR1cm4gdHJ1ZTsKKworICAvKiBIYW5kbGUg dHlwZXMgd2l0aCBubyBzdG9yYWdlIHJlcXVpcmVtZW50LiAgKi8KKyAgaWYg KFRZUEVfTU9ERSAodHlwZSkgPT0gVk9JRG1vZGUpCisgICAgcmV0dXJuIGZh bHNlOworCisgICAvKiBIYW5kbGUgY29tcGxleCB0eXBlcy4gICovCisgIGlm IChUUkVFX0NPREUgKHR5cGUpID09IENPTVBMRVhfVFlQRSkKKyAgICByZXR1 cm4gKG1pY3JvYmxhemVfcGFybV9uZWVkc19zdGFjayAoYXJnc19zb19mYXIs IFRSRUVfVFlQRSAodHlwZSkpCisgICAgICAgICAgICAgfHwgbWljcm9ibGF6 ZV9wYXJtX25lZWRzX3N0YWNrIChhcmdzX3NvX2ZhciwgVFJFRV9UWVBFICh0 eXBlKSkpOworCisgIC8qIEhhbmRsZSB0cmFuc3BhcmVudCBhZ2dyZWdhdGVz LiAgKi8KKyAgaWYgKChUUkVFX0NPREUgKHR5cGUpID09IFVOSU9OX1RZUEUg fHwgVFJFRV9DT0RFICh0eXBlKSA9PSBSRUNPUkRfVFlQRSkKKyAgICAgICYm IFRZUEVfVFJBTlNQQVJFTlRfQUdHUiAodHlwZSkpCisgICAgdHlwZSA9IFRS RUVfVFlQRSAoZmlyc3RfZmllbGQgKHR5cGUpKTsKKworICAvKiBTZWUgaWYg dGhpcyBhcmcgd2FzIHBhc3NlZCBieSBpbnZpc2libGUgcmVmZXJlbmNlLiAg Ki8KKyAgaWYgKHBhc3NfYnlfcmVmZXJlbmNlIChnZXRfY3VtdWxhdGl2ZV9h cmdzIChhcmdzX3NvX2ZhciksCisgICAgICAgICAgICAgICAgICAgICAgICAg VFlQRV9NT0RFICh0eXBlKSwgdHlwZSwgdHJ1ZSkpCisgICAgdHlwZSA9IGJ1 aWxkX3BvaW50ZXJfdHlwZSAodHlwZSk7CisKKyAgLyogRmluZCBtb2RlIGFz IGl0IGlzIHBhc3NlZCBieSB0aGUgQUJJLiAgKi8KKyAgdW5zaWduZWRwID0g VFlQRV9VTlNJR05FRCAodHlwZSk7CisgIG1vZGUgPSBwcm9tb3RlX21vZGUg KHR5cGUsIFRZUEVfTU9ERSAodHlwZSksICZ1bnNpZ25lZHApOworCisgIC8q IElmIHRoZXJlIGlzIG5vIGluY29taW5nIHJlZ2lzdGVyLCB3ZSBuZWVkIGEg c3RhY2suICAqLworICBlbnRyeV9wYXJtID0gbWljcm9ibGF6ZV9mdW5jdGlv bl9hcmcgKGFyZ3Nfc29fZmFyLCBtb2RlLCB0eXBlLCB0cnVlKTsKKworICBp ZiAoZW50cnlfcGFybSA9PSBOVUxMKQorICAgIHJldHVybiB0cnVlOworCisg IC8qIExpa2V3aXNlIGlmIHdlIG5lZWQgdG8gcGFzcyBib3RoIGluIHJlZ2lz dGVycyBhbmQgb24gdGhlIHN0YWNrLiAgKi8KKyAgaWYgKEdFVF9DT0RFIChl bnRyeV9wYXJtKSA9PSBQQVJBTExFTAorICAgICAgJiYgWEVYUCAoWFZFQ0VY UCAoZW50cnlfcGFybSwgMCwgMCksIDApID09IE5VTExfUlRYKQorICAgIHJl dHVybiB0cnVlOworCisgIC8qIEFsc28gdHJ1ZSBpZiB3ZSdyZSBwYXJ0aWFs bHkgaW4gcmVnaXN0ZXJzIGFuZCBwYXJ0aWFsbHkgbm90LiAgKi8KKyAgaWYg KGZ1bmN0aW9uX2FyZ19wYXJ0aWFsX2J5dGVzIChhcmdzX3NvX2ZhciwgbW9k ZSwgdHlwZSwgdHJ1ZSkgIT0gMCkKKyAgICByZXR1cm4gdHJ1ZTsKKworICAv KiBVcGRhdGUgaW5mbyBvbiB3aGVyZSBuZXh0IGFyZyBhcnJpdmVzIGluIHJl Z2lzdGVycy4gICovCisgIG1pY3JvYmxhemVfZnVuY3Rpb25fYXJnX2FkdmFu Y2UgKGFyZ3Nfc29fZmFyLCBtb2RlLCB0eXBlLCB0cnVlKTsKKworICByZXR1 cm4gZmFsc2U7Cit9CisKKy8qIEZ1bmN0aW9uIG5lZWQgc3RhY2sgZm9yIHBh cmFtIGlmCisgICAxLiBUaGUgZnVuY3Rpb24gaXMgYSBsaWJjYWxsLgorICAg Mi4gVmFyaWFibGUgbnVtYmVyIG9mIGFyZ3VtZW50cy4KKyAgIDMuIElmIHRo ZSBwYXJhbSBpcyBhZ2dyZWdhdGUgZGF0YSB0eXBlcy4KKyAgIDQuIElmIHBh cnRpYWxseSBzb21lIHBhcmFtIGluIHJlZ2lzdGVycyBhbmQgc29tZSBpbiB0 aGUgc3RhY2suICAqLworCitzdGF0aWMgYm9vbAorbWljcm9ibGF6ZV9mdW5j dGlvbl9wYXJtc19uZWVkX3N0YWNrICh0cmVlIGZ1biwgYm9vbCBpbmNvbWlu ZykKK3sKKyAgdHJlZSBmbnR5cGUsIHJlc3VsdDsKKyAgQ1VNVUxBVElWRV9B UkdTIGFyZ3Nfc29fZmFyX3Y7CisgIGN1bXVsYXRpdmVfYXJnc190IGFyZ3Nf c29fZmFyOworICBpbnQgbnVtX29mX2FyZ3MgPSAwOworCisgIC8qIE11c3Qg YmUgYSBsaWJjYWxsLCBhbGwgb2Ygd2hpY2ggb25seSB1c2UgcmVnIHBhcm1z LiAgKi8KKyAgaWYgKCFmdW4pCisgICAgcmV0dXJuIHRydWU7CisKKyAgZm50 eXBlID0gZnVuOworICBpZiAoIVRZUEVfUCAoZnVuKSkKKyAgICBmbnR5cGUg PSBUUkVFX1RZUEUgKGZ1bik7CisKKyAgLyogVmFyYXJncyBmdW5jdGlvbnMg bmVlZCB0aGUgcGFyYW1ldGVyIHNhdmUgYXJlYS4gICovCisgIGlmICgoIWlu Y29taW5nICYmICFwcm90b3R5cGVfcCAoZm50eXBlKSkgfHwgc3RkYXJnX3Ag KGZudHlwZSkpCisgICAgcmV0dXJuIHRydWU7CisKKyAgSU5JVF9DVU1VTEFU SVZFX0FSR1MoYXJnc19zb19mYXJfdiwgZm50eXBlLCBOVUxMX1JUWCwwLDAp OworICBhcmdzX3NvX2ZhciA9IHBhY2tfY3VtdWxhdGl2ZV9hcmdzICgmYXJn c19zb19mYXJfdik7CisKKyAgaWYgKGluY29taW5nKQorICAgIHsKKyAgICAg IGdjY19hc3NlcnQgKERFQ0xfUCAoZnVuKSk7CisgICAgICByZXN1bHQgPSBE RUNMX1JFU1VMVCAoZnVuKTsKKyAgICB9CisgIGVsc2UKKyAgICByZXN1bHQg PSBUUkVFX1RZUEUgKGZudHlwZSk7CisKKyAgaWYgKHJlc3VsdCAmJiBhZ2dy ZWdhdGVfdmFsdWVfcCAocmVzdWx0LCBmbnR5cGUpKQorICAgIHsKKyAgICAg IGlmICghVFlQRV9QIChyZXN1bHQpKQorICAgICAgICByZXN1bHQgPSBidWls ZF9wb2ludGVyX3R5cGUgKHJlc3VsdCk7CisgICAgICAgIG1pY3JvYmxhemVf cGFybV9uZWVkc19zdGFjayAoYXJnc19zb19mYXIsIHJlc3VsdCk7CisgICAg fQorCisgIGlmIChpbmNvbWluZykKKyAgICB7CisgICAgICB0cmVlIHBhcm07 CisgICAgICBmb3IgKHBhcm0gPSBERUNMX0FSR1VNRU5UUyAoZnVuKTsKKyAg ICAgICAgICAgcGFybSAmJiBwYXJtICE9IHZvaWRfbGlzdF9ub2RlOworICAg ICAgICAgICBwYXJtID0gVFJFRV9DSEFJTiAocGFybSkpCisgICAgICAgICBp ZiAobWljcm9ibGF6ZV9wYXJtX25lZWRzX3N0YWNrIChhcmdzX3NvX2Zhciwg VFJFRV9UWVBFIChwYXJtKSkpCisgICAgICAgICAgIHJldHVybiB0cnVlOwor ICAgIH0KKyAgZWxzZQorICAgIHsKKyAgICAgIGZ1bmN0aW9uX2FyZ3NfaXRl cmF0b3IgYXJnc19pdGVyOworICAgICAgdHJlZSBhcmdfdHlwZTsKKworICAg ICAgRk9SRUFDSF9GVU5DVElPTl9BUkdTIChmbnR5cGUsIGFyZ190eXBlLCBh cmdzX2l0ZXIpCisgICAgICB7CisgICAgICAgIG51bV9vZl9hcmdzKys7Cisg ICAgICAgIGlmIChtaWNyb2JsYXplX3Bhcm1fbmVlZHNfc3RhY2sgKGFyZ3Nf c29fZmFyLCBhcmdfdHlwZSkpCisgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAg ICAgIH0KKyAgICB9CisKKyAgaWYgKG51bV9vZl9hcmdzID4gMSkKKyAgICBy ZXR1cm4gdHJ1ZTsKKworICByZXR1cm4gZmFsc2U7Cit9CisKKy8qIFRoaXMg ZnVuY3Rpb24gZGVmaW5lcyBSRUdfUEFSTV9TVEFDS19TUEFDRSBtYWNyby5J ZgorICAgdGhlIFBhcmFtIG5lZWRzIHN0YWNrIHJldHVybnMgdGhlIG51bWJl ciBvZiB3b3JkcyB0bworICAgYmUgcmVzZXJ2ZWQuIE90aGVyd2lzZSByZXR1 cm4gMC4gICovCisKK2ludAorbWljcm9ibGF6ZV9yZWdfcGFybV9zdGFja19z cGFjZSh0cmVlIGZ1bikKK3sKKyAgaWYgKG1pY3JvYmxhemVfZnVuY3Rpb25f cGFybXNfbmVlZF9zdGFjayAoZnVuLCBmYWxzZSkpCisgICAgcmV0dXJuIE1B WF9BUkdTX0lOX1JFR0lTVEVSUyAqIFVOSVRTX1BFUl9XT1JEOworICBlbHNl CisgICAgcmV0dXJuIDA7Cit9CiAMCiAjdW5kZWYgVEFSR0VUX0VOQ09ERV9T RUNUSU9OX0lORk8KICNkZWZpbmUgVEFSR0VUX0VOQ09ERV9TRUNUSU9OX0lO Rk8gICAgICBtaWNyb2JsYXplX2VuY29kZV9zZWN0aW9uX2luZm8KZGlmZiAt LWdpdCBhL2djYy9jb25maWcvbWljcm9ibGF6ZS9taWNyb2JsYXplLmggYi9n Y2MvY29uZmlnL21pY3JvYmxhemUvbWljcm9ibGF6ZS5oCmluZGV4IGZhZWI3 ODAuLjY5ZmJkODkgMTAwNjQ0Ci0tLSBhL2djYy9jb25maWcvbWljcm9ibGF6 ZS9taWNyb2JsYXplLmgKKysrIGIvZ2NjL2NvbmZpZy9taWNyb2JsYXplL21p Y3JvYmxhemUuaApAQCAtNDUxLDcgKzQ1MSw3IEBAIGV4dGVybiBzdHJ1Y3Qg bWljcm9ibGF6ZV9mcmFtZV9pbmZvIGN1cnJlbnRfZnJhbWVfaW5mbzsKIAog I2RlZmluZSBBUkdfUE9JTlRFUl9DRkFfT0ZGU0VUKEZOREVDTCkJCTAKIAot I2RlZmluZSBSRUdfUEFSTV9TVEFDS19TUEFDRShGTkRFQ0wpICAJCShNQVhf QVJHU19JTl9SRUdJU1RFUlMgKiBVTklUU19QRVJfV09SRCkKKyNkZWZpbmUg UkVHX1BBUk1fU1RBQ0tfU1BBQ0UoRk5ERUNMKSAgCQltaWNyb2JsYXplX3Jl Z19wYXJtX3N0YWNrX3NwYWNlIChGTkRFQ0wpCiAKICNkZWZpbmUgT1VUR09J TkdfUkVHX1BBUk1fU1RBQ0tfU1BBQ0UoRk5UWVBFKQkxCiAKLS0gCjEuNy4x Cgo= --_002_37378DC5BCD0EE48BA4B082E0B55DFAA41F41AB7XAPPVEXMBX02xln_--