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 "ir_builder.h" 25#include "program/prog_instruction.h" 26 27using namespace ir_builder; 28 29namespace ir_builder { 30 31void 32ir_factory::emit(ir_instruction *ir) 33{ 34 instructions->push_tail(ir); 35} 36 37ir_variable * 38ir_factory::make_temp(const glsl_type *type, const char *name) 39{ 40 ir_variable *var; 41 42 var = new(mem_ctx) ir_variable(type, name, ir_var_temporary); 43 emit(var); 44 45 return var; 46} 47 48ir_assignment * 49assign(deref lhs, operand rhs, operand condition, int writemask) 50{ 51 void *mem_ctx = ralloc_parent(lhs.val); 52 53 ir_assignment *assign = new(mem_ctx) ir_assignment(lhs.val, 54 rhs.val, 55 condition.val, 56 writemask); 57 58 return assign; 59} 60 61ir_assignment * 62assign(deref lhs, operand rhs) 63{ 64 return assign(lhs, rhs, (1 << lhs.val->type->vector_elements) - 1); 65} 66 67ir_assignment * 68assign(deref lhs, operand rhs, int writemask) 69{ 70 return assign(lhs, rhs, (ir_rvalue *) NULL, writemask); 71} 72 73ir_assignment * 74assign(deref lhs, operand rhs, operand condition) 75{ 76 return assign(lhs, rhs, condition, (1 << lhs.val->type->vector_elements) - 1); 77} 78 79ir_return * 80ret(operand retval) 81{ 82 void *mem_ctx = ralloc_parent(retval.val); 83 return new(mem_ctx) ir_return(retval.val); 84} 85 86ir_swizzle * 87swizzle(operand a, int swizzle, int components) 88{ 89 void *mem_ctx = ralloc_parent(a.val); 90 91 return new(mem_ctx) ir_swizzle(a.val, 92 GET_SWZ(swizzle, 0), 93 GET_SWZ(swizzle, 1), 94 GET_SWZ(swizzle, 2), 95 GET_SWZ(swizzle, 3), 96 components); 97} 98 99ir_swizzle * 100swizzle_for_size(operand a, unsigned components) 101{ 102 void *mem_ctx = ralloc_parent(a.val); 103 104 if (a.val->type->vector_elements < components) 105 components = a.val->type->vector_elements; 106 107 unsigned s[4] = { 0, 1, 2, 3 }; 108 for (int i = components; i < 4; i++) 109 s[i] = components - 1; 110 111 return new(mem_ctx) ir_swizzle(a.val, s, components); 112} 113 114ir_swizzle * 115swizzle_xxxx(operand a) 116{ 117 return swizzle(a, SWIZZLE_XXXX, 4); 118} 119 120ir_swizzle * 121swizzle_yyyy(operand a) 122{ 123 return swizzle(a, SWIZZLE_YYYY, 4); 124} 125 126ir_swizzle * 127swizzle_zzzz(operand a) 128{ 129 return swizzle(a, SWIZZLE_ZZZZ, 4); 130} 131 132ir_swizzle * 133swizzle_wwww(operand a) 134{ 135 return swizzle(a, SWIZZLE_WWWW, 4); 136} 137 138ir_swizzle * 139swizzle_x(operand a) 140{ 141 return swizzle(a, SWIZZLE_XXXX, 1); 142} 143 144ir_swizzle * 145swizzle_y(operand a) 146{ 147 return swizzle(a, SWIZZLE_YYYY, 1); 148} 149 150ir_swizzle * 151swizzle_z(operand a) 152{ 153 return swizzle(a, SWIZZLE_ZZZZ, 1); 154} 155 156ir_swizzle * 157swizzle_w(operand a) 158{ 159 return swizzle(a, SWIZZLE_WWWW, 1); 160} 161 162ir_swizzle * 163swizzle_xy(operand a) 164{ 165 return swizzle(a, SWIZZLE_XYZW, 2); 166} 167 168ir_swizzle * 169swizzle_xyz(operand a) 170{ 171 return swizzle(a, SWIZZLE_XYZW, 3); 172} 173 174ir_swizzle * 175swizzle_xyzw(operand a) 176{ 177 return swizzle(a, SWIZZLE_XYZW, 4); 178} 179 180ir_expression * 181expr(ir_expression_operation op, operand a) 182{ 183 void *mem_ctx = ralloc_parent(a.val); 184 185 return new(mem_ctx) ir_expression(op, a.val); 186} 187 188ir_expression * 189expr(ir_expression_operation op, operand a, operand b) 190{ 191 void *mem_ctx = ralloc_parent(a.val); 192 193 return new(mem_ctx) ir_expression(op, a.val, b.val); 194} 195 196ir_expression * 197expr(ir_expression_operation op, operand a, operand b, operand c) 198{ 199 void *mem_ctx = ralloc_parent(a.val); 200 201 return new(mem_ctx) ir_expression(op, a.val, b.val, c.val); 202} 203 204ir_expression *add(operand a, operand b) 205{ 206 return expr(ir_binop_add, a, b); 207} 208 209ir_expression *sub(operand a, operand b) 210{ 211 return expr(ir_binop_sub, a, b); 212} 213 214ir_expression *min2(operand a, operand b) 215{ 216 return expr(ir_binop_min, a, b); 217} 218 219ir_expression *max2(operand a, operand b) 220{ 221 return expr(ir_binop_max, a, b); 222} 223 224ir_expression *mul(operand a, operand b) 225{ 226 return expr(ir_binop_mul, a, b); 227} 228 229ir_expression *imul_high(operand a, operand b) 230{ 231 return expr(ir_binop_imul_high, a, b); 232} 233 234ir_expression *div(operand a, operand b) 235{ 236 return expr(ir_binop_div, a, b); 237} 238 239ir_expression *carry(operand a, operand b) 240{ 241 return expr(ir_binop_carry, a, b); 242} 243 244ir_expression *borrow(operand a, operand b) 245{ 246 return expr(ir_binop_borrow, a, b); 247} 248 249ir_expression *trunc(operand a) 250{ 251 return expr(ir_unop_trunc, a); 252} 253 254ir_expression *round_even(operand a) 255{ 256 return expr(ir_unop_round_even, a); 257} 258 259ir_expression *fract(operand a) 260{ 261 return expr(ir_unop_fract, a); 262} 263 264/* dot for vectors, mul for scalars */ 265ir_expression *dot(operand a, operand b) 266{ 267 assert(a.val->type == b.val->type); 268 269 if (a.val->type->vector_elements == 1) 270 return expr(ir_binop_mul, a, b); 271 272 return expr(ir_binop_dot, a, b); 273} 274 275ir_expression* 276clamp(operand a, operand b, operand c) 277{ 278 return expr(ir_binop_min, expr(ir_binop_max, a, b), c); 279} 280 281ir_expression * 282saturate(operand a) 283{ 284 return expr(ir_unop_saturate, a); 285} 286 287ir_expression * 288abs(operand a) 289{ 290 return expr(ir_unop_abs, a); 291} 292 293ir_expression * 294neg(operand a) 295{ 296 return expr(ir_unop_neg, a); 297} 298 299ir_expression * 300sin(operand a) 301{ 302 return expr(ir_unop_sin, a); 303} 304 305ir_expression * 306cos(operand a) 307{ 308 return expr(ir_unop_cos, a); 309} 310 311ir_expression * 312exp(operand a) 313{ 314 return expr(ir_unop_exp, a); 315} 316 317ir_expression * 318rsq(operand a) 319{ 320 return expr(ir_unop_rsq, a); 321} 322 323ir_expression * 324sqrt(operand a) 325{ 326 return expr(ir_unop_sqrt, a); 327} 328 329ir_expression * 330log(operand a) 331{ 332 return expr(ir_unop_log, a); 333} 334 335ir_expression * 336sign(operand a) 337{ 338 return expr(ir_unop_sign, a); 339} 340 341ir_expression * 342subr_to_int(operand a) 343{ 344 return expr(ir_unop_subroutine_to_int, a); 345} 346 347ir_expression* 348equal(operand a, operand b) 349{ 350 return expr(ir_binop_equal, a, b); 351} 352 353ir_expression* 354nequal(operand a, operand b) 355{ 356 return expr(ir_binop_nequal, a, b); 357} 358 359ir_expression* 360less(operand a, operand b) 361{ 362 return expr(ir_binop_less, a, b); 363} 364 365ir_expression* 366greater(operand a, operand b) 367{ 368 return expr(ir_binop_greater, a, b); 369} 370 371ir_expression* 372lequal(operand a, operand b) 373{ 374 return expr(ir_binop_lequal, a, b); 375} 376 377ir_expression* 378gequal(operand a, operand b) 379{ 380 return expr(ir_binop_gequal, a, b); 381} 382 383ir_expression* 384logic_not(operand a) 385{ 386 return expr(ir_unop_logic_not, a); 387} 388 389ir_expression* 390logic_and(operand a, operand b) 391{ 392 return expr(ir_binop_logic_and, a, b); 393} 394 395ir_expression* 396logic_or(operand a, operand b) 397{ 398 return expr(ir_binop_logic_or, a, b); 399} 400 401ir_expression* 402bit_not(operand a) 403{ 404 return expr(ir_unop_bit_not, a); 405} 406 407ir_expression* 408bit_and(operand a, operand b) 409{ 410 return expr(ir_binop_bit_and, a, b); 411} 412 413ir_expression* 414bit_or(operand a, operand b) 415{ 416 return expr(ir_binop_bit_or, a, b); 417} 418 419ir_expression* 420bit_xor(operand a, operand b) 421{ 422 return expr(ir_binop_bit_xor, a, b); 423} 424 425ir_expression* 426lshift(operand a, operand b) 427{ 428 return expr(ir_binop_lshift, a, b); 429} 430 431ir_expression* 432rshift(operand a, operand b) 433{ 434 return expr(ir_binop_rshift, a, b); 435} 436 437ir_expression* 438f2i(operand a) 439{ 440 return expr(ir_unop_f2i, a); 441} 442 443ir_expression* 444bitcast_f2i(operand a) 445{ 446 return expr(ir_unop_bitcast_f2i, a); 447} 448 449ir_expression* 450i2f(operand a) 451{ 452 return expr(ir_unop_i2f, a); 453} 454 455ir_expression* 456bitcast_i2f(operand a) 457{ 458 return expr(ir_unop_bitcast_i2f, a); 459} 460 461ir_expression* 462i2u(operand a) 463{ 464 return expr(ir_unop_i2u, a); 465} 466 467ir_expression* 468u2i(operand a) 469{ 470 return expr(ir_unop_u2i, a); 471} 472 473ir_expression* 474f2u(operand a) 475{ 476 return expr(ir_unop_f2u, a); 477} 478 479ir_expression* 480bitcast_f2u(operand a) 481{ 482 return expr(ir_unop_bitcast_f2u, a); 483} 484 485ir_expression* 486u2f(operand a) 487{ 488 return expr(ir_unop_u2f, a); 489} 490 491ir_expression* 492bitcast_u2f(operand a) 493{ 494 return expr(ir_unop_bitcast_u2f, a); 495} 496 497ir_expression* 498i2b(operand a) 499{ 500 return expr(ir_unop_i2b, a); 501} 502 503ir_expression* 504b2i(operand a) 505{ 506 return expr(ir_unop_b2i, a); 507} 508 509ir_expression * 510f2b(operand a) 511{ 512 return expr(ir_unop_f2b, a); 513} 514 515ir_expression * 516b2f(operand a) 517{ 518 return expr(ir_unop_b2f, a); 519} 520 521ir_expression * 522interpolate_at_centroid(operand a) 523{ 524 return expr(ir_unop_interpolate_at_centroid, a); 525} 526 527ir_expression * 528interpolate_at_offset(operand a, operand b) 529{ 530 return expr(ir_binop_interpolate_at_offset, a, b); 531} 532 533ir_expression * 534interpolate_at_sample(operand a, operand b) 535{ 536 return expr(ir_binop_interpolate_at_sample, a, b); 537} 538 539ir_expression * 540f2d(operand a) 541{ 542 return expr(ir_unop_f2d, a); 543} 544 545ir_expression * 546i2d(operand a) 547{ 548 return expr(ir_unop_i2d, a); 549} 550 551ir_expression * 552u2d(operand a) 553{ 554 return expr(ir_unop_u2d, a); 555} 556 557ir_expression * 558fma(operand a, operand b, operand c) 559{ 560 return expr(ir_triop_fma, a, b, c); 561} 562 563ir_expression * 564lrp(operand x, operand y, operand a) 565{ 566 return expr(ir_triop_lrp, x, y, a); 567} 568 569ir_expression * 570csel(operand a, operand b, operand c) 571{ 572 return expr(ir_triop_csel, a, b, c); 573} 574 575ir_expression * 576bitfield_extract(operand a, operand b, operand c) 577{ 578 return expr(ir_triop_bitfield_extract, a, b, c); 579} 580 581ir_expression * 582bitfield_insert(operand a, operand b, operand c, operand d) 583{ 584 void *mem_ctx = ralloc_parent(a.val); 585 return new(mem_ctx) ir_expression(ir_quadop_bitfield_insert, 586 a.val->type, a.val, b.val, c.val, d.val); 587} 588 589ir_if* 590if_tree(operand condition, 591 ir_instruction *then_branch) 592{ 593 assert(then_branch != NULL); 594 595 void *mem_ctx = ralloc_parent(condition.val); 596 597 ir_if *result = new(mem_ctx) ir_if(condition.val); 598 result->then_instructions.push_tail(then_branch); 599 return result; 600} 601 602ir_if* 603if_tree(operand condition, 604 ir_instruction *then_branch, 605 ir_instruction *else_branch) 606{ 607 assert(then_branch != NULL); 608 assert(else_branch != NULL); 609 610 void *mem_ctx = ralloc_parent(condition.val); 611 612 ir_if *result = new(mem_ctx) ir_if(condition.val); 613 result->then_instructions.push_tail(then_branch); 614 result->else_instructions.push_tail(else_branch); 615 return result; 616} 617 618} /* namespace ir_builder */ 619