1 /*
2 * Copyright (c) 2009, 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.tools.classfile;
27
28 import java.io.IOException;
29 import java.util.ArrayList;
30 import java.util.List;
31
32 import com.sun.tools.classfile.TypeAnnotation.Position.TypePathEntry;
33
34 /**
35 * See JSR 308 specification, Section 3.
36 *
37 * <p><b>This is NOT part of any supported API.
38 * If you write code that depends on this, you do so at your own risk.
39 * This code and its internal interfaces are subject to change or
40 * deletion without notice.</b>
41 */
42 public class TypeAnnotation {
43 TypeAnnotation(ClassReader cr) throws IOException, Annotation.InvalidAnnotation {
44 constant_pool = cr.getConstantPool();
45 position = read_position(cr);
46 annotation = new Annotation(cr);
47 }
48
49 public TypeAnnotation(ConstantPool constant_pool,
50 Annotation annotation, Position position) {
51 this.constant_pool = constant_pool;
52 this.position = position;
53 this.annotation = annotation;
54 }
55
56 public int length() {
57 int n = annotation.length();
58 n += position_length(position);
59 return n;
60 }
61
62 @Override
63 public String toString() {
64 try {
65 return "@" + constant_pool.getUTF8Value(annotation.type_index).toString().substring(1) +
66 " pos: " + position.toString();
67 } catch (Exception e) {
68 e.printStackTrace();
69 return e.toString();
70 }
71 }
72
73 public final ConstantPool constant_pool;
74 public final Position position;
75 public final Annotation annotation;
76
77 private static Position read_position(ClassReader cr) throws IOException, Annotation.InvalidAnnotation {
78 // Copied from ClassReader
79 int tag = cr.readUnsignedByte(); // TargetType tag is a byte
80 if (!TargetType.isValidTargetTypeValue(tag))
81 throw new Annotation.InvalidAnnotation("TypeAnnotation: Invalid type annotation target type value: " + String.format("0x%02X", tag));
82
83 TargetType type = TargetType.fromTargetTypeValue(tag);
84
85 Position position = new Position();
86 position.type = type;
87
88 switch (type) {
89 // instanceof
90 case INSTANCEOF:
91 // new expression
92 case NEW:
93 // constructor/method reference receiver
94 case CONSTRUCTOR_REFERENCE:
95 case METHOD_REFERENCE:
96 position.offset = cr.readUnsignedShort();
97 break;
98 // local variable
99 case LOCAL_VARIABLE:
100 // resource variable
101 case RESOURCE_VARIABLE:
102 int table_length = cr.readUnsignedShort();
103 position.lvarOffset = new int[table_length];
104 position.lvarLength = new int[table_length];
105 position.lvarIndex = new int[table_length];
106 for (int i = 0; i < table_length; ++i) {
107 position.lvarOffset[i] = cr.readUnsignedShort();
108 position.lvarLength[i] = cr.readUnsignedShort();
109 position.lvarIndex[i] = cr.readUnsignedShort();
110 }
111 break;
112 // exception parameter
113 case EXCEPTION_PARAMETER:
114 position.exception_index = cr.readUnsignedShort();
115 break;
116 // method receiver
117 case METHOD_RECEIVER:
118 // Do nothing
119 break;
120 // type parameter
121 case CLASS_TYPE_PARAMETER:
122 case METHOD_TYPE_PARAMETER:
123 position.parameter_index = cr.readUnsignedByte();
124 break;
125 // type parameter bound
126 case CLASS_TYPE_PARAMETER_BOUND:
127 case METHOD_TYPE_PARAMETER_BOUND:
128 position.parameter_index = cr.readUnsignedByte();
129 position.bound_index = cr.readUnsignedByte();
130 break;
131 // class extends or implements clause
132 case CLASS_EXTENDS:
133 int in = cr.readUnsignedShort();
134 if (in == 0xFFFF)
135 in = -1;
136 position.type_index = in;
137 break;
138 // throws
139 case THROWS:
140 position.type_index = cr.readUnsignedShort();
141 break;
142 // method parameter
143 case METHOD_FORMAL_PARAMETER:
144 position.parameter_index = cr.readUnsignedByte();
145 break;
146 // type cast
147 case CAST:
148 // method/constructor/reference type argument
149 case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
150 case METHOD_INVOCATION_TYPE_ARGUMENT:
151 case CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
152 case METHOD_REFERENCE_TYPE_ARGUMENT:
153 position.offset = cr.readUnsignedShort();
154 position.type_index = cr.readUnsignedByte();
155 break;
156 // We don't need to worry about these
157 case METHOD_RETURN:
158 case FIELD:
159 break;
160 case UNKNOWN:
161 throw new AssertionError("TypeAnnotation: UNKNOWN target type should never occur!");
162 default:
163 throw new AssertionError("TypeAnnotation: Unknown target type: " + type);
164 }
165
166 { // Write type path
167 int len = cr.readUnsignedByte();
168 List<Integer> loc = new ArrayList<>(len);
169 for (int i = 0; i < len * TypePathEntry.bytesPerEntry; ++i)
170 loc.add(cr.readUnsignedByte());
171 position.location = Position.getTypePathFromBinary(loc);
172 }
173 return position;
174 }
175
176 private static int position_length(Position pos) {
177 int n = 0;
178 n += 1; // TargetType tag is a byte
179 switch (pos.type) {
180 // instanceof
181 case INSTANCEOF:
182 // new expression
183 case NEW:
184 // constructor/method reference receiver
185 case CONSTRUCTOR_REFERENCE:
186 case METHOD_REFERENCE:
187 n += 2; // offset
188 break;
189 // local variable
190 case LOCAL_VARIABLE:
191 // resource variable
192 case RESOURCE_VARIABLE:
193 n += 2; // table_length;
194 int table_length = pos.lvarOffset.length;
195 n += 2 * table_length; // offset
196 n += 2 * table_length; // length
197 n += 2 * table_length; // index
198 break;
199 // exception parameter
200 case EXCEPTION_PARAMETER:
201 n += 2; // exception_index
202 break;
203 // method receiver
204 case METHOD_RECEIVER:
205 // Do nothing
206 break;
207 // type parameter
208 case CLASS_TYPE_PARAMETER:
209 case METHOD_TYPE_PARAMETER:
210 n += 1; // parameter_index
211 break;
212 // type parameter bound
213 case CLASS_TYPE_PARAMETER_BOUND:
214 case METHOD_TYPE_PARAMETER_BOUND:
215 n += 1; // parameter_index
216 n += 1; // bound_index
217 break;
218 // class extends or implements clause
219 case CLASS_EXTENDS:
220 n += 2; // type_index
221 break;
222 // throws
223 case THROWS:
224 n += 2; // type_index
225 break;
226 // method parameter
227 case METHOD_FORMAL_PARAMETER:
228 n += 1; // parameter_index
229 break;
230 // type cast
231 case CAST:
232 // method/constructor/reference type argument
233 case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
234 case METHOD_INVOCATION_TYPE_ARGUMENT:
235 case CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
236 case METHOD_REFERENCE_TYPE_ARGUMENT:
237 n += 2; // offset
238 n += 1; // type index
239 break;
240 // We don't need to worry about these
241 case METHOD_RETURN:
242 case FIELD:
243 break;
244 case UNKNOWN:
245 throw new AssertionError("TypeAnnotation: UNKNOWN target type should never occur!");
246 default:
247 throw new AssertionError("TypeAnnotation: Unknown target type: " + pos.type);
248 }
249
250 {
251 n += 1; // length
252 n += TypePathEntry.bytesPerEntry * pos.location.size(); // bytes for actual array
253 }
254
255 return n;
256 }
257
258 // Code duplicated from com.sun.tools.javac.code.TypeAnnotationPosition
259 public static class Position {
260 public enum TypePathEntryKind {
261 ARRAY(0),
262 INNER_TYPE(1),
263 WILDCARD(2),
264 TYPE_ARGUMENT(3);
265
266 public final int tag;
267
268 private TypePathEntryKind(int tag) {
269 this.tag = tag;
270 }
271 }
272
273 public static class TypePathEntry {
274 /** The fixed number of bytes per TypePathEntry. */
275 public static final int bytesPerEntry = 2;
276
277 public final TypePathEntryKind tag;
278 public final int arg;
279
280 public static final TypePathEntry ARRAY = new TypePathEntry(TypePathEntryKind.ARRAY);
281 public static final TypePathEntry INNER_TYPE = new TypePathEntry(TypePathEntryKind.INNER_TYPE);
282 public static final TypePathEntry WILDCARD = new TypePathEntry(TypePathEntryKind.WILDCARD);
283
284 private TypePathEntry(TypePathEntryKind tag) {
285 if (!(tag == TypePathEntryKind.ARRAY ||
286 tag == TypePathEntryKind.INNER_TYPE ||
287 tag == TypePathEntryKind.WILDCARD)) {
288 throw new AssertionError("Invalid TypePathEntryKind: " + tag);
289 }
290 this.tag = tag;
291 this.arg = 0;
292 }
293
294 public TypePathEntry(TypePathEntryKind tag, int arg) {
295 if (tag != TypePathEntryKind.TYPE_ARGUMENT) {
296 throw new AssertionError("Invalid TypePathEntryKind: " + tag);
297 }
298 this.tag = tag;
299 this.arg = arg;
300 }
301
302 public static TypePathEntry fromBinary(int tag, int arg) {
303 if (arg != 0 && tag != TypePathEntryKind.TYPE_ARGUMENT.tag) {
304 throw new AssertionError("Invalid TypePathEntry tag/arg: " + tag + "/" + arg);
305 }
306 switch (tag) {
307 case 0:
308 return ARRAY;
309 case 1:
310 return INNER_TYPE;
311 case 2:
312 return WILDCARD;
313 case 3:
314 return new TypePathEntry(TypePathEntryKind.TYPE_ARGUMENT, arg);
315 default:
316 throw new AssertionError("Invalid TypePathEntryKind tag: " + tag);
317 }
318 }
319
320 @Override
321 public String toString() {
322 return tag.toString() +
323 (tag == TypePathEntryKind.TYPE_ARGUMENT ? ("(" + arg + ")") : "");
324 }
325
326 @Override
327 public boolean equals(Object other) {
328 if (! (other instanceof TypePathEntry)) {
329 return false;
330 }
331 TypePathEntry tpe = (TypePathEntry) other;
332 return this.tag == tpe.tag && this.arg == tpe.arg;
333 }
334
335 @Override
336 public int hashCode() {
337 return this.tag.hashCode() * 17 + this.arg;
338 }
339 }
340
341 public TargetType type = TargetType.UNKNOWN;
342
343 // For generic/array types.
344 // TODO: or should we use null? Noone will use this object.
345 public List<TypePathEntry> location = new ArrayList<>(0);
346
347 // Tree position.
348 public int pos = -1;
349
350 // For typecasts, type tests, new (and locals, as start_pc).
351 public boolean isValidOffset = false;
352 public int offset = -1;
353
354 // For locals. arrays same length
355 public int[] lvarOffset = null;
356 public int[] lvarLength = null;
357 public int[] lvarIndex = null;
358
359 // For type parameter bound
360 public int bound_index = Integer.MIN_VALUE;
361
362 // For type parameter and method parameter
363 public int parameter_index = Integer.MIN_VALUE;
364
365 // For class extends, implements, and throws clauses
366 public int type_index = Integer.MIN_VALUE;
367
368 // For exception parameters, index into exception table
369 public int exception_index = Integer.MIN_VALUE;
370
371 public Position() {}
372
373 @Override
374 public String toString() {
375 StringBuilder sb = new StringBuilder();
376 sb.append('[');
377 sb.append(type);
378
379 switch (type) {
380 // instanceof
381 case INSTANCEOF:
382 // new expression
383 case NEW:
384 // constructor/method reference receiver
385 case CONSTRUCTOR_REFERENCE:
386 case METHOD_REFERENCE:
387 sb.append(", offset = ");
388 sb.append(offset);
389 break;
390 // local variable
391 case LOCAL_VARIABLE:
392 // resource variable
393 case RESOURCE_VARIABLE:
394 if (lvarOffset == null) {
395 sb.append(", lvarOffset is null!");
396 break;
397 }
398 sb.append(", {");
399 for (int i = 0; i < lvarOffset.length; ++i) {
400 if (i != 0) sb.append("; ");
401 sb.append("start_pc = ");
402 sb.append(lvarOffset[i]);
403 sb.append(", length = ");
404 sb.append(lvarLength[i]);
405 sb.append(", index = ");
406 sb.append(lvarIndex[i]);
407 }
408 sb.append("}");
409 break;
410 // method receiver
411 case METHOD_RECEIVER:
412 // Do nothing
413 break;
414 // type parameter
415 case CLASS_TYPE_PARAMETER:
416 case METHOD_TYPE_PARAMETER:
417 sb.append(", param_index = ");
418 sb.append(parameter_index);
419 break;
420 // type parameter bound
421 case CLASS_TYPE_PARAMETER_BOUND:
422 case METHOD_TYPE_PARAMETER_BOUND:
423 sb.append(", param_index = ");
424 sb.append(parameter_index);
425 sb.append(", bound_index = ");
426 sb.append(bound_index);
427 break;
428 // class extends or implements clause
429 case CLASS_EXTENDS:
430 sb.append(", type_index = ");
431 sb.append(type_index);
432 break;
433 // throws
434 case THROWS:
435 sb.append(", type_index = ");
436 sb.append(type_index);
437 break;
438 // exception parameter
439 case EXCEPTION_PARAMETER:
440 sb.append(", exception_index = ");
441 sb.append(exception_index);
442 break;
443 // method parameter
444 case METHOD_FORMAL_PARAMETER:
445 sb.append(", param_index = ");
446 sb.append(parameter_index);
447 break;
448 // type cast
449 case CAST:
450 // method/constructor/reference type argument
451 case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
452 case METHOD_INVOCATION_TYPE_ARGUMENT:
453 case CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
454 case METHOD_REFERENCE_TYPE_ARGUMENT:
455 sb.append(", offset = ");
456 sb.append(offset);
457 sb.append(", type_index = ");
458 sb.append(type_index);
459 break;
460 // We don't need to worry about these
461 case METHOD_RETURN:
462 case FIELD:
463 break;
464 case UNKNOWN:
465 sb.append(", position UNKNOWN!");
466 break;
467 default:
468 throw new AssertionError("Unknown target type: " + type);
469 }
470
471 // Append location data for generics/arrays.
472 if (!location.isEmpty()) {
473 sb.append(", location = (");
474 sb.append(location);
475 sb.append(")");
476 }
477
478 sb.append(", pos = ");
479 sb.append(pos);
480
481 sb.append(']');
482 return sb.toString();
483 }
484
485 /**
486 * Indicates whether the target tree of the annotation has been optimized
487 * away from classfile or not.
488 * @return true if the target has not been optimized away
489 */
490 public boolean emitToClassfile() {
491 return !type.isLocal() || isValidOffset;
492 }
493
494 /**
495 * Decode the binary representation for a type path and set
496 * the {@code location} field.
497 *
498 * @param list The bytecode representation of the type path.
499 */
500 public static List<TypePathEntry> getTypePathFromBinary(List<Integer> list) {
501 List<TypePathEntry> loc = new ArrayList<>(list.size() / TypePathEntry.bytesPerEntry);
502 int idx = 0;
503 while (idx < list.size()) {
504 if (idx + 1 == list.size()) {
505 throw new AssertionError("Could not decode type path: " + list);
506 }
507 loc.add(TypePathEntry.fromBinary(list.get(idx), list.get(idx + 1)));
508 idx += 2;
509 }
510 return loc;
511 }
512
513 public static List<Integer> getBinaryFromTypePath(List<TypePathEntry> locs) {
514 List<Integer> loc = new ArrayList<>(locs.size() * TypePathEntry.bytesPerEntry);
515 for (TypePathEntry tpe : locs) {
516 loc.add(tpe.tag.tag);
517 loc.add(tpe.arg);
518 }
519 return loc;
520 }
521 }
522
523 // Code duplicated from com.sun.tools.javac.code.TargetType
524 // The IsLocal flag could be removed here.
525 public enum TargetType {
526 /** For annotations on a class type parameter declaration. */
527 CLASS_TYPE_PARAMETER(0x00),
528
529 /** For annotations on a method type parameter declaration. */
530 METHOD_TYPE_PARAMETER(0x01),
531
532 /** For annotations on the type of an "extends" or "implements" clause. */
533 CLASS_EXTENDS(0x10),
534
535 /** For annotations on a bound of a type parameter of a class. */
536 CLASS_TYPE_PARAMETER_BOUND(0x11),
537
538 /** For annotations on a bound of a type parameter of a method. */
539 METHOD_TYPE_PARAMETER_BOUND(0x12),
540
541 /** For annotations on a field. */
542 FIELD(0x13),
543
544 /** For annotations on a method return type. */
545 METHOD_RETURN(0x14),
546
547 /** For annotations on the method receiver. */
548 METHOD_RECEIVER(0x15),
549
550 /** For annotations on a method parameter. */
551 METHOD_FORMAL_PARAMETER(0x16),
552
553 /** For annotations on a throws clause in a method declaration. */
554 THROWS(0x17),
555
556 /** For annotations on a local variable. */
557 LOCAL_VARIABLE(0x40, true),
558
559 /** For annotations on a resource variable. */
560 RESOURCE_VARIABLE(0x41, true),
561
562 /** For annotations on an exception parameter. */
563 EXCEPTION_PARAMETER(0x42, true),
564
565 /** For annotations on a type test. */
566 INSTANCEOF(0x43, true),
567
568 /** For annotations on an object creation expression. */
569 NEW(0x44, true),
570
571 /** For annotations on a constructor reference receiver. */
572 CONSTRUCTOR_REFERENCE(0x45, true),
573
574 /** For annotations on a method reference receiver. */
575 METHOD_REFERENCE(0x46, true),
576
577 /** For annotations on a typecast. */
578 CAST(0x47, true),
579
580 /** For annotations on a type argument of an object creation expression. */
581 CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT(0x48, true),
582
583 /** For annotations on a type argument of a method call. */
584 METHOD_INVOCATION_TYPE_ARGUMENT(0x49, true),
585
586 /** For annotations on a type argument of a constructor reference. */
587 CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT(0x4A, true),
588
589 /** For annotations on a type argument of a method reference. */
590 METHOD_REFERENCE_TYPE_ARGUMENT(0x4B, true),
591
592 /** For annotations with an unknown target. */
593 UNKNOWN(0xFF);
594
595 private static final int MAXIMUM_TARGET_TYPE_VALUE = 0x4B;
596
597 private final int targetTypeValue;
598 private final boolean isLocal;
599
600 private TargetType(int targetTypeValue) {
601 this(targetTypeValue, false);
602 }
603
604 private TargetType(int targetTypeValue, boolean isLocal) {
605 if (targetTypeValue < 0
606 || targetTypeValue > 255)
607 throw new AssertionError("Attribute type value needs to be an unsigned byte: " + String.format("0x%02X", targetTypeValue));
608 this.targetTypeValue = targetTypeValue;
609 this.isLocal = isLocal;
610 }
611
612 /**
613 * Returns whether or not this TargetType represents an annotation whose
614 * target is exclusively a tree in a method body
615 *
616 * Note: wildcard bound targets could target a local tree and a class
617 * member declaration signature tree
618 */
619 public boolean isLocal() {
620 return isLocal;
621 }
622
623 public int targetTypeValue() {
624 return this.targetTypeValue;
625 }
626
627 private static final TargetType[] targets;
628
629 static {
630 targets = new TargetType[MAXIMUM_TARGET_TYPE_VALUE + 1];
631 TargetType[] alltargets = values();
632 for (TargetType target : alltargets) {
633 if (target.targetTypeValue != UNKNOWN.targetTypeValue)
634 targets[target.targetTypeValue] = target;
635 }
636 for (int i = 0; i <= MAXIMUM_TARGET_TYPE_VALUE; ++i) {
637 if (targets[i] == null)
638 targets[i] = UNKNOWN;
639 }
640 }
641
642 public static boolean isValidTargetTypeValue(int tag) {
643 if (tag == UNKNOWN.targetTypeValue)
644 return true;
645 return (tag >= 0 && tag < targets.length);
646 }
647
648 public static TargetType fromTargetTypeValue(int tag) {
649 if (tag == UNKNOWN.targetTypeValue)
650 return UNKNOWN;
651
652 if (tag < 0 || tag >= targets.length)
653 throw new AssertionError("Unknown TargetType: " + tag);
654 return targets[tag];
655 }
656 }
657 }