1 /*
   2  * Copyright (c) 2017, 2018, 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.gen;
  26 
  27 import java.util.ArrayDeque;
  28 import java.util.Arrays;
  29 import java.util.Queue;
  30 
  31 import jdk.internal.vm.compiler.collections.EconomicMap;
  32 import jdk.internal.vm.compiler.collections.Equivalence;
  33 import org.graalvm.compiler.debug.CounterKey;
  34 import org.graalvm.compiler.debug.DebugContext;
  35 import org.graalvm.compiler.debug.GraalError;
  36 import org.graalvm.compiler.lir.ConstantValue;
  37 import org.graalvm.compiler.lir.LIRFrameState;
  38 import org.graalvm.compiler.lir.LabelRef;
  39 import org.graalvm.compiler.lir.Variable;
  40 import org.graalvm.compiler.nodes.ConstantNode;
  41 import org.graalvm.compiler.nodes.FrameState;
  42 import org.graalvm.compiler.nodes.ValueNode;
  43 import org.graalvm.compiler.nodes.spi.NodeValueMap;
  44 import org.graalvm.compiler.nodes.util.GraphUtil;
  45 import org.graalvm.compiler.nodes.virtual.EscapeObjectState;
  46 import org.graalvm.compiler.nodes.virtual.VirtualObjectNode;
  47 import org.graalvm.compiler.virtual.nodes.MaterializedObjectState;
  48 import org.graalvm.compiler.virtual.nodes.VirtualObjectState;
  49 
  50 import jdk.vm.ci.code.BytecodeFrame;
  51 import jdk.vm.ci.code.VirtualObject;
  52 import jdk.vm.ci.meta.JavaConstant;
  53 import jdk.vm.ci.meta.JavaKind;
  54 import jdk.vm.ci.meta.JavaType;
  55 import jdk.vm.ci.meta.JavaValue;
  56 import jdk.vm.ci.meta.ResolvedJavaField;
  57 import jdk.vm.ci.meta.ResolvedJavaType;
  58 import jdk.vm.ci.meta.Value;
  59 
  60 /**
  61  * Builds {@link LIRFrameState}s from {@link FrameState}s.
  62  */
  63 public class DebugInfoBuilder {
  64 
  65     protected final NodeValueMap nodeValueMap;
  66     protected final DebugContext debug;
  67 
  68     public DebugInfoBuilder(NodeValueMap nodeValueMap, DebugContext debug) {
  69         this.nodeValueMap = nodeValueMap;
  70         this.debug = debug;
  71     }
  72 
  73     private static final JavaValue[] NO_JAVA_VALUES = {};
  74     private static final JavaKind[] NO_JAVA_KINDS = {};
  75 
  76     protected final EconomicMap<VirtualObjectNode, VirtualObject> virtualObjects = EconomicMap.create(Equivalence.IDENTITY);
  77     protected final EconomicMap<VirtualObjectNode, EscapeObjectState> objectStates = EconomicMap.create(Equivalence.IDENTITY);
  78 
  79     protected final Queue<VirtualObjectNode> pendingVirtualObjects = new ArrayDeque<>();
  80 
  81     public LIRFrameState build(FrameState topState, LabelRef exceptionEdge) {
  82         assert virtualObjects.size() == 0;
  83         assert objectStates.size() == 0;
  84         assert pendingVirtualObjects.size() == 0;
  85 
  86         // collect all VirtualObjectField instances:
  87         FrameState current = topState;
  88         do {
  89             if (current.virtualObjectMappingCount() > 0) {
  90                 for (EscapeObjectState state : current.virtualObjectMappings()) {
  91                     if (!objectStates.containsKey(state.object())) {
  92                         if (!(state instanceof MaterializedObjectState) || ((MaterializedObjectState) state).materializedValue() != state.object()) {
  93                             objectStates.put(state.object(), state);
  94                         }
  95                     }
  96                 }
  97             }
  98             current = current.outerFrameState();
  99         } while (current != null);
 100 
 101         BytecodeFrame frame = computeFrameForState(topState);
 102 
 103         VirtualObject[] virtualObjectsArray = null;
 104         if (virtualObjects.size() != 0) {
 105             // fill in the VirtualObject values
 106             VirtualObjectNode vobjNode;
 107             while ((vobjNode = pendingVirtualObjects.poll()) != null) {
 108                 VirtualObject vobjValue = virtualObjects.get(vobjNode);
 109                 assert vobjValue.getValues() == null;
 110 
 111                 JavaValue[] values;
 112                 JavaKind[] slotKinds;
 113                 int entryCount = vobjNode.entryCount();
 114                 if (entryCount == 0) {
 115                     values = NO_JAVA_VALUES;
 116                     slotKinds = NO_JAVA_KINDS;
 117                 } else {
 118                     values = new JavaValue[entryCount];
 119                     slotKinds = new JavaKind[entryCount];
 120                 }
 121                 if (values.length > 0) {
 122                     VirtualObjectState currentField = (VirtualObjectState) objectStates.get(vobjNode);
 123                     assert currentField != null;
 124                     int pos = 0;
 125                     for (int i = 0; i < entryCount; i++) {
 126                         ValueNode value = currentField.values().get(i);
 127                         if (value == null) {
 128                             JavaKind entryKind = vobjNode.entryKind(i);
 129                             values[pos] = JavaConstant.defaultForKind(entryKind.getStackKind());
 130                             slotKinds[pos] = entryKind.getStackKind();
 131                             pos++;
 132                         } else if (!value.isConstant() || value.asJavaConstant().getJavaKind() != JavaKind.Illegal) {
 133                             values[pos] = toJavaValue(value);
 134                             slotKinds[pos] = toSlotKind(value);
 135                             pos++;
 136                         } else {
 137                             assert value.getStackKind() == JavaKind.Illegal;
 138                             ValueNode previousValue = currentField.values().get(i - 1);
 139                             assert (previousValue != null && previousValue.getStackKind().needsTwoSlots()) : vobjNode + " " + i +
 140                                             " " + previousValue + " " + currentField.values().snapshot();
 141                             if (previousValue == null || !previousValue.getStackKind().needsTwoSlots()) {
 142                                 // Don't allow the IllegalConstant to leak into the debug info
 143                                 JavaKind entryKind = vobjNode.entryKind(i);
 144                                 values[pos] = JavaConstant.defaultForKind(entryKind.getStackKind());
 145                                 slotKinds[pos] = entryKind.getStackKind();
 146                                 pos++;
 147                             }
 148                         }
 149                     }
 150                     if (pos != entryCount) {
 151                         values = Arrays.copyOf(values, pos);
 152                         slotKinds = Arrays.copyOf(slotKinds, pos);
 153                     }
 154                 }
 155                 assert checkValues(vobjValue.getType(), values, slotKinds);
 156                 vobjValue.setValues(values, slotKinds);
 157             }
 158 
 159             virtualObjectsArray = new VirtualObject[virtualObjects.size()];
 160             int index = 0;
 161             for (VirtualObject value : virtualObjects.getValues()) {
 162                 virtualObjectsArray[index++] = value;
 163             }
 164             virtualObjects.clear();
 165         }
 166         objectStates.clear();
 167 
 168         return newLIRFrameState(exceptionEdge, frame, virtualObjectsArray);
 169     }
 170 
 171     private boolean checkValues(ResolvedJavaType type, JavaValue[] values, JavaKind[] slotKinds) {
 172         assert (values == null) == (slotKinds == null);
 173         if (values != null) {
 174             assert values.length == slotKinds.length;
 175             if (!type.isArray()) {
 176                 ResolvedJavaField[] fields = type.getInstanceFields(true);
 177                 int fieldIndex = 0;
 178                 for (int valueIndex = 0; valueIndex < values.length; valueIndex++, fieldIndex++) {
 179                     ResolvedJavaField field = fields[fieldIndex];
 180                     JavaKind valKind = slotKinds[valueIndex].getStackKind();
 181                     JavaKind fieldKind = storageKind(field.getType());
 182                     if ((valKind == JavaKind.Double || valKind == JavaKind.Long) && fieldKind == JavaKind.Int) {
 183                         assert fieldIndex + 1 < fields.length : String.format("Not enough fields for fieldIndex = %d valueIndex = %d %s %s", fieldIndex, valueIndex, Arrays.toString(fields),
 184                                         Arrays.toString(values));
 185                         assert storageKind(fields[fieldIndex + 1].getType()) == JavaKind.Int : String.format("fieldIndex = %d valueIndex = %d %s %s %s", fieldIndex, valueIndex,
 186                                         storageKind(fields[fieldIndex + 1].getType()), Arrays.toString(fields),
 187                                         Arrays.toString(values));
 188                         fieldIndex++;
 189                     } else {
 190                         assert valKind == fieldKind.getStackKind() : field + ": " + valKind + " != " + fieldKind;
 191                     }
 192                 }
 193                 assert fields.length == fieldIndex : type + ": fields=" + Arrays.toString(fields) + ", field values=" + Arrays.toString(values);
 194             } else {
 195                 JavaKind componentKind = storageKind(type.getComponentType()).getStackKind();
 196                 if (componentKind == JavaKind.Object) {
 197                     for (int i = 0; i < values.length; i++) {
 198                         assert slotKinds[i].isObject() : slotKinds[i] + " != " + componentKind;
 199                     }
 200                 } else {
 201                     for (int i = 0; i < values.length; i++) {
 202                         assert slotKinds[i] == componentKind || componentKind.getBitCount() >= slotKinds[i].getBitCount() ||
 203                                         (componentKind == JavaKind.Int && slotKinds[i].getBitCount() >= JavaKind.Int.getBitCount()) : slotKinds[i] + " != " + componentKind;
 204                     }
 205                 }
 206             }
 207         }
 208         return true;
 209     }
 210 
 211     /*
 212      * Customization point for subclasses. For example, Word types have a kind Object, but are
 213      * internally stored as a primitive value. We do not know about Word types here, but subclasses
 214      * do know.
 215      */
 216     protected JavaKind storageKind(JavaType type) {
 217         return type.getJavaKind();
 218     }
 219 
 220     protected LIRFrameState newLIRFrameState(LabelRef exceptionEdge, BytecodeFrame frame, VirtualObject[] virtualObjectsArray) {
 221         return new LIRFrameState(frame, virtualObjectsArray, exceptionEdge);
 222     }
 223 
 224     protected BytecodeFrame computeFrameForState(FrameState state) {
 225         try {
 226             assert state.bci != BytecodeFrame.INVALID_FRAMESTATE_BCI;
 227             assert state.bci != BytecodeFrame.UNKNOWN_BCI;
 228             assert state.bci != BytecodeFrame.BEFORE_BCI || state.locksSize() == 0;
 229             assert state.bci != BytecodeFrame.AFTER_BCI || state.locksSize() == 0;
 230             assert state.bci != BytecodeFrame.AFTER_EXCEPTION_BCI || state.locksSize() == 0;
 231             assert !(state.getMethod().isSynchronized() && state.bci != BytecodeFrame.BEFORE_BCI && state.bci != BytecodeFrame.AFTER_BCI && state.bci != BytecodeFrame.AFTER_EXCEPTION_BCI) ||
 232                             state.locksSize() > 0;
 233             assert state.verify();
 234 
 235             int numLocals = state.localsSize();
 236             int numStack = state.stackSize();
 237             int numLocks = state.locksSize();
 238 
 239             int numValues = numLocals + numStack + numLocks;
 240             int numKinds = numLocals + numStack;
 241 
 242             JavaValue[] values = numValues == 0 ? NO_JAVA_VALUES : new JavaValue[numValues];
 243             JavaKind[] slotKinds = numKinds == 0 ? NO_JAVA_KINDS : new JavaKind[numKinds];
 244             computeLocals(state, numLocals, values, slotKinds);
 245             computeStack(state, numLocals, numStack, values, slotKinds);
 246             computeLocks(state, values);
 247 
 248             BytecodeFrame caller = null;
 249             if (state.outerFrameState() != null) {
 250                 caller = computeFrameForState(state.outerFrameState());
 251             }
 252 
 253             if (!state.canProduceBytecodeFrame()) {
 254                 // This typically means a snippet or intrinsic frame state made it to the backend
 255                 String ste = state.getCode() != null ? state.getCode().asStackTraceElement(state.bci).toString() : state.toString();
 256                 throw new GraalError("Frame state for %s cannot be converted to a BytecodeFrame since the frame state's code is " +
 257                                 "not the same as the frame state method's code", ste);
 258             }
 259 
 260             return new BytecodeFrame(caller, state.getMethod(), state.bci, state.rethrowException(), state.duringCall(), values, slotKinds, numLocals, numStack, numLocks);
 261         } catch (GraalError e) {
 262             throw e.addContext("FrameState: ", state);
 263         }
 264     }
 265 
 266     protected void computeLocals(FrameState state, int numLocals, JavaValue[] values, JavaKind[] slotKinds) {
 267         for (int i = 0; i < numLocals; i++) {
 268             ValueNode local = state.localAt(i);
 269             values[i] = toJavaValue(local);
 270             slotKinds[i] = toSlotKind(local);
 271         }
 272     }
 273 
 274     protected void computeStack(FrameState state, int numLocals, int numStack, JavaValue[] values, JavaKind[] slotKinds) {
 275         for (int i = 0; i < numStack; i++) {
 276             ValueNode stack = state.stackAt(i);
 277             values[numLocals + i] = toJavaValue(stack);
 278             slotKinds[numLocals + i] = toSlotKind(stack);
 279         }
 280     }
 281 
 282     protected void computeLocks(FrameState state, JavaValue[] values) {
 283         for (int i = 0; i < state.locksSize(); i++) {
 284             values[state.localsSize() + state.stackSize() + i] = computeLockValue(state, i);
 285         }
 286     }
 287 
 288     protected JavaValue computeLockValue(FrameState state, int i) {
 289         return toJavaValue(state.lockAt(i));
 290     }
 291 
 292     private static final CounterKey STATE_VIRTUAL_OBJECTS = DebugContext.counter("StateVirtualObjects");
 293     private static final CounterKey STATE_ILLEGALS = DebugContext.counter("StateIllegals");
 294     private static final CounterKey STATE_VARIABLES = DebugContext.counter("StateVariables");
 295     private static final CounterKey STATE_CONSTANTS = DebugContext.counter("StateConstants");
 296 
 297     private static JavaKind toSlotKind(ValueNode value) {
 298         if (value == null) {
 299             return JavaKind.Illegal;
 300         } else {
 301             return value.getStackKind();
 302         }
 303     }
 304 
 305     protected JavaValue toJavaValue(ValueNode value) {
 306         try {
 307             if (value instanceof VirtualObjectNode) {
 308                 VirtualObjectNode obj = (VirtualObjectNode) value;
 309                 EscapeObjectState state = objectStates.get(obj);
 310                 if (state == null && obj.entryCount() > 0) {
 311                     // null states occur for objects with 0 fields
 312                     throw new GraalError("no mapping found for virtual object %s", obj);
 313                 }
 314                 if (state instanceof MaterializedObjectState) {
 315                     return toJavaValue(((MaterializedObjectState) state).materializedValue());
 316                 } else {
 317                     assert obj.entryCount() == 0 || state instanceof VirtualObjectState;
 318                     VirtualObject vobject = virtualObjects.get(obj);
 319                     if (vobject == null) {
 320                         vobject = VirtualObject.get(obj.type(), virtualObjects.size());
 321                         virtualObjects.put(obj, vobject);
 322                         pendingVirtualObjects.add(obj);
 323                     }
 324                     STATE_VIRTUAL_OBJECTS.increment(debug);
 325                     return vobject;
 326                 }
 327             } else {
 328                 // Remove proxies from constants so the constant can be directly embedded.
 329                 ValueNode unproxied = GraphUtil.unproxify(value);
 330                 if (unproxied instanceof ConstantNode) {
 331                     STATE_CONSTANTS.increment(debug);
 332                     return unproxied.asJavaConstant();
 333 
 334                 } else if (value != null) {
 335                     STATE_VARIABLES.increment(debug);
 336                     Value operand = nodeValueMap.operand(value);
 337                     if (operand instanceof ConstantValue && ((ConstantValue) operand).isJavaConstant()) {
 338                         return ((ConstantValue) operand).getJavaConstant();
 339                     } else {
 340                         assert operand instanceof Variable : operand + " for " + value;
 341                         return (JavaValue) operand;
 342                     }
 343 
 344                 } else {
 345                     // return a dummy value because real value not needed
 346                     STATE_ILLEGALS.increment(debug);
 347                     return Value.ILLEGAL;
 348                 }
 349             }
 350         } catch (GraalError e) {
 351             throw e.addContext("toValue: ", value);
 352         }
 353     }
 354 }