1/*
2 * Copyright (C) 2017-2018 Rob Clark <robclark@freedesktop.org>
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 FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 * SOFTWARE.
22 *
23 * Authors:
24 *    Rob Clark <robclark@freedesktop.org>
25 */
26
27#include "ir3_image.h"
28
29/*
30 * SSBO/Image to/from IBO/tex hw mapping table:
31 */
32
33void
34ir3_ibo_mapping_init(struct ir3_ibo_mapping *mapping, unsigned num_textures)
35{
36   memset(mapping, IBO_INVALID, sizeof(*mapping));
37   mapping->num_tex = 0;
38   mapping->tex_base = num_textures;
39}
40
41struct ir3_instruction *
42ir3_ssbo_to_ibo(struct ir3_context *ctx, nir_src src)
43{
44   if (ir3_bindless_resource(src))
45      ctx->so->bindless_ibo = true;
46   return ir3_get_src(ctx, &src)[0];
47}
48
49unsigned
50ir3_ssbo_to_tex(struct ir3_ibo_mapping *mapping, unsigned ssbo)
51{
52   if (mapping->ssbo_to_tex[ssbo] == IBO_INVALID) {
53      unsigned tex = mapping->num_tex++;
54      mapping->ssbo_to_tex[ssbo] = tex;
55      mapping->tex_to_image[tex] = IBO_SSBO | ssbo;
56   }
57   return mapping->ssbo_to_tex[ssbo] + mapping->tex_base;
58}
59
60struct ir3_instruction *
61ir3_image_to_ibo(struct ir3_context *ctx, nir_src src)
62{
63   if (ir3_bindless_resource(src)) {
64      ctx->so->bindless_ibo = true;
65      return ir3_get_src(ctx, &src)[0];
66   }
67
68   if (nir_src_is_const(src)) {
69      int image_idx = nir_src_as_uint(src);
70      return create_immed(ctx->block, ctx->s->info.num_ssbos + image_idx);
71   } else {
72      struct ir3_instruction *image_idx = ir3_get_src(ctx, &src)[0];
73      if (ctx->s->info.num_ssbos) {
74         return ir3_ADD_U(ctx->block,
75            image_idx, 0,
76            create_immed(ctx->block, ctx->s->info.num_ssbos), 0);
77      } else {
78         return image_idx;
79      }
80   }
81}
82
83unsigned
84ir3_image_to_tex(struct ir3_ibo_mapping *mapping, unsigned image)
85{
86   if (mapping->image_to_tex[image] == IBO_INVALID) {
87      unsigned tex = mapping->num_tex++;
88      mapping->image_to_tex[image] = tex;
89      mapping->tex_to_image[tex] = image;
90   }
91   return mapping->image_to_tex[image] + mapping->tex_base;
92}
93
94/* see tex_info() for equiv logic for texture instructions.. it would be
95 * nice if this could be better unified..
96 */
97unsigned
98ir3_get_image_coords(const nir_intrinsic_instr *instr, unsigned *flagsp)
99{
100   enum glsl_sampler_dim dim = nir_intrinsic_image_dim(instr);
101   unsigned coords = nir_image_intrinsic_coord_components(instr);
102   unsigned flags = 0;
103
104   if (dim == GLSL_SAMPLER_DIM_CUBE || nir_intrinsic_image_array(instr))
105      flags |= IR3_INSTR_A;
106   else if (dim == GLSL_SAMPLER_DIM_3D)
107      flags |= IR3_INSTR_3D;
108
109   if (flagsp)
110      *flagsp = flags;
111
112   return coords;
113}
114
115type_t
116ir3_get_type_for_image_intrinsic(const nir_intrinsic_instr *instr)
117{
118   const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
119   int bit_size = info->has_dest ? nir_dest_bit_size(instr->dest) : nir_src_bit_size(instr->src[3]);
120
121   nir_alu_type type = nir_type_uint;
122   switch (instr->intrinsic) {
123   case nir_intrinsic_image_load:
124   case nir_intrinsic_bindless_image_load:
125      type = nir_alu_type_get_base_type(nir_intrinsic_dest_type(instr));
126      /* SpvOpAtomicLoad doesn't have dest type */
127      if (type == nir_type_invalid)
128         type = nir_type_uint;
129      break;
130
131   case nir_intrinsic_image_store:
132   case nir_intrinsic_bindless_image_store:
133      type = nir_alu_type_get_base_type(nir_intrinsic_src_type(instr));
134      /* SpvOpAtomicStore doesn't have src type */
135      if (type == nir_type_invalid)
136         type = nir_type_uint;
137      break;
138
139   case nir_intrinsic_image_atomic_add:
140   case nir_intrinsic_bindless_image_atomic_add:
141   case nir_intrinsic_image_atomic_umin:
142   case nir_intrinsic_bindless_image_atomic_umin:
143   case nir_intrinsic_image_atomic_umax:
144   case nir_intrinsic_bindless_image_atomic_umax:
145   case nir_intrinsic_image_atomic_and:
146   case nir_intrinsic_bindless_image_atomic_and:
147   case nir_intrinsic_image_atomic_or:
148   case nir_intrinsic_bindless_image_atomic_or:
149   case nir_intrinsic_image_atomic_xor:
150   case nir_intrinsic_bindless_image_atomic_xor:
151   case nir_intrinsic_image_atomic_exchange:
152   case nir_intrinsic_bindless_image_atomic_exchange:
153   case nir_intrinsic_image_atomic_comp_swap:
154   case nir_intrinsic_bindless_image_atomic_comp_swap:
155   case nir_intrinsic_image_atomic_inc_wrap:
156   case nir_intrinsic_bindless_image_atomic_inc_wrap:
157      type = nir_type_uint;
158      break;
159
160   case nir_intrinsic_image_atomic_imin:
161   case nir_intrinsic_bindless_image_atomic_imin:
162   case nir_intrinsic_image_atomic_imax:
163   case nir_intrinsic_bindless_image_atomic_imax:
164      type = nir_type_int;
165      break;
166
167   default:
168      unreachable("Unhandled NIR image intrinsic");
169   }
170
171   switch (type) {
172   case nir_type_uint:
173      return bit_size == 16 ? TYPE_U16 : TYPE_U32;
174   case nir_type_int:
175      return bit_size == 16 ? TYPE_S16 : TYPE_S32;
176   case nir_type_float:
177      return bit_size == 16 ? TYPE_F16 : TYPE_F32;
178   default:
179      unreachable("bad type");
180   }
181}
182
183/* Returns the number of components for the different image formats
184 * supported by the GLES 3.1 spec, plus those added by the
185 * GL_NV_image_formats extension.
186 */
187unsigned
188ir3_get_num_components_for_image_format(enum pipe_format format)
189{
190   if (format == PIPE_FORMAT_NONE)
191      return 4;
192   else
193      return util_format_get_nr_components(format);
194}
195