private void encodeFrameDatas() { UnsafeArrayTypeWriter encodingBuffer = UnsafeArrayTypeWriter.create(ByteArrayReader.supportsUnalignedMemoryAccess()); for (FrameData data : allDebugInfos) { data.indexInEncodings = encodingBuffer.getBytesWritten(); encodeFrameData(data, encodingBuffer); } frameInfoEncodings = encodingBuffer.toArray(newByteArray(TypeConversion.asS4(encodingBuffer.getBytesWritten()))); }
private static void writeSizeEncoding(UnsafeArrayTypeWriter writeBuffer, IPData data, int entryFlags) { switch (CodeInfoDecoder.extractFS(entryFlags)) { case CodeInfoDecoder.FS_SIZE_S1: writeBuffer.putS1(data.frameSizeEncoding); break; case CodeInfoDecoder.FS_SIZE_S2: writeBuffer.putS2(data.frameSizeEncoding); break; case CodeInfoDecoder.FS_SIZE_S4: writeBuffer.putS4(data.frameSizeEncoding); break; } }
private void encodeValues(ValueInfo[] valueInfos, UnsafeArrayTypeWriter encodingBuffer) { encodingBuffer.putUV(valueInfos.length); for (ValueInfo valueInfo : valueInfos) { if (valueInfo.type == ValueType.Constant) { if (valueInfo.kind == JavaKind.Object) { valueInfo.data = objectConstants.getIndex(valueInfo.value); } else { valueInfo.data = encodePrimitiveConstant(valueInfo.value); } } encodingBuffer.putU1(encodeFlags(valueInfo.type, valueInfo.kind, valueInfo.isCompressedReference)); if (valueInfo.type.hasData) { encodingBuffer.putSV(valueInfo.data); } } }
private static void writeReferenceMapIndex(UnsafeArrayTypeWriter writeBuffer, IPData data, int entryFlags) { switch (CodeInfoDecoder.extractRM(entryFlags)) { case CodeInfoDecoder.RM_INDEX_U2: writeBuffer.putU2(data.referenceMapIndex); break; case CodeInfoDecoder.RM_INDEX_U4: writeBuffer.putU4(data.referenceMapIndex); break; } }
@Platforms(Platform.HOSTED_ONLY.class) public static byte[] encode(LineNumberTable table) { if (table == null) { return null; } int[] lineNumbers = table.getLineNumbers(); int[] bcis = table.getBcis(); assert lineNumbers.length == bcis.length; UnsafeArrayTypeWriter encodingBuffer = UnsafeArrayTypeWriter.create(ByteArrayReader.supportsUnalignedMemoryAccess()); int lastLineNumber = 0; int lastBci = 0; encodingBuffer.putUV(lineNumbers.length); for (int i = 0; i < lineNumbers.length; i++) { encodingBuffer.putSV(lineNumbers[i] - lastLineNumber); encodingBuffer.putSV(bcis[i] - lastBci); lastLineNumber = lineNumbers[i]; lastBci = bcis[i]; } byte[] encodedTable = encodingBuffer.toArray(new byte[TypeConversion.asS4(encodingBuffer.getBytesWritten())]); assert verifyTable(table, decode(encodedTable)); return encodedTable; }
UnsafeArrayTypeWriter indexBuffer = UnsafeArrayTypeWriter.create(ByteArrayReader.supportsUnalignedMemoryAccess()); UnsafeArrayTypeWriter encodingBuffer = UnsafeArrayTypeWriter.create(ByteArrayReader.supportsUnalignedMemoryAccess()); for (IPData data = first; data != null; data = data.next) { assert data.ip <= nextIndexIP; if (data.ip == nextIndexIP) { indexBuffer.putU4(encodingBuffer.getBytesWritten()); nextIndexIP += CodeInfoDecoder.indexGranularity(); entryFlags = entryFlags | flagsForDeoptFrameInfo(data) << CodeInfoDecoder.FI_SHIFT; encodingBuffer.putU1(entryFlags); encodingBuffer.putU1(data.next == null ? CodeInfoDecoder.DELTA_END_OF_TABLE : (data.next.ip - data.ip)); codeInfoIndex = indexBuffer.toArray(newByteArray(TypeConversion.asU4(indexBuffer.getBytesWritten()))); codeInfoEncodings = encodingBuffer.toArray(newByteArray(TypeConversion.asU4(encodingBuffer.getBytesWritten())));
private long encodeSourcePositions(NodeSourcePosition sourcePosition, EconomicMap<NodeSourcePosition, Long> sourcePositionStartOffsets, UnsafeArrayTypeWriter encodingBuffer) { Long existingAbsoluteOffset = sourcePositionStartOffsets.get(sourcePosition); if (existingAbsoluteOffset != null) { return existingAbsoluteOffset; } long callerAbsoluteOffset = -1; if (sourcePosition.getCaller() != null) { callerAbsoluteOffset = encodeSourcePositions(sourcePosition.getCaller(), sourcePositionStartOffsets, encodingBuffer); } long startAbsoluteOffset = encodingBuffer.getBytesWritten(); long callerRelativeOffset = DeoptimizationSourcePositionDecoder.NO_CALLER; if (sourcePosition.getCaller() != null) { callerRelativeOffset = startAbsoluteOffset - callerAbsoluteOffset; assert callerRelativeOffset > DeoptimizationSourcePositionDecoder.NO_CALLER; } encodingBuffer.putUV(callerRelativeOffset); encodingBuffer.putSV(sourcePosition.getBCI()); encodingBuffer.putUV(objectConstants.getIndex(sourcePosition.getMethod())); sourcePositionStartOffsets.put(sourcePosition, startAbsoluteOffset); return startAbsoluteOffset; }
public byte[] getEncoding() { return writer.toArray(new byte[TypeConversion.asS4(writer.getBytesWritten())]); }
nodeStartOffsets[orderId] = writer.getBytesWritten(); writer.putUV(nodeClasses.getIndex(nodeClass)); writeEdges(node, nodeClass.getEdges(Edges.Type.Inputs), nodeOrder); writeProperties(node, nodeClass.getData()); writer.putUV(merge.phis().count()); for (PhiNode phi : merge.phis()) { writeOrderId(phi.valueAt(end), nodeOrder); writeOrderId(exit.stateAfter(), nodeOrder); writer.putUV(exit.proxies().count()); for (ProxyNode proxy : exit.proxies()) { writeOrderId(proxy, nodeOrder); int metadataStart = TypeConversion.asS4(writer.getBytesWritten()); writer.putUV(nodeOrder.maxFixedNodeOrderId); writer.putUV(nodeCount); for (int i = 0; i < nodeCount; i++) { writer.putUV(metadataStart - nodeStartOffsets[i]);
protected void writeProperties(Node node, Fields fields) { writeObjectId(node.getNodeSourcePosition()); for (int idx = 0; idx < fields.getCount(); idx++) { if (fields.getType(idx).isPrimitive()) { long primitive = fields.getRawPrimitive(node, idx); writer.putSV(primitive); } else { Object property = fields.get(node, idx); writeObjectId(property); } } }
private static void writeDeoptFrameInfo(UnsafeArrayTypeWriter writeBuffer, IPData data, int entryFlags) { switch (CodeInfoDecoder.extractFI(entryFlags)) { case CodeInfoDecoder.FI_DEOPT_ENTRY_INDEX_S4: case CodeInfoDecoder.FI_INFO_ONLY_INDEX_S4: writeBuffer.putS4(data.frameData.indexInEncodings); break; } }
protected void writeObjectId(Object object) { writer.putUV(objects.getIndex(object)); }
@Override public final void putU2(long value) { putS2(asU2(value)); }
public GraphEncoder(Architecture architecture) { this.architecture = architecture; objects = FrequencyEncoder.createEqualityEncoder(); nodeClasses = FrequencyEncoder.createIdentityEncoder(); writer = UnsafeArrayTypeWriter.create(architecture.supportsUnalignedMemoryAccess()); }
int uncompressedSize = FrameAccess.uncompressedReferenceSize(); long startIndex = writeBuffer.getBytesWritten(); int run = 0; int gap = 0;
cur.encodedBci = FrameInfoDecoder.NO_LOCAL_INFO_BCI; encodingBuffer.putSV(cur.encodedBci); assert cur == data.frame || !cur.isDeoptEntry : "Deoptimization entry information for caller frames is not persisted"; encodingBuffer.putUV(cur.numLocks); encodingBuffer.putUV(cur.numLocals); encodingBuffer.putUV(cur.numStack); assert deoptMethodIndex >= 0; encodingBuffer.putSV(deoptMethodIndex); encodingBuffer.putUV(cur.virtualObjects.length); for (ValueInfo[] virtualObject : cur.virtualObjects) { encodeValues(virtualObject, encodingBuffer); cur.sourceMethodNameIndex = methodIndex; encodingBuffer.putSV(classIndex); encodingBuffer.putSV(methodIndex); encodingBuffer.putSV(cur.sourceLineNumber); for (ValueInfo valueInfo : cur.valueInfos) { valueInfo.nameIndex = names.getIndex(valueInfo.name); encodingBuffer.putUV(valueInfo.nameIndex); encodingBuffer.putSV(FrameInfoDecoder.NO_CALLER_BCI);
public byte[] encodeAll(PinnedAllocator allocator) { assert writeBuffer.getBytesWritten() == 0 : "encodeAll() must not be called multiple times"; /* * The table always starts with the empty reference map. This allows clients to actually * iterate the empty reference map, making a check for the empty map optional. */ assert CodeInfoQueryResult.EMPTY_REFERENCE_MAP == writeBuffer.getBytesWritten(); encodeEndOfTable(); /* * Sort reference map by usage count, so that frequently used maps get smaller indices * (which can be encoded in fewer bytes). */ List<Map.Entry<Input, Long>> sortedEntries = new ArrayList<>(usageCounts.entrySet()); sortedEntries.sort((o1, o2) -> -Long.compare(o1.getValue(), o2.getValue())); for (Map.Entry<Input, Long> entry : sortedEntries) { Input map = entry.getKey(); encodings.put(map, encode(map.getOffsets())); } int length = TypeConversion.asS4(writeBuffer.getBytesWritten()); return writeBuffer.toArray(newByteArray(allocator, length)); }
protected void writeEdges(Node node, Edges edges, NodeOrder nodeOrder) { if (node instanceof PhiNode) { /* Edges are not needed for decoding, so we must not write it. */ return; } for (int idx = 0; idx < edges.getDirectCount(); idx++) { if (GraphDecoder.skipDirectEdge(node, edges, idx)) { /* Edge is not needed for decoding, so we must not write it. */ continue; } Node edge = Edges.getNode(node, edges.getOffsets(), idx); writeOrderId(edge, nodeOrder); } if (node instanceof AbstractMergeNode && edges.type() == Edges.Type.Inputs) { /* The ends of merge nodes are decoded manually when the ends are processed. */ } else { for (int idx = edges.getDirectCount(); idx < edges.getCount(); idx++) { NodeList<Node> edgeList = Edges.getNodeList(node, edges.getOffsets(), idx); if (edgeList == null) { writer.putSV(-1); } else { writer.putSV(edgeList.size()); for (Node edge : edgeList) { writeOrderId(edge, nodeOrder); } } } } }
@Override public final void putU4(long value) { putS4(asU4(value)); }