1 /* 2 * Copyright (c) 2013, 2019, 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 24 25 package org.graalvm.compiler.core.test; 26 27 import static org.graalvm.compiler.debug.DebugContext.BASIC_LEVEL; 28 29 import java.util.ArrayList; 30 import java.util.Arrays; 31 import java.util.HashSet; 32 import java.util.List; 33 import java.util.Set; 34 35 import org.graalvm.compiler.core.common.type.ObjectStamp; 36 import org.graalvm.compiler.debug.DebugContext; 37 import org.graalvm.compiler.debug.GraalError; 38 import org.graalvm.compiler.graph.Graph; 39 import org.graalvm.compiler.graph.Node; 40 import org.graalvm.compiler.graph.NodeInputList; 41 import org.graalvm.compiler.nodes.CallTargetNode; 42 import org.graalvm.compiler.nodes.Invoke; 43 import org.graalvm.compiler.nodes.NodeView; 44 import org.graalvm.compiler.nodes.StructuredGraph; 45 import org.graalvm.compiler.nodes.ValueNode; 46 import org.graalvm.compiler.nodes.java.MethodCallTargetNode; 47 import org.graalvm.compiler.nodes.java.NewArrayNode; 48 import org.graalvm.compiler.nodes.java.StoreIndexedNode; 49 import org.graalvm.compiler.nodes.spi.CoreProviders; 50 import org.graalvm.compiler.phases.VerifyPhase; 51 52 import jdk.vm.ci.meta.Constant; 53 import jdk.vm.ci.meta.MetaAccessProvider; 54 import jdk.vm.ci.meta.PrimitiveConstant; 55 import jdk.vm.ci.meta.ResolvedJavaMethod; 56 import jdk.vm.ci.meta.ResolvedJavaType; 57 58 /** 59 * Verifies that call sites calling one of the methods in {@link DebugContext} use them correctly. 60 * Correct usage of the methods in {@link DebugContext} requires call sites to not eagerly evaluate 61 * their arguments. Additionally this phase verifies that no argument is the result of a call to 62 * {@link StringBuilder#toString()} or {@link StringBuffer#toString()}. Ideally the parameters at 63 * call sites of {@link DebugContext} are eliminated, and do not produce additional allocations, if 64 * {@link DebugContext#isDumpEnabled(int)} (or {@link DebugContext#isLogEnabled(int)}, ...) is 65 * {@code false}. 66 * 67 * Methods in {@link DebugContext} checked by this phase are various different versions of 68 * {@link DebugContext#log(String)} , {@link DebugContext#dump(int, Object, String)}, 69 * {@link DebugContext#logAndIndent(String)} and {@link DebugContext#verify(Object, String)}. 70 */ 71 public class VerifyDebugUsage extends VerifyPhase<CoreProviders> { 72 73 @Override 74 public boolean checkContract() { 75 return false; 76 } 77 78 MetaAccessProvider metaAccess; 79 80 @Override 81 protected void verify(StructuredGraph graph, CoreProviders context) { 82 metaAccess = context.getMetaAccess(); 83 ResolvedJavaType debugType = metaAccess.lookupJavaType(DebugContext.class); 84 ResolvedJavaType nodeType = metaAccess.lookupJavaType(Node.class); 85 ResolvedJavaType stringType = metaAccess.lookupJavaType(String.class); 86 ResolvedJavaType graalErrorType = metaAccess.lookupJavaType(GraalError.class); 87 88 for (MethodCallTargetNode t : graph.getNodes(MethodCallTargetNode.TYPE)) { 89 ResolvedJavaMethod callee = t.targetMethod(); 90 String calleeName = callee.getName(); 91 if (callee.getDeclaringClass().equals(debugType)) { 92 boolean isDump = calleeName.equals("dump"); 93 if (calleeName.equals("log") || calleeName.equals("logAndIndent") || calleeName.equals("verify") || isDump) { 94 verifyParameters(t, graph, t.arguments(), stringType, isDump ? 2 : 1); 95 } 96 } 97 if (callee.getDeclaringClass().isAssignableFrom(nodeType)) { 98 if (calleeName.equals("assertTrue") || calleeName.equals("assertFalse")) { 99 verifyParameters(t, graph, t.arguments(), stringType, 1); 100 } 101 } 102 if (callee.getDeclaringClass().isAssignableFrom(graalErrorType) && !graph.method().getDeclaringClass().isAssignableFrom(graalErrorType)) { 103 if (calleeName.equals("guarantee")) { 104 verifyParameters(t, graph, t.arguments(), stringType, 0); 105 } 106 if (calleeName.equals("<init>") && callee.getSignature().getParameterCount(false) == 2) { 107 verifyParameters(t, graph, t.arguments(), stringType, 1); 108 } 109 } 110 } 111 } 112 113 private void verifyParameters(MethodCallTargetNode callTarget, StructuredGraph callerGraph, NodeInputList<? extends ValueNode> args, ResolvedJavaType stringType, int startArgIdx) { 114 if (callTarget.targetMethod().isVarArgs() && args.get(args.count() - 1) instanceof NewArrayNode) { 115 // unpack the arguments to the var args 116 List<ValueNode> unpacked = new ArrayList<>(args.snapshot()); 117 NewArrayNode varArgParameter = (NewArrayNode) unpacked.remove(unpacked.size() - 1); 118 int firstVarArg = unpacked.size(); 119 for (Node usage : varArgParameter.usages()) { 120 if (usage instanceof StoreIndexedNode) { 121 StoreIndexedNode si = (StoreIndexedNode) usage; 122 unpacked.add(si.value()); 123 } 124 } 125 verifyParameters(callerGraph, callTarget, unpacked, stringType, startArgIdx, firstVarArg); 126 } else { 127 verifyParameters(callerGraph, callTarget, args, stringType, startArgIdx, -1); 128 } 129 } 130 131 private static final Set<Integer> DebugLevels = new HashSet<>( 132 Arrays.asList(DebugContext.ENABLED_LEVEL, BASIC_LEVEL, DebugContext.INFO_LEVEL, DebugContext.VERBOSE_LEVEL, DebugContext.DETAILED_LEVEL, DebugContext.VERY_DETAILED_LEVEL)); 133 134 /** 135 * The set of methods allowed to call a {@code Debug.dump(...)} method with the {@code level} 136 * parameter bound to {@link DebugContext#BASIC_LEVEL} and the {@code object} parameter bound to 137 * a {@link StructuredGraph} value. 138 * 139 * This whitelist exists to ensure any increase in graph dumps is in line with the policy 140 * outlined by {@link DebugContext#BASIC_LEVEL}. If you add a *justified* graph dump at this 141 * level, then update the whitelist. 142 */ 143 private static final Set<String> BasicLevelStructuredGraphDumpWhitelist = new HashSet<>(Arrays.asList( 144 "org.graalvm.compiler.phases.BasePhase.dumpAfter", 145 "org.graalvm.compiler.phases.BasePhase.dumpBefore", 146 "org.graalvm.compiler.core.GraalCompiler.emitFrontEnd", 147 "org.graalvm.compiler.truffle.compiler.PartialEvaluator.fastPartialEvaluation", 148 "org.graalvm.compiler.truffle.compiler.PartialEvaluator$PerformanceInformationHandler.reportPerformanceWarnings", 149 "org.graalvm.compiler.truffle.compiler.TruffleCompilerImpl.compilePEGraph", 150 "org.graalvm.compiler.core.test.VerifyDebugUsageTest$ValidDumpUsagePhase.run", 151 "org.graalvm.compiler.core.test.VerifyDebugUsageTest$InvalidConcatDumpUsagePhase.run", 152 "org.graalvm.compiler.core.test.VerifyDebugUsageTest$InvalidDumpUsagePhase.run", 153 "org.graalvm.compiler.hotspot.SymbolicSnippetEncoder.verifySnippetEncodeDecode", 154 "org.graalvm.compiler.truffle.compiler.phases.inlining.CallTree.dumpBasic")); 155 156 /** 157 * The set of methods allowed to call a {@code Debug.dump(...)} method with the {@code level} 158 * parameter bound to {@link DebugContext#INFO_LEVEL} and the {@code object} parameter bound to 159 * a {@link StructuredGraph} value. 160 * 161 * This whitelist exists to ensure any increase in graph dumps is in line with the policy 162 * outlined by {@link DebugContext#INFO_LEVEL}. If you add a *justified* graph dump at this 163 * level, then update the whitelist. 164 */ 165 private static final Set<String> InfoLevelStructuredGraphDumpWhitelist = new HashSet<>(Arrays.asList( 166 "org.graalvm.compiler.core.GraalCompiler.emitFrontEnd", 167 "org.graalvm.compiler.phases.BasePhase.dumpAfter", 168 "org.graalvm.compiler.replacements.ReplacementsImpl$GraphMaker.makeGraph", 169 "org.graalvm.compiler.replacements.SnippetTemplate.instantiate", 170 "org.graalvm.compiler.replacements.SnippetTemplate.<init>", 171 "org.graalvm.compiler.hotspot.SymbolicSnippetEncoder.verifySnippetEncodeDecode", 172 "org.graalvm.compiler.truffle.compiler.phases.inlining.CallTree.dumpInfo")); 173 174 private void verifyParameters(StructuredGraph callerGraph, MethodCallTargetNode debugCallTarget, List<? extends ValueNode> args, ResolvedJavaType stringType, int startArgIdx, 175 int varArgsIndex) { 176 ResolvedJavaMethod verifiedCallee = debugCallTarget.targetMethod(); 177 Integer dumpLevel = null; 178 int argIdx = startArgIdx; 179 int varArgsElementIndex = 0; 180 boolean reportVarArgs = false; 181 for (int i = 0; i < args.size(); i++) { 182 ValueNode arg = args.get(i); 183 if (arg instanceof Invoke) { 184 reportVarArgs = varArgsIndex >= 0 && argIdx >= varArgsIndex; 185 Invoke invoke = (Invoke) arg; 186 CallTargetNode callTarget = invoke.callTarget(); 187 if (callTarget instanceof MethodCallTargetNode) { 188 ResolvedJavaMethod m = ((MethodCallTargetNode) callTarget).targetMethod(); 189 if (m.getName().equals("toString")) { 190 int bci = invoke.bci(); 191 int nonVarArgIdx = reportVarArgs ? argIdx - varArgsElementIndex : argIdx; 192 verifyStringConcat(callerGraph, verifiedCallee, bci, nonVarArgIdx, reportVarArgs ? varArgsElementIndex : -1, m); 193 verifyToStringCall(callerGraph, verifiedCallee, stringType, m, bci, nonVarArgIdx, reportVarArgs ? varArgsElementIndex : -1); 194 } else if (m.getName().equals("format")) { 195 int bci = invoke.bci(); 196 int nonVarArgIdx = reportVarArgs ? argIdx - varArgsElementIndex : argIdx; 197 verifyFormatCall(callerGraph, verifiedCallee, stringType, m, bci, nonVarArgIdx, reportVarArgs ? varArgsElementIndex : -1); 198 199 } 200 } 201 } 202 if (i == 1) { 203 if (verifiedCallee.getName().equals("dump")) { 204 dumpLevel = verifyDumpLevelParameter(callerGraph, debugCallTarget, verifiedCallee, arg); 205 } 206 } else if (i == 2) { 207 if (dumpLevel != null) { 208 verifyDumpObjectParameter(callerGraph, debugCallTarget, arg, verifiedCallee, dumpLevel); 209 } 210 } 211 if (varArgsIndex >= 0 && i >= varArgsIndex) { 212 varArgsElementIndex++; 213 } 214 argIdx++; 215 } 216 } 217 218 /** 219 * The {@code level} arg for the {@code Debug.dump(...)} methods must be a reference to one of 220 * the {@code Debug.*_LEVEL} constants. 221 */ 222 protected Integer verifyDumpLevelParameter(StructuredGraph callerGraph, MethodCallTargetNode debugCallTarget, ResolvedJavaMethod verifiedCallee, ValueNode arg) 223 throws org.graalvm.compiler.phases.VerifyPhase.VerificationError { 224 // The 'level' arg for the Debug.dump(...) methods must be a reference to one of 225 // the Debug.*_LEVEL constants. 226 227 Constant c = arg.asConstant(); 228 if (c != null) { 229 Integer dumpLevel = ((PrimitiveConstant) c).asInt(); 230 if (!DebugLevels.contains(dumpLevel)) { 231 StackTraceElement e = callerGraph.method().asStackTraceElement(debugCallTarget.invoke().bci()); 232 throw new VerificationError( 233 "In %s: parameter 0 of call to %s does not match a Debug.*_LEVEL constant: %s.%n", e, verifiedCallee.format("%H.%n(%p)"), dumpLevel); 234 } 235 return dumpLevel; 236 } 237 StackTraceElement e = callerGraph.method().asStackTraceElement(debugCallTarget.invoke().bci()); 238 throw new VerificationError( 239 "In %s: parameter 0 of call to %s must be a constant, not %s.%n", e, verifiedCallee.format("%H.%n(%p)"), arg); 240 } 241 242 protected void verifyDumpObjectParameter(StructuredGraph callerGraph, MethodCallTargetNode debugCallTarget, ValueNode arg, ResolvedJavaMethod verifiedCallee, Integer dumpLevel) 243 throws org.graalvm.compiler.phases.VerifyPhase.VerificationError { 244 ResolvedJavaType argType = ((ObjectStamp) arg.stamp(NodeView.DEFAULT)).type(); 245 if (metaAccess.lookupJavaType(Graph.class).isAssignableFrom(argType)) { 246 verifyStructuredGraphDumping(callerGraph, debugCallTarget, verifiedCallee, dumpLevel); 247 } 248 } 249 250 /** 251 * Verifies that dumping a {@link StructuredGraph} at level {@link DebugContext#BASIC_LEVEL} or 252 * {@link DebugContext#INFO_LEVEL} only occurs in white-listed methods. 253 */ 254 protected void verifyStructuredGraphDumping(StructuredGraph callerGraph, MethodCallTargetNode debugCallTarget, ResolvedJavaMethod verifiedCallee, Integer dumpLevel) 255 throws org.graalvm.compiler.phases.VerifyPhase.VerificationError { 256 if (dumpLevel == DebugContext.BASIC_LEVEL) { 257 StackTraceElement e = callerGraph.method().asStackTraceElement(debugCallTarget.invoke().bci()); 258 String qualifiedMethod = e.getClassName() + "." + e.getMethodName(); 259 if (!BasicLevelStructuredGraphDumpWhitelist.contains(qualifiedMethod)) { 260 throw new VerificationError( 261 "In %s: call to %s with level == DebugContext.BASIC_LEVEL not in %s.BasicLevelDumpWhitelist.%n", e, verifiedCallee.format("%H.%n(%p)"), 262 getClass().getName()); 263 } 264 } else if (dumpLevel == DebugContext.INFO_LEVEL) { 265 StackTraceElement e = callerGraph.method().asStackTraceElement(debugCallTarget.invoke().bci()); 266 String qualifiedMethod = e.getClassName() + "." + e.getMethodName(); 267 if (!InfoLevelStructuredGraphDumpWhitelist.contains(qualifiedMethod)) { 268 throw new VerificationError( 269 "In %s: call to %s with level == Debug.INFO_LEVEL not in %s.InfoLevelDumpWhitelist.%n", e, verifiedCallee.format("%H.%n(%p)"), 270 getClass().getName()); 271 } 272 } 273 } 274 275 /** 276 * Checks that a given call is not to {@link StringBuffer#toString()} or 277 * {@link StringBuilder#toString()}. 278 */ 279 private static void verifyStringConcat(StructuredGraph callerGraph, ResolvedJavaMethod verifiedCallee, int bci, int argIdx, int varArgsElementIndex, ResolvedJavaMethod callee) { 280 if (callee.getDeclaringClass().getName().equals("Ljava/lang/StringBuilder;") || callee.getDeclaringClass().getName().equals("Ljava/lang/StringBuffer;")) { 281 StackTraceElement e = callerGraph.method().asStackTraceElement(bci); 282 if (varArgsElementIndex >= 0) { 283 throw new VerificationError( 284 "In %s: element %d of parameter %d of call to %s appears to be a String concatenation expression.%n", e, varArgsElementIndex, argIdx, 285 verifiedCallee.format("%H.%n(%p)")); 286 } else { 287 throw new VerificationError( 288 "In %s: parameter %d of call to %s appears to be a String concatenation expression.", e, argIdx, verifiedCallee.format("%H.%n(%p)")); 289 } 290 } 291 } 292 293 /** 294 * Checks that a given call is not to {@link Object#toString()}. 295 */ 296 private static void verifyToStringCall(StructuredGraph callerGraph, ResolvedJavaMethod verifiedCallee, ResolvedJavaType stringType, ResolvedJavaMethod callee, int bci, int argIdx, 297 int varArgsElementIndex) { 298 if (callee.getSignature().getParameterCount(false) == 0 && callee.getSignature().getReturnType(callee.getDeclaringClass()).equals(stringType)) { 299 StackTraceElement e = callerGraph.method().asStackTraceElement(bci); 300 if (varArgsElementIndex >= 0) { 301 throw new VerificationError( 302 "In %s: element %d of parameter %d of call to %s is a call to toString() which is redundant (the callee will do it) and forces unnecessary eager evaluation.", 303 e, varArgsElementIndex, argIdx, verifiedCallee.format("%H.%n(%p)")); 304 } else { 305 throw new VerificationError("In %s: parameter %d of call to %s is a call to toString() which is redundant (the callee will do it) and forces unnecessary eager evaluation.", e, argIdx, 306 verifiedCallee.format("%H.%n(%p)")); 307 } 308 } 309 } 310 311 /** 312 * Checks that a given call is not to {@link String#format(String, Object...)} or 313 * {@link String#format(java.util.Locale, String, Object...)}. 314 */ 315 private static void verifyFormatCall(StructuredGraph callerGraph, ResolvedJavaMethod verifiedCallee, ResolvedJavaType stringType, ResolvedJavaMethod callee, int bci, int argIdx, 316 int varArgsElementIndex) { 317 if (callee.getDeclaringClass().equals(stringType) && callee.getSignature().getReturnType(callee.getDeclaringClass()).equals(stringType)) { 318 StackTraceElement e = callerGraph.method().asStackTraceElement(bci); 319 if (varArgsElementIndex >= 0) { 320 throw new VerificationError( 321 "In %s: element %d of parameter %d of call to %s is a call to String.format() which is redundant (%s does formatting) and forces unnecessary eager evaluation.", 322 e, varArgsElementIndex, argIdx, verifiedCallee.format("%H.%n(%p)"), verifiedCallee.format("%h.%n")); 323 } else { 324 throw new VerificationError("In %s: parameter %d of call to %s is a call to String.format() which is redundant (%s does formatting) and forces unnecessary eager evaluation.", e, 325 argIdx, 326 verifiedCallee.format("%H.%n(%p)"), verifiedCallee.format("%h.%n")); 327 } 328 } 329 } 330 }