public Constant defineConstant(string name, Type type, object value) { if (null == name) name = ".C"+m_code.constants.Count; Constant c = new Constant(name, type, value); m_code.constants.Add(c); return c; }
public void Constant_accepts_Visitor() { var constant = new Constant(typeof(string), "a"); constant.AcceptVisitor(theVisitor); theVisitor.Received().Constant(constant); }
public override Constant ApplyConstant(Constant c) { if (c.IsValid) return c.Negate(); else return c; }
public static string FormatValue(Constant c) { if (((PrimitiveType)c.DataType).Domain == Domain.SignedInt) return FormatSignedValue(c); else return FormatUnsignedValue(c); }
public void Constant_accepts_Visitor() { var constant = new Constant(typeof(string), "a"); constant.AcceptVisitor(theVisitor); theVisitor.AssertWasCalled(x => x.Constant(constant)); }
public bool Match(BinaryExpression exp) { if (exp.Operator != Operator.IAdd) return false; id = exp.Left as Identifier; bin = exp.Right as BinaryExpression; if ((id == null || bin == null) && exp.Operator == Operator.IAdd) { id = exp.Right as Identifier; bin = exp.Left as BinaryExpression; } if (id == null || bin == null) return false; if (bin.Operator != Operator.SMul && bin.Operator != Operator.UMul && bin.Operator != Operator.IMul) return false; Identifier idInner = bin.Left as Identifier; cInner = bin.Right as Constant; if (idInner == null ||cInner == null) return false; if (idInner != id) return false; return true; }
//--------------------------------------------------------------------- public static void ConstantQuery(OleDbConnection dbcon, CodeGenerator cg) { cg.ConstantList.Clear(); OleDbCommand cmd = new OleDbCommand("SELECT * FROM Constants ORDER BY Topic, ID", dbcon); OleDbDataReader dr = cmd.ExecuteReader(); while (dr.Read()) { Constant curConst = new Constant(); curConst.Name = dr["Name"].ToString(); curConst.Value = dr["Value"].ToString(); Int32 nTopic = Convert.ToInt32(dr["Topic"].ToString()); if (nTopic > 0) { curConst.Topic = cg.TopicList[nTopic - 1].Name.ToString(); } else { curConst.Topic = ""; } curConst.Description = dr["Description"].ToString(); cg.ConstantList.Add(curConst); //curConst.Print(); } dr.Close(); }
public override Constant ApplyConstants(Constant c1, Constant c2) { return c1.ToInt32() != c2.ToInt32() ? Constant.True() : Constant.False(); }
public bool MatchMul(BinaryExpression b) { if (b.Operator == Operator.SMul || b.Operator == Operator.UMul || b.Operator == Operator.IMul) { Constant c = b.Left as Constant; Expression e = b.Right; if (c == null) { c = b.Right as Constant; e = b.Left; } if (c != null) { elemSize = c; Index = e; return true; } } if (b.Operator == Operator.Shl) { Constant c = b.Right as Constant; if (c != null) { elemSize = b.Operator.ApplyConstants(Constant.Create(b.Left.DataType, 1), c); Index = b.Left; return true; } } return false; }
public override Constant ApplyConstants(Constant c1, Constant c2) { if (!ValidArgs(c1, c2)) return Constant.Invalid; return Constant.Bool(c1.ToInt32() >= c2.ToInt32()); }
private void Initialize() { // create all symbols var sum = new Sum(); var prog = new Prog(); var frog = new Frog(); var left = new Left(); var forward = new Forward(); var constant = new Constant(); var allSymbols = new List<ISymbol>() { sum, prog, frog, left, forward, constant }; // add all symbols to the grammar foreach (var s in allSymbols) AddSymbol(s); // define grammar rules foreach (var s in allSymbols) { AddAllowedChildSymbol(sum, s); AddAllowedChildSymbol(sum, s); AddAllowedChildSymbol(prog, s); AddAllowedChildSymbol(prog, s); AddAllowedChildSymbol(frog, s); AddAllowedChildSymbol(StartSymbol, s); } }
public override Constant ApplyConstants(Constant c1, Constant c2) { if (!ValidArgs(c1, c2)) return Constant.Invalid; return BuildConstant(c1.DataType, c2.DataType, (int) (c1.ToUInt64() - c2.ToUInt64())); }
/// <summary> /// Creates a slot with constant value being <paramref name="value"/>. /// </summary> internal ConstantProjectedSlot(Constant value, MemberPath memberPath) { Debug.Assert(value != null); Debug.Assert(value.IsNotNull() == false, "Cannot store NotNull in a slot - NotNull is only for conditions"); m_constant = value; m_memberPath = memberPath; }
public override Constant ApplyConstants(Constant c1, Constant c2) { if (!ValidArgs(c1, c2)) return Constant.Invalid; uint v1 = c1.ToUInt32(); uint v2 = c2.ToUInt32(); return Constant.Bool(v1 <= v2); }
public MemoryOperand(PrimitiveType width, Constant off) : base(width) { SegOverride = RegisterStorage.None; Base = RegisterStorage.None; Offset = off; Index = RegisterStorage.None; Scale = 1; }
internal static CilConstant Create(Constant constant, ref CilReaders readers) { CilConstant ilConstant = new CilConstant(); ilConstant._constant = constant; ilConstant._readers = readers; ilConstant._isTypeInitialized = false; return ilConstant; }
public MemoryOperand(PrimitiveType width, RegisterStorage @base, RegisterStorage index, byte scale, Constant off) : base(width) { SegOverride = RegisterStorage.None; Base = @base; Offset = off; Index = index; Scale = scale; }
public override Constant ApplyConstants(Constant c1, Constant c2) { if (!ValidArgs(c1, c2)) return Constant.Invalid; if (c2.IsIntegerZero) return Constant.Invalid; return BuildConstant(c1.DataType, c2.DataType, c1.ToInt32() % c2.ToInt32()); }
public TextureReplacement(string fname, Constant fmt, int w, int h, float s) { filename = fname; format = (int)fmt; width = w; height = h; scale = s; }
public bool Match(Slice slice) { if (!(slice.DataType is PrimitiveType))//$TODO: remove this once varargs processing is complete. return false; this.slice = slice; this.c = slice.Expression as Constant; return c != null && c != Constant.Invalid; }
public bool Match(Expression e) { elemSize = null; Index = null; ArrayPointer = null; BinaryExpression b = e as BinaryExpression; if (b == null) return false; if (MatchMul(b)) { ArrayPointer = Constant.Zero(b.DataType); return true; } // (+ x y) if (b.Operator == Operator.IAdd) { BinaryExpression bInner = b.Left as BinaryExpression; if (bInner != null) { if (MatchMul(bInner)) { // (+ (* i c) ptr) ArrayPointer = b.Right; return true; } } bInner = b.Right as BinaryExpression; if (bInner != null) { if (MatchMul(bInner)) { // (+ ptr (* i c)) ArrayPointer = b.Left; return true; } if (bInner.Operator == Operator.IAdd) { // (+ x (+ a b)) var bbInner = bInner.Left as BinaryExpression; if (bbInner != null && MatchMul(bbInner)) { // (+ x (+ (* i c) y)) rearranges to become // (+ (* i c) (+ x y)) this.ArrayPointer = new BinaryExpression( Operator.IAdd, PrimitiveType.Create(Domain.Pointer, b.Left.DataType.Size), b.Left, bInner.Right); return true; } } } } return false; }
public bool Match(Identifier id) { Expression e = ctx.GetValue(id); cSrc = e as Constant; if (cSrc == null || !cSrc.IsValid) return false; idDst = id; return true; }
protected override bool IsEqualTo(Constant right) { TypeConstant rightTypeConstant = right as TypeConstant; if (rightTypeConstant == null) { return false; } return m_edmType == rightTypeConstant.m_edmType; }
public void Setup() { m = new ProcedureBuilder(); i = m.Local32("i"); c = m.Int32(16); off = m.Int32(42); r = m.Local32("r"); aem = new ArrayExpressionMatcher(PrimitiveType.Pointer32); }
public override Constant ApplyConstants(Constant c1, Constant c2) { if (!ValidArgs(c1, c2)) return Constant.Invalid; return c1.ToInt32() != c2.ToInt32() ? Constant.True() : Constant.False(); }
public void Associate(Identifier basePtr, Constant memberPtr) { if (assocs.ContainsKey(basePtr)) { assocs[basePtr] = overAssociatedId; consts[basePtr] = overAssociatedConst; return; } consts[basePtr] = memberPtr; }
public LinearInductionVariable( Constant initial, Constant delta, Constant final, bool isSigned) { this.Initial = initial; this.Delta = delta; this.Final = final; this.IsSigned = isSigned; }
public static string FormatSignedValue(Constant c) { string s = "+"; int tmp = c.ToInt32(); if (tmp < 0) { s = "-"; tmp = -tmp; } return s + tmp.ToString(FormatString(c.DataType)); }
public override void SetRegister(RegisterStorage reg, Constant c) { if (c == null || !c.IsValid) { valid[reg.Number] = false; } else { reg.SetRegisterFileValues(regs, c.ToUInt32(), valid); //$REVIEW: AsUint64 for PPC-64? } }
internal override BoolExpr<DomainConstraint<BoolLiteral, Constant>> GetDomainBoolExpression(MemberDomainMap domainMap) { // Essentially say that the variable can take values true or false and here its value is only true IEnumerable<Constant> actualValues = new Constant[] { new ScalarConstant(true) }; IEnumerable<Constant> possibleValues = new Constant[] { new ScalarConstant(true), new ScalarConstant(false) }; var variableDomain = new Set<Constant>(possibleValues, Constant.EqualityComparer).MakeReadOnly(); var thisDomain = new Set<Constant>(actualValues, Constant.EqualityComparer).MakeReadOnly(); var result = MakeTermExpression(this, variableDomain, thisDomain); return result; }
public override Address MakeAddressFromConstant(Constant c, bool codeAlign) { throw new NotImplementedException(); }
Expression ConvertExpression(ResolveContext ec) { // TODO: ImplicitConversionExists should take care of this if (left.eclass == ExprClass.MethodGroup) { return(null); } TypeSpec ltype = left.Type; // // If left is a nullable type and an implicit conversion exists from right to underlying type of left, // the result is underlying type of left // if (ltype.IsNullableType) { unwrap = Unwrap.Create(left, false); if (unwrap == null) { return(null); } // // Reduce (left ?? null) to left // if (right.IsNull) { return(ReducedExpression.Create(left, this)); } if (Convert.ImplicitConversionExists(ec, right, unwrap.Type)) { left = unwrap; ltype = left.Type; // // If right is a dynamic expression, the result type is dynamic // if (right.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) { type = right.Type; // Need to box underlying value type left = Convert.ImplicitBoxingConversion(left, ltype, type); return(this); } right = Convert.ImplicitConversion(ec, right, ltype, loc); type = ltype; return(this); } } else if (TypeSpec.IsReferenceType(ltype)) { if (Convert.ImplicitConversionExists(ec, right, ltype)) { // // If right is a dynamic expression, the result type is dynamic // if (right.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) { type = right.Type; return(this); } // // Reduce ("foo" ?? expr) to expression // Constant lc = left as Constant; if (lc != null && !lc.IsDefaultValue) { return(ReducedExpression.Create(lc, this)); } // // Reduce (left ?? null) to left OR (null-constant ?? right) to right // if (right.IsNull || lc != null) { return(ReducedExpression.Create(lc != null ? right : left, this)); } right = Convert.ImplicitConversion(ec, right, ltype, loc); type = ltype; return(this); } // // Special case null ?? null // if (ltype == right.Type) { type = ltype; return(this); } } else { return(null); } TypeSpec rtype = right.Type; if (!Convert.ImplicitConversionExists(ec, unwrap != null ? unwrap : left, rtype) || right.eclass == ExprClass.MethodGroup) { return(null); } // // Reduce (null ?? right) to right // if (left.IsNull) { return(ReducedExpression.Create(right, this).Resolve(ec)); } left = Convert.ImplicitConversion(ec, unwrap != null ? unwrap : left, rtype, loc); type = rtype; return(this); }
private bool TryDecodeOperand(PrimitiveType width, int maxReg, out MachineOperand op) { op = null !; if (!rdr.TryReadByte(out byte bSpecifier)) { return(false); } var reg = arch.GetRegister(bSpecifier & 0xF) !; switch (bSpecifier >> 4) { case 0: // Literal mode case 1: case 2: case 3: op = LiteralOperand(width, bSpecifier); break; case 4: // Index mode op = IndexOperand(width, reg) !; if (op == null) { return(false); } break; case 5: // Register mode if (reg.Number > maxReg) { return(false); } op = new RegisterOperand(reg); break; case 6: // Register deferred op = new MemoryOperand(width) { Base = new RegisterOperand(reg) }; break; case 7: // Autodecrement mode op = new MemoryOperand(width) { Base = new RegisterOperand(reg), AutoDecrement = true, }; break; case 8: // Autoincrement mode if (reg.Number == 0x0F) { op = ImmediateOperand(width) !; return(op != null); } else { op = new MemoryOperand(width) { Base = new RegisterOperand(reg), AutoIncrement = true, }; } break; case 9: // Deferred Autoincrement mode op = new MemoryOperand(width) { Base = new RegisterOperand(reg), AutoIncrement = true, Deferred = true, }; break; case 0xA: // Displacement mode case 0xB: if (!rdr.TryReadByte(out byte b)) { return(false); } op = DisplacementOperand(width, reg, Constant.SByte((sbyte)b), bSpecifier); break; case 0xC: case 0xD: if (!rdr.TryReadUInt16(out ushort w)) { return(false); } op = DisplacementOperand(width, reg, Constant.Int16((short)w), bSpecifier); break; case 0xE: case 0xF: if (!rdr.TryReadUInt32(out uint dw)) { return(false); } op = DisplacementOperand(width, reg, Constant.Word32(dw), bSpecifier); break; default: throw new InvalidCastException("Impossiburu!"); } return(true); }
private MachineOperand DisplacementOperand(PrimitiveType width, RegisterStorage reg, Constant c, byte bSpecifier) { bool deferred = ((bSpecifier >> 4) & 0x1) != 0; if (reg.Number == 15) { var addr = Address.Ptr32((uint)((int)rdr.Address.ToLinear() + c.ToInt32())); if (!deferred) { return(AddressOperand.Create(addr)); } else { return(new MemoryOperand(width) { Offset = addr.ToConstant(), Deferred = true }); } } return(new MemoryOperand(width) { Base = new RegisterOperand(reg), Offset = c, Deferred = deferred }); }
private void RewriteOne(PrimitiveType dt) { m.Assign(RewriteSrc(instr.Operands[0]), Constant.Create(dt, 1)); }
public void VpAddZero() { Identifier r = m.Reg32("r"); var sub = new BinaryExpression(Operator.ISub, PrimitiveType.Word32, new MemoryAccess(MemoryIdentifier.GlobalMemory, r, PrimitiveType.Word32), Constant.Word32(0)); var vp = new ExpressionSimplifier(segmentMap, new SsaEvaluationContext(arch.Object, m.Ssa.Identifiers, dynamicLinker.Object), listener); var exp = sub.Accept(vp); Assert.AreEqual("Mem0[r:word32]", exp.ToString()); }
public bool TryRead(PrimitiveType dataType, out Constant value) => TryReadBe(dataType, out value);
/// <inheritdoc/> public override bool Equals(Constant other) { return(other is MethodTokenConstant && Method == ((MethodTokenConstant)other).Method); }
private void RewriteSet1() { RewriteDst(instr.Operands[0], Constant.Bool(true), (a, b) => b); }
private Expression MaybeShiftOperand(Expression exp, ArmInstructionOperand op) { switch (op.Shifter.Type) { case ArmShifterType.ASR: return(m.Sar(exp, op.Shifter.Value)); case ArmShifterType.LSL: return(m.Shl(exp, op.Shifter.Value)); case ArmShifterType.LSR: return(m.Shr(exp, op.Shifter.Value)); case ArmShifterType.ROR: return(host.PseudoProcedure(PseudoProcedure.Ror, PrimitiveType.Word32, exp, Constant.Int32(op.Shifter.Value))); case ArmShifterType.RRX: return(host.PseudoProcedure("rrx", PrimitiveType.Word32, exp, Constant.Int32(op.Shifter.Value))); case ArmShifterType.ASR_REG: return(m.Sar(exp, Reg(op.Shifter.Value))); case ArmShifterType.LSL_REG: return(m.Shl(exp, Reg(op.Shifter.Value))); case ArmShifterType.LSR_REG: return(m.Shr(exp, Reg(op.Shifter.Value))); case ArmShifterType.ROR_REG: return(host.PseudoProcedure(PseudoProcedure.Ror, PrimitiveType.Word32, exp, Reg(op.Shifter.Value))); case ArmShifterType.RRX_REG: return(host.PseudoProcedure("rrx", PrimitiveType.Word32, exp, Reg(op.Shifter.Value))); default: return(exp); } }
} // the data width of the current instruction being rewritten. /// <summary> /// Rewrite operands being used as sources. /// </summary> /// <param name="operand"></param> /// <param name="addrInstr">Address of the current instruction</param> /// <returns></returns> public Expression RewriteSrc(MachineOperand operand, Address addrInstr, bool addressAsAddress = false) { var reg = operand as RegisterOperand; if (reg != null) { Expression r = binder.EnsureRegister(reg.Register); if (DataWidth != null && DataWidth.Size != reg.Width.Size) { r = m.Cast(DataWidth, r); } return(r); } var imm = operand as M68kImmediateOperand; if (imm != null) { if (imm.Width.Domain == Domain.Real) { return(imm.Constant.CloneExpression()); } if (DataWidth != null && DataWidth.BitSize > imm.Width.BitSize) { return(Constant.Create(DataWidth, imm.Constant.ToInt64())); } else { return(Constant.Create(imm.Width, imm.Constant.ToUInt32())); } } var mem = operand as MemoryOperand; if (mem != null) { return(RewriteMemoryAccess(mem, DataWidth, addrInstr)); } var addr = operand as M68kAddressOperand; if (addr != null) { if (addressAsAddress) { return(addr.Address); } else { return(m.Load(DataWidth, addr.Address)); } } var pre = operand as PredecrementMemoryOperand; if (pre != null) { var ea = binder.EnsureRegister(pre.Register); m.Assign(ea, m.ISub(ea, DataWidth.Size)); return(m.Load(DataWidth, ea)); } var post = operand as PostIncrementMemoryOperand; if (post != null) { var r = binder.EnsureRegister(post.Register); var tmp = binder.CreateTemporary(DataWidth); m.Assign(tmp, m.Load(DataWidth, r)); m.Assign(r, m.IAdd(r, DataWidth.Size)); return(tmp); } var indidx = operand as IndirectIndexedOperand; if (indidx != null) { Expression ea = RewriteIndirectBaseRegister(indidx, addrInstr); Expression ix = binder.EnsureRegister(indidx.XRegister); if (indidx.XWidth.Size != 4) { ix = m.Cast(PrimitiveType.Int32, m.Cast(PrimitiveType.Int16, ix)); } if (indidx.Scale > 1) { ix = m.IMul(ix, Constant.Int32(indidx.Scale)); } return(m.Load(DataWidth, m.IAdd(ea, ix))); } var indop = operand as IndexedOperand; if (indop != null) { Expression ea = Combine(indop.Base, indop.base_reg); if (indop.postindex) { ea = m.LoadDw(ea); } if (indop.index_reg != null) { var idx = Combine(null, indop.index_reg); if (indop.index_scale > 1) { idx = m.IMul(idx, indop.index_scale); } ea = Combine(ea, idx); } if (indop.preindex) { ea = m.LoadDw(ea); } ea = Combine(ea, indop.outer); return(m.Load(DataWidth, ea)); } throw new NotImplementedException("Unimplemented RewriteSrc for operand type " + operand.GetType().Name); }
public Expression RewriteMoveDst(MachineOperand opDst, Address addrInstr, PrimitiveType dataWidth, Expression src) { var reg = opDst as RegisterOperand; if (reg != null) { var r = binder.EnsureRegister(reg.Register); if (r.DataType.Size > dataWidth.Size) { var tmp = binder.CreateTemporary(dataWidth); m.Assign(r, m.Dpb(r, src, 0)); return(tmp); } else { m.Assign(r, src); return(r); } } var mem = opDst as MemoryOperand; if (mem != null) { src = Spill(src, binder.EnsureRegister(mem.Base)); var load = RewriteMemoryAccess(mem, dataWidth, addrInstr); var tmp = binder.CreateTemporary(dataWidth); m.Assign(load, src); return(tmp); } var post = opDst as PostIncrementMemoryOperand; if (post != null) { var r = binder.EnsureRegister(post.Register); var rExp = Spill(src, r); var load = m.Load(dataWidth, r); m.Assign(load, rExp); m.Assign(r, m.IAdd(r, dataWidth.Size)); return(src); } var pre = opDst as PredecrementMemoryOperand; if (pre != null) { var r = binder.EnsureRegister(pre.Register); m.Assign(r, m.ISub(r, dataWidth.Size)); var rExp = Spill(src, r); var load = m.Load(dataWidth, rExp); m.Assign(load, src); return(src); } var idxop = opDst as IndexedOperand; if (idxop != null) { var b = binder.EnsureRegister(idxop.base_reg); var i = binder.EnsureRegister(idxop.index_reg); var s = m.Const(i.DataType, idxop.index_scale); var load = m.Load(dataWidth, m.IAdd(b, m.IMul(i, s))); m.Assign(load, src); return(src); } var indidx = opDst as IndirectIndexedOperand; if (indidx != null) { var a = binder.EnsureRegister(indidx.ARegister); var x = binder.EnsureRegister(indidx.XRegister); var load = m.Load(dataWidth, m.IAdd(a, x)); m.Assign(load, src); return(src); } var mAddr = opDst as M68kAddressOperand; if (mAddr != null) { m.Assign( m.Load( dataWidth, Constant.Word32(mAddr.Address.ToUInt32())), src); return(src); } throw new NotImplementedException("Unimplemented RewriteMoveDst for operand type " + opDst.GetType().Name); }
public string CreateRequest(List <IOrderItemMessage> items, Guid orderId, string processorUrl, Dictionary <string, string> settings) { //PayPal cart version string PostUrl = processorUrl; string Cmd = "_cart"; //string Cmd = "_xclick"; string Upload = "1"; string BusinessEmail = settings["BusinessEmail"]; string Currency = "USD"; string ShipAmount = "1"; StringBuilder ppForm = new StringBuilder(); var convRate = new ConversionRate(); ppForm.Append("<HTML><BODY><form name='frmPP' id='frmPP' action='" + PostUrl + "' method='post'>"); ppForm.Append("<input type='hidden' name='shipping' value='" + ShipAmount + "'>"); ppForm.Append("<input type='hidden' name='cmd' value='" + Cmd + "'>"); ppForm.Append("<input type='hidden' name='upload' value='" + Upload + "}'>"); ppForm.Append("<input type='hidden' name='business' value='" + BusinessEmail + "'>"); ppForm.Append("<input type='hidden' name='currency_code' value='" + Currency + "'>"); ppForm.Append("<input type='hidden' name='rm' value='1'>"); ppForm.Append("<input type='hidden' name='return' value='" + settings["ReturnUrl"] + "'>"); ppForm.Append("<input type='hidden' name='notify_url' value='" + settings["NotifyUrl"] + "'>"); ppForm.Append("<input type='hidden' name='cancel_return' value='" + settings["CancelPurchaseUrl"] + "'>"); ppForm.Append("<input type='hidden' name='custom' value='" + orderId.ToString() + "'>"); for (int i = 0; i < items.Count; i++) { var item = items[i]; ppForm.Append("<input type='hidden' name='item_number_" + (i + 1).ToString() + "' value='" + (i + 1).ToString() + "'>"); ppForm.Append("<input type='hidden' name='item_name_" + (i + 1).ToString() + "' value='" + Constant.GetItemDescription(item.DomainName, GetPlan(item.SubPlanID).ProductName, GetPlan(item.SubPlanID).DisplayName) + "'>"); ppForm.Append("<input type='hidden' name='amount_" + (i + 1).ToString() + "' value='" + convRate.ConvertRupeeToDollar(GetPlan(item.SubPlanID)).ToString() + "'>"); ppForm.Append("<input type='hidden' name='quantity_" + (i + 1).ToString() + "' value='1'>"); } ppForm.Append("</form>" + PayPalPostScript() + "</BODY></HTML>"); return(ppForm.ToString()); }
public StoreOffset(Statement stm, Store store, Constant Offset) { this.Statement = stm; this.Store = store; this.Offset = Offset; }
public void X86Orw32_IndexedAccess() { MemoryOperand mem = new MemoryOperand(PrimitiveType.Word32, Registers.eax, Registers.edx, 4, Constant.Word32(0x24)); Expression expr = orw.Transform(instr, mem, PrimitiveType.Word32, state); Assert.AreEqual("Mem0[eax + 0x24<32> + edx * 4<32>:word32]", expr.ToString()); }
public void VpMulAddShift() { Identifier id = m.Reg32("id"); var vp = new ExpressionSimplifier(segmentMap, new SsaEvaluationContext(arch.Object, m.Ssa.Identifiers, dynamicLinker.Object), listener); PrimitiveType t = PrimitiveType.Int32; BinaryExpression b = new BinaryExpression(Operator.Shl, t, new BinaryExpression(Operator.IAdd, t, new BinaryExpression(Operator.SMul, t, id, Constant.Create(t, 4)), id), Constant.Create(t, 2)); Expression e = vp.VisitBinaryExpression(b); Assert.AreEqual("id *s 20", e.ToString()); }
public IncrementedUse(Statement stm, BinaryExpression exp, Constant inc) { this.Statement = stm; this.Expression = exp; this.Increment = inc; }
private void RewriteSel() { var bank = (RegisterBankOperand)instr.Operands[0]; m.SideEffect(host.Intrinsic("__select_register_bank", false, VoidType.Instance, Constant.Byte((byte)bank.Bank))); }
public abstract bool TryRead(MemoryArea mem, Address addr, PrimitiveType dt, out Constant value);
public override Address MakeAddressFromConstant(Constant c) { return(Address.Ptr16(c.ToUInt16())); }
public Address MakeSegmentedAddress(Constant selector, Constant offset) { throw new NotImplementedException(); }
private void RewriteClr(PrimitiveType dt) { m.Assign(RewriteSrc(instr.Operands[0]), Constant.Zero(dt)); }
public Address MakeAddressFromConstant(Constant c) { return(program.Architecture.MakeAddressFromConstant(c, true)); }
/// <summary> /// Adds the specified constant as a member to this class. /// /// <param name="c">a constant</param> /// </summary> public override void add_constant(Constant c) { constants.Add(c); scope.add(c.name, c); }
private static void addInitializersToMain(Program prog, string mainProcName) { if (mainProcName == "") { List <string> entrypoints = EntrypointScanner.FindEntrypoint(prog); if (entrypoints.Count == 0) { //throw new InternalError("Main procedure not found"); Console.WriteLine("Main procedure not found"); return; } mainProcName = entrypoints[0]; } var mainProc = cba.Util.BoogieUtil.findProcedureImpl(prog.TopLevelDeclarations, mainProcName); if (mainProc == null) { Console.WriteLine("Implementation of main procedure " + mainProcName + " not found"); return; } // Find all initializers List <Cmd> newCmds = new List <Cmd>(); foreach (var decl in prog.TopLevelDeclarations) { var impl = decl as Implementation; if (impl == null) { continue; } if (impl.Name.EndsWith("cctor")) { if (impl.InParams.Count == 0) { newCmds.Add(new CallCmd(Token.NoToken, impl.Name, new List <Expr>(), new List <IdentifierExpr>())); } } } // Find relevant variables and constants GlobalVariable exceptionVariable = null; Constant nullConstant = null; foreach (var decl in prog.TopLevelDeclarations) { GlobalVariable globalVariable = decl as GlobalVariable; if (globalVariable != null) { if (globalVariable.Name == "$Exception") { exceptionVariable = globalVariable; } } Constant constant = decl as Constant; if (constant != null) { if (constant.Name == "null") { nullConstant = constant; } } if (exceptionVariable != null && nullConstant != null) { break; } } // Create initialization of exception variable if (exceptionVariable == null) { throw new InternalError("Variable $Exception not found"); } else if (nullConstant == null) { throw new InternalError("Constant null not found"); } else { List <AssignLhs> lhss = new List <AssignLhs>(); lhss.Add(new SimpleAssignLhs(Token.NoToken, Expr.Ident(exceptionVariable))); List <Expr> rhss = new List <Expr>(); rhss.Add(Expr.Ident(nullConstant)); newCmds.Add(new AssignCmd(Token.NoToken, lhss, rhss)); } // Create initialization of track variable for GetMeHere { GlobalVariable trackVariable = new GlobalVariable(Token.NoToken, new TypedIdent(Token.NoToken, "$GetMeHereTracker", Microsoft.Boogie.Type.Int)); prog.AddTopLevelDeclaration(trackVariable); List <AssignLhs> lhss = new List <AssignLhs>(); lhss.Add(new SimpleAssignLhs(Token.NoToken, Expr.Ident(trackVariable))); List <Expr> rhss = new List <Expr>(); rhss.Add(new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.ZERO)); newCmds.Add(new AssignCmd(Token.NoToken, lhss, rhss)); } // Add call to all initializers in main var block = mainProc.Blocks[0]; newCmds.AddRange(block.Cmds); block.Cmds = newCmds; }
private void RewriteClr1() { RewriteDst(instr.Operands[0], Constant.Bool(false), (a, b) => b); }
public override Address MakeAddressFromConstant(Constant c) => Address.Ptr32(c.ToUInt32());
public abstract Address MakeAddressFromConstant(Constant c, bool codeAlign);
public Expression RewriteDst( MachineOperand operand, Address addrInstr, PrimitiveType dataWidth, Expression src, Func <Expression, Expression, Expression> opGen) { var reg = operand as RegisterOperand; if (reg != null) { Expression r = binder.EnsureRegister(reg.Register); Expression tmp = r; if (dataWidth != null && reg.Width.BitSize > dataWidth.BitSize && reg.Width.Domain != Domain.Real) { Expression rSub = m.Cast(dataWidth, r); var srcExp = opGen(src, rSub); if (srcExp is Identifier || srcExp is Constant || srcExp is DepositBits) { tmp = srcExp; } else { tmp = binder.CreateTemporary(dataWidth); m.Assign(tmp, srcExp); } src = m.Dpb(r, tmp, 0); } else { src = opGen(src, r); } m.Assign(r, src); return(tmp); } var dbl = operand as DoubleRegisterOperand; if (dbl != null) { Identifier h = binder.EnsureRegister(dbl.Register1); Identifier l = binder.EnsureRegister(dbl.Register2); var d = binder.EnsureSequence(h.Storage, l.Storage, PrimitiveType.Word64); var result = opGen(src, l); m.Assign(d, result); return(d); } var addr = operand as M68kAddressOperand; if (addr != null) { var load = m.Load(dataWidth, addr.Address); var tmp = binder.CreateTemporary(dataWidth); m.Assign(tmp, opGen(src, load)); m.Assign(load, tmp); return(tmp); } var mem = operand as MemoryOperand; if (mem != null) { var load = RewriteMemoryAccess(mem, dataWidth, addrInstr); var tmp = binder.CreateTemporary(dataWidth); m.Assign(tmp, opGen(src, load)); m.Assign(load, tmp); return(tmp); } var post = operand as PostIncrementMemoryOperand; if (post != null) { var r = binder.EnsureRegister(post.Register); var tmp = binder.CreateTemporary(dataWidth); m.Assign(tmp, opGen(src, m.Load(post.Width, r))); m.Assign(m.Load(dataWidth, r), tmp); m.Assign(r, m.IAdd(r, dataWidth.Size)); return(tmp); } var pre = operand as PredecrementMemoryOperand; if (pre != null) { var r = binder.EnsureRegister(pre.Register); src = Spill(src, r); m.Assign(r, m.ISub(r, dataWidth.Size)); var load = m.Load(dataWidth, r); var tmp = binder.CreateTemporary(dataWidth); m.Assign(tmp, opGen(src, load)); m.Assign(m.Load(dataWidth, r), tmp); return(tmp); } var indidx = operand as IndirectIndexedOperand; if (indidx != null) { Expression ea = binder.EnsureRegister(indidx.ARegister); if (indidx.Imm8 != 0) { ea = m.IAdd(ea, Constant.Int32(indidx.Imm8)); } Expression ix = binder.EnsureRegister(indidx.XRegister); if (indidx.Scale > 1) { ix = m.IMul(ix, Constant.Int32(indidx.Scale)); } var load = m.Load(dataWidth, m.IAdd(ea, ix)); var tmp = binder.CreateTemporary(dataWidth); m.Assign(tmp, opGen(src, load)); m.Assign(load, tmp); return(tmp); } return(null); }
public virtual Address MakeSegmentedAddress(Constant seg, Constant offset) { throw new NotSupportedException("This architecture doesn't support segmented addresses."); }