AMDGPU: Add instruction definitions for some scratch_* instructions

[arsenm]

Summary

Omit atomics for now since they probably aren't useful.

lib/Target/AMDGPU/AMDGPU.td

def isCIVI : Predicate <
   "Subtarget->getGeneration() >= AMDGPUSubtarget::SEA_ISLANDS">,
   AssemblerPredicate<"FeatureCIInsts">;
 
 def HasFlatAddressSpace : Predicate<"Subtarget->hasFlatAddressSpace()">,
   AssemblerPredicate<"FeatureFlatAddressSpace">;
 
 def HasFlatGlobalInsts : Predicate<"Subtarget->hasFlatGlobalInsts()">,
   AssemblerPredicate<"FeatureFlatGlobalInsts">;
+def HasFlatScratchInsts : Predicate<"Subtarget->hasFlatScratchInsts()">,
+  AssemblerPredicate<"FeatureFlatScratchInsts">;
 
 def Has16BitInsts : Predicate<"Subtarget->has16BitInsts()">,
   AssemblerPredicate<"Feature16BitInsts">;
 def HasVOP3PInsts : Predicate<"Subtarget->hasVOP3PInsts()">,
   AssemblerPredicate<"FeatureVOP3P">;
 
 def HasSDWA : Predicate<"Subtarget->hasSDWA()">,
   AssemblerPredicate<"FeatureSDWA">;

lib/Target/AMDGPU/FLATInstructions.td

 
 defm GLOBAL_ATOMIC_DEC_X2 : FLAT_Atomic_Pseudo <"global_atomic_dec_x2",
                               VReg_64, i64, atomic_dec_global, 1>;
 } // End is_flat_global = 1
 
 } // End SubtargetPredicate = HasFlatGlobalInsts
 
 
+let SubtargetPredicate = HasFlatScratchInsts in {
+def SCRATCH_LOAD_UBYTE    : FLAT_Scratch_Load_Pseudo <"scratch_load_ubyte", VGPR_32>;
+def SCRATCH_LOAD_SBYTE    : FLAT_Scratch_Load_Pseudo <"scratch_load_sbyte", VGPR_32>;
+def SCRATCH_LOAD_USHORT   : FLAT_Scratch_Load_Pseudo <"scratch_load_ushort", VGPR_32>;
+def SCRATCH_LOAD_SSHORT   : FLAT_Scratch_Load_Pseudo <"scratch_load_sshort", VGPR_32>;
+def SCRATCH_LOAD_DWORD    : FLAT_Scratch_Load_Pseudo <"scratch_load_dword", VGPR_32>;
+def SCRATCH_LOAD_DWORDX2  : FLAT_Scratch_Load_Pseudo <"scratch_load_dwordx2", VReg_64>;
+def SCRATCH_LOAD_DWORDX3  : FLAT_Scratch_Load_Pseudo <"scratch_load_dwordx3", VReg_96>;
+def SCRATCH_LOAD_DWORDX4  : FLAT_Scratch_Load_Pseudo <"scratch_load_dwordx4", VReg_128>;
+
+def SCRATCH_STORE_BYTE    : FLAT_Scratch_Store_Pseudo <"scratch_store_byte", VGPR_32>;
+def SCRATCH_STORE_SHORT   : FLAT_Scratch_Store_Pseudo <"scratch_store_short", VGPR_32>;
+def SCRATCH_STORE_DWORD   : FLAT_Scratch_Store_Pseudo <"scratch_store_dword", VGPR_32>;
+def SCRATCH_STORE_DWORDX2 : FLAT_Scratch_Store_Pseudo <"scratch_store_dwordx2", VReg_64>;
+def SCRATCH_STORE_DWORDX3 : FLAT_Scratch_Store_Pseudo <"scratch_store_dwordx3", VReg_96>;
+def SCRATCH_STORE_DWORDX4 : FLAT_Scratch_Store_Pseudo <"scratch_store_dwordx4", VReg_128>;
+
+} // End SubtargetPredicate = HasFlatScratchInsts
+
 //===----------------------------------------------------------------------===//
 // Flat Patterns
 //===----------------------------------------------------------------------===//
 
 class flat_ld <SDPatternOperator ld> : PatFrag<(ops node:$ptr),
                                                (ld node:$ptr), [{
   auto const AS = cast<MemSDNode>(N)->getAddressSpace();
   return AS == AMDGPUASI.FLAT_ADDRESS ||

 defm GLOBAL_ATOMIC_UMIN_X2    : FLAT_Real_Atomics_vi <0x65, GLOBAL_ATOMIC_UMIN_X2>;
 defm GLOBAL_ATOMIC_SMAX_X2    : FLAT_Real_Atomics_vi <0x66, GLOBAL_ATOMIC_SMAX_X2>;
 defm GLOBAL_ATOMIC_UMAX_X2    : FLAT_Real_Atomics_vi <0x67, GLOBAL_ATOMIC_UMAX_X2>;
 defm GLOBAL_ATOMIC_AND_X2     : FLAT_Real_Atomics_vi <0x68, GLOBAL_ATOMIC_AND_X2>;
 defm GLOBAL_ATOMIC_OR_X2      : FLAT_Real_Atomics_vi <0x69, GLOBAL_ATOMIC_OR_X2>;
 defm GLOBAL_ATOMIC_XOR_X2     : FLAT_Real_Atomics_vi <0x6a, GLOBAL_ATOMIC_XOR_X2>;
 defm GLOBAL_ATOMIC_INC_X2     : FLAT_Real_Atomics_vi <0x6b, GLOBAL_ATOMIC_INC_X2>;
 defm GLOBAL_ATOMIC_DEC_X2     : FLAT_Real_Atomics_vi <0x6c, GLOBAL_ATOMIC_DEC_X2>;
+
+def SCRATCH_LOAD_UBYTE_vi : FLAT_Real_vi <0x10, SCRATCH_LOAD_UBYTE>;
+def SCRATCH_LOAD_SBYTE_vi : FLAT_Real_vi <0x11, SCRATCH_LOAD_SBYTE>;
+def SCRATCH_LOAD_USHORT_vi : FLAT_Real_vi <0x12, SCRATCH_LOAD_USHORT>;
+def SCRATCH_LOAD_SSHORT_vi : FLAT_Real_vi <0x13, SCRATCH_LOAD_SSHORT>;
+def SCRATCH_LOAD_DWORD_vi : FLAT_Real_vi <0x14, SCRATCH_LOAD_DWORD>;
+def SCRATCH_LOAD_DWORDX2_vi : FLAT_Real_vi <0x15, SCRATCH_LOAD_DWORDX2>;
+def SCRATCH_LOAD_DWORDX4_vi : FLAT_Real_vi <0x17, SCRATCH_LOAD_DWORDX4>;
+def SCRATCH_LOAD_DWORDX3_vi : FLAT_Real_vi <0x16, SCRATCH_LOAD_DWORDX3>;
+
+def SCRATCH_STORE_BYTE_vi : FLAT_Real_vi <0x18, SCRATCH_STORE_BYTE>;
+def SCRATCH_STORE_SHORT_vi : FLAT_Real_vi <0x1a, SCRATCH_STORE_SHORT>;
+def SCRATCH_STORE_DWORD_vi : FLAT_Real_vi <0x1c, SCRATCH_STORE_DWORD>;
+def SCRATCH_STORE_DWORDX2_vi : FLAT_Real_vi <0x1d, SCRATCH_STORE_DWORDX2>;
+def SCRATCH_STORE_DWORDX4_vi : FLAT_Real_vi <0x1f, SCRATCH_STORE_DWORDX4>;
+def SCRATCH_STORE_DWORDX3_vi : FLAT_Real_vi <0x1e, SCRATCH_STORE_DWORDX3>;

test/MC/AMDGPU/flat-scratch-instructions.s

+// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 -show-encoding %s | FileCheck -check-prefix=GFX9 -check-prefix=GCN %s
+// RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 -show-encoding 2>&1 %s | FileCheck -check-prefix=GFX9-ERR -check-prefix=GCNERR %s
+// RUN: not llvm-mc -arch=amdgcn -mcpu=tonga -show-encoding 2>&1 %s | FileCheck -check-prefix=VI-ERR -check-prefix=GCNERR %s
+
+scratch_load_ubyte v1, v[3:4]
+// GFX9: scratch_load_ubyte v1, v[3:4]      ; encoding: [0x00,0x40,0x40,0xdc,0x03,0x00,0x00,0x01]
+// VI-ERR: instruction not supported on this GPU
+
+scratch_load_sbyte v1, v[3:4]
+// GFX9: scratch_load_sbyte v1, v[3:4]      ; encoding: [0x00,0x40,0x44,0xdc,0x03,0x00,0x00,0x01]
+// VI-ERR: instruction not supported on this GPU
+
+scratch_load_ushort v1, v[3:4]
+// GFX9: scratch_load_ushort v1, v[3:4]      ; encoding: [0x00,0x40,0x48,0xdc,0x03,0x00,0x00,0x01]
+// VI-ERR: instruction not supported on this GPU
+
+scratch_load_sshort v1, v[3:4]
+// GFX9: scratch_load_sshort v1, v[3:4]      ; encoding: [0x00,0x40,0x4c,0xdc,0x03,0x00,0x00,0x01]
+// VI-ERR: instruction not supported on this GPU
+
+scratch_load_dword v1, v[3:4]
+// GFX9: scratch_load_dword v1, v[3:4]      ; encoding: [0x00,0x40,0x50,0xdc,0x03,0x00,0x00,0x01]
+// VI-ERR: instruction not supported on this GPU
+
+scratch_load_dwordx2 v[1:2], v[3:4]
+// GFX9: scratch_load_dwordx2 v[1:2], v[3:4]      ; encoding: [0x00,0x40,0x54,0xdc,0x03,0x00,0x00,0x01]
+// VI-ERR: instruction not supported on this GPU
+
+scratch_load_dwordx3 v[1:3], v[3:4]
+// GFX9: scratch_load_dwordx3 v[1:3], v[3:4]      ; encoding: [0x00,0x40,0x58,0xdc,0x03,0x00,0x00,0x01]
+// VI-ERR: instruction not supported on this GPU
+
+scratch_load_dwordx4 v[1:4], v[3:4]
+// GFX9: scratch_load_dwordx4 v[1:4], v[3:4]      ; encoding: [0x00,0x40,0x5c,0xdc,0x03,0x00,0x00,0x01]
+// VI-ERR: instruction not supported on this GPU
+// FIXME: VI error should be instruction nto supported
+scratch_load_dword v1, v[3:4] offset:0
+// GFX9: scratch_load_dword v1, v[3:4]      ; encoding: [0x00,0x40,0x50,0xdc,0x03,0x00,0x00,0x01]
+// VI-ERR: :37: error: not a valid operand.
+
+scratch_load_dword v1, v[3:4] offset:4095
+// GFX9: scratch_load_dword v1, v[3:4] offset:4095 ; encoding: [0xff,0x4f,0x50,0xdc,0x03,0x00,0x00,0x01]
+// VI-ERR: error: not a valid operand.
+
+scratch_load_dword v1, v[3:4] offset:-1
+// GFX9: scratch_load_dword v1, v[3:4] offset:-1 ; encoding: [0xff,0x5f,0x50,0xdc,0x03,0x00,0x00,0x01]
+// VI-ERR: error: not a valid operand.
+
+scratch_load_dword v1, v[3:4] offset:-4096
+// GFX9: scratch_load_dword v1, v[3:4] offset:-4096 ; encoding: [0x00,0x50,0x50,0xdc,0x03,0x00,0x00,0x01]
+// VI-ERR: error: not a valid operand.
+
+scratch_load_dword v1, v[3:4] offset:4096
+// GFX9-ERR: error: invalid operand for instruction
+// VI-ERR: error: not a valid operand.
+
+scratch_load_dword v1, v[3:4] offset:-4097
+// GFX9-ERR: :31: error: invalid operand for instruction
+// VI-ERR: error: not a valid operand.
+
+scratch_store_byte v[3:4], v1
+// GFX9: scratch_store_byte v[3:4], v1 ; encoding: [0x00,0x40,0x60,0xdc,0x03,0x01,0x00,0x00]
+// VI-ERR: instruction not supported on this GPU
+
+scratch_store_short v[3:4], v1
+// GFX9: scratch_store_short v[3:4], v1 ; encoding: [0x00,0x40,0x68,0xdc,0x03,0x01,0x00,0x00]
+// VI-ERR: instruction not supported on this GPU
+
+scratch_store_dword v[3:4], v1
+// GFX9: scratch_store_dword v[3:4], v1 ; encoding: [0x00,0x40,0x70,0xdc,0x03,0x01,0x00,0x00]
+// VI-ERR: instruction not supported on this GPU
+
+scratch_store_dwordx2 v[3:4], v[1:2]
+// GFX9: scratch_store_dwordx2 v[3:4], v[1:2] ; encoding: [0x00,0x40,0x74,0xdc,0x03,0x01,0x00,0x00]
+// VI-ERR: instruction not supported on this GPU
+
+scratch_store_dwordx3 v[3:4], v[1:3]
+// GFX9: scratch_store_dwordx3 v[3:4], v[1:3] ; encoding: [0x00,0x40,0x78,0xdc,0x03,0x01,0x00,0x00]
+// VI-ERR: instruction not supported on this GPU
+
+scratch_store_dwordx4 v[3:4], v[1:4]
+// GFX9: scratch_store_dwordx4 v[3:4], v[1:4] ; encoding: [0x00,0x40,0x7c,0xdc,0x03,0x01,0x00,0x00]
+// VI-ERR: instruction not supported on this GPU
+
+scratch_store_dword v[3:4], v1 offset:12
+// GFX9: scratch_store_dword v[3:4], v1 offset:12 ; encoding: [0x0c,0x40,0x70,0xdc,0x03,0x01,0x00,0x00]
+// VI-ERR: error: not a valid operand