1 /*
2 * Copyright (C) 2014 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.h"
28
29 /*
30 * Find/group instruction neighbors:
31 */
32
33 static void
insert_mov(struct ir3_instruction * collect,int idx)34 insert_mov(struct ir3_instruction *collect, int idx)
35 {
36 struct ir3_instruction *src = ssa(collect->regs[idx+1]);
37 struct ir3_instruction *mov = ir3_MOV(src->block, src,
38 (collect->regs[idx+1]->flags & IR3_REG_HALF) ? TYPE_U16 : TYPE_U32);
39
40 collect->regs[idx+1]->instr = mov;
41
42 /* if collect and src are in the same block, move the inserted mov
43 * to just before the collect to avoid a use-before-def. Otherwise
44 * it should be safe to leave at the end of the block it is in:
45 */
46 if (src->block == collect->block) {
47 ir3_instr_move_before(mov, collect);
48 }
49 }
50
51 /* verify that cur != instr, but cur is also not in instr's neighbor-list: */
52 static bool
in_neighbor_list(struct ir3_instruction * instr,struct ir3_instruction * cur,int pos)53 in_neighbor_list(struct ir3_instruction *instr, struct ir3_instruction *cur, int pos)
54 {
55 int idx = 0;
56
57 if (!instr)
58 return false;
59
60 if (instr == cur)
61 return true;
62
63 for (instr = ir3_neighbor_first(instr); instr; instr = instr->cp.right)
64 if ((idx++ != pos) && (instr == cur))
65 return true;
66
67 return false;
68 }
69
70 static void
group_collect(struct ir3_instruction * collect)71 group_collect(struct ir3_instruction *collect)
72 {
73 struct ir3_register **regs = &collect->regs[1];
74 unsigned n = collect->regs_count - 1;
75
76 /* first pass, figure out what has conflicts and needs a mov
77 * inserted. Do this up front, before starting to setup
78 * left/right neighbor pointers. Trying to do it in a single
79 * pass could result in a situation where we can't even setup
80 * the mov's right neighbor ptr if the next instr also needs
81 * a mov.
82 */
83 restart:
84 for (unsigned i = 0; i < n; i++) {
85 struct ir3_instruction *instr = ssa(regs[i]);
86 if (instr) {
87 struct ir3_instruction *left = (i > 0) ? ssa(regs[i - 1]) : NULL;
88 struct ir3_instruction *right = (i < (n-1)) ? ssa(regs[i + 1]) : NULL;
89 bool conflict;
90
91 /* check for left/right neighbor conflicts: */
92 conflict = conflicts(instr->cp.left, left) ||
93 conflicts(instr->cp.right, right);
94
95 /* Mixing array elements and higher register classes
96 * (ie. groups) doesn't really work out in RA. See:
97 *
98 * https://trello.com/c/DqeDkeVf/156-bug-with-stk-70frag
99 */
100 if (instr->regs[0]->flags & IR3_REG_ARRAY)
101 conflict = true;
102
103 /* we also can't have an instr twice in the group: */
104 for (unsigned j = i + 1; (j < n) && !conflict; j++)
105 if (in_neighbor_list(ssa(regs[j]), instr, i))
106 conflict = true;
107
108 if (conflict) {
109 insert_mov(collect, i);
110 /* inserting the mov may have caused a conflict
111 * against the previous:
112 */
113 goto restart;
114 }
115 }
116 }
117
118 /* second pass, now that we've inserted mov's, fixup left/right
119 * neighbors. This is guaranteed to succeed, since by definition
120 * the newly inserted mov's cannot conflict with anything.
121 */
122 for (unsigned i = 0; i < n; i++) {
123 struct ir3_instruction *instr = ssa(regs[i]);
124 if (instr) {
125 struct ir3_instruction *left = (i > 0) ? ssa(regs[i - 1]) : NULL;
126 struct ir3_instruction *right = (i < (n-1)) ? ssa(regs[i + 1]) : NULL;
127
128 debug_assert(!conflicts(instr->cp.left, left));
129 if (left) {
130 instr->cp.left_cnt++;
131 instr->cp.left = left;
132 }
133
134 debug_assert(!conflicts(instr->cp.right, right));
135 if (right) {
136 instr->cp.right_cnt++;
137 instr->cp.right = right;
138 }
139 }
140 }
141 }
142
143 static bool
instr_find_neighbors(struct ir3_instruction * instr)144 instr_find_neighbors(struct ir3_instruction *instr)
145 {
146 bool progress = false;
147
148 if (ir3_instr_check_mark(instr))
149 return false;
150
151 if (instr->opc == OPC_META_COLLECT) {
152 group_collect(instr);
153 progress = true;
154 }
155
156 foreach_ssa_src (src, instr)
157 progress |= instr_find_neighbors(src);
158
159 return progress;
160 }
161
162 static bool
find_neighbors(struct ir3 * ir)163 find_neighbors(struct ir3 *ir)
164 {
165 bool progress = false;
166 unsigned i;
167
168 foreach_output (out, ir)
169 progress |= instr_find_neighbors(out);
170
171 foreach_block (block, &ir->block_list) {
172 for (i = 0; i < block->keeps_count; i++) {
173 struct ir3_instruction *instr = block->keeps[i];
174 progress |= instr_find_neighbors(instr);
175 }
176
177 /* We also need to account for if-condition: */
178 if (block->condition)
179 progress |= instr_find_neighbors(block->condition);
180 }
181
182 return progress;
183 }
184
185 bool
ir3_group(struct ir3 * ir)186 ir3_group(struct ir3 *ir)
187 {
188 ir3_clear_mark(ir);
189 return find_neighbors(ir);
190 }
191