From d31bc9866b1bb85670264f0eb4f7085655b69f38 Mon Sep 17 00:00:00 2001 From: Heejin Ahn Date: Mon, 9 Jul 2018 20:18:21 +0000 Subject: [WebAssembly] Improve readability of load/stores and tests. NFC. Summary: - Changed variable/function names to be more consistent - Improved comments in test files - Added more tests - Fixed a few typos - Misc. cosmetic changes Reviewers: dschuff Subscribers: sbc100, jgravelle-google, sunfish, llvm-commits Differential Revision: https://reviews.llvm.org/D49087 llvm-svn: 336598 --- .../Target/WebAssembly/WebAssemblyInstrAtomics.td | 123 ++++++++++----------- .../Target/WebAssembly/WebAssemblyInstrMemory.td | 65 ++++++----- 2 files changed, 89 insertions(+), 99 deletions(-) (limited to 'llvm/lib/Target/WebAssembly') diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrAtomics.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrAtomics.td index e19de1ac0ef..cac651dc68e 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrAtomics.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrAtomics.td @@ -40,7 +40,6 @@ def : LoadPatGlobalAddr; def : LoadPatExternalSym; def : LoadPatExternalSym; - // Select loads with just a constant offset. def : LoadPatOffsetOnly; def : LoadPatOffsetOnly; @@ -63,7 +62,7 @@ defm ATOMIC_LOAD16_U_I64 : WebAssemblyLoad; defm ATOMIC_LOAD32_U_I64 : WebAssemblyLoad; } // Defs = [ARGUMENTS] -// Fragments for exending loads. These are different from regular loads because +// Fragments for extending loads. These are different from regular loads because // the SDNodes are derived from AtomicSDNode rather than LoadSDNode and // therefore don't have the extension type field. So instead of matching that, // we match the patterns that the type legalizer expands them to. @@ -72,10 +71,10 @@ defm ATOMIC_LOAD32_U_I64 : WebAssemblyLoad; // i32 (zext (i8 (atomic_load_8))) gets legalized to // i32 (and (i32 (atomic_load_8)), 255) // These can be selected to a single zero-extending atomic load instruction. -def zext_aload_8 : PatFrag<(ops node:$addr), - (and (i32 (atomic_load_8 node:$addr)), 255)>; -def zext_aload_16 : PatFrag<(ops node:$addr), - (and (i32 (atomic_load_16 node:$addr)), 65535)>; +def zext_aload_8_32 : + PatFrag<(ops node:$addr), (and (i32 (atomic_load_8 node:$addr)), 255)>; +def zext_aload_16_32 : + PatFrag<(ops node:$addr), (and (i32 (atomic_load_16 node:$addr)), 65535)>; // Unlike regular loads, extension to i64 is handled differently than i32. // i64 (zext (i8 (atomic_load_8))) gets legalized to // i64 (and (i64 (anyext (i32 (atomic_load_8)))), 255) @@ -93,15 +92,15 @@ def zext_aload_32_64 : // match bare subword loads (for 32-bit results) and anyext loads (for 64-bit // results) and select a zext load; the next instruction will be sext_inreg // which is selected by itself. -def anyext_aload_8_64 : +def sext_aload_8_64 : PatFrag<(ops node:$addr), (anyext (i32 (atomic_load_8 node:$addr)))>; -def anyext_aload_16_64 : +def sext_aload_16_64 : PatFrag<(ops node:$addr), (anyext (i32 (atomic_load_16 node:$addr)))>; let Predicates = [HasAtomics] in { // Select zero-extending loads with no constant offset. -def : LoadPatNoOffset; -def : LoadPatNoOffset; +def : LoadPatNoOffset; +def : LoadPatNoOffset; def : LoadPatNoOffset; def : LoadPatNoOffset; def : LoadPatNoOffset; @@ -109,16 +108,15 @@ def : LoadPatNoOffset; // Select sign-extending loads with no constant offset def : LoadPatNoOffset; def : LoadPatNoOffset; -def : LoadPatNoOffset; -def : LoadPatNoOffset; -// 32->64 sext load gets selected as i32.atomic.load, i64.extend_s/i64 - +def : LoadPatNoOffset; +def : LoadPatNoOffset; +// 32->64 sext load gets selected as i32.atomic.load, i64.extend_s/i32 // Zero-extending loads with constant offset -def : LoadPatImmOff; -def : LoadPatImmOff; -def : LoadPatImmOff; -def : LoadPatImmOff; +def : LoadPatImmOff; +def : LoadPatImmOff; +def : LoadPatImmOff; +def : LoadPatImmOff; def : LoadPatImmOff; def : LoadPatImmOff; def : LoadPatImmOff; @@ -131,64 +129,62 @@ def : LoadPatImmOff; def : LoadPatImmOff; def : LoadPatImmOff; def : LoadPatImmOff; -def : LoadPatImmOff; -def : LoadPatImmOff; -def : LoadPatImmOff; -def : LoadPatImmOff; +def : LoadPatImmOff; +def : LoadPatImmOff; +def : LoadPatImmOff; +def : LoadPatImmOff; // No 32->64 patterns, just use i32.atomic.load and i64.extend_s/i64 -def : LoadPatGlobalAddr; -def : LoadPatGlobalAddr; +def : LoadPatGlobalAddr; +def : LoadPatGlobalAddr; def : LoadPatGlobalAddr; def : LoadPatGlobalAddr; def : LoadPatGlobalAddr; def : LoadPatGlobalAddr; def : LoadPatGlobalAddr; -def : LoadPatGlobalAddr; -def : LoadPatGlobalAddr; +def : LoadPatGlobalAddr; +def : LoadPatGlobalAddr; -def : LoadPatExternalSym; -def : LoadPatExternalSym; +def : LoadPatExternalSym; +def : LoadPatExternalSym; def : LoadPatExternalSym; def : LoadPatExternalSym; def : LoadPatExternalSym; def : LoadPatExternalSym; def : LoadPatExternalSym; -def : LoadPatExternalSym; -def : LoadPatExternalSym; - +def : LoadPatExternalSym; +def : LoadPatExternalSym; // Extending loads with just a constant offset -def : LoadPatOffsetOnly; -def : LoadPatOffsetOnly; +def : LoadPatOffsetOnly; +def : LoadPatOffsetOnly; def : LoadPatOffsetOnly; def : LoadPatOffsetOnly; def : LoadPatOffsetOnly; def : LoadPatOffsetOnly; def : LoadPatOffsetOnly; -def : LoadPatOffsetOnly; -def : LoadPatOffsetOnly; +def : LoadPatOffsetOnly; +def : LoadPatOffsetOnly; -def : LoadPatGlobalAddrOffOnly; -def : LoadPatGlobalAddrOffOnly; +def : LoadPatGlobalAddrOffOnly; +def : LoadPatGlobalAddrOffOnly; def : LoadPatGlobalAddrOffOnly; def : LoadPatGlobalAddrOffOnly; def : LoadPatGlobalAddrOffOnly; def : LoadPatGlobalAddrOffOnly; def : LoadPatGlobalAddrOffOnly; -def : LoadPatGlobalAddrOffOnly; -def : LoadPatGlobalAddrOffOnly; +def : LoadPatGlobalAddrOffOnly; +def : LoadPatGlobalAddrOffOnly; -def : LoadPatExternSymOffOnly; -def : LoadPatExternSymOffOnly; +def : LoadPatExternSymOffOnly; +def : LoadPatExternSymOffOnly; def : LoadPatExternSymOffOnly; def : LoadPatExternSymOffOnly; def : LoadPatExternSymOffOnly; def : LoadPatExternSymOffOnly; def : LoadPatExternSymOffOnly; -def : LoadPatExternSymOffOnly; -def : LoadPatExternSymOffOnly; - +def : LoadPatExternSymOffOnly; +def : LoadPatExternSymOffOnly; } // Predicates = [HasAtomics] @@ -209,52 +205,49 @@ defm ATOMIC_STORE_I64 : WebAssemblyStore; let Predicates = [HasAtomics] in { // Select stores with no constant offset. -class AStorePatNoOffset : - Pat<(node I32:$addr, ty:$val), (inst 0, 0, $addr, $val)>; +class AStorePatNoOffset : + Pat<(kind I32:$addr, ty:$val), (inst 0, 0, I32:$addr, ty:$val)>; def : AStorePatNoOffset; def : AStorePatNoOffset; // Select stores with a constant offset. // Pattern with address + immediate offset -class AStorePatImmOff : - Pat<(storekind (operand I32:$addr, imm:$off), ty:$val), - (inst 0, imm:$off, $addr, ty:$val)>; +class AStorePatImmOff : + Pat<(kind (operand I32:$addr, imm:$off), ty:$val), + (inst 0, imm:$off, I32:$addr, ty:$val)>; def : AStorePatImmOff; def : AStorePatImmOff; def : AStorePatImmOff; def : AStorePatImmOff; -class AStorePatGlobalAddr : - Pat<(storekind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)), - ty:$val), +class AStorePatGlobalAddr : + Pat<(kind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)), + ty:$val), (inst 0, tglobaladdr:$off, I32:$addr, ty:$val)>; def : AStorePatGlobalAddr; def : AStorePatGlobalAddr; -class AStorePatExternalSym : - Pat<(storekind (add I32:$addr, (WebAssemblywrapper texternalsym:$off)), - ty:$val), +class AStorePatExternalSym : + Pat<(kind (add I32:$addr, (WebAssemblywrapper texternalsym:$off)), ty:$val), (inst 0, texternalsym:$off, I32:$addr, ty:$val)>; def : AStorePatExternalSym; def : AStorePatExternalSym; // Select stores with just a constant offset. -class AStorePatOffsetOnly : - Pat<(storekind imm:$off, ty:$val), - (inst 0, imm:$off, (CONST_I32 0), ty:$val)>; +class AStorePatOffsetOnly : + Pat<(kind imm:$off, ty:$val), (inst 0, imm:$off, (CONST_I32 0), ty:$val)>; def : AStorePatOffsetOnly; def : AStorePatOffsetOnly; -class AStorePatGlobalAddrOffOnly : - Pat<(storekind (WebAssemblywrapper tglobaladdr:$off), ty:$val), +class AStorePatGlobalAddrOffOnly : + Pat<(kind (WebAssemblywrapper tglobaladdr:$off), ty:$val), (inst 0, tglobaladdr:$off, (CONST_I32 0), ty:$val)>; def : AStorePatGlobalAddrOffOnly; def : AStorePatGlobalAddrOffOnly; -class AStorePatExternSymOffOnly : - Pat<(storekind (WebAssemblywrapper texternalsym:$off), ty:$val), +class AStorePatExternSymOffOnly : + Pat<(kind (WebAssemblywrapper texternalsym:$off), ty:$val), (inst 0, texternalsym:$off, (CONST_I32 0), ty:$val)>; def : AStorePatExternSymOffOnly; def : AStorePatExternSymOffOnly; @@ -275,9 +268,9 @@ defm ATOMIC_STORE32_I64 : WebAssemblyStore; // We don't have single truncating atomic store instructions. For 32-bit // instructions, we just need to match bare atomic stores. On the other hand, // truncating stores from i64 values are once truncated to i32 first. -class trunc_astore_64 : +class trunc_astore_64 : PatFrag<(ops node:$addr, node:$val), - (storekind node:$addr, (i32 (trunc (i64 node:$val))))>; + (kind node:$addr, (i32 (trunc (i64 node:$val))))>; def trunc_astore_8_64 : trunc_astore_64; def trunc_astore_16_64 : trunc_astore_64; def trunc_astore_32_64 : trunc_astore_64; diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td index e97e34b183d..8a49325af2b 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td @@ -75,8 +75,8 @@ defm LOAD_F64 : WebAssemblyLoad; } // Defs = [ARGUMENTS] // Select loads with no constant offset. -class LoadPatNoOffset : - Pat<(ty (node I32:$addr)), (inst 0, 0, $addr)>; +class LoadPatNoOffset : + Pat<(ty (kind I32:$addr)), (inst 0, 0, I32:$addr)>; def : LoadPatNoOffset; def : LoadPatNoOffset; @@ -87,9 +87,8 @@ def : LoadPatNoOffset; // Select loads with a constant offset. // Pattern with address + immediate offset -class LoadPatImmOff : - Pat<(ty (loadkind (operand I32:$addr, imm:$off))), - (inst 0, imm:$off, $addr)>; +class LoadPatImmOff : + Pat<(ty (kind (operand I32:$addr, imm:$off))), (inst 0, imm:$off, I32:$addr)>; def : LoadPatImmOff; def : LoadPatImmOff; @@ -100,18 +99,18 @@ def : LoadPatImmOff; def : LoadPatImmOff; def : LoadPatImmOff; -class LoadPatGlobalAddr : - Pat<(ty (loadkind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)))), - (inst 0, tglobaladdr:$off, $addr)>; +class LoadPatGlobalAddr : + Pat<(ty (kind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)))), + (inst 0, tglobaladdr:$off, I32:$addr)>; def : LoadPatGlobalAddr; def : LoadPatGlobalAddr; def : LoadPatGlobalAddr; def : LoadPatGlobalAddr; -class LoadPatExternalSym : - Pat<(ty (loadkind (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))), - (inst 0, texternalsym:$off, $addr)>; +class LoadPatExternalSym : + Pat<(ty (kind (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))), + (inst 0, texternalsym:$off, I32:$addr)>; def : LoadPatExternalSym; def : LoadPatExternalSym; def : LoadPatExternalSym; @@ -119,16 +118,16 @@ def : LoadPatExternalSym; // Select loads with just a constant offset. -class LoadPatOffsetOnly : - Pat<(ty (loadkind imm:$off)), (inst 0, imm:$off, (CONST_I32 0))>; +class LoadPatOffsetOnly : + Pat<(ty (kind imm:$off)), (inst 0, imm:$off, (CONST_I32 0))>; def : LoadPatOffsetOnly; def : LoadPatOffsetOnly; def : LoadPatOffsetOnly; def : LoadPatOffsetOnly; -class LoadPatGlobalAddrOffOnly : - Pat<(ty (loadkind (WebAssemblywrapper tglobaladdr:$off))), +class LoadPatGlobalAddrOffOnly : + Pat<(ty (kind (WebAssemblywrapper tglobaladdr:$off))), (inst 0, tglobaladdr:$off, (CONST_I32 0))>; def : LoadPatGlobalAddrOffOnly; @@ -136,8 +135,8 @@ def : LoadPatGlobalAddrOffOnly; def : LoadPatGlobalAddrOffOnly; def : LoadPatGlobalAddrOffOnly; -class LoadPatExternSymOffOnly : - Pat<(ty (loadkind (WebAssemblywrapper texternalsym:$off))), +class LoadPatExternSymOffOnly : + Pat<(ty (kind (WebAssemblywrapper texternalsym:$off))), (inst 0, texternalsym:$off, (CONST_I32 0))>; def : LoadPatExternSymOffOnly; def : LoadPatExternSymOffOnly; @@ -326,7 +325,7 @@ defm STORE_F64 : WebAssemblyStore; // Select stores with no constant offset. class StorePatNoOffset : - Pat<(node ty:$val, I32:$addr), (inst 0, 0, $addr, $val)>; + Pat<(node ty:$val, I32:$addr), (inst 0, 0, I32:$addr, ty:$val)>; def : StorePatNoOffset; def : StorePatNoOffset; @@ -334,9 +333,9 @@ def : StorePatNoOffset; def : StorePatNoOffset; // Select stores with a constant offset. -class StorePatImmOff : - Pat<(storekind ty:$val, (operand I32:$addr, imm:$off)), - (inst 0, imm:$off, $addr, ty:$val)>; +class StorePatImmOff : + Pat<(kind ty:$val, (operand I32:$addr, imm:$off)), + (inst 0, imm:$off, I32:$addr, ty:$val)>; def : StorePatImmOff; def : StorePatImmOff; @@ -347,18 +346,17 @@ def : StorePatImmOff; def : StorePatImmOff; def : StorePatImmOff; -class StorePatGlobalAddr : - Pat<(storekind ty:$val, (regPlusGA I32:$addr, - (WebAssemblywrapper tglobaladdr:$off))), +class StorePatGlobalAddr : + Pat<(kind ty:$val, + (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off))), (inst 0, tglobaladdr:$off, I32:$addr, ty:$val)>; def : StorePatGlobalAddr; def : StorePatGlobalAddr; def : StorePatGlobalAddr; def : StorePatGlobalAddr; -class StorePatExternalSym : - Pat<(storekind ty:$val, (add I32:$addr, - (WebAssemblywrapper texternalsym:$off))), +class StorePatExternalSym : + Pat<(kind ty:$val, (add I32:$addr, (WebAssemblywrapper texternalsym:$off))), (inst 0, texternalsym:$off, I32:$addr, ty:$val)>; def : StorePatExternalSym; def : StorePatExternalSym; @@ -366,24 +364,23 @@ def : StorePatExternalSym; def : StorePatExternalSym; // Select stores with just a constant offset. -class StorePatOffsetOnly : - Pat<(storekind ty:$val, imm:$off), - (inst 0, imm:$off, (CONST_I32 0), ty:$val)>; +class StorePatOffsetOnly : + Pat<(kind ty:$val, imm:$off), (inst 0, imm:$off, (CONST_I32 0), ty:$val)>; def : StorePatOffsetOnly; def : StorePatOffsetOnly; def : StorePatOffsetOnly; def : StorePatOffsetOnly; -class StorePatGlobalAddrOffOnly : - Pat<(storekind ty:$val, (WebAssemblywrapper tglobaladdr:$off)), +class StorePatGlobalAddrOffOnly : + Pat<(kind ty:$val, (WebAssemblywrapper tglobaladdr:$off)), (inst 0, tglobaladdr:$off, (CONST_I32 0), ty:$val)>; def : StorePatGlobalAddrOffOnly; def : StorePatGlobalAddrOffOnly; def : StorePatGlobalAddrOffOnly; def : StorePatGlobalAddrOffOnly; -class StorePatExternSymOffOnly : - Pat<(storekind ty:$val, (WebAssemblywrapper texternalsym:$off)), +class StorePatExternSymOffOnly : + Pat<(kind ty:$val, (WebAssemblywrapper texternalsym:$off)), (inst 0, texternalsym:$off, (CONST_I32 0), ty:$val)>; def : StorePatExternSymOffOnly; def : StorePatExternSymOffOnly; -- cgit v1.2.3