# HG changeset patch # User acorn # Date 1236308849 18000 # Node ID 3db67f76d308233bf701cffdc3d9a44a0b0d63ef # Parent 5caef2219893e6c4597b238464eaba51e7b61330# Parent d8c7fa77a6dc2547735c002c638faacf7c0f9612 Merge diff -r 5caef2219893 -r 3db67f76d308 make/linux/makefiles/adlc.make --- a/make/linux/makefiles/adlc.make Mon Mar 02 16:56:51 2009 -0700 +++ b/make/linux/makefiles/adlc.make Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ # -# Copyright 1999-2008 Sun Microsystems, Inc. All Rights Reserved. +# Copyright 1999-2009 Sun Microsystems, Inc. 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 @@ -61,8 +61,8 @@ CPPFLAGS += -DASSERT # CFLAGS_WARN holds compiler options to suppress/enable warnings. -# Suppress warnings (for now) -CFLAGS_WARN = -w +# Compiler warnings are treated as errors +CFLAGS_WARN = -Werror CFLAGS += $(CFLAGS_WARN) OBJECTNAMES = \ diff -r 5caef2219893 -r 3db67f76d308 make/solaris/makefiles/adlc.make --- a/make/solaris/makefiles/adlc.make Mon Mar 02 16:56:51 2009 -0700 +++ b/make/solaris/makefiles/adlc.make Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ # -# Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved. +# Copyright 1997-2009 Sun Microsystems, Inc. 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 @@ -67,6 +67,8 @@ endif # CFLAGS_WARN holds compiler options to suppress/enable warnings. +# Compiler warnings are treated as errors +CFLAGS_WARN = +w -errwarn CFLAGS += $(CFLAGS_WARN) ifeq ("${Platform_compiler}", "sparcWorks") diff -r 5caef2219893 -r 3db67f76d308 src/cpu/sparc/vm/interp_masm_sparc.cpp diff -r 5caef2219893 -r 3db67f76d308 src/cpu/sparc/vm/nativeInst_sparc.hpp --- a/src/cpu/sparc/vm/nativeInst_sparc.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/cpu/sparc/vm/nativeInst_sparc.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -243,7 +243,7 @@ // Regenerate the instruction sequence that performs the 64 bit // sethi. This only does the sethi. The disp field (bottom 10 bits) - // must be handled seperately. + // must be handled separately. static void set_data64_sethi(address instaddr, intptr_t x); // combine the fields of a sethi/simm13 pair (simm13 = or, add, jmpl, ld/st) diff -r 5caef2219893 -r 3db67f76d308 src/cpu/sparc/vm/sparc.ad --- a/src/cpu/sparc/vm/sparc.ad Mon Mar 02 16:56:51 2009 -0700 +++ b/src/cpu/sparc/vm/sparc.ad Thu Mar 05 22:07:29 2009 -0500 @@ -189,7 +189,7 @@ // double fp register numbers. FloatRegisterImpl in register_sparc.hpp // wants 0-63, so we have to convert every time we want to use fp regs // with the macroassembler, using reg_to_DoubleFloatRegister_object(). -// 255 is a flag meaning 'dont go here'. +// 255 is a flag meaning "don't go here". // I believe we can't handle callee-save doubles D32 and up until // the place in the sparc stack crawler that asserts on the 255 is // fixed up. @@ -462,7 +462,7 @@ // Macros to extract hi & lo halves from a long pair. // G0 is not part of any long pair, so assert on that. -// Prevents accidently using G1 instead of G0. +// Prevents accidentally using G1 instead of G0. #define LONG_HI_REG(x) (x) #define LONG_LO_REG(x) (x) @@ -1431,7 +1431,7 @@ #ifndef _LP64 // In the LP64 build, all registers can be moved as aligned/adjacent - // pairs, so there's never any need to move the high bits seperately. + // pairs, so there's never any need to move the high bits separately. // The 32-bit builds have to deal with the 32-bit ABI which can force // all sorts of silly alignment problems. @@ -1624,7 +1624,7 @@ Register temp_reg = G3; assert( G5_ic_reg != temp_reg, "conflicting registers" ); - // Load klass from reciever + // Load klass from receiver __ load_klass(O0, temp_reg); // Compare against expected klass __ cmp(temp_reg, G5_ic_reg); @@ -4149,7 +4149,7 @@ //----------OPERAND CLASSES---------------------------------------------------- // Operand Classes are groups of operands that are used to simplify -// instruction definitions by not requiring the AD writer to specify seperate +// instruction definitions by not requiring the AD writer to specify separate // instructions for every form of operand when the instruction accepts // multiple operand types with the same basic encoding and format. The classic // case of this is memory operands. @@ -6847,7 +6847,7 @@ ins_pipe(sdiv_reg_reg); %} -// Magic constant, reciprical of 10 +// Magic constant, reciprocal of 10 instruct loadConI_x66666667(iRegIsafe dst) %{ effect( DEF dst ); @@ -6857,7 +6857,7 @@ ins_pipe(ialu_hi_lo_reg); %} -// Register Shift Right Arithmatic Long by 32-63 +// Register Shift Right Arithmetic Long by 32-63 instruct sra_31( iRegI dst, iRegI src ) %{ effect( DEF dst, USE src ); format %{ "SRA $src,31,$dst\t! Used in div-by-10" %} @@ -9048,7 +9048,7 @@ // These must follow all instruction definitions as they use the names // defined in the instructions definitions. // -// peepmatch ( root_instr_name [preceeding_instruction]* ); +// peepmatch ( root_instr_name [preceding_instruction]* ); // // peepconstraint %{ // (instruction_number.operand_name relational_op instruction_number.operand_name diff -r 5caef2219893 -r 3db67f76d308 src/cpu/sparc/vm/templateTable_sparc.cpp --- a/src/cpu/sparc/vm/templateTable_sparc.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/cpu/sparc/vm/templateTable_sparc.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1545,7 +1545,7 @@ // Handle all the JSR stuff here, then exit. // It's much shorter and cleaner than intermingling with the - // non-JSR normal-branch stuff occuring below. + // non-JSR normal-branch stuff occurring below. if( is_jsr ) { // compute return address as bci in Otos_i __ ld_ptr(Address(Lmethod, 0, in_bytes(methodOopDesc::const_offset())), G3_scratch); @@ -3079,7 +3079,7 @@ Label ok; // Check that entry is non-null. Null entries are probably a bytecode - // problem. If the interface isn't implemented by the reciever class, + // problem. If the interface isn't implemented by the receiver class, // the VM should throw IncompatibleClassChangeError. linkResolver checks // this too but that's only if the entry isn't already resolved, so we // need to check again. diff -r 5caef2219893 -r 3db67f76d308 src/cpu/x86/vm/assembler_x86.cpp --- a/src/cpu/x86/vm/assembler_x86.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/cpu/x86/vm/assembler_x86.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -6463,7 +6463,8 @@ Address index(noreg, tmp, Address::times_1); ExternalAddress page(os::get_memory_serialize_page()); - movptr(ArrayAddress(page, index), tmp); + // Size of store must match masking code above + movl(as_Address(ArrayAddress(page, index)), tmp); } // Calls to C land diff -r 5caef2219893 -r 3db67f76d308 src/cpu/x86/vm/c1_LIRGenerator_x86.cpp --- a/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -501,7 +501,7 @@ LIRItem right(x->y(), this); left.load_item(); - // dont load constants to save register + // don't load constants to save register right.load_nonconstant(); rlock_result(x); arithmetic_op_long(x->op(), x->operand(), left.result(), right.result(), NULL); diff -r 5caef2219893 -r 3db67f76d308 src/cpu/x86/vm/cppInterpreter_x86.cpp --- a/src/cpu/x86/vm/cppInterpreter_x86.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/cpu/x86/vm/cppInterpreter_x86.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -523,7 +523,7 @@ #ifdef _LP64 // Make sure stack is properly aligned and sized for the abi __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows - __ andptr(rsp, -16); // must be 16 byte boundry (see amd64 ABI) + __ andptr(rsp, -16); // must be 16 byte boundary (see amd64 ABI) #endif // _LP64 @@ -970,7 +970,7 @@ #ifdef _LP64 // duplicate the alignment rsp got after setting stack_base __ subptr(rax, frame::arg_reg_save_area_bytes); // windows - __ andptr(rax, -16); // must be 16 byte boundry (see amd64 ABI) + __ andptr(rax, -16); // must be 16 byte boundary (see amd64 ABI) #endif // _LP64 __ cmpptr(rax, rsp); __ jcc(Assembler::equal, L); @@ -1067,7 +1067,7 @@ #ifdef _LP64 __ subptr(rsp, t); __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows - __ andptr(rsp, -16); // must be 16 byte boundry (see amd64 ABI) + __ andptr(rsp, -16); // must be 16 byte boundary (see amd64 ABI) #else __ addptr(t, 2*wordSize); // allocate two more slots for JNIEnv and possible mirror __ subptr(rsp, t); diff -r 5caef2219893 -r 3db67f76d308 src/cpu/x86/vm/sharedRuntime_x86_64.cpp --- a/src/cpu/x86/vm/sharedRuntime_x86_64.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/cpu/x86/vm/sharedRuntime_x86_64.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1350,7 +1350,7 @@ { Label L; __ mov(rax, rsp); - __ andptr(rax, -16); // must be 16 byte boundry (see amd64 ABI) + __ andptr(rax, -16); // must be 16 byte boundary (see amd64 ABI) __ cmpptr(rax, rsp); __ jcc(Assembler::equal, L); __ stop("improperly aligned stack"); diff -r 5caef2219893 -r 3db67f76d308 src/cpu/x86/vm/templateInterpreter_x86_64.cpp --- a/src/cpu/x86/vm/templateInterpreter_x86_64.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/cpu/x86/vm/templateInterpreter_x86_64.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -826,7 +826,7 @@ __ subptr(rsp, t); __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows - __ andptr(rsp, -16); // must be 16 byte boundry (see amd64 ABI) + __ andptr(rsp, -16); // must be 16 byte boundary (see amd64 ABI) // get signature handler { diff -r 5caef2219893 -r 3db67f76d308 src/cpu/x86/vm/templateTable_x86_32.cpp --- a/src/cpu/x86/vm/templateTable_x86_32.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/cpu/x86/vm/templateTable_x86_32.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1586,7 +1586,7 @@ // Handle all the JSR stuff here, then exit. // It's much shorter and cleaner than intermingling with the - // non-JSR normal-branch stuff occuring below. + // non-JSR normal-branch stuff occurring below. if (is_jsr) { // Pre-load the next target bytecode into EBX __ load_unsigned_byte(rbx, Address(rsi, rdx, Address::times_1, 0)); diff -r 5caef2219893 -r 3db67f76d308 src/cpu/x86/vm/templateTable_x86_64.cpp --- a/src/cpu/x86/vm/templateTable_x86_64.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/cpu/x86/vm/templateTable_x86_64.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1559,7 +1559,7 @@ // Handle all the JSR stuff here, then exit. // It's much shorter and cleaner than intermingling with the non-JSR - // normal-branch stuff occuring below. + // normal-branch stuff occurring below. if (is_jsr) { // Pre-load the next target bytecode into rbx __ load_unsigned_byte(rbx, Address(r13, rdx, Address::times_1, 0)); diff -r 5caef2219893 -r 3db67f76d308 src/cpu/x86/vm/x86_32.ad --- a/src/cpu/x86/vm/x86_32.ad Mon Mar 02 16:56:51 2009 -0700 +++ b/src/cpu/x86/vm/x86_32.ad Thu Mar 05 22:07:29 2009 -0500 @@ -130,7 +130,7 @@ // allocation. Highest priority is first. A useful heuristic is to // give registers a low priority when they are required by machine // instructions, like EAX and EDX. Registers which are used as -// pairs must fall on an even boundry (witness the FPR#L's in this list). +// pairs must fall on an even boundary (witness the FPR#L's in this list). // For the Intel integer registers, the equivalent Long pairs are // EDX:EAX, EBX:ECX, and EDI:EBP. alloc_class chunk0( ECX, EBX, EBP, EDI, EAX, EDX, ESI, ESP, @@ -5857,7 +5857,7 @@ //----------OPERAND CLASSES---------------------------------------------------- // Operand Classes are groups of operands that are used as to simplify -// instruction definitions by not requiring the AD writer to specify seperate +// instruction definitions by not requiring the AD writer to specify separate // instructions for every form of operand when the instruction accepts // multiple operand types with the same basic encoding and format. The classic // case of this is memory operands. @@ -13220,7 +13220,7 @@ // These must follow all instruction definitions as they use the names // defined in the instructions definitions. // -// peepmatch ( root_instr_name [preceeding_instruction]* ); +// peepmatch ( root_instr_name [preceding_instruction]* ); // // peepconstraint %{ // (instruction_number.operand_name relational_op instruction_number.operand_name diff -r 5caef2219893 -r 3db67f76d308 src/cpu/x86/vm/x86_64.ad --- a/src/cpu/x86/vm/x86_64.ad Mon Mar 02 16:56:51 2009 -0700 +++ b/src/cpu/x86/vm/x86_64.ad Thu Mar 05 22:07:29 2009 -0500 @@ -5483,7 +5483,7 @@ //----------OPERAND CLASSES---------------------------------------------------- // Operand Classes are groups of operands that are used as to simplify -// instruction definitions by not requiring the AD writer to specify seperate +// instruction definitions by not requiring the AD writer to specify separate // instructions for every form of operand when the instruction accepts // multiple operand types with the same basic encoding and format. The classic // case of this is memory operands. @@ -8363,7 +8363,7 @@ //----------- DivL-By-Constant-Expansions-------------------------------------- // DivI cases are handled by the compiler -// Magic constant, reciprical of 10 +// Magic constant, reciprocal of 10 instruct loadConL_0x6666666666666667(rRegL dst) %{ effect(DEF dst); @@ -12082,7 +12082,7 @@ // These must follow all instruction definitions as they use the names // defined in the instructions definitions. // -// peepmatch ( root_instr_name [precerding_instruction]* ); +// peepmatch ( root_instr_name [preceding_instruction]* ); // // peepconstraint %{ // (instruction_number.operand_name relational_op instruction_number.operand_name diff -r 5caef2219893 -r 3db67f76d308 src/os/linux/launcher/java.c --- a/src/os/linux/launcher/java.c Mon Mar 02 16:56:51 2009 -0700 +++ b/src/os/linux/launcher/java.c Thu Mar 05 22:07:29 2009 -0500 @@ -419,7 +419,7 @@ goto leave; } mainClass = LoadClass(env, classname); - if(mainClass == NULL) { /* exception occured */ + if(mainClass == NULL) { /* exception occurred */ ReportExceptionDescription(env); message = "Could not find the main class. Program will exit."; goto leave; @@ -441,7 +441,7 @@ goto leave; } mainClass = LoadClass(env, classname); - if(mainClass == NULL) { /* exception occured */ + if(mainClass == NULL) { /* exception occurred */ ReportExceptionDescription(env); message = "Could not find the main class. Program will exit."; goto leave; diff -r 5caef2219893 -r 3db67f76d308 src/os/linux/launcher/java_md.h --- a/src/os/linux/launcher/java_md.h Mon Mar 02 16:56:51 2009 -0700 +++ b/src/os/linux/launcher/java_md.h Thu Mar 05 22:07:29 2009 -0500 @@ -47,7 +47,7 @@ #ifdef JAVA_ARGS /* * ApplicationHome is prepended to each of these entries; the resulting - * strings are concatenated (seperated by PATH_SEPARATOR) and used as the + * strings are concatenated (separated by PATH_SEPARATOR) and used as the * value of -cp option to the launcher. */ #ifndef APP_CLASSPATH diff -r 5caef2219893 -r 3db67f76d308 src/os/linux/vm/perfMemory_linux.cpp --- a/src/os/linux/vm/perfMemory_linux.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/os/linux/vm/perfMemory_linux.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -192,7 +192,7 @@ // check if the given path is considered a secure directory for // the backing store files. Returns true if the directory exists // and is considered a secure location. Returns false if the path -// is a symbolic link or if an error occured. +// is a symbolic link or if an error occurred. // static bool is_directory_secure(const char* path) { struct stat statbuf; diff -r 5caef2219893 -r 3db67f76d308 src/os/solaris/launcher/java.c --- a/src/os/solaris/launcher/java.c Mon Mar 02 16:56:51 2009 -0700 +++ b/src/os/solaris/launcher/java.c Thu Mar 05 22:07:29 2009 -0500 @@ -419,7 +419,7 @@ goto leave; } mainClass = LoadClass(env, classname); - if(mainClass == NULL) { /* exception occured */ + if(mainClass == NULL) { /* exception occurred */ ReportExceptionDescription(env); message = "Could not find the main class. Program will exit."; goto leave; @@ -441,7 +441,7 @@ goto leave; } mainClass = LoadClass(env, classname); - if(mainClass == NULL) { /* exception occured */ + if(mainClass == NULL) { /* exception occurred */ ReportExceptionDescription(env); message = "Could not find the main class. Program will exit."; goto leave; diff -r 5caef2219893 -r 3db67f76d308 src/os/solaris/launcher/java_md.h --- a/src/os/solaris/launcher/java_md.h Mon Mar 02 16:56:51 2009 -0700 +++ b/src/os/solaris/launcher/java_md.h Thu Mar 05 22:07:29 2009 -0500 @@ -47,7 +47,7 @@ #ifdef JAVA_ARGS /* * ApplicationHome is prepended to each of these entries; the resulting - * strings are concatenated (seperated by PATH_SEPARATOR) and used as the + * strings are concatenated (separated by PATH_SEPARATOR) and used as the * value of -cp option to the launcher. */ #ifndef APP_CLASSPATH diff -r 5caef2219893 -r 3db67f76d308 src/os/solaris/vm/perfMemory_solaris.cpp --- a/src/os/solaris/vm/perfMemory_solaris.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/os/solaris/vm/perfMemory_solaris.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -194,7 +194,7 @@ // check if the given path is considered a secure directory for // the backing store files. Returns true if the directory exists // and is considered a secure location. Returns false if the path -// is a symbolic link or if an error occured. +// is a symbolic link or if an error occurred. // static bool is_directory_secure(const char* path) { struct stat statbuf; diff -r 5caef2219893 -r 3db67f76d308 src/os/windows/vm/perfMemory_windows.cpp --- a/src/os/windows/vm/perfMemory_windows.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/os/windows/vm/perfMemory_windows.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -195,7 +195,7 @@ // check if the given path is considered a secure directory for // the backing store files. Returns true if the directory exists // and is considered a secure location. Returns false if the path -// is a symbolic link or if an error occured. +// is a symbolic link or if an error occurred. // static bool is_directory_secure(const char* path) { @@ -994,7 +994,7 @@ return false; } - // if running on windows 2000 or later, set the automatic inheritence + // if running on windows 2000 or later, set the automatic inheritance // control flags. SetSecurityDescriptorControlFnPtr _SetSecurityDescriptorControl; _SetSecurityDescriptorControl = (SetSecurityDescriptorControlFnPtr) @@ -1002,7 +1002,7 @@ "SetSecurityDescriptorControl"); if (_SetSecurityDescriptorControl != NULL) { - // We do not want to further propogate inherited DACLs, so making them + // We do not want to further propagate inherited DACLs, so making them // protected prevents that. if (!_SetSecurityDescriptorControl(pSD, SE_DACL_PROTECTED, SE_DACL_PROTECTED)) { diff -r 5caef2219893 -r 3db67f76d308 src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp --- a/src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -532,7 +532,7 @@ if (oldAct.sa_sigaction != signalHandler) { void* sighand = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction) : CAST_FROM_FN_PTR(void*, oldAct.sa_handler); - warning("Unexpected Signal %d occured under user-defined signal handler " INTPTR_FORMAT, sig, (intptr_t)sighand); + warning("Unexpected Signal %d occurred under user-defined signal handler " INTPTR_FORMAT, sig, (intptr_t)sighand); } } diff -r 5caef2219893 -r 3db67f76d308 src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp --- a/src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -694,7 +694,7 @@ if (oldAct.sa_sigaction != signalHandler) { void* sighand = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction) : CAST_FROM_FN_PTR(void*, oldAct.sa_handler); - warning("Unexpected Signal %d occured under user-defined signal handler %#lx", sig, (long)sighand); + warning("Unexpected Signal %d occurred under user-defined signal handler %#lx", sig, (long)sighand); } } diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/Makefile --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/Makefile Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,75 @@ +# +# Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, +# CA 95054 USA or visit www.sun.com if you need additional information or +# have any questions. +# +# +PKGLIST = \ +com.sun.hotspot.tools.compiler +#END PKGLIST + +FILELIST = com/sun/hotspot/tools/compiler/*.java + +ifneq "x$(ALT_BOOTDIR)" "x" + BOOTDIR := $(ALT_BOOTDIR) +endif + +ifeq "x$(BOOTDIR)" "x" + JDK_HOME := $(shell dirname $(shell which java))/.. +else + JDK_HOME := $(BOOTDIR) +endif + +isUnix := $(shell test -r c:/; echo $$?) + +ifeq "$(isUnix)" "1" + CPS := : +else + CPS := ";" +endif + +SRC_DIR = src +BUILD_DIR = build +OUTPUT_DIR = $(BUILD_DIR)/classes + +# gnumake 3.78.1 does not accept the *s, +# so use the shell to expand them +ALLFILES := $(patsubst %,$(SRC_DIR)/%,$(FILELIST)) +ALLFILES := $(shell /bin/ls $(ALLFILES)) + +JAVAC = $(JDK_HOME)/bin/javac +JAR = $(JDK_HOME)/bin/jar + +# Tagging it on because there's no reason not to run it +all: logc.jar + +logc.jar: filelist manifest.mf + @mkdir -p $(OUTPUT_DIR) + $(JAVAC) -source 1.5 -deprecation -sourcepath $(SRC_DIR) -d $(OUTPUT_DIR) @filelist + $(JAR) cvfm logc.jar manifest.mf -C $(OUTPUT_DIR) com + +.PHONY: filelist +filelist: $(ALLFILES) + @rm -f $@ + @echo $(ALLFILES) > $@ + +clean:: + rm -rf filelist logc.jar + rm -rf $(BUILD_DIR) diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/README --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/README Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,18 @@ +This is a very rough tool for parsing -XX:+LogCompilation output. +It's main purpose is to recreate output similar to +-XX:+PrintCompilation -XX:+PrintInlining output from a debug JVM. It +requires a 1.5 JDK to build and simply typing make should build it. + +It produces a jar file, logc.jar, that can be run on the +hotspot.log from LogCompilation output like this: + + java -jar logc.jar hotspot.log + +This will produce something like the normal PrintCompilation output. +Adding the -i option with also report inlining like PrintInlining. + +More information about the LogCompilation output can be found at + +http://wikis.sun.com/display/HotSpotInternals/LogCompilation+overview +http://wikis.sun.com/display/HotSpotInternals/PrintCompilation +http://wikis.sun.com/display/HotSpotInternals/LogCompilation+tool diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/manifest.mf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/manifest.mf Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,1 @@ +Main-Class: com.sun.hotspot.tools.compiler.LogCompilation diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/BasicLogEvent.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/BasicLogEvent.java Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,75 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package com.sun.hotspot.tools.compiler; + +import java.io.PrintStream; + +/** + * + * @author never + */ +public abstract class BasicLogEvent implements LogEvent { + + protected final String id; + protected final double start; + protected double end; + protected Compilation compilation; + + BasicLogEvent(double start, String id) { + this.start = start; + this.end = start; + this.id = id; + } + + public double getStart() { + return start; + } + + public double getEnd() { + return end; + } + + public void setEnd(double end) { + this.end = end; + } + + public double getElapsedTime() { + return ((int) ((getEnd() - getStart()) * 1000)) / 1000.0; + } + + public String getId() { + return id; + } + + public Compilation getCompilation() { + return compilation; + } + + public void setCompilation(Compilation compilation) { + this.compilation = compilation; + } + + abstract public void print(PrintStream stream); +} diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/CallSite.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/CallSite.java Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,183 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package com.sun.hotspot.tools.compiler; + +import java.io.PrintStream; +import java.util.ArrayList; +import java.util.List; + +public class CallSite { + + private int bci; + private Method method; + private int count; + private String receiver; + private int receiver_count; + private String reason; + private List calls; + + CallSite() { + } + + CallSite(int bci, Method m) { + this.bci = bci; + this.method = m; + } + + void add(CallSite site) { + if (getCalls() == null) { + setCalls(new ArrayList()); + } + getCalls().add(site); + } + + CallSite last() { + return last(-1); + } + + CallSite last(int fromEnd) { + return getCalls().get(getCalls().size() + fromEnd); + } + + public String toString() { + StringBuilder sb = new StringBuilder(); + if (getReason() == null) { + sb.append(" @ " + getBci() + " " + getMethod()); + } else { + sb.append("- @ " + getBci() + " " + getMethod() + " " + getReason()); + } + sb.append("\n"); + if (getCalls() != null) { + for (CallSite site : getCalls()) { + sb.append(site); + sb.append("\n"); + } + } + return sb.toString(); + } + + public void print(PrintStream stream) { + print(stream, 0); + } + + void emit(PrintStream stream, int indent) { + for (int i = 0; i < indent; i++) { + stream.print(' '); + } + } + private static boolean compat = true; + + public void print(PrintStream stream, int indent) { + emit(stream, indent); + String m = getMethod().getHolder().replace('/', '.') + "::" + getMethod().getName(); + if (getReason() == null) { + stream.println(" @ " + getBci() + " " + m + " (" + getMethod().getBytes() + " bytes)"); + + } else { + if (isCompat()) { + stream.println(" @ " + getBci() + " " + m + " " + getReason()); + } else { + stream.println("- @ " + getBci() + " " + m + + " (" + getMethod().getBytes() + " bytes) " + getReason()); + } + } + if (getReceiver() != null) { + emit(stream, indent + 3); + // stream.println("type profile " + method.holder + " -> " + receiver + " (" + + // receiver_count + "/" + count + "," + (receiver_count * 100 / count) + "%)"); + stream.println("type profile " + getMethod().getHolder() + " -> " + getReceiver() + " (" + + (getReceiverCount() * 100 / getCount()) + "%)"); + } + if (getCalls() != null) { + for (CallSite site : getCalls()) { + site.print(stream, indent + 2); + } + } + } + + public int getBci() { + return bci; + } + + public void setBci(int bci) { + this.bci = bci; + } + + public Method getMethod() { + return method; + } + + public void setMethod(Method method) { + this.method = method; + } + + public int getCount() { + return count; + } + + public void setCount(int count) { + this.count = count; + } + + public String getReceiver() { + return receiver; + } + + public void setReceiver(String receiver) { + this.receiver = receiver; + } + + public int getReceiverCount() { + return receiver_count; + } + + public void setReceiver_count(int receiver_count) { + this.receiver_count = receiver_count; + } + + public String getReason() { + return reason; + } + + public void setReason(String reason) { + this.reason = reason; + } + + public List getCalls() { + return calls; + } + + public void setCalls(List calls) { + this.calls = calls; + } + + public static boolean isCompat() { + return compat; + } + + public static void setCompat(boolean aCompat) { + compat = aCompat; + } +} diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/Compilation.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/Compilation.java Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,236 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package com.sun.hotspot.tools.compiler; + +import java.io.PrintStream; +import java.util.ArrayList; + +public class Compilation implements LogEvent { + + private int id; + private boolean osr; + private Method method; + private CallSite call = new CallSite(); + private int osrBci; + private String icount; + private String bcount; + private String special; + private double start; + private double end; + private int attempts; + private NMethod nmethod; + private ArrayList phases = new ArrayList(4); + private String failureReason; + + Compilation(int id) { + this.id = id; + } + + Phase getPhase(String s) { + for (Phase p : getPhases()) { + if (p.getName().equals(s)) { + return p; + } + } + return null; + } + + double getRegallocTime() { + return getPhase("regalloc").getElapsedTime(); + } + + public double getStart() { + return start; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(getId()); + sb.append(" "); + sb.append(getMethod()); + sb.append(" "); + sb.append(getIcount()); + sb.append("+"); + sb.append(getBcount()); + sb.append("\n"); + for (CallSite site : getCall().getCalls()) { + sb.append(site); + sb.append("\n"); + } + return sb.toString(); + } + + public void printShort(PrintStream stream) { + if (getMethod() == null) { + stream.println(getSpecial()); + } else { + int bc = isOsr() ? getOsr_bci() : -1; + stream.print(getId() + getMethod().decodeFlags(bc) + getMethod().format(bc)); + } + } + + public void print(PrintStream stream) { + print(stream, 0, false); + } + + public void print(PrintStream stream, boolean printInlining) { + print(stream, 0, printInlining); + } + + public void print(PrintStream stream, int indent, boolean printInlining) { + if (getMethod() == null) { + stream.println(getSpecial()); + } else { + int bc = isOsr() ? getOsr_bci() : -1; + stream.print(getId() + getMethod().decodeFlags(bc) + getMethod().format(bc)); + stream.println(); + if (getFailureReason() != null) { + stream.println("COMPILE FAILED " + getFailureReason()); + } + if (printInlining && call.getCalls() != null) { + for (CallSite site : call.getCalls()) { + site.print(stream, indent + 2); + } + } + } + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public boolean isOsr() { + return osr; + } + + public void setOsr(boolean osr) { + this.osr = osr; + } + + public int getOsr_bci() { + return osrBci; + } + + public void setOsr_bci(int osrBci) { + this.osrBci = osrBci; + } + + public String getIcount() { + return icount; + } + + public void setICount(String icount) { + this.icount = icount; + } + + public String getBcount() { + return bcount; + } + + public void setBCount(String bcount) { + this.bcount = bcount; + } + + public String getSpecial() { + return special; + } + + public void setSpecial(String special) { + this.special = special; + } + + public void setStart(double start) { + this.start = start; + } + + public double getEnd() { + return end; + } + + public void setEnd(double end) { + this.end = end; + } + + public int getAttempts() { + return attempts; + } + + public void setAttempts(int attempts) { + this.attempts = attempts; + } + + public NMethod getNMethod() { + return nmethod; + } + + public void setNMethod(NMethod NMethod) { + this.nmethod = NMethod; + } + + public ArrayList getPhases() { + return phases; + } + + public void setPhases(ArrayList phases) { + this.setPhases(phases); + } + + public String getFailureReason() { + return failureReason; + } + + public void setFailureReason(String failureReason) { + this.failureReason = failureReason; + } + + public Method getMethod() { + return method; + } + + public void setMethod(Method method) { + this.method = method; + } + + public CallSite getCall() { + return call; + } + + public void setCall(CallSite call) { + this.call = call; + } + + public double getElapsedTime() { + return end - start; + } + + public Compilation getCompilation() { + return this; + } +} diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/Constants.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/Constants.java Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,46 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package com.sun.hotspot.tools.compiler; + +interface Constants { + static final int JVM_ACC_PUBLIC = 0x0001; /* visible to everyone */ + static final int JVM_ACC_PRIVATE = 0x0002; /* visible only to the defining class */ + static final int JVM_ACC_PROTECTED = 0x0004; /* visible to subclasses */ + static final int JVM_ACC_STATIC = 0x0008; /* instance variable is static */ + static final int JVM_ACC_FINAL = 0x0010; /* no further subclassing, overriding */ + static final int JVM_ACC_SYNCHRONIZED = 0x0020; /* wrap method call in monitor lock */ + static final int JVM_ACC_SUPER = 0x0020; /* funky handling of invokespecial */ + static final int JVM_ACC_VOLATILE = 0x0040; /* can not cache in registers */ + static final int JVM_ACC_BRIDGE = 0x0040; /* bridge method generated by compiler */ + static final int JVM_ACC_TRANSIENT = 0x0080; /* not persistent */ + static final int JVM_ACC_VARARGS = 0x0080; /* method declared with variable number of args */ + static final int JVM_ACC_NATIVE = 0x0100; /* implemented in C */ + static final int JVM_ACC_INTERFACE = 0x0200; /* class is an interface */ + static final int JVM_ACC_ABSTRACT = 0x0400; /* no definition provided */ + static final int JVM_ACC_STRICT = 0x0800; /* strict floating point */ + static final int JVM_ACC_SYNTHETIC = 0x1000; /* compiler-generated class, method or field */ + static final int JVM_ACC_ANNOTATION = 0x2000; /* annotation type */ + static final int JVM_ACC_ENUM = 0x4000; /* field is declared as element of enum */ +} diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/LogCleanupReader.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/LogCleanupReader.java Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,212 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package com.sun.hotspot.tools.compiler; + +import java.io.*; +import java.util.regex.*; + +/** + * This class is a filter class to deal with malformed XML that used + * to be produced by the JVM when generating LogCompilation. In 1.6 + * and later releases it shouldn't be required. + * @author never + */ + +class LogCleanupReader extends Reader { + private Reader reader; + + private char[] buffer = new char[4096]; + + private int bufferCount; + + private int bufferOffset; + + private char[] line = new char[1024]; + + private int index; + + private int length; + + private char[] one = new char[1]; + + LogCleanupReader(Reader r) { + reader = r; + } + + static final private Matcher pattern = Pattern.compile(".+ compile_id='[0-9]+'.*( compile_id='[0-9]+)").matcher(""); + static final private Matcher pattern2 = Pattern.compile("' (C[12]) compile_id=").matcher(""); + static final private Matcher pattern3 = Pattern.compile("'(destroy_vm)/").matcher(""); + + private void fill() throws IOException { + rawFill(); + if (length != -1) { + boolean changed = false; + String s = new String(line, 0, length); + String orig = s; + + pattern2.reset(s); + if (pattern2.find()) { + s = s.substring(0, pattern2.start(1)) + s.substring(pattern2.end(1) + 1); + changed = true; + } + + pattern.reset(s); + if (pattern.lookingAt()) { + s = s.substring(0, pattern.start(1)) + s.substring(pattern.end(1) + 1); + changed = true; + } + + pattern3.reset(s); + if (pattern3.find()) { + s = s.substring(0, pattern3.start(1)) + s.substring(pattern3.end(1)); + changed = true; + } + + if (changed) { + s.getChars(0, s.length(), line, 0); + length = s.length(); + } + } + } + + private void rawFill() throws IOException { + if (bufferCount == -1) { + length = -1; + return; + } + + int i = 0; + boolean fillNonEOL = true; + outer: + while (true) { + if (fillNonEOL) { + int p; + for (p = bufferOffset; p < bufferCount; p++) { + char c = buffer[p]; + if (c == '\r' || c == '\n') { + bufferOffset = p; + fillNonEOL = false; + continue outer; + } + if (i >= line.length) { + // copy and enlarge the line array + char[] newLine = new char[line.length * 2]; + System.arraycopy(line, 0, newLine, 0, line.length); + line = newLine; + } + line[i++] = c; + } + bufferOffset = p; + } else { + int p; + for (p = bufferOffset; p < bufferCount; p++) { + char c = buffer[p]; + if (c != '\r' && c != '\n') { + bufferOffset = p; + length = i; + index = 0; + return; + } + line[i++] = c; + } + bufferOffset = p; + } + if (bufferCount == -1) { + if (i == 0) { + length = -1; + } else { + length = i; + } + index = 0; + return; + } + if (bufferOffset != bufferCount) { + System.out.println(bufferOffset); + System.out.println(bufferCount); + throw new InternalError("how did we get here"); + } + // load more data and try again. + bufferCount = reader.read(buffer, 0, buffer.length); + bufferOffset = 0; + } + } + + public int read() throws java.io.IOException { + read(one, 0, 1); + return one[0]; + } + + public int read(char[] buffer) throws java.io.IOException { + return read(buffer, 0, buffer.length); + } + + public int read(char[] b, int off, int len) throws java.io.IOException { + if (length == -1) { + return -1; + } + + if (index == length) { + fill(); + if (length == -1) { + return -1; + } + } + int n = Math.min(length - index, Math.min(b.length - off, len)); + // System.out.printf("%d %d %d %d %d\n", index, length, off, len, n); + System.arraycopy(line, index, b, off, n); + index += n; + return n; + } + + public long skip(long n) throws java.io.IOException { + long result = n; + while (n-- > 0) read(); + return result; + } + + public boolean ready() throws java.io.IOException { + return reader.ready() || (line != null && length > 0); + } + + public boolean markSupported() { + return false; + } + + public void mark(int unused) throws java.io.IOException { + throw new UnsupportedOperationException("mark not supported"); + } + + public void reset() throws java.io.IOException { + reader.reset(); + line = null; + index = 0; + } + + public void close() throws java.io.IOException { + reader.close(); + line = null; + index = 0; + } +} diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/LogCompilation.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/LogCompilation.java Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,177 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +/** + * The main command line driver of a parser for LogCompilation output. + * @author never + */ + +package com.sun.hotspot.tools.compiler; + +import java.io.PrintStream; +import java.util.*; +import org.xml.sax.*; +import org.xml.sax.helpers.*; + +public class LogCompilation extends DefaultHandler implements ErrorHandler, Constants { + + public static void usage(int exitcode) { + System.out.println("Usage: LogCompilation [ -v ] [ -c ] [ -s ] [ -e | -N ] file1 ..."); + System.out.println(" -c: clean up malformed 1.5 xml"); + System.out.println(" -i: print inlining decisions"); + System.out.println(" -S: print compilation statistics"); + System.out.println(" -s: sort events by start time"); + System.out.println(" -e: sort events by elapsed time"); + System.out.println(" -N: sort events by name and start"); + System.exit(exitcode); + } + + public static void main(String[] args) throws Exception { + Comparator defaultSort = LogParser.sortByStart; + boolean statistics = false; + boolean printInlining = false; + boolean cleanup = false; + int index = 0; + + while (args.length > index) { + if (args[index].equals("-e")) { + defaultSort = LogParser.sortByElapsed; + index++; + } else if (args[index].equals("-n")) { + defaultSort = LogParser.sortByNameAndStart; + index++; + } else if (args[index].equals("-s")) { + defaultSort = LogParser.sortByStart; + index++; + } else if (args[index].equals("-c")) { + cleanup = true; + index++; + } else if (args[index].equals("-S")) { + statistics = true; + index++; + } else if (args[index].equals("-h")) { + usage(0); + } else if (args[index].equals("-i")) { + printInlining = true; + index++; + } else { + break; + } + } + + if (index >= args.length) { + usage(1); + } + + while (index < args.length) { + ArrayList events = LogParser.parse(args[index], cleanup); + + if (statistics) { + printStatistics(events, System.out); + } else { + Collections.sort(events, defaultSort); + for (LogEvent c : events) { + if (printInlining && c instanceof Compilation) { + Compilation comp = (Compilation)c; + comp.print(System.out, true); + } else { + c.print(System.out); + } + } + } + index++; + } + } + + public static void printStatistics(ArrayList events, PrintStream out) { + long cacheSize = 0; + long maxCacheSize = 0; + int nmethodsCreated = 0; + int nmethodsLive = 0; + int[] attempts = new int[32]; + double regallocTime = 0; + int maxattempts = 0; + + LinkedHashMap phaseTime = new LinkedHashMap(7); + LinkedHashMap phaseNodes = new LinkedHashMap(7); + double elapsed = 0; + + for (LogEvent e : events) { + if (e instanceof Compilation) { + Compilation c = (Compilation) e; + c.printShort(out); + out.printf(" %6.4f\n", c.getElapsedTime()); + attempts[c.getAttempts()]++; + maxattempts = Math.max(maxattempts,c.getAttempts()); + elapsed += c.getElapsedTime(); + for (Phase phase : c.getPhases()) { + out.printf("\t%s %6.4f\n", phase.getName(), phase.getElapsedTime()); + Double v = phaseTime.get(phase.getName()); + if (v == null) { + v = Double.valueOf(0.0); + } + phaseTime.put(phase.getName(), Double.valueOf(v.doubleValue() + phase.getElapsedTime())); + + Integer v2 = phaseNodes.get(phase.getName()); + if (v2 == null) { + v2 = Integer.valueOf(0); + } + phaseNodes.put(phase.getName(), Integer.valueOf(v2.intValue() + phase.getNodes())); + } + } else if (e instanceof MakeNotEntrantEvent) { + MakeNotEntrantEvent mne = (MakeNotEntrantEvent) e; + NMethod nm = mne.getNMethod(); + if (mne.isZombie()) { + if (nm == null) { + System.err.println(mne.getId()); + } + cacheSize -= nm.getSize(); + nmethodsLive--; + } + } else if (e instanceof NMethod) { + nmethodsLive++; + nmethodsCreated++; + NMethod nm = (NMethod) e; + cacheSize += nm.getSize(); + maxCacheSize = Math.max(cacheSize, maxCacheSize); + } + } + out.printf("NMethods: %d created %d live %d bytes (%d peak) in the code cache\n", + nmethodsCreated, nmethodsLive, cacheSize, maxCacheSize); + out.println("Phase times:"); + for (String name : phaseTime.keySet()) { + Double v = phaseTime.get(name); + Integer v2 = phaseNodes.get(name); + out.printf("%20s %6.4f %d\n", name, v.doubleValue(), v2.intValue()); + } + out.printf("%20s %6.4f\n", "total", elapsed); + + if (maxattempts > 0) { + out.println("Distribution of regalloc passes:"); + for (int i = 0; i <= maxattempts; i++) { + out.printf("%2d %8d\n", i, attempts[i]); + } + } + } +} diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/LogEvent.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/LogEvent.java Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,38 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package com.sun.hotspot.tools.compiler; + +import java.io.PrintStream; +import java.util.*; + +public interface LogEvent { + public double getStart(); + + public double getElapsedTime(); + + public Compilation getCompilation(); + + public void print(PrintStream stream); +} diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/LogParser.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/LogParser.java Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,430 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +/** + * A SAX based parser of LogCompilation output from HotSpot. It takes a complete + * @author never + */ + +package com.sun.hotspot.tools.compiler; + +import java.io.FileReader; +import java.io.Reader; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.Stack; +import javax.xml.parsers.SAXParser; +import javax.xml.parsers.SAXParserFactory; +import org.xml.sax.Attributes; +import org.xml.sax.ErrorHandler; +import org.xml.sax.InputSource; +import org.xml.sax.helpers.DefaultHandler; + +public class LogParser extends DefaultHandler implements ErrorHandler, Constants { + + static final HashMap typeMap; + static { + typeMap = new HashMap(); + typeMap.put("[I", "int[]"); + typeMap.put("[C", "char[]"); + typeMap.put("[Z", "boolean[]"); + typeMap.put("[L", "Object[]"); + typeMap.put("[B", "byte[]"); + } + + static Comparator sortByStart = new Comparator() { + + public int compare(LogEvent a, LogEvent b) { + double difference = (a.getStart() - b.getStart()); + if (difference < 0) { + return -1; + } + if (difference > 0) { + return 1; + } + return 0; + } + + @Override + public boolean equals(Object other) { + return false; + } + + @Override + public int hashCode() { + return 7; + } + }; + static Comparator sortByNameAndStart = new Comparator() { + + public int compare(LogEvent a, LogEvent b) { + Compilation c1 = a.getCompilation(); + Compilation c2 = b.getCompilation(); + if (c1 != null && c2 != null) { + int result = c1.getMethod().toString().compareTo(c2.getMethod().toString()); + if (result != 0) { + return result; + } + } + double difference = (a.getStart() - b.getStart()); + if (difference < 0) { + return -1; + } + if (difference > 0) { + return 1; + } + return 0; + } + + public boolean equals(Object other) { + return false; + } + + @Override + public int hashCode() { + return 7; + } + }; + static Comparator sortByElapsed = new Comparator() { + + public int compare(LogEvent a, LogEvent b) { + double difference = (a.getElapsedTime() - b.getElapsedTime()); + if (difference < 0) { + return -1; + } + if (difference > 0) { + return 1; + } + return 0; + } + + @Override + public boolean equals(Object other) { + return false; + } + + @Override + public int hashCode() { + return 7; + } + }; + + private ArrayList events = new ArrayList(); + + private HashMap types = new HashMap(); + private HashMap methods = new HashMap(); + private LinkedHashMap nmethods = new LinkedHashMap(); + private HashMap compiles = new HashMap(); + private String failureReason; + private int bci; + private Stack scopes = new Stack(); + private Compilation compile; + private CallSite site; + private Stack phaseStack = new Stack(); + private UncommonTrapEvent currentTrap; + + long parseLong(String l) { + try { + return Long.decode(l).longValue(); + } catch (NumberFormatException nfe) { + int split = l.length() - 8; + String s1 = "0x" + l.substring(split); + String s2 = l.substring(0, split); + long v1 = Long.decode(s1).longValue() & 0xffffffffL; + long v2 = (Long.decode(s2).longValue() & 0xffffffffL) << 32; + if (!l.equals("0x" + Long.toHexString(v1 + v2))) { + System.out.println(l); + System.out.println(s1); + System.out.println(s2); + System.out.println(v1); + System.out.println(v2); + System.out.println(Long.toHexString(v1 + v2)); + throw new InternalError("bad conversion"); + } + return v1 + v2; + } + } + + public static ArrayList parse(String file, boolean cleanup) throws Exception { + return parse(new FileReader(file), cleanup); + } + + public static ArrayList parse(Reader reader, boolean cleanup) throws Exception { + // Create the XML input factory + SAXParserFactory factory = SAXParserFactory.newInstance(); + + // Create the XML LogEvent reader + SAXParser p = factory.newSAXParser(); + + if (cleanup) { + // some versions of the log have slightly malformed XML, so clean it + // up before passing it to SAX + reader = new LogCleanupReader(reader); + } + + LogParser log = new LogParser(); + p.parse(new InputSource(reader), log); + + // Associate compilations with their NMethods + for (NMethod nm : log.nmethods.values()) { + Compilation c = log.compiles.get(nm.getId()); + nm.setCompilation(c); + // Native wrappers for methods don't have a compilation + if (c != null) { + c.setNMethod(nm); + } + } + + // Initially we want the LogEvent log sorted by timestamp + Collections.sort(log.events, sortByStart); + + return log.events; + } + + String search(Attributes attr, String name) { + return search(attr, name, null); + } + + String search(Attributes attr, String name, String defaultValue) { + String result = attr.getValue(name); + if (result != null) { + return result; + } + if (defaultValue != null) { + return defaultValue; + } + for (int i = 0; i < attr.getLength(); i++) { + System.out.println(attr.getQName(i) + " " + attr.getValue(attr.getQName(i))); + } + throw new InternalError("can't find " + name); + } + int indent = 0; + String compile_id; + + String type(String id) { + String result = types.get(id); + if (result == null) { + throw new InternalError(id); + } + String remapped = typeMap.get(result); + if (remapped != null) { + return remapped; + } + return result; + } + + void type(String id, String name) { + assert type(id) == null; + types.put(id, name); + } + + Method method(String id) { + Method result = methods.get(id); + if (result == null) { + throw new InternalError(id); + } + return result; + } + + public String makeId(Attributes atts) { + String id = atts.getValue("compile_id"); + String kind = atts.getValue("kind"); + if (kind != null && kind.equals("osr")) { + id += "%"; + } + return id; + } + + @Override + public void startElement(String uri, + String localName, + String qname, + Attributes atts) { + if (qname.equals("phase")) { + Phase p = new Phase(search(atts, "name"), + Double.parseDouble(search(atts, "stamp")), + Integer.parseInt(search(atts, "nodes"))); + phaseStack.push(p); + } else if (qname.equals("phase_done")) { + Phase p = phaseStack.pop(); + p.setEndNodes(Integer.parseInt(search(atts, "nodes"))); + p.setEnd(Double.parseDouble(search(atts, "stamp"))); + compile.getPhases().add(p); + } else if (qname.equals("task")) { + compile = new Compilation(Integer.parseInt(search(atts, "compile_id", "-1"))); + compile.setStart(Double.parseDouble(search(atts, "stamp"))); + compile.setICount(search(atts, "count", "0")); + compile.setBCount(search(atts, "backedge_count", "0")); + + String method = atts.getValue("method"); + int space = method.indexOf(' '); + method = method.substring(0, space) + "::" + + method.substring(space + 1, method.indexOf(' ', space + 1) + 1); + String compiler = atts.getValue("compiler"); + if (compiler == null) { + compiler = ""; + } + String kind = atts.getValue("compile_kind"); + if (kind == null) { + kind = "normal"; + } + if (kind.equals("osr")) { + compile.setOsr(true); + compile.setOsr_bci(Integer.parseInt(search(atts, "osr_bci"))); + } else if (kind.equals("c2i")) { + compile.setSpecial("--- adapter " + method); + } else { + compile.setSpecial(compile.getId() + " " + method + " (0 bytes)"); + } + events.add(compile); + compiles.put(makeId(atts), compile); + } else if (qname.equals("type")) { + type(search(atts, "id"), search(atts, "name")); + } else if (qname.equals("bc")) { + bci = Integer.parseInt(search(atts, "bci")); + } else if (qname.equals("klass")) { + type(search(atts, "id"), search(atts, "name")); + } else if (qname.equals("method")) { + String id = search(atts, "id"); + Method m = new Method(); + m.setHolder(type(search(atts, "holder"))); + m.setName(search(atts, "name")); + m.setReturnType(type(search(atts, "return"))); + m.setArguments(search(atts, "arguments", "void")); + m.setBytes(search(atts, "bytes")); + m.setIICount(search(atts, "iicount")); + m.setFlags(search(atts, "flags")); + methods.put(id, m); + } else if (qname.equals("call")) { + site = new CallSite(bci, method(search(atts, "method"))); + site.setCount(Integer.parseInt(search(atts, "count"))); + String receiver = atts.getValue("receiver"); + if (receiver != null) { + site.setReceiver(type(receiver)); + site.setReceiver_count(Integer.parseInt(search(atts, "receiver_count"))); + } + scopes.peek().add(site); + } else if (qname.equals("regalloc")) { + compile.setAttempts(Integer.parseInt(search(atts, "attempts"))); + } else if (qname.equals("inline_fail")) { + scopes.peek().last().setReason(search(atts, "reason")); + } else if (qname.equals("failure")) { + failureReason = search(atts, "reason"); + } else if (qname.equals("task_done")) { + compile.setEnd(Double.parseDouble(search(atts, "stamp"))); + if (Integer.parseInt(search(atts, "success")) == 0) { + compile.setFailureReason(failureReason); + } + } else if (qname.equals("make_not_entrant")) { + String id = makeId(atts); + NMethod nm = nmethods.get(id); + if (nm == null) throw new InternalError(); + LogEvent e = new MakeNotEntrantEvent(Double.parseDouble(search(atts, "stamp")), id, + atts.getValue("zombie") != null, nm); + events.add(e); + } else if (qname.equals("uncommon_trap")) { + String id = atts.getValue("compile_id"); + if (id != null) { + id = makeId(atts); + currentTrap = new UncommonTrapEvent(Double.parseDouble(search(atts, "stamp")), + id, + atts.getValue("reason"), + atts.getValue("action"), + Integer.parseInt(search(atts, "count", "0"))); + events.add(currentTrap); + } else { + // uncommon trap inserted during parsing. + // ignore for now + } + } else if (qname.equals("jvms")) { + // + if (currentTrap != null) { + currentTrap.addJVMS(atts.getValue("method"), Integer.parseInt(atts.getValue("bci"))); + } else { + System.err.println("Missing uncommon_trap for jvms"); + } + } else if (qname.equals("nmethod")) { + String id = makeId(atts); + NMethod nm = new NMethod(Double.parseDouble(search(atts, "stamp")), + id, + parseLong(atts.getValue("address")), + parseLong(atts.getValue("size"))); + nmethods.put(id, nm); + events.add(nm); + } else if (qname.equals("parse")) { + Method m = method(search(atts, "method")); + if (scopes.size() == 0) { + compile.setMethod(m); + scopes.push(compile.getCall()); + } else { + if (site.getMethod() == m) { + scopes.push(site); + } else if (scopes.peek().getCalls().size() > 2 && m == scopes.peek().last(-2).getMethod()) { + scopes.push(scopes.peek().last(-2)); + } else { + System.out.println(site.getMethod()); + System.out.println(m); + throw new InternalError("call site and parse don't match"); + } + } + } + } + + @Override + public void endElement(String uri, + String localName, + String qname) { + if (qname.equals("parse")) { + indent -= 2; + scopes.pop(); + } else if (qname.equals("uncommon_trap")) { + currentTrap = null; + } else if (qname.equals("task")) { + types.clear(); + methods.clear(); + site = null; + } + } + + @Override + public void warning(org.xml.sax.SAXParseException e) { + System.err.println(e.getMessage() + " at line " + e.getLineNumber() + ", column " + e.getColumnNumber()); + e.printStackTrace(); + } + + @Override + public void error(org.xml.sax.SAXParseException e) { + System.err.println(e.getMessage() + " at line " + e.getLineNumber() + ", column " + e.getColumnNumber()); + e.printStackTrace(); + } + + @Override + public void fatalError(org.xml.sax.SAXParseException e) { + System.err.println(e.getMessage() + " at line " + e.getLineNumber() + ", column " + e.getColumnNumber()); + e.printStackTrace(); + } +} diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/MakeNotEntrantEvent.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/MakeNotEntrantEvent.java Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,55 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package com.sun.hotspot.tools.compiler; + +import java.io.PrintStream; + +class MakeNotEntrantEvent extends BasicLogEvent { + private final boolean zombie; + + private NMethod nmethod; + + MakeNotEntrantEvent(double s, String i, boolean z, NMethod nm) { + super(s, i); + zombie = z; + nmethod = nm; + } + + public NMethod getNMethod() { + return nmethod; + } + + public void print(PrintStream stream) { + if (isZombie()) { + stream.printf("%s make_zombie\n", getId()); + } else { + stream.printf("%s make_not_entrant\n", getId()); + } + } + + public boolean isZombie() { + return zombie; + } +} diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/Method.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/Method.java Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,120 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package com.sun.hotspot.tools.compiler; + +import java.util.Arrays; + +public class Method implements Constants { + + private String holder; + private String name; + private String returnType; + private String arguments; + private String bytes; + private String iicount; + private String flags; + + String decodeFlags(int osr_bci) { + int f = Integer.parseInt(getFlags()); + char[] c = new char[4]; + Arrays.fill(c, ' '); + if (osr_bci >= 0) { + c[0] = '%'; + } + if ((f & JVM_ACC_SYNCHRONIZED) != 0) { + c[1] = 's'; + } + return new String(c); + } + + String format(int osr_bci) { + if (osr_bci >= 0) { + return getHolder().replace('/', '.') + "::" + getName() + " @ " + osr_bci + " (" + getBytes() + " bytes)"; + } else { + return getHolder().replace('/', '.') + "::" + getName() + " (" + getBytes() + " bytes)"; + } + } + + @Override + public String toString() { + return getHolder().replace('/', '.') + "::" + getName() + " (" + getBytes() + " bytes)"; + } + + public String getHolder() { + return holder; + } + + public void setHolder(String holder) { + this.holder = holder; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getReturnType() { + return returnType; + } + + public void setReturnType(String returnType) { + this.returnType = returnType; + } + + public String getArguments() { + return arguments; + } + + public void setArguments(String arguments) { + this.arguments = arguments; + } + + public String getBytes() { + return bytes; + } + + public void setBytes(String bytes) { + this.bytes = bytes; + } + + public String getIICount() { + return iicount; + } + + public void setIICount(String iicount) { + this.iicount = iicount; + } + + public String getFlags() { + return flags; + } + + public void setFlags(String flags) { + this.flags = flags; + } +} diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/NMethod.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/NMethod.java Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,60 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package com.sun.hotspot.tools.compiler; + +import java.io.PrintStream; + +public class NMethod extends BasicLogEvent { + + private long address; + private long size; + + NMethod(double s, String i, long a, long sz) { + super(s, i); + address = a; + size = sz; + } + + public void print(PrintStream out) { + // XXX Currently we do nothing + // throw new InternalError(); + } + + public long getAddress() { + return address; + } + + public void setAddress(long address) { + this.address = address; + } + + public long getSize() { + return size; + } + + public void setSize(long size) { + this.size = size; + } +} diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/Phase.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/Phase.java Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,63 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package com.sun.hotspot.tools.compiler; + +import java.io.PrintStream; + +public class Phase extends BasicLogEvent { + + private final int startNodes; + private int endNodes; + + Phase(String n, double s, int nodes) { + super(s, n); + startNodes = nodes; + } + + int getNodes() { + return getStartNodes(); + } + + void setEndNodes(int n) { + endNodes = n; + } + + public String getName() { + return getId(); + } + + public int getStartNodes() { + return startNodes; + } + + public int getEndNodes() { + return endNodes; + } + + @Override + public void print(PrintStream stream) { + throw new UnsupportedOperationException("Not supported yet."); + } +} diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/UncommonTrapEvent.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/UncommonTrapEvent.java Thu Mar 05 22:07:29 2009 -0500 @@ -0,0 +1,84 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package com.sun.hotspot.tools.compiler; + +import java.io.PrintStream; + +class UncommonTrapEvent extends BasicLogEvent { + + private final String reason; + private final String action; + private int count; + private String jvms = ""; + + UncommonTrapEvent(double s, String i, String r, String a, int c) { + super(s, i); + reason = r; + action = a; + count = c; + } + + + public void addJVMS(String method, int bci) { + setJvms(getJvms() + " @" + bci + " " + method + "\n"); + } + + public void updateCount(UncommonTrapEvent trap) { + setCount(Math.max(getCount(), trap.getCount())); + } + + public void print(PrintStream stream) { + stream.printf("%s uncommon trap %s %s\n", getId(), getReason(), getAction()); + stream.print(getJvms()); + } + + public String getReason() { + return reason; + } + + public String getAction() { + return action; + } + + public int getCount() { + return count; + } + + public void setCount(int count) { + this.count = count; + } + + public String getJvms() { + return jvms; + } + + public void setJvms(String jvms) { + this.jvms = jvms; + } + + public void setCompilation(Compilation compilation) { + this.compilation = compilation; + } +} diff -r 5caef2219893 -r 3db67f76d308 src/share/tools/MakeDeps/Database.java --- a/src/share/tools/MakeDeps/Database.java Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/tools/MakeDeps/Database.java Thu Mar 05 22:07:29 2009 -0500 @@ -365,7 +365,7 @@ // HACK ALERT. The compilation of ad_ files is very slow. // We want to start compiling them as early as possible. The compilation - // order on unix is dependant on the order we emit files here. + // order on unix is dependent on the order we emit files here. // By sorting the output before emitting it, we expect // that ad_ will be compiled early. boolean shouldSortObjFiles = true; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/Doc/Syntax.doc --- a/src/share/vm/adlc/Doc/Syntax.doc Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/Doc/Syntax.doc Thu Mar 05 22:07:29 2009 -0500 @@ -88,7 +88,7 @@ // these are used for constraints, etc. alloc_class class1(AX, BX); // form an allocation class of registers - // used by the register allocator for seperate + // used by the register allocator for separate // allocation of target register classes 3. Pipeline Syntax for Scheduling @@ -150,7 +150,7 @@ b. %} (block terminator) c. EOF (file terminator) - 4. Each statement must start on a seperate line + 4. Each statement must start on a separate line 5. Identifiers cannot contain: (){}%;,"/\ diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/adlc.hpp --- a/src/share/vm/adlc/adlc.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/adlc.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -79,6 +79,7 @@ // Macros // Debugging note: Put a breakpoint on "abort". +#undef assert #define assert(cond, msg) { if (!(cond)) { fprintf(stderr, "assert fails %s %d: %s\n", __FILE__, __LINE__, msg); abort(); }} #define max(a, b) (((a)>(b)) ? (a) : (b)) diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/adlparse.cpp --- a/src/share/vm/adlc/adlparse.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/adlparse.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1997-2009 Sun Microsystems, Inc. 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 @@ -298,7 +298,7 @@ rule->count_commutative_op(count); if (count > 0) { // Clone match rule and swap commutative operation's operands. - rule->swap_commutative_op(instr_ident, count, match_rules_cnt); + rule->matchrule_swap_commutative_op(instr_ident, count, match_rules_cnt); } } @@ -2586,7 +2586,7 @@ while( _curchar != ')' ) { // Get information on the left instruction and its operand // left-instructions's number - intptr_t left_inst = get_int(); + int left_inst = get_int(); // Left-instruction's operand skipws(); if( _curchar != '.' ) { @@ -2602,7 +2602,7 @@ skipws(); // Get information on the right instruction and its operand - intptr_t right_inst; // Right-instructions's number + int right_inst; // Right-instructions's number if( isdigit(_curchar) ) { right_inst = get_int(); // Right-instruction's operand @@ -3497,22 +3497,24 @@ // (1) // Check if there is a string to pass through to output - char *start = _ptr; // Record start of the next string - while ((_curchar != '$') && ((_curchar != '%') || (*(_ptr+1) != '}')) ) { - // If at the start of a comment, skip past it - if( (_curchar == '/') && ((*(_ptr+1) == '/') || (*(_ptr+1) == '*')) ) { - skipws_no_preproc(); - } else { - // ELSE advance to the next character, or start of the next line - next_char_or_line(); + { + char *start = _ptr; // Record start of the next string + while ((_curchar != '$') && ((_curchar != '%') || (*(_ptr+1) != '}')) ) { + // If at the start of a comment, skip past it + if( (_curchar == '/') && ((*(_ptr+1) == '/') || (*(_ptr+1) == '*')) ) { + skipws_no_preproc(); + } else { + // ELSE advance to the next character, or start of the next line + next_char_or_line(); + } } - } - // If a string was found, terminate it and record in EncClass - if ( start != _ptr ) { - *_ptr = '\0'; // Terminate the string - // Add flag to _strings list indicating we should check _rep_vars - format->_strings.addName(NameList::_signal2); - format->_strings.addName(start); + // If a string was found, terminate it and record in EncClass + if ( start != _ptr ) { + *_ptr = '\0'; // Terminate the string + // Add flag to _strings list indicating we should check _rep_vars + format->_strings.addName(NameList::_signal2); + format->_strings.addName(start); + } } // (2) @@ -3563,10 +3565,10 @@ // copy it and record in FormatRule if ( _curchar == '$' ) { next_char(); // Move past the '$' - char* rep_var = get_ident(); // Nil terminate the variable name - rep_var = strdup(rep_var);// Copy the string + char* next_rep_var = get_ident(); // Nil terminate the variable name + next_rep_var = strdup(next_rep_var);// Copy the string *_ptr = _curchar; // and replace Nil with original character - format->_rep_vars.addName(rep_var); + format->_rep_vars.addName(next_rep_var); // Add flag to _strings list indicating we should check _rep_vars format->_strings.addName(NameList::_signal); } @@ -3714,13 +3716,13 @@ parse_err(SYNERR, "identifier expected at %c\n", _curchar); continue; } // Check that you have a valid operand - const Form *form = instr->_localNames[ident2]; - if (!form) { + const Form *form2 = instr->_localNames[ident2]; + if (!form2) { parse_err(SYNERR, "operand name expected at %s\n", ident2); continue; } - oper = form->is_operand(); - if (oper == NULL && !form->is_opclass()) { + oper = form2->is_operand(); + if (oper == NULL && !form2->is_opclass()) { parse_err(SYNERR, "operand name expected at %s\n", ident2); continue; } // Add operand to list @@ -4271,7 +4273,7 @@ int result; // Storage for integer result if( _curline == NULL ) // Return NULL at EOF. - return NULL; + return 0; skipws(); // Skip whitespace before identifier start = end = _ptr; // Start points at first character @@ -4553,7 +4555,7 @@ //---------------------------ensure_start_of_line------------------------------ // A preprocessor directive has been encountered. Be sure it has fallen at -// the begining of a line, or else report an error. +// the beginning of a line, or else report an error. void ADLParser::ensure_start_of_line(void) { if (_curchar == '\n') { next_line(); return; } assert( _ptr >= _curline && _ptr < _curline+strlen(_curline), diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/archDesc.cpp --- a/src/share/vm/adlc/archDesc.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/archDesc.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ // -// Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved. +// Copyright 1997-2009 Sun Microsystems, Inc. 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 @@ -436,10 +436,12 @@ if ((oper->_matrule) && (oper->_matrule->_lChild == NULL) && (oper->_matrule->_rChild == NULL)) { - const Form *form = _globalNames[oper->_matrule->_opType]; - if ((form) && form->is_operand() && - (form->ideal_only() == false)) { - add_chain_rule_entry(oper->_matrule->_opType, oper->cost(), oper->_ident); + { + const Form *form = _globalNames[oper->_matrule->_opType]; + if ((form) && form->is_operand() && + (form->ideal_only() == false)) { + add_chain_rule_entry(oper->_matrule->_opType, oper->cost(), oper->_ident); + } } // Check for additional chain rules if (oper->_matrule->_next) { @@ -1015,12 +1017,12 @@ int idealIndex = 0; for (idealIndex = 1; idealIndex < _last_machine_leaf; ++idealIndex) { const char *idealName = NodeClassNames[idealIndex]; - _idealIndex.Insert((void*)idealName, (void*)idealIndex); + _idealIndex.Insert((void*) idealName, (void*) (intptr_t) idealIndex); } for ( idealIndex = _last_machine_leaf+1; idealIndex < _last_opcode; ++idealIndex) { const char *idealName = NodeClassNames[idealIndex]; - _idealIndex.Insert((void*)idealName, (void*)idealIndex); + _idealIndex.Insert((void*) idealName, (void*) (intptr_t) idealIndex); } } diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/dfa.cpp --- a/src/share/vm/adlc/dfa.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/dfa.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 1997-2004 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1997-2009 Sun Microsystems, Inc. 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 @@ -870,7 +870,7 @@ } // Print out the dictionary contents as key-value pairs -static void dumpekey(const void* key) { fprintf(stdout, "%s", key); } +static void dumpekey(const void* key) { fprintf(stdout, "%s", (char*) key); } static void dumpexpr(const void* expr) { fflush(stdout); ((Expr*)expr)->print(); } void ExprDict::dump() { @@ -1020,7 +1020,7 @@ } // Print out the dictionary contents as key-value pairs -static void print_key (const void* key) { fprintf(stdout, "%s", key); } +static void print_key (const void* key) { fprintf(stdout, "%s", (char*) key); } static void print_production(const void* production) { fflush(stdout); ((Production*)production)->print(); } void ProductionState::print() { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/dict2.cpp --- a/src/share/vm/adlc/dict2.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/dict2.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -275,7 +275,7 @@ // Convert string to hash key. This algorithm implements a universal hash // function with the multipliers frozen (ok, so it's not universal). The // multipliers (and allowable characters) are all odd, so the resultant sum -// is odd - guarenteed not divisible by any power of two, so the hash tables +// is odd - guaranteed not divisible by any power of two, so the hash tables // can be any power of two with good results. Also, I choose multipliers // that have only 2 bits set (the low is always set to be odd) so // multiplication requires only shifts and adds. Characters are required to @@ -296,7 +296,7 @@ } //------------------------------hashptr-------------------------------------- -// Slimey cheap hash function; no guarenteed performance. Better than the +// Slimey cheap hash function; no guaranteed performance. Better than the // default for pointers, especially on MS-DOS machines. int hashptr(const void *key) { #ifdef __TURBOC__ @@ -306,7 +306,7 @@ #endif } -// Slimey cheap hash function; no guarenteed performance. +// Slimey cheap hash function; no guaranteed performance. int hashkey(const void *key) { return (int)((intptr_t)key); } diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/dict2.hpp --- a/src/share/vm/adlc/dict2.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/dict2.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -89,10 +89,10 @@ // Hashing functions int hashstr(const void *s); // Nice string hash -// Slimey cheap hash function; no guarenteed performance. Better than the +// Slimey cheap hash function; no guaranteed performance. Better than the // default for pointers, especially on MS-DOS machines. int hashptr(const void *key); -// Slimey cheap hash function; no guarenteed performance. +// Slimey cheap hash function; no guaranteed performance. int hashkey(const void *key); // Key comparators diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/filebuff.cpp --- a/src/share/vm/adlc/filebuff.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/filebuff.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1997-2009 Sun Microsystems, Inc. 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 @@ -25,6 +25,8 @@ // FILEBUFF.CPP - Routines for handling a parser file buffer #include "adlc.hpp" +using namespace std; + //------------------------------FileBuff--------------------------------------- // Create a new parsing buffer FileBuff::FileBuff( BufferedFile *fptr, ArchDesc& archDesc) : _fp(fptr), _AD(archDesc) { @@ -48,10 +50,10 @@ file_error(SEMERR, 0, "Buffer allocation failed\n"); exit(1); // Exit on allocation failure } - *_bigbuf = '\n'; // Lead with a sentinal newline - _buf = _bigbuf+1; // Skip sentinal + *_bigbuf = '\n'; // Lead with a sentinel newline + _buf = _bigbuf+1; // Skip sentinel _bufmax = _buf; // Buffer is empty - _bufeol = _bigbuf; // _bufeol points at sentinal + _bufeol = _bigbuf; // _bufeol points at sentinel _filepos = -1; // filepos is in sync with _bufeol _bufoff = _offset = 0L; // Offset at file start @@ -60,8 +62,8 @@ file_error(SEMERR, 0, "File read error, no input read\n"); exit(1); // Exit on read error } - *_bufmax = '\n'; // End with a sentinal new-line - *(_bufmax+1) = '\0'; // Then end with a sentinal NULL + *_bufmax = '\n'; // End with a sentinel new-line + *(_bufmax+1) = '\0'; // Then end with a sentinel NULL } //------------------------------~FileBuff-------------------------------------- @@ -79,7 +81,7 @@ _linenum++; retval = ++_bufeol; // return character following end of previous line - if (*retval == '\0') return NULL; // Check for EOF sentinal + if (*retval == '\0') return NULL; // Check for EOF sentinel // Search for newline character which must end each line for(_filepos++; *_bufeol != '\n'; _bufeol++) _filepos++; // keep filepos in sync with _bufeol @@ -217,7 +219,7 @@ off = expandtab(os,off,*s++,'-','-'); if( i == len ) os << '^'; // Mark end of region os << '\n'; // End of marked line - return 0L; // All done + return 0; // All done } //------------------------------print------------------------------------------ diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/filebuff.hpp --- a/src/share/vm/adlc/filebuff.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/filebuff.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1997-2009 Sun Microsystems, Inc. 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 @@ -26,6 +26,7 @@ #include using namespace std; + // STRUCTURE FOR HANDLING INPUT AND OUTPUT FILES typedef struct { const char *_name; @@ -36,7 +37,7 @@ //------------------------------FileBuff-------------------------------------- // This class defines a nicely behaved buffer of text. Entire file of text -// is read into buffer at creation, with sentinals at start and end. +// is read into buffer at creation, with sentinels at start and end. class FileBuff { friend class FileBuffRegion; private: @@ -45,8 +46,8 @@ long _bufoff; // Start of buffer file offset char *_buf; // The buffer itself. - char *_bigbuf; // The buffer plus sentinals; actual heap area - char *_bufmax; // A pointer to the buffer end sentinal + char *_bigbuf; // The buffer plus sentinels; actual heap area + char *_bufmax; // A pointer to the buffer end sentinel char *_bufeol; // A pointer to the last complete line end int _err; // Error flag for file seek/read operations @@ -72,7 +73,7 @@ // This converts a pointer into the buffer to a file offset. It only works // when the pointer is valid (i.e. just obtained from getline()). - int getoff(const char *s) { return _bufoff+(int)(s-_buf); } + long getoff(const char* s) { return _bufoff + (s - _buf); } }; //------------------------------FileBuffRegion--------------------------------- @@ -95,8 +96,6 @@ FileBuffRegion *copy(); // Deep copy FileBuffRegion *merge(FileBuffRegion*); // Merge 2 regions; delete input -// void print(std::ostream&); -// friend std::ostream& operator<< (std::ostream&, FileBuffRegion&); void print(ostream&); friend ostream& operator<< (ostream&, FileBuffRegion&); }; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/forms.cpp --- a/src/share/vm/adlc/forms.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/forms.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1997-2009 Sun Microsystems, Inc. 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 @@ -370,7 +370,7 @@ } // Print out the dictionary contents as key-value pairs -static void dumpkey (const void* key) { fprintf(stdout, "%s", key); } +static void dumpkey (const void* key) { fprintf(stdout, "%s", (char*) key); } static void dumpform(const void* form) { fflush(stdout); ((Form*)form)->dump(); } void FormDict::dump() { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/forms.hpp --- a/src/share/vm/adlc/forms.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/forms.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1997-2009 Sun Microsystems, Inc. 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 @@ -124,7 +124,7 @@ public: // Public Data Form *_next; // Next pointer for form lists - long _linenum; // Line number for debugging + int _linenum; // Line number for debugging // Dynamic type check for common forms. virtual OpClassForm *is_opclass() const; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/formsopt.cpp --- a/src/share/vm/adlc/formsopt.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/formsopt.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 1998-2006 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1998-2009 Sun Microsystems, Inc. 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 @@ -273,13 +273,13 @@ for(_regDefs.reset(); (name = _regDefs.iter()) != NULL;) { int rnum = ((RegDef*)_regDef[name])->register_num(); if( (rnum >> 5) == wordnum ) - word |= (1L<<(rnum&31)); + word |= (1 << (rnum & 31)); } if( stack_also ) { // Now also collect stack bits for( int i = 0; i < 32; i++ ) if( wordnum*32+i >= RegisterForm::_reg_ctr ) - word |= (1L< _max_position ) _max_position = position; - _parent.addName((char *)parent); - _position.addName((char *)position); + _parent.addName((char*) (intptr_t) parent); + _position.addName((char*) (intptr_t) position); _instrs.addName(name); - _input.addName((char *)input); + _input.addName((char*) (intptr_t) input); } // Access info about instructions in the peep-match rule @@ -603,7 +603,7 @@ return _max_position; } -const char *PeepMatch::instruction_name(intptr_t position) { +const char *PeepMatch::instruction_name(int position) { return _instrs.name(position); } @@ -615,11 +615,11 @@ _input.reset(); } -void PeepMatch::next_instruction( intptr_t &parent, intptr_t &position, const char * &name, intptr_t &input ){ - parent = (intptr_t)_parent.iter(); - position = (intptr_t)_position.iter(); +void PeepMatch::next_instruction(int &parent, int &position, const char* &name, int &input) { + parent = (int) (intptr_t) _parent.iter(); + position = (int) (intptr_t) _position.iter(); name = _instrs.iter(); - input = (intptr_t)_input.iter(); + input = (int) (intptr_t) _input.iter(); } // 'true' if current position in iteration is a placeholder, not matched. @@ -637,15 +637,15 @@ } //------------------------------PeepConstraint--------------------------------- -PeepConstraint::PeepConstraint(intptr_t left_inst, char *left_op, char *relation, - intptr_t right_inst, char *right_op) +PeepConstraint::PeepConstraint(int left_inst, char* left_op, char* relation, + int right_inst, char* right_op) : _left_inst(left_inst), _left_op(left_op), _relation(relation), _right_inst(right_inst), _right_op(right_op), _next(NULL) {} PeepConstraint::~PeepConstraint() { } // Check if constraints use instruction at position -bool PeepConstraint::constrains_instruction(intptr_t position) { +bool PeepConstraint::constrains_instruction(int position) { // Check local instruction constraints if( _left_inst == position ) return true; if( _right_inst == position ) return true; @@ -692,7 +692,7 @@ } void PeepReplace::add_operand( int inst_num, char *inst_operand ) { _instruction.add_signal(); - _operand_inst_num.addName((char*)inst_num); + _operand_inst_num.addName((char*) (intptr_t) inst_num); _operand_op_name.addName(inst_operand); } @@ -702,15 +702,15 @@ _operand_inst_num.reset(); _operand_op_name.reset(); } -void PeepReplace::next_instruction(const char * &inst){ +void PeepReplace::next_instruction(const char* &inst){ inst = _instruction.iter(); - intptr_t inst_num = (intptr_t)_operand_inst_num.iter(); - const char *inst_operand = _operand_op_name.iter(); + int inst_num = (int) (intptr_t) _operand_inst_num.iter(); + const char* inst_operand = _operand_op_name.iter(); } -void PeepReplace::next_operand( intptr_t &inst_num, const char * &inst_operand ) { - const char *inst = _instruction.iter(); - inst_num = (intptr_t)_operand_inst_num.iter(); - inst_operand = _operand_op_name.iter(); +void PeepReplace::next_operand(int &inst_num, const char* &inst_operand) { + const char* inst = _instruction.iter(); + inst_num = (int) (intptr_t) _operand_inst_num.iter(); + inst_operand = _operand_op_name.iter(); } diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/formsopt.hpp --- a/src/share/vm/adlc/formsopt.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/formsopt.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 1998-2006 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1998-2009 Sun Microsystems, Inc. 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 @@ -457,10 +457,10 @@ // Access info about instructions in the peep-match rule int max_position(); - const char *instruction_name(intptr_t position); + const char *instruction_name(int position); // Iterate through all info on matched instructions void reset(); - void next_instruction( intptr_t &parent, intptr_t &position, const char * &name, intptr_t &input ); + void next_instruction(int &parent, int &position, const char* &name, int &input); // 'true' if current position in iteration is a placeholder, not matched. bool is_placeholder(); @@ -474,20 +474,20 @@ PeepConstraint *_next; // Additional constraints ANDed together public: - const intptr_t _left_inst; - const char *_left_op; - const char *_relation; - const intptr_t _right_inst; - const char *_right_op; + const int _left_inst; + const char* _left_op; + const char* _relation; + const int _right_inst; + const char* _right_op; public: // Public Methods - PeepConstraint(intptr_t left_inst, char *left_op, char *relation, - intptr_t right_inst, char *right_op); + PeepConstraint(int left_inst, char* left_op, char* relation, + int right_inst, char* right_op); ~PeepConstraint(); // Check if constraints use instruction at position - bool constrains_instruction(intptr_t position); + bool constrains_instruction(int position); // Add another constraint void append(PeepConstraint *next_peep_constraint); @@ -519,7 +519,7 @@ // Access contents of peepreplace void reset(); void next_instruction(const char * &root); - void next_operand( intptr_t &inst_num, const char * &inst_operand ); + void next_operand(int &inst_num, const char * &inst_operand ); // Utilities void dump(); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/formssel.cpp --- a/src/share/vm/adlc/formssel.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/formssel.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 1998-2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1998-2009 Sun Microsystems, Inc. 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 @@ -844,8 +844,12 @@ for (_parameters.reset(); (name = _parameters.iter()) != NULL;) { OperandForm *opForm = (OperandForm*)_localNames[name]; - const Form *form = _effects[name]; - Effect *e = form ? form->is_effect() : NULL; + Effect* e = NULL; + { + const Form* form = _effects[name]; + e = form ? form->is_effect() : NULL; + } + if (e != NULL) { has_temp |= e->is(Component::TEMP); @@ -858,19 +862,7 @@ OperandForm* kill = (OperandForm*)_localNames[kill_name]; globalAD->syntax_err(_linenum, "%s: %s %s must be at the end of the argument list\n", _ident, kill->_ident, kill_name); - } else if (e->isa(Component::KILL)) { - kill_name = name; - } - - // TEMPs are real uses and need to be among the first parameters - // listed, otherwise the numbering of operands and inputs gets - // screwy, so enforce this restriction during parse. - if (kill_name != NULL && - e->isa(Component::TEMP) && !e->isa(Component::DEF)) { - OperandForm* kill = (OperandForm*)_localNames[kill_name]; - globalAD->syntax_err(_linenum, "%s: %s %s must follow %s %s in the argument list\n", - _ident, kill->_ident, kill_name, opForm->_ident, name); - } else if (e->isa(Component::KILL)) { + } else if (e->isa(Component::KILL) && !e->isa(Component::USE)) { kill_name = name; } } @@ -1122,7 +1114,7 @@ const char *op_name = NULL; const char *reg_type = NULL; FormDict &globals = AD.globalNames(); - cisc_spill_operand = _matrule->cisc_spill_match(globals, AD.get_registers(), instr->_matrule, op_name, reg_type); + cisc_spill_operand = _matrule->matchrule_cisc_spill_match(globals, AD.get_registers(), instr->_matrule, op_name, reg_type); if( (cisc_spill_operand != Not_cisc_spillable) && (op_name != NULL) && equivalent_predicates(this, instr) ) { cisc_spill_operand = operand_position(op_name, Component::USE); int def_oper = operand_position(op_name, Component::DEF); @@ -1217,13 +1209,17 @@ // Seach through operands to determine parameters unique positions. void InstructForm::set_unique_opnds() { uint* uniq_idx = NULL; - uint nopnds = num_opnds(); + int nopnds = num_opnds(); uint num_uniq = nopnds; - uint i; + int i; + _uniq_idx_length = 0; if ( nopnds > 0 ) { - // Allocate index array with reserve. - uniq_idx = (uint*) malloc(sizeof(uint)*(nopnds + 2)); - for( i = 0; i < nopnds+2; i++ ) { + // Allocate index array. Worst case we're mapping from each + // component back to an index and any DEF always goes at 0 so the + // length of the array has to be the number of components + 1. + _uniq_idx_length = _components.count() + 1; + uniq_idx = (uint*) malloc(sizeof(uint)*(_uniq_idx_length)); + for( i = 0; i < _uniq_idx_length; i++ ) { uniq_idx[i] = i; } } @@ -1238,8 +1234,8 @@ _parameters.reset(); while( (name = _parameters.iter()) != NULL ) { count = 0; - uint position = 0; - uint uniq_position = 0; + int position = 0; + int uniq_position = 0; _components.reset(); Component *comp = NULL; if( sets_result() ) { @@ -1255,6 +1251,7 @@ } if( strcmp(name, comp->_name)==0 ) { if( ++count > 1 ) { + assert(position < _uniq_idx_length, "out of bounds"); uniq_idx[position] = uniq_position; has_dupl_use = true; } else { @@ -1284,7 +1281,7 @@ _num_uniq = num_uniq; } -// Generate index values needed for determing the operand position +// Generate index values needed for determining the operand position void InstructForm::index_temps(FILE *fp, FormDict &globals, const char *prefix, const char *receiver) { uint idx = 0; // position of operand in match rule int cur_num_opnds = num_opnds(); @@ -2200,8 +2197,8 @@ // Return zero-based position in component list, only counting constants; // Return -1 if not in list. int OperandForm::constant_position(FormDict &globals, const Component *last) { - // Iterate through components and count constants preceeding 'constant' - uint position = 0; + // Iterate through components and count constants preceding 'constant' + int position = 0; Component *comp; _components.reset(); while( (comp = _components.iter()) != NULL && (comp != last) ) { @@ -2238,7 +2235,7 @@ // Return zero-based position in component list, only counting constants; // Return -1 if not in list. int OperandForm::register_position(FormDict &globals, const char *reg_name) { - // Iterate through components and count registers preceeding 'last' + // Iterate through components and count registers preceding 'last' uint position = 0; Component *comp; _components.reset(); @@ -2304,7 +2301,7 @@ if ( op->is_base_constant(globals) == Form::idealP ) { // Find the constant's index: _c0, _c1, _c2, ... , _cN uint idx = op->constant_position( globals, rep_var); - fprintf(fp," virtual bool disp_is_oop() const {", _ident); + fprintf(fp," virtual bool disp_is_oop() const {"); fprintf(fp, " return _c%d->isa_oop_ptr();", idx); fprintf(fp, " }\n"); } @@ -3042,9 +3039,9 @@ // Recursive call collecting info on top-level operands, not transitive. // Implementation does not modify state of internal structures. -void MatchNode::append_components(FormDict &locals, ComponentList &components, - bool deflag) const { - int usedef = deflag ? Component::DEF : Component::USE; +void MatchNode::append_components(FormDict& locals, ComponentList& components, + bool def_flag) const { + int usedef = def_flag ? Component::DEF : Component::USE; FormDict &globals = _AD.globalNames(); assert (_name != NULL, "MatchNode::build_components encountered empty node\n"); @@ -3062,10 +3059,10 @@ return; } // Promote results of "Set" to DEF - bool def_flag = (!strcmp(_opType, "Set")) ? true : false; - if (_lChild) _lChild->append_components(locals, components, def_flag); - def_flag = false; // only applies to component immediately following 'Set' - if (_rChild) _rChild->append_components(locals, components, def_flag); + bool tmpdef_flag = (!strcmp(_opType, "Set")) ? true : false; + if (_lChild) _lChild->append_components(locals, components, tmpdef_flag); + tmpdef_flag = false; // only applies to component immediately following 'Set' + if (_rChild) _rChild->append_components(locals, components, tmpdef_flag); } // Find the n'th base-operand in the match node, @@ -3411,9 +3408,9 @@ return (form1 == form2); } -//-------------------------cisc_spill_match------------------------------------ +//-------------------------cisc_spill_match_node------------------------------- // Recursively check two MatchRules for legal conversion via cisc-spilling -int MatchNode::cisc_spill_match(FormDict &globals, RegisterForm *registers, MatchNode *mRule2, const char * &operand, const char * ®_type) { +int MatchNode::cisc_spill_match(FormDict& globals, RegisterForm* registers, MatchNode* mRule2, const char* &operand, const char* ®_type) { int cisc_spillable = Maybe_cisc_spillable; int left_spillable = Maybe_cisc_spillable; int right_spillable = Maybe_cisc_spillable; @@ -3487,13 +3484,13 @@ return cisc_spillable; } -//---------------------------cisc_spill_match---------------------------------- +//---------------------------cisc_spill_match_rule------------------------------ // Recursively check two MatchRules for legal conversion via cisc-spilling // This method handles the root of Match tree, // general recursive checks done in MatchNode -int MatchRule::cisc_spill_match(FormDict &globals, RegisterForm *registers, - MatchRule *mRule2, const char * &operand, - const char * ®_type) { +int MatchRule::matchrule_cisc_spill_match(FormDict& globals, RegisterForm* registers, + MatchRule* mRule2, const char* &operand, + const char* ®_type) { int cisc_spillable = Maybe_cisc_spillable; int left_spillable = Maybe_cisc_spillable; int right_spillable = Maybe_cisc_spillable; @@ -3531,7 +3528,7 @@ //----------------------------- equivalent ------------------------------------ // Recursively check to see if two match rules are equivalent. // This rule handles the root. -bool MatchRule::equivalent(FormDict &globals, MatchRule *mRule2) { +bool MatchRule::equivalent(FormDict &globals, MatchNode *mRule2) { // Check that each sets a result if (sets_result() != mRule2->sets_result()) { return false; @@ -3647,7 +3644,7 @@ //-------------------------- swap_commutative_op ------------------------------ // Recursively swap specified commutative operation with subtree operands. -void MatchRule::swap_commutative_op(const char* instr_ident, int count, int& match_rules_cnt) { +void MatchRule::matchrule_swap_commutative_op(const char* instr_ident, int count, int& match_rules_cnt) { assert(match_rules_cnt < 100," too many match rule clones"); // Clone MatchRule* clone = new MatchRule(_AD, this); @@ -3660,8 +3657,8 @@ clone->_next = this->_next; this-> _next = clone; if( (--count) > 0 ) { - this-> swap_commutative_op(instr_ident, count, match_rules_cnt); - clone->swap_commutative_op(instr_ident, count, match_rules_cnt); + this-> matchrule_swap_commutative_op(instr_ident, count, match_rules_cnt); + clone->matchrule_swap_commutative_op(instr_ident, count, match_rules_cnt); } } @@ -3693,7 +3690,7 @@ // Recursive call collecting info on top-level operands, not transitive. // Implementation does not modify state of internal structures. -void MatchRule::append_components(FormDict &locals, ComponentList &components) const { +void MatchRule::append_components(FormDict& locals, ComponentList& components, bool def_flag) const { assert (_name != NULL, "MatchNode::build_components encountered empty node\n"); MatchNode::append_components(locals, components, diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/formssel.hpp --- a/src/share/vm/adlc/formssel.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/formssel.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 1998-2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1998-2009 Sun Microsystems, Inc. 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 @@ -101,6 +101,7 @@ const char *_ins_pipe; // Instruction Scheduline description class uint *_uniq_idx; // Indexes of unique operands + int _uniq_idx_length; // Length of _uniq_idx array uint _num_uniq; // Number of unique operands ComponentList _components; // List of Components matches MachNode's // operand structure @@ -257,11 +258,13 @@ void set_unique_opnds(); uint num_unique_opnds() { return _num_uniq; } uint unique_opnds_idx(int idx) { - if( _uniq_idx != NULL && idx > 0 ) + if( _uniq_idx != NULL && idx > 0 ) { + assert(idx < _uniq_idx_length, "out of bounds"); return _uniq_idx[idx]; - else + } else { return idx; - } + } + } // Operands which are only KILLs aren't part of the input array and // require special handling in some cases. Their position in this @@ -274,7 +277,7 @@ // // Generate the format call for the replacement variable void rep_var_format(FILE *fp, const char *rep_var); - // Generate index values needed for determing the operand position + // Generate index values needed for determining the operand position void index_temps (FILE *fp, FormDict &globals, const char *prefix = "", const char *receiver = ""); // --------------------------- @@ -341,7 +344,7 @@ // --------------------------- Code Block // Add code - void add_code(const char *string_preceeding_replacement_var); + void add_code(const char *string_preceding_replacement_var); // Add a replacement variable or one of its subfields // Subfields are stored with a leading '$' void add_rep_var(char *replacement_var); @@ -917,8 +920,8 @@ // return 1 if found and position is incremented by operand offset in rule bool find_name(const char *str, int &position) const; bool find_type(const char *str, int &position) const; - void append_components(FormDict &locals, ComponentList &components, - bool def_flag) const; + virtual void append_components(FormDict& locals, ComponentList& components, + bool def_flag = false) const; bool base_operand(uint &position, FormDict &globals, const char * &result, const char * &name, const char * &opType) const; @@ -944,12 +947,12 @@ const char *reduce_left (FormDict &globals) const; // Recursive version of check in MatchRule - int cisc_spill_match(FormDict &globals, RegisterForm *registers, - MatchNode *mRule2, const char * &operand, - const char * ®_type); + int cisc_spill_match(FormDict& globals, RegisterForm* registers, + MatchNode* mRule2, const char* &operand, + const char* ®_type); int cisc_spill_merge(int left_result, int right_result); - bool equivalent(FormDict &globals, MatchNode *mNode2); + virtual bool equivalent(FormDict& globals, MatchNode* mNode2); void count_commutative_op(int& count); void swap_commutative_op(bool atroot, int count); @@ -976,7 +979,7 @@ MatchRule(ArchDesc &ad, MatchNode* mroot, int depth, char* construct, int numleaves); ~MatchRule(); - void append_components(FormDict &locals, ComponentList &components) const; + virtual void append_components(FormDict& locals, ComponentList& components, bool def_flag = false) const; // Recursive call on all operands' match rules in my match rule. bool base_operand(uint &position, FormDict &globals, const char * &result, const char * &name, @@ -1003,14 +1006,14 @@ Form::DataType is_ideal_store() const;// node matches ideal 'StoreXNode' // Check if 'mRule2' is a cisc-spill variant of this MatchRule - int cisc_spill_match(FormDict &globals, RegisterForm *registers, - MatchRule *mRule2, const char * &operand, - const char * ®_type); + int matchrule_cisc_spill_match(FormDict &globals, RegisterForm* registers, + MatchRule* mRule2, const char* &operand, + const char* ®_type); // Check if 'mRule2' is equivalent to this MatchRule - bool equivalent(FormDict &globals, MatchRule *mRule2); + virtual bool equivalent(FormDict& globals, MatchNode* mRule2); - void swap_commutative_op(const char* instr_ident, int count, int& match_rules_cnt); + void matchrule_swap_commutative_op(const char* instr_ident, int count, int& match_rules_cnt); void dump(); void output(FILE *fp); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/main.cpp --- a/src/share/vm/adlc/main.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/main.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1997-2009 Sun Microsystems, Inc. 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 @@ -349,7 +349,7 @@ } else { if (_ADL_file._name) printf("%s --> ", _ADL_file._name); - printf("%s, %s, %s, %s, %s, %s, %s, %s, %s", + printf("%s, %s, %s, %s, %s, %s, %s, %s, %s, %s", _CPP_file._name, _CPP_CLONE_file._name, _CPP_EXPAND_file._name, @@ -358,7 +358,8 @@ _CPP_MISC_file._name, _CPP_PEEPHOLE_file._name, _CPP_PIPELINE_file._name, - _HPP_file._name, _DFA_file._name); + _HPP_file._name, + _DFA_file._name); } printf("\n"); } @@ -431,7 +432,7 @@ legal_end = fbuf.get_line(); } *legal_text = legal_start; - return (legal_end - legal_start); + return (int) (legal_end - legal_start); } // VS2005 has its own definition, identical to this one. diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/output_c.cpp --- a/src/share/vm/adlc/output_c.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/output_c.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 1998-2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1998-2009 Sun Microsystems, Inc. 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 @@ -225,11 +225,11 @@ pipeclass->_parameters.reset(); while ( (paramname = pipeclass->_parameters.iter()) != NULL ) { - const PipeClassOperandForm *pipeopnd = + const PipeClassOperandForm *tmppipeopnd = (const PipeClassOperandForm *)pipeclass->_localUsage[paramname]; - if (pipeopnd) - templen += 10 + (int)strlen(pipeopnd->_stage); + if (tmppipeopnd) + templen += 10 + (int)strlen(tmppipeopnd->_stage); else templen += 19; @@ -253,10 +253,10 @@ pipeclass->_parameters.reset(); while ( (paramname = pipeclass->_parameters.iter()) != NULL ) { - const PipeClassOperandForm *pipeopnd = + const PipeClassOperandForm *tmppipeopnd = (const PipeClassOperandForm *)pipeclass->_localUsage[paramname]; templen += sprintf(&operand_stages[templen], " stage_%s%c\n", - pipeopnd ? pipeopnd->_stage : "undefined", + tmppipeopnd ? tmppipeopnd->_stage : "undefined", (++i < paramcount ? ',' : ' ') ); } @@ -1042,10 +1042,10 @@ // Scan the peepmatch and output a test for each instruction static void check_peepmatch_instruction_tree(FILE *fp, PeepMatch *pmatch, PeepConstraint *pconstraint) { - intptr_t parent = -1; - intptr_t inst_position = 0; - const char *inst_name = NULL; - intptr_t input = 0; + int parent = -1; + int inst_position = 0; + const char* inst_name = NULL; + int input = 0; fprintf(fp, " // Check instruction sub-tree\n"); pmatch->reset(); for( pmatch->next_instruction( parent, inst_position, inst_name, input ); @@ -1055,14 +1055,14 @@ if( ! pmatch->is_placeholder() ) { // Define temporaries 'inst#', based on parent and parent's input index if( parent != -1 ) { // root was initialized - fprintf(fp, " inst%ld = inst%ld->in(%ld);\n", + fprintf(fp, " inst%d = inst%d->in(%d);\n", inst_position, parent, input); } // When not the root // Test we have the correct instruction by comparing the rule if( parent != -1 ) { - fprintf(fp, " matches = matches && ( inst%ld->rule() == %s_rule );", + fprintf(fp, " matches = matches && ( inst%d->rule() == %s_rule );", inst_position, inst_name); } } else { @@ -1073,20 +1073,20 @@ } } -static void print_block_index(FILE *fp, intptr_t inst_position) { +static void print_block_index(FILE *fp, int inst_position) { assert( inst_position >= 0, "Instruction number less than zero"); fprintf(fp, "block_index"); if( inst_position != 0 ) { - fprintf(fp, " - %ld", inst_position); + fprintf(fp, " - %d", inst_position); } } // Scan the peepmatch and output a test for each instruction static void check_peepmatch_instruction_sequence(FILE *fp, PeepMatch *pmatch, PeepConstraint *pconstraint) { - intptr_t parent = -1; - intptr_t inst_position = 0; - const char *inst_name = NULL; - intptr_t input = 0; + int parent = -1; + int inst_position = 0; + const char* inst_name = NULL; + int input = 0; fprintf(fp, " // Check instruction sub-tree\n"); pmatch->reset(); for( pmatch->next_instruction( parent, inst_position, inst_name, input ); @@ -1101,14 +1101,14 @@ print_block_index(fp, inst_position); fprintf(fp, " > 0 ) {\n Node *n = block->_nodes.at("); print_block_index(fp, inst_position); - fprintf(fp, ");\n inst%ld = (n->is_Mach()) ? ", inst_position); + fprintf(fp, ");\n inst%d = (n->is_Mach()) ? ", inst_position); fprintf(fp, "n->as_Mach() : NULL;\n }\n"); } // When not the root // Test we have the correct instruction by comparing the rule. if( parent != -1 ) { - fprintf(fp, " matches = matches && (inst%ld != NULL) && (inst%ld->rule() == %s_rule);\n", + fprintf(fp, " matches = matches && (inst%d != NULL) && (inst%d->rule() == %s_rule);\n", inst_position, inst_position, inst_name); } } else { @@ -1121,10 +1121,10 @@ // Build mapping for register indices, num_edges to input static void build_instruction_index_mapping( FILE *fp, FormDict &globals, PeepMatch *pmatch ) { - intptr_t parent = -1; - intptr_t inst_position = 0; - const char *inst_name = NULL; - intptr_t input = 0; + int parent = -1; + int inst_position = 0; + const char* inst_name = NULL; + int input = 0; fprintf(fp, " // Build map to register info\n"); pmatch->reset(); for( pmatch->next_instruction( parent, inst_position, inst_name, input ); @@ -1136,9 +1136,9 @@ InstructForm *inst = globals[inst_name]->is_instruction(); if( inst != NULL ) { char inst_prefix[] = "instXXXX_"; - sprintf(inst_prefix, "inst%ld_", inst_position); + sprintf(inst_prefix, "inst%d_", inst_position); char receiver[] = "instXXXX->"; - sprintf(receiver, "inst%ld->", inst_position); + sprintf(receiver, "inst%d->", inst_position); inst->index_temps( fp, globals, inst_prefix, receiver ); } } @@ -1168,7 +1168,7 @@ } // LEFT - intptr_t left_index = pconstraint->_left_inst; + int left_index = pconstraint->_left_inst; const char *left_op = pconstraint->_left_op; // Access info on the instructions whose operands are compared InstructForm *inst_left = globals[pmatch->instruction_name(left_index)]->is_instruction(); @@ -1191,7 +1191,7 @@ // RIGHT int right_op_index = -1; - intptr_t right_index = pconstraint->_right_inst; + int right_index = pconstraint->_right_inst; const char *right_op = pconstraint->_right_op; if( right_index != -1 ) { // Match operand // Access info on the instructions whose operands are compared @@ -1351,7 +1351,7 @@ assert( root_form != NULL, "Replacement instruction was not previously defined"); fprintf(fp, " %sNode *root = new (C) %sNode();\n", root_inst, root_inst); - intptr_t inst_num; + int inst_num; const char *op_name; int opnds_index = 0; // define result operand // Then install the use-operands for the new sub-tree @@ -1362,7 +1362,6 @@ InstructForm *inst_form; inst_form = globals[pmatch->instruction_name(inst_num)]->is_instruction(); assert( inst_form, "Parser should guaranty this is an instruction"); - int op_base = inst_form->oper_input_base(globals); int inst_op_num = inst_form->operand_position(op_name, Component::USE); if( inst_op_num == NameList::Not_in_list ) inst_op_num = inst_form->operand_position(op_name, Component::USE_DEF); @@ -1379,32 +1378,32 @@ // Add unmatched edges from root of match tree int op_base = root_form->oper_input_base(globals); for( int unmatched_edge = 1; unmatched_edge < op_base; ++unmatched_edge ) { - fprintf(fp, " root->add_req(inst%ld->in(%d)); // unmatched ideal edge\n", + fprintf(fp, " root->add_req(inst%d->in(%d)); // unmatched ideal edge\n", inst_num, unmatched_edge); } // If new instruction captures bottom type if( root_form->captures_bottom_type() ) { // Get bottom type from instruction whose result we are replacing - fprintf(fp, " root->_bottom_type = inst%ld->bottom_type();\n", inst_num); + fprintf(fp, " root->_bottom_type = inst%d->bottom_type();\n", inst_num); } // Define result register and result operand - fprintf(fp, " ra_->add_reference(root, inst%ld);\n", inst_num); - fprintf(fp, " ra_->set_oop (root, ra_->is_oop(inst%ld));\n", inst_num); - fprintf(fp, " ra_->set_pair(root->_idx, ra_->get_reg_second(inst%ld), ra_->get_reg_first(inst%ld));\n", inst_num, inst_num); - fprintf(fp, " root->_opnds[0] = inst%ld->_opnds[0]->clone(C); // result\n", inst_num); + fprintf(fp, " ra_->add_reference(root, inst%d);\n", inst_num); + fprintf(fp, " ra_->set_oop (root, ra_->is_oop(inst%d));\n", inst_num); + fprintf(fp, " ra_->set_pair(root->_idx, ra_->get_reg_second(inst%d), ra_->get_reg_first(inst%d));\n", inst_num, inst_num); + fprintf(fp, " root->_opnds[0] = inst%d->_opnds[0]->clone(C); // result\n", inst_num); fprintf(fp, " // ----- Done with initial setup -----\n"); } else { if( (op_form == NULL) || (op_form->is_base_constant(globals) == Form::none) ) { // Do not have ideal edges for constants after matching - fprintf(fp, " for( unsigned x%d = inst%ld_idx%d; x%d < inst%ld_idx%d; x%d++ )\n", + fprintf(fp, " for( unsigned x%d = inst%d_idx%d; x%d < inst%d_idx%d; x%d++ )\n", inst_op_num, inst_num, inst_op_num, inst_op_num, inst_num, inst_op_num+1, inst_op_num ); - fprintf(fp, " root->add_req( inst%ld->in(x%d) );\n", + fprintf(fp, " root->add_req( inst%d->in(x%d) );\n", inst_num, inst_op_num ); } else { fprintf(fp, " // no ideal edge for constants after matching\n"); } - fprintf(fp, " root->_opnds[%d] = inst%ld->_opnds[%d]->clone(C);\n", + fprintf(fp, " root->_opnds[%d] = inst%d->_opnds[%d]->clone(C);\n", opnds_index, inst_num, inst_op_num ); } ++opnds_index; @@ -1443,7 +1442,7 @@ } for( int i = 0; i <= max_position; ++i ) { if( i == 0 ) { - fprintf(fp, " MachNode *inst0 = this;\n", i); + fprintf(fp, " MachNode *inst0 = this;\n"); } else { fprintf(fp, " MachNode *inst%d = NULL;\n", i); } @@ -1743,7 +1742,7 @@ } // delete the rest of edges fprintf(fp," for(int i = idx%d - 1; i >= (int)idx%d; i--) {\n", cur_num_opnds, new_num_opnds); - fprintf(fp," del_req(i);\n", i); + fprintf(fp," del_req(i);\n"); fprintf(fp," }\n"); fprintf(fp," _num_opnds = %d;\n", new_num_opnds); } @@ -1817,7 +1816,7 @@ fprintf(fp,"\n"); if( node->expands() ) { - fprintf(fp," return result;\n",cnt-1); + fprintf(fp," return result;\n"); } else { fprintf(fp," return this;\n"); } diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/adlc/output_h.cpp --- a/src/share/vm/adlc/output_h.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/adlc/output_h.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 1998-2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1998-2009 Sun Microsystems, Inc. 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 @@ -574,7 +574,7 @@ // Generate the user-defined portion of the format if( inst._format ) { // If there are replacement variables, - // Generate index values needed for determing the operand position + // Generate index values needed for determining the operand position if( inst._format->_rep_vars.count() ) inst.index_temps(fp, globals); @@ -1832,7 +1832,7 @@ break; case Form::idealP: case Form::idealN: - fprintf(fp," return opnd_array(1)->type();\n",result); + fprintf(fp," return opnd_array(1)->type();\n"); break; case Form::idealD: fprintf(fp," return TypeD::make(opnd_array(1)->constantD());\n"); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/asm/assembler.cpp --- a/src/share/vm/asm/assembler.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/asm/assembler.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -31,7 +31,7 @@ // The AbstractAssembler is generating code into a CodeBuffer. To make code generation faster, // the assembler keeps a copy of the code buffers boundaries & modifies them when // emitting bytes rather than using the code buffers accessor functions all the time. -// The code buffer is updated via set_code_end(...) after emiting a whole instruction. +// The code buffer is updated via set_code_end(...) after emitting a whole instruction. AbstractAssembler::AbstractAssembler(CodeBuffer* code) { if (code == NULL) return; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/asm/assembler.hpp --- a/src/share/vm/asm/assembler.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/asm/assembler.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -22,7 +22,7 @@ * */ -// This file contains platform-independant assembler declarations. +// This file contains platform-independent assembler declarations. class CodeBuffer; class MacroAssembler; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/ci/ciTypeFlow.cpp --- a/src/share/vm/ci/ciTypeFlow.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/ci/ciTypeFlow.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -541,7 +541,7 @@ // is report a value that will meet correctly with any downstream // reference types on paths that will truly be executed. This null type // meets with any reference type to yield that same reference type. - // (The compiler will generate an unconditonal exception here.) + // (The compiler will generate an unconditional exception here.) push(null_type()); return; } diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/classfile/symbolTable.cpp --- a/src/share/vm/classfile/symbolTable.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/classfile/symbolTable.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -156,7 +156,7 @@ symbolOop test = lookup(index, (char*)name, len, hashValue); if (test != NULL) { - // A race occured and another thread introduced the symbol, this one + // A race occurred and another thread introduced the symbol, this one // will be dropped and collected. return test; } @@ -193,7 +193,7 @@ int index = hash_to_index(hashValues[i]); symbolOop test = lookup(index, names[i], lengths[i], hashValues[i]); if (test != NULL) { - // A race occured and another thread introduced the symbol, this one + // A race occurred and another thread introduced the symbol, this one // will be dropped and collected. Use test instead. cp->symbol_at_put(cp_indices[i], test); } else { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/code/nmethod.cpp --- a/src/share/vm/code/nmethod.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/code/nmethod.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -380,7 +380,7 @@ void nmethod::add_handler_for_exception_and_pc(Handle exception, address pc, address handler) { // There are potential race conditions during exception cache updates, so we // must own the ExceptionCache_lock before doing ANY modifications. Because - // we dont lock during reads, it is possible to have several threads attempt + // we don't lock during reads, it is possible to have several threads attempt // to update the cache with the same data. We need to check for already inserted // copies of the current data before adding it. diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/code/nmethod.hpp --- a/src/share/vm/code/nmethod.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/code/nmethod.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -167,7 +167,7 @@ nmFlags flags; // various flags to keep track of nmethod state bool _markedForDeoptimization; // Used for stack deoptimization enum { alive = 0, - not_entrant = 1, // uncommon trap has happend but activations may still exist + not_entrant = 1, // uncommon trap has happened but activations may still exist zombie = 2, unloaded = 3 }; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp --- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -393,7 +393,7 @@ // Restarts the concurrent phases timer. void concurrent_phases_resume(); - // Time begining and end of the marking phase for + // Time beginning and end of the marking phase for // a synchronous MS collection. A MS collection // that finishes in the foreground can have started // in the background. These methods capture the diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp --- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -69,7 +69,7 @@ // end of the sweep of the tenured generation. PerfVariable* _avg_cms_free_counter; // Average of the free space in the tenured generation at the - // start of the sweep of the tenured genertion. + // start of the sweep of the tenured generation. PerfVariable* _avg_cms_free_at_sweep_counter; // Average of the free space in the tenured generation at the // after any resizing of the tenured generation at the end diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp --- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -4178,7 +4178,7 @@ // and is deferred for now; see CR# TBF. 07252005YSR. XXX assert(!CMSAbortSemantics || tsk.aborted(), "Inconsistency"); // If _restart_addr is non-NULL, a marking stack overflow - // occured; we need to do a fresh marking iteration from the + // occurred; we need to do a fresh marking iteration from the // indicated restart address. if (_foregroundGCIsActive && asynch) { // We may be running into repeated stack overflows, having @@ -4221,7 +4221,7 @@ // should be incremental with periodic yields. _markBitMap.iterate(&markFromRootsClosure); // If _restart_addr is non-NULL, a marking stack overflow - // occured; we need to do a fresh iteration from the + // occurred; we need to do a fresh iteration from the // indicated restart address. while (_restart_addr != NULL) { if (_foregroundGCIsActive && asynch) { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp --- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -2513,7 +2513,7 @@ } save_marks(); - // We must do this before any possible evacuation that should propogate + // We must do this before any possible evacuation that should propagate // marks, including evacuation of popular objects in a popular pause. if (mark_in_progress()) { double start_time_sec = os::elapsedTime(); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp --- a/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -78,7 +78,7 @@ } // Card marks are not precise. The current system can leave us with - // a mismash of precise marks and begining of object marks. This means + // a mismash of precise marks and beginning of object marks. This means // we test for missing precise marks first. If any are found, we don't // fail unless the object head is also unmarked. virtual void do_object(oop obj) { @@ -258,7 +258,7 @@ if (!start_array->object_starts_in_range(slice_start, slice_end)) { continue; } - // Update our begining addr + // Update our beginning addr HeapWord* first_object = start_array->object_start(slice_start); debug_only(oop* first_object_within_slice = (oop*) first_object;) if (first_object < slice_start) { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/gc_implementation/parallelScavenge/objectStartArray.hpp --- a/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -127,7 +127,7 @@ // Optimized for finding the first object that crosses into // a given block. The blocks contain the offset of the last // object in that block. Scroll backwards by one, and the first - // object hit should be at the begining of the block + // object hit should be at the beginning of the block HeapWord* object_start(HeapWord* addr) const { assert(_covered_region.contains(addr), "Must be in covered region"); jbyte* block = block_for_addr(addr); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/gc_implementation/parallelScavenge/prefetchQueue.hpp --- a/src/share/vm/gc_implementation/parallelScavenge/prefetchQueue.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/prefetchQueue.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -26,7 +26,7 @@ // PrefetchQueue is a FIFO queue of variable length (currently 8). // // We need to examine the performance penalty of variable lengths. -// We may also want to split this into cpu dependant bits. +// We may also want to split this into cpu dependent bits. // const int PREFETCH_QUEUE_SIZE = 8; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp --- a/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -74,7 +74,7 @@ for (int i = 0; i < lgrp_spaces()->length(); i++) { LGRPSpace *ls = lgrp_spaces()->at(i); MutableSpace *s = ls->space(); - if (s->top() < top()) { // For all spaces preceeding the one containing top() + if (s->top() < top()) { // For all spaces preceding the one containing top() if (s->free_in_words() > 0) { size_t area_touched_words = pointer_delta(s->end(), s->top()); CollectedHeap::fill_with_object(s->top(), area_touched_words); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/includeDB_core --- a/src/share/vm/includeDB_core Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/includeDB_core Thu Mar 05 22:07:29 2009 -0500 @@ -474,6 +474,7 @@ cardTableModRefBS.cpp mutexLocker.hpp cardTableModRefBS.cpp sharedHeap.hpp cardTableModRefBS.cpp space.hpp +cardTableModRefBS.cpp space.inline.hpp cardTableModRefBS.cpp universe.hpp cardTableModRefBS.cpp virtualspace.hpp diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/interpreter/abstractInterpreter.hpp --- a/src/share/vm/interpreter/abstractInterpreter.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/interpreter/abstractInterpreter.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -22,7 +22,7 @@ * */ -// This file contains the platform-independant parts +// This file contains the platform-independent parts // of the abstract interpreter and the abstract interpreter generator. // Organization of the interpreter(s). There exists two different interpreters in hotpot diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/interpreter/bytecodeInterpreter.cpp --- a/src/share/vm/interpreter/bytecodeInterpreter.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/interpreter/bytecodeInterpreter.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -2642,7 +2642,7 @@ // two interpreted frames). We need to save the current arguments in C heap so that // the deoptimized frame when it restarts can copy the arguments to its expression // stack and re-execute the call. We also have to notify deoptimization that this - // has occured and to pick the preerved args copy them to the deoptimized frame's + // has occurred and to pick the preserved args copy them to the deoptimized frame's // java expression stack. Yuck. // THREAD->popframe_preserve_args(in_ByteSize(METHOD->size_of_parameters() * wordSize), diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/interpreter/bytecodeInterpreter.inline.hpp --- a/src/share/vm/interpreter/bytecodeInterpreter.inline.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/interpreter/bytecodeInterpreter.inline.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -22,7 +22,7 @@ * */ -// This file holds platform-independant bodies of inline functions for the C++ based interpreter +// This file holds platform-independent bodies of inline functions for the C++ based interpreter #ifdef CC_INTERP diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/interpreter/cppInterpreter.hpp --- a/src/share/vm/interpreter/cppInterpreter.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/interpreter/cppInterpreter.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -24,7 +24,7 @@ #ifdef CC_INTERP -// This file contains the platform-independant parts +// This file contains the platform-independent parts // of the c++ interpreter class CppInterpreter: public AbstractInterpreter { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/interpreter/cppInterpreterGenerator.hpp --- a/src/share/vm/interpreter/cppInterpreterGenerator.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/interpreter/cppInterpreterGenerator.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -22,7 +22,7 @@ * */ -// This file contains the platform-independant parts +// This file contains the platform-independent parts // of the template interpreter generator. #ifdef CC_INTERP diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/interpreter/interpreter.hpp --- a/src/share/vm/interpreter/interpreter.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/interpreter/interpreter.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -22,7 +22,7 @@ * */ -// This file contains the platform-independant parts +// This file contains the platform-independent parts // of the interpreter and the interpreter generator. //------------------------------------------------------------------------------------------------------------------------ diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/interpreter/interpreterGenerator.hpp --- a/src/share/vm/interpreter/interpreterGenerator.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/interpreter/interpreterGenerator.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -22,7 +22,7 @@ * */ -// This file contains the platform-independant parts +// This file contains the platform-independent parts // of the interpreter generator. diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/interpreter/templateInterpreter.hpp --- a/src/share/vm/interpreter/templateInterpreter.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/interpreter/templateInterpreter.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -22,7 +22,7 @@ * */ -// This file contains the platform-independant parts +// This file contains the platform-independent parts // of the template interpreter and the template interpreter generator. #ifndef CC_INTERP diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/interpreter/templateInterpreterGenerator.hpp --- a/src/share/vm/interpreter/templateInterpreterGenerator.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/interpreter/templateInterpreterGenerator.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -22,7 +22,7 @@ * */ -// This file contains the platform-independant parts +// This file contains the platform-independent parts // of the template interpreter generator. #ifndef CC_INTERP diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/libadt/dict.cpp --- a/src/share/vm/libadt/dict.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/libadt/dict.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -306,7 +306,7 @@ // Convert string to hash key. This algorithm implements a universal hash // function with the multipliers frozen (ok, so it's not universal). The // multipliers (and allowable characters) are all odd, so the resultant sum -// is odd - guarenteed not divisible by any power of two, so the hash tables +// is odd - guaranteed not divisible by any power of two, so the hash tables // can be any power of two with good results. Also, I choose multipliers // that have only 2 bits set (the low is always set to be odd) so // multiplication requires only shifts and adds. Characters are required to @@ -326,7 +326,7 @@ } //------------------------------hashptr-------------------------------------- -// Slimey cheap hash function; no guarenteed performance. Better than the +// Slimey cheap hash function; no guaranteed performance. Better than the // default for pointers, especially on MS-DOS machines. int hashptr(const void *key) { #ifdef __TURBOC__ @@ -336,7 +336,7 @@ #endif } -// Slimey cheap hash function; no guarenteed performance. +// Slimey cheap hash function; no guaranteed performance. int hashkey(const void *key) { return (intptr_t)key; } diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/libadt/dict.hpp --- a/src/share/vm/libadt/dict.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/libadt/dict.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -86,10 +86,10 @@ // Hashing functions int hashstr(const void *s); // Nice string hash -// Slimey cheap hash function; no guarenteed performance. Better than the +// Slimey cheap hash function; no guaranteed performance. Better than the // default for pointers, especially on MS-DOS machines. int hashptr(const void *key); -// Slimey cheap hash function; no guarenteed performance. +// Slimey cheap hash function; no guaranteed performance. int hashkey(const void *key); // Key comparators diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/memory/filemap.cpp --- a/src/share/vm/memory/filemap.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/memory/filemap.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -35,14 +35,14 @@ extern address JVM_FunctionAtStart(); extern address JVM_FunctionAtEnd(); -// Complain and stop. All error conditions occuring during the writing of +// Complain and stop. All error conditions occurring during the writing of // an archive file should stop the process. Unrecoverable errors during // the reading of the archive file should stop the process. static void fail(const char *msg, va_list ap) { // This occurs very early during initialization: tty is not initialized. jio_fprintf(defaultStream::error_stream(), - "An error has occured while processing the" + "An error has occurred while processing the" " shared archive file.\n"); jio_vfprintf(defaultStream::error_stream(), msg, ap); jio_fprintf(defaultStream::error_stream(), "\n"); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/memory/permGen.hpp --- a/src/share/vm/memory/permGen.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/memory/permGen.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -36,7 +36,7 @@ friend class VMStructs; protected: size_t _capacity_expansion_limit; // maximum expansion allowed without a - // full gc occuring + // full gc occurring HeapWord* mem_allocate_in_gen(size_t size, Generation* gen); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/oops/generateOopMap.cpp --- a/src/share/vm/oops/generateOopMap.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/oops/generateOopMap.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -2003,7 +2003,7 @@ // ============ Main Entry Point =========== // GenerateOopMap::GenerateOopMap(methodHandle method) { - // We have to initialize all variables here, that can be queried direcly + // We have to initialize all variables here, that can be queried directly _method = method; _max_locals=0; _init_vars = NULL; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/oops/generateOopMap.hpp --- a/src/share/vm/oops/generateOopMap.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/oops/generateOopMap.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -292,7 +292,7 @@ int _max_stack; // Cached value of max. stack depth int _max_monitors; // Cached value of max. monitor stack depth int _has_exceptions; // True, if exceptions exist for method - bool _got_error; // True, if an error occured during interpretation. + bool _got_error; // True, if an error occurred during interpretation. Handle _exception; // Exception if got_error is true. bool _did_rewriting; // was bytecodes rewritten bool _did_relocation; // was relocation neccessary @@ -422,7 +422,7 @@ void add_to_ref_init_set (int localNo); // Conflicts rewrite logic - bool _conflict; // True, if a conflict occured during interpretation + bool _conflict; // True, if a conflict occurred during interpretation int _nof_refval_conflicts; // No. of conflicts that require rewrites int * _new_var_map; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/oops/instanceKlass.cpp --- a/src/share/vm/oops/instanceKlass.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/oops/instanceKlass.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1917,7 +1917,7 @@ / itableOffsetEntry::size(); for (int cnt = 0 ; ; cnt ++, ioe ++) { - // If the interface isn't implemented by the reciever class, + // If the interface isn't implemented by the receiver class, // the VM should throw IncompatibleClassChangeError. if (cnt >= nof_interfaces) { THROW_OOP_0(vmSymbols::java_lang_IncompatibleClassChangeError()); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/oops/klass.cpp --- a/src/share/vm/oops/klass.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/oops/klass.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -71,7 +71,7 @@ return r; // Return the 1 concrete class } -// Find LCA in class heirarchy +// Find LCA in class hierarchy Klass *Klass::LCA( Klass *k2 ) { Klass *k1 = this; while( 1 ) { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/oops/klass.hpp --- a/src/share/vm/oops/klass.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/oops/klass.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -471,7 +471,7 @@ } bool search_secondary_supers(klassOop k) const; - // Find LCA in class heirarchy + // Find LCA in class hierarchy Klass *LCA( Klass *k ); // Check whether reflection/jni/jvm code is allowed to instantiate this class; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/oops/methodOop.hpp --- a/src/share/vm/oops/methodOop.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/oops/methodOop.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -296,7 +296,7 @@ void set_compiled_invocation_count(int count) { _compiled_invocation_count = count; } #endif // not PRODUCT - // Clear (non-shared space) pointers which could not be relevent + // Clear (non-shared space) pointers which could not be relevant // if this (shared) method were mapped into another JVM. void remove_unshareable_info(); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/block.cpp --- a/src/share/vm/opto/block.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/block.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -181,7 +181,7 @@ } //------------------------------has_uncommon_code------------------------------ -// Return true if the block's code implies that it is not likely to be +// Return true if the block's code implies that it is likely to be // executed infrequently. Check to see if the block ends in a Halt or // a low probability call. bool Block::has_uncommon_code() const { @@ -909,6 +909,10 @@ !(n->jvms() != NULL && n->jvms()->is_monitor_use(k)) ) { assert( b->find_node(def) < j, "uses must follow definitions" ); } + if( def->is_SafePointScalarObject() ) { + assert(_bbs[def->_idx] == b, "SafePointScalarObject Node should be at the same block as its SafePoint node"); + assert(_bbs[def->_idx] == _bbs[def->in(0)->_idx], "SafePointScalarObject Node should be at the same block as its control edge"); + } } } } @@ -1307,7 +1311,7 @@ } } else if (e->state() == CFGEdge::open) { // Append traces, even without a fall-thru connection. - // But leave root entry at the begining of the block list. + // But leave root entry at the beginning of the block list. if (targ_trace != trace(_cfg._broot)) { e->set_state(CFGEdge::connected); src_trace->append(targ_trace); @@ -1430,7 +1434,7 @@ } // Backbranch to the top of a trace - // Scroll foward through the trace from the targ_block. If we find + // Scroll forward through the trace from the targ_block. If we find // a loop head before another loop top, use the the loop head alignment. for (Block *b = targ_block; b != NULL; b = next(b)) { if (b->has_loop_alignment()) { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/block.hpp --- a/src/share/vm/opto/block.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/block.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -347,6 +347,8 @@ // Helper function to insert a node into a block void schedule_node_into_block( Node *n, Block *b ); + void replace_block_proj_ctrl( Node *n ); + // Set the basic block for pinned Nodes void schedule_pinned_nodes( VectorSet &visited ); @@ -607,7 +609,7 @@ Block * next(Block *b) const { return _next_list[b->_pre_order]; } void set_next(Block *b, Block *n) const { _next_list[b->_pre_order] = n; } - // Return the block that preceeds "b" in the trace. + // Return the block that precedes "b" in the trace. Block * prev(Block *b) const { return _prev_list[b->_pre_order]; } void set_prev(Block *b, Block *p) const { _prev_list[b->_pre_order] = p; } diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/buildOopMap.cpp --- a/src/share/vm/opto/buildOopMap.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/buildOopMap.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -55,7 +55,7 @@ // breadth-first approach but it was worse (showed O(n^2) in the // pick-next-block code). // -// The relevent data is kept in a struct of arrays (it could just as well be +// The relevant data is kept in a struct of arrays (it could just as well be // an array of structs, but the struct-of-arrays is generally a little more // efficient). The arrays are indexed by register number (including // stack-slots as registers) and so is bounded by 200 to 300 elements in diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/callnode.cpp --- a/src/share/vm/opto/callnode.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/callnode.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -975,6 +975,7 @@ } bool SafePointScalarObjectNode::pinned() const { return true; } +bool SafePointScalarObjectNode::depends_only_on_test() const { return false; } uint SafePointScalarObjectNode::ideal_reg() const { return 0; // No matching to machine instruction diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/callnode.hpp --- a/src/share/vm/opto/callnode.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/callnode.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -437,6 +437,10 @@ // of the SafePoint node for which it was generated. virtual bool pinned() const; // { return true; } + // SafePointScalarObject depends on the SafePoint node + // for which it was generated. + virtual bool depends_only_on_test() const; // { return false; } + virtual uint size_of() const { return sizeof(*this); } // Assumes that "this" is an argument to a safepoint node "s", and that diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/cfgnode.cpp --- a/src/share/vm/opto/cfgnode.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/cfgnode.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1350,7 +1350,7 @@ } // Register the new node but do not transform it. Cannot transform until the - // entire Region/Phi conglerate has been hacked as a single huge transform. + // entire Region/Phi conglomerate has been hacked as a single huge transform. igvn->register_new_node_with_optimizer( newn ); // Now I can point to the new node. n->add_req(newn); @@ -1381,7 +1381,7 @@ Node *val = phi->in(i); // Constant to split for uint hit = 0; // Number of times it occurs - for( ; i < phi->req(); i++ ){ // Count occurances of constant + for( ; i < phi->req(); i++ ){ // Count occurrences of constant Node *n = phi->in(i); if( !n ) return NULL; if( phase->type(n) == Type::TOP ) return NULL; @@ -1423,7 +1423,7 @@ //============================================================================= //------------------------------simple_data_loop_check------------------------- -// Try to determing if the phi node in a simple safe/unsafe data loop. +// Try to determining if the phi node in a simple safe/unsafe data loop. // Returns: // enum LoopSafety { Safe = 0, Unsafe, UnsafeLoop }; // Safe - safe case when the phi and it's inputs reference only safe data @@ -1687,7 +1687,7 @@ progress = phase->C->top(); break; } - // If tranformed to a MergeMem, get the desired slice + // If transformed to a MergeMem, get the desired slice // Otherwise the returned node represents memory for every slice Node *new_mem = (m->is_MergeMem()) ? m->as_MergeMem()->memory_at(alias_idx) : m; @@ -1962,7 +1962,7 @@ f[CatchProjNode::fall_through_index] = Type::TOP; } else if( call->req() > TypeFunc::Parms ) { const Type *arg0 = phase->type( call->in(TypeFunc::Parms) ); - // Check for null reciever to virtual or interface calls + // Check for null receiver to virtual or interface calls if( call->is_CallDynamicJava() && arg0->higher_equal(TypePtr::NULL_PTR) ) { f[CatchProjNode::fall_through_index] = Type::TOP; @@ -1995,7 +1995,7 @@ // also remove any exception table entry. Thus we must know the call // feeding the Catch will not really throw an exception. This is ok for // the main fall-thru control (happens when we know a call can never throw - // an exception) or for "rethrow", because a further optimnization will + // an exception) or for "rethrow", because a further optimization will // yank the rethrow (happens when we inline a function that can throw an // exception and the caller has no handler). Not legal, e.g., for passing // a NULL receiver to a v-call, or passing bad types to a slow-check-cast. diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/chaitin.cpp --- a/src/share/vm/opto/chaitin.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/chaitin.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1246,7 +1246,7 @@ // If the live range is not bound, then we actually had some choices // to make. In this case, the mask has more bits in it than the colors - // choosen. Restrict the mask to just what was picked. + // chosen. Restrict the mask to just what was picked. if( lrg->num_regs() == 1 ) { // Size 1 live range lrg->Clear(); // Clear the mask lrg->Insert(reg); // Set regmask to match selected reg diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/chaitin.hpp --- a/src/share/vm/opto/chaitin.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/chaitin.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -327,7 +327,7 @@ // True if lidx is used before any real register is def'd in the block bool prompt_use( Block *b, uint lidx ); Node *get_spillcopy_wide( Node *def, Node *use, uint uidx ); - // Insert the spill at chosen location. Skip over any interveneing Proj's or + // Insert the spill at chosen location. Skip over any intervening Proj's or // Phis. Skip over a CatchNode and projs, inserting in the fall-through block // instead. Update high-pressure indices. Create a new live range. void insert_proj( Block *b, uint i, Node *spill, uint maxlrg ); @@ -431,7 +431,7 @@ void Simplify(); // Select colors by re-inserting edges into the IFG. - // Return TRUE if any spills occured. + // Return TRUE if any spills occurred. uint Select( ); // Helper function for select which allows biased coloring OptoReg::Name choose_color( LRG &lrg, int chunk ); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/coalesce.cpp --- a/src/share/vm/opto/coalesce.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/coalesce.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -123,7 +123,7 @@ } //------------------------------clone_projs------------------------------------ -// After cloning some rematierialized instruction, clone any MachProj's that +// After cloning some rematerialized instruction, clone any MachProj's that // follow it. Example: Intel zero is XOR, kills flags. Sparc FP constants // use G3 as an address temp. int PhaseChaitin::clone_projs( Block *b, uint idx, Node *con, Node *copy, uint &maxlrg ) { @@ -694,8 +694,8 @@ } // End of if not infinite-stack neighbor } // End of if actually inserted } // End of if live range overlaps - } // End of else collect intereferences for 1 node - } // End of while forever, scan back for intereferences + } // End of else collect interferences for 1 node + } // End of while forever, scan back for interferences return reg_degree; } @@ -786,7 +786,7 @@ if( rm_size == 0 ) return false; // Another early bail-out test is when we are double-coalescing and the - // 2 copies are seperated by some control flow. + // 2 copies are separated by some control flow. if( dst_copy != src_copy ) { Block *src_b = _phc._cfg._bbs[src_copy->_idx]; Block *b2 = b; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/compile.cpp --- a/src/share/vm/opto/compile.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/compile.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -337,7 +337,7 @@ tty->print_cr("*********************************************************"); } if (env()->break_at_compile()) { - // Open the debugger when compiing this method. + // Open the debugger when compiling this method. tty->print("### Breaking when compiling: "); method()->print_short_name(); tty->cr(); @@ -1191,8 +1191,8 @@ default: ShouldNotReachHere(); } break; - case 2: // No collasping at level 2; keep all splits - case 3: // No collasping at level 3; keep all splits + case 2: // No collapsing at level 2; keep all splits + case 3: // No collapsing at level 3; keep all splits break; default: Unimplemented(); @@ -2102,7 +2102,7 @@ // [base_reg + offset] // NullCheck base_reg // - // Pin the new DecodeN node to non-null path on these patforms (Sparc) + // Pin the new DecodeN node to non-null path on these platform (Sparc) // to keep the information to which NULL check the new DecodeN node // corresponds to use it as value in implicit_null_check(). // diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/connode.cpp --- a/src/share/vm/opto/connode.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/connode.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -71,7 +71,7 @@ to figure out which test post-dominates. The real problem is that it doesn't matter which one you pick. After you pick up, the dominating-test elider in IGVN can remove the test and allow you to hoist up to the dominating test on -the choosen oop bypassing the test on the not-choosen oop. Seen in testing. +the chosen oop bypassing the test on the not-chosen oop. Seen in testing. Oops. (3) Leave the CastPP's in. This makes the graph more accurate in some sense; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/divnode.cpp --- a/src/share/vm/opto/divnode.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/divnode.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -35,7 +35,7 @@ // by constant into a multiply/shift/add series. Return false if calculations // fail. // -// Borrowed almost verbatum from Hacker's Delight by Henry S. Warren, Jr. with +// Borrowed almost verbatim from Hacker's Delight by Henry S. Warren, Jr. with // minor type name and parameter changes. static bool magic_int_divide_constants(jint d, jint &M, jint &s) { int32_t p; @@ -202,7 +202,7 @@ // by constant into a multiply/shift/add series. Return false if calculations // fail. // -// Borrowed almost verbatum from Hacker's Delight by Henry S. Warren, Jr. with +// Borrowed almost verbatim from Hacker's Delight by Henry S. Warren, Jr. with // minor type name and parameter changes. Adjusted to 64 bit word width. static bool magic_long_divide_constants(jlong d, jlong &M, jint &s) { int64_t p; @@ -1069,7 +1069,7 @@ int log2_con = -1; - // If this is a power of two, they maybe we can mask it + // If this is a power of two, then maybe we can mask it if( is_power_of_2_long(pos_con) ) { log2_con = log2_long(pos_con); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/domgraph.cpp --- a/src/share/vm/opto/domgraph.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/domgraph.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -183,7 +183,7 @@ if (pre_order == 1) t->_parent = NULL; // first block doesn't have parent else { - // Save parent (currernt top block on stack) in DFS + // Save parent (current top block on stack) in DFS t->_parent = &_tarjan[_stack_top->block->_pre_order]; } // Now put this block on stack diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/escape.cpp --- a/src/share/vm/opto/escape.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/escape.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -515,7 +515,7 @@ // cause the failure in add_offset() with narrow oops since TypeOopPtr() // constructor verifies correctness of the offset. // - // It could happend on subclass's branch (from the type profiling + // It could happened on subclass's branch (from the type profiling // inlining) which was not eliminated during parsing since the exactness // of the allocation type was not propagated to the subclass type check. // @@ -703,7 +703,7 @@ while (prev != result) { prev = result; if (result == start_mem) - break; // hit one of our sentinals + break; // hit one of our sentinels if (result->is_Mem()) { const Type *at = phase->type(result->in(MemNode::Address)); if (at != Type::TOP) { @@ -720,7 +720,7 @@ if (result->is_Proj() && result->as_Proj()->_con == TypeFunc::Memory) { Node *proj_in = result->in(0); if (proj_in->is_Allocate() && proj_in->_idx == (uint)tinst->instance_id()) { - break; // hit one of our sentinals + break; // hit one of our sentinels } else if (proj_in->is_Call()) { CallNode *call = proj_in->as_Call(); if (!call->may_modify(tinst, phase)) { @@ -804,7 +804,7 @@ // Phase 2: Process MemNode's from memnode_worklist. compute new address type and // search the Memory chain for a store with the appropriate type // address type. If a Phi is found, create a new version with -// the approriate memory slices from each of the Phi inputs. +// the appropriate memory slices from each of the Phi inputs. // For stores, process the users as follows: // MemNode: push on memnode_worklist // MergeMem: push on mergemem_worklist @@ -1558,7 +1558,7 @@ has_non_escaping_obj = true; // Non GlobalEscape Node* n = ptn->_node; if (n->is_Allocate() && ptn->_scalar_replaceable ) { - // Push scalar replaceable alocations on alloc_worklist + // Push scalar replaceable allocations on alloc_worklist // for processing in split_unique_types(). alloc_worklist.append(n); } diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/gcm.cpp --- a/src/share/vm/opto/gcm.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/gcm.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -57,6 +57,37 @@ } } +//----------------------------replace_block_proj_ctrl------------------------- +// Nodes that have is_block_proj() nodes as their control need to use +// the appropriate Region for their actual block as their control since +// the projection will be in a predecessor block. +void PhaseCFG::replace_block_proj_ctrl( Node *n ) { + const Node *in0 = n->in(0); + assert(in0 != NULL, "Only control-dependent"); + const Node *p = in0->is_block_proj(); + if (p != NULL && p != n) { // Control from a block projection? + assert(!n->pinned() || n->is_SafePointScalarObject(), "only SafePointScalarObject pinned node is expected here"); + // Find trailing Region + Block *pb = _bbs[in0->_idx]; // Block-projection already has basic block + uint j = 0; + if (pb->_num_succs != 1) { // More then 1 successor? + // Search for successor + uint max = pb->_nodes.size(); + assert( max > 1, "" ); + uint start = max - pb->_num_succs; + // Find which output path belongs to projection + for (j = start; j < max; j++) { + if( pb->_nodes[j] == in0 ) + break; + } + assert( j < max, "must find" ); + // Change control to match head of successor basic block + j -= start; + } + n->set_req(0, pb->_succs[j]->head()); + } +} + //------------------------------schedule_pinned_nodes-------------------------- // Set the basic block for Nodes pinned into blocks @@ -68,8 +99,10 @@ Node *n = spstack.pop(); if( !visited.test_set(n->_idx) ) { // Test node and flag it as visited if( n->pinned() && !_bbs.lookup(n->_idx) ) { // Pinned? Nail it down! + assert( n->in(0), "pinned Node must have Control" ); + // Before setting block replace block_proj control edge + replace_block_proj_ctrl(n); Node *input = n->in(0); - assert( input, "pinned Node must have Control" ); while( !input->is_block_start() ) input = input->in(0); Block *b = _bbs[input->_idx]; // Basic block of controlling input @@ -158,34 +191,12 @@ uint i = nstack_top_i; if (i == 0) { - // Special control input processing. - // While I am here, go ahead and look for Nodes which are taking control - // from a is_block_proj Node. After I inserted RegionNodes to make proper - // blocks, the control at a is_block_proj more properly comes from the - // Region being controlled by the block_proj Node. + // Fixup some control. Constants without control get attached + // to root and nodes that use is_block_proj() nodes should be attached + // to the region that starts their block. const Node *in0 = n->in(0); if (in0 != NULL) { // Control-dependent? - const Node *p = in0->is_block_proj(); - if (p != NULL && p != n) { // Control from a block projection? - // Find trailing Region - Block *pb = _bbs[in0->_idx]; // Block-projection already has basic block - uint j = 0; - if (pb->_num_succs != 1) { // More then 1 successor? - // Search for successor - uint max = pb->_nodes.size(); - assert( max > 1, "" ); - uint start = max - pb->_num_succs; - // Find which output path belongs to projection - for (j = start; j < max; j++) { - if( pb->_nodes[j] == in0 ) - break; - } - assert( j < max, "must find" ); - // Change control to match head of successor basic block - j -= start; - } - n->set_req(0, pb->_succs[j]->head()); - } + replace_block_proj_ctrl(n); } else { // n->in(0) == NULL if (n->req() == 1) { // This guy is a constant with NO inputs? n->set_req(0, _root); @@ -226,6 +237,8 @@ if (!n->pinned()) { // Set earliest legal block. _bbs.map(n->_idx, find_deepest_input(n, _bbs)); + } else { + assert(_bbs[n->_idx] == _bbs[n->in(0)->_idx], "Pinned Node should be at the same block as its control edge"); } if (nstack.is_empty()) { @@ -593,7 +606,7 @@ if (pred_block != early) { // If any predecessor of the Phi matches the load's "early block", // we do not need a precedence edge between the Phi and 'load' - // since the load will be forced into a block preceeding the Phi. + // since the load will be forced into a block preceding the Phi. pred_block->set_raise_LCA_mark(load_index); assert(!LCA_orig->dominates(pred_block) || early->dominates(pred_block), "early is high enough"); @@ -1386,7 +1399,7 @@ #ifdef ASSERT for (uint i = 0; i < _num_blocks; i++ ) { Block *b = _blocks[i]; - assert(b->_freq >= MIN_BLOCK_FREQUENCY, "Register Allocator requiers meaningful block frequency"); + assert(b->_freq >= MIN_BLOCK_FREQUENCY, "Register Allocator requires meaningful block frequency"); } #endif @@ -1639,7 +1652,7 @@ // successor blocks. assert(_num_succs == 2, "expecting 2 successors of a null check"); // If either successor has only one predecessor, then the - // probabiltity estimate can be derived using the + // probability estimate can be derived using the // relative frequency of the successor and this block. if (_succs[i]->num_preds() == 2) { return _succs[i]->_freq / _freq; @@ -1841,7 +1854,7 @@ } //------------------------------update_succ_freq------------------------------- -// Update the appropriate frequency associated with block 'b', a succesor of +// Update the appropriate frequency associated with block 'b', a successor of // a block in this loop. void CFGLoop::update_succ_freq(Block* b, float freq) { if (b->_loop == this) { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/graphKit.cpp --- a/src/share/vm/opto/graphKit.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/graphKit.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1148,7 +1148,7 @@ Node *tst = _gvn.transform( btst ); //----------- - // if peephole optimizations occured, a prior test existed. + // if peephole optimizations occurred, a prior test existed. // If a prior test existed, maybe it dominates as we can avoid this test. if (tst != btst && type == T_OBJECT) { // At this point we want to scan up the CFG to see if we can @@ -1196,7 +1196,7 @@ // Consider using 'Reason_class_check' instead? // To cause an implicit null check, we set the not-null probability - // to the maximum (PROB_MAX). For an explicit check the probablity + // to the maximum (PROB_MAX). For an explicit check the probability // is set to a smaller value. if (null_control != NULL || too_many_traps(reason)) { // probability is less likely diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/ifg.cpp --- a/src/share/vm/opto/ifg.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/ifg.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -292,7 +292,7 @@ //------------------------------interfere_with_live---------------------------- // Interfere this register with everything currently live. Use the RegMasks // to trim the set of possible interferences. Return a count of register-only -// inteferences as an estimate of register pressure. +// interferences as an estimate of register pressure. void PhaseChaitin::interfere_with_live( uint r, IndexSet *liveout ) { uint retval = 0; // Interfere with everything live. diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/ifnode.cpp --- a/src/share/vm/opto/ifnode.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/ifnode.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -81,7 +81,7 @@ uint i4; for( i4 = 1; i4 < phi->req(); i4++ ) { con1 = phi->in(i4); - if( !con1 ) return NULL; // Do not optimize partially collaped merges + if( !con1 ) return NULL; // Do not optimize partially collapsed merges if( con1->is_Con() ) break; // Found a constant // Also allow null-vs-not-null checks const TypePtr *tp = igvn->type(con1)->isa_ptr(); @@ -204,7 +204,7 @@ // T F T F T F // ..s.. ..t .. ..s.. ..t.. ..s.. ..t.. // - // Split the paths coming into the merge point into 2 seperate groups of + // Split the paths coming into the merge point into 2 separate groups of // merges. On the left will be all the paths feeding constants into the // Cmp's Phi. On the right will be the remaining paths. The Cmp's Phi // will fold up into a constant; this will let the Cmp fold up as well as @@ -236,7 +236,7 @@ } // Register the new RegionNodes but do not transform them. Cannot - // transform until the entire Region/Phi conglerate has been hacked + // transform until the entire Region/Phi conglomerate has been hacked // as a single huge transform. igvn->register_new_node_with_optimizer( region_c ); igvn->register_new_node_with_optimizer( region_x ); @@ -599,7 +599,7 @@ //------------------------------fold_compares---------------------------- // See if a pair of CmpIs can be converted into a CmpU. In some cases -// the direction of this if is determined by the preciding if so it +// the direction of this if is determined by the preceding if so it // can be eliminate entirely. Given an if testing (CmpI n c) check // for an immediately control dependent if that is testing (CmpI n c2) // and has one projection leading to this if and the other projection @@ -811,7 +811,7 @@ // Try to remove extra range checks. All 'up_one_dom' gives up at merges // so all checks we inspect post-dominate the top-most check we find. // If we are going to fail the current check and we reach the top check - // then we are guarenteed to fail, so just start interpreting there. + // then we are guaranteed to fail, so just start interpreting there. // We 'expand' the top 2 range checks to include all post-dominating // checks. diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/library_call.cpp --- a/src/share/vm/opto/library_call.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/library_call.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -992,7 +992,7 @@ Node *argument = pop(); // pop non-receiver first: it was pushed second Node *receiver = pop(); - // don't intrinsify is argument isn't a constant string. + // don't intrinsify if argument isn't a constant string. if (!argument->is_Con()) { return false; } @@ -1267,7 +1267,7 @@ // result = DPow(x,y); // } // if (result != result)? { - // ucommon_trap(); + // uncommon_trap(); // } // return result; @@ -1324,7 +1324,7 @@ // Check if (y isn't int) then go to slow path Node *bol2 = _gvn.transform( new (C, 2) BoolNode( cmpinty, BoolTest::ne ) ); - // Branch eith way + // Branch either way IfNode *if2 = create_and_xform_if(complex_path,bol2, PROB_STATIC_INFREQUENT, COUNT_UNKNOWN); Node *slow_path = opt_iff(r,if2); // Set region path 2 @@ -1715,8 +1715,8 @@ } //----------------------------inline_reverseBytes_int/long------------------- -// inline Int.reverseBytes(int) -// inline Long.reverseByes(long) +// inline Integer.reverseBytes(int) +// inline Long.reverseBytes(long) bool LibraryCallKit::inline_reverseBytes(vmIntrinsics::ID id) { assert(id == vmIntrinsics::_reverseBytes_i || id == vmIntrinsics::_reverseBytes_l, "not reverse Bytes"); if (id == vmIntrinsics::_reverseBytes_i && !Matcher::has_match_rule(Op_ReverseBytesI)) return false; @@ -1915,7 +1915,7 @@ // addition to memory membars when is_volatile. This is a little // too strong, but avoids the need to insert per-alias-type // volatile membars (for stores; compare Parse::do_put_xxx), which - // we cannot do effctively here because we probably only have a + // we cannot do effectively here because we probably only have a // rough approximation of type. need_mem_bar = true; // For Stores, place a memory ordering barrier now. @@ -2099,7 +2099,7 @@ // overly confusing. (This is a true fact! I originally combined // them, but even I was confused by it!) As much code/comments as // possible are retained from inline_unsafe_access though to make - // the correspondances clearer. - dl + // the correspondences clearer. - dl if (callee()->is_static()) return false; // caller must have the capability! @@ -2166,7 +2166,7 @@ int alias_idx = C->get_alias_index(adr_type); // Memory-model-wise, a CAS acts like a little synchronized block, - // so needs barriers on each side. These don't't translate into + // so needs barriers on each side. These don't translate into // actual barriers on most machines, but we still need rest of // compiler to respect ordering. @@ -3208,7 +3208,7 @@ Node *hash_shift = _gvn.intcon(markOopDesc::hash_shift); Node *hshifted_header= _gvn.transform( new (C, 3) URShiftXNode(header, hash_shift) ); // This hack lets the hash bits live anywhere in the mark object now, as long - // as the shift drops the relevent bits into the low 32 bits. Note that + // as the shift drops the relevant bits into the low 32 bits. Note that // Java spec says that HashCode is an int so there's no point in capturing // an 'X'-sized hashcode (32 in 32-bit build or 64 in 64-bit build). hshifted_header = ConvX2I(hshifted_header); @@ -3255,7 +3255,7 @@ } //---------------------------inline_native_getClass---------------------------- -// Build special case code for calls to hashCode on an object. +// Build special case code for calls to getClass on an object. bool LibraryCallKit::inline_native_getClass() { Node* obj = null_check_receiver(callee()); if (stopped()) return true; @@ -4594,7 +4594,7 @@ } // The memory edges above are precise in order to model effects around - // array copyies accurately to allow value numbering of field loads around + // array copies accurately to allow value numbering of field loads around // arraycopy. Such field loads, both before and after, are common in Java // collections and similar classes involving header/array data structures. // diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/live.cpp --- a/src/share/vm/opto/live.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/live.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -39,7 +39,7 @@ // Leftover bits become the new live-in for the predecessor block, and the pred // block is put on the worklist. // The locally live-in stuff is computed once and added to predecessor -// live-out sets. This seperate compilation is done in the outer loop below. +// live-out sets. This separate compilation is done in the outer loop below. PhaseLive::PhaseLive( const PhaseCFG &cfg, LRG_List &names, Arena *arena ) : Phase(LIVE), _cfg(cfg), _names(names), _arena(arena), _live(0) { } diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/locknode.cpp --- a/src/share/vm/opto/locknode.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/locknode.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -121,7 +121,7 @@ kill_dead_locals(); pop(); // Pop oop to unlock - // Because monitors are guarenteed paired (else we bail out), we know + // Because monitors are guaranteed paired (else we bail out), we know // the matching Lock for this Unlock. Hence we know there is no need // for a null check on Unlock. shared_unlock(map()->peek_monitor_box(), map()->peek_monitor_obj()); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/loopTransform.cpp --- a/src/share/vm/opto/loopTransform.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/loopTransform.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -119,7 +119,7 @@ //---------------------is_invariant_addition----------------------------- // Return nonzero index of invariant operand for an Add or Sub -// of (nonconstant) invariant and variant values. Helper for reassoicate_invariants. +// of (nonconstant) invariant and variant values. Helper for reassociate_invariants. int IdealLoopTree::is_invariant_addition(Node* n, PhaseIdealLoop *phase) { int op = n->Opcode(); if (op == Op_AddI || op == Op_SubI) { @@ -520,7 +520,7 @@ //------------------------------policy_align----------------------------------- // Return TRUE or FALSE if the loop should be cache-line aligned. Gather the // expression that does the alignment. Note that only one array base can be -// aligned in a loop (unless the VM guarentees mutual alignment). Note that +// aligned in a loop (unless the VM guarantees mutual alignment). Note that // if we vectorize short memory ops into longer memory ops, we may want to // increase alignment. bool IdealLoopTree::policy_align( PhaseIdealLoop *phase ) const { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/loopUnswitch.cpp --- a/src/share/vm/opto/loopUnswitch.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/loopUnswitch.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -131,7 +131,7 @@ ProjNode* proj_false = invar_iff->proj_out(0)->as_Proj(); - // Hoist invariant casts out of each loop to the appropiate + // Hoist invariant casts out of each loop to the appropriate // control projection. Node_List worklist; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/loopnode.cpp --- a/src/share/vm/opto/loopnode.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/loopnode.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -274,7 +274,7 @@ // // Canonicalize the condition on the test. If we can exactly determine // the trip-counter exit value, then set limit to that value and use - // a '!=' test. Otherwise use conditon '<' for count-up loops and + // a '!=' test. Otherwise use condition '<' for count-up loops and // '>' for count-down loops. If the condition is inverted and we will // be rolling through MININT to MAXINT, then bail out. @@ -290,7 +290,7 @@ // If compare points to incr, we are ok. Otherwise the compare // can directly point to the phi; in this case adjust the compare so that - // it points to the incr by adusting the limit. + // it points to the incr by adjusting the limit. if( cmp->in(1) == phi || cmp->in(2) == phi ) limit = gvn->transform(new (C, 3) AddINode(limit,stride)); @@ -471,7 +471,7 @@ lazy_replace( x, l ); set_idom(l, init_control, dom_depth(x)); - // Check for immediately preceeding SafePoint and remove + // Check for immediately preceding SafePoint and remove Node *sfpt2 = le->in(0); if( sfpt2->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt2)) lazy_replace( sfpt2, sfpt2->in(TypeFunc::Control)); @@ -1506,7 +1506,7 @@ // Build Dominators for elision of NULL checks & loop finding. // Since nodes do not have a slot for immediate dominator, make - // a persistant side array for that info indexed on node->_idx. + // a persistent side array for that info indexed on node->_idx. _idom_size = C->unique(); _idom = NEW_RESOURCE_ARRAY( Node*, _idom_size ); _dom_depth = NEW_RESOURCE_ARRAY( uint, _idom_size ); @@ -1529,7 +1529,7 @@ // Given dominators, try to find inner loops with calls that must // always be executed (call dominates loop tail). These loops do - // not need a seperate safepoint. + // not need a separate safepoint. Node_List cisstack(a); _ltree_root->check_safepts(visited, cisstack); @@ -2332,7 +2332,7 @@ if (done) { // All of n's inputs have been processed, complete post-processing. - // Compute earilest point this Node can go. + // Compute earliest point this Node can go. // CFG, Phi, pinned nodes already know their controlling input. if (!has_node(n)) { // Record earliest legal location @@ -2672,9 +2672,9 @@ pinned = false; } if( pinned ) { - IdealLoopTree *choosen_loop = get_loop(n->is_CFG() ? n : get_ctrl(n)); - if( !choosen_loop->_child ) // Inner loop? - choosen_loop->_body.push(n); // Collect inner loops + IdealLoopTree *chosen_loop = get_loop(n->is_CFG() ? n : get_ctrl(n)); + if( !chosen_loop->_child ) // Inner loop? + chosen_loop->_body.push(n); // Collect inner loops return; } } else { // No slot zero @@ -2746,9 +2746,9 @@ set_ctrl(n, least); // Collect inner loop bodies - IdealLoopTree *choosen_loop = get_loop(least); - if( !choosen_loop->_child ) // Inner loop? - choosen_loop->_body.push(n);// Collect inner loops + IdealLoopTree *chosen_loop = get_loop(least); + if( !chosen_loop->_child ) // Inner loop? + chosen_loop->_body.push(n);// Collect inner loops } #ifndef PRODUCT diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/loopnode.hpp --- a/src/share/vm/opto/loopnode.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/loopnode.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -390,7 +390,7 @@ // Return TRUE or FALSE if the loop should be cache-line aligned. // Gather the expression that does the alignment. Note that only - // one array base can be aligned in a loop (unless the VM guarentees + // one array base can be aligned in a loop (unless the VM guarantees // mutual alignment). Note that if we vectorize short memory ops // into longer memory ops, we may want to increase alignment. bool policy_align( PhaseIdealLoop *phase ) const; @@ -403,7 +403,7 @@ // Reassociate invariant add and subtract expressions. Node* reassociate_add_sub(Node* n1, PhaseIdealLoop *phase); // Return nonzero index of invariant operand if invariant and variant - // are combined with an Add or Sub. Helper for reassoicate_invariants. + // are combined with an Add or Sub. Helper for reassociate_invariants. int is_invariant_addition(Node* n, PhaseIdealLoop *phase); // Return true if n is invariant diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/loopopts.cpp --- a/src/share/vm/opto/loopopts.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/loopopts.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -97,7 +97,7 @@ // (Note: This tweaking with igvn only works because x is a new node.) _igvn.set_type(x, t); // If x is a TypeNode, capture any more-precise type permanently into Node - // othewise it will be not updated during igvn->transform since + // otherwise it will be not updated during igvn->transform since // igvn->type(x) is set to x->Value() already. x->raise_bottom_type(t); Node *y = x->Identity(&_igvn); @@ -879,7 +879,7 @@ Node *x_ctrl = NULL; if( u->is_Phi() ) { // Replace all uses of normal nodes. Replace Phi uses - // individually, so the seperate Nodes can sink down + // individually, so the separate Nodes can sink down // different paths. uint k = 1; while( u->in(k) != n ) k++; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/machnode.cpp --- a/src/share/vm/opto/machnode.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/machnode.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -136,7 +136,7 @@ // Size of instruction in bytes uint MachNode::size(PhaseRegAlloc *ra_) const { // If a virtual was not defined for this specific instruction, - // Call the helper which finds the size by emiting the bits. + // Call the helper which finds the size by emitting the bits. return MachNode::emit_size(ra_); } diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/macro.cpp --- a/src/share/vm/opto/macro.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/macro.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -64,6 +64,7 @@ uint old_unique = C->unique(); Node* new_in = old_sosn->clone(jvms_adj, sosn_map); if (old_unique != C->unique()) { + new_in->set_req(0, newcall->in(0)); // reset control edge new_in = transform_later(new_in); // Register new node. } old_in = new_in; @@ -215,7 +216,7 @@ const TypeOopPtr *tinst = phase->C->get_adr_type(alias_idx)->isa_oopptr(); while (true) { if (mem == alloc_mem || mem == start_mem ) { - return mem; // hit one of our sentinals + return mem; // hit one of our sentinels } else if (mem->is_MergeMem()) { mem = mem->as_MergeMem()->memory_at(alias_idx); } else if (mem->is_Proj() && mem->as_Proj()->_con == TypeFunc::Memory) { @@ -1667,7 +1668,7 @@ if (UseOptoBiasInlining) { /* - * See the full descrition in MacroAssembler::biased_locking_enter(). + * See the full description in MacroAssembler::biased_locking_enter(). * * if( (mark_word & biased_lock_mask) == biased_lock_pattern ) { * // The object is biased. @@ -1903,7 +1904,7 @@ if (UseOptoBiasInlining) { // Check for biased locking unlock case, which is a no-op. - // See the full descrition in MacroAssembler::biased_locking_exit(). + // See the full description in MacroAssembler::biased_locking_exit(). region = new (C, 4) RegionNode(4); // create a Phi for the memory state mem_phi = new (C, 4) PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/matcher.cpp --- a/src/share/vm/opto/matcher.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/matcher.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -897,7 +897,7 @@ #ifdef ASSERT _new2old_map.map(m->_idx, n); #endif - mstack.push(m, Post_Visit, n, i); // Don't neet to visit + mstack.push(m, Post_Visit, n, i); // Don't need to visit mstack.push(m->in(0), Visit, m, 0); } else { mstack.push(m, Visit, n, i); @@ -1267,7 +1267,7 @@ } } - // Not forceably cloning. If shared, put it into a register. + // Not forceable cloning. If shared, put it into a register. return shared; } @@ -1542,7 +1542,7 @@ // This is what my child will give me. int opnd_class_instance = s->_rule[op]; // Choose between operand class or not. - // This is what I will recieve. + // This is what I will receive. int catch_op = (FIRST_OPERAND_CLASS <= op && op < NUM_OPERANDS) ? opnd_class_instance : op; // New rule for child. Chase operand classes to get the actual rule. int newrule = s->_rule[catch_op]; @@ -1966,7 +1966,7 @@ // BoolNode::match_edge always returns a zero. // We reorder the Op_If in a pre-order manner, so we can visit without - // accidently sharing the Cmp (the Bool and the If make 2 users). + // accidentally sharing the Cmp (the Bool and the If make 2 users). n->add_req( n->in(1)->in(1) ); // Add the Cmp next to the Bool } else if (nstate == Post_Visit) { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/memnode.cpp --- a/src/share/vm/opto/memnode.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/memnode.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -100,12 +100,12 @@ while (prev != result) { prev = result; if (result == start_mem) - break; // hit one of our sentinals + break; // hit one of our sentinels // skip over a call which does not affect this memory slice if (result->is_Proj() && result->as_Proj()->_con == TypeFunc::Memory) { Node *proj_in = result->in(0); if (proj_in->is_Allocate() && proj_in->_idx == instance_id) { - break; // hit one of our sentinals + break; // hit one of our sentinels } else if (proj_in->is_Call()) { CallNode *call = proj_in->as_Call(); if (!call->may_modify(t_adr, phase)) { @@ -198,7 +198,7 @@ // If not, we can update the input infinitely along a MergeMem cycle // Equivalent code in PhiNode::Ideal Node* m = phase->transform(mmem); - // If tranformed to a MergeMem, get the desired slice + // If transformed to a MergeMem, get the desired slice // Otherwise the returned node represents memory for every slice mem = (m->is_MergeMem())? m->as_MergeMem()->memory_at(alias_idx) : m; // Update input if it is progress over what we have now @@ -970,7 +970,7 @@ } // Search for an existing data phi which was generated before for the same - // instance's field to avoid infinite genertion of phis in a loop. + // instance's field to avoid infinite generation of phis in a loop. Node *region = mem->in(0); if (is_instance_field_load_with_local_phi(region)) { const TypePtr *addr_t = in(MemNode::Address)->bottom_type()->isa_ptr(); @@ -1254,7 +1254,7 @@ // (This tweaking with igvn only works because x is a new node.) igvn->set_type(x, t); // If x is a TypeNode, capture any more-precise type permanently into Node - // othewise it will be not updated during igvn->transform since + // otherwise it will be not updated during igvn->transform since // igvn->type(x) is set to x->Value() already. x->raise_bottom_type(t); Node *y = x->Identity(igvn); @@ -2591,7 +2591,7 @@ // capturing of nearby memory operations. // // During macro-expansion, all captured initializations which store -// constant values of 32 bits or smaller are coalesced (if advantagous) +// constant values of 32 bits or smaller are coalesced (if advantageous) // into larger 'tiles' 32 or 64 bits. This allows an object to be // initialized in fewer memory operations. Memory words which are // covered by neither tiles nor non-constant stores are pre-zeroed @@ -3678,7 +3678,7 @@ else if (old_mmem != NULL) { new_mem = old_mmem->memory_at(i); } - // else preceeding memory was not a MergeMem + // else preceding memory was not a MergeMem // replace equivalent phis (unfortunately, they do not GVN together) if (new_mem != NULL && new_mem != new_base && diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/memnode.hpp --- a/src/share/vm/opto/memnode.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/memnode.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -757,10 +757,10 @@ // Model. Monitor-enter and volatile-load act as Aquires: no following ref // can be moved to before them. We insert a MemBar-Acquire after a FastLock or // volatile-load. Monitor-exit and volatile-store act as Release: no -// preceeding ref can be moved to after them. We insert a MemBar-Release +// preceding ref can be moved to after them. We insert a MemBar-Release // before a FastUnlock or volatile-store. All volatiles need to be // serialized, so we follow all volatile-stores with a MemBar-Volatile to -// seperate it from any following volatile-load. +// separate it from any following volatile-load. class MemBarNode: public MultiNode { virtual uint hash() const ; // { return NO_HASH; } virtual uint cmp( const Node &n ) const ; // Always fail, except on self diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/node.cpp --- a/src/share/vm/opto/node.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/node.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -968,22 +968,23 @@ // Example: when reshape "(X+3)+4" into "X+7" you must leave the Node for // "X+3" unchanged in case it is shared. // -// If you modify the 'this' pointer's inputs, you must use 'set_req' with -// def-use info. If you are making a new Node (either as the new root or -// some new internal piece) you must NOT use set_req with def-use info. -// You can make a new Node with either 'new' or 'clone'. In either case, -// def-use info is (correctly) not generated. +// If you modify the 'this' pointer's inputs, you should use +// 'set_req'. If you are making a new Node (either as the new root or +// some new internal piece) you may use 'init_req' to set the initial +// value. You can make a new Node with either 'new' or 'clone'. In +// either case, def-use info is correctly maintained. +// // Example: reshape "(X+3)+4" into "X+7": -// set_req(1,in(1)->in(1) /* grab X */, du /* must use DU on 'this' */); -// set_req(2,phase->intcon(7),du); +// set_req(1, in(1)->in(1)); +// set_req(2, phase->intcon(7)); // return this; -// Example: reshape "X*4" into "X<<1" -// return new (C,3) LShiftINode( in(1), phase->intcon(1) ); +// Example: reshape "X*4" into "X<<2" +// return new (C,3) LShiftINode(in(1), phase->intcon(2)); // // You must call 'phase->transform(X)' on any new Nodes X you make, except -// for the returned root node. Example: reshape "X*31" with "(X<<5)-1". +// for the returned root node. Example: reshape "X*31" with "(X<<5)-X". // Node *shift=phase->transform(new(C,3)LShiftINode(in(1),phase->intcon(5))); -// return new (C,3) AddINode(shift, phase->intcon(-1)); +// return new (C,3) AddINode(shift, in(1)); // // When making a Node for a constant use 'phase->makecon' or 'phase->intcon'. // These forms are faster than 'phase->transform(new (C,1) ConNode())' and Do @@ -1679,7 +1680,7 @@ if (visited.member(this)) return; visited.push(this); - // Walk over all input edges, checking for correspondance + // Walk over all input edges, checking for correspondence for( i = 0; i < len(); i++ ) { n = in(i); if (n != NULL && !n->is_top()) { @@ -1723,7 +1724,7 @@ // Contained in new_space or old_space? VectorSet *v = C->node_arena()->contains(n) ? &new_space : &old_space; // Check for visited in the proper space. Numberings are not unique - // across spaces so we need a seperate VectorSet for each space. + // across spaces so we need a separate VectorSet for each space. if( v->test_set(n->_idx) ) return; if (n->is_Con() && n->bottom_type() == Type::TOP) { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/node.hpp --- a/src/share/vm/opto/node.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/node.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -257,7 +257,7 @@ Node **_in; // Array of use-def references to Nodes Node **_out; // Array of def-use references to Nodes - // Input edges are split into two catagories. Required edges are required + // Input edges are split into two categories. Required edges are required // for semantic correctness; order is important and NULLs are allowed. // Precedence edges are used to help determine execution order and are // added, e.g., for scheduling purposes. They are unordered and not @@ -854,7 +854,7 @@ // If the hash function returns the special sentinel value NO_HASH, // the node is guaranteed never to compare equal to any other node. - // If we accidently generate a hash with value NO_HASH the node + // If we accidentally generate a hash with value NO_HASH the node // won't go into the table and we'll lose a little optimization. enum { NO_HASH = 0 }; virtual uint hash() const; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/output.cpp --- a/src/share/vm/opto/output.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/output.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1171,7 +1171,7 @@ cb->flush_bundle(false); // The following logic is duplicated in the code ifdeffed for - // ENABLE_ZAP_DEAD_LOCALS which apppears above in this file. It + // ENABLE_ZAP_DEAD_LOCALS which appears above in this file. It // should be factored out. Or maybe dispersed to the nodes? // Special handling for SafePoint/Call Nodes @@ -1275,7 +1275,7 @@ } #ifdef ASSERT - // Check that oop-store preceeds the card-mark + // Check that oop-store precedes the card-mark else if( mach->ideal_Opcode() == Op_StoreCM ) { uint storeCM_idx = j; Node *oop_store = mach->in(mach->_cnt); // First precedence edge @@ -1291,7 +1291,7 @@ #endif else if( !n->is_Proj() ) { - // Remember the begining of the previous instruction, in case + // Remember the beginning of the previous instruction, in case // it's followed by a flag-kill and a null-check. Happens on // Intel all the time, with add-to-memory kind of opcodes. previous_offset = current_offset; @@ -1567,7 +1567,7 @@ compile.set_node_bundling_limit(_node_bundling_limit); - // This one is persistant within the Compile class + // This one is persistent within the Compile class _node_bundling_base = NEW_ARENA_ARRAY(compile.comp_arena(), Bundle, node_max); // Allocate space for fixed-size arrays @@ -1666,7 +1666,7 @@ // Compute the latency of all the instructions. This is fairly simple, // because we already have a legal ordering. Walk over the instructions // from first to last, and compute the latency of the instruction based -// on the latency of the preceeding instruction(s). +// on the latency of the preceding instruction(s). void Scheduling::ComputeLocalLatenciesForward(const Block *bb) { #ifndef PRODUCT if (_cfg->C->trace_opto_output()) @@ -1931,7 +1931,7 @@ uint siz = _available.size(); // Conditional branches can support an instruction that - // is unconditionally executed and not dependant by the + // is unconditionally executed and not dependent by the // branch, OR a conditionally executed instruction if // the branch is taken. In practice, this means that // the first instruction at the branch target is @@ -1947,7 +1947,7 @@ #endif // At least 1 instruction is on the available list - // that is not dependant on the branch + // that is not dependent on the branch for (uint i = 0; i < siz; i++) { Node *d = _available[i]; const Pipeline *avail_pipeline = d->pipeline(); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/parse.hpp --- a/src/share/vm/opto/parse.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/parse.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -78,7 +78,7 @@ }; // See if it is OK to inline. - // The reciever is the inline tree for the caller. + // The receiver is the inline tree for the caller. // // The result is a temperature indication. If it is hot or cold, // inlining is immediate or undesirable. Otherwise, the info block diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/parse1.cpp --- a/src/share/vm/opto/parse1.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/parse1.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -607,7 +607,7 @@ if (control()->is_Region() && !block->is_loop_head() && !has_irreducible && !block->is_handler()) { // In the absence of irreducible loops, the Region and Phis // associated with a merge that doesn't involve a backedge can - // be simplfied now since the RPO parsing order guarantees + // be simplified now since the RPO parsing order guarantees // that any path which was supposed to reach here has already // been parsed or must be dead. Node* c = control(); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/parse2.cpp --- a/src/share/vm/opto/parse2.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/parse2.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -32,7 +32,7 @@ void Parse::array_load(BasicType elem_type) { const Type* elem = Type::TOP; Node* adr = array_addressing(elem_type, 0, &elem); - if (stopped()) return; // guarenteed null or range check + if (stopped()) return; // guaranteed null or range check _sp -= 2; // Pop array and index const TypeAryPtr* adr_type = TypeAryPtr::get_array_body_type(elem_type); Node* ld = make_load(control(), adr, elem, elem_type, adr_type); @@ -43,7 +43,7 @@ //--------------------------------array_store---------------------------------- void Parse::array_store(BasicType elem_type) { Node* adr = array_addressing(elem_type, 1); - if (stopped()) return; // guarenteed null or range check + if (stopped()) return; // guaranteed null or range check Node* val = pop(); _sp -= 2; // Pop array and index const TypeAryPtr* adr_type = TypeAryPtr::get_array_body_type(elem_type); @@ -1541,14 +1541,14 @@ case Bytecodes::_aaload: array_load(T_OBJECT); break; case Bytecodes::_laload: { a = array_addressing(T_LONG, 0); - if (stopped()) return; // guarenteed null or range check + if (stopped()) return; // guaranteed null or range check _sp -= 2; // Pop array and index push_pair( make_load(control(), a, TypeLong::LONG, T_LONG, TypeAryPtr::LONGS)); break; } case Bytecodes::_daload: { a = array_addressing(T_DOUBLE, 0); - if (stopped()) return; // guarenteed null or range check + if (stopped()) return; // guaranteed null or range check _sp -= 2; // Pop array and index push_pair( make_load(control(), a, Type::DOUBLE, T_DOUBLE, TypeAryPtr::DOUBLES)); break; @@ -1560,7 +1560,7 @@ case Bytecodes::_fastore: array_store(T_FLOAT); break; case Bytecodes::_aastore: { d = array_addressing(T_OBJECT, 1); - if (stopped()) return; // guarenteed null or range check + if (stopped()) return; // guaranteed null or range check array_store_check(); c = pop(); // Oop to store b = pop(); // index (already used) @@ -1572,7 +1572,7 @@ } case Bytecodes::_lastore: { a = array_addressing(T_LONG, 2); - if (stopped()) return; // guarenteed null or range check + if (stopped()) return; // guaranteed null or range check c = pop_pair(); _sp -= 2; // Pop array and index store_to_memory(control(), a, c, T_LONG, TypeAryPtr::LONGS); @@ -1580,7 +1580,7 @@ } case Bytecodes::_dastore: { a = array_addressing(T_DOUBLE, 2); - if (stopped()) return; // guarenteed null or range check + if (stopped()) return; // guaranteed null or range check c = pop_pair(); _sp -= 2; // Pop array and index c = dstore_rounding(c); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/phase.cpp --- a/src/share/vm/opto/phase.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/phase.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -73,7 +73,7 @@ //------------------------------Phase------------------------------------------ Phase::Phase( PhaseNumber pnum ) : _pnum(pnum), C( pnum == Compiler ? NULL : Compile::current()) { - // Poll for requests from shutdown mechanism to quiesce comiler (4448539, 4448544). + // Poll for requests from shutdown mechanism to quiesce compiler (4448539, 4448544). // This is an effective place to poll, since the compiler is full of phases. // In particular, every inlining site uses a recursively created Parse phase. CompileBroker::maybe_block(); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/phaseX.cpp --- a/src/share/vm/opto/phaseX.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/phaseX.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -196,7 +196,7 @@ } //------------------------------hash_delete------------------------------------ -// Replace in hash table with sentinal +// Replace in hash table with sentinel bool NodeHash::hash_delete( const Node *n ) { Node *k; uint hash = n->hash(); @@ -207,7 +207,7 @@ uint key = hash & (_max-1); uint stride = key | 0x01; debug_only( uint counter = 0; ); - for( ; /* (k != NULL) && (k != _sentinal) */; ) { + for( ; /* (k != NULL) && (k != _sentinel) */; ) { debug_only( counter++ ); debug_only( _delete_probes++ ); k = _table[key]; // Get hashed value @@ -715,7 +715,7 @@ #ifdef ASSERT //------------------------------dead_loop_check-------------------------------- -// Check for a simple dead loop when a data node references itself direcly +// Check for a simple dead loop when a data node references itself directly // or through an other data node excluding cons and phis. void PhaseGVN::dead_loop_check( Node *n ) { // Phi may reference itself in a loop @@ -1359,7 +1359,7 @@ worklist.push(p); // Propagate change to user } } - // If we changed the reciever type to a call, we need to revisit + // If we changed the receiver type to a call, we need to revisit // the Catch following the call. It's looking for a non-NULL // receiver to know when to enable the regular fall-through path // in addition to the NullPtrException path diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/postaloc.cpp --- a/src/share/vm/opto/postaloc.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/postaloc.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -46,7 +46,7 @@ // be splitting live ranges for callee save registers to such // an extent that in large methods the chains can be very long // (50+). The conservative answer is to return true if we don't - // know as this prevents optimizations from occuring. + // know as this prevents optimizations from occurring. const int limit = 60; int i; @@ -286,7 +286,7 @@ // // n will be replaced with the old value but n might have // kills projections associated with it so remove them now so that - // yank_if_dead will be able to elminate the copy once the uses + // yank_if_dead will be able to eliminate the copy once the uses // have been transferred to the old[value]. for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) { Node* use = n->fast_out(i); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/reg_split.cpp --- a/src/share/vm/opto/reg_split.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/reg_split.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -26,8 +26,8 @@ #include "incls/_reg_split.cpp.incl" //------------------------------Split-------------------------------------- -// Walk the graph in RPO and for each lrg which spills, propogate reaching -// definitions. During propogation, split the live range around regions of +// Walk the graph in RPO and for each lrg which spills, propagate reaching +// definitions. During propagation, split the live range around regions of // High Register Pressure (HRP). If a Def is in a region of Low Register // Pressure (LRP), it will not get spilled until we encounter a region of // HRP between it and one of its uses. We will spill at the transition @@ -88,7 +88,7 @@ } //------------------------------insert_proj------------------------------------ -// Insert the spill at chosen location. Skip over any interveneing Proj's or +// Insert the spill at chosen location. Skip over any intervening Proj's or // Phis. Skip over a CatchNode and projs, inserting in the fall-through block // instead. Update high-pressure indices. Create a new live range. void PhaseChaitin::insert_proj( Block *b, uint i, Node *spill, uint maxlrg ) { @@ -125,7 +125,7 @@ } //------------------------------split_DEF-------------------------------------- -// There are four catagories of Split; UP/DOWN x DEF/USE +// There are four categories of Split; UP/DOWN x DEF/USE // Only three of these really occur as DOWN/USE will always color // Any Split with a DEF cannot CISC-Spill now. Thus we need // two helper routines, one for Split DEFS (insert after instruction), @@ -726,7 +726,7 @@ // ********** Handle Crossing HRP Boundry ********** if( (insidx == b->_ihrp_index) || (insidx == b->_fhrp_index) ) { for( slidx = 0; slidx < spill_cnt; slidx++ ) { - // Check for need to split at HRP boundry - split if UP + // Check for need to split at HRP boundary - split if UP n1 = Reachblock[slidx]; // bail out if no reaching DEF if( n1 == NULL ) continue; diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/runtime.cpp --- a/src/share/vm/opto/runtime.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/runtime.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1196,7 +1196,7 @@ // The following does not work because for one thing, the // thread state is wrong; it expects java, but it is native. -// Also, the invarients in a native stub are different and +// Also, the invariants in a native stub are different and // I'm not sure it is safe to have a MachCalRuntimeDirectNode // in there. // So for now, we do not zap in native stubs. diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/split_if.cpp --- a/src/share/vm/opto/split_if.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/split_if.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -318,7 +318,7 @@ if( use->is_Phi() ) { // Phi uses in prior block // Grab the first Phi use; there may be many. - // Each will be handled as a seperate iteration of + // Each will be handled as a separate iteration of // the "while( phi->outcnt() )" loop. uint j; for( j = 1; j < use->req(); j++ ) diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/superword.cpp --- a/src/share/vm/opto/superword.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/superword.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -470,7 +470,7 @@ } //------------------------------stmts_can_pack--------------------------- -// Can s1 and s2 be in a pack with s1 immediately preceeding s2 and +// Can s1 and s2 be in a pack with s1 immediately preceding s2 and // s1 aligned at "align" bool SuperWord::stmts_can_pack(Node* s1, Node* s2, int align) { if (isomorphic(s1, s2)) { @@ -869,7 +869,7 @@ for (uint i = start; i < end; i++) { if (!is_vector_use(p0, i)) { // For now, return false if not scalar promotion case (inputs are the same.) - // Later, implement PackNode and allow differring, non-vector inputs + // Later, implement PackNode and allow differing, non-vector inputs // (maybe just the ones from outside the block.) Node* p0_def = p0->in(i); for (uint j = 1; j < p->size(); j++) { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/superword.hpp --- a/src/share/vm/opto/superword.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/superword.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -308,7 +308,7 @@ void dependence_graph(); // Return a memory slice (node list) in predecessor order starting at "start" void mem_slice_preds(Node* start, Node* stop, GrowableArray &preds); - // Can s1 and s2 be in a pack with s1 immediately preceeding s2 and s1 aligned at "align" + // Can s1 and s2 be in a pack with s1 immediately preceding s2 and s1 aligned at "align" bool stmts_can_pack(Node* s1, Node* s2, int align); // Does s exist in a pack at position pos? bool exists_at(Node* s, uint pos); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/opto/type.cpp --- a/src/share/vm/opto/type.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/opto/type.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -2455,7 +2455,7 @@ // code and dereferenced at the time the nmethod is made. Until that time, // it is not reasonable to do arithmetic with the addresses of oops (we don't // have access to the addresses!). This does not seem to currently happen, - // but this assertion here is to help prevent its occurrance. + // but this assertion here is to help prevent its occurence. tty->print_cr("Found oop constant with non-zero offset"); ShouldNotReachHere(); } @@ -2761,7 +2761,7 @@ // LCA is object_klass, but if we subclass from the top we can do better if( above_centerline(_ptr) ) { // if( _ptr == TopPTR || _ptr == AnyNull ) // If 'this' (InstPtr) is above the centerline and it is Object class - // then we can subclass in the Java class heirarchy. + // then we can subclass in the Java class hierarchy. if (klass()->equals(ciEnv::current()->Object_klass())) { // that is, tp's array type is a subtype of my klass return TypeAryPtr::make(ptr, tp->ary(), tp->klass(), tp->klass_is_exact(), offset, instance_id); @@ -3022,7 +3022,7 @@ //------------------------------xdual------------------------------------------ // Dual: do NOT dual on klasses. This means I do NOT understand the Java -// inheritence mechanism. +// inheritance mechanism. const Type *TypeInstPtr::xdual() const { return new TypeInstPtr( dual_ptr(), klass(), klass_is_exact(), const_oop(), dual_offset(), dual_instance_id() ); } @@ -3176,7 +3176,7 @@ bool chg = false; if (lo < min_lo) { lo = min_lo; chg = true; } if (hi > max_hi) { hi = max_hi; chg = true; } - // Negative length arrays will produce weird intermediate dead fath-path code + // Negative length arrays will produce weird intermediate dead fast-path code if (lo > hi) return TypeInt::ZERO; if (!chg) @@ -3358,7 +3358,7 @@ // LCA is object_klass, but if we subclass from the top we can do better if (above_centerline(tp->ptr())) { // If 'tp' is above the centerline and it is Object class - // then we can subclass in the Java class heirarchy. + // then we can subclass in the Java class hierarchy. if( tp->klass()->equals(ciEnv::current()->Object_klass()) ) { // that is, my array type is a subtype of 'tp' klass return make( ptr, _ary, _klass, _klass_is_exact, offset, instance_id ); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/prims/jvmtiRedefineClasses.cpp --- a/src/share/vm/prims/jvmtiRedefineClasses.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/prims/jvmtiRedefineClasses.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1352,39 +1352,39 @@ // rewrite constant pool references in the methods: if (!rewrite_cp_refs_in_methods(scratch_class, THREAD)) { - // propogate failure back to caller + // propagate failure back to caller return false; } // rewrite constant pool references in the class_annotations: if (!rewrite_cp_refs_in_class_annotations(scratch_class, THREAD)) { - // propogate failure back to caller + // propagate failure back to caller return false; } // rewrite constant pool references in the fields_annotations: if (!rewrite_cp_refs_in_fields_annotations(scratch_class, THREAD)) { - // propogate failure back to caller + // propagate failure back to caller return false; } // rewrite constant pool references in the methods_annotations: if (!rewrite_cp_refs_in_methods_annotations(scratch_class, THREAD)) { - // propogate failure back to caller + // propagate failure back to caller return false; } // rewrite constant pool references in the methods_parameter_annotations: if (!rewrite_cp_refs_in_methods_parameter_annotations(scratch_class, THREAD)) { - // propogate failure back to caller + // propagate failure back to caller return false; } // rewrite constant pool references in the methods_default_annotations: if (!rewrite_cp_refs_in_methods_default_annotations(scratch_class, THREAD)) { - // propogate failure back to caller + // propagate failure back to caller return false; } @@ -1603,7 +1603,7 @@ byte_i_ref, THREAD)) { RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("bad annotation_struct at %d", calc_num_annotations)); - // propogate failure back to caller + // propagate failure back to caller return false; } } @@ -1669,7 +1669,7 @@ byte_i_ref, THREAD)) { RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("bad element_value at %d", calc_num_element_value_pairs)); - // propogate failure back to caller + // propagate failure back to caller return false; } } // end for each component @@ -1818,7 +1818,7 @@ // field. This is a nested annotation. if (!rewrite_cp_refs_in_annotation_struct(annotations_typeArray, byte_i_ref, THREAD)) { - // propogate failure back to caller + // propagate failure back to caller return false; } break; @@ -1845,7 +1845,7 @@ annotations_typeArray, byte_i_ref, THREAD)) { RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("bad nested element_value at %d", calc_num_values)); - // propogate failure back to caller + // propagate failure back to caller return false; } } @@ -1889,7 +1889,7 @@ THREAD)) { RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("bad field_annotations at %d", i)); - // propogate failure back to caller + // propagate failure back to caller return false; } } @@ -1926,7 +1926,7 @@ THREAD)) { RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("bad method_annotations at %d", i)); - // propogate failure back to caller + // propagate failure back to caller return false; } } @@ -1994,7 +1994,7 @@ method_parameter_annotations, byte_i, THREAD)) { RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("bad method_parameter_annotations at %d", calc_num_parameters)); - // propogate failure back to caller + // propagate failure back to caller return false; } } @@ -2044,7 +2044,7 @@ method_default_annotations, byte_i, THREAD)) { RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("bad default element_value at %d", i)); - // propogate failure back to caller + // propagate failure back to caller return false; } } diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/runtime/extendedPC.hpp --- a/src/share/vm/runtime/extendedPC.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/runtime/extendedPC.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -23,7 +23,7 @@ */ // An ExtendedPC contains the _pc from a signal handler in a platform -// independant way. +// independent way. class ExtendedPC VALUE_OBJ_CLASS_SPEC { private: diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/runtime/fprofiler.cpp --- a/src/share/vm/runtime/fprofiler.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/runtime/fprofiler.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -988,7 +988,7 @@ void ThreadProfiler::record_tick_for_running_frame(JavaThread* thread, frame fr) { - // The tick happend in real code -> non VM code + // The tick happened in real code -> non VM code if (fr.is_interpreted_frame()) { interval_data_ref()->inc_interpreted(); record_interpreted_tick(thread, fr, tp_code, FlatProfiler::bytecode_ticks); @@ -1019,7 +1019,7 @@ } void ThreadProfiler::record_tick_for_calling_frame(JavaThread* thread, frame fr) { - // The tick happend in VM code + // The tick happened in VM code interval_data_ref()->inc_native(); if (fr.is_interpreted_frame()) { record_interpreted_tick(thread, fr, tp_native, FlatProfiler::bytecode_ticks_stub); diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/runtime/frame.cpp --- a/src/share/vm/runtime/frame.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/runtime/frame.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -930,7 +930,7 @@ // => process callee's arguments // // Note: The expression stack can be empty if an exception - // occured during method resolution/execution. In all + // occurred during method resolution/execution. In all // cases we empty the expression stack completely be- // fore handling the exception (the exception handling // code in the interpreter calls a blocking runtime diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/runtime/frame.inline.hpp --- a/src/share/vm/runtime/frame.inline.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/runtime/frame.inline.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -22,7 +22,7 @@ * */ -// This file holds platform-independant bodies of inline functions for frames. +// This file holds platform-independent bodies of inline functions for frames. // Note: The bcx usually contains the bcp; however during GC it contains the bci // (changed by gc_prologue() and gc_epilogue()) to be methodOop position diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/runtime/mutex.hpp --- a/src/share/vm/runtime/mutex.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/runtime/mutex.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -82,7 +82,7 @@ // *in that order*. If their implementations change such that these // assumptions are violated, a whole lot of code will break. -// The default length of monitor name is choosen to be 64 to avoid false sharing. +// The default length of monitor name is chosen to be 64 to avoid false sharing. static const int MONITOR_NAME_LEN = 64; class Monitor : public CHeapObj { diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/runtime/orderAccess.hpp --- a/src/share/vm/runtime/orderAccess.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/runtime/orderAccess.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -31,7 +31,7 @@ // at runtime. // // In the following, the terms 'previous', 'subsequent', 'before', -// 'after', 'preceeding' and 'succeeding' refer to program order. The +// 'after', 'preceding' and 'succeeding' refer to program order. The // terms 'down' and 'below' refer to forward load or store motion // relative to program order, while 'up' and 'above' refer to backward // motion. diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/runtime/os.cpp --- a/src/share/vm/runtime/os.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/runtime/os.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -943,7 +943,7 @@ assert(StackRedPages > 0 && StackYellowPages > 0,"Sanity check"); address sp = current_stack_pointer(); // Check if we have StackShadowPages above the yellow zone. This parameter - // is dependant on the depth of the maximum VM call stack possible from + // is dependent on the depth of the maximum VM call stack possible from // the handler for stack overflow. 'instanceof' in the stack overflow // handler or a println uses at least 8k stack of VM and native code // respectively. diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/runtime/safepoint.cpp --- a/src/share/vm/runtime/safepoint.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/runtime/safepoint.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -369,7 +369,7 @@ // Start suspended threads for(JavaThread *current = Threads::first(); current; current = current->next()) { - // A problem occuring on Solaris is when attempting to restart threads + // A problem occurring on Solaris is when attempting to restart threads // the first #cpus - 1 go well, but then the VMThread is preempted when we get // to the next one (since it has been running the longest). We then have // to wait for a cpu to become available before we can continue restarting diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/runtime/signature.hpp --- a/src/share/vm/runtime/signature.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/runtime/signature.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -266,7 +266,7 @@ class NativeSignatureIterator: public SignatureIterator { private: methodHandle _method; -// We need seperate JNI and Java offset values because in 64 bit mode, +// We need separate JNI and Java offset values because in 64 bit mode, // the argument offsets are not in sync with the Java stack. // For example a long takes up 1 "C" stack entry but 2 Java stack entries. int _offset; // The java stack offset diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/runtime/threadCritical.hpp --- a/src/share/vm/runtime/threadCritical.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/runtime/threadCritical.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -29,7 +29,7 @@ // // Due to race conditions during vm exit, some of the os level // synchronization primitives may not be deallocated at exit. It -// is a good plan to implement the platform dependant sections of +// is a good plan to implement the platform dependent sections of // code with resources that are recoverable during process // cleanup by the os. Calling the initialize method before use // is also problematic, it is best to use preinitialized primitives diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/utilities/globalDefinitions.hpp --- a/src/share/vm/utilities/globalDefinitions.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/utilities/globalDefinitions.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -881,7 +881,7 @@ i++; p *= 2; } // p = 2^(i+1) && x < p (i.e., 2^i <= x < 2^(i+1)) - // (if p = 0 then overflow occured and i = 31) + // (if p = 0 then overflow occurred and i = 31) return i; } @@ -895,7 +895,7 @@ i++; p *= 2; } // p = 2^(i+1) && x < p (i.e., 2^i <= x < 2^(i+1)) - // (if p = 0 then overflow occured and i = 63) + // (if p = 0 then overflow occurred and i = 63) return i; } diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/utilities/vmError.cpp --- a/src/share/vm/utilities/vmError.cpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/utilities/vmError.cpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 2003-2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 2003-2009 Sun Microsystems, Inc. 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 @@ -306,7 +306,7 @@ strncpy(buf, file, buflen); if (len + 10 < buflen) { - sprintf(buf + len, ":" SIZE_FORMAT, _lineno); + sprintf(buf + len, ":%d", _lineno); } st->print(" (%s)", buf); } else { @@ -420,7 +420,7 @@ if (fr.sp()) { st->print(", sp=" PTR_FORMAT, fr.sp()); - st->print(", free space=%dk", + st->print(", free space=%" INTPTR_FORMAT "k", ((intptr_t)fr.sp() - (intptr_t)stack_bottom) >> 10); } diff -r 5caef2219893 -r 3db67f76d308 src/share/vm/utilities/vmError.hpp --- a/src/share/vm/utilities/vmError.hpp Mon Mar 02 16:56:51 2009 -0700 +++ b/src/share/vm/utilities/vmError.hpp Thu Mar 05 22:07:29 2009 -0500 @@ -1,5 +1,5 @@ /* - * Copyright 2003-2007 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 2003-2009 Sun Microsystems, Inc. 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 @@ -50,7 +50,7 @@ // additional info for VM internal errors const char * _filename; - size_t _lineno; + int _lineno; // used by fatal error handler int _current_step;