Replace GraphBuilderContext#getInliningCallStack with GraphBuilderContext#getInliningChain.

Author: Aca-S

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/graphbuilderconf/GraphBuilderContext.java

@@ -28,8 +28,6 @@
 import static jdk.graal.compiler.core.common.type.StampFactory.objectNonNull;
 import static jdk.vm.ci.meta.DeoptimizationAction.InvalidateReprofile;
 
-import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
 import jdk.graal.compiler.bytecode.Bytecode;
@@ -77,6 +75,7 @@
 import jdk.graal.compiler.nodes.type.StampTool;
 import jdk.internal.misc.ScopedMemoryAccess;
 import jdk.vm.ci.code.BailoutException;
+import jdk.vm.ci.code.BytecodePosition;
 import jdk.vm.ci.meta.Assumptions;
 import jdk.vm.ci.meta.DeoptimizationAction;
 import jdk.vm.ci.meta.DeoptimizationReason;
@@ -284,19 +283,16 @@ default int getDepth() {
     }
 
     /**
-     * Gets the inlined call stack for this context. A list with only one element implies that no
-     * inlining has taken place.
-     *
-     * @param ignoreInvocationPluginTarget if set to true, and {@link #isParsingInvocationPlugin()}
-     *            returns true, the resulting call stack does not include the target of the
-     *            invocation plugin.
+     * Gets the inlining chain of this context. A null return value implies that this is the context
+     * for the parse root.
      */
-    default List<StackTraceElement> getInliningCallStack(boolean ignoreInvocationPluginTarget) {
-        List<StackTraceElement> callStack = new ArrayList<>();
-        for (GraphBuilderContext cur = this; cur != null; cur = cur.getParent()) {
-            callStack.add(cur.getMethod().asStackTraceElement(cur.bci()));
+    default BytecodePosition getInliningChain() {
+        BytecodePosition inliningContext = null;
+        for (GraphBuilderContext cur = getParent(); cur != null; cur = cur.getParent()) {
+            BytecodePosition caller = new BytecodePosition(null, cur.getMethod(), cur.bci());
+            inliningContext = inliningContext == null ? caller : inliningContext.addCaller(caller);
         }
-        return Collections.unmodifiableList(callStack);
+        return inliningContext;
     }
 
     /**

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/IntrinsicGraphBuilder.java

@@ -26,9 +26,6 @@
 
 import static jdk.vm.ci.code.BytecodeFrame.AFTER_BCI;
 
-import java.util.Collections;
-import java.util.List;
-
 import jdk.graal.compiler.bytecode.Bytecode;
 import jdk.graal.compiler.core.common.type.Stamp;
 import jdk.graal.compiler.core.common.type.StampFactory;
@@ -71,6 +68,7 @@
 import jdk.graal.compiler.nodes.spi.CoreProvidersDelegate;
 import jdk.graal.compiler.options.OptionValues;
 import jdk.vm.ci.code.BailoutException;
+import jdk.vm.ci.code.BytecodePosition;
 import jdk.vm.ci.meta.DeoptimizationAction;
 import jdk.vm.ci.meta.DeoptimizationReason;
 import jdk.vm.ci.meta.JavaKind;
@@ -329,8 +327,8 @@ public int getDepth() {
     }
 
     @Override
-    public List<StackTraceElement> getInliningCallStack(boolean ignoreInvocationPluginTarget) {
-        return Collections.emptyList();
+    public BytecodePosition getInliningChain() {
+        return null;
     }
 
     @Override

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/PEGraphDecoder.java

@@ -36,13 +36,13 @@
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.Formatter;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+import jdk.vm.ci.code.BytecodePosition;
 import org.graalvm.collections.Pair;
 
 import jdk.graal.compiler.api.replacements.Fold;
@@ -414,18 +414,15 @@ public int getDepth() {
         }
 
         @Override
-        public List<StackTraceElement> getInliningCallStack(boolean ignoreInvocationPluginTarget) {
-            StackTraceElement[] callStackArray = methodScope.getCallStack();
-            List<StackTraceElement> callStack = new ArrayList<>(callStackArray.length);
-            Collections.addAll(callStack, callStackArray);
-            /*
-             * If triggered while processing an invocation plugin, the call stack as returned by the
-             * methodScope object will include the target of the plugin.
-             */
-            if (isParsingInvocationPlugin() && ignoreInvocationPluginTarget) {
-                callStack.removeFirst();
-            }
-            return Collections.unmodifiableList(callStack);
+        public BytecodePosition getInliningChain() {
+            BytecodePosition inliningContext = null;
+            int bci = methodScope.invokeData == null ? 0 : methodScope.invokeData.invoke.bci();
+            for (PEMethodScope cur = methodScope.caller; cur != null; cur = cur.caller) {
+                BytecodePosition caller = new BytecodePosition(null, cur.method, bci);
+                inliningContext = inliningContext == null ? caller : inliningContext.addCaller(caller);
+                bci = cur.invokeData == null ? 0 : cur.invokeData.invoke.bci();
+            }
+            return inliningContext;
         }
 
         @Override

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/dynamicaccessinference/DynamicAccessInferenceLog.java

@@ -25,6 +25,7 @@
 package com.oracle.svm.hosted.dynamicaccessinference;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
@@ -34,6 +35,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import jdk.vm.ci.code.BytecodePosition;
 import org.graalvm.collections.Pair;
 import org.graalvm.nativeimage.ImageSingletons;
 
@@ -99,12 +101,25 @@ abstract static class LogEntry {
             assert targetMethod.hasReceiver() == (targetReceiver != null) : "Inferred receiver does not match with target method signature";
             assert targetMethod.getSignature().getParameterCount(false) == targetArguments.length : "Inferred arguments do not match with target method signature";
             this.callLocation = Pair.create(b.getMethod(), b.bci());
-            this.callStack = b.getInliningCallStack(true);
+            this.callStack = getCallStack(b);
             this.targetMethod = targetMethod;
             this.targetReceiver = targetReceiver;
             this.targetArguments = targetArguments;
         }
 
+        private static List<StackTraceElement> getCallStack(GraphBuilderContext b) {
+            BytecodePosition inliningContext = b.getInliningChain();
+            List<StackTraceElement> callStack = new ArrayList<>();
+            if (inliningContext == null || !inliningContext.getMethod().equals(b.getMethod()) || inliningContext.getBCI() != b.bci()) {
+                callStack.add(b.getMethod().asStackTraceElement(b.bci()));
+            }
+            while (inliningContext != null) {
+                callStack.add(inliningContext.getMethod().asStackTraceElement(inliningContext.getBCI()));
+                inliningContext = inliningContext.getCaller();
+            }
+            return callStack;
+        }
+
         @Override
         public String toString() {
             String targetArgumentsString = Stream.of(targetArguments)