1 /*
2 * Copyright (c) 2022, 2024, 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 jdk.internal.classfile.impl;
27
28 import java.lang.classfile.*;
29 import java.lang.classfile.attribute.*;
30 import java.lang.classfile.constantpool.ClassEntry;
31 import java.lang.classfile.constantpool.ConstantPool;
32 import java.lang.classfile.constantpool.ConstantValueEntry;
33 import java.lang.classfile.constantpool.LoadableConstantEntry;
34 import java.lang.classfile.constantpool.ModuleEntry;
35 import java.lang.classfile.constantpool.NameAndTypeEntry;
36 import java.lang.classfile.constantpool.PackageEntry;
37 import java.lang.classfile.constantpool.PoolEntry;
38 import java.lang.classfile.constantpool.Utf8Entry;
39 import java.util.ArrayList;
40 import java.util.Collections;
41 import java.util.List;
42 import java.util.Objects;
43 import java.util.Optional;
44 import java.util.function.Function;
45
46 import jdk.internal.access.SharedSecrets;
47
48 import static java.lang.classfile.Attributes.*;
49
50 public abstract sealed class BoundAttribute<T extends Attribute<T>>
51 extends AbstractElement
52 implements Attribute<T>, Util.Writable {
53
54 static final int NAME_AND_LENGTH_PREFIX = 6;
55 private final AttributeMapper<T> mapper;
56 final ClassReaderImpl classReader;
57 final int payloadStart;
58
59 BoundAttribute(ClassReader classReader, AttributeMapper<T> mapper, int payloadStart) {
60 this.mapper = mapper;
61 this.classReader = (ClassReaderImpl)classReader;
62 this.payloadStart = payloadStart;
63 }
64
65 public int payloadLen() {
66 return classReader.readInt(payloadStart - 4);
67 }
68
69 @Override
70 public String attributeName() {
71 return mapper.name();
72 }
73
74 @Override
75 public AttributeMapper<T> attributeMapper() {
76 return mapper;
77 }
78
79 public byte[] contents() {
80 return classReader.readBytes(payloadStart, payloadLen());
81 }
82
83 @Override
84 public void writeTo(DirectClassBuilder builder) {
85 builder.writeAttribute(this);
86 }
87
88 @Override
89 public void writeTo(DirectCodeBuilder builder) {
90 builder.writeAttribute(this);
91 }
92
93 @Override
94 public void writeTo(DirectMethodBuilder builder) {
95 builder.writeAttribute(this);
96 }
97
98 @Override
99 public void writeTo(DirectFieldBuilder builder) {
100 builder.writeAttribute(this);
101 }
102
103 @Override
104 @SuppressWarnings("unchecked")
105 public void writeTo(BufWriterImpl buf) {
106 if (!buf.canWriteDirect(classReader))
107 attributeMapper().writeAttribute(buf, (T) this);
108 else
109 classReader.copyBytesTo(buf, payloadStart - NAME_AND_LENGTH_PREFIX, payloadLen() + NAME_AND_LENGTH_PREFIX);
110 }
111
112 public ConstantPool constantPool() {
113 return classReader;
114 }
115
116 @Override
117 public String toString() {
118 return String.format("Attribute[name=%s]", mapper.name());
119 }
120
121 <E extends PoolEntry> List<E> readEntryList(int p, Class<E> type) {
122 int cnt = classReader.readU2(p);
123 p += 2;
124 var entries = new Object[cnt];
125 int end = p + (cnt * 2);
126 for (int i = 0; p < end; i++, p += 2) {
127 entries[i] = classReader.readEntry(p, type);
128 }
129 return SharedSecrets.getJavaUtilCollectionAccess().listFromTrustedArray(entries);
130 }
131
132 public static List<Attribute<?>> readAttributes(AttributedElement enclosing, ClassReader reader, int pos,
133 Function<Utf8Entry, AttributeMapper<?>> customAttributes) {
134 int size = reader.readU2(pos);
135 var filled = new ArrayList<Attribute<?>>(size);
136 int p = pos + 2;
137 int cfLen = reader.classfileLength();
138 for (int i = 0; i < size; ++i) {
139 Utf8Entry name = reader.readEntry(p, Utf8Entry.class);
140 int len = reader.readInt(p + 2);
141 p += 6;
142 if (len < 0 || len > cfLen - p) {
143 throw new IllegalArgumentException("attribute " + name.stringValue() + " too big to handle");
144 }
145
146 var mapper = standardAttribute(name);
147 if (mapper == null) {
148 mapper = customAttributes.apply(name);
149 }
150 if (mapper != null) {
151 filled.add(Objects.requireNonNull(mapper.readAttribute(enclosing, reader, p)));
152 } else {
153 AttributeMapper<UnknownAttribute> fakeMapper = new AttributeMapper<>() {
154 @Override
155 public String name() {
156 return name.stringValue();
157 }
158
159 @Override
160 public UnknownAttribute readAttribute(AttributedElement enclosing, ClassReader cf, int pos) {
161 // Will never get called
162 throw new UnsupportedOperationException();
163 }
164
165 @Override
166 public void writeAttribute(BufWriter buf, UnknownAttribute attr) {
167 buf.writeIndex(name);
168 var cont = attr.contents();
169 buf.writeInt(cont.length);
170 buf.writeBytes(cont);
171 }
172
173 @Override
174 public boolean allowMultiple() {
175 return true;
176 }
177
178 @Override
179 public AttributeMapper.AttributeStability stability() {
180 return AttributeStability.UNKNOWN;
181 }
182 };
183 filled.add(new BoundUnknownAttribute(reader, fakeMapper, p));
184 }
185 p += len;
186 }
187 return Collections.unmodifiableList(filled);
188 }
189
190 public static final class BoundUnknownAttribute extends BoundAttribute<UnknownAttribute>
191 implements UnknownAttribute {
192 public BoundUnknownAttribute(ClassReader cf, AttributeMapper<UnknownAttribute> mapper, int pos) {
193 super(cf, mapper, pos);
194 }
195 }
196
197 public static final class BoundStackMapTableAttribute
198 extends BoundAttribute<StackMapTableAttribute>
199 implements StackMapTableAttribute {
200 final MethodModel method;
201 final LabelContext ctx;
202 List<StackMapFrameInfo> entries = null;
203
204 public BoundStackMapTableAttribute(CodeImpl code, ClassReader cf, AttributeMapper<StackMapTableAttribute> mapper, int pos) {
205 super(cf, mapper, pos);
206 method = code.parent().orElseThrow();
207 ctx = code;
208 }
209
210 @Override
211 public List<StackMapFrameInfo> entries() {
212 if (entries == null) {
213 entries = new StackMapDecoder(classReader, payloadStart, ctx, StackMapDecoder.initFrameLocals(method)).entries();
214 }
215 return entries;
216 }
217 }
218
219 public static final class BoundSyntheticAttribute extends BoundAttribute<SyntheticAttribute>
220 implements SyntheticAttribute {
221 public BoundSyntheticAttribute(ClassReader cf, AttributeMapper<SyntheticAttribute> mapper, int pos) {
222 super(cf, mapper, pos);
223 }
224 }
225
226 public static final class BoundLineNumberTableAttribute
227 extends BoundAttribute<LineNumberTableAttribute>
228 implements LineNumberTableAttribute {
229 private List<LineNumberInfo> lineNumbers = null;
230
231 public BoundLineNumberTableAttribute(ClassReader cf, AttributeMapper<LineNumberTableAttribute> mapper, int pos) {
232 super(cf, mapper, pos);
233 }
234
235 @Override
236 public List<LineNumberInfo> lineNumbers() {
237 if (lineNumbers == null) {
238 int nLn = classReader.readU2(payloadStart);
239 LineNumberInfo[] elements = new LineNumberInfo[nLn];
240 int p = payloadStart + 2;
241 int pEnd = p + (nLn * 4);
242 for (int i = 0; p < pEnd; p += 4, i++) {
243 int startPc = classReader.readU2(p);
244 int lineNumber = classReader.readU2(p + 2);
245 elements[i] = LineNumberInfo.of(startPc, lineNumber);
246 }
247 lineNumbers = List.of(elements);
248 }
249 return lineNumbers;
250 }
251 }
252
253 public static final class BoundCharacterRangeTableAttribute extends BoundAttribute<CharacterRangeTableAttribute> implements CharacterRangeTableAttribute {
254 private List<CharacterRangeInfo> characterRangeTable = null;
255
256 public BoundCharacterRangeTableAttribute(ClassReader cf, AttributeMapper<CharacterRangeTableAttribute> mapper, int pos) {
257 super(cf, mapper, pos);
258 }
259
260 @Override
261 public List<CharacterRangeInfo> characterRangeTable() {
262 if (characterRangeTable == null) {
263 int nLn = classReader.readU2(payloadStart);
264 CharacterRangeInfo[] elements = new CharacterRangeInfo[nLn];
265 int p = payloadStart + 2;
266 int pEnd = p + (nLn * 14);
267 for (int i = 0; p < pEnd; p += 14, i++) {
268 int startPc = classReader.readU2(p);
269 int endPc = classReader.readU2(p + 2);
270 int characterRangeStart = classReader.readInt(p + 4);
271 int characterRangeEnd = classReader.readInt(p + 8);
272 int flags = classReader.readU2(p + 12);
273 elements[i] = CharacterRangeInfo.of(startPc, endPc, characterRangeStart, characterRangeEnd, flags);
274 }
275 characterRangeTable = List.of(elements);
276 }
277 return characterRangeTable;
278 }
279 }
280
281 public static final class BoundLocalVariableTableAttribute
282 extends BoundAttribute<LocalVariableTableAttribute>
283 implements LocalVariableTableAttribute {
284 private final CodeImpl codeAttribute;
285 private List<LocalVariableInfo> localVars = null;
286
287 public BoundLocalVariableTableAttribute(AttributedElement enclosing, ClassReader cf, AttributeMapper<LocalVariableTableAttribute> mapper, int pos) {
288 super(cf, mapper, pos);
289 if (enclosing instanceof CodeImpl ci) {
290 this.codeAttribute = ci;
291 } else {
292 throw new IllegalArgumentException("Invalid LocalVariableTable attribute location");
293 }
294 }
295
296 @Override
297 public List<LocalVariableInfo> localVariables() {
298 if (localVars == null) {
299 int cnt = classReader.readU2(payloadStart);
300 BoundLocalVariable[] elements = new BoundLocalVariable[cnt];
301 int p = payloadStart + 2;
302 int pEnd = p + (cnt * 10);
303 for (int i = 0; p < pEnd; p += 10, i++) {
304 elements[i] = new BoundLocalVariable(codeAttribute, p);
305 }
306 localVars = List.of(elements);
307 }
308 return localVars;
309 }
310 }
311
312 public static final class BoundLocalVariableTypeTableAttribute
313 extends BoundAttribute<LocalVariableTypeTableAttribute>
314 implements LocalVariableTypeTableAttribute {
315 private final CodeImpl codeAttribute;
316 private List<LocalVariableTypeInfo> localVars = null;
317
318 public BoundLocalVariableTypeTableAttribute(AttributedElement enclosing, ClassReader cf, AttributeMapper<LocalVariableTypeTableAttribute> mapper, int pos) {
319 super(cf, mapper, pos);
320 if (enclosing instanceof CodeImpl ci) {
321 this.codeAttribute = ci;
322 } else {
323 throw new IllegalArgumentException("Invalid LocalVariableTypeTable attribute location");
324 }
325 }
326
327 @Override
328 public List<LocalVariableTypeInfo> localVariableTypes() {
329 if (localVars == null) {
330 final int cnt = classReader.readU2(payloadStart);
331 BoundLocalVariableType[] elements = new BoundLocalVariableType[cnt];
332 int p = payloadStart + 2;
333 int pEnd = p + (cnt * 10);
334 for (int i = 0; p < pEnd; p += 10, i++) {
335 elements[i] = new BoundLocalVariableType(codeAttribute, p);
336 }
337 localVars = List.of(elements);
338 }
339 return localVars;
340 }
341 }
342
343 public static final class BoundMethodParametersAttribute extends BoundAttribute<MethodParametersAttribute>
344 implements MethodParametersAttribute {
345 private List<MethodParameterInfo> parameters = null;
346
347 public BoundMethodParametersAttribute(ClassReader cf, AttributeMapper<MethodParametersAttribute> mapper, int pos) {
348 super(cf, mapper, pos);
349 }
350
351 @Override
352 public List<MethodParameterInfo> parameters() {
353 if (parameters == null) {
354 final int cnt = classReader.readU1(payloadStart);
355 MethodParameterInfo[] elements = new MethodParameterInfo[cnt];
356 int p = payloadStart + 1;
357 int pEnd = p + (cnt * 4);
358 for (int i = 0; p < pEnd; p += 4, i++) {
359 Utf8Entry name = classReader.readEntryOrNull(p, Utf8Entry.class);
360 int accessFlags = classReader.readU2(p + 2);
361 elements[i] = MethodParameterInfo.of(Optional.ofNullable(name), accessFlags);
362 }
363 parameters = List.of(elements);
364 }
365 return parameters;
366 }
367 }
368
369 public static final class BoundModuleHashesAttribute extends BoundAttribute<ModuleHashesAttribute>
370 implements ModuleHashesAttribute {
371 private List<ModuleHashInfo> hashes = null;
372
373 public BoundModuleHashesAttribute(ClassReader cf, AttributeMapper<ModuleHashesAttribute> mapper, int pos) {
374 super(cf, mapper, pos);
375 }
376
377 @Override
378 public Utf8Entry algorithm() {
379 return classReader.readEntry(payloadStart, Utf8Entry.class);
380 }
381
382 @Override
383 public List<ModuleHashInfo> hashes() {
384 if (hashes == null) {
385 final int cnt = classReader.readU2(payloadStart + 2);
386 ModuleHashInfo[] elements = new ModuleHashInfo[cnt];
387 int p = payloadStart + 4;
388 //System.err.printf("%5d: ModuleHashesAttr alg = %s, cnt = %d%n", pos, algorithm(), cnt);
389 for (int i = 0; i < cnt; ++i) {
390 ModuleEntry module = classReader.readEntry(p, ModuleEntry.class);
391 int hashLength = classReader.readU2(p + 2);
392 //System.err.printf("%5d: [%d] module = %s, hashLength = %d%n", p, i, module, hashLength);
393 p += 4;
394 elements[i] = ModuleHashInfo.of(module, classReader.readBytes(p, hashLength));
395 p += hashLength;
396 }
397 hashes = List.of(elements);
398 }
399 return hashes;
400 }
401 }
402
403 public static final class BoundRecordAttribute extends BoundAttribute<RecordAttribute>
404 implements RecordAttribute {
405 private List<RecordComponentInfo> components = null;
406
407 public BoundRecordAttribute(ClassReader cf, AttributeMapper<RecordAttribute> mapper, int pos) {
408 super(cf, mapper, pos);
409 }
410
411 @Override
412 public List<RecordComponentInfo> components() {
413 if (components == null) {
414 final int cnt = classReader.readU2(payloadStart);
415 RecordComponentInfo[] elements = new RecordComponentInfo[cnt];
416 int p = payloadStart + 2;
417 for (int i = 0; i < cnt; i++) {
418 elements[i] = new BoundRecordComponentInfo(classReader, p);
419 p = classReader.skipAttributeHolder(p + 4);
420 }
421 components = List.of(elements);
422 }
423 return components;
424 }
425 }
426
427 public static final class BoundDeprecatedAttribute extends BoundAttribute<DeprecatedAttribute>
428 implements DeprecatedAttribute {
429 public BoundDeprecatedAttribute(ClassReader cf, AttributeMapper<DeprecatedAttribute> mapper, int pos) {
430 super(cf, mapper, pos);
431 }
432 }
433
434 public static final class BoundSignatureAttribute extends BoundAttribute<SignatureAttribute>
435 implements SignatureAttribute {
436 public BoundSignatureAttribute(ClassReader cf, AttributeMapper<SignatureAttribute> mapper, int pos) {
437 super(cf, mapper, pos);
438 }
439
440 @Override
441 public Utf8Entry signature() {
442 return classReader.readEntry(payloadStart, Utf8Entry.class);
443 }
444 }
445
446 public static final class BoundSourceFileAttribute extends BoundAttribute<SourceFileAttribute>
447 implements SourceFileAttribute {
448 public BoundSourceFileAttribute(ClassReader cf, AttributeMapper<SourceFileAttribute> mapper, int pos) {
449 super(cf, mapper, pos);
450 }
451
452 @Override
453 public Utf8Entry sourceFile() {
454 return classReader.readEntry(payloadStart, Utf8Entry.class);
455 }
456
457 }
458
459 public static final class BoundModuleMainClassAttribute extends BoundAttribute<ModuleMainClassAttribute> implements ModuleMainClassAttribute {
460 public BoundModuleMainClassAttribute(ClassReader cf, AttributeMapper<ModuleMainClassAttribute> mapper, int pos) {
461 super(cf, mapper, pos);
462 }
463
464 @Override
465 public ClassEntry mainClass() {
466 return classReader.readEntry(payloadStart, ClassEntry.class);
467 }
468 }
469
470 public static final class BoundNestHostAttribute extends BoundAttribute<NestHostAttribute>
471 implements NestHostAttribute {
472 public BoundNestHostAttribute(ClassReader cf, AttributeMapper<NestHostAttribute> mapper, int pos) {
473 super(cf, mapper, pos);
474 }
475
476 @Override
477 public ClassEntry nestHost() {
478 return classReader.readEntry(payloadStart, ClassEntry.class);
479 }
480 }
481
482 public static final class BoundSourceDebugExtensionAttribute extends BoundAttribute<SourceDebugExtensionAttribute>
483 implements SourceDebugExtensionAttribute {
484 public BoundSourceDebugExtensionAttribute(ClassReader cf, AttributeMapper<SourceDebugExtensionAttribute> mapper, int pos) {
485 super(cf, mapper, pos);
486 }
487 }
488
489 public static final class BoundConstantValueAttribute extends BoundAttribute<ConstantValueAttribute>
490 implements ConstantValueAttribute {
491 public BoundConstantValueAttribute(ClassReader cf, AttributeMapper<ConstantValueAttribute> mapper, int pos) {
492 super(cf, mapper, pos);
493 }
494
495 @Override
496 public ConstantValueEntry constant() {
497 return classReader.readEntry(payloadStart, ConstantValueEntry.class);
498 }
499
500 }
501
502 public static final class BoundModuleTargetAttribute extends BoundAttribute<ModuleTargetAttribute>
503 implements ModuleTargetAttribute {
504 public BoundModuleTargetAttribute(ClassReader cf, AttributeMapper<ModuleTargetAttribute> mapper, int pos) {
505 super(cf, mapper, pos);
506 }
507
508 @Override
509 public Utf8Entry targetPlatform() {
510 return classReader.readEntry(payloadStart, Utf8Entry.class);
511 }
512 }
513
514 public static final class BoundCompilationIDAttribute extends BoundAttribute<CompilationIDAttribute>
515 implements CompilationIDAttribute {
516 public BoundCompilationIDAttribute(ClassReader cf, AttributeMapper<CompilationIDAttribute> mapper, int pos) {
517 super(cf, mapper, pos);
518 }
519
520 @Override
521 public Utf8Entry compilationId() {
522 return classReader.readEntry(payloadStart, Utf8Entry.class);
523 }
524 }
525
526 public static final class BoundSourceIDAttribute extends BoundAttribute<SourceIDAttribute>
527 implements SourceIDAttribute {
528 public BoundSourceIDAttribute(ClassReader cf, AttributeMapper<SourceIDAttribute> mapper, int pos) {
529 super(cf, mapper, pos);
530 }
531
532 @Override
533 public Utf8Entry sourceId() {
534 return classReader.readEntry(payloadStart, Utf8Entry.class);
535 }
536 }
537
538 public static final class BoundModuleResolutionAttribute extends BoundAttribute<ModuleResolutionAttribute>
539 implements ModuleResolutionAttribute {
540 public BoundModuleResolutionAttribute(ClassReader cf, AttributeMapper<ModuleResolutionAttribute> mapper, int pos) {
541 super(cf, mapper, pos);
542 }
543
544 @Override
545 public int resolutionFlags() {
546 return classReader.readU2(payloadStart);
547 }
548 }
549
550 public static final class BoundExceptionsAttribute extends BoundAttribute<ExceptionsAttribute>
551 implements ExceptionsAttribute {
552 private List<ClassEntry> exceptions = null;
553
554 public BoundExceptionsAttribute(ClassReader cf, AttributeMapper<ExceptionsAttribute> mapper, int pos) {
555 super(cf, mapper, pos);
556 }
557
558 @Override
559 public List<ClassEntry> exceptions() {
560 if (exceptions == null) {
561 exceptions = readEntryList(payloadStart, ClassEntry.class);
562 }
563 return exceptions;
564 }
565 }
566
567 public static final class BoundModuleAttribute extends BoundAttribute<ModuleAttribute>
568 implements ModuleAttribute {
569 private List<ModuleRequireInfo> requires = null;
570 private List<ModuleExportInfo> exports = null;
571 private List<ModuleOpenInfo> opens = null;
572 private List<ClassEntry> uses = null;
573 private List<ModuleProvideInfo> provides = null;
574
575 public BoundModuleAttribute(ClassReader cf, AttributeMapper<ModuleAttribute> mapper, int pos) {
576 super(cf, mapper, pos);
577 }
578
579 @Override
580 public ModuleEntry moduleName() {
581 return classReader.readEntry(payloadStart, ModuleEntry.class);
582 }
583
584 @Override
585 public int moduleFlagsMask() {
586 return classReader.readU2(payloadStart + 2);
587 }
588
589 @Override
590 public Optional<Utf8Entry> moduleVersion() {
591 return Optional.ofNullable(classReader.readEntryOrNull(payloadStart + 4, Utf8Entry.class));
592 }
593
594 @Override
595 public List<ModuleRequireInfo> requires() {
596 if (requires == null) {
597 structure();
598 }
599 return requires;
600 }
601
602 @Override
603 public List<ModuleExportInfo> exports() {
604 if (exports == null) {
605 structure();
606 }
607 return exports;
608 }
609
610 @Override
611 public List<ModuleOpenInfo> opens() {
612 if (opens == null) {
613 structure();
614 }
615 return opens;
616 }
617
618 @Override
619 public List<ClassEntry> uses() {
620 if (uses == null) {
621 structure();
622 }
623 return uses;
624 }
625
626 @Override
627 public List<ModuleProvideInfo> provides() {
628 if (provides == null) {
629 structure();
630 }
631 return provides;
632 }
633
634 private void structure() {
635 int p = payloadStart + 8;
636
637 {
638 int cnt = classReader.readU2(payloadStart + 6);
639 ModuleRequireInfo[] elements = new ModuleRequireInfo[cnt];
640 int end = p + (cnt * 6);
641 for (int i = 0; p < end; p += 6, i++) {
642 elements[i] = ModuleRequireInfo.of(classReader.readEntry(p, ModuleEntry.class),
643 classReader.readU2(p + 2),
644 classReader.readEntryOrNull(p + 4, Utf8Entry.class));
645 }
646 requires = List.of(elements);
647 }
648
649 {
650 int cnt = classReader.readU2(p);
651 p += 2;
652 ModuleExportInfo[] elements = new ModuleExportInfo[cnt];
653 for (int i = 0; i < cnt; i++) {
654 PackageEntry pe = classReader.readEntry(p, PackageEntry.class);
655 int exportFlags = classReader.readU2(p + 2);
656 p += 4;
657 List<ModuleEntry> exportsTo = readEntryList(p, ModuleEntry.class);
658 p += 2 + exportsTo.size() * 2;
659 elements[i] = ModuleExportInfo.of(pe, exportFlags, exportsTo);
660 }
661 exports = List.of(elements);
662 }
663
664 {
665 int cnt = classReader.readU2(p);
666 p += 2;
667 ModuleOpenInfo[] elements = new ModuleOpenInfo[cnt];
668 for (int i = 0; i < cnt; i++) {
669 PackageEntry po = classReader.readEntry(p, PackageEntry.class);
670 int opensFlags = classReader.readU2(p + 2);
671 p += 4;
672 List<ModuleEntry> opensTo = readEntryList(p, ModuleEntry.class);
673 p += 2 + opensTo.size() * 2;
674 elements[i] = ModuleOpenInfo.of(po, opensFlags, opensTo);
675 }
676 opens = List.of(elements);
677 }
678
679 {
680 uses = readEntryList(p, ClassEntry.class);
681 p += 2 + uses.size() * 2;
682 int cnt = classReader.readU2(p);
683 p += 2;
684 ModuleProvideInfo[] elements = new ModuleProvideInfo[cnt];
685 provides = new ArrayList<>(cnt);
686 for (int i = 0; i < cnt; i++) {
687 ClassEntry c = classReader.readEntry(p, ClassEntry.class);
688 p += 2;
689 List<ClassEntry> providesWith = readEntryList(p, ClassEntry.class);
690 p += 2 + providesWith.size() * 2;
691 elements[i] = ModuleProvideInfo.of(c, providesWith);
692 }
693 provides = List.of(elements);
694 }
695 }
696 }
697
698 public static final class BoundModulePackagesAttribute extends BoundAttribute<ModulePackagesAttribute>
699 implements ModulePackagesAttribute {
700 private List<PackageEntry> packages = null;
701
702 public BoundModulePackagesAttribute(ClassReader cf, AttributeMapper<ModulePackagesAttribute> mapper, int pos) {
703 super(cf, mapper, pos);
704 }
705
706 @Override
707 public List<PackageEntry> packages() {
708 if (packages == null) {
709 packages = readEntryList(payloadStart, PackageEntry.class);
710 }
711 return packages;
712 }
713 }
714
715 public static final class BoundNestMembersAttribute extends BoundAttribute<NestMembersAttribute>
716 implements NestMembersAttribute {
717
718 private List<ClassEntry> members = null;
719
720 public BoundNestMembersAttribute(ClassReader cf, AttributeMapper<NestMembersAttribute> mapper, int pos) {
721 super(cf, mapper, pos);
722 }
723
724 @Override
725 public List<ClassEntry> nestMembers() {
726 if (members == null) {
727 members = readEntryList(payloadStart, ClassEntry.class);
728 }
729 return members;
730 }
731 }
732
733 public static final class BoundBootstrapMethodsAttribute extends BoundAttribute<BootstrapMethodsAttribute>
734 implements BootstrapMethodsAttribute {
735
736 private List<BootstrapMethodEntry> bootstraps = null;
737 private final int size;
738
739 public BoundBootstrapMethodsAttribute(ClassReader reader, AttributeMapper<BootstrapMethodsAttribute> mapper, int pos) {
740 super(reader, mapper, pos);
741 size = classReader.readU2(pos);
742 }
743
744 @Override
745 public int bootstrapMethodsSize() {
746 return size;
747 }
748
749 @Override
750 public List<BootstrapMethodEntry> bootstrapMethods() {
751 if (bootstraps == null) {
752 BootstrapMethodEntry[] bs = new BootstrapMethodEntry[size];
753 int p = payloadStart + 2;
754 for (int i = 0; i < size; ++i) {
755 final var handle = classReader.readEntry(p, AbstractPoolEntry.MethodHandleEntryImpl.class);
756 final List<LoadableConstantEntry> args = readEntryList(p + 2, LoadableConstantEntry.class);
757 p += 4 + args.size() * 2;
758 int hash = BootstrapMethodEntryImpl.computeHashCode(handle, args);
759 bs[i] = new BootstrapMethodEntryImpl(classReader, i, hash, handle, args);
760 }
761 bootstraps = List.of(bs);
762 }
763 return bootstraps;
764 }
765 }
766
767 public static final class BoundInnerClassesAttribute extends BoundAttribute<InnerClassesAttribute>
768 implements InnerClassesAttribute {
769 private List<InnerClassInfo> classes;
770
771 public BoundInnerClassesAttribute(ClassReader cf, AttributeMapper<InnerClassesAttribute> mapper, int pos) {
772 super(cf, mapper, pos);
773 }
774
775 @Override
776 public List<InnerClassInfo> classes() {
777 if (classes == null) {
778 final int cnt = classReader.readU2(payloadStart);
779 int p = payloadStart + 2;
780 InnerClassInfo[] elements = new InnerClassInfo[cnt];
781 for (int i = 0; i < cnt; i++) {
782 ClassEntry innerClass = classReader.readEntry(p, ClassEntry.class);
783 var outerClass = classReader.readEntryOrNull(p + 2, ClassEntry.class);
784 var innerName = classReader.readEntryOrNull(p + 4, Utf8Entry.class);
785 int flags = classReader.readU2(p + 6);
786 p += 8;
787 elements[i] = InnerClassInfo.of(innerClass, Optional.ofNullable(outerClass), Optional.ofNullable(innerName), flags);
788 }
789 classes = List.of(elements);
790 }
791 return classes;
792 }
793 }
794
795 public static final class BoundEnclosingMethodAttribute extends BoundAttribute<EnclosingMethodAttribute>
796 implements EnclosingMethodAttribute {
797 public BoundEnclosingMethodAttribute(ClassReader cf, AttributeMapper<EnclosingMethodAttribute> mapper, int pos) {
798 super(cf, mapper, pos);
799 }
800
801 @Override
802 public ClassEntry enclosingClass() {
803 return classReader.readEntry(payloadStart, ClassEntry.class);
804 }
805
806 @Override
807 public Optional<NameAndTypeEntry> enclosingMethod() {
808 return Optional.ofNullable(classReader.readEntryOrNull(payloadStart + 2, NameAndTypeEntry.class));
809 }
810 }
811
812 public static final class BoundAnnotationDefaultAttr
813 extends BoundAttribute<AnnotationDefaultAttribute>
814 implements AnnotationDefaultAttribute {
815 private AnnotationValue annotationValue;
816
817 public BoundAnnotationDefaultAttr(ClassReader cf, AttributeMapper<AnnotationDefaultAttribute> mapper, int pos) {
818 super(cf, mapper, pos);
819 }
820
821 @Override
822 public AnnotationValue defaultValue() {
823 if (annotationValue == null)
824 annotationValue = AnnotationReader.readElementValue(classReader, payloadStart);
825 return annotationValue;
826 }
827 }
828
829 public static final class BoundRuntimeVisibleTypeAnnotationsAttribute extends BoundAttribute<RuntimeVisibleTypeAnnotationsAttribute>
830 implements RuntimeVisibleTypeAnnotationsAttribute {
831
832 private final LabelContext labelContext;
833
834 public BoundRuntimeVisibleTypeAnnotationsAttribute(AttributedElement enclosing, ClassReader cf, AttributeMapper<RuntimeVisibleTypeAnnotationsAttribute> mapper, int pos) {
835 super(cf, mapper, pos);
836 this.labelContext = (enclosing instanceof LabelContext lc) ? lc : null;
837 }
838
839 @Override
840 public List<TypeAnnotation> annotations() {
841 return AnnotationReader.readTypeAnnotations(classReader, payloadStart, labelContext);
842 }
843 }
844
845 public static final class BoundRuntimeInvisibleTypeAnnotationsAttribute
846 extends BoundAttribute<RuntimeInvisibleTypeAnnotationsAttribute>
847 implements RuntimeInvisibleTypeAnnotationsAttribute {
848 public BoundRuntimeInvisibleTypeAnnotationsAttribute(AttributedElement enclosing, ClassReader cf, AttributeMapper<RuntimeInvisibleTypeAnnotationsAttribute> mapper, int pos) {
849 super(cf, mapper, pos);
850 this.labelContext = (enclosing instanceof LabelContext lc) ? lc : null;
851 }
852
853 private final LabelContext labelContext;
854
855 @Override
856 public List<TypeAnnotation> annotations() {
857 return AnnotationReader.readTypeAnnotations(classReader, payloadStart, labelContext);
858 }
859 }
860
861 public static final class BoundRuntimeVisibleParameterAnnotationsAttribute
862 extends BoundAttribute<RuntimeVisibleParameterAnnotationsAttribute>
863 implements RuntimeVisibleParameterAnnotationsAttribute {
864
865 public BoundRuntimeVisibleParameterAnnotationsAttribute(ClassReader cf, AttributeMapper<RuntimeVisibleParameterAnnotationsAttribute> mapper, int pos) {
866 super(cf, mapper, pos);
867 }
868
869 @Override
870 public List<List<Annotation>> parameterAnnotations() {
871 return AnnotationReader.readParameterAnnotations(classReader, payloadStart);
872 }
873 }
874
875 public static final class BoundRuntimeInvisibleParameterAnnotationsAttribute
876 extends BoundAttribute<RuntimeInvisibleParameterAnnotationsAttribute>
877 implements RuntimeInvisibleParameterAnnotationsAttribute {
878
879 public BoundRuntimeInvisibleParameterAnnotationsAttribute(ClassReader cf, AttributeMapper<RuntimeInvisibleParameterAnnotationsAttribute> mapper, int pos) {
880 super(cf, mapper, pos);
881 }
882
883 @Override
884 public List<List<Annotation>> parameterAnnotations() {
885 return AnnotationReader.readParameterAnnotations(classReader, payloadStart);
886 }
887 }
888
889 public static final class BoundRuntimeInvisibleAnnotationsAttribute
890 extends BoundAttribute<RuntimeInvisibleAnnotationsAttribute>
891 implements RuntimeInvisibleAnnotationsAttribute {
892 private List<Annotation> inflated;
893
894 public BoundRuntimeInvisibleAnnotationsAttribute(ClassReader cf,
895 int payloadStart) {
896 super(cf, Attributes.runtimeInvisibleAnnotations(), payloadStart);
897 }
898
899 @Override
900 public List<Annotation> annotations() {
901 if (inflated == null)
902 inflated = AnnotationReader.readAnnotations(classReader, payloadStart);
903 return inflated;
904 }
905 }
906
907 public static final class BoundRuntimeVisibleAnnotationsAttribute
908 extends BoundAttribute<RuntimeVisibleAnnotationsAttribute>
909 implements RuntimeVisibleAnnotationsAttribute {
910 private List<Annotation> inflated;
911
912 public BoundRuntimeVisibleAnnotationsAttribute(ClassReader cf,
913 int payloadStart) {
914 super(cf, Attributes.runtimeVisibleAnnotations(), payloadStart);
915 }
916
917 @Override
918 public List<Annotation> annotations() {
919 if (inflated == null)
920 inflated = AnnotationReader.readAnnotations(classReader, payloadStart);
921 return inflated;
922 }
923 }
924
925 public static final class BoundPermittedSubclassesAttribute extends BoundAttribute<PermittedSubclassesAttribute>
926 implements PermittedSubclassesAttribute {
927 private List<ClassEntry> permittedSubclasses = null;
928
929 public BoundPermittedSubclassesAttribute(ClassReader cf, AttributeMapper<PermittedSubclassesAttribute> mapper, int pos) {
930 super(cf, mapper, pos);
931 }
932
933 @Override
934 public List<ClassEntry> permittedSubclasses() {
935 if (permittedSubclasses == null) {
936 permittedSubclasses = readEntryList(payloadStart, ClassEntry.class);
937 }
938 return permittedSubclasses;
939 }
940 }
941
942 public static final class BoundLoadableDescriptorsAttribute extends BoundAttribute<LoadableDescriptorsAttribute>
943 implements LoadableDescriptorsAttribute {
944 private List<Utf8Entry> loadableDescriptors = null;
945
946 public BoundLoadableDescriptorsAttribute(ClassReader cf, AttributeMapper<LoadableDescriptorsAttribute> mapper, int pos) {
947 super(cf, mapper, pos);
948 }
949
950 @Override
951 public List<Utf8Entry> loadableDescriptors() {
952 if (loadableDescriptors == null) {
953 loadableDescriptors = readEntryList(payloadStart, Utf8Entry.class);
954 }
955 return loadableDescriptors;
956 }
957 }
958
959 public abstract static sealed class BoundCodeAttribute
960 extends BoundAttribute<CodeAttribute>
961 implements CodeAttribute
962 permits CodeImpl {
963 protected final int codeStart;
964 protected final int codeLength;
965 protected final int codeEnd;
966 protected final int attributePos;
967 protected final int exceptionHandlerPos;
968 protected final int exceptionHandlerCnt;
969 protected final MethodModel enclosingMethod;
970
971 public BoundCodeAttribute(AttributedElement enclosing,
972 ClassReader reader,
973 AttributeMapper<CodeAttribute> mapper,
974 int payloadStart) {
975 super(reader, mapper, payloadStart);
976 this.codeLength = classReader.readInt(payloadStart + 4);
977 this.enclosingMethod = (MethodModel) enclosing;
978 this.codeStart = payloadStart + 8;
979 this.codeEnd = codeStart + codeLength;
980 this.exceptionHandlerPos = codeEnd;
981 this.exceptionHandlerCnt = classReader.readU2(exceptionHandlerPos);
982 this.attributePos = exceptionHandlerPos + 2 + exceptionHandlerCnt * 8;
983 }
984
985 // CodeAttribute
986
987 @Override
988 public int maxStack() {
989 return classReader.readU2(payloadStart);
990 }
991
992 @Override
993 public int maxLocals() {
994 return classReader.readU2(payloadStart + 2);
995 }
996
997 @Override
998 public int codeLength() {
999 return codeLength;
1000 }
1001
1002 @Override
1003 public byte[] codeArray() {
1004 return classReader.readBytes(payloadStart + 8, codeLength());
1005 }
1006 }
1007
1008 /**
1009 * {@return the attribute mapper for a standard attribute}
1010 *
1011 * @param name the name of the attribute to find
1012 */
1013 public static AttributeMapper<?> standardAttribute(Utf8Entry name) {
1014 // critical bootstrap path, so no lambdas nor method handles here
1015 return switch (name.hashCode()) {
1016 case 0x46699ff2 ->
1017 name.equalsString(NAME_ANNOTATION_DEFAULT) ? annotationDefault() : null;
1018 case 0x5208e184 ->
1019 name.equalsString(NAME_BOOTSTRAP_METHODS) ? bootstrapMethods() : null;
1020 case 0xcb60907a ->
1021 name.equalsString(NAME_CHARACTER_RANGE_TABLE) ? characterRangeTable() : null;
1022 case 0x4020220d ->
1023 name.equalsString(NAME_CODE) ? code() : null;
1024 case 0xc20dd1fe ->
1025 name.equalsString(NAME_COMPILATION_ID) ? compilationId() : null;
1026 case 0xcab1940d ->
1027 name.equalsString(NAME_CONSTANT_VALUE) ? constantValue() : null;
1028 case 0x558641d3 ->
1029 name.equalsString(NAME_DEPRECATED) ? deprecated() : null;
1030 case 0x51d443cd ->
1031 name.equalsString(NAME_ENCLOSING_METHOD) ? enclosingMethod() : null;
1032 case 0x687c1624 ->
1033 name.equalsString(NAME_EXCEPTIONS) ? exceptions() : null;
1034 case 0x7adb2910 ->
1035 name.equalsString(NAME_INNER_CLASSES) ? innerClasses() : null;
1036 case 0x653f0551 ->
1037 name.equalsString(NAME_LINE_NUMBER_TABLE) ? lineNumberTable() : null;
1038 case 0x5f348b64 ->
1039 name.equalsString(NAME_LOADABLE_DESCRIPTORS) ? loadableDescriptors() : null;
1040 case 0x64c75927 ->
1041 name.equalsString(NAME_LOCAL_VARIABLE_TABLE) ? localVariableTable() : null;
1042 case 0x6697f98d ->
1043 name.equalsString(NAME_LOCAL_VARIABLE_TYPE_TABLE) ? localVariableTypeTable() : null;
1044 case 0xdbb0cdcb ->
1045 name.equalsString(NAME_METHOD_PARAMETERS) ? methodParameters() : null;
1046 case 0xc9b0928c ->
1047 name.equalsString(NAME_MODULE) ? module() : null;
1048 case 0x41cd27e8 ->
1049 name.equalsString(NAME_MODULE_HASHES) ? moduleHashes() : null;
1050 case 0x7deb0a13 ->
1051 name.equalsString(NAME_MODULE_MAIN_CLASS) ? moduleMainClass() : null;
1052 case 0x6706ff99 ->
1053 name.equalsString(NAME_MODULE_PACKAGES) ? modulePackages() : null;
1054 case 0x60272858 ->
1055 name.equalsString(NAME_MODULE_RESOLUTION) ? moduleResolution() : null;
1056 case 0x5646d73d ->
1057 name.equalsString(NAME_MODULE_TARGET) ? moduleTarget() : null;
1058 case 0x50336c40 ->
1059 name.equalsString(NAME_NEST_HOST) ? nestHost() : null;
1060 case 0x4735ab81 ->
1061 name.equalsString(NAME_NEST_MEMBERS) ? nestMembers() : null;
1062 case 0x7100d9fe ->
1063 name.equalsString(NAME_PERMITTED_SUBCLASSES) ? permittedSubclasses() : null;
1064 case 0xd1ab5871 ->
1065 name.equalsString(NAME_RECORD) ? record() : null;
1066 case 0x7588550f ->
1067 name.equalsString(NAME_RUNTIME_INVISIBLE_ANNOTATIONS) ? runtimeInvisibleAnnotations() : null;
1068 case 0xcc74da30 ->
1069 name.equalsString(NAME_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS) ? runtimeInvisibleParameterAnnotations() : null;
1070 case 0xf67697f5 ->
1071 name.equalsString(NAME_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS) ? runtimeInvisibleTypeAnnotations() : null;
1072 case 0xe0837d2a ->
1073 name.equalsString(NAME_RUNTIME_VISIBLE_ANNOTATIONS) ? runtimeVisibleAnnotations() : null;
1074 case 0xc945a075 ->
1075 name.equalsString(NAME_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS) ? runtimeVisibleParameterAnnotations() : null;
1076 case 0x611a3a90 ->
1077 name.equalsString(NAME_RUNTIME_VISIBLE_TYPE_ANNOTATIONS) ? runtimeVisibleTypeAnnotations() : null;
1078 case 0xf76fb898 ->
1079 name.equalsString(NAME_SIGNATURE) ? signature() : null;
1080 case 0x6b41b047 ->
1081 name.equalsString(NAME_SOURCE_DEBUG_EXTENSION) ? sourceDebugExtension() : null;
1082 case 0x748c2857 ->
1083 name.equalsString(NAME_SOURCE_FILE) ? sourceFile() : null;
1084 case 0x6bf13a96 ->
1085 name.equalsString(NAME_SOURCE_ID) ? sourceId() : null;
1086 case 0xfa85ee5a ->
1087 name.equalsString(NAME_STACK_MAP_TABLE) ? stackMapTable() : null;
1088 case 0xf2670725 ->
1089 name.equalsString(NAME_SYNTHETIC) ? synthetic() : null;
1090 default -> null;
1091 };
1092 }
1093 }