std::vector<int> cartesian_communicator::coordinates(int rk) const { std::vector<int> cbuf(ndims()); BOOST_MPI_CHECK_RESULT(MPI_Cart_coords, (MPI_Comm(*this), rk, cbuf.size(), c_data(cbuf) )); return cbuf; }
address JNI_FastGetField::generate_fast_get_float_field0(BasicType type) { const char *name; switch (type) { case T_FLOAT: name = "jni_fast_GetFloatField"; break; case T_DOUBLE: name = "jni_fast_GetDoubleField"; break; default: ShouldNotReachHere(); } ResourceMark rm; BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE*wordSize); CodeBuffer cbuf(blob); MacroAssembler* masm = new MacroAssembler(&cbuf); address fast_entry = __ pc(); Label label1, label2; AddressLiteral cnt_addrlit(SafepointSynchronize::safepoint_counter_addr()); __ sethi (cnt_addrlit, O3); Address cnt_addr(O3, cnt_addrlit.low10()); __ ld (cnt_addr, G4); __ andcc (G4, 1, G0); __ br (Assembler::notZero, false, Assembler::pn, label1); __ delayed()->srl (O2, 2, O4); __ ld_ptr (O1, 0, O5); assert(count < LIST_CAPACITY, "LIST_CAPACITY too small"); speculative_load_pclist[count] = __ pc(); switch (type) { case T_FLOAT: __ ldf (FloatRegisterImpl::S, O5, O4, F0); break; case T_DOUBLE: __ ldf (FloatRegisterImpl::D, O5, O4, F0); break; default: ShouldNotReachHere(); } __ ld (cnt_addr, O5); __ cmp (O5, G4); __ br (Assembler::notEqual, false, Assembler::pn, label2); __ delayed()->mov (O7, G1); __ retl (); __ delayed()-> nop (); slowcase_entry_pclist[count++] = __ pc(); __ bind (label1); __ mov (O7, G1); address slow_case_addr; switch (type) { case T_FLOAT: slow_case_addr = jni_GetFloatField_addr(); break; case T_DOUBLE: slow_case_addr = jni_GetDoubleField_addr(); break; default: ShouldNotReachHere(); } __ bind (label2); __ call (slow_case_addr, relocInfo::none); __ delayed()->mov (G1, O7); __ flush (); return fast_entry; }
Lng32 UnicodeStringToLocale(Lng32 charset, const NAWchar* wstr, Lng32 wstrLen, char* buf, Lng32 bufLen, NABoolean addNullAtEnd, NABoolean allowInvalidCodePoint) { charBuf cbuf((unsigned char*)buf, bufLen); charBuf* cbufPtr = &cbuf; charBuf* res = 0; Int32 errorcode = 0; switch (charset) { #ifdef IS_MP /* :cnu -- As of 8/30/2011, not used in SQ SQL */ case CharInfo::KANJI_MP: res = unicodeToSjis( NAWcharBuf((NAWchar*)wstr, wstrLen), 0, cbufPtr, addNullAtEnd, allowInvalidCodePoint ); break; case CharInfo::KSC5601_MP: res = unicodeToKsc5601( NAWcharBuf((NAWchar*)wstr, wstrLen), 0, cbufPtr, addNullAtEnd, allowInvalidCodePoint ); break; #endif case CharInfo::ISO88591: res = unicodeToISO88591( NAWcharBuf((NAWchar*)wstr, wstrLen), 0, cbufPtr, addNullAtEnd, allowInvalidCodePoint ); break; // case CharInfo::ISO88591: case CharInfo::EUCJP: case CharInfo::GB18030: case CharInfo::GB2312: case CharInfo::GBK: case CharInfo::KSC5601: case CharInfo::BIG5: case CharInfo::UTF8: case CharInfo::SJIS: res = unicodeTocset( NAWcharBuf((NAWchar*)wstr, wstrLen), 0, cbufPtr, charset, errorcode, addNullAtEnd, allowInvalidCodePoint ); break; default: break; } return (res) ? res->getStrLen() : 0; }
bool NativeInstruction::is_ic_miss_trap() { if (ic_miss_trap_bits == 0) { ResourceMark rm; char buf[40]; CodeBuffer cbuf((address)&buf[0], 20); MacroAssembler* a = new MacroAssembler(&cbuf); address ia = a->pc(); a->trap(Assembler::notEqual, Assembler::ptr_cc, G0, ST_RESERVED_FOR_USER_0 + 2); int bits = *(int*)ia; assert(is_op3(bits, Assembler::trap_op3, Assembler::arith_op), "bad instruction"); ic_miss_trap_bits = bits; assert(ic_miss_trap_bits != 0, "oops"); } return long_at(0) == ic_miss_trap_bits; }
int NativeInstruction::illegal_instruction() { if (illegal_instruction_bits == 0) { ResourceMark rm; char buf[40]; CodeBuffer cbuf((address)&buf[0], 20); MacroAssembler* a = new MacroAssembler(&cbuf); address ia = a->pc(); a->trap(ST_RESERVED_FOR_USER_0 + 1); int bits = *(int*)ia; assert(is_op3(bits, Assembler::trap_op3, Assembler::arith_op), "bad instruction"); illegal_instruction_bits = bits; assert(illegal_instruction_bits != 0, "oops"); } return illegal_instruction_bits; }
inline void _debugOut(const char* msg, TransliterationRule* rule, const Replaceable& theText, UTransPosition& pos) { UnicodeString buf(msg, ""); if (rule) { UnicodeString r; rule->toRule(r, TRUE); buf.append((UChar)32).append(r); } buf.append(UnicodeString(" => ", "")); UnicodeString* text = (UnicodeString*)&theText; _formatInput(buf, *text, pos); UnicodeString esc; _escape(buf, esc); CharString cbuf(esc); printf("%s\n", (const char*) cbuf); }
gsgl::index_t ft_stream::write(const wchar_t *buf, const gsgl::index_t num) { if (mode & FILE_OPEN_WRITE) { /// \todo Implement UTF-8 for file streams. data::smart_pointer<char, true> cbuf (new char[num+1]); for (int i = 0; i < num; ++i) cbuf[i] = (char) buf[i]; return (gsgl::index_t) ::fwrite(cbuf, 1, num, static_cast<FILE *>(fp)); } else { throw io_exception(L"cannot write to a read-only file"); } } // ft_stream::write()
gsgl::index_t ft_stream::read(wchar_t *buf, const gsgl::index_t num) { if (mode & FILE_OPEN_READ) { /// \todo Implement UTF-8 for file streams. data::smart_pointer<char, true> cbuf(new char[num+1]); int num_read = (gsgl::index_t) ::fread(cbuf, 1, num, static_cast<FILE *>(fp)); for (int i = 0; i < num_read; ++i) buf[i] = cbuf[i]; return num_read; } else { throw io_exception(L"cannot read from a write-only file"); } } // ft_stream::read()
bool nsWindowsSystemProxySettings::MatchOverride(const nsACString& aHost) { nsresult rv; uint32_t flags = 0; nsAutoString buf; rv = ReadInternetOption(INTERNET_PER_CONN_PROXY_BYPASS, flags, buf); if (NS_FAILED(rv)) return false; NS_ConvertUTF16toUTF8 cbuf(buf); nsAutoCString host(aHost); int32_t start = 0; int32_t end = cbuf.Length(); // Windows formats its proxy override list in the form: // server;server;server where 'server' is a server name pattern or IP // address, or "<local>". "<local>" must be translated to // "localhost;127.0.0.1". // In a server name pattern, a '*' character matches any substring and // all other characters must match themselves; the whole pattern must match // the whole hostname. while (true) { int32_t delimiter = cbuf.FindCharInSet(" ;", start); if (delimiter == -1) delimiter = end; if (delimiter != start) { const nsAutoCString override(Substring(cbuf, start, delimiter - start)); if (override.EqualsLiteral("<local>")) { // This override matches local addresses. if (host.EqualsLiteral("localhost") || host.EqualsLiteral("127.0.0.1")) return true; } else if (PatternMatch(host, override)) { return true; } } if (delimiter == end) break; start = ++delimiter; }
PRBool nsWindowsSystemProxySettings::MatchOverride(const nsACString& aHost) { nsresult rv; nsAutoString buf; rv = mKey->ReadStringValue(NS_LITERAL_STRING("ProxyOverride"), buf); if (NS_FAILED(rv)) return PR_FALSE; NS_ConvertUTF16toUTF8 cbuf(buf); nsCAutoString host(aHost); PRInt32 start = 0; PRInt32 end = cbuf.Length(); // Windows formats its proxy override list in the form: // server;server;server where 'server' is a server name pattern or IP // address, or "<local>". "<local>" must be translated to // "localhost;127.0.0.1". // In a server name pattern, a '*' character matches any substring and // all other characters must match themselves; the whole pattern must match // the whole hostname. while (true) { PRInt32 delimiter = cbuf.FindCharInSet(" ;", start); if (delimiter == -1) delimiter = end; if (delimiter != start) { const nsCAutoString override(Substring(cbuf, start, delimiter - start)); if (override.EqualsLiteral("<local>")) { // This override matches local addresses. if (host.EqualsLiteral("localhost") || host.EqualsLiteral("127.0.0.1")) return PR_TRUE; } else if (PatternMatch(host, override)) { return PR_TRUE; } } if (delimiter == end) break; start = ++delimiter; }
void compute_bbox(MRI_SURFACE* mris, tDblCoords& cmin, tDblCoords& cmax, bool initVars) { tDblCoords cbuf; VERTEX* pvtx = &( mris->vertices[0] ); unsigned int nvertices = (unsigned int)mris->nvertices; cbuf(0) = pvtx->x; cbuf(1) = pvtx->y; cbuf(2) = pvtx->z; if ( initVars ) { cmin = cbuf; cmax = cbuf; } else { cmin = min(cmin, cbuf); cmax = max(cmax, cbuf); } ++pvtx; for ( unsigned int ui = 1; ui < nvertices; ++ui, ++pvtx ) { cbuf(0) = pvtx->x; cbuf(1) = pvtx->y; cbuf(2) = pvtx->z; cmin = min(cmin, cbuf); cmax = max(cmax, cbuf); } // next ui, pvtx }
address JNI_FastGetField::generate_fast_get_int_field0(BasicType type) { const char *name; switch (type) { case T_BOOLEAN: name = "jni_fast_GetBooleanField"; break; case T_BYTE: name = "jni_fast_GetByteField"; break; case T_CHAR: name = "jni_fast_GetCharField"; break; case T_SHORT: name = "jni_fast_GetShortField"; break; case T_INT: name = "jni_fast_GetIntField"; break; case T_LONG: name = "jni_fast_GetLongField"; break; case T_FLOAT: name = "jni_fast_GetFloatField"; break; case T_DOUBLE: name = "jni_fast_GetDoubleField"; break; default: ShouldNotReachHere(); } ResourceMark rm; BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE); CodeBuffer cbuf(blob); MacroAssembler* masm = new MacroAssembler(&cbuf); address fast_entry = __ pc(); Label slow; unsigned long offset; __ adrp(rcounter_addr, SafepointSynchronize::safepoint_counter_addr(), offset); Address safepoint_counter_addr(rcounter_addr, offset); __ ldrw(rcounter, safepoint_counter_addr); __ andw(rscratch1, rcounter, 1); __ cbnzw(rscratch1, slow); __ eor(robj, c_rarg1, rcounter); __ eor(robj, robj, rcounter); // obj, since // robj ^ rcounter ^ rcounter == robj // robj is address dependent on rcounter. __ ldr(robj, Address(robj, 0)); // *obj __ lsr(roffset, c_rarg2, 2); // offset assert(count < LIST_CAPACITY, "LIST_CAPACITY too small"); speculative_load_pclist[count] = __ pc(); // Used by the segfault handler switch (type) { case T_BOOLEAN: __ ldrb (result, Address(robj, roffset)); break; case T_BYTE: __ ldrsb (result, Address(robj, roffset)); break; case T_CHAR: __ ldrh (result, Address(robj, roffset)); break; case T_SHORT: __ ldrsh (result, Address(robj, roffset)); break; case T_FLOAT: __ ldrw (result, Address(robj, roffset)); break; case T_INT: __ ldrsw (result, Address(robj, roffset)); break; case T_DOUBLE: case T_LONG: __ ldr (result, Address(robj, roffset)); break; default: ShouldNotReachHere(); } // counter_addr is address dependent on result. __ eor(rcounter_addr, rcounter_addr, result); __ eor(rcounter_addr, rcounter_addr, result); __ ldrw(rscratch1, safepoint_counter_addr); __ cmpw(rcounter, rscratch1); __ br (Assembler::NE, slow); switch (type) { case T_FLOAT: __ fmovs(v0, result); break; case T_DOUBLE: __ fmovd(v0, result); break; default: __ mov(r0, result); break; } __ ret(lr); slowcase_entry_pclist[count++] = __ pc(); __ bind(slow); address slow_case_addr; switch (type) { case T_BOOLEAN: slow_case_addr = jni_GetBooleanField_addr(); break; case T_BYTE: slow_case_addr = jni_GetByteField_addr(); break; case T_CHAR: slow_case_addr = jni_GetCharField_addr(); break; case T_SHORT: slow_case_addr = jni_GetShortField_addr(); break; case T_INT: slow_case_addr = jni_GetIntField_addr(); break; case T_LONG: slow_case_addr = jni_GetLongField_addr(); break; case T_FLOAT: slow_case_addr = jni_GetFloatField_addr(); break; case T_DOUBLE: slow_case_addr = jni_GetDoubleField_addr(); break; default: ShouldNotReachHere(); } { __ enter(); __ lea(rscratch1, ExternalAddress(slow_case_addr)); __ blr(rscratch1); __ maybe_isb(); __ leave(); __ ret(lr); } __ flush (); return fast_entry; }
address JNI_FastGetField::generate_fast_get_long_field() { const char *name = "jni_fast_GetLongField"; ResourceMark rm; BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE*wordSize); CodeBuffer cbuf(blob); MacroAssembler* masm = new MacroAssembler(&cbuf); address fast_entry = __ pc(); Label label1, label2; AddressLiteral cnt_addrlit(SafepointSynchronize::safepoint_counter_addr()); __ sethi (cnt_addrlit, G3); Address cnt_addr(G3, cnt_addrlit.low10()); __ ld (cnt_addr, G4); __ andcc (G4, 1, G0); __ br (Assembler::notZero, false, Assembler::pn, label1); __ delayed()->srl (O2, 2, O4); __ ld_ptr (O1, 0, O5); __ add (O5, O4, O5); #ifndef _LP64 assert(count < LIST_CAPACITY-1, "LIST_CAPACITY too small"); speculative_load_pclist[count++] = __ pc(); __ ld (O5, 0, G2); speculative_load_pclist[count] = __ pc(); __ ld (O5, 4, O3); #else assert(count < LIST_CAPACITY, "LIST_CAPACITY too small"); speculative_load_pclist[count] = __ pc(); __ ldx (O5, 0, O3); #endif __ ld (cnt_addr, G1); __ cmp (G1, G4); __ br (Assembler::notEqual, false, Assembler::pn, label2); __ delayed()->mov (O7, G1); #ifndef _LP64 __ mov (G2, O0); __ retl (); __ delayed()->mov (O3, O1); #else __ retl (); __ delayed()->mov (O3, O0); #endif #ifndef _LP64 slowcase_entry_pclist[count-1] = __ pc(); slowcase_entry_pclist[count++] = __ pc() ; #else slowcase_entry_pclist[count++] = __ pc(); #endif __ bind (label1); __ mov (O7, G1); address slow_case_addr = jni_GetLongField_addr(); __ bind (label2); __ call (slow_case_addr, relocInfo::none); __ delayed()->mov (G1, O7); __ flush (); return fast_entry; }
int cbuf9(int f, int n) { return cbuf(f, n, 9); }
int cbuf10(int f, int n) { return cbuf(f, n, 10); }
address JNI_FastGetField::generate_fast_get_int_field0(BasicType type) { const char *name; switch (type) { case T_BOOLEAN: name = "jni_fast_GetBooleanField"; break; case T_BYTE: name = "jni_fast_GetByteField"; break; case T_CHAR: name = "jni_fast_GetCharField"; break; case T_SHORT: name = "jni_fast_GetShortField"; break; case T_INT: name = "jni_fast_GetIntField"; break; default: ShouldNotReachHere(); } ResourceMark rm; BufferBlob* b = BufferBlob::create(name, BUFFER_SIZE*wordSize); address fast_entry = b->instructions_begin(); CodeBuffer cbuf(fast_entry, b->instructions_size()); MacroAssembler* masm = new MacroAssembler(&cbuf); Label slow; // stack layout: offset from rsp (in words): // return pc 0 // jni env 1 // obj 2 // jfieldID 3 ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr()); __ mov32 (rcx, counter); __ testb (rcx, 1); __ jcc (Assembler::notZero, slow); if (os::is_MP()) { __ mov(rax, rcx); __ andptr(rax, 1); // rax, must end up 0 __ movptr(rdx, Address(rsp, rax, Address::times_1, 2*wordSize)); // obj, notice rax, is 0. // rdx is data dependent on rcx. } else { __ movptr (rdx, Address(rsp, 2*wordSize)); // obj } __ movptr(rax, Address(rsp, 3*wordSize)); // jfieldID __ movptr(rdx, Address(rdx, 0)); // *obj __ shrptr (rax, 2); // offset assert(count < LIST_CAPACITY, "LIST_CAPACITY too small"); speculative_load_pclist[count] = __ pc(); switch (type) { case T_BOOLEAN: __ movzbl (rax, Address(rdx, rax, Address::times_1)); break; case T_BYTE: __ movsbl (rax, Address(rdx, rax, Address::times_1)); break; case T_CHAR: __ movzwl (rax, Address(rdx, rax, Address::times_1)); break; case T_SHORT: __ movswl (rax, Address(rdx, rax, Address::times_1)); break; case T_INT: __ movl (rax, Address(rdx, rax, Address::times_1)); break; default: ShouldNotReachHere(); } Address ca1; if (os::is_MP()) { __ lea(rdx, counter); __ xorptr(rdx, rax); __ xorptr(rdx, rax); __ cmp32(rcx, Address(rdx, 0)); // ca1 is the same as ca because // rax, ^ counter_addr ^ rax, = address // ca1 is data dependent on rax,. } else { __ cmp32(rcx, counter); } __ jcc (Assembler::notEqual, slow); #ifndef _WINDOWS __ ret (0); #else // __stdcall calling convention __ ret (3*wordSize); #endif slowcase_entry_pclist[count++] = __ pc(); __ bind (slow); address slow_case_addr; switch (type) { case T_BOOLEAN: slow_case_addr = jni_GetBooleanField_addr(); break; case T_BYTE: slow_case_addr = jni_GetByteField_addr(); break; case T_CHAR: slow_case_addr = jni_GetCharField_addr(); break; case T_SHORT: slow_case_addr = jni_GetShortField_addr(); break; case T_INT: slow_case_addr = jni_GetIntField_addr(); } // tail call __ jump (ExternalAddress(slow_case_addr)); __ flush (); #ifndef _WINDOWS return fast_entry; #else switch (type) { case T_BOOLEAN: jni_fast_GetBooleanField_fp = (GetBooleanField_t)fast_entry; break; case T_BYTE: jni_fast_GetByteField_fp = (GetByteField_t)fast_entry; break; case T_CHAR: jni_fast_GetCharField_fp = (GetCharField_t)fast_entry; break; case T_SHORT: jni_fast_GetShortField_fp = (GetShortField_t)fast_entry; break; case T_INT: jni_fast_GetIntField_fp = (GetIntField_t)fast_entry; } return os::win32::fast_jni_accessor_wrapper(type); #endif }
int cbuf39(int f, int n) { return cbuf(f, n, 39); }
int cbuf5(int f, int n) { return cbuf(f, n, 5); }
int cbuf6(int f, int n) { return cbuf(f, n, 6); }
int cbuf37(int f, int n) { return cbuf(f, n, 37); }
int cbuf4(int f, int n) { return cbuf(f, n, 4); }
int cbuf2(int f, int n) { return cbuf(f, n, 2); }
int cbuf1(int f, int n) { return cbuf(f, n, 1); }
int cbuf40(int f, int n) { return cbuf(f, n, 40); }
address JNI_FastGetField::generate_fast_get_long_field() { const char *name = "jni_fast_GetLongField"; ResourceMark rm; BufferBlob* b = BufferBlob::create(name, BUFFER_SIZE*wordSize); address fast_entry = b->instructions_begin(); CodeBuffer cbuf(fast_entry, b->instructions_size()); MacroAssembler* masm = new MacroAssembler(&cbuf); Label slow; // stack layout: offset from rsp (in words): // old rsi 0 // return pc 1 // jni env 2 // obj 3 // jfieldID 4 ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr()); __ push (rsi); __ mov32 (rcx, counter); __ testb (rcx, 1); __ jcc (Assembler::notZero, slow); if (os::is_MP()) { __ mov(rax, rcx); __ andptr(rax, 1); // rax, must end up 0 __ movptr(rdx, Address(rsp, rax, Address::times_1, 3*wordSize)); // obj, notice rax, is 0. // rdx is data dependent on rcx. } else { __ movptr(rdx, Address(rsp, 3*wordSize)); // obj } __ movptr(rsi, Address(rsp, 4*wordSize)); // jfieldID __ movptr(rdx, Address(rdx, 0)); // *obj __ shrptr(rsi, 2); // offset assert(count < LIST_CAPACITY-1, "LIST_CAPACITY too small"); speculative_load_pclist[count++] = __ pc(); __ movptr(rax, Address(rdx, rsi, Address::times_1)); #ifndef _LP64 speculative_load_pclist[count] = __ pc(); __ movl(rdx, Address(rdx, rsi, Address::times_1, 4)); #endif // _LP64 if (os::is_MP()) { __ lea(rsi, counter); __ xorptr(rsi, rdx); __ xorptr(rsi, rax); __ xorptr(rsi, rdx); __ xorptr(rsi, rax); __ cmp32(rcx, Address(rsi, 0)); // ca1 is the same as ca because // rax, ^ rdx ^ counter_addr ^ rax, ^ rdx = address // ca1 is data dependent on both rax, and rdx. } else { __ cmp32(rcx, counter); } __ jcc (Assembler::notEqual, slow); __ pop (rsi); #ifndef _WINDOWS __ ret (0); #else // __stdcall calling convention __ ret (3*wordSize); #endif slowcase_entry_pclist[count-1] = __ pc(); slowcase_entry_pclist[count++] = __ pc(); __ bind (slow); __ pop (rsi); address slow_case_addr = jni_GetLongField_addr();; // tail call __ jump (ExternalAddress(slow_case_addr)); __ flush (); #ifndef _WINDOWS return fast_entry; #else jni_fast_GetLongField_fp = (GetLongField_t)fast_entry; return os::win32::fast_jni_accessor_wrapper(T_LONG); #endif }
int cbuf7(int f, int n) { return cbuf(f, n, 7); }
address JNI_FastGetField::generate_fast_get_float_field0(BasicType type) { const char *name; switch (type) { case T_FLOAT: name = "jni_fast_GetFloatField"; break; case T_DOUBLE: name = "jni_fast_GetDoubleField"; break; default: ShouldNotReachHere(); } ResourceMark rm; BufferBlob* b = BufferBlob::create(name, BUFFER_SIZE*wordSize); address fast_entry = b->instructions_begin(); CodeBuffer cbuf(fast_entry, b->instructions_size()); MacroAssembler* masm = new MacroAssembler(&cbuf); Label slow_with_pop, slow; // stack layout: offset from rsp (in words): // return pc 0 // jni env 1 // obj 2 // jfieldID 3 ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr()); __ mov32 (rcx, counter); __ testb (rcx, 1); __ jcc (Assembler::notZero, slow); if (os::is_MP()) { __ mov(rax, rcx); __ andptr(rax, 1); // rax, must end up 0 __ movptr(rdx, Address(rsp, rax, Address::times_1, 2*wordSize)); // obj, notice rax, is 0. // rdx is data dependent on rcx. } else { __ movptr(rdx, Address(rsp, 2*wordSize)); // obj } __ movptr(rax, Address(rsp, 3*wordSize)); // jfieldID __ movptr(rdx, Address(rdx, 0)); // *obj __ shrptr(rax, 2); // offset assert(count < LIST_CAPACITY, "LIST_CAPACITY too small"); speculative_load_pclist[count] = __ pc(); switch (type) { #ifndef _LP64 case T_FLOAT: __ fld_s (Address(rdx, rax, Address::times_1)); break; case T_DOUBLE: __ fld_d (Address(rdx, rax, Address::times_1)); break; #else case T_FLOAT: __ movflt (xmm0, Address(robj, roffset, Address::times_1)); break; case T_DOUBLE: __ movdbl (xmm0, Address(robj, roffset, Address::times_1)); break; #endif // _LP64 default: ShouldNotReachHere(); } Address ca1; if (os::is_MP()) { __ fst_s (Address(rsp, -4)); __ lea(rdx, counter); __ movl (rax, Address(rsp, -4)); // garbage hi-order bits on 64bit are harmless. __ xorptr(rdx, rax); __ xorptr(rdx, rax); __ cmp32(rcx, Address(rdx, 0)); // rax, ^ counter_addr ^ rax, = address // ca1 is data dependent on the field // access. } else { __ cmp32(rcx, counter); } __ jcc (Assembler::notEqual, slow_with_pop); #ifndef _WINDOWS __ ret (0); #else // __stdcall calling convention __ ret (3*wordSize); #endif __ bind (slow_with_pop); // invalid load. pop FPU stack. __ fstp_d (0); slowcase_entry_pclist[count++] = __ pc(); __ bind (slow); address slow_case_addr; switch (type) { case T_FLOAT: slow_case_addr = jni_GetFloatField_addr(); break; case T_DOUBLE: slow_case_addr = jni_GetDoubleField_addr(); break; default: ShouldNotReachHere(); } // tail call __ jump (ExternalAddress(slow_case_addr)); __ flush (); #ifndef _WINDOWS return fast_entry; #else switch (type) { case T_FLOAT: jni_fast_GetFloatField_fp = (GetFloatField_t)fast_entry; break; case T_DOUBLE: jni_fast_GetDoubleField_fp = (GetDoubleField_t)fast_entry; } return os::win32::fast_jni_accessor_wrapper(type); #endif }
int cbuf8(int f, int n) { return cbuf(f, n, 8); }
int cbuf3(int f, int n) { return cbuf(f, n, 3); }
int cbuf38(int f, int n) { return cbuf(f, n, 38); }