Blame - llvm/lib/Target/PowerPC/PPCInstrVSX.td - toolchain/llvm-project

2014-03-13 07:58:58 +0000

[diff] [blame]

1

//===- PPCInstrVSX.td - The PowerPC VSX Extension --*- tablegen -*-===//

2

//

3

// The LLVM Compiler Infrastructure

4

//

5

// This file is distributed under the University of Illinois Open Source

6

// License. See LICENSE.TXT for details.

7

//

8

//===----------------------------------------------------------------------===//

9

//

10

// This file describes the VSX extension to the PowerPC instruction set.

11

//

12

//===----------------------------------------------------------------------===//

13

14

def PPCRegVSRCAsmOperand : AsmOperandClass {

15

let Name = "RegVSRC"; let PredicateMethod = "isVSRegNumber";

16

}

17

def vsrc : RegisterOperand<VSRC> {

18

let ParserMatchClass = PPCRegVSRCAsmOperand;

19

}

20

21

multiclass XX3Form_Rcr<bits<6> opcode, bits<7> xo, dag OOL, dag IOL,

22

string asmbase, string asmstr, InstrItinClass itin,

23

list<dag> pattern> {

24

let BaseName = asmbase in {

25

def NAME : XX3Form_Rc<opcode, xo, OOL, IOL,

26

!strconcat(asmbase, !strconcat(" ", asmstr)), itin,

27

pattern>;

28

let Defs = [CR6] in

29

def o : XX3Form_Rc<opcode, xo, OOL, IOL,

30

!strconcat(asmbase, !strconcat(". ", asmstr)), itin,

[]>, isDOT;

}

}

def HasVSX : Predicate<"PPCSubTarget.hasVSX()">;

36

let Predicates = [HasVSX] in {

37

let AddedComplexity = 400 in { // Prefer VSX patterns over non-VSX patterns.

38

let neverHasSideEffects = 1 in { // VSX instructions don't have side effects.

39

let Uses = [RM] in {

40

41

// Load indexed instructions

42

let mayLoad = 1, canFoldAsLoad = 1 in {

43

def LXSDX : XForm_1<31, 588,

44

(outs vsrc:$XT), (ins memrr:$src),

45

"lxsdx $XT, $src", IIC_LdStLFD,

46

[(set f64:$XT, (load xoaddr:$src))]>;

47

48

def LXVD2X : XForm_1<31, 844,

49

(outs vsrc:$XT), (ins memrr:$src),

50

"lxvd2x $XT, $src", IIC_LdStLFD,

51

[(set v2f64:$XT, (load xoaddr:$src))]>;

52

53

def LXVDSX : XForm_1<31, 332,

54

(outs vsrc:$XT), (ins memrr:$src),

55

"lxvdsx $XT, $src", IIC_LdStLFD, []>;

56

// TODO: match load + splat to lxvdsx.

57

58

def LXVW4X : XForm_1<31, 780,

59

(outs vsrc:$XT), (ins memrr:$src),

Hal Finkel

ea76a44

2014-03-26 18:26:36 +0000

[diff] [blame]

60

"lxvw4x $XT, $src", IIC_LdStLFD, []>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

61

}

62

63

// Store indexed instructions

64

let mayStore = 1 in {

65

def STXSDX : XX1Form<31, 716,

66

(outs), (ins vsrc:$XT, memrr:$dst),

67

"stxsdx $XT, $dst", IIC_LdStSTFD,

68

[(store f64:$XT, xoaddr:$dst)]>;

69

70

def STXVD2X : XX1Form<31, 972,

71

(outs), (ins vsrc:$XT, memrr:$dst),

72

"stxvd2x $XT, $dst", IIC_LdStSTFD,

73

[(store v2f64:$XT, xoaddr:$dst)]>;

74

75

def STXVW4X : XX1Form<31, 908,

76

(outs), (ins vsrc:$XT, memrr:$dst),

Hal Finkel

ea76a44

2014-03-26 18:26:36 +0000

[diff] [blame]

77

"stxvw4x $XT, $dst", IIC_LdStSTFD, []>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

78

}

79

80

// Add/Mul Instructions

81

let isCommutable = 1 in {

82

def XSADDDP : XX3Form<60, 32,

83

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

84

"xsadddp $XT, $XA, $XB", IIC_VecFP,

85

[(set f64:$XT, (fadd f64:$XA, f64:$XB))]>;

86

def XSMULDP : XX3Form<60, 48,

87

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

88

"xsmuldp $XT, $XA, $XB", IIC_VecFP,

89

[(set f64:$XT, (fmul f64:$XA, f64:$XB))]>;

90

91

def XVADDDP : XX3Form<60, 96,

92

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

93

"xvadddp $XT, $XA, $XB", IIC_VecFP,

94

[(set v2f64:$XT, (fadd v2f64:$XA, v2f64:$XB))]>;

95

96

def XVADDSP : XX3Form<60, 64,

97

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

98

"xvaddsp $XT, $XA, $XB", IIC_VecFP,

99

[(set v4f32:$XT, (fadd v4f32:$XA, v4f32:$XB))]>;

100

101

def XVMULDP : XX3Form<60, 112,

102

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

103

"xvmuldp $XT, $XA, $XB", IIC_VecFP,

104

[(set v2f64:$XT, (fmul v2f64:$XA, v2f64:$XB))]>;

105

106

def XVMULSP : XX3Form<60, 80,

107

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

108

"xvmulsp $XT, $XA, $XB", IIC_VecFP,

109

[(set v4f32:$XT, (fmul v4f32:$XA, v4f32:$XB))]>;

110

}

111

112

// Subtract Instructions

113

def XSSUBDP : XX3Form<60, 40,

114

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

115

"xssubdp $XT, $XA, $XB", IIC_VecFP,

116

[(set f64:$XT, (fsub f64:$XA, f64:$XB))]>;

117

118

def XVSUBDP : XX3Form<60, 104,

119

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

120

"xvsubdp $XT, $XA, $XB", IIC_VecFP,

121

[(set v2f64:$XT, (fsub v2f64:$XA, v2f64:$XB))]>;

122

def XVSUBSP : XX3Form<60, 72,

123

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

124

"xvsubsp $XT, $XA, $XB", IIC_VecFP,

125

[(set v4f32:$XT, (fsub v4f32:$XA, v4f32:$XB))]>;

126

127

// FMA Instructions

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

128

let BaseName = "XSMADDADP" in {

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

129

let isCommutable = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

130

def XSMADDADP : XX3Form<60, 33,

131

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

132

"xsmaddadp $XT, $XA, $XB", IIC_VecFP,

133

[(set f64:$XT, (fma f64:$XA, f64:$XB, f64:$XTi))]>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

134

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

135

AltVSXFMARel;

136

let IsVSXFMAAlt = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

137

def XSMADDMDP : XX3Form<60, 41,

138

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

139

"xsmaddmdp $XT, $XA, $XB", IIC_VecFP, []>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

140

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

141

AltVSXFMARel;

142

}

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

143

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

144

let BaseName = "XSMSUBADP" in {

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

145

let isCommutable = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

146

def XSMSUBADP : XX3Form<60, 49,

147

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

148

"xsmsubadp $XT, $XA, $XB", IIC_VecFP,

149

[(set f64:$XT, (fma f64:$XA, f64:$XB, (fneg f64:$XTi)))]>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

150

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

151

AltVSXFMARel;

152

let IsVSXFMAAlt = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

153

def XSMSUBMDP : XX3Form<60, 57,

154

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

155

"xsmsubmdp $XT, $XA, $XB", IIC_VecFP, []>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

156

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

157

AltVSXFMARel;

158

}

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

159

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

160

let BaseName = "XSNMADDADP" in {

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

161

let isCommutable = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

162

def XSNMADDADP : XX3Form<60, 161,

163

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

164

"xsnmaddadp $XT, $XA, $XB", IIC_VecFP,

165

[(set f64:$XT, (fneg (fma f64:$XA, f64:$XB, f64:$XTi)))]>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

166

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

167

AltVSXFMARel;

168

let IsVSXFMAAlt = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

169

def XSNMADDMDP : XX3Form<60, 169,

170

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

171

"xsnmaddmdp $XT, $XA, $XB", IIC_VecFP, []>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

172

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

173

AltVSXFMARel;

174

}

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

175

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

176

let BaseName = "XSNMSUBADP" in {

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

177

let isCommutable = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

178

def XSNMSUBADP : XX3Form<60, 177,

179

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

180

"xsnmsubadp $XT, $XA, $XB", IIC_VecFP,

181

[(set f64:$XT, (fneg (fma f64:$XA, f64:$XB, (fneg f64:$XTi))))]>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

182

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

183

AltVSXFMARel;

184

let IsVSXFMAAlt = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

185

def XSNMSUBMDP : XX3Form<60, 185,

186

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

187

"xsnmsubmdp $XT, $XA, $XB", IIC_VecFP, []>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

188

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

189

AltVSXFMARel;

190

}

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

191

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

192

let BaseName = "XVMADDADP" in {

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

193

let isCommutable = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

194

def XVMADDADP : XX3Form<60, 97,

195

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

196

"xvmaddadp $XT, $XA, $XB", IIC_VecFP,

197

[(set v2f64:$XT, (fma v2f64:$XA, v2f64:$XB, v2f64:$XTi))]>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

198

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

199

AltVSXFMARel;

200

let IsVSXFMAAlt = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

201

def XVMADDMDP : XX3Form<60, 105,

202

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

203

"xvmaddmdp $XT, $XA, $XB", IIC_VecFP, []>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

204

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

205

AltVSXFMARel;

206

}

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

207

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

208

let BaseName = "XVMADDASP" in {

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

209

let isCommutable = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

210

def XVMADDASP : XX3Form<60, 65,

211

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

212

"xvmaddasp $XT, $XA, $XB", IIC_VecFP,

213

[(set v4f32:$XT, (fma v4f32:$XA, v4f32:$XB, v4f32:$XTi))]>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

214

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

215

AltVSXFMARel;

216

let IsVSXFMAAlt = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

217

def XVMADDMSP : XX3Form<60, 73,

218

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

219

"xvmaddmsp $XT, $XA, $XB", IIC_VecFP, []>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

220

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

221

AltVSXFMARel;

222

}

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

223

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

224

let BaseName = "XVMSUBADP" in {

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

225

let isCommutable = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

226

def XVMSUBADP : XX3Form<60, 113,

227

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

228

"xvmsubadp $XT, $XA, $XB", IIC_VecFP,

229

[(set v2f64:$XT, (fma v2f64:$XA, v2f64:$XB, (fneg v2f64:$XTi)))]>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

230

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

231

AltVSXFMARel;

232

let IsVSXFMAAlt = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

233

def XVMSUBMDP : XX3Form<60, 121,

234

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

235

"xvmsubmdp $XT, $XA, $XB", IIC_VecFP, []>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

236

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

237

AltVSXFMARel;

238

}

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

239

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

240

let BaseName = "XVMSUBASP" in {

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

241

let isCommutable = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

242

def XVMSUBASP : XX3Form<60, 81,

243

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

244

"xvmsubasp $XT, $XA, $XB", IIC_VecFP,

245

[(set v4f32:$XT, (fma v4f32:$XA, v4f32:$XB, (fneg v4f32:$XTi)))]>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

246

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

247

AltVSXFMARel;

248

let IsVSXFMAAlt = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

249

def XVMSUBMSP : XX3Form<60, 89,

250

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

251

"xvmsubmsp $XT, $XA, $XB", IIC_VecFP, []>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

252

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

253

AltVSXFMARel;

254

}

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

255

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

256

let BaseName = "XVNMADDADP" in {

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

257

let isCommutable = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

258

def XVNMADDADP : XX3Form<60, 225,

259

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

260

"xvnmaddadp $XT, $XA, $XB", IIC_VecFP,

261

[(set v2f64:$XT, (fneg (fma v2f64:$XA, v2f64:$XB, v2f64:$XTi)))]>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

262

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

263

AltVSXFMARel;

264

let IsVSXFMAAlt = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

265

def XVNMADDMDP : XX3Form<60, 233,

266

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

267

"xvnmaddmdp $XT, $XA, $XB", IIC_VecFP, []>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

268

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

269

AltVSXFMARel;

270

}

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

271

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

272

let BaseName = "XVNMADDASP" in {

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

273

let isCommutable = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

274

def XVNMADDASP : XX3Form<60, 193,

275

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

276

"xvnmaddasp $XT, $XA, $XB", IIC_VecFP,

277

[(set v4f32:$XT, (fneg (fma v4f32:$XA, v4f32:$XB, v4f32:$XTi)))]>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

278

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

279

AltVSXFMARel;

280

let IsVSXFMAAlt = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

281

def XVNMADDMSP : XX3Form<60, 201,

282

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

283

"xvnmaddmsp $XT, $XA, $XB", IIC_VecFP, []>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

284

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

285

AltVSXFMARel;

286

}

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

287

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

288

let BaseName = "XVNMSUBADP" in {

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

289

let isCommutable = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

290

def XVNMSUBADP : XX3Form<60, 241,

291

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

292

"xvnmsubadp $XT, $XA, $XB", IIC_VecFP,

293

[(set v2f64:$XT, (fneg (fma v2f64:$XA, v2f64:$XB, (fneg v2f64:$XTi))))]>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

294

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

295

AltVSXFMARel;

296

let IsVSXFMAAlt = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

297

def XVNMSUBMDP : XX3Form<60, 249,

298

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

299

"xvnmsubmdp $XT, $XA, $XB", IIC_VecFP, []>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

300

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

301

AltVSXFMARel;

302

}

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

303

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

304

let BaseName = "XVNMSUBASP" in {

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

305

let isCommutable = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

306

def XVNMSUBASP : XX3Form<60, 209,

307

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

308

"xvnmsubasp $XT, $XA, $XB", IIC_VecFP,

309

[(set v4f32:$XT, (fneg (fma v4f32:$XA, v4f32:$XB, (fneg v4f32:$XTi))))]>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

310

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

311

AltVSXFMARel;

312

let IsVSXFMAAlt = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

313

def XVNMSUBMSP : XX3Form<60, 217,

314

(outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),

315

"xvnmsubmsp $XT, $XA, $XB", IIC_VecFP, []>,

Hal Finkel

2014-03-25 18:55:11 +0000

[diff] [blame]

316

RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,

317

AltVSXFMARel;

318

}

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

319

320

// Division Instructions

321

def XSDIVDP : XX3Form<60, 56,

322

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

323

"xsdivdp $XT, $XA, $XB", IIC_VecFP,

324

[(set f64:$XT, (fdiv f64:$XA, f64:$XB))]>;

325

def XSSQRTDP : XX2Form<60, 75,

326

(outs vsrc:$XT), (ins vsrc:$XB),

327

"xssqrtdp $XT, $XB", IIC_VecFP,

328

[(set f64:$XT, (fsqrt f64:$XB))]>;

329

330

def XSREDP : XX2Form<60, 90,

331

(outs vsrc:$XT), (ins vsrc:$XB),

332

"xsredp $XT, $XB", IIC_VecFP,

333

[(set f64:$XT, (PPCfre f64:$XB))]>;

334

def XSRSQRTEDP : XX2Form<60, 74,

335

(outs vsrc:$XT), (ins vsrc:$XB),

336

"xsrsqrtedp $XT, $XB", IIC_VecFP,

337

[(set f64:$XT, (PPCfrsqrte f64:$XB))]>;

338

339

def XSTDIVDP : XX3Form_1<60, 61,

340

(outs crrc:$crD), (ins vsrc:$XA, vsrc:$XB),

341

"xstdivdp $crD, $XA, $XB", IIC_VecFP, []>;

342

def XSTSQRTDP : XX2Form_1<60, 106,

343

(outs crrc:$crD), (ins vsrc:$XB),

344

"xstsqrtdp $crD, $XB", IIC_VecFP, []>;

345

346

def XVDIVDP : XX3Form<60, 120,

347

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

348

"xvdivdp $XT, $XA, $XB", IIC_VecFP,

349

[(set v2f64:$XT, (fdiv v2f64:$XA, v2f64:$XB))]>;

350

def XVDIVSP : XX3Form<60, 88,

351

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

352

"xvdivsp $XT, $XA, $XB", IIC_VecFP,

353

[(set v4f32:$XT, (fdiv v4f32:$XA, v4f32:$XB))]>;

354

355

def XVSQRTDP : XX2Form<60, 203,

356

(outs vsrc:$XT), (ins vsrc:$XB),

357

"xvsqrtdp $XT, $XB", IIC_VecFP,

358

[(set v2f64:$XT, (fsqrt v2f64:$XB))]>;

359

def XVSQRTSP : XX2Form<60, 139,

360

(outs vsrc:$XT), (ins vsrc:$XB),

361

"xvsqrtsp $XT, $XB", IIC_VecFP,

362

[(set v4f32:$XT, (fsqrt v4f32:$XB))]>;

363

364

def XVTDIVDP : XX3Form_1<60, 125,

365

(outs crrc:$crD), (ins vsrc:$XA, vsrc:$XB),

366

"xvtdivdp $crD, $XA, $XB", IIC_VecFP, []>;

367

def XVTDIVSP : XX3Form_1<60, 93,

368

(outs crrc:$crD), (ins vsrc:$XA, vsrc:$XB),

369

"xvtdivsp $crD, $XA, $XB", IIC_VecFP, []>;

370

371

def XVTSQRTDP : XX2Form_1<60, 234,

372

(outs crrc:$crD), (ins vsrc:$XB),

373

"xvtsqrtdp $crD, $XB", IIC_VecFP, []>;

374

def XVTSQRTSP : XX2Form_1<60, 170,

375

(outs crrc:$crD), (ins vsrc:$XB),

376

"xvtsqrtsp $crD, $XB", IIC_VecFP, []>;

377

378

def XVREDP : XX2Form<60, 218,

379

(outs vsrc:$XT), (ins vsrc:$XB),

380

"xvredp $XT, $XB", IIC_VecFP,

381

[(set v2f64:$XT, (PPCfre v2f64:$XB))]>;

382

def XVRESP : XX2Form<60, 154,

383

(outs vsrc:$XT), (ins vsrc:$XB),

384

"xvresp $XT, $XB", IIC_VecFP,

385

[(set v4f32:$XT, (PPCfre v4f32:$XB))]>;

386

387

def XVRSQRTEDP : XX2Form<60, 202,

388

(outs vsrc:$XT), (ins vsrc:$XB),

389

"xvrsqrtedp $XT, $XB", IIC_VecFP,

390

[(set v2f64:$XT, (PPCfrsqrte v2f64:$XB))]>;

391

def XVRSQRTESP : XX2Form<60, 138,

392

(outs vsrc:$XT), (ins vsrc:$XB),

393

"xvrsqrtesp $XT, $XB", IIC_VecFP,

394

[(set v4f32:$XT, (PPCfrsqrte v4f32:$XB))]>;

395

396

// Compare Instructions

397

def XSCMPODP : XX3Form_1<60, 43,

398

(outs crrc:$crD), (ins vsrc:$XA, vsrc:$XB),

399

"xscmpodp $crD, $XA, $XB", IIC_VecFPCompare, []>;

400

def XSCMPUDP : XX3Form_1<60, 35,

401

(outs crrc:$crD), (ins vsrc:$XA, vsrc:$XB),

402

"xscmpudp $crD, $XA, $XB", IIC_VecFPCompare, []>;

403

404

defm XVCMPEQDP : XX3Form_Rcr<60, 99,

405

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

406

"xvcmpeqdp", "$XT, $XA, $XB", IIC_VecFPCompare, []>;

407

defm XVCMPEQSP : XX3Form_Rcr<60, 67,

408

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

409

"xvcmpeqsp", "$XT, $XA, $XB", IIC_VecFPCompare, []>;

410

defm XVCMPGEDP : XX3Form_Rcr<60, 115,

411

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

412

"xvcmpgedp", "$XT, $XA, $XB", IIC_VecFPCompare, []>;

413

defm XVCMPGESP : XX3Form_Rcr<60, 83,

414

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

415

"xvcmpgesp", "$XT, $XA, $XB", IIC_VecFPCompare, []>;

416

defm XVCMPGTDP : XX3Form_Rcr<60, 107,

417

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

418

"xvcmpgtdp", "$XT, $XA, $XB", IIC_VecFPCompare, []>;

419

defm XVCMPGTSP : XX3Form_Rcr<60, 75,

420

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

421

"xvcmpgtsp", "$XT, $XA, $XB", IIC_VecFPCompare, []>;

422

423

// Move Instructions

424

def XSABSDP : XX2Form<60, 345,

425

(outs vsrc:$XT), (ins vsrc:$XB),

426

"xsabsdp $XT, $XB", IIC_VecFP,

427

[(set f64:$XT, (fabs f64:$XB))]>;

428

def XSNABSDP : XX2Form<60, 361,

429

(outs vsrc:$XT), (ins vsrc:$XB),

430

"xsnabsdp $XT, $XB", IIC_VecFP,

431

[(set f64:$XT, (fneg (fabs f64:$XB)))]>;

432

def XSNEGDP : XX2Form<60, 377,

433

(outs vsrc:$XT), (ins vsrc:$XB),

434

"xsnegdp $XT, $XB", IIC_VecFP,

435

[(set f64:$XT, (fneg f64:$XB))]>;

436

def XSCPSGNDP : XX3Form<60, 176,

437

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

438

"xscpsgndp $XT, $XA, $XB", IIC_VecFP,

439

[(set f64:$XT, (fcopysign f64:$XB, f64:$XA))]>;

440

441

def XVABSDP : XX2Form<60, 473,

442

(outs vsrc:$XT), (ins vsrc:$XB),

443

"xvabsdp $XT, $XB", IIC_VecFP,

444

[(set v2f64:$XT, (fabs v2f64:$XB))]>;

445

446

def XVABSSP : XX2Form<60, 409,

447

(outs vsrc:$XT), (ins vsrc:$XB),

448

"xvabssp $XT, $XB", IIC_VecFP,

449

[(set v4f32:$XT, (fabs v4f32:$XB))]>;

450

451

def XVCPSGNDP : XX3Form<60, 240,

452

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

453

"xvcpsgndp $XT, $XA, $XB", IIC_VecFP,

454

[(set v2f64:$XT, (fcopysign v2f64:$XB, v2f64:$XA))]>;

455

def XVCPSGNSP : XX3Form<60, 208,

456

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

457

"xvcpsgnsp $XT, $XA, $XB", IIC_VecFP,

458

[(set v4f32:$XT, (fcopysign v4f32:$XB, v4f32:$XA))]>;

459

460

def XVNABSDP : XX2Form<60, 489,

461

(outs vsrc:$XT), (ins vsrc:$XB),

462

"xvnabsdp $XT, $XB", IIC_VecFP,

463

[(set v2f64:$XT, (fneg (fabs v2f64:$XB)))]>;

464

def XVNABSSP : XX2Form<60, 425,

465

(outs vsrc:$XT), (ins vsrc:$XB),

466

"xvnabssp $XT, $XB", IIC_VecFP,

467

[(set v4f32:$XT, (fneg (fabs v4f32:$XB)))]>;

468

469

def XVNEGDP : XX2Form<60, 505,

470

(outs vsrc:$XT), (ins vsrc:$XB),

471

"xvnegdp $XT, $XB", IIC_VecFP,

472

[(set v2f64:$XT, (fneg v2f64:$XB))]>;

473

def XVNEGSP : XX2Form<60, 441,

474

(outs vsrc:$XT), (ins vsrc:$XB),

475

"xvnegsp $XT, $XB", IIC_VecFP,

476

[(set v4f32:$XT, (fneg v4f32:$XB))]>;

477

478

// Conversion Instructions

479

def XSCVDPSP : XX2Form<60, 265,

480

(outs vsrc:$XT), (ins vsrc:$XB),

481

"xscvdpsp $XT, $XB", IIC_VecFP, []>;

482

def XSCVDPSXDS : XX2Form<60, 344,

483

(outs vsrc:$XT), (ins vsrc:$XB),

Hal Finkel

2014-03-23 05:35:00 +0000

[diff] [blame]

484

"xscvdpsxds $XT, $XB", IIC_VecFP,

485

[(set f64:$XT, (PPCfctidz f64:$XB))]>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

486

def XSCVDPSXWS : XX2Form<60, 88,

487

(outs vsrc:$XT), (ins vsrc:$XB),

Hal Finkel

2014-03-23 05:35:00 +0000

[diff] [blame]

488

"xscvdpsxws $XT, $XB", IIC_VecFP,

489

[(set f64:$XT, (PPCfctiwz f64:$XB))]>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

490

def XSCVDPUXDS : XX2Form<60, 328,

491

(outs vsrc:$XT), (ins vsrc:$XB),

Hal Finkel

2014-03-23 05:35:00 +0000

[diff] [blame]

492

"xscvdpuxds $XT, $XB", IIC_VecFP,

493

[(set f64:$XT, (PPCfctiduz f64:$XB))]>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

494

def XSCVDPUXWS : XX2Form<60, 72,

495

(outs vsrc:$XT), (ins vsrc:$XB),

Hal Finkel

2014-03-23 05:35:00 +0000

[diff] [blame]

496

"xscvdpuxws $XT, $XB", IIC_VecFP,

497

[(set f64:$XT, (PPCfctiwuz f64:$XB))]>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

498

def XSCVSPDP : XX2Form<60, 329,

499

(outs vsrc:$XT), (ins vsrc:$XB),

500

"xscvspdp $XT, $XB", IIC_VecFP, []>;

501

def XSCVSXDDP : XX2Form<60, 376,

502

(outs vsrc:$XT), (ins vsrc:$XB),

Hal Finkel

2014-03-23 05:35:00 +0000

[diff] [blame]

503

"xscvsxddp $XT, $XB", IIC_VecFP,

504

[(set f64:$XT, (PPCfcfid f64:$XB))]>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

505

def XSCVUXDDP : XX2Form<60, 360,

506

(outs vsrc:$XT), (ins vsrc:$XB),

Hal Finkel

2014-03-23 05:35:00 +0000

[diff] [blame]

507

"xscvuxddp $XT, $XB", IIC_VecFP,

508

[(set f64:$XT, (PPCfcfidu f64:$XB))]>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

509

510

def XVCVDPSP : XX2Form<60, 393,

511

(outs vsrc:$XT), (ins vsrc:$XB),

512

"xvcvdpsp $XT, $XB", IIC_VecFP, []>;

513

def XVCVDPSXDS : XX2Form<60, 472,

514

(outs vsrc:$XT), (ins vsrc:$XB),

Hal Finkel

2014-03-26 19:13:54 +0000

[diff] [blame^]

515

"xvcvdpsxds $XT, $XB", IIC_VecFP,

516

[(set v2i64:$XT, (fp_to_sint v2f64:$XB))]>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

517

def XVCVDPSXWS : XX2Form<60, 216,

518

(outs vsrc:$XT), (ins vsrc:$XB),

519

"xvcvdpsxws $XT, $XB", IIC_VecFP, []>;

520

def XVCVDPUXDS : XX2Form<60, 456,

521

(outs vsrc:$XT), (ins vsrc:$XB),

Hal Finkel

2014-03-26 19:13:54 +0000

[diff] [blame^]

522

"xvcvdpuxds $XT, $XB", IIC_VecFP,

523

[(set v2i64:$XT, (fp_to_uint v2f64:$XB))]>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

524

def XVCVDPUXWS : XX2Form<60, 200,

525

(outs vsrc:$XT), (ins vsrc:$XB),

526

"xvcvdpuxws $XT, $XB", IIC_VecFP, []>;

527

528

def XVCVSPDP : XX2Form<60, 457,

529

(outs vsrc:$XT), (ins vsrc:$XB),

530

"xvcvspdp $XT, $XB", IIC_VecFP, []>;

531

def XVCVSPSXDS : XX2Form<60, 408,

532

(outs vsrc:$XT), (ins vsrc:$XB),

533

"xvcvspsxds $XT, $XB", IIC_VecFP, []>;

534

def XVCVSPSXWS : XX2Form<60, 152,

535

(outs vsrc:$XT), (ins vsrc:$XB),

536

"xvcvspsxws $XT, $XB", IIC_VecFP, []>;

537

def XVCVSPUXDS : XX2Form<60, 392,

538

(outs vsrc:$XT), (ins vsrc:$XB),

539

"xvcvspuxds $XT, $XB", IIC_VecFP, []>;

540

def XVCVSPUXWS : XX2Form<60, 136,

541

(outs vsrc:$XT), (ins vsrc:$XB),

542

"xvcvspuxws $XT, $XB", IIC_VecFP, []>;

543

def XVCVSXDDP : XX2Form<60, 504,

544

(outs vsrc:$XT), (ins vsrc:$XB),

Hal Finkel

2014-03-26 19:13:54 +0000

[diff] [blame^]

545

"xvcvsxddp $XT, $XB", IIC_VecFP,

546

[(set v2f64:$XT, (sint_to_fp v2i64:$XB))]>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

547

def XVCVSXDSP : XX2Form<60, 440,

548

(outs vsrc:$XT), (ins vsrc:$XB),

549

"xvcvsxdsp $XT, $XB", IIC_VecFP, []>;

550

def XVCVSXWDP : XX2Form<60, 248,

551

(outs vsrc:$XT), (ins vsrc:$XB),

552

"xvcvsxwdp $XT, $XB", IIC_VecFP, []>;

553

def XVCVSXWSP : XX2Form<60, 184,

554

(outs vsrc:$XT), (ins vsrc:$XB),

555

"xvcvsxwsp $XT, $XB", IIC_VecFP, []>;

556

def XVCVUXDDP : XX2Form<60, 488,

557

(outs vsrc:$XT), (ins vsrc:$XB),

Hal Finkel

2014-03-26 19:13:54 +0000

[diff] [blame^]

558

"xvcvuxddp $XT, $XB", IIC_VecFP,

559

[(set v2f64:$XT, (uint_to_fp v2i64:$XB))]>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

560

def XVCVUXDSP : XX2Form<60, 424,

561

(outs vsrc:$XT), (ins vsrc:$XB),

562

"xvcvuxdsp $XT, $XB", IIC_VecFP, []>;

563

def XVCVUXWDP : XX2Form<60, 232,

564

(outs vsrc:$XT), (ins vsrc:$XB),

565

"xvcvuxwdp $XT, $XB", IIC_VecFP, []>;

566

def XVCVUXWSP : XX2Form<60, 168,

567

(outs vsrc:$XT), (ins vsrc:$XB),

568

"xvcvuxwsp $XT, $XB", IIC_VecFP, []>;

569

570

// Rounding Instructions

571

def XSRDPI : XX2Form<60, 73,

572

(outs vsrc:$XT), (ins vsrc:$XB),

573

"xsrdpi $XT, $XB", IIC_VecFP,

574

[(set f64:$XT, (frnd f64:$XB))]>;

575

def XSRDPIC : XX2Form<60, 107,

576

(outs vsrc:$XT), (ins vsrc:$XB),

577

"xsrdpic $XT, $XB", IIC_VecFP,

578

[(set f64:$XT, (fnearbyint f64:$XB))]>;

579

def XSRDPIM : XX2Form<60, 121,

580

(outs vsrc:$XT), (ins vsrc:$XB),

581

"xsrdpim $XT, $XB", IIC_VecFP,

582

[(set f64:$XT, (ffloor f64:$XB))]>;

583

def XSRDPIP : XX2Form<60, 105,

584

(outs vsrc:$XT), (ins vsrc:$XB),

585

"xsrdpip $XT, $XB", IIC_VecFP,

586

[(set f64:$XT, (fceil f64:$XB))]>;

587

def XSRDPIZ : XX2Form<60, 89,

588

(outs vsrc:$XT), (ins vsrc:$XB),

589

"xsrdpiz $XT, $XB", IIC_VecFP,

590

[(set f64:$XT, (ftrunc f64:$XB))]>;

591

592

def XVRDPI : XX2Form<60, 201,

593

(outs vsrc:$XT), (ins vsrc:$XB),

594

"xvrdpi $XT, $XB", IIC_VecFP,

595

[(set v2f64:$XT, (frnd v2f64:$XB))]>;

596

def XVRDPIC : XX2Form<60, 235,

597

(outs vsrc:$XT), (ins vsrc:$XB),

598

"xvrdpic $XT, $XB", IIC_VecFP,

599

[(set v2f64:$XT, (fnearbyint v2f64:$XB))]>;

600

def XVRDPIM : XX2Form<60, 249,

601

(outs vsrc:$XT), (ins vsrc:$XB),

602

"xvrdpim $XT, $XB", IIC_VecFP,

603

[(set v2f64:$XT, (ffloor v2f64:$XB))]>;

604

def XVRDPIP : XX2Form<60, 233,

605

(outs vsrc:$XT), (ins vsrc:$XB),

606

"xvrdpip $XT, $XB", IIC_VecFP,

607

[(set v2f64:$XT, (fceil v2f64:$XB))]>;

608

def XVRDPIZ : XX2Form<60, 217,

609

(outs vsrc:$XT), (ins vsrc:$XB),

610

"xvrdpiz $XT, $XB", IIC_VecFP,

611

[(set v2f64:$XT, (ftrunc v2f64:$XB))]>;

612

613

def XVRSPI : XX2Form<60, 137,

614

(outs vsrc:$XT), (ins vsrc:$XB),

615

"xvrspi $XT, $XB", IIC_VecFP,

616

[(set v4f32:$XT, (frnd v4f32:$XB))]>;

617

def XVRSPIC : XX2Form<60, 171,

618

(outs vsrc:$XT), (ins vsrc:$XB),

619

"xvrspic $XT, $XB", IIC_VecFP,

620

[(set v4f32:$XT, (fnearbyint v4f32:$XB))]>;

621

def XVRSPIM : XX2Form<60, 185,

622

(outs vsrc:$XT), (ins vsrc:$XB),

623

"xvrspim $XT, $XB", IIC_VecFP,

624

[(set v4f32:$XT, (ffloor v4f32:$XB))]>;

625

def XVRSPIP : XX2Form<60, 169,

626

(outs vsrc:$XT), (ins vsrc:$XB),

627

"xvrspip $XT, $XB", IIC_VecFP,

628

[(set v4f32:$XT, (fceil v4f32:$XB))]>;

629

def XVRSPIZ : XX2Form<60, 153,

630

(outs vsrc:$XT), (ins vsrc:$XB),

631

"xvrspiz $XT, $XB", IIC_VecFP,

632

[(set v4f32:$XT, (ftrunc v4f32:$XB))]>;

633

634

// Max/Min Instructions

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

635

let isCommutable = 1 in {

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

636

def XSMAXDP : XX3Form<60, 160,

637

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

638

"xsmaxdp $XT, $XA, $XB", IIC_VecFP, []>;

639

def XSMINDP : XX3Form<60, 168,

640

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

641

"xsmindp $XT, $XA, $XB", IIC_VecFP, []>;

642

643

def XVMAXDP : XX3Form<60, 224,

644

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

645

"xvmaxdp $XT, $XA, $XB", IIC_VecFP, []>;

646

def XVMINDP : XX3Form<60, 232,

647

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

648

"xvmindp $XT, $XA, $XB", IIC_VecFP, []>;

649

650

def XVMAXSP : XX3Form<60, 192,

651

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

652

"xvmaxsp $XT, $XA, $XB", IIC_VecFP, []>;

653

def XVMINSP : XX3Form<60, 200,

654

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

655

"xvminsp $XT, $XA, $XB", IIC_VecFP, []>;

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

656

} // isCommutable

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

657

} // Uses = [RM]

658

659

// Logical Instructions

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

660

let isCommutable = 1 in

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

661

def XXLAND : XX3Form<60, 130,

662

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

Hal Finkel

2014-03-26 04:55:40 +0000

[diff] [blame]

663

"xxland $XT, $XA, $XB", IIC_VecGeneral,

664

[(set v4i32:$XT, (and v4i32:$XA, v4i32:$XB))]>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

665

def XXLANDC : XX3Form<60, 138,

666

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

Hal Finkel

2014-03-26 04:55:40 +0000

[diff] [blame]

667

"xxlandc $XT, $XA, $XB", IIC_VecGeneral,

668

[(set v4i32:$XT, (and v4i32:$XA,

669

(vnot_ppc v4i32:$XB)))]>;

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

670

let isCommutable = 1 in {

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

671

def XXLNOR : XX3Form<60, 162,

672

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

Hal Finkel

2014-03-26 04:55:40 +0000

[diff] [blame]

673

"xxlnor $XT, $XA, $XB", IIC_VecGeneral,

674

[(set v4i32:$XT, (vnot_ppc (or v4i32:$XA,

675

v4i32:$XB)))]>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

676

def XXLOR : XX3Form<60, 146,

677

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

Hal Finkel

2014-03-26 04:55:40 +0000

[diff] [blame]

678

"xxlor $XT, $XA, $XB", IIC_VecGeneral,

679

[(set v4i32:$XT, (or v4i32:$XA, v4i32:$XB))]>;

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

680

def XXLXOR : XX3Form<60, 154,

681

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

Hal Finkel

2014-03-26 04:55:40 +0000

[diff] [blame]

682

"xxlxor $XT, $XA, $XB", IIC_VecGeneral,

683

[(set v4i32:$XT, (xor v4i32:$XA, v4i32:$XB))]>;

Hal Finkel

2014-03-24 15:07:28 +0000

[diff] [blame]

684

} // isCommutable

Hal Finkel

2014-03-13 07:58:58 +0000

[diff] [blame]

685

686

// Permutation Instructions

687

def XXMRGHW : XX3Form<60, 18,

688

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

689

"xxmrghw $XT, $XA, $XB", IIC_VecPerm, []>;

690

def XXMRGLW : XX3Form<60, 50,

691

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),

692

"xxmrglw $XT, $XA, $XB", IIC_VecPerm, []>;

693

694

def XXPERMDI : XX3Form_2<60, 10,

695

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB, u2imm:$DM),

696

"xxpermdi $XT, $XA, $XB, $DM", IIC_VecPerm, []>;

697

def XXSEL : XX4Form<60, 3,

698

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB, vsrc:$XC),

699

"xxsel $XT, $XA, $XB, $XC", IIC_VecPerm, []>;

700

701

def XXSLDWI : XX3Form_2<60, 2,

702

(outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB, u2imm:$SHW),

703

"xxsldwi $XT, $XA, $XB, $SHW", IIC_VecPerm, []>;

704

def XXSPLTW : XX2Form_2<60, 164,

705

(outs vsrc:$XT), (ins vsrc:$XB, u2imm:$UIM),

706

"xxspltw $XT, $XB, $UIM", IIC_VecPerm, []>;

707

} // neverHasSideEffects

708

} // AddedComplexity

709

710

def : InstAlias<"xvmovdp $XT, $XB",

711

(XVCPSGNDP vsrc:$XT, vsrc:$XB, vsrc:$XB)>;

712

def : InstAlias<"xvmovsp $XT, $XB",

713

(XVCPSGNSP vsrc:$XT, vsrc:$XB, vsrc:$XB)>;

714

715

def : InstAlias<"xxspltd $XT, $XB, 0",

716

(XXPERMDI vsrc:$XT, vsrc:$XB, vsrc:$XB, 0)>;

717

def : InstAlias<"xxspltd $XT, $XB, 1",

718

(XXPERMDI vsrc:$XT, vsrc:$XB, vsrc:$XB, 3)>;

719

def : InstAlias<"xxmrghd $XT, $XA, $XB",

720

(XXPERMDI vsrc:$XT, vsrc:$XA, vsrc:$XB, 0)>;

721

def : InstAlias<"xxmrgld $XT, $XA, $XB",

722

(XXPERMDI vsrc:$XT, vsrc:$XA, vsrc:$XB, 3)>;

723

def : InstAlias<"xxswapd $XT, $XB",

724

(XXPERMDI vsrc:$XT, vsrc:$XB, vsrc:$XB, 2)>;

725

726

let AddedComplexity = 400 in { // Prefer VSX patterns over non-VSX patterns.

727

def : Pat<(v2f64 (scalar_to_vector f64:$A)),

728

(INSERT_SUBREG (v2f64 (IMPLICIT_DEF)), $A, sub_64)>;

729

730

def : Pat<(f64 (vector_extract v2f64:$S, 0)),

731

(EXTRACT_SUBREG (v2f64 (COPY_TO_REGCLASS $S, VSLRC)), sub_64)>;

732

def : Pat<(f64 (vector_extract v2f64:$S, 1)),

733

(EXTRACT_SUBREG (v2f64 (COPY_TO_REGCLASS (XXPERMDI $S, $S, 3),

734

VSLRC)), sub_64)>;

735

736

// Additional fnmsub patterns: -a*c + b == -(a*c - b)

737

def : Pat<(fma (fneg f64:$A), f64:$C, f64:$B),

738

(XSNMSUBADP $B, $C, $A)>;

739

def : Pat<(fma f64:$A, (fneg f64:$C), f64:$B),

740

(XSNMSUBADP $B, $C, $A)>;

741

742

def : Pat<(fma (fneg v2f64:$A), v2f64:$C, v2f64:$B),

743

(XVNMSUBADP $B, $C, $A)>;

744

def : Pat<(fma v2f64:$A, (fneg v2f64:$C), v2f64:$B),

745

(XVNMSUBADP $B, $C, $A)>;

746

747

def : Pat<(fma (fneg v4f32:$A), v4f32:$C, v4f32:$B),

748

(XVNMSUBASP $B, $C, $A)>;

749

def : Pat<(fma v4f32:$A, (fneg v4f32:$C), v4f32:$B),

750

(XVNMSUBASP $B, $C, $A)>;

751

752

def : Pat<(v2f64 (bitconvert v4i32:$A)),

753

(COPY_TO_REGCLASS $A, VSRC)>;

754

def : Pat<(v2f64 (bitconvert v8i16:$A)),

755

(COPY_TO_REGCLASS $A, VSRC)>;

756

def : Pat<(v2f64 (bitconvert v16i8:$A)),

757

(COPY_TO_REGCLASS $A, VSRC)>;

758

759

def : Pat<(v4i32 (bitconvert v2f64:$A)),

760

(COPY_TO_REGCLASS $A, VRRC)>;

761

def : Pat<(v8i16 (bitconvert v2f64:$A)),

762

(COPY_TO_REGCLASS $A, VRRC)>;

763

def : Pat<(v16i8 (bitconvert v2f64:$A)),

764

(COPY_TO_REGCLASS $A, VRRC)>;

765

Hal Finkel

a6c8b51

2014-03-26 16:12:58 +0000

[diff] [blame]

766

def : Pat<(v2i64 (bitconvert v4i32:$A)),

767

(COPY_TO_REGCLASS $A, VSRC)>;

768

def : Pat<(v2i64 (bitconvert v8i16:$A)),

769

(COPY_TO_REGCLASS $A, VSRC)>;

770

def : Pat<(v2i64 (bitconvert v16i8:$A)),

771

(COPY_TO_REGCLASS $A, VSRC)>;

772

773

def : Pat<(v4i32 (bitconvert v2i64:$A)),

774

(COPY_TO_REGCLASS $A, VRRC)>;

775

def : Pat<(v8i16 (bitconvert v2i64:$A)),

776

(COPY_TO_REGCLASS $A, VRRC)>;

777

def : Pat<(v16i8 (bitconvert v2i64:$A)),

778

(COPY_TO_REGCLASS $A, VRRC)>;

779

Hal Finkel

9281c9a

2014-03-26 18:26:30 +0000

[diff] [blame]

780

def : Pat<(v2f64 (bitconvert v2i64:$A)),

781

(COPY_TO_REGCLASS $A, VRRC)>;

782

def : Pat<(v2i64 (bitconvert v2f64:$A)),

783

(COPY_TO_REGCLASS $A, VRRC)>;

784

Hal Finkel