[GR-68269] Support boxing certain phis in Vector API expansion

PullRequest: graal/22283

Author: gergo-

compiler/OWNERS.toml

@@ -7,5 +7,4 @@ any = [
     "gergo.barany@oracle.com",
     "yudi.zheng@oracle.com",
     "raphael.m.mosaner@oracle.com",
-    "quan.anh.mai@oracle.com",
 ]

compiler/src/jdk.graal.compiler.processor/src/jdk/graal/compiler/options/processor/OptionProcessor.java

@@ -396,6 +396,7 @@ record OptionsDeclarer(Element element,
                     Set<Element> originatingElements) {
 
         static OptionsDeclarer ERROR = new OptionsDeclarer(null, null, null, false, null, null);
+
         static OptionsDeclarer create(ProcessingEnvironment env, Element optionsDeclarerElement, boolean implementsOptionsContainer) {
             Element e = optionsDeclarerElement;
 

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/vector/replacements/vectorapi/VectorAPIBoxingUtils.java

@@ -43,6 +43,7 @@
 import jdk.graal.compiler.nodes.PiNode;
 import jdk.graal.compiler.nodes.StructuredGraph;
 import jdk.graal.compiler.nodes.ValueNode;
+import jdk.graal.compiler.nodes.ValuePhiNode;
 import jdk.graal.compiler.nodes.calc.NarrowNode;
 import jdk.graal.compiler.nodes.calc.NotNode;
 import jdk.graal.compiler.nodes.calc.SignExtendNode;
@@ -51,22 +52,24 @@
 import jdk.graal.compiler.nodes.java.LoadFieldNode;
 import jdk.graal.compiler.nodes.java.NewArrayNode;
 import jdk.graal.compiler.nodes.java.NewInstanceNode;
-import jdk.graal.compiler.nodes.java.StoreFieldNode;
 import jdk.graal.compiler.nodes.memory.ReadNode;
 import jdk.graal.compiler.nodes.memory.WriteNode;
 import jdk.graal.compiler.nodes.memory.address.AddressNode;
 import jdk.graal.compiler.nodes.memory.address.IndexAddressNode;
 import jdk.graal.compiler.nodes.memory.address.OffsetAddressNode;
 import jdk.graal.compiler.nodes.spi.CoreProviders;
 import jdk.graal.compiler.nodes.spi.ValueProxy;
+import jdk.graal.compiler.replacements.DefaultJavaLoweringProvider;
 import jdk.graal.compiler.vector.architecture.VectorArchitecture;
 import jdk.graal.compiler.vector.architecture.VectorLoweringProvider;
 import jdk.graal.compiler.vector.nodes.simd.LogicValueStamp;
 import jdk.graal.compiler.vector.nodes.simd.SimdBlendWithLogicMaskNode;
 import jdk.graal.compiler.vector.nodes.simd.SimdConstant;
 import jdk.graal.compiler.vector.nodes.simd.SimdStamp;
+import jdk.graal.compiler.vector.replacements.vectorapi.nodes.VectorAPIMacroNode;
 import jdk.vm.ci.meta.ConstantReflectionProvider;
 import jdk.vm.ci.meta.JavaConstant;
+import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.ResolvedJavaField;
 import jdk.vm.ci.meta.ResolvedJavaType;
@@ -167,6 +170,20 @@ public static int[] tryReadShuffleConstant(JavaConstant constant, CoreProviders
         return elements;
     }
 
+    /**
+     * Determine if the given object is a non-null instance of a concrete Vector API vector type. If
+     * yes, return its type; return {@code null} otherwise.
+     */
+    public static VectorAPIType isBoxedVectorAPIObject(ValueNode value, CoreProviders providers) {
+        if (value.stamp(NodeView.DEFAULT) instanceof ObjectStamp objectStamp && objectStamp.nonNull() && objectStamp.isExactType()) {
+            ResolvedJavaType maybeVectorType = objectStamp.type();
+            if (maybeVectorType != null) {
+                return VectorAPIType.ofType(maybeVectorType, providers);
+            }
+        }
+        return null;
+    }
+
     /**
      * Determine if the given object is a non-null instance of a concrete Vector API vector type
      * that we can unbox to a SIMD value. Such objects can occur as inputs to macro nodes via things
@@ -178,36 +195,33 @@ public static int[] tryReadShuffleConstant(JavaConstant constant, CoreProviders
     static VectorAPIType asUnboxableVectorType(ValueNode value, CoreProviders providers) {
         /*
          * Unboxing an object involves placing fixed read nodes. Therefore the value must be fixed,
-         * or it must be a pi with a fixed guard so we have a valid insertion position.
+         * or it must be a phi or a pi with a fixed guard so we have a valid insertion position.
          */
-        if (!(value instanceof FixedWithNextNode || (value instanceof ValueProxy pi && pi.getGuard() != null && pi.getGuard() instanceof FixedWithNextNode))) {
+        if (!(value instanceof FixedWithNextNode || value instanceof VectorAPIMacroNode ||
+                        value instanceof ValuePhiNode ||
+                        (value instanceof ValueProxy pi && pi.getGuard() != null && pi.getGuard() instanceof FixedWithNextNode))) {
             return null;
         }
         /* Now check if this is a Vector API object we can do a SIMD read from. */
-        if (value.stamp(NodeView.DEFAULT) instanceof ObjectStamp objectStamp && objectStamp.nonNull() && objectStamp.isExactType()) {
-            ResolvedJavaType maybeVectorType = objectStamp.type();
-            if (maybeVectorType != null) {
-                VectorLoweringProvider vectorLowerer = (VectorLoweringProvider) providers.getLowerer();
-                VectorAPIType vectorType = VectorAPIType.ofType(maybeVectorType, providers);
-                if (vectorType != null && vectorType.vectorLength > 1) {
-                    VectorArchitecture vectorArch = vectorLowerer.getVectorArchitecture();
-                    Stamp elementStamp = vectorType.payloadStamp.getComponent(0);
-                    if (vectorType.isMask) {
-                        /*
-                         * The mask is represented as booleans in memory, to unbox it to a logic
-                         * vector we must be able to compare against zero.
-                         */
-                        if (!canConvertBooleansToLogic(vectorType, vectorArch)) {
-                            return null;
-                        }
-                        if (vectorArch.getSupportedVectorComparisonLength(elementStamp, CanonicalCondition.EQ, vectorType.vectorLength) != vectorType.vectorLength) {
-                            return null;
-                        }
-                    }
-                    if (vectorArch.getSupportedVectorMoveLength(elementStamp, vectorType.vectorLength) == vectorType.vectorLength) {
-                        return vectorType;
-                    }
+        VectorAPIType vectorType = isBoxedVectorAPIObject(value, providers);
+        if (vectorType != null && vectorType.vectorLength > 1) {
+            VectorLoweringProvider vectorLowerer = (VectorLoweringProvider) providers.getLowerer();
+            VectorArchitecture vectorArch = vectorLowerer.getVectorArchitecture();
+            Stamp elementStamp = vectorType.payloadStamp.getComponent(0);
+            if (vectorType.isMask) {
+                /*
+                 * The mask is represented as booleans in memory, to unbox it to a logic vector we
+                 * must be able to compare against zero.
+                 */
+                if (!canConvertBooleansToLogic(vectorType, vectorArch)) {
+                    return null;
                 }
+                if (vectorArch.getSupportedVectorComparisonLength(elementStamp, CanonicalCondition.EQ, vectorType.vectorLength) != vectorType.vectorLength) {
+                    return null;
+                }
+            }
+            if (vectorArch.getSupportedVectorMoveLength(elementStamp, vectorType.vectorLength) == vectorType.vectorLength) {
+                return vectorType;
             }
         }
         return null;
@@ -220,7 +234,7 @@ static VectorAPIType asUnboxableVectorType(ValueNode value, CoreProviders provid
      */
     static ValueNode boxVector(ResolvedJavaType boxType, FixedNode successor, ValueNode vector, CoreProviders providers) {
         VectorAPIType typeMeta = VectorAPIType.ofType(boxType, providers);
-        GraalError.guarantee(typeMeta != null, "unexpected vector type %s", boxType);
+        GraalError.guarantee(typeMeta != null, "unexpected vector type %s, vector %s", boxType, vector);
         StructuredGraph graph = vector.graph();
 
         // Allocate the payload array
@@ -248,12 +262,20 @@ static ValueNode boxVector(ResolvedJavaType boxType, FixedNode successor, ValueN
         NewInstanceNode box = graph.add(new NewInstanceNode(boxType, true));
         graph.addBeforeFixed(successor, box);
 
-        // Store the allocated payload array into the corresponding field of the box instance
+        /*
+         * Store the allocated payload array into the corresponding field of the box instance. We
+         * use a lowered write instead of a StoreField because we want to use the init location.
+         */
         ResolvedJavaField[] boxFields = boxType.getInstanceFields(true);
         GraalError.guarantee(boxFields.length == 1, "unexpected field count in %s", boxType);
         ResolvedJavaField payloadField = boxFields[0];
         GraalError.guarantee(payloadField.getName().equals("payload"), "unexpected field %s %s in %s", payloadField.getDeclaringClass(), payloadField.getName(), boxType);
-        StoreFieldNode storeToBox = graph.add(new StoreFieldNode(box, payloadField, publishedPayloadArray));
+        DefaultJavaLoweringProvider javaLowerer = ((VectorLoweringProvider) providers.getLowerer()).getBasicLoweringProvider();
+        int fieldOffset = javaLowerer.getBasicLoweringProvider().fieldOffset(payloadField);
+        AddressNode payloadFieldAddress = graph.addOrUnique(new OffsetAddressNode(box, ConstantNode.forLong(fieldOffset, graph)));
+        ValueNode compressedPayloadArray = javaLowerer.getBasicLoweringProvider().implicitStoreConvert(graph, JavaKind.Object, publishedPayloadArray);
+        BarrierType barrierType = providers.getLowerer().getBarrierSet().fieldWriteBarrierType(payloadField, JavaKind.Object);
+        WriteNode storeToBox = graph.add(new WriteNode(payloadFieldAddress, LocationIdentity.INIT_LOCATION, compressedPayloadArray, barrierType, MemoryOrderMode.PLAIN));
         graph.addBeforeFixed(successor, storeToBox);
 
         // Publish the allocated box instance
@@ -280,6 +302,10 @@ static ValueNode unboxObject(ValueNode value, CoreProviders providers) {
         FixedWithNextNode insertionPoint;
         if (value instanceof FixedWithNextNode fixed) {
             insertionPoint = fixed;
+        } else if (value instanceof VectorAPIMacroNode macro) {
+            insertionPoint = macro.next();
+        } else if (value instanceof ValuePhiNode phi) {
+            insertionPoint = phi.merge();
         } else {
             insertionPoint = (FixedWithNextNode) ((ValueProxy) value).getGuard();
         }