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 #ifdef FACTOR_DEBUG
 119                 assert(TAG(value) == FIXNUM_TYPE && untag_fixnum(value) < TYPE_COUNT);
 120 #endif
 121         }
 122
 123         cell hi_tag() {
 124                 check_header();
 125                 return value >> TAG_BITS;
 126         }
 127
 128         bool forwarding_pointer_p() {
 129                 return TAG(value) == GC_COLLECTED;
 130         }
 131
 132         object *forwarding_pointer() {
 133                 return (object *)UNTAG(value);
 134         }
 135
 136         void forward_to(object *pointer) {
 137                 value = RETAG(pointer,GC_COLLECTED);
 138         }
 139 };
 140
 141 #define NO_TYPE_CHECK static const cell type_number = TYPE_COUNT
 142
 143 struct object {
 144         NO_TYPE_CHECK;
 145         header h;
 146         cell *slots() { return (cell *)this; }
 147 };
 148
 149 /* Assembly code makes assumptions about the layout of this struct */
 150 struct array : public object {
 151         static const cell type_number = ARRAY_TYPE;
 152         static const cell element_size = sizeof(cell);
 153         /* tagged */
 154         cell capacity;
 155
 156         cell *data() { return (cell *)(this + 1); }
 157 };
 158
 159 /* These are really just arrays, but certain elements have special
 160 significance */
 161 struct tuple_layout : public array {
 162         NO_TYPE_CHECK;
 163         /* tagged */
 164         cell klass;
 165         /* tagged fixnum */
 166         cell size;
 167         /* tagged fixnum */
 168         cell echelon;
 169 };
 170
 171 struct bignum : public object {
 172         static const cell type_number = BIGNUM_TYPE;
 173         static const cell element_size = sizeof(cell);
 174         /* tagged */
 175         cell capacity;
 176
 177         cell *data() { return (cell *)(this + 1); }
 178 };
 179
 180 struct byte_array : public object {
 181         static const cell type_number = BYTE_ARRAY_TYPE;
 182         static const cell element_size = 1;
 183         /* tagged */
 184         cell capacity;
 185
 186 #ifndef FACTOR_64
 187         cell padding0;
 188         cell padding1;
 189 #endif
 190
 191         template<typename Scalar> Scalar *data() { return (Scalar *)(this + 1); }
 192 };
 193
 194 /* Assembly code makes assumptions about the layout of this struct */
 195 struct string : public object {
 196         static const cell type_number = STRING_TYPE;
 197         /* tagged num of chars */
 198         cell length;
 199         /* tagged */
 200         cell aux;
 201         /* tagged */
 202         cell hashcode;
 203
 204         u8 *data() { return (u8 *)(this + 1); }
 205 };
 206
 207 /* The compiled code heap is structured into blocks. */
 208 struct heap_block
 209 {
 210         cell header;
 211
 212         bool free_p()
 213         {
 214                 return header & 1 == 1;
 215         }
 216
 217         void set_free()
 218         {
 219                 header |= 1;
 220         }
 221
 222         void clear_free()
 223         {
 224                 header &= ~1;
 225         }
 226
 227         cell size()
 228         {
 229                 return header >> 3;
 230         }
 231
 232         void set_size(cell size)
 233         {
 234                 header = (header & 0x7) | (size << 3);
 235         }
 236 };
 237
 238 struct free_heap_block : public heap_block
 239 {
 240         free_heap_block *next_free;
 241 };
 242
 243 struct code_block : public heap_block
 244 {
 245         cell owner; /* tagged pointer to word, quotation or f */
 246         cell literals; /* tagged pointer to array or f */
 247         cell relocation; /* tagged pointer to byte-array or f */
 248
 249         void *xt()
 250         {
 251                 return (void *)(this + 1);
 252         }
 253
 254         code_block_type type()
 255         {
 256                 return (code_block_type)((header >> 1) & 0x3);
 257         }
 258
 259         void set_type(code_block_type type)
 260         {
 261                 header = ((header & ~0x7) | (type << 1));
 262         }
 263
 264         bool pic_p()
 265         {
 266                 return type() == code_block_pic;
 267         }
 268
 269         bool optimized_p()
 270         {
 271                 return type() == code_block_optimized;
 272         }
 273 };
 274
 275 /* Assembly code makes assumptions about the layout of this struct */
 276 struct word : public object {
 277         static const cell type_number = WORD_TYPE;
 278         /* TAGGED hashcode */
 279         cell hashcode;
 280         /* TAGGED word name */
 281         cell name;
 282         /* TAGGED word vocabulary */
 283         cell vocabulary;
 284         /* TAGGED definition */
 285         cell def;
 286         /* TAGGED property assoc for library code */
 287         cell props;
 288         /* TAGGED alternative entry point for direct non-tail calls. Used for inline caching */
 289         cell pic_def;
 290         /* TAGGED alternative entry point for direct tail calls. Used for inline caching */
 291         cell pic_tail_def;
 292         /* TAGGED call count for profiling */
 293         cell counter;
 294         /* TAGGED machine code for sub-primitive */
 295         cell subprimitive;
 296         /* UNTAGGED execution token: jump here to execute word */
 297         void *xt;
 298         /* UNTAGGED compiled code block */
 299         code_block *code;
 300         /* UNTAGGED profiler stub */
 301         code_block *profiling;
 302 };
 303
 304 /* Assembly code makes assumptions about the layout of this struct */
 305 struct wrapper : public object {
 306         static const cell type_number = WRAPPER_TYPE;
 307         cell object;
 308 };
 309
 310 /* Assembly code makes assumptions about the layout of this struct */
 311 struct boxed_float : object {
 312         static const cell type_number = FLOAT_TYPE;
 313
 314 #ifndef FACTOR_64
 315         cell padding;
 316 #endif
 317
 318         double n;
 319 };
 320
 321 /* Assembly code makes assumptions about the layout of this struct */
 322 struct quotation : public object {
 323         static const cell type_number = QUOTATION_TYPE;
 324         /* tagged */
 325         cell array;
 326         /* tagged */
 327         cell cached_effect;
 328         /* tagged */
 329         cell cache_counter;
 330         /* UNTAGGED */
 331         void *xt;
 332         /* UNTAGGED compiled code block */
 333         code_block *code;
 334 };
 335
 336 /* Assembly code makes assumptions about the layout of this struct */
 337 struct alien : public object {
 338         static const cell type_number = ALIEN_TYPE;
 339         /* tagged */
 340         cell base;
 341         /* tagged */
 342         cell expired;
 343         /* untagged */
 344         cell displacement;
 345 };
 346
 347 struct dll : public object {
 348         static const cell type_number = DLL_TYPE;
 349         /* tagged byte array holding a C string */
 350         cell path;
 351         /* OS-specific handle */
 352         void *dll;
 353 };
 354
 355 struct stack_frame
 356 {
 357         void *xt;
 358         /* Frame size in bytes */
 359         cell size;
 360 };
 361
 362 struct callstack : public object {
 363         static const cell type_number = CALLSTACK_TYPE;
 364         /* tagged */
 365         cell length;
 366
 367         stack_frame *frame_at(cell offset)
 368         {
 369                 return (stack_frame *)((char *)(this + 1) + offset);
 370         }
 371
 372         stack_frame *top() { return (stack_frame *)(this + 1); }
 373         stack_frame *bottom() { return (stack_frame *)((cell)(this + 1) + untag_fixnum(length)); }
 374 };
 375
 376 struct tuple : public object {
 377         static const cell type_number = TUPLE_TYPE;
 378         /* tagged layout */
 379         cell layout;
 380
 381         cell *data() { return (cell *)(this + 1); }
 382 };
 383
 384 }