vm/.gitignore vm/builtin_block_environment.hpp vm/builtin_bytearray.hpp vm/builtin_compiledmethod.hpp vm/builtin_exception.hpp vm/builtin_executable.hpp vm/builtin_fixnum.hpp vm/builtin_immediates.hpp vm/builtin_io.hpp vm/builtin_lookuptable.hpp vm/builtin_memorypointer.hpp vm/builtin_methodtable.hpp vm/builtin_nativefunction.hpp vm/builtin_staticscope.hpp vm/builtin_symbol.hpp vm/builtin_tuple.hpp vm/compiled_file.cpp vm/compiled_file.hpp vm/doc/execution.txt vm/environment.cpp vm/environment.hpp vm/field_extract.rb vm/main.cpp vm/primitives.cpp vm/primitives.hpp vm/test/test_compiled_file.hpp vm/test/test_compiledmethod.hpp vm/test/test_instructions.hpp vm/test/test_vmmethod.hpp @@ -4,13 +4,14 @@ namespace rubinius { class Array : public BuiltinType { public: - const static size_t fields = 4; + const static size_t fields = 5; const static object_type type = ArrayType; - INTEGER total; - Tuple* tuple; - INTEGER start; - OBJECT shared; + OBJECT __ivars__; // slot + INTEGER total; // slot + Tuple* tuple; // slot + INTEGER start; // slot + OBJECT shared; // slot size_t size() { return total->n2i(); @@ -23,6 +24,13 @@ namespace rubinius { OBJECT set(STATE, size_t idx, OBJECT val); OBJECT append(STATE, OBJECT val); bool includes_p(STATE, OBJECT val); + + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); + }; }; }; vm/builtin_array.hpp @@ -170,7 +170,7 @@ namespace rubinius { } void Bignum::init(STATE) { - state->add_type_info(new Bignum::Info(G(bignum))); + state->add_type_info(new Bignum::Info(Bignum::type)); } Bignum* Bignum::create(STATE, native_int num) { @@ -253,7 +253,6 @@ namespace rubinius { INTEGER Bignum::div(STATE, INTEGER b, INTEGER mod_obj) { NMP; - mp_int *mod = MP(mod_obj); mp_int m, x, y, z; if(kind_of<Fixnum>(b)) { @@ -297,7 +296,8 @@ namespace rubinius { mp_copy(&y, &m); } - if(mod) { + if(!mod_obj->nil_p()) { + mp_int *mod = MP(mod_obj); mp_copy(&m, mod); } vm/builtin_bignum.cpp @@ -57,7 +57,7 @@ namespace rubinius { class Info : public TypeInfo { public: - Info(Class* cls) : TypeInfo(cls) { } + Info(object_type type) : TypeInfo(type) { } virtual void cleanup(OBJECT obj); }; }; vm/builtin_bignum.hpp @@ -9,6 +9,13 @@ namespace rubinius { } void Channel::send(STATE, OBJECT val) { + if(!waiting->empty_p()) { + Thread* thr = as<Thread>(waiting->shift(state)); + thr->set_top(state, val); + state->queue_thread(thr); + return; + } + if(value->nil_p()) { List* lst = List::create(state); lst->append(state, val); @@ -33,10 +40,7 @@ namespace rubinius { } bool Channel::has_readers_p() { - return false; + return !waiting->empty_p(); } - void Thread::sleep_for(STATE, Channel* chan) { - - } } vm/builtin_channel.cpp @@ -7,16 +7,25 @@ namespace rubinius { const static size_t fields = 3; const static object_type type = ChannelType; - OBJECT value; - List* waiting; + OBJECT __ivars__; // slot + OBJECT value; // slot + List* waiting; // slot static Channel* create(STATE); void send(STATE, OBJECT); void receive(STATE); bool has_readers_p(); + + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); + }; }; class ChannelCallback : public ObjectCallback { + public: TypedRoot<Channel*> channel; ChannelCallback(STATE, Channel* chan) : ObjectCallback(state) { vm/builtin_channel.hpp @@ -78,14 +78,13 @@ namespace rubinius { MetaClass* MetaClass::attach(STATE, OBJECT obj, OBJECT sup) { MetaClass *meta; - meta = (MetaClass*)state->om->new_object(G(metaclass), - MetaClass::fields); + meta = (MetaClass*)state->new_object(G(metaclass)); if(!sup) { sup = obj->klass; } meta->IsMeta = TRUE; SET(meta, attached_instance, obj); meta->setup(state); SET(meta, superclass, sup); - state->om->set_class(obj, meta); + SET(obj, klass, meta); return meta; } vm/builtin_class.cpp @@ -6,16 +6,14 @@ namespace rubinius { class Module : public BuiltinType { public: - const static size_t fields = 7; + const static size_t fields = 5; const static object_type type = ModuleType; - OBJECT instance_variables; - LookupTable* method_table; - OBJECT method_cache; - SYMBOL name; - LookupTable* constants; - OBJECT encloser; - Class* superclass; + OBJECT __ivars__; // slot + LookupTable* method_table; // slot + SYMBOL name; // slot + LookupTable* constants; // slot + Module* superclass; // slot static Module* create(STATE); void setup(STATE); @@ -28,23 +26,37 @@ namespace rubinius { OBJECT get_const(STATE, char* sym); void set_name(STATE, Module* under, SYMBOL name); + + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); + }; }; class Class : public Module { public: - const static size_t fields = 11; + const static size_t fields = 9; const static object_type type = ClassType; - FIXNUM instance_fields; - OBJECT has_ivars; - OBJECT needs_cleanup; - FIXNUM instance_type; + FIXNUM instance_fields; // slot + OBJECT has_ivars; // slot + OBJECT needs_cleanup; // slot + FIXNUM instance_type; // slot void set_object_type(size_t type) { instance_type = Object::i2n(type); } static Class* create(STATE, Class* super); + + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); + }; }; /* See t1 */ @@ -57,22 +69,34 @@ namespace rubinius { class MetaClass : public Class { public: - const static size_t fields = 12; + const static size_t fields = 10; const static object_type type = MetaclassType; - OBJECT attached_instance; - - static bool is_a(OBJECT obj) { - return obj->obj_type == MetaclassType; - } + OBJECT attached_instance; // slot static MetaClass* attach(STATE, OBJECT obj, OBJECT sup = NULL); + + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); + }; }; class IncludedModule : public Module { public: + const static size_t field = 6; + const static object_type type = IncModType; - OBJECT module; + OBJECT module; // slot + + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); + }; }; }; vm/builtin_class.hpp @@ -1,5 +1,6 @@ #include "builtin.hpp" #include "ffi.hpp" +#include "marshal.hpp" namespace rubinius { CompiledMethod* CompiledMethod::create(STATE) { @@ -7,8 +8,8 @@ namespace rubinius { return cm; } - CompiledMethod::Visibility* CompiledMethod::Visibility::create(STATE) { - return (CompiledMethod::Visibility*)state->new_object(G(cmethod_vis)); + MethodVisibility* MethodVisibility::create(STATE) { + return (MethodVisibility*)state->new_object(G(cmethod_vis)); } void CompiledMethod::post_marshal(STATE) { vm/builtin_compiledmethod.cpp @@ -13,6 +13,9 @@ namespace rubinius { } + void MethodContext::Info::mark(MethodContext* obj) { + } + BlockContext* BlockContext::create(STATE) { return (BlockContext*)state->new_struct(G(blokctx), sizeof(BlockContext)); } @@ -21,13 +24,17 @@ namespace rubinius { } + void BlockEnvironment::call(STATE, Message& msg) { + + } + BlockContext* BlockEnvironment::create_context(STATE) { BlockContext* ctx = BlockContext::create(state); SET(ctx, sender, (MethodContext*)Qnil); SET(ctx, name, (SYMBOL)this); SET(ctx, cm, method); SET(ctx, stack, Tuple::create(state, method->stack_size->to_nint())); - + ctx->vmm = method->vmmethod(state); ctx->ip = 0; ctx->sp = method->number_of_locals() - 1; @@ -37,9 +44,9 @@ namespace rubinius { BlockEnvironment* BlockEnvironment::under_context(STATE, CompiledMethod* cm, MethodContext* parent, MethodContext* active) { - + BlockEnvironment* be = (BlockEnvironment*)state->new_object(G(blokenv)); - + parent->reference(state); active->reference(state); vm/builtin_contexts.cpp @@ -27,7 +27,7 @@ namespace rubinius { int sp; size_t args; OBJECT block; - SYMBOL name; + OBJECT name; bool no_value; /* Locals are stored at the top of the stack. */ @@ -37,6 +37,8 @@ namespace rubinius { void reference(STATE); class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } virtual void mark(MethodContext* obj); }; }; @@ -52,9 +54,18 @@ namespace rubinius { static BlockContext* create(STATE); - class Info : public MethodContext::Info { }; + class Info : public MethodContext::Info { + public: + Info(object_type type) : MethodContext::Info(type) { } + }; }; + template <> + static bool kind_of<MethodContext>(OBJECT obj) { + return obj->obj_type == MethodContext::type || + obj->obj_type == BlockContext::type; + } + } #endif vm/builtin_contexts.hpp @@ -11,6 +11,17 @@ namespace rubinius { return flt; } + OBJECT Float::compare(STATE, Float* other) { + double b = other->to_double(); + if(val < b) { + return Object::i2n(-1); + } else if(val > b) { + return Object::i2n(1); + } else { + return Object::i2n(0); + } + } + Float* Float::coerce(STATE, OBJECT value) { if(value->fixnum_p()) { return Float::create(state, (double)(as<Fixnum>(value)->to_nint())); vm/builtin_float.cpp @@ -17,13 +17,15 @@ namespace rubinius { static bool is_a(OBJECT obj) { return obj->obj_type == FloatType; } - + double val; static Float* create(STATE, double val); static Float* coerce(STATE, OBJECT value); double to_double(STATE) { return val; } + double to_double() { return val; } void into_string(STATE, char* buf, size_t sz); + OBJECT compare(STATE, Float* other); static int radix() { return FLT_RADIX; } static int rounds() { return FLT_ROUNDS; } @@ -36,6 +38,11 @@ namespace rubinius { static int dig() { return DBL_DIG; } static int mant_dig() { return DBL_MANT_DIG; } static double epsilon() { return DBL_EPSILON; } + + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + }; }; } vm/builtin_float.hpp @@ -1,8 +1,6 @@ #include "builtin.hpp" -#define MAX_DENSITY 0.75 #define find_bin(hash, total) (hash & (total - 1)) -#define hash_redistribute_p(hash) (hash->entries->n2i() >= MAX_DENSITY * hash->bins->n2i()) #define CSM_SIZE 12 namespace rubinius { @@ -26,8 +24,8 @@ namespace rubinius { Hash* Hash::dup(STATE) { size_t size, i; Hash *dup; - OBJECT tmp, ent, next; - Tuple *vals, *lst; + OBJECT tmp; + Tuple *vals, *lst, *ent, *next; size = bins->n2i(); dup = Hash::create(state, size); @@ -42,26 +40,26 @@ namespace rubinius { SET(dup, values, vals); for(i = 0; i < size; i++) { - tmp = (Tuple*)values->at(i); - if(tmp->nil_p()) continue; + tmp = try_as<Tuple>(values->at(i)); + if(!tmp) continue; - ent = tmp->dup(state); + ent = as<Tuple>(tmp->dup(state)); vals->put(state, i, ent); - next = ent->at(3); - lst = (Tuple*)ent; + next = try_as<Tuple>(ent->at(3)); + lst = ent; - while(!next->nil_p()) { - next = next->dup(state); + while(next) { + next = as<Tuple>(next->dup(state)); lst->put(state, 3, next); - lst = (Tuple*)next; - next = next->at(3); + lst = next; + next = try_as<Tuple>(next->at(3)); } } return dup; } - OBJECT Hash::entry_new(STATE, hashval hsh, OBJECT key, OBJECT data) { + Tuple* Hash::entry_new(STATE, hashval hsh, OBJECT key, OBJECT data) { Tuple* tup = Tuple::create(state, 4); tup->put(state, 0, Object::i2n(hsh)); tup->put(state, 1, key); @@ -70,14 +68,14 @@ namespace rubinius { return tup; } - OBJECT Hash::entry_append(STATE, OBJECT top, OBJECT nxt) { + Tuple* Hash::entry_append(STATE, Tuple* top, Tuple* nxt) { int depth = 1; - Tuple* cur = (Tuple*)top->at(3); - Tuple* last = (Tuple*)top; + Tuple* cur = try_as<Tuple>(top->at(3)); + Tuple* last = top; - while(!cur->nil_p()) { + while(cur) { last = cur; - cur = (Tuple*)cur->at(3); + cur = try_as<Tuple>(cur->at(3)); depth++; } @@ -85,17 +83,13 @@ namespace rubinius { return nxt; } - OBJECT Hash::add_entry(STATE, hashval hsh, OBJECT ent) { - OBJECT entry; - + OBJECT Hash::add_entry(STATE, hashval hsh, Tuple* ent) { size_t bin = find_bin(hsh, bins->n2i()); - entry = values->at(bin); - - if(entry->nil_p()) { - values->put(state, bin, ent); - } else { + if(Tuple* entry = try_as<Tuple>(values->at(bin))) { entry_append(state, entry, ent); + } else { + values->put(state, bin, ent); } entries = Object::i2n(entries->n2i() + 1); @@ -112,20 +106,18 @@ namespace rubinius { Tuple* new_values = Tuple::create(state, size); for(size_t i = 0; i < num; i++) { - Tuple* entry = (Tuple*)values->at(i); + Tuple* entry = try_as<Tuple>(values->at(i)); - while(!entry->nil_p()) { - Tuple* next = (Tuple*)entry->at(3); + while(entry) { + Tuple* next = try_as<Tuple>(entry->at(3)); entry->put(state, 3, Qnil); native_int hash = as<Integer>(entry->at(0))->n2i(); size_t bin = find_bin(hash, size); - OBJECT slot = new_values->at(bin); - - if(slot->nil_p()) { - new_values->put(state, bin, entry); - } else { + if(Tuple* slot = try_as<Tuple>(new_values->at(bin))) { entry_append(state, slot, entry); + } else { + new_values->put(state, bin, entry); } entry = next; @@ -136,25 +128,29 @@ namespace rubinius { bins = Object::i2n(size); } - OBJECT Hash::find_entry(STATE, hashval hsh) { + /* Find the entry that has a hash value of +hsh+. Return NULL if nothing + * found. */ + Tuple* Hash::find_entry(STATE, hashval hsh) { size_t num = bins->n2i(); size_t bin = find_bin(hsh, num); - OBJECT entry = values->at(bin); + Tuple* entry = try_as<Tuple>(values->at(bin)); + if(!entry) return NULL; - while(!entry->nil_p()) { + for(;;) { INTEGER th = as<Integer>(entry->at(0)); if((hashval)th->n2i() == hsh) { return entry; } - entry = entry->at(3); + + if((entry = try_as<Tuple>(entry->at(3))) == NULL) return NULL; } - return Qnil; + return NULL; } OBJECT Hash::add(STATE, hashval hsh, OBJECT key, OBJECT data) { - Tuple* entry = (Tuple*)find_entry(state, hsh); + Tuple* entry = find_entry(state, hsh); - if(!entry->nil_p()) { + if(entry) { entry->put(state, 2, data); return data; } @@ -171,8 +167,8 @@ namespace rubinius { } OBJECT Hash::get(STATE, hashval hsh) { - OBJECT entry = find_entry(state, hsh); - if(!entry->nil_p()) { + Tuple* entry = find_entry(state, hsh); + if(entry) { return entry->at(2); } @@ -183,20 +179,20 @@ namespace rubinius { * Uses +==+ to verify the key in the table matches +key+. * Return TRUE if key was found, and *value will be filled. */ int Hash::lookup(STATE, OBJECT key, hashval hash, OBJECT *value) { - OBJECT ent, hk; + OBJECT hk; - ent = find_entry(state, hash); - if(ent->reference_p()) { - while((hashval)as<Integer>(ent->at(0))->n2i() == hash) { - hk = ent->at(1); - if(hk == key) { - *value = ent->at(2); - return TRUE; - } + Tuple* ent = find_entry(state, hash); + if(!ent) return FALSE; - ent = ent->at(3); - if(ent->nil_p()) break; + while((hashval)as<Integer>(ent->at(0))->n2i() == hash) { + hk = ent->at(1); + if(hk == key) { + *value = ent->at(2); + return TRUE; } + + ent = try_as<Tuple>(ent->at(3)); + if(!ent) break; } return FALSE; @@ -207,20 +203,20 @@ namespace rubinius { * Return TRUE if key was found, and *value will be filled. */ int Hash::lookup2(STATE, int (*compare)(STATE, OBJECT, OBJECT), OBJECT key, hashval hash, OBJECT *value) { - OBJECT ent, hk; + OBJECT hk; - ent = find_entry(state, hash); - if(ent->reference_p()) { - while((hashval)as<Integer>(ent->at(0))->n2i() == hash) { - hk = ent->at(1); - if(compare(state, hk, key)) { - *value = ent->at(2); - return TRUE; - } + Tuple* ent = find_entry(state, hash); + if(!ent) return FALSE; - ent = ent->at(3); - if(ent->nil_p()) break; + while((hashval)as<Integer>(ent->at(0))->n2i() == hash) { + hk = ent->at(1); + if(compare(state, hk, key)) { + *value = ent->at(2); + return TRUE; } + + ent = try_as<Tuple>(ent->at(3)); + if(!ent) break; } return FALSE; @@ -232,8 +228,8 @@ namespace rubinius { Tuple* ent; Tuple* base; - base = ent = (Tuple*)find_entry(state, hash); - if(ent->reference_p()) { + base = ent = find_entry(state, hash); + if(ent) { while((hashval)as<Integer>(ent->at(0))->n2i() == hash) { hk = ent->at(1); if(compare(state, hk, key)) { @@ -241,8 +237,8 @@ namespace rubinius { return; } - ent = (Tuple*)ent->at(3); - if(ent->nil_p()) break; + ent = try_as<Tuple>(ent->at(3)); + if(!ent) break; } } @@ -251,14 +247,14 @@ namespace rubinius { redistribute(state); } - if(base->reference_p()) { - ent = (Tuple*)entry_new(state, hash, key, value); + if(base) { + ent = entry_new(state, hash, key, value); entry_append(state, base, ent); entries = Object::i2n(entries->n2i() + 1); return; } - ent = (Tuple*)entry_new(state, hash, key, value); + ent = entry_new(state, hash, key, value); add_entry(state, hash, ent); } @@ -268,10 +264,8 @@ namespace rubinius { */ OBJECT Hash::get_undef(STATE, hashval hsh) { - OBJECT entry; - - entry = find_entry(state, hsh); - if(RTEST(entry)) { + Tuple* entry = find_entry(state, hsh); + if(entry) { return entry->at(2); } else { return Qundef; @@ -313,7 +307,7 @@ namespace rubinius { return Qnil; } - Hash* Hash::from_tuple(STATE, OBJECT tup) { + Hash* Hash::from_tuple(STATE, Tuple* tup) { OBJECT key, val; int i, fel; vm/builtin_hash.cpp @@ -11,22 +11,22 @@ namespace rubinius { const static size_t fields = 7; const static object_type type = HashType; - OBJECT instance_variables; - OBJECT keys; - Tuple* values; - FIXNUM bins; - FIXNUM entries; - OBJECT default_value; - OBJECT default_proc; + OBJECT __ivars__; // slot + OBJECT keys; // slot + Tuple* values; // slot + FIXNUM bins; // slot + FIXNUM entries; // slot + OBJECT default_value; // slot + OBJECT default_proc; // slot static Hash* create(STATE, size_t size = HASH_MINSIZE); void setup(STATE, size_t size); Hash* dup(STATE); - static OBJECT entry_new(STATE, hashval hsh, OBJECT key, OBJECT data); - static OBJECT entry_append(STATE, OBJECT top, OBJECT nxt); - OBJECT add_entry(STATE, hashval hsh, OBJECT ent); + static Tuple* entry_new(STATE, hashval hsh, OBJECT key, OBJECT data); + static Tuple* entry_append(STATE, Tuple* top, Tuple* nxt); + OBJECT add_entry(STATE, hashval hsh, Tuple* ent); void redistribute(STATE); - OBJECT find_entry(STATE, hashval hsh); + Tuple* find_entry(STATE, hashval hsh); OBJECT add(STATE, hashval hsh, OBJECT key, OBJECT data); OBJECT set(STATE, OBJECT key, OBJECT val); OBJECT get(STATE, hashval hsh); @@ -38,14 +38,24 @@ namespace rubinius { OBJECT get_undef(STATE, hashval hsh); OBJECT remove(STATE, hashval hsh); - static Hash* from_tuple(STATE, OBJECT tup); + static Hash* from_tuple(STATE, Tuple* tup); static Tuple* csm_new(STATE); static OBJECT csm_find(STATE, Tuple* csm, OBJECT key); static OBJECT csm_add(STATE, Tuple* csm, OBJECT key, OBJECT val); static Hash* csm_into_hash(STATE, Tuple* csm); static LookupTable* csm_into_lookuptable(STATE, Tuple* csm); + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); + }; + }; + +#define HASH_MAX_DENSITY 0.75 +#define hash_redistribute_p(hash) (hash->entries->n2i() >= HASH_MAX_DENSITY * hash->bins->n2i()) }; #endif vm/builtin_hash.hpp @@ -6,11 +6,11 @@ namespace rubinius { void IO::init(STATE) { - GO(iobuffer).set(state->new_class("Buffer", G(object), IO::Buffer::fields, G(io))); + GO(iobuffer).set(state->new_class("Buffer", G(object), IOBuffer::fields, G(io))); } - IO::Buffer* IO::Buffer::create(STATE, size_t bytes) { - IO::Buffer* buf = (IO::Buffer*)state->new_object(G(iobuffer)); + IOBuffer* IOBuffer::create(STATE, size_t bytes) { + IOBuffer* buf = (IOBuffer*)state->new_object(G(iobuffer)); SET(buf, storage, ByteArray::create(state, bytes)); SET(buf, total, Object::i2n(bytes)); SET(buf, used, Object::i2n(0)); @@ -23,4 +23,9 @@ namespace rubinius { SET(io, descriptor, Object::i2n(state, fd)); return io; } + + void IO::initialize(STATE, int fd, char* mode) { + SET(this, descriptor, Object::i2n(state, fd)); + SET(this, mode, String::create(state, mode)); + } }; vm/builtin_io.cpp @@ -1,13 +1,13 @@ #include "builtin.hpp" namespace rubinius { - ISeq* ISeq::create(STATE, size_t instructions) { - ISeq* is = (ISeq*)state->new_object(G(iseq)); - is->instructions = Tuple::create(state, instructions); + InstructionSequence* InstructionSequence::create(STATE, size_t instructions) { + InstructionSequence* is = (InstructionSequence*)state->new_object(G(iseq)); + is->opcodes = Tuple::create(state, instructions); return is; } - void ISeq::post_marshal(STATE) { + void InstructionSequence::post_marshal(STATE) { } vm/builtin_iseq.cpp @@ -4,16 +4,24 @@ #include "objects.hpp" namespace rubinius { - class ISeq : public BuiltinType { + class InstructionSequence : public BuiltinType { public: - const static size_t fields = 2; + const static size_t fields = 3; const static object_type type = ISeqType; - OBJECT instance_variables; - Tuple* instructions; + OBJECT __ivars__; // slot + Tuple* opcodes; // slot + FIXNUM stack_depth; // slot void post_marshal(STATE); - static ISeq* create(STATE, size_t instructions); + static InstructionSequence* create(STATE, size_t instructions); + + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); + }; #include "gen/iseq_instruction_names.hpp" }; vm/builtin_iseq.hpp @@ -10,22 +10,24 @@ namespace rubinius { cls->set_object_type(ListType); GO(list_node).set(state->new_class("Node", G(object), - List::Node::fields, cls)); + ListNode::fields, cls)); + + G(list_node)->set_object_type(ListNodeType); } /* Create a new List object, containing no elements. */ List* List::create(STATE) { List* list = (List*)state->new_object(G(list)); - list->count = Object::i2n(0); + SET(list, count, Object::i2n(0)); return list; } /* Append +obj+ to the current List. */ void List::append(STATE, OBJECT obj) { - List::Node* node = (List::Node*)state->new_object(G(list_node)); + ListNode* node = (ListNode*)state->new_object(G(list_node)); SET(node, object, obj); - List::Node* cur_last = last; + ListNode* cur_last = last; if(!cur_last->nil_p()) { SET(cur_last, next, node); @@ -37,12 +39,12 @@ namespace rubinius { SET(this, first, node); } - count = Object::i2n(state, count->n2i() + 1); + SET(this, count, Object::i2n(state, count->n2i() + 1)); } /* Return the +index+ numbered element from the beginning. */ OBJECT List::locate(STATE, size_t index) { - Node* cur = first; + ListNode* cur = first; while(index > 0) { if(cur->nil_p()) return Qnil; @@ -60,12 +62,12 @@ namespace rubinius { OBJECT List::shift(STATE) { if(empty_p()) return Qnil; - count = Object::i2n(state, count->n2i() - 1); - List::Node* n = first; + SET(this, count, Object::i2n(state, count->n2i() - 1)); + ListNode* n = first; SET(this, first, first->next); if(last == n) { - last = (Node*)Qnil; + SET(this, last, Qnil); } return n->object; @@ -79,9 +81,9 @@ namespace rubinius { size_t deleted = 0, counted = 0; - Node* node = first; - Node* lst = (Node*)Qnil; - Node* nxt = (Node*)Qnil; + ListNode* node = first; + ListNode* lst = (ListNode*)Qnil; + ListNode* nxt = (ListNode*)Qnil; while(!node->nil_p()) { nxt = node->next; @@ -98,7 +100,7 @@ namespace rubinius { SET(this, last, lst); } - lst = (Node*)Qnil; + lst = (ListNode*)Qnil; } else { counted++; lst = node; @@ -107,7 +109,7 @@ namespace rubinius { node = nxt; } - count = Object::i2n(state, counted); + SET(this, count, Object::i2n(state, counted)); return deleted; } vm/builtin_list.cpp @@ -5,24 +5,34 @@ namespace rubinius { - class List : public BuiltinType { - public: + class ListNode : public BuiltinType { + public: - class Node : public BuiltinType { - public: + const static size_t fields = 2; + const static object_type type = ListNodeType; - const static size_t fields = 2; + OBJECT object; // slot + ListNode* next; // slot - OBJECT object; - Node* next; + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); }; - - const static size_t fields = 3; + + }; + + class List : public BuiltinType { + public: + + const static size_t fields = 4; const static object_type type = ListType; - INTEGER count; - Node* first; - Node* last; + OBJECT __ivars__; // slot + INTEGER count; // slot + ListNode* first; // slot + ListNode* last; // slot /* Returns true if the List is empty, contains no elements. */ bool empty_p() { @@ -40,6 +50,14 @@ namespace rubinius { OBJECT shift(STATE); OBJECT locate(STATE, size_t index); size_t remove(STATE, OBJECT obj); + + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); + }; + }; }; vm/builtin_list.hpp @@ -52,9 +52,9 @@ namespace rubinius { state->om->set_class(dup, class_object(state)); size_t num = entries->n2i(); - Array* entries = (Array*)all_entries(state); + Array* entries = all_entries(state); for(i = 0; i < num; i++) { - OBJECT entry = entries->get(state, i); + Tuple* entry = as<Tuple>(entries->get(state, i)); OBJECT key = entry->at(0); OBJECT value = entry->at(1); dup->store(state, key, value); @@ -71,13 +71,13 @@ namespace rubinius { return tup; } - OBJECT LookupTable::entry_append(STATE, OBJECT top, OBJECT nxt) { - Tuple* cur = (Tuple*)top->at(2); - Tuple* last = (Tuple*)top; + OBJECT LookupTable::entry_append(STATE, Tuple* top, OBJECT nxt) { + Tuple* cur = try_as<Tuple>(top->at(2)); + Tuple* last = top; - while(!cur->nil_p()) { + while(cur) { last = cur; - cur = (Tuple*)cur->at(2); + cur = try_as<Tuple>(cur->at(2)); } last->put(state, 2, nxt); @@ -96,9 +96,9 @@ namespace rubinius { entry->put(state, 2, Qnil); size_t bin = find_bin(key_hash(entry->at(0)), size); - OBJECT slot = new_values->at(bin); + Tuple* slot = try_as<Tuple>(new_values->at(bin)); - if(slot->nil_p()) { + if(!slot) { new_values->put(state, bin, entry); } else { entry_append(state, slot, entry); @@ -149,38 +149,32 @@ namespace rubinius { return val; } - OBJECT LookupTable::find_entry(STATE, OBJECT key) { + Tuple* LookupTable::find_entry(STATE, OBJECT key) { unsigned int bin; - OBJECT entry; + Tuple* entry; key_to_sym(key); bin = find_bin(key_hash(key), bins->n2i()); - entry = values->at(bin); + entry = try_as<Tuple>(values->at(bin)); - while(!entry->nil_p()) { + while(entry) { if(entry->at(0) == key) { return entry; } - entry = entry->at(2); + entry = try_as<Tuple>(entry->at(2)); } - return Qnil; + return NULL; } OBJECT LookupTable::fetch(STATE, OBJECT key) { - OBJECT entry; - - entry = find_entry(state, key); - if(!entry->nil_p()) { - return entry->at(1); - } + Tuple* entry = find_entry(state, key); + if(entry) return entry->at(1); return Qnil; } OBJECT LookupTable::fetch(STATE, OBJECT key, bool* found) { - OBJECT entry; - - entry = find_entry(state, key); - if(!entry->nil_p()) { + Tuple* entry = find_entry(state, key); + if(entry) { *found = true; return entry->at(1); } @@ -195,10 +189,8 @@ namespace rubinius { * in cpu.c in e.g. cpu_const_get_in_context. */ OBJECT LookupTable::find(STATE, OBJECT key) { - OBJECT entry; - - entry = find_entry(state, key); - if(!entry->nil_p()) { + Tuple* entry = find_entry(state, key); + if(entry) { return entry->at(1); } return Qundef; @@ -247,35 +239,33 @@ namespace rubinius { } OBJECT LookupTable::has_key(STATE, OBJECT key) { - OBJECT entry; + Tuple* entry = find_entry(state, key); - entry = find_entry(state, key); - if(!entry->nil_p()) { - return Qtrue; - } + if(entry) return Qtrue; return Qfalse; } - Array* LookupTable::collect(STATE, LookupTable* tbl, OBJECT (*action)(STATE, OBJECT)) { + Array* LookupTable::collect(STATE, LookupTable* tbl, OBJECT (*action)(STATE, Tuple*)) { size_t i, j; - OBJECT values, entry; + Tuple* values; + Tuple* entry; Array* ary = Array::create(state, tbl->entries->n2i()); size_t num_bins = tbl->bins->n2i(); values = tbl->values; for(i = j = 0; i < num_bins; i++) { - entry = values->at(i); + entry = try_as<Tuple>(values->at(i)); - while(!entry->nil_p()) { + while(entry) { ary->set(state, j++, action(state, entry)); - entry = entry->at(2); + entry = try_as<Tuple>(entry->at(2)); } } return ary; } - OBJECT LookupTable::get_key(STATE, OBJECT entry) { + OBJECT LookupTable::get_key(STATE, Tuple* entry) { return entry->at(0); } @@ -283,7 +273,7 @@ namespace rubinius { return collect(state, this, get_key); } - OBJECT LookupTable::get_value(STATE, OBJECT entry) { + OBJECT LookupTable::get_value(STATE, Tuple* entry) { return entry->at(1); } @@ -291,11 +281,11 @@ namespace rubinius { return collect(state, this, get_value); } - OBJECT LookupTable::get_entry(STATE, OBJECT entry) { + OBJECT LookupTable::get_entry(STATE, Tuple* entry) { return entry; } - OBJECT LookupTable::all_entries(STATE) { + Array* LookupTable::all_entries(STATE) { return collect(state, this, get_entry); } vm/builtin_lookuptable.cpp @@ -114,8 +114,8 @@ namespace rubinius { Class* Object::class_object(STATE) { if(reference_p()) { Class* cls = klass; - while(!cls->nil_p() && !kind_of<Class>(cls)) { - cls = (Class*)cls->superclass; + while(!cls->nil_p() && !instance_of<Class>(cls)) { + cls = as<Class>(cls->superclass); } return cls; @@ -231,29 +231,26 @@ namespace rubinius { /* Implements the external ivars table for objects that don't have their own space for ivars. */ if(!reference_p()) { - LookupTable* tbl = (LookupTable*)G(external_ivars)->fetch(state, this); - if(!tbl->nil_p()) { - return tbl->fetch(state, sym); - } + LookupTable* tbl = try_as<LookupTable>(G(external_ivars)->fetch(state, this)); + if(tbl) return tbl->fetch(state, sym); return Qnil; } else if(!has_ivars_p()) { - MetaClass* meta = (MetaClass*)metaclass(state); - LookupTable* tbl = (LookupTable*)meta->has_ivars; + MetaClass* meta = as<MetaClass>(metaclass(state)); + LookupTable* tbl = try_as<LookupTable>(meta->has_ivars); - if(tbl->nil_p()) return Qnil; + if(tbl) return tbl->fetch(state, sym); + return Qnil; + } - return tbl->fetch(state, sym); + /* It's a tuple, use csm */ + if(Tuple* tup = try_as<Tuple>(((NormalObject*)this)->instance_variables)) { + return Hash::csm_find(state, tup, sym); } - tbl = (LookupTable*)((NormalObject*)this)->instance_variables; + tbl = try_as<LookupTable>(((NormalObject*)this)->instance_variables); /* No table, no ivar! */ - if(tbl->nil_p()) return Qnil; - - /* It's a tuple, use csm */ - if(kind_of<Tuple>(tbl)) { - return Hash::csm_find(state, (Tuple*)tbl, sym); - } + if(!tbl) return Qnil; /* It's a normal hash, no problem. */ val = tbl->fetch(state, sym); @@ -266,20 +263,20 @@ namespace rubinius { /* Implements the external ivars table for objects that don't have their own space for ivars. */ if(!reference_p()) { - tbl = (LookupTable*)G(external_ivars)->fetch(state, this); + tbl = try_as<LookupTable>(G(external_ivars)->fetch(state, this)); - if(tbl->nil_p()) { - tbl = (LookupTable*)LookupTable::create(state); + if(!tbl) { + tbl = LookupTable::create(state); G(external_ivars)->store(state, this, tbl); } tbl->store(state, sym, val); return val; } else if(!has_ivars_p()) { - MetaClass* meta = (MetaClass*)metaclass(state); - LookupTable* tbl = (LookupTable*)meta->has_ivars; + MetaClass* meta = as<MetaClass>(metaclass(state)); + tbl = try_as<LookupTable>(meta->has_ivars); - if(tbl->nil_p()) { - tbl = (LookupTable*)LookupTable::create(state); + if(!tbl) { + tbl = LookupTable::create(state); SET(meta, has_ivars, tbl); } @@ -287,26 +284,27 @@ namespace rubinius { return val; } - tbl = (LookupTable*)((NormalObject*)this)->instance_variables; + OBJECT ivars = ((NormalObject*)this)->instance_variables; /* Lazy creation of hash to store instance variables. */ - if(tbl->nil_p()) { - Tuple* tup = (Tuple*)Hash::csm_new(state); + if(ivars->nil_p()) { + Tuple* tup = Hash::csm_new(state); SET((NormalObject*)this, instance_variables, tup); Hash::csm_add(state, tup, sym, val); return val; } - if(kind_of<Tuple>(tbl)) { - if(Hash::csm_add(state, (Tuple*)tbl, sym, val) == Qtrue) { + if(Tuple* tup = try_as<Tuple>(ivars)) { + if(Hash::csm_add(state, tup, sym, val) == Qtrue) { return val; } /* csm_add said false, meaning there is no room. We convert the csm into a normal hash and use it from now on. */ - tbl = (LookupTable*)Hash::csm_into_lookuptable(state, (Tuple*)tbl); + tbl = Hash::csm_into_lookuptable(state, (Tuple*)tbl); SET((NormalObject*)this, instance_variables, tbl); } - tbl->store(state, sym, val); + + as<LookupTable>(ivars)->store(state, sym, val); return val; } @@ -323,4 +321,24 @@ namespace rubinius { void Object::cleanup(STATE) { state->om->find_type_info(this)->cleanup(this); } + + void Object::copy_flags(STATE, OBJECT source) { + this->obj_type = source->obj_type; + this->CanStoreIvars = source->CanStoreIvars; + this->StoresBytes = source->StoresBytes; + this->RequiresCleanup = source->RequiresCleanup; + this->IsBlockContext = source->IsBlockContext; + this->IsMeta = source->IsMeta; + } + + // 'virtual' methods. They dispatch to the object's TypeInfo + // object to perform the work. + OBJECT Object::get_field(STATE, size_t index) { + return state->om->type_info[obj_type]->get_field(state, this, index); + } + + void Object::set_field(STATE, size_t index, OBJECT val) { + state->om->type_info[obj_type]->set_field(state, this, index, val); + } + } vm/builtin_object.cpp @@ -42,7 +42,7 @@ namespace rubinius { GO(matchdata).set(state->new_class("MatchData", G(object), 0)); - state->add_type_info(new RegexpData::Info(G(regexpdata))); + state->add_type_info(new RegexpData::Info(RegexpData::type)); } char *Regexp::version(STATE) { vm/builtin_regexp.cpp @@ -1,7 +1,6 @@ #ifndef RBX_REGEXP_HPP #define RBX_REGEXP_HPP - namespace rubinius { class RegexpData : public BuiltinType { public: @@ -10,32 +9,20 @@ namespace rubinius { class Info : public TypeInfo { public: - Info(Class* cls) : TypeInfo(cls) { } + Info(object_type type) : TypeInfo(type) { } virtual void cleanup(OBJECT obj); }; }; - - class MatchData : public BuiltinType { - public: - const static size_t fields = 5; - const static object_type type = MatchDataType; - OBJECT instance_variables; - OBJECT source; - OBJECT regexp; - OBJECT full; - OBJECT region; - }; - class Regexp : public BuiltinType { public: const static size_t fields = 4; const static object_type type = RegexpType; - OBJECT instance_variables; - OBJECT source; - OBJECT data; - OBJECT names; + OBJECT __ivars__; // slot + String* source; // slot + RegexpData* data; // slot + Hash* names; // slot static void cleanup(STATE, OBJECT data); static void init(STATE); @@ -45,7 +32,34 @@ namespace rubinius { OBJECT options(STATE); OBJECT match_region(STATE, String* string, INTEGER start, INTEGER end, OBJECT forward); + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); + }; + + }; + + class MatchData : public BuiltinType { + public: + const static size_t fields = 5; + const static object_type type = MatchDataType; + + OBJECT __ivars__; // slot + String* source; // slot + Regexp* regexp; // slot + Tuple* full; // slot + Tuple* region; // slot + + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); + }; }; + } #endif vm/builtin_regexp.hpp @@ -10,10 +10,12 @@ namespace rubinius { class Selector : public BuiltinType { public: - static const size_t fields = 2; + static const size_t fields = 3; + static const object_type type = SelectorType; - OBJECT name; - Array* send_sites; + OBJECT __ivars__; // slot + SYMBOL name; // slot + Array* send_sites; // slot static void init(STATE); static Selector* create(STATE, OBJECT name); @@ -24,6 +26,13 @@ namespace rubinius { void clear(STATE); bool includes_p(STATE, SendSite* ss); + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); + }; + }; }; vm/builtin_selector.hpp @@ -52,7 +52,7 @@ namespace rubinius { bool HierarchyResolver::resolve(STATE, Message& msg) { Module* module = msg.lookup_from; OBJECT entry; - CompiledMethod::Visibility* vis; + MethodVisibility* vis; do { entry = module->method_table->fetch(state, msg.name); @@ -64,7 +64,7 @@ namespace rubinius { * (eg. undef_method) */ if(entry == Qfalse) return false; - vis = try_as<CompiledMethod::Visibility>(entry); + vis = try_as<MethodVisibility>(entry); /* If this was a private send, then we can handle use * any method seen. */ vm/builtin_sendsite.cpp @@ -45,7 +45,7 @@ namespace rubinius { size_t sz = size(state); hashval h = hash_str(bp, sz); - hash = Object::ui2n(state, h); + SET(this, hash, Object::ui2n(state, h)); return h; } @@ -76,8 +76,8 @@ namespace rubinius { } int String::string_equal_p(STATE, OBJECT a, OBJECT b) { - String* self = (String*)a; - String* other = (String*)b; + String* self = as<String>(a); + String* other = as<String>(b); if(self->bytes != other->bytes) return FALSE; if(strcmp(self->byte_address(state), other->byte_address(state))) { @@ -91,8 +91,8 @@ namespace rubinius { String* ns; ns = (String*)dup(state); - ns->shared = Qtrue; - shared = Qtrue; + SET(ns, shared, Qtrue); + SET(this, shared, Qtrue); state->om->set_class(ns, class_object(state)); @@ -100,8 +100,8 @@ namespace rubinius { } void String::unshare(STATE) { - data = data->dup(state); - shared = Qfalse; + SET(this, data, as<ByteArray>(data->dup(state))); + SET(this, shared, Qfalse); } String* String::append(STATE, String* other) { @@ -116,8 +116,8 @@ namespace rubinius { d2->bytes[new_size] = 0; num_bytes = Object::i2n(state, new_size); - data = d2; - hash = Qnil; + SET(this, data, d2); + SET(this, hash, Qnil); return this; } @@ -135,8 +135,8 @@ namespace rubinius { d2->bytes[new_size] = 0; num_bytes = Object::i2n(state, new_size); - data = d2; - hash = Qnil; + SET(this, data, d2); + SET(this, hash, Qnil); return this; } vm/builtin_string.cpp @@ -4,19 +4,20 @@ namespace rubinius { class String : public BuiltinType { public: - const static size_t fields = 6; + const static size_t fields = 7; const static object_type type = StringType; static bool is_a(OBJECT obj) { return obj->reference_p() && obj->obj_type == StringType; } - INTEGER num_bytes; - OBJECT characters; - OBJECT encoding; - OBJECT data; - OBJECT hash; - OBJECT shared; + OBJECT __ivars__; // slot + INTEGER num_bytes; // slot + INTEGER characters; // slot + OBJECT encoding; // slot + ByteArray* data; // slot + INTEGER hash; // slot + OBJECT shared; // slot static String* create(STATE, const char* str, size_t bytes = 0); static hashval hash_str(const unsigned char *bp, unsigned int sz); @@ -30,11 +31,6 @@ namespace rubinius { return num_bytes->n2i(); } - /* Allows the String object to be cast as a char* */ - operator const char *() { - return (const char*)(data->bytes); - } - /* TODO: since we're technically say it's ok to change this, we might * want to copy it first. */ operator char *() { @@ -55,6 +51,13 @@ namespace rubinius { String* add(STATE, String* other); String* add(STATE, char* other); + class Info : public TypeInfo { + public: + Info(object_type type) : TypeInfo(type) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); + }; + }; }; vm/builtin_string.hpp @@ -20,10 +20,10 @@ namespace rubinius { if(!size) size = std::strlen(str); hashval hash = String::hash_str((unsigned char*)str, size); - OBJECT ent = strings->find_entry(state, hash); + Tuple* ent = strings->find_entry(state, hash); /* If it wasn't present, use the longer, more correct version. */ - if(ent->nil_p() || ent == Qundef) { + if(!ent) { return lookup(state, String::create(state, str, size)); } vm/builtin_symbol.cpp @@ -15,10 +15,7 @@ namespace rubinius { } Task* Task::create(STATE, OBJECT recv, CompiledMethod* meth) { - Task* task = (Task*)state->new_struct(G(task), sizeof(Task)); - task->ip = 0; - task->sp = -1; - task->state = state; + Task* task = create(state); task->make_active(task->generate_context(recv, meth)); return task; } @@ -28,9 +25,16 @@ namespace rubinius { task->ip = 0; task->sp = -1; task->state = state; + SET(task, control_channel, Qnil); + SET(task, debug_channel, Qnil); + SET(task, active, Qnil); + return task; } + void Task::Info::mark(Task* obj) { + } + MethodContext* Task::generate_context(OBJECT recv, CompiledMethod* meth) { MethodContext* ctx = MethodContext::create(state); @@ -208,9 +212,9 @@ namespace rubinius { return (Executable*)Qnil; } - CompiledMethod::Visibility *vis; + MethodVisibility *vis; - vis = try_as<CompiledMethod::Visibility>(msg.method); + vis = try_as<MethodVisibility>(msg.method); if(vis) { return vis->method; } vm/builtin_task.cpp @@ -89,9 +89,9 @@ namespace rubinius { class Info : public TypeInfo { public: + Info(object_type type) : TypeInfo(type) { } virtual void mark(Task* obj); }; - }; } vm/builtin_task.hpp @@ -20,4 +20,18 @@ namespace rubinius { SET(thr, priority, Object::i2n(2)); return thr; } + + void Thread::boot_task(STATE) { + Task* task = Task::create(state); + SET(this, task, task); + } + + void Thread::set_top(STATE, OBJECT val) { + task->stack->put(state, task->sp, val); + } + + void Thread::sleep_for(STATE, Channel* chan) { + channel = chan; + set_ivar(state, state->symbol("@sleep"), Qtrue); + } } vm/builtin_thread.cpp @@ -7,13 +7,16 @@ namespace rubinius { const static size_t fields = 5; const static object_type type = ThreadType; + OBJECT ivars; Task* task; Channel* channel; FIXNUM priority; static void init(STATE); static Thread* create(STATE); + void boot_task(STATE); void sleep_for(STATE, Channel* chan); + void set_top(STATE, OBJECT val); }; class DeadLock : public Assertion { vm/builtin_thread.hpp @@ -75,7 +75,7 @@ namespace rubinius { ev.data = this; } - void Read::into_buffer(rubinius::IO::Buffer *buf, size_t bytes) { + void Read::into_buffer(rubinius::IOBuffer *buf, size_t bytes) { count = bytes; buffer.set(buf); } vm/event.cpp @@ -18,7 +18,7 @@ namespace rubinius { STATE; ObjectCallback* channel; size_t id; - TypedRoot<IO::Buffer*> buffer; + TypedRoot<IOBuffer*> buffer; Loop* loop; Event(STATE, ObjectCallback* chan); @@ -57,7 +57,7 @@ namespace rubinius { Read(STATE, ObjectCallback* chan, int fd); virtual ~Read() { } - void into_buffer(rubinius::IO::Buffer* buffer, size_t bytes); + void into_buffer(rubinius::IOBuffer* buffer, size_t bytes); virtual bool activated(); }; vm/event.hpp @@ -21,50 +21,9 @@ #define RBX_FFI_TYPE_STRPTR 17 #define RBX_FFI_TYPE_CHARARR 18 -#include <ffi.h> #include "prelude.hpp" #include "object.hpp" #include "message.hpp" -namespace rubinius { - class MemoryPointer : public BuiltinType { - public: - const static size_t fields = 0; - const static object_type type = MemPtrType; - - void* pointer; - - static MemoryPointer* create(STATE, void* ptr); - - OBJECT get_field(STATE, int offset, int type); - void set_field(STATE, int offset, int type, OBJECT val); - }; - - class NativeFunction : public Executable { - public: - struct ffi_stub { - ffi_cif cif; - size_t arg_count; - int *arg_types; - int ret_type; - void *ep; - }; - - static const size_t fields = 7; - OBJECT name; - String* file; - MemoryPointer* data; - - static void* find_symbol(STATE, OBJECT library, String* name); - - static size_t type_size(size_t type); - static NativeFunction* create(STATE, OBJECT name, int args); - void bind(STATE, int arg_count, int *arg_types, int ret_type, void* func); - static NativeFunction* bind(STATE, String* library, String* name, Array* args, OBJECT ret); - void **marshal_arguments(STATE, Message *msg); - OBJECT call(STATE, Message* msg); - }; - -} #endif vm/ffi.hpp @@ -49,9 +49,9 @@ namespace rubinius { entry->name = name; entry->module = mod; - if(kind_of<CompiledMethod::Visibility>(meth)) { - CompiledMethod::Visibility* vis; - vis = as<CompiledMethod::Visibility>(meth); + if(kind_of<MethodVisibility>(meth)) { + MethodVisibility* vis; + vis = as<MethodVisibility>(meth); if(vis->public_p(state)) { entry->is_public = true; vm/global_cache.hpp @@ -55,6 +55,7 @@ namespace rubinius { TypedRoot<Module*> vm; TypedRoot<Thread*> current_thread; TypedRoot<Task*> current_task; + TypedRoot<OBJECT> main; /* Leave this as the last data member always */ TypedRoot<Class*> special_classes[SPECIAL_CLASS_SIZE]; @@ -99,7 +100,8 @@ namespace rubinius { top_scope(&roots), on_gc_channel(&roots), vm(&roots), current_thread(&roots), - current_task(&roots) + current_task(&roots), + main(&roots) { } }; }; vm/globals.hpp @@ -72,7 +72,7 @@ class TestInstructions : public CxxTest::TestSuite { fd.puts "void #{meth}() {" fd.puts "Task* task = Task::create(state);" fd.puts "CompiledMethod* cm = CompiledMethod::create(state);" - fd.puts "cm->iseq = ISeq::create(state, 10);" + fd.puts "cm->iseq = InstructionSequence::create(state, 10);" fd.puts "cm->stack_size = Object::i2n(10);" fd.puts "MethodContext* ctx = task->generate_context(Qnil, cm);" fd.puts "task->make_active(ctx);" @@ -80,7 +80,7 @@ class TestInstructions : public CxxTest::TestSuite { fd.puts "Tuple* stack = task->stack; stack += 0;" fd.puts "task->literals = Tuple::create(state, 10);" fd.puts "opcode stream[100];" - fd.puts "stream[0] = ISeq::insn_#{ins.opcode};" + fd.puts "stream[0] = InstructionSequence::insn_#{ins.opcode};" fd.puts "#define run(val) task->execute_stream(stream)" fd.puts "#line #{line} \"instructions.rb\"" fd.puts code @@ -197,7 +197,7 @@ class TestInstructions : public CxxTest::TestSuite { end def generate_names - str = "const char *rubinius::ISeq::get_instruction_name(int op) {\n" + str = "const char *rubinius::InstructionSequence::get_instruction_name(int op) {\n" str << "static const char instruction_names[] = {\n" InstructionSet::OpCodes.each do |ins| str << " \"#{ins.opcode.to_s}\\0\"\n" @@ -852,88 +852,6 @@ CODE end # [Operation] - # Store a value into the specified object field - # [Format] - # \store_field - # [Stack Before] - # * field - # * value - # * object - # * ... - # [Stack After] - # * object - # * ... - # [Description] - # Overwrite the value of a particular field slot with the specified - # object. The object reference is left on the stack. - - def store_field - <<-CODE - t1 = stack_pop(); - t2 = stack_pop(); - t3 = stack_pop(); - size_t idx = (size_t)as<Fixnum>(t1)->n2i(); - check_bounds(t3, idx); - SET(t3, field[idx], t2); - stack_push(t3); - CODE - end - - def test_store_field - <<-CODE - Tuple* tup = Tuple::create(state, 3); - tup->put(state, 0, Qnil); - - stack->put(state, ++task->sp, tup); - stack->put(state, ++task->sp, Qtrue); - stack->put(state, ++task->sp, Object::i2n(0)); - - run(); - - TS_ASSERT_EQUALS(tup->at(0), Qtrue); - CODE - end - - # [Operation] - # Retrieve the value within the field of the specified object - # [Format] - # \fetch_field - # [Stack Before] - # * field - # * object - # * ... - # [Stack After] - # * value - # * ... - # [Description] - # Retrieve the object of the specified object field number. - - def fetch_field - <<-CODE - t1 = stack_pop(); - t2 = stack_pop(); - size_t index = as<Fixnum>(t1)->n2i(); - check_bounds(t2, index); - stack_push(t2->at(index)); - CODE - end - - def test_fetch_field - <<-CODE - Tuple* tup = Tuple::create(state, 3); - tup->put(state, 0, Qtrue); - - stack->put(state, ++task->sp, tup); - stack->put(state, ++task->sp, Object::i2n(0)); - - run(); - - TS_ASSERT_EQUALS(task->sp, 0); - TS_ASSERT_EQUALS(stack->at(task->sp), Qtrue); - CODE - end - - # [Operation] # Pushes a value from an object field onto the stack # [Format] # \push_my_field fld @@ -953,7 +871,7 @@ CODE def push_my_field <<-CODE next_int; - stack_push(self->at(_int)); + stack_push(self->get_field(state, _int)); CODE end @@ -965,10 +883,20 @@ CODE task->self = tup; stream[1] = (opcode)0; + + TS_ASSERT_THROWS(run(), std::runtime_error); + + Class* cls = state->new_class("Blah"); + + task->self = cls; + + stream[1] = (opcode)2; + + task->sp = -1; run(); TS_ASSERT_EQUALS(task->sp, 0); - TS_ASSERT_EQUALS(stack->at(task->sp), Qtrue); + TS_ASSERT_EQUALS(stack->at(task->sp), state->symbol("Blah")); CODE end @@ -2359,7 +2287,7 @@ CODE def test_send_method <<-CODE CompiledMethod* target = CompiledMethod::create(state); - target->iseq = ISeq::create(state, 0); + target->iseq = InstructionSequence::create(state, 0); target->total_args = Object::i2n(0); target->required_args = target->total_args; target->stack_size = Object::i2n(10); @@ -2451,7 +2379,7 @@ CODE def test_send_stack <<-CODE CompiledMethod* target = CompiledMethod::create(state); - target->iseq = ISeq::create(state, 0); + target->iseq = InstructionSequence::create(state, 0); target->total_args = Object::i2n(1); target->required_args = target->total_args; target->stack_size = Object::i2n(1); @@ -2521,7 +2449,7 @@ CODE def test_send_stack_with_block <<-CODE CompiledMethod* target = CompiledMethod::create(state); - target->iseq = ISeq::create(state, 0); + target->iseq = InstructionSequence::create(state, 0); target->total_args = Object::i2n(1); target->required_args = target->total_args; target->stack_size = Object::i2n(1); @@ -2612,7 +2540,7 @@ CODE def test_send_stack_with_splat <<-CODE CompiledMethod* target = CompiledMethod::create(state); - target->iseq = ISeq::create(state, 0); + target->iseq = InstructionSequence::create(state, 0); target->total_args = Object::i2n(2); target->required_args = target->total_args; target->stack_size = Object::i2n(2); @@ -2687,7 +2615,7 @@ CODE def test_send_super_stack_with_block <<-CODE CompiledMethod* target = CompiledMethod::create(state); - target->iseq = ISeq::create(state, 0); + target->iseq = InstructionSequence::create(state, 0); target->total_args = Object::i2n(1); target->required_args = target->total_args; target->stack_size = Object::i2n(1); @@ -2780,7 +2708,7 @@ CODE def test_send_super_stack_with_splat <<-CODE CompiledMethod* target = CompiledMethod::create(state); - target->iseq = ISeq::create(state, 0); + target->iseq = InstructionSequence::create(state, 0); target->total_args = Object::i2n(2); target->required_args = target->total_args; target->stack_size = Object::i2n(2); @@ -3340,16 +3268,15 @@ perform_no_ss_send: def shift_tuple <<-CODE - t1 = stack_pop(); - sassert(t1->reference_p()); + Tuple* tup = as<Tuple>(stack_pop()); if(NUM_FIELDS(t1) == 0) { - stack_push(t1); + stack_push(tup); stack_push(Qnil); } else { j = NUM_FIELDS(t1) - 1; - t3 = t1->at(0); + t3 = tup->at(0); Tuple* tup = Tuple::create(state, j); - tup->copy_from(state, as<Tuple>(t1), 1, j); + tup->copy_from(state, tup, 1, j); stack_push(t2); stack_push(t3); } vm/instructions.rb @@ -36,32 +36,45 @@ namespace rubinius { stream >> count; String* str = String::create(state, NULL, count + 1); - stream >> (char*)*str; + stream.get(); // read off newline + stream.read((char*)*str, count); + stream.get(); // read off newline return str; } void Marshaller::set_symbol(SYMBOL sym) { String* str = sym->to_str(state); - stream << "x" << endl << (char*)*str << endl; + stream << "x" << endl << str->size() << endl; + stream.write((char*)*str, str->size()) << endl; } SYMBOL UnMarshaller::get_symbol() { char data[1024]; + size_t count; - stream >> data; + stream >> count; + stream.get(); + stream.read(data, count + 1); + data[count] = 0; // clamp return G(symbols)->lookup(state, data); } void Marshaller::set_sendsite(SendSite* ss) { String* str = ss->name->to_str(state); - stream << "S" << endl << (char*)*str << endl; + stream << "S" << endl << str->size() << endl; + stream.write((char*)*str, str->size()) << endl; } SendSite* UnMarshaller::get_sendsite() { char data[1024]; - stream >> data; + size_t count; + + stream >> count; + stream.get(); + stream.read(data, count + 1); + data[count] = 0; // clamp SYMBOL sym = G(symbols)->lookup(state, data); @@ -123,17 +136,26 @@ namespace rubinius { return Float::create(state, val); } - void Marshaller::set_iseq(ISeq* iseq) { - stream << "i" << endl << iseq->body_in_bytes() << endl; - stream.write(iseq->bytes, iseq->body_in_bytes()) << endl; + void Marshaller::set_iseq(InstructionSequence* iseq) { + Tuple* ops = iseq->opcodes; + stream << "i" << endl << ops->field_count << endl; + for(size_t i = 0; i < ops->field_count; i++) { + stream << as<Fixnum>(ops->at(i))->to_nint() << endl; + } } - ISeq* UnMarshaller::get_iseq() { - size_t bytes; - stream >> bytes; + InstructionSequence* UnMarshaller::get_iseq() { + size_t count; + long op; + stream >> count; - ISeq* iseq = ISeq::create(state, bytes); - stream.read(iseq->bytes, bytes); + InstructionSequence* iseq = InstructionSequence::create(state, count); + Tuple* ops = iseq->opcodes; + + for(size_t i = 0; i < count; i++) { + stream >> op; + ops->put(state, i, Object::i2n(op)); + } iseq->post_marshal(state); @@ -141,11 +163,7 @@ namespace rubinius { } void Marshaller::set_cmethod(CompiledMethod* cm) { - stream << "M" << endl << 1 << endl; - - for(size_t i = 0; i < CompiledMethod::saved_fields; i++) { - marshal(cm->at(i)); - } + assert(0); } CompiledMethod* UnMarshaller::get_cmethod() { @@ -154,9 +172,20 @@ namespace rubinius { CompiledMethod* cm = CompiledMethod::create(state); - for(size_t i = 0; i < CompiledMethod::saved_fields; i++) { - SET(cm, field[i], unmarshal()); - } + SET(cm, __ivars__, unmarshal()); + SET(cm, primitive, unmarshal()); + SET(cm, name, unmarshal()); + SET(cm, iseq, unmarshal()); + SET(cm, stack_size, unmarshal()); + SET(cm, local_count, unmarshal()); + SET(cm, required_args, unmarshal()); + SET(cm, total_args, unmarshal()); + SET(cm, splat, unmarshal()); + SET(cm, literals, unmarshal()); + SET(cm, exceptions, unmarshal()); + SET(cm, lines, unmarshal()); + SET(cm, file, unmarshal()); + SET(cm, local_names, unmarshal()); cm->post_marshal(state); @@ -165,6 +194,7 @@ namespace rubinius { OBJECT UnMarshaller::unmarshal() { char code; + stream >> code; switch(code) { @@ -220,8 +250,8 @@ namespace rubinius { set_tuple(as<Tuple>(obj)); } else if(kind_of<Float>(obj)) { set_float(as<Float>(obj)); - } else if(kind_of<ISeq>(obj)) { - set_iseq(as<ISeq>(obj)); + } else if(kind_of<InstructionSequence>(obj)) { + set_iseq(as<InstructionSequence>(obj)); } else if(kind_of<CompiledMethod>(obj)) { set_cmethod(as<CompiledMethod>(obj)); } else { vm/marshal.cpp @@ -30,7 +30,7 @@ namespace rubinius { void set_tuple(Tuple* o); void set_bignum(Bignum* o); void set_float(Float* o); - void set_iseq(ISeq* o); + void set_iseq(InstructionSequence* o); void set_cmethod(CompiledMethod* o); }; @@ -52,7 +52,7 @@ namespace rubinius { Tuple* get_tuple(); Float* get_float(); - ISeq* get_iseq(); + InstructionSequence* get_iseq(); CompiledMethod* get_cmethod(); }; } vm/marshal.hpp @@ -76,6 +76,7 @@ to be a simple test for that bit pattern. #define REFERENCE_P(v) (TAG(v) == TAG_REF) #define INDEXED(obj) (REFERENCE_P(obj) && !obj->StoresBytes) +#define STORE_BYTES(obj) (REFERENCE_P(obj) && obj->StoresBytes) #define SIZE_OF_OBJECT ((size_t)(sizeof(OBJECT))) @@ -91,7 +92,13 @@ to be a simple test for that bit pattern. /* rubinius_object types, takes up 3 bits */ typedef enum { - ObjectType = 0, + InvalidType = 0, + NumericType , + IntegerType , + FalseType , + TrueType , + NilType , + ObjectType , MContextType , BContextType , ClassType , @@ -108,7 +115,6 @@ to be a simple test for that bit pattern. SymbolType , CMethodType , NMethodType , - NilType , BlockEnvType , TupleType , ArrayType , @@ -132,6 +138,8 @@ to be a simple test for that bit pattern. ExecutableType , CMVisibilityType, ListType , + ListNodeType , + NativeFuncType , LastObjectType // must remain at end } object_type; @@ -295,13 +303,6 @@ to be a simple test for that bit pattern. return zone == MatureObjectZone; } - OBJECT at(size_t index) { - if(field_count <= index) { - throw new ObjectBoundsExceeded(this, index); - } - return field[index]; - } - bool forwarded_p() { return Forwarded == 1; } @@ -352,6 +353,8 @@ to be a simple test for that bit pattern. return reference_p() && obj_type == type; } + OBJECT get_field(STATE, size_t index); + void set_field(STATE, size_t index, OBJECT val); void cleanup(STATE); bool kind_of_p(STATE, OBJECT cls); @@ -365,6 +368,10 @@ to be a simple test for that bit pattern. OBJECT get_ivar(STATE, OBJECT sym); OBJECT set_ivar(STATE, OBJECT sym, OBJECT val); + void copy_flags(STATE, OBJECT other); + void copy_ivars(STATE, OBJECT other); + void copy_metaclass(STATE, OBJECT other); + static const char* type_to_name(object_type type); }; @@ -374,30 +381,56 @@ to be a simple test for that bit pattern. /* Given builtin-class +T+, return true if +obj+ is of class +T+ */ template <class T> - static bool kind_of(OBJECT obj) { + static inline bool kind_of(OBJECT obj) { if(obj->reference_p()) { return obj->obj_type == T::type; } return false; } + /* Another version of kind_of that shouldn't be specialized for subtype + * compatibility. */ + template <class T> + static inline bool instance_of(OBJECT obj) { + if(obj->reference_p()) { + return obj->obj_type == T::type; + } + return false; + } + + template <> + static inline bool kind_of<Object>(OBJECT obj) { + return true; + } + + template <> + static inline bool kind_of<Class>(OBJECT obj) { + return obj->obj_type == ClassType || + obj->obj_type == MetaclassType || + obj->obj_type == IncModType; + } + + /* Used when casting between object types. * * Given builtin class +T+, return +obj+ cast as type +T*+. If * +obj+ is not of type +T+, throw's a TypeError exception. * */ template <class T> - static T* as(OBJECT obj) { + static inline T* as(OBJECT obj) { /* The 'obj &&' gives us additional saftey, checking for * NULL objects. */ if(obj && kind_of<T>(obj)) return (T*)obj; throw new TypeError(T::type, obj); } + template <> + static inline Object* as<Object>(OBJECT obj) { return obj; } + /* Similar to as<>, but returns NULL if the type is invalid. ONLY * use this when doing a conditional cast. */ template <class T> - static T* try_as(OBJECT obj) { + static inline T* try_as(OBJECT obj) { /* The 'obj &&' gives us additional saftey, checking for * NULL objects. */ if(obj && kind_of<T>(obj)) return (T*)obj; vm/object.hpp @@ -156,7 +156,10 @@ namespace rubinius { }; #define SET(obj, field, val) ({ \ - typeof(obj) _o = (obj); OBJECT _v = (val); _o->field = (typeof(_o->field))_v; state->om->write_barrier(_o, _v); }) + typeof(obj) _o = (obj); OBJECT _v = (val); \ + if(_v->nil_p()) { _o->field = (typeof(_o->field))Qnil; } else { \ + _o->field = as<typeof(*_o->field)>(_v); state->om->write_barrier(_o, _v); } }) + #define FREE(obj) free(obj) #define ALLOC_N(type, size) ((type*)calloc(size, sizeof(type))) vm/objectmemory.hpp @@ -67,7 +67,7 @@ namespace rubinius { cls->instance_fields = Object::i2n(Class::fields); cls->has_ivars = Qtrue; - cls->instance_type = Object::i2n(ClassType); + cls->set_object_type(ClassType); cls->obj_type = ClassType; GO(klass).set(cls); @@ -130,6 +130,7 @@ namespace rubinius { G(blokenv)->instance_type = Object::i2n(BlockEnvType); GO(staticscope).set(new_class(object, StaticScope::fields)); + G(staticscope)->set_object_type(StaticScopeType); bootstrap_symbol(); @@ -180,7 +181,7 @@ namespace rubinius { GO(task).set(new_class("Task", object, 0)); G(task)->instance_type = Object::i2n(TaskType); - GO(iseq).set(new_class("InstructionSequence", G(object), ISeq::fields)); + GO(iseq).set(new_class("InstructionSequence", G(object), InstructionSequence::fields)); G(iseq)->instance_type = Object::i2n(ISeqType); for(size_t i = 0; i < SPECIAL_CLASS_SIZE; i += 4) { @@ -202,7 +203,7 @@ namespace rubinius { Regexp::init(this); GO(cmethod_vis).set(new_class("CompiledMethod::Visibility", G(object), - CompiledMethod::Visibility::fields, G(cmethod))); + MethodVisibility::fields, G(cmethod))); G(cmethod_vis)->set_object_type(CMVisibilityType); Module* x = new_module("Rubinius"); @@ -219,6 +220,8 @@ namespace rubinius { init_ffi(); Task::init(state); Thread::init(state); + + TypeInfo::init(state); } void VM::bootstrap_symbol() { vm/objects.cpp @@ -5,434 +5,105 @@ #include "object.hpp" #include "type_info.hpp" +#include <iostream> + namespace rubinius { class BuiltinType : public Object { }; - - class NilClass : public BuiltinType { }; - /* NOTE(t1): - * This looks scary, but it's pretty simple. We're specializing - * the kind_of when passed NilClass to just test using nil_p(). - * This makes kind_of smarter, letting us use it everywhere for - * type checks. */ - template <> - static bool kind_of<NilClass>(OBJECT obj) { - return obj == Qnil; - } - - class TrueClass : public BuiltinType { }; - /* See t1 */ - template <> - static bool kind_of<TrueClass>(OBJECT obj) { - return obj == Qtrue; - } - - class FalseClass : public BuiltinType { }; - /* See t1 */ - template <> - static bool kind_of<FalseClass>(OBJECT obj) { - return obj == Qfalse; - } - - class Integer : public BuiltinType { - public: - inline native_int n2i(); - }; } -#include "builtin_bignum.hpp" +#include "builtin_immediates.hpp" namespace rubinius { - - class Fixnum : public Integer { + class Numeric : public BuiltinType { public: - const static size_t fields = 0; - const static object_type type = FixnumType; - - INTEGER add(STATE, FIXNUM other) { - return Object::i2n(state, n2i() + other->n2i()); - } - - INTEGER sub(STATE, FIXNUM other) { - return Object::i2n(state, n2i() - other->n2i()); - } - - INTEGER multiply(STATE, FIXNUM other) { - return Object::i2n(state, n2i() * other->n2i()); - } - - INTEGER divide(STATE, FIXNUM other) { - return Object::i2n(state, n2i() / other->n2i()); - } + static const object_type type = NumericType; - INTEGER modulo(STATE, FIXNUM other) { - return Object::i2n(state, n2i() % other->n2i()); - } - - native_int to_nint() { - return STRIP_TAG(this); - } - - }; - - typedef Fixnum* FIXNUM; - - /* See t1 */ - template <> - static bool kind_of<Integer>(OBJECT obj) { - return obj->fixnum_p() || (obj->reference_p() && obj->obj_type == Bignum::type); - } - - /* For some reason, the as<> template doesn't pick up the specialized kind_of<>, until - * we figure out why, just special as<> too. */ - template <> - static INTEGER as<Integer>(OBJECT obj) { - if(kind_of<Integer>(obj)) return (Integer*)obj; - throw new TypeError(obj->obj_type, obj, "can't be cast as an Integer"); - } - - template <> - static bool kind_of<Fixnum>(OBJECT obj) { - return obj->fixnum_p(); - } - - class StaticScope : public BuiltinType { + class Info : public TypeInfo { public: - const static size_t fields = 3; - const static object_type type = StaticScopeType; - - OBJECT instance_variables; - Module* module; - StaticScope* parent; - - static StaticScope* create(STATE); - }; - - native_int Integer::n2i() { - if(fixnum_p()) { - return ((FIXNUM)this)->to_nint(); - } - - return as<Bignum>(this)->to_nint(); - } - -}; - -namespace rubinius { - - class String; - class Hash; - class Tuple; - - class Symbol : public BuiltinType { - public: - const static size_t fields = 0; - const static object_type type = SymbolType; - - native_int index() { - return DATA_STRIP_TAG(this); - } - - static Symbol* from_index(STATE, size_t index) { - return (Symbol*)DATA_APPLY_TAG(index, DATA_TAG_SYMBOL); - } - - String* to_str(STATE); + Info(object_type type) : TypeInfo(type) { } + }; }; - /* See t1 */ - template <> - static bool kind_of<Symbol>(OBJECT obj) { - return obj->symbol_p(); - } + class Integer : public Numeric { + public: + static const object_type type = IntegerType; - typedef Symbol* SYMBOL; + inline native_int n2i(); - class SymbolTable : public BuiltinType { + class Info : public TypeInfo { public: - const static size_t fields = 3; - const static object_type type = SymbolTableType; - - OBJECT instance_variables; - Tuple* symbols; - Hash* strings; - - static SymbolTable* create(STATE); - SYMBOL lookup(STATE, const char* str, size_t size = 0); - SYMBOL lookup(STATE, String* str); - String* find_string(STATE, Symbol* sym); + Info(object_type type) : TypeInfo(type) { } + }; }; -}; - -namespace rubinius { - class Tuple : public BuiltinType { - public: - const static size_t fields = 0; - const static object_type type = TupleType; +} - static Tuple* create(STATE, size_t fields); - static Tuple* from(STATE, size_t fields, ...); - static bool is_a(OBJECT obj) { - return obj->obj_type == TupleType; - } +#include "builtin_bignum.hpp" +#include "builtin_fixnum.hpp" - OBJECT put(STATE, size_t idx, OBJECT val); - void copy_from(STATE, Tuple* other, int start, int end); +#include "builtin_staticscope.hpp" +#include "builtin_symbol.hpp" - }; -}; +#include "builtin_tuple.hpp" #include "builtin_hash.hpp" - namespace rubinius { class NormalObject : public BuiltinType { - public: + public: const static size_t fields = 1; const static object_type type = ObjectType; OBJECT instance_variables; - }; -}; - -#include "builtin_array.hpp" - -namespace rubinius { - class Exception : public BuiltinType { - public: - const static size_t fields = 3; - const static object_type type = ExceptionType; - - static Exception* create(STATE); - OBJECT instance_variables; - OBJECT message; - OBJECT context; - }; -}; - -namespace rubinius { - class CompiledMethod; - class MethodContext; - class BlockContext; - - class BlockEnvironment : public BuiltinType { + + class Info : public TypeInfo { public: - const static size_t fields = 5; - const static object_type type = BlockEnvType; - - OBJECT instance_variables; - MethodContext* home; - MethodContext* home_block; - OBJECT local_count; - CompiledMethod* method; - - static BlockEnvironment* under_context(STATE, CompiledMethod* cm, - MethodContext* parent, MethodContext* active); - - void call(STATE, size_t args); - BlockContext* create_context(STATE); + Info(object_type type) : TypeInfo(type) { } + }; }; }; +#include "builtin_array.hpp" +#include "builtin_exception.hpp" -namespace rubinius { - class IO : public BuiltinType { - public: - const static size_t fields = 4; - const static object_type type = IOType; - - OBJECT instance_variables; - OBJECT descriptor; - OBJECT buffer; - OBJECT mode; - - static void init(STATE); - static IO* create(STATE, int fd); - - class Buffer : public BuiltinType { - public: - const static size_t fields = 4; - const static object_type type = IOBufferType; - - OBJECT instance_variables; - OBJECT storage; - INTEGER total; - INTEGER used; - - static Buffer* create(STATE, size_t bytes); - void reset(STATE); - String* drain(STATE); - - char* byte_address() { - return (char*)storage->bytes; - } - - size_t left() { - return total->n2i() - used->n2i(); - } - - char* at_unused() { - char* start = (char*)storage->bytes; - start += used->n2i(); - return start; - } +#include "builtin_block_environment.hpp" - void read_bytes(size_t bytes) { - used = Object::i2n(used->n2i() + bytes); - } - - }; - }; -}; +#include "builtin_io.hpp" #include "builtin_regexp.hpp" +#include "builtin_bytearray.hpp" #include "builtin_string.hpp" -namespace rubinius { - class ByteArray : public BuiltinType { - public: - const static size_t fields = 0; - const static object_type type = ByteArrayType; - - static ByteArray* create(STATE, size_t bytes); - }; -}; +#include "builtin_lookuptable.hpp" +#include "builtin_methodtable.hpp" -namespace rubinius { - #define LOOKUPTABLE_MIN_SIZE 16 - class LookupTable : public BuiltinType { - public: - const static size_t fields = 4; - const static object_type type = LookupTableType; - - OBJECT instance_variables; - Tuple* values; - INTEGER bins; - INTEGER entries; - - /* Prototypes */ - static LookupTable* create(STATE, size_t sz = LOOKUPTABLE_MIN_SIZE); - void setup(STATE, size_t sz); - OBJECT store(STATE, OBJECT key, OBJECT val); - OBJECT fetch(STATE, OBJECT key); - OBJECT fetch(STATE, OBJECT key, bool* found); - LookupTable* dup(STATE); - static OBJECT entry_new(STATE, OBJECT key, OBJECT val); - static OBJECT entry_append(STATE, OBJECT top, OBJECT nxt); - void redistribute(STATE, size_t size); - OBJECT find_entry(STATE, OBJECT key); - OBJECT find(STATE, OBJECT key); - OBJECT remove(STATE, OBJECT key); - OBJECT has_key(STATE, OBJECT key); - static Array* collect(STATE, LookupTable* tbl, OBJECT (*action)(STATE, OBJECT)); - static OBJECT get_key(STATE, OBJECT entry); - Array* all_keys(STATE); - static OBJECT get_value(STATE, OBJECT entry); - Array* all_values(STATE); - static OBJECT get_entry(STATE, OBJECT entry); - OBJECT all_entries(STATE); - }; - - class MethodTable : public LookupTable { - public: - const static object_type type = MTType; - static MethodTable* create(STATE); - }; -}; - -namespace rubinius { - - class Executable : public BuiltinType { - public: - const static size_t fields = 4; - const static object_type type = ExecutableType; - - OBJECT instance_variables; - OBJECT primitive; - OBJECT required; - OBJECT serial; - }; - - - class ISeq; - class MemoryPointer; - class VMMethod; - - class CompiledMethod : public Executable { - public: - const static size_t fields = 20; - const static object_type type = CMethodType; - const static size_t saved_fields = 16; - - SYMBOL name; - ISeq* iseq; - FIXNUM stack_size; - FIXNUM local_count; - FIXNUM required_args; - FIXNUM total_args; - OBJECT splat; - Tuple* literals; - Tuple* exceptions; - Tuple* lines; - SYMBOL file; - SYMBOL path; - FIXNUM serial; - OBJECT bonus; - MemoryPointer* compiled; - StaticScope* scope; - - static CompiledMethod* create(STATE); - void post_marshal(STATE); - size_t number_of_locals(); - void set_scope(StaticScope*); - VMMethod* vmmethod(STATE); - - class Visibility : public BuiltinType { - public: - const static size_t fields = 3; - const static object_type type = CMVisibilityType; - - LookupTable* instance_variables; - SYMBOL visibility; - Executable* method; - - static Visibility* create(STATE); - - bool public_p(STATE) { - return visibility == G(sym_public); - } - - bool private_p(STATE) { - return visibility == G(sym_private); - } - - bool protected_p(STATE) { - return visibility == G(sym_protected); - } - }; - }; - - template <> - static bool kind_of<Executable>(OBJECT obj) { - if(obj->obj_type == Executable::type || - obj->obj_type == CompiledMethod::type) { - return true; - } - - return false; - } -}; +#include "builtin_executable.hpp" +#include "builtin_compiledmethod.hpp" #include "builtin_class.hpp" #include "builtin_contexts.hpp" #include "builtin_iseq.hpp" #include "builtin_float.hpp" + +namespace rubinius { + template <> + static bool kind_of<Numeric>(OBJECT obj) { + return obj->fixnum_p() || + (obj->reference_p() && ( + obj->obj_type == Bignum::type || + obj->obj_type == Float::type)); + } +} + #include "builtin_list.hpp" #include "builtin_selector.hpp" #include "builtin_task.hpp" #include "builtin_iseq.hpp" #include "builtin_channel.hpp" +#include "builtin_memorypointer.hpp" +#include "builtin_nativefunction.hpp" + #endif vm/objects.hpp @@ -11,6 +11,10 @@ #define G(whatever) state->globals.whatever.get() #define GO(whatever) state->globals.whatever +/* a noop identifier which goes in front of all declared typed slots. + * This aids in finding them via parsing */ +#define gc + namespace rubinius { typedef intptr_t native_int; vm/prelude.hpp @@ -10,6 +10,8 @@ class CCompile @flags = [] @linker = "gcc" @deps = {} + + Dir.mkdir ".deps" unless File.directory?(".deps") end attr_accessor :includes, :flags, :deps @@ -43,7 +45,19 @@ class CCompile objects = [] list.each do |name| - headers = extract_headers(name) + next if name == "../main.cpp" + deps = File.join(".deps", name.hash.to_s) + if File.exists?(deps) and File.mtime(deps) > File.mtime(name) + headers = Marshal.load(File.read(deps)) rescue nil + else + headers = nil + end + + unless headers + puts "DEP #{name}" + headers = extract_headers(name) + File.open(deps, "w") { |f| f << Marshal.dump(headers) } + end output = name.gsub(/\.[^.]+$/, ".o") objects << output @@ -57,6 +71,15 @@ class CCompile end def extract_headers(path) + includes = @includes.map { |i| "-I#{i}" }.join(" ") + data = `g++ #{includes} -MM -c #{path}`.split(/(?:\s+|\\\n)/) + data.shift + data.reject! { |s| s.size == 0 } + + return data + end + + def ruby_extract_headers(path) dir = File.dirname(path) h = File.read(path).scan(/#include\s*.([^\n]*)./).map do |i| File.join(dir, i[0]) @@ -131,7 +154,17 @@ file "../gen/task_instructions_switch.c" => "../instructions.rb" do x "cd ..; ruby instructions.rb" end +file "../gen/primitive_implementation.gen.cpp" => "../primitives.rb" do + puts "GEN primitives.rb" + x "cd ..; ruby primitives.rb" +end + file "../builtin_task.o" => "../gen/task_instructions_switch.c" +file "../primitives.o" => "../gen/primitive_implementation.gen.cpp" +file "../type_info.o" => "../gen/typechecks.gen.cpp" +file "../gen/typechecks.gen.cpp" => FileList["../builtin_*.hpp"] do + Rake::Task[:field_extract].invoke +end file "runner.cpp" => tests + objs do puts "GEN runner.cpp" @@ -146,10 +179,31 @@ file "runner" => "runner.o" do compiler.link "runner", :objects => objs + ["runner.o"], :libs => ex_libs end +file "../main.o" => "../main.cpp" do + compiler.compile "../main.cpp" +end + +file "../vm" => objs + ["../main.o"] do + puts "LD ../vm" + compiler.link "../vm", :objects => objs + ["../main.o"], :libs => ex_libs +end + task :test => "runner" do x "./runner" end +task :field_extract do + order = ["objects.hpp"] + File.open("../objects.hpp") do |f| + f.each_line do |line| + if /\#include "builtin_(.*)"/.match(line) + order << "builtin_#{$1}" + end + end + end + sh "cd ..; ruby field_extract.rb #{order.join(' ')}" +end + simple = objs + (compiler << "simple.cpp") task :simple => simple do vm/test/Rakefile @@ -2,6 +2,7 @@ #include "builtin_list.hpp" #include "vm.hpp" #include "objectmemory.hpp" +#include "event.hpp" #include <cxxtest/TestSuite.h> @@ -69,13 +70,65 @@ class TestChannel : public CxxTest::TestSuite { void test_receive_causes_thread_switch() { Thread* other = Thread::create(state); - Thread* waiter = Thread::create(state); + Thread* orig = G(current_thread); + + G(current_task)->stack = Tuple::create(state, 10); state->queue_thread(other); - state->activate_thread(waiter); - TS_ASSERT_EQUALS(G(current_thread), waiter); + chan->receive(state); + TS_ASSERT_EQUALS(G(current_thread), other); + TS_ASSERT_EQUALS(orig->get_ivar(state, state->symbol("@sleep")), Qtrue); + } + + void test_receive_causes_event_block() { + ChannelCallback cb(state, chan); + event::Timer* timer = new event::Timer(state, &cb, 0.2); + + Thread* orig = G(current_thread); + state->events->start(timer); + + G(current_task)->stack = Tuple::create(state, 10); + + TS_ASSERT(!state->wait_events); + chan->receive(state); + + TS_ASSERT_EQUALS(chan->waiting->locate(state, 0), G(current_thread)); + + TS_ASSERT(state->wait_events); + state->events->run_and_wait(); + TS_ASSERT(chan->waiting->empty_p()); + + TS_ASSERT_EQUALS(G(current_thread), orig); + TS_ASSERT_EQUALS(G(current_task)->sp, 0); + TS_ASSERT_EQUALS(G(current_task)->stack->at(0), Qnil) + } + + void test_receive_polls_events() { + ChannelCallback cb(state, chan); + event::Timer* timer = new event::Timer(state, &cb, 0.2); + + Thread* orig = G(current_thread); + state->events->start(timer); + + G(current_task)->stack = Tuple::create(state, 10); + + TS_ASSERT(!state->wait_events); + usleep(300000); + chan->receive(state); + TS_ASSERT(!state->wait_events); + + TS_ASSERT(chan->waiting->empty_p()); + + TS_ASSERT_EQUALS(G(current_thread), orig); + TS_ASSERT_EQUALS(G(current_task)->sp, 0); + TS_ASSERT_EQUALS(G(current_task)->stack->at(0), Qnil) + } + void test_has_readers_p() { + TS_ASSERT(!chan->has_readers_p()); + chan->waiting->append(state, G(current_thread)); + TS_ASSERT(chan->has_readers_p()); } }; vm/test/test_channel.hpp @@ -78,7 +78,7 @@ class TestEventLoop : public CxxTest::TestSuite { TestChannelObject chan(state); event::Read* read = new event::Read(state, &chan, fds[0]); - IO::Buffer *buf = IO::Buffer::create(state, 12); + IOBuffer *buf = IOBuffer::create(state, 12); read->into_buffer(buf, 1); TS_ASSERT_EQUALS(buf->used, Object::i2n(0)); vm/test/test_event.hpp @@ -16,6 +16,7 @@ class TestLookupTable : public CxxTest::TestSuite { tbl = LookupTable::create(&vm); TS_ASSERT_EQUALS(tbl->obj_type, LookupTableType); + TS_ASSERT_EQUALS(tbl->bins->n2i(), LOOKUPTABLE_MIN_SIZE); } void test_store_fetch() { @@ -67,11 +68,11 @@ class TestLookupTable : public CxxTest::TestSuite { tbl->store(state, k3, v3); TS_ASSERT_EQUALS(as<Integer>(tbl->entries)->n2i(), 3); - OBJECT entry = tbl->find_entry(state, k1); - TS_ASSERT(!entry->nil_p()); + Tuple* entry = tbl->find_entry(state, k1); + TS_ASSERT(entry); TS_ASSERT(!entry->at(2)->nil_p()); - TS_ASSERT_EQUALS(entry->at(2)->at(0), k2); + TS_ASSERT_EQUALS(as<Tuple>(entry->at(2))->at(0), k2); entry = tbl->find_entry(state, k3); TS_ASSERT(!entry->nil_p()); @@ -128,11 +129,11 @@ class TestLookupTable : public CxxTest::TestSuite { OBJECT k = Object::i2n(47); tbl->store(state, k, Qtrue); - OBJECT entry = tbl->find_entry(state, k); + Tuple* entry = tbl->find_entry(state, k); TS_ASSERT_EQUALS(k, entry->at(0)); entry = tbl->find_entry(state, Object::i2n(40)); - TS_ASSERT(entry->nil_p()); + TS_ASSERT(!entry); } void test_find() { vm/test/test_lookuptable.hpp @@ -54,12 +54,12 @@ public: void test_symbol() { mar->marshal(state->symbol("blah")); - TS_ASSERT_EQUALS(mar->sstream.str(), "x\nblah\n"); + TS_ASSERT_EQUALS(mar->sstream.str(), "x\n4\nblah\n"); } void test_sendsite() { mar->marshal(SendSite::create(state, state->symbol("blah"))); - TS_ASSERT_EQUALS(mar->sstream.str(), "S\nblah\n"); + TS_ASSERT_EQUALS(mar->sstream.str(), "S\n4\nblah\n"); } void test_array() { @@ -98,4 +98,12 @@ public: TS_ASSERT_EQUALS(mar->sstream.str(), std::string("d\n15.5\n")); } + void test_iseq() { + InstructionSequence* iseq = InstructionSequence::create(state, 1); + iseq->opcodes->put(state, 0, Object::i2n(0)); + + mar->marshal(iseq); + TS_ASSERT_EQUALS(mar->sstream.str(), std::string("i\n1\n0\n")); + } + }; vm/test/test_marshal.hpp @@ -35,7 +35,7 @@ class TestMessage : public CxxTest::TestSuite { CompiledMethod* create_cm() { CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->stack_size = Object::i2n(10); cm->total_args = Object::i2n(0); cm->required_args = cm->total_args; vm/test/test_message.hpp @@ -68,16 +68,16 @@ class TestObject : public CxxTest::TestSuite { } void test_metaclass() { - TS_ASSERT(MetaClass::is_a(G(object)->metaclass(state))); + TS_ASSERT(kind_of<MetaClass>(G(object)->metaclass(state))); TS_ASSERT_EQUALS(Qnil->metaclass(state), G(nil_class)); TS_ASSERT_EQUALS(Qtrue->metaclass(state), G(true_class)); TS_ASSERT_EQUALS(Qfalse->metaclass(state), G(false_class)); Tuple *tup = Tuple::create(state, 1); - TS_ASSERT(!MetaClass::is_a(tup->klass)); + TS_ASSERT(!kind_of<MetaClass>(tup->klass)); - TS_ASSERT(MetaClass::is_a(tup->metaclass(state))); - TS_ASSERT(MetaClass::is_a(tup->klass)); + TS_ASSERT(kind_of<MetaClass>(tup->metaclass(state))); + TS_ASSERT(kind_of<MetaClass>(tup->klass)); } void test_get_ivar() { vm/test/test_object.hpp @@ -112,10 +112,10 @@ class TestObjectMemory : public CxxTest::TestSuite { obj = new_obj; TS_ASSERT(om.young.current->contains_p(obj)); - obj3 = obj->at(0); + obj3 = obj->field[0]; TS_ASSERT(obj2 != obj3); - TS_ASSERT_EQUALS(obj2->at(0), Qtrue); + TS_ASSERT_EQUALS(obj2->field[0], Qtrue); } /* Could crash on failure */ @@ -202,8 +202,8 @@ class TestObjectMemory : public CxxTest::TestSuite { Roots roots(0); om.collect_young(roots); - TS_ASSERT(mature->at(0) != young); - TS_ASSERT_EQUALS(mature->at(0)->at(0), Qtrue); + TS_ASSERT(mature->field[0] != young); + TS_ASSERT_EQUALS(mature->field[0]->field[0], Qtrue); } void test_collect_young_promotes_objects() { @@ -249,7 +249,7 @@ class TestObjectMemory : public CxxTest::TestSuite { TS_ASSERT_EQUALS(young->age, 0); om.collect_young(roots); - TS_ASSERT_EQUALS(mature->at(0)->age, 1); + TS_ASSERT_EQUALS(mature->field[0]->age, 1); om.collect_young(roots); TS_ASSERT_EQUALS(om.remember_set->size(), 0); @@ -273,9 +273,9 @@ class TestObjectMemory : public CxxTest::TestSuite { obj = roots.front()->get(); - obj2 = obj->at(0); - TS_ASSERT_EQUALS(obj2, obj->at(1)); - TS_ASSERT_EQUALS(obj2, obj->at(2)); + obj2 = obj->field[0]; + TS_ASSERT_EQUALS(obj2, obj->field[1]); + TS_ASSERT_EQUALS(obj2, obj->field[2]); } void test_collect_young_copies_byte_bodies() { @@ -376,9 +376,9 @@ class TestObjectMemory : public CxxTest::TestSuite { om.collect_mature(roots); young = roots.front()->get(); - mature = young->at(0); + mature = young->field[0]; - TS_ASSERT_EQUALS(mature->at(0), young); + TS_ASSERT_EQUALS(mature->field[0], young); } void test_collect_young_stops_at_already_marked_objects() { @@ -399,10 +399,10 @@ class TestObjectMemory : public CxxTest::TestSuite { om.collect_young(roots); obj = roots.front()->get(); - obj2 = obj->at(0); + obj2 = obj->field[0]; - TS_ASSERT_EQUALS(obj2->at(0), obj); - TS_ASSERT_EQUALS(obj2->at(1), Qtrue); + TS_ASSERT_EQUALS(obj2->field[0], obj); + TS_ASSERT_EQUALS(obj2->field[1], Qtrue); } void test_collect_young_tells_objectmemory_about_collection() { vm/test/test_objectmemory.hpp @@ -30,8 +30,9 @@ class TestObjects : public CxxTest::TestSuite { void test_class() { Class *cls; - cls = (Class*)G(klass); - TS_ASSERT_EQUALS(cls->class_object(state), cls); + cls = G(klass); + Class* o = cls->class_object(state); + TS_ASSERT_EQUALS(cls, o); TS_ASSERT_EQUALS(cls->superclass, G(module)); check_const(klass, "Class"); } @@ -42,7 +43,7 @@ class TestObjects : public CxxTest::TestSuite { cls = (Class*)G(klass); meta = (MetaClass*)cls->klass; - TS_ASSERT(MetaClass::is_a(G(object)->klass)); + TS_ASSERT(kind_of<MetaClass>(G(object)->klass)); TS_ASSERT(kind_of<LookupTable>(meta->method_table)); TS_ASSERT(kind_of<LookupTable>(meta->constants)); } vm/test/test_objects.hpp @@ -89,7 +89,7 @@ class TestRegexp : public CxxTest::TestSuite { TS_ASSERT_EQUALS(as<Integer>(matches->full->at(1))->n2i(), 2); TS_ASSERT_EQUALS(matches->region->field_count, 1); - TS_ASSERT_EQUALS(as<Integer>(matches->region->at(0)->at(0))->n2i(), 1); - TS_ASSERT_EQUALS(as<Integer>(matches->region->at(0)->at(1))->n2i(), 2); + TS_ASSERT_EQUALS(as<Integer>(as<Tuple>(matches->region->at(0))->at(0))->n2i(), 1); + TS_ASSERT_EQUALS(as<Integer>(as<Tuple>(matches->region->at(0))->at(1))->n2i(), 2); } }; vm/test/test_regexp.hpp @@ -23,7 +23,7 @@ class TestTask : public CxxTest::TestSuite { CompiledMethod* create_cm() { CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->stack_size = Object::i2n(10); cm->total_args = Object::i2n(0); cm->required_args = cm->total_args; @@ -456,7 +456,7 @@ class TestTask : public CxxTest::TestSuite { Task* task = Task::create(state, Qnil, cm); - CompiledMethod::Visibility* vis = CompiledMethod::Visibility::create(state); + MethodVisibility* vis = MethodVisibility::create(state); vis->method = cm; vis->visibility = G(sym_private); @@ -473,7 +473,7 @@ class TestTask : public CxxTest::TestSuite { Task* task = Task::create(state, Qnil, cm); - CompiledMethod::Visibility* vis = CompiledMethod::Visibility::create(state); + MethodVisibility* vis = MethodVisibility::create(state); vis->method = cm; vis->visibility = G(sym_private); @@ -571,7 +571,7 @@ class TestTask : public CxxTest::TestSuite { SET(cs, parent, ps); CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->stack_size = Object::i2n(1); Task* task = Task::create(state, Qnil, cm); @@ -612,7 +612,7 @@ class TestTask : public CxxTest::TestSuite { SET(child, superclass, inc); CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->stack_size = Object::i2n(1); Task* task = Task::create(state, Qnil, cm); @@ -641,7 +641,7 @@ class TestTask : public CxxTest::TestSuite { G(object)->set_const(state, "Age", Object::i2n(28)); CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->stack_size = Object::i2n(1); Task* task = Task::create(state, Qnil, cm); @@ -662,7 +662,7 @@ class TestTask : public CxxTest::TestSuite { ps->parent = (StaticScope*)Qnil; CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->stack_size = Object::i2n(1); Task* task = Task::create(state, Qnil, cm); @@ -681,7 +681,7 @@ class TestTask : public CxxTest::TestSuite { ps->parent = (StaticScope*)Qnil; CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->stack_size = Object::i2n(1); Task* task = Task::create(state, Qnil, cm); @@ -701,7 +701,7 @@ class TestTask : public CxxTest::TestSuite { thrown = true; } - TS_ASSERT(thrown); + TS_ASSERT(!thrown); } void test_current_module() { @@ -712,7 +712,7 @@ class TestTask : public CxxTest::TestSuite { ps->parent = (StaticScope*)Qnil; CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->stack_size = Object::i2n(1); Task* task = Task::create(state, Qnil, cm); @@ -729,7 +729,7 @@ class TestTask : public CxxTest::TestSuite { ps->parent = (StaticScope*)Qnil; CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->stack_size = Object::i2n(1); Task* task = Task::create(state, Qnil, cm); @@ -752,7 +752,7 @@ class TestTask : public CxxTest::TestSuite { ps->parent = (StaticScope*)Qnil; CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->stack_size = Object::i2n(1); Task* task = Task::create(state, Qnil, cm); @@ -775,7 +775,7 @@ class TestTask : public CxxTest::TestSuite { ps->parent = (StaticScope*)Qnil; CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->stack_size = Object::i2n(1); Task* task = Task::create(state, Qnil, cm); @@ -796,7 +796,7 @@ class TestTask : public CxxTest::TestSuite { ps->parent = (StaticScope*)Qnil; CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->stack_size = Object::i2n(1); Task* task = Task::create(state, Qnil, cm); @@ -811,7 +811,7 @@ class TestTask : public CxxTest::TestSuite { void test_raise_exception() { CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->total_args = Object::i2n(0); cm->stack_size = Object::i2n(1); cm->exceptions = Tuple::from(state, 1, @@ -847,7 +847,7 @@ class TestTask : public CxxTest::TestSuite { void test_raise_exception_into_sender() { CompiledMethod* cm = CompiledMethod::create(state); - cm->iseq = ISeq::create(state, 40); + cm->iseq = InstructionSequence::create(state, 40); cm->stack_size = Object::i2n(1); cm->exceptions = Tuple::from(state, 1, Tuple::from(state, 3, Object::i2n(0), Object::i2n(3), Object::i2n(5))); vm/test/test_task.hpp @@ -5,6 +5,8 @@ #include <iostream> #include <sstream> + + using namespace rubinius; class StringUnMarshaller : public UnMarshaller { @@ -30,6 +32,23 @@ public: delete mar; } + bool tuple_equals(Tuple* x, Tuple* y) { + if(x->field_count != y->field_count) return false; + for(size_t i = 0; i < x->field_count; i++) { + OBJECT x1 = x->at(i); + OBJECT y1 = y->at(i); + + if(kind_of<Tuple>(x1)) { + if(!tuple_equals(as<Tuple>(x1), as<Tuple>(y1))) return false; + } else { + if(x1 != y1) return false; + } + } + + return true; + } + + void test_init() { mar->sstream.str(std::string("I\n3\n")); OBJECT obj = mar->unmarshal(); @@ -48,7 +67,7 @@ public: } void test_symbol() { - mar->sstream.str(std::string("x\nblah\n")); + mar->sstream.str(std::string("x\n4\nblah\n")); OBJECT obj = mar->unmarshal(); TS_ASSERT(obj->symbol_p()); @@ -56,15 +75,16 @@ public: } void test_sendsite() { - mar->sstream.str(std::string("S\nblah\n")); + mar->sstream.str(std::string("S\n4\nblah\n")); OBJECT obj = mar->unmarshal(); TS_ASSERT(kind_of<SendSite>(obj)); + TS_ASSERT_EQUALS(as<SendSite>(obj)->name, state->symbol("blah")); } void test_array() { - mar->sstream.str(std::string("A\n3\nI\n1\nx\nfoo\ns\n3\nblah\n")); + mar->sstream.str(std::string("A\n3\nI\n1\nx\n3\nfoo\ns\n4\nblah\n")); OBJECT obj = mar->unmarshal(); TS_ASSERT(kind_of<Array>(obj)); @@ -103,4 +123,48 @@ public: TS_ASSERT_EQUALS(flt->val, 15.5); } + void test_iseq() { + mar->sstream.str(std::string("i\n1\n0\n")); + + OBJECT obj = mar->unmarshal(); + + TS_ASSERT(kind_of<InstructionSequence>(obj)); + + InstructionSequence* seq = as<InstructionSequence>(obj); + + TS_ASSERT(kind_of<Tuple>(seq->opcodes)); + + TS_ASSERT_EQUALS(seq->opcodes->field_count, 1); + + TS_ASSERT_EQUALS(seq->opcodes->at(0), Object::i2n(0)); + } + + void test_cmethod() { + std::string str = "M\n1\nn\nx\n4\nblah\nx\n4\ntest\ni\n1\n0\nI\n10\nI\n0\nI\n0\nI\n0\nn\np\n2\nI\n1\nI\n2\nn\np\n1\np\n3\nI\n0\nI\n1\nI\n1\nx\n8\nnot_real\np\n1\nx\n4\nblah\n"; + mar->sstream.str(str); + + OBJECT obj = mar->unmarshal(); + + TS_ASSERT(kind_of<CompiledMethod>(obj)); + + CompiledMethod* cm = as<CompiledMethod>(obj); + + TS_ASSERT_EQUALS(cm->__ivars__, Qnil); + TS_ASSERT_EQUALS(cm->primitive, state->symbol("blah")); + TS_ASSERT_EQUALS(cm->name, state->symbol("test")); + TS_ASSERT(tuple_equals(cm->iseq->opcodes, Tuple::from(state, 1, Object::i2n(0)))); + TS_ASSERT_EQUALS(cm->stack_size, Object::i2n(10)); + TS_ASSERT_EQUALS(cm->local_count, Object::i2n(0)); + TS_ASSERT_EQUALS(cm->required_args, Object::i2n(0)); + TS_ASSERT_EQUALS(cm->total_args, Object::i2n(0)); + TS_ASSERT_EQUALS(cm->splat, Qnil); + TS_ASSERT(tuple_equals(cm->literals, Tuple::from(state, 2, Object::i2n(1), Object::i2n(2)))); + TS_ASSERT_EQUALS(cm->exceptions, Qnil); + TS_ASSERT(tuple_equals(cm->lines, Tuple::from(state, 1, + Tuple::from(state, 3, Object::i2n(0), Object::i2n(1), Object::i2n(1))))); + + TS_ASSERT_EQUALS(cm->file, state->symbol("not_real")); + TS_ASSERT(tuple_equals(cm->local_names, Tuple::from(state, 1, state->symbol("blah")))); + } + }; vm/test/test_unmarshal.hpp @@ -13,7 +13,7 @@ class TestVM : public CxxTest::TestSuite { VM *state; void setUp() { - state = new VM(1024); + state = new VM(); } void tearDown() { @@ -36,6 +36,7 @@ class TestVM : public CxxTest::TestSuite { } void test_globals() { - TS_ASSERT_EQUALS(state->globals.roots.size(), 120); + TS_ASSERT_EQUALS(state->globals.roots.size(), 121); } + }; vm/test/test_vm.hpp @@ -1,9 +1,18 @@ +#include "builtin.hpp" #include "type_info.hpp" -#include "objects.hpp" namespace rubinius { - TypeInfo::TypeInfo(Class *cls) { - type = (object_type)cls->instance_type->n2i(); + TypeInfo::TypeInfo(object_type type) : type(type) { state = NULL; } + + void TypeInfo::set_field(STATE, OBJECT target, size_t index, OBJECT val) { + throw std::runtime_error("field access denied"); + } + + OBJECT TypeInfo::get_field(STATE, OBJECT target, size_t index) { + throw std::runtime_error("unable to access field"); + } + +#include "gen/typechecks.gen.cpp" } vm/type_info.cpp @@ -4,20 +4,30 @@ #include "prelude.hpp" #include "object.hpp" +#include <map> +#include <stdexcept> + namespace rubinius { class VM; class Class; /* TypeInfo contains varies operations that are registered by types */ class TypeInfo { - public: + public: + + typedef std::map<native_int, long> Slots; + VM* state; object_type type; + Slots slots; - TypeInfo(Class* cls); + static void init(STATE); + TypeInfo(object_type type); virtual ~TypeInfo() { } virtual void cleanup(OBJECT obj) { } virtual void mark(OBJECT obj) { } + virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val); + virtual OBJECT get_field(STATE, OBJECT target, size_t index); }; } vm/type_info.hpp @@ -4,13 +4,17 @@ #include "event.hpp" #include "global_cache.hpp" +#include <iostream> + namespace rubinius { - VM::VM(size_t bytes) { + VM::VM(size_t bytes) : wait_events(false) { om = new ObjectMemory(bytes); bootstrap_ontology(); events = new event::Loop(EVFLAG_FORKCHECK); global_cache = new GlobalCache; + + boot_threads(); } VM::~VM() { @@ -19,6 +23,13 @@ namespace rubinius { delete global_cache; } + void VM::boot_threads() { + Thread* thr = Thread::create(this); + thr->boot_task(this); + + activate_thread(thr); + } + OBJECT VM::new_object(Class *cls) { return om->new_object(cls, cls->instance_fields->n2i()); } @@ -54,7 +65,26 @@ namespace rubinius { } void VM::run_best_thread() { - throw new DeadLock("no runnable threads, present or future."); + Thread* next = NULL; + + events->poll(); + + for(size_t i = 0; i < globals.scheduled_threads->field_count; i++) { + List* lst = as<List>(globals.scheduled_threads->at(i)); + if(lst->empty_p()) continue; + next = as<Thread>(lst->shift(this)); + } + + if(!next) { + if(events->num_of_events() == 0) { + throw new DeadLock("no runnable threads, present or future."); + } + + wait_events = true; + return; + } + + activate_thread(next); } void VM::return_value(OBJECT val) { @@ -70,4 +100,31 @@ namespace rubinius { globals.current_thread.set(thread); globals.current_task.set(thread->task); } + + OBJECT VM::current_block() { + return globals.current_task->active->block; + } + + void VM::raise_from_errno(char* msg) { + + } + + void VM::inspect(OBJECT obj) { + if(obj->symbol_p()) { + String* str = as<Symbol>(obj)->to_str(this); + std::cout << "<Symbol :" << (char*)*str << ">" << std::endl; + } else if(obj->fixnum_p()) { + std::cout << "<Fixnum " << as<Fixnum>(obj)->to_nint() << ">" << std::endl; + } else { + std::cout << "<Object: " << (void*)obj << ">" << std::endl; + } + } + + void VM::set_const(const char* name, OBJECT val) { + globals.object->set_const(this, (char*)name, val); + } + + void VM::set_const(Module* mod, const char* name, OBJECT val) { + mod->set_const(this, (char*)name, val); + } }; vm/vm.cpp @@ -6,6 +6,8 @@ namespace rubinius { + class Exception; + namespace event { class Loop; } @@ -20,6 +22,8 @@ namespace rubinius { event::Loop* events; GlobalCache* global_cache; + bool wait_events; + static const size_t default_bytes = 10240; /* Inline methods */ @@ -30,6 +34,7 @@ namespace rubinius { void bootstrap_ontology(); void bootstrap_symbol(); void bootstrap_exceptions(); + void boot_threads(); OBJECT new_object(Class* cls); Class* new_basic_class(OBJECT sup, size_t fields); @@ -52,6 +57,14 @@ namespace rubinius { void run_best_thread(); void queue_thread(Thread* thread); void activate_thread(Thread* thread); + void raise_from_errno(char* reason); + void raise_exception(Exception* exc); + Exception* new_exception(Class* cls, char* msg); + OBJECT current_block(); + + void inspect(OBJECT obj); + void set_const(const char* name, OBJECT val); + void set_const(Module* mod, const char* name, OBJECT val); }; }; vm/vm.hpp @@ -1,13 +1,13 @@ #include "objects.hpp" namespace rubinius { - VMMethod::VMMethod(CompiledMethod* meth) { - size_t total = meth->iseq->instructions->field_count; + VMMethod::VMMethod(CompiledMethod* meth) : original(meth) { + total = meth->iseq->opcodes->field_count; opcodes = new opcode[total]; for(size_t index = 0; index < total; index++) { - OBJECT val = meth->iseq->instructions->at(index); + OBJECT val = meth->iseq->opcodes->at(index); if(val->nil_p()) { opcodes[index] = 0; } else { @@ -23,4 +23,21 @@ namespace rubinius { VMMethod::~VMMethod() { delete[] opcodes; } + + void VMMethod::specialize(TypeInfo* ti) { + for(size_t i = 0; i < total; i++) { + opcode op = opcodes[i]; + + if(op == InstructionSequence::insn_push_ivar) { + native_int idx = opcodes[i + 1]; + native_int sym = as<Symbol>(original->literals->at(idx))->index(); + + TypeInfo::Slots::iterator it = ti->slots.find(sym); + if(it != ti->slots.end()) { + opcodes[i] = InstructionSequence::insn_push_my_field; + opcodes[++i] = it->second; + } + } + } + } } vm/vmmethod.cpp @@ -10,11 +10,14 @@ namespace rubinius { static instlocation* instructions; opcode* opcodes; + size_t total; CompiledMethod* original; VMMethod(CompiledMethod* meth); VMMethod(size_t fields); ~VMMethod(); + + void specialize(TypeInfo* ti); }; }; vm/vmmethod.hpp runtime/stable/bootstrap.rba runtime/stable/compiler.rba runtime/stable/core.rba runtime/stable/loader.rbc runtime/stable/platform.rba 611cd7440cacf3fa3c730f5093dc66e3f8e33d2e Evan Phoenix ephoenix@engineyard.com http://github.com/evanphx/rubinius/commit/feb91b43f113f8dc3b5e28c569cabc0a9c3d508c feb91b43f113f8dc3b5e28c569cabc0a9c3d508c 2008-05-07T18:05:09-07:00 2008-05-07T18:05:09-07:00 Tons of stuff (too much probably) 8fc9bbf14c77c67c4d0726c48eb93c3a27ed69a5 Evan Phoenix ephoenix@engineyard.com