jdk-sandbox: comparison src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/StructuredGraph.java

equal deleted inserted replaced

-:5bce1b7e7800
+:47f19ff9903c
 import java.util.Iterator;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
+import org.graalvm.collections.EconomicMap;
+import org.graalvm.collections.EconomicSet;
+import org.graalvm.collections.Equivalence;
+import org.graalvm.collections.UnmodifiableEconomicMap;
 import org.graalvm.compiler.core.common.CancellationBailoutException;
 import org.graalvm.compiler.core.common.CompilationIdentifier;
 import org.graalvm.compiler.core.common.GraalOptions;
 import org.graalvm.compiler.core.common.cfg.BlockMap;
 import org.graalvm.compiler.core.common.type.Stamp;
 import org.graalvm.compiler.debug.DebugContext;
 import org.graalvm.compiler.debug.JavaMethodContext;
 import org.graalvm.compiler.graph.Graph;
 import org.graalvm.compiler.graph.Node;
 import org.graalvm.compiler.graph.NodeMap;
+import org.graalvm.compiler.graph.NodeSourcePosition;
 import org.graalvm.compiler.nodes.calc.FloatingNode;
 import org.graalvm.compiler.nodes.cfg.Block;
 import org.graalvm.compiler.nodes.cfg.ControlFlowGraph;
 import org.graalvm.compiler.nodes.java.MethodCallTargetNode;
 import org.graalvm.compiler.nodes.spi.VirtualizableAllocation;
 import org.graalvm.compiler.nodes.util.GraphUtil;
 import org.graalvm.compiler.options.OptionValues;
-import org.graalvm.util.EconomicMap;
-import org.graalvm.util.EconomicSet;
-import org.graalvm.util.Equivalence;
-import org.graalvm.util.UnmodifiableEconomicMap;
 import jdk.vm.ci.meta.Assumptions;
 import jdk.vm.ci.meta.Assumptions.Assumption;
 import jdk.vm.ci.meta.DefaultProfilingInfo;
 import jdk.vm.ci.meta.JavaMethod;
 private int entryBCI = JVMCICompiler.INVOCATION_ENTRY_BCI;
 private boolean useProfilingInfo = true;
 private final OptionValues options;
 private Cancellable cancellable = null;
 private final DebugContext debug;
+private NodeSourcePosition callerContext;
 /**
 * Creates a builder for a graph.
 */
 public Builder(OptionValues options, DebugContext debug, AllowAssumptions allowAssumptions) {
 public Builder useProfilingInfo(boolean flag) {
 this.useProfilingInfo = flag;
 return this;
 }
+public Builder callerContext(NodeSourcePosition context) {
+this.callerContext = context;
+return this;
+}
 public StructuredGraph build() {
-return new StructuredGraph(name, rootMethod, entryBCI, assumptions, speculationLog, useProfilingInfo, compilationId, options, debug, cancellable);
+return new StructuredGraph(name, rootMethod, entryBCI, assumptions, speculationLog, useProfilingInfo, compilationId, options, debug, cancellable, callerContext);
 }
 }
 public static final long INVALID_GRAPH_ID = -1;
 private static final AtomicLong uniqueGraphIds = new AtomicLong();
 private SpeculationLog speculationLog;
 private ScheduleResult lastSchedule;
+private final InliningLog inliningLog;
+/**
+* Call stack (context) leading to construction of this graph.
+*/
+private final NodeSourcePosition callerContext;
 /**
 * Records the methods that were used while constructing this graph, one entry for each time a
 * specific method is used.
 */
 private final List<ResolvedJavaMethod> methods = new ArrayList<>();
 SpeculationLog speculationLog,
 boolean useProfilingInfo,
 CompilationIdentifier compilationId,
 OptionValues options,
 DebugContext debug,
-Cancellable cancellable) {
+Cancellable cancellable,
+NodeSourcePosition context) {
 super(name, options, debug);
 this.setStart(add(new StartNode()));
 this.rootMethod = method;
 this.graphId = uniqueGraphIds.incrementAndGet();
 this.compilationId = compilationId;
 this.entryBCI = entryBCI;
 this.assumptions = assumptions;
 this.speculationLog = speculationLog;
 this.useProfilingInfo = useProfilingInfo;
 this.cancellable = cancellable;
+this.inliningLog = new InliningLog();
+this.callerContext = context;
 }
 public void setLastSchedule(ScheduleResult result) {
 lastSchedule = result;
 }
 public void setStart(StartNode start) {
 this.start = start;
 }
+public InliningLog getInliningLog() {
+return inliningLog;
+}
 /**
 * Creates a copy of this graph.
 *
 * @param newName the name of the copy, used for debugging purposes (can be null)
 * @param duplicationMapCallback consumer of the duplication map created during the copying
 entryBCI,
 assumptions == null ? null : new Assumptions(),
 speculationLog,
 useProfilingInfo,
 newCompilationId,
-getOptions(), debugForCopy, null);
+getOptions(), debugForCopy, null, callerContext);
 if (allowAssumptions == AllowAssumptions.YES && assumptions != null) {
 copy.assumptions.record(assumptions);
 }
 copy.hasUnsafeAccess = hasUnsafeAccess;
 copy.setGuardsStage(getGuardsStage());
 @Override
 protected void afterRegister(Node node) {
 assert hasValueProxies() || !(node instanceof ValueProxyNode);
 }
+public NodeSourcePosition getCallerContext() {
+return callerContext;
+}
 }

changeset 48861	47f19ff9903c
parent 48190	25cfedf27edc
child 49451	e06f9607f370