Blame - clang/test/CodeGen/builtins-systemz-zvector-error.c - toolchain/llvm-project

Ulrich Weigand

ca25643

2015-07-30 14:10:43 +0000

[diff] [blame]

1

// REQUIRES: systemz-registered-target

2

// RUN: %clang_cc1 -target-cpu z13 -triple s390x-linux-gnu \

3

// RUN: -fzvector -fno-lax-vector-conversions \

4

// RUN: -Wall -Wno-unused -Werror -fsyntax-only -verify %s

5

6

#include <vecintrin.h>

7

8

volatile vector signed char vsc;

9

volatile vector signed short vss;

10

volatile vector signed int vsi;

11

volatile vector signed long long vsl;

12

volatile vector unsigned char vuc;

13

volatile vector unsigned short vus;

14

volatile vector unsigned int vui;

15

volatile vector unsigned long long vul;

16

volatile vector bool char vbc;

17

volatile vector bool short vbs;

18

volatile vector bool int vbi;

19

volatile vector bool long long vbl;

20

volatile vector double vd;

21

22

volatile signed char sc;

23

volatile signed short ss;

24

volatile signed int si;

25

volatile signed long long sl;

26

volatile unsigned char uc;

27

volatile unsigned short us;

28

volatile unsigned int ui;

29

volatile unsigned long long ul;

30

volatile double d;

31

32

const void * volatile cptr;

33

const signed char * volatile cptrsc;

34

const signed short * volatile cptrss;

35

const signed int * volatile cptrsi;

36

const signed long long * volatile cptrsl;

37

const unsigned char * volatile cptruc;

38

const unsigned short * volatile cptrus;

39

const unsigned int * volatile cptrui;

40

const unsigned long long * volatile cptrul;

41

const float * volatile cptrf;

42

const double * volatile cptrd;

43

44

void * volatile ptr;

45

signed char * volatile ptrsc;

46

signed short * volatile ptrss;

47

signed int * volatile ptrsi;

48

signed long long * volatile ptrsl;

49

unsigned char * volatile ptruc;

50

unsigned short * volatile ptrus;

51

unsigned int * volatile ptrui;

52

unsigned long long * volatile ptrul;

53

float * volatile ptrf;

54

double * volatile ptrd;

55

56

volatile unsigned int len;

volatile int idx;

int cc;

void test_core(void) {

61

len = __lcbb(cptr, idx); // expected-error {{no matching function}}

62

// expected-note@vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}

63

len = __lcbb(cptr, 200); // expected-error {{no matching function}}

64

// expected-note@vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}

65

len = __lcbb(cptr, 32); // expected-error {{no matching function}}

66

// expected-note@vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}

67

len = __lcbb(cptr, 8192); // expected-error {{no matching function}}

68

// expected-note@vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}

69

70

vsl = vec_permi(vsl, vsl, idx); // expected-error {{no matching function}}

71

// expected-note@vecintrin.h:* 3 {{candidate function not viable}}

72

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

73

vsl = vec_permi(vsl, vsl, -1); // expected-error {{no matching function}}

74

// expected-note@vecintrin.h:* 3 {{candidate function not viable}}

75

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

76

vsl = vec_permi(vsl, vsl, 4); // expected-error {{no matching function}}

77

// expected-note@vecintrin.h:* 3 {{candidate function not viable}}

78

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

79

vul = vec_permi(vul, vul, idx); // expected-error {{no matching function}}

80

// expected-note@vecintrin.h:* 2 {{candidate function not viable}}

81

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

82

vul = vec_permi(vul, vul, -1); // expected-error {{no matching function}}

83

// expected-note@vecintrin.h:* 2 {{candidate function not viable}}

84

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

85

vul = vec_permi(vul, vul, 4); // expected-error {{no matching function}}

86

// expected-note@vecintrin.h:* 2 {{candidate function not viable}}

87

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

88

vbl = vec_permi(vbl, vbl, idx); // expected-error {{no matching function}}

89

// expected-note@vecintrin.h:* 2 {{candidate function not viable}}

90

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

91

vbl = vec_permi(vbl, vbl, -1); // expected-error {{no matching function}}

92

// expected-note@vecintrin.h:* 2 {{candidate function not viable}}

93

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

94

vbl = vec_permi(vbl, vbl, 4); // expected-error {{no matching function}}

95

// expected-note@vecintrin.h:* 2 {{candidate function not viable}}

96

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

97

vd = vec_permi(vd, vd, idx); // expected-error {{no matching function}}

98

// expected-note@vecintrin.h:* 3 {{candidate function not viable}}

99

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

100

vd = vec_permi(vd, vd, -1); // expected-error {{no matching function}}

101

// expected-note@vecintrin.h:* 3 {{candidate function not viable}}

102

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

103

vd = vec_permi(vd, vd, 4); // expected-error {{no matching function}}

104

// expected-note@vecintrin.h:* 3 {{candidate function not viable}}

105

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

106

107

vsi = vec_gather_element(vsi, vui, cptrsi, idx); // expected-error {{no matching function}}

108

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

109

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

110

vsi = vec_gather_element(vsi, vui, cptrsi, -1); // expected-error {{no matching function}}

111

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

112

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

113

vsi = vec_gather_element(vsi, vui, cptrsi, 4); // expected-error {{no matching function}}

114

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

115

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

116

vui = vec_gather_element(vui, vui, cptrui, idx); // expected-error {{no matching function}}

117

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

118

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

119

vui = vec_gather_element(vui, vui, cptrui, -1); // expected-error {{no matching function}}

120

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

121

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

122

vui = vec_gather_element(vui, vui, cptrui, 4); // expected-error {{no matching function}}

123

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

124

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

125

vbi = vec_gather_element(vbi, vui, cptrui, idx); // expected-error {{no matching function}}

126

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

127

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

128

vbi = vec_gather_element(vbi, vui, cptrui, -1); // expected-error {{no matching function}}

129

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

130

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

131

vbi = vec_gather_element(vbi, vui, cptrui, 4); // expected-error {{no matching function}}

132

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

133

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

134

vsl = vec_gather_element(vsl, vul, cptrsl, idx); // expected-error {{no matching function}}

135

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

136

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

137

vsl = vec_gather_element(vsl, vul, cptrsl, -1); // expected-error {{no matching function}}

138

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

139

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

140

vsl = vec_gather_element(vsl, vul, cptrsl, 2); // expected-error {{no matching function}}

141

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

142

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

143

vul = vec_gather_element(vul, vul, cptrul, idx); // expected-error {{no matching function}}

144

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

145

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

146

vul = vec_gather_element(vul, vul, cptrul, -1); // expected-error {{no matching function}}

147

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

148

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

149

vul = vec_gather_element(vul, vul, cptrul, 2); // expected-error {{no matching function}}

150

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

151

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

152

vbl = vec_gather_element(vbl, vul, cptrul, idx); // expected-error {{no matching function}}

153

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

154

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

155

vbl = vec_gather_element(vbl, vul, cptrul, -1); // expected-error {{no matching function}}

156

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

157

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

158

vbl = vec_gather_element(vbl, vul, cptrul, 2); // expected-error {{no matching function}}

159

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

160

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

161

vd = vec_gather_element(vd, vul, cptrd, idx); // expected-error {{no matching function}}

162

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

163

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

164

vd = vec_gather_element(vd, vul, cptrd, -1); // expected-error {{no matching function}}

165

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

166

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

167

vd = vec_gather_element(vd, vul, cptrd, 2); // expected-error {{no matching function}}

168

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

169

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

170

171

vec_scatter_element(vsi, vui, ptrsi, idx); // expected-error {{no matching function}}

172

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

173

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

174

vec_scatter_element(vsi, vui, ptrsi, -1); // expected-error {{no matching function}}

175

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

176

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

177

vec_scatter_element(vsi, vui, ptrsi, 4); // expected-error {{no matching function}}

178

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

179

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

180

vec_scatter_element(vui, vui, ptrui, idx); // expected-error {{no matching function}}

181

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

182

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

183

vec_scatter_element(vui, vui, ptrui, -1); // expected-error {{no matching function}}

184

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

185

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

186

vec_scatter_element(vui, vui, ptrui, 4); // expected-error {{no matching function}}

187

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

188

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

189

vec_scatter_element(vbi, vui, ptrui, idx); // expected-error {{no matching function}}

190

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

191

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

192

vec_scatter_element(vbi, vui, ptrui, -1); // expected-error {{no matching function}}

193

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

194

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

195

vec_scatter_element(vbi, vui, ptrui, 4); // expected-error {{no matching function}}

196

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

197

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

198

vec_scatter_element(vsl, vul, ptrsl, idx); // expected-error {{no matching function}}

199

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

200

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

201

vec_scatter_element(vsl, vul, ptrsl, -1); // expected-error {{no matching function}}

202

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

203

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

204

vec_scatter_element(vsl, vul, ptrsl, 2); // expected-error {{no matching function}}

205

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

206

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

207

vec_scatter_element(vul, vul, ptrul, idx); // expected-error {{no matching function}}

208

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

209

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

210

vec_scatter_element(vul, vul, ptrul, -1); // expected-error {{no matching function}}

211

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

212

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

213

vec_scatter_element(vul, vul, ptrul, 2); // expected-error {{no matching function}}

214

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

215

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

216

vec_scatter_element(vbl, vul, ptrul, idx); // expected-error {{no matching function}}

217

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

218

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

219

vec_scatter_element(vbl, vul, ptrul, -1); // expected-error {{no matching function}}

220

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

221

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

222

vec_scatter_element(vbl, vul, ptrul, 2); // expected-error {{no matching function}}

223

// expected-note@vecintrin.h:* 5 {{candidate function not viable}}

224

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

225

vec_scatter_element(vd, vul, ptrd, idx); // expected-error {{no matching function}}

226

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

227

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

228

vec_scatter_element(vd, vul, ptrd, -1); // expected-error {{no matching function}}

229

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

230

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

231

vec_scatter_element(vd, vul, ptrd, 2); // expected-error {{no matching function}}

232

// expected-note@vecintrin.h:* 6 {{candidate function not viable}}

233

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

234

235

vsc = vec_load_bndry(cptrsc, idx); // expected-error {{no matching function}}

236

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

237

// expected-note@vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}

238

vsc = vec_load_bndry(cptrsc, 200); // expected-error {{no matching function}}

239

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

240

// expected-note@vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}

241

vsc = vec_load_bndry(cptrsc, 32); // expected-error {{no matching function}}

242

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

243

// expected-note@vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}

244

vsc = vec_load_bndry(cptrsc, 8192); // expected-error {{no matching function}}

245

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

246

// expected-note@vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}

247

vuc = vec_load_bndry(cptruc, idx); // expected-error {{no matching function}}

248

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

249

// expected-note@vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}

250

vss = vec_load_bndry(cptrss, idx); // expected-error {{no matching function}}

251

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

252

// expected-note@vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}

253

vus = vec_load_bndry(cptrus, idx); // expected-error {{no matching function}}

254

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

255

// expected-note@vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}

256

vsi = vec_load_bndry(cptrsi, idx); // expected-error {{no matching function}}

257

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

258

// expected-note@vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}

259

vui = vec_load_bndry(cptrui, idx); // expected-error {{no matching function}}

260

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

261

// expected-note@vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}

262

vsl = vec_load_bndry(cptrsl, idx); // expected-error {{no matching function}}

263

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

264

// expected-note@vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}

265

vul = vec_load_bndry(cptrul, idx); // expected-error {{no matching function}}

266

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

267

// expected-note@vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}

268

269

vuc = vec_genmask(idx); // expected-error {{no matching function}}

270

// expected-note@vecintrin.h:* {{must be a constant integer}}

271

272

vuc = vec_genmasks_8(0, idx); // expected-error {{no matching function}}

273

// expected-note@vecintrin.h:* {{must be a constant integer}}

274

vuc = vec_genmasks_8(idx, 0); // expected-error {{no matching function}}

275

// expected-note@vecintrin.h:* {{must be a constant integer}}

276

vuc = vec_genmasks_8(idx, idx); // expected-error {{no matching function}}

277

// expected-note@vecintrin.h:* {{must be a constant integer}}

278

vus = vec_genmasks_16(0, idx); // expected-error {{no matching function}}

279

// expected-note@vecintrin.h:* {{must be a constant integer}}

280

vus = vec_genmasks_16(idx, 0); // expected-error {{no matching function}}

281

// expected-note@vecintrin.h:* {{must be a constant integer}}

282

vus = vec_genmasks_16(idx, idx); // expected-error {{no matching function}}

283

// expected-note@vecintrin.h:* {{must be a constant integer}}

284

vui = vec_genmasks_32(0, idx); // expected-error {{no matching function}}

285

// expected-note@vecintrin.h:* {{must be a constant integer}}

286

vui = vec_genmasks_32(idx, 0); // expected-error {{no matching function}}

287

// expected-note@vecintrin.h:* {{must be a constant integer}}

288

vui = vec_genmasks_32(idx, idx); // expected-error {{no matching function}}

289

// expected-note@vecintrin.h:* {{must be a constant integer}}

290

vul = vec_genmasks_64(0, idx); // expected-error {{no matching function}}

291

// expected-note@vecintrin.h:* {{must be a constant integer}}

292

vul = vec_genmasks_64(idx, 0); // expected-error {{no matching function}}

293

// expected-note@vecintrin.h:* {{must be a constant integer}}

294

vul = vec_genmasks_64(idx, idx); // expected-error {{no matching function}}

295

// expected-note@vecintrin.h:* {{must be a constant integer}}

296

297

vsc = vec_splat(vsc, idx); // expected-error {{no matching function}}

298

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

299

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

300

vsc = vec_splat(vsc, -1); // expected-error {{no matching function}}

301

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

302

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

303

vsc = vec_splat(vsc, 16); // expected-error {{no matching function}}

304

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

305

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

306

vuc = vec_splat(vuc, idx); // expected-error {{no matching function}}

307

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

308

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}

309

vuc = vec_splat(vuc, -1); // expected-error {{no matching function}}

310

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

311

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}

312

vuc = vec_splat(vuc, 16); // expected-error {{no matching function}}

313

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

314

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}

315

vbc = vec_splat(vbc, idx); // expected-error {{no matching function}}

316

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

317

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}

318

vbc = vec_splat(vbc, -1); // expected-error {{no matching function}}

319

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

320

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}

321

vbc = vec_splat(vbc, 16); // expected-error {{no matching function}}

322

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

323

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}

324

vss = vec_splat(vss, idx); // expected-error {{no matching function}}

325

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

326

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}

327

vss = vec_splat(vss, -1); // expected-error {{no matching function}}

328

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

329

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}

330

vss = vec_splat(vss, 8); // expected-error {{no matching function}}

331

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

332

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}

333

vus = vec_splat(vus, idx); // expected-error {{no matching function}}

334

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

335

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}

336

vus = vec_splat(vus, -1); // expected-error {{no matching function}}

337

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

338

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}

339

vus = vec_splat(vus, 8); // expected-error {{no matching function}}

340

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

341

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}

342

vbs = vec_splat(vbs, idx); // expected-error {{no matching function}}

343

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

344

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}

345

vbs = vec_splat(vbs, -1); // expected-error {{no matching function}}

346

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

347

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}

348

vbs = vec_splat(vbs, 8); // expected-error {{no matching function}}

349

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

350

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}

351

vsi = vec_splat(vsi, idx); // expected-error {{no matching function}}

352

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

353

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

354

vsi = vec_splat(vsi, -1); // expected-error {{no matching function}}

355

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

356

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

357

vsi = vec_splat(vsi, 4); // expected-error {{no matching function}}

358

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

359

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

360

vui = vec_splat(vui, idx); // expected-error {{no matching function}}

361

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

362

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

363

vui = vec_splat(vui, -1); // expected-error {{no matching function}}

364

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

365

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

366

vui = vec_splat(vui, 4); // expected-error {{no matching function}}

367

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

368

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

369

vbi = vec_splat(vbi, idx); // expected-error {{no matching function}}

370

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

371

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

372

vbi = vec_splat(vbi, -1); // expected-error {{no matching function}}

373

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

374

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

375

vbi = vec_splat(vbi, 4); // expected-error {{no matching function}}

376

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

377

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}

378

vsl = vec_splat(vsl, idx); // expected-error {{no matching function}}

379

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

380

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

381

vsl = vec_splat(vsl, -1); // expected-error {{no matching function}}

382

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

383

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

384

vsl = vec_splat(vsl, 2); // expected-error {{no matching function}}

385

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

386

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

387

vul = vec_splat(vul, idx); // expected-error {{no matching function}}

388

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

389

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

390

vul = vec_splat(vul, -1); // expected-error {{no matching function}}

391

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

392

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

393

vul = vec_splat(vul, 2); // expected-error {{no matching function}}

394

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

395

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

396

vbl = vec_splat(vbl, idx); // expected-error {{no matching function}}

397

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

398

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

399

vbl = vec_splat(vbl, -1); // expected-error {{no matching function}}

400

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

401

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

402

vbl = vec_splat(vbl, 2); // expected-error {{no matching function}}

403

// expected-note@vecintrin.h:* 11 {{candidate function not viable}}

404

// expected-note@vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}

405

vd = vec_splat(vd, idx); // expected-error {{no matching function}}

406

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

407

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

408

vd = vec_splat(vd, -1); // expected-error {{no matching function}}

409

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

410

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

411

vd = vec_splat(vd, 2); // expected-error {{no matching function}}

412

// expected-note@vecintrin.h:* 12 {{candidate function not viable}}

413

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}

414

415

vsc = vec_splat_s8(idx); // expected-error {{no matching function}}

416

// expected-note@vecintrin.h:* {{must be a constant integer}}

417

vuc = vec_splat_u8(idx); // expected-error {{no matching function}}

418

// expected-note@vecintrin.h:* {{must be a constant integer}}

419

vss = vec_splat_s16(idx); // expected-error {{no matching function}}

420

// expected-note@vecintrin.h:* {{must be a constant integer}}

421

vus = vec_splat_u16(idx); // expected-error {{no matching function}}

422

// expected-note@vecintrin.h:* {{must be a constant integer}}

423

vsi = vec_splat_s32(idx); // expected-error {{no matching function}}

424

// expected-note@vecintrin.h:* {{must be a constant integer}}

425

vui = vec_splat_u32(idx); // expected-error {{no matching function}}

426

// expected-note@vecintrin.h:* {{must be a constant integer}}

427

vsl = vec_splat_s64(idx); // expected-error {{no matching function}}

428

// expected-note@vecintrin.h:* {{must be a constant integer}}

429

vul = vec_splat_u64(idx); // expected-error {{no matching function}}

430

// expected-note@vecintrin.h:* {{must be a constant integer}}

431

}

432

433

void test_integer(void) {

434

vsc = vec_rl_mask(vsc, vuc, idx); // expected-error {{no matching function}}

435

// expected-note@vecintrin.h:* 7 {{candidate function not viable}}

436

// expected-note@vecintrin.h:* 1 {{must be a constant integer}}

437

vuc = vec_rl_mask(vuc, vuc, idx); // expected-error {{no matching function}}

438

// expected-note@vecintrin.h:* 7 {{candidate function not viable}}

439

// expected-note@vecintrin.h:* 1 {{must be a constant integer}}

440

vss = vec_rl_mask(vss, vus, idx); // expected-error {{no matching function}}

441

// expected-note@vecintrin.h:* 7 {{candidate function not viable}}

442

// expected-note@vecintrin.h:* 1 {{must be a constant integer}}

443

vus = vec_rl_mask(vus, vus, idx); // expected-error {{no matching function}}

444

// expected-note@vecintrin.h:* 7 {{candidate function not viable}}

445

// expected-note@vecintrin.h:* 1 {{must be a constant integer}}

446

vsi = vec_rl_mask(vsi, vui, idx); // expected-error {{no matching function}}

447

// expected-note@vecintrin.h:* 7 {{candidate function not viable}}

448

// expected-note@vecintrin.h:* 1 {{must be a constant integer}}

449

vui = vec_rl_mask(vui, vui, idx); // expected-error {{no matching function}}

450

// expected-note@vecintrin.h:* 7 {{candidate function not viable}}

451

// expected-note@vecintrin.h:* 1 {{must be a constant integer}}

452

vsl = vec_rl_mask(vsl, vul, idx); // expected-error {{no matching function}}

453

// expected-note@vecintrin.h:* 7 {{candidate function not viable}}

454

// expected-note@vecintrin.h:* 1 {{must be a constant integer}}

455

vul = vec_rl_mask(vul, vul, idx); // expected-error {{no matching function}}

456

// expected-note@vecintrin.h:* 7 {{candidate function not viable}}

457

// expected-note@vecintrin.h:* 1 {{must be a constant integer}}

458

459

vsc = vec_sld(vsc, vsc, idx); // expected-error {{no matching function}}

460

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

461

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

462

vsc = vec_sld(vsc, vsc, -1); // expected-error {{no matching function}}

463

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

464

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

465

vsc = vec_sld(vsc, vsc, 16); // expected-error {{no matching function}}

466

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

467

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

468

vuc = vec_sld(vuc, vuc, idx); // expected-error {{no matching function}}

469

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

470

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

471

vuc = vec_sld(vuc, vuc, -1); // expected-error {{no matching function}}

472

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

473

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

474

vuc = vec_sld(vuc, vuc, 16); // expected-error {{no matching function}}

475

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

476

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

477

vss = vec_sld(vss, vss, idx); // expected-error {{no matching function}}

478

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

479

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

480

vus = vec_sld(vus, vus, idx); // expected-error {{no matching function}}

481

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

482

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

483

vsi = vec_sld(vsi, vsi, idx); // expected-error {{no matching function}}

484

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

485

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

486

vui = vec_sld(vui, vui, idx); // expected-error {{no matching function}}

487

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

488

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

489

vsl = vec_sld(vsl, vsl, idx); // expected-error {{no matching function}}

490

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

491

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

492

vul = vec_sld(vul, vul, idx); // expected-error {{no matching function}}

493

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

494

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

495

vd = vec_sld(vd, vd, idx); // expected-error {{no matching function}}

496

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

497

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}

498

499

vsc = vec_sldw(vsc, vsc, idx); // expected-error {{no matching function}}

500

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

501

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

502

vsc = vec_sldw(vsc, vsc, -1); // expected-error {{no matching function}}

503

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

504

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

505

vsc = vec_sldw(vsc, vsc, 4); // expected-error {{no matching function}}

506

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

507

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

508

vuc = vec_sldw(vuc, vuc, idx); // expected-error {{no matching function}}

509

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

510

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

511

vuc = vec_sldw(vuc, vuc, -1); // expected-error {{no matching function}}

512

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

513

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

514

vuc = vec_sldw(vuc, vuc, 4); // expected-error {{no matching function}}

515

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

516

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

517

vss = vec_sldw(vss, vss, idx); // expected-error {{no matching function}}

518

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

519

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

520

vus = vec_sldw(vus, vus, idx); // expected-error {{no matching function}}

521

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

522

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

523

vsi = vec_sldw(vsi, vsi, idx); // expected-error {{no matching function}}

524

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

525

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

526

vui = vec_sldw(vui, vui, idx); // expected-error {{no matching function}}

527

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

528

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

529

vsl = vec_sldw(vsl, vsl, idx); // expected-error {{no matching function}}

530

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

531

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

532

vul = vec_sldw(vul, vul, idx); // expected-error {{no matching function}}

533

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

534

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

535

vd = vec_sldw(vd, vd, idx); // expected-error {{no matching function}}

536

// expected-note@vecintrin.h:* 8 {{candidate function not viable}}

537

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}

538

}

539

540

void test_float(void) {

541

vd = vec_ctd(vsl, idx); // expected-error {{no matching function}}

542

// expected-note@vecintrin.h:* 1 {{candidate function not viable}}

543

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}

544

vd = vec_ctd(vsl, -1); // expected-error {{no matching function}}

545

// expected-note@vecintrin.h:* 1 {{candidate function not viable}}

546

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}

547

vd = vec_ctd(vsl, 32); // expected-error {{no matching function}}

548

// expected-note@vecintrin.h:* 1 {{candidate function not viable}}

549

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}

550

vd = vec_ctd(vul, idx); // expected-error {{no matching function}}

551

// expected-note@vecintrin.h:* 1 {{candidate function not viable}}

552

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}

553

vd = vec_ctd(vul, -1); // expected-error {{no matching function}}

554

// expected-note@vecintrin.h:* 1 {{candidate function not viable}}

555

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}

556

vd = vec_ctd(vul, 32); // expected-error {{no matching function}}

557

// expected-note@vecintrin.h:* 1 {{candidate function not viable}}

558

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}

559

560

vsl = vec_ctsl(vd, idx); // expected-error {{no matching function}}

561

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}

562

vsl = vec_ctsl(vd, -1); // expected-error {{no matching function}}

563

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}

564

vsl = vec_ctsl(vd, 32); // expected-error {{no matching function}}

565

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}

566

vul = vec_ctul(vd, idx); // expected-error {{no matching function}}

567

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}

568

vul = vec_ctul(vd, -1); // expected-error {{no matching function}}

569

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}

570

vul = vec_ctul(vd, 32); // expected-error {{no matching function}}

571

// expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}

572

573

vbl = vec_fp_test_data_class(vd, idx, &cc); // expected-error {{must be a constant integer}}

574

vbl = vec_fp_test_data_class(vd, -1, &cc); // expected-error {{should be a value from 0 to 4095}}

575

vbl = vec_fp_test_data_class(vd, 4096, &cc); // expected-error {{should be a value from 0 to 4095}}

576

}