1 /* -*- c++ -*- */ 2 /* 3 * Copyright © 2010 Intel Corporation 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 */ 24 25 #pragma once 26 #ifndef IR_HIERARCHICAL_VISITOR_H 27 #define IR_HIERARCHICAL_VISITOR_H 28 29 /** 30 * Enumeration values returned by visit methods to guide processing 31 */ 32 enum ir_visitor_status { 33 visit_continue, /**< Continue visiting as normal. */ 34 visit_continue_with_parent, /**< Don't visit siblings, continue w/parent. */ 35 visit_stop /**< Stop visiting immediately. */ 36 }; 37 38 39 #ifdef __cplusplus 40 /** 41 * Base class of hierarchical visitors of IR instruction trees 42 * 43 * Hierarchical visitors differ from traditional visitors in a couple of 44 * important ways. Rather than having a single \c visit method for each 45 * subclass in the composite, there are three kinds of visit methods. 46 * Leaf-node classes have a traditional \c visit method. Internal-node 47 * classes have a \c visit_enter method, which is invoked just before 48 * processing child nodes, and a \c visit_leave method which is invoked just 49 * after processing child nodes. 50 * 51 * In addition, each visit method and the \c accept methods in the composite 52 * have a return value which guides the navigation. Any of the visit methods 53 * can choose to continue visiting the tree as normal (by returning \c 54 * visit_continue), terminate visiting any further nodes immediately (by 55 * returning \c visit_stop), or stop visiting sibling nodes (by returning \c 56 * visit_continue_with_parent). 57 * 58 * These two changes combine to allow nagivation of children to be implemented 59 * in the composite's \c accept method. The \c accept method for a leaf-node 60 * class will simply call the \c visit method, as usual, and pass its return 61 * value on. The \c accept method for internal-node classes will call the \c 62 * visit_enter method, call the \c accpet method of each child node, and, 63 * finally, call the \c visit_leave method. If any of these return a value 64 * other that \c visit_continue, the correct action must be taken. 65 * 66 * The final benefit is that the hierarchical visitor base class need not be 67 * abstract. Default implementations of every \c visit, \c visit_enter, and 68 * \c visit_leave method can be provided. By default each of these methods 69 * simply returns \c visit_continue. This allows a significant reduction in 70 * derived class code. 71 * 72 * For more information about hierarchical visitors, see: 73 * 74 * http://c2.com/cgi/wiki?HierarchicalVisitorPattern 75 * http://c2.com/cgi/wiki?HierarchicalVisitorDiscussion 76 */ 77 78 class ir_hierarchical_visitor { 79 public: 80 ir_hierarchical_visitor(); 81 82 /** 83 * \name Visit methods for leaf-node classes 84 */ 85 /*@{*/ 86 virtual ir_visitor_status visit(class ir_rvalue *); 87 virtual ir_visitor_status visit(class ir_variable *); 88 virtual ir_visitor_status visit(class ir_constant *); 89 virtual ir_visitor_status visit(class ir_loop_jump *); 90 virtual ir_visitor_status visit(class ir_precision_statement *); 91 virtual ir_visitor_status visit(class ir_typedecl_statement *); 92 93 /** 94 * ir_dereference_variable isn't technically a leaf, but it is treated as a 95 * leaf here for a couple reasons. By not automatically visiting the one 96 * child ir_variable node from the ir_dereference_variable, ir_variable 97 * nodes can always be handled as variable declarations. Code that used 98 * non-hierarchical visitors had to set an "in a dereference" flag to 99 * determine how to handle an ir_variable. By forcing the visitor to 100 * handle the ir_variable within the ir_dereference_variable visitor, this 101 * kludge can be avoided. 102 * 103 * In addition, I can envision no use for having separate enter and leave 104 * methods. Anything that could be done in the enter and leave methods 105 * that couldn't just be done in the visit method. 106 */ 107 virtual ir_visitor_status visit(class ir_dereference_variable *); 108 /*@}*/ 109 110 /** 111 * \name Visit methods for internal-node classes 112 */ 113 /*@{*/ 114 virtual ir_visitor_status visit_enter(class ir_loop *); 115 virtual ir_visitor_status visit_leave(class ir_loop *); 116 virtual ir_visitor_status visit_enter(class ir_function_signature *); 117 virtual ir_visitor_status visit_leave(class ir_function_signature *); 118 virtual ir_visitor_status visit_enter(class ir_function *); 119 virtual ir_visitor_status visit_leave(class ir_function *); 120 virtual ir_visitor_status visit_enter(class ir_expression *); 121 virtual ir_visitor_status visit_leave(class ir_expression *); 122 virtual ir_visitor_status visit_enter(class ir_texture *); 123 virtual ir_visitor_status visit_leave(class ir_texture *); 124 virtual ir_visitor_status visit_enter(class ir_swizzle *); 125 virtual ir_visitor_status visit_leave(class ir_swizzle *); 126 virtual ir_visitor_status visit_enter(class ir_dereference_array *); 127 virtual ir_visitor_status visit_leave(class ir_dereference_array *); 128 virtual ir_visitor_status visit_enter(class ir_dereference_record *); 129 virtual ir_visitor_status visit_leave(class ir_dereference_record *); 130 virtual ir_visitor_status visit_enter(class ir_assignment *); 131 virtual ir_visitor_status visit_leave(class ir_assignment *); 132 virtual ir_visitor_status visit_enter(class ir_call *); 133 virtual ir_visitor_status visit_leave(class ir_call *); 134 virtual ir_visitor_status visit_enter(class ir_return *); 135 virtual ir_visitor_status visit_leave(class ir_return *); 136 virtual ir_visitor_status visit_enter(class ir_discard *); 137 virtual ir_visitor_status visit_leave(class ir_discard *); 138 virtual ir_visitor_status visit_enter(class ir_if *); 139 virtual ir_visitor_status visit_leave(class ir_if *); 140 virtual ir_visitor_status visit_enter(class ir_emit_vertex *); 141 virtual ir_visitor_status visit_leave(class ir_emit_vertex *); 142 virtual ir_visitor_status visit_enter(class ir_end_primitive *); 143 virtual ir_visitor_status visit_leave(class ir_end_primitive *); 144 /*@}*/ 145 146 147 /** 148 * Utility function to process a linked list of instructions with a visitor 149 */ 150 void run(struct exec_list *instructions); 151 152 /* Some visitors may need to insert new variable declarations and 153 * assignments for portions of a subtree, which means they need a 154 * pointer to the current instruction in the stream, not just their 155 * node in the tree rooted at that instruction. 156 * 157 * This is implemented by visit_list_elements -- if the visitor is 158 * not called by it, nothing good will happen. 159 */ 160 class ir_instruction *base_ir; 161 162 /** 163 * Callback function that is invoked on entry to each node visited. 164 * 165 * \warning 166 * Visitor classes derived from \c ir_hierarchical_visitor \b may \b not 167 * invoke this function. This can be used, for example, to cause the 168 * callback to be invoked on every node type except one. 169 */ 170 void (*callback_enter)(class ir_instruction *ir, void *data); 171 172 /** 173 * Callback function that is invoked on exit of each node visited. 174 * 175 * \warning 176 * Visitor classes derived from \c ir_hierarchical_visitor \b may \b not 177 * invoke this function. This can be used, for example, to cause the 178 * callback to be invoked on every node type except one. 179 */ 180 void (*callback_leave)(class ir_instruction *ir, void *data); 181 182 /** 183 * Extra data parameter passed to the per-node callback_enter function 184 */ 185 void *data_enter; 186 187 /** 188 * Extra data parameter passed to the per-node callback_leave function 189 */ 190 void *data_leave; 191 192 /** 193 * Currently in the LHS of an assignment? 194 * 195 * This is set and cleared by the \c ir_assignment::accept method. 196 */ 197 bool in_assignee; 198 }; 199 200 void visit_tree(ir_instruction *ir, 201 void (*callback_enter)(class ir_instruction *ir, void *data), 202 void *data_enter, 203 void (*callback_leave)(class ir_instruction *ir, void *data) = NULL, 204 void *data_leave = NULL); 205 206 ir_visitor_status visit_list_elements(ir_hierarchical_visitor *v, exec_list *l, 207 bool statement_list = true); 208 #endif /* __cplusplus */ 209 210 #endif /* IR_HIERARCHICAL_VISITOR_H */ 211