~ubuntu-branches/ubuntu/quantal/mesa/quantal-proposed

  field bits<32> Inst;

  bit Trig = 0;

  bit Op3 = 0;

 

  let Inst = inst;

  let Namespace = "AMDGPU";

  // Vector instructions are instructions that must fill all slots in an

  // instruction group

  let TSFlags{6} = isVector;

}

 

class InstR600ISA <dag outs, dag ins, string asm, list<dag> pattern> :

 

 

 

           "PRED $dst, $src0, $src1",

{

  let DisableEncoding = "$src0";

  field bits<32> Inst;

  bits<32> src1;

 

  let Inst = src1;

}

 

def JUMP : InstR600 <0x10,

          (outs),

          (ins brtarget:$target, R600_Pred:$p),

  bits<4>  COMP_MASK;

  bits<4>  BURST_COUNT;

  bits<1>  VPM;

  bits<1>  MARK;

  bits<1>  BARRIER;

 

  let Inst{3-0}   = rat_id;

  let Inst{9-4}   = rat_inst;

  let Inst{12-11} = RIM;

  let Inst{14-13} = TYPE;

  let Inst{21-15} = RW_GPR;

  let Inst{29-23} = INDEX_GPR;

  let Inst{31-30} = ELEM_SIZE;

 

  let Inst{43-32} = ARRAY_SIZE;

  let Inst{47-44} = COMP_MASK;

  let Inst{51-48} = BURST_COUNT;

  let Inst{52}    = VPM;

  let Inst{61-54} = cf_inst;

  let Inst{62}    = MARK;

  let Inst{63}    = BARRIER;

}

 

def load_param : PatFrag<(ops node:$ptr),

                         (load node:$ptr),

                          [{

                           return false;

                          }]>;

 

def isR600 : Predicate<"Subtarget.device()"

                            "->getGeneration() == AMDGPUDeviceInfo::HD4XXX">;

def isR700 : Predicate<"Subtarget.device()"

 

let Predicates = [isR600toCayman] in { 

 

def ADD : R600_2OP <

  0x0, "ADD",

  [(set R600_Reg32:$dst, (fadd R600_Reg32:$src0, R600_Reg32:$src1))]

  [(set R600_Reg32:$dst, (AMDGPUfmin R600_Reg32:$src0, R600_Reg32:$src1))]

>;

 

 

def SETE : R600_2OP <

  0x08, "SETE",

  [(set R600_Reg32:$dst, (int_AMDGPU_floor R600_Reg32:$src))]

>;

 

 

class MOV_IMM <ValueType vt, Operand immType> : InstR600 <0x19,

  (outs R600_Reg32:$dst),

  (MOV_IMM_F32 (i32 ALU_LITERAL_X), fpimm:$val)

>;

 

 

def AND_INT : R600_2OP <

  0x30, "AND_INT",

   (select R600_Reg32:$src0, R600_Reg32:$src2, R600_Reg32:$src1))]

>;

 

 

def TEX_LD : R600_TEX <

  0x03, "TEX_LD",

  []

>;

 

 

class MUL_LIT_Common <bits<32> inst> : R600_3OP <

  inst, "MUL_LIT",

 

class DOT4_Common <bits<32> inst> : R600_REDUCTION <

  inst,

  "DOT4 $dst $src0, $src1",

 

class EXP_IEEE_Common <bits<32> inst> : R600_1OP <

  inst, "EXP_IEEE",

  let Trig = 1;

}

 

 

class DIV_Common <InstR600 recip_ieee> : Pat<

  (int_AMDGPU_div R600_Reg32:$src0, R600_Reg32:$src1),

  (exp_ieee (mul_lit (log_clamped (MAX R600_Reg32:$src_y, (f32 ZERO))), R600_Reg32:$src_w, R600_Reg32:$src_x))

>;

 

 

let Predicates = [isR600] in {

 

  def CNDGT_r600 : CNDGT_Common<0x19>;

  def CNDGE_r600 : CNDGE_Common<0x1A>;

  def DOT4_r600 : DOT4_Common<0x50>;

  def EXP_IEEE_r600 : EXP_IEEE_Common<0x61>;

  def LOG_CLAMPED_r600 : LOG_CLAMPED_Common<0x62>;

  def LOG_IEEE_r600 : LOG_IEEE_Common<0x63>;

 

} // End Predicates = [isEG]

 

 

let Predicates = [isEGorCayman] in {

 

  def SIN_eg : SIN_Common<0x8D>;

  def COS_eg : COS_Common<0x8E>;

  def DOT4_eg : DOT4_Common<0xBE>;

 

  def DIV_eg : DIV_Common<RECIP_IEEE_eg>;

  def POW_eg : POW_Common<LOG_IEEE_eg, EXP_IEEE_eg, MUL, GPRF32>;

let usesCustomInserter = 1 in {

 

def RAT_WRITE_CACHELESS_eg : EG_CF_RAT <0x57, 0x2, 0, (outs),

{

  let RIM         = 0;

  let TYPE        = 1;

  let RW_REL      = 0;

  let ELEM_SIZE   = 0;

  let COMP_MASK   = 1;

  let BURST_COUNT = 0;

  let VPM         = 0;

  let MARK        = 0;

  let BARRIER     = 1;

}

 

} // End usesCustomInserter = 1

 

// Floating point global_store

def : Pat <

  (global_store (f32 R600_TReg32_X:$val), R600_TReg32_X:$ptr),

>;

 

class VTX_READ_eg <bits<8> buffer_id, dag outs, list<dag> pattern>

 

} // End isCayman

 

let isCodeGenOnly = 1 in {

 

  def MULLIT : AMDGPUShaderInst <

    (outs R600_Reg128:$dst),

 

} // End usesCustomInserter = 1

 

//===----------------------------------------------------------------------===//

// ISel Patterns

//===----------------------------------------------------------------------===//

// KIL Patterns

def KILP : Pat <

  (int_AMDGPU_kilp),

>;

 

def KIL : Pat <

  (int_AMDGPU_kill R600_Reg32:$src0),

>;

 

// SGT Reverse args