freedreno/ir3: pass variant to postsched
[mesa.git] / src / freedreno / ir3 / ir3_context.c
1 /*
2 * Copyright (C) 2015-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_compiler.h"
28 #include "ir3_context.h"
29 #include "ir3_image.h"
30 #include "ir3_shader.h"
31 #include "ir3_nir.h"
32
33 struct ir3_context *
34 ir3_context_init(struct ir3_compiler *compiler,
35 struct ir3_shader_variant *so)
36 {
37 struct ir3_context *ctx = rzalloc(NULL, struct ir3_context);
38
39 if (compiler->gpu_id >= 400) {
40 if (so->type == MESA_SHADER_VERTEX) {
41 ctx->astc_srgb = so->key.vastc_srgb;
42 } else if (so->type == MESA_SHADER_FRAGMENT) {
43 ctx->astc_srgb = so->key.fastc_srgb;
44 }
45
46 } else {
47 if (so->type == MESA_SHADER_VERTEX) {
48 ctx->samples = so->key.vsamples;
49 } else if (so->type == MESA_SHADER_FRAGMENT) {
50 ctx->samples = so->key.fsamples;
51 }
52 }
53
54 if (compiler->gpu_id >= 600) {
55 ctx->funcs = &ir3_a6xx_funcs;
56 } else if (compiler->gpu_id >= 400) {
57 ctx->funcs = &ir3_a4xx_funcs;
58 }
59
60 ctx->compiler = compiler;
61 ctx->so = so;
62 ctx->def_ht = _mesa_hash_table_create(ctx,
63 _mesa_hash_pointer, _mesa_key_pointer_equal);
64 ctx->block_ht = _mesa_hash_table_create(ctx,
65 _mesa_hash_pointer, _mesa_key_pointer_equal);
66 ctx->sel_cond_conversions = _mesa_hash_table_create(ctx,
67 _mesa_hash_pointer, _mesa_key_pointer_equal);
68
69 /* TODO: maybe generate some sort of bitmask of what key
70 * lowers vs what shader has (ie. no need to lower
71 * texture clamp lowering if no texture sample instrs)..
72 * although should be done further up the stack to avoid
73 * creating duplicate variants..
74 */
75
76 ctx->s = nir_shader_clone(ctx, so->shader->nir);
77 if (ir3_key_lowers_nir(&so->key))
78 ir3_optimize_nir(so->shader, ctx->s, &so->key);
79
80 /* this needs to be the last pass run, so do this here instead of
81 * in ir3_optimize_nir():
82 */
83 bool progress = false;
84 NIR_PASS(progress, ctx->s, nir_lower_locals_to_regs);
85
86 /* we could need cleanup after lower_locals_to_regs */
87 while (progress) {
88 progress = false;
89 NIR_PASS(progress, ctx->s, nir_opt_algebraic);
90 NIR_PASS(progress, ctx->s, nir_opt_constant_folding);
91 }
92
93 /* We want to lower nir_op_imul as late as possible, to catch also
94 * those generated by earlier passes (e.g, nir_lower_locals_to_regs).
95 * However, we want a final swing of a few passes to have a chance
96 * at optimizing the result.
97 */
98 progress = false;
99 NIR_PASS(progress, ctx->s, ir3_nir_lower_imul);
100 while (progress) {
101 progress = false;
102 NIR_PASS(progress, ctx->s, nir_opt_algebraic);
103 NIR_PASS(progress, ctx->s, nir_opt_copy_prop_vars);
104 NIR_PASS(progress, ctx->s, nir_opt_dead_write_vars);
105 NIR_PASS(progress, ctx->s, nir_opt_dce);
106 NIR_PASS(progress, ctx->s, nir_opt_constant_folding);
107 }
108
109 /* Enable the texture pre-fetch feature only a4xx onwards. But
110 * only enable it on generations that have been tested:
111 */
112 if ((so->type == MESA_SHADER_FRAGMENT) && (compiler->gpu_id >= 600))
113 NIR_PASS_V(ctx->s, ir3_nir_lower_tex_prefetch);
114
115 NIR_PASS_V(ctx->s, nir_convert_from_ssa, true);
116
117 /* Super crude heuristic to limit # of tex prefetch in small
118 * shaders. This completely ignores loops.. but that's really
119 * not the worst of it's problems. (A frag shader that has
120 * loops is probably going to be big enough to not trigger a
121 * lower threshold.)
122 *
123 * 1) probably want to do this in terms of ir3 instructions
124 * 2) probably really want to decide this after scheduling
125 * (or at least pre-RA sched) so we have a rough idea about
126 * nops, and don't count things that get cp'd away
127 * 3) blob seems to use higher thresholds with a mix of more
128 * SFU instructions. Which partly makes sense, more SFU
129 * instructions probably means you want to get the real
130 * shader started sooner, but that considers where in the
131 * shader the SFU instructions are, which blob doesn't seem
132 * to do.
133 *
134 * This uses more conservative thresholds assuming a more alu
135 * than sfu heavy instruction mix.
136 */
137 if (so->type == MESA_SHADER_FRAGMENT) {
138 nir_function_impl *fxn = nir_shader_get_entrypoint(ctx->s);
139
140 unsigned instruction_count = 0;
141 nir_foreach_block (block, fxn) {
142 instruction_count += exec_list_length(&block->instr_list);
143 }
144
145 if (instruction_count < 50) {
146 ctx->prefetch_limit = 2;
147 } else if (instruction_count < 70) {
148 ctx->prefetch_limit = 3;
149 } else {
150 ctx->prefetch_limit = IR3_MAX_SAMPLER_PREFETCH;
151 }
152 }
153
154 if (shader_debug_enabled(so->type)) {
155 fprintf(stdout, "NIR (final form) for %s shader %s:\n",
156 ir3_shader_stage(so), so->shader->nir->info.name);
157 nir_print_shader(ctx->s, stdout);
158 }
159
160 ir3_ibo_mapping_init(&so->image_mapping, ctx->s->info.num_textures);
161
162 return ctx;
163 }
164
165 void
166 ir3_context_free(struct ir3_context *ctx)
167 {
168 ralloc_free(ctx);
169 }
170
171 /*
172 * Misc helpers
173 */
174
175 /* allocate a n element value array (to be populated by caller) and
176 * insert in def_ht
177 */
178 struct ir3_instruction **
179 ir3_get_dst_ssa(struct ir3_context *ctx, nir_ssa_def *dst, unsigned n)
180 {
181 struct ir3_instruction **value =
182 ralloc_array(ctx->def_ht, struct ir3_instruction *, n);
183 _mesa_hash_table_insert(ctx->def_ht, dst, value);
184 return value;
185 }
186
187 struct ir3_instruction **
188 ir3_get_dst(struct ir3_context *ctx, nir_dest *dst, unsigned n)
189 {
190 struct ir3_instruction **value;
191
192 if (dst->is_ssa) {
193 value = ir3_get_dst_ssa(ctx, &dst->ssa, n);
194 } else {
195 value = ralloc_array(ctx, struct ir3_instruction *, n);
196 }
197
198 /* NOTE: in non-ssa case, we don't really need to store last_dst
199 * but this helps us catch cases where put_dst() call is forgotten
200 */
201 compile_assert(ctx, !ctx->last_dst);
202 ctx->last_dst = value;
203 ctx->last_dst_n = n;
204
205 return value;
206 }
207
208 struct ir3_instruction * const *
209 ir3_get_src(struct ir3_context *ctx, nir_src *src)
210 {
211 if (src->is_ssa) {
212 struct hash_entry *entry;
213 entry = _mesa_hash_table_search(ctx->def_ht, src->ssa);
214 compile_assert(ctx, entry);
215 return entry->data;
216 } else {
217 nir_register *reg = src->reg.reg;
218 struct ir3_array *arr = ir3_get_array(ctx, reg);
219 unsigned num_components = arr->r->num_components;
220 struct ir3_instruction *addr = NULL;
221 struct ir3_instruction **value =
222 ralloc_array(ctx, struct ir3_instruction *, num_components);
223
224 if (src->reg.indirect)
225 addr = ir3_get_addr0(ctx, ir3_get_src(ctx, src->reg.indirect)[0],
226 reg->num_components);
227
228 for (unsigned i = 0; i < num_components; i++) {
229 unsigned n = src->reg.base_offset * reg->num_components + i;
230 compile_assert(ctx, n < arr->length);
231 value[i] = ir3_create_array_load(ctx, arr, n, addr, reg->bit_size);
232 }
233
234 return value;
235 }
236 }
237
238 void
239 ir3_put_dst(struct ir3_context *ctx, nir_dest *dst)
240 {
241 unsigned bit_size = nir_dest_bit_size(*dst);
242
243 /* add extra mov if dst value is HIGH reg.. in some cases not all
244 * instructions can read from HIGH regs, in cases where they can
245 * ir3_cp will clean up the extra mov:
246 */
247 for (unsigned i = 0; i < ctx->last_dst_n; i++) {
248 if (!ctx->last_dst[i])
249 continue;
250 if (ctx->last_dst[i]->regs[0]->flags & IR3_REG_HIGH) {
251 ctx->last_dst[i] = ir3_MOV(ctx->block, ctx->last_dst[i], TYPE_U32);
252 }
253 }
254
255 /* Note: 1-bit bools are stored in 32-bit regs */
256 if (bit_size == 16) {
257 for (unsigned i = 0; i < ctx->last_dst_n; i++) {
258 struct ir3_instruction *dst = ctx->last_dst[i];
259 ir3_set_dst_type(dst, true);
260 ir3_fixup_src_type(dst);
261 if (dst->opc == OPC_META_SPLIT) {
262 ir3_set_dst_type(ssa(dst->regs[1]), true);
263 ir3_fixup_src_type(ssa(dst->regs[1]));
264 dst->regs[1]->flags |= IR3_REG_HALF;
265 }
266 }
267 }
268
269 if (!dst->is_ssa) {
270 nir_register *reg = dst->reg.reg;
271 struct ir3_array *arr = ir3_get_array(ctx, reg);
272 unsigned num_components = ctx->last_dst_n;
273 struct ir3_instruction *addr = NULL;
274
275 if (dst->reg.indirect)
276 addr = ir3_get_addr0(ctx, ir3_get_src(ctx, dst->reg.indirect)[0],
277 reg->num_components);
278
279 for (unsigned i = 0; i < num_components; i++) {
280 unsigned n = dst->reg.base_offset * reg->num_components + i;
281 compile_assert(ctx, n < arr->length);
282 if (!ctx->last_dst[i])
283 continue;
284 ir3_create_array_store(ctx, arr, n, ctx->last_dst[i], addr);
285 }
286
287 ralloc_free(ctx->last_dst);
288 }
289
290 ctx->last_dst = NULL;
291 ctx->last_dst_n = 0;
292 }
293
294 static unsigned
295 dest_flags(struct ir3_instruction *instr)
296 {
297 return instr->regs[0]->flags & (IR3_REG_HALF | IR3_REG_HIGH);
298 }
299
300 struct ir3_instruction *
301 ir3_create_collect(struct ir3_context *ctx, struct ir3_instruction *const *arr,
302 unsigned arrsz)
303 {
304 struct ir3_block *block = ctx->block;
305 struct ir3_instruction *collect;
306
307 if (arrsz == 0)
308 return NULL;
309
310 unsigned flags = dest_flags(arr[0]);
311
312 collect = ir3_instr_create2(block, OPC_META_COLLECT, 1 + arrsz);
313 __ssa_dst(collect)->flags |= flags;
314 for (unsigned i = 0; i < arrsz; i++) {
315 struct ir3_instruction *elem = arr[i];
316
317 /* Since arrays are pre-colored in RA, we can't assume that
318 * things will end up in the right place. (Ie. if a collect
319 * joins elements from two different arrays.) So insert an
320 * extra mov.
321 *
322 * We could possibly skip this if all the collected elements
323 * are contiguous elements in a single array.. not sure how
324 * likely that is to happen.
325 *
326 * Fixes a problem with glamor shaders, that in effect do
327 * something like:
328 *
329 * if (foo)
330 * texcoord = ..
331 * else
332 * texcoord = ..
333 * color = texture2D(tex, texcoord);
334 *
335 * In this case, texcoord will end up as nir registers (which
336 * translate to ir3 array's of length 1. And we can't assume
337 * the two (or more) arrays will get allocated in consecutive
338 * scalar registers.
339 *
340 */
341 if (elem->regs[0]->flags & IR3_REG_ARRAY) {
342 type_t type = (flags & IR3_REG_HALF) ? TYPE_U16 : TYPE_U32;
343 elem = ir3_MOV(block, elem, type);
344 }
345
346 compile_assert(ctx, dest_flags(elem) == flags);
347 __ssa_src(collect, elem, flags);
348 }
349
350 collect->regs[0]->wrmask = MASK(arrsz);
351
352 return collect;
353 }
354
355 /* helper for instructions that produce multiple consecutive scalar
356 * outputs which need to have a split meta instruction inserted
357 */
358 void
359 ir3_split_dest(struct ir3_block *block, struct ir3_instruction **dst,
360 struct ir3_instruction *src, unsigned base, unsigned n)
361 {
362 struct ir3_instruction *prev = NULL;
363
364 if ((n == 1) && (src->regs[0]->wrmask == 0x1)) {
365 dst[0] = src;
366 return;
367 }
368
369 if (src->opc == OPC_META_COLLECT) {
370 debug_assert((base + n) < src->regs_count);
371
372 for (int i = 0; i < n; i++) {
373 dst[i] = ssa(src->regs[i + base + 1]);
374 }
375
376 return;
377 }
378
379 unsigned flags = dest_flags(src);
380
381 for (int i = 0, j = 0; i < n; i++) {
382 struct ir3_instruction *split =
383 ir3_instr_create(block, OPC_META_SPLIT);
384 __ssa_dst(split)->flags |= flags;
385 __ssa_src(split, src, flags);
386 split->split.off = i + base;
387
388 if (prev) {
389 split->cp.left = prev;
390 split->cp.left_cnt++;
391 prev->cp.right = split;
392 prev->cp.right_cnt++;
393 }
394 prev = split;
395
396 if (src->regs[0]->wrmask & (1 << (i + base)))
397 dst[j++] = split;
398 }
399 }
400
401 NORETURN void
402 ir3_context_error(struct ir3_context *ctx, const char *format, ...)
403 {
404 struct hash_table *errors = NULL;
405 va_list ap;
406 va_start(ap, format);
407 if (ctx->cur_instr) {
408 errors = _mesa_hash_table_create(NULL,
409 _mesa_hash_pointer,
410 _mesa_key_pointer_equal);
411 char *msg = ralloc_vasprintf(errors, format, ap);
412 _mesa_hash_table_insert(errors, ctx->cur_instr, msg);
413 } else {
414 _debug_vprintf(format, ap);
415 }
416 va_end(ap);
417 nir_print_shader_annotated(ctx->s, stdout, errors);
418 ralloc_free(errors);
419 ctx->error = true;
420 unreachable("");
421 }
422
423 static struct ir3_instruction *
424 create_addr0(struct ir3_block *block, struct ir3_instruction *src, int align)
425 {
426 struct ir3_instruction *instr, *immed;
427
428 instr = ir3_COV(block, src, TYPE_U32, TYPE_S16);
429
430 switch(align){
431 case 1:
432 /* src *= 1: */
433 break;
434 case 2:
435 /* src *= 2 => src <<= 1: */
436 immed = create_immed_typed(block, 1, TYPE_S16);
437 instr = ir3_SHL_B(block, instr, 0, immed, 0);
438 break;
439 case 3:
440 /* src *= 3: */
441 immed = create_immed_typed(block, 3, TYPE_S16);
442 instr = ir3_MULL_U(block, instr, 0, immed, 0);
443 break;
444 case 4:
445 /* src *= 4 => src <<= 2: */
446 immed = create_immed_typed(block, 2, TYPE_S16);
447 instr = ir3_SHL_B(block, instr, 0, immed, 0);
448 break;
449 default:
450 unreachable("bad align");
451 return NULL;
452 }
453
454 instr->regs[0]->flags |= IR3_REG_HALF;
455
456 instr = ir3_MOV(block, instr, TYPE_S16);
457 instr->regs[0]->num = regid(REG_A0, 0);
458 instr->regs[0]->flags &= ~IR3_REG_SSA;
459
460 return instr;
461 }
462
463 static struct ir3_instruction *
464 create_addr1(struct ir3_block *block, unsigned const_val)
465 {
466
467 struct ir3_instruction *immed = create_immed_typed(block, const_val, TYPE_S16);
468 struct ir3_instruction *instr = ir3_MOV(block, immed, TYPE_S16);
469 instr->regs[0]->num = regid(REG_A0, 1);
470 instr->regs[0]->flags &= ~IR3_REG_SSA;
471 return instr;
472 }
473
474 /* caches addr values to avoid generating multiple cov/shl/mova
475 * sequences for each use of a given NIR level src as address
476 */
477 struct ir3_instruction *
478 ir3_get_addr0(struct ir3_context *ctx, struct ir3_instruction *src, int align)
479 {
480 struct ir3_instruction *addr;
481 unsigned idx = align - 1;
482
483 compile_assert(ctx, idx < ARRAY_SIZE(ctx->addr0_ht));
484
485 if (!ctx->addr0_ht[idx]) {
486 ctx->addr0_ht[idx] = _mesa_hash_table_create(ctx,
487 _mesa_hash_pointer, _mesa_key_pointer_equal);
488 } else {
489 struct hash_entry *entry;
490 entry = _mesa_hash_table_search(ctx->addr0_ht[idx], src);
491 if (entry)
492 return entry->data;
493 }
494
495 addr = create_addr0(ctx->block, src, align);
496 _mesa_hash_table_insert(ctx->addr0_ht[idx], src, addr);
497
498 return addr;
499 }
500
501 /* Similar to ir3_get_addr0, but for a1.x. */
502 struct ir3_instruction *
503 ir3_get_addr1(struct ir3_context *ctx, unsigned const_val)
504 {
505 struct ir3_instruction *addr;
506
507 if (!ctx->addr1_ht) {
508 ctx->addr1_ht = _mesa_hash_table_u64_create(ctx);
509 } else {
510 addr = _mesa_hash_table_u64_search(ctx->addr1_ht, const_val);
511 if (addr)
512 return addr;
513 }
514
515 addr = create_addr1(ctx->block, const_val);
516 _mesa_hash_table_u64_insert(ctx->addr1_ht, const_val, addr);
517
518 return addr;
519 }
520
521 struct ir3_instruction *
522 ir3_get_predicate(struct ir3_context *ctx, struct ir3_instruction *src)
523 {
524 struct ir3_block *b = ctx->block;
525 struct ir3_instruction *cond;
526
527 /* NOTE: only cmps.*.* can write p0.x: */
528 cond = ir3_CMPS_S(b, src, 0, create_immed(b, 0), 0);
529 cond->cat2.condition = IR3_COND_NE;
530
531 /* condition always goes in predicate register: */
532 cond->regs[0]->num = regid(REG_P0, 0);
533 cond->regs[0]->flags &= ~IR3_REG_SSA;
534
535 return cond;
536 }
537
538 /*
539 * Array helpers
540 */
541
542 void
543 ir3_declare_array(struct ir3_context *ctx, nir_register *reg)
544 {
545 struct ir3_array *arr = rzalloc(ctx, struct ir3_array);
546 arr->id = ++ctx->num_arrays;
547 /* NOTE: sometimes we get non array regs, for example for arrays of
548 * length 1. See fs-const-array-of-struct-of-array.shader_test. So
549 * treat a non-array as if it was an array of length 1.
550 *
551 * It would be nice if there was a nir pass to convert arrays of
552 * length 1 to ssa.
553 */
554 arr->length = reg->num_components * MAX2(1, reg->num_array_elems);
555 compile_assert(ctx, arr->length > 0);
556 arr->r = reg;
557 list_addtail(&arr->node, &ctx->ir->array_list);
558 }
559
560 struct ir3_array *
561 ir3_get_array(struct ir3_context *ctx, nir_register *reg)
562 {
563 foreach_array (arr, &ctx->ir->array_list) {
564 if (arr->r == reg)
565 return arr;
566 }
567 ir3_context_error(ctx, "bogus reg: %s\n", reg->name);
568 return NULL;
569 }
570
571 /* relative (indirect) if address!=NULL */
572 struct ir3_instruction *
573 ir3_create_array_load(struct ir3_context *ctx, struct ir3_array *arr, int n,
574 struct ir3_instruction *address, unsigned bitsize)
575 {
576 struct ir3_block *block = ctx->block;
577 struct ir3_instruction *mov;
578 struct ir3_register *src;
579 unsigned flags = 0;
580
581 mov = ir3_instr_create(block, OPC_MOV);
582 if (bitsize == 16) {
583 mov->cat1.src_type = TYPE_U16;
584 mov->cat1.dst_type = TYPE_U16;
585 flags |= IR3_REG_HALF;
586 arr->half = true;
587 } else {
588 mov->cat1.src_type = TYPE_U32;
589 mov->cat1.dst_type = TYPE_U32;
590 }
591
592 mov->barrier_class = IR3_BARRIER_ARRAY_R;
593 mov->barrier_conflict = IR3_BARRIER_ARRAY_W;
594 __ssa_dst(mov)->flags |= flags;
595 src = ir3_reg_create(mov, 0, IR3_REG_ARRAY |
596 COND(address, IR3_REG_RELATIV) | flags);
597 src->instr = arr->last_write;
598 src->size = arr->length;
599 src->array.id = arr->id;
600 src->array.offset = n;
601
602 if (address)
603 ir3_instr_set_address(mov, address);
604
605 return mov;
606 }
607
608 /* relative (indirect) if address!=NULL */
609 void
610 ir3_create_array_store(struct ir3_context *ctx, struct ir3_array *arr, int n,
611 struct ir3_instruction *src, struct ir3_instruction *address)
612 {
613 struct ir3_block *block = ctx->block;
614 struct ir3_instruction *mov;
615 struct ir3_register *dst;
616
617 /* if not relative store, don't create an extra mov, since that
618 * ends up being difficult for cp to remove.
619 *
620 * Also, don't skip the mov if the src is meta (like fanout/split),
621 * since that creates a situation that RA can't really handle properly.
622 */
623 if (!address && !is_meta(src)) {
624 dst = src->regs[0];
625
626 src->barrier_class |= IR3_BARRIER_ARRAY_W;
627 src->barrier_conflict |= IR3_BARRIER_ARRAY_R | IR3_BARRIER_ARRAY_W;
628
629 dst->flags |= IR3_REG_ARRAY;
630 dst->instr = arr->last_write;
631 dst->size = arr->length;
632 dst->array.id = arr->id;
633 dst->array.offset = n;
634
635 arr->last_write = src;
636
637 array_insert(block, block->keeps, src);
638
639 return;
640 }
641
642 mov = ir3_instr_create(block, OPC_MOV);
643 mov->cat1.src_type = TYPE_U32;
644 mov->cat1.dst_type = TYPE_U32;
645 mov->barrier_class = IR3_BARRIER_ARRAY_W;
646 mov->barrier_conflict = IR3_BARRIER_ARRAY_R | IR3_BARRIER_ARRAY_W;
647 dst = ir3_reg_create(mov, 0, IR3_REG_ARRAY |
648 COND(address, IR3_REG_RELATIV));
649 dst->instr = arr->last_write;
650 dst->size = arr->length;
651 dst->array.id = arr->id;
652 dst->array.offset = n;
653 ir3_reg_create(mov, 0, IR3_REG_SSA)->instr = src;
654
655 if (address)
656 ir3_instr_set_address(mov, address);
657
658 arr->last_write = mov;
659
660 /* the array store may only matter to something in an earlier
661 * block (ie. loops), but since arrays are not in SSA, depth
662 * pass won't know this.. so keep all array stores:
663 */
664 array_insert(block, block->keeps, mov);
665 }