• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright © 2014 Broadcom
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 /**
25  * @file vc4_opt_copy_propagation.c
26  *
27  * This implements simple copy propagation for QIR without control flow.
28  *
29  * For each temp, it keeps a qreg of which source it was MOVed from, if it
30  * was.  If we see that used later, we can just reuse the source value, since
31  * we know we don't have control flow, and we have SSA for our values so
32  * there's no killing to worry about.
33  */
34 
35 #include "vc4_qir.h"
36 
37 static bool
is_copy_mov(struct qinst * inst)38 is_copy_mov(struct qinst *inst)
39 {
40         if (!inst)
41                 return false;
42 
43         if (inst->op != QOP_MOV &&
44             inst->op != QOP_FMOV &&
45             inst->op != QOP_MMOV) {
46                 return false;
47         }
48 
49         if (inst->dst.file != QFILE_TEMP)
50                 return false;
51 
52         if (inst->src[0].file != QFILE_TEMP &&
53             inst->src[0].file != QFILE_UNIF) {
54                 return false;
55         }
56 
57         if (inst->dst.pack || inst->cond != QPU_COND_ALWAYS)
58                 return false;
59 
60         return true;
61 
62 }
63 
64 static bool
try_copy_prop(struct vc4_compile * c,struct qinst * inst,struct qinst ** movs)65 try_copy_prop(struct vc4_compile *c, struct qinst *inst, struct qinst **movs)
66 {
67         bool debug = false;
68         bool progress = false;
69 
70 	for (int i = 0; i < qir_get_nsrc(inst); i++) {
71                 if (inst->src[i].file != QFILE_TEMP)
72                         continue;
73 
74                 /* We have two ways of finding MOVs we can copy propagate
75                  * from.  One is if it's an SSA def: then we can reuse it from
76                  * any block in the program, as long as its source is also an
77                  * SSA def.  Alternatively, if it's in the "movs" array
78                  * tracked within the block, then we know the sources for it
79                  * haven't been changed since we saw the instruction within
80                  * our block.
81                  */
82                 struct qinst *mov = movs[inst->src[i].index];
83                 if (!mov) {
84                         if (!is_copy_mov(c->defs[inst->src[i].index]))
85                                 continue;
86                         mov = c->defs[inst->src[i].index];
87 
88                         if (mov->src[0].file == QFILE_TEMP &&
89                             !c->defs[mov->src[0].index])
90                                 continue;
91                 }
92 
93                 /* Mul rotation's source needs to be in an r0-r3 accumulator,
94                  * so no uniforms or regfile-a/r4 unpacking allowed.
95                  */
96                 if (inst->op == QOP_ROT_MUL &&
97                     (mov->src[0].file != QFILE_TEMP ||
98                      mov->src[0].pack))
99                         continue;
100 
101                 uint8_t unpack;
102                 if (mov->src[0].pack) {
103                         /* Make sure that the meaning of the unpack
104                          * would be the same between the two
105                          * instructions.
106                          */
107                         if (qir_is_float_input(inst) !=
108                             qir_is_float_input(mov)) {
109                                 continue;
110                         }
111 
112                         /* There's only one unpack field, so make sure
113                          * this instruction doesn't already use it.
114                          */
115                         bool already_has_unpack = false;
116                         for (int j = 0; j < qir_get_nsrc(inst); j++) {
117                                 if (inst->src[j].pack)
118                                         already_has_unpack = true;
119                         }
120                         if (already_has_unpack)
121                                 continue;
122 
123                         /* A destination pack requires the PM bit to
124                          * be set to a specific value already, which
125                          * may be different from ours.
126                          */
127                         if (inst->dst.pack)
128                                 continue;
129 
130                         unpack = mov->src[0].pack;
131                 } else {
132                         unpack = inst->src[i].pack;
133                 }
134 
135                 if (debug) {
136                         fprintf(stderr, "Copy propagate: ");
137                         qir_dump_inst(c, inst);
138                         fprintf(stderr, "\n");
139                 }
140 
141                 inst->src[i] = mov->src[0];
142                 inst->src[i].pack = unpack;
143 
144                 if (debug) {
145                         fprintf(stderr, "to: ");
146                         qir_dump_inst(c, inst);
147                         fprintf(stderr, "\n");
148                 }
149 
150                 progress = true;
151         }
152 
153         return progress;
154 }
155 
156 static void
apply_kills(struct vc4_compile * c,struct qinst ** movs,struct qinst * inst)157 apply_kills(struct vc4_compile *c, struct qinst **movs, struct qinst *inst)
158 {
159         if (inst->dst.file != QFILE_TEMP)
160                 return;
161 
162         for (int i = 0; i < c->num_temps; i++) {
163                 if (movs[i] &&
164                     (movs[i]->dst.index == inst->dst.index ||
165                      (movs[i]->src[0].file == QFILE_TEMP &&
166                       movs[i]->src[0].index == inst->dst.index))) {
167                         movs[i] = NULL;
168                 }
169         }
170 }
171 
172 bool
qir_opt_copy_propagation(struct vc4_compile * c)173 qir_opt_copy_propagation(struct vc4_compile *c)
174 {
175         bool progress = false;
176         struct qinst **movs;
177 
178         movs = ralloc_array(c, struct qinst *, c->num_temps);
179         if (!movs)
180                 return false;
181 
182         qir_for_each_block(block, c) {
183                 /* The MOVs array tracks only available movs within the
184                  * block.
185                  */
186                 memset(movs, 0, sizeof(struct qinst *) * c->num_temps);
187 
188                 qir_for_each_inst(inst, block) {
189                         progress = try_copy_prop(c, inst, movs) || progress;
190 
191                         apply_kills(c, movs, inst);
192 
193                         if (is_copy_mov(inst))
194                                 movs[inst->dst.index] = inst;
195                 }
196         }
197 
198         ralloc_free(movs);
199 
200         return progress;
201 }
202