1 /*
   2  * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package org.graalvm.compiler.printer;
  24 
  25 import java.io.Closeable;
  26 import java.io.IOException;
  27 import java.lang.reflect.Array;
  28 import java.util.Arrays;
  29 import java.util.List;
  30 import java.util.Map;
  31 
  32 import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
  33 import org.graalvm.compiler.debug.DebugContext;
  34 import org.graalvm.compiler.debug.DebugContext.Scope;
  35 import org.graalvm.compiler.graph.Graph;
  36 import org.graalvm.compiler.nodes.ConstantNode;
  37 import org.graalvm.compiler.nodes.StructuredGraph;

  38 import org.graalvm.compiler.phases.schedule.SchedulePhase;
  39 import org.graalvm.compiler.serviceprovider.JDK9Method;
  40 
  41 import jdk.vm.ci.meta.JavaConstant;
  42 import jdk.vm.ci.meta.JavaKind;
  43 import jdk.vm.ci.meta.JavaType;
  44 import jdk.vm.ci.meta.MetaUtil;
  45 import jdk.vm.ci.meta.ResolvedJavaMethod;
  46 import jdk.vm.ci.runtime.JVMCI;
  47 import jdk.vm.ci.services.Services;
  48 
  49 interface GraphPrinter extends Closeable {
  50 
  51     /**
  52      * Starts a new group of graphs with the given name, short name and method byte code index (BCI)
  53      * as properties.
  54      */
  55     void beginGroup(DebugContext debug, String name, String shortName, ResolvedJavaMethod method, int bci, Map<Object, Object> properties) throws IOException;
  56 
  57     /**
  58      * Prints an entire {@link Graph} with the specified title, optionally using short names for
  59      * nodes.
  60      */
  61     void print(DebugContext debug, Graph graph, Map<Object, Object> properties, int id, String format, Object... args) throws IOException;
  62 
  63     SnippetReflectionProvider getSnippetReflectionProvider();
  64 
  65     /**
  66      * Ends the current group.
  67      */
  68     void endGroup() throws IOException;
  69 
  70     @Override
  71     void close();
  72 
  73     /**
  74      * A JVMCI package dynamically exported to trusted modules.
  75      */
  76     String JVMCI_RUNTIME_PACKAGE = JVMCI.class.getPackage().getName();
  77 
  78     /**
  79      * {@code jdk.vm.ci} module.
  80      */
  81     Object JVMCI_MODULE = JDK9Method.JAVA_SPECIFICATION_VERSION < 9 ? null : JDK9Method.getModule.invoke(Services.class);
  82 
  83     /**
  84      * Classes whose {@link #toString()} method does not run any untrusted code.
  85      */
  86     List<Class<?>> TRUSTED_CLASSES = Arrays.asList(
  87                     String.class,
  88                     Class.class,
  89                     Boolean.class,
  90                     Byte.class,
  91                     Character.class,
  92                     Short.class,
  93                     Integer.class,
  94                     Float.class,
  95                     Long.class,
  96                     Double.class);
  97     int MAX_CONSTANT_TO_STRING_LENGTH = 50;
  98 
  99     /**
 100      * Determines if invoking {@link Object#toString()} on an instance of {@code c} will only run
 101      * trusted code.
 102      */
 103     static boolean isToStringTrusted(Class<?> c) {
 104         if (TRUSTED_CLASSES.contains(c)) {
 105             return true;
 106         }
 107         if (JDK9Method.JAVA_SPECIFICATION_VERSION < 9) {
 108             if (c.getClassLoader() == Services.class.getClassLoader()) {
 109                 // Loaded by the JVMCI class loader
 110                 return true;
 111             }
 112         } else {
 113             Object module = JDK9Method.getModule.invoke(c);
 114             if (JVMCI_MODULE == module || (Boolean) JDK9Method.isOpenTo.invoke(JVMCI_MODULE, JVMCI_RUNTIME_PACKAGE, module)) {
 115                 // Can access non-statically-exported package in JVMCI
 116                 return true;
 117             }
 118         }



 119         return false;
 120     }
 121 
 122     /**
 123      * Sets or updates the {@code "rawvalue"} and {@code "toString"} properties in {@code props} for
 124      * {@code cn} if it's a boxed Object value and {@code snippetReflection} can access the raw
 125      * value.
 126      */
 127     default void updateStringPropertiesForConstant(Map<Object, Object> props, ConstantNode cn) {

 128         SnippetReflectionProvider snippetReflection = getSnippetReflectionProvider();
 129         if (snippetReflection != null && cn.getValue() instanceof JavaConstant) {
 130             JavaConstant constant = (JavaConstant) cn.getValue();
 131             if (constant.getJavaKind() == JavaKind.Object) {
 132                 Object obj = snippetReflection.asObject(Object.class, constant);
 133                 if (obj != null) {
 134                     String toString = GraphPrinter.constantToString(obj);














 135                     String rawvalue = GraphPrinter.truncate(toString);
 136                     // Overwrite the value inserted by
 137                     // ConstantNode.getDebugProperties()
 138                     props.put("rawvalue", rawvalue);
 139                     if (!rawvalue.equals(toString)) {
 140                         props.put("toString", toString);
 141                     }
 142                 }
 143             }
 144         }
 145     }
 146 
 147     /**
 148      * Replaces all {@link JavaType} elements in {@code args} with the result of
 149      * {@link JavaType#getUnqualifiedName()}.
 150      *
 151      * @return a copy of {@code args} with the above mentioned substitutions or {@code args} if no
 152      *         substitutions were performed
 153      */
 154     default Object[] simplifyClassArgs(Object... args) {
 155         Object[] res = args;
 156         for (int i = 0; i < args.length; i++) {
 157             Object arg = args[i];
 158             if (arg instanceof JavaType) {
 159                 if (args == res) {
 160                     res = new Object[args.length];
 161                     for (int a = 0; a < i; a++) {
 162                         res[a] = args[a];
 163                     }
 164                 }
 165                 res[i] = ((JavaType) arg).getUnqualifiedName();
 166             } else {
 167                 res[i] = arg;
 168             }
 169         }
 170         return res;
 171     }
 172 
 173     static String truncate(String s) {
 174         if (s.length() > MAX_CONSTANT_TO_STRING_LENGTH) {
 175             return s.substring(0, MAX_CONSTANT_TO_STRING_LENGTH - 3) + "...";
 176         }
 177         return s;
 178     }
 179 
 180     static String constantToString(Object value) {
 181         Class<?> c = value.getClass();
 182         if (c.isArray()) {
 183             return constantArrayToString(value);
 184         } else if (value instanceof Enum) {
 185             return ((Enum<?>) value).name();
 186         } else if (isToStringTrusted(c)) {
 187             return value.toString();
 188         }
 189         return MetaUtil.getSimpleName(c, true) + "@" + Integer.toHexString(System.identityHashCode(value));
 190 
 191     }
 192 
 193     static String constantArrayToString(Object array) {
 194         Class<?> componentType = array.getClass().getComponentType();
 195         assert componentType != null;
 196         int arrayLength = Array.getLength(array);
 197         StringBuilder buf = new StringBuilder(MetaUtil.getSimpleName(componentType, true)).append('[').append(arrayLength).append("]{");
 198         int length = arrayLength;
 199         boolean primitive = componentType.isPrimitive();
 200         for (int i = 0; i < length; i++) {
 201             if (primitive) {
 202                 buf.append(Array.get(array, i));
 203             } else {
 204                 Object o = ((Object[]) array)[i];
 205                 buf.append(o == null ? "null" : constantToString(o));
 206             }
 207             if (i != length - 1) {
 208                 buf.append(", ");
 209             }
 210         }
 211         return buf.append('}').toString();
 212     }
 213 
 214     @SuppressWarnings("try")
 215     static StructuredGraph.ScheduleResult getScheduleOrNull(Graph graph) {
 216         if (graph instanceof StructuredGraph) {
 217             StructuredGraph sgraph = (StructuredGraph) graph;
 218             StructuredGraph.ScheduleResult scheduleResult = sgraph.getLastSchedule();
 219             if (scheduleResult == null) {
 220                 DebugContext debug = graph.getDebug();
 221                 try (Scope scope = debug.disable()) {
 222                     SchedulePhase schedule = new SchedulePhase(graph.getOptions());
 223                     schedule.apply(sgraph);
 224                     scheduleResult = sgraph.getLastSchedule();
 225                 } catch (Throwable t) {
 226                 }
 227             }
 228             return scheduleResult;
 229         }
 230         return null;
 231     }
 232 }
--- EOF ---