src/gallium/auxiliary/gallivm/lp_bld_type.h

   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  */
  64 struct 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  */
 121 struct 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
 142 static INLINE struct lp_type
 143 lp_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
 157 static INLINE struct lp_type
 158 lp_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
 171 static INLINE struct lp_type
 172 lp_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
 184 static INLINE struct lp_type
 185 lp_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
 198 static INLINE struct lp_type
 199 lp_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
 213 static INLINE struct lp_type
 214 lp_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
 227 LLVMTypeRef
 228 lp_build_elem_type(struct lp_type type);
 229
 230
 231 LLVMTypeRef
 232 lp_build_vec_type(struct lp_type type);
 233
 234
 235 boolean
 236 lp_check_elem_type(struct lp_type type, LLVMTypeRef elem_type);
 237
 238
 239 boolean
 240 lp_check_vec_type(struct lp_type type, LLVMTypeRef vec_type);
 241
 242
 243 boolean
 244 lp_check_value(struct lp_type type, LLVMValueRef val);
 245
 246
 247 LLVMTypeRef
 248 lp_build_int_elem_type(struct lp_type type);
 249
 250
 251 LLVMTypeRef
 252 lp_build_int_vec_type(struct lp_type type);
 253
 254
 255 LLVMTypeRef
 256 lp_build_int32_vec4_type(void);
 257
 258
 259 struct lp_type
 260 lp_uint_type(struct lp_type type);
 261
 262
 263 struct lp_type
 264 lp_int_type(struct lp_type type);
 265
 266
 267 struct lp_type
 268 lp_wider_type(struct lp_type type);
 269
 270
 271 void
 272 lp_build_context_init(struct lp_build_context *bld,
 273                       LLVMBuilderRef builder,
 274                       struct lp_type type);
 275
 276
 277 #endif /* !LP_BLD_TYPE_H */