lp_bld_type.h revision c61bf363937f40624a5632745630d4f2b9907082
1/************************************************************************** 2 * 3 * Copyright 2009 VMware, Inc. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR 22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27 28/** 29 * @file 30 * Convenient representation of SIMD types. 31 * 32 * @author Jose Fonseca <jfonseca@vmware.com> 33 */ 34 35 36#ifndef LP_BLD_TYPE_H 37#define LP_BLD_TYPE_H 38 39 40#include <llvm-c/Core.h> 41 42#include <pipe/p_compiler.h> 43 44 45/** 46 * Native SIMD register width. 47 * 48 * 128 for all architectures we care about. 49 */ 50#define LP_NATIVE_VECTOR_WIDTH 128 51 52/** 53 * Several functions can only cope with vectors of length up to this value. 54 * You may need to increase that value if you want to represent bigger vectors. 55 */ 56#define LP_MAX_VECTOR_LENGTH 16 57 58 59/** 60 * The LLVM type system can't conveniently express all the things we care about 61 * on the types used for intermediate computations, such as signed vs unsigned, 62 * normalized values, or fixed point. 63 */ 64struct lp_type { 65 /** 66 * Floating-point. Cannot be used with fixed. Integer numbers are 67 * represented by this zero. 68 */ 69 unsigned floating:1; 70 71 /** 72 * Fixed-point. Cannot be used with floating. Integer numbers are 73 * represented by this zero. 74 */ 75 unsigned fixed:1; 76 77 /** 78 * Whether it can represent negative values or not. 79 * 80 * If this is not set for floating point, it means that all values are 81 * assumed to be positive. 82 */ 83 unsigned sign:1; 84 85 /** 86 * Whether values are normalized to fit [0, 1] interval, or [-1, 1] 87 * interval for signed types. 88 * 89 * For integer types it means the representable integer range should be 90 * interpreted as the interval above. 91 * 92 * For floating and fixed point formats it means the values should be 93 * clamped to the interval above. 94 */ 95 unsigned norm:1; 96 97 /** 98 * Element width. 99 * 100 * For fixed point values, the fixed point is assumed to be at half the 101 * width. 102 */ 103 unsigned width:14; 104 105 /** 106 * Vector length. 107 * 108 * width*length should be a power of two greater or equal to eight. 109 * 110 * @sa LP_MAX_VECTOR_LENGTH 111 */ 112 unsigned length:14; 113}; 114 115 116/** 117 * We need most of the information here in order to correctly and efficiently 118 * translate an arithmetic operation into LLVM IR. Putting it here avoids the 119 * trouble of passing it as parameters. 120 */ 121struct lp_build_context 122{ 123 LLVMBuilderRef builder; 124 125 /** 126 * This not only describes the input/output LLVM types, but also whether 127 * to normalize/clamp the results. 128 */ 129 struct lp_type type; 130 131 /** Same as lp_build_undef(type) */ 132 LLVMValueRef undef; 133 134 /** Same as lp_build_zero(type) */ 135 LLVMValueRef zero; 136 137 /** Same as lp_build_one(type) */ 138 LLVMValueRef one; 139}; 140 141 142static INLINE struct lp_type 143lp_type_float(unsigned width) 144{ 145 struct lp_type res_type; 146 147 memset(&res_type, 0, sizeof res_type); 148 res_type.floating = TRUE; 149 res_type.sign = TRUE; 150 res_type.width = width; 151 res_type.length = LP_NATIVE_VECTOR_WIDTH / width; 152 153 return res_type; 154} 155 156 157static INLINE struct lp_type 158lp_type_int(unsigned width) 159{ 160 struct lp_type res_type; 161 162 memset(&res_type, 0, sizeof res_type); 163 res_type.sign = TRUE; 164 res_type.width = width; 165 res_type.length = LP_NATIVE_VECTOR_WIDTH / width; 166 167 return res_type; 168} 169 170 171static INLINE struct lp_type 172lp_type_uint(unsigned width) 173{ 174 struct lp_type res_type; 175 176 memset(&res_type, 0, sizeof res_type); 177 res_type.width = width; 178 res_type.length = LP_NATIVE_VECTOR_WIDTH / width; 179 180 return res_type; 181} 182 183 184static INLINE struct lp_type 185lp_type_unorm(unsigned width) 186{ 187 struct lp_type res_type; 188 189 memset(&res_type, 0, sizeof res_type); 190 res_type.norm = TRUE; 191 res_type.width = width; 192 res_type.length = LP_NATIVE_VECTOR_WIDTH / width; 193 194 return res_type; 195} 196 197 198static INLINE struct lp_type 199lp_type_fixed(unsigned width) 200{ 201 struct lp_type res_type; 202 203 memset(&res_type, 0, sizeof res_type); 204 res_type.sign = TRUE; 205 res_type.fixed = TRUE; 206 res_type.width = width; 207 res_type.length = LP_NATIVE_VECTOR_WIDTH / width; 208 209 return res_type; 210} 211 212 213static INLINE struct lp_type 214lp_type_ufixed(unsigned width) 215{ 216 struct lp_type res_type; 217 218 memset(&res_type, 0, sizeof res_type); 219 res_type.fixed = TRUE; 220 res_type.width = width; 221 res_type.length = LP_NATIVE_VECTOR_WIDTH / width; 222 223 return res_type; 224} 225 226 227LLVMTypeRef 228lp_build_elem_type(struct lp_type type); 229 230 231LLVMTypeRef 232lp_build_vec_type(struct lp_type type); 233 234 235boolean 236lp_check_elem_type(struct lp_type type, LLVMTypeRef elem_type); 237 238 239boolean 240lp_check_vec_type(struct lp_type type, LLVMTypeRef vec_type); 241 242 243boolean 244lp_check_value(struct lp_type type, LLVMValueRef val); 245 246 247LLVMTypeRef 248lp_build_int_elem_type(struct lp_type type); 249 250 251LLVMTypeRef 252lp_build_int_vec_type(struct lp_type type); 253 254 255LLVMTypeRef 256lp_build_int32_vec4_type(void); 257 258 259struct lp_type 260lp_int_type(struct lp_type type); 261 262 263struct lp_type 264lp_wider_type(struct lp_type type); 265 266 267void 268lp_build_context_init(struct lp_build_context *bld, 269 LLVMBuilderRef builder, 270 struct lp_type type); 271 272 273#endif /* !LP_BLD_TYPE_H */ 274