1/*
2 * Copyright © 2012 Intel Corporation
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#include "brw_fs.h"
25#include "brw_fs_cfg.h"
26
27namespace { /* avoid conflict with opt_copy_propagation_elements */
28struct acp_entry : public exec_node {
29   fs_reg dst;
30   fs_reg src;
31};
32}
33
34bool
35fs_visitor::try_copy_propagate(fs_inst *inst, int arg, acp_entry *entry)
36{
37   if (inst->src[arg].file != entry->dst.file ||
38       inst->src[arg].reg != entry->dst.reg ||
39       inst->src[arg].reg_offset != entry->dst.reg_offset) {
40      return false;
41   }
42
43   /* See resolve_ud_negate() and comment in brw_fs_emit.cpp. */
44   if (inst->conditional_mod &&
45       inst->src[arg].type == BRW_REGISTER_TYPE_UD &&
46       entry->src.negate)
47      return false;
48
49   bool has_source_modifiers = entry->src.abs || entry->src.negate;
50
51   if (intel->gen == 6 && inst->is_math() &&
52       (has_source_modifiers || entry->src.file == UNIFORM))
53      return false;
54
55   inst->src[arg].file = entry->src.file;
56   inst->src[arg].reg = entry->src.reg;
57   inst->src[arg].reg_offset = entry->src.reg_offset;
58
59   if (!inst->src[arg].abs) {
60      inst->src[arg].abs = entry->src.abs;
61      inst->src[arg].negate ^= entry->src.negate;
62   }
63
64   return true;
65}
66
67/** @file brw_fs_copy_propagation.cpp
68 *
69 * Support for local copy propagation by walking the list of instructions
70 * and maintaining the ACP table of available copies for propagation.
71 *
72 * See Muchnik's Advanced Compiler Design and Implementation, section
73 * 12.5 (p356).
74 */
75
76/* Walks a basic block and does copy propagation on it using the acp
77 * list.
78 */
79bool
80fs_visitor::opt_copy_propagate_local(void *mem_ctx,
81				     fs_bblock *block, exec_list *acp)
82{
83   bool progress = false;
84
85   for (fs_inst *inst = block->start;
86	inst != block->end->next;
87	inst = (fs_inst *)inst->next) {
88
89      /* Try propagating into this instruction. */
90      foreach_list(entry_node, acp) {
91	 acp_entry *entry = (acp_entry *)entry_node;
92
93	 for (int i = 0; i < 3; i++) {
94	    if (try_copy_propagate(inst, i, entry))
95	       progress = true;
96	 }
97      }
98
99      /* kill the destination from the ACP */
100      if (inst->dst.file == GRF) {
101	 foreach_list_safe(entry_node, acp) {
102	    acp_entry *entry = (acp_entry *)entry_node;
103
104	    if (inst->overwrites_reg(entry->dst) ||
105                inst->overwrites_reg(entry->src)) {
106	       entry->remove();
107	    }
108	 }
109      }
110
111      /* If this instruction is a raw copy, add it to the ACP. */
112      if (inst->opcode == BRW_OPCODE_MOV &&
113	  inst->dst.file == GRF &&
114	  ((inst->src[0].file == GRF &&
115	    (inst->src[0].reg != inst->dst.reg ||
116	     inst->src[0].reg_offset != inst->dst.reg_offset)) ||
117	   inst->src[0].file == UNIFORM) &&
118	  inst->src[0].type == inst->dst.type &&
119	  !inst->saturate &&
120	  !inst->predicated &&
121	  !inst->force_uncompressed &&
122	  !inst->force_sechalf &&
123	  inst->src[0].smear == -1) {
124	 acp_entry *entry = ralloc(mem_ctx, acp_entry);
125	 entry->dst = inst->dst;
126	 entry->src = inst->src[0];
127	 acp->push_tail(entry);
128      }
129   }
130
131   return progress;
132}
133
134bool
135fs_visitor::opt_copy_propagate()
136{
137   bool progress = false;
138   void *mem_ctx = ralloc_context(this->mem_ctx);
139
140   fs_cfg cfg(this);
141
142   for (int b = 0; b < cfg.num_blocks; b++) {
143      fs_bblock *block = cfg.blocks[b];
144      exec_list acp;
145
146      progress = opt_copy_propagate_local(mem_ctx, block, &acp) || progress;
147   }
148
149   ralloc_free(mem_ctx);
150
151   if (progress)
152      live_intervals_valid = false;
153
154   return progress;
155}
156