1 /* 2 * Copyright 2010 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 21 * DEALINGS IN THE SOFTWARE. 22 */ 23 24 #include <string.h> 25 #include "main/compiler.h" 26 #include "ir.h" 27 #include "glsl_types.h" 28 extern "C" { 29 #include "program/hash_table.h" 30 } 31 32 /** 33 * Duplicate an IR variable 34 * 35 * \note 36 * This will probably be made \c virtual and moved to the base class 37 * eventually. 38 */ 39 ir_variable * 40 ir_variable::clone(void *mem_ctx, struct hash_table *ht) const 41 { 42 ir_variable *var = new(mem_ctx) ir_variable(this->type, this->name, 43 (ir_variable_mode) this->mode); 44 45 var->max_array_access = this->max_array_access; 46 var->read_only = this->read_only; 47 var->centroid = this->centroid; 48 var->invariant = this->invariant; 49 var->interpolation = this->interpolation; 50 var->array_lvalue = this->array_lvalue; 51 var->location = this->location; 52 var->warn_extension = this->warn_extension; 53 var->origin_upper_left = this->origin_upper_left; 54 var->pixel_center_integer = this->pixel_center_integer; 55 var->explicit_location = this->explicit_location; 56 if (this->explicit_location) 57 var->location = this->location; 58 59 if (this->constant_value) 60 var->constant_value = this->constant_value->clone(mem_ctx, ht); 61 62 if (ht) { 63 hash_table_insert(ht, var, (void *)const_cast<ir_variable *>(this)); 64 } 65 66 return var; 67 } 68 69 ir_swizzle * 70 ir_swizzle::clone(void *mem_ctx, struct hash_table *ht) const 71 { 72 return new(mem_ctx) ir_swizzle(this->val->clone(mem_ctx, ht), this->mask); 73 } 74 75 ir_return * 76 ir_return::clone(void *mem_ctx, struct hash_table *ht) const 77 { 78 ir_rvalue *new_value = NULL; 79 80 if (this->value) 81 new_value = this->value->clone(mem_ctx, ht); 82 83 return new(mem_ctx) ir_return(new_value); 84 } 85 86 ir_discard * 87 ir_discard::clone(void *mem_ctx, struct hash_table *ht) const 88 { 89 ir_rvalue *new_condition = NULL; 90 91 if (this->condition != NULL) 92 new_condition = this->condition->clone(mem_ctx, ht); 93 94 return new(mem_ctx) ir_discard(new_condition); 95 } 96 97 ir_loop_jump * 98 ir_loop_jump::clone(void *mem_ctx, struct hash_table *ht) const 99 { 100 (void)ht; 101 102 return new(mem_ctx) ir_loop_jump(this->mode); 103 } 104 105 ir_if * 106 ir_if::clone(void *mem_ctx, struct hash_table *ht) const 107 { 108 ir_if *new_if = new(mem_ctx) ir_if(this->condition->clone(mem_ctx, ht)); 109 110 foreach_iter(exec_list_iterator, iter, this->then_instructions) { 111 ir_instruction *ir = (ir_instruction *)iter.get(); 112 new_if->then_instructions.push_tail(ir->clone(mem_ctx, ht)); 113 } 114 115 foreach_iter(exec_list_iterator, iter, this->else_instructions) { 116 ir_instruction *ir = (ir_instruction *)iter.get(); 117 new_if->else_instructions.push_tail(ir->clone(mem_ctx, ht)); 118 } 119 120 return new_if; 121 } 122 123 ir_loop * 124 ir_loop::clone(void *mem_ctx, struct hash_table *ht) const 125 { 126 ir_loop *new_loop = new(mem_ctx) ir_loop(); 127 128 if (this->from) 129 new_loop->from = this->from->clone(mem_ctx, ht); 130 if (this->to) 131 new_loop->to = this->to->clone(mem_ctx, ht); 132 if (this->increment) 133 new_loop->increment = this->increment->clone(mem_ctx, ht); 134 new_loop->counter = counter; 135 136 foreach_iter(exec_list_iterator, iter, this->body_instructions) { 137 ir_instruction *ir = (ir_instruction *)iter.get(); 138 new_loop->body_instructions.push_tail(ir->clone(mem_ctx, ht)); 139 } 140 141 new_loop->cmp = this->cmp; 142 return new_loop; 143 } 144 145 ir_call * 146 ir_call::clone(void *mem_ctx, struct hash_table *ht) const 147 { 148 if (this->type == glsl_type::error_type) 149 return ir_call::get_error_instruction(mem_ctx); 150 151 exec_list new_parameters; 152 153 foreach_iter(exec_list_iterator, iter, this->actual_parameters) { 154 ir_instruction *ir = (ir_instruction *)iter.get(); 155 new_parameters.push_tail(ir->clone(mem_ctx, ht)); 156 } 157 158 return new(mem_ctx) ir_call(this->callee, &new_parameters); 159 } 160 161 ir_expression * 162 ir_expression::clone(void *mem_ctx, struct hash_table *ht) const 163 { 164 ir_rvalue *op[Elements(this->operands)] = { NULL, }; 165 unsigned int i; 166 167 for (i = 0; i < get_num_operands(); i++) { 168 op[i] = this->operands[i]->clone(mem_ctx, ht); 169 } 170 171 return new(mem_ctx) ir_expression(this->operation, this->type, 172 op[0], op[1], op[2], op[3]); 173 } 174 175 ir_dereference_variable * 176 ir_dereference_variable::clone(void *mem_ctx, struct hash_table *ht) const 177 { 178 ir_variable *new_var; 179 180 if (ht) { 181 new_var = (ir_variable *)hash_table_find(ht, this->var); 182 if (!new_var) 183 new_var = this->var; 184 } else { 185 new_var = this->var; 186 } 187 188 return new(mem_ctx) ir_dereference_variable(new_var); 189 } 190 191 ir_dereference_array * 192 ir_dereference_array::clone(void *mem_ctx, struct hash_table *ht) const 193 { 194 return new(mem_ctx) ir_dereference_array(this->array->clone(mem_ctx, ht), 195 this->array_index->clone(mem_ctx, 196 ht)); 197 } 198 199 ir_dereference_record * 200 ir_dereference_record::clone(void *mem_ctx, struct hash_table *ht) const 201 { 202 return new(mem_ctx) ir_dereference_record(this->record->clone(mem_ctx, ht), 203 this->field); 204 } 205 206 ir_texture * 207 ir_texture::clone(void *mem_ctx, struct hash_table *ht) const 208 { 209 ir_texture *new_tex = new(mem_ctx) ir_texture(this->op); 210 new_tex->type = this->type; 211 212 new_tex->sampler = this->sampler->clone(mem_ctx, ht); 213 new_tex->coordinate = this->coordinate->clone(mem_ctx, ht); 214 if (this->projector) 215 new_tex->projector = this->projector->clone(mem_ctx, ht); 216 if (this->shadow_comparitor) { 217 new_tex->shadow_comparitor = this->shadow_comparitor->clone(mem_ctx, ht); 218 } 219 220 for (int i = 0; i < 3; i++) 221 new_tex->offsets[i] = this->offsets[i]; 222 223 switch (this->op) { 224 case ir_tex: 225 break; 226 case ir_txb: 227 new_tex->lod_info.bias = this->lod_info.bias->clone(mem_ctx, ht); 228 break; 229 case ir_txl: 230 case ir_txf: 231 new_tex->lod_info.lod = this->lod_info.lod->clone(mem_ctx, ht); 232 break; 233 case ir_txd: 234 new_tex->lod_info.grad.dPdx = this->lod_info.grad.dPdx->clone(mem_ctx, ht); 235 new_tex->lod_info.grad.dPdy = this->lod_info.grad.dPdy->clone(mem_ctx, ht); 236 break; 237 } 238 239 return new_tex; 240 } 241 242 ir_assignment * 243 ir_assignment::clone(void *mem_ctx, struct hash_table *ht) const 244 { 245 ir_rvalue *new_condition = NULL; 246 247 if (this->condition) 248 new_condition = this->condition->clone(mem_ctx, ht); 249 250 return new(mem_ctx) ir_assignment(this->lhs->clone(mem_ctx, ht), 251 this->rhs->clone(mem_ctx, ht), 252 new_condition, 253 this->write_mask); 254 } 255 256 ir_function * 257 ir_function::clone(void *mem_ctx, struct hash_table *ht) const 258 { 259 ir_function *copy = new(mem_ctx) ir_function(this->name); 260 261 foreach_list_const(node, &this->signatures) { 262 const ir_function_signature *const sig = 263 (const ir_function_signature *const) node; 264 265 ir_function_signature *sig_copy = sig->clone(mem_ctx, ht); 266 copy->add_signature(sig_copy); 267 268 if (ht != NULL) 269 hash_table_insert(ht, sig_copy, 270 (void *)const_cast<ir_function_signature *>(sig)); 271 } 272 273 return copy; 274 } 275 276 ir_function_signature * 277 ir_function_signature::clone(void *mem_ctx, struct hash_table *ht) const 278 { 279 ir_function_signature *copy = this->clone_prototype(mem_ctx, ht); 280 281 copy->is_defined = this->is_defined; 282 283 /* Clone the instruction list. 284 */ 285 foreach_list_const(node, &this->body) { 286 const ir_instruction *const inst = (const ir_instruction *) node; 287 288 ir_instruction *const inst_copy = inst->clone(mem_ctx, ht); 289 copy->body.push_tail(inst_copy); 290 } 291 292 return copy; 293 } 294 295 ir_function_signature * 296 ir_function_signature::clone_prototype(void *mem_ctx, struct hash_table *ht) const 297 { 298 ir_function_signature *copy = 299 new(mem_ctx) ir_function_signature(this->return_type); 300 301 copy->is_defined = false; 302 copy->is_builtin = this->is_builtin; 303 304 /* Clone the parameter list, but NOT the body. 305 */ 306 foreach_list_const(node, &this->parameters) { 307 const ir_variable *const param = (const ir_variable *) node; 308 309 assert(const_cast<ir_variable *>(param)->as_variable() != NULL); 310 311 ir_variable *const param_copy = param->clone(mem_ctx, ht); 312 copy->parameters.push_tail(param_copy); 313 } 314 315 return copy; 316 } 317 318 ir_constant * 319 ir_constant::clone(void *mem_ctx, struct hash_table *ht) const 320 { 321 (void)ht; 322 323 switch (this->type->base_type) { 324 case GLSL_TYPE_UINT: 325 case GLSL_TYPE_INT: 326 case GLSL_TYPE_FLOAT: 327 case GLSL_TYPE_BOOL: 328 return new(mem_ctx) ir_constant(this->type, &this->value); 329 330 case GLSL_TYPE_STRUCT: { 331 ir_constant *c = new(mem_ctx) ir_constant; 332 333 c->type = this->type; 334 for (exec_node *node = this->components.head 335 ; !node->is_tail_sentinel() 336 ; node = node->next) { 337 ir_constant *const orig = (ir_constant *) node; 338 339 c->components.push_tail(orig->clone(mem_ctx, NULL)); 340 } 341 342 return c; 343 } 344 345 case GLSL_TYPE_ARRAY: { 346 ir_constant *c = new(mem_ctx) ir_constant; 347 348 c->type = this->type; 349 c->array_elements = hieralloc_array(c, ir_constant *, this->type->length); 350 for (unsigned i = 0; i < this->type->length; i++) { 351 c->array_elements[i] = this->array_elements[i]->clone(mem_ctx, NULL); 352 } 353 return c; 354 } 355 356 default: 357 assert(!"Should not get here."); 358 return NULL; 359 } 360 } 361 362 363 class fixup_ir_call_visitor : public ir_hierarchical_visitor { 364 public: 365 fixup_ir_call_visitor(struct hash_table *ht) 366 { 367 this->ht = ht; 368 } 369 370 virtual ir_visitor_status visit_enter(ir_call *ir) 371 { 372 /* Try to find the function signature referenced by the ir_call in the 373 * table. If it is found, replace it with the value from the table. 374 */ 375 ir_function_signature *sig = 376 (ir_function_signature *) hash_table_find(this->ht, ir->get_callee()); 377 if (sig != NULL) 378 ir->set_callee(sig); 379 380 /* Since this may be used before function call parameters are flattened, 381 * the children also need to be processed. 382 */ 383 return visit_continue; 384 } 385 386 private: 387 struct hash_table *ht; 388 }; 389 390 391 static void 392 fixup_function_calls(struct hash_table *ht, exec_list *instructions) 393 { 394 fixup_ir_call_visitor v(ht); 395 v.run(instructions); 396 } 397 398 399 void 400 clone_ir_list(void *mem_ctx, exec_list *out, const exec_list *in) 401 { 402 struct hash_table *ht = 403 hash_table_ctor(0, hash_table_pointer_hash, hash_table_pointer_compare); 404 405 foreach_list_const(node, in) { 406 const ir_instruction *const original = (ir_instruction *) node; 407 ir_instruction *copy = original->clone(mem_ctx, ht); 408 409 out->push_tail(copy); 410 } 411 412 /* Make a pass over the cloned tree to fix up ir_call nodes to point to the 413 * cloned ir_function_signature nodes. This cannot be done automatically 414 * during cloning because the ir_call might be a forward reference (i.e., 415 * the function signature that it references may not have been cloned yet). 416 */ 417 fixup_function_calls(ht, out); 418 419 hash_table_dtor(ht); 420 } 421
