1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 package org.apache.bcel.classfile;
18
19 import java.io.DataInput;
20 import java.io.DataOutputStream;
21 import java.io.IOException;
22 import java.util.Arrays;
23
24 import org.apache.bcel.Const;
25 import org.apache.bcel.util.Args;
26 import org.apache.commons.lang3.ArrayUtils;
27
28 /**
29 * This class represents a chunk of Java byte code contained in a method. It is instantiated by the
30 * <em>Attribute.readAttribute()</em> method. A <em>Code</em> attribute contains informations about operand stack, local
31 * variables, byte code and the exceptions handled within this method.
32 *
33 * This attribute has attributes itself, namely <em>LineNumberTable</em> which is used for debugging purposes and
34 * <em>LocalVariableTable</em> which contains information about the local variables.
35 *
36 * <pre>
37 * Code_attribute {
38 * u2 attribute_name_index;
39 * u4 attribute_length;
40 * u2 max_stack;
41 * u2 max_locals;
42 * u4 code_length;
43 * u1 code[code_length];
44 * u2 exception_table_length;
45 * {
46 * u2 start_pc;
47 * u2 end_pc;
48 * u2 handler_pc;
49 * u2 catch_type;
50 * } exception_table[exception_table_length];
51 * u2 attributes_count;
52 * attribute_info attributes[attributes_count];
53 * }
54 * </pre>
55 * @see Attribute
56 * @see CodeException
57 * @see LineNumberTable
58 * @see LocalVariableTable
59 */
60 public final class Code extends Attribute {
61
62 private int maxStack; // Maximum size of stack used by this method // TODO this could be made final (setter is not used)
63 private int maxLocals; // Number of local variables // TODO this could be made final (setter is not used)
64 private byte[] code; // Actual byte code
65 private CodeException[] exceptionTable; // Table of handled exceptions
66 private Attribute[] attributes; // or LocalVariable
67
68 /**
69 * Initialize from another object. Note that both objects use the same references (shallow copy). Use copy() for a
70 * physical copy.
71 *
72 * @param code The source Code.
73 */
74 public Code(final Code code) {
75 this(code.getNameIndex(), code.getLength(), code.getMaxStack(), code.getMaxLocals(), code.getCode(), code.getExceptionTable(), code.getAttributes(),
76 code.getConstantPool());
77 }
78
79 /**
80 * @param nameIndex Index pointing to the name <em>Code</em>
81 * @param length Content length in bytes
82 * @param file Input stream
83 * @param constantPool Array of constants
84 */
85 Code(final int nameIndex, final int length, final DataInput file, final ConstantPool constantPool) throws IOException {
86 // Initialize with some default values which will be overwritten later
87 this(nameIndex, length, file.readUnsignedShort(), file.readUnsignedShort(), (byte[]) null, (CodeException[]) null, (Attribute[]) null, constantPool);
88 final int codeLength = Args.requireU4(file.readInt(), 1, "Code length attribute");
89 code = new byte[codeLength]; // Read byte code
90 file.readFully(code);
91 /*
92 * Read exception table that contains all regions where an exception handler is active, i.e., a try { ... } catch ()
93 * block.
94 */
95 final int exceptionTableLength = file.readUnsignedShort();
96 exceptionTable = new CodeException[exceptionTableLength];
97 for (int i = 0; i < exceptionTableLength; i++) {
98 exceptionTable[i] = new CodeException(file);
99 }
100 /*
101 * Read all attributes, currently 'LineNumberTable' and 'LocalVariableTable'
102 */
103 final int attributesCount = file.readUnsignedShort();
104 attributes = new Attribute[attributesCount];
105 for (int i = 0; i < attributesCount; i++) {
106 attributes[i] = readAttribute(file, constantPool);
107 }
108 /*
109 * Adjust length, because of setAttributes in this(), s.b. length is incorrect, because it didn't take the internal
110 * attributes into account yet! Very subtle bug, fixed in 3.1.1.
111 */
112 super.setLength(length);
113 }
114
115 /**
116 * @param nameIndex Index pointing to the name <em>Code</em>
117 * @param length Content length in bytes
118 * @param maxStack Maximum size of stack
119 * @param maxLocals Number of local variables
120 * @param code Actual byte code
121 * @param exceptionTable of handled exceptions
122 * @param attributes Attributes of code: LineNumber or LocalVariable
123 * @param constantPool Array of constants
124 */
125 public Code(final int nameIndex, final int length, final int maxStack, final int maxLocals, final byte[] code, final CodeException[] exceptionTable,
126 final Attribute[] attributes, final ConstantPool constantPool) {
127 super(Const.ATTR_CODE, nameIndex, length, constantPool);
128 this.maxStack = Args.requireU2(maxStack, "maxStack");
129 this.maxLocals = Args.requireU2(maxLocals, "maxLocals");
130 this.code = ArrayUtils.nullToEmpty(code);
131 this.exceptionTable = ArrayUtils.nullToEmpty(exceptionTable, CodeException[].class);
132 Args.requireU2(this.exceptionTable.length, "exceptionTable.length");
133 this.attributes = attributes != null ? attributes : EMPTY_ARRAY;
134 super.setLength(calculateLength()); // Adjust length
135 }
136
137 /**
138 * Called by objects that are traversing the nodes of the tree implicitly defined by the contents of a Java class.
139 * I.e., the hierarchy of methods, fields, attributes, etc. spawns a tree of objects.
140 *
141 * @param v Visitor object
142 */
143 @Override
144 public void accept(final Visitor v) {
145 v.visitCode(this);
146 }
147
148 /**
149 * @return the full size of this code attribute, minus its first 6 bytes, including the size of all its contained
150 * attributes
151 */
152 private int calculateLength() {
153 int len = 0;
154 if (attributes != null) {
155 for (final Attribute attribute : attributes) {
156 len += attribute.getLength() + 6 /* attribute header size */;
157 }
158 }
159 return len + getInternalLength();
160 }
161
162 /**
163 * @return deep copy of this attribute
164 *
165 * @param constantPool the constant pool to duplicate
166 */
167 @Override
168 public Attribute copy(final ConstantPool constantPool) {
169 final Code c = (Code) clone();
170 if (code != null) {
171 c.code = code.clone();
172 }
173 c.setConstantPool(constantPool);
174 c.exceptionTable = new CodeException[exceptionTable.length];
175 Arrays.setAll(c.exceptionTable, i -> exceptionTable[i].copy());
176 c.attributes = new Attribute[attributes.length];
177 Arrays.setAll(c.attributes, i -> attributes[i].copy(constantPool));
178 return c;
179 }
180
181 /**
182 * Dump code attribute to file stream in binary format.
183 *
184 * @param file Output file stream
185 * @throws IOException if an I/O error occurs.
186 */
187 @Override
188 public void dump(final DataOutputStream file) throws IOException {
189 super.dump(file);
190 file.writeShort(maxStack);
191 file.writeShort(maxLocals);
192 file.writeInt(code.length);
193 file.write(code, 0, code.length);
194 file.writeShort(exceptionTable.length);
195 for (final CodeException exception : exceptionTable) {
196 exception.dump(file);
197 }
198 file.writeShort(attributes.length);
199 for (final Attribute attribute : attributes) {
200 attribute.dump(file);
201 }
202 }
203
204 /**
205 * @return Collection of code attributes.
206 * @see Attribute
207 */
208 public Attribute[] getAttributes() {
209 return attributes;
210 }
211
212 /**
213 * @return Actual byte code of the method.
214 */
215 public byte[] getCode() {
216 return code;
217 }
218
219 /**
220 * @return Table of handled exceptions.
221 * @see CodeException
222 */
223 public CodeException[] getExceptionTable() {
224 return exceptionTable;
225 }
226
227 /**
228 * @return the internal length of this code attribute (minus the first 6 bytes) and excluding all its attributes
229 */
230 private int getInternalLength() {
231 return 2 /* maxStack */ + 2 /* maxLocals */ + 4 /* code length */
232 + code.length /* byte-code */
233 + 2 /* exception-table length */
234 + 8 * (exceptionTable == null ? 0 : exceptionTable.length) /* exception table */
235 + 2 /* attributes count */;
236 }
237
238 /**
239 * @return LineNumberTable of Code, if it has one
240 */
241 public LineNumberTable getLineNumberTable() {
242 for (final Attribute attribute : attributes) {
243 if (attribute instanceof LineNumberTable) {
244 return (LineNumberTable) attribute;
245 }
246 }
247 return null;
248 }
249
250 /**
251 * @return LocalVariableTable of Code, if it has one
252 */
253 public LocalVariableTable getLocalVariableTable() {
254 for (final Attribute attribute : attributes) {
255 if (attribute instanceof LocalVariableTable) {
256 return (LocalVariableTable) attribute;
257 }
258 }
259 return null;
260 }
261
262 /**
263 * Gets the local variable type table attribute {@link LocalVariableTypeTable}.
264 * @return LocalVariableTypeTable of Code, if it has one, null otherwise.
265 * @since 6.10.0
266 */
267 public LocalVariableTypeTable getLocalVariableTypeTable() {
268 for (final Attribute attribute : attributes) {
269 if (attribute instanceof LocalVariableTypeTable) {
270 return (LocalVariableTypeTable) attribute;
271 }
272 }
273 return null;
274 }
275
276 /**
277 * @return Number of local variables.
278 */
279 public int getMaxLocals() {
280 return maxLocals;
281 }
282
283 /**
284 * @return Maximum size of stack used by this method.
285 */
286 public int getMaxStack() {
287 return maxStack;
288 }
289
290 /**
291 * Finds the attribute of {@link StackMap} instance.
292 * @return StackMap of Code, if it has one, else null.
293 * @since 6.8.0
294 */
295 public StackMap getStackMap() {
296 for (final Attribute attribute : attributes) {
297 if (attribute instanceof StackMap) {
298 return (StackMap) attribute;
299 }
300 }
301 return null;
302 }
303
304 /**
305 * @param attributes the attributes to set for this Code
306 */
307 public void setAttributes(final Attribute[] attributes) {
308 this.attributes = attributes != null ? attributes : EMPTY_ARRAY;
309 super.setLength(calculateLength()); // Adjust length
310 }
311
312 /**
313 * @param code byte code
314 */
315 public void setCode(final byte[] code) {
316 this.code = ArrayUtils.nullToEmpty(code);
317 super.setLength(calculateLength()); // Adjust length
318 }
319
320 /**
321 * @param exceptionTable exception table
322 */
323 public void setExceptionTable(final CodeException[] exceptionTable) {
324 this.exceptionTable = exceptionTable != null ? exceptionTable : CodeException.EMPTY_ARRAY;
325 super.setLength(calculateLength()); // Adjust length
326 }
327
328 /**
329 * @param maxLocals maximum number of local variables
330 */
331 public void setMaxLocals(final int maxLocals) {
332 this.maxLocals = maxLocals;
333 }
334
335 /**
336 * @param maxStack maximum stack size
337 */
338 public void setMaxStack(final int maxStack) {
339 this.maxStack = maxStack;
340 }
341
342 /**
343 * @return String representation of code chunk.
344 */
345 @Override
346 public String toString() {
347 return toString(true);
348 }
349
350 /**
351 * Converts this object to a String.
352 *
353 * @param verbose Provides verbose output when true.
354 * @return String representation of code chunk.
355 */
356 public String toString(final boolean verbose) {
357 final StringBuilder buf = new StringBuilder(100); // CHECKSTYLE IGNORE MagicNumber
358 buf.append("Code(maxStack = ").append(maxStack).append(", maxLocals = ").append(maxLocals).append(", code_length = ").append(code.length).append(")\n")
359 .append(Utility.codeToString(code, super.getConstantPool(), 0, -1, verbose));
360 if (exceptionTable.length > 0) {
361 buf.append("\nException handler(s) = \n").append("From\tTo\tHandler\tType\n");
362 for (final CodeException exception : exceptionTable) {
363 buf.append(exception.toString(super.getConstantPool(), verbose)).append("\n");
364 }
365 }
366 if (attributes.length > 0) {
367 buf.append("\nAttribute(s) = ");
368 for (final Attribute attribute : attributes) {
369 buf.append("\n").append(attribute.getName()).append(":");
370 buf.append("\n").append(attribute);
371 }
372 }
373 return buf.toString();
374 }
375 }