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-02-22 20:04:02 +0000

[diff] [blame]

31

// Treat an 'or' node as an 'add' if the or'ed bits are known to be zero.

32

def or_is_add : PatFrag<(ops node:$lhs, node:$rhs), (or node:$lhs, node:$rhs),[{

33

if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N->getOperand(1)))

34

return CurDAG->MaskedValueIsZero(N->getOperand(0), CN->getAPIntValue());

35

36

APInt KnownZero0, KnownOne0;

37

CurDAG->computeKnownBits(N->getOperand(0), KnownZero0, KnownOne0, 0);

38

APInt KnownZero1, KnownOne1;

39

CurDAG->computeKnownBits(N->getOperand(1), KnownZero1, KnownOne1, 0);

40

return (~KnownZero0 & ~KnownZero1) == 0;

41

}]>;

42

Dan Gohman

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

[diff] [blame]

43

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

Derek Schuff

1b258d3

2016-08-31 20:27:20 +0000

[diff] [blame^]

44

// into immediate values as long as the add is 'nuw'.

45

// TODO: We'd like to also match GA offsets but there are cases where the

46

// register can have a negative value. Find out what more we can do.

Dan Gohman

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

[diff] [blame]

47

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

48

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

49

[{

Derek Schuff

1b258d3

2016-08-31 20:27:20 +0000

[diff] [blame^]

50

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

Dan Gohman

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

[diff] [blame]

51

}]>;

52

53

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

54

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

55

Dan Gohman

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

[diff] [blame]

56

let Defs = [ARGUMENTS] in {

57

JF Bastien

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

[diff] [blame]

58

// Basic load.

Dan Gohman

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

[diff] [blame]

59

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

60

P2Align:$p2align), [],

61

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

62

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

63

P2Align:$p2align), [],

64

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

65

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

66

P2Align:$p2align), [],

67

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

68

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

69

P2Align:$p2align), [],

70

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

JF Bastien

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

[diff] [blame]

71

Dan Gohman

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

[diff] [blame]

72

} // Defs = [ARGUMENTS]

73

74

// Select loads with no constant offset.

Dan Gohman

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

[diff] [blame]

75

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

76

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

77

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

78

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

Dan Gohman

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

[diff] [blame]

79

80

// Select loads with a constant offset.

Dan Gohman

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

[diff] [blame]

81

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

Dan Gohman

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

[diff] [blame]

82

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

Dan Gohman

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

[diff] [blame]

83

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

Dan Gohman

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

[diff] [blame]

84

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

Dan Gohman

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

[diff] [blame]

85

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

Dan Gohman

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

[diff] [blame]

86

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

Dan Gohman

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

[diff] [blame]

87

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

Dan Gohman

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

[diff] [blame]

88

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

Dan Gohman

2016-02-22 20:04:02 +0000

[diff] [blame]

89

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

90

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

91

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

92

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

93

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

94

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

95

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

96

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

Dan Gohman

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

[diff] [blame]

97

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

98

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

99

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

Dan Gohman

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

[diff] [blame]

100

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

101

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

102

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

Dan Gohman

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

[diff] [blame]

103

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

104

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

105

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

Dan Gohman

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

[diff] [blame]

106

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

107

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

108

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

Dan Gohman

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

[diff] [blame]

109

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

Dan Gohman

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

[diff] [blame]

110

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

Dan Gohman

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

[diff] [blame]

111

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

Dan Gohman

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

[diff] [blame]

112

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

Dan Gohman

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

[diff] [blame]

113

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

Dan Gohman

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

[diff] [blame]

114

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

Dan Gohman

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

[diff] [blame]

115

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

Dan Gohman

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

[diff] [blame]

116

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

Dan Gohman

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

[diff] [blame]

117

118

// Select loads with just a constant offset.

Dan Gohman

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

[diff] [blame]

119

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

120

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

121

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

122

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]

123

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

Dan Gohman

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

[diff] [blame]

124

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

Dan Gohman

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

[diff] [blame]

125

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

Dan Gohman

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

[diff] [blame]

126

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

Dan Gohman

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

[diff] [blame]

127

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

Dan Gohman

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

[diff] [blame]

128

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

Dan Gohman

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

[diff] [blame]

129

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

Dan Gohman

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

[diff] [blame]

130

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

Dan Gohman

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

[diff] [blame]

131

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

Dan Gohman

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

[diff] [blame]

132

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

Dan Gohman

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

[diff] [blame]

133

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

Dan Gohman

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

[diff] [blame]

134

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

Dan Gohman

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

[diff] [blame]

135

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

Dan Gohman

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

[diff] [blame]

136

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

Dan Gohman

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

[diff] [blame]

137

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

Dan Gohman

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

[diff] [blame]

138

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

Dan Gohman

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

[diff] [blame]

139

140

let Defs = [ARGUMENTS] in {

141

JF Bastien

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

[diff] [blame]

142

// Extending load.

Dan Gohman

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

[diff] [blame]

143

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

144

P2Align:$p2align), [],

145

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

146

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

147

P2Align:$p2align), [],

148

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

149

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

150

P2Align:$p2align), [],

151

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

152

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

153

P2Align:$p2align), [],

154

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

155

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

156

P2Align:$p2align), [],

157

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

158

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

159

P2Align:$p2align), [],

160

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

161

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

162

P2Align:$p2align), [],

163

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

164

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

165

P2Align:$p2align), [],

166

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

167

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

168

P2Align:$p2align), [],

169

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

170

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

171

P2Align:$p2align), [],

172

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

JF Bastien

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

[diff] [blame]

173

Dan Gohman

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

[diff] [blame]

174

} // Defs = [ARGUMENTS]

175

Derek Schuff

9d77952

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

[diff] [blame]

176

// Select extending loads with no constant offset.

Dan Gohman

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

[diff] [blame]

177

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

178

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

179

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

180

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

181

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

182

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

183

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

184

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

185

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

186

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

Derek Schuff

9d77952

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

[diff] [blame]

187

Dan Gohman

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

[diff] [blame]

188

// Select extending loads with a constant offset.

Dan Gohman

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

[diff] [blame]

189

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

Dan Gohman

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

[diff] [blame]

190

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

Dan Gohman

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

[diff] [blame]

191

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

Dan Gohman

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

[diff] [blame]

192

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

Dan Gohman

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

[diff] [blame]

193

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

Dan Gohman

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

[diff] [blame]

194

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

Dan Gohman

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

[diff] [blame]

195

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

Dan Gohman

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

[diff] [blame]

196

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

Dan Gohman

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

[diff] [blame]

197

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

Dan Gohman

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

[diff] [blame]

198

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

Dan Gohman

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

[diff] [blame]

199

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

Dan Gohman

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

[diff] [blame]

200

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

Dan Gohman

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

[diff] [blame]

201

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

Dan Gohman

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

[diff] [blame]

202

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

Dan Gohman

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

[diff] [blame]

203

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

Dan Gohman

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

[diff] [blame]

204

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

Dan Gohman

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

[diff] [blame]

205

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

Dan Gohman

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

[diff] [blame]

206

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

Dan Gohman

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

[diff] [blame]

207

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

Dan Gohman

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

[diff] [blame]

208

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

Dan Gohman

2016-02-22 20:04:02 +0000

[diff] [blame]

209

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

210

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

211

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

212

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

213

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

214

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

215

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

216

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

217

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

218

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

219

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

220

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

221

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

222

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

223

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

224

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

225

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

226

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

227

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

228

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

Dan Gohman

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

[diff] [blame]

229

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

230

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

231

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

Dan Gohman

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

[diff] [blame]

232

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

233

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

234

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

Dan Gohman

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

[diff] [blame]

235

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

236

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

237

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

Dan Gohman

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

[diff] [blame]

238

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

239

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

240

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

Dan Gohman

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

[diff] [blame]

241

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

242

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

243

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

Dan Gohman

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

[diff] [blame]

244

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

245

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

246

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

Dan Gohman

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

[diff] [blame]

247

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

248

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

249

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

Dan Gohman

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

[diff] [blame]

250

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

251

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

252

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

Dan Gohman

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

[diff] [blame]

253

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

254

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

255

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

Dan Gohman

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

[diff] [blame]

256

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

257

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

258

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

Dan Gohman

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

[diff] [blame]

259

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

260

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

261

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

Dan Gohman

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

[diff] [blame]

262

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

263

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

264

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

Dan Gohman

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

[diff] [blame]

265

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

266

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

267

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

Dan Gohman

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

[diff] [blame]

268

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

269

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

270

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

Dan Gohman

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

[diff] [blame]

271

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

272

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

273

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

Dan Gohman

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

[diff] [blame]

274

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

275

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

276

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

Dan Gohman

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

[diff] [blame]

277

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

278

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

279

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

Dan Gohman

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

[diff] [blame]

280

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

281

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

282

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

Dan Gohman

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

[diff] [blame]

283

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

284

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

285

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

Dan Gohman

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

[diff] [blame]

286

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

287

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

288

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

Dan Gohman

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

[diff] [blame]

289

290

// Select extending loads with just a constant offset.

Dan Gohman

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

[diff] [blame]

291

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

292

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

293

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

294

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

295

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

296

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

297

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

298

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

299

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

300

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

301

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

302

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

303

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

304

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

305

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

306

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

307

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

308

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

309

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

310

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

Dan Gohman

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

[diff] [blame]

311

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

Dan Gohman

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

[diff] [blame]

312

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

Dan Gohman

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

[diff] [blame]

313

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

Dan Gohman

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

[diff] [blame]

314

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

Dan Gohman

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

[diff] [blame]

315

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

Dan Gohman

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

[diff] [blame]

316

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

Dan Gohman

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

[diff] [blame]

317

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

Dan Gohman

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

[diff] [blame]

318

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

Dan Gohman

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

[diff] [blame]

319

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

Dan Gohman

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

[diff] [blame]

320

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

Dan Gohman

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

[diff] [blame]

321

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

Dan Gohman

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

[diff] [blame]

322

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

Dan Gohman

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

[diff] [blame]

323

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

Dan Gohman

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

[diff] [blame]

324

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

Dan Gohman

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

[diff] [blame]

325

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

Dan Gohman

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

[diff] [blame]

326

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

Dan Gohman

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

[diff] [blame]

327

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

Dan Gohman

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

[diff] [blame]

328

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

Dan Gohman

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

[diff] [blame]

329

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

Dan Gohman

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

[diff] [blame]

330

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

Dan Gohman

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

[diff] [blame]

331

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

Dan Gohman

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

[diff] [blame]

332

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

Dan Gohman

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

[diff] [blame]

333

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

Dan Gohman

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

[diff] [blame]

334

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

Dan Gohman

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

[diff] [blame]

335

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

Dan Gohman

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

[diff] [blame]

336

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

Dan Gohman

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

[diff] [blame]

337

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

Dan Gohman

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

[diff] [blame]

338

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

Dan Gohman

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

[diff] [blame]

339

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

Dan Gohman

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

[diff] [blame]

340

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

Dan Gohman

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

[diff] [blame]

341

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

Dan Gohman

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

[diff] [blame]

342

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

Dan Gohman

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

[diff] [blame]

343

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

Dan Gohman

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

[diff] [blame]

344

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

Dan Gohman

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

[diff] [blame]

345

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

Dan Gohman

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

[diff] [blame]

346

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

Dan Gohman

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

[diff] [blame]

347

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

Dan Gohman

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

[diff] [blame]

348

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

Dan Gohman

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

[diff] [blame]

349

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

Dan Gohman

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

[diff] [blame]

350

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

Dan Gohman

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

[diff] [blame]

351

352

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

353

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

354

355

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

Dan Gohman

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

[diff] [blame]

356

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

357

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

358

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

359

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

360

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

JF Bastien

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

[diff] [blame]

361

Dan Gohman

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

[diff] [blame]

362

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

Dan Gohman

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

[diff] [blame]

363

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

Dan Gohman

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

[diff] [blame]

364

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

Dan Gohman

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

[diff] [blame]

365

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

Dan Gohman

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

[diff] [blame]

366

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

Dan Gohman

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

[diff] [blame]

367

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

Dan Gohman

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

[diff] [blame]

368

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

Dan Gohman

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

[diff] [blame]

369

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

Dan Gohman

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

[diff] [blame]

370

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

Dan Gohman

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

[diff] [blame]

371

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

Dan Gohman

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

[diff] [blame]

372

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

Dan Gohman

2016-02-22 20:04:02 +0000

[diff] [blame]

373

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

374

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

375

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

376

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

377

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

378

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

379

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

380

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

381

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

382

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

Dan Gohman

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

[diff] [blame]

383

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

384

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

385

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

Dan Gohman

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

[diff] [blame]

386

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

387

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

388

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

Dan Gohman

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

[diff] [blame]

389

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

390

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

391

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

Dan Gohman

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

[diff] [blame]

392

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

393

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

394

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

Dan Gohman

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

[diff] [blame]

395

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

396

(WebAssemblywrapper tglobaladdr:$off)))),

Dan Gohman

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

[diff] [blame]

397

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

Dan Gohman

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

[diff] [blame]

398

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

399

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

400

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

Dan Gohman

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

[diff] [blame]

401

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

402

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

403

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

Dan Gohman

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

[diff] [blame]

404

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

405

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

406

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

Dan Gohman

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

[diff] [blame]

407

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

408

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

409

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

Dan Gohman

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

[diff] [blame]

410

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

411

(WebAssemblywrapper texternalsym:$off)))),

Dan Gohman

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

[diff] [blame]

412

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

Dan Gohman

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

[diff] [blame]

413

414

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

Dan Gohman

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

[diff] [blame]

415

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

416

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

417

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

418

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

419

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

420

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

421

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

422

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

423

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

424

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

Dan Gohman

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

[diff] [blame]

425

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

Dan Gohman

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

[diff] [blame]

426

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

Dan Gohman

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

[diff] [blame]

427

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

Dan Gohman

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

[diff] [blame]

428

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

Dan Gohman

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

[diff] [blame]

429

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

Dan Gohman

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

[diff] [blame]

430

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

Dan Gohman

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

[diff] [blame]

431

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

Dan Gohman

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

[diff] [blame]

432

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

Dan Gohman

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

[diff] [blame]

433

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

Dan Gohman

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

[diff] [blame]

434

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

Dan Gohman

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

[diff] [blame]

435

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

Dan Gohman

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

[diff] [blame]

436

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

Dan Gohman

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

[diff] [blame]

437

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

Dan Gohman

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

[diff] [blame]

438

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

Dan Gohman

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

[diff] [blame]

439

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

Dan Gohman

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

[diff] [blame]

440

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

Dan Gohman

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

[diff] [blame]

441

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

Dan Gohman

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

[diff] [blame]

442

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

Dan Gohman

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

[diff] [blame]

443

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

Dan Gohman

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

[diff] [blame]

444

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

Dan Gohman

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

[diff] [blame]

445

Dan Gohman

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

[diff] [blame]

446

let Defs = [ARGUMENTS] in {

447

JF Bastien

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

[diff] [blame]

448

// Basic store.

Dan Gohman

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

[diff] [blame]

449

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

450

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

451

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

452

// operands.

JF Bastien

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

[diff] [blame]

453

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

Dan Gohman

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

[diff] [blame]

454

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

455

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

456

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

457

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

458

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

459

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

460

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

461

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

462

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

463

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

464

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

465

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

Dan Gohman

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

[diff] [blame]

466

Dan Gohman

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

[diff] [blame]

467

} // Defs = [ARGUMENTS]

468

Dan Gohman

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

[diff] [blame]

469

// Select stores with no constant offset.

Dan Gohman

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

[diff] [blame]

470

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

471

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

472

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

473

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]

474

Dan Gohman

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

[diff] [blame]

475

// Select stores with a constant offset.

Dan Gohman

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

[diff] [blame]

476

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

Dan Gohman

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

[diff] [blame]

477

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

Dan Gohman

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

[diff] [blame]

478

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

Dan Gohman

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

[diff] [blame]

479

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

Dan Gohman

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

[diff] [blame]

480

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

Dan Gohman

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

[diff] [blame]

481

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

Dan Gohman

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

[diff] [blame]

482

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

Dan Gohman

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

[diff] [blame]

483

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

Dan Gohman

2016-02-22 20:04:02 +0000

[diff] [blame]

484

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

485

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

486

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

487

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

488

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

489

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

490

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

491

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

Dan Gohman

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

[diff] [blame]

492

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

493

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

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

[diff] [blame]

494

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

Dan Gohman

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

[diff] [blame]

495

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

496

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

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

[diff] [blame]

497

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

Dan Gohman

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

[diff] [blame]

498

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

499

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

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

[diff] [blame]

500

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

Dan Gohman

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

[diff] [blame]

501

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

502

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

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

[diff] [blame]

503

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

Dan Gohman

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

[diff] [blame]

504

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

505

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

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

[diff] [blame]

506

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

Dan Gohman

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

[diff] [blame]

507

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

508

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

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

[diff] [blame]

509

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

Dan Gohman

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

[diff] [blame]

510

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

511

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

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

[diff] [blame]

512

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

Dan Gohman

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

[diff] [blame]

513

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

514

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

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

[diff] [blame]

515

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

Dan Gohman

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

[diff] [blame]

516

517

// Select stores with just a constant offset.

518

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

Dan Gohman

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

[diff] [blame]

519

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

Dan Gohman

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

[diff] [blame]

520

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

Dan Gohman

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

[diff] [blame]

521

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

Dan Gohman

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

[diff] [blame]

522

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

Dan Gohman

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

[diff] [blame]

523

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

Dan Gohman

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

[diff] [blame]

524

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

Dan Gohman

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

[diff] [blame]

525

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

Dan Gohman

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

[diff] [blame]

526

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

Dan Gohman

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

[diff] [blame]

527

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

Dan Gohman

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

[diff] [blame]

528

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

Dan Gohman

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

[diff] [blame]

529

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

Dan Gohman

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

[diff] [blame]

530

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

Dan Gohman

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

[diff] [blame]

531

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

Dan Gohman

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

[diff] [blame]

532

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

Dan Gohman

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

[diff] [blame]

533

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

Dan Gohman

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

[diff] [blame]

534

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

Dan Gohman

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

[diff] [blame]

535

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

Dan Gohman

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

[diff] [blame]

536

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

Dan Gohman

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

[diff] [blame]

537

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

Dan Gohman

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

[diff] [blame]

538

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

Dan Gohman

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

[diff] [blame]

539

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

Dan Gohman

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

[diff] [blame]

540

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

Dan Gohman

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

[diff] [blame]

541

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

JF Bastien

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

[diff] [blame]

542

Dan Gohman

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

[diff] [blame]

543

let Defs = [ARGUMENTS] in {

544

JF Bastien

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

[diff] [blame]

545

// Truncating store.

Dan Gohman

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

[diff] [blame]

546

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

547

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

548

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

549

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

550

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

551

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

552

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

553

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

554

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

555

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

556

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

557

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

558

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

559

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

560

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

Dan Gohman

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

[diff] [blame]

561

Dan Gohman

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

[diff] [blame]

562

} // Defs = [ARGUMENTS]

563

Dan Gohman

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

[diff] [blame]

564

// Select truncating stores with no constant offset.

Dan Gohman

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

[diff] [blame]

565

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

Dan Gohman

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

[diff] [blame]

566

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

Dan Gohman

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

[diff] [blame]

567

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

Dan Gohman

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

[diff] [blame]

568

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

Dan Gohman

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

[diff] [blame]

569

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

Dan Gohman

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

[diff] [blame]

570

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

Dan Gohman

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

[diff] [blame]

571

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

Dan Gohman

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

[diff] [blame]

572

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

Dan Gohman

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

[diff] [blame]

573

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

Dan Gohman

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

[diff] [blame]

574

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

JF Bastien

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

[diff] [blame]

575

Dan Gohman

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

[diff] [blame]

576

// Select truncating stores with a constant offset.

Dan Gohman

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

[diff] [blame]

577

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

Dan Gohman

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

[diff] [blame]

578

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

Dan Gohman

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

[diff] [blame]

579

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

Dan Gohman

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

[diff] [blame]

580

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

Dan Gohman

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

[diff] [blame]

581

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

Dan Gohman

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

[diff] [blame]

582

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

Dan Gohman

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

[diff] [blame]

583

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

Dan Gohman

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

[diff] [blame]

584

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

Dan Gohman

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

[diff] [blame]

585

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

Dan Gohman

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

[diff] [blame]

586

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

Dan Gohman

2016-02-22 20:04:02 +0000

[diff] [blame]

587

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

588

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

589

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

590

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

591

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

592

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

593

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

594

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

595

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

596

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

Dan Gohman

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

[diff] [blame]

597

def : Pat<(truncstorei8 I32:$val,

598

(regPlusGA I32:$addr,

599

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

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

[diff] [blame]

600

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

Dan Gohman

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

[diff] [blame]

601

def : Pat<(truncstorei16 I32:$val,

602

(regPlusGA I32:$addr,

603

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

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

[diff] [blame]

604

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

Dan Gohman

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

[diff] [blame]

605

def : Pat<(truncstorei8 I64:$val,

606

(regPlusGA I32:$addr,

607

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

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

[diff] [blame]

608

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

Dan Gohman

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

[diff] [blame]

609

def : Pat<(truncstorei16 I64:$val,

610

(regPlusGA I32:$addr,

611

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

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

[diff] [blame]

612

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

Dan Gohman

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

[diff] [blame]

613

def : Pat<(truncstorei32 I64:$val,

614

(regPlusGA I32:$addr,

615

(WebAssemblywrapper tglobaladdr:$off))),

Dan Gohman

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

[diff] [blame]

616

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

Dan Gohman

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

[diff] [blame]

617

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

618

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

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

[diff] [blame]

619

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

Dan Gohman

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

[diff] [blame]

620

def : Pat<(truncstorei16 I32:$val,

621

(add I32:$addr,

622

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

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

[diff] [blame]

623

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

Dan Gohman

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

[diff] [blame]

624

def : Pat<(truncstorei8 I64:$val,

625

(add I32:$addr,

626

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

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

[diff] [blame]

627

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

Dan Gohman

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

[diff] [blame]

628

def : Pat<(truncstorei16 I64:$val,

629

(add I32:$addr,

630

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

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

[diff] [blame]

631

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

Dan Gohman

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

[diff] [blame]

632

def : Pat<(truncstorei32 I64:$val,

633

(add I32:$addr,

634

(WebAssemblywrapper texternalsym:$off))),

Dan Gohman

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

[diff] [blame]

635

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

Dan Gohman

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

[diff] [blame]

636

637

// Select truncating stores with just a constant offset.

638

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

Dan Gohman

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

[diff] [blame]

639

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

Dan Gohman

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

[diff] [blame]

640

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

Dan Gohman

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

[diff] [blame]

641

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

Dan Gohman

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

[diff] [blame]

642

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

Dan Gohman

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

[diff] [blame]

643

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

Dan Gohman

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

[diff] [blame]

644

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

Dan Gohman

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

[diff] [blame]

645

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

Dan Gohman

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

[diff] [blame]

646

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

Dan Gohman

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

[diff] [blame]

647

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

Dan Gohman

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

[diff] [blame]

648

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

Dan Gohman

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

[diff] [blame]

649

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

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

650

def : Pat<(truncstorei16 I32:$val, (WebAssemblywrapper tglobaladdr:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame]

651

(STORE16_I32 tglobaladdr:$off, (CONST_I32 0), 0, I32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

652

def : Pat<(truncstorei8 I64:$val, (WebAssemblywrapper tglobaladdr:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame]

653

(STORE8_I64 tglobaladdr:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

654

def : Pat<(truncstorei16 I64:$val, (WebAssemblywrapper tglobaladdr:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame]

655

(STORE16_I64 tglobaladdr:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

656

def : Pat<(truncstorei32 I64:$val, (WebAssemblywrapper tglobaladdr:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame]

657

(STORE32_I64 tglobaladdr:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

658

def : Pat<(truncstorei8 I32:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame]

659

(STORE8_I32 texternalsym:$off, (CONST_I32 0), 0, I32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

660

def : Pat<(truncstorei16 I32:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame]

661

(STORE16_I32 texternalsym:$off, (CONST_I32 0), 0, I32:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

662

def : Pat<(truncstorei8 I64:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame]

663

(STORE8_I64 texternalsym:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

664

def : Pat<(truncstorei16 I64:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame]

665

(STORE16_I64 texternalsym:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

666

def : Pat<(truncstorei32 I64:$val, (WebAssemblywrapper texternalsym:$off)),

Dan Gohman

2016-01-26 03:39:31 +0000

[diff] [blame]

667

(STORE32_I64 texternalsym:$off, (CONST_I32 0), 0, I64:$val)>;

Dan Gohman

2015-12-15 22:01:29 +0000

[diff] [blame]

668

Dan Gohman

2015-11-25 19:36:19 +0000

[diff] [blame]

669

let Defs = [ARGUMENTS] in {

670

Derek Schuff

31680dd

2016-05-02 17:25:22 +0000

[diff] [blame]

671

// Current memory size.

672

def CURRENT_MEMORY_I32 : I<(outs I32:$dst), (ins),

673

[(set I32:$dst, (int_wasm_current_memory))],

674

"current_memory\t$dst">,

675

Requires<[HasAddr32]>;

676

def CURRENT_MEMORY_I64 : I<(outs I64:$dst), (ins),

677

[(set I64:$dst, (int_wasm_current_memory))],

678

"current_memory\t$dst">,

679

Requires<[HasAddr64]>;

Dan Gohman

baba8c6

2015-10-02 20:10:26 +0000

[diff] [blame]

680

Dan Gohman

d7ffb91

2015-11-05 20:16:59 +0000

[diff] [blame]

681

// Grow memory.

Dan Gohman

f433324

2015-11-13 20:19:11 +0000

[diff] [blame]

682

def GROW_MEMORY_I32 : I<(outs), (ins I32:$delta),

Dan Gohman

af29bd4

2015-11-05 20:42:30 +0000

[diff] [blame]

683

[(int_wasm_grow_memory I32:$delta)],

Dan Gohman

192dddc

2015-11-23 22:37:29 +0000

[diff] [blame]

684

"grow_memory\t$delta">,

Dan Gohman

d7ffb91

2015-11-05 20:16:59 +0000

[diff] [blame]

685

Requires<[HasAddr32]>;

Dan Gohman

f433324

2015-11-13 20:19:11 +0000

[diff] [blame]

686

def GROW_MEMORY_I64 : I<(outs), (ins I64:$delta),

Dan Gohman

af29bd4

2015-11-05 20:42:30 +0000

[diff] [blame]

687

[(int_wasm_grow_memory I64:$delta)],

Dan Gohman

192dddc

2015-11-23 22:37:29 +0000

[diff] [blame]

688

"grow_memory\t$delta">,

Dan Gohman

d7ffb91

2015-11-05 20:16:59 +0000

[diff] [blame]

689

Requires<[HasAddr64]>;

Dan Gohman