/* Allocates memory */
cell factor_vm::allot_alien(void* address) {
- return allot_alien(false_object, (cell) address);
+ return allot_alien(false_object, (cell)address);
}
/* make an alien pointing at an offset of another alien */
if the object is a byte array, as a sanity check. */
/* Allocates memory (from_unsigned_cell can allocate) */
void factor_vm::primitive_alien_address() {
- ctx->replace(from_unsigned_cell((cell) pinned_alien_offset(ctx->peek())));
+ ctx->replace(from_unsigned_cell((cell)pinned_alien_offset(ctx->peek())));
}
/* pop ( alien n ) from datastack, return alien's address plus n */
} \
VM_C_API void primitive_set_alien_##name(factor_vm * parent) { \
type* ptr = (type*)parent->alien_pointer(); \
- type value = (type) parent->to(parent->ctx->pop()); \
+ type value = (type)parent->to(parent->ctx->pop()); \
*ptr = value; \
}
#ifdef FACTOR_DEBUG
#define FACTOR_ASSERT(condition) \
((condition) \
- ? (void) 0 \
+ ? (void)0 \
: (::fprintf(stderr, "assertion \"%s\" failed: file \"%s\", line %d\n", \
#condition, __FILE__, __LINE__), \
::factor::abort()))
#else
-#define FACTOR_ASSERT(condition) ((void) 0)
+#define FACTOR_ASSERT(condition) ((void)0)
#endif
}
__forceinline static cell fetch_add(volatile cell* ptr, cell val) {
- return (cell)
- InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr), (LONG) val);
+ return (cell)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
+ (LONG) val);
}
__forceinline static fixnum fetch_add(volatile fixnum* ptr, fixnum val) {
- return (fixnum)
- InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr), (LONG) val);
+ return (fixnum)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
+ (LONG) val);
}
__forceinline static cell fetch_subtract(volatile cell* ptr, cell val) {
- return (cell) InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
- -(LONG) val);
+ return (cell)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
+ -(LONG)val);
}
__forceinline static fixnum fetch_subtract(volatile fixnum* ptr, fixnum val) {
- return (fixnum) InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
- -(LONG) val);
+ return (fixnum)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
+ -(LONG)val);
}
__forceinline static void fence() { MemoryBarrier(); }
namespace atomic {
__forceinline static bool cas(volatile cell* ptr, cell old_val, cell new_val) {
return InterlockedCompareExchange64(reinterpret_cast<volatile LONG64*>(ptr),
- (LONG64) old_val, (LONG64) new_val) ==
- (LONG64) old_val;
+ (LONG64)old_val, (LONG64)new_val) ==
+ (LONG64)old_val;
}
__forceinline static bool cas(volatile fixnum* ptr, fixnum old_val,
fixnum new_val) {
return InterlockedCompareExchange64(reinterpret_cast<volatile LONG64*>(ptr),
- (LONG64) old_val, (LONG64) new_val) ==
- (LONG64) old_val;
+ (LONG64)old_val, (LONG64)new_val) ==
+ (LONG64)old_val;
}
__forceinline static cell fetch_add(volatile cell* ptr, cell val) {
- return (cell) InterlockedExchangeAdd64(
- reinterpret_cast<volatile LONG64*>(ptr), (LONG64) val);
+ return (cell)InterlockedExchangeAdd64(
+ reinterpret_cast<volatile LONG64*>(ptr), (LONG64)val);
}
__forceinline static fixnum fetch_add(volatile fixnum* ptr, fixnum val) {
- return (fixnum) InterlockedExchangeAdd64(
- reinterpret_cast<volatile LONG64*>(ptr), (LONG64) val);
+ return (fixnum)InterlockedExchangeAdd64(
+ reinterpret_cast<volatile LONG64*>(ptr), (LONG64)val);
}
__forceinline static cell fetch_subtract(volatile cell* ptr, cell val) {
- return (cell) InterlockedExchangeAdd64(
- reinterpret_cast<volatile LONG64*>(ptr), -(LONG64) val);
+ return (cell)InterlockedExchangeAdd64(
+ reinterpret_cast<volatile LONG64*>(ptr), -(LONG64)val);
}
__forceinline static fixnum fetch_subtract(volatile fixnum* ptr, fixnum val) {
- return (fixnum) InterlockedExchangeAdd64(
- reinterpret_cast<volatile LONG64*>(ptr), -(LONG64) val);
+ return (fixnum)InterlockedExchangeAdd64(
+ reinterpret_cast<volatile LONG64*>(ptr), -(LONG64)val);
}
__forceinline static void fence() { MemoryBarrier(); }
significand *= (factor); \
digit = ((bignum_digit_type) significand); \
(*--scan) = digit; \
- significand -= ((double) digit); \
+ significand -= ((double)digit); \
}
#define inf std::numeric_limits<double>::infinity()
bignum_digit_type digit;
int odd_bits = (exponent % BIGNUM_DIGIT_LENGTH);
if (odd_bits > 0)
- DTB_WRITE_DIGIT((fixnum) 1 << odd_bits);
+ DTB_WRITE_DIGIT((fixnum)1 << odd_bits);
while (start < scan) {
if (significand == 0) {
while (start < scan)
bignum_digit_type* end_source = (scan_source + (BIGNUM_LENGTH(source)));
bignum_digit_type* end_target = (scan_target + (BIGNUM_LENGTH(target)));
int shift_right = (BIGNUM_DIGIT_LENGTH - shift_left);
- bignum_digit_type mask = (((cell) 1 << shift_right) - 1);
+ bignum_digit_type mask = (((cell)1 << shift_right) - 1);
while (scan_source < end_source) {
digit = (*scan_source++);
(*scan_target++) = (((digit & mask) << shift_left) | carry);
bignum_digit_type digit;
bignum_digit_type carry = 0;
int shift_left = (BIGNUM_DIGIT_LENGTH - shift_right);
- bignum_digit_type mask = (((fixnum) 1 << shift_right) - 1);
+ bignum_digit_type mask = (((fixnum)1 << shift_right) - 1);
while (start < scan) {
digit = (*--scan);
(*scan) = ((digit >> shift_right) | carry);
return 0;
bignum_digit_type digit = (BIGNUM_REF(bignum, index));
int p = shift % BIGNUM_DIGIT_LENGTH;
- bignum_digit_type mask = ((fixnum) 1) << p;
+ bignum_digit_type mask = ((fixnum)1) << p;
return (digit & mask) ? 1 : 0;
}
#define BIGNUM_DIGIT_LENGTH (((sizeof(bignum_digit_type)) * CHAR_BIT) - 2)
#define BIGNUM_HALF_DIGIT_LENGTH (BIGNUM_DIGIT_LENGTH / 2)
-#define BIGNUM_RADIX (bignum_digit_type)(((cell) 1) << BIGNUM_DIGIT_LENGTH)
+#define BIGNUM_RADIX (bignum_digit_type)(((cell)1) << BIGNUM_DIGIT_LENGTH)
#define BIGNUM_RADIX_ROOT (((bignum_digit_type) 1) << BIGNUM_HALF_DIGIT_LENGTH)
#define BIGNUM_DIGIT_MASK (BIGNUM_RADIX - 1)
#define BIGNUM_HALF_DIGIT_MASK (BIGNUM_RADIX_ROOT - 1)
bump_allocator(cell size, cell start)
: here(start), start(start), end(start + size), size(size) {}
- bool contains_p(Block* block) { return ((cell) block - start) < size; }
+ bool contains_p(Block* block) { return ((cell)block - start) < size; }
Block* allot(cell size) {
cell h = here;
void callback_heap::update(code_block* stub) {
store_callback_operand(stub, setup_seh_p() ? 2 : 1,
- (cell) callback_entry_point(stub));
+ (cell)callback_entry_point(stub));
stub->flush_icache();
}
memcpy(stub->entry_point(), insns->data<void>(), size);
/* Store VM pointer */
- store_callback_operand(stub, 0, (cell) parent);
+ store_callback_operand(stub, 0, (cell)parent);
cell index;
void update();
code_block* next(code_block* stub) {
- return (code_block*)((cell) stub + stub->size());
+ return (code_block*)((cell)stub + stub->size());
}
template <typename Iterator> void each_callback(Iterator& iter) {
void* top = second_from_top_stack_frame(ctx);
void* bottom = ctx->callstack_bottom;
- fixnum size = std::max((fixnum) 0, (fixnum) bottom - (fixnum) top);
+ fixnum size = std::max((fixnum)0, (fixnum)bottom - (fixnum)top);
callstack* stack = allot_callstack(size);
memcpy(stack->top(), top, size);
void* factor_vm::frame_predecessor(void* frame_top) {
void* addr = frame_return_address((void*)frame_top);
FACTOR_ASSERT(addr != 0);
- code_block* owner = code->code_block_for_address((cell) addr);
- cell frame_size = owner->stack_frame_size_for_address((cell) addr);
+ code_block* owner = code->code_block_for_address((cell)addr);
+ cell frame_size = owner->stack_frame_size_for_address((cell)addr);
return (void*)((char*)frame_top + frame_size);
}
callstack* stack = untag_check<callstack>(ctx->peek());
void* frame = stack->top();
void* addr = frame_return_address(frame);
- ctx->replace(code->code_block_for_address((cell) addr)->owner_quot());
+ ctx->replace(code->code_block_for_address((cell)addr)->owner_quot());
}
void factor_vm::primitive_innermost_stack_frame_scan() {
callstack* stack = untag_check<callstack>(ctx->peek());
void* frame = stack->top();
void* addr = frame_return_address(frame);
- ctx->replace(code->code_block_for_address((cell) addr)->scan(this, addr));
+ ctx->replace(code->code_block_for_address((cell)addr)->scan(this, addr));
}
void factor_vm::primitive_set_innermost_stack_frame_quot() {
void* inner = stack->top();
void* addr = frame_return_address(inner);
- code_block* block = code->code_block_for_address((cell) addr);
+ code_block* block = code->code_block_for_address((cell)addr);
cell offset = block->offset(addr);
set_frame_return_address(inner, (char*)quot->entry_point + offset);
}
void* fixed_addr = Fixup::translated_code_block_map
? (void*)fixup.translate_code((code_block*)addr)
: addr;
- code_block* owner = code->code_block_for_address((cell) fixed_addr);
- cell frame_size = owner->stack_frame_size_for_address((cell) fixed_addr);
+ code_block* owner = code->code_block_for_address((cell)fixed_addr);
+ cell frame_size = owner->stack_frame_size_for_address((cell)fixed_addr);
iterator(frame_top, frame_size, owner, fixed_addr);
frame_offset += frame_size;
? (void*)fixup.translate_code((code_block*)addr)
: addr;
- code_block* owner = code->code_block_for_address((cell) fixed_addr);
+ code_block* owner = code->code_block_for_address((cell)fixed_addr);
code_block* fixed_owner =
Fixup::translated_code_block_map ? owner : fixup.translate_code(owner);
cell frame_size =
- fixed_owner->stack_frame_size_for_address((cell) fixed_addr);
+ fixed_owner->stack_frame_size_for_address((cell)fixed_addr);
void* fixed_addr_for_iter =
Fixup::translated_code_block_map ? fixed_addr : addr;
cell factor_vm::compute_entry_point_address(cell obj) {
switch (tagged<object>(obj).type()) {
case WORD_TYPE:
- return (cell) untag<word>(obj)->entry_point;
+ return (cell)untag<word>(obj)->entry_point;
case QUOTATION_TYPE:
- return (cell) untag<quotation>(obj)->entry_point;
+ return (cell)untag<quotation>(obj)->entry_point;
default:
critical_error("Expected word or quotation", obj);
return 0;
cell factor_vm::compute_entry_point_pic_address(word* w, cell tagged_quot) {
if (!to_boolean(tagged_quot) || max_pic_size == 0)
- return (cell) w->entry_point;
+ return (cell)w->entry_point;
else {
quotation* quot = untag<quotation>(tagged_quot);
if (quot_compiled_p(quot))
- return (cell) quot->entry_point;
+ return (cell)quot->entry_point;
else
- return (cell) w->entry_point;
+ return (cell)w->entry_point;
}
}
void* undefined_symbol = (void*)factor::undefined_symbol;
undefined_symbol = FUNCTION_CODE_POINTER(undefined_symbol);
if (d != NULL && !d->handle)
- return (cell) undefined_symbol;
+ return (cell)undefined_symbol;
switch (tagged<object>(symbol).type()) {
case BYTE_ARRAY_TYPE: {
void* sym = ffi_dlsym(d, name);
if (sym)
- return (cell) sym;
+ return (cell)sym;
else
- return (cell) undefined_symbol;
+ return (cell)undefined_symbol;
}
case ARRAY_TYPE: {
array* names = untag<array>(symbol);
void* sym = ffi_dlsym(d, name);
if (sym)
- return (cell) sym;
+ return (cell)sym;
}
- return (cell) undefined_symbol;
+ return (cell)undefined_symbol;
}
default:
critical_error("Bad symbol specifier", symbol);
- return (cell) undefined_symbol;
+ return (cell)undefined_symbol;
}
}
void* undefined_toc = (void*)factor::undefined_symbol;
undefined_toc = FUNCTION_TOC_POINTER(undefined_toc);
if (d != NULL && !d->handle)
- return (cell) undefined_toc;
+ return (cell)undefined_toc;
switch (tagged<object>(symbol).type()) {
case BYTE_ARRAY_TYPE: {
symbol_char* name = alien_offset(symbol);
void* toc = ffi_dlsym_toc(d, name);
if (toc)
- return (cell) toc;
+ return (cell)toc;
else
- return (cell) undefined_toc;
+ return (cell)undefined_toc;
}
case ARRAY_TYPE: {
array* names = untag<array>(symbol);
void* toc = ffi_dlsym_toc(d, name);
if (toc)
- return (cell) toc;
+ return (cell)toc;
}
- return (cell) undefined_toc;
+ return (cell)undefined_toc;
}
default:
critical_error("Bad symbol specifier", symbol);
- return (cell) undefined_toc;
+ return (cell)undefined_toc;
}
}
#endif
cell factor_vm::compute_vm_address(cell arg) {
- return (cell) this + untag_fixnum(arg);
+ return (cell)this + untag_fixnum(arg);
}
void factor_vm::store_external_address(instruction_operand op) {
op.store_value(compute_dlsym_address(parameters, index));
break;
case RT_THIS:
- op.store_value((cell) compiled->entry_point());
+ op.store_value((cell)compiled->entry_point());
break;
case RT_MEGAMORPHIC_CACHE_HITS:
- op.store_value((cell) & dispatch_stats.megamorphic_cache_hits);
+ op.store_value((cell)&dispatch_stats.megamorphic_cache_hits);
break;
case RT_VM:
op.store_value(compute_vm_address(array_nth(parameters, index)));
break;
#ifdef WINDOWS
case RT_EXCEPTION_HANDLER:
- op.store_value((cell) & factor::exception_handler);
+ op.store_value((cell)&factor::exception_handler);
break;
#endif
#ifdef FACTOR_PPC
break;
#endif
case RT_INLINE_CACHE_MISS:
- op.store_value((cell) & factor::inline_cache_miss);
+ op.store_value((cell)&factor::inline_cache_miss);
break;
case RT_SAFEPOINT:
- op.store_value((cell) code->safepoint_page);
+ op.store_value((cell)code->safepoint_page);
break;
default:
critical_error("Bad rel type in store_external_address()", op.rel_type());
code_block* compiled) {
fixnum n = untag_fixnum(arg);
if (n >= 0)
- return (cell) compiled->entry_point() + offset + n;
+ return (cell)compiled->entry_point() + offset + n;
else
- return (cell) compiled->entry_point() - n;
+ return (cell)compiled->entry_point() - n;
}
struct initial_code_block_visitor {
relocation_entry new_entry(RT_HERE, rel_class, offset);
instruction_operand op(new_entry, compiled, 0);
- op.store_value(target + (cell) compiled->entry_point());
+ op.store_value(target + (cell)compiled->entry_point());
}
}
block's instruction operands. In most cases this is done right after this
method returns, except when compiling words with the non-optimizing
compiler at the beginning of bootstrap */
- this->code->uninitialized_blocks
- .insert(std::make_pair(compiled, literals.value()));
- this->code->all_blocks.insert((cell) compiled);
+ this->code->uninitialized_blocks.insert(
+ std::make_pair(compiled, literals.value()));
+ this->code->all_blocks.insert((cell)compiled);
/* next time we do a minor GC, we have to trace this code block, since
the fields of the code_block struct might point into nursery or aging */
void factor_vm::undefined_symbol() {
void* frame = ctx->callstack_top;
void* return_address = frame_return_address(frame);
- code_block* compiled = code->code_block_for_address((cell) return_address);
- find_symbol_at_address_visitor visitor(this, (cell) return_address);
+ code_block* compiled = code->code_block_for_address((cell)return_address);
+ find_symbol_at_address_visitor visitor(this, (cell)return_address);
compiled->each_instruction_operand(visitor);
if (!to_boolean(visitor.symbol))
critical_error("Can't find RT_DLSYM at return address",
- (cell) return_address);
+ (cell)return_address);
else
general_error(ERROR_UNDEFINED_SYMBOL, visitor.symbol, visitor.library);
}
return (gc_info*)((uint8_t*)this + size() - sizeof(gc_info));
}
- void flush_icache() { factor::flush_icache((cell) this, size()); }
+ void flush_icache() { factor::flush_icache((cell)this, size()); }
template <typename Iterator> void each_instruction_operand(Iterator& iter) {
if (to_boolean(relocation)) {
FACTOR_ASSERT(!uninitialized_p(compiled));
points_to_nursery.erase(compiled);
points_to_aging.erase(compiled);
- all_blocks.erase((cell) compiled);
+ all_blocks.erase((cell)compiled);
allocator->free(compiled);
}
void operator()(code_block* free_block, cell size) {
std::set<cell>::iterator erase_from =
- code->all_blocks.lower_bound((cell) free_block);
+ code->all_blocks.lower_bound((cell)free_block);
std::set<cell>::iterator erase_to =
- code->all_blocks.lower_bound((cell) free_block + size);
+ code->all_blocks.lower_bound((cell)free_block + size);
code->all_blocks.erase(erase_from, erase_to);
}
: all_blocks(all_blocks) {}
void operator()(code_block* block, cell size) {
- FACTOR_ASSERT(all_blocks->find((cell) block) != all_blocks->end());
+ FACTOR_ASSERT(all_blocks->find((cell)block) != all_blocks->end());
}
};
FACTOR_ASSERT(blocki != all_blocks.begin());
--blocki;
code_block* found_block = (code_block*)*blocki;
- FACTOR_ASSERT((cell) found_block->entry_point() <=
+ FACTOR_ASSERT((cell)found_block->entry_point() <=
address /* XXX this isn't valid during fixup. should store the
size in the map
&& address - (cell)found_block->entry_point() <
all_blocks_set_inserter(code_heap* code) : code(code) {}
void operator()(code_block* block, cell size) {
- code->all_blocks.insert((cell) block);
+ code->all_blocks.insert((cell)block);
}
};
from_unsigned_cell() here. It is OK, however, to add it as
if it were a fixnum, and have library code shift it to the
left by 4. */
- cell entry_point = (cell) compiled->entry_point();
+ cell entry_point = (cell)compiled->entry_point();
FACTOR_ASSERT((entry_point & (data_alignment - 1)) == 0);
FACTOR_ASSERT((entry_point & TAG_MASK) == FIXNUM_TYPE);
objects.push_back(entry_point);
bool safepoint_p(cell addr) {
cell page_mask = ~(getpagesize() - 1);
- return (addr & page_mask) == (cell) safepoint_page;
+ return (addr & page_mask) == (cell)safepoint_page;
}
};
code_block* fixup_code(code_block* compiled) {
if (!code->marked_p(compiled)) {
code->set_marked_p(compiled);
- parent->mark_stack.push_back((cell) compiled + 1);
+ parent->mark_stack.push_back((cell)compiled + 1);
}
return compiled;
: parent(parent), old_address(old_address), fixup(fixup) {}
void operator()(instruction_operand op) {
- cell old_offset = op.rel_offset() + (cell) old_address->entry_point();
+ cell old_offset = op.rel_offset() + (cell)old_address->entry_point();
switch (op.rel_type()) {
case RT_LITERAL: {
cell value = op.load_value(old_offset);
cell offset = TAG(value);
code_block* compiled = (code_block*)UNTAG(value);
- op.store_value((cell) fixup.fixup_code(compiled) + offset);
+ op.store_value((cell)fixup.fixup_code(compiled) + offset);
break;
}
case RT_THIS:
code_block* block = (code_block*)(root->value & (~data_alignment + 1));
/* Offset of return address within 16-byte allocation line */
- cell offset = root->value - (cell) block;
+ cell offset = root->value - (cell)block;
if (root->valid && state->marked_p(block)) {
block = state->forward_block(block);
- root->value = (cell) block + offset;
+ root->value = (cell)block + offset;
} else
root->valid = false;
}
uint32_t insn = *(uint32_t*)return_address;
- fixnum relative_address = ((cell) target - return_address);
+ fixnum relative_address = ((cell)target - return_address);
insn = ((insn & ~b_mask) | (relative_address & b_mask));
*(uint32_t*)return_address = insn;
void* frame_top = (void*)ctx->callstack_top;
while (frame_top < ctx->callstack_bottom &&
- (cell) frame_top < ctx->callstack_seg->start + stack_reserved) {
+ (cell)frame_top < ctx->callstack_seg->start + stack_reserved) {
frame_top = frame_predecessor(frame_top);
}
- *sp = (cell) frame_top;
+ *sp = (cell)frame_top;
ctx->callstack_top = frame_top;
*pc = handler;
} else {
} else
FACTOR_ASSERT(false);
- *pc = (cell) handler_word->entry_point;
+ *pc = (cell)handler_word->entry_point;
}
}
inline static void check_call_site(cell return_address) {
unsigned char opcode = call_site_opcode(return_address);
FACTOR_ASSERT(opcode == call_opcode || opcode == jmp_opcode);
- (void) opcode; // suppress warning when compiling without assertions
+ (void)opcode; // suppress warning when compiling without assertions
}
inline static void* get_call_target(cell return_address) {
inline static void set_call_target(cell return_address, void* target) {
check_call_site(return_address);
- *(int*)(return_address - 4) = (uint32_t)((cell) target - return_address);
+ *(int*)(return_address - 4) = (uint32_t)((cell)target - return_address);
}
inline static bool tail_call_site_p(cell return_address) {
namespace factor {
void factor_vm::init_card_decks() {
- cards_offset = (cell) data->cards - addr_to_card(data->start);
- decks_offset = (cell) data->decks - addr_to_deck(data->start);
+ cards_offset = (cell)data->cards - addr_to_card(data->start);
+ decks_offset = (cell)data->decks - addr_to_deck(data->start);
}
data_heap::data_heap(cell young_size_, cell aging_size_, cell tenured_size_) {
else if (parent->data->tenured->contains_p(obj))
return tenured_generation;
else {
- critical_error("Bad object", (cell) obj);
- return (generation) - 1;
+ critical_error("Bad object", (cell)obj);
+ return (generation)-1;
}
}
: parent(parent), obj(obj), gen(gen) {}
void check_write_barrier(cell* slot_ptr, generation target, char mask) {
- cell object_card_pointer = parent->cards_offset + ((cell) obj >> card_bits);
+ cell object_card_pointer = parent->cards_offset + ((cell)obj >> card_bits);
cell slot_card_pointer =
- parent->cards_offset + ((cell) slot_ptr >> card_bits);
+ parent->cards_offset + ((cell)slot_ptr >> card_bits);
char slot_card_value = *(char*)slot_card_pointer;
if ((slot_card_value & mask) != mask) {
std::cout << "card not marked" << std::endl;
gc_bignum(bignum** addr, factor_vm* parent) : addr(addr), parent(parent) {
if (*addr)
parent->check_data_pointer(*addr);
- parent->bignum_roots.push_back((cell) addr);
+ parent->bignum_roots.push_back((cell)addr);
}
~gc_bignum() {
- FACTOR_ASSERT(parent->bignum_roots.back() == (cell) addr);
+ FACTOR_ASSERT(parent->bignum_roots.back() == (cell)addr);
parent->bignum_roots.pop_back();
}
};
std::ostream& operator<<(std::ostream& out, const string* str) {
for (cell i = 0; i < string_capacity(str); i++)
- out << (char) str->data()[i];
+ out << (char)str->data()[i];
return out;
}
parent->print_obj(owner->scan(parent, addr));
std::cout << std::endl;
std::cout << "word/quot addr: ";
- std::cout << std::hex << (cell) owner->owner << std::dec;
+ std::cout << std::hex << (cell)owner->owner << std::dec;
std::cout << std::endl;
std::cout << "word/quot xt: ";
- std::cout << std::hex << (cell) owner->entry_point() << std::dec;
+ std::cout << std::hex << (cell)owner->entry_point() << std::dec;
std::cout << std::endl;
std::cout << "return address: ";
- std::cout << std::hex << (cell) addr << std::dec;
+ std::cout << std::hex << (cell)addr << std::dec;
std::cout << std::endl;
}
};
dump_generation("Tenured", data->tenured);
std::cout << "Cards:";
- std::cout << "base=" << (cell) data->cards << ", ";
+ std::cout << "base=" << (cell)data->cards << ", ";
std::cout << "size=" << (cell)(data->cards_end - data->cards) << std::endl;
std::cout << std::dec;
void operator()(object* obj) {
if (type == TYPE_COUNT || obj->type() == type) {
- std::cout << padded_address((cell) obj) << " ";
+ std::cout << padded_address((cell)obj) << " ";
parent->print_nested_obj(tag_dynamic(obj), 2);
std::cout << std::endl;
}
void operator()(cell* scan) {
if (look_for == *scan) {
- std::cout << padded_address((cell) obj) << " ";
+ std::cout << padded_address((cell)obj) << " ";
parent->print_nested_obj(tag_dynamic(obj), 2);
std::cout << std::endl;
}
else
status = "allocated";
- std::cout << std::hex << (cell) scan << std::dec << " ";
+ std::cout << std::hex << (cell)scan << std::dec << " ";
std::cout << std::hex << size << std::dec << " ";
std::cout << status << " ";
std::cout << "stack frame " << scan->stack_frame_size();
print_callstack();
else if (strcmp(cmd, "e") == 0) {
for (cell i = 0; i < special_object_count; i++)
- dump_cell((cell) & special_objects[i]);
+ dump_cell((cell)&special_objects[i]);
} else if (strcmp(cmd, "g") == 0)
dump_generations();
else if (strcmp(cmd, "c") == 0) {
array* echelons = untag<array>(methods);
fixnum echelon = std::min(untag_fixnum(layout->echelon),
- (fixnum) array_capacity(echelons) - 1);
+ (fixnum)array_capacity(echelons) - 1);
while (echelon >= 0) {
cell echelon_methods = array_nth(echelons, echelon);
p->image_path = default_image_path();
}
- srand((unsigned int) nano_count());
+ srand((unsigned int)nano_count());
init_ffi();
init_contexts(p->datastack_size, p->retainstack_size, p->callstack_size);
init_callbacks(p->callback_size);
load_image(p);
init_c_io();
- init_inline_caching((int) p->max_pic_size);
+ init_inline_caching((int)p->max_pic_size);
special_objects[OBJ_CPU] =
- allot_alien(false_object, (cell) FACTOR_CPU_STRING);
- special_objects[OBJ_OS] = allot_alien(false_object, (cell) FACTOR_OS_STRING);
+ allot_alien(false_object, (cell)FACTOR_CPU_STRING);
+ special_objects[OBJ_OS] = allot_alien(false_object, (cell)FACTOR_OS_STRING);
special_objects[OBJ_CELL_SIZE] = tag_fixnum(sizeof(cell));
special_objects[OBJ_EXECUTABLE] =
- allot_alien(false_object, (cell) p->executable_path);
+ allot_alien(false_object, (cell)p->executable_path);
special_objects[OBJ_ARGS] = false_object;
special_objects[OBJ_EMBEDDED] = false_object;
special_objects[OBJ_VM_COMPILER] =
- allot_alien(false_object, (cell) FACTOR_COMPILER_VERSION);
+ allot_alien(false_object, (cell)FACTOR_COMPILER_VERSION);
/* We can GC now */
gc_off = false;
growable_array args(this);
for (fixnum i = 1; i < argc; i++)
- args.add(allot_alien(false_object, (cell) argv[i]));
+ args.add(allot_alien(false_object, (cell)argv[i]));
args.trim();
special_objects[OBJ_ARGS] = args.elements.value();
clear_free_list();
if (occupied != end - start) {
free_heap_block* last_block = (free_heap_block*)(start + occupied);
- last_block->make_free(end - (cell) last_block);
+ last_block->make_free(end - (cell)last_block);
add_to_free_list(last_block);
}
}
/* Split it up into pieces and add each piece back to the free list */
for (cell offset = 0; offset < large_block_size; offset += size) {
free_heap_block* small_block = large_block;
- large_block = (free_heap_block*)((cell) large_block + size);
+ large_block = (free_heap_block*)((cell)large_block + size);
small_block->make_free(size);
add_to_free_list(small_block);
}
cell size) {
if (block->size() != size) {
/* split the block in two */
- free_heap_block* split = (free_heap_block*)((cell) block + size);
+ free_heap_block* split = (free_heap_block*)((cell)block + size);
split->make_free(block->size() - size);
block->make_free(size);
add_to_free_list(split);
template <typename Block>
bool free_list_allocator<Block>::contains_p(Block* block) {
- return ((cell) block - start) < size;
+ return ((cell)block - start) < size;
}
template <typename Block> Block* free_list_allocator<Block>::first_block() {
template <typename Block>
Block* free_list_allocator<Block>::next_block_after(Block* block) {
- return (Block*)((cell) block + block->size());
+ return (Block*)((cell)block + block->size());
}
template <typename Block>
Block* free_list_allocator<Block>::next_allocated_block_after(Block* block) {
while (block != this->last_block() && block->free_p()) {
free_heap_block* free_block = (free_heap_block*)block;
- block = (object*)((cell) free_block + free_block->size());
+ block = (object*)((cell)free_block + free_block->size());
}
if (block == this->last_block())
/* Now update the free list; there will be a single free block at
the end */
- free_blocks.initial_free_list(start, end, (cell) compactor.address - start);
+ free_blocks.initial_free_list(start, end, (cell)compactor.address - start);
}
/* During compaction we have to be careful and measure object sizes
while (scan != end) {
cell size = fixup.size(scan);
- Block* next = (Block*)((cell) scan + size);
+ Block* next = (Block*)((cell)scan + size);
if (!scan->free_p())
iter(scan, size);
scan = next;
void promoted_object(object* obj) {
tenured->set_marked_p(obj);
- parent->mark_stack.push_back((cell) obj);
+ parent->mark_stack.push_back((cell)obj);
}
void visited_object(object* obj) {
FACTOR_ASSERT(return_address < owner->size());
cell index = info->return_address_index(return_address);
- if (index != (cell) - 1)
+ if (index != (cell)-1)
ctx->scrub_stacks(info, index);
}
};
return i;
}
- return (cell) - 1;
+ return (cell)-1;
}
}
fixnum bytes_read =
safe_fread((void*)data->tenured->start, 1, h->data_size, file);
- if ((cell) bytes_read != h->data_size) {
+ if ((cell)bytes_read != h->data_size) {
std::cout << "truncated image: " << bytes_read << " bytes read, ";
std::cout << h->data_size << " bytes expected\n";
fatal_error("load_data_heap failed", 0);
: data_offset(data_offset), code_offset(code_offset) {}
object* fixup_data(object* obj) {
- return (object*)((cell) obj + data_offset);
+ return (object*)((cell)obj + data_offset);
}
code_block* fixup_code(code_block* obj) {
- return (code_block*)((cell) obj + code_offset);
+ return (code_block*)((cell)obj + code_offset);
}
object* translate_data(const object* obj) { return fixup_data((object*)obj); }
void operator()(instruction_operand op) {
code_block* compiled = op.compiled;
cell old_offset =
- op.rel_offset() + (cell) compiled->entry_point() - fixup.code_offset;
+ op.rel_offset() + (cell)compiled->entry_point() - fixup.code_offset;
switch (op.rel_type()) {
case RT_LITERAL: {
cell value = op.load_value(old_offset);
cell offset = TAG(value);
code_block* compiled = (code_block*)UNTAG(value);
- op.store_value((cell) fixup.fixup_code(compiled) + offset);
+ op.store_value((cell)fixup.fixup_code(compiled) + offset);
break;
}
case RT_UNTAGGED:
bool factor_vm::read_embedded_image_footer(FILE* file,
embedded_image_footer* footer) {
- safe_fseek(file, -(off_t) sizeof(embedded_image_footer), SEEK_END);
- safe_fread(footer, (off_t) sizeof(embedded_image_footer), 1, file);
+ safe_fseek(file, -(off_t)sizeof(embedded_image_footer), SEEK_END);
+ safe_fread(footer, (off_t)sizeof(embedded_image_footer), 1, file);
return footer->magic == image_magic;
}
std::cout << "No embedded image" << std::endl;
exit(1);
}
- safe_fseek(file, (off_t) footer.image_offset, SEEK_SET);
+ safe_fseek(file, (off_t)footer.image_offset, SEEK_SET);
return file;
} else
return OPEN_READ(p->image_path);
fixup_code(data_offset, code_offset);
/* Store image path name */
- special_objects[OBJ_IMAGE] = allot_alien(false_object, (cell) p->image_path);
+ special_objects[OBJ_IMAGE] = allot_alien(false_object, (cell)p->image_path);
}
/* Save the current image to disk */
void factor_vm::deallocate_inline_cache(cell return_address) {
/* Find the call target. */
void* old_entry_point = get_call_target(return_address);
- check_code_pointer((cell) old_entry_point);
+ check_code_pointer((cell)old_entry_point);
code_block* old_block = (code_block*)old_entry_point - 1;
#ifdef PIC_DEBUG
std::cout << "Updated " << (tail_call_site ? "tail" : "non-tail")
<< " call site 0x" << std::hex << return_address.value << std::dec
- << " with 0x" << std::hex << (cell) xt << std::dec << std::endl;
+ << " with 0x" << std::hex << (cell)xt << std::dec << std::endl;
print_callstack();
#endif
}
: rel(rel),
compiled(compiled),
index(index),
- pointer((cell) compiled->entry_point() + rel.rel_offset()) {}
+ pointer((cell)compiled->entry_point() + rel.rel_offset()) {}
/* Load a 32-bit value from a PowerPC LIS/ORI sequence */
fixnum instruction_operand::load_value_2_2() {
uint64_t lhi = (ptr[-2] & 0xffff);
uint64_t llo = (ptr[-1] & 0xffff);
uint64_t val = hhi << 48 | hlo << 32 | lhi << 16 | llo;
- return (cell) val;
+ return (cell)val;
}
/* Load a value from a bitfield of a PowerPC instruction */
cell shift) {
int32_t* ptr = (int32_t*)(pointer - sizeof(uint32_t));
- return (((*ptr & (int32_t) mask) << bits) >> bits) << shift;
+ return (((*ptr & (int32_t)mask) << bits) >> bits) << shift;
}
fixnum instruction_operand::load_value(cell relative_to) {
*(cell*)(pointer - sizeof(cell)) = absolute_value;
break;
case RC_ABSOLUTE:
- *(uint32_t*)(pointer - sizeof(uint32_t)) = (uint32_t) absolute_value;
+ *(uint32_t*)(pointer - sizeof(uint32_t)) = (uint32_t)absolute_value;
break;
case RC_RELATIVE:
- *(int32_t*)(pointer - sizeof(int32_t)) = (int32_t) relative_value;
+ *(int32_t*)(pointer - sizeof(int32_t)) = (int32_t)relative_value;
break;
case RC_ABSOLUTE_PPC_2_2:
store_value_2_2(absolute_value);
0);
break;
case RC_ABSOLUTE_2:
- *(uint16_t*)(pointer - sizeof(uint16_t)) = (uint16_t) absolute_value;
+ *(uint16_t*)(pointer - sizeof(uint16_t)) = (uint16_t)absolute_value;
break;
case RC_ABSOLUTE_1:
- *(uint8_t*)(pointer - sizeof(uint8_t)) = (uint8_t) absolute_value;
+ *(uint8_t*)(pointer - sizeof(uint8_t)) = (uint8_t)absolute_value;
break;
case RC_ABSOLUTE_PPC_2_2_2_2:
store_value_2_2_2_2(absolute_value);
}
void instruction_operand::store_code_block(code_block* compiled) {
- store_value((cell) compiled->entry_point());
+ store_value((cell)compiled->entry_point());
}
}
normal operation. */
void factor_vm::init_c_io() {
- special_objects[OBJ_STDIN] = allot_alien(false_object, (cell) stdin);
- special_objects[OBJ_STDOUT] = allot_alien(false_object, (cell) stdout);
- special_objects[OBJ_STDERR] = allot_alien(false_object, (cell) stderr);
+ special_objects[OBJ_STDIN] = allot_alien(false_object, (cell)stdin);
+ special_objects[OBJ_STDOUT] = allot_alien(false_object, (cell)stdout);
+ special_objects[OBJ_STDERR] = allot_alien(false_object, (cell)stderr);
}
void factor_vm::io_error() {
void factor_vm::primitive_fputc() {
FILE* file = pop_file_handle();
fixnum ch = to_fixnum(ctx->pop());
- safe_fputc((int) ch, file);
+ safe_fputc((int)ch, file);
}
void factor_vm::primitive_fwrite() {
void factor_vm::primitive_fseek() {
FILE* file = pop_file_handle();
- int whence = (int) to_fixnum(ctx->pop());
- off_t offset = (off_t) to_signed_8(ctx->pop());
+ int whence = (int)to_fixnum(ctx->pop());
+ off_t offset = (off_t)to_signed_8(ctx->pop());
safe_fseek(file, offset, whence);
}
parent(vm) {
fixnum old_count = atomic::fetch_add(&parent->current_jit_count, 1);
FACTOR_ASSERT(old_count >= 0);
- (void) old_count;
+ (void)old_count;
}
jit::~jit() {
fixnum old_count = atomic::fetch_subtract(&parent->current_jit_count, 1);
FACTOR_ASSERT(old_count >= 1);
- (void) old_count;
+ (void)old_count;
}
void jit::emit_relocation(cell relocation_template_) {
inline static fixnum untag_fixnum(cell tagged) {
FACTOR_ASSERT(TAG(tagged) == FIXNUM_TYPE);
- return ((fixnum) tagged) >> TAG_BITS;
+ return ((fixnum)tagged) >> TAG_BITS;
}
inline static cell tag_fixnum(fixnum untagged) {
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 */
if (exception == EXC_BAD_ACCESS) {
signal_fault_addr = MACH_EXC_STATE_FAULT(exc_state);
- signal_fault_pc = (cell) MACH_PROGRAM_COUNTER(thread_state);
+ signal_fault_pc = (cell)MACH_PROGRAM_COUNTER(thread_state);
verify_memory_protection_error(signal_fault_addr);
- handler = (cell) factor::memory_signal_handler_impl;
+ handler = (cell)factor::memory_signal_handler_impl;
} else if (exception == EXC_ARITHMETIC && code != MACH_EXC_INTEGER_DIV) {
signal_fpu_status = fpu_status(mach_fpu_status(float_state));
mach_clear_fpu_status(float_state);
- handler = (cell) factor::fp_signal_handler_impl;
+ handler = (cell)factor::fp_signal_handler_impl;
} else {
switch (exception) {
case EXC_ARITHMETIC:
break;
}
- handler = (cell) factor::synchronous_signal_handler_impl;
+ handler = (cell)factor::synchronous_signal_handler_impl;
}
FACTOR_ASSERT(handler != 0);
dispatch_signal_handler((cell*)&MACH_STACK_POINTER(thread_state),
(cell*)&MACH_PROGRAM_COUNTER(thread_state),
- (cell) handler);
+ (cell)handler);
}
static void call_fault_handler(mach_port_t thread, exception_type_t exception,
}
cell block_line(const Block* address) {
- return (((cell) address - start) / data_alignment);
+ return (((cell)address - start) / data_alignment);
}
Block* line_block(cell line) {
bool bitmap_elt(cell* bits, const Block* address) {
std::pair<cell, cell> position = bitmap_deref(address);
- return (bits[position.first] & ((cell) 1 << position.second)) != 0;
+ return (bits[position.first] & ((cell)1 << position.second)) != 0;
}
Block* next_block_after(const Block* block) {
- return (Block*)((cell) block + block->size());
+ return (Block*)((cell)block + block->size());
}
void set_bitmap_range(cell* bits, const Block* address) {
std::pair<cell, cell> start = bitmap_deref(address);
std::pair<cell, cell> end = bitmap_deref(next_block_after(address));
- cell start_mask = ((cell) 1 << start.second) - 1;
- cell end_mask = ((cell) 1 << end.second) - 1;
+ cell start_mask = ((cell)1 << start.second) - 1;
+ cell end_mask = ((cell)1 << end.second) - 1;
if (start.first == end.first)
bits[start.first] |= start_mask ^ end_mask;
bits[start.first] |= ~start_mask;
for (cell index = start.first + 1; index < end.first; index++)
- bits[index] = (cell) - 1;
+ bits[index] = (cell)-1;
if (end_mask != 0) {
FACTOR_ASSERT(end.first < bits_size);
Block* forward_block(const Block* original) {
FACTOR_ASSERT(marked_p(original));
std::pair<cell, cell> position = bitmap_deref(original);
- cell offset = (cell) original & (data_alignment - 1);
+ cell offset = (cell)original & (data_alignment - 1);
cell approx_popcount = forwarding[position.first];
- cell mask = ((cell) 1 << position.second) - 1;
+ cell mask = ((cell)1 << position.second) - 1;
cell new_line_number =
approx_popcount + popcount(marked[position.first] & mask);
cell bit_index = position.second;
for (cell index = position.first; index < bits_size; index++) {
- cell mask = ((fixnum) marked[index] >> bit_index);
+ cell mask = ((fixnum)marked[index] >> bit_index);
if (~mask) {
/* Found an unmarked block on this page. Stop, it's hammer time */
cell clear_bit = rightmost_clear_bit(mask);
ctx->replace(tag_fixnum(x >> -y));
return;
} else if (y < WORD_SIZE - TAG_BITS) {
- fixnum mask = -((fixnum) 1 << (WORD_SIZE - 1 - TAG_BITS - y));
+ fixnum mask = -((fixnum)1 << (WORD_SIZE - 1 - TAG_BITS - y));
if (!(branchless_abs(x) & mask)) {
ctx->replace(tag_fixnum(x << y));
return;
}
void factor_vm::primitive_bignum_bitp() {
- int bit = (int) to_fixnum(ctx->pop());
+ int bit = (int)to_fixnum(ctx->pop());
bignum* x = untag<bignum>(ctx->peek());
ctx->replace(tag_boolean(bignum_logbitp(bit, x)));
}
/* Allocates memory */
void factor_vm::primitive_float_bits() {
ctx->push(
- from_unsigned_cell(float_bits((float) untag_float_check(ctx->pop()))));
+ from_unsigned_cell(float_bits((float)untag_float_check(ctx->pop()))));
}
/* Allocates memory */
void factor_vm::primitive_bits_float() {
- ctx->push(allot_float(bits_float((uint32_t) to_cell(ctx->pop()))));
+ ctx->push(allot_float(bits_float((uint32_t)to_cell(ctx->pop()))));
}
void factor_vm::primitive_double_bits() {
return parent->to_fixnum(tagged);
}
-cell factor_vm::to_cell(cell tagged) { return (cell) to_fixnum(tagged); }
+cell factor_vm::to_cell(cell tagged) { return (cell)to_fixnum(tagged); }
VM_C_API cell to_cell(cell tagged, factor_vm* parent) {
return parent->to_cell(tagged);
if (n < fixnum_min || n > fixnum_max)
return tag<bignum>(long_long_to_bignum(n));
else
- return tag_fixnum((fixnum) n);
+ return tag_fixnum((fixnum)n);
}
VM_C_API cell from_signed_8(int64_t n, factor_vm* parent) {
/* Allocates memory */
cell factor_vm::from_unsigned_8(uint64_t n) {
- if (n > (uint64_t) fixnum_max)
+ if (n > (uint64_t)fixnum_max)
return tag<bignum>(ulong_long_to_bignum(n));
else
- return tag_fixnum((fixnum) n);
+ return tag_fixnum((fixnum)n);
}
VM_C_API cell from_unsigned_8(uint64_t n, factor_vm* parent) {
/* Cannot allocate */
float factor_vm::to_float(cell value) {
- return (float) untag_float_check(value);
+ return (float)untag_float_check(value);
}
/* Cannot allocate */
namespace factor {
static const fixnum fixnum_max =
- (((fixnum) 1 << (WORD_SIZE - TAG_BITS - 1)) - 1);
-static const fixnum fixnum_min = (-((fixnum) 1 << (WORD_SIZE - TAG_BITS - 1)));
-static const fixnum array_size_max = ((cell) 1 << (WORD_SIZE - TAG_BITS - 2));
+ (((fixnum)1 << (WORD_SIZE - TAG_BITS - 1)) - 1);
+static const fixnum fixnum_min = (-((fixnum)1 << (WORD_SIZE - TAG_BITS - 1)));
+static const fixnum array_size_max = ((cell)1 << (WORD_SIZE - TAG_BITS - 2));
/* Allocates memory */
inline cell factor_vm::from_signed_cell(fixnum x) {
/* Allocates memory */
inline cell factor_vm::from_unsigned_cell(cell x) {
- if (x > (cell) fixnum_max)
+ if (x > (cell)fixnum_max)
return tag<bignum>(cell_to_bignum(x));
else
return tag_fixnum(x);
}
inline fixnum factor_vm::float_to_fixnum(cell tagged) {
- return (fixnum) untag_float(tagged);
+ return (fixnum)untag_float(tagged);
}
inline double factor_vm::fixnum_to_float(cell tagged) {
- return (double) untag_fixnum(tagged);
+ return (double)untag_fixnum(tagged);
}
inline cell factor_vm::unbox_array_size() {
cell obj = ctx->peek();
if (TAG(obj) == FIXNUM_TYPE) {
fixnum n = untag_fixnum(obj);
- if (n >= 0 && n < (fixnum) array_size_max) {
+ if (n >= 0 && n < (fixnum)array_size_max) {
ctx->pop();
return n;
}
/* we need to remember the first object allocated in the card */
void object_start_map::record_object_start_offset(object* obj) {
- cell idx = addr_to_card((cell) obj - start);
- card obj_start = ((cell) obj & addr_card_mask);
+ cell idx = addr_to_card((cell)obj - start);
+ card obj_start = ((cell)obj & addr_card_mask);
object_start_offsets[idx] = std::min(object_start_offsets[idx], obj_start);
}
object_counter++;
if (object_counter == 0)
object_counter++;
- obj->set_hashcode((cell) obj ^ object_counter);
+ obj->set_hashcode((cell)obj ^ object_counter);
}
void factor_vm::primitive_compute_identity_hashcode() {
}
template <typename Iterator> void object::each_slot(Iterator& iter) {
- cell scan = (cell) this;
+ cell scan = (cell)this;
cell payload_start = binary_payload_start();
cell end = scan + payload_start;
int ret = clock_gettime(CLOCK_MONOTONIC, &t);
if (ret != 0)
fatal_error("clock_gettime failed", 0);
- return (uint64_t) t.tv_sec * 1000000000 + t.tv_nsec;
+ return (uint64_t)t.tv_sec * 1000000000 + t.tv_nsec;
}
}
#define UAP_PROGRAM_COUNTER(ucontext) \
(((ucontext_t*)ucontext)->uc_mcontext.arm_pc)
#define UAP_STACK_POINTER_TYPE greg_t
-#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
+#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
-#define CODE_TO_FUNCTION_POINTER(code) (void) 0
-#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
+#define CODE_TO_FUNCTION_POINTER(code) (void)0
+#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
#define FUNCTION_CODE_POINTER(ptr) ptr
#define FUNCTION_TOC_POINTER(ptr) ptr
}
((ucontext_t*)ucontext)->uc_mcontext.uc_regs->gregs[1]
#define UAP_PROGRAM_COUNTER(ucontext) \
(((ucontext_t*)ucontext)->uc_mcontext.uc_regs->gregs[32])
-#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
+#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
-#define CODE_TO_FUNCTION_POINTER(code) (void) 0
-#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
+#define CODE_TO_FUNCTION_POINTER(code) (void)0
+#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
#define FUNCTION_CODE_POINTER(ptr) ptr
#define FUNCTION_TOC_POINTER(ptr) ptr
((ucontext_t*)ucontext)->uc_mcontext.gp_regs[1]
#define UAP_PROGRAM_COUNTER(ucontext) \
(((ucontext_t*)ucontext)->uc_mcontext.gp_regs[32])
-#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
+#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
#define FACTOR_PPC_TOC 1
(((ucontext_t*)ucontext)->uc_mcontext.gregs[7])
#define UAP_PROGRAM_COUNTER(ucontext) \
(((ucontext_t*)ucontext)->uc_mcontext.gregs[14])
-#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
+#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
-#define CODE_TO_FUNCTION_POINTER(code) (void) 0
-#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
+#define CODE_TO_FUNCTION_POINTER(code) (void)0
+#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
#define FUNCTION_CODE_POINTER(ptr) ptr
#define FUNCTION_TOC_POINTER(ptr) ptr
(((ucontext_t*)ucontext)->uc_mcontext.gregs[15])
#define UAP_PROGRAM_COUNTER(ucontext) \
(((ucontext_t*)ucontext)->uc_mcontext.gregs[16])
-#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
+#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
-#define CODE_TO_FUNCTION_POINTER(code) (void) 0
-#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
+#define CODE_TO_FUNCTION_POINTER(code) (void)0
+#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
#define FUNCTION_CODE_POINTER(ptr) ptr
#define FUNCTION_TOC_POINTER(ptr) ptr
const char* default_image_path();
#define UAP_STACK_POINTER(ucontext) (((ucontext_t*)ucontext)->uc_stack.ss_sp)
-#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
+#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
-#define UAP_STACK_POINTER_TYPE void *
+#define UAP_STACK_POINTER_TYPE void*
-#define CODE_TO_FUNCTION_POINTER(code) (void) 0
-#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
+#define CODE_TO_FUNCTION_POINTER(code) (void)0
+#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
#define FUNCTION_CODE_POINTER(ptr) ptr
#define FUNCTION_TOC_POINTER(ptr) ptr
out_of_memory();
if (mprotect(array, pagesize, PROT_NONE) == -1)
- fatal_error("Cannot protect low guard page", (cell) array);
+ fatal_error("Cannot protect low guard page", (cell)array);
if (mprotect(array + pagesize + size, pagesize, PROT_NONE) == -1)
- fatal_error("Cannot protect high guard page", (cell) array);
+ fatal_error("Cannot protect high guard page", (cell)array);
start = (cell)(array + pagesize);
end = start + size;
void code_heap::guard_safepoint() {
if (mprotect(safepoint_page, getpagesize(), PROT_NONE) == -1)
- fatal_error("Cannot protect safepoint guard page", (cell) safepoint_page);
+ fatal_error("Cannot protect safepoint guard page", (cell)safepoint_page);
}
void code_heap::unguard_safepoint() {
if (mprotect(safepoint_page, getpagesize(), PROT_WRITE) == -1)
- fatal_error("Cannot unprotect safepoint guard page", (cell) safepoint_page);
+ fatal_error("Cannot unprotect safepoint guard page", (cell)safepoint_page);
}
void factor_vm::dispatch_signal(void* uap, void(handler)()) {
dispatch_signal_handler((cell*)&UAP_STACK_POINTER(uap),
(cell*)&UAP_PROGRAM_COUNTER(uap),
- (cell) FUNCTION_CODE_POINTER(handler));
- UAP_SET_TOC_POINTER(uap, (cell) FUNCTION_TOC_POINTER(handler));
+ (cell)FUNCTION_CODE_POINTER(handler));
+ UAP_SET_TOC_POINTER(uap, (cell)FUNCTION_TOC_POINTER(handler));
}
void factor_vm::start_sampling_profiler_timer() {
void memory_signal_handler(int signal, siginfo_t* siginfo, void* uap) {
factor_vm* vm = current_vm();
- vm->verify_memory_protection_error((cell) siginfo->si_addr);
- vm->signal_fault_addr = (cell) siginfo->si_addr;
- vm->signal_fault_pc = (cell) UAP_PROGRAM_COUNTER(uap);
+ vm->verify_memory_protection_error((cell)siginfo->si_addr);
+ vm->signal_fault_addr = (cell)siginfo->si_addr;
+ vm->signal_fault_pc = (cell)UAP_PROGRAM_COUNTER(uap);
vm->dispatch_signal(uap, factor::memory_signal_handler_impl);
}
vm = thread_vms.begin()->second;
}
if (atomic::load(&vm->sampling_profiler_p))
- vm->safepoint.enqueue_samples(vm, 1, (cell) UAP_PROGRAM_COUNTER(uap),
+ vm->safepoint.enqueue_samples(vm, 1, (cell)UAP_PROGRAM_COUNTER(uap),
foreign_thread);
else if (!foreign_thread)
enqueue_signal(vm, signal);
seh_area->handler[12] = 0xe0;
/* Store address of exception handler in the operand of the 'mov' */
- cell handler = (cell) & factor::exception_handler;
+ cell handler = (cell)&factor::exception_handler;
memcpy(&seh_area->handler[2], &handler, sizeof(cell));
UNWIND_INFO* unwind_info = &seh_area->unwind_info;
unwind_info->CountOfCodes = 0;
unwind_info->FrameRegister = 0;
unwind_info->FrameOffset = 0;
- unwind_info->ExceptionHandler = (DWORD)((cell) & seh_area->handler[0] - base);
+ unwind_info->ExceptionHandler = (DWORD)((cell)&seh_area->handler[0] - base);
unwind_info->ExceptionData[0] = 0;
RUNTIME_FUNCTION* func = &seh_area->func;
func->BeginAddress = 0;
func->EndAddress = (DWORD)(code->seg->end - base);
- func->UnwindData = (DWORD)((cell) & seh_area->unwind_info - base);
+ func->UnwindData = (DWORD)((cell)&seh_area->unwind_info - base);
if (!RtlAddFunctionTable(func, 1, base))
fatal_error("RtlAddFunctionTable() failed", 0);
out_of_memory();
if (!VirtualProtect(mem, getpagesize(), PAGE_NOACCESS, &ignore))
- fatal_error("Cannot allocate low guard page", (cell) mem);
+ fatal_error("Cannot allocate low guard page", (cell)mem);
if (!VirtualProtect(mem + size + getpagesize(), getpagesize(), PAGE_NOACCESS,
&ignore))
- fatal_error("Cannot allocate high guard page", (cell) mem);
+ fatal_error("Cannot allocate high guard page", (cell)mem);
- start = (cell) mem + getpagesize();
+ start = (cell)mem + getpagesize();
end = start + size;
}
void code_heap::guard_safepoint() {
DWORD ignore;
if (!VirtualProtect(safepoint_page, getpagesize(), PAGE_NOACCESS, &ignore))
- fatal_error("Cannot protect safepoint guard page", (cell) safepoint_page);
+ fatal_error("Cannot protect safepoint guard page", (cell)safepoint_page);
}
void code_heap::unguard_safepoint() {
DWORD ignore;
if (!VirtualProtect(safepoint_page, getpagesize(), PAGE_READWRITE, &ignore))
- fatal_error("Cannot unprotect safepoint guard page", (cell) safepoint_page);
+ fatal_error("Cannot unprotect safepoint guard page", (cell)safepoint_page);
}
void factor_vm::move_file(const vm_char* path1, const vm_char* path2) {
#endif
lo = count.LowPart;
- return (uint64_t)((((uint64_t) hi << 32) | (uint64_t) lo) * scale_factor);
+ return (uint64_t)((((uint64_t)hi << 32) | (uint64_t)lo) * scale_factor);
}
void sleep_nanos(uint64_t nsec) { Sleep((DWORD)(nsec / 1000000)); }
signal_fault_addr = e->ExceptionInformation[1];
verify_memory_protection_error(signal_fault_addr);
dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP,
- (cell) factor::memory_signal_handler_impl);
+ (cell)factor::memory_signal_handler_impl);
break;
case STATUS_FLOAT_DENORMAL_OPERAND:
#endif
MXCSR(c) &= 0xffffffc0;
dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP,
- (cell) factor::fp_signal_handler_impl);
+ (cell)factor::fp_signal_handler_impl);
break;
default:
signal_number = e->ExceptionCode;
dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP,
- (cell) factor::synchronous_signal_handler_impl);
+ (cell)factor::synchronous_signal_handler_impl);
break;
}
inline static void breakpoint() { DebugBreak(); }
-#define CODE_TO_FUNCTION_POINTER(code) (void) 0
-#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
+#define CODE_TO_FUNCTION_POINTER(code) (void)0
+#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
#define FUNCTION_CODE_POINTER(ptr) ptr
#define FUNCTION_TOC_POINTER(ptr) ptr
}
void factor_vm::primitive_quotation_code() {
data_root<quotation> quot(ctx->pop(), this);
- ctx->push(from_unsigned_cell((cell) quot->entry_point));
- ctx->push(from_unsigned_cell((cell) quot->code() + quot->code()->size()));
+ ctx->push(from_unsigned_cell((cell)quot->entry_point));
+ ctx->push(from_unsigned_cell((cell)quot->code() + quot->code()->size()));
}
/* Allocates memory */
namespace factor {
-void factor_vm::primitive_exit() { exit((int) to_fixnum(ctx->pop())); }
+void factor_vm::primitive_exit() { exit((int)to_fixnum(ctx->pop())); }
void exit(int status) {
factor_vm::close_console();
} else if (atomic::load(&parent->sampling_profiler_p)) {
FACTOR_ASSERT(parent->code->seg->in_segment_p(pc));
code_block* block = parent->code->code_block_for_address(pc);
- bool prolog_p = (cell) block->entry_point() == pc;
+ bool prolog_p = (cell)block->entry_point() == pc;
parent->record_sample(prolog_p);
}
callstack_object_size(untag_fixnum(((callstack*)this)->length)),
data_alignment);
default:
- critical_error("Invalid header in size", (cell) this);
+ critical_error("Invalid header in size", (cell)this);
return 0; /* can't happen */
}
}
case WRAPPER_TYPE:
return sizeof(wrapper);
default:
- critical_error("Invalid header in binary_payload_start", (cell) this);
+ critical_error("Invalid header in binary_payload_start", (cell)this);
return 0; /* can't happen */
}
}
template <typename Fixup>
void slot_visitor<Fixup>::visit_slots(object* ptr, cell payload_start) {
cell* slot = (cell*)ptr;
- cell* end = (cell*)((cell) ptr + payload_start);
+ cell* end = (cell*)((cell)ptr + payload_start);
if (slot != end) {
slot++;
cell* handle = (cell*)(*iter);
if (*handle)
- *handle = (cell) fixup.fixup_data(*(object**)handle);
+ *handle = (cell)fixup.fixup_data(*(object**)handle);
}
}
FACTOR_ASSERT(return_address < compiled->size());
cell callsite = info->return_address_index(return_address);
- if (callsite == (cell) - 1)
+ if (callsite == (cell)-1)
return;
#ifdef DEBUG_GC_MAPS
}
cell first_object() {
- return (cell) next_allocated_block_after(this->first_block());
+ return (cell)next_allocated_block_after(this->first_block());
}
cell next_object_after(cell scan) {
cell size = ((object*)scan)->size();
object* next = (object*)(scan + size);
- return (cell) next_allocated_block_after(next);
+ return (cell)next_allocated_block_after(next);
}
void clear_mark_bits() { state.clear_mark_bits(); }
}
void promoted_object(object* obj) {
- parent->mark_stack.push_back((cell) obj);
+ parent->mark_stack.push_back((cell)obj);
}
void visited_object(object* obj) {}
memset(dst, 0, size);
else {
uint16_t* start = (uint16_t*)dst;
- uint16_t* end = (uint16_t*)((cell) dst + size);
+ uint16_t* end = (uint16_t*)((cell)dst + size);
while (start < end) {
*start = pattern;
start++;
memset(dst, 0, size);
else {
cell* start = (cell*)dst;
- cell* end = (cell*)((cell) dst + size);
+ cell* end = (cell*)((cell)dst + size);
while (start < end) {
*start = pattern;
start++;
/* the write barrier must be called any time we are potentially storing a
pointer from an older generation to a younger one */
inline void write_barrier(cell* slot_ptr) {
- *(char*)(cards_offset + ((cell) slot_ptr >> card_bits)) = card_mark_mask;
- *(char*)(decks_offset + ((cell) slot_ptr >> deck_bits)) = card_mark_mask;
+ *(char*)(cards_offset + ((cell)slot_ptr >> card_bits)) = card_mark_mask;
+ *(char*)(decks_offset + ((cell)slot_ptr >> deck_bits)) = card_mark_mask;
}
inline void write_barrier(object* obj, cell size) {
- cell start = (cell) obj & (~card_size + 1);
- cell end = ((cell) obj + size + card_size - 1) & (~card_size + 1);
+ cell start = (cell)obj & (~card_size + 1);
+ cell end = ((cell)obj + size + card_size - 1) & (~card_size + 1);
for (cell offset = start; offset < end; offset += card_size)
write_barrier((cell*)offset);
inline void check_data_pointer(object* pointer) {
FACTOR_ASSERT((current_gc && current_gc->op == collect_growing_heap_op) ||
- data->seg->in_segment_p((cell) pointer));
+ data->seg->in_segment_p((cell)pointer));
}
// generic arrays
data_root<word> w(ctx->pop(), this);
w.untag_check(this);
- ctx->push(from_unsigned_cell((cell) w->entry_point));
- ctx->push(from_unsigned_cell((cell) w->code() + w->code()->size()));
+ ctx->push(from_unsigned_cell((cell)w->entry_point));
+ ctx->push(from_unsigned_cell((cell)w->code() + w->code()->size()));
}
void factor_vm::primitive_optimized_p() {
projects / factor.git / commitdiff