Blame - llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td - toolchain/llvm-project

2015-08-31 22:24:11 +0000

[diff] [blame]

16

// - HasAddr64

JF Bastien

2015-08-31 22:24:11 +0000

[diff] [blame]

17

// - WebAssemblyTargetLowering having to do with atomics

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

18

// - Each has optional alignment.

JF Bastien

2015-08-31 22:24:11 +0000

[diff] [blame]

19

20

// WebAssembly has i8/i16/i32/i64/f32/f64 memory types, but doesn't have i8/i16

21

// local types. These memory-only types instead zero- or sign-extend into local

22

// types when loading, and truncate when storing.

23

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

24

// WebAssembly constant offsets are performed as unsigned with infinite

25

// precision, so we need to check for NoUnsignedWrap so that we don't fold an

26

// offset for an add that needs wrapping.

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

27

def regPlusImm : PatFrag<(ops node:$addr, node:$off),

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

28

(add node:$addr, node:$off),

29

[{ return N->getFlags()->hasNoUnsignedWrap(); }]>;

30

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

31

// GlobalAddresses are conceptually unsigned values, so we can also fold them

32

// into immediate values as long as their offsets are non-negative.

33

def regPlusGA : PatFrag<(ops node:$addr, node:$off),

34

(add node:$addr, node:$off),

35

[{

36

return N->getFlags()->hasNoUnsignedWrap() ||

37

(N->getOperand(1)->getOpcode() == WebAssemblyISD::Wrapper &&

38

isa<GlobalAddressSDNode>(N->getOperand(1)->getOperand(0)) &&

39

cast<GlobalAddressSDNode>(N->getOperand(1)->getOperand(0))

->getOffset() >= 0);

}]>;

// We don't need a regPlusES because external symbols never have constant

44

// offsets folded into them, so we can just use add.

45

Dan Gohman

2015-11-25 19:36:19 +0000

[diff] [blame]

46

let Defs = [ARGUMENTS] in {

47

JF Bastien

2015-08-31 22:24:11 +0000

[diff] [blame]

48

// Basic load.

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

49

def LOAD_I32 : I<(outs I32:$dst), (ins i32imm:$off, I32:$addr,

50

P2Align:$p2align), [],

51

"i32.load\t$dst, ${off}(${addr})${p2align}">;

52

def LOAD_I64 : I<(outs I64:$dst), (ins i32imm:$off, I32:$addr,

53

P2Align:$p2align), [],

54

"i64.load\t$dst, ${off}(${addr})${p2align}">;

55

def LOAD_F32 : I<(outs F32:$dst), (ins i32imm:$off, I32:$addr,

56

P2Align:$p2align), [],

57

"f32.load\t$dst, ${off}(${addr})${p2align}">;

58

def LOAD_F64 : I<(outs F64:$dst), (ins i32imm:$off, I32:$addr,

59

P2Align:$p2align), [],

60

"f64.load\t$dst, ${off}(${addr})${p2align}">;

JF Bastien

2015-08-31 22:24:11 +0000

[diff] [blame]

61

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

62

} // Defs = [ARGUMENTS]

63

64

// Select loads with no constant offset.

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

65

def : Pat<(i32 (load I32:$addr)), (LOAD_I32 0, $addr, 0)>;

66

def : Pat<(i64 (load I32:$addr)), (LOAD_I64 0, $addr, 0)>;

67

def : Pat<(f32 (load I32:$addr)), (LOAD_F32 0, $addr, 0)>;

68

def : Pat<(f64 (load I32:$addr)), (LOAD_F64 0, $addr, 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

69

70

// Select loads with a constant offset.

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

71

def : Pat<(i32 (load (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

72

(LOAD_I32 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

73

def : Pat<(i64 (load (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

74

(LOAD_I64 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

75

def : Pat<(f32 (load (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

76

(LOAD_F32 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

77

def : Pat<(f64 (load (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

78

(LOAD_F64 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

79

def : Pat<(i32 (load (regPlusGA I32:$addr,

80

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

81

(LOAD_I32 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

82

def : Pat<(i64 (load (regPlusGA I32:$addr,

83

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

84

(LOAD_I64 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

85

def : Pat<(f32 (load (regPlusGA I32:$addr,

86

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

87

(LOAD_F32 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

88

def : Pat<(f64 (load (regPlusGA I32:$addr,

89

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

90

(LOAD_F64 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

91

def : Pat<(i32 (load (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

92

(LOAD_I32 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

93

def : Pat<(i64 (load (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

94

(LOAD_I64 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

95

def : Pat<(f32 (load (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

96

(LOAD_F32 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

97

def : Pat<(f64 (load (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

98

(LOAD_F64 texternalsym:$off, $addr, 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

99

100

// Select loads with just a constant offset.

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

101

def : Pat<(i32 (load imm:$off)), (LOAD_I32 imm:$off, (CONST_I32 0), 0)>;

102

def : Pat<(i64 (load imm:$off)), (LOAD_I64 imm:$off, (CONST_I32 0), 0)>;

103

def : Pat<(f32 (load imm:$off)), (LOAD_F32 imm:$off, (CONST_I32 0), 0)>;

104

def : Pat<(f64 (load imm:$off)), (LOAD_F64 imm:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

105

def : Pat<(i32 (load (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

106

(LOAD_I32 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

107

def : Pat<(i64 (load (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

108

(LOAD_I64 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

109

def : Pat<(f32 (load (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

110

(LOAD_F32 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

111

def : Pat<(f64 (load (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

112

(LOAD_F64 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

113

def : Pat<(i32 (load (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

114

(LOAD_I32 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

115

def : Pat<(i64 (load (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

116

(LOAD_I64 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

117

def : Pat<(f32 (load (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

118

(LOAD_F32 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

119

def : Pat<(f64 (load (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

120

(LOAD_F64 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

121

122

let Defs = [ARGUMENTS] in {

123

JF Bastien

2015-08-31 22:24:11 +0000

[diff] [blame]

124

// Extending load.

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

125

def LOAD8_S_I32 : I<(outs I32:$dst), (ins i32imm:$off, I32:$addr,

126

P2Align:$p2align), [],

127

"i32.load8_s\t$dst, ${off}(${addr})${p2align}">;

128

def LOAD8_U_I32 : I<(outs I32:$dst), (ins i32imm:$off, I32:$addr,

129

P2Align:$p2align), [],

130

"i32.load8_u\t$dst, ${off}(${addr})${p2align}">;

131

def LOAD16_S_I32 : I<(outs I32:$dst), (ins i32imm:$off, I32:$addr,

132

P2Align:$p2align), [],

133

"i32.load16_s\t$dst, ${off}(${addr})${p2align}">;

134

def LOAD16_U_I32 : I<(outs I32:$dst), (ins i32imm:$off, I32:$addr,

135

P2Align:$p2align), [],

136

"i32.load16_u\t$dst, ${off}(${addr})${p2align}">;

137

def LOAD8_S_I64 : I<(outs I64:$dst), (ins i32imm:$off, I32:$addr,

138

P2Align:$p2align), [],

139

"i64.load8_s\t$dst, ${off}(${addr})${p2align}">;

140

def LOAD8_U_I64 : I<(outs I64:$dst), (ins i32imm:$off, I32:$addr,

141

P2Align:$p2align), [],

142

"i64.load8_u\t$dst, ${off}(${addr})${p2align}">;

143

def LOAD16_S_I64 : I<(outs I64:$dst), (ins i32imm:$off, I32:$addr,

144

P2Align:$p2align), [],

145

"i64.load16_s\t$dst, ${off}(${addr})${p2align}">;

146

def LOAD16_U_I64 : I<(outs I64:$dst), (ins i32imm:$off, I32:$addr,

147

P2Align:$p2align), [],

148

"i64.load16_u\t$dst, ${off}(${addr})${p2align}">;

149

def LOAD32_S_I64 : I<(outs I64:$dst), (ins i32imm:$off, I32:$addr,

150

P2Align:$p2align), [],

151

"i64.load32_s\t$dst, ${off}(${addr})${p2align}">;

152

def LOAD32_U_I64 : I<(outs I64:$dst), (ins i32imm:$off, I32:$addr,

153

P2Align:$p2align), [],

154

"i64.load32_u\t$dst, ${off}(${addr})${p2align}">;

JF Bastien

2015-08-31 22:24:11 +0000

[diff] [blame]

155

Dan Gohman

2015-11-25 19:36:19 +0000

[diff] [blame]

156

} // Defs = [ARGUMENTS]

157

Derek Schuff

9d77952

2015-12-05 00:26:39 +0000

[diff] [blame]

158

// Select extending loads with no constant offset.

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

159

def : Pat<(i32 (sextloadi8 I32:$addr)), (LOAD8_S_I32 0, $addr, 0)>;

160

def : Pat<(i32 (zextloadi8 I32:$addr)), (LOAD8_U_I32 0, $addr, 0)>;

161

def : Pat<(i32 (sextloadi16 I32:$addr)), (LOAD16_S_I32 0, $addr, 0)>;

162

def : Pat<(i32 (zextloadi16 I32:$addr)), (LOAD16_U_I32 0, $addr, 0)>;

163

def : Pat<(i64 (sextloadi8 I32:$addr)), (LOAD8_S_I64 0, $addr, 0)>;

164

def : Pat<(i64 (zextloadi8 I32:$addr)), (LOAD8_U_I64 0, $addr, 0)>;

165

def : Pat<(i64 (sextloadi16 I32:$addr)), (LOAD16_S_I64 0, $addr, 0)>;

166

def : Pat<(i64 (zextloadi16 I32:$addr)), (LOAD16_U_I64 0, $addr, 0)>;

167

def : Pat<(i64 (sextloadi32 I32:$addr)), (LOAD32_S_I64 0, $addr, 0)>;

168

def : Pat<(i64 (zextloadi32 I32:$addr)), (LOAD32_U_I64 0, $addr, 0)>;

Derek Schuff

9d77952

2015-12-05 00:26:39 +0000

[diff] [blame]

169

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

170

// Select extending loads with a constant offset.

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

171

def : Pat<(i32 (sextloadi8 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

172

(LOAD8_S_I32 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

173

def : Pat<(i32 (zextloadi8 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

174

(LOAD8_U_I32 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

175

def : Pat<(i32 (sextloadi16 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

176

(LOAD16_S_I32 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

177

def : Pat<(i32 (zextloadi16 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

178

(LOAD16_U_I32 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

179

def : Pat<(i64 (sextloadi8 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

180

(LOAD8_S_I64 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

181

def : Pat<(i64 (zextloadi8 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

182

(LOAD8_U_I64 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

183

def : Pat<(i64 (sextloadi16 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

184

(LOAD16_S_I64 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

185

def : Pat<(i64 (zextloadi16 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

186

(LOAD16_U_I64 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

187

def : Pat<(i64 (sextloadi32 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

188

(LOAD32_S_I64 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

189

def : Pat<(i64 (zextloadi32 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

190

(LOAD32_U_I64 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

191

def : Pat<(i32 (sextloadi8 (regPlusGA I32:$addr,

192

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

193

(LOAD8_S_I32 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

194

def : Pat<(i32 (zextloadi8 (regPlusGA I32:$addr,

195

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

196

(LOAD8_U_I32 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

197

def : Pat<(i32 (sextloadi16 (regPlusGA I32:$addr,

198

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

199

(LOAD16_S_I32 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

200

def : Pat<(i32 (zextloadi16 (regPlusGA I32:$addr,

201

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

202

(LOAD16_U_I32 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

203

def : Pat<(i64 (sextloadi8 (regPlusGA I32:$addr,

204

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

205

(LOAD8_S_I64 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

206

def : Pat<(i64 (zextloadi8 (regPlusGA I32:$addr,

207

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

208

(LOAD8_U_I64 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

209

def : Pat<(i64 (sextloadi16 (regPlusGA I32:$addr,

210

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

211

(LOAD16_S_I64 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

212

def : Pat<(i64 (zextloadi16 (regPlusGA I32:$addr,

213

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

214

(LOAD16_U_I64 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

215

def : Pat<(i64 (sextloadi32 (regPlusGA I32:$addr,

216

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

217

(LOAD32_S_I64 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

218

def : Pat<(i64 (zextloadi32 (regPlusGA I32:$addr,

219

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

220

(LOAD32_U_I64 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

221

def : Pat<(i32 (sextloadi8 (add I32:$addr,

222

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

223

(LOAD8_S_I32 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

224

def : Pat<(i32 (zextloadi8 (add I32:$addr,

225

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

226

(LOAD8_U_I32 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

227

def : Pat<(i32 (sextloadi16 (add I32:$addr,

228

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

229

(LOAD16_S_I32 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

230

def : Pat<(i32 (zextloadi16 (add I32:$addr,

231

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

232

(LOAD16_U_I32 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

233

def : Pat<(i64 (sextloadi8 (add I32:$addr,

234

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

235

(LOAD8_S_I64 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

236

def : Pat<(i64 (zextloadi8 (add I32:$addr,

237

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

238

(LOAD8_U_I64 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

239

def : Pat<(i64 (sextloadi16 (add I32:$addr,

240

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

241

(LOAD16_S_I64 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

242

def : Pat<(i64 (zextloadi16 (add I32:$addr,

243

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

244

(LOAD16_U_I64 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

245

def : Pat<(i64 (sextloadi32 (add I32:$addr,

246

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

247

(LOAD32_S_I64 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

248

def : Pat<(i64 (zextloadi32 (add I32:$addr,

249

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

250

(LOAD32_U_I64 texternalsym:$off, $addr, 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

251

252

// Select extending loads with just a constant offset.

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

253

def : Pat<(i32 (sextloadi8 imm:$off)),

254

(LOAD8_S_I32 imm:$off, (CONST_I32 0), 0)>;

255

def : Pat<(i32 (zextloadi8 imm:$off)),

256

(LOAD8_U_I32 imm:$off, (CONST_I32 0), 0)>;

257

def : Pat<(i32 (sextloadi16 imm:$off)),

258

(LOAD16_S_I32 imm:$off, (CONST_I32 0), 0)>;

259

def : Pat<(i32 (zextloadi16 imm:$off)),

260

(LOAD16_U_I32 imm:$off, (CONST_I32 0), 0)>;

261

def : Pat<(i64 (sextloadi8 imm:$off)),

262

(LOAD8_S_I64 imm:$off, (CONST_I32 0), 0)>;

263

def : Pat<(i64 (zextloadi8 imm:$off)),

264

(LOAD8_U_I64 imm:$off, (CONST_I32 0), 0)>;

265

def : Pat<(i64 (sextloadi16 imm:$off)),

266

(LOAD16_S_I64 imm:$off, (CONST_I32 0), 0)>;

267

def : Pat<(i64 (zextloadi16 imm:$off)),

268

(LOAD16_U_I64 imm:$off, (CONST_I32 0), 0)>;

269

def : Pat<(i64 (sextloadi32 imm:$off)),

270

(LOAD32_S_I64 imm:$off, (CONST_I32 0), 0)>;

271

def : Pat<(i64 (zextloadi32 imm:$off)),

272

(LOAD32_U_I64 imm:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

273

def : Pat<(i32 (sextloadi8 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

274

(LOAD8_S_I32 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

275

def : Pat<(i32 (zextloadi8 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

276

(LOAD8_U_I32 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

277

def : Pat<(i32 (sextloadi16 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

278

(LOAD16_S_I32 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

279

def : Pat<(i32 (zextloadi16 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

280

(LOAD16_U_I32 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

281

def : Pat<(i64 (sextloadi8 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

282

(LOAD8_S_I64 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

283

def : Pat<(i64 (zextloadi8 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

284

(LOAD8_U_I64 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

285

def : Pat<(i64 (sextloadi16 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

286

(LOAD16_S_I64 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

287

def : Pat<(i64 (zextloadi16 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

288

(LOAD16_U_I64 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

289

def : Pat<(i64 (sextloadi32 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

290

(LOAD32_S_I64 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

291

def : Pat<(i64 (zextloadi32 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

292

(LOAD32_U_I64 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

293

def : Pat<(i32 (sextloadi8 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

294

(LOAD8_S_I32 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

295

def : Pat<(i32 (zextloadi8 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

296

(LOAD8_U_I32 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

297

def : Pat<(i32 (sextloadi16 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

298

(LOAD16_S_I32 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

299

def : Pat<(i32 (zextloadi16 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

300

(LOAD16_U_I32 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

301

def : Pat<(i64 (sextloadi8 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

302

(LOAD8_S_I64 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

303

def : Pat<(i64 (zextloadi8 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

304

(LOAD8_U_I64 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

305

def : Pat<(i64 (sextloadi16 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

306

(LOAD16_S_I64 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

307

def : Pat<(i64 (zextloadi16 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

308

(LOAD16_U_I64 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

309

def : Pat<(i64 (sextloadi32 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

310

(LOAD32_S_I64 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

311

def : Pat<(i64 (zextloadi32 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

312

(LOAD32_U_I64 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

313

314

// Resolve "don't care" extending loads to zero-extending loads. This is

315

// somewhat arbitrary, but zero-extending is conceptually simpler.

316

317

// Select "don't care" extending loads with no constant offset.

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

318

def : Pat<(i32 (extloadi8 I32:$addr)), (LOAD8_U_I32 0, $addr, 0)>;

319

def : Pat<(i32 (extloadi16 I32:$addr)), (LOAD16_U_I32 0, $addr, 0)>;

320

def : Pat<(i64 (extloadi8 I32:$addr)), (LOAD8_U_I64 0, $addr, 0)>;

321

def : Pat<(i64 (extloadi16 I32:$addr)), (LOAD16_U_I64 0, $addr, 0)>;

322

def : Pat<(i64 (extloadi32 I32:$addr)), (LOAD32_U_I64 0, $addr, 0)>;

JF Bastien

2015-08-31 22:24:11 +0000

[diff] [blame]

323

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

324

// Select "don't care" extending loads with a constant offset.

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

325

def : Pat<(i32 (extloadi8 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

326

(LOAD8_U_I32 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

327

def : Pat<(i32 (extloadi16 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

328

(LOAD16_U_I32 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

329

def : Pat<(i64 (extloadi8 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

330

(LOAD8_U_I64 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

331

def : Pat<(i64 (extloadi16 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

332

(LOAD16_U_I64 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

333

def : Pat<(i64 (extloadi32 (regPlusImm I32:$addr, imm:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

334

(LOAD32_U_I64 imm:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

335

def : Pat<(i32 (extloadi8 (regPlusGA I32:$addr,

336

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

337

(LOAD8_U_I32 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

338

def : Pat<(i32 (extloadi16 (regPlusGA I32:$addr,

339

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

340

(LOAD16_U_I32 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

341

def : Pat<(i64 (extloadi8 (regPlusGA I32:$addr,

342

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

343

(LOAD8_U_I64 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

344

def : Pat<(i64 (extloadi16 (regPlusGA I32:$addr,

345

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

346

(LOAD16_U_I64 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

347

def : Pat<(i64 (extloadi32 (regPlusGA I32:$addr,

348

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

349

(LOAD32_U_I64 tglobaladdr:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

350

def : Pat<(i32 (extloadi8 (add I32:$addr,

351

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

352

(LOAD8_U_I32 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

353

def : Pat<(i32 (extloadi16 (add I32:$addr,

354

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

355

(LOAD16_U_I32 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

356

def : Pat<(i64 (extloadi8 (add I32:$addr,

357

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

358

(LOAD8_U_I64 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

359

def : Pat<(i64 (extloadi16 (add I32:$addr,

360

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

361

(LOAD16_U_I64 texternalsym:$off, $addr, 0)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

362

def : Pat<(i64 (extloadi32 (add I32:$addr,

363

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

364

(LOAD32_U_I64 texternalsym:$off, $addr, 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

365

366

// Select "don't care" extending loads with just a constant offset.

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

367

def : Pat<(i32 (extloadi8 imm:$off)),

368

(LOAD8_U_I32 imm:$off, (CONST_I32 0), 0)>;

369

def : Pat<(i32 (extloadi16 imm:$off)),

370

(LOAD16_U_I32 imm:$off, (CONST_I32 0), 0)>;

371

def : Pat<(i64 (extloadi8 imm:$off)),

372

(LOAD8_U_I64 imm:$off, (CONST_I32 0), 0)>;

373

def : Pat<(i64 (extloadi16 imm:$off)),

374

(LOAD16_U_I64 imm:$off, (CONST_I32 0), 0)>;

375

def : Pat<(i64 (extloadi32 imm:$off)),

376

(LOAD32_U_I64 imm:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

377

def : Pat<(i32 (extloadi8 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

378

(LOAD8_U_I32 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

379

def : Pat<(i32 (extloadi16 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

380

(LOAD16_U_I32 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

381

def : Pat<(i64 (extloadi8 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

382

(LOAD8_U_I64 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

383

def : Pat<(i64 (extloadi16 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

384

(LOAD16_U_I64 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

385

def : Pat<(i64 (extloadi32 (WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

386

(LOAD32_U_I64 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

387

def : Pat<(i32 (extloadi8 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

388

(LOAD8_U_I32 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

389

def : Pat<(i32 (extloadi16 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

390

(LOAD16_U_I32 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

391

def : Pat<(i64 (extloadi8 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

392

(LOAD8_U_I64 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

393

def : Pat<(i64 (extloadi16 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

394

(LOAD16_U_I64 texternalsym:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

395

def : Pat<(i64 (extloadi32 (WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

396

(LOAD32_U_I64 tglobaladdr:$off, (CONST_I32 0), 0)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

397

Dan Gohman

2015-11-25 19:36:19 +0000

[diff] [blame]

398

let Defs = [ARGUMENTS] in {

399

JF Bastien

2015-08-31 22:24:11 +0000

[diff] [blame]

400

// Basic store.

Dan Gohman

2015-11-23 21:16:35 +0000

[diff] [blame]

401

// Note that we split the patterns out of the instruction definitions because

402

// WebAssembly's stores return their operand value, and tablegen doesn't like

403

// instruction definition patterns that don't reference all of the output

404

// operands.

JF Bastien

2015-08-31 22:24:11 +0000

[diff] [blame]

405

// Note: WebAssembly inverts SelectionDAG's usual operand order.

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

406

def STORE_I32 : I<(outs I32:$dst), (ins i32imm:$off, I32:$addr,

407

P2Align:$p2align, I32:$val), [],

408

"i32.store\t$dst, ${off}(${addr})${p2align}, $val">;

409

def STORE_I64 : I<(outs I64:$dst), (ins i32imm:$off, I32:$addr,

410

P2Align:$p2align, I64:$val), [],

411

"i64.store\t$dst, ${off}(${addr})${p2align}, $val">;

412

def STORE_F32 : I<(outs F32:$dst), (ins i32imm:$off, I32:$addr,

413

P2Align:$p2align, F32:$val), [],

414

"f32.store\t$dst, ${off}(${addr})${p2align}, $val">;

415

def STORE_F64 : I<(outs F64:$dst), (ins i32imm:$off, I32:$addr,

416

P2Align:$p2align, F64:$val), [],

417

"f64.store\t$dst, ${off}(${addr})${p2align}, $val">;

Dan Gohman

2015-11-23 21:16:35 +0000

[diff] [blame]

418

Dan Gohman

2015-11-25 19:36:19 +0000

[diff] [blame]

419

} // Defs = [ARGUMENTS]

420

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

421

// Select stores with no constant offset.

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

422

def : Pat<(store I32:$val, I32:$addr), (STORE_I32 0, I32:$addr, 0, I32:$val)>;

423

def : Pat<(store I64:$val, I32:$addr), (STORE_I64 0, I32:$addr, 0, I64:$val)>;

424

def : Pat<(store F32:$val, I32:$addr), (STORE_F32 0, I32:$addr, 0, F32:$val)>;

425

def : Pat<(store F64:$val, I32:$addr), (STORE_F64 0, I32:$addr, 0, F64:$val)>;

Derek Schuff

9d77952

2015-12-05 00:26:39 +0000

[diff] [blame]

426

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

427

// Select stores with a constant offset.

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

428

def : Pat<(store I32:$val, (regPlusImm I32:$addr, imm:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

429

(STORE_I32 imm:$off, I32:$addr, 0, I32:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

430

def : Pat<(store I64:$val, (regPlusImm I32:$addr, imm:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

431

(STORE_I64 imm:$off, I32:$addr, 0, I64:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

432

def : Pat<(store F32:$val, (regPlusImm I32:$addr, imm:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

433

(STORE_F32 imm:$off, I32:$addr, 0, F32:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

434

def : Pat<(store F64:$val, (regPlusImm I32:$addr, imm:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

435

(STORE_F64 imm:$off, I32:$addr, 0, F64:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

436

def : Pat<(store I32:$val, (regPlusGA I32:$addr,

437

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

438

(STORE_I32 tglobaladdr:$off, I32:$addr, 0, I32:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

439

def : Pat<(store I64:$val, (regPlusGA I32:$addr,

440

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

441

(STORE_I64 tglobaladdr:$off, I32:$addr, 0, I64:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

442

def : Pat<(store F32:$val, (regPlusGA I32:$addr,

443

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

444

(STORE_F32 tglobaladdr:$off, I32:$addr, 0, F32:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

445

def : Pat<(store F64:$val, (regPlusGA I32:$addr,

446

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

447

(STORE_F64 tglobaladdr:$off, I32:$addr, 0, F64:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

448

def : Pat<(store I32:$val, (add I32:$addr,

449

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

450

(STORE_I32 texternalsym:$off, I32:$addr, 0, I32:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

451

def : Pat<(store I64:$val, (add I32:$addr,

452

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

453

(STORE_I64 texternalsym:$off, I32:$addr, 0, I64:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

454

def : Pat<(store F32:$val, (add I32:$addr,

455

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

456

(STORE_F32 texternalsym:$off, I32:$addr, 0, F32:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

457

def : Pat<(store F64:$val, (add I32:$addr,

458

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

459

(STORE_F64 texternalsym:$off, I32:$addr, 0, F64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

460

461

// Select stores with just a constant offset.

462

def : Pat<(store I32:$val, imm:$off),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

463

(STORE_I32 imm:$off, (CONST_I32 0), 0, I32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

464

def : Pat<(store I64:$val, imm:$off),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

465

(STORE_I64 imm:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

466

def : Pat<(store F32:$val, imm:$off),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

467

(STORE_F32 imm:$off, (CONST_I32 0), 0, F32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

468

def : Pat<(store F64:$val, imm:$off),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

469

(STORE_F64 imm:$off, (CONST_I32 0), 0, F64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

470

def : Pat<(store I32:$val, (WebAssemblywrapper tglobaladdr:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

471

(STORE_I32 tglobaladdr:$off, (CONST_I32 0), 0, I32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

472

def : Pat<(store I64:$val, (WebAssemblywrapper tglobaladdr:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

473

(STORE_I64 tglobaladdr:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

474

def : Pat<(store F32:$val, (WebAssemblywrapper tglobaladdr:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

475

(STORE_F32 tglobaladdr:$off, (CONST_I32 0), 0, F32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

476

def : Pat<(store F64:$val, (WebAssemblywrapper tglobaladdr:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

477

(STORE_F64 tglobaladdr:$off, (CONST_I32 0), 0, F64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

478

def : Pat<(store I32:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

479

(STORE_I32 texternalsym:$off, (CONST_I32 0), 0, I32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

480

def : Pat<(store I64:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

481

(STORE_I64 texternalsym:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

482

def : Pat<(store F32:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

483

(STORE_F32 texternalsym:$off, (CONST_I32 0), 0, F32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

484

def : Pat<(store F64:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

485

(STORE_F64 texternalsym:$off, (CONST_I32 0), 0, F64:$val)>;

JF Bastien

2015-08-31 22:24:11 +0000

[diff] [blame]

486

Dan Gohman

2015-11-25 19:36:19 +0000

[diff] [blame]

487

let Defs = [ARGUMENTS] in {

488

JF Bastien

2015-08-31 22:24:11 +0000

[diff] [blame]

489

// Truncating store.

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

490

def STORE8_I32 : I<(outs I32:$dst), (ins i32imm:$off, I32:$addr,

491

P2Align:$p2align, I32:$val), [],

492

"i32.store8\t$dst, ${off}(${addr})${p2align}, $val">;

493

def STORE16_I32 : I<(outs I32:$dst), (ins i32imm:$off, I32:$addr,

494

P2Align:$p2align, I32:$val), [],

495

"i32.store16\t$dst, ${off}(${addr})${p2align}, $val">;

496

def STORE8_I64 : I<(outs I64:$dst), (ins i32imm:$off, I32:$addr,

497

P2Align:$p2align, I64:$val), [],

498

"i64.store8\t$dst, ${off}(${addr})${p2align}, $val">;

499

def STORE16_I64 : I<(outs I64:$dst), (ins i32imm:$off, I32:$addr,

500

P2Align:$p2align, I64:$val), [],

501

"i64.store16\t$dst, ${off}(${addr})${p2align}, $val">;

502

def STORE32_I64 : I<(outs I64:$dst), (ins i32imm:$off, I32:$addr,

503

P2Align:$p2align, I64:$val), [],

504

"i64.store32\t$dst, ${off}(${addr})${p2align}, $val">;

Dan Gohman

2015-11-23 21:16:35 +0000

[diff] [blame]

505

Dan Gohman

2015-11-25 19:36:19 +0000

[diff] [blame]

506

} // Defs = [ARGUMENTS]

507

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

508

// Select truncating stores with no constant offset.

Dan Gohman

2015-11-23 21:16:35 +0000

[diff] [blame]

509

def : Pat<(truncstorei8 I32:$val, I32:$addr),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

510

(STORE8_I32 0, I32:$addr, 0, I32:$val)>;

Dan Gohman

2015-11-23 21:16:35 +0000

[diff] [blame]

511

def : Pat<(truncstorei16 I32:$val, I32:$addr),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

512

(STORE16_I32 0, I32:$addr, 0, I32:$val)>;

Dan Gohman

2015-11-23 21:16:35 +0000

[diff] [blame]

513

def : Pat<(truncstorei8 I64:$val, I32:$addr),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

514

(STORE8_I64 0, I32:$addr, 0, I64:$val)>;

Dan Gohman

2015-11-23 21:16:35 +0000

[diff] [blame]

515

def : Pat<(truncstorei16 I64:$val, I32:$addr),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

516

(STORE16_I64 0, I32:$addr, 0, I64:$val)>;

Dan Gohman

2015-11-23 21:16:35 +0000

[diff] [blame]

517

def : Pat<(truncstorei32 I64:$val, I32:$addr),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

518

(STORE32_I64 0, I32:$addr, 0, I64:$val)>;

JF Bastien

2015-08-31 22:24:11 +0000

[diff] [blame]

519

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

520

// Select truncating stores with a constant offset.

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

521

def : Pat<(truncstorei8 I32:$val, (regPlusImm I32:$addr, imm:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

522

(STORE8_I32 imm:$off, I32:$addr, 0, I32:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

523

def : Pat<(truncstorei16 I32:$val, (regPlusImm I32:$addr, imm:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

524

(STORE16_I32 imm:$off, I32:$addr, 0, I32:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

525

def : Pat<(truncstorei8 I64:$val, (regPlusImm I32:$addr, imm:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

526

(STORE8_I64 imm:$off, I32:$addr, 0, I64:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

527

def : Pat<(truncstorei16 I64:$val, (regPlusImm I32:$addr, imm:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

528

(STORE16_I64 imm:$off, I32:$addr, 0, I64:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

529

def : Pat<(truncstorei32 I64:$val, (regPlusImm I32:$addr, imm:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

530

(STORE32_I64 imm:$off, I32:$addr, 0, I64:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

531

def : Pat<(truncstorei8 I32:$val,

532

(regPlusGA I32:$addr,

533

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

534

(STORE8_I32 tglobaladdr:$off, I32:$addr, 0, I32:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

535

def : Pat<(truncstorei16 I32:$val,

536

(regPlusGA I32:$addr,

537

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

538

(STORE16_I32 tglobaladdr:$off, I32:$addr, 0, I32:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

539

def : Pat<(truncstorei8 I64:$val,

540

(regPlusGA I32:$addr,

541

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

542

(STORE8_I64 tglobaladdr:$off, I32:$addr, 0, I64:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

543

def : Pat<(truncstorei16 I64:$val,

544

(regPlusGA I32:$addr,

545

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

546

(STORE16_I64 tglobaladdr:$off, I32:$addr, 0, I64:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

547

def : Pat<(truncstorei32 I64:$val,

548

(regPlusGA I32:$addr,

549

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

550

(STORE32_I64 tglobaladdr:$off, I32:$addr, 0, I64:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

551

def : Pat<(truncstorei8 I32:$val, (add I32:$addr,

552

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

553

(STORE8_I32 texternalsym:$off, I32:$addr, 0, I32:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

554

def : Pat<(truncstorei16 I32:$val,

555

(add I32:$addr,

556

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

557

(STORE16_I32 texternalsym:$off, I32:$addr, 0, I32:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

558

def : Pat<(truncstorei8 I64:$val,

559

(add I32:$addr,

560

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

561

(STORE8_I64 texternalsym:$off, I32:$addr, 0, I64:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

562

def : Pat<(truncstorei16 I64:$val,

563

(add I32:$addr,

564

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

565

(STORE16_I64 texternalsym:$off, I32:$addr, 0, I64:$val)>;

Dan Gohman

2016-01-11 22:05:44 +0000

[diff] [blame]

566

def : Pat<(truncstorei32 I64:$val,

567

(add I32:$addr,

568

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

569

(STORE32_I64 texternalsym:$off, I32:$addr, 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

570

571

// Select truncating stores with just a constant offset.

572

def : Pat<(truncstorei8 I32:$val, imm:$off),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

573

(STORE8_I32 imm:$off, (CONST_I32 0), 0, I32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

574

def : Pat<(truncstorei16 I32:$val, imm:$off),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

575

(STORE16_I32 imm:$off, (CONST_I32 0), 0, I32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

576

def : Pat<(truncstorei8 I64:$val, imm:$off),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

577

(STORE8_I64 imm:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

578

def : Pat<(truncstorei16 I64:$val, imm:$off),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

579

(STORE16_I64 imm:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

580

def : Pat<(truncstorei32 I64:$val, imm:$off),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

581

(STORE32_I64 imm:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

582

def : Pat<(truncstorei8 I32:$val, (WebAssemblywrapper tglobaladdr:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

583

(STORE8_I32 tglobaladdr:$off, (CONST_I32 0), 0, I32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

584

def : Pat<(truncstorei16 I32:$val, (WebAssemblywrapper tglobaladdr:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

585

(STORE16_I32 tglobaladdr:$off, (CONST_I32 0), 0, I32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

586

def : Pat<(truncstorei8 I64:$val, (WebAssemblywrapper tglobaladdr:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

587

(STORE8_I64 tglobaladdr:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

588

def : Pat<(truncstorei16 I64:$val, (WebAssemblywrapper tglobaladdr:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

589

(STORE16_I64 tglobaladdr:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

590

def : Pat<(truncstorei32 I64:$val, (WebAssemblywrapper tglobaladdr:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

591

(STORE32_I64 tglobaladdr:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

592

def : Pat<(truncstorei8 I32:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

593

(STORE8_I32 texternalsym:$off, (CONST_I32 0), 0, I32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

594

def : Pat<(truncstorei16 I32:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

595

(STORE16_I32 texternalsym:$off, (CONST_I32 0), 0, I32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

596

def : Pat<(truncstorei8 I64:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

597

(STORE8_I64 texternalsym:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

598

def : Pat<(truncstorei16 I64:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

599

(STORE16_I64 texternalsym:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

600

def : Pat<(truncstorei32 I64:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame^]

601

(STORE32_I64 texternalsym:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

602

Dan Gohman

2015-11-25 19:36:19 +0000

[diff] [blame]

603

let Defs = [ARGUMENTS] in {

604

Dan Gohman

72f1692

2015-10-02 19:21:15 +0000

[diff] [blame]

605

// Memory size.

Dan Gohman

2015-11-13 20:19:11 +0000

[diff] [blame]

606

def MEMORY_SIZE_I32 : I<(outs I32:$dst), (ins),

Dan Gohman

2015-11-05 20:42:30 +0000

[diff] [blame]

607

[(set I32:$dst, (int_wasm_memory_size))],

Dan Gohman

2015-11-23 22:37:29 +0000

[diff] [blame]

608

"memory_size\t$dst">,

Dan Gohman

72f1692

2015-10-02 19:21:15 +0000

[diff] [blame]

609

Requires<[HasAddr32]>;

Dan Gohman

2015-11-13 20:19:11 +0000

[diff] [blame]

610

def MEMORY_SIZE_I64 : I<(outs I64:$dst), (ins),

Dan Gohman

2015-11-05 20:42:30 +0000

[diff] [blame]

611

[(set I64:$dst, (int_wasm_memory_size))],

Dan Gohman

2015-11-23 22:37:29 +0000

[diff] [blame]

612

"memory_size\t$dst">,

Dan Gohman

72f1692

2015-10-02 19:21:15 +0000

[diff] [blame]

613

Requires<[HasAddr64]>;

Dan Gohman

baba8c6

2015-10-02 20:10:26 +0000

[diff] [blame]

614

Dan Gohman

d7ffb91

2015-11-05 20:16:59 +0000

[diff] [blame]

615

// Grow memory.

Dan Gohman

2015-11-13 20:19:11 +0000

[diff] [blame]

616

def GROW_MEMORY_I32 : I<(outs), (ins I32:$delta),

Dan Gohman

2015-11-05 20:42:30 +0000

[diff] [blame]

617

[(int_wasm_grow_memory I32:$delta)],

Dan Gohman

2015-11-23 22:37:29 +0000

[diff] [blame]

618

"grow_memory\t$delta">,

Dan Gohman

d7ffb91

2015-11-05 20:16:59 +0000

[diff] [blame]

619

Requires<[HasAddr32]>;

Dan Gohman

2015-11-13 20:19:11 +0000

[diff] [blame]

620

def GROW_MEMORY_I64 : I<(outs), (ins I64:$delta),

Dan Gohman

2015-11-05 20:42:30 +0000

[diff] [blame]

621

[(int_wasm_grow_memory I64:$delta)],

Dan Gohman

2015-11-23 22:37:29 +0000

[diff] [blame]

622

"grow_memory\t$delta">,

Dan Gohman

d7ffb91

2015-11-05 20:16:59 +0000

[diff] [blame]

623

Requires<[HasAddr64]>;

Dan Gohman