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->flagsDef >= 0);
 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       switch (insn->src(0).getFile()) {
 683       case FILE_GPR:
 684          if (insn->def(0).getFile() == FILE_PREDICATE) {
 685             emitInsn(0x5b6a0000);
 686             emitGPR (0x08);
 687          } else {
 688             emitInsn(0x5c980000);
 689          }
 690          emitGPR (0x14, insn->src(0));
 691          break;
 692       case FILE_MEMORY_CONST:
 693          emitInsn(0x4c980000);
 694          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
 695          break;
 696       case FILE_IMMEDIATE:
 697          emitInsn(0x38980000);
 698          emitIMMD(0x14, 19, insn->src(0));
 699          break;
 700       case FILE_PREDICATE:
 701          emitInsn(0x50880000);
 702          emitPRED(0x0c, insn->src(0));
 703          emitPRED(0x1d);
 704          emitPRED(0x27);
 705          break;
 706       default:
 707          assert(!"bad src file");
 708          break;
 709       }
 710       if (insn->def(0).getFile() != FILE_PREDICATE &&
 711           insn->src(0).getFile() != FILE_PREDICATE)
 712          emitField(0x27, 4, insn->lanes);
 713    } else {
 714       emitInsn (0x01000000);
 715       emitIMMD (0x14, 32, insn->src(0));
 716       emitField(0x0c, 4, insn->lanes);
 717    }
 718
 719    if (insn->def(0).getFile() == FILE_PREDICATE) {
 720       emitPRED(0x27);
 721       emitPRED(0x03, insn->def(0));
 722       emitPRED(0x00);
 723    } else {
 724       emitGPR(0x00, insn->def(0));
 725    }
 726 }
 727
 728 void
 729 CodeEmitterGM107::emitS2R()
 730 {
 731    emitInsn(0xf0c80000);
 732    emitSYS (0x14, insn->src(0));
 733    emitGPR (0x00, insn->def(0));
 734 }
 735
 736 void
 737 CodeEmitterGM107::emitF2F()
 738 {
 739    RoundMode rnd = insn->rnd;
 740
 741    switch (insn->op) {
 742    case OP_FLOOR: rnd = ROUND_MI; break;
 743    case OP_CEIL : rnd = ROUND_PI; break;
 744    case OP_TRUNC: rnd = ROUND_ZI; break;
 745    default:
 746       break;
 747    }
 748
 749    switch (insn->src(0).getFile()) {
 750    case FILE_GPR:
 751       emitInsn(0x5ca80000);
 752       emitGPR (0x14, insn->src(0));
 753       break;
 754    case FILE_MEMORY_CONST:
 755       emitInsn(0x4ca80000);
 756       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
 757       break;
 758    case FILE_IMMEDIATE:
 759       emitInsn(0x38a80000);
 760       emitIMMD(0x14, 19, insn->src(0));
 761       break;
 762    default:
 763       assert(!"bad src0 file");
 764       break;
 765    }
 766
 767    emitField(0x32, 1, (insn->op == OP_SAT) || insn->saturate);
 768    emitField(0x31, 1, (insn->op == OP_ABS) || insn->src(0).mod.abs());
 769    emitCC   (0x2f);
 770    emitField(0x2d, 1, (insn->op == OP_NEG) || insn->src(0).mod.neg());
 771    emitFMZ  (0x2c, 1);
 772    emitField(0x29, 1, insn->subOp);
 773    emitRND  (0x27, rnd, 0x2a);
 774    emitField(0x0a, 2, util_logbase2(typeSizeof(insn->sType)));
 775    emitField(0x08, 2, util_logbase2(typeSizeof(insn->dType)));
 776    emitGPR  (0x00, insn->def(0));
 777 }
 778
 779 void
 780 CodeEmitterGM107::emitF2I()
 781 {
 782    RoundMode rnd = insn->rnd;
 783
 784    switch (insn->op) {
 785    case OP_FLOOR: rnd = ROUND_M; break;
 786    case OP_CEIL : rnd = ROUND_P; break;
 787    case OP_TRUNC: rnd = ROUND_Z; break;
 788    default:
 789       break;
 790    }
 791
 792    switch (insn->src(0).getFile()) {
 793    case FILE_GPR:
 794       emitInsn(0x5cb00000);
 795       emitGPR (0x14, insn->src(0));
 796       break;
 797    case FILE_MEMORY_CONST:
 798       emitInsn(0x4cb00000);
 799       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
 800       break;
 801    case FILE_IMMEDIATE:
 802       emitInsn(0x38b00000);
 803       emitIMMD(0x14, 19, insn->src(0));
 804       break;
 805    default:
 806       assert(!"bad src0 file");
 807       break;
 808    }
 809
 810    emitField(0x31, 1, (insn->op == OP_ABS) || insn->src(0).mod.abs());
 811    emitCC   (0x2f);
 812    emitField(0x2d, 1, (insn->op == OP_NEG) || insn->src(0).mod.neg());
 813    emitFMZ  (0x2c, 1);
 814    emitRND  (0x27, rnd, 0x2a);
 815    emitField(0x0c, 1, isSignedType(insn->dType));
 816    emitField(0x0a, 2, util_logbase2(typeSizeof(insn->sType)));
 817    emitField(0x08, 2, util_logbase2(typeSizeof(insn->dType)));
 818    emitGPR  (0x00, insn->def(0));
 819 }
 820
 821 void
 822 CodeEmitterGM107::emitI2F()
 823 {
 824    RoundMode rnd = insn->rnd;
 825
 826    switch (insn->op) {
 827    case OP_FLOOR: rnd = ROUND_M; break;
 828    case OP_CEIL : rnd = ROUND_P; break;
 829    case OP_TRUNC: rnd = ROUND_Z; break;
 830    default:
 831       break;
 832    }
 833
 834    switch (insn->src(0).getFile()) {
 835    case FILE_GPR:
 836       emitInsn(0x5cb80000);
 837       emitGPR (0x14, insn->src(0));
 838       break;
 839    case FILE_MEMORY_CONST:
 840       emitInsn(0x4cb80000);
 841       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
 842       break;
 843    case FILE_IMMEDIATE:
 844       emitInsn(0x38b80000);
 845       emitIMMD(0x14, 19, insn->src(0));
 846       break;
 847    default:
 848       assert(!"bad src0 file");
 849       break;
 850    }
 851
 852    emitField(0x31, 1, (insn->op == OP_ABS) || insn->src(0).mod.abs());
 853    emitCC   (0x2f);
 854    emitField(0x2d, 1, (insn->op == OP_NEG) || insn->src(0).mod.neg());
 855    emitField(0x29, 2, insn->subOp);
 856    emitRND  (0x27, rnd, -1);
 857    emitField(0x0d, 1, isSignedType(insn->sType));
 858    emitField(0x0a, 2, util_logbase2(typeSizeof(insn->sType)));
 859    emitField(0x08, 2, util_logbase2(typeSizeof(insn->dType)));
 860    emitGPR  (0x00, insn->def(0));
 861 }
 862
 863 void
 864 CodeEmitterGM107::emitI2I()
 865 {
 866    switch (insn->src(0).getFile()) {
 867    case FILE_GPR:
 868       emitInsn(0x5ce00000);
 869       emitGPR (0x14, insn->src(0));
 870       break;
 871    case FILE_MEMORY_CONST:
 872       emitInsn(0x4ce00000);
 873       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
 874       break;
 875    case FILE_IMMEDIATE:
 876       emitInsn(0x38e00000);
 877       emitIMMD(0x14, 19, insn->src(0));
 878       break;
 879    default:
 880       assert(!"bad src0 file");
 881       break;
 882    }
 883
 884    emitSAT  (0x32);
 885    emitField(0x31, 1, (insn->op == OP_ABS) || insn->src(0).mod.abs());
 886    emitCC   (0x2f);
 887    emitField(0x2d, 1, (insn->op == OP_NEG) || insn->src(0).mod.neg());
 888    emitField(0x29, 2, insn->subOp);
 889    emitField(0x0d, 1, isSignedType(insn->sType));
 890    emitField(0x0c, 1, isSignedType(insn->dType));
 891    emitField(0x0a, 2, util_logbase2(typeSizeof(insn->sType)));
 892    emitField(0x08, 2, util_logbase2(typeSizeof(insn->dType)));
 893    emitGPR  (0x00, insn->def(0));
 894 }
 895
 896 static void
 897 selpFlip(const FixupEntry *entry, uint32_t *code, const FixupData& data)
 898 {
 899    int loc = entry->loc;
 900    if (data.force_persample_interp)
 901       code[loc + 1] |= 1 << 10;
 902    else
 903       code[loc + 1] &= ~(1 << 10);
 904 }
 905
 906 void
 907 CodeEmitterGM107::emitSEL()
 908 {
 909    switch (insn->src(1).getFile()) {
 910    case FILE_GPR:
 911       emitInsn(0x5ca00000);
 912       emitGPR (0x14, insn->src(1));
 913       break;
 914    case FILE_MEMORY_CONST:
 915       emitInsn(0x4ca00000);
 916       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
 917       break;
 918    case FILE_IMMEDIATE:
 919       emitInsn(0x38a00000);
 920       emitIMMD(0x14, 19, insn->src(1));
 921       break;
 922    default:
 923       assert(!"bad src1 file");
 924       break;
 925    }
 926
 927    emitINV (0x2a, insn->src(2));
 928    emitPRED(0x27, insn->src(2));
 929    emitGPR (0x08, insn->src(0));
 930    emitGPR (0x00, insn->def(0));
 931
 932    if (insn->subOp == 1) {
 933       addInterp(0, 0, selpFlip);
 934    }
 935 }
 936
 937 void
 938 CodeEmitterGM107::emitSHFL()
 939 {
 940    int type = 0;
 941
 942    emitInsn (0xef100000);
 943
 944    switch (insn->src(1).getFile()) {
 945    case FILE_GPR:
 946       emitGPR(0x14, insn->src(1));
 947       break;
 948    case FILE_IMMEDIATE:
 949       emitIMMD(0x14, 5, insn->src(1));
 950       type |= 1;
 951       break;
 952    default:
 953       assert(!"invalid src1 file");
 954       break;
 955    }
 956
 957    /*XXX: what is this arg? hardcode immediate for now */
 958    emitField(0x22, 13, 0x1c03);
 959    type |= 2;
 960
 961    emitPRED (0x30);
 962    emitField(0x1e, 2, insn->subOp);
 963    emitField(0x1c, 2, type);
 964    emitGPR  (0x08, insn->src(0));
 965    emitGPR  (0x00, insn->def(0));
 966 }
 967
 968 /*******************************************************************************
 969  * double
 970  ******************************************************************************/
 971
 972 void
 973 CodeEmitterGM107::emitDADD()
 974 {
 975    switch (insn->src(1).getFile()) {
 976    case FILE_GPR:
 977       emitInsn(0x5c700000);
 978       emitGPR (0x14, insn->src(1));
 979       break;
 980    case FILE_MEMORY_CONST:
 981       emitInsn(0x4c700000);
 982       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
 983       break;
 984    case FILE_IMMEDIATE:
 985       emitInsn(0x38700000);
 986       emitIMMD(0x14, 19, insn->src(1));
 987       break;
 988    default:
 989       assert(!"bad src1 file");
 990       break;
 991    }
 992    emitABS(0x31, insn->src(1));
 993    emitNEG(0x30, insn->src(0));
 994    emitCC (0x2f);
 995    emitABS(0x2e, insn->src(0));
 996    emitNEG(0x2d, insn->src(1));
 997
 998    if (insn->op == OP_SUB)
 999       code[1] ^= 0x00002000;
1000
1001    emitGPR(0x08, insn->src(0));
1002    emitGPR(0x00, insn->def(0));
1003 }
1004
1005 void
1006 CodeEmitterGM107::emitDMUL()
1007 {
1008    switch (insn->src(1).getFile()) {
1009    case FILE_GPR:
1010       emitInsn(0x5c800000);
1011       emitGPR (0x14, insn->src(1));
1012       break;
1013    case FILE_MEMORY_CONST:
1014       emitInsn(0x4c800000);
1015       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1016       break;
1017    case FILE_IMMEDIATE:
1018       emitInsn(0x38800000);
1019       emitIMMD(0x14, 19, insn->src(1));
1020       break;
1021    default:
1022       assert(!"bad src1 file");
1023       break;
1024    }
1025
1026    emitNEG2(0x30, insn->src(0), insn->src(1));
1027    emitCC  (0x2f);
1028    emitRND (0x27);
1029    emitGPR (0x08, insn->src(0));
1030    emitGPR (0x00, insn->def(0));
1031 }
1032
1033 void
1034 CodeEmitterGM107::emitDFMA()
1035 {
1036    switch(insn->src(2).getFile()) {
1037    case FILE_GPR:
1038       switch (insn->src(1).getFile()) {
1039       case FILE_GPR:
1040          emitInsn(0x5b700000);
1041          emitGPR (0x14, insn->src(1));
1042          break;
1043       case FILE_MEMORY_CONST:
1044          emitInsn(0x4b700000);
1045          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1046          break;
1047       case FILE_IMMEDIATE:
1048          emitInsn(0x36700000);
1049          emitIMMD(0x14, 19, insn->src(1));
1050          break;
1051       default:
1052          assert(!"bad src1 file");
1053          break;
1054       }
1055       emitGPR (0x27, insn->src(2));
1056       break;
1057    case FILE_MEMORY_CONST:
1058       emitInsn(0x53700000);
1059       emitGPR (0x27, insn->src(1));
1060       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(2));
1061       break;
1062    default:
1063       assert(!"bad src2 file");
1064       break;
1065    }
1066
1067    emitRND (0x32);
1068    emitNEG (0x31, insn->src(2));
1069    emitNEG2(0x30, insn->src(0), insn->src(1));
1070    emitCC  (0x2f);
1071    emitGPR (0x08, insn->src(0));
1072    emitGPR (0x00, insn->def(0));
1073 }
1074
1075 void
1076 CodeEmitterGM107::emitDMNMX()
1077 {
1078    switch (insn->src(1).getFile()) {
1079    case FILE_GPR:
1080       emitInsn(0x5c500000);
1081       emitGPR (0x14, insn->src(1));
1082       break;
1083    case FILE_MEMORY_CONST:
1084       emitInsn(0x4c500000);
1085       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1086       break;
1087    case FILE_IMMEDIATE:
1088       emitInsn(0x38500000);
1089       emitIMMD(0x14, 19, insn->src(1));
1090       break;
1091    default:
1092       assert(!"bad src1 file");
1093       break;
1094    }
1095
1096    emitABS  (0x31, insn->src(1));
1097    emitNEG  (0x30, insn->src(0));
1098    emitCC   (0x2f);
1099    emitABS  (0x2e, insn->src(0));
1100    emitNEG  (0x2d, insn->src(1));
1101    emitField(0x2a, 1, insn->op == OP_MAX);
1102    emitPRED (0x27);
1103    emitGPR  (0x08, insn->src(0));
1104    emitGPR  (0x00, insn->def(0));
1105 }
1106
1107 void
1108 CodeEmitterGM107::emitDSET()
1109 {
1110    const CmpInstruction *insn = this->insn->asCmp();
1111
1112    switch (insn->src(1).getFile()) {
1113    case FILE_GPR:
1114       emitInsn(0x59000000);
1115       emitGPR (0x14, insn->src(1));
1116       break;
1117    case FILE_MEMORY_CONST:
1118       emitInsn(0x49000000);
1119       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1120       break;
1121    case FILE_IMMEDIATE:
1122       emitInsn(0x32000000);
1123       emitIMMD(0x14, 19, insn->src(1));
1124       break;
1125    default:
1126       assert(!"bad src1 file");
1127       break;
1128    }
1129
1130    if (insn->op != OP_SET) {
1131       switch (insn->op) {
1132       case OP_SET_AND: emitField(0x2d, 2, 0); break;
1133       case OP_SET_OR : emitField(0x2d, 2, 1); break;
1134       case OP_SET_XOR: emitField(0x2d, 2, 2); break;
1135       default:
1136          assert(!"invalid set op");
1137          break;
1138       }
1139       emitPRED(0x27, insn->src(2));
1140    } else {
1141       emitPRED(0x27);
1142    }
1143
1144    emitABS  (0x36, insn->src(0));
1145    emitNEG  (0x35, insn->src(1));
1146    emitField(0x34, 1, insn->dType == TYPE_F32);
1147    emitCond4(0x30, insn->setCond);
1148    emitCC   (0x2f);
1149    emitABS  (0x2c, insn->src(1));
1150    emitNEG  (0x2b, insn->src(0));
1151    emitGPR  (0x08, insn->src(0));
1152    emitGPR  (0x00, insn->def(0));
1153 }
1154
1155 void
1156 CodeEmitterGM107::emitDSETP()
1157 {
1158    const CmpInstruction *insn = this->insn->asCmp();
1159
1160    switch (insn->src(1).getFile()) {
1161    case FILE_GPR:
1162       emitInsn(0x5b800000);
1163       emitGPR (0x14, insn->src(1));
1164       break;
1165    case FILE_MEMORY_CONST:
1166       emitInsn(0x4b800000);
1167       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1168       break;
1169    case FILE_IMMEDIATE:
1170       emitInsn(0x36800000);
1171       emitIMMD(0x14, 19, insn->src(1));
1172       break;
1173    default:
1174       assert(!"bad src1 file");
1175       break;
1176    }
1177
1178    if (insn->op != OP_SET) {
1179       switch (insn->op) {
1180       case OP_SET_AND: emitField(0x2d, 2, 0); break;
1181       case OP_SET_OR : emitField(0x2d, 2, 1); break;
1182       case OP_SET_XOR: emitField(0x2d, 2, 2); break;
1183       default:
1184          assert(!"invalid set op");
1185          break;
1186       }
1187       emitPRED(0x27, insn->src(2));
1188    } else {
1189       emitPRED(0x27);
1190    }
1191
1192    emitCond4(0x30, insn->setCond);
1193    emitABS  (0x2c, insn->src(1));
1194    emitNEG  (0x2b, insn->src(0));
1195    emitGPR  (0x08, insn->src(0));
1196    emitABS  (0x07, insn->src(0));
1197    emitNEG  (0x06, insn->src(1));
1198    emitPRED (0x03, insn->def(0));
1199    if (insn->defExists(1))
1200       emitPRED(0x00, insn->def(1));
1201    else
1202       emitPRED(0x00);
1203 }
1204
1205 /*******************************************************************************
1206  * float
1207  ******************************************************************************/
1208
1209 void
1210 CodeEmitterGM107::emitFADD()
1211 {
1212    if (!longIMMD(insn->src(1))) {
1213       switch (insn->src(1).getFile()) {
1214       case FILE_GPR:
1215          emitInsn(0x5c580000);
1216          emitGPR (0x14, insn->src(1));
1217          break;
1218       case FILE_MEMORY_CONST:
1219          emitInsn(0x4c580000);
1220          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1221          break;
1222       case FILE_IMMEDIATE:
1223          emitInsn(0x38580000);
1224          emitIMMD(0x14, 19, insn->src(1));
1225          break;
1226       default:
1227          assert(!"bad src1 file");
1228          break;
1229       }
1230       emitSAT(0x32);
1231       emitABS(0x31, insn->src(1));
1232       emitNEG(0x30, insn->src(0));
1233       emitCC (0x2f);
1234       emitABS(0x2e, insn->src(0));
1235       emitNEG(0x2d, insn->src(1));
1236       emitFMZ(0x2c, 1);
1237
1238       if (insn->op == OP_SUB)
1239          code[1] ^= 0x00002000;
1240    } else {
1241       emitInsn(0x08000000);
1242       emitABS(0x39, insn->src(1));
1243       emitNEG(0x38, insn->src(0));
1244       emitFMZ(0x37, 1);
1245       emitABS(0x36, insn->src(0));
1246       emitNEG(0x35, insn->src(1));
1247       emitCC  (0x34);
1248       emitIMMD(0x14, 32, insn->src(1));
1249
1250       if (insn->op == OP_SUB)
1251          code[1] ^= 0x00080000;
1252    }
1253
1254    emitGPR(0x08, insn->src(0));
1255    emitGPR(0x00, insn->def(0));
1256 }
1257
1258 void
1259 CodeEmitterGM107::emitFMUL()
1260 {
1261    if (!longIMMD(insn->src(1))) {
1262       switch (insn->src(1).getFile()) {
1263       case FILE_GPR:
1264          emitInsn(0x5c680000);
1265          emitGPR (0x14, insn->src(1));
1266          break;
1267       case FILE_MEMORY_CONST:
1268          emitInsn(0x4c680000);
1269          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1270          break;
1271       case FILE_IMMEDIATE:
1272          emitInsn(0x38680000);
1273          emitIMMD(0x14, 19, insn->src(1));
1274          break;
1275       default:
1276          assert(!"bad src1 file");
1277          break;
1278       }
1279       emitSAT (0x32);
1280       emitNEG2(0x30, insn->src(0), insn->src(1));
1281       emitCC  (0x2f);
1282       emitFMZ (0x2c, 2);
1283       emitPDIV(0x29);
1284       emitRND (0x27);
1285    } else {
1286       emitInsn(0x1e000000);
1287       emitSAT (0x37);
1288       emitFMZ (0x35, 2);
1289       emitCC  (0x34);
1290       emitIMMD(0x14, 32, insn->src(1));
1291       if (insn->src(0).mod.neg() ^ insn->src(1).mod.neg())
1292          code[1] ^= 0x00080000; /* flip immd sign bit */
1293    }
1294
1295    emitGPR(0x08, insn->src(0));
1296    emitGPR(0x00, insn->def(0));
1297 }
1298
1299 void
1300 CodeEmitterGM107::emitFFMA()
1301 {
1302    /*XXX: ffma32i exists, but not using it as third src overlaps dst */
1303    switch(insn->src(2).getFile()) {
1304    case FILE_GPR:
1305       switch (insn->src(1).getFile()) {
1306       case FILE_GPR:
1307          emitInsn(0x59800000);
1308          emitGPR (0x14, insn->src(1));
1309          break;
1310       case FILE_MEMORY_CONST:
1311          emitInsn(0x49800000);
1312          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1313          break;
1314       case FILE_IMMEDIATE:
1315          emitInsn(0x32800000);
1316          emitIMMD(0x14, 19, insn->src(1));
1317          break;
1318       default:
1319          assert(!"bad src1 file");
1320          break;
1321       }
1322       emitGPR (0x27, insn->src(2));
1323       break;
1324    case FILE_MEMORY_CONST:
1325       emitInsn(0x51800000);
1326       emitGPR (0x27, insn->src(1));
1327       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(2));
1328       break;
1329    default:
1330       assert(!"bad src2 file");
1331       break;
1332    }
1333    emitRND (0x33);
1334    emitSAT (0x32);
1335    emitNEG (0x31, insn->src(2));
1336    emitNEG2(0x30, insn->src(0), insn->src(1));
1337    emitCC  (0x2f);
1338
1339    emitFMZ(0x35, 2);
1340    emitGPR(0x08, insn->src(0));
1341    emitGPR(0x00, insn->def(0));
1342 }
1343
1344 void
1345 CodeEmitterGM107::emitMUFU()
1346 {
1347    int mufu = 0;
1348
1349    switch (insn->op) {
1350    case OP_COS: mufu = 0; break;
1351    case OP_SIN: mufu = 1; break;
1352    case OP_EX2: mufu = 2; break;
1353    case OP_LG2: mufu = 3; break;
1354    case OP_RCP: mufu = 4 + 2 * insn->subOp; break;
1355    case OP_RSQ: mufu = 5 + 2 * insn->subOp; break;
1356    default:
1357       assert(!"invalid mufu");
1358       break;
1359    }
1360
1361    emitInsn (0x50800000);
1362    emitSAT  (0x32);
1363    emitNEG  (0x30, insn->src(0));
1364    emitABS  (0x2e, insn->src(0));
1365    emitField(0x14, 3, mufu);
1366    emitGPR  (0x08, insn->src(0));
1367    emitGPR  (0x00, insn->def(0));
1368 }
1369
1370 void
1371 CodeEmitterGM107::emitFMNMX()
1372 {
1373    switch (insn->src(1).getFile()) {
1374    case FILE_GPR:
1375       emitInsn(0x5c600000);
1376       emitGPR (0x14, insn->src(1));
1377       break;
1378    case FILE_MEMORY_CONST:
1379       emitInsn(0x4c600000);
1380       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1381       break;
1382    case FILE_IMMEDIATE:
1383       emitInsn(0x38600000);
1384       emitIMMD(0x14, 19, insn->src(1));
1385       break;
1386    default:
1387       assert(!"bad src1 file");
1388       break;
1389    }
1390
1391    emitField(0x2a, 1, insn->op == OP_MAX);
1392    emitPRED (0x27);
1393
1394    emitABS(0x31, insn->src(1));
1395    emitNEG(0x30, insn->src(0));
1396    emitCC (0x2f);
1397    emitABS(0x2e, insn->src(0));
1398    emitNEG(0x2d, insn->src(1));
1399    emitFMZ(0x2c, 1);
1400    emitGPR(0x08, insn->src(0));
1401    emitGPR(0x00, insn->def(0));
1402 }
1403
1404 void
1405 CodeEmitterGM107::emitRRO()
1406 {
1407    switch (insn->src(0).getFile()) {
1408    case FILE_GPR:
1409       emitInsn(0x5c900000);
1410       emitGPR (0x14, insn->src(0));
1411       break;
1412    case FILE_MEMORY_CONST:
1413       emitInsn(0x4c900000);
1414       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
1415       break;
1416    case FILE_IMMEDIATE:
1417       emitInsn(0x38900000);
1418       emitIMMD(0x14, 19, insn->src(0));
1419       break;
1420    default:
1421       assert(!"bad src file");
1422       break;
1423    }
1424
1425    emitABS  (0x31, insn->src(0));
1426    emitNEG  (0x2d, insn->src(0));
1427    emitField(0x27, 1, insn->op == OP_PREEX2);
1428    emitGPR  (0x00, insn->def(0));
1429 }
1430
1431 void
1432 CodeEmitterGM107::emitFCMP()
1433 {
1434    const CmpInstruction *insn = this->insn->asCmp();
1435    CondCode cc = insn->setCond;
1436
1437    if (insn->src(2).mod.neg())
1438       cc = reverseCondCode(cc);
1439
1440    switch(insn->src(2).getFile()) {
1441    case FILE_GPR:
1442       switch (insn->src(1).getFile()) {
1443       case FILE_GPR:
1444          emitInsn(0x5ba00000);
1445          emitGPR (0x14, insn->src(1));
1446          break;
1447       case FILE_MEMORY_CONST:
1448          emitInsn(0x4ba00000);
1449          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1450          break;
1451       case FILE_IMMEDIATE:
1452          emitInsn(0x36a00000);
1453          emitIMMD(0x14, 19, insn->src(1));
1454          break;
1455       default:
1456          assert(!"bad src1 file");
1457          break;
1458       }
1459       emitGPR (0x27, insn->src(2));
1460       break;
1461    case FILE_MEMORY_CONST:
1462       emitInsn(0x53a00000);
1463       emitGPR (0x27, insn->src(1));
1464       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(2));
1465       break;
1466    default:
1467       assert(!"bad src2 file");
1468       break;
1469    }
1470
1471    emitCond4(0x30, cc);
1472    emitFMZ  (0x2f, 1);
1473    emitGPR  (0x08, insn->src(0));
1474    emitGPR  (0x00, insn->def(0));
1475 }
1476
1477 void
1478 CodeEmitterGM107::emitFSET()
1479 {
1480    const CmpInstruction *insn = this->insn->asCmp();
1481
1482    switch (insn->src(1).getFile()) {
1483    case FILE_GPR:
1484       emitInsn(0x58000000);
1485       emitGPR (0x14, insn->src(1));
1486       break;
1487    case FILE_MEMORY_CONST:
1488       emitInsn(0x48000000);
1489       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1490       break;
1491    case FILE_IMMEDIATE:
1492       emitInsn(0x30000000);
1493       emitIMMD(0x14, 19, insn->src(1));
1494       break;
1495    default:
1496       assert(!"bad src1 file");
1497       break;
1498    }
1499
1500    if (insn->op != OP_SET) {
1501       switch (insn->op) {
1502       case OP_SET_AND: emitField(0x2d, 2, 0); break;
1503       case OP_SET_OR : emitField(0x2d, 2, 1); break;
1504       case OP_SET_XOR: emitField(0x2d, 2, 2); break;
1505       default:
1506          assert(!"invalid set op");
1507          break;
1508       }
1509       emitPRED(0x27, insn->src(2));
1510    } else {
1511       emitPRED(0x27);
1512    }
1513
1514    emitFMZ  (0x37, 1);
1515    emitABS  (0x36, insn->src(0));
1516    emitNEG  (0x35, insn->src(1));
1517    emitField(0x34, 1, insn->dType == TYPE_F32);
1518    emitCond4(0x30, insn->setCond);
1519    emitCC   (0x2f);
1520    emitABS  (0x2c, insn->src(1));
1521    emitNEG  (0x2b, insn->src(0));
1522    emitGPR  (0x08, insn->src(0));
1523    emitGPR  (0x00, insn->def(0));
1524 }
1525
1526 void
1527 CodeEmitterGM107::emitFSETP()
1528 {
1529    const CmpInstruction *insn = this->insn->asCmp();
1530
1531    switch (insn->src(1).getFile()) {
1532    case FILE_GPR:
1533       emitInsn(0x5bb00000);
1534       emitGPR (0x14, insn->src(1));
1535       break;
1536    case FILE_MEMORY_CONST:
1537       emitInsn(0x4bb00000);
1538       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1539       break;
1540    case FILE_IMMEDIATE:
1541       emitInsn(0x36b00000);
1542       emitIMMD(0x14, 19, insn->src(1));
1543       break;
1544    default:
1545       assert(!"bad src1 file");
1546       break;
1547    }
1548
1549    if (insn->op != OP_SET) {
1550       switch (insn->op) {
1551       case OP_SET_AND: emitField(0x2d, 2, 0); break;
1552       case OP_SET_OR : emitField(0x2d, 2, 1); break;
1553       case OP_SET_XOR: emitField(0x2d, 2, 2); break;
1554       default:
1555          assert(!"invalid set op");
1556          break;
1557       }
1558       emitPRED(0x27, insn->src(2));
1559    } else {
1560       emitPRED(0x27);
1561    }
1562
1563    emitCond4(0x30, insn->setCond);
1564    emitFMZ  (0x2f, 1);
1565    emitABS  (0x2c, insn->src(1));
1566    emitNEG  (0x2b, insn->src(0));
1567    emitGPR  (0x08, insn->src(0));
1568    emitABS  (0x07, insn->src(0));
1569    emitNEG  (0x06, insn->src(1));
1570    emitPRED (0x03, insn->def(0));
1571    if (insn->defExists(1))
1572       emitPRED(0x00, insn->def(1));
1573    else
1574       emitPRED(0x00);
1575 }
1576
1577 void
1578 CodeEmitterGM107::emitFSWZADD()
1579 {
1580    emitInsn (0x50f80000);
1581    emitCC   (0x2f);
1582    emitFMZ  (0x2c, 1);
1583    emitRND  (0x27);
1584    emitField(0x26, 1, insn->lanes); /* abused for .ndv */
1585    emitField(0x1c, 8, insn->subOp);
1586    if (insn->predSrc != 1)
1587       emitGPR  (0x14, insn->src(1));
1588    else
1589       emitGPR  (0x14);
1590    emitGPR  (0x08, insn->src(0));
1591    emitGPR  (0x00, insn->def(0));
1592 }
1593
1594 /*******************************************************************************
1595  * integer
1596  ******************************************************************************/
1597
1598 void
1599 CodeEmitterGM107::emitLOP()
1600 {
1601    int lop = 0;
1602
1603    switch (insn->op) {
1604    case OP_AND: lop = 0; break;
1605    case OP_OR : lop = 1; break;
1606    case OP_XOR: lop = 2; break;
1607    default:
1608       assert(!"invalid lop");
1609       break;
1610    }
1611
1612    if (insn->src(1).getFile() != FILE_IMMEDIATE) {
1613       switch (insn->src(1).getFile()) {
1614       case FILE_GPR:
1615          emitInsn(0x5c400000);
1616          emitGPR (0x14, insn->src(1));
1617          break;
1618       case FILE_MEMORY_CONST:
1619          emitInsn(0x4c400000);
1620          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1621          break;
1622       case FILE_IMMEDIATE:
1623          emitInsn(0x38400000);
1624          emitIMMD(0x14, 19, insn->src(1));
1625          break;
1626       default:
1627          assert(!"bad src1 file");
1628          break;
1629       }
1630       emitPRED (0x30);
1631       emitCC   (0x2f);
1632       emitX    (0x2b);
1633       emitField(0x29, 2, lop);
1634       emitINV  (0x28, insn->src(1));
1635       emitINV  (0x27, insn->src(0));
1636    } else {
1637       emitInsn (0x04000000);
1638       emitX    (0x39);
1639       emitINV  (0x38, insn->src(1));
1640       emitINV  (0x37, insn->src(0));
1641       emitField(0x35, 2, lop);
1642       emitCC   (0x34);
1643       emitIMMD (0x14, 32, insn->src(1));
1644    }
1645
1646    emitGPR  (0x08, insn->src(0));
1647    emitGPR  (0x00, insn->def(0));
1648 }
1649
1650 /* special-case of emitLOP(): lop pass_b dst 0 ~src */
1651 void
1652 CodeEmitterGM107::emitNOT()
1653 {
1654    if (!longIMMD(insn->src(0))) {
1655       switch (insn->src(0).getFile()) {
1656       case FILE_GPR:
1657          emitInsn(0x5c400700);
1658          emitGPR (0x14, insn->src(0));
1659          break;
1660       case FILE_MEMORY_CONST:
1661          emitInsn(0x4c400700);
1662          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
1663          break;
1664       case FILE_IMMEDIATE:
1665          emitInsn(0x38400700);
1666          emitIMMD(0x14, 19, insn->src(0));
1667          break;
1668       default:
1669          assert(!"bad src1 file");
1670          break;
1671       }
1672       emitPRED (0x30);
1673    } else {
1674       emitInsn (0x05600000);
1675       emitIMMD (0x14, 32, insn->src(1));
1676    }
1677
1678    emitGPR(0x08);
1679    emitGPR(0x00, insn->def(0));
1680 }
1681
1682 void
1683 CodeEmitterGM107::emitIADD()
1684 {
1685    if (!longIMMD(insn->src(1))) {
1686       switch (insn->src(1).getFile()) {
1687       case FILE_GPR:
1688          emitInsn(0x5c100000);
1689          emitGPR (0x14, insn->src(1));
1690          break;
1691       case FILE_MEMORY_CONST:
1692          emitInsn(0x4c100000);
1693          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1694          break;
1695       case FILE_IMMEDIATE:
1696          emitInsn(0x38100000);
1697          emitIMMD(0x14, 19, insn->src(1));
1698          break;
1699       default:
1700          assert(!"bad src1 file");
1701          break;
1702       }
1703       emitSAT(0x32);
1704       emitNEG(0x31, insn->src(0));
1705       emitNEG(0x30, insn->src(1));
1706       emitCC (0x2f);
1707       emitX  (0x2b);
1708    } else {
1709       emitInsn(0x1c000000);
1710       emitSAT (0x36);
1711       emitX   (0x35);
1712       emitCC  (0x34);
1713       emitIMMD(0x14, 32, insn->src(1));
1714    }
1715
1716    if (insn->op == OP_SUB)
1717       code[1] ^= 0x00010000;
1718
1719    emitGPR(0x08, insn->src(0));
1720    emitGPR(0x00, insn->def(0));
1721 }
1722
1723 void
1724 CodeEmitterGM107::emitIMUL()
1725 {
1726    if (insn->src(1).getFile() != FILE_IMMEDIATE) {
1727       switch (insn->src(1).getFile()) {
1728       case FILE_GPR:
1729          emitInsn(0x5c380000);
1730          emitGPR (0x14, insn->src(1));
1731          break;
1732       case FILE_MEMORY_CONST:
1733          emitInsn(0x4c380000);
1734          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1735          break;
1736       case FILE_IMMEDIATE:
1737          emitInsn(0x38380000);
1738          emitIMMD(0x14, 19, insn->src(1));
1739          break;
1740       default:
1741          assert(!"bad src1 file");
1742          break;
1743       }
1744       emitCC   (0x2f);
1745       emitField(0x29, 1, isSignedType(insn->sType));
1746       emitField(0x28, 1, isSignedType(insn->dType));
1747       emitField(0x27, 1, insn->subOp == NV50_IR_SUBOP_MUL_HIGH);
1748    } else {
1749       emitInsn (0x1f000000);
1750       emitField(0x37, 1, isSignedType(insn->sType));
1751       emitField(0x36, 1, isSignedType(insn->dType));
1752       emitField(0x35, 1, insn->subOp == NV50_IR_SUBOP_MUL_HIGH);
1753       emitCC   (0x34);
1754       emitIMMD (0x14, 32, insn->src(1));
1755    }
1756
1757    emitGPR(0x08, insn->src(0));
1758    emitGPR(0x00, insn->def(0));
1759 }
1760
1761 void
1762 CodeEmitterGM107::emitIMAD()
1763 {
1764    /*XXX: imad32i exists, but not using it as third src overlaps dst */
1765    switch(insn->src(2).getFile()) {
1766    case FILE_GPR:
1767       switch (insn->src(1).getFile()) {
1768       case FILE_GPR:
1769          emitInsn(0x5a000000);
1770          emitGPR (0x14, insn->src(1));
1771          break;
1772       case FILE_MEMORY_CONST:
1773          emitInsn(0x4a000000);
1774          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1775          break;
1776       case FILE_IMMEDIATE:
1777          emitInsn(0x34000000);
1778          emitIMMD(0x14, 19, insn->src(1));
1779          break;
1780       default:
1781          assert(!"bad src1 file");
1782          break;
1783       }
1784       emitGPR (0x27, insn->src(2));
1785       break;
1786    case FILE_MEMORY_CONST:
1787       emitInsn(0x52000000);
1788       emitGPR (0x27, insn->src(1));
1789       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(2));
1790       break;
1791    default:
1792       assert(!"bad src2 file");
1793       break;
1794    }
1795
1796    emitField(0x36, 1, insn->subOp == NV50_IR_SUBOP_MUL_HIGH);
1797    emitField(0x35, 1, isSignedType(insn->sType));
1798    emitNEG  (0x34, insn->src(2));
1799    emitNEG2 (0x33, insn->src(0), insn->src(1));
1800    emitSAT  (0x32);
1801    emitX    (0x31);
1802    emitField(0x30, 1, isSignedType(insn->dType));
1803    emitCC   (0x2f);
1804    emitGPR  (0x08, insn->src(0));
1805    emitGPR  (0x00, insn->def(0));
1806 }
1807
1808 void
1809 CodeEmitterGM107::emitIMNMX()
1810 {
1811    switch (insn->src(1).getFile()) {
1812    case FILE_GPR:
1813       emitInsn(0x5c200000);
1814       emitGPR (0x14, insn->src(1));
1815       break;
1816    case FILE_MEMORY_CONST:
1817       emitInsn(0x4c200000);
1818       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1819       break;
1820    case FILE_IMMEDIATE:
1821       emitInsn(0x38200000);
1822       emitIMMD(0x14, 19, insn->src(1));
1823       break;
1824    default:
1825       assert(!"bad src1 file");
1826       break;
1827    }
1828
1829    emitField(0x30, 1, isSignedType(insn->dType));
1830    emitCC   (0x2f);
1831    emitField(0x2a, 1, insn->op == OP_MAX);
1832    emitPRED (0x27);
1833    emitGPR  (0x08, insn->src(0));
1834    emitGPR  (0x00, insn->def(0));
1835 }
1836
1837 void
1838 CodeEmitterGM107::emitICMP()
1839 {
1840    const CmpInstruction *insn = this->insn->asCmp();
1841    CondCode cc = insn->setCond;
1842
1843    if (insn->src(2).mod.neg())
1844       cc = reverseCondCode(cc);
1845
1846    switch(insn->src(2).getFile()) {
1847    case FILE_GPR:
1848       switch (insn->src(1).getFile()) {
1849       case FILE_GPR:
1850          emitInsn(0x5b400000);
1851          emitGPR (0x14, insn->src(1));
1852          break;
1853       case FILE_MEMORY_CONST:
1854          emitInsn(0x4b400000);
1855          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1856          break;
1857       case FILE_IMMEDIATE:
1858          emitInsn(0x36400000);
1859          emitIMMD(0x14, 19, insn->src(1));
1860          break;
1861       default:
1862          assert(!"bad src1 file");
1863          break;
1864       }
1865       emitGPR (0x27, insn->src(2));
1866       break;
1867    case FILE_MEMORY_CONST:
1868       emitInsn(0x53400000);
1869       emitGPR (0x27, insn->src(1));
1870       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(2));
1871       break;
1872    default:
1873       assert(!"bad src2 file");
1874       break;
1875    }
1876
1877    emitCond3(0x31, cc);
1878    emitField(0x30, 1, isSignedType(insn->sType));
1879    emitGPR  (0x08, insn->src(0));
1880    emitGPR  (0x00, insn->def(0));
1881 }
1882
1883 void
1884 CodeEmitterGM107::emitISET()
1885 {
1886    const CmpInstruction *insn = this->insn->asCmp();
1887
1888    switch (insn->src(1).getFile()) {
1889    case FILE_GPR:
1890       emitInsn(0x5b500000);
1891       emitGPR (0x14, insn->src(1));
1892       break;
1893    case FILE_MEMORY_CONST:
1894       emitInsn(0x4b500000);
1895       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1896       break;
1897    case FILE_IMMEDIATE:
1898       emitInsn(0x36500000);
1899       emitIMMD(0x14, 19, insn->src(1));
1900       break;
1901    default:
1902       assert(!"bad src1 file");
1903       break;
1904    }
1905
1906    if (insn->op != OP_SET) {
1907       switch (insn->op) {
1908       case OP_SET_AND: emitField(0x2d, 2, 0); break;
1909       case OP_SET_OR : emitField(0x2d, 2, 1); break;
1910       case OP_SET_XOR: emitField(0x2d, 2, 2); break;
1911       default:
1912          assert(!"invalid set op");
1913          break;
1914       }
1915       emitPRED(0x27, insn->src(2));
1916    } else {
1917       emitPRED(0x27);
1918    }
1919
1920    emitCond3(0x31, insn->setCond);
1921    emitField(0x30, 1, isSignedType(insn->sType));
1922    emitCC   (0x2f);
1923    emitField(0x2c, 1, insn->dType == TYPE_F32);
1924    emitX    (0x2b);
1925    emitGPR  (0x08, insn->src(0));
1926    emitGPR  (0x00, insn->def(0));
1927 }
1928
1929 void
1930 CodeEmitterGM107::emitISETP()
1931 {
1932    const CmpInstruction *insn = this->insn->asCmp();
1933
1934    switch (insn->src(1).getFile()) {
1935    case FILE_GPR:
1936       emitInsn(0x5b600000);
1937       emitGPR (0x14, insn->src(1));
1938       break;
1939    case FILE_MEMORY_CONST:
1940       emitInsn(0x4b600000);
1941       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1942       break;
1943    case FILE_IMMEDIATE:
1944       emitInsn(0x36600000);
1945       emitIMMD(0x14, 19, insn->src(1));
1946       break;
1947    default:
1948       assert(!"bad src1 file");
1949       break;
1950    }
1951
1952    if (insn->op != OP_SET) {
1953       switch (insn->op) {
1954       case OP_SET_AND: emitField(0x2d, 2, 0); break;
1955       case OP_SET_OR : emitField(0x2d, 2, 1); break;
1956       case OP_SET_XOR: emitField(0x2d, 2, 2); break;
1957       default:
1958          assert(!"invalid set op");
1959          break;
1960       }
1961       emitPRED(0x27, insn->src(2));
1962    } else {
1963       emitPRED(0x27);
1964    }
1965
1966    emitCond3(0x31, insn->setCond);
1967    emitField(0x30, 1, isSignedType(insn->sType));
1968    emitX    (0x2b);
1969    emitGPR  (0x08, insn->src(0));
1970    emitPRED (0x03, insn->def(0));
1971    if (insn->defExists(1))
1972       emitPRED(0x00, insn->def(1));
1973    else
1974       emitPRED(0x00);
1975 }
1976
1977 void
1978 CodeEmitterGM107::emitSHL()
1979 {
1980    switch (insn->src(1).getFile()) {
1981    case FILE_GPR:
1982       emitInsn(0x5c480000);
1983       emitGPR (0x14, insn->src(1));
1984       break;
1985    case FILE_MEMORY_CONST:
1986       emitInsn(0x4c480000);
1987       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
1988       break;
1989    case FILE_IMMEDIATE:
1990       emitInsn(0x38480000);
1991       emitIMMD(0x14, 19, insn->src(1));
1992       break;
1993    default:
1994       assert(!"bad src1 file");
1995       break;
1996    }
1997
1998    emitCC   (0x2f);
1999    emitX    (0x2b);
2000    emitField(0x27, 1, insn->subOp == NV50_IR_SUBOP_SHIFT_WRAP);
2001    emitGPR  (0x08, insn->src(0));
2002    emitGPR  (0x00, insn->def(0));
2003 }
2004
2005 void
2006 CodeEmitterGM107::emitSHR()
2007 {
2008    switch (insn->src(1).getFile()) {
2009    case FILE_GPR:
2010       emitInsn(0x5c280000);
2011       emitGPR (0x14, insn->src(1));
2012       break;
2013    case FILE_MEMORY_CONST:
2014       emitInsn(0x4c280000);
2015       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
2016       break;
2017    case FILE_IMMEDIATE:
2018       emitInsn(0x38280000);
2019       emitIMMD(0x14, 19, insn->src(1));
2020       break;
2021    default:
2022       assert(!"bad src1 file");
2023       break;
2024    }
2025
2026    emitField(0x30, 1, isSignedType(insn->dType));
2027    emitCC   (0x2f);
2028    emitX    (0x2c);
2029    emitField(0x27, 1, insn->subOp == NV50_IR_SUBOP_SHIFT_WRAP);
2030    emitGPR  (0x08, insn->src(0));
2031    emitGPR  (0x00, insn->def(0));
2032 }
2033
2034 void
2035 CodeEmitterGM107::emitPOPC()
2036 {
2037    switch (insn->src(0).getFile()) {
2038    case FILE_GPR:
2039       emitInsn(0x5c080000);
2040       emitGPR (0x14, insn->src(0));
2041       break;
2042    case FILE_MEMORY_CONST:
2043       emitInsn(0x4c080000);
2044       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
2045       break;
2046    case FILE_IMMEDIATE:
2047       emitInsn(0x38080000);
2048       emitIMMD(0x14, 19, insn->src(0));
2049       break;
2050    default:
2051       assert(!"bad src1 file");
2052       break;
2053    }
2054
2055    emitINV(0x28, insn->src(0));
2056    emitGPR(0x00, insn->def(0));
2057 }
2058
2059 void
2060 CodeEmitterGM107::emitBFI()
2061 {
2062    switch(insn->src(2).getFile()) {
2063    case FILE_GPR:
2064       switch (insn->src(1).getFile()) {
2065       case FILE_GPR:
2066          emitInsn(0x5bf00000);
2067          emitGPR (0x14, insn->src(1));
2068          break;
2069       case FILE_MEMORY_CONST:
2070          emitInsn(0x4bf00000);
2071          emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
2072          break;
2073       case FILE_IMMEDIATE:
2074          emitInsn(0x36f00000);
2075          emitIMMD(0x14, 19, insn->src(1));
2076          break;
2077       default:
2078          assert(!"bad src1 file");
2079          break;
2080       }
2081       emitGPR (0x27, insn->src(2));
2082       break;
2083    case FILE_MEMORY_CONST:
2084       emitInsn(0x53f00000);
2085       emitGPR (0x27, insn->src(1));
2086       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(2));
2087       break;
2088    default:
2089       assert(!"bad src2 file");
2090       break;
2091    }
2092
2093    emitCC   (0x2f);
2094    emitGPR  (0x08, insn->src(0));
2095    emitGPR  (0x00, insn->def(0));
2096 }
2097
2098 void
2099 CodeEmitterGM107::emitBFE()
2100 {
2101    switch (insn->src(1).getFile()) {
2102    case FILE_GPR:
2103       emitInsn(0x5c000000);
2104       emitGPR (0x14, insn->src(1));
2105       break;
2106    case FILE_MEMORY_CONST:
2107       emitInsn(0x4c000000);
2108       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
2109       break;
2110    case FILE_IMMEDIATE:
2111       emitInsn(0x38000000);
2112       emitIMMD(0x14, 19, insn->src(1));
2113       break;
2114    default:
2115       assert(!"bad src1 file");
2116       break;
2117    }
2118
2119    emitField(0x30, 1, isSignedType(insn->dType));
2120    emitCC   (0x2f);
2121    emitField(0x28, 1, insn->subOp == NV50_IR_SUBOP_EXTBF_REV);
2122    emitGPR  (0x08, insn->src(0));
2123    emitGPR  (0x00, insn->def(0));
2124 }
2125
2126 void
2127 CodeEmitterGM107::emitFLO()
2128 {
2129    switch (insn->src(0).getFile()) {
2130    case FILE_GPR:
2131       emitInsn(0x5c300000);
2132       emitGPR (0x14, insn->src(0));
2133       break;
2134    case FILE_MEMORY_CONST:
2135       emitInsn(0x4c300000);
2136       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(0));
2137       break;
2138    case FILE_IMMEDIATE:
2139       emitInsn(0x38300000);
2140       emitIMMD(0x14, 19, insn->src(0));
2141       break;
2142    default:
2143       assert(!"bad src1 file");
2144       break;
2145    }
2146
2147    emitField(0x30, 1, isSignedType(insn->dType));
2148    emitCC   (0x2f);
2149    emitField(0x29, 1, insn->subOp == NV50_IR_SUBOP_BFIND_SAMT);
2150    emitINV  (0x28, insn->src(0));
2151    emitGPR  (0x00, insn->def(0));
2152 }
2153
2154 /*******************************************************************************
2155  * memory
2156  ******************************************************************************/
2157
2158 void
2159 CodeEmitterGM107::emitLDSTs(int pos, DataType type)
2160 {
2161    int data = 0;
2162
2163    switch (typeSizeof(type)) {
2164    case  1: data = isSignedType(type) ? 1 : 0; break;
2165    case  2: data = isSignedType(type) ? 3 : 2; break;
2166    case  4: data = 4; break;
2167    case  8: data = 5; break;
2168    case 16: data = 6; break;
2169    default:
2170       assert(!"bad type");
2171       break;
2172    }
2173
2174    emitField(pos, 3, data);
2175 }
2176
2177 void
2178 CodeEmitterGM107::emitLDSTc(int pos)
2179 {
2180    int mode = 0;
2181
2182    switch (insn->cache) {
2183    case CACHE_CA: mode = 0; break;
2184    case CACHE_CG: mode = 1; break;
2185    case CACHE_CS: mode = 2; break;
2186    case CACHE_CV: mode = 3; break;
2187    default:
2188       assert(!"invalid caching mode");
2189       break;
2190    }
2191
2192    emitField(pos, 2, mode);
2193 }
2194
2195 void
2196 CodeEmitterGM107::emitLDC()
2197 {
2198    emitInsn (0xef900000);
2199    emitLDSTs(0x30, insn->dType);
2200    emitField(0x2c, 2, insn->subOp);
2201    emitCBUF (0x24, 0x08, 0x14, 16, 0, insn->src(0));
2202    emitGPR  (0x00, insn->def(0));
2203 }
2204
2205 void
2206 CodeEmitterGM107::emitLDL()
2207 {
2208    emitInsn (0xef400000);
2209    emitLDSTs(0x30, insn->dType);
2210    emitLDSTc(0x2c);
2211    emitADDR (0x08, 0x14, 24, 0, insn->src(0));
2212    emitGPR  (0x00, insn->def(0));
2213 }
2214
2215 void
2216 CodeEmitterGM107::emitLDS()
2217 {
2218    emitInsn (0xef480000);
2219    emitLDSTs(0x30, insn->dType);
2220    emitADDR (0x08, 0x14, 24, 0, insn->src(0));
2221    emitGPR  (0x00, insn->def(0));
2222 }
2223
2224 void
2225 CodeEmitterGM107::emitLD()
2226 {
2227    emitInsn (0x80000000);
2228    emitPRED (0x3a);
2229    emitLDSTc(0x38);
2230    emitLDSTs(0x35, insn->dType);
2231    emitField(0x34, 1, insn->src(0).getIndirect(0)->getSize() == 8);
2232    emitADDR (0x08, 0x14, 32, 0, insn->src(0));
2233    emitGPR  (0x00, insn->def(0));
2234 }
2235
2236 void
2237 CodeEmitterGM107::emitSTL()
2238 {
2239    emitInsn (0xef500000);
2240    emitLDSTs(0x30, insn->dType);
2241    emitLDSTc(0x2c);
2242    emitADDR (0x08, 0x14, 24, 0, insn->src(0));
2243    emitGPR  (0x00, insn->src(1));
2244 }
2245
2246 void
2247 CodeEmitterGM107::emitSTS()
2248 {
2249    emitInsn (0xef580000);
2250    emitLDSTs(0x30, insn->dType);
2251    emitADDR (0x08, 0x14, 24, 0, insn->src(0));
2252    emitGPR  (0x00, insn->src(1));
2253 }
2254
2255 void
2256 CodeEmitterGM107::emitST()
2257 {
2258    emitInsn (0xa0000000);
2259    emitPRED (0x3a);
2260    emitLDSTc(0x38);
2261    emitLDSTs(0x35, insn->dType);
2262    emitField(0x34, 1, insn->src(0).getIndirect(0)->getSize() == 8);
2263    emitADDR (0x08, 0x14, 32, 0, insn->src(0));
2264    emitGPR  (0x00, insn->src(1));
2265 }
2266
2267 void
2268 CodeEmitterGM107::emitALD()
2269 {
2270    emitInsn (0xefd80000);
2271    emitField(0x2f, 2, (insn->getDef(0)->reg.size / 4) - 1);
2272    emitGPR  (0x27, insn->src(0).getIndirect(1));
2273    emitO    (0x20);
2274    emitP    (0x1f);
2275    emitADDR (0x08, 20, 10, 0, insn->src(0));
2276    emitGPR  (0x00, insn->def(0));
2277 }
2278
2279 void
2280 CodeEmitterGM107::emitAST()
2281 {
2282    emitInsn (0xeff00000);
2283    emitField(0x2f, 2, (typeSizeof(insn->dType) / 4) - 1);
2284    emitGPR  (0x27, insn->src(0).getIndirect(1));
2285    emitP    (0x1f);
2286    emitADDR (0x08, 20, 10, 0, insn->src(0));
2287    emitGPR  (0x00, insn->src(1));
2288 }
2289
2290 void
2291 CodeEmitterGM107::emitISBERD()
2292 {
2293    emitInsn(0xefd00000);
2294    emitGPR (0x08, insn->src(0));
2295    emitGPR (0x00, insn->def(0));
2296 }
2297
2298 void
2299 CodeEmitterGM107::emitAL2P()
2300 {
2301    emitInsn (0xefa00000);
2302    emitField(0x2f, 2, (insn->getDef(0)->reg.size / 4) - 1);
2303    emitO    (0x20);
2304    emitField(0x14, 11, insn->src(0).get()->reg.data.offset);
2305    emitGPR  (0x08, insn->src(0).getIndirect(0));
2306    emitGPR  (0x00, insn->def(0));
2307 }
2308
2309 static void
2310 interpApply(const FixupEntry *entry, uint32_t *code, const FixupData& data)
2311 {
2312    int ipa = entry->ipa;
2313    int reg = entry->reg;
2314    int loc = entry->loc;
2315
2316    if (data.flatshade &&
2317        (ipa & NV50_IR_INTERP_MODE_MASK) == NV50_IR_INTERP_SC) {
2318       ipa = NV50_IR_INTERP_FLAT;
2319       reg = 0xff;
2320    } else if (data.force_persample_interp &&
2321               (ipa & NV50_IR_INTERP_SAMPLE_MASK) == NV50_IR_INTERP_DEFAULT &&
2322               (ipa & NV50_IR_INTERP_MODE_MASK) != NV50_IR_INTERP_FLAT) {
2323       ipa |= NV50_IR_INTERP_CENTROID;
2324    }
2325    code[loc + 1] &= ~(0xf << 0x14);
2326    code[loc + 1] |= (ipa & 0x3) << 0x16;
2327    code[loc + 1] |= (ipa & 0xc) << (0x14 - 2);
2328    code[loc + 0] &= ~(0xff << 0x14);
2329    code[loc + 0] |= reg << 0x14;
2330 }
2331
2332 void
2333 CodeEmitterGM107::emitIPA()
2334 {
2335    int ipam = 0, ipas = 0;
2336
2337    switch (insn->getInterpMode()) {
2338    case NV50_IR_INTERP_LINEAR     : ipam = 0; break;
2339    case NV50_IR_INTERP_PERSPECTIVE: ipam = 1; break;
2340    case NV50_IR_INTERP_FLAT       : ipam = 2; break;
2341    case NV50_IR_INTERP_SC         : ipam = 3; break;
2342    default:
2343       assert(!"invalid ipa mode");
2344       break;
2345    }
2346
2347    switch (insn->getSampleMode()) {
2348    case NV50_IR_INTERP_DEFAULT : ipas = 0; break;
2349    case NV50_IR_INTERP_CENTROID: ipas = 1; break;
2350    case NV50_IR_INTERP_OFFSET  : ipas = 2; break;
2351    default:
2352       assert(!"invalid ipa sample mode");
2353       break;
2354    }
2355
2356    emitInsn (0xe0000000);
2357    emitField(0x36, 2, ipam);
2358    emitField(0x34, 2, ipas);
2359    emitSAT  (0x33);
2360    emitField(0x2f, 3, 7);
2361    emitADDR (0x08, 0x1c, 10, 0, insn->src(0));
2362    if ((code[0] & 0x0000ff00) != 0x0000ff00)
2363       code[1] |= 0x00000040; /* .idx */
2364    emitGPR(0x00, insn->def(0));
2365
2366    if (insn->op == OP_PINTERP) {
2367       emitGPR(0x14, insn->src(1));
2368       if (insn->getSampleMode() == NV50_IR_INTERP_OFFSET)
2369          emitGPR(0x27, insn->src(2));
2370       addInterp(insn->ipa, insn->getSrc(1)->reg.data.id, interpApply);
2371    } else {
2372       if (insn->getSampleMode() == NV50_IR_INTERP_OFFSET)
2373          emitGPR(0x27, insn->src(1));
2374       emitGPR(0x14);
2375       addInterp(insn->ipa, 0xff, interpApply);
2376    }
2377
2378    if (insn->getSampleMode() != NV50_IR_INTERP_OFFSET)
2379       emitGPR(0x27);
2380 }
2381
2382 void
2383 CodeEmitterGM107::emitATOM()
2384 {
2385    unsigned dType, subOp;
2386
2387    if (insn->subOp == NV50_IR_SUBOP_ATOM_CAS) {
2388       switch (insn->dType) {
2389       case TYPE_U32: dType = 0; break;
2390       case TYPE_U64: dType = 1; break;
2391       default: assert(!"unexpected dType"); dType = 0; break;
2392       }
2393       subOp = 15;
2394
2395       emitInsn (0xee000000);
2396    } else {
2397       switch (insn->dType) {
2398       case TYPE_U32: dType = 0; break;
2399       case TYPE_S32: dType = 1; break;
2400       case TYPE_U64: dType = 2; break;
2401       case TYPE_F32: dType = 3; break;
2402       case TYPE_B128: dType = 4; break;
2403       case TYPE_S64: dType = 5; break;
2404       default: assert(!"unexpected dType"); dType = 0; break;
2405       }
2406       if (insn->subOp == NV50_IR_SUBOP_ATOM_EXCH)
2407          subOp = 8;
2408       else
2409          subOp = insn->subOp;
2410
2411       emitInsn (0xed000000);
2412    }
2413
2414    emitField(0x34, 4, subOp);
2415    emitField(0x31, 3, dType);
2416    emitField(0x30, 1, insn->src(0).getIndirect(0)->getSize() == 8);
2417    emitGPR  (0x14, insn->src(1));
2418    emitADDR (0x08, 0x1c, 20, 0, insn->src(0));
2419    emitGPR  (0x00, insn->def(0));
2420 }
2421
2422 void
2423 CodeEmitterGM107::emitATOMS()
2424 {
2425    unsigned dType, subOp;
2426
2427    if (insn->subOp == NV50_IR_SUBOP_ATOM_CAS) {
2428       switch (insn->dType) {
2429       case TYPE_U32: dType = 0; break;
2430       case TYPE_U64: dType = 1; break;
2431       default: assert(!"unexpected dType"); dType = 0; break;
2432       }
2433       subOp = 4;
2434
2435       emitInsn (0xee000000);
2436       emitField(0x34, 1, dType);
2437    } else {
2438       switch (insn->dType) {
2439       case TYPE_U32: dType = 0; break;
2440       case TYPE_S32: dType = 1; break;
2441       case TYPE_U64: dType = 2; break;
2442       case TYPE_S64: dType = 3; break;
2443       default: assert(!"unexpected dType"); dType = 0; break;
2444       }
2445
2446       if (insn->subOp == NV50_IR_SUBOP_ATOM_EXCH)
2447          subOp = 8;
2448       else
2449          subOp = insn->subOp;
2450
2451       emitInsn (0xec000000);
2452       emitField(0x1c, 3, dType);
2453    }
2454
2455    emitField(0x34, 4, subOp);
2456    emitGPR  (0x14, insn->src(1));
2457    emitADDR (0x08, 0x12, 22, 0, insn->src(0));
2458    emitGPR  (0x00, insn->def(0));
2459 }
2460
2461 void
2462 CodeEmitterGM107::emitCCTL()
2463 {
2464    unsigned width;
2465    if (insn->src(0).getFile() == FILE_MEMORY_GLOBAL) {
2466       emitInsn(0xef600000);
2467       width = 30;
2468    } else {
2469       emitInsn(0xef800000);
2470       width = 22;
2471    }
2472    emitField(0x34, 1, insn->src(0).getIndirect(0)->getSize() == 8);
2473    emitADDR (0x08, 0x16, width, 2, insn->src(0));
2474    emitField(0x00, 4, insn->subOp);
2475 }
2476
2477 /*******************************************************************************
2478  * surface
2479  ******************************************************************************/
2480
2481 void
2482 CodeEmitterGM107::emitPIXLD()
2483 {
2484    emitInsn (0xefe80000);
2485    emitPRED (0x2d);
2486    emitField(0x1f, 3, insn->subOp);
2487    emitGPR  (0x08, insn->src(0));
2488    emitGPR  (0x00, insn->def(0));
2489 }
2490
2491 /*******************************************************************************
2492  * texture
2493  ******************************************************************************/
2494
2495 void
2496 CodeEmitterGM107::emitTEXs(int pos)
2497 {
2498    int src1 = insn->predSrc == 1 ? 2 : 1;
2499    if (insn->srcExists(src1))
2500       emitGPR(pos, insn->src(src1));
2501    else
2502       emitGPR(pos);
2503 }
2504
2505 void
2506 CodeEmitterGM107::emitTEX()
2507 {
2508    const TexInstruction *insn = this->insn->asTex();
2509    int lodm = 0;
2510
2511    if (!insn->tex.levelZero) {
2512       switch (insn->op) {
2513       case OP_TEX: lodm = 0; break;
2514       case OP_TXB: lodm = 2; break;
2515       case OP_TXL: lodm = 3; break;
2516       default:
2517          assert(!"invalid tex op");
2518          break;
2519       }
2520    } else {
2521       lodm = 1;
2522    }
2523
2524    if (insn->tex.rIndirectSrc >= 0) {
2525       emitInsn (0xdeb80000);
2526       emitField(0x35, 2, lodm);
2527       emitField(0x24, 1, insn->tex.useOffsets == 1);
2528    } else {
2529       emitInsn (0xc0380000);
2530       emitField(0x37, 2, lodm);
2531       emitField(0x36, 1, insn->tex.useOffsets == 1);
2532       emitField(0x24, 13, insn->tex.r);
2533    }
2534
2535    emitField(0x32, 1, insn->tex.target.isShadow());
2536    emitField(0x31, 1, insn->tex.liveOnly);
2537    emitField(0x23, 1, insn->tex.derivAll);
2538    emitField(0x1f, 4, insn->tex.mask);
2539    emitField(0x1d, 2, insn->tex.target.isCube() ? 3 :
2540                       insn->tex.target.getDim() - 1);
2541    emitField(0x1c, 1, insn->tex.target.isArray());
2542    emitTEXs (0x14);
2543    emitGPR  (0x08, insn->src(0));
2544    emitGPR  (0x00, insn->def(0));
2545 }
2546
2547 void
2548 CodeEmitterGM107::emitTLD()
2549 {
2550    const TexInstruction *insn = this->insn->asTex();
2551
2552    if (insn->tex.rIndirectSrc >= 0) {
2553       emitInsn (0xdd380000);
2554    } else {
2555       emitInsn (0xdc380000);
2556       emitField(0x24, 13, insn->tex.r);
2557    }
2558
2559    emitField(0x37, 1, insn->tex.levelZero == 0);
2560    emitField(0x32, 1, insn->tex.target.isMS());
2561    emitField(0x31, 1, insn->tex.liveOnly);
2562    emitField(0x23, 1, insn->tex.useOffsets == 1);
2563    emitField(0x1f, 4, insn->tex.mask);
2564    emitField(0x1d, 2, insn->tex.target.isCube() ? 3 :
2565                       insn->tex.target.getDim() - 1);
2566    emitField(0x1c, 1, insn->tex.target.isArray());
2567    emitTEXs (0x14);
2568    emitGPR  (0x08, insn->src(0));
2569    emitGPR  (0x00, insn->def(0));
2570 }
2571
2572 void
2573 CodeEmitterGM107::emitTLD4()
2574 {
2575    const TexInstruction *insn = this->insn->asTex();
2576
2577    if (insn->tex.rIndirectSrc >= 0) {
2578       emitInsn (0xdef80000);
2579       emitField(0x26, 2, insn->tex.gatherComp);
2580       emitField(0x25, 2, insn->tex.useOffsets == 4);
2581       emitField(0x24, 2, insn->tex.useOffsets == 1);
2582    } else {
2583       emitInsn (0xc8380000);
2584       emitField(0x38, 2, insn->tex.gatherComp);
2585       emitField(0x37, 2, insn->tex.useOffsets == 4);
2586       emitField(0x36, 2, insn->tex.useOffsets == 1);
2587       emitField(0x24, 13, insn->tex.r);
2588    }
2589
2590    emitField(0x32, 1, insn->tex.target.isShadow());
2591    emitField(0x31, 1, insn->tex.liveOnly);
2592    emitField(0x23, 1, insn->tex.derivAll);
2593    emitField(0x1f, 4, insn->tex.mask);
2594    emitField(0x1d, 2, insn->tex.target.isCube() ? 3 :
2595                       insn->tex.target.getDim() - 1);
2596    emitField(0x1c, 1, insn->tex.target.isArray());
2597    emitTEXs (0x14);
2598    emitGPR  (0x08, insn->src(0));
2599    emitGPR  (0x00, insn->def(0));
2600 }
2601
2602 void
2603 CodeEmitterGM107::emitTXD()
2604 {
2605    const TexInstruction *insn = this->insn->asTex();
2606
2607    if (insn->tex.rIndirectSrc >= 0) {
2608       emitInsn (0xde780000);
2609    } else {
2610       emitInsn (0xde380000);
2611       emitField(0x24, 13, insn->tex.r);
2612    }
2613
2614    emitField(0x31, 1, insn->tex.liveOnly);
2615    emitField(0x23, 1, insn->tex.useOffsets == 1);
2616    emitField(0x1f, 4, insn->tex.mask);
2617    emitField(0x1d, 2, insn->tex.target.isCube() ? 3 :
2618                       insn->tex.target.getDim() - 1);
2619    emitField(0x1c, 1, insn->tex.target.isArray());
2620    emitTEXs (0x14);
2621    emitGPR  (0x08, insn->src(0));
2622    emitGPR  (0x00, insn->def(0));
2623 }
2624
2625 void
2626 CodeEmitterGM107::emitTMML()
2627 {
2628    const TexInstruction *insn = this->insn->asTex();
2629
2630    if (insn->tex.rIndirectSrc >= 0) {
2631       emitInsn (0xdf600000);
2632    } else {
2633       emitInsn (0xdf580000);
2634       emitField(0x24, 13, insn->tex.r);
2635    }
2636
2637    emitField(0x31, 1, insn->tex.liveOnly);
2638    emitField(0x23, 1, insn->tex.derivAll);
2639    emitField(0x1f, 4, insn->tex.mask);
2640    emitField(0x1d, 2, insn->tex.target.isCube() ? 3 :
2641                       insn->tex.target.getDim() - 1);
2642    emitField(0x1c, 1, insn->tex.target.isArray());
2643    emitTEXs (0x14);
2644    emitGPR  (0x08, insn->src(0));
2645    emitGPR  (0x00, insn->def(0));
2646 }
2647
2648 void
2649 CodeEmitterGM107::emitTXQ()
2650 {
2651    const TexInstruction *insn = this->insn->asTex();
2652    int type = 0;
2653
2654    switch (insn->tex.query) {
2655    case TXQ_DIMS           : type = 0x01; break;
2656    case TXQ_TYPE           : type = 0x02; break;
2657    case TXQ_SAMPLE_POSITION: type = 0x05; break;
2658    case TXQ_FILTER         : type = 0x10; break;
2659    case TXQ_LOD            : type = 0x12; break;
2660    case TXQ_WRAP           : type = 0x14; break;
2661    case TXQ_BORDER_COLOUR  : type = 0x16; break;
2662    default:
2663       assert(!"invalid txq query");
2664       break;
2665    }
2666
2667    if (insn->tex.rIndirectSrc >= 0) {
2668       emitInsn (0xdf500000);
2669    } else {
2670       emitInsn (0xdf480000);
2671       emitField(0x24, 13, insn->tex.r);
2672    }
2673
2674    emitField(0x31, 1, insn->tex.liveOnly);
2675    emitField(0x1f, 4, insn->tex.mask);
2676    emitField(0x16, 6, type);
2677    emitGPR  (0x08, insn->src(0));
2678    emitGPR  (0x00, insn->def(0));
2679 }
2680
2681 void
2682 CodeEmitterGM107::emitDEPBAR()
2683 {
2684    emitInsn (0xf0f00000);
2685    emitField(0x1d, 1, 1); /* le */
2686    emitField(0x1a, 3, 5);
2687    emitField(0x14, 6, insn->subOp);
2688    emitField(0x00, 6, insn->subOp);
2689 }
2690
2691 /*******************************************************************************
2692  * misc
2693  ******************************************************************************/
2694
2695 void
2696 CodeEmitterGM107::emitNOP()
2697 {
2698    emitInsn(0x50b00000);
2699 }
2700
2701 void
2702 CodeEmitterGM107::emitKIL()
2703 {
2704    emitInsn (0xe3300000);
2705    emitCond5(0x00, CC_TR);
2706 }
2707
2708 void
2709 CodeEmitterGM107::emitOUT()
2710 {
2711    const int cut  = insn->op == OP_RESTART || insn->subOp;
2712    const int emit = insn->op == OP_EMIT;
2713
2714    switch (insn->src(1).getFile()) {
2715    case FILE_GPR:
2716       emitInsn(0xfbe00000);
2717       emitGPR (0x14, insn->src(1));
2718       break;
2719    case FILE_IMMEDIATE:
2720       emitInsn(0xf6e00000);
2721       emitIMMD(0x14, 19, insn->src(1));
2722       break;
2723    case FILE_MEMORY_CONST:
2724       emitInsn(0xebe00000);
2725       emitCBUF(0x22, -1, 0x14, 16, 2, insn->src(1));
2726       break;
2727    default:
2728       assert(!"bad src1 file");
2729       break;
2730    }
2731
2732    emitField(0x27, 2, (cut << 1) | emit);
2733    emitGPR  (0x08, insn->src(0));
2734    emitGPR  (0x00, insn->def(0));
2735 }
2736
2737 void
2738 CodeEmitterGM107::emitBAR()
2739 {
2740    uint8_t subop;
2741
2742    emitInsn (0xf0a80000);
2743
2744    switch (insn->subOp) {
2745    case NV50_IR_SUBOP_BAR_RED_POPC: subop = 0x02; break;
2746    case NV50_IR_SUBOP_BAR_RED_AND:  subop = 0x0a; break;
2747    case NV50_IR_SUBOP_BAR_RED_OR:   subop = 0x12; break;
2748    case NV50_IR_SUBOP_BAR_ARRIVE:   subop = 0x81; break;
2749    default:
2750       subop = 0x80;
2751       assert(insn->subOp == NV50_IR_SUBOP_BAR_SYNC);
2752       break;
2753    }
2754
2755    emitField(0x20, 8, subop);
2756
2757    // barrier id
2758    if (insn->src(0).getFile() == FILE_GPR) {
2759       emitGPR(0x08, insn->src(0));
2760    } else {
2761       ImmediateValue *imm = insn->getSrc(0)->asImm();
2762       assert(imm);
2763       emitField(0x08, 8, imm->reg.data.u32);
2764       emitField(0x2b, 1, 1);
2765    }
2766
2767    // thread count
2768    if (insn->src(1).getFile() == FILE_GPR) {
2769       emitGPR(0x14, insn->src(1));
2770    } else {
2771       ImmediateValue *imm = insn->getSrc(0)->asImm();
2772       assert(imm);
2773       emitField(0x14, 12, imm->reg.data.u32);
2774       emitField(0x2c, 1, 1);
2775    }
2776
2777    if (insn->srcExists(2) && (insn->predSrc != 2)) {
2778       emitPRED (0x27, insn->src(2));
2779       emitField(0x2a, 1, insn->src(2).mod == Modifier(NV50_IR_MOD_NOT));
2780    } else {
2781       emitField(0x27, 3, 7);
2782    }
2783 }
2784
2785 void
2786 CodeEmitterGM107::emitMEMBAR()
2787 {
2788    emitInsn (0xef980000);
2789    emitField(0x08, 2, insn->subOp >> 2);
2790 }
2791
2792 void
2793 CodeEmitterGM107::emitVOTE()
2794 {
2795    int subOp;
2796
2797    assert(insn->src(0).getFile() == FILE_PREDICATE &&
2798           insn->def(1).getFile() == FILE_PREDICATE);
2799
2800    switch (insn->subOp) {
2801    case NV50_IR_SUBOP_VOTE_ANY: subOp = 1; break;
2802    default:
2803       assert(insn->subOp == NV50_IR_SUBOP_VOTE_ALL);
2804       subOp = 0;
2805       break;
2806    }
2807
2808    emitInsn (0x50d80000);
2809    emitField(0x30, 2, subOp);
2810    emitGPR  (0x00, insn->def(0));
2811    emitPRED (0x2d, insn->def(1));
2812    emitField(0x2a, 1, insn->src(0).mod == Modifier(NV50_IR_MOD_NOT));
2813    emitPRED (0x27, insn->src(0));
2814 }
2815
2816 /*******************************************************************************
2817  * assembler front-end
2818  ******************************************************************************/
2819
2820 bool
2821 CodeEmitterGM107::emitInstruction(Instruction *i)
2822 {
2823    const unsigned int size = (writeIssueDelays && !(codeSize & 0x1f)) ? 16 : 8;
2824    bool ret = true;
2825
2826    insn = i;
2827
2828    if (insn->encSize != 8) {
2829       ERROR("skipping undecodable instruction: "); insn->print();
2830       return false;
2831    } else
2832    if (codeSize + size > codeSizeLimit) {
2833       ERROR("code emitter output buffer too small\n");
2834       return false;
2835    }
2836
2837    if (writeIssueDelays) {
2838       int n = ((codeSize & 0x1f) / 8) - 1;
2839       if (n < 0) {
2840          data = code;
2841          data[0] = 0x00000000;
2842          data[1] = 0x00000000;
2843          code += 2;
2844          codeSize += 8;
2845          n++;
2846       }
2847
2848       emitField(data, n * 21, 21, insn->sched);
2849    }
2850
2851    switch (insn->op) {
2852    case OP_EXIT:
2853       emitEXIT();
2854       break;
2855    case OP_BRA:
2856       emitBRA();
2857       break;
2858    case OP_CALL:
2859       emitCAL();
2860       break;
2861    case OP_PRECONT:
2862       emitPCNT();
2863       break;
2864    case OP_CONT:
2865       emitCONT();
2866       break;
2867    case OP_PREBREAK:
2868       emitPBK();
2869       break;
2870    case OP_BREAK:
2871       emitBRK();
2872       break;
2873    case OP_PRERET:
2874       emitPRET();
2875       break;
2876    case OP_RET:
2877       emitRET();
2878       break;
2879    case OP_JOINAT:
2880       emitSSY();
2881       break;
2882    case OP_JOIN:
2883       emitSYNC();
2884       break;
2885    case OP_QUADON:
2886       emitSAM();
2887       break;
2888    case OP_QUADPOP:
2889       emitRAM();
2890       break;
2891    case OP_MOV:
2892       emitMOV();
2893       break;
2894    case OP_RDSV:
2895       emitS2R();
2896       break;
2897    case OP_ABS:
2898    case OP_NEG:
2899    case OP_SAT:
2900    case OP_FLOOR:
2901    case OP_CEIL:
2902    case OP_TRUNC:
2903    case OP_CVT:
2904       if (insn->op == OP_CVT && (insn->def(0).getFile() == FILE_PREDICATE ||
2905                                  insn->src(0).getFile() == FILE_PREDICATE)) {
2906          emitMOV();
2907       } else if (isFloatType(insn->dType)) {
2908          if (isFloatType(insn->sType))
2909             emitF2F();
2910          else
2911             emitI2F();
2912       } else {
2913          if (isFloatType(insn->sType))
2914             emitF2I();
2915          else
2916             emitI2I();
2917       }
2918       break;
2919    case OP_SHFL:
2920       emitSHFL();
2921       break;
2922    case OP_ADD:
2923    case OP_SUB:
2924       if (isFloatType(insn->dType)) {
2925          if (insn->dType == TYPE_F64)
2926             emitDADD();
2927          else
2928             emitFADD();
2929       } else {
2930          emitIADD();
2931       }
2932       break;
2933    case OP_MUL:
2934       if (isFloatType(insn->dType)) {
2935          if (insn->dType == TYPE_F64)
2936             emitDMUL();
2937          else
2938             emitFMUL();
2939       } else {
2940          emitIMUL();
2941       }
2942       break;
2943    case OP_MAD:
2944    case OP_FMA:
2945       if (isFloatType(insn->dType)) {
2946          if (insn->dType == TYPE_F64)
2947             emitDFMA();
2948          else
2949             emitFFMA();
2950       } else {
2951          emitIMAD();
2952       }
2953       break;
2954    case OP_MIN:
2955    case OP_MAX:
2956       if (isFloatType(insn->dType)) {
2957          if (insn->dType == TYPE_F64)
2958             emitDMNMX();
2959          else
2960             emitFMNMX();
2961       } else {
2962          emitIMNMX();
2963       }
2964       break;
2965    case OP_SHL:
2966       emitSHL();
2967       break;
2968    case OP_SHR:
2969       emitSHR();
2970       break;
2971    case OP_POPCNT:
2972       emitPOPC();
2973       break;
2974    case OP_INSBF:
2975       emitBFI();
2976       break;
2977    case OP_EXTBF:
2978       emitBFE();
2979       break;
2980    case OP_BFIND:
2981       emitFLO();
2982       break;
2983    case OP_SLCT:
2984       if (isFloatType(insn->dType))
2985          emitFCMP();
2986       else
2987          emitICMP();
2988       break;
2989    case OP_SET:
2990    case OP_SET_AND:
2991    case OP_SET_OR:
2992    case OP_SET_XOR:
2993       if (insn->def(0).getFile() != FILE_PREDICATE) {
2994          if (isFloatType(insn->sType))
2995             if (insn->sType == TYPE_F64)
2996                emitDSET();
2997             else
2998                emitFSET();
2999          else
3000             emitISET();
3001       } else {
3002          if (isFloatType(insn->sType))
3003             if (insn->sType == TYPE_F64)
3004                emitDSETP();
3005             else
3006                emitFSETP();
3007          else
3008             emitISETP();
3009       }
3010       break;
3011    case OP_SELP:
3012       emitSEL();
3013       break;
3014    case OP_PRESIN:
3015    case OP_PREEX2:
3016       emitRRO();
3017       break;
3018    case OP_COS:
3019    case OP_SIN:
3020    case OP_EX2:
3021    case OP_LG2:
3022    case OP_RCP:
3023    case OP_RSQ:
3024       emitMUFU();
3025       break;
3026    case OP_AND:
3027    case OP_OR:
3028    case OP_XOR:
3029       emitLOP();
3030       break;
3031    case OP_NOT:
3032       emitNOT();
3033       break;
3034    case OP_LOAD:
3035       switch (insn->src(0).getFile()) {
3036       case FILE_MEMORY_CONST : emitLDC(); break;
3037       case FILE_MEMORY_LOCAL : emitLDL(); break;
3038       case FILE_MEMORY_SHARED: emitLDS(); break;
3039       case FILE_MEMORY_GLOBAL: emitLD(); break;
3040       default:
3041          assert(!"invalid load");
3042          emitNOP();
3043          break;
3044       }
3045       break;
3046    case OP_STORE:
3047       switch (insn->src(0).getFile()) {
3048       case FILE_MEMORY_LOCAL : emitSTL(); break;
3049       case FILE_MEMORY_SHARED: emitSTS(); break;
3050       case FILE_MEMORY_GLOBAL: emitST(); break;
3051       default:
3052          assert(!"invalid store");
3053          emitNOP();
3054          break;
3055       }
3056       break;
3057    case OP_ATOM:
3058       if (insn->src(0).getFile() == FILE_MEMORY_SHARED)
3059          emitATOMS();
3060       else
3061          emitATOM();
3062       break;
3063    case OP_CCTL:
3064       emitCCTL();
3065       break;
3066    case OP_VFETCH:
3067       emitALD();
3068       break;
3069    case OP_EXPORT:
3070       emitAST();
3071       break;
3072    case OP_PFETCH:
3073       emitISBERD();
3074       break;
3075    case OP_AFETCH:
3076       emitAL2P();
3077       break;
3078    case OP_LINTERP:
3079    case OP_PINTERP:
3080       emitIPA();
3081       break;
3082    case OP_PIXLD:
3083       emitPIXLD();
3084       break;
3085    case OP_TEX:
3086    case OP_TXB:
3087    case OP_TXL:
3088       emitTEX();
3089       break;
3090    case OP_TXF:
3091       emitTLD();
3092       break;
3093    case OP_TXG:
3094       emitTLD4();
3095       break;
3096    case OP_TXD:
3097       emitTXD();
3098       break;
3099    case OP_TXQ:
3100       emitTXQ();
3101       break;
3102    case OP_TXLQ:
3103       emitTMML();
3104       break;
3105    case OP_TEXBAR:
3106       emitDEPBAR();
3107       break;
3108    case OP_QUADOP:
3109       emitFSWZADD();
3110       break;
3111    case OP_NOP:
3112       emitNOP();
3113       break;
3114    case OP_DISCARD:
3115       emitKIL();
3116       break;
3117    case OP_EMIT:
3118    case OP_RESTART:
3119       emitOUT();
3120       break;
3121    case OP_BAR:
3122       emitBAR();
3123       break;
3124    case OP_MEMBAR:
3125       emitMEMBAR();
3126       break;
3127    case OP_VOTE:
3128       emitVOTE();
3129       break;
3130    default:
3131       assert(!"invalid opcode");
3132       emitNOP();
3133       ret = false;
3134       break;
3135    }
3136
3137    if (insn->join) {
3138       /*XXX*/
3139    }
3140
3141    code += 2;
3142    codeSize += 8;
3143    return ret;
3144 }
3145
3146 uint32_t
3147 CodeEmitterGM107::getMinEncodingSize(const Instruction *i) const
3148 {
3149    return 8;
3150 }
3151
3152 /*******************************************************************************
3153  * sched data calculator
3154  ******************************************************************************/
3155
3156 class SchedDataCalculatorGM107 : public Pass
3157 {
3158 public:
3159    SchedDataCalculatorGM107(const Target *targ) : targ(targ) {}
3160 private:
3161    const Target *targ;
3162    bool visit(BasicBlock *bb);
3163 };
3164
3165 bool
3166 SchedDataCalculatorGM107::visit(BasicBlock *bb)
3167 {
3168    for (Instruction *insn = bb->getEntry(); insn; insn = insn->next) {
3169       /*XXX*/
3170       insn->sched = 0x7e0;
3171    }
3172
3173    return true;
3174 }
3175
3176 /*******************************************************************************
3177  * main
3178  ******************************************************************************/
3179
3180 void
3181 CodeEmitterGM107::prepareEmission(Function *func)
3182 {
3183    SchedDataCalculatorGM107 sched(targ);
3184    CodeEmitter::prepareEmission(func);
3185    sched.run(func, true, true);
3186 }
3187
3188 static inline uint32_t sizeToBundlesGM107(uint32_t size)
3189 {
3190    return (size + 23) / 24;
3191 }
3192
3193 void
3194 CodeEmitterGM107::prepareEmission(Program *prog)
3195 {
3196    for (ArrayList::Iterator fi = prog->allFuncs.iterator();
3197         !fi.end(); fi.next()) {
3198       Function *func = reinterpret_cast<Function *>(fi.get());
3199       func->binPos = prog->binSize;
3200       prepareEmission(func);
3201
3202       // adjust sizes & positions for schedulding info:
3203       if (prog->getTarget()->hasSWSched) {
3204          uint32_t adjPos = func->binPos;
3205          BasicBlock *bb = NULL;
3206          for (int i = 0; i < func->bbCount; ++i) {
3207             bb = func->bbArray[i];
3208             int32_t adjSize = bb->binSize;
3209             if (adjPos % 32) {
3210                adjSize -= 32 - adjPos % 32;
3211                if (adjSize < 0)
3212                   adjSize = 0;
3213             }
3214             adjSize = bb->binSize + sizeToBundlesGM107(adjSize) * 8;
3215             bb->binPos = adjPos;
3216             bb->binSize = adjSize;
3217             adjPos += adjSize;
3218          }
3219          if (bb)
3220             func->binSize = adjPos - func->binPos;
3221       }
3222
3223       prog->binSize += func->binSize;
3224    }
3225 }
3226
3227 CodeEmitterGM107::CodeEmitterGM107(const TargetGM107 *target)
3228    : CodeEmitter(target),
3229      targGM107(target),
3230      writeIssueDelays(target->hasSWSched)
3231 {
3232    code = NULL;
3233    codeSize = codeSizeLimit = 0;
3234    relocInfo = NULL;
3235 }
3236
3237 CodeEmitter *
3238 TargetGM107::createCodeEmitterGM107(Program::Type type)
3239 {
3240    CodeEmitterGM107 *emit = new CodeEmitterGM107(this);
3241    emit->setProgramType(type);
3242    return emit;
3243 }
3244
3245 } // namespace nv50_ir