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),

60

"lxvw4x $XT, $src", IIC_LdStLFD,

61

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

62

}

63

64

// Store indexed instructions

65

let mayStore = 1 in {

66

def STXSDX : XX1Form<31, 716,

67

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

68

"stxsdx $XT, $dst", IIC_LdStSTFD,

69

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

70

71

def STXVD2X : XX1Form<31, 972,

72

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

73

"stxvd2x $XT, $dst", IIC_LdStSTFD,

74

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

75

76

def STXVW4X : XX1Form<31, 908,

77

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

78

"stxvw4x $XT, $dst", IIC_LdStSTFD,

79

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

80

}

81

82

// Add/Mul Instructions

83

let isCommutable = 1 in {

84

def XSADDDP : XX3Form<60, 32,

85

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

86

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

87

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

88

def XSMULDP : XX3Form<60, 48,

89

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

90

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

91

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

92

93

def XVADDDP : XX3Form<60, 96,

94

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

95

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

96

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

97

98

def XVADDSP : XX3Form<60, 64,

99

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

100

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

101

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

102

103

def XVMULDP : XX3Form<60, 112,

104

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

105

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

106

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

107

108

def XVMULSP : XX3Form<60, 80,

109

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

110

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

111

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

112

}

113

114

// Subtract Instructions

115

def XSSUBDP : XX3Form<60, 40,

116

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

117

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

118

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

119

120

def XVSUBDP : XX3Form<60, 104,

121

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

122

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

123

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

124

def XVSUBSP : XX3Form<60, 72,

125

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

126

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

127

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

128

129

// FMA Instructions

Hal Finkel

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

[diff] [blame]

130

let BaseName = "XSMADDADP" in {

Hal Finkel

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

[diff] [blame]

131

let isCommutable = 1 in

Hal Finkel

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

[diff] [blame]

132

def XSMADDADP : XX3Form<60, 33,

133

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

134

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

135

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

Hal Finkel

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

[diff] [blame]

136

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

137

AltVSXFMARel;

138

let IsVSXFMAAlt = 1 in

Hal Finkel

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

[diff] [blame]

139

def XSMADDMDP : XX3Form<60, 41,

140

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

141

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

Hal Finkel

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

[diff] [blame]

142

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

143

AltVSXFMARel;

144

}

Hal Finkel

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

[diff] [blame]

145

Hal Finkel

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

[diff] [blame]

146

let BaseName = "XSMSUBADP" in {

Hal Finkel

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

[diff] [blame]

147

let isCommutable = 1 in

Hal Finkel

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

[diff] [blame]

148

def XSMSUBADP : XX3Form<60, 49,

149

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

150

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

151

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

Hal Finkel

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

[diff] [blame]

152

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

153

AltVSXFMARel;

154

let IsVSXFMAAlt = 1 in

Hal Finkel

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

[diff] [blame]

155

def XSMSUBMDP : XX3Form<60, 57,

156

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

157

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

Hal Finkel

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

[diff] [blame]

158

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

159

AltVSXFMARel;

160

}

Hal Finkel

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

[diff] [blame]

161

Hal Finkel

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

[diff] [blame]

162

let BaseName = "XSNMADDADP" in {

Hal Finkel

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

[diff] [blame]

163

let isCommutable = 1 in

Hal Finkel

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

[diff] [blame]

164

def XSNMADDADP : XX3Form<60, 161,

165

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

166

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

167

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

Hal Finkel

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

[diff] [blame]

168

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

169

AltVSXFMARel;

170

let IsVSXFMAAlt = 1 in

Hal Finkel

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

[diff] [blame]

171

def XSNMADDMDP : XX3Form<60, 169,

172

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

173

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

Hal Finkel

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

[diff] [blame]

174

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

175

AltVSXFMARel;

176

}

Hal Finkel

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

[diff] [blame]

177

Hal Finkel

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

[diff] [blame]

178

let BaseName = "XSNMSUBADP" in {

Hal Finkel

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

[diff] [blame]

179

let isCommutable = 1 in

Hal Finkel

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

[diff] [blame]

180

def XSNMSUBADP : XX3Form<60, 177,

181

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

182

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

183

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

Hal Finkel

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

[diff] [blame]

184

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

185

AltVSXFMARel;

186

let IsVSXFMAAlt = 1 in

Hal Finkel

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

[diff] [blame]

187

def XSNMSUBMDP : XX3Form<60, 185,

188

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

189

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

Hal Finkel

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

[diff] [blame]

190

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

191

AltVSXFMARel;

192

}

Hal Finkel

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

[diff] [blame]

193

Hal Finkel

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

[diff] [blame]

194

let BaseName = "XVMADDADP" in {

Hal Finkel

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

[diff] [blame]

195

let isCommutable = 1 in

Hal Finkel

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

[diff] [blame]

196

def XVMADDADP : XX3Form<60, 97,

197

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

198

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

199

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

Hal Finkel

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

[diff] [blame]

200

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

201

AltVSXFMARel;

202

let IsVSXFMAAlt = 1 in

Hal Finkel

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

[diff] [blame]

203

def XVMADDMDP : XX3Form<60, 105,

204

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

205

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

Hal Finkel

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

[diff] [blame]

206

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

207

AltVSXFMARel;

208

}

Hal Finkel

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

[diff] [blame]

209

Hal Finkel

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

[diff] [blame]

210

let BaseName = "XVMADDASP" in {

Hal Finkel

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

[diff] [blame]

211

let isCommutable = 1 in

Hal Finkel

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

[diff] [blame]

212

def XVMADDASP : XX3Form<60, 65,

213

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

214

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

215

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

Hal Finkel

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

[diff] [blame]

216

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

217

AltVSXFMARel;

218

let IsVSXFMAAlt = 1 in

Hal Finkel

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

[diff] [blame]

219

def XVMADDMSP : XX3Form<60, 73,

220

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

221

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

Hal Finkel

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

[diff] [blame]

222

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

223

AltVSXFMARel;

224

}

Hal Finkel

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

[diff] [blame]

225

Hal Finkel

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

[diff] [blame]

226

let BaseName = "XVMSUBADP" in {

Hal Finkel

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

[diff] [blame]

227

let isCommutable = 1 in

Hal Finkel

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

[diff] [blame]

228

def XVMSUBADP : XX3Form<60, 113,

229

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

230

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

231

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

Hal Finkel

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

[diff] [blame]

232

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

233

AltVSXFMARel;

234

let IsVSXFMAAlt = 1 in

Hal Finkel

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

[diff] [blame]

235

def XVMSUBMDP : XX3Form<60, 121,

236

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

237

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

Hal Finkel

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

[diff] [blame]

238

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

239

AltVSXFMARel;

240

}

Hal Finkel

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

[diff] [blame]

241

Hal Finkel

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

[diff] [blame]

242

let BaseName = "XVMSUBASP" in {

Hal Finkel

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

[diff] [blame]

243

let isCommutable = 1 in

Hal Finkel

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

[diff] [blame]

244

def XVMSUBASP : XX3Form<60, 81,

245

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

246

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

247

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

Hal Finkel

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

[diff] [blame]

248

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

249

AltVSXFMARel;

250

let IsVSXFMAAlt = 1 in

Hal Finkel

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

[diff] [blame]

251

def XVMSUBMSP : XX3Form<60, 89,

252

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

253

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

Hal Finkel

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

[diff] [blame]

254

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

255

AltVSXFMARel;

256

}

Hal Finkel

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

[diff] [blame]

257

Hal Finkel

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

[diff] [blame]

258

let BaseName = "XVNMADDADP" in {

Hal Finkel

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

[diff] [blame]

259

let isCommutable = 1 in

Hal Finkel

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

[diff] [blame]

260

def XVNMADDADP : XX3Form<60, 225,

261

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

262

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

263

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

Hal Finkel

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

[diff] [blame]

264

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

265

AltVSXFMARel;

266

let IsVSXFMAAlt = 1 in

Hal Finkel

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

[diff] [blame]

267

def XVNMADDMDP : XX3Form<60, 233,

268

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

269

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

Hal Finkel

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

[diff] [blame]

270

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

271

AltVSXFMARel;

272

}

Hal Finkel

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

[diff] [blame]

273

Hal Finkel

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

[diff] [blame]

274

let BaseName = "XVNMADDASP" in {

Hal Finkel

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

[diff] [blame]

275

let isCommutable = 1 in

Hal Finkel

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

[diff] [blame]

276

def XVNMADDASP : XX3Form<60, 193,

277

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

278

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

279

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

Hal Finkel

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

[diff] [blame]

280

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

281

AltVSXFMARel;

282

let IsVSXFMAAlt = 1 in

Hal Finkel

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

[diff] [blame]

283

def XVNMADDMSP : XX3Form<60, 201,

284

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

285

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

Hal Finkel

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

[diff] [blame]

286

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

287

AltVSXFMARel;

288

}

Hal Finkel

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

[diff] [blame]

289

Hal Finkel

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

[diff] [blame]

290

let BaseName = "XVNMSUBADP" in {

Hal Finkel

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

[diff] [blame]

291

let isCommutable = 1 in

Hal Finkel

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

[diff] [blame]

292

def XVNMSUBADP : XX3Form<60, 241,

293

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

294

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

295

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

Hal Finkel

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

[diff] [blame]

296

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

297

AltVSXFMARel;

298

let IsVSXFMAAlt = 1 in

Hal Finkel

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

[diff] [blame]

299

def XVNMSUBMDP : XX3Form<60, 249,

300

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

301

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

Hal Finkel

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

[diff] [blame]

302

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

303

AltVSXFMARel;

304

}

Hal Finkel

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

[diff] [blame]

305

Hal Finkel

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

[diff] [blame]

306

let BaseName = "XVNMSUBASP" in {

Hal Finkel

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

[diff] [blame]

307

let isCommutable = 1 in

Hal Finkel

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

[diff] [blame]

308

def XVNMSUBASP : XX3Form<60, 209,

309

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

310

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

311

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

Hal Finkel

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

[diff] [blame]

312

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

313

AltVSXFMARel;

314

let IsVSXFMAAlt = 1 in

Hal Finkel

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

[diff] [blame]

315

def XVNMSUBMSP : XX3Form<60, 217,

316

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

317

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

Hal Finkel

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

[diff] [blame]

318

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

319

AltVSXFMARel;

320

}

Hal Finkel

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

[diff] [blame]

321

322

// Division Instructions

323

def XSDIVDP : XX3Form<60, 56,

324

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

325

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

326

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

327

def XSSQRTDP : XX2Form<60, 75,

328

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

329

"xssqrtdp $XT, $XB", IIC_VecFP,

330

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

331

332

def XSREDP : XX2Form<60, 90,

333

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

334

"xsredp $XT, $XB", IIC_VecFP,

335

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

336

def XSRSQRTEDP : XX2Form<60, 74,

337

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

338

"xsrsqrtedp $XT, $XB", IIC_VecFP,

339

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

340

341

def XSTDIVDP : XX3Form_1<60, 61,

342

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

343

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

344

def XSTSQRTDP : XX2Form_1<60, 106,

345

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

346

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

347

348

def XVDIVDP : XX3Form<60, 120,

349

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

350

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

351

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

352

def XVDIVSP : XX3Form<60, 88,

353

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

354

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

355

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

356

357

def XVSQRTDP : XX2Form<60, 203,

358

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

359

"xvsqrtdp $XT, $XB", IIC_VecFP,

360

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

361

def XVSQRTSP : XX2Form<60, 139,

362

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

363

"xvsqrtsp $XT, $XB", IIC_VecFP,

364

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

365

366

def XVTDIVDP : XX3Form_1<60, 125,

367

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

368

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

369

def XVTDIVSP : XX3Form_1<60, 93,

370

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

371

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

372

373

def XVTSQRTDP : XX2Form_1<60, 234,

374

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

375

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

376

def XVTSQRTSP : XX2Form_1<60, 170,

377

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

378

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

379

380

def XVREDP : XX2Form<60, 218,

381

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

382

"xvredp $XT, $XB", IIC_VecFP,

383

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

384

def XVRESP : XX2Form<60, 154,

385

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

386

"xvresp $XT, $XB", IIC_VecFP,

387

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

388

389

def XVRSQRTEDP : XX2Form<60, 202,

390

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

391

"xvrsqrtedp $XT, $XB", IIC_VecFP,

392

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

393

def XVRSQRTESP : XX2Form<60, 138,

394

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

395

"xvrsqrtesp $XT, $XB", IIC_VecFP,

396

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

397

398

// Compare Instructions

399

def XSCMPODP : XX3Form_1<60, 43,

400

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

401

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

402

def XSCMPUDP : XX3Form_1<60, 35,

403

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

404

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

405

406

defm XVCMPEQDP : XX3Form_Rcr<60, 99,

407

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

408

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

409

defm XVCMPEQSP : XX3Form_Rcr<60, 67,

410

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

411

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

412

defm XVCMPGEDP : XX3Form_Rcr<60, 115,

413

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

414

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

415

defm XVCMPGESP : XX3Form_Rcr<60, 83,

416

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

417

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

418

defm XVCMPGTDP : XX3Form_Rcr<60, 107,

419

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

420

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

421

defm XVCMPGTSP : XX3Form_Rcr<60, 75,

422

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

423

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

424

425

// Move Instructions

426

def XSABSDP : XX2Form<60, 345,

427

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

428

"xsabsdp $XT, $XB", IIC_VecFP,

429

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

430

def XSNABSDP : XX2Form<60, 361,

431

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

432

"xsnabsdp $XT, $XB", IIC_VecFP,

433

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

434

def XSNEGDP : XX2Form<60, 377,

435

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

436

"xsnegdp $XT, $XB", IIC_VecFP,

437

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

438

def XSCPSGNDP : XX3Form<60, 176,

439

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

440

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

441

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

442

443

def XVABSDP : XX2Form<60, 473,

444

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

445

"xvabsdp $XT, $XB", IIC_VecFP,

446

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

447

448

def XVABSSP : XX2Form<60, 409,

449

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

450

"xvabssp $XT, $XB", IIC_VecFP,

451

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

452

453

def XVCPSGNDP : XX3Form<60, 240,

454

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

455

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

456

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

457

def XVCPSGNSP : XX3Form<60, 208,

458

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

459

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

460

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

461

462

def XVNABSDP : XX2Form<60, 489,

463

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

464

"xvnabsdp $XT, $XB", IIC_VecFP,

465

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

466

def XVNABSSP : XX2Form<60, 425,

467

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

468

"xvnabssp $XT, $XB", IIC_VecFP,

469

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

470

471

def XVNEGDP : XX2Form<60, 505,

472

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

473

"xvnegdp $XT, $XB", IIC_VecFP,

474

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

475

def XVNEGSP : XX2Form<60, 441,

476

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

477

"xvnegsp $XT, $XB", IIC_VecFP,

478

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

479

480

// Conversion Instructions

481

def XSCVDPSP : XX2Form<60, 265,

482

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

483

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

484

def XSCVDPSXDS : XX2Form<60, 344,

485

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

Hal Finkel

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

[diff] [blame]

486

"xscvdpsxds $XT, $XB", IIC_VecFP,

487

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

Hal Finkel

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

[diff] [blame]

488

def XSCVDPSXWS : XX2Form<60, 88,

489

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

Hal Finkel

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

[diff] [blame]

490

"xscvdpsxws $XT, $XB", IIC_VecFP,

491

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

Hal Finkel

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

[diff] [blame]

492

def XSCVDPUXDS : XX2Form<60, 328,

493

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

Hal Finkel

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

[diff] [blame]

494

"xscvdpuxds $XT, $XB", IIC_VecFP,

495

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

Hal Finkel

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

[diff] [blame]

496

def XSCVDPUXWS : XX2Form<60, 72,

497

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

Hal Finkel

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

[diff] [blame]

498

"xscvdpuxws $XT, $XB", IIC_VecFP,

499

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

Hal Finkel

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

[diff] [blame]

500

def XSCVSPDP : XX2Form<60, 329,

501

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

502

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

503

def XSCVSXDDP : XX2Form<60, 376,

504

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

Hal Finkel

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

[diff] [blame]

505

"xscvsxddp $XT, $XB", IIC_VecFP,

506

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

Hal Finkel

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

[diff] [blame]

507

def XSCVUXDDP : XX2Form<60, 360,

508

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

Hal Finkel

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

[diff] [blame]

509

"xscvuxddp $XT, $XB", IIC_VecFP,

510

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

Hal Finkel

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

[diff] [blame]

511

512

def XVCVDPSP : XX2Form<60, 393,

513

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

514

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

515

def XVCVDPSXDS : XX2Form<60, 472,

516

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

517

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

518

def XVCVDPSXWS : XX2Form<60, 216,

519

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

520

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

521

def XVCVDPUXDS : XX2Form<60, 456,

522

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

523

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

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),

545

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

546

def XVCVSXDSP : XX2Form<60, 440,

547

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

548

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

549

def XVCVSXWDP : XX2Form<60, 248,

550

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

551

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

552

def XVCVSXWSP : XX2Form<60, 184,

553

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

554

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

555

def XVCVUXDDP : XX2Form<60, 488,

556

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

557

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

558

def XVCVUXDSP : XX2Form<60, 424,

559

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

560

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

561

def XVCVUXWDP : XX2Form<60, 232,

562

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

563

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

564

def XVCVUXWSP : XX2Form<60, 168,

565

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

566

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

567

568

// Rounding Instructions

569

def XSRDPI : XX2Form<60, 73,

570

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

571

"xsrdpi $XT, $XB", IIC_VecFP,

572

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

573

def XSRDPIC : XX2Form<60, 107,

574

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

575

"xsrdpic $XT, $XB", IIC_VecFP,

576

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

577

def XSRDPIM : XX2Form<60, 121,

578

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

579

"xsrdpim $XT, $XB", IIC_VecFP,

580

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

581

def XSRDPIP : XX2Form<60, 105,

582

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

583

"xsrdpip $XT, $XB", IIC_VecFP,

584

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

585

def XSRDPIZ : XX2Form<60, 89,

586

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

587

"xsrdpiz $XT, $XB", IIC_VecFP,

588

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

589

590

def XVRDPI : XX2Form<60, 201,

591

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

592

"xvrdpi $XT, $XB", IIC_VecFP,

593

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

594

def XVRDPIC : XX2Form<60, 235,

595

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

596

"xvrdpic $XT, $XB", IIC_VecFP,

597

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

598

def XVRDPIM : XX2Form<60, 249,

599

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

600

"xvrdpim $XT, $XB", IIC_VecFP,

601

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

602

def XVRDPIP : XX2Form<60, 233,

603

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

604

"xvrdpip $XT, $XB", IIC_VecFP,

605

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

606

def XVRDPIZ : XX2Form<60, 217,

607

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

608

"xvrdpiz $XT, $XB", IIC_VecFP,

609

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

610

611

def XVRSPI : XX2Form<60, 137,

612

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

613

"xvrspi $XT, $XB", IIC_VecFP,

614

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

615

def XVRSPIC : XX2Form<60, 171,

616

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

617

"xvrspic $XT, $XB", IIC_VecFP,

618

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

619

def XVRSPIM : XX2Form<60, 185,

620

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

621

"xvrspim $XT, $XB", IIC_VecFP,

622

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

623

def XVRSPIP : XX2Form<60, 169,

624

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

625

"xvrspip $XT, $XB", IIC_VecFP,

626

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

627

def XVRSPIZ : XX2Form<60, 153,

628

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

629

"xvrspiz $XT, $XB", IIC_VecFP,

630

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

631

632

// Max/Min Instructions

Hal Finkel

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

[diff] [blame]

633

let isCommutable = 1 in {

Hal Finkel

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

[diff] [blame]

634

def XSMAXDP : XX3Form<60, 160,

635

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

636

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

637

def XSMINDP : XX3Form<60, 168,

638

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

639

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

640

641

def XVMAXDP : XX3Form<60, 224,

642

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

643

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

644

def XVMINDP : XX3Form<60, 232,

645

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

646

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

647

648

def XVMAXSP : XX3Form<60, 192,

649

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

650

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

651

def XVMINSP : XX3Form<60, 200,

652

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

653

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

Hal Finkel

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

[diff] [blame]

654

} // isCommutable

Hal Finkel

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

[diff] [blame]

655

} // Uses = [RM]

656

657

// Logical Instructions

Hal Finkel

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

[diff] [blame]

658

let isCommutable = 1 in

Hal Finkel

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

[diff] [blame]

659

def XXLAND : XX3Form<60, 130,

660

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

Hal Finkel

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

[diff] [blame]

661

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

662

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

Hal Finkel

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

[diff] [blame]

663

def XXLANDC : XX3Form<60, 138,

664

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

Hal Finkel

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

[diff] [blame]

665

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

666

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

667

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

Hal Finkel

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

[diff] [blame]

668

let isCommutable = 1 in {

Hal Finkel

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

[diff] [blame]

669

def XXLNOR : XX3Form<60, 162,

670

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

Hal Finkel

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

[diff] [blame]

671

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

672

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

673

v4i32:$XB)))]>;

Hal Finkel

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

[diff] [blame]

674

def XXLOR : XX3Form<60, 146,

675

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

Hal Finkel

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

[diff] [blame]

676

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

677

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

Hal Finkel

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

[diff] [blame]

678

def XXLXOR : XX3Form<60, 154,

679

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

Hal Finkel

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

[diff] [blame]

680

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

681

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

Hal Finkel

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

[diff] [blame]

682

} // isCommutable

Hal Finkel

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

[diff] [blame]

683

684

// Permutation Instructions

685

def XXMRGHW : XX3Form<60, 18,

686

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

687

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

688

def XXMRGLW : XX3Form<60, 50,

689

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

690

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

691

692

def XXPERMDI : XX3Form_2<60, 10,

693

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

694

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

695

def XXSEL : XX4Form<60, 3,

696

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

697

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

698

699

def XXSLDWI : XX3Form_2<60, 2,

700

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

701

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

702

def XXSPLTW : XX2Form_2<60, 164,

703

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

704

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

705

} // neverHasSideEffects

706

} // AddedComplexity

707

708

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

709

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

710

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

711

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

712

713

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

714

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

715

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

716

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

717

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

718

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

719

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

720

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

721

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

722

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

723

724

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

725

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

726

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

727

728

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

729

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

730

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

731

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

732

VSLRC)), sub_64)>;

733

734

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

735

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

736

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

737

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

738

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

739

740

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

741

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

742

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

743

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

744

745

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

746

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

747

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

748

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

749

750

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

751

(COPY_TO_REGCLASS $A, VSRC)>;

752

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

753

(COPY_TO_REGCLASS $A, VSRC)>;

754

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

755

(COPY_TO_REGCLASS $A, VSRC)>;

756

757

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

758

(COPY_TO_REGCLASS $A, VRRC)>;

759

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

760

(COPY_TO_REGCLASS $A, VRRC)>;

761

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

762

(COPY_TO_REGCLASS $A, VRRC)>;

763

Hal Finkel

a6c8b51

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

[diff] [blame]

764

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

765

(COPY_TO_REGCLASS $A, VSRC)>;

766

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

767

(COPY_TO_REGCLASS $A, VSRC)>;

768

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

769

(COPY_TO_REGCLASS $A, VSRC)>;

770

771

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

772

(COPY_TO_REGCLASS $A, VRRC)>;

773

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

774

(COPY_TO_REGCLASS $A, VRRC)>;

775

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

776

(COPY_TO_REGCLASS $A, VRRC)>;

777

Hal Finkel

9281c9a

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

[diff] [blame^]

778

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

779

(COPY_TO_REGCLASS $A, VRRC)>;

780

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

781

(COPY_TO_REGCLASS $A, VRRC)>;

782

Hal Finkel