[GR-41995] [GR-42103] [GR-42600] Various fixes.

PullRequest: graal/13249

Author: Christian Wimmer

compiler/src/org.graalvm.compiler.java/src/org/graalvm/compiler/java/BciBlockMapping.java

@@ -737,30 +737,14 @@ public String toString() {
     private int newDuplicateBlocks;
     private int duplicateBlocks;
 
-    /**
-     * Amount by which {@link Options#MaxDuplicationFactor} is multiplied.
-     */
-    private final int maxDuplicationBoost;
-
     /**
      * Creates a new BlockMap instance from {@code code}.
      */
     protected BciBlockMapping(Bytecode code, DebugContext debug) {
-        this(code, debug, 1);
-    }
-
-    /**
-     * Creates a new BlockMap instance from {@code code}.
-     *
-     * @param maxDuplicationBoost amount by which to multiply {@link Options#MaxDuplicationFactor}
-     */
-    protected BciBlockMapping(Bytecode code, DebugContext debug, int maxDuplicationBoost) {
         this.code = code;
         this.debug = debug;
         this.exceptionHandlers = code.getExceptionHandlers().length != 0 ? code.getExceptionHandlers() : null;
         this.blockMap = new BciBlock[code.getCodeSize()];
-        assert maxDuplicationBoost >= 1 : maxDuplicationBoost;
-        this.maxDuplicationBoost = maxDuplicationBoost;
     }
 
     public BciBlock[] getBlocks() {
@@ -1749,7 +1733,7 @@ private void computeBlockOrder(BciBlock initialBlock) {
                     OptionValues options = debug.getOptions();
                     double factor = MaxDuplicationFactor.getValue(options);
                     duplicateBlocks += newDuplicateBlocks;
-                    if (duplicateBlocks > postJsrBlockCount * factor * maxDuplicationBoost) {
+                    if (duplicateBlocks > postJsrBlockCount * factor) {
                         throw new PermanentBailoutException("Non-reducible loop requires too much duplication. " +
                                         "Setting " + MaxDuplicationFactor.getName() + " to a value higher than " + factor + " may resolve this.");
                     }
@@ -1792,11 +1776,7 @@ private boolean checkBlocks(int start, BciBlock inserting) {
     }
 
     public static BciBlockMapping create(BytecodeStream stream, Bytecode code, OptionValues options, DebugContext debug, boolean hasAsyncExceptions) {
-        return create(stream, code, options, debug, hasAsyncExceptions, 1);
-    }
-
-    public static BciBlockMapping create(BytecodeStream stream, Bytecode code, OptionValues options, DebugContext debug, boolean hasAsyncExceptions, int maxDuplicationBoost) {
-        BciBlockMapping map = new BciBlockMapping(code, debug, maxDuplicationBoost);
+        BciBlockMapping map = new BciBlockMapping(code, debug);
         buildMap(stream, code, options, debug, map, hasAsyncExceptions);
         return map;
     }

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/PointsToAnalysis.java

@@ -299,84 +299,81 @@ public AnalysisMethod addRootMethod(Executable method, boolean invokeSpecial) {
     @SuppressWarnings("try")
     public AnalysisMethod addRootMethod(AnalysisMethod aMethod, boolean invokeSpecial) {
         assert !universe.sealed() : "Cannot register root methods after analysis universe is sealed.";
-        try (Indent indent = debug.logAndIndent("add root method %s", aMethod.getName())) {
+        AnalysisType declaringClass = aMethod.getDeclaringClass();
+        boolean isStatic = aMethod.isStatic();
+        WrappedSignature signature = aMethod.getSignature();
+        int paramCount = signature.getParameterCount(!isStatic);
+        PointsToAnalysisMethod pointsToMethod = assertPointsToAnalysisMethod(aMethod);
 
-            AnalysisType declaringClass = aMethod.getDeclaringClass();
-            boolean isStatic = aMethod.isStatic();
-            WrappedSignature signature = aMethod.getSignature();
-            int paramCount = signature.getParameterCount(!isStatic);
-            PointsToAnalysisMethod pointsToMethod = assertPointsToAnalysisMethod(aMethod);
-
-            if (isStatic) {
-                /*
-                 * For static methods trigger analysis in the empty context. This will trigger
-                 * parsing and return the method flows graph. Then the method parameter type flows
-                 * are initialized with the corresponding parameter declared type.
-                 */
-                postTask(() -> {
-                    pointsToMethod.registerAsDirectRootMethod();
-                    pointsToMethod.registerAsImplementationInvoked(null);
-                    MethodFlowsGraph methodFlowsGraph = analysisPolicy.staticRootMethodGraph(this, pointsToMethod);
-                    for (int idx = 0; idx < paramCount; idx++) {
-                        AnalysisType declaredParamType = (AnalysisType) signature.getParameterType(idx, declaringClass);
-                        FormalParamTypeFlow parameter = methodFlowsGraph.getParameter(idx);
-                        if (declaredParamType.getJavaKind() == JavaKind.Object && parameter != null) {
-                            TypeFlow<?> initialParameterFlow = declaredParamType.getTypeFlow(this, true);
-                            initialParameterFlow.addUse(this, parameter);
-                        }
+        if (isStatic) {
+            /*
+             * For static methods trigger analysis in the empty context. This will trigger parsing
+             * and return the method flows graph. Then the method parameter type flows are
+             * initialized with the corresponding parameter declared type.
+             */
+            postTask(() -> {
+                pointsToMethod.registerAsDirectRootMethod();
+                pointsToMethod.registerAsImplementationInvoked(null);
+                MethodFlowsGraph methodFlowsGraph = analysisPolicy.staticRootMethodGraph(this, pointsToMethod);
+                for (int idx = 0; idx < paramCount; idx++) {
+                    AnalysisType declaredParamType = (AnalysisType) signature.getParameterType(idx, declaringClass);
+                    FormalParamTypeFlow parameter = methodFlowsGraph.getParameter(idx);
+                    if (declaredParamType.getJavaKind() == JavaKind.Object && parameter != null) {
+                        TypeFlow<?> initialParameterFlow = declaredParamType.getTypeFlow(this, true);
+                        initialParameterFlow.addUse(this, parameter);
                     }
-                });
-            } else {
-                if (invokeSpecial && pointsToMethod.isAbstract()) {
-                    throw AnalysisError.userError("Abstract methods cannot be registered as special invoke entry point.");
                 }
+            });
+        } else {
+            if (invokeSpecial && pointsToMethod.isAbstract()) {
+                throw AnalysisError.userError("Abstract methods cannot be registered as special invoke entry point.");
+            }
+            /*
+             * For special invoked methods trigger method resolution by using the
+             * context-insensitive special invoke type flow. This will resolve the method in its
+             * declaring class when the declaring class is instantiated.
+             *
+             * For virtual methods trigger method resolution by using the context-insensitive
+             * virtual invoke type flow. Since the virtual invoke observes the receiver flow state
+             * it will get notified for any future reachable subtypes and will resolve the method in
+             * each subtype.
+             *
+             * In both cases the context-insensitive invoke parameters are initialized with the
+             * corresponding declared type state. When a callee is resolved the method is parsed and
+             * the actual parameter type state is propagated to the formal parameters. Then the
+             * callee is linked and registered as implementation-invoked.
+             */
+            postTask(() -> {
+                if (invokeSpecial) {
+                    pointsToMethod.registerAsDirectRootMethod();
+                } else {
+                    pointsToMethod.registerAsVirtualRootMethod();
+                }
+                InvokeTypeFlow invoke = pointsToMethod.initAndGetContextInsensitiveInvoke(PointsToAnalysis.this, null, invokeSpecial);
                 /*
-                 * For special invoked methods trigger method resolution by using the
-                 * context-insensitive special invoke type flow. This will resolve the method in its
-                 * declaring class when the declaring class is instantiated.
-                 *
-                 * For virtual methods trigger method resolution by using the context-insensitive
-                 * virtual invoke type flow. Since the virtual invoke observes the receiver flow
-                 * state it will get notified for any future reachable subtypes and will resolve the
-                 * method in each subtype.
+                 * Initialize the type flow of the invoke's actual parameters with the corresponding
+                 * parameter declared type. Thus, when the invoke links callees it will propagate
+                 * the parameter types too.
                  *
-                 * In both cases the context-insensitive invoke parameters are initialized with the
-                 * corresponding declared type state. When a callee is resolved the method is parsed
-                 * and the actual parameter type state is propagated to the formal parameters. Then
-                 * the callee is linked and registered as implementation-invoked.
+                 * The parameter iteration skips the primitive parameters, as these are not modeled.
+                 * The type flow of the receiver is set to the receiver type already when the invoke
+                 * is created.
                  */
-                postTask(() -> {
-                    if (invokeSpecial) {
-                        pointsToMethod.registerAsDirectRootMethod();
-                    } else {
-                        pointsToMethod.registerAsVirtualRootMethod();
-                    }
-                    InvokeTypeFlow invoke = pointsToMethod.initAndGetContextInsensitiveInvoke(PointsToAnalysis.this, null, invokeSpecial);
+                for (int idx = 1; idx < paramCount; idx++) {
                     /*
-                     * Initialize the type flow of the invoke's actual parameters with the
-                     * corresponding parameter declared type. Thus, when the invoke links callees it
-                     * will propagate the parameter types too.
-                     *
-                     * The parameter iteration skips the primitive parameters, as these are not
-                     * modeled. The type flow of the receiver is set to the receiver type already
-                     * when the invoke is created.
+                     * Note: the Signature doesn't count the receiver of a virtual invoke as a
+                     * parameter whereas the MethodTypeFlow does, hence when accessing the parameter
+                     * type below we use idx-1 but when accessing the actual parameter flow we
+                     * simply use idx.
                      */
-                    for (int idx = 1; idx < paramCount; idx++) {
-                        /*
-                         * Note: the Signature doesn't count the receiver of a virtual invoke as a
-                         * parameter whereas the MethodTypeFlow does, hence when accessing the
-                         * parameter type below we use idx-1 but when accessing the actual parameter
-                         * flow we simply use idx.
-                         */
-                        AnalysisType declaredParamType = (AnalysisType) signature.getParameterType(idx - 1, declaringClass);
-                        TypeFlow<?> actualParameterFlow = invoke.getActualParameter(idx);
-                        if (declaredParamType.getJavaKind() == JavaKind.Object && actualParameterFlow != null) {
-                            TypeFlow<?> initialParameterFlow = declaredParamType.getTypeFlow(this, true);
-                            initialParameterFlow.addUse(this, actualParameterFlow);
-                        }
+                    AnalysisType declaredParamType = (AnalysisType) signature.getParameterType(idx - 1, declaringClass);
+                    TypeFlow<?> actualParameterFlow = invoke.getActualParameter(idx);
+                    if (declaredParamType.getJavaKind() == JavaKind.Object && actualParameterFlow != null) {
+                        TypeFlow<?> initialParameterFlow = declaredParamType.getTypeFlow(this, true);
+                        initialParameterFlow.addUse(this, actualParameterFlow);
                     }
-                });
-            }
+                }
+            });
         }
         return aMethod;
 
@@ -397,24 +394,22 @@ public AnalysisType addRootClass(Class<?> clazz, boolean addFields, boolean addA
     @SuppressWarnings({"try"})
     @Override
     public AnalysisType addRootClass(AnalysisType type, boolean addFields, boolean addArrayClass) {
-        try (Indent indent = debug.logAndIndent("add root class %s", type.getName())) {
-            for (AnalysisField field : type.getInstanceFields(false)) {
-                if (addFields) {
-                    field.registerAsAccessed();
-                }
-                /*
-                 * For system classes any instantiated (sub)type of the declared field type can be
-                 * written to the field flow.
-                 */
-                TypeFlow<?> fieldDeclaredTypeFlow = field.getType().getTypeFlow(this, true);
-                fieldDeclaredTypeFlow.addUse(this, type.getContextInsensitiveAnalysisObject().getInstanceFieldFlow(this, field, true));
-            }
-            if (type.getSuperclass() != null) {
-                addRootClass(type.getSuperclass(), addFields, addArrayClass);
-            }
-            if (addArrayClass) {
-                addRootClass(type.getArrayClass(), false, false);
+        for (AnalysisField field : type.getInstanceFields(false)) {
+            if (addFields) {
+                field.registerAsAccessed();
             }
+            /*
+             * For system classes any instantiated (sub)type of the declared field type can be
+             * written to the field flow.
+             */
+            TypeFlow<?> fieldDeclaredTypeFlow = field.getType().getTypeFlow(this, true);
+            fieldDeclaredTypeFlow.addUse(this, type.getContextInsensitiveAnalysisObject().getInstanceFieldFlow(this, field, true));
+        }
+        if (type.getSuperclass() != null) {
+            addRootClass(type.getSuperclass(), addFields, addArrayClass);
+        }
+        if (addArrayClass) {
+            addRootClass(type.getArrayClass(), false, false);
         }
         return type;
     }
@@ -425,15 +420,13 @@ public AnalysisType addRootField(Class<?> clazz, String fieldName) {
         AnalysisType type = addRootClass(clazz, false, false);
         for (AnalysisField field : type.getInstanceFields(true)) {
             if (field.getName().equals(fieldName)) {
-                try (Indent indent = debug.logAndIndent("add root field %s in class %s", fieldName, clazz.getName())) {
-                    field.registerAsAccessed();
-                    /*
-                     * For system classes any instantiated (sub)type of the declared field type can
-                     * be written to the field flow.
-                     */
-                    TypeFlow<?> fieldDeclaredTypeFlow = field.getType().getTypeFlow(this, true);
-                    fieldDeclaredTypeFlow.addUse(this, type.getContextInsensitiveAnalysisObject().getInstanceFieldFlow(this, field, true));
-                }
+                field.registerAsAccessed();
+                /*
+                 * For system classes any instantiated (sub)type of the declared field type can be
+                 * written to the field flow.
+                 */
+                TypeFlow<?> fieldDeclaredTypeFlow = field.getType().getTypeFlow(this, true);
+                fieldDeclaredTypeFlow.addUse(this, type.getContextInsensitiveAnalysisObject().getInstanceFieldFlow(this, field, true));
                 return field.getType();
             }
         }
@@ -445,14 +438,12 @@ public AnalysisType addRootStaticField(Class<?> clazz, String fieldName) {
         addRootClass(clazz, false, false);
         Field reflectField;
         try {
-            try (Indent indent = debug.logAndIndent("add system static field %s in class %s", fieldName, clazz.getName())) {
-                reflectField = clazz.getField(fieldName);
-                AnalysisField field = metaAccess.lookupJavaField(reflectField);
-                field.registerAsAccessed();
-                TypeFlow<?> fieldFlow = field.getType().getTypeFlow(this, true);
-                fieldFlow.addUse(this, field.getStaticFieldFlow());
-                return field.getType();
-            }
+            reflectField = clazz.getField(fieldName);
+            AnalysisField field = metaAccess.lookupJavaField(reflectField);
+            field.registerAsAccessed();
+            TypeFlow<?> fieldFlow = field.getType().getTypeFlow(this, true);
+            fieldFlow.addUse(this, field.getStaticFieldFlow());
+            return field.getType();
         } catch (NoSuchFieldException e) {
             throw shouldNotReachHere("field not found: " + fieldName);
         }

substratevm/src/com.oracle.graal.reachability/src/com/oracle/graal/reachability/ReachabilityAnalysisEngine.java

@@ -32,7 +32,6 @@
 import java.util.Set;
 import java.util.concurrent.ForkJoinPool;
 
-import org.graalvm.compiler.debug.Indent;
 import org.graalvm.compiler.nodes.StructuredGraph;
 import org.graalvm.compiler.options.OptionValues;
 
@@ -108,21 +107,19 @@ public AnalysisMethod addRootMethod(Executable method, boolean invokeSpecial) {
     @SuppressWarnings("try")
     @Override
     public AnalysisType addRootClass(AnalysisType type, boolean addFields, boolean addArrayClass) {
-        try (Indent indent = debug.logAndIndent("add root class %s", type.getName())) {
-            for (AnalysisField field : type.getInstanceFields(false)) {
-                if (addFields) {
-                    field.registerAsAccessed();
-                }
+        for (AnalysisField field : type.getInstanceFields(false)) {
+            if (addFields) {
+                field.registerAsAccessed();
             }
+        }
 
-            markTypeAsReachable(type);
+        markTypeAsReachable(type);
 
-            if (type.getSuperclass() != null) {
-                addRootClass(type.getSuperclass(), addFields, addArrayClass);
-            }
-            if (addArrayClass) {
-                addRootClass(type.getArrayClass(), false, false);
-            }
+        if (type.getSuperclass() != null) {
+            addRootClass(type.getSuperclass(), addFields, addArrayClass);
+        }
+        if (addArrayClass) {
+            addRootClass(type.getArrayClass(), false, false);
         }
         return type;
     }
@@ -133,9 +130,7 @@ public AnalysisType addRootField(Class<?> clazz, String fieldName) {
         AnalysisType type = addRootClass(clazz, false, false);
         for (AnalysisField field : type.getInstanceFields(true)) {
             if (field.getName().equals(fieldName)) {
-                try (Indent indent = debug.logAndIndent("add root field %s in class %s", fieldName, clazz.getName())) {
-                    field.registerAsAccessed();
-                }
+                field.registerAsAccessed();
                 return field.getType();
             }
         }