add foreign calls to method summaries

Author: d-kozak

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

@@ -28,12 +28,14 @@
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
 import com.oracle.graal.pointsto.meta.AnalysisType;
 import jdk.vm.ci.meta.JavaConstant;
+import org.graalvm.compiler.core.common.spi.ForeignCallDescriptor;
+import org.graalvm.compiler.core.common.spi.ForeignCallSignature;
 
 import java.util.Arrays;
 
 public class MethodSummary {
     public static final MethodSummary EMPTY = new MethodSummary(new AnalysisMethod[0], new AnalysisMethod[0], new AnalysisType[0], new AnalysisType[0], new AnalysisField[0], new AnalysisField[0],
-                    new JavaConstant[0]);
+                    new JavaConstant[0], new ForeignCallDescriptor[0], new ForeignCallSignature[0]);
 
     public final AnalysisMethod[] invokedMethods;
     public final AnalysisMethod[] implementationInvokedMethods;
@@ -42,17 +44,23 @@ public class MethodSummary {
     public final AnalysisField[] readFields;
     public final AnalysisField[] writtenFields;
     public final JavaConstant[] embeddedConstants;
+    public final ForeignCallDescriptor[] foreignCallDescriptors;
+    public final ForeignCallSignature[] foreignCallSignatures;
 
     public MethodSummary(AnalysisMethod[] invokedMethods, AnalysisMethod[] implementationInvokedMethods, AnalysisType[] accessedTypes, AnalysisType[] instantiatedTypes, AnalysisField[] readFields,
                     AnalysisField[] writtenFields,
-                    JavaConstant[] embeddedConstants) {
+                    JavaConstant[] embeddedConstants,
+                    ForeignCallDescriptor[] foreignCallDescriptors,
+                    ForeignCallSignature[] foreignCallSignatures) {
         this.invokedMethods = invokedMethods;
         this.implementationInvokedMethods = implementationInvokedMethods;
         this.accessedTypes = accessedTypes;
         this.instantiatedTypes = instantiatedTypes;
         this.readFields = readFields;
         this.writtenFields = writtenFields;
         this.embeddedConstants = embeddedConstants;
+        this.foreignCallDescriptors = foreignCallDescriptors;
+        this.foreignCallSignatures = foreignCallSignatures;
     }
 
     @Override
@@ -69,6 +77,7 @@ public String toString() {
     }
 
     public MethodSummary withoutMethods() {
-        return new MethodSummary(new AnalysisMethod[0], new AnalysisMethod[0], accessedTypes, instantiatedTypes, readFields, writtenFields, embeddedConstants);
+        return new MethodSummary(new AnalysisMethod[0], new AnalysisMethod[0], accessedTypes, instantiatedTypes, readFields, writtenFields, embeddedConstants, foreignCallDescriptors,
+                        foreignCallSignatures);
     }
 }

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

@@ -41,6 +41,7 @@
 import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import org.graalvm.compiler.core.common.spi.ForeignCallDescriptor;
+import org.graalvm.compiler.core.common.spi.ForeignCallSignature;
 import org.graalvm.compiler.debug.Indent;
 import org.graalvm.compiler.graph.Node;
 import org.graalvm.compiler.nodes.FrameState;
@@ -181,6 +182,12 @@ private void processSummary(AnalysisMethod method, MethodSummary summary) {
                 }
             }
         }
+        for (ForeignCallDescriptor descriptor : summary.foreignCallDescriptors) {
+            registerForeignCall(descriptor);
+        }
+        for (ForeignCallSignature signature : summary.foreignCallSignatures) {
+            registerForeignCall(getProviders().getForeignCalls().getDescriptor(signature));
+        }
     }
 
     @Override

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

@@ -37,20 +37,25 @@
 import jdk.vm.ci.meta.ResolvedJavaField;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
+import org.graalvm.compiler.core.common.spi.ForeignCallDescriptor;
+import org.graalvm.compiler.core.common.spi.ForeignCallSignature;
 import org.graalvm.compiler.graph.Node;
 import org.graalvm.compiler.nodes.CallTargetNode;
 import org.graalvm.compiler.nodes.ConstantNode;
 import org.graalvm.compiler.nodes.FrameState;
 import org.graalvm.compiler.nodes.Invoke;
 import org.graalvm.compiler.nodes.StructuredGraph;
+import org.graalvm.compiler.nodes.extended.ForeignCall;
 import org.graalvm.compiler.nodes.java.AccessFieldNode;
 import org.graalvm.compiler.nodes.java.InstanceOfNode;
 import org.graalvm.compiler.nodes.java.LoadFieldNode;
 import org.graalvm.compiler.nodes.java.NewArrayNode;
 import org.graalvm.compiler.nodes.java.NewInstanceNode;
 import org.graalvm.compiler.nodes.java.NewMultiArrayNode;
 import org.graalvm.compiler.nodes.java.StoreFieldNode;
+import org.graalvm.compiler.replacements.nodes.BinaryMathIntrinsicNode;
 import org.graalvm.compiler.replacements.nodes.MacroInvokable;
+import org.graalvm.compiler.replacements.nodes.UnaryMathIntrinsicNode;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -113,6 +118,8 @@ protected class Instance {
         public final List<AnalysisMethod> invokedMethods = new ArrayList<>();
         public final List<AnalysisMethod> implementationInvokedMethods = new ArrayList<>();
         public final List<JavaConstant> embeddedConstants = new ArrayList<>();
+        public final List<ForeignCallDescriptor> foreignCallDescriptors = new ArrayList<>();
+        public final List<ForeignCallSignature> foreignCallSignatures = new ArrayList<>();
 
         private MethodSummary createSummaryFromGraph(StructuredGraph graph) {
 
@@ -182,13 +189,19 @@ private MethodSummary createSummaryFromGraph(StructuredGraph graph) {
                     } else {
                         invokedMethods.add(targetMethod);
                     }
+                } else if (n instanceof ForeignCall) {
+                    foreignCallDescriptors.add(((ForeignCall) n).getDescriptor());
+                } else if (n instanceof UnaryMathIntrinsicNode) {
+                    foreignCallSignatures.add(((UnaryMathIntrinsicNode) n).getOperation().foreignCallSignature);
+                } else if (n instanceof BinaryMathIntrinsicNode) {
+                    foreignCallSignatures.add(((BinaryMathIntrinsicNode) n).getOperation().foreignCallSignature);
                 }
                 delegateNodeProcessing(this, n);
             }
             return new MethodSummary(invokedMethods.toArray(new AnalysisMethod[0]), implementationInvokedMethods.toArray(new AnalysisMethod[0]),
                             accessedTypes.toArray(new AnalysisType[0]),
                             instantiatedTypes.toArray(new AnalysisType[0]), readFields.toArray(new AnalysisField[0]), writtenFields.toArray(new AnalysisField[0]),
-                            embeddedConstants.toArray(new JavaConstant[0]));
+                            embeddedConstants.toArray(new JavaConstant[0]), foreignCallDescriptors.toArray(new ForeignCallDescriptor[0]), foreignCallSignatures.toArray(new ForeignCallSignature[0]));
         }
     }
 }