public SymbolicMemoryOperand(MemoryOperand opr, SymbolicTarget target) { base.Base = opr.Base; base.Displacement = opr.Displacement; base.Index = opr.Index; base.Scaling = opr.Scaling; base.Segment = opr.Segment; base.Size = opr.Size; this.Target = target; }
protected override Address ResolveFlowInstructionTarget(PointerOperand operand) { SymbolicTarget symbolicTarget = operand.Tag as SymbolicTarget; if (symbolicTarget != null) { Address symbolicAddress = ResolveSymbolicTarget(symbolicTarget); return(symbolicAddress); } return(base.ResolveFlowInstructionTarget(operand)); }
private Address ResolveSymbolicTarget(SymbolicTarget symbolicTarget) { Address referentAddress = symbolicTarget.Referent.Resolve(); if (referentAddress == Address.Invalid) { //AddError(start, ErrorCode.UnresolvedTarget, // "Cannot resolve target: {0}.", symbolicTarget); return(Address.Invalid); } Address symbolicAddress = referentAddress + (int)symbolicTarget.Displacement; return(symbolicAddress); }
protected override Address ResolveFlowInstructionTarget(RelativeOperand operand) { SymbolicTarget symbolicTarget = operand.Tag as SymbolicTarget; if (symbolicTarget != null) { Address symbolicAddress = ResolveSymbolicTarget(symbolicTarget); if (symbolicAddress != Address.Invalid) { Address target = symbolicAddress + operand.Offset.Value; return(new Address(target.Segment, (UInt16)target.Offset)); } return(Address.Invalid); } return(base.ResolveFlowInstructionTarget(operand)); }
public SymbolicPointerOperand(SymbolicTarget target) { this.Target = target; }
public SymbolicImmediateOperand(ImmediateOperand opr, SymbolicTarget target) : base(opr.Immediate, opr.Size) { this.Target = target; }
public SymbolicRelativeOperand(SymbolicTarget target) { this.Target = target; }
private void UpdateImage(ObjectModule module) { #if false // For each segment, construct a list of LEDATA/LIDATA records. // These records fill data into the segment. // It is required that the data do not overlap, and do not // exceed segment boundary (here we only support 16-bit segments, // whose maximum size is 64KB). // Find the first CODE segment. LogicalSegment codeSegment = null; foreach (var seg in module.Segments) { if (seg.Class == "CODE") { codeSegment = seg; break; } } if (codeSegment == null) return; // Create a BinaryImage with the code. BinaryImage image = new BinaryImage(codeSegment.Image.Data, new Pointer(0, 0)); // Disassemble the instructions literally. Note that this should // be improved, but we don't do that yet. var addr = image.BaseAddress; for (var i = image.StartAddress; i < image.EndAddress; ) { var instruction = image.DecodeInstruction(addr); // An operand may have zero or one component that may be // fixed up. Check this. #if false for (int k = 0; k < instruction.Operands.Length; k++) { var operand = instruction.Operands[k]; if (operand is RelativeOperand) { var opr = (RelativeOperand)operand; var loc = opr.Offset.Location; int j = i - image.StartAddress + loc.StartOffset; int fixupIndex = codeSegment.DataFixups[j]; if (fixupIndex != 0) { FixupDefinition fixup = codeSegment.Fixups[fixupIndex - 1]; if (fixup.DataOffset != j) continue; var target = new SymbolicTarget(fixup, module); instruction.Operands[k] = new SymbolicRelativeOperand(target); System.Diagnostics.Debug.WriteLine(instruction.ToString()); } } } #endif image.CreatePiece(addr, addr + instruction.EncodedLength, ByteType.Code); image[addr].Instruction = instruction; addr = addr.Increment(instruction.EncodedLength); // TODO: we need to check more accurately. #if false // Check if any bytes covered by this instruction has a fixup // record associated with it. Note that an instruction might // have multiple fixup records associated with it, such as // in a far call. for (int j = 0; j < instruction.EncodedLength; j++) { int fixupIndex = codeSegment.DataFixups[i - image.StartAddress + j]; if (fixupIndex != 0) { FixupDefinition fixup = codeSegment.Fixups[fixupIndex - 1]; if (fixup.DataOffset != i - image.StartAddress + j) continue; if (fixup.Target.Method == FixupTargetSpecFormat.ExternalPlusDisplacement || fixup.Target.Method == FixupTargetSpecFormat.ExternalWithoutDisplacement) { var extIndex = fixup.Target.IndexOrFrame; var extName = module.ExternalNames[extIndex - 1]; var disp = fixup.Target.Displacement; System.Diagnostics.Debug.WriteLine(string.Format( "{0} refers to {1}+{2} : {3}", instruction, extName, disp, fixup.Location)); } } } #endif i += instruction.EncodedLength; } // ... // Display the code in our disassmbly window. if (this.ListingWindow != null) { Document doc = new Document(); doc.Image = image; this.ListingWindow.Document = doc; } #endif }
private Address ResolveSymbolicTarget(SymbolicTarget symbolicTarget) { Address referentAddress = symbolicTarget.Referent.Resolve(); if (referentAddress == Address.Invalid) { //AddError(start, ErrorCode.UnresolvedTarget, // "Cannot resolve target: {0}.", symbolicTarget); return Address.Invalid; } Address symbolicAddress = referentAddress + (int)symbolicTarget.Displacement; return symbolicAddress; }