vm/layouts.hpp

   1 namespace factor
   2 {
   3
   4 typedef unsigned char u8;
   5 typedef unsigned short u16;
   6 typedef unsigned int u32;
   7 typedef unsigned long long u64;
   8 typedef signed char s8;
   9 typedef signed short s16;
  10 typedef signed int s32;
  11 typedef signed long long s64;
  12
  13 #ifdef _WIN64
  14         typedef long long fixnum;
  15         typedef unsigned long long cell;
  16 #else
  17         typedef long fixnum;
  18         typedef unsigned long cell;
  19 #endif
  20
  21 inline static cell align(cell a, cell b)
  22 {
  23         return (a + (b-1)) & ~(b-1);
  24 }
  25
  26 inline static cell align8(cell a)
  27 {
  28         return align(a,8);
  29 }
  30
  31 #define WORD_SIZE (signed)(sizeof(cell)*8)
  32
  33 #define TAG_MASK 7
  34 #define TAG_BITS 3
  35 #define TAG(x) ((cell)(x) & TAG_MASK)
  36 #define UNTAG(x) ((cell)(x) & ~TAG_MASK)
  37 #define RETAG(x,tag) (UNTAG(x) | (tag))
  38
  39 /*** Tags ***/
  40 #define FIXNUM_TYPE 0
  41 #define BIGNUM_TYPE 1
  42 #define ARRAY_TYPE 2
  43 #define FLOAT_TYPE 3
  44 #define QUOTATION_TYPE 4
  45 #define F_TYPE 5
  46 #define OBJECT_TYPE 6
  47 #define TUPLE_TYPE 7
  48
  49 /* Canonical F object */
  50 #define F F_TYPE
  51
  52 #define HEADER_TYPE 8 /* anything less than this is a tag */
  53
  54 #define GC_COLLECTED 5 /* can be anything other than FIXNUM_TYPE */
  55
  56 /*** Header types ***/
  57 #define WRAPPER_TYPE 8
  58 #define BYTE_ARRAY_TYPE 9
  59 #define CALLSTACK_TYPE 10
  60 #define STRING_TYPE 11
  61 #define WORD_TYPE 12
  62 #define DLL_TYPE 13
  63 #define ALIEN_TYPE 14
  64
  65 #define TYPE_COUNT 15
  66
  67 /* Not real types, but code_block's type can be set to this */
  68 #define PIC_TYPE 16
  69 #define FREE_BLOCK_TYPE 17
  70
  71 /* Constants used when floating-point trap exceptions are thrown */
  72 enum
  73 {
  74         FP_TRAP_INVALID_OPERATION = 1 << 0,
  75         FP_TRAP_OVERFLOW          = 1 << 1,
  76         FP_TRAP_UNDERFLOW         = 1 << 2,
  77         FP_TRAP_ZERO_DIVIDE       = 1 << 3,
  78         FP_TRAP_INEXACT           = 1 << 4,
  79 };
  80
  81 inline static bool immediate_p(cell obj)
  82 {
  83         return (obj == F || TAG(obj) == FIXNUM_TYPE);
  84 }
  85
  86 inline static fixnum untag_fixnum(cell tagged)
  87 {
  88 #ifdef FACTOR_DEBUG
  89         assert(TAG(tagged) == FIXNUM_TYPE);
  90 #endif
  91         return ((fixnum)tagged) >> TAG_BITS;
  92 }
  93
  94 inline static cell tag_fixnum(fixnum untagged)
  95 {
  96         return RETAG(untagged << TAG_BITS,FIXNUM_TYPE);
  97 }
  98
  99 inline static cell tag_for(cell type)
 100 {
 101         return type < HEADER_TYPE ? type : OBJECT_TYPE;
 102 }
 103
 104 struct object;
 105
 106 struct header {
 107         cell value;
 108
 109         /* Default ctor to make gcc 3.x happy */
 110         explicit header() { abort(); }
 111
 112         explicit header(cell value_) : value(value_ << TAG_BITS) {}
 113
 114         void check_header() {
 115 #ifdef FACTOR_DEBUG
 116                 assert(TAG(value) == FIXNUM_TYPE && untag_fixnum(value) < TYPE_COUNT);
 117 #endif
 118         }
 119
 120         cell hi_tag() {
 121                 check_header();
 122                 return value >> TAG_BITS;
 123         }
 124
 125         bool forwarding_pointer_p() {
 126                 return TAG(value) == GC_COLLECTED;
 127         }
 128
 129         object *forwarding_pointer() {
 130                 return (object *)UNTAG(value);
 131         }
 132
 133         void forward_to(object *pointer) {
 134                 value = RETAG(pointer,GC_COLLECTED);
 135         }
 136 };
 137
 138 #define NO_TYPE_CHECK static const cell type_number = TYPE_COUNT
 139
 140 struct object {
 141         NO_TYPE_CHECK;
 142         header h;
 143         cell *slots() { return (cell *)this; }
 144 };
 145
 146 /* Assembly code makes assumptions about the layout of this struct */
 147 struct array : public object {
 148         static const cell type_number = ARRAY_TYPE;
 149         static const cell element_size = sizeof(cell);
 150         /* tagged */
 151         cell capacity;
 152
 153         cell *data() { return (cell *)(this + 1); }
 154 };
 155
 156 /* These are really just arrays, but certain elements have special
 157 significance */
 158 struct tuple_layout : public array {
 159         NO_TYPE_CHECK;
 160         /* tagged */
 161         cell klass;
 162         /* tagged fixnum */
 163         cell size;
 164         /* tagged fixnum */
 165         cell echelon;
 166 };
 167
 168 struct bignum : public object {
 169         static const cell type_number = BIGNUM_TYPE;
 170         static const cell element_size = sizeof(cell);
 171         /* tagged */
 172         cell capacity;
 173
 174         cell *data() { return (cell *)(this + 1); }
 175 };
 176
 177 struct byte_array : public object {
 178         static const cell type_number = BYTE_ARRAY_TYPE;
 179         static const cell element_size = 1;
 180         /* tagged */
 181         cell capacity;
 182
 183         template<typename Scalar> Scalar *data() { return (Scalar *)(this + 1); }
 184 };
 185
 186 /* Assembly code makes assumptions about the layout of this struct */
 187 struct string : public object {
 188         static const cell type_number = STRING_TYPE;
 189         /* tagged num of chars */
 190         cell length;
 191         /* tagged */
 192         cell aux;
 193         /* tagged */
 194         cell hashcode;
 195
 196         u8 *data() { return (u8 *)(this + 1); }
 197 };
 198
 199 /* The compiled code heap is structured into blocks. */
 200 struct heap_block
 201 {
 202         cell header;
 203
 204         cell type() { return (header >> 1) & 0x1f; }
 205         void set_type(cell type)
 206         {
 207                 header = ((header & ~(0x1f << 1)) | (type << 1));
 208         }
 209
 210         cell size() { return (header >> 6); }
 211         void set_size(cell size)
 212         {
 213                 header = (header & 0x2f) | (size << 6);
 214         }
 215 };
 216
 217 struct free_heap_block : public heap_block
 218 {
 219         free_heap_block *next_free;
 220 };
 221
 222 struct code_block : public heap_block
 223 {
 224         cell owner; /* tagged pointer to word, quotation or f */
 225         cell literals; /* tagged pointer to array or f */
 226         cell relocation; /* tagged pointer to byte-array or f */
 227
 228         void *xt() { return (void *)(this + 1); }
 229 };
 230
 231 /* Assembly code makes assumptions about the layout of this struct */
 232 struct word : public object {
 233         static const cell type_number = WORD_TYPE;
 234         /* TAGGED hashcode */
 235         cell hashcode;
 236         /* TAGGED word name */
 237         cell name;
 238         /* TAGGED word vocabulary */
 239         cell vocabulary;
 240         /* TAGGED definition */
 241         cell def;
 242         /* TAGGED property assoc for library code */
 243         cell props;
 244         /* TAGGED alternative entry point for direct non-tail calls. Used for inline caching */
 245         cell pic_def;
 246         /* TAGGED alternative entry point for direct tail calls. Used for inline caching */
 247         cell pic_tail_def;
 248         /* TAGGED call count for profiling */
 249         cell counter;
 250         /* TAGGED machine code for sub-primitive */
 251         cell subprimitive;
 252         /* UNTAGGED execution token: jump here to execute word */
 253         void *xt;
 254         /* UNTAGGED compiled code block */
 255         code_block *code;
 256         /* UNTAGGED profiler stub */
 257         code_block *profiling;
 258 };
 259
 260 /* Assembly code makes assumptions about the layout of this struct */
 261 struct wrapper : public object {
 262         static const cell type_number = WRAPPER_TYPE;
 263         cell object;
 264 };
 265
 266 /* Assembly code makes assumptions about the layout of this struct */
 267 struct boxed_float : object {
 268         static const cell type_number = FLOAT_TYPE;
 269
 270 #ifndef FACTOR_64
 271         cell padding;
 272 #endif
 273
 274         double n;
 275 };
 276
 277 /* Assembly code makes assumptions about the layout of this struct */
 278 struct quotation : public object {
 279         static const cell type_number = QUOTATION_TYPE;
 280         /* tagged */
 281         cell array;
 282         /* tagged */
 283         cell cached_effect;
 284         /* tagged */
 285         cell cache_counter;
 286         /* UNTAGGED */
 287         void *xt;
 288         /* UNTAGGED compiled code block */
 289         code_block *code;
 290 };
 291
 292 /* Assembly code makes assumptions about the layout of this struct */
 293 struct alien : public object {
 294         static const cell type_number = ALIEN_TYPE;
 295         /* tagged */
 296         cell base;
 297         /* tagged */
 298         cell expired;
 299         /* untagged */
 300         cell displacement;
 301 };
 302
 303 struct dll : public object {
 304         static const cell type_number = DLL_TYPE;
 305         /* tagged byte array holding a C string */
 306         cell path;
 307         /* OS-specific handle */
 308         void *dll;
 309 };
 310
 311 struct stack_frame
 312 {
 313         void *xt;
 314         /* Frame size in bytes */
 315         cell size;
 316 };
 317
 318 struct callstack : public object {
 319         static const cell type_number = CALLSTACK_TYPE;
 320         /* tagged */
 321         cell length;
 322
 323         stack_frame *frame_at(cell offset)
 324         {
 325                 return (stack_frame *)((char *)(this + 1) + offset);
 326         }
 327
 328         stack_frame *top() { return (stack_frame *)(this + 1); }
 329         stack_frame *bottom() { return (stack_frame *)((cell)(this + 1) + untag_fixnum(length)); }
 330 };
 331
 332 struct tuple : public object {
 333         static const cell type_number = TUPLE_TYPE;
 334         /* tagged layout */
 335         cell layout;
 336
 337         cell *data() { return (cell *)(this + 1); }
 338 };
 339
 340 }