truffle: src/share/vm/opto/library

comparison src/share/vm/opto/library_call.cpp @ 605:98cb887364d3

6810672: Comment typos Summary: I have collected some typos I have found while looking at the code. Reviewed-by: kvn, never

author	twisti
date	Fri, 27 Feb 2009 13:27:09 -0800
parents	a1980da045cc
children	c771b7f43bbf

comparison

equal deleted inserted replaced

-:ec59443af135
+:98cb887364d3
 _sp += 2;
 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;
 }
 const TypeOopPtr* str_type = _gvn.type(argument)->isa_oopptr();
 if (str_type == NULL) {
 //   }
 // } else {
 //   result = DPow(x,y);
 // }
 // if (result != result)?  {
-//   ucommon_trap();
+//   uncommon_trap();
 // }
 // return result;
 _sp += arg_size();        // restore stack pointer
 Node* y = pop_math_arg();
 // Check (double)((int) y) : y
 Node *cmpinty= _gvn.transform(new (C, 3) CmpDNode(doubleinty, y));
 // 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
 // Calculate DPow(abs(x), y)*(1 & (int)y)
 // Node for constant 1
 return basic_plus_adr(base, offset);
 }
 }
 //----------------------------inline_reverseBytes_int/long-------------------
-// inline Int.reverseBytes(int)
+// inline Integer.reverseBytes(int)
-// inline Long.reverseByes(long)
+// 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;
 if (id == vmIntrinsics::_reverseBytes_l && !Matcher::has_match_rule(Op_ReverseBytesL)) return false;
 _sp += arg_size();        // restore stack pointer
 if (is_volatile) {
 // We need to emit leading and trailing CPU membars (see below) in
 // 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.
 if (is_store)
 insert_mem_bar(Op_MemBarRelease);
 // This basic scheme here is the same as inline_unsafe_access, but
 // differs in enough details that combining them would make the code
 // 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!
 #ifndef PRODUCT
 {
 Compile::AliasType* alias_type = C->alias_type(adr_type);
 assert(alias_type->index() != Compile::AliasIdxBot, "no bare pointers here");
 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.
 insert_mem_bar(Op_MemBarRelease);
 insert_mem_bar(Op_MemBarCPUOrder);
 // vm: see markOop.hpp.
 Node *hash_mask      = _gvn.intcon(markOopDesc::hash_mask);
 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);
 Node *hash_val       = _gvn.transform( new (C, 3) AndINode(hshifted_header, hash_mask) );
 return true;
 }
 //---------------------------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;
 push( load_mirror_from_klass(load_object_klass(obj)) );
 return true;
 original_dest->set_req(0, control());
 _gvn.hash_find_insert(original_dest);  // put back into GVN table
 }
 // 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.
 //
 // But with low number of register or when some registers are used or killed
 // by arraycopy calls it causes registers spilling on stack. See 6544710.

Mercurial > hg > truffle

comparison src/share/vm/opto/library_call.cpp @ 605:98cb887364d3