cleanup. remove dummy code. add test.

Author: Boris Ulasevich

src/hotspot/share/code/aotCodeCache.cpp

@@ -2038,7 +2038,6 @@ void AOTCodeAddressTable::init_extrs() {
     ADD_EXTERNAL_ADDRESS(OptoRuntime::new_instance_C);
     ADD_EXTERNAL_ADDRESS(OptoRuntime::new_array_C);
     ADD_EXTERNAL_ADDRESS(OptoRuntime::new_array_nozero_C);
-    ADD_EXTERNAL_ADDRESS(OptoRuntime::multianewarray2_C);
     ADD_EXTERNAL_ADDRESS(OptoRuntime::multianewarray3_C);
     ADD_EXTERNAL_ADDRESS(OptoRuntime::multianewarray4_C);
     ADD_EXTERNAL_ADDRESS(OptoRuntime::multianewarray5_C);

src/hotspot/share/opto/parse.hpp

@@ -549,7 +549,7 @@ class Parse : public GraphKit {
   void do_anewarray();
   void do_multianewarray();
   Node* expand_multianewarray(ciArrayKlass* array_klass, Node* *lengths, int ndimensions, int nargs);
-  void init_array2d(Node* array, ciArrayKlass* array_klass, Node* length1, Node* length2);
+  Node* multianewarray2(ciArrayKlass* array_klass, Node* length1, Node* length2);
 
   // implementation of jsr/ret
   void do_jsr();

src/hotspot/share/opto/parse3.cpp

@@ -327,45 +327,48 @@ Node* Parse::expand_multianewarray(ciArrayKlass* array_klass, Node* *lengths, in
 /**
  * Initialize the graph, equivalent to the following Java code:
  *
- * for (int index = 0; index < length1; index++)
- *   multi_array[index] = new array_klass[length2];
- *
- * The actual loop structure:
- *
- * if (length1 > 0) {
- *   int index = 0;
- *   do {
- *     multi_array[index] = new T[length2];
- *     index++;
- *   } while (index < length1);
- * }
- *
- * The corresponding C2 IR graph:
- *
- * CmpI(length1, 0) -> Bool(gt) -> If
- *   IfFalse => skip_ctrl
- *   IfTrue =>
- *     CastII(length2, POS) -> length2
- *     LoopNode(IfTrue, back_edge)
- *       Phi(LoopNode, 0,       next_index) -> index
- *       Phi(LoopNode, pre_mem, body_mem)
- *       Phi(LoopNode, pre_io,  body_io)
- *       AllocateArray(klass_1, length2) -> array
- *       StoreP(array_element_address(multi_array, index), array)
- *       AddI(index, 1) -> next_index
- *       CmpI(next_index, length1) -> Bool(lt) -> If
- *         IfTrue  => back_edge => LoopNode
- *         IfFalse => loop_exit
- * Region(skip_ctrl, loop_exit)
- *   Phi(Region, pre_mem, body_mem)
- *   Phi(Region, pre_io,  body_io)
+ *   multi_array = new T[length1][];
+ *   for (int index = 0; index < length1; index++) {
+ *     multi_array[index] = new array_klass[length2];
+ *   }
  */
-void Parse::init_array2d(Node* multi_array,
-                         ciArrayKlass* array_klass,
-                         Node* length1, Node* length2) {
+Node* Parse::multianewarray2(ciArrayKlass* array_klass, Node* length1, Node* length2) {
+
+  assert(length1 != nullptr && length2 != nullptr, "");
+  Node* multi_array = new_array(makecon(TypeKlassPtr::make(array_klass, Type::trust_interfaces)), length1, false);
 
   C->set_has_loops(true);
 
+  // The actual loop structure:
+  //
+  // if (length1 > 0) {
+  //   int index = 0;
+  //   do {
+  //     multi_array[index] = new T[length2];
+  //     index++;
+  //   } while (index < length1);
+  // }
+  //
+  // The corresponding C2 IR graph:
+  //
+  // CmpI(length1, 0) -> Bool(gt) -> If
+  //   IfFalse => skip_ctrl
+  //   IfTrue =>
+  //     CastII(length2, POS) -> length2
+  //     LoopNode(IfTrue, back_edge)
+  //       Phi(LoopNode, 0,       next_index) -> index
+  //       Phi(LoopNode, pre_mem, body_mem)
+  //       Phi(LoopNode, pre_io,  body_io)
+  //       AllocateArray(klass_1, length2) -> array
+  //       StoreP(array_element_address(multi_array, index), array)
+  //       AddI(index, 1) -> next_index
+  //       CmpI(next_index, length1) -> Bool(lt) -> If
+  //         IfTrue  => back_edge => LoopNode
+  //         IfFalse => loop_exit
+  // Region(skip_ctrl, loop_exit)
+  //   Phi(Region, pre_mem, body_mem)
+  //   Phi(Region, pre_io,  body_io)
+
   Node* i_init = _gvn.intcon(0);
   Node* cmp_init = _gvn.transform(new CmpINode(length1, i_init));
   Node* bool_init = _gvn.transform(new BoolNode(cmp_init, BoolTest::gt));
@@ -408,10 +411,11 @@ void Parse::init_array2d(Node* multi_array,
 
   Node* array = _gvn.transform(new_array(klass_node, length2, false));
 
-  store_to_memory(control(),
+  const TypeOopPtr* elemtype = _gvn.type(multi_array)->is_aryptr()->elem()->make_oopptr();
+  access_store_at(multi_array,
                   array_element_address(multi_array, index, T_OBJECT),
-                  array,
-                  T_OBJECT, MemNode::unordered, TypeAryPtr::OOPS, false, false, true);
+                  TypeAryPtr::OOPS,
+                  array, elemtype, T_OBJECT, IN_HEAP | IS_ARRAY);
 
   Node* new_i = _gvn.transform(new AddINode(index, _gvn.intcon(1)));
   Node* cmp = _gvn.transform(new CmpINode(new_i, length1));
@@ -444,6 +448,8 @@ void Parse::init_array2d(Node* multi_array,
   set_control(exit_region);
   set_all_memory(exit_mem);
   set_i_o(exit_io);
+
+  return multi_array;
 }
 
 void Parse::do_multianewarray() {
@@ -507,12 +513,7 @@ void Parse::do_multianewarray() {
     Node* obj = nullptr;
     { PreserveReexecuteState preexecs(this);
       inc_sp(ndimensions);
-
-      Node* length1 = length[0];
-      Node* length2 = length[1];
-      assert(length1 != nullptr && length2 != nullptr, "");
-      obj = new_array(makecon(TypeKlassPtr::make(array_klass, Type::trust_interfaces)), length1, false);
-      init_array2d(obj, array_klass, length1, length2);
+      obj = multianewarray2(array_klass, length[0], length[1]);
     }
     push(obj);
     return;
@@ -521,7 +522,7 @@ void Parse::do_multianewarray() {
   address fun = nullptr;
   switch (ndimensions) {
   case 1: ShouldNotReachHere(); break;
-  case 2: fun = OptoRuntime::multianewarray2_Java(); break;
+  case 2: ShouldNotReachHere(); break;
   case 3: fun = OptoRuntime::multianewarray3_Java(); break;
   case 4: fun = OptoRuntime::multianewarray4_Java(); break;
   case 5: fun = OptoRuntime::multianewarray5_Java(); break;

src/hotspot/share/opto/runtime.cpp

@@ -172,7 +172,6 @@ bool OptoRuntime::generate(ciEnv* env) {
 
 const TypeFunc* OptoRuntime::_new_instance_Type                   = nullptr;
 const TypeFunc* OptoRuntime::_new_array_Type                      = nullptr;
-const TypeFunc* OptoRuntime::_multianewarray2_Type                = nullptr;
 const TypeFunc* OptoRuntime::_multianewarray3_Type                = nullptr;
 const TypeFunc* OptoRuntime::_multianewarray4_Type                = nullptr;
 const TypeFunc* OptoRuntime::_multianewarray5_Type                = nullptr;
@@ -426,22 +425,6 @@ JRT_END
 
 // Note: multianewarray for one dimension is handled inline by GraphKit::new_array.
 
-// multianewarray for 2 dimensions
-JRT_ENTRY(void, OptoRuntime::multianewarray2_C(Klass* elem_type, int len1, int len2, JavaThread* current))
-#ifndef PRODUCT
-  SharedRuntime::_multi2_ctr++;                // multianewarray for 1 dimension
-#endif
-  assert(check_compiled_frame(current), "incorrect caller");
-  assert(elem_type->is_klass(), "not a class");
-  jint dims[2];
-  dims[0] = len1;
-  dims[1] = len2;
-  Handle holder(current, elem_type->klass_holder()); // keep the klass alive
-  oop obj = ArrayKlass::cast(elem_type)->multi_allocate(2, dims, THREAD);
-  deoptimize_caller_frame(current, HAS_PENDING_EXCEPTION);
-  current->set_vm_result_oop(obj);
-JRT_END
-
 // multianewarray for 3 dimensions
 JRT_ENTRY(void, OptoRuntime::multianewarray3_C(Klass* elem_type, int len1, int len2, int len3, JavaThread* current))
 #ifndef PRODUCT
@@ -2269,7 +2252,6 @@ NamedCounter* OptoRuntime::new_named_counter(JVMState* youngest_jvms, NamedCount
 void OptoRuntime::initialize_types() {
   _new_instance_Type                  = make_new_instance_Type();
   _new_array_Type                     = make_new_array_Type();
-  _multianewarray2_Type               = multianewarray_Type(2);
   _multianewarray3_Type               = multianewarray_Type(3);
   _multianewarray4_Type               = multianewarray_Type(4);
   _multianewarray5_Type               = multianewarray_Type(5);

src/hotspot/share/opto/runtime.hpp

@@ -125,7 +125,6 @@ class OptoRuntime : public AllStatic {
   // static TypeFunc* data members
   static const TypeFunc* _new_instance_Type;
   static const TypeFunc* _new_array_Type;
-  static const TypeFunc* _multianewarray2_Type;
   static const TypeFunc* _multianewarray3_Type;
   static const TypeFunc* _multianewarray4_Type;
   static const TypeFunc* _multianewarray5_Type;
@@ -217,7 +216,6 @@ class OptoRuntime : public AllStatic {
 
   // Allocate storage for a multi-dimensional arrays
   // Note: needs to be fixed for arbitrary number of dimensions
-  static void multianewarray2_C(Klass* klass, int len1, int len2, JavaThread* current);
   static void multianewarray3_C(Klass* klass, int len1, int len2, int len3, JavaThread* current);
   static void multianewarray4_C(Klass* klass, int len1, int len2, int len3, int len4, JavaThread* current);
   static void multianewarray5_C(Klass* klass, int len1, int len2, int len3, int len4, int len5, JavaThread* current);
@@ -282,7 +280,6 @@ class OptoRuntime : public AllStatic {
   static address new_instance_Java()                     { return _new_instance_Java; }
   static address new_array_Java()                        { return _new_array_Java; }
   static address new_array_nozero_Java()                 { return _new_array_nozero_Java; }
-  static address multianewarray2_Java()                  { return _multianewarray2_Java; }
   static address multianewarray3_Java()                  { return _multianewarray3_Java; }
   static address multianewarray4_Java()                  { return _multianewarray4_Java; }
   static address multianewarray5_Java()                  { return _multianewarray5_Java; }
@@ -329,11 +326,6 @@ class OptoRuntime : public AllStatic {
 
   static const TypeFunc* multianewarray_Type(int ndim); // multianewarray
 
-  static inline const TypeFunc* multianewarray2_Type() {
-    assert(_multianewarray2_Type != nullptr, "should be initialized");
-    return _multianewarray2_Type;
-  }
-
   static inline const TypeFunc* multianewarray3_Type() {
     assert(_multianewarray3_Type != nullptr, "should be initialized");
     return _multianewarray3_Type;

src/hotspot/share/runtime/stubDeclarations.hpp

@@ -218,7 +218,6 @@
   do_stub(new_instance, 0, true, false)                                \
   do_stub(new_array, 0, true, false)                                   \
   do_stub(new_array_nozero, 0, true, false)                            \
-  do_stub(multianewarray2, 0, true, false)                             \
   do_stub(multianewarray3, 0, true, false)                             \
   do_stub(multianewarray4, 0, true, false)                             \
   do_stub(multianewarray5, 0, true, false)                             \

test/hotspot/jtreg/compiler/allocation/TestMultiArrayAlloc.java

@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2026, BELLSOFT. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8308105
+ * @summary Test correctness of inlined 2D array allocation
+ *
+ * @run main/othervm -Xcomp -Xbatch -XX:-TieredCompilation compiler.allocation.TestMultiArrayAlloc
+ * @run main/othervm -Xcomp -Xbatch -XX:-TieredCompilation -XX:+UseSerialGC compiler.allocation.TestMultiArrayAlloc
+ * @run main/othervm -Xcomp -Xbatch -XX:-TieredCompilation -XX:+UseG1GC compiler.allocation.TestMultiArrayAlloc
+ *
+ * @requires vm.gc.Shenandoah & vm.gc.Z
+ * @run main/othervm -Xcomp -Xbatch -XX:-TieredCompilation -XX:+UseShenandoahGC compiler.allocation.TestMultiArrayAlloc
+ * @run main/othervm -Xcomp -Xbatch -XX:-TieredCompilation -XX:+UseZGC compiler.allocation.TestMultiArrayAlloc
+ */
+
+package compiler.allocation;
+
+public class TestMultiArrayAlloc {
+
+    static int[][]    allocInt(int n1, int n2) { return new int[n1][n2]; }
+    static Object[][] allocObj(int n1, int n2) { return new Object[n1][n2]; }
+    static String[][] allocStr(int n1, int n2) { return new String[n1][n2]; }
+
+    static void check(boolean cond, String msg) { if (!cond) throw new RuntimeException(msg); }
+
+    static void testArrayContents() {
+        int n1 = 10, n2 = 20;
+        int[][]    ints = allocInt(n1, n2);
+        Object[][] objs = allocObj(n1, n2);
+        String[][] strs = allocStr(n1, n2);
+        check(ints.length == n1, "int outer length");
+        check(objs.length == n1, "Object outer length");
+        check(strs.length == n1, "String outer length");
+        for (int i = 0; i < n1; i++) {
+            check(ints[i] instanceof int[]    && ints[i].length == n2, "int inner at " + i);
+            check(objs[i] instanceof Object[] && objs[i].length == n2, "Object inner at " + i);
+            check(strs[i] instanceof String[] && strs[i].length == n2, "String inner at " + i);
+            for (int j = 0; j < n2; j++) {
+                check(ints[i][j] == 0,    "int not zero at ["    + i + "][" + j + "]");
+                check(objs[i][j] == null, "Object not null at [" + i + "][" + j + "]");
+                check(strs[i][j] == null, "String not null at [" + i + "][" + j + "]");
+            }
+        }
+        // length1 == 0
+        int[][] b = allocInt(0, n2);
+        check(b.length == 0, "int[0][n2] wrong length");
+        // length2 == 0
+        int[][] c = allocInt(n1, 0);
+        for (int i = 0; i < n1; i++) {
+            check(c[i].length == 0, "int[n1][0] inner length wrong at " + i);
+        }
+    }
+
+    static void testExceptions() {
+        try {
+            allocInt(-1, 5);
+            throw new RuntimeException("expected NegativeArraySizeException for length1 < 0");
+        } catch (NegativeArraySizeException e) { /* expected */ }
+        try {
+            allocInt(5, -1);
+            throw new RuntimeException("expected NegativeArraySizeException for length2 < 0");
+        } catch (NegativeArraySizeException e) { /* expected */ }
+        try {
+            allocInt(-1, -1);
+            throw new RuntimeException("expected NegativeArraySizeException for both < 0");
+        } catch (NegativeArraySizeException e) { /* expected */ }
+    }
+
+    static void testRefsAfterGC() {
+        int count = 5000, n1 = 4, n2 = 4;
+        int[][][] refs = new int[count][][];
+        for (int i = 0; i < count; i++) {
+            refs[i] = allocInt(n1, n2);
+            for (int j = 0; j < n1; j++) {
+                refs[i][j][0] = i;
+            }
+        }
+        System.gc();
+        for (int i = 0; i < count; i++) {
+            check(refs[i] != null, "GC collected outer array at " + i);
+            for (int j = 0; j < n1; j++) {
+                check(refs[i][j] != null, "GC collected inner array at [" + i + "][" + j + "]");
+            }
+            check(refs[i][0][0] == i, "GC corrupted value at " + i);
+        }
+    }
+
+    public static void main(String[] args) {
+        testArrayContents();
+        testExceptions();
+        testRefsAfterGC();
+    }
+}