hotspot/src/jdk.vm.compiler/share/classes/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/classfile/ClassfileBytecode.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package org.graalvm.compiler.replacements.classfile;

 import java.io.ByteArrayInputStream;
 import java.io.DataInputStream;
 import java.io.IOException;
 import java.lang.instrument.Instrumentation;

 import org.graalvm.compiler.bytecode.Bytecode;
 import org.graalvm.compiler.debug.GraalError;
 import org.graalvm.compiler.replacements.classfile.ClassfileConstant.Utf8;

 import jdk.vm.ci.meta.ConstantPool;
 import jdk.vm.ci.meta.DefaultProfilingInfo;
 import jdk.vm.ci.meta.ExceptionHandler;
 import jdk.vm.ci.meta.JavaType;
 import jdk.vm.ci.meta.LineNumberTable;
 import jdk.vm.ci.meta.Local;
 import jdk.vm.ci.meta.LocalVariableTable;
 import jdk.vm.ci.meta.ProfilingInfo;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.TriState;

 /**
  * The bytecode properties of a method as parsed directly from a class file without any
  * {@linkplain Instrumentation instrumentation} or other rewriting performed on the bytecode.
  */
 public class ClassfileBytecode implements Bytecode {

     private static final int EXCEPTION_HANDLER_TABLE_SIZE_IN_BYTES = 8;
     private static final int LINE_NUMBER_TABLE_ENTRY_SIZE_IN_BYTES = 4;
     private static final int LOCAL_VARIABLE_TABLE_SIZE_IN_BYTES = 10;

     private final ResolvedJavaMethod method;

     private final ClassfileConstantPool constantPool;

     private byte[] code;
     private int maxLocals;
     private int maxStack;

     private byte[] exceptionTableBytes;
     private byte[] lineNumberTableBytes;
     private byte[] localVariableTableBytes;

     public ClassfileBytecode(ResolvedJavaMethod method, DataInputStream stream, ClassfileConstantPool constantPool) throws IOException {
         this.method = method;
         this.constantPool = constantPool;
         maxStack = stream.readUnsignedShort();
         maxLocals = stream.readUnsignedShort();
         int codeLength = stream.readInt();
         code = new byte[codeLength];
         stream.readFully(code);
         int exceptionTableLength = stream.readUnsignedShort();
         exceptionTableBytes = new byte[exceptionTableLength * EXCEPTION_HANDLER_TABLE_SIZE_IN_BYTES];
         stream.readFully(exceptionTableBytes);
         readCodeAttributes(stream);
     }

     private void readCodeAttributes(DataInputStream stream) throws IOException {
         int count = stream.readUnsignedShort();
         for (int i = 0; i < count; i++) {
             String attributeName = constantPool.get(Utf8.class, stream.readUnsignedShort()).value;
             int attributeLength = stream.readInt();
             switch (attributeName) {
                 case "LocalVariableTable": {
                     int length = stream.readUnsignedShort();
                     localVariableTableBytes = new byte[length * LOCAL_VARIABLE_TABLE_SIZE_IN_BYTES];
                     stream.readFully(localVariableTableBytes);
                     break;
                 }
                 case "LineNumberTable": {
                     int length = stream.readUnsignedShort();
                     lineNumberTableBytes = new byte[length * LINE_NUMBER_TABLE_ENTRY_SIZE_IN_BYTES];
                     stream.readFully(lineNumberTableBytes);
                     break;
                 }
                 default: {
                     Classfile.skipFully(stream, attributeLength);
                     break;
                 }
             }
         }
     }

     @Override
     public byte[] getCode() {
         return code;
     }

     @Override
     public int getCodeSize() {
         return code.length;
     }

     @Override
     public int getMaxLocals() {
         return maxLocals;
     }

     @Override
     public int getMaxStackSize() {
         return maxStack;
     }

     @Override
     public ExceptionHandler[] getExceptionHandlers() {
         if (exceptionTableBytes == null) {
             return new ExceptionHandler[0];
         }

         final int exceptionTableLength = exceptionTableBytes.length / EXCEPTION_HANDLER_TABLE_SIZE_IN_BYTES;
         ExceptionHandler[] handlers = new ExceptionHandler[exceptionTableLength];
         DataInputStream stream = new DataInputStream(new ByteArrayInputStream(exceptionTableBytes));

         for (int i = 0; i < exceptionTableLength; i++) {
             try {
                 final int startPc = stream.readUnsignedShort();
                 final int endPc = stream.readUnsignedShort();
                 final int handlerPc = stream.readUnsignedShort();
                 int catchTypeIndex = stream.readUnsignedShort();

                 JavaType catchType;
                 if (catchTypeIndex == 0) {
                     catchType = null;
                 } else {
                     final int opcode = -1;  // opcode is not used
                     catchType = constantPool.lookupType(catchTypeIndex, opcode);

                     // Check for Throwable which catches everything.
                     if (catchType.toJavaName().equals("java.lang.Throwable")) {
                         catchTypeIndex = 0;
                         catchType = null;
                     }
                 }
                 handlers[i] = new ExceptionHandler(startPc, endPc, handlerPc, catchTypeIndex, catchType);
             } catch (IOException e) {
                 throw new GraalError(e);
             }
         }

         return handlers;
     }

     @Override
     public StackTraceElement asStackTraceElement(int bci) {
         int line = getLineNumberTable().getLineNumber(bci);
         return new StackTraceElement(method.getDeclaringClass().toJavaName(), method.getName(), method.getDeclaringClass().getSourceFileName(), line);
     }

     @Override
     public ConstantPool getConstantPool() {
         return constantPool;
     }

     @Override
     public LineNumberTable getLineNumberTable() {
         if (lineNumberTableBytes == null) {
             return null;
         }

         final int lineNumberTableLength = lineNumberTableBytes.length / LINE_NUMBER_TABLE_ENTRY_SIZE_IN_BYTES;
         DataInputStream stream = new DataInputStream(new ByteArrayInputStream(lineNumberTableBytes));
         int[] bci = new int[lineNumberTableLength];
         int[] line = new int[lineNumberTableLength];

         for (int i = 0; i < lineNumberTableLength; i++) {
             try {
                 bci[i] = stream.readUnsignedShort();
                 line[i] = stream.readUnsignedShort();
             } catch (IOException e) {
                 throw new GraalError(e);
             }
         }

         return new LineNumberTable(line, bci);
     }

     @Override
     public LocalVariableTable getLocalVariableTable() {
         if (localVariableTableBytes == null) {
             return null;
         }

         final int localVariableTableLength = localVariableTableBytes.length / LOCAL_VARIABLE_TABLE_SIZE_IN_BYTES;
         DataInputStream stream = new DataInputStream(new ByteArrayInputStream(localVariableTableBytes));
         Local[] locals = new Local[localVariableTableLength];

         for (int i = 0; i < localVariableTableLength; i++) {
             try {
                 final int startBci = stream.readUnsignedShort();
                 final int endBci = startBci + stream.readUnsignedShort();
                 final int nameCpIndex = stream.readUnsignedShort();
                 final int typeCpIndex = stream.readUnsignedShort();
                 final int slot = stream.readUnsignedShort();

                 String localName = constantPool.lookupUtf8(nameCpIndex);
                 String localType = constantPool.lookupUtf8(typeCpIndex);

                 ClassfileBytecodeProvider context = constantPool.context;
                 Class<?> c = context.resolveToClass(localType);
                 locals[i] = new Local(localName, context.metaAccess.lookupJavaType(c), startBci, endBci, slot);
             } catch (IOException e) {
                 throw new GraalError(e);
             }
         }

         return new LocalVariableTable(locals);
     }

     @Override
     public ResolvedJavaMethod getMethod() {
         return method;
     }

     @Override
     public ProfilingInfo getProfilingInfo() {
         return DefaultProfilingInfo.get(TriState.FALSE);
     }

     @Override
     public String toString() {
         return getClass().getName() + method.format("<%H.%n(%p)>");
     }
 }
	/*
	* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package org.graalvm.compiler.replacements.classfile;

	import java.io.ByteArrayInputStream;
	import java.io.DataInputStream;
	import java.io.IOException;
	import java.lang.instrument.Instrumentation;

	import org.graalvm.compiler.bytecode.Bytecode;
	import org.graalvm.compiler.debug.GraalError;
	import org.graalvm.compiler.replacements.classfile.ClassfileConstant.Utf8;

	import jdk.vm.ci.meta.ConstantPool;
	import jdk.vm.ci.meta.DefaultProfilingInfo;
	import jdk.vm.ci.meta.ExceptionHandler;
	import jdk.vm.ci.meta.JavaType;
	import jdk.vm.ci.meta.LineNumberTable;
	import jdk.vm.ci.meta.Local;
	import jdk.vm.ci.meta.LocalVariableTable;
	import jdk.vm.ci.meta.ProfilingInfo;
	import jdk.vm.ci.meta.ResolvedJavaMethod;
	import jdk.vm.ci.meta.TriState;

	/**
	* The bytecode properties of a method as parsed directly from a class file without any
	* {@linkplain Instrumentation instrumentation} or other rewriting performed on the bytecode.
	*/
	public class ClassfileBytecode implements Bytecode {

	private static final int EXCEPTION_HANDLER_TABLE_SIZE_IN_BYTES = 8;
	private static final int LINE_NUMBER_TABLE_ENTRY_SIZE_IN_BYTES = 4;
	private static final int LOCAL_VARIABLE_TABLE_SIZE_IN_BYTES = 10;

	private final ResolvedJavaMethod method;

	private final ClassfileConstantPool constantPool;

	private byte[] code;
	private int maxLocals;
	private int maxStack;

	private byte[] exceptionTableBytes;
	private byte[] lineNumberTableBytes;
	private byte[] localVariableTableBytes;

	public ClassfileBytecode(ResolvedJavaMethod method, DataInputStream stream, ClassfileConstantPool constantPool) throws IOException {
	this.method = method;
	this.constantPool = constantPool;
	maxStack = stream.readUnsignedShort();
	maxLocals = stream.readUnsignedShort();
	int codeLength = stream.readInt();
	code = new byte[codeLength];
	stream.readFully(code);
	int exceptionTableLength = stream.readUnsignedShort();
	exceptionTableBytes = new byte[exceptionTableLength * EXCEPTION_HANDLER_TABLE_SIZE_IN_BYTES];
	stream.readFully(exceptionTableBytes);
	readCodeAttributes(stream);
	}

	private void readCodeAttributes(DataInputStream stream) throws IOException {
	int count = stream.readUnsignedShort();
	for (int i = 0; i < count; i++) {
	String attributeName = constantPool.get(Utf8.class, stream.readUnsignedShort()).value;
	int attributeLength = stream.readInt();
	switch (attributeName) {
	case "LocalVariableTable": {
	int length = stream.readUnsignedShort();
	localVariableTableBytes = new byte[length * LOCAL_VARIABLE_TABLE_SIZE_IN_BYTES];
	stream.readFully(localVariableTableBytes);
	break;
	}
	case "LineNumberTable": {
	int length = stream.readUnsignedShort();
	lineNumberTableBytes = new byte[length * LINE_NUMBER_TABLE_ENTRY_SIZE_IN_BYTES];
	stream.readFully(lineNumberTableBytes);
	break;
	}
	default: {
	Classfile.skipFully(stream, attributeLength);
	break;
	}
	}
	}
	}

	@Override
	public byte[] getCode() {
	return code;
	}

	@Override
	public int getCodeSize() {
	return code.length;
	}

	@Override
	public int getMaxLocals() {
	return maxLocals;
	}

	@Override
	public int getMaxStackSize() {
	return maxStack;
	}

	@Override
	public ExceptionHandler[] getExceptionHandlers() {
	if (exceptionTableBytes == null) {
	return new ExceptionHandler[0];
	}

	final int exceptionTableLength = exceptionTableBytes.length / EXCEPTION_HANDLER_TABLE_SIZE_IN_BYTES;
	ExceptionHandler[] handlers = new ExceptionHandler[exceptionTableLength];
	DataInputStream stream = new DataInputStream(new ByteArrayInputStream(exceptionTableBytes));

	for (int i = 0; i < exceptionTableLength; i++) {
	try {
	final int startPc = stream.readUnsignedShort();
	final int endPc = stream.readUnsignedShort();
	final int handlerPc = stream.readUnsignedShort();
	int catchTypeIndex = stream.readUnsignedShort();

	JavaType catchType;
	if (catchTypeIndex == 0) {
	catchType = null;
	} else {
	final int opcode = -1; // opcode is not used
	catchType = constantPool.lookupType(catchTypeIndex, opcode);

	// Check for Throwable which catches everything.
	if (catchType.toJavaName().equals("java.lang.Throwable")) {
	catchTypeIndex = 0;
	catchType = null;
	}
	}
	handlers[i] = new ExceptionHandler(startPc, endPc, handlerPc, catchTypeIndex, catchType);
	} catch (IOException e) {
	throw new GraalError(e);
	}
	}

	return handlers;
	}

	@Override
	public StackTraceElement asStackTraceElement(int bci) {
	int line = getLineNumberTable().getLineNumber(bci);
	return new StackTraceElement(method.getDeclaringClass().toJavaName(), method.getName(), method.getDeclaringClass().getSourceFileName(), line);
	}

	@Override
	public ConstantPool getConstantPool() {
	return constantPool;
	}

	@Override
	public LineNumberTable getLineNumberTable() {
	if (lineNumberTableBytes == null) {
	return null;
	}

	final int lineNumberTableLength = lineNumberTableBytes.length / LINE_NUMBER_TABLE_ENTRY_SIZE_IN_BYTES;
	DataInputStream stream = new DataInputStream(new ByteArrayInputStream(lineNumberTableBytes));
	int[] bci = new int[lineNumberTableLength];
	int[] line = new int[lineNumberTableLength];

	for (int i = 0; i < lineNumberTableLength; i++) {
	try {
	bci[i] = stream.readUnsignedShort();
	line[i] = stream.readUnsignedShort();
	} catch (IOException e) {
	throw new GraalError(e);
	}
	}

	return new LineNumberTable(line, bci);
	}

	@Override
	public LocalVariableTable getLocalVariableTable() {
	if (localVariableTableBytes == null) {
	return null;
	}

	final int localVariableTableLength = localVariableTableBytes.length / LOCAL_VARIABLE_TABLE_SIZE_IN_BYTES;
	DataInputStream stream = new DataInputStream(new ByteArrayInputStream(localVariableTableBytes));
	Local[] locals = new Local[localVariableTableLength];

	for (int i = 0; i < localVariableTableLength; i++) {
	try {
	final int startBci = stream.readUnsignedShort();
	final int endBci = startBci + stream.readUnsignedShort();
	final int nameCpIndex = stream.readUnsignedShort();
	final int typeCpIndex = stream.readUnsignedShort();
	final int slot = stream.readUnsignedShort();

	String localName = constantPool.lookupUtf8(nameCpIndex);
	String localType = constantPool.lookupUtf8(typeCpIndex);

	ClassfileBytecodeProvider context = constantPool.context;
	Class<?> c = context.resolveToClass(localType);
	locals[i] = new Local(localName, context.metaAccess.lookupJavaType(c), startBci, endBci, slot);
	} catch (IOException e) {
	throw new GraalError(e);
	}
	}

	return new LocalVariableTable(locals);
	}

	@Override
	public ResolvedJavaMethod getMethod() {
	return method;
	}

	@Override
	public ProfilingInfo getProfilingInfo() {
	return DefaultProfilingInfo.get(TriState.FALSE);
	}

	@Override
	public String toString() {
	return getClass().getName() + method.format("<%H.%n(%p)>");
	}
	}