| /* |
| * [The "BSD licence"] |
| * Copyright (c) 2010 Ben Gruver (JesusFreke) |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| package org.jf.baksmali.Adaptors; |
| |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.Lists; |
| import org.jf.baksmali.Adaptors.Debug.DebugMethodItem; |
| import org.jf.baksmali.Adaptors.Format.InstructionMethodItemFactory; |
| import org.jf.baksmali.BaksmaliOptions; |
| import org.jf.dexlib2.AccessFlags; |
| import org.jf.dexlib2.Format; |
| import org.jf.dexlib2.Opcode; |
| import org.jf.dexlib2.ReferenceType; |
| import org.jf.dexlib2.analysis.AnalysisException; |
| import org.jf.dexlib2.analysis.AnalyzedInstruction; |
| import org.jf.dexlib2.analysis.MethodAnalyzer; |
| import org.jf.dexlib2.dexbacked.DexBackedDexFile.InvalidItemIndex; |
| import org.jf.dexlib2.iface.*; |
| import org.jf.dexlib2.iface.debug.DebugItem; |
| import org.jf.dexlib2.iface.instruction.Instruction; |
| import org.jf.dexlib2.iface.instruction.OffsetInstruction; |
| import org.jf.dexlib2.iface.instruction.ReferenceInstruction; |
| import org.jf.dexlib2.iface.instruction.formats.Instruction31t; |
| import org.jf.dexlib2.iface.reference.MethodReference; |
| import org.jf.dexlib2.immutable.instruction.ImmutableInstruction31t; |
| import org.jf.dexlib2.util.InstructionOffsetMap; |
| import org.jf.dexlib2.util.InstructionOffsetMap.InvalidInstructionOffset; |
| import org.jf.dexlib2.util.ReferenceUtil; |
| import org.jf.dexlib2.util.SyntheticAccessorResolver; |
| import org.jf.dexlib2.util.SyntheticAccessorResolver.AccessedMember; |
| import org.jf.dexlib2.util.TypeUtils; |
| import org.jf.util.ExceptionWithContext; |
| import org.jf.util.IndentingWriter; |
| import org.jf.util.SparseIntArray; |
| |
| import javax.annotation.Nonnull; |
| import javax.annotation.Nullable; |
| import java.io.IOException; |
| import java.util.*; |
| |
| public class MethodDefinition { |
| @Nonnull public final ClassDefinition classDef; |
| @Nonnull public final Method method; |
| @Nonnull public final MethodImplementation methodImpl; |
| @Nonnull public final ImmutableList<Instruction> instructions; |
| @Nonnull public final List<Instruction> effectiveInstructions; |
| |
| @Nonnull public final ImmutableList<MethodParameter> methodParameters; |
| public RegisterFormatter registerFormatter; |
| |
| @Nonnull private final LabelCache labelCache = new LabelCache(); |
| |
| @Nonnull private final SparseIntArray packedSwitchMap; |
| @Nonnull private final SparseIntArray sparseSwitchMap; |
| @Nonnull private final InstructionOffsetMap instructionOffsetMap; |
| |
| public MethodDefinition(@Nonnull ClassDefinition classDef, @Nonnull Method method, |
| @Nonnull MethodImplementation methodImpl) { |
| this.classDef = classDef; |
| this.method = method; |
| this.methodImpl = methodImpl; |
| |
| try { |
| //TODO: what about try/catch blocks inside the dead code? those will need to be commented out too. ugh. |
| |
| instructions = ImmutableList.copyOf(methodImpl.getInstructions()); |
| methodParameters = ImmutableList.copyOf(method.getParameters()); |
| |
| effectiveInstructions = Lists.newArrayList(instructions); |
| |
| packedSwitchMap = new SparseIntArray(0); |
| sparseSwitchMap = new SparseIntArray(0); |
| instructionOffsetMap = new InstructionOffsetMap(instructions); |
| |
| int endOffset = instructionOffsetMap.getInstructionCodeOffset(instructions.size()-1) + |
| instructions.get(instructions.size()-1).getCodeUnits(); |
| |
| for (int i=0; i<instructions.size(); i++) { |
| Instruction instruction = instructions.get(i); |
| |
| Opcode opcode = instruction.getOpcode(); |
| if (opcode == Opcode.PACKED_SWITCH) { |
| boolean valid = true; |
| int codeOffset = instructionOffsetMap.getInstructionCodeOffset(i); |
| int targetOffset = codeOffset + ((OffsetInstruction)instruction).getCodeOffset(); |
| try { |
| targetOffset = findPayloadOffset(targetOffset, Opcode.PACKED_SWITCH_PAYLOAD); |
| } catch (InvalidSwitchPayload ex) { |
| valid = false; |
| } |
| if (valid) { |
| if (packedSwitchMap.get(targetOffset, -1) != -1) { |
| Instruction payloadInstruction = |
| findSwitchPayload(targetOffset, Opcode.PACKED_SWITCH_PAYLOAD); |
| targetOffset = endOffset; |
| effectiveInstructions.set(i, new ImmutableInstruction31t(opcode, |
| ((Instruction31t)instruction).getRegisterA(), targetOffset-codeOffset)); |
| effectiveInstructions.add(payloadInstruction); |
| endOffset += payloadInstruction.getCodeUnits(); |
| } |
| packedSwitchMap.append(targetOffset, codeOffset); |
| } |
| } else if (opcode == Opcode.SPARSE_SWITCH) { |
| boolean valid = true; |
| int codeOffset = instructionOffsetMap.getInstructionCodeOffset(i); |
| int targetOffset = codeOffset + ((OffsetInstruction)instruction).getCodeOffset(); |
| try { |
| targetOffset = findPayloadOffset(targetOffset, Opcode.SPARSE_SWITCH_PAYLOAD); |
| } catch (InvalidSwitchPayload ex) { |
| valid = false; |
| // The offset to the payload instruction was invalid. Nothing to do, except that we won't |
| // add this instruction to the map. |
| } |
| if (valid) { |
| if (sparseSwitchMap.get(targetOffset, -1) != -1) { |
| Instruction payloadInstruction = |
| findSwitchPayload(targetOffset, Opcode.SPARSE_SWITCH_PAYLOAD); |
| targetOffset = endOffset; |
| effectiveInstructions.set(i, new ImmutableInstruction31t(opcode, |
| ((Instruction31t)instruction).getRegisterA(), targetOffset-codeOffset)); |
| effectiveInstructions.add(payloadInstruction); |
| endOffset += payloadInstruction.getCodeUnits(); |
| } |
| sparseSwitchMap.append(targetOffset, codeOffset); |
| } |
| } |
| } |
| } catch (Exception ex) { |
| String methodString; |
| try { |
| methodString = ReferenceUtil.getMethodDescriptor(method); |
| } catch (Exception ex2) { |
| throw ExceptionWithContext.withContext(ex, "Error while processing method"); |
| } |
| throw ExceptionWithContext.withContext(ex, "Error while processing method %s", methodString); |
| } |
| } |
| |
| public static void writeEmptyMethodTo(IndentingWriter writer, Method method, |
| BaksmaliOptions options) throws IOException { |
| writer.write(".method "); |
| writeAccessFlags(writer, method.getAccessFlags()); |
| writer.write(method.getName()); |
| writer.write("("); |
| ImmutableList<MethodParameter> methodParameters = ImmutableList.copyOf(method.getParameters()); |
| for (MethodParameter parameter: methodParameters) { |
| writer.write(parameter.getType()); |
| } |
| writer.write(")"); |
| writer.write(method.getReturnType()); |
| writer.write('\n'); |
| |
| writer.indent(4); |
| writeParameters(writer, method, methodParameters, options); |
| |
| String containingClass = null; |
| if (options.implicitReferences) { |
| containingClass = method.getDefiningClass(); |
| } |
| AnnotationFormatter.writeTo(writer, method.getAnnotations(), containingClass); |
| |
| writer.deindent(4); |
| writer.write(".end method\n"); |
| } |
| |
| public void writeTo(IndentingWriter writer) throws IOException { |
| int parameterRegisterCount = 0; |
| if (!AccessFlags.STATIC.isSet(method.getAccessFlags())) { |
| parameterRegisterCount++; |
| } |
| |
| writer.write(".method "); |
| writeAccessFlags(writer, method.getAccessFlags()); |
| writer.write(method.getName()); |
| writer.write("("); |
| for (MethodParameter parameter: methodParameters) { |
| String type = parameter.getType(); |
| writer.write(type); |
| parameterRegisterCount++; |
| if (TypeUtils.isWideType(type)) { |
| parameterRegisterCount++; |
| } |
| } |
| writer.write(")"); |
| writer.write(method.getReturnType()); |
| writer.write('\n'); |
| |
| writer.indent(4); |
| if (classDef.options.localsDirective) { |
| writer.write(".locals "); |
| writer.printSignedIntAsDec(methodImpl.getRegisterCount() - parameterRegisterCount); |
| } else { |
| writer.write(".registers "); |
| writer.printSignedIntAsDec(methodImpl.getRegisterCount()); |
| } |
| writer.write('\n'); |
| writeParameters(writer, method, methodParameters, classDef.options); |
| |
| if (registerFormatter == null) { |
| registerFormatter = new RegisterFormatter(classDef.options, methodImpl.getRegisterCount(), |
| parameterRegisterCount); |
| } |
| |
| String containingClass = null; |
| if (classDef.options.implicitReferences) { |
| containingClass = method.getDefiningClass(); |
| } |
| AnnotationFormatter.writeTo(writer, method.getAnnotations(), containingClass); |
| |
| writer.write('\n'); |
| |
| List<MethodItem> methodItems = getMethodItems(); |
| for (MethodItem methodItem: methodItems) { |
| if (methodItem.writeTo(writer)) { |
| writer.write('\n'); |
| } |
| } |
| writer.deindent(4); |
| writer.write(".end method\n"); |
| } |
| |
| public Instruction findSwitchPayload(int targetOffset, Opcode type) { |
| int targetIndex; |
| try { |
| targetIndex = instructionOffsetMap.getInstructionIndexAtCodeOffset(targetOffset); |
| } catch (InvalidInstructionOffset ex) { |
| throw new InvalidSwitchPayload(targetOffset); |
| } |
| |
| //TODO: does dalvik let you pad with multiple nops? |
| //TODO: does dalvik let a switch instruction point to a non-payload instruction? |
| |
| Instruction instruction = instructions.get(targetIndex); |
| if (instruction.getOpcode() != type) { |
| // maybe it's pointing to a NOP padding instruction. Look at the next instruction |
| if (instruction.getOpcode() == Opcode.NOP) { |
| targetIndex += 1; |
| if (targetIndex < instructions.size()) { |
| instruction = instructions.get(targetIndex); |
| if (instruction.getOpcode() == type) { |
| return instruction; |
| } |
| } |
| } |
| throw new InvalidSwitchPayload(targetOffset); |
| } else { |
| return instruction; |
| } |
| } |
| |
| public int findPayloadOffset(int targetOffset, Opcode type) { |
| int targetIndex; |
| try { |
| targetIndex = instructionOffsetMap.getInstructionIndexAtCodeOffset(targetOffset); |
| } catch (InvalidInstructionOffset ex) { |
| throw new InvalidSwitchPayload(targetOffset); |
| } |
| |
| //TODO: does dalvik let you pad with multiple nops? |
| //TODO: does dalvik let a switch instruction point to a non-payload instruction? |
| |
| Instruction instruction = instructions.get(targetIndex); |
| if (instruction.getOpcode() != type) { |
| // maybe it's pointing to a NOP padding instruction. Look at the next instruction |
| if (instruction.getOpcode() == Opcode.NOP) { |
| targetIndex += 1; |
| if (targetIndex < instructions.size()) { |
| instruction = instructions.get(targetIndex); |
| if (instruction.getOpcode() == type) { |
| return instructionOffsetMap.getInstructionCodeOffset(targetIndex); |
| } |
| } |
| } |
| throw new InvalidSwitchPayload(targetOffset); |
| } else { |
| return targetOffset; |
| } |
| } |
| |
| private static void writeAccessFlags(IndentingWriter writer, int accessFlags) |
| throws IOException { |
| for (AccessFlags accessFlag: AccessFlags.getAccessFlagsForMethod(accessFlags)) { |
| writer.write(accessFlag.toString()); |
| writer.write(' '); |
| } |
| } |
| |
| private static void writeParameters(IndentingWriter writer, Method method, |
| List<? extends MethodParameter> parameters, |
| BaksmaliOptions options) throws IOException { |
| boolean isStatic = AccessFlags.STATIC.isSet(method.getAccessFlags()); |
| int registerNumber = isStatic?0:1; |
| for (MethodParameter parameter: parameters) { |
| String parameterType = parameter.getType(); |
| String parameterName = parameter.getName(); |
| Collection<? extends Annotation> annotations = parameter.getAnnotations(); |
| if ((options.debugInfo && parameterName != null) || annotations.size() != 0) { |
| writer.write(".param p"); |
| writer.printSignedIntAsDec(registerNumber); |
| |
| if (parameterName != null && options.debugInfo) { |
| writer.write(", "); |
| ReferenceFormatter.writeStringReference(writer, parameterName); |
| } |
| writer.write(" # "); |
| writer.write(parameterType); |
| writer.write("\n"); |
| if (annotations.size() > 0) { |
| writer.indent(4); |
| |
| String containingClass = null; |
| if (options.implicitReferences) { |
| containingClass = method.getDefiningClass(); |
| } |
| AnnotationFormatter.writeTo(writer, annotations, containingClass); |
| writer.deindent(4); |
| writer.write(".end param\n"); |
| } |
| } |
| |
| registerNumber++; |
| if (TypeUtils.isWideType(parameterType)) { |
| registerNumber++; |
| } |
| } |
| } |
| |
| @Nonnull public LabelCache getLabelCache() { |
| return labelCache; |
| } |
| |
| public int getPackedSwitchBaseAddress(int packedSwitchPayloadCodeOffset) { |
| return packedSwitchMap.get(packedSwitchPayloadCodeOffset, -1); |
| } |
| |
| public int getSparseSwitchBaseAddress(int sparseSwitchPayloadCodeOffset) { |
| return sparseSwitchMap.get(sparseSwitchPayloadCodeOffset, -1); |
| } |
| |
| private List<MethodItem> getMethodItems() { |
| ArrayList<MethodItem> methodItems = new ArrayList<MethodItem>(); |
| |
| if ((classDef.options.registerInfo != 0) || (classDef.options.normalizeVirtualMethods) || |
| (classDef.options.deodex && needsAnalyzed())) { |
| addAnalyzedInstructionMethodItems(methodItems); |
| } else { |
| addInstructionMethodItems(methodItems); |
| } |
| |
| addTries(methodItems); |
| if (classDef.options.debugInfo) { |
| addDebugInfo(methodItems); |
| } |
| |
| if (classDef.options.sequentialLabels) { |
| setLabelSequentialNumbers(); |
| } |
| |
| for (LabelMethodItem labelMethodItem: labelCache.getLabels()) { |
| methodItems.add(labelMethodItem); |
| } |
| |
| Collections.sort(methodItems); |
| |
| return methodItems; |
| } |
| |
| private boolean needsAnalyzed() { |
| for (Instruction instruction: methodImpl.getInstructions()) { |
| if (instruction.getOpcode().odexOnly()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private void addInstructionMethodItems(List<MethodItem> methodItems) { |
| int currentCodeAddress = 0; |
| |
| for (int i=0; i<effectiveInstructions.size(); i++) { |
| Instruction instruction = effectiveInstructions.get(i); |
| |
| MethodItem methodItem = InstructionMethodItemFactory.makeInstructionFormatMethodItem(this, |
| currentCodeAddress, instruction); |
| |
| methodItems.add(methodItem); |
| |
| if (i != effectiveInstructions.size() - 1) { |
| methodItems.add(new BlankMethodItem(currentCodeAddress)); |
| } |
| |
| if (classDef.options.codeOffsets) { |
| methodItems.add(new MethodItem(currentCodeAddress) { |
| |
| @Override |
| public double getSortOrder() { |
| return -1000; |
| } |
| |
| @Override |
| public boolean writeTo(IndentingWriter writer) throws IOException { |
| writer.write("#@"); |
| writer.printUnsignedLongAsHex(codeAddress & 0xFFFFFFFFL); |
| return true; |
| } |
| }); |
| } |
| |
| if (classDef.options.accessorComments && classDef.options.syntheticAccessorResolver != null && |
| (instruction instanceof ReferenceInstruction)) { |
| Opcode opcode = instruction.getOpcode(); |
| |
| if (opcode.referenceType == ReferenceType.METHOD) { |
| MethodReference methodReference = null; |
| try { |
| methodReference = (MethodReference)((ReferenceInstruction)instruction).getReference(); |
| } catch (InvalidItemIndex ex) { |
| // just ignore it for now. We'll deal with it later, when processing the instructions |
| // themselves |
| } |
| |
| if (methodReference != null && |
| SyntheticAccessorResolver.looksLikeSyntheticAccessor(methodReference.getName())) { |
| AccessedMember accessedMember = |
| classDef.options.syntheticAccessorResolver.getAccessedMember(methodReference); |
| if (accessedMember != null) { |
| methodItems.add(new SyntheticAccessCommentMethodItem(accessedMember, currentCodeAddress)); |
| } |
| } |
| } |
| } |
| |
| currentCodeAddress += instruction.getCodeUnits(); |
| } |
| } |
| |
| private void addAnalyzedInstructionMethodItems(List<MethodItem> methodItems) { |
| MethodAnalyzer methodAnalyzer = new MethodAnalyzer(classDef.options.classPath, method, |
| classDef.options.inlineResolver, classDef.options.normalizeVirtualMethods); |
| |
| AnalysisException analysisException = methodAnalyzer.getAnalysisException(); |
| if (analysisException != null) { |
| // TODO: need to keep track of whether any errors occurred, so we can exit with a non-zero result |
| methodItems.add(new CommentMethodItem( |
| String.format("AnalysisException: %s", analysisException.getMessage()), |
| analysisException.codeAddress, Integer.MIN_VALUE)); |
| analysisException.printStackTrace(System.err); |
| } |
| |
| List<AnalyzedInstruction> instructions = methodAnalyzer.getAnalyzedInstructions(); |
| |
| int currentCodeAddress = 0; |
| for (int i=0; i<instructions.size(); i++) { |
| AnalyzedInstruction instruction = instructions.get(i); |
| |
| MethodItem methodItem = InstructionMethodItemFactory.makeInstructionFormatMethodItem( |
| this, currentCodeAddress, instruction.getInstruction()); |
| |
| methodItems.add(methodItem); |
| |
| if (instruction.getInstruction().getOpcode().format == Format.UnresolvedOdexInstruction) { |
| methodItems.add(new CommentedOutMethodItem( |
| InstructionMethodItemFactory.makeInstructionFormatMethodItem( |
| this, currentCodeAddress, instruction.getOriginalInstruction()))); |
| } |
| |
| if (i != instructions.size() - 1) { |
| methodItems.add(new BlankMethodItem(currentCodeAddress)); |
| } |
| |
| if (classDef.options.codeOffsets) { |
| methodItems.add(new MethodItem(currentCodeAddress) { |
| |
| @Override |
| public double getSortOrder() { |
| return -1000; |
| } |
| |
| @Override |
| public boolean writeTo(IndentingWriter writer) throws IOException { |
| writer.write("#@"); |
| writer.printUnsignedLongAsHex(codeAddress & 0xFFFFFFFFL); |
| return true; |
| } |
| }); |
| } |
| |
| if (classDef.options.registerInfo != 0 && |
| !instruction.getInstruction().getOpcode().format.isPayloadFormat) { |
| methodItems.add( |
| new PreInstructionRegisterInfoMethodItem(classDef.options.registerInfo, |
| methodAnalyzer, registerFormatter, instruction, currentCodeAddress)); |
| |
| methodItems.add( |
| new PostInstructionRegisterInfoMethodItem(registerFormatter, instruction, currentCodeAddress)); |
| } |
| |
| currentCodeAddress += instruction.getInstruction().getCodeUnits(); |
| } |
| } |
| |
| private void addTries(List<MethodItem> methodItems) { |
| List<? extends TryBlock<? extends ExceptionHandler>> tryBlocks = methodImpl.getTryBlocks(); |
| if (tryBlocks.size() == 0) { |
| return; |
| } |
| |
| int lastInstructionAddress = instructionOffsetMap.getInstructionCodeOffset(instructions.size() - 1); |
| int codeSize = lastInstructionAddress + instructions.get(instructions.size() - 1).getCodeUnits(); |
| |
| for (TryBlock<? extends ExceptionHandler> tryBlock: tryBlocks) { |
| int startAddress = tryBlock.getStartCodeAddress(); |
| int endAddress = startAddress + tryBlock.getCodeUnitCount(); |
| |
| if (startAddress >= codeSize) { |
| throw new RuntimeException(String.format("Try start offset %d is past the end of the code block.", |
| startAddress)); |
| } |
| // Note: not >=. endAddress == codeSize is valid, when the try covers the last instruction |
| if (endAddress > codeSize) { |
| throw new RuntimeException(String.format("Try end offset %d is past the end of the code block.", |
| endAddress)); |
| } |
| |
| /** |
| * The end address points to the address immediately after the end of the last |
| * instruction that the try block covers. We want the .catch directive and end_try |
| * label to be associated with the last covered instruction, so we need to get |
| * the address for that instruction |
| */ |
| |
| int lastCoveredIndex = instructionOffsetMap.getInstructionIndexAtCodeOffset(endAddress - 1, false); |
| int lastCoveredAddress = instructionOffsetMap.getInstructionCodeOffset(lastCoveredIndex); |
| |
| for (ExceptionHandler handler: tryBlock.getExceptionHandlers()) { |
| int handlerAddress = handler.getHandlerCodeAddress(); |
| if (handlerAddress >= codeSize) { |
| throw new ExceptionWithContext( |
| "Exception handler offset %d is past the end of the code block.", handlerAddress); |
| } |
| |
| //use the address from the last covered instruction |
| CatchMethodItem catchMethodItem = new CatchMethodItem(classDef.options, labelCache, lastCoveredAddress, |
| handler.getExceptionType(), startAddress, endAddress, handlerAddress); |
| methodItems.add(catchMethodItem); |
| } |
| } |
| } |
| |
| private void addDebugInfo(final List<MethodItem> methodItems) { |
| for (DebugItem debugItem: methodImpl.getDebugItems()) { |
| methodItems.add(DebugMethodItem.build(registerFormatter, debugItem)); |
| } |
| } |
| |
| private void setLabelSequentialNumbers() { |
| HashMap<String, Integer> nextLabelSequenceByType = new HashMap<String, Integer>(); |
| ArrayList<LabelMethodItem> sortedLabels = new ArrayList<LabelMethodItem>(labelCache.getLabels()); |
| |
| //sort the labels by their location in the method |
| Collections.sort(sortedLabels); |
| |
| for (LabelMethodItem labelMethodItem: sortedLabels) { |
| Integer labelSequence = nextLabelSequenceByType.get(labelMethodItem.getLabelPrefix()); |
| if (labelSequence == null) { |
| labelSequence = 0; |
| } |
| labelMethodItem.setLabelSequence(labelSequence); |
| nextLabelSequenceByType.put(labelMethodItem.getLabelPrefix(), labelSequence + 1); |
| } |
| } |
| |
| @Nullable |
| private String getContainingClassForImplicitReference() { |
| if (classDef.options.implicitReferences) { |
| return classDef.classDef.getType(); |
| } |
| return null; |
| } |
| |
| public static class LabelCache { |
| protected HashMap<LabelMethodItem, LabelMethodItem> labels = new HashMap<LabelMethodItem, LabelMethodItem>(); |
| |
| public LabelCache() { |
| } |
| |
| public LabelMethodItem internLabel(LabelMethodItem labelMethodItem) { |
| LabelMethodItem internedLabelMethodItem = labels.get(labelMethodItem); |
| if (internedLabelMethodItem != null) { |
| return internedLabelMethodItem; |
| } |
| labels.put(labelMethodItem, labelMethodItem); |
| return labelMethodItem; |
| } |
| |
| |
| public Collection<LabelMethodItem> getLabels() { |
| return labels.values(); |
| } |
| } |
| |
| public static class InvalidSwitchPayload extends ExceptionWithContext { |
| private final int payloadOffset; |
| |
| public InvalidSwitchPayload(int payloadOffset) { |
| super("No switch payload at offset: %d", payloadOffset); |
| this.payloadOffset = payloadOffset; |
| } |
| |
| public int getPayloadOffset() { |
| return payloadOffset; |
| } |
| } |
| } |
