src/gallium/auxiliary/gallivm/lp_bld_arit.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  * Helper arithmetic functions.
  31  *
  32  * @author Jose Fonseca <jfonseca@vmware.com>
  33  */
  34
  35
  36 #ifndef LP_BLD_ARIT_H
  37 #define LP_BLD_ARIT_H
  38
  39
  40 #include "gallivm/lp_bld.h"
  41
  42
  43 struct lp_type;
  44 struct lp_build_context;
  45 struct gallivm_state;
  46
  47
  48 /**
  49  * Complement, i.e., 1 - a.
  50  */
  51 LLVMValueRef
  52 lp_build_comp(struct lp_build_context *bld,
  53               LLVMValueRef a);
  54
  55 LLVMValueRef
  56 lp_build_add(struct lp_build_context *bld,
  57              LLVMValueRef a,
  58              LLVMValueRef b);
  59
  60 LLVMValueRef
  61 lp_build_horizontal_add(struct lp_build_context *bld,
  62                         LLVMValueRef a);
  63
  64 LLVMValueRef
  65 lp_build_hadd_partial4(struct lp_build_context *bld,
  66                        LLVMValueRef vectors[],
  67                        unsigned num_vecs);
  68
  69 LLVMValueRef
  70 lp_build_sub(struct lp_build_context *bld,
  71              LLVMValueRef a,
  72              LLVMValueRef b);
  73
  74 LLVMValueRef
  75 lp_build_mul(struct lp_build_context *bld,
  76              LLVMValueRef a,
  77              LLVMValueRef b);
  78
  79 LLVMValueRef
  80 lp_build_mul_imm(struct lp_build_context *bld,
  81                  LLVMValueRef a,
  82                  int b);
  83
  84 LLVMValueRef
  85 lp_build_div(struct lp_build_context *bld,
  86              LLVMValueRef a,
  87              LLVMValueRef b);
  88
  89
  90 /**
  91  * Set when the weights for normalized are prescaled, that is, in range
  92  * 0..2**n, as opposed to range 0..2**(n-1).
  93  */
  94 #define LP_BLD_LERP_PRESCALED_WEIGHTS (1 << 0)
  95
  96 /**
  97  * Used internally when using wide intermediates for normalized lerps.
  98  *
  99  * Do not use.
 100  */
 101 #define LP_BLD_LERP_WIDE_NORMALIZED (1 << 1)
 102
 103 LLVMValueRef
 104 lp_build_lerp(struct lp_build_context *bld,
 105               LLVMValueRef x,
 106               LLVMValueRef v0,
 107               LLVMValueRef v1,
 108               unsigned flags);
 109
 110 LLVMValueRef
 111 lp_build_lerp_2d(struct lp_build_context *bld,
 112                  LLVMValueRef x,
 113                  LLVMValueRef y,
 114                  LLVMValueRef v00,
 115                  LLVMValueRef v01,
 116                  LLVMValueRef v10,
 117                  LLVMValueRef v11,
 118                  unsigned flags);
 119
 120 LLVMValueRef
 121 lp_build_lerp_3d(struct lp_build_context *bld,
 122                  LLVMValueRef x,
 123                  LLVMValueRef y,
 124                  LLVMValueRef z,
 125                  LLVMValueRef v000,
 126                  LLVMValueRef v001,
 127                  LLVMValueRef v010,
 128                  LLVMValueRef v011,
 129                  LLVMValueRef v100,
 130                  LLVMValueRef v101,
 131                  LLVMValueRef v110,
 132                  LLVMValueRef v111,
 133                  unsigned flags);
 134
 135 /**
 136  * Specifies floating point NaN behavior.
 137  */
 138 enum gallivm_nan_behavior {
 139    /* Results are undefined with NaN. Results in fastest code */
 140    GALLIVM_NAN_BEHAVIOR_UNDEFINED,
 141    /* If input is NaN, NaN is returned */
 142    GALLIVM_NAN_RETURN_NAN,
 143    /* If one of the inputs is NaN, the other operand is returned */
 144    GALLIVM_NAN_RETURN_OTHER,
 145    /* If one of the inputs is NaN, the second operand is returned.
 146     * In min/max it will be as fast as undefined with sse opcodes */
 147    GALLIVM_NAN_RETURN_SECOND
 148 };
 149
 150 LLVMValueRef
 151 lp_build_min(struct lp_build_context *bld,
 152              LLVMValueRef a,
 153              LLVMValueRef b);
 154
 155 LLVMValueRef
 156 lp_build_min_ext(struct lp_build_context *bld,
 157                  LLVMValueRef a,
 158                  LLVMValueRef b,
 159                  enum gallivm_nan_behavior nan_behavior);
 160
 161 LLVMValueRef
 162 lp_build_max(struct lp_build_context *bld,
 163              LLVMValueRef a,
 164              LLVMValueRef b);
 165
 166 LLVMValueRef
 167 lp_build_max_ext(struct lp_build_context *bld,
 168                  LLVMValueRef a,
 169                  LLVMValueRef b,
 170                  enum gallivm_nan_behavior nan_behavior);
 171
 172 LLVMValueRef
 173 lp_build_clamp(struct lp_build_context *bld,
 174                LLVMValueRef a,
 175                LLVMValueRef min,
 176                LLVMValueRef max);
 177
 178 LLVMValueRef
 179 lp_build_abs(struct lp_build_context *bld,
 180              LLVMValueRef a);
 181
 182 LLVMValueRef
 183 lp_build_negate(struct lp_build_context *bld,
 184                 LLVMValueRef a);
 185
 186 LLVMValueRef
 187 lp_build_sgn(struct lp_build_context *bld,
 188              LLVMValueRef a);
 189
 190 LLVMValueRef
 191 lp_build_set_sign(struct lp_build_context *bld,
 192                   LLVMValueRef a, LLVMValueRef sign);
 193
 194 LLVMValueRef
 195 lp_build_int_to_float(struct lp_build_context *bld,
 196                       LLVMValueRef a);
 197
 198 LLVMValueRef
 199 lp_build_round(struct lp_build_context *bld,
 200                LLVMValueRef a);
 201
 202 LLVMValueRef
 203 lp_build_floor(struct lp_build_context *bld,
 204                LLVMValueRef a);
 205
 206 LLVMValueRef
 207 lp_build_ceil(struct lp_build_context *bld,
 208               LLVMValueRef a);
 209
 210 LLVMValueRef
 211 lp_build_trunc(struct lp_build_context *bld,
 212                LLVMValueRef a);
 213
 214 LLVMValueRef
 215 lp_build_fract(struct lp_build_context *bld,
 216                LLVMValueRef a);
 217
 218 LLVMValueRef
 219 lp_build_fract_safe(struct lp_build_context *bld,
 220                     LLVMValueRef a);
 221
 222 LLVMValueRef
 223 lp_build_ifloor(struct lp_build_context *bld,
 224                 LLVMValueRef a);
 225 LLVMValueRef
 226 lp_build_iceil(struct lp_build_context *bld,
 227                LLVMValueRef a);
 228
 229 LLVMValueRef
 230 lp_build_iround(struct lp_build_context *bld,
 231                 LLVMValueRef a);
 232
 233 LLVMValueRef
 234 lp_build_itrunc(struct lp_build_context *bld,
 235                 LLVMValueRef a);
 236
 237 void
 238 lp_build_ifloor_fract(struct lp_build_context *bld,
 239                       LLVMValueRef a,
 240                       LLVMValueRef *out_ipart,
 241                       LLVMValueRef *out_fpart);
 242
 243 void
 244 lp_build_ifloor_fract_safe(struct lp_build_context *bld,
 245                            LLVMValueRef a,
 246                            LLVMValueRef *out_ipart,
 247                            LLVMValueRef *out_fpart);
 248
 249 LLVMValueRef
 250 lp_build_sqrt(struct lp_build_context *bld,
 251               LLVMValueRef a);
 252
 253 LLVMValueRef
 254 lp_build_rcp(struct lp_build_context *bld,
 255              LLVMValueRef a);
 256
 257 LLVMValueRef
 258 lp_build_rsqrt(struct lp_build_context *bld,
 259                LLVMValueRef a);
 260
 261 boolean
 262 lp_build_fast_rsqrt_available(struct lp_type type);
 263
 264 LLVMValueRef
 265 lp_build_fast_rsqrt(struct lp_build_context *bld,
 266                     LLVMValueRef a);
 267
 268 LLVMValueRef
 269 lp_build_polynomial(struct lp_build_context *bld,
 270                     LLVMValueRef x,
 271                     const double *coeffs,
 272                     unsigned num_coeffs);
 273
 274 LLVMValueRef
 275 lp_build_cos(struct lp_build_context *bld,
 276              LLVMValueRef a);
 277
 278 LLVMValueRef
 279 lp_build_sin(struct lp_build_context *bld,
 280              LLVMValueRef a);
 281
 282 LLVMValueRef
 283 lp_build_pow(struct lp_build_context *bld,
 284              LLVMValueRef a,
 285              LLVMValueRef b);
 286
 287 LLVMValueRef
 288 lp_build_exp(struct lp_build_context *bld,
 289              LLVMValueRef a);
 290
 291 LLVMValueRef
 292 lp_build_log(struct lp_build_context *bld,
 293              LLVMValueRef a);
 294
 295 LLVMValueRef
 296 lp_build_log_safe(struct lp_build_context *bld,
 297                   LLVMValueRef a);
 298
 299 LLVMValueRef
 300 lp_build_exp2(struct lp_build_context *bld,
 301               LLVMValueRef a);
 302
 303 LLVMValueRef
 304 lp_build_extract_exponent(struct lp_build_context *bld,
 305                           LLVMValueRef x,
 306                           int bias);
 307
 308 LLVMValueRef
 309 lp_build_extract_mantissa(struct lp_build_context *bld,
 310                           LLVMValueRef x);
 311
 312 LLVMValueRef
 313 lp_build_log2(struct lp_build_context *bld,
 314               LLVMValueRef a);
 315
 316 LLVMValueRef
 317 lp_build_log2_safe(struct lp_build_context *bld,
 318                    LLVMValueRef a);
 319
 320 LLVMValueRef
 321 lp_build_fast_log2(struct lp_build_context *bld,
 322                    LLVMValueRef a);
 323
 324 LLVMValueRef
 325 lp_build_ilog2(struct lp_build_context *bld,
 326                LLVMValueRef x);
 327
 328 void
 329 lp_build_log2_approx(struct lp_build_context *bld,
 330                      LLVMValueRef x,
 331                      LLVMValueRef *p_exp,
 332                      LLVMValueRef *p_floor_log2,
 333                      LLVMValueRef *p_log2,
 334                      boolean handle_nans);
 335
 336 LLVMValueRef
 337 lp_build_mod(struct lp_build_context *bld,
 338              LLVMValueRef x,
 339              LLVMValueRef y);
 340
 341 LLVMValueRef
 342 lp_build_isnan(struct lp_build_context *bld,
 343                LLVMValueRef x);
 344
 345 LLVMValueRef
 346 lp_build_isfinite(struct lp_build_context *bld,
 347                   LLVMValueRef x);
 348
 349
 350 LLVMValueRef
 351 lp_build_is_inf_or_nan(struct gallivm_state *gallivm,
 352                        const struct lp_type type,
 353                        LLVMValueRef x);
 354
 355 #endif /* !LP_BLD_ARIT_H */