8327963: C2: fix construction of memory graph around Initialize node to prevent incorrect execution if allocation is removed

src/hotspot/share/opto/graphKit.cpp

@@ -3642,9 +3642,9 @@ Node* GraphKit::set_output_for_allocation(AllocateNode* alloc,
     Node* minit_out = memory(rawidx);
     assert(minit_out->is_Proj() && minit_out->in(0) == init, "");
     int mark_idx = C->get_alias_index(oop_type->add_offset(oopDesc::mark_offset_in_bytes()));
-    // Add an edge in the MergeMem for the header fields so an access to one of those has correct memory state
+    // Add an edge in the MergeMem for the header fields so an access to one of those has correct memory state.
     // Use one NarrowMemProjNode per slice to properly record the adr type of each slice. The Initialize node will have
-    // multiple projection as a result.
+    // multiple projections as a result.
     set_memory(_gvn.transform(new NarrowMemProjNode(init, C->get_adr_type(mark_idx))), mark_idx);
     int klass_idx = C->get_alias_index(oop_type->add_offset(oopDesc::klass_offset_in_bytes()));
     set_memory(_gvn.transform(new NarrowMemProjNode(init, C->get_adr_type(klass_idx))), klass_idx);

src/hotspot/share/opto/macro.cpp

@@ -1620,12 +1620,12 @@ void PhaseMacroExpand::expand_initialize_membar(AllocateNode* alloc, InitializeN
 
       Node* init_ctrl = init->proj_out_or_null(TypeFunc::Control);
 
-      // What we want is to prevent the compiler and the cpu from re-ordering the stores that initialize this object
+      // What we want is to prevent the compiler and the CPU from re-ordering the stores that initialize this object
       // with subsequent stores to any slice. As a consequence, this MemBar should capture the entire memory state at
       // this point in the IR and produce a new memory state that should cover all slices. However, the Initialize node
       // only captures/produces a partial memory state making it complicated to insert such a MemBar. Because
       // re-ordering by the compiler can't happen by construction (a later Store that publishes the just allocated
-      // object reference is indirectly control dependent on the Initialize node), preventing reordering by the cpu is
+      // object reference is indirectly control dependent on the Initialize node), preventing reordering by the CPU is
       // sufficient. For that a MemBar on the raw memory slice is good enough.
       MemBarNode* mb = MemBarNode::make(C, Op_MemBarStoreStore, Compile::AliasIdxRaw);
       transform_later(mb);

src/hotspot/share/opto/multnode.hpp

@@ -68,7 +68,7 @@ class MultiNode : public Node {
       _i++;
     }
     Node* current() {
-      return _node->fast_out(_i);;
+      return _node->fast_out(_i);
     }
     UsesIteratorFast(DUIterator_Fast& imax, DUIterator_Fast& i, const Node* node)
       : _imax(imax), _i(i), _node(node) {
@@ -87,7 +87,7 @@ class MultiNode : public Node {
       _i++;
     }
     Node* current() {
-      return _node->out(_i);;
+      return _node->out(_i);
     }
     UsesIterator(DUIterator& i, const Node* node)
       : _i(i), _node(node) {

test/hotspot/jtreg/compiler/macronodes/TestEliminationOfAllocationWithoutUse.java

@@ -27,7 +27,7 @@
  * @summary Revealed issue where hook_memory_on_init links some array slice to the rawptr slice.
  *          Now that array slice depends on the rawslice. And then when the Initialize MemBar gets
  *          removed in expand_allocate_common, the rawslice sees that it has now no effect, looks
- *          through the MergeMem and sees the initial stae. That way, also the linked array slice
+ *          through the MergeMem and sees the initial state. That way, also the linked array slice
  *          goes to the initial state, even if before the allocation there were stores on the array
  *          slice. This leads to a messed up memory graph, and missing stores in the generated code.
  *