From patchwork Fri Jul 19 14:54:02 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Matthieu Longo X-Patchwork-Id: 1962525 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=arm.com header.i=@arm.com header.a=rsa-sha256 header.s=selector1 header.b=Fp3vchPS; dkim=pass (1024-bit key) header.d=arm.com header.i=@arm.com header.a=rsa-sha256 header.s=selector1 header.b=Fp3vchPS; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4WQXmB06Kkz1xpQ for ; Sat, 20 Jul 2024 00:55:38 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 3FE3E384A446 for ; Fri, 19 Jul 2024 14:55:36 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from EUR05-AM6-obe.outbound.protection.outlook.com (mail-am6eur05on2062f.outbound.protection.outlook.com [IPv6:2a01:111:f403:2612::62f]) by sourceware.org (Postfix) with ESMTPS id D0061384AB59 for ; Fri, 19 Jul 2024 14:55:00 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org D0061384AB59 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=arm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=arm.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org D0061384AB59 Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=2a01:111:f403:2612::62f ARC-Seal: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1721400904; cv=pass; b=Schgkat8tz5iSgzpWe0yD9rcDeKXskYxF6a14h0AF6dhbu5R6gFZG5DmWq+zg19rxWxMh2RKzpvC/CWUBsURitD3TPghNPBw+a94sGnq/uM29zv5ctXUmCh1F5OGLVBlttowsmhA8mw1vfUXB5fewp4T2/0Uq4wshL8ZfmX5GDg= ARC-Message-Signature: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1721400904; c=relaxed/simple; bh=GtuMNBeDHPVVta4niaWIxqmN33G90msnqTi5jawtJmg=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=YMOg5w85KupgExNpsnwTew5TvkGkMLbDTAcWAqem4niFivT0vRYK5F5s+E8JpkSewvqdFtn10tJHruExve6N3tY7smUFHW+s33dTqrstt1emmrOL7wNzuS6L9FEEobNcgA1MrwAojWbmvOPw0o624m4/fwO/dTblRZTbXdk0Bsk= ARC-Authentication-Results: i=3; server2.sourceware.org ARC-Seal: i=2; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=pass; b=jEcduwwxyvpJSnbilp5KEXVV2HAQzpQqydQCkqsmXTSH/h+uO+8YW2xZYdzKBoQ41amZNFaBhLENSy5Gv9+0wSve0N85pfYK7jBjZbn1WE9/aIGg36q+ESsUzpCvZUZE7B8/UOdHyD18iiQv+1IBZADXyQdoP6FBS3Y0ot5vOAuVGld4hN09oUk1Ng6+mHkU8l7jCR9vYJvs0BxXv3HnH2ebGeDqd7ON961uUD9QV5Su158WCYRJlrPm/xMLdM5/GHFbrLCPZoTGDbikYiQDdVdN7eUqbpZWRX+gwsX4TdPkVaaMKK++6ygRbOClQWmWAxbkN7WM59frr3JZdjvGeA== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; 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=IQ0QeVACGGDKT22rRBXudB7dh4STtmra6atQLOl2OGw=; b=cKJ2t1Y6dVIo4iFSynGX/n7xuGDfw7U72dcd050OSvNa49fAAbW131/ShuLqSKdcj4Xr0lgmcS7O8F+yIlnXPSIUd7A7ZbbysesGnse3i6fPIFeGwcVzl6UQ4soY6SlqFYRoqUX1D5puAVLQWcSsHJFxlzMjwnw4v5CxAL92FUGNMXwFypWWs5uhOD3rFVSbAAVe8UbPfYq/xZ3Mpv9xsyFzgWLeq62BC+wrKi4T+KvQ8G+5iASwGkJEjKglvuWgkzoKxI8YAAMD/pGJ4Z82CcWthmxkoIJT7YqMEcHPjLLM1Cm/io0M0yBsyhB4k/hOp6kyFcRAIB6XFFjG8jYtIA== ARC-Authentication-Results: i=2; mx.microsoft.com 1; spf=pass (sender ip is 63.35.35.123) smtp.rcpttodomain=gcc.gnu.org smtp.mailfrom=arm.com; dmarc=pass (p=none sp=none pct=100) action=none header.from=arm.com; dkim=pass (signature was verified) header.d=arm.com; arc=pass (0 oda=1 ltdi=1 spf=[1,1,smtp.mailfrom=arm.com] dmarc=[1,1,header.from=arm.com]) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=arm.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=IQ0QeVACGGDKT22rRBXudB7dh4STtmra6atQLOl2OGw=; b=Fp3vchPSde7Ka1QO+Mig95UvwBu/spB+Sbzw9irtDYfZzgHH72GvtdoomeAlaYpAvIdC+ziA1AgBBnJEq7AwFziIxtj83gfvrvBySFaZsGzNVpBHVoDQqq08gXzRRNeasScaSTZ/LLiK0AqMjRbGxNeAQ3tqIbzyb+ihlLdZIKA= Received: from DU2PR04CA0012.eurprd04.prod.outlook.com (2603:10a6:10:3b::17) by AM9PR08MB5875.eurprd08.prod.outlook.com (2603:10a6:20b:2dc::17) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7784.20; Fri, 19 Jul 2024 14:54:58 +0000 Received: from DB5PEPF00014B95.eurprd02.prod.outlook.com (2603:10a6:10:3b:cafe::de) by DU2PR04CA0012.outlook.office365.com (2603:10a6:10:3b::17) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7784.18 via Frontend Transport; Fri, 19 Jul 2024 14:54:57 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 63.35.35.123) smtp.mailfrom=arm.com; dkim=pass (signature was verified) header.d=arm.com;dmarc=pass action=none header.from=arm.com; Received-SPF: Pass (protection.outlook.com: domain of arm.com designates 63.35.35.123 as permitted sender) receiver=protection.outlook.com; client-ip=63.35.35.123; helo=64aa7808-outbound-1.mta.getcheckrecipient.com; pr=C Received: from 64aa7808-outbound-1.mta.getcheckrecipient.com (63.35.35.123) by DB5PEPF00014B95.mail.protection.outlook.com (10.167.8.233) with Microsoft SMTP Server (version=TLS1_3, cipher=TLS_AES_256_GCM_SHA384) id 15.20.7784.11 via Frontend Transport; Fri, 19 Jul 2024 14:54:57 +0000 Received: ("Tessian outbound 0808e8e76ea3:v365"); Fri, 19 Jul 2024 14:54:57 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: e7cd21a5b652365f X-CR-MTA-TID: 64aa7808 Received: from L86cc810f3c40.1 by 64aa7808-outbound-1.mta.getcheckrecipient.com id A0F51ABD-0482-4EB2-AFFC-FD3BAA02C27E.1; Fri, 19 Jul 2024 14:54:50 +0000 Received: from EUR05-AM6-obe.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id L86cc810f3c40.1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Fri, 19 Jul 2024 14:54:50 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=khXU2IUC5m7wrFnJcUU1CpqCewSiMccm2WiQRo35EeJ88aCeZiPYY9mELYZ+GzMQ2CGo1Vm4DKpWxFyx6bWp5sifcDlatiawc/asweEk0v++f2M0TSEiACw3vlvvJUWxu/E7tWTYbUmFACDthvfChJXw+VMATyJFU3EhlgWoIj6PGa+Vt5QAX3Cjaz3nxFO+AgzciBLgHMaAyYYPit4lV2qm+YcpxaroUHDll3OAzs55ubmPEmh3v1Wz2FVoJVGePw6py7+Zaj/9ltxAxzsPNbG0bP7iVsOsEaOlvHsACbIP2WONSOV8DEzXev736TzFZEZ3zHgQpRxpd05JcTxq+A== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; 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=IQ0QeVACGGDKT22rRBXudB7dh4STtmra6atQLOl2OGw=; b=bZgWW1Xw1Uxbdejk2EBNZOpe62MnWPzdY5Fzag4FP3V6yhupOQ9JKSeacQ99NDI3b1td94kK1KW/X6ZJzHL/irbaq8ds8upCLSIpllLGzr0GPpZ21TdnWHCuFe6rVCWJWtaAbu1APMsC4cZCnrzrlzCpRgwrig17FAnGkER/DA2U/Fprdyb6At60Vo/6GdedJypU7STL3JH0499NYyEHETHSHH0FXO+oxevQuyalz+xuE/+hi6/YywXJj+kj7qe+XonjkCHou7A82qJctNUYUnjIL5HQsXprs5ZdhyT/nNaKoIEppnBh5U0xgn7nt63kP/EOsyyGSc6T43WwJihIOw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 40.67.248.234) smtp.rcpttodomain=gcc.gnu.org smtp.mailfrom=arm.com; dmarc=pass (p=none sp=none pct=100) action=none header.from=arm.com; dkim=none (message not signed); arc=none (0) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=arm.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=IQ0QeVACGGDKT22rRBXudB7dh4STtmra6atQLOl2OGw=; b=Fp3vchPSde7Ka1QO+Mig95UvwBu/spB+Sbzw9irtDYfZzgHH72GvtdoomeAlaYpAvIdC+ziA1AgBBnJEq7AwFziIxtj83gfvrvBySFaZsGzNVpBHVoDQqq08gXzRRNeasScaSTZ/LLiK0AqMjRbGxNeAQ3tqIbzyb+ihlLdZIKA= Received: from DUZPR01CA0057.eurprd01.prod.exchangelabs.com (2603:10a6:10:469::6) by VE1PR08MB5854.eurprd08.prod.outlook.com (2603:10a6:800:1b0::6) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7784.16; Fri, 19 Jul 2024 14:54:48 +0000 Received: from DB5PEPF00014B8E.eurprd02.prod.outlook.com (2603:10a6:10:469::4) by DUZPR01CA0057.outlook.office365.com (2603:10a6:10:469::6) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7784.20 via Frontend Transport; Fri, 19 Jul 2024 14:54:48 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 40.67.248.234) smtp.mailfrom=arm.com; dkim=none (message not signed) header.d=none;dmarc=pass action=none header.from=arm.com; Received-SPF: Pass (protection.outlook.com: domain of arm.com designates 40.67.248.234 as permitted sender) receiver=protection.outlook.com; client-ip=40.67.248.234; helo=nebula.arm.com; pr=C Received: from nebula.arm.com (40.67.248.234) by DB5PEPF00014B8E.mail.protection.outlook.com (10.167.8.202) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.7784.11 via Frontend Transport; Fri, 19 Jul 2024 14:54:48 +0000 Received: from AZ-NEU-EX03.Arm.com (10.251.24.31) by AZ-NEU-EX04.Arm.com (10.251.24.32) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.39; Fri, 19 Jul 2024 14:54:47 +0000 Received: from PW070M4K.cambridge.arm.com (10.57.76.129) by mail.arm.com (10.251.24.31) with Microsoft SMTP Server id 15.1.2507.39 via Frontend Transport; Fri, 19 Jul 2024 14:54:47 +0000 From: Matthieu Longo To: CC: Richard Earnshaw , Szabolcs Nagy , Jakub Jelinek , Matthieu Longo Subject: [PATCH v1 1/3] aarch64: store signing key and signing method in DWARF _Unwind_FrameState Date: Fri, 19 Jul 2024 15:54:02 +0100 Message-ID: <20240719145404.683815-2-matthieu.longo@arm.com> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20240719145404.683815-1-matthieu.longo@arm.com> References: <20240719145404.683815-1-matthieu.longo@arm.com> MIME-Version: 1.0 X-EOPAttributedMessage: 1 X-MS-TrafficTypeDiagnostic: DB5PEPF00014B8E:EE_|VE1PR08MB5854:EE_|DB5PEPF00014B95:EE_|AM9PR08MB5875:EE_ X-MS-Office365-Filtering-Correlation-Id: 46f92e93-7d9b-43ec-8c87-08dca802c1ee x-checkrecipientrouted: true NoDisclaimer: true X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam-Untrusted: BCL:0; ARA:13230040|1800799024|82310400026|376014|36860700013; X-Microsoft-Antispam-Message-Info-Original: FbzTab74QWfHZRNCpCoaxmAK0YHsFRUGGJ95uApl3VTJPPWglIT3EZ6CtUIM3mMJqx67L0ru5Saqhb8srKGtdbdu61qcV99/0mxk0+/vjPcobduGmlhwmbRN44W3u717qwFoAKZkEHd95LjuE/8hvKok3W2hZsOz/Gh5Wv1ZHU4RPWj6OH06ydI5ElZVe3g4uiq+bjXxveUEiFRE/0ZEKGOiSI3eRbdE1gRWoX1XgWGY3hWYiJqzgBul2zT3SLZn3D46oW3sZsssnl/FzBD/k1mBoXTuAnDc89NW+ZDLXYcIX1NYOaYdSNP3gTyvZW9beMlM6dod5OLuBnfJG5vlxcnYAQMr9EuKuGlHGeBpgVZfL+D6P8uDrPoYCd4gZY1lv4dIbqrXUP8fQ9PDOSF0IjNRcZstCgQAMK37omiTfwFpe5Uks9d93pEC6m6xW+uAZKVxUR8/twnYhcdtGHNXPRItABb0xhrkSJsfwo5lE5r0Izu3sLsA6LnhWxd1bS0H6M1TotVs7MCDPhd5ukha8pfMUvize/8lAWoByl4t3kowPhF/G1PRoqlmAB3EEHIncZfeHJshjFsrUSijR2w1epi4U8b7DptfyJR9k7mQZLGAQ4DgOem//d+YEf45Q9iE4fct59Bzj31K4dpGURzBqYBrbM452cXm3mjnoa9NrCylcQB26iVlrbDPZgMW0SOqNN8KdD9oXXVFDTam4IJfq+X2IsEe7jPYsTaXcGdrzN9JLlUksVbXbn9dEv/JdLfDLxlGDUiL4Ts5OflNYNBtv/C57XeY2a7Sb+OJ0XH+F5fz1I2FnrYLTOQpzMYNCq8D1GsLv3v7ek4/Mwe0zeV3U91DsnxxDEy5jD6fhIc/8M2mrGF3UkfU1K+kMfIP9D1Yzh5dGD4OU/HXqRFPoEyf1HZfq6PFS+TaRGTyeiqr+CvKUNdXGrZBWB7wRt2QRdf6xxbOll80JZGO/DFBKcSJYoH7KLguoFvPT6zTd4DqCDvZNyzywK/yV+Bkch5ok2dvthO/oXVCqsz3UKULboPjsZ3s02uowacxW/4t48yzAdDBmUDzBIW/AvDJgF7urFsfzWvbUKhWNcIu0kKip6uKZGScteje3PXVIf6fU9jmLjwe5pz+H4iZ2Fz7mun6eq7WIjHQdWAHgtf9gVkTuZWYID04N+bSW57fJLjdgf+KqU3dxyKsH5oxaJ+U3Oqx+/AjrdG5WLljiteT9iRo4N2mP67VDQjD6GEUV8jtPNDMjWoZyKE0nJpb5Y1Bww/BFFrtAESguHawbo3iO3hiHstxqyC0QxxFTXc1bbt4lJfdiHkUeHpJIfhy1G9sOEDrDp0E0XDpUuA+cjjXoKCs1hu42wOWhxhk9v0+xMrhLtDxVPIcnscugGBfYMZ8vqf2je3NP2jvTQYofiz5yGhLfKeHVA== X-Forefront-Antispam-Report-Untrusted: CIP:40.67.248.234; CTRY:IE; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:nebula.arm.com; PTR:InfoDomainNonexistent; CAT:NONE; SFS:(13230040)(1800799024)(82310400026)(376014)(36860700013); DIR:OUT; SFP:1101; X-MS-Exchange-Transport-CrossTenantHeadersStamped: VE1PR08MB5854 X-MS-Exchange-SkipListedInternetSender: ip=[2603:10a6:10:469::6]; domain=DUZPR01CA0057.eurprd01.prod.exchangelabs.com X-MS-Exchange-Transport-CrossTenantHeadersStripped: DB5PEPF00014B95.eurprd02.prod.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: 6b75f8e1-1be6-4f17-fc91-08dca802bc4f X-Microsoft-Antispam: BCL:0; ARA:13230040|376014|82310400026|35042699022|1800799024|36860700013|34020700016; X-Microsoft-Antispam-Message-Info: ErqpW4tv9nEHfDUssqX6ziSpWAGqeRnc8IkM/KhL0Ssu/g13fcdJgv6uwEhYItReq7nhl7pCLHhimQTogbc14WIX/Efymlbc/Zm17bHwktFvfnXLY0A+pr75AlhMZWo6V5XdF683oR9ltc+jpraEp4vBRkwXdGUU7Uvo68pjNUYlTII4F0pF3m/4ZE2Syt7145mEehFAkMD+fEZ307TxzxMaaNcqMhHPkQwiyaidaR2CtzSR+rTt9sRhsggZRe6qh50ARGOMp56Sue/qejGiLkfUTl3Wc3kI7eGMyd8111PlubVHzbI1dxVbViwS+5PNZqBkYdatwmaATHFbfA+SKWPUPAo5gqr9c9wCs7//x2maXv4CWRoEwRS69k0OYmhutqFxDv3HFYhleWxCTTjxHr8p/fnJblkGaQYwaH34+aRz4LaTWRJFscyaAkDNFIXJ4Kw8agK3k1zrgExlNmSUHwAh6K1nJkLSN7jxpHPJ9ONaIRrzhZcDbpxUuNbcaTsYalgkjwedfhzelxgL0RezFv01JctONpRvLyfzB8eD2Qcb67fEW7wGR63ncB5e6sU6mTB6NxsTbjhaLmIbnpvAmCMEsb2SNN8cCs/PQ16s7ZGWTh1E6tpr0pYZTiK2ghJwRTWlQm8VAZUjRK3KLAMzX/26Sy3obOkb3F/ny2ZhxRlAOev4OW5Z7/PGuI46fxSqDnmwHrEY152MRlG+Je7IiDeM3FUe/o1YRtXulz3bnoxzAgm+i61D6z8isOfXus+e72MhthVNZr8Zlm3677MNxZXCdQ4bSplS8EpBnU+JYV8k5IW/umSjy4wcDRp9lB6LShshFBL13gE2GNyZPsZRNL5ofa1Fo8yF61azat5/W6JkBwaiFyyd/3jt3bks1OuKP7PY2S90iUr9vR2vXZ9skukzcgIAlYDPAr0AXb+W1FMYjEjenHyY7hm9PaWTJVm5bcTc3aBUpC8apddSMURCnxLf1hCqkisWEjtpVVtkE0sD0IkdP6CfI5+HwJoej2BriW0qXeo0L/gwB8GScx6gIFpf7FW0ZTlYI1yc4Qk6Oo8WbDi7ZLqqKNAQmTE50pjxfWbYeMrutr6rcQd0xP9dG1tgTZAdQSCk9GU0GTZQX3Rg1koEfZkQNYj/yQ/392beSs0Thfu1yOIr/ivljBpItF/Y0KIV7C8j//u8ezYOdw+TAXUsAGQAJdr3ytAR3o8qYkncEplbYPd+KFtRzUgMTcBrO7FoAX1jbqtChHu5L/D+pcEP/IKPjro/q+1jJQ9qo6/6ByVPVFQmd8MBA/NbnLfkBoFFUgRJ1977uAwUkKspMAtjNEghaCOBqT3oaSnBkWFvdgJyqUCLgSdJCn8iExBX/FVt4DQZHGgiKdsYSbHNWKGEPxjhZBdhs4TqYing5YztHNL6TnQmhMY5ixs1qQ== X-Forefront-Antispam-Report: CIP:63.35.35.123; CTRY:IE; LANG:en; SCL:1; SRV:; IPV:CAL; SFV:NSPM; H:64aa7808-outbound-1.mta.getcheckrecipient.com; PTR:ec2-63-35-35-123.eu-west-1.compute.amazonaws.com; CAT:NONE; SFS:(13230040)(376014)(82310400026)(35042699022)(1800799024)(36860700013)(34020700016); DIR:OUT; SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 19 Jul 2024 14:54:57.6648 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 46f92e93-7d9b-43ec-8c87-08dca802c1ee X-MS-Exchange-CrossTenant-Id: f34e5979-57d9-4aaa-ad4d-b122a662184d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=f34e5979-57d9-4aaa-ad4d-b122a662184d; Ip=[63.35.35.123]; Helo=[64aa7808-outbound-1.mta.getcheckrecipient.com] X-MS-Exchange-CrossTenant-AuthSource: DB5PEPF00014B95.eurprd02.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM9PR08MB5875 X-Spam-Status: No, score=-11.9 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FORGED_SPF_HELO, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_PASS, SPF_NONE, TXREP, UNPARSEABLE_RELAY autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org This patch is only a refactoring of the existing implementation of PAuth and returned-address signing. The existing behavior is preserved. _Unwind_FrameState already contains several CIE and FDE information (see the attributes below the comment "The information we care about from the CIE/FDE" in libgcc/unwind-dw2.h). The patch aims at moving the information from DWARF CIE (signing key stored in the augmentation string) and FDE (the used signing method) into _Unwind_FrameState along the already-stored CIE and FDE information. Note: those information have to be saved in frame_state_reg_info instead of _Unwind_FrameState as they need to be savable by DW_CFA_remember_state and restorable by DW_CFA_restore_state, that both rely on the attribute "prev". Those new information in _Unwind_FrameState simplifies the look-up of the signing key when the return address is demangled. It also allows future signing methods to be easily added. _Unwind_FrameState is not a part of the public API of libunwind, so the change is backward compatible. A new architecture-specific handler MD_ARCH_EXTENSION_FRAME_INIT allows to reset values (if needed) in the frame state and unwind context before changing the frame state to the caller context. A new architecture-specific handler MD_ARCH_EXTENSION_CIE_AUG_HANDLER isolates the architecture-specific augmentation strings in AArch64 backend, and allows others architectures to reuse augmentation strings that would have clashed with AArch64 DWARF extensions. aarch64_demangle_return_addr, DW_CFA_AARCH64_negate_ra_state and DW_CFA_val_expression cases in libgcc/unwind-dw2-execute_cfa.h were documented to clarify where the value of the RA state register is stored (FS and CONTEXT respectively). libgcc/ChangeLog: * config/aarch64/aarch64-unwind.h (AARCH64_DWARF_RA_STATE_MASK): The mask for RA state register. (aarch64_RA_signing_method_t): The diversifiers used to sign a function's return address. (aarch64_pointer_auth_key): The key used to sign a function's return address. (aarch64_cie_signed_with_b_key): Deleted as the signing key is available now in _Unwind_FrameState. (MD_ARCH_EXTENSION_CIE_AUG_HANDLER): New CIE augmentation string handler for architecture extensions. (MD_ARCH_EXTENSION_FRAME_INIT): New architecture-extension initialization routine for DWARF frame state and context before execution of DWARF instructions. (aarch64_context_RA_state_get): Read RA state register from CONTEXT. (aarch64_RA_state_get): Read RA state register from FS. (aarch64_RA_state_set): Write RA state register into FS. (aarch64_RA_state_toggle): Toggle RA state register in FS. (aarch64_cie_aug_handler): Handler AArch64 augmentation strings. (aarch64_arch_extension_frame_init): Initialize defaults for the signing key (PAUTH_KEY_A), and RA state register (RA_no_signing). (aarch64_demangle_return_addr): Rely on the frame registers and the signing_key attribute in _Unwind_FrameState. * unwind-dw2-execute_cfa.h: Use the right alias DW_CFA_AARCH64_negate_ra_state for __aarch64__ instead of DW_CFA_GNU_window_save. (DW_CFA_AARCH64_negate_ra_state): Save the signing method in RA state register. Toggle RA state register without resetting 'how' to REG_UNSAVED. * unwind-dw2.c: (extract_cie_info): Save the signing key in the current _Unwind_FrameState while parsing the augmentation data. (uw_frame_state_for): Reset some attributes related to architecture extensions in _Unwind_FrameState. (uw_update_context): Move authentication code to AArch64 unwinding. * unwind-dw2.h (enum register_rule): Give a name to the existing enum for the register rules, and replace 'unsigned char' by 'enum register_rule' to facilitate debugging in GDB. (_Unwind_FrameState): Add a new architecture-extension attribute to store the signing key. --- libgcc/config/aarch64/aarch64-unwind.h | 154 ++++++++++++++++++++----- libgcc/unwind-dw2-execute_cfa.h | 34 ++++-- libgcc/unwind-dw2.c | 19 ++- libgcc/unwind-dw2.h | 17 ++- 4 files changed, 175 insertions(+), 49 deletions(-) diff --git a/libgcc/config/aarch64/aarch64-unwind.h b/libgcc/config/aarch64/aarch64-unwind.h index daf96624b5e..cc225a7e207 100644 --- a/libgcc/config/aarch64/aarch64-unwind.h +++ b/libgcc/config/aarch64/aarch64-unwind.h @@ -25,55 +25,155 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #if !defined (AARCH64_UNWIND_H) && !defined (__ILP32__) #define AARCH64_UNWIND_H -#define DWARF_REGNUM_AARCH64_RA_STATE 34 +#include "ansidecl.h" +#include + +#define AARCH64_DWARF_REGNUM_RA_STATE 34 +#define AARCH64_DWARF_RA_STATE_MASK 0x1 + +/* The diversifiers used to sign a function's return address. */ +typedef enum +{ + AARCH64_RA_no_signing = 0x0, + AARCH64_RA_signing_SP = 0x1, +} __attribute__((packed)) aarch64_RA_signing_method_t; + +/* The key used to sign a function's return address. */ +typedef enum { + AARCH64_PAUTH_KEY_A, + AARCH64_PAUTH_KEY_B, +} __attribute__((packed)) aarch64_pointer_auth_key; + +#define MD_ARCH_EXTENSION_CIE_AUG_HANDLER(fs, aug) \ + aarch64_cie_aug_handler(fs, aug) + +#define MD_ARCH_EXTENSION_FRAME_INIT(context, fs) \ + aarch64_arch_extension_frame_init(context, fs) #define MD_DEMANGLE_RETURN_ADDR(context, fs, addr) \ aarch64_demangle_return_addr (context, fs, addr) -static inline int -aarch64_cie_signed_with_b_key (struct _Unwind_Context *context) +static inline aarch64_RA_signing_method_t +aarch64_context_RA_state_get(struct _Unwind_Context *context) +{ + const int index = AARCH64_DWARF_REGNUM_RA_STATE; + return _Unwind_GetGR (context, index) & AARCH64_DWARF_RA_STATE_MASK; +} + +static inline aarch64_RA_signing_method_t +aarch64_fs_RA_state_get(_Unwind_FrameState const* fs) { - const struct dwarf_fde *fde = _Unwind_Find_FDE (context->bases.func, - &context->bases); - if (fde != NULL) + const int index = AARCH64_DWARF_REGNUM_RA_STATE; + return fs->regs.reg[index].loc.offset & AARCH64_DWARF_RA_STATE_MASK; +} + +static inline void +aarch64_fs_RA_state_set(_Unwind_FrameState *fs, + aarch64_RA_signing_method_t signing_method) +{ + fs->regs.reg[AARCH64_DWARF_REGNUM_RA_STATE].loc.offset = signing_method; +} + +static inline void +aarch64_fs_RA_state_toggle(_Unwind_FrameState *fs) +{ + aarch64_RA_signing_method_t signing_method = aarch64_fs_RA_state_get(fs); + gcc_assert (signing_method == AARCH64_RA_no_signing || + signing_method == AARCH64_RA_signing_SP); + aarch64_fs_RA_state_set(fs, (signing_method == AARCH64_RA_no_signing) + ? AARCH64_RA_signing_SP + : AARCH64_RA_no_signing); +} + +/* CIE handler for custom augmentation string. */ +static inline bool +aarch64_cie_aug_handler(_Unwind_FrameState *fs, unsigned char aug) +{ + // AArch64 B-key pointer authentication. + if (aug == 'B') { - const struct dwarf_cie *cie = get_cie (fde); - if (cie != NULL) - { - const unsigned char *aug_str = cie->augmentation; - return __builtin_strchr ((const char *) aug_str, - 'B') == NULL ? 0 : 1; - } + fs->regs.signing_key = AARCH64_PAUTH_KEY_B; + return true; } - return 0; + return false; } -/* Do AArch64 private extraction on ADDR_WORD based on context info CONTEXT and - unwind frame info FS. If ADDR_WORD is signed, we do address authentication - on it using CFA of current frame. */ +/* At the entrance of a new frame, some cached information from the CIE/FDE, + * and registers values related to architectural extensions require a default + * initialization. + * If any of those values related to architecture extensions had to be saved + * for the next frame, it should be done via the architecture extensions handler + * MD_FROB_UPDATE_CONTEXT in uw_update_context_1 (libgcc/unwind-dw2.c). */ +static inline void +aarch64_arch_extension_frame_init (struct _Unwind_Context *context ATTRIBUTE_UNUSED, + _Unwind_FrameState *fs) +{ + // Reset previously cached CIE/FDE information. + fs->regs.signing_key = AARCH64_PAUTH_KEY_A; + + // Reset some registers. + // Note: the associated fs->how table is automatically reset to REG_UNSAVED in + // uw_frame_state_for (libgcc/unwind-dw2.c). REG_UNSAVED means that whatever + // was in the previous context is the current register value. In other words, + // the next context inherits by default the previous value for a register. + // To keep this logic coherent with some architecture extensions, we need to + // reinitialize fs->how for some registers to REG_ARCHEXT. + const int reg = AARCH64_DWARF_REGNUM_RA_STATE; + fs->regs.how[reg] = REG_ARCHEXT; + aarch64_fs_RA_state_set(fs, AARCH64_RA_no_signing); +} +/* Do AArch64 private extraction on ADDR_WORD based on context info CONTEXT and + unwind frame info FS. If ADDR_WORD is signed, we do address authentication + on it using CFA of current frame. + Note: this function is called after uw_update_context_1 in uw_update_context. + uw_update_context_1 is the function in which val expression are computed. Thus + if DW_CFA_val_expression is used, the value of the RA state register is stored + in CONTEXT, not FS. (more details about when DW_CFA_val_expression is used in + the next comment below) */ static inline void * aarch64_demangle_return_addr (struct _Unwind_Context *context, _Unwind_FrameState *fs, _Unwind_Word addr_word) { void *addr = (void *)addr_word; - const int reg = DWARF_REGNUM_AARCH64_RA_STATE; - - if (fs->regs.how[reg] == REG_UNSAVED) - return addr; + const int reg = AARCH64_DWARF_REGNUM_RA_STATE; + + // In libgcc, REG_ARCHEXT means that the RA state register was set by an AArch64 + // DWARF instruction and contains a valid value. + // Return-address signing state is normally toggled by DW_CFA_AARCH64_negate_ra_state + // (also knwon by its alias as DW_CFA_GNU_window_save). + // However, RA state register can be set directly via DW_CFA_val_expression + // too. GCC does not generate such CFI but some other compilers reportedly do. + // (see PR104689 for more details). + // Any other value than REG_ARCHEXT should be interpreted as if the RA state register + // is set by another DWARF instruction, and the value is fetchable via _Unwind_GetGR. + aarch64_RA_signing_method_t signing_method = AARCH64_RA_no_signing; + if (fs->regs.how[reg] == REG_ARCHEXT) + { + signing_method = aarch64_fs_RA_state_get(fs); + } + else if (fs->regs.how[reg] != REG_UNSAVED) + { + signing_method = aarch64_context_RA_state_get(context); + + // If the value was set in context, CONTEXT->by_value was set to 1. + // uw_install_context_1 contains an assert on by_value, to check that all + // registers values have been resolved before installing the context. + // This will make the unwinding crash if we don't reset CONTEXT->by_value, + // and CONTEXT->reg[reg]. + context->reg[reg] = _Unwind_Get_Unwind_Context_Reg_Val(0x0); + context->by_value[reg] = 0; + } - /* Return-address signing state is toggled by DW_CFA_GNU_window_save (where - REG_UNSAVED/REG_UNSAVED_ARCHEXT means RA signing is disabled/enabled), - or set by a DW_CFA_expression. */ - if (fs->regs.how[reg] == REG_UNSAVED_ARCHEXT - || (_Unwind_GetGR (context, reg) & 0x1) != 0) + if (signing_method == AARCH64_RA_signing_SP) { _Unwind_Word salt = (_Unwind_Word) context->cfa; - if (aarch64_cie_signed_with_b_key (context) != 0) + if (fs->regs.signing_key == AARCH64_PAUTH_KEY_B) return __builtin_aarch64_autib1716 (addr, salt); return __builtin_aarch64_autia1716 (addr, salt); } + // else {} // signing_method == AARCH64_RA_no_signing, nothing to do. return addr; } diff --git a/libgcc/unwind-dw2-execute_cfa.h b/libgcc/unwind-dw2-execute_cfa.h index a6b249f9ad6..2ea78c4ef8d 100644 --- a/libgcc/unwind-dw2-execute_cfa.h +++ b/libgcc/unwind-dw2-execute_cfa.h @@ -271,23 +271,33 @@ fs->regs.how[reg] = REG_SAVED_VAL_EXP; fs->regs.reg[reg].loc.exp = insn_ptr; } + // Don't execute the expression, but jump over it by adding + // DW_FORM_block's size to insn_ptr. insn_ptr = read_uleb128 (insn_ptr, &utmp); insn_ptr += utmp; break; - case DW_CFA_GNU_window_save: #if defined (__aarch64__) && !defined (__ILP32__) - /* This CFA is multiplexed with Sparc. On AArch64 it's used to toggle - return address signing status. REG_UNSAVED/REG_UNSAVED_ARCHEXT - mean RA signing is disabled/enabled. */ - reg = DWARF_REGNUM_AARCH64_RA_STATE; - gcc_assert (fs->regs.how[reg] == REG_UNSAVED - || fs->regs.how[reg] == REG_UNSAVED_ARCHEXT); - if (fs->regs.how[reg] == REG_UNSAVED) - fs->regs.how[reg] = REG_UNSAVED_ARCHEXT; - else - fs->regs.how[reg] = REG_UNSAVED; + case DW_CFA_AARCH64_negate_ra_state: + // This CFA is multiplexed with Sparc. + // On AArch64 it's used to toggle the status of return address signing + // with SP as a diversifier. + // - REG_ARCHEXT means that the RA state register in FS contains a + // valid value, and that no other DWARF directive has changed the value + // of this register. + // - any other value is not compatible with negating the RA state. + reg = AARCH64_DWARF_REGNUM_RA_STATE; + + // /!\ Mixing DW_CFA_val_expression with DW_CFA_AARCH64_negate_ra_state + // will result in an undefined behavior (likely an unwinding failure), + // as the chronology of the DWARF directives will be broken. + gcc_assert (fs->regs.how[reg] == REG_ARCHEXT); + + // Toggle current state + aarch64_fs_RA_state_toggle(fs); + break; #else + case DW_CFA_GNU_window_save: /* ??? Hardcoded for SPARC register window configuration. */ if (__LIBGCC_DWARF_FRAME_REGISTERS__ >= 32) for (reg = 16; reg < 32; ++reg) @@ -295,8 +305,8 @@ fs->regs.how[reg] = REG_SAVED_OFFSET; fs->regs.reg[reg].loc.offset = (reg - 16) * sizeof (void *); } -#endif break; +#endif case DW_CFA_GNU_args_size: insn_ptr = read_uleb128 (insn_ptr, &utmp); diff --git a/libgcc/unwind-dw2.c b/libgcc/unwind-dw2.c index 0849e89cd34..fb60853825d 100644 --- a/libgcc/unwind-dw2.c +++ b/libgcc/unwind-dw2.c @@ -501,11 +501,11 @@ extract_cie_info (const struct dwarf_cie *cie, struct _Unwind_Context *context, fs->signal_frame = 1; aug += 1; } - /* aarch64 B-key pointer authentication. */ - else if (aug[0] == 'B') - { - aug += 1; - } + +#if defined(MD_ARCH_EXTENSION_CIE_AUG_HANDLER) + else if (MD_ARCH_EXTENSION_CIE_AUG_HANDLER(fs, aug[0])) + aug += 1; +#endif /* Otherwise we have an unknown augmentation string. Bail unless we saw a 'z' prefix. */ @@ -996,6 +996,9 @@ uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs) memset (&fs->regs.how[0], 0, sizeof (*fs) - offsetof (_Unwind_FrameState, regs.how[0])); +#if defined(MD_ARCH_EXTENSION_FRAME_INIT) + MD_ARCH_EXTENSION_FRAME_INIT(context, fs); +#endif context->args_size = 0; context->lsda = 0; @@ -1197,7 +1200,11 @@ uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs) { case REG_UNSAVED: case REG_UNDEFINED: - case REG_UNSAVED_ARCHEXT: + case REG_ARCHEXT: // If the value depends on an augmenter, then there is + // no processing to do here, and the value computation + // should be delayed until the architecture handler + // computes the value correctly based on the augmenter + // information. break; case REG_SAVED_OFFSET: diff --git a/libgcc/unwind-dw2.h b/libgcc/unwind-dw2.h index 0dd8611f697..b75f4c65f98 100644 --- a/libgcc/unwind-dw2.h +++ b/libgcc/unwind-dw2.h @@ -22,16 +22,17 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see . */ -enum { +enum register_rule +{ REG_UNSAVED, REG_SAVED_OFFSET, REG_SAVED_REG, REG_SAVED_EXP, REG_SAVED_VAL_OFFSET, REG_SAVED_VAL_EXP, - REG_UNSAVED_ARCHEXT, /* Target specific extension. */ + REG_ARCHEXT, /* Target specific extension. */ REG_UNDEFINED -}; +} __attribute__((packed)); /* The result of interpreting the frame unwind info for a frame. This is all symbolic at this point, as none of the values can @@ -49,7 +50,7 @@ typedef struct const unsigned char *exp; } loc; } reg[__LIBGCC_DWARF_FRAME_REGISTERS__+1]; - unsigned char how[__LIBGCC_DWARF_FRAME_REGISTERS__+1]; + enum register_rule how[__LIBGCC_DWARF_FRAME_REGISTERS__+1]; enum { CFA_UNSET, @@ -65,6 +66,14 @@ typedef struct _Unwind_Sword cfa_offset; _Unwind_Word cfa_reg; const unsigned char *cfa_exp; + + /* Architecture extensions information from CIE/FDE. + * Note: those information have to be saved in struct frame_state_reg_info + * instead of _Unwind_FrameState as DW_CFA_restore_state has to be able to + * restore them. */ +#if defined(__aarch64__) && !defined (__ILP32__) + unsigned char signing_key; +#endif } regs; /* The PC described by the current frame state. */