public static Trace GenerateEmptyTrace()
{
var newTrace = new Trace();
var instHeader = new TraceElementHeader();
newTrace.Annotations.Add(new AnnotationElement(new TraceElementHeader(), "transmit", "transmit"));
newTrace.Elements.Add(new InstructionOnlyElement(instHeader));
newTrace.Elements.Add(new InstructionDisasmElement(instHeader));
newTrace.Elements.Add(new InstructionDisasmSchemaElement(instHeader));
newTrace.Elements.Add(new InstructionRegsDisasmElement(instHeader));
newTrace.Elements.Add(new InstructionRegsElement(instHeader));
newTrace.Elements.Add(new InstructionOnlyElement(new TraceElementHeader()));
newTrace.Elements.Add(new CallElement(new TraceElementHeader()));
newTrace.Elements.Add(new BranchElement(new TraceElementHeader()));
newTrace.Elements.Add(new ReturnElement(new TraceElementHeader()));
return(newTrace);
}
public static MemoryElementWrite Generate(TraceElementHeader header, BinaryReader reader)
{
var memWrite = new MemoryElementWrite(header)
{
Addr = reader.ReadUInt32()
};
int bytesRemaining = (int)header.Length
//- ( (int)TraceElementHeader.SizeInBytes
- sizeof(uint);
if (bytesRemaining <= 0)
{
memWrite.BytesWritten = new byte[] { }
}
;
else
{
memWrite.BytesWritten = reader.ReadBytes(bytesRemaining);
}
return(memWrite);
}
public MemoryElementWrite(TraceElementHeader header) : base(header)
{
}
public MemoryElementRead(TraceElementHeader header) : base(header)
{
}
protected MemoryElement(TraceElementHeader header) : base(header)
{
}
private static void ProcessTrace(Trace trace, MutableObject traceMutable, bool memTrace = false)
{
//trace.GenerateCallGraph();
//Dictionary< int, FlaggedAnnotation > foundAnnotations = new Dictionary< int, FlaggedAnnotation >();
// foreach ( var annotationElement in trace.Annotations )
// {
// foundAnnotations.Add( (int)annotationElement.Header.InstructionCount, new FlaggedAnnotation { Flagged = false, Annotation = annotationElement } );
// }
Dictionary <int, MutableObject> instructionMutables = new Dictionary <int, MutableObject>();
Dictionary <int, string> comms = new Dictionary <int, string>();
int instructionCount = 0;
foreach (var element in trace.Elements)
{
if (instructionMutables.ContainsKey(element.Header.InstructionCount))
{
continue;
}
var newInstruction = CreateInstructionMutable(element, instructionCount);
instructionMutables.Add(element.Header.InstructionCount, newInstruction);
instructionCount++;
}
int lateAddedAnnotationCount = 0;
// Add any annotations that were not interleaved in the trace (announcer additions; crashes...)
foreach (var annotation in trace.Annotations)
//foundAnnotations.Where( p => p.Value.Flagged == false ) )
{
//instructionMutables.FirstOrDefault( i => (int)i["Original Index"] == (int)pair.Key );
MutableObject foundInstructionMutable;
if (!instructionMutables.ContainsKey(annotation.Header.InstructionCount))
{
var lastElement = trace.Elements.Last();
var newHeader = new TraceElementHeader(
lastElement.Header.RawTypeIndex,
lastElement.Header.Length,
lastElement.Header.WallTime,
lastElement.Header.InstructionCount + 1 + lateAddedAnnotationCount++);
var newElement = new InstructionOnlyElement(newHeader)
{
Eip = lastElement.Eip
};
foundInstructionMutable = CreateInstructionMutable(newElement, instructionCount++);
//foundInstructionMutable[ "Annotated" ] = true;
instructionMutables.Add(newHeader.InstructionCount, foundInstructionMutable);
}
else
{
foundInstructionMutable = instructionMutables[annotation.Header.InstructionCount];
}
SetAnnotationOnInstructionMutable(foundInstructionMutable, annotation, comms);
}
traceMutable.Add("Instructions", instructionMutables.Values);
traceMutable.Add("InstructionCount", instructionMutables.Count);
if (memTrace)
{
var memReads = new List <MutableObject>();
foreach (var memRead in trace.MemoryReads)
{
var newRead = new MutableObject()
{
{ "Read Address", (uint)memRead.Addr },
{ "Read Hex", StringExtensions.ByteArrayToString(memRead.BytesRead) },
{ "Read Size", memRead.NumberOfBytesRead },
{ "Original Index", memRead.Header.InstructionCount }
};
// match original index to get processed index
if (instructionMutables.ContainsKey(memRead.Header.InstructionCount))
{
newRead["Processed Index"] =
instructionMutables[memRead.Header.InstructionCount]["Processed Index"];
}
else
{
newRead["Processed Index"] = 0;
}
memReads.Add(newRead);
}
traceMutable.Add("Memory Reads", memReads);
var memWrites = new List <MutableObject>();
foreach (var memWrite in trace.MemoryWrites)
{
var newWrite = new MutableObject()
{
{ "Write Address", (uint)memWrite.Addr },
{ "Write Hex", StringExtensions.ByteArrayToString(memWrite.BytesWritten) },
{ "Write Size", memWrite.NumberOfBytesWritten },
{ "Original Index", memWrite.Header.InstructionCount }
//memWrite.Header.InstructionCount }
};
// match original index to get processed index
if (instructionMutables.ContainsKey(memWrite.Header.InstructionCount))
{
newWrite["Processed Index"] =
instructionMutables[memWrite.Header.InstructionCount]["Processed Index"];
}
else
{
newWrite["Processed Index"] = 0;
}
memWrites.Add(newWrite);
}
;
traceMutable.Add("Memory Writes", memWrites);
}
var sb = new StringBuilder("Comms:\n");
foreach (var c in comms)
{
sb.AppendLine(string.Format("{0:D5} {1}", c.Key, c.Value));
}
//Debug.Log( sb.ToString() );
}
private void ReadElements(BinaryReader reader)
{
////////////DEBUG////////
//Random rand = new Random(1337);
//string[] elementTypes = new string[]
//{
// "start1",
// "end1",
// "transmit",
// "receive",
// "terminate",
// "fdwait",
// "random",
// "allocate",
// "free",
//};
///////////////////////
Elements = new List <InstructionElement>();
Annotations = new List <AnnotationElement>();
MemoryReads = new List <MemoryElementRead>();
MemoryWrites = new List <MemoryElementWrite>();
while (reader.PeekChar() != -1)
{
var elementHeader = TraceElementHeader.Generate(reader);
if (!Generators.ContainsKey(elementHeader.RawTypeIndex))
{
Console.WriteLine("No generator for index {0}.", elementHeader.RawTypeIndex);
continue;
}
var newElement = Generators[elementHeader.RawTypeIndex](elementHeader, reader);
if (newElement is TypeDeclarationElement)
{
var typeDeclarationElement = newElement as TypeDeclarationElement;
if (typeDeclarationElement.ElementTypeStringIdentifier == null)
{
throw new Exception("Element isn't a type declaration...?");
}
if (!MasterGenerators.ContainsKey(typeDeclarationElement.ElementTypeStringIdentifier))
{
Console.WriteLine("No master generator specified for type {0} of index {1}.", typeDeclarationElement.ElementTypeStringIdentifier, typeDeclarationElement.ElementTypeIndex);
continue;
}
var generationMethod = MasterGenerators[typeDeclarationElement.ElementTypeStringIdentifier];
Generators.Add(typeDeclarationElement.ElementTypeIndex, generationMethod);
}
else if (newElement is PerfElement)
{
}
else if (newElement is InstructionElement)
{
Elements.Add(newElement as InstructionElement);
//////////////DEBUG
//if (SpoofAnnotations)
//{
// if (rand.Next(40) > 38)
// {
// var eventType = elementTypes[rand.Next(elementTypes.Length)];
// var newAnnotation = new AnnotationElement(newElement.Header,
// eventType,
// eventType + " rolled a " + rand.Next(20));
// Annotations.Add(newAnnotation);
// }
//}
////////////////
continue;
}
else if (newElement is AnnotationElement)
{
Annotations.Add(newElement as AnnotationElement);
}
else if (newElement is MemoryElementRead)
{
MemoryReads.Add(newElement as MemoryElementRead);
}
else if (newElement is MemoryElementWrite)
{
MemoryWrites.Add(newElement as MemoryElementWrite);
}
else
{
Console.WriteLine("Unknown type! {0}", newElement.GetType());
}
}
}
