aaron/ispc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Some fixes in function names and more tests was added.

Browse Source
This commit is contained in:
Vsevolod Livinskij
2013-12-22 19:28:26 +04:00
parent 9a135c48d9
commit 07c6f1714a
44 changed files with 215 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
builtins/target-avx-common.ll
View File

@@ -40,7 +40,7 @@ ctlztz()
define_prefetches()
define_shuffles()
aossoa()
saturation_arithmetic_scalar()
saturation_arithmetic_uniform()
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; rounding floats

2
builtins/target-avx-x2.ll
View File

@@ -40,7 +40,7 @@ stdlib_core()
packed_load_and_store()
scans()
int64minmax()
saturation_arithmetic_vec16()
saturation_arithmetic()
include(`target-avx-common.ll')

2
builtins/target-avx1-i64x4base.ll
View File

@@ -40,7 +40,7 @@ stdlib_core()
packed_load_and_store()
scans()
int64minmax()
saturation_arithmetic_vec4()
saturation_arithmetic()
include(`target-avx-common.ll')

2
builtins/target-avx1.ll
View File

@@ -32,7 +32,7 @@
include(`target-avx.ll')
rdrand_decls()
saturation_arithmetic_vec8()
saturation_arithmetic()
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; int min/max

3
builtins/target-avx11.ll
View File

@@ -34,7 +34,8 @@ include(`target-avx.ll')
ifelse(LLVM_VERSION, `LLVM_3_0', `rdrand_decls()',
LLVM_VERSION, `LLVM_3_1', `rdrand_decls()',
`rdrand_definition()')
saturation_arithmetic_vec8()
saturation_arithmetic()
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; int min/max

3
builtins/target-avx2.ll
View File

@@ -38,7 +38,8 @@ include(`target-avx.ll')
ifelse(LLVM_VERSION, `LLVM_3_0', `rdrand_decls()',
LLVM_VERSION, `LLVM_3_1', `rdrand_decls()',
`rdrand_definition()')
saturation_arithmetic_vec8()
saturation_arithmetic()
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; int min/max

2
builtins/target-generic-1.ll
View File

@@ -9,7 +9,7 @@ packed_load_and_store()
scans()
int64minmax()
aossoa()
saturation_arithmetic_scalar()
saturation_arithmetic()
saturation_arithmetic_novec()
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

2
builtins/target-generic-16.ll
View File

@@ -31,4 +31,4 @@
define(`WIDTH',`16')
include(`target-generic-common.ll')
saturation_arithmetic_vec16()
saturation_arithmetic()

2
builtins/target-generic-4.ll
View File

@@ -31,4 +31,4 @@
define(`WIDTH',`4')
include(`target-generic-common.ll')
saturation_arithmetic_vec4()
saturation_arithmetic()

2
builtins/target-generic-8.ll
View File

@@ -31,4 +31,4 @@
define(`WIDTH',`8')
include(`target-generic-common.ll')
saturation_arithmetic_vec8()
saturation_arithmetic()

2
builtins/target-generic-common.ll
View File

@@ -41,7 +41,7 @@ stdlib_core()
scans()
reduce_equal(WIDTH)
rdrand_decls()
saturation_arithmetic_scalar()
saturation_arithmetic_uniform()
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; broadcast/rotate/shuffle

2
builtins/target-sse2-common.ll
View File

@@ -34,7 +34,7 @@ define_prefetches()
define_shuffles()
aossoa()
rdrand_decls()
saturation_arithmetic_scalar()
saturation_arithmetic_uniform()
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; rcp

2
builtins/target-sse2-x2.ll
View File

@@ -44,7 +44,7 @@ stdlib_core()
packed_load_and_store()
scans()
int64minmax()
saturation_arithmetic_vec8()
saturation_arithmetic()
include(`target-sse2-common.ll')

2
builtins/target-sse2.ll
View File

@@ -41,7 +41,7 @@ stdlib_core()
packed_load_and_store()
scans()
int64minmax()
saturation_arithmetic_vec4()
saturation_arithmetic()
include(`target-sse2-common.ll')

2
builtins/target-sse4-16.ll
View File

@@ -41,7 +41,7 @@ stdlib_core()
packed_load_and_store()
scans()
int64minmax()
saturation_arithmetic_vec8()
saturation_arithmetic()
include(`target-sse4-common.ll')

2
builtins/target-sse4-8.ll
View File

@@ -41,7 +41,7 @@ stdlib_core()
packed_load_and_store()
scans()
int64minmax()
saturation_arithmetic_vec16()
saturation_arithmetic()
include(`target-sse4-common.ll')

2
builtins/target-sse4-common.ll
View File

@@ -37,7 +37,7 @@ define_prefetches()
define_shuffles()
aossoa()
rdrand_decls()
saturation_arithmetic_scalar()
saturation_arithmetic_uniform()
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; rounding floats

2
builtins/target-sse4-x2.ll
View File

@@ -44,7 +44,7 @@ stdlib_core()
packed_load_and_store()
scans()
int64minmax()
saturation_arithmetic_vec8()
saturation_arithmetic()
include(`target-sse4-common.ll')

2
builtins/target-sse4.ll
View File

@@ -41,7 +41,7 @@ stdlib_core()
packed_load_and_store()
scans()
int64minmax()
saturation_arithmetic_vec4()
saturation_arithmetic()
include(`target-sse4-common.ll')

123
builtins/util.m4
View File

@@ -180,9 +180,16 @@ define(`convert32to16', `
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;saturation arithmetic
;;scalar saturation arithmetic
define(`saturation_arithmetic_scalar', `
define(`saturation_arithmetic',
`ifelse(WIDTH, `4', `saturation_arithmetic_vec4()',
WIDTH, `8', `saturation_arithmetic_vec8()',
WIDTH, `16', `saturation_arithmetic_vec16()',
`saturation_arithmetic_uniform()')')
;;uniform saturation arithmetic
define(`saturation_arithmetic_uniform', `
declare <16 x i8> @llvm.x86.sse2.padds.b(<16 x i8>, <16 x i8>) nounwind readnone
define i8 @__padds_i8(i8 %a0, i8 %a1) {
sse_binary_scalar(ret, 16, i8, @llvm.x86.sse2.padds.b, %a0, %a1)
@@ -303,168 +310,168 @@ define <WIDTH x i16> @__psubus_vi16(<WIDTH x i16>, <WIDTH x i16>) {
;;4-wide vector saturation arithmetic
define(`saturation_arithmetic_vec4', `
define <WIDTH x i8> @__padds_vi8(<WIDTH x i8>, <WIDTH x i8>) {
define <4 x i8> @__padds_vi8(<4 x i8>, <4 x i8>) {
convert4to16(i8, %0, %v0)
convert4to16(i8, %1, %v1)
%r16 = call <16 x i8> @llvm.x86.sse2.padds.b(<16 x i8> %v0, <16 x i8> %v1)
convert16to4(i8, %r16, %r)
ret <WIDTH x i8> %r
ret <4 x i8> %r
}
define <WIDTH x i16> @__padds_vi16(<WIDTH x i16>, <WIDTH x i16>) {
define <4 x i16> @__padds_vi16(<4 x i16>, <4 x i16>) {
convert4to8(i16, %0, %v0)
convert4to8(i16, %1, %v1)
%r16 = call <8 x i16> @llvm.x86.sse2.padds.w(<8 x i16> %v0, <8 x i16> %v1)
convert8to4(i16, %r16, %r)
ret <WIDTH x i16> %r
ret <4 x i16> %r
}
define <WIDTH x i8> @__paddus_vi8(<WIDTH x i8>, <WIDTH x i8>) {
define <4 x i8> @__paddus_vi8(<4 x i8>, <4 x i8>) {
convert4to16(i8, %0, %v0)
convert4to16(i8, %1, %v1)
%r16 = call <16 x i8> @llvm.x86.sse2.paddus.b(<16 x i8> %v0, <16 x i8> %v1)
convert16to4(i8, %r16, %r)
ret <WIDTH x i8> %r
ret <4 x i8> %r
}
define <WIDTH x i16> @__paddus_vi16(<WIDTH x i16>, <WIDTH x i16>) {
define <4 x i16> @__paddus_vi16(<4 x i16>, <4 x i16>) {
convert4to8(i16, %0, %v0)
convert4to8(i16, %1, %v1)
%r16 = call <8 x i16> @llvm.x86.sse2.paddus.w(<8 x i16> %v0, <8 x i16> %v1)
convert8to4(i16, %r16, %r)
ret <WIDTH x i16> %r
ret <4 x i16> %r
}
define <WIDTH x i8> @__psubs_vi8(<WIDTH x i8>, <WIDTH x i8>) {
define <4 x i8> @__psubs_vi8(<4 x i8>, <4 x i8>) {
convert4to16(i8, %0, %v0)
convert4to16(i8, %1, %v1)
%r16 = call <16 x i8> @llvm.x86.sse2.psubs.b(<16 x i8> %v0, <16 x i8> %v1)
convert16to4(i8, %r16, %r)
ret <WIDTH x i8> %r
ret <4 x i8> %r
}
define <WIDTH x i16> @__psubs_vi16(<WIDTH x i16>, <WIDTH x i16>) {
define <4 x i16> @__psubs_vi16(<4 x i16>, <4 x i16>) {
convert4to8(i16, %0, %v0)
convert4to8(i16, %1, %v1)
%r16 = call <8 x i16> @llvm.x86.sse2.psubs.w(<8 x i16> %v0, <8 x i16> %v1)
convert8to4(i16, %r16, %r)
ret <WIDTH x i16> %r
ret <4 x i16> %r
}
define <WIDTH x i8> @__psubus_vi8(<WIDTH x i8>, <WIDTH x i8>) {
define <4 x i8> @__psubus_vi8(<4 x i8>, <4 x i8>) {
convert4to16(i8, %0, %v0)
convert4to16(i8, %1, %v1)
%r16 = call <16 x i8> @llvm.x86.sse2.psubus.b(<16 x i8> %v0, <16 x i8> %v1)
convert16to4(i8, %r16, %r)
ret <WIDTH x i8> %r
ret <4 x i8> %r
}
define <WIDTH x i16> @__psubus_vi16(<WIDTH x i16>, <WIDTH x i16>) {
define <4 x i16> @__psubus_vi16(<4 x i16>, <4 x i16>) {
convert4to8(i16, %0, %v0)
convert4to8(i16, %1, %v1)
%r16 = call <8 x i16> @llvm.x86.sse2.psubus.w(<8 x i16> %v0, <8 x i16> %v1)
convert8to4(i16, %r16, %r)
ret <WIDTH x i16> %r
ret <4 x i16> %r
}
')
;;8-wide vector saturation arithmetic
define(`saturation_arithmetic_vec8', `
define <WIDTH x i8> @__padds_vi8(<WIDTH x i8>, <WIDTH x i8>) {
define <8 x i8> @__padds_vi8(<8 x i8>, <8 x i8>) {
convert8to16(i8, %0, %v0)
convert8to16(i8, %1, %v1)
%r16 = call <16 x i8> @llvm.x86.sse2.padds.b(<16 x i8> %v0, <16 x i8> %v1)
convert16to8(i8, %r16, %r)
ret <WIDTH x i8> %r
ret <8 x i8> %r
}
define <WIDTH x i16> @__padds_vi16(<WIDTH x i16> %a0, <WIDTH x i16> %a1) {
%res = call <WIDTH x i16> @llvm.x86.sse2.padds.w(<WIDTH x i16> %a0, <WIDTH x i16> %a1)
ret <WIDTH x i16> %res
define <8 x i16> @__padds_vi16(<8 x i16> %a0, <8 x i16> %a1) {
%res = call <8 x i16> @llvm.x86.sse2.padds.w(<8 x i16> %a0, <8 x i16> %a1)
ret <8 x i16> %res
}
define <WIDTH x i8> @__paddus_vi8(<WIDTH x i8>, <WIDTH x i8>) {
define <8 x i8> @__paddus_vi8(<8 x i8>, <8 x i8>) {
convert8to16(i8, %0, %v0)
convert8to16(i8, %1, %v1)
%r16 = call <16 x i8> @llvm.x86.sse2.paddus.b(<16 x i8> %v0, <16 x i8> %v1)
convert16to8(i8, %r16, %r)
ret <WIDTH x i8> %r
ret <8 x i8> %r
}
define <WIDTH x i16> @__paddus_vi16(<WIDTH x i16> %a0, <WIDTH x i16> %a1) {
%res = call <WIDTH x i16> @llvm.x86.sse2.paddus.w(<WIDTH x i16> %a0, <WIDTH x i16> %a1)
ret <WIDTH x i16> %res
define <8 x i16> @__paddus_vi16(<8 x i16> %a0, <8 x i16> %a1) {
%res = call <8 x i16> @llvm.x86.sse2.paddus.w(<8 x i16> %a0, <8 x i16> %a1)
ret <8 x i16> %res
}
define <WIDTH x i8> @__psubs_vi8(<WIDTH x i8>, <WIDTH x i8>) {
define <8 x i8> @__psubs_vi8(<8 x i8>, <8 x i8>) {
convert8to16(i8, %0, %v0)
convert8to16(i8, %1, %v1)
%r16 = call <16 x i8> @llvm.x86.sse2.psubs.b(<16 x i8> %v0, <16 x i8> %v1)
convert16to8(i8, %r16, %r)
ret <WIDTH x i8> %r
ret <8 x i8> %r
}
define <WIDTH x i16> @__psubs_vi16(<WIDTH x i16> %a0, <WIDTH x i16> %a1) {
%res = call <WIDTH x i16> @llvm.x86.sse2.psubs.w(<WIDTH x i16> %a0, <WIDTH x i16> %a1)
ret <WIDTH x i16> %res
define <8 x i16> @__psubs_vi16(<8 x i16> %a0, <8 x i16> %a1) {
%res = call <8 x i16> @llvm.x86.sse2.psubs.w(<8 x i16> %a0, <8 x i16> %a1)
ret <8 x i16> %res
}
define <WIDTH x i8> @__psubus_vi8(<WIDTH x i8>, <WIDTH x i8>) {
define <8 x i8> @__psubus_vi8(<8 x i8>, <8 x i8>) {
convert8to16(i8, %0, %v0)
convert8to16(i8, %1, %v1)
%r16 = call <16 x i8> @llvm.x86.sse2.psubus.b(<16 x i8> %v0, <16 x i8> %v1)
convert16to8(i8, %r16, %r)
ret <WIDTH x i8> %r
ret <8 x i8> %r
}
define <WIDTH x i16> @__psubus_vi16(<WIDTH x i16> %a0, <WIDTH x i16> %a1) {
%res = call <WIDTH x i16> @llvm.x86.sse2.psubus.w(<WIDTH x i16> %a0, <WIDTH x i16> %a1)
ret <WIDTH x i16> %res
define <8 x i16> @__psubus_vi16(<8 x i16> %a0, <8 x i16> %a1) {
%res = call <8 x i16> @llvm.x86.sse2.psubus.w(<8 x i16> %a0, <8 x i16> %a1)
ret <8 x i16> %res
}
')
;;16-wide vector saturation arithmetic
define(`saturation_arithmetic_vec16', `
define <WIDTH x i8> @__padds_vi8(<WIDTH x i8> %a0, <WIDTH x i8> %a1) {
%res = call <WIDTH x i8> @llvm.x86.sse2.padds.b(<WIDTH x i8> %a0, <WIDTH x i8> %a1) ; <<16 x i8>> [#uses=1]
ret <WIDTH x i8> %res
define <16 x i8> @__padds_vi8(<16 x i8> %a0, <16 x i8> %a1) {
%res = call <16 x i8> @llvm.x86.sse2.padds.b(<16 x i8> %a0, <16 x i8> %a1) ; <<16 x i8>> [#uses=1]
ret <16 x i8> %res
}
define <WIDTH x i16> @__padds_vi16(<WIDTH x i16> %a0, <WIDTH x i16> %a1) {
define <16 x i16> @__padds_vi16(<16 x i16> %a0, <16 x i16> %a1) {
binary8to16(ret, i16, @llvm.x86.sse2.padds.w, %a0, %a1)
ret <WIDTH x i16> %ret
ret <16 x i16> %ret
}
define <WIDTH x i8> @__paddus_vi8(<WIDTH x i8> %a0, <WIDTH x i8> %a1) {
%res = call <WIDTH x i8> @llvm.x86.sse2.paddus.b(<WIDTH x i8> %a0, <WIDTH x i8> %a1) ; <<16 x i8>> [#uses=1]
ret <WIDTH x i8> %res
define <16 x i8> @__paddus_vi8(<16 x i8> %a0, <16 x i8> %a1) {
%res = call <16 x i8> @llvm.x86.sse2.paddus.b(<16 x i8> %a0, <16 x i8> %a1) ; <<16 x i8>> [#uses=1]
ret <16 x i8> %res
}
define <WIDTH x i16> @__paddus_vi16(<WIDTH x i16> %a0, <WIDTH x i16> %a1) {
define <16 x i16> @__paddus_vi16(<16 x i16> %a0, <16 x i16> %a1) {
binary8to16(ret, i16, @llvm.x86.sse2.paddus.w, %a0, %a1)
ret <WIDTH x i16> %ret
ret <16 x i16> %ret
}
define <WIDTH x i8> @__psubs_vi8(<WIDTH x i8> %a0, <WIDTH x i8> %a1) {
%res = call <WIDTH x i8> @llvm.x86.sse2.psubs.b(<WIDTH x i8> %a0, <WIDTH x i8> %a1) ; <<16 x i8>> [#uses=1]
ret <WIDTH x i8> %res
define <16 x i8> @__psubs_vi8(<16 x i8> %a0, <16 x i8> %a1) {
%res = call <16 x i8> @llvm.x86.sse2.psubs.b(<16 x i8> %a0, <16 x i8> %a1) ; <<16 x i8>> [#uses=1]
ret <16 x i8> %res
}
define <WIDTH x i16> @__psubs_vi16(<WIDTH x i16> %a0, <WIDTH x i16> %a1) {
define <16 x i16> @__psubs_vi16(<16 x i16> %a0, <16 x i16> %a1) {
binary8to16(ret, i16, @llvm.x86.sse2.psubs.w, %a0, %a1)
ret <WIDTH x i16> %ret
ret <16 x i16> %ret
}
define <WIDTH x i8> @__psubus_vi8(<WIDTH x i8> %a0, <WIDTH x i8> %a1) {
%res = call <WIDTH x i8> @llvm.x86.sse2.psubus.b(<WIDTH x i8> %a0, <WIDTH x i8> %a1) ; <<16 x i8>> [#uses=1]
ret <WIDTH x i8> %res
define <16 x i8> @__psubus_vi8(<16 x i8> %a0, <16 x i8> %a1) {
%res = call <16 x i8> @llvm.x86.sse2.psubus.b(<16 x i8> %a0, <16 x i8> %a1) ; <<16 x i8>> [#uses=1]
ret <16 x i8> %res
}
define <WIDTH x i16> @__psubus_vi16(<WIDTH x i16> %a0, <WIDTH x i16> %a1) {
define <16 x i16> @__psubus_vi16(<16 x i16> %a0, <16 x i16> %a1) {
binary8to16(ret, i16, @llvm.x86.sse2.psubus.w, %a0, %a1)
ret <WIDTH x i16> %ret
ret <16 x i16> %ret
}
')

11
tests/padds_i16-2.ispc Normal file
View File

@@ -0,0 +1,11 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int16 a = -32768; // min signed int16
RET[programIndex] = saturating_add(a, -b);
}
export void result(uniform float RET[]) {
RET[programIndex] = (uniform int16) -32768;
}

6
tests/padds_i16.ispc
View File

@@ -1,11 +1,11 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
uniform int16 a = 32767, b = 32767; // max signed int16
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int16 a = 32767; // max signed int16
RET[programIndex] = saturating_add(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = 32767;
RET[programIndex] = (uniform int16) 32767;
}

11
tests/padds_i8-2.ispc Normal file
View File

@@ -0,0 +1,11 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int8 a = -128; // min signed int8
RET[programIndex] = saturating_add(a, -b);
}
export void result(uniform float RET[]) {
RET[programIndex] = (uniform int8) -128;
}

6
tests/padds_i8.ispc
View File

@@ -1,11 +1,11 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
uniform int8 a = 127, b = 127; // max signed int8
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int8 a = 127; // max signed int8
RET[programIndex] = saturating_add(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = 127;
RET[programIndex] = (uniform int8) 127;
}

11
tests/padds_vi16-2.ispc Normal file
View File

@@ -0,0 +1,11 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
varying int16 a = -32768, b = aFOO[programIndex]; // max signed int16
RET[programIndex] = saturating_add(a, -b);
}
export void result(uniform float RET[]) {
RET[programIndex] = (varying int16) -32768;
}

4
tests/padds_vi16.ispc
View File

@@ -2,10 +2,10 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
varying int16 a = 32767, b = 32767; // max signed int16
varying int16 a = 32767, b = aFOO[programIndex]; // max signed int16
RET[programIndex] = saturating_add(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = 32767;
RET[programIndex] = (varying int16) 32767;
}

11
tests/padds_vi8-2.ispc Normal file
View File

@@ -0,0 +1,11 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
varying int8 a = -128, b = aFOO[programIndex]; // max signed int8
RET[programIndex] = saturating_add(a, -b);
}
export void result(uniform float RET[]) {
RET[programIndex] = (varying int8) -128;
}

4
tests/padds_vi8.ispc
View File

@@ -2,10 +2,10 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
varying int8 a = 127, b = 127; // max signed int8
varying int8 a = 127, b = aFOO[programIndex]; // max signed int8
RET[programIndex] = saturating_add(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = 127;
RET[programIndex] = (varying int8) 127;
}

6
tests/paddus_i16.ispc
View File

@@ -1,11 +1,11 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
uniform unsigned int16 a = 65535, b = 65535; // max unsigned int16
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int16 a = 65535; // max unsigned int16
RET[programIndex] = saturating_add(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = 65535;
RET[programIndex] = (uniform unsigned int16) 65535;
}

6
tests/paddus_i8.ispc
View File

@@ -1,11 +1,11 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
uniform unsigned int8 a = 255, b = 255; // max unsigned int8
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int8 a = 255; // max unsigned int8
RET[programIndex] = saturating_add(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = 255;
RET[programIndex] = (uniform unsigned int8) 255;
}

4
tests/paddus_vi16.ispc
View File

@@ -2,10 +2,10 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
varying unsigned int16 a = 65535, b = 65535; // max unsigned int16
varying unsigned int16 a = 65535, b = aFOO[programIndex]; // max unsigned int16
RET[programIndex] = saturating_add(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = 65535;
RET[programIndex] = (varying unsigned int16) 65535;
}

4
tests/paddus_vi8.ispc
View File

@@ -2,10 +2,10 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
varying unsigned int8 a = 255, b = 255; // max unsigned int8
varying unsigned int8 a = 255, b = aFOO[programIndex]; // max unsigned int8
RET[programIndex] = saturating_add(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = 255;
RET[programIndex] = (varying unsigned int8) 255;
}

11
tests/psubs_i16-2.ispc Normal file
View File

@@ -0,0 +1,11 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int16 a = 32767; // max signed int16
RET[programIndex] = saturating_sub(a, -b);
}
export void result(uniform float RET[]) {
RET[programIndex] = (uniform int16) 32767;
}

6
tests/psubs_i16.ispc
View File

@@ -1,11 +1,11 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
uniform int16 a = -32768, b = 32767; // min and max signed int16
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int16 a = -32768; // min signed int16
RET[programIndex] = saturating_sub(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = -32768;
RET[programIndex] = (uniform int16) -32768;
}

11
tests/psubs_i8-2.ispc Normal file
View File

@@ -0,0 +1,11 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int8 a = 127; // max signed int8
RET[programIndex] = saturating_sub(a, -b);
}
export void result(uniform float RET[]) {
RET[programIndex] = (uniform int8) 127;
}

6
tests/psubs_i8.ispc
View File

@@ -1,11 +1,11 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
uniform int8 a = -128, b = 127; // min and max signed int8
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int8 a = -128; // min signed int8
RET[programIndex] = saturating_sub(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = -128;
RET[programIndex] = (uniform int8) -128;
}

11
tests/psubs_vi16-2.ispc Normal file
View File

@@ -0,0 +1,11 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
varying int16 a = 32767, b = aFOO[programIndex]; // min unsigned int16
RET[programIndex] = saturating_sub(a, -b);
}
export void result(uniform float RET[]) {
RET[programIndex] = (varying int16) 32767;
}

4
tests/psubs_vi16.ispc
View File

@@ -2,10 +2,10 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
varying int16 a = -32768, b = 32767; // min and max unsigned int16
varying int16 a = -32768, b = aFOO[programIndex]; // min unsigned int16
RET[programIndex] = saturating_sub(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = -32768;
RET[programIndex] = (varying int16) -32768;
}

11
tests/psubs_vi8-2.ispc Normal file
View File

@@ -0,0 +1,11 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
varying int8 a = 127, b = aFOO[programIndex]; // min unsigned int8
RET[programIndex] = saturating_sub(a, -b);
}
export void result(uniform float RET[]) {
RET[programIndex] = (varying int8) 127;
}

4
tests/psubs_vi8.ispc
View File

@@ -2,10 +2,10 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
varying int8 a = -128, b = 127; // min and max unsigned int8
varying int8 a = -128, b = aFOO[programIndex]; // min unsigned int8
RET[programIndex] = saturating_sub(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = -128;
RET[programIndex] = (varying int8) -128;
}

6
tests/psubus_i16.ispc
View File

@@ -1,11 +1,11 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
uniform unsigned int8 a = 0, b = 32767; // min and max unsigned int16
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int8 a = 0; // min unsigned int16
RET[programIndex] = saturating_sub(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = 0;
RET[programIndex] = (uniform unsigned int8) 0;
}

6
tests/psubus_i8.ispc
View File

@@ -1,11 +1,11 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
uniform unsigned int8 a = 0, b = 255; // min and max unsigned int8
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int8 a = 0; // min unsigned int8
RET[programIndex] = saturating_sub(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = 0;
RET[programIndex] = (uniform unsigned int8) 0;
}

4
tests/psubus_vi16.ispc
View File

@@ -2,10 +2,10 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
varying unsigned int16 a = 0, b = 32767; // min and max unsigned int16
varying unsigned int16 a = 0, b = aFOO[programIndex]; // min unsigned int16
RET[programIndex] = saturating_sub(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = 0;
RET[programIndex] = (varying unsigned int16) 0;
}

4
tests/psubus_vi8.ispc
View File

@@ -2,10 +2,10 @@
export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
varying unsigned int8 a = 0, b = 255; // min and max unsigned int8
varying unsigned int8 a = 0, b = aFOO[programIndex]; // min unsigned int8
RET[programIndex] = saturating_sub(a, b);
}
export void result(uniform float RET[]) {
RET[programIndex] = 0;
RET[programIndex] = (varying unsigned int8) 0;
}