 { code-heap-before mark-sweep-sizes }
 { data-heap-after data-heap-room }
 { code-heap-after mark-sweep-sizes }
-{ cards-scanned cell }
-{ decks-scanned cell }
-{ code-blocks-scanned cell }
+{ cards-scanned cell_t }
+{ decks-scanned cell_t }
+{ code-blocks-scanned cell_t }
 { start-time ulonglong }
-{ total-time cell }
-{ card-scan-time cell }
-{ code-scan-time cell }
-{ data-sweep-time cell }
-{ code-sweep-time cell }
-{ compaction-time cell }
+{ total-time cell_t }
+{ card-scan-time cell_t }
+{ code-scan-time cell_t }
+{ data-sweep-time cell_t }
+{ code-sweep-time cell_t }
+{ compaction-time cell_t }
 { temp-time ulonglong } ;
 
 STRUCT: dispatch-statistics
-{ megamorphic-cache-hits cell }
-{ megamorphic-cache-misses cell }
+{ megamorphic-cache-hits cell_t }
+{ megamorphic-cache-misses cell_t }
 
-{ cold-call-to-ic-transitions cell }
-{ ic-to-pic-transitions cell }
-{ pic-to-mega-transitions cell }
+{ cold-call-to-ic-transitions cell_t }
+{ ic-to-pic-transitions cell_t }
+{ pic-to-mega-transitions cell_t }
 
-{ pic-tag-count cell }
-{ pic-tuple-count cell } ;
+{ pic-tag-count cell_t }
+{ pic-tuple-count cell_t } ;
 
 ! gc-info should be kept in sync with:
 !   vm/gc_info.hpp

CONSTANT: collect-growing-heap-op 5

STRUCT: copying-sizes
{ size cell }
{ occupied cell }
{ free cell } ;

STRUCT: mark-sweep-sizes
{ size cell }
{ occupied cell }
{ total-free cell }
{ contiguous-free cell }
{ free-block-count cell } ;

STRUCT: data-heap-room
{ nursery copying-sizes }
{ aging copying-sizes }
{ tenured mark-sweep-sizes }
{ cards cell }
{ decks cell }
{ mark-stack cell } ;

STRUCT: gc-event
{ op uint }

USING: classes.struct alien.c-types alien.syntax kernel.private ;
IN: vm

TYPEDEF: uintptr_t cell_t

STRUCT: context
{ callstack-top void* }
{ callstack-bottom void* }
{ datastack cell_t }
{ retainstack cell_t }
{ callstack-save cell_t }
{ datastack-region void* }
{ retainstack-region void* }
{ callstack-region void* }
{ context-objects cell_t[context-object-count] } ;

: context-field-offset ( field -- offset ) context offset-of ; inline

STRUCT: zone
{ here cell_t }
{ start cell_t }
{ end cell_t }
{ size cell_t } ;

STRUCT: vm
{ ctx context* }
{ spare-ctx context* }
{ nursery zone }
{ cards-offset cell_t }
{ decks-offset cell_t }
{ signal-handler-addr cell_t }
{ faulting? cell_t }
{ special-objects cell_t[special-object-count] } ;

: vm-field-offset ( field -- offset ) vm offset-of ; inline

