0,0 → 1,453 |
/************************************************************************** |
* |
* Copyright 2009 VMware, Inc. |
* All Rights Reserved. |
* |
* Permission is hereby granted, free of charge, to any person obtaining a |
* copy of this software and associated documentation files (the |
* "Software"), to deal in the Software without restriction, including |
* without limitation the rights to use, copy, modify, merge, publish, |
* distribute, sub license, and/or sell copies of the Software, and to |
* permit persons to whom the Software is furnished to do so, subject to |
* the following conditions: |
* |
* The above copyright notice and this permission notice (including the |
* next paragraph) shall be included in all copies or substantial portions |
* of the Software. |
* |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. |
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR |
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
* |
**************************************************************************/ |
|
/** |
* @file |
* Convenient representation of SIMD types. |
* |
* @author Jose Fonseca <jfonseca@vmware.com> |
*/ |
|
|
#ifndef LP_BLD_TYPE_H |
#define LP_BLD_TYPE_H |
|
|
#include "util/u_format.h" |
#include "pipe/p_compiler.h" |
#include "gallivm/lp_bld.h" |
|
/** |
* Native SIMD architecture width available at runtime. |
* |
* Using this width should give the best performance, |
* and it determines the necessary alignment of vector variables. |
*/ |
extern unsigned lp_native_vector_width; |
|
/** |
* Maximum supported vector width (not necessarily supported at run-time). |
* |
* Should only be used when lp_native_vector_width isn't available, |
* i.e. sizing/alignment of non-malloced variables. |
*/ |
#define LP_MAX_VECTOR_WIDTH 256 |
|
/** |
* Minimum vector alignment for static variable alignment |
* |
* It should always be a constant equal to LP_MAX_VECTOR_WIDTH/8. An |
* expression is non-portable. |
*/ |
#define LP_MIN_VECTOR_ALIGN 32 |
|
/** |
* Several functions can only cope with vectors of length up to this value. |
* You may need to increase that value if you want to represent bigger vectors. |
*/ |
#define LP_MAX_VECTOR_LENGTH (LP_MAX_VECTOR_WIDTH/8) |
|
/** |
* The LLVM type system can't conveniently express all the things we care about |
* on the types used for intermediate computations, such as signed vs unsigned, |
* normalized values, or fixed point. |
*/ |
struct lp_type { |
/** |
* Floating-point. Cannot be used with fixed. Integer numbers are |
* represented by this zero. |
*/ |
unsigned floating:1; |
|
/** |
* Fixed-point. Cannot be used with floating. Integer numbers are |
* represented by this zero. |
*/ |
unsigned fixed:1; |
|
/** |
* Whether it can represent negative values or not. |
* |
* If this is not set for floating point, it means that all values are |
* assumed to be positive. |
*/ |
unsigned sign:1; |
|
/** |
* Whether values are normalized to fit [0, 1] interval, or [-1, 1] |
* interval for signed types. |
* |
* For integer types it means the representable integer range should be |
* interpreted as the interval above. |
* |
* For floating and fixed point formats it means the values should be |
* clamped to the interval above. |
*/ |
unsigned norm:1; |
|
/** |
* Element width. |
* |
* For fixed point values, the fixed point is assumed to be at half the |
* width. |
*/ |
unsigned width:14; |
|
/** |
* Vector length. If length==1, this is a scalar (float/int) type. |
* |
* width*length should be a power of two greater or equal to eight. |
* |
* @sa LP_MAX_VECTOR_LENGTH |
*/ |
unsigned length:14; |
}; |
|
|
/** |
* We need most of the information here in order to correctly and efficiently |
* translate an arithmetic operation into LLVM IR. Putting it here avoids the |
* trouble of passing it as parameters. |
*/ |
struct lp_build_context |
{ |
struct gallivm_state *gallivm; |
|
/** |
* This not only describes the input/output LLVM types, but also whether |
* to normalize/clamp the results. |
*/ |
struct lp_type type; |
|
/** Same as lp_build_elem_type(type) */ |
LLVMTypeRef elem_type; |
|
/** Same as lp_build_vec_type(type) */ |
LLVMTypeRef vec_type; |
|
/** Same as lp_build_int_elem_type(type) */ |
LLVMTypeRef int_elem_type; |
|
/** Same as lp_build_int_vec_type(type) */ |
LLVMTypeRef int_vec_type; |
|
/** Same as lp_build_undef(type) */ |
LLVMValueRef undef; |
|
/** Same as lp_build_zero(type) */ |
LLVMValueRef zero; |
|
/** Same as lp_build_one(type) */ |
LLVMValueRef one; |
}; |
|
|
/** |
* Converts a format description into an lp_type. |
* |
* Only works with "array formats". |
* |
* e.g. With PIPE_FORMAT_R32G32B32A32_FLOAT returns an lp_type with float[4] |
*/ |
static INLINE void |
lp_type_from_format_desc(struct lp_type* type, const struct util_format_description *format_desc) |
{ |
assert(format_desc->is_array); |
assert(!format_desc->is_mixed); |
|
memset(type, 0, sizeof(struct lp_type)); |
type->floating = format_desc->channel[0].type == UTIL_FORMAT_TYPE_FLOAT; |
type->fixed = format_desc->channel[0].type == UTIL_FORMAT_TYPE_FIXED; |
type->sign = format_desc->channel[0].type != UTIL_FORMAT_TYPE_UNSIGNED; |
type->norm = format_desc->channel[0].normalized; |
type->width = format_desc->channel[0].size; |
type->length = format_desc->nr_channels; |
} |
|
|
static INLINE void |
lp_type_from_format(struct lp_type* type, enum pipe_format format) |
{ |
lp_type_from_format_desc(type, util_format_description(format)); |
} |
|
|
static INLINE unsigned |
lp_type_width(struct lp_type type) |
{ |
return type.width * type.length; |
} |
|
|
/** Create scalar float type */ |
static INLINE struct lp_type |
lp_type_float(unsigned width) |
{ |
struct lp_type res_type; |
|
memset(&res_type, 0, sizeof res_type); |
res_type.floating = TRUE; |
res_type.sign = TRUE; |
res_type.width = width; |
res_type.length = 1; |
|
return res_type; |
} |
|
|
/** Create vector of float type */ |
static INLINE struct lp_type |
lp_type_float_vec(unsigned width, unsigned total_width) |
{ |
struct lp_type res_type; |
|
memset(&res_type, 0, sizeof res_type); |
res_type.floating = TRUE; |
res_type.sign = TRUE; |
res_type.width = width; |
res_type.length = total_width / width; |
|
return res_type; |
} |
|
|
/** Create scalar int type */ |
static INLINE struct lp_type |
lp_type_int(unsigned width) |
{ |
struct lp_type res_type; |
|
memset(&res_type, 0, sizeof res_type); |
res_type.sign = TRUE; |
res_type.width = width; |
res_type.length = 1; |
|
return res_type; |
} |
|
|
/** Create vector int type */ |
static INLINE struct lp_type |
lp_type_int_vec(unsigned width, unsigned total_width) |
{ |
struct lp_type res_type; |
|
memset(&res_type, 0, sizeof res_type); |
res_type.sign = TRUE; |
res_type.width = width; |
res_type.length = total_width / width; |
|
return res_type; |
} |
|
|
/** Create scalar uint type */ |
static INLINE struct lp_type |
lp_type_uint(unsigned width) |
{ |
struct lp_type res_type; |
|
memset(&res_type, 0, sizeof res_type); |
res_type.width = width; |
res_type.length = 1; |
|
return res_type; |
} |
|
|
/** Create vector uint type */ |
static INLINE struct lp_type |
lp_type_uint_vec(unsigned width, unsigned total_width) |
{ |
struct lp_type res_type; |
|
memset(&res_type, 0, sizeof res_type); |
res_type.width = width; |
res_type.length = total_width / width; |
|
return res_type; |
} |
|
|
static INLINE struct lp_type |
lp_type_unorm(unsigned width, unsigned total_width) |
{ |
struct lp_type res_type; |
|
memset(&res_type, 0, sizeof res_type); |
res_type.norm = TRUE; |
res_type.width = width; |
res_type.length = total_width / width; |
|
return res_type; |
} |
|
|
static INLINE struct lp_type |
lp_type_fixed(unsigned width, unsigned total_width) |
{ |
struct lp_type res_type; |
|
memset(&res_type, 0, sizeof res_type); |
res_type.sign = TRUE; |
res_type.fixed = TRUE; |
res_type.width = width; |
res_type.length = total_width / width; |
|
return res_type; |
} |
|
|
static INLINE struct lp_type |
lp_type_ufixed(unsigned width, unsigned total_width) |
{ |
struct lp_type res_type; |
|
memset(&res_type, 0, sizeof res_type); |
res_type.fixed = TRUE; |
res_type.width = width; |
res_type.length = total_width / width; |
|
return res_type; |
} |
|
|
LLVMTypeRef |
lp_build_elem_type(struct gallivm_state *gallivm, struct lp_type type); |
|
|
LLVMTypeRef |
lp_build_vec_type(struct gallivm_state *gallivm, struct lp_type type); |
|
|
boolean |
lp_check_elem_type(struct lp_type type, LLVMTypeRef elem_type); |
|
|
boolean |
lp_check_vec_type(struct lp_type type, LLVMTypeRef vec_type); |
|
|
boolean |
lp_check_value(struct lp_type type, LLVMValueRef val); |
|
|
LLVMTypeRef |
lp_build_int_elem_type(struct gallivm_state *gallivm, struct lp_type type); |
|
|
LLVMTypeRef |
lp_build_int_vec_type(struct gallivm_state *gallivm, struct lp_type type); |
|
|
static INLINE struct lp_type |
lp_float32_vec4_type(void) |
{ |
struct lp_type type; |
|
memset(&type, 0, sizeof(type)); |
type.floating = TRUE; |
type.sign = TRUE; |
type.norm = FALSE; |
type.width = 32; |
type.length = 4; |
|
return type; |
} |
|
|
static INLINE struct lp_type |
lp_int32_vec4_type(void) |
{ |
struct lp_type type; |
|
memset(&type, 0, sizeof(type)); |
type.floating = FALSE; |
type.sign = TRUE; |
type.norm = FALSE; |
type.width = 32; |
type.length = 4; |
|
return type; |
} |
|
|
static INLINE struct lp_type |
lp_unorm8_vec4_type(void) |
{ |
struct lp_type type; |
|
memset(&type, 0, sizeof(type)); |
type.floating = FALSE; |
type.sign = FALSE; |
type.norm = TRUE; |
type.width = 8; |
type.length = 4; |
|
return type; |
} |
|
|
struct lp_type |
lp_elem_type(struct lp_type type); |
|
|
struct lp_type |
lp_uint_type(struct lp_type type); |
|
|
struct lp_type |
lp_int_type(struct lp_type type); |
|
|
struct lp_type |
lp_wider_type(struct lp_type type); |
|
|
unsigned |
lp_sizeof_llvm_type(LLVMTypeRef t); |
|
|
const char * |
lp_typekind_name(LLVMTypeKind t); |
|
|
void |
lp_dump_llvmtype(LLVMTypeRef t); |
|
|
void |
lp_build_context_init(struct lp_build_context *bld, |
struct gallivm_state *gallivm, |
struct lp_type type); |
|
|
unsigned |
lp_build_count_ir_module(LLVMModuleRef module); |
|
|
#endif /* !LP_BLD_TYPE_H */ |