Home | History | Annotate | Line # | Download | only in nir 
      1 /* Copyright (C) 2018 Red Hat
      2  * Copyright (C) 2020 Valve Corporation
      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_INTRINSICS_INDICES_
     25 #define _NIR_INTRINSICS_INDICES_
     26 
     27 
     28 
     29 static inline int
     30 nir_intrinsic_base(const nir_intrinsic_instr *instr)
     31 {
     32    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
     33    assert(info->index_map[NIR_INTRINSIC_BASE] > 0);
     34    return (int)instr->const_index[info->index_map[NIR_INTRINSIC_BASE] - 1];
     35 }
     36 
     37 static inline void
     38 nir_intrinsic_set_base(nir_intrinsic_instr *instr, int val)
     39 {
     40    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
     41    assert(info->index_map[NIR_INTRINSIC_BASE] > 0);
     42    instr->const_index[info->index_map[NIR_INTRINSIC_BASE] - 1] = val;
     43 }
     44 
     45 static inline bool
     46 nir_intrinsic_has_base(const nir_intrinsic_instr *instr)
     47 {
     48    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
     49    return info->index_map[NIR_INTRINSIC_BASE] > 0;
     50 }
     51 
     52 
     53 static inline unsigned
     54 nir_intrinsic_write_mask(const nir_intrinsic_instr *instr)
     55 {
     56    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
     57    assert(info->index_map[NIR_INTRINSIC_WRITE_MASK] > 0);
     58    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_WRITE_MASK] - 1];
     59 }
     60 
     61 static inline void
     62 nir_intrinsic_set_write_mask(nir_intrinsic_instr *instr, unsigned val)
     63 {
     64    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
     65    assert(info->index_map[NIR_INTRINSIC_WRITE_MASK] > 0);
     66    instr->const_index[info->index_map[NIR_INTRINSIC_WRITE_MASK] - 1] = val;
     67 }
     68 
     69 static inline bool
     70 nir_intrinsic_has_write_mask(const nir_intrinsic_instr *instr)
     71 {
     72    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
     73    return info->index_map[NIR_INTRINSIC_WRITE_MASK] > 0;
     74 }
     75 
     76 
     77 static inline unsigned
     78 nir_intrinsic_stream_id(const nir_intrinsic_instr *instr)
     79 {
     80    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
     81    assert(info->index_map[NIR_INTRINSIC_STREAM_ID] > 0);
     82    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_STREAM_ID] - 1];
     83 }
     84 
     85 static inline void
     86 nir_intrinsic_set_stream_id(nir_intrinsic_instr *instr, unsigned val)
     87 {
     88    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
     89    assert(info->index_map[NIR_INTRINSIC_STREAM_ID] > 0);
     90    instr->const_index[info->index_map[NIR_INTRINSIC_STREAM_ID] - 1] = val;
     91 }
     92 
     93 static inline bool
     94 nir_intrinsic_has_stream_id(const nir_intrinsic_instr *instr)
     95 {
     96    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
     97    return info->index_map[NIR_INTRINSIC_STREAM_ID] > 0;
     98 }
     99 
    100 
    101 static inline unsigned
    102 nir_intrinsic_ucp_id(const nir_intrinsic_instr *instr)
    103 {
    104    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    105    assert(info->index_map[NIR_INTRINSIC_UCP_ID] > 0);
    106    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_UCP_ID] - 1];
    107 }
    108 
    109 static inline void
    110 nir_intrinsic_set_ucp_id(nir_intrinsic_instr *instr, unsigned val)
    111 {
    112    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    113    assert(info->index_map[NIR_INTRINSIC_UCP_ID] > 0);
    114    instr->const_index[info->index_map[NIR_INTRINSIC_UCP_ID] - 1] = val;
    115 }
    116 
    117 static inline bool
    118 nir_intrinsic_has_ucp_id(const nir_intrinsic_instr *instr)
    119 {
    120    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    121    return info->index_map[NIR_INTRINSIC_UCP_ID] > 0;
    122 }
    123 
    124 
    125 static inline unsigned
    126 nir_intrinsic_range_base(const nir_intrinsic_instr *instr)
    127 {
    128    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    129    assert(info->index_map[NIR_INTRINSIC_RANGE_BASE] > 0);
    130    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_RANGE_BASE] - 1];
    131 }
    132 
    133 static inline void
    134 nir_intrinsic_set_range_base(nir_intrinsic_instr *instr, unsigned val)
    135 {
    136    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    137    assert(info->index_map[NIR_INTRINSIC_RANGE_BASE] > 0);
    138    instr->const_index[info->index_map[NIR_INTRINSIC_RANGE_BASE] - 1] = val;
    139 }
    140 
    141 static inline bool
    142 nir_intrinsic_has_range_base(const nir_intrinsic_instr *instr)
    143 {
    144    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    145    return info->index_map[NIR_INTRINSIC_RANGE_BASE] > 0;
    146 }
    147 
    148 
    149 static inline unsigned
    150 nir_intrinsic_range(const nir_intrinsic_instr *instr)
    151 {
    152    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    153    assert(info->index_map[NIR_INTRINSIC_RANGE] > 0);
    154    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_RANGE] - 1];
    155 }
    156 
    157 static inline void
    158 nir_intrinsic_set_range(nir_intrinsic_instr *instr, unsigned val)
    159 {
    160    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    161    assert(info->index_map[NIR_INTRINSIC_RANGE] > 0);
    162    instr->const_index[info->index_map[NIR_INTRINSIC_RANGE] - 1] = val;
    163 }
    164 
    165 static inline bool
    166 nir_intrinsic_has_range(const nir_intrinsic_instr *instr)
    167 {
    168    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    169    return info->index_map[NIR_INTRINSIC_RANGE] > 0;
    170 }
    171 
    172 
    173 static inline unsigned
    174 nir_intrinsic_desc_set(const nir_intrinsic_instr *instr)
    175 {
    176    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    177    assert(info->index_map[NIR_INTRINSIC_DESC_SET] > 0);
    178    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_DESC_SET] - 1];
    179 }
    180 
    181 static inline void
    182 nir_intrinsic_set_desc_set(nir_intrinsic_instr *instr, unsigned val)
    183 {
    184    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    185    assert(info->index_map[NIR_INTRINSIC_DESC_SET] > 0);
    186    instr->const_index[info->index_map[NIR_INTRINSIC_DESC_SET] - 1] = val;
    187 }
    188 
    189 static inline bool
    190 nir_intrinsic_has_desc_set(const nir_intrinsic_instr *instr)
    191 {
    192    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    193    return info->index_map[NIR_INTRINSIC_DESC_SET] > 0;
    194 }
    195 
    196 
    197 static inline unsigned
    198 nir_intrinsic_binding(const nir_intrinsic_instr *instr)
    199 {
    200    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    201    assert(info->index_map[NIR_INTRINSIC_BINDING] > 0);
    202    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_BINDING] - 1];
    203 }
    204 
    205 static inline void
    206 nir_intrinsic_set_binding(nir_intrinsic_instr *instr, unsigned val)
    207 {
    208    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    209    assert(info->index_map[NIR_INTRINSIC_BINDING] > 0);
    210    instr->const_index[info->index_map[NIR_INTRINSIC_BINDING] - 1] = val;
    211 }
    212 
    213 static inline bool
    214 nir_intrinsic_has_binding(const nir_intrinsic_instr *instr)
    215 {
    216    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    217    return info->index_map[NIR_INTRINSIC_BINDING] > 0;
    218 }
    219 
    220 
    221 static inline unsigned
    222 nir_intrinsic_component(const nir_intrinsic_instr *instr)
    223 {
    224    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    225    assert(info->index_map[NIR_INTRINSIC_COMPONENT] > 0);
    226    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_COMPONENT] - 1];
    227 }
    228 
    229 static inline void
    230 nir_intrinsic_set_component(nir_intrinsic_instr *instr, unsigned val)
    231 {
    232    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    233    assert(info->index_map[NIR_INTRINSIC_COMPONENT] > 0);
    234    instr->const_index[info->index_map[NIR_INTRINSIC_COMPONENT] - 1] = val;
    235 }
    236 
    237 static inline bool
    238 nir_intrinsic_has_component(const nir_intrinsic_instr *instr)
    239 {
    240    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    241    return info->index_map[NIR_INTRINSIC_COMPONENT] > 0;
    242 }
    243 
    244 
    245 static inline unsigned
    246 nir_intrinsic_column(const nir_intrinsic_instr *instr)
    247 {
    248    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    249    assert(info->index_map[NIR_INTRINSIC_COLUMN] > 0);
    250    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_COLUMN] - 1];
    251 }
    252 
    253 static inline void
    254 nir_intrinsic_set_column(nir_intrinsic_instr *instr, unsigned val)
    255 {
    256    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    257    assert(info->index_map[NIR_INTRINSIC_COLUMN] > 0);
    258    instr->const_index[info->index_map[NIR_INTRINSIC_COLUMN] - 1] = val;
    259 }
    260 
    261 static inline bool
    262 nir_intrinsic_has_column(const nir_intrinsic_instr *instr)
    263 {
    264    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    265    return info->index_map[NIR_INTRINSIC_COLUMN] > 0;
    266 }
    267 
    268 
    269 static inline unsigned
    270 nir_intrinsic_interp_mode(const nir_intrinsic_instr *instr)
    271 {
    272    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    273    assert(info->index_map[NIR_INTRINSIC_INTERP_MODE] > 0);
    274    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_INTERP_MODE] - 1];
    275 }
    276 
    277 static inline void
    278 nir_intrinsic_set_interp_mode(nir_intrinsic_instr *instr, unsigned val)
    279 {
    280    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    281    assert(info->index_map[NIR_INTRINSIC_INTERP_MODE] > 0);
    282    instr->const_index[info->index_map[NIR_INTRINSIC_INTERP_MODE] - 1] = val;
    283 }
    284 
    285 static inline bool
    286 nir_intrinsic_has_interp_mode(const nir_intrinsic_instr *instr)
    287 {
    288    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    289    return info->index_map[NIR_INTRINSIC_INTERP_MODE] > 0;
    290 }
    291 
    292 
    293 static inline unsigned
    294 nir_intrinsic_reduction_op(const nir_intrinsic_instr *instr)
    295 {
    296    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    297    assert(info->index_map[NIR_INTRINSIC_REDUCTION_OP] > 0);
    298    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_REDUCTION_OP] - 1];
    299 }
    300 
    301 static inline void
    302 nir_intrinsic_set_reduction_op(nir_intrinsic_instr *instr, unsigned val)
    303 {
    304    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    305    assert(info->index_map[NIR_INTRINSIC_REDUCTION_OP] > 0);
    306    instr->const_index[info->index_map[NIR_INTRINSIC_REDUCTION_OP] - 1] = val;
    307 }
    308 
    309 static inline bool
    310 nir_intrinsic_has_reduction_op(const nir_intrinsic_instr *instr)
    311 {
    312    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    313    return info->index_map[NIR_INTRINSIC_REDUCTION_OP] > 0;
    314 }
    315 
    316 
    317 static inline unsigned
    318 nir_intrinsic_cluster_size(const nir_intrinsic_instr *instr)
    319 {
    320    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    321    assert(info->index_map[NIR_INTRINSIC_CLUSTER_SIZE] > 0);
    322    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_CLUSTER_SIZE] - 1];
    323 }
    324 
    325 static inline void
    326 nir_intrinsic_set_cluster_size(nir_intrinsic_instr *instr, unsigned val)
    327 {
    328    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    329    assert(info->index_map[NIR_INTRINSIC_CLUSTER_SIZE] > 0);
    330    instr->const_index[info->index_map[NIR_INTRINSIC_CLUSTER_SIZE] - 1] = val;
    331 }
    332 
    333 static inline bool
    334 nir_intrinsic_has_cluster_size(const nir_intrinsic_instr *instr)
    335 {
    336    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    337    return info->index_map[NIR_INTRINSIC_CLUSTER_SIZE] > 0;
    338 }
    339 
    340 
    341 static inline unsigned
    342 nir_intrinsic_param_idx(const nir_intrinsic_instr *instr)
    343 {
    344    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    345    assert(info->index_map[NIR_INTRINSIC_PARAM_IDX] > 0);
    346    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_PARAM_IDX] - 1];
    347 }
    348 
    349 static inline void
    350 nir_intrinsic_set_param_idx(nir_intrinsic_instr *instr, unsigned val)
    351 {
    352    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    353    assert(info->index_map[NIR_INTRINSIC_PARAM_IDX] > 0);
    354    instr->const_index[info->index_map[NIR_INTRINSIC_PARAM_IDX] - 1] = val;
    355 }
    356 
    357 static inline bool
    358 nir_intrinsic_has_param_idx(const nir_intrinsic_instr *instr)
    359 {
    360    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    361    return info->index_map[NIR_INTRINSIC_PARAM_IDX] > 0;
    362 }
    363 
    364 
    365 static inline enum glsl_sampler_dim
    366 nir_intrinsic_image_dim(const nir_intrinsic_instr *instr)
    367 {
    368    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    369    assert(info->index_map[NIR_INTRINSIC_IMAGE_DIM] > 0);
    370    return (enum glsl_sampler_dim)instr->const_index[info->index_map[NIR_INTRINSIC_IMAGE_DIM] - 1];
    371 }
    372 
    373 static inline void
    374 nir_intrinsic_set_image_dim(nir_intrinsic_instr *instr, enum glsl_sampler_dim val)
    375 {
    376    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    377    assert(info->index_map[NIR_INTRINSIC_IMAGE_DIM] > 0);
    378    instr->const_index[info->index_map[NIR_INTRINSIC_IMAGE_DIM] - 1] = val;
    379 }
    380 
    381 static inline bool
    382 nir_intrinsic_has_image_dim(const nir_intrinsic_instr *instr)
    383 {
    384    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    385    return info->index_map[NIR_INTRINSIC_IMAGE_DIM] > 0;
    386 }
    387 
    388 
    389 static inline bool
    390 nir_intrinsic_image_array(const nir_intrinsic_instr *instr)
    391 {
    392    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    393    assert(info->index_map[NIR_INTRINSIC_IMAGE_ARRAY] > 0);
    394    return (bool)instr->const_index[info->index_map[NIR_INTRINSIC_IMAGE_ARRAY] - 1];
    395 }
    396 
    397 static inline void
    398 nir_intrinsic_set_image_array(nir_intrinsic_instr *instr, bool val)
    399 {
    400    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    401    assert(info->index_map[NIR_INTRINSIC_IMAGE_ARRAY] > 0);
    402    instr->const_index[info->index_map[NIR_INTRINSIC_IMAGE_ARRAY] - 1] = val;
    403 }
    404 
    405 static inline bool
    406 nir_intrinsic_has_image_array(const nir_intrinsic_instr *instr)
    407 {
    408    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    409    return info->index_map[NIR_INTRINSIC_IMAGE_ARRAY] > 0;
    410 }
    411 
    412 
    413 static inline enum pipe_format
    414 nir_intrinsic_format(const nir_intrinsic_instr *instr)
    415 {
    416    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    417    assert(info->index_map[NIR_INTRINSIC_FORMAT] > 0);
    418    return (enum pipe_format)instr->const_index[info->index_map[NIR_INTRINSIC_FORMAT] - 1];
    419 }
    420 
    421 static inline void
    422 nir_intrinsic_set_format(nir_intrinsic_instr *instr, enum pipe_format val)
    423 {
    424    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    425    assert(info->index_map[NIR_INTRINSIC_FORMAT] > 0);
    426    instr->const_index[info->index_map[NIR_INTRINSIC_FORMAT] - 1] = val;
    427 }
    428 
    429 static inline bool
    430 nir_intrinsic_has_format(const nir_intrinsic_instr *instr)
    431 {
    432    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    433    return info->index_map[NIR_INTRINSIC_FORMAT] > 0;
    434 }
    435 
    436 
    437 static inline enum gl_access_qualifier
    438 nir_intrinsic_access(const nir_intrinsic_instr *instr)
    439 {
    440    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    441    assert(info->index_map[NIR_INTRINSIC_ACCESS] > 0);
    442    return (enum gl_access_qualifier)instr->const_index[info->index_map[NIR_INTRINSIC_ACCESS] - 1];
    443 }
    444 
    445 static inline void
    446 nir_intrinsic_set_access(nir_intrinsic_instr *instr, enum gl_access_qualifier val)
    447 {
    448    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    449    assert(info->index_map[NIR_INTRINSIC_ACCESS] > 0);
    450    instr->const_index[info->index_map[NIR_INTRINSIC_ACCESS] - 1] = val;
    451 }
    452 
    453 static inline bool
    454 nir_intrinsic_has_access(const nir_intrinsic_instr *instr)
    455 {
    456    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    457    return info->index_map[NIR_INTRINSIC_ACCESS] > 0;
    458 }
    459 
    460 
    461 static inline unsigned
    462 nir_intrinsic_call_idx(const nir_intrinsic_instr *instr)
    463 {
    464    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    465    assert(info->index_map[NIR_INTRINSIC_CALL_IDX] > 0);
    466    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_CALL_IDX] - 1];
    467 }
    468 
    469 static inline void
    470 nir_intrinsic_set_call_idx(nir_intrinsic_instr *instr, unsigned val)
    471 {
    472    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    473    assert(info->index_map[NIR_INTRINSIC_CALL_IDX] > 0);
    474    instr->const_index[info->index_map[NIR_INTRINSIC_CALL_IDX] - 1] = val;
    475 }
    476 
    477 static inline bool
    478 nir_intrinsic_has_call_idx(const nir_intrinsic_instr *instr)
    479 {
    480    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    481    return info->index_map[NIR_INTRINSIC_CALL_IDX] > 0;
    482 }
    483 
    484 
    485 static inline unsigned
    486 nir_intrinsic_stack_size(const nir_intrinsic_instr *instr)
    487 {
    488    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    489    assert(info->index_map[NIR_INTRINSIC_STACK_SIZE] > 0);
    490    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_STACK_SIZE] - 1];
    491 }
    492 
    493 static inline void
    494 nir_intrinsic_set_stack_size(nir_intrinsic_instr *instr, unsigned val)
    495 {
    496    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    497    assert(info->index_map[NIR_INTRINSIC_STACK_SIZE] > 0);
    498    instr->const_index[info->index_map[NIR_INTRINSIC_STACK_SIZE] - 1] = val;
    499 }
    500 
    501 static inline bool
    502 nir_intrinsic_has_stack_size(const nir_intrinsic_instr *instr)
    503 {
    504    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    505    return info->index_map[NIR_INTRINSIC_STACK_SIZE] > 0;
    506 }
    507 
    508 
    509 static inline unsigned
    510 nir_intrinsic_align_mul(const nir_intrinsic_instr *instr)
    511 {
    512    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    513    assert(info->index_map[NIR_INTRINSIC_ALIGN_MUL] > 0);
    514    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_ALIGN_MUL] - 1];
    515 }
    516 
    517 static inline void
    518 nir_intrinsic_set_align_mul(nir_intrinsic_instr *instr, unsigned val)
    519 {
    520    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    521    assert(info->index_map[NIR_INTRINSIC_ALIGN_MUL] > 0);
    522    instr->const_index[info->index_map[NIR_INTRINSIC_ALIGN_MUL] - 1] = val;
    523 }
    524 
    525 static inline bool
    526 nir_intrinsic_has_align_mul(const nir_intrinsic_instr *instr)
    527 {
    528    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    529    return info->index_map[NIR_INTRINSIC_ALIGN_MUL] > 0;
    530 }
    531 
    532 
    533 static inline unsigned
    534 nir_intrinsic_align_offset(const nir_intrinsic_instr *instr)
    535 {
    536    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    537    assert(info->index_map[NIR_INTRINSIC_ALIGN_OFFSET] > 0);
    538    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_ALIGN_OFFSET] - 1];
    539 }
    540 
    541 static inline void
    542 nir_intrinsic_set_align_offset(nir_intrinsic_instr *instr, unsigned val)
    543 {
    544    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    545    assert(info->index_map[NIR_INTRINSIC_ALIGN_OFFSET] > 0);
    546    instr->const_index[info->index_map[NIR_INTRINSIC_ALIGN_OFFSET] - 1] = val;
    547 }
    548 
    549 static inline bool
    550 nir_intrinsic_has_align_offset(const nir_intrinsic_instr *instr)
    551 {
    552    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    553    return info->index_map[NIR_INTRINSIC_ALIGN_OFFSET] > 0;
    554 }
    555 
    556 
    557 static inline unsigned
    558 nir_intrinsic_desc_type(const nir_intrinsic_instr *instr)
    559 {
    560    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    561    assert(info->index_map[NIR_INTRINSIC_DESC_TYPE] > 0);
    562    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_DESC_TYPE] - 1];
    563 }
    564 
    565 static inline void
    566 nir_intrinsic_set_desc_type(nir_intrinsic_instr *instr, unsigned val)
    567 {
    568    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    569    assert(info->index_map[NIR_INTRINSIC_DESC_TYPE] > 0);
    570    instr->const_index[info->index_map[NIR_INTRINSIC_DESC_TYPE] - 1] = val;
    571 }
    572 
    573 static inline bool
    574 nir_intrinsic_has_desc_type(const nir_intrinsic_instr *instr)
    575 {
    576    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    577    return info->index_map[NIR_INTRINSIC_DESC_TYPE] > 0;
    578 }
    579 
    580 
    581 static inline nir_alu_type
    582 nir_intrinsic_src_type(const nir_intrinsic_instr *instr)
    583 {
    584    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    585    assert(info->index_map[NIR_INTRINSIC_SRC_TYPE] > 0);
    586    return (nir_alu_type)instr->const_index[info->index_map[NIR_INTRINSIC_SRC_TYPE] - 1];
    587 }
    588 
    589 static inline void
    590 nir_intrinsic_set_src_type(nir_intrinsic_instr *instr, nir_alu_type val)
    591 {
    592    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    593    assert(info->index_map[NIR_INTRINSIC_SRC_TYPE] > 0);
    594    instr->const_index[info->index_map[NIR_INTRINSIC_SRC_TYPE] - 1] = val;
    595 }
    596 
    597 static inline bool
    598 nir_intrinsic_has_src_type(const nir_intrinsic_instr *instr)
    599 {
    600    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    601    return info->index_map[NIR_INTRINSIC_SRC_TYPE] > 0;
    602 }
    603 
    604 
    605 static inline nir_alu_type
    606 nir_intrinsic_dest_type(const nir_intrinsic_instr *instr)
    607 {
    608    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    609    assert(info->index_map[NIR_INTRINSIC_DEST_TYPE] > 0);
    610    return (nir_alu_type)instr->const_index[info->index_map[NIR_INTRINSIC_DEST_TYPE] - 1];
    611 }
    612 
    613 static inline void
    614 nir_intrinsic_set_dest_type(nir_intrinsic_instr *instr, nir_alu_type val)
    615 {
    616    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    617    assert(info->index_map[NIR_INTRINSIC_DEST_TYPE] > 0);
    618    instr->const_index[info->index_map[NIR_INTRINSIC_DEST_TYPE] - 1] = val;
    619 }
    620 
    621 static inline bool
    622 nir_intrinsic_has_dest_type(const nir_intrinsic_instr *instr)
    623 {
    624    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    625    return info->index_map[NIR_INTRINSIC_DEST_TYPE] > 0;
    626 }
    627 
    628 
    629 static inline unsigned
    630 nir_intrinsic_swizzle_mask(const nir_intrinsic_instr *instr)
    631 {
    632    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    633    assert(info->index_map[NIR_INTRINSIC_SWIZZLE_MASK] > 0);
    634    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_SWIZZLE_MASK] - 1];
    635 }
    636 
    637 static inline void
    638 nir_intrinsic_set_swizzle_mask(nir_intrinsic_instr *instr, unsigned val)
    639 {
    640    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    641    assert(info->index_map[NIR_INTRINSIC_SWIZZLE_MASK] > 0);
    642    instr->const_index[info->index_map[NIR_INTRINSIC_SWIZZLE_MASK] - 1] = val;
    643 }
    644 
    645 static inline bool
    646 nir_intrinsic_has_swizzle_mask(const nir_intrinsic_instr *instr)
    647 {
    648    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    649    return info->index_map[NIR_INTRINSIC_SWIZZLE_MASK] > 0;
    650 }
    651 
    652 
    653 static inline bool
    654 nir_intrinsic_is_swizzled(const nir_intrinsic_instr *instr)
    655 {
    656    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    657    assert(info->index_map[NIR_INTRINSIC_IS_SWIZZLED] > 0);
    658    return (bool)instr->const_index[info->index_map[NIR_INTRINSIC_IS_SWIZZLED] - 1];
    659 }
    660 
    661 static inline void
    662 nir_intrinsic_set_is_swizzled(nir_intrinsic_instr *instr, bool val)
    663 {
    664    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    665    assert(info->index_map[NIR_INTRINSIC_IS_SWIZZLED] > 0);
    666    instr->const_index[info->index_map[NIR_INTRINSIC_IS_SWIZZLED] - 1] = val;
    667 }
    668 
    669 static inline bool
    670 nir_intrinsic_has_is_swizzled(const nir_intrinsic_instr *instr)
    671 {
    672    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    673    return info->index_map[NIR_INTRINSIC_IS_SWIZZLED] > 0;
    674 }
    675 
    676 
    677 static inline bool
    678 nir_intrinsic_slc_amd(const nir_intrinsic_instr *instr)
    679 {
    680    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    681    assert(info->index_map[NIR_INTRINSIC_SLC_AMD] > 0);
    682    return (bool)instr->const_index[info->index_map[NIR_INTRINSIC_SLC_AMD] - 1];
    683 }
    684 
    685 static inline void
    686 nir_intrinsic_set_slc_amd(nir_intrinsic_instr *instr, bool val)
    687 {
    688    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    689    assert(info->index_map[NIR_INTRINSIC_SLC_AMD] > 0);
    690    instr->const_index[info->index_map[NIR_INTRINSIC_SLC_AMD] - 1] = val;
    691 }
    692 
    693 static inline bool
    694 nir_intrinsic_has_slc_amd(const nir_intrinsic_instr *instr)
    695 {
    696    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    697    return info->index_map[NIR_INTRINSIC_SLC_AMD] > 0;
    698 }
    699 
    700 
    701 static inline enum gl_access_qualifier
    702 nir_intrinsic_dst_access(const nir_intrinsic_instr *instr)
    703 {
    704    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    705    assert(info->index_map[NIR_INTRINSIC_DST_ACCESS] > 0);
    706    return (enum gl_access_qualifier)instr->const_index[info->index_map[NIR_INTRINSIC_DST_ACCESS] - 1];
    707 }
    708 
    709 static inline void
    710 nir_intrinsic_set_dst_access(nir_intrinsic_instr *instr, enum gl_access_qualifier val)
    711 {
    712    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    713    assert(info->index_map[NIR_INTRINSIC_DST_ACCESS] > 0);
    714    instr->const_index[info->index_map[NIR_INTRINSIC_DST_ACCESS] - 1] = val;
    715 }
    716 
    717 static inline bool
    718 nir_intrinsic_has_dst_access(const nir_intrinsic_instr *instr)
    719 {
    720    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    721    return info->index_map[NIR_INTRINSIC_DST_ACCESS] > 0;
    722 }
    723 
    724 
    725 static inline enum gl_access_qualifier
    726 nir_intrinsic_src_access(const nir_intrinsic_instr *instr)
    727 {
    728    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    729    assert(info->index_map[NIR_INTRINSIC_SRC_ACCESS] > 0);
    730    return (enum gl_access_qualifier)instr->const_index[info->index_map[NIR_INTRINSIC_SRC_ACCESS] - 1];
    731 }
    732 
    733 static inline void
    734 nir_intrinsic_set_src_access(nir_intrinsic_instr *instr, enum gl_access_qualifier val)
    735 {
    736    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    737    assert(info->index_map[NIR_INTRINSIC_SRC_ACCESS] > 0);
    738    instr->const_index[info->index_map[NIR_INTRINSIC_SRC_ACCESS] - 1] = val;
    739 }
    740 
    741 static inline bool
    742 nir_intrinsic_has_src_access(const nir_intrinsic_instr *instr)
    743 {
    744    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    745    return info->index_map[NIR_INTRINSIC_SRC_ACCESS] > 0;
    746 }
    747 
    748 
    749 static inline unsigned
    750 nir_intrinsic_driver_location(const nir_intrinsic_instr *instr)
    751 {
    752    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    753    assert(info->index_map[NIR_INTRINSIC_DRIVER_LOCATION] > 0);
    754    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_DRIVER_LOCATION] - 1];
    755 }
    756 
    757 static inline void
    758 nir_intrinsic_set_driver_location(nir_intrinsic_instr *instr, unsigned val)
    759 {
    760    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    761    assert(info->index_map[NIR_INTRINSIC_DRIVER_LOCATION] > 0);
    762    instr->const_index[info->index_map[NIR_INTRINSIC_DRIVER_LOCATION] - 1] = val;
    763 }
    764 
    765 static inline bool
    766 nir_intrinsic_has_driver_location(const nir_intrinsic_instr *instr)
    767 {
    768    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    769    return info->index_map[NIR_INTRINSIC_DRIVER_LOCATION] > 0;
    770 }
    771 
    772 
    773 static inline nir_memory_semantics
    774 nir_intrinsic_memory_semantics(const nir_intrinsic_instr *instr)
    775 {
    776    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    777    assert(info->index_map[NIR_INTRINSIC_MEMORY_SEMANTICS] > 0);
    778    return (nir_memory_semantics)instr->const_index[info->index_map[NIR_INTRINSIC_MEMORY_SEMANTICS] - 1];
    779 }
    780 
    781 static inline void
    782 nir_intrinsic_set_memory_semantics(nir_intrinsic_instr *instr, nir_memory_semantics val)
    783 {
    784    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    785    assert(info->index_map[NIR_INTRINSIC_MEMORY_SEMANTICS] > 0);
    786    instr->const_index[info->index_map[NIR_INTRINSIC_MEMORY_SEMANTICS] - 1] = val;
    787 }
    788 
    789 static inline bool
    790 nir_intrinsic_has_memory_semantics(const nir_intrinsic_instr *instr)
    791 {
    792    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    793    return info->index_map[NIR_INTRINSIC_MEMORY_SEMANTICS] > 0;
    794 }
    795 
    796 
    797 static inline nir_variable_mode
    798 nir_intrinsic_memory_modes(const nir_intrinsic_instr *instr)
    799 {
    800    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    801    assert(info->index_map[NIR_INTRINSIC_MEMORY_MODES] > 0);
    802    return (nir_variable_mode)instr->const_index[info->index_map[NIR_INTRINSIC_MEMORY_MODES] - 1];
    803 }
    804 
    805 static inline void
    806 nir_intrinsic_set_memory_modes(nir_intrinsic_instr *instr, nir_variable_mode val)
    807 {
    808    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    809    assert(info->index_map[NIR_INTRINSIC_MEMORY_MODES] > 0);
    810    instr->const_index[info->index_map[NIR_INTRINSIC_MEMORY_MODES] - 1] = val;
    811 }
    812 
    813 static inline bool
    814 nir_intrinsic_has_memory_modes(const nir_intrinsic_instr *instr)
    815 {
    816    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    817    return info->index_map[NIR_INTRINSIC_MEMORY_MODES] > 0;
    818 }
    819 
    820 
    821 static inline nir_scope
    822 nir_intrinsic_memory_scope(const nir_intrinsic_instr *instr)
    823 {
    824    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    825    assert(info->index_map[NIR_INTRINSIC_MEMORY_SCOPE] > 0);
    826    return (nir_scope)instr->const_index[info->index_map[NIR_INTRINSIC_MEMORY_SCOPE] - 1];
    827 }
    828 
    829 static inline void
    830 nir_intrinsic_set_memory_scope(nir_intrinsic_instr *instr, nir_scope val)
    831 {
    832    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    833    assert(info->index_map[NIR_INTRINSIC_MEMORY_SCOPE] > 0);
    834    instr->const_index[info->index_map[NIR_INTRINSIC_MEMORY_SCOPE] - 1] = val;
    835 }
    836 
    837 static inline bool
    838 nir_intrinsic_has_memory_scope(const nir_intrinsic_instr *instr)
    839 {
    840    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    841    return info->index_map[NIR_INTRINSIC_MEMORY_SCOPE] > 0;
    842 }
    843 
    844 
    845 static inline nir_scope
    846 nir_intrinsic_execution_scope(const nir_intrinsic_instr *instr)
    847 {
    848    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    849    assert(info->index_map[NIR_INTRINSIC_EXECUTION_SCOPE] > 0);
    850    return (nir_scope)instr->const_index[info->index_map[NIR_INTRINSIC_EXECUTION_SCOPE] - 1];
    851 }
    852 
    853 static inline void
    854 nir_intrinsic_set_execution_scope(nir_intrinsic_instr *instr, nir_scope val)
    855 {
    856    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    857    assert(info->index_map[NIR_INTRINSIC_EXECUTION_SCOPE] > 0);
    858    instr->const_index[info->index_map[NIR_INTRINSIC_EXECUTION_SCOPE] - 1] = val;
    859 }
    860 
    861 static inline bool
    862 nir_intrinsic_has_execution_scope(const nir_intrinsic_instr *instr)
    863 {
    864    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    865    return info->index_map[NIR_INTRINSIC_EXECUTION_SCOPE] > 0;
    866 }
    867 
    868 
    869 static inline struct nir_io_semantics
    870 nir_intrinsic_io_semantics(const nir_intrinsic_instr *instr)
    871 {
    872    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    873    assert(info->index_map[NIR_INTRINSIC_IO_SEMANTICS] > 0);
    874    struct nir_io_semantics res;
    875    STATIC_ASSERT(sizeof(instr->const_index[0]) == sizeof(res));
    876    memcpy(&res, &instr->const_index[info->index_map[NIR_INTRINSIC_IO_SEMANTICS] - 1], sizeof(res));
    877    return res;
    878 }
    879 
    880 static inline void
    881 nir_intrinsic_set_io_semantics(nir_intrinsic_instr *instr, struct nir_io_semantics val)
    882 {
    883    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    884    assert(info->index_map[NIR_INTRINSIC_IO_SEMANTICS] > 0);
    885    val._pad = 0; /* clear padding bits */
    886    STATIC_ASSERT(sizeof(instr->const_index[0]) == sizeof(val));
    887    memcpy(&instr->const_index[info->index_map[NIR_INTRINSIC_IO_SEMANTICS] - 1], &val, sizeof(val));
    888 }
    889 
    890 static inline bool
    891 nir_intrinsic_has_io_semantics(const nir_intrinsic_instr *instr)
    892 {
    893    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    894    return info->index_map[NIR_INTRINSIC_IO_SEMANTICS] > 0;
    895 }
    896 
    897 
    898 static inline nir_rounding_mode
    899 nir_intrinsic_rounding_mode(const nir_intrinsic_instr *instr)
    900 {
    901    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    902    assert(info->index_map[NIR_INTRINSIC_ROUNDING_MODE] > 0);
    903    return (nir_rounding_mode)instr->const_index[info->index_map[NIR_INTRINSIC_ROUNDING_MODE] - 1];
    904 }
    905 
    906 static inline void
    907 nir_intrinsic_set_rounding_mode(nir_intrinsic_instr *instr, nir_rounding_mode val)
    908 {
    909    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    910    assert(info->index_map[NIR_INTRINSIC_ROUNDING_MODE] > 0);
    911    instr->const_index[info->index_map[NIR_INTRINSIC_ROUNDING_MODE] - 1] = val;
    912 }
    913 
    914 static inline bool
    915 nir_intrinsic_has_rounding_mode(const nir_intrinsic_instr *instr)
    916 {
    917    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    918    return info->index_map[NIR_INTRINSIC_ROUNDING_MODE] > 0;
    919 }
    920 
    921 
    922 static inline unsigned
    923 nir_intrinsic_saturate(const nir_intrinsic_instr *instr)
    924 {
    925    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    926    assert(info->index_map[NIR_INTRINSIC_SATURATE] > 0);
    927    return (unsigned)instr->const_index[info->index_map[NIR_INTRINSIC_SATURATE] - 1];
    928 }
    929 
    930 static inline void
    931 nir_intrinsic_set_saturate(nir_intrinsic_instr *instr, unsigned val)
    932 {
    933    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    934    assert(info->index_map[NIR_INTRINSIC_SATURATE] > 0);
    935    instr->const_index[info->index_map[NIR_INTRINSIC_SATURATE] - 1] = val;
    936 }
    937 
    938 static inline bool
    939 nir_intrinsic_has_saturate(const nir_intrinsic_instr *instr)
    940 {
    941    const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
    942    return info->index_map[NIR_INTRINSIC_SATURATE] > 0;
    943 }
    944 
    945 #endif /* _NIR_INTRINSICS_INDICES_ */