jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/jvm/ClassReader.java

-:0c244701188e
+:31780dd06ec7
 /**
 * Whether or not any parameter names have been found.
 */
 boolean haveParameterNameIndices;
+/** Set this to false every time we start reading a method
+* and are saving parameter names.  Set it to true when we see
+* MethodParameters, if it's set when we see a LocalVariableTable,
+* then we ignore the parameter names from the LVT.
+*/
+boolean sawMethodParameters;
 /**
 * The set of attribute names for which warnings have been generated for the current class
 */
 Set<Name> warnedAttrs = new HashSet<Name>();
 },
 new AttributeReader(names.LocalVariableTable, V45_3, CLASS_OR_MEMBER_ATTRIBUTE) {
 protected void read(Symbol sym, int attrLen) {
 int newbp = bp + attrLen;
-if (saveParameterNames) {
+if (saveParameterNames && !sawMethodParameters) {
 // Pick up parameter names from the variable table.
 // Parameter names are not explicitly identified as such,
 // but all parameter name entries in the LocalVariableTable
 // have a start_pc of 0.  Therefore, we record the name
 // indicies of all slots with a start_pc of zero in the
 }
 }
 bp = newbp;
 }
 },
+new AttributeReader(names.MethodParameters, V52, MEMBER_ATTRIBUTE) {
+protected void read(Symbol sym, int attrlen) {
+int newbp = bp + attrlen;
+if (saveParameterNames) {
+sawMethodParameters = true;
+int numEntries = nextByte();
+parameterNameIndices = new int[numEntries];
+haveParameterNameIndices = true;
+for (int i = 0; i < numEntries; i++) {
+int nameIndex = nextChar();
+int flags = nextInt();
+parameterNameIndices[i] = nameIndex;
+}
+}
+bp = newbp;
+}
+},
 new AttributeReader(names.SourceFile, V45_3, CLASS_ATTRIBUTE) {
 protected void read(Symbol sym, int attrLen) {
 ClassSymbol c = (ClassSymbol) sym;
 Name n = readName(nextChar());
 || parameterNameIndices.length < expectedParameterSlots) {
 parameterNameIndices = new int[expectedParameterSlots];
 } else
 Arrays.fill(parameterNameIndices, 0);
 haveParameterNameIndices = false;
+sawMethodParameters = false;
 }
 /**
 * Set the parameter names for a symbol from the name index in the
 * parameterNameIndicies array. The type of the symbol may have changed
 */
 void setParameterNames(MethodSymbol sym, Type jvmType) {
 // if no names were found in the class file, there's nothing more to do
 if (!haveParameterNameIndices)
 return;
+// If we get parameter names from MethodParameters, then we
-int firstParam = ((sym.flags() & STATIC) == 0) ? 1 : 0;
+// don't need to skip.
-// the code in readMethod may have skipped the first parameter when
+int firstParam = 0;
-// setting up the MethodType. If so, we make a corresponding allowance
+if (!sawMethodParameters) {
-// here for the position of the first parameter.  Note that this
+firstParam = ((sym.flags() & STATIC) == 0) ? 1 : 0;
-// assumes the skipped parameter has a width of 1 -- i.e. it is not
+// the code in readMethod may have skipped the first
+// parameter when setting up the MethodType. If so, we
+// make a corresponding allowance here for the position of
+// the first parameter.  Note that this assumes the
+// skipped parameter has a width of 1 -- i.e. it is not
 // a double width type (long or double.)
 if (sym.name == names.init && currentOwner.hasOuterInstance()) {
 // Sometimes anonymous classes don't have an outer
 // instance, however, there is no reliable way to tell so
 // we never strip this$n
 if (!currentOwner.name.isEmpty())
 firstParam += 1;
 }
 if (sym.type != jvmType) {
-// reading the method attributes has caused the symbol's type to
+// reading the method attributes has caused the
-// be changed. (i.e. the Signature attribute.)  This may happen if
+// symbol's type to be changed. (i.e. the Signature
-// there are hidden (synthetic) parameters in the descriptor, but
+// attribute.)  This may happen if there are hidden
-// not in the Signature.  The position of these hidden parameters
+// (synthetic) parameters in the descriptor, but not
-// is unspecified; for now, assume they are at the beginning, and
+// in the Signature.  The position of these hidden
-// so skip over them. The primary case for this is two hidden
+// parameters is unspecified; for now, assume they are
-// parameters passed into Enum constructors.
+// at the beginning, and so skip over them. The
+// primary case for this is two hidden parameters
+// passed into Enum constructors.
 int skip = Code.width(jvmType.getParameterTypes())
 - Code.width(sym.type.getParameterTypes());
 firstParam += skip;
+}
 }
 List<Name> paramNames = List.nil();
 int index = firstParam;
 for (Type t: sym.type.getParameterTypes()) {
 int nameIdx = (index < parameterNameIndices.length

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/jvm/ClassReader.java

src/share/classes/com/sun/tools/javac/jvm/ClassReader.java