private void ExtendSegmentCoverage(int segmentIndex, int startOffset, int endOffset)
{
ExecutableSegment segment = GetSegment(segmentIndex);
if (segment.OffsetCoverage.IsSupersetOf(new Range <int>(startOffset, endOffset)))
{
return;
}
// Extend the segment's offset coverage.
if (segment.OffsetCoverage.IsEmpty)
{
segment.OffsetCoverage = new Range <int>(startOffset, endOffset);
}
else
{
segment.OffsetCoverage = new Range <int>(
Math.Min(segment.OffsetCoverage.Begin, startOffset),
Math.Max(segment.OffsetCoverage.End, endOffset));
}
// Shrink the offset bounds of its neighboring segments.
if (segmentIndex > 0)
{
ExecutableSegment segBefore = GetSegment(segmentIndex - 1);
int numBytesOverlap =
(segBefore.Frame * 16 + segBefore.OffsetBounds.End) -
(segment.Frame * 16 + segment.OffsetCoverage.Begin);
if (numBytesOverlap > 0)
{
segBefore.SetOffsetBounds(new Range <int>(
segBefore.OffsetBounds.Begin,
segBefore.OffsetBounds.End - numBytesOverlap));
}
}
if (segmentIndex < base.Segments.Count - 1)
{
ExecutableSegment segAfter = GetSegment(segmentIndex + 1);
int numBytesOverlap =
(segment.Frame * 16 + segment.OffsetCoverage.End) -
(segAfter.Frame * 16 + segAfter.OffsetBounds.Begin);
if (numBytesOverlap > 0)
{
segAfter.SetOffsetBounds(new Range <int>(
segAfter.OffsetBounds.Begin + numBytesOverlap,
segAfter.OffsetBounds.End));
}
}
}
public ExecutableImage(MZFile file)
{
if (file == null)
throw new ArgumentNullException("file");
this.bytes = file.Image;
// Store relocatable locations for future use.
List<int> relocs = new List<int>();
foreach (FarPointer location in file.RelocatableLocations)
{
int index = location.Segment * 16 + location.Offset;
if (index >= 0 && index < bytes.Length - 1)
relocs.Add(index);
}
relocs.Sort();
this.relocatableLocations = relocs.ToArray();
// Guess segmentation info from the segment values to be
// relocated. For example, if a relocatable location contains the
// word 0x1790, it means that 0x1790 will be a segment that will
// be accessed some time during the program's execution.
//
// Although the SEG:OFF addresses of the relocatable locations
// themselves also provide clue about the program's segmentation,
// it is less important because they are not directly referenced
// in the program. Therefore we ignore them for the moment.
foreach (int index in relocatableLocations)
{
UInt16 frame = BitConverter.ToUInt16(bytes, index);
mapFrameToSegment[frame] = -1;
}
mapFrameToSegment[file.EntryPoint.Segment] = -1;
// Create a dummy segment for each of the guessed segments.
// Initially, we set segment.OffsetCoverage to an empty range to
// indicate that we have no knowledge about the start and end
// offset of each segment.
for (int i = 0; i < mapFrameToSegment.Count; i++)
{
UInt16 frameNumber = mapFrameToSegment.Keys[i];
ExecutableSegment segment = new ExecutableSegment(this, i, frameNumber);
// Compute offset bounds for this segment.
// The lower bound is off course zero.
// The upper bound is 15 bytes into the next segment.
int startIndex = frameNumber * 16;
if (startIndex < bytes.Length)
{
int offsetLowerBound = 0;
int offsetUpperBound = Math.Min(bytes.Length - startIndex, 0x10000);
if (i < mapFrameToSegment.Count - 1)
{
offsetUpperBound = Math.Min(
offsetUpperBound,
mapFrameToSegment.Keys[i + 1] * 16 + 15 - startIndex);
}
segment.SetOffsetBounds(
new Range<int>(offsetLowerBound, offsetUpperBound));
}
mapFrameToSegment[frameNumber] = i;
base.Segments.Add(segment);
}
this.entryPoint = new Address(
MapFrameToSegment(file.EntryPoint.Segment), file.EntryPoint.Offset);
}
public ExecutableImage(MZFile file)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
this.bytes = file.Image;
// Store relocatable locations for future use.
List <int> relocs = new List <int>();
foreach (FarPointer location in file.RelocatableLocations)
{
int index = location.Segment * 16 + location.Offset;
if (index >= 0 && index < bytes.Length - 1)
{
relocs.Add(index);
}
}
relocs.Sort();
this.relocatableLocations = relocs.ToArray();
// Guess segmentation info from the segment values to be
// relocated. For example, if a relocatable location contains the
// word 0x1790, it means that 0x1790 will be a segment that will
// be accessed some time during the program's execution.
//
// Although the SEG:OFF addresses of the relocatable locations
// themselves also provide clue about the program's segmentation,
// it is less important because they are not directly referenced
// in the program. Therefore we ignore them for the moment.
foreach (int index in relocatableLocations)
{
UInt16 frame = BitConverter.ToUInt16(bytes, index);
mapFrameToSegment[frame] = -1;
}
mapFrameToSegment[file.EntryPoint.Segment] = -1;
// Create a dummy segment for each of the guessed segments.
// Initially, we set segment.OffsetCoverage to an empty range to
// indicate that we have no knowledge about the start and end
// offset of each segment.
for (int i = 0; i < mapFrameToSegment.Count; i++)
{
UInt16 frameNumber = mapFrameToSegment.Keys[i];
ExecutableSegment segment = new ExecutableSegment(this, i, frameNumber);
// Compute offset bounds for this segment.
// The lower bound is off course zero.
// The upper bound is 15 bytes into the next segment.
int startIndex = frameNumber * 16;
if (startIndex < bytes.Length)
{
int offsetLowerBound = 0;
int offsetUpperBound = Math.Min(bytes.Length - startIndex, 0x10000);
if (i < mapFrameToSegment.Count - 1)
{
offsetUpperBound = Math.Min(
offsetUpperBound,
mapFrameToSegment.Keys[i + 1] * 16 + 15 - startIndex);
}
segment.SetOffsetBounds(
new Range <int>(offsetLowerBound, offsetUpperBound));
}
mapFrameToSegment[frameNumber] = i;
base.Segments.Add(segment);
}
this.entryPoint = new Address(
MapFrameToSegment(file.EntryPoint.Segment), file.EntryPoint.Offset);
}
private int ToLinearAddress(Address address)
{
ExecutableSegment segment = (ExecutableSegment)base.Segments[address.Segment];
return(segment.Frame * 16 + address.Offset);
}
