1 /*
2 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.java.util.jar.pack;
27
28 import com.sun.java.util.jar.pack.ConstantPool.ClassEntry;
29 import com.sun.java.util.jar.pack.ConstantPool.DescriptorEntry;
30 import com.sun.java.util.jar.pack.ConstantPool.Entry;
31 import com.sun.java.util.jar.pack.ConstantPool.SignatureEntry;
32 import com.sun.java.util.jar.pack.ConstantPool.MemberEntry;
33 import com.sun.java.util.jar.pack.ConstantPool.MethodHandleEntry;
34 import com.sun.java.util.jar.pack.ConstantPool.BootstrapMethodEntry;
35 import com.sun.java.util.jar.pack.ConstantPool.Utf8Entry;
36 import com.sun.java.util.jar.pack.Package.Class;
37 import com.sun.java.util.jar.pack.Package.InnerClass;
38 import java.io.DataInputStream;
39 import java.io.FilterInputStream;
40 import java.io.IOException;
41 import java.io.InputStream;
42 import java.util.ArrayList;
43 import java.util.Arrays;
44 import java.util.Map;
45 import static com.sun.java.util.jar.pack.Constants.*;
46
47 /**
48 * Reader for a class file that is being incorporated into a package.
49 * @author John Rose
50 */
51 class ClassReader {
52 int verbose;
53
54 Package pkg;
55 Class cls;
56 long inPos;
57 long constantPoolLimit = -1;
58 DataInputStream in;
59 Map<Attribute.Layout, Attribute> attrDefs;
60 Map<Attribute.Layout, String> attrCommands;
61 String unknownAttrCommand = "error";;
62
63 ClassReader(Class cls, InputStream in) throws IOException {
64 this.pkg = cls.getPackage();
65 this.cls = cls;
66 this.verbose = pkg.verbose;
67 this.in = new DataInputStream(new FilterInputStream(in) {
68 public int read(byte b[], int off, int len) throws IOException {
69 int nr = super.read(b, off, len);
70 if (nr >= 0) inPos += nr;
71 return nr;
72 }
73 public int read() throws IOException {
74 int ch = super.read();
75 if (ch >= 0) inPos += 1;
76 return ch;
77 }
78 public long skip(long n) throws IOException {
79 long ns = super.skip(n);
80 if (ns >= 0) inPos += ns;
81 return ns;
82 }
83 });
84 }
85
86 public void setAttrDefs(Map<Attribute.Layout, Attribute> attrDefs) {
87 this.attrDefs = attrDefs;
88 }
89
90 public void setAttrCommands(Map<Attribute.Layout, String> attrCommands) {
91 this.attrCommands = attrCommands;
92 }
93
94 private void skip(int n, String what) throws IOException {
95 Utils.log.warning("skipping "+n+" bytes of "+what);
96 long skipped = 0;
97 while (skipped < n) {
98 long j = in.skip(n - skipped);
99 assert(j > 0);
100 skipped += j;
101 }
102 assert(skipped == n);
103 }
104
105 private int readUnsignedShort() throws IOException {
106 return in.readUnsignedShort();
107 }
108
109 private int readInt() throws IOException {
110 return in.readInt();
111 }
112
113 /** Read a 2-byte int, and return the <em>global</em> CP entry for it. */
114 private Entry readRef() throws IOException {
115 int i = in.readUnsignedShort();
116 return i == 0 ? null : cls.cpMap[i];
117 }
118
119 private Entry readRef(byte tag) throws IOException {
120 Entry e = readRef();
121 assert(!(e instanceof UnresolvedEntry));
122 checkTag(e, tag);
123 return e;
124 }
125
126 /** Throw a ClassFormatException if the entry does not match the expected tag type. */
127 private Entry checkTag(Entry e, byte tag) throws ClassFormatException {
128 if (e == null || !e.tagMatches(tag)) {
129 String where = (inPos == constantPoolLimit
130 ? " in constant pool"
131 : " at pos: " + inPos);
132 String got = (e == null
133 ? "null CP index"
134 : "type=" + ConstantPool.tagName(e.tag));
135 throw new ClassFormatException("Bad constant, expected type=" +
136 ConstantPool.tagName(tag) +
137 " got "+ got + ", in File: " + cls.file.nameString + where);
138 }
139 return e;
140 }
141 private Entry checkTag(Entry e, byte tag, boolean nullOK) throws ClassFormatException {
142 return nullOK && e == null ? null : checkTag(e, tag);
143 }
144
145 private Entry readRefOrNull(byte tag) throws IOException {
146 Entry e = readRef();
147 checkTag(e, tag, true);
148 return e;
149 }
150
151 private Utf8Entry readUtf8Ref() throws IOException {
152 return (Utf8Entry) readRef(CONSTANT_Utf8);
153 }
154
155 private ClassEntry readClassRef() throws IOException {
156 return (ClassEntry) readRef(CONSTANT_Class);
157 }
158
159 private ClassEntry readClassRefOrNull() throws IOException {
160 return (ClassEntry) readRefOrNull(CONSTANT_Class);
161 }
162
163 private SignatureEntry readSignatureRef() throws IOException {
164 // The class file stores a Utf8, but we want a Signature.
165 Entry e = readRef(CONSTANT_Signature);
166 return (e != null && e.getTag() == CONSTANT_Utf8)
167 ? ConstantPool.getSignatureEntry(e.stringValue())
168 : (SignatureEntry) e;
169 }
170
171 void read() throws IOException {
172 boolean ok = false;
173 try {
174 readMagicNumbers();
175 readConstantPool();
176 readHeader();
177 readMembers(false); // fields
178 readMembers(true); // methods
179 readAttributes(ATTR_CONTEXT_CLASS, cls);
180 fixUnresolvedEntries();
181 cls.finishReading();
182 assert(0 >= in.read(new byte[1]));
183 ok = true;
184 } finally {
185 if (!ok) {
186 if (verbose > 0) Utils.log.warning("Erroneous data at input offset "+inPos+" of "+cls.file);
187 }
188 }
189 }
190
191 void readMagicNumbers() throws IOException {
192 cls.magic = in.readInt();
193 if (cls.magic != JAVA_MAGIC)
194 throw new Attribute.FormatException
195 ("Bad magic number in class file "
196 +Integer.toHexString(cls.magic),
197 ATTR_CONTEXT_CLASS, "magic-number", "pass");
198 int minver = (short) readUnsignedShort();
199 int majver = (short) readUnsignedShort();
200 cls.version = Package.Version.of(majver, minver);
201
202 //System.out.println("ClassFile.version="+cls.majver+"."+cls.minver);
203 String bad = checkVersion(cls.version);
204 if (bad != null) {
205 throw new Attribute.FormatException
206 ("classfile version too "+bad+": "
207 +cls.version+" in "+cls.file,
208 ATTR_CONTEXT_CLASS, "version", "pass");
209 }
210 }
211
212 private String checkVersion(Package.Version ver) {
213 int majver = ver.major;
214 int minver = ver.minor;
215 if (majver < pkg.minClassVersion.major ||
216 (majver == pkg.minClassVersion.major &&
217 minver < pkg.minClassVersion.minor)) {
218 return "small";
219 }
220 if (majver > pkg.maxClassVersion.major ||
221 (majver == pkg.maxClassVersion.major &&
222 minver > pkg.maxClassVersion.minor)) {
223 return "large";
224 }
225 return null; // OK
226 }
227
228 void readConstantPool() throws IOException {
229 int length = in.readUnsignedShort();
230 //System.err.println("reading CP, length="+length);
231
232 int[] fixups = new int[length*4];
233 int fptr = 0;
234
235 Entry[] cpMap = new Entry[length];
236 cpMap[0] = null;
237 for (int i = 1; i < length; i++) {
238 //System.err.println("reading CP elt, i="+i);
239 int tag = in.readByte();
240 switch (tag) {
241 case CONSTANT_Utf8:
242 cpMap[i] = ConstantPool.getUtf8Entry(in.readUTF());
243 break;
244 case CONSTANT_Integer:
245 {
246 cpMap[i] = ConstantPool.getLiteralEntry(in.readInt());
247 }
248 break;
249 case CONSTANT_Float:
250 {
251 cpMap[i] = ConstantPool.getLiteralEntry(in.readFloat());
252 }
253 break;
254 case CONSTANT_Long:
255 {
256 cpMap[i] = ConstantPool.getLiteralEntry(in.readLong());
257 cpMap[++i] = null;
258 }
259 break;
260 case CONSTANT_Double:
261 {
262 cpMap[i] = ConstantPool.getLiteralEntry(in.readDouble());
263 cpMap[++i] = null;
264 }
265 break;
266
267 // just read the refs; do not attempt to resolve while reading
268 case CONSTANT_Class:
269 case CONSTANT_String:
270 case CONSTANT_MethodType:
271 fixups[fptr++] = i;
272 fixups[fptr++] = tag;
273 fixups[fptr++] = in.readUnsignedShort();
274 fixups[fptr++] = -1; // empty ref2
275 break;
276 case CONSTANT_Fieldref:
277 case CONSTANT_Methodref:
278 case CONSTANT_InterfaceMethodref:
279 case CONSTANT_NameandType:
280 fixups[fptr++] = i;
281 fixups[fptr++] = tag;
282 fixups[fptr++] = in.readUnsignedShort();
283 fixups[fptr++] = in.readUnsignedShort();
284 break;
285 case CONSTANT_InvokeDynamic:
286 fixups[fptr++] = i;
287 fixups[fptr++] = tag;
288 fixups[fptr++] = -1 ^ in.readUnsignedShort(); // not a ref
289 fixups[fptr++] = in.readUnsignedShort();
290 break;
291 case CONSTANT_MethodHandle:
292 fixups[fptr++] = i;
293 fixups[fptr++] = tag;
294 fixups[fptr++] = -1 ^ in.readUnsignedByte();
295 fixups[fptr++] = in.readUnsignedShort();
296 break;
297 default:
298 throw new ClassFormatException("Bad constant pool tag " +
299 tag + " in File: " + cls.file.nameString +
300 " at pos: " + inPos);
301 }
302 }
303 constantPoolLimit = inPos;
304
305 // Fix up refs, which might be out of order.
306 while (fptr > 0) {
307 if (verbose > 3)
308 Utils.log.fine("CP fixups ["+fptr/4+"]");
309 int flimit = fptr;
310 fptr = 0;
311 for (int fi = 0; fi < flimit; ) {
312 int cpi = fixups[fi++];
313 int tag = fixups[fi++];
314 int ref = fixups[fi++];
315 int ref2 = fixups[fi++];
316 if (verbose > 3)
317 Utils.log.fine(" cp["+cpi+"] = "+ConstantPool.tagName(tag)+"{"+ref+","+ref2+"}");
318 if (ref >= 0 && cpMap[ref] == null || ref2 >= 0 && cpMap[ref2] == null) {
319 // Defer.
320 fixups[fptr++] = cpi;
321 fixups[fptr++] = tag;
322 fixups[fptr++] = ref;
323 fixups[fptr++] = ref2;
324 continue;
325 }
326 switch (tag) {
327 case CONSTANT_Class:
328 cpMap[cpi] = ConstantPool.getClassEntry(cpMap[ref].stringValue());
329 break;
330 case CONSTANT_String:
331 cpMap[cpi] = ConstantPool.getStringEntry(cpMap[ref].stringValue());
332 break;
333 case CONSTANT_Fieldref:
334 case CONSTANT_Methodref:
335 case CONSTANT_InterfaceMethodref:
336 ClassEntry mclass = (ClassEntry) checkTag(cpMap[ref], CONSTANT_Class);
337 DescriptorEntry mdescr = (DescriptorEntry) checkTag(cpMap[ref2], CONSTANT_NameandType);
338 cpMap[cpi] = ConstantPool.getMemberEntry((byte)tag, mclass, mdescr);
339 break;
340 case CONSTANT_NameandType:
341 Utf8Entry mname = (Utf8Entry) checkTag(cpMap[ref], CONSTANT_Utf8);
342 Utf8Entry mtype = (Utf8Entry) checkTag(cpMap[ref2], CONSTANT_Signature);
343 cpMap[cpi] = ConstantPool.getDescriptorEntry(mname, mtype);
344 break;
345 case CONSTANT_MethodType:
346 cpMap[cpi] = ConstantPool.getMethodTypeEntry((Utf8Entry) checkTag(cpMap[ref], CONSTANT_Signature));
347 break;
348 case CONSTANT_MethodHandle:
349 byte refKind = (byte)(-1 ^ ref);
350 MemberEntry memRef = (MemberEntry) checkTag(cpMap[ref2], CONSTANT_AnyMember);
351 cpMap[cpi] = ConstantPool.getMethodHandleEntry(refKind, memRef);
352 break;
353 case CONSTANT_InvokeDynamic:
354 DescriptorEntry idescr = (DescriptorEntry) checkTag(cpMap[ref2], CONSTANT_NameandType);
355 cpMap[cpi] = new UnresolvedEntry((byte)tag, (-1 ^ ref), idescr);
356 // Note that ref must be resolved later, using the BootstrapMethods attribute.
357 break;
358 default:
359 assert(false);
360 }
361 }
362 assert(fptr < flimit); // Must make progress.
363 }
364
365 cls.cpMap = cpMap;
366 }
367
368 private /*non-static*/
369 class UnresolvedEntry extends Entry {
370 final Object[] refsOrIndexes;
371 UnresolvedEntry(byte tag, Object... refsOrIndexes) {
372 super(tag);
373 this.refsOrIndexes = refsOrIndexes;
374 ClassReader.this.haveUnresolvedEntry = true;
375 }
376 Entry resolve() {
377 Class cls = ClassReader.this.cls;
378 Entry res;
379 switch (tag) {
380 case CONSTANT_InvokeDynamic:
381 BootstrapMethodEntry iboots = cls.bootstrapMethods.get((Integer) refsOrIndexes[0]);
382 DescriptorEntry idescr = (DescriptorEntry) refsOrIndexes[1];
383 res = ConstantPool.getInvokeDynamicEntry(iboots, idescr);
384 break;
385 default:
386 throw new AssertionError();
387 }
388 return res;
389 }
390 private void unresolved() { throw new RuntimeException("unresolved entry has no string"); }
391 public int compareTo(Object x) { unresolved(); return 0; }
392 public boolean equals(Object x) { unresolved(); return false; }
393 protected int computeValueHash() { unresolved(); return 0; }
394 public String stringValue() { unresolved(); return toString(); }
395 public String toString() { return "(unresolved "+ConstantPool.tagName(tag)+")"; }
396 }
397
398 boolean haveUnresolvedEntry;
399 private void fixUnresolvedEntries() {
400 if (!haveUnresolvedEntry) return;
401 Entry[] cpMap = cls.getCPMap();
402 for (int i = 0; i < cpMap.length; i++) {
403 Entry e = cpMap[i];
404 if (e instanceof UnresolvedEntry) {
405 cpMap[i] = e = ((UnresolvedEntry)e).resolve();
406 assert(!(e instanceof UnresolvedEntry));
407 }
408 }
409 haveUnresolvedEntry = false;
410 }
411
412 void readHeader() throws IOException {
413 cls.flags = readUnsignedShort();
414 cls.thisClass = readClassRef();
415 cls.superClass = readClassRefOrNull();
416 int ni = readUnsignedShort();
417 cls.interfaces = new ClassEntry[ni];
418 for (int i = 0; i < ni; i++) {
419 cls.interfaces[i] = readClassRef();
420 }
421 }
422
423 void readMembers(boolean doMethods) throws IOException {
424 int nm = readUnsignedShort();
425 for (int i = 0; i < nm; i++) {
426 readMember(doMethods);
427 }
428 }
429
430 void readMember(boolean doMethod) throws IOException {
431 int mflags = readUnsignedShort();
432 Utf8Entry mname = readUtf8Ref();
433 SignatureEntry mtype = readSignatureRef();
434 DescriptorEntry descr = ConstantPool.getDescriptorEntry(mname, mtype);
435 Class.Member m;
436 if (!doMethod)
437 m = cls.new Field(mflags, descr);
438 else
439 m = cls.new Method(mflags, descr);
440 readAttributes(!doMethod ? ATTR_CONTEXT_FIELD : ATTR_CONTEXT_METHOD,
441 m);
442 }
443 void readAttributes(int ctype, Attribute.Holder h) throws IOException {
444 int na = readUnsignedShort();
445 if (na == 0) return; // nothing to do here
446 if (verbose > 3)
447 Utils.log.fine("readAttributes "+h+" ["+na+"]");
448 for (int i = 0; i < na; i++) {
449 String name = readUtf8Ref().stringValue();
450 int length = readInt();
451 // See if there is a special command that applies.
452 if (attrCommands != null) {
453 Attribute.Layout lkey = Attribute.keyForLookup(ctype, name);
454 String cmd = attrCommands.get(lkey);
455 if (cmd != null) {
456 switch (cmd) {
457 case "pass":
458 String message1 = "passing attribute bitwise in " + h;
459 throw new Attribute.FormatException(message1, ctype, name, cmd);
460 case "error":
461 String message2 = "attribute not allowed in " + h;
462 throw new Attribute.FormatException(message2, ctype, name, cmd);
463 case "strip":
464 skip(length, name + " attribute in " + h);
465 continue;
466 }
467 }
468 }
469 // Find canonical instance of the requested attribute.
470 Attribute a = Attribute.lookup(Package.attrDefs, ctype, name);
471 if (verbose > 4 && a != null)
472 Utils.log.fine("pkg_attribute_lookup "+name+" = "+a);
473 if (a == null) {
474 a = Attribute.lookup(this.attrDefs, ctype, name);
475 if (verbose > 4 && a != null)
476 Utils.log.fine("this "+name+" = "+a);
477 }
478 if (a == null) {
479 a = Attribute.lookup(null, ctype, name);
480 if (verbose > 4 && a != null)
481 Utils.log.fine("null_attribute_lookup "+name+" = "+a);
482 }
483 if (a == null && length == 0) {
484 // Any zero-length attr is "known"...
485 // We can assume an empty attr. has an empty layout.
486 // Handles markers like Enum, Bridge, Synthetic, Deprecated.
487 a = Attribute.find(ctype, name, "");
488 }
489 boolean isStackMap = (ctype == ATTR_CONTEXT_CODE
490 && (name.equals("StackMap") ||
491 name.equals("StackMapX")));
492 if (isStackMap) {
493 // Known attribute but with a corner case format, "pass" it.
494 Code code = (Code) h;
495 final int TOO_BIG = 0x10000;
496 if (code.max_stack >= TOO_BIG ||
497 code.max_locals >= TOO_BIG ||
498 code.getLength() >= TOO_BIG ||
499 name.endsWith("X")) {
500 // No, we don't really know what to do with this one.
501 // Do not compress the rare and strange "u4" and "X" cases.
502 a = null;
503 }
504 }
505 if (a == null) {
506 if (isStackMap) {
507 // Known attribute but w/o a format; pass it.
508 String message = "unsupported StackMap variant in "+h;
509 throw new Attribute.FormatException(message, ctype, name,
510 "pass");
511 } else if ("strip".equals(unknownAttrCommand)) {
512 // Skip the unknown attribute.
513 skip(length, "unknown "+name+" attribute in "+h);
514 continue;
515 } else {
516 String message = " is unknown attribute in class " + h;
517 throw new Attribute.FormatException(message, ctype, name,
518 unknownAttrCommand);
519 }
520 }
521 long pos0 = inPos; // in case we want to check it
522 if (a.layout() == Package.attrCodeEmpty) {
523 // These are hardwired.
524 Class.Method m = (Class.Method) h;
525 m.code = new Code(m);
526 try {
527 readCode(m.code);
528 } catch (Instruction.FormatException iie) {
529 String message = iie.getMessage() + " in " + h;
530 throw new ClassReader.ClassFormatException(message, iie);
531 }
532 assert(length == inPos - pos0);
533 // Keep empty attribute a...
534 } else if (a.layout() == Package.attrBootstrapMethodsEmpty) {
535 assert(h == cls);
536 readBootstrapMethods(cls);
537 assert(length == inPos - pos0);
538 // Delete the attribute; it is logically part of the constant pool.
539 continue;
540 } else if (a.layout() == Package.attrInnerClassesEmpty) {
541 // These are hardwired also.
542 assert(h == cls);
543 readInnerClasses(cls);
544 assert(length == inPos - pos0);
545 // Keep empty attribute a...
546 } else if (length > 0) {
547 byte[] bytes = new byte[length];
548 in.readFully(bytes);
549 a = a.addContent(bytes);
550 }
551 if (a.size() == 0 && !a.layout().isEmpty()) {
552 throw new ClassFormatException(name +
553 ": attribute length cannot be zero, in " + h);
554 }
555 h.addAttribute(a);
556 if (verbose > 2)
557 Utils.log.fine("read "+a);
558 }
559 }
560
561 void readCode(Code code) throws IOException {
562 code.max_stack = readUnsignedShort();
563 code.max_locals = readUnsignedShort();
564 code.bytes = new byte[readInt()];
565 in.readFully(code.bytes);
566 Entry[] cpMap = cls.getCPMap();
567 Instruction.opcodeChecker(code.bytes, cpMap, this.cls.version);
568 int nh = readUnsignedShort();
569 code.setHandlerCount(nh);
570 for (int i = 0; i < nh; i++) {
571 code.handler_start[i] = readUnsignedShort();
572 code.handler_end[i] = readUnsignedShort();
573 code.handler_catch[i] = readUnsignedShort();
574 code.handler_class[i] = readClassRefOrNull();
575 }
576 readAttributes(ATTR_CONTEXT_CODE, code);
577 }
578
579 void readBootstrapMethods(Class cls) throws IOException {
580 BootstrapMethodEntry[] bsms = new BootstrapMethodEntry[readUnsignedShort()];
581 for (int i = 0; i < bsms.length; i++) {
582 MethodHandleEntry bsmRef = (MethodHandleEntry) readRef(CONSTANT_MethodHandle);
583 Entry[] argRefs = new Entry[readUnsignedShort()];
584 for (int j = 0; j < argRefs.length; j++) {
585 argRefs[j] = readRef(CONSTANT_LoadableValue);
586 }
587 bsms[i] = ConstantPool.getBootstrapMethodEntry(bsmRef, argRefs);
588 }
589 cls.setBootstrapMethods(Arrays.asList(bsms));
590 }
591
592 void readInnerClasses(Class cls) throws IOException {
593 int nc = readUnsignedShort();
594 ArrayList<InnerClass> ics = new ArrayList<>(nc);
595 for (int i = 0; i < nc; i++) {
596 InnerClass ic =
597 new InnerClass(readClassRef(),
598 readClassRefOrNull(),
599 (Utf8Entry)readRefOrNull(CONSTANT_Utf8),
600 readUnsignedShort());
601 ics.add(ic);
602 }
603 cls.innerClasses = ics; // set directly; do not use setInnerClasses.
604 // (Later, ics may be transferred to the pkg.)
605 }
606
607 static class ClassFormatException extends IOException {
608 private static final long serialVersionUID = -3564121733989501833L;
609
610 public ClassFormatException(String message) {
611 super(message);
612 }
613
614 public ClassFormatException(String message, Throwable cause) {
615 super(message, cause);
616 }
617 }
618 }