moved write_barrier inline function impls to vm.hpp

diff --git a/vm/master.hpp b/vm/master.hpp
index 2f9b19d12bf0f91b4650b4559f0b5f7916694e81..0b3bf7b47411855dc3e32422712d9f57ec7260db 100755 (executable)
--- a/vm/master.hpp
+++ b/vm/master.hpp
@@ -47,9 +47,9 @@
 #include "bignumint.hpp"
 #include "bignum.hpp"
 #include "code_block.hpp"
-#include "vm.hpp"
 #include "data_heap.hpp"
 #include "write_barrier.hpp"
+#include "vm.hpp"
 #include "data_gc.hpp"
 #include "local_roots.hpp"
 #include "generic_arrays.hpp"

diff --git a/vm/vm.hpp b/vm/vm.hpp
index 2c52ffcf5dc0933c8b112bcf7584535ec43a312b..cfb18d2036734bf9834db392804f45839ebaa7f3 100644 (file)
--- a/vm/vm.hpp
+++ b/vm/vm.hpp
@@ -362,7 +362,6 @@ struct factorvm {
        inline cell allot_float(double n);
        inline bignum *float_to_bignum(cell tagged);
        inline double bignum_to_float(cell tagged);
-       // next method here:
        
        //io
        void init_c_io();
@@ -580,4 +579,106 @@ struct factorvm {
 
 extern factorvm *vm;
 
+
+// write_barrier.hpp
+
+inline card *factorvm::addr_to_card(cell a)
+{
+       return (card*)(((cell)(a) >> card_bits) + cards_offset);
+}
+
+inline card *addr_to_card(cell a)
+{
+       return vm->addr_to_card(a);
+}
+
+inline cell factorvm::card_to_addr(card *c)
+{
+       return ((cell)c - cards_offset) << card_bits;
+}
+
+inline cell card_to_addr(card *c)
+{
+       return vm->card_to_addr(c);
+}
+
+inline cell factorvm::card_offset(card *c)
+{
+       return *(c - (cell)data->cards + (cell)data->allot_markers);
+}
+
+inline cell card_offset(card *c)
+{
+       return vm->card_offset(c);
+}
+
+inline card_deck *factorvm::addr_to_deck(cell a)
+{
+       return (card_deck *)(((cell)a >> deck_bits) + decks_offset);
+}
+
+inline card_deck *addr_to_deck(cell a)
+{
+       return vm->addr_to_deck(a);
+}
+
+inline cell factorvm::deck_to_addr(card_deck *c)
+{
+       return ((cell)c - decks_offset) << deck_bits;
+}
+
+inline cell deck_to_addr(card_deck *c)
+{
+       return vm->deck_to_addr(c);
+}
+
+inline card *factorvm::deck_to_card(card_deck *d)
+{
+       return (card *)((((cell)d - decks_offset) << (deck_bits - card_bits)) + cards_offset);
+}
+
+inline card *deck_to_card(card_deck *d)
+{
+       return vm->deck_to_card(d);
+}
+
+inline card *factorvm::addr_to_allot_marker(object *a)
+{
+       return (card *)(((cell)a >> card_bits) + allot_markers_offset);
+}
+
+inline card *addr_to_allot_marker(object *a)
+{
+       return vm->addr_to_allot_marker(a);
+}
+
+/* the write barrier must be called any time we are potentially storing a
+pointer from an older generation to a younger one */
+inline void factorvm::write_barrier(object *obj)
+{
+       *addr_to_card((cell)obj) = card_mark_mask;
+       *addr_to_deck((cell)obj) = card_mark_mask;
+}
+
+inline void write_barrier(object *obj)
+{
+       return vm->write_barrier(obj);
+}
+
+/* we need to remember the first object allocated in the card */
+inline void factorvm::allot_barrier(object *address)
+{
+       card *ptr = addr_to_allot_marker(address);
+       if(*ptr == invalid_allot_marker)
+               *ptr = ((cell)address & addr_card_mask);
+}
+
+inline void allot_barrier(object *address)
+{
+       return vm->allot_barrier(address);
+}
+
+// next method here:
+
+
 }

diff --git a/vm/write_barrier.hpp b/vm/write_barrier.hpp
index e874600b24b864363a9ac8e268118b5432f5ce82..b45573b1269178cc02092cb04359c980466ae81c 100755 (executable)
--- a/vm/write_barrier.hpp
+++ b/vm/write_barrier.hpp
@@ -22,110 +22,13 @@ static const cell card_bits = 8;
 static const cell card_size = (1<<card_bits);
 static const cell addr_card_mask = (card_size-1);
 
-inline card *factorvm::addr_to_card(cell a)
-{
-       return (card*)(((cell)(a) >> card_bits) + cards_offset);
-}
-
-inline card *addr_to_card(cell a)
-{
-       return vm->addr_to_card(a);
-}
-
-inline cell factorvm::card_to_addr(card *c)
-{
-       return ((cell)c - cards_offset) << card_bits;
-}
-
-inline cell card_to_addr(card *c)
-{
-       return vm->card_to_addr(c);
-}
-
-inline cell factorvm::card_offset(card *c)
-{
-       return *(c - (cell)data->cards + (cell)data->allot_markers);
-}
-
-inline cell card_offset(card *c)
-{
-       return vm->card_offset(c);
-}
 
 typedef u8 card_deck;
 
 static const cell deck_bits = (card_bits + 10);
 static const cell deck_size = (1<<deck_bits);
 static const cell addr_deck_mask = (deck_size-1);
-
-inline card_deck *factorvm::addr_to_deck(cell a)
-{
-       return (card_deck *)(((cell)a >> deck_bits) + decks_offset);
-}
-
-inline card_deck *addr_to_deck(cell a)
-{
-       return vm->addr_to_deck(a);
-}
-
-inline cell factorvm::deck_to_addr(card_deck *c)
-{
-       return ((cell)c - decks_offset) << deck_bits;
-}
-
-inline cell deck_to_addr(card_deck *c)
-{
-       return vm->deck_to_addr(c);
-}
-
-inline card *factorvm::deck_to_card(card_deck *d)
-{
-       return (card *)((((cell)d - decks_offset) << (deck_bits - card_bits)) + cards_offset);
-}
-
-inline card *deck_to_card(card_deck *d)
-{
-       return vm->deck_to_card(d);
-}
-
 static const cell invalid_allot_marker = 0xff;
-
 extern cell allot_markers_offset;
 
-inline card *factorvm::addr_to_allot_marker(object *a)
-{
-       return (card *)(((cell)a >> card_bits) + allot_markers_offset);
-}
-
-inline card *addr_to_allot_marker(object *a)
-{
-       return vm->addr_to_allot_marker(a);
-}
-
-/* the write barrier must be called any time we are potentially storing a
-pointer from an older generation to a younger one */
-inline void factorvm::write_barrier(object *obj)
-{
-       *addr_to_card((cell)obj) = card_mark_mask;
-       *addr_to_deck((cell)obj) = card_mark_mask;
-}
-
-inline void write_barrier(object *obj)
-{
-       return vm->write_barrier(obj);
-}
-
-/* we need to remember the first object allocated in the card */
-inline void factorvm::allot_barrier(object *address)
-{
-       card *ptr = addr_to_allot_marker(address);
-       if(*ptr == invalid_allot_marker)
-               *ptr = ((cell)address & addr_card_mask);
-}
-
-inline void allot_barrier(object *address)
-{
-       return vm->allot_barrier(address);
-}
-
 }