floatOop as_floatOop(float value) { union { float f; uint32 i; } x; x.f = value; uint32 i = x.i; int32 exp = i >> expOffset & nthMask(expSize); int32 selfExp = exp - bias + selfBias; int32 fract = i & nthMask(fractSize); int32 r = (i & (nthMask(signSize) << signOffset)) | Float_Tag; if (selfExp <= 0) { // underflow - round towards zero } else if (selfExp >= nthMask(selfExpSize)) { if (exp < nthMask(expSize)) { // warning1("converting float %g to Inf", value); r |= nthMask(selfExpSize) << selfExpOffset; } else if (fract == 0) { r |= int32(infinityOop); } else { // NaN r |= (nthMask(selfExpSize) << selfExpOffset) | (fract << Tag_Size); } } else { r |= (selfExp << selfExpOffset) | (fract << Tag_Size); } return floatOop(r); }
void BitVector::addFromTo(int32 first, int32 last) { // mark bits [first..last] assert(first >= 0 && first < length, "wrong index"); assert(last >= 0 && last < length, "wrong index"); fint startIndex = indexFromNumber(first); fint endIndex = indexFromNumber(last); if (startIndex == endIndex) { assert(last - first < BitsPerWord, "oops"); int32 mask = nthMask(last - first + 1); bits[startIndex] |= mask << offsetFromNumber(first); } else { bits[startIndex] |= AllBits << offsetFromNumber(first); for (fint i = startIndex + 1; i < endIndex; i++) bits[i] = AllBits; bits[endIndex] |= nthMask(offsetFromNumber(last) + 1); } # if GENERATE_DEBUGGING_AIDS if (CheckAssertions) for (fint i = first; i <= last; i++) assert(includes(i), "bit should be set"); # endif }
oop* oldSpace::object_start(oop* p) { // Find the page start oop* q = p; int b = (int) q; clearBits(b, nthMask(card_shift)); q = (oop*) b; assert(contains(q), "q must be in this space"); int index = (q - bottom()) / card_size_in_oops; int offset = offset_array[index--]; while(offset == card_size_in_oops) { q -= card_size_in_oops; offset = offset_array[index--]; } q -= offset; oop* n = q; assert((*n)->is_mark(), "check for header"); while (n <= p) { q = n; n += as_memOop(n)->size(); } assert( as_memOop(q)->mark()->is_mark(), "Must be mark"); return q; }
float floatOopClass::value() { uint32 i = uint32(this); int32 selfExp = i >> selfExpOffset & nthMask(selfExpSize); int32 fract = i >> Tag_Size & nthMask(fractSize); int32 exp = selfExp - selfBias + bias; int32 r = i & (nthMask(signSize) << signOffset); if (selfExp == 0) { assert(fract == 0, "self float is denormalized"); // zero } else if (selfExp >= nthMask(selfExpSize)) { if (fract == 0) { r |= nthMask(expSize) << expOffset; // infinity } else { r |= (nthMask(expSize) << expOffset) | fract; // NaN } } else { r |= (exp << expOffset) | fract; } union { float f; uint32 i; } x; x.i = r; return x.f; }
# include "_scopeDescRecorder.cpp.incl" # if defined(FAST_COMPILER) || defined(SIC_COMPILER) # define INITIAL_SLOT_SIZE 10 # define INITIAL_EXPR_SIZE 10 # define INITIAL_BLOCK_SIZE 10 # define INITIAL_OOPS_SIZE 100 # define INITIAL_VALUES_SIZE 100 const u_char nameDescHeaderByte::code_width = 2; const u_char nameDescHeaderByte::index_width = 5; const u_char nameDescHeaderByte::hasId_bit_num = code_width+index_width; const u_char nameDescHeaderByte::max_code = nthMask(code_width); const u_char nameDescHeaderByte::illegal_value = nthMask(BitsPerByte); const u_char nameDescHeaderByte::no_index = nthMask(index_width) - 1; const u_char nameDescHeaderByte::max_index = nthMask(index_width) - 2; const u_char scopeDescHeaderByte::code_width = 3; const u_char scopeDescHeaderByte::lookup_width = 3; const u_char scopeDescHeaderByte::lite_bit_num = code_width+lookup_width; const u_char scopeDescHeaderByte::nameDescs_bit_num = lite_bit_num+1; const u_char scopeDescHeaderByte::max_code = nthMask(code_width); const u_char scopeDescHeaderByte::max_lookup = nthMask(lookup_width); class Vector: public ResourceObj { public: fint index; fint size;
/* float formats: IEEE_float = { int sign:1; int fract: 23; int exp: 8 } Normally: Self_float = { int sign:1; int fract: 23; int exp: 6; int tag: 2} if FAST_FLOATS is defined Self_float = { int sign:1; int fract: 21; int exp: 8; int tag: 2} */ static const fint fractSize = 23; static const fint expSize = 8; static const fint expOffset = fractSize; # ifdef FAST_FLOATS floatOop infinityOop = floatOop(nthMask(expSize) << expOffset | Float_Tag); # else static const fint signSize = 1; static const fint signOffset = fractSize + expSize; static const fint selfExpSize = fint(expSize - Tag_Size); static const fint selfExpOffset = fint(expOffset + Tag_Size); static const fint bias = nthBit(expSize) / 2 - 1; static const fint selfBias = nthBit(selfExpSize) / 2 - 1; floatOop infinityOop = floatOop(nthMask(selfExpSize) << selfExpOffset | Float_Tag);
inline int32 nmln::hash() { return (int32(this) >> IgnoreBits) & nthMask(MapBits); }