What exactly is the "Stack" when defining custom thunks?

Kotaru_1 · March 9, 2025, 10:40pm

NVM, this excerpt helped me understand it better:

"

Every function call in BPVM (whether native function or script function/event) handled the same way:
BPVM reads the related UFunction* that get linked in runtime we mentioned earlier, and reads its properties, like what kind of params it has and total size of its parameters.
A memory block is allocated before function call happens (via FMemory__Alloca__Aligned macro). Size of this memory block is equal to total size of the paramters of your function. This is what we call “parms memory”.
When a function call happens, all the existing parameters in stack/graph that created for the function parameter is copied to said memory block. For example, if you have a local float variable in a BP function, and if thats plugged to a pin of a node that is a custom thunk, that float variable is copied to “parms memory” block BPVM allocated just before this step.
This “parms memory” can be accessed through FFrame::Locals, because FFrame::Locals is a uint8* pointer that points to the allocated “parms memory”. When you use PARAM_PASSED_BY_VAL macros or use Stack.StepCompiledIn<FProperty>(Object, &Thing) you actually walk through Locals. This part is a bit confusing and it’s normal if you’re lost, but bear with me.

"

gist.github.com

https://gist.github.com/intaxwashere/e9b1f798427686b46beab2521d7efbcf

customthunkexample.md

# Custom thunks TL;DR

This smol post assumes you worked on a custom thunk implementation before but no idea how it works, why you're using cursed macros from 1990s etc. If you don't have any programming experience or relatively new to Unreal world, it's likely you might not understand anything from this post, not because concepts are too difficult to grasp, but rather because this post is written for the people who has an understanding of how Unreal works since a while and want to expand their knowledge of custom thunks implementation.

## Part 1:
- A thunk is a function that you can save and call later, so if you had an array of `TFunction<void()>`s, you would have an array of custom thunks that you can bind/unbind new function pointers to existing `TFunction`s.
- Custom thunks of Blueprints are the same, they're a fancy array/list of function pointers. Imagine for each node you placed to graph, Blueprints have a place for that node in it's list of custom thunks. For example the `+` node in Blueprints that sums two floats is `UKismetMathLibrary::AddAdd_Float` function, declared in `KismetMathLibrary.h`. 
- Engine associates and links `UKismetMathLibrary::AddAdd_Float` with `+` node automatically because its a `BlueprintCallable` function. BPVM knows whenever it needs to evaluate `+` node, it calls `UKismetMathLibrary::AddAdd_Float` function.
- Basically, BP compiler serializes an empty `UFunction*` pointer to bytecode, it tells BPVM which native function to call when we reach the `+` node to sum two floats.
- During loading, engine links the native functions to those `UFunction*` pointer, so when BPVM reaches `+`, the assigned `UKismetMathLibrary::AddAdd_Float` gets executed.

This file has been truncated. show original