This is an archive of the discontinued LLVM Phabricator instance.

Differential D25950

[PPC] add float and double overloads for vec_orc and vec_nand in altivec.h
ClosedPublic

Authored by sfertile on Oct 25 2016, 10:53 AM.

Details

Reviewers
lei
syzaara
kbarton
amehsan
jtony
nemanjai
Summary

add missing overloads for vec_orc:
vector double vec_orc (vector bool long long, vector double);
vector double vec_orc (vector double, vector bool long long);
vector float vec_orc (vector bool int, vector float);
vector float vec_orc (vector float, vector bool int);

and vec_nand:
vector double vec_nand (vector double, vector double);
vector float vec_nand (vector float, vector float);

Diff Detail

Repository
rL LLVM

Event Timeline

sfertile updated this revision to Diff 75729.Oct 25 2016, 10:53 AM
sfertile retitled this revision from to [PPC] add float and double overloads for vec_orc and vec_nand in altivec.h.
sfertile updated this object.
sfertile added reviewers: amehsan, nemanjai, lei, syzaara, kbarton, jtony.
sfertile set the repository for this revision to rL LLVM.
sfertile added subscribers: llvm-commits, echristo.
amehsan added inline comments.Oct 25 2016, 11:00 AM
lib/Headers/altivec.h
5273–5278

@kbarton Using C-style cast here, violates strict aliasing. Is that correct? Could it lead to functional problems if someone compiles their code WITHOUT -fno-strict-aliasing while using this built-ins? For example if this built-in is used in a context where a and b are deferenced pointers? Note that this will be inlined.

amehsan added inline comments.Oct 25 2016, 11:01 AM
lib/Headers/altivec.h
5273–5278

used in a context where

__a and __b

Sorry for bad format of the comment.
@nemanjai what do you think?

nemanjai added inline comments.Oct 25 2016, 1:47 PM
lib/Headers/altivec.h
5273–5278

I may be wrong, but I don't think it does still. I think the semantics of the cast are always equivalent to a static_cast rather than a reinterpret_cast.

echristo added inline comments.Oct 25 2016, 2:51 PM
lib/Headers/altivec.h
5273–5278

The semantics of the cast should be equivalent to static_cast and not reinterpret_cast. It's overall a weird set of fallback rules and there's really nothing to say what happens in the spec.

Also, FWIW, we do this all over the place in the x86 intrinsics.

amehsan added inline comments.Oct 25 2016, 5:38 PM
lib/Headers/altivec.h
5273–5278

Also, FWIW, we do this all over the place in the x86 intrinsics.

Good to know. Then we don't need to worry about this.

The semantics of the cast should be equivalent to static_cast and not reinterpret_cast.

I think what is meant here is that the cast here does not change the binary representation of the vector. Right? That seems to be the behavior both static_cast and reinterpret_cast for vectors:

amehsan@genoa:~/dev$ cat vcast.cpp
#include<altivec.h>
#include <iostream>
using namespace std;

int main() {

  vector float vf = {2.3f, 2.4f, 2.5f, 2.6f};
  cout << vf[1] << endl;
  vector unsigned vu = static_cast<vector unsigned>(vf);
  cout << vu[1] << endl;
  vector unsigned vu2 = reinterpret_cast<vector unsigned>(vf);
  cout << vu2[1] << endl;
  vector unsigned vu3 = (vector unsigned)vf;
  cout << vu3[1] << endl;

  float x = 3.14f;
  cout << x << endl;
  cout << static_cast<unsigned>(x) << endl;
  //cout << reinterpret_cast<unsigned>(x) << endl;//compile error
  cout << (unsigned) x << endl;

  return 0;

}
amehsan@genoa:~/dev$ clang++ vcast.cpp -o vcast  -maltivec
amehsan@genoa:~/dev$ ./vcast
2.4
1075419546
1075419546
1075419546
3.14
3
3
amehsan@genoa:~/dev$
nemanjai edited edge metadata.Oct 27 2016, 12:48 AM

This LGTM but I'll let @kbarton have a look as well.

kbarton accepted this revision.Oct 27 2016, 1:04 PM
kbarton edited edge metadata.

LGTM

This revision is now accepted and ready to land.Oct 27 2016, 1:04 PM
sfertile updated this revision to Diff 76230.Oct 28 2016, 12:07 PM
sfertile edited edge metadata.

rebased to top of master, picking up incoming altivec.h changes

nemanjai added a comment.Oct 28 2016, 1:14 PM

Committed revision 285439.
Sean please close this review if there are no buildbot failures.

sfertile closed this revision.Oct 31 2016, 7:08 AM

Revision Contents

PathSize
lib/
Headers/
32 lines
test/
CodeGen/
36 lines

Diff 75729

lib/Headers/altivec.h

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 5,264 Lines • ▼ Show 20 Linesvec_nand(vector bool int __a, vector unsigned int __b) {
return ~(__a & __b); return ~(__a & __b);
} }
static __inline__ vector bool int __ATTRS_o_ai vec_nand(vector bool int __a, static __inline__ vector bool int __ATTRS_o_ai vec_nand(vector bool int __a,
vector bool int __b) { vector bool int __b) {
return ~(__a & __b); return ~(__a & __b);
} }
static __inline__ vector float __ATTRS_o_ai
vec_nand(vector float __a, vector float __b) {
return (vector float)(~((vector unsigned int)__a &
(vector unsigned int)__b));
}
amehsanUnsubmitted
Not Done
ReplyInline Actions

@kbarton Using C-style cast here, violates strict aliasing. Is that correct? Could it lead to functional problems if someone compiles their code WITHOUT -fno-strict-aliasing while using this built-ins? For example if this built-in is used in a context where a and b are deferenced pointers? Note that this will be inlined.

amehsan: @kbarton Using C-style cast here, violates strict aliasing. Is that correct? Could it lead to…
amehsanUnsubmitted
Not Done
ReplyInline Actions

used in a context where

__a and __b

Sorry for bad format of the comment.
@nemanjai what do you think?

amehsan: used in a context where ``` __a and __b ``` Sorry for bad format of the comment. @nemanjai…
nemanjaiUnsubmitted
Not Done
ReplyInline Actions

I may be wrong, but I don't think it does still. I think the semantics of the cast are always equivalent to a static_cast rather than a reinterpret_cast.

nemanjai: I may be wrong, but I don't think it does still. I think the semantics of the cast are always…
echristoUnsubmitted
Not Done
ReplyInline Actions

The semantics of the cast should be equivalent to static_cast and not reinterpret_cast. It's overall a weird set of fallback rules and there's really nothing to say what happens in the spec.

Also, FWIW, we do this all over the place in the x86 intrinsics.

echristo: The semantics of the cast should be equivalent to static_cast and not reinterpret_cast. It's…
amehsanUnsubmitted
Not Done
ReplyInline Actions

Also, FWIW, we do this all over the place in the x86 intrinsics.

Good to know. Then we don't need to worry about this.

The semantics of the cast should be equivalent to static_cast and not reinterpret_cast.

I think what is meant here is that the cast here does not change the binary representation of the vector. Right? That seems to be the behavior both static_cast and reinterpret_cast for vectors:

amehsan@genoa:~/dev$ cat vcast.cpp
#include<altivec.h>
#include <iostream>
using namespace std;

int main() {

  vector float vf = {2.3f, 2.4f, 2.5f, 2.6f};
  cout << vf[1] << endl;
  vector unsigned vu = static_cast<vector unsigned>(vf);
  cout << vu[1] << endl;
  vector unsigned vu2 = reinterpret_cast<vector unsigned>(vf);
  cout << vu2[1] << endl;
  vector unsigned vu3 = (vector unsigned)vf;
  cout << vu3[1] << endl;

  float x = 3.14f;
  cout << x << endl;
  cout << static_cast<unsigned>(x) << endl;
  //cout << reinterpret_cast<unsigned>(x) << endl;//compile error
  cout << (unsigned) x << endl;

  return 0;

}
amehsan@genoa:~/dev$ clang++ vcast.cpp -o vcast  -maltivec
amehsan@genoa:~/dev$ ./vcast
2.4
1075419546
1075419546
1075419546
3.14
3
3
amehsan@genoa:~/dev$
amehsan: > Also, FWIW, we do this all over the place in the x86 intrinsics. Good to know. Then we don't…
static __inline__ vector signed long long __ATTRS_o_ai static __inline__ vector signed long long __ATTRS_o_ai
vec_nand(vector signed long long __a, vector signed long long __b) { vec_nand(vector signed long long __a, vector signed long long __b) {
return ~(__a & __b); return ~(__a & __b);
} }
static __inline__ vector signed long long __ATTRS_o_ai static __inline__ vector signed long long __ATTRS_o_ai
vec_nand(vector signed long long __a, vector bool long long __b) { vec_nand(vector signed long long __a, vector bool long long __b) {
return ~(__a & __b); return ~(__a & __b);
Show All 19 Linesvec_nand(vector bool long long __a, vector unsigned long long __b) {
return ~(__a & __b); return ~(__a & __b);
} }
static __inline__ vector bool long long __ATTRS_o_ai static __inline__ vector bool long long __ATTRS_o_ai
vec_nand(vector bool long long __a, vector bool long long __b) { vec_nand(vector bool long long __a, vector bool long long __b) {
return ~(__a & __b); return ~(__a & __b);
} }
static __inline__ vector double __ATTRS_o_ai
vec_nand(vector double __a, vector double __b) {
return (vector double)(~((vector unsigned long long)__a &
(vector unsigned long long)__b));
}
#endif #endif
/* vec_nmadd */ /* vec_nmadd */
#ifdef __VSX__ #ifdef __VSX__
static __inline__ vector float __ATTRS_o_ai vec_nmadd(vector float __a, static __inline__ vector float __ATTRS_o_ai vec_nmadd(vector float __a,
vector float __b, vector float __b,
vector float __c) { vector float __c) {
▲ Show 20 Lines • Show All 455 Lines • ▼ Show 20 Linesvec_orc(vector bool int __a, vector unsigned int __b) {
return __a | ~__b; return __a | ~__b;
} }
static __inline__ vector bool int __ATTRS_o_ai vec_orc(vector bool int __a, static __inline__ vector bool int __ATTRS_o_ai vec_orc(vector bool int __a,
vector bool int __b) { vector bool int __b) {
return __a | ~__b; return __a | ~__b;
} }
static __inline__ vector float __ATTRS_o_ai
vec_orc(vector bool int __a, vector float __b) {
return (vector float)(__a | ~(vector unsigned int)__b);
}
static __inline__ vector float __ATTRS_o_ai
vec_orc(vector float __a, vector bool int __b) {
return (vector float)((vector unsigned int)__a | ~__b);
}
static __inline__ vector signed long long __ATTRS_o_ai static __inline__ vector signed long long __ATTRS_o_ai
vec_orc(vector signed long long __a, vector signed long long __b) { vec_orc(vector signed long long __a, vector signed long long __b) {
return __a | ~__b; return __a | ~__b;
} }
static __inline__ vector signed long long __ATTRS_o_ai static __inline__ vector signed long long __ATTRS_o_ai
vec_orc(vector signed long long __a, vector bool long long __b) { vec_orc(vector signed long long __a, vector bool long long __b) {
return __a | ~__b; return __a | ~__b;
Show All 18 Lines
vec_orc(vector bool long long __a, vector unsigned long long __b) { vec_orc(vector bool long long __a, vector unsigned long long __b) {
return __a | ~__b; return __a | ~__b;
} }
static __inline__ vector bool long long __ATTRS_o_ai static __inline__ vector bool long long __ATTRS_o_ai
vec_orc(vector bool long long __a, vector bool long long __b) { vec_orc(vector bool long long __a, vector bool long long __b) {
return __a | ~__b; return __a | ~__b;
} }
static __inline__ vector double __ATTRS_o_ai
vec_orc(vector double __a, vector bool long long __b) {
return (vector double)((vector unsigned long long)__a | ~__b);
}
static __inline__ vector double __ATTRS_o_ai
vec_orc(vector bool long long __a, vector double __b) {
return (vector double)(__a | ~(vector unsigned long long)__b);
}
#endif #endif
/* vec_vor */ /* vec_vor */
static __inline__ vector signed char __ATTRS_o_ai static __inline__ vector signed char __ATTRS_o_ai
vec_vor(vector signed char __a, vector signed char __b) { vec_vor(vector signed char __a, vector signed char __b) {
return __a | __b; return __a | __b;
} }
▲ Show 20 Lines • Show All 9,219 Lines • Show Last 20 Lines

test/CodeGen/builtins-ppc-p8vector.c

Show First 20 Lines • Show All 1,260 Lines • ▼ Show 20 Lines
// CHECK-LE: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1> // CHECK-LE: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1>
res_vui = vec_nand(vui, vui); res_vui = vec_nand(vui, vui);
// CHECK: [[T1:%.+]] = and <4 x i32> // CHECK: [[T1:%.+]] = and <4 x i32>
// CHECK: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1> // CHECK: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1>
// CHECK-LE: [[T1:%.+]] = and <4 x i32> // CHECK-LE: [[T1:%.+]] = and <4 x i32>
// CHECK-LE: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1> // CHECK-LE: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1>
res_vf = vec_nand(vfa, vfa);
// CHECK: [[T1:%.+]] = and <4 x i32>
// CHECK: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1>
// CHECK-LE: [[T1:%.+]] = and <4 x i32>
// CHECK-LE: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1>
res_vsll = vec_nand(vsll, vsll); res_vsll = vec_nand(vsll, vsll);
// CHECK: [[T1:%.+]] = and <2 x i64> // CHECK: [[T1:%.+]] = and <2 x i64>
// CHECK: xor <2 x i64> [[T1]], <i64 -1, i64 -1> // CHECK: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
// CHECK-LE: [[T1:%.+]] = and <2 x i64> // CHECK-LE: [[T1:%.+]] = and <2 x i64>
// CHECK-LE: xor <2 x i64> [[T1]], <i64 -1, i64 -1> // CHECK-LE: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
res_vsll = vec_nand(vbll, vbll); res_vsll = vec_nand(vbll, vbll);
// CHECK: [[T1:%.+]] = and <2 x i64> // CHECK: [[T1:%.+]] = and <2 x i64>
// CHECK: xor <2 x i64> [[T1]], <i64 -1, i64 -1> // CHECK: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
// CHECK-LE: [[T1:%.+]] = and <2 x i64> // CHECK-LE: [[T1:%.+]] = and <2 x i64>
// CHECK-LE: xor <2 x i64> [[T1]], <i64 -1, i64 -1> // CHECK-LE: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
res_vull = vec_nand(vull, vull); res_vull = vec_nand(vull, vull);
// CHECK: [[T1:%.+]] = and <2 x i64> // CHECK: [[T1:%.+]] = and <2 x i64>
// CHECK: xor <2 x i64> [[T1]], <i64 -1, i64 -1> // CHECK: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
// CHECK-LE: [[T1:%.+]] = and <2 x i64> // CHECK-LE: [[T1:%.+]] = and <2 x i64>
// CHECK-LE: xor <2 x i64> [[T1]], <i64 -1, i64 -1> // CHECK-LE: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
res_vd = vec_nand(vda, vda);
// CHECK: [[T1:%.+]] = and <2 x i64>
// CHECK: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
// CHECK-LE: [[T1:%.+]] = and <2 x i64>
// CHECK-LE: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
/* vec_orc */ /* vec_orc */
res_vsc = vec_orc(vsc, vsc); res_vsc = vec_orc(vsc, vsc);
// CHECK: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1> // CHECK: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
// CHECK: or <16 x i8> {{%.+}}, [[T1]] // CHECK: or <16 x i8> {{%.+}}, [[T1]]
// CHECK-LE: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1> // CHECK-LE: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
// CHECK-LE: or <16 x i8> {{%.+}}, [[T1]] // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]]
// CHECK-PPC: warning: implicit declaration of function 'vec_orc' is invalid in C99 // CHECK-PPC: warning: implicit declaration of function 'vec_orc' is invalid in C99
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines
// CHECK-LE: or <4 x i32> {{%.+}}, [[T1]] // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]]
res_vbi = vec_orc(vbi, vbi); res_vbi = vec_orc(vbi, vbi);
// CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
// CHECK: or <4 x i32> {{%.+}}, [[T1]] // CHECK: or <4 x i32> {{%.+}}, [[T1]]
// CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
// CHECK-LE: or <4 x i32> {{%.+}}, [[T1]] // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]]
res_vf = vec_orc(vbi, vfa);
// CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
// CHECK: or <4 x i32> {{%.+}}, [[T1]]
// CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
// CHECK-LE: or <4 x i32> {{%.+}}, [[T1]]
res_vf = vec_orc(vfa, vbi);
// CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
// CHECK: or <4 x i32> {{%.+}}, [[T1]]
// CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
// CHECK-LE: or <4 x i32> {{%.+}}, [[T1]]
res_vsll = vec_orc(vsll, vsll); res_vsll = vec_orc(vsll, vsll);
// CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
// CHECK: or <2 x i64> {{%.+}}, [[T1]] // CHECK: or <2 x i64> {{%.+}}, [[T1]]
// CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
// CHECK-LE: or <2 x i64> {{%.+}}, [[T1]] // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]]
res_vsll = vec_orc(vsll, vbll); res_vsll = vec_orc(vsll, vbll);
// CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
Show All 26 Lines
// CHECK-LE: or <2 x i64> {{%.+}}, [[T1]] // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]]
res_vbll = vec_orc(vbll, vbll); res_vbll = vec_orc(vbll, vbll);
// CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
// CHECK: or <2 x i64> {{%.+}}, [[T1]] // CHECK: or <2 x i64> {{%.+}}, [[T1]]
// CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
// CHECK-LE: or <2 x i64> {{%.+}}, [[T1]] // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]]
res_vd = vec_orc(vbll, vda);
// CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
// CHECK: or <2 x i64> {{%.+}}, [[T1]]
// CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
// CHECK-LE: or <2 x i64> {{%.+}}, [[T1]]
res_vd = vec_orc(vda, vbll);
// CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
// CHECK: or <2 x i64> {{%.+}}, [[T1]]
// CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
// CHECK-LE: or <2 x i64> {{%.+}}, [[T1]]
/* vec_sub */ /* vec_sub */
res_vsll = vec_sub(vsll, vsll); res_vsll = vec_sub(vsll, vsll);
// CHECK: sub <2 x i64> // CHECK: sub <2 x i64>
// CHECK-LE: sub <2 x i64> // CHECK-LE: sub <2 x i64>
res_vull = vec_sub(vull, vull); res_vull = vec_sub(vull, vull);
// CHECK: sub <2 x i64> // CHECK: sub <2 x i64>
// CHECK-LE: sub <2 x i64> // CHECK-LE: sub <2 x i64>
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines