src/mesa/drivers/dri/i965/brw_eu.h

   1 /*
   2  Copyright (C) Intel Corp.  2006.  All Rights Reserved.
   3  Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
   4  develop this 3D driver.
   5
   6  Permission is hereby granted, free of charge, to any person obtaining
   7  a copy of this software and associated documentation files (the
   8  "Software"), to deal in the Software without restriction, including
   9  without limitation the rights to use, copy, modify, merge, publish,
  10  distribute, sublicense, and/or sell copies of the Software, and to
  11  permit persons to whom the Software is furnished to do so, subject to
  12  the following conditions:
  13
  14  The above copyright notice and this permission notice (including the
  15  next paragraph) shall be included in all copies or substantial
  16  portions of the Software.
  17
  18  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  22  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26  **********************************************************************/
  27  /*
  28   * Authors:
  29   *   Keith Whitwell <keith@tungstengraphics.com>
  30   */
  31
  32
  33 #ifndef BRW_EU_H
  34 #define BRW_EU_H
  35
  36 #include "brw_structs.h"
  37 #include "brw_defines.h"
  38 #include "shader/prog_instruction.h"
  39
  40 #define BRW_SWIZZLE4(a,b,c,d) (((a)<<0) | ((b)<<2) | ((c)<<4) | ((d)<<6))
  41 #define BRW_GET_SWZ(swz, idx) (((swz) >> ((idx)*2)) & 0x3)
  42
  43 #define BRW_SWIZZLE_NOOP      BRW_SWIZZLE4(0,1,2,3)
  44 #define BRW_SWIZZLE_XYZW      BRW_SWIZZLE4(0,1,2,3)
  45 #define BRW_SWIZZLE_XXXX      BRW_SWIZZLE4(0,0,0,0)
  46 #define BRW_SWIZZLE_XYXY      BRW_SWIZZLE4(0,1,0,1)
  47
  48
  49 #define REG_SIZE (8*4)
  50
  51
  52 /* These aren't hardware structs, just something useful for us to pass around:
  53  *
  54  * Align1 operation has a lot of control over input ranges.  Used in
  55  * WM programs to implement shaders decomposed into "channel serial"
  56  * or "structure of array" form:
  57  */
  58 struct brw_reg
  59 {
  60    GLuint type:4;
  61    GLuint file:2;
  62    GLuint nr:8;
  63    GLuint subnr:5;              /* :1 in align16 */
  64    GLuint negate:1;             /* source only */
  65    GLuint abs:1;                /* source only */
  66    GLuint vstride:4;            /* source only */
  67    GLuint width:3;              /* src only, align1 only */
  68    GLuint hstride:2;            /* src only, align1 only */
  69    GLuint address_mode:1;       /* relative addressing, hopefully! */
  70    GLuint pad0:1;
  71
  72    union {
  73       struct {
  74          GLuint swizzle:8;              /* src only, align16 only */
  75          GLuint writemask:4;            /* dest only, align16 only */
  76          GLint  indirect_offset:10;     /* relative addressing offset */
  77          GLuint pad1:10;                /* two dwords total */
  78       } bits;
  79
  80       GLfloat f;
  81       GLint   d;
  82       GLuint ud;
  83    } dw1;
  84 };
  85
  86
  87 struct brw_indirect {
  88    GLuint addr_subnr:4;
  89    GLint addr_offset:10;
  90    GLuint pad:18;
  91 };
  92
  93
  94 #define BRW_EU_MAX_INSN_STACK 5
  95 #define BRW_EU_MAX_INSN 1200
  96
  97 struct brw_compile {
  98    struct brw_instruction store[BRW_EU_MAX_INSN];
  99    GLuint nr_insn;
 100
 101    /* Allow clients to push/pop instruction state:
 102     */
 103    struct brw_instruction stack[BRW_EU_MAX_INSN_STACK];
 104    struct brw_instruction *current;
 105
 106    GLuint flag_value;
 107    GLboolean single_program_flow;
 108    struct brw_context *brw;
 109 };
 110
 111
 112
 113 static __inline int type_sz( GLuint type )
 114 {
 115    switch( type ) {
 116    case BRW_REGISTER_TYPE_UD:
 117    case BRW_REGISTER_TYPE_D:
 118    case BRW_REGISTER_TYPE_F:
 119       return 4;
 120    case BRW_REGISTER_TYPE_HF:
 121    case BRW_REGISTER_TYPE_UW:
 122    case BRW_REGISTER_TYPE_W:
 123       return 2;
 124    case BRW_REGISTER_TYPE_UB:
 125    case BRW_REGISTER_TYPE_B:
 126       return 1;
 127    default:
 128       return 0;
 129    }
 130 }
 131
 132 static __inline struct brw_reg brw_reg( GLuint file,
 133                                         GLuint nr,
 134                                         GLuint subnr,
 135                                         GLuint type,
 136                                         GLuint vstride,
 137                                         GLuint width,
 138                                         GLuint hstride,
 139                                         GLuint swizzle,
 140                                         GLuint writemask)
 141 {
 142
 143    struct brw_reg reg;
 144    reg.type = type;
 145    reg.file = file;
 146    reg.nr = nr;
 147    reg.subnr = subnr * type_sz(type);
 148    reg.negate = 0;
 149    reg.abs = 0;
 150    reg.vstride = vstride;
 151    reg.width = width;
 152    reg.hstride = hstride;
 153    reg.address_mode = BRW_ADDRESS_DIRECT;
 154    reg.pad0 = 0;
 155
 156    /* Could do better: If the reg is r5.3<0;1,0>, we probably want to
 157     * set swizzle and writemask to W, as the lower bits of subnr will
 158     * be lost when converted to align16.  This is probably too much to
 159     * keep track of as you'd want it adjusted by suboffset(), etc.
 160     * Perhaps fix up when converting to align16?
 161     */
 162    reg.dw1.bits.swizzle = swizzle;
 163    reg.dw1.bits.writemask = writemask;
 164    reg.dw1.bits.indirect_offset = 0;
 165    reg.dw1.bits.pad1 = 0;
 166    return reg;
 167 }
 168
 169 static __inline struct brw_reg brw_vec16_reg( GLuint file,
 170                                               GLuint nr,
 171                                               GLuint subnr )
 172 {
 173    return brw_reg(file,
 174                   nr,
 175                   subnr,
 176                   BRW_REGISTER_TYPE_F,
 177                   BRW_VERTICAL_STRIDE_16,
 178                   BRW_WIDTH_16,
 179                   BRW_HORIZONTAL_STRIDE_1,
 180                   BRW_SWIZZLE_XYZW,
 181                   WRITEMASK_XYZW);
 182 }
 183
 184 static __inline struct brw_reg brw_vec8_reg( GLuint file,
 185                                              GLuint nr,
 186                                              GLuint subnr )
 187 {
 188    return brw_reg(file,
 189                   nr,
 190                   subnr,
 191                   BRW_REGISTER_TYPE_F,
 192                   BRW_VERTICAL_STRIDE_8,
 193                   BRW_WIDTH_8,
 194                   BRW_HORIZONTAL_STRIDE_1,
 195                   BRW_SWIZZLE_XYZW,
 196                   WRITEMASK_XYZW);
 197 }
 198
 199
 200 static __inline struct brw_reg brw_vec4_reg( GLuint file,
 201                                               GLuint nr,
 202                                               GLuint subnr )
 203 {
 204    return brw_reg(file,
 205                   nr,
 206                   subnr,
 207                   BRW_REGISTER_TYPE_F,
 208                   BRW_VERTICAL_STRIDE_4,
 209                   BRW_WIDTH_4,
 210                   BRW_HORIZONTAL_STRIDE_1,
 211                   BRW_SWIZZLE_XYZW,
 212                   WRITEMASK_XYZW);
 213 }
 214
 215
 216 static __inline struct brw_reg brw_vec2_reg( GLuint file,
 217                                               GLuint nr,
 218                                               GLuint subnr )
 219 {
 220    return brw_reg(file,
 221                   nr,
 222                   subnr,
 223                   BRW_REGISTER_TYPE_F,
 224                   BRW_VERTICAL_STRIDE_2,
 225                   BRW_WIDTH_2,
 226                   BRW_HORIZONTAL_STRIDE_1,
 227                   BRW_SWIZZLE_XYXY,
 228                   WRITEMASK_XY);
 229 }
 230
 231 static __inline struct brw_reg brw_vec1_reg( GLuint file,
 232                                              GLuint nr,
 233                                              GLuint subnr )
 234 {
 235    return brw_reg(file,
 236                   nr,
 237                   subnr,
 238                   BRW_REGISTER_TYPE_F,
 239                   BRW_VERTICAL_STRIDE_0,
 240                   BRW_WIDTH_1,
 241                   BRW_HORIZONTAL_STRIDE_0,
 242                   BRW_SWIZZLE_XXXX,
 243                   WRITEMASK_X);
 244 }
 245
 246
 247 static __inline struct brw_reg retype( struct brw_reg reg,
 248                                        GLuint type )
 249 {
 250    reg.type = type;
 251    return reg;
 252 }
 253
 254 static __inline struct brw_reg suboffset( struct brw_reg reg,
 255                                           GLuint delta )
 256 {
 257    reg.subnr += delta * type_sz(reg.type);
 258    return reg;
 259 }
 260
 261
 262 static __inline struct brw_reg offset( struct brw_reg reg,
 263                                        GLuint delta )
 264 {
 265    reg.nr += delta;
 266    return reg;
 267 }
 268
 269
 270 static __inline struct brw_reg byte_offset( struct brw_reg reg,
 271                                             GLuint bytes )
 272 {
 273    GLuint newoffset = reg.nr * REG_SIZE + reg.subnr + bytes;
 274    reg.nr = newoffset / REG_SIZE;
 275    reg.subnr = newoffset % REG_SIZE;
 276    return reg;
 277 }
 278
 279
 280 static __inline struct brw_reg brw_uw16_reg( GLuint file,
 281                                              GLuint nr,
 282                                              GLuint subnr )
 283 {
 284    return suboffset(retype(brw_vec16_reg(file, nr, 0), BRW_REGISTER_TYPE_UW), subnr);
 285 }
 286
 287 static __inline struct brw_reg brw_uw8_reg( GLuint file,
 288                                             GLuint nr,
 289                                             GLuint subnr )
 290 {
 291    return suboffset(retype(brw_vec8_reg(file, nr, 0), BRW_REGISTER_TYPE_UW), subnr);
 292 }
 293
 294 static __inline struct brw_reg brw_uw1_reg( GLuint file,
 295                                             GLuint nr,
 296                                             GLuint subnr )
 297 {
 298    return suboffset(retype(brw_vec1_reg(file, nr, 0), BRW_REGISTER_TYPE_UW), subnr);
 299 }
 300
 301 static __inline struct brw_reg brw_imm_reg( GLuint type )
 302 {
 303    return brw_reg( BRW_IMMEDIATE_VALUE,
 304                    0,
 305                    0,
 306                    type,
 307                    BRW_VERTICAL_STRIDE_0,
 308                    BRW_WIDTH_1,
 309                    BRW_HORIZONTAL_STRIDE_0,
 310                    0,
 311                    0);
 312 }
 313
 314 static __inline struct brw_reg brw_imm_f( GLfloat f )
 315 {
 316    struct brw_reg imm = brw_imm_reg(BRW_REGISTER_TYPE_F);
 317    imm.dw1.f = f;
 318    return imm;
 319 }
 320
 321 static __inline struct brw_reg brw_imm_d( GLint d )
 322 {
 323    struct brw_reg imm = brw_imm_reg(BRW_REGISTER_TYPE_D);
 324    imm.dw1.d = d;
 325    return imm;
 326 }
 327
 328 static __inline struct brw_reg brw_imm_ud( GLuint ud )
 329 {
 330    struct brw_reg imm = brw_imm_reg(BRW_REGISTER_TYPE_UD);
 331    imm.dw1.ud = ud;
 332    return imm;
 333 }
 334
 335 static __inline struct brw_reg brw_imm_uw( GLushort uw )
 336 {
 337    struct brw_reg imm = brw_imm_reg(BRW_REGISTER_TYPE_UW);
 338    imm.dw1.ud = uw;
 339    return imm;
 340 }
 341
 342 static __inline struct brw_reg brw_imm_w( GLshort w )
 343 {
 344    struct brw_reg imm = brw_imm_reg(BRW_REGISTER_TYPE_W);
 345    imm.dw1.d = w;
 346    return imm;
 347 }
 348
 349 /* brw_imm_b and brw_imm_ub aren't supported by hardware - the type
 350  * numbers alias with _V and _VF below:
 351  */
 352
 353 /* Vector of eight signed half-byte values:
 354  */
 355 static __inline struct brw_reg brw_imm_v( GLuint v )
 356 {
 357    struct brw_reg imm = brw_imm_reg(BRW_REGISTER_TYPE_V);
 358    imm.vstride = BRW_VERTICAL_STRIDE_0;
 359    imm.width = BRW_WIDTH_8;
 360    imm.hstride = BRW_HORIZONTAL_STRIDE_1;
 361    imm.dw1.ud = v;
 362    return imm;
 363 }
 364
 365 /* Vector of four 8-bit float values:
 366  */
 367 static __inline struct brw_reg brw_imm_vf( GLuint v )
 368 {
 369    struct brw_reg imm = brw_imm_reg(BRW_REGISTER_TYPE_VF);
 370    imm.vstride = BRW_VERTICAL_STRIDE_0;
 371    imm.width = BRW_WIDTH_4;
 372    imm.hstride = BRW_HORIZONTAL_STRIDE_1;
 373    imm.dw1.ud = v;
 374    return imm;
 375 }
 376
 377 #define VF_ZERO 0x0
 378 #define VF_ONE  0x30
 379 #define VF_NEG  (1<<7)
 380
 381 static __inline struct brw_reg brw_imm_vf4( GLuint v0,
 382                                             GLuint v1,
 383                                             GLuint v2,
 384                                             GLuint v3)
 385 {
 386    struct brw_reg imm = brw_imm_reg(BRW_REGISTER_TYPE_VF);
 387    imm.vstride = BRW_VERTICAL_STRIDE_0;
 388    imm.width = BRW_WIDTH_4;
 389    imm.hstride = BRW_HORIZONTAL_STRIDE_1;
 390    imm.dw1.ud = ((v0 << 0) |
 391                  (v1 << 8) |
 392                  (v2 << 16) |
 393                  (v3 << 24));
 394    return imm;
 395 }
 396
 397
 398 static __inline struct brw_reg brw_address( struct brw_reg reg )
 399 {
 400    return brw_imm_uw(reg.nr * REG_SIZE + reg.subnr);
 401 }
 402
 403
 404 static __inline struct brw_reg brw_vec1_grf( GLuint nr,
 405                                                GLuint subnr )
 406 {
 407    return brw_vec1_reg(BRW_GENERAL_REGISTER_FILE, nr, subnr);
 408 }
 409
 410 static __inline struct brw_reg brw_vec8_grf( GLuint nr,
 411                                              GLuint subnr )
 412 {
 413    return brw_vec8_reg(BRW_GENERAL_REGISTER_FILE, nr, subnr);
 414 }
 415
 416 static __inline struct brw_reg brw_vec4_grf( GLuint nr,
 417                                              GLuint subnr )
 418 {
 419    return brw_vec4_reg(BRW_GENERAL_REGISTER_FILE, nr, subnr);
 420 }
 421
 422
 423 static __inline struct brw_reg brw_vec2_grf( GLuint nr,
 424                                              GLuint subnr )
 425 {
 426    return brw_vec2_reg(BRW_GENERAL_REGISTER_FILE, nr, subnr);
 427 }
 428
 429 static __inline struct brw_reg brw_uw8_grf( GLuint nr,
 430                                             GLuint subnr )
 431 {
 432    return brw_uw8_reg(BRW_GENERAL_REGISTER_FILE, nr, subnr);
 433 }
 434
 435 static __inline struct brw_reg brw_null_reg( void )
 436 {
 437    return brw_vec8_reg(BRW_ARCHITECTURE_REGISTER_FILE,
 438                        BRW_ARF_NULL,
 439                        0);
 440 }
 441
 442 static __inline struct brw_reg brw_address_reg( GLuint subnr )
 443 {
 444    return brw_uw1_reg(BRW_ARCHITECTURE_REGISTER_FILE,
 445                       BRW_ARF_ADDRESS,
 446                       subnr);
 447 }
 448
 449 /* If/else instructions break in align16 mode if writemask & swizzle
 450  * aren't xyzw.  This goes against the convention for other scalar
 451  * regs:
 452  */
 453 static __inline struct brw_reg brw_ip_reg( void )
 454 {
 455    return brw_reg(BRW_ARCHITECTURE_REGISTER_FILE,
 456                   BRW_ARF_IP,
 457                   0,
 458                   BRW_REGISTER_TYPE_UD,
 459                   BRW_VERTICAL_STRIDE_4, /* ? */
 460                   BRW_WIDTH_1,
 461                   BRW_HORIZONTAL_STRIDE_0,
 462                   BRW_SWIZZLE_XYZW, /* NOTE! */
 463                   WRITEMASK_XYZW); /* NOTE! */
 464 }
 465
 466 static __inline struct brw_reg brw_acc_reg( void )
 467 {
 468    return brw_vec8_reg(BRW_ARCHITECTURE_REGISTER_FILE,
 469                        BRW_ARF_ACCUMULATOR,
 470                        0);
 471 }
 472
 473
 474 static __inline struct brw_reg brw_flag_reg( void )
 475 {
 476    return brw_uw1_reg(BRW_ARCHITECTURE_REGISTER_FILE,
 477                       BRW_ARF_FLAG,
 478                       0);
 479 }
 480
 481
 482 static __inline struct brw_reg brw_mask_reg( GLuint subnr )
 483 {
 484    return brw_uw1_reg(BRW_ARCHITECTURE_REGISTER_FILE,
 485                       BRW_ARF_MASK,
 486                       subnr);
 487 }
 488
 489 static __inline struct brw_reg brw_message_reg( GLuint nr )
 490 {
 491    return brw_vec8_reg(BRW_MESSAGE_REGISTER_FILE,
 492                        nr,
 493                        0);
 494 }
 495
 496
 497
 498
 499 /* This is almost always called with a numeric constant argument, so
 500  * make things easy to evaluate at compile time:
 501  */
 502 static __inline GLuint cvt( GLuint val )
 503 {
 504    switch (val) {
 505    case 0: return 0;
 506    case 1: return 1;
 507    case 2: return 2;
 508    case 4: return 3;
 509    case 8: return 4;
 510    case 16: return 5;
 511    case 32: return 6;
 512    }
 513    return 0;
 514 }
 515
 516 static __inline struct brw_reg stride( struct brw_reg reg,
 517                                        GLuint vstride,
 518                                        GLuint width,
 519                                        GLuint hstride )
 520 {
 521
 522    reg.vstride = cvt(vstride);
 523    reg.width = cvt(width) - 1;
 524    reg.hstride = cvt(hstride);
 525    return reg;
 526 }
 527
 528 static __inline struct brw_reg vec16( struct brw_reg reg )
 529 {
 530    return stride(reg, 16,16,1);
 531 }
 532
 533 static __inline struct brw_reg vec8( struct brw_reg reg )
 534 {
 535    return stride(reg, 8,8,1);
 536 }
 537
 538 static __inline struct brw_reg vec4( struct brw_reg reg )
 539 {
 540    return stride(reg, 4,4,1);
 541 }
 542
 543 static __inline struct brw_reg vec2( struct brw_reg reg )
 544 {
 545    return stride(reg, 2,2,1);
 546 }
 547
 548 static __inline struct brw_reg vec1( struct brw_reg reg )
 549 {
 550    return stride(reg, 0,1,0);
 551 }
 552
 553 static __inline struct brw_reg get_element( struct brw_reg reg, GLuint elt )
 554 {
 555    return vec1(suboffset(reg, elt));
 556 }
 557
 558 static __inline struct brw_reg get_element_ud( struct brw_reg reg, GLuint elt )
 559 {
 560    return vec1(suboffset(retype(reg, BRW_REGISTER_TYPE_UD), elt));
 561 }
 562
 563
 564 static __inline struct brw_reg brw_swizzle( struct brw_reg reg,
 565                                             GLuint x,
 566                                             GLuint y,
 567                                             GLuint z,
 568                                             GLuint w)
 569 {
 570    reg.dw1.bits.swizzle = BRW_SWIZZLE4(BRW_GET_SWZ(reg.dw1.bits.swizzle, x),
 571                                        BRW_GET_SWZ(reg.dw1.bits.swizzle, y),
 572                                        BRW_GET_SWZ(reg.dw1.bits.swizzle, z),
 573                                        BRW_GET_SWZ(reg.dw1.bits.swizzle, w));
 574    return reg;
 575 }
 576
 577
 578 static __inline struct brw_reg brw_swizzle1( struct brw_reg reg,
 579                                              GLuint x )
 580 {
 581    return brw_swizzle(reg, x, x, x, x);
 582 }
 583
 584 static __inline struct brw_reg brw_writemask( struct brw_reg reg,
 585                                               GLuint mask )
 586 {
 587    reg.dw1.bits.writemask &= mask;
 588    return reg;
 589 }
 590
 591 static __inline struct brw_reg brw_set_writemask( struct brw_reg reg,
 592                                                   GLuint mask )
 593 {
 594    reg.dw1.bits.writemask = mask;
 595    return reg;
 596 }
 597
 598 static __inline struct brw_reg negate( struct brw_reg reg )
 599 {
 600    reg.negate ^= 1;
 601    return reg;
 602 }
 603
 604 static __inline struct brw_reg brw_abs( struct brw_reg reg )
 605 {
 606    reg.abs = 1;
 607    return reg;
 608 }
 609
 610 /***********************************************************************
 611  */
 612 static __inline struct brw_reg brw_vec4_indirect( GLuint subnr,
 613                                                   GLint offset )
 614 {
 615    struct brw_reg reg =  brw_vec4_grf(0, 0);
 616    reg.subnr = subnr;
 617    reg.address_mode = BRW_ADDRESS_REGISTER_INDIRECT_REGISTER;
 618    reg.dw1.bits.indirect_offset = offset;
 619    return reg;
 620 }
 621
 622 static __inline struct brw_reg brw_vec1_indirect( GLuint subnr,
 623                                                   GLint offset )
 624 {
 625    struct brw_reg reg =  brw_vec1_grf(0, 0);
 626    reg.subnr = subnr;
 627    reg.address_mode = BRW_ADDRESS_REGISTER_INDIRECT_REGISTER;
 628    reg.dw1.bits.indirect_offset = offset;
 629    return reg;
 630 }
 631
 632 static __inline struct brw_reg deref_4f(struct brw_indirect ptr, GLint offset)
 633 {
 634    return brw_vec4_indirect(ptr.addr_subnr, ptr.addr_offset + offset);
 635 }
 636
 637 static __inline struct brw_reg deref_1f(struct brw_indirect ptr, GLint offset)
 638 {
 639    return brw_vec1_indirect(ptr.addr_subnr, ptr.addr_offset + offset);
 640 }
 641
 642 static __inline struct brw_reg deref_4b(struct brw_indirect ptr, GLint offset)
 643 {
 644    return retype(deref_4f(ptr, offset), BRW_REGISTER_TYPE_B);
 645 }
 646
 647 static __inline struct brw_reg deref_1uw(struct brw_indirect ptr, GLint offset)
 648 {
 649    return retype(deref_1f(ptr, offset), BRW_REGISTER_TYPE_UW);
 650 }
 651
 652 static __inline struct brw_reg deref_1d(struct brw_indirect ptr, GLint offset)
 653 {
 654    return retype(deref_1f(ptr, offset), BRW_REGISTER_TYPE_D);
 655 }
 656
 657 static __inline struct brw_reg deref_1ud(struct brw_indirect ptr, GLint offset)
 658 {
 659    return retype(deref_1f(ptr, offset), BRW_REGISTER_TYPE_UD);
 660 }
 661
 662 static __inline struct brw_reg get_addr_reg(struct brw_indirect ptr)
 663 {
 664    return brw_address_reg(ptr.addr_subnr);
 665 }
 666
 667 static __inline struct brw_indirect brw_indirect_offset( struct brw_indirect ptr, GLint offset )
 668 {
 669    ptr.addr_offset += offset;
 670    return ptr;
 671 }
 672
 673 static __inline struct brw_indirect brw_indirect( GLuint addr_subnr, GLint offset )
 674 {
 675    struct brw_indirect ptr;
 676    ptr.addr_subnr = addr_subnr;
 677    ptr.addr_offset = offset;
 678    ptr.pad = 0;
 679    return ptr;
 680 }
 681
 682 static __inline struct brw_instruction *current_insn( struct brw_compile *p)
 683 {
 684         return &p->store[p->nr_insn];
 685 }
 686
 687 void brw_pop_insn_state( struct brw_compile *p );
 688 void brw_push_insn_state( struct brw_compile *p );
 689 void brw_set_mask_control( struct brw_compile *p, GLuint value );
 690 void brw_set_saturate( struct brw_compile *p, GLuint value );
 691 void brw_set_access_mode( struct brw_compile *p, GLuint access_mode );
 692 void brw_set_compression_control( struct brw_compile *p, GLboolean control );
 693 void brw_set_predicate_control_flag_value( struct brw_compile *p, GLuint value );
 694 void brw_set_predicate_control( struct brw_compile *p, GLuint pc );
 695 void brw_set_conditionalmod( struct brw_compile *p, GLuint conditional );
 696
 697 void brw_init_compile( struct brw_context *, struct brw_compile *p );
 698 const GLuint *brw_get_program( struct brw_compile *p, GLuint *sz );
 699
 700
 701 /* Helpers for regular instructions:
 702  */
 703 #define ALU1(OP)                                        \
 704 struct brw_instruction *brw_##OP(struct brw_compile *p, \
 705               struct brw_reg dest,                      \
 706               struct brw_reg src0);
 707
 708 #define ALU2(OP)                                        \
 709 struct brw_instruction *brw_##OP(struct brw_compile *p, \
 710               struct brw_reg dest,                      \
 711               struct brw_reg src0,                      \
 712               struct brw_reg src1);
 713
 714 ALU1(MOV)
 715 ALU2(SEL)
 716 ALU1(NOT)
 717 ALU2(AND)
 718 ALU2(OR)
 719 ALU2(XOR)
 720 ALU2(SHR)
 721 ALU2(SHL)
 722 ALU2(RSR)
 723 ALU2(RSL)
 724 ALU2(ASR)
 725 ALU2(JMPI)
 726 ALU2(ADD)
 727 ALU2(MUL)
 728 ALU1(FRC)
 729 ALU1(RNDD)
 730 ALU2(MAC)
 731 ALU2(MACH)
 732 ALU1(LZD)
 733 ALU2(DP4)
 734 ALU2(DPH)
 735 ALU2(DP3)
 736 ALU2(DP2)
 737 ALU2(LINE)
 738
 739 #undef ALU1
 740 #undef ALU2
 741
 742
 743
 744 /* Helpers for SEND instruction:
 745  */
 746 void brw_urb_WRITE(struct brw_compile *p,
 747                    struct brw_reg dest,
 748                    GLuint msg_reg_nr,
 749                    struct brw_reg src0,
 750                    GLboolean allocate,
 751                    GLboolean used,
 752                    GLuint msg_length,
 753                    GLuint response_length,
 754                    GLboolean eot,
 755                    GLboolean writes_complete,
 756                    GLuint offset,
 757                    GLuint swizzle);
 758
 759 void brw_fb_WRITE(struct brw_compile *p,
 760                    struct brw_reg dest,
 761                    GLuint msg_reg_nr,
 762                    struct brw_reg src0,
 763                    GLuint binding_table_index,
 764                    GLuint msg_length,
 765                    GLuint response_length,
 766                    GLboolean eot);
 767
 768 void brw_SAMPLE(struct brw_compile *p,
 769                 struct brw_reg dest,
 770                 GLuint msg_reg_nr,
 771                 struct brw_reg src0,
 772                 GLuint binding_table_index,
 773                 GLuint sampler,
 774                 GLuint writemask,
 775                 GLuint msg_type,
 776                 GLuint response_length,
 777                 GLuint msg_length,
 778                 GLboolean eot);
 779
 780 void brw_math_16( struct brw_compile *p,
 781                   struct brw_reg dest,
 782                   GLuint function,
 783                   GLuint saturate,
 784                   GLuint msg_reg_nr,
 785                   struct brw_reg src,
 786                   GLuint precision );
 787
 788 void brw_math( struct brw_compile *p,
 789                struct brw_reg dest,
 790                GLuint function,
 791                GLuint saturate,
 792                GLuint msg_reg_nr,
 793                struct brw_reg src,
 794                GLuint data_type,
 795                GLuint precision );
 796
 797 void brw_dp_READ_16( struct brw_compile *p,
 798                      struct brw_reg dest,
 799                      GLuint msg_reg_nr,
 800                      GLuint scratch_offset );
 801
 802 void brw_dp_WRITE_16( struct brw_compile *p,
 803                       struct brw_reg src,
 804                       GLuint msg_reg_nr,
 805                       GLuint scratch_offset );
 806
 807 /* If/else/endif.  Works by manipulating the execution flags on each
 808  * channel.
 809  */
 810 struct brw_instruction *brw_IF(struct brw_compile *p,
 811                                GLuint execute_size);
 812
 813 struct brw_instruction *brw_ELSE(struct brw_compile *p,
 814                                  struct brw_instruction *if_insn);
 815
 816 void brw_ENDIF(struct brw_compile *p,
 817                struct brw_instruction *if_or_else_insn);
 818
 819
 820 /* DO/WHILE loops:
 821  */
 822 struct brw_instruction *brw_DO(struct brw_compile *p,
 823                                GLuint execute_size);
 824
 825 struct brw_instruction *brw_WHILE(struct brw_compile *p,
 826                struct brw_instruction *patch_insn);
 827
 828 struct brw_instruction *brw_BREAK(struct brw_compile *p);
 829 struct brw_instruction *brw_CONT(struct brw_compile *p);
 830 /* Forward jumps:
 831  */
 832 void brw_land_fwd_jump(struct brw_compile *p,
 833                        struct brw_instruction *jmp_insn);
 834
 835
 836
 837 void brw_NOP(struct brw_compile *p);
 838
 839 /* Special case: there is never a destination, execution size will be
 840  * taken from src0:
 841  */
 842 void brw_CMP(struct brw_compile *p,
 843              struct brw_reg dest,
 844              GLuint conditional,
 845              struct brw_reg src0,
 846              struct brw_reg src1);
 847
 848 void brw_print_reg( struct brw_reg reg );
 849
 850
 851 /***********************************************************************
 852  * brw_eu_util.c:
 853  */
 854
 855 void brw_copy_indirect_to_indirect(struct brw_compile *p,
 856                                    struct brw_indirect dst_ptr,
 857                                    struct brw_indirect src_ptr,
 858                                    GLuint count);
 859
 860 void brw_copy_from_indirect(struct brw_compile *p,
 861                             struct brw_reg dst,
 862                             struct brw_indirect ptr,
 863                             GLuint count);
 864
 865 void brw_copy4(struct brw_compile *p,
 866                struct brw_reg dst,
 867                struct brw_reg src,
 868                GLuint count);
 869
 870 void brw_copy8(struct brw_compile *p,
 871                struct brw_reg dst,
 872                struct brw_reg src,
 873                GLuint count);
 874
 875 void brw_math_invert( struct brw_compile *p,
 876                       struct brw_reg dst,
 877                       struct brw_reg src);
 878
 879 void brw_set_src1( struct brw_instruction *insn,
 880                           struct brw_reg reg );
 881 #endif