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

Merge branch 'master' into nvptx_clean

Browse Source
This commit is contained in:
Evghenii
2014-02-21 12:45:01 +01:00
parent 739e4e73ef 1f2541fbec
commit 42c4d3246c
48 changed files with 1492 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
module.cpp
View File

@@ -2048,9 +2048,6 @@ void
Module::execPreprocessor(const char *infilename, llvm::raw_string_ostream *ostream) const Module::execPreprocessor(const char *infilename, llvm::raw_string_ostream *ostream) const
{ {
clang::CompilerInstance inst; clang::CompilerInstance inst;
#if defined(LLVM_3_5)
inst.createVirtualFileSystem();
#endif
inst.createFileManager(); inst.createFileManager();
llvm::raw_fd_ostream stderrRaw(2, false); llvm::raw_fd_ostream stderrRaw(2, false);

72
opt.cpp
View File

@@ -1335,12 +1335,24 @@ char ImproveMemoryOpsPass::ID = 0;
*/ */
static llvm::Value * static llvm::Value *
lCheckForActualPointer(llvm::Value *v) { lCheckForActualPointer(llvm::Value *v) {
if (v == NULL) if (v == NULL) {
return NULL; return NULL;
else if (llvm::isa<llvm::PointerType>(v->getType())) }
else if (llvm::isa<llvm::PointerType>(v->getType())) {
return v; return v;
else if (llvm::isa<llvm::PtrToIntInst>(v)) }
else if (llvm::isa<llvm::PtrToIntInst>(v)) {
return v; return v;
}
else if (llvm::CastInst *ci = llvm::dyn_cast<llvm::CastInst>(v)) {
llvm::Value *t = lCheckForActualPointer(ci->getOperand(0));
if (t == NULL) {
return NULL;
}
else {
return v;
}
}
else { else {
llvm::ConstantExpr *uce = llvm::ConstantExpr *uce =
llvm::dyn_cast<llvm::ConstantExpr>(v); llvm::dyn_cast<llvm::ConstantExpr>(v);
@@ -1358,7 +1370,7 @@ lCheckForActualPointer(llvm::Value *v) {
pointer value; otherwise it returns NULL. pointer value; otherwise it returns NULL.
*/ */
static llvm::Value * static llvm::Value *
lGetBasePointer(llvm::Value *v) { lGetBasePointer(llvm::Value *v, llvm::Instruction *insertBefore) {
if (llvm::isa<llvm::InsertElementInst>(v) || if (llvm::isa<llvm::InsertElementInst>(v) ||
llvm::isa<llvm::ShuffleVectorInst>(v)) { llvm::isa<llvm::ShuffleVectorInst>(v)) {
llvm::Value *element = LLVMFlattenInsertChain llvm::Value *element = LLVMFlattenInsertChain
@@ -1382,6 +1394,20 @@ lGetBasePointer(llvm::Value *v) {
else if (llvm::ConstantDataVector *cdv = llvm::dyn_cast<llvm::ConstantDataVector>(v)) { else if (llvm::ConstantDataVector *cdv = llvm::dyn_cast<llvm::ConstantDataVector>(v)) {
return lCheckForActualPointer(cdv->getSplatValue()); return lCheckForActualPointer(cdv->getSplatValue());
} }
// It is a little bit tricky to use operations with pointers, casted to int with another bit size
// but sometimes it is useful, so we handle this case here.
else if (llvm::CastInst *ci = llvm::dyn_cast<llvm::CastInst>(v)) {
llvm::Value *t = lGetBasePointer(ci->getOperand(0), insertBefore);
if (t == NULL) {
return NULL;
}
else {
return llvm::CastInst::Create(ci->getOpcode(),
t, ci->getType()->getScalarType(),
LLVMGetName(t, "_cast"),
insertBefore);
}
}
return NULL; return NULL;
} }
@@ -1435,7 +1461,7 @@ lGetBasePtrAndOffsets(llvm::Value *ptrs, llvm::Value **offsets,
LLVMDumpValue(ptrs); LLVMDumpValue(ptrs);
} }
llvm::Value *base = lGetBasePointer(ptrs); llvm::Value *base = lGetBasePointer(ptrs, insertBefore);
if (base != NULL) { if (base != NULL) {
// We have a straight up varying pointer with no indexing that's // We have a straight up varying pointer with no indexing that's
// actually all the same value. // actually all the same value.
@@ -1571,30 +1597,30 @@ lExtractConstantOffset(llvm::Value *vec, llvm::Value **constOffset,
return; return;
} }
llvm::SExtInst *sext = llvm::dyn_cast<llvm::SExtInst>(vec); llvm::CastInst *cast = llvm::dyn_cast<llvm::CastInst>(vec);
if (sext != NULL) { if (cast != NULL) {
// Check the sext target. // Check the cast target.
llvm::Value *co, *vo; llvm::Value *co, *vo;
lExtractConstantOffset(sext->getOperand(0), &co, &vo, insertBefore); lExtractConstantOffset(cast->getOperand(0), &co, &vo, insertBefore);
// make new sext instructions for the two parts // make new cast instructions for the two parts
if (co == NULL) if (co == NULL)
*constOffset = NULL; *constOffset = NULL;
else else
*constOffset = new llvm::SExtInst(co, sext->getType(), *constOffset = llvm::CastInst::Create(cast->getOpcode(),
LLVMGetName(co, "_sext"), co, cast->getType(),
LLVMGetName(co, "_cast"),
insertBefore); insertBefore);
if (vo == NULL) if (vo == NULL)
*variableOffset = NULL; *variableOffset = NULL;
else else
*variableOffset = new llvm::SExtInst(vo, sext->getType(), *variableOffset = llvm::CastInst::Create(cast->getOpcode(),
LLVMGetName(vo, "_sext"), vo, cast->getType(),
LLVMGetName(vo, "_cast"),
insertBefore); insertBefore);
return; return;
} }
// FIXME? handle bitcasts / type casts here
llvm::BinaryOperator *bop = llvm::dyn_cast<llvm::BinaryOperator>(vec); llvm::BinaryOperator *bop = llvm::dyn_cast<llvm::BinaryOperator>(vec);
if (bop != NULL) { if (bop != NULL) {
llvm::Value *op0 = bop->getOperand(0); llvm::Value *op0 = bop->getOperand(0);
@@ -1786,17 +1812,17 @@ lExtract248Scale(llvm::Value *splatOperand, int splatValue,
*/ */
static llvm::Value * static llvm::Value *
lExtractOffsetVector248Scale(llvm::Value **vec) { lExtractOffsetVector248Scale(llvm::Value **vec) {
llvm::SExtInst *sext = llvm::dyn_cast<llvm::SExtInst>(*vec); llvm::CastInst *cast = llvm::dyn_cast<llvm::CastInst>(*vec);
if (sext != NULL) { if (cast != NULL) {
llvm::Value *sextOp = sext->getOperand(0); llvm::Value *castOp = cast->getOperand(0);
// Check the sext target. // Check the cast target.
llvm::Value *scale = lExtractOffsetVector248Scale(&sextOp); llvm::Value *scale = lExtractOffsetVector248Scale(&castOp);
if (scale == NULL) if (scale == NULL)
return NULL; return NULL;
// make a new sext instruction so that we end up with the right // make a new cast instruction so that we end up with the right
// type // type
*vec = new llvm::SExtInst(sextOp, sext->getType(), "offset_sext", sext); *vec = llvm::CastInst::Create(cast->getOpcode(), castOp, cast->getType(), "offset_cast", cast);
return scale; return scale;
} }

338
stdlib.ispc
View File

@@ -4595,6 +4595,42 @@ static inline varying int16 saturating_add(varying int16 a, varying int16 b) {
return __padds_vi16(a, b); return __padds_vi16(a, b);
} }
static inline uniform int32 saturating_add(uniform int32 a, uniform int32 b) {
uniform unsigned int32 a_unsig = a, b_unsig = b;
uniform unsigned int32 result = a_unsig + b_unsig;
a_unsig = (a_unsig >> 31) + INT32_MAX;
if ((uniform int32) ((a_unsig ^ b_unsig) | ~(b_unsig ^ result)) >= 0)
result = a_unsig;
return result;
}
static inline varying int32 saturating_add(varying int32 a, varying int32 b) {
varying unsigned int32 a_unsig = a, b_unsig = b;
varying unsigned int32 result = a_unsig + b_unsig;
a_unsig = (a_unsig >> 31) + INT32_MAX;
if ((varying int32) ((a_unsig ^ b_unsig) | ~(b_unsig ^ result)) >= 0)
result = a_unsig;
return result;
}
static inline uniform int64 saturating_add(uniform int64 a, uniform int64 b) {
uniform unsigned int64 a_unsig = a, b_unsig = b;
uniform unsigned int64 result = a_unsig + b_unsig;
a_unsig = (a_unsig >> 63) + INT64_MAX;
if ((uniform int64) ((a_unsig ^ b_unsig) | ~(b_unsig ^ result)) >= 0)
result = a_unsig;
return result;
}
static inline varying int64 saturating_add(varying int64 a, varying int64 b) {
varying unsigned int64 a_unsig = a, b_unsig = b;
varying unsigned int64 result = a_unsig + b_unsig;
a_unsig = (a_unsig >> 63) + INT64_MAX;
if ((varying int64) ((a_unsig ^ b_unsig) | ~(b_unsig ^ result)) >= 0)
result = a_unsig;
return result;
}
static inline uniform unsigned int8 saturating_add(uniform unsigned int8 a, static inline uniform unsigned int8 saturating_add(uniform unsigned int8 a,
uniform unsigned int8 b) { uniform unsigned int8 b) {
uniform unsigned int8 result = a + b; uniform unsigned int8 result = a + b;
@@ -4619,6 +4655,34 @@ static inline varying unsigned int16 saturating_add(varying unsigned int16 a,
return __paddus_vi16(a, b); return __paddus_vi16(a, b);
} }
static inline uniform unsigned int32 saturating_add(uniform unsigned int32 a,
uniform unsigned int32 b) {
uniform unsigned int32 result = a + b;
result |= (-(uniform int32)(result < a));
return result;
}
static inline varying unsigned int32 saturating_add(varying unsigned int32 a,
varying unsigned int32 b) {
varying unsigned int32 result = a + b;
result |= (-(varying int32)(result < a));
return result;
}
static inline uniform unsigned int64 saturating_add(uniform unsigned int64 a,
uniform unsigned int64 b) {
uniform unsigned int64 result = a + b;
result |= (-(uniform int64)(result < a));
return result;
}
static inline varying unsigned int64 saturating_add(varying unsigned int64 a,
varying unsigned int64 b) {
varying unsigned int64 result = a + b;
result |= (-(varying int64)(result < a));
return result;
}
static inline uniform int8 saturating_sub(uniform int8 a, uniform int8 b) { static inline uniform int8 saturating_sub(uniform int8 a, uniform int8 b) {
uniform unsigned int8 a_unsig = a, b_unsig = b; uniform unsigned int8 a_unsig = a, b_unsig = b;
uniform unsigned int8 result = a_unsig - b_unsig; uniform unsigned int8 result = a_unsig - b_unsig;
@@ -4645,6 +4709,42 @@ static inline varying int16 saturating_sub(varying int16 a, varying int16 b) {
return __psubs_vi16(a, b); return __psubs_vi16(a, b);
} }
static inline uniform int32 saturating_sub(uniform int32 a, uniform int32 b) {
uniform unsigned int32 a_unsig = a, b_unsig = b;
uniform unsigned int32 result = a_unsig - b_unsig;
a_unsig = (a_unsig >> 31) + INT32_MAX;
if ((uniform int32) ((a_unsig ^ b_unsig) & (a_unsig ^ result)) < 0)
result = a_unsig;
return result;
}
static inline varying int32 saturating_sub(varying int32 a, varying int32 b) {
varying unsigned int32 a_unsig = a, b_unsig = b;
varying unsigned int32 result = a_unsig - b_unsig;
a_unsig = (a_unsig >> 31) + INT32_MAX;
if ((varying int32) ((a_unsig ^ b_unsig) & (a_unsig ^ result)) < 0)
result = a_unsig;
return result;
}
static inline uniform int64 saturating_sub(uniform int64 a, uniform int64 b) {
uniform unsigned int64 a_unsig = a, b_unsig = b;
uniform unsigned int64 result = a_unsig - b_unsig;
a_unsig = (a_unsig >> 63) + INT64_MAX;
if ((uniform int64) ((a_unsig ^ b_unsig) & (a_unsig ^ result)) < 0)
result = a_unsig;
return result;
}
static inline varying int64 saturating_sub(varying int64 a, varying int64 b) {
varying unsigned int64 a_unsig = a, b_unsig = b;
varying unsigned int64 result = a_unsig - b_unsig;
a_unsig = (a_unsig >> 63) + INT64_MAX;
if ((varying int64) ((a_unsig ^ b_unsig) & (a_unsig ^ result)) < 0)
result = a_unsig;
return result;
}
static inline uniform unsigned int8 saturating_sub(uniform unsigned int8 a, static inline uniform unsigned int8 saturating_sub(uniform unsigned int8 a,
uniform unsigned int8 b) { uniform unsigned int8 b) {
uniform unsigned int8 result = a - b; uniform unsigned int8 result = a - b;
@@ -4668,6 +4768,244 @@ static inline varying unsigned int16 saturating_sub(varying unsigned int16 a,
varying unsigned int16 b) { varying unsigned int16 b) {
return __psubus_vi16(a, b); return __psubus_vi16(a, b);
} }
static inline uniform unsigned int32 saturating_sub(uniform unsigned int32 a,
uniform unsigned int32 b) {
uniform unsigned int32 result = a - b;
result &= (-(uniform int32)(result <= a));
return result;
}
static inline varying unsigned int32 saturating_sub(varying unsigned int32 a,
varying unsigned int32 b) {
varying unsigned int32 result = a - b;
result &= (-(varying int32)(result <= a));
return result;
}
static inline uniform unsigned int64 saturating_sub(uniform unsigned int64 a,
uniform unsigned int64 b) {
uniform unsigned int64 result = a - b;
result &= (-(uniform int64)(result <= a));
return result;
}
static inline varying unsigned int64 saturating_sub(varying unsigned int64 a,
varying unsigned int64 b) {
varying unsigned int64 result = a - b;
result &= (-(varying int64)(result <= a));
return result;
}
static inline uniform int8 saturating_div(uniform int8 a, uniform int8 b) {
/* Only one way to overflow, so test for and prevent it. */
a += !((b + 1) | ((uniform unsigned int8) a + INT8_MIN));
return a / b;
}
static inline varying int8 saturating_div(varying int8 a, varying int8 b) {
/* Only one way to overflow, so test for and prevent it. */
a += !((b + 1) | ((varying unsigned int8) a + INT8_MIN));
return a / b;
}
static inline uniform int16 saturating_div(uniform int16 a, uniform int16 b) {
/* Only one way to overflow, so test for and prevent it. */
a += !((b + 1) | ((uniform unsigned int16) a + INT16_MIN));
return a / b;
}
static inline varying int16 saturating_div(varying int16 a, varying int16 b) {
/* Only one way to overflow, so test for and prevent it. */
a += !((b + 1) | ((varying unsigned int16) a + INT16_MIN));
return a / b;
}
static inline uniform int32 saturating_div(uniform int32 a, uniform int32 b) {
/* Only one way to overflow, so test for and prevent it. */
a += !((b + 1) | ((uniform unsigned int32) a + INT32_MIN));
return a / b;
}
static inline varying int32 saturating_div(varying int32 a, varying int32 b) {
/* Only one way to overflow, so test for and prevent it. */
a += !((b + 1) | ((varying unsigned int32) a + INT32_MIN));
return a / b;
}
static inline uniform int64 saturating_div(uniform int64 a, uniform int64 b) {
/* Only one way to overflow, so test for and prevent it. */
a += !((b + 1) | ((uniform unsigned int64) a + INT64_MIN));
return a / b;
}
static inline varying int64 saturating_div(varying int64 a, varying int64 b) {
/* Only one way to overflow, so test for and prevent it. */
a += !((b + 1) | ((varying unsigned int64) a + INT64_MIN));
return a / b;
}
static inline uniform unsigned int8 saturating_div(uniform unsigned int8 a,
uniform unsigned int8 b) {
/* No overflow possible */
return a / b;
}
static inline varying unsigned int8 saturating_div(varying unsigned int8 a,
varying unsigned int8 b) {
/* No overflow possible */
return a / b;
}
static inline uniform unsigned int16 saturating_div(uniform unsigned int16 a,
uniform unsigned int16 b) {
/* No overflow possible */
return a / b;
}
static inline varying unsigned int16 saturating_div(varying unsigned int16 a,
varying unsigned int16 b) {
/* No overflow possible */
return a / b;
}
static inline uniform unsigned int32 saturating_div(uniform unsigned int32 a,
uniform unsigned int32 b) {
/* No overflow possible */
return a / b;
}
static inline varying unsigned int32 saturating_div(varying unsigned int32 a,
varying unsigned int32 b) {
/* No overflow possible */
return a / b;
}
static inline uniform unsigned int64 saturating_div(uniform unsigned int64 a,
uniform unsigned int64 b) {
/* No overflow possible */
return a / b;
}
static inline varying unsigned int64 saturating_div(varying unsigned int64 a,
varying unsigned int64 b) {
/* No overflow possible */
return a / b;
}
static inline uniform int8 saturating_mul(uniform int8 a, uniform int8 b) {
uniform int16 result = (uniform int16) a * (uniform int16) b;
uniform unsigned int8 result2 = ((uniform unsigned int8) (a ^ b) >> 7) + INT8_MAX;
uniform int8 hi = result >> 8;
uniform int8 lo = result;
if (hi != (lo >> 7))
result = result2;
return result;
}
static inline varying int8 saturating_mul(varying int8 a, varying int8 b) {
varying int16 result = (varying int16) a * (varying int16) b;
varying unsigned int8 result2 = ((varying unsigned int8) (a ^ b) >> 7) + INT8_MAX;
varying int8 hi = result >> 8;
varying int8 lo = result;
if (hi != (lo >> 7))
result = result2;
return result;
}
static inline uniform int16 saturating_mul(uniform int16 a, uniform int16 b) {
uniform int32 result = (uniform int32) a * (uniform int32) b;
uniform unsigned int16 result2 = ((uniform unsigned int16) (a ^ b) >> 15) + INT16_MAX;
uniform int16 hi = result >> 16;
uniform int16 lo = result;
if (hi != (lo >> 15))
result = result2;
return result;
}
static inline varying int16 saturating_mul(varying int16 a, varying int16 b) {
varying int32 result = (varying int32) a * (varying int32) b;
varying unsigned int16 result2 = ((varying unsigned int16) (a ^ b) >> 15) + INT16_MAX;
varying int16 hi = result >> 16;
varying int16 lo = result;
if (hi != (lo >> 15))
result = result2;
return result;
}
static inline uniform int32 saturating_mul(uniform int32 a, uniform int32 b) {
uniform int64 result = (uniform int64) a * (uniform int64) b;
uniform unsigned int32 result2 = ((uniform unsigned int32) (a ^ b) >> 31) + INT32_MAX;
uniform int32 hi = result >> 32;
uniform int32 lo = result;
if (hi != (lo >> 31))
result = result2;
return result;
}
static inline varying int32 saturating_mul(varying int32 a, varying int32 b) {
varying int64 result = (varying int64) a * (varying int64) b;
varying unsigned int32 result2 = ((varying unsigned int32) (a ^ b) >> 31) + INT32_MAX;
varying int32 hi = result >> 32;
varying int32 lo = result;
if (hi != (lo >> 31))
result = result2;
return result;
}
static inline uniform unsigned int8 saturating_mul(uniform unsigned int8 a,
uniform unsigned int8 b) {
uniform unsigned int16 result = (uniform unsigned int16) a *
(uniform unsigned int16) b;
uniform unsigned int8 hi = result >> 8;
uniform unsigned int8 lo = result;
return lo | - (uniform int8) !! hi;
}
static inline varying unsigned int8 saturating_mul(varying unsigned int8 a,
varying unsigned int8 b) {
varying unsigned int16 result = (varying unsigned int16) a *
(varying unsigned int16) b;
varying unsigned int8 hi = result >> 8;
varying unsigned int8 lo = result;
return lo | - (varying int8) !! hi;
}
static inline uniform unsigned int16 saturating_mul(uniform unsigned int16 a,
uniform unsigned int16 b) {
uniform unsigned int32 result = (uniform unsigned int32) a *
(uniform unsigned int32) b;
uniform unsigned int16 hi = result >> 16;
uniform unsigned int16 lo = result;
return lo | - (uniform int16) !! hi;
}
static inline varying unsigned int16 saturating_mul(varying unsigned int16 a,
varying unsigned int16 b) {
varying unsigned int32 result = (varying unsigned int32) a *
(varying unsigned int32) b;
varying unsigned int16 hi = result >> 16;
varying unsigned int16 lo = result;
return lo | - (varying int16) !! hi;
}
static inline uniform unsigned int32 saturating_mul(uniform unsigned int32 a,
uniform unsigned int32 b) {
uniform unsigned int64 result = (uniform unsigned int64) a *
(uniform unsigned int64) b;
uniform unsigned int32 hi = result >> 32;
uniform unsigned int32 lo = result;
return lo | - (uniform int32) !! hi;
}
static inline varying unsigned int32 saturating_mul(varying unsigned int32 a,
varying unsigned int32 b) {
varying unsigned int64 result = (varying unsigned int64) a *
(varying unsigned int64) b;
varying unsigned int32 hi = result >> 32;
varying unsigned int32 lo = result;
return lo | - (varying int32) !! hi;
}
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// rdrand // rdrand

27
tests/padds_i32.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_add(a_max, b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_add(a_min, -b);
}
else {
RET[programIndex] = saturating_add(a_min, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform int32) -0x80000000; // min signed int32
}
else {
RET[programIndex] = (uniform int32) -0x7FFFFFFB; // min + 5
}
}

27
tests/padds_i64.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_add(a_max, b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_add(a_min, -b);
}
else {
RET[programIndex] = saturating_add(a_min, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform int64) -0x8000000000000000; // min signed int64
}
else {
RET[programIndex] = (uniform int64) -0x7FFFFFFFFFFFFFFB; // min + 5
}
}

27
tests/padds_vi32.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_add(a_max, b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_add(a_min, -b);
}
else {
RET[programIndex] = saturating_add(a_min, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying int32) -0x80000000; // min signed int32
}
else {
RET[programIndex] = (varying int32) -0x7FFFFFFB; // min + 5
}
}

27
tests/padds_vi64.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_add(a_max, b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_add(a_min, -b);
}
else {
RET[programIndex] = saturating_add(a_min, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying int64) -0x8000000000000000; // min signed int64
}
else {
RET[programIndex] = (varying int64) -0x7FFFFFFFFFFFFFFB; // min + 5
}
}

21
tests/paddus_i32.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_add(a_max, b);
}
else {
RET[programIndex] = saturating_add(a_min, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (uniform unsigned int32) 0xFFFFFFFF; // max unsigned int32
}
else {
RET[programIndex] = (uniform unsigned int32) 5;
}
}

21
tests/paddus_i64.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_add(a_max, b);
}
else {
RET[programIndex] = saturating_add(a_min, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (uniform unsigned int64) 0xFFFFFFFFFFFFFFFF; // max unsigned int64
}
else {
RET[programIndex] = (uniform unsigned int64) 5;
}
}

21
tests/paddus_vi32.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_add(a_max, b);
}
else {
RET[programIndex] = saturating_add(a_min, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (varying unsigned int32) 0xFFFFFFFF; // max unsigned int32
}
else {
RET[programIndex] = (varying unsigned int32) 5;
}
}

21
tests/paddus_vi64.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_add(a_max, b);
}
else {
RET[programIndex] = saturating_add(a_min, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (varying unsigned int64) 0xFFFFFFFFFFFFFFFF; // max unsigned int64
}
else {
RET[programIndex] = (varying unsigned int64) 5;
}
}

27
tests/pdivs_i16.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int16 a_max = 0x7FFF, a_min = -0x8000; // max and min signed int16
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_div(a_max, (uniform int16) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_div(a_min, (uniform int16) b);
}
else {
RET[programIndex] = saturating_div(a_min, (uniform int16) -1);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform int16) 6553.4; // max / 5
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform int16) -6553.6; // min / 5
}
else {
RET[programIndex] = (uniform int16) 0x7FFF; // max signed int16
}
}

27
tests/pdivs_i32.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_div(a_max, (uniform int32) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_div(a_min, (uniform int32) b);
}
else {
RET[programIndex] = saturating_div(a_min, (uniform int32) -1);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform int32) 429496729.4; // max / 5
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform int32) -429496729.6; // min / 5
}
else {
RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32
}
}

27
tests/pdivs_i64.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_div(a_max, (uniform int64) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_div(a_min, (uniform int64) b);
}
else {
RET[programIndex] = saturating_div(a_min, (uniform int64) -1);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform int64) 1844674407370955161.4; // max / 5
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform int64) -1844674407370955161.6; // min / 5
}
else {
RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
}
}

27
tests/pdivs_i8.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int8 a_max = 0x7F, a_min = -0x80; // max and min signed int8
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_div(a_max, (uniform int8) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_div(a_min, (uniform int8) b);
}
else {
RET[programIndex] = saturating_div(a_min, (uniform int8) -1);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform int8) 25.4; // max / 5
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform int8) -25.6; // min / 5
}
else {
RET[programIndex] = (uniform int8) 0x7F; // max signed int8
}
}

27
tests/pdivs_vi16.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying int16 a_max = 0x7FFF, a_min = -0x8000; // max and min signed int16
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_div(a_max, (varying int16) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_div(a_min, (varying int16) b);
}
else {
RET[programIndex] = saturating_div(a_min, (varying int16) -1);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying int16) 6553.4; // max / 5
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying int16) -6553.6; // min / 5
}
else {
RET[programIndex] = (varying int16) 0x7FFF; // max signed int16
}
}

27
tests/pdivs_vi32.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_div(a_max, (varying int32) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_div(a_min, (varying int32) b);
}
else {
RET[programIndex] = saturating_div(a_min, (varying int32) -1);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying int32) 429496729.4; // max / 5
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying int32) -429496729.6; // min / 5
}
else {
RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32
}
}

27
tests/pdivs_vi64.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_div(a_max, (varying int64) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_div(a_min, (varying int64) b);
}
else {
RET[programIndex] = saturating_div(a_min, (varying int64) -1);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying int64) 1844674407370955161.4; // max / 5
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying int64) -1844674407370955161.6; // min / 5
}
else {
RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
}
}

27
tests/pdivs_vi8.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying int8 a_max = 0x7F, a_min = -0x80; // max and min signed int8
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_div(a_max, (varying int8) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_div(a_min, (varying int8) b);
}
else {
RET[programIndex] = saturating_div(a_min, (varying int8) -1);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying int8) 25.4; // max / 5
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying int8) -25.6; // min / 5
}
else {
RET[programIndex] = (varying int8) 0x7F; // max signed int8
}
}

21
tests/pdivus_i16.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int16 a_max = 0xFFFF, a_min = 0; // max and min unsigned int16
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_div(a_min, (uniform unsigned int16) b);
}
else {
RET[programIndex] = saturating_div(a_max, (uniform unsigned int16) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (uniform unsigned int16) 0; // min unsigned int16
}
else {
RET[programIndex] = (uniform unsigned int16) 0x3333; // max unsigned int16 / 5
}
}

21
tests/pdivus_i32.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_div(a_min, (uniform unsigned int32) b);
}
else {
RET[programIndex] = saturating_div(a_max, (uniform unsigned int32) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (uniform unsigned int32) 0; // min unsigned int32
}
else {
RET[programIndex] = (uniform unsigned int32) 0x33333333; // max unsigned int32 / 5
}
}

21
tests/pdivus_i64.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_div(a_min, (uniform unsigned int64) b);
}
else {
RET[programIndex] = saturating_div(a_max, (uniform unsigned int64) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (uniform unsigned int64) 0; // min unsigned int64
}
else {
RET[programIndex] = (uniform unsigned int64) 0x3333333333333333; // max unsigned int64 / 5
}
}

21
tests/pdivus_i8.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int8 a_max = 0xFF, a_min = 0; // max and min unsigned int8
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_div(a_min, (uniform unsigned int8) b);
}
else {
RET[programIndex] = saturating_div(a_max, (uniform unsigned int8) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (uniform unsigned int8) 0; // min unsigned int8
}
else {
RET[programIndex] = (uniform unsigned int8) 0x33; // max unsigned int8 / 5
}
}

21
tests/pdivus_vi16.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying unsigned int16 a_max = 0xFFFF, a_min = 0; // max and min unsigned int16
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_div(a_min, (varying unsigned int16) b);
}
else {
RET[programIndex] = saturating_div(a_max, (varying unsigned int16) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (varying unsigned int16) 0; // min unsigned int16
}
else {
RET[programIndex] = (varying unsigned int16) 0x3333; // max unsigned int16 / 5
}
}

21
tests/pdivus_vi32.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_div(a_min, (varying unsigned int32) b);
}
else {
RET[programIndex] = saturating_div(a_max, (varying unsigned int32) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (varying unsigned int32) 0; // min unsigned int32
}
else {
RET[programIndex] = (varying unsigned int32) 0x33333333; // max unsigned int32 / 5
}
}

21
tests/pdivus_vi64.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_div(a_min, (varying unsigned int64) b);
}
else {
RET[programIndex] = saturating_div(a_max, (varying unsigned int64) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (varying unsigned int64) 0; // min unsigned int64
}
else {
RET[programIndex] = (varying unsigned int64) 0x3333333333333333; // max unsigned int64 / 5
}
}

21
tests/pdivus_vi8.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying unsigned int8 a_max = 0xFF, a_min = 0; // max and min unsigned int8
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_div(a_min, (varying unsigned int8) b);
}
else {
RET[programIndex] = saturating_div(a_max, (varying unsigned int8) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (varying unsigned int8) 0; // min unsigned int8
}
else {
RET[programIndex] = (varying unsigned int8) 0x33; // max unsigned int8 / 5
}
}

28
tests/pmuls_i16.ispc Normal file
View File

@@ -0,0 +1,28 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int16 a_max = 0x7FFF, a_min = -0x8000; // max and min signed int16
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_mul(a_max, (uniform int16) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_mul(a_min, (uniform int16) b);
}
else {
RET[programIndex] = saturating_mul((uniform int16) b,
(uniform int16) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform int16) 0x7FFF; // max signed int16
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform int16) -0x8000; // min signed int16
}
else {
RET[programIndex] = (uniform int16) 25;
}
}

28
tests/pmuls_i32.ispc Normal file
View File

@@ -0,0 +1,28 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_mul(a_max, (uniform int32) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_mul(a_min, (uniform int32) b);
}
else {
RET[programIndex] = saturating_mul((uniform int32) b,
(uniform int32) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform int32) -0x80000000; // min signed int32
}
else {
RET[programIndex] = (uniform int32) 25;
}
}

28
tests/pmuls_i8.ispc Normal file
View File

@@ -0,0 +1,28 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int8 a_max = 0x7F, a_min = -0x80; // max and min signed int8
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_mul(a_max, (uniform int8) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_mul(a_min, (uniform int8) b);
}
else {
RET[programIndex] = saturating_mul((uniform int8) b,
(uniform int8) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform int8) 0x7F; // max signed int8
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform int8) -0x80; // min signed int8
}
else {
RET[programIndex] = (uniform int8) 25;
}
}

28
tests/pmuls_vi16.ispc Normal file
View File

@@ -0,0 +1,28 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying int16 a_max = 0x7FFF, a_min = -0x8000; // max and min signed int16
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_mul(a_max, (varying int16) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_mul(a_min, (varying int16) b);
}
else {
RET[programIndex] = saturating_mul((varying int16) b,
(varying int16) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying int16) 0x7FFF; // max signed int16
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying int16) -0x8000; // min signed int16
}
else {
RET[programIndex] = (varying int16) 25;
}
}

28
tests/pmuls_vi32.ispc Normal file
View File

@@ -0,0 +1,28 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_mul(a_max, (varying int32) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_mul(a_min, (varying int32) b);
}
else {
RET[programIndex] = saturating_mul((varying int32) b,
(varying int32) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying int32) -0x80000000; // min signed int32
}
else {
RET[programIndex] = (varying int32) 25;
}
}

28
tests/pmuls_vi8.ispc Normal file
View File

@@ -0,0 +1,28 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying int8 a_max = 0x7F, a_min = -0x80; // max and min signed int8
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_mul(a_max, (varying int8) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_mul(a_min, (varying int8) b);
}
else {
RET[programIndex] = saturating_mul((varying int8) b,
(varying int8) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying int8) 0x7F; // max signed int8
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying int8) -0x80; // min signed int8
}
else {
RET[programIndex] = (varying int8) 25;
}
}

28
tests/pmulus_i16.ispc Normal file
View File

@@ -0,0 +1,28 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int16 a_max = 0xFFFF, a_min = 0; // max and min unsigned int16
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_mul(a_max, (uniform unsigned int16) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_mul(a_min, (uniform unsigned int16) -b);
}
else {
RET[programIndex] = saturating_mul((uniform unsigned int16) b,
(uniform unsigned int16) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform unsigned int16) 0xFFFF; // max unsigned int16
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform unsigned int16) 0; // min unsigned int16
}
else {
RET[programIndex] = (uniform unsigned int16) 25;
}
}

28
tests/pmulus_i32.ispc Normal file
View File

@@ -0,0 +1,28 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_mul(a_max, (uniform unsigned int32) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_mul(a_min, (uniform unsigned int32) -b);
}
else {
RET[programIndex] = saturating_mul((uniform unsigned int32) b,
(uniform unsigned int32) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform unsigned int32) 0xFFFFFFFF; // max unsigned int32
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform unsigned int32) 0; // min unsigned int32
}
else {
RET[programIndex] = (uniform unsigned int32) 25;
}
}

28
tests/pmulus_i8.ispc Normal file
View File

@@ -0,0 +1,28 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int8 a_max = 0xFF, a_min = 0; // max and min unsigned int8
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_mul(a_max, (uniform unsigned int8) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_mul(a_min, (uniform unsigned int8) -b);
}
else {
RET[programIndex] = saturating_mul((uniform unsigned int8) b,
(uniform unsigned int8) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform unsigned int8) 0xFF; // max unsigned int8
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform unsigned int8) 0; // min unsigned int8
}
else {
RET[programIndex] = (uniform unsigned int8) 25;
}
}

28
tests/pmulus_vi16.ispc Normal file
View File

@@ -0,0 +1,28 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying unsigned int16 a_max = 0xFFFF, a_min = 0; // max and min unsigned int16
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_mul(a_max, (varying unsigned int16) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_mul(a_min, (varying unsigned int16) -b);
}
else {
RET[programIndex] = saturating_mul((varying unsigned int16) b,
(varying unsigned int16) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying unsigned int16) 0xFFFF; // max unsigned int16
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying unsigned int16) 0; // min unsigned int16
}
else {
RET[programIndex] = (varying unsigned int16) 25;
}
}

28
tests/pmulus_vi32.ispc Normal file
View File

@@ -0,0 +1,28 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_mul(a_max, (varying unsigned int32) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_mul(a_min, (varying unsigned int32) -b);
}
else {
RET[programIndex] = saturating_mul((varying unsigned int32) b,
(varying unsigned int32) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying unsigned int32) 0xFFFFFFFF; // max unsigned int32
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying unsigned int32) 0; // min unsigned int32
}
else {
RET[programIndex] = (varying unsigned int32) 25;
}
}

28
tests/pmulus_vi8.ispc Normal file
View File

@@ -0,0 +1,28 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying unsigned int8 a_max = 0xFF, a_min = 0; // max and min unsigned int8
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_mul(a_max, (varying unsigned int8) b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_mul(a_min, (varying unsigned int8) -b);
}
else {
RET[programIndex] = saturating_mul((varying unsigned int8) b,
(varying unsigned int8) b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying unsigned int8) 0xFF; // max unsigned int8
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying unsigned int8) 0; // min unsigned int8
}
else {
RET[programIndex] = (varying unsigned int8) 25;
}
}

27
tests/psubs_i32.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min int32
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_sub(a_min, b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_sub(a_max, -b);
}
else {
RET[programIndex] = saturating_sub(a_max, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform int32) -0x80000000; // min signed int32
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32
}
else {
RET[programIndex] = (uniform int32) 0x7FFFFFFA;
}
}

27
tests/psubs_i64.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min int64
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_sub(a_min, b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_sub(a_max, -b);
}
else {
RET[programIndex] = saturating_sub(a_max, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (uniform int64) -0x8000000000000000; // min signed int64
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
}
else {
RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFA;
}
}

27
tests/psubs_vi32.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min int32
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_sub(a_min, b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_sub(a_max, -b);
}
else {
RET[programIndex] = saturating_sub(a_max, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying int32) -0x80000000; // min signed int32
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32
}
else {
RET[programIndex] = (varying int32) 0x7FFFFFFA;
}
}

27
tests/psubs_vi64.ispc Normal file
View File

@@ -0,0 +1,27 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min int64
if (programIndex % 3 == 0) {
RET[programIndex] = saturating_sub(a_min, b);
}
else if (programIndex % 3 == 1) {
RET[programIndex] = saturating_sub(a_max, -b);
}
else {
RET[programIndex] = saturating_sub(a_max, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 3 == 0) {
RET[programIndex] = (varying int64) -0x8000000000000000; // min signed int64
}
else if (programIndex % 3 == 1) {
RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
}
else {
RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFA;
}
}

21
tests/psubus_i32.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_sub(a_min, b);
}
else {
RET[programIndex] = saturating_sub(a_max, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (uniform unsigned int32) 0; // min unsigned int32
}
else {
RET[programIndex] = (uniform unsigned int32) 0xFFFFFFFB; // max unsigned int32 - 5
}
}

21
tests/psubus_i64.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_sub(a_min, b);
}
else {
RET[programIndex] = saturating_sub(a_max, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (uniform unsigned int64) 0; // min unsigned int64
}
else {
RET[programIndex] = (uniform unsigned int64) 0xFFFFFFFFFFFFFFFB; // max unsigned int64 - 5
}
}

21
tests/psubus_vi32.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_sub(a_min, b);
}
else {
RET[programIndex] = saturating_sub(a_max, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (varying unsigned int32) 0; // min unsigned int32
}
else {
RET[programIndex] = (varying unsigned int32) 0xFFFFFFFB; // max unsigned int32 - 5
}
}

21
tests/psubus_vi64.ispc Normal file
View File

@@ -0,0 +1,21 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
varying unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
if (programIndex % 2 == 0) {
RET[programIndex] = saturating_sub(a_min, b);
}
else {
RET[programIndex] = saturating_sub(a_max, b);
}
}
export void result(uniform float RET[]) {
if (programIndex % 2 == 0) {
RET[programIndex] = (varying unsigned int64) 0; // min unsigned int64
}
else {
RET[programIndex] = (varying unsigned int64) 0xFFFFFFFFFFFFFFFB; // max unsigned int64 - 5
}
}

2
tests/ptr-int-1.ispc
View File

@@ -5,7 +5,7 @@ export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) { export void f_f(uniform float RET[], uniform float aFOO[]) {
uniform int a = 1; uniform int a = 1;
uniform int * uniform b = &a; uniform int * uniform b = &a;
int64 pi = (int64)b; uintptr_t pi = (uintptr_t)b;
RET[programIndex] = *((uniform int * varying)pi); RET[programIndex] = *((uniform int * varying)pi);
} }