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