← Back to branch summary

~pali/+junk/llvm-toolchain-3.7

« back to all changes in this revision

Viewing changes to lib/Target/AMDGPU/CIInstructions.td

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2015-07-15 17:51:08 UTC
  • Revision ID: package-import@ubuntu.com-20150715175108-l8mynwovkx4zx697
Tags: upstream-3.7~+rc2
Import upstream version 3.7~+rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/Target/AMDGPU/CIInstructions.td
 
1
//===-- CIInstructions.td - CI Instruction Defintions ---------------------===//
 
2
//
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
//
 
8
//===----------------------------------------------------------------------===//
 
9
// Instruction definitions for CI and newer.
 
10
//===----------------------------------------------------------------------===//
 
11
 
 
12
 
 
13
def isCIVI : Predicate <
 
14
  "Subtarget->getGeneration() == AMDGPUSubtarget::SEA_ISLANDS || "
 
15
  "Subtarget->getGeneration() == AMDGPUSubtarget::VOLCANIC_ISLANDS"
 
16
>, AssemblerPredicate<"FeatureCIInsts">;
 
17
 
 
18
def HasFlatAddressSpace : Predicate<"Subtarget->hasFlatAddressSpace()">;
 
19
 
 
20
//===----------------------------------------------------------------------===//
 
21
// VOP1 Instructions
 
22
//===----------------------------------------------------------------------===//
 
23
 
 
24
let SubtargetPredicate = isCIVI in {
 
25
 
 
26
defm V_TRUNC_F64 : VOP1Inst <vop1<0x17>, "v_trunc_f64",
 
27
  VOP_F64_F64, ftrunc
 
28
>;
 
29
defm V_CEIL_F64 : VOP1Inst <vop1<0x18>, "v_ceil_f64",
 
30
  VOP_F64_F64, fceil
 
31
>;
 
32
defm V_FLOOR_F64 : VOP1Inst <vop1<0x1A>, "v_floor_f64",
 
33
  VOP_F64_F64, ffloor
 
34
>;
 
35
defm V_RNDNE_F64 : VOP1Inst <vop1<0x19>, "v_rndne_f64",
 
36
  VOP_F64_F64, frint
 
37
>;
 
38
defm V_LOG_LEGACY_F32 : VOP1Inst <vop1<0x45, 0x4c>, "v_log_legacy_f32",
 
39
  VOP_F32_F32
 
40
>;
 
41
defm V_EXP_LEGACY_F32 : VOP1Inst <vop1<0x46, 0x4b>, "v_exp_legacy_f32",
 
42
  VOP_F32_F32
 
43
>;
 
44
 
 
45
//===----------------------------------------------------------------------===//
 
46
// Flat Instructions
 
47
//===----------------------------------------------------------------------===//
 
48
 
 
49
def FLAT_LOAD_UBYTE : FLAT_Load_Helper <0x8, "flat_load_ubyte", VGPR_32>;
 
50
def FLAT_LOAD_SBYTE : FLAT_Load_Helper <0x9, "flat_load_sbyte", VGPR_32>;
 
51
def FLAT_LOAD_USHORT : FLAT_Load_Helper <0xa, "flat_load_ushort", VGPR_32>;
 
52
def FLAT_LOAD_SSHORT : FLAT_Load_Helper <0xb, "flat_load_sshort", VGPR_32>;
 
53
def FLAT_LOAD_DWORD : FLAT_Load_Helper <0xc, "flat_load_dword", VGPR_32>;
 
54
def FLAT_LOAD_DWORDX2 : FLAT_Load_Helper <0xd, "flat_load_dwordx2", VReg_64>;
 
55
def FLAT_LOAD_DWORDX4 : FLAT_Load_Helper <0xe, "flat_load_dwordx4", VReg_128>;
 
56
def FLAT_LOAD_DWORDX3 : FLAT_Load_Helper <0xf, "flat_load_dwordx3", VReg_96>;
 
57
def FLAT_STORE_BYTE : FLAT_Store_Helper <0x18, "flat_store_byte", VGPR_32>;
 
58
def FLAT_STORE_SHORT : FLAT_Store_Helper <0x1a, "flat_store_short", VGPR_32>;
 
59
def FLAT_STORE_DWORD : FLAT_Store_Helper <0x1c, "flat_store_dword", VGPR_32>;
 
60
def FLAT_STORE_DWORDX2 : FLAT_Store_Helper <
 
61
  0x1d, "flat_store_dwordx2", VReg_64
 
62
>;
 
63
def FLAT_STORE_DWORDX4 : FLAT_Store_Helper <
 
64
  0x1e, "flat_store_dwordx4", VReg_128
 
65
>;
 
66
def FLAT_STORE_DWORDX3 : FLAT_Store_Helper <
 
67
  0x1f, "flat_store_dwordx3", VReg_96
 
68
>;
 
69
defm FLAT_ATOMIC_SWAP : FLAT_ATOMIC <0x30, "flat_atomic_swap", VGPR_32>;
 
70
defm FLAT_ATOMIC_CMPSWAP : FLAT_ATOMIC <
 
71
  0x31, "flat_atomic_cmpswap", VGPR_32, VReg_64
 
72
>;
 
73
defm FLAT_ATOMIC_ADD : FLAT_ATOMIC <0x32, "flat_atomic_add", VGPR_32>;
 
74
defm FLAT_ATOMIC_SUB : FLAT_ATOMIC <0x33, "flat_atomic_sub", VGPR_32>;
 
75
defm FLAT_ATOMIC_RSUB : FLAT_ATOMIC <0x34, "flat_atomic_rsub", VGPR_32>;
 
76
defm FLAT_ATOMIC_SMIN : FLAT_ATOMIC <0x35, "flat_atomic_smin", VGPR_32>;
 
77
defm FLAT_ATOMIC_UMIN : FLAT_ATOMIC <0x36, "flat_atomic_umin", VGPR_32>;
 
78
defm FLAT_ATOMIC_SMAX : FLAT_ATOMIC <0x37, "flat_atomic_smax", VGPR_32>;
 
79
defm FLAT_ATOMIC_UMAX : FLAT_ATOMIC <0x38, "flat_atomic_umax", VGPR_32>;
 
80
defm FLAT_ATOMIC_AND : FLAT_ATOMIC <0x39, "flat_atomic_and", VGPR_32>;
 
81
defm FLAT_ATOMIC_OR : FLAT_ATOMIC <0x3a, "flat_atomic_or", VGPR_32>;
 
82
defm FLAT_ATOMIC_XOR : FLAT_ATOMIC <0x3b, "flat_atomic_xor", VGPR_32>;
 
83
defm FLAT_ATOMIC_INC : FLAT_ATOMIC <0x3c, "flat_atomic_inc", VGPR_32>;
 
84
defm FLAT_ATOMIC_DEC : FLAT_ATOMIC <0x3d, "flat_atomic_dec", VGPR_32>;
 
85
defm FLAT_ATOMIC_FCMPSWAP : FLAT_ATOMIC <
 
86
  0x3e, "flat_atomic_fcmpswap", VGPR_32, VReg_64
 
87
>;
 
88
defm FLAT_ATOMIC_FMIN : FLAT_ATOMIC <0x3f, "flat_atomic_fmin", VGPR_32>;
 
89
defm FLAT_ATOMIC_FMAX : FLAT_ATOMIC <0x40, "flat_atomic_fmax", VGPR_32>;
 
90
defm FLAT_ATOMIC_SWAP_X2 : FLAT_ATOMIC <0x50, "flat_atomic_swap_x2", VReg_64>;
 
91
defm FLAT_ATOMIC_CMPSWAP_X2 : FLAT_ATOMIC <
 
92
  0x51, "flat_atomic_cmpswap_x2", VReg_64, VReg_128
 
93
>;
 
94
defm FLAT_ATOMIC_ADD_X2 : FLAT_ATOMIC <0x52, "flat_atomic_add_x2", VReg_64>;
 
95
defm FLAT_ATOMIC_SUB_X2 : FLAT_ATOMIC <0x53, "flat_atomic_sub_x2", VReg_64>;
 
96
defm FLAT_ATOMIC_RSUB_X2 : FLAT_ATOMIC <0x54, "flat_atomic_rsub_x2", VReg_64>;
 
97
defm FLAT_ATOMIC_SMIN_X2 : FLAT_ATOMIC <0x55, "flat_atomic_smin_x2", VReg_64>;
 
98
defm FLAT_ATOMIC_UMIN_X2 : FLAT_ATOMIC <0x56, "flat_atomic_umin_x2", VReg_64>;
 
99
defm FLAT_ATOMIC_SMAX_X2 : FLAT_ATOMIC <0x57, "flat_atomic_smax_x2", VReg_64>;
 
100
defm FLAT_ATOMIC_UMAX_X2 : FLAT_ATOMIC <0x58, "flat_atomic_umax_x2", VReg_64>;
 
101
defm FLAT_ATOMIC_AND_X2 : FLAT_ATOMIC <0x59, "flat_atomic_and_x2", VReg_64>;
 
102
defm FLAT_ATOMIC_OR_X2 : FLAT_ATOMIC <0x5a, "flat_atomic_or_x2", VReg_64>;
 
103
defm FLAT_ATOMIC_XOR_X2 : FLAT_ATOMIC <0x5b, "flat_atomic_xor_x2", VReg_64>;
 
104
defm FLAT_ATOMIC_INC_X2 : FLAT_ATOMIC <0x5c, "flat_atomic_inc_x2", VReg_64>;
 
105
defm FLAT_ATOMIC_DEC_X2 : FLAT_ATOMIC <0x5d, "flat_atomic_dec_x2", VReg_64>;
 
106
defm FLAT_ATOMIC_FCMPSWAP_X2 : FLAT_ATOMIC <
 
107
  0x5e, "flat_atomic_fcmpswap_x2", VReg_64, VReg_128
 
108
>;
 
109
defm FLAT_ATOMIC_FMIN_X2 : FLAT_ATOMIC <0x5f, "flat_atomic_fmin_x2", VReg_64>;
 
110
defm FLAT_ATOMIC_FMAX_X2 : FLAT_ATOMIC <0x60, "flat_atomic_fmax_x2", VReg_64>;
 
111
 
 
112
} // End SubtargetPredicate = isCIVI
 
113
 
 
114
//===----------------------------------------------------------------------===//
 
115
// Flat Patterns
 
116
//===----------------------------------------------------------------------===//
 
117
 
 
118
let Predicates = [HasFlatAddressSpace] in {
 
119
 
 
120
class FLATLoad_Pattern <FLAT Instr_ADDR64, ValueType vt,
 
121
                             PatFrag flat_ld> :
 
122
  Pat <(vt (flat_ld i64:$ptr)),
 
123
       (Instr_ADDR64 $ptr, 0, 0, 0)
 
124
>;
 
125
 
 
126
def : FLATLoad_Pattern <FLAT_LOAD_SBYTE, i32, sextloadi8_flat>;
 
127
def : FLATLoad_Pattern <FLAT_LOAD_UBYTE, i32, az_extloadi8_flat>;
 
128
def : FLATLoad_Pattern <FLAT_LOAD_SSHORT, i32, sextloadi16_flat>;
 
129
def : FLATLoad_Pattern <FLAT_LOAD_USHORT, i32, az_extloadi16_flat>;
 
130
def : FLATLoad_Pattern <FLAT_LOAD_DWORD, i32, flat_load>;
 
131
def : FLATLoad_Pattern <FLAT_LOAD_DWORDX2, i64, flat_load>;
 
132
def : FLATLoad_Pattern <FLAT_LOAD_DWORDX2, i64, az_extloadi32_flat>;
 
133
def : FLATLoad_Pattern <FLAT_LOAD_DWORDX2, v2i32, flat_load>;
 
134
def : FLATLoad_Pattern <FLAT_LOAD_DWORDX4, v4i32, flat_load>;
 
135
 
 
136
class FLATStore_Pattern <FLAT Instr, ValueType vt, PatFrag st> :
 
137
  Pat <(st vt:$value, i64:$ptr),
 
138
        (Instr $value, $ptr, 0, 0, 0)
 
139
  >;
 
140
 
 
141
def : FLATStore_Pattern <FLAT_STORE_BYTE, i32, truncstorei8_flat>;
 
142
def : FLATStore_Pattern <FLAT_STORE_SHORT, i32, truncstorei16_flat>;
 
143
def : FLATStore_Pattern <FLAT_STORE_DWORD, i32, flat_store>;
 
144
def : FLATStore_Pattern <FLAT_STORE_DWORDX2, i64, flat_store>;
 
145
def : FLATStore_Pattern <FLAT_STORE_DWORDX2, v2i32, flat_store>;
 
146
def : FLATStore_Pattern <FLAT_STORE_DWORDX4, v4i32, flat_store>;
 
147
 
 
148
} // End HasFlatAddressSpace predicate
 
149