From patchwork Thu Sep 19 13:09:23 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Claudio Bantaloukas X-Patchwork-Id: 1987376 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=Kf/Ca5ml; dkim=pass (1024-bit key) header.d=arm.com header.i=@arm.com header.a=rsa-sha256 header.s=selector1 header.b=Kf/Ca5ml; 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 4X8bVB6Jvcz1y1m for ; Thu, 19 Sep 2024 23:10:25 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 22C4A3858C39 for ; Thu, 19 Sep 2024 13:10:23 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05on20601.outbound.protection.outlook.com [IPv6:2a01:111:f403:2614::601]) by sourceware.org (Postfix) with ESMTPS id F16903858C50 for ; Thu, 19 Sep 2024 13:09:54 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org F16903858C50 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 F16903858C50 Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=2a01:111:f403:2614::601 ARC-Seal: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1726751400; cv=pass; b=PVZZ1/30vQCplIzPd5e2Uiz2T48KeLPQNsAevCCGXPdGGpmUZtEcqyWKvDdhntoaF0CTRX/K69Du0dnEOMeJkBi2S1c5AEcNblcWDYAYzFFD7T4egMWjkXrgEyQNnEPhyy0drCq2wRF1jM6+hcF4Cu4m+3TNFojCKgX1Qh6zxq8= ARC-Message-Signature: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1726751400; c=relaxed/simple; bh=QBIqQdSShiuBDSJkTdNfmJBsYkIA8pRN0Y16YEgt9Z8=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=j93MoTDtqNcKVhszkx7Yv3IWxC7pXPWRZhZ+Akv938aY/dtKQw2Vpf1ov8aysZldFpbCMVby8yDL/Q1a6nYnyhgd/7uG7zq34KUnG9ekg3eWGh6UDuZUEezlg0od4lo3g3S6ejdoFHw+8dTVz3aEQ04AImemS0b7GbuB5SCaAeA= ARC-Authentication-Results: i=3; server2.sourceware.org ARC-Seal: i=2; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=pass; b=sz0N/x9CFBRkuFGJUoFljGflp1Uc23N2cx+DzYVCSMqZgRYF93EtRcWVLiZiW+R8uSXOtELlzWR0sABHw50S9fr1sk+2DapFx55JDqr4/hpHZ5JQAeWjX8vFmc8SykLQHlypfz9bllV+oRGaH9gUc2Pkn/woRlO8jlVuaYfMvhuTz0Yf/Zdd47gfW1LPSPEV5XJRzNEGnxiLWgJvrpjBr4imDMk0oqMqaeWt0gPleMDReKFl8P2s5rm2Euvk1oXM4uOUZYocIpErSmUOALl0eDbf9M9i3hWCpPZwKNoLMyYo2Al/PIlZAl5LOLX+dkt6ukekP4DlciUlg/4b5Z4Ukg== 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=X3EDUN4NCQ4k1QtUprEQS5A5nYnU8EzAezWMF4WHGHw=; b=AQzp1eTdrmancN9rtBWx2DgDOCSL6UEiJE9DJApaMmMHzu1B35tXMUR/NbnvsBwzY42S1lDZvl3cAUR5XT1kbSRjmvq+4SDcZ1HAG7OreX1UBO238BWTwjjmbAFocgqObjSBYKK3cawBRLQblvVA+BTbUhrcDN/hbHeyZT0UM7mKiPQyjnRz2gsHXDy2KuSzph9vYy+130X/2/eUKE6O1mrRr+G4qk7cSUI8z3Ki0ijLWdmXHcjr/jqEYJd3xkJNy2WqSE62emXJ7ilHGjbC0+xnQiNelx8yieJSHBjuvxzyCxMtbSnCZ1H0RBMvo64xHRpvVB2zzYEk2FsceFLVNA== 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=X3EDUN4NCQ4k1QtUprEQS5A5nYnU8EzAezWMF4WHGHw=; b=Kf/Ca5mlDdEgyu+/Wcg9zslkAK4kyf/19/ABGQjosgLkb5uB4AXdyJRz9oApbaMkTvRg065cAD5/wbJgxnDICwS6IeM7jGIoMhpPNDUtKUpPW4E/WB4U5YJWlzOjDGT7VZ5z2L1ivuBN6fQOTSmVNoG24usnztlliW8g+u31r6s= Received: from DU6P191CA0008.EURP191.PROD.OUTLOOK.COM (2603:10a6:10:540::20) by DB4PR08MB9285.eurprd08.prod.outlook.com (2603:10a6:10:3f2::21) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.8005.7; Thu, 19 Sep 2024 13:09:47 +0000 Received: from DB1PEPF00039232.eurprd03.prod.outlook.com (2603:10a6:10:540:cafe::92) by DU6P191CA0008.outlook.office365.com (2603:10a6:10:540::20) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7962.26 via Frontend Transport; Thu, 19 Sep 2024 13:09:47 +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 DB1PEPF00039232.mail.protection.outlook.com (10.167.8.105) with Microsoft SMTP Server (version=TLS1_3, cipher=TLS_AES_256_GCM_SHA384) id 15.20.7918.13 via Frontend Transport; Thu, 19 Sep 2024 13:09:47 +0000 Received: ("Tessian outbound 467a4accc038:v457"); Thu, 19 Sep 2024 13:09:46 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: b57be6db25d47f17 X-TessianGatewayMetadata: TiYJZ4KIj18iCrMKxV8tEY+UbwAHWmYtC+lnNvV24761y+tFstlJxuHmv/+mPbnm2jQIoZfEvvDEJavaOe7U6TyWqdFN+fCSkxhpfpz7HElfLE2pQAZldpvocsp7QKq9cjd5GRrJIvrja4akAQlQHI/aMPb9CmILTLoHgmyG2EI= X-CR-MTA-TID: 64aa7808 Received: from Lb11253c83ccb.1 by 64aa7808-outbound-1.mta.getcheckrecipient.com id 6C4D8A95-3911-4F1A-AD72-BEDD4D4BAEE2.1; Thu, 19 Sep 2024 13:09:35 +0000 Received: from EUR03-AM7-obe.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id Lb11253c83ccb.1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Thu, 19 Sep 2024 13:09:35 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=xOxZoFgimr5ZwbVrSn48IX1ISR9hFNxOFB+q1kkG6NxgRgjX8ZSY5rE6Ec9W51fSr0JTsQc7JomlY1CdURFwuegkvhf2E2wx1EEYBqzq6OvPc/MKBTqv/ustbI2DXZstX3JgZkadh3Ik26SYeFDkw7h6mktlp8WEqMHIjlXpyq4SW2rjxlnf7p/uSUY7ZGhM+DdlKpbjqaGcIOa0ofudY1gg76D32zbGbAdm8PL2grjpoKYM23tBbhLC+waqXHS6E1z4x8W3fXPoo5EAdmn7IJ23pU28m4kh/iqGvN+3BTo+8pAEK94x9Jn1nR/7GdTr4h+c+P0HPpjcSkg1Cbo07Q== 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=X3EDUN4NCQ4k1QtUprEQS5A5nYnU8EzAezWMF4WHGHw=; b=DfM1aIl6SPVMztSkWABMrViX5NIgt0/YmZYf3rpxwe4uCYW9yYneCuoIpliP3d/YC0t+SV5vHwBsFmXLhqEf4JIEanFQexpev6U+FbQdDB8KWOcXoUehjygWTgJgH6TfXfxwiM40bJIcbIfPmd4o0wJbN7zMYx4NLpkWF1jhggLcCU5sXM7Ln4dSXulDePaw1H7r0wazcp8LyMGkBjtpj28Jfu5P/F4BsbP7ZBln3uz6cM/VSMDM2oQpG8oAxPSWaWGHpkg+Sf8XSKNOsWnXwWoC/HKxv3Dgqk/CcN226xlzv9P5C4qMIJqqqau7uzSacUAAqxuyvDWTov8i/9UjYg== 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=X3EDUN4NCQ4k1QtUprEQS5A5nYnU8EzAezWMF4WHGHw=; b=Kf/Ca5mlDdEgyu+/Wcg9zslkAK4kyf/19/ABGQjosgLkb5uB4AXdyJRz9oApbaMkTvRg065cAD5/wbJgxnDICwS6IeM7jGIoMhpPNDUtKUpPW4E/WB4U5YJWlzOjDGT7VZ5z2L1ivuBN6fQOTSmVNoG24usnztlliW8g+u31r6s= Received: from AS9PR05CA0206.eurprd05.prod.outlook.com (2603:10a6:20b:495::29) by AS2PR08MB9318.eurprd08.prod.outlook.com (2603:10a6:20b:59a::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7982.16; Thu, 19 Sep 2024 13:09:30 +0000 Received: from AMS1EPF00000045.eurprd04.prod.outlook.com (2603:10a6:20b:495:cafe::78) by AS9PR05CA0206.outlook.office365.com (2603:10a6:20b:495::29) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7962.28 via Frontend Transport; Thu, 19 Sep 2024 13:09:30 +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 AMS1EPF00000045.mail.protection.outlook.com (10.167.16.42) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.7918.13 via Frontend Transport; Thu, 19 Sep 2024 13:09:30 +0000 Received: from AZ-NEU-EXJ01.Arm.com (10.240.25.132) by AZ-NEU-EX03.Arm.com (10.251.24.31) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.39; Thu, 19 Sep 2024 13:09:27 +0000 Received: from AZ-NEU-EX04.Arm.com (10.251.24.32) by AZ-NEU-EXJ01.Arm.com (10.240.25.132) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.39; Thu, 19 Sep 2024 13:09:25 +0000 Received: from 221664dbf3aa.euhpc2.arm.com (10.58.86.32) by mail.arm.com (10.251.24.32) with Microsoft SMTP Server id 15.1.2507.39 via Frontend Transport; Thu, 19 Sep 2024 13:09:25 +0000 From: Claudio Bantaloukas To: CC: Subject: [PATCH v2] aarch64: Add fp8 scalar types Date: Thu, 19 Sep 2024 13:09:23 +0000 Message-ID: <20240919130923.2657996-1-claudio.bantaloukas@arm.com> X-Mailer: git-send-email 2.43.0 MIME-Version: 1.0 X-EOPAttributedMessage: 1 X-MS-TrafficTypeDiagnostic: AMS1EPF00000045:EE_|AS2PR08MB9318:EE_|DB1PEPF00039232:EE_|DB4PR08MB9285:EE_ X-MS-Office365-Filtering-Correlation-Id: 2fd04828-68ba-4790-4884-08dcd8ac564d x-checkrecipientrouted: true NoDisclaimer: true X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam-Untrusted: BCL:0; ARA:13230040|36860700013|1800799024|82310400026|376014; X-Microsoft-Antispam-Message-Info-Original: IP7YyCqWeCww9W67oPN03vVuGe+YIr38zi/mjJd9K470U/zTDJOiFQwEsqPvYzkR/Xojkt6mXn1IgLPi2gkJiqsXPRdPxBG7mBJpVNT8chA1Hui4svcog000Jfsui4fKWp33wil6BnCyxKiMt+7OMYYi2rywM9shaMStkuv07pnl02uVllsmiN9aPHtgdvG1NegzAo4O8hLi0SirTXA0rx7JtKLrUbY1oaGOGOwvz8+CLd7JgeNlDm9v0cqqHdR0qhqa2G2hIsvH/8XZPuzcRZ5SXMEGg8QWs7ByZNRDYPcWpqH/wLQ3suLKOjbh70YR5aPMNSuv8qSXqtlUiJsOxEufWxCYedcPRLgpUqlyPPGELIvfFtnJ1J8o3S+aL1V6Ao9Wz/p4ty82ex0bIOnyL/okwoCohoQoNE66kllyjcn0KfGXjLihnwYiiuyL6qLNcDP9qfKb/TVzDD+xj6xOsiErVkSqkWwx3dfzTKEJnCCoVMBq47d0j9MLERsjob5esTBs01VL0kPlqDU22ymFYFIeKzkjC0cj2ASk3BMgY58HIXLwAy8VnNUCdVGuDJECLR51E/msRqQMXnAD3tZAVXeUvnH8y3ZLMpxCtH9NCKLaA4PjslIEJKmOzEYnfbObgbxDP2c+NgT+JoP1EgvFwR9/NQt9SC4obLF0BOgtkvs+pVLEV8Jj8f51UbN9KxhqXyk4iwUjmPlo3hOv+lNarL1Q5SF9nE31dz6b7xUgh6UfBmJbco/XBH7WvrxQHftfNzCnL1IkAAPQmW43mvICf7Qwr6dVpVbANnerytpkaNkhVx/TdgsLnZ0JkLgD6MXRxoRHXWMy7VBBmZhIvmvcDZFSR214GZY6OQ0EJ2Xdxmps9xapFJUJweUD+vXdlZ+tuqcn6ozABLRxLdo6tJrAaN7t8E8+/fQQLrwUwWlGAweEr5E6kwWOVJG63HnQV+JCgWTJ32wQnbIdJK6i7q2YKZ6PiGCNeOWNjzT25CpyJTg/UBtVRrfuLCSOvMtWWgs1aU/z/bBJTd++cTxCvnI3T5vKTJRk1+f4tV3VyVsr+t1cbm2CLx3zEovXyMHl9LXp0F8tYNL5yaTAAWgfek4LGX2BIP/6blLkVGchX+ovFsmObKn1QIKUzaXFEqp4fEAAM6rArOY2WLeWrVSpQDpI3jkdT4hJkjYqf4onPJo3nlxwuU3rUBWr0M1MpODVhauK8/stBqTihTaAFpkFlM/1hpjyCE1ACkoh1/FJE2NQ/tLmK/bJywMXYUbW551zX0zQeBa/cRCllr3SyvBTcB+jVJpRMUDWHfwPPiAYZbpXkbpt8LwjbT8YmJuHhP2L4nTDvAvFf2R/9F5Fch8U+Qf5yjheQidrR9QTU2A5FVpvGzK7YPlSkVCXX9X2gIDGOGDZxJUP+TcXHr40/qtWOLgShw== 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)(36860700013)(1800799024)(82310400026)(376014); DIR:OUT; SFP:1101; X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS2PR08MB9318 X-MS-Exchange-SkipListedInternetSender: ip=[2603:10a6:20b:495::29]; domain=AS9PR05CA0206.eurprd05.prod.outlook.com X-MS-Exchange-Transport-CrossTenantHeadersStripped: DB1PEPF00039232.eurprd03.prod.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: 4f34f1e0-d479-412a-5f23-08dcd8ac4c04 X-Microsoft-Antispam: BCL:0; ARA:13230040|36860700013|82310400026|376014|1800799024|35042699022; X-Microsoft-Antispam-Message-Info: =?utf-8?q?mqJmlJ7Ajc9jY4bYtKrLhKpzvRZCkhT?= =?utf-8?q?ofxJnF9cNhp3WNrQzCpksI297wexB1OqAAftMQiPPI10mM/ZOZSV8Amqgl9bg5boL?= =?utf-8?q?7N0ekrb6Q4jPeYDmtXSrKTqhy9gC7PR9pNIcBCtUNS9mwAAGhIIwuwdH2YmNf9yR2?= =?utf-8?q?tli8fHjflh21qAjxXlDIOSXFZS0cJgwtM2tTHeNxFJpwJsmij23eQsM9ADXEgQyO2?= =?utf-8?q?DG4kMlTAz9+rjnNG110JdyDMvig2P3gInzwBtrfAM5UyhQ+cMFTIAzzuxGsFB1IL8?= =?utf-8?q?4a9nRwyB4laQWrH4jAOUh1wNL8LEuiLx9N6H4IyOyUXwvSvby1FxKhuSkxTOv7pol?= =?utf-8?q?OIR3VRqTRTrAHnB21r/yGcMkIKda1OhIl9ww44QP/+ljFTYMx80PNUTAJPAMu+73+?= =?utf-8?q?6Y431nEeMbBC7JPs/vqnMs7LvjjebnDN7ySu4ZGu5tnkoosqPLrqVyKoRxJAQLluQ?= =?utf-8?q?mRWVMosZ+oD2hRK+THHuDdQbXhrVfTIKGD++l7ltc/DPk49cBZTdVBHSJ4HeAsRr4?= =?utf-8?q?oD5zCkdEbFKKKyeKqGZp+cW5iog+ZgqSU7HhXfJFKBr9uN9Ov5187hAzsRF9YyPl/?= =?utf-8?q?vCwWxhBdvjk+Bc6HrvT4UY+sAF8Br1qqYi3VHpVM5rSoU7KWFj+sAncnpkQjF8PSh?= =?utf-8?q?syM6mk0g4f5gXuU9mpTljp0Ci86j44NM0DyrIY1JtgVGBT1w7as/+fDndBQqlJwyB?= =?utf-8?q?wcUFXepSiDTeuI7HG0SrQfNjOPR9vwv5Zsn16liclKtsa8m5JCT+HswvH2tQ3z/Rj?= =?utf-8?q?MbdCzbOED4UA8wmyFkRqhDyrx/uOTo7ZDgRd1JEmW4q/mZhzR9PMb6NXFbQyoGIum?= =?utf-8?q?u5lcO2Rt3rJd3jIhXfuBcEui+WTFDqHZCyHjF+iub/xOrESxVT6Ko7+R6wpN9QJdj?= =?utf-8?q?TANW7Dvh0Kit2+25PJgnb+FTaJs7nqImzgIIv0jSntW1gU/JUQMbh/ZtCEaqR589Z?= =?utf-8?q?9+KDlKll0vWfljqLOc26LYZ4Z6yUBeagg6RXwZTO7y5coSKJU59ZswyCZzDcPqlfU?= =?utf-8?q?90cXlLmM+RkCs3lrMzmsuN3PwBgR2RqrRGa/nHAIyaAtx0yvdreWlvYfd6qaRzT43?= =?utf-8?q?B1gknCaX0Tc54il1R6YW0EYO8lj8DBMTwYn+n/zrtda9n4K6NJWTZ2rWLErYj9YDz?= =?utf-8?q?teehm+G/ccdipPVh6kGUueBtjoKbjv6SMJDE4z9gbp7B9FHvLBE8/15o1nPv2Ibrf?= =?utf-8?q?SltgeDQ3nZ/OKmqAgVYCSpcNlbsv2Avww3F//w5xyTgdSazP2dnkdo70RLT5NAJbP?= =?utf-8?q?wvrbvtmGhSXfkSuwSxDukdGMZNDNS5Kg/kmQHmjlxRq/QA4NHAsrxfGt6ZzW6aVUF?= =?utf-8?q?MUcB+jQpoBA7z5VHsSTylZTeQOZrBxaV9Q=3D=3D?= 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)(36860700013)(82310400026)(376014)(1800799024)(35042699022); DIR:OUT; SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 19 Sep 2024 13:09:47.3178 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 2fd04828-68ba-4790-4884-08dcd8ac564d 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: DB1PEPF00039232.eurprd03.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB4PR08MB9285 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, 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 The ACLE defines a new scalar type, __mfp8. This is an opaque 8bit types that can only be used by fp8 intrinsics. Additionally, the mfloat8_t type is made available in arm_neon.h and arm_sve.h as an alias of the same. This implementation uses an unsigned INTEGER_TYPE, with precision 8 to represent __mfp8. Conversions to int and other types are disabled via the TARGET_INVALID_CONVERSION hook. Additionally, operations that are typically available to integer types are disabled via TARGET_INVALID_UNARY_OP and TARGET_INVALID_BINARY_OP hooks. gcc/ChangeLog: * config/aarch64/aarch64-builtins.cc (aarch64_mfp8_type_node): Add node for __mfp8 type. (aarch64_mfp8_ptr_type_node): Add node for __mfp8 pointer type. (aarch64_init_fp8_types): New function to initialise fp8 types and register with language backends. * config/aarch64/aarch64.cc (aarch64_mangle_type): Add ABI mangling for new type. (aarch64_invalid_conversion): Add function implementing TARGET_INVALID_CONVERSION hook that blocks conversion to and from the __mfp8 type. (aarch64_invalid_unary_op): Add function implementing TARGET_UNARY_OP hook that blocks operations on __mfp8 other than &. (aarch64_invalid_binary_op): Extend TARGET_BINARY_OP hook to disallow operations on __mfp8 type. (TARGET_INVALID_CONVERSION): Add define. (TARGET_INVALID_UNARY_OP): Likewise. * config/aarch64/aarch64.h (aarch64_mfp8_type_node): Add node for __mfp8 type. (aarch64_mfp8_ptr_type_node): Add node for __mfp8 pointer type. * config/aarch64/arm_neon.h (mfloat8_t): Add typedef. * config/aarch64/arm_sve.h (mfloat8_t): Likewise. gcc/testsuite/ChangeLog: * g++.target/aarch64/fp8_mangling.C: New tests exercising mangling. * g++.target/aarch64/fp8_scalar_typecheck_2.C: New tests in C++. * gcc.target/aarch64/fp8_scalar_1.c: New tests in C. * gcc.target/aarch64/fp8_scalar_typecheck_1.c: Likewise. --- Hi, Is this ok for master? I do not have commit rights yet, if ok, can someone commit it on my behalf? Regression tested with aarch64-unknown-linux-gnu. Compared to V1 of the patch, in version 2: - mangling for the __mfp8 type was added along with tests - unneeded comments were removed - simplified type checks in hooks - simplified initialization of aarch64_mfp8_type_node - separated mfloat8_t define from other fp types in arm_sve.h - C++ tests were moved to g++.target/aarch64 - added more tests around binary operations, function declaration, type traits - added tests exercising loads and stores from floating point registers Thanks, Claudio Bantaloukas gcc/config/aarch64/aarch64-builtins.cc | 20 + gcc/config/aarch64/aarch64.cc | 54 ++- gcc/config/aarch64/aarch64.h | 5 + gcc/config/aarch64/arm_neon.h | 2 + gcc/config/aarch64/arm_sve.h | 2 + .../g++.target/aarch64/fp8_mangling.C | 44 ++ .../aarch64/fp8_scalar_typecheck_2.C | 381 ++++++++++++++++++ .../gcc.target/aarch64/fp8_scalar_1.c | 134 ++++++ .../aarch64/fp8_scalar_typecheck_1.c | 356 ++++++++++++++++ 9 files changed, 996 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/g++.target/aarch64/fp8_mangling.C create mode 100644 gcc/testsuite/g++.target/aarch64/fp8_scalar_typecheck_2.C create mode 100644 gcc/testsuite/gcc.target/aarch64/fp8_scalar_1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/fp8_scalar_typecheck_1.c diff --git a/gcc/config/aarch64/aarch64-builtins.cc b/gcc/config/aarch64/aarch64-builtins.cc index eb878b933fe..7d17df05a0f 100644 --- a/gcc/config/aarch64/aarch64-builtins.cc +++ b/gcc/config/aarch64/aarch64-builtins.cc @@ -961,6 +961,11 @@ static GTY(()) tree aarch64_simd_intOI_type_node = NULL_TREE; static GTY(()) tree aarch64_simd_intCI_type_node = NULL_TREE; static GTY(()) tree aarch64_simd_intXI_type_node = NULL_TREE; +/* The user-visible __mfp8 type, and a pointer to that type. Used + across the back-end. */ +tree aarch64_mfp8_type_node = NULL_TREE; +tree aarch64_mfp8_ptr_type_node = NULL_TREE; + /* The user-visible __fp16 type, and a pointer to that type. Used across the back-end. */ tree aarch64_fp16_type_node = NULL_TREE; @@ -1721,6 +1726,19 @@ aarch64_init_builtin_rsqrt (void) } } +/* Initialize the backend type that supports the user-visible __mfp8 + type and its relative pointer type. */ + +static void +aarch64_init_fp8_types (void) +{ + aarch64_mfp8_type_node = make_unsigned_type (8); + SET_TYPE_MODE (aarch64_mfp8_type_node, QImode); + + lang_hooks.types.register_builtin_type (aarch64_mfp8_type_node, "__mfp8"); + aarch64_mfp8_ptr_type_node = build_pointer_type (aarch64_mfp8_type_node); +} + /* Initialize the backend types that support the user-visible __fp16 type, also initialize a pointer to that type, to be used when forming HFAs. */ @@ -2125,6 +2143,8 @@ aarch64_general_init_builtins (void) { aarch64_init_fpsr_fpcr_builtins (); + aarch64_init_fp8_types (); + aarch64_init_fp16_types (); aarch64_init_bf16_types (); diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc index 92763d403c7..0ac00027502 100644 --- a/gcc/config/aarch64/aarch64.cc +++ b/gcc/config/aarch64/aarch64.cc @@ -22467,6 +22467,10 @@ aarch64_mangle_type (const_tree type) return "Dh"; } + /* Modal 8 bit floating point types. */ + if (TYPE_MAIN_VARIANT (type) == aarch64_mfp8_type_node) + return "u6__mfp8"; + /* Mangle AArch64-specific internal types. TYPE_NAME is non-NULL_TREE for builtin types. */ if (TYPE_NAME (type) != NULL) @@ -22481,6 +22485,29 @@ aarch64_mangle_type (const_tree type) return NULL; } +/* Implement TARGET_INVALID_CONVERSION. */ + +static const char * +aarch64_invalid_conversion (const_tree fromtype, const_tree totype) +{ + /* Do not allow conversions to/from FP8. But do allow conversions between + volatile and const variants of __mfp8. */ + bool fromtype_is_fp8 + = (TYPE_MAIN_VARIANT (fromtype) == aarch64_mfp8_type_node); + bool totype_is_fp8 = (TYPE_MAIN_VARIANT (totype) == aarch64_mfp8_type_node); + + if (fromtype_is_fp8 && totype_is_fp8) + return NULL; + + if (fromtype_is_fp8) + return N_ ("invalid conversion from type %"); + if (totype_is_fp8) + return N_ ("invalid conversion to type %"); + + /* Conversion allowed. */ + return NULL; +} + /* Implement TARGET_VERIFY_TYPE_CONTEXT. */ static bool @@ -29031,8 +29058,20 @@ aarch64_stack_protect_guard (void) return NULL_TREE; } -/* Return the diagnostic message string if the binary operation OP is - not permitted on TYPE1 and TYPE2, NULL otherwise. */ +/* Implement TARGET_INVALID_UNARY_OP. */ + +static const char * +aarch64_invalid_unary_op (int op, const_tree type) +{ + /* Reject all single-operand operations on __mfp8 except for &. */ + if (TYPE_MAIN_VARIANT (type) == aarch64_mfp8_type_node && op != ADDR_EXPR) + return N_ ("operation not permitted on type %"); + + /* Operation allowed. */ + return NULL; +} + +/* Implement TARGET_INVALID_BINARY_OP. */ static const char * aarch64_invalid_binary_op (int op ATTRIBUTE_UNUSED, const_tree type1, @@ -29046,6 +29085,11 @@ aarch64_invalid_binary_op (int op ATTRIBUTE_UNUSED, const_tree type1, != aarch64_sve::builtin_type_p (type2))) return N_("cannot combine GNU and SVE vectors in a binary operation"); + /* Reject all 2-operand operations on __mfp8. */ + if (TYPE_MAIN_VARIANT (type1) == aarch64_mfp8_type_node + || TYPE_MAIN_VARIANT (type2) == aarch64_mfp8_type_node) + return N_ ("operation not permitted on type %"); + /* Operation allowed. */ return NULL; } @@ -30763,6 +30807,12 @@ aarch64_libgcc_floating_mode_supported_p #undef TARGET_MANGLE_TYPE #define TARGET_MANGLE_TYPE aarch64_mangle_type +#undef TARGET_INVALID_CONVERSION +#define TARGET_INVALID_CONVERSION aarch64_invalid_conversion + +#undef TARGET_INVALID_UNARY_OP +#define TARGET_INVALID_UNARY_OP aarch64_invalid_unary_op + #undef TARGET_INVALID_BINARY_OP #define TARGET_INVALID_BINARY_OP aarch64_invalid_binary_op diff --git a/gcc/config/aarch64/aarch64.h b/gcc/config/aarch64/aarch64.h index 2dfb999bea5..7ef82ce3587 100644 --- a/gcc/config/aarch64/aarch64.h +++ b/gcc/config/aarch64/aarch64.h @@ -1447,6 +1447,11 @@ extern const char *aarch64_rewrite_mcpu (int argc, const char **argv); #define ASM_OUTPUT_POOL_EPILOGUE aarch64_asm_output_pool_epilogue +/* This type is the user-visible __mfp8, and a pointer to that type. We + need it in many places in the backend. Defined in aarch64-builtins.cc. */ +extern GTY(()) tree aarch64_mfp8_type_node; +extern GTY(()) tree aarch64_mfp8_ptr_type_node; + /* This type is the user-visible __fp16, and a pointer to that type. We need it in many places in the backend. Defined in aarch64-builtins.cc. */ extern GTY(()) tree aarch64_fp16_type_node; diff --git a/gcc/config/aarch64/arm_neon.h b/gcc/config/aarch64/arm_neon.h index e376685489d..0092314cf75 100644 --- a/gcc/config/aarch64/arm_neon.h +++ b/gcc/config/aarch64/arm_neon.h @@ -72,6 +72,8 @@ typedef __Poly16_t poly16_t; typedef __Poly64_t poly64_t; typedef __Poly128_t poly128_t; +typedef __mfp8 mfloat8_t; + typedef __fp16 float16_t; typedef float float32_t; typedef double float64_t; diff --git a/gcc/config/aarch64/arm_sve.h b/gcc/config/aarch64/arm_sve.h index aa0bd9909f9..dbc61650df2 100644 --- a/gcc/config/aarch64/arm_sve.h +++ b/gcc/config/aarch64/arm_sve.h @@ -29,6 +29,8 @@ #include #include +typedef __mfp8 mfloat8_t; + typedef __fp16 float16_t; typedef float float32_t; typedef double float64_t; diff --git a/gcc/testsuite/g++.target/aarch64/fp8_mangling.C b/gcc/testsuite/g++.target/aarch64/fp8_mangling.C new file mode 100644 index 00000000000..1dfcaa71f15 --- /dev/null +++ b/gcc/testsuite/g++.target/aarch64/fp8_mangling.C @@ -0,0 +1,44 @@ +/* Test that mfloat8_t mangles differently from uint8_t */ +/* { dg-options "-O1 -march=armv9.4-a+fp8" } */ + +int +foo (__mfp8) +{ + return 1; +} + +int +foo (unsigned char) +{ + return 2; +} + +int +bar (__mfp8 x) +{ + return foo (x); +} +/* { dg-final { scan-assembler-times "\n_Z3fooh:\n" 1 } } */ +/* { dg-final { scan-assembler-times "\n_Z3foou6__mfp8:\n" 1 } } */ + +constexpr __mfp8 cfp8{}; + +constexpr int +fooc (unsigned char) +{ + return 3; +} + +constexpr int +fooc (__mfp8) +{ + return 4; +} + +constexpr int +barc (__mfp8 x) +{ + return fooc (x); +} + +static_assert (barc (cfp8) == 4, "constexpr selects incorrect overload"); diff --git a/gcc/testsuite/g++.target/aarch64/fp8_scalar_typecheck_2.C b/gcc/testsuite/g++.target/aarch64/fp8_scalar_typecheck_2.C new file mode 100644 index 00000000000..61557c95663 --- /dev/null +++ b/gcc/testsuite/g++.target/aarch64/fp8_scalar_typecheck_2.C @@ -0,0 +1,381 @@ +/* Test that mfloat8_t is only usable with intrinsics, thus not convertible. */ +/* { dg-do assemble } */ +/* { dg-options "-O1 -march=armv9.4-a+fp8 -Wno-narrowing" } */ + +#include +#include +#include + +mfloat8_t glob_fp8; + +int is_an_int; +uint8_t is_a_uint8; +int8_t is_an_int8; +short is_a_short_int; +float is_a_float; +double is_a_double; + +uint8_t *uint8_ptr; + +mfloat8_t +invalid_from_fp8 (uint16_t __a) +{ + mfloat8_t b = __a; /* { dg-error "invalid conversion to type 'mfloat8_t'" } */ + return b; +} + +uint16_t +invalid_to_fp8 (mfloat8_t __a) +{ + uint16_t b = __a; /*{ dg-error "invalid conversion from type 'mfloat8_t'" } */ + return b; +} + +mfloat8_t +foo1 (void) +{ + return (mfloat8_t)0x1234; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ +} + +mfloat8_t +foo2 (void) +{ + return (mfloat8_t)(short)0x1234; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ +} + +mfloat8_t +footest (mfloat8_t scalar0) +{ + + /* Initialisation */ + + mfloat8_t scalar1_1; + mfloat8_t scalar1_2 = glob_fp8; + mfloat8_t scalar1_3 + = 0; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_4 + = 0.1; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_5 + = is_a_float; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_6 + = is_an_int; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_8 + = is_a_double; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_9 = is_a_short_int; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_10 + = is_a_uint8; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_11 + = is_an_int8; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + + int initi_1_1 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + float initi_1_2 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + short initi_1_4 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + double initi_1_5 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + uint8_t initi_1_6 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + int8_t initi_1_7 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + mfloat8_t scalar2_1 = {}; + mfloat8_t scalar2_2 = { glob_fp8 }; + mfloat8_t scalar2_3 + = { 0 }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar2_4 + = { 0.1 }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar2_5 = { + is_a_float /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + }; + mfloat8_t scalar2_6 = { + is_an_int /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + }; + mfloat8_t scalar2_8 = { + is_a_double /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + }; + mfloat8_t scalar2_9 = { + is_a_short_int /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + }; + mfloat8_t scalar2_10 = { + is_a_uint8 /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + }; + mfloat8_t scalar2_11 = { + is_an_int8 /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + }; + + int initi_2_1 = { + glob_fp8 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + }; + float initi_2_2 = { + glob_fp8 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + }; + short initi_2_4 = { + glob_fp8 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + }; + double initi_2_5 = { + glob_fp8 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + }; + uint8_t initi_2_6 = { + glob_fp8 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + }; + int8_t initi_2_7 = { + glob_fp8 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + }; + + /* Assignments. */ + + glob_fp8 = glob_fp8; + glob_fp8 = 0; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 = 0.1; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 + = is_a_float; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 + = is_an_int; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 + = is_a_double; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 = is_a_short_int; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 + = is_a_uint8; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 + = is_an_int8; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + + is_an_int + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_a_float + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_a_double + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_a_short_int + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_a_uint8 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_an_int8 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + /* Casting. */ + + (void)glob_fp8; + (mfloat8_t) glob_fp8; + + (int)glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (float)glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (double) + glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (short)glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (uint8_t) + glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (int8_t) + glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + (mfloat8_t) + is_an_int; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t) + is_a_float; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t) + is_a_double; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t) is_a_short_int; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t) + is_a_uint8; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t) + is_an_int8; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + + /* Compound literals. */ + + (mfloat8_t){}; + (mfloat8_t){ glob_fp8 }; + (mfloat8_t){ 0 }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t){ + 0.1 /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + }; + (mfloat8_t){ + is_a_float /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + }; + (mfloat8_t){ + is_an_int /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + }; + (mfloat8_t){ + is_a_double /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + }; + (mfloat8_t){ + is_a_short_int /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + }; + (mfloat8_t){ + is_a_uint8 /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + }; + (mfloat8_t){ + is_an_int8 /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + }; + + (int){ + glob_fp8 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + }; + (float){ + glob_fp8 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + }; + (double){ + glob_fp8 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + }; + (short){ + glob_fp8 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + }; + (uint8_t){ + glob_fp8 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + }; + (int8_t){ + glob_fp8 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + }; + + /* Arrays and Structs. */ + + typedef mfloat8_t array_type[2]; + extern mfloat8_t extern_array[]; + + mfloat8_t array[2]; + mfloat8_t zero_length_array[0]; + mfloat8_t empty_init_array[] = {}; + typedef mfloat8_t some_other_type[is_an_int]; + + struct struct1 + { + mfloat8_t a; + }; + + union union1 + { + mfloat8_t a; + }; + + /* Addressing and dereferencing. */ + + mfloat8_t *fp8_ptr = &scalar0; + scalar0 = *fp8_ptr; + + /* Pointer assignment. */ + + mfloat8_t *fp8_ptr2 = fp8_ptr; + mfloat8_t *fp8_ptr3 = array; + + /* Pointer arithmetic. */ + + ++fp8_ptr; + --fp8_ptr; + fp8_ptr++; + fp8_ptr--; + fp8_ptr += 1; + fp8_ptr -= 1; + fp8_ptr - fp8_ptr2; + fp8_ptr = &fp8_ptr3[0]; + fp8_ptr = &fp8_ptr3[1]; + + /* Simple comparison. */ + scalar0 + > glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + glob_fp8 + == scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 > is_a_float; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_a_float + == scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 > 0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0 == scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 > 0.1; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0.1 == scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 + > is_an_int; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_an_int + == scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + /* Pointer comparison. */ + + fp8_ptr == &scalar0; + fp8_ptr != &scalar0; + fp8_ptr < &scalar0; + fp8_ptr <= &scalar0; + fp8_ptr > &scalar0; + fp8_ptr >= &scalar0; + fp8_ptr == fp8_ptr2; + fp8_ptr != fp8_ptr2; + fp8_ptr < fp8_ptr2; + fp8_ptr <= fp8_ptr2; + fp8_ptr > fp8_ptr2; + fp8_ptr >= fp8_ptr2; + + /* Conditional expressions. */ + + 0 ? scalar0 : scalar0; + 0 ? scalar0 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + : is_a_float; + 0 ? is_a_float + : scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0 ? scalar0 : 0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0 ? 0 : scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0 ? 0.1 + : scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0 ? scalar0 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + : 0.1; + 0 ? fp8_ptr : fp8_ptr2; + 0 ? fp8_ptr : uint8_ptr; /* { dg-error {conditional expression between distinct pointer types} } */ + 0 ? uint8_ptr : fp8_ptr; /* { dg-error {conditional expression between distinct pointer types} } */ + + scalar0 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + ? scalar0 + : scalar0; + scalar0 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + ? is_a_float + : scalar0; + scalar0 ? scalar0 : is_a_float; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 ? is_a_float : is_a_float; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + /* Unary operators. */ + + +scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + -scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + ~scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + !scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + *scalar0; /* { dg-error {invalid type argument of unary} } */ + __real scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + __imag scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + ++scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + --scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + scalar0++; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + scalar0--; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + + /* Binary arithmetic operations. */ + + scalar0 = glob_fp8 + scalar1_2; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 = glob_fp8 + *fp8_ptr; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 = glob_fp8 + + 0.1; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 = glob_fp8 + + 0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 = glob_fp8 + is_a_float; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + glob_fp8 + glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + glob_fp8 - glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + glob_fp8 * glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + glob_fp8 / glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + glob_fp8 && glob_fp8; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + glob_fp8 || glob_fp8; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + + return scalar0; +} + +/* Check that function decls for mfloat8_t and unsigned char differ */ + +mfloat8_t extern_fn1(void); +unsigned char extern_fn1(void); /* { dg-error {ambiguating new declaration of 'unsigned char extern_fn1\(\)'} } */ + +mfloat8_t extern_fn2(void); +uint8_t extern_fn2(void); /* { dg-error {ambiguating new declaration of 'uint8_t extern_fn2\(\)} } */ + +unsigned char extern_fn3(void); +mfloat8_t extern_fn3(void); /* { dg-error {ambiguating new declaration of 'mfloat8_t extern_fn3\(\)} } */ + +uint8_t extern_fn4(void); +mfloat8_t extern_fn4(void); /* { dg-error {ambiguating new declaration of 'mfloat8_t extern_fn4\(\)} } */ + +/* Check that the type conforms to the contract */ +static_assert(!std::is_integral<__mfp8>(), "not integral"); +static_assert(!std::is_signed<__mfp8>(), "not signed"); +static_assert(!std::is_unsigned<__mfp8>(), "not unsigned"); diff --git a/gcc/testsuite/gcc.target/aarch64/fp8_scalar_1.c b/gcc/testsuite/gcc.target/aarch64/fp8_scalar_1.c new file mode 100644 index 00000000000..1bc2ac26b2a --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/fp8_scalar_1.c @@ -0,0 +1,134 @@ +/* Test the fp8 ACLE intrinsics family. */ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=armv9.4-a+fp8" } */ +/* { dg-final { check-function-bodies "**" "" "" } } */ + +#include + +/* +**stacktest1: +** sub sp, sp, #16 +** and w0, w0, 255 +** strb w0, \[sp, 15\] +** ldrb w0, \[sp, 15\] +** add sp, sp, 16 +** ret +*/ +mfloat8_t +stacktest1 (mfloat8_t __a) +{ + volatile mfloat8_t b = __a; + return b; +} + +/* +**fp8_mov_ww: +** dup b1, v2.b\[0\] +** ret +*/ +void +fp8_mov_ww (void) +{ + register mfloat8_t x asm ("h2"); + register mfloat8_t y asm ("h1"); + asm volatile ("" : "=w"(x)); + y = x; + asm volatile ("" ::"w"(y)); +} + +/* +**fp8_mov_rw: +** dup v1.8b, w1 +** ret +*/ +void +fp8_mov_rw (void) +{ + register mfloat8_t x asm ("w1"); + register mfloat8_t y asm ("h1"); + asm volatile ("" : "=r"(x)); + y = x; + asm volatile ("" ::"w"(y)); +} + +/* +**fp8_mov_wr: +** umov w1, v1.b\[0\] +** ret +*/ +void +fp8_mov_wr (void) +{ + register mfloat8_t x asm ("h1"); + register mfloat8_t y asm ("w1"); + asm volatile ("" : "=w"(x)); + y = x; + asm volatile ("" ::"r"(y)); +} + +/* +**fp8_mov_rr: +** mov w1, w2 +** ret +*/ +void +fp8_mov_rr (void) +{ + register mfloat8_t x asm ("w2"); + register mfloat8_t y asm ("w1"); + asm volatile ("" : "=r"(x)); + y = x; + asm volatile ("" ::"r"(y)); +} + +/* +**fp8_mov_rm: +** strb w2, \[x0\] +** ret +*/ +void +fp8_mov_rm (mfloat8_t *ptr) +{ + register mfloat8_t x asm ("w2"); + asm volatile ("" : "=r"(x)); + *ptr = x; +} + +/* +**fp8_mov_mr: +** ldrb w2, \[x0\] +** ret +*/ +void +fp8_mov_mr (mfloat8_t *ptr) +{ + register mfloat8_t y asm ("w2"); + y = *ptr; + asm volatile ("" ::"r"(y)); +} + +/* +**fp8_str_r: +** str b2, \[x0\] +** ret +*/ +void +fp8_str_r (mfloat8_t *ptr) +{ + register mfloat8_t x asm ("v2"); + asm volatile ("" : "=w"(x)); + *ptr = x; +} + +/* +**fp8_ldr_r: +** ldr b2, \[x0\] +** ret +*/ +void +fp8_ldr_r (mfloat8_t *ptr) +{ + register mfloat8_t y asm ("v2"); + y = *ptr; + asm volatile ("" ::"w"(y)); +} diff --git a/gcc/testsuite/gcc.target/aarch64/fp8_scalar_typecheck_1.c b/gcc/testsuite/gcc.target/aarch64/fp8_scalar_typecheck_1.c new file mode 100644 index 00000000000..9169f40c4b7 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/fp8_scalar_typecheck_1.c @@ -0,0 +1,356 @@ +/* Test that there is no conversion between ints and mfloat8_t. */ +/* { dg-do assemble } */ +/* { dg-options "-O1 -march=armv9.4-a+fp8" } */ + +#include +#include + +mfloat8_t glob_fp8; + +int is_an_int; +uint8_t is_a_uint8; +int8_t is_an_int8; +short is_a_short_int; +float is_a_float; +double is_a_double; + +uint8_t *uint8_ptr; + +mfloat8_t +invalid_from_fp8 (uint16_t __a) +{ + mfloat8_t b = __a; // { dg-error "invalid conversion to type 'mfloat8_t'" } + return b; +} + +uint16_t +invalid_to_fp8 (mfloat8_t __a) +{ + uint16_t b = __a; // { dg-error "invalid conversion from type 'mfloat8_t'" } + return b; +} + +mfloat8_t +foo1 (void) +{ + return (mfloat8_t)0x1234; // { dg-error {invalid conversion to type 'mfloat8_t'} } +} +mfloat8_t +foo2 (void) +{ + return (mfloat8_t)(short)0x1234; // { dg-error {invalid conversion to type 'mfloat8_t'} } +} + +mfloat8_t +footest (mfloat8_t scalar0) +{ + + /* Initialisation */ + + mfloat8_t scalar1_1; + mfloat8_t scalar1_2 = glob_fp8; + mfloat8_t scalar1_3 = 0; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_4 + = 0.1; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_5 + = is_a_float; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_6 + = is_an_int; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_8 + = is_a_double; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_9 + = is_a_short_int; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_10 + = is_a_uint8; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar1_11 + = is_an_int8; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + + int initi_1_1 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + float initi_1_2 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + short initi_1_4 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + double initi_1_5 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + uint8_t initi_1_6 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + int8_t initi_1_7 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + mfloat8_t scalar2_1 = {}; + mfloat8_t scalar2_2 = { glob_fp8 }; + mfloat8_t scalar2_3 + = { 0 }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar2_4 + = { 0.1 }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar2_5 + = { is_a_float }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar2_6 + = { is_an_int }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar2_8 = { + is_a_double + }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar2_9 = { + is_a_short_int + }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar2_10 + = { is_a_uint8 }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + mfloat8_t scalar2_11 + = { is_an_int8 }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + + int initi_2_1 + = { glob_fp8 }; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + float initi_2_2 + = { glob_fp8 }; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + short initi_2_4 + = { glob_fp8 }; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + double initi_2_5 + = { glob_fp8 }; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + uint8_t initi_2_6 + = { glob_fp8 }; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + int8_t initi_2_7 + = { glob_fp8 }; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + /* Assignments. */ + + glob_fp8 = glob_fp8; + glob_fp8 = 0; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 = 0.1; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 + = is_a_float; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 = is_an_int; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 + = is_a_double; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 + = is_a_short_int; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 + = is_a_uint8; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + glob_fp8 + = is_an_int8; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + + is_an_int + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_a_float + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_a_double + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_a_short_int + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_a_uint8 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_an_int8 + = glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + /* Casting. */ + + (void)glob_fp8; + (mfloat8_t) glob_fp8; + + (int)glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (float)glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (double)glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (short)glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (uint8_t)glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (int8_t)glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + (mfloat8_t) is_an_int; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t) is_a_float; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t) is_a_double; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t) + is_a_short_int; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t) is_a_uint8; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t) is_an_int8; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + + /* Compound literals. */ + + (mfloat8_t){}; + (mfloat8_t){ glob_fp8 }; + (mfloat8_t){ 0 }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t){ 0.1 }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t){ + is_a_float + }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t){ + is_an_int + }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t){ + is_a_double + }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t){ + is_a_short_int + }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t){ + is_a_uint8 + }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + (mfloat8_t){ + is_an_int8 + }; /* { dg-error {invalid conversion to type 'mfloat8_t'} } */ + + (int){ glob_fp8 }; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (float){ + glob_fp8 + }; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (double){ + glob_fp8 + }; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (short){ + glob_fp8 + }; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (uint8_t){ + glob_fp8 + }; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + (int8_t){ + glob_fp8 + }; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + /* Arrays and Structs. */ + + typedef mfloat8_t array_type[2]; + extern mfloat8_t extern_array[]; + + mfloat8_t array[2]; + mfloat8_t zero_length_array[0]; + mfloat8_t empty_init_array[] = {}; + typedef mfloat8_t some_other_type[is_an_int]; + + struct struct1 + { + mfloat8_t a; + }; + + union union1 + { + mfloat8_t a; + }; + + /* Addressing and dereferencing. */ + + mfloat8_t *fp8_ptr = &scalar0; + scalar0 = *fp8_ptr; + + /* Pointer assignment. */ + + mfloat8_t *fp8_ptr2 = fp8_ptr; + mfloat8_t *fp8_ptr3 = array; + + /* Pointer arithmetic. */ + + ++fp8_ptr; + --fp8_ptr; + fp8_ptr++; + fp8_ptr--; + fp8_ptr += 1; + fp8_ptr -= 1; + fp8_ptr - fp8_ptr2; + fp8_ptr = &fp8_ptr3[0]; + fp8_ptr = &fp8_ptr3[1]; + + /* Simple comparison. */ + scalar0 > glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + glob_fp8 + == scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 > is_a_float; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_a_float + == scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 > 0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0 == scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 > 0.1; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0.1 == scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 + > is_an_int; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + is_an_int + == scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + /* Pointer comparison. */ + + fp8_ptr == &scalar0; + fp8_ptr != &scalar0; + fp8_ptr < &scalar0; + fp8_ptr <= &scalar0; + fp8_ptr > &scalar0; + fp8_ptr >= &scalar0; + fp8_ptr == fp8_ptr2; + fp8_ptr != fp8_ptr2; + fp8_ptr < fp8_ptr2; + fp8_ptr <= fp8_ptr2; + fp8_ptr > fp8_ptr2; + fp8_ptr >= fp8_ptr2; + + /* Conditional expressions. */ + + 0 ? scalar0 : scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0 ? scalar0 + : is_a_float; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0 ? is_a_float + : scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0 ? scalar0 : 0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0 ? 0 : scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0 ? 0.1 : scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0 ? scalar0 : 0.1; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + 0 ? fp8_ptr : fp8_ptr2; + 0 ? fp8_ptr : uint8_ptr; /* { dg-error {pointer type mismatch in conditional expression} } */ + 0 ? uint8_ptr : fp8_ptr; /* { dg-error {pointer type mismatch in conditional expression} } */ + + scalar0 ? scalar0 /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + : scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 ? is_a_float /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + : scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 ? scalar0 : is_a_float; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 ? is_a_float : is_a_float; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + /* Unary operators. */ + + +scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + -scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + ~scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + !scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + *scalar0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + __real scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + __imag scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + ++scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + --scalar0; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + scalar0++; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + scalar0--; /* { dg-error {operation not permitted on type 'mfloat8_t'} } */ + + /* Binary arithmetic operations. */ + + scalar0 = glob_fp8 + scalar1_2; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 = glob_fp8 + *fp8_ptr; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 = glob_fp8 + + 0.1; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 + = glob_fp8 + 0; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + scalar0 + = glob_fp8 + + is_a_float; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + glob_fp8 + glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + glob_fp8 - glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + glob_fp8 * glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + glob_fp8 / glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + glob_fp8 && glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + glob_fp8 || glob_fp8; /* { dg-error {invalid conversion from type 'mfloat8_t'} } */ + + return scalar0; +} + +/* Check that function decls for mfloat8_t and unsigned char differ */ + +mfloat8_t extern_fn1(void); +unsigned char extern_fn1(void); /* { dg-error {conflicting types for 'extern_fn1'; have 'unsigned char\(void\)'} } */ + +mfloat8_t extern_fn2(void); +uint8_t extern_fn2(void); /* { dg-error {conflicting types for 'extern_fn2'; have 'uint8_t\(void\)'} } */ + +unsigned char extern_fn3(void); +mfloat8_t extern_fn3(void); /* { dg-error {conflicting types for 'extern_fn3'; have 'mfloat8_t\(void\)'} } */ + +uint8_t extern_fn4(void); +mfloat8_t extern_fn4(void); /* { dg-error {conflicting types for 'extern_fn4'; have 'mfloat8_t\(void\)'} } */ + +void extern_fn5(mfloat8_t); +void extern_fn5(unsigned char); /* { dg-error {conflicting types for 'extern_fn5'; have 'void\(unsigned char\)'} } */ + +void extern_fn6(mfloat8_t); +void extern_fn6(uint8_t); /* { dg-error {conflicting types for 'extern_fn6'; have 'void\(uint8_t\)'} } */