🐞 Update version of third_party/ijar

third_party/ijar/classfile.cc

-// Copyright 2001,2007 Alan Donovan. All rights reserved.
+// Copyright 2015 The Bazel Authors. All rights reserved.
 //
-// Author: Alan Donovan <adonovan@google.com>
-//
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //    http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
@@ skipping 12 matching lines @@
 // http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4
 
 #define __STDC_FORMAT_MACROS 1
 #define __STDC_LIMIT_MACROS 1
 #include <inttypes.h> // for PRIx32
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include <set>
+#include <sstream>
 #include <string>
 #include <vector>
 
 #include "third_party/ijar/common.h"
 
+namespace {
+// Converts a value to string.
+// Workaround for mingw where std::to_string is not implemented.
+// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52015.
+template <typename T>
+std::string ToString(const T& value) {
+  std::ostringstream oss;
+  oss << value;
+  return oss.str();
+}
+}  // namespace
+
 namespace devtools_ijar {
 
 // See Table 4.3 in JVM Spec.
 enum CONSTANT {
   CONSTANT_Class              = 7,
   CONSTANT_FieldRef           = 9,
   CONSTANT_Methodref          = 10,
   CONSTANT_Interfacemethodref = 11,
   CONSTANT_String             = 8,
   CONSTANT_Integer            = 3,
   CONSTANT_Float              = 4,
   CONSTANT_Long               = 5,
   CONSTANT_Double             = 6,
   CONSTANT_NameAndType        = 12,
   CONSTANT_Utf8               = 1,
   CONSTANT_MethodHandle       = 15,
   CONSTANT_MethodType         = 16,
   CONSTANT_InvokeDynamic      = 18
 };
 
 // See Tables 4.1, 4.4, 4.5 in JVM Spec.
-enum ACCESS  {
-  ACC_PUBLIC          = 0x0001,
-  ACC_PRIVATE         = 0x0002,
-  ACC_PROTECTED       = 0x0004,
-  ACC_STATIC          = 0x0008,
-  ACC_FINAL           = 0x0010,
-  ACC_SYNCHRONIZED    = 0x0020,
-  ACC_VOLATILE        = 0x0040,
-  ACC_TRANSIENT       = 0x0080,
-  ACC_INTERFACE       = 0x0200,
-  ACC_ABSTRACT        = 0x0400
+enum ACCESS {
+  ACC_PUBLIC = 0x0001,
+  ACC_PRIVATE = 0x0002,
+  ACC_PROTECTED = 0x0004,
+  ACC_STATIC = 0x0008,
+  ACC_FINAL = 0x0010,
+  ACC_SYNCHRONIZED = 0x0020,
+  ACC_BRIDGE = 0x0040,
+  ACC_VOLATILE = 0x0040,
+  ACC_TRANSIENT = 0x0080,
+  ACC_INTERFACE = 0x0200,
+  ACC_ABSTRACT = 0x0400,
+  ACC_SYNTHETIC = 0x1000
 };
 
 // See Table 4.7.20-A in Java 8 JVM Spec.
 enum TARGET_TYPE {
   // Targets for type parameter declarations (ElementType.TYPE_PARAMETER):
   CLASS_TYPE_PARAMETER        = 0x00,
   METHOD_TYPE_PARAMETER       = 0x01,
 
   // Targets for type uses that may be externally visible in classes and members
   // (ElementType.TYPE_USE):
   CLASS_EXTENDS               = 0x10,
   CLASS_TYPE_PARAMETER_BOUND  = 0x11,
   METHOD_TYPE_PARAMETER_BOUND = 0x12,
   FIELD                       = 0x13,
   METHOD_RETURN               = 0x14,
   METHOD_RECEIVER             = 0x15,
   METHOD_FORMAL_PARAMETER     = 0x16,
   THROWS                      = 0x17,
 
   // TARGET_TYPE >= 0x40 is reserved for type uses that occur only within code
   // blocks. Ijar doesn't need to know about these.
 };
 
 struct Constant;
 
 // TODO(adonovan) these globals are unfortunate
 static std::vector<Constant*>        const_pool_in; // input constant pool
 static std::vector<Constant*>        const_pool_out; // output constant_pool
+static std::set<std::string>         used_class_names;
+static Constant *                    class_name;
 
 // Returns the Constant object, given an index into the input constant pool.
 // Note: constant(0) == NULL; this invariant is exploited by the
 // InnerClassesAttribute, inter alia.
 inline Constant *constant(int idx) {
   if (idx < 0 || (unsigned)idx >= const_pool_in.size()) {
     fprintf(stderr, "Illegal constant pool index: %d\n", idx);
     abort();
   }
   return const_pool_in[idx];
@@ skipping 19 matching lines @@
   virtual std::string Display() = 0;
 
   virtual void Write(u1 *&p) = 0;
 
   // Called by slot() when a constant has been identified as required
   // in the output classfile's constant pool.  This is a hook allowing
   // constants to register their dependency on other constants, by
   // calling slot() on them in turn.
   virtual void Keep() {}
 
+  bool Kept() {
+    return slot_ != 0;
+  }
+
   // Returns the index of this constant in the output class's constant
   // pool, assigning a slot if not already done.
   u2 slot() {
     if (slot_ == 0) {
       Keep();
       slot_ = const_pool_out.size(); // BugBot's "narrowing" warning
                                      // is bogus.  The number of
                                      // output constants can't exceed
                                      // the number of input constants.
       if (slot_ == 0) {
         fprintf(stderr, "Constant::slot() called before output phase.\n");
         abort();
       }
       const_pool_out.push_back(this);
       if (tag_ == CONSTANT_Long || tag_ == CONSTANT_Double) {
         const_pool_out.push_back(NULL);
       }
     }
     return slot_;
   }
 
   u2 slot_; // zero => "this constant is unreachable garbage"
   u1 tag_;
 };
 
+// Extracts class names from a signature and puts them into the global
+// variable used_class_names.
+//
+// desc: the descriptor class names should be extracted from.
+// p: the position where the extraction should tart.
+void ExtractClassNames(const std::string& desc, size_t* p);
+
 // See sec.4.4.1 of JVM spec.
 struct Constant_Class : Constant
 {
   Constant_Class(u2 name_index) :
       Constant(CONSTANT_Class),
       name_index_(name_index) {}
 
   void Write(u1 *&p) {
     put_u1(p, tag_);
     put_u2be(p, constant(name_index_)->slot());
@@ skipping 152 matching lines @@
       reference_kind_(reference_kind),
       reference_index_(reference_index) {}
 
   void Write(u1 *&p) {
     put_u1(p, tag_);
     put_u1(p, reference_kind_);
     put_u2be(p, reference_index_);
   }
 
   std::string Display() {
-    return "Constant_MethodHandle::" + std::to_string(reference_kind_) + "::"
+    return "Constant_MethodHandle::" + ToString(reference_kind_) + "::"
         + constant(reference_index_)->Display();
   }
 
   u1 reference_kind_;
   u2 reference_index_;
 };
 
 // See sec.4.4.9 of JVM spec.
 struct Constant_MethodType : Constant
 {
@@ skipping 22 matching lines @@
       name_and_type_index_(name_and_type_index) {}
 
   void Write(u1 *&p) {
     put_u1(p, tag_);
     put_u2be(p, bootstrap_method_attr_index_);
     put_u2be(p, name_and_type_index_);
   }
 
   std::string Display() {
     return  "Constant_InvokeDynamic::"
-        + std::to_string(bootstrap_method_attr_index_) + "::"
+        + ToString(bootstrap_method_attr_index_) + "::"
         + constant(name_and_type_index_)->Display();
   }
 
   u2 bootstrap_method_attr_index_;
   u2 name_and_type_index_;
 };
 
 /**********************************************************************
  *                                                                    *
  *                             Attributes                             *
  *                                                                    *
  **********************************************************************/
 
 // See sec.4.7 of JVM spec.
 struct Attribute {
 
   virtual ~Attribute() {}
   virtual void Write(u1 *&p) = 0;
+  virtual void ExtractClassNames() {}
 
   void WriteProlog(u1 *&p, u2 length) {
     put_u2be(p, attribute_name_->slot());
     put_u4be(p, length);
   }
 
   Constant *attribute_name_;
 };
 
 // See sec.4.7.5 of JVM spec.
@@ skipping 47 matching lines @@
       entry->outer_class_info = constant(get_u2be(p));
       entry->inner_name = constant(get_u2be(p));
       entry->inner_class_access_flags = get_u2be(p);
 
       attr->entries_.push_back(entry);
     }
     return attr;
   }
 
   void Write(u1 *&p) {
-    WriteProlog(p, 2 + entries_.size() * 8);
-    put_u2be(p, entries_.size());
-    for (size_t ii = 0; ii < entries_.size(); ++ii) {
-      Entry *entry = entries_[ii];
+    std::set<int> kept_entries;
+    // We keep an entry if the constant referring to the inner class is already
+    // kept. Then we mark its outer class and its class name as kept, too, then
+    // iterate until a fixed point is reached.
+    int entry_count;
+    int iteration = 0;
+
+    do {
+      entry_count = kept_entries.size();
+      for (int i_entry = 0; i_entry < static_cast<int>(entries_.size());
+           ++i_entry) {
+        Entry* entry = entries_[i_entry];
+        if (entry->inner_class_info->Kept() ||
+            used_class_names.find(entry->inner_class_info->Display()) !=
+                used_class_names.end() ||
+            entry->outer_class_info == class_name) {
+          if (entry->inner_name == NULL) {
+            // JVMS 4.7.6: inner_name_index is zero iff the class is anonymous
+            continue;
+          }
+
+          kept_entries.insert(i_entry);
+
+          // JVMS 4.7.6: outer_class_info_index is zero for top-level classes
+          if (entry->outer_class_info != NULL) {
+            entry->outer_class_info->slot();
+          }
+
+          entry->inner_name->slot();
+        }
+      }
+      iteration += 1;
+    } while (entry_count != static_cast<int>(kept_entries.size()));
+
+    if (kept_entries.size() == 0) {
+      return;
+    }
+
+    WriteProlog(p, 2 + kept_entries.size() * 8);
+    put_u2be(p, kept_entries.size());
+
+    for (std::set<int>::iterator it = kept_entries.begin();
+         it != kept_entries.end();
+         ++it) {
+      Entry *entry = entries_[*it];
       put_u2be(p, entry->inner_class_info == NULL
                ? 0
                : entry->inner_class_info->slot());
       put_u2be(p, entry->outer_class_info == NULL
                ? 0
                : entry->outer_class_info->slot());
       put_u2be(p, entry->inner_name == NULL
                ? 0
                : entry->inner_name->slot());
       put_u2be(p, entry->inner_class_access_flags);
@@ skipping 28 matching lines @@
 
   Constant *class_;
   Constant *method_;
 };
 
 // See sec.4.7.16.1 of JVM spec.
 // Used by AnnotationDefault and other attributes.
 struct ElementValue {
   virtual ~ElementValue() {}
   virtual void Write(u1 *&p) = 0;
+  virtual void ExtractClassNames() {}
   static ElementValue* Read(const u1 *&p);
   u1 tag_;
   u4 length_;
 };
 
 struct BaseTypeElementValue : ElementValue {
   void Write(u1 *&p) {
     put_u1(p, tag_);
     put_u2be(p, const_value_->slot());
   }
@@ skipping 19 matching lines @@
   }
   Constant *type_name_;
   Constant *const_name_;
 };
 
 struct ClassTypeElementValue : ElementValue {
   void Write(u1 *&p) {
     put_u1(p, tag_);
     put_u2be(p, class_info_->slot());
   }
+
+  virtual void ExtractClassNames() {
+    size_t idx = 0;
+    devtools_ijar::ExtractClassNames(class_info_->Display(), &idx);
+  }
+
   static ClassTypeElementValue *Read(const u1 *&p) {
     ClassTypeElementValue *value = new ClassTypeElementValue;
     value->class_info_ = constant(get_u2be(p));
     return value;
   }
   Constant *class_info_;
 };
 
 struct ArrayTypeElementValue : ElementValue {
   virtual ~ArrayTypeElementValue() {
-    for (size_t i = 0; i < values_.size(); i++) {
-      delete values_[i];
+    for (const auto *value : values_) {
+      delete value;
+    }
+  }
+
+  virtual void ExtractClassNames() {
+    for (auto *value : values_) {
+      value->ExtractClassNames();
     }
   }
 
   void Write(u1 *&p) {
     put_u1(p, tag_);
     put_u2be(p, values_.size());
-    for (size_t ii = 0; ii < values_.size(); ++ii) {
-      values_[ii]->Write(p);
+    for (auto *value : values_) {
+      value->Write(p);
     }
   }
   static ArrayTypeElementValue *Read(const u1 *&p) {
     ArrayTypeElementValue *value = new ArrayTypeElementValue;
     u2 num_values = get_u2be(p);
     for (int ii = 0; ii < num_values; ++ii) {
       value->values_.push_back(ElementValue::Read(p));
     }
     return value;
   }
   std::vector<ElementValue*> values_;
 };
 
 // See sec.4.7.16 of JVM spec.
 struct Annotation {
   virtual ~Annotation() {
     for (size_t i = 0; i < element_value_pairs_.size(); i++) {
       delete element_value_pairs_[i]->element_value_;
       delete element_value_pairs_[i];
     }
   }
 
+  void ExtractClassNames() {
+    for (size_t i = 0; i < element_value_pairs_.size(); i++) {
+      element_value_pairs_[i]->element_value_->ExtractClassNames();
+    }
+  }
+
   void Write(u1 *&p) {
     put_u2be(p, type_->slot());
     put_u2be(p, element_value_pairs_.size());
     for (size_t ii = 0; ii < element_value_pairs_.size(); ++ii) {
       put_u2be(p, element_value_pairs_[ii]->element_name_->slot());
       element_value_pairs_[ii]->element_value_->Write(p);
     }
   }
   static Annotation *Read(const u1 *&p) {
     Annotation *value = new Annotation;
@@ skipping 45 matching lines @@
 //   element_value_pairs[num_element_value_pairs];
 // }
 //
 struct TypeAnnotation {
   virtual ~TypeAnnotation() {
     delete target_info_;
     delete type_path_;
     delete annotation_;
   }
 
+  void ExtractClassNames() {
+    annotation_->ExtractClassNames();
+  }
+
   void Write(u1 *&p) {
     put_u1(p, target_type_);
     target_info_->Write(p);
     type_path_->Write(p);
     annotation_->Write(p);
   }
 
   static TypeAnnotation *Read(const u1 *&p) {
     TypeAnnotation *value = new TypeAnnotation;
     value->target_type_ = get_u1(p);
@@ skipping 191 matching lines @@
     attr->attribute_name_ = attribute_name;
     attr->default_value_ = ElementValue::Read(p);
     return attr;
   }
 
   void Write(u1 *&p) {
     WriteProlog(p, default_value_->length_);
     default_value_->Write(p);
   }
 
+  virtual void ExtractClassNames() {
+    default_value_->ExtractClassNames();
+  }
+
   ElementValue *default_value_;
 };
 
 // See sec.4.7.2 of JVM spec.
 // We preserve ConstantValue attributes because they are required for
 // compile-time constant propagation.
 struct ConstantValueAttribute : Attribute {
 
   static ConstantValueAttribute* Read(const u1 *&p, Constant *attribute_name) {
     ConstantValueAttribute *attr = new ConstantValueAttribute;
@@ skipping 20 matching lines @@
     attr->attribute_name_ = attribute_name;
     attr->signature_  = constant(get_u2be(p));
     return attr;
   }
 
   void Write(u1 *&p) {
     WriteProlog(p, 2);
     put_u2be(p, signature_->slot());
   }
 
+  virtual void ExtractClassNames() {
+    size_t signature_idx = 0;
+    devtools_ijar::ExtractClassNames(signature_->Display(), &signature_idx);
+  }
+
   Constant *signature_;
 };
 
 // See sec.4.7.15 of JVM spec.
 // We preserve Deprecated attributes because they are required by the
 // compiler to generate warning messages.
 struct DeprecatedAttribute : Attribute {
 
   static DeprecatedAttribute* Read(const u1 *&p, Constant *attribute_name) {
     DeprecatedAttribute *attr = new DeprecatedAttribute;
@@ skipping 21 matching lines @@
     AnnotationsAttribute *attr = new AnnotationsAttribute;
     attr->attribute_name_ = attribute_name;
     u2 num_annotations = get_u2be(p);
     for (int ii = 0; ii < num_annotations; ++ii) {
       Annotation *annotation = Annotation::Read(p);
       attr->annotations_.push_back(annotation);
     }
     return attr;
   }
 
+  virtual void ExtractClassNames() {
+    for (auto *annotation : annotations_) {
+      annotation->ExtractClassNames();
+    }
+  }
+
   void Write(u1 *&p) {
     WriteProlog(p, -1);
     u1 *payload_start = p - 4;
     put_u2be(p, annotations_.size());
-    for (size_t ii = 0; ii < annotations_.size(); ++ii) {
-      annotations_[ii]->Write(p);
+    for (auto *annotation : annotations_) {
+      annotation->Write(p);
     }
     put_u4be(payload_start, p - 4 - payload_start);  // backpatch length
   }
 
   std::vector<Annotation*> annotations_;
 };
 
 // See sec.4.7.18-19 of JVM spec.  Includes RuntimeVisible and
 // RuntimeInvisible.
 //
@@ skipping 10 matching lines @@
       u2 num_annotations = get_u2be(p);
       for (int ii = 0; ii < num_annotations; ++ii) {
         Annotation *annotation = Annotation::Read(p);
         annotations.push_back(annotation);
       }
       attr->parameter_annotations_.push_back(annotations);
     }
     return attr;
   }
 
+  virtual void ExtractClassNames() {
+    for (size_t i = 0; i < parameter_annotations_.size(); i++) {
+      const std::vector<Annotation*>& annotations = parameter_annotations_[i];
+      for (size_t j = 0; j < annotations.size(); j++) {
+        annotations[j]->ExtractClassNames();
+      }
+    }
+  }
+
   void Write(u1 *&p) {
     WriteProlog(p, -1);
     u1 *payload_start = p - 4;
     put_u1(p, parameter_annotations_.size());
     for (size_t ii = 0; ii < parameter_annotations_.size(); ++ii) {
       std::vector<Annotation *> &annotations = parameter_annotations_[ii];
       put_u2be(p, annotations.size());
       for (size_t jj = 0; jj < annotations.size(); ++jj) {
         annotations[jj]->Write(p);
       }
@@ skipping 12 matching lines @@
     auto attr = new TypeAnnotationsAttribute;
     attr->attribute_name_ = attribute_name;
     u2 num_annotations = get_u2be(p);
     for (int ii = 0; ii < num_annotations; ++ii) {
       TypeAnnotation *annotation = TypeAnnotation::Read(p);
       attr->type_annotations_.push_back(annotation);
     }
     return attr;
   }
 
+  virtual void ExtractClassNames() {
+    for (auto *type_annotation : type_annotations_) {
+      type_annotation->ExtractClassNames();
+    }
+  }
+
   void Write(u1 *&p) {
     WriteProlog(p, -1);
     u1 *payload_start = p - 4;
     put_u2be(p, type_annotations_.size());
     for (TypeAnnotation *annotation : type_annotations_) {
       annotation->Write(p);
     }
     put_u4be(payload_start, p - 4 - payload_start);  // backpatch length
   }
 
   std::vector<TypeAnnotation*> type_annotations_;
 };
 
+// See JVMS §4.7.24
+struct MethodParametersAttribute : Attribute {
+  static MethodParametersAttribute *Read(const u1 *&p, Constant *attribute_name,
+                                         u4 attribute_length) {
+    auto attr = new MethodParametersAttribute;
+    attr->attribute_name_ = attribute_name;
+    u1 parameters_count = get_u1(p);
+    for (int ii = 0; ii < parameters_count; ++ii) {
+      MethodParameter* parameter = new MethodParameter;
+      parameter->name_ = constant(get_u2be(p));
+      parameter->access_flags_ = get_u2be(p);
+      attr->parameters_.push_back(parameter);
+    }
+    return attr;
+  }
+
+  void Write(u1 *&p) {
+    WriteProlog(p, -1);
+    u1 *payload_start = p - 4;
+    put_u1(p, parameters_.size());
+    for (MethodParameter* parameter : parameters_) {
+      put_u2be(p, parameter->name_->slot());
+      put_u2be(p, parameter->access_flags_);
+    }
+    put_u4be(payload_start, p - 4 - payload_start);  // backpatch length
+  }
+
+  struct MethodParameter {
+    Constant *name_;
+    u2 access_flags_;
+  };
+
+  std::vector<MethodParameter*> parameters_;
+};
+
 struct GeneralAttribute : Attribute {
   static GeneralAttribute* Read(const u1 *&p, Constant *attribute_name,
                                 u4 attribute_length) {
     auto attr = new GeneralAttribute;
     attr->attribute_name_ = attribute_name;
     attr->attribute_length_ = attribute_length;
     attr->attribute_content_ = p;
     p += attribute_length;
     return attr;
   }
@@ skipping 13 matching lines @@
  *                                                                    *
  **********************************************************************/
 
 struct HasAttrs {
   std::vector<Attribute*> attributes;
 
   void WriteAttrs(u1 *&p);
   void ReadAttrs(const u1 *&p);
 
   virtual ~HasAttrs() {
-    for (size_t i = 0; i < attributes.size(); i++) {
-      delete attributes[i];
+    for (const auto *attribute : attributes) {
+      delete attribute;
+    }
+  }
+
+  void ExtractClassNames() {
+    for (auto *attribute : attributes) {
+      attribute->ExtractClassNames();
     }
   }
 };
 
 // A field or method.
 // See sec.4.5 and 4.6 of JVM spec.
 struct Member : HasAttrs {
   u2 access_flags;
   Constant *name;
   Constant *descriptor;
@@ skipping 42 matching lines @@
       delete methods[i];
     }
 
     // Constants do not need to be deleted; they are owned by the constant pool.
   }
 
   void WriteClass(u1 *&p);
 
   bool ReadConstantPool(const u1 *&p);
 
-  void StripIfAnonymous();
+  bool IsLocalOrAnonymous();
 
   void WriteHeader(u1 *&p) {
     put_u4be(p, magic);
     put_u2be(p, major);
     put_u2be(p, minor);
 
     put_u2be(p, const_pool_out.size());
     for (u2 ii = 1; ii < const_pool_out.size(); ++ii) {
       if (const_pool_out[ii] != NULL) { // NB: NULLs appear after long/double.
         const_pool_out[ii]->Write(p);
@@ skipping 10 matching lines @@
       put_u2be(p, interfaces[ii]->slot());
     }
     put_u2be(p, fields.size());
     for (size_t ii = 0; ii < fields.size(); ++ii) {
       fields[ii]->Write(p);
     }
     put_u2be(p, methods.size());
     for (size_t ii = 0; ii < methods.size(); ++ii) {
       methods[ii]->Write(p);
     }
+
+    Attribute* inner_classes = NULL;
+
+    // Make the inner classes attribute the last, so that it can know which
+    // constants were needed
+    for (size_t ii = 0; ii < attributes.size(); ii++) {
+      if (attributes[ii]->attribute_name_->Display() == "InnerClasses") {
+        inner_classes = attributes[ii];
+        attributes.erase(attributes.begin() + ii);
+        break;
+      }
+    }
+
+    if (inner_classes != NULL) {
+      attributes.push_back(inner_classes);
+    }
+
     WriteAttrs(p);
   }
 
 };
 
 void HasAttrs::ReadAttrs(const u1 *&p) {
   u2 attributes_count = get_u2be(p);
   for (int ii = 0; ii < attributes_count; ii++) {
     Constant *attribute_name = constant(get_u2be(p));
     u4 attribute_length = get_u4be(p);
 
     std::string attr_name = attribute_name->Display();
     if (attr_name == "SourceFile" ||
+        attr_name == "StackMapTable" ||
         attr_name == "LineNumberTable" ||
         attr_name == "LocalVariableTable" ||
         attr_name == "LocalVariableTypeTable" ||
         attr_name == "Code" ||
         attr_name == "Synthetic" ||
-        attr_name == "BootstrapMethods") {
+        attr_name == "BootstrapMethods" ||
+        attr_name == "SourceDebugExtension") {
       p += attribute_length; // drop these attributes
     } else if (attr_name == "Exceptions") {
       attributes.push_back(ExceptionsAttribute::Read(p, attribute_name));
     } else if (attr_name == "Signature") {
       attributes.push_back(SignatureAttribute::Read(p, attribute_name));
     } else if (attr_name == "Deprecated") {
       attributes.push_back(DeprecatedAttribute::Read(p, attribute_name));
     } else if (attr_name == "EnclosingMethod") {
       attributes.push_back(EnclosingMethodAttribute::Read(p, attribute_name));
     } else if (attr_name == "InnerClasses") {
@@ skipping 12 matching lines @@
           ParameterAnnotationsAttribute::Read(p, attribute_name));
     } else if (attr_name == "Scala" ||
                attr_name == "ScalaSig" ||
                attr_name == "ScalaInlineInfo") {
       // These are opaque blobs, so can be handled with a general
       // attribute handler
       attributes.push_back(GeneralAttribute::Read(p, attribute_name,
                                                   attribute_length));
     } else if (attr_name == "RuntimeVisibleTypeAnnotations" ||
                attr_name == "RuntimeInvisibleTypeAnnotations") {
-      // JSR 308: annotations on types. JDK 7 has no use for these yet, but the
-      // Checkers Framework relies on them.
       attributes.push_back(TypeAnnotationsAttribute::Read(p, attribute_name,
                                                           attribute_length));
+    } else if (attr_name == "MethodParameters") {
+      attributes.push_back(
+          MethodParametersAttribute::Read(p, attribute_name, attribute_length));
     } else {
       // Skip over unknown attributes with a warning.  The JVM spec
       // says this is ok, so long as we handle the mandatory attributes.
       fprintf(stderr, "ijar: skipping unknown attribute: \"%s\".\n",
               attr_name.c_str());
       p += attribute_length;
     }
   }
 }
 
 void HasAttrs::WriteAttrs(u1 *&p) {
-  put_u2be(p, attributes.size());
+  u1* p_size = p;
+
+  put_u2be(p, 0);
+  int n_written_attrs = 0;
   for (size_t ii = 0; ii < attributes.size(); ii++) {
+    u1* before = p;
     attributes[ii]->Write(p);
+    if (p != before) {
+      n_written_attrs++;
+    }
   }
+
+  put_u2be(p_size, n_written_attrs);
 }
 
 // See sec.4.4 of JVM spec.
 bool ClassFile::ReadConstantPool(const u1 *&p) {
 
   const_pool_in.clear();
   const_pool_in.push_back(NULL); // dummy first item
 
   u2 cp_count = get_u2be(p);
   for (int ii = 1; ii < cp_count; ++ii) {
@@ skipping 82 matching lines @@
         fprintf(stderr, "Unknown constant: %02x. Passing class through.\n",
                 tag);
         return false;
       }
     }
   }
 
   return true;
 }
 
-// Anonymous inner classes are stripped to opaque classes that only extend
-// Object. None of their methods or fields are accessible anyway.
-void ClassFile::StripIfAnonymous() {
-  int enclosing_index = -1;
-  int inner_classes_index = -1;
-
-  for (size_t ii = 0; ii < attributes.size(); ++ii) {
-    if (attributes[ii]->attribute_name_->Display() == "EnclosingMethod") {
-      enclosing_index = ii;
-    } else if (attributes[ii]->attribute_name_->Display() == "InnerClasses") {
-      inner_classes_index = ii;
+bool ClassFile::IsLocalOrAnonymous() {
+  for (const Attribute *attribute : attributes) {
+    if (attribute->attribute_name_->Display() == "EnclosingMethod") {
+      // JVMS 4.7.6: a class must has EnclosingMethod attribute iff it
+      // represents a local class or an anonymous class
+      return true;
     }
   }
-
-  // Presence of an EnclosingMethod attribute indicates a local or anonymous
-  // class, which can be stripped.
-  if (enclosing_index > -1) {
-    // Clear the signature to only extend java.lang.Object.
-    super_class = NULL;
-    interfaces.clear();
-
-    // Clear away all fields (implementation details).
-    for (size_t ii = 0; ii < fields.size(); ++ii) {
-      delete fields[ii];
-    }
-    fields.clear();
-
-    // Clear away all methods (implementation details).
-    for (size_t ii = 0; ii < methods.size(); ++ii) {
-      delete methods[ii];
-    }
-    methods.clear();
-
-    // Only preserve the InnerClasses attribute to comply with the spec.
-    Attribute *attr = NULL;
-    for (size_t ii = 0; ii < attributes.size(); ++ii) {
-      if (static_cast<int>(ii) != inner_classes_index) {
-        delete attributes[ii];
-      } else {
-        attr = attributes[ii];
-      }
-    }
-    attributes.clear();
-    if (attr != NULL) {
-      attributes.push_back(attr);
-    }
-  }
+  return false;
 }
 
 static ClassFile *ReadClass(const void *classdata, size_t length) {
   const u1 *p = (u1*) classdata;
 
   ClassFile *clazz = new ClassFile;
 
   clazz->length = length;
 
   clazz->magic = get_u4be(p);
   if (clazz->magic != 0xCAFEBABE) {
     fprintf(stderr, "Bad magic %" PRIx32 "\n", clazz->magic);
     abort();
   }
   clazz->major = get_u2be(p);
   clazz->minor = get_u2be(p);
 
   if (!clazz->ReadConstantPool(p)) {
     delete clazz;
     return NULL;
   }
 
   clazz->access_flags = get_u2be(p);
   clazz->this_class = constant(get_u2be(p));
+  class_name = clazz->this_class;
+
   u2 super_class_id = get_u2be(p);
   clazz->super_class = super_class_id == 0 ? NULL : constant(super_class_id);
 
   u2 interfaces_count = get_u2be(p);
   for (int ii = 0; ii < interfaces_count; ++ii) {
     clazz->interfaces.push_back(constant(get_u2be(p)));
   }
 
   u2 fields_count = get_u2be(p);
   for (int ii = 0; ii < fields_count; ++ii) {
     Member *field = Member::Read(p);
 
-    if (!(field->access_flags & ACC_PRIVATE)) { // drop private fields
-      clazz->fields.push_back(field);
+    if ((field->access_flags & ACC_PRIVATE) == ACC_PRIVATE) {
+      // drop private fields
+      continue;
     }
+    clazz->fields.push_back(field);
   }
 
   u2 methods_count = get_u2be(p);
   for (int ii = 0; ii < methods_count; ++ii) {
     Member *method = Member::Read(p);
 
     // drop class initializers
     if (method->name->Display() == "<clinit>") continue;
 
-    if (!(method->access_flags & ACC_PRIVATE)) { // drop private methods
-      clazz->methods.push_back(method);
+    if ((method->access_flags & ACC_PRIVATE) == ACC_PRIVATE) {
+      // drop private methods
+      continue;
     }
+    if ((method->access_flags & (ACC_SYNTHETIC | ACC_BRIDGE)) ==
+        ACC_SYNTHETIC) {
+      // drop non-bridge synthetic methods, e.g. package-private synthetic
+      // constructors used to instantiate private nested classes within their
+      // declaring compilation unit
+      continue;
+    }
+    clazz->methods.push_back(method);
   }
 
   clazz->ReadAttrs(p);
-  clazz->StripIfAnonymous();
 
   return clazz;
 }
 
+// In theory, '/' is also reserved, but it's okay if we just parse package
+// identifiers as part of the class name. Note that signatures are UTF-8, but
+// this works just as well as in plain ASCII.
+static const char *SIGNATURE_NON_IDENTIFIER_CHARS = ".;[<>:";
+
+void Expect(const std::string& desc, size_t* p, char expected) {
+  if (desc[*p] != expected) {
+    fprintf(stderr, "Expected '%c' in '%s' at %zd in signature\n",
+            expected, desc.substr(*p).c_str(), *p);
+    exit(1);
+  }
+
+  *p += 1;
+}
+
+// These functions form a crude recursive descent parser for descriptors and
+// signatures in class files (see JVM spec 4.3).
+//
+// This parser is a bit more liberal than the spec, but this should be fine,
+// because it accepts all valid class files and croaks only on invalid ones.
+void ParseFromClassTypeSignature(const std::string& desc, size_t* p);
+void ParseSimpleClassTypeSignature(const std::string& desc, size_t* p);
+void ParseClassTypeSignatureSuffix(const std::string& desc, size_t* p);
+void ParseIdentifier(const std::string& desc, size_t* p);
+void ParseTypeArgumentsOpt(const std::string& desc, size_t* p);
+void ParseMethodDescriptor(const std::string& desc, size_t* p);
+
+void ParseClassTypeSignature(const std::string& desc, size_t* p) {
+  Expect(desc, p, 'L');
+  ParseSimpleClassTypeSignature(desc, p);
+  ParseClassTypeSignatureSuffix(desc, p);
+  Expect(desc, p, ';');
+}
+
+void ParseSimpleClassTypeSignature(const std::string& desc, size_t* p) {
+  ParseIdentifier(desc, p);
+  ParseTypeArgumentsOpt(desc, p);
+}
+
+void ParseClassTypeSignatureSuffix(const std::string& desc, size_t* p) {
+  while (desc[*p] == '.') {
+    *p += 1;
+    ParseSimpleClassTypeSignature(desc, p);
+  }
+}
+
+void ParseIdentifier(const std::string& desc, size_t* p) {
+  size_t next = desc.find_first_of(SIGNATURE_NON_IDENTIFIER_CHARS, *p);
+  std::string id = desc.substr(*p, next - *p);
+  used_class_names.insert(id);
+  *p = next;
+}
+
+void ParseTypeArgumentsOpt(const std::string& desc, size_t* p) {
+  if (desc[*p] != '<') {
+    return;
+  }
+
+  *p += 1;
+  while (desc[*p] != '>') {
+    switch (desc[*p]) {
+      case '*':
+        *p += 1;
+        break;
+
+      case '+':
+      case '-':
+        *p += 1;
+        ExtractClassNames(desc, p);
+        break;
+
+      default:
+        ExtractClassNames(desc, p);
+        break;
+    }
+  }
+
+  *p += 1;
+}
+
+void ParseMethodDescriptor(const std::string& desc, size_t* p) {
+  Expect(desc, p, '(');
+  while (desc[*p] != ')') {
+    ExtractClassNames(desc, p);
+  }
+
+  Expect(desc, p, ')');
+  ExtractClassNames(desc, p);
+}
+
+void ParseFormalTypeParameters(const std::string& desc, size_t* p) {
+  Expect(desc, p, '<');
+  while (desc[*p] != '>') {
+    ParseIdentifier(desc, p);
+    Expect(desc, p, ':');
+    if (desc[*p] != ':' && desc[*p] != '>') {
+      ExtractClassNames(desc, p);
+    }
+
+    while (desc[*p] == ':') {
+      Expect(desc, p, ':');
+      ExtractClassNames(desc, p);
+    }
+  }
+
+  Expect(desc, p, '>');
+}
+
+void ExtractClassNames(const std::string& desc, size_t* p) {
+  switch (desc[*p]) {
+    case '<':
+      ParseFormalTypeParameters(desc, p);
+      ExtractClassNames(desc, p);
+      break;
+
+    case 'L':
+      ParseClassTypeSignature(desc, p);
+      break;
+
+    case '[':
+      *p += 1;
+      ExtractClassNames(desc, p);
+      break;
+
+    case 'T':
+      *p += 1;
+      ParseIdentifier(desc, p);
+      Expect(desc, p, ';');
+      break;
+
+    case '(':
+      ParseMethodDescriptor(desc, p);
+      break;
+
+    case 'B':
+    case 'C':
+    case 'D':
+    case 'F':
+    case 'I':
+    case 'J':
+    case 'S':
+    case 'Z':
+    case 'V':
+      *p += 1;
+      break;
+
+    default:
+      fprintf(stderr, "Invalid signature %s\n", desc.substr(*p).c_str());
+  }
+}
+
 void ClassFile::WriteClass(u1 *&p) {
+  used_class_names.clear();
+  std::vector<Member *> members;
+  members.insert(members.end(), fields.begin(), fields.end());
+  members.insert(members.end(), methods.begin(), methods.end());
+  ExtractClassNames();
+  for (auto *member : members) {
+    size_t idx = 0;
+    devtools_ijar::ExtractClassNames(member->descriptor->Display(), &idx);
+    member->ExtractClassNames();
+  }
+
   // We have to write the body out before the header in order to reference
   // the essential constants and populate the output constant pool:
   u1 *body = new u1[length];
   u1 *q = body;
   WriteBody(q); // advances q
   u4 body_length = q - body;
 
   WriteHeader(p); // advances p
   put_n(p, body, body_length);
   delete[] body;
 }
 
-
-void StripClass(u1 *&classdata_out, const u1 *classdata_in, size_t in_length) {
+bool StripClass(u1 *&classdata_out, const u1 *classdata_in, size_t in_length) {
   ClassFile *clazz = ReadClass(classdata_in, in_length);
+  bool keep = true;
   if (clazz == NULL) {
     // Class is invalid. Simply copy it to the output and call it a day.
     put_n(classdata_out, classdata_in, in_length);
+  } else if (clazz->IsLocalOrAnonymous()) {
+    keep = false;
   } else {
 
     // Constant pool item zero is a dummy entry.  Setting it marks the
     // beginning of the output phase; calls to Constant::slot() will
     // fail if called prior to this.
     const_pool_out.push_back(NULL);
-
-    // TODO(bazel-team): We should only keep classes in the InnerClass attributes
-    // if they're used in the output. The entries can then be cleaned out of the
-    // constant pool in the normal way.
-
     clazz->WriteClass(classdata_out);
 
     delete clazz;
   }
 
   // Now clean up all the mess we left behind.
 
   for (size_t i = 0; i < const_pool_in.size(); i++) {
     delete const_pool_in[i];
   }
 
   const_pool_in.clear();
   const_pool_out.clear();
+  return keep;
 }
 
 }  // namespace devtools_ijar