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 2013-05-13 00:53:47 -04:00
parent 88d7c10d03
commit ffe41b3d7f
64 changed files with 259 additions and 259 deletions

View File

@ -48,7 +48,7 @@ cell factor_vm::allot_alien(cell delegate_, cell displacement) {
/* Allocates memory */ /* Allocates memory */
cell factor_vm::allot_alien(void* address) { 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 */ /* 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. */ if the object is a byte array, as a sanity check. */
/* Allocates memory (from_unsigned_cell can allocate) */ /* Allocates memory (from_unsigned_cell can allocate) */
void factor_vm::primitive_alien_address() { 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 */ /* 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) { \ VM_C_API void primitive_set_alien_##name(factor_vm * parent) { \
type* ptr = (type*)parent->alien_pointer(); \ type* ptr = (type*)parent->alien_pointer(); \
type value = (type) parent->to(parent->ctx->pop()); \ type value = (type)parent->to(parent->ctx->pop()); \
*ptr = value; \ *ptr = value; \
} }

View File

@ -3,10 +3,10 @@ namespace factor { void abort(); }
#ifdef FACTOR_DEBUG #ifdef FACTOR_DEBUG
#define FACTOR_ASSERT(condition) \ #define FACTOR_ASSERT(condition) \
((condition) \ ((condition) \
? (void) 0 \ ? (void)0 \
: (::fprintf(stderr, "assertion \"%s\" failed: file \"%s\", line %d\n", \ : (::fprintf(stderr, "assertion \"%s\" failed: file \"%s\", line %d\n", \
#condition, __FILE__, __LINE__), \ #condition, __FILE__, __LINE__), \
::factor::abort())) ::factor::abort()))
#else #else
#define FACTOR_ASSERT(condition) ((void) 0) #define FACTOR_ASSERT(condition) ((void)0)
#endif #endif

View File

@ -15,21 +15,21 @@ __forceinline static bool cas(volatile fixnum* ptr, fixnum old_val,
} }
__forceinline static cell fetch_add(volatile cell* ptr, cell val) { __forceinline static cell fetch_add(volatile cell* ptr, cell val) {
return (cell) return (cell)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr), (LONG) val); (LONG) val);
} }
__forceinline static fixnum fetch_add(volatile fixnum* ptr, fixnum val) { __forceinline static fixnum fetch_add(volatile fixnum* ptr, fixnum val) {
return (fixnum) return (fixnum)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr), (LONG) val); (LONG) val);
} }
__forceinline static cell fetch_subtract(volatile cell* ptr, cell val) { __forceinline static cell fetch_subtract(volatile cell* ptr, cell val) {
return (cell) InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr), return (cell)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
-(LONG) val); -(LONG)val);
} }
__forceinline static fixnum fetch_subtract(volatile fixnum* ptr, fixnum val) { __forceinline static fixnum fetch_subtract(volatile fixnum* ptr, fixnum val) {
return (fixnum) InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr), return (fixnum)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
-(LONG) val); -(LONG)val);
} }
__forceinline static void fence() { MemoryBarrier(); } __forceinline static void fence() { MemoryBarrier(); }

View File

@ -4,32 +4,32 @@ namespace factor {
namespace atomic { namespace atomic {
__forceinline static bool cas(volatile cell* ptr, cell old_val, cell new_val) { __forceinline static bool cas(volatile cell* ptr, cell old_val, cell new_val) {
return InterlockedCompareExchange64(reinterpret_cast<volatile LONG64*>(ptr), return InterlockedCompareExchange64(reinterpret_cast<volatile LONG64*>(ptr),
(LONG64) old_val, (LONG64) new_val) == (LONG64)old_val, (LONG64)new_val) ==
(LONG64) old_val; (LONG64)old_val;
} }
__forceinline static bool cas(volatile fixnum* ptr, fixnum old_val, __forceinline static bool cas(volatile fixnum* ptr, fixnum old_val,
fixnum new_val) { fixnum new_val) {
return InterlockedCompareExchange64(reinterpret_cast<volatile LONG64*>(ptr), return InterlockedCompareExchange64(reinterpret_cast<volatile LONG64*>(ptr),
(LONG64) old_val, (LONG64) new_val) == (LONG64)old_val, (LONG64)new_val) ==
(LONG64) old_val; (LONG64)old_val;
} }
__forceinline static cell fetch_add(volatile cell* ptr, cell val) { __forceinline static cell fetch_add(volatile cell* ptr, cell val) {
return (cell) InterlockedExchangeAdd64( return (cell)InterlockedExchangeAdd64(
reinterpret_cast<volatile LONG64*>(ptr), (LONG64) val); reinterpret_cast<volatile LONG64*>(ptr), (LONG64)val);
} }
__forceinline static fixnum fetch_add(volatile fixnum* ptr, fixnum val) { __forceinline static fixnum fetch_add(volatile fixnum* ptr, fixnum val) {
return (fixnum) InterlockedExchangeAdd64( return (fixnum)InterlockedExchangeAdd64(
reinterpret_cast<volatile LONG64*>(ptr), (LONG64) val); reinterpret_cast<volatile LONG64*>(ptr), (LONG64)val);
} }
__forceinline static cell fetch_subtract(volatile cell* ptr, cell val) { __forceinline static cell fetch_subtract(volatile cell* ptr, cell val) {
return (cell) InterlockedExchangeAdd64( return (cell)InterlockedExchangeAdd64(
reinterpret_cast<volatile LONG64*>(ptr), -(LONG64) val); reinterpret_cast<volatile LONG64*>(ptr), -(LONG64)val);
} }
__forceinline static fixnum fetch_subtract(volatile fixnum* ptr, fixnum val) { __forceinline static fixnum fetch_subtract(volatile fixnum* ptr, fixnum val) {
return (fixnum) InterlockedExchangeAdd64( return (fixnum)InterlockedExchangeAdd64(
reinterpret_cast<volatile LONG64*>(ptr), -(LONG64) val); reinterpret_cast<volatile LONG64*>(ptr), -(LONG64)val);
} }
__forceinline static void fence() { MemoryBarrier(); } __forceinline static void fence() { MemoryBarrier(); }

View File

@ -330,7 +330,7 @@ BIGNUM_TO_FOO(ulong_long, uint64_t, int64_t, uint64_t)
significand *= (factor); \ significand *= (factor); \
digit = ((bignum_digit_type) significand); \ digit = ((bignum_digit_type) significand); \
(*--scan) = digit; \ (*--scan) = digit; \
significand -= ((double) digit); \ significand -= ((double)digit); \
} }
#define inf std::numeric_limits<double>::infinity() #define inf std::numeric_limits<double>::infinity()
@ -355,7 +355,7 @@ bignum* factor_vm::double_to_bignum(double x) {
bignum_digit_type digit; bignum_digit_type digit;
int odd_bits = (exponent % BIGNUM_DIGIT_LENGTH); int odd_bits = (exponent % BIGNUM_DIGIT_LENGTH);
if (odd_bits > 0) if (odd_bits > 0)
DTB_WRITE_DIGIT((fixnum) 1 << odd_bits); DTB_WRITE_DIGIT((fixnum)1 << odd_bits);
while (start < scan) { while (start < scan) {
if (significand == 0) { if (significand == 0) {
while (start < scan) 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_source = (scan_source + (BIGNUM_LENGTH(source)));
bignum_digit_type* end_target = (scan_target + (BIGNUM_LENGTH(target))); bignum_digit_type* end_target = (scan_target + (BIGNUM_LENGTH(target)));
int shift_right = (BIGNUM_DIGIT_LENGTH - shift_left); 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) { while (scan_source < end_source) {
digit = (*scan_source++); digit = (*scan_source++);
(*scan_target++) = (((digit & mask) << shift_left) | carry); (*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 digit;
bignum_digit_type carry = 0; bignum_digit_type carry = 0;
int shift_left = (BIGNUM_DIGIT_LENGTH - shift_right); 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) { while (start < scan) {
digit = (*--scan); digit = (*--scan);
(*scan) = ((digit >> shift_right) | carry); (*scan) = ((digit >> shift_right) | carry);
@ -1605,7 +1605,7 @@ int factor_vm::bignum_unsigned_logbitp(int shift, bignum* bignum) {
return 0; return 0;
bignum_digit_type digit = (BIGNUM_REF(bignum, index)); bignum_digit_type digit = (BIGNUM_REF(bignum, index));
int p = shift % BIGNUM_DIGIT_LENGTH; 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; return (digit & mask) ? 1 : 0;
} }

View File

@ -63,7 +63,7 @@ typedef int64_t bignum_twodigit_type;
#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)
#define BIGNUM_RADIX_ROOT (((bignum_digit_type) 1) << BIGNUM_HALF_DIGIT_LENGTH) #define BIGNUM_RADIX_ROOT (((bignum_digit_type) 1) << BIGNUM_HALF_DIGIT_LENGTH)
#define BIGNUM_DIGIT_MASK (BIGNUM_RADIX - 1) #define BIGNUM_DIGIT_MASK (BIGNUM_RADIX - 1)
#define BIGNUM_HALF_DIGIT_MASK (BIGNUM_RADIX_ROOT - 1) #define BIGNUM_HALF_DIGIT_MASK (BIGNUM_RADIX_ROOT - 1)

View File

@ -10,7 +10,7 @@ template <typename Block> struct bump_allocator {
bump_allocator(cell size, cell start) bump_allocator(cell size, cell start)
: here(start), start(start), end(start + size), size(size) {} : 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) { Block* allot(cell size) {
cell h = here; cell h = here;

View File

@ -51,7 +51,7 @@ void callback_heap::store_callback_operand(code_block* stub, cell index,
void callback_heap::update(code_block* stub) { void callback_heap::update(code_block* stub) {
store_callback_operand(stub, setup_seh_p() ? 2 : 1, store_callback_operand(stub, setup_seh_p() ? 2 : 1,
(cell) callback_entry_point(stub)); (cell)callback_entry_point(stub));
stub->flush_icache(); 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); memcpy(stub->entry_point(), insns->data<void>(), size);
/* Store VM pointer */ /* Store VM pointer */
store_callback_operand(stub, 0, (cell) parent); store_callback_operand(stub, 0, (cell)parent);
cell index; cell index;

View File

@ -49,7 +49,7 @@ struct callback_heap {
void update(); void update();
code_block* next(code_block* stub) { 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) { template <typename Iterator> void each_callback(Iterator& iter) {

View File

@ -31,7 +31,7 @@ cell factor_vm::capture_callstack(context* ctx) {
void* top = second_from_top_stack_frame(ctx); void* top = second_from_top_stack_frame(ctx);
void* bottom = ctx->callstack_bottom; 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); callstack* stack = allot_callstack(size);
memcpy(stack->top(), top, 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* factor_vm::frame_predecessor(void* frame_top) {
void* addr = frame_return_address((void*)frame_top); void* addr = frame_return_address((void*)frame_top);
FACTOR_ASSERT(addr != 0); FACTOR_ASSERT(addr != 0);
code_block* owner = code->code_block_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); cell frame_size = owner->stack_frame_size_for_address((cell)addr);
return (void*)((char*)frame_top + frame_size); 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()); callstack* stack = untag_check<callstack>(ctx->peek());
void* frame = stack->top(); void* frame = stack->top();
void* addr = frame_return_address(frame); 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() { void factor_vm::primitive_innermost_stack_frame_scan() {
callstack* stack = untag_check<callstack>(ctx->peek()); callstack* stack = untag_check<callstack>(ctx->peek());
void* frame = stack->top(); void* frame = stack->top();
void* addr = frame_return_address(frame); 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() { 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* inner = stack->top();
void* addr = frame_return_address(inner); 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); cell offset = block->offset(addr);
set_frame_return_address(inner, (char*)quot->entry_point + offset); set_frame_return_address(inner, (char*)quot->entry_point + offset);
} }

View File

@ -21,8 +21,8 @@ inline void factor_vm::iterate_callstack_object(callstack* stack_,
void* fixed_addr = Fixup::translated_code_block_map void* fixed_addr = Fixup::translated_code_block_map
? (void*)fixup.translate_code((code_block*)addr) ? (void*)fixup.translate_code((code_block*)addr)
: addr; : addr;
code_block* owner = code->code_block_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); cell frame_size = owner->stack_frame_size_for_address((cell)fixed_addr);
iterator(frame_top, frame_size, owner, fixed_addr); iterator(frame_top, frame_size, owner, fixed_addr);
frame_offset += frame_size; 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) ? (void*)fixup.translate_code((code_block*)addr)
: 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 = code_block* fixed_owner =
Fixup::translated_code_block_map ? owner : fixup.translate_code(owner); Fixup::translated_code_block_map ? owner : fixup.translate_code(owner);
cell frame_size = 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 = void* fixed_addr_for_iter =
Fixup::translated_code_block_map ? fixed_addr : addr; Fixup::translated_code_block_map ? fixed_addr : addr;

View File

@ -34,9 +34,9 @@ cell code_block::scan(factor_vm* vm, void* addr) const {
cell factor_vm::compute_entry_point_address(cell obj) { cell factor_vm::compute_entry_point_address(cell obj) {
switch (tagged<object>(obj).type()) { switch (tagged<object>(obj).type()) {
case WORD_TYPE: case WORD_TYPE:
return (cell) untag<word>(obj)->entry_point; return (cell)untag<word>(obj)->entry_point;
case QUOTATION_TYPE: case QUOTATION_TYPE:
return (cell) untag<quotation>(obj)->entry_point; return (cell)untag<quotation>(obj)->entry_point;
default: default:
critical_error("Expected word or quotation", obj); critical_error("Expected word or quotation", obj);
return 0; 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) { cell factor_vm::compute_entry_point_pic_address(word* w, cell tagged_quot) {
if (!to_boolean(tagged_quot) || max_pic_size == 0) if (!to_boolean(tagged_quot) || max_pic_size == 0)
return (cell) w->entry_point; return (cell)w->entry_point;
else { else {
quotation* quot = untag<quotation>(tagged_quot); quotation* quot = untag<quotation>(tagged_quot);
if (quot_compiled_p(quot)) if (quot_compiled_p(quot))
return (cell) quot->entry_point; return (cell)quot->entry_point;
else 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; void* undefined_symbol = (void*)factor::undefined_symbol;
undefined_symbol = FUNCTION_CODE_POINTER(undefined_symbol); undefined_symbol = FUNCTION_CODE_POINTER(undefined_symbol);
if (d != NULL && !d->handle) if (d != NULL && !d->handle)
return (cell) undefined_symbol; return (cell)undefined_symbol;
switch (tagged<object>(symbol).type()) { switch (tagged<object>(symbol).type()) {
case BYTE_ARRAY_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); void* sym = ffi_dlsym(d, name);
if (sym) if (sym)
return (cell) sym; return (cell)sym;
else else
return (cell) undefined_symbol; return (cell)undefined_symbol;
} }
case ARRAY_TYPE: { case ARRAY_TYPE: {
array* names = untag<array>(symbol); 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); void* sym = ffi_dlsym(d, name);
if (sym) if (sym)
return (cell) sym; return (cell)sym;
} }
return (cell) undefined_symbol; return (cell)undefined_symbol;
} }
default: default:
critical_error("Bad symbol specifier", symbol); 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; void* undefined_toc = (void*)factor::undefined_symbol;
undefined_toc = FUNCTION_TOC_POINTER(undefined_toc); undefined_toc = FUNCTION_TOC_POINTER(undefined_toc);
if (d != NULL && !d->handle) if (d != NULL && !d->handle)
return (cell) undefined_toc; return (cell)undefined_toc;
switch (tagged<object>(symbol).type()) { switch (tagged<object>(symbol).type()) {
case BYTE_ARRAY_TYPE: { case BYTE_ARRAY_TYPE: {
symbol_char* name = alien_offset(symbol); symbol_char* name = alien_offset(symbol);
void* toc = ffi_dlsym_toc(d, name); void* toc = ffi_dlsym_toc(d, name);
if (toc) if (toc)
return (cell) toc; return (cell)toc;
else else
return (cell) undefined_toc; return (cell)undefined_toc;
} }
case ARRAY_TYPE: { case ARRAY_TYPE: {
array* names = untag<array>(symbol); 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); void* toc = ffi_dlsym_toc(d, name);
if (toc) if (toc)
return (cell) toc; return (cell)toc;
} }
return (cell) undefined_toc; return (cell)undefined_toc;
} }
default: default:
critical_error("Bad symbol specifier", symbol); critical_error("Bad symbol specifier", symbol);
return (cell) undefined_toc; return (cell)undefined_toc;
} }
} }
#endif #endif
cell factor_vm::compute_vm_address(cell arg) { 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) { 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)); op.store_value(compute_dlsym_address(parameters, index));
break; break;
case RT_THIS: case RT_THIS:
op.store_value((cell) compiled->entry_point()); op.store_value((cell)compiled->entry_point());
break; break;
case RT_MEGAMORPHIC_CACHE_HITS: case RT_MEGAMORPHIC_CACHE_HITS:
op.store_value((cell) & dispatch_stats.megamorphic_cache_hits); op.store_value((cell)&dispatch_stats.megamorphic_cache_hits);
break; break;
case RT_VM: case RT_VM:
op.store_value(compute_vm_address(array_nth(parameters, index))); op.store_value(compute_vm_address(array_nth(parameters, index)));
@ -262,7 +262,7 @@ void factor_vm::store_external_address(instruction_operand op) {
break; break;
#ifdef WINDOWS #ifdef WINDOWS
case RT_EXCEPTION_HANDLER: case RT_EXCEPTION_HANDLER:
op.store_value((cell) & factor::exception_handler); op.store_value((cell)&factor::exception_handler);
break; break;
#endif #endif
#ifdef FACTOR_PPC #ifdef FACTOR_PPC
@ -271,10 +271,10 @@ void factor_vm::store_external_address(instruction_operand op) {
break; break;
#endif #endif
case RT_INLINE_CACHE_MISS: case RT_INLINE_CACHE_MISS:
op.store_value((cell) & factor::inline_cache_miss); op.store_value((cell)&factor::inline_cache_miss);
break; break;
case RT_SAFEPOINT: case RT_SAFEPOINT:
op.store_value((cell) code->safepoint_page); op.store_value((cell)code->safepoint_page);
break; break;
default: default:
critical_error("Bad rel type in store_external_address()", op.rel_type()); 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) { code_block* compiled) {
fixnum n = untag_fixnum(arg); fixnum n = untag_fixnum(arg);
if (n >= 0) if (n >= 0)
return (cell) compiled->entry_point() + offset + n; return (cell)compiled->entry_point() + offset + n;
else else
return (cell) compiled->entry_point() - n; return (cell)compiled->entry_point() - n;
} }
struct initial_code_block_visitor { 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); relocation_entry new_entry(RT_HERE, rel_class, offset);
instruction_operand op(new_entry, compiled, 0); 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 block's instruction operands. In most cases this is done right after this
method returns, except when compiling words with the non-optimizing method returns, except when compiling words with the non-optimizing
compiler at the beginning of bootstrap */ compiler at the beginning of bootstrap */
this->code->uninitialized_blocks this->code->uninitialized_blocks.insert(
.insert(std::make_pair(compiled, literals.value())); std::make_pair(compiled, literals.value()));
this->code->all_blocks.insert((cell) compiled); this->code->all_blocks.insert((cell)compiled);
/* next time we do a minor GC, we have to trace this code block, since /* 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 */ 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 factor_vm::undefined_symbol() {
void* frame = ctx->callstack_top; void* frame = ctx->callstack_top;
void* return_address = frame_return_address(frame); void* return_address = frame_return_address(frame);
code_block* compiled = code->code_block_for_address((cell) return_address); code_block* compiled = code->code_block_for_address((cell)return_address);
find_symbol_at_address_visitor visitor(this, (cell) return_address); find_symbol_at_address_visitor visitor(this, (cell)return_address);
compiled->each_instruction_operand(visitor); compiled->each_instruction_operand(visitor);
if (!to_boolean(visitor.symbol)) if (!to_boolean(visitor.symbol))
critical_error("Can't find RT_DLSYM at return address", critical_error("Can't find RT_DLSYM at return address",
(cell) return_address); (cell)return_address);
else else
general_error(ERROR_UNDEFINED_SYMBOL, visitor.symbol, visitor.library); general_error(ERROR_UNDEFINED_SYMBOL, visitor.symbol, visitor.library);
} }

View File

@ -75,7 +75,7 @@ struct code_block {
return (gc_info*)((uint8_t*)this + size() - sizeof(gc_info)); 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) { template <typename Iterator> void each_instruction_operand(Iterator& iter) {
if (to_boolean(relocation)) { if (to_boolean(relocation)) {

View File

@ -53,7 +53,7 @@ void code_heap::free(code_block* compiled) {
FACTOR_ASSERT(!uninitialized_p(compiled)); FACTOR_ASSERT(!uninitialized_p(compiled));
points_to_nursery.erase(compiled); points_to_nursery.erase(compiled);
points_to_aging.erase(compiled); points_to_aging.erase(compiled);
all_blocks.erase((cell) compiled); all_blocks.erase((cell)compiled);
allocator->free(compiled); allocator->free(compiled);
} }
@ -66,9 +66,9 @@ struct clear_free_blocks_from_all_blocks_iterator {
void operator()(code_block* free_block, cell size) { void operator()(code_block* free_block, cell size) {
std::set<cell>::iterator erase_from = 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 = 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); code->all_blocks.erase(erase_from, erase_to);
} }
@ -89,7 +89,7 @@ struct all_blocks_set_verifier {
: all_blocks(all_blocks) {} : all_blocks(all_blocks) {}
void operator()(code_block* block, cell size) { 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()); FACTOR_ASSERT(blocki != all_blocks.begin());
--blocki; --blocki;
code_block* found_block = (code_block*)*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 address /* XXX this isn't valid during fixup. should store the
size in the map size in the map
&& address - (cell)found_block->entry_point() < && address - (cell)found_block->entry_point() <
@ -117,7 +117,7 @@ struct all_blocks_set_inserter {
all_blocks_set_inserter(code_heap* code) : code(code) {} all_blocks_set_inserter(code_heap* code) : code(code) {}
void operator()(code_block* block, cell size) { 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 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 if it were a fixnum, and have library code shift it to the
left by 4. */ 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 & (data_alignment - 1)) == 0);
FACTOR_ASSERT((entry_point & TAG_MASK) == FIXNUM_TYPE); FACTOR_ASSERT((entry_point & TAG_MASK) == FIXNUM_TYPE);
objects.push_back(entry_point); objects.push_back(entry_point);

View File

@ -53,7 +53,7 @@ struct code_heap {
bool safepoint_p(cell addr) { bool safepoint_p(cell addr) {
cell page_mask = ~(getpagesize() - 1); cell page_mask = ~(getpagesize() - 1);
return (addr & page_mask) == (cell) safepoint_page; return (addr & page_mask) == (cell)safepoint_page;
} }
}; };

View File

@ -63,7 +63,7 @@ struct gc_workhorse : no_fixup {
code_block* fixup_code(code_block* compiled) { code_block* fixup_code(code_block* compiled) {
if (!code->marked_p(compiled)) { if (!code->marked_p(compiled)) {
code->set_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; return compiled;

View File

@ -88,7 +88,7 @@ template <typename Fixup> struct code_block_compaction_relocation_visitor {
: parent(parent), old_address(old_address), fixup(fixup) {} : parent(parent), old_address(old_address), fixup(fixup) {}
void operator()(instruction_operand op) { 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()) { switch (op.rel_type()) {
case RT_LITERAL: { case RT_LITERAL: {
@ -107,7 +107,7 @@ template <typename Fixup> struct code_block_compaction_relocation_visitor {
cell value = op.load_value(old_offset); cell value = op.load_value(old_offset);
cell offset = TAG(value); cell offset = TAG(value);
code_block* compiled = (code_block*)UNTAG(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; break;
} }
case RT_THIS: 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)); code_block* block = (code_block*)(root->value & (~data_alignment + 1));
/* Offset of return address within 16-byte allocation line */ /* 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)) { if (root->valid && state->marked_p(block)) {
block = state->forward_block(block); block = state->forward_block(block);
root->value = (cell) block + offset; root->value = (cell)block + offset;
} else } else
root->valid = false; root->valid = false;
} }

View File

@ -43,7 +43,7 @@ inline static void set_call_target(cell return_address, void* target) {
uint32_t insn = *(uint32_t*)return_address; 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)); insn = ((insn & ~b_mask) | (relative_address & b_mask));
*(uint32_t*)return_address = insn; *(uint32_t*)return_address = insn;

View File

@ -14,11 +14,11 @@ void factor_vm::dispatch_signal_handler(cell* sp, cell* pc, cell handler) {
void* frame_top = (void*)ctx->callstack_top; void* frame_top = (void*)ctx->callstack_top;
while (frame_top < ctx->callstack_bottom && 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); frame_top = frame_predecessor(frame_top);
} }
*sp = (cell) frame_top; *sp = (cell)frame_top;
ctx->callstack_top = frame_top; ctx->callstack_top = frame_top;
*pc = handler; *pc = handler;
} else { } else {
@ -53,7 +53,7 @@ void factor_vm::dispatch_signal_handler(cell* sp, cell* pc, cell handler) {
} else } else
FACTOR_ASSERT(false); FACTOR_ASSERT(false);
*pc = (cell) handler_word->entry_point; *pc = (cell)handler_word->entry_point;
} }
} }

View File

@ -34,7 +34,7 @@ inline static unsigned char call_site_opcode(cell return_address) {
inline static void check_call_site(cell return_address) { inline static void check_call_site(cell return_address) {
unsigned char opcode = call_site_opcode(return_address); unsigned char opcode = call_site_opcode(return_address);
FACTOR_ASSERT(opcode == call_opcode || opcode == jmp_opcode); 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) { 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) { inline static void set_call_target(cell return_address, void* target) {
check_call_site(return_address); 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) { inline static bool tail_call_site_p(cell return_address) {

View File

@ -3,8 +3,8 @@
namespace factor { namespace factor {
void factor_vm::init_card_decks() { void factor_vm::init_card_decks() {
cards_offset = (cell) data->cards - addr_to_card(data->start); cards_offset = (cell)data->cards - addr_to_card(data->start);
decks_offset = (cell) data->decks - addr_to_deck(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_) { data_heap::data_heap(cell young_size_, cell aging_size_, cell tenured_size_) {

View File

@ -19,8 +19,8 @@ inline generation generation_of(factor_vm* parent, object* obj) {
else if (parent->data->tenured->contains_p(obj)) else if (parent->data->tenured->contains_p(obj))
return tenured_generation; return tenured_generation;
else { else {
critical_error("Bad object", (cell) obj); critical_error("Bad object", (cell)obj);
return (generation) - 1; return (generation)-1;
} }
} }
@ -33,9 +33,9 @@ struct slot_checker {
: parent(parent), obj(obj), gen(gen) {} : parent(parent), obj(obj), gen(gen) {}
void check_write_barrier(cell* slot_ptr, generation target, char mask) { 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 = 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; char slot_card_value = *(char*)slot_card_pointer;
if ((slot_card_value & mask) != mask) { if ((slot_card_value & mask) != mask) {
std::cout << "card not marked" << std::endl; std::cout << "card not marked" << std::endl;

View File

@ -37,11 +37,11 @@ struct gc_bignum {
gc_bignum(bignum** addr, factor_vm* parent) : addr(addr), parent(parent) { gc_bignum(bignum** addr, factor_vm* parent) : addr(addr), parent(parent) {
if (*addr) if (*addr)
parent->check_data_pointer(*addr); parent->check_data_pointer(*addr);
parent->bignum_roots.push_back((cell) addr); parent->bignum_roots.push_back((cell)addr);
} }
~gc_bignum() { ~gc_bignum() {
FACTOR_ASSERT(parent->bignum_roots.back() == (cell) addr); FACTOR_ASSERT(parent->bignum_roots.back() == (cell)addr);
parent->bignum_roots.pop_back(); parent->bignum_roots.pop_back();
} }
}; };

View File

@ -4,7 +4,7 @@ namespace factor {
std::ostream& operator<<(std::ostream& out, const string* str) { std::ostream& operator<<(std::ostream& out, const string* str) {
for (cell i = 0; i < string_capacity(str); i++) for (cell i = 0; i < string_capacity(str); i++)
out << (char) str->data()[i]; out << (char)str->data()[i];
return out; return out;
} }
@ -201,13 +201,13 @@ struct stack_frame_printer {
parent->print_obj(owner->scan(parent, addr)); parent->print_obj(owner->scan(parent, addr));
std::cout << std::endl; std::cout << std::endl;
std::cout << "word/quot addr: "; 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 << std::endl;
std::cout << "word/quot xt: "; 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 << std::endl;
std::cout << "return address: "; std::cout << "return address: ";
std::cout << std::hex << (cell) addr << std::dec; std::cout << std::hex << (cell)addr << std::dec;
std::cout << std::endl; std::cout << std::endl;
} }
}; };
@ -270,7 +270,7 @@ void factor_vm::dump_generations() {
dump_generation("Tenured", data->tenured); dump_generation("Tenured", data->tenured);
std::cout << "Cards:"; 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 << "size=" << (cell)(data->cards_end - data->cards) << std::endl;
std::cout << std::dec; std::cout << std::dec;
@ -285,7 +285,7 @@ struct object_dumper {
void operator()(object* obj) { void operator()(object* obj) {
if (type == TYPE_COUNT || obj->type() == type) { 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); parent->print_nested_obj(tag_dynamic(obj), 2);
std::cout << std::endl; std::cout << std::endl;
} }
@ -309,7 +309,7 @@ struct find_data_reference_slot_visitor {
void operator()(cell* scan) { void operator()(cell* scan) {
if (look_for == *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); parent->print_nested_obj(tag_dynamic(obj), 2);
std::cout << std::endl; std::cout << std::endl;
} }
@ -374,7 +374,7 @@ struct code_block_printer {
else else
status = "allocated"; 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 << std::hex << size << std::dec << " ";
std::cout << status << " "; std::cout << status << " ";
std::cout << "stack frame " << scan->stack_frame_size(); std::cout << "stack frame " << scan->stack_frame_size();
@ -531,7 +531,7 @@ void factor_vm::factorbug() {
print_callstack(); print_callstack();
else if (strcmp(cmd, "e") == 0) { else if (strcmp(cmd, "e") == 0) {
for (cell i = 0; i < special_object_count; i++) 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) } else if (strcmp(cmd, "g") == 0)
dump_generations(); dump_generations();
else if (strcmp(cmd, "c") == 0) { else if (strcmp(cmd, "c") == 0) {

View File

@ -40,7 +40,7 @@ cell factor_vm::lookup_tuple_method(cell obj, cell methods) {
array* echelons = untag<array>(methods); array* echelons = untag<array>(methods);
fixnum echelon = std::min(untag_fixnum(layout->echelon), fixnum echelon = std::min(untag_fixnum(layout->echelon),
(fixnum) array_capacity(echelons) - 1); (fixnum)array_capacity(echelons) - 1);
while (echelon >= 0) { while (echelon >= 0) {
cell echelon_methods = array_nth(echelons, echelon); cell echelon_methods = array_nth(echelons, echelon);

View File

@ -135,23 +135,23 @@ void factor_vm::init_factor(vm_parameters* p) {
p->image_path = default_image_path(); p->image_path = default_image_path();
} }
srand((unsigned int) nano_count()); srand((unsigned int)nano_count());
init_ffi(); init_ffi();
init_contexts(p->datastack_size, p->retainstack_size, p->callstack_size); init_contexts(p->datastack_size, p->retainstack_size, p->callstack_size);
init_callbacks(p->callback_size); init_callbacks(p->callback_size);
load_image(p); load_image(p);
init_c_io(); init_c_io();
init_inline_caching((int) p->max_pic_size); init_inline_caching((int)p->max_pic_size);
special_objects[OBJ_CPU] = special_objects[OBJ_CPU] =
allot_alien(false_object, (cell) FACTOR_CPU_STRING); allot_alien(false_object, (cell)FACTOR_CPU_STRING);
special_objects[OBJ_OS] = allot_alien(false_object, (cell) FACTOR_OS_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_CELL_SIZE] = tag_fixnum(sizeof(cell));
special_objects[OBJ_EXECUTABLE] = 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_ARGS] = false_object;
special_objects[OBJ_EMBEDDED] = false_object; special_objects[OBJ_EMBEDDED] = false_object;
special_objects[OBJ_VM_COMPILER] = 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 */ /* We can GC now */
gc_off = false; gc_off = false;
@ -172,7 +172,7 @@ void factor_vm::pass_args_to_factor(int argc, vm_char** argv) {
growable_array args(this); growable_array args(this);
for (fixnum i = 1; i < argc; i++) 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(); args.trim();
special_objects[OBJ_ARGS] = args.elements.value(); special_objects[OBJ_ARGS] = args.elements.value();

View File

@ -14,7 +14,7 @@ void free_list::initial_free_list(cell start, cell end, cell occupied) {
clear_free_list(); clear_free_list();
if (occupied != end - start) { if (occupied != end - start) {
free_heap_block* last_block = (free_heap_block*)(start + occupied); 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); 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 */ /* Split it up into pieces and add each piece back to the free list */
for (cell offset = 0; offset < large_block_size; offset += size) { for (cell offset = 0; offset < large_block_size; offset += size) {
free_heap_block* small_block = large_block; 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); small_block->make_free(size);
add_to_free_list(small_block); add_to_free_list(small_block);
} }
@ -87,7 +87,7 @@ free_heap_block* free_list::split_free_block(free_heap_block* block,
cell size) { cell size) {
if (block->size() != size) { if (block->size() != size) {
/* split the block in two */ /* 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); split->make_free(block->size() - size);
block->make_free(size); block->make_free(size);
add_to_free_list(split); add_to_free_list(split);

View File

@ -46,7 +46,7 @@ void free_list_allocator<Block>::initial_free_list(cell occupied) {
template <typename Block> template <typename Block>
bool free_list_allocator<Block>::contains_p(Block* 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() { 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> template <typename Block>
Block* free_list_allocator<Block>::next_block_after(Block* 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> template <typename Block>
Block* free_list_allocator<Block>::next_allocated_block_after(Block* block) { Block* free_list_allocator<Block>::next_allocated_block_after(Block* block) {
while (block != this->last_block() && block->free_p()) { while (block != this->last_block() && block->free_p()) {
free_heap_block* free_block = (free_heap_block*)block; 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()) 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 /* Now update the free list; there will be a single free block at
the end */ 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 /* 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) { while (scan != end) {
cell size = fixup.size(scan); cell size = fixup.size(scan);
Block* next = (Block*)((cell) scan + size); Block* next = (Block*)((cell)scan + size);
if (!scan->free_p()) if (!scan->free_p())
iter(scan, size); iter(scan, size);
scan = next; scan = next;

View File

@ -13,7 +13,7 @@ struct full_policy {
void promoted_object(object* obj) { void promoted_object(object* obj) {
tenured->set_marked_p(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) { void visited_object(object* obj) {

View File

@ -205,7 +205,7 @@ struct call_frame_scrubber {
FACTOR_ASSERT(return_address < owner->size()); FACTOR_ASSERT(return_address < owner->size());
cell index = info->return_address_index(return_address); cell index = info->return_address_index(return_address);
if (index != (cell) - 1) if (index != (cell)-1)
ctx->scrub_stacks(info, index); ctx->scrub_stacks(info, index);
} }
}; };

View File

@ -10,7 +10,7 @@ cell gc_info::return_address_index(cell return_address) {
return i; return i;
} }
return (cell) - 1; return (cell)-1;
} }
} }

View File

@ -20,7 +20,7 @@ void factor_vm::load_data_heap(FILE* file, image_header* h, vm_parameters* p) {
fixnum bytes_read = fixnum bytes_read =
safe_fread((void*)data->tenured->start, 1, h->data_size, file); 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 << "truncated image: " << bytes_read << " bytes read, ";
std::cout << h->data_size << " bytes expected\n"; std::cout << h->data_size << " bytes expected\n";
fatal_error("load_data_heap failed", 0); fatal_error("load_data_heap failed", 0);
@ -59,11 +59,11 @@ struct startup_fixup {
: data_offset(data_offset), code_offset(code_offset) {} : data_offset(data_offset), code_offset(code_offset) {}
object* fixup_data(object* obj) { object* fixup_data(object* obj) {
return (object*)((cell) obj + data_offset); return (object*)((cell)obj + data_offset);
} }
code_block* fixup_code(code_block* obj) { 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); } 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) { void operator()(instruction_operand op) {
code_block* compiled = op.compiled; code_block* compiled = op.compiled;
cell old_offset = 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()) { switch (op.rel_type()) {
case RT_LITERAL: { case RT_LITERAL: {
@ -159,7 +159,7 @@ struct startup_code_block_relocation_visitor {
cell value = op.load_value(old_offset); cell value = op.load_value(old_offset);
cell offset = TAG(value); cell offset = TAG(value);
code_block* compiled = (code_block*)UNTAG(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; break;
} }
case RT_UNTAGGED: 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, bool factor_vm::read_embedded_image_footer(FILE* file,
embedded_image_footer* footer) { embedded_image_footer* footer) {
safe_fseek(file, -(off_t) sizeof(embedded_image_footer), SEEK_END); safe_fseek(file, -(off_t)sizeof(embedded_image_footer), SEEK_END);
safe_fread(footer, (off_t) sizeof(embedded_image_footer), 1, file); safe_fread(footer, (off_t)sizeof(embedded_image_footer), 1, file);
return footer->magic == image_magic; return footer->magic == image_magic;
} }
@ -213,7 +213,7 @@ FILE* factor_vm::open_image(vm_parameters* p) {
std::cout << "No embedded image" << std::endl; std::cout << "No embedded image" << std::endl;
exit(1); exit(1);
} }
safe_fseek(file, (off_t) footer.image_offset, SEEK_SET); safe_fseek(file, (off_t)footer.image_offset, SEEK_SET);
return file; return file;
} else } else
return OPEN_READ(p->image_path); return OPEN_READ(p->image_path);
@ -253,7 +253,7 @@ void factor_vm::load_image(vm_parameters* p) {
fixup_code(data_offset, code_offset); fixup_code(data_offset, code_offset);
/* Store image path name */ /* 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 */ /* Save the current image to disk */

View File

@ -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) { void factor_vm::deallocate_inline_cache(cell return_address) {
/* Find the call target. */ /* Find the call target. */
void* old_entry_point = get_call_target(return_address); 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; 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 #ifdef PIC_DEBUG
std::cout << "Updated " << (tail_call_site ? "tail" : "non-tail") std::cout << "Updated " << (tail_call_site ? "tail" : "non-tail")
<< " call site 0x" << std::hex << return_address.value << std::dec << " 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(); print_callstack();
#endif #endif
} }

View File

@ -7,7 +7,7 @@ instruction_operand::instruction_operand(relocation_entry rel,
: rel(rel), : rel(rel),
compiled(compiled), compiled(compiled),
index(index), 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 */ /* Load a 32-bit value from a PowerPC LIS/ORI sequence */
fixnum instruction_operand::load_value_2_2() { 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 lhi = (ptr[-2] & 0xffff);
uint64_t llo = (ptr[-1] & 0xffff); uint64_t llo = (ptr[-1] & 0xffff);
uint64_t val = hhi << 48 | hlo << 32 | lhi << 16 | llo; 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 */ /* 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) { cell shift) {
int32_t* ptr = (int32_t*)(pointer - sizeof(uint32_t)); 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) { 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; *(cell*)(pointer - sizeof(cell)) = absolute_value;
break; break;
case RC_ABSOLUTE: case RC_ABSOLUTE:
*(uint32_t*)(pointer - sizeof(uint32_t)) = (uint32_t) absolute_value; *(uint32_t*)(pointer - sizeof(uint32_t)) = (uint32_t)absolute_value;
break; break;
case RC_RELATIVE: case RC_RELATIVE:
*(int32_t*)(pointer - sizeof(int32_t)) = (int32_t) relative_value; *(int32_t*)(pointer - sizeof(int32_t)) = (int32_t)relative_value;
break; break;
case RC_ABSOLUTE_PPC_2_2: case RC_ABSOLUTE_PPC_2_2:
store_value_2_2(absolute_value); store_value_2_2(absolute_value);
@ -144,10 +144,10 @@ void instruction_operand::store_value(fixnum absolute_value) {
0); 0);
break; break;
case RC_ABSOLUTE_2: 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; break;
case RC_ABSOLUTE_1: 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; break;
case RC_ABSOLUTE_PPC_2_2_2_2: case RC_ABSOLUTE_PPC_2_2_2_2:
store_value_2_2_2_2(absolute_value); 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) { void instruction_operand::store_code_block(code_block* compiled) {
store_value((cell) compiled->entry_point()); store_value((cell)compiled->entry_point());
} }
} }

View File

@ -14,9 +14,9 @@ with many more capabilities so these words are not usually used in
normal operation. */ normal operation. */
void factor_vm::init_c_io() { void factor_vm::init_c_io() {
special_objects[OBJ_STDIN] = allot_alien(false_object, (cell) stdin); special_objects[OBJ_STDIN] = allot_alien(false_object, (cell)stdin);
special_objects[OBJ_STDOUT] = allot_alien(false_object, (cell) stdout); special_objects[OBJ_STDOUT] = allot_alien(false_object, (cell)stdout);
special_objects[OBJ_STDERR] = allot_alien(false_object, (cell) stderr); special_objects[OBJ_STDERR] = allot_alien(false_object, (cell)stderr);
} }
void factor_vm::io_error() { void factor_vm::io_error() {
@ -196,7 +196,7 @@ void factor_vm::primitive_fread() {
void factor_vm::primitive_fputc() { void factor_vm::primitive_fputc() {
FILE* file = pop_file_handle(); FILE* file = pop_file_handle();
fixnum ch = to_fixnum(ctx->pop()); fixnum ch = to_fixnum(ctx->pop());
safe_fputc((int) ch, file); safe_fputc((int)ch, file);
} }
void factor_vm::primitive_fwrite() { void factor_vm::primitive_fwrite() {
@ -219,8 +219,8 @@ void factor_vm::primitive_ftell() {
void factor_vm::primitive_fseek() { void factor_vm::primitive_fseek() {
FILE* file = pop_file_handle(); FILE* file = pop_file_handle();
int whence = (int) to_fixnum(ctx->pop()); int whence = (int)to_fixnum(ctx->pop());
off_t offset = (off_t) to_signed_8(ctx->pop()); off_t offset = (off_t)to_signed_8(ctx->pop());
safe_fseek(file, offset, whence); safe_fseek(file, offset, whence);
} }

View File

@ -21,13 +21,13 @@ jit::jit(code_block_type type, cell owner, factor_vm* vm)
parent(vm) { parent(vm) {
fixnum old_count = atomic::fetch_add(&parent->current_jit_count, 1); fixnum old_count = atomic::fetch_add(&parent->current_jit_count, 1);
FACTOR_ASSERT(old_count >= 0); FACTOR_ASSERT(old_count >= 0);
(void) old_count; (void)old_count;
} }
jit::~jit() { jit::~jit() {
fixnum old_count = atomic::fetch_subtract(&parent->current_jit_count, 1); fixnum old_count = atomic::fetch_subtract(&parent->current_jit_count, 1);
FACTOR_ASSERT(old_count >= 1); FACTOR_ASSERT(old_count >= 1);
(void) old_count; (void)old_count;
} }
void jit::emit_relocation(cell relocation_template_) { void jit::emit_relocation(cell relocation_template_) {

View File

@ -96,7 +96,7 @@ inline static bool immediate_p(cell obj) {
inline static fixnum untag_fixnum(cell tagged) { inline static fixnum untag_fixnum(cell tagged) {
FACTOR_ASSERT(TAG(tagged) == FIXNUM_TYPE); FACTOR_ASSERT(TAG(tagged) == FIXNUM_TYPE);
return ((fixnum) tagged) >> TAG_BITS; return ((fixnum)tagged) >> TAG_BITS;
} }
inline static cell tag_fixnum(fixnum untagged) { inline static cell tag_fixnum(fixnum untagged) {
@ -137,7 +137,7 @@ struct object {
object* forwarding_pointer() const { return (object*)UNTAG(header); } 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 */ /* Assembly code makes assumptions about the layout of this struct */

View File

@ -37,13 +37,13 @@ void factor_vm::call_fault_handler(exception_type_t exception,
if (exception == EXC_BAD_ACCESS) { if (exception == EXC_BAD_ACCESS) {
signal_fault_addr = MACH_EXC_STATE_FAULT(exc_state); 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); 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) { } else if (exception == EXC_ARITHMETIC && code != MACH_EXC_INTEGER_DIV) {
signal_fpu_status = fpu_status(mach_fpu_status(float_state)); signal_fpu_status = fpu_status(mach_fpu_status(float_state));
mach_clear_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 { } else {
switch (exception) { switch (exception) {
case EXC_ARITHMETIC: case EXC_ARITHMETIC:
@ -57,14 +57,14 @@ void factor_vm::call_fault_handler(exception_type_t exception,
break; break;
} }
handler = (cell) factor::synchronous_signal_handler_impl; handler = (cell)factor::synchronous_signal_handler_impl;
} }
FACTOR_ASSERT(handler != 0); FACTOR_ASSERT(handler != 0);
dispatch_signal_handler((cell*)&MACH_STACK_POINTER(thread_state), dispatch_signal_handler((cell*)&MACH_STACK_POINTER(thread_state),
(cell*)&MACH_PROGRAM_COUNTER(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, static void call_fault_handler(mach_port_t thread, exception_type_t exception,

View File

@ -32,7 +32,7 @@ template <typename Block> struct mark_bits {
} }
cell block_line(const Block* address) { cell block_line(const Block* address) {
return (((cell) address - start) / data_alignment); return (((cell)address - start) / data_alignment);
} }
Block* line_block(cell line) { Block* line_block(cell line) {
@ -48,19 +48,19 @@ template <typename Block> struct mark_bits {
bool bitmap_elt(cell* bits, const Block* address) { bool bitmap_elt(cell* bits, const Block* address) {
std::pair<cell, cell> position = bitmap_deref(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) { 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) { void set_bitmap_range(cell* bits, const Block* address) {
std::pair<cell, cell> start = bitmap_deref(address); std::pair<cell, cell> start = bitmap_deref(address);
std::pair<cell, cell> end = bitmap_deref(next_block_after(address)); std::pair<cell, cell> end = bitmap_deref(next_block_after(address));
cell start_mask = ((cell) 1 << start.second) - 1; cell start_mask = ((cell)1 << start.second) - 1;
cell end_mask = ((cell) 1 << end.second) - 1; cell end_mask = ((cell)1 << end.second) - 1;
if (start.first == end.first) if (start.first == end.first)
bits[start.first] |= start_mask ^ end_mask; bits[start.first] |= start_mask ^ end_mask;
@ -69,7 +69,7 @@ template <typename Block> struct mark_bits {
bits[start.first] |= ~start_mask; bits[start.first] |= ~start_mask;
for (cell index = start.first + 1; index < end.first; index++) for (cell index = start.first + 1; index < end.first; index++)
bits[index] = (cell) - 1; bits[index] = (cell)-1;
if (end_mask != 0) { if (end_mask != 0) {
FACTOR_ASSERT(end.first < bits_size); FACTOR_ASSERT(end.first < bits_size);
@ -97,10 +97,10 @@ template <typename Block> struct mark_bits {
Block* forward_block(const Block* original) { Block* forward_block(const Block* original) {
FACTOR_ASSERT(marked_p(original)); FACTOR_ASSERT(marked_p(original));
std::pair<cell, cell> position = bitmap_deref(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 approx_popcount = forwarding[position.first];
cell mask = ((cell) 1 << position.second) - 1; cell mask = ((cell)1 << position.second) - 1;
cell new_line_number = cell new_line_number =
approx_popcount + popcount(marked[position.first] & mask); approx_popcount + popcount(marked[position.first] & mask);
@ -114,7 +114,7 @@ template <typename Block> struct mark_bits {
cell bit_index = position.second; cell bit_index = position.second;
for (cell index = position.first; index < bits_size; index++) { 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) { if (~mask) {
/* Found an unmarked block on this page. Stop, it's hammer time */ /* Found an unmarked block on this page. Stop, it's hammer time */
cell clear_bit = rightmost_clear_bit(mask); cell clear_bit = rightmost_clear_bit(mask);

View File

@ -65,7 +65,7 @@ void factor_vm::primitive_fixnum_shift() {
ctx->replace(tag_fixnum(x >> -y)); ctx->replace(tag_fixnum(x >> -y));
return; return;
} else if (y < WORD_SIZE - TAG_BITS) { } 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)) { if (!(branchless_abs(x) & mask)) {
ctx->replace(tag_fixnum(x << y)); ctx->replace(tag_fixnum(x << y));
return; return;
@ -179,7 +179,7 @@ void factor_vm::primitive_bignum_not() {
} }
void factor_vm::primitive_bignum_bitp() { 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()); bignum* x = untag<bignum>(ctx->peek());
ctx->replace(tag_boolean(bignum_logbitp(bit, x))); ctx->replace(tag_boolean(bignum_logbitp(bit, x)));
} }
@ -276,12 +276,12 @@ void factor_vm::primitive_float_greatereq() {
/* Allocates memory */ /* Allocates memory */
void factor_vm::primitive_float_bits() { void factor_vm::primitive_float_bits() {
ctx->push( 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 */ /* Allocates memory */
void factor_vm::primitive_bits_float() { 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() { 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); 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) { VM_C_API cell to_cell(cell tagged, factor_vm* parent) {
return parent->to_cell(tagged); 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) if (n < fixnum_min || n > fixnum_max)
return tag<bignum>(long_long_to_bignum(n)); return tag<bignum>(long_long_to_bignum(n));
else else
return tag_fixnum((fixnum) n); return tag_fixnum((fixnum)n);
} }
VM_C_API cell from_signed_8(int64_t n, factor_vm* parent) { 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 */ /* Allocates memory */
cell factor_vm::from_unsigned_8(uint64_t n) { 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)); return tag<bignum>(ulong_long_to_bignum(n));
else else
return tag_fixnum((fixnum) n); return tag_fixnum((fixnum)n);
} }
VM_C_API cell from_unsigned_8(uint64_t n, factor_vm* parent) { 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 */ /* Cannot allocate */
float factor_vm::to_float(cell value) { float factor_vm::to_float(cell value) {
return (float) untag_float_check(value); return (float)untag_float_check(value);
} }
/* Cannot allocate */ /* Cannot allocate */

View File

@ -1,9 +1,9 @@
namespace factor { namespace factor {
static const fixnum fixnum_max = static const fixnum fixnum_max =
(((fixnum) 1 << (WORD_SIZE - TAG_BITS - 1)) - 1); (((fixnum)1 << (WORD_SIZE - TAG_BITS - 1)) - 1);
static const fixnum fixnum_min = (-((fixnum) 1 << (WORD_SIZE - TAG_BITS - 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)); static const fixnum array_size_max = ((cell)1 << (WORD_SIZE - TAG_BITS - 2));
/* Allocates memory */ /* Allocates memory */
inline cell factor_vm::from_signed_cell(fixnum x) { inline cell factor_vm::from_signed_cell(fixnum x) {
@ -15,7 +15,7 @@ inline cell factor_vm::from_signed_cell(fixnum x) {
/* Allocates memory */ /* Allocates memory */
inline cell factor_vm::from_unsigned_cell(cell x) { 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)); return tag<bignum>(cell_to_bignum(x));
else else
return tag_fixnum(x); 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) { 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) { 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() { inline cell factor_vm::unbox_array_size() {
cell obj = ctx->peek(); cell obj = ctx->peek();
if (TAG(obj) == FIXNUM_TYPE) { if (TAG(obj) == FIXNUM_TYPE) {
fixnum n = untag_fixnum(obj); fixnum n = untag_fixnum(obj);
if (n >= 0 && n < (fixnum) array_size_max) { if (n >= 0 && n < (fixnum)array_size_max) {
ctx->pop(); ctx->pop();
return n; return n;
} }

View File

@ -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 */ /* we need to remember the first object allocated in the card */
void object_start_map::record_object_start_offset(object* obj) { void object_start_map::record_object_start_offset(object* obj) {
cell idx = addr_to_card((cell) obj - start); cell idx = addr_to_card((cell)obj - start);
card obj_start = ((cell) obj & addr_card_mask); card obj_start = ((cell)obj & addr_card_mask);
object_start_offsets[idx] = std::min(object_start_offsets[idx], obj_start); object_start_offsets[idx] = std::min(object_start_offsets[idx], obj_start);
} }

View File

@ -23,7 +23,7 @@ void factor_vm::compute_identity_hashcode(object* obj) {
object_counter++; object_counter++;
if (object_counter == 0) if (object_counter == 0)
object_counter++; object_counter++;
obj->set_hashcode((cell) obj ^ object_counter); obj->set_hashcode((cell)obj ^ object_counter);
} }
void factor_vm::primitive_compute_identity_hashcode() { void factor_vm::primitive_compute_identity_hashcode() {

View File

@ -118,7 +118,7 @@ inline static bool save_special_p(cell i) {
} }
template <typename Iterator> void object::each_slot(Iterator& iter) { template <typename Iterator> void object::each_slot(Iterator& iter) {
cell scan = (cell) this; cell scan = (cell)this;
cell payload_start = binary_payload_start(); cell payload_start = binary_payload_start();
cell end = scan + payload_start; cell end = scan + payload_start;

View File

@ -32,7 +32,7 @@ uint64_t nano_count() {
int ret = clock_gettime(CLOCK_MONOTONIC, &t); int ret = clock_gettime(CLOCK_MONOTONIC, &t);
if (ret != 0) if (ret != 0)
fatal_error("clock_gettime failed", 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;
} }
} }

View File

@ -11,10 +11,10 @@ void flush_icache(cell start, cell len);
#define UAP_PROGRAM_COUNTER(ucontext) \ #define UAP_PROGRAM_COUNTER(ucontext) \
(((ucontext_t*)ucontext)->uc_mcontext.arm_pc) (((ucontext_t*)ucontext)->uc_mcontext.arm_pc)
#define UAP_STACK_POINTER_TYPE greg_t #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(code) (void)0
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0 #define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
#define FUNCTION_CODE_POINTER(ptr) ptr #define FUNCTION_CODE_POINTER(ptr) ptr
#define FUNCTION_TOC_POINTER(ptr) ptr #define FUNCTION_TOC_POINTER(ptr) ptr
} }

View File

@ -8,10 +8,10 @@ namespace factor {
((ucontext_t*)ucontext)->uc_mcontext.uc_regs->gregs[1] ((ucontext_t*)ucontext)->uc_mcontext.uc_regs->gregs[1]
#define UAP_PROGRAM_COUNTER(ucontext) \ #define UAP_PROGRAM_COUNTER(ucontext) \
(((ucontext_t*)ucontext)->uc_mcontext.uc_regs->gregs[32]) (((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(code) (void)0
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0 #define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
#define FUNCTION_CODE_POINTER(ptr) ptr #define FUNCTION_CODE_POINTER(ptr) ptr
#define FUNCTION_TOC_POINTER(ptr) ptr #define FUNCTION_TOC_POINTER(ptr) ptr

View File

@ -8,7 +8,7 @@ namespace factor {
((ucontext_t*)ucontext)->uc_mcontext.gp_regs[1] ((ucontext_t*)ucontext)->uc_mcontext.gp_regs[1]
#define UAP_PROGRAM_COUNTER(ucontext) \ #define UAP_PROGRAM_COUNTER(ucontext) \
(((ucontext_t*)ucontext)->uc_mcontext.gp_regs[32]) (((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 #define FACTOR_PPC_TOC 1

View File

@ -50,10 +50,10 @@ inline static void uap_clear_fpu_status(void* uap) {
(((ucontext_t*)ucontext)->uc_mcontext.gregs[7]) (((ucontext_t*)ucontext)->uc_mcontext.gregs[7])
#define UAP_PROGRAM_COUNTER(ucontext) \ #define UAP_PROGRAM_COUNTER(ucontext) \
(((ucontext_t*)ucontext)->uc_mcontext.gregs[14]) (((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(code) (void)0
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0 #define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
#define FUNCTION_CODE_POINTER(ptr) ptr #define FUNCTION_CODE_POINTER(ptr) ptr
#define FUNCTION_TOC_POINTER(ptr) ptr #define FUNCTION_TOC_POINTER(ptr) ptr

View File

@ -18,10 +18,10 @@ inline static void uap_clear_fpu_status(void* uap) {
(((ucontext_t*)ucontext)->uc_mcontext.gregs[15]) (((ucontext_t*)ucontext)->uc_mcontext.gregs[15])
#define UAP_PROGRAM_COUNTER(ucontext) \ #define UAP_PROGRAM_COUNTER(ucontext) \
(((ucontext_t*)ucontext)->uc_mcontext.gregs[16]) (((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(code) (void)0
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0 #define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
#define FUNCTION_CODE_POINTER(ptr) ptr #define FUNCTION_CODE_POINTER(ptr) ptr
#define FUNCTION_TOC_POINTER(ptr) ptr #define FUNCTION_TOC_POINTER(ptr) ptr

View File

@ -9,12 +9,12 @@ const char* vm_executable_path();
const char* default_image_path(); const char* default_image_path();
#define UAP_STACK_POINTER(ucontext) (((ucontext_t*)ucontext)->uc_stack.ss_sp) #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(code) (void)0
#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0 #define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
#define FUNCTION_CODE_POINTER(ptr) ptr #define FUNCTION_CODE_POINTER(ptr) ptr
#define FUNCTION_TOC_POINTER(ptr) ptr #define FUNCTION_TOC_POINTER(ptr) ptr

View File

@ -92,10 +92,10 @@ segment::segment(cell size_, bool executable_p) {
out_of_memory(); out_of_memory();
if (mprotect(array, pagesize, PROT_NONE) == -1) 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) 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); start = (cell)(array + pagesize);
end = start + size; end = start + size;
@ -110,19 +110,19 @@ segment::~segment() {
void code_heap::guard_safepoint() { void code_heap::guard_safepoint() {
if (mprotect(safepoint_page, getpagesize(), PROT_NONE) == -1) 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() { void code_heap::unguard_safepoint() {
if (mprotect(safepoint_page, getpagesize(), PROT_WRITE) == -1) 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)()) { void factor_vm::dispatch_signal(void* uap, void(handler)()) {
dispatch_signal_handler((cell*)&UAP_STACK_POINTER(uap), dispatch_signal_handler((cell*)&UAP_STACK_POINTER(uap),
(cell*)&UAP_PROGRAM_COUNTER(uap), (cell*)&UAP_PROGRAM_COUNTER(uap),
(cell) FUNCTION_CODE_POINTER(handler)); (cell)FUNCTION_CODE_POINTER(handler));
UAP_SET_TOC_POINTER(uap, (cell) FUNCTION_TOC_POINTER(handler)); UAP_SET_TOC_POINTER(uap, (cell)FUNCTION_TOC_POINTER(handler));
} }
void factor_vm::start_sampling_profiler_timer() { 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) { void memory_signal_handler(int signal, siginfo_t* siginfo, void* uap) {
factor_vm* vm = current_vm(); factor_vm* vm = current_vm();
vm->verify_memory_protection_error((cell) siginfo->si_addr); vm->verify_memory_protection_error((cell)siginfo->si_addr);
vm->signal_fault_addr = (cell) siginfo->si_addr; vm->signal_fault_addr = (cell)siginfo->si_addr;
vm->signal_fault_pc = (cell) UAP_PROGRAM_COUNTER(uap); vm->signal_fault_pc = (cell)UAP_PROGRAM_COUNTER(uap);
vm->dispatch_signal(uap, factor::memory_signal_handler_impl); 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; vm = thread_vms.begin()->second;
} }
if (atomic::load(&vm->sampling_profiler_p)) 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); foreign_thread);
else if (!foreign_thread) else if (!foreign_thread)
enqueue_signal(vm, signal); enqueue_signal(vm, signal);

View File

@ -54,7 +54,7 @@ void factor_vm::c_to_factor_toplevel(cell quot) {
seh_area->handler[12] = 0xe0; seh_area->handler[12] = 0xe0;
/* Store address of exception handler in the operand of the 'mov' */ /* 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)); memcpy(&seh_area->handler[2], &handler, sizeof(cell));
UNWIND_INFO* unwind_info = &seh_area->unwind_info; 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->CountOfCodes = 0;
unwind_info->FrameRegister = 0; unwind_info->FrameRegister = 0;
unwind_info->FrameOffset = 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; unwind_info->ExceptionData[0] = 0;
RUNTIME_FUNCTION* func = &seh_area->func; RUNTIME_FUNCTION* func = &seh_area->func;
func->BeginAddress = 0; func->BeginAddress = 0;
func->EndAddress = (DWORD)(code->seg->end - base); 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)) if (!RtlAddFunctionTable(func, 1, base))
fatal_error("RtlAddFunctionTable() failed", 0); fatal_error("RtlAddFunctionTable() failed", 0);

View File

@ -104,13 +104,13 @@ segment::segment(cell size_, bool executable_p) {
out_of_memory(); out_of_memory();
if (!VirtualProtect(mem, getpagesize(), PAGE_NOACCESS, &ignore)) 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, if (!VirtualProtect(mem + size + getpagesize(), getpagesize(), PAGE_NOACCESS,
&ignore)) &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; end = start + size;
} }
@ -134,13 +134,13 @@ long getpagesize() {
void code_heap::guard_safepoint() { void code_heap::guard_safepoint() {
DWORD ignore; DWORD ignore;
if (!VirtualProtect(safepoint_page, getpagesize(), PAGE_NOACCESS, &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() { void code_heap::unguard_safepoint() {
DWORD ignore; DWORD ignore;
if (!VirtualProtect(safepoint_page, getpagesize(), PAGE_READWRITE, &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) { void factor_vm::move_file(const vm_char* path1, const vm_char* path2) {
@ -184,7 +184,7 @@ uint64_t nano_count() {
#endif #endif
lo = count.LowPart; 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)); } 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]; signal_fault_addr = e->ExceptionInformation[1];
verify_memory_protection_error(signal_fault_addr); verify_memory_protection_error(signal_fault_addr);
dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP, dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP,
(cell) factor::memory_signal_handler_impl); (cell)factor::memory_signal_handler_impl);
break; break;
case STATUS_FLOAT_DENORMAL_OPERAND: case STATUS_FLOAT_DENORMAL_OPERAND:
@ -225,12 +225,12 @@ LONG factor_vm::exception_handler(PEXCEPTION_RECORD e, void* frame, PCONTEXT c,
#endif #endif
MXCSR(c) &= 0xffffffc0; MXCSR(c) &= 0xffffffc0;
dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP, dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP,
(cell) factor::fp_signal_handler_impl); (cell)factor::fp_signal_handler_impl);
break; break;
default: default:
signal_number = e->ExceptionCode; signal_number = e->ExceptionCode;
dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP, dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP,
(cell) factor::synchronous_signal_handler_impl); (cell)factor::synchronous_signal_handler_impl);
break; break;
} }

View File

@ -86,8 +86,8 @@ inline static THREADHANDLE thread_id() {
inline static void breakpoint() { DebugBreak(); } inline static void breakpoint() { DebugBreak(); }
#define CODE_TO_FUNCTION_POINTER(code) (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_CALLBACK(vm, code) (void)0
#define FUNCTION_CODE_POINTER(ptr) ptr #define FUNCTION_CODE_POINTER(ptr) ptr
#define FUNCTION_TOC_POINTER(ptr) ptr #define FUNCTION_TOC_POINTER(ptr) ptr
} }

View File

@ -350,8 +350,8 @@ void factor_vm::primitive_array_to_quotation() {
void factor_vm::primitive_quotation_code() { void factor_vm::primitive_quotation_code() {
data_root<quotation> quot(ctx->pop(), this); data_root<quotation> quot(ctx->pop(), this);
ctx->push(from_unsigned_cell((cell) quot->entry_point)); 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->code() + quot->code()->size()));
} }
/* Allocates memory */ /* Allocates memory */

View File

@ -2,7 +2,7 @@
namespace factor { 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) { void exit(int status) {
factor_vm::close_console(); factor_vm::close_console();

View File

@ -44,7 +44,7 @@ void safepoint_state::handle_safepoint(factor_vm* parent, cell pc) volatile {
} else if (atomic::load(&parent->sampling_profiler_p)) { } else if (atomic::load(&parent->sampling_profiler_p)) {
FACTOR_ASSERT(parent->code->seg->in_segment_p(pc)); FACTOR_ASSERT(parent->code->seg->in_segment_p(pc));
code_block* block = parent->code->code_block_for_address(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); parent->record_sample(prolog_p);
} }

View File

@ -36,7 +36,7 @@ template <typename Fixup> cell object::size(Fixup fixup) const {
callstack_object_size(untag_fixnum(((callstack*)this)->length)), callstack_object_size(untag_fixnum(((callstack*)this)->length)),
data_alignment); data_alignment);
default: default:
critical_error("Invalid header in size", (cell) this); critical_error("Invalid header in size", (cell)this);
return 0; /* can't happen */ return 0; /* can't happen */
} }
} }
@ -79,7 +79,7 @@ template <typename Fixup> cell object::binary_payload_start(Fixup fixup) const {
case WRAPPER_TYPE: case WRAPPER_TYPE:
return sizeof(wrapper); return sizeof(wrapper);
default: 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 */ return 0; /* can't happen */
} }
} }
@ -154,7 +154,7 @@ void slot_visitor<Fixup>::visit_object_array(cell* start, cell* end) {
template <typename Fixup> template <typename Fixup>
void slot_visitor<Fixup>::visit_slots(object* ptr, cell payload_start) { void slot_visitor<Fixup>::visit_slots(object* ptr, cell payload_start) {
cell* slot = (cell*)ptr; cell* slot = (cell*)ptr;
cell* end = (cell*)((cell) ptr + payload_start); cell* end = (cell*)((cell)ptr + payload_start);
if (slot != end) { if (slot != end) {
slot++; slot++;
@ -191,7 +191,7 @@ template <typename Fixup> void slot_visitor<Fixup>::visit_bignum_roots() {
cell* handle = (cell*)(*iter); cell* handle = (cell*)(*iter);
if (*handle) 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()); FACTOR_ASSERT(return_address < compiled->size());
cell callsite = info->return_address_index(return_address); cell callsite = info->return_address_index(return_address);
if (callsite == (cell) - 1) if (callsite == (cell)-1)
return; return;
#ifdef DEBUG_GC_MAPS #ifdef DEBUG_GC_MAPS

View File

@ -16,13 +16,13 @@ struct tenured_space : free_list_allocator<object> {
} }
cell first_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 next_object_after(cell scan) {
cell size = ((object*)scan)->size(); cell size = ((object*)scan)->size();
object* next = (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(); } void clear_mark_bits() { state.clear_mark_bits(); }

View File

@ -12,7 +12,7 @@ struct to_tenured_policy {
} }
void promoted_object(object* obj) { void promoted_object(object* obj) {
parent->mark_stack.push_back((cell) obj); parent->mark_stack.push_back((cell)obj);
} }
void visited_object(object* obj) {} void visited_object(object* obj) {}

View File

@ -9,7 +9,7 @@ inline static void memset_2(void* dst, uint16_t pattern, size_t size) {
memset(dst, 0, size); memset(dst, 0, size);
else { else {
uint16_t* start = (uint16_t*)dst; 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) { while (start < end) {
*start = pattern; *start = pattern;
start++; start++;
@ -30,7 +30,7 @@ inline static void memset_cell(void* dst, cell pattern, size_t size) {
memset(dst, 0, size); memset(dst, 0, size);
else { else {
cell* start = (cell*)dst; cell* start = (cell*)dst;
cell* end = (cell*)((cell) dst + size); cell* end = (cell*)((cell)dst + size);
while (start < end) { while (start < end) {
*start = pattern; *start = pattern;
start++; start++;

View File

@ -337,13 +337,13 @@ struct factor_vm {
/* the write barrier must be called any time we are potentially storing a /* the write barrier must be called any time we are potentially storing a
pointer from an older generation to a younger one */ pointer from an older generation to a younger one */
inline void write_barrier(cell* slot_ptr) { inline void write_barrier(cell* slot_ptr) {
*(char*)(cards_offset + ((cell) slot_ptr >> card_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; *(char*)(decks_offset + ((cell)slot_ptr >> deck_bits)) = card_mark_mask;
} }
inline void write_barrier(object* obj, cell size) { inline void write_barrier(object* obj, cell size) {
cell start = (cell) obj & (~card_size + 1); cell start = (cell)obj & (~card_size + 1);
cell end = ((cell) obj + size + card_size - 1) & (~card_size + 1); cell end = ((cell)obj + size + card_size - 1) & (~card_size + 1);
for (cell offset = start; offset < end; offset += card_size) for (cell offset = start; offset < end; offset += card_size)
write_barrier((cell*)offset); write_barrier((cell*)offset);
@ -387,7 +387,7 @@ struct factor_vm {
inline void check_data_pointer(object* pointer) { inline void check_data_pointer(object* pointer) {
FACTOR_ASSERT((current_gc && current_gc->op == collect_growing_heap_op) || 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 // generic arrays

View File

@ -77,8 +77,8 @@ void factor_vm::primitive_word_code() {
data_root<word> w(ctx->pop(), this); data_root<word> w(ctx->pop(), this);
w.untag_check(this); w.untag_check(this);
ctx->push(from_unsigned_cell((cell) w->entry_point)); 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->code() + w->code()->size()));
} }
void factor_vm::primitive_optimized_p() { void factor_vm::primitive_optimized_p() {