Mercurial > hg > truffle
changeset 6089:785573170238 hs24-b12
Merge
| author | amurillo |
|---|---|
| date | Fri, 25 May 2012 14:45:35 -0700 |
| parents | 48064e53e997 (current diff) 7089278210e2 (diff) |
| children | 37add4fa0296 |
| files | |
| diffstat | 62 files changed, 1443 insertions(+), 609 deletions(-) [+] |
line wrap: on
line diff
--- a/agent/src/share/classes/sun/jvm/hotspot/HotSpotAgent.java Thu May 24 16:15:37 2012 -0700 +++ b/agent/src/share/classes/sun/jvm/hotspot/HotSpotAgent.java Fri May 25 14:45:35 2012 -0700 @@ -572,10 +572,10 @@ if (cpu.equals("x86")) { machDesc = new MachineDescriptionIntelX86(); - } else if (cpu.equals("amd64")) { + } else if (cpu.equals("amd64") || cpu.equals("x86_64")) { machDesc = new MachineDescriptionAMD64(); } else { - throw new DebuggerException("BSD only supported on x86/amd64"); + throw new DebuggerException("BSD only supported on x86/x86_64. Current arch: " + cpu); } BsdDebuggerLocal dbg = new BsdDebuggerLocal(machDesc, !isServer);
--- a/agent/src/share/classes/sun/jvm/hotspot/bugspot/BugSpotAgent.java Thu May 24 16:15:37 2012 -0700 +++ b/agent/src/share/classes/sun/jvm/hotspot/bugspot/BugSpotAgent.java Fri May 25 14:45:35 2012 -0700 @@ -762,10 +762,10 @@ if (cpu.equals("x86")) { machDesc = new MachineDescriptionIntelX86(); - } else if (cpu.equals("amd64")) { + } else if (cpu.equals("amd64") || (cpu.equals("x86_64"))) { machDesc = new MachineDescriptionAMD64(); } else { - throw new DebuggerException("Bsd only supported on x86/amd64"); + throw new DebuggerException("Bsd only supported on x86/x86_64. Current arch: " + cpu); } // Note we do not use a cache for the local debugger in server
--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/BsdCDebugger.java Thu May 24 16:15:37 2012 -0700 +++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/BsdCDebugger.java Fri May 25 14:45:35 2012 -0700 @@ -90,7 +90,7 @@ Address pc = context.getRegisterAsAddress(X86ThreadContext.EIP); if (pc == null) return null; return new BsdX86CFrame(dbg, ebp, pc); - } else if (cpu.equals("amd64")) { + } else if (cpu.equals("amd64") || cpu.equals("x86_64")) { AMD64ThreadContext context = (AMD64ThreadContext) thread.getContext(); Address rbp = context.getRegisterAsAddress(AMD64ThreadContext.RBP); if (rbp == null) return null;
--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/BsdThreadContextFactory.java Thu May 24 16:15:37 2012 -0700 +++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/BsdThreadContextFactory.java Fri May 25 14:45:35 2012 -0700 @@ -33,7 +33,7 @@ String cpu = dbg.getCPU(); if (cpu.equals("x86")) { return new BsdX86ThreadContext(dbg); - } else if (cpu.equals("amd64")) { + } else if (cpu.equals("amd64") || cpu.equals("x86_64")) { return new BsdAMD64ThreadContext(dbg); } else { throw new RuntimeException("cpu " + cpu + " is not yet supported");
--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcDebuggerLocal.java Thu May 24 16:15:37 2012 -0700 +++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcDebuggerLocal.java Fri May 25 14:45:35 2012 -0700 @@ -81,7 +81,7 @@ pcRegIndex = X86ThreadContext.EIP; fpRegIndex = X86ThreadContext.EBP; unalignedAccessesOkay = true; - } else if (cpu.equals("amd64")) { + } else if (cpu.equals("amd64") || cpu.equals("x86_64")) { threadFactory = new ProcAMD64ThreadFactory(this); pcRegIndex = AMD64ThreadContext.RIP; fpRegIndex = AMD64ThreadContext.RBP;
--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteDebuggerClient.java Thu May 24 16:15:37 2012 -0700 +++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteDebuggerClient.java Fri May 25 14:45:35 2012 -0700 @@ -64,7 +64,7 @@ cachePageSize = 4096; cacheNumPages = parseCacheNumPagesProperty(cacheSize / cachePageSize); unalignedAccessesOkay = true; - } else if (cpu.equals("amd64")) { + } else if (cpu.equals("amd64") || cpu.equals("x86_64")) { threadFactory = new RemoteAMD64ThreadFactory(this); cachePageSize = 4096; cacheNumPages = parseCacheNumPagesProperty(cacheSize / cachePageSize);
--- a/agent/src/share/classes/sun/jvm/hotspot/runtime/Threads.java Thu May 24 16:15:37 2012 -0700 +++ b/agent/src/share/classes/sun/jvm/hotspot/runtime/Threads.java Fri May 25 14:45:35 2012 -0700 @@ -95,7 +95,7 @@ } else if (os.equals("bsd")) { if (cpu.equals("x86")) { access = new BsdX86JavaThreadPDAccess(); - } else if (cpu.equals("amd64")) { + } else if (cpu.equals("amd64") || cpu.equals("x86_64")) { access = new BsdAMD64JavaThreadPDAccess(); } }
--- a/agent/src/share/classes/sun/jvm/hotspot/ui/classbrowser/HTMLGenerator.java Thu May 24 16:15:37 2012 -0700 +++ b/agent/src/share/classes/sun/jvm/hotspot/ui/classbrowser/HTMLGenerator.java Fri May 25 14:45:35 2012 -0700 @@ -199,7 +199,7 @@ cpuHelper = new SPARCHelper(); } else if (cpu.equals("x86")) { cpuHelper = new X86Helper(); - } else if (cpu.equals("amd64")) { + } else if (cpu.equals("amd64") || cpu.equals("x86_64")) { cpuHelper = new AMD64Helper(); } else if (cpu.equals("ia64")) { cpuHelper = new IA64Helper();
--- a/agent/src/share/classes/sun/jvm/hotspot/utilities/soql/JSJavaFrame.java Thu May 24 16:15:37 2012 -0700 +++ b/agent/src/share/classes/sun/jvm/hotspot/utilities/soql/JSJavaFrame.java Fri May 25 14:45:35 2012 -0700 @@ -153,7 +153,8 @@ List visibleVars = new ArrayList(0); for (int i = 0; i < localVars.length; i++) { LocalVariableTableElement cur = localVars[i]; - if (cur.getStartBCI() >= bci && cur.getLength() > 0) { + int startBCI = cur.getStartBCI(); + if (startBCI <= bci && bci < startBCI + cur.getLength()) { visibleVars.add(cur); } }
--- a/make/hotspot_version Thu May 24 16:15:37 2012 -0700 +++ b/make/hotspot_version Fri May 25 14:45:35 2012 -0700 @@ -35,7 +35,7 @@ HS_MAJOR_VER=24 HS_MINOR_VER=0 -HS_BUILD_NUMBER=11 +HS_BUILD_NUMBER=12 JDK_MAJOR_VER=1 JDK_MINOR_VER=8
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/make/solaris/makefiles/add_gnu_debuglink.make Fri May 25 14:45:35 2012 -0700 @@ -0,0 +1,51 @@ +# +# Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# +# + +# Rules to build add_gnu_debuglink, used by vm.make on Solaris + +GENERATED = ../generated +ADD_GNU_DEBUGLINK = $(GENERATED)/add_gnu_debuglink + +ADD_GNU_DEBUGLINK_DIR = $(GAMMADIR)/src/os/solaris/add_gnu_debuglink +ADD_GNU_DEBUGLINK_SRC = $(ADD_GNU_DEBUGLINK_DIR)/add_gnu_debuglink.c +ADD_GNU_DEBUGLINK_FLAGS = +LIBS_ADD_GNU_DEBUGLINK += -lelf + +ifeq ("${Platform_compiler}", "sparcWorks") +# Enable the following ADD_GNU_DEBUGLINK_FLAGS addition if you need to +# compare the built ELF objects. +# +# The -g option makes static data global and the "-W0,-noglobal" +# option tells the compiler to not globalize static data using a unique +# globalization prefix. Instead force the use of a static globalization +# prefix based on the source filepath so the objects from two identical +# compilations are the same. +# +# Note: The blog says to use "-W0,-xglobalstatic", but that doesn't +# seem to work. I got "-W0,-noglobal" from Kelly and that works. +#ADD_GNU_DEBUGLINK_FLAGS += -W0,-noglobal +endif # Platform_compiler == sparcWorks + +$(ADD_GNU_DEBUGLINK): $(ADD_GNU_DEBUGLINK_SRC) + $(CC) -g -o $@ $< $(ADD_GNU_DEBUGLINK_FLAGS) $(LIBS_ADD_GNU_DEBUGLINK)
--- a/make/solaris/makefiles/defs.make Thu May 24 16:15:37 2012 -0700 +++ b/make/solaris/makefiles/defs.make Fri May 25 14:45:35 2012 -0700 @@ -109,18 +109,12 @@ # overridden in some situations, e.g., a BUILD_FLAVOR != product # build. - # Disable FULL_DEBUG_SYMBOLS by default because dtrace tests are - # failing in nightly when the debug info files are ZIP'ed. On - # Solaris debug info files need to be ZIP'ed to reduce the impact - # on disk space footprint. - FULL_DEBUG_SYMBOLS ?= 0 ifeq ($(BUILD_FLAVOR), product) - # FULL_DEBUG_SYMBOLS ?= 1 + FULL_DEBUG_SYMBOLS ?= 1 ENABLE_FULL_DEBUG_SYMBOLS = $(FULL_DEBUG_SYMBOLS) else # debug variants always get Full Debug Symbols (if available) - # ENABLE_FULL_DEBUG_SYMBOLS = 1 - ENABLE_FULL_DEBUG_SYMBOLS = $(FULL_DEBUG_SYMBOLS) + ENABLE_FULL_DEBUG_SYMBOLS = 1 endif _JUNK_ := $(shell \ echo >&2 "INFO: ENABLE_FULL_DEBUG_SYMBOLS=$(ENABLE_FULL_DEBUG_SYMBOLS)") @@ -178,9 +172,7 @@ _JUNK_ := $(shell \ echo >&2 "INFO: STRIP_POLICY=$(STRIP_POLICY)") - # Disable ZIP_DEBUGINFO_FILES by default because dtrace tests are - # failing in nightly when the debug info files are ZIP'ed. - ZIP_DEBUGINFO_FILES ?= 0 + ZIP_DEBUGINFO_FILES ?= 1 _JUNK_ := $(shell \ echo >&2 "INFO: ZIP_DEBUGINFO_FILES=$(ZIP_DEBUGINFO_FILES)")
--- a/make/solaris/makefiles/vm.make Thu May 24 16:15:37 2012 -0700 +++ b/make/solaris/makefiles/vm.make Fri May 25 14:45:35 2012 -0700 @@ -145,6 +145,10 @@ include $(MAKEFILES_DIR)/dtrace.make #---------------------------------------------------------------------- +# add_gnu_debuglink tool +include $(MAKEFILES_DIR)/add_gnu_debuglink.make + +#---------------------------------------------------------------------- # JVM JVM = jvm @@ -276,7 +280,7 @@ LINK_VM = $(LINK_LIB.CXX) endif # making the library: -$(LIBJVM): $(LIBJVM.o) $(LIBJVM_MAPFILE) +$(LIBJVM): $(ADD_GNU_DEBUGLINK) $(LIBJVM.o) $(LIBJVM_MAPFILE) ifeq ($(filter -sbfast -xsbfast, $(CFLAGS_BROWSE)),) @echo Linking vm... $(QUIETLY) $(LINK_LIB.CXX/PRE_HOOK) @@ -287,7 +291,11 @@ $(QUIETLY) [ -f $(LIBJVM_G).1 ] || ln -s $@.1 $(LIBJVM_G).1 ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1) $(QUIETLY) $(OBJCOPY) --only-keep-debug $@ $(LIBJVM_DEBUGINFO) - $(QUIETLY) $(OBJCOPY) --add-gnu-debuglink=$(LIBJVM_DEBUGINFO) $@ +# $(OBJCOPY) --add-gnu-debuglink=... corrupts the SUNW_dof section +# in libjvm.so. Use $(ADD_GNU_DEBUGLINK) until a fixed $(OBJCOPY) +# is available. +# $(QUIETLY) $(OBJCOPY) --add-gnu-debuglink=$(LIBJVM_DEBUGINFO) $@ + $(QUIETLY) $(ADD_GNU_DEBUGLINK) $(LIBJVM_DEBUGINFO) $@ ifeq ($(STRIP_POLICY),all_strip) $(QUIETLY) $(STRIP) $@ else
--- a/make/windows/makefiles/defs.make Thu May 24 16:15:37 2012 -0700 +++ b/make/windows/makefiles/defs.make Fri May 25 14:45:35 2012 -0700 @@ -145,7 +145,12 @@ ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1) # Disable ZIP_DEBUGINFO_FILES by default because various tests are # failing in nightly when the debug info files are ZIP'ed. - ZIP_DEBUGINFO_FILES ?= 0 + #ZIP_DEBUGINFO_FILES ?= 0 + # The above conditional setting logic is unreliable on Windows for + # unknown reasons. We force ZIP_DEBUGINFO_FILES to be disabled on + # Windows until we figure out why the various tests are failing + # AND why the conditional setting logic is unreliable. + ZIP_DEBUGINFO_FILES=0 else ZIP_DEBUGINFO_FILES=0 endif
--- a/src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp Fri May 25 14:45:35 2012 -0700 @@ -738,7 +738,8 @@ case vmIntrinsics::_dlog: // fall through case vmIntrinsics::_dsin: // fall through case vmIntrinsics::_dtan: // fall through - case vmIntrinsics::_dcos: { + case vmIntrinsics::_dcos: // fall through + case vmIntrinsics::_dexp: { assert(x->number_of_arguments() == 1, "wrong type"); address runtime_entry = NULL; @@ -758,12 +759,23 @@ case vmIntrinsics::_dlog10: runtime_entry = CAST_FROM_FN_PTR(address, SharedRuntime::dlog10); break; + case vmIntrinsics::_dexp: + runtime_entry = CAST_FROM_FN_PTR(address, SharedRuntime::dexp); + break; default: ShouldNotReachHere(); } LIR_Opr result = call_runtime(x->argument_at(0), runtime_entry, x->type(), NULL); set_result(x, result); + break; + } + case vmIntrinsics::_dpow: { + assert(x->number_of_arguments() == 2, "wrong type"); + address runtime_entry = CAST_FROM_FN_PTR(address, SharedRuntime::dpow); + LIR_Opr result = call_runtime(x->argument_at(0), x->argument_at(1), runtime_entry, x->type(), NULL); + set_result(x, result); + break; } } }
--- a/src/cpu/sparc/vm/interpreter_sparc.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/sparc/vm/interpreter_sparc.cpp Fri May 25 14:45:35 2012 -0700 @@ -403,6 +403,8 @@ case Interpreter::java_lang_math_abs : break; case Interpreter::java_lang_math_log : break; case Interpreter::java_lang_math_log10 : break; + case Interpreter::java_lang_math_pow : break; + case Interpreter::java_lang_math_exp : break; case Interpreter::java_lang_ref_reference_get : entry_point = ((InterpreterGenerator*)this)->generate_Reference_get_entry(); break; default : ShouldNotReachHere(); break;
--- a/src/cpu/x86/vm/assembler_x86.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/x86/vm/assembler_x86.cpp Fri May 25 14:45:35 2012 -0700 @@ -3578,6 +3578,21 @@ emit_byte(0xF1); } +void Assembler::frndint() { + emit_byte(0xD9); + emit_byte(0xFC); +} + +void Assembler::f2xm1() { + emit_byte(0xD9); + emit_byte(0xF0); +} + +void Assembler::fldl2e() { + emit_byte(0xD9); + emit_byte(0xEA); +} + // SSE SIMD prefix byte values corresponding to VexSimdPrefix encoding. static int simd_pre[4] = { 0, 0x66, 0xF3, 0xF2 }; // SSE opcode second byte values (first is 0x0F) corresponding to VexOpcode encoding. @@ -6868,6 +6883,243 @@ Assembler::fldcw(as_Address(src)); } +void MacroAssembler::pow_exp_core_encoding() { + // kills rax, rcx, rdx + subptr(rsp,sizeof(jdouble)); + // computes 2^X. Stack: X ... + // f2xm1 computes 2^X-1 but only operates on -1<=X<=1. Get int(X) and + // keep it on the thread's stack to compute 2^int(X) later + // then compute 2^(X-int(X)) as (2^(X-int(X)-1+1) + // final result is obtained with: 2^X = 2^int(X) * 2^(X-int(X)) + fld_s(0); // Stack: X X ... + frndint(); // Stack: int(X) X ... + fsuba(1); // Stack: int(X) X-int(X) ... + fistp_s(Address(rsp,0)); // move int(X) as integer to thread's stack. Stack: X-int(X) ... + f2xm1(); // Stack: 2^(X-int(X))-1 ... + fld1(); // Stack: 1 2^(X-int(X))-1 ... + faddp(1); // Stack: 2^(X-int(X)) + // computes 2^(int(X)): add exponent bias (1023) to int(X), then + // shift int(X)+1023 to exponent position. + // Exponent is limited to 11 bits if int(X)+1023 does not fit in 11 + // bits, set result to NaN. 0x000 and 0x7FF are reserved exponent + // values so detect them and set result to NaN. + movl(rax,Address(rsp,0)); + movl(rcx, -2048); // 11 bit mask and valid NaN binary encoding + addl(rax, 1023); + movl(rdx,rax); + shll(rax,20); + // Check that 0 < int(X)+1023 < 2047. Otherwise set rax to NaN. + addl(rdx,1); + // Check that 1 < int(X)+1023+1 < 2048 + // in 3 steps: + // 1- (int(X)+1023+1)&-2048 == 0 => 0 <= int(X)+1023+1 < 2048 + // 2- (int(X)+1023+1)&-2048 != 0 + // 3- (int(X)+1023+1)&-2048 != 1 + // Do 2- first because addl just updated the flags. + cmov32(Assembler::equal,rax,rcx); + cmpl(rdx,1); + cmov32(Assembler::equal,rax,rcx); + testl(rdx,rcx); + cmov32(Assembler::notEqual,rax,rcx); + movl(Address(rsp,4),rax); + movl(Address(rsp,0),0); + fmul_d(Address(rsp,0)); // Stack: 2^X ... + addptr(rsp,sizeof(jdouble)); +} + +void MacroAssembler::fast_pow() { + // computes X^Y = 2^(Y * log2(X)) + // if fast computation is not possible, result is NaN. Requires + // fallback from user of this macro. + fyl2x(); // Stack: (Y*log2(X)) ... + pow_exp_core_encoding(); // Stack: exp(X) ... +} + +void MacroAssembler::fast_exp() { + // computes exp(X) = 2^(X * log2(e)) + // if fast computation is not possible, result is NaN. Requires + // fallback from user of this macro. + fldl2e(); // Stack: log2(e) X ... + fmulp(1); // Stack: (X*log2(e)) ... + pow_exp_core_encoding(); // Stack: exp(X) ... +} + +void MacroAssembler::pow_or_exp(bool is_exp, int num_fpu_regs_in_use) { + // kills rax, rcx, rdx + // pow and exp needs 2 extra registers on the fpu stack. + Label slow_case, done; + Register tmp = noreg; + if (!VM_Version::supports_cmov()) { + // fcmp needs a temporary so preserve rdx, + tmp = rdx; + } + Register tmp2 = rax; + Register tmp3 = rcx; + + if (is_exp) { + // Stack: X + fld_s(0); // duplicate argument for runtime call. Stack: X X + fast_exp(); // Stack: exp(X) X + fcmp(tmp, 0, false, false); // Stack: exp(X) X + // exp(X) not equal to itself: exp(X) is NaN go to slow case. + jcc(Assembler::parity, slow_case); + // get rid of duplicate argument. Stack: exp(X) + if (num_fpu_regs_in_use > 0) { + fxch(); + fpop(); + } else { + ffree(1); + } + jmp(done); + } else { + // Stack: X Y + Label x_negative, y_odd; + + fldz(); // Stack: 0 X Y + fcmp(tmp, 1, true, false); // Stack: X Y + jcc(Assembler::above, x_negative); + + // X >= 0 + + fld_s(1); // duplicate arguments for runtime call. Stack: Y X Y + fld_s(1); // Stack: X Y X Y + fast_pow(); // Stack: X^Y X Y + fcmp(tmp, 0, false, false); // Stack: X^Y X Y + // X^Y not equal to itself: X^Y is NaN go to slow case. + jcc(Assembler::parity, slow_case); + // get rid of duplicate arguments. Stack: X^Y + if (num_fpu_regs_in_use > 0) { + fxch(); fpop(); + fxch(); fpop(); + } else { + ffree(2); + ffree(1); + } + jmp(done); + + // X <= 0 + bind(x_negative); + + fld_s(1); // Stack: Y X Y + frndint(); // Stack: int(Y) X Y + fcmp(tmp, 2, false, false); // Stack: int(Y) X Y + jcc(Assembler::notEqual, slow_case); + + subptr(rsp, 8); + + // For X^Y, when X < 0, Y has to be an integer and the final + // result depends on whether it's odd or even. We just checked + // that int(Y) == Y. We move int(Y) to gp registers as a 64 bit + // integer to test its parity. If int(Y) is huge and doesn't fit + // in the 64 bit integer range, the integer indefinite value will + // end up in the gp registers. Huge numbers are all even, the + // integer indefinite number is even so it's fine. + +#ifdef ASSERT + // Let's check we don't end up with an integer indefinite number + // when not expected. First test for huge numbers: check whether + // int(Y)+1 == int(Y) which is true for very large numbers and + // those are all even. A 64 bit integer is guaranteed to not + // overflow for numbers where y+1 != y (when precision is set to + // double precision). + Label y_not_huge; + + fld1(); // Stack: 1 int(Y) X Y + fadd(1); // Stack: 1+int(Y) int(Y) X Y + +#ifdef _LP64 + // trip to memory to force the precision down from double extended + // precision + fstp_d(Address(rsp, 0)); + fld_d(Address(rsp, 0)); +#endif + + fcmp(tmp, 1, true, false); // Stack: int(Y) X Y +#endif + + // move int(Y) as 64 bit integer to thread's stack + fistp_d(Address(rsp,0)); // Stack: X Y + +#ifdef ASSERT + jcc(Assembler::notEqual, y_not_huge); + + // Y is huge so we know it's even. It may not fit in a 64 bit + // integer and we don't want the debug code below to see the + // integer indefinite value so overwrite int(Y) on the thread's + // stack with 0. + movl(Address(rsp, 0), 0); + movl(Address(rsp, 4), 0); + + bind(y_not_huge); +#endif + + fld_s(1); // duplicate arguments for runtime call. Stack: Y X Y + fld_s(1); // Stack: X Y X Y + fabs(); // Stack: abs(X) Y X Y + fast_pow(); // Stack: abs(X)^Y X Y + fcmp(tmp, 0, false, false); // Stack: abs(X)^Y X Y + // abs(X)^Y not equal to itself: abs(X)^Y is NaN go to slow case. + + pop(tmp2); + NOT_LP64(pop(tmp3)); + jcc(Assembler::parity, slow_case); + +#ifdef ASSERT + // Check that int(Y) is not integer indefinite value (int + // overflow). Shouldn't happen because for values that would + // overflow, 1+int(Y)==Y which was tested earlier. +#ifndef _LP64 + { + Label integer; + testl(tmp2, tmp2); + jcc(Assembler::notZero, integer); + cmpl(tmp3, 0x80000000); + jcc(Assembler::notZero, integer); + stop("integer indefinite value shouldn't be seen here"); + bind(integer); + } +#else + { + Label integer; + mov(tmp3, tmp2); // preserve tmp2 for parity check below + shlq(tmp3, 1); + jcc(Assembler::carryClear, integer); + jcc(Assembler::notZero, integer); + stop("integer indefinite value shouldn't be seen here"); + bind(integer); + } +#endif +#endif + + // get rid of duplicate arguments. Stack: X^Y + if (num_fpu_regs_in_use > 0) { + fxch(); fpop(); + fxch(); fpop(); + } else { + ffree(2); + ffree(1); + } + + testl(tmp2, 1); + jcc(Assembler::zero, done); // X <= 0, Y even: X^Y = abs(X)^Y + // X <= 0, Y even: X^Y = -abs(X)^Y + + fchs(); // Stack: -abs(X)^Y Y + jmp(done); + } + + // slow case: runtime call + bind(slow_case); + + fpop(); // pop incorrect result or int(Y) + + fp_runtime_fallback(is_exp ? CAST_FROM_FN_PTR(address, SharedRuntime::dexp) : CAST_FROM_FN_PTR(address, SharedRuntime::dpow), + is_exp ? 1 : 2, num_fpu_regs_in_use); + + // Come here with result in F-TOS + bind(done); +} + void MacroAssembler::fpop() { ffree(); fincstp(); @@ -8045,6 +8297,144 @@ #endif } +void MacroAssembler::fp_runtime_fallback(address runtime_entry, int nb_args, int num_fpu_regs_in_use) { + pusha(); + + // if we are coming from c1, xmm registers may be live + if (UseSSE >= 1) { + subptr(rsp, sizeof(jdouble)* LP64_ONLY(16) NOT_LP64(8)); + } + int off = 0; + if (UseSSE == 1) { + movflt(Address(rsp,off++*sizeof(jdouble)),xmm0); + movflt(Address(rsp,off++*sizeof(jdouble)),xmm1); + movflt(Address(rsp,off++*sizeof(jdouble)),xmm2); + movflt(Address(rsp,off++*sizeof(jdouble)),xmm3); + movflt(Address(rsp,off++*sizeof(jdouble)),xmm4); + movflt(Address(rsp,off++*sizeof(jdouble)),xmm5); + movflt(Address(rsp,off++*sizeof(jdouble)),xmm6); + movflt(Address(rsp,off++*sizeof(jdouble)),xmm7); + } else if (UseSSE >= 2) { + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm0); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm1); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm2); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm3); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm4); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm5); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm6); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm7); +#ifdef _LP64 + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm8); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm9); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm10); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm11); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm12); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm13); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm14); + movdbl(Address(rsp,off++*sizeof(jdouble)),xmm15); +#endif + } + + // Preserve registers across runtime call + int incoming_argument_and_return_value_offset = -1; + if (num_fpu_regs_in_use > 1) { + // Must preserve all other FPU regs (could alternatively convert + // SharedRuntime::dsin, dcos etc. into assembly routines known not to trash + // FPU state, but can not trust C compiler) + NEEDS_CLEANUP; + // NOTE that in this case we also push the incoming argument(s) to + // the stack and restore it later; we also use this stack slot to + // hold the return value from dsin, dcos etc. + for (int i = 0; i < num_fpu_regs_in_use; i++) { + subptr(rsp, sizeof(jdouble)); + fstp_d(Address(rsp, 0)); + } + incoming_argument_and_return_value_offset = sizeof(jdouble)*(num_fpu_regs_in_use-1); + for (int i = nb_args-1; i >= 0; i--) { + fld_d(Address(rsp, incoming_argument_and_return_value_offset-i*sizeof(jdouble))); + } + } + + subptr(rsp, nb_args*sizeof(jdouble)); + for (int i = 0; i < nb_args; i++) { + fstp_d(Address(rsp, i*sizeof(jdouble))); + } + +#ifdef _LP64 + if (nb_args > 0) { + movdbl(xmm0, Address(rsp, 0)); + } + if (nb_args > 1) { + movdbl(xmm1, Address(rsp, sizeof(jdouble))); + } + assert(nb_args <= 2, "unsupported number of args"); +#endif // _LP64 + + // NOTE: we must not use call_VM_leaf here because that requires a + // complete interpreter frame in debug mode -- same bug as 4387334 + // MacroAssembler::call_VM_leaf_base is perfectly safe and will + // do proper 64bit abi + + NEEDS_CLEANUP; + // Need to add stack banging before this runtime call if it needs to + // be taken; however, there is no generic stack banging routine at + // the MacroAssembler level + + MacroAssembler::call_VM_leaf_base(runtime_entry, 0); + +#ifdef _LP64 + movsd(Address(rsp, 0), xmm0); + fld_d(Address(rsp, 0)); +#endif // _LP64 + addptr(rsp, sizeof(jdouble) * nb_args); + if (num_fpu_regs_in_use > 1) { + // Must save return value to stack and then restore entire FPU + // stack except incoming arguments + fstp_d(Address(rsp, incoming_argument_and_return_value_offset)); + for (int i = 0; i < num_fpu_regs_in_use - nb_args; i++) { + fld_d(Address(rsp, 0)); + addptr(rsp, sizeof(jdouble)); + } + fld_d(Address(rsp, (nb_args-1)*sizeof(jdouble))); + addptr(rsp, sizeof(jdouble) * nb_args); + } + + off = 0; + if (UseSSE == 1) { + movflt(xmm0, Address(rsp,off++*sizeof(jdouble))); + movflt(xmm1, Address(rsp,off++*sizeof(jdouble))); + movflt(xmm2, Address(rsp,off++*sizeof(jdouble))); + movflt(xmm3, Address(rsp,off++*sizeof(jdouble))); + movflt(xmm4, Address(rsp,off++*sizeof(jdouble))); + movflt(xmm5, Address(rsp,off++*sizeof(jdouble))); + movflt(xmm6, Address(rsp,off++*sizeof(jdouble))); + movflt(xmm7, Address(rsp,off++*sizeof(jdouble))); + } else if (UseSSE >= 2) { + movdbl(xmm0, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm1, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm2, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm3, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm4, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm5, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm6, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm7, Address(rsp,off++*sizeof(jdouble))); +#ifdef _LP64 + movdbl(xmm8, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm9, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm10, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm11, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm12, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm13, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm14, Address(rsp,off++*sizeof(jdouble))); + movdbl(xmm15, Address(rsp,off++*sizeof(jdouble))); +#endif + } + if (UseSSE >= 1) { + addptr(rsp, sizeof(jdouble)* LP64_ONLY(16) NOT_LP64(8)); + } + popa(); +} + static const double pi_4 = 0.7853981633974483; void MacroAssembler::trigfunc(char trig, int num_fpu_regs_in_use) { @@ -8092,73 +8482,27 @@ // slow case: runtime call bind(slow_case); - // Preserve registers across runtime call - pusha(); - int incoming_argument_and_return_value_offset = -1; - if (num_fpu_regs_in_use > 1) { - // Must preserve all other FPU regs (could alternatively convert - // SharedRuntime::dsin and dcos into assembly routines known not to trash - // FPU state, but can not trust C compiler) - NEEDS_CLEANUP; - // NOTE that in this case we also push the incoming argument to - // the stack and restore it later; we also use this stack slot to - // hold the return value from dsin or dcos. - for (int i = 0; i < num_fpu_regs_in_use; i++) { - subptr(rsp, sizeof(jdouble)); - fstp_d(Address(rsp, 0)); - } - incoming_argument_and_return_value_offset = sizeof(jdouble)*(num_fpu_regs_in_use-1); - fld_d(Address(rsp, incoming_argument_and_return_value_offset)); - } - subptr(rsp, sizeof(jdouble)); - fstp_d(Address(rsp, 0)); -#ifdef _LP64 - movdbl(xmm0, Address(rsp, 0)); -#endif // _LP64 - - // NOTE: we must not use call_VM_leaf here because that requires a - // complete interpreter frame in debug mode -- same bug as 4387334 - // MacroAssembler::call_VM_leaf_base is perfectly safe and will - // do proper 64bit abi - - NEEDS_CLEANUP; - // Need to add stack banging before this runtime call if it needs to - // be taken; however, there is no generic stack banging routine at - // the MacroAssembler level + switch(trig) { case 's': { - MacroAssembler::call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::dsin), 0); + fp_runtime_fallback(CAST_FROM_FN_PTR(address, SharedRuntime::dsin), 1, num_fpu_regs_in_use); } break; case 'c': { - MacroAssembler::call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::dcos), 0); + fp_runtime_fallback(CAST_FROM_FN_PTR(address, SharedRuntime::dcos), 1, num_fpu_regs_in_use); } break; case 't': { - MacroAssembler::call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::dtan), 0); + fp_runtime_fallback(CAST_FROM_FN_PTR(address, SharedRuntime::dtan), 1, num_fpu_regs_in_use); } break; default: assert(false, "bad intrinsic"); break; } -#ifdef _LP64 - movsd(Address(rsp, 0), xmm0); - fld_d(Address(rsp, 0)); -#endif // _LP64 - addptr(rsp, sizeof(jdouble)); - if (num_fpu_regs_in_use > 1) { - // Must save return value to stack and then restore entire FPU stack - fstp_d(Address(rsp, incoming_argument_and_return_value_offset)); - for (int i = 0; i < num_fpu_regs_in_use; i++) { - fld_d(Address(rsp, 0)); - addptr(rsp, sizeof(jdouble)); - } - } - popa(); // Come here with result in F-TOS bind(done);
--- a/src/cpu/x86/vm/assembler_x86.hpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/x86/vm/assembler_x86.hpp Fri May 25 14:45:35 2012 -0700 @@ -1148,6 +1148,9 @@ void fxsave(Address dst); void fyl2x(); + void frndint(); + void f2xm1(); + void fldl2e(); void hlt(); @@ -2387,7 +2390,28 @@ void ldmxcsr(Address src) { Assembler::ldmxcsr(src); } void ldmxcsr(AddressLiteral src); + // compute pow(x,y) and exp(x) with x86 instructions. Don't cover + // all corner cases and may result in NaN and require fallback to a + // runtime call. + void fast_pow(); + void fast_exp(); + + // computes exp(x). Fallback to runtime call included. + void exp_with_fallback(int num_fpu_regs_in_use) { pow_or_exp(true, num_fpu_regs_in_use); } + // computes pow(x,y). Fallback to runtime call included. + void pow_with_fallback(int num_fpu_regs_in_use) { pow_or_exp(false, num_fpu_regs_in_use); } + private: + + // call runtime as a fallback for trig functions and pow/exp. + void fp_runtime_fallback(address runtime_entry, int nb_args, int num_fpu_regs_in_use); + + // computes 2^(Ylog2X); Ylog2X in ST(0) + void pow_exp_core_encoding(); + + // computes pow(x,y) or exp(x). Fallback to runtime call included. + void pow_or_exp(bool is_exp, int num_fpu_regs_in_use); + // these are private because users should be doing movflt/movdbl void movss(Address dst, XMMRegister src) { Assembler::movss(dst, src); }
--- a/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp Fri May 25 14:45:35 2012 -0700 @@ -2446,6 +2446,12 @@ // Should consider not saving rbx, if not necessary __ trigfunc('t', op->as_Op2()->fpu_stack_size()); break; + case lir_exp : + __ exp_with_fallback(op->as_Op2()->fpu_stack_size()); + break; + case lir_pow : + __ pow_with_fallback(op->as_Op2()->fpu_stack_size()); + break; default : ShouldNotReachHere(); } } else {
--- a/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp Fri May 25 14:45:35 2012 -0700 @@ -823,7 +823,7 @@ void LIRGenerator::do_MathIntrinsic(Intrinsic* x) { - assert(x->number_of_arguments() == 1, "wrong type"); + assert(x->number_of_arguments() == 1 || (x->number_of_arguments() == 2 && x->id() == vmIntrinsics::_dpow), "wrong type"); LIRItem value(x->argument_at(0), this); bool use_fpu = false; @@ -834,6 +834,8 @@ case vmIntrinsics::_dtan: case vmIntrinsics::_dlog: case vmIntrinsics::_dlog10: + case vmIntrinsics::_dexp: + case vmIntrinsics::_dpow: use_fpu = true; } } else { @@ -843,20 +845,37 @@ value.load_item(); LIR_Opr calc_input = value.result(); + LIR_Opr calc_input2 = NULL; + if (x->id() == vmIntrinsics::_dpow) { + LIRItem extra_arg(x->argument_at(1), this); + if (UseSSE < 2) { + extra_arg.set_destroys_register(); + } + extra_arg.load_item(); + calc_input2 = extra_arg.result(); + } LIR_Opr calc_result = rlock_result(x); - // sin and cos need two free fpu stack slots, so register two temporary operands + // sin, cos, pow and exp need two free fpu stack slots, so register + // two temporary operands LIR_Opr tmp1 = FrameMap::caller_save_fpu_reg_at(0); LIR_Opr tmp2 = FrameMap::caller_save_fpu_reg_at(1); if (use_fpu) { LIR_Opr tmp = FrameMap::fpu0_double_opr; + int tmp_start = 1; + if (calc_input2 != NULL) { + __ move(calc_input2, tmp); + tmp_start = 2; + calc_input2 = tmp; + } __ move(calc_input, tmp); calc_input = tmp; calc_result = tmp; - tmp1 = FrameMap::caller_save_fpu_reg_at(1); - tmp2 = FrameMap::caller_save_fpu_reg_at(2); + + tmp1 = FrameMap::caller_save_fpu_reg_at(tmp_start); + tmp2 = FrameMap::caller_save_fpu_reg_at(tmp_start + 1); } switch(x->id()) { @@ -867,6 +886,8 @@ case vmIntrinsics::_dtan: __ tan (calc_input, calc_result, tmp1, tmp2); break; case vmIntrinsics::_dlog: __ log (calc_input, calc_result, tmp1); break; case vmIntrinsics::_dlog10: __ log10(calc_input, calc_result, tmp1); break; + case vmIntrinsics::_dexp: __ exp (calc_input, calc_result, tmp1, tmp2, FrameMap::rax_opr, FrameMap::rcx_opr, FrameMap::rdx_opr); break; + case vmIntrinsics::_dpow: __ pow (calc_input, calc_input2, calc_result, tmp1, tmp2, FrameMap::rax_opr, FrameMap::rcx_opr, FrameMap::rdx_opr); break; default: ShouldNotReachHere(); }
--- a/src/cpu/x86/vm/c1_LinearScan_x86.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/x86/vm/c1_LinearScan_x86.cpp Fri May 25 14:45:35 2012 -0700 @@ -690,8 +690,8 @@ case lir_mul_strictfp: case lir_div_strictfp: { - assert(op2->tmp_opr()->is_fpu_register(), "strict operations need temporary fpu stack slot"); - insert_free_if_dead(op2->tmp_opr()); + assert(op2->tmp1_opr()->is_fpu_register(), "strict operations need temporary fpu stack slot"); + insert_free_if_dead(op2->tmp1_opr()); assert(sim()->stack_size() <= 7, "at least one stack slot must be free"); // fall-through: continue with the normal handling of lir_mul and lir_div } @@ -787,16 +787,17 @@ case lir_log: case lir_log10: { - // log and log10 needs one temporary fpu stack slot, so there is ontemporary - // registers stored in temp of the operation. - // the stack allocator must guarantee that the stack slots are really free, - // otherwise there might be a stack overflow. + // log and log10 need one temporary fpu stack slot, so + // there is one temporary registers stored in temp of the + // operation. the stack allocator must guarantee that the stack + // slots are really free, otherwise there might be a stack + // overflow. assert(right->is_illegal(), "must be"); assert(left->is_fpu_register(), "must be"); assert(res->is_fpu_register(), "must be"); - assert(op2->tmp_opr()->is_fpu_register(), "must be"); + assert(op2->tmp1_opr()->is_fpu_register(), "must be"); - insert_free_if_dead(op2->tmp_opr()); + insert_free_if_dead(op2->tmp1_opr()); insert_free_if_dead(res, left); insert_exchange(left); do_rename(left, res); @@ -812,8 +813,9 @@ case lir_tan: case lir_sin: - case lir_cos: { - // sin and cos need two temporary fpu stack slots, so there are two temporary + case lir_cos: + case lir_exp: { + // sin, cos and exp need two temporary fpu stack slots, so there are two temporary // registers (stored in right and temp of the operation). // the stack allocator must guarantee that the stack slots are really free, // otherwise there might be a stack overflow. @@ -821,11 +823,11 @@ assert(res->is_fpu_register(), "must be"); // assert(left->is_last_use(), "old value gets destroyed"); assert(right->is_fpu_register(), "right is used as the first temporary register"); - assert(op2->tmp_opr()->is_fpu_register(), "temp is used as the second temporary register"); - assert(fpu_num(left) != fpu_num(right) && fpu_num(right) != fpu_num(op2->tmp_opr()) && fpu_num(op2->tmp_opr()) != fpu_num(res), "need distinct temp registers"); + assert(op2->tmp1_opr()->is_fpu_register(), "temp is used as the second temporary register"); + assert(fpu_num(left) != fpu_num(right) && fpu_num(right) != fpu_num(op2->tmp1_opr()) && fpu_num(op2->tmp1_opr()) != fpu_num(res), "need distinct temp registers"); insert_free_if_dead(right); - insert_free_if_dead(op2->tmp_opr()); + insert_free_if_dead(op2->tmp1_opr()); insert_free_if_dead(res, left); insert_exchange(left); @@ -839,6 +841,53 @@ break; } + case lir_pow: { + // pow needs two temporary fpu stack slots, so there are two temporary + // registers (stored in tmp1 and tmp2 of the operation). + // the stack allocator must guarantee that the stack slots are really free, + // otherwise there might be a stack overflow. + assert(left->is_fpu_register(), "must be"); + assert(right->is_fpu_register(), "must be"); + assert(res->is_fpu_register(), "must be"); + + assert(op2->tmp1_opr()->is_fpu_register(), "tmp1 is the first temporary register"); + assert(op2->tmp2_opr()->is_fpu_register(), "tmp2 is the second temporary register"); + assert(fpu_num(left) != fpu_num(right) && fpu_num(left) != fpu_num(op2->tmp1_opr()) && fpu_num(left) != fpu_num(op2->tmp2_opr()) && fpu_num(left) != fpu_num(res), "need distinct temp registers"); + assert(fpu_num(right) != fpu_num(op2->tmp1_opr()) && fpu_num(right) != fpu_num(op2->tmp2_opr()) && fpu_num(right) != fpu_num(res), "need distinct temp registers"); + assert(fpu_num(op2->tmp1_opr()) != fpu_num(op2->tmp2_opr()) && fpu_num(op2->tmp1_opr()) != fpu_num(res), "need distinct temp registers"); + assert(fpu_num(op2->tmp2_opr()) != fpu_num(res), "need distinct temp registers"); + + insert_free_if_dead(op2->tmp1_opr()); + insert_free_if_dead(op2->tmp2_opr()); + + // Must bring both operands to top of stack with following operand ordering: + // * fpu stack before pow: ... right left + // * fpu stack after pow: ... left + + insert_free_if_dead(res, right); + + if (tos_offset(right) != 1) { + insert_exchange(right); + insert_exchange(1); + } + insert_exchange(left); + assert(tos_offset(right) == 1, "check"); + assert(tos_offset(left) == 0, "check"); + + new_left = to_fpu_stack_top(left); + new_right = to_fpu_stack(right); + + op2->set_fpu_stack_size(sim()->stack_size()); + assert(sim()->stack_size() <= 6, "at least two stack slots must be free"); + + sim()->pop(); + + do_rename(right, res); + + new_res = to_fpu_stack_top(res); + break; + } + default: { assert(false, "missed a fpu-operation"); }
--- a/src/cpu/x86/vm/interpreter_x86_32.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/x86/vm/interpreter_x86_32.cpp Fri May 25 14:45:35 2012 -0700 @@ -181,6 +181,19 @@ __ push_fTOS(); __ pop_fTOS(); break; + case Interpreter::java_lang_math_pow: + __ fld_d(Address(rsp, 3*wordSize)); // second argument + __ pow_with_fallback(0); + // Store to stack to convert 80bit precision back to 64bits + __ push_fTOS(); + __ pop_fTOS(); + break; + case Interpreter::java_lang_math_exp: + __ exp_with_fallback(0); + // Store to stack to convert 80bit precision back to 64bits + __ push_fTOS(); + __ pop_fTOS(); + break; default : ShouldNotReachHere(); }
--- a/src/cpu/x86/vm/interpreter_x86_64.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/x86/vm/interpreter_x86_64.cpp Fri May 25 14:45:35 2012 -0700 @@ -271,6 +271,14 @@ case Interpreter::java_lang_math_log10: __ flog10(); break; + case Interpreter::java_lang_math_pow: + __ fld_d(Address(rsp, 3*wordSize)); // second argument (one + // empty stack slot) + __ pow_with_fallback(0); + break; + case Interpreter::java_lang_math_exp: + __ exp_with_fallback(0); + break; default : ShouldNotReachHere(); }
--- a/src/cpu/x86/vm/stubGenerator_x86_32.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/x86/vm/stubGenerator_x86_32.cpp Fri May 25 14:45:35 2012 -0700 @@ -2136,11 +2136,23 @@ __ trigfunc('t'); __ ret(0); } + { + StubCodeMark mark(this, "StubRoutines", "exp"); + StubRoutines::_intrinsic_exp = (double (*)(double)) __ pc(); - // The intrinsic version of these seem to return the same value as - // the strict version. - StubRoutines::_intrinsic_exp = SharedRuntime::dexp; - StubRoutines::_intrinsic_pow = SharedRuntime::dpow; + __ fld_d(Address(rsp, 4)); + __ exp_with_fallback(0); + __ ret(0); + } + { + StubCodeMark mark(this, "StubRoutines", "pow"); + StubRoutines::_intrinsic_pow = (double (*)(double,double)) __ pc(); + + __ fld_d(Address(rsp, 12)); + __ fld_d(Address(rsp, 4)); + __ pow_with_fallback(0); + __ ret(0); + } } public:
--- a/src/cpu/x86/vm/stubGenerator_x86_64.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/x86/vm/stubGenerator_x86_64.cpp Fri May 25 14:45:35 2012 -0700 @@ -2928,11 +2928,34 @@ __ addq(rsp, 8); __ ret(0); } - - // The intrinsic version of these seem to return the same value as - // the strict version. - StubRoutines::_intrinsic_exp = SharedRuntime::dexp; - StubRoutines::_intrinsic_pow = SharedRuntime::dpow; + { + StubCodeMark mark(this, "StubRoutines", "exp"); + StubRoutines::_intrinsic_exp = (double (*)(double)) __ pc(); + + __ subq(rsp, 8); + __ movdbl(Address(rsp, 0), xmm0); + __ fld_d(Address(rsp, 0)); + __ exp_with_fallback(0); + __ fstp_d(Address(rsp, 0)); + __ movdbl(xmm0, Address(rsp, 0)); + __ addq(rsp, 8); + __ ret(0); + } + { + StubCodeMark mark(this, "StubRoutines", "pow"); + StubRoutines::_intrinsic_pow = (double (*)(double,double)) __ pc(); + + __ subq(rsp, 8); + __ movdbl(Address(rsp, 0), xmm1); + __ fld_d(Address(rsp, 0)); + __ movdbl(Address(rsp, 0), xmm0); + __ fld_d(Address(rsp, 0)); + __ pow_with_fallback(0); + __ fstp_d(Address(rsp, 0)); + __ movdbl(xmm0, Address(rsp, 0)); + __ addq(rsp, 8); + __ ret(0); + } } #undef __
--- a/src/cpu/x86/vm/templateInterpreter_x86_32.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/x86/vm/templateInterpreter_x86_32.cpp Fri May 25 14:45:35 2012 -0700 @@ -1518,7 +1518,9 @@ case Interpreter::java_lang_math_abs : // fall thru case Interpreter::java_lang_math_log : // fall thru case Interpreter::java_lang_math_log10 : // fall thru - case Interpreter::java_lang_math_sqrt : entry_point = ((InterpreterGenerator*)this)->generate_math_entry(kind); break; + case Interpreter::java_lang_math_sqrt : // fall thru + case Interpreter::java_lang_math_pow : // fall thru + case Interpreter::java_lang_math_exp : entry_point = ((InterpreterGenerator*)this)->generate_math_entry(kind); break; case Interpreter::java_lang_ref_reference_get : entry_point = ((InterpreterGenerator*)this)->generate_Reference_get_entry(); break; default : ShouldNotReachHere(); break; @@ -1540,7 +1542,9 @@ case Interpreter::java_lang_math_abs : // fall thru case Interpreter::java_lang_math_log : // fall thru case Interpreter::java_lang_math_log10 : // fall thru - case Interpreter::java_lang_math_sqrt : + case Interpreter::java_lang_math_sqrt : // fall thru + case Interpreter::java_lang_math_pow : // fall thru + case Interpreter::java_lang_math_exp : return false; default: return true;
--- a/src/cpu/x86/vm/templateInterpreter_x86_64.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/x86/vm/templateInterpreter_x86_64.cpp Fri May 25 14:45:35 2012 -0700 @@ -1534,7 +1534,9 @@ case Interpreter::java_lang_math_abs : // fall thru case Interpreter::java_lang_math_log : // fall thru case Interpreter::java_lang_math_log10 : // fall thru - case Interpreter::java_lang_math_sqrt : entry_point = ((InterpreterGenerator*) this)->generate_math_entry(kind); break; + case Interpreter::java_lang_math_sqrt : // fall thru + case Interpreter::java_lang_math_pow : // fall thru + case Interpreter::java_lang_math_exp : entry_point = ((InterpreterGenerator*) this)->generate_math_entry(kind); break; case Interpreter::java_lang_ref_reference_get : entry_point = ((InterpreterGenerator*)this)->generate_Reference_get_entry(); break; default : ShouldNotReachHere(); break; @@ -1558,7 +1560,9 @@ case Interpreter::java_lang_math_abs : // fall thru case Interpreter::java_lang_math_log : // fall thru case Interpreter::java_lang_math_log10 : // fall thru - case Interpreter::java_lang_math_sqrt : + case Interpreter::java_lang_math_sqrt : // fall thru + case Interpreter::java_lang_math_pow : // fall thru + case Interpreter::java_lang_math_exp : return false; default: return true;
--- a/src/cpu/x86/vm/x86_32.ad Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/x86/vm/x86_32.ad Fri May 25 14:45:35 2012 -0700 @@ -2536,45 +2536,6 @@ __ fld_d(Address(rsp, 0)); %} - // Compute X^Y using Intel's fast hardware instructions, if possible. - // Otherwise return a NaN. - enc_class pow_exp_core_encoding %{ - // FPR1 holds Y*ln2(X). Compute FPR1 = 2^(Y*ln2(X)) - emit_opcode(cbuf,0xD9); emit_opcode(cbuf,0xC0); // fdup = fld st(0) Q Q - emit_opcode(cbuf,0xD9); emit_opcode(cbuf,0xFC); // frndint int(Q) Q - emit_opcode(cbuf,0xDC); emit_opcode(cbuf,0xE9); // fsub st(1) -= st(0); int(Q) frac(Q) - emit_opcode(cbuf,0xDB); // FISTP [ESP] frac(Q) - emit_opcode(cbuf,0x1C); - emit_d8(cbuf,0x24); - emit_opcode(cbuf,0xD9); emit_opcode(cbuf,0xF0); // f2xm1 2^frac(Q)-1 - emit_opcode(cbuf,0xD9); emit_opcode(cbuf,0xE8); // fld1 1 2^frac(Q)-1 - emit_opcode(cbuf,0xDE); emit_opcode(cbuf,0xC1); // faddp 2^frac(Q) - emit_opcode(cbuf,0x8B); // mov rax,[esp+0]=int(Q) - encode_RegMem(cbuf, EAX_enc, ESP_enc, 0x4, 0, 0, false); - emit_opcode(cbuf,0xC7); // mov rcx,0xFFFFF800 - overflow mask - emit_rm(cbuf, 0x3, 0x0, ECX_enc); - emit_d32(cbuf,0xFFFFF800); - emit_opcode(cbuf,0x81); // add rax,1023 - the double exponent bias - emit_rm(cbuf, 0x3, 0x0, EAX_enc); - emit_d32(cbuf,1023); - emit_opcode(cbuf,0x8B); // mov rbx,eax - emit_rm(cbuf, 0x3, EBX_enc, EAX_enc); - emit_opcode(cbuf,0xC1); // shl rax,20 - Slide to exponent position - emit_rm(cbuf,0x3,0x4,EAX_enc); - emit_d8(cbuf,20); - emit_opcode(cbuf,0x85); // test rbx,ecx - check for overflow - emit_rm(cbuf, 0x3, EBX_enc, ECX_enc); - emit_opcode(cbuf,0x0F); emit_opcode(cbuf,0x45); // CMOVne rax,ecx - overflow; stuff NAN into EAX - emit_rm(cbuf, 0x3, EAX_enc, ECX_enc); - emit_opcode(cbuf,0x89); // mov [esp+4],eax - Store as part of double word - encode_RegMem(cbuf, EAX_enc, ESP_enc, 0x4, 0, 4, false); - emit_opcode(cbuf,0xC7); // mov [esp+0],0 - [ESP] = (double)(1<<int(Q)) = 2^int(Q) - encode_RegMem(cbuf, 0x0, ESP_enc, 0x4, 0, 0, false); - emit_d32(cbuf,0); - emit_opcode(cbuf,0xDC); // fmul dword st(0),[esp+0]; FPR1 = 2^int(Q)*2^frac(Q) = 2^Q - encode_RegMem(cbuf, 0x1, ESP_enc, 0x4, 0, 0, false); - %} - enc_class Push_Result_Mod_DPR( regDPR src) %{ if ($src$$reg != FPR1L_enc) { // fincstp @@ -10100,161 +10061,67 @@ ins_pipe( pipe_slow ); %} -instruct powDPR_reg(regDPR X, regDPR1 Y, eAXRegI rax, eBXRegI rbx, eCXRegI rcx) %{ +instruct powDPR_reg(regDPR X, regDPR1 Y, eAXRegI rax, eDXRegI rdx, eCXRegI rcx, eFlagsReg cr) %{ predicate (UseSSE<=1); match(Set Y (PowD X Y)); // Raise X to the Yth power - effect(KILL rax, KILL rbx, KILL rcx); - format %{ "SUB ESP,8\t\t# Fast-path POW encoding\n\t" - "FLD_D $X\n\t" - "FYL2X \t\t\t# Q=Y*ln2(X)\n\t" - - "FDUP \t\t\t# Q Q\n\t" - "FRNDINT\t\t\t# int(Q) Q\n\t" - "FSUB ST(1),ST(0)\t# int(Q) frac(Q)\n\t" - "FISTP dword [ESP]\n\t" - "F2XM1 \t\t\t# 2^frac(Q)-1 int(Q)\n\t" - "FLD1 \t\t\t# 1 2^frac(Q)-1 int(Q)\n\t" - "FADDP \t\t\t# 2^frac(Q) int(Q)\n\t" // could use FADD [1.000] instead - "MOV EAX,[ESP]\t# Pick up int(Q)\n\t" - "MOV ECX,0xFFFFF800\t# Overflow mask\n\t" - "ADD EAX,1023\t\t# Double exponent bias\n\t" - "MOV EBX,EAX\t\t# Preshifted biased expo\n\t" - "SHL EAX,20\t\t# Shift exponent into place\n\t" - "TEST EBX,ECX\t\t# Check for overflow\n\t" - "CMOVne EAX,ECX\t\t# If overflow, stuff NaN into EAX\n\t" - "MOV [ESP+4],EAX\t# Marshal 64-bit scaling double\n\t" - "MOV [ESP+0],0\n\t" - "FMUL ST(0),[ESP+0]\t# Scale\n\t" - - "ADD ESP,8" - %} - ins_encode( push_stack_temp_qword, - Push_Reg_DPR(X), - Opcode(0xD9), Opcode(0xF1), // fyl2x - pow_exp_core_encoding, - pop_stack_temp_qword); - ins_pipe( pipe_slow ); -%} - -instruct powD_reg(regD dst, regD src0, regD src1, regDPR1 tmp1, eAXRegI rax, eBXRegI rbx, eCXRegI rcx ) %{ + effect(KILL rax, KILL rdx, KILL rcx, KILL cr); + format %{ "fast_pow $X $Y -> $Y // KILL $rax, $rcx, $rdx" %} + ins_encode %{ + __ subptr(rsp, 8); + __ fld_s($X$$reg - 1); + __ fast_pow(); + __ addptr(rsp, 8); + %} + ins_pipe( pipe_slow ); +%} + +instruct powD_reg(regD dst, regD src0, regD src1, eAXRegI rax, eDXRegI rdx, eCXRegI rcx, eFlagsReg cr) %{ predicate (UseSSE>=2); match(Set dst (PowD src0 src1)); // Raise src0 to the src1'th power - effect(KILL tmp1, KILL rax, KILL rbx, KILL rcx ); - format %{ "SUB ESP,8\t\t# Fast-path POW encoding\n\t" - "MOVSD [ESP],$src1\n\t" - "FLD FPR1,$src1\n\t" - "MOVSD [ESP],$src0\n\t" - "FLD FPR1,$src0\n\t" - "FYL2X \t\t\t# Q=Y*ln2(X)\n\t" - - "FDUP \t\t\t# Q Q\n\t" - "FRNDINT\t\t\t# int(Q) Q\n\t" - "FSUB ST(1),ST(0)\t# int(Q) frac(Q)\n\t" - "FISTP dword [ESP]\n\t" - "F2XM1 \t\t\t# 2^frac(Q)-1 int(Q)\n\t" - "FLD1 \t\t\t# 1 2^frac(Q)-1 int(Q)\n\t" - "FADDP \t\t\t# 2^frac(Q) int(Q)\n\t" // could use FADD [1.000] instead - "MOV EAX,[ESP]\t# Pick up int(Q)\n\t" - "MOV ECX,0xFFFFF800\t# Overflow mask\n\t" - "ADD EAX,1023\t\t# Double exponent bias\n\t" - "MOV EBX,EAX\t\t# Preshifted biased expo\n\t" - "SHL EAX,20\t\t# Shift exponent into place\n\t" - "TEST EBX,ECX\t\t# Check for overflow\n\t" - "CMOVne EAX,ECX\t\t# If overflow, stuff NaN into EAX\n\t" - "MOV [ESP+4],EAX\t# Marshal 64-bit scaling double\n\t" - "MOV [ESP+0],0\n\t" - "FMUL ST(0),[ESP+0]\t# Scale\n\t" - - "FST_D [ESP]\n\t" - "MOVSD $dst,[ESP]\n\t" - "ADD ESP,8" - %} - ins_encode( push_stack_temp_qword, - push_xmm_to_fpr1(src1), - push_xmm_to_fpr1(src0), - Opcode(0xD9), Opcode(0xF1), // fyl2x - pow_exp_core_encoding, - Push_ResultD(dst) ); - ins_pipe( pipe_slow ); -%} - - -instruct expDPR_reg(regDPR1 dpr1, eAXRegI rax, eBXRegI rbx, eCXRegI rcx) %{ + effect(KILL rax, KILL rdx, KILL rcx, KILL cr); + format %{ "fast_pow $src0 $src1 -> $dst // KILL $rax, $rcx, $rdx" %} + ins_encode %{ + __ subptr(rsp, 8); + __ movdbl(Address(rsp, 0), $src1$$XMMRegister); + __ fld_d(Address(rsp, 0)); + __ movdbl(Address(rsp, 0), $src0$$XMMRegister); + __ fld_d(Address(rsp, 0)); + __ fast_pow(); + __ fstp_d(Address(rsp, 0)); + __ movdbl($dst$$XMMRegister, Address(rsp, 0)); + __ addptr(rsp, 8); + %} + ins_pipe( pipe_slow ); +%} + + +instruct expDPR_reg(regDPR1 dpr1, eAXRegI rax, eDXRegI rdx, eCXRegI rcx, eFlagsReg cr) %{ predicate (UseSSE<=1); match(Set dpr1 (ExpD dpr1)); - effect(KILL rax, KILL rbx, KILL rcx); - format %{ "SUB ESP,8\t\t# Fast-path EXP encoding" - "FLDL2E \t\t\t# Ld log2(e) X\n\t" - "FMULP \t\t\t# Q=X*log2(e)\n\t" - - "FDUP \t\t\t# Q Q\n\t" - "FRNDINT\t\t\t# int(Q) Q\n\t" - "FSUB ST(1),ST(0)\t# int(Q) frac(Q)\n\t" - "FISTP dword [ESP]\n\t" - "F2XM1 \t\t\t# 2^frac(Q)-1 int(Q)\n\t" - "FLD1 \t\t\t# 1 2^frac(Q)-1 int(Q)\n\t" - "FADDP \t\t\t# 2^frac(Q) int(Q)\n\t" // could use FADD [1.000] instead - "MOV EAX,[ESP]\t# Pick up int(Q)\n\t" - "MOV ECX,0xFFFFF800\t# Overflow mask\n\t" - "ADD EAX,1023\t\t# Double exponent bias\n\t" - "MOV EBX,EAX\t\t# Preshifted biased expo\n\t" - "SHL EAX,20\t\t# Shift exponent into place\n\t" - "TEST EBX,ECX\t\t# Check for overflow\n\t" - "CMOVne EAX,ECX\t\t# If overflow, stuff NaN into EAX\n\t" - "MOV [ESP+4],EAX\t# Marshal 64-bit scaling double\n\t" - "MOV [ESP+0],0\n\t" - "FMUL ST(0),[ESP+0]\t# Scale\n\t" - - "ADD ESP,8" - %} - ins_encode( push_stack_temp_qword, - Opcode(0xD9), Opcode(0xEA), // fldl2e - Opcode(0xDE), Opcode(0xC9), // fmulp - pow_exp_core_encoding, - pop_stack_temp_qword); - ins_pipe( pipe_slow ); -%} - -instruct expD_reg(regD dst, regD src, regDPR1 tmp1, eAXRegI rax, eBXRegI rbx, eCXRegI rcx) %{ + effect(KILL rax, KILL rcx, KILL rdx, KILL cr); + format %{ "fast_exp $dpr1 -> $dpr1 // KILL $rax, $rcx, $rdx" %} + ins_encode %{ + __ fast_exp(); + %} + ins_pipe( pipe_slow ); +%} + +instruct expD_reg(regD dst, regD src, eAXRegI rax, eDXRegI rdx, eCXRegI rcx, eFlagsReg cr) %{ predicate (UseSSE>=2); match(Set dst (ExpD src)); - effect(KILL tmp1, KILL rax, KILL rbx, KILL rcx); - format %{ "SUB ESP,8\t\t# Fast-path EXP encoding\n\t" - "MOVSD [ESP],$src\n\t" - "FLDL2E \t\t\t# Ld log2(e) X\n\t" - "FMULP \t\t\t# Q=X*log2(e) X\n\t" - - "FDUP \t\t\t# Q Q\n\t" - "FRNDINT\t\t\t# int(Q) Q\n\t" - "FSUB ST(1),ST(0)\t# int(Q) frac(Q)\n\t" - "FISTP dword [ESP]\n\t" - "F2XM1 \t\t\t# 2^frac(Q)-1 int(Q)\n\t" - "FLD1 \t\t\t# 1 2^frac(Q)-1 int(Q)\n\t" - "FADDP \t\t\t# 2^frac(Q) int(Q)\n\t" // could use FADD [1.000] instead - "MOV EAX,[ESP]\t# Pick up int(Q)\n\t" - "MOV ECX,0xFFFFF800\t# Overflow mask\n\t" - "ADD EAX,1023\t\t# Double exponent bias\n\t" - "MOV EBX,EAX\t\t# Preshifted biased expo\n\t" - "SHL EAX,20\t\t# Shift exponent into place\n\t" - "TEST EBX,ECX\t\t# Check for overflow\n\t" - "CMOVne EAX,ECX\t\t# If overflow, stuff NaN into EAX\n\t" - "MOV [ESP+4],EAX\t# Marshal 64-bit scaling double\n\t" - "MOV [ESP+0],0\n\t" - "FMUL ST(0),[ESP+0]\t# Scale\n\t" - - "FST_D [ESP]\n\t" - "MOVSD $dst,[ESP]\n\t" - "ADD ESP,8" - %} - ins_encode( Push_SrcD(src), - Opcode(0xD9), Opcode(0xEA), // fldl2e - Opcode(0xDE), Opcode(0xC9), // fmulp - pow_exp_core_encoding, - Push_ResultD(dst) ); - ins_pipe( pipe_slow ); -%} - - + effect(KILL rax, KILL rcx, KILL rdx, KILL cr); + format %{ "fast_exp $dst -> $src // KILL $rax, $rcx, $rdx" %} + ins_encode %{ + __ subptr(rsp, 8); + __ movdbl(Address(rsp, 0), $src$$XMMRegister); + __ fld_d(Address(rsp, 0)); + __ fast_exp(); + __ fstp_d(Address(rsp, 0)); + __ movdbl($dst$$XMMRegister, Address(rsp, 0)); + __ addptr(rsp, 8); + %} + ins_pipe( pipe_slow ); +%} instruct log10DPR_reg(regDPR1 dst, regDPR1 src) %{ predicate (UseSSE<=1);
--- a/src/cpu/x86/vm/x86_64.ad Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/x86/vm/x86_64.ad Fri May 25 14:45:35 2012 -0700 @@ -9823,7 +9823,39 @@ ins_pipe( pipe_slow ); %} - +instruct powD_reg(regD dst, regD src0, regD src1, rax_RegI rax, rdx_RegI rdx, rcx_RegI rcx, rFlagsReg cr) %{ + match(Set dst (PowD src0 src1)); // Raise src0 to the src1'th power + effect(KILL rax, KILL rdx, KILL rcx, KILL cr); + format %{ "fast_pow $src0 $src1 -> $dst // KILL $rax, $rcx, $rdx" %} + ins_encode %{ + __ subptr(rsp, 8); + __ movdbl(Address(rsp, 0), $src1$$XMMRegister); + __ fld_d(Address(rsp, 0)); + __ movdbl(Address(rsp, 0), $src0$$XMMRegister); + __ fld_d(Address(rsp, 0)); + __ fast_pow(); + __ fstp_d(Address(rsp, 0)); + __ movdbl($dst$$XMMRegister, Address(rsp, 0)); + __ addptr(rsp, 8); + %} + ins_pipe( pipe_slow ); +%} + +instruct expD_reg(regD dst, regD src, rax_RegI rax, rdx_RegI rdx, rcx_RegI rcx, rFlagsReg cr) %{ + match(Set dst (ExpD src)); + effect(KILL rax, KILL rcx, KILL rdx, KILL cr); + format %{ "fast_exp $dst -> $src // KILL $rax, $rcx, $rdx" %} + ins_encode %{ + __ subptr(rsp, 8); + __ movdbl(Address(rsp, 0), $src$$XMMRegister); + __ fld_d(Address(rsp, 0)); + __ fast_exp(); + __ fstp_d(Address(rsp, 0)); + __ movdbl($dst$$XMMRegister, Address(rsp, 0)); + __ addptr(rsp, 8); + %} + ins_pipe( pipe_slow ); +%} //----------Arithmetic Conversion Instructions---------------------------------
--- a/src/cpu/zero/vm/cppInterpreter_zero.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/cpu/zero/vm/cppInterpreter_zero.cpp Fri May 25 14:45:35 2012 -0700 @@ -1026,6 +1026,16 @@ java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); oop arg = VMSLOTS_OBJECT(arg_slot); jvalue arg_value; + if (arg == NULL) { + // queue a nullpointer exception for the caller + stack->set_sp(calculate_unwind_sp(stack, method_handle)); + CALL_VM_NOCHECK_NOFIX( + throw_exception( + thread, vmSymbols::java_lang_NullPointerException())); + // NB all oops trashed! + assert(HAS_PENDING_EXCEPTION, "should do"); + return; + } BasicType arg_type = java_lang_boxing_object::get_value(arg, &arg_value); if (arg_type == T_LONG || arg_type == T_DOUBLE) { intptr_t *unwind_sp = calculate_unwind_sp(stack, method_handle); @@ -1112,6 +1122,15 @@ case T_SHORT: return; } + // INT results sometimes need narrowing + case T_BOOLEAN: + case T_CHAR: + case T_BYTE: + case T_SHORT: + switch (src_rtype) { + case T_INT: + return; + } } tty->print_cr("unhandled conversion:");
--- a/src/os/bsd/vm/os_bsd.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/os/bsd/vm/os_bsd.cpp Fri May 25 14:45:35 2012 -0700 @@ -2340,93 +2340,21 @@ #endif } +void os::print_os_info_brief(outputStream* st) { + st->print("Bsd"); + + os::Posix::print_uname_info(st); +} void os::print_os_info(outputStream* st) { st->print("OS:"); - - // Try to identify popular distros. - // Most Bsd distributions have /etc/XXX-release file, which contains - // the OS version string. Some have more than one /etc/XXX-release file - // (e.g. Mandrake has both /etc/mandrake-release and /etc/redhat-release.), - // so the order is important. - if (!_print_ascii_file("/etc/mandrake-release", st) && - !_print_ascii_file("/etc/sun-release", st) && - !_print_ascii_file("/etc/redhat-release", st) && - !_print_ascii_file("/etc/SuSE-release", st) && - !_print_ascii_file("/etc/turbobsd-release", st) && - !_print_ascii_file("/etc/gentoo-release", st) && - !_print_ascii_file("/etc/debian_version", st) && - !_print_ascii_file("/etc/ltib-release", st) && - !_print_ascii_file("/etc/angstrom-version", st)) { - st->print("Bsd"); - } - st->cr(); - - // kernel - st->print("uname:"); - struct utsname name; - uname(&name); - st->print(name.sysname); st->print(" "); - st->print(name.release); st->print(" "); - st->print(name.version); st->print(" "); - st->print(name.machine); - st->cr(); - -#ifndef _ALLBSD_SOURCE - // Print warning if unsafe chroot environment detected - if (unsafe_chroot_detected) { - st->print("WARNING!! "); - st->print_cr(unstable_chroot_error); - } - - // libc, pthread - st->print("libc:"); - st->print(os::Bsd::glibc_version()); st->print(" "); - st->print(os::Bsd::libpthread_version()); st->print(" "); - if (os::Bsd::is_BsdThreads()) { - st->print("(%s stack)", os::Bsd::is_floating_stack() ? "floating" : "fixed"); - } - st->cr(); -#endif - - // rlimit - st->print("rlimit:"); - struct rlimit rlim; - - st->print(" STACK "); - getrlimit(RLIMIT_STACK, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%uk", rlim.rlim_cur >> 10); - - st->print(", CORE "); - getrlimit(RLIMIT_CORE, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%uk", rlim.rlim_cur >> 10); - - st->print(", NPROC "); - getrlimit(RLIMIT_NPROC, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%d", rlim.rlim_cur); - - st->print(", NOFILE "); - getrlimit(RLIMIT_NOFILE, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%d", rlim.rlim_cur); - -#ifndef _ALLBSD_SOURCE - st->print(", AS "); - getrlimit(RLIMIT_AS, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%uk", rlim.rlim_cur >> 10); - st->cr(); - - // load average - st->print("load average:"); - double loadavg[3]; - os::loadavg(loadavg, 3); - st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]); - st->cr(); -#endif + st->print("Bsd"); + + os::Posix::print_uname_info(st); + + os::Posix::print_rlimit_info(st); + + os::Posix::print_load_average(st); } void os::pd_print_cpu_info(outputStream* st) {
--- a/src/os/linux/vm/os_linux.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/os/linux/vm/os_linux.cpp Fri May 25 14:45:35 2012 -0700 @@ -2020,15 +2020,43 @@ } } +void os::print_os_info_brief(outputStream* st) { + os::Linux::print_distro_info(st); + + os::Posix::print_uname_info(st); + + os::Linux::print_libversion_info(st); + +} void os::print_os_info(outputStream* st) { st->print("OS:"); - // Try to identify popular distros. - // Most Linux distributions have /etc/XXX-release file, which contains - // the OS version string. Some have more than one /etc/XXX-release file - // (e.g. Mandrake has both /etc/mandrake-release and /etc/redhat-release.), - // so the order is important. + os::Linux::print_distro_info(st); + + os::Posix::print_uname_info(st); + + // Print warning if unsafe chroot environment detected + if (unsafe_chroot_detected) { + st->print("WARNING!! "); + st->print_cr(unstable_chroot_error); + } + + os::Linux::print_libversion_info(st); + + os::Posix::print_rlimit_info(st); + + os::Posix::print_load_average(st); + + os::Linux::print_full_memory_info(st); +} + +// Try to identify popular distros. +// Most Linux distributions have /etc/XXX-release file, which contains +// the OS version string. Some have more than one /etc/XXX-release file +// (e.g. Mandrake has both /etc/mandrake-release and /etc/redhat-release.), +// so the order is important. +void os::Linux::print_distro_info(outputStream* st) { if (!_print_ascii_file("/etc/mandrake-release", st) && !_print_ascii_file("/etc/sun-release", st) && !_print_ascii_file("/etc/redhat-release", st) && @@ -2041,23 +2069,9 @@ st->print("Linux"); } st->cr(); - - // kernel - st->print("uname:"); - struct utsname name; - uname(&name); - st->print(name.sysname); st->print(" "); - st->print(name.release); st->print(" "); - st->print(name.version); st->print(" "); - st->print(name.machine); - st->cr(); - - // Print warning if unsafe chroot environment detected - if (unsafe_chroot_detected) { - st->print("WARNING!! "); - st->print_cr(unstable_chroot_error); - } - +} + +void os::Linux::print_libversion_info(outputStream* st) { // libc, pthread st->print("libc:"); st->print(os::Linux::glibc_version()); st->print(" "); @@ -2066,56 +2080,12 @@ st->print("(%s stack)", os::Linux::is_floating_stack() ? "floating" : "fixed"); } st->cr(); - - // rlimit - st->print("rlimit:"); - struct rlimit rlim; - - st->print(" STACK "); - getrlimit(RLIMIT_STACK, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%uk", rlim.rlim_cur >> 10); - - st->print(", CORE "); - getrlimit(RLIMIT_CORE, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%uk", rlim.rlim_cur >> 10); - - st->print(", NPROC "); - getrlimit(RLIMIT_NPROC, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%d", rlim.rlim_cur); - - st->print(", NOFILE "); - getrlimit(RLIMIT_NOFILE, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%d", rlim.rlim_cur); - - st->print(", AS "); - getrlimit(RLIMIT_AS, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%uk", rlim.rlim_cur >> 10); - st->cr(); - - // load average - st->print("load average:"); - double loadavg[3]; - os::loadavg(loadavg, 3); - st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]); - st->cr(); - - // meminfo - st->print("\n/proc/meminfo:\n"); - _print_ascii_file("/proc/meminfo", st); - st->cr(); -} - -void os::pd_print_cpu_info(outputStream* st) { - st->print("\n/proc/cpuinfo:\n"); - if (!_print_ascii_file("/proc/cpuinfo", st)) { - st->print(" <Not Available>"); - } - st->cr(); +} + +void os::Linux::print_full_memory_info(outputStream* st) { + st->print("\n/proc/meminfo:\n"); + _print_ascii_file("/proc/meminfo", st); + st->cr(); } void os::print_memory_info(outputStream* st) { @@ -2138,6 +2108,14 @@ st->cr(); } +void os::pd_print_cpu_info(outputStream* st) { + st->print("\n/proc/cpuinfo:\n"); + if (!_print_ascii_file("/proc/cpuinfo", st)) { + st->print(" <Not Available>"); + } + st->cr(); +} + // Taken from /usr/include/bits/siginfo.h Supposed to be architecture specific // but they're the same for all the linux arch that we support // and they're the same for solaris but there's no common place to put this.
--- a/src/os/linux/vm/os_linux.hpp Thu May 24 16:15:37 2012 -0700 +++ b/src/os/linux/vm/os_linux.hpp Fri May 25 14:45:35 2012 -0700 @@ -89,6 +89,10 @@ static bool hugetlbfs_sanity_check(bool warn, size_t page_size); + static void print_full_memory_info(outputStream* st); + static void print_distro_info(outputStream* st); + static void print_libversion_info(outputStream* st); + public: static void init_thread_fpu_state(); static int get_fpu_control_word();
--- a/src/os/posix/vm/os_posix.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/os/posix/vm/os_posix.cpp Fri May 25 14:45:35 2012 -0700 @@ -28,6 +28,8 @@ #include <unistd.h> #include <sys/resource.h> +#include <sys/utsname.h> + // Check core dump limit and report possible place where core can be found void os::check_or_create_dump(void* exceptionRecord, void* contextRecord, char* buffer, size_t bufferSize) { @@ -72,3 +74,59 @@ // don't do anything on posix platforms return; } + +void os::Posix::print_load_average(outputStream* st) { + st->print("load average:"); + double loadavg[3]; + os::loadavg(loadavg, 3); + st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]); + st->cr(); +} + +void os::Posix::print_rlimit_info(outputStream* st) { + st->print("rlimit:"); + struct rlimit rlim; + + st->print(" STACK "); + getrlimit(RLIMIT_STACK, &rlim); + if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); + else st->print("%uk", rlim.rlim_cur >> 10); + + st->print(", CORE "); + getrlimit(RLIMIT_CORE, &rlim); + if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); + else st->print("%uk", rlim.rlim_cur >> 10); + + //Isn't there on solaris +#ifndef TARGET_OS_FAMILY_solaris + st->print(", NPROC "); + getrlimit(RLIMIT_NPROC, &rlim); + if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); + else st->print("%d", rlim.rlim_cur); +#endif + + st->print(", NOFILE "); + getrlimit(RLIMIT_NOFILE, &rlim); + if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); + else st->print("%d", rlim.rlim_cur); + + st->print(", AS "); + getrlimit(RLIMIT_AS, &rlim); + if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); + else st->print("%uk", rlim.rlim_cur >> 10); + st->cr(); +} + +void os::Posix::print_uname_info(outputStream* st) { + // kernel + st->print("uname:"); + struct utsname name; + uname(&name); + st->print(name.sysname); st->print(" "); + st->print(name.release); st->print(" "); + st->print(name.version); st->print(" "); + st->print(name.machine); + st->cr(); +} + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/os/posix/vm/os_posix.hpp Fri May 25 14:45:35 2012 -0700 @@ -0,0 +1,41 @@ +/* + * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef OS_POSIX_VM_OS_POSIX_HPP +#define OS_POSIX_VM_OS_POSIX_HPP +class Posix { + friend class os; + +protected: + static void print_distro_info(outputStream* st); + static void print_rlimit_info(outputStream* st); + static void print_uname_info(outputStream* st); + static void print_libversion_info(outputStream* st); + static void print_load_average(outputStream* st); + + +}; + + +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/os/solaris/add_gnu_debuglink/add_gnu_debuglink.c Fri May 25 14:45:35 2012 -0700 @@ -0,0 +1,285 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/* + * Name: add_gnu_debuglink.c + * + * Description: Add a ".gnu_debuglink" section that refers to the specified + * debug_info_path to the specified ELF object. + * + * This program is adapted from the example program shown on the + * elf(3elf) man page and from code from the Solaris compiler + * driver. + */ + +/* + * needed to define SHF_EXCLUDE + */ +#define ELF_TARGET_ALL + +#include <fcntl.h> +#include <stdio.h> +#include <libelf.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +static void failure(void); +static unsigned int gnu_debuglink_crc32(unsigned int crc, unsigned char *buf, + size_t len); + +void +main(int argc, char ** argv) { + /* new ELF section name */ + static char SEC_NAME[] = ".gnu_debuglink"; + + unsigned char buffer[8 * 1024]; /* I/O buffer */ + int buffer_len; /* buffer length */ + char * debug_info_path; /* debug info path */ + void * ehdr; /* ELF header */ + Elf * elf; /* ELF descriptor */ + char * elf_ident; /* ELF identity string */ + char * elf_obj; /* elf_obj file */ + int fd; /* descriptor for files */ + unsigned int file_crc = 0; /* CRC for debug info file */ + int is_elfclass64; /* is an ELFCLASS64 file? */ + Elf_Data * link_dat; /* ELF data for new debug info link */ + Elf_Data * name_dat; /* ELF data for new section name */ + Elf_Scn * new_scn; /* new ELF section descriptor */ + void * new_shdr; /* new ELF section header */ + Elf_Scn * scn; /* ELF section descriptor */ + void * shdr; /* ELF section header */ + + if (argc != 3) { + (void) fprintf(stderr, "Usage: %s debug_info_path elf_obj\n", argv[0]); + exit(2); + } + + debug_info_path = argv[1]; /* save for later */ + if ((fd = open(debug_info_path, O_RDONLY)) == -1) { + (void) fprintf(stderr, "%s: cannot open file.\n", debug_info_path); + exit(3); + } + + (void) printf("Computing CRC for '%s'\n", debug_info_path); + (void) fflush(stdout); + /* compute CRC for the debug info file */ + for (;;) { + int len = read(fd, buffer, sizeof buffer); + if (len <= 0) { + break; + } + file_crc = gnu_debuglink_crc32(file_crc, buffer, len); + } + (void) close(fd); + + /* open the elf_obj */ + elf_obj = argv[2]; + if ((fd = open(elf_obj, O_RDWR)) == -1) { + (void) fprintf(stderr, "%s: cannot open file.\n", elf_obj); + exit(4); + } + + (void) printf("Opening '%s' for update\n", elf_obj); + (void) fflush(stdout); + (void) elf_version(EV_CURRENT); /* coordinate ELF versions */ + + /* obtain the ELF descriptors from the input file */ + if ((elf = elf_begin(fd, ELF_C_RDWR, NULL)) == NULL) { + failure(); + } + + /* determine if ELFCLASS64 or not? */ + elf_ident = elf_getident(elf, NULL); + is_elfclass64 = (elf_ident[EI_CLASS] == ELFCLASS64); + + /* get the ELF header */ + if (is_elfclass64) { + ehdr = elf64_getehdr(elf); + } else { + ehdr = elf32_getehdr(elf); + } + if (ehdr == NULL) { + failure(); + } + + /* get the ELF section descriptor */ + if (is_elfclass64) { + scn = elf_getscn(elf, ((Elf64_Ehdr *) ehdr)->e_shstrndx); + } else { + scn = elf_getscn(elf, ((Elf32_Ehdr *) ehdr)->e_shstrndx); + } + if (scn == NULL) { + failure(); + } + + /* get the section header */ + if (is_elfclass64) { + shdr = elf64_getshdr(scn); + } else { + shdr = elf32_getshdr(scn); + } + if (shdr == NULL) { + failure(); + } + + (void) printf("Adding ELF data for new section name\n"); + (void) fflush(stdout); + name_dat = elf_newdata(scn); + name_dat->d_buf = (void *) SEC_NAME; + if (is_elfclass64) { + name_dat->d_off = ((Elf64_Shdr *) shdr)->sh_size + 1; + } else { + name_dat->d_off = ((Elf32_Shdr *) shdr)->sh_size + 1; + } + name_dat->d_align = 1; + name_dat->d_size = strlen(SEC_NAME) + 1; + + new_scn = elf_newscn(elf); + + if (is_elfclass64) { + new_shdr = elf64_getshdr(new_scn); + ((Elf64_Shdr *) new_shdr)->sh_flags = SHF_EXCLUDE; + ((Elf64_Shdr *) new_shdr)->sh_type = SHT_PROGBITS; + ((Elf64_Shdr *) new_shdr)->sh_name = ((Elf64_Shdr *) shdr)->sh_size; + ((Elf64_Shdr *) new_shdr)->sh_addralign = 1; + ((Elf64_Shdr *) shdr)->sh_size += (strlen(SEC_NAME) + 1); + } else { + new_shdr = elf32_getshdr(new_scn); + ((Elf32_Shdr *) new_shdr)->sh_flags = SHF_EXCLUDE; + ((Elf32_Shdr *) new_shdr)->sh_type = SHT_PROGBITS; + ((Elf32_Shdr *) new_shdr)->sh_name = ((Elf32_Shdr *) shdr)->sh_size; + ((Elf32_Shdr *) new_shdr)->sh_addralign = 1; + ((Elf32_Shdr *) shdr)->sh_size += (strlen(SEC_NAME) + 1); + } + + (void) printf("Adding ELF data for debug_info_path value\n"); + (void) fflush(stdout); + (void) memset(buffer, 0, sizeof buffer); + buffer_len = strlen(debug_info_path) + 1; /* +1 for NUL */ + (void) strncpy((char *) buffer, debug_info_path, buffer_len); + if (buffer_len % 4 != 0) { + /* not on a 4 byte boundary so pad to the next one */ + buffer_len += (4 - buffer_len % 4); + } + /* save the CRC */ + (void) memcpy(&buffer[buffer_len], &file_crc, sizeof file_crc); + buffer_len += sizeof file_crc; + + link_dat = elf_newdata(new_scn); + link_dat->d_type = ELF_T_BYTE; + link_dat->d_size = buffer_len; + link_dat->d_buf = buffer; + link_dat->d_align = 1; + + (void) printf("Saving updates to '%s'\n", elf_obj); + (void) fflush(stdout); + (void) elf_update(elf, ELF_C_NULL); /* recalc ELF memory structures */ + (void) elf_update(elf, ELF_C_WRITE); /* write out changes to ELF obj */ + (void) elf_end(elf); /* done with ELF obj */ + (void) close(fd); + + (void) printf("Done updating '%s'\n", elf_obj); + (void) fflush(stdout); + exit(0); +} /* end main */ + + +static void +failure() { + (void) fprintf(stderr, "%s\n", elf_errmsg(elf_errno())); + exit(5); +} + + +/* + * The CRC used in gnu_debuglink, retrieved from + * http://sourceware.org/gdb/current/onlinedocs/gdb/Separate-Debug-Files.html#Separate-Debug-Files. + */ + +static unsigned int +gnu_debuglink_crc32(unsigned int crc, unsigned char *buf, size_t len) { + static const unsigned int crc32_table[256] = { + 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, + 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, + 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, + 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, + 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, + 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, + 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, + 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, + 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, + 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, + 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, + 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, + 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, + 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, + 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, + 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, + 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, + 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, + 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, + 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, + 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, + 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, + 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, + 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, + 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, + 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, + 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, + 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, + 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, + 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, + 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, + 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, + 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, + 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, + 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, + 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, + 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, + 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, + 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, + 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, + 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, + 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, + 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, + 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, + 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, + 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, + 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, + 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, + 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, + 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, + 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, + 0x2d02ef8d + }; + + unsigned char *end; + + crc = ~crc & 0xffffffff; + for (end = buf + len; buf < end; ++buf) { + crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8); + } + return ~crc & 0xffffffff; +}
--- a/src/os/solaris/vm/os_solaris.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/os/solaris/vm/os_solaris.cpp Fri May 25 14:45:35 2012 -0700 @@ -2242,61 +2242,44 @@ return true; } +void os::print_os_info_brief(outputStream* st) { + os::Solaris::print_distro_info(st); + + os::Posix::print_uname_info(st); + + os::Solaris::print_libversion_info(st); +} + void os::print_os_info(outputStream* st) { st->print("OS:"); + os::Solaris::print_distro_info(st); + + os::Posix::print_uname_info(st); + + os::Solaris::print_libversion_info(st); + + os::Posix::print_rlimit_info(st); + + os::Posix::print_load_average(st); +} + +void os::Solaris::print_distro_info(outputStream* st) { if (!_print_ascii_file("/etc/release", st)) { - st->print("Solaris"); + st->print("Solaris"); + } + st->cr(); +} + +void os::Solaris::print_libversion_info(outputStream* st) { + if (os::Solaris::T2_libthread()) { + st->print(" (T2 libthread)"); + } + else { + st->print(" (T1 libthread)"); } st->cr(); - - // kernel - st->print("uname:"); - struct utsname name; - uname(&name); - st->print(name.sysname); st->print(" "); - st->print(name.release); st->print(" "); - st->print(name.version); st->print(" "); - st->print(name.machine); - - // libthread - if (os::Solaris::T2_libthread()) st->print(" (T2 libthread)"); - else st->print(" (T1 libthread)"); - st->cr(); - - // rlimit - st->print("rlimit:"); - struct rlimit rlim; - - st->print(" STACK "); - getrlimit(RLIMIT_STACK, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%uk", rlim.rlim_cur >> 10); - - st->print(", CORE "); - getrlimit(RLIMIT_CORE, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%uk", rlim.rlim_cur >> 10); - - st->print(", NOFILE "); - getrlimit(RLIMIT_NOFILE, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%d", rlim.rlim_cur); - - st->print(", AS "); - getrlimit(RLIMIT_AS, &rlim); - if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); - else st->print("%uk", rlim.rlim_cur >> 10); - st->cr(); - - // load average - st->print("load average:"); - double loadavg[3]; - os::loadavg(loadavg, 3); - st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]); - st->cr(); -} - +} static bool check_addr0(outputStream* st) { jboolean status = false;
--- a/src/os/solaris/vm/os_solaris.hpp Thu May 24 16:15:37 2012 -0700 +++ b/src/os/solaris/vm/os_solaris.hpp Fri May 25 14:45:35 2012 -0700 @@ -180,6 +180,9 @@ // proc_t structure (note that this is a system struct). static address _main_stack_base; + static void print_distro_info(outputStream* st); + static void print_libversion_info(outputStream* st); + public: static void libthread_init(); static void synchronization_init();
--- a/src/os/windows/vm/os_windows.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/os/windows/vm/os_windows.cpp Fri May 25 14:45:35 2012 -0700 @@ -1562,9 +1562,17 @@ enumerate_modules(pid, _print_module, (void *)st); } +void os::print_os_info_brief(outputStream* st) { + os::print_os_info(st); +} + void os::print_os_info(outputStream* st) { st->print("OS:"); + os::win32::print_windows_version(st); +} + +void os::win32::print_windows_version(outputStream* st) { OSVERSIONINFOEX osvi; ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX)); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
--- a/src/os/windows/vm/os_windows.hpp Thu May 24 16:15:37 2012 -0700 +++ b/src/os/windows/vm/os_windows.hpp Fri May 25 14:45:35 2012 -0700 @@ -27,6 +27,7 @@ // Win32_OS defines the interface to windows operating systems class win32 { + friend class os; protected: static int _vm_page_size; @@ -39,6 +40,8 @@ static bool _is_windows_2003; static bool _is_windows_server; + static void print_windows_version(outputStream* st); + public: // Windows-specific interface: static void initialize_system_info();
--- a/src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp Fri May 25 14:45:35 2012 -0700 @@ -522,11 +522,12 @@ if ((sig == SIGSEGV || sig == SIGBUS) && os::is_poll_address((address)info->si_addr)) { stub = SharedRuntime::get_poll_stub(pc); -#if defined(__APPLE__) && !defined(AMD64) +#if defined(__APPLE__) // 32-bit Darwin reports a SIGBUS for nearly all memory access exceptions. + // 64-bit Darwin may also use a SIGBUS (seen with compressed oops). // Catching SIGBUS here prevents the implicit SIGBUS NULL check below from // being called, so only do so if the implicit NULL check is not necessary. - } else if (sig == SIGBUS && MacroAssembler::needs_explicit_null_check((int)info->si_addr)) { + } else if (sig == SIGBUS && MacroAssembler::needs_explicit_null_check((intptr_t)info->si_addr)) { #else } else if (sig == SIGBUS /* && info->si_code == BUS_OBJERR */) { #endif
--- a/src/share/vm/c1/c1_GraphBuilder.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/share/vm/c1/c1_GraphBuilder.cpp Fri May 25 14:45:35 2012 -0700 @@ -2949,6 +2949,8 @@ case vmIntrinsics::_dtan : // fall through case vmIntrinsics::_dlog : // fall through case vmIntrinsics::_dlog10 : // fall through + case vmIntrinsics::_dexp : // fall through + case vmIntrinsics::_dpow : // fall through { // Compiles where the root method is an intrinsic need a special // compilation environment because the bytecodes for the method @@ -2969,6 +2971,9 @@ _state = start_block->state()->copy_for_parsing(); _last = start_block; load_local(doubleType, 0); + if (scope->method()->intrinsic_id() == vmIntrinsics::_dpow) { + load_local(doubleType, 2); + } // Emit the intrinsic node. bool result = try_inline_intrinsics(scope->method()); @@ -3182,6 +3187,8 @@ case vmIntrinsics::_dtan : // fall through case vmIntrinsics::_dlog : // fall through case vmIntrinsics::_dlog10 : // fall through + case vmIntrinsics::_dexp : // fall through + case vmIntrinsics::_dpow : // fall through if (!InlineMathNatives) return false; cantrap = false; preserves_state = true;
--- a/src/share/vm/c1/c1_LIR.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/share/vm/c1/c1_LIR.cpp Fri May 25 14:45:35 2012 -0700 @@ -624,11 +624,13 @@ { assert(op->as_Op2() != NULL, "must be"); LIR_Op2* op2 = (LIR_Op2*)op; + assert(op2->_tmp2->is_illegal() && op2->_tmp3->is_illegal() && + op2->_tmp4->is_illegal() && op2->_tmp5->is_illegal(), "not used"); if (op2->_info) do_info(op2->_info); if (op2->_opr1->is_valid()) do_input(op2->_opr1); if (op2->_opr2->is_valid()) do_input(op2->_opr2); - if (op2->_tmp->is_valid()) do_temp(op2->_tmp); + if (op2->_tmp1->is_valid()) do_temp(op2->_tmp1); if (op2->_result->is_valid()) do_output(op2->_result); break; @@ -641,7 +643,8 @@ assert(op->as_Op2() != NULL, "must be"); LIR_Op2* op2 = (LIR_Op2*)op; - assert(op2->_info == NULL && op2->_tmp->is_illegal(), "not used"); + assert(op2->_info == NULL && op2->_tmp1->is_illegal() && op2->_tmp2->is_illegal() && + op2->_tmp3->is_illegal() && op2->_tmp4->is_illegal() && op2->_tmp5->is_illegal(), "not used"); assert(op2->_opr1->is_valid() && op2->_opr2->is_valid() && op2->_result->is_valid(), "used"); do_input(op2->_opr1); @@ -665,10 +668,12 @@ assert(op2->_opr1->is_valid(), "used"); assert(op2->_opr2->is_valid(), "used"); assert(op2->_result->is_valid(), "used"); + assert(op2->_tmp2->is_illegal() && op2->_tmp3->is_illegal() && + op2->_tmp4->is_illegal() && op2->_tmp5->is_illegal(), "not used"); do_input(op2->_opr1); do_temp(op2->_opr1); do_input(op2->_opr2); do_temp(op2->_opr2); - if (op2->_tmp->is_valid()) do_temp(op2->_tmp); + if (op2->_tmp1->is_valid()) do_temp(op2->_tmp1); do_output(op2->_result); break; @@ -682,6 +687,8 @@ if (op2->_opr1->is_valid()) do_temp(op2->_opr1); if (op2->_opr2->is_valid()) do_input(op2->_opr2); // exception object is input parameter assert(op2->_result->is_illegal(), "no result"); + assert(op2->_tmp2->is_illegal() && op2->_tmp3->is_illegal() && + op2->_tmp4->is_illegal() && op2->_tmp5->is_illegal(), "not used"); break; } @@ -702,7 +709,8 @@ case lir_sin: case lir_cos: case lir_log: - case lir_log10: { + case lir_log10: + case lir_exp: { assert(op->as_Op2() != NULL, "must be"); LIR_Op2* op2 = (LIR_Op2*)op; @@ -711,16 +719,47 @@ // Register input operand as temp to guarantee that it doesn't // overlap with the input. assert(op2->_info == NULL, "not used"); + assert(op2->_tmp5->is_illegal(), "not used"); + assert(op2->_tmp2->is_valid() == (op->code() == lir_exp), "not used"); + assert(op2->_tmp3->is_valid() == (op->code() == lir_exp), "not used"); + assert(op2->_tmp4->is_valid() == (op->code() == lir_exp), "not used"); assert(op2->_opr1->is_valid(), "used"); do_input(op2->_opr1); do_temp(op2->_opr1); if (op2->_opr2->is_valid()) do_temp(op2->_opr2); - if (op2->_tmp->is_valid()) do_temp(op2->_tmp); + if (op2->_tmp1->is_valid()) do_temp(op2->_tmp1); + if (op2->_tmp2->is_valid()) do_temp(op2->_tmp2); + if (op2->_tmp3->is_valid()) do_temp(op2->_tmp3); + if (op2->_tmp4->is_valid()) do_temp(op2->_tmp4); if (op2->_result->is_valid()) do_output(op2->_result); break; } + case lir_pow: { + assert(op->as_Op2() != NULL, "must be"); + LIR_Op2* op2 = (LIR_Op2*)op; + + // On x86 pow needs two temporary fpu stack slots: tmp1 and + // tmp2. Register input operands as temps to guarantee that it + // doesn't overlap with the temporary slots. + assert(op2->_info == NULL, "not used"); + assert(op2->_opr1->is_valid() && op2->_opr2->is_valid(), "used"); + assert(op2->_tmp1->is_valid() && op2->_tmp2->is_valid() && op2->_tmp3->is_valid() + && op2->_tmp4->is_valid() && op2->_tmp5->is_valid(), "used"); + assert(op2->_result->is_valid(), "used"); + + do_input(op2->_opr1); do_temp(op2->_opr1); + do_input(op2->_opr2); do_temp(op2->_opr2); + do_temp(op2->_tmp1); + do_temp(op2->_tmp2); + do_temp(op2->_tmp3); + do_temp(op2->_tmp4); + do_temp(op2->_tmp5); + do_output(op2->_result); + + break; + } // LIR_Op3 case lir_idiv: @@ -1670,6 +1709,8 @@ case lir_tan: s = "tan"; break; case lir_log: s = "log"; break; case lir_log10: s = "log10"; break; + case lir_exp: s = "exp"; break; + case lir_pow: s = "pow"; break; case lir_logic_and: s = "logic_and"; break; case lir_logic_or: s = "logic_or"; break; case lir_logic_xor: s = "logic_xor"; break; @@ -1892,7 +1933,11 @@ } in_opr1()->print(out); out->print(" "); in_opr2()->print(out); out->print(" "); - if (tmp_opr()->is_valid()) { tmp_opr()->print(out); out->print(" "); } + if (tmp1_opr()->is_valid()) { tmp1_opr()->print(out); out->print(" "); } + if (tmp2_opr()->is_valid()) { tmp2_opr()->print(out); out->print(" "); } + if (tmp3_opr()->is_valid()) { tmp3_opr()->print(out); out->print(" "); } + if (tmp4_opr()->is_valid()) { tmp4_opr()->print(out); out->print(" "); } + if (tmp5_opr()->is_valid()) { tmp5_opr()->print(out); out->print(" "); } result_opr()->print(out); }
--- a/src/share/vm/c1/c1_LIR.hpp Thu May 24 16:15:37 2012 -0700 +++ b/src/share/vm/c1/c1_LIR.hpp Fri May 25 14:45:35 2012 -0700 @@ -916,6 +916,8 @@ , lir_tan , lir_log , lir_log10 + , lir_exp + , lir_pow , lir_logic_and , lir_logic_or , lir_logic_xor @@ -1560,7 +1562,11 @@ LIR_Opr _opr1; LIR_Opr _opr2; BasicType _type; - LIR_Opr _tmp; + LIR_Opr _tmp1; + LIR_Opr _tmp2; + LIR_Opr _tmp3; + LIR_Opr _tmp4; + LIR_Opr _tmp5; LIR_Condition _condition; void verify() const; @@ -1573,7 +1579,11 @@ , _type(T_ILLEGAL) , _condition(condition) , _fpu_stack_size(0) - , _tmp(LIR_OprFact::illegalOpr) { + , _tmp1(LIR_OprFact::illegalOpr) + , _tmp2(LIR_OprFact::illegalOpr) + , _tmp3(LIR_OprFact::illegalOpr) + , _tmp4(LIR_OprFact::illegalOpr) + , _tmp5(LIR_OprFact::illegalOpr) { assert(code == lir_cmp, "code check"); } @@ -1584,7 +1594,11 @@ , _type(type) , _condition(condition) , _fpu_stack_size(0) - , _tmp(LIR_OprFact::illegalOpr) { + , _tmp1(LIR_OprFact::illegalOpr) + , _tmp2(LIR_OprFact::illegalOpr) + , _tmp3(LIR_OprFact::illegalOpr) + , _tmp4(LIR_OprFact::illegalOpr) + , _tmp5(LIR_OprFact::illegalOpr) { assert(code == lir_cmove, "code check"); assert(type != T_ILLEGAL, "cmove should have type"); } @@ -1597,25 +1611,38 @@ , _type(type) , _condition(lir_cond_unknown) , _fpu_stack_size(0) - , _tmp(LIR_OprFact::illegalOpr) { + , _tmp1(LIR_OprFact::illegalOpr) + , _tmp2(LIR_OprFact::illegalOpr) + , _tmp3(LIR_OprFact::illegalOpr) + , _tmp4(LIR_OprFact::illegalOpr) + , _tmp5(LIR_OprFact::illegalOpr) { assert(code != lir_cmp && is_in_range(code, begin_op2, end_op2), "code check"); } - LIR_Op2(LIR_Code code, LIR_Opr opr1, LIR_Opr opr2, LIR_Opr result, LIR_Opr tmp) + LIR_Op2(LIR_Code code, LIR_Opr opr1, LIR_Opr opr2, LIR_Opr result, LIR_Opr tmp1, LIR_Opr tmp2 = LIR_OprFact::illegalOpr, + LIR_Opr tmp3 = LIR_OprFact::illegalOpr, LIR_Opr tmp4 = LIR_OprFact::illegalOpr, LIR_Opr tmp5 = LIR_OprFact::illegalOpr) : LIR_Op(code, result, NULL) , _opr1(opr1) , _opr2(opr2) , _type(T_ILLEGAL) , _condition(lir_cond_unknown) , _fpu_stack_size(0) - , _tmp(tmp) { + , _tmp1(tmp1) + , _tmp2(tmp2) + , _tmp3(tmp3) + , _tmp4(tmp4) + , _tmp5(tmp5) { assert(code != lir_cmp && is_in_range(code, begin_op2, end_op2), "code check"); } LIR_Opr in_opr1() const { return _opr1; } LIR_Opr in_opr2() const { return _opr2; } BasicType type() const { return _type; } - LIR_Opr tmp_opr() const { return _tmp; } + LIR_Opr tmp1_opr() const { return _tmp1; } + LIR_Opr tmp2_opr() const { return _tmp2; } + LIR_Opr tmp3_opr() const { return _tmp3; } + LIR_Opr tmp4_opr() const { return _tmp4; } + LIR_Opr tmp5_opr() const { return _tmp5; } LIR_Condition condition() const { assert(code() == lir_cmp || code() == lir_cmove, "only valid for cmp and cmove"); return _condition; } @@ -2025,6 +2052,8 @@ void sin (LIR_Opr from, LIR_Opr to, LIR_Opr tmp1, LIR_Opr tmp2) { append(new LIR_Op2(lir_sin , from, tmp1, to, tmp2)); } void cos (LIR_Opr from, LIR_Opr to, LIR_Opr tmp1, LIR_Opr tmp2) { append(new LIR_Op2(lir_cos , from, tmp1, to, tmp2)); } void tan (LIR_Opr from, LIR_Opr to, LIR_Opr tmp1, LIR_Opr tmp2) { append(new LIR_Op2(lir_tan , from, tmp1, to, tmp2)); } + void exp (LIR_Opr from, LIR_Opr to, LIR_Opr tmp1, LIR_Opr tmp2, LIR_Opr tmp3, LIR_Opr tmp4, LIR_Opr tmp5) { append(new LIR_Op2(lir_exp , from, tmp1, to, tmp2, tmp3, tmp4, tmp5)); } + void pow (LIR_Opr arg1, LIR_Opr arg2, LIR_Opr res, LIR_Opr tmp1, LIR_Opr tmp2, LIR_Opr tmp3, LIR_Opr tmp4, LIR_Opr tmp5) { append(new LIR_Op2(lir_pow, arg1, arg2, res, tmp1, tmp2, tmp3, tmp4, tmp5)); } void add (LIR_Opr left, LIR_Opr right, LIR_Opr res) { append(new LIR_Op2(lir_add, left, right, res)); } void sub (LIR_Opr left, LIR_Opr right, LIR_Opr res, CodeEmitInfo* info = NULL) { append(new LIR_Op2(lir_sub, left, right, res, info)); }
--- a/src/share/vm/c1/c1_LIRAssembler.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/share/vm/c1/c1_LIRAssembler.cpp Fri May 25 14:45:35 2012 -0700 @@ -718,7 +718,7 @@ if (op->in_opr2()->is_constant()) { shift_op(op->code(), op->in_opr1(), op->in_opr2()->as_constant_ptr()->as_jint(), op->result_opr()); } else { - shift_op(op->code(), op->in_opr1(), op->in_opr2(), op->result_opr(), op->tmp_opr()); + shift_op(op->code(), op->in_opr1(), op->in_opr2(), op->result_opr(), op->tmp1_opr()); } break; @@ -746,6 +746,8 @@ case lir_cos: case lir_log: case lir_log10: + case lir_exp: + case lir_pow: intrinsic_op(op->code(), op->in_opr1(), op->in_opr2(), op->result_opr(), op); break;
--- a/src/share/vm/c1/c1_LIRGenerator.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/share/vm/c1/c1_LIRGenerator.cpp Fri May 25 14:45:35 2012 -0700 @@ -2960,7 +2960,9 @@ case vmIntrinsics::_dsqrt: // fall through case vmIntrinsics::_dtan: // fall through case vmIntrinsics::_dsin : // fall through - case vmIntrinsics::_dcos : do_MathIntrinsic(x); break; + case vmIntrinsics::_dcos : // fall through + case vmIntrinsics::_dexp : // fall through + case vmIntrinsics::_dpow : do_MathIntrinsic(x); break; case vmIntrinsics::_arraycopy: do_ArrayCopy(x); break; // java.nio.Buffer.checkIndex
--- a/src/share/vm/c1/c1_LinearScan.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/share/vm/c1/c1_LinearScan.cpp Fri May 25 14:45:35 2012 -0700 @@ -6579,6 +6579,8 @@ case lir_abs: case lir_log10: case lir_log: + case lir_pow: + case lir_exp: case lir_logic_and: case lir_logic_or: case lir_logic_xor:
--- a/src/share/vm/interpreter/abstractInterpreter.hpp Thu May 24 16:15:37 2012 -0700 +++ b/src/share/vm/interpreter/abstractInterpreter.hpp Fri May 25 14:45:35 2012 -0700 @@ -107,6 +107,8 @@ java_lang_math_sqrt, // implementation of java.lang.Math.sqrt (x) java_lang_math_log, // implementation of java.lang.Math.log (x) java_lang_math_log10, // implementation of java.lang.Math.log10 (x) + java_lang_math_pow, // implementation of java.lang.Math.pow (x,y) + java_lang_math_exp, // implementation of java.lang.Math.exp (x) java_lang_ref_reference_get, // implementation of java.lang.ref.Reference.get() number_of_method_entries, invalid = -1
--- a/src/share/vm/interpreter/interpreter.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/share/vm/interpreter/interpreter.cpp Fri May 25 14:45:35 2012 -0700 @@ -221,6 +221,8 @@ case vmIntrinsics::_dsqrt : return java_lang_math_sqrt ; case vmIntrinsics::_dlog : return java_lang_math_log ; case vmIntrinsics::_dlog10: return java_lang_math_log10; + case vmIntrinsics::_dpow : return java_lang_math_pow ; + case vmIntrinsics::_dexp : return java_lang_math_exp ; case vmIntrinsics::_Reference_get: return java_lang_ref_reference_get;
--- a/src/share/vm/interpreter/templateInterpreter.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/share/vm/interpreter/templateInterpreter.cpp Fri May 25 14:45:35 2012 -0700 @@ -370,6 +370,8 @@ method_entry(java_lang_math_sqrt ) method_entry(java_lang_math_log ) method_entry(java_lang_math_log10) + method_entry(java_lang_math_exp ) + method_entry(java_lang_math_pow ) method_entry(java_lang_ref_reference_get) // all native method kinds (must be one contiguous block)
--- a/src/share/vm/opto/doCall.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/share/vm/opto/doCall.cpp Fri May 25 14:45:35 2012 -0700 @@ -780,7 +780,7 @@ if( at_method_entry ) { // bump invocation counter if top method (for statistics) if (CountCompiledCalls && depth() == 1) { - const TypeInstPtr* addr_type = TypeInstPtr::make(method()); + const TypeOopPtr* addr_type = TypeOopPtr::make_from_constant(method()); Node* adr1 = makecon(addr_type); Node* adr2 = basic_plus_adr(adr1, adr1, in_bytes(methodOopDesc::compiled_invocation_counter_offset())); increment_counter(adr2);
--- a/src/share/vm/opto/library_call.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/share/vm/opto/library_call.cpp Fri May 25 14:45:35 2012 -0700 @@ -1557,9 +1557,6 @@ // every again. NaN results requires StrictMath.exp handling. if (too_many_traps(Deoptimization::Reason_intrinsic)) return false; - // Do not intrinsify on older platforms which lack cmove. - if (ConditionalMoveLimit == 0) return false; - _sp += arg_size(); // restore stack pointer Node *x = pop_math_arg(); Node *result = _gvn.transform(new (C, 2) ExpDNode(0,x)); @@ -1802,15 +1799,11 @@ case vmIntrinsics::_dsqrt: return Matcher::has_match_rule(Op_SqrtD) ? inline_sqrt(id) : false; case vmIntrinsics::_dabs: return Matcher::has_match_rule(Op_AbsD) ? inline_abs(id) : false; - // These intrinsics don't work on X86. The ad implementation doesn't - // handle NaN's properly. Instead of returning infinity, the ad - // implementation returns a NaN on overflow. See bug: 6304089 - // Once the ad implementations are fixed, change the code below - // to match the intrinsics above - case vmIntrinsics::_dexp: return + Matcher::has_match_rule(Op_ExpD) ? inline_exp(id) : runtime_math(OptoRuntime::Math_D_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dexp), "EXP"); case vmIntrinsics::_dpow: return + Matcher::has_match_rule(Op_PowD) ? inline_pow(id) : runtime_math(OptoRuntime::Math_DD_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dpow), "POW"); // These intrinsics are not yet correctly implemented
--- a/src/share/vm/opto/subnode.cpp Thu May 24 16:15:37 2012 -0700 +++ b/src/share/vm/opto/subnode.cpp Fri May 25 14:45:35 2012 -0700 @@ -1314,7 +1314,5 @@ if( t2->base() != Type::DoubleCon ) return Type::DOUBLE; double d1 = t1->getd(); double d2 = t2->getd(); - if( d1 < 0.0 ) return Type::DOUBLE; - if( d2 < 0.0 ) return Type::DOUBLE; return TypeD::make( StubRoutines::intrinsic_pow( d1, d2 ) ); }
--- a/src/share/vm/runtime/os.hpp Thu May 24 16:15:37 2012 -0700 +++ b/src/share/vm/runtime/os.hpp Fri May 25 14:45:35 2012 -0700 @@ -492,6 +492,7 @@ // Print out system information; they are called by fatal error handler. // Output format may be different on different platforms. static void print_os_info(outputStream* st); + static void print_os_info_brief(outputStream* st); static void print_cpu_info(outputStream* st); static void pd_print_cpu_info(outputStream* st); static void print_memory_info(outputStream* st); @@ -685,14 +686,17 @@ // Platform dependent stuff #ifdef TARGET_OS_FAMILY_linux # include "os_linux.hpp" +# include "os_posix.hpp" #endif #ifdef TARGET_OS_FAMILY_solaris # include "os_solaris.hpp" +# include "os_posix.hpp" #endif #ifdef TARGET_OS_FAMILY_windows # include "os_windows.hpp" #endif #ifdef TARGET_OS_FAMILY_bsd +# include "os_posix.hpp" # include "os_bsd.hpp" #endif #ifdef TARGET_OS_ARCH_linux_x86
--- a/test/compiler/6894807/Test6894807.sh Thu May 24 16:15:37 2012 -0700 +++ b/test/compiler/6894807/Test6894807.sh Fri May 25 14:45:35 2012 -0700 @@ -18,8 +18,6 @@ exit 1 fi -BIT_FLAG="" - # set platform-dependent variables OS=`uname -s` case "$OS" in @@ -27,12 +25,6 @@ NULL=/dev/null PS=":" FS="/" - ## for solaris, linux it's HOME - FILE_LOCATION=$HOME - if [ -f ${FILE_LOCATION}${FS}JDK64BIT -a ${OS} = "SunOS" ] - then - BIT_FLAG=`cat ${FILE_LOCATION}${FS}JDK64BIT | grep -v '^#'` - fi ;; Windows_* ) NULL=NUL @@ -50,9 +42,9 @@ THIS_DIR=`pwd` -${TESTJAVA}${FS}bin${FS}java ${BIT_FLAG} -version +${TESTJAVA}${FS}bin${FS}java ${TESTVMOPTS} -version -${TESTJAVA}${FS}bin${FS}java ${BIT_FLAG} -server IsInstanceTest > test.out 2>&1 +${TESTJAVA}${FS}bin${FS}java ${TESTVMOPTS} IsInstanceTest > test.out 2>&1 cat test.out
--- a/test/gc/6941923/test6941923.sh Thu May 24 16:15:37 2012 -0700 +++ b/test/gc/6941923/test6941923.sh Fri May 25 14:45:35 2012 -0700 @@ -30,7 +30,7 @@ exit 0 fi -$JAVA_HOME/bin/java -version > $NULL 2>&1 +$JAVA_HOME/bin/java ${TESTVMOPTS} -version > $NULL 2>&1 if [ $? != 0 ]; then echo "Wrong JAVA_HOME? JAVA_HOME: $JAVA_HOME" @@ -119,7 +119,7 @@ options="-Xloggc:$logfile -XX:+UseConcMarkSweepGC -XX:+PrintGC -XX:+PrintGCDetails -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=1 -XX:GCLogFileSize=$gclogsize" echo "Test gc log rotation in same file, wait for $tts minutes ...." -$JAVA_HOME/bin/java $options $testname $tts +$JAVA_HOME/bin/java ${TESTVMOPTS} $options $testname $tts if [ $? != 0 ]; then echo "$msgfail" exit -1 @@ -148,7 +148,7 @@ numoffiles=3 options="-Xloggc:$logfile -XX:+UseConcMarkSweepGC -XX:+PrintGC -XX:+PrintGCDetails -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=$numoffiles -XX:GCLogFileSize=$gclogsize" echo "Test gc log rotation in $numoffiles files, wait for $tts minutes ...." -$JAVA_HOME/bin/java $options $testname $tts +$JAVA_HOME/bin/java ${TESTVMOPTS} $options $testname $tts if [ $? != 0 ]; then echo "$msgfail" exit -1
--- a/test/runtime/6626217/Test6626217.sh Thu May 24 16:15:37 2012 -0700 +++ b/test/runtime/6626217/Test6626217.sh Fri May 25 14:45:35 2012 -0700 @@ -1,5 +1,5 @@ # -# Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # This code is free software; you can redistribute it and/or modify it @@ -46,8 +46,6 @@ exit 1 fi -BIT_FLAG="" - # set platform-dependent variables OS=`uname -s` case "$OS" in @@ -58,12 +56,6 @@ RM=/bin/rm CP=/bin/cp MV=/bin/mv - ## for solaris, linux it's HOME - FILE_LOCATION=$HOME - if [ -f ${FILE_LOCATION}${FS}JDK64BIT -a ${OS} = "SunOS" ] - then - BIT_FLAG=`cat ${FILE_LOCATION}${FS}JDK64BIT` - fi ;; Windows_* ) NULL=NUL @@ -87,7 +79,7 @@ JAVA=${TESTJAVA}${FS}bin${FS}java JAVAC=${TESTJAVA}${FS}bin${FS}javac -${JAVA} ${BIT_FLAG} -version +${JAVA} ${TESTVMOPTS} -version # Current directory is scratch directory, copy all the test source there # (for the subsequent moves to work). @@ -113,7 +105,7 @@ ${MV} many_loader.impl1 many_loader.class ${RM} many_loader.java -${JAVA} ${BIT_FLAG} -Xverify -Xint -cp . bug_21227 >test.out 2>&1 +${JAVA} ${TESTVMOPTS} -Xverify -Xint -cp . bug_21227 >test.out 2>&1 grep "loader constraint" test.out exit $?
--- a/test/runtime/6878713/Test6878713.sh Thu May 24 16:15:37 2012 -0700 +++ b/test/runtime/6878713/Test6878713.sh Fri May 25 14:45:35 2012 -0700 @@ -25,8 +25,6 @@ exit 1 fi -BIT_FLAG="" - # set platform-dependent variables OS=`uname -s` case "$OS" in @@ -34,12 +32,6 @@ NULL=/dev/null PS=":" FS="/" - ## for solaris, linux it's HOME - FILE_LOCATION=$HOME - if [ -f ${FILE_LOCATION}${FS}JDK64BIT -a ${OS} = "SunOS" ] - then - BIT_FLAG=`cat ${FILE_LOCATION}${FS}JDK64BIT | grep -v '^#'` - fi ;; Windows_* ) NULL=NUL @@ -57,11 +49,11 @@ THIS_DIR=`pwd` -${TESTJAVA}${FS}bin${FS}java ${BIT_FLAG} -version +${TESTJAVA}${FS}bin${FS}java ${TESTVMOPTS} -version ${TESTJAVA}${FS}bin${FS}jar xvf ${TESTSRC}${FS}testcase.jar -${TESTJAVA}${FS}bin${FS}java ${BIT_FLAG} OOMCrashClass1960_2 > test.out 2>&1 +${TESTJAVA}${FS}bin${FS}java ${TESTVMOPTS} OOMCrashClass1960_2 > test.out 2>&1 if [ -s core -o -s "hs_*.log" ] then
--- a/test/runtime/6929067/Test6929067.sh Thu May 24 16:15:37 2012 -0700 +++ b/test/runtime/6929067/Test6929067.sh Fri May 25 14:45:35 2012 -0700 @@ -19,8 +19,6 @@ echo "If this is incorrect, try setting the variable manually." fi -BIT_FLAG="" - # set platform-dependent variables OS=`uname -s` case "$OS" in @@ -42,7 +40,19 @@ ;; esac -LD_LIBRARY_PATH=.:${TESTJAVA}/jre/lib/i386/client:/usr/openwin/lib:/usr/dt/lib:/usr/lib:$LD_LIBRARY_PATH +# Choose arch: i386 or amd64 (test is Linux-specific) +# Cannot simply look at TESTVMOPTS as -d64 is not +# passed if there is only a 64-bit JVM available. + +${TESTJAVA}/bin/java ${TESTVMOPTS} -version 2>1 | grep "64-Bit" >/dev/null +if [ "$?" = "0" ] +then + ARCH=amd64 +else + ARCH=i386 +fi + +LD_LIBRARY_PATH=.:${TESTJAVA}/jre/lib/${ARCH}/client:/usr/openwin/lib:/usr/dt/lib:/usr/lib:$LD_LIBRARY_PATH export LD_LIBRARY_PATH THIS_DIR=`pwd` @@ -51,10 +61,10 @@ cp ${TESTSRC}${FS}T.java ${THIS_DIR} -${TESTJAVA}${FS}bin${FS}java ${BIT_FLAG} -fullversion +${TESTJAVA}${FS}bin${FS}java ${TESTVMOPTS} -fullversion ${TESTJAVA}${FS}bin${FS}javac T.java -gcc -o invoke -I${TESTJAVA}/include -I${TESTJAVA}/include/linux invoke.c ${TESTJAVA}/jre/lib/i386/client/libjvm.so +gcc -o invoke -I${TESTJAVA}/include -I${TESTJAVA}/include/linux invoke.c ${TESTJAVA}/jre/lib/${ARCH}/client/libjvm.so ./invoke exit $?
--- a/test/runtime/7020373/Test7020373.sh Thu May 24 16:15:37 2012 -0700 +++ b/test/runtime/7020373/Test7020373.sh Fri May 25 14:45:35 2012 -0700 @@ -27,8 +27,6 @@ exit 1 fi -BIT_FLAG="" - # set platform-dependent variables OS=`uname -s` case "$OS" in @@ -36,12 +34,6 @@ NULL=/dev/null PS=":" FS="/" - ## for solaris, linux it's HOME - FILE_LOCATION=$HOME - if [ -f ${FILE_LOCATION}${FS}JDK64BIT -a ${OS} = "SunOS" ] - then - BIT_FLAG=`cat ${FILE_LOCATION}${FS}JDK64BIT | grep -v '^#'` - fi ;; Windows_* ) NULL=NUL @@ -59,11 +51,11 @@ THIS_DIR=`pwd` -${TESTJAVA}${FS}bin${FS}java ${BIT_FLAG} -version +${TESTJAVA}${FS}bin${FS}java ${TESTVMOPTS} -version ${TESTJAVA}${FS}bin${FS}jar xvf ${TESTSRC}${FS}testcase.jar -${TESTJAVA}${FS}bin${FS}java ${BIT_FLAG} OOMCrashClass4000_1 > test.out 2>&1 +${TESTJAVA}${FS}bin${FS}java ${TESTVMOPTS} OOMCrashClass4000_1 > test.out 2>&1 cat test.out
--- a/test/runtime/7051189/Xchecksig.sh Thu May 24 16:15:37 2012 -0700 +++ b/test/runtime/7051189/Xchecksig.sh Fri May 25 14:45:35 2012 -0700 @@ -1,5 +1,5 @@ # -# Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # This code is free software; you can redistribute it and/or modify it @@ -41,18 +41,10 @@ fi -BIT_FLAG="" - OS=`uname -s` case "$OS" in SunOS | Linux ) FS="/" - ## for solaris, linux it's HOME - FILE_LOCATION=$HOME - if [ -f ${FILE_LOCATION}${FS}JDK64BIT -a ${OS} = "SunOS" ] - then - BIT_FLAG=`cat ${FILE_LOCATION}${FS}JDK64BIT` - fi ;; Windows_* ) printf "Not testing libjsig.so on Windows. PASSED.\n " @@ -69,20 +61,16 @@ # LD_PRELOAD arch needs to match the binary we run, so run the java # 64-bit binary directly if we are testing 64-bit (bin/ARCH/java). - -# However JPRT runs: .../solaris_x64_5.10-debug/bin/java -# ..which is 32-bit, when it has built the 64-bit version to test. -# -# How does this script know we are meant to run the 64-bit version? -# Can check for the path of the binary containing "x64" on Solaris. +# Check if TESTVMOPS contains -d64, but cannot use +# java ${TESTVMOPS} to run "java -d64" with LD_PRELOAD. if [ ${OS} -eq "SunOS" ] then - printf "SunOS test JAVA=${JAVA}" - printf ${JAVA} | grep x64 > /dev/null + printf "SunOS test TESTVMOPTS = ${TESTVMOPTS}" + printf ${TESTVMOPTS} | grep d64 > /dev/null if [ $? -eq 0 ] then - printf "SunOS x64 test, forcing -d64\n" + printf "SunOS 64-bit test\n" BIT_FLAG=-d64 fi fi @@ -127,20 +115,19 @@ printf "Skipping test: libjsig missing for given architecture: ${LIBJSIG}\n" exit 0 fi -# Use java -version to test, java version info appeas on stderr, +# Use java -version to test, java version info appears on stderr, # the libjsig message we are removing appears on stdout. # grep returns zero meaning found, non-zero means not found: -LD_PRELOAD=${LIBJSIG} ${JAVA} ${BIT_FLAG} -Xcheck:jni -version 2>&1 | grep "libjsig is activated" - +LD_PRELOAD=${LIBJSIG} ${JAVA} ${TESTVMOPTS} -Xcheck:jni -version 2>&1 | grep "libjsig is activated" if [ $? -eq 0 ]; then printf "Failed: -Xcheck:jni prints message when libjsig.so is loaded.\n" exit 1 fi -LD_PRELOAD=${LIBJSIG} ${JAVA} ${BIT_FLAG} -Xcheck:jni -verbose:jni -version 2>&1 | grep "libjsig is activated" +LD_PRELOAD=${LIBJSIG} ${JAVA} ${TESTVMOPTS} -Xcheck:jni -verbose:jni -version 2>&1 | grep "libjsig is activated" if [ $? != 0 ]; then printf "Failed: -Xcheck:jni does not print message when libjsig.so is loaded and -verbose:jni is set.\n" exit 1
--- a/test/runtime/7158988/TestFieldMonitor.sh Thu May 24 16:15:37 2012 -0700 +++ b/test/runtime/7158988/TestFieldMonitor.sh Fri May 25 14:45:35 2012 -0700 @@ -18,8 +18,6 @@ exit 1 fi -BIT_FLAG="" - # set platform-dependent variables OS=`uname -s` case "$OS" in @@ -27,12 +25,6 @@ NULL=/dev/null PS=":" FS="/" - ## for solaris, linux it's HOME - FILE_LOCATION=$HOME - if [ -f ${FILE_LOCATION}${FS}JDK64BIT -a ${OS} = "SunOS" -a `uname -p`='sparc' ] - then - BIT_FLAG="-d64" - fi ;; Windows_95 | Windows_98 | Windows_ME ) NULL=NUL @@ -56,11 +48,11 @@ cp ${TESTSRC}${FS}*.java . -${TESTJAVA}${FS}bin${FS}java ${BIT_FLAG} -fullversion +${TESTJAVA}${FS}bin${FS}java ${TESTVMOPTS} -fullversion ${TESTJAVA}${FS}bin${FS}javac -classpath .${PS}$TESTJAVA${FS}lib${FS}tools.jar *.java -${TESTJAVA}${FS}bin${FS}java ${BIT_FLAG} -classpath .${PS}$TESTJAVA${FS}lib${FS}tools.jar FieldMonitor > test.out 2>&1 & +${TESTJAVA}${FS}bin${FS}java ${TESTVMOPTS} -classpath .${PS}$TESTJAVA${FS}lib${FS}tools.jar FieldMonitor > test.out 2>&1 & P_PID=$!