GenericPlatformStackWalk.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "UObject/NameTypes.h"
 
class FName;
struct FGenericCrashContext;
struct FProcHandle;
struct FProgramCounterSymbolInfoEx;
 
struct FStackWalkModuleInfo
{
    uint64 BaseOfImage;
    uint32 ImageSize;
    uint32 TimeDateStamp;
    TCHAR ModuleName[32];
    TCHAR ImageName[256];
    TCHAR LoadedImageName[256];
    uint32 PdbSig;
    uint32 PdbAge;
    struct
    {
        unsigned long  Data1;
        unsigned short Data2;
        unsigned short Data3;
        unsigned char  Data4[8];
    } PdbSig70;
};
 
struct FProgramCounterSymbolInfo final
{
    enum
    {
        MAX_NAME_LENGTH = 1024,
    };
 
    ANSICHAR    ModuleName[MAX_NAME_LENGTH];
 
    ANSICHAR    FunctionName[MAX_NAME_LENGTH];
 
    ANSICHAR    Filename[MAX_NAME_LENGTH];
 
    int32       LineNumber;
 
    int32       SymbolDisplacement;
 
    uint64      OffsetInModule;
 
    uint64      ProgramCounter;
 
    CORE_API FProgramCounterSymbolInfo();
};
 
struct FProgramCounterSymbolInfoEx
{
    FString ModuleName;
 
    FString FunctionName;
 
    FString Filename;
 
    uint32  LineNumber;
 
    uint64  SymbolDisplacement;
 
    uint64  OffsetInModule;
 
    uint64  ProgramCounter;
 
    CORE_API FProgramCounterSymbolInfoEx(FString InModuleName = "", FString InFunctionName = "", FString InFilename = "", uint32 InLineNumber = 0, uint64 InSymbolDisplacement = 0, uint64 InOffsetInModule = 0, uint64 InProgramCounter = 0);
};
 
struct FGenericPlatformStackWalk
{
    typedef FGenericPlatformStackWalk Base;
 
    struct EStackWalkFlags
    {
        enum
        {
            AccurateStackWalk               =   0,
 
            FastStackWalk                   =   (1 << 0),
 
            FlagsUsedWhenHandlingEnsure     =   (FastStackWalk)
        };
    };
 
    static CORE_API void Init();
 
    static bool InitStackWalking()
    {
        return 1;
    }
 
    static bool InitStackWalkingForProcess(const FProcHandle& Process)
    {
        return false;
    }
 
    static CORE_API bool ProgramCounterToHumanReadableString( int32 CurrentCallDepth, uint64 ProgramCounter, ANSICHAR* HumanReadableString, SIZE_T HumanReadableStringSize, FGenericCrashContext* Context = nullptr );
 
    static CORE_API bool SymbolInfoToHumanReadableString( const FProgramCounterSymbolInfo& SymbolInfo, ANSICHAR* HumanReadableString, SIZE_T HumanReadableStringSize );
 
    static CORE_API bool SymbolInfoToHumanReadableStringEx( const FProgramCounterSymbolInfoEx& SymbolInfo, FString& out_HumanReadableString );
 
    static void ProgramCounterToSymbolInfo( uint64 ProgramCounter, FProgramCounterSymbolInfo& out_SymbolInfo)
    {
        out_SymbolInfo.ProgramCounter = ProgramCounter;
    }
 
    static void ProgramCounterToSymbolInfoEx( uint64 ProgramCounter, FProgramCounterSymbolInfoEx& out_SymbolInfo)
    {
        out_SymbolInfo.ProgramCounter = ProgramCounter;
    }
 
    static CORE_API uint32 CaptureStackBackTrace( uint64* BackTrace, uint32 MaxDepth, void* Context = nullptr );
 
    static CORE_API uint32 CaptureThreadStackBackTrace(uint64 ThreadId, uint64* BackTrace, uint32 MaxDepth, void* Context = nullptr);
 
    CORE_API FORCENOINLINE static void StackWalkAndDump( ANSICHAR* HumanReadableString, SIZE_T HumanReadableStringSize, int32 IgnoreCount, void* Context = nullptr );  // FORCENOINLINE so it can be counted during StackTrace
 
    static CORE_API void StackWalkAndDump( ANSICHAR* HumanReadableString, SIZE_T HumanReadableStringSize, void* ProgramCounter, void* Context = nullptr );
 
    static CORE_API TArray<FProgramCounterSymbolInfo> GetStack(int32 IgnoreCount, int32 MaxDepth = 100, void* Context = nullptr);
 
    static void ThreadStackWalkAndDump(ANSICHAR* HumanReadableString, SIZE_T HumanReadableStringSize, int32 IgnoreCount, uint32 ThreadId)
    {
    }
 
    static CORE_API void StackWalkAndDumpEx( ANSICHAR* HumanReadableString, SIZE_T HumanReadableStringSize, int32 IgnoreCount, uint32 Flags, void* Context = nullptr );
    static CORE_API void StackWalkAndDumpEx( ANSICHAR* HumanReadableString, SIZE_T HumanReadableStringSize, void* ProgramCounter, uint32 Flags, void* Context = nullptr );
 
    FORCEINLINE static int32 GetProcessModuleCount()
    {
        return 0;
    }
 
    FORCEINLINE static int32 GetProcessModuleSignatures(FStackWalkModuleInfo *ModuleSignatures, const int32 ModuleSignaturesSize)
    {
        return 0;
    }
 
    static CORE_API TMap<FName, FString> GetSymbolMetaData();
 
    static CORE_API void CopyVirtualPathToLocal(char* Dest, int32 DestCapacity, const char* Source);
 
protected:
 
    static CORE_API bool WantsDetailedCallstacksInNonMonolithicBuilds();
 
};