add BRIDGE flag to bridge methods

3 files changed, 93 insertions, 0 deletions

diff --git a/src/cuchaz/enigma/TranslatingTypeLoader.java b/src/cuchaz/enigma/TranslatingTypeLoader.java
index 8bec17fb..19e3d2ad 100644
--- a/src/cuchaz/enigma/TranslatingTypeLoader.java
+++ b/src/cuchaz/enigma/TranslatingTypeLoader.java
@@ -29,6 +29,7 @@ import com.strobel.assembler.metadata.Buffer;
 import com.strobel.assembler.metadata.ClasspathTypeLoader;
 import com.strobel.assembler.metadata.ITypeLoader;
 
+import cuchaz.enigma.analysis.BridgeMarker;
 import cuchaz.enigma.analysis.JarIndex;
 import cuchaz.enigma.bytecode.ClassRenamer;
 import cuchaz.enigma.bytecode.ClassTranslator;
@@ -198,6 +199,7 @@ public class TranslatingTypeLoader implements ITypeLoader {
                 assertClassName(c, obfClassEntry);
                 
                 // do all kinds of deobfuscating transformations on the class
+                new BridgeMarker(m_jarIndex.getBridgedMethods()).markBridges(c);
                 new MethodParameterWriter(m_deobfuscatingTranslator).writeMethodArguments(c);
                 new ClassTranslator(m_deobfuscatingTranslator).translate(c);
                 
diff --git a/src/cuchaz/enigma/analysis/BridgeMarker.java b/src/cuchaz/enigma/analysis/BridgeMarker.java
new file mode 100644
index 00000000..e80f87dc
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/BridgeMarker.java
@@ -0,0 +1,36 @@
+package cuchaz.enigma.analysis;
+
+import javassist.CtClass;
+import javassist.CtMethod;
+import javassist.bytecode.AccessFlag;
+
+import com.google.common.collect.BiMap;
+
+import cuchaz.enigma.mapping.EntryFactory;
+import cuchaz.enigma.mapping.MethodEntry;
+
+public class BridgeMarker {
+        
+        private BiMap<MethodEntry,MethodEntry> m_bridgedMethods;
+        
+        public BridgeMarker(BiMap<MethodEntry,MethodEntry> bridgedMethods) {
+                m_bridgedMethods = bridgedMethods;
+        }
+        
+        public void markBridges(CtClass c) {
+                
+                for (CtMethod method : c.getDeclaredMethods()) {
+                        MethodEntry methodEntry = EntryFactory.getMethodEntry(method);
+                        
+                        // is this a bridge method?
+                        MethodEntry bridgedMethodEntry = m_bridgedMethods.get(methodEntry);
+                        if (bridgedMethodEntry != null) {
+                                
+                                // it's a bridge method! add the bridge flag
+                                int flags = method.getMethodInfo().getAccessFlags();
+                                flags |= AccessFlag.BRIDGE;
+                                method.getMethodInfo().setAccessFlags(flags);
+                        }
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/JarIndex.java b/src/cuchaz/enigma/analysis/JarIndex.java
index 24d110ee..797deb82 100644
--- a/src/cuchaz/enigma/analysis/JarIndex.java
+++ b/src/cuchaz/enigma/analysis/JarIndex.java
@@ -23,6 +23,8 @@ import javassist.CtBehavior;
 import javassist.CtClass;
 import javassist.CtConstructor;
 import javassist.CtField;
+import javassist.CtMethod;
+import javassist.NotFoundException;
 import javassist.bytecode.AccessFlag;
 import javassist.bytecode.Descriptor;
 import javassist.bytecode.FieldInfo;
@@ -32,6 +34,8 @@ import javassist.expr.FieldAccess;
 import javassist.expr.MethodCall;
 import javassist.expr.NewExpr;
 
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
@@ -62,6 +66,7 @@ public class JarIndex {
         private Multimap<String,String> m_innerClasses;
         private Map<String,String> m_outerClasses;
         private Map<String,BehaviorEntry> m_anonymousClasses;
+        private BiMap<MethodEntry,MethodEntry> m_bridgedMethods;
         
         public JarIndex() {
                 m_obfClassEntries = Sets.newHashSet();
@@ -74,6 +79,7 @@ public class JarIndex {
                 m_innerClasses = HashMultimap.create();
                 m_outerClasses = Maps.newHashMap();
                 m_anonymousClasses = Maps.newHashMap();
+                m_bridgedMethods = HashBiMap.create();
         }
         
         public void indexJar(JarFile jar, boolean buildInnerClasses) {
@@ -171,6 +177,12 @@ public class JarIndex {
                         
                         // index implementation
                         m_methodImplementations.put(behaviorEntry.getClassName(), methodEntry);
+                        
+                        // look for bridge and bridged methods
+                        CtMethod bridgedMethod = getBridgedMethod((CtMethod)behavior);
+                        if (bridgedMethod != null) {
+                                m_bridgedMethods.put(methodEntry, EntryFactory.getMethodEntry(bridgedMethod));
+                        }
                 }
                 // looks like we don't care about constructors here
         }
@@ -241,6 +253,45 @@ public class JarIndex {
                 }
         }
         
+        private CtMethod getBridgedMethod(CtMethod method) {
+                
+                // bridge methods just call another method, cast it to the return type, and return the result
+                // let's see if we can detect this scenario
+                
+                // skip non-synthetic methods
+                if ((method.getModifiers() & AccessFlag.SYNTHETIC) == 0) {
+                        return null;
+                }
+                
+                // get all the called methods
+                final List<MethodCall> methodCalls = Lists.newArrayList();
+                try {
+                        method.instrument(new ExprEditor() {
+                                @Override
+                                public void edit(MethodCall call) {
+                                        methodCalls.add(call);
+                                }
+                        });
+                } catch (CannotCompileException ex) {
+                        // this is stupid... we're not even compiling anything
+                        throw new Error(ex);
+                }
+                
+                // is there just one?
+                if (methodCalls.size() != 1) {
+                        return null;
+                }
+                MethodCall call = methodCalls.get(0);
+                
+                try {
+                        // we have a bridge method!
+                        return call.getMethod();
+                } catch (NotFoundException ex) {
+                        // can't find the type? not a bridge method
+                        return null;
+                }
+        }
+        
         private String findOuterClass(CtClass c) {
                 
                 // inner classes:
@@ -706,4 +757,8 @@ public class JarIndex {
                         throw new Error("Entry type not supported: " + obfEntry.getClass().getName());
                 }
         }
+        
+        public BiMap<MethodEntry,MethodEntry> getBridgedMethods() {
+                return m_bridgedMethods;
+        }
 }