From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR04-VI1-obe.outbound.protection.outlook.com (mail-vi1eur04on2079.outbound.protection.outlook.com [40.107.8.79]) by sourceware.org (Postfix) with ESMTPS id F3E4A3854839 for ; Fri, 3 Mar 2023 13:02:49 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org F3E4A3854839 Authentication-Results: sourceware.org; dmarc=pass (p=quarantine dis=none) header.from=suse.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=suse.com ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=fWdhoojZT10aArcNSd9q0mD+eNnvlelkhE7Zgd5CsaHk8UepJNrpY6RSoKTRn15yZwVGKDiDr1PV+maxfpxgcp3jixD6/0Gzu2iTWf90t4Jg4q4JOSEGMt1Le2cSk9pddwp9GYqUbFc3sxExbcgSPvL2rq1r8+mW114fs8vO5SpGMh7ts2Ijtnk+UZQ0Yo/hOK1ZoQGJBMvmNSpTurfuPi1KSjBXZJbHZpBn1UhX1/l+GKN5obVsJJQiMjLMWa65AymCCQWk8eUbUX3SEvz+XpFDltcPE6B7Wr55EpDcbIrludxCw258NbN0YMFPwI5FPgpBjTD81Vk5RCwYJPxYkA== 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=7bRQf3PUsZB9+LdSU1YCgm6JR8QriNzbxOzI+bqycww=; b=R9l/4IbGWhPOyghNGRb39n1GwfNbI77n1EG3ng9oiw5VcbI9phyNnEWUoOy6G+0dwgyYlrCawr5wcqidbCKsCcW9+3vyUo8mtOQpbyhyQWyTiszVIKCGT/zbL6t8heaDcphi5WEQb4htkvOfRY1parS9nQIaROeg3SLHKMb7JeYoifLj4PKERDSfKm6sEJbJ2OTTm04Or8OKj36Kc4MvI81I0T3xovDhdYqVtF7xaE6zJMDeVMABCB58Mr4S92eKJjuk/Yp8hDnzt6RlyLUYQwkx17JwUTkjq9tSjIF5+M9hg/h6dG3m2UCdIPMSfKj5HjHJDtae+7DerNt59cgWjA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=suse.com; dmarc=pass action=none header.from=suse.com; dkim=pass header.d=suse.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=7bRQf3PUsZB9+LdSU1YCgm6JR8QriNzbxOzI+bqycww=; b=QCI6m4L2ge7M5q+ajaD4H7rsl3D0RLkYi0ymZga/zI4e2j1cgOkXOKVW90nrqBdfffXD6gfPS7BiIYx13++EwKzJA3f0HOmKb3ppArW8QNFOba5mAHQCkZzKvoA81V20GS+WSB+YTnImVzhhxiUciKPt0JtxzH9zcta4OeIuTZ3KNS+vzJ+XrRK5aSxOKp2S8ejooyv+HUqIU4GLKYTc2bZ44HhL2TekkFjyzRDbY1yfC770Q9wbfgXVmYJgjCx59jHAy1RJWtwRs2AK3KjTtqpY4ywdgJyTNfleBN8lU0WHhWuyMWwNf3TYOB6kAY4khqUfImqJsh17jS48vML+kA== Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=suse.com; Received: from VE1PR04MB6560.eurprd04.prod.outlook.com (2603:10a6:803:122::25) by PA4PR04MB9222.eurprd04.prod.outlook.com (2603:10a6:102:2a1::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6156.18; Fri, 3 Mar 2023 13:02:47 +0000 Received: from VE1PR04MB6560.eurprd04.prod.outlook.com ([fe80::154e:166d:ec25:531b]) by VE1PR04MB6560.eurprd04.prod.outlook.com ([fe80::154e:166d:ec25:531b%7]) with mapi id 15.20.6156.019; Fri, 3 Mar 2023 13:02:45 +0000 Message-ID: Date: Fri, 3 Mar 2023 14:02:44 +0100 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101 Thunderbird/102.8.0 Subject: [PATCH 11/18] x86: process instruction operands for .insn Content-Language: en-US To: Binutils Cc: "H.J. Lu" , "Jiang, Haochen" References: <764b9e03-18bd-6945-692f-a250522196ca@suse.com> From: Jan Beulich In-Reply-To: <764b9e03-18bd-6945-692f-a250522196ca@suse.com> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-ClientProxiedBy: FR3P281CA0105.DEUP281.PROD.OUTLOOK.COM (2603:10a6:d10:a1::6) To VE1PR04MB6560.eurprd04.prod.outlook.com (2603:10a6:803:122::25) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: VE1PR04MB6560:EE_|PA4PR04MB9222:EE_ X-MS-Office365-Filtering-Correlation-Id: aed29ea4-6ede-4c6a-881f-08db1be7952f X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 67wOv3IRjkA5kS8cPWTlbmuUVJNFILuiFwWb3OX1IJ5DFlPGlCNhmmrvaAtPYZGJGvG9zDvF1hh4FK0jer9Iu8dImAkdgEqxLKaiS4bgIQvymkBDSvMPTdfaSp9x4vZyEH0iRVZYrMRdRPFGCLSfSrXhET4j4BJebtehLJAg4jgI+fjZMeTPquGenMApv3SBC8fEikaS72VwIbjOsmqibQ88OHZqomRw47UwhBCUFUiEM+71MLICjEG2miz5aRQcKfcNJs8hnAmA7rjMrXpIBk7OGLfIMAzOHa9qu5MOC1K1a3fpCWWSzKuVsQfqhECS3Igis8ND9v73Dghz9V6weFS+ljPdSzxaccpEF5BESNyivQmSuEmZG68DhI9kjqe6kUxPA25M7ofCnr4KHKBhwPJky+e5Z1WDTcpM3D7SWzZy1Q7vYCeZ9u3zBJgZ9rj7k3A4qEg7rhpjwVPZrMO/OAX7cfMLKFbH8wUoHf7P9wLB/YfEREpWpdBsmHFv8B/89nqJAw2mCQvlzEgRmMoTo3F99sNCPfAWwdCPPK9PKBMyyMXM2lPjePYSffVoctTKK+Mvd198IhJ84KHGeKbof5nv5JngBUKTCDwPiP8I0yHhOjRoIXpHriJJYvbEdqa25TAgJsjl/Ba0Ty/ZAIq80ew8k3Snuopet5r54JyOr2PuKW6fn1JV5mvvte4Qb+N0SL7pJPumfMEILrhFpwAZ9Y66Qlgl5YJ2nIhq5AkyE4Mx9CNl+ljmfnx8lSH760sA X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:VE1PR04MB6560.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230025)(39860400002)(376002)(136003)(346002)(366004)(396003)(451199018)(6486002)(31686004)(5660300002)(30864003)(66899018)(66476007)(4326008)(36756003)(8936002)(41300700001)(83380400001)(66946007)(2906002)(8676002)(66556008)(316002)(38100700002)(6916009)(26005)(6506007)(6512007)(186003)(2616005)(86362001)(478600001)(54906003)(31696002)(142923001)(45980500001)(43740500002);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?NlpIWHgzdnBhdjlwV2RLTkNXbDJtb3pUNFpaaFdWQXg3VTYwQk53azRscDg2?= =?utf-8?B?c3phdnNjUDlPeGdqbEJYajhQd0x4NW1ER0R6R0ZVY2NSZzBxQk1WOFpHLys0?= =?utf-8?B?UUliRE53K2xLTUlQd05oRVVsaG12WFE3WEFGZnFMTlZQY0ZKd3VKRVlTVmpP?= =?utf-8?B?SXV0QWd2cjJXRVFKTUc1R0g5VFZ6MlM3ZHFaYVlHUWMvWnVhV3BvTGY5TWlz?= =?utf-8?B?U3NOSVZ5NElLNGNNbU1Fck5uRXlyMmZLNlk5czJRQ1FjL2lZSUgxVHBTV1pr?= =?utf-8?B?RXpwUFhxNUF3UTVWTXk4KzUrN0t2eVJnaklXTFlEazVkZFNwZ0VtandnUnpo?= =?utf-8?B?WFRTVC82OGx5cEhNV2lXb3REZlJ6NkxYSzRpd3l6aE9xdE1ERkNrSTNYQ3RG?= =?utf-8?B?MndCaW5ITDk5OS9Mb2JEWG52TlhYY08xL21Uamt0cFlVZ2FEbDNBSktYYWwx?= =?utf-8?B?RzJXS0RXNUJvOURpaVU1cllacFJ5ekpKV2NJQzR3NFM4RFExNGxhT2FxTzNm?= =?utf-8?B?NjZSQ09PRTJBK2dua2FSTkU1ak1rWERQS3U2bFRjdGtoaUdsVWtOUitpWDlJ?= =?utf-8?B?ckVidTl0MUwyRlFid3lrUkxFemZ0d3AvaGNOZVV0VWxxK1FadUZsWUVtRTFM?= =?utf-8?B?ZTY4aGJwb0RsbHZSUXlhaUhENCtHQ2djN3hlWUdtYm9tZ250SU03WUs5UW9R?= =?utf-8?B?Z2RBWHVSR0F0L0JCeEdveGtzSDZvMGwwSXd0V3VKTXR1SWExLzFyaXlObm45?= =?utf-8?B?Zjk4cTh5SGpXSDlSUVlrWktqV2dsa1NzZXNtYzNEcjk0azk1ckpkSnB4NUo5?= =?utf-8?B?NUx5WEEzaGZnZEtid3IxSklUTExhdlVWOGZtaC9PSFlRSGxDcFZaU0VpRG1t?= =?utf-8?B?STRHOUkvdmN5aTUySFk3cncrZnlUZ0FNeTZGbGNWZDNLUXlTaDhIdmh4Rk11?= =?utf-8?B?d0dLb0JXaWtaNXcvZURkK0VXN21YV2Z5akpSa3lVSlBFVXp5cWNlcDQ5Sk1x?= =?utf-8?B?Mkc2c3hDS2VSMWczRDI2enF2RENxUmt5cjZKRHdVWUxqMTR6TmdWVExZMDJJ?= =?utf-8?B?RlpWZlVzSFhIY2dacmNXWUtoNDUxV0hLQ2VkQUhLT3dCRkVmbXhnU2VkL1Za?= =?utf-8?B?ZlJvQjEzanN2VjdrR2ZZeUlXbHVrbERXNDZ0alNaUnUzZS8zYi9CUDd6V0FC?= =?utf-8?B?c1FBeGVIdWxvL0tHUjh5a1F0WXB0cjFaYXZ4bUxyZVQwTUlROFhIRVJTQzRx?= =?utf-8?B?WDdiYlYzbDNaUWY5enVwUXdmVTM1RDI0OVZMTWxnc2x1b21LRWpnSWhJaXIr?= =?utf-8?B?RisxTjA1UVBCdVlYUm16cDFjN2piQW5WVUhycHF6WjF6ODhFRlloZHNWeE5I?= =?utf-8?B?WVBxY21IaDNHdFUySWw5TGIvT04xdC9lSHAzRkJZeDhUbHh6a2htcmJMbG1z?= =?utf-8?B?RzFNM3gyOGdFczZUeGViQmFOZVIvTVJ3aG13WER5N2QxNHI0VG5vVkRDYjRD?= =?utf-8?B?am9ZNGV0ZXVTZnEyNU5QSHluaUNhM3d1L1hDQmlQU2JtTGNFeFhkVHMrM0VK?= =?utf-8?B?dnpwd09hdDdsYVJ0OWdxVW1QY2FNelNZZnNsS21rSFdEeDlFUUtIQUdSbmEy?= =?utf-8?B?NGFFVUhkd3JLbzdHWEZFakZsMW5waXp2UE1nZ21xekI3bHU1UGtvdDdxaDEr?= =?utf-8?B?OG81NVFsT3VLK0pPazlkTnA0WE9ONzYyM2M1YXRTemR3bDNoRWpzcGdCY2NW?= =?utf-8?B?bkNkZ3c3N2FnbmYzU1YxeWhGd09XVDlHK2Jia0xYVHNQQ1JiVHBacXhlRTMz?= =?utf-8?B?VlNIZVRqWHlkTERVeWVUZ3hWbWNiQytsYmVadGlxY0gvYVVsVWdycUhQVklw?= =?utf-8?B?ZzExeEtuWDNZTWV2SS9tVmpJOUEwQWpRSkdsMUNGQVNKbWN4R3MzVDhWSHRl?= =?utf-8?B?bHB1MkpFZ0lNbVNBY2MzY2R0VjBYL2RhZEJhSkpUdkl6dG1Gd3NXVXp6VHBn?= =?utf-8?B?QWFmeHdqY0tEM1M0TTd2WTJpSnJLcjI1UHZHT3VzWmVhb1pJYVNQbUNKS1d5?= =?utf-8?B?ZlN1TkJzcis2dTFHWlhHMWdmanFaUVEwQjFjTWtZVWtSbE5BZ3U3STdxN3U5?= =?utf-8?Q?k3fCIAutim3yVoSTeyowKHbJp?= X-OriginatorOrg: suse.com X-MS-Exchange-CrossTenant-Network-Message-Id: aed29ea4-6ede-4c6a-881f-08db1be7952f X-MS-Exchange-CrossTenant-AuthSource: VE1PR04MB6560.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 03 Mar 2023 13:02:45.8622 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: f7a17af6-1c5c-4a36-aa8b-f5be247aa4ba X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: IlZOrRU4yxTKFDubCTi0AaSLdKMTnQnTz7eEwgL5TqbRXQSwmQu4DhLODjRfddsQy5wAAhoQc9rYA2tABGdbNg== X-MS-Exchange-Transport-CrossTenantHeadersStamped: PA4PR04MB9222 X-Spam-Status: No, score=-3028.3 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_PASS,SPF_PASS,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: Deal with register and memory operands; immediate operands will follow later, as will the handling of EVEX embedded broadcast and EVEX Disp8 scaling. Note that because we can't really know how to encode their use, %cr8 and up cannot be used with .insn outside of 64-bit mode. Users would need to specify an explicit LOCK prefix in combination with %cr0 etc. --- I'm not convinced the assertions early in build_modrm_byte() are useful to retain. --- a/gas/config/tc-i386.c +++ b/gas/config/tc-i386.c @@ -2356,7 +2356,8 @@ fits_in_disp8 (offsetT num) static INLINE int fits_in_imm4 (offsetT num) { - return (num & 0xf) == num; + /* Despite the name, check for imm3 if we're dealing with EVEX. */ + return (num & (i.vec_encoding != vex_encoding_evex ? 0xf : 7)) == num; } static i386_operand_type @@ -8227,7 +8228,7 @@ process_operands (void) } } } - else if (i.types[0].bitfield.class == SReg) + else if (i.types[0].bitfield.class == SReg && !dot_insn ()) { if (flag_code != CODE_64BIT ? i.tm.base_opcode == POP_SEG_SHORT @@ -8260,15 +8261,32 @@ process_operands (void) } else if (i.short_form) { - /* The register operand is in operand 0 or 1. */ - const reg_entry *r = i.op[0].regs; + /* The register operand is in the 1st or 2nd non-immediate operand. */ + const reg_entry *r = i.op[i.imm_operands].regs; - if (i.imm_operands - || (r->reg_type.bitfield.instance == Accum && i.op[1].regs)) - r = i.op[1].regs; + if (!dot_insn () + && r->reg_type.bitfield.instance == Accum + && i.op[i.imm_operands + 1].regs) + r = i.op[i.imm_operands + 1].regs; /* Register goes in low 3 bits of opcode. */ i.tm.base_opcode |= r->reg_num; set_rex_vrex (r, REX_B, false); + + if (dot_insn () && i.reg_operands == 2) + { + gas_assert (is_any_vex_encoding (&i.tm) + || i.vec_encoding != vex_encoding_default); + i.vex.register_specifier = i.op[i.operands - 1].regs; + } + } + else if (i.reg_operands == 1 + && !i.flags[i.operands - 1] + && i.tm.operand_types[i.operands - 1].bitfield.instance + == InstanceNone) + { + gas_assert (is_any_vex_encoding (&i.tm) + || i.vec_encoding != vex_encoding_default); + i.vex.register_specifier = i.op[i.operands - 1].regs; } if ((i.seg[0] || i.prefix[SEG_PREFIX]) @@ -8329,10 +8347,12 @@ build_modrm_byte (void) VexW0 or VexW1. The destination must be either XMM, YMM or ZMM register. 2. 4 operands: 4 register operands or 3 register operands - plus 1 memory operand, with VexXDS. */ + plus 1 memory operand, with VexXDS. + 3. Other equivalent combinations when coming from s_insn(). */ gas_assert (i.tm.opcode_modifier.vexvvvv - && i.tm.opcode_modifier.vexw - && i.tm.operand_types[dest].bitfield.class == RegSIMD); + && i.tm.opcode_modifier.vexw); + gas_assert (dot_insn () + || i.tm.operand_types[dest].bitfield.class == RegSIMD); /* Of the first two non-immediate operands the one with the template not allowing for a memory one is encoded in the immediate operand. */ @@ -8341,6 +8361,14 @@ build_modrm_byte (void) else reg_slot = source++; + if (!dot_insn ()) + { + gas_assert (i.tm.operand_types[reg_slot].bitfield.class == RegSIMD); + gas_assert (!(i.op[reg_slot].regs->reg_flags & RegVRex)); + } + else + gas_assert (i.tm.operand_types[reg_slot].bitfield.class != ClassNone); + if (i.imm_operands == 0) { /* When there is no immediate operand, generate an 8bit @@ -8350,10 +8378,7 @@ build_modrm_byte (void) i.types[i.operands].bitfield.imm8 = 1; i.operands++; - gas_assert (i.tm.operand_types[reg_slot].bitfield.class == RegSIMD); exp->X_op = O_constant; - exp->X_add_number = register_number (i.op[reg_slot].regs) << 4; - gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0); } else { @@ -8364,11 +8389,11 @@ build_modrm_byte (void) /* Turn on Imm8 again so that output_imm will generate it. */ i.types[0].bitfield.imm8 = 1; - gas_assert (i.tm.operand_types[reg_slot].bitfield.class == RegSIMD); - i.op[0].imms->X_add_number - |= register_number (i.op[reg_slot].regs) << 4; - gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0); + exp = i.op[0].imms; } + exp->X_add_number |= register_number (i.op[reg_slot].regs) + << (3 + !(is_evex_encoding (&i.tm) + || i.vec_encoding == vex_encoding_evex)); } for (v = source + 1; v < dest; ++v) @@ -10633,6 +10658,9 @@ s_insn (int dummy ATTRIBUTE_UNUSED) goto bad; } + if (line > end && i.vec_encoding == vex_encoding_default) + i.vec_encoding = evex ? vex_encoding_evex : vex_encoding_vex; + if (line > end && *line == '.') { /* Length specifier (VEX.L, XOP.L, EVEX.L'L). */ @@ -10912,7 +10940,243 @@ s_insn (int dummy ATTRIBUTE_UNUSED) goto bad; } i.opcode_length = j; - i.tm.base_opcode = val; + + /* Handle operands, if any. */ + if (*line == ',') + { + i386_operand_type combined; + bool changed; + + ptr = parse_operands (line + 1, &i386_mnemonics[MN__insn]); + this_operand = -1; + if (!ptr) + goto bad; + line = ptr; + + if (!i.operands) + { + as_bad (_("expecting operand after ','; got nothing")); + goto done; + } + + if (i.mem_operands > 1) + { + as_bad (_("too many memory references for `%s'"), + &i386_mnemonics[MN__insn]); + goto done; + } + + /* Are we to emit ModR/M encoding? */ + if (!i.short_form + && (i.mem_operands + || i.reg_operands > (i.vec_encoding != vex_encoding_default) + || i.tm.extension_opcode != None)) + i.tm.opcode_modifier.modrm = 1; + + if (!i.tm.opcode_modifier.modrm + && (i.reg_operands + > i.short_form + 0U + (i.vec_encoding != vex_encoding_default) + || i.mem_operands)) + { + as_bad (_("too many register/memory operands")); + goto done; + } + + /* Enforce certain constraints on operands. */ + switch (i.reg_operands + i.mem_operands + + (i.tm.extension_opcode != None)) + { + case 0: + if (i.short_form) + { + as_bad (_("too few register/memory operands")); + goto done; + } + /* Fall through. */ + case 1: + if (i.tm.opcode_modifier.modrm) + { + as_bad (_("too few register/memory operands")); + goto done; + } + break; + + case 2: + break; + + case 4: + if (i.imm_operands + && (i.op[0].imms->X_op != O_constant + || !fits_in_imm4 (i.op[0].imms->X_add_number))) + { + as_bad (_("constant doesn't fit in %d bits"), evex ? 3 : 4); + goto done; + } + /* Fall through. */ + case 3: + if (i.vec_encoding != vex_encoding_default) + { + i.tm.opcode_modifier.vexvvvv = 1; + break; + } + /* Fall through. */ + default: + as_bad (_("too many register/memory operands")); + goto done; + } + + /* Bring operands into canonical order (imm, mem, reg). */ + do + { + changed = false; + + for (j = 1; j < i.operands; ++j) + { + if ((!operand_type_check (i.types[j - 1], imm) + && operand_type_check (i.types[j], imm)) + || (i.types[j - 1].bitfield.class != ClassNone + && i.types[j].bitfield.class == ClassNone)) + { + swap_2_operands (j - 1, j); + changed = true; + } + } + } + while (changed); + + /* For Intel syntax swap the order of register operands. */ + if (intel_syntax) + switch (i.reg_operands) + { + case 0: + case 1: + break; + + case 4: + swap_2_operands (i.imm_operands + i.mem_operands + 1, i.operands - 2); + /* Fall through. */ + case 3: + case 2: + swap_2_operands (i.imm_operands + i.mem_operands, i.operands - 1); + break; + + default: + abort (); + } + + /* Enforce constraints when using VSIB. */ + if (i.index_reg + && (i.index_reg->reg_type.bitfield.xmmword + || i.index_reg->reg_type.bitfield.ymmword + || i.index_reg->reg_type.bitfield.zmmword)) + { + if (i.vec_encoding == vex_encoding_default) + { + as_bad (_("VSIB unavailable with legacy encoding")); + goto done; + } + + if (i.vec_encoding == vex_encoding_evex + && i.reg_operands > 1) + { + /* We could allow two register operands, encoding the 2nd one in + an 8-bit immediate like for 4-register-operand insns, but that + would require ugly fiddling with process_operands() and/or + build_modrm_byte(). */ + as_bad (_("too many register operands with VSIB")); + goto done; + } + + i.tm.opcode_modifier.sib = 1; + } + + /* Establish operand size encoding. */ + operand_type_set (&combined, 0); + for (j = i.imm_operands; j < i.operands; ++j) + { + i.types[j].bitfield.instance = InstanceNone; + + if (operand_type_check (i.types[j], disp)) + i.types[j].bitfield.baseindex = 1; + + if (i.broadcast.type && j == i.broadcast.operand) + continue; + + combined = operand_type_or (combined, i.types[j]); + combined.bitfield.class = ClassNone; + } + + if (i.vec_encoding == vex_encoding_default) + { + if (flag_code == CODE_64BIT && combined.bitfield.qword) + i.rex |= REX_W; + else if ((flag_code == CODE_16BIT ? combined.bitfield.dword + : combined.bitfield.word) + && !add_prefix (DATA_PREFIX_OPCODE)) + goto done; + } + else if (!i.tm.opcode_modifier.vexw) + { + if (flag_code == CODE_64BIT) + { + if (combined.bitfield.qword) + i.tm.opcode_modifier.vexw = VEXW1; + else if (combined.bitfield.dword) + i.tm.opcode_modifier.vexw = VEXW0; + } + + if (!i.tm.opcode_modifier.vexw) + i.tm.opcode_modifier.vexw = VEXWIG; + } + + if (vex || xop) + { + if (!i.tm.opcode_modifier.vex) + { + if (combined.bitfield.ymmword) + i.tm.opcode_modifier.vex = VEX256; + else if (combined.bitfield.xmmword) + i.tm.opcode_modifier.vex = VEX128; + } + } + else if (evex) + { + if (!i.tm.opcode_modifier.evex) + { + /* Do _not_ consider AVX512VL here. */ + if (i.rounding.type != rc_none || combined.bitfield.zmmword) + i.tm.opcode_modifier.evex = EVEX512; + else if (combined.bitfield.ymmword) + i.tm.opcode_modifier.evex = EVEX256; + else if (combined.bitfield.xmmword) + i.tm.opcode_modifier.evex = EVEX128; + } + } + + if (i.disp_operands && !optimize_disp (&i.tm)) + goto done; + + for (j = 0; j < i.operands; ++j) + i.tm.operand_types[j] = i.types[j]; + + process_operands (); + } + + /* Don't set opcode until after processing operands, to avoid any + potential special casing there. */ + i.tm.base_opcode |= val; + + if (i.vec_encoding == vex_encoding_error + || (i.vec_encoding != vex_encoding_evex + ? i.broadcast.type + || i.rounding.type != rc_none + || i.mask.reg + : i.broadcast.type + && i.rounding.type != rc_none)) + { + as_bad (_("conflicting .insn operands")); + goto done; + } if (vex || xop) { @@ -10930,6 +11194,8 @@ s_insn (int dummy ATTRIBUTE_UNUSED) build_evex_prefix (); i.rex &= REX_OPCODE; } + else if (i.rex != 0) + add_prefix (REX_OPCODE | i.rex); output_insn (); @@ -11898,6 +12164,15 @@ i386_att_operand (char *operand_string) as_bad (_("junk `%s' after register"), op_string); return 0; } + + /* Reject pseudo registers for .insn. */ + if (dot_insn () && r->reg_type.bitfield.class == ClassNone) + { + as_bad (_("`%s%s' cannot be used here"), + register_prefix, r->reg_name); + return 0; + } + temp = r->reg_type; temp.bitfield.baseindex = 0; i.types[this_operand] = operand_type_or (i.types[this_operand], @@ -13273,7 +13548,9 @@ static bool check_register (const reg_en } if (((r->reg_flags & (RegRex64 | RegRex)) || r->reg_type.bitfield.qword) - && (!cpu_arch_flags.bitfield.cpulm || r->reg_type.bitfield.class != RegCR) + && (!cpu_arch_flags.bitfield.cpulm + || r->reg_type.bitfield.class != RegCR + || dot_insn ()) && flag_code != CODE_64BIT) return false; --- a/gas/config/tc-i386-intel.c +++ b/gas/config/tc-i386-intel.c @@ -320,8 +320,10 @@ i386_intel_simplify_register (expression as_bad (_("invalid use of register")); return 0; } - if (i386_regtab[reg_num].reg_type.bitfield.class == SReg - && i386_regtab[reg_num].reg_num == RegFlat) + if ((i386_regtab[reg_num].reg_type.bitfield.class == SReg + && i386_regtab[reg_num].reg_num == RegFlat) + || (dot_insn () + && i386_regtab[reg_num].reg_type.bitfield.class == ClassNone)) { as_bad (_("invalid use of pseudo-register")); return 0; @@ -342,6 +344,7 @@ i386_intel_simplify_register (expression if (intel_state.in_scale || i386_regtab[reg_num].reg_type.bitfield.baseindex + || dot_insn () || t->mnem_off == MN_bndmk || t->mnem_off == MN_bndldx || t->mnem_off == MN_bndstx) --- a/gas/testsuite/gas/i386/insn-32.d +++ b/gas/testsuite/gas/i386/insn-32.d @@ -11,6 +11,24 @@ Disassembly of section .text: [ ]*[a-f0-9]+: f3 90[ ]+pause [ ]*[a-f0-9]+: d9 ee[ ]+fldz [ ]*[a-f0-9]+: f3 0f 01 e8[ ]+setssbsy +[ ]*[a-f0-9]+: 8b c1[ ]+mov %ecx,%eax +[ ]*[a-f0-9]+: 66 8b c8[ ]+mov %ax,%cx +[ ]*[a-f0-9]+: 89 48 04[ ]+mov %ecx,0x4\(%eax\) +[ ]*[a-f0-9]+: 8b 0c 05 44 44 00 00[ ]+mov 0x4444\(,%eax,1\),%ecx +[ ]*[a-f0-9]+: 66 0f b6 cc[ ]+movzbw %ah,%cx +[ ]*[a-f0-9]+: 0f b7 c8[ ]+movzwl %ax,%ecx +[ ]*[a-f0-9]+: 0f ca[ ]+bswap %edx [ ]*[a-f0-9]+: c5 fc 77[ ]+vzeroall [ ]*[a-f0-9]+: c4 e1 7c 77[ ]+vzeroall +[ ]*[a-f0-9]+: c5 f1 58 d0[ ]+vaddpd %xmm0,%xmm1,%xmm2 +[ ]*[a-f0-9]+: c5 f5 58 d0[ ]+vaddpd %ymm0,%ymm1,%ymm2 +[ ]*[a-f0-9]+: c5 f2 58 d0[ ]+vaddss %xmm0,%xmm1,%xmm2 +[ ]*[a-f0-9]+: c4 e3 69 68 19 00[ ]+vfmaddps %xmm0,\(%ecx\),%xmm2,%xmm3 +[ ]*[a-f0-9]+: c4 e3 e9 68 19 00[ ]+vfmaddps \(%ecx\),%xmm0,%xmm2,%xmm3 +[ ]*[a-f0-9]+: c4 e3 e9 68 18 10[ ]+vfmaddps \(%eax\),%xmm1,%xmm2,%xmm3 +[ ]*[a-f0-9]+: c5 f8 92 c8[ ]+kmovw %eax,%k1 +[ ]*[a-f0-9]+: c5 f8 93 c1[ ]+kmovw %k1,%eax +[ ]*[a-f0-9]+: 62 f1 74 18 58 d0[ ]+vaddps \{rn-sae\},%zmm0,%zmm1,%zmm2 +[ ]*[a-f0-9]+: c4 e2 79 92 1c 48[ ]+vgatherdps %xmm0,\(%eax,%xmm1,2\),%xmm3 +[ ]*[a-f0-9]+: 62 f2 fd 0c 93 1c 48[ ]+vgatherqpd \(%eax,%xmm1,2\),%xmm3\{%k4\} #pass --- a/gas/testsuite/gas/i386/insn-32.s +++ b/gas/testsuite/gas/i386/insn-32.s @@ -13,6 +13,42 @@ insn: # setssbsy .insn 0xf30f01e8 + # mov + .insn 0x8b, %ecx, %eax + .insn 0x8b, %ax, %cx + .insn 0x89, %ecx, 4(%eax) + .insn 0x8b, 0x4444(,%eax), %ecx + + # movzx + .insn 0x0fb6, %ah, %cx + .insn 0x0fb7, %eax, %ecx + + # bswap + .insn 0x0fc8+r, %edx + # vzeroall .insn VEX.256.0F.WIG 0x77 .insn {vex3} VEX.L1 0x0f77 + + # vaddpd + .insn VEX.66.0F 0x58, %xmm0, %xmm1, %xmm2 + .insn VEX.66 0x0f58, %ymm0, %ymm1, %ymm2 + + # vaddss + .insn VEX.LIG.F3.0F 0x58, %xmm0, %xmm1, %xmm2 + + # vfmaddps + .insn VEX.66.0F3A.W0 0x68, %xmm0, (%ecx), %xmm2, %xmm3 + .insn VEX.66.0F3A.W1 0x68, %xmm0, (%ecx), %xmm2, %xmm3 + .insn VEX.66.0F3A.W1 0x68, (%eax), %xmm1, %xmm2, %xmm3 + + # kmovw + .insn VEX.L0.0F.W0 0x92, %eax, %k1 + .insn VEX.L0.0F.W0 0x93, %k1, %eax + + # vaddps + .insn EVEX.NP.0F.W0 0x58, {rn-sae}, %zmm0, %zmm1, %zmm2 + + # vgather... + .insn VEX.66.0f38.W0 0x92, %xmm0, (%eax, %xmm1, 2), %xmm3 + .insn EVEX.66.0f38.W1 0x93, (%eax, %xmm1, 2), %xmm3{%k4} --- a/gas/testsuite/gas/i386/insn-64.d +++ b/gas/testsuite/gas/i386/insn-64.d @@ -11,6 +11,35 @@ Disassembly of section .text: [ ]*[a-f0-9]+: f3 90[ ]+pause [ ]*[a-f0-9]+: d9 ee[ ]+fldz [ ]*[a-f0-9]+: f3 0f 01 e8[ ]+setssbsy +[ ]*[a-f0-9]+: 44 8b c1[ ]+mov %ecx,%r8d +[ ]*[a-f0-9]+: 48 8b c8[ ]+mov %rax,%rcx +[ ]*[a-f0-9]+: 41 89 48 08[ ]+mov %ecx,0x8\(%r8\) +[ ]*[a-f0-9]+: 42 8b 0c 05 80 80 00 00[ ]+mov 0x8080\(,%r8,1\),%ecx +[ ]*[a-f0-9]+: 66 0f be cc[ ]+movsbw %ah,%cx +[ ]*[a-f0-9]+: 0f bf c8[ ]+movswl %ax,%ecx +[ ]*[a-f0-9]+: 48 63 c8[ ]+movslq %eax,%rcx +[ ]*[a-f0-9]+: 48 0f ca[ ]+bswap %rdx +[ ]*[a-f0-9]+: 41 0f c8[ ]+bswap %r8d [ ]*[a-f0-9]+: c5 fc 77[ ]+vzeroall [ ]*[a-f0-9]+: c4 e1 7c 77[ ]+vzeroall +[ ]*[a-f0-9]+: c4 c1 71 58 d0[ ]+vaddpd %xmm8,%xmm1,%xmm2 +[ ]*[a-f0-9]+: c5 b5 58 d0[ ]+vaddpd %ymm0,%ymm9,%ymm2 +[ ]*[a-f0-9]+: c5 72 58 d0[ ]+vaddss %xmm0,%xmm1,%xmm10 +[ ]*[a-f0-9]+: c4 e3 69 68 19 80[ ]+vfmaddps %xmm8,\(%rcx\),%xmm2,%xmm3 +[ ]*[a-f0-9]+: 67 c4 e3 e9 68 19 00[ ]+vfmaddps \(%ecx\),%xmm0,%xmm2,%xmm3 +[ ]*[a-f0-9]+: c4 c3 e9 68 18 10[ ]+vfmaddps \(%r8\),%xmm1,%xmm2,%xmm3 +[ ]*[a-f0-9]+: c4 c1 78 92 c8[ ]+kmovw %r8d,%k1 +[ ]*[a-f0-9]+: c5 78 93 c1[ ]+kmovw %k1,%r8d +[ ]*[a-f0-9]+: 62 b1 74 38 58 d0[ ]+vaddps \{rd-sae\},%zmm16,%zmm1,%zmm2 +[ ]*[a-f0-9]+: 62 f1 74 10 58 d0[ ]+vaddps \{rn-sae\},%zmm0,%zmm17,%zmm2 +[ ]*[a-f0-9]+: 62 e1 74 58 58 d0[ ]+vaddps \{ru-sae\},%zmm0,%zmm1,%zmm18 +[ ]*[a-f0-9]+: c4 e2 39 92 1c 48[ ]+vgatherdps %xmm8,\(%rax,%xmm1,2\),%xmm3 +[ ]*[a-f0-9]+: c4 c2 79 92 1c 48[ ]+vgatherdps %xmm0,\(%r8,%xmm1,2\),%xmm3 +[ ]*[a-f0-9]+: c4 a2 79 92 1c 48[ ]+vgatherdps %xmm0,\(%rax,%xmm9,2\),%xmm3 +[ ]*[a-f0-9]+: c4 62 79 92 1c 48[ ]+vgatherdps %xmm0,\(%rax,%xmm1,2\),%xmm11 +[ ]*[a-f0-9]+: 62 d2 fd 0c 93 1c 48[ ]+vgatherqpd \(%r8,%xmm1,2\),%xmm3\{%k4\} +[ ]*[a-f0-9]+: 62 b2 fd 0c 93 1c 48[ ]+vgatherqpd \(%rax,%xmm9,2\),%xmm3\{%k4\} +[ ]*[a-f0-9]+: 62 f2 fd 04 93 1c 48[ ]+vgatherqpd \(%rax,%xmm17,2\),%xmm3\{%k4\} +[ ]*[a-f0-9]+: 62 72 fd 0c 93 1c 48[ ]+vgatherqpd \(%rax,%xmm1,2\),%xmm11\{%k4\} +[ ]*[a-f0-9]+: 62 e2 fd 0c 93 1c 48[ ]+vgatherqpd \(%rax,%xmm1,2\),%xmm19\{%k4\} #pass --- a/gas/testsuite/gas/i386/insn-64.s +++ b/gas/testsuite/gas/i386/insn-64.s @@ -13,6 +13,53 @@ insn: # setssbsy .insn 0xf30f01e8 + # mov + .insn 0x8b, %ecx, %r8d + .insn 0x8b, %rax, %rcx + .insn 0x89, %ecx, 8(%r8) + .insn 0x8b, 0x8080(,%r8), %ecx + + # movsx + .insn 0x0fbe, %ah, %cx + .insn 0x0fbf, %eax, %ecx + .insn 0x63, %rax, %rcx + + # bswap + .insn 0x0fc8+r, %rdx + .insn 0x0fc8+r, %r8d + # vzeroall .insn VEX.256.0F.WIG 0x77 .insn {vex3} VEX.L1 0x0f77 + + # vaddpd + .insn VEX.66.0F 0x58, %xmm8, %xmm1, %xmm2 + .insn VEX.66 0x0f58, %ymm0, %ymm9, %ymm2 + + # vaddss + .insn VEX.LIG.F3.0F 0x58, %xmm0, %xmm1, %xmm10 + + # vfmaddps + .insn VEX.66.0F3A.W0 0x68, %xmm8, (%rcx), %xmm2, %xmm3 + .insn VEX.66.0F3A.W1 0x68, %xmm0, (%ecx), %xmm2, %xmm3 + .insn VEX.66.0F3A.W1 0x68, (%r8), %xmm1, %xmm2, %xmm3 + + # kmovw + .insn VEX.L0.0F.W0 0x92, %r8d, %k1 + .insn VEX.L0.0F.W0 0x93, %k1, %r8d + + # vaddps + .insn EVEX.NP.0F.W0 0x58, {rd-sae}, %zmm16, %zmm1, %zmm2 + .insn EVEX.NP.0F.W0 0x58, {rn-sae}, %zmm0, %zmm17, %zmm2 + .insn EVEX.NP.0F.W0 0x58, {ru-sae}, %zmm0, %zmm1, %zmm18 + + # vgather... + .insn VEX.66.0f38.W0 0x92, %xmm8, (%rax, %xmm1, 2), %xmm3 + .insn VEX.66.0f38.W0 0x92, %xmm0, (%r8, %xmm1, 2), %xmm3 + .insn VEX.66.0f38.W0 0x92, %xmm0, (%rax, %xmm9, 2), %xmm3 + .insn VEX.66.0f38.W0 0x92, %xmm0, (%rax, %xmm1, 2), %xmm11 + .insn EVEX.66.0f38.W1 0x93, (%r8, %xmm1, 2), %xmm3{%k4} + .insn EVEX.66.0f38.W1 0x93, (%rax, %xmm9, 2), %xmm3{%k4} + .insn EVEX.66.0f38.W1 0x93, (%rax, %xmm17, 2), %xmm3{%k4} + .insn EVEX.66.0f38.W1 0x93, (%rax, %xmm1, 2), %xmm11{%k4} + .insn EVEX.66.0f38.W1 0x93, (%rax, %xmm1, 2), %xmm19{%k4}