#include <float.h>
#include "util/u_debug.h"
+#include "util/u_math.h"
+#include "util/u_half.h"
#include "lp_bld_type.h"
#include "lp_bld_const.h"
if(type.floating) {
switch(type.width) {
+ case 16:
+ return 10;
case 32:
return 23;
case 64:
- return 53;
+ return 52;
default:
assert(0);
return 0;
if (type.floating) {
switch(type.width) {
+ case 16:
+ return -65504;
case 32:
return -FLT_MAX;
case 64:
if (type.floating) {
switch(type.width) {
+ case 16:
+ return 65504;
case 32:
return FLT_MAX;
case 64:
{
if (type.floating) {
switch(type.width) {
+ case 16:
+ return 2E-10;
case 32:
return FLT_EPSILON;
case 64:
elem_type = lp_build_elem_type(gallivm, type);
- if(type.floating)
+ if(type.floating && type.width == 16)
+ elems[0] = LLVMConstInt(elem_type, util_float_to_half(1.0f), 0);
+ else if(type.floating)
elems[0] = LLVMConstReal(elem_type, 1.0);
else if(type.fixed)
elems[0] = LLVMConstInt(elem_type, 1LL << (type.width/2), 0);
else {
/* special case' -- 1.0 for normalized types is more easily attained if
* we start with a vector consisting of all bits set */
- LLVMTypeRef vec_type = LLVMVectorType(elem_type, type.length);
+ LLVMTypeRef vec_type = lp_build_vec_type(gallivm, type);
LLVMValueRef vec = LLVMConstAllOnes(vec_type);
#if 0
LLVMTypeRef elem_type = lp_build_elem_type(gallivm, type);
LLVMValueRef elem;
- if(type.floating) {
+ if(type.floating && type.width == 16) {
+ elem = LLVMConstInt(elem_type, util_float_to_half((float)val), 0);
+ } else if(type.floating) {
elem = LLVMConstReal(elem_type, val);
}
else {
double dscale = lp_const_scale(type);
- elem = LLVMConstInt(elem_type, val*dscale + 0.5, 0);
+ elem = LLVMConstInt(elem_type, round(val*dscale), 0);
}
return elem;
const unsigned char *swizzle)
{
const unsigned char default_swizzle[4] = {0, 1, 2, 3};
- LLVMTypeRef elem_type;
LLVMValueRef elems[LP_MAX_VECTOR_LENGTH];
unsigned i;
assert(type.length % 4 == 0);
assert(type.length <= LP_MAX_VECTOR_LENGTH);
- elem_type = lp_build_elem_type(gallivm, type);
+ lp_build_elem_type(gallivm, type);
if(swizzle == NULL)
swizzle = default_swizzle;
- if(type.floating) {
- elems[swizzle[0]] = LLVMConstReal(elem_type, r);
- elems[swizzle[1]] = LLVMConstReal(elem_type, g);
- elems[swizzle[2]] = LLVMConstReal(elem_type, b);
- elems[swizzle[3]] = LLVMConstReal(elem_type, a);
- }
- else {
- double dscale = lp_const_scale(type);
-
- elems[swizzle[0]] = LLVMConstInt(elem_type, r*dscale + 0.5, 0);
- elems[swizzle[1]] = LLVMConstInt(elem_type, g*dscale + 0.5, 0);
- elems[swizzle[2]] = LLVMConstInt(elem_type, b*dscale + 0.5, 0);
- elems[swizzle[3]] = LLVMConstInt(elem_type, a*dscale + 0.5, 0);
- }
+ elems[swizzle[0]] = lp_build_const_elem(gallivm, type, r);
+ elems[swizzle[1]] = lp_build_const_elem(gallivm, type, g);
+ elems[swizzle[2]] = lp_build_const_elem(gallivm, type, b);
+ elems[swizzle[3]] = lp_build_const_elem(gallivm, type, a);
for(i = 4; i < type.length; ++i)
elems[i] = elems[i % 4];
LLVMValueRef
lp_build_const_mask_aos(struct gallivm_state *gallivm,
struct lp_type type,
- unsigned mask)
+ unsigned mask,
+ unsigned channels)
{
LLVMTypeRef elem_type = LLVMIntTypeInContext(gallivm->context, type.width);
LLVMValueRef masks[LP_MAX_VECTOR_LENGTH];
assert(type.length <= LP_MAX_VECTOR_LENGTH);
- for (j = 0; j < type.length; j += 4) {
- for( i = 0; i < 4; ++i) {
+ for (j = 0; j < type.length; j += channels) {
+ for( i = 0; i < channels; ++i) {
masks[j + i] = LLVMConstInt(elem_type,
mask & (1 << i) ? ~0ULL : 0,
1);
*/
LLVMValueRef
lp_build_const_mask_aos_swizzled(struct gallivm_state *gallivm,
- struct lp_type type,
- unsigned mask,
- const unsigned char *swizzle)
+ struct lp_type type,
+ unsigned mask,
+ unsigned channels,
+ const unsigned char *swizzle)
{
- mask =
- ((mask & (1 << swizzle[0])) >> swizzle[0])
- | (((mask & (1 << swizzle[1])) >> swizzle[1]) << 1)
- | (((mask & (1 << swizzle[2])) >> swizzle[2]) << 2)
- | (((mask & (1 << swizzle[3])) >> swizzle[3]) << 3);
+ unsigned i, mask_swizzled;
+ mask_swizzled = 0;
+
+ for (i = 0; i < channels; ++i) {
+ if (swizzle[i] < 4) {
+ mask_swizzled |= ((mask & (1 << swizzle[i])) >> swizzle[i]) << i;
+ }
+ }
- return lp_build_const_mask_aos(gallivm, type, mask);
+ return lp_build_const_mask_aos(gallivm, type, mask_swizzled, channels);
}
/**
* Build a callable function pointer.
*
- * We this casts instead of LLVMAddGlobalMapping()
+ * We use function pointer constants instead of LLVMAddGlobalMapping()
* to work around a bug in LLVM 2.6, and for efficiency/simplicity.
*/
LLVMValueRef