Stack.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    Stack.h: Kismet VM execution stack definition.
=============================================================================*/
 
#pragma once
 
#include "UObject/Script.h"
#include "Misc/CoreMisc.h"
#include "Templates/Casts.h"
#include "UObject/UnrealType.h"
#include "UObject/EnumProperty.h"
#include "Memory/VirtualStackAllocator.h"
 
DECLARE_LOG_CATEGORY_EXTERN(LogScriptFrame, Warning, All);
 
#ifndef UE_USE_VIRTUAL_STACK_ALLOCATOR_FOR_SCRIPT_VM
#define UE_USE_VIRTUAL_STACK_ALLOCATOR_FOR_SCRIPT_VM 0
#endif 
 
#if UE_USE_VIRTUAL_STACK_ALLOCATOR_FOR_SCRIPT_VM
FORCEINLINE void* UeVstackAllocHelper(FVirtualStackAllocator* Allocator, size_t Size, size_t Align)
{
    if (Size == 0)
    {
        return nullptr; 
    }
    if (Align < 16)
    {
        Align = 16;
    }
    return Allocator->Allocate(Size, Align);
}
 
#define UE_VSTACK_MAKE_FRAME(Name, VirtualStackAllocatorPtr) FScopedStackAllocatorBookmark Name = (VirtualStackAllocatorPtr)->CreateScopedBookmark()
#define UE_VSTACK_ALLOC(VirtualStackAllocatorPtr, Size) UeVstackAllocHelper((VirtualStackAllocatorPtr), (Size), 0) 
#define UE_VSTACK_ALLOC_ALIGNED(VirtualStackAllocatorPtr, Size, Align) UeVstackAllocHelper((VirtualStackAllocatorPtr), (Size), (Align))
#else
#define UE_VSTACK_MAKE_FRAME(Name, VirtualStackAllocatorPtr)
#define UE_VSTACK_ALLOC(VirtualStackAllocatorPtr, Size) FMemory_Alloca(Size)
#define UE_VSTACK_ALLOC_ALIGNED(VirtualStackAllocatorPtr, Size, Align) FMemory_Alloca_Aligned(Size, Align)
#endif
 
enum EPropertyType
{
    CPT_None,
    CPT_Byte,
    CPT_UInt16,
    CPT_UInt32,
    CPT_UInt64,
    CPT_Int8,
    CPT_Int16,
    CPT_Int,
    CPT_Int64,
    CPT_Bool,
    CPT_Bool8,
    CPT_Bool16,
    CPT_Bool32,
    CPT_Bool64,
    CPT_Float,
    CPT_ObjectReference,
    CPT_Name,
    CPT_Delegate,
    CPT_Interface,
    CPT_Unused_Index_19,
    CPT_Struct,
    CPT_Unused_Index_21,
    CPT_Unused_Index_22,
    CPT_String,
    CPT_Text,
    CPT_MulticastDelegate,
    CPT_WeakObjectReference,
    CPT_LazyObjectReference,
    CPT_ObjectPtrReference,
    CPT_SoftObjectReference,
    CPT_Double,
    CPT_Map,
    CPT_Set,
    CPT_FieldPath,
    CPT_FLargeWorldCoordinatesReal,
 
    CPT_MAX
};
 
 
 
/*-----------------------------------------------------------------------------
    Execution stack helpers.
-----------------------------------------------------------------------------*/
 
typedef TArray< CodeSkipSizeType, TInlineAllocator<8> > FlowStackType;
 
//
// Information remembered about an Out parameter.
//
struct FOutParmRec
{
    FProperty* Property;
    uint8*      PropAddr;
    FOutParmRec* NextOutParm;
};
 
//
// Information about script execution at one stack level.
//
 
struct FFrame : public FOutputDevice
{   
public:
    // Variables.
    UFunction* Node;
    UObject* Object;
    uint8* Code;
    uint8* Locals;
 
    FProperty* MostRecentProperty;
    uint8* MostRecentPropertyAddress;
    uint8* MostRecentPropertyContainer;
 
    FlowStackType FlowStack;
 
    FFrame* PreviousFrame;
 
    FOutParmRec* OutParms;
 
    FField* PropertyChainForCompiledIn;
 
    UFunction* CurrentNativeFunction;
 
#if UE_USE_VIRTUAL_STACK_ALLOCATOR_FOR_SCRIPT_VM
    FVirtualStackAllocator* CachedThreadVirtualStackAllocator;
#endif
 
    FFrame* PreviousTrackingFrame;
 
    bool bArrayContextFailed;
 
    bool bAbortingExecution;
 
#if PER_FUNCTION_SCRIPT_STATS
    uint8 DepthCounter;
#endif
public:
 
    // Constructors.
    FFrame( UObject* InObject, UFunction* InNode, void* InLocals, FFrame* InPreviousFrame = NULL, FField* InPropertyChainForCompiledIn = NULL );
 
    virtual ~FFrame()
    {
#if DO_BLUEPRINT_GUARD
        FBlueprintContextTracker& BlueprintExceptionTracker = FBlueprintContextTracker::Get();
        if (BlueprintExceptionTracker.ScriptStack.Num())
        {
            BlueprintExceptionTracker.ScriptStack.Pop(EAllowShrinking::No);
        }
 
        // ensure that GTopTrackingStackFrame is accurate
        if (BlueprintExceptionTracker.ScriptStack.Num() == 0)
        {
            ensure(PreviousTrackingFrame == nullptr);
        }
        else
        {
            ensure(BlueprintExceptionTracker.ScriptStack.Last() == PreviousTrackingFrame);
        }
#endif
        PopThreadLocalTopStackFrame(PreviousTrackingFrame);
        
        if (PreviousTrackingFrame)
        {
            // we propagate bAbortingExecution to frames below to avoid losing abort state
            // across heterogeneous frames (eg. bpvm -> c++ -> bpvm)
            PreviousTrackingFrame->bAbortingExecution |= bAbortingExecution;
        }
    }
 
    // Functions.
    COREUOBJECT_API void Step(UObject* Context, RESULT_DECL);
 
    FORCEINLINE_DEBUGGABLE bool StepAndCheckMostRecentProperty(UObject* Context, RESULT_DECL);
 
    COREUOBJECT_API void StepExplicitProperty(void*const Result, FProperty* Property);
 
    template<class TProperty>
    FORCEINLINE_DEBUGGABLE void StepCompiledIn(void* Result);
    FORCEINLINE_DEBUGGABLE void StepCompiledIn(void* Result, const FFieldClass* ExpectedPropertyType);
 
    template<class TProperty, typename TNativeType>
    FORCEINLINE_DEBUGGABLE TNativeType& StepCompiledInRef(void*const TemporaryBuffer);
 
    COREUOBJECT_API virtual void Serialize( const TCHAR* V, ELogVerbosity::Type Verbosity, const class FName& Category ) override;
    
    COREUOBJECT_API static void KismetExecutionMessage(const TCHAR* Message, ELogVerbosity::Type Verbosity, FName WarningId = FName());
 
    const uint8 PeekCode() const { return *Code; }
 
    void SkipCode(const int32 NumOps) { Code += NumOps; }
 
    template<typename T>
    T Read();
    template<typename TNumericType>
    TNumericType ReadInt();
    float ReadFloat();
    double ReadDouble();
    ScriptPointerType ReadPointer();
    FName ReadName();
    UObject* ReadObject();
    int32 ReadWord();
    FProperty* ReadProperty();
 
    FProperty* ReadPropertyUnchecked();
 
    CodeSkipSizeType ReadCodeSkipCount();
 
    VariableSizeType ReadVariableSize(FProperty** ExpressionField);
 
    COREUOBJECT_API FString GetStackTrace() const;
 
    COREUOBJECT_API void GetStackTrace(FStringBuilderBase& StringBuilder) const;
 
    COREUOBJECT_API static FString GetScriptCallstack(bool bReturnEmpty = false, bool bTopOfStackOnly = false);
 
    COREUOBJECT_API static void GetScriptCallstack(FStringBuilderBase& StringBuilder, bool bReturnEmpty = false, bool bTopOfStackOnly = false);
        
    UE_DEPRECATED(5.1, "Please use GetStackDescription(FStringBuilderBase&).")
    COREUOBJECT_API FString GetStackDescription() const;
 
    COREUOBJECT_API void GetStackDescription(FStringBuilderBase& StringBuilder) const;
 
#if DO_BLUEPRINT_GUARD
    static void InitPrintScriptCallstack();
#endif
 
    COREUOBJECT_API static FFrame* PushThreadLocalTopStackFrame(FFrame* NewTopStackFrame);
    COREUOBJECT_API static void PopThreadLocalTopStackFrame(FFrame* NewTopStackFrame);
    COREUOBJECT_API static FFrame* GetThreadLocalTopStackFrame();
};
 
 
/*-----------------------------------------------------------------------------
    FFrame implementation.
-----------------------------------------------------------------------------*/
 
inline FFrame::FFrame( UObject* InObject, UFunction* InNode, void* InLocals, FFrame* InPreviousFrame, FField* InPropertyChainForCompiledIn )
    : Node(InNode)
    , Object(InObject)
    , Code(InNode->Script.GetData())
    , Locals((uint8*)InLocals)
    , MostRecentProperty(nullptr)
    , MostRecentPropertyAddress(nullptr)
    , MostRecentPropertyContainer(nullptr)
    , PreviousFrame(InPreviousFrame)
    , OutParms(NULL)
    , PropertyChainForCompiledIn(InPropertyChainForCompiledIn)
    , CurrentNativeFunction(nullptr)
    , bArrayContextFailed(false)
    , bAbortingExecution(false)
#if PER_FUNCTION_SCRIPT_STATS
    , DepthCounter(0)
#endif
{
#if DO_BLUEPRINT_GUARD
    FBlueprintContextTracker::Get().ScriptStack.Push(this);
#endif
    PreviousTrackingFrame = PushThreadLocalTopStackFrame(this);
    
    {
        // we propagate bAbortingExecution to *upper* frames to avoid invoking code
        // on top of already-aborted frames
        if (PreviousTrackingFrame)
        {
            bAbortingExecution |= PreviousTrackingFrame->bAbortingExecution;
        }
        if (InPreviousFrame)
        {
            bAbortingExecution |= InPreviousFrame->bAbortingExecution;
        }
    }
 
#if PER_FUNCTION_SCRIPT_STATS
    if (InPreviousFrame)
    {
        DepthCounter = (InPreviousFrame->DepthCounter < MAX_uint8) ? InPreviousFrame->DepthCounter + 1 : MAX_uint8;
    }
#endif
#if UE_USE_VIRTUAL_STACK_ALLOCATOR_FOR_SCRIPT_VM
    if (InPreviousFrame == nullptr)
    {
        CachedThreadVirtualStackAllocator = FBlueprintContext::GetThreadSingleton()->GetVirtualStackAllocator();
    }
    else
    {
        CachedThreadVirtualStackAllocator = InPreviousFrame->CachedThreadVirtualStackAllocator;
    }
#endif
}
 
template<typename T>
inline T FFrame::Read()
{
    T Result = FPlatformMemory::ReadUnaligned<T>(Code);
    Code += sizeof(T);
    return Result;
}
 
template<typename TNumericType>
inline TNumericType FFrame::ReadInt()
{
    return Read<TNumericType>();
}
 
inline UObject* FFrame::ReadObject()
{
    UObject* Result = (UObject*) ReadPointer();
 
#if UE_WITH_OBJECT_HANDLE_LATE_RESOLVE || UE_WITH_REMOTE_OBJECT_HANDLE
    TObjectPtr<UObject> ObjPtr(Result);
    return ObjPtr.Get();
#else
    return Result;
#endif
}
 
inline FProperty* FFrame::ReadProperty()
{
    FProperty* Result = ReadPropertyUnchecked();
 
    // Callers don't check for NULL; this method is expected to succeed.
    check(Result);
 
    return Result;
}
 
inline FProperty* FFrame::ReadPropertyUnchecked()
{
    FProperty* Result = (FProperty*)ReadPointer();
    MostRecentProperty = Result;
    return Result;
}
 
inline float FFrame::ReadFloat()
{
    return Read<float>();
}
 
inline double FFrame::ReadDouble()
{
    return Read<double>();
}
 
inline ScriptPointerType FFrame::ReadPointer()
{
    // Serialized pointers are always the size of ScriptPointerType 
    ScriptPointerType Pointer = FPlatformMemory::ReadUnaligned<ScriptPointerType>(Code);
 
    Code += sizeof(ScriptPointerType);
    return Pointer;
}
 
inline int32 FFrame::ReadWord()
{
    return Read<uint16>();
}
 
inline CodeSkipSizeType FFrame::ReadCodeSkipCount()
{
    CodeSkipSizeType Result = FPlatformMemory::ReadUnaligned<CodeSkipSizeType>(Code);
    Code += sizeof(CodeSkipSizeType);
    return Result;
}
 
inline VariableSizeType FFrame::ReadVariableSize( FProperty** ExpressionField )
{
    VariableSizeType Result=0;
 
    FField* Field = (FField*)ReadPropertyUnchecked(); // Is it safe to assume it's an FField?
    FProperty* Property = CastField<FProperty>(Field);
    if (Property)
    {
        Result = (VariableSizeType)Property->GetSize();
    }
 
    if (ExpressionField != nullptr)
    {
        *ExpressionField = Property;
    }
 
    return Result;
}
 
inline FName FFrame::ReadName()
{
    FScriptName Result = FPlatformMemory::ReadUnaligned<FScriptName>(Code);
    Code += sizeof(FScriptName);
    return ScriptNameToName(Result);
}
 
COREUOBJECT_API void GInitRunaway();
 
FORCEINLINE_DEBUGGABLE bool FFrame::StepAndCheckMostRecentProperty(UObject* Context, RESULT_DECL)
{
    Step(Context, RESULT_PARAM);
 
    return (MostRecentProperty && MostRecentPropertyAddress);
}
 
template<class TProperty>
FORCEINLINE_DEBUGGABLE void FFrame::StepCompiledIn(void* Result)
{
    StepCompiledIn(Result, TProperty::StaticClass());
}
 
FORCEINLINE_DEBUGGABLE void FFrame::StepCompiledIn(void* Result, const FFieldClass* ExpectedPropertyType)
{
    if (Code)
    {
        Step(Object, Result);
    }
    else
    {
        checkSlow(ExpectedPropertyType && ExpectedPropertyType->IsChildOf(FProperty::StaticClass()));
        checkSlow(PropertyChainForCompiledIn && PropertyChainForCompiledIn->IsA(ExpectedPropertyType));
        FProperty* Property = (FProperty*)PropertyChainForCompiledIn;
        PropertyChainForCompiledIn = Property->Next;
        StepExplicitProperty(Result, Property);
    }
}
 
template<class TProperty, typename TNativeType>
FORCEINLINE_DEBUGGABLE TNativeType& FFrame::StepCompiledInRef(void*const TemporaryBuffer)
{
    MostRecentPropertyAddress = nullptr;
    MostRecentPropertyContainer = nullptr;
 
    if (Code)
    {
        Step(Object, TemporaryBuffer);
    }
    else
    {
        checkSlow(CastField<TProperty>(PropertyChainForCompiledIn) && CastField<FProperty>(PropertyChainForCompiledIn));
        TProperty* Property = (TProperty*)PropertyChainForCompiledIn;
        PropertyChainForCompiledIn = Property->Next;
        StepExplicitProperty(TemporaryBuffer, Property);
    }
 
    return (MostRecentPropertyAddress != NULL) ? *(TNativeType*)(MostRecentPropertyAddress) : *(TNativeType*)TemporaryBuffer;
}