src/compiler/spirv/vtn_opencl.c

   1 /*
   2  * Copyright © 2018 Red Hat
   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  * Authors:
  24  *    Rob Clark (robdclark@gmail.com)
  25  */
  26
  27 #include "math.h"
  28
  29 #include "nir/nir_builtin_builder.h"
  30
  31 #include "vtn_private.h"
  32 #include "OpenCL.std.h"
  33
  34 typedef nir_ssa_def *(*nir_handler)(struct vtn_builder *b,
  35                                     enum OpenCLstd_Entrypoints opcode,
  36                                     unsigned num_srcs, nir_ssa_def **srcs,
  37                                     const struct glsl_type *dest_type);
  38
  39 static void
  40 handle_instr(struct vtn_builder *b, enum OpenCLstd_Entrypoints opcode,
  41              const uint32_t *w, unsigned count, nir_handler handler)
  42 {
  43    const struct glsl_type *dest_type =
  44       vtn_value(b, w[1], vtn_value_type_type)->type->type;
  45
  46    unsigned num_srcs = count - 5;
  47    nir_ssa_def *srcs[3] = { NULL };
  48    vtn_assert(num_srcs <= ARRAY_SIZE(srcs));
  49    for (unsigned i = 0; i < num_srcs; i++) {
  50       srcs[i] = vtn_ssa_value(b, w[i + 5])->def;
  51    }
  52
  53    nir_ssa_def *result = handler(b, opcode, num_srcs, srcs, dest_type);
  54    if (result) {
  55       struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_ssa);
  56       val->ssa = vtn_create_ssa_value(b, dest_type);
  57       val->ssa->def = result;
  58    } else {
  59       vtn_assert(dest_type == glsl_void_type());
  60    }
  61 }
  62
  63 static nir_op
  64 nir_alu_op_for_opencl_opcode(struct vtn_builder *b,
  65                              enum OpenCLstd_Entrypoints opcode)
  66 {
  67    switch (opcode) {
  68    case OpenCLstd_Fabs: return nir_op_fabs;
  69    case OpenCLstd_SAbs: return nir_op_iabs;
  70    case OpenCLstd_SAdd_sat: return nir_op_iadd_sat;
  71    case OpenCLstd_UAdd_sat: return nir_op_uadd_sat;
  72    case OpenCLstd_Ceil: return nir_op_fceil;
  73    case OpenCLstd_Cos: return nir_op_fcos;
  74    case OpenCLstd_Exp2: return nir_op_fexp2;
  75    case OpenCLstd_Log2: return nir_op_flog2;
  76    case OpenCLstd_Floor: return nir_op_ffloor;
  77    case OpenCLstd_SHadd: return nir_op_ihadd;
  78    case OpenCLstd_UHadd: return nir_op_uhadd;
  79    case OpenCLstd_Fma: return nir_op_ffma;
  80    case OpenCLstd_Fmax: return nir_op_fmax;
  81    case OpenCLstd_SMax: return nir_op_imax;
  82    case OpenCLstd_UMax: return nir_op_umax;
  83    case OpenCLstd_Fmin: return nir_op_fmin;
  84    case OpenCLstd_SMin: return nir_op_imin;
  85    case OpenCLstd_UMin: return nir_op_umin;
  86    case OpenCLstd_Fmod: return nir_op_fmod;
  87    case OpenCLstd_Mix: return nir_op_flrp;
  88    case OpenCLstd_SMul_hi: return nir_op_imul_high;
  89    case OpenCLstd_UMul_hi: return nir_op_umul_high;
  90    case OpenCLstd_Popcount: return nir_op_bit_count;
  91    case OpenCLstd_Pow: return nir_op_fpow;
  92    case OpenCLstd_Remainder: return nir_op_frem;
  93    case OpenCLstd_SRhadd: return nir_op_irhadd;
  94    case OpenCLstd_URhadd: return nir_op_urhadd;
  95    case OpenCLstd_Rsqrt: return nir_op_frsq;
  96    case OpenCLstd_Sign: return nir_op_fsign;
  97    case OpenCLstd_Sin: return nir_op_fsin;
  98    case OpenCLstd_Sqrt: return nir_op_fsqrt;
  99    case OpenCLstd_SSub_sat: return nir_op_isub_sat;
 100    case OpenCLstd_USub_sat: return nir_op_usub_sat;
 101    case OpenCLstd_Trunc: return nir_op_ftrunc;
 102    /* uhm... */
 103    case OpenCLstd_UAbs: return nir_op_mov;
 104    default:
 105       vtn_fail("No NIR equivalent");
 106    }
 107 }
 108
 109 static nir_ssa_def *
 110 handle_alu(struct vtn_builder *b, enum OpenCLstd_Entrypoints opcode,
 111            unsigned num_srcs, nir_ssa_def **srcs,
 112            const struct glsl_type *dest_type)
 113 {
 114    return nir_build_alu(&b->nb, nir_alu_op_for_opencl_opcode(b, opcode),
 115                         srcs[0], srcs[1], srcs[2], NULL);
 116 }
 117
 118 static nir_ssa_def *
 119 handle_special(struct vtn_builder *b, enum OpenCLstd_Entrypoints opcode,
 120                unsigned num_srcs, nir_ssa_def **srcs,
 121                const struct glsl_type *dest_type)
 122 {
 123    nir_builder *nb = &b->nb;
 124
 125    switch (opcode) {
 126    case OpenCLstd_SAbs_diff:
 127       return nir_iabs_diff(nb, srcs[0], srcs[1]);
 128    case OpenCLstd_UAbs_diff:
 129       return nir_uabs_diff(nb, srcs[0], srcs[1]);
 130    case OpenCLstd_Bitselect:
 131       return nir_bitselect(nb, srcs[0], srcs[1], srcs[2]);
 132    case OpenCLstd_FClamp:
 133       return nir_fclamp(nb, srcs[0], srcs[1], srcs[2]);
 134    case OpenCLstd_SClamp:
 135       return nir_iclamp(nb, srcs[0], srcs[1], srcs[2]);
 136    case OpenCLstd_UClamp:
 137       return nir_uclamp(nb, srcs[0], srcs[1], srcs[2]);
 138    case OpenCLstd_Copysign:
 139       return nir_copysign(nb, srcs[0], srcs[1]);
 140    case OpenCLstd_Cross:
 141       if (glsl_get_components(dest_type) == 4)
 142          return nir_cross4(nb, srcs[0], srcs[1]);
 143       return nir_cross3(nb, srcs[0], srcs[1]);
 144    case OpenCLstd_Degrees:
 145       return nir_degrees(nb, srcs[0]);
 146    case OpenCLstd_Fdim:
 147       return nir_fdim(nb, srcs[0], srcs[1]);
 148    case OpenCLstd_Distance:
 149       return nir_distance(nb, srcs[0], srcs[1]);
 150    case OpenCLstd_Fast_distance:
 151       return nir_fast_distance(nb, srcs[0], srcs[1]);
 152    case OpenCLstd_Fast_length:
 153       return nir_fast_length(nb, srcs[0]);
 154    case OpenCLstd_Fast_normalize:
 155       return nir_fast_normalize(nb, srcs[0]);
 156    case OpenCLstd_Length:
 157       return nir_length(nb, srcs[0]);
 158    case OpenCLstd_Mad:
 159       return nir_fmad(nb, srcs[0], srcs[1], srcs[2]);
 160    case OpenCLstd_Maxmag:
 161       return nir_maxmag(nb, srcs[0], srcs[1]);
 162    case OpenCLstd_Minmag:
 163       return nir_minmag(nb, srcs[0], srcs[1]);
 164    case OpenCLstd_Nan:
 165       return nir_nan(nb, srcs[0]);
 166    case OpenCLstd_Nextafter:
 167       return nir_nextafter(nb, srcs[0], srcs[1]);
 168    case OpenCLstd_Normalize:
 169       return nir_normalize(nb, srcs[0]);
 170    case OpenCLstd_Radians:
 171       return nir_radians(nb, srcs[0]);
 172    case OpenCLstd_Rotate:
 173       return nir_rotate(nb, srcs[0], srcs[1]);
 174    case OpenCLstd_Smoothstep:
 175       return nir_smoothstep(nb, srcs[0], srcs[1], srcs[2]);
 176    case OpenCLstd_Select:
 177       return nir_select(nb, srcs[0], srcs[1], srcs[2]);
 178    case OpenCLstd_Step:
 179       return nir_sge(nb, srcs[1], srcs[0]);
 180    case OpenCLstd_S_Upsample:
 181    case OpenCLstd_U_Upsample:
 182       return nir_upsample(nb, srcs[0], srcs[1]);
 183    default:
 184       vtn_fail("No NIR equivalent");
 185       return NULL;
 186    }
 187 }
 188
 189 static void
 190 _handle_v_load_store(struct vtn_builder *b, enum OpenCLstd_Entrypoints opcode,
 191                      const uint32_t *w, unsigned count, bool load)
 192 {
 193    struct vtn_type *type;
 194    if (load)
 195       type = vtn_value(b, w[1], vtn_value_type_type)->type;
 196    else
 197       type = vtn_untyped_value(b, w[5])->type;
 198    unsigned a = load ? 0 : 1;
 199
 200    const struct glsl_type *dest_type = type->type;
 201    unsigned components = glsl_get_vector_elements(dest_type);
 202    unsigned stride = components * glsl_get_bit_size(dest_type) / 8;
 203
 204    nir_ssa_def *offset = vtn_ssa_value(b, w[5 + a])->def;
 205    struct vtn_value *p = vtn_value(b, w[6 + a], vtn_value_type_pointer);
 206
 207    nir_deref_instr *deref = vtn_pointer_to_deref(b, p->pointer);
 208
 209    /* 1. cast to vec type with adjusted stride */
 210    deref = nir_build_deref_cast(&b->nb, &deref->dest.ssa, deref->mode,
 211                                 dest_type, stride);
 212    /* 2. deref ptr_as_array */
 213    deref = nir_build_deref_ptr_as_array(&b->nb, deref, offset);
 214
 215    if (load) {
 216       struct vtn_ssa_value *val = vtn_local_load(b, deref, p->type->access);
 217       vtn_push_ssa(b, w[2], type, val);
 218    } else {
 219       struct vtn_ssa_value *val = vtn_ssa_value(b, w[5]);
 220       vtn_local_store(b, val, deref, p->type->access);
 221    }
 222 }
 223
 224 static void
 225 vtn_handle_opencl_vload(struct vtn_builder *b, enum OpenCLstd_Entrypoints opcode,
 226                         const uint32_t *w, unsigned count)
 227 {
 228    _handle_v_load_store(b, opcode, w, count, true);
 229 }
 230
 231 static void
 232 vtn_handle_opencl_vstore(struct vtn_builder *b, enum OpenCLstd_Entrypoints opcode,
 233                          const uint32_t *w, unsigned count)
 234 {
 235    _handle_v_load_store(b, opcode, w, count, false);
 236 }
 237
 238 static nir_ssa_def *
 239 handle_printf(struct vtn_builder *b, enum OpenCLstd_Entrypoints opcode,
 240               unsigned num_srcs, nir_ssa_def **srcs,
 241               const struct glsl_type *dest_type)
 242 {
 243    /* hahah, yeah, right.. */
 244    return nir_imm_int(&b->nb, -1);
 245 }
 246
 247 bool
 248 vtn_handle_opencl_instruction(struct vtn_builder *b, uint32_t ext_opcode,
 249                               const uint32_t *w, unsigned count)
 250 {
 251    switch (ext_opcode) {
 252    case OpenCLstd_Fabs:
 253    case OpenCLstd_SAbs:
 254    case OpenCLstd_UAbs:
 255    case OpenCLstd_SAdd_sat:
 256    case OpenCLstd_UAdd_sat:
 257    case OpenCLstd_Ceil:
 258    case OpenCLstd_Cos:
 259    case OpenCLstd_Exp2:
 260    case OpenCLstd_Log2:
 261    case OpenCLstd_Floor:
 262    case OpenCLstd_Fma:
 263    case OpenCLstd_Fmax:
 264    case OpenCLstd_SHadd:
 265    case OpenCLstd_UHadd:
 266    case OpenCLstd_SMax:
 267    case OpenCLstd_UMax:
 268    case OpenCLstd_Fmin:
 269    case OpenCLstd_SMin:
 270    case OpenCLstd_UMin:
 271    case OpenCLstd_Mix:
 272    case OpenCLstd_Fmod:
 273    case OpenCLstd_SMul_hi:
 274    case OpenCLstd_UMul_hi:
 275    case OpenCLstd_Popcount:
 276    case OpenCLstd_Pow:
 277    case OpenCLstd_Remainder:
 278    case OpenCLstd_SRhadd:
 279    case OpenCLstd_URhadd:
 280    case OpenCLstd_Rsqrt:
 281    case OpenCLstd_Sign:
 282    case OpenCLstd_Sin:
 283    case OpenCLstd_Sqrt:
 284    case OpenCLstd_SSub_sat:
 285    case OpenCLstd_USub_sat:
 286    case OpenCLstd_Trunc:
 287       handle_instr(b, ext_opcode, w, count, handle_alu);
 288       return true;
 289    case OpenCLstd_SAbs_diff:
 290    case OpenCLstd_UAbs_diff:
 291    case OpenCLstd_Bitselect:
 292    case OpenCLstd_FClamp:
 293    case OpenCLstd_SClamp:
 294    case OpenCLstd_UClamp:
 295    case OpenCLstd_Copysign:
 296    case OpenCLstd_Cross:
 297    case OpenCLstd_Degrees:
 298    case OpenCLstd_Fdim:
 299    case OpenCLstd_Distance:
 300    case OpenCLstd_Fast_distance:
 301    case OpenCLstd_Fast_length:
 302    case OpenCLstd_Fast_normalize:
 303    case OpenCLstd_Length:
 304    case OpenCLstd_Mad:
 305    case OpenCLstd_Maxmag:
 306    case OpenCLstd_Minmag:
 307    case OpenCLstd_Nan:
 308    case OpenCLstd_Nextafter:
 309    case OpenCLstd_Normalize:
 310    case OpenCLstd_Radians:
 311    case OpenCLstd_Rotate:
 312    case OpenCLstd_Select:
 313    case OpenCLstd_Step:
 314    case OpenCLstd_Smoothstep:
 315    case OpenCLstd_S_Upsample:
 316    case OpenCLstd_U_Upsample:
 317       handle_instr(b, ext_opcode, w, count, handle_special);
 318       return true;
 319    case OpenCLstd_Vloadn:
 320       vtn_handle_opencl_vload(b, ext_opcode, w, count);
 321       return true;
 322    case OpenCLstd_Vstoren:
 323       vtn_handle_opencl_vstore(b, ext_opcode, w, count);
 324       return true;
 325    case OpenCLstd_Printf:
 326       handle_instr(b, ext_opcode, w, count, handle_printf);
 327       return true;
 328    case OpenCLstd_Prefetch:
 329       /* TODO maybe add a nir instruction for this? */
 330       return true;
 331    default:
 332       vtn_fail("unhandled opencl opc: %u\n", ext_opcode);
 333       return false;
 334    }
 335 }