GenericPlatformCrashContext.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainersFwd.h"
#include "Containers/StringFwd.h"
#include "Containers/StringView.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "Delegates/DelegateCombinations.h"
#include "GenericPlatform/GenericPlatformStackWalk.h"
#include "HAL/PlatformMemory.h"
#include "HAL/PlatformProcess.h"
#include "HAL/PlatformStackWalk.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Optional.h"
#include "Misc/SecureHash.h"
#include "Misc/Timespan.h"
#include "Templates/Function.h"
#include "Templates/UnrealTemplate.h"
 
struct FDateTime;
struct FGuid;
struct FScopedAdditionalCrashContextProvider;
 
#ifndef WITH_ADDITIONAL_CRASH_CONTEXTS
#define WITH_ADDITIONAL_CRASH_CONTEXTS 1
#endif
 
struct FProgramCounterSymbolInfo;
 
enum ECrashExitCodes : int32
{
    MonitoredApplicationStillRunning = 777001,
 
    MonitoredApplicationExitCodeNotAvailable = 777002,
 
    CrashReporterCrashed = 777003,
 
    CrashHandlerCrashed = 777004,
 
    OutOfProcessReporterExitedUnexpectedly = 777005,
 
    CrashDuringStaticInit = 777006,
 
    OutOfProcessReporterCheckFailed = 777007,
 
    UnhandledEnsure = 777008,
};
 
enum class ECrashDescVersions : int32
{
    VER_1_NewCrashFormat,
 
    VER_2_AddedNewProperties,
 
    VER_3_CrashContext = 3,
};
 
enum class ECrashDumpMode : int32
{
    Default = 0,
 
    FullDump = 1,
 
    FullDumpAlways = 2,
};
 
struct FCrashStackFrame
{
    FString ModuleName;
    uint64 BaseAddress;
    uint64 Offset;
 
    FCrashStackFrame(FString ModuleNameIn, uint64 BaseAddressIn, uint64 OffsetIn)
        : ModuleName(MoveTemp(ModuleNameIn))
        , BaseAddress(BaseAddressIn)
        , Offset(OffsetIn)
    {
    }
};
 
struct FThreadStackFrames {
    FString                     ThreadName;
    uint32                      ThreadId;
    TArray<FCrashStackFrame>    StackFrames;
};
 
enum class ECrashContextType
{
    Crash,
    Assert,
    Ensure,
    Stall,
    GPUCrash,
    Hang,
    OutOfMemory,
    AbnormalShutdown,
    VerseRuntimeError,
 
    Max
};
 
enum class ECrashTrigger
{
    Debug = -1,
    Normal = 0
};
 
enum class EUnattendedStatus : uint8
{
    Unknown,
    Attended,
    Unattended
};
 
CORE_API const TCHAR* AttendedStatusToString(const EUnattendedStatus Status);
 
#define CR_MAX_ERROR_MESSAGE_CHARS 2048
#define CR_MAX_DIRECTORY_CHARS 256
#define CR_MAX_SYMBOL_CHARS 128
#define CR_MAX_STACK_FRAMES 256
#define CR_MAX_THREAD_NAME_CHARS 64
#define CR_MAX_THREADS 512
#define CR_MAX_GENERIC_FIELD_CHARS 64
#define CR_MAX_COMMANDLINE_CHARS 1024
#define CR_MAX_RICHTEXT_FIELD_CHARS 512
#define CR_MAX_DYNAMIC_BUFFER_CHARS 1024*32
#define CR_MAX_GPU_BREADCRUMBS_QUEUES 2
#define CR_MAX_GPU_BREADCRUMBS_STRING_CHARS 1024*8
 
struct FSessionContext 
{
    bool                    bIsInternalBuild;
    bool                    bIsPerforceBuild;
    bool                    bWithDebugInfo;
    bool                    bIsSourceDistribution;
    bool                    bIsUERelease;
    bool                    bIsOOM;
    bool                    bIsExitRequested;
    bool                    bIsStuck;
    uint32                  ProcessId;
    int32                   LanguageLCID;
    int32                   NumberOfCores;
    int32                   NumberOfCoresIncludingHyperthreads;
    uint32                  CPUModelID;
    uint32                  CPUMicrocodeRevision;
    int32                   SecondsSinceStart;
    int32                   CrashDumpMode;
    int32                   CrashTrigger;
    uint32                  StuckThreadId;
    int32                   OOMAllocationAlignment;
    uint64                  OOMAllocationSize;
    TCHAR                   EngineVersion[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   EngineCompatibleVersion[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   BuildVersion[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   GameName[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   EngineMode[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   EngineModeEx[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   ExecutableName[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   BuildConfigurationName[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   DeploymentName[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   BaseDir[CR_MAX_DIRECTORY_CHARS];
    TCHAR                   RootDir[CR_MAX_DIRECTORY_CHARS];
    TCHAR                   EpicAccountId[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   LoginIdStr[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   SymbolsLabel[CR_MAX_SYMBOL_CHARS];
    TCHAR                   OsVersion[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   OsSubVersion[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   CPUVendor[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   CPUBrand[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   PrimaryGPUBrand[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   UserName[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   DefaultLocale[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   CrashGUIDRoot[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   UserActivityHint[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   GameSessionID[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   CommandLine[CR_MAX_COMMANDLINE_CHARS];
    TCHAR                   CrashReportClientRichText[CR_MAX_RICHTEXT_FIELD_CHARS];
    TCHAR                   GameStateName[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   CrashConfigFilePath[CR_MAX_DIRECTORY_CHARS];
    TCHAR                   AttendedStatus[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   PlatformName[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   PlatformNameIni[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR                   AnticheatProvider[CR_MAX_GENERIC_FIELD_CHARS];
    FPlatformMemoryStats    MemoryStats;
};
 
struct FUserSettingsContext
{
    bool                    bNoDialog = false;
    bool                    bSendUnattendedBugReports = false;
    bool                    bSendUsageData = false;
    bool                    bImplicitSend = false;
    TCHAR                   LogFilePath[CR_MAX_DIRECTORY_CHARS];
};
 
struct FGPUBreadcrumbsSharedContext
{
    struct FQueueData {
        TCHAR QueueName[CR_MAX_GENERIC_FIELD_CHARS];
        TCHAR FullHash[CR_MAX_GENERIC_FIELD_CHARS];
        TCHAR ActiveHash[CR_MAX_GENERIC_FIELD_CHARS];
        TCHAR Breadcrumbs[CR_MAX_GPU_BREADCRUMBS_STRING_CHARS];
    };
 
    TCHAR SourceName[CR_MAX_GENERIC_FIELD_CHARS];
    TCHAR Version[CR_MAX_GENERIC_FIELD_CHARS];
 
    uint32 NumQueues = 0;
    FQueueData Queues[CR_MAX_GPU_BREADCRUMBS_QUEUES];
};
 
struct FSharedCrashContext
{
    // Exception info
    TCHAR                   ErrorMessage[CR_MAX_ERROR_MESSAGE_CHARS];
    uint32                  ThreadIds[CR_MAX_THREADS];
    TCHAR                   ThreadNames[CR_MAX_THREAD_NAME_CHARS * CR_MAX_THREADS];
    uint32                  NumThreads;
    uint32                  CrashingThreadId;
    ECrashContextType       CrashType;
 
    // Additional user settings.
    FUserSettingsContext    UserSettings;
 
    // Platform specific crash context (must be portable)
    void*                   PlatformCrashContext;
    // Directory for dumped files
    TCHAR                   CrashFilesDirectory[CR_MAX_DIRECTORY_CHARS];
    // Game/Engine information not possible to catch out of process
    FSessionContext         SessionContext;
    // Count and offset into dynamic buffer to comma separated plugin list
    uint32                  EnabledPluginsNum;
    uint32                  EnabledPluginsOffset;
    // Count and offset into dynamic buffer to comma separated key=value data for engine information
    uint32                  EngineDataNum;
    uint32                  EngineDataOffset;
    // Count and offset into dynamic buffer to comma separated key=value data for  game information
    uint32                  GameDataNum;
    uint32                  GameDataOffset;
    // Count and offset into dynamic buffer to comma separated file list
    uint32                  FilePathsNum;
    uint32                  FilePathsOffset;
    // Fixed size dynamic buffer
    TCHAR                   DynamicData[CR_MAX_DYNAMIC_BUFFER_CHARS];
 
    // Program counter address where the error occurred.
    void*                   ErrorProgramCounter;
 
    // Instruction address where the exception was raised that initiated crash reporting
    void*                   ExceptionProgramCounter;
 
    // GPU breadcrumbs.
    FGPUBreadcrumbsSharedContext  GPUBreadcrumbs;
};
 
#if WITH_ADDITIONAL_CRASH_CONTEXTS
 
struct FCrashContextExtendedWriter
{
    virtual ~FCrashContextExtendedWriter() = default;
 
    virtual void AddBuffer(const TCHAR* Identifier, const uint8* Data, uint32 DataSize) = 0;
 
    virtual void AddString(const TCHAR* Identifier, const TCHAR* DataStr) = 0;
};
 
DECLARE_MULTICAST_DELEGATE_OneParam(FAdditionalCrashContextDelegate, FCrashContextExtendedWriter&);
 
#endif //WITH_ADDITIONAL_CRASH_CONTEXTS
 
DECLARE_MULTICAST_DELEGATE(FEngineDataResetDelegate);
DECLARE_MULTICAST_DELEGATE_TwoParams(FEngineDataSetDelegate, const FString&, const FString&);
 
DECLARE_MULTICAST_DELEGATE(FGameDataResetDelegate);
DECLARE_MULTICAST_DELEGATE_TwoParams(FGameDataSetDelegate, const FString&, const FString&);
 
struct FThreadCallStack
{
    TConstArrayView<uint64> StackFrames;
    const TCHAR* ThreadName;
    uint32 ThreadId;
};
 
struct FGPUBreadcrumbCrashData
{
    static constexpr TCHAR const CurrentVersion[] = TEXT("526BDA74-7A81-44C3-B0FD-9DBF80973C25");
 
    enum class EState : uint8
    {
        NotStarted = 0,
        Active     = 1,
        Finished   = 2
    };
 
    // These are serialized. Do not change this array without bumping the CurrentVersion.
    TCHAR const static constexpr StateChars[] =
    {
        TEXT('N'),
        TEXT('A'),
        TEXT('F'),
    };
 
    struct FQueueData
    {
        FString BreadcrumbString;
        FSHAHash FullHash;
        FSHAHash ActiveHash;
 
        operator bool() const { return !BreadcrumbString.IsEmpty(); }
    };
    TMap<FString, FQueueData> Queues;
    FString SourceName;
    FString Version;
 
    class FSerializer
    {
        FString String;
        FSHA1 FullHash, ActiveHash;
        TArray<bool> ChildStack;
 
        // Sanitize the event name string to remove characters that are used as delimiters for parsing.
        static FString Sanitize(FString const& Name);
 
        // Event names include parameters, mostly numeric (e.g. "Frame 1234"), that should be ignored when computing the hash.
        static FString SanitizeForHash(FString const& Name);
 
    public:
        CORE_API void BeginNode(FString const& Name, EState State);
        CORE_API void EndNode();
 
        CORE_API FQueueData GetResult();
    };
 
    FGPUBreadcrumbCrashData(TCHAR const* InSourceName, TCHAR const* InVersion = CurrentVersion)
        : SourceName(InSourceName), Version(InVersion)
    {}
};
 
struct FGenericCrashContext
{
public:
 
    CORE_API static const ANSICHAR* const CrashContextRuntimeXMLNameA;
    CORE_API static const TCHAR* const CrashContextRuntimeXMLNameW;
 
    CORE_API static const ANSICHAR* const CrashConfigFileNameA;
    CORE_API static const TCHAR* const CrashConfigFileNameW;
    CORE_API static const TCHAR* const CrashConfigExtension;
    CORE_API static const TCHAR* const ConfigSectionName;
    CORE_API static const TCHAR* const CrashConfigPurgeDays;
    CORE_API static const TCHAR* const CrashGUIDRootPrefix;
 
    CORE_API static const TCHAR* const CrashReportOptionalAttachmentsDirName;
 
    CORE_API static const TCHAR* const CrashContextExtension;
    CORE_API static const TCHAR* const RuntimePropertiesTag;
    CORE_API static const TCHAR* const DeploymentNameTag;
    CORE_API static const TCHAR* const PlatformPropertiesTag;
    CORE_API static const TCHAR* const EngineDataTag;
    CORE_API static const TCHAR* const GameDataTag;
    CORE_API static const TCHAR* const RequestDataTag;
    CORE_API static const TCHAR* const GameNameTag;
    CORE_API static const TCHAR* const EnabledPluginsTag;
    CORE_API static const TCHAR* const UEMinidumpName;
    CORE_API static const TCHAR* const NewLineTag;
    CORE_API static const TCHAR* const CrashVersionTag;
    CORE_API static const TCHAR* const ExecutionGuidTag;
    CORE_API static const TCHAR* const CrashGuidTag;
    CORE_API static const TCHAR* const IsEnsureTag;
    CORE_API static const TCHAR* const IsStallTag;
    CORE_API static const TCHAR* const IsAssertTag;
    CORE_API static const TCHAR* const CrashTypeTag;
    CORE_API static const TCHAR* const ErrorMessageTag;
    CORE_API static const TCHAR* const CrashReporterMessageTag;
    CORE_API static const TCHAR* const AttendedStatusTag;
    CORE_API static const TCHAR* const SecondsSinceStartTag;
    CORE_API static const TCHAR* const BuildVersionTag;
    CORE_API static const TCHAR* const CallStackTag;
    CORE_API static const TCHAR* const PortableCallStackTag;
    CORE_API static const TCHAR* const PortableCallStackHashTag;
    CORE_API static const TCHAR* const IsRequestingExitTag;
    CORE_API static const TCHAR* const LogFilePathTag;
    CORE_API static const TCHAR* const ProcessIdTag;
    CORE_API static const TCHAR* const IsInternalBuildTag;
    CORE_API static const TCHAR* const IsPerforceBuildTag;
    CORE_API static const TCHAR* const IsWithDebugInfoTag;
    CORE_API static const TCHAR* const IsSourceDistributionTag;
 
    static constexpr inline int32 CrashGUIDLength = 128;
 
    CORE_API static const TCHAR* const CrashTypeCrash;
    CORE_API static const TCHAR* const CrashTypeAssert;
    CORE_API static const TCHAR* const CrashTypeEnsure;
    CORE_API static const TCHAR* const CrashTypeStall;
    CORE_API static const TCHAR* const CrashTypeGPU;
    CORE_API static const TCHAR* const CrashTypeHang;
    CORE_API static const TCHAR* const CrashTypeAbnormalShutdown;
    CORE_API static const TCHAR* const CrashTypeOutOfMemory;
    CORE_API static const TCHAR* const CrashTypeVerseRuntimeError;
 
    CORE_API static const TCHAR* const EngineModeExUnknown;
    CORE_API static const TCHAR* const EngineModeExDirty;
    CORE_API static const TCHAR* const EngineModeExVanilla;
 
    // A guid that identifies this particular execution. Allows multiple crash reports from the same run of the project to be tied together
    CORE_API static const FGuid ExecutionGuid;
 
    CORE_API static void Initialize();
 
    CORE_API static void InitializeFromContext(const FSessionContext& Context, const TCHAR* EnabledPlugins, const TCHAR* EngineData, const TCHAR* GameData, const TCHAR* FilePathData, const FGPUBreadcrumbsSharedContext* GPUBreadcrumbs);
 
    CORE_API static const FSessionContext& GetCachedSessionContext();
 
    CORE_API static FString GetGameName();
 
    static bool IsInitalized()
    {
        return bIsInitialized;
    }
 
    static bool IsOutOfProcessCrashReporter()
    {
        return OutOfProcessCrashReporterPid != 0;
    }
 
    static uint32 GetOutOfProcessCrashReporterProcessId()
    {
        return OutOfProcessCrashReporterPid;
    }
 
    static void SetOutOfProcessCrashReporterPid(uint32 ProcessId)
    {
        OutOfProcessCrashReporterPid = ProcessId;
    }
 
    CORE_API static void SetOutOfProcessCrashReporterExitCode(int32 ExitCode);
 
    CORE_API static TOptional<int32> GetOutOfProcessCrashReporterExitCode();
 
    CORE_API FGenericCrashContext(ECrashContextType InType, const TCHAR* ErrorMessage);
 
    virtual ~FGenericCrashContext() { }
 
    CORE_API static FString GetTempSessionContextFilePath(uint64 ProcessID);
 
    CORE_API static void CleanupTempSessionContextFiles(const FTimespan& ExpirationAge);
 
    CORE_API void SerializeContentToBuffer() const;
 
    const FString& GetBuffer() const
    {
        return CommonBuffer;
    }
 
    CORE_API void GetUniqueCrashName(TCHAR* GUIDBuffer, int32 BufferSize) const;
 
    CORE_API const bool IsFullCrashDump() const;
 
    CORE_API virtual void SerializeAsXML( const TCHAR* Filename ) const;
 
    CORE_API static void SerializeSessionContext(FString& Buffer);
    
    template <typename Type>
    void AddCrashProperty(const TCHAR* PropertyName, const Type& Value) const
    {
        AddCrashPropertyInternal(CommonBuffer, PropertyName, Value);
    }
 
    template <typename Type>
    static void AddCrashProperty(FString& Buffer, const TCHAR* PropertyName, const Type& Value)
    {
        AddCrashPropertyInternal(Buffer, PropertyName, Value);
    }
 
    CORE_API static void AppendEscapedXMLString(FString& OutBuffer, FStringView Text );
    CORE_API static void AppendEscapedXMLString(FStringBuilderBase& OutBuffer, FStringView Text);
 
    CORE_API static void AppendPortableCallstack(FString& OutBuffer, TConstArrayView<FCrashStackFrame> StackFrames);
 
    CORE_API static FString UnescapeXMLString( const FString& Text );
 
    CORE_API static const TCHAR* GetCrashTypeString(ECrashContextType Type);
 
    CORE_API static FString GetCrashGameName();
 
    CORE_API static const TCHAR* GetCrashConfigFilePath();
 
    CORE_API static const TCHAR* GetCrashConfigFolder();
 
    CORE_API static void PurgeOldCrashConfig();
 
    CORE_API static void SetEpicAccountId(const FString& EpicAccountId);
 
    CORE_API static void ResetEngineData();
 
    static FEngineDataResetDelegate& OnEngineDataResetDelegate() { return OnEngineDataReset; }
 
    CORE_API static void SetEngineData(const FString& Key, const FString& Value);
 
    CORE_API static void SetGPUBreadcrumbs(FGPUBreadcrumbCrashData&& Data);
 
    static FEngineDataSetDelegate& OnEngineDataSetDelegate() { return OnEngineDataSet; }
 
    CORE_API static const TMap<FString, FString>& GetEngineData();
 
    CORE_API static void ResetGameData();
 
    static FGameDataResetDelegate& OnGameDataResetDelegate() { return OnGameDataReset; }
 
    CORE_API static void SetGameData(const FString& Key, const FString& Value);
 
    static FGameDataSetDelegate& OnGameDataSetDelegate() { return OnGameDataSet; }
 
    CORE_API static const TMap<FString, FString>& GetGameData();
 
    CORE_API static void AddPlugin(const FString& PluginDesc);
 
    CORE_API static void AddFile(const FString& AbsoluteSourcePath);
 
    CORE_API static FString DumpLog(const FString& CrashFolderAbsolute);
 
    CORE_API static void DumpAdditionalContext(const TCHAR* CrashFolderAbsolute);
 
    CORE_API static void CopySharedCrashContext(FSharedCrashContext& Dst);
 
    CORE_API static void SetMemoryStats(const FPlatformMemoryStats& MemoryStats);
 
    CORE_API static void SetAnticheatProvider(const FString& AnticheatProvider);
 
    CORE_API static void OnThreadStuck(uint32 ThreadId);
 
    CORE_API static void OnThreadUnstuck(uint32 ThreadId);
 
    CORE_API static bool CreateCrashReportDirectory(const TCHAR* CrashGUIDRoot, int32 CrashIndex, FString& OutCrashDirectoryAbsolute);
 
    CORE_API static void SetEngineExit(bool bIsRequestExit);
 
#if WITH_ADDITIONAL_CRASH_CONTEXTS
    static inline FAdditionalCrashContextDelegate& OnAdditionalCrashContextDelegate()
    {
        return AdditionalCrashContextDelegate;
    }
#endif //WITH_ADDITIONAL_CRASH_CONTEXTS
 
    void SetCrashedProcess(const FProcHandle& Process)
    {
        ProcessHandle = Process;
    }
 
    void SetCrashedThreadId(uint32 InId)
    {
        CrashedThreadId = InId;
    }
 
    CORE_API void SetNumMinidumpFramesToIgnore(int32 InNumMinidumpFramesToIgnore);
 
    CORE_API void CapturePortableCallStack(void* ErrorProgramCounter, void* Context);
 
    CORE_API void CaptureThreadPortableCallStack(const uint64 ThreadId, void* Context);
 
    UE_DEPRECATED(5.0, "")
    CORE_API void CapturePortableCallStack(int32 NumStackFramesToIgnore, void* Context);
    
    CORE_API virtual void SetPortableCallStack(const uint64* StackFrames, int32 NumStackFrames);
 
    CORE_API virtual void GetPortableCallStack(const uint64* StackFrames, int32 NumStackFrames, TArray<FCrashStackFrame>& OutCallStack) const;
 
    CORE_API virtual void CaptureModules();
 
    CORE_API virtual void GetModules(TArray<FStackWalkModuleInfo>& OutModules) const;
    
    CORE_API virtual void AddPortableThreadCallStacks(TConstArrayView<FThreadCallStack> Threads);
    CORE_API virtual void AddPortableThreadCallStack(uint32 ThreadId, const TCHAR* ThreadName, const uint64* StackFrames, int32 NumStackFrames);
 
    CORE_API virtual void CopyPlatformSpecificFiles(const TCHAR* OutputDirectory, void* Context);
 
    CORE_API static void CleanupPlatformSpecificFiles();
 
    ECrashContextType GetType() const { return Type; }
 
    static bool IsTypeContinuable(ECrashContextType Type)
    {
        switch (Type)
        {
        // Verse runtime errors only halt the Verse runtime itself; they do not result in a crash.
        // Certain runtime errors may be recoverable from in the future.
        case ECrashContextType::VerseRuntimeError:
        case ECrashContextType::Ensure:
        case ECrashContextType::Stall:
            return true;
 
        case ECrashContextType::Crash:
        case ECrashContextType::Assert:
        case ECrashContextType::GPUCrash:
        case ECrashContextType::Hang:
        case ECrashContextType::OutOfMemory:
        case ECrashContextType::AbnormalShutdown:
        case ECrashContextType::Max:
        default:
            return false;
        }
    }
 
    CORE_API static void SetDeploymentName(const FString& EpicApp);
 
    CORE_API static const TCHAR* GetDeploymentName();
 
    CORE_API static void SetCrashTrigger(ECrashTrigger Type);
 
protected:
    virtual bool GetPlatformAllThreadContextsString(FString& OutStr) const { return false; }
 
    FProcHandle ProcessHandle;
    ECrashContextType Type;
    uint32 CrashedThreadId;
    const TCHAR* ErrorMessage;
    int NumMinidumpFramesToIgnore;
    TArray<FCrashStackFrame> CallStack;
    TArray<FThreadStackFrames> ThreadCallStacks;
    TArray<FStackWalkModuleInfo> ModulesInfo;
 
    CORE_API virtual const TCHAR* GetCallstackProperty() const;
 
    CORE_API static const FString* GetEngineData(const FString& Key);
 
    CORE_API static const FString* GetGameData(const FString& Key);
 
    CORE_API static FString GenerateNewCrashGuidBase();
 
private:
 
    static void SerializeTempCrashContextToFile();
 
    static void SerializeUserSettings(FString& Buffer);
 
    CORE_API static void AddCrashPropertyInternal(FString& Buffer, FStringView PropertyName, FStringView PropertyValue);
 
    template <typename Type>
    static void AddCrashPropertyInternal(FString& Buffer, FStringView PropertyName, const Type& Value)
    {
        AddCrashPropertyInternal(Buffer, PropertyName, FStringView(TTypeToString<Type>::ToString(Value)));
    }
 
    CORE_API virtual void AddPlatformSpecificProperties() const;
 
    void AddPortableCallStack() const;
 
    void AddPortableCallStackHash() const;
 
    void AddGPUBreadcrumbs() const;
 
    void AddModules() const;
 
public:  // Allows this helper functionality to be present for clients to write their own types of crash reports.
    CORE_API static void AddHeader(FString& Buffer);
 
    CORE_API static void AddFooter(FString& Buffer);
 
    CORE_API static void BeginSection(FString& Buffer, const TCHAR* SectionName);
    CORE_API static void EndSection(FString& Buffer, const TCHAR* SectionName);
    CORE_API static void AddSection(FString& Buffer, const TCHAR* SectionName, const FString& SectionContent);
 
private:
    static void InitializeFromConfig();
 
    static void UpdateLocalizedStrings();
 
    static bool bIsInitialized;
 
    CORE_API static uint32 OutOfProcessCrashReporterPid;
 
    static volatile int64 OutOfProcessCrashReporterExitCode;
 
    static int32 StaticCrashContextIndex;
 
#if WITH_ADDITIONAL_CRASH_CONTEXTS
    CORE_API static FAdditionalCrashContextDelegate AdditionalCrashContextDelegate;
#endif //WITH_ADDITIONAL_CRASH_CONTEXTS
 
    mutable FString CommonBuffer;
 
    int32 CrashContextIndex;
 
    CORE_API static FEngineDataResetDelegate OnEngineDataReset;
    CORE_API static FEngineDataSetDelegate OnEngineDataSet;
 
    CORE_API static FGameDataResetDelegate OnGameDataReset;
    CORE_API static FGameDataSetDelegate OnGameDataSet;
 
    // FNoncopyable
    FGenericCrashContext( const FGenericCrashContext& ) = delete;
    FGenericCrashContext& operator=(const FGenericCrashContext&) = delete;
};
 
struct FGenericMemoryWarningContext
{};
 
namespace RecoveryService
{
    CORE_API FString GetRecoveryServerName();
 
    CORE_API FString MakeSessionName();
 
    CORE_API bool TokenizeSessionName(const FString& SessionName, FString* OutServerName, int32* SeqNum, FString* ProjName, FDateTime* DateTime);
}
 
#if WITH_ADDITIONAL_CRASH_CONTEXTS
 
struct FAdditionalCrashContextStack
{
    CORE_API static FAdditionalCrashContextStack& GetThreadContextProvider();
    CORE_API static void PushProvider(struct FScopedAdditionalCrashContextProvider* Provider);
    CORE_API static void PopProvider();
 
    CORE_API static void ExecuteProviders(FCrashContextExtendedWriter& Writer);
 
private:
    enum { MaxStackDepth = 16 };
    FAdditionalCrashContextStack* Next;
    const FScopedAdditionalCrashContextProvider* Stack[MaxStackDepth];
    uint32 StackIndex = 0;
 
    FAdditionalCrashContextStack();
    ~FAdditionalCrashContextStack();
    
    inline void PushProviderInternal(const FScopedAdditionalCrashContextProvider* Provider) 
    {
        check(StackIndex < MaxStackDepth);
        Stack[StackIndex++] = Provider;
    }
 
    inline void PopProviderInternal()
    {
        check(StackIndex > 0);
        Stack[--StackIndex] = nullptr;
    }
};
 
struct FScopedAdditionalCrashContextProvider
{
public:
    FScopedAdditionalCrashContextProvider(TUniqueFunction<void(FCrashContextExtendedWriter&)> InFunc)
        : Func(MoveTemp(InFunc))
    {
        FAdditionalCrashContextStack::PushProvider(this);
    }
 
    ~FScopedAdditionalCrashContextProvider()
    {
        FAdditionalCrashContextStack::PopProvider();
    }
 
    void Execute(FCrashContextExtendedWriter& Writer) const
    {
        Func(Writer);
    }
 
private:
    TUniqueFunction<void(FCrashContextExtendedWriter&)> Func;
};
 
#define UE_ADD_CRASH_CONTEXT_SCOPE(FuncExpr) FScopedAdditionalCrashContextProvider ANONYMOUS_VARIABLE(AddCrashCtx)(FuncExpr)
 
#else
 
#define UE_ADD_CRASH_CONTEXT_SCOPE(FuncExpr) 
 
#endif // WITH_ADDITIONAL_CRASH_CONTEXTS