2013-05-11 22:08:13 -04:00
|
|
|
namespace factor {
|
2009-05-04 02:46:13 -04:00
|
|
|
|
2013-05-13 00:28:25 -04:00
|
|
|
typedef intptr_t fixnum;
|
|
|
|
typedef uintptr_t cell;
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2013-05-11 22:08:13 -04:00
|
|
|
inline static cell align(cell a, cell b) { return (a + (b - 1)) & ~(b - 1); }
|
2009-05-04 02:00:30 -04:00
|
|
|
|
2013-05-11 22:08:13 -04:00
|
|
|
inline static cell alignment_for(cell a, cell b) { return align(a, b) - a; }
|
2010-06-11 20:06:00 -04:00
|
|
|
|
2009-10-20 13:45:00 -04:00
|
|
|
static const cell data_alignment = 16;
|
2009-05-08 16:05:55 -04:00
|
|
|
|
2015-08-24 16:44:30 -04:00
|
|
|
/* Must match leaf-stack-frame-size in core/layouts/layouts.factor */
|
|
|
|
#define LEAF_FRAME_SIZE 16
|
|
|
|
|
2013-05-11 22:08:13 -04:00
|
|
|
#define WORD_SIZE (signed)(sizeof(cell) * 8)
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-11-02 04:25:39 -05:00
|
|
|
#define TAG_MASK 15
|
|
|
|
#define TAG_BITS 4
|
2009-05-04 05:50:24 -04:00
|
|
|
#define TAG(x) ((cell)(x) & TAG_MASK)
|
|
|
|
#define UNTAG(x) ((cell)(x) & ~TAG_MASK)
|
2013-05-11 22:08:13 -04:00
|
|
|
#define RETAG(x, tag) (UNTAG(x) | (tag))
|
2009-05-02 05:04:19 -04:00
|
|
|
|
|
|
|
/*** Tags ***/
|
|
|
|
#define FIXNUM_TYPE 0
|
2009-11-02 21:21:21 -05:00
|
|
|
#define F_TYPE 1
|
2009-05-02 05:04:19 -04:00
|
|
|
#define ARRAY_TYPE 2
|
|
|
|
#define FLOAT_TYPE 3
|
|
|
|
#define QUOTATION_TYPE 4
|
2009-11-02 21:21:21 -05:00
|
|
|
#define BIGNUM_TYPE 5
|
2009-11-02 04:25:39 -05:00
|
|
|
#define ALIEN_TYPE 6
|
2009-05-02 05:04:19 -04:00
|
|
|
#define TUPLE_TYPE 7
|
|
|
|
#define WRAPPER_TYPE 8
|
|
|
|
#define BYTE_ARRAY_TYPE 9
|
|
|
|
#define CALLSTACK_TYPE 10
|
|
|
|
#define STRING_TYPE 11
|
|
|
|
#define WORD_TYPE 12
|
|
|
|
#define DLL_TYPE 13
|
|
|
|
|
2009-11-02 04:25:39 -05:00
|
|
|
#define TYPE_COUNT 14
|
|
|
|
|
2013-05-11 22:08:13 -04:00
|
|
|
static inline const char* type_name(cell type) {
|
|
|
|
switch (type) {
|
|
|
|
case FIXNUM_TYPE:
|
|
|
|
return "fixnum";
|
|
|
|
case F_TYPE:
|
|
|
|
return "f";
|
|
|
|
case ARRAY_TYPE:
|
|
|
|
return "array";
|
|
|
|
case FLOAT_TYPE:
|
|
|
|
return "float";
|
|
|
|
case QUOTATION_TYPE:
|
|
|
|
return "quotation";
|
|
|
|
case BIGNUM_TYPE:
|
|
|
|
return "bignum";
|
|
|
|
case ALIEN_TYPE:
|
|
|
|
return "alien";
|
|
|
|
case TUPLE_TYPE:
|
|
|
|
return "tuple";
|
|
|
|
case WRAPPER_TYPE:
|
|
|
|
return "wrapper";
|
|
|
|
case BYTE_ARRAY_TYPE:
|
|
|
|
return "byte-array";
|
|
|
|
case CALLSTACK_TYPE:
|
|
|
|
return "callstack";
|
|
|
|
case STRING_TYPE:
|
|
|
|
return "string";
|
|
|
|
case WORD_TYPE:
|
|
|
|
return "word";
|
|
|
|
case DLL_TYPE:
|
|
|
|
return "dll";
|
|
|
|
default:
|
|
|
|
FACTOR_ASSERT(false);
|
|
|
|
return "";
|
|
|
|
}
|
2011-11-06 22:56:47 -05:00
|
|
|
}
|
|
|
|
|
2013-05-11 22:08:13 -04:00
|
|
|
enum code_block_type {
|
|
|
|
code_block_unoptimized,
|
|
|
|
code_block_optimized,
|
|
|
|
code_block_pic
|
2009-10-20 10:37:24 -04:00
|
|
|
};
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-09-14 00:37:28 -04:00
|
|
|
/* Constants used when floating-point trap exceptions are thrown */
|
2013-05-11 22:08:13 -04:00
|
|
|
enum {
|
|
|
|
FP_TRAP_INVALID_OPERATION = 1 << 0,
|
|
|
|
FP_TRAP_OVERFLOW = 1 << 1,
|
|
|
|
FP_TRAP_UNDERFLOW = 1 << 2,
|
|
|
|
FP_TRAP_ZERO_DIVIDE = 1 << 3,
|
|
|
|
FP_TRAP_INEXACT = 1 << 4,
|
2009-09-14 00:37:28 -04:00
|
|
|
};
|
|
|
|
|
2009-10-18 21:26:21 -04:00
|
|
|
/* What Factor calls 'f' */
|
|
|
|
static const cell false_object = F_TYPE;
|
|
|
|
|
2013-05-11 22:08:13 -04:00
|
|
|
inline static bool immediate_p(cell obj) {
|
|
|
|
/* We assume that fixnums have tag 0 and false_object has tag 1 */
|
|
|
|
return TAG(obj) <= F_TYPE;
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
|
2013-05-11 22:08:13 -04:00
|
|
|
inline static fixnum untag_fixnum(cell tagged) {
|
|
|
|
FACTOR_ASSERT(TAG(tagged) == FIXNUM_TYPE);
|
2013-05-13 00:53:47 -04:00
|
|
|
return ((fixnum)tagged) >> TAG_BITS;
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
|
2013-05-11 22:08:13 -04:00
|
|
|
inline static cell tag_fixnum(fixnum untagged) {
|
|
|
|
return (untagged << TAG_BITS) | FIXNUM_TYPE;
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
|
2009-11-10 22:06:36 -05:00
|
|
|
#define NO_TYPE_CHECK static const cell type_number = TYPE_COUNT
|
2009-05-04 02:00:30 -04:00
|
|
|
|
2009-11-10 22:06:36 -05:00
|
|
|
struct object {
|
2013-05-11 22:08:13 -04:00
|
|
|
NO_TYPE_CHECK;
|
2016-08-05 08:44:37 -04:00
|
|
|
// header format (bits indexed with least significant as zero):
|
|
|
|
// bit 0 : free?
|
|
|
|
// if not forwarding:
|
|
|
|
// bit 1 : forwarding pointer?
|
|
|
|
// bit 2-5 : tag
|
|
|
|
// bit 7-end : hashcode
|
|
|
|
// if forwarding:
|
|
|
|
// bit 2-end : forwarding pointer
|
2013-05-11 22:08:13 -04:00
|
|
|
cell header;
|
|
|
|
|
2015-07-03 12:47:33 -04:00
|
|
|
template <typename Fixup> cell base_size(Fixup fixup) const;
|
2013-05-11 22:08:13 -04:00
|
|
|
template <typename Fixup> cell size(Fixup fixup) const;
|
2015-07-03 12:47:33 -04:00
|
|
|
cell size() const;
|
2013-05-11 22:08:13 -04:00
|
|
|
|
2015-07-04 14:57:02 -04:00
|
|
|
cell slot_count() const;
|
|
|
|
template <typename Fixup> cell slot_count(Fixup fixup) const;
|
2013-05-11 22:08:13 -04:00
|
|
|
|
|
|
|
cell* slots() const { return (cell*)this; }
|
|
|
|
|
|
|
|
template <typename Iterator> void each_slot(Iterator& iter);
|
|
|
|
|
|
|
|
/* Only valid for objects in tenured space; must cast to free_heap_block
|
|
|
|
to do anything with it if its free */
|
|
|
|
bool free_p() const { return (header & 1) == 1; }
|
|
|
|
|
|
|
|
cell type() const { return (header >> 2) & TAG_MASK; }
|
|
|
|
|
|
|
|
void initialize(cell type) { header = type << 2; }
|
|
|
|
|
|
|
|
cell hashcode() const { return (header >> 6); }
|
|
|
|
|
|
|
|
void set_hashcode(cell hashcode) {
|
|
|
|
header = (header & 0x3f) | (hashcode << 6);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool forwarding_pointer_p() const { return (header & 2) == 2; }
|
|
|
|
|
|
|
|
object* forwarding_pointer() const { return (object*)UNTAG(header); }
|
|
|
|
|
2013-05-13 00:53:47 -04:00
|
|
|
void forward_to(object* pointer) { header = ((cell)pointer | 2); }
|
2009-05-02 05:04:19 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Assembly code makes assumptions about the layout of this struct */
|
2009-05-04 05:50:24 -04:00
|
|
|
struct array : public object {
|
2013-05-11 22:08:13 -04:00
|
|
|
static const cell type_number = ARRAY_TYPE;
|
|
|
|
static const cell element_size = sizeof(cell);
|
|
|
|
/* tagged */
|
|
|
|
cell capacity;
|
2009-05-04 02:00:30 -04:00
|
|
|
|
2013-05-11 22:08:13 -04:00
|
|
|
cell* data() const { return (cell*)(this + 1); }
|
2009-05-02 05:04:19 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/* These are really just arrays, but certain elements have special
|
2013-05-11 22:08:13 -04:00
|
|
|
significance */
|
2009-05-04 05:50:24 -04:00
|
|
|
struct tuple_layout : public array {
|
2013-05-11 22:08:13 -04:00
|
|
|
NO_TYPE_CHECK;
|
|
|
|
/* tagged */
|
|
|
|
cell klass;
|
|
|
|
/* tagged fixnum */
|
|
|
|
cell size;
|
|
|
|
/* tagged fixnum */
|
|
|
|
cell echelon;
|
2009-05-02 05:04:19 -04:00
|
|
|
};
|
|
|
|
|
2009-05-04 05:50:24 -04:00
|
|
|
struct bignum : public object {
|
2013-05-11 22:08:13 -04:00
|
|
|
static const cell type_number = BIGNUM_TYPE;
|
|
|
|
static const cell element_size = sizeof(cell);
|
|
|
|
/* tagged */
|
|
|
|
cell capacity;
|
2009-05-04 02:00:30 -04:00
|
|
|
|
2013-05-11 22:08:13 -04:00
|
|
|
cell* data() const { return (cell*)(this + 1); }
|
2009-05-02 05:04:19 -04:00
|
|
|
};
|
|
|
|
|
2009-05-04 05:50:24 -04:00
|
|
|
struct byte_array : public object {
|
2013-05-11 22:08:13 -04:00
|
|
|
static const cell type_number = BYTE_ARRAY_TYPE;
|
|
|
|
static const cell element_size = 1;
|
|
|
|
/* tagged */
|
|
|
|
cell capacity;
|
2009-05-04 02:00:30 -04:00
|
|
|
|
2009-10-20 13:45:00 -04:00
|
|
|
#ifndef FACTOR_64
|
2013-05-11 22:08:13 -04:00
|
|
|
cell padding0;
|
|
|
|
cell padding1;
|
2009-10-20 13:45:00 -04:00
|
|
|
#endif
|
|
|
|
|
2013-05-11 22:08:13 -04:00
|
|
|
template <typename Scalar> Scalar* data() const {
|
|
|
|
return (Scalar*)(this + 1);
|
|
|
|
}
|
2009-05-02 05:04:19 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Assembly code makes assumptions about the layout of this struct */
|
2009-05-04 05:50:24 -04:00
|
|
|
struct string : public object {
|
2013-05-11 22:08:13 -04:00
|
|
|
static const cell type_number = STRING_TYPE;
|
|
|
|
/* tagged num of chars */
|
|
|
|
cell length;
|
|
|
|
/* tagged */
|
|
|
|
cell aux;
|
|
|
|
/* tagged */
|
|
|
|
cell hashcode;
|
|
|
|
|
2013-05-13 00:28:25 -04:00
|
|
|
uint8_t* data() const { return (uint8_t*)(this + 1); }
|
2009-05-02 05:04:19 -04:00
|
|
|
};
|
|
|
|
|
2009-11-07 17:16:09 -05:00
|
|
|
struct code_block;
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2011-11-10 19:00:47 -05:00
|
|
|
/* Assembly code makes assumptions about the layout of this struct:
|
2013-05-11 22:08:13 -04:00
|
|
|
basis/bootstrap/images/images.factor
|
|
|
|
basis/compiler/constants/constants.factor
|
|
|
|
core/bootstrap/primitives.factor
|
2011-11-10 19:00:47 -05:00
|
|
|
*/
|
2009-05-04 05:50:24 -04:00
|
|
|
struct word : public object {
|
2013-05-11 22:08:13 -04:00
|
|
|
static const cell type_number = WORD_TYPE;
|
|
|
|
/* TAGGED hashcode */
|
|
|
|
cell hashcode;
|
|
|
|
/* TAGGED word name */
|
|
|
|
cell name;
|
|
|
|
/* TAGGED word vocabulary */
|
|
|
|
cell vocabulary;
|
|
|
|
/* TAGGED definition */
|
|
|
|
cell def;
|
|
|
|
/* TAGGED property assoc for library code */
|
|
|
|
cell props;
|
|
|
|
/* TAGGED alternative entry point for direct non-tail calls. Used for inline
|
|
|
|
* caching */
|
|
|
|
cell pic_def;
|
|
|
|
/* TAGGED alternative entry point for direct tail calls. Used for inline
|
|
|
|
* caching */
|
|
|
|
cell pic_tail_def;
|
|
|
|
/* TAGGED machine code for sub-primitive */
|
|
|
|
cell subprimitive;
|
|
|
|
/* UNTAGGED entry point: jump here to execute word */
|
2015-01-07 05:51:19 -05:00
|
|
|
cell entry_point;
|
2013-05-11 22:08:13 -04:00
|
|
|
/* UNTAGGED compiled code block */
|
|
|
|
|
|
|
|
/* defined in code_blocks.hpp */
|
|
|
|
code_block* code() const;
|
2009-05-02 05:04:19 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Assembly code makes assumptions about the layout of this struct */
|
2009-05-04 05:50:24 -04:00
|
|
|
struct wrapper : public object {
|
2013-05-11 22:08:13 -04:00
|
|
|
static const cell type_number = WRAPPER_TYPE;
|
|
|
|
cell object;
|
2009-05-02 05:04:19 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Assembly code makes assumptions about the layout of this struct */
|
2009-05-04 05:50:24 -04:00
|
|
|
struct boxed_float : object {
|
2013-05-11 22:08:13 -04:00
|
|
|
static const cell type_number = FLOAT_TYPE;
|
2009-05-04 02:00:30 -04:00
|
|
|
|
|
|
|
#ifndef FACTOR_64
|
2013-05-11 22:08:13 -04:00
|
|
|
cell padding;
|
2009-05-04 02:00:30 -04:00
|
|
|
#endif
|
|
|
|
|
2013-05-11 22:08:13 -04:00
|
|
|
double n;
|
2009-05-02 05:04:19 -04:00
|
|
|
};
|
|
|
|
|
2011-11-10 19:00:47 -05:00
|
|
|
/* Assembly code makes assumptions about the layout of this struct:
|
2013-05-11 22:08:13 -04:00
|
|
|
basis/bootstrap/images/images.factor
|
|
|
|
basis/compiler/constants/constants.factor
|
|
|
|
core/bootstrap/primitives.factor
|
2011-11-10 19:00:47 -05:00
|
|
|
*/
|
2009-05-04 05:50:24 -04:00
|
|
|
struct quotation : public object {
|
2013-05-11 22:08:13 -04:00
|
|
|
static const cell type_number = QUOTATION_TYPE;
|
|
|
|
/* tagged */
|
|
|
|
cell array;
|
|
|
|
/* tagged */
|
|
|
|
cell cached_effect;
|
|
|
|
/* tagged */
|
|
|
|
cell cache_counter;
|
|
|
|
/* UNTAGGED entry point; jump here to call quotation */
|
2015-01-07 05:51:19 -05:00
|
|
|
cell entry_point;
|
2013-05-11 22:08:13 -04:00
|
|
|
|
|
|
|
/* defined in code_blocks.hpp */
|
|
|
|
code_block* code() const;
|
2009-05-02 05:04:19 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Assembly code makes assumptions about the layout of this struct */
|
2009-05-04 05:50:24 -04:00
|
|
|
struct alien : public object {
|
2013-05-11 22:08:13 -04:00
|
|
|
static const cell type_number = ALIEN_TYPE;
|
|
|
|
/* tagged */
|
|
|
|
cell base;
|
|
|
|
/* tagged */
|
|
|
|
cell expired;
|
|
|
|
/* untagged */
|
|
|
|
cell displacement;
|
|
|
|
/* untagged */
|
|
|
|
cell address;
|
|
|
|
|
|
|
|
void update_address() {
|
|
|
|
if (base == false_object)
|
|
|
|
address = displacement;
|
|
|
|
else
|
|
|
|
address = UNTAG(base) + sizeof(byte_array) + displacement;
|
|
|
|
}
|
2009-05-02 05:04:19 -04:00
|
|
|
};
|
|
|
|
|
2009-05-04 05:50:24 -04:00
|
|
|
struct dll : public object {
|
2013-05-11 22:08:13 -04:00
|
|
|
static const cell type_number = DLL_TYPE;
|
|
|
|
/* tagged byte array holding a C string */
|
|
|
|
cell path;
|
|
|
|
/* OS-specific handle */
|
|
|
|
void* handle;
|
2009-05-02 05:04:19 -04:00
|
|
|
};
|
|
|
|
|
2009-05-08 16:05:55 -04:00
|
|
|
struct callstack : public object {
|
2013-05-11 22:08:13 -04:00
|
|
|
static const cell type_number = CALLSTACK_TYPE;
|
|
|
|
/* tagged */
|
|
|
|
cell length;
|
|
|
|
|
2015-01-06 11:35:44 -05:00
|
|
|
cell frame_top_at(cell offset) const {
|
|
|
|
return (cell)(this + 1) + offset;
|
2013-05-11 22:08:13 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void* top() const { return (void*)(this + 1); }
|
|
|
|
void* bottom() const {
|
|
|
|
return (void*)((cell)(this + 1) + untag_fixnum(length));
|
|
|
|
}
|
2009-05-08 16:05:55 -04:00
|
|
|
};
|
|
|
|
|
2009-05-04 05:50:24 -04:00
|
|
|
struct tuple : public object {
|
2013-05-11 22:08:13 -04:00
|
|
|
static const cell type_number = TUPLE_TYPE;
|
|
|
|
/* tagged layout */
|
|
|
|
cell layout;
|
2009-05-04 02:00:30 -04:00
|
|
|
|
2013-05-11 22:08:13 -04:00
|
|
|
cell* data() const { return (cell*)(this + 1); }
|
2009-05-02 05:04:19 -04:00
|
|
|
};
|
2009-05-04 02:46:13 -04:00
|
|
|
|
2015-07-04 14:57:02 -04:00
|
|
|
inline static cell tuple_capacity(const tuple_layout *layout) {
|
|
|
|
return untag_fixnum(layout->size);
|
|
|
|
}
|
|
|
|
|
2015-07-03 13:12:57 -04:00
|
|
|
inline static cell tuple_size(const tuple_layout* layout) {
|
2015-07-04 14:57:02 -04:00
|
|
|
return sizeof(tuple) + tuple_capacity(layout) * sizeof(cell);
|
2015-07-03 13:12:57 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
inline static cell string_capacity(const string* str) {
|
|
|
|
return untag_fixnum(str->length);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline static cell string_size(cell size) { return sizeof(string) + size; }
|
|
|
|
|
2009-05-04 02:46:13 -04:00
|
|
|
}
|