/** * Constructs an instance. * * @param encoded encoded debug info * @param codesize size of code block in code units * @param regSize register size, in register units, of the register space used by this method * @param isStatic true if method is static * @param ref method descriptor of method this debug info is for * @param file dex file this debug info will be stored in */ DebugInfoDecoder( byte[] encoded, int codesize, int regSize, boolean isStatic, CstMethodRef ref, DexFile file) { if (encoded == null) { throw new NullPointerException("encoded == null"); } this.encoded = encoded; this.isStatic = isStatic; this.desc = ref.getPrototype(); this.file = file; this.regSize = regSize; positions = new ArrayList<PositionEntry>(); locals = new ArrayList<LocalEntry>(); this.codesize = codesize; lastEntryForReg = new LocalEntry[regSize]; int idx = -1; try { idx = file.getStringIds().indexOf(new CstString("this")); } catch (IllegalArgumentException ex) { /* * Silently tolerate not finding "this". It just means that * no method has local variable info that looks like * a standard instance method. */ } thisStringIdx = idx; }
/** {@inheritDoc} */ @Override protected void place0(Section addedTo, int offset) { // Encode the data and note the size. try { encoded = encode(addedTo.getFile(), null, null, null, false); setWriteSize(encoded.length); } catch (RuntimeException ex) { throw ExceptionWithContext.withContext( ex, "...while placing debug info for " + ref.toHuman()); } }
/** * Validates an encoded debug info stream against data used to encode it, throwing an exception if * they do not match. Used to validate the encoder. * * @param info encoded debug info * @param file {@code non-null;} file to refer to during decoding * @param ref {@code non-null;} method whose info is being decoded * @param code {@code non-null;} original code object that was encoded * @param isStatic whether the method is static */ public static void validateEncode( byte[] info, DexFile file, CstMethodRef ref, DalvCode code, boolean isStatic) { PositionList pl = code.getPositions(); LocalList ll = code.getLocals(); DalvInsnList insns = code.getInsns(); int codeSize = insns.codeSize(); int countRegisters = insns.getRegistersSize(); try { validateEncode0(info, codeSize, countRegisters, isStatic, ref, file, pl, ll); } catch (RuntimeException ex) { System.err.println("instructions:"); insns.debugPrint(System.err, " ", true); System.err.println("local list:"); ll.debugPrint(System.err, " "); throw ExceptionWithContext.withContext(ex, "while processing " + ref.toHuman()); } }
/** * Processes the methods of the given class. * * @param cf {@code non-null;} class being translated * @param cfOptions {@code non-null;} options for class translation * @param dexOptions {@code non-null;} options for dex output * @param out {@code non-null;} output class */ private static void processMethods( DirectClassFile cf, CfOptions cfOptions, DexOptions dexOptions, ClassDefItem out) { CstType thisClass = cf.getThisClass(); MethodList methods = cf.getMethods(); int sz = methods.size(); for (int i = 0; i < sz; i++) { Method one = methods.get(i); try { CstMethodRef meth = new CstMethodRef(thisClass, one.getNat()); int accessFlags = one.getAccessFlags(); boolean isStatic = AccessFlags.isStatic(accessFlags); boolean isPrivate = AccessFlags.isPrivate(accessFlags); boolean isNative = AccessFlags.isNative(accessFlags); boolean isAbstract = AccessFlags.isAbstract(accessFlags); boolean isConstructor = meth.isInstanceInit() || meth.isClassInit(); DalvCode code; if (isNative || isAbstract) { // There's no code for native or abstract methods. code = null; } else { ConcreteMethod concrete = new ConcreteMethod( one, cf, (cfOptions.positionInfo != PositionList.NONE), cfOptions.localInfo); TranslationAdvice advice; advice = DexTranslationAdvice.THE_ONE; RopMethod rmeth = Ropper.convert(concrete, advice); RopMethod nonOptRmeth = null; int paramSize; paramSize = meth.getParameterWordCount(isStatic); String canonicalName = thisClass.getClassType().getDescriptor() + "." + one.getName().getString(); if (cfOptions.optimize && OptimizerOptions.shouldOptimize(canonicalName)) { if (DEBUG) { System.err.println("Optimizing " + canonicalName); } nonOptRmeth = rmeth; rmeth = Optimizer.optimize(rmeth, paramSize, isStatic, cfOptions.localInfo, advice); if (DEBUG) { OptimizerOptions.compareOptimizerStep( nonOptRmeth, paramSize, isStatic, cfOptions, advice, rmeth); } if (cfOptions.statistics) { CodeStatistics.updateRopStatistics(nonOptRmeth, rmeth); } } LocalVariableInfo locals = null; if (cfOptions.localInfo) { locals = LocalVariableExtractor.extract(rmeth); } code = RopTranslator.translate(rmeth, cfOptions.positionInfo, locals, paramSize, dexOptions); if (cfOptions.statistics && nonOptRmeth != null) { updateDexStatistics( cfOptions, dexOptions, rmeth, nonOptRmeth, locals, paramSize, concrete.getCode().size()); } } // Preserve the synchronized flag as its "declared" variant... if (AccessFlags.isSynchronized(accessFlags)) { accessFlags |= AccessFlags.ACC_DECLARED_SYNCHRONIZED; /* * ...but only native methods are actually allowed to be * synchronized. */ if (!isNative) { accessFlags &= ~AccessFlags.ACC_SYNCHRONIZED; } } if (isConstructor) { accessFlags |= AccessFlags.ACC_CONSTRUCTOR; } TypeList exceptions = AttributeTranslator.getExceptions(one); EncodedMethod mi = new EncodedMethod(meth, accessFlags, code, exceptions); if (meth.isInstanceInit() || meth.isClassInit() || isStatic || isPrivate) { out.addDirectMethod(mi); } else { out.addVirtualMethod(mi); } Annotations annotations = AttributeTranslator.getMethodAnnotations(one); if (annotations.size() != 0) { out.addMethodAnnotations(meth, annotations); } AnnotationsList list = AttributeTranslator.getParameterAnnotations(one); if (list.size() != 0) { out.addParameterAnnotations(meth, list); } } catch (RuntimeException ex) { String msg = "...while processing " + one.getName().toHuman() + " " + one.getDescriptor().toHuman(); throw ExceptionWithContext.withContext(ex, msg); } } }