| /* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under |
| * the terms of the Common Public License v1.0 which accompanies this distribution, |
| * and is available at http://www.eclipse.org/legal/cpl-v10.html |
| * |
| * $Id: InstrVisitor.java,v 1.1.1.1.2.4 2004/07/16 23:32:28 vlad_r Exp $ |
| */ |
| package com.vladium.emma.instr; |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Comparator; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import com.vladium.jcd.cls.*; |
| import com.vladium.jcd.cls.attribute.*; |
| import com.vladium.jcd.cls.constant.CONSTANT_Class_info; |
| import com.vladium.jcd.cls.constant.CONSTANT_Long_info; |
| import com.vladium.jcd.cls.constant.CONSTANT_Methodref_info; |
| import com.vladium.jcd.cls.constant.CONSTANT_String_info; |
| import com.vladium.jcd.compiler.CodeGen; |
| import com.vladium.jcd.lib.Types; |
| import com.vladium.jcd.opcodes.IOpcodes; |
| import com.vladium.logging.Logger; |
| import com.vladium.util.ByteArrayOStream; |
| import com.vladium.util.IConstants; |
| import com.vladium.util.IntIntMap; |
| import com.vladium.util.IntObjectMap; |
| import com.vladium.util.IntSet; |
| import com.vladium.util.asserts.$assert; |
| import com.vladium.emma.IAppConstants; |
| import com.vladium.emma.data.ClassDescriptor; |
| import com.vladium.emma.data.CoverageOptions; |
| import com.vladium.emma.data.IMetadataConstants; |
| import com.vladium.emma.data.MethodDescriptor; |
| |
| // ---------------------------------------------------------------------------- |
| /** |
| * @author Vlad Roubtsov, (C) 2003 |
| */ |
| public |
| final class InstrVisitor extends AbstractClassDefVisitor |
| implements IClassDefVisitor, IAttributeVisitor, IOpcodes, IConstants |
| { |
| // public: ................................................................ |
| |
| // TODO: m_instrument is unused |
| |
| public static final class InstrResult |
| { |
| public boolean m_instrumented; |
| public ClassDescriptor m_descriptor; |
| |
| } // end of nested class |
| |
| public InstrVisitor (final CoverageOptions options) |
| { |
| m_excludeSyntheticMethods = options.excludeSyntheticMethods (); |
| m_excludeBridgeMethods = options.excludeBridgeMethods (); |
| m_doSUIDCompensation = options.doSUIDCompensation (); |
| |
| m_log = Logger.getLogger (); |
| } |
| |
| /** |
| * Analyzes 'cls' and/or instruments it for coverage: |
| * <ul> |
| * <li> if 'instrument' is true, the class definition is instrumented for |
| * coverage if that is feasible |
| * <li> if 'metadata' is true, the class definition is analysed |
| * to create a {@link ClassDescriptor} for the original class definition |
| * </ul> |
| * This method returns null if 'metadata' is 'false' *or* if 'cls' is an |
| * interface [the latter precludes coverage of interface static |
| * initializers and may be removed in the future].<P> |
| * |
| * NOTE: if 'instrument' is 'true', the caller should always assume that 'cls' |
| * has been mutated by this method even if it returned null. The caller should |
| * then revert to the original class definition that was created as a |
| * <code>cls.clone()</code> or by retaining the original definition bytes. |
| * This part of contract is for efficienty and also simplifies the implementation. |
| */ |
| public void process (final ClassDef cls, |
| final boolean ignoreAlreadyInstrumented, |
| final boolean instrument, final boolean metadata, |
| final InstrResult out) |
| { |
| out.m_instrumented = false; |
| out.m_descriptor = null; |
| |
| if (! (instrument || metadata)) return; // nothing to do |
| |
| if (cls.isInterface ()) |
| return; // skip interfaces [may change in the future] |
| else |
| { |
| reset (); |
| |
| m_cls = cls; |
| |
| // TODO: handle classes that cannot be instrumented due to bytecode/JVM limitations |
| m_instrument = instrument; |
| m_metadata = metadata; |
| m_ignoreAlreadyInstrumented = ignoreAlreadyInstrumented; |
| |
| // TODO: create 'no instrumentation' execution path here |
| |
| visit ((ClassDef) null, null); // potentially changes m_instrument and m_metadata |
| |
| if (m_metadata) |
| { |
| setClassName (cls.getName ()); |
| |
| out.m_descriptor = new ClassDescriptor (m_classPackageName, m_className, m_classSignature, m_classSrcFileName, m_classMethodDescriptors); |
| } |
| |
| out.m_instrumented = m_instrument; |
| } |
| } |
| |
| |
| // IClassDefVisitor: |
| |
| public Object visit (final ClassDef ignore, final Object ctx) |
| { |
| final ClassDef cls = m_cls; |
| final String clsVMName = cls.getName (); |
| final String clsName = Types.vmNameToJavaName (clsVMName); |
| |
| final boolean trace1 = m_log.atTRACE1 (); |
| if (trace1) m_log.trace1 ("visit", "class: [" + clsVMName + "]"); |
| |
| |
| // skip synthetic classes if enabled: |
| if (SKIP_SYNTHETIC_CLASSES && cls.isSynthetic ()) |
| { |
| m_instrument = false; |
| m_metadata = false; |
| |
| if (trace1) m_log.trace1 ("visit", "skipping synthetic class"); |
| return ctx; |
| } |
| |
| // TODO: ideally, this check should be done in outer scope somewhere |
| if (! m_warningIssued && clsName.startsWith (IAppConstants.APP_PACKAGE)) |
| { |
| m_warningIssued = true; |
| |
| m_log.warning (IAppConstants.APP_NAME + " classes appear to be included on the instrumentation"); |
| m_log.warning ("path: this is not a correct way to use " + IAppConstants.APP_NAME); |
| } |
| |
| // field uniqueness check done to detect double instrumentation: |
| { |
| final int [] existing = cls.getFields (COVERAGE_FIELD_NAME); |
| if (existing.length > 0) |
| { |
| m_instrument = false; |
| m_metadata = false; |
| |
| if (m_ignoreAlreadyInstrumented) |
| { |
| if (trace1) m_log.trace1 ("visit", "skipping instrumented class"); |
| return ctx; |
| } |
| else |
| { |
| // TODO: use a app coded exception |
| throw new IllegalStateException ("class [" + clsName + "] appears to be instrumented already"); |
| } |
| } |
| } |
| |
| final IConstantCollection constants = cls.getConstants (); |
| |
| SyntheticAttribute_info syntheticMarker = null; |
| |
| // cache the location of "Synthetic" string: |
| { |
| if (MARK_ADDED_ELEMENTS_SYNTHETIC) |
| m_syntheticStringIndex = cls.addCONSTANT_Utf8 (Attribute_info.ATTRIBUTE_SYNTHETIC, true); |
| } |
| |
| // add a Fieldref for the runtime coverage collector field: |
| { |
| // note: this is a bit premature if the class has no methods that need |
| // instrumentation |
| // TODO: the mutated version is easily discardable; however, this case |
| // needs attention at metadata/report generation level |
| |
| final int coverageFieldOffset; |
| final String fieldDescriptor = "[[Z"; |
| |
| // note that post-4019 builds can modify this field outside of <clinit> (although |
| // it can only happen as part of initializing a set of classes); however, it is legal |
| // to declare this field final: |
| |
| final int fieldModifiers = IAccessFlags.ACC_PRIVATE | IAccessFlags.ACC_STATIC | IAccessFlags.ACC_FINAL; |
| |
| // add declared field: |
| if (MARK_ADDED_ELEMENTS_SYNTHETIC) |
| { |
| final IAttributeCollection fieldAttributes = ElementFactory.newAttributeCollection (1); |
| |
| syntheticMarker = new SyntheticAttribute_info (m_syntheticStringIndex); |
| fieldAttributes.add (syntheticMarker); |
| |
| coverageFieldOffset = cls.addField (COVERAGE_FIELD_NAME, fieldDescriptor, |
| fieldModifiers, fieldAttributes); |
| } |
| else |
| { |
| coverageFieldOffset = cls.addField (COVERAGE_FIELD_NAME, fieldDescriptor, |
| fieldModifiers); |
| } |
| |
| //add fieldref: |
| m_coverageFieldrefIndex = cls.addFieldref (coverageFieldOffset); |
| } |
| |
| // add a Methodref for Runtime.r(): |
| { |
| // TODO: compute this without loading Runtime Class? |
| final String classJVMName = "com/vladium/emma/rt/RT"; |
| final int class_index = cls.addClassref (classJVMName); |
| |
| // NOTE: keep this descriptor in sync with the actual signature |
| final String methodDescriptor = "([[ZLjava/lang/String;J)V"; |
| final int nametype_index = cls.addNameType ("r", methodDescriptor); |
| |
| m_registerMethodrefIndex = constants.add (new CONSTANT_Methodref_info (class_index, nametype_index)); |
| } |
| |
| // SF FR 971186: split the init logic into a separate method so it could |
| // be called from regular method headers if necessary: |
| |
| // add a Methodref for pre-<clinit> method: |
| { |
| // NOTE: keep this descriptor in sync with the actual signature |
| final String methodDescriptor = "()[[Z"; |
| final int nametype_index = cls.addNameType (PRECLINIT_METHOD_NAME, methodDescriptor); |
| |
| m_preclinitMethodrefIndex = constants.add (new CONSTANT_Methodref_info (cls.getThisClassIndex (), nametype_index)); |
| } |
| |
| // add a CONSTANT_String that corresponds to the class name [in JVM format]: |
| { |
| m_classNameConstantIndex = constants.add (new CONSTANT_String_info (cls.getThisClass ().m_name_index)); |
| } |
| |
| // visit method collection: |
| visit (cls.getMethods (), ctx); |
| |
| // if necessary, do SUID compensation [need to be done after method |
| // visits when it is known whether a <clinit> was added]: |
| if (m_doSUIDCompensation) |
| { |
| // compensation not necessary if the original clsdef already defined <clinit>: |
| boolean compensate = ((m_clinitStatus & IMetadataConstants.METHOD_ADDED) != 0); |
| |
| int existingSUIDFieldCount = 0; |
| |
| if (compensate) |
| { |
| // compensation not necessary if the original clsdef already controlled it via 'serialVersionUID': |
| { |
| final int [] existing = cls.getFields (SUID_FIELD_NAME); |
| existingSUIDFieldCount = existing.length; |
| |
| if (existingSUIDFieldCount > 0) |
| { |
| final IFieldCollection fields = cls.getFields (); |
| |
| for (int f = 0; f < existingSUIDFieldCount; ++ f) |
| { |
| final Field_info field = fields.get (existing [f]); |
| if ((field.getAccessFlags () & (IAccessFlags.ACC_STATIC | IAccessFlags.ACC_FINAL)) |
| == (IAccessFlags.ACC_STATIC | IAccessFlags.ACC_FINAL)) |
| { |
| // TODO: should also check for presence of a non-zero initializer |
| |
| compensate = false; |
| break; |
| } |
| } |
| } |
| } |
| |
| // compensation not necessary if we can determine that this class |
| // does not implement java.io.Serializable/Externalizable: |
| |
| if (compensate && (cls.getThisClassIndex () == 0)) // no superclasses [this tool can't traverse inheritance chains] |
| { |
| boolean serializable = false; |
| |
| final IInterfaceCollection interfaces = cls.getInterfaces (); |
| for (int i = 0, iLimit = interfaces.size (); i < iLimit; ++ i) |
| { |
| final CONSTANT_Class_info ifc = (CONSTANT_Class_info) constants.get (interfaces.get (i)); |
| final String ifcName = ifc.getName (cls); |
| if (JAVA_IO_SERIALIZABLE_NAME.equals (ifcName) || JAVA_IO_EXTERNALIZABLE_NAME.equals (ifcName)) |
| { |
| serializable = true; |
| break; |
| } |
| } |
| |
| if (! serializable) compensate = false; |
| } |
| } |
| |
| if (compensate) |
| { |
| if (existingSUIDFieldCount > 0) |
| { |
| // if we get here, the class declares a 'serialVersionUID' field |
| // that is not both static and final and/or is not initialized |
| // statically: warn that SUID compensation may not work |
| |
| m_log.warning ("class [" + clsName + "] declares a 'serialVersionUID'"); |
| m_log.warning ("field that is not static and final: this is likely an implementation mistake"); |
| m_log.warning ("and can interfere with " + IAppConstants.APP_NAME + "'s SUID compensation"); |
| } |
| |
| final String fieldDescriptor = "J"; |
| final int fieldModifiers = IAccessFlags.ACC_PRIVATE | IAccessFlags.ACC_STATIC | IAccessFlags.ACC_FINAL; |
| final IAttributeCollection fieldAttributes = ElementFactory.newAttributeCollection (MARK_ADDED_ELEMENTS_SYNTHETIC ? 2 : 1); |
| |
| final int nameIndex = cls.addCONSTANT_Utf8 (Attribute_info.ATTRIBUTE_CONSTANT_VALUE, true); |
| final int valueIndex = constants.add (new CONSTANT_Long_info (cls.computeSUID (true))); // ignore the added <clinit> |
| |
| final ConstantValueAttribute_info initializer = new ConstantValueAttribute_info (nameIndex, valueIndex); |
| fieldAttributes.add (initializer); |
| |
| if (MARK_ADDED_ELEMENTS_SYNTHETIC) |
| { |
| if (syntheticMarker == null) syntheticMarker = new SyntheticAttribute_info (m_syntheticStringIndex); |
| fieldAttributes.add (syntheticMarker); |
| } |
| |
| cls.addField (SUID_FIELD_NAME, fieldDescriptor, fieldModifiers, fieldAttributes); |
| } |
| |
| } // if (m_doSUIDCompensation) |
| |
| // visit class attributes [to get src file name, etc]: |
| visit (cls.getAttributes (), ctx); |
| |
| return ctx; |
| } |
| |
| |
| public Object visit (final IMethodCollection methods, final Object ctx) |
| { |
| final ClassDef cls = m_cls; |
| |
| final boolean trace2 = m_log.atTRACE2 (); |
| |
| final int originalMethodCount = methods.size (); |
| final boolean constructMetadata = m_metadata; |
| |
| // create block count map: TODO: is the extra slot really needed? |
| // - create [potentially unused] slot for added <clinit> |
| m_classBlockCounts = new int [originalMethodCount + 1]; |
| |
| if (constructMetadata) |
| { |
| // prepare to collect metadata: |
| m_classBlockMetadata = new int [originalMethodCount + 1] [] []; // same comments as above |
| |
| m_classMethodDescriptors = new MethodDescriptor [originalMethodCount]; |
| } |
| |
| |
| // visit each original method: |
| |
| for (int m = 0; m < originalMethodCount; ++ m) |
| { |
| final Method_info method = methods.get (m); |
| m_methodName = method.getName (cls); |
| if (trace2) m_log.trace2 ("visit", (method.isSynthetic () ? "synthetic " : "") + "method #" + m + ": [" + m_methodName + "]"); |
| |
| final boolean isClinit = IClassDefConstants.CLINIT_NAME.equals (m_methodName); |
| |
| // TODO: research whether synthetic methods add nontrivially to line coverage or not |
| |
| boolean excluded = false; |
| |
| if (! isClinit) |
| { |
| if (m_excludeSyntheticMethods && method.isSynthetic ()) |
| { |
| excluded = true; |
| if (trace2) m_log.trace2 ("visit", "skipped synthetic method"); |
| } |
| else if (m_excludeBridgeMethods && method.isBridge ()) |
| { |
| excluded = true; |
| if (trace2) m_log.trace2 ("visit", "skipped bridge method"); |
| } |
| } |
| |
| if (excluded) |
| { |
| if (constructMetadata) |
| { |
| m_classMethodDescriptors [m] = new MethodDescriptor (m_methodName, method.getDescriptor (cls), IMetadataConstants.METHOD_EXCLUDED, m_methodBlockSizes, null, 0); |
| } |
| } |
| else |
| { |
| if ((method.getAccessFlags () & (IAccessFlags.ACC_ABSTRACT | IAccessFlags.ACC_NATIVE)) != 0) |
| { |
| if (constructMetadata) |
| { |
| m_classMethodDescriptors [m] = new MethodDescriptor (m_methodName, method.getDescriptor (cls), IMetadataConstants.METHOD_ABSTRACT_OR_NATIVE, m_methodBlockSizes, null, 0); |
| } |
| |
| if (trace2) m_log.trace2 ("visit", "skipped " + (method.isAbstract () ? "abstract" : "native") + " method"); |
| } |
| else // this is a regular, non-<clinit> method that has bytecode: |
| { |
| // reset first line: |
| m_methodFirstLine = 0; |
| |
| // set current method ID: |
| m_methodID = m; |
| |
| if (isClinit) |
| { |
| // if <clinit> found: note the ID but delay processing until the very end |
| m_clinitID = m; |
| if (trace2) m_log.trace2 ("visit", "<clinit> method delayed"); |
| } |
| else |
| { |
| // visit attributes [skip visit (IAttributeCollection) method]: |
| final IAttributeCollection attributes = method.getAttributes (); |
| final int attributeCount = attributes.size (); |
| for (int a = 0; a < attributeCount; ++ a) |
| { |
| final Attribute_info attribute = attributes.get (a); |
| attribute.accept (this, ctx); |
| } |
| |
| if (constructMetadata) |
| { |
| if ($assert.ENABLED) $assert.ASSERT (m_classBlockCounts [m_methodID] > 0, "invalid block count for method " + m_methodID + ": " + m_classBlockCounts [m_methodID]); |
| if ($assert.ENABLED) $assert.ASSERT (m_methodBlockSizes != null && m_methodBlockSizes.length == m_classBlockCounts [m_methodID], "invalid block sizes map for method " + m_methodID); |
| |
| final int [][] methodBlockMetadata = m_classBlockMetadata [m_methodID]; |
| final int status = (methodBlockMetadata == null ? IMetadataConstants.METHOD_NO_LINE_NUMBER_TABLE : 0); |
| |
| m_classMethodDescriptors [m] = new MethodDescriptor (m_methodName, method.getDescriptor (cls), status, m_methodBlockSizes, methodBlockMetadata, m_methodFirstLine); |
| } |
| } |
| } |
| } |
| } |
| |
| // add <clinit> (and instrument if needed) [a <clinit> is always needed |
| // even if there are no other instrumented method to act as a load hook]: |
| |
| final boolean instrumentClinit = false; // TODO: make use of this [to limit instrumentation to clinitHeader only], take into account whether we added and whether it is synthetic |
| final Method_info clinit; |
| |
| if (m_clinitID >= 0) |
| { |
| // <clinit> existed in the original class: needs to be covered |
| |
| // m_clinitStatus = 0; |
| clinit = methods.get (m_clinitID); |
| |
| m_classInstrMethodCount = originalMethodCount; |
| } |
| else |
| { |
| // there is no <clinit> defined by the original class: add one [and mark it synthetic] |
| |
| m_clinitStatus = IMetadataConstants.METHOD_ADDED; // mark as added by us |
| |
| final int attribute_name_index = cls.addCONSTANT_Utf8 (Attribute_info.ATTRIBUTE_CODE, true); |
| final int name_index = cls.addCONSTANT_Utf8 (IClassDefConstants.CLINIT_NAME, true); |
| final int descriptor_index = cls.addCONSTANT_Utf8 ("()V", true); |
| |
| final IAttributeCollection attributes; |
| |
| if (MARK_ADDED_ELEMENTS_SYNTHETIC) |
| attributes = ElementFactory.newAttributeCollection (2); |
| else |
| attributes = ElementFactory.newAttributeCollection (1); |
| |
| final CodeAttribute_info code = new CodeAttribute_info (attribute_name_index, |
| 0, 0, |
| new byte [] {(byte) _return}, |
| AttributeElementFactory.newExceptionHandlerTable (0), |
| ElementFactory.newAttributeCollection (0)); |
| |
| attributes.add (code); |
| |
| if (MARK_ADDED_ELEMENTS_SYNTHETIC) |
| { |
| attributes.add (new SyntheticAttribute_info (m_syntheticStringIndex)); |
| } |
| |
| clinit = new Method_info (IAccessFlags.ACC_STATIC | IAccessFlags.ACC_PRIVATE, name_index, descriptor_index, attributes); |
| |
| m_clinitID = cls.addMethod (clinit); |
| |
| if (trace2) m_log.trace2 ("visit", "added synthetic <clinit> method"); |
| |
| // TODO: this should exclude <clinit> if it were added by us |
| m_classInstrMethodCount = originalMethodCount + 1; |
| } |
| |
| if ($assert.ENABLED) $assert.ASSERT (m_classInstrMethodCount >= 0, |
| "m_classInstrMethodCount not set"); |
| |
| |
| // visit <clinit>: |
| { |
| m_methodFirstLine = 0; |
| m_methodID = m_clinitID; |
| |
| if (trace2) m_log.trace2 ("visit", (clinit.isSynthetic () ? "synthetic " : "") + "method #" + m_methodID + ": [<clinit>]"); |
| |
| final IAttributeCollection attributes = clinit.getAttributes (); |
| final int attributeCount = attributes.size (); |
| for (int a = 0; a < attributeCount; ++ a) |
| { |
| final Attribute_info attribute = attributes.get (a); |
| attribute.accept (this, ctx); |
| } |
| } |
| |
| // add pre-<clinit> method: |
| |
| { |
| final int attribute_name_index = cls.addCONSTANT_Utf8 (Attribute_info.ATTRIBUTE_CODE, true); |
| final int name_index = cls.addCONSTANT_Utf8 (PRECLINIT_METHOD_NAME, false); |
| final int descriptor_index = cls.addCONSTANT_Utf8 ("()[[Z", false); |
| |
| final IAttributeCollection attributes; |
| |
| if (MARK_ADDED_ELEMENTS_SYNTHETIC) |
| attributes = ElementFactory.newAttributeCollection (2); |
| else |
| attributes = ElementFactory.newAttributeCollection (1); |
| |
| final ByteArrayOStream buf = new ByteArrayOStream (PRECLINIT_INIT_CAPACITY); |
| { |
| final int [] blockCounts = m_classBlockCounts; |
| final int instrMethodCount = m_classInstrMethodCount; // actual number of methods to instrument may be less than the size of the block map |
| |
| if ($assert.ENABLED) $assert.ASSERT (blockCounts != null && blockCounts.length >= instrMethodCount, |
| "invalid block count map"); |
| |
| // new and set COVERAGE_FIELD: |
| |
| // push first dimension: |
| CodeGen.push_int_value (buf, cls, instrMethodCount); |
| |
| // [stack +1] |
| |
| // new boolean [][]: |
| final int type_index = cls.addClassref ("[[Z"); |
| buf.write4 (_multianewarray, |
| type_index >>> 8, // indexbyte1 |
| type_index, // indexbyte2 |
| 1); // only one dimension created here |
| |
| // [stack +1] |
| |
| // clone array ref: |
| buf.write4 (_dup, |
| |
| // [stack +2] |
| |
| // store in the static field |
| _putstatic, |
| m_coverageFieldrefIndex >>> 8, // indexbyte1 |
| m_coverageFieldrefIndex); // indexbyte2 |
| |
| // [stack +1] |
| |
| for (int m = 0; m < instrMethodCount; ++ m) |
| { |
| final int blockCount = blockCounts [m]; |
| if (blockCount > 0) |
| { |
| // clone array ref: |
| buf.write (_dup); |
| |
| // [stack +2] |
| |
| // push outer dim index: |
| CodeGen.push_int_value (buf, cls, m); |
| |
| // [stack +3] |
| |
| // push dim: |
| CodeGen.push_int_value (buf, cls, blockCount); |
| |
| // [stack +4] |
| |
| // newarray boolean []: |
| buf.write3 (_newarray, |
| 4, // "T_BOOLEAN" |
| |
| // add subarray to the outer array: |
| _aastore); |
| |
| // [stack +1] |
| } |
| } |
| |
| // [stack +1] |
| |
| { |
| // clone array ref |
| buf.write (_dup); |
| |
| // [stack +2] |
| |
| CodeGen.push_constant_index (buf, m_classNameConstantIndex); |
| |
| // [stack +3] |
| |
| buf.write3 (_ldc2_w, |
| m_stampIndex >>> 8, // indexbyte1 |
| m_stampIndex); // indexbyte2 |
| |
| // [stack +5] |
| |
| buf.write3 (_invokestatic, |
| m_registerMethodrefIndex >>> 8, // indexbyte1 |
| m_registerMethodrefIndex); // indexbyte2 |
| |
| // [stack +1] |
| } |
| |
| // pop and return extra array ref: |
| buf.write (_areturn); |
| |
| // [stack +0] |
| } |
| |
| final CodeAttribute_info code = new CodeAttribute_info (attribute_name_index, |
| 5, 0, // adjust constants if the bytecode emitted above changes |
| EMPTY_BYTE_ARRAY, |
| AttributeElementFactory.newExceptionHandlerTable (0), |
| ElementFactory.newAttributeCollection (0)); |
| |
| code.setCode (buf.getByteArray (), buf.size ()); |
| |
| attributes.add (code); |
| |
| if (MARK_ADDED_ELEMENTS_SYNTHETIC) |
| { |
| attributes.add (new SyntheticAttribute_info (m_syntheticStringIndex)); |
| } |
| |
| final Method_info preclinit = new Method_info (IAccessFlags.ACC_STATIC | IAccessFlags.ACC_PRIVATE, name_index, descriptor_index, attributes); |
| cls.addMethod (preclinit); |
| |
| if (trace2) m_log.trace2 ("visit", "added synthetic pre-<clinit> method"); |
| } |
| |
| |
| if (constructMetadata) |
| { |
| if ($assert.ENABLED) $assert.ASSERT (m_classBlockCounts [m_methodID] > 0, "invalid block count for method " + m_methodID + " (" + IClassDefConstants.CLINIT_NAME + "): " + m_classBlockCounts [m_methodID]); |
| if ($assert.ENABLED) $assert.ASSERT (m_methodBlockSizes != null && m_methodBlockSizes.length == m_classBlockCounts [m_methodID], "invalid block sizes map for method " + m_methodID); |
| |
| final int [][] methodBlockMetadata = m_classBlockMetadata [m_methodID]; |
| m_clinitStatus |= (methodBlockMetadata == null ? IMetadataConstants.METHOD_NO_LINE_NUMBER_TABLE : 0); |
| |
| // TODO: this still does not process not added/synthetic case |
| |
| if ((m_clinitStatus & IMetadataConstants.METHOD_ADDED) == 0) |
| m_classMethodDescriptors [m_methodID] = new MethodDescriptor (IClassDefConstants.CLINIT_NAME, clinit.getDescriptor (cls), m_clinitStatus, m_methodBlockSizes, methodBlockMetadata, m_methodFirstLine); |
| } |
| |
| return ctx; |
| } |
| |
| |
| public Object visit (final IAttributeCollection attributes, Object ctx) |
| { |
| for (int a = 0, aCount = attributes.size (); a < aCount; ++ a) |
| { |
| // TODO: define a global way to set the mask set of attrs to be visited |
| attributes.get (a).accept (this, ctx); |
| } |
| |
| return ctx; |
| } |
| |
| |
| // IAttributeVisitor: |
| |
| public Object visit (final CodeAttribute_info attribute, final Object ctx) |
| { |
| final boolean trace2 = m_log.atTRACE2 (); |
| final boolean trace3 = m_log.atTRACE3 (); |
| |
| final byte [] code = attribute.getCode (); |
| final int codeSize = attribute.getCodeSize (); |
| |
| if (trace2) m_log.trace2 ("visit", "code attribute for method #" + m_methodID + ": size = " + codeSize); |
| |
| final IntSet leaders = new IntSet (); |
| |
| // instructionMap.get(ip) is the number of instructions in code[0-ip) |
| // [this map will include a mapping for code length as well] |
| final IntIntMap /* int(ip)->instr count */ instructionMap = new IntIntMap (); |
| |
| // add first instruction and all exc handler start pcs: |
| leaders.add (0); |
| |
| final IExceptionHandlerTable exceptions = attribute.getExceptionTable (); |
| final int exceptionCount = exceptions.size (); |
| for (int e = 0; e < exceptionCount; ++ e) |
| { |
| final Exception_info exception = exceptions.get (e); |
| leaders.add (exception.m_handler_pc); |
| } |
| |
| |
| final IntObjectMap branches = new IntObjectMap (); |
| |
| // determine block leaders [an O(code length) loop]: |
| |
| boolean branch = false; |
| boolean wide = false; |
| |
| int instructionCount = 0; |
| instructionMap.put (0, 0); |
| |
| for (int ip = 0; ip < codeSize; ) |
| { |
| final int opcode = 0xFF & code [ip]; |
| int size = 0; // will be set to -<real size> for special cases in the switch below |
| |
| //if (trace3) m_log.trace3 ("parse", MNEMONICS [opcode]); |
| // "visitor.visit (opcode, wide, ip, null)": |
| |
| { // "opcode visit" logic: |
| |
| int iv, ov; |
| |
| if (branch) |
| { |
| // previous instruction was a branch: this one is a leader |
| leaders.add (ip); |
| branch = false; |
| } |
| |
| switch (opcode) |
| { |
| case _ifeq: |
| case _iflt: |
| case _ifle: |
| case _ifne: |
| case _ifgt: |
| case _ifge: |
| case _ifnull: |
| case _ifnonnull: |
| case _if_icmpeq: |
| case _if_icmpne: |
| case _if_icmplt: |
| case _if_icmpgt: |
| case _if_icmple: |
| case _if_icmpge: |
| case _if_acmpeq: |
| case _if_acmpne: |
| { |
| //ov = getI2 (code, ip + 1); |
| int scan = ip + 1; |
| ov = (code [scan] << 8) | (0xFF & code [++ scan]); |
| |
| final int target = ip + ov; |
| leaders.add (target); |
| |
| branches.put (ip, new IFJUMP2 (opcode, target)); |
| branch = true; |
| } |
| break; |
| |
| |
| case _goto: |
| case _jsr: |
| { |
| //ov = getI2 (code, ip + 1); |
| int scan = ip + 1; |
| ov = (code [scan] << 8) | (0xFF & code [++ scan]); |
| |
| final int target = ip + ov; |
| leaders.add (target); |
| |
| branches.put (ip, new JUMP2 (opcode, target)); |
| branch = true; |
| } |
| break; |
| |
| |
| case _lookupswitch: |
| { |
| int scan = ip + 4 - (ip & 3); // eat padding |
| |
| ov = (code [scan] << 24) | ((0xFF & code [++ scan]) << 16) | ((0xFF & code [++ scan]) << 8) | (0xFF & code [++ scan]); |
| leaders.add (ip + ov); |
| |
| //final int npairs = getU4 (code, scan); |
| //scan += 4; |
| final int npairs = ((0xFF & code [++ scan]) << 24) | ((0xFF & code [++ scan]) << 16) | ((0xFF & code [++ scan]) << 8) | (0xFF & code [++ scan]); |
| |
| final int [] keys = new int [npairs]; |
| final int [] targets = new int [npairs + 1]; |
| targets [0] = ip + ov; |
| |
| for (int p = 0; p < npairs; ++ p) |
| { |
| //iv = getI4 (code, scan); |
| //scan += 4; |
| iv = (code [++ scan] << 24) | ((0xFF & code [++ scan]) << 16) | ((0xFF & code [++ scan]) << 8) | (0xFF & code [++ scan]); |
| keys [p] = iv; |
| |
| |
| //ov = getI4 (code, scan); |
| //scan += 4; |
| ov = (code [++ scan] << 24) | ((0xFF & code [++ scan]) << 16) | ((0xFF & code [++ scan]) << 8) | (0xFF & code [++ scan]); |
| targets [p + 1] = ip + ov; |
| leaders.add (ip + ov); |
| } |
| |
| branches.put (ip, new LOOKUPSWITCH (keys, targets)); |
| branch = true; |
| |
| size = ip - scan - 1; // special case |
| } |
| break; |
| |
| |
| case _tableswitch: |
| { |
| int scan = ip + 4 - (ip & 3); // eat padding |
| |
| ov = (code [scan] << 24) | ((0xFF & code [++ scan]) << 16) | ((0xFF & code [++ scan]) << 8) | (0xFF & code [++ scan]); |
| leaders.add (ip + ov); |
| |
| //final int low = getI4 (code, scan + 4); |
| final int low = (code [++ scan] << 24) | ((0xFF & code [++ scan]) << 16) | ((0xFF & code [++ scan]) << 8) | (0xFF & code [++ scan]); |
| //final int high = getI4 (code, scan + 8); |
| //scan += 12; |
| final int high = (code [++ scan] << 24) | ((0xFF & code [++ scan]) << 16) | ((0xFF & code [++ scan]) << 8) | (0xFF & code [++ scan]); |
| |
| final int [] targets = new int [high - low + 2]; |
| targets [0] = ip + ov; |
| |
| for (int index = low; index <= high; ++ index) |
| { |
| //ov = getI4 (code, scan); |
| ov = (code [++ scan] << 24) | ((0xFF & code [++ scan]) << 16) | ((0xFF & code [++ scan]) << 8) | (0xFF & code [++ scan]); |
| targets [index - low + 1] = ip + ov; |
| leaders.add (ip + ov); |
| //scan += 4; |
| } |
| |
| branches.put (ip, new TABLESWITCH (low, high, targets)); |
| branch = true; |
| |
| size = ip - scan - 1; // special case |
| } |
| break; |
| |
| |
| case _goto_w: |
| case _jsr_w: |
| { |
| int scan = ip + 1; |
| //ov = getI4 (code, ip + 1); |
| ov = (code [scan] << 24) | ((0xFF & code [++ scan]) << 16) | ((0xFF & code [++ scan]) << 8) | (0xFF & code [++ scan]); |
| final int target = ip + ov; |
| |
| leaders.add (target); |
| |
| branches.put (ip, new JUMP4 (opcode, target)); |
| branch = true; |
| } |
| break; |
| |
| |
| case _ret: |
| { |
| int scan = ip + 1; |
| iv = wide ? (((0xFF & code [scan]) << 8) | (0xFF & code [++ scan])) : (0xFF & code [scan]); |
| |
| branches.put (ip, new RET (opcode, iv)); |
| branch = true; |
| } |
| break; |
| |
| |
| case _athrow: |
| case _ireturn: |
| case _lreturn: |
| case _freturn: |
| case _dreturn: |
| case _areturn: |
| case _return: |
| { |
| branches.put (ip, new TERMINATE (opcode)); |
| branch = true; |
| } |
| break; |
| |
| } // end of switch |
| |
| } // end of processing the current opcode |
| |
| |
| // shift to the next instruction [this is the only block that adjusts 'ip']: |
| |
| if (size == 0) |
| size = (wide ? WIDE_SIZE : NARROW_SIZE) [opcode]; |
| else |
| size = -size; |
| |
| ip += size; |
| wide = (opcode == _wide); |
| |
| instructionMap.put (ip, ++ instructionCount); |
| |
| } // end of for |
| |
| |
| // split 'code' into an ordered list of basic blocks [O(block count) loops]: |
| |
| final int blockCount = leaders.size (); |
| if (trace2) m_log.trace2 ("visit", "method contains " + blockCount + " basic blocks"); |
| |
| final BlockList blocks = new BlockList (blockCount); |
| |
| final int [] _leaders = new int [blockCount + 1]; // room for end-of-code leader at the end |
| leaders.values (_leaders, 0); |
| _leaders [blockCount] = codeSize; |
| |
| Arrays.sort (_leaders); |
| |
| final int [] _branch_locations = branches.keys (); |
| Arrays.sort (_branch_locations); |
| |
| final IntIntMap leaderToBlockID = new IntIntMap (_leaders.length); |
| |
| if (m_metadata) |
| { |
| // help construct a MethodDescriptor for the current method: |
| |
| m_methodBlockSizes = new int [blockCount]; |
| m_methodBlockOffsets = _leaders; |
| } |
| |
| // compute signature even if metadata is not needed (because the instrumented |
| // classdef uses it): |
| consumeSignatureData (m_methodID, _leaders); |
| |
| // pass 1: |
| |
| final int [] intHolder = new int [1]; |
| int instr_count = 0, prev_instr_count; |
| |
| for (int bl = 0, br = 0; bl < blockCount; ++ bl) |
| { |
| final Block block = new Block (); |
| blocks.m_blocks.add (block); |
| |
| final int leader = _leaders [bl]; |
| |
| block.m_first = leader; // m_first set |
| leaderToBlockID.put (leader, bl); |
| |
| final int next_leader = _leaders [bl + 1]; |
| boolean branchDelimited = false; |
| |
| prev_instr_count = instr_count; |
| |
| if (_branch_locations.length > br) |
| { |
| final int next_branch_location = _branch_locations [br]; |
| if (next_branch_location < next_leader) |
| { |
| branchDelimited = true; |
| |
| block.m_length = next_branch_location - leader; // m_length set |
| |
| if ($assert.ENABLED) |
| $assert.ASSERT (instructionMap.get (next_branch_location, intHolder), "no mapping for " + next_branch_location); |
| else |
| instructionMap.get (next_branch_location, intHolder); |
| |
| instr_count = intHolder [0] + 1; // [+ 1 for the branch] |
| |
| block.m_branch = (Branch) branches.get (next_branch_location); |
| block.m_branch.m_parentBlockID = bl; // m_branch set |
| |
| ++ br; |
| } |
| } |
| |
| if (! branchDelimited) |
| { |
| block.m_length = next_leader - leader; // m_length set |
| |
| if ($assert.ENABLED) |
| $assert.ASSERT (instructionMap.get (next_leader, intHolder), "no mapping for " + next_leader); |
| else |
| instructionMap.get (next_leader, intHolder); |
| |
| instr_count = intHolder [0]; |
| } |
| |
| block.m_instrCount = instr_count - prev_instr_count; // m_instrCount set |
| |
| if ($assert.ENABLED) $assert.ASSERT (block.m_length == 0 || block.m_instrCount > 0, "invalid instr count for block " + bl + ": " + block.m_instrCount); |
| if (m_metadata) m_methodBlockSizes [bl] = block.m_instrCount; |
| } |
| |
| // pass 2: |
| |
| final Block [] _blocks = (Block []) blocks.m_blocks.toArray (new Block [blockCount]); |
| |
| for (int l = 0; l < blockCount; ++ l) |
| { |
| final Block block = _blocks [l]; |
| |
| if (block.m_branch != null) |
| { |
| final int [] targets = block.m_branch.m_targets; |
| if (targets != null) |
| { |
| for (int t = 0, targetCount = targets.length; t < targetCount; ++ t) |
| { |
| // TODO: HACK ! convert block absolute offsets to block IDs: |
| |
| if ($assert.ENABLED) |
| $assert.ASSERT (leaderToBlockID.get (targets [t], intHolder), "no mapping for " + targets [t]); |
| else |
| leaderToBlockID.get (targets [t], intHolder); |
| |
| targets [t] = intHolder [0]; |
| } |
| } |
| } |
| } |
| |
| |
| // update block count map [used later by <clinit> visit]: |
| m_classBlockCounts [m_methodID] = blockCount; |
| |
| // actual basic block instrumentation: |
| { |
| if (trace2) m_log.trace2 ("visit", "instrumenting... "); |
| |
| // determine the local var index for the var that will alias COVERAGE_FIELD: |
| final int localVarIndex = attribute.m_max_locals ++; |
| |
| if (m_methodID == m_clinitID) // note: m_clinitID can be -1 if <clinit> has not been visited yet |
| { |
| // add a long stamp constant after all the original methods have been visited: |
| |
| m_stampIndex = m_cls.getConstants ().add (new CONSTANT_Long_info (m_classSignature)); |
| |
| blocks.m_header = new clinitHeader (this, localVarIndex); |
| } |
| else |
| blocks.m_header = new methodHeader (this, localVarIndex); |
| |
| int headerMaxStack = blocks.m_header.maxstack (); |
| int methodMaxStack = 0; |
| |
| for (int l = 0; l < blockCount; ++ l) |
| { |
| final Block block = _blocks [l]; |
| |
| final CodeSegment insertion = new BlockSegment (this, localVarIndex, l); |
| block.m_insertion = insertion; |
| |
| final int insertionMaxStack = insertion.maxstack (); |
| if (insertionMaxStack > methodMaxStack) |
| methodMaxStack = insertionMaxStack; |
| } |
| |
| // update maxstack as needed [it can only grow]: |
| { |
| final int oldMaxStack = attribute.m_max_stack; |
| |
| attribute.m_max_stack += methodMaxStack; // this is not precise, but still need to add because the insertion may be happening at the old maxstack point |
| |
| if (headerMaxStack > attribute.m_max_stack) |
| attribute.m_max_stack = headerMaxStack; |
| |
| if (trace3) m_log.trace3 ("visit", "increasing maxstack by " + (attribute.m_max_stack - oldMaxStack)); |
| } |
| |
| if ($assert.ENABLED) $assert.ASSERT (blocks.m_header != null, "header not set"); |
| } |
| |
| |
| // assemble all blocks into an instrumented code block: |
| if (trace2) m_log.trace2 ("visit", "assembling... "); |
| |
| int newcodeCapacity = codeSize << 1; |
| if (newcodeCapacity < EMIT_CTX_MIN_INIT_CAPACITY) newcodeCapacity = EMIT_CTX_MIN_INIT_CAPACITY; |
| |
| final ByteArrayOStream newcode = new ByteArrayOStream (newcodeCapacity); // TODO: empirical capacity |
| final EmitCtx emitctx = new EmitCtx (blocks, newcode); |
| |
| // create a jump adjustment map: |
| final int [] jumpAdjOffsets = new int [blockCount]; // room for initial 0 + (blockCount - 1) |
| final int [] jumpAdjMap = new int [jumpAdjOffsets.length]; // room for initial 0 + (blockCount - 1) |
| |
| if ($assert.ENABLED) $assert.ASSERT (jumpAdjOffsets.length == jumpAdjMap.length, |
| "jumpAdjOffsets and jumpAdjMap length mismatch"); |
| |
| // header: |
| blocks.m_header.emit (emitctx); |
| // jumpAdjOffsets [0] = 0: redundant |
| jumpAdjMap [0] = emitctx.m_out.size (); |
| |
| // rest of blocks: |
| for (int l = 0; l < blockCount; ++ l) |
| { |
| final Block block = _blocks [l]; |
| |
| if (l + 1 < blockCount) |
| { |
| jumpAdjOffsets [l + 1] = _blocks [l].m_first + _blocks [l].m_length; // implies the insertion goes just before the branch |
| } |
| |
| block.emit (emitctx, code); |
| |
| // TODO: this breaks if code can shrink: |
| if (l + 1 < blockCount) |
| { |
| jumpAdjMap [l + 1] = emitctx.m_out.size () - _blocks [l + 1].m_first; |
| } |
| } |
| |
| m_methodJumpAdjOffsets = jumpAdjOffsets; |
| m_methodJumpAdjValues = jumpAdjMap; |
| |
| if (trace3) |
| { |
| final StringBuffer s = new StringBuffer ("jump adjustment map:" + EOL); |
| for (int a = 0; a < jumpAdjOffsets.length; ++ a) |
| { |
| s.append (" " + jumpAdjOffsets [a] + ": +" + jumpAdjMap [a]); |
| if (a < jumpAdjOffsets.length - 1) s.append (EOL); |
| } |
| |
| m_log.trace3 ("visit", s.toString ()); |
| } |
| |
| final byte [] _newcode = newcode.getByteArray (); // note: not cloned |
| final int _newcodeSize = newcode.size (); |
| |
| // [all blocks have had their m_first adjusted] |
| |
| // backpatching pass: |
| if (trace3) m_log.trace3 ("visit", "backpatching " + emitctx.m_backpatchQueue.size () + " ip(s)"); |
| |
| for (Iterator i = emitctx.m_backpatchQueue.iterator (); i.hasNext (); ) |
| { |
| final int [] patchData = (int []) i.next (); |
| int ip = patchData [1]; |
| |
| if ($assert.ENABLED) $assert.ASSERT (patchData != null, "null patch data for ip " + ip); |
| |
| final int jump = _blocks [patchData [3]].m_first - patchData [2]; |
| if ($assert.ENABLED) $assert.ASSERT (jump > 0, "negative backpatch jump offset " + jump + " for ip " + ip); |
| |
| switch (patchData [0]) |
| { |
| case 4: |
| { |
| _newcode [ip ++] = (byte) (jump >>> 24); |
| _newcode [ip ++] = (byte) (jump >>> 16); |
| |
| } // *FALL THROUGH* |
| |
| case 2: |
| { |
| _newcode [ip ++] = (byte) (jump >>> 8); |
| _newcode [ip] = (byte) jump; |
| } |
| } |
| } |
| |
| attribute.setCode (_newcode, _newcodeSize); |
| if (trace2) m_log.trace2 ("visit", "method assembled into " + _newcodeSize + " code bytes"); |
| |
| |
| // adjust bytecode offsets in the exception table: |
| final IExceptionHandlerTable exceptionTable = attribute.getExceptionTable (); |
| for (int e = 0; e < exceptionTable.size (); ++ e) |
| { |
| final Exception_info exception = exceptionTable.get (e); |
| |
| int adjSegment = lowbound (jumpAdjOffsets, exception.m_start_pc); |
| exception.m_start_pc += jumpAdjMap [adjSegment]; |
| |
| adjSegment = lowbound (jumpAdjOffsets, exception.m_end_pc); |
| exception.m_end_pc += jumpAdjMap [adjSegment]; |
| |
| adjSegment = lowbound (jumpAdjOffsets, exception.m_handler_pc); |
| exception.m_handler_pc += jumpAdjMap [adjSegment]; |
| } |
| |
| |
| // visit other nested attributes [LineNumberAttribute, etc]: |
| final IAttributeCollection attributes = attribute.getAttributes (); |
| final int attributeCount = attributes.size (); |
| for (int a = 0; a < attributeCount; ++ a) |
| { |
| final Attribute_info nested = attributes.get (a); |
| nested.accept (this, ctx); |
| } |
| |
| return ctx; |
| } |
| |
| |
| public Object visit (final LineNumberTableAttribute_info attribute, final Object ctx) |
| { |
| final boolean trace2 = m_log.atTRACE2 (); |
| final boolean trace3 = m_log.atTRACE3 (); |
| if (trace2) m_log.trace2 ("visit", "attribute: [" + attribute.getName (m_cls) + "]"); |
| |
| final int lineCount = attribute.size (); |
| |
| if (m_metadata) |
| { |
| if (trace2) m_log.trace2 ("visit", "processing line number table for metadata..."); |
| |
| final int blockCount = m_classBlockCounts [m_methodID]; |
| if ($assert.ENABLED) $assert.ASSERT (blockCount > 0, "invalid method block count for method " + m_methodID); |
| |
| final int [][] blockLineMap = new int [blockCount][]; |
| |
| if ($assert.ENABLED) $assert.ASSERT (blockCount + 1 == m_methodBlockOffsets.length, |
| "invalid m_methodBlockOffsets"); |
| |
| if (lineCount == 0) |
| { |
| for (int bl = 0; bl < blockCount; ++ bl) |
| blockLineMap [bl] = EMPTY_INT_ARRAY; |
| } |
| else |
| { |
| // TODO: this code does not work if there are multiple LineNumberTableAttribute attributes for the method |
| |
| final LineNumber_info [] sortedLines = new LineNumber_info [attribute.size ()]; |
| |
| for (int l = 0; l < lineCount; ++ l) |
| { |
| final LineNumber_info line = attribute.get (l); |
| sortedLines [l] = line; |
| } |
| |
| Arrays.sort (sortedLines, LINE_NUMBER_COMPARATOR); |
| |
| // construct block->line mapping: TODO: is the loop below the fastest it can be done? |
| |
| final int [] methodBlockOffsets = m_methodBlockOffsets; |
| |
| LineNumber_info line = sortedLines [0]; // never null |
| LineNumber_info prev_line = null; |
| |
| // remember the first line: |
| m_methodFirstLine = line.m_line_number; |
| |
| for (int bl = 0, l = 0; bl < blockCount; ++ bl) |
| { |
| final IntSet blockLines = new IntSet (); |
| |
| if ((prev_line != null) && (line.m_start_pc > methodBlockOffsets [bl])) |
| { |
| blockLines.add (prev_line.m_line_number); |
| } |
| |
| while (line.m_start_pc < methodBlockOffsets [bl + 1]) |
| { |
| blockLines.add (line.m_line_number); |
| |
| if (l == lineCount - 1) |
| break; |
| else |
| { |
| prev_line = line; |
| line = sortedLines [++ l]; // advance to the next line |
| } |
| } |
| |
| blockLineMap [bl] = blockLines.values (); |
| } |
| } |
| |
| m_classBlockMetadata [m_methodID] = blockLineMap; |
| |
| if (trace3) |
| { |
| StringBuffer s = new StringBuffer ("block-line map for method #" + m_methodID + ":"); |
| for (int bl = 0; bl < blockCount; ++ bl) |
| { |
| s.append (EOL); |
| s.append (" block " + bl + ": "); |
| |
| final int [] lines = blockLineMap [bl]; |
| for (int l = 0; l < lines.length; ++ l) |
| { |
| if (l != 0) s.append (", "); |
| s.append (lines [l]); |
| } |
| } |
| |
| m_log.trace3 ("visit", s.toString ()); |
| } |
| } |
| |
| for (int l = 0; l < lineCount; ++ l) |
| { |
| final LineNumber_info line = attribute.get (l); |
| |
| // TODO: make this faster using either table assist or the sorted array in 'sortedLines' |
| |
| // adjust bytecode offset for line number mapping: |
| int adjSegment = lowbound (m_methodJumpAdjOffsets, line.m_start_pc); |
| line.m_start_pc += m_methodJumpAdjValues [adjSegment]; |
| } |
| |
| return ctx; |
| } |
| |
| // TODO: line var table as well |
| |
| |
| // no-op visits: |
| |
| public Object visit (final ExceptionsAttribute_info attribute, final Object ctx) |
| { |
| return ctx; |
| } |
| |
| public Object visit (final ConstantValueAttribute_info attribute, final Object ctx) |
| { |
| return ctx; |
| } |
| |
| public Object visit (final SourceFileAttribute_info attribute, final Object ctx) |
| { |
| m_classSrcFileName = attribute.getSourceFile (m_cls).m_value; |
| |
| return ctx; |
| } |
| |
| public Object visit (final SyntheticAttribute_info attribute, final Object ctx) |
| { |
| return ctx; |
| } |
| |
| public Object visit (final BridgeAttribute_info attribute, final Object ctx) |
| { |
| return ctx; |
| } |
| |
| public Object visit (final InnerClassesAttribute_info attribute, final Object ctx) |
| { |
| return ctx; |
| } |
| |
| public Object visit (final GenericAttribute_info attribute, final Object ctx) |
| { |
| return ctx; |
| } |
| |
| // protected: ............................................................. |
| |
| // package: ............................................................... |
| |
| // private: ............................................................... |
| |
| |
| private static final class BlockList |
| { |
| BlockList () |
| { |
| m_blocks = new ArrayList (); |
| } |
| |
| BlockList (final int capacity) |
| { |
| m_blocks = new ArrayList (capacity); |
| } |
| |
| final List /* Block */ m_blocks; // TODO: might as well use an array here? |
| CodeSegment m_header; |
| |
| } // end of nested class |
| |
| |
| private static final class Block |
| { |
| int m_first; // inclusive offset of the leader instruction [first instr in the block] |
| //int m_last; // exclusive offset of the last non-branch instruction [excludes possible control transfer at the end] |
| int m_length; // excluding the branch statement [can be 0] |
| int m_instrCount; // size in instructions, including the [optional] original branch; [m_insertion is not counted] |
| |
| // NOTE: it is possible that m_first == m_last [the block is empty except for a possible control transfer instr] |
| |
| // public int maxlength () |
| // { |
| // // TODO: cache |
| // return m_length |
| //// + (m_insertion != null ? m_insertion.maxlength () : 0) |
| // + (m_branch != null ? m_branch.maxlength () : 0); |
| // } |
| |
| /** |
| * When this is called, all previous blocks have been written out and |
| * their m_first have been updated. |
| */ |
| void emit (final EmitCtx ctx, final byte [] code) // TODO: move 'code' into 'ctx' |
| { |
| final ByteArrayOStream out = ctx.m_out; |
| final int first = m_first; |
| |
| m_first = out.size (); // update position to be within new code array |
| |
| for (int i = 0, length = m_length; i < length; ++ i) |
| { |
| out.write (code [first + i]); |
| } |
| |
| if (m_insertion != null) |
| m_insertion.emit (ctx); |
| |
| if (m_branch != null) |
| m_branch.emit (ctx); |
| } |
| |
| public CodeSegment m_insertion; |
| public Branch m_branch; // falling through is implied by this being null |
| |
| } // end of nested class |
| |
| |
| static final class EmitCtx |
| { |
| // TODO: profile to check that ByteArrayOStream.write() is not the bottleneck |
| |
| EmitCtx (final BlockList blocks, final ByteArrayOStream out) |
| { |
| m_blocks = blocks; |
| m_out = out; |
| |
| m_backpatchQueue = new ArrayList (); |
| } |
| |
| final BlockList m_blocks; |
| final ByteArrayOStream m_out; |
| final List /* int[4] */ m_backpatchQueue; |
| |
| } // end of nested class |
| |
| |
| /** |
| * A Branch does not add any maxlocals/maxstack requirements. |
| */ |
| static abstract class Branch |
| { |
| protected Branch (final int opcode, final int [] targets) |
| { |
| m_opcode = (byte) opcode; |
| m_targets = targets; |
| } |
| |
| /* |
| * Called when targets are block IDs, before emitting. |
| */ |
| int maxlength () { return 1; } |
| |
| abstract void emit (EmitCtx ctx); |
| |
| // TODO: this method must signal when it is necessary to switch to long jump form |
| protected final void emitJumpOffset2 (final EmitCtx ctx, final int ip, final int targetBlockID) |
| { |
| final ByteArrayOStream out = ctx.m_out; |
| |
| if (targetBlockID <= m_parentBlockID) |
| { |
| // backwards branch: |
| final int jumpOffset = ((Block) ctx.m_blocks.m_blocks.get (targetBlockID)).m_first - ip; |
| |
| out.write2 (jumpOffset >>> 8, // targetbyte1 |
| jumpOffset); // targetbyte2 |
| } |
| else |
| { |
| final int jumpOffsetLocation = out.size (); |
| |
| // else write out zeros and submit for backpatching: |
| out.write2 (0, |
| 0); |
| |
| ctx.m_backpatchQueue.add (new int [] {2, jumpOffsetLocation, ip, targetBlockID}); |
| } |
| } |
| |
| protected final void emitJumpOffset4 (final EmitCtx ctx, final int ip, final int targetBlockID) |
| { |
| final ByteArrayOStream out = ctx.m_out; |
| |
| if (targetBlockID <= m_parentBlockID) |
| { |
| // backwards branch: |
| final int jumpOffset = ((Block) ctx.m_blocks.m_blocks.get (targetBlockID)).m_first - ip; |
| |
| out.write4 (jumpOffset >>> 24, // targetbyte1 |
| jumpOffset >>> 16, // targetbyte2 |
| jumpOffset >>> 8, // targetbyte3 |
| jumpOffset); // targetbyte4 |
| } |
| else |
| { |
| final int jumpOffsetLocation = out.size (); |
| |
| // else write out zeros and submit for backpatching: |
| out.write4 (0, |
| 0, |
| 0, |
| 0); |
| |
| ctx.m_backpatchQueue.add (new int [] {4, jumpOffsetLocation, ip, targetBlockID}); |
| } |
| } |
| |
| final byte m_opcode; |
| final int [] m_targets; // could be code offsets or block IDs |
| |
| int m_parentBlockID; |
| |
| } // end of nested class |
| |
| |
| // TODO: these could be static instance-pooled |
| static final class TERMINATE extends Branch // _[x]return, _athrow |
| { |
| TERMINATE (final int opcode) |
| { |
| super (opcode, null); |
| } |
| |
| int length () { return 1; } |
| |
| void emit (final EmitCtx ctx) |
| { |
| ctx.m_out.write (m_opcode); |
| } |
| |
| } // end of nested class |
| |
| |
| static final class RET extends Branch // [wide] ret |
| { |
| RET (final int opcode, final int varindex) |
| { |
| super (opcode, null); |
| m_varindex = varindex; |
| } |
| |
| int length () { return (m_varindex <= 0xFF) ? 2 : 3; } |
| |
| void emit (final EmitCtx ctx) |
| { |
| final ByteArrayOStream out = ctx.m_out; |
| |
| if (m_varindex <= 0xFF) |
| { |
| out.write2 (m_opcode, |
| m_varindex); // indexbyte |
| } |
| else |
| { |
| out.write4 (_wide, |
| m_opcode, |
| m_varindex >>> 8, // indexbyte1 |
| m_varindex); // indexbyte2 |
| } |
| } |
| |
| final int m_varindex; |
| |
| } // end of nested class |
| |
| |
| static final class JUMP2 extends Branch // _goto, _jsr |
| { |
| JUMP2 (final int opcode, final int target) |
| { |
| super (opcode, new int [] {target}); |
| } |
| |
| int maxlength () { return 5; } |
| |
| void emit (final EmitCtx ctx) |
| { |
| final ByteArrayOStream out = ctx.m_out; |
| final int targetBlockID = m_targets [0]; |
| final int ip = out.size (); |
| |
| // TODO: switch to 4-byte long form if jump > 32k |
| |
| out.write (m_opcode); |
| emitJumpOffset2 (ctx, ip, targetBlockID); |
| } |
| |
| } // end of nested class |
| |
| |
| static final class JUMP4 extends Branch // _goto_w, _jsr_w |
| { |
| JUMP4 (final int opcode, final int target) |
| { |
| super (opcode, new int [] {target}); |
| } |
| |
| int maxlength () { return 5; } |
| |
| void emit (final EmitCtx ctx) |
| { |
| final ByteArrayOStream out = ctx.m_out; |
| final int targetBlockID = m_targets [0]; |
| final int ip = out.size (); |
| |
| out.write (m_opcode); |
| emitJumpOffset4 (ctx, ip, targetBlockID); |
| } |
| |
| } // end of nested class |
| |
| |
| static final class IFJUMP2 extends Branch // _ifxxx |
| { |
| IFJUMP2 (final int opcode, final int target) |
| { |
| super (opcode, new int [] {target}); |
| } |
| |
| int maxlength () { return 8; } |
| |
| void emit (final EmitCtx ctx) |
| { |
| final ByteArrayOStream out = ctx.m_out; |
| final int targetBlockID = m_targets [0]; |
| final int ip = out.size (); |
| |
| // TODO: switch to 8-byte long form if jump > 32k |
| |
| out.write (m_opcode); |
| emitJumpOffset2 (ctx, ip, targetBlockID); |
| } |
| |
| } // end of nested class |
| |
| |
| static final class LOOKUPSWITCH extends Branch |
| { |
| LOOKUPSWITCH (final int [] keys, final int [] targets /* first one is default */) |
| { |
| super (_lookupswitch, targets); |
| m_keys = keys; |
| } |
| |
| int maxlength () { return 12 + (m_keys.length << 3); } |
| |
| void emit (final EmitCtx ctx) |
| { |
| final ByteArrayOStream out = ctx.m_out; |
| final int ip = out.size (); |
| |
| out.write (m_opcode); |
| |
| // padding bytes: |
| for (int p = 0, padCount = 3 - (ip & 3); p < padCount; ++ p) out.write (0); |
| |
| // default: |
| emitJumpOffset4 (ctx, ip, m_targets [0]); |
| |
| // npairs count: |
| final int npairs = m_keys.length; |
| out.write4 (npairs >>> 24, // byte1 |
| npairs >>> 16, // byte2 |
| npairs >>> 8, // byte3 |
| npairs); // byte4 |
| |
| // keyed targets: |
| for (int t = 1; t < m_targets.length; ++ t) |
| { |
| final int key = m_keys [t - 1]; |
| out.write4 (key >>> 24, // byte1 |
| key >>> 16, // byte2 |
| key >>> 8, // byte3 |
| key); // byte4 |
| |
| // key target: |
| emitJumpOffset4 (ctx, ip, m_targets [t]); |
| } |
| } |
| |
| final int [] m_keys; |
| |
| } // end of nested class |
| |
| |
| static final class TABLESWITCH extends Branch |
| { |
| TABLESWITCH (final int low, final int high, final int [] targets /* first one is default */) |
| { |
| super (_tableswitch, targets); |
| m_low = low; |
| m_high = high; |
| } |
| |
| int maxlength () { return 12 + (m_targets.length << 2); } |
| |
| void emit (final EmitCtx ctx) |
| { |
| final ByteArrayOStream out = ctx.m_out; |
| final int ip = out.size (); |
| |
| // TODO: switch to long form for any jump > 32k |
| |
| out.write (m_opcode); |
| |
| // padding bytes: |
| for (int p = 0, padCount = 3 - (ip & 3); p < padCount; ++ p) out.write (0); |
| |
| // default: |
| emitJumpOffset4 (ctx, ip, m_targets [0]); |
| |
| // low, high: |
| final int low = m_low; |
| out.write4 (low >>> 24, // byte1 |
| low >>> 16, // byte2 |
| low >>> 8, // byte3 |
| low); // byte4 |
| |
| final int high = m_high; |
| out.write4 (high >>> 24, // byte1 |
| high >>> 16, // byte2 |
| high >>> 8, // byte3 |
| high); // byte4 |
| |
| // targets: |
| for (int t = 1; t < m_targets.length; ++ t) |
| { |
| // key target: |
| emitJumpOffset4 (ctx, ip, m_targets [t]); |
| } |
| } |
| |
| final int m_low, m_high; |
| |
| } // end of nested class |
| |
| |
| /** |
| * TODO: CodeSegment right now must be 100% position-independent code; |
| * otherwise it must follow maxlengtt() Branch pattern... |
| */ |
| static abstract class CodeSegment |
| { |
| CodeSegment (final InstrVisitor visitor) |
| { |
| m_visitor = visitor; // TODO: will this field be used? |
| } |
| |
| abstract int length (); |
| abstract int maxstack (); |
| abstract void emit (EmitCtx ctx); |
| |
| |
| final InstrVisitor m_visitor; |
| |
| } // end of nested class |
| |
| |
| static final class clinitHeader extends CodeSegment |
| { |
| clinitHeader (final InstrVisitor visitor, final int localVarIndex) |
| { |
| super (visitor); |
| final ByteArrayOStream buf = new ByteArrayOStream (CLINIT_HEADER_INIT_CAPACITY); |
| m_buf = buf; |
| |
| final ClassDef cls = visitor.m_cls; |
| |
| final int [] blockCounts = visitor.m_classBlockCounts; |
| final int instrMethodCount = visitor.m_classInstrMethodCount; // actual number of methods to instrument may be less than the size of the block map |
| if ($assert.ENABLED) $assert.ASSERT (blockCounts != null && blockCounts.length >= instrMethodCount, |
| "invalid block count map"); |
| |
| final int coverageFieldrefIndex = visitor.m_coverageFieldrefIndex; |
| final int preclinitMethodrefIndex = visitor.m_preclinitMethodrefIndex; |
| final int classNameConstantIndex = visitor.m_classNameConstantIndex; |
| |
| if ($assert.ENABLED) |
| { |
| $assert.ASSERT (coverageFieldrefIndex > 0, "invalid coverageFieldrefIndex"); |
| $assert.ASSERT (preclinitMethodrefIndex > 0, "invalid registerMethodrefIndex"); |
| $assert.ASSERT (classNameConstantIndex > 0, "invalid classNameConstantIndex"); |
| } |
| |
| // init and load COVERAGE_FIELD: |
| buf.write3 (_invokestatic, |
| preclinitMethodrefIndex >>> 8, // indexbyte1 |
| preclinitMethodrefIndex); // indexbyte2 |
| |
| // [stack +1] |
| |
| // TODO: disable this when there are no real blocks following? |
| // [in general, use a different template when this method contains a single block] |
| |
| // TODO: if this method has been added by us, do not instrument its blocks |
| |
| // push int literal equal to 'methodID' [for the parent method]: |
| CodeGen.push_int_value (buf, cls, visitor.m_methodID); |
| |
| // [stack +2] |
| |
| // push subarray reference: |
| buf.write (_aaload); |
| |
| // [stack +1] |
| |
| // store it in alias var: |
| CodeGen.store_local_object_var (buf, localVarIndex); |
| |
| // [stack +0] |
| } |
| |
| int length () { return m_buf.size (); } |
| int maxstack () { return 2; } // note: needs to be updated each time emitted code changes |
| |
| void emit (final EmitCtx ctx) |
| { |
| // TODO: better error handling here? |
| try |
| { |
| m_buf.writeTo (ctx.m_out); |
| } |
| catch (IOException ioe) |
| { |
| if ($assert.ENABLED) $assert.ASSERT (false, ioe.toString ()); |
| } |
| } |
| |
| |
| private final ByteArrayOStream m_buf; |
| |
| private static final int CLINIT_HEADER_INIT_CAPACITY = 32; // covers about 80% of classes (no reallocation) |
| |
| } // end of nested class |
| |
| |
| static final class methodHeader extends CodeSegment |
| { |
| methodHeader (final InstrVisitor visitor, final int localVarIndex) |
| { |
| super (visitor); |
| final ByteArrayOStream buf = new ByteArrayOStream (HEADER_INIT_CAPACITY); |
| m_buf = buf; |
| |
| final ClassDef cls = visitor.m_cls; |
| final int coverageFieldrefIndex = visitor.m_coverageFieldrefIndex; |
| final int preclinitMethodrefIndex = visitor.m_preclinitMethodrefIndex; |
| |
| // TODO: disable this when there are no real blocks following? |
| // [in general, use a different template when this method contains a single block] |
| |
| // push ref to the static field and dup it: |
| buf.write4 (_getstatic, |
| coverageFieldrefIndex >>> 8, // indexbyte1 |
| coverageFieldrefIndex, // indexbyte2 |
| _dup); |
| |
| // [stack +2] |
| |
| // SF FR 971186: check if it is null and if so run the field |
| // init and class RT register code (only relevant for |
| // methods that can be executed ahead of <clinit>) [rare] |
| |
| buf.write3 (_ifnonnull, // skip over pre-<clinit> method call |
| 0, |
| 3 + /* size of the block below */ 4); |
| |
| // [stack +1] |
| |
| // block: call pre-<clinit> method |
| { |
| buf.write4 (_pop, |
| _invokestatic, |
| preclinitMethodrefIndex >>> 8, // indexbyte1 |
| preclinitMethodrefIndex); // indexbyte2 |
| |
| // [stack +1] |
| } |
| |
| // push int literal equal to 'methodID': |
| CodeGen.push_int_value (buf, cls, visitor.m_methodID); |
| |
| // [stack +2] |
| |
| // push subarray reference: |
| buf.write (_aaload); |
| |
| // [stack +1] |
| |
| // store it in alias var: |
| CodeGen.store_local_object_var (buf, localVarIndex); |
| |
| // [stack +0] |
| } |
| |
| int length () { return m_buf.size (); } |
| int maxstack () { return 2; } // note: needs to be updated each time emitted code changes |
| |
| void emit (final EmitCtx ctx) |
| { |
| // TODO: better error handling here? |
| try |
| { |
| m_buf.writeTo (ctx.m_out); |
| } |
| catch (IOException ioe) |
| { |
| if ($assert.ENABLED) $assert.ASSERT (false, ioe.toString ()); |
| } |
| } |
| |
| |
| private final ByteArrayOStream m_buf; |
| |
| private static final int HEADER_INIT_CAPACITY = 16; |
| |
| } // end of nested class |
| |
| |
| static final class BlockSegment extends CodeSegment |
| { |
| public BlockSegment (final InstrVisitor visitor, final int localVarIndex, final int blockID) |
| { |
| super (visitor); |
| final ByteArrayOStream buf = new ByteArrayOStream (BLOCK_INIT_CAPACITY); |
| m_buf = buf; |
| |
| final ClassDef cls = visitor.m_cls; |
| |
| // push alias var: |
| CodeGen.load_local_object_var (buf, localVarIndex); |
| |
| // [stack +1] |
| |
| // push int value equal to 'blockID': |
| CodeGen.push_int_value (buf, cls, blockID); |
| |
| // [stack +2] |
| |
| // push boolean 'true': |
| buf.write2 (_iconst_1, |
| |
| // [stack +3] |
| |
| // store it in the array: |
| _bastore); |
| |
| // [stack +0] |
| } |
| |
| int length () { return m_buf.size (); } |
| int maxstack () { return 3; } // note: needs to be updated each time emitted code changes |
| |
| void emit (final EmitCtx ctx) |
| { |
| // TODO: better error handling here? |
| try |
| { |
| m_buf.writeTo (ctx.m_out); |
| } |
| catch (IOException ioe) |
| { |
| if ($assert.ENABLED) $assert.ASSERT (false, ioe.toString ()); |
| } |
| } |
| |
| |
| private final ByteArrayOStream m_buf; |
| |
| private static final int BLOCK_INIT_CAPACITY = 16; |
| |
| } // end of nested class |
| |
| |
| private static final class LineNumberComparator implements Comparator |
| { |
| public final int compare (final Object o1, final Object o2) |
| { |
| return ((LineNumber_info) o1).m_start_pc - ((LineNumber_info) o2).m_start_pc; |
| } |
| |
| } // end of nested class |
| |
| |
| |
| private void setClassName (final String fullName) |
| { |
| if ($assert.ENABLED) $assert.ASSERT (fullName != null && fullName.length () > 0, |
| "null or empty input: fullName"); |
| |
| final int lastSlash = fullName.lastIndexOf ('/'); |
| if (lastSlash < 0) |
| { |
| m_classPackageName = ""; |
| m_className = fullName; |
| } |
| else |
| { |
| if ($assert.ENABLED) $assert.ASSERT (lastSlash < fullName.length () - 1, |
| "malformed class name [" + fullName + "]"); |
| |
| m_classPackageName = fullName.substring (0, lastSlash); |
| m_className = fullName.substring (lastSlash + 1); |
| } |
| } |
| |
| private void consumeSignatureData (final int methodID, final int [] basicBlockOffsets) |
| { |
| // note: by itself, this is not a very good checksum for a class def; |
| // however, it is fast to compute and since it will be used along with |
| // a class name it should be good at detecting structural changes that |
| // matter to us (method and basic block ordering/sizes) |
| |
| final int temp1 = basicBlockOffsets.length; |
| long temp2 = NBEAST * m_classSignature + (methodID + 1) * temp1; |
| |
| for (int i = 1; i < temp1; ++ i) // skip the initial 0 offset |
| { |
| temp2 = NBEAST * temp2 + basicBlockOffsets [i]; |
| } |
| |
| m_classSignature = temp2; |
| } |
| |
| // TODO: use a compilation flag to use table assist here instead of binary search |
| // BETTER YET: use binsearch for online mode and table assist for offline [when memory is not an issue] |
| |
| /** |
| * Returns the maximum index 'i' such that (values[i] <= x). values[] |
| * contains distinct non-negative integers in increasing order. values[0] is 0, |
| * 'x' is non-negative. |
| * |
| * Edge case: |
| * returns values.length-1 if values [values.length - 1] < x |
| */ |
| private static int lowbound (final int [] values, final int x) |
| { |
| int low = 0, high = values.length - 1; |
| |
| // assertion: lb is in [low, high] |
| |
| while (low <= high) |
| { |
| final int m = (low + high) >> 1; |
| final int v = values [m]; |
| |
| if (v == x) |
| return m; |
| else if (v < x) |
| low = m + 1; |
| else // v > x |
| high = m - 1; |
| } |
| |
| return high; |
| } |
| |
| private void reset () |
| { |
| // TODO: check that all state is reset |
| |
| m_instrument = false; |
| m_metadata = false; |
| m_ignoreAlreadyInstrumented = false; |
| |
| m_cls = null; |
| m_classPackageName = null; |
| m_className = null; |
| m_classSrcFileName = null; |
| m_classBlockMetadata = null; |
| m_classMethodDescriptors = null; |
| |
| m_syntheticStringIndex = -1; |
| m_coverageFieldrefIndex = -1; |
| m_registerMethodrefIndex = -1; |
| m_preclinitMethodrefIndex = -1; |
| m_classNameConstantIndex = -1; |
| m_clinitID = -1; |
| m_clinitStatus = 0; |
| m_classInstrMethodCount = -1; |
| m_classBlockCounts = null; |
| m_classSignature = 0; |
| |
| m_methodID = -1; |
| m_methodName = null; |
| m_methodFirstLine = 0; |
| m_methodBlockOffsets = null; |
| m_methodJumpAdjOffsets = null; |
| m_methodJumpAdjValues = null; |
| } |
| |
| |
| private final boolean m_excludeSyntheticMethods; |
| private final boolean m_excludeBridgeMethods; |
| private final boolean m_doSUIDCompensation; |
| |
| private final Logger m_log; // instr visitor logging context is latched at construction time |
| |
| // non-resettable state: |
| |
| private boolean m_warningIssued; |
| |
| |
| // resettable state: |
| |
| private boolean m_instrument; |
| private boolean m_metadata; |
| private boolean m_ignoreAlreadyInstrumented; |
| |
| /*private*/ ClassDef m_cls; |
| private String m_classPackageName; // in JVM format [com/vladium/...]; empty string for default package |
| private String m_className; // in JVM format [<init>, <clinit>, etc], relative to 'm_classPackageName' |
| private String m_classSrcFileName; |
| private int [][][] m_classBlockMetadata; // methodID->(blockID->line) map [valid only if 'm_constructMetadata' is true; null if the method has not line number table] |
| private MethodDescriptor [] m_classMethodDescriptors; |
| |
| // current class scope: |
| private int m_syntheticStringIndex; // index of CONSTANT_Utf8 String that reads "Synthetic" |
| /*private*/ int m_coverageFieldrefIndex; // index of the Fieldref for COVERAGE_FIELD |
| private int m_registerMethodrefIndex; // index of Methodref for RT.r() |
| /*private*/ int m_preclinitMethodrefIndex; // index of Methodref for pre-<clinit> method |
| /*private*/ int m_classNameConstantIndex; // index of CONSTANT_String that is the class name [in JVM format] |
| private int m_stampIndex; // index of CONSTANT_Long that is the class instr stamp |
| private int m_clinitID; // offset of <clinit> method [-1 if not determined yet] |
| private int m_clinitStatus; |
| /*private*/ int m_classInstrMethodCount; // the number of slots in 'm_classBlockCounts' corresponding to methods to be instrumented for coverage |
| /*private*/ int [] m_classBlockCounts; // basic block counts for all methods [only valid just before <clinit> is processed] |
| private long m_classSignature; |
| |
| // current method scope: |
| /*private*/ int m_methodID; // offset of current method being instrumented |
| private String m_methodName; |
| private int m_methodFirstLine; |
| private int [] m_methodBlockOffsets; // [unadjusted] basic block boundaries [length = m_classBlockCounts[m_methodID]+1; the last slot is method bytecode length] |
| private int [] m_methodBlockSizes; |
| private int [] m_methodJumpAdjOffsets; // TODO: length ? |
| private int [] m_methodJumpAdjValues; // TODO: length ? |
| |
| |
| private static final long NBEAST = 16661; // prime |
| |
| private static final String COVERAGE_FIELD_NAME = "$VR" + "c"; |
| private static final String SUID_FIELD_NAME = "serialVersionUID"; |
| private static final String PRECLINIT_METHOD_NAME = "$VR" + "i"; |
| |
| private static final String JAVA_IO_SERIALIZABLE_NAME = "java/io/Serializable"; |
| private static final String JAVA_IO_EXTERNALIZABLE_NAME = "java/io/Externalizable"; |
| |
| private static final int EMIT_CTX_MIN_INIT_CAPACITY = 64; // good value determined empirically |
| private static final int PRECLINIT_INIT_CAPACITY = 128; // covers about 80% of classes (no reallocation) |
| private static final boolean MARK_ADDED_ELEMENTS_SYNTHETIC = true; |
| |
| /* It appears that nested classes and interfaces ought to be marked |
| * as Synthetic; however, neither Sun nor IBM compilers seem to do this. |
| * |
| * (As a side note, implied no-arg constructors ought to be marked as |
| * synthetic as well, but Sun's javac is not consistent about that either) |
| */ |
| private static final boolean SKIP_SYNTHETIC_CLASSES = false; |
| |
| private static final LineNumberComparator LINE_NUMBER_COMPARATOR = new LineNumberComparator (); |
| |
| private static final byte [] EMPTY_BYTE_ARRAY = new byte [0]; |
| |
| } // end of class |
| // ---------------------------------------------------------------------------- |
