text stringlengths 1 24.5M |
|---|
#pragma once
//---------------------------------------------------------------------------
#include "../host_core/build.h"
//---------------------------------------------------------------------------
|
#include "build.h"
#include "../host_core/launcherCommandline.h"
#include "../host_core/runtimeEnvironment.h"
#include "winKernel.h"
#include "winMemory.h"
#include "winFileSystem.h"
int main(int argc, const char** argv)
{
// create win systems
win::FileSystem winFileSystem;
win::Kernel winKernel;
win::Memory* w... |
#include "build.h"
#include "winFileSystem.h"
namespace win
{
File::File(HANDLE hFile)
: m_hFile(hFile)
{}
File::~File()
{
CloseHandle(m_hFile);
m_hFile = NULL;
}
bool File::GetOffset(uint64& outOffset) const
{
LARGE_INTEGER offsetToMove;
offsetToMove.QuadPart = 0;
LARGE_INTEGER newPointer;
new... |
#pragma once
#include "../host_core/nativeFileSystem.h"
namespace win
{
class File : public native::IFile
{
public:
File(HANDLE hFile);
virtual ~File();
virtual bool GetOffset(uint64& outOffset) const override final;
virtual bool SetOffset(const uint64 offset) override final;
virtual bool Read(void* buf... |
#include "build.h"
#include "winKernel.h"
namespace win
{
//----
static native::WaitResult ToWaitResult( const DWORD ret )
{
switch (ret)
{
case WAIT_OBJECT_0: return native::WaitResult::Success;
case WAIT_IO_COMPLETION: return native::WaitResult::IOCompletion;
case WAIT_TIMEOUT: return native::WaitRe... |
#pragma once
#include "../host_core/nativeKernel.h"
#include <mutex>
namespace win
{
class CriticalSection : public native::ICriticalSection
{
public:
CriticalSection();
virtual ~CriticalSection();
virtual void Acquire() override final;
virtual void Release() override final;
private:
CRITICAL_SECTION m... |
#include "build.h"
#include "winMemory.h"
namespace win
{
Memory::Memory()
{
}
Memory::~Memory()
{
}
void* Memory::AllocVirtualMemory(const uint64_t prefferedBaseAddres, const uint64_t size)
{
GLog.Log("Win: Requested OS to allocate %u bytes of virtual memory", size);
const auto ret = ::VirtualAlloc((v... |
#pragma once
#include "../host_core/nativeMemory.h"
namespace win
{
/// memory handler
class Memory : public native::IMemory
{
public:
Memory();
~Memory();
virtual void* AllocVirtualMemory(const uint64_t prefferedBaseAddres, const uint64_t size) override final;
virtual void FreeVirtualMemory(void* addres... |
#include "build.h"
|
#pragma once
#include <stdio.h>
#include <tchar.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <set>
#include <deque>
#include <map>
#include <string>
#include <algorithm>
#include <functional>
#include <mutex>
#include <atomic>
#include "..\recompiler_core\build.h"
|
#include "build.h"
#include "../recompiler_core/internalUtils.h"
#include "../recompiler_core/decodingEnvironment.h"
#include "../recompiler_core/codeGenerator.h"
#include "../recompiler_core/decodingContext.h"
#include "../recompiler_core/platformDefinition.h"
#include "../recompiler_core/platformDecompilation.h"
#in... |
#pragma once
namespace utils
{
template <typename T>
class big_vector
{
public:
big_vector()
{
m_numTotalElements = 0;
m_curPage = new Page();
m_pages.push_back(m_curPage);
}
// get size of the buffer
inline size_t size() const
{
return m_numTotalElements;
}
// get element by index
... |
#include "build.h"
|
#pragma once
#include <cstdio>
#include <cstdlib>
#include <cstdarg>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <memory>
#include <istream>
#include <fstream>
#include <functional>
#include <algorithm>
#ifdef _LIB
#d... |
#include "build.h"
#include "codeGenerator.h"
#include "codeGeneratorMSVC.h"
#include "internalUtils.h"
namespace code
{
IGenerator::~IGenerator()
{}
void IGenerator::ListGenerators(std::vector<std::string>& outCodeGenerators)
{
outCodeGenerators.push_back("cpp_msvc");
outCodeGenerators.push_back("cpp_clang"... |
#pragma once
namespace code
{
class Printer;
/// Code generator executable runner
class RECOMPILER_API IGeneratorRemoteExecutor
{
public:
virtual const uint32 RunExecutable(ILogOutput& log, const std::wstring& executablePath, const std::wstring& executableArguments) = 0;
};
/// Code generator
class RECOMPI... |
#include "build.h"
#include "codeGeneratorMSVC.h"
#include "codePrinter.h"
#include "internalUtils.h"
#include "zlib\zlib.h"
#include "decodingEnvironment.h"
#if defined(_WIN64) || defined(_WIN32)
#include <Windows.h>
namespace code
{
namespace msvc
{
//----------------------------------------------------------... |
#pragma once
#include "codeGenerator.h"
namespace code
{
namespace msvc
{
/// Code generator for MSVC tool chain
class Generator : public IGenerator
{
public:
Generator(class ILogOutput& log, const Commandline& params);
virtual ~Generator();
protected:
// IGenerator
virtual void SetLoadAddres... |
#include "build.h"
#include "internalUtils.h"
#include "internalFile.h"
#include "codePrinter.h"
namespace code
{
//---------------------------------------------------------------------------
Printer::Page::Page( const uint32 capacity )
: m_size( 0 )
, m_capacity( capacity )
{
m_data = (uint8*) malloc( capa... |
#pragma once
namespace code
{
/// universal code printer
class RECOMPILER_API Printer
{
private:
struct Page
{
uint8* m_data;
uint32 m_size;
uint32 m_capacity;
Page( const uint32 capacity );
~Page();
bool Write( const void* data, uint32& currentOffset, const uint32 size );
bool Appen... |
#include "build.h"
#include "decodingMemoryMap.h"
#include "decodingAddressMap.h"
#include "internalFile.h"
namespace decoding
{
//-------------------------------------------------------------------------
AddressMap::AddressMap(class decoding::MemoryMap* map)
: m_memoryMap(map)
, m_isModified(false)
{
}
Ad... |
#pragma once
class IBinaryFileWriter;
class IBinaryFileReader;
namespace decoding
{
class MemoryMap;
/// Optional map for referenced memory, also adds branches
class RECOMPILER_API AddressMap
{
public:
// are the comments modified ?
inline bool IsModified() const { return m_isModified; }
public:
Address... |
#include "build.h"
#include "decodingMemoryMap.h"
#include "decodingCommentMap.h"
#include "internalFile.h"
namespace decoding
{
CommentMap::CommentMap(class MemoryMap* map)
: m_memoryMap(map)
, m_isModified(false)
{
}
CommentMap::~CommentMap()
{
}
const char* CommentMap::GetComment(const uint64 addr) co... |
#pragma once
class IBinaryFileWriter;
class IBinaryFileReader;
namespace decoding
{
class MemoryMap;
/// Optional comments per line
class RECOMPILER_API CommentMap
{
public:
// are the comments modified ?
inline bool IsModified() const { return m_isModified; }
public:
CommentMap(class MemoryMap* map);
... |
#include "build.h"
#include "internalUtils.h"
#include "image.h"
#include "platformDefinition.h"
#include "decodingContext.h"
#include "decodingInstructionCache.h"
#include "decodingMemoryMap.h"
#include "decodingCommentMap.h"
#include "decodingNameMap.h"
#include "decodingAddressMap.h"
namespace decoding
{
//---... |
#pragma once
namespace image
{
class Binary;
class Section;
}
namespace platform
{
class Definition;
}
namespace decoding
{
class MemoryMap;
class CommentMap;
class AddressMap;
class NameMap;
class Instruction;
class InstructionCache;
/// Decoding context - main data holder for the module being decoded
c... |
#include "build.h"
#include "internalUtils.h"
#include "internalFile.h"
#include "xmlReader.h"
#include "image.h"
#include "platformLibrary.h"
#include "platformDefinition.h"
#include "decodingEnvironment.h"
#include "decodingContext.h"
#include "decodingMemoryMap.h"
#include "decodingCommentMap.h"
#include "decodin... |
#pragma once
namespace platform
{
class Definition;
class CompilerDefinition;
}
namespace image
{
class Binary;
}
namespace decoding
{
class Context;
/// Global decoding environment
class RECOMPILER_API Environment
{
public:
~Environment();
//----
// Get the project path (can be empty until saved)
... |
#include "build.h"
#include "internalUtils.h"
#include "internalParser.inl"
#include "platformDefinition.h"
#include "platformCPU.h"
#include "decodingInstruction.h"
#include "decodingInstructionInfo.h"
namespace decoding
{
Instruction::Instruction()
: m_codeSize( 0 )
, m_dataSize( 32 )
, m_addrSize( 32 )
, ... |
#pragma once
//---------------------------------------------------------------------------
namespace platform
{
class CPURegister;
class CPUInstruction;
}
//---------------------------------------------------------------------------
namespace decoding
{
class Context;
class InstructionExtendedInfo;
/// Gener... |
#include "build.h"
#include "image.h"
#include "platformCPU.h"
#include "decodingInstructionCache.h"
#include "decodingMemoryMap.h"
#include "decodingInstruction.h"
namespace decoding
{
InstructionCache::InstructionCache( const image::Section* imageSection, class MemoryMap* memory, const platform::CPU* decodingCP... |
#pragma once
#include "decodingInstruction.h"
namespace image
{
class Section;
}
namespace platform
{
class CPU;
}
namespace decoding
{
class MemoryMap;
class Instruction;
/// Quick lookup so we don't decode the instructions over and over
class RECOMPILER_API InstructionCache
{
public:
InstructionCache( ... |
#include "build.h"
#include "internalUtils.h"
#include "internalParser.inl"
#include "platformDefinition.h"
#include "platformCPU.h"
#include "decodingInstructionInfo.h"
#include "traceUtils.h"
namespace decoding
{
InstructionExtendedInfo::InstructionExtendedInfo()
: m_codeAddress(0)
, m_codeFlags(0)
, m_memor... |
#pragma once
//---------------------------------------------------------------------------
namespace platform
{
class CPURegister;
class CPUInstruction;
}
//---------------------------------------------------------------------------
namespace trace
{
class Registers;
class DataFrame;
}
//----------------------... |
#include "build.h"
#include "decodingMemoryMap.h"
#include "internalFile.h"
#include "image.h"
namespace decoding
{
MemoryMap::MemoryMap()
: m_memoryMap(NULL)
, m_memorySize(0)
, m_baseAddress(0)
, m_lastDirtyAddress(0)
, m_firstDirtyAddress(0)
, m_isModified(false)
{
}
MemoryMap::~MemoryMap()
{
i... |
#pragma once
class IBinaryFileReader;
class IBinaryFileWriter;
namespace image
{
class Binary;
}
namespace decoding
{
//---------------------------------------------------------------------------
// Generic type of memory location - as read from the section
enum class MemoryFlag : uint16
{
// valid memory (c... |
#include "build.h"
#include "decodingMemoryMap.h"
#include "decodingNameMap.h"
#include "internalFile.h"
namespace decoding
{
//-------------------------------------------------------------------------
NameMap::NameMap(class MemoryMap* map)
: m_memoryMap(map)
, m_isModified(false)
{
}
NameMap::~NameMap()
... |
#pragma once
class IBinaryFileWriter;
class IBinaryFileReader;
namespace decoding
{
class MemoryMap;
/// Optional debug name for each address
class RECOMPILER_API NameMap
{
public:
struct SymbolInfo
{
const char* m_name;
uint64 m_address;
};
class ISymbolConsumer
{
public:
virtual ~ISymbo... |
#pragma once
/// run external application, returns exit code of the application
/// all output of the application is passed to the log
extern RECOMPILER_API uint32 RunApplication(ILogOutput& log, const std::wstring& executablePath, const std::wstring& commandLine);
|
#include "build.h"
#include "externalApp.h"
#if defined(_WIN32) || defined(_WIN64)
#include <Windows.h>
namespace prv
{
//--------------------------------------------------------------------------
class TaskIOReader
{
public:
TaskIOReader(ILogOutput& log, const char* prefix, const bool stripErrors);
~TaskI... |
#include "build.h"
#include "image.h"
#include "internalUtils.h"
#include "internalFile.h"
namespace image
{
//---------------------------------------------------------------------------
Section::Section()
: m_name("none")
, m_cpuName("none")
, m_virtualOffset(0)
, m_virtualSize(0)
, m_physicalOffset(0)
... |
#pragma once
//---------------------------------------------------------------------------
namespace image
{
//---------------------------------------------------------------------------
class Section;
class Export;
class Import;
class Reolocation;
class Binary;
//-------------------------------------------... |
#include "build.h"
#include "internalUtils.h"
#include "internalFile.h"
//---------------------------------------------------------------------------
struct ChunkInfo
{
static const uint32 MAGIC = 'CHNK';
uint32 m_magic;
uint32 m_version;
uint64 m_crc; // crc of the data
uint64 m_size; // allows to skip the d... |
#pragma once
//---------------------------------------------------------------------------
/// Binary file writer, used to save the project data
class RECOMPILER_API IBinaryFileWriter
{
public:
virtual ~IBinaryFileWriter() {};
// save raw data
virtual void Save(const void* data, const uint32 size) = 0;
// get f... |
#include "build.h"
#include "internalUtils.h"
#include "zlib\zlib.h"
#if defined(_WIN64) || defined(_WIN32)
#include <Windows.h>
#endif
#include <algorithm>
//---------------------------------------------------------------------------
void FixFilePathA(const char* filePath, const char* newExtension, std::string& ou... |
#pragma once
//---------------------------------------------------------------------------
#include <mutex>
//---------------------------------------------------------------------------
template < class T >
static inline void SafeRelease(T*& ptr)
{
if (nullptr != ptr)
{
ptr->Release();
ptr = nullptr;
}
}
te... |
#include "build.h"
#include <algorithm>
#include <Windows.h>
ILogOutput::ILogOutput(ILogOutput* parent /*= nullptr*/)
: m_parent(nullptr)
{
Attach(parent);
}
ILogOutput::~ILogOutput()
{
Detach();
}
void ILogOutput::Attach(ILogOutput* parent)
{
if (m_parent != parent)
{
Detach();
m_parent = parent;
if (m... |
#pragma once
// generic output interface user everywhere
class RECOMPILER_API ILogOutput
{
public:
ILogOutput(ILogOutput* parent = nullptr);
virtual ~ILogOutput();
enum class LogLevel
{
Info,
Warning,
Error,
};
// loging/errors
void Log(_Printf_format_string_ const char* txt, ...);
void Warn(_Printf_fo... |
#include "build.h"
#include "internalParser.inl"
#include "internalUtils.h"
#include "platformCPU.h"
#include "decodingInstruction.h"
namespace platform
{
//---------------------------------------------------------------------------
CPURegister::CPURegister(const char* name, const uint32 bitSize, const uint32 bitO... |
#pragma once
namespace trace
{
class DataFrame;
class Registers;
class PagedFileReader;
}
namespace decoding
{
class Context;
class Instruction;
class InstructionExtendedInfo;
}
namespace platform
{
//---------------------------------------------------------------------------
/// Native instruction decoder... |
#pragma once
namespace code
{
class IGenerator;
}
namespace decoding
{
class Context;
}
namespace platform
{
//---------------------------------------------------------------------------
/// Platform decompilation interface (loaded from DLL)
class RECOMPILER_API DecompilationInterface
{
public:
//! Releas... |
#include "build.h"
#include "xmlReader.h"
#include "internalUtils.h"
#include "internalFile.h"
#include "platformDefinition.h"
#include "platformLauncher.h"
#include "platformDecompilation.h"
#include "platformExports.h"
#include "platformCPU.h"
#if defined(_WIN32) || defined(_WIN64)
#include <Windows.h>
#else
#error ... |
#pragma once
namespace image
{
class Binary;
}
namespace decoding
{
class Context;
}
namespace code
{
class IGenerator;
}
namespace platform
{
class CPU;
class DecompilationInterface;
struct RECOMPILER_API FileFormat
{
std::string m_name;
std::string m_extension;
};
/// Platform definition
class R... |
#include "build.h"
#include "xmlReader.h"
#include "platformExports.h"
namespace platform
{
//---------------------------------------------------------------------------
static bool ParseImportIndex(const char* str, int& outNumber)
{
// hex ?
int base = 10;
if (str[0] == '0' && str[1] == 'x')
{
str += ... |
#pragma once
namespace platform
{
/// Artifical (XML based) list of images and their imports, used by some platforms
class RECOMPILER_API ExportLibrary
{
public:
// export information
class RECOMPILER_API ExportInfo
{
private:
std::string m_name;
std::string m_alias;
uint32 m_ordinal;
uint... |
#pragma once
namespace platform
{
} // platform |
#include "build.h"
#include "platformLibrary.h"
#include "platformDefinition.h"
#include "internalUtils.h"
#include "xmlReader.h"
namespace platform
{
Library::Library()
{
}
Library::~Library()
{
}
Library& Library::GetInstance()
{
static Library theInstance;
return theInstance;
}
const Definition* L... |
#pragma once
namespace platform
{
class CPU;
struct FileFormat;
class Definition;
class ExportLibrary;
/// platform library - contains all of the supported platforms
class RECOMPILER_API Library
{
public:
// platform libraries
inline const uint32 GetNumPlatforms() const { return (uint32)m_platformLibrary.... |
#ifndef RAPIDXML_HPP_INCLUDED
#define RAPIDXML_HPP_INCLUDED
// Copyright (C) 2006, 2009 Marcin Kalicinski
// Version 1.13
// Revision $DateTime: 2009/05/13 01:46:17 $
//! \file rapidxml.hpp This file contains rapidxml parser and DOM implementation
// If standard library is disabled, user must provide implementations ... |
#ifndef RAPIDXML_ITERATORS_HPP_INCLUDED
#define RAPIDXML_ITERATORS_HPP_INCLUDED
// Copyright (C) 2006, 2009 Marcin Kalicinski
// Version 1.13
// Revision $DateTime: 2009/05/13 01:46:17 $
//! \file rapidxml_iterators.hpp This file contains rapidxml iterators
#include "rapidxml.hpp"
namespace rapidxml
{
//! Itera... |
#ifndef RAPIDXML_PRINT_HPP_INCLUDED
#define RAPIDXML_PRINT_HPP_INCLUDED
// Copyright (C) 2006, 2009 Marcin Kalicinski
// Version 1.13
// Revision $DateTime: 2009/05/13 01:46:17 $
//! \file rapidxml_print.hpp This file contains rapidxml printer implementation
#include "rapidxml.hpp"
// Only include streams if not dis... |
#ifndef RAPIDXML_UTILS_HPP_INCLUDED
#define RAPIDXML_UTILS_HPP_INCLUDED
// Copyright (C) 2006, 2009 Marcin Kalicinski
// Version 1.13
// Revision $DateTime: 2009/05/13 01:46:17 $
//! \file rapidxml_utils.hpp This file contains high-level rapidxml utilities that can be useful
//! in certain simple scenarios. They shoul... |
#include "build.h"
#include "internalUtils.h"
#include "platformCPU.h"
#include "platformLibrary.h"
#include "decodingEnvironment.h"
#include "decodingInstruction.h"
#include "decodingInstructionInfo.h"
#include "decodingContext.h"
#include "traceDataFile.h"
#include "traceUtils.h"
#include "timemachine.h"
namespa... |
#pragma once
class ILogOutput;
namespace timemachine
{
class Entry;
class Trace;
/// trace - a collection of entries
class RECOMPILER_API Trace
{
public:
~Trace();
// create the time machine trace entry
static Trace* CreateTimeMachine(decoding::Context* context, trace::DataFile* traceData, const TraceFr... |
#include "build.h"
#if 0
#include "traceData.h"
#include "traceCalltree.h"
#include "internalFile.h"
#include "decodingContext.h"
#include "decodingMemoryMap.h"
#include "decodingNameMap.h"
#include "decodingInstruction.h"
#include "decodingInstructionInfo.h"
#include "platformDefinition.h"
#include "platformCPU.h"
n... |
#pragma once
namespace decoding
{
class Context;
}
namespace trace
{
class Data;
class DataReader;
/// CallTree (all calls)
class RECOMPILER_API CallTree
{
public:
struct SFrame
{
uint32 m_functionStart; // address of function entered
uint32 m_traceEnter;
uint32 m_traceLeave; // 0 if no ... |
#pragma once
namespace common
{
struct TraceFileHeader
{
static const uint32 MAGIC = 'TRAC';
uint32 m_magic;
char m_platformName[16];
char m_cpuName[16];
uint32_t m_numRegisers; // number of registers captured
};
struct TraceRegiserInfo
{
char m_name[16];
uint32_t m_bitSize;
};
struct Tr... |
#include "build.h"
#include "traceDataBuilder.h"
#include "decodingContext.h"
#include "decodingMemoryMap.h"
#include "decodingInstruction.h"
#include "decodingInstructionInfo.h"
#include <algorithm>
#include "platformCPU.h"
#include "traceUtils.h"
namespace trace
{
DataBuilder::DataBuilder(const RawTraceReader& ra... |
#pragma once
#include "traceRawReader.h"
#include "traceDataFile.h"
#include "bigArray.h"
namespace trace
{
/// builder of the trace data
class DataBuilder : public IRawTraceVisitor
{
public:
typedef std::function<decoding::Context*(const uint64_t ip)> TDecodingContextQuery;
DataBuilder(const RawTraceReader... |
#include "build.h"
#include "traceDataFile.h"
#include "platformCPU.h"
#include "traceRawReader.h"
#include "traceDataBuilder.h"
#include "internalUtils.h"
#include <algorithm>
#pragma optimize("",off)
namespace trace
{
//---
DataFrame::DataFrame(const LocationInfo& locInfo, const FrameType& type, const Navigatio... |
#pragma once
#include "traceMemorySlice.h"
namespace trace
{
class RawTraceReader;
// representation of trace point in various units
struct LocationInfo
{
TraceFrameID m_seq; // global sequence number
uint32 m_contextId; // context (thread/IRQ, etc)
uint32 m_contextSeq; // sequence number in context
uint... |
#include "build.h"
#if 0
#include "traceMemoryHistory.h"
namespace trace
{
MemoryHistory::MemoryHistory()
: m_pageRanges(NULL)
, m_entryFile(NULL)
, m_numPageRanges(0)
, m_pages(NULL)
, m_numPages(0)
{
}
MemoryHistory::~MemoryHistory()
{
if (m_pages)
{
free((void*)m_pages);
m_pages = NULL;... |
#pragma once
namespace trace
{
//---------------------------------------------------------------------------
class PagedFile;
class PagedFileReader;
class MemoryHistoryReader;
class MemoryHistoryBuilder;
//---------------------------------------------------------------------------
/// Trace memory history
... |
#include "build.h"
#if 0
#include "decodingContext.h"
#include "decodingInstruction.h"
#include "decodingInstructionInfo.h"
#include "tracePagedFile.h"
#include "traceData.h"
#include "traceMemoryHistory.h"
#include "traceMemoryHistoryBuilder.h"
#include "platformCPU.h"
#include "traceUtils.h"
namespace trace
{
M... |
#pragma once
#include "traceMemoryHistory.h"
namespace image
{
class Binary;
}
namespace trace
{
class Data;
/// build of the memory trace file
class RECOMPILER_API MemoryHistoryBuilder
{
public:
struct Page
{
uint32 m_id;
uint64 m_address;
uint32 m_entriesHead[MemoryHistory::ENTRIES_PER_PAGE]... |
#include "build.h"
#include "traceMemorySlice.h"
namespace trace
{
//--
MemoryCell::MemoryCell()
: m_value(0)
, m_history(nullptr)
, m_numHistoryEntries(0)
, m_curHistoryEntry(0)
, m_curSeq(INVALID_TRACE_FRAME_ID)
, m_nextSeq(INVALID_TRACE_FRAME_ID)
{}
MemoryCell::MemoryCell(const MemoryCellHistoryE... |
#pragma once
namespace trace
{
#pragma pack(push)
#pragma pack(1)
struct MemoryCellHistoryEntry
{
TraceFrameID m_seq;
uint8_t m_value;
};
#pragma pack(pop)
/// cell (single byte) of memory
/// has the features to be traced back in the history
class RECOMPILER_API MemoryCell
{
public:
MemoryCell();
M... |
#include "build.h"
#include "traceRawReader.h"
#include "traceCommon.h"
#include "traceDataFile.h"
#pragma optimize("",off)
namespace trace
{
RawTraceReader::RawTraceReader(std::unique_ptr<std::ifstream>& f)
: m_file(std::move(f))
{}
RawTraceReader::~RawTraceReader()
{}
void RawTraceReader::Read(void* data,... |
#pragma once
namespace trace
{
//---------------------------------------------------------------------------
class PagedFile;
class PagedFileReader;
//---------------------------------------------------------------------------
// raw trace frame data
struct RawTraceFrame
{
uint8_t m_type;
uint32 m_writ... |
#include "build.h"
#include "traceDataFile.h"
#include "traceUtils.h"
#include "platformCPU.h"
namespace trace
{
int64 GetRegisterValueInteger(const platform::CPURegister* reg, const TRegisterDataFetchFunc& fetchFunc, const bool signExtend/*= true*/)
{
uint64 bitSize = reg->GetBitSize();
uint64 bitOffset = reg-... |
#pragma once
namespace platform
{
class CPURegister;
}
namespace trace
{
class DataFrame;
//---------------------------------------------------------------------------
// how should we interpret the bit patterns
enum class RegDisplayFormat
{
Auto = 0, // auto select, based on the register type (signed/floa... |
#include "build.h"
#include "xmlReader.h"
namespace xml
{
Reader::Reader(const char* buffer, const bool makeCopy /*= false*/)
{
// Setup buffer
if (makeCopy)
{
const auto size = strlen(buffer);
char* localBuffer = new char[size + 1];
memcpy(localBuffer, buffer, size + 1);
localBuffer[size] = 0;
... |
#pragma once
#include "rapidxml.hpp"
#include "rapidxml_print.hpp"
namespace xml
{
/// Trivial XML reader
class RECOMPILER_API Reader
{
public:
typedef rapidxml::xml_document<char> TDoc;
typedef rapidxml::xml_attribute<char> TAttr;
typedef rapidxml::xml_node<char> TNode;
typedef std::vector< const TNode... |
/* adler32.c -- compute the Adler-32 checksum of a data stream
* Copyright (C) 1995-2011 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* @(#) $Id$ */
#include "zutil.h"
#define local static
local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
#... |
/* compress.c -- compress a memory buffer
* Copyright (C) 1995-2005 Jean-loup Gailly.
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* @(#) $Id$ */
#define ZLIB_INTERNAL
#include "zlib.h"
/* ===========================================================================
Compresses t... |
/* crc32.c -- compute the CRC-32 of a data stream
* Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*
* Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
* CRC methods: exclusive-oring 32 bits of data at a time,... |
/* crc32.h -- tables for rapid CRC calculation
* Generated automatically by crc32.c
*/
local const z_crc_t FAR crc_table[TBLS][256] =
{
{
0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
0xe0d5e91eUL, 0x97d2d988U... |
/* deflate.c -- compress data using the deflation algorithm
* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/*
* ALGORITHM
*
* The "deflation" process depends on being able to identify portions
* of the input text w... |
/* deflate.h -- internal compression state
* Copyright (C) 1995-2012 Jean-loup Gailly
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* WARNING: this file should *not* be used by applications. It is
part of the implementation of the compression library and is
subject to change. Ap... |
/* infback.c -- inflate using a call-back interface
* Copyright (C) 1995-2011 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/*
This code is largely copied from inflate.c. Normally either infback.o or
inflate.o would be linked into an application--not both. The interf... |
/* inffast.c -- fast decoding
* Copyright (C) 1995-2008, 2010, 2013 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "zutil.h"
#include "inftrees.h"
#include "inflate.h"
#include "inffast.h"
#ifndef ASMINF
/* Allow machine dependent optimization for post-increment or... |
/* inffast.h -- header to use inffast.c
* Copyright (C) 1995-2003, 2010 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* WARNING: this file should *not* be used by applications. It is
part of the implementation of the compression library and is
subject to change. Appli... |
/* inffixed.h -- table for decoding fixed codes
* Generated automatically by makefixed().
*/
/* WARNING: this file should *not* be used by applications.
It is part of the implementation of this library and is
subject to change. Applications should only use zlib.h.
*/
static co... |
/* inflate.c -- zlib decompression
* Copyright (C) 1995-2012 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/*
* Change history:
*
* 1.2.beta0 24 Nov 2002
* - First version -- complete rewrite of inflate to simplify code, avoid
* creation of window when not needed, ... |
/* inflate.h -- internal inflate state definition
* Copyright (C) 1995-2009 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* WARNING: this file should *not* be used by applications. It is
part of the implementation of the compression library and is
subject to change. A... |
/* inftrees.c -- generate Huffman trees for efficient decoding
* Copyright (C) 1995-2013 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "zutil.h"
#include "inftrees.h"
#define MAXBITS 15
const char inflate_copyright[] =
" inflate 1.2.8 Copyright 1995-2013 Mark A... |
/* inftrees.h -- header to use inftrees.c
* Copyright (C) 1995-2005, 2010 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* WARNING: this file should *not* be used by applications. It is
part of the implementation of the compression library and is
subject to change. App... |
/* trees.c -- output deflated data using Huffman coding
* Copyright (C) 1995-2012 Jean-loup Gailly
* detect_data_type() function provided freely by Cosmin Truta, 2006
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/*
* ALGORITHM
*
* The "deflation" process uses several Huffman... |
/* header created automatically with -DGEN_TREES_H */
local const ct_data static_ltree[L_CODES+2] = {
{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}},
{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}},
{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},... |
/* uncompr.c -- decompress a memory buffer
* Copyright (C) 1995-2003, 2010 Jean-loup Gailly.
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* @(#) $Id$ */
#define ZLIB_INTERNAL
#include "zlib.h"
/* ===========================================================================
Decom... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.