Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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