steve
/
factor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

removed a bunch of superflous blank lines

db4
Phil Dawes 2009-09-23 18:25:10 +01:00
parent 46bab62689
commit e566656e46
36 changed files with 0 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
vm/arrays.hpp
View File

@ -13,5 +13,4 @@ inline cell array_nth(array *array, cell slot)
PRIMITIVE(array); PRIMITIVE(array);
PRIMITIVE(resize_array); PRIMITIVE(resize_array);
} }

50
vm/bignum.cpp
View File

@ -73,7 +73,6 @@ int factorvm::bignum_equal_p(bignum * x, bignum * y)
&& (bignum_equal_p_unsigned (x, y)))); && (bignum_equal_p_unsigned (x, y))));
} }
enum bignum_comparison factorvm::bignum_compare(bignum * x, bignum * y) enum bignum_comparison factorvm::bignum_compare(bignum * x, bignum * y)
{ {
return return
@ -96,7 +95,6 @@ enum bignum_comparison factorvm::bignum_compare(bignum * x, bignum * y)
: (bignum_compare_unsigned (x, y)))); : (bignum_compare_unsigned (x, y))));
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_add(bignum * x, bignum * y) bignum *factorvm::bignum_add(bignum * x, bignum * y)
{ {
@ -133,7 +131,6 @@ bignum *factorvm::bignum_subtract(bignum * x, bignum * y)
: (bignum_subtract_unsigned (x, y)))))); : (bignum_subtract_unsigned (x, y))))));
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_multiply(bignum * x, bignum * y) bignum *factorvm::bignum_multiply(bignum * x, bignum * y)
{ {
@ -166,7 +163,6 @@ bignum *factorvm::bignum_multiply(bignum * x, bignum * y)
return (bignum_multiply_unsigned (x, y, negative_p)); return (bignum_multiply_unsigned (x, y, negative_p));
} }
/* allocates memory */ /* allocates memory */
void factorvm::bignum_divide(bignum * numerator, bignum * denominator, bignum * * quotient, bignum * * remainder) void factorvm::bignum_divide(bignum * numerator, bignum * denominator, bignum * * quotient, bignum * * remainder)
{ {
@ -238,7 +234,6 @@ void factorvm::bignum_divide(bignum * numerator, bignum * denominator, bignum *
} }
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_quotient(bignum * numerator, bignum * denominator) bignum *factorvm::bignum_quotient(bignum * numerator, bignum * denominator)
{ {
@ -291,7 +286,6 @@ bignum *factorvm::bignum_quotient(bignum * numerator, bignum * denominator)
} }
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_remainder(bignum * numerator, bignum * denominator) bignum *factorvm::bignum_remainder(bignum * numerator, bignum * denominator)
{ {
@ -336,7 +330,6 @@ bignum *factorvm::bignum_remainder(bignum * numerator, bignum * denominator)
} }
} }
#define FOO_TO_BIGNUM(name,type,utype) \ #define FOO_TO_BIGNUM(name,type,utype) \
bignum * factorvm::name##_to_bignum(type n) \ bignum * factorvm::name##_to_bignum(type n) \
{ \ { \
@ -408,7 +401,6 @@ double factorvm::bignum_to_double(bignum * bignum)
} }
} }
#define DTB_WRITE_DIGIT(factor) \ #define DTB_WRITE_DIGIT(factor) \
{ \ { \
significand *= (factor); \ significand *= (factor); \
@ -451,7 +443,6 @@ bignum *factorvm::double_to_bignum(double x)
} }
} }
#undef DTB_WRITE_DIGIT #undef DTB_WRITE_DIGIT
/* Comparisons */ /* Comparisons */
@ -473,7 +464,6 @@ int factorvm::bignum_equal_p_unsigned(bignum * x, bignum * y)
} }
} }
enum bignum_comparison factorvm::bignum_compare_unsigned(bignum * x, bignum * y) enum bignum_comparison factorvm::bignum_compare_unsigned(bignum * x, bignum * y)
{ {
bignum_length_type x_length = (BIGNUM_LENGTH (x)); bignum_length_type x_length = (BIGNUM_LENGTH (x));
@ -499,7 +489,6 @@ enum bignum_comparison factorvm::bignum_compare_unsigned(bignum * x, bignum * y)
return (bignum_comparison_equal); return (bignum_comparison_equal);
} }
/* Addition */ /* Addition */
/* allocates memory */ /* allocates memory */
@ -567,7 +556,6 @@ bignum *factorvm::bignum_add_unsigned(bignum * x, bignum * y, int negative_p)
} }
} }
/* Subtraction */ /* Subtraction */
/* allocates memory */ /* allocates memory */
@ -642,7 +630,6 @@ bignum *factorvm::bignum_subtract_unsigned(bignum * x, bignum * y)
} }
} }
/* Multiplication /* Multiplication
Maximum value for product_low or product_high: Maximum value for product_low or product_high:
((R * R) + (R * (R - 2)) + (R - 1)) ((R * R) + (R * (R - 2)) + (R - 1))
@ -720,7 +707,6 @@ bignum *factorvm::bignum_multiply_unsigned(bignum * x, bignum * y, int negative_
} }
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_multiply_unsigned_small_factor(bignum * x, bignum_digit_type y,int negative_p) bignum *factorvm::bignum_multiply_unsigned_small_factor(bignum * x, bignum_digit_type y,int negative_p)
{ {
@ -736,7 +722,6 @@ bignum *factorvm::bignum_multiply_unsigned_small_factor(bignum * x, bignum_digit
return (bignum_trim (p)); return (bignum_trim (p));
} }
void factorvm::bignum_destructive_add(bignum * bignum, bignum_digit_type n) void factorvm::bignum_destructive_add(bignum * bignum, bignum_digit_type n)
{ {
bignum_digit_type * scan = (BIGNUM_START_PTR (bignum)); bignum_digit_type * scan = (BIGNUM_START_PTR (bignum));
@ -760,7 +745,6 @@ void factorvm::bignum_destructive_add(bignum * bignum, bignum_digit_type n)
} }
} }
void factorvm::bignum_destructive_scale_up(bignum * bignum, bignum_digit_type factor) void factorvm::bignum_destructive_scale_up(bignum * bignum, bignum_digit_type factor)
{ {
bignum_digit_type carry = 0; bignum_digit_type carry = 0;
@ -790,7 +774,6 @@ void factorvm::bignum_destructive_scale_up(bignum * bignum, bignum_digit_type fa
#undef product_high #undef product_high
} }
/* Division */ /* Division */
/* For help understanding this algorithm, see: /* For help understanding this algorithm, see:
@ -856,7 +839,6 @@ void factorvm::bignum_divide_unsigned_large_denominator(bignum * numerator, bign
return; return;
} }
void factorvm::bignum_divide_unsigned_normalized(bignum * u, bignum * v, bignum * q) void factorvm::bignum_divide_unsigned_normalized(bignum * u, bignum * v, bignum * q)
{ {
bignum_length_type u_length = (BIGNUM_LENGTH (u)); bignum_length_type u_length = (BIGNUM_LENGTH (u));
@ -931,7 +913,6 @@ void factorvm::bignum_divide_unsigned_normalized(bignum * u, bignum * v, bignum
#undef qj #undef qj
} }
bignum_digit_type factorvm::bignum_divide_subtract(bignum_digit_type * v_start, bignum_digit_type * v_end, bignum_digit_type guess, bignum_digit_type * u_start) bignum_digit_type factorvm::bignum_divide_subtract(bignum_digit_type * v_start, bignum_digit_type * v_end, bignum_digit_type guess, bignum_digit_type * u_start)
{ {
bignum_digit_type * v_scan = v_start; bignum_digit_type * v_scan = v_start;
@ -1007,7 +988,6 @@ bignum_digit_type factorvm::bignum_divide_subtract(bignum_digit_type * v_start,
return (guess - 1); return (guess - 1);
} }
/* allocates memory */ /* allocates memory */
void factorvm::bignum_divide_unsigned_medium_denominator(bignum * numerator,bignum_digit_type denominator, bignum * * quotient, bignum * * remainder,int q_negative_p, int r_negative_p) void factorvm::bignum_divide_unsigned_medium_denominator(bignum * numerator,bignum_digit_type denominator, bignum * * quotient, bignum * * remainder,int q_negative_p, int r_negative_p)
{ {
@ -1067,7 +1047,6 @@ void factorvm::bignum_divide_unsigned_medium_denominator(bignum * numerator,bign
return; return;
} }
void factorvm::bignum_destructive_normalization(bignum * source, bignum * target, int shift_left) void factorvm::bignum_destructive_normalization(bignum * source, bignum * target, int shift_left)
{ {
bignum_digit_type digit; bignum_digit_type digit;
@ -1091,7 +1070,6 @@ void factorvm::bignum_destructive_normalization(bignum * source, bignum * target
return; return;
} }
void factorvm::bignum_destructive_unnormalization(bignum * bignum, int shift_right) void factorvm::bignum_destructive_unnormalization(bignum * bignum, int shift_right)
{ {
bignum_digit_type * start = (BIGNUM_START_PTR (bignum)); bignum_digit_type * start = (BIGNUM_START_PTR (bignum));
@ -1110,7 +1088,6 @@ void factorvm::bignum_destructive_unnormalization(bignum * bignum, int shift_rig
return; return;
} }
/* This is a reduced version of the division algorithm, applied to the /* This is a reduced version of the division algorithm, applied to the
case of dividing two bignum digits by one bignum digit. It is case of dividing two bignum digits by one bignum digit. It is
assumed that the numerator, denominator are normalized. */ assumed that the numerator, denominator are normalized. */
@ -1175,7 +1152,6 @@ bignum_digit_type factorvm::bignum_digit_divide(bignum_digit_type uh, bignum_dig
return (HD_CONS ((u[2]), (u[3]))); return (HD_CONS ((u[2]), (u[3])));
} }
#undef BDD_STEP #undef BDD_STEP
#define BDDS_MULSUB(vn, un, carry_in) \ #define BDDS_MULSUB(vn, un, carry_in) \
@ -1239,7 +1215,6 @@ bignum_digit_type factorvm::bignum_digit_divide_subtract(bignum_digit_type v1, b
return (guess - 1); return (guess - 1);
} }
#undef BDDS_MULSUB #undef BDDS_MULSUB
#undef BDDS_ADD #undef BDDS_ADD
@ -1263,7 +1238,6 @@ void factorvm::bignum_divide_unsigned_small_denominator(bignum * numerator, bign
return; return;
} }
/* Given (denominator > 1), it is fairly easy to show that /* Given (denominator > 1), it is fairly easy to show that
(quotient_high < BIGNUM_RADIX_ROOT), after which it is easy to see (quotient_high < BIGNUM_RADIX_ROOT), after which it is easy to see
that all digits are < BIGNUM_RADIX. */ that all digits are < BIGNUM_RADIX. */
@ -1290,7 +1264,6 @@ bignum_digit_type factorvm::bignum_destructive_scale_down(bignum * bignum, bignu
#undef quotient_high #undef quotient_high
} }
/* allocates memory */ /* allocates memory */
bignum * factorvm::bignum_remainder_unsigned_small_denominator(bignum * n, bignum_digit_type d, int negative_p) bignum * factorvm::bignum_remainder_unsigned_small_denominator(bignum * n, bignum_digit_type d, int negative_p)
{ {
@ -1310,7 +1283,6 @@ bignum * factorvm::bignum_remainder_unsigned_small_denominator(bignum * n, bignu
return (bignum_digit_to_bignum (r, negative_p)); return (bignum_digit_to_bignum (r, negative_p));
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_digit_to_bignum(bignum_digit_type digit, int negative_p) bignum *factorvm::bignum_digit_to_bignum(bignum_digit_type digit, int negative_p)
{ {
@ -1324,7 +1296,6 @@ bignum *factorvm::bignum_digit_to_bignum(bignum_digit_type digit, int negative_p
} }
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::allot_bignum(bignum_length_type length, int negative_p) bignum *factorvm::allot_bignum(bignum_length_type length, int negative_p)
{ {
@ -1334,7 +1305,6 @@ bignum *factorvm::allot_bignum(bignum_length_type length, int negative_p)
return (result); return (result);
} }
/* allocates memory */ /* allocates memory */
bignum * factorvm::allot_bignum_zeroed(bignum_length_type length, int negative_p) bignum * factorvm::allot_bignum_zeroed(bignum_length_type length, int negative_p)
{ {
@ -1346,7 +1316,6 @@ bignum * factorvm::allot_bignum_zeroed(bignum_length_type length, int negative_p
return (result); return (result);
} }
#define BIGNUM_REDUCE_LENGTH(source, length) \ #define BIGNUM_REDUCE_LENGTH(source, length) \
source = reallot_array(source,length + 1) source = reallot_array(source,length + 1)
@ -1363,7 +1332,6 @@ bignum *factorvm::bignum_shorten_length(bignum * bignum, bignum_length_type leng
return (bignum); return (bignum);
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_trim(bignum * bignum) bignum *factorvm::bignum_trim(bignum * bignum)
{ {
@ -1382,7 +1350,6 @@ bignum *factorvm::bignum_trim(bignum * bignum)
return (bignum); return (bignum);
} }
/* Copying */ /* Copying */
/* allocates memory */ /* allocates memory */
@ -1395,7 +1362,6 @@ bignum *factorvm::bignum_new_sign(bignum * x, int negative_p)
return (result); return (result);
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_maybe_new_sign(bignum * x, int negative_p) bignum *factorvm::bignum_maybe_new_sign(bignum * x, int negative_p)
{ {
@ -1410,7 +1376,6 @@ bignum *factorvm::bignum_maybe_new_sign(bignum * x, int negative_p)
} }
} }
void factorvm::bignum_destructive_copy(bignum * source, bignum * target) void factorvm::bignum_destructive_copy(bignum * source, bignum * target)
{ {
bignum_digit_type * scan_source = (BIGNUM_START_PTR (source)); bignum_digit_type * scan_source = (BIGNUM_START_PTR (source));
@ -1422,7 +1387,6 @@ void factorvm::bignum_destructive_copy(bignum * source, bignum * target)
return; return;
} }
/* /*
* Added bitwise operations (and oddp). * Added bitwise operations (and oddp).
*/ */
@ -1433,7 +1397,6 @@ bignum *factorvm::bignum_bitwise_not(bignum * x)
return bignum_subtract(BIGNUM_ONE(1), x); return bignum_subtract(BIGNUM_ONE(1), x);
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_arithmetic_shift(bignum * arg1, fixnum n) bignum *factorvm::bignum_arithmetic_shift(bignum * arg1, fixnum n)
{ {
@ -1443,7 +1406,6 @@ bignum *factorvm::bignum_arithmetic_shift(bignum * arg1, fixnum n)
return bignum_magnitude_ash(arg1, n); return bignum_magnitude_ash(arg1, n);
} }
#define AND_OP 0 #define AND_OP 0
#define IOR_OP 1 #define IOR_OP 1
#define XOR_OP 2 #define XOR_OP 2
@ -1462,7 +1424,6 @@ bignum *factorvm::bignum_bitwise_and(bignum * arg1, bignum * arg2)
); );
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_bitwise_ior(bignum * arg1, bignum * arg2) bignum *factorvm::bignum_bitwise_ior(bignum * arg1, bignum * arg2)
{ {
@ -1477,7 +1438,6 @@ bignum *factorvm::bignum_bitwise_ior(bignum * arg1, bignum * arg2)
); );
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_bitwise_xor(bignum * arg1, bignum * arg2) bignum *factorvm::bignum_bitwise_xor(bignum * arg1, bignum * arg2)
{ {
@ -1492,7 +1452,6 @@ bignum *factorvm::bignum_bitwise_xor(bignum * arg1, bignum * arg2)
); );
} }
/* allocates memory */ /* allocates memory */
/* ash for the magnitude */ /* ash for the magnitude */
/* assume arg1 is a big number, n is a long */ /* assume arg1 is a big number, n is a long */
@ -1556,7 +1515,6 @@ bignum *factorvm::bignum_magnitude_ash(bignum * arg1, fixnum n)
return (bignum_trim (result)); return (bignum_trim (result));
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_pospos_bitwise_op(int op, bignum * arg1, bignum * arg2) bignum *factorvm::bignum_pospos_bitwise_op(int op, bignum * arg1, bignum * arg2)
{ {
@ -1591,7 +1549,6 @@ bignum *factorvm::bignum_pospos_bitwise_op(int op, bignum * arg1, bignum * arg2)
return bignum_trim(result); return bignum_trim(result);
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_posneg_bitwise_op(int op, bignum * arg1, bignum * arg2) bignum *factorvm::bignum_posneg_bitwise_op(int op, bignum * arg1, bignum * arg2)
{ {
@ -1644,7 +1601,6 @@ bignum *factorvm::bignum_posneg_bitwise_op(int op, bignum * arg1, bignum * arg2)
return bignum_trim(result); return bignum_trim(result);
} }
/* allocates memory */ /* allocates memory */
bignum *factorvm::bignum_negneg_bitwise_op(int op, bignum * arg1, bignum * arg2) bignum *factorvm::bignum_negneg_bitwise_op(int op, bignum * arg1, bignum * arg2)
{ {
@ -1705,7 +1661,6 @@ bignum *factorvm::bignum_negneg_bitwise_op(int op, bignum * arg1, bignum * arg2)
return bignum_trim(result); return bignum_trim(result);
} }
void factorvm::bignum_negate_magnitude(bignum * arg) void factorvm::bignum_negate_magnitude(bignum * arg)
{ {
bignum_digit_type *scan; bignum_digit_type *scan;
@ -1733,7 +1688,6 @@ void factorvm::bignum_negate_magnitude(bignum * arg)
} }
} }
/* Allocates memory */ /* Allocates memory */
bignum *factorvm::bignum_integer_length(bignum * x) bignum *factorvm::bignum_integer_length(bignum * x)
{ {
@ -1755,7 +1709,6 @@ bignum *factorvm::bignum_integer_length(bignum * x)
return (bignum_trim (result)); return (bignum_trim (result));
} }
/* Allocates memory */ /* Allocates memory */
int factorvm::bignum_logbitp(int shift, bignum * arg) int factorvm::bignum_logbitp(int shift, bignum * arg)
{ {
@ -1764,7 +1717,6 @@ int factorvm::bignum_logbitp(int shift, bignum * arg)
: bignum_unsigned_logbitp (shift,arg)); : bignum_unsigned_logbitp (shift,arg));
} }
int factorvm::bignum_unsigned_logbitp(int shift, bignum * bignum) int factorvm::bignum_unsigned_logbitp(int shift, bignum * bignum)
{ {
bignum_length_type len = (BIGNUM_LENGTH (bignum)); bignum_length_type len = (BIGNUM_LENGTH (bignum));
@ -1777,7 +1729,6 @@ int factorvm::bignum_unsigned_logbitp(int shift, bignum * bignum)
return (digit & mask) ? 1 : 0; return (digit & mask) ? 1 : 0;
} }
/* Allocates memory */ /* Allocates memory */
bignum *factorvm::digit_stream_to_bignum(unsigned int n_digits, unsigned int (*producer)(unsigned int, factorvm*), unsigned int radix, int negative_p) bignum *factorvm::digit_stream_to_bignum(unsigned int n_digits, unsigned int (*producer)(unsigned int, factorvm*), unsigned int radix, int negative_p)
{ {
@ -1815,5 +1766,4 @@ bignum *factorvm::digit_stream_to_bignum(unsigned int n_digits, unsigned int (*p
} }
} }
} }

1
vm/bignumint.hpp
View File

@ -54,7 +54,6 @@ typedef fixnum bignum_length_type;
/* BIGNUM_EXCEPTION is invoked to handle assertion violations. */ /* BIGNUM_EXCEPTION is invoked to handle assertion violations. */
#define BIGNUM_EXCEPTION abort #define BIGNUM_EXCEPTION abort
#define BIGNUM_DIGIT_LENGTH (((sizeof (bignum_digit_type)) * CHAR_BIT) - 2) #define BIGNUM_DIGIT_LENGTH (((sizeof (bignum_digit_type)) * CHAR_BIT) - 2)
#define BIGNUM_HALF_DIGIT_LENGTH (BIGNUM_DIGIT_LENGTH / 2) #define BIGNUM_HALF_DIGIT_LENGTH (BIGNUM_DIGIT_LENGTH / 2)
#define BIGNUM_RADIX (bignum_digit_type)(((cell) 1) << BIGNUM_DIGIT_LENGTH) #define BIGNUM_RADIX (bignum_digit_type)(((cell) 1) << BIGNUM_DIGIT_LENGTH)

1
vm/booleans.hpp
View File

@ -1,7 +1,6 @@
namespace factor namespace factor
{ {
VM_C_API void box_boolean(bool value, factorvm *vm); VM_C_API void box_boolean(bool value, factorvm *vm);
VM_C_API bool to_boolean(cell value, factorvm *vm); VM_C_API bool to_boolean(cell value, factorvm *vm);

1
vm/byte_arrays.cpp
View File

@ -10,7 +10,6 @@ byte_array *factorvm::allot_byte_array(cell size)
return array; return array;
} }
inline void factorvm::primitive_byte_array() inline void factorvm::primitive_byte_array()
{ {
cell size = unbox_array_size(); cell size = unbox_array_size();

1
vm/byte_arrays.hpp
View File

@ -5,5 +5,4 @@ PRIMITIVE(byte_array);
PRIMITIVE(uninitialized_byte_array); PRIMITIVE(uninitialized_byte_array);
PRIMITIVE(resize_byte_array); PRIMITIVE(resize_byte_array);
} }

1
vm/callstack.cpp
View File

@ -89,7 +89,6 @@ code_block *factorvm::frame_code(stack_frame *frame)
return (code_block *)frame->xt - 1; return (code_block *)frame->xt - 1;
} }
cell factorvm::frame_type(stack_frame *frame) cell factorvm::frame_type(stack_frame *frame)
{ {
return frame_code(frame)->type; return frame_code(frame)->type;

1
vm/callstack.hpp
View File

@ -16,5 +16,4 @@ PRIMITIVE(set_innermost_stack_frame_quot);
VM_ASM_API void save_callstack_bottom(stack_frame *callstack_bottom,factorvm *vm); VM_ASM_API void save_callstack_bottom(stack_frame *callstack_bottom,factorvm *vm);
} }

14
vm/code_gc.cpp
View File

@ -8,7 +8,6 @@ void factorvm::clear_free_list(heap *heap)
memset(&heap->free,0,sizeof(heap_free_list)); memset(&heap->free,0,sizeof(heap_free_list));
} }
/* This malloc-style heap code is reasonably generic. Maybe in the future, it /* This malloc-style heap code is reasonably generic. Maybe in the future, it
will be used for the data heap too, if we ever get incremental will be used for the data heap too, if we ever get incremental
mark/sweep/compact GC. */ mark/sweep/compact GC. */
@ -21,7 +20,6 @@ void factorvm::new_heap(heap *heap, cell size)
clear_free_list(heap); clear_free_list(heap);
} }
void factorvm::add_to_free_list(heap *heap, free_heap_block *block) void factorvm::add_to_free_list(heap *heap, free_heap_block *block)
{ {
if(block->size < free_list_count * block_size_increment) if(block->size < free_list_count * block_size_increment)
@ -37,7 +35,6 @@ void factorvm::add_to_free_list(heap *heap, free_heap_block *block)
} }
} }
/* Called after reading the code heap from the image file, and after code GC. /* Called after reading the code heap from the image file, and after code GC.
In the former case, we must add a large free block from compiling.base + size to In the former case, we must add a large free block from compiling.base + size to
@ -94,7 +91,6 @@ void factorvm::build_free_list(heap *heap, cell size)
} }
void factorvm::assert_free_block(free_heap_block *block) void factorvm::assert_free_block(free_heap_block *block)
{ {
if(block->status != B_FREE) if(block->status != B_FREE)
@ -142,7 +138,6 @@ free_heap_block *factorvm::find_free_block(heap *heap, cell size)
return NULL; return NULL;
} }
free_heap_block *factorvm::split_free_block(heap *heap, free_heap_block *block, cell size) free_heap_block *factorvm::split_free_block(heap *heap, free_heap_block *block, cell size)
{ {
if(block->size != size ) if(block->size != size )
@ -159,7 +154,6 @@ free_heap_block *factorvm::split_free_block(heap *heap, free_heap_block *block,
return block; return block;
} }
/* Allocate a block of memory from the mark and sweep GC heap */ /* Allocate a block of memory from the mark and sweep GC heap */
heap_block *factorvm::heap_allot(heap *heap, cell size) heap_block *factorvm::heap_allot(heap *heap, cell size)
{ {
@ -177,7 +171,6 @@ heap_block *factorvm::heap_allot(heap *heap, cell size)
return NULL; return NULL;
} }
/* Deallocates a block manually */ /* Deallocates a block manually */
void factorvm::heap_free(heap *heap, heap_block *block) void factorvm::heap_free(heap *heap, heap_block *block)
{ {
@ -185,7 +178,6 @@ void factorvm::heap_free(heap *heap, heap_block *block)
add_to_free_list(heap,(free_heap_block *)block); add_to_free_list(heap,(free_heap_block *)block);
} }
void factorvm::mark_block(heap_block *block) void factorvm::mark_block(heap_block *block)
{ {
/* If already marked, do nothing */ /* If already marked, do nothing */
@ -202,7 +194,6 @@ void factorvm::mark_block(heap_block *block)
} }
} }
/* If in the middle of code GC, we have to grow the heap, data GC restarts from /* If in the middle of code GC, we have to grow the heap, data GC restarts from
scratch, so we have to unmark any marked blocks. */ scratch, so we have to unmark any marked blocks. */
void factorvm::unmark_marked(heap *heap) void factorvm::unmark_marked(heap *heap)
@ -218,7 +209,6 @@ void factorvm::unmark_marked(heap *heap)
} }
} }
/* After code GC, all referenced code blocks have status set to B_MARKED, so any /* After code GC, all referenced code blocks have status set to B_MARKED, so any
which are allocated and not marked can be reclaimed. */ which are allocated and not marked can be reclaimed. */
void factorvm::free_unmarked(heap *heap, heap_iterator iter) void factorvm::free_unmarked(heap *heap, heap_iterator iter)
@ -268,7 +258,6 @@ void factorvm::free_unmarked(heap *heap, heap_iterator iter)
add_to_free_list(heap,(free_heap_block *)prev); add_to_free_list(heap,(free_heap_block *)prev);
} }
/* Compute total sum of sizes of free blocks, and size of largest free block */ /* Compute total sum of sizes of free blocks, and size of largest free block */
void factorvm::heap_usage(heap *heap, cell *used, cell *total_free, cell *max_free) void factorvm::heap_usage(heap *heap, cell *used, cell *total_free, cell *max_free)
{ {
@ -298,7 +287,6 @@ void factorvm::heap_usage(heap *heap, cell *used, cell *total_free, cell *max_fr
} }
} }
/* The size of the heap, not including the last block if it's free */ /* The size of the heap, not including the last block if it's free */
cell factorvm::heap_size(heap *heap) cell factorvm::heap_size(heap *heap)
{ {
@ -315,7 +303,6 @@ cell factorvm::heap_size(heap *heap)
return heap->seg->size; return heap->seg->size;
} }
/* Compute where each block is going to go, after compaction */ /* Compute where each block is going to go, after compaction */
cell factorvm::compute_heap_forwarding(heap *heap, unordered_map<heap_block *,char *> &forwarding) cell factorvm::compute_heap_forwarding(heap *heap, unordered_map<heap_block *,char *> &forwarding)
{ {
@ -338,7 +325,6 @@ cell factorvm::compute_heap_forwarding(heap *heap, unordered_map<heap_block *,ch
return (cell)address - heap->seg->start; return (cell)address - heap->seg->start;
} }
void factorvm::compact_heap(heap *heap, unordered_map<heap_block *,char *> &forwarding) void factorvm::compact_heap(heap *heap, unordered_map<heap_block *,char *> &forwarding)
{ {
heap_block *scan = first_block(heap); heap_block *scan = first_block(heap);

8
vm/code_heap.cpp
View File

@ -28,7 +28,6 @@ void factorvm::jit_compile_word(cell word_, cell def_, bool relocate)
if(word->pic_tail_def != F) jit_compile(word->pic_tail_def,relocate); if(word->pic_tail_def != F) jit_compile(word->pic_tail_def,relocate);
} }
/* Apply a function to every code block */ /* Apply a function to every code block */
void factorvm::iterate_code_heap(code_heap_iterator iter) void factorvm::iterate_code_heap(code_heap_iterator iter)
{ {
@ -42,7 +41,6 @@ void factorvm::iterate_code_heap(code_heap_iterator iter)
} }
} }
/* Copy literals referenced from all code blocks to newspace. Only for /* Copy literals referenced from all code blocks to newspace. Only for
aging and nursery collections */ aging and nursery collections */
void factorvm::copy_code_heap_roots() void factorvm::copy_code_heap_roots()
@ -50,7 +48,6 @@ void factorvm::copy_code_heap_roots()
iterate_code_heap(factor::copy_literal_references); iterate_code_heap(factor::copy_literal_references);
} }
/* Update pointers to words referenced from all code blocks. Only after /* Update pointers to words referenced from all code blocks. Only after
defining a new word. */ defining a new word. */
void factorvm::update_code_heap_words() void factorvm::update_code_heap_words()
@ -58,7 +55,6 @@ void factorvm::update_code_heap_words()
iterate_code_heap(factor::update_word_references); iterate_code_heap(factor::update_word_references);
} }
inline void factorvm::primitive_modify_code_heap() inline void factorvm::primitive_modify_code_heap()
{ {
gc_root<array> alist(dpop(),this); gc_root<array> alist(dpop(),this);
@ -131,13 +127,11 @@ PRIMITIVE(code_room)
PRIMITIVE_GETVM()->primitive_code_room(); PRIMITIVE_GETVM()->primitive_code_room();
} }
code_block *factorvm::forward_xt(code_block *compiled) code_block *factorvm::forward_xt(code_block *compiled)
{ {
return (code_block *)forwarding[compiled]; return (code_block *)forwarding[compiled];
} }
void factorvm::forward_frame_xt(stack_frame *frame) void factorvm::forward_frame_xt(stack_frame *frame)
{ {
cell offset = (cell)FRAME_RETURN_ADDRESS(frame) - (cell)frame_code(frame); cell offset = (cell)FRAME_RETURN_ADDRESS(frame) - (cell)frame_code(frame);
@ -193,7 +187,6 @@ void factorvm::forward_object_xts()
end_scan(); end_scan();
} }
/* Set the XT fields now that the heap has been compacted */ /* Set the XT fields now that the heap has been compacted */
void factorvm::fixup_object_xts() void factorvm::fixup_object_xts()
{ {
@ -223,7 +216,6 @@ void factorvm::fixup_object_xts()
end_scan(); end_scan();
} }
/* Move all free space to the end of the code heap. This is not very efficient, /* Move all free space to the end of the code heap. This is not very efficient,
since it makes several passes over the code and data heaps, but we only ever since it makes several passes over the code and data heaps, but we only ever
do this before saving a deployed image and exiting, so performaance is not do this before saving a deployed image and exiting, so performaance is not

1
vm/contexts.cpp
View File

@ -3,7 +3,6 @@
namespace factor namespace factor
{ {
void factorvm::reset_datastack() void factorvm::reset_datastack()
{ {
ds = ds_bot - sizeof(cell); ds = ds_bot - sizeof(cell);

1
vm/cpu-x86.32.S
View File

@ -93,7 +93,6 @@ DEF(F_FASTCALL void,throw_impl,(CELL quot, F_STACK_FRAME *rewind_to, void *vm)):
mov NV_TEMP_REG,ARG1 mov NV_TEMP_REG,ARG1
jmp *QUOT_XT_OFFSET(ARG0) jmp *QUOT_XT_OFFSET(ARG0)
DEF(F_FASTCALL void,lazy_jit_compile,(CELL quot, void *vm)): DEF(F_FASTCALL void,lazy_jit_compile,(CELL quot, void *vm)):
mov ARG1,NV_TEMP_REG /* stash vm ptr */ mov ARG1,NV_TEMP_REG /* stash vm ptr */
mov STACK_REG,ARG1 /* Save stack pointer */ mov STACK_REG,ARG1 /* Save stack pointer */

1
vm/cpu-x86.64.S
View File

@ -89,7 +89,6 @@ DEF(void,primitive_inline_cache_miss_tail,(void *vm)):
add $STACK_PADDING,%rsp add $STACK_PADDING,%rsp
jmp *%rax jmp *%rax
DEF(void,get_sse_env,(void*)): DEF(void,get_sse_env,(void*)):
stmxcsr (%rdi) stmxcsr (%rdi)
ret ret

20
vm/data_heap.cpp
View File

@ -11,7 +11,6 @@ cell factorvm::init_zone(zone *z, cell size, cell start)
return z->end; return z->end;
} }
void factorvm::init_card_decks() void factorvm::init_card_decks()
{ {
cell start = align(data->seg->start,deck_size); cell start = align(data->seg->start,deck_size);
@ -84,7 +83,6 @@ data_heap *factorvm::alloc_data_heap(cell gens, cell young_size,cell aging_size,
return data; return data;
} }
data_heap *factorvm::grow_data_heap(data_heap *data, cell requested_bytes) data_heap *factorvm::grow_data_heap(data_heap *data, cell requested_bytes)
{ {
cell new_tenured_size = (data->tenured_size * 2) + requested_bytes; cell new_tenured_size = (data->tenured_size * 2) + requested_bytes;
@ -95,7 +93,6 @@ data_heap *factorvm::grow_data_heap(data_heap *data, cell requested_bytes)
new_tenured_size); new_tenured_size);
} }
void factorvm::dealloc_data_heap(data_heap *data) void factorvm::dealloc_data_heap(data_heap *data)
{ {
dealloc_segment(data->seg); dealloc_segment(data->seg);
@ -107,7 +104,6 @@ void factorvm::dealloc_data_heap(data_heap *data)
free(data); free(data);
} }
void factorvm::clear_cards(cell from, cell to) void factorvm::clear_cards(cell from, cell to)
{ {
/* NOTE: reverse order due to heap layout. */ /* NOTE: reverse order due to heap layout. */
@ -116,7 +112,6 @@ void factorvm::clear_cards(cell from, cell to)
memset(first_card,0,last_card - first_card); memset(first_card,0,last_card - first_card);
} }
void factorvm::clear_decks(cell from, cell to) void factorvm::clear_decks(cell from, cell to)
{ {
/* NOTE: reverse order due to heap layout. */ /* NOTE: reverse order due to heap layout. */
@ -125,7 +120,6 @@ void factorvm::clear_decks(cell from, cell to)
memset(first_deck,0,last_deck - first_deck); memset(first_deck,0,last_deck - first_deck);
} }
void factorvm::clear_allot_markers(cell from, cell to) void factorvm::clear_allot_markers(cell from, cell to)
{ {
/* NOTE: reverse order due to heap layout. */ /* NOTE: reverse order due to heap layout. */
@ -134,7 +128,6 @@ void factorvm::clear_allot_markers(cell from, cell to)
memset(first_card,invalid_allot_marker,last_card - first_card); memset(first_card,invalid_allot_marker,last_card - first_card);
} }
void factorvm::reset_generation(cell i) void factorvm::reset_generation(cell i)
{ {
zone *z = (i == data->nursery() ? &nursery : &data->generations[i]); zone *z = (i == data->nursery() ? &nursery : &data->generations[i]);
@ -144,7 +137,6 @@ void factorvm::reset_generation(cell i)
memset((void*)z->start,69,z->size); memset((void*)z->start,69,z->size);
} }
/* After garbage collection, any generations which are now empty need to have /* After garbage collection, any generations which are now empty need to have
their allocation pointers and cards reset. */ their allocation pointers and cards reset. */
void factorvm::reset_generations(cell from, cell to) void factorvm::reset_generations(cell from, cell to)
@ -158,7 +150,6 @@ void factorvm::reset_generations(cell from, cell to)
clear_allot_markers(from,to); clear_allot_markers(from,to);
} }
void factorvm::set_data_heap(data_heap *data_) void factorvm::set_data_heap(data_heap *data_)
{ {
data = data_; data = data_;
@ -169,7 +160,6 @@ void factorvm::set_data_heap(data_heap *data_)
clear_allot_markers(data->nursery(),data->tenured()); clear_allot_markers(data->nursery(),data->tenured());
} }
void factorvm::init_data_heap(cell gens,cell young_size,cell aging_size,cell tenured_size,bool secure_gc_) void factorvm::init_data_heap(cell gens,cell young_size,cell aging_size,cell tenured_size,bool secure_gc_)
{ {
set_data_heap(alloc_data_heap(gens,young_size,aging_size,tenured_size)); set_data_heap(alloc_data_heap(gens,young_size,aging_size,tenured_size));
@ -177,7 +167,6 @@ void factorvm::init_data_heap(cell gens,cell young_size,cell aging_size,cell ten
init_data_gc(); init_data_gc();
} }
/* Size of the object pointed to by a tagged pointer */ /* Size of the object pointed to by a tagged pointer */
cell factorvm::object_size(cell tagged) cell factorvm::object_size(cell tagged)
{ {
@ -187,14 +176,12 @@ cell factorvm::object_size(cell tagged)
return untagged_object_size(untag<object>(tagged)); return untagged_object_size(untag<object>(tagged));
} }
/* Size of the object pointed to by an untagged pointer */ /* Size of the object pointed to by an untagged pointer */
cell factorvm::untagged_object_size(object *pointer) cell factorvm::untagged_object_size(object *pointer)
{ {
return align8(unaligned_object_size(pointer)); return align8(unaligned_object_size(pointer));
} }
/* Size of the data area of an object pointed to by an untagged pointer */ /* Size of the data area of an object pointed to by an untagged pointer */
cell factorvm::unaligned_object_size(object *pointer) cell factorvm::unaligned_object_size(object *pointer)
{ {
@ -230,7 +217,6 @@ cell factorvm::unaligned_object_size(object *pointer)
} }
} }
inline void factorvm::primitive_size() inline void factorvm::primitive_size()
{ {
box_unsigned_cell(object_size(dpop())); box_unsigned_cell(object_size(dpop()));
@ -278,7 +264,6 @@ cell factorvm::binary_payload_start(object *pointer)
} }
} }
/* Push memory usage statistics in data heap */ /* Push memory usage statistics in data heap */
inline void factorvm::primitive_data_room() inline void factorvm::primitive_data_room()
{ {
@ -311,13 +296,11 @@ void factorvm::begin_scan()
gc_off = true; gc_off = true;
} }
void factorvm::end_scan() void factorvm::end_scan()
{ {
gc_off = false; gc_off = false;
} }
inline void factorvm::primitive_begin_scan() inline void factorvm::primitive_begin_scan()
{ {
begin_scan(); begin_scan();
@ -341,7 +324,6 @@ cell factorvm::next_object()
return tag_dynamic(obj); return tag_dynamic(obj);
} }
/* Push object at heap scan cursor and advance; pushes f when done */ /* Push object at heap scan cursor and advance; pushes f when done */
inline void factorvm::primitive_next_object() inline void factorvm::primitive_next_object()
{ {
@ -373,7 +355,6 @@ template<typename TYPE> void factorvm::each_object(TYPE &functor)
end_scan(); end_scan();
} }
namespace namespace
{ {
@ -401,5 +382,4 @@ cell factorvm::find_all_words()
return accum.words.elements.value(); return accum.words.elements.value();
} }
} }

2
vm/data_heap.hpp
View File

@ -1,7 +1,6 @@
namespace factor namespace factor
{ {
/* generational copying GC divides memory into zones */ /* generational copying GC divides memory into zones */
struct zone { struct zone {
/* allocation pointer is 'here'; its offset is hardcoded in the /* allocation pointer is 'here'; its offset is hardcoded in the
@ -45,7 +44,6 @@ struct data_heap {
bool have_aging_p() { return gen_count > 2; } bool have_aging_p() { return gen_count > 2; }
}; };
static const cell max_gen_count = 3; static const cell max_gen_count = 3;
inline static bool in_zone(zone *z, object *pointer) inline static bool in_zone(zone *z, object *pointer)

20
vm/debug.cpp
View File

@ -3,7 +3,6 @@
namespace factor namespace factor
{ {
void factorvm::print_chars(string* str) void factorvm::print_chars(string* str)
{ {
cell i; cell i;
@ -11,7 +10,6 @@ void factorvm::print_chars(string* str)
putchar(string_nth(str,i)); putchar(string_nth(str,i));
} }
void factorvm::print_word(word* word, cell nesting) void factorvm::print_word(word* word, cell nesting)
{ {
if(tagged<object>(word->vocabulary).type_p(STRING_TYPE)) if(tagged<object>(word->vocabulary).type_p(STRING_TYPE))
@ -30,7 +28,6 @@ void factorvm::print_word(word* word, cell nesting)
} }
} }
void factorvm::print_factor_string(string* str) void factorvm::print_factor_string(string* str)
{ {
putchar('"'); putchar('"');
@ -38,7 +35,6 @@ void factorvm::print_factor_string(string* str)
putchar('"'); putchar('"');
} }
void factorvm::print_array(array* array, cell nesting) void factorvm::print_array(array* array, cell nesting)
{ {
cell length = array_capacity(array); cell length = array_capacity(array);
@ -63,7 +59,6 @@ void factorvm::print_array(array* array, cell nesting)
print_string("..."); print_string("...");
} }
void factorvm::print_tuple(tuple *tuple, cell nesting) void factorvm::print_tuple(tuple *tuple, cell nesting)
{ {
tuple_layout *layout = untag<tuple_layout>(tuple->layout); tuple_layout *layout = untag<tuple_layout>(tuple->layout);
@ -93,7 +88,6 @@ void factorvm::print_tuple(tuple *tuple, cell nesting)
print_string("..."); print_string("...");
} }
void factorvm::print_nested_obj(cell obj, fixnum nesting) void factorvm::print_nested_obj(cell obj, fixnum nesting)
{ {
if(nesting <= 0 && !full_output) if(nesting <= 0 && !full_output)
@ -144,13 +138,11 @@ void factorvm::print_nested_obj(cell obj, fixnum nesting)
} }
} }
void factorvm::print_obj(cell obj) void factorvm::print_obj(cell obj)
{ {
print_nested_obj(obj,10); print_nested_obj(obj,10);
} }
void factorvm::print_objects(cell *start, cell *end) void factorvm::print_objects(cell *start, cell *end)
{ {
for(; start <= end; start++) for(; start <= end; start++)
@ -160,21 +152,18 @@ void factorvm::print_objects(cell *start, cell *end)
} }
} }
void factorvm::print_datastack() void factorvm::print_datastack()
{ {
print_string("==== DATA STACK:\n"); print_string("==== DATA STACK:\n");
print_objects((cell *)ds_bot,(cell *)ds); print_objects((cell *)ds_bot,(cell *)ds);
} }
void factorvm::print_retainstack() void factorvm::print_retainstack()
{ {
print_string("==== RETAIN STACK:\n"); print_string("==== RETAIN STACK:\n");
print_objects((cell *)rs_bot,(cell *)rs); print_objects((cell *)rs_bot,(cell *)rs);
} }
void factorvm::print_stack_frame(stack_frame *frame) void factorvm::print_stack_frame(stack_frame *frame)
{ {
print_obj(frame_executing(frame)); print_obj(frame_executing(frame));
@ -205,7 +194,6 @@ void factorvm::print_callstack()
iterate_callstack(top,bottom,factor::print_stack_frame); iterate_callstack(top,bottom,factor::print_stack_frame);
} }
void factorvm::dump_cell(cell x) void factorvm::dump_cell(cell x)
{ {
print_cell_hex_pad(x); print_string(": "); print_cell_hex_pad(x); print_string(": ");
@ -214,7 +202,6 @@ void factorvm::dump_cell(cell x)
nl(); nl();
} }
void factorvm::dump_memory(cell from, cell to) void factorvm::dump_memory(cell from, cell to)
{ {
from = UNTAG(from); from = UNTAG(from);
@ -223,7 +210,6 @@ void factorvm::dump_memory(cell from, cell to)
dump_cell(from); dump_cell(from);
} }
void factorvm::dump_zone(zone *z) void factorvm::dump_zone(zone *z)
{ {
print_string("Start="); print_cell(z->start); print_string("Start="); print_cell(z->start);
@ -231,7 +217,6 @@ void factorvm::dump_zone(zone *z)
print_string(", here="); print_cell(z->here - z->start); nl(); print_string(", here="); print_cell(z->here - z->start); nl();
} }
void factorvm::dump_generations() void factorvm::dump_generations()
{ {
cell i; cell i;
@ -258,7 +243,6 @@ void factorvm::dump_generations()
nl(); nl();
} }
void factorvm::dump_objects(cell type) void factorvm::dump_objects(cell type)
{ {
gc(); gc();
@ -280,7 +264,6 @@ void factorvm::dump_objects(cell type)
} }
void factorvm::find_data_references_step(cell *scan) void factorvm::find_data_references_step(cell *scan)
{ {
if(look_for == *scan) if(look_for == *scan)
@ -309,7 +292,6 @@ void factorvm::find_data_references(cell look_for_)
end_scan(); end_scan();
} }
/* Dump all code blocks for debugging */ /* Dump all code blocks for debugging */
void factorvm::dump_code_heap() void factorvm::dump_code_heap()
{ {
@ -351,7 +333,6 @@ void factorvm::dump_code_heap()
print_cell(literal_size); print_string(" bytes of literal data\n"); print_cell(literal_size); print_string(" bytes of literal data\n");
} }
void factorvm::factorbug() void factorvm::factorbug()
{ {
if(fep_disabled) if(fep_disabled)
@ -496,7 +477,6 @@ void factorvm::factorbug()
} }
} }
inline void factorvm::primitive_die() inline void factorvm::primitive_die()
{ {
print_string("The die word was called by the library. Unless you called it yourself,\n"); print_string("The die word was called by the library. Unless you called it yourself,\n");

1
vm/debug.hpp
View File

@ -1,7 +1,6 @@
namespace factor namespace factor
{ {
PRIMITIVE(die); PRIMITIVE(die);
} }

2
vm/errors.cpp
View File

@ -76,7 +76,6 @@ void factorvm::general_error(vm_error_type error, cell arg1, cell arg2, stack_fr
tag_fixnum(error),arg1,arg2),callstack_top); tag_fixnum(error),arg1,arg2),callstack_top);
} }
void factorvm::type_error(cell type, cell tagged) void factorvm::type_error(cell type, cell tagged)
{ {
general_error(ERROR_TYPE,tag_fixnum(type),tagged,NULL); general_error(ERROR_TYPE,tag_fixnum(type),tagged,NULL);
@ -87,7 +86,6 @@ void factorvm::not_implemented_error()
general_error(ERROR_NOT_IMPLEMENTED,F,F,NULL); general_error(ERROR_NOT_IMPLEMENTED,F,F,NULL);
} }
/* Test if 'fault' is in the guard page at the top or bottom (depending on /* Test if 'fault' is in the guard page at the top or bottom (depending on
offset being 0 or -1) of area+area_size */ offset being 0 or -1) of area+area_size */
bool factorvm::in_page(cell fault, cell area, cell area_size, int offset) bool factorvm::in_page(cell fault, cell area, cell area_size, int offset)

2
vm/factor.cpp
View File

@ -183,7 +183,6 @@ void factorvm::start_factor(vm_parameters *p)
unnest_stacks(); unnest_stacks();
} }
char *factorvm::factor_eval_string(char *string) char *factorvm::factor_eval_string(char *string)
{ {
char *(*callback)(char *) = (char *(*)(char *))alien_offset(userenv[EVAL_CALLBACK_ENV]); char *(*callback)(char *) = (char *(*)(char *))alien_offset(userenv[EVAL_CALLBACK_ENV]);
@ -231,7 +230,6 @@ void* start_standalone_factor_thread(void *arg)
return 0; return 0;
} }
VM_C_API void start_standalone_factor(int argc, vm_char **argv) VM_C_API void start_standalone_factor(int argc, vm_char **argv)
{ {
factorvm *newvm = new factorvm; factorvm *newvm = new factorvm;

15
vm/image.cpp
View File

@ -14,8 +14,6 @@ void factorvm::init_objects(image_header *h)
bignum_neg_one = h->bignum_neg_one; bignum_neg_one = h->bignum_neg_one;
} }
void factorvm::load_data_heap(FILE *file, image_header *h, vm_parameters *p) void factorvm::load_data_heap(FILE *file, image_header *h, vm_parameters *p)
{ {
cell good_size = h->data_size + (1 << 20); cell good_size = h->data_size + (1 << 20);
@ -49,8 +47,6 @@ void factorvm::load_data_heap(FILE *file, image_header *h, vm_parameters *p)
data_relocation_base = h->data_relocation_base; data_relocation_base = h->data_relocation_base;
} }
void factorvm::load_code_heap(FILE *file, image_header *h, vm_parameters *p) void factorvm::load_code_heap(FILE *file, image_header *h, vm_parameters *p)
{ {
if(h->code_size > p->code_size) if(h->code_size > p->code_size)
@ -76,7 +72,6 @@ void factorvm::load_code_heap(FILE *file, image_header *h, vm_parameters *p)
build_free_list(&code,h->code_size); build_free_list(&code,h->code_size);
} }
/* Save the current image to disk */ /* Save the current image to disk */
bool factorvm::save_image(const vm_char *filename) bool factorvm::save_image(const vm_char *filename)
{ {
@ -123,7 +118,6 @@ bool factorvm::save_image(const vm_char *filename)
return ok; return ok;
} }
inline void factorvm::primitive_save_image() inline void factorvm::primitive_save_image()
{ {
/* do a full GC to push everything into tenured space */ /* do a full GC to push everything into tenured space */
@ -191,7 +185,6 @@ template <typename TYPE> void factorvm::code_fixup(TYPE **handle)
*handle = new_ptr; *handle = new_ptr;
} }
void factorvm::fixup_word(word *word) void factorvm::fixup_word(word *word)
{ {
if(word->code) if(word->code)
@ -201,7 +194,6 @@ void factorvm::fixup_word(word *word)
code_fixup(&word->xt); code_fixup(&word->xt);
} }
void factorvm::fixup_quotation(quotation *quot) void factorvm::fixup_quotation(quotation *quot)
{ {
if(quot->code) if(quot->code)
@ -213,13 +205,11 @@ void factorvm::fixup_quotation(quotation *quot)
quot->xt = (void *)lazy_jit_compile; quot->xt = (void *)lazy_jit_compile;
} }
void factorvm::fixup_alien(alien *d) void factorvm::fixup_alien(alien *d)
{ {
d->expired = T; d->expired = T;
} }
void factorvm::fixup_stack_frame(stack_frame *frame) void factorvm::fixup_stack_frame(stack_frame *frame)
{ {
code_fixup(&frame->xt); code_fixup(&frame->xt);
@ -236,7 +226,6 @@ void factorvm::fixup_callstack_object(callstack *stack)
iterate_callstack_object(stack,factor::fixup_stack_frame); iterate_callstack_object(stack,factor::fixup_stack_frame);
} }
/* Initialize an object in a newly-loaded image */ /* Initialize an object in a newly-loaded image */
void factorvm::relocate_object(object *object) void factorvm::relocate_object(object *object)
{ {
@ -281,7 +270,6 @@ void factorvm::relocate_object(object *object)
} }
} }
/* Since the image might have been saved with a different base address than /* Since the image might have been saved with a different base address than
where it is loaded, we need to fix up pointers in the image. */ where it is loaded, we need to fix up pointers in the image. */
void factorvm::relocate_data() void factorvm::relocate_data()
@ -309,7 +297,6 @@ void factorvm::relocate_data()
} }
} }
void factorvm::fixup_code_block(code_block *compiled) void factorvm::fixup_code_block(code_block *compiled)
{ {
/* relocate literal table data */ /* relocate literal table data */
@ -329,7 +316,6 @@ void factorvm::relocate_code()
iterate_code_heap(factor::fixup_code_block); iterate_code_heap(factor::fixup_code_block);
} }
/* Read an image file from disk, only done once during startup */ /* Read an image file from disk, only done once during startup */
/* This function also initializes the data and code heaps */ /* This function also initializes the data and code heaps */
void factorvm::load_image(vm_parameters *p) void factorvm::load_image(vm_parameters *p)
@ -366,5 +352,4 @@ void factorvm::load_image(vm_parameters *p)
userenv[IMAGE_ENV] = allot_alien(F,(cell)p->image_path); userenv[IMAGE_ENV] = allot_alien(F,(cell)p->image_path);
} }
} }

2
vm/inline_cache.cpp
View File

@ -3,7 +3,6 @@
namespace factor namespace factor
{ {
void factorvm::init_inline_caching(int max_size) void factorvm::init_inline_caching(int max_size)
{ {
max_pic_size = max_size; max_pic_size = max_size;
@ -251,7 +250,6 @@ VM_C_API void *inline_cache_miss(cell return_address, factorvm *myvm)
return VM_PTR->inline_cache_miss(return_address); return VM_PTR->inline_cache_miss(return_address);
} }
inline void factorvm::primitive_reset_inline_cache_stats() inline void factorvm::primitive_reset_inline_cache_stats()
{ {
cold_call_to_ic_transitions = ic_to_pic_transitions = pic_to_mega_transitions = 0; cold_call_to_ic_transitions = ic_to_pic_transitions = pic_to_mega_transitions = 0;

4
vm/inlineimpls.hpp
View File

@ -18,13 +18,11 @@ inline card *factorvm::addr_to_card(cell a)
return (card*)(((cell)(a) >> card_bits) + cards_offset); return (card*)(((cell)(a) >> card_bits) + cards_offset);
} }
inline cell factorvm::card_to_addr(card *c) inline cell factorvm::card_to_addr(card *c)
{ {
return ((cell)c - cards_offset) << card_bits; return ((cell)c - cards_offset) << card_bits;
} }
inline cell factorvm::card_offset(card *c) inline cell factorvm::card_offset(card *c)
{ {
return *(c - (cell)data->cards + (cell)data->allot_markers); return *(c - (cell)data->cards + (cell)data->allot_markers);
@ -66,7 +64,6 @@ inline void factorvm::allot_barrier(object *address)
*ptr = ((cell)address & addr_card_mask); *ptr = ((cell)address & addr_card_mask);
} }
//data_gc.hpp //data_gc.hpp
inline bool factorvm::collecting_accumulation_gen_p() inline bool factorvm::collecting_accumulation_gen_p()
{ {
@ -372,7 +369,6 @@ template<typename TYPE> void factorvm::iterate_callstack(cell top, cell bottom,
} }
} }
// data_heap.hpp // data_heap.hpp
/* Every object has a regular representation in the runtime, which makes GC /* Every object has a regular representation in the runtime, which makes GC
much simpler. Every slot of the object until binary_payload_start is a pointer much simpler. Every slot of the object until binary_payload_start is a pointer

2
vm/io.cpp
View File

@ -21,7 +21,6 @@ void factorvm::init_c_io()
userenv[STDERR_ENV] = allot_alien(F,(cell)stderr); userenv[STDERR_ENV] = allot_alien(F,(cell)stderr);
} }
void factorvm::io_error() void factorvm::io_error()
{ {
#ifndef WINCE #ifndef WINCE
@ -32,7 +31,6 @@ void factorvm::io_error()
general_error(ERROR_IO,tag_fixnum(errno),F,NULL); general_error(ERROR_IO,tag_fixnum(errno),F,NULL);
} }
inline void factorvm::primitive_fopen() inline void factorvm::primitive_fopen()
{ {
gc_root<byte_array> mode(dpop(),this); gc_root<byte_array> mode(dpop(),this);

1
vm/mach_signal.cpp
View File

@ -150,7 +150,6 @@ catch_exception_raise (mach_port_t exception_port,
return KERN_SUCCESS; return KERN_SUCCESS;
} }
/* The main function of the thread listening for exceptions. */ /* The main function of the thread listening for exceptions. */
static void * static void *
mach_exception_thread (void *arg) mach_exception_thread (void *arg)

1
vm/mach_signal.hpp
View File

@ -38,7 +38,6 @@ Modified for Factor by Slava Pestov */
exception thread directly. */ exception thread directly. */
extern "C" boolean_t exc_server (mach_msg_header_t *request_msg, mach_msg_header_t *reply_msg); extern "C" boolean_t exc_server (mach_msg_header_t *request_msg, mach_msg_header_t *reply_msg);
/* http://web.mit.edu/darwin/src/modules/xnu/osfmk/man/catch_exception_raise.html /* http://web.mit.edu/darwin/src/modules/xnu/osfmk/man/catch_exception_raise.html
These functions are defined in this file, and called by exc_server. These functions are defined in this file, and called by exc_server.
FIXME: What needs to be done when this code is put into a shared library? */ FIXME: What needs to be done when this code is put into a shared library? */

4
vm/math.cpp
View File

@ -71,19 +71,16 @@ inline fixnum factorvm::sign_mask(fixnum x)
return x >> (WORD_SIZE - 1); return x >> (WORD_SIZE - 1);
} }
inline fixnum factorvm::branchless_max(fixnum x, fixnum y) inline fixnum factorvm::branchless_max(fixnum x, fixnum y)
{ {
return (x - ((x - y) & sign_mask(x - y))); return (x - ((x - y) & sign_mask(x - y)));
} }
inline fixnum factorvm::branchless_abs(fixnum x) inline fixnum factorvm::branchless_abs(fixnum x)
{ {
return (x ^ sign_mask(x)) - sign_mask(x); return (x ^ sign_mask(x)) - sign_mask(x);
} }
inline void factorvm::primitive_fixnum_shift() inline void factorvm::primitive_fixnum_shift()
{ {
fixnum y = untag_fixnum(dpop()); fixnum y = untag_fixnum(dpop());
@ -397,7 +394,6 @@ cell factorvm::unbox_array_size()
return 0; /* can't happen */ return 0; /* can't happen */
} }
inline void factorvm::primitive_fixnum_to_float() inline void factorvm::primitive_fixnum_to_float()
{ {
drepl(allot_float(fixnum_to_float(dpeek()))); drepl(allot_float(fixnum_to_float(dpeek())));

4
vm/os-unix.cpp
View File

@ -17,7 +17,6 @@ THREADHANDLE start_thread(void *(*start_routine)(void *),void *args)
return thread; return thread;
} }
pthread_key_t tlsKey = 0; pthread_key_t tlsKey = 0;
void init_platform_globals() void init_platform_globals()
@ -78,7 +77,6 @@ void factorvm::ffi_dlclose(dll *dll)
inline void factorvm::primitive_existsp() inline void factorvm::primitive_existsp()
{ {
struct stat sb; struct stat sb;
@ -148,7 +146,6 @@ stack_frame *factorvm::uap_stack_pointer(void *uap)
} }
void factorvm::memory_signal_handler(int signal, siginfo_t *siginfo, void *uap) void factorvm::memory_signal_handler(int signal, siginfo_t *siginfo, void *uap)
{ {
signal_fault_addr = (cell)siginfo->si_addr; signal_fault_addr = (cell)siginfo->si_addr;
@ -161,7 +158,6 @@ void memory_signal_handler(int signal, siginfo_t *siginfo, void *uap)
SIGNAL_VM_PTR()->memory_signal_handler(signal,siginfo,uap); SIGNAL_VM_PTR()->memory_signal_handler(signal,siginfo,uap);
} }
void factorvm::misc_signal_handler(int signal, siginfo_t *siginfo, void *uap) void factorvm::misc_signal_handler(int signal, siginfo_t *siginfo, void *uap)
{ {
signal_number = signal; signal_number = signal;

2
vm/os-windows.cpp
View File

@ -56,7 +56,6 @@ bool factorvm::windows_stat(vm_char *path)
return ret; return ret;
} }
void factorvm::windows_image_path(vm_char *full_path, vm_char *temp_path, unsigned int length) void factorvm::windows_image_path(vm_char *full_path, vm_char *temp_path, unsigned int length)
{ {
snwprintf(temp_path, length-1, L"%s.image", full_path); snwprintf(temp_path, length-1, L"%s.image", full_path);
@ -91,7 +90,6 @@ const vm_char *factorvm::vm_executable_path()
return safe_strdup(full_path); return safe_strdup(full_path);
} }
inline void factorvm::primitive_existsp() inline void factorvm::primitive_existsp()
{ {
vm_char *path = untag_check<byte_array>(dpop())->data<vm_char>(); vm_char *path = untag_check<byte_array>(dpop())->data<vm_char>();

1
vm/os-windows.hpp
View File

@ -41,7 +41,6 @@ typedef wchar_t vm_char;
/* Difference between Jan 1 00:00:00 1601 and Jan 1 00:00:00 1970 */ /* Difference between Jan 1 00:00:00 1601 and Jan 1 00:00:00 1970 */
#define EPOCH_OFFSET 0x019db1ded53e8000LL #define EPOCH_OFFSET 0x019db1ded53e8000LL
inline static void init_signals() {} inline static void init_signals() {}
inline static void early_init() {} inline static void early_init() {}

4
vm/profiler.cpp
View File

@ -3,13 +3,11 @@
namespace factor namespace factor
{ {
void factorvm::init_profiler() void factorvm::init_profiler()
{ {
profiling_p = false; profiling_p = false;
} }
/* Allocates memory */ /* Allocates memory */
code_block *factorvm::compile_profiling_stub(cell word_) code_block *factorvm::compile_profiling_stub(cell word_)
{ {
@ -21,7 +19,6 @@ code_block *factorvm::compile_profiling_stub(cell word_)
return jit.to_code_block(); return jit.to_code_block();
} }
/* Allocates memory */ /* Allocates memory */
void factorvm::set_profiling(bool profiling) void factorvm::set_profiling(bool profiling)
{ {
@ -50,7 +47,6 @@ void factorvm::set_profiling(bool profiling)
iterate_code_heap(factor::relocate_code_block); iterate_code_heap(factor::relocate_code_block);
} }
inline void factorvm::primitive_profiling() inline void factorvm::primitive_profiling()
{ {
set_profiling(to_boolean(dpop())); set_profiling(to_boolean(dpop()));

1
vm/run.cpp
View File

@ -3,7 +3,6 @@
namespace factor namespace factor
{ {
inline void factorvm::primitive_getenv() inline void factorvm::primitive_getenv()
{ {
fixnum e = untag_fixnum(dpeek()); fixnum e = untag_fixnum(dpeek());

9
vm/strings.cpp
View File

@ -22,13 +22,11 @@ cell factorvm::string_nth(string* str, cell index)
} }
} }
void factorvm::set_string_nth_fast(string *str, cell index, cell ch) void factorvm::set_string_nth_fast(string *str, cell index, cell ch)
{ {
str->data()[index] = ch; str->data()[index] = ch;
} }
void factorvm::set_string_nth_slow(string *str_, cell index, cell ch) void factorvm::set_string_nth_slow(string *str_, cell index, cell ch)
{ {
gc_root<string> str(str_,this); gc_root<string> str(str_,this);
@ -56,7 +54,6 @@ void factorvm::set_string_nth_slow(string *str_, cell index, cell ch)
aux->data<u16>()[index] = ((ch >> 7) ^ 1); aux->data<u16>()[index] = ((ch >> 7) ^ 1);
} }
/* allocates memory */ /* allocates memory */
void factorvm::set_string_nth(string *str, cell index, cell ch) void factorvm::set_string_nth(string *str, cell index, cell ch)
{ {
@ -66,7 +63,6 @@ void factorvm::set_string_nth(string *str, cell index, cell ch)
set_string_nth_slow(str,index,ch); set_string_nth_slow(str,index,ch);
} }
/* Allocates memory */ /* Allocates memory */
string *factorvm::allot_string_internal(cell capacity) string *factorvm::allot_string_internal(cell capacity)
{ {
@ -79,7 +75,6 @@ string *factorvm::allot_string_internal(cell capacity)
return str; return str;
} }
/* Allocates memory */ /* Allocates memory */
void factorvm::fill_string(string *str_, cell start, cell capacity, cell fill) void factorvm::fill_string(string *str_, cell start, cell capacity, cell fill)
{ {
@ -96,7 +91,6 @@ void factorvm::fill_string(string *str_, cell start, cell capacity, cell fill)
} }
} }
/* Allocates memory */ /* Allocates memory */
string *factorvm::allot_string(cell capacity, cell fill) string *factorvm::allot_string(cell capacity, cell fill)
{ {
@ -105,7 +99,6 @@ string *factorvm::allot_string(cell capacity, cell fill)
return str.untagged(); return str.untagged();
} }
inline void factorvm::primitive_string() inline void factorvm::primitive_string()
{ {
cell initial = to_cell(dpop()); cell initial = to_cell(dpop());
@ -125,7 +118,6 @@ bool factorvm::reallot_string_in_place_p(string *str, cell capacity)
&& capacity <= string_capacity(str); && capacity <= string_capacity(str);
} }
string* factorvm::reallot_string(string *str_, cell capacity) string* factorvm::reallot_string(string *str_, cell capacity)
{ {
gc_root<string> str(str_,this); gc_root<string> str(str_,this);
@ -168,7 +160,6 @@ string* factorvm::reallot_string(string *str_, cell capacity)
} }
} }
inline void factorvm::primitive_resize_string() inline void factorvm::primitive_resize_string()
{ {
string* str = untag_check<string>(dpop()); string* str = untag_check<string>(dpop());

2
vm/utilities.cpp
View File

@ -18,7 +18,6 @@ vm_char *safe_strdup(const vm_char *str)
return ptr; return ptr;
} }
/* We don't use printf directly, because format directives are not portable. /* We don't use printf directly, because format directives are not portable.
Instead we define the common cases here. */ Instead we define the common cases here. */
void nl() void nl()
@ -31,7 +30,6 @@ void print_string(const char *str)
fputs(str,stdout); fputs(str,stdout);
} }
void print_cell(cell x) void print_cell(cell x)
{ {
printf(CELL_FORMAT,x); printf(CELL_FORMAT,x);

4
vm/vm.hpp
View File

@ -166,7 +166,6 @@ struct factorvm : factorvmdata {
inline void write_barrier(object *obj); inline void write_barrier(object *obj);
inline void allot_barrier(object *address); inline void allot_barrier(object *address);
//data_gc //data_gc
void init_data_gc(); void init_data_gc();
object *copy_untagged_object_impl(object *pointer, cell size); object *copy_untagged_object_impl(object *pointer, cell size);
@ -454,7 +453,6 @@ struct factorvm : factorvmdata {
void compact_code_heap(); void compact_code_heap();
inline void check_code_pointer(cell ptr); inline void check_code_pointer(cell ptr);
//image //image
void init_objects(image_header *h); void init_objects(image_header *h);
void load_data_heap(FILE *file, image_header *h, vm_parameters *p); void load_data_heap(FILE *file, image_header *h, vm_parameters *p);
@ -498,7 +496,6 @@ struct factorvm : factorvmdata {
template<typename T> void iterate_callstack(cell top, cell bottom, T &iterator); template<typename T> void iterate_callstack(cell top, cell bottom, T &iterator);
inline void do_slots(cell obj, void (* iter)(cell *,factorvm*)); inline void do_slots(cell obj, void (* iter)(cell *,factorvm*));
//alien //alien
char *pinned_alien_offset(cell obj); char *pinned_alien_offset(cell obj);
cell allot_alien(cell delegate_, cell displacement); cell allot_alien(cell delegate_, cell displacement);
@ -614,7 +611,6 @@ struct factorvm : factorvmdata {
void print_vm_data(); void print_vm_data();
}; };
#ifndef FACTOR_REENTRANT #ifndef FACTOR_REENTRANT
#define FACTOR_SINGLE_THREADED_SINGLETON #define FACTOR_SINGLE_THREADED_SINGLETON
#endif #endif

1
vm/write_barrier.cpp
View File

@ -2,4 +2,3 @@
using namespace factor; using namespace factor;

1
vm/write_barrier.hpp
View File

@ -19,7 +19,6 @@ static const cell card_bits = 8;
static const cell card_size = (1<<card_bits); static const cell card_size = (1<<card_bits);
static const cell addr_card_mask = (card_size-1); static const cell addr_card_mask = (card_size-1);
typedef u8 card_deck; typedef u8 card_deck;
static const cell deck_bits = (card_bits + 10); static const cell deck_bits = (card_bits + 10);