From patchwork Wed Oct 18 15:02:44 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Victor Do Nascimento X-Patchwork-Id: 1850946 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=armh.onmicrosoft.com header.i=@armh.onmicrosoft.com header.a=rsa-sha256 header.s=selector2-armh-onmicrosoft-com header.b=UZ0YrKU9; dkim=pass (1024-bit key) header.d=armh.onmicrosoft.com header.i=@armh.onmicrosoft.com header.a=rsa-sha256 header.s=selector2-armh-onmicrosoft-com header.b=UZ0YrKU9; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=8.43.85.97; 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 [8.43.85.97]) (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 4S9Z1K6yfQz20Zj for ; Thu, 19 Oct 2023 02:06:13 +1100 (AEDT) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id EDA483858000 for ; Wed, 18 Oct 2023 15:06:11 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from EUR04-HE1-obe.outbound.protection.outlook.com (mail-he1eur04on2078.outbound.protection.outlook.com [40.107.7.78]) by sourceware.org (Postfix) with ESMTPS id D87A83858C2F for ; Wed, 18 Oct 2023 15:04:35 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org D87A83858C2F 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 D87A83858C2F Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=40.107.7.78 ARC-Seal: i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1697641489; cv=pass; b=LWbxVQj3H8WKZ5C5ZWonWhjZeZDAG5Bdfpkm6yf8JfXfBoMDtPOh+HuV9yMSCSo1F7ue2TW96DFDUPZYoCKzJs8XcPPfCrpZAx7RBegsH6x1B4IKNpMTG9UjqBXtrsnzO0dihjfcaPT1J9qVUMcmwYi/6+BNSSnet4r3X9B32Pg= ARC-Message-Signature: i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1697641489; c=relaxed/simple; bh=VkL3UdsEnOMHZBxUDilrEWxNuqG5ZOHApACDueFeSJM=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=S6woEhCVRZ37CMSyQSRAW9kZA4uY6H0YEINNm/fSm6JeNcawEmhtw7sT3bKblobTYt0WKSBcNEV5/3hTmjPn3f/RoaYQ/3yLkGj+rcLHLEEh/sEyQgdxQQkIEmuMh2hDb/G34fCoOV6qdbMlZCMatR9Pupwywi50cAYAESkY5OI= ARC-Authentication-Results: i=2; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com; s=selector2-armh-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=mWulP5M5p94mp6w5pSHh/OF8Dnw9OfWOsKKK3TJR0Mg=; b=UZ0YrKU9Axu2A1UuRC1gC9nlGnl6LE1Yz+fB6MNRs74Uo8T4KyvoGJ2SDKQA4FPdoMeD9zSRZTUiCkYoZ1Yzvbiv9OwzdyuSakt1Q25hu1JUKsiXatBATidPHdBIvTwbX56nfqPpsA6wB+ihfqO9Gdog5VHk+8KVkJpsslF/Z8s= Received: from AM0PR04CA0057.eurprd04.prod.outlook.com (2603:10a6:208:1::34) by PAWPR08MB9029.eurprd08.prod.outlook.com (2603:10a6:102:341::15) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6886.35; Wed, 18 Oct 2023 15:04:32 +0000 Received: from AM7EUR03FT019.eop-EUR03.prod.protection.outlook.com (2603:10a6:208:1:cafe::af) by AM0PR04CA0057.outlook.office365.com (2603:10a6:208:1::34) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6907.21 via Frontend Transport; Wed, 18 Oct 2023 15:04:32 +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=armh.onmicrosoft.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 AM7EUR03FT019.mail.protection.outlook.com (100.127.140.245) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6907.20 via Frontend Transport; Wed, 18 Oct 2023 15:04:32 +0000 Received: ("Tessian outbound d9a8e74be042:v215"); Wed, 18 Oct 2023 15:04:32 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: ac82b19fdd158b77 X-CR-MTA-TID: 64aa7808 Received: from b4f81a10c6a0.1 by 64aa7808-outbound-1.mta.getcheckrecipient.com id 7DBBB658-3C15-40D0-B663-4708EF380C55.1; Wed, 18 Oct 2023 15:04:25 +0000 Received: from EUR03-AM7-obe.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id b4f81a10c6a0.1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Wed, 18 Oct 2023 15:04:25 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=D1E3yh5c98KUxIgiUyU3NYS8nChr1F8QR4lSWIQYqV6KL7Peg3lCosnd6tXOtLtWYz0nMYEAyIfs3xlde9K7TzduK4q8AEWIFBoQKkh6K+kfLgM61Zw5VbiredDu5PJSXAbIgwB7m80+psGBdIxz1Xkdw6GHvjFQM+IwGILvmSFD64WCZGvXTSPwTJrRYzBqfPaQmzwMQS0qTrLaLPtWMyjXj0gMkyFfX951wEnO7j+MIxI0lPihIwXdOV9aCdxLoqf3fGwCJ6GmSz9flJh178UHtjbYRfq+cHFihGNJPbHWhIIZ40YD2uuirYOm6ao06zTyrNGbr42B3L6P+/4zRQ== 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=mWulP5M5p94mp6w5pSHh/OF8Dnw9OfWOsKKK3TJR0Mg=; b=VXBIA2QvSphTwde3gE/jeJAwjJCwjH8nbFvbIxzZ6PPLkFt+qxJawXJPOq+6nHXyPlHluyriR0MO+86dGeglCVuUPoyIRxgUK5aUn5qWXFoPkDVIguW7JpoZWmXi53xGc2XQUF8DRKz7pY86vNRha3naaQrrcNNGuWl/8/Eck3BAQZ76mzDDI3bfIZ3CMQQPkd8vwnUP4ZROCNrDR4MMSaTsM9YbTd7fxMyqwANF62yyaCQJ/L9CWCYUQPNz752+adS2SdIgOcogtslbBnhISlID/nHsmQLSWqo/Ke9RVzgKrdl3ddM/eQFNlUJwu3kDH0Isv0wmu3UafhE3KRIRqA== 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 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com; s=selector2-armh-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=mWulP5M5p94mp6w5pSHh/OF8Dnw9OfWOsKKK3TJR0Mg=; b=UZ0YrKU9Axu2A1UuRC1gC9nlGnl6LE1Yz+fB6MNRs74Uo8T4KyvoGJ2SDKQA4FPdoMeD9zSRZTUiCkYoZ1Yzvbiv9OwzdyuSakt1Q25hu1JUKsiXatBATidPHdBIvTwbX56nfqPpsA6wB+ihfqO9Gdog5VHk+8KVkJpsslF/Z8s= Received: from DUZP191CA0042.EURP191.PROD.OUTLOOK.COM (2603:10a6:10:4f8::6) by PA4PR08MB5952.eurprd08.prod.outlook.com (2603:10a6:102:e9::10) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6907.22; Wed, 18 Oct 2023 15:04:19 +0000 Received: from DU6PEPF0000B61E.eurprd02.prod.outlook.com (2603:10a6:10:4f8:cafe::30) by DUZP191CA0042.outlook.office365.com (2603:10a6:10:4f8::6) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6886.36 via Frontend Transport; Wed, 18 Oct 2023 15:04:19 +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 DU6PEPF0000B61E.mail.protection.outlook.com (10.167.8.133) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.6907.20 via Frontend Transport; Wed, 18 Oct 2023 15:04:19 +0000 Received: from AZ-NEU-EX04.Arm.com (10.251.24.32) 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.32; Wed, 18 Oct 2023 15:04:16 +0000 Received: from e125768.cambridge.arm.com (10.2.78.50) by mail.arm.com (10.251.24.32) with Microsoft SMTP Server id 15.1.2507.32 via Frontend Transport; Wed, 18 Oct 2023 15:04:16 +0000 From: Victor Do Nascimento To: CC: , , , Victor Do Nascimento Subject: [PATCH V2 3/7] aarch64: Implement system register validation tools Date: Wed, 18 Oct 2023 16:02:44 +0100 Message-ID: <20231018150310.253793-4-victor.donascimento@arm.com> X-Mailer: git-send-email 2.41.0 In-Reply-To: <20231018150310.253793-1-victor.donascimento@arm.com> References: <20231018150310.253793-1-victor.donascimento@arm.com> MIME-Version: 1.0 X-EOPAttributedMessage: 1 X-MS-TrafficTypeDiagnostic: DU6PEPF0000B61E:EE_|PA4PR08MB5952:EE_|AM7EUR03FT019:EE_|PAWPR08MB9029:EE_ X-MS-Office365-Filtering-Correlation-Id: ccd6896c-ead5-4c4d-98c1-08dbcfeb88ce x-checkrecipientrouted: true NoDisclaimer: true X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam-Untrusted: BCL:0; X-Microsoft-Antispam-Message-Info-Original: 26/fsqbp3uGZoBdRUayQwSMUAvspvlZA5fdp03oOSsVSCXMz60A2spq0M2wQBT5NwnYK6SSltDrPGKxzVJoX4emAsQHp1I6PRs0to2wywalKBUXSQyyyg6nDdzgSGsL6uhmYpcWWRm8zhQW9fTFYmIqIX61MTIDaAfrfA97zOKyfUx+FPsJ3hzmDAsr5TtJxUtDap5Mkrhd1fciMJpQ3yvZlX9Xy1b55wn9K3hCNff5moUv2Eu4774L959iLMtPSVmEtfo2xpCByKtLfD0/nuuO2UfR3cHB8ygI1Z0U7yYCgsQ4PZdik7LOhxyW69ukiP1ccRxUfZNQmlYxDZ4hZznfIuZfZgM2j3qdwaOkwbd6R7HI/WmILfJc72bA7WuNSmbf0top9MLcgOaQwynD6wg7WNbruhffjlQaTf0phVsY2EAASNBJkVrcwuo4M0JcFfSLD3DlcpL7YbPCjKw2QbGFIl0/ox3/YsUrrgrmzsLVrIdEk+r/XeMTIhp1IDTCTRlBbc83vYQFo4AoQp6UniREqZ6XzARN+dLJMaiG275CsJWV48iJep7iYagOZ0n+wCqLkz7PSgTBDCIVV4Z1qUQxHIBIb8/TJ01yFSHdGoi2neBgAhfWEdj+qk2gM/96QKEc5AeQLrGJtcA5u83k8bykS1FKO0zht02Egexe/YfEthV+JWIN0gi1tluxzrctVhZdQ51aW3s+WjA9pQd4VNenfniWJpusBmX5DxJx3tJMBrtvzV+E7EX5gcmLyVpAOIC+XycX2p/m2EaTIkcJ+zg== 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:(13230031)(4636009)(39860400002)(396003)(346002)(376002)(136003)(230922051799003)(451199024)(64100799003)(186009)(1800799009)(82310400011)(40470700004)(36840700001)(46966006)(316002)(6916009)(86362001)(6666004)(83380400001)(40480700001)(2906002)(70206006)(7696005)(54906003)(478600001)(356005)(82740400003)(26005)(2616005)(70586007)(40460700003)(1076003)(81166007)(36756003)(336012)(426003)(36860700001)(8676002)(8936002)(4326008)(5660300002)(41300700001)(47076005)(36900700001); DIR:OUT; SFP:1101; X-MS-Exchange-Transport-CrossTenantHeadersStamped: PA4PR08MB5952 X-MS-Exchange-Transport-CrossTenantHeadersStripped: AM7EUR03FT019.eop-EUR03.prod.protection.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: d56171e7-7fc7-437c-4ced-08dbcfeb8157 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: YNQo8aGfmu1RVEKtoP3vd6Rm2kw3qeGJQUcc+tLuFl+re2lO1oBonvyO0EtlDzEvArb8teLLyVlyhDecuMRnRj8MAd4D97vdQLP43FC1mtFQVNpqss7j0wn3SgIGHO12m6pMUPH1jBoOg87E2BCYaE75FHdjc3mBbszv0cekg3+9Bcx+j783glJX7X8u0016QI+Wf7v3a9wgSxD9u/2orTWYTLNotsY35hpNcrqms7qdviqvRqkeIYXpVgJeMDtcJDgsArLr+h2Mxzu5X6oNhLPVOkJ+WVk4MkEwaA1ekKXp3DkkZMaNL/n9Ri1/2geLxhsnQe08onv9MgQUtiZ17IPmaXpx0CmnMz+B8830TXWF6LtLl7F1QPj/xsDt27HljH9ffW6id0I1kCf7s9DhvSfsnokKKNOpvKCmAyaoOoiSm2mK8tvhPapzwAKJBJyvxxCRtyPHNNJeIoI18zz8dq7mgNPVB46OexUVEKIiZ6VNL0TNhtGIzgcLmNGYDCg38lL6u+MMLxJmp2gl+y/YenvFKI/H1pISQnsoUhCmaiheHJpN/7sPTuCRp4NTHUhQPxnvQJ/0o6eBveYIiKgZWwZZf27iZxvdiPIyyExmtNEARmZUHT3EDMKd+5gFfst2rVAUNCidKVlyOoqvaQwfx/ndu3y5WHcNe2WT8MmdAtKg/UoAorU2/h++6boC7HXXFc0qgcOy8p4gEh6TmgCJIjWXJz5o4X4R2C/8XR1THMYfy0/go7HWyMAagdPBd0Jh 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:(13230031)(4636009)(136003)(376002)(396003)(346002)(39860400002)(230922051799003)(451199024)(64100799003)(82310400011)(1800799009)(186009)(36840700001)(40470700004)(46966006)(40460700003)(40480700001)(6666004)(54906003)(70586007)(6916009)(70206006)(478600001)(41300700001)(426003)(2616005)(36860700001)(83380400001)(47076005)(86362001)(82740400003)(26005)(316002)(7696005)(1076003)(336012)(81166007)(36756003)(8676002)(5660300002)(8936002)(2906002)(4326008); DIR:OUT; SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 18 Oct 2023 15:04:32.1781 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: ccd6896c-ead5-4c4d-98c1-08dbcfeb88ce 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: AM7EUR03FT019.eop-EUR03.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAWPR08MB9029 X-Spam-Status: No, score=-12.6 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, FORGED_SPF_HELO, GIT_PATCH_0, KAM_DMARC_NONE, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, 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 Given the implementation of a mechanism of encoding system registers into GCC, this patch provides the mechanism of validating their use by the compiler. In particular, this involves: 1. Ensuring a supplied string corresponds to a known system register name. System registers can be accessed either via their name (e.g. `SPSR_EL1') or their encoding (e.g. `S3_0_C4_C0_0'). Register names are validated using a hash map, mapping known system register names to its corresponding `sysreg_t' struct, which is populated from the `aarch64_system_regs.def' file. Register name validation is done via `lookup_sysreg_map', while the encoding naming convention is validated via a parser implemented in this patch - `is_implem_def_reg'. 2. Once a given register name is deemed to be valid, it is checked against a further 2 criteria: a. Is the referenced register implemented in the target architecture? This is achieved by comparing the ARCH field in the relevant SYSREG entry from `aarch64_system_regs.def' against `aarch64_feature_flags' flags set at compile-time. b. Is the register being used correctly? Check the requested operation against the FLAGS specified in SYSREG. This prevents operations like writing to a read-only system register. gcc/ChangeLog: * gcc/config/aarch64/aarch64-protos.h (aarch64_valid_sysreg_name_p): New. (aarch64_retrieve_sysreg): Likewise. * gcc/config/aarch64/aarch64.cc (is_implem_def_reg): Likewise. (aarch64_valid_sysreg_name_p): Likewise. (aarch64_retrieve_sysreg): Likewise. (aarch64_register_sysreg): Likewise. (aarch64_init_sysregs): Likewise. (aarch64_lookup_sysreg_map): Likewise. * gcc/config/aarch64/predicates.md (aarch64_sysreg_string): New. --- gcc/config/aarch64/aarch64-protos.h | 2 + gcc/config/aarch64/aarch64.cc | 146 ++++++++++++++++++++++++++++ gcc/config/aarch64/predicates.md | 4 + 3 files changed, 152 insertions(+) diff --git a/gcc/config/aarch64/aarch64-protos.h b/gcc/config/aarch64/aarch64-protos.h index 60a55f4bc19..a134e2fcf8e 100644 --- a/gcc/config/aarch64/aarch64-protos.h +++ b/gcc/config/aarch64/aarch64-protos.h @@ -830,6 +830,8 @@ bool aarch64_simd_shift_imm_p (rtx, machine_mode, bool); bool aarch64_sve_ptrue_svpattern_p (rtx, struct simd_immediate_info *); bool aarch64_simd_valid_immediate (rtx, struct simd_immediate_info *, enum simd_immediate_check w = AARCH64_CHECK_MOV); +bool aarch64_valid_sysreg_name_p (const char *); +const char *aarch64_retrieve_sysreg (char *, bool); rtx aarch64_check_zero_based_sve_index_immediate (rtx); bool aarch64_sve_index_immediate_p (rtx); bool aarch64_sve_arith_immediate_p (machine_mode, rtx, bool); diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc index 69de2366424..816c4b69fc8 100644 --- a/gcc/config/aarch64/aarch64.cc +++ b/gcc/config/aarch64/aarch64.cc @@ -85,6 +85,7 @@ #include "config/arm/aarch-common.h" #include "config/arm/aarch-common-protos.h" #include "ssa.h" +#include "hash-map.h" /* This file should be included last. */ #include "target-def.h" @@ -2845,6 +2846,52 @@ const sysreg_t sysreg_structs[] = const unsigned nsysreg = TOTAL_ITEMS; #undef TOTAL_ITEMS +using sysreg_map_t = hash_map; +static sysreg_map_t *sysreg_map = nullptr; + +/* Map system register names to their hardware metadata: Encoding, + feature flags and architectural feature requirements, all of which + are encoded in a sysreg_t struct. */ +void +aarch64_register_sysreg (const char *name, const sysreg_t *metadata) +{ + bool dup = sysreg_map->put (name, metadata); + gcc_checking_assert (!dup); +} + +/* Lazily initialize hash table for system register validation, + checking the validity of supplied register name and returning + register's associated metadata. */ +static void +aarch64_init_sysregs (void) +{ + gcc_assert (!sysreg_map); + sysreg_map = new sysreg_map_t; + gcc_assert (sysreg_map); + + for (unsigned i = 0; i < nsysreg; i++) + { + const sysreg_t *reg = sysreg_structs + i; + aarch64_register_sysreg (reg->name , reg); + } +} + +/* No direct access to the sysreg hash-map should be made. Doing so + risks trying to acess an unitialized hash-map and dereferencing the + returned double pointer without due care risks dereferencing a + null-pointer. */ +const sysreg_t * +aarch64_lookup_sysreg_map (const char *regname) +{ + if (!sysreg_map) + aarch64_init_sysregs (); + + const sysreg_t **sysreg_entry = sysreg_map->get (regname); + if (sysreg_entry != NULL) + return *sysreg_entry; + return NULL; +} + /* The current tuning set. */ struct tune_params aarch64_tune_params = generic_tunings; @@ -28053,6 +28100,105 @@ aarch64_pars_overlap_p (rtx par1, rtx par2) return false; } +/* Parse an implementation-defined system register name of + the form S[0-3]_[0-7]_C[0-15]_C[0-15]_[1-7]. + Return true if name matched against above pattern, false + otherwise. */ +bool +is_implem_def_reg (const char *regname) +{ + /* Check for implementation-defined system registers. */ + int name_len = strlen (regname); + if (name_len < 12 || name_len > 14) + return false; + + int pos = 0, i = 0, j = 0; + char n[3] = {0}, m[3] = {0}; + if (regname[pos] != 's' && regname[pos] != 'S') + return false; + pos++; + if (regname[pos] < '0' || regname[pos] > '3') + return false; + pos++; + if (regname[pos++] != '_') + return false; + if (regname[pos] < '0' || regname[pos] > '7') + return false; + pos++; + if (regname[pos++] != '_') + return false; + if (regname[pos] != 'c' && regname[pos] != 'C') + return false; + pos++; + while (regname[pos] != '_') + { + if (i > 2) + return false; + if (!ISDIGIT (regname[pos])) + return false; + n[i++] = regname[pos++]; + } + if (atoi (n) > 15) + return false; + if (regname[pos++] != '_') + return false; + if (regname[pos] != 'c' && regname[pos] != 'C') + return false; + pos++; + while (regname[pos] != '_') + { + if (j > 2) + return false; + if (!ISDIGIT (regname[pos])) + return false; + m[j++] = regname[pos++]; + } + if (atoi (m) > 15) + return false; + if (regname[pos++] != '_') + return false; + if (regname[pos] < '0' || regname[pos] > '7') + return false; + return true; +} + +/* Validate REGNAME against the permitted system register names, or a + generic sysreg specification. For use in back-end predicate + `aarch64_sysreg_string'. */ +bool +aarch64_valid_sysreg_name_p (const char *regname) +{ + const sysreg_t *sysreg = aarch64_lookup_sysreg_map (regname); + if (sysreg == NULL) + return is_implem_def_reg (regname); + return (aarch64_isa_flags & sysreg->arch_reqs); +} + +/* Validate REGNAME against the permitted system register names, or a + generic sysreg specification. WRITE_P is true iff the register is + being written to. */ +const char * +aarch64_retrieve_sysreg (char *regname, bool write_p) +{ + const sysreg_t *sysreg = aarch64_lookup_sysreg_map (regname); + if (sysreg == NULL) + { + if (is_implem_def_reg (regname)) + return (const char *) regname; + else + return NULL; + } + if ((write_p && (sysreg->properties & F_REG_READ)) + || (!write_p && (sysreg->properties & F_REG_WRITE))) + return NULL; + if (aarch64_isa_flags & sysreg->arch_reqs) + { + if (sysreg->encoding) + return sysreg->encoding; + } + return NULL; +} + /* Target-specific selftests. */ #if CHECKING_P diff --git a/gcc/config/aarch64/predicates.md b/gcc/config/aarch64/predicates.md index 01de4743974..5f0d242e4a8 100644 --- a/gcc/config/aarch64/predicates.md +++ b/gcc/config/aarch64/predicates.md @@ -20,6 +20,10 @@ (include "../arm/common.md") +(define_predicate "aarch64_sysreg_string" + (and (match_code "const_string") + (match_test "aarch64_valid_sysreg_name_p (XSTR (op, 0))"))) + (define_special_predicate "cc_register" (and (match_code "reg") (and (match_test "REGNO (op) == CC_REGNUM")