From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from NAM12-BN8-obe.outbound.protection.outlook.com (mail-bn8nam12on2089.outbound.protection.outlook.com [40.107.237.89]) by sourceware.org (Postfix) with ESMTPS id 9E7DF3858D28 for ; Mon, 18 Apr 2022 11:04:48 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 9E7DF3858D28 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=HXzsCxLNZSfShC4rsOhP8RTSsT1nu2t3TWrXKhCMjWpos2kK0w6cXldCnk6PypvlxdA8EqV8P8nU6zS73YCHqsAk0L3t6ZNL3wtgD5sEl8h2Y+WA+zHMXCmpMXYWfsk/2u6qWp2ugoOAE4cvHzby35+XQ6Qv2UG+/KRY2/JgYM04RsW5eCc+aMaOWea43/abl3duQ5PT3c23YD/TFSw67xEaqqA0p8vv4crlV7ndWVqRH28VjXSLMhk+GIL8H4WjOpi41xZ8jKSP0H6IZSR0s30AyAdG5r7kLxXV95TXYWCk9+cHGrkxMRXUWAMDU+45LVdxM/p1nBumkzBzFGtF8Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=7+jAvikCZOAFdmdQtB8LrIyd8XMttPfDtj0o2kHq5zM=; b=H0dvtAy+UVgLRUVLbYhV97t8wTN4Ot/a7sDudPLMAhNyGdgfCPK59EKGNRxW2ctqbBGNR+ATBxiScLPnOW8IE6fWJjjEkVxobbuQq3q6d73xTfZvG6TkE9G90Qm/et8qohkb/sD1aESPzBo5yjcJaennBGT6+Cs8lULlVbrv8atVE7p3iaagosTmK7DpNnjLghDCeHY9Rp8+pyJ6aI0cRsQ+rtdKfwYpR9HDJ+rMxTHMh1zTyoS1Z4QBVTNNUwRrcHdd33n4CcZyNN+ivKhnaXdoChFIwxIoNbEJCWIgTndwBQ5zj4jYKYAUS3At6jr3ki0GXfXB3h54WKgWqnWD6g== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=amd.com; dmarc=pass action=none header.from=amd.com; dkim=pass header.d=amd.com; arc=none Received: from DM4PR12MB5796.namprd12.prod.outlook.com (2603:10b6:8:63::16) by MW3PR12MB4473.namprd12.prod.outlook.com (2603:10b6:303:56::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5164.20; Mon, 18 Apr 2022 11:04:44 +0000 Received: from DM4PR12MB5796.namprd12.prod.outlook.com ([fe80::b05f:c760:5349:c2b2]) by DM4PR12MB5796.namprd12.prod.outlook.com ([fe80::b05f:c760:5349:c2b2%5]) with mapi id 15.20.5164.025; Mon, 18 Apr 2022 11:04:43 +0000 From: "Natarajan, Kavitha" To: Tom Tromey , "Natarajan, Kavitha via Gdb-patches" CC: Bruno Larsen , "George, Jini Susan" , "Parasuraman, Hariharan" Subject: RE: [PATCH] Debug support for global alias variable Thread-Topic: [PATCH] Debug support for global alias variable Thread-Index: Adgvx/KC9Ls2FcnvTJeRu5jcNWYisQPvqNcAAMR4mPAAN0esgAApFU6QAAWQfSADLKLJ2ACLGbgg Date: Mon, 18 Apr 2022 11:04:43 +0000 Message-ID: References: <66ca57f9-c3b8-4aeb-f07c-c3c254dfdea6@redhat.com> <87ilra1gcx.fsf@tromey.com> In-Reply-To: <87ilra1gcx.fsf@tromey.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: yes X-MS-TNEF-Correlator: msip_labels: MSIP_Label_88914ebd-7e6c-4e12-a031-a9906be2db14_ActionId=29db486e-0b69-4f33-8c66-790a820d7cac; MSIP_Label_88914ebd-7e6c-4e12-a031-a9906be2db14_ContentBits=0; MSIP_Label_88914ebd-7e6c-4e12-a031-a9906be2db14_Enabled=true; MSIP_Label_88914ebd-7e6c-4e12-a031-a9906be2db14_Method=Standard; MSIP_Label_88914ebd-7e6c-4e12-a031-a9906be2db14_Name=AMD Official Use Only-AIP 2.0; MSIP_Label_88914ebd-7e6c-4e12-a031-a9906be2db14_SetDate=2022-04-18T10:29:03Z; MSIP_Label_88914ebd-7e6c-4e12-a031-a9906be2db14_SiteId=3dd8961f-e488-4e60-8e11-a82d994e183d; x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: aa4f2942-5c69-41ad-f117-08da212b3e15 x-ms-traffictypediagnostic: MW3PR12MB4473:EE_ x-microsoft-antispam-prvs: x-ms-exchange-senderadcheck: 1 x-ms-exchange-antispam-relay: 0 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: DKfX4+zOm067gXdYEHJqTIXooXI+HJqw5hmI4+kDhZkGw7TqawpsY4isUVZ+G5HpP9aeqCPtpnJYq96G3MlL8fJXtsoXavPTicfOHvercbYpOTzDG2QMBqVhghSo1+q70qrntZqhb3aAecJLJXqHZhNNPEU8sCRHYOELLr0uE8OI+VLVaqBVzN1ggXE1bVGu0c4SYK7fFgG9g/VeAFi+6VX4Hy+WLjmvq9a5Qkl18JGgDGQM1dgNH67kAWkt18yJ1o9TzoJ0gHnuQzVACneVMvwmgBmvonvu7dXrXv8gReNPie3nAAZiNdfcfU1f7T1+KUHhLZYAzIAc3ZF//1u9O6y8r6gJcFPl+FdeB945j6uKGiHB2RB1gGU3T89bHUl42Oqr7wzvo9Ydl9mj9FE3JxMH3chUUSIU6r0/XLefLacHl0ZMzs8jweZUWG3/LptTCoTnh/6x/fVT8/gCcATULnWAEa8NwCXNDoMRxsly3BXIecUdbu8h8BlCX09rq/PgCVcsgGRZkMdl36x5Omsazrf2yDGZWnj5aRvMg/jFVspPI0aBbHQ6RlFOWiClXYMk8vfWokFN771cn7/oG1/AIcb1NgY0kPjrWX3ndxywW2NpJBYCGE97xvSAXFlawj9aIGmy/fONWEHz2AvRpOb6a5mMox7Nh3h0ZAaawmewekzKU1ScioRZ1uSWSgZmGQPAwEkRx08HGTjfZcZzM8d8x3Qt51Q/ta2ITEBudbW6aVzTGlKdych4vz4dL2MXQkDKkCSQTBlzhEdxMghHP+Za4P7Tb85twTJBbBldFx6aIO4= x-forefront-antispam-report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:DM4PR12MB5796.namprd12.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230001)(4636009)(366004)(52536014)(8676002)(54906003)(110136005)(38100700002)(186003)(71200400001)(26005)(4326008)(66446008)(33656002)(66476007)(316002)(8936002)(76116006)(66946007)(66556008)(84970400001)(64756008)(55016003)(122000001)(508600001)(2906002)(99936003)(86362001)(5660300002)(6506007)(38070700005)(7696005)(83380400001)(9686003); DIR:OUT; SFP:1101; x-ms-exchange-antispam-messagedata-chunkcount: 1 x-ms-exchange-antispam-messagedata-0: =?us-ascii?Q?+9PGeQA7e4mQk3hXEIeFtn4uTNWOS8T43s4yW9bWq7n8AOi3VBaba0lM3pcY?= =?us-ascii?Q?v+A2taq3GvVEO7/qa/VnPD8nH6Gz/CsXdc0FcnfKb5TPfVivpo6QtSXaVV82?= =?us-ascii?Q?8aq2QrElRb/Eo6JuykueHBbiYT9Ywb4YiB3muCz3JhFkFOI0ls6jJoskM4MQ?= =?us-ascii?Q?G4U70nfP+t1by4iwd3aGlpHvLAyYI14+1r8l40cTix6PPZvFi6fs5ZaMPJbP?= =?us-ascii?Q?iyjsj83mSti2uqFGKSG/tzfFc4jlCYhsqFlpZjVwdKIjQPGTPvQ3yqCfSpTs?= =?us-ascii?Q?6No0bSiwnKv5ArINW/aixLI6Atl+mgwV9If1zRoWtQPxzyRABAveWcXUrmx8?= =?us-ascii?Q?mfiwXnVAbfuq2kc3qJBqJrpY919EZkXSrXUrZtNRw6qmzC3+UrX/0e/hgxvB?= =?us-ascii?Q?aUM55BvpmwaDeVjJBrv8otnNH+h5pIKi8iEJ86zW8pkJcaYie5DEO4cX7Jvb?= =?us-ascii?Q?5C/8rp2DGZ05nrDE/0LPwAe1iXVthruI8GumDpDM8zf9zT1s8XnInbP2uUGI?= =?us-ascii?Q?UmV26UCfexwBVjejfCiwkDyKrL+OL+zlg/8upNJonD4nHXpE6ItOZy1dgqFQ?= =?us-ascii?Q?mWfpEWROkKhouzbThzDZXeCAhXNTYt4ChQZIAUuJrzTVGgRxW1m6Eal1myL8?= =?us-ascii?Q?I+7RUxMXsoVMmchHjNdlYU+auIz74ULUnL0HC+toH/ytY0fK0/7CwOmsfA4N?= =?us-ascii?Q?8x2zutPNlUmSZnjLhymkO1r9cs9uItOgyIO66ybyKuPUlVnoYm9ZKO1eQmo/?= =?us-ascii?Q?r0VIg5VPc40wY6ef53hGw15mitJgZtWqhvqrIkwCi996feWPSoaXxT7H6QH0?= =?us-ascii?Q?EHlGw/ArGF4Jiks4HVed9AYY7GhXGsF0ZDJs0pDUjBtR/SuxGzqPrMUnYmWt?= =?us-ascii?Q?lXxwJeTiZmW7fkj5bFhAHsUH52xCaJzBHTP0rxJBp9ZaLVpv6CO8vHqiBDjv?= =?us-ascii?Q?oY2sixCy9B+7mXSf9w6FcZTl4Bib6SbetLxZSDN1A1Trg8QuORs1e/Ygg8TL?= =?us-ascii?Q?Zk0+Xc5eDzqfZUoZrYASaPTtBJzhdVdDzhMlM3FPh5nIsGVJ75e8Spx+60Z4?= =?us-ascii?Q?3Ec4ceFOQ+VSeW3Rex8JSMdHcSi19o4NdddVRF3amr2FXtSCK++re5ygLFbY?= =?us-ascii?Q?LDq7XcFb6gblRWG9katwVKD1HEvqbg+WN80a3QgrLG9pRrgUYNrplg/hm5fR?= =?us-ascii?Q?dWm8Sl9SOtUw4RdrHS8mohP5nCXiGgmGiAhDZiZ7OJYtyQzPwZ9XGU184TF6?= =?us-ascii?Q?1GAc6zKm3LN2ehGlKCL9xhkecyNM3W8kxJq2yNLVZTGY3DT0+XxhLoAu/OkE?= =?us-ascii?Q?iotndn/raMic8/BW6vG7LQdvj/dVC2gcR/zDQitgFGlaEMADAid1DzPz6R46?= =?us-ascii?Q?vdKSD4ZHt1ad126B/hJa+gVk85PyMldpNYniazrRzdNC5b+8iwd4irxlgr9I?= =?us-ascii?Q?677CkjlrrjQ2kbcBNFtFP3J/3cAEwudKAVZIUA1yEgfNicHZjYTsOweH+8pv?= =?us-ascii?Q?jhZktFd/mTSO7fS19h47WMSvYEz+qDBMGIHDX69gA8dAK8aYAvPxXDp2b9kg?= =?us-ascii?Q?Ws8eb5lQR6elUR8teym3Lx9XqqeFO6yGeLpfiP6xBg43Vo9Jur0Xek9JVMUW?= =?us-ascii?Q?GHyVGhJU0XaeWi6Igeyb8oLdW8IG1v6knafORLi9OIcLPZY+HbmegI4Kv/3K?= =?us-ascii?Q?FxhIvDXAn5TIocPPKeO7qfZzfLv8yUqMl7o4Ia8DAlucTROaiWUcDCy2iAx3?= =?us-ascii?Q?XoWSyUG35g=3D=3D?= Content-Type: multipart/mixed; boundary="_002_DM4PR12MB579651F1A1172BC69695CC93F7F39DM4PR12MB5796namp_" MIME-Version: 1.0 X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-AuthSource: DM4PR12MB5796.namprd12.prod.outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: aa4f2942-5c69-41ad-f117-08da212b3e15 X-MS-Exchange-CrossTenant-originalarrivaltime: 18 Apr 2022 11:04:43.4188 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: lMsbWnmrSHzgpBIY3ara0lS9bNycocGDVcpgzuM8GmvbPSNzMnK5wqRNyzwEH4UZgNKHStGc/JFjL6kbA3CuaA== X-MS-Exchange-Transport-CrossTenantHeadersStamped: MW3PR12MB4473 X-Spam-Status: No, score=-13.0 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, SPF_HELO_PASS, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Mon, 18 Apr 2022 11:04:52 -0000 --_002_DM4PR12MB579651F1A1172BC69695CC93F7F39DM4PR12MB5796namp_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable [AMD Official Use Only] Thank you Tom for reviewing my patch. I am sending the updated patch. > > + if (((cu->per_cu->lang =3D=3D language_c) > > + || (cu->per_cu->lang =3D=3D language_cplus)) > > This expression is over-parenthesized. > The inner parens can be removed. > > However, I don't understand why this would necessarily be specific to C o= r > C++. The old read_namespace_alias wasn't, so doesn't this check possibly > regress for some other language? There doesn't seem to be any impact on other languages as the new symbol is created only for TYPE_CODE_NAMESPACE in read_namespace_alias function. However, it could regress with my change. So I have moved this check specif= ic to my change so that this change is specific to C/C++ global alias variable= s. Thanks, Kavitha =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D When clang emits the dwarf information of global alias variable as DW_TAG_imported_declaration, gdb does not handle it. GDB reads this tag as C++/fortran imported declaration (type alias, namespace alias and fortran module). Added support to handle this tag as alias variable. This change fixes the failure in gdb.base/symbol-alias.exp testcase. This testcase is also updated to test nested (recursive) alias. --- gdb/dwarf2/read.c | 62 +++++++++++++++--------- gdb/testsuite/gdb.base/symbol-alias.exp | 63 ++++++++++++++++++++++++- gdb/testsuite/gdb.base/symbol-alias2.c | 16 +++++++ 3 files changed, 118 insertions(+), 23 deletions(-) diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c index 6dcd446e5f4..b0eed600312 100644 --- a/gdb/dwarf2/read.c +++ b/gdb/dwarf2/read.c @@ -957,6 +957,10 @@ static void build_type_psymtabs_reader (cutu_reader *r= eader, static void dwarf2_build_psymtabs_hard (dwarf2_per_objfile *per_objfile); +static void var_decode_location (struct attribute *attr, + struct symbol *sym, + struct dwarf2_cu *cu); + static unsigned int peek_abbrev_code (bfd *, const gdb_byte *); static const gdb_byte *read_attribute (const struct die_reader_specs *, @@ -1134,7 +1138,7 @@ static struct using_direct **using_directives (struct= dwarf2_cu *cu); static void read_import_statement (struct die_info *die, struct dwarf2_cu = *); -static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *c= u); +static bool read_alias (struct die_info *die, struct dwarf2_cu *cu); static struct type *read_module_type (struct die_info *die, struct dwarf2_cu *cu); @@ -8728,9 +8732,9 @@ process_die (struct die_info *die, struct dwarf2_cu *= cu) break; case DW_TAG_imported_declaration: cu->processing_has_namespace_info =3D true; - if (read_namespace_alias (die, cu)) + if (read_alias (die, cu)) break; - /* The declaration is not a global namespace alias. */ + /* The declaration is not a global namespace or variable alias. */ /* Fall through. */ case DW_TAG_imported_module: cu->processing_has_namespace_info =3D true; @@ -9198,18 +9202,19 @@ dwarf2_physname (const char *name, struct die_info = *die, struct dwarf2_cu *cu) return retval; } -/* Inspect DIE in CU for a namespace alias. If one exists, record - a new symbol for it. +/* Inspect DIE in CU for a namespace alias or a variable + with alias attribute. If one exists, record a new symbol + for it. - Returns 1 if a namespace alias was recorded, 0 otherwise. */ + Returns "true" if an alias was recorded, "false" otherwise. */ -static int -read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu) +static bool +read_alias (struct die_info *die, struct dwarf2_cu *cu) { struct attribute *attr; - /* If the die does not have a name, this is not a namespace - alias. */ + /* If the die does not have a name, this is not a namespace alias + or variable alias. */ attr =3D dwarf2_attr (die, DW_AT_name, cu); if (attr !=3D NULL) { @@ -9235,26 +9240,41 @@ read_namespace_alias (struct die_info *die, struct = dwarf2_cu *cu) { complaint (_("DIE at %s has too many recursively imported " "declarations"), sect_offset_str (d->sect_off)); - return 0; + return false; } if (attr !=3D NULL) { struct type *type; - sect_offset sect_off =3D attr->get_ref_die_offset (); - - type =3D get_die_type_at_offset (sect_off, cu->per_cu, cu->per_ob= jfile); - if (type !=3D NULL && type->code () =3D=3D TYPE_CODE_NAMESPACE) + if (((cu->per_cu->lang =3D=3D language_c) + || (cu->per_cu->lang =3D=3D language_cplus)) + && (d->tag =3D=3D DW_TAG_variable)) { - /* This declaration is a global namespace alias. Add - a symbol for it whose type is the aliased namespace. */ - new_symbol (die, type, cu); - return 1; + /* This declaration is a C/C++ global variable alias. Add + a symbol for it whose type is same as aliased variable. *= / + type =3D die_type (d, imported_cu); + struct symbol *sym =3D new_symbol (die, type, cu); + attr =3D dwarf2_attr (d, DW_AT_location, imported_cu); + sym->set_aclass_index (LOC_UNRESOLVED); + if (attr !=3D nullptr) + var_decode_location (attr, sym, cu); + return true; + } + else + { + sect_offset sect_off =3D attr->get_ref_die_offset (); + type =3D get_die_type_at_offset (sect_off, cu->per_cu, cu->pe= r_objfile); + if (type !=3D NULL && type->code () =3D=3D TYPE_CODE_NAMESPAC= E) + { + /* This declaration is a global namespace alias. Add + a symbol for it whose type is the aliased namespace. = */ + new_symbol (die, type, cu); + return true; + } } } } - - return 0; + return false; } /* Return the using directives repository (global or local?) to use in the diff --git a/gdb/testsuite/gdb.base/symbol-alias.exp b/gdb/testsuite/gdb.ba= se/symbol-alias.exp index 2b53cc31053..a9487b25f4d 100644 --- a/gdb/testsuite/gdb.base/symbol-alias.exp +++ b/gdb/testsuite/gdb.base/symbol-alias.exp @@ -15,6 +15,9 @@ # along with this program. If not, see . standard_testfile symbol-alias.c symbol-alias2.c +set using_clang [test_compiler_info clang-*] +set old_clang [expr [test_compiler_info {clang-1[0-3]-*-*}] \ + || [test_compiler_info {clang-[1-9]-*}]] if { [prepare_for_testing "failed to prepare" ${testfile} [list $srcfile $= srcfile2]] } { return -1 @@ -31,6 +34,62 @@ foreach f {"func" "func_alias"} { } # Variables. -foreach v {"g_var_s" "g_var_s_alias"} { - gdb_test "p $v" "=3D {field1 =3D 1, field2 =3D 2}" +gdb_test "p g_var_s" "=3D {field1 =3D 1, field2 =3D 2}" +foreach v {"g_var_s_alias" "g_var_s_alias2"} { + gdb_test_multiple "p $v" "p $v" { + -re " =3D {field1 =3D 1, field2 =3D 2}.*$gdb_prompt $" { + pass "print alias of variable $v" + } + -re ".*has unknown type; cast it to its declared type.*$gdb_prompt= $" { + if { $old_clang } { + xfail "print alias variable $v" + } else { + fail "print alias variable $v" + } + } + } +} + +# Static Variable. +gdb_test "p g_var" " =3D 1" +gdb_test_multiple "p g_var_alias" "p g_var_alias" { + -re " =3D 1.*$gdb_prompt $" { + pass "print alias of static variable" + } + -re ".*has unknown type; cast it to its declared type.*$gdb_prompt $"= { + if { $old_clang } { + xfail "print alias of static variable" + } else { + fail "print alias of static variable" + } + } +} + +# Deferred Variable. +gdb_test "p g_def_var" " =3D 2" +gdb_test_multiple "p g_def_var_alias" "p g_def_var_alias" { + -re " =3D 2.*$gdb_prompt $" { + pass "print alias of deferred variable" + } + -re ".*has unknown type; cast it to its declared type.*$gdb_prompt $"= { + if { $using_clang } { + xfail "print alias of deferred variable" + } else { + fail "print alias of deferred variable" + } + } +} + +# Alias of deferred Variable alias. +gdb_test_multiple "p g_def_var2_alias2" "p g_def_var2_alias2" { + -re " =3D 3.*$gdb_prompt $" { + pass "print alias of alias of deferred variable" + } + -re ".*has unknown type; cast it to its declared type.*$gdb_prompt $"= { + if { $old_clang } { + xfail "print alias of alias of deferred variable" + } else { + fail "print alias of alias of deferred variable" + } + } } diff --git a/gdb/testsuite/gdb.base/symbol-alias2.c b/gdb/testsuite/gdb.bas= e/symbol-alias2.c index 34f4e121e25..41d4b6a53e5 100644 --- a/gdb/testsuite/gdb.base/symbol-alias2.c +++ b/gdb/testsuite/gdb.base/symbol-alias2.c @@ -23,6 +23,8 @@ struct S struct S g_var_s =3D { 1, 2 }; +static int g_var =3D 1; + #ifdef __cplusplus /* So that the alias attribute below work without having to figure out this function's mangled name. */ @@ -38,3 +40,17 @@ func (void) struct S *func_alias (void) __attribute__ ((alias ("func"))); extern struct S g_var_s_alias __attribute__ ((alias ("g_var_s"))); + +extern struct S g_var_s_alias2 __attribute__ ((alias ("g_var_s_alias"))); + +extern int g_var_alias __attribute__ ((alias ("g_var"))); + +extern int g_def_var_alias __attribute__ ((alias ("g_def_var"))); + +int g_def_var =3D 2; + +extern int g_def_var2_alias __attribute__ ((alias ("g_def_var2"))); + +int g_def_var2 =3D 3; + +extern int g_def_var2_alias2 __attribute__ ((alias ("g_def_var2_alias"))); -- --_002_DM4PR12MB579651F1A1172BC69695CC93F7F39DM4PR12MB5796namp_ Content-Type: application/octet-stream; name="0005-Debug-support-for-C-global-alias-variable-tom-tromey.patch" Content-Description: 0005-Debug-support-for-C-global-alias-variable-tom-tromey.patch Content-Disposition: attachment; filename="0005-Debug-support-for-C-global-alias-variable-tom-tromey.patch"; size=8595; creation-date="Mon, 18 Apr 2022 11:02:00 GMT"; modification-date="Mon, 18 Apr 2022 11:04:42 GMT" Content-Transfer-Encoding: base64 V2hlbiBjbGFuZyBlbWl0cyB0aGUgZHdhcmYgaW5mb3JtYXRpb24gb2YgZ2xvYmFsIGFsaWFzIHZh cmlhYmxlDQphcyBEV19UQUdfaW1wb3J0ZWRfZGVjbGFyYXRpb24sIGdkYiBkb2VzIG5vdCBoYW5k bGUgaXQuIEdEQiByZWFkcw0KdGhpcyB0YWcgYXMgQysrL2ZvcnRyYW4gaW1wb3J0ZWQgZGVjbGFy YXRpb24gKHR5cGUgYWxpYXMsIG5hbWVzcGFjZQ0KYWxpYXMgYW5kIGZvcnRyYW4gbW9kdWxlKS4g QWRkZWQgc3VwcG9ydCB0byBoYW5kbGUgdGhpcyB0YWcgYXMNCmFsaWFzIHZhcmlhYmxlLg0KDQpU aGlzIGNoYW5nZSBmaXhlcyB0aGUgZmFpbHVyZSBpbiBnZGIuYmFzZS9zeW1ib2wtYWxpYXMuZXhw IHRlc3RjYXNlLg0KVGhpcyB0ZXN0Y2FzZSBpcyBhbHNvIHVwZGF0ZWQgdG8gdGVzdCBuZXN0ZWQg KHJlY3Vyc2l2ZSkgYWxpYXMuDQotLS0NCiBnZGIvZHdhcmYyL3JlYWQuYyAgICAgICAgICAgICAg ICAgICAgICAgfCA2MiArKysrKysrKysrKysrKystLS0tLS0tLS0NCiBnZGIvdGVzdHN1aXRlL2dk Yi5iYXNlL3N5bWJvbC1hbGlhcy5leHAgfCA2MyArKysrKysrKysrKysrKysrKysrKysrKystDQog Z2RiL3Rlc3RzdWl0ZS9nZGIuYmFzZS9zeW1ib2wtYWxpYXMyLmMgIHwgMTYgKysrKysrKw0KIDMg ZmlsZXMgY2hhbmdlZCwgMTE4IGluc2VydGlvbnMoKyksIDIzIGRlbGV0aW9ucygtKQ0KDQpkaWZm IC0tZ2l0IGEvZ2RiL2R3YXJmMi9yZWFkLmMgYi9nZGIvZHdhcmYyL3JlYWQuYw0KaW5kZXggNmRj ZDQ0NmU1ZjQuLmIwZWVkNjAwMzEyIDEwMDY0NA0KLS0tIGEvZ2RiL2R3YXJmMi9yZWFkLmMNCisr KyBiL2dkYi9kd2FyZjIvcmVhZC5jDQpAQCAtOTU3LDYgKzk1NywxMCBAQCBzdGF0aWMgdm9pZCBi dWlsZF90eXBlX3BzeW10YWJzX3JlYWRlciAoY3V0dV9yZWFkZXIgKnJlYWRlciwNCiANCiBzdGF0 aWMgdm9pZCBkd2FyZjJfYnVpbGRfcHN5bXRhYnNfaGFyZCAoZHdhcmYyX3Blcl9vYmpmaWxlICpw ZXJfb2JqZmlsZSk7DQogDQorc3RhdGljIHZvaWQgdmFyX2RlY29kZV9sb2NhdGlvbiAoc3RydWN0 IGF0dHJpYnV0ZSAqYXR0ciwNCisJCQkJIHN0cnVjdCBzeW1ib2wgKnN5bSwNCisJCQkJIHN0cnVj dCBkd2FyZjJfY3UgKmN1KTsNCisNCiBzdGF0aWMgdW5zaWduZWQgaW50IHBlZWtfYWJicmV2X2Nv ZGUgKGJmZCAqLCBjb25zdCBnZGJfYnl0ZSAqKTsNCiANCiBzdGF0aWMgY29uc3QgZ2RiX2J5dGUg KnJlYWRfYXR0cmlidXRlIChjb25zdCBzdHJ1Y3QgZGllX3JlYWRlcl9zcGVjcyAqLA0KQEAgLTEx MzQsNyArMTEzOCw3IEBAIHN0YXRpYyBzdHJ1Y3QgdXNpbmdfZGlyZWN0ICoqdXNpbmdfZGlyZWN0 aXZlcyAoc3RydWN0IGR3YXJmMl9jdSAqY3UpOw0KIA0KIHN0YXRpYyB2b2lkIHJlYWRfaW1wb3J0 X3N0YXRlbWVudCAoc3RydWN0IGRpZV9pbmZvICpkaWUsIHN0cnVjdCBkd2FyZjJfY3UgKik7DQog DQotc3RhdGljIGludCByZWFkX25hbWVzcGFjZV9hbGlhcyAoc3RydWN0IGRpZV9pbmZvICpkaWUs IHN0cnVjdCBkd2FyZjJfY3UgKmN1KTsNCitzdGF0aWMgYm9vbCByZWFkX2FsaWFzIChzdHJ1Y3Qg ZGllX2luZm8gKmRpZSwgc3RydWN0IGR3YXJmMl9jdSAqY3UpOw0KIA0KIHN0YXRpYyBzdHJ1Y3Qg dHlwZSAqcmVhZF9tb2R1bGVfdHlwZSAoc3RydWN0IGRpZV9pbmZvICpkaWUsDQogCQkJCSAgICAg IHN0cnVjdCBkd2FyZjJfY3UgKmN1KTsNCkBAIC04NzI4LDkgKzg3MzIsOSBAQCBwcm9jZXNzX2Rp ZSAoc3RydWN0IGRpZV9pbmZvICpkaWUsIHN0cnVjdCBkd2FyZjJfY3UgKmN1KQ0KICAgICAgIGJy ZWFrOw0KICAgICBjYXNlIERXX1RBR19pbXBvcnRlZF9kZWNsYXJhdGlvbjoNCiAgICAgICBjdS0+ cHJvY2Vzc2luZ19oYXNfbmFtZXNwYWNlX2luZm8gPSB0cnVlOw0KLSAgICAgIGlmIChyZWFkX25h bWVzcGFjZV9hbGlhcyAoZGllLCBjdSkpDQorICAgICAgaWYgKHJlYWRfYWxpYXMgKGRpZSwgY3Up KQ0KIAlicmVhazsNCi0gICAgICAvKiBUaGUgZGVjbGFyYXRpb24gaXMgbm90IGEgZ2xvYmFsIG5h bWVzcGFjZSBhbGlhcy4gICovDQorICAgICAgLyogVGhlIGRlY2xhcmF0aW9uIGlzIG5vdCBhIGds b2JhbCBuYW1lc3BhY2Ugb3IgdmFyaWFibGUgYWxpYXMuICAqLw0KICAgICAgIC8qIEZhbGwgdGhy b3VnaC4gICovDQogICAgIGNhc2UgRFdfVEFHX2ltcG9ydGVkX21vZHVsZToNCiAgICAgICBjdS0+ cHJvY2Vzc2luZ19oYXNfbmFtZXNwYWNlX2luZm8gPSB0cnVlOw0KQEAgLTkxOTgsMTggKzkyMDIs MTkgQEAgZHdhcmYyX3BoeXNuYW1lIChjb25zdCBjaGFyICpuYW1lLCBzdHJ1Y3QgZGllX2luZm8g KmRpZSwgc3RydWN0IGR3YXJmMl9jdSAqY3UpDQogICByZXR1cm4gcmV0dmFsOw0KIH0NCiANCi0v KiBJbnNwZWN0IERJRSBpbiBDVSBmb3IgYSBuYW1lc3BhY2UgYWxpYXMuICBJZiBvbmUgZXhpc3Rz LCByZWNvcmQNCi0gICBhIG5ldyBzeW1ib2wgZm9yIGl0Lg0KKy8qIEluc3BlY3QgRElFIGluIENV IGZvciBhIG5hbWVzcGFjZSBhbGlhcyBvciBhIHZhcmlhYmxlDQorICAgd2l0aCBhbGlhcyBhdHRy aWJ1dGUuIElmIG9uZSBleGlzdHMsIHJlY29yZCBhIG5ldyBzeW1ib2wNCisgICBmb3IgaXQuDQog DQotICAgUmV0dXJucyAxIGlmIGEgbmFtZXNwYWNlIGFsaWFzIHdhcyByZWNvcmRlZCwgMCBvdGhl cndpc2UuICAqLw0KKyAgIFJldHVybnMgInRydWUiIGlmIGFuIGFsaWFzIHdhcyByZWNvcmRlZCwg ImZhbHNlIiBvdGhlcndpc2UuICAqLw0KIA0KLXN0YXRpYyBpbnQNCi1yZWFkX25hbWVzcGFjZV9h bGlhcyAoc3RydWN0IGRpZV9pbmZvICpkaWUsIHN0cnVjdCBkd2FyZjJfY3UgKmN1KQ0KK3N0YXRp YyBib29sDQorcmVhZF9hbGlhcyAoc3RydWN0IGRpZV9pbmZvICpkaWUsIHN0cnVjdCBkd2FyZjJf Y3UgKmN1KQ0KIHsNCiAgIHN0cnVjdCBhdHRyaWJ1dGUgKmF0dHI7DQogDQotICAvKiBJZiB0aGUg ZGllIGRvZXMgbm90IGhhdmUgYSBuYW1lLCB0aGlzIGlzIG5vdCBhIG5hbWVzcGFjZQ0KLSAgICAg YWxpYXMuICAqLw0KKyAgLyogSWYgdGhlIGRpZSBkb2VzIG5vdCBoYXZlIGEgbmFtZSwgdGhpcyBp cyBub3QgYSBuYW1lc3BhY2UgYWxpYXMNCisgICAgIG9yIHZhcmlhYmxlIGFsaWFzLiAgKi8NCiAg IGF0dHIgPSBkd2FyZjJfYXR0ciAoZGllLCBEV19BVF9uYW1lLCBjdSk7DQogICBpZiAoYXR0ciAh PSBOVUxMKQ0KICAgICB7DQpAQCAtOTIzNSwyNiArOTI0MCw0MSBAQCByZWFkX25hbWVzcGFjZV9h bGlhcyAoc3RydWN0IGRpZV9pbmZvICpkaWUsIHN0cnVjdCBkd2FyZjJfY3UgKmN1KQ0KIAl7DQog CSAgY29tcGxhaW50IChfKCJESUUgYXQgJXMgaGFzIHRvbyBtYW55IHJlY3Vyc2l2ZWx5IGltcG9y dGVkICINCiAJCSAgICAgICAiZGVjbGFyYXRpb25zIiksIHNlY3Rfb2Zmc2V0X3N0ciAoZC0+c2Vj dF9vZmYpKTsNCi0JICByZXR1cm4gMDsNCisJICByZXR1cm4gZmFsc2U7DQogCX0NCiANCiAgICAg ICBpZiAoYXR0ciAhPSBOVUxMKQ0KIAl7DQogCSAgc3RydWN0IHR5cGUgKnR5cGU7DQotCSAgc2Vj dF9vZmZzZXQgc2VjdF9vZmYgPSBhdHRyLT5nZXRfcmVmX2RpZV9vZmZzZXQgKCk7DQotDQotCSAg dHlwZSA9IGdldF9kaWVfdHlwZV9hdF9vZmZzZXQgKHNlY3Rfb2ZmLCBjdS0+cGVyX2N1LCBjdS0+ cGVyX29iamZpbGUpOw0KLQkgIGlmICh0eXBlICE9IE5VTEwgJiYgdHlwZS0+Y29kZSAoKSA9PSBU WVBFX0NPREVfTkFNRVNQQUNFKQ0KKwkgIGlmICgoKGN1LT5wZXJfY3UtPmxhbmcgPT0gbGFuZ3Vh Z2VfYykNCisJICAgICAgfHwgKGN1LT5wZXJfY3UtPmxhbmcgPT0gbGFuZ3VhZ2VfY3BsdXMpKQ0K KwkgICAgICAmJiAoZC0+dGFnID09IERXX1RBR192YXJpYWJsZSkpDQogCSAgICB7DQotCSAgICAg IC8qIFRoaXMgZGVjbGFyYXRpb24gaXMgYSBnbG9iYWwgbmFtZXNwYWNlIGFsaWFzLiAgQWRkDQot CQkgYSBzeW1ib2wgZm9yIGl0IHdob3NlIHR5cGUgaXMgdGhlIGFsaWFzZWQgbmFtZXNwYWNlLiAg Ki8NCi0JICAgICAgbmV3X3N5bWJvbCAoZGllLCB0eXBlLCBjdSk7DQotCSAgICAgIHJldHVybiAx Ow0KKwkgICAgICAvKiBUaGlzIGRlY2xhcmF0aW9uIGlzIGEgQy9DKysgZ2xvYmFsIHZhcmlhYmxl IGFsaWFzLiBBZGQNCisJCSBhIHN5bWJvbCBmb3IgaXQgd2hvc2UgdHlwZSBpcyBzYW1lIGFzIGFs aWFzZWQgdmFyaWFibGUuICAqLw0KKwkgICAgICB0eXBlID0gZGllX3R5cGUgKGQsIGltcG9ydGVk X2N1KTsNCisJICAgICAgc3RydWN0IHN5bWJvbCAqc3ltID0gbmV3X3N5bWJvbCAoZGllLCB0eXBl LCBjdSk7DQorCSAgICAgIGF0dHIgPSBkd2FyZjJfYXR0ciAoZCwgRFdfQVRfbG9jYXRpb24sIGlt cG9ydGVkX2N1KTsNCisJICAgICAgc3ltLT5zZXRfYWNsYXNzX2luZGV4IChMT0NfVU5SRVNPTFZF RCk7DQorCSAgICAgIGlmIChhdHRyICE9IG51bGxwdHIpDQorCQl2YXJfZGVjb2RlX2xvY2F0aW9u IChhdHRyLCBzeW0sIGN1KTsNCisJICAgICAgcmV0dXJuIHRydWU7DQorCSAgICB9DQorCSAgZWxz ZQ0KKwkgICAgew0KKwkgICAgICBzZWN0X29mZnNldCBzZWN0X29mZiA9IGF0dHItPmdldF9yZWZf ZGllX29mZnNldCAoKTsNCisJICAgICAgdHlwZSA9IGdldF9kaWVfdHlwZV9hdF9vZmZzZXQgKHNl Y3Rfb2ZmLCBjdS0+cGVyX2N1LCBjdS0+cGVyX29iamZpbGUpOw0KKwkgICAgICBpZiAodHlwZSAh PSBOVUxMICYmIHR5cGUtPmNvZGUgKCkgPT0gVFlQRV9DT0RFX05BTUVTUEFDRSkNCisJCXsNCisJ CSAgLyogVGhpcyBkZWNsYXJhdGlvbiBpcyBhIGdsb2JhbCBuYW1lc3BhY2UgYWxpYXMuIEFkZA0K KwkJICAgICBhIHN5bWJvbCBmb3IgaXQgd2hvc2UgdHlwZSBpcyB0aGUgYWxpYXNlZCBuYW1lc3Bh Y2UuICAqLw0KKwkJICBuZXdfc3ltYm9sIChkaWUsIHR5cGUsIGN1KTsNCisJCSAgcmV0dXJuIHRy dWU7DQorCQl9DQogCSAgICB9DQogCX0NCiAgICAgfQ0KLQ0KLSAgcmV0dXJuIDA7DQorICByZXR1 cm4gZmFsc2U7DQogfQ0KIA0KIC8qIFJldHVybiB0aGUgdXNpbmcgZGlyZWN0aXZlcyByZXBvc2l0 b3J5IChnbG9iYWwgb3IgbG9jYWw/KSB0byB1c2UgaW4gdGhlDQpkaWZmIC0tZ2l0IGEvZ2RiL3Rl c3RzdWl0ZS9nZGIuYmFzZS9zeW1ib2wtYWxpYXMuZXhwIGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuYmFz ZS9zeW1ib2wtYWxpYXMuZXhwDQppbmRleCAyYjUzY2MzMTA1My4uYTk0ODdiMjVmNGQgMTAwNjQ0 DQotLS0gYS9nZGIvdGVzdHN1aXRlL2dkYi5iYXNlL3N5bWJvbC1hbGlhcy5leHANCisrKyBiL2dk Yi90ZXN0c3VpdGUvZ2RiLmJhc2Uvc3ltYm9sLWFsaWFzLmV4cA0KQEAgLTE1LDYgKzE1LDkgQEAN CiAjIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251 Lm9yZy9saWNlbnNlcy8+Lg0KIA0KIHN0YW5kYXJkX3Rlc3RmaWxlIHN5bWJvbC1hbGlhcy5jIHN5 bWJvbC1hbGlhczIuYw0KK3NldCB1c2luZ19jbGFuZyBbdGVzdF9jb21waWxlcl9pbmZvIGNsYW5n LSpdDQorc2V0IG9sZF9jbGFuZyBbZXhwciBbdGVzdF9jb21waWxlcl9pbmZvIHtjbGFuZy0xWzAt M10tKi0qfV0gXA0KKwkJIHx8IFt0ZXN0X2NvbXBpbGVyX2luZm8ge2NsYW5nLVsxLTldLSp9XV0N CiANCiBpZiB7IFtwcmVwYXJlX2Zvcl90ZXN0aW5nICJmYWlsZWQgdG8gcHJlcGFyZSIgJHt0ZXN0 ZmlsZX0gW2xpc3QgJHNyY2ZpbGUgJHNyY2ZpbGUyXV0gfSB7DQogICAgIHJldHVybiAtMQ0KQEAg LTMxLDYgKzM0LDYyIEBAIGZvcmVhY2ggZiB7ImZ1bmMiICJmdW5jX2FsaWFzIn0gew0KIH0NCiAN CiAjIFZhcmlhYmxlcy4NCi1mb3JlYWNoIHYgeyJnX3Zhcl9zIiAiZ192YXJfc19hbGlhcyJ9IHsN Ci0gICAgZ2RiX3Rlc3QgInAgJHYiICI9IHtmaWVsZDEgPSAxLCBmaWVsZDIgPSAyfSINCitnZGJf dGVzdCAicCBnX3Zhcl9zIiAiPSB7ZmllbGQxID0gMSwgZmllbGQyID0gMn0iDQorZm9yZWFjaCB2 IHsiZ192YXJfc19hbGlhcyIgImdfdmFyX3NfYWxpYXMyIn0gew0KKyAgICBnZGJfdGVzdF9tdWx0 aXBsZSAicCAkdiIgInAgJHYiIHsNCisJLXJlICAiID0ge2ZpZWxkMSA9IDEsIGZpZWxkMiA9IDJ9 LiokZ2RiX3Byb21wdCAkIiB7DQorCSAgICBwYXNzICJwcmludCBhbGlhcyBvZiB2YXJpYWJsZSAk diINCisJfQ0KKwktcmUgICIuKmhhcyB1bmtub3duIHR5cGU7IGNhc3QgaXQgdG8gaXRzIGRlY2xh cmVkIHR5cGUuKiRnZGJfcHJvbXB0ICQiIHsNCisJICAgIGlmIHsgJG9sZF9jbGFuZyB9IHsNCisJ CXhmYWlsICJwcmludCBhbGlhcyB2YXJpYWJsZSAkdiINCisJICAgIH0gZWxzZSB7DQorCQlmYWls ICJwcmludCBhbGlhcyB2YXJpYWJsZSAkdiINCisJICAgIH0NCisJfQ0KKyAgICB9DQorfQ0KKw0K KyMgU3RhdGljIFZhcmlhYmxlLg0KK2dkYl90ZXN0ICJwIGdfdmFyIiAiID0gMSINCitnZGJfdGVz dF9tdWx0aXBsZSAicCBnX3Zhcl9hbGlhcyIgInAgZ192YXJfYWxpYXMiIHsNCisgICAgLXJlICAi ID0gMS4qJGdkYl9wcm9tcHQgJCIgew0KKwlwYXNzICJwcmludCBhbGlhcyBvZiBzdGF0aWMgdmFy aWFibGUiDQorICAgIH0NCisgICAgLXJlICAiLipoYXMgdW5rbm93biB0eXBlOyBjYXN0IGl0IHRv IGl0cyBkZWNsYXJlZCB0eXBlLiokZ2RiX3Byb21wdCAkIiB7DQorCWlmIHsgJG9sZF9jbGFuZyB9 IHsNCisJICB4ZmFpbCAicHJpbnQgYWxpYXMgb2Ygc3RhdGljIHZhcmlhYmxlIg0KKwl9IGVsc2Ug ew0KKwkgIGZhaWwgInByaW50IGFsaWFzIG9mIHN0YXRpYyB2YXJpYWJsZSINCisJfQ0KKyAgICB9 DQorfQ0KKw0KKyMgRGVmZXJyZWQgVmFyaWFibGUuDQorZ2RiX3Rlc3QgInAgZ19kZWZfdmFyIiAi ID0gMiINCitnZGJfdGVzdF9tdWx0aXBsZSAicCBnX2RlZl92YXJfYWxpYXMiICJwIGdfZGVmX3Zh cl9hbGlhcyIgew0KKyAgICAtcmUgICIgPSAyLiokZ2RiX3Byb21wdCAkIiB7DQorCXBhc3MgInBy aW50IGFsaWFzIG9mIGRlZmVycmVkIHZhcmlhYmxlIg0KKyAgICB9DQorICAgIC1yZSAgIi4qaGFz IHVua25vd24gdHlwZTsgY2FzdCBpdCB0byBpdHMgZGVjbGFyZWQgdHlwZS4qJGdkYl9wcm9tcHQg JCIgew0KKwlpZiB7ICR1c2luZ19jbGFuZyB9IHsNCisJICB4ZmFpbCAicHJpbnQgYWxpYXMgb2Yg ZGVmZXJyZWQgdmFyaWFibGUiDQorCX0gZWxzZSB7DQorCSAgZmFpbCAicHJpbnQgYWxpYXMgb2Yg ZGVmZXJyZWQgdmFyaWFibGUiDQorCX0NCisgICAgfQ0KK30NCisNCisjIEFsaWFzIG9mIGRlZmVy cmVkIFZhcmlhYmxlIGFsaWFzLg0KK2dkYl90ZXN0X211bHRpcGxlICJwIGdfZGVmX3ZhcjJfYWxp YXMyIiAicCBnX2RlZl92YXIyX2FsaWFzMiIgew0KKyAgICAtcmUgICIgPSAzLiokZ2RiX3Byb21w dCAkIiB7DQorCXBhc3MgInByaW50IGFsaWFzIG9mIGFsaWFzIG9mIGRlZmVycmVkIHZhcmlhYmxl Ig0KKyAgICB9DQorICAgIC1yZSAgIi4qaGFzIHVua25vd24gdHlwZTsgY2FzdCBpdCB0byBpdHMg ZGVjbGFyZWQgdHlwZS4qJGdkYl9wcm9tcHQgJCIgew0KKwlpZiB7ICRvbGRfY2xhbmcgfSB7DQor CSAgeGZhaWwgInByaW50IGFsaWFzIG9mIGFsaWFzIG9mIGRlZmVycmVkIHZhcmlhYmxlIg0KKwl9 IGVsc2Ugew0KKwkgIGZhaWwgInByaW50IGFsaWFzIG9mIGFsaWFzIG9mIGRlZmVycmVkIHZhcmlh YmxlIg0KKwl9DQorICAgIH0NCiB9DQpkaWZmIC0tZ2l0IGEvZ2RiL3Rlc3RzdWl0ZS9nZGIuYmFz ZS9zeW1ib2wtYWxpYXMyLmMgYi9nZGIvdGVzdHN1aXRlL2dkYi5iYXNlL3N5bWJvbC1hbGlhczIu Yw0KaW5kZXggMzRmNGUxMjFlMjUuLjQxZDRiNmE1M2U1IDEwMDY0NA0KLS0tIGEvZ2RiL3Rlc3Rz dWl0ZS9nZGIuYmFzZS9zeW1ib2wtYWxpYXMyLmMNCisrKyBiL2dkYi90ZXN0c3VpdGUvZ2RiLmJh c2Uvc3ltYm9sLWFsaWFzMi5jDQpAQCAtMjMsNiArMjMsOCBAQCBzdHJ1Y3QgUw0KIA0KIHN0cnVj dCBTIGdfdmFyX3MgPSB7IDEsIDIgfTsNCiANCitzdGF0aWMgaW50IGdfdmFyID0gMTsNCisNCiAj aWZkZWYgX19jcGx1c3BsdXMNCiAvKiBTbyB0aGF0IHRoZSBhbGlhcyBhdHRyaWJ1dGUgYmVsb3cg d29yayB3aXRob3V0IGhhdmluZyB0byBmaWd1cmUgb3V0DQogICAgdGhpcyBmdW5jdGlvbidzIG1h bmdsZWQgbmFtZS4gICovDQpAQCAtMzgsMyArNDAsMTcgQEAgZnVuYyAodm9pZCkNCiBzdHJ1Y3Qg UyAqZnVuY19hbGlhcyAodm9pZCkgX19hdHRyaWJ1dGVfXyAoKGFsaWFzICgiZnVuYyIpKSk7DQog DQogZXh0ZXJuIHN0cnVjdCBTIGdfdmFyX3NfYWxpYXMgX19hdHRyaWJ1dGVfXyAoKGFsaWFzICgi Z192YXJfcyIpKSk7DQorDQorZXh0ZXJuIHN0cnVjdCBTIGdfdmFyX3NfYWxpYXMyIF9fYXR0cmli dXRlX18gKChhbGlhcyAoImdfdmFyX3NfYWxpYXMiKSkpOw0KKw0KK2V4dGVybiBpbnQgZ192YXJf YWxpYXMgX19hdHRyaWJ1dGVfXyAoKGFsaWFzICgiZ192YXIiKSkpOw0KKw0KK2V4dGVybiBpbnQg Z19kZWZfdmFyX2FsaWFzIF9fYXR0cmlidXRlX18gKChhbGlhcyAoImdfZGVmX3ZhciIpKSk7DQor DQoraW50IGdfZGVmX3ZhciA9IDI7DQorDQorZXh0ZXJuIGludCBnX2RlZl92YXIyX2FsaWFzIF9f YXR0cmlidXRlX18gKChhbGlhcyAoImdfZGVmX3ZhcjIiKSkpOw0KKw0KK2ludCBnX2RlZl92YXIy ID0gMzsNCisNCitleHRlcm4gaW50IGdfZGVmX3ZhcjJfYWxpYXMyIF9fYXR0cmlidXRlX18gKChh bGlhcyAoImdfZGVmX3ZhcjJfYWxpYXMiKSkpOw0KLS0gDQoyLjI1LjENCg0K --_002_DM4PR12MB579651F1A1172BC69695CC93F7F39DM4PR12MB5796namp_--