public static void Psetp(ShaderIrBlock Block, long OpCode) { bool NegA = ((OpCode >> 15) & 1) != 0; bool NegB = ((OpCode >> 32) & 1) != 0; bool NegP = ((OpCode >> 42) & 1) != 0; ShaderIrInst LopInst = GetBLop24(OpCode); ShaderIrNode OperA = GetOperPred12(OpCode); ShaderIrNode OperB = GetOperPred29(OpCode); if (NegA) { OperA = new ShaderIrOp(ShaderIrInst.Bnot, OperA); } if (NegB) { OperB = new ShaderIrOp(ShaderIrInst.Bnot, OperB); } ShaderIrOp Op = new ShaderIrOp(LopInst, OperA, OperB); ShaderIrOperPred P0Node = GetOperPred3(OpCode); ShaderIrOperPred P1Node = GetOperPred0(OpCode); ShaderIrOperPred P2Node = GetOperPred39(OpCode); Block.AddNode(GetPredNode(new ShaderIrAsg(P0Node, Op), OpCode)); LopInst = GetBLop45(OpCode); if (LopInst == ShaderIrInst.Band && P1Node.IsConst && P2Node.IsConst) { return; } ShaderIrNode P2NNode = P2Node; if (NegP) { P2NNode = new ShaderIrOp(ShaderIrInst.Bnot, P2NNode); } Op = new ShaderIrOp(ShaderIrInst.Bnot, P0Node); Op = new ShaderIrOp(LopInst, Op, P2NNode); Block.AddNode(GetPredNode(new ShaderIrAsg(P1Node, Op), OpCode)); Op = new ShaderIrOp(LopInst, P0Node, P2NNode); Block.AddNode(GetPredNode(new ShaderIrAsg(P0Node, Op), OpCode)); }
public static void Psetp(ShaderIrBlock Block, long OpCode, int Position) { bool NegA = OpCode.Read(15); bool NegB = OpCode.Read(32); bool NegP = OpCode.Read(42); ShaderIrInst LopInst = OpCode.BLop24(); ShaderIrNode OperA = OpCode.Pred12(); ShaderIrNode OperB = OpCode.Pred29(); if (NegA) { OperA = new ShaderIrOp(ShaderIrInst.Bnot, OperA); } if (NegB) { OperB = new ShaderIrOp(ShaderIrInst.Bnot, OperB); } ShaderIrOp Op = new ShaderIrOp(LopInst, OperA, OperB); ShaderIrOperPred P0Node = OpCode.Pred3(); ShaderIrOperPred P1Node = OpCode.Pred0(); ShaderIrOperPred P2Node = OpCode.Pred39(); Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P0Node, Op))); LopInst = OpCode.BLop45(); if (LopInst == ShaderIrInst.Band && P1Node.IsConst && P2Node.IsConst) { return; } ShaderIrNode P2NNode = P2Node; if (NegP) { P2NNode = new ShaderIrOp(ShaderIrInst.Bnot, P2NNode); } Op = new ShaderIrOp(ShaderIrInst.Bnot, P0Node); Op = new ShaderIrOp(LopInst, Op, P2NNode); Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P1Node, Op))); Op = new ShaderIrOp(LopInst, P0Node, P2NNode); Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P0Node, Op))); }
public static void Psetp(ShaderIrBlock block, long opCode, int position) { bool negA = opCode.Read(15); bool negB = opCode.Read(32); bool negP = opCode.Read(42); ShaderIrInst lopInst = opCode.BLop24(); ShaderIrNode operA = opCode.Pred12(); ShaderIrNode operB = opCode.Pred29(); if (negA) { operA = new ShaderIrOp(ShaderIrInst.Bnot, operA); } if (negB) { operB = new ShaderIrOp(ShaderIrInst.Bnot, operB); } ShaderIrOp op = new ShaderIrOp(lopInst, operA, operB); ShaderIrOperPred p0Node = opCode.Pred3(); ShaderIrOperPred p1Node = opCode.Pred0(); ShaderIrOperPred p2Node = opCode.Pred39(); block.AddNode(opCode.PredNode(new ShaderIrAsg(p0Node, op))); lopInst = opCode.BLop45(); if (lopInst == ShaderIrInst.Band && p1Node.IsConst && p2Node.IsConst) { return; } ShaderIrNode p2NNode = p2Node; if (negP) { p2NNode = new ShaderIrOp(ShaderIrInst.Bnot, p2NNode); } op = new ShaderIrOp(ShaderIrInst.Bnot, p0Node); op = new ShaderIrOp(lopInst, op, p2NNode); block.AddNode(opCode.PredNode(new ShaderIrAsg(p1Node, op))); op = new ShaderIrOp(lopInst, p0Node, p2NNode); block.AddNode(opCode.PredNode(new ShaderIrAsg(p0Node, op))); }
private static void EmitFmnmx(ShaderIrBlock Block, long OpCode, ShaderOper Oper) { bool NegB = ((OpCode >> 45) & 1) != 0; bool AbsA = ((OpCode >> 46) & 1) != 0; bool NegA = ((OpCode >> 48) & 1) != 0; bool AbsB = ((OpCode >> 49) & 1) != 0; ShaderIrNode OperA = GetOperGpr8(OpCode), OperB; OperA = GetAluFabsFneg(OperA, AbsA, NegA); switch (Oper) { case ShaderOper.CR: OperB = GetOperCbuf34(OpCode); break; case ShaderOper.Immf: OperB = GetOperImmf19_20(OpCode); break; case ShaderOper.RR: OperB = GetOperGpr20(OpCode); break; default: throw new ArgumentException(nameof(Oper)); } OperB = GetAluFabsFneg(OperB, AbsB, NegB); ShaderIrOperPred Pred = GetOperPred39(OpCode); ShaderIrOp Op; if (Pred.IsConst) { bool IsMax = ((OpCode >> 42) & 1) != 0; Op = new ShaderIrOp(IsMax ? ShaderIrInst.Fmax : ShaderIrInst.Fmin, OperA, OperB); Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); } else { ShaderIrNode PredN = GetOperPred39N(OpCode); ShaderIrOp OpMax = new ShaderIrOp(ShaderIrInst.Fmax, OperA, OperB); ShaderIrOp OpMin = new ShaderIrOp(ShaderIrInst.Fmin, OperA, OperB); ShaderIrAsg AsgMax = new ShaderIrAsg(GetOperGpr0(OpCode), OpMax); ShaderIrAsg AsgMin = new ShaderIrAsg(GetOperGpr0(OpCode), OpMin); Block.AddNode(GetPredNode(new ShaderIrCond(PredN, AsgMax, Not: true), OpCode)); Block.AddNode(GetPredNode(new ShaderIrCond(PredN, AsgMin, Not: false), OpCode)); } }
public ShaderIrOp( ShaderIrInst Inst, ShaderIrNode OperandA = null, ShaderIrNode OperandB = null, ShaderIrNode OperandC = null, ShaderIrMeta MetaData = null) { this.Inst = Inst; this.OperandA = OperandA; this.OperandB = OperandB; this.OperandC = OperandC; this.MetaData = MetaData; }
public static void Ipa(ShaderIrBlock block, long opCode, int position) { ShaderIrNode operA = opCode.Abuf28(); ShaderIrNode operB = opCode.Gpr20(); ShaderIpaMode mode = (ShaderIpaMode)(opCode.Read(54, 3)); ShaderIrMetaIpa meta = new ShaderIrMetaIpa(mode); ShaderIrOp op = new ShaderIrOp(ShaderIrInst.Ipa, operA, operB, null, meta); block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op))); }
public ShaderIrOp( ShaderIrInst inst, ShaderIrNode operandA = null, ShaderIrNode operandB = null, ShaderIrNode operandC = null, ShaderIrMeta metaData = null) { Inst = inst; OperandA = operandA; OperandB = operandB; OperandC = operandC; MetaData = metaData; }
private static ShaderIrNode PredNode(this long OpCode, ShaderIrNode Node) { ShaderIrOperPred Pred = OpCode.PredNode(); if (Pred.Index != ShaderIrOperPred.UnusedIndex) { bool Inv = OpCode.Read(19); Node = new ShaderIrCond(Pred, Node, Inv); } return(Node); }
public static void Iadd_I32(ShaderIrBlock block, long opCode, int position) { ShaderIrNode operA = opCode.Gpr8(); ShaderIrNode operB = opCode.Imm32_20(); bool negA = opCode.Read(56); operA = GetAluIneg(operA, negA); ShaderIrOp op = new ShaderIrOp(ShaderIrInst.Add, operA, operB); block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op))); }
public static void Ipa(ShaderIrBlock Block, long OpCode, long Position) { ShaderIrNode OperA = GetOperAbuf28(OpCode); ShaderIrNode OperB = GetOperGpr20(OpCode); ShaderIpaMode Mode = (ShaderIpaMode)((OpCode >> 54) & 3); ShaderIrMetaIpa Meta = new ShaderIrMetaIpa(Mode); ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Ipa, OperA, OperB, null, Meta); Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); }
private static ShaderIrNode PredNode(this long opCode, ShaderIrNode node) { ShaderIrOperPred pred = opCode.PredNode(); if (pred.Index != ShaderIrOperPred.UnusedIndex) { bool inv = opCode.Read(19); node = new ShaderIrCond(pred, node, inv); } return(node); }
public static void Iadd_I32(ShaderIrBlock Block, long OpCode) { ShaderIrNode OperA = GetOperGpr8(OpCode); ShaderIrNode OperB = GetOperImm32_20(OpCode); bool NegA = ((OpCode >> 56) & 1) != 0; OperA = GetAluIneg(OperA, NegA); ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Add, OperA, OperB); Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); }
public static void Iadd_I32(ShaderIrBlock Block, long OpCode, int Position) { ShaderIrNode OperA = OpCode.Gpr8(); ShaderIrNode OperB = OpCode.Imm32_20(); bool NegA = OpCode.Read(56); OperA = GetAluIneg(OperA, NegA); ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Add, OperA, OperB); Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); }
public static void Ipa(ShaderIrBlock Block, long OpCode, int Position) { ShaderIrNode OperA = OpCode.Abuf28(); ShaderIrNode OperB = OpCode.Gpr20(); ShaderIpaMode Mode = (ShaderIpaMode)(OpCode.Read(54, 3)); ShaderIrMetaIpa Meta = new ShaderIrMetaIpa(Mode); ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Ipa, OperA, OperB, null, Meta); Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); }
public static ShaderIrNode ExtendTo32(ShaderIrNode Node, bool Signed, int Size) { int Shift = 32 - Size; ShaderIrInst RightShift = Signed ? ShaderIrInst.Asr : ShaderIrInst.Lsr; Node = new ShaderIrOp(ShaderIrInst.Lsl, Node, new ShaderIrOperImm(Shift)); Node = new ShaderIrOp(RightShift, Node, new ShaderIrOperImm(Shift)); return(Node); }
public static ShaderIrNode GetPredNode(ShaderIrNode Node, long OpCode) { ShaderIrOperPred Pred = GetPredNode(OpCode); if (Pred.Index != ShaderIrOperPred.UnusedIndex) { bool Inv = ((OpCode >> 19) & 1) != 0; Node = new ShaderIrCond(Pred, Node, Inv); } return(Node); }
public static ShaderIrNode ExtendTo32(ShaderIrNode node, bool signed, int size) { int shift = 32 - size; ShaderIrInst rightShift = signed ? ShaderIrInst.Asr : ShaderIrInst.Lsr; node = new ShaderIrOp(ShaderIrInst.Lsl, node, new ShaderIrOperImm(shift)); node = new ShaderIrOp(rightShift, node, new ShaderIrOperImm(shift)); return(node); }
private static void EmitLop(ShaderIrBlock block, long opCode, ShaderOper oper) { int subOp = opCode.Read(41, 3); bool invA = opCode.Read(39); bool invB = opCode.Read(40); ShaderIrInst inst = 0; switch (subOp) { case 0: inst = ShaderIrInst.And; break; case 1: inst = ShaderIrInst.Or; break; case 2: inst = ShaderIrInst.Xor; break; } ShaderIrNode operA = GetAluNot(opCode.Gpr8(), invA); ShaderIrNode operB; switch (oper) { case ShaderOper.Cr: operB = opCode.Cbuf34(); break; case ShaderOper.Imm: operB = opCode.Imm19_20(); break; case ShaderOper.Rr: operB = opCode.Gpr20(); break; default: throw new ArgumentException(nameof(oper)); } operB = GetAluNot(operB, invB); ShaderIrNode op; if (subOp < 3) { op = new ShaderIrOp(inst, operA, operB); } else { op = operB; } ShaderIrNode compare = new ShaderIrOp(ShaderIrInst.Cne, op, new ShaderIrOperImm(0)); block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Pred48(), compare))); block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op))); }
private static void EmitLop(ShaderIrBlock Block, long OpCode, ShaderOper Oper) { int SubOp = OpCode.Read(41, 3); bool InvA = OpCode.Read(39); bool InvB = OpCode.Read(40); ShaderIrInst Inst = 0; switch (SubOp) { case 0: Inst = ShaderIrInst.And; break; case 1: Inst = ShaderIrInst.Or; break; case 2: Inst = ShaderIrInst.Xor; break; } ShaderIrNode OperA = GetAluNot(OpCode.Gpr8(), InvA); ShaderIrNode OperB; switch (Oper) { case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break; case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } OperB = GetAluNot(OperB, InvB); ShaderIrNode Op; if (SubOp < 3) { Op = new ShaderIrOp(Inst, OperA, OperB); } else { Op = OperB; } ShaderIrNode Compare = new ShaderIrOp(ShaderIrInst.Cne, Op, new ShaderIrOperImm(0)); Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Pred48(), Compare))); Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); }
private static void EmitLop(ShaderIrBlock Block, long OpCode, ShaderOper Oper) { int SubOp = (int)(OpCode >> 41) & 3; bool InvA = ((OpCode >> 39) & 1) != 0; bool InvB = ((OpCode >> 40) & 1) != 0; ShaderIrInst Inst = 0; switch (SubOp) { case 0: Inst = ShaderIrInst.And; break; case 1: Inst = ShaderIrInst.Or; break; case 2: Inst = ShaderIrInst.Xor; break; } ShaderIrNode OperA = GetAluNot(GetOperGpr8(OpCode), InvA); ShaderIrNode OperB; switch (Oper) { case ShaderOper.CR: OperB = GetOperCbuf34(OpCode); break; case ShaderOper.Imm: OperB = GetOperImm19_20(OpCode); break; case ShaderOper.RR: OperB = GetOperGpr20(OpCode); break; default: throw new ArgumentException(nameof(Oper)); } OperB = GetAluNot(OperB, InvB); ShaderIrNode Op; if (SubOp < 3) { Op = new ShaderIrOp(Inst, OperA, OperB); } else { Op = OperB; } ShaderIrNode Compare = new ShaderIrOp(ShaderIrInst.Cne, Op, new ShaderIrOperImm(0)); Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperPred48(OpCode), Compare), OpCode)); Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); }
private static void EmitTex(ShaderIrBlock Block, long OpCode, ShaderIrInst Inst) { //TODO: Support other formats. ShaderIrNode OperA = GetOperGpr8(OpCode); ShaderIrNode OperB = GetOperGpr20(OpCode); ShaderIrNode OperC = GetOperImm13_36(OpCode); int LutIndex; LutIndex = GetOperGpr0(OpCode).Index != ShaderIrOperGpr.ZRIndex ? 1 : 0; LutIndex |= GetOperGpr28(OpCode).Index != ShaderIrOperGpr.ZRIndex ? 2 : 0; int ChMask = MaskLut[LutIndex, (OpCode >> 50) & 7]; for (int Ch = 0; Ch < 4; Ch++) { ShaderIrOperGpr Dst = new ShaderIrOperGpr(TempRegStart + Ch); ShaderIrMetaTex Meta = new ShaderIrMetaTex(Ch); ShaderIrOp Op = new ShaderIrOp(Inst, OperA, OperB, OperC, Meta); Block.AddNode(GetPredNode(new ShaderIrAsg(Dst, Op), OpCode)); } int RegInc = 0; for (int Ch = 0; Ch < 4; Ch++) { if (!IsChannelUsed(ChMask, Ch)) { continue; } ShaderIrOperGpr Src = new ShaderIrOperGpr(TempRegStart + Ch); ShaderIrOperGpr Dst = (RegInc >> 1) != 0 ? GetOperGpr28(OpCode) : GetOperGpr0(OpCode); Dst.Index += RegInc++ & 1; if (Dst.Index >= ShaderIrOperGpr.ZRIndex) { continue; } Block.AddNode(GetPredNode(new ShaderIrAsg(Dst, Src), OpCode)); } }
public static ShaderIrNode ExtendTo32(ShaderIrNode Node, bool Signed, ShaderIrNode Size) { ShaderIrOperImm WordSize = new ShaderIrOperImm(32); ShaderIrOp Shift = new ShaderIrOp(ShaderIrInst.Sub, WordSize, Size); ShaderIrInst RightShift = Signed ? ShaderIrInst.Asr : ShaderIrInst.Lsr; Node = new ShaderIrOp(ShaderIrInst.Lsl, Node, Shift); Node = new ShaderIrOp(RightShift, Node, Shift); return(Node); }
public static ShaderIrNode ExtendTo32(ShaderIrNode node, bool signed, ShaderIrNode size) { ShaderIrOperImm wordSize = new ShaderIrOperImm(32); ShaderIrOp shift = new ShaderIrOp(ShaderIrInst.Sub, wordSize, size); ShaderIrInst rightShift = signed ? ShaderIrInst.Asr : ShaderIrInst.Lsr; node = new ShaderIrOp(ShaderIrInst.Lsl, node, shift); node = new ShaderIrOp(rightShift, node, shift); return(node); }
private void PrintBlockScope(string ScopeName, int IdentationLevel, params ShaderIrNode[] Nodes) { string Identation = string.Empty; for (int Index = 0; Index < IdentationLevel - 1; Index++) { Identation += IdentationStr; } if (ScopeName != string.Empty) { ScopeName += " "; } SB.AppendLine(Identation + ScopeName + "{"); string LastLine = Identation + "}"; if (IdentationLevel > 0) { Identation += IdentationStr; } for (int Index = 0; Index < Nodes.Length; Index++) { ShaderIrNode Node = Nodes[Index]; if (Node is ShaderIrCond Cond) { string IfExpr = GetSrcExpr(Cond.Pred, true); if (Cond.Not) { IfExpr = "!(" + IfExpr + ")"; } string SubScopeName = "if (" + IfExpr + ")"; PrintBlockScope(SubScopeName, IdentationLevel + 1, Cond.Child); } else if (Node is ShaderIrAsg Asg && IsValidOutOper(Asg.Dst)) { string Expr = GetSrcExpr(Asg.Src, true); Expr = GetExprWithCast(Asg.Dst, Asg.Src, Expr); SB.AppendLine(Identation + GetDstOperName(Asg.Dst) + " = " + Expr + ";"); }
public static void Ld_C(ShaderIrBlock block, long opCode, int position) { int cbufPos = opCode.Read(22, 0x3fff); int cbufIndex = opCode.Read(36, 0x1f); int type = opCode.Read(48, 7); if (type > 5) { throw new InvalidOperationException(); } ShaderIrOperGpr temp = ShaderIrOperGpr.MakeTemporary(); block.AddNode(new ShaderIrAsg(temp, opCode.Gpr8())); int count = type == 5 ? 2 : 1; for (int index = 0; index < count; index++) { ShaderIrOperCbuf operA = new ShaderIrOperCbuf(cbufIndex, cbufPos, temp); ShaderIrOperGpr operD = opCode.Gpr0(); operA.Pos += index; operD.Index += index; if (!operD.IsValidRegister) { break; } ShaderIrNode node = operA; if (type < 4) { //This is a 8 or 16 bits type. bool signed = (type & 1) != 0; int size = 8 << (type >> 1); node = ExtendTo32(node, signed, size); } block.AddNode(opCode.PredNode(new ShaderIrAsg(operD, node))); } }
public static void Fadd_I32(ShaderIrBlock Block, long OpCode, int Position) { ShaderIrNode OperA = OpCode.Gpr8(); ShaderIrNode OperB = OpCode.Immf32_20(); bool NegB = OpCode.Read(53); bool AbsA = OpCode.Read(54); bool NegA = OpCode.Read(56); bool AbsB = OpCode.Read(57); OperA = GetAluFabsFneg(OperA, AbsA, NegA); OperB = GetAluFabsFneg(OperB, AbsB, NegB); ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Fadd, OperA, OperB); Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); }
public static void Fadd_I32(ShaderIrBlock block, long opCode, int position) { ShaderIrNode operA = opCode.Gpr8(); ShaderIrNode operB = opCode.Immf32_20(); bool negB = opCode.Read(53); bool absA = opCode.Read(54); bool negA = opCode.Read(56); bool absB = opCode.Read(57); operA = GetAluFabsFneg(operA, absA, negA); operB = GetAluFabsFneg(operB, absB, negB); ShaderIrOp op = new ShaderIrOp(ShaderIrInst.Fadd, operA, operB); block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op))); }
public static void Fadd_I32(ShaderIrBlock Block, long OpCode) { ShaderIrNode OperA = GetOperGpr8(OpCode); ShaderIrNode OperB = GetOperImmf32_20(OpCode); bool NegB = ((OpCode >> 53) & 1) != 0; bool AbsA = ((OpCode >> 54) & 1) != 0; bool NegA = ((OpCode >> 56) & 1) != 0; bool AbsB = ((OpCode >> 57) & 1) != 0; OperA = GetAluFabsFneg(OperA, AbsA, NegA); OperB = GetAluFabsFneg(OperB, AbsB, NegB); ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Fadd, OperA, OperB); Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); }
public static void Ld_C(ShaderIrBlock Block, long OpCode, long Position) { int CbufPos = (int)(OpCode >> 22) & 0x3fff; int CbufIndex = (int)(OpCode >> 36) & 0x1f; int Type = (int)(OpCode >> 48) & 7; if (Type > 5) { throw new InvalidOperationException(); } ShaderIrOperGpr Temp = ShaderIrOperGpr.MakeTemporary(); Block.AddNode(new ShaderIrAsg(Temp, GetOperGpr8(OpCode))); int Count = Type == 5 ? 2 : 1; for (int Index = 0; Index < Count; Index++) { ShaderIrOperCbuf OperA = new ShaderIrOperCbuf(CbufIndex, CbufPos, Temp); ShaderIrOperGpr OperD = GetOperGpr0(OpCode); OperA.Pos += Index; OperD.Index += Index; if (!OperD.IsValidRegister) { break; } ShaderIrNode Node = OperA; if (Type < 4) { //This is a 8 or 16 bits type. bool Signed = (Type & 1) != 0; int Size = 8 << (Type >> 1); Node = ExtendTo32(Node, Signed, Size); } Block.AddNode(GetPredNode(new ShaderIrAsg(OperD, Node), OpCode)); } }
public static void Texq(ShaderIrBlock Block, long OpCode) { ShaderIrNode OperD = GetOperGpr0(OpCode); ShaderIrNode OperA = GetOperGpr8(OpCode); ShaderTexqInfo Info = (ShaderTexqInfo)((OpCode >> 22) & 0x1f); ShaderIrMetaTexq Meta0 = new ShaderIrMetaTexq(Info, 0); ShaderIrMetaTexq Meta1 = new ShaderIrMetaTexq(Info, 1); ShaderIrNode OperC = GetOperImm13_36(OpCode); ShaderIrOp Op0 = new ShaderIrOp(ShaderIrInst.Texq, OperA, null, OperC, Meta0); ShaderIrOp Op1 = new ShaderIrOp(ShaderIrInst.Texq, OperA, null, OperC, Meta1); Block.AddNode(GetPredNode(new ShaderIrAsg(OperD, Op0), OpCode)); Block.AddNode(GetPredNode(new ShaderIrAsg(OperA, Op1), OpCode)); //Is this right? }