VM: Fixup cast formatting after clang-format
clang-format doesn't recognize casts to non-pointer/non-template types so it winds up adding a space between the right paren and the expression and then failing to recognize prefix operators in the process (e.g. foo = (cell) & bar; should be foo = (cell)&bar;). This commit manually fixes up the major cases (fixnum, cell, all types ending in _t).db4
Erik Charlebois
parent
88d7c10d03
commit
ffe41b3d7f
|
|
@ -48,7 +48,7 @@ cell factor_vm::allot_alien(cell delegate_, cell displacement) {
|
|||
|
||||
/* Allocates memory */
|
||||
cell factor_vm::allot_alien(void* address) {
|
||||
return allot_alien(false_object, (cell) address);
|
||||
return allot_alien(false_object, (cell)address);
|
||||
}
|
||||
|
||||
/* make an alien pointing at an offset of another alien */
|
||||
|
|
@ -73,7 +73,7 @@ void factor_vm::primitive_displaced_alien() {
|
|||
if the object is a byte array, as a sanity check. */
|
||||
/* Allocates memory (from_unsigned_cell can allocate) */
|
||||
void factor_vm::primitive_alien_address() {
|
||||
ctx->replace(from_unsigned_cell((cell) pinned_alien_offset(ctx->peek())));
|
||||
ctx->replace(from_unsigned_cell((cell)pinned_alien_offset(ctx->peek())));
|
||||
}
|
||||
|
||||
/* pop ( alien n ) from datastack, return alien's address plus n */
|
||||
|
|
@ -89,7 +89,7 @@ void* factor_vm::alien_pointer() {
|
|||
} \
|
||||
VM_C_API void primitive_set_alien_##name(factor_vm * parent) { \
|
||||
type* ptr = (type*)parent->alien_pointer(); \
|
||||
type value = (type) parent->to(parent->ctx->pop()); \
|
||||
type value = (type)parent->to(parent->ctx->pop()); \
|
||||
*ptr = value; \
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,10 +3,10 @@ namespace factor { void abort(); }
|
|||
#ifdef FACTOR_DEBUG
|
||||
#define FACTOR_ASSERT(condition) \
|
||||
((condition) \
|
||||
? (void) 0 \
|
||||
? (void)0 \
|
||||
: (::fprintf(stderr, "assertion \"%s\" failed: file \"%s\", line %d\n", \
|
||||
#condition, __FILE__, __LINE__), \
|
||||
::factor::abort()))
|
||||
#else
|
||||
#define FACTOR_ASSERT(condition) ((void) 0)
|
||||
#define FACTOR_ASSERT(condition) ((void)0)
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -15,21 +15,21 @@ __forceinline static bool cas(volatile fixnum* ptr, fixnum old_val,
|
|||
}
|
||||
|
||||
__forceinline static cell fetch_add(volatile cell* ptr, cell val) {
|
||||
return (cell)
|
||||
InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr), (LONG) val);
|
||||
return (cell)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
|
||||
(LONG) val);
|
||||
}
|
||||
__forceinline static fixnum fetch_add(volatile fixnum* ptr, fixnum val) {
|
||||
return (fixnum)
|
||||
InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr), (LONG) val);
|
||||
return (fixnum)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
|
||||
(LONG) val);
|
||||
}
|
||||
|
||||
__forceinline static cell fetch_subtract(volatile cell* ptr, cell val) {
|
||||
return (cell) InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
|
||||
-(LONG) val);
|
||||
return (cell)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
|
||||
-(LONG)val);
|
||||
}
|
||||
__forceinline static fixnum fetch_subtract(volatile fixnum* ptr, fixnum val) {
|
||||
return (fixnum) InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
|
||||
-(LONG) val);
|
||||
return (fixnum)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
|
||||
-(LONG)val);
|
||||
}
|
||||
|
||||
__forceinline static void fence() { MemoryBarrier(); }
|
||||
|
|
|
|||
|
|
@ -4,32 +4,32 @@ namespace factor {
|
|||
namespace atomic {
|
||||
__forceinline static bool cas(volatile cell* ptr, cell old_val, cell new_val) {
|
||||
return InterlockedCompareExchange64(reinterpret_cast<volatile LONG64*>(ptr),
|
||||
(LONG64) old_val, (LONG64) new_val) ==
|
||||
(LONG64) old_val;
|
||||
(LONG64)old_val, (LONG64)new_val) ==
|
||||
(LONG64)old_val;
|
||||
}
|
||||
__forceinline static bool cas(volatile fixnum* ptr, fixnum old_val,
|
||||
fixnum new_val) {
|
||||
return InterlockedCompareExchange64(reinterpret_cast<volatile LONG64*>(ptr),
|
||||
(LONG64) old_val, (LONG64) new_val) ==
|
||||
(LONG64) old_val;
|
||||
(LONG64)old_val, (LONG64)new_val) ==
|
||||
(LONG64)old_val;
|
||||
}
|
||||
|
||||
__forceinline static cell fetch_add(volatile cell* ptr, cell val) {
|
||||
return (cell) InterlockedExchangeAdd64(
|
||||
reinterpret_cast<volatile LONG64*>(ptr), (LONG64) val);
|
||||
return (cell)InterlockedExchangeAdd64(
|
||||
reinterpret_cast<volatile LONG64*>(ptr), (LONG64)val);
|
||||
}
|
||||
__forceinline static fixnum fetch_add(volatile fixnum* ptr, fixnum val) {
|
||||
return (fixnum) InterlockedExchangeAdd64(
|
||||
reinterpret_cast<volatile LONG64*>(ptr), (LONG64) val);
|
||||
return (fixnum)InterlockedExchangeAdd64(
|
||||
reinterpret_cast<volatile LONG64*>(ptr), (LONG64)val);
|
||||
}
|
||||
|
||||
__forceinline static cell fetch_subtract(volatile cell* ptr, cell val) {
|
||||
return (cell) InterlockedExchangeAdd64(
|
||||
reinterpret_cast<volatile LONG64*>(ptr), -(LONG64) val);
|
||||
return (cell)InterlockedExchangeAdd64(
|
||||
reinterpret_cast<volatile LONG64*>(ptr), -(LONG64)val);
|
||||
}
|
||||
__forceinline static fixnum fetch_subtract(volatile fixnum* ptr, fixnum val) {
|
||||
return (fixnum) InterlockedExchangeAdd64(
|
||||
reinterpret_cast<volatile LONG64*>(ptr), -(LONG64) val);
|
||||
return (fixnum)InterlockedExchangeAdd64(
|
||||
reinterpret_cast<volatile LONG64*>(ptr), -(LONG64)val);
|
||||
}
|
||||
|
||||
__forceinline static void fence() { MemoryBarrier(); }
|
||||
|
|
|
|||
|
|
@ -330,7 +330,7 @@ BIGNUM_TO_FOO(ulong_long, uint64_t, int64_t, uint64_t)
|
|||
significand *= (factor); \
|
||||
digit = ((bignum_digit_type) significand); \
|
||||
(*--scan) = digit; \
|
||||
significand -= ((double) digit); \
|
||||
significand -= ((double)digit); \
|
||||
}
|
||||
|
||||
#define inf std::numeric_limits<double>::infinity()
|
||||
|
|
@ -355,7 +355,7 @@ bignum* factor_vm::double_to_bignum(double x) {
|
|||
bignum_digit_type digit;
|
||||
int odd_bits = (exponent % BIGNUM_DIGIT_LENGTH);
|
||||
if (odd_bits > 0)
|
||||
DTB_WRITE_DIGIT((fixnum) 1 << odd_bits);
|
||||
DTB_WRITE_DIGIT((fixnum)1 << odd_bits);
|
||||
while (start < scan) {
|
||||
if (significand == 0) {
|
||||
while (start < scan)
|
||||
|
|
@ -924,7 +924,7 @@ void factor_vm::bignum_destructive_normalization(bignum* source, bignum* target,
|
|||
bignum_digit_type* end_source = (scan_source + (BIGNUM_LENGTH(source)));
|
||||
bignum_digit_type* end_target = (scan_target + (BIGNUM_LENGTH(target)));
|
||||
int shift_right = (BIGNUM_DIGIT_LENGTH - shift_left);
|
||||
bignum_digit_type mask = (((cell) 1 << shift_right) - 1);
|
||||
bignum_digit_type mask = (((cell)1 << shift_right) - 1);
|
||||
while (scan_source < end_source) {
|
||||
digit = (*scan_source++);
|
||||
(*scan_target++) = (((digit & mask) << shift_left) | carry);
|
||||
|
|
@ -944,7 +944,7 @@ void factor_vm::bignum_destructive_unnormalization(bignum* bignum,
|
|||
bignum_digit_type digit;
|
||||
bignum_digit_type carry = 0;
|
||||
int shift_left = (BIGNUM_DIGIT_LENGTH - shift_right);
|
||||
bignum_digit_type mask = (((fixnum) 1 << shift_right) - 1);
|
||||
bignum_digit_type mask = (((fixnum)1 << shift_right) - 1);
|
||||
while (start < scan) {
|
||||
digit = (*--scan);
|
||||
(*scan) = ((digit >> shift_right) | carry);
|
||||
|
|
@ -1605,7 +1605,7 @@ int factor_vm::bignum_unsigned_logbitp(int shift, bignum* bignum) {
|
|||
return 0;
|
||||
bignum_digit_type digit = (BIGNUM_REF(bignum, index));
|
||||
int p = shift % BIGNUM_DIGIT_LENGTH;
|
||||
bignum_digit_type mask = ((fixnum) 1) << p;
|
||||
bignum_digit_type mask = ((fixnum)1) << p;
|
||||
return (digit & mask) ? 1 : 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ typedef int64_t bignum_twodigit_type;
|
|||
|
||||
#define BIGNUM_DIGIT_LENGTH (((sizeof(bignum_digit_type)) * CHAR_BIT) - 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)
|
||||
#define BIGNUM_RADIX_ROOT (((bignum_digit_type) 1) << BIGNUM_HALF_DIGIT_LENGTH)
|
||||
#define BIGNUM_DIGIT_MASK (BIGNUM_RADIX - 1)
|
||||
#define BIGNUM_HALF_DIGIT_MASK (BIGNUM_RADIX_ROOT - 1)
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ template <typename Block> struct bump_allocator {
|
|||
bump_allocator(cell size, cell start)
|
||||
: here(start), start(start), end(start + size), size(size) {}
|
||||
|
||||
bool contains_p(Block* block) { return ((cell) block - start) < size; }
|
||||
bool contains_p(Block* block) { return ((cell)block - start) < size; }
|
||||
|
||||
Block* allot(cell size) {
|
||||
cell h = here;
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ void callback_heap::store_callback_operand(code_block* stub, cell index,
|
|||
|
||||
void callback_heap::update(code_block* stub) {
|
||||
store_callback_operand(stub, setup_seh_p() ? 2 : 1,
|
||||
(cell) callback_entry_point(stub));
|
||||
(cell)callback_entry_point(stub));
|
||||
stub->flush_icache();
|
||||
}
|
||||
|
||||
|
|
@ -76,7 +76,7 @@ code_block* callback_heap::add(cell owner, cell return_rewind) {
|
|||
memcpy(stub->entry_point(), insns->data<void>(), size);
|
||||
|
||||
/* Store VM pointer */
|
||||
store_callback_operand(stub, 0, (cell) parent);
|
||||
store_callback_operand(stub, 0, (cell)parent);
|
||||
|
||||
cell index;
|
||||
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ struct callback_heap {
|
|||
void update();
|
||||
|
||||
code_block* next(code_block* stub) {
|
||||
return (code_block*)((cell) stub + stub->size());
|
||||
return (code_block*)((cell)stub + stub->size());
|
||||
}
|
||||
|
||||
template <typename Iterator> void each_callback(Iterator& iter) {
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ cell factor_vm::capture_callstack(context* ctx) {
|
|||
void* top = second_from_top_stack_frame(ctx);
|
||||
void* bottom = ctx->callstack_bottom;
|
||||
|
||||
fixnum size = std::max((fixnum) 0, (fixnum) bottom - (fixnum) top);
|
||||
fixnum size = std::max((fixnum)0, (fixnum)bottom - (fixnum)top);
|
||||
|
||||
callstack* stack = allot_callstack(size);
|
||||
memcpy(stack->top(), top, size);
|
||||
|
|
@ -48,8 +48,8 @@ void factor_vm::primitive_callstack_for() {
|
|||
void* factor_vm::frame_predecessor(void* frame_top) {
|
||||
void* addr = frame_return_address((void*)frame_top);
|
||||
FACTOR_ASSERT(addr != 0);
|
||||
code_block* owner = code->code_block_for_address((cell) addr);
|
||||
cell frame_size = owner->stack_frame_size_for_address((cell) addr);
|
||||
code_block* owner = code->code_block_for_address((cell)addr);
|
||||
cell frame_size = owner->stack_frame_size_for_address((cell)addr);
|
||||
return (void*)((char*)frame_top + frame_size);
|
||||
}
|
||||
|
||||
|
|
@ -99,14 +99,14 @@ void factor_vm::primitive_innermost_stack_frame_executing() {
|
|||
callstack* stack = untag_check<callstack>(ctx->peek());
|
||||
void* frame = stack->top();
|
||||
void* addr = frame_return_address(frame);
|
||||
ctx->replace(code->code_block_for_address((cell) addr)->owner_quot());
|
||||
ctx->replace(code->code_block_for_address((cell)addr)->owner_quot());
|
||||
}
|
||||
|
||||
void factor_vm::primitive_innermost_stack_frame_scan() {
|
||||
callstack* stack = untag_check<callstack>(ctx->peek());
|
||||
void* frame = stack->top();
|
||||
void* addr = frame_return_address(frame);
|
||||
ctx->replace(code->code_block_for_address((cell) addr)->scan(this, addr));
|
||||
ctx->replace(code->code_block_for_address((cell)addr)->scan(this, addr));
|
||||
}
|
||||
|
||||
void factor_vm::primitive_set_innermost_stack_frame_quot() {
|
||||
|
|
@ -120,7 +120,7 @@ void factor_vm::primitive_set_innermost_stack_frame_quot() {
|
|||
|
||||
void* inner = stack->top();
|
||||
void* addr = frame_return_address(inner);
|
||||
code_block* block = code->code_block_for_address((cell) addr);
|
||||
code_block* block = code->code_block_for_address((cell)addr);
|
||||
cell offset = block->offset(addr);
|
||||
set_frame_return_address(inner, (char*)quot->entry_point + offset);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,8 +21,8 @@ inline void factor_vm::iterate_callstack_object(callstack* stack_,
|
|||
void* fixed_addr = Fixup::translated_code_block_map
|
||||
? (void*)fixup.translate_code((code_block*)addr)
|
||||
: addr;
|
||||
code_block* owner = code->code_block_for_address((cell) fixed_addr);
|
||||
cell frame_size = owner->stack_frame_size_for_address((cell) fixed_addr);
|
||||
code_block* owner = code->code_block_for_address((cell)fixed_addr);
|
||||
cell frame_size = owner->stack_frame_size_for_address((cell)fixed_addr);
|
||||
|
||||
iterator(frame_top, frame_size, owner, fixed_addr);
|
||||
frame_offset += frame_size;
|
||||
|
|
@ -51,12 +51,12 @@ inline void factor_vm::iterate_callstack(context* ctx, Iterator& iterator,
|
|||
? (void*)fixup.translate_code((code_block*)addr)
|
||||
: addr;
|
||||
|
||||
code_block* owner = code->code_block_for_address((cell) fixed_addr);
|
||||
code_block* owner = code->code_block_for_address((cell)fixed_addr);
|
||||
code_block* fixed_owner =
|
||||
Fixup::translated_code_block_map ? owner : fixup.translate_code(owner);
|
||||
|
||||
cell frame_size =
|
||||
fixed_owner->stack_frame_size_for_address((cell) fixed_addr);
|
||||
fixed_owner->stack_frame_size_for_address((cell)fixed_addr);
|
||||
|
||||
void* fixed_addr_for_iter =
|
||||
Fixup::translated_code_block_map ? fixed_addr : addr;
|
||||
|
|
|
|||
|
|
@ -34,9 +34,9 @@ cell code_block::scan(factor_vm* vm, void* addr) const {
|
|||
cell factor_vm::compute_entry_point_address(cell obj) {
|
||||
switch (tagged<object>(obj).type()) {
|
||||
case WORD_TYPE:
|
||||
return (cell) untag<word>(obj)->entry_point;
|
||||
return (cell)untag<word>(obj)->entry_point;
|
||||
case QUOTATION_TYPE:
|
||||
return (cell) untag<quotation>(obj)->entry_point;
|
||||
return (cell)untag<quotation>(obj)->entry_point;
|
||||
default:
|
||||
critical_error("Expected word or quotation", obj);
|
||||
return 0;
|
||||
|
|
@ -45,13 +45,13 @@ cell factor_vm::compute_entry_point_address(cell obj) {
|
|||
|
||||
cell factor_vm::compute_entry_point_pic_address(word* w, cell tagged_quot) {
|
||||
if (!to_boolean(tagged_quot) || max_pic_size == 0)
|
||||
return (cell) w->entry_point;
|
||||
return (cell)w->entry_point;
|
||||
else {
|
||||
quotation* quot = untag<quotation>(tagged_quot);
|
||||
if (quot_compiled_p(quot))
|
||||
return (cell) quot->entry_point;
|
||||
return (cell)quot->entry_point;
|
||||
else
|
||||
return (cell) w->entry_point;
|
||||
return (cell)w->entry_point;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -162,7 +162,7 @@ cell factor_vm::compute_dlsym_address(array* parameters, cell index) {
|
|||
void* undefined_symbol = (void*)factor::undefined_symbol;
|
||||
undefined_symbol = FUNCTION_CODE_POINTER(undefined_symbol);
|
||||
if (d != NULL && !d->handle)
|
||||
return (cell) undefined_symbol;
|
||||
return (cell)undefined_symbol;
|
||||
|
||||
switch (tagged<object>(symbol).type()) {
|
||||
case BYTE_ARRAY_TYPE: {
|
||||
|
|
@ -170,9 +170,9 @@ cell factor_vm::compute_dlsym_address(array* parameters, cell index) {
|
|||
void* sym = ffi_dlsym(d, name);
|
||||
|
||||
if (sym)
|
||||
return (cell) sym;
|
||||
return (cell)sym;
|
||||
else
|
||||
return (cell) undefined_symbol;
|
||||
return (cell)undefined_symbol;
|
||||
}
|
||||
case ARRAY_TYPE: {
|
||||
array* names = untag<array>(symbol);
|
||||
|
|
@ -181,13 +181,13 @@ cell factor_vm::compute_dlsym_address(array* parameters, cell index) {
|
|||
void* sym = ffi_dlsym(d, name);
|
||||
|
||||
if (sym)
|
||||
return (cell) sym;
|
||||
return (cell)sym;
|
||||
}
|
||||
return (cell) undefined_symbol;
|
||||
return (cell)undefined_symbol;
|
||||
}
|
||||
default:
|
||||
critical_error("Bad symbol specifier", symbol);
|
||||
return (cell) undefined_symbol;
|
||||
return (cell)undefined_symbol;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -201,16 +201,16 @@ cell factor_vm::compute_dlsym_toc_address(array* parameters, cell index) {
|
|||
void* undefined_toc = (void*)factor::undefined_symbol;
|
||||
undefined_toc = FUNCTION_TOC_POINTER(undefined_toc);
|
||||
if (d != NULL && !d->handle)
|
||||
return (cell) undefined_toc;
|
||||
return (cell)undefined_toc;
|
||||
|
||||
switch (tagged<object>(symbol).type()) {
|
||||
case BYTE_ARRAY_TYPE: {
|
||||
symbol_char* name = alien_offset(symbol);
|
||||
void* toc = ffi_dlsym_toc(d, name);
|
||||
if (toc)
|
||||
return (cell) toc;
|
||||
return (cell)toc;
|
||||
else
|
||||
return (cell) undefined_toc;
|
||||
return (cell)undefined_toc;
|
||||
}
|
||||
case ARRAY_TYPE: {
|
||||
array* names = untag<array>(symbol);
|
||||
|
|
@ -219,19 +219,19 @@ cell factor_vm::compute_dlsym_toc_address(array* parameters, cell index) {
|
|||
void* toc = ffi_dlsym_toc(d, name);
|
||||
|
||||
if (toc)
|
||||
return (cell) toc;
|
||||
return (cell)toc;
|
||||
}
|
||||
return (cell) undefined_toc;
|
||||
return (cell)undefined_toc;
|
||||
}
|
||||
default:
|
||||
critical_error("Bad symbol specifier", symbol);
|
||||
return (cell) undefined_toc;
|
||||
return (cell)undefined_toc;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
cell factor_vm::compute_vm_address(cell arg) {
|
||||
return (cell) this + untag_fixnum(arg);
|
||||
return (cell)this + untag_fixnum(arg);
|
||||
}
|
||||
|
||||
void factor_vm::store_external_address(instruction_operand op) {
|
||||
|
|
@ -246,10 +246,10 @@ void factor_vm::store_external_address(instruction_operand op) {
|
|||
op.store_value(compute_dlsym_address(parameters, index));
|
||||
break;
|
||||
case RT_THIS:
|
||||
op.store_value((cell) compiled->entry_point());
|
||||
op.store_value((cell)compiled->entry_point());
|
||||
break;
|
||||
case RT_MEGAMORPHIC_CACHE_HITS:
|
||||
op.store_value((cell) & dispatch_stats.megamorphic_cache_hits);
|
||||
op.store_value((cell)&dispatch_stats.megamorphic_cache_hits);
|
||||
break;
|
||||
case RT_VM:
|
||||
op.store_value(compute_vm_address(array_nth(parameters, index)));
|
||||
|
|
@ -262,7 +262,7 @@ void factor_vm::store_external_address(instruction_operand op) {
|
|||
break;
|
||||
#ifdef WINDOWS
|
||||
case RT_EXCEPTION_HANDLER:
|
||||
op.store_value((cell) & factor::exception_handler);
|
||||
op.store_value((cell)&factor::exception_handler);
|
||||
break;
|
||||
#endif
|
||||
#ifdef FACTOR_PPC
|
||||
|
|
@ -271,10 +271,10 @@ void factor_vm::store_external_address(instruction_operand op) {
|
|||
break;
|
||||
#endif
|
||||
case RT_INLINE_CACHE_MISS:
|
||||
op.store_value((cell) & factor::inline_cache_miss);
|
||||
op.store_value((cell)&factor::inline_cache_miss);
|
||||
break;
|
||||
case RT_SAFEPOINT:
|
||||
op.store_value((cell) code->safepoint_page);
|
||||
op.store_value((cell)code->safepoint_page);
|
||||
break;
|
||||
default:
|
||||
critical_error("Bad rel type in store_external_address()", op.rel_type());
|
||||
|
|
@ -286,9 +286,9 @@ cell factor_vm::compute_here_address(cell arg, cell offset,
|
|||
code_block* compiled) {
|
||||
fixnum n = untag_fixnum(arg);
|
||||
if (n >= 0)
|
||||
return (cell) compiled->entry_point() + offset + n;
|
||||
return (cell)compiled->entry_point() + offset + n;
|
||||
else
|
||||
return (cell) compiled->entry_point() - n;
|
||||
return (cell)compiled->entry_point() - n;
|
||||
}
|
||||
|
||||
struct initial_code_block_visitor {
|
||||
|
|
@ -364,7 +364,7 @@ void factor_vm::fixup_labels(array* labels, code_block* compiled) {
|
|||
relocation_entry new_entry(RT_HERE, rel_class, offset);
|
||||
|
||||
instruction_operand op(new_entry, compiled, 0);
|
||||
op.store_value(target + (cell) compiled->entry_point());
|
||||
op.store_value(target + (cell)compiled->entry_point());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -440,9 +440,9 @@ code_block* factor_vm::add_code_block(code_block_type type, cell code_,
|
|||
block's instruction operands. In most cases this is done right after this
|
||||
method returns, except when compiling words with the non-optimizing
|
||||
compiler at the beginning of bootstrap */
|
||||
this->code->uninitialized_blocks
|
||||
.insert(std::make_pair(compiled, literals.value()));
|
||||
this->code->all_blocks.insert((cell) compiled);
|
||||
this->code->uninitialized_blocks.insert(
|
||||
std::make_pair(compiled, literals.value()));
|
||||
this->code->all_blocks.insert((cell)compiled);
|
||||
|
||||
/* next time we do a minor GC, we have to trace this code block, since
|
||||
the fields of the code_block struct might point into nursery or aging */
|
||||
|
|
@ -480,12 +480,12 @@ struct find_symbol_at_address_visitor {
|
|||
void factor_vm::undefined_symbol() {
|
||||
void* frame = ctx->callstack_top;
|
||||
void* return_address = frame_return_address(frame);
|
||||
code_block* compiled = code->code_block_for_address((cell) return_address);
|
||||
find_symbol_at_address_visitor visitor(this, (cell) return_address);
|
||||
code_block* compiled = code->code_block_for_address((cell)return_address);
|
||||
find_symbol_at_address_visitor visitor(this, (cell)return_address);
|
||||
compiled->each_instruction_operand(visitor);
|
||||
if (!to_boolean(visitor.symbol))
|
||||
critical_error("Can't find RT_DLSYM at return address",
|
||||
(cell) return_address);
|
||||
(cell)return_address);
|
||||
else
|
||||
general_error(ERROR_UNDEFINED_SYMBOL, visitor.symbol, visitor.library);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ struct code_block {
|
|||
return (gc_info*)((uint8_t*)this + size() - sizeof(gc_info));
|
||||
}
|
||||
|
||||
void flush_icache() { factor::flush_icache((cell) this, size()); }
|
||||
void flush_icache() { factor::flush_icache((cell)this, size()); }
|
||||
|
||||
template <typename Iterator> void each_instruction_operand(Iterator& iter) {
|
||||
if (to_boolean(relocation)) {
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ void code_heap::free(code_block* compiled) {
|
|||
FACTOR_ASSERT(!uninitialized_p(compiled));
|
||||
points_to_nursery.erase(compiled);
|
||||
points_to_aging.erase(compiled);
|
||||
all_blocks.erase((cell) compiled);
|
||||
all_blocks.erase((cell)compiled);
|
||||
allocator->free(compiled);
|
||||
}
|
||||
|
||||
|
|
@ -66,9 +66,9 @@ struct clear_free_blocks_from_all_blocks_iterator {
|
|||
|
||||
void operator()(code_block* free_block, cell size) {
|
||||
std::set<cell>::iterator erase_from =
|
||||
code->all_blocks.lower_bound((cell) free_block);
|
||||
code->all_blocks.lower_bound((cell)free_block);
|
||||
std::set<cell>::iterator erase_to =
|
||||
code->all_blocks.lower_bound((cell) free_block + size);
|
||||
code->all_blocks.lower_bound((cell)free_block + size);
|
||||
|
||||
code->all_blocks.erase(erase_from, erase_to);
|
||||
}
|
||||
|
|
@ -89,7 +89,7 @@ struct all_blocks_set_verifier {
|
|||
: all_blocks(all_blocks) {}
|
||||
|
||||
void operator()(code_block* block, cell size) {
|
||||
FACTOR_ASSERT(all_blocks->find((cell) block) != all_blocks->end());
|
||||
FACTOR_ASSERT(all_blocks->find((cell)block) != all_blocks->end());
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -103,7 +103,7 @@ code_block* code_heap::code_block_for_address(cell address) {
|
|||
FACTOR_ASSERT(blocki != all_blocks.begin());
|
||||
--blocki;
|
||||
code_block* found_block = (code_block*)*blocki;
|
||||
FACTOR_ASSERT((cell) found_block->entry_point() <=
|
||||
FACTOR_ASSERT((cell)found_block->entry_point() <=
|
||||
address /* XXX this isn't valid during fixup. should store the
|
||||
size in the map
|
||||
&& address - (cell)found_block->entry_point() <
|
||||
|
|
@ -117,7 +117,7 @@ struct all_blocks_set_inserter {
|
|||
all_blocks_set_inserter(code_heap* code) : code(code) {}
|
||||
|
||||
void operator()(code_block* block, cell size) {
|
||||
code->all_blocks.insert((cell) block);
|
||||
code->all_blocks.insert((cell)block);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -263,7 +263,7 @@ struct code_block_accumulator {
|
|||
from_unsigned_cell() here. It is OK, however, to add it as
|
||||
if it were a fixnum, and have library code shift it to the
|
||||
left by 4. */
|
||||
cell entry_point = (cell) compiled->entry_point();
|
||||
cell entry_point = (cell)compiled->entry_point();
|
||||
FACTOR_ASSERT((entry_point & (data_alignment - 1)) == 0);
|
||||
FACTOR_ASSERT((entry_point & TAG_MASK) == FIXNUM_TYPE);
|
||||
objects.push_back(entry_point);
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ struct code_heap {
|
|||
|
||||
bool safepoint_p(cell addr) {
|
||||
cell page_mask = ~(getpagesize() - 1);
|
||||
return (addr & page_mask) == (cell) safepoint_page;
|
||||
return (addr & page_mask) == (cell)safepoint_page;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ struct gc_workhorse : no_fixup {
|
|||
code_block* fixup_code(code_block* compiled) {
|
||||
if (!code->marked_p(compiled)) {
|
||||
code->set_marked_p(compiled);
|
||||
parent->mark_stack.push_back((cell) compiled + 1);
|
||||
parent->mark_stack.push_back((cell)compiled + 1);
|
||||
}
|
||||
|
||||
return compiled;
|
||||
|
|
|
|||
|
|
@ -88,7 +88,7 @@ template <typename Fixup> struct code_block_compaction_relocation_visitor {
|
|||
: parent(parent), old_address(old_address), fixup(fixup) {}
|
||||
|
||||
void operator()(instruction_operand op) {
|
||||
cell old_offset = op.rel_offset() + (cell) old_address->entry_point();
|
||||
cell old_offset = op.rel_offset() + (cell)old_address->entry_point();
|
||||
|
||||
switch (op.rel_type()) {
|
||||
case RT_LITERAL: {
|
||||
|
|
@ -107,7 +107,7 @@ template <typename Fixup> struct code_block_compaction_relocation_visitor {
|
|||
cell value = op.load_value(old_offset);
|
||||
cell offset = TAG(value);
|
||||
code_block* compiled = (code_block*)UNTAG(value);
|
||||
op.store_value((cell) fixup.fixup_code(compiled) + offset);
|
||||
op.store_value((cell)fixup.fixup_code(compiled) + offset);
|
||||
break;
|
||||
}
|
||||
case RT_THIS:
|
||||
|
|
@ -159,11 +159,11 @@ void factor_vm::update_code_roots_for_compaction() {
|
|||
code_block* block = (code_block*)(root->value & (~data_alignment + 1));
|
||||
|
||||
/* Offset of return address within 16-byte allocation line */
|
||||
cell offset = root->value - (cell) block;
|
||||
cell offset = root->value - (cell)block;
|
||||
|
||||
if (root->valid && state->marked_p(block)) {
|
||||
block = state->forward_block(block);
|
||||
root->value = (cell) block + offset;
|
||||
root->value = (cell)block + offset;
|
||||
} else
|
||||
root->valid = false;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ inline static void set_call_target(cell return_address, void* target) {
|
|||
|
||||
uint32_t insn = *(uint32_t*)return_address;
|
||||
|
||||
fixnum relative_address = ((cell) target - return_address);
|
||||
fixnum relative_address = ((cell)target - return_address);
|
||||
insn = ((insn & ~b_mask) | (relative_address & b_mask));
|
||||
*(uint32_t*)return_address = insn;
|
||||
|
||||
|
|
|
|||
|
|
@ -14,11 +14,11 @@ void factor_vm::dispatch_signal_handler(cell* sp, cell* pc, cell handler) {
|
|||
void* frame_top = (void*)ctx->callstack_top;
|
||||
|
||||
while (frame_top < ctx->callstack_bottom &&
|
||||
(cell) frame_top < ctx->callstack_seg->start + stack_reserved) {
|
||||
(cell)frame_top < ctx->callstack_seg->start + stack_reserved) {
|
||||
frame_top = frame_predecessor(frame_top);
|
||||
}
|
||||
|
||||
*sp = (cell) frame_top;
|
||||
*sp = (cell)frame_top;
|
||||
ctx->callstack_top = frame_top;
|
||||
*pc = handler;
|
||||
} else {
|
||||
|
|
@ -53,7 +53,7 @@ void factor_vm::dispatch_signal_handler(cell* sp, cell* pc, cell handler) {
|
|||
} else
|
||||
FACTOR_ASSERT(false);
|
||||
|
||||
*pc = (cell) handler_word->entry_point;
|
||||
*pc = (cell)handler_word->entry_point;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ inline static unsigned char call_site_opcode(cell return_address) {
|
|||
inline static void check_call_site(cell return_address) {
|
||||
unsigned char opcode = call_site_opcode(return_address);
|
||||
FACTOR_ASSERT(opcode == call_opcode || opcode == jmp_opcode);
|
||||
(void) opcode; // suppress warning when compiling without assertions
|
||||
(void)opcode; // suppress warning when compiling without assertions
|
||||
}
|
||||
|
||||
inline static void* get_call_target(cell return_address) {
|
||||
|
|
@ -44,7 +44,7 @@ inline static void* get_call_target(cell return_address) {
|
|||
|
||||
inline static void set_call_target(cell return_address, void* target) {
|
||||
check_call_site(return_address);
|
||||
*(int*)(return_address - 4) = (uint32_t)((cell) target - return_address);
|
||||
*(int*)(return_address - 4) = (uint32_t)((cell)target - return_address);
|
||||
}
|
||||
|
||||
inline static bool tail_call_site_p(cell return_address) {
|
||||
|
|
|
|||
|
|
@ -3,8 +3,8 @@
|
|||
namespace factor {
|
||||
|
||||
void factor_vm::init_card_decks() {
|
||||
cards_offset = (cell) data->cards - addr_to_card(data->start);
|
||||
decks_offset = (cell) data->decks - addr_to_deck(data->start);
|
||||
cards_offset = (cell)data->cards - addr_to_card(data->start);
|
||||
decks_offset = (cell)data->decks - addr_to_deck(data->start);
|
||||
}
|
||||
|
||||
data_heap::data_heap(cell young_size_, cell aging_size_, cell tenured_size_) {
|
||||
|
|
|
|||
|
|
@ -19,8 +19,8 @@ inline generation generation_of(factor_vm* parent, object* obj) {
|
|||
else if (parent->data->tenured->contains_p(obj))
|
||||
return tenured_generation;
|
||||
else {
|
||||
critical_error("Bad object", (cell) obj);
|
||||
return (generation) - 1;
|
||||
critical_error("Bad object", (cell)obj);
|
||||
return (generation)-1;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -33,9 +33,9 @@ struct slot_checker {
|
|||
: parent(parent), obj(obj), gen(gen) {}
|
||||
|
||||
void check_write_barrier(cell* slot_ptr, generation target, char mask) {
|
||||
cell object_card_pointer = parent->cards_offset + ((cell) obj >> card_bits);
|
||||
cell object_card_pointer = parent->cards_offset + ((cell)obj >> card_bits);
|
||||
cell slot_card_pointer =
|
||||
parent->cards_offset + ((cell) slot_ptr >> card_bits);
|
||||
parent->cards_offset + ((cell)slot_ptr >> card_bits);
|
||||
char slot_card_value = *(char*)slot_card_pointer;
|
||||
if ((slot_card_value & mask) != mask) {
|
||||
std::cout << "card not marked" << std::endl;
|
||||
|
|
|
|||
|
|
@ -37,11 +37,11 @@ struct gc_bignum {
|
|||
gc_bignum(bignum** addr, factor_vm* parent) : addr(addr), parent(parent) {
|
||||
if (*addr)
|
||||
parent->check_data_pointer(*addr);
|
||||
parent->bignum_roots.push_back((cell) addr);
|
||||
parent->bignum_roots.push_back((cell)addr);
|
||||
}
|
||||
|
||||
~gc_bignum() {
|
||||
FACTOR_ASSERT(parent->bignum_roots.back() == (cell) addr);
|
||||
FACTOR_ASSERT(parent->bignum_roots.back() == (cell)addr);
|
||||
parent->bignum_roots.pop_back();
|
||||
}
|
||||
};
|
||||
|
|
|
|||
18
vm/debug.cpp
18
vm/debug.cpp
|
|
@ -4,7 +4,7 @@ namespace factor {
|
|||
|
||||
std::ostream& operator<<(std::ostream& out, const string* str) {
|
||||
for (cell i = 0; i < string_capacity(str); i++)
|
||||
out << (char) str->data()[i];
|
||||
out << (char)str->data()[i];
|
||||
return out;
|
||||
}
|
||||
|
||||
|
|
@ -201,13 +201,13 @@ struct stack_frame_printer {
|
|||
parent->print_obj(owner->scan(parent, addr));
|
||||
std::cout << std::endl;
|
||||
std::cout << "word/quot addr: ";
|
||||
std::cout << std::hex << (cell) owner->owner << std::dec;
|
||||
std::cout << std::hex << (cell)owner->owner << std::dec;
|
||||
std::cout << std::endl;
|
||||
std::cout << "word/quot xt: ";
|
||||
std::cout << std::hex << (cell) owner->entry_point() << std::dec;
|
||||
std::cout << std::hex << (cell)owner->entry_point() << std::dec;
|
||||
std::cout << std::endl;
|
||||
std::cout << "return address: ";
|
||||
std::cout << std::hex << (cell) addr << std::dec;
|
||||
std::cout << std::hex << (cell)addr << std::dec;
|
||||
std::cout << std::endl;
|
||||
}
|
||||
};
|
||||
|
|
@ -270,7 +270,7 @@ void factor_vm::dump_generations() {
|
|||
dump_generation("Tenured", data->tenured);
|
||||
|
||||
std::cout << "Cards:";
|
||||
std::cout << "base=" << (cell) data->cards << ", ";
|
||||
std::cout << "base=" << (cell)data->cards << ", ";
|
||||
std::cout << "size=" << (cell)(data->cards_end - data->cards) << std::endl;
|
||||
|
||||
std::cout << std::dec;
|
||||
|
|
@ -285,7 +285,7 @@ struct object_dumper {
|
|||
|
||||
void operator()(object* obj) {
|
||||
if (type == TYPE_COUNT || obj->type() == type) {
|
||||
std::cout << padded_address((cell) obj) << " ";
|
||||
std::cout << padded_address((cell)obj) << " ";
|
||||
parent->print_nested_obj(tag_dynamic(obj), 2);
|
||||
std::cout << std::endl;
|
||||
}
|
||||
|
|
@ -309,7 +309,7 @@ struct find_data_reference_slot_visitor {
|
|||
|
||||
void operator()(cell* scan) {
|
||||
if (look_for == *scan) {
|
||||
std::cout << padded_address((cell) obj) << " ";
|
||||
std::cout << padded_address((cell)obj) << " ";
|
||||
parent->print_nested_obj(tag_dynamic(obj), 2);
|
||||
std::cout << std::endl;
|
||||
}
|
||||
|
|
@ -374,7 +374,7 @@ struct code_block_printer {
|
|||
else
|
||||
status = "allocated";
|
||||
|
||||
std::cout << std::hex << (cell) scan << std::dec << " ";
|
||||
std::cout << std::hex << (cell)scan << std::dec << " ";
|
||||
std::cout << std::hex << size << std::dec << " ";
|
||||
std::cout << status << " ";
|
||||
std::cout << "stack frame " << scan->stack_frame_size();
|
||||
|
|
@ -531,7 +531,7 @@ void factor_vm::factorbug() {
|
|||
print_callstack();
|
||||
else if (strcmp(cmd, "e") == 0) {
|
||||
for (cell i = 0; i < special_object_count; i++)
|
||||
dump_cell((cell) & special_objects[i]);
|
||||
dump_cell((cell)&special_objects[i]);
|
||||
} else if (strcmp(cmd, "g") == 0)
|
||||
dump_generations();
|
||||
else if (strcmp(cmd, "c") == 0) {
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ cell factor_vm::lookup_tuple_method(cell obj, cell methods) {
|
|||
array* echelons = untag<array>(methods);
|
||||
|
||||
fixnum echelon = std::min(untag_fixnum(layout->echelon),
|
||||
(fixnum) array_capacity(echelons) - 1);
|
||||
(fixnum)array_capacity(echelons) - 1);
|
||||
|
||||
while (echelon >= 0) {
|
||||
cell echelon_methods = array_nth(echelons, echelon);
|
||||
|
|
|
|||
|
|
@ -135,23 +135,23 @@ void factor_vm::init_factor(vm_parameters* p) {
|
|||
p->image_path = default_image_path();
|
||||
}
|
||||
|
||||
srand((unsigned int) nano_count());
|
||||
srand((unsigned int)nano_count());
|
||||
init_ffi();
|
||||
init_contexts(p->datastack_size, p->retainstack_size, p->callstack_size);
|
||||
init_callbacks(p->callback_size);
|
||||
load_image(p);
|
||||
init_c_io();
|
||||
init_inline_caching((int) p->max_pic_size);
|
||||
init_inline_caching((int)p->max_pic_size);
|
||||
special_objects[OBJ_CPU] =
|
||||
allot_alien(false_object, (cell) FACTOR_CPU_STRING);
|
||||
special_objects[OBJ_OS] = allot_alien(false_object, (cell) FACTOR_OS_STRING);
|
||||
allot_alien(false_object, (cell)FACTOR_CPU_STRING);
|
||||
special_objects[OBJ_OS] = allot_alien(false_object, (cell)FACTOR_OS_STRING);
|
||||
special_objects[OBJ_CELL_SIZE] = tag_fixnum(sizeof(cell));
|
||||
special_objects[OBJ_EXECUTABLE] =
|
||||
allot_alien(false_object, (cell) p->executable_path);
|
||||
allot_alien(false_object, (cell)p->executable_path);
|
||||
special_objects[OBJ_ARGS] = false_object;
|
||||
special_objects[OBJ_EMBEDDED] = false_object;
|
||||
special_objects[OBJ_VM_COMPILER] =
|
||||
allot_alien(false_object, (cell) FACTOR_COMPILER_VERSION);
|
||||
allot_alien(false_object, (cell)FACTOR_COMPILER_VERSION);
|
||||
|
||||
/* We can GC now */
|
||||
gc_off = false;
|
||||
|
|
@ -172,7 +172,7 @@ void factor_vm::pass_args_to_factor(int argc, vm_char** argv) {
|
|||
growable_array args(this);
|
||||
|
||||
for (fixnum i = 1; i < argc; i++)
|
||||
args.add(allot_alien(false_object, (cell) argv[i]));
|
||||
args.add(allot_alien(false_object, (cell)argv[i]));
|
||||
|
||||
args.trim();
|
||||
special_objects[OBJ_ARGS] = args.elements.value();
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ void free_list::initial_free_list(cell start, cell end, cell occupied) {
|
|||
clear_free_list();
|
||||
if (occupied != end - start) {
|
||||
free_heap_block* last_block = (free_heap_block*)(start + occupied);
|
||||
last_block->make_free(end - (cell) last_block);
|
||||
last_block->make_free(end - (cell)last_block);
|
||||
add_to_free_list(last_block);
|
||||
}
|
||||
}
|
||||
|
|
@ -49,7 +49,7 @@ free_heap_block* free_list::find_free_block(cell size) {
|
|||
/* Split it up into pieces and add each piece back to the free list */
|
||||
for (cell offset = 0; offset < large_block_size; offset += size) {
|
||||
free_heap_block* small_block = large_block;
|
||||
large_block = (free_heap_block*)((cell) large_block + size);
|
||||
large_block = (free_heap_block*)((cell)large_block + size);
|
||||
small_block->make_free(size);
|
||||
add_to_free_list(small_block);
|
||||
}
|
||||
|
|
@ -87,7 +87,7 @@ free_heap_block* free_list::split_free_block(free_heap_block* block,
|
|||
cell size) {
|
||||
if (block->size() != size) {
|
||||
/* split the block in two */
|
||||
free_heap_block* split = (free_heap_block*)((cell) block + size);
|
||||
free_heap_block* split = (free_heap_block*)((cell)block + size);
|
||||
split->make_free(block->size() - size);
|
||||
block->make_free(size);
|
||||
add_to_free_list(split);
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ void free_list_allocator<Block>::initial_free_list(cell occupied) {
|
|||
|
||||
template <typename Block>
|
||||
bool free_list_allocator<Block>::contains_p(Block* block) {
|
||||
return ((cell) block - start) < size;
|
||||
return ((cell)block - start) < size;
|
||||
}
|
||||
|
||||
template <typename Block> Block* free_list_allocator<Block>::first_block() {
|
||||
|
|
@ -59,14 +59,14 @@ template <typename Block> Block* free_list_allocator<Block>::last_block() {
|
|||
|
||||
template <typename Block>
|
||||
Block* free_list_allocator<Block>::next_block_after(Block* block) {
|
||||
return (Block*)((cell) block + block->size());
|
||||
return (Block*)((cell)block + block->size());
|
||||
}
|
||||
|
||||
template <typename Block>
|
||||
Block* free_list_allocator<Block>::next_allocated_block_after(Block* block) {
|
||||
while (block != this->last_block() && block->free_p()) {
|
||||
free_heap_block* free_block = (free_heap_block*)block;
|
||||
block = (object*)((cell) free_block + free_block->size());
|
||||
block = (object*)((cell)free_block + free_block->size());
|
||||
}
|
||||
|
||||
if (block == this->last_block())
|
||||
|
|
@ -182,7 +182,7 @@ void free_list_allocator<Block>::compact(Iterator& iter, Fixup fixup,
|
|||
|
||||
/* Now update the free list; there will be a single free block at
|
||||
the end */
|
||||
free_blocks.initial_free_list(start, end, (cell) compactor.address - start);
|
||||
free_blocks.initial_free_list(start, end, (cell)compactor.address - start);
|
||||
}
|
||||
|
||||
/* During compaction we have to be careful and measure object sizes
|
||||
|
|
@ -195,7 +195,7 @@ void free_list_allocator<Block>::iterate(Iterator& iter, Fixup fixup) {
|
|||
|
||||
while (scan != end) {
|
||||
cell size = fixup.size(scan);
|
||||
Block* next = (Block*)((cell) scan + size);
|
||||
Block* next = (Block*)((cell)scan + size);
|
||||
if (!scan->free_p())
|
||||
iter(scan, size);
|
||||
scan = next;
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ struct full_policy {
|
|||
|
||||
void promoted_object(object* obj) {
|
||||
tenured->set_marked_p(obj);
|
||||
parent->mark_stack.push_back((cell) obj);
|
||||
parent->mark_stack.push_back((cell)obj);
|
||||
}
|
||||
|
||||
void visited_object(object* obj) {
|
||||
|
|
|
|||
|
|
@ -205,7 +205,7 @@ struct call_frame_scrubber {
|
|||
|
||||
FACTOR_ASSERT(return_address < owner->size());
|
||||
cell index = info->return_address_index(return_address);
|
||||
if (index != (cell) - 1)
|
||||
if (index != (cell)-1)
|
||||
ctx->scrub_stacks(info, index);
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ cell gc_info::return_address_index(cell return_address) {
|
|||
return i;
|
||||
}
|
||||
|
||||
return (cell) - 1;
|
||||
return (cell)-1;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
18
vm/image.cpp
18
vm/image.cpp
|
|
@ -20,7 +20,7 @@ void factor_vm::load_data_heap(FILE* file, image_header* h, vm_parameters* p) {
|
|||
fixnum bytes_read =
|
||||
safe_fread((void*)data->tenured->start, 1, h->data_size, file);
|
||||
|
||||
if ((cell) bytes_read != h->data_size) {
|
||||
if ((cell)bytes_read != h->data_size) {
|
||||
std::cout << "truncated image: " << bytes_read << " bytes read, ";
|
||||
std::cout << h->data_size << " bytes expected\n";
|
||||
fatal_error("load_data_heap failed", 0);
|
||||
|
|
@ -59,11 +59,11 @@ struct startup_fixup {
|
|||
: data_offset(data_offset), code_offset(code_offset) {}
|
||||
|
||||
object* fixup_data(object* obj) {
|
||||
return (object*)((cell) obj + data_offset);
|
||||
return (object*)((cell)obj + data_offset);
|
||||
}
|
||||
|
||||
code_block* fixup_code(code_block* obj) {
|
||||
return (code_block*)((cell) obj + code_offset);
|
||||
return (code_block*)((cell)obj + code_offset);
|
||||
}
|
||||
|
||||
object* translate_data(const object* obj) { return fixup_data((object*)obj); }
|
||||
|
|
@ -140,7 +140,7 @@ struct startup_code_block_relocation_visitor {
|
|||
void operator()(instruction_operand op) {
|
||||
code_block* compiled = op.compiled;
|
||||
cell old_offset =
|
||||
op.rel_offset() + (cell) compiled->entry_point() - fixup.code_offset;
|
||||
op.rel_offset() + (cell)compiled->entry_point() - fixup.code_offset;
|
||||
|
||||
switch (op.rel_type()) {
|
||||
case RT_LITERAL: {
|
||||
|
|
@ -159,7 +159,7 @@ struct startup_code_block_relocation_visitor {
|
|||
cell value = op.load_value(old_offset);
|
||||
cell offset = TAG(value);
|
||||
code_block* compiled = (code_block*)UNTAG(value);
|
||||
op.store_value((cell) fixup.fixup_code(compiled) + offset);
|
||||
op.store_value((cell)fixup.fixup_code(compiled) + offset);
|
||||
break;
|
||||
}
|
||||
case RT_UNTAGGED:
|
||||
|
|
@ -195,8 +195,8 @@ void factor_vm::fixup_code(cell data_offset, cell code_offset) {
|
|||
|
||||
bool factor_vm::read_embedded_image_footer(FILE* file,
|
||||
embedded_image_footer* footer) {
|
||||
safe_fseek(file, -(off_t) sizeof(embedded_image_footer), SEEK_END);
|
||||
safe_fread(footer, (off_t) sizeof(embedded_image_footer), 1, file);
|
||||
safe_fseek(file, -(off_t)sizeof(embedded_image_footer), SEEK_END);
|
||||
safe_fread(footer, (off_t)sizeof(embedded_image_footer), 1, file);
|
||||
return footer->magic == image_magic;
|
||||
}
|
||||
|
||||
|
|
@ -213,7 +213,7 @@ FILE* factor_vm::open_image(vm_parameters* p) {
|
|||
std::cout << "No embedded image" << std::endl;
|
||||
exit(1);
|
||||
}
|
||||
safe_fseek(file, (off_t) footer.image_offset, SEEK_SET);
|
||||
safe_fseek(file, (off_t)footer.image_offset, SEEK_SET);
|
||||
return file;
|
||||
} else
|
||||
return OPEN_READ(p->image_path);
|
||||
|
|
@ -253,7 +253,7 @@ void factor_vm::load_image(vm_parameters* p) {
|
|||
fixup_code(data_offset, code_offset);
|
||||
|
||||
/* Store image path name */
|
||||
special_objects[OBJ_IMAGE] = allot_alien(false_object, (cell) p->image_path);
|
||||
special_objects[OBJ_IMAGE] = allot_alien(false_object, (cell)p->image_path);
|
||||
}
|
||||
|
||||
/* Save the current image to disk */
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ void factor_vm::init_inline_caching(int max_size) { max_pic_size = max_size; }
|
|||
void factor_vm::deallocate_inline_cache(cell return_address) {
|
||||
/* Find the call target. */
|
||||
void* old_entry_point = get_call_target(return_address);
|
||||
check_code_pointer((cell) old_entry_point);
|
||||
check_code_pointer((cell)old_entry_point);
|
||||
|
||||
code_block* old_block = (code_block*)old_entry_point - 1;
|
||||
|
||||
|
|
@ -216,7 +216,7 @@ void* factor_vm::inline_cache_miss(cell return_address_) {
|
|||
#ifdef PIC_DEBUG
|
||||
std::cout << "Updated " << (tail_call_site ? "tail" : "non-tail")
|
||||
<< " call site 0x" << std::hex << return_address.value << std::dec
|
||||
<< " with 0x" << std::hex << (cell) xt << std::dec << std::endl;
|
||||
<< " with 0x" << std::hex << (cell)xt << std::dec << std::endl;
|
||||
print_callstack();
|
||||
#endif
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ instruction_operand::instruction_operand(relocation_entry rel,
|
|||
: rel(rel),
|
||||
compiled(compiled),
|
||||
index(index),
|
||||
pointer((cell) compiled->entry_point() + rel.rel_offset()) {}
|
||||
pointer((cell)compiled->entry_point() + rel.rel_offset()) {}
|
||||
|
||||
/* Load a 32-bit value from a PowerPC LIS/ORI sequence */
|
||||
fixnum instruction_operand::load_value_2_2() {
|
||||
|
|
@ -25,7 +25,7 @@ fixnum instruction_operand::load_value_2_2_2_2() {
|
|||
uint64_t lhi = (ptr[-2] & 0xffff);
|
||||
uint64_t llo = (ptr[-1] & 0xffff);
|
||||
uint64_t val = hhi << 48 | hlo << 32 | lhi << 16 | llo;
|
||||
return (cell) val;
|
||||
return (cell)val;
|
||||
}
|
||||
|
||||
/* Load a value from a bitfield of a PowerPC instruction */
|
||||
|
|
@ -33,7 +33,7 @@ fixnum instruction_operand::load_value_masked(cell mask, cell bits,
|
|||
cell shift) {
|
||||
int32_t* ptr = (int32_t*)(pointer - sizeof(uint32_t));
|
||||
|
||||
return (((*ptr & (int32_t) mask) << bits) >> bits) << shift;
|
||||
return (((*ptr & (int32_t)mask) << bits) >> bits) << shift;
|
||||
}
|
||||
|
||||
fixnum instruction_operand::load_value(cell relative_to) {
|
||||
|
|
@ -115,10 +115,10 @@ void instruction_operand::store_value(fixnum absolute_value) {
|
|||
*(cell*)(pointer - sizeof(cell)) = absolute_value;
|
||||
break;
|
||||
case RC_ABSOLUTE:
|
||||
*(uint32_t*)(pointer - sizeof(uint32_t)) = (uint32_t) absolute_value;
|
||||
*(uint32_t*)(pointer - sizeof(uint32_t)) = (uint32_t)absolute_value;
|
||||
break;
|
||||
case RC_RELATIVE:
|
||||
*(int32_t*)(pointer - sizeof(int32_t)) = (int32_t) relative_value;
|
||||
*(int32_t*)(pointer - sizeof(int32_t)) = (int32_t)relative_value;
|
||||
break;
|
||||
case RC_ABSOLUTE_PPC_2_2:
|
||||
store_value_2_2(absolute_value);
|
||||
|
|
@ -144,10 +144,10 @@ void instruction_operand::store_value(fixnum absolute_value) {
|
|||
0);
|
||||
break;
|
||||
case RC_ABSOLUTE_2:
|
||||
*(uint16_t*)(pointer - sizeof(uint16_t)) = (uint16_t) absolute_value;
|
||||
*(uint16_t*)(pointer - sizeof(uint16_t)) = (uint16_t)absolute_value;
|
||||
break;
|
||||
case RC_ABSOLUTE_1:
|
||||
*(uint8_t*)(pointer - sizeof(uint8_t)) = (uint8_t) absolute_value;
|
||||
*(uint8_t*)(pointer - sizeof(uint8_t)) = (uint8_t)absolute_value;
|
||||
break;
|
||||
case RC_ABSOLUTE_PPC_2_2_2_2:
|
||||
store_value_2_2_2_2(absolute_value);
|
||||
|
|
@ -159,7 +159,7 @@ void instruction_operand::store_value(fixnum absolute_value) {
|
|||
}
|
||||
|
||||
void instruction_operand::store_code_block(code_block* compiled) {
|
||||
store_value((cell) compiled->entry_point());
|
||||
store_value((cell)compiled->entry_point());
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
12
vm/io.cpp
12
vm/io.cpp
|
|
@ -14,9 +14,9 @@ with many more capabilities so these words are not usually used in
|
|||
normal operation. */
|
||||
|
||||
void factor_vm::init_c_io() {
|
||||
special_objects[OBJ_STDIN] = allot_alien(false_object, (cell) stdin);
|
||||
special_objects[OBJ_STDOUT] = allot_alien(false_object, (cell) stdout);
|
||||
special_objects[OBJ_STDERR] = allot_alien(false_object, (cell) stderr);
|
||||
special_objects[OBJ_STDIN] = allot_alien(false_object, (cell)stdin);
|
||||
special_objects[OBJ_STDOUT] = allot_alien(false_object, (cell)stdout);
|
||||
special_objects[OBJ_STDERR] = allot_alien(false_object, (cell)stderr);
|
||||
}
|
||||
|
||||
void factor_vm::io_error() {
|
||||
|
|
@ -196,7 +196,7 @@ void factor_vm::primitive_fread() {
|
|||
void factor_vm::primitive_fputc() {
|
||||
FILE* file = pop_file_handle();
|
||||
fixnum ch = to_fixnum(ctx->pop());
|
||||
safe_fputc((int) ch, file);
|
||||
safe_fputc((int)ch, file);
|
||||
}
|
||||
|
||||
void factor_vm::primitive_fwrite() {
|
||||
|
|
@ -219,8 +219,8 @@ void factor_vm::primitive_ftell() {
|
|||
|
||||
void factor_vm::primitive_fseek() {
|
||||
FILE* file = pop_file_handle();
|
||||
int whence = (int) to_fixnum(ctx->pop());
|
||||
off_t offset = (off_t) to_signed_8(ctx->pop());
|
||||
int whence = (int)to_fixnum(ctx->pop());
|
||||
off_t offset = (off_t)to_signed_8(ctx->pop());
|
||||
safe_fseek(file, offset, whence);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -21,13 +21,13 @@ jit::jit(code_block_type type, cell owner, factor_vm* vm)
|
|||
parent(vm) {
|
||||
fixnum old_count = atomic::fetch_add(&parent->current_jit_count, 1);
|
||||
FACTOR_ASSERT(old_count >= 0);
|
||||
(void) old_count;
|
||||
(void)old_count;
|
||||
}
|
||||
|
||||
jit::~jit() {
|
||||
fixnum old_count = atomic::fetch_subtract(&parent->current_jit_count, 1);
|
||||
FACTOR_ASSERT(old_count >= 1);
|
||||
(void) old_count;
|
||||
(void)old_count;
|
||||
}
|
||||
|
||||
void jit::emit_relocation(cell relocation_template_) {
|
||||
|
|
|
|||
|
|
@ -96,7 +96,7 @@ inline static bool immediate_p(cell obj) {
|
|||
|
||||
inline static fixnum untag_fixnum(cell tagged) {
|
||||
FACTOR_ASSERT(TAG(tagged) == FIXNUM_TYPE);
|
||||
return ((fixnum) tagged) >> TAG_BITS;
|
||||
return ((fixnum)tagged) >> TAG_BITS;
|
||||
}
|
||||
|
||||
inline static cell tag_fixnum(fixnum untagged) {
|
||||
|
|
@ -137,7 +137,7 @@ struct object {
|
|||
|
||||
object* forwarding_pointer() const { return (object*)UNTAG(header); }
|
||||
|
||||
void forward_to(object* pointer) { header = ((cell) pointer | 2); }
|
||||
void forward_to(object* pointer) { header = ((cell)pointer | 2); }
|
||||
};
|
||||
|
||||
/* Assembly code makes assumptions about the layout of this struct */
|
||||
|
|
|
|||
|
|
@ -37,13 +37,13 @@ void factor_vm::call_fault_handler(exception_type_t exception,
|
|||
|
||||
if (exception == EXC_BAD_ACCESS) {
|
||||
signal_fault_addr = MACH_EXC_STATE_FAULT(exc_state);
|
||||
signal_fault_pc = (cell) MACH_PROGRAM_COUNTER(thread_state);
|
||||
signal_fault_pc = (cell)MACH_PROGRAM_COUNTER(thread_state);
|
||||
verify_memory_protection_error(signal_fault_addr);
|
||||
handler = (cell) factor::memory_signal_handler_impl;
|
||||
handler = (cell)factor::memory_signal_handler_impl;
|
||||
} else if (exception == EXC_ARITHMETIC && code != MACH_EXC_INTEGER_DIV) {
|
||||
signal_fpu_status = fpu_status(mach_fpu_status(float_state));
|
||||
mach_clear_fpu_status(float_state);
|
||||
handler = (cell) factor::fp_signal_handler_impl;
|
||||
handler = (cell)factor::fp_signal_handler_impl;
|
||||
} else {
|
||||
switch (exception) {
|
||||
case EXC_ARITHMETIC:
|
||||
|
|
@ -57,14 +57,14 @@ void factor_vm::call_fault_handler(exception_type_t exception,
|
|||
break;
|
||||
}
|
||||
|
||||
handler = (cell) factor::synchronous_signal_handler_impl;
|
||||
handler = (cell)factor::synchronous_signal_handler_impl;
|
||||
}
|
||||
|
||||
FACTOR_ASSERT(handler != 0);
|
||||
|
||||
dispatch_signal_handler((cell*)&MACH_STACK_POINTER(thread_state),
|
||||
(cell*)&MACH_PROGRAM_COUNTER(thread_state),
|
||||
(cell) handler);
|
||||
(cell)handler);
|
||||
}
|
||||
|
||||
static void call_fault_handler(mach_port_t thread, exception_type_t exception,
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ template <typename Block> struct mark_bits {
|
|||
}
|
||||
|
||||
cell block_line(const Block* address) {
|
||||
return (((cell) address - start) / data_alignment);
|
||||
return (((cell)address - start) / data_alignment);
|
||||
}
|
||||
|
||||
Block* line_block(cell line) {
|
||||
|
|
@ -48,19 +48,19 @@ template <typename Block> struct mark_bits {
|
|||
|
||||
bool bitmap_elt(cell* bits, const Block* address) {
|
||||
std::pair<cell, cell> position = bitmap_deref(address);
|
||||
return (bits[position.first] & ((cell) 1 << position.second)) != 0;
|
||||
return (bits[position.first] & ((cell)1 << position.second)) != 0;
|
||||
}
|
||||
|
||||
Block* next_block_after(const Block* block) {
|
||||
return (Block*)((cell) block + block->size());
|
||||
return (Block*)((cell)block + block->size());
|
||||
}
|
||||
|
||||
void set_bitmap_range(cell* bits, const Block* address) {
|
||||
std::pair<cell, cell> start = bitmap_deref(address);
|
||||
std::pair<cell, cell> end = bitmap_deref(next_block_after(address));
|
||||
|
||||
cell start_mask = ((cell) 1 << start.second) - 1;
|
||||
cell end_mask = ((cell) 1 << end.second) - 1;
|
||||
cell start_mask = ((cell)1 << start.second) - 1;
|
||||
cell end_mask = ((cell)1 << end.second) - 1;
|
||||
|
||||
if (start.first == end.first)
|
||||
bits[start.first] |= start_mask ^ end_mask;
|
||||
|
|
@ -69,7 +69,7 @@ template <typename Block> struct mark_bits {
|
|||
bits[start.first] |= ~start_mask;
|
||||
|
||||
for (cell index = start.first + 1; index < end.first; index++)
|
||||
bits[index] = (cell) - 1;
|
||||
bits[index] = (cell)-1;
|
||||
|
||||
if (end_mask != 0) {
|
||||
FACTOR_ASSERT(end.first < bits_size);
|
||||
|
|
@ -97,10 +97,10 @@ template <typename Block> struct mark_bits {
|
|||
Block* forward_block(const Block* original) {
|
||||
FACTOR_ASSERT(marked_p(original));
|
||||
std::pair<cell, cell> position = bitmap_deref(original);
|
||||
cell offset = (cell) original & (data_alignment - 1);
|
||||
cell offset = (cell)original & (data_alignment - 1);
|
||||
|
||||
cell approx_popcount = forwarding[position.first];
|
||||
cell mask = ((cell) 1 << position.second) - 1;
|
||||
cell mask = ((cell)1 << position.second) - 1;
|
||||
|
||||
cell new_line_number =
|
||||
approx_popcount + popcount(marked[position.first] & mask);
|
||||
|
|
@ -114,7 +114,7 @@ template <typename Block> struct mark_bits {
|
|||
cell bit_index = position.second;
|
||||
|
||||
for (cell index = position.first; index < bits_size; index++) {
|
||||
cell mask = ((fixnum) marked[index] >> bit_index);
|
||||
cell mask = ((fixnum)marked[index] >> bit_index);
|
||||
if (~mask) {
|
||||
/* Found an unmarked block on this page. Stop, it's hammer time */
|
||||
cell clear_bit = rightmost_clear_bit(mask);
|
||||
|
|
|
|||
18
vm/math.cpp
18
vm/math.cpp
|
|
@ -65,7 +65,7 @@ void factor_vm::primitive_fixnum_shift() {
|
|||
ctx->replace(tag_fixnum(x >> -y));
|
||||
return;
|
||||
} else if (y < WORD_SIZE - TAG_BITS) {
|
||||
fixnum mask = -((fixnum) 1 << (WORD_SIZE - 1 - TAG_BITS - y));
|
||||
fixnum mask = -((fixnum)1 << (WORD_SIZE - 1 - TAG_BITS - y));
|
||||
if (!(branchless_abs(x) & mask)) {
|
||||
ctx->replace(tag_fixnum(x << y));
|
||||
return;
|
||||
|
|
@ -179,7 +179,7 @@ void factor_vm::primitive_bignum_not() {
|
|||
}
|
||||
|
||||
void factor_vm::primitive_bignum_bitp() {
|
||||
int bit = (int) to_fixnum(ctx->pop());
|
||||
int bit = (int)to_fixnum(ctx->pop());
|
||||
bignum* x = untag<bignum>(ctx->peek());
|
||||
ctx->replace(tag_boolean(bignum_logbitp(bit, x)));
|
||||
}
|
||||
|
|
@ -276,12 +276,12 @@ void factor_vm::primitive_float_greatereq() {
|
|||
/* Allocates memory */
|
||||
void factor_vm::primitive_float_bits() {
|
||||
ctx->push(
|
||||
from_unsigned_cell(float_bits((float) untag_float_check(ctx->pop()))));
|
||||
from_unsigned_cell(float_bits((float)untag_float_check(ctx->pop()))));
|
||||
}
|
||||
|
||||
/* Allocates memory */
|
||||
void factor_vm::primitive_bits_float() {
|
||||
ctx->push(allot_float(bits_float((uint32_t) to_cell(ctx->pop()))));
|
||||
ctx->push(allot_float(bits_float((uint32_t)to_cell(ctx->pop()))));
|
||||
}
|
||||
|
||||
void factor_vm::primitive_double_bits() {
|
||||
|
|
@ -310,7 +310,7 @@ VM_C_API fixnum to_fixnum(cell tagged, factor_vm* parent) {
|
|||
return parent->to_fixnum(tagged);
|
||||
}
|
||||
|
||||
cell factor_vm::to_cell(cell tagged) { return (cell) to_fixnum(tagged); }
|
||||
cell factor_vm::to_cell(cell tagged) { return (cell)to_fixnum(tagged); }
|
||||
|
||||
VM_C_API cell to_cell(cell tagged, factor_vm* parent) {
|
||||
return parent->to_cell(tagged);
|
||||
|
|
@ -331,7 +331,7 @@ cell factor_vm::from_signed_8(int64_t n) {
|
|||
if (n < fixnum_min || n > fixnum_max)
|
||||
return tag<bignum>(long_long_to_bignum(n));
|
||||
else
|
||||
return tag_fixnum((fixnum) n);
|
||||
return tag_fixnum((fixnum)n);
|
||||
}
|
||||
|
||||
VM_C_API cell from_signed_8(int64_t n, factor_vm* parent) {
|
||||
|
|
@ -357,10 +357,10 @@ VM_C_API int64_t to_signed_8(cell obj, factor_vm* parent) {
|
|||
|
||||
/* Allocates memory */
|
||||
cell factor_vm::from_unsigned_8(uint64_t n) {
|
||||
if (n > (uint64_t) fixnum_max)
|
||||
if (n > (uint64_t)fixnum_max)
|
||||
return tag<bignum>(ulong_long_to_bignum(n));
|
||||
else
|
||||
return tag_fixnum((fixnum) n);
|
||||
return tag_fixnum((fixnum)n);
|
||||
}
|
||||
|
||||
VM_C_API cell from_unsigned_8(uint64_t n, factor_vm* parent) {
|
||||
|
|
@ -386,7 +386,7 @@ VM_C_API uint64_t to_unsigned_8(cell obj, factor_vm* parent) {
|
|||
|
||||
/* Cannot allocate */
|
||||
float factor_vm::to_float(cell value) {
|
||||
return (float) untag_float_check(value);
|
||||
return (float)untag_float_check(value);
|
||||
}
|
||||
|
||||
/* Cannot allocate */
|
||||
|
|
|
|||
14
vm/math.hpp
14
vm/math.hpp
|
|
@ -1,9 +1,9 @@
|
|||
namespace factor {
|
||||
|
||||
static const fixnum fixnum_max =
|
||||
(((fixnum) 1 << (WORD_SIZE - TAG_BITS - 1)) - 1);
|
||||
static const fixnum fixnum_min = (-((fixnum) 1 << (WORD_SIZE - TAG_BITS - 1)));
|
||||
static const fixnum array_size_max = ((cell) 1 << (WORD_SIZE - TAG_BITS - 2));
|
||||
(((fixnum)1 << (WORD_SIZE - TAG_BITS - 1)) - 1);
|
||||
static const fixnum fixnum_min = (-((fixnum)1 << (WORD_SIZE - TAG_BITS - 1)));
|
||||
static const fixnum array_size_max = ((cell)1 << (WORD_SIZE - TAG_BITS - 2));
|
||||
|
||||
/* Allocates memory */
|
||||
inline cell factor_vm::from_signed_cell(fixnum x) {
|
||||
|
|
@ -15,7 +15,7 @@ inline cell factor_vm::from_signed_cell(fixnum x) {
|
|||
|
||||
/* Allocates memory */
|
||||
inline cell factor_vm::from_unsigned_cell(cell x) {
|
||||
if (x > (cell) fixnum_max)
|
||||
if (x > (cell)fixnum_max)
|
||||
return tag<bignum>(cell_to_bignum(x));
|
||||
else
|
||||
return tag_fixnum(x);
|
||||
|
|
@ -42,18 +42,18 @@ inline double factor_vm::untag_float_check(cell tagged) {
|
|||
}
|
||||
|
||||
inline fixnum factor_vm::float_to_fixnum(cell tagged) {
|
||||
return (fixnum) untag_float(tagged);
|
||||
return (fixnum)untag_float(tagged);
|
||||
}
|
||||
|
||||
inline double factor_vm::fixnum_to_float(cell tagged) {
|
||||
return (double) untag_fixnum(tagged);
|
||||
return (double)untag_fixnum(tagged);
|
||||
}
|
||||
|
||||
inline cell factor_vm::unbox_array_size() {
|
||||
cell obj = ctx->peek();
|
||||
if (TAG(obj) == FIXNUM_TYPE) {
|
||||
fixnum n = untag_fixnum(obj);
|
||||
if (n >= 0 && n < (fixnum) array_size_max) {
|
||||
if (n >= 0 && n < (fixnum)array_size_max) {
|
||||
ctx->pop();
|
||||
return n;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,8 +33,8 @@ cell object_start_map::find_object_containing_card(cell card_index) {
|
|||
|
||||
/* we need to remember the first object allocated in the card */
|
||||
void object_start_map::record_object_start_offset(object* obj) {
|
||||
cell idx = addr_to_card((cell) obj - start);
|
||||
card obj_start = ((cell) obj & addr_card_mask);
|
||||
cell idx = addr_to_card((cell)obj - start);
|
||||
card obj_start = ((cell)obj & addr_card_mask);
|
||||
object_start_offsets[idx] = std::min(object_start_offsets[idx], obj_start);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ void factor_vm::compute_identity_hashcode(object* obj) {
|
|||
object_counter++;
|
||||
if (object_counter == 0)
|
||||
object_counter++;
|
||||
obj->set_hashcode((cell) obj ^ object_counter);
|
||||
obj->set_hashcode((cell)obj ^ object_counter);
|
||||
}
|
||||
|
||||
void factor_vm::primitive_compute_identity_hashcode() {
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ inline static bool save_special_p(cell i) {
|
|||
}
|
||||
|
||||
template <typename Iterator> void object::each_slot(Iterator& iter) {
|
||||
cell scan = (cell) this;
|
||||
cell scan = (cell)this;
|
||||
cell payload_start = binary_payload_start();
|
||||
cell end = scan + payload_start;
|
||||
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ uint64_t nano_count() {
|
|||
int ret = clock_gettime(CLOCK_MONOTONIC, &t);
|
||||
if (ret != 0)
|
||||
fatal_error("clock_gettime failed", 0);
|
||||
return (uint64_t) t.tv_sec * 1000000000 + t.tv_nsec;
|
||||
return (uint64_t)t.tv_sec * 1000000000 + t.tv_nsec;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,10 +11,10 @@ void flush_icache(cell start, cell len);
|
|||
#define UAP_PROGRAM_COUNTER(ucontext) \
|
||||
(((ucontext_t*)ucontext)->uc_mcontext.arm_pc)
|
||||
#define UAP_STACK_POINTER_TYPE greg_t
|
||||
#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
|
||||
#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
|
||||
|
||||
#define CODE_TO_FUNCTION_POINTER(code) (void) 0
|
||||
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
|
||||
#define CODE_TO_FUNCTION_POINTER(code) (void)0
|
||||
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
|
||||
#define FUNCTION_CODE_POINTER(ptr) ptr
|
||||
#define FUNCTION_TOC_POINTER(ptr) ptr
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,10 +8,10 @@ namespace factor {
|
|||
((ucontext_t*)ucontext)->uc_mcontext.uc_regs->gregs[1]
|
||||
#define UAP_PROGRAM_COUNTER(ucontext) \
|
||||
(((ucontext_t*)ucontext)->uc_mcontext.uc_regs->gregs[32])
|
||||
#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
|
||||
#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
|
||||
|
||||
#define CODE_TO_FUNCTION_POINTER(code) (void) 0
|
||||
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
|
||||
#define CODE_TO_FUNCTION_POINTER(code) (void)0
|
||||
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
|
||||
#define FUNCTION_CODE_POINTER(ptr) ptr
|
||||
#define FUNCTION_TOC_POINTER(ptr) ptr
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ namespace factor {
|
|||
((ucontext_t*)ucontext)->uc_mcontext.gp_regs[1]
|
||||
#define UAP_PROGRAM_COUNTER(ucontext) \
|
||||
(((ucontext_t*)ucontext)->uc_mcontext.gp_regs[32])
|
||||
#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
|
||||
#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
|
||||
|
||||
#define FACTOR_PPC_TOC 1
|
||||
|
||||
|
|
|
|||
|
|
@ -50,10 +50,10 @@ inline static void uap_clear_fpu_status(void* uap) {
|
|||
(((ucontext_t*)ucontext)->uc_mcontext.gregs[7])
|
||||
#define UAP_PROGRAM_COUNTER(ucontext) \
|
||||
(((ucontext_t*)ucontext)->uc_mcontext.gregs[14])
|
||||
#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
|
||||
#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
|
||||
|
||||
#define CODE_TO_FUNCTION_POINTER(code) (void) 0
|
||||
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
|
||||
#define CODE_TO_FUNCTION_POINTER(code) (void)0
|
||||
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
|
||||
#define FUNCTION_CODE_POINTER(ptr) ptr
|
||||
#define FUNCTION_TOC_POINTER(ptr) ptr
|
||||
|
||||
|
|
|
|||
|
|
@ -18,10 +18,10 @@ inline static void uap_clear_fpu_status(void* uap) {
|
|||
(((ucontext_t*)ucontext)->uc_mcontext.gregs[15])
|
||||
#define UAP_PROGRAM_COUNTER(ucontext) \
|
||||
(((ucontext_t*)ucontext)->uc_mcontext.gregs[16])
|
||||
#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
|
||||
#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
|
||||
|
||||
#define CODE_TO_FUNCTION_POINTER(code) (void) 0
|
||||
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
|
||||
#define CODE_TO_FUNCTION_POINTER(code) (void)0
|
||||
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
|
||||
#define FUNCTION_CODE_POINTER(ptr) ptr
|
||||
#define FUNCTION_TOC_POINTER(ptr) ptr
|
||||
|
||||
|
|
|
|||
|
|
@ -9,12 +9,12 @@ const char* vm_executable_path();
|
|||
const char* default_image_path();
|
||||
|
||||
#define UAP_STACK_POINTER(ucontext) (((ucontext_t*)ucontext)->uc_stack.ss_sp)
|
||||
#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
|
||||
#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
|
||||
|
||||
#define UAP_STACK_POINTER_TYPE void *
|
||||
#define UAP_STACK_POINTER_TYPE void*
|
||||
|
||||
#define CODE_TO_FUNCTION_POINTER(code) (void) 0
|
||||
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
|
||||
#define CODE_TO_FUNCTION_POINTER(code) (void)0
|
||||
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
|
||||
#define FUNCTION_CODE_POINTER(ptr) ptr
|
||||
#define FUNCTION_TOC_POINTER(ptr) ptr
|
||||
|
||||
|
|
|
|||
|
|
@ -92,10 +92,10 @@ segment::segment(cell size_, bool executable_p) {
|
|||
out_of_memory();
|
||||
|
||||
if (mprotect(array, pagesize, PROT_NONE) == -1)
|
||||
fatal_error("Cannot protect low guard page", (cell) array);
|
||||
fatal_error("Cannot protect low guard page", (cell)array);
|
||||
|
||||
if (mprotect(array + pagesize + size, pagesize, PROT_NONE) == -1)
|
||||
fatal_error("Cannot protect high guard page", (cell) array);
|
||||
fatal_error("Cannot protect high guard page", (cell)array);
|
||||
|
||||
start = (cell)(array + pagesize);
|
||||
end = start + size;
|
||||
|
|
@ -110,19 +110,19 @@ segment::~segment() {
|
|||
|
||||
void code_heap::guard_safepoint() {
|
||||
if (mprotect(safepoint_page, getpagesize(), PROT_NONE) == -1)
|
||||
fatal_error("Cannot protect safepoint guard page", (cell) safepoint_page);
|
||||
fatal_error("Cannot protect safepoint guard page", (cell)safepoint_page);
|
||||
}
|
||||
|
||||
void code_heap::unguard_safepoint() {
|
||||
if (mprotect(safepoint_page, getpagesize(), PROT_WRITE) == -1)
|
||||
fatal_error("Cannot unprotect safepoint guard page", (cell) safepoint_page);
|
||||
fatal_error("Cannot unprotect safepoint guard page", (cell)safepoint_page);
|
||||
}
|
||||
|
||||
void factor_vm::dispatch_signal(void* uap, void(handler)()) {
|
||||
dispatch_signal_handler((cell*)&UAP_STACK_POINTER(uap),
|
||||
(cell*)&UAP_PROGRAM_COUNTER(uap),
|
||||
(cell) FUNCTION_CODE_POINTER(handler));
|
||||
UAP_SET_TOC_POINTER(uap, (cell) FUNCTION_TOC_POINTER(handler));
|
||||
(cell)FUNCTION_CODE_POINTER(handler));
|
||||
UAP_SET_TOC_POINTER(uap, (cell)FUNCTION_TOC_POINTER(handler));
|
||||
}
|
||||
|
||||
void factor_vm::start_sampling_profiler_timer() {
|
||||
|
|
@ -141,9 +141,9 @@ void factor_vm::end_sampling_profiler_timer() {
|
|||
|
||||
void memory_signal_handler(int signal, siginfo_t* siginfo, void* uap) {
|
||||
factor_vm* vm = current_vm();
|
||||
vm->verify_memory_protection_error((cell) siginfo->si_addr);
|
||||
vm->signal_fault_addr = (cell) siginfo->si_addr;
|
||||
vm->signal_fault_pc = (cell) UAP_PROGRAM_COUNTER(uap);
|
||||
vm->verify_memory_protection_error((cell)siginfo->si_addr);
|
||||
vm->signal_fault_addr = (cell)siginfo->si_addr;
|
||||
vm->signal_fault_pc = (cell)UAP_PROGRAM_COUNTER(uap);
|
||||
vm->dispatch_signal(uap, factor::memory_signal_handler_impl);
|
||||
}
|
||||
|
||||
|
|
@ -195,7 +195,7 @@ void sample_signal_handler(int signal, siginfo_t* siginfo, void* uap) {
|
|||
vm = thread_vms.begin()->second;
|
||||
}
|
||||
if (atomic::load(&vm->sampling_profiler_p))
|
||||
vm->safepoint.enqueue_samples(vm, 1, (cell) UAP_PROGRAM_COUNTER(uap),
|
||||
vm->safepoint.enqueue_samples(vm, 1, (cell)UAP_PROGRAM_COUNTER(uap),
|
||||
foreign_thread);
|
||||
else if (!foreign_thread)
|
||||
enqueue_signal(vm, signal);
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ void factor_vm::c_to_factor_toplevel(cell quot) {
|
|||
seh_area->handler[12] = 0xe0;
|
||||
|
||||
/* Store address of exception handler in the operand of the 'mov' */
|
||||
cell handler = (cell) & factor::exception_handler;
|
||||
cell handler = (cell)&factor::exception_handler;
|
||||
memcpy(&seh_area->handler[2], &handler, sizeof(cell));
|
||||
|
||||
UNWIND_INFO* unwind_info = &seh_area->unwind_info;
|
||||
|
|
@ -64,13 +64,13 @@ void factor_vm::c_to_factor_toplevel(cell quot) {
|
|||
unwind_info->CountOfCodes = 0;
|
||||
unwind_info->FrameRegister = 0;
|
||||
unwind_info->FrameOffset = 0;
|
||||
unwind_info->ExceptionHandler = (DWORD)((cell) & seh_area->handler[0] - base);
|
||||
unwind_info->ExceptionHandler = (DWORD)((cell)&seh_area->handler[0] - base);
|
||||
unwind_info->ExceptionData[0] = 0;
|
||||
|
||||
RUNTIME_FUNCTION* func = &seh_area->func;
|
||||
func->BeginAddress = 0;
|
||||
func->EndAddress = (DWORD)(code->seg->end - base);
|
||||
func->UnwindData = (DWORD)((cell) & seh_area->unwind_info - base);
|
||||
func->UnwindData = (DWORD)((cell)&seh_area->unwind_info - base);
|
||||
|
||||
if (!RtlAddFunctionTable(func, 1, base))
|
||||
fatal_error("RtlAddFunctionTable() failed", 0);
|
||||
|
|
|
|||
|
|
@ -104,13 +104,13 @@ segment::segment(cell size_, bool executable_p) {
|
|||
out_of_memory();
|
||||
|
||||
if (!VirtualProtect(mem, getpagesize(), PAGE_NOACCESS, &ignore))
|
||||
fatal_error("Cannot allocate low guard page", (cell) mem);
|
||||
fatal_error("Cannot allocate low guard page", (cell)mem);
|
||||
|
||||
if (!VirtualProtect(mem + size + getpagesize(), getpagesize(), PAGE_NOACCESS,
|
||||
&ignore))
|
||||
fatal_error("Cannot allocate high guard page", (cell) mem);
|
||||
fatal_error("Cannot allocate high guard page", (cell)mem);
|
||||
|
||||
start = (cell) mem + getpagesize();
|
||||
start = (cell)mem + getpagesize();
|
||||
end = start + size;
|
||||
}
|
||||
|
||||
|
|
@ -134,13 +134,13 @@ long getpagesize() {
|
|||
void code_heap::guard_safepoint() {
|
||||
DWORD ignore;
|
||||
if (!VirtualProtect(safepoint_page, getpagesize(), PAGE_NOACCESS, &ignore))
|
||||
fatal_error("Cannot protect safepoint guard page", (cell) safepoint_page);
|
||||
fatal_error("Cannot protect safepoint guard page", (cell)safepoint_page);
|
||||
}
|
||||
|
||||
void code_heap::unguard_safepoint() {
|
||||
DWORD ignore;
|
||||
if (!VirtualProtect(safepoint_page, getpagesize(), PAGE_READWRITE, &ignore))
|
||||
fatal_error("Cannot unprotect safepoint guard page", (cell) safepoint_page);
|
||||
fatal_error("Cannot unprotect safepoint guard page", (cell)safepoint_page);
|
||||
}
|
||||
|
||||
void factor_vm::move_file(const vm_char* path1, const vm_char* path2) {
|
||||
|
|
@ -184,7 +184,7 @@ uint64_t nano_count() {
|
|||
#endif
|
||||
lo = count.LowPart;
|
||||
|
||||
return (uint64_t)((((uint64_t) hi << 32) | (uint64_t) lo) * scale_factor);
|
||||
return (uint64_t)((((uint64_t)hi << 32) | (uint64_t)lo) * scale_factor);
|
||||
}
|
||||
|
||||
void sleep_nanos(uint64_t nsec) { Sleep((DWORD)(nsec / 1000000)); }
|
||||
|
|
@ -203,7 +203,7 @@ LONG factor_vm::exception_handler(PEXCEPTION_RECORD e, void* frame, PCONTEXT c,
|
|||
signal_fault_addr = e->ExceptionInformation[1];
|
||||
verify_memory_protection_error(signal_fault_addr);
|
||||
dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP,
|
||||
(cell) factor::memory_signal_handler_impl);
|
||||
(cell)factor::memory_signal_handler_impl);
|
||||
break;
|
||||
|
||||
case STATUS_FLOAT_DENORMAL_OPERAND:
|
||||
|
|
@ -225,12 +225,12 @@ LONG factor_vm::exception_handler(PEXCEPTION_RECORD e, void* frame, PCONTEXT c,
|
|||
#endif
|
||||
MXCSR(c) &= 0xffffffc0;
|
||||
dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP,
|
||||
(cell) factor::fp_signal_handler_impl);
|
||||
(cell)factor::fp_signal_handler_impl);
|
||||
break;
|
||||
default:
|
||||
signal_number = e->ExceptionCode;
|
||||
dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP,
|
||||
(cell) factor::synchronous_signal_handler_impl);
|
||||
(cell)factor::synchronous_signal_handler_impl);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -86,8 +86,8 @@ inline static THREADHANDLE thread_id() {
|
|||
|
||||
inline static void breakpoint() { DebugBreak(); }
|
||||
|
||||
#define CODE_TO_FUNCTION_POINTER(code) (void) 0
|
||||
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
|
||||
#define CODE_TO_FUNCTION_POINTER(code) (void)0
|
||||
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
|
||||
#define FUNCTION_CODE_POINTER(ptr) ptr
|
||||
#define FUNCTION_TOC_POINTER(ptr) ptr
|
||||
}
|
||||
|
|
|
|||
|
|
@ -350,8 +350,8 @@ void factor_vm::primitive_array_to_quotation() {
|
|||
void factor_vm::primitive_quotation_code() {
|
||||
data_root<quotation> quot(ctx->pop(), this);
|
||||
|
||||
ctx->push(from_unsigned_cell((cell) quot->entry_point));
|
||||
ctx->push(from_unsigned_cell((cell) quot->code() + quot->code()->size()));
|
||||
ctx->push(from_unsigned_cell((cell)quot->entry_point));
|
||||
ctx->push(from_unsigned_cell((cell)quot->code() + quot->code()->size()));
|
||||
}
|
||||
|
||||
/* Allocates memory */
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
namespace factor {
|
||||
|
||||
void factor_vm::primitive_exit() { exit((int) to_fixnum(ctx->pop())); }
|
||||
void factor_vm::primitive_exit() { exit((int)to_fixnum(ctx->pop())); }
|
||||
|
||||
void exit(int status) {
|
||||
factor_vm::close_console();
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ void safepoint_state::handle_safepoint(factor_vm* parent, cell pc) volatile {
|
|||
} else if (atomic::load(&parent->sampling_profiler_p)) {
|
||||
FACTOR_ASSERT(parent->code->seg->in_segment_p(pc));
|
||||
code_block* block = parent->code->code_block_for_address(pc);
|
||||
bool prolog_p = (cell) block->entry_point() == pc;
|
||||
bool prolog_p = (cell)block->entry_point() == pc;
|
||||
|
||||
parent->record_sample(prolog_p);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ template <typename Fixup> cell object::size(Fixup fixup) const {
|
|||
callstack_object_size(untag_fixnum(((callstack*)this)->length)),
|
||||
data_alignment);
|
||||
default:
|
||||
critical_error("Invalid header in size", (cell) this);
|
||||
critical_error("Invalid header in size", (cell)this);
|
||||
return 0; /* can't happen */
|
||||
}
|
||||
}
|
||||
|
|
@ -79,7 +79,7 @@ template <typename Fixup> cell object::binary_payload_start(Fixup fixup) const {
|
|||
case WRAPPER_TYPE:
|
||||
return sizeof(wrapper);
|
||||
default:
|
||||
critical_error("Invalid header in binary_payload_start", (cell) this);
|
||||
critical_error("Invalid header in binary_payload_start", (cell)this);
|
||||
return 0; /* can't happen */
|
||||
}
|
||||
}
|
||||
|
|
@ -154,7 +154,7 @@ void slot_visitor<Fixup>::visit_object_array(cell* start, cell* end) {
|
|||
template <typename Fixup>
|
||||
void slot_visitor<Fixup>::visit_slots(object* ptr, cell payload_start) {
|
||||
cell* slot = (cell*)ptr;
|
||||
cell* end = (cell*)((cell) ptr + payload_start);
|
||||
cell* end = (cell*)((cell)ptr + payload_start);
|
||||
|
||||
if (slot != end) {
|
||||
slot++;
|
||||
|
|
@ -191,7 +191,7 @@ template <typename Fixup> void slot_visitor<Fixup>::visit_bignum_roots() {
|
|||
cell* handle = (cell*)(*iter);
|
||||
|
||||
if (*handle)
|
||||
*handle = (cell) fixup.fixup_data(*(object**)handle);
|
||||
*handle = (cell)fixup.fixup_data(*(object**)handle);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -285,7 +285,7 @@ template <typename Fixup> struct call_frame_slot_visitor {
|
|||
|
||||
FACTOR_ASSERT(return_address < compiled->size());
|
||||
cell callsite = info->return_address_index(return_address);
|
||||
if (callsite == (cell) - 1)
|
||||
if (callsite == (cell)-1)
|
||||
return;
|
||||
|
||||
#ifdef DEBUG_GC_MAPS
|
||||
|
|
|
|||
|
|
@ -16,13 +16,13 @@ struct tenured_space : free_list_allocator<object> {
|
|||
}
|
||||
|
||||
cell first_object() {
|
||||
return (cell) next_allocated_block_after(this->first_block());
|
||||
return (cell)next_allocated_block_after(this->first_block());
|
||||
}
|
||||
|
||||
cell next_object_after(cell scan) {
|
||||
cell size = ((object*)scan)->size();
|
||||
object* next = (object*)(scan + size);
|
||||
return (cell) next_allocated_block_after(next);
|
||||
return (cell)next_allocated_block_after(next);
|
||||
}
|
||||
|
||||
void clear_mark_bits() { state.clear_mark_bits(); }
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ struct to_tenured_policy {
|
|||
}
|
||||
|
||||
void promoted_object(object* obj) {
|
||||
parent->mark_stack.push_back((cell) obj);
|
||||
parent->mark_stack.push_back((cell)obj);
|
||||
}
|
||||
|
||||
void visited_object(object* obj) {}
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ inline static void memset_2(void* dst, uint16_t pattern, size_t size) {
|
|||
memset(dst, 0, size);
|
||||
else {
|
||||
uint16_t* start = (uint16_t*)dst;
|
||||
uint16_t* end = (uint16_t*)((cell) dst + size);
|
||||
uint16_t* end = (uint16_t*)((cell)dst + size);
|
||||
while (start < end) {
|
||||
*start = pattern;
|
||||
start++;
|
||||
|
|
@ -30,7 +30,7 @@ inline static void memset_cell(void* dst, cell pattern, size_t size) {
|
|||
memset(dst, 0, size);
|
||||
else {
|
||||
cell* start = (cell*)dst;
|
||||
cell* end = (cell*)((cell) dst + size);
|
||||
cell* end = (cell*)((cell)dst + size);
|
||||
while (start < end) {
|
||||
*start = pattern;
|
||||
start++;
|
||||
|
|
|
|||
10
vm/vm.hpp
10
vm/vm.hpp
|
|
@ -337,13 +337,13 @@ struct factor_vm {
|
|||
/* the write barrier must be called any time we are potentially storing a
|
||||
pointer from an older generation to a younger one */
|
||||
inline void write_barrier(cell* slot_ptr) {
|
||||
*(char*)(cards_offset + ((cell) slot_ptr >> card_bits)) = card_mark_mask;
|
||||
*(char*)(decks_offset + ((cell) slot_ptr >> deck_bits)) = card_mark_mask;
|
||||
*(char*)(cards_offset + ((cell)slot_ptr >> card_bits)) = card_mark_mask;
|
||||
*(char*)(decks_offset + ((cell)slot_ptr >> deck_bits)) = card_mark_mask;
|
||||
}
|
||||
|
||||
inline void write_barrier(object* obj, cell size) {
|
||||
cell start = (cell) obj & (~card_size + 1);
|
||||
cell end = ((cell) obj + size + card_size - 1) & (~card_size + 1);
|
||||
cell start = (cell)obj & (~card_size + 1);
|
||||
cell end = ((cell)obj + size + card_size - 1) & (~card_size + 1);
|
||||
|
||||
for (cell offset = start; offset < end; offset += card_size)
|
||||
write_barrier((cell*)offset);
|
||||
|
|
@ -387,7 +387,7 @@ struct factor_vm {
|
|||
|
||||
inline void check_data_pointer(object* pointer) {
|
||||
FACTOR_ASSERT((current_gc && current_gc->op == collect_growing_heap_op) ||
|
||||
data->seg->in_segment_p((cell) pointer));
|
||||
data->seg->in_segment_p((cell)pointer));
|
||||
}
|
||||
|
||||
// generic arrays
|
||||
|
|
|
|||
|
|
@ -77,8 +77,8 @@ void factor_vm::primitive_word_code() {
|
|||
data_root<word> w(ctx->pop(), this);
|
||||
w.untag_check(this);
|
||||
|
||||
ctx->push(from_unsigned_cell((cell) w->entry_point));
|
||||
ctx->push(from_unsigned_cell((cell) w->code() + w->code()->size()));
|
||||
ctx->push(from_unsigned_cell((cell)w->entry_point));
|
||||
ctx->push(from_unsigned_cell((cell)w->code() + w->code()->size()));
|
||||
}
|
||||
|
||||
void factor_vm::primitive_optimized_p() {
|
||||
|
|
|
|||
Loading…
Reference in New Issue