Esempio n. 1
0
        /// <summary>
        /// Writes the execution data of the given trace file into the given output file.
        /// </summary>
        /// <param name="traceFile">The trace file to be converted.</param>
        /// <param name="outputFileName">The output file name.</param>
        /// <param name="callChainInstructionAddress">The address of the instruction for which a call chain shall be printed (else 0).</param>
        /// <param name="relativeMemoryAddresses">Determines whether allocation block accesses should be converted to their relative offsets.</param>
        public void Dump(TraceFile traceFile, string outputFileName, uint callChainInstructionAddress, bool relativeMemoryAddresses)
        {
            // Make sure that all entries are loaded (the trace file is iterated two times simultaneously)
            traceFile.CacheEntries();

            // Print call chain?
            if (callChainInstructionAddress != 0)
            {
                Program.Log($"Call chain instruction address: 0x{callChainInstructionAddress.ToString("X8")}\n", Program.LogLevel.Debug);
            }

            // Open output file for writing
            TextWriter outputWriter = null;

            using (!string.IsNullOrWhiteSpace(outputFileName) ? outputWriter = new StreamWriter(File.Open(outputFileName, FileMode.Create)) : outputWriter = Console.Out)
            {
                // Run through entries
                Stack <string> callStack       = new Stack <string>();
                int            callLevel       = 0;
                int            entryIndexWidth = (int)Math.Ceiling(Math.Log10(traceFile.EntryCount));
                int            i = 0;
                var            traceFileEntryEncoder = TraceFileDiff.EncodeTraceEntries(traceFile).GetEnumerator();
                foreach (TraceEntry entry in traceFile.Entries)
                {
                    // Get encoding for current entry
                    traceFileEntryEncoder.MoveNext();
                    long encodedEntry = traceFileEntryEncoder.Current;

                    // Print entry index
                    outputWriter.Write($"[{i.ToString().PadLeft(entryIndexWidth, ' ')}] \t");

                    // Add indentation depending on call level
                    outputWriter.Write(new string('\t', callLevel));

                    // Print entry depending on type
                    switch (entry.EntryType)
                    {
                    case TraceEntryTypes.Allocation:
                    {
                        // Print entry
                        AllocationEntry allocationEntry = (AllocationEntry)entry;
                        outputWriter.WriteLine($"Alloc {allocationEntry.Address.ToString("X16")} :: {(allocationEntry.Address + allocationEntry.Size).ToString("X16")}, {allocationEntry.Size} bytes");

                        break;
                    }

                    case TraceEntryTypes.Free:
                    {
                        // Print entry
                        FreeEntry freeEntry = (FreeEntry)entry;
                        outputWriter.WriteLine($"Free {freeEntry.Address}");

                        break;
                    }

                    case TraceEntryTypes.AllocMemoryRead:
                    case TraceEntryTypes.AllocMemoryWrite:
                    case TraceEntryTypes.ImageMemoryRead:
                    case TraceEntryTypes.ImageMemoryWrite:
                    {
                        uint instructionAddr = 0;
                        switch (entry.EntryType)
                        {
                        case TraceEntryTypes.AllocMemoryRead:
                        {
                            // Retrieve function name of executed instruction
                            AllocMemoryReadEntry allocMemoryReadEntry = (AllocMemoryReadEntry)entry;
                            instructionAddr = allocMemoryReadEntry.InstructionAddress;
                            string formattedInstructionAddress = FormatAddressWithSymbolNames(allocMemoryReadEntry.InstructionAddress, allocMemoryReadEntry.ImageId, allocMemoryReadEntry.ImageName);

                            // Get allocation block relative offset from encoded entry
                            uint   addressPart            = (uint)(encodedEntry >> 32);
                            string formattedMemoryAddress = allocMemoryReadEntry.MemoryAddress.ToString("X16");
                            if (relativeMemoryAddresses && addressPart != 0)
                            {
                                formattedMemoryAddress = $"rel:{addressPart.ToString("X")}";
                            }

                            // Print entry
                            outputWriter.WriteLine($"MemRead <0x{allocMemoryReadEntry.InstructionAddress:X8} {formattedInstructionAddress}>  {formattedMemoryAddress}");

                            break;
                        }

                        case TraceEntryTypes.AllocMemoryWrite:
                        {
                            // Retrieve function name of executed instruction
                            AllocMemoryWriteEntry allocMemoryWriteEntry = (AllocMemoryWriteEntry)entry;
                            instructionAddr = allocMemoryWriteEntry.InstructionAddress;
                            string formattedInstructionAddress = FormatAddressWithSymbolNames(allocMemoryWriteEntry.InstructionAddress, allocMemoryWriteEntry.ImageId, allocMemoryWriteEntry.ImageName);

                            // Get allocation block relative offset from encoded entry
                            uint   addressPart            = (uint)(encodedEntry >> 32);
                            string formattedMemoryAddress = allocMemoryWriteEntry.MemoryAddress.ToString("X16");
                            if (relativeMemoryAddresses && addressPart != 0)
                            {
                                formattedMemoryAddress = $"rel:{addressPart.ToString("X")}";
                            }

                            // Print entry
                            outputWriter.WriteLine($"MemWrite <0x{allocMemoryWriteEntry.InstructionAddress:X8} {formattedInstructionAddress}>  {formattedMemoryAddress}");

                            break;
                        }

                        case TraceEntryTypes.ImageMemoryRead:
                        {
                            // Retrieve function name of executed instruction
                            ImageMemoryReadEntry imageMemoryReadEntry = (ImageMemoryReadEntry)entry;
                            instructionAddr = imageMemoryReadEntry.InstructionAddress;
                            string formattedInstructionAddress = FormatAddressWithSymbolNames(imageMemoryReadEntry.InstructionAddress, imageMemoryReadEntry.InstructionImageId, imageMemoryReadEntry.InstructionImageName);

                            // Print entry
                            outputWriter.WriteLine($"ImgRead <0x{imageMemoryReadEntry.InstructionAddress:X8} {formattedInstructionAddress}>  {imageMemoryReadEntry.MemoryImageName}+{imageMemoryReadEntry.MemoryAddress.ToString("X8")}");

                            break;
                        }

                        case TraceEntryTypes.ImageMemoryWrite:
                        {
                            // Retrieve function name of executed instruction
                            ImageMemoryWriteEntry imageMemoryWriteEntry = (ImageMemoryWriteEntry)entry;
                            instructionAddr = imageMemoryWriteEntry.InstructionAddress;
                            string formattedInstructionAddress = FormatAddressWithSymbolNames(imageMemoryWriteEntry.InstructionAddress, imageMemoryWriteEntry.InstructionImageId, imageMemoryWriteEntry.InstructionImageName);

                            // Print entry
                            outputWriter.WriteLine($"ImgWrite <0x{imageMemoryWriteEntry.InstructionAddress:X8} {formattedInstructionAddress}>  {imageMemoryWriteEntry.MemoryImageName}+{imageMemoryWriteEntry.MemoryAddress.ToString("X8")}");

                            break;
                        }
                        }

                        // Output call chain of this instruction?
                        if (instructionAddr == callChainInstructionAddress)
                        {
                            outputWriter.WriteLine($"[{new string('-', entryIndexWidth)}] CALL CHAIN:");
                            foreach (string call in callStack.Reverse())
                            {
                                outputWriter.Write($"{new string(' ', 1 + entryIndexWidth + 1 + 1 + 4)}");
                                outputWriter.WriteLine(call);
                            }
                        }
                        break;
                    }

                    case TraceEntryTypes.Branch:
                    {
                        // Retrieve function names of instructions
                        BranchEntry branchEntry = (BranchEntry)entry;
                        string      formattedSourceInstructionAddress      = FormatAddressWithSymbolNames(branchEntry.SourceInstructionAddress, branchEntry.SourceImageId, branchEntry.SourceImageName);
                        string      formattedDestinationInstructionAddress = FormatAddressWithSymbolNames(branchEntry.DestinationInstructionAddress, branchEntry.DestinationImageId, branchEntry.DestinationImageName);

                        // Output entry and update call level
                        if (branchEntry.BranchType == BranchTypes.Call)
                        {
                            string lg = $"Call <0x{branchEntry.SourceInstructionAddress:X8} {formattedSourceInstructionAddress}>    ->    <0x{branchEntry.DestinationInstructionAddress:X8} {formattedDestinationInstructionAddress}>";
                            outputWriter.WriteLine(lg);
                            callStack.Push(lg);
                            ++callLevel;
                        }
                        else if (branchEntry.BranchType == BranchTypes.Ret)
                        {
                            outputWriter.WriteLine($"Return <0x{branchEntry.SourceInstructionAddress:X8} {formattedSourceInstructionAddress}>    ->    <0x{branchEntry.DestinationInstructionAddress:X8} {formattedDestinationInstructionAddress}>");
                            if (callStack.Count() > 0)
                            {
                                callStack.Pop();
                            }
                            --callLevel;

                            // Check indentation
                            if (callLevel < 0)
                            {
                                // Just output a warning, this was probably caused by trampoline functions and similar constructions
                                callLevel = 0;
                                Program.Log($"Warning: Indentation error in line {i}\n", Program.LogLevel.Warning);
                            }
                        }
                        else if (branchEntry.BranchType == BranchTypes.Jump)
                        {
                            outputWriter.WriteLine($"Jump <0x{branchEntry.SourceInstructionAddress:X8} {formattedSourceInstructionAddress}>    ->    <0x{branchEntry.DestinationInstructionAddress:X8} {formattedDestinationInstructionAddress}> {(branchEntry.Taken ? "" : "not ")}taken");
                        }

                        break;
                    }
                    }

                    // Next entry
                    ++i;
                }
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Encodes all entries of the given trace file as 64-bit integers. This implies a loss of information.
        /// The least significant 4 bits of each entry will contain the entry type (directly casted from <see cref="TraceEntryTypes"/>).
        /// </summary>
        /// <param name="traceFile">The trace file to be encoded.</param>
        /// <returns>A list of encoded trace entries.</returns>
        public static IEnumerable <long> EncodeTraceEntries(TraceFile traceFile)
        {
            // Initialize stack memory allocation block
            AllocationData stackMemory = new AllocationData
            {
                AllocationLineNumber = 0,
                FreeLineNumber       = traceFile.EntryCount, // Never freed
                StartAddress         = traceFile.StackPointerMin,
                EndAddress           = traceFile.StackPointerMax
            };

            // Run through entries
            int line = 0;
            SortedList <int, AllocationData> allocs = new SortedList <int, AllocationData>();

            foreach (TraceEntry entry in traceFile.Entries)
            {
                // Encode type right away
                ulong enc = (ulong)entry.EntryType;
                switch (entry.EntryType)
                {
                case TraceEntryTypes.Allocation:
                {
                    // Save allocation data
                    AllocationEntry allocationEntry = (AllocationEntry)entry;
                    allocs[line] = new AllocationData()
                    {
                        AllocationLineNumber = line,
                        FreeLineNumber       = traceFile.EntryCount, // First assume as never freed, is overwritten as soon as a matching free is encountered
                        StartAddress         = allocationEntry.Address,
                        EndAddress           = allocationEntry.Address + allocationEntry.Size
                    };

                    // Encode allocation size
                    enc |= (ulong)allocationEntry.Size << 4;
                    break;
                }

                case TraceEntryTypes.Free:
                {
                    // Find corresponding allocation block to mark as freed
                    FreeEntry freeEntry       = (FreeEntry)entry;
                    var       allocCandidates = allocs.Where(a => a.Key <= line && a.Value.FreeLineNumber >= line && a.Value.StartAddress == freeEntry.Address);
                    if (!allocCandidates.Any())
                    {
                        // TODO Error handling (same problem as in TraceFileComparer)
                        //Debug.WriteLine($"Warning! Processing line {line}: Skipped free() without any matching allocation block.");
                    }
                    else
                    {
                        // Mark block as freed
                        AllocationData allocData = allocCandidates.First().Value;
                        allocData.FreeLineNumber = line;
                    }

                    // Not encoded
                    break;
                }

                case TraceEntryTypes.ImageMemoryRead:
                {
                    // Encode instruction and address offset
                    ImageMemoryReadEntry imageMemoryReadEntry = (ImageMemoryReadEntry)entry;
                    enc |= imageMemoryReadEntry.InstructionAddress << 4;
                    enc |= (ulong)imageMemoryReadEntry.MemoryAddress << 32;
                    break;
                }

                case TraceEntryTypes.ImageMemoryWrite:
                {
                    // Encode instruction and address offset
                    ImageMemoryWriteEntry imageMemoryWriteEntry = (ImageMemoryWriteEntry)entry;
                    enc |= imageMemoryWriteEntry.InstructionAddress << 4;
                    enc |= (ulong)imageMemoryWriteEntry.MemoryAddress << 32;
                    break;
                }

                case TraceEntryTypes.AllocMemoryRead:
                {
                    // Find related allocation block
                    // Stack or heap?
                    AllocMemoryReadEntry allocMemoryReadEntry = (AllocMemoryReadEntry)entry;
                    AllocationData       allocData            = stackMemory;
                    if (allocMemoryReadEntry.MemoryAddress < stackMemory.StartAddress || stackMemory.EndAddress < allocMemoryReadEntry.MemoryAddress)
                    {
                        // Heap?
                        var allocCandidates = allocs.Where(a => a.Key <= line && a.Value.FreeLineNumber >= line && a.Value.StartAddress <= allocMemoryReadEntry.MemoryAddress && allocMemoryReadEntry.MemoryAddress <= a.Value.EndAddress);
                        if (!allocCandidates.Any())
                        {
                            // TODO error handling - caused by missed malloc()
                            //Program.Log($"Error: Could not find allocation block for [{line}] {allocMemoryReadEntry.ToString()}\n", Program.LogLevel.Error);
                            Debug.WriteLine($"Error: Could not find allocation block for [{line}] {allocMemoryReadEntry.ToString()}");
                            break;
                        }
                        else
                        {
                            allocData = allocCandidates.Last().Value;
                        }
                    }

                    // Encode instruction address, the size of the allocation block, and the offset
                    enc |= allocMemoryReadEntry.InstructionAddress << 4;
                    enc |= (allocMemoryReadEntry.MemoryAddress - allocData.StartAddress) << 32;
                    //enc |= (allocData.EndAddress - allocData.StartAddress) << 48; // Only catches sizes less than 64 KB (16 bit address space)
                    break;
                }

                case TraceEntryTypes.AllocMemoryWrite:
                {
                    // Find related allocation block
                    // Stack or heap?
                    AllocMemoryWriteEntry allocMemoryWriteEntry = (AllocMemoryWriteEntry)entry;
                    AllocationData        allocData             = stackMemory;
                    if (allocMemoryWriteEntry.MemoryAddress < stackMemory.StartAddress || stackMemory.EndAddress < allocMemoryWriteEntry.MemoryAddress)
                    {
                        // Heap?
                        var allocCandidates = allocs.Where(a => a.Key <= line && a.Value.FreeLineNumber >= line && a.Value.StartAddress <= allocMemoryWriteEntry.MemoryAddress && allocMemoryWriteEntry.MemoryAddress <= a.Value.EndAddress);
                        if (!allocCandidates.Any())
                        {
                            // TODO error handling - caused by missed malloc()
                            //Program.Log($"Error: Could not find allocation block for [{line}] {allocMemoryWriteEntry.ToString()}\n", Program.LogLevel.Error);
                            Debug.WriteLine($"Error: Could not find allocation block for [{line}] {allocMemoryWriteEntry.ToString()}");
                            break;
                        }
                        else
                        {
                            allocData = allocCandidates.Last().Value;
                        }
                    }

                    // Encode instruction address, the size of the allocation block, and the offset
                    enc |= allocMemoryWriteEntry.InstructionAddress << 4;
                    enc |= (allocMemoryWriteEntry.MemoryAddress - allocData.StartAddress) << 32;
                    //enc |= (allocData.EndAddress - allocData.StartAddress) << 48; // Only catches sizes less than 64 KB (16 bit address space)
                    break;
                }

                case TraceEntryTypes.Branch:
                {
                    // Encode branch source and destination image offsets, and the "taken" flag
                    BranchEntry branchEntry = (BranchEntry)entry;
                    enc |= branchEntry.SourceInstructionAddress << 4;
                    enc |= (ulong)branchEntry.DestinationInstructionAddress << 32;
                    enc |= (ulong)(branchEntry.Taken ? 1 : 0) << 63;
                    break;
                }
                }
                yield return(unchecked ((long)enc));

                ++line;
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Reads all entries from the trace file using deferred execution.
        /// </summary>
        /// <returns></returns>
        private IEnumerable <TraceEntry> ReadEntriesLazily()
        {
            // Read trace entries
            _traceFileReader.Position = _headerEndOffset;
            for (int i = 0; i < _traceEntryCount; ++i)
            {
                // Read depending on type
                TraceEntryTypes entryType = (TraceEntryTypes)_traceFileReader.ReadByte();
                switch (entryType)
                {
                case TraceEntryTypes.Allocation:
                {
                    AllocationEntry entry = new AllocationEntry();
                    entry.Size    = _traceFileReader.ReadUInt32();
                    entry.Address = _traceFileReader.ReadUInt64();

                    yield return(entry);

                    break;
                }

                case TraceEntryTypes.Free:
                {
                    FreeEntry entry = new FreeEntry();
                    entry.Address = _traceFileReader.ReadUInt64();

                    yield return(entry);

                    break;
                }

                case TraceEntryTypes.ImageMemoryRead:
                {
                    ImageMemoryReadEntry entry = new ImageMemoryReadEntry();
                    entry.InstructionImageId   = _imageIdLookup[_traceFileReader.ReadByte()];
                    entry.InstructionImageName = _knownImages[entry.InstructionImageId];
                    entry.InstructionAddress   = _traceFileReader.ReadUInt32();
                    entry.MemoryImageId        = _imageIdLookup[_traceFileReader.ReadByte()];
                    entry.MemoryImageName      = _knownImages[entry.MemoryImageId];
                    entry.MemoryAddress        = (uint)(_traceFileReader.ReadUInt32() & _alignmentOperand);

                    yield return(entry);

                    break;
                }

                case TraceEntryTypes.ImageMemoryWrite:
                {
                    ImageMemoryWriteEntry entry = new ImageMemoryWriteEntry();
                    entry.InstructionImageId   = _imageIdLookup[_traceFileReader.ReadByte()];
                    entry.InstructionImageName = _knownImages[entry.InstructionImageId];
                    entry.InstructionAddress   = _traceFileReader.ReadUInt32();
                    entry.MemoryImageId        = _imageIdLookup[_traceFileReader.ReadByte()];
                    entry.MemoryImageName      = _knownImages[entry.MemoryImageId];
                    entry.MemoryAddress        = (uint)(_traceFileReader.ReadUInt32() & _alignmentOperand);

                    yield return(entry);

                    break;
                }

                case TraceEntryTypes.AllocMemoryRead:
                {
                    AllocMemoryReadEntry entry = new AllocMemoryReadEntry();
                    entry.ImageId            = _imageIdLookup[_traceFileReader.ReadByte()];
                    entry.ImageName          = _knownImages[entry.ImageId];
                    entry.InstructionAddress = _traceFileReader.ReadUInt32();
                    entry.MemoryAddress      = _traceFileReader.ReadUInt64() & _alignmentOperand;

                    yield return(entry);

                    break;
                }

                case TraceEntryTypes.AllocMemoryWrite:
                {
                    AllocMemoryWriteEntry entry = new AllocMemoryWriteEntry();
                    entry.ImageId            = _imageIdLookup[_traceFileReader.ReadByte()];
                    entry.ImageName          = _knownImages[entry.ImageId];
                    entry.InstructionAddress = _traceFileReader.ReadUInt32();
                    entry.MemoryAddress      = _traceFileReader.ReadUInt64() & _alignmentOperand;

                    yield return(entry);

                    break;
                }

                case TraceEntryTypes.Branch:
                {
                    BranchEntry entry = new BranchEntry();
                    entry.SourceImageId                 = _imageIdLookup[_traceFileReader.ReadByte()];
                    entry.SourceImageName               = _knownImages[entry.SourceImageId];
                    entry.SourceInstructionAddress      = _traceFileReader.ReadUInt32();
                    entry.DestinationImageId            = _imageIdLookup[_traceFileReader.ReadByte()];
                    entry.DestinationImageName          = _knownImages[entry.DestinationImageId];
                    entry.DestinationInstructionAddress = _traceFileReader.ReadUInt32();
                    entry.Taken      = _traceFileReader.ReadBoolean();
                    entry.BranchType = (BranchTypes)_traceFileReader.ReadByte();

                    yield return(entry);

                    break;
                }
                }
            }
        }
Esempio n. 4
0
        /// <summary>
        /// Executes the comparison and returns whether the two traces have identical memory access patterns.
        /// </summary>
        /// <returns></returns>
        public bool Compare()
        {
            // Run linearily through trace entries and compare them
            // If the traces have different length, use the shorter one as reference
            // This should not lead to wrong results: The shorter trace won't just randomly end, instead there has to be some kind of branch mismatch before
            // Keep track of currently allocated datablocks
            AllocationData stackMemory = new AllocationData() // StartAddress = Top of stack, EndAddress = Bottom of stack
            {
                StartAddress1 = TraceFile1.StackPointerMin,
                StartAddress2 = TraceFile2.StackPointerMin,
                EndAddress1   = TraceFile1.StackPointerMax,
                EndAddress2   = TraceFile2.StackPointerMax
            };
            int totalEntries         = Math.Min(TraceFile1.EntryCount, TraceFile2.EntryCount);
            var traceFile1Enumerator = TraceFile1.Entries.GetEnumerator();
            var traceFile2Enumerator = TraceFile2.Entries.GetEnumerator();

            for (int i = 0; i < totalEntries; ++i)
            {
                // Retrieve entries
                traceFile1Enumerator.MoveNext();
                traceFile2Enumerator.MoveNext();
                TraceEntry e1 = traceFile1Enumerator.Current;
                TraceEntry e2 = traceFile2Enumerator.Current;

                // The entries should have the same type
                // If not, something must have gone very wrong: Differing branches are detected, so we should not run into differing instructions
                if (e1.EntryType != e2.EntryType)
                {
                    Result = ComparisonResults.ExecutionFlow_DifferentType;
                    ComparisonErrorLine  = i;
                    ComparisonErrorItems = new Tuple <TraceEntry, TraceEntry>(e1, e2);
                    if (PrintResults)
                    {
                        PrintComparisonResult($"Entries #{i} have different type (probably some bigger error occured?).", false,
                                              $"Trace 1: {e1.ToString()}",
                                              $"Trace 2: {e2.ToString()}");
                    }
                    return(false);
                }

                // Act depending on entry types
                switch (e1.EntryType)
                {
                // Possible leakages:
                // - Different branch targets
                // - In one execution the branch is taken, in the other one not
                case TraceEntryTypes.Branch:
                {
                    // Cast entries
                    BranchEntry branch1 = (BranchEntry)e1;
                    BranchEntry branch2 = (BranchEntry)e2;

                    // Compare targets
                    if (branch1.DestinationImageId != branch2.DestinationImageId || branch1.DestinationInstructionAddress != branch2.DestinationInstructionAddress)
                    {
                        Result = ComparisonResults.ExecutionFlow_DifferentBranchTarget;
                        ComparisonErrorLine  = i;
                        ComparisonErrorItems = new Tuple <TraceEntry, TraceEntry>(e1, e2);
                        if (PrintResults)
                        {
                            PrintComparisonResult($"Entries #{i}: Different branch target: <{branch1.DestinationImageName}+{branch1.DestinationInstructionAddress.ToString("X8")}> vs. <{branch2.DestinationImageName}+{branch2.DestinationInstructionAddress.ToString("X8")}>", false,
                                                  $"Trace 1: {e1.ToString()}",
                                                  $"Trace 2: {e2.ToString()}");
                        }
                        return(false);
                    }

                    // Compare "taken"
                    if (branch1.Taken != branch2.Taken)
                    {
                        if (branch1.Taken)
                        {
                            Result = ComparisonResults.ExecutionFlow_BranchTakenIn1;
                            ComparisonErrorLine  = i;
                            ComparisonErrorItems = new Tuple <TraceEntry, TraceEntry>(e1, e2);
                            if (PrintResults)
                            {
                                PrintComparisonResult($"Entries #{i}: Branch to <{branch1.DestinationImageName}+{branch1.DestinationInstructionAddress.ToString("X8")}> taken in trace 1, but not in trace 2.", false,
                                                      $"Trace 1: {e1.ToString()}",
                                                      $"Trace 2: {e2.ToString()}");
                            }
                        }
                        else
                        {
                            Result = ComparisonResults.ExecutionFlow_BranchTakenIn2;
                            ComparisonErrorLine  = i;
                            ComparisonErrorItems = new Tuple <TraceEntry, TraceEntry>(e1, e2);
                            if (PrintResults)
                            {
                                PrintComparisonResult($"Entries #{i}: Branch to <{branch1.DestinationImageName}+{branch1.DestinationInstructionAddress.ToString("X8")}> not taken in trace 1, but in trace 2.", false,
                                                      $"Trace 1: {e1.ToString()}",
                                                      $"Trace 2: {e2.ToString()}");
                            }
                        }
                        return(false);
                    }

                    // OK
                    break;
                }

                // Store allocation metadata
                // Possible leakages:
                // - The allocation size might differ
                case TraceEntryTypes.Allocation:
                {
                    // Cast entries
                    AllocationEntry alloc1 = (AllocationEntry)e1;
                    AllocationEntry alloc2 = (AllocationEntry)e2;

                    // Compare sizes
                    if (alloc1.Size != alloc2.Size)
                    {
                        Result = ComparisonResults.MemoryAccess_DifferentAllocationSize;
                        ComparisonErrorLine  = i;
                        ComparisonErrorItems = new Tuple <TraceEntry, TraceEntry>(e1, e2);
                        if (PrintResults)
                        {
                            PrintComparisonResult($"Entries #{i}: Allocation size differs: {alloc1.Size} vs. {alloc2.Size}", false,
                                                  $"Trace 1: {e1.ToString()}",
                                                  $"Trace 2: {e2.ToString()}");
                        }
                        return(false);
                    }

                    // Save allocation data
                    _allocs[alloc1.Address] = new AllocationData()
                    {
                        StartAddress1 = alloc1.Address,
                        EndAddress1   = alloc1.Address + alloc1.Size,
                        StartAddress2 = alloc2.Address,
                        EndAddress2   = alloc2.Address + alloc2.Size
                    };

                    // OK
                    break;
                }

                // Remove allocation metadata from list
                case TraceEntryTypes.Free:
                {
                    // Cast entries
                    FreeEntry free1 = (FreeEntry)e1;
                    FreeEntry free2 = (FreeEntry)e2;

                    // Make sure the frees apply to the same datablock
                    if (!_allocs.TryGetValue(free1.Address, out AllocationData freeCandidate))
                    {
                        /*Result = ComparisonResults.MemoryAccess_FreedBlockNotFound;
                         * ComparisonErrorLine = i;
                         * PrintComparisonResult($"Entries #{i}: Cannot find freed allocation block for execution trace 1.", false,
                         *  $"Trace 1: {e1.ToString()}",
                         *  $"Trace 2: {e2.ToString()}");
                         * // TODO This line is triggered in the Alloc/Free prefix, when one malloc() call was missed
                         * return false;*/
                    }
                    else if (freeCandidate.StartAddress2 != free2.Address)
                    {
                        Result = ComparisonResults.MemoryAccess_FreedBlockNotMatching;
                        ComparisonErrorLine  = i;
                        ComparisonErrorItems = new Tuple <TraceEntry, TraceEntry>(e1, e2);
                        if (PrintResults)
                        {
                            PrintComparisonResult($"Entries #{i}: Freed allocation block of execution trace 1 does not match freed block of execution trace 2.", false,
                                                  $"Trace 1: {e1.ToString()}",
                                                  $"Trace 2: {e2.ToString()}");
                        }
                        return(false);
                    }
                    else
                    {
                        // OK, remove allocation block
                        _allocs.Remove(free1.Address);
                    }
                    break;
                }

                // Possible leakages:
                // -> Different access offset in image
                case TraceEntryTypes.ImageMemoryRead:
                {
                    // Cast entries
                    ImageMemoryReadEntry read1 = (ImageMemoryReadEntry)e1;
                    ImageMemoryReadEntry read2 = (ImageMemoryReadEntry)e2;

                    // Compare relative access offsets
                    if (read1.MemoryAddress != read2.MemoryAddress)
                    {
                        Result = ComparisonResults.MemoryAccess_DifferentImageMemoryReadOffset;
                        ComparisonErrorLine  = i;
                        ComparisonErrorItems = new Tuple <TraceEntry, TraceEntry>(e1, e2);
                        if (PrintResults)
                        {
                            PrintComparisonResult($"Entries #{i}: Memory read offsets in image differ: {read1.MemoryImageName}+{read1.MemoryAddress.ToString("X")} vs. {read2.MemoryImageName}+{read2.MemoryAddress.ToString("X")}", false,
                                                  $"Trace 1: {e1.ToString()}",
                                                  $"Trace 2: {e2.ToString()}");
                        }
                        return(false);
                    }

                    // OK
                    break;
                }

                // Possible leakages:
                // -> Different access offset in image
                case TraceEntryTypes.ImageMemoryWrite:
                {
                    // Cast entries
                    ImageMemoryWriteEntry write1 = (ImageMemoryWriteEntry)e1;
                    ImageMemoryWriteEntry write2 = (ImageMemoryWriteEntry)e2;

                    // Compare relative access offsets
                    if (write1.MemoryAddress != write2.MemoryAddress)
                    {
                        Result = ComparisonResults.MemoryAccess_DifferentImageMemoryWriteOffset;
                        ComparisonErrorLine  = i;
                        ComparisonErrorItems = new Tuple <TraceEntry, TraceEntry>(e1, e2);
                        if (PrintResults)
                        {
                            PrintComparisonResult($"Entries #{i}: Memory write offsets in image differ: {write1.MemoryImageName}+{write1.MemoryAddress.ToString("X")} vs. {write2.MemoryImageName}+{write2.MemoryAddress.ToString("X")}", false,
                                                  $"Trace 1: {e1.ToString()}",
                                                  $"Trace 2: {e2.ToString()}");
                        }
                        return(false);
                    }

                    // OK
                    break;
                }

                // Possible leakages:
                // -> Different access offset (after subtracting allocation base addresses)
                case TraceEntryTypes.AllocMemoryRead:
                {
                    // Cast entries
                    AllocMemoryReadEntry read1 = (AllocMemoryReadEntry)e1;
                    AllocMemoryReadEntry read2 = (AllocMemoryReadEntry)e2;

                    // Find related allocation block
                    AllocationData allocCandidate = FindAllocationBlock(read1.MemoryAddress, read2.MemoryAddress);
                    if (allocCandidate == null)
                    {
                        // Stack access?
                        if (stackMemory.StartAddress1 <= read1.MemoryAddress && read1.MemoryAddress <= stackMemory.EndAddress1 &&
                            stackMemory.StartAddress2 <= read2.MemoryAddress && read2.MemoryAddress <= stackMemory.EndAddress2)
                        {
                            allocCandidate = stackMemory;
                        }
                        else
                        {
                            // TODO remove warning, better include the fs/gs segment bounds in the trace
                            if (PrintResults)
                            {
                                PrintComparisonResult($"Entries #{i}: Cannot find common accessed allocation block. Maybe there are segment registers involved?", true,
                                                      $"Trace 1: {read1.ToString()}",
                                                      $"Trace 2: {read2.ToString()}",
                                                      $"Stack: {stackMemory.ToString()}");
                            }
                            break;
                        }
                    }

                    // Calculate and compare relative access offsets
                    ulong offset1 = read1.MemoryAddress - allocCandidate.StartAddress1;
                    ulong offset2 = read2.MemoryAddress - allocCandidate.StartAddress2;
                    if (offset1 != offset2)
                    {
                        Result = ComparisonResults.MemoryAccess_DifferentAllocMemoryReadOffset;
                        ComparisonErrorLine  = i;
                        ComparisonErrorItems = new Tuple <TraceEntry, TraceEntry>(e1, e2);
                        if (PrintResults)
                        {
                            PrintComparisonResult($"Entries #{i}: Memory read offsets in common allocation block differ: +{offset1.ToString("X8")} vs. +{offset2.ToString("X8")}", false,
                                                  $"Trace 1: {e1.ToString()}",
                                                  $"Trace 2: {e2.ToString()}");
                        }
                        return(false);
                    }

                    // OK
                    break;
                }

                // Possible leakages:
                // -> Different access offset (after subtracting allocation/stack pointer base addresses)
                case TraceEntryTypes.AllocMemoryWrite:
                {
                    // Cast entries
                    AllocMemoryWriteEntry write1 = (AllocMemoryWriteEntry)e1;
                    AllocMemoryWriteEntry write2 = (AllocMemoryWriteEntry)e2;

                    // Find related allocation block
                    AllocationData allocCandidate = FindAllocationBlock(write1.MemoryAddress, write2.MemoryAddress);
                    if (allocCandidate == null)
                    {
                        // Stack access?
                        if (stackMemory.StartAddress1 <= write1.MemoryAddress && write1.MemoryAddress <= stackMemory.EndAddress1 &&
                            stackMemory.StartAddress2 <= write2.MemoryAddress && write2.MemoryAddress <= stackMemory.EndAddress2)
                        {
                            allocCandidate = stackMemory;
                        }
                        else
                        {
                            // TODO remove warning, better include the fs/gs segment bounds in the trace
                            if (PrintResults)
                            {
                                PrintComparisonResult($"Entries #{i}: Cannot find common accessed allocation block. Maybe there are segment registers involved?", true,
                                                      $"Trace 1: {write1.ToString()}",
                                                      $"Trace 2: {write2.ToString()}",
                                                      $"Stack: {stackMemory.ToString()}");
                            }
                            break;
                        }
                    }

                    // Calculate and compare relative access offsets
                    ulong offset1 = write1.MemoryAddress - allocCandidate.StartAddress1;
                    ulong offset2 = write2.MemoryAddress - allocCandidate.StartAddress2;
                    if (offset1 != offset2)
                    {
                        Result = ComparisonResults.MemoryAccess_DifferentAllocMemoryWriteOffset;
                        ComparisonErrorLine  = i;
                        ComparisonErrorItems = new Tuple <TraceEntry, TraceEntry>(e1, e2);
                        if (PrintResults)
                        {
                            PrintComparisonResult($"Entries #{i}: Memory write offsets in common allocation block differ: +{offset1.ToString("X8")} vs. +{offset2.ToString("X8")}", false,
                                                  $"Trace 1: {e1.ToString()}",
                                                  $"Trace 2: {e2.ToString()}");
                        }
                        return(false);
                    }

                    // OK
                    break;
                }
                }
            }

            // No differences found
            Result = ComparisonResults.Match;
            return(true);
        }