/// <summary> /// Encodes the displacement in the <see cref="EncodedInstruction"/>. /// </summary> /// <param name="context">The <see cref="Context"/> in which the operand is used.</param> /// <param name="instr">The <see cref="EncodedInstruction"/> encoding the operand.</param> /// <param name="addressSize">The address size used by the effective address.</param> private void EncodeDisplacement(Context context, EncodedInstruction instr, DataSize addressSize) { #region Contract Contract.Requires<ArgumentNullException>(context != null); Contract.Requires<ArgumentNullException>(instr != null); #endregion DataSize displacementSize = DataSize.None; SimpleExpression displacementExpression = null; if (displacement != null) { // Let's evaluate the displacement expression. displacementExpression = displacement(context); // Determine the size of the displacement. displacementSize = addressSize; if (displacementSize == DataSize.None) { // Does the result have a (resolved or not resolved) reference? if (displacementExpression.Reference != null && !displacementExpression.Reference.Resolved) // When the result has a reference, use the architecture's address size. displacementSize = context.Representation.Architecture.AddressSize; else // Otherwise, use the most efficient word size. displacementSize = MathExt.GetSizeOfValue(displacementExpression.Evaluate(context)); //.Constant); } } instr.DisplacementSize = displacementSize; instr.Displacement = displacementExpression; }
/// <summary> /// Emits the immediate value as part of the instruction, if any. /// </summary> /// <param name="writer">The <see cref="BinaryWriter"/> to which the encoded instruction is written.</param> /// <param name="instructionOffset">The offset of the instruction in the stream underlying /// <paramref name="writer"/>.</param> /// <param name="context">The <see cref="Context"/> of the instruction.</param> /// <param name="expression">The <see cref="SimpleExpression"/> to emit.</param> /// <param name="size">The size of the value to emit.</param> private void EmitSimpleExpression(BinaryWriter writer, long instructionOffset, Context context, SimpleExpression expression, DataSize size) { #region Contract Contract.Requires <ArgumentNullException>(writer != null); Contract.Requires <ArgumentNullException>(context != null); Contract.Requires <InvalidEnumArgumentException>(Enum.IsDefined(typeof(DataSize), size)); #endregion if (expression == null) { return; } // Number of bytes before the expression. ulong relocationDiff = (ulong)(writer.BaseStream.Position - instructionOffset); Relocation relocation = null; Int128 actualValue = expression.Evaluate(context); if (expression.Reference != null) { relocation = new Relocation( expression.Reference.Symbol, context.Section, context.Address, actualValue, RelocationType.Default32); } // Emit the expression's value. EmitConstant(writer, size, actualValue); // Add the relocation to the context. if (relocation != null) { relocation.Offset += relocationDiff; context.RelocationTable.Add(relocation); } }
private static bool ProcessSimple(XElement conditionXml, Exchange exchange) { return(SimpleExpression.Evaluate(exchange, conditionXml.Value)); }