STACKFRAME

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct ADDRESS
{
    public uint Offset;
    public ushort Segment;
    public int Mode;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct KDHELP
{
    public uint Thread;
    public uint ThCallbackStack;
    public uint NextCallback;
    public uint FramePointer;
    public uint KiCallUserMode;
    public uint KeUserCallbackDispatcher;
    public uint SystemRangeStart;
    public uint ThCallbackBStore;
    public uint KiUserExceptionDispatcher;
    public uint StackBase;
    public uint StackLimit;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] public uint[] Reserved;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct STACKFRAME
{
    public ADDRESS AddrPC;
    public ADDRESS AddrReturn;
    public ADDRESS AddrFrame;
    public ADDRESS AddrStack;
    public IntPtr FuncTableEntry;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public uint[] Params;
    [MarshalAs(UnmanagedType.Bool)] public bool Far;
    [MarshalAs(UnmanagedType.Bool)] public bool Virtual;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] public uint[] Reserved;
    public KDHELP KdHelp;
    public ADDRESS AddrBStore;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure ADDRESS
    Public Offset As UInteger
    Public Segment As UShort
    Public Mode As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure KDHELP
    Public Thread As UInteger
    Public ThCallbackStack As UInteger
    Public NextCallback As UInteger
    Public FramePointer As UInteger
    Public KiCallUserMode As UInteger
    Public KeUserCallbackDispatcher As UInteger
    Public SystemRangeStart As UInteger
    Public ThCallbackBStore As UInteger
    Public KiUserExceptionDispatcher As UInteger
    Public StackBase As UInteger
    Public StackLimit As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=5)> Public Reserved() As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure STACKFRAME
    Public AddrPC As ADDRESS
    Public AddrReturn As ADDRESS
    Public AddrFrame As ADDRESS
    Public AddrStack As ADDRESS
    Public FuncTableEntry As IntPtr
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=4)> Public Params() As UInteger
    <MarshalAs(UnmanagedType.Bool)> Public Far As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public Virtual As Boolean
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=3)> Public Reserved() As UInteger
    Public KdHelp As KDHELP
    Public AddrBStore As ADDRESS
End Structure

import ctypes
from ctypes import wintypes

class ADDRESS(ctypes.Structure):
    _fields_ = [
        ("Offset", wintypes.DWORD),
        ("Segment", ctypes.c_ushort),
        ("Mode", ctypes.c_int),
    ]

class KDHELP(ctypes.Structure):
    _fields_ = [
        ("Thread", wintypes.DWORD),
        ("ThCallbackStack", wintypes.DWORD),
        ("NextCallback", wintypes.DWORD),
        ("FramePointer", wintypes.DWORD),
        ("KiCallUserMode", wintypes.DWORD),
        ("KeUserCallbackDispatcher", wintypes.DWORD),
        ("SystemRangeStart", wintypes.DWORD),
        ("ThCallbackBStore", wintypes.DWORD),
        ("KiUserExceptionDispatcher", wintypes.DWORD),
        ("StackBase", wintypes.DWORD),
        ("StackLimit", wintypes.DWORD),
        ("Reserved", wintypes.DWORD * 5),
    ]

class STACKFRAME(ctypes.Structure):
    _fields_ = [
        ("AddrPC", ADDRESS),
        ("AddrReturn", ADDRESS),
        ("AddrFrame", ADDRESS),
        ("AddrStack", ADDRESS),
        ("FuncTableEntry", ctypes.c_void_p),
        ("Params", wintypes.DWORD * 4),
        ("Far", wintypes.BOOL),
        ("Virtual", wintypes.BOOL),
        ("Reserved", wintypes.DWORD * 3),
        ("KdHelp", KDHELP),
        ("AddrBStore", ADDRESS),
    ]

#[repr(C)]
pub struct ADDRESS {
    pub Offset: u32,
    pub Segment: u16,
    pub Mode: i32,
}

#[repr(C)]
pub struct KDHELP {
    pub Thread: u32,
    pub ThCallbackStack: u32,
    pub NextCallback: u32,
    pub FramePointer: u32,
    pub KiCallUserMode: u32,
    pub KeUserCallbackDispatcher: u32,
    pub SystemRangeStart: u32,
    pub ThCallbackBStore: u32,
    pub KiUserExceptionDispatcher: u32,
    pub StackBase: u32,
    pub StackLimit: u32,
    pub Reserved: [u32; 5],
}

#[repr(C)]
pub struct STACKFRAME {
    pub AddrPC: ADDRESS,
    pub AddrReturn: ADDRESS,
    pub AddrFrame: ADDRESS,
    pub AddrStack: ADDRESS,
    pub FuncTableEntry: *mut core::ffi::c_void,
    pub Params: [u32; 4],
    pub Far: i32,
    pub Virtual: i32,
    pub Reserved: [u32; 3],
    pub KdHelp: KDHELP,
    pub AddrBStore: ADDRESS,
}

import "golang.org/x/sys/windows"

type ADDRESS struct {
	Offset uint32
	Segment uint16
	Mode int32
}

type KDHELP struct {
	Thread uint32
	ThCallbackStack uint32
	NextCallback uint32
	FramePointer uint32
	KiCallUserMode uint32
	KeUserCallbackDispatcher uint32
	SystemRangeStart uint32
	ThCallbackBStore uint32
	KiUserExceptionDispatcher uint32
	StackBase uint32
	StackLimit uint32
	Reserved [5]uint32
}

type STACKFRAME struct {
	AddrPC ADDRESS
	AddrReturn ADDRESS
	AddrFrame ADDRESS
	AddrStack ADDRESS
	FuncTableEntry uintptr
	Params [4]uint32
	Far int32
	Virtual int32
	Reserved [3]uint32
	KdHelp KDHELP
	AddrBStore ADDRESS
}

type
  ADDRESS = record
    Offset: DWORD;
    Segment: Word;
    Mode: Integer;
  end;

  KDHELP = record
    Thread: DWORD;
    ThCallbackStack: DWORD;
    NextCallback: DWORD;
    FramePointer: DWORD;
    KiCallUserMode: DWORD;
    KeUserCallbackDispatcher: DWORD;
    SystemRangeStart: DWORD;
    ThCallbackBStore: DWORD;
    KiUserExceptionDispatcher: DWORD;
    StackBase: DWORD;
    StackLimit: DWORD;
    Reserved: array[0..4] of DWORD;
  end;

  STACKFRAME = record
    AddrPC: ADDRESS;
    AddrReturn: ADDRESS;
    AddrFrame: ADDRESS;
    AddrStack: ADDRESS;
    FuncTableEntry: Pointer;
    Params: array[0..3] of DWORD;
    Far: BOOL;
    Virtual: BOOL;
    Reserved: array[0..2] of DWORD;
    KdHelp: KDHELP;
    AddrBStore: ADDRESS;
  end;

const ADDRESS = extern struct {
    Offset: u32,
    Segment: u16,
    Mode: i32,
};

const KDHELP = extern struct {
    Thread: u32,
    ThCallbackStack: u32,
    NextCallback: u32,
    FramePointer: u32,
    KiCallUserMode: u32,
    KeUserCallbackDispatcher: u32,
    SystemRangeStart: u32,
    ThCallbackBStore: u32,
    KiUserExceptionDispatcher: u32,
    StackBase: u32,
    StackLimit: u32,
    Reserved: [5]u32,
};

const STACKFRAME = extern struct {
    AddrPC: ADDRESS,
    AddrReturn: ADDRESS,
    AddrFrame: ADDRESS,
    AddrStack: ADDRESS,
    FuncTableEntry: ?*anyopaque,
    Params: [4]u32,
    Far: i32,
    Virtual: i32,
    Reserved: [3]u32,
    KdHelp: KDHELP,
    AddrBStore: ADDRESS,
};

type
  ADDRESS {.bycopy.} = object
    Offset: uint32
    Segment: uint16
    Mode: int32

  KDHELP {.bycopy.} = object
    Thread: uint32
    ThCallbackStack: uint32
    NextCallback: uint32
    FramePointer: uint32
    KiCallUserMode: uint32
    KeUserCallbackDispatcher: uint32
    SystemRangeStart: uint32
    ThCallbackBStore: uint32
    KiUserExceptionDispatcher: uint32
    StackBase: uint32
    StackLimit: uint32
    Reserved: array[5, uint32]

  STACKFRAME {.bycopy.} = object
    AddrPC: ADDRESS
    AddrReturn: ADDRESS
    AddrFrame: ADDRESS
    AddrStack: ADDRESS
    FuncTableEntry: pointer
    Params: array[4, uint32]
    Far: int32
    Virtual: int32
    Reserved: array[3, uint32]
    KdHelp: KDHELP
    AddrBStore: ADDRESS

struct ADDRESS
{
    uint Offset;
    ushort Segment;
    int Mode;
}

struct KDHELP
{
    uint Thread;
    uint ThCallbackStack;
    uint NextCallback;
    uint FramePointer;
    uint KiCallUserMode;
    uint KeUserCallbackDispatcher;
    uint SystemRangeStart;
    uint ThCallbackBStore;
    uint KiUserExceptionDispatcher;
    uint StackBase;
    uint StackLimit;
    uint[5] Reserved;
}

struct STACKFRAME
{
    ADDRESS AddrPC;
    ADDRESS AddrReturn;
    ADDRESS AddrFrame;
    ADDRESS AddrStack;
    void* FuncTableEntry;
    uint[4] Params;
    int Far;
    int Virtual;
    uint[3] Reserved;
    KDHELP KdHelp;
    ADDRESS AddrBStore;
}