src/compiler/nir/nir_builtin_builder.h

   1 /*
   2  * Copyright © 2018 Red Hat Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #ifndef NIR_BUILTIN_BUILDER_H
  25 #define NIR_BUILTIN_BUILDER_H
  26
  27 #include "util/u_math.h"
  28 #include "nir_builder.h"
  29
  30 #ifdef __cplusplus
  31 extern "C" {
  32 #endif
  33
  34 /*
  35  * Functions are sorted alphabetically with removed type and "fast" prefix.
  36  * Definitions for functions in the C file come first.
  37  */
  38
  39 nir_ssa_def* nir_cross3(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y);
  40 nir_ssa_def* nir_cross4(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y);
  41 nir_ssa_def* nir_length(nir_builder *b, nir_ssa_def *vec);
  42 nir_ssa_def* nir_fast_length(nir_builder *b, nir_ssa_def *vec);
  43 nir_ssa_def* nir_nextafter(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y);
  44 nir_ssa_def* nir_normalize(nir_builder *b, nir_ssa_def *vec);
  45 nir_ssa_def* nir_rotate(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y);
  46 nir_ssa_def* nir_smoothstep(nir_builder *b, nir_ssa_def *edge0,
  47                             nir_ssa_def *edge1, nir_ssa_def *x);
  48 nir_ssa_def* nir_upsample(nir_builder *b, nir_ssa_def *hi, nir_ssa_def *lo);
  49 nir_ssa_def* nir_atan(nir_builder *b, nir_ssa_def *y_over_x);
  50 nir_ssa_def* nir_atan2(nir_builder *b, nir_ssa_def *y, nir_ssa_def *x);
  51
  52 nir_ssa_def *
  53 nir_get_texture_lod(nir_builder *b, nir_tex_instr *tex);
  54
  55 nir_ssa_def *
  56 nir_get_texture_size(nir_builder *b, nir_tex_instr *tex);
  57
  58 static inline nir_ssa_def *
  59 nir_nan_check2(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y, nir_ssa_def *res)
  60 {
  61    return nir_bcsel(b, nir_fneu(b, x, x), x, nir_bcsel(b, nir_fneu(b, y, y), y, res));
  62 }
  63
  64 static inline nir_ssa_def *
  65 nir_fmax_abs_vec_comp(nir_builder *b, nir_ssa_def *vec)
  66 {
  67    nir_ssa_def *res = nir_channel(b, vec, 0);
  68    for (unsigned i = 1; i < vec->num_components; ++i)
  69       res = nir_fmax(b, res, nir_fabs(b, nir_channel(b, vec, i)));
  70    return res;
  71 }
  72
  73 static inline nir_ssa_def *
  74 nir_iabs_diff(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y)
  75 {
  76    nir_ssa_def *cond = nir_ige(b, x, y);
  77    nir_ssa_def *res0 = nir_isub(b, x, y);
  78    nir_ssa_def *res1 = nir_isub(b, y, x);
  79    return nir_bcsel(b, cond, res0, res1);
  80 }
  81
  82 static inline nir_ssa_def *
  83 nir_uabs_diff(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y)
  84 {
  85    nir_ssa_def *cond = nir_uge(b, x, y);
  86    nir_ssa_def *res0 = nir_isub(b, x, y);
  87    nir_ssa_def *res1 = nir_isub(b, y, x);
  88    return nir_bcsel(b, cond, res0, res1);
  89 }
  90
  91 static inline nir_ssa_def *
  92 nir_fexp(nir_builder *b, nir_ssa_def *x)
  93 {
  94    return nir_fexp2(b, nir_fmul_imm(b, x, M_LOG2E));
  95 }
  96
  97 static inline nir_ssa_def *
  98 nir_flog(nir_builder *b, nir_ssa_def *x)
  99 {
 100    return nir_fmul_imm(b, nir_flog2(b, x), 1.0 / M_LOG2E);
 101 }
 102
 103 static inline nir_ssa_def *
 104 nir_imad24(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y, nir_ssa_def *z)
 105 {
 106    nir_ssa_def *temp = nir_imul24(b, x, y);
 107    return nir_iadd(b, temp, z);
 108 }
 109
 110 static inline nir_ssa_def *
 111 nir_imad_hi(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y, nir_ssa_def *z)
 112 {
 113    nir_ssa_def *temp = nir_imul_high(b, x, y);
 114    return nir_iadd(b, temp, z);
 115 }
 116
 117 static inline nir_ssa_def *
 118 nir_umad_hi(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y, nir_ssa_def *z)
 119 {
 120    nir_ssa_def *temp = nir_umul_high(b, x, y);
 121    return nir_iadd(b, temp, z);
 122 }
 123
 124 static inline nir_ssa_def *
 125 nir_bitselect(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y, nir_ssa_def *s)
 126 {
 127    return nir_ior(b, nir_iand(b, nir_inot(b, s), x), nir_iand(b, s, y));
 128 }
 129
 130 static inline nir_ssa_def *
 131 nir_fclamp(nir_builder *b,
 132            nir_ssa_def *x, nir_ssa_def *min_val, nir_ssa_def *max_val)
 133 {
 134    return nir_fmin(b, nir_fmax(b, x, min_val), max_val);
 135 }
 136
 137 static inline nir_ssa_def *
 138 nir_iclamp(nir_builder *b,
 139            nir_ssa_def *x, nir_ssa_def *min_val, nir_ssa_def *max_val)
 140 {
 141    return nir_imin(b, nir_imax(b, x, min_val), max_val);
 142 }
 143
 144 static inline nir_ssa_def *
 145 nir_uclamp(nir_builder *b,
 146            nir_ssa_def *x, nir_ssa_def *min_val, nir_ssa_def *max_val)
 147 {
 148    return nir_umin(b, nir_umax(b, x, min_val), max_val);
 149 }
 150
 151 static inline nir_ssa_def *
 152 nir_copysign(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y)
 153 {
 154    uint64_t masks = 1ull << (x->bit_size - 1);
 155    uint64_t maskv = ~masks;
 156
 157    nir_ssa_def *s = nir_imm_intN_t(b, masks, x->bit_size);
 158    nir_ssa_def *v = nir_imm_intN_t(b, maskv, x->bit_size);
 159
 160    return nir_ior(b, nir_iand(b, x, v), nir_iand(b, y, s));
 161 }
 162
 163 static inline nir_ssa_def *
 164 nir_degrees(nir_builder *b, nir_ssa_def *val)
 165 {
 166    return nir_fmul_imm(b, val, 180.0 / M_PI);
 167 }
 168
 169 static inline nir_ssa_def *
 170 nir_fdim(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y)
 171 {
 172    nir_ssa_def *cond = nir_flt(b, y, x);
 173    nir_ssa_def *res = nir_fsub(b, x, y);
 174    nir_ssa_def *zero = nir_imm_floatN_t(b, 0.0, x->bit_size);
 175
 176    // return NaN if either x or y are NaN, else x-y if x>y, else +0.0
 177    return nir_nan_check2(b, x, y, nir_bcsel(b, cond, res, zero));
 178 }
 179
 180 static inline nir_ssa_def *
 181 nir_distance(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y)
 182 {
 183    return nir_length(b, nir_fsub(b, x, y));
 184 }
 185
 186 static inline nir_ssa_def *
 187 nir_fast_distance(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y)
 188 {
 189    return nir_fast_length(b, nir_fsub(b, x, y));
 190 }
 191
 192 static inline nir_ssa_def*
 193 nir_fast_normalize(nir_builder *b, nir_ssa_def *vec)
 194 {
 195    return nir_fdiv(b, vec, nir_fast_length(b, vec));
 196 }
 197
 198 static inline nir_ssa_def*
 199 nir_fmad(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y, nir_ssa_def *z)
 200 {
 201    return nir_fadd(b, nir_fmul(b, x, y), z);
 202 }
 203
 204 static inline nir_ssa_def*
 205 nir_maxmag(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y)
 206 {
 207    nir_ssa_def *xabs = nir_fabs(b, x);
 208    nir_ssa_def *yabs = nir_fabs(b, y);
 209
 210    nir_ssa_def *condy = nir_flt(b, xabs, yabs);
 211    nir_ssa_def *condx = nir_flt(b, yabs, xabs);
 212
 213    return nir_bcsel(b, condy, y, nir_bcsel(b, condx, x, nir_fmax(b, x, y)));
 214 }
 215
 216 static inline nir_ssa_def*
 217 nir_minmag(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y)
 218 {
 219    nir_ssa_def *xabs = nir_fabs(b, x);
 220    nir_ssa_def *yabs = nir_fabs(b, y);
 221
 222    nir_ssa_def *condx = nir_flt(b, xabs, yabs);
 223    nir_ssa_def *condy = nir_flt(b, yabs, xabs);
 224
 225    return nir_bcsel(b, condy, y, nir_bcsel(b, condx, x, nir_fmin(b, x, y)));
 226 }
 227
 228 static inline nir_ssa_def*
 229 nir_nan(nir_builder *b, nir_ssa_def *x)
 230 {
 231    nir_ssa_def *nan = nir_imm_floatN_t(b, NAN, x->bit_size);
 232    if (x->num_components == 1)
 233       return nan;
 234
 235    nir_ssa_def *nans[NIR_MAX_VEC_COMPONENTS];
 236    for (unsigned i = 0; i < x->num_components; ++i)
 237       nans[i] = nan;
 238
 239    return nir_vec(b, nans, x->num_components);
 240 }
 241
 242 static inline nir_ssa_def *
 243 nir_radians(nir_builder *b, nir_ssa_def *val)
 244 {
 245    return nir_fmul_imm(b, val, M_PI / 180.0);
 246 }
 247
 248 static inline nir_ssa_def *
 249 nir_select(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y, nir_ssa_def *s)
 250 {
 251    if (s->num_components != 1) {
 252       uint64_t mask = 1ull << (s->bit_size - 1);
 253       s = nir_iand(b, s, nir_imm_intN_t(b, mask, s->bit_size));
 254    }
 255    return nir_bcsel(b, nir_ieq(b, s, nir_imm_intN_t(b, 0, s->bit_size)), x, y);
 256 }
 257
 258 static inline nir_ssa_def *
 259 nir_ftan(nir_builder *b, nir_ssa_def *x)
 260 {
 261    return nir_fdiv(b, nir_fsin(b, x), nir_fcos(b, x));
 262 }
 263
 264 static inline nir_ssa_def *
 265 nir_clz_u(nir_builder *b, nir_ssa_def *a)
 266 {
 267    nir_ssa_def *val;
 268    val = nir_isub(b, nir_imm_intN_t(b, a->bit_size - 1, 32), nir_ufind_msb(b, a));
 269    return nir_u2u(b, val, a->bit_size);
 270 }
 271
 272 #ifdef __cplusplus
 273 }
 274 #endif
 275
 276 #endif /* NIR_BUILTIN_BUILDER_H */