Atom {.union.} = object
  ptrVal*: pointer           ## akPtr
  strVal*: VmString          ## akString
  seqVal*: VmSeq             ## akSeq
  refVal*: HeapSlotHandle    ## akRef
  callableVal*: VmFunctionPtr ## akCallable
  nodeVal*: PNode            ## akPNode
  

AtomKind = enum
  akInt, akFloat, akPtr, akSet, akString, akSeq, akRef, akCallable,
  akDiscriminator, akPNode, akObject, akArray

BranchListEntry = object
  case kind*: BranchListEntryKind
  of blekStart:
      field*: FieldIndex     ## The index of the corresponding discriminator
      numItems*: uint32 ## The number of items following this entry that are
                        ## part of this record-case. Used for the fast skipping
                        ## of inactive branches
      defaultBranch*: uint16 ## The index of the default branch
      numBranches*: uint16   ## The number of branches this record-case has.
                             ## Does not include branches of sub record-cases
    
  of blekBranch, blekEnd:
      fieldRange*: Slice[FieldIndex] ## 
                                     ## For 'branch' entries, the range of field indices the branch spans.
                                     ## For `end` entries, the range of fields past the corresponding
                                     ## record-case that are still part of the surrounding branch.
                                     ## 
                                     ## In both cases, the slice may be empty, with `fieldRange.a` always
                                     ## being >= the previous entry's `fieldRange.a`.
                                     ## For the dedicated 'end' entry, `fieldRange.b` is always 0
    
  

BranchListEntryKind = enum
  blekStart, blekBranch, blekEnd

CallableKind = enum
  ckDefault,                ## A normal function
  ckCallback                 ## A VmCallback

CellId = int

CellPtr = distinct ptr UncheckedArray[byte]

CodeGenFlag = enum
  cgfAllowMeta ## If not present, type or other meta expressions are
               ## disallowed in imperative contexts and code-gen for meta
               ## function arguments (e.g. `typedesc`) is suppressed

CodeInfo = tuple[start: int, ## The position where the bytecode starts
                 regCount: int]

ConstantId = int

ConstantKind = enum
  cnstInt, cnstFloat, cnstNode, ## AST, type literals
  cnstSliceListInt, cnstSliceListFloat

EhInstr = tuple[opcode: EhOpcode, a: uint16, ## meaning depends on the opcode
                b: uint32]

EhOpcode = enum
  ehoExcept,                ## unconditional exception handler
  ehoExceptWithFilter, ## conditionl exception handler. If the exception is a subtype or equal
                        ## to the specified type, the handler is entered
  ehoFinally,               ## enter the ``finally`` handler
  ehoNext,                  ## relative jump to another instruction
  ehoEnd                     ## ends the thread without treating the exception as handled

ExceptionState = object
  stack*: seq[VmException]   ## previously caught but not yet full handled exceptions
  current*: HeapSlotHandle   ## the current exception, which is what ``getCurrentException`` returns
  

FieldIndex = distinct uint32

FieldPosition = distinct uint32

FuncTableEntry = object
  sym*: PSym
  retValDesc*: PVmType       ## the return value type (may be empty)
  isClosure*: bool           ## whether the closure calling convention is used
  sig*: RoutineSigId
  case kind*: CallableKind
  of ckDefault:
      regCount*: uint16
      start*: int            ## the code position where the function starts
    
  of ckCallback:
      cbOffset*: int         ## the index into the callback list
    
  

FunctionIndex = distinct int

HandlerTableEntry = tuple[offset: uint32, ## instruction offset
                          instr: uint32]

HeapSlot = object
  handle*: LocHandle
  refCount*: int

HeapSlotHandle = int

LinkIndex = uint32

LocHandle = object
  cell*: CellId              ## the ID of the cell that owns the location
  p*: VmMemPointer           ## the memory address of the reference location, in host address space
  typ* {.cursor.}: PVmType   ## the type that the handles views the location as
  

NumericConvKind = enum
  nckFToI, nckFToU, nckIToF, nckUToF, nckFToF, ## float-to-float
  nckToB                     ## float or int to bool

PrgCtr = int

ProfileInfo = object
  time*: float               ## the time spent on executing instructions (inclusive)
  count*: int                ## the number of instructions executed (exclusive)
  

Profiler = object
  enabled*: bool             ## whether profiling is enabled
  tEnter*: float             ## the point-in-time when the active measurment started
  data*: Table[PSym, ProfileInfo] ## maps the symbol of a procedure to the associated data gathered by the
                                  ## profiler
  

PVmType = ref VmType

RoutineSig = distinct PType

RoutineSigId = distinct int

StackFrameIndex = int

TCtx = object
  code*: seq[TInstr]
  debug*: seq[TLineInfo]
  ehTable*: seq[HandlerTableEntry] ## stores the instruction-to-EH mappings. Used to look up the EH
                                   ## instruction to start exception handling with in case of a normal
                                   ## instruction raising
  ehCode*: seq[EhInstr]      ## stores the instructions for the exception handling (EH) mechanism
  globals*: seq[LocHandle]   ## global slots
  constants*: seq[VmConstant] ## constant data
  complexConsts*: seq[LocHandle] ## complex constants (i.e. everything that
                                 ## is not a int/float/string literal)
  typeInfoCache*: TypeInfoCache ## manages the types used by the VM
  rtti*: seq[VmTypeInfo]     ## run-time-type-information as needed by
                             ## conversion and `repr`
  functions*: seq[FuncTableEntry] ## the function table. Contains an entry
                                  ## for each procedure known to the VM. Indexed by `FunctionIndex`
  memory*: VmMemoryManager
  flags*: set[CodeGenFlag]   ## flags that alter the behaviour of the code
                             ## generator. Initialized by the VM's callsite and queried by the JIT.
  callbackKeys*: Patterns
  module*: PSym
  callsite*: PNode
  mode*: TEvalMode
  features*: TSandboxFlags
  traceActive*: bool
  comesFromHeuristic*: TLineInfo
  callbacks*: seq[VmCallback]
  cache*: IdentCache
  config*: ConfigRef
  graph*: ModuleGraph
  idgen*: IdGenerator
  profiler*: Profiler
  templInstCounter*: ref int
  vmstateDiff*: seq[(PSym, PNode)]
  vmTraceHandler*: TraceHandler ## handle trace output from an executing vm
  

TEvalMode = enum
  emRepl,                   ## evaluate because in REPL mode
  emConst,                  ## evaluate for 'const' according to spec
  emOptimize,               ## evaluate for optimization purposes (same as
                             ## emConst?)
  emStaticExpr,             ## evaluate for enforced compile time eval
                             ## ('static' context)
  emStaticStmt,             ## 'static' as an expression
  emStandalone               ## standalone execution separate from
                             ## code-generation

TFullReg = object
  case kind*: TRegisterKind
  of rkNone:
    nil
  of rkInt:
    intVal*: BiggestInt
  of rkFloat:
    floatVal*: BiggestFloat
  of rkAddress:
      addrVal*: pointer
      addrTyp*: PVmType

  of rkLocation, rkHandle:
      handle*: LocHandle

  of rkNimNode:
      nimNode*: PNode

  

TInstr = distinct TInstrType

TInstrType = uint64

TraceHandler = proc (c: TCtx; t: VmExecTrace): void

TRegister = range[0 .. 65535'u64.int]

TSandboxFlag = enum
  allowCast,                ## allow unsafe language feature: 'cast'
  allowInfiniteLoops         ## allow endless loops

TSandboxFlags = set[TSandboxFlag]

TStackFrame = object
  prc*: PSym
  start*: int ## position in the thread's register sequence where the registers for
              ## the frame start
  eh*: HOslice[int]          ## points to the active list of instruction-to-EH mappings
  baseOffset*: PrgCtr ## the instruction that all offsets in the instruction-to-EH list are
                      ## relative to. Only valid when `eh` is not empty
  comesFrom*: int

TypeInfoCache = object
  lut*: Table[ItemId, PVmType] ## `PType`-id -> `PVmType` mappings
  structs*: TypeTable        ## All structural types created by ``vmtypegen``
  signatures*: Table[RoutineSig, RoutineSigId]
  nextSigId*: RoutineSigId   ## The ID to use for a new `signatures` entry
  types*: seq[PVmType]       ## all generated types (including those created
                             ## during VM setup)
  staticInfo*: array[AtomKind, tuple[size, align: uint8]] ## size and alignment information for atoms where this information is
                                                          ## the same for every instance
  boolType*: PVmType
  charType*: PVmType
  stringType*: PVmType
  pointerType*: PVmType
  nodeType*: PVmType
  emptyType*: PVmType
  intTypes*: array[tyInt .. tyInt64, PVmType]
  uintTypes*: array[tyUInt .. tyUInt64, PVmType]
  floatTypes*: array[tyFloat .. tyFloat64, PVmType]
  rootRef*: PVmType          ## the VM type corresponding to ``ref RootObj``.
  

TypeTable = object
  data*: seq[TypeTableEntry]
  counter*: int

TypeTableEntry = tuple[hcode: int, typ: VmTypeId]

VmAllocator = object
  cells*: seq[VmCell] ## the underlying storage for the cell slots. Both stack and
                      ## (non-refcounted) heap slots are included here
  freeHead*, freeTail*: int
  byteType*: PVmType         ## The VM type for `byte`
  

VmArgs = object
  ra*, rb*, rc*: Natural
  slots*: ptr UncheckedArray[TFullReg]
  exState*: ptr ExceptionState
  currentLineInfo*: TLineInfo
  typeCache*: ptr TypeInfoCache
  mem*: ptr VmMemoryManager
  heap*: ptr VmHeap
  graph*: ModuleGraph
  config*: ConfigRef
  currentModule*: PSym       ## module currently being compiled
  cache*: IdentCache
  idgen*: IdGenerator

VmCallback = proc (args: VmArgs) {.closure.}

VmCell = object
  count*: int ## stores the number of locations for cells that are in-use; for free
              ## cells this is the next pointer
  sizeInBytes*: int          ## the total number of *guest-accesible* bytes the cell occupies
  p*: ptr UncheckedArray[byte]
  typ* {.cursor.}: PVmType

VmConstant = object
  case kind*: ConstantKind
  of cnstInt:
      intVal*: BiggestInt

  of cnstFloat:
      floatVal*: BiggestFloat

  of cnstNode:
      node*: PNode

  of cnstSliceListInt:
      intSlices*: seq[Slice[BiggestInt]]

  of cnstSliceListFloat:
      floatSlices*: seq[Slice[BiggestFloat]]

  

VmEvent = object
  instLoc*: InstantiationInfo ## instantiation in VM's source
  case kind*: VmEventKind
  of vmEvtUserError:
      errLoc*: TLineInfo
      errMsg*: string

  of vmEvtArgNodeNotASymbol:
      callName*: string
      argAst*: PNode
      argPos*: int

  of vmEvtCannotCast, vmEvtIllegalConvFromXToY:
      typeMismatch*: VmTypeMismatch

  of vmEvtIndexError:
      indexSpec*: tuple[usedIdx, minIdx, maxIdx: Int128]

  of vmEvtErrInternal, vmEvtNilAccess, vmEvtIllegalConv, vmEvtFieldUnavailable,
     vmEvtFieldNotFound, vmEvtCacheKeyAlreadyExists, vmEvtMissingCacheKey,
     vmEvtCannotCreateNode:
      msg*: string

  of vmEvtCannotSetChild, vmEvtCannotAddChild, vmEvtCannotGetChild, vmEvtNoType,
     vmEvtNodeNotASymbol:
      ast*: PNode

  of vmEvtUnhandledException:
      exc*: PNode
      trace*: VmRawStackTrace

  of vmEvtNotAField:
      sym*: PSym

  else:
      nil

  

VmEventKind = enum
  vmEvtOpcParseExpectedExpression, vmEvtUserError, vmEvtUnhandledException,
  vmEvtCannotCast, vmEvtCannotModifyTypechecked, vmEvtNilAccess,
  vmEvtAccessOutOfBounds, vmEvtAccessTypeMismatch, vmEvtAccessNoLocation,
  vmEvtErrInternal, vmEvtIndexError, vmEvtOutOfRange, vmEvtOverOrUnderflow,
  vmEvtDivisionByConstZero, vmEvtArgNodeNotASymbol, vmEvtNodeNotASymbol,
  vmEvtNodeNotAProcSymbol, vmEvtIllegalConv, vmEvtIllegalConvFromXToY,
  vmEvtMissingCacheKey, vmEvtCacheKeyAlreadyExists, vmEvtFieldNotFound,
  vmEvtNotAField, vmEvtFieldUnavailable, vmEvtCannotCreateNode,
  vmEvtCannotSetChild, vmEvtCannotAddChild, vmEvtCannotGetChild, vmEvtNoType,
  vmEvtTooManyIterations

VmEventKindAccessError = range[vmEvtAccessOutOfBounds .. vmEvtAccessNoLocation]

VmException = object
  refVal*: HeapSlotHandle
  trace*: VmRawStackTrace
  caught*: bool              ## whether the exception was already caught
  

VmExecTrace = object
  pc*: PrgCtr
  case kind*: VmExecTraceKind
  of vmTraceMin:
      nil

  of vmTraceFull:
      ra*, rb*, rc*: TRegisterKind

  

VmExecTraceKind = enum
  vmTraceMin,               ## minimal data execution trace, lighter/faster
  vmTraceFull                ## full data execution trace, more info/heavier likely slower

VmFunctionPtr = distinct int

VmGenDiag = object
  location*: TLineInfo       ## diagnostic location
  instLoc*: InstantiationInfo ## instantiation in VM Gen's source
  case kind*: VmGenDiagKind
  of vmGenDiagCannotImportc, vmGenDiagTooLargeOffset, vmGenDiagCannotCallMethod:
      sym*: PSym

  of vmGenDiagCannotCast:
      typeMismatch*: VmTypeMismatch

  of vmGenDiagMissingImportcCompleteStruct, vmGenDiagCodeGenUnhandledMagic:
      magic*: TMagic

  of vmGenDiagNotUnused, vmGenDiagCannotEvaluateAtComptime:
      ast*: PNode

  of vmGenDiagTooManyRegistersRequired:
      nil

  

VmGenDiagKind = enum
  vmGenDiagTooManyRegistersRequired, vmGenDiagNotUnused,
  vmGenDiagCannotEvaluateAtComptime, vmGenDiagMissingImportcCompleteStruct,
  vmGenDiagCodeGenUnhandledMagic, vmGenDiagCannotImportc,
  vmGenDiagTooLargeOffset, vmGenDiagCannotCallMethod, vmGenDiagCannotCast

VmGenDiagKindAstRelated = range[vmGenDiagNotUnused ..
    vmGenDiagCannotEvaluateAtComptime]

VmGenDiagKindMagicRelated = range[vmGenDiagMissingImportcCompleteStruct ..
    vmGenDiagCodeGenUnhandledMagic]

VmGenDiagKindSymRelated = range[vmGenDiagCannotImportc ..
    vmGenDiagCannotCallMethod]

VmHeap = object
  slots*: seq[HeapSlot]
  pending*: seq[int]         ## the indices of the slots that are pending clean-up
  

VmMemoryManager = object
  allocator*: VmAllocator
  heap*: VmHeap

VmMemoryRegion = openArray[byte]

VmMemPointer = distinct ptr UncheckedArray[byte]

VmRawStackTrace = seq[tuple[sym: PSym, pc: PrgCtr]]

VmSeq = object
  length*: int
  data*: CellPtr

VmSlice = object
  cell*: CellId              ## the cell of which the locations are part of
  start*: VmMemPointer       ## start of the slice (or ``nil``)
  len*: int                  ## the number of items
  typ* {.cursor.}: PVmType   ## the item type
  

VmStackTrace = object
  currentExceptionA*, currentExceptionB*: PNode
  stacktrace*: seq[tuple[sym: PSym, location: TLineInfo]]
  skipped*: int

VmString = distinct VmSeq

VmType = object
  case kind*: AtomKind
  of akInt, akFloat, akPNode:
    nil
  of akPtr, akRef:
      targetType*: PVmType

  of akSet:
      setLength*: int        ## The number of elements in the set
    
  of akSeq, akString:
      seqElemStride*: int
      seqElemType*: PVmType

  of akCallable:
      routineSig*: RoutineSigId

  of akDiscriminator:
      numBits*: int          ## The amount of bits the discriminator value occupies
    
  of akObject:
      relFieldStart*: uint32 ## Encodes both the position (`PSym.position`) of
                             ## the first field as well as whether the object
                             ## has a base. If > 0, the object has a base.
                             ## Subtracting 1 one from a `> 0` value yields the
                             ## position
      objFields*: seq[tuple[offset: int, typ: PVmType]]
      branches*: seq[BranchListEntry] ## Empty if the object is no variant
    
  of akArray:
      elementCount*: int
      elementStride*: int
      elementType*: PVmType

  sizeInBytes*: uint
  alignment*: uint8          ## 1 shl `alignment` == real alignment value
  

VmTypeId = uint32

VmTypeInfo = object
  internal*: PVmType         ## the `VmType` the type maps to
  nimType*: PType

VmTypeMismatch = object
  actualType*, formalType*: PType

byteExcess = 128

nimNodeFlag = 16

noneType: PVmType = nil

pseudoAtomKinds = {akObject, akArray}

realAtomKinds = {akInt..akPNode}

regAMask = 65535'u64

regAShift = 8'u64

regBMask = 65535'u64

regBShift = 24'u64

regBxMask = 16777215'u64

regBxMax = 8388607

regBxMin = -8388607

regBxShift = 24'u64

regCMask = 65535'u64

regCShift = 40'u64

regOMask = 255'u64

regOShift = 0'u64

wordExcess = 8388608

func `$`(x: ptr UncheckedArray[byte]): string {....raises: [], tags: [].}

func `$`(x: PVmType): string {....raises: [], tags: [].}

func `<=`(a, b: FieldIndex): bool {.borrow, ...raises: [], tags: [].}

func `<`(a, b: FieldIndex): bool {.borrow, ...raises: [], tags: [].}

func `==`(a, b: FieldIndex): bool {.borrow, ...raises: [], tags: [].}

func `==`(a, b: FunctionIndex): bool {.borrow, ...raises: [], tags: [].}

func `==`(a, b: RoutineSigId): bool {.borrow, ...raises: [], tags: [].}

func applyOffset(p: VmMemPointer | CellPtr; offset: uint): VmMemPointer {.inline.}

func data(s: VmString): CellPtr {.inline, ...raises: [], tags: [].}

proc init(cache: var TypeInfoCache) {....raises: [], tags: [].}

proc initCtx(module: PSym; cache: IdentCache; g: ModuleGraph;
             idgen: IdGenerator; tracer: TraceHandler = defaultTracer): TCtx {.
    ...raises: [], tags: [].}

func len(s: VmString): int {.inline, ...raises: [], tags: [].}

func newVmString(data: CellPtr; len: Natural): VmString {.inline, ...raises: [],
    tags: [].}

func overlap(a, b: int; aLen, bLen: Natural): bool {....raises: [], tags: [].}

func overlap(a, b: pointer; aLen, bLen: Natural): bool {....raises: [], tags: [].}

func packedConvDesc(op: NumericConvKind; dstbytes, srcbytes: range[1 .. 8]): uint16 {.
    ...raises: [], tags: [].}

func refresh(c: var TCtx; module: PSym; idgen: IdGenerator) {....raises: [],
    tags: [].}

func safeCopyMem(dest: var openArray[byte | char]; src: openArray[byte | char];
                 numBytes: Natural) {.inline.}

func safeCopyMemSrc(dest: var openArray[byte]; src: openArray[byte]) {.inline,
    ...raises: [], tags: [].}

func safeZeroMem(dest: var openArray[byte]; numBytes: Natural) {....raises: [],
    tags: [].}

func toFuncIndex(x: VmFunctionPtr): FunctionIndex {....raises: [], tags: [].}

func toFuncPtr(x: FunctionIndex): VmFunctionPtr {....raises: [], tags: [].}

func unpackedConvDesc(info: uint16): tuple[op: NumericConvKind,
    dstbytes, srcbytes: int] {....raises: [], tags: [].}

template `-`(a: FieldIndex; b: int): FieldIndex

template allocator(c: TCtx): untyped

template byteView(x: ptr UncheckedArray[byte]; t: PVmType; num: int): untyped

template byteView(x: VmMemPointer | CellPtr; t: PVmType; num: int): untyped

template currentException(a: VmArgs): HeapSlotHandle

template currentException=(a: VmArgs; h: HeapSlotHandle)

template fieldAt(x: PVmType; i: FieldIndex): untyped

template fieldAt(x: VmType; i: FieldIndex): untyped

template fpos(x: int): FieldPosition

template heap(c: TCtx): untyped

template isNil(h: HeapSlotHandle): bool

template isNil(p: VmMemPointer | CellPtr): bool

template isNil(x: VmFunctionPtr): bool

template isNotNil(h: HeapSlotHandle): bool

template isValid(handle: LocHandle): bool

template isValid(t: PVmType): bool

template jmpDiff(x: TInstr): int

template opcode(x: TInstr): TOpcode

template rawPointer(h: LocHandle): untyped

template rawPointer(p: VmMemPointer | CellPtr): untyped

template regA(x: TInstr): TRegister

template regB(x: TInstr): TRegister

template regBx(x: TInstr): int

template regC(x: TInstr): TRegister

template subView[T](x: openArray[T]; off): untyped

template subView[T](x: openArray[T]; off, len): untyped

template types(c: TCtx): untyped