Lines Matching refs:instr
193 list_for_each_entry_safe(nir_instr, instr, &shader->gc_list, gc_node) {
194 nir_instr_free(instr);
660 instr_init(nir_instr *instr, nir_instr_type type)
662 instr->type = type;
663 instr->block = NULL;
664 exec_node_init(&instr->node);
698 nir_alu_instr *instr = calloc(1, sizeof(nir_alu_instr) + num_srcs * sizeof(nir_alu_src));
700 instr_init(&instr->instr, nir_instr_type_alu);
701 instr->op = op;
702 alu_dest_init(&instr->dest);
704 alu_src_init(&instr->src[i]);
706 list_add(&instr->instr.gc_node, &shader->gc_list);
708 return instr;
714 nir_deref_instr *instr = calloc(1, sizeof(*instr));
716 instr_init(&instr->instr, nir_instr_type_deref);
718 instr->deref_type = deref_type;
720 src_init(&instr->parent);
724 src_init(&instr->arr.index);
726 dest_init(&instr->dest);
728 list_add(&instr->instr.gc_node, &shader->gc_list);
730 return instr;
736 nir_jump_instr *instr = malloc(sizeof(*instr));
737 instr_init(&instr->instr, nir_instr_type_jump);
738 src_init(&instr->condition);
739 instr->type = type;
740 instr->target = NULL;
741 instr->else_target = NULL;
743 list_add(&instr->instr.gc_node, &shader->gc_list);
745 return instr;
752 nir_load_const_instr *instr =
753 calloc(1, sizeof(*instr) + num_components * sizeof(*instr->value));
754 instr_init(&instr->instr, nir_instr_type_load_const);
756 nir_ssa_def_init(&instr->instr, &instr->def, num_components, bit_size);
758 list_add(&instr->instr.gc_node, &shader->gc_list);
760 return instr;
768 nir_intrinsic_instr *instr =
771 instr_init(&instr->instr, nir_instr_type_intrinsic);
772 instr->intrinsic = op;
775 dest_init(&instr->dest);
778 src_init(&instr->src[i]);
780 list_add(&instr->instr.gc_node, &shader->gc_list);
782 return instr;
789 nir_call_instr *instr =
790 calloc(1, sizeof(*instr) + num_params * sizeof(instr->params[0]));
792 instr_init(&instr->instr, nir_instr_type_call);
793 instr->callee = callee;
794 instr->num_params = num_params;
796 src_init(&instr->params[i]);
798 list_add(&instr->instr.gc_node, &shader->gc_list);
800 return instr;
814 nir_tex_instr *instr = calloc(1, sizeof(*instr));
815 instr_init(&instr->instr, nir_instr_type_tex);
817 dest_init(&instr->dest);
819 instr->num_srcs = num_srcs;
820 instr->src = malloc(sizeof(nir_tex_src) * num_srcs);
822 src_init(&instr->src[i].src);
824 instr->texture_index = 0;
825 instr->sampler_index = 0;
826 memcpy(instr->tg4_offsets, default_tg4_offsets, sizeof(instr->tg4_offsets));
828 list_add(&instr->instr.gc_node, &shader->gc_list);
830 return instr;
843 nir_instr_move_src(&tex->instr, &new_srcs[i].src,
851 nir_instr_rewrite_src(&tex->instr, &tex->src[tex->num_srcs].src, src);
861 nir_instr_rewrite_src(&tex->instr, &tex->src[src_idx].src, NIR_SRC_INIT);
866 nir_instr_move_src(&tex->instr, &tex->src[i-1].src, &tex->src[i].src);
883 nir_phi_instr *instr = malloc(sizeof(*instr));
884 instr_init(&instr->instr, nir_instr_type_phi);
886 dest_init(&instr->dest);
887 exec_list_make_empty(&instr->srcs);
889 list_add(&instr->instr.gc_node, &shader->gc_list);
891 return instr;
898 * that the instr is not in the shader. If it is, you have to do:
903 nir_phi_instr_add_src(nir_phi_instr *instr, nir_block *pred, nir_src src)
910 phi_src->src.parent_instr = &instr->instr;
911 exec_list_push_tail(&instr->srcs, &phi_src->node);
919 nir_parallel_copy_instr *instr = malloc(sizeof(*instr));
920 instr_init(&instr->instr, nir_instr_type_parallel_copy);
922 exec_list_make_empty(&instr->entries);
924 list_add(&instr->instr.gc_node, &shader->gc_list);
926 return instr;
934 nir_ssa_undef_instr *instr = malloc(sizeof(*instr));
935 instr_init(&instr->instr, nir_instr_type_ssa_undef);
937 nir_ssa_def_init(&instr->instr, &instr->def, num_components, bit_size);
939 list_add(&instr->instr.gc_node, &shader->gc_list);
941 return instr;
1041 nir_instr *prev_instr = nir_instr_prev(cursor.instr);
1044 cursor.instr = prev_instr;
1048 cursor.block = cursor.instr->block;
1055 if (nir_instr_next(cursor.instr) == NULL) {
1058 cursor.block = cursor.instr->block;
1080 nir_instr *instr = state;
1082 src->parent_instr = instr;
1092 nir_instr *instr = state;
1094 if (instr->block && def->index == UINT_MAX) {
1096 nir_cf_node_get_function(&instr->block->cf_node);
1109 nir_instr *instr = state;
1112 dest->reg.parent_instr = instr;
1120 add_defs_uses(nir_instr *instr)
1122 nir_foreach_src(instr, add_use_cb, instr);
1123 nir_foreach_dest(instr, add_reg_def_cb, instr);
1124 nir_foreach_ssa_def(instr, add_ssa_def_cb, instr);
1128 nir_instr_insert(nir_cursor cursor, nir_instr *instr)
1133 if (instr->type == nir_instr_type_jump)
1136 instr->block = cursor.block;
1137 add_defs_uses(instr);
1138 exec_list_push_head(&cursor.block->instr_list, &instr->node);
1146 instr->block = cursor.block;
1147 add_defs_uses(instr);
1148 exec_list_push_tail(&cursor.block->instr_list, &instr->node);
1152 assert(instr->type != nir_instr_type_jump);
1153 instr->block = cursor.instr->block;
1154 add_defs_uses(instr);
1155 exec_node_insert_node_before(&cursor.instr->node, &instr->node);
1159 assert(cursor.instr->type != nir_instr_type_jump);
1162 if (instr->type == nir_instr_type_jump)
1163 assert(cursor.instr == nir_block_last_instr(cursor.instr->block));
1165 instr->block = cursor.instr->block;
1166 add_defs_uses(instr);
1167 exec_node_insert_after(&cursor.instr->node, &instr->node);
1171 if (instr->type == nir_instr_type_jump)
1172 nir_handle_add_jump(instr->block);
1174 nir_function_impl *impl = nir_cf_node_get_function(&instr->block->cf_node);
1179 nir_instr_move(nir_cursor cursor, nir_instr *instr)
1186 cursor.instr == instr)
1189 nir_instr_remove(instr);
1190 nir_instr_insert(cursor, instr);
1223 remove_defs_uses(nir_instr *instr)
1225 nir_foreach_dest(instr, remove_def_cb, instr);
1226 nir_foreach_src(instr, remove_use_cb, instr);
1229 void nir_instr_remove_v(nir_instr *instr)
1231 remove_defs_uses(instr);
1232 exec_node_remove(&instr->node);
1234 if (instr->type == nir_instr_type_jump) {
1235 nir_jump_instr *jump_instr = nir_instr_as_jump(instr);
1236 nir_handle_remove_jump(instr->block, jump_instr->type);
1252 void nir_instr_free(nir_instr *instr)
1254 nir_foreach_src(instr, free_src_indirects_cb, NULL);
1255 nir_foreach_dest(instr, free_dest_indirects_cb, NULL);
1257 switch (instr->type) {
1259 free(nir_instr_as_tex(instr)->src);
1263 nir_phi_instr *phi = nir_instr_as_phi(instr);
1274 list_del(&instr->gc_node);
1275 free(instr);
1300 static bool nir_instr_free_and_dce_is_live(nir_instr *instr)
1305 if (instr->type == nir_instr_type_intrinsic) {
1306 nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
1313 nir_foreach_ssa_def(instr, nir_instr_free_and_dce_live_cb, &live);
1335 nir_instr_dce_add_dead_ssa_srcs(nir_instr_worklist *wl, nir_instr *instr)
1337 nir_foreach_src(instr, nir_instr_dce_add_dead_srcs_cb, wl);
1345 nir_instr_free_and_dce(nir_instr *instr)
1349 nir_instr_dce_add_dead_ssa_srcs(worklist, instr);
1350 nir_cursor c = nir_instr_remove(instr);
1359 /* If we're removing the instr where our cursor is, then we have to
1364 c.instr == dce_instr)
1407 nir_foreach_ssa_def(nir_instr *instr, nir_foreach_ssa_def_cb cb, void *state)
1409 switch (instr->type) {
1417 return nir_foreach_dest(instr, nir_ssa_def_visitor, &foreach_state);
1421 return cb(&nir_instr_as_load_const(instr)->def, state);
1423 return cb(&nir_instr_as_ssa_undef(instr)->def, state);
1433 nir_instr_ssa_def(nir_instr *instr)
1435 switch (instr->type) {
1437 assert(nir_instr_as_alu(instr)->dest.dest.is_ssa);
1438 return &nir_instr_as_alu(instr)->dest.dest.ssa;
1441 assert(nir_instr_as_deref(instr)->dest.is_ssa);
1442 return &nir_instr_as_deref(instr)->dest.ssa;
1445 assert(nir_instr_as_tex(instr)->dest.is_ssa);
1446 return &nir_instr_as_tex(instr)->dest.ssa;
1449 nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
1459 assert(nir_instr_as_phi(instr)->dest.is_ssa);
1460 return &nir_instr_as_phi(instr)->dest.ssa;
1466 return &nir_instr_as_load_const(instr)->def;
1469 return &nir_instr_as_ssa_undef(instr)->def;
1480 nir_instr_def_is_register(nir_instr *instr)
1482 switch (instr->type) {
1484 return !nir_instr_as_alu(instr)->dest.dest.is_ssa;
1487 return !nir_instr_as_deref(instr)->dest.is_ssa;
1490 return !nir_instr_as_tex(instr)->dest.is_ssa;
1493 nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
1499 return !nir_instr_as_phi(instr)->dest.is_ssa;
1525 nir_foreach_instr(instr, block->successors[i]) {
1526 if (instr->type != nir_instr_type_phi)
1529 nir_phi_instr *phi = nir_instr_as_phi(instr);
1678 nir_instr_rewrite_src(nir_instr *instr, nir_src *src, nir_src new_src)
1680 assert(!src_is_valid(src) || src->parent_instr == instr);
1684 src_add_all_uses(src, instr, NULL);
1712 nir_instr_rewrite_dest(nir_instr *instr, nir_dest *dest, nir_dest new_dest)
1728 dest->reg.parent_instr = instr;
1732 src_add_all_uses(dest->reg.indirect, instr, NULL);
1737 nir_ssa_def_init(nir_instr *instr, nir_ssa_def *def,
1741 def->parent_instr = instr;
1748 if (instr->block) {
1750 nir_cf_node_get_function(&instr->block->cf_node);
1762 nir_ssa_dest_init(nir_instr *instr, nir_dest *dest,
1767 nir_ssa_def_init(instr, &dest->ssa, num_components, bit_size);
2170 nir_foreach_instr(instr, block)
2171 nir_foreach_ssa_def(instr, index_ssa_def_cb, &index);
2189 nir_foreach_instr(instr, block)
2190 instr->index = index++;
2223 nir_instr *instr = nir_block_first_instr(block);
2224 if (instr)
2225 return instr;
2238 return cursor.instr;
2241 if (nir_instr_next(cursor.instr))
2242 return nir_instr_next(cursor.instr);
2245 cursor.block = cursor.instr->block;
2273 nir_instr *instr;
2274 while ((instr = cursor_next_instr(iter)) != NULL) {
2275 if (filter && !filter(instr, cb_data)) {
2276 iter = nir_after_instr(instr);
2280 assert(nir_foreach_dest(instr, dest_is_ssa, NULL));
2281 nir_ssa_def *old_def = nir_instr_ssa_def(instr);
2284 /* We're about to ask the callback to generate a replacement for instr.
2285 * Save off the uses from instr's SSA def so we know what uses to
2287 * case where the generated replacement code uses the result of instr
2291 * where the replacement is something consumed by instr, and suffers
2302 b.cursor = nir_after_instr(instr);
2303 nir_ssa_def *new_def = lower(&b, instr, cb_data);
2307 if (new_def->parent_instr->block != instr->block)
2318 iter = nir_instr_free_and_dce(instr);
2320 iter = nir_after_instr(instr);
2332 iter = nir_instr_free_and_dce(instr);
2335 iter = nir_after_instr(instr);
2774 nir_instr_rewrite_src(&intrin->instr, &intrin->src[0],
2779 nir_image_intrinsic_coord_components(const nir_intrinsic_instr *instr)
2781 enum glsl_sampler_dim dim = nir_intrinsic_image_dim(instr);
2786 return coords + nir_intrinsic_image_array(instr);
2925 nir_alu_instr_is_copy(nir_alu_instr *instr)
2927 assert(instr->src[0].src.is_ssa);
2929 if (instr->op == nir_op_mov) {
2930 return !instr->dest.saturate &&
2931 !instr->src[0].abs &&
2932 !instr->src[0].negate;
2933 } else if (nir_op_is_vec(instr->op)) {
2934 for (unsigned i = 0; i < instr->dest.dest.ssa.num_components; i++) {
2935 if (instr->src[i].abs || instr->src[i].negate)
2938 return !instr->dest.saturate;
3087 nir_alu_instr_channel_used(const nir_alu_instr *instr, unsigned src,
3090 if (nir_op_infos[instr->op].input_sizes[src] > 0)
3091 return channel < nir_op_infos[instr->op].input_sizes[src];
3093 return (instr->dest.write_mask >> channel) & 1;
3097 nir_alu_instr_src_read_mask(const nir_alu_instr *instr, unsigned src)
3101 if (!nir_alu_instr_channel_used(instr, src, c))
3104 read_mask |= (1 << instr->src[src].swizzle[c]);
3110 nir_ssa_alu_instr_src_components(const nir_alu_instr *instr, unsigned src)
3112 if (nir_op_infos[instr->op].input_sizes[src] > 0)
3113 return nir_op_infos[instr->op].input_sizes[src];
3115 return nir_dest_num_components(instr->dest.dest);
3125 nir_alu_instr_is_comparison(const nir_alu_instr *instr)
3127 switch (instr->op) {
3209 nir_tex_instr_need_sampler(const nir_tex_instr *instr)
3211 switch (instr->op) {
3225 nir_tex_instr_result_size(const nir_tex_instr *instr)
3227 switch (instr->op) {
3230 switch (instr->sampler_dim) {
3249 if (instr->is_array)
3264 if (instr->is_shadow && instr->is_new_style_shadow)
3272 nir_tex_instr_is_query(const nir_tex_instr *instr)
3274 switch (instr->op) {
3296 nir_tex_instr_has_implicit_derivative(const nir_tex_instr *instr)
3298 switch (instr->op) {
3309 nir_tex_instr_src_type(const nir_tex_instr *instr, unsigned src)
3311 switch (instr->src[src].src_type) {
3313 switch (instr->op) {
3328 switch (instr->op) {
3372 nir_tex_instr_src_size(const nir_tex_instr *instr, unsigned src)
3374 if (instr->src[src].src_type == nir_tex_src_coord)
3375 return instr->coord_components;
3378 if (instr->src[src].src_type == nir_tex_src_ms_mcs_intel)
3381 if (instr->src[src].src_type == nir_tex_src_ddx ||
3382 instr->src[src].src_type == nir_tex_src_ddy) {
3384 if (instr->is_array && !instr->array_is_lowered_cube)
3385 return instr->coord_components - 1;
3387 return instr->coord_components;
3390 if (instr->src[src].src_type == nir_tex_src_offset) {
3391 if (instr->is_array)
3392 return instr->coord_components - 1;
3394 return instr->coord_components;
3397 if (instr->src[src].src_type == nir_tex_src_backend1 ||
3398 instr->src[src].src_type == nir_tex_src_backend2)
3399 return nir_src_num_components(instr->src[src].src);
3402 if (instr->src[src].src_type == nir_tex_src_texture_handle ||
3403 instr->src[src].src_type == nir_tex_src_sampler_handle)
3414 nir_instr_xfb_write_mask(nir_intrinsic_instr *instr)
3418 if (nir_intrinsic_has_io_xfb(instr)) {
3419 unsigned wr_mask = nir_intrinsic_write_mask(instr) <<
3420 nir_intrinsic_component(instr);
3426 nir_io_xfb xfb = i < 2 ? nir_intrinsic_io_xfb(instr) :
3427 nir_intrinsic_io_xfb2(instr);
3511 nir_instr_remove(&intr->instr);
3529 nir_instr_remove(&intr->instr);