2 * Copyright © 2014 Broadcom
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:
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
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
25 #include "util/ralloc.h"
29 #define QPU_MUX(mux, muxfield) \
30 QPU_SET_FIELD(mux != QPU_MUX_SMALL_IMM ? mux : QPU_MUX_B, muxfield)
33 set_src_raddr(uint64_t inst
, struct qpu_reg src
)
35 if (src
.mux
== QPU_MUX_A
) {
36 assert(QPU_GET_FIELD(inst
, QPU_RADDR_A
) == QPU_R_NOP
||
37 QPU_GET_FIELD(inst
, QPU_RADDR_A
) == src
.addr
);
38 return QPU_UPDATE_FIELD(inst
, src
.addr
, QPU_RADDR_A
);
41 if (src
.mux
== QPU_MUX_B
) {
42 assert((QPU_GET_FIELD(inst
, QPU_RADDR_B
) == QPU_R_NOP
||
43 QPU_GET_FIELD(inst
, QPU_RADDR_B
) == src
.addr
) &&
44 QPU_GET_FIELD(inst
, QPU_SIG
) != QPU_SIG_SMALL_IMM
);
45 return QPU_UPDATE_FIELD(inst
, src
.addr
, QPU_RADDR_B
);
48 if (src
.mux
== QPU_MUX_SMALL_IMM
) {
49 if (QPU_GET_FIELD(inst
, QPU_SIG
) == QPU_SIG_SMALL_IMM
) {
50 assert(QPU_GET_FIELD(inst
, QPU_RADDR_B
) == src
.addr
);
52 inst
= qpu_set_sig(inst
, QPU_SIG_SMALL_IMM
);
53 assert(QPU_GET_FIELD(inst
, QPU_RADDR_B
) == QPU_R_NOP
);
55 return ((inst
& ~QPU_RADDR_B_MASK
) |
56 QPU_SET_FIELD(src
.addr
, QPU_RADDR_B
));
67 inst
|= QPU_SET_FIELD(QPU_A_NOP
, QPU_OP_ADD
);
68 inst
|= QPU_SET_FIELD(QPU_M_NOP
, QPU_OP_MUL
);
70 /* Note: These field values are actually non-zero */
71 inst
|= QPU_SET_FIELD(QPU_W_NOP
, QPU_WADDR_ADD
);
72 inst
|= QPU_SET_FIELD(QPU_W_NOP
, QPU_WADDR_MUL
);
73 inst
|= QPU_SET_FIELD(QPU_R_NOP
, QPU_RADDR_A
);
74 inst
|= QPU_SET_FIELD(QPU_R_NOP
, QPU_RADDR_B
);
75 inst
|= QPU_SET_FIELD(QPU_SIG_NONE
, QPU_SIG
);
81 qpu_a_dst(struct qpu_reg dst
)
85 if (dst
.mux
<= QPU_MUX_R5
) {
86 /* Translate the mux to the ACCn values. */
87 inst
|= QPU_SET_FIELD(32 + dst
.mux
, QPU_WADDR_ADD
);
89 inst
|= QPU_SET_FIELD(dst
.addr
, QPU_WADDR_ADD
);
90 if (dst
.mux
== QPU_MUX_B
)
98 qpu_m_dst(struct qpu_reg dst
)
102 if (dst
.mux
<= QPU_MUX_R5
) {
103 /* Translate the mux to the ACCn values. */
104 inst
|= QPU_SET_FIELD(32 + dst
.mux
, QPU_WADDR_MUL
);
106 inst
|= QPU_SET_FIELD(dst
.addr
, QPU_WADDR_MUL
);
107 if (dst
.mux
== QPU_MUX_A
)
115 qpu_a_MOV(struct qpu_reg dst
, struct qpu_reg src
)
119 inst
|= QPU_SET_FIELD(QPU_SIG_NONE
, QPU_SIG
);
120 inst
|= QPU_SET_FIELD(QPU_A_OR
, QPU_OP_ADD
);
121 inst
|= QPU_SET_FIELD(QPU_R_NOP
, QPU_RADDR_A
);
122 inst
|= QPU_SET_FIELD(QPU_R_NOP
, QPU_RADDR_B
);
123 inst
|= qpu_a_dst(dst
);
124 inst
|= QPU_SET_FIELD(QPU_COND_ALWAYS
, QPU_COND_ADD
);
125 inst
|= QPU_MUX(src
.mux
, QPU_ADD_A
);
126 inst
|= QPU_MUX(src
.mux
, QPU_ADD_B
);
127 inst
= set_src_raddr(inst
, src
);
128 inst
|= QPU_SET_FIELD(QPU_W_NOP
, QPU_WADDR_MUL
);
134 qpu_m_MOV(struct qpu_reg dst
, struct qpu_reg src
)
138 inst
|= QPU_SET_FIELD(QPU_SIG_NONE
, QPU_SIG
);
139 inst
|= QPU_SET_FIELD(QPU_M_V8MIN
, QPU_OP_MUL
);
140 inst
|= QPU_SET_FIELD(QPU_R_NOP
, QPU_RADDR_A
);
141 inst
|= QPU_SET_FIELD(QPU_R_NOP
, QPU_RADDR_B
);
142 inst
|= qpu_m_dst(dst
);
143 inst
|= QPU_SET_FIELD(QPU_COND_ALWAYS
, QPU_COND_MUL
);
144 inst
|= QPU_MUX(src
.mux
, QPU_MUL_A
);
145 inst
|= QPU_MUX(src
.mux
, QPU_MUL_B
);
146 inst
= set_src_raddr(inst
, src
);
147 inst
|= QPU_SET_FIELD(QPU_W_NOP
, QPU_WADDR_ADD
);
153 qpu_load_imm_ui(struct qpu_reg dst
, uint32_t val
)
157 inst
|= qpu_a_dst(dst
);
158 inst
|= QPU_SET_FIELD(QPU_W_NOP
, QPU_WADDR_MUL
);
159 inst
|= QPU_SET_FIELD(QPU_COND_ALWAYS
, QPU_COND_ADD
);
160 inst
|= QPU_SET_FIELD(QPU_COND_ALWAYS
, QPU_COND_MUL
);
161 inst
|= QPU_SET_FIELD(QPU_SIG_LOAD_IMM
, QPU_SIG
);
168 qpu_load_imm_u2(struct qpu_reg dst
, uint32_t val
)
170 return qpu_load_imm_ui(dst
, val
) | QPU_SET_FIELD(QPU_LOAD_IMM_MODE_U2
,
175 qpu_load_imm_i2(struct qpu_reg dst
, uint32_t val
)
177 return qpu_load_imm_ui(dst
, val
) | QPU_SET_FIELD(QPU_LOAD_IMM_MODE_I2
,
182 qpu_branch(uint32_t cond
, uint32_t target
)
186 inst
|= qpu_a_dst(qpu_ra(QPU_W_NOP
));
187 inst
|= qpu_m_dst(qpu_rb(QPU_W_NOP
));
188 inst
|= QPU_SET_FIELD(cond
, QPU_BRANCH_COND
);
189 inst
|= QPU_SET_FIELD(QPU_SIG_BRANCH
, QPU_SIG
);
190 inst
|= QPU_SET_FIELD(target
, QPU_BRANCH_TARGET
);
196 qpu_a_alu2(enum qpu_op_add op
,
197 struct qpu_reg dst
, struct qpu_reg src0
, struct qpu_reg src1
)
201 inst
|= QPU_SET_FIELD(QPU_SIG_NONE
, QPU_SIG
);
202 inst
|= QPU_SET_FIELD(op
, QPU_OP_ADD
);
203 inst
|= QPU_SET_FIELD(QPU_R_NOP
, QPU_RADDR_A
);
204 inst
|= QPU_SET_FIELD(QPU_R_NOP
, QPU_RADDR_B
);
205 inst
|= qpu_a_dst(dst
);
206 inst
|= QPU_SET_FIELD(QPU_COND_ALWAYS
, QPU_COND_ADD
);
207 inst
|= QPU_MUX(src0
.mux
, QPU_ADD_A
);
208 inst
= set_src_raddr(inst
, src0
);
209 inst
|= QPU_MUX(src1
.mux
, QPU_ADD_B
);
210 inst
= set_src_raddr(inst
, src1
);
211 inst
|= QPU_SET_FIELD(QPU_W_NOP
, QPU_WADDR_MUL
);
217 qpu_m_alu2(enum qpu_op_mul op
,
218 struct qpu_reg dst
, struct qpu_reg src0
, struct qpu_reg src1
)
222 inst
|= QPU_SET_FIELD(QPU_SIG_NONE
, QPU_SIG
);
223 inst
|= QPU_SET_FIELD(op
, QPU_OP_MUL
);
224 inst
|= QPU_SET_FIELD(QPU_R_NOP
, QPU_RADDR_A
);
225 inst
|= QPU_SET_FIELD(QPU_R_NOP
, QPU_RADDR_B
);
226 inst
|= qpu_m_dst(dst
);
227 inst
|= QPU_SET_FIELD(QPU_COND_ALWAYS
, QPU_COND_MUL
);
228 inst
|= QPU_MUX(src0
.mux
, QPU_MUL_A
);
229 inst
= set_src_raddr(inst
, src0
);
230 inst
|= QPU_MUX(src1
.mux
, QPU_MUL_B
);
231 inst
= set_src_raddr(inst
, src1
);
232 inst
|= QPU_SET_FIELD(QPU_W_NOP
, QPU_WADDR_ADD
);
238 qpu_m_rot(struct qpu_reg dst
, struct qpu_reg src0
, int rot
)
241 inst
= qpu_m_alu2(QPU_M_V8MIN
, dst
, src0
, src0
);
243 inst
= QPU_UPDATE_FIELD(inst
, QPU_SIG_SMALL_IMM
, QPU_SIG
);
244 inst
= QPU_UPDATE_FIELD(inst
, QPU_SMALL_IMM_MUL_ROT
+ rot
,
251 merge_fields(uint64_t *merge
,
252 uint64_t a
, uint64_t b
,
253 uint64_t mask
, uint64_t ignore
)
255 if ((a
& mask
) == ignore
) {
256 *merge
= (*merge
& ~mask
) | (b
& mask
);
257 } else if ((b
& mask
) == ignore
) {
258 *merge
= (*merge
& ~mask
) | (a
& mask
);
260 if ((a
& mask
) != (b
& mask
))
268 qpu_num_sf_accesses(uint64_t inst
)
271 static const uint32_t specials
[] = {
288 uint32_t waddr_add
= QPU_GET_FIELD(inst
, QPU_WADDR_ADD
);
289 uint32_t waddr_mul
= QPU_GET_FIELD(inst
, QPU_WADDR_MUL
);
290 uint32_t raddr_a
= QPU_GET_FIELD(inst
, QPU_RADDR_A
);
291 uint32_t raddr_b
= QPU_GET_FIELD(inst
, QPU_RADDR_B
);
293 for (int j
= 0; j
< ARRAY_SIZE(specials
); j
++) {
294 if (waddr_add
== specials
[j
])
296 if (waddr_mul
== specials
[j
])
300 if (raddr_a
== QPU_R_MUTEX_ACQUIRE
)
302 if (raddr_b
== QPU_R_MUTEX_ACQUIRE
&&
303 QPU_GET_FIELD(inst
, QPU_SIG
) != QPU_SIG_SMALL_IMM
)
306 /* XXX: semaphore, combined color read/write? */
307 switch (QPU_GET_FIELD(inst
, QPU_SIG
)) {
308 case QPU_SIG_COLOR_LOAD
:
309 case QPU_SIG_COLOR_LOAD_END
:
310 case QPU_SIG_LOAD_TMU0
:
311 case QPU_SIG_LOAD_TMU1
:
319 qpu_waddr_ignores_ws(uint32_t waddr
)
328 case QPU_W_TLB_COLOR_MS
:
329 case QPU_W_TLB_COLOR_ALL
:
330 case QPU_W_TLB_ALPHA_MASK
:
332 case QPU_W_SFU_RECIP
:
333 case QPU_W_SFU_RECIPSQRT
:
351 swap_ra_file_mux_helper(uint64_t *merge
, uint64_t *a
, uint32_t mux_shift
)
353 uint64_t mux_mask
= (uint64_t)0x7 << mux_shift
;
354 uint64_t mux_a_val
= (uint64_t)QPU_MUX_A
<< mux_shift
;
355 uint64_t mux_b_val
= (uint64_t)QPU_MUX_B
<< mux_shift
;
357 if ((*a
& mux_mask
) == mux_a_val
) {
358 *a
= (*a
& ~mux_mask
) | mux_b_val
;
359 *merge
= (*merge
& ~mux_mask
) | mux_b_val
;
364 try_swap_ra_file(uint64_t *merge
, uint64_t *a
, uint64_t *b
)
366 uint32_t raddr_a_a
= QPU_GET_FIELD(*a
, QPU_RADDR_A
);
367 uint32_t raddr_a_b
= QPU_GET_FIELD(*a
, QPU_RADDR_B
);
368 uint32_t raddr_b_a
= QPU_GET_FIELD(*b
, QPU_RADDR_A
);
369 uint32_t raddr_b_b
= QPU_GET_FIELD(*b
, QPU_RADDR_B
);
371 if (raddr_a_b
!= QPU_R_NOP
)
382 if (!(*merge
& QPU_PM
) &&
383 QPU_GET_FIELD(*merge
, QPU_UNPACK
) != QPU_UNPACK_NOP
) {
387 if (raddr_b_b
!= QPU_R_NOP
&&
388 raddr_b_b
!= raddr_a_a
)
391 /* Move raddr A to B in instruction a. */
392 *a
= (*a
& ~QPU_RADDR_A_MASK
) | QPU_SET_FIELD(QPU_R_NOP
, QPU_RADDR_A
);
393 *a
= (*a
& ~QPU_RADDR_B_MASK
) | QPU_SET_FIELD(raddr_a_a
, QPU_RADDR_B
);
394 *merge
= QPU_UPDATE_FIELD(*merge
, raddr_b_a
, QPU_RADDR_A
);
395 *merge
= QPU_UPDATE_FIELD(*merge
, raddr_a_a
, QPU_RADDR_B
);
396 swap_ra_file_mux_helper(merge
, a
, QPU_ADD_A_SHIFT
);
397 swap_ra_file_mux_helper(merge
, a
, QPU_ADD_B_SHIFT
);
398 swap_ra_file_mux_helper(merge
, a
, QPU_MUL_A_SHIFT
);
399 swap_ra_file_mux_helper(merge
, a
, QPU_MUL_B_SHIFT
);
405 convert_mov(uint64_t *inst
)
407 uint32_t add_a
= QPU_GET_FIELD(*inst
, QPU_ADD_A
);
408 uint32_t waddr_add
= QPU_GET_FIELD(*inst
, QPU_WADDR_ADD
);
409 uint32_t cond_add
= QPU_GET_FIELD(*inst
, QPU_COND_ADD
);
412 if (QPU_GET_FIELD(*inst
, QPU_OP_ADD
) != QPU_A_OR
||
413 (add_a
!= QPU_GET_FIELD(*inst
, QPU_ADD_B
))) {
417 if (QPU_GET_FIELD(*inst
, QPU_SIG
) != QPU_SIG_NONE
)
420 /* We could maybe support this in the .8888 and .8a-.8d cases. */
424 *inst
= QPU_UPDATE_FIELD(*inst
, QPU_A_NOP
, QPU_OP_ADD
);
425 *inst
= QPU_UPDATE_FIELD(*inst
, QPU_M_V8MIN
, QPU_OP_MUL
);
427 *inst
= QPU_UPDATE_FIELD(*inst
, add_a
, QPU_MUL_A
);
428 *inst
= QPU_UPDATE_FIELD(*inst
, add_a
, QPU_MUL_B
);
429 *inst
= QPU_UPDATE_FIELD(*inst
, QPU_MUX_R0
, QPU_ADD_A
);
430 *inst
= QPU_UPDATE_FIELD(*inst
, QPU_MUX_R0
, QPU_ADD_B
);
432 *inst
= QPU_UPDATE_FIELD(*inst
, waddr_add
, QPU_WADDR_MUL
);
433 *inst
= QPU_UPDATE_FIELD(*inst
, QPU_W_NOP
, QPU_WADDR_ADD
);
435 *inst
= QPU_UPDATE_FIELD(*inst
, cond_add
, QPU_COND_MUL
);
436 *inst
= QPU_UPDATE_FIELD(*inst
, QPU_COND_NEVER
, QPU_COND_ADD
);
438 if (!qpu_waddr_ignores_ws(waddr_add
))
445 writes_a_file(uint64_t inst
)
447 if (!(inst
& QPU_WS
))
448 return QPU_GET_FIELD(inst
, QPU_WADDR_ADD
) < 32;
450 return QPU_GET_FIELD(inst
, QPU_WADDR_MUL
) < 32;
454 reads_r4(uint64_t inst
)
456 return (QPU_GET_FIELD(inst
, QPU_ADD_A
) == QPU_MUX_R4
||
457 QPU_GET_FIELD(inst
, QPU_ADD_B
) == QPU_MUX_R4
||
458 QPU_GET_FIELD(inst
, QPU_MUL_A
) == QPU_MUX_R4
||
459 QPU_GET_FIELD(inst
, QPU_MUL_B
) == QPU_MUX_R4
);
463 qpu_merge_inst(uint64_t a
, uint64_t b
)
465 uint64_t merge
= a
| b
;
467 uint32_t a_sig
= QPU_GET_FIELD(a
, QPU_SIG
);
468 uint32_t b_sig
= QPU_GET_FIELD(b
, QPU_SIG
);
470 if (QPU_GET_FIELD(a
, QPU_OP_ADD
) != QPU_A_NOP
&&
471 QPU_GET_FIELD(b
, QPU_OP_ADD
) != QPU_A_NOP
) {
472 if (QPU_GET_FIELD(a
, QPU_OP_MUL
) != QPU_M_NOP
||
473 QPU_GET_FIELD(b
, QPU_OP_MUL
) != QPU_M_NOP
||
474 !(convert_mov(&a
) || convert_mov(&b
))) {
481 if (QPU_GET_FIELD(a
, QPU_OP_MUL
) != QPU_M_NOP
&&
482 QPU_GET_FIELD(b
, QPU_OP_MUL
) != QPU_M_NOP
)
485 if (qpu_num_sf_accesses(a
) && qpu_num_sf_accesses(b
))
488 if (a_sig
== QPU_SIG_LOAD_IMM
||
489 b_sig
== QPU_SIG_LOAD_IMM
||
490 a_sig
== QPU_SIG_SMALL_IMM
||
491 b_sig
== QPU_SIG_SMALL_IMM
||
492 a_sig
== QPU_SIG_BRANCH
||
493 b_sig
== QPU_SIG_BRANCH
) {
497 ok
= ok
&& merge_fields(&merge
, a
, b
, QPU_SIG_MASK
,
498 QPU_SET_FIELD(QPU_SIG_NONE
, QPU_SIG
));
500 /* Misc fields that have to match exactly. */
501 ok
= ok
&& merge_fields(&merge
, a
, b
, QPU_SF
, ~0);
503 if (!merge_fields(&merge
, a
, b
, QPU_RADDR_A_MASK
,
504 QPU_SET_FIELD(QPU_R_NOP
, QPU_RADDR_A
))) {
505 /* Since we tend to use regfile A by default both for register
506 * allocation and for our special values (uniforms and
507 * varyings), try swapping uniforms and varyings to regfile B
508 * to resolve raddr A conflicts.
510 if (!try_swap_ra_file(&merge
, &a
, &b
) &&
511 !try_swap_ra_file(&merge
, &b
, &a
)) {
516 ok
= ok
&& merge_fields(&merge
, a
, b
, QPU_RADDR_B_MASK
,
517 QPU_SET_FIELD(QPU_R_NOP
, QPU_RADDR_B
));
519 ok
= ok
&& merge_fields(&merge
, a
, b
, QPU_WADDR_ADD_MASK
,
520 QPU_SET_FIELD(QPU_W_NOP
, QPU_WADDR_ADD
));
521 ok
= ok
&& merge_fields(&merge
, a
, b
, QPU_WADDR_MUL_MASK
,
522 QPU_SET_FIELD(QPU_W_NOP
, QPU_WADDR_MUL
));
524 /* Allow disagreement on WS (swapping A vs B physical reg file as the
525 * destination for ADD/MUL) if one of the original instructions
526 * ignores it (probably because it's just writing to accumulators).
528 if (qpu_waddr_ignores_ws(QPU_GET_FIELD(a
, QPU_WADDR_ADD
)) &&
529 qpu_waddr_ignores_ws(QPU_GET_FIELD(a
, QPU_WADDR_MUL
))) {
530 merge
= (merge
& ~QPU_WS
) | (b
& QPU_WS
);
531 } else if (qpu_waddr_ignores_ws(QPU_GET_FIELD(b
, QPU_WADDR_ADD
)) &&
532 qpu_waddr_ignores_ws(QPU_GET_FIELD(b
, QPU_WADDR_MUL
))) {
533 merge
= (merge
& ~QPU_WS
) | (a
& QPU_WS
);
535 if ((a
& QPU_WS
) != (b
& QPU_WS
))
539 if (!merge_fields(&merge
, a
, b
, QPU_PM
, ~0)) {
540 /* If one instruction has PM bit set and the other not, the
541 * one without PM shouldn't do packing/unpacking, and we
542 * have to make sure non-NOP packing/unpacking from PM
543 * instruction aren't added to it.
547 /* Let a be the one with PM bit */
554 if ((b
& (QPU_PACK_MASK
| QPU_UNPACK_MASK
)) != 0)
557 if ((a
& QPU_PACK_MASK
) != 0 &&
558 QPU_GET_FIELD(b
, QPU_OP_MUL
) != QPU_M_NOP
)
561 if ((a
& QPU_UNPACK_MASK
) != 0 && reads_r4(b
))
564 /* packing: Make sure that non-NOP packs agree, then deal with
565 * special-case failing of adding a non-NOP pack to something
568 if (!merge_fields(&merge
, a
, b
, QPU_PACK_MASK
, 0))
570 bool new_a_pack
= (QPU_GET_FIELD(a
, QPU_PACK
) !=
571 QPU_GET_FIELD(merge
, QPU_PACK
));
572 bool new_b_pack
= (QPU_GET_FIELD(b
, QPU_PACK
) !=
573 QPU_GET_FIELD(merge
, QPU_PACK
));
574 if (!(merge
& QPU_PM
)) {
575 /* Make sure we're not going to be putting a new
576 * a-file packing on either half.
578 if (new_a_pack
&& writes_a_file(a
))
581 if (new_b_pack
&& writes_a_file(b
))
584 /* Make sure we're not going to be putting new MUL
585 * packing oneither half.
588 QPU_GET_FIELD(a
, QPU_OP_MUL
) != QPU_M_NOP
)
592 QPU_GET_FIELD(b
, QPU_OP_MUL
) != QPU_M_NOP
)
596 /* unpacking: Make sure that non-NOP unpacks agree, then deal
597 * with special-case failing of adding a non-NOP unpack to
598 * something with a NOP unpack.
600 if (!merge_fields(&merge
, a
, b
, QPU_UNPACK_MASK
, 0))
602 bool new_a_unpack
= (QPU_GET_FIELD(a
, QPU_UNPACK
) !=
603 QPU_GET_FIELD(merge
, QPU_UNPACK
));
604 bool new_b_unpack
= (QPU_GET_FIELD(b
, QPU_UNPACK
) !=
605 QPU_GET_FIELD(merge
, QPU_UNPACK
));
606 if (!(merge
& QPU_PM
)) {
607 /* Make sure we're not going to be putting a new
608 * a-file packing on either half.
611 QPU_GET_FIELD(a
, QPU_RADDR_A
) != QPU_R_NOP
)
615 QPU_GET_FIELD(b
, QPU_RADDR_A
) != QPU_R_NOP
)
618 /* Make sure we're not going to be putting new r4
619 * unpack on either half.
621 if (new_a_unpack
&& reads_r4(a
))
624 if (new_b_unpack
&& reads_r4(b
))
636 qpu_set_sig(uint64_t inst
, uint32_t sig
)
638 assert(QPU_GET_FIELD(inst
, QPU_SIG
) == QPU_SIG_NONE
);
639 return QPU_UPDATE_FIELD(inst
, sig
, QPU_SIG
);
643 qpu_set_cond_add(uint64_t inst
, uint32_t cond
)
645 assert(QPU_GET_FIELD(inst
, QPU_COND_ADD
) == QPU_COND_ALWAYS
);
646 return QPU_UPDATE_FIELD(inst
, cond
, QPU_COND_ADD
);
650 qpu_set_cond_mul(uint64_t inst
, uint32_t cond
)
652 assert(QPU_GET_FIELD(inst
, QPU_COND_MUL
) == QPU_COND_ALWAYS
);
653 return QPU_UPDATE_FIELD(inst
, cond
, QPU_COND_MUL
);
657 qpu_waddr_is_tlb(uint32_t waddr
)
660 case QPU_W_TLB_COLOR_ALL
:
661 case QPU_W_TLB_COLOR_MS
:
670 qpu_inst_is_tlb(uint64_t inst
)
672 uint32_t sig
= QPU_GET_FIELD(inst
, QPU_SIG
);
674 return (qpu_waddr_is_tlb(QPU_GET_FIELD(inst
, QPU_WADDR_ADD
)) ||
675 qpu_waddr_is_tlb(QPU_GET_FIELD(inst
, QPU_WADDR_MUL
)) ||
676 sig
== QPU_SIG_COLOR_LOAD
||
677 sig
== QPU_SIG_WAIT_FOR_SCOREBOARD
);
681 * Returns the small immediate value to be encoded in to the raddr b field if
682 * the argument can be represented as one, or ~0 otherwise.
685 qpu_encode_small_immediate(uint32_t i
)
689 if ((int)i
< 0 && (int)i
>= -16)
731 qpu_serialize_one_inst(struct vc4_compile
*c
, uint64_t inst
)
733 if (c
->qpu_inst_count
>= c
->qpu_inst_size
) {
734 c
->qpu_inst_size
= MAX2(16, c
->qpu_inst_size
* 2);
735 c
->qpu_insts
= reralloc(c
, c
->qpu_insts
,
736 uint64_t, c
->qpu_inst_size
);
738 c
->qpu_insts
[c
->qpu_inst_count
++] = inst
;