diff options
| author | twisti <none@none> | 2009-02-27 13:27:09 -0800 |
|---|---|---|
| committer | twisti <none@none> | 2009-02-27 13:27:09 -0800 |
| commit | 7391ddb49d5cccafae11c106a35716cfad3cab6b (patch) | |
| tree | 3e151c366d950a8573d5e7e906dfe28d3c373ba4 | |
| parent | 2e0e422376085c72a7ec1bdb09d486dd1a4f8fee (diff) | |
6810672: Comment typos
Summary: I have collected some typos I have found while looking at the code.
Reviewed-by: kvn, never
120 files changed, 278 insertions, 277 deletions
diff --git a/src/cpu/sparc/vm/interp_masm_sparc.cpp b/src/cpu/sparc/vm/interp_masm_sparc.cpp index f134852e4..d1ac3e5b3 100644 --- a/src/cpu/sparc/vm/interp_masm_sparc.cpp +++ b/src/cpu/sparc/vm/interp_masm_sparc.cpp @@ -2465,7 +2465,7 @@ void InterpreterMacroAssembler::verify_FPU(int stack_depth, TosState state) { // InterpreterRuntime::post_method_entry(); // } // if (DTraceMethodProbes) { -// SharedRuntime::dtrace_method_entry(method, reciever); +// SharedRuntime::dtrace_method_entry(method, receiver); // } void InterpreterMacroAssembler::notify_method_entry() { diff --git a/src/cpu/sparc/vm/nativeInst_sparc.hpp b/src/cpu/sparc/vm/nativeInst_sparc.hpp index 2527e35b3..81bdca4cd 100644 --- a/src/cpu/sparc/vm/nativeInst_sparc.hpp +++ b/src/cpu/sparc/vm/nativeInst_sparc.hpp @@ -243,7 +243,7 @@ class NativeInstruction VALUE_OBJ_CLASS_SPEC { // 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 --git a/src/cpu/sparc/vm/sparc.ad b/src/cpu/sparc/vm/sparc.ad index b4a94ac24..0095f652c 100644 --- a/src/cpu/sparc/vm/sparc.ad +++ b/src/cpu/sparc/vm/sparc.ad @@ -189,7 +189,7 @@ reg_def R_F31( SOC, SOC, Op_RegF, 31, F31->as_VMReg()); // 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 @@ extern bool can_branch_register( Node *bol, Node *cmp ); // 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 @@ uint MachSpillCopyNode::implementation( CodeBuffer *cbuf, #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 @@ void MachUEPNode::emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const { 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 cmpOp_commute() %{ //----------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 @@ instruct mul_hi(iRegIsafe dst, iRegIsafe src1, iRegIsafe src2 ) %{ 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 @@ instruct loadConI_x66666667(iRegIsafe dst) %{ 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 @@ instruct storeL_reversed(memory dst, iRegL src) %{ // 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 --git a/src/cpu/sparc/vm/templateTable_sparc.cpp b/src/cpu/sparc/vm/templateTable_sparc.cpp index 6ba85859c..a4c1fa892 100644 --- a/src/cpu/sparc/vm/templateTable_sparc.cpp +++ b/src/cpu/sparc/vm/templateTable_sparc.cpp @@ -1545,7 +1545,7 @@ void TemplateTable::branch(bool is_jsr, bool is_wide) { // 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 @@ void TemplateTable::invokeinterface(int byte_no) { 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 --git a/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp b/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp index 26acffbb3..5b46c4a88 100644 --- a/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp +++ b/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp @@ -501,7 +501,7 @@ void LIRGenerator::do_ArithmeticOp_Long(ArithmeticOp* x) { 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 --git a/src/cpu/x86/vm/cppInterpreter_x86.cpp b/src/cpu/x86/vm/cppInterpreter_x86.cpp index a3621ad88..377d0f261 100644 --- a/src/cpu/x86/vm/cppInterpreter_x86.cpp +++ b/src/cpu/x86/vm/cppInterpreter_x86.cpp @@ -523,7 +523,7 @@ void CppInterpreterGenerator::generate_compute_interpreter_state(const Register #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 @@ address InterpreterGenerator::generate_native_entry(bool synchronized) { #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 @@ address InterpreterGenerator::generate_native_entry(bool synchronized) { #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 --git a/src/cpu/x86/vm/sharedRuntime_x86_64.cpp b/src/cpu/x86/vm/sharedRuntime_x86_64.cpp index 7fc2b6685..2fbcb7010 100644 --- a/src/cpu/x86/vm/sharedRuntime_x86_64.cpp +++ b/src/cpu/x86/vm/sharedRuntime_x86_64.cpp @@ -1350,7 +1350,7 @@ nmethod *SharedRuntime::generate_native_wrapper(MacroAssembler *masm, { 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 --git a/src/cpu/x86/vm/templateInterpreter_x86_64.cpp b/src/cpu/x86/vm/templateInterpreter_x86_64.cpp index 9caf33f6b..b237b7b5f 100644 --- a/src/cpu/x86/vm/templateInterpreter_x86_64.cpp +++ b/src/cpu/x86/vm/templateInterpreter_x86_64.cpp @@ -826,7 +826,7 @@ address InterpreterGenerator::generate_native_entry(bool synchronized) { __ 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 --git a/src/cpu/x86/vm/templateTable_x86_32.cpp b/src/cpu/x86/vm/templateTable_x86_32.cpp index 13242651c..6acbc8e28 100644 --- a/src/cpu/x86/vm/templateTable_x86_32.cpp +++ b/src/cpu/x86/vm/templateTable_x86_32.cpp @@ -1586,7 +1586,7 @@ void TemplateTable::branch(bool is_jsr, bool is_wide) { // 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 --git a/src/cpu/x86/vm/templateTable_x86_64.cpp b/src/cpu/x86/vm/templateTable_x86_64.cpp index e4b4cb969..50c23fd45 100644 --- a/src/cpu/x86/vm/templateTable_x86_64.cpp +++ b/src/cpu/x86/vm/templateTable_x86_64.cpp @@ -1559,7 +1559,7 @@ void TemplateTable::branch(bool is_jsr, bool is_wide) { // 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 --git a/src/cpu/x86/vm/x86_32.ad b/src/cpu/x86/vm/x86_32.ad index edc6a63e7..43daf35fc 100644 --- a/src/cpu/x86/vm/x86_32.ad +++ b/src/cpu/x86/vm/x86_32.ad @@ -130,7 +130,7 @@ reg_def XMM7b( SOC, SOC, Op_RegF, 7, xmm7->as_VMReg()->next()); // 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 cmpOp_commute() %{ //----------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 @@ instruct safePoint_poll(eFlagsReg cr) %{ // 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 --git a/src/cpu/x86/vm/x86_64.ad b/src/cpu/x86/vm/x86_64.ad index ad4f03b23..09157f3a3 100644 --- a/src/cpu/x86/vm/x86_64.ad +++ b/src/cpu/x86/vm/x86_64.ad @@ -5483,7 +5483,7 @@ operand cmpOpUCF2() %{ //----------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 @@ instruct divModL_rReg_divmod(rax_RegL rax, rdx_RegL rdx, no_rax_rdx_RegL div, //----------- 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 @@ instruct RethrowException() // 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 --git a/src/os/linux/launcher/java.c b/src/os/linux/launcher/java.c index a13782ec4..e33577632 100644 --- a/src/os/linux/launcher/java.c +++ b/src/os/linux/launcher/java.c @@ -419,7 +419,7 @@ main(int argc, char ** argv) 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 @@ main(int argc, char ** argv) 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 --git a/src/os/linux/launcher/java_md.h b/src/os/linux/launcher/java_md.h index 89e4d0b7a..601662175 100644 --- a/src/os/linux/launcher/java_md.h +++ b/src/os/linux/launcher/java_md.h @@ -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 --git a/src/os/linux/vm/perfMemory_linux.cpp b/src/os/linux/vm/perfMemory_linux.cpp index c56798c01..381650562 100644 --- a/src/os/linux/vm/perfMemory_linux.cpp +++ b/src/os/linux/vm/perfMemory_linux.cpp @@ -192,7 +192,7 @@ static pid_t filename_to_pid(const char* filename) { // 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 --git a/src/os/solaris/launcher/java.c b/src/os/solaris/launcher/java.c index e4fc014de..866be7c65 100644 --- a/src/os/solaris/launcher/java.c +++ b/src/os/solaris/launcher/java.c @@ -419,7 +419,7 @@ main(int argc, char ** argv) 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 @@ main(int argc, char ** argv) 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 --git a/src/os/solaris/launcher/java_md.h b/src/os/solaris/launcher/java_md.h index c65b42e2a..5122de9fc 100644 --- a/src/os/solaris/launcher/java_md.h +++ b/src/os/solaris/launcher/java_md.h @@ -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 --git a/src/os/solaris/vm/perfMemory_solaris.cpp b/src/os/solaris/vm/perfMemory_solaris.cpp index 4626d7299..459ef573a 100644 --- a/src/os/solaris/vm/perfMemory_solaris.cpp +++ b/src/os/solaris/vm/perfMemory_solaris.cpp @@ -194,7 +194,7 @@ static pid_t filename_to_pid(const char* filename) { // 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 --git a/src/os/windows/vm/perfMemory_windows.cpp b/src/os/windows/vm/perfMemory_windows.cpp index 42a45ee65..95063df2e 100644 --- a/src/os/windows/vm/perfMemory_windows.cpp +++ b/src/os/windows/vm/perfMemory_windows.cpp @@ -195,7 +195,7 @@ static int filename_to_pid(const char* filename) { // 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 @@ static bool add_allow_aces(PSECURITY_DESCRIPTOR pSD, 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 @@ static bool add_allow_aces(PSECURITY_DESCRIPTOR pSD, "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 --git a/src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp b/src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp index 012c170a9..802934511 100644 --- a/src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp +++ b/src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp @@ -532,7 +532,7 @@ int JVM_handle_solaris_signal(int sig, siginfo_t* info, void* ucVoid, int abort_ 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 --git a/src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp b/src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp index 71f99cba0..e6b1edca5 100644 --- a/src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp +++ b/src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp @@ -694,7 +694,7 @@ int JVM_handle_solaris_signal(int sig, siginfo_t* info, void* ucVoid, int abort_ 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 --git a/src/share/tools/MakeDeps/Database.java b/src/share/tools/MakeDeps/Database.java index 5cec93b7d..3cdffebca 100644 --- a/src/share/tools/MakeDeps/Database.java +++ b/src/share/tools/MakeDeps/Database.java @@ -365,7 +365,7 @@ public class Database { // HACK ALERT. The compilation of ad_<arch> 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_<arch> will be compiled early. boolean shouldSortObjFiles = true; diff --git a/src/share/vm/adlc/Doc/Syntax.doc b/src/share/vm/adlc/Doc/Syntax.doc index ade893410..c2a24afc3 100644 --- a/src/share/vm/adlc/Doc/Syntax.doc +++ b/src/share/vm/adlc/Doc/Syntax.doc @@ -88,7 +88,7 @@ reg_class X_REG(AX, BX); // form a matcher register class of X_REG // 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 @@ D. Delimiters 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 --git a/src/share/vm/adlc/adlparse.cpp b/src/share/vm/adlc/adlparse.cpp index f212d3f57..61ba5e248 100644 --- a/src/share/vm/adlc/adlparse.cpp +++ b/src/share/vm/adlc/adlparse.cpp @@ -4555,7 +4555,7 @@ void ADLParser::parse_err(int flag, const char *fmt, ...) { //---------------------------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 --git a/src/share/vm/adlc/dict2.cpp b/src/share/vm/adlc/dict2.cpp index f46693fd0..d1816423d 100644 --- a/src/share/vm/adlc/dict2.cpp +++ b/src/share/vm/adlc/dict2.cpp @@ -275,7 +275,7 @@ void Dict::print(PrintKeyOrValue print_key, PrintKeyOrValue print_value) { // 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 @@ int hashstr(const void *t) { } //------------------------------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 @@ int hashptr(const void *key) { #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 --git a/src/share/vm/adlc/dict2.hpp b/src/share/vm/adlc/dict2.hpp index 41a1b19d1..14c75e5df 100644 --- a/src/share/vm/adlc/dict2.hpp +++ b/src/share/vm/adlc/dict2.hpp @@ -89,10 +89,10 @@ class Dict { // Dictionary structure // 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 --git a/src/share/vm/adlc/filebuff.cpp b/src/share/vm/adlc/filebuff.cpp index 36e611e15..d5dfd2186 100644 --- a/src/share/vm/adlc/filebuff.cpp +++ b/src/share/vm/adlc/filebuff.cpp @@ -50,10 +50,10 @@ FileBuff::FileBuff( BufferedFile *fptr, ArchDesc& archDesc) : _fp(fptr), _AD(arc 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 @@ -62,8 +62,8 @@ FileBuff::FileBuff( BufferedFile *fptr, ArchDesc& archDesc) : _fp(fptr), _AD(arc 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-------------------------------------- @@ -81,7 +81,7 @@ char *FileBuff::get_line(void) { _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 diff --git a/src/share/vm/adlc/filebuff.hpp b/src/share/vm/adlc/filebuff.hpp index e5e8cccbe..6967d64a3 100644 --- a/src/share/vm/adlc/filebuff.hpp +++ b/src/share/vm/adlc/filebuff.hpp @@ -37,7 +37,7 @@ class ArchDesc; //------------------------------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: @@ -46,8 +46,8 @@ class FileBuff { 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 diff --git a/src/share/vm/adlc/formssel.cpp b/src/share/vm/adlc/formssel.cpp index cf48d2650..d203e2d7f 100644 --- a/src/share/vm/adlc/formssel.cpp +++ b/src/share/vm/adlc/formssel.cpp @@ -1281,7 +1281,7 @@ void InstructForm::set_unique_opnds() { _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(); @@ -2197,7 +2197,7 @@ int OperandForm::operand_position(const char *name, int usedef) { // 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' + // Iterate through components and count constants preceding 'constant' int position = 0; Component *comp; _components.reset(); @@ -2235,7 +2235,7 @@ int OperandForm::constant_position(FormDict &globals, const char *name) { // 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(); diff --git a/src/share/vm/adlc/formssel.hpp b/src/share/vm/adlc/formssel.hpp index 84c49be69..2a7bfbb79 100644 --- a/src/share/vm/adlc/formssel.hpp +++ b/src/share/vm/adlc/formssel.hpp @@ -277,7 +277,7 @@ public: // // 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 = ""); // --------------------------- @@ -344,7 +344,7 @@ public: // --------------------------- 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); diff --git a/src/share/vm/adlc/output_h.cpp b/src/share/vm/adlc/output_h.cpp index 764dcd03d..4668d68f9 100644 --- a/src/share/vm/adlc/output_h.cpp +++ b/src/share/vm/adlc/output_h.cpp @@ -574,7 +574,7 @@ void gen_inst_format(FILE *fp, FormDict &globals, InstructForm &inst, bool for_c // 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); diff --git a/src/share/vm/asm/assembler.cpp b/src/share/vm/asm/assembler.cpp index e9d99621b..0afc39604 100644 --- a/src/share/vm/asm/assembler.cpp +++ b/src/share/vm/asm/assembler.cpp @@ -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 --git a/src/share/vm/asm/assembler.hpp b/src/share/vm/asm/assembler.hpp index 7af6e5dff..b8a29cead 100644 --- a/src/share/vm/asm/assembler.hpp +++ b/src/share/vm/asm/assembler.hpp @@ -22,7 +22,7 @@ * */ -// This file contains platform-independant assembler declarations. +// This file contains platform-independent assembler declarations. class CodeBuffer; class MacroAssembler; diff --git a/src/share/vm/ci/ciTypeFlow.cpp b/src/share/vm/ci/ciTypeFlow.cpp index 083962350..51f49132b 100644 --- a/src/share/vm/ci/ciTypeFlow.cpp +++ b/src/share/vm/ci/ciTypeFlow.cpp @@ -541,7 +541,7 @@ void ciTypeFlow::StateVector::do_aaload(ciBytecodeStream* str) { // 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 --git a/src/share/vm/classfile/symbolTable.cpp b/src/share/vm/classfile/symbolTable.cpp index 0c2d6bbb3..b77db6bd9 100644 --- a/src/share/vm/classfile/symbolTable.cpp +++ b/src/share/vm/classfile/symbolTable.cpp @@ -156,7 +156,7 @@ symbolOop SymbolTable::basic_add(int index, u1 *name, int len, 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 @@ bool SymbolTable::basic_add(constantPoolHandle cp, int names_count, 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 --git a/src/share/vm/code/nmethod.cpp b/src/share/vm/code/nmethod.cpp index 6baa28690..ff5985f1e 100644 --- a/src/share/vm/code/nmethod.cpp +++ b/src/share/vm/code/nmethod.cpp @@ -380,7 +380,7 @@ address nmethod::handler_for_exception_and_pc(Handle exception, address pc) { 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 --git a/src/share/vm/code/nmethod.hpp b/src/share/vm/code/nmethod.hpp index d2c4af895..8305f7949 100644 --- a/src/share/vm/code/nmethod.hpp +++ b/src/share/vm/code/nmethod.hpp @@ -167,7 +167,7 @@ class nmethod : public CodeBlob { 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 --git a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp index 3a07470e3..b21dab7ff 100644 --- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp @@ -393,7 +393,7 @@ class CMSAdaptiveSizePolicy : public AdaptiveSizePolicy { // 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 --git a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp index 333218245..f90540020 100644 --- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp @@ -69,7 +69,7 @@ class CMSGCAdaptivePolicyCounters : public GCAdaptivePolicyCounters { // 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 --git a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp index d716797ba..11480430f 100644 --- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @@ -4178,7 +4178,7 @@ bool CMSCollector::do_marking_mt(bool asynch) { // 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 @@ bool CMSCollector::do_marking_st(bool asynch) { // 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 --git a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp index 1c6766b99..38e49da93 100644 --- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @@ -2513,7 +2513,7 @@ G1CollectedHeap::do_collection_pause_at_safepoint(HeapRegion* popular_region) { } 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 --git a/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp b/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp index cd260de6c..8bf1a3e69 100644 --- a/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp +++ b/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp @@ -78,7 +78,7 @@ class CheckForUnmarkedObjects : public ObjectClosure { } // 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 @@ void CardTableExtension::scavenge_contents_parallel(ObjectStartArray* start_arra 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 --git a/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.hpp b/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.hpp index d587d0ae2..f44bcbbb0 100644 --- a/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.hpp +++ b/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.hpp @@ -127,7 +127,7 @@ class ObjectStartArray : public CHeapObj { // 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 --git a/src/share/vm/gc_implementation/parallelScavenge/prefetchQueue.hpp b/src/share/vm/gc_implementation/parallelScavenge/prefetchQueue.hpp index 5266d6731..7c6f86d3f 100644 --- a/src/share/vm/gc_implementation/parallelScavenge/prefetchQueue.hpp +++ b/src/share/vm/gc_implementation/parallelScavenge/prefetchQueue.hpp @@ -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 --git a/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp b/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp index a3787c8cd..e710fd779 100644 --- a/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp +++ b/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp @@ -74,7 +74,7 @@ void MutableNUMASpace::ensure_parsability() { 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 --git a/src/share/vm/interpreter/abstractInterpreter.hpp b/src/share/vm/interpreter/abstractInterpreter.hpp index 76fbb53b8..581ddfb16 100644 --- a/src/share/vm/interpreter/abstractInterpreter.hpp +++ b/src/share/vm/interpreter/abstractInterpreter.hpp @@ -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 --git a/src/share/vm/interpreter/bytecodeInterpreter.cpp b/src/share/vm/interpreter/bytecodeInterpreter.cpp index 351d29cc9..c9343622b 100644 --- a/src/share/vm/interpreter/bytecodeInterpreter.cpp +++ b/src/share/vm/interpreter/bytecodeInterpreter.cpp @@ -2642,7 +2642,7 @@ handle_return: // 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 --git a/src/share/vm/interpreter/bytecodeInterpreter.inline.hpp b/src/share/vm/interpreter/bytecodeInterpreter.inline.hpp index b765dcebe..a40991d09 100644 --- a/src/share/vm/interpreter/bytecodeInterpreter.inline.hpp +++ b/src/share/vm/interpreter/bytecodeInterpreter.inline.hpp @@ -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 --git a/src/share/vm/interpreter/cppInterpreter.hpp b/src/share/vm/interpreter/cppInterpreter.hpp index 9e4b87fba..bb61d4009 100644 --- a/src/share/vm/interpreter/cppInterpreter.hpp +++ b/src/share/vm/interpreter/cppInterpreter.hpp @@ -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 --git a/src/share/vm/interpreter/cppInterpreterGenerator.hpp b/src/share/vm/interpreter/cppInterpreterGenerator.hpp index 3ce3ce156..b077f4224 100644 --- a/src/share/vm/interpreter/cppInterpreterGenerator.hpp +++ b/src/share/vm/interpreter/cppInterpreterGenerator.hpp @@ -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 --git a/src/share/vm/interpreter/interpreter.hpp b/src/share/vm/interpreter/interpreter.hpp index eb316c5bc..767b748da 100644 --- a/src/share/vm/interpreter/interpreter.hpp +++ b/src/share/vm/interpreter/interpreter.hpp @@ -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 --git a/src/share/vm/interpreter/interpreterGenerator.hpp b/src/share/vm/interpreter/interpreterGenerator.hpp index 791b4777a..cf6089c3b 100644 --- a/src/share/vm/interpreter/interpreterGenerator.hpp +++ b/src/share/vm/interpreter/interpreterGenerator.hpp @@ -22,7 +22,7 @@ * */ -// This file contains the platform-independant parts +// This file contains the platform-independent parts // of the interpreter generator. diff --git a/src/share/vm/interpreter/templateInterpreter.hpp b/src/share/vm/interpreter/templateInterpreter.hpp index f6c89f9bd..e64423516 100644 --- a/src/share/vm/interpreter/templateInterpreter.hpp +++ b/src/share/vm/interpreter/templateInterpreter.hpp @@ -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 --git a/src/share/vm/interpreter/templateInterpreterGenerator.hpp b/src/share/vm/interpreter/templateInterpreterGenerator.hpp index 452e1c534..52425a045 100644 --- a/src/share/vm/interpreter/templateInterpreterGenerator.hpp +++ b/src/share/vm/interpreter/templateInterpreterGenerator.hpp @@ -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 --git a/src/share/vm/libadt/dict.cpp b/src/share/vm/libadt/dict.cpp index 003dd6a4f..5620f15c5 100644 --- a/src/share/vm/libadt/dict.cpp +++ b/src/share/vm/libadt/dict.cpp @@ -306,7 +306,7 @@ void Dict::print() { // 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 @@ int hashstr(const void *t) { } //------------------------------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 @@ int hashptr(const void *key) { #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 --git a/src/share/vm/libadt/dict.hpp b/src/share/vm/libadt/dict.hpp index 93f86829e..a3553ed87 100644 --- a/src/share/vm/libadt/dict.hpp +++ b/src/share/vm/libadt/dict.hpp @@ -86,10 +86,10 @@ class Dict : public ResourceObj { // Dictionary structure // 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 --git a/src/share/vm/memory/filemap.cpp b/src/share/vm/memory/filemap.cpp index b68f94c0a..2f317bf77 100644 --- a/src/share/vm/memory/filemap.cpp +++ b/src/share/vm/memory/filemap.cpp @@ -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 --git a/src/share/vm/memory/permGen.hpp b/src/share/vm/memory/permGen.hpp index 454b10f79..1b5782849 100644 --- a/src/share/vm/memory/permGen.hpp +++ b/src/share/vm/memory/permGen.hpp @@ -36,7 +36,7 @@ class PermGen : public CHeapObj { 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 --git a/src/share/vm/oops/generateOopMap.cpp b/src/share/vm/oops/generateOopMap.cpp index 4a9741c0f..5828a6d37 100644 --- a/src/share/vm/oops/generateOopMap.cpp +++ b/src/share/vm/oops/generateOopMap.cpp @@ -2003,7 +2003,7 @@ void GenerateOopMap::print_time() { // ============ 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 --git a/src/share/vm/oops/generateOopMap.hpp b/src/share/vm/oops/generateOopMap.hpp index 432902ef3..00057d574 100644 --- a/src/share/vm/oops/generateOopMap.hpp +++ b/src/share/vm/oops/generateOopMap.hpp @@ -292,7 +292,7 @@ class GenerateOopMap VALUE_OBJ_CLASS_SPEC { 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 @@ class GenerateOopMap VALUE_OBJ_CLASS_SPEC { 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 --git a/src/share/vm/oops/instanceKlass.cpp b/src/share/vm/oops/instanceKlass.cpp index 7a2d34087..12adb12ab 100644 --- a/src/share/vm/oops/instanceKlass.cpp +++ b/src/share/vm/oops/instanceKlass.cpp @@ -1917,7 +1917,7 @@ methodOop instanceKlass::method_at_itable(klassOop holder, int index, TRAPS) { / 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 --git a/src/share/vm/oops/klass.cpp b/src/share/vm/oops/klass.cpp index a028f65bb..63a342e5b 100644 --- a/src/share/vm/oops/klass.cpp +++ b/src/share/vm/oops/klass.cpp @@ -71,7 +71,7 @@ Klass *Klass::up_cast_abstract() { 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 --git a/src/share/vm/oops/klass.hpp b/src/share/vm/oops/klass.hpp index 881da970d..7fac52886 100644 --- a/src/share/vm/oops/klass.hpp +++ b/src/share/vm/oops/klass.hpp @@ -471,7 +471,7 @@ class Klass : public Klass_vtbl { } 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 --git a/src/share/vm/oops/methodOop.hpp b/src/share/vm/oops/methodOop.hpp index 8b03a6838..d266c9a33 100644 --- a/src/share/vm/oops/methodOop.hpp +++ b/src/share/vm/oops/methodOop.hpp @@ -296,7 +296,7 @@ class methodOopDesc : public oopDesc { 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 --git a/src/share/vm/opto/block.cpp b/src/share/vm/opto/block.cpp index 284000477..4749dc34d 100644 --- a/src/share/vm/opto/block.cpp +++ b/src/share/vm/opto/block.cpp @@ -181,7 +181,7 @@ int Block::is_Empty() const { } //------------------------------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 { @@ -1311,7 +1311,7 @@ void PhaseBlockLayout::merge_traces(bool fall_thru_only) } } 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); @@ -1434,7 +1434,7 @@ bool Trace::backedge(CFGEdge *e) { } // 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 --git a/src/share/vm/opto/block.hpp b/src/share/vm/opto/block.hpp index f678983dd..f4c46ba2a 100644 --- a/src/share/vm/opto/block.hpp +++ b/src/share/vm/opto/block.hpp @@ -609,7 +609,7 @@ class Trace : public ResourceObj { 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 --git a/src/share/vm/opto/buildOopMap.cpp b/src/share/vm/opto/buildOopMap.cpp index 30a9d2684..4a8612687 100644 --- a/src/share/vm/opto/buildOopMap.cpp +++ b/src/share/vm/opto/buildOopMap.cpp @@ -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 --git a/src/share/vm/opto/cfgnode.cpp b/src/share/vm/opto/cfgnode.cpp index e29cc0d58..139672ed7 100644 --- a/src/share/vm/opto/cfgnode.cpp +++ b/src/share/vm/opto/cfgnode.cpp @@ -1350,7 +1350,7 @@ static void split_once(PhaseIterGVN *igvn, Node *phi, Node *val, Node *n, Node * } // 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 @@ static Node* split_flow_path(PhaseGVN *phase, PhiNode *phi) { 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 @@ static Node* split_flow_path(PhaseGVN *phase, PhiNode *phi) { //============================================================================= //------------------------------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 @@ Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) { 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 @@ const Type *CatchNode::Value( PhaseTransform *phase ) const { 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 @@ Node *CatchProjNode::Identity( PhaseTransform *phase ) { // 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 --git a/src/share/vm/opto/chaitin.cpp b/src/share/vm/opto/chaitin.cpp index 82558d8f5..363db9117 100644 --- a/src/share/vm/opto/chaitin.cpp +++ b/src/share/vm/opto/chaitin.cpp @@ -1246,7 +1246,7 @@ uint PhaseChaitin::Select( ) { // 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 --git a/src/share/vm/opto/chaitin.hpp b/src/share/vm/opto/chaitin.hpp index 307d6110c..bbf828d59 100644 --- a/src/share/vm/opto/chaitin.hpp +++ b/src/share/vm/opto/chaitin.hpp @@ -327,7 +327,7 @@ class PhaseChaitin : public PhaseRegAlloc { // 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 @@ private: 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 --git a/src/share/vm/opto/coalesce.cpp b/src/share/vm/opto/coalesce.cpp index 7d9ab0083..52c009927 100644 --- a/src/share/vm/opto/coalesce.cpp +++ b/src/share/vm/opto/coalesce.cpp @@ -123,7 +123,7 @@ void PhaseChaitin::new_lrg( const Node *x, uint lrg ) { } //------------------------------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 @@ uint PhaseConservativeCoalesce::compute_separating_interferences(Node *dst_copy, } // 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 @@ bool PhaseConservativeCoalesce::copy_copy( Node *dst_copy, Node *src_copy, Block 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 --git a/src/share/vm/opto/compile.cpp b/src/share/vm/opto/compile.cpp index 7c6f751f8..5790af4c6 100644 --- a/src/share/vm/opto/compile.cpp +++ b/src/share/vm/opto/compile.cpp @@ -337,7 +337,7 @@ void Compile::print_compile_messages() { 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 @@ const TypePtr *Compile::flatten_alias_type( const TypePtr *tj ) const { 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 @@ static void final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &fpu ) { // [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 --git a/src/share/vm/opto/connode.cpp b/src/share/vm/opto/connode.cpp index 7e1cafefa..d46b6d4e9 100644 --- a/src/share/vm/opto/connode.cpp +++ b/src/share/vm/opto/connode.cpp @@ -71,7 +71,7 @@ testing. 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 --git a/src/share/vm/opto/divnode.cpp b/src/share/vm/opto/divnode.cpp index 67cad0679..55350e11f 100644 --- a/src/share/vm/opto/divnode.cpp +++ b/src/share/vm/opto/divnode.cpp @@ -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 @@ static Node *transform_int_divide( PhaseGVN *phase, Node *dividend, jint divisor // 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 @@ Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) { 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 --git a/src/share/vm/opto/domgraph.cpp b/src/share/vm/opto/domgraph.cpp index 2ef02fd0c..af198e3c7 100644 --- a/src/share/vm/opto/domgraph.cpp +++ b/src/share/vm/opto/domgraph.cpp @@ -183,7 +183,7 @@ class Block_Stack { 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 --git a/src/share/vm/opto/escape.cpp b/src/share/vm/opto/escape.cpp index 2606d0df8..c9ddc95dc 100644 --- a/src/share/vm/opto/escape.cpp +++ b/src/share/vm/opto/escape.cpp @@ -515,7 +515,7 @@ bool ConnectionGraph::split_AddP(Node *addp, Node *base, PhaseGVN *igvn) { // 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 @@ Node* ConnectionGraph::find_inst_mem(Node *orig_mem, int alias_idx, GrowableArra 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 @@ Node* ConnectionGraph::find_inst_mem(Node *orig_mem, int alias_idx, GrowableArra 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 @@ Node* ConnectionGraph::find_inst_mem(Node *orig_mem, int alias_idx, GrowableArra // 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 @@ bool ConnectionGraph::compute_escape() { 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 --git a/src/share/vm/opto/gcm.cpp b/src/share/vm/opto/gcm.cpp index 65c63339e..27ccc8126 100644 --- a/src/share/vm/opto/gcm.cpp +++ b/src/share/vm/opto/gcm.cpp @@ -606,7 +606,7 @@ Block* PhaseCFG::insert_anti_dependences(Block* LCA, Node* load, bool verify) { 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"); @@ -1399,7 +1399,7 @@ void PhaseCFG::Estimate_Block_Frequency() { #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 @@ -1652,7 +1652,7 @@ float Block::succ_prob(uint i) { // 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; @@ -1854,7 +1854,7 @@ void Block::update_uncommon_branch(Block* ub) { } //------------------------------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 --git a/src/share/vm/opto/graphKit.cpp b/src/share/vm/opto/graphKit.cpp index c0cb4ba01..e81e00753 100644 --- a/src/share/vm/opto/graphKit.cpp +++ b/src/share/vm/opto/graphKit.cpp @@ -1148,7 +1148,7 @@ Node* GraphKit::null_check_common(Node* value, BasicType type, 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 @@ Node* GraphKit::null_check_common(Node* value, BasicType type, // 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 --git a/src/share/vm/opto/ifg.cpp b/src/share/vm/opto/ifg.cpp index b3250513d..d5b7dc9b4 100644 --- a/src/share/vm/opto/ifg.cpp +++ b/src/share/vm/opto/ifg.cpp @@ -292,7 +292,7 @@ void PhaseIFG::verify( const PhaseChaitin *pc ) const { //------------------------------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 --git a/src/share/vm/opto/ifnode.cpp b/src/share/vm/opto/ifnode.cpp index 4f230765a..38fab34a5 100644 --- a/src/share/vm/opto/ifnode.cpp +++ b/src/share/vm/opto/ifnode.cpp @@ -81,7 +81,7 @@ static Node* split_if(IfNode *iff, PhaseIterGVN *igvn) { 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 @@ static Node* split_if(IfNode *iff, PhaseIterGVN *igvn) { // 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 @@ static Node* split_if(IfNode *iff, PhaseIterGVN *igvn) { } // 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 @@ const TypeInt* IfNode::filtered_int_type(PhaseGVN* gvn, Node *val, Node* if_proj //------------------------------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 @@ Node *IfNode::Ideal(PhaseGVN *phase, bool can_reshape) { // 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 --git a/src/share/vm/opto/library_call.cpp b/src/share/vm/opto/library_call.cpp index 17a5c1f79..6cbcee84b 100644 --- a/src/share/vm/opto/library_call.cpp +++ b/src/share/vm/opto/library_call.cpp @@ -992,7 +992,7 @@ bool LibraryCallKit::inline_string_indexOf() { 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 @@ bool LibraryCallKit::inline_pow(vmIntrinsics::ID id) { // result = DPow(x,y); // } // if (result != result)? { - // ucommon_trap(); + // uncommon_trap(); // } // return result; @@ -1324,7 +1324,7 @@ bool LibraryCallKit::inline_pow(vmIntrinsics::ID id) { // 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 Node* LibraryCallKit::make_unsafe_address(Node* base, Node* offset) { } //----------------------------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 @@ bool LibraryCallKit::inline_unsafe_access(bool is_native_ptr, bool is_store, Bas // 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 @@ bool LibraryCallKit::inline_unsafe_CAS(BasicType type) { // 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 @@ bool LibraryCallKit::inline_unsafe_CAS(BasicType type) { 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 @@ bool LibraryCallKit::inline_native_hashcode(bool is_virtual, bool is_static) { 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 @@ bool LibraryCallKit::inline_native_hashcode(bool is_virtual, bool is_static) { } //---------------------------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 @@ LibraryCallKit::generate_arraycopy(const TypePtr* adr_type, } // 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 --git a/src/share/vm/opto/live.cpp b/src/share/vm/opto/live.cpp index d2ff51505..e9aa3815c 100644 --- a/src/share/vm/opto/live.cpp +++ b/src/share/vm/opto/live.cpp @@ -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 --git a/src/share/vm/opto/locknode.cpp b/src/share/vm/opto/locknode.cpp index 0099284a7..f6a012221 100644 --- a/src/share/vm/opto/locknode.cpp +++ b/src/share/vm/opto/locknode.cpp @@ -121,7 +121,7 @@ void Parse::do_monitor_exit() { 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 --git a/src/share/vm/opto/loopTransform.cpp b/src/share/vm/opto/loopTransform.cpp index caa676f6f..4ff59d9d4 100644 --- a/src/share/vm/opto/loopTransform.cpp +++ b/src/share/vm/opto/loopTransform.cpp @@ -119,7 +119,7 @@ void IdealLoopTree::compute_profile_trip_cnt( PhaseIdealLoop *phase ) { //---------------------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 @@ bool IdealLoopTree::policy_unroll( PhaseIdealLoop *phase ) const { //------------------------------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 --git a/src/share/vm/opto/loopUnswitch.cpp b/src/share/vm/opto/loopUnswitch.cpp index 2a385e768..4bb67ad0f 100644 --- a/src/share/vm/opto/loopUnswitch.cpp +++ b/src/share/vm/opto/loopUnswitch.cpp @@ -131,7 +131,7 @@ void PhaseIdealLoop::do_unswitching (IdealLoopTree *loop, Node_List &old_new) { 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 --git a/src/share/vm/opto/loopnode.cpp b/src/share/vm/opto/loopnode.cpp index fba4a350b..7f939a197 100644 --- a/src/share/vm/opto/loopnode.cpp +++ b/src/share/vm/opto/loopnode.cpp @@ -274,7 +274,7 @@ Node *PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) { // // 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 @@ Node *PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) { // 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 @@ Node *PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) { 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 @@ PhaseIdealLoop::PhaseIdealLoop( PhaseIterGVN &igvn, const PhaseIdealLoop *verify // 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 @@ PhaseIdealLoop::PhaseIdealLoop( PhaseIterGVN &igvn, const PhaseIdealLoop *verify // 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 @@ void PhaseIdealLoop::build_loop_early( VectorSet &visited, Node_List &worklist, 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 @@ void PhaseIdealLoop::build_loop_late_post( Node *n, const PhaseIdealLoop *verify 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 @@ void PhaseIdealLoop::build_loop_late_post( Node *n, const PhaseIdealLoop *verify 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 --git a/src/share/vm/opto/loopnode.hpp b/src/share/vm/opto/loopnode.hpp index 537756466..ab172a3eb 100644 --- a/src/share/vm/opto/loopnode.hpp +++ b/src/share/vm/opto/loopnode.hpp @@ -390,7 +390,7 @@ public: // 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 @@ public: // 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 --git a/src/share/vm/opto/loopopts.cpp b/src/share/vm/opto/loopopts.cpp index 41048cbcb..454c207fd 100644 --- a/src/share/vm/opto/loopopts.cpp +++ b/src/share/vm/opto/loopopts.cpp @@ -97,7 +97,7 @@ Node *PhaseIdealLoop::split_thru_phi( Node *n, Node *region, int policy ) { // (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 @@ void PhaseIdealLoop::split_if_with_blocks_post( Node *n ) { 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 --git a/src/share/vm/opto/machnode.cpp b/src/share/vm/opto/machnode.cpp index eadd0da5f..adb7ecb98 100644 --- a/src/share/vm/opto/machnode.cpp +++ b/src/share/vm/opto/machnode.cpp @@ -136,7 +136,7 @@ void MachNode::emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const { // 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 --git a/src/share/vm/opto/macro.cpp b/src/share/vm/opto/macro.cpp index aa8bc4921..5b67f078c 100644 --- a/src/share/vm/opto/macro.cpp +++ b/src/share/vm/opto/macro.cpp @@ -216,7 +216,7 @@ static Node *scan_mem_chain(Node *mem, int alias_idx, int offset, Node *start_me 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) { @@ -1668,7 +1668,7 @@ void PhaseMacroExpand::expand_lock_node(LockNode *lock) { 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. @@ -1904,7 +1904,7 @@ void PhaseMacroExpand::expand_unlock_node(UnlockNode *unlock) { 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 --git a/src/share/vm/opto/matcher.cpp b/src/share/vm/opto/matcher.cpp index 9f424c0e4..74c7a7087 100644 --- a/src/share/vm/opto/matcher.cpp +++ b/src/share/vm/opto/matcher.cpp @@ -897,7 +897,7 @@ Node *Matcher::xform( Node *n, int max_stack ) { #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 @@ static bool match_into_reg( const Node *n, Node *m, Node *control, int i, bool s } } - // 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 @@ void Matcher::ReduceInst_Chain_Rule( State *s, int rule, Node *&mem, MachNode *m // 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 @@ void Matcher::find_shared( Node *n ) { // 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 --git a/src/share/vm/opto/memnode.cpp b/src/share/vm/opto/memnode.cpp index 95e41e0d5..3d096b248 100644 --- a/src/share/vm/opto/memnode.cpp +++ b/src/share/vm/opto/memnode.cpp @@ -100,12 +100,12 @@ Node *MemNode::optimize_simple_memory_chain(Node *mchain, const TypePtr *t_adr, 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 @@ static Node *step_through_mergemem(PhaseGVN *phase, MergeMemNode *mmem, const T // 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 @@ Node *LoadNode::Identity( PhaseTransform *phase ) { } // 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 @@ Node *LoadNode::split_through_phi(PhaseGVN *phase) { // (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 @@ Node *MemBarNode::match( const ProjNode *proj, const Matcher *m ) { // 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 @@ Node *MergeMemNode::Ideal(PhaseGVN *phase, bool can_reshape) { 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 --git a/src/share/vm/opto/memnode.hpp b/src/share/vm/opto/memnode.hpp index 63cb0d653..3da000dff 100644 --- a/src/share/vm/opto/memnode.hpp +++ b/src/share/vm/opto/memnode.hpp @@ -757,10 +757,10 @@ public: // 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 --git a/src/share/vm/opto/node.cpp b/src/share/vm/opto/node.cpp index 9130403ed..f7d71d172 100644 --- a/src/share/vm/opto/node.cpp +++ b/src/share/vm/opto/node.cpp @@ -968,22 +968,23 @@ const Type *Node::Value( PhaseTransform * ) const { // 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 @@ void Node::verify_edges(Unique_Node_List &visited) { 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 @@ void Node::verify_recur(const Node *n, int verify_depth, // 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 --git a/src/share/vm/opto/node.hpp b/src/share/vm/opto/node.hpp index f55a40309..bad160705 100644 --- a/src/share/vm/opto/node.hpp +++ b/src/share/vm/opto/node.hpp @@ -257,7 +257,7 @@ protected: 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 @@ public: // 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 --git a/src/share/vm/opto/output.cpp b/src/share/vm/opto/output.cpp index 7d6482ccd..c29274174 100644 --- a/src/share/vm/opto/output.cpp +++ b/src/share/vm/opto/output.cpp @@ -1171,7 +1171,7 @@ void Compile::Fill_buffer() { 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 @@ void Compile::Fill_buffer() { } #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 @@ void Compile::Fill_buffer() { #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 @@ Scheduling::Scheduling(Arena *arena, Compile &compile) 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 @@ void Compile::ScheduleAndBundle() { // 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 @@ void Scheduling::AddNodeToBundle(Node *n, const Block *bb) { 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 @@ void Scheduling::AddNodeToBundle(Node *n, const Block *bb) { #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 --git a/src/share/vm/opto/parse.hpp b/src/share/vm/opto/parse.hpp index d33acba3e..e00dfca6a 100644 --- a/src/share/vm/opto/parse.hpp +++ b/src/share/vm/opto/parse.hpp @@ -78,7 +78,7 @@ public: }; // 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 --git a/src/share/vm/opto/parse1.cpp b/src/share/vm/opto/parse1.cpp index b896faca4..12b75fb32 100644 --- a/src/share/vm/opto/parse1.cpp +++ b/src/share/vm/opto/parse1.cpp @@ -607,7 +607,7 @@ void Parse::do_all_blocks() { 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 --git a/src/share/vm/opto/parse2.cpp b/src/share/vm/opto/parse2.cpp index 0f40fdd96..201ffad99 100644 --- a/src/share/vm/opto/parse2.cpp +++ b/src/share/vm/opto/parse2.cpp @@ -32,7 +32,7 @@ extern int explicit_null_checks_inserted, 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 @@ void Parse::array_load(BasicType elem_type) { //--------------------------------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 @@ void Parse::do_one_bytecode() { 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 @@ void Parse::do_one_bytecode() { 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 @@ void Parse::do_one_bytecode() { } 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 @@ void Parse::do_one_bytecode() { } 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 --git a/src/share/vm/opto/phase.cpp b/src/share/vm/opto/phase.cpp index 904214a33..b0ea80a82 100644 --- a/src/share/vm/opto/phase.cpp +++ b/src/share/vm/opto/phase.cpp @@ -73,7 +73,7 @@ elapsedTimer Phase::_t_buildOopMaps; //------------------------------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 --git a/src/share/vm/opto/phaseX.cpp b/src/share/vm/opto/phaseX.cpp index 484629a90..78c484522 100644 --- a/src/share/vm/opto/phaseX.cpp +++ b/src/share/vm/opto/phaseX.cpp @@ -196,7 +196,7 @@ void NodeHash::hash_insert( Node *n ) { } //------------------------------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 @@ bool NodeHash::hash_delete( const Node *n ) { 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 @@ Node *PhaseGVN::transform_no_reclaim( Node *n ) { #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 @@ void PhaseCCP::analyze() { 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 --git a/src/share/vm/opto/postaloc.cpp b/src/share/vm/opto/postaloc.cpp index cd881065f..fa28c6aa1 100644 --- a/src/share/vm/opto/postaloc.cpp +++ b/src/share/vm/opto/postaloc.cpp @@ -46,7 +46,7 @@ bool PhaseChaitin::may_be_copy_of_callee( Node *def ) const { // 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 @@ bool PhaseChaitin::eliminate_copy_of_constant(Node* val, Node* n, // // 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 --git a/src/share/vm/opto/reg_split.cpp b/src/share/vm/opto/reg_split.cpp index 003df4c48..f3254dc2a 100644 --- a/src/share/vm/opto/reg_split.cpp +++ b/src/share/vm/opto/reg_split.cpp @@ -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 @@ Node *PhaseChaitin::get_spillcopy_wide( Node *def, Node *use, uint uidx ) { } //------------------------------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 @@ void PhaseChaitin::insert_proj( Block *b, uint i, Node *spill, uint maxlrg ) { } //------------------------------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 @@ uint PhaseChaitin::Split( uint maxlrg ) { // ********** 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 --git a/src/share/vm/opto/runtime.cpp b/src/share/vm/opto/runtime.cpp index 7b5effc81..cbbbfacfc 100644 --- a/src/share/vm/opto/runtime.cpp +++ b/src/share/vm/opto/runtime.cpp @@ -1196,7 +1196,7 @@ JRT_END // 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 --git a/src/share/vm/opto/split_if.cpp b/src/share/vm/opto/split_if.cpp index 130b26675..a7a6baaa9 100644 --- a/src/share/vm/opto/split_if.cpp +++ b/src/share/vm/opto/split_if.cpp @@ -318,7 +318,7 @@ Node *PhaseIdealLoop::find_use_block( Node *use, Node *def, Node *old_false, Nod 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 --git a/src/share/vm/opto/superword.cpp b/src/share/vm/opto/superword.cpp index 4551162bf..e0ca68f31 100644 --- a/src/share/vm/opto/superword.cpp +++ b/src/share/vm/opto/superword.cpp @@ -470,7 +470,7 @@ void SuperWord::mem_slice_preds(Node* start, Node* stop, GrowableArray<Node*> &p } //------------------------------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 @@ bool SuperWord::profitable(Node_List* p) { 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 --git a/src/share/vm/opto/superword.hpp b/src/share/vm/opto/superword.hpp index b60cc83c1..1c09607ed 100644 --- a/src/share/vm/opto/superword.hpp +++ b/src/share/vm/opto/superword.hpp @@ -308,7 +308,7 @@ class SuperWord : public ResourceObj { void dependence_graph(); // Return a memory slice (node list) in predecessor order starting at "start" void mem_slice_preds(Node* start, Node* stop, GrowableArray<Node*> &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 --git a/src/share/vm/opto/type.cpp b/src/share/vm/opto/type.cpp index 6830277ea..3f250be52 100644 --- a/src/share/vm/opto/type.cpp +++ b/src/share/vm/opto/type.cpp @@ -2455,7 +2455,7 @@ intptr_t TypeOopPtr::get_con() const { // 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 @@ const Type *TypeInstPtr::xmeet( const Type *t ) const { // 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 @@ ciType* TypeInstPtr::java_mirror_type() const { //------------------------------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 @@ const TypeInt* TypeAryPtr::narrow_size_type(const TypeInt* size) const { 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 @@ const Type *TypeAryPtr::xmeet( const Type *t ) const { // 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 --git a/src/share/vm/prims/jvmtiRedefineClasses.cpp b/src/share/vm/prims/jvmtiRedefineClasses.cpp index 4cc6b577b..154ab6507 100644 --- a/src/share/vm/prims/jvmtiRedefineClasses.cpp +++ b/src/share/vm/prims/jvmtiRedefineClasses.cpp @@ -1349,39 +1349,39 @@ bool VM_RedefineClasses::rewrite_cp_refs(instanceKlassHandle scratch_class, // 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; } @@ -1600,7 +1600,7 @@ bool VM_RedefineClasses::rewrite_cp_refs_in_annotations_typeArray( 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; } } @@ -1666,7 +1666,7 @@ bool VM_RedefineClasses::rewrite_cp_refs_in_annotation_struct( 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 @@ -1815,7 +1815,7 @@ bool VM_RedefineClasses::rewrite_cp_refs_in_element_value( // 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; @@ -1842,7 +1842,7 @@ bool VM_RedefineClasses::rewrite_cp_refs_in_element_value( 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; } } @@ -1886,7 +1886,7 @@ bool VM_RedefineClasses::rewrite_cp_refs_in_fields_annotations( 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; } } @@ -1923,7 +1923,7 @@ bool VM_RedefineClasses::rewrite_cp_refs_in_methods_annotations( 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; } } @@ -1991,7 +1991,7 @@ bool VM_RedefineClasses::rewrite_cp_refs_in_methods_parameter_annotations( 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; } } @@ -2041,7 +2041,7 @@ bool VM_RedefineClasses::rewrite_cp_refs_in_methods_default_annotations( 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 --git a/src/share/vm/runtime/extendedPC.hpp b/src/share/vm/runtime/extendedPC.hpp index a2680851a..19ce2a514 100644 --- a/src/share/vm/runtime/extendedPC.hpp +++ b/src/share/vm/runtime/extendedPC.hpp @@ -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 --git a/src/share/vm/runtime/fprofiler.cpp b/src/share/vm/runtime/fprofiler.cpp index adecc642d..87554e371 100644 --- a/src/share/vm/runtime/fprofiler.cpp +++ b/src/share/vm/runtime/fprofiler.cpp @@ -988,7 +988,7 @@ extern "C" void find(int x); 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_running_frame(JavaThread* thread, frame fr) } 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 --git a/src/share/vm/runtime/frame.cpp b/src/share/vm/runtime/frame.cpp index e84d6d3ad..8d53406e4 100644 --- a/src/share/vm/runtime/frame.cpp +++ b/src/share/vm/runtime/frame.cpp @@ -930,7 +930,7 @@ void frame::oops_interpreted_do(OopClosure* f, const RegisterMap* map, bool quer // => 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 --git a/src/share/vm/runtime/frame.inline.hpp b/src/share/vm/runtime/frame.inline.hpp index 3449ead76..95acb8dbb 100644 --- a/src/share/vm/runtime/frame.inline.hpp +++ b/src/share/vm/runtime/frame.inline.hpp @@ -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 --git a/src/share/vm/runtime/mutex.hpp b/src/share/vm/runtime/mutex.hpp index edebb8800..f0b9e8bd7 100644 --- a/src/share/vm/runtime/mutex.hpp +++ b/src/share/vm/runtime/mutex.hpp @@ -82,7 +82,7 @@ class ParkEvent ; // *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 --git a/src/share/vm/runtime/orderAccess.hpp b/src/share/vm/runtime/orderAccess.hpp index a2040ed84..c51a92297 100644 --- a/src/share/vm/runtime/orderAccess.hpp +++ b/src/share/vm/runtime/orderAccess.hpp @@ -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 --git a/src/share/vm/runtime/os.cpp b/src/share/vm/runtime/os.cpp index 8c81d4273..de8f12a2c 100644 --- a/src/share/vm/runtime/os.cpp +++ b/src/share/vm/runtime/os.cpp @@ -943,7 +943,7 @@ bool os::stack_shadow_pages_available(Thread *thread, methodHandle method) { 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 --git a/src/share/vm/runtime/safepoint.cpp b/src/share/vm/runtime/safepoint.cpp index c13af643a..32af64a23 100644 --- a/src/share/vm/runtime/safepoint.cpp +++ b/src/share/vm/runtime/safepoint.cpp @@ -369,7 +369,7 @@ void SafepointSynchronize::end() { // 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 --git a/src/share/vm/runtime/signature.hpp b/src/share/vm/runtime/signature.hpp index 51b45a0a0..9b506d329 100644 --- a/src/share/vm/runtime/signature.hpp +++ b/src/share/vm/runtime/signature.hpp @@ -266,7 +266,7 @@ class Fingerprinter: public SignatureIterator { 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 --git a/src/share/vm/runtime/threadCritical.hpp b/src/share/vm/runtime/threadCritical.hpp index 6f8529512..42b43379b 100644 --- a/src/share/vm/runtime/threadCritical.hpp +++ b/src/share/vm/runtime/threadCritical.hpp @@ -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 --git a/src/share/vm/utilities/globalDefinitions.hpp b/src/share/vm/utilities/globalDefinitions.hpp index 0a9b8f2a2..757910c17 100644 --- a/src/share/vm/utilities/globalDefinitions.hpp +++ b/src/share/vm/utilities/globalDefinitions.hpp @@ -881,7 +881,7 @@ inline int log2_intptr(intptr_t x) { 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 @@ inline int log2_long(jlong x) { 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; } |