src/gallium/drivers/nouveau/codegen/nv50_ir_emit_gm107.cpp

   1 /*
   2  * Copyright 2014 Red Hat Inc.
   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 shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: Ben Skeggs <bskeggs@redhat.com>
  23  */
  24
  25 #include "codegen/nv50_ir_target_gm107.h"
  26
  27 namespace nv50_ir {
  28
  29 class CodeEmitterGM107 : public CodeEmitter
  30 {
  31 public:
  32    CodeEmitterGM107(const TargetGM107 *);
  33
  34    virtual bool emitInstruction(Instruction *);
  35    virtual uint32_t getMinEncodingSize(const Instruction *) const;
  36
  37    virtual void prepareEmission(Program *);
  38    virtual void prepareEmission(Function *);
  39
  40    inline void setProgramType(Program::Type pType) { progType = pType; }
  41
  42 private:
  43    const TargetGM107 *targGM107;
  44
  45    Program::Type progType;
  46
  47    const Instruction *insn;
  48    const bool writeIssueDelays;
  49    uint32_t *data;
  50
  51 private:
  52    inline void emitField(uint32_t *, int, int, uint32_t);
  53    inline void emitField(int b, int s, uint32_t v) { emitField(code, b, s, v); }
  54
  55    inline void emitInsn(uint32_t, bool);
  56    inline void emitInsn(uint32_t o) { emitInsn(o, true); }
  57    inline void emitPred();
  58    inline void emitGPR(int, const Value *);
  59    inline void emitGPR(int pos) {
  60       emitGPR(pos, (const Value *)NULL);
  61    }
  62    inline void emitGPR(int pos, const ValueRef &ref) {
  63       emitGPR(pos, ref.get() ? ref.rep() : (const Value *)NULL);
  64    }
  65    inline void emitGPR(int pos, const ValueRef *ref) {
  66       emitGPR(pos, ref ? ref->rep() : (const Value *)NULL);
  67    }
  68    inline void emitGPR(int pos, const ValueDef &def) {
  69       emitGPR(pos, def.get() ? def.rep() : (const Value *)NULL);
  70    }
  71    inline void emitSYS(int, const Value *);
  72    inline void emitSYS(int pos, const ValueRef &ref) {
  73       emitSYS(pos, ref.get() ? ref.rep() : (const Value *)NULL);
  74    }
  75    inline void emitPRED(int, const Value *);
  76    inline void emitPRED(int pos) {
  77       emitPRED(pos, (const Value *)NULL);
  78    }
  79    inline void emitPRED(int pos, const ValueRef &ref) {
  80       emitPRED(pos, ref.get() ? ref.rep() : (const Value *)NULL);
  81    }
  82    inline void emitPRED(int pos, const ValueDef &def) {
  83       emitPRED(pos, def.get() ? def.rep() : (const Value *)NULL);
  84    }
  85    inline void emitADDR(int, int, int, int, const ValueRef &);
  86    inline void emitCBUF(int, int, int, int, int, const ValueRef &);
  87    inline bool longIMMD(const ValueRef &);
  88    inline void emitIMMD(int, int, const ValueRef &);
  89
  90    void emitCond3(int, CondCode);
  91    void emitCond4(int, CondCode);
  92    void emitCond5(int pos, CondCode cc) { emitCond4(pos, cc); }
  93    inline void emitO(int);
  94    inline void emitP(int);
  95    inline void emitSAT(int);
  96    inline void emitCC(int);
  97    inline void emitX(int);
  98    inline void emitABS(int, const ValueRef &);
  99    inline void emitNEG(int, const ValueRef &);
 100    inline void emitNEG2(int, const ValueRef &, const ValueRef &);
 101    inline void emitFMZ(int, int);
 102    inline void emitRND(int, RoundMode, int);
 103    inline void emitRND(int pos) {
 104       emitRND(pos, insn->rnd, -1);
 105    }
 106    inline void emitPDIV(int);
 107    inline void emitINV(int, const ValueRef &);
 108
 109    void emitEXIT();
 110    void emitBRA();
 111    void emitCAL();
 112    void emitPCNT();
 113    void emitCONT();
 114    void emitPBK();
 115    void emitBRK();
 116    void emitPRET();
 117    void emitRET();
 118    void emitSSY();
 119    void emitSYNC();
 120    void emitSAM();
 121    void emitRAM();
 122
 123    void emitMOV();
 124    void emitS2R();
 125    void emitF2F();
 126    void emitF2I();
 127    void emitI2F();
 128    void emitI2I();
 129    void emitSEL();
 130    void emitSHFL();
 131
 132    void emitDADD();
 133    void emitDMUL();
 134    void emitDFMA();
 135    void emitDMNMX();
 136    void emitDSET();
 137    void emitDSETP();
 138
 139    void emitFADD();
 140    void emitFMUL();
 141    void emitFFMA();
 142    void emitMUFU();
 143    void emitFMNMX();
 144    void emitRRO();
 145    void emitFCMP();
 146    void emitFSET();
 147    void emitFSETP();
 148    void emitFSWZADD();
 149
 150    void emitLOP();
 151    void emitNOT();
 152    void emitIADD();
 153    void emitIMUL();
 154    void emitIMAD();
 155    void emitIMNMX();
 156    void emitICMP();
 157    void emitISET();
 158    void emitISETP();
 159    void emitSHL();
 160    void emitSHR();
 161    void emitPOPC();
 162    void emitBFI();
 163    void emitBFE();
 164    void emitFLO();
 165
 166    void emitLDSTs(int, DataType);
 167    void emitLDSTc(int);
 168    void emitLDC();
 169    void emitLDL();
 170    void emitLDS();
 171    void emitLD();
 172    void emitSTL();
 173    void emitSTS();
 174    void emitST();
 175    void emitALD();
 176    void emitAST();
 177    void emitISBERD();
 178    void emitAL2P();
 179    void emitIPA();
 180    void emitATOM();
 181    void emitATOMS();
 182    void emitCCTL();
 183
 184    void emitPIXLD();
 185
 186    void emitTEXs(int);
 187    void emitTEX();
 188    void emitTLD();
 189    void emitTLD4();
 190    void emitTXD();
 191    void emitTXQ();
 192    void emitTMML();
 193    void emitDEPBAR();
 194
 195    void emitNOP();
 196    void emitKIL();
 197    void emitOUT();
 198
 199    void emitBAR();
 200    void emitMEMBAR();
 201
 202    void emitVOTE();
 203 };
 204
 205 /*******************************************************************************
 206  * general instruction layout/fields
 207  ******************************************************************************/
 208
 209 void
 210 CodeEmitterGM107::emitField(uint32_t *data, int b, int s, uint32_t v)
 211 {
 212    if (b >= 0) {
 213       uint32_t m = ((1ULL << s) - 1);
 214       uint64_t d = (uint64_t)(v & m) << b;
 215       assert(!(v & ~m) || (v & ~m) == ~m);
 216       data[1] |= d >> 32;
 217       data[0] |= d;
 218    }
 219 }
 220
 221 void
 222 CodeEmitterGM107::emitPred()
 223 {
 224    if (insn->predSrc >= 0) {
 225       emitField(16, 3, insn->getSrc(insn->predSrc)->rep()->reg.data.id);
 226       emitField(19, 1, insn->cc == CC_NOT_P);
 227    } else {
 228       emitField(16, 3, 7);
 229    }
 230 }
 231
 232 void
 233 CodeEmitterGM107::emitInsn(uint32_t hi, bool pred)
 234 {
 235    code[0] = 0x00000000;
 236    code[1] = hi;
 237    if (pred)
 238       emitPred();
 239 }
 240
 241 void
 242 CodeEmitterGM107::emitGPR(int pos, const Value *val)
 243 {
 244    emitField(pos, 8, val ? val->reg.data.id : 255);
 245 }
 246
 247 void
 248 CodeEmitterGM107::emitSYS(int pos, const Value *val)
 249 {
 250    int id = val ? val->reg.data.id : -1;
 251
 252    switch (id) {
 253    case SV_LANEID         : id = 0x00; break;
 254    case SV_VERTEX_COUNT   : id = 0x10; break;
 255    case SV_INVOCATION_ID  : id = 0x11; break;
 256    case SV_THREAD_KILL    : id = 0x13; break;
 257    case SV_INVOCATION_INFO: id = 0x1d; break;
 258    case SV_TID            : id = 0x21 + val->reg.data.sv.index; break;
 259    case SV_CTAID          : id = 0x25 + val->reg.data.sv.index; break;
 260    default:
 261       assert(!"invalid system value");
 262       id = 0;
 263       break;
 264    }
 265
 266    emitField(pos, 8, id);
 267 }
 268
 269 void
 270 CodeEmitterGM107::emitPRED(int pos, const Value *val)
 271 {
 272    emitField(pos, 3, val ? val->reg.data.id : 7);
 273 }
 274
 275 void
 276 CodeEmitterGM107::emitADDR(int gpr, int off, int len, int shr,
 277                            const ValueRef &ref)
 278 {
 279    const Value *v = ref.get();
 280    assert(!(v->reg.data.offset & ((1 << shr) - 1)));
 281    if (gpr >= 0)
 282       emitGPR(gpr, ref.getIndirect(0));
 283    emitField(off, len, v->reg.data.offset >> shr);
 284 }
 285
 286 void
 287 CodeEmitterGM107::emitCBUF(int buf, int gpr, int off, int len, int shr,
 288                            const ValueRef &ref)
 289 {
 290    const Value *v = ref.get();
 291    const Symbol *s = v->asSym();
 292
 293    assert(!(s->reg.data.offset & ((1 << shr) - 1)));
 294
 295    emitField(buf,  5, v->reg.fileIndex);
 296    if (gpr >= 0)
 297       emitGPR(gpr, ref.getIndirect(0));
 298    emitField(off, 16, s->reg.data.offset >> shr);
 299 }
 300
 301 bool
 302 CodeEmitterGM107::longIMMD(const ValueRef &ref)
 303 {
 304    if (ref.getFile() == FILE_IMMEDIATE) {
 305       const ImmediateValue *imm = ref.get()->asImm();
 306       if (isFloatType(insn->sType)) {
 307          if ((imm->reg.data.u32 & 0x00000fff) != 0x00000000)
 308             return true;
 309       } else {
 310          if ((imm->reg.data.u32 & 0xfff00000) != 0x00000000 &&
 311              (imm->reg.data.u32 & 0xfff00000) != 0xfff00000)
 312             return true;
 313       }
 314    }
 315    return false;
 316 }
 317
 318 void
 319 CodeEmitterGM107::emitIMMD(int pos, int len, const ValueRef &ref)
 320 {
 321    const ImmediateValue *imm = ref.get()->asImm();
 322    uint32_t val = imm->reg.data.u32;
 323
 324    if (len == 19) {
 325       if (insn->sType == TYPE_F32 || insn->sType == TYPE_F16) {
 326          assert(!(val & 0x00000fff));
 327          val >>= 12;
 328       } else if (insn->sType == TYPE_F64) {
 329          assert(!(imm->reg.data.u64 & 0x00000fffffffffffULL));
 330          val = imm->reg.data.u64 >> 44;
 331       }
 332       assert(!(val & 0xfff00000) || (val & 0xfff00000) == 0xfff00000);
 333       emitField( 56,   1, (val & 0x80000) >> 19);
 334       emitField(pos, len, (val & 0x7ffff));
 335    } else {
 336       emitField(pos, len, val);
 337    }
 338 }
 339
 340 /*******************************************************************************
 341  * modifiers
 342  ******************************************************************************/
 343
 344 void
 345 CodeEmitterGM107::emitCond3(int pos, CondCode code)
 346 {
 347    int data = 0;
 348
 349    switch (code) {
 350    case CC_FL : data = 0x00; break;
 351    case CC_LTU:
 352    case CC_LT : data = 0x01; break;
 353    case CC_EQU:
 354    case CC_EQ : data = 0x02; break;
 355    case CC_LEU:
 356    case CC_LE : data = 0x03; break;
 357    case CC_GTU:
 358    case CC_GT : data = 0x04; break;
 359    case CC_NEU:
 360    case CC_NE : data = 0x05; break;
 361    case CC_GEU:
 362    case CC_GE : data = 0x06; break;
 363    case CC_TR : data = 0x07; break;
 364    default:
 365       assert(!"invalid cond3");
 366       break;
 367    }
 368
 369    emitField(pos, 3, data);
 370 }
 371
 372 void
 373 CodeEmitterGM107::emitCond4(int pos, CondCode code)
 374 {
 375    int data = 0;
 376
 377    switch (code) {
 378    case CC_FL: data = 0x00; break;
 379    case CC_LT: data = 0x01; break;
 380    case CC_EQ: data = 0x02; break;
 381    case CC_LE: data = 0x03; break;
 382    case CC_GT: data = 0x04; break;
 383    case CC_NE: data = 0x05; break;
 384    case CC_GE: data = 0x06; break;
 385 //   case CC_NUM: data = 0x07; break;
 386 //   case CC_NAN: data = 0x08; break;
 387    case CC_LTU: data = 0x09; break;
 388    case CC_EQU: data = 0x0a; break;
 389    case CC_LEU: data = 0x0b; break;
 390    case CC_GTU: data = 0x0c; break;
 391    case CC_NEU: data = 0x0d; break;
 392    case CC_GEU: data = 0x0e; break;
 393    case CC_TR:  data = 0x0f; break;
 394    default:
 395       assert(!"invalid cond4");
 396       break;
 397    }
 398
 399    emitField(pos, 4, data);
 400 }
 401
 402 void
 403 CodeEmitterGM107::emitO(int pos)
 404 {
 405    emitField(pos, 1, insn->getSrc(0)->reg.file == FILE_SHADER_OUTPUT);
 406 }
 407
 408 void
 409 CodeEmitterGM107::emitP(int pos)
 410 {
 411    emitField(pos, 1, insn->perPatch);
 412 }
 413
 414 void
 415 CodeEmitterGM107::emitSAT(int pos)
 416 {
 417    emitField(pos, 1, insn->saturate);
 418 }
 419
 420 void
 421 CodeEmitterGM107::emitCC(int pos)
 422 {
 423    emitField(pos, 1, insn->defExists(1));
 424 }
 425
 426 void
 427 CodeEmitterGM107::emitX(int pos)
 428 {
 429    emitField(pos, 1, insn->flagsSrc >= 0);
 430 }
 431
 432 void
 433 CodeEmitterGM107::emitABS(int pos, const ValueRef &ref)
 434 {
 435    emitField(pos, 1, ref.mod.abs());
 436 }
 437
 438 void
 439 CodeEmitterGM107::emitNEG(int pos, const ValueRef &ref)
 440 {
 441    emitField(pos, 1, ref.mod.neg());
 442 }
 443
 444 void
 445 CodeEmitterGM107::emitNEG2(int pos, const ValueRef &a, const ValueRef &b)
 446 {
 447    emitField(pos, 1, a.mod.neg() ^ b.mod.neg());
 448 }
 449
 450 void
 451 CodeEmitterGM107::emitFMZ(int pos, int len)
 452 {
 453    emitField(pos, len, insn->dnz << 1 | insn->ftz);
 454 }
 455
 456 void
 457 CodeEmitterGM107::emitRND(int rmp, RoundMode rnd, int rip)
 458 {
 459    int rm = 0, ri = 0;
 460    switch (rnd) {
 461    case ROUND_NI: ri = 1;
 462    case ROUND_N : rm = 0; break;
 463    case ROUND_MI: ri = 1;
 464    case ROUND_M : rm = 1; break;
 465    case ROUND_PI: ri = 1;
 466    case ROUND_P : rm = 2; break;
 467    case ROUND_ZI: ri = 1;
 468    case ROUND_Z : rm = 3; break;
 469    default:
 470       assert(!"invalid round mode");
 471       break;
 472    }
 473    emitField(rip, 1, ri);
 474    emitField(rmp, 2, rm);
 475 }
 476
 477 void
 478 CodeEmitterGM107::emitPDIV(int pos)
 479 {
 480    assert(insn->postFactor >= -3 && insn->postFactor <= 3);
 481    if (insn->postFactor > 0)
 482       emitField(pos, 3, 7 - insn->postFactor);
 483    else
 484       emitField(pos, 3, 0 - insn->postFactor);
 485 }
 486
 487 void
 488 CodeEmitterGM107::emitINV(int pos, const ValueRef &ref)
 489 {
 490    emitField(pos, 1, !!(ref.mod & Modifier(NV50_IR_MOD_NOT)));
 491 }
 492
 493 /*******************************************************************************
 494  * control flow
 495  ******************************************************************************/
 496
 497 void
 498 CodeEmitterGM107::emitEXIT()
 499 {
 500    emitInsn (0xe3000000);
 501    emitCond5(0x00, CC_TR);
 502 }
 503
 504 void
 505 CodeEmitterGM107::emitBRA()
 506 {
 507    const FlowInstruction *insn = this->insn->asFlow();
 508    int gpr = -1;
 509
 510    if (insn->indirect) {
 511       if (insn->absolute)
 512          emitInsn(0xe2000000); // JMX
 513       else
 514          emitInsn(0xe2500000); // BRX
 515       gpr = 0x08;
 516    } else {
 517       if (insn->absolute)
 518          emitInsn(0xe2100000); // JMP
 519       else
 520          emitInsn(0xe2400000); // BRA
 521       emitField(0x07, 1, insn->allWarp);
 522    }
 523
 524    emitField(0x06, 1, insn->limit);
 525    emitCond5(0x00, CC_TR);
 526
 527    if (!insn->srcExists(0) || insn->src(0).getFile() != FILE_MEMORY_CONST) {
 528       int32_t pos = insn->target.bb->binPos;
 529       if (writeIssueDelays && !(pos & 0x1f))
 530          pos += 8;
 531       if (!insn->absolute)
 532          emitField(0x14, 24, pos - (codeSize + 8));
 533       else
 534          emitField(0x14, 32, pos);
 535    } else {
 536       emitCBUF (0x24, gpr, 20, 16, 0, insn->src(0));
 537       emitField(0x05, 1, 1);
 538    }
 539 }
 540
 541 void
 542 CodeEmitterGM107::emitCAL()
 543 {
 544    const FlowInstruction *insn = this->insn->asFlow();
 545
 546    if (insn->absolute) {
 547       emitInsn(0xe2200000, 0); // JCAL
 548    } else {
 549       emitInsn(0xe2600000, 0); // CAL
 550    }
 551
 552    if (!insn->srcExists(0) || insn->src(0).getFile() != FILE_MEMORY_CONST) {
 553       if (!insn->absolute)
 554          emitField(0x14, 24, insn->target.bb->binPos - (codeSize + 8));
 555       else {
 556          if (insn->builtin) {
 557             int pcAbs = targGM107->getBuiltinOffset(insn->target.builtin);
 558             addReloc(RelocEntry::TYPE_BUILTIN, 0, pcAbs, 0xfff00000,  20);
 559             addReloc(RelocEntry::TYPE_BUILTIN, 1, pcAbs, 0x000fffff, -12);
 560          } else {
 561             emitField(0x14, 32, insn->target.bb->binPos);
 562          }
 563       }
 564    } else {
 565       emitCBUF (0x24, -1, 20, 16, 0, insn->src(0));
 566       emitField(0x05, 1, 1);
 567    }
 568 }
 569
 570 void
 571 CodeEmitterGM107::emitPCNT()
 572 {
 573    const FlowInstruction *insn = this->insn->asFlow();
 574
 575    emitInsn(0xe2b00000, 0);
 576
 577    if (!insn->srcExists(0) || insn->src(0).getFile() != FILE_MEMORY_CONST) {
 578       emitField(0x14, 24, insn->target.bb->binPos - (codeSize + 8));
 579    } else {
 580       emitCBUF (0x24, -1, 20, 16, 0, insn->src(0));
 581       emitField(0x05, 1, 1);
 582    }
 583 }
 584
 585 void
 586 CodeEmitterGM107::emitCONT()
 587 {
 588    emitInsn (0xe3500000);
 589    emitCond5(0x00, CC_TR);
 590 }
 591
 592 void
 593 CodeEmitterGM107::emitPBK()
 594 {
 595    const FlowInstruction *insn = this->insn->asFlow();
 596
 597    emitInsn(0xe2a00000, 0);
 598
 599    if (!insn->srcExists(0) || insn->src(0).getFile() != FILE_MEMORY_CONST) {
 600       emitField(0x14, 24, insn->target.bb->binPos - (codeSize + 8));
 601    } else {
 602       emitCBUF (0x24, -1, 20, 16, 0, insn->src(0));
 603       emitField(0x05, 1, 1);
 604    }
 605 }
 606
 607 void
 608 CodeEmitterGM107::emitBRK()
 609 {
 610    emitInsn (0xe3400000);
 611    emitCond5(0x00, CC_TR);
 612 }
 613
 614 void
 615 CodeEmitterGM107::emitPRET()
 616 {
 617    const FlowInstruction *insn = this->insn->asFlow();
 618
 619    emitInsn(0xe2700000, 0);
 620
 621    if (!insn->srcExists(0) || insn->src(0).getFile() != FILE_MEMORY_CONST) {
 622       emitField(0x14, 24, insn->target.bb->binPos - (codeSize + 8));
 623    } else {
 624       emitCBUF (0x24, -1, 20, 16, 0, insn->src(0));
 625       emitField(0x05, 1, 1);
 626    }
 627 }
 628
 629 void
 630 CodeEmitterGM107::emitRET()
 631 {
 632    emitInsn (0xe3200000);
 633    emitCond5(0x00, CC_TR);
 634 }
 635
 636 void
 637 CodeEmitterGM107::emitSSY()
 638 {
 639    const FlowInstruction *insn = this->insn->asFlow();
 640
 641    emitInsn(0xe2900000, 0);
 642
 643    if (!insn->srcExists(0) || insn->src(0).getFile() != FILE_MEMORY_CONST) {
 644       emitField(0x14, 24, insn->target.bb->binPos - (codeSize + 8));
 645    } else {
 646       emitCBUF (0x24, -1, 20, 16, 0, insn->src(0));
 647       emitField(0x05, 1, 1);
 648    }
 649 }
 650
 651 void
 652 CodeEmitterGM107::emitSYNC()
 653 {
 654    emitInsn (0xf0f80000);
 655    emitCond5(0x00, CC_TR);
 656 }
 657
 658 void
 659 CodeEmitterGM107::emitSAM()
 660 {
 661    emitInsn(0xe3700000, 0);
 662 }
 663
 664 void
 665 CodeEmitterGM107::emitRAM()
 666 {
 667    emitInsn(0xe3800000, 0);
 668 }
 669
 670 /*******************************************************************************
 671  * predicate/cc
 672  ******************************************************************************/
 673
 674 /*******************************************************************************
 675  * movement / conversion
 676  ******************************************************************************/
 677
 678 void
 679 CodeEmitterGM107::emitMOV()
 680 {
 681    if ( insn->src(0).getFile() != FILE_IMMEDIATE ||
 682        (insn->sType != TYPE_F32 && !longIMMD(insn->src(0)))) {
 683       switch (insn->src(0).getFile()) {
 684       case FILE_GPR:
 685          if (insn->def(0).getFile() == FILE_PREDICATE) {
 686             emitInsn(0x5b6a0000);
 687             emitGPR (0x08);
 688          } else {
 689             emitInsn(0x5c980000);
 690          }
 691          emitGPR (0x14, insn->src(0));
 692          break;
 693       case FILE_MEMORY_CONST:
 694          emitInsn(0x4c980000);
 695          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
 696          break;
 697       case FILE_IMMEDIATE:
 698          emitInsn(0x38980000);
 699          emitIMMD(0x14, 19, insn->src(0));
 700          break;
 701       case FILE_PREDICATE:
 702          emitInsn(0x50880000);
 703          emitPRED(0x0c, insn->src(0));
 704          emitPRED(0x1d);
 705          emitPRED(0x27);
 706          break;
 707       default:
 708          assert(!"bad src file");
 709          break;
 710       }
 711       if (insn->def(0).getFile() != FILE_PREDICATE &&
 712           insn->src(0).getFile() != FILE_PREDICATE)
 713          emitField(0x27, 4, insn->lanes);
 714    } else {
 715       emitInsn (0x01000000);
 716       emitIMMD (0x14, 32, insn->src(0));
 717       emitField(0x0c, 4, insn->lanes);
 718    }
 719
 720    if (insn->def(0).getFile() == FILE_PREDICATE) {
 721       emitPRED(0x27);
 722       emitPRED(0x03, insn->def(0));
 723       emitPRED(0x00);
 724    } else {
 725       emitGPR(0x00, insn->def(0));
 726    }
 727 }
 728
 729 void
 730 CodeEmitterGM107::emitS2R()
 731 {
 732    emitInsn(0xf0c80000);
 733    emitSYS (0x14, insn->src(0));
 734    emitGPR (0x00, insn->def(0));
 735 }
 736
 737 void
 738 CodeEmitterGM107::emitF2F()
 739 {
 740    RoundMode rnd = insn->rnd;
 741
 742    switch (insn->op) {
 743    case OP_FLOOR: rnd = ROUND_MI; break;
 744    case OP_CEIL : rnd = ROUND_PI; break;
 745    case OP_TRUNC: rnd = ROUND_ZI; break;
 746    default:
 747       break;
 748    }
 749
 750    switch (insn->src(0).getFile()) {
 751    case FILE_GPR:
 752       emitInsn(0x5ca80000);
 753       emitGPR (0x14, insn->src(0));
 754       break;
 755    case FILE_MEMORY_CONST:
 756       emitInsn(0x4ca80000);
 757       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
 758       break;
 759    case FILE_IMMEDIATE:
 760       emitInsn(0x38a80000);
 761       emitIMMD(0x14, 19, insn->src(0));
 762       break;
 763    default:
 764       assert(!"bad src0 file");
 765       break;
 766    }
 767
 768    emitField(0x32, 1, (insn->op == OP_SAT) || insn->saturate);
 769    emitField(0x31, 1, (insn->op == OP_ABS) || insn->src(0).mod.abs());
 770    emitCC   (0x2f);
 771    emitField(0x2d, 1, (insn->op == OP_NEG) || insn->src(0).mod.neg());
 772    emitFMZ  (0x2c, 1);
 773    emitField(0x29, 1, insn->subOp);
 774    emitRND  (0x27, rnd, 0x2a);
 775    emitField(0x0a, 2, util_logbase2(typeSizeof(insn->sType)));
 776    emitField(0x08, 2, util_logbase2(typeSizeof(insn->dType)));
 777    emitGPR  (0x00, insn->def(0));
 778 }
 779
 780 void
 781 CodeEmitterGM107::emitF2I()
 782 {
 783    RoundMode rnd = insn->rnd;
 784
 785    switch (insn->op) {
 786    case OP_FLOOR: rnd = ROUND_M; break;
 787    case OP_CEIL : rnd = ROUND_P; break;
 788    case OP_TRUNC: rnd = ROUND_Z; break;
 789    default:
 790       break;
 791    }
 792
 793    switch (insn->src(0).getFile()) {
 794    case FILE_GPR:
 795       emitInsn(0x5cb00000);
 796       emitGPR (0x14, insn->src(0));
 797       break;
 798    case FILE_MEMORY_CONST:
 799       emitInsn(0x4cb00000);
 800       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
 801       break;
 802    case FILE_IMMEDIATE:
 803       emitInsn(0x38b00000);
 804       emitIMMD(0x14, 19, insn->src(0));
 805       break;
 806    default:
 807       assert(!"bad src0 file");
 808       break;
 809    }
 810
 811    emitField(0x31, 1, (insn->op == OP_ABS) || insn->src(0).mod.abs());
 812    emitCC   (0x2f);
 813    emitField(0x2d, 1, (insn->op == OP_NEG) || insn->src(0).mod.neg());
 814    emitFMZ  (0x2c, 1);
 815    emitRND  (0x27, rnd, 0x2a);
 816    emitField(0x0c, 1, isSignedType(insn->dType));
 817    emitField(0x0a, 2, util_logbase2(typeSizeof(insn->sType)));
 818    emitField(0x08, 2, util_logbase2(typeSizeof(insn->dType)));
 819    emitGPR  (0x00, insn->def(0));
 820 }
 821
 822 void
 823 CodeEmitterGM107::emitI2F()
 824 {
 825    RoundMode rnd = insn->rnd;
 826
 827    switch (insn->op) {
 828    case OP_FLOOR: rnd = ROUND_M; break;
 829    case OP_CEIL : rnd = ROUND_P; break;
 830    case OP_TRUNC: rnd = ROUND_Z; break;
 831    default:
 832       break;
 833    }
 834
 835    switch (insn->src(0).getFile()) {
 836    case FILE_GPR:
 837       emitInsn(0x5cb80000);
 838       emitGPR (0x14, insn->src(0));
 839       break;
 840    case FILE_MEMORY_CONST:
 841       emitInsn(0x4cb80000);
 842       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
 843       break;
 844    case FILE_IMMEDIATE:
 845       emitInsn(0x38b80000);
 846       emitIMMD(0x14, 19, insn->src(0));
 847       break;
 848    default:
 849       assert(!"bad src0 file");
 850       break;
 851    }
 852
 853    emitField(0x31, 1, (insn->op == OP_ABS) || insn->src(0).mod.abs());
 854    emitCC   (0x2f);
 855    emitField(0x2d, 1, (insn->op == OP_NEG) || insn->src(0).mod.neg());
 856    emitField(0x29, 2, insn->subOp);
 857    emitRND  (0x27, rnd, -1);
 858    emitField(0x0d, 1, isSignedType(insn->sType));
 859    emitField(0x0a, 2, util_logbase2(typeSizeof(insn->sType)));
 860    emitField(0x08, 2, util_logbase2(typeSizeof(insn->dType)));
 861    emitGPR  (0x00, insn->def(0));
 862 }
 863
 864 void
 865 CodeEmitterGM107::emitI2I()
 866 {
 867    switch (insn->src(0).getFile()) {
 868    case FILE_GPR:
 869       emitInsn(0x5ce00000);
 870       emitGPR (0x14, insn->src(0));
 871       break;
 872    case FILE_MEMORY_CONST:
 873       emitInsn(0x4ce00000);
 874       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
 875       break;
 876    case FILE_IMMEDIATE:
 877       emitInsn(0x38e00000);
 878       emitIMMD(0x14, 19, insn->src(0));
 879       break;
 880    default:
 881       assert(!"bad src0 file");
 882       break;
 883    }
 884
 885    emitSAT  (0x32);
 886    emitField(0x31, 1, (insn->op == OP_ABS) || insn->src(0).mod.abs());
 887    emitCC   (0x2f);
 888    emitField(0x2d, 1, (insn->op == OP_NEG) || insn->src(0).mod.neg());
 889    emitField(0x29, 2, insn->subOp);
 890    emitField(0x0d, 1, isSignedType(insn->sType));
 891    emitField(0x0c, 1, isSignedType(insn->dType));
 892    emitField(0x0a, 2, util_logbase2(typeSizeof(insn->sType)));
 893    emitField(0x08, 2, util_logbase2(typeSizeof(insn->dType)));
 894    emitGPR  (0x00, insn->def(0));
 895 }
 896
 897 static void
 898 selpFlip(const FixupEntry *entry, uint32_t *code, const FixupData& data)
 899 {
 900    int loc = entry->loc;
 901    if (data.force_persample_interp)
 902       code[loc + 1] |= 1 << 10;
 903    else
 904       code[loc + 1] &= ~(1 << 10);
 905 }
 906
 907 void
 908 CodeEmitterGM107::emitSEL()
 909 {
 910    switch (insn->src(1).getFile()) {
 911    case FILE_GPR:
 912       emitInsn(0x5ca00000);
 913       emitGPR (0x14, insn->src(1));
 914       break;
 915    case FILE_MEMORY_CONST:
 916       emitInsn(0x4ca00000);
 917       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
 918       break;
 919    case FILE_IMMEDIATE:
 920       emitInsn(0x38a00000);
 921       emitIMMD(0x14, 19, insn->src(1));
 922       break;
 923    default:
 924       assert(!"bad src1 file");
 925       break;
 926    }
 927
 928    emitINV (0x2a, insn->src(2));
 929    emitPRED(0x27, insn->src(2));
 930    emitGPR (0x08, insn->src(0));
 931    emitGPR (0x00, insn->def(0));
 932
 933    if (insn->subOp == 1) {
 934       addInterp(0, 0, selpFlip);
 935    }
 936 }
 937
 938 void
 939 CodeEmitterGM107::emitSHFL()
 940 {
 941    int type = 0;
 942
 943    emitInsn (0xef100000);
 944
 945    switch (insn->src(1).getFile()) {
 946    case FILE_GPR:
 947       emitGPR(0x14, insn->src(1));
 948       break;
 949    case FILE_IMMEDIATE:
 950       emitIMMD(0x14, 5, insn->src(1));
 951       type |= 1;
 952       break;
 953    default:
 954       assert(!"invalid src1 file");
 955       break;
 956    }
 957
 958    /*XXX: what is this arg? hardcode immediate for now */
 959    emitField(0x22, 13, 0x1c03);
 960    type |= 2;
 961
 962    emitPRED (0x30);
 963    emitField(0x1e, 2, insn->subOp);
 964    emitField(0x1c, 2, type);
 965    emitGPR  (0x08, insn->src(0));
 966    emitGPR  (0x00, insn->def(0));
 967 }
 968
 969 /*******************************************************************************
 970  * double
 971  ******************************************************************************/
 972
 973 void
 974 CodeEmitterGM107::emitDADD()
 975 {
 976    switch (insn->src(1).getFile()) {
 977    case FILE_GPR:
 978       emitInsn(0x5c700000);
 979       emitGPR (0x14, insn->src(1));
 980       break;
 981    case FILE_MEMORY_CONST:
 982       emitInsn(0x4c700000);
 983       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
 984       break;
 985    case FILE_IMMEDIATE:
 986       emitInsn(0x38700000);
 987       emitIMMD(0x14, 19, insn->src(1));
 988       break;
 989    default:
 990       assert(!"bad src1 file");
 991       break;
 992    }
 993    emitABS(0x31, insn->src(1));
 994    emitNEG(0x30, insn->src(0));
 995    emitCC (0x2f);
 996    emitABS(0x2e, insn->src(0));
 997    emitNEG(0x2d, insn->src(1));
 998
 999    if (insn->op == OP_SUB)
1000       code[1] ^= 0x00002000;
1001
1002    emitGPR(0x08, insn->src(0));
1003    emitGPR(0x00, insn->def(0));
1004 }
1005
1006 void
1007 CodeEmitterGM107::emitDMUL()
1008 {
1009    switch (insn->src(1).getFile()) {
1010    case FILE_GPR:
1011       emitInsn(0x5c800000);
1012       emitGPR (0x14, insn->src(1));
1013       break;
1014    case FILE_MEMORY_CONST:
1015       emitInsn(0x4c800000);
1016       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1017       break;
1018    case FILE_IMMEDIATE:
1019       emitInsn(0x38800000);
1020       emitIMMD(0x14, 19, insn->src(1));
1021       break;
1022    default:
1023       assert(!"bad src1 file");
1024       break;
1025    }
1026
1027    emitNEG2(0x30, insn->src(0), insn->src(1));
1028    emitCC  (0x2f);
1029    emitRND (0x27);
1030    emitGPR (0x08, insn->src(0));
1031    emitGPR (0x00, insn->def(0));
1032 }
1033
1034 void
1035 CodeEmitterGM107::emitDFMA()
1036 {
1037    switch(insn->src(2).getFile()) {
1038    case FILE_GPR:
1039       switch (insn->src(1).getFile()) {
1040       case FILE_GPR:
1041          emitInsn(0x5b700000);
1042          emitGPR (0x14, insn->src(1));
1043          break;
1044       case FILE_MEMORY_CONST:
1045          emitInsn(0x4b700000);
1046          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1047          break;
1048       case FILE_IMMEDIATE:
1049          emitInsn(0x36700000);
1050          emitIMMD(0x14, 19, insn->src(1));
1051          break;
1052       default:
1053          assert(!"bad src1 file");
1054          break;
1055       }
1056       emitGPR (0x27, insn->src(2));
1057       break;
1058    case FILE_MEMORY_CONST:
1059       emitInsn(0x53700000);
1060       emitGPR (0x27, insn->src(1));
1061       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(2));
1062       break;
1063    default:
1064       assert(!"bad src2 file");
1065       break;
1066    }
1067
1068    emitRND (0x32);
1069    emitNEG (0x31, insn->src(2));
1070    emitNEG2(0x30, insn->src(0), insn->src(1));
1071    emitCC  (0x2f);
1072    emitGPR (0x08, insn->src(0));
1073    emitGPR (0x00, insn->def(0));
1074 }
1075
1076 void
1077 CodeEmitterGM107::emitDMNMX()
1078 {
1079    switch (insn->src(1).getFile()) {
1080    case FILE_GPR:
1081       emitInsn(0x5c500000);
1082       emitGPR (0x14, insn->src(1));
1083       break;
1084    case FILE_MEMORY_CONST:
1085       emitInsn(0x4c500000);
1086       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1087       break;
1088    case FILE_IMMEDIATE:
1089       emitInsn(0x38500000);
1090       emitIMMD(0x14, 19, insn->src(1));
1091       break;
1092    default:
1093       assert(!"bad src1 file");
1094       break;
1095    }
1096
1097    emitABS  (0x31, insn->src(1));
1098    emitNEG  (0x30, insn->src(0));
1099    emitCC   (0x2f);
1100    emitABS  (0x2e, insn->src(0));
1101    emitNEG  (0x2d, insn->src(1));
1102    emitField(0x2a, 1, insn->op == OP_MAX);
1103    emitPRED (0x27);
1104    emitGPR  (0x08, insn->src(0));
1105    emitGPR  (0x00, insn->def(0));
1106 }
1107
1108 void
1109 CodeEmitterGM107::emitDSET()
1110 {
1111    const CmpInstruction *insn = this->insn->asCmp();
1112
1113    switch (insn->src(1).getFile()) {
1114    case FILE_GPR:
1115       emitInsn(0x59000000);
1116       emitGPR (0x14, insn->src(1));
1117       break;
1118    case FILE_MEMORY_CONST:
1119       emitInsn(0x49000000);
1120       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1121       break;
1122    case FILE_IMMEDIATE:
1123       emitInsn(0x32000000);
1124       emitIMMD(0x14, 19, insn->src(1));
1125       break;
1126    default:
1127       assert(!"bad src1 file");
1128       break;
1129    }
1130
1131    if (insn->op != OP_SET) {
1132       switch (insn->op) {
1133       case OP_SET_AND: emitField(0x2d, 2, 0); break;
1134       case OP_SET_OR : emitField(0x2d, 2, 1); break;
1135       case OP_SET_XOR: emitField(0x2d, 2, 2); break;
1136       default:
1137          assert(!"invalid set op");
1138          break;
1139       }
1140       emitPRED(0x27, insn->src(2));
1141    } else {
1142       emitPRED(0x27);
1143    }
1144
1145    emitABS  (0x36, insn->src(0));
1146    emitNEG  (0x35, insn->src(1));
1147    emitField(0x34, 1, insn->dType == TYPE_F32);
1148    emitCond4(0x30, insn->setCond);
1149    emitCC   (0x2f);
1150    emitABS  (0x2c, insn->src(1));
1151    emitNEG  (0x2b, insn->src(0));
1152    emitGPR  (0x08, insn->src(0));
1153    emitGPR  (0x00, insn->def(0));
1154 }
1155
1156 void
1157 CodeEmitterGM107::emitDSETP()
1158 {
1159    const CmpInstruction *insn = this->insn->asCmp();
1160
1161    switch (insn->src(1).getFile()) {
1162    case FILE_GPR:
1163       emitInsn(0x5b800000);
1164       emitGPR (0x14, insn->src(1));
1165       break;
1166    case FILE_MEMORY_CONST:
1167       emitInsn(0x4b800000);
1168       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1169       break;
1170    case FILE_IMMEDIATE:
1171       emitInsn(0x36800000);
1172       emitIMMD(0x14, 19, insn->src(1));
1173       break;
1174    default:
1175       assert(!"bad src1 file");
1176       break;
1177    }
1178
1179    if (insn->op != OP_SET) {
1180       switch (insn->op) {
1181       case OP_SET_AND: emitField(0x2d, 2, 0); break;
1182       case OP_SET_OR : emitField(0x2d, 2, 1); break;
1183       case OP_SET_XOR: emitField(0x2d, 2, 2); break;
1184       default:
1185          assert(!"invalid set op");
1186          break;
1187       }
1188       emitPRED(0x27, insn->src(2));
1189    } else {
1190       emitPRED(0x27);
1191    }
1192
1193    emitCond4(0x30, insn->setCond);
1194    emitABS  (0x2c, insn->src(1));
1195    emitNEG  (0x2b, insn->src(0));
1196    emitGPR  (0x08, insn->src(0));
1197    emitABS  (0x07, insn->src(0));
1198    emitNEG  (0x06, insn->src(1));
1199    emitPRED (0x03, insn->def(0));
1200    if (insn->defExists(1))
1201       emitPRED(0x00, insn->def(1));
1202    else
1203       emitPRED(0x00);
1204 }
1205
1206 /*******************************************************************************
1207  * float
1208  ******************************************************************************/
1209
1210 void
1211 CodeEmitterGM107::emitFADD()
1212 {
1213    if (!longIMMD(insn->src(1))) {
1214       switch (insn->src(1).getFile()) {
1215       case FILE_GPR:
1216          emitInsn(0x5c580000);
1217          emitGPR (0x14, insn->src(1));
1218          break;
1219       case FILE_MEMORY_CONST:
1220          emitInsn(0x4c580000);
1221          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1222          break;
1223       case FILE_IMMEDIATE:
1224          emitInsn(0x38580000);
1225          emitIMMD(0x14, 19, insn->src(1));
1226          break;
1227       default:
1228          assert(!"bad src1 file");
1229          break;
1230       }
1231       emitSAT(0x32);
1232       emitABS(0x31, insn->src(1));
1233       emitNEG(0x30, insn->src(0));
1234       emitCC (0x2f);
1235       emitABS(0x2e, insn->src(0));
1236       emitNEG(0x2d, insn->src(1));
1237       emitFMZ(0x2c, 1);
1238    } else {
1239       emitInsn(0x08000000);
1240       emitABS(0x39, insn->src(1));
1241       emitNEG(0x38, insn->src(0));
1242       emitFMZ(0x37, 1);
1243       emitABS(0x36, insn->src(0));
1244       emitNEG(0x35, insn->src(1));
1245       emitCC  (0x34);
1246       emitIMMD(0x14, 32, insn->src(1));
1247    }
1248
1249    if (insn->op == OP_SUB)
1250       code[1] ^= 0x00002000;
1251
1252    emitGPR(0x08, insn->src(0));
1253    emitGPR(0x00, insn->def(0));
1254 }
1255
1256 void
1257 CodeEmitterGM107::emitFMUL()
1258 {
1259    if (!longIMMD(insn->src(1))) {
1260       switch (insn->src(1).getFile()) {
1261       case FILE_GPR:
1262          emitInsn(0x5c680000);
1263          emitGPR (0x14, insn->src(1));
1264          break;
1265       case FILE_MEMORY_CONST:
1266          emitInsn(0x4c680000);
1267          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1268          break;
1269       case FILE_IMMEDIATE:
1270          emitInsn(0x38680000);
1271          emitIMMD(0x14, 19, insn->src(1));
1272          break;
1273       default:
1274          assert(!"bad src1 file");
1275          break;
1276       }
1277       emitSAT (0x32);
1278       emitNEG2(0x30, insn->src(0), insn->src(1));
1279       emitCC  (0x2f);
1280       emitFMZ (0x2c, 2);
1281       emitPDIV(0x29);
1282       emitRND (0x27);
1283    } else {
1284       emitInsn(0x1e000000);
1285       emitSAT (0x37);
1286       emitFMZ (0x35, 2);
1287       emitCC  (0x34);
1288       emitIMMD(0x14, 32, insn->src(1));
1289       if (insn->src(0).mod.neg() ^ insn->src(1).mod.neg())
1290          code[1] ^= 0x00080000; /* flip immd sign bit */
1291    }
1292
1293    emitGPR(0x08, insn->src(0));
1294    emitGPR(0x00, insn->def(0));
1295 }
1296
1297 void
1298 CodeEmitterGM107::emitFFMA()
1299 {
1300    /*XXX: ffma32i exists, but not using it as third src overlaps dst */
1301    switch(insn->src(2).getFile()) {
1302    case FILE_GPR:
1303       switch (insn->src(1).getFile()) {
1304       case FILE_GPR:
1305          emitInsn(0x59800000);
1306          emitGPR (0x14, insn->src(1));
1307          break;
1308       case FILE_MEMORY_CONST:
1309          emitInsn(0x49800000);
1310          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1311          break;
1312       case FILE_IMMEDIATE:
1313          emitInsn(0x32800000);
1314          emitIMMD(0x14, 19, insn->src(1));
1315          break;
1316       default:
1317          assert(!"bad src1 file");
1318          break;
1319       }
1320       emitGPR (0x27, insn->src(2));
1321       break;
1322    case FILE_MEMORY_CONST:
1323       emitInsn(0x51800000);
1324       emitGPR (0x27, insn->src(1));
1325       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(2));
1326       break;
1327    default:
1328       assert(!"bad src2 file");
1329       break;
1330    }
1331    emitRND (0x33);
1332    emitSAT (0x32);
1333    emitNEG (0x31, insn->src(2));
1334    emitNEG2(0x30, insn->src(0), insn->src(1));
1335    emitCC  (0x2f);
1336
1337    emitFMZ(0x35, 2);
1338    emitGPR(0x08, insn->src(0));
1339    emitGPR(0x00, insn->def(0));
1340 }
1341
1342 void
1343 CodeEmitterGM107::emitMUFU()
1344 {
1345    int mufu = 0;
1346
1347    switch (insn->op) {
1348    case OP_COS: mufu = 0; break;
1349    case OP_SIN: mufu = 1; break;
1350    case OP_EX2: mufu = 2; break;
1351    case OP_LG2: mufu = 3; break;
1352    case OP_RCP: mufu = 4 + 2 * insn->subOp; break;
1353    case OP_RSQ: mufu = 5 + 2 * insn->subOp; break;
1354    default:
1355       assert(!"invalid mufu");
1356       break;
1357    }
1358
1359    emitInsn (0x50800000);
1360    emitSAT  (0x32);
1361    emitNEG  (0x30, insn->src(0));
1362    emitABS  (0x2e, insn->src(0));
1363    emitField(0x14, 3, mufu);
1364    emitGPR  (0x08, insn->src(0));
1365    emitGPR  (0x00, insn->def(0));
1366 }
1367
1368 void
1369 CodeEmitterGM107::emitFMNMX()
1370 {
1371    switch (insn->src(1).getFile()) {
1372    case FILE_GPR:
1373       emitInsn(0x5c600000);
1374       emitGPR (0x14, insn->src(1));
1375       break;
1376    case FILE_MEMORY_CONST:
1377       emitInsn(0x4c600000);
1378       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1379       break;
1380    case FILE_IMMEDIATE:
1381       emitInsn(0x38600000);
1382       emitIMMD(0x14, 19, insn->src(1));
1383       break;
1384    default:
1385       assert(!"bad src1 file");
1386       break;
1387    }
1388
1389    emitField(0x2a, 1, insn->op == OP_MAX);
1390    emitPRED (0x27);
1391
1392    emitABS(0x31, insn->src(1));
1393    emitNEG(0x30, insn->src(0));
1394    emitCC (0x2f);
1395    emitABS(0x2e, insn->src(0));
1396    emitNEG(0x2d, insn->src(1));
1397    emitFMZ(0x2c, 1);
1398    emitGPR(0x08, insn->src(0));
1399    emitGPR(0x00, insn->def(0));
1400 }
1401
1402 void
1403 CodeEmitterGM107::emitRRO()
1404 {
1405    switch (insn->src(0).getFile()) {
1406    case FILE_GPR:
1407       emitInsn(0x5c900000);
1408       emitGPR (0x14, insn->src(0));
1409       break;
1410    case FILE_MEMORY_CONST:
1411       emitInsn(0x4c900000);
1412       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
1413       break;
1414    case FILE_IMMEDIATE:
1415       emitInsn(0x38900000);
1416       emitIMMD(0x14, 19, insn->src(0));
1417       break;
1418    default:
1419       assert(!"bad src file");
1420       break;
1421    }
1422
1423    emitABS  (0x31, insn->src(0));
1424    emitNEG  (0x2d, insn->src(0));
1425    emitField(0x27, 1, insn->op == OP_PREEX2);
1426    emitGPR  (0x00, insn->def(0));
1427 }
1428
1429 void
1430 CodeEmitterGM107::emitFCMP()
1431 {
1432    const CmpInstruction *insn = this->insn->asCmp();
1433    CondCode cc = insn->setCond;
1434
1435    if (insn->src(2).mod.neg())
1436       cc = reverseCondCode(cc);
1437
1438    switch(insn->src(2).getFile()) {
1439    case FILE_GPR:
1440       switch (insn->src(1).getFile()) {
1441       case FILE_GPR:
1442          emitInsn(0x5ba00000);
1443          emitGPR (0x14, insn->src(1));
1444          break;
1445       case FILE_MEMORY_CONST:
1446          emitInsn(0x4ba00000);
1447          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1448          break;
1449       case FILE_IMMEDIATE:
1450          emitInsn(0x36a00000);
1451          emitIMMD(0x14, 19, insn->src(1));
1452          break;
1453       default:
1454          assert(!"bad src1 file");
1455          break;
1456       }
1457       emitGPR (0x27, insn->src(2));
1458       break;
1459    case FILE_MEMORY_CONST:
1460       emitInsn(0x53a00000);
1461       emitGPR (0x27, insn->src(1));
1462       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(2));
1463       break;
1464    default:
1465       assert(!"bad src2 file");
1466       break;
1467    }
1468
1469    emitCond4(0x30, cc);
1470    emitFMZ  (0x2f, 1);
1471    emitGPR  (0x08, insn->src(0));
1472    emitGPR  (0x00, insn->def(0));
1473 }
1474
1475 void
1476 CodeEmitterGM107::emitFSET()
1477 {
1478    const CmpInstruction *insn = this->insn->asCmp();
1479
1480    switch (insn->src(1).getFile()) {
1481    case FILE_GPR:
1482       emitInsn(0x58000000);
1483       emitGPR (0x14, insn->src(1));
1484       break;
1485    case FILE_MEMORY_CONST:
1486       emitInsn(0x48000000);
1487       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1488       break;
1489    case FILE_IMMEDIATE:
1490       emitInsn(0x30000000);
1491       emitIMMD(0x14, 19, insn->src(1));
1492       break;
1493    default:
1494       assert(!"bad src1 file");
1495       break;
1496    }
1497
1498    if (insn->op != OP_SET) {
1499       switch (insn->op) {
1500       case OP_SET_AND: emitField(0x2d, 2, 0); break;
1501       case OP_SET_OR : emitField(0x2d, 2, 1); break;
1502       case OP_SET_XOR: emitField(0x2d, 2, 2); break;
1503       default:
1504          assert(!"invalid set op");
1505          break;
1506       }
1507       emitPRED(0x27, insn->src(2));
1508    } else {
1509       emitPRED(0x27);
1510    }
1511
1512    emitFMZ  (0x37, 1);
1513    emitABS  (0x36, insn->src(0));
1514    emitNEG  (0x35, insn->src(1));
1515    emitField(0x34, 1, insn->dType == TYPE_F32);
1516    emitCond4(0x30, insn->setCond);
1517    emitCC   (0x2f);
1518    emitABS  (0x2c, insn->src(1));
1519    emitNEG  (0x2b, insn->src(0));
1520    emitGPR  (0x08, insn->src(0));
1521    emitGPR  (0x00, insn->def(0));
1522 }
1523
1524 void
1525 CodeEmitterGM107::emitFSETP()
1526 {
1527    const CmpInstruction *insn = this->insn->asCmp();
1528
1529    switch (insn->src(1).getFile()) {
1530    case FILE_GPR:
1531       emitInsn(0x5bb00000);
1532       emitGPR (0x14, insn->src(1));
1533       break;
1534    case FILE_MEMORY_CONST:
1535       emitInsn(0x4bb00000);
1536       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1537       break;
1538    case FILE_IMMEDIATE:
1539       emitInsn(0x36b00000);
1540       emitIMMD(0x14, 19, insn->src(1));
1541       break;
1542    default:
1543       assert(!"bad src1 file");
1544       break;
1545    }
1546
1547    if (insn->op != OP_SET) {
1548       switch (insn->op) {
1549       case OP_SET_AND: emitField(0x2d, 2, 0); break;
1550       case OP_SET_OR : emitField(0x2d, 2, 1); break;
1551       case OP_SET_XOR: emitField(0x2d, 2, 2); break;
1552       default:
1553          assert(!"invalid set op");
1554          break;
1555       }
1556       emitPRED(0x27, insn->src(2));
1557    } else {
1558       emitPRED(0x27);
1559    }
1560
1561    emitCond4(0x30, insn->setCond);
1562    emitFMZ  (0x2f, 1);
1563    emitABS  (0x2c, insn->src(1));
1564    emitNEG  (0x2b, insn->src(0));
1565    emitGPR  (0x08, insn->src(0));
1566    emitABS  (0x07, insn->src(0));
1567    emitNEG  (0x06, insn->src(1));
1568    emitPRED (0x03, insn->def(0));
1569    if (insn->defExists(1))
1570       emitPRED(0x00, insn->def(1));
1571    else
1572       emitPRED(0x00);
1573 }
1574
1575 void
1576 CodeEmitterGM107::emitFSWZADD()
1577 {
1578    emitInsn (0x50f80000);
1579    emitCC   (0x2f);
1580    emitFMZ  (0x2c, 1);
1581    emitRND  (0x27);
1582    emitField(0x26, 1, insn->lanes); /* abused for .ndv */
1583    emitField(0x1c, 8, insn->subOp);
1584    if (insn->predSrc != 1)
1585       emitGPR  (0x14, insn->src(1));
1586    else
1587       emitGPR  (0x14);
1588    emitGPR  (0x08, insn->src(0));
1589    emitGPR  (0x00, insn->def(0));
1590 }
1591
1592 /*******************************************************************************
1593  * integer
1594  ******************************************************************************/
1595
1596 void
1597 CodeEmitterGM107::emitLOP()
1598 {
1599    int lop = 0;
1600
1601    switch (insn->op) {
1602    case OP_AND: lop = 0; break;
1603    case OP_OR : lop = 1; break;
1604    case OP_XOR: lop = 2; break;
1605    default:
1606       assert(!"invalid lop");
1607       break;
1608    }
1609
1610    if (!longIMMD(insn->src(1))) {
1611       switch (insn->src(1).getFile()) {
1612       case FILE_GPR:
1613          emitInsn(0x5c400000);
1614          emitGPR (0x14, insn->src(1));
1615          break;
1616       case FILE_MEMORY_CONST:
1617          emitInsn(0x4c400000);
1618          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1619          break;
1620       case FILE_IMMEDIATE:
1621          emitInsn(0x38400000);
1622          emitIMMD(0x14, 19, insn->src(1));
1623          break;
1624       default:
1625          assert(!"bad src1 file");
1626          break;
1627       }
1628       emitPRED (0x30);
1629       emitX    (0x2b);
1630       emitField(0x29, 2, lop);
1631       emitINV  (0x28, insn->src(1));
1632       emitINV  (0x27, insn->src(0));
1633    } else {
1634       emitInsn (0x04000000);
1635       emitX    (0x39);
1636       emitINV  (0x38, insn->src(1));
1637       emitINV  (0x37, insn->src(0));
1638       emitField(0x35, 2, lop);
1639       emitIMMD (0x14, 32, insn->src(1));
1640    }
1641
1642    emitGPR  (0x08, insn->src(0));
1643    emitGPR  (0x00, insn->def(0));
1644 }
1645
1646 /* special-case of emitLOP(): lop pass_b dst 0 ~src */
1647 void
1648 CodeEmitterGM107::emitNOT()
1649 {
1650    if (!longIMMD(insn->src(0))) {
1651       switch (insn->src(0).getFile()) {
1652       case FILE_GPR:
1653          emitInsn(0x5c400700);
1654          emitGPR (0x14, insn->src(0));
1655          break;
1656       case FILE_MEMORY_CONST:
1657          emitInsn(0x4c400700);
1658          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
1659          break;
1660       case FILE_IMMEDIATE:
1661          emitInsn(0x38400700);
1662          emitIMMD(0x14, 19, insn->src(0));
1663          break;
1664       default:
1665          assert(!"bad src1 file");
1666          break;
1667       }
1668       emitPRED (0x30);
1669    } else {
1670       emitInsn (0x05600000);
1671       emitIMMD (0x14, 32, insn->src(1));
1672    }
1673
1674    emitGPR(0x08);
1675    emitGPR(0x00, insn->def(0));
1676 }
1677
1678 void
1679 CodeEmitterGM107::emitIADD()
1680 {
1681    if (!longIMMD(insn->src(1))) {
1682       switch (insn->src(1).getFile()) {
1683       case FILE_GPR:
1684          emitInsn(0x5c100000);
1685          emitGPR (0x14, insn->src(1));
1686          break;
1687       case FILE_MEMORY_CONST:
1688          emitInsn(0x4c100000);
1689          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1690          break;
1691       case FILE_IMMEDIATE:
1692          emitInsn(0x38100000);
1693          emitIMMD(0x14, 19, insn->src(1));
1694          break;
1695       default:
1696          assert(!"bad src1 file");
1697          break;
1698       }
1699       emitSAT(0x32);
1700       emitNEG(0x31, insn->src(0));
1701       emitNEG(0x30, insn->src(1));
1702       emitCC (0x2f);
1703       emitX  (0x2b);
1704    } else {
1705       emitInsn(0x1c000000);
1706       emitSAT (0x36);
1707       emitX   (0x35);
1708       emitCC  (0x34);
1709       emitIMMD(0x14, 32, insn->src(1));
1710    }
1711
1712    if (insn->op == OP_SUB)
1713       code[1] ^= 0x00010000;
1714
1715    emitGPR(0x08, insn->src(0));
1716    emitGPR(0x00, insn->def(0));
1717 }
1718
1719 void
1720 CodeEmitterGM107::emitIMUL()
1721 {
1722    if (!longIMMD(insn->src(1))) {
1723       switch (insn->src(1).getFile()) {
1724       case FILE_GPR:
1725          emitInsn(0x5c380000);
1726          emitGPR (0x14, insn->src(1));
1727          break;
1728       case FILE_MEMORY_CONST:
1729          emitInsn(0x4c380000);
1730          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1731          break;
1732       case FILE_IMMEDIATE:
1733          emitInsn(0x38380000);
1734          emitIMMD(0x14, 19, insn->src(1));
1735          break;
1736       default:
1737          assert(!"bad src1 file");
1738          break;
1739       }
1740       emitCC   (0x2f);
1741       emitField(0x29, 1, isSignedType(insn->sType));
1742       emitField(0x28, 1, isSignedType(insn->dType));
1743       emitField(0x27, 1, insn->subOp == NV50_IR_SUBOP_MUL_HIGH);
1744    } else {
1745       emitInsn (0x1f000000);
1746       emitField(0x37, 1, isSignedType(insn->sType));
1747       emitField(0x36, 1, isSignedType(insn->dType));
1748       emitField(0x35, 1, insn->subOp == NV50_IR_SUBOP_MUL_HIGH);
1749       emitCC   (0x34);
1750       emitIMMD (0x14, 32, insn->src(1));
1751    }
1752
1753    emitGPR(0x08, insn->src(0));
1754    emitGPR(0x00, insn->def(0));
1755 }
1756
1757 void
1758 CodeEmitterGM107::emitIMAD()
1759 {
1760    /*XXX: imad32i exists, but not using it as third src overlaps dst */
1761    switch(insn->src(2).getFile()) {
1762    case FILE_GPR:
1763       switch (insn->src(1).getFile()) {
1764       case FILE_GPR:
1765          emitInsn(0x5a000000);
1766          emitGPR (0x14, insn->src(1));
1767          break;
1768       case FILE_MEMORY_CONST:
1769          emitInsn(0x4a000000);
1770          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1771          break;
1772       case FILE_IMMEDIATE:
1773          emitInsn(0x34000000);
1774          emitIMMD(0x14, 19, insn->src(1));
1775          break;
1776       default:
1777          assert(!"bad src1 file");
1778          break;
1779       }
1780       emitGPR (0x27, insn->src(2));
1781       break;
1782    case FILE_MEMORY_CONST:
1783       emitInsn(0x52000000);
1784       emitGPR (0x27, insn->src(1));
1785       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(2));
1786       break;
1787    default:
1788       assert(!"bad src2 file");
1789       break;
1790    }
1791
1792    emitField(0x36, 1, insn->subOp == NV50_IR_SUBOP_MUL_HIGH);
1793    emitField(0x35, 1, isSignedType(insn->sType));
1794    emitNEG  (0x34, insn->src(2));
1795    emitNEG2 (0x33, insn->src(0), insn->src(1));
1796    emitSAT  (0x32);
1797    emitX    (0x31);
1798    emitField(0x30, 1, isSignedType(insn->dType));
1799    emitCC   (0x2f);
1800    emitGPR  (0x08, insn->src(0));
1801    emitGPR  (0x00, insn->def(0));
1802 }
1803
1804 void
1805 CodeEmitterGM107::emitIMNMX()
1806 {
1807    switch (insn->src(1).getFile()) {
1808    case FILE_GPR:
1809       emitInsn(0x5c200000);
1810       emitGPR (0x14, insn->src(1));
1811       break;
1812    case FILE_MEMORY_CONST:
1813       emitInsn(0x4c200000);
1814       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1815       break;
1816    case FILE_IMMEDIATE:
1817       emitInsn(0x38200000);
1818       emitIMMD(0x14, 19, insn->src(1));
1819       break;
1820    default:
1821       assert(!"bad src1 file");
1822       break;
1823    }
1824
1825    emitField(0x30, 1, isSignedType(insn->dType));
1826    emitCC   (0x2f);
1827    emitField(0x2a, 1, insn->op == OP_MAX);
1828    emitPRED (0x27);
1829    emitGPR  (0x08, insn->src(0));
1830    emitGPR  (0x00, insn->def(0));
1831 }
1832
1833 void
1834 CodeEmitterGM107::emitICMP()
1835 {
1836    const CmpInstruction *insn = this->insn->asCmp();
1837    CondCode cc = insn->setCond;
1838
1839    if (insn->src(2).mod.neg())
1840       cc = reverseCondCode(cc);
1841
1842    switch(insn->src(2).getFile()) {
1843    case FILE_GPR:
1844       switch (insn->src(1).getFile()) {
1845       case FILE_GPR:
1846          emitInsn(0x5b400000);
1847          emitGPR (0x14, insn->src(1));
1848          break;
1849       case FILE_MEMORY_CONST:
1850          emitInsn(0x4b400000);
1851          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1852          break;
1853       case FILE_IMMEDIATE:
1854          emitInsn(0x36400000);
1855          emitIMMD(0x14, 19, insn->src(1));
1856          break;
1857       default:
1858          assert(!"bad src1 file");
1859          break;
1860       }
1861       emitGPR (0x27, insn->src(2));
1862       break;
1863    case FILE_MEMORY_CONST:
1864       emitInsn(0x53400000);
1865       emitGPR (0x27, insn->src(1));
1866       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(2));
1867       break;
1868    default:
1869       assert(!"bad src2 file");
1870       break;
1871    }
1872
1873    emitCond3(0x31, cc);
1874    emitField(0x30, 1, isSignedType(insn->sType));
1875    emitGPR  (0x08, insn->src(0));
1876    emitGPR  (0x00, insn->def(0));
1877 }
1878
1879 void
1880 CodeEmitterGM107::emitISET()
1881 {
1882    const CmpInstruction *insn = this->insn->asCmp();
1883
1884    switch (insn->src(1).getFile()) {
1885    case FILE_GPR:
1886       emitInsn(0x5b500000);
1887       emitGPR (0x14, insn->src(1));
1888       break;
1889    case FILE_MEMORY_CONST:
1890       emitInsn(0x4b500000);
1891       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1892       break;
1893    case FILE_IMMEDIATE:
1894       emitInsn(0x36500000);
1895       emitIMMD(0x14, 19, insn->src(1));
1896       break;
1897    default:
1898       assert(!"bad src1 file");
1899       break;
1900    }
1901
1902    if (insn->op != OP_SET) {
1903       switch (insn->op) {
1904       case OP_SET_AND: emitField(0x2d, 2, 0); break;
1905       case OP_SET_OR : emitField(0x2d, 2, 1); break;
1906       case OP_SET_XOR: emitField(0x2d, 2, 2); break;
1907       default:
1908          assert(!"invalid set op");
1909          break;
1910       }
1911       emitPRED(0x27, insn->src(2));
1912    } else {
1913       emitPRED(0x27);
1914    }
1915
1916    emitCond3(0x31, insn->setCond);
1917    emitField(0x30, 1, isSignedType(insn->sType));
1918    emitCC   (0x2f);
1919    emitField(0x2c, 1, insn->dType == TYPE_F32);
1920    emitX    (0x2b);
1921    emitGPR  (0x08, insn->src(0));
1922    emitGPR  (0x00, insn->def(0));
1923 }
1924
1925 void
1926 CodeEmitterGM107::emitISETP()
1927 {
1928    const CmpInstruction *insn = this->insn->asCmp();
1929
1930    switch (insn->src(1).getFile()) {
1931    case FILE_GPR:
1932       emitInsn(0x5b600000);
1933       emitGPR (0x14, insn->src(1));
1934       break;
1935    case FILE_MEMORY_CONST:
1936       emitInsn(0x4b600000);
1937       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1938       break;
1939    case FILE_IMMEDIATE:
1940       emitInsn(0x36600000);
1941       emitIMMD(0x14, 19, insn->src(1));
1942       break;
1943    default:
1944       assert(!"bad src1 file");
1945       break;
1946    }
1947
1948    if (insn->op != OP_SET) {
1949       switch (insn->op) {
1950       case OP_SET_AND: emitField(0x2d, 2, 0); break;
1951       case OP_SET_OR : emitField(0x2d, 2, 1); break;
1952       case OP_SET_XOR: emitField(0x2d, 2, 2); break;
1953       default:
1954          assert(!"invalid set op");
1955          break;
1956       }
1957       emitPRED(0x27, insn->src(2));
1958    } else {
1959       emitPRED(0x27);
1960    }
1961
1962    emitCond3(0x31, insn->setCond);
1963    emitField(0x30, 1, isSignedType(insn->sType));
1964    emitX    (0x2b);
1965    emitGPR  (0x08, insn->src(0));
1966    emitPRED (0x03, insn->def(0));
1967    if (insn->defExists(1))
1968       emitPRED(0x00, insn->def(1));
1969    else
1970       emitPRED(0x00);
1971 }
1972
1973 void
1974 CodeEmitterGM107::emitSHL()
1975 {
1976    switch (insn->src(1).getFile()) {
1977    case FILE_GPR:
1978       emitInsn(0x5c480000);
1979       emitGPR (0x14, insn->src(1));
1980       break;
1981    case FILE_MEMORY_CONST:
1982       emitInsn(0x4c480000);
1983       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1984       break;
1985    case FILE_IMMEDIATE:
1986       emitInsn(0x38480000);
1987       emitIMMD(0x14, 19, insn->src(1));
1988       break;
1989    default:
1990       assert(!"bad src1 file");
1991       break;
1992    }
1993
1994    emitCC   (0x2f);
1995    emitX    (0x2b);
1996    emitField(0x27, 1, insn->subOp == NV50_IR_SUBOP_SHIFT_WRAP);
1997    emitGPR  (0x08, insn->src(0));
1998    emitGPR  (0x00, insn->def(0));
1999 }
2000
2001 void
2002 CodeEmitterGM107::emitSHR()
2003 {
2004    switch (insn->src(1).getFile()) {
2005    case FILE_GPR:
2006       emitInsn(0x5c280000);
2007       emitGPR (0x14, insn->src(1));
2008       break;
2009    case FILE_MEMORY_CONST:
2010       emitInsn(0x4c280000);
2011       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
2012       break;
2013    case FILE_IMMEDIATE:
2014       emitInsn(0x38280000);
2015       emitIMMD(0x14, 19, insn->src(1));
2016       break;
2017    default:
2018       assert(!"bad src1 file");
2019       break;
2020    }
2021
2022    emitField(0x30, 1, isSignedType(insn->dType));
2023    emitCC   (0x2f);
2024    emitX    (0x2c);
2025    emitField(0x27, 1, insn->subOp == NV50_IR_SUBOP_SHIFT_WRAP);
2026    emitGPR  (0x08, insn->src(0));
2027    emitGPR  (0x00, insn->def(0));
2028 }
2029
2030 void
2031 CodeEmitterGM107::emitPOPC()
2032 {
2033    switch (insn->src(0).getFile()) {
2034    case FILE_GPR:
2035       emitInsn(0x5c080000);
2036       emitGPR (0x14, insn->src(0));
2037       break;
2038    case FILE_MEMORY_CONST:
2039       emitInsn(0x4c080000);
2040       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
2041       break;
2042    case FILE_IMMEDIATE:
2043       emitInsn(0x38080000);
2044       emitIMMD(0x14, 19, insn->src(0));
2045       break;
2046    default:
2047       assert(!"bad src1 file");
2048       break;
2049    }
2050
2051    emitINV(0x28, insn->src(0));
2052    emitGPR(0x00, insn->def(0));
2053 }
2054
2055 void
2056 CodeEmitterGM107::emitBFI()
2057 {
2058    switch(insn->src(2).getFile()) {
2059    case FILE_GPR:
2060       switch (insn->src(1).getFile()) {
2061       case FILE_GPR:
2062          emitInsn(0x5bf00000);
2063          emitGPR (0x14, insn->src(1));
2064          break;
2065       case FILE_MEMORY_CONST:
2066          emitInsn(0x4bf00000);
2067          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
2068          break;
2069       case FILE_IMMEDIATE:
2070          emitInsn(0x36f00000);
2071          emitIMMD(0x14, 19, insn->src(1));
2072          break;
2073       default:
2074          assert(!"bad src1 file");
2075          break;
2076       }
2077       emitGPR (0x27, insn->src(2));
2078       break;
2079    case FILE_MEMORY_CONST:
2080       emitInsn(0x53f00000);
2081       emitGPR (0x27, insn->src(1));
2082       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(2));
2083       break;
2084    default:
2085       assert(!"bad src2 file");
2086       break;
2087    }
2088
2089    emitCC   (0x2f);
2090    emitGPR  (0x08, insn->src(0));
2091    emitGPR  (0x00, insn->def(0));
2092 }
2093
2094 void
2095 CodeEmitterGM107::emitBFE()
2096 {
2097    switch (insn->src(1).getFile()) {
2098    case FILE_GPR:
2099       emitInsn(0x5c000000);
2100       emitGPR (0x14, insn->src(1));
2101       break;
2102    case FILE_MEMORY_CONST:
2103       emitInsn(0x4c000000);
2104       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
2105       break;
2106    case FILE_IMMEDIATE:
2107       emitInsn(0x38000000);
2108       emitIMMD(0x14, 19, insn->src(1));
2109       break;
2110    default:
2111       assert(!"bad src1 file");
2112       break;
2113    }
2114
2115    emitField(0x30, 1, isSignedType(insn->dType));
2116    emitCC   (0x2f);
2117    emitField(0x28, 1, insn->subOp == NV50_IR_SUBOP_EXTBF_REV);
2118    emitGPR  (0x08, insn->src(0));
2119    emitGPR  (0x00, insn->def(0));
2120 }
2121
2122 void
2123 CodeEmitterGM107::emitFLO()
2124 {
2125    switch (insn->src(0).getFile()) {
2126    case FILE_GPR:
2127       emitInsn(0x5c300000);
2128       emitGPR (0x14, insn->src(0));
2129       break;
2130    case FILE_MEMORY_CONST:
2131       emitInsn(0x4c300000);
2132       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
2133       break;
2134    case FILE_IMMEDIATE:
2135       emitInsn(0x38300000);
2136       emitIMMD(0x14, 19, insn->src(0));
2137       break;
2138    default:
2139       assert(!"bad src1 file");
2140       break;
2141    }
2142
2143    emitField(0x30, 1, isSignedType(insn->dType));
2144    emitCC   (0x2f);
2145    emitField(0x29, 1, insn->subOp == NV50_IR_SUBOP_BFIND_SAMT);
2146    emitINV  (0x28, insn->src(0));
2147    emitGPR  (0x00, insn->def(0));
2148 }
2149
2150 /*******************************************************************************
2151  * memory
2152  ******************************************************************************/
2153
2154 void
2155 CodeEmitterGM107::emitLDSTs(int pos, DataType type)
2156 {
2157    int data = 0;
2158
2159    switch (typeSizeof(type)) {
2160    case  1: data = isSignedType(type) ? 1 : 0; break;
2161    case  2: data = isSignedType(type) ? 3 : 2; break;
2162    case  4: data = 4; break;
2163    case  8: data = 5; break;
2164    case 16: data = 6; break;
2165    default:
2166       assert(!"bad type");
2167       break;
2168    }
2169
2170    emitField(pos, 3, data);
2171 }
2172
2173 void
2174 CodeEmitterGM107::emitLDSTc(int pos)
2175 {
2176    int mode = 0;
2177
2178    switch (insn->cache) {
2179    case CACHE_CA: mode = 0; break;
2180    case CACHE_CG: mode = 1; break;
2181    case CACHE_CS: mode = 2; break;
2182    case CACHE_CV: mode = 3; break;
2183    default:
2184       assert(!"invalid caching mode");
2185       break;
2186    }
2187
2188    emitField(pos, 2, mode);
2189 }
2190
2191 void
2192 CodeEmitterGM107::emitLDC()
2193 {
2194    emitInsn (0xef900000);
2195    emitLDSTs(0x30, insn->dType);
2196    emitField(0x2c, 2, insn->subOp);
2197    emitCBUF (0x24, 0x08, 0x14, 16, 0, insn->src(0));
2198    emitGPR  (0x00, insn->def(0));
2199 }
2200
2201 void
2202 CodeEmitterGM107::emitLDL()
2203 {
2204    emitInsn (0xef400000);
2205    emitLDSTs(0x30, insn->dType);
2206    emitLDSTc(0x2c);
2207    emitADDR (0x08, 0x14, 24, 0, insn->src(0));
2208    emitGPR  (0x00, insn->def(0));
2209 }
2210
2211 void
2212 CodeEmitterGM107::emitLDS()
2213 {
2214    emitInsn (0xef480000);
2215    emitLDSTs(0x30, insn->dType);
2216    emitADDR (0x08, 0x14, 24, 0, insn->src(0));
2217    emitGPR  (0x00, insn->def(0));
2218 }
2219
2220 void
2221 CodeEmitterGM107::emitLD()
2222 {
2223    emitInsn (0x80000000);
2224    emitPRED (0x3a);
2225    emitLDSTc(0x38);
2226    emitLDSTs(0x35, insn->dType);
2227    emitField(0x34, 1, insn->src(0).getIndirect(0)->getSize() == 8);
2228    emitADDR (0x08, 0x14, 32, 0, insn->src(0));
2229    emitGPR  (0x00, insn->def(0));
2230 }
2231
2232 void
2233 CodeEmitterGM107::emitSTL()
2234 {
2235    emitInsn (0xef500000);
2236    emitLDSTs(0x30, insn->dType);
2237    emitLDSTc(0x2c);
2238    emitADDR (0x08, 0x14, 24, 0, insn->src(0));
2239    emitGPR  (0x00, insn->src(1));
2240 }
2241
2242 void
2243 CodeEmitterGM107::emitSTS()
2244 {
2245    emitInsn (0xef580000);
2246    emitLDSTs(0x30, insn->dType);
2247    emitADDR (0x08, 0x14, 24, 0, insn->src(0));
2248    emitGPR  (0x00, insn->src(1));
2249 }
2250
2251 void
2252 CodeEmitterGM107::emitST()
2253 {
2254    emitInsn (0xa0000000);
2255    emitPRED (0x3a);
2256    emitLDSTc(0x38);
2257    emitLDSTs(0x35, insn->dType);
2258    emitField(0x34, 1, insn->src(0).getIndirect(0)->getSize() == 8);
2259    emitADDR (0x08, 0x14, 32, 0, insn->src(0));
2260    emitGPR  (0x00, insn->src(1));
2261 }
2262
2263 void
2264 CodeEmitterGM107::emitALD()
2265 {
2266    emitInsn (0xefd80000);
2267    emitField(0x2f, 2, (insn->getDef(0)->reg.size / 4) - 1);
2268    emitGPR  (0x27, insn->src(0).getIndirect(1));
2269    emitO    (0x20);
2270    emitP    (0x1f);
2271    emitADDR (0x08, 20, 10, 0, insn->src(0));
2272    emitGPR  (0x00, insn->def(0));
2273 }
2274
2275 void
2276 CodeEmitterGM107::emitAST()
2277 {
2278    emitInsn (0xeff00000);
2279    emitField(0x2f, 2, (typeSizeof(insn->dType) / 4) - 1);
2280    emitGPR  (0x27, insn->src(0).getIndirect(1));
2281    emitP    (0x1f);
2282    emitADDR (0x08, 20, 10, 0, insn->src(0));
2283    emitGPR  (0x00, insn->src(1));
2284 }
2285
2286 void
2287 CodeEmitterGM107::emitISBERD()
2288 {
2289    emitInsn(0xefd00000);
2290    emitGPR (0x08, insn->src(0));
2291    emitGPR (0x00, insn->def(0));
2292 }
2293
2294 void
2295 CodeEmitterGM107::emitAL2P()
2296 {
2297    emitInsn (0xefa00000);
2298    emitField(0x2f, 2, (insn->getDef(0)->reg.size / 4) - 1);
2299    emitO    (0x20);
2300    emitField(0x14, 11, insn->src(0).get()->reg.data.offset);
2301    emitGPR  (0x08, insn->src(0).getIndirect(0));
2302    emitGPR  (0x00, insn->def(0));
2303 }
2304
2305 static void
2306 interpApply(const FixupEntry *entry, uint32_t *code, const FixupData& data)
2307 {
2308    int ipa = entry->ipa;
2309    int reg = entry->reg;
2310    int loc = entry->loc;
2311
2312    if (data.flatshade &&
2313        (ipa & NV50_IR_INTERP_MODE_MASK) == NV50_IR_INTERP_SC) {
2314       ipa = NV50_IR_INTERP_FLAT;
2315       reg = 0xff;
2316    } else if (data.force_persample_interp &&
2317               (ipa & NV50_IR_INTERP_SAMPLE_MASK) == NV50_IR_INTERP_DEFAULT &&
2318               (ipa & NV50_IR_INTERP_MODE_MASK) != NV50_IR_INTERP_FLAT) {
2319       ipa |= NV50_IR_INTERP_CENTROID;
2320    }
2321    code[loc + 1] &= ~(0xf << 0x14);
2322    code[loc + 1] |= (ipa & 0x3) << 0x16;
2323    code[loc + 1] |= (ipa & 0xc) << (0x14 - 2);
2324    code[loc + 0] &= ~(0xff << 0x14);
2325    code[loc + 0] |= reg << 0x14;
2326 }
2327
2328 void
2329 CodeEmitterGM107::emitIPA()
2330 {
2331    int ipam = 0, ipas = 0;
2332
2333    switch (insn->getInterpMode()) {
2334    case NV50_IR_INTERP_LINEAR     : ipam = 0; break;
2335    case NV50_IR_INTERP_PERSPECTIVE: ipam = 1; break;
2336    case NV50_IR_INTERP_FLAT       : ipam = 2; break;
2337    case NV50_IR_INTERP_SC         : ipam = 3; break;
2338    default:
2339       assert(!"invalid ipa mode");
2340       break;
2341    }
2342
2343    switch (insn->getSampleMode()) {
2344    case NV50_IR_INTERP_DEFAULT : ipas = 0; break;
2345    case NV50_IR_INTERP_CENTROID: ipas = 1; break;
2346    case NV50_IR_INTERP_OFFSET  : ipas = 2; break;
2347    default:
2348       assert(!"invalid ipa sample mode");
2349       break;
2350    }
2351
2352    emitInsn (0xe0000000);
2353    emitField(0x36, 2, ipam);
2354    emitField(0x34, 2, ipas);
2355    emitSAT  (0x33);
2356    emitField(0x2f, 3, 7);
2357    emitADDR (0x08, 0x1c, 10, 0, insn->src(0));
2358    if ((code[0] & 0x0000ff00) != 0x0000ff00)
2359       code[1] |= 0x00000040; /* .idx */
2360    emitGPR(0x00, insn->def(0));
2361
2362    if (insn->op == OP_PINTERP) {
2363       emitGPR(0x14, insn->src(1));
2364       if (insn->getSampleMode() == NV50_IR_INTERP_OFFSET)
2365          emitGPR(0x27, insn->src(2));
2366       addInterp(insn->ipa, insn->getSrc(1)->reg.data.id, interpApply);
2367    } else {
2368       if (insn->getSampleMode() == NV50_IR_INTERP_OFFSET)
2369          emitGPR(0x27, insn->src(1));
2370       emitGPR(0x14);
2371       addInterp(insn->ipa, 0xff, interpApply);
2372    }
2373
2374    if (insn->getSampleMode() != NV50_IR_INTERP_OFFSET)
2375       emitGPR(0x27);
2376 }
2377
2378 void
2379 CodeEmitterGM107::emitATOM()
2380 {
2381    unsigned dType, subOp;
2382
2383    if (insn->subOp == NV50_IR_SUBOP_ATOM_CAS) {
2384       switch (insn->dType) {
2385       case TYPE_U32: dType = 0; break;
2386       case TYPE_U64: dType = 1; break;
2387       default: assert(!"unexpected dType"); dType = 0; break;
2388       }
2389       subOp = 15;
2390
2391       emitInsn (0xee000000);
2392    } else {
2393       switch (insn->dType) {
2394       case TYPE_U32: dType = 0; break;
2395       case TYPE_S32: dType = 1; break;
2396       case TYPE_U64: dType = 2; break;
2397       case TYPE_F32: dType = 3; break;
2398       case TYPE_B128: dType = 4; break;
2399       case TYPE_S64: dType = 5; break;
2400       default: assert(!"unexpected dType"); dType = 0; break;
2401       }
2402       if (insn->subOp == NV50_IR_SUBOP_ATOM_EXCH)
2403          subOp = 8;
2404       else
2405          subOp = insn->subOp;
2406
2407       emitInsn (0xed000000);
2408    }
2409
2410    emitField(0x34, 4, subOp);
2411    emitField(0x31, 3, dType);
2412    emitField(0x30, 1, insn->src(0).getIndirect(0)->getSize() == 8);
2413    emitGPR  (0x14, insn->src(1));
2414    emitADDR (0x08, 0x1c, 20, 0, insn->src(0));
2415    emitGPR  (0x00, insn->def(0));
2416 }
2417
2418 void
2419 CodeEmitterGM107::emitATOMS()
2420 {
2421    unsigned dType, subOp;
2422
2423    if (insn->subOp == NV50_IR_SUBOP_ATOM_CAS) {
2424       switch (insn->dType) {
2425       case TYPE_U32: dType = 0; break;
2426       case TYPE_U64: dType = 1; break;
2427       default: assert(!"unexpected dType"); dType = 0; break;
2428       }
2429       subOp = 4;
2430
2431       emitInsn (0xee000000);
2432       emitField(0x34, 1, dType);
2433    } else {
2434       switch (insn->dType) {
2435       case TYPE_U32: dType = 0; break;
2436       case TYPE_S32: dType = 1; break;
2437       case TYPE_U64: dType = 2; break;
2438       case TYPE_S64: dType = 3; break;
2439       default: assert(!"unexpected dType"); dType = 0; break;
2440       }
2441
2442       if (insn->subOp == NV50_IR_SUBOP_ATOM_EXCH)
2443          subOp = 8;
2444       else
2445          subOp = insn->subOp;
2446
2447       emitInsn (0xec000000);
2448       emitField(0x1c, 3, dType);
2449    }
2450
2451    emitField(0x34, 4, subOp);
2452    emitGPR  (0x14, insn->src(1));
2453    emitADDR (0x08, 0x12, 22, 0, insn->src(0));
2454    emitGPR  (0x00, insn->def(0));
2455 }
2456
2457 void
2458 CodeEmitterGM107::emitCCTL()
2459 {
2460    unsigned width;
2461    if (insn->src(0).getFile() == FILE_MEMORY_GLOBAL) {
2462       emitInsn(0xef600000);
2463       width = 30;
2464    } else {
2465       emitInsn(0xef800000);
2466       width = 22;
2467    }
2468    emitField(0x34, 1, insn->src(0).getIndirect(0)->getSize() == 8);
2469    emitADDR (0x08, 0x16, width, 2, insn->src(0));
2470    emitField(0x00, 4, insn->subOp);
2471 }
2472
2473 /*******************************************************************************
2474  * surface
2475  ******************************************************************************/
2476
2477 void
2478 CodeEmitterGM107::emitPIXLD()
2479 {
2480    emitInsn (0xefe80000);
2481    emitPRED (0x2d);
2482    emitField(0x1f, 3, insn->subOp);
2483    emitGPR  (0x08, insn->src(0));
2484    emitGPR  (0x00, insn->def(0));
2485 }
2486
2487 /*******************************************************************************
2488  * texture
2489  ******************************************************************************/
2490
2491 void
2492 CodeEmitterGM107::emitTEXs(int pos)
2493 {
2494    int src1 = insn->predSrc == 1 ? 2 : 1;
2495    if (insn->srcExists(src1))
2496       emitGPR(pos, insn->src(src1));
2497    else
2498       emitGPR(pos);
2499 }
2500
2501 void
2502 CodeEmitterGM107::emitTEX()
2503 {
2504    const TexInstruction *insn = this->insn->asTex();
2505    int lodm = 0;
2506
2507    if (!insn->tex.levelZero) {
2508       switch (insn->op) {
2509       case OP_TEX: lodm = 0; break;
2510       case OP_TXB: lodm = 2; break;
2511       case OP_TXL: lodm = 3; break;
2512       default:
2513          assert(!"invalid tex op");
2514          break;
2515       }
2516    } else {
2517       lodm = 1;
2518    }
2519
2520    if (insn->tex.rIndirectSrc >= 0) {
2521       emitInsn (0xdeb80000);
2522       emitField(0x35, 2, lodm);
2523       emitField(0x24, 1, insn->tex.useOffsets == 1);
2524    } else {
2525       emitInsn (0xc0380000);
2526       emitField(0x37, 2, lodm);
2527       emitField(0x36, 1, insn->tex.useOffsets == 1);
2528       emitField(0x24, 13, insn->tex.r);
2529    }
2530
2531    emitField(0x32, 1, insn->tex.target.isShadow());
2532    emitField(0x31, 1, insn->tex.liveOnly);
2533    emitField(0x23, 1, insn->tex.derivAll);
2534    emitField(0x1f, 4, insn->tex.mask);
2535    emitField(0x1d, 2, insn->tex.target.isCube() ? 3 :
2536                       insn->tex.target.getDim() - 1);
2537    emitField(0x1c, 1, insn->tex.target.isArray());
2538    emitTEXs (0x14);
2539    emitGPR  (0x08, insn->src(0));
2540    emitGPR  (0x00, insn->def(0));
2541 }
2542
2543 void
2544 CodeEmitterGM107::emitTLD()
2545 {
2546    const TexInstruction *insn = this->insn->asTex();
2547
2548    if (insn->tex.rIndirectSrc >= 0) {
2549       emitInsn (0xdd380000);
2550    } else {
2551       emitInsn (0xdc380000);
2552       emitField(0x24, 13, insn->tex.r);
2553    }
2554
2555    emitField(0x37, 1, insn->tex.levelZero == 0);
2556    emitField(0x32, 1, insn->tex.target.isMS());
2557    emitField(0x31, 1, insn->tex.liveOnly);
2558    emitField(0x23, 1, insn->tex.useOffsets == 1);
2559    emitField(0x1f, 4, insn->tex.mask);
2560    emitField(0x1d, 2, insn->tex.target.isCube() ? 3 :
2561                       insn->tex.target.getDim() - 1);
2562    emitField(0x1c, 1, insn->tex.target.isArray());
2563    emitTEXs (0x14);
2564    emitGPR  (0x08, insn->src(0));
2565    emitGPR  (0x00, insn->def(0));
2566 }
2567
2568 void
2569 CodeEmitterGM107::emitTLD4()
2570 {
2571    const TexInstruction *insn = this->insn->asTex();
2572
2573    if (insn->tex.rIndirectSrc >= 0) {
2574       emitInsn (0xdef80000);
2575       emitField(0x26, 2, insn->tex.gatherComp);
2576       emitField(0x25, 2, insn->tex.useOffsets == 4);
2577       emitField(0x24, 2, insn->tex.useOffsets == 1);
2578    } else {
2579       emitInsn (0xc8380000);
2580       emitField(0x38, 2, insn->tex.gatherComp);
2581       emitField(0x37, 2, insn->tex.useOffsets == 4);
2582       emitField(0x36, 2, insn->tex.useOffsets == 1);
2583       emitField(0x24, 13, insn->tex.r);
2584    }
2585
2586    emitField(0x32, 1, insn->tex.target.isShadow());
2587    emitField(0x31, 1, insn->tex.liveOnly);
2588    emitField(0x23, 1, insn->tex.derivAll);
2589    emitField(0x1f, 4, insn->tex.mask);
2590    emitField(0x1d, 2, insn->tex.target.isCube() ? 3 :
2591                       insn->tex.target.getDim() - 1);
2592    emitField(0x1c, 1, insn->tex.target.isArray());
2593    emitTEXs (0x14);
2594    emitGPR  (0x08, insn->src(0));
2595    emitGPR  (0x00, insn->def(0));
2596 }
2597
2598 void
2599 CodeEmitterGM107::emitTXD()
2600 {
2601    const TexInstruction *insn = this->insn->asTex();
2602
2603    if (insn->tex.rIndirectSrc >= 0) {
2604       emitInsn (0xde780000);
2605    } else {
2606       emitInsn (0xde380000);
2607       emitField(0x24, 13, insn->tex.r);
2608    }
2609
2610    emitField(0x31, 1, insn->tex.liveOnly);
2611    emitField(0x23, 1, insn->tex.useOffsets == 1);
2612    emitField(0x1f, 4, insn->tex.mask);
2613    emitField(0x1d, 2, insn->tex.target.isCube() ? 3 :
2614                       insn->tex.target.getDim() - 1);
2615    emitField(0x1c, 1, insn->tex.target.isArray());
2616    emitTEXs (0x14);
2617    emitGPR  (0x08, insn->src(0));
2618    emitGPR  (0x00, insn->def(0));
2619 }
2620
2621 void
2622 CodeEmitterGM107::emitTMML()
2623 {
2624    const TexInstruction *insn = this->insn->asTex();
2625
2626    if (insn->tex.rIndirectSrc >= 0) {
2627       emitInsn (0xdf600000);
2628    } else {
2629       emitInsn (0xdf580000);
2630       emitField(0x24, 13, insn->tex.r);
2631    }
2632
2633    emitField(0x31, 1, insn->tex.liveOnly);
2634    emitField(0x23, 1, insn->tex.derivAll);
2635    emitField(0x1f, 4, insn->tex.mask);
2636    emitField(0x1d, 2, insn->tex.target.isCube() ? 3 :
2637                       insn->tex.target.getDim() - 1);
2638    emitField(0x1c, 1, insn->tex.target.isArray());
2639    emitTEXs (0x14);
2640    emitGPR  (0x08, insn->src(0));
2641    emitGPR  (0x00, insn->def(0));
2642 }
2643
2644 void
2645 CodeEmitterGM107::emitTXQ()
2646 {
2647    const TexInstruction *insn = this->insn->asTex();
2648    int type = 0;
2649
2650    switch (insn->tex.query) {
2651    case TXQ_DIMS           : type = 0x01; break;
2652    case TXQ_TYPE           : type = 0x02; break;
2653    case TXQ_SAMPLE_POSITION: type = 0x05; break;
2654    case TXQ_FILTER         : type = 0x10; break;
2655    case TXQ_LOD            : type = 0x12; break;
2656    case TXQ_WRAP           : type = 0x14; break;
2657    case TXQ_BORDER_COLOUR  : type = 0x16; break;
2658    default:
2659       assert(!"invalid txq query");
2660       break;
2661    }
2662
2663    if (insn->tex.rIndirectSrc >= 0) {
2664       emitInsn (0xdf500000);
2665    } else {
2666       emitInsn (0xdf480000);
2667       emitField(0x24, 13, insn->tex.r);
2668    }
2669
2670    emitField(0x31, 1, insn->tex.liveOnly);
2671    emitField(0x1f, 4, insn->tex.mask);
2672    emitField(0x16, 6, type);
2673    emitGPR  (0x08, insn->src(0));
2674    emitGPR  (0x00, insn->def(0));
2675 }
2676
2677 void
2678 CodeEmitterGM107::emitDEPBAR()
2679 {
2680    emitInsn (0xf0f00000);
2681    emitField(0x1d, 1, 1); /* le */
2682    emitField(0x1a, 3, 5);
2683    emitField(0x14, 6, insn->subOp);
2684    emitField(0x00, 6, insn->subOp);
2685 }
2686
2687 /*******************************************************************************
2688  * misc
2689  ******************************************************************************/
2690
2691 void
2692 CodeEmitterGM107::emitNOP()
2693 {
2694    emitInsn(0x50b00000);
2695 }
2696
2697 void
2698 CodeEmitterGM107::emitKIL()
2699 {
2700    emitInsn (0xe3300000);
2701    emitCond5(0x00, CC_TR);
2702 }
2703
2704 void
2705 CodeEmitterGM107::emitOUT()
2706 {
2707    const int cut  = insn->op == OP_RESTART || insn->subOp;
2708    const int emit = insn->op == OP_EMIT;
2709
2710    switch (insn->src(1).getFile()) {
2711    case FILE_GPR:
2712       emitInsn(0xfbe00000);
2713       emitGPR (0x14, insn->src(1));
2714       break;
2715    case FILE_IMMEDIATE:
2716       emitInsn(0xf6e00000);
2717       emitIMMD(0x14, 19, insn->src(1));
2718       break;
2719    case FILE_MEMORY_CONST:
2720       emitInsn(0xebe00000);
2721       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
2722       break;
2723    default:
2724       assert(!"bad src1 file");
2725       break;
2726    }
2727
2728    emitField(0x27, 2, (cut << 1) | emit);
2729    emitGPR  (0x08, insn->src(0));
2730    emitGPR  (0x00, insn->def(0));
2731 }
2732
2733 void
2734 CodeEmitterGM107::emitBAR()
2735 {
2736    uint8_t subop;
2737
2738    emitInsn (0xf0a80000);
2739
2740    switch (insn->subOp) {
2741    case NV50_IR_SUBOP_BAR_RED_POPC: subop = 0x02; break;
2742    case NV50_IR_SUBOP_BAR_RED_AND:  subop = 0x0a; break;
2743    case NV50_IR_SUBOP_BAR_RED_OR:   subop = 0x12; break;
2744    case NV50_IR_SUBOP_BAR_ARRIVE:   subop = 0x81; break;
2745    default:
2746       subop = 0x80;
2747       assert(insn->subOp == NV50_IR_SUBOP_BAR_SYNC);
2748       break;
2749    }
2750
2751    emitField(0x20, 8, subop);
2752
2753    // barrier id
2754    if (insn->src(0).getFile() == FILE_GPR) {
2755       emitGPR(0x08, insn->src(0));
2756    } else {
2757       ImmediateValue *imm = insn->getSrc(0)->asImm();
2758       assert(imm);
2759       emitField(0x08, 8, imm->reg.data.u32);
2760       emitField(0x2b, 1, 1);
2761    }
2762
2763    // thread count
2764    if (insn->src(1).getFile() == FILE_GPR) {
2765       emitGPR(0x14, insn->src(1));
2766    } else {
2767       ImmediateValue *imm = insn->getSrc(0)->asImm();
2768       assert(imm);
2769       emitField(0x14, 12, imm->reg.data.u32);
2770       emitField(0x2c, 1, 1);
2771    }
2772
2773    if (insn->srcExists(2) && (insn->predSrc != 2)) {
2774       emitPRED (0x27, insn->src(2));
2775       emitField(0x2a, 1, insn->src(2).mod == Modifier(NV50_IR_MOD_NOT));
2776    } else {
2777       emitField(0x27, 3, 7);
2778    }
2779 }
2780
2781 void
2782 CodeEmitterGM107::emitMEMBAR()
2783 {
2784    emitInsn (0xef980000);
2785    emitField(0x08, 2, insn->subOp >> 2);
2786 }
2787
2788 void
2789 CodeEmitterGM107::emitVOTE()
2790 {
2791    int subOp;
2792
2793    assert(insn->src(0).getFile() == FILE_PREDICATE &&
2794           insn->def(1).getFile() == FILE_PREDICATE);
2795
2796    switch (insn->subOp) {
2797    case NV50_IR_SUBOP_VOTE_ANY: subOp = 1; break;
2798    default:
2799       assert(insn->subOp == NV50_IR_SUBOP_VOTE_ALL);
2800       subOp = 0;
2801       break;
2802    }
2803
2804    emitInsn (0x50d80000);
2805    emitField(0x30, 2, subOp);
2806    emitGPR  (0x00, insn->def(0));
2807    emitPRED (0x2d, insn->def(1));
2808    emitField(0x2a, 1, insn->src(0).mod == Modifier(NV50_IR_MOD_NOT));
2809    emitPRED (0x27, insn->src(0));
2810 }
2811
2812 /*******************************************************************************
2813  * assembler front-end
2814  ******************************************************************************/
2815
2816 bool
2817 CodeEmitterGM107::emitInstruction(Instruction *i)
2818 {
2819    const unsigned int size = (writeIssueDelays && !(codeSize & 0x1f)) ? 16 : 8;
2820    bool ret = true;
2821
2822    insn = i;
2823
2824    if (insn->encSize != 8) {
2825       ERROR("skipping undecodable instruction: "); insn->print();
2826       return false;
2827    } else
2828    if (codeSize + size > codeSizeLimit) {
2829       ERROR("code emitter output buffer too small\n");
2830       return false;
2831    }
2832
2833    if (writeIssueDelays) {
2834       int n = ((codeSize & 0x1f) / 8) - 1;
2835       if (n < 0) {
2836          data = code;
2837          data[0] = 0x00000000;
2838          data[1] = 0x00000000;
2839          code += 2;
2840          codeSize += 8;
2841          n++;
2842       }
2843
2844       emitField(data, n * 21, 21, insn->sched);
2845    }
2846
2847    switch (insn->op) {
2848    case OP_EXIT:
2849       emitEXIT();
2850       break;
2851    case OP_BRA:
2852       emitBRA();
2853       break;
2854    case OP_CALL:
2855       emitCAL();
2856       break;
2857    case OP_PRECONT:
2858       emitPCNT();
2859       break;
2860    case OP_CONT:
2861       emitCONT();
2862       break;
2863    case OP_PREBREAK:
2864       emitPBK();
2865       break;
2866    case OP_BREAK:
2867       emitBRK();
2868       break;
2869    case OP_PRERET:
2870       emitPRET();
2871       break;
2872    case OP_RET:
2873       emitRET();
2874       break;
2875    case OP_JOINAT:
2876       emitSSY();
2877       break;
2878    case OP_JOIN:
2879       emitSYNC();
2880       break;
2881    case OP_QUADON:
2882       emitSAM();
2883       break;
2884    case OP_QUADPOP:
2885       emitRAM();
2886       break;
2887    case OP_MOV:
2888       emitMOV();
2889       break;
2890    case OP_RDSV:
2891       emitS2R();
2892       break;
2893    case OP_ABS:
2894    case OP_NEG:
2895    case OP_SAT:
2896    case OP_FLOOR:
2897    case OP_CEIL:
2898    case OP_TRUNC:
2899    case OP_CVT:
2900       if (insn->op == OP_CVT && (insn->def(0).getFile() == FILE_PREDICATE ||
2901                                  insn->src(0).getFile() == FILE_PREDICATE)) {
2902          emitMOV();
2903       } else if (isFloatType(insn->dType)) {
2904          if (isFloatType(insn->sType))
2905             emitF2F();
2906          else
2907             emitI2F();
2908       } else {
2909          if (isFloatType(insn->sType))
2910             emitF2I();
2911          else
2912             emitI2I();
2913       }
2914       break;
2915    case OP_SHFL:
2916       emitSHFL();
2917       break;
2918    case OP_ADD:
2919    case OP_SUB:
2920       if (isFloatType(insn->dType)) {
2921          if (insn->dType == TYPE_F64)
2922             emitDADD();
2923          else
2924             emitFADD();
2925       } else {
2926          emitIADD();
2927       }
2928       break;
2929    case OP_MUL:
2930       if (isFloatType(insn->dType)) {
2931          if (insn->dType == TYPE_F64)
2932             emitDMUL();
2933          else
2934             emitFMUL();
2935       } else {
2936          emitIMUL();
2937       }
2938       break;
2939    case OP_MAD:
2940    case OP_FMA:
2941       if (isFloatType(insn->dType)) {
2942          if (insn->dType == TYPE_F64)
2943             emitDFMA();
2944          else
2945             emitFFMA();
2946       } else {
2947          emitIMAD();
2948       }
2949       break;
2950    case OP_MIN:
2951    case OP_MAX:
2952       if (isFloatType(insn->dType)) {
2953          if (insn->dType == TYPE_F64)
2954             emitDMNMX();
2955          else
2956             emitFMNMX();
2957       } else {
2958          emitIMNMX();
2959       }
2960       break;
2961    case OP_SHL:
2962       emitSHL();
2963       break;
2964    case OP_SHR:
2965       emitSHR();
2966       break;
2967    case OP_POPCNT:
2968       emitPOPC();
2969       break;
2970    case OP_INSBF:
2971       emitBFI();
2972       break;
2973    case OP_EXTBF:
2974       emitBFE();
2975       break;
2976    case OP_BFIND:
2977       emitFLO();
2978       break;
2979    case OP_SLCT:
2980       if (isFloatType(insn->dType))
2981          emitFCMP();
2982       else
2983          emitICMP();
2984       break;
2985    case OP_SET:
2986    case OP_SET_AND:
2987    case OP_SET_OR:
2988    case OP_SET_XOR:
2989       if (insn->def(0).getFile() != FILE_PREDICATE) {
2990          if (isFloatType(insn->sType))
2991             if (insn->sType == TYPE_F64)
2992                emitDSET();
2993             else
2994                emitFSET();
2995          else
2996             emitISET();
2997       } else {
2998          if (isFloatType(insn->sType))
2999             if (insn->sType == TYPE_F64)
3000                emitDSETP();
3001             else
3002                emitFSETP();
3003          else
3004             emitISETP();
3005       }
3006       break;
3007    case OP_SELP:
3008       emitSEL();
3009       break;
3010    case OP_PRESIN:
3011    case OP_PREEX2:
3012       emitRRO();
3013       break;
3014    case OP_COS:
3015    case OP_SIN:
3016    case OP_EX2:
3017    case OP_LG2:
3018    case OP_RCP:
3019    case OP_RSQ:
3020       emitMUFU();
3021       break;
3022    case OP_AND:
3023    case OP_OR:
3024    case OP_XOR:
3025       emitLOP();
3026       break;
3027    case OP_NOT:
3028       emitNOT();
3029       break;
3030    case OP_LOAD:
3031       switch (insn->src(0).getFile()) {
3032       case FILE_MEMORY_CONST : emitLDC(); break;
3033       case FILE_MEMORY_LOCAL : emitLDL(); break;
3034       case FILE_MEMORY_SHARED: emitLDS(); break;
3035       case FILE_MEMORY_GLOBAL: emitLD(); break;
3036       default:
3037          assert(!"invalid load");
3038          emitNOP();
3039          break;
3040       }
3041       break;
3042    case OP_STORE:
3043       switch (insn->src(0).getFile()) {
3044       case FILE_MEMORY_LOCAL : emitSTL(); break;
3045       case FILE_MEMORY_SHARED: emitSTS(); break;
3046       case FILE_MEMORY_GLOBAL: emitST(); break;
3047       default:
3048          assert(!"invalid store");
3049          emitNOP();
3050          break;
3051       }
3052       break;
3053    case OP_ATOM:
3054       if (insn->src(0).getFile() == FILE_MEMORY_SHARED)
3055          emitATOMS();
3056       else
3057          emitATOM();
3058       break;
3059    case OP_CCTL:
3060       emitCCTL();
3061       break;
3062    case OP_VFETCH:
3063       emitALD();
3064       break;
3065    case OP_EXPORT:
3066       emitAST();
3067       break;
3068    case OP_PFETCH:
3069       emitISBERD();
3070       break;
3071    case OP_AFETCH:
3072       emitAL2P();
3073       break;
3074    case OP_LINTERP:
3075    case OP_PINTERP:
3076       emitIPA();
3077       break;
3078    case OP_PIXLD:
3079       emitPIXLD();
3080       break;
3081    case OP_TEX:
3082    case OP_TXB:
3083    case OP_TXL:
3084       emitTEX();
3085       break;
3086    case OP_TXF:
3087       emitTLD();
3088       break;
3089    case OP_TXG:
3090       emitTLD4();
3091       break;
3092    case OP_TXD:
3093       emitTXD();
3094       break;
3095    case OP_TXQ:
3096       emitTXQ();
3097       break;
3098    case OP_TXLQ:
3099       emitTMML();
3100       break;
3101    case OP_TEXBAR:
3102       emitDEPBAR();
3103       break;
3104    case OP_QUADOP:
3105       emitFSWZADD();
3106       break;
3107    case OP_NOP:
3108       emitNOP();
3109       break;
3110    case OP_DISCARD:
3111       emitKIL();
3112       break;
3113    case OP_EMIT:
3114    case OP_RESTART:
3115       emitOUT();
3116       break;
3117    case OP_BAR:
3118       emitBAR();
3119       break;
3120    case OP_MEMBAR:
3121       emitMEMBAR();
3122       break;
3123    case OP_VOTE:
3124       emitVOTE();
3125       break;
3126    default:
3127       assert(!"invalid opcode");
3128       emitNOP();
3129       ret = false;
3130       break;
3131    }
3132
3133    if (insn->join) {
3134       /*XXX*/
3135    }
3136
3137    code += 2;
3138    codeSize += 8;
3139    return ret;
3140 }
3141
3142 uint32_t
3143 CodeEmitterGM107::getMinEncodingSize(const Instruction *i) const
3144 {
3145    return 8;
3146 }
3147
3148 /*******************************************************************************
3149  * sched data calculator
3150  ******************************************************************************/
3151
3152 class SchedDataCalculatorGM107 : public Pass
3153 {
3154 public:
3155    SchedDataCalculatorGM107(const Target *targ) : targ(targ) {}
3156 private:
3157    const Target *targ;
3158    bool visit(BasicBlock *bb);
3159 };
3160
3161 bool
3162 SchedDataCalculatorGM107::visit(BasicBlock *bb)
3163 {
3164    for (Instruction *insn = bb->getEntry(); insn; insn = insn->next) {
3165       /*XXX*/
3166       insn->sched = 0x7e0;
3167    }
3168
3169    return true;
3170 }
3171
3172 /*******************************************************************************
3173  * main
3174  ******************************************************************************/
3175
3176 void
3177 CodeEmitterGM107::prepareEmission(Function *func)
3178 {
3179    SchedDataCalculatorGM107 sched(targ);
3180    CodeEmitter::prepareEmission(func);
3181    sched.run(func, true, true);
3182 }
3183
3184 static inline uint32_t sizeToBundlesGM107(uint32_t size)
3185 {
3186    return (size + 23) / 24;
3187 }
3188
3189 void
3190 CodeEmitterGM107::prepareEmission(Program *prog)
3191 {
3192    for (ArrayList::Iterator fi = prog->allFuncs.iterator();
3193         !fi.end(); fi.next()) {
3194       Function *func = reinterpret_cast<Function *>(fi.get());
3195       func->binPos = prog->binSize;
3196       prepareEmission(func);
3197
3198       // adjust sizes & positions for schedulding info:
3199       if (prog->getTarget()->hasSWSched) {
3200          uint32_t adjPos = func->binPos;
3201          BasicBlock *bb = NULL;
3202          for (int i = 0; i < func->bbCount; ++i) {
3203             bb = func->bbArray[i];
3204             int32_t adjSize = bb->binSize;
3205             if (adjPos % 32) {
3206                adjSize -= 32 - adjPos % 32;
3207                if (adjSize < 0)
3208                   adjSize = 0;
3209             }
3210             adjSize = bb->binSize + sizeToBundlesGM107(adjSize) * 8;
3211             bb->binPos = adjPos;
3212             bb->binSize = adjSize;
3213             adjPos += adjSize;
3214          }
3215          if (bb)
3216             func->binSize = adjPos - func->binPos;
3217       }
3218
3219       prog->binSize += func->binSize;
3220    }
3221 }
3222
3223 CodeEmitterGM107::CodeEmitterGM107(const TargetGM107 *target)
3224    : CodeEmitter(target),
3225      targGM107(target),
3226      writeIssueDelays(target->hasSWSched)
3227 {
3228    code = NULL;
3229    codeSize = codeSizeLimit = 0;
3230    relocInfo = NULL;
3231 }
3232
3233 CodeEmitter *
3234 TargetGM107::createCodeEmitterGM107(Program::Type type)
3235 {
3236    CodeEmitterGM107 *emit = new CodeEmitterGM107(this);
3237    emit->setProgramType(type);
3238    return emit;
3239 }
3240
3241 } // namespace nv50_ir