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

   1 /*
   2  * Copyright 2011 Christoph Bumiller
   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 AUTHORS OR COPYRIGHT HOLDERS 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
  23 #include "codegen/nv50_ir.h"
  24 #include "codegen/nv50_ir_target_nv50.h"
  25
  26 namespace nv50_ir {
  27
  28 #define NV50_OP_ENC_LONG     0
  29 #define NV50_OP_ENC_SHORT    1
  30 #define NV50_OP_ENC_IMM      2
  31 #define NV50_OP_ENC_LONG_ALT 3
  32
  33 class CodeEmitterNV50 : public CodeEmitter
  34 {
  35 public:
  36    CodeEmitterNV50(const TargetNV50 *);
  37
  38    virtual bool emitInstruction(Instruction *);
  39
  40    virtual uint32_t getMinEncodingSize(const Instruction *) const;
  41
  42    inline void setProgramType(Program::Type pType) { progType = pType; }
  43
  44    virtual void prepareEmission(Function *);
  45
  46 private:
  47    Program::Type progType;
  48
  49    const TargetNV50 *targNV50;
  50
  51 private:
  52    inline void defId(const ValueDef&, const int pos);
  53    inline void srcId(const ValueRef&, const int pos);
  54    inline void srcId(const ValueRef *, const int pos);
  55
  56    inline void srcAddr16(const ValueRef&, bool adj, const int pos);
  57    inline void srcAddr8(const ValueRef&, const int pos);
  58
  59    void emitFlagsRd(const Instruction *);
  60    void emitFlagsWr(const Instruction *);
  61
  62    void emitCondCode(CondCode cc, DataType ty, int pos);
  63
  64    inline void setARegBits(unsigned int);
  65
  66    void setAReg16(const Instruction *, int s);
  67    void setImmediate(const Instruction *, int s);
  68
  69    void setDst(const Value *);
  70    void setDst(const Instruction *, int d);
  71    void setSrcFileBits(const Instruction *, int enc);
  72    void setSrc(const Instruction *, unsigned int s, int slot);
  73
  74    void emitForm_MAD(const Instruction *);
  75    void emitForm_ADD(const Instruction *);
  76    void emitForm_MUL(const Instruction *);
  77    void emitForm_IMM(const Instruction *);
  78
  79    void emitLoadStoreSizeLG(DataType ty, int pos);
  80    void emitLoadStoreSizeCS(DataType ty);
  81
  82    void roundMode_MAD(const Instruction *);
  83    void roundMode_CVT(RoundMode);
  84
  85    void emitMNeg12(const Instruction *);
  86
  87    void emitLOAD(const Instruction *);
  88    void emitSTORE(const Instruction *);
  89    void emitMOV(const Instruction *);
  90    void emitRDSV(const Instruction *);
  91    void emitNOP();
  92    void emitINTERP(const Instruction *);
  93    void emitPFETCH(const Instruction *);
  94    void emitOUT(const Instruction *);
  95
  96    void emitUADD(const Instruction *);
  97    void emitAADD(const Instruction *);
  98    void emitFADD(const Instruction *);
  99    void emitDADD(const Instruction *);
 100    void emitIMUL(const Instruction *);
 101    void emitFMUL(const Instruction *);
 102    void emitDMUL(const Instruction *);
 103    void emitFMAD(const Instruction *);
 104    void emitDMAD(const Instruction *);
 105    void emitIMAD(const Instruction *);
 106    void emitISAD(const Instruction *);
 107
 108    void emitMINMAX(const Instruction *);
 109
 110    void emitPreOp(const Instruction *);
 111    void emitSFnOp(const Instruction *, uint8_t subOp);
 112
 113    void emitShift(const Instruction *);
 114    void emitARL(const Instruction *, unsigned int shl);
 115    void emitLogicOp(const Instruction *);
 116    void emitNOT(const Instruction *);
 117
 118    void emitCVT(const Instruction *);
 119    void emitSET(const Instruction *);
 120
 121    void emitTEX(const TexInstruction *);
 122    void emitTXQ(const TexInstruction *);
 123    void emitTEXPREP(const TexInstruction *);
 124
 125    void emitQUADOP(const Instruction *, uint8_t lane, uint8_t quOp);
 126
 127    void emitFlow(const Instruction *, uint8_t flowOp);
 128    void emitPRERETEmu(const FlowInstruction *);
 129    void emitBAR(const Instruction *);
 130
 131    void emitATOM(const Instruction *);
 132 };
 133
 134 #define SDATA(a) ((a).rep()->reg.data)
 135 #define DDATA(a) ((a).rep()->reg.data)
 136
 137 void CodeEmitterNV50::srcId(const ValueRef& src, const int pos)
 138 {
 139    assert(src.get());
 140    code[pos / 32] |= SDATA(src).id << (pos % 32);
 141 }
 142
 143 void CodeEmitterNV50::srcId(const ValueRef *src, const int pos)
 144 {
 145    assert(src->get());
 146    code[pos / 32] |= SDATA(*src).id << (pos % 32);
 147 }
 148
 149 void CodeEmitterNV50::srcAddr16(const ValueRef& src, bool adj, const int pos)
 150 {
 151    assert(src.get());
 152
 153    int32_t offset = SDATA(src).offset;
 154
 155    assert(!adj || src.get()->reg.size <= 4);
 156    if (adj)
 157       offset /= src.get()->reg.size;
 158
 159    assert(offset <= 0x7fff && offset >= (int32_t)-0x8000 && (pos % 32) <= 16);
 160
 161    if (offset < 0)
 162       offset &= adj ? (0xffff >> (src.get()->reg.size >> 1)) : 0xffff;
 163
 164    code[pos / 32] |= offset << (pos % 32);
 165 }
 166
 167 void CodeEmitterNV50::srcAddr8(const ValueRef& src, const int pos)
 168 {
 169    assert(src.get());
 170
 171    uint32_t offset = SDATA(src).offset;
 172
 173    assert((offset <= 0x1fc || offset == 0x3fc) && !(offset & 0x3));
 174
 175    code[pos / 32] |= (offset >> 2) << (pos % 32);
 176 }
 177
 178 void CodeEmitterNV50::defId(const ValueDef& def, const int pos)
 179 {
 180    assert(def.get() && def.getFile() != FILE_SHADER_OUTPUT);
 181
 182    code[pos / 32] |= DDATA(def).id << (pos % 32);
 183 }
 184
 185 void
 186 CodeEmitterNV50::roundMode_MAD(const Instruction *insn)
 187 {
 188    switch (insn->rnd) {
 189    case ROUND_M: code[1] |= 1 << 22; break;
 190    case ROUND_P: code[1] |= 2 << 22; break;
 191    case ROUND_Z: code[1] |= 3 << 22; break;
 192    default:
 193       assert(insn->rnd == ROUND_N);
 194       break;
 195    }
 196 }
 197
 198 void
 199 CodeEmitterNV50::emitMNeg12(const Instruction *i)
 200 {
 201    code[1] |= i->src(0).mod.neg() << 26;
 202    code[1] |= i->src(1).mod.neg() << 27;
 203 }
 204
 205 void CodeEmitterNV50::emitCondCode(CondCode cc, DataType ty, int pos)
 206 {
 207    uint8_t enc;
 208
 209    assert(pos >= 32 || pos <= 27);
 210
 211    switch (cc) {
 212    case CC_LT:  enc = 0x1; break;
 213    case CC_LTU: enc = 0x9; break;
 214    case CC_EQ:  enc = 0x2; break;
 215    case CC_EQU: enc = 0xa; break;
 216    case CC_LE:  enc = 0x3; break;
 217    case CC_LEU: enc = 0xb; break;
 218    case CC_GT:  enc = 0x4; break;
 219    case CC_GTU: enc = 0xc; break;
 220    case CC_NE:  enc = 0x5; break;
 221    case CC_NEU: enc = 0xd; break;
 222    case CC_GE:  enc = 0x6; break;
 223    case CC_GEU: enc = 0xe; break;
 224    case CC_TR:  enc = 0xf; break;
 225    case CC_FL:  enc = 0x0; break;
 226
 227    case CC_O:  enc = 0x10; break;
 228    case CC_C:  enc = 0x11; break;
 229    case CC_A:  enc = 0x12; break;
 230    case CC_S:  enc = 0x13; break;
 231    case CC_NS: enc = 0x1c; break;
 232    case CC_NA: enc = 0x1d; break;
 233    case CC_NC: enc = 0x1e; break;
 234    case CC_NO: enc = 0x1f; break;
 235
 236    default:
 237       enc = 0;
 238       assert(!"invalid condition code");
 239       break;
 240    }
 241    if (ty != TYPE_NONE && !isFloatType(ty))
 242       enc &= ~0x8; // unordered only exists for float types
 243
 244    code[pos / 32] |= enc << (pos % 32);
 245 }
 246
 247 void
 248 CodeEmitterNV50::emitFlagsRd(const Instruction *i)
 249 {
 250    int s = (i->flagsSrc >= 0) ? i->flagsSrc : i->predSrc;
 251
 252    assert(!(code[1] & 0x00003f80));
 253
 254    if (s >= 0) {
 255       assert(i->getSrc(s)->reg.file == FILE_FLAGS);
 256       emitCondCode(i->cc, TYPE_NONE, 32 + 7);
 257       srcId(i->src(s), 32 + 12);
 258    } else {
 259       code[1] |= 0x0780;
 260    }
 261 }
 262
 263 void
 264 CodeEmitterNV50::emitFlagsWr(const Instruction *i)
 265 {
 266    assert(!(code[1] & 0x70));
 267
 268    int flagsDef = i->flagsDef;
 269
 270    // find flags definition and check that it is the last def
 271    if (flagsDef < 0) {
 272       for (int d = 0; i->defExists(d); ++d)
 273          if (i->def(d).getFile() == FILE_FLAGS)
 274             flagsDef = d;
 275       if (flagsDef >= 0 && 0) // TODO: enforce use of flagsDef at some point
 276          WARN("Instruction::flagsDef was not set properly\n");
 277    }
 278    if (flagsDef == 0 && i->defExists(1))
 279       WARN("flags def should not be the primary definition\n");
 280
 281    if (flagsDef >= 0)
 282       code[1] |= (DDATA(i->def(flagsDef)).id << 4) | 0x40;
 283
 284 }
 285
 286 void
 287 CodeEmitterNV50::setARegBits(unsigned int u)
 288 {
 289    code[0] |= (u & 3) << 26;
 290    code[1] |= (u & 4);
 291 }
 292
 293 void
 294 CodeEmitterNV50::setAReg16(const Instruction *i, int s)
 295 {
 296    if (i->srcExists(s)) {
 297       s = i->src(s).indirect[0];
 298       if (s >= 0)
 299          setARegBits(SDATA(i->src(s)).id + 1);
 300    }
 301 }
 302
 303 void
 304 CodeEmitterNV50::setImmediate(const Instruction *i, int s)
 305 {
 306    const ImmediateValue *imm = i->src(s).get()->asImm();
 307    assert(imm);
 308
 309    uint32_t u = imm->reg.data.u32;
 310
 311    if (i->src(s).mod & Modifier(NV50_IR_MOD_NOT))
 312       u = ~u;
 313
 314    code[1] |= 3;
 315    code[0] |= (u & 0x3f) << 16;
 316    code[1] |= (u >> 6) << 2;
 317 }
 318
 319 void
 320 CodeEmitterNV50::setDst(const Value *dst)
 321 {
 322    const Storage *reg = &dst->join->reg;
 323
 324    assert(reg->file != FILE_ADDRESS);
 325
 326    if (reg->data.id < 0 || reg->file == FILE_FLAGS) {
 327       code[0] |= (127 << 2) | 1;
 328       code[1] |= 8;
 329    } else {
 330       int id;
 331       if (reg->file == FILE_SHADER_OUTPUT) {
 332          code[1] |= 8;
 333          id = reg->data.offset / 4;
 334       } else {
 335          id = reg->data.id;
 336       }
 337       code[0] |= id << 2;
 338    }
 339 }
 340
 341 void
 342 CodeEmitterNV50::setDst(const Instruction *i, int d)
 343 {
 344    if (i->defExists(d)) {
 345       setDst(i->getDef(d));
 346    } else
 347    if (!d) {
 348       code[0] |= 0x01fc; // bit bucket
 349       code[1] |= 0x0008;
 350    }
 351 }
 352
 353 // 3 * 2 bits:
 354 // 0: r
 355 // 1: a/s
 356 // 2: c
 357 // 3: i
 358 void
 359 CodeEmitterNV50::setSrcFileBits(const Instruction *i, int enc)
 360 {
 361    uint8_t mode = 0;
 362
 363    for (unsigned int s = 0; s < Target::operationSrcNr[i->op]; ++s) {
 364       switch (i->src(s).getFile()) {
 365       case FILE_GPR:
 366          break;
 367       case FILE_MEMORY_SHARED:
 368       case FILE_SHADER_INPUT:
 369          mode |= 1 << (s * 2);
 370          break;
 371       case FILE_MEMORY_CONST:
 372          mode |= 2 << (s * 2);
 373          break;
 374       case FILE_IMMEDIATE:
 375          mode |= 3 << (s * 2);
 376          break;
 377       default:
 378          ERROR("invalid file on source %i: %u\n", s, i->src(s).getFile());
 379          assert(0);
 380          break;
 381       }
 382    }
 383    switch (mode) {
 384    case 0x00: // rrr
 385       break;
 386    case 0x01: // arr/grr
 387       if (progType == Program::TYPE_GEOMETRY && i->src(0).isIndirect(0)) {
 388          code[0] |= 0x01800000;
 389          if (enc == NV50_OP_ENC_LONG || enc == NV50_OP_ENC_LONG_ALT)
 390             code[1] |= 0x00200000;
 391       } else {
 392          if (enc == NV50_OP_ENC_SHORT)
 393             code[0] |= 0x01000000;
 394          else
 395             code[1] |= 0x00200000;
 396       }
 397       break;
 398    case 0x03: // irr
 399       assert(i->op == OP_MOV);
 400       return;
 401    case 0x0c: // rir
 402       break;
 403    case 0x0d: // gir
 404       assert(progType == Program::TYPE_GEOMETRY ||
 405              progType == Program::TYPE_COMPUTE);
 406       code[0] |= 0x01000000;
 407       if (progType == Program::TYPE_GEOMETRY && i->src(0).isIndirect(0)) {
 408          int reg = i->src(0).getIndirect(0)->rep()->reg.data.id;
 409          assert(reg < 3);
 410          code[0] |= (reg + 1) << 26;
 411       }
 412       break;
 413    case 0x08: // rcr
 414       code[0] |= (enc == NV50_OP_ENC_LONG_ALT) ? 0x01000000 : 0x00800000;
 415       code[1] |= (i->getSrc(1)->reg.fileIndex << 22);
 416       break;
 417    case 0x09: // acr/gcr
 418       if (progType == Program::TYPE_GEOMETRY && i->src(0).isIndirect(0)) {
 419          code[0] |= 0x01800000;
 420       } else {
 421          code[0] |= (enc == NV50_OP_ENC_LONG_ALT) ? 0x01000000 : 0x00800000;
 422          code[1] |= 0x00200000;
 423       }
 424       code[1] |= (i->getSrc(1)->reg.fileIndex << 22);
 425       break;
 426    case 0x20: // rrc
 427       code[0] |= 0x01000000;
 428       code[1] |= (i->getSrc(2)->reg.fileIndex << 22);
 429       break;
 430    case 0x21: // arc
 431       code[0] |= 0x01000000;
 432       code[1] |= 0x00200000 | (i->getSrc(2)->reg.fileIndex << 22);
 433       assert(progType != Program::TYPE_GEOMETRY);
 434       break;
 435    default:
 436       ERROR("not encodable: %x\n", mode);
 437       assert(0);
 438       break;
 439    }
 440    if (progType != Program::TYPE_COMPUTE)
 441       return;
 442
 443    if ((mode & 3) == 1) {
 444       const int pos = ((mode >> 2) & 3) == 3 ? 13 : 14;
 445
 446       switch (i->sType) {
 447       case TYPE_U8:
 448          break;
 449       case TYPE_U16:
 450          code[0] |= 1 << pos;
 451          break;
 452       case TYPE_S16:
 453          code[0] |= 2 << pos;
 454          break;
 455       default:
 456          code[0] |= 3 << pos;
 457          assert(i->getSrc(0)->reg.size == 4);
 458          break;
 459       }
 460    }
 461 }
 462
 463 void
 464 CodeEmitterNV50::setSrc(const Instruction *i, unsigned int s, int slot)
 465 {
 466    if (Target::operationSrcNr[i->op] <= s)
 467       return;
 468    const Storage *reg = &i->src(s).rep()->reg;
 469
 470    unsigned int id = (reg->file == FILE_GPR) ?
 471       reg->data.id :
 472       reg->data.offset >> (reg->size >> 1); // no > 4 byte sources here
 473
 474    switch (slot) {
 475    case 0: code[0] |= id << 9; break;
 476    case 1: code[0] |= id << 16; break;
 477    case 2: code[1] |= id << 14; break;
 478    default:
 479       assert(0);
 480       break;
 481    }
 482 }
 483
 484 // the default form:
 485 //  - long instruction
 486 //  - 1 to 3 sources in slots 0, 1, 2 (rrr, arr, rcr, acr, rrc, arc, gcr, grr)
 487 //  - address & flags
 488 void
 489 CodeEmitterNV50::emitForm_MAD(const Instruction *i)
 490 {
 491    assert(i->encSize == 8);
 492    code[0] |= 1;
 493
 494    emitFlagsRd(i);
 495    emitFlagsWr(i);
 496
 497    setDst(i, 0);
 498
 499    setSrcFileBits(i, NV50_OP_ENC_LONG);
 500    setSrc(i, 0, 0);
 501    setSrc(i, 1, 1);
 502    setSrc(i, 2, 2);
 503
 504    if (i->getIndirect(0, 0)) {
 505       assert(!i->srcExists(1) || !i->getIndirect(1, 0));
 506       assert(!i->srcExists(2) || !i->getIndirect(2, 0));
 507       setAReg16(i, 0);
 508    } else if (i->srcExists(1) && i->getIndirect(1, 0)) {
 509       assert(!i->srcExists(2) || !i->getIndirect(2, 0));
 510       setAReg16(i, 1);
 511    } else {
 512       setAReg16(i, 2);
 513    }
 514 }
 515
 516 // like default form, but 2nd source in slot 2, and no 3rd source
 517 void
 518 CodeEmitterNV50::emitForm_ADD(const Instruction *i)
 519 {
 520    assert(i->encSize == 8);
 521    code[0] |= 1;
 522
 523    emitFlagsRd(i);
 524    emitFlagsWr(i);
 525
 526    setDst(i, 0);
 527
 528    setSrcFileBits(i, NV50_OP_ENC_LONG_ALT);
 529    setSrc(i, 0, 0);
 530    if (i->predSrc != 1)
 531       setSrc(i, 1, 2);
 532
 533    if (i->getIndirect(0, 0)) {
 534       assert(!i->getIndirect(1, 0));
 535       setAReg16(i, 0);
 536    } else {
 537       setAReg16(i, 1);
 538    }
 539 }
 540
 541 // default short form (rr, ar, rc, gr)
 542 void
 543 CodeEmitterNV50::emitForm_MUL(const Instruction *i)
 544 {
 545    assert(i->encSize == 4 && !(code[0] & 1));
 546    assert(i->defExists(0));
 547    assert(!i->getPredicate());
 548
 549    setDst(i, 0);
 550
 551    setSrcFileBits(i, NV50_OP_ENC_SHORT);
 552    setSrc(i, 0, 0);
 553    setSrc(i, 1, 1);
 554 }
 555
 556 // usual immediate form
 557 // - 1 to 3 sources where second is immediate (rir, gir)
 558 // - no address or predicate possible
 559 void
 560 CodeEmitterNV50::emitForm_IMM(const Instruction *i)
 561 {
 562    assert(i->encSize == 8);
 563    code[0] |= 1;
 564
 565    assert(i->defExists(0) && i->srcExists(0));
 566
 567    setDst(i, 0);
 568
 569    setSrcFileBits(i, NV50_OP_ENC_IMM);
 570    if (Target::operationSrcNr[i->op] > 1) {
 571       setSrc(i, 0, 0);
 572       setImmediate(i, 1);
 573       // If there is another source, it has to be the same as the dest reg.
 574    } else {
 575       setImmediate(i, 0);
 576    }
 577 }
 578
 579 void
 580 CodeEmitterNV50::emitLoadStoreSizeLG(DataType ty, int pos)
 581 {
 582    uint8_t enc;
 583
 584    switch (ty) {
 585    case TYPE_F32: // fall through
 586    case TYPE_S32: // fall through
 587    case TYPE_U32:  enc = 0x6; break;
 588    case TYPE_B128: enc = 0x5; break;
 589    case TYPE_F64: // fall through
 590    case TYPE_S64: // fall through
 591    case TYPE_U64:  enc = 0x4; break;
 592    case TYPE_S16:  enc = 0x3; break;
 593    case TYPE_U16:  enc = 0x2; break;
 594    case TYPE_S8:   enc = 0x1; break;
 595    case TYPE_U8:   enc = 0x0; break;
 596    default:
 597       enc = 0;
 598       assert(!"invalid load/store type");
 599       break;
 600    }
 601    code[pos / 32] |= enc << (pos % 32);
 602 }
 603
 604 void
 605 CodeEmitterNV50::emitLoadStoreSizeCS(DataType ty)
 606 {
 607    switch (ty) {
 608    case TYPE_U8: break;
 609    case TYPE_U16: code[1] |= 0x4000; break;
 610    case TYPE_S16: code[1] |= 0x8000; break;
 611    case TYPE_F32:
 612    case TYPE_S32:
 613    case TYPE_U32: code[1] |= 0xc000; break;
 614    default:
 615       assert(0);
 616       break;
 617    }
 618 }
 619
 620 void
 621 CodeEmitterNV50::emitLOAD(const Instruction *i)
 622 {
 623    DataFile sf = i->src(0).getFile();
 624    int32_t offset = i->getSrc(0)->reg.data.offset;
 625
 626    switch (sf) {
 627    case FILE_SHADER_INPUT:
 628       if (progType == Program::TYPE_GEOMETRY && i->src(0).isIndirect(0))
 629          code[0] = 0x11800001;
 630       else
 631          // use 'mov' where we can
 632          code[0] = i->src(0).isIndirect(0) ? 0x00000001 : 0x10000001;
 633       code[1] = 0x00200000 | (i->lanes << 14);
 634       if (typeSizeof(i->dType) == 4)
 635          code[1] |= 0x04000000;
 636       break;
 637    case FILE_MEMORY_SHARED:
 638       if (targ->getChipset() >= 0x84) {
 639          assert(offset <= (int32_t)(0x3fff * typeSizeof(i->sType)));
 640          code[0] = 0x10000001;
 641          code[1] = 0x40000000;
 642
 643          if (typeSizeof(i->dType) == 4)
 644             code[1] |= 0x04000000;
 645
 646          emitLoadStoreSizeCS(i->sType);
 647       } else {
 648          assert(offset <= (int32_t)(0x1f * typeSizeof(i->sType)));
 649          code[0] = 0x10000001;
 650          code[1] = 0x00200000 | (i->lanes << 14);
 651          emitLoadStoreSizeCS(i->sType);
 652       }
 653       break;
 654    case FILE_MEMORY_CONST:
 655       code[0] = 0x10000001;
 656       code[1] = 0x20000000 | (i->getSrc(0)->reg.fileIndex << 22);
 657       if (typeSizeof(i->dType) == 4)
 658          code[1] |= 0x04000000;
 659       emitLoadStoreSizeCS(i->sType);
 660       break;
 661    case FILE_MEMORY_LOCAL:
 662       code[0] = 0xd0000001;
 663       code[1] = 0x40000000;
 664       break;
 665    case FILE_MEMORY_GLOBAL:
 666       code[0] = 0xd0000001 | (i->getSrc(0)->reg.fileIndex << 16);
 667       code[1] = 0x80000000;
 668       break;
 669    default:
 670       assert(!"invalid load source file");
 671       break;
 672    }
 673    if (sf == FILE_MEMORY_LOCAL ||
 674        sf == FILE_MEMORY_GLOBAL)
 675       emitLoadStoreSizeLG(i->sType, 21 + 32);
 676
 677    setDst(i, 0);
 678
 679    emitFlagsRd(i);
 680    emitFlagsWr(i);
 681
 682    if (i->src(0).getFile() == FILE_MEMORY_GLOBAL) {
 683       srcId(*i->src(0).getIndirect(0), 9);
 684    } else {
 685       setAReg16(i, 0);
 686       srcAddr16(i->src(0), i->src(0).getFile() != FILE_MEMORY_LOCAL, 9);
 687    }
 688 }
 689
 690 void
 691 CodeEmitterNV50::emitSTORE(const Instruction *i)
 692 {
 693    DataFile f = i->getSrc(0)->reg.file;
 694    int32_t offset = i->getSrc(0)->reg.data.offset;
 695
 696    switch (f) {
 697    case FILE_SHADER_OUTPUT:
 698       code[0] = 0x00000001 | ((offset >> 2) << 9);
 699       code[1] = 0x80c00000;
 700       srcId(i->src(1), 32 + 14);
 701       break;
 702    case FILE_MEMORY_GLOBAL:
 703       code[0] = 0xd0000001 | (i->getSrc(0)->reg.fileIndex << 16);
 704       code[1] = 0xa0000000;
 705       emitLoadStoreSizeLG(i->dType, 21 + 32);
 706       srcId(i->src(1), 2);
 707       break;
 708    case FILE_MEMORY_LOCAL:
 709       code[0] = 0xd0000001;
 710       code[1] = 0x60000000;
 711       emitLoadStoreSizeLG(i->dType, 21 + 32);
 712       srcId(i->src(1), 2);
 713       break;
 714    case FILE_MEMORY_SHARED:
 715       code[0] = 0x00000001;
 716       code[1] = 0xe0000000;
 717       switch (typeSizeof(i->dType)) {
 718       case 1:
 719          code[0] |= offset << 9;
 720          code[1] |= 0x00400000;
 721          break;
 722       case 2:
 723          code[0] |= (offset >> 1) << 9;
 724          break;
 725       case 4:
 726          code[0] |= (offset >> 2) << 9;
 727          code[1] |= 0x04200000;
 728          break;
 729       default:
 730          assert(0);
 731          break;
 732       }
 733       srcId(i->src(1), 32 + 14);
 734       break;
 735    default:
 736       assert(!"invalid store destination file");
 737       break;
 738    }
 739
 740    if (f == FILE_MEMORY_GLOBAL)
 741       srcId(*i->src(0).getIndirect(0), 9);
 742    else
 743       setAReg16(i, 0);
 744
 745    if (f == FILE_MEMORY_LOCAL)
 746       srcAddr16(i->src(0), false, 9);
 747
 748    emitFlagsRd(i);
 749 }
 750
 751 void
 752 CodeEmitterNV50::emitMOV(const Instruction *i)
 753 {
 754    DataFile sf = i->getSrc(0)->reg.file;
 755    DataFile df = i->getDef(0)->reg.file;
 756
 757    assert(sf == FILE_GPR || df == FILE_GPR);
 758
 759    if (sf == FILE_FLAGS) {
 760       assert(i->flagsSrc >= 0);
 761       code[0] = 0x00000001;
 762       code[1] = 0x20000000;
 763       defId(i->def(0), 2);
 764       emitFlagsRd(i);
 765    } else
 766    if (sf == FILE_ADDRESS) {
 767       code[0] = 0x00000001;
 768       code[1] = 0x40000000;
 769       defId(i->def(0), 2);
 770       setARegBits(SDATA(i->src(0)).id + 1);
 771       emitFlagsRd(i);
 772    } else
 773    if (df == FILE_FLAGS) {
 774       assert(i->flagsDef >= 0);
 775       code[0] = 0x00000001;
 776       code[1] = 0xa0000000;
 777       srcId(i->src(0), 9);
 778       emitFlagsRd(i);
 779       emitFlagsWr(i);
 780    } else
 781    if (sf == FILE_IMMEDIATE) {
 782       code[0] = 0x10008001;
 783       code[1] = 0x00000003;
 784       emitForm_IMM(i);
 785    } else {
 786       if (i->encSize == 4) {
 787          code[0] = 0x10008000;
 788       } else {
 789          code[0] = 0x10000001;
 790          code[1] = (typeSizeof(i->dType) == 2) ? 0 : 0x04000000;
 791          code[1] |= (i->lanes << 14);
 792          emitFlagsRd(i);
 793       }
 794       defId(i->def(0), 2);
 795       srcId(i->src(0), 9);
 796    }
 797    if (df == FILE_SHADER_OUTPUT) {
 798       assert(i->encSize == 8);
 799       code[1] |= 0x8;
 800    }
 801 }
 802
 803 static inline uint8_t getSRegEncoding(const ValueRef &ref)
 804 {
 805    switch (SDATA(ref).sv.sv) {
 806    case SV_PHYSID:        return 0;
 807    case SV_CLOCK:         return 1;
 808    case SV_VERTEX_STRIDE: return 3;
 809 // case SV_PM_COUNTER:    return 4 + SDATA(ref).sv.index;
 810    case SV_SAMPLE_INDEX:  return 8;
 811    default:
 812       assert(!"no sreg for system value");
 813       return 0;
 814    }
 815 }
 816
 817 void
 818 CodeEmitterNV50::emitRDSV(const Instruction *i)
 819 {
 820    code[0] = 0x00000001;
 821    code[1] = 0x60000000 | (getSRegEncoding(i->src(0)) << 14);
 822    defId(i->def(0), 2);
 823    emitFlagsRd(i);
 824 }
 825
 826 void
 827 CodeEmitterNV50::emitNOP()
 828 {
 829    code[0] = 0xf0000001;
 830    code[1] = 0xe0000000;
 831 }
 832
 833 void
 834 CodeEmitterNV50::emitQUADOP(const Instruction *i, uint8_t lane, uint8_t quOp)
 835 {
 836    code[0] = 0xc0000000 | (lane << 16);
 837    code[1] = 0x80000000;
 838
 839    code[0] |= (quOp & 0x03) << 20;
 840    code[1] |= (quOp & 0xfc) << 20;
 841
 842    emitForm_ADD(i);
 843
 844    if (!i->srcExists(1) || i->predSrc == 1)
 845       srcId(i->src(0), 32 + 14);
 846 }
 847
 848 /* NOTE: This returns the base address of a vertex inside the primitive.
 849  * src0 is an immediate, the index (not offset) of the vertex
 850  * inside the primitive. XXX: signed or unsigned ?
 851  * src1 (may be NULL) should use whatever units the hardware requires
 852  * (on nv50 this is bytes, so, relative index * 4; signed 16 bit value).
 853  */
 854 void
 855 CodeEmitterNV50::emitPFETCH(const Instruction *i)
 856 {
 857    const uint32_t prim = i->src(0).get()->reg.data.u32;
 858    assert(prim <= 127);
 859
 860    if (i->def(0).getFile() == FILE_ADDRESS) {
 861       // shl $aX a[] 0
 862       code[0] = 0x00000001 | ((DDATA(i->def(0)).id + 1) << 2);
 863       code[1] = 0xc0200000;
 864       code[0] |= prim << 9;
 865       assert(!i->srcExists(1));
 866    } else
 867    if (i->srcExists(1)) {
 868       // ld b32 $rX a[$aX+base]
 869       code[0] = 0x00000001;
 870       code[1] = 0x04200000 | (0xf << 14);
 871       defId(i->def(0), 2);
 872       code[0] |= prim << 9;
 873       setARegBits(SDATA(i->src(1)).id + 1);
 874    } else {
 875       // mov b32 $rX a[]
 876       code[0] = 0x10000001;
 877       code[1] = 0x04200000 | (0xf << 14);
 878       defId(i->def(0), 2);
 879       code[0] |= prim << 9;
 880    }
 881    emitFlagsRd(i);
 882 }
 883
 884 static void
 885 interpApply(const FixupEntry *entry, uint32_t *code, const FixupData& data)
 886 {
 887    int ipa = entry->ipa;
 888    int encSize = entry->reg;
 889    int loc = entry->loc;
 890
 891    if ((ipa & NV50_IR_INTERP_SAMPLE_MASK) == NV50_IR_INTERP_DEFAULT &&
 892        (ipa & NV50_IR_INTERP_MODE_MASK) != NV50_IR_INTERP_FLAT) {
 893       if (data.force_persample_interp) {
 894          if (encSize == 8)
 895             code[loc + 1] |= 1 << 16;
 896          else
 897             code[loc + 0] |= 1 << 24;
 898       } else {
 899          if (encSize == 8)
 900             code[loc + 1] &= ~(1 << 16);
 901          else
 902             code[loc + 0] &= ~(1 << 24);
 903       }
 904    }
 905 }
 906
 907 void
 908 CodeEmitterNV50::emitINTERP(const Instruction *i)
 909 {
 910    code[0] = 0x80000000;
 911
 912    defId(i->def(0), 2);
 913    srcAddr8(i->src(0), 16);
 914
 915    if (i->encSize != 8 && i->getInterpMode() == NV50_IR_INTERP_FLAT) {
 916       code[0] |= 1 << 8;
 917    } else {
 918       if (i->op == OP_PINTERP) {
 919          code[0] |= 1 << 25;
 920          srcId(i->src(1), 9);
 921       }
 922       if (i->getSampleMode() == NV50_IR_INTERP_CENTROID)
 923          code[0] |= 1 << 24;
 924    }
 925
 926    if (i->encSize == 8) {
 927       if (i->getInterpMode() == NV50_IR_INTERP_FLAT)
 928          code[1] = 4 << 16;
 929       else
 930          code[1] = (code[0] & (3 << 24)) >> (24 - 16);
 931       code[0] &= ~0x03000000;
 932       code[0] |= 1;
 933       emitFlagsRd(i);
 934    }
 935
 936    addInterp(i->ipa, i->encSize, interpApply);
 937 }
 938
 939 void
 940 CodeEmitterNV50::emitMINMAX(const Instruction *i)
 941 {
 942    if (i->dType == TYPE_F64) {
 943       code[0] = 0xe0000000;
 944       code[1] = (i->op == OP_MIN) ? 0xa0000000 : 0xc0000000;
 945    } else {
 946       code[0] = 0x30000000;
 947       code[1] = 0x80000000;
 948       if (i->op == OP_MIN)
 949          code[1] |= 0x20000000;
 950
 951       switch (i->dType) {
 952       case TYPE_F32: code[0] |= 0x80000000; break;
 953       case TYPE_S32: code[1] |= 0x8c000000; break;
 954       case TYPE_U32: code[1] |= 0x84000000; break;
 955       case TYPE_S16: code[1] |= 0x80000000; break;
 956       case TYPE_U16: break;
 957       default:
 958          assert(0);
 959          break;
 960       }
 961    }
 962
 963    code[1] |= i->src(0).mod.abs() << 20;
 964    code[1] |= i->src(0).mod.neg() << 26;
 965    code[1] |= i->src(1).mod.abs() << 19;
 966    code[1] |= i->src(1).mod.neg() << 27;
 967
 968    emitForm_MAD(i);
 969 }
 970
 971 void
 972 CodeEmitterNV50::emitFMAD(const Instruction *i)
 973 {
 974    const int neg_mul = i->src(0).mod.neg() ^ i->src(1).mod.neg();
 975    const int neg_add = i->src(2).mod.neg();
 976
 977    code[0] = 0xe0000000;
 978
 979    if (i->src(1).getFile() == FILE_IMMEDIATE) {
 980       code[1] = 0;
 981       emitForm_IMM(i);
 982       code[0] |= neg_mul << 15;
 983       code[0] |= neg_add << 22;
 984       if (i->saturate)
 985          code[0] |= 1 << 8;
 986    } else
 987    if (i->encSize == 4) {
 988       emitForm_MUL(i);
 989       code[0] |= neg_mul << 15;
 990       code[0] |= neg_add << 22;
 991       if (i->saturate)
 992          code[0] |= 1 << 8;
 993    } else {
 994       code[1]  = neg_mul << 26;
 995       code[1] |= neg_add << 27;
 996       if (i->saturate)
 997          code[1] |= 1 << 29;
 998       emitForm_MAD(i);
 999    }
1000 }
1001
1002 void
1003 CodeEmitterNV50::emitDMAD(const Instruction *i)
1004 {
1005    const int neg_mul = i->src(0).mod.neg() ^ i->src(1).mod.neg();
1006    const int neg_add = i->src(2).mod.neg();
1007
1008    assert(i->encSize == 8);
1009    assert(!i->saturate);
1010
1011    code[1] = 0x40000000;
1012    code[0] = 0xe0000000;
1013
1014    code[1] |= neg_mul << 26;
1015    code[1] |= neg_add << 27;
1016
1017    roundMode_MAD(i);
1018
1019    emitForm_MAD(i);
1020 }
1021
1022 void
1023 CodeEmitterNV50::emitFADD(const Instruction *i)
1024 {
1025    const int neg0 = i->src(0).mod.neg();
1026    const int neg1 = i->src(1).mod.neg() ^ ((i->op == OP_SUB) ? 1 : 0);
1027
1028    code[0] = 0xb0000000;
1029
1030    assert(!(i->src(0).mod | i->src(1).mod).abs());
1031
1032    if (i->src(1).getFile() == FILE_IMMEDIATE) {
1033       code[1] = 0;
1034       emitForm_IMM(i);
1035       code[0] |= neg0 << 15;
1036       code[0] |= neg1 << 22;
1037       if (i->saturate)
1038          code[0] |= 1 << 8;
1039    } else
1040    if (i->encSize == 8) {
1041       code[1] = 0;
1042       emitForm_ADD(i);
1043       code[1] |= neg0 << 26;
1044       code[1] |= neg1 << 27;
1045       if (i->saturate)
1046          code[1] |= 1 << 29;
1047    } else {
1048       emitForm_MUL(i);
1049       code[0] |= neg0 << 15;
1050       code[0] |= neg1 << 22;
1051       if (i->saturate)
1052          code[0] |= 1 << 8;
1053    }
1054 }
1055
1056 void
1057 CodeEmitterNV50::emitDADD(const Instruction *i)
1058 {
1059    const int neg0 = i->src(0).mod.neg();
1060    const int neg1 = i->src(1).mod.neg() ^ ((i->op == OP_SUB) ? 1 : 0);
1061
1062    assert(!(i->src(0).mod | i->src(1).mod).abs());
1063    assert(!i->saturate);
1064    assert(i->encSize == 8);
1065
1066    code[1] = 0x60000000;
1067    code[0] = 0xe0000000;
1068
1069    emitForm_ADD(i);
1070
1071    code[1] |= neg0 << 26;
1072    code[1] |= neg1 << 27;
1073 }
1074
1075 void
1076 CodeEmitterNV50::emitUADD(const Instruction *i)
1077 {
1078    const int neg0 = i->src(0).mod.neg();
1079    const int neg1 = i->src(1).mod.neg() ^ ((i->op == OP_SUB) ? 1 : 0);
1080
1081    code[0] = 0x20008000;
1082
1083    if (i->src(1).getFile() == FILE_IMMEDIATE) {
1084       code[1] = 0;
1085       emitForm_IMM(i);
1086    } else
1087    if (i->encSize == 8) {
1088       code[0] = 0x20000000;
1089       code[1] = (typeSizeof(i->dType) == 2) ? 0 : 0x04000000;
1090       emitForm_ADD(i);
1091    } else {
1092       emitForm_MUL(i);
1093    }
1094    assert(!(neg0 && neg1));
1095    code[0] |= neg0 << 28;
1096    code[0] |= neg1 << 22;
1097
1098    if (i->flagsSrc >= 0) {
1099       // addc == sub | subr
1100       assert(!(code[0] & 0x10400000) && !i->getPredicate());
1101       code[0] |= 0x10400000;
1102       srcId(i->src(i->flagsSrc), 32 + 12);
1103    }
1104 }
1105
1106 void
1107 CodeEmitterNV50::emitAADD(const Instruction *i)
1108 {
1109    const int s = (i->op == OP_MOV) ? 0 : 1;
1110
1111    code[0] = 0xd0000001 | (i->getSrc(s)->reg.data.u16 << 9);
1112    code[1] = 0x20000000;
1113
1114    code[0] |= (DDATA(i->def(0)).id + 1) << 2;
1115
1116    emitFlagsRd(i);
1117
1118    if (s && i->srcExists(0))
1119       setARegBits(SDATA(i->src(0)).id + 1);
1120 }
1121
1122 void
1123 CodeEmitterNV50::emitIMUL(const Instruction *i)
1124 {
1125    code[0] = 0x40000000;
1126
1127    if (i->src(1).getFile() == FILE_IMMEDIATE) {
1128       if (i->sType == TYPE_S16)
1129          code[0] |= 0x8100;
1130       code[1] = 0;
1131       emitForm_IMM(i);
1132    } else
1133    if (i->encSize == 8) {
1134       code[1] = (i->sType == TYPE_S16) ? (0x8000 | 0x4000) : 0x0000;
1135       emitForm_MAD(i);
1136    } else {
1137       if (i->sType == TYPE_S16)
1138          code[0] |= 0x8100;
1139       emitForm_MUL(i);
1140    }
1141 }
1142
1143 void
1144 CodeEmitterNV50::emitFMUL(const Instruction *i)
1145 {
1146    const int neg = (i->src(0).mod ^ i->src(1).mod).neg();
1147
1148    code[0] = 0xc0000000;
1149
1150    if (i->src(1).getFile() == FILE_IMMEDIATE) {
1151       code[1] = 0;
1152       emitForm_IMM(i);
1153       if (neg)
1154          code[0] |= 0x8000;
1155       if (i->saturate)
1156          code[0] |= 1 << 8;
1157    } else
1158    if (i->encSize == 8) {
1159       code[1] = i->rnd == ROUND_Z ? 0x0000c000 : 0;
1160       if (neg)
1161          code[1] |= 0x08000000;
1162       if (i->saturate)
1163          code[1] |= 1 << 20;
1164       emitForm_MAD(i);
1165    } else {
1166       emitForm_MUL(i);
1167       if (neg)
1168          code[0] |= 0x8000;
1169       if (i->saturate)
1170          code[0] |= 1 << 8;
1171    }
1172 }
1173
1174 void
1175 CodeEmitterNV50::emitDMUL(const Instruction *i)
1176 {
1177    const int neg = (i->src(0).mod ^ i->src(1).mod).neg();
1178
1179    assert(!i->saturate);
1180    assert(i->encSize == 8);
1181
1182    code[1] = 0x80000000;
1183    code[0] = 0xe0000000;
1184
1185    if (neg)
1186       code[1] |= 0x08000000;
1187
1188    roundMode_CVT(i->rnd);
1189
1190    emitForm_MAD(i);
1191 }
1192
1193 void
1194 CodeEmitterNV50::emitIMAD(const Instruction *i)
1195 {
1196    int mode;
1197    code[0] = 0x60000000;
1198
1199    assert(!i->src(0).mod && !i->src(1).mod && !i->src(2).mod);
1200    if (!isSignedType(i->sType))
1201       mode = 0;
1202    else if (i->saturate)
1203       mode = 2;
1204    else
1205       mode = 1;
1206
1207    if (i->src(1).getFile() == FILE_IMMEDIATE) {
1208       code[1] = 0;
1209       emitForm_IMM(i);
1210       code[0] |= (mode & 1) << 8 | (mode & 2) << 14;
1211       if (i->flagsSrc >= 0) {
1212          assert(!(code[0] & 0x10400000));
1213          assert(SDATA(i->src(i->flagsSrc)).id == 0);
1214          code[0] |= 0x10400000;
1215       }
1216    } else
1217    if (i->encSize == 4) {
1218       emitForm_MUL(i);
1219       code[0] |= (mode & 1) << 8 | (mode & 2) << 14;
1220       if (i->flagsSrc >= 0) {
1221          assert(!(code[0] & 0x10400000));
1222          assert(SDATA(i->src(i->flagsSrc)).id == 0);
1223          code[0] |= 0x10400000;
1224       }
1225    } else {
1226       code[1] = mode << 29;
1227       emitForm_MAD(i);
1228
1229       if (i->flagsSrc >= 0) {
1230          // add with carry from $cX
1231          assert(!(code[1] & 0x0c000000) && !i->getPredicate());
1232          code[1] |= 0xc << 24;
1233          srcId(i->src(i->flagsSrc), 32 + 12);
1234       }
1235    }
1236 }
1237
1238 void
1239 CodeEmitterNV50::emitISAD(const Instruction *i)
1240 {
1241    if (i->encSize == 8) {
1242       code[0] = 0x50000000;
1243       switch (i->sType) {
1244       case TYPE_U32: code[1] = 0x04000000; break;
1245       case TYPE_S32: code[1] = 0x0c000000; break;
1246       case TYPE_U16: code[1] = 0x00000000; break;
1247       case TYPE_S16: code[1] = 0x08000000; break;
1248       default:
1249          assert(0);
1250          break;
1251       }
1252       emitForm_MAD(i);
1253    } else {
1254       switch (i->sType) {
1255       case TYPE_U32: code[0] = 0x50008000; break;
1256       case TYPE_S32: code[0] = 0x50008100; break;
1257       case TYPE_U16: code[0] = 0x50000000; break;
1258       case TYPE_S16: code[0] = 0x50000100; break;
1259       default:
1260          assert(0);
1261          break;
1262       }
1263       emitForm_MUL(i);
1264    }
1265 }
1266
1267 void
1268 CodeEmitterNV50::emitSET(const Instruction *i)
1269 {
1270    code[0] = 0x30000000;
1271    code[1] = 0x60000000;
1272
1273    switch (i->sType) {
1274    case TYPE_F64:
1275       code[0] = 0xe0000000;
1276       code[1] = 0xe0000000;
1277       break;
1278    case TYPE_F32: code[0] |= 0x80000000; break;
1279    case TYPE_S32: code[1] |= 0x0c000000; break;
1280    case TYPE_U32: code[1] |= 0x04000000; break;
1281    case TYPE_S16: code[1] |= 0x08000000; break;
1282    case TYPE_U16: break;
1283    default:
1284       assert(0);
1285       break;
1286    }
1287
1288    emitCondCode(i->asCmp()->setCond, i->sType, 32 + 14);
1289
1290    if (i->src(0).mod.neg()) code[1] |= 0x04000000;
1291    if (i->src(1).mod.neg()) code[1] |= 0x08000000;
1292    if (i->src(0).mod.abs()) code[1] |= 0x00100000;
1293    if (i->src(1).mod.abs()) code[1] |= 0x00080000;
1294
1295    emitForm_MAD(i);
1296 }
1297
1298 void
1299 CodeEmitterNV50::roundMode_CVT(RoundMode rnd)
1300 {
1301    switch (rnd) {
1302    case ROUND_NI: code[1] |= 0x08000000; break;
1303    case ROUND_M:  code[1] |= 0x00020000; break;
1304    case ROUND_MI: code[1] |= 0x08020000; break;
1305    case ROUND_P:  code[1] |= 0x00040000; break;
1306    case ROUND_PI: code[1] |= 0x08040000; break;
1307    case ROUND_Z:  code[1] |= 0x00060000; break;
1308    case ROUND_ZI: code[1] |= 0x08060000; break;
1309    default:
1310       assert(rnd == ROUND_N);
1311       break;
1312    }
1313 }
1314
1315 void
1316 CodeEmitterNV50::emitCVT(const Instruction *i)
1317 {
1318    const bool f2f = isFloatType(i->dType) && isFloatType(i->sType);
1319    RoundMode rnd;
1320    DataType dType;
1321
1322    switch (i->op) {
1323    case OP_CEIL:  rnd = f2f ? ROUND_PI : ROUND_P; break;
1324    case OP_FLOOR: rnd = f2f ? ROUND_MI : ROUND_M; break;
1325    case OP_TRUNC: rnd = f2f ? ROUND_ZI : ROUND_Z; break;
1326    default:
1327       rnd = i->rnd;
1328       break;
1329    }
1330
1331    if (i->op == OP_NEG && i->dType == TYPE_U32)
1332       dType = TYPE_S32;
1333    else
1334       dType = i->dType;
1335
1336    code[0] = 0xa0000000;
1337
1338    switch (dType) {
1339    case TYPE_F64:
1340       switch (i->sType) {
1341       case TYPE_F64: code[1] = 0xc4404000; break;
1342       case TYPE_S64: code[1] = 0x44414000; break;
1343       case TYPE_U64: code[1] = 0x44404000; break;
1344       case TYPE_F32: code[1] = 0xc4400000; break;
1345       case TYPE_S32: code[1] = 0x44410000; break;
1346       case TYPE_U32: code[1] = 0x44400000; break;
1347       default:
1348          assert(0);
1349          break;
1350       }
1351       break;
1352    case TYPE_S64:
1353       switch (i->sType) {
1354       case TYPE_F64: code[1] = 0x8c404000; break;
1355       case TYPE_F32: code[1] = 0x8c400000; break;
1356       default:
1357          assert(0);
1358          break;
1359       }
1360       break;
1361    case TYPE_U64:
1362       switch (i->sType) {
1363       case TYPE_F64: code[1] = 0x84404000; break;
1364       case TYPE_F32: code[1] = 0x84400000; break;
1365       default:
1366          assert(0);
1367          break;
1368       }
1369       break;
1370    case TYPE_F32:
1371       switch (i->sType) {
1372       case TYPE_F64: code[1] = 0xc0404000; break;
1373       case TYPE_S64: code[1] = 0x40414000; break;
1374       case TYPE_U64: code[1] = 0x40404000; break;
1375       case TYPE_F32: code[1] = 0xc4004000; break;
1376       case TYPE_S32: code[1] = 0x44014000; break;
1377       case TYPE_U32: code[1] = 0x44004000; break;
1378       case TYPE_F16: code[1] = 0xc4000000; break;
1379       case TYPE_U16: code[1] = 0x44000000; break;
1380       default:
1381          assert(0);
1382          break;
1383       }
1384       break;
1385    case TYPE_S32:
1386       switch (i->sType) {
1387       case TYPE_F64: code[1] = 0x88404000; break;
1388       case TYPE_F32: code[1] = 0x8c004000; break;
1389       case TYPE_S32: code[1] = 0x0c014000; break;
1390       case TYPE_U32: code[1] = 0x0c004000; break;
1391       case TYPE_F16: code[1] = 0x8c000000; break;
1392       case TYPE_S16: code[1] = 0x0c010000; break;
1393       case TYPE_U16: code[1] = 0x0c000000; break;
1394       case TYPE_S8:  code[1] = 0x0c018000; break;
1395       case TYPE_U8:  code[1] = 0x0c008000; break;
1396       default:
1397          assert(0);
1398          break;
1399       }
1400       break;
1401    case TYPE_U32:
1402       switch (i->sType) {
1403       case TYPE_F64: code[1] = 0x80404000; break;
1404       case TYPE_F32: code[1] = 0x84004000; break;
1405       case TYPE_S32: code[1] = 0x04014000; break;
1406       case TYPE_U32: code[1] = 0x04004000; break;
1407       case TYPE_F16: code[1] = 0x84000000; break;
1408       case TYPE_S16: code[1] = 0x04010000; break;
1409       case TYPE_U16: code[1] = 0x04000000; break;
1410       case TYPE_S8:  code[1] = 0x04018000; break;
1411       case TYPE_U8:  code[1] = 0x04008000; break;
1412       default:
1413          assert(0);
1414          break;
1415       }
1416       break;
1417    case TYPE_S16:
1418    case TYPE_U16:
1419    case TYPE_S8:
1420    case TYPE_U8:
1421    default:
1422       assert(0);
1423       break;
1424    }
1425    if (typeSizeof(i->sType) == 1 && i->getSrc(0)->reg.size == 4)
1426       code[1] |= 0x00004000;
1427
1428    roundMode_CVT(rnd);
1429
1430    switch (i->op) {
1431    case OP_ABS: code[1] |= 1 << 20; break;
1432    case OP_SAT: code[1] |= 1 << 19; break;
1433    case OP_NEG: code[1] |= 1 << 29; break;
1434    default:
1435       break;
1436    }
1437    code[1] ^= i->src(0).mod.neg() << 29;
1438    code[1] |= i->src(0).mod.abs() << 20;
1439    if (i->saturate)
1440       code[1] |= 1 << 19;
1441
1442    assert(i->op != OP_ABS || !i->src(0).mod.neg());
1443
1444    emitForm_MAD(i);
1445 }
1446
1447 void
1448 CodeEmitterNV50::emitPreOp(const Instruction *i)
1449 {
1450    code[0] = 0xb0000000;
1451    code[1] = (i->op == OP_PREEX2) ? 0xc0004000 : 0xc0000000;
1452
1453    code[1] |= i->src(0).mod.abs() << 20;
1454    code[1] |= i->src(0).mod.neg() << 26;
1455
1456    emitForm_MAD(i);
1457 }
1458
1459 void
1460 CodeEmitterNV50::emitSFnOp(const Instruction *i, uint8_t subOp)
1461 {
1462    code[0] = 0x90000000;
1463
1464    if (i->encSize == 4) {
1465       assert(i->op == OP_RCP);
1466       assert(!i->saturate);
1467       code[0] |= i->src(0).mod.abs() << 15;
1468       code[0] |= i->src(0).mod.neg() << 22;
1469       emitForm_MUL(i);
1470    } else {
1471       code[1] = subOp << 29;
1472       code[1] |= i->src(0).mod.abs() << 20;
1473       code[1] |= i->src(0).mod.neg() << 26;
1474       if (i->saturate) {
1475          assert(subOp == 6 && i->op == OP_EX2);
1476          code[1] |= 1 << 27;
1477       }
1478       emitForm_MAD(i);
1479    }
1480 }
1481
1482 void
1483 CodeEmitterNV50::emitNOT(const Instruction *i)
1484 {
1485    code[0] = 0xd0000000;
1486    code[1] = 0x0002c000;
1487
1488    switch (i->sType) {
1489    case TYPE_U32:
1490    case TYPE_S32:
1491       code[1] |= 0x04000000;
1492       break;
1493    default:
1494       break;
1495    }
1496    emitForm_MAD(i);
1497    setSrc(i, 0, 1);
1498 }
1499
1500 void
1501 CodeEmitterNV50::emitLogicOp(const Instruction *i)
1502 {
1503    code[0] = 0xd0000000;
1504    code[1] = 0;
1505
1506    if (i->src(1).getFile() == FILE_IMMEDIATE) {
1507       switch (i->op) {
1508       case OP_OR:  code[0] |= 0x0100; break;
1509       case OP_XOR: code[0] |= 0x8000; break;
1510       default:
1511          assert(i->op == OP_AND);
1512          break;
1513       }
1514       if (i->src(0).mod & Modifier(NV50_IR_MOD_NOT))
1515          code[0] |= 1 << 22;
1516
1517       emitForm_IMM(i);
1518    } else {
1519       switch (i->op) {
1520       case OP_AND: code[1] = 0x04000000; break;
1521       case OP_OR:  code[1] = 0x04004000; break;
1522       case OP_XOR: code[1] = 0x04008000; break;
1523       default:
1524          assert(0);
1525          break;
1526       }
1527       if (i->src(0).mod & Modifier(NV50_IR_MOD_NOT))
1528          code[1] |= 1 << 16;
1529       if (i->src(1).mod & Modifier(NV50_IR_MOD_NOT))
1530          code[1] |= 1 << 17;
1531
1532       emitForm_MAD(i);
1533    }
1534 }
1535
1536 void
1537 CodeEmitterNV50::emitARL(const Instruction *i, unsigned int shl)
1538 {
1539    code[0] = 0x00000001 | (shl << 16);
1540    code[1] = 0xc0000000;
1541
1542    code[0] |= (DDATA(i->def(0)).id + 1) << 2;
1543
1544    setSrcFileBits(i, NV50_OP_ENC_IMM);
1545    setSrc(i, 0, 0);
1546    emitFlagsRd(i);
1547 }
1548
1549 void
1550 CodeEmitterNV50::emitShift(const Instruction *i)
1551 {
1552    if (i->def(0).getFile() == FILE_ADDRESS) {
1553       assert(i->srcExists(1) && i->src(1).getFile() == FILE_IMMEDIATE);
1554       emitARL(i, i->getSrc(1)->reg.data.u32 & 0x3f);
1555    } else {
1556       code[0] = 0x30000001;
1557       code[1] = (i->op == OP_SHR) ? 0xe4000000 : 0xc4000000;
1558       if (i->op == OP_SHR && isSignedType(i->sType))
1559           code[1] |= 1 << 27;
1560
1561       if (i->src(1).getFile() == FILE_IMMEDIATE) {
1562          code[1] |= 1 << 20;
1563          code[0] |= (i->getSrc(1)->reg.data.u32 & 0x7f) << 16;
1564          defId(i->def(0), 2);
1565          srcId(i->src(0), 9);
1566          emitFlagsRd(i);
1567       } else {
1568          emitForm_MAD(i);
1569       }
1570    }
1571 }
1572
1573 void
1574 CodeEmitterNV50::emitOUT(const Instruction *i)
1575 {
1576    code[0] = (i->op == OP_EMIT) ? 0xf0000201 : 0xf0000401;
1577    code[1] = 0xc0000000;
1578
1579    emitFlagsRd(i);
1580 }
1581
1582 void
1583 CodeEmitterNV50::emitTEX(const TexInstruction *i)
1584 {
1585    code[0] = 0xf0000001;
1586    code[1] = 0x00000000;
1587
1588    switch (i->op) {
1589    case OP_TXB:
1590       code[1] = 0x20000000;
1591       break;
1592    case OP_TXL:
1593       code[1] = 0x40000000;
1594       break;
1595    case OP_TXF:
1596       code[0] |= 0x01000000;
1597       break;
1598    case OP_TXG:
1599       code[0] |= 0x01000000;
1600       code[1] = 0x80000000;
1601       break;
1602    case OP_TXLQ:
1603       code[1] = 0x60020000;
1604       break;
1605    default:
1606       assert(i->op == OP_TEX);
1607       break;
1608    }
1609
1610    code[0] |= i->tex.r << 9;
1611    code[0] |= i->tex.s << 17;
1612
1613    int argc = i->tex.target.getArgCount();
1614
1615    if (i->op == OP_TXB || i->op == OP_TXL || i->op == OP_TXF)
1616       argc += 1;
1617    if (i->tex.target.isShadow())
1618       argc += 1;
1619    assert(argc <= 4);
1620
1621    code[0] |= (argc - 1) << 22;
1622
1623    if (i->tex.target.isCube()) {
1624       code[0] |= 0x08000000;
1625    } else
1626    if (i->tex.useOffsets) {
1627       code[1] |= (i->tex.offset[0] & 0xf) << 24;
1628       code[1] |= (i->tex.offset[1] & 0xf) << 20;
1629       code[1] |= (i->tex.offset[2] & 0xf) << 16;
1630    }
1631
1632    code[0] |= (i->tex.mask & 0x3) << 25;
1633    code[1] |= (i->tex.mask & 0xc) << 12;
1634
1635    if (i->tex.liveOnly)
1636       code[1] |= 1 << 2;
1637    if (i->tex.derivAll)
1638       code[1] |= 1 << 3;
1639
1640    defId(i->def(0), 2);
1641
1642    emitFlagsRd(i);
1643 }
1644
1645 void
1646 CodeEmitterNV50::emitTXQ(const TexInstruction *i)
1647 {
1648    assert(i->tex.query == TXQ_DIMS);
1649
1650    code[0] = 0xf0000001;
1651    code[1] = 0x60000000;
1652
1653    code[0] |= i->tex.r << 9;
1654    code[0] |= i->tex.s << 17;
1655
1656    code[0] |= (i->tex.mask & 0x3) << 25;
1657    code[1] |= (i->tex.mask & 0xc) << 12;
1658
1659    defId(i->def(0), 2);
1660
1661    emitFlagsRd(i);
1662 }
1663
1664 void
1665 CodeEmitterNV50::emitTEXPREP(const TexInstruction *i)
1666 {
1667    code[0] = 0xf8000001 | (3 << 22) | (i->tex.s << 17) | (i->tex.r << 9);
1668    code[1] = 0x60010000;
1669
1670    code[0] |= (i->tex.mask & 0x3) << 25;
1671    code[1] |= (i->tex.mask & 0xc) << 12;
1672    defId(i->def(0), 2);
1673
1674    emitFlagsRd(i);
1675 }
1676
1677 void
1678 CodeEmitterNV50::emitPRERETEmu(const FlowInstruction *i)
1679 {
1680    uint32_t pos = i->target.bb->binPos + 8; // +8 to skip an op */
1681
1682    code[0] = 0x10000003; // bra
1683    code[1] = 0x00000780; // always
1684
1685    switch (i->subOp) {
1686    case NV50_IR_SUBOP_EMU_PRERET + 0: // bra to the call
1687       break;
1688    case NV50_IR_SUBOP_EMU_PRERET + 1: // bra to skip the call
1689       pos += 8;
1690       break;
1691    default:
1692       assert(i->subOp == (NV50_IR_SUBOP_EMU_PRERET + 2));
1693       code[0] = 0x20000003; // call
1694       code[1] = 0x00000000; // no predicate
1695       break;
1696    }
1697    addReloc(RelocEntry::TYPE_CODE, 0, pos, 0x07fff800, 9);
1698    addReloc(RelocEntry::TYPE_CODE, 1, pos, 0x000fc000, -4);
1699 }
1700
1701 void
1702 CodeEmitterNV50::emitFlow(const Instruction *i, uint8_t flowOp)
1703 {
1704    const FlowInstruction *f = i->asFlow();
1705    bool hasPred = false;
1706    bool hasTarg = false;
1707
1708    code[0] = 0x00000003 | (flowOp << 28);
1709    code[1] = 0x00000000;
1710
1711    switch (i->op) {
1712    case OP_BRA:
1713       hasPred = true;
1714       hasTarg = true;
1715       break;
1716    case OP_BREAK:
1717    case OP_BRKPT:
1718    case OP_DISCARD:
1719    case OP_RET:
1720       hasPred = true;
1721       break;
1722    case OP_CALL:
1723    case OP_PREBREAK:
1724    case OP_JOINAT:
1725       hasTarg = true;
1726       break;
1727    case OP_PRERET:
1728       hasTarg = true;
1729       if (i->subOp >= NV50_IR_SUBOP_EMU_PRERET) {
1730          emitPRERETEmu(f);
1731          return;
1732       }
1733       break;
1734    default:
1735       break;
1736    }
1737
1738    if (hasPred)
1739       emitFlagsRd(i);
1740
1741    if (hasTarg && f) {
1742       uint32_t pos;
1743
1744       if (f->op == OP_CALL) {
1745          if (f->builtin) {
1746             pos = targNV50->getBuiltinOffset(f->target.builtin);
1747          } else {
1748             pos = f->target.fn->binPos;
1749          }
1750       } else {
1751          pos = f->target.bb->binPos;
1752       }
1753
1754       code[0] |= ((pos >>  2) & 0xffff) << 11;
1755       code[1] |= ((pos >> 18) & 0x003f) << 14;
1756
1757       RelocEntry::Type relocTy;
1758
1759       relocTy = f->builtin ? RelocEntry::TYPE_BUILTIN : RelocEntry::TYPE_CODE;
1760
1761       addReloc(relocTy, 0, pos, 0x07fff800, 9);
1762       addReloc(relocTy, 1, pos, 0x000fc000, -4);
1763    }
1764 }
1765
1766 void
1767 CodeEmitterNV50::emitBAR(const Instruction *i)
1768 {
1769    ImmediateValue *barId = i->getSrc(0)->asImm();
1770    assert(barId);
1771
1772    code[0] = 0x82000003 | (barId->reg.data.u32 << 21);
1773    code[1] = 0x00004000;
1774
1775    if (i->subOp == NV50_IR_SUBOP_BAR_SYNC)
1776       code[0] |= 1 << 26;
1777 }
1778
1779 void
1780 CodeEmitterNV50::emitATOM(const Instruction *i)
1781 {
1782    uint8_t subOp;
1783    switch (i->subOp) {
1784    case NV50_IR_SUBOP_ATOM_ADD:  subOp = 0x0; break;
1785    case NV50_IR_SUBOP_ATOM_MIN:  subOp = 0x7; break;
1786    case NV50_IR_SUBOP_ATOM_MAX:  subOp = 0x6; break;
1787    case NV50_IR_SUBOP_ATOM_INC:  subOp = 0x4; break;
1788    case NV50_IR_SUBOP_ATOM_DEC:  subOp = 0x5; break;
1789    case NV50_IR_SUBOP_ATOM_AND:  subOp = 0xa; break;
1790    case NV50_IR_SUBOP_ATOM_OR:   subOp = 0xb; break;
1791    case NV50_IR_SUBOP_ATOM_XOR:  subOp = 0xc; break;
1792    case NV50_IR_SUBOP_ATOM_CAS:  subOp = 0x2; break;
1793    case NV50_IR_SUBOP_ATOM_EXCH: subOp = 0x1; break;
1794    default:
1795       assert(!"invalid subop");
1796       return;
1797    }
1798    code[0] = 0xd0000001;
1799    code[1] = 0xe0c00000 | (subOp << 2);
1800    if (isSignedType(i->dType))
1801       code[1] |= 1 << 21;
1802
1803    // args
1804    emitFlagsRd(i);
1805    setDst(i, 0);
1806    setSrc(i, 1, 1);
1807    if (i->subOp == NV50_IR_SUBOP_ATOM_CAS)
1808       setSrc(i, 2, 2);
1809
1810    // g[] pointer
1811    code[0] |= i->getSrc(0)->reg.fileIndex << 23;
1812    srcId(i->getIndirect(0, 0), 9);
1813 }
1814
1815 bool
1816 CodeEmitterNV50::emitInstruction(Instruction *insn)
1817 {
1818    if (!insn->encSize) {
1819       ERROR("skipping unencodable instruction: "); insn->print();
1820       return false;
1821    } else
1822    if (codeSize + insn->encSize > codeSizeLimit) {
1823       ERROR("code emitter output buffer too small\n");
1824       return false;
1825    }
1826
1827    if (insn->bb->getProgram()->dbgFlags & NV50_IR_DEBUG_BASIC) {
1828       INFO("EMIT: "); insn->print();
1829    }
1830
1831    switch (insn->op) {
1832    case OP_MOV:
1833       emitMOV(insn);
1834       break;
1835    case OP_EXIT:
1836    case OP_NOP:
1837    case OP_JOIN:
1838       emitNOP();
1839       break;
1840    case OP_VFETCH:
1841    case OP_LOAD:
1842       emitLOAD(insn);
1843       break;
1844    case OP_EXPORT:
1845    case OP_STORE:
1846       emitSTORE(insn);
1847       break;
1848    case OP_PFETCH:
1849       emitPFETCH(insn);
1850       break;
1851    case OP_RDSV:
1852       emitRDSV(insn);
1853       break;
1854    case OP_LINTERP:
1855    case OP_PINTERP:
1856       emitINTERP(insn);
1857       break;
1858    case OP_ADD:
1859    case OP_SUB:
1860       if (insn->dType == TYPE_F64)
1861          emitDADD(insn);
1862       else if (isFloatType(insn->dType))
1863          emitFADD(insn);
1864       else if (insn->getDef(0)->reg.file == FILE_ADDRESS)
1865          emitAADD(insn);
1866       else
1867          emitUADD(insn);
1868       break;
1869    case OP_MUL:
1870       if (insn->dType == TYPE_F64)
1871          emitDMUL(insn);
1872       else if (isFloatType(insn->dType))
1873          emitFMUL(insn);
1874       else
1875          emitIMUL(insn);
1876       break;
1877    case OP_MAD:
1878    case OP_FMA:
1879       if (insn->dType == TYPE_F64)
1880          emitDMAD(insn);
1881       else if (isFloatType(insn->dType))
1882          emitFMAD(insn);
1883       else
1884          emitIMAD(insn);
1885       break;
1886    case OP_SAD:
1887       emitISAD(insn);
1888       break;
1889    case OP_NOT:
1890       emitNOT(insn);
1891       break;
1892    case OP_AND:
1893    case OP_OR:
1894    case OP_XOR:
1895       emitLogicOp(insn);
1896       break;
1897    case OP_SHL:
1898    case OP_SHR:
1899       emitShift(insn);
1900       break;
1901    case OP_SET:
1902       emitSET(insn);
1903       break;
1904    case OP_MIN:
1905    case OP_MAX:
1906       emitMINMAX(insn);
1907       break;
1908    case OP_CEIL:
1909    case OP_FLOOR:
1910    case OP_TRUNC:
1911    case OP_ABS:
1912    case OP_NEG:
1913    case OP_SAT:
1914       emitCVT(insn);
1915       break;
1916    case OP_CVT:
1917       if (insn->def(0).getFile() == FILE_ADDRESS)
1918          emitARL(insn, 0);
1919       else
1920       if (insn->def(0).getFile() == FILE_FLAGS ||
1921           insn->src(0).getFile() == FILE_FLAGS ||
1922           insn->src(0).getFile() == FILE_ADDRESS)
1923          emitMOV(insn);
1924       else
1925          emitCVT(insn);
1926       break;
1927    case OP_RCP:
1928       emitSFnOp(insn, 0);
1929       break;
1930    case OP_RSQ:
1931       emitSFnOp(insn, 2);
1932       break;
1933    case OP_LG2:
1934       emitSFnOp(insn, 3);
1935       break;
1936    case OP_SIN:
1937       emitSFnOp(insn, 4);
1938       break;
1939    case OP_COS:
1940       emitSFnOp(insn, 5);
1941       break;
1942    case OP_EX2:
1943       emitSFnOp(insn, 6);
1944       break;
1945    case OP_PRESIN:
1946    case OP_PREEX2:
1947       emitPreOp(insn);
1948       break;
1949    case OP_TEX:
1950    case OP_TXB:
1951    case OP_TXL:
1952    case OP_TXF:
1953    case OP_TXG:
1954    case OP_TXLQ:
1955       emitTEX(insn->asTex());
1956       break;
1957    case OP_TXQ:
1958       emitTXQ(insn->asTex());
1959       break;
1960    case OP_TEXPREP:
1961       emitTEXPREP(insn->asTex());
1962       break;
1963    case OP_EMIT:
1964    case OP_RESTART:
1965       emitOUT(insn);
1966       break;
1967    case OP_DISCARD:
1968       emitFlow(insn, 0x0);
1969       break;
1970    case OP_BRA:
1971       emitFlow(insn, 0x1);
1972       break;
1973    case OP_CALL:
1974       emitFlow(insn, 0x2);
1975       break;
1976    case OP_RET:
1977       emitFlow(insn, 0x3);
1978       break;
1979    case OP_PREBREAK:
1980       emitFlow(insn, 0x4);
1981       break;
1982    case OP_BREAK:
1983       emitFlow(insn, 0x5);
1984       break;
1985    case OP_QUADON:
1986       emitFlow(insn, 0x6);
1987       break;
1988    case OP_QUADPOP:
1989       emitFlow(insn, 0x7);
1990       break;
1991    case OP_JOINAT:
1992       emitFlow(insn, 0xa);
1993       break;
1994    case OP_PRERET:
1995       emitFlow(insn, 0xd);
1996       break;
1997    case OP_QUADOP:
1998       emitQUADOP(insn, insn->lanes, insn->subOp);
1999       break;
2000    case OP_DFDX:
2001       emitQUADOP(insn, 4, insn->src(0).mod.neg() ? 0x66 : 0x99);
2002       break;
2003    case OP_DFDY:
2004       emitQUADOP(insn, 5, insn->src(0).mod.neg() ? 0x5a : 0xa5);
2005       break;
2006    case OP_ATOM:
2007       emitATOM(insn);
2008       break;
2009    case OP_BAR:
2010       emitBAR(insn);
2011       break;
2012    case OP_PHI:
2013    case OP_UNION:
2014    case OP_CONSTRAINT:
2015       ERROR("operation should have been eliminated\n");
2016       return false;
2017    case OP_EXP:
2018    case OP_LOG:
2019    case OP_SQRT:
2020    case OP_POW:
2021    case OP_SELP:
2022    case OP_SLCT:
2023    case OP_TXD:
2024    case OP_PRECONT:
2025    case OP_CONT:
2026    case OP_POPCNT:
2027    case OP_INSBF:
2028    case OP_EXTBF:
2029       ERROR("operation should have been lowered\n");
2030       return false;
2031    default:
2032       ERROR("unknown op: %u\n", insn->op);
2033       return false;
2034    }
2035    if (insn->join || insn->op == OP_JOIN)
2036       code[1] |= 0x2;
2037    else
2038    if (insn->exit || insn->op == OP_EXIT)
2039       code[1] |= 0x1;
2040
2041    assert((insn->encSize == 8) == (code[0] & 1));
2042
2043    code += insn->encSize / 4;
2044    codeSize += insn->encSize;
2045    return true;
2046 }
2047
2048 uint32_t
2049 CodeEmitterNV50::getMinEncodingSize(const Instruction *i) const
2050 {
2051    const Target::OpInfo &info = targ->getOpInfo(i);
2052
2053    if (info.minEncSize > 4 || i->dType == TYPE_F64)
2054       return 8;
2055
2056    // check constraints on dst and src operands
2057    for (int d = 0; i->defExists(d); ++d) {
2058       if (i->def(d).rep()->reg.data.id > 63 ||
2059           i->def(d).rep()->reg.file != FILE_GPR)
2060          return 8;
2061    }
2062
2063    for (int s = 0; i->srcExists(s); ++s) {
2064       DataFile sf = i->src(s).getFile();
2065       if (sf != FILE_GPR)
2066          if (sf != FILE_SHADER_INPUT || progType != Program::TYPE_FRAGMENT)
2067             return 8;
2068       if (i->src(s).rep()->reg.data.id > 63)
2069          return 8;
2070    }
2071
2072    // check modifiers & rounding
2073    if (i->join || i->lanes != 0xf || i->exit)
2074       return 8;
2075    if (i->op == OP_MUL && i->rnd != ROUND_N)
2076       return 8;
2077
2078    if (i->asTex())
2079       return 8; // TODO: short tex encoding
2080
2081    // check constraints on short MAD
2082    if (info.srcNr >= 2 && i->srcExists(2)) {
2083       if (!i->defExists(0) ||
2084           (i->flagsSrc >= 0 && SDATA(i->src(i->flagsSrc)).id > 0) ||
2085           DDATA(i->def(0)).id != SDATA(i->src(2)).id)
2086          return 8;
2087    }
2088
2089    return info.minEncSize;
2090 }
2091
2092 // Change the encoding size of an instruction after BBs have been scheduled.
2093 static void
2094 makeInstructionLong(Instruction *insn)
2095 {
2096    if (insn->encSize == 8)
2097       return;
2098    Function *fn = insn->bb->getFunction();
2099    int n = 0;
2100    int adj = 4;
2101
2102    for (Instruction *i = insn->next; i && i->encSize == 4; ++n, i = i->next);
2103
2104    if (n & 1) {
2105       adj = 8;
2106       insn->next->encSize = 8;
2107    } else
2108    if (insn->prev && insn->prev->encSize == 4) {
2109       adj = 8;
2110       insn->prev->encSize = 8;
2111    }
2112    insn->encSize = 8;
2113
2114    for (int i = fn->bbCount - 1; i >= 0 && fn->bbArray[i] != insn->bb; --i) {
2115       fn->bbArray[i]->binPos += adj;
2116    }
2117    fn->binSize += adj;
2118    insn->bb->binSize += adj;
2119 }
2120
2121 static bool
2122 trySetExitModifier(Instruction *insn)
2123 {
2124    if (insn->op == OP_DISCARD ||
2125        insn->op == OP_QUADON ||
2126        insn->op == OP_QUADPOP)
2127       return false;
2128    for (int s = 0; insn->srcExists(s); ++s)
2129       if (insn->src(s).getFile() == FILE_IMMEDIATE)
2130          return false;
2131    if (insn->asFlow()) {
2132       if (insn->op == OP_CALL) // side effects !
2133          return false;
2134       if (insn->getPredicate()) // cannot do conditional exit (or can we ?)
2135          return false;
2136       insn->op = OP_EXIT;
2137    }
2138    insn->exit = 1;
2139    makeInstructionLong(insn);
2140    return true;
2141 }
2142
2143 static void
2144 replaceExitWithModifier(Function *func)
2145 {
2146    BasicBlock *epilogue = BasicBlock::get(func->cfgExit);
2147
2148    if (!epilogue->getExit() ||
2149        epilogue->getExit()->op != OP_EXIT) // only main will use OP_EXIT
2150       return;
2151
2152    if (epilogue->getEntry()->op != OP_EXIT) {
2153       Instruction *insn = epilogue->getExit()->prev;
2154       if (!insn || !trySetExitModifier(insn))
2155          return;
2156       insn->exit = 1;
2157    } else {
2158       for (Graph::EdgeIterator ei = func->cfgExit->incident();
2159            !ei.end(); ei.next()) {
2160          BasicBlock *bb = BasicBlock::get(ei.getNode());
2161          Instruction *i = bb->getExit();
2162
2163          if (!i || !trySetExitModifier(i))
2164             return;
2165       }
2166    }
2167
2168    int adj = epilogue->getExit()->encSize;
2169    epilogue->binSize -= adj;
2170    func->binSize -= adj;
2171    delete_Instruction(func->getProgram(), epilogue->getExit());
2172
2173    // There may be BB's that are laid out after the exit block
2174    for (int i = func->bbCount - 1; i >= 0 && func->bbArray[i] != epilogue; --i) {
2175       func->bbArray[i]->binPos -= adj;
2176    }
2177 }
2178
2179 void
2180 CodeEmitterNV50::prepareEmission(Function *func)
2181 {
2182    CodeEmitter::prepareEmission(func);
2183
2184    replaceExitWithModifier(func);
2185 }
2186
2187 CodeEmitterNV50::CodeEmitterNV50(const TargetNV50 *target) :
2188    CodeEmitter(target), targNV50(target)
2189 {
2190    targ = target; // specialized
2191    code = NULL;
2192    codeSize = codeSizeLimit = 0;
2193    relocInfo = NULL;
2194 }
2195
2196 CodeEmitter *
2197 TargetNV50::getCodeEmitter(Program::Type type)
2198 {
2199    CodeEmitterNV50 *emit = new CodeEmitterNV50(this);
2200    emit->setProgramType(type);
2201    return emit;
2202 }
2203
2204 } // namespace nv50_ir