43972
|
1 |
/*
|
58299
|
2 |
* Copyright (c) 2009, 2019, Oracle and/or its affiliates. All rights reserved.
|
43972
|
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.
|
|
8 |
*
|
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that
|
|
13 |
* accompanied this code).
|
|
14 |
*
|
|
15 |
* You should have received a copy of the GNU General Public License version
|
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
18 |
*
|
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
20 |
* or visit www.oracle.com if you need additional information or have any
|
|
21 |
* questions.
|
|
22 |
*/
|
50858
|
23 |
|
|
24 |
|
43972
|
25 |
package org.graalvm.compiler.code;
|
|
26 |
|
|
27 |
import static java.util.Collections.emptyList;
|
|
28 |
import static java.util.Collections.unmodifiableList;
|
|
29 |
import static jdk.vm.ci.meta.MetaUtil.identityHashCodeString;
|
|
30 |
|
|
31 |
import java.util.ArrayList;
|
|
32 |
import java.util.Arrays;
|
|
33 |
import java.util.Collection;
|
|
34 |
import java.util.Collections;
|
|
35 |
import java.util.List;
|
|
36 |
import java.util.Objects;
|
|
37 |
|
49873
|
38 |
import jdk.internal.vm.compiler.collections.EconomicSet;
|
47084
|
39 |
import org.graalvm.compiler.core.common.CompilationIdentifier;
|
43972
|
40 |
import org.graalvm.compiler.graph.NodeSourcePosition;
|
|
41 |
|
|
42 |
import jdk.vm.ci.code.DebugInfo;
|
|
43 |
import jdk.vm.ci.code.StackSlot;
|
|
44 |
import jdk.vm.ci.code.site.Call;
|
|
45 |
import jdk.vm.ci.code.site.ConstantReference;
|
|
46 |
import jdk.vm.ci.code.site.DataPatch;
|
|
47 |
import jdk.vm.ci.code.site.DataSectionReference;
|
|
48 |
import jdk.vm.ci.code.site.ExceptionHandler;
|
|
49 |
import jdk.vm.ci.code.site.Infopoint;
|
|
50 |
import jdk.vm.ci.code.site.InfopointReason;
|
|
51 |
import jdk.vm.ci.code.site.Mark;
|
|
52 |
import jdk.vm.ci.code.site.Reference;
|
|
53 |
import jdk.vm.ci.code.site.Site;
|
|
54 |
import jdk.vm.ci.meta.Assumptions.Assumption;
|
|
55 |
import jdk.vm.ci.meta.InvokeTarget;
|
|
56 |
import jdk.vm.ci.meta.ResolvedJavaField;
|
|
57 |
import jdk.vm.ci.meta.ResolvedJavaMethod;
|
54084
|
58 |
import jdk.vm.ci.meta.SpeculationLog;
|
43972
|
59 |
|
|
60 |
/**
|
|
61 |
* Represents the output from compiling a method, including the compiled machine code, associated
|
|
62 |
* data and references, relocation information, deoptimization information, etc.
|
|
63 |
*/
|
|
64 |
public class CompilationResult {
|
|
65 |
|
|
66 |
/**
|
|
67 |
* Provides extra information about instructions or data at specific positions in
|
|
68 |
* {@link CompilationResult#getTargetCode()}. This is optional information that can be used to
|
|
69 |
* enhance a disassembly of the code.
|
|
70 |
*/
|
|
71 |
public abstract static class CodeAnnotation {
|
|
72 |
|
|
73 |
public final int position;
|
|
74 |
|
|
75 |
public CodeAnnotation(int position) {
|
|
76 |
this.position = position;
|
|
77 |
}
|
|
78 |
|
|
79 |
@Override
|
|
80 |
public final int hashCode() {
|
|
81 |
throw new UnsupportedOperationException("hashCode");
|
|
82 |
}
|
|
83 |
|
|
84 |
@Override
|
|
85 |
public String toString() {
|
|
86 |
return identityHashCodeString(this);
|
|
87 |
}
|
|
88 |
|
|
89 |
@Override
|
|
90 |
public abstract boolean equals(Object obj);
|
|
91 |
}
|
|
92 |
|
|
93 |
/**
|
|
94 |
* A string comment about one or more instructions at a specific position in the code.
|
|
95 |
*/
|
|
96 |
public static final class CodeComment extends CodeAnnotation {
|
|
97 |
|
|
98 |
public final String value;
|
|
99 |
|
|
100 |
public CodeComment(int position, String comment) {
|
|
101 |
super(position);
|
|
102 |
this.value = comment;
|
|
103 |
}
|
|
104 |
|
|
105 |
@Override
|
|
106 |
public boolean equals(Object obj) {
|
|
107 |
if (this == obj) {
|
|
108 |
return true;
|
|
109 |
}
|
|
110 |
if (obj instanceof CodeComment) {
|
|
111 |
CodeComment that = (CodeComment) obj;
|
|
112 |
if (this.position == that.position && this.value.equals(that.value)) {
|
|
113 |
return true;
|
|
114 |
}
|
|
115 |
}
|
|
116 |
return false;
|
|
117 |
}
|
|
118 |
|
|
119 |
@Override
|
|
120 |
public String toString() {
|
|
121 |
return getClass().getSimpleName() + "@" + position + ": " + value;
|
|
122 |
}
|
|
123 |
}
|
|
124 |
|
|
125 |
/**
|
|
126 |
* Describes a table of signed offsets embedded in the code. The offsets are relative to the
|
|
127 |
* starting address of the table. This type of table maybe generated when translating a
|
|
128 |
* multi-way branch based on a key value from a dense value set (e.g. the {@code tableswitch}
|
|
129 |
* JVM instruction).
|
|
130 |
*
|
|
131 |
* The table is indexed by the contiguous range of integers from {@link #low} to {@link #high}
|
|
132 |
* inclusive.
|
|
133 |
*/
|
|
134 |
public static final class JumpTable extends CodeAnnotation {
|
|
135 |
|
|
136 |
/**
|
|
137 |
* The low value in the key range (inclusive).
|
|
138 |
*/
|
|
139 |
public final int low;
|
|
140 |
|
|
141 |
/**
|
|
142 |
* The high value in the key range (inclusive).
|
|
143 |
*/
|
|
144 |
public final int high;
|
|
145 |
|
|
146 |
/**
|
|
147 |
* The size (in bytes) of each table entry.
|
|
148 |
*/
|
|
149 |
public final int entrySize;
|
|
150 |
|
|
151 |
public JumpTable(int position, int low, int high, int entrySize) {
|
|
152 |
super(position);
|
|
153 |
this.low = low;
|
|
154 |
this.high = high;
|
|
155 |
this.entrySize = entrySize;
|
|
156 |
}
|
|
157 |
|
|
158 |
@Override
|
|
159 |
public boolean equals(Object obj) {
|
|
160 |
if (this == obj) {
|
|
161 |
return true;
|
|
162 |
}
|
|
163 |
if (obj instanceof JumpTable) {
|
|
164 |
JumpTable that = (JumpTable) obj;
|
|
165 |
if (this.position == that.position && this.entrySize == that.entrySize && this.low == that.low && this.high == that.high) {
|
|
166 |
return true;
|
|
167 |
}
|
|
168 |
}
|
|
169 |
return false;
|
|
170 |
}
|
|
171 |
|
|
172 |
@Override
|
|
173 |
public String toString() {
|
|
174 |
return getClass().getSimpleName() + "@" + position + ": [" + low + " .. " + high + "]";
|
|
175 |
}
|
|
176 |
}
|
|
177 |
|
|
178 |
private boolean closed;
|
|
179 |
|
|
180 |
private int entryBCI = -1;
|
|
181 |
|
|
182 |
private final DataSection dataSection = new DataSection();
|
|
183 |
|
|
184 |
private final List<Infopoint> infopoints = new ArrayList<>();
|
|
185 |
private final List<SourceMapping> sourceMapping = new ArrayList<>();
|
|
186 |
private final List<DataPatch> dataPatches = new ArrayList<>();
|
|
187 |
private final List<ExceptionHandler> exceptionHandlers = new ArrayList<>();
|
|
188 |
private final List<Mark> marks = new ArrayList<>();
|
|
189 |
|
|
190 |
private int totalFrameSize = -1;
|
|
191 |
private int maxInterpreterFrameSize = -1;
|
|
192 |
|
|
193 |
private StackSlot customStackArea = null;
|
|
194 |
|
52578
|
195 |
/**
|
|
196 |
* A customized name that is unrelated to {@link #compilationId}. Can be null if
|
|
197 |
* {@link #compilationId} fully describes the compilation.
|
|
198 |
*/
|
43972
|
199 |
private final String name;
|
|
200 |
|
47084
|
201 |
private final CompilationIdentifier compilationId;
|
|
202 |
|
43972
|
203 |
/**
|
|
204 |
* The buffer containing the emitted machine code.
|
|
205 |
*/
|
|
206 |
private byte[] targetCode;
|
|
207 |
|
|
208 |
/**
|
|
209 |
* The leading number of bytes in {@link #targetCode} containing the emitted machine code.
|
|
210 |
*/
|
|
211 |
private int targetCodeSize;
|
|
212 |
|
|
213 |
private ArrayList<CodeAnnotation> annotations;
|
|
214 |
|
|
215 |
private Assumption[] assumptions;
|
|
216 |
|
|
217 |
/**
|
|
218 |
* The list of the methods whose bytecodes were used as input to the compilation. If
|
|
219 |
* {@code null}, then the compilation did not record method dependencies. Otherwise, the first
|
|
220 |
* element of this array is the root method of the compilation.
|
|
221 |
*/
|
|
222 |
private ResolvedJavaMethod[] methods;
|
|
223 |
|
|
224 |
/**
|
54084
|
225 |
* The {@link SpeculationLog} log used during compilation.
|
|
226 |
*/
|
|
227 |
private SpeculationLog speculationLog;
|
|
228 |
|
|
229 |
/**
|
43972
|
230 |
* The list of fields that were accessed from the bytecodes.
|
|
231 |
*/
|
|
232 |
private ResolvedJavaField[] fields;
|
|
233 |
|
|
234 |
private int bytecodeSize;
|
|
235 |
|
|
236 |
private boolean hasUnsafeAccess;
|
|
237 |
|
|
238 |
private boolean isImmutablePIC;
|
|
239 |
|
47084
|
240 |
public CompilationResult(CompilationIdentifier compilationId) {
|
52578
|
241 |
this(compilationId, null, false);
|
47084
|
242 |
}
|
|
243 |
|
|
244 |
public CompilationResult(CompilationIdentifier compilationId, String name) {
|
|
245 |
this(compilationId, name, false);
|
|
246 |
}
|
|
247 |
|
|
248 |
public CompilationResult(CompilationIdentifier compilationId, boolean isImmutablePIC) {
|
|
249 |
this(compilationId, null, isImmutablePIC);
|
|
250 |
}
|
|
251 |
|
|
252 |
public CompilationResult(CompilationIdentifier compilationId, String name, boolean isImmutablePIC) {
|
|
253 |
this.compilationId = compilationId;
|
|
254 |
this.name = name;
|
|
255 |
this.isImmutablePIC = isImmutablePIC;
|
43972
|
256 |
}
|
|
257 |
|
|
258 |
public CompilationResult(String name) {
|
47084
|
259 |
this(null, name);
|
43972
|
260 |
}
|
|
261 |
|
|
262 |
@Override
|
|
263 |
public int hashCode() {
|
|
264 |
// CompilationResult instances should not be used as hash map keys
|
|
265 |
throw new UnsupportedOperationException("hashCode");
|
|
266 |
}
|
|
267 |
|
|
268 |
@Override
|
|
269 |
public String toString() {
|
|
270 |
if (methods != null) {
|
|
271 |
return getClass().getName() + "[" + methods[0].format("%H.%n(%p)%r") + "]";
|
|
272 |
}
|
|
273 |
return identityHashCodeString(this);
|
|
274 |
}
|
|
275 |
|
|
276 |
@Override
|
|
277 |
public boolean equals(Object obj) {
|
|
278 |
if (this == obj) {
|
|
279 |
return true;
|
|
280 |
}
|
|
281 |
if (obj != null && obj.getClass() == getClass()) {
|
|
282 |
CompilationResult that = (CompilationResult) obj;
|
|
283 |
// @formatter:off
|
|
284 |
if (this.entryBCI == that.entryBCI &&
|
|
285 |
Objects.equals(this.customStackArea, that.customStackArea) &&
|
|
286 |
this.totalFrameSize == that.totalFrameSize &&
|
|
287 |
this.targetCodeSize == that.targetCodeSize &&
|
|
288 |
Objects.equals(this.name, that.name) &&
|
47084
|
289 |
Objects.equals(this.compilationId, that.compilationId) &&
|
43972
|
290 |
Objects.equals(this.annotations, that.annotations) &&
|
|
291 |
Objects.equals(this.dataSection, that.dataSection) &&
|
|
292 |
Objects.equals(this.exceptionHandlers, that.exceptionHandlers) &&
|
|
293 |
Objects.equals(this.dataPatches, that.dataPatches) &&
|
|
294 |
Objects.equals(this.infopoints, that.infopoints) &&
|
|
295 |
Objects.equals(this.marks, that.marks) &&
|
|
296 |
Arrays.equals(this.assumptions, that.assumptions) &&
|
|
297 |
Arrays.equals(targetCode, that.targetCode)) {
|
|
298 |
return true;
|
|
299 |
}
|
|
300 |
// @formatter:on
|
|
301 |
}
|
|
302 |
return false;
|
|
303 |
}
|
|
304 |
|
|
305 |
/**
|
|
306 |
* @return the entryBCI
|
|
307 |
*/
|
|
308 |
public int getEntryBCI() {
|
|
309 |
return entryBCI;
|
|
310 |
}
|
|
311 |
|
|
312 |
/**
|
|
313 |
* @param entryBCI the entryBCI to set
|
|
314 |
*/
|
|
315 |
public void setEntryBCI(int entryBCI) {
|
|
316 |
checkOpen();
|
|
317 |
this.entryBCI = entryBCI;
|
|
318 |
}
|
|
319 |
|
|
320 |
/**
|
|
321 |
* Sets the assumptions made during compilation.
|
|
322 |
*/
|
|
323 |
public void setAssumptions(Assumption[] assumptions) {
|
|
324 |
this.assumptions = assumptions;
|
|
325 |
}
|
|
326 |
|
|
327 |
/**
|
|
328 |
* Gets the assumptions made during compilation.
|
|
329 |
*
|
|
330 |
* The caller must not modify the contents of the returned array.
|
|
331 |
*/
|
|
332 |
public Assumption[] getAssumptions() {
|
|
333 |
return assumptions;
|
|
334 |
}
|
|
335 |
|
|
336 |
/**
|
|
337 |
* Sets the methods whose bytecodes were used as input to the compilation.
|
|
338 |
*
|
|
339 |
* @param rootMethod the root method of the compilation
|
|
340 |
* @param inlinedMethods the methods inlined during compilation
|
|
341 |
*/
|
|
342 |
public void setMethods(ResolvedJavaMethod rootMethod, Collection<ResolvedJavaMethod> inlinedMethods) {
|
|
343 |
checkOpen();
|
|
344 |
assert rootMethod != null;
|
|
345 |
assert inlinedMethods != null;
|
|
346 |
if (inlinedMethods.contains(rootMethod)) {
|
|
347 |
methods = inlinedMethods.toArray(new ResolvedJavaMethod[inlinedMethods.size()]);
|
|
348 |
for (int i = 0; i < methods.length; i++) {
|
|
349 |
if (methods[i].equals(rootMethod)) {
|
|
350 |
if (i != 0) {
|
|
351 |
ResolvedJavaMethod tmp = methods[0];
|
|
352 |
methods[0] = methods[i];
|
|
353 |
methods[i] = tmp;
|
|
354 |
}
|
|
355 |
break;
|
|
356 |
}
|
|
357 |
}
|
|
358 |
} else {
|
|
359 |
methods = new ResolvedJavaMethod[1 + inlinedMethods.size()];
|
|
360 |
methods[0] = rootMethod;
|
|
361 |
int i = 1;
|
|
362 |
for (ResolvedJavaMethod m : inlinedMethods) {
|
|
363 |
methods[i++] = m;
|
|
364 |
}
|
|
365 |
}
|
|
366 |
}
|
|
367 |
|
|
368 |
/**
|
|
369 |
* Gets the methods whose bytecodes were used as input to the compilation.
|
|
370 |
*
|
|
371 |
* The caller must not modify the contents of the returned array.
|
|
372 |
*
|
|
373 |
* @return {@code null} if the compilation did not record method dependencies otherwise the
|
|
374 |
* methods whose bytecodes were used as input to the compilation with the first element
|
|
375 |
* being the root method of the compilation
|
|
376 |
*/
|
|
377 |
public ResolvedJavaMethod[] getMethods() {
|
|
378 |
return methods;
|
|
379 |
}
|
|
380 |
|
|
381 |
/**
|
54084
|
382 |
* Sets the {@link SpeculationLog} log used during compilation.
|
|
383 |
*/
|
|
384 |
public void setSpeculationLog(SpeculationLog speculationLog) {
|
|
385 |
checkOpen();
|
|
386 |
this.speculationLog = speculationLog;
|
|
387 |
}
|
|
388 |
|
|
389 |
/**
|
|
390 |
* Gets the {@link SpeculationLog} log, if any, used during compilation.
|
|
391 |
*/
|
|
392 |
public SpeculationLog getSpeculationLog() {
|
|
393 |
return speculationLog;
|
|
394 |
}
|
|
395 |
|
|
396 |
/**
|
43972
|
397 |
* Sets the fields that were referenced from the bytecodes that were used as input to the
|
|
398 |
* compilation.
|
|
399 |
*
|
|
400 |
* @param accessedFields the collected set of fields accessed during compilation
|
|
401 |
*/
|
46344
|
402 |
public void setFields(EconomicSet<ResolvedJavaField> accessedFields) {
|
|
403 |
if (accessedFields != null) {
|
|
404 |
fields = accessedFields.toArray(new ResolvedJavaField[accessedFields.size()]);
|
|
405 |
}
|
43972
|
406 |
}
|
|
407 |
|
|
408 |
/**
|
|
409 |
* Gets the fields that were referenced from bytecodes that were used as input to the
|
|
410 |
* compilation.
|
|
411 |
*
|
|
412 |
* The caller must not modify the contents of the returned array.
|
|
413 |
*
|
|
414 |
* @return {@code null} if the compilation did not record fields dependencies otherwise the
|
|
415 |
* fields that were accessed from bytecodes were used as input to the compilation.
|
|
416 |
*/
|
|
417 |
public ResolvedJavaField[] getFields() {
|
|
418 |
return fields;
|
|
419 |
}
|
|
420 |
|
|
421 |
public void setBytecodeSize(int bytecodeSize) {
|
|
422 |
checkOpen();
|
|
423 |
this.bytecodeSize = bytecodeSize;
|
|
424 |
}
|
|
425 |
|
|
426 |
public int getBytecodeSize() {
|
|
427 |
return bytecodeSize;
|
|
428 |
}
|
|
429 |
|
|
430 |
public DataSection getDataSection() {
|
|
431 |
return dataSection;
|
|
432 |
}
|
|
433 |
|
|
434 |
/**
|
|
435 |
* The total frame size of the method in bytes. This includes the return address pushed onto the
|
|
436 |
* stack, if any.
|
|
437 |
*
|
|
438 |
* @return the frame size
|
|
439 |
*/
|
|
440 |
public int getTotalFrameSize() {
|
|
441 |
assert totalFrameSize != -1 : "frame size not yet initialized!";
|
|
442 |
return totalFrameSize;
|
|
443 |
}
|
|
444 |
|
|
445 |
/**
|
|
446 |
* Sets the total frame size in bytes. This includes the return address pushed onto the stack,
|
|
447 |
* if any.
|
|
448 |
*
|
|
449 |
* @param size the size of the frame in bytes
|
|
450 |
*/
|
|
451 |
public void setTotalFrameSize(int size) {
|
|
452 |
checkOpen();
|
|
453 |
totalFrameSize = size;
|
|
454 |
}
|
|
455 |
|
|
456 |
public int getMaxInterpreterFrameSize() {
|
|
457 |
return maxInterpreterFrameSize;
|
|
458 |
}
|
|
459 |
|
|
460 |
public void setMaxInterpreterFrameSize(int maxInterpreterFrameSize) {
|
|
461 |
checkOpen();
|
|
462 |
this.maxInterpreterFrameSize = maxInterpreterFrameSize;
|
|
463 |
}
|
|
464 |
|
|
465 |
public boolean isImmutablePIC() {
|
|
466 |
return this.isImmutablePIC;
|
|
467 |
}
|
|
468 |
|
|
469 |
/**
|
|
470 |
* Sets the machine that has been generated by the compiler.
|
|
471 |
*
|
|
472 |
* @param code the machine code generated
|
|
473 |
* @param size the size of the machine code
|
|
474 |
*/
|
|
475 |
public void setTargetCode(byte[] code, int size) {
|
|
476 |
checkOpen();
|
|
477 |
targetCode = code;
|
|
478 |
targetCodeSize = size;
|
|
479 |
}
|
|
480 |
|
|
481 |
/**
|
|
482 |
* Records a data patch in the code section. The data patch can refer to something in the
|
|
483 |
* {@link DataSectionReference data section} or directly to an {@link ConstantReference inlined
|
|
484 |
* constant}.
|
|
485 |
*
|
|
486 |
* @param codePos the position in the code that needs to be patched
|
|
487 |
* @param ref the reference that should be inserted in the code
|
|
488 |
*/
|
|
489 |
public void recordDataPatch(int codePos, Reference ref) {
|
|
490 |
checkOpen();
|
|
491 |
assert codePos >= 0 && ref != null;
|
|
492 |
dataPatches.add(new DataPatch(codePos, ref));
|
|
493 |
}
|
|
494 |
|
|
495 |
/**
|
|
496 |
* Records a data patch in the code section. The data patch can refer to something in the
|
|
497 |
* {@link DataSectionReference data section} or directly to an {@link ConstantReference inlined
|
|
498 |
* constant}.
|
|
499 |
*
|
|
500 |
* @param codePos the position in the code that needs to be patched
|
|
501 |
* @param ref the reference that should be inserted in the code
|
|
502 |
* @param note a note attached to data patch for use by post-processing tools
|
|
503 |
*/
|
|
504 |
public void recordDataPatchWithNote(int codePos, Reference ref, Object note) {
|
|
505 |
assert codePos >= 0 && ref != null;
|
|
506 |
dataPatches.add(new DataPatch(codePos, ref, note));
|
|
507 |
}
|
|
508 |
|
|
509 |
/**
|
|
510 |
* Records a call in the code array.
|
|
511 |
*
|
|
512 |
* @param codePos the position of the call in the code array
|
|
513 |
* @param size the size of the call instruction
|
|
514 |
* @param target the being called
|
|
515 |
* @param debugInfo the debug info for the call
|
|
516 |
* @param direct specifies if this is a {@linkplain Call#direct direct} call
|
|
517 |
*/
|
|
518 |
public void recordCall(int codePos, int size, InvokeTarget target, DebugInfo debugInfo, boolean direct) {
|
|
519 |
checkOpen();
|
|
520 |
final Call call = new Call(target, codePos, size, direct, debugInfo);
|
|
521 |
addInfopoint(call);
|
|
522 |
}
|
|
523 |
|
|
524 |
/**
|
|
525 |
* Records an exception handler for this method.
|
|
526 |
*
|
|
527 |
* @param codePos the position in the code that is covered by the handler
|
|
528 |
* @param handlerPos the position of the handler
|
|
529 |
*/
|
|
530 |
public void recordExceptionHandler(int codePos, int handlerPos) {
|
|
531 |
checkOpen();
|
|
532 |
assert validateExceptionHandlerAdd(codePos, handlerPos) : String.format("Duplicate exception handler for pc 0x%x handlerPos 0x%x", codePos, handlerPos);
|
|
533 |
exceptionHandlers.add(new ExceptionHandler(codePos, handlerPos));
|
|
534 |
}
|
|
535 |
|
|
536 |
/**
|
|
537 |
* Validate if the exception handler for codePos already exists and handlerPos is different.
|
|
538 |
*
|
|
539 |
* @param codePos
|
|
540 |
* @param handlerPos
|
|
541 |
* @return true if the validation is successful
|
|
542 |
*/
|
|
543 |
private boolean validateExceptionHandlerAdd(int codePos, int handlerPos) {
|
|
544 |
ExceptionHandler exHandler = getExceptionHandlerForCodePos(codePos);
|
|
545 |
return exHandler == null || exHandler.handlerPos == handlerPos;
|
|
546 |
}
|
|
547 |
|
|
548 |
/**
|
|
549 |
* Returns the first ExceptionHandler which matches codePos.
|
|
550 |
*
|
|
551 |
* @param codePos position to search for
|
|
552 |
* @return first matching ExceptionHandler
|
|
553 |
*/
|
|
554 |
private ExceptionHandler getExceptionHandlerForCodePos(int codePos) {
|
|
555 |
for (ExceptionHandler h : exceptionHandlers) {
|
|
556 |
if (h.pcOffset == codePos) {
|
|
557 |
return h;
|
|
558 |
}
|
|
559 |
}
|
|
560 |
return null;
|
|
561 |
}
|
|
562 |
|
|
563 |
/**
|
|
564 |
* Records an infopoint in the code array.
|
|
565 |
*
|
|
566 |
* @param codePos the position of the infopoint in the code array
|
|
567 |
* @param debugInfo the debug info for the infopoint
|
|
568 |
*/
|
|
569 |
public void recordInfopoint(int codePos, DebugInfo debugInfo, InfopointReason reason) {
|
|
570 |
addInfopoint(new Infopoint(codePos, debugInfo, reason));
|
|
571 |
}
|
|
572 |
|
|
573 |
/**
|
|
574 |
* Records a custom infopoint in the code section.
|
|
575 |
*
|
|
576 |
* Compiler implementations can use this method to record non-standard infopoints, which are not
|
|
577 |
* handled by dedicated methods like {@link #recordCall}.
|
|
578 |
*
|
|
579 |
* @param infopoint the infopoint to record, usually a derived class from {@link Infopoint}
|
|
580 |
*/
|
|
581 |
public void addInfopoint(Infopoint infopoint) {
|
|
582 |
checkOpen();
|
|
583 |
infopoints.add(infopoint);
|
|
584 |
}
|
|
585 |
|
|
586 |
public void recordSourceMapping(int startOffset, int endOffset, NodeSourcePosition sourcePosition) {
|
|
587 |
checkOpen();
|
|
588 |
sourceMapping.add(new SourceMapping(startOffset, endOffset, sourcePosition));
|
|
589 |
}
|
|
590 |
|
|
591 |
/**
|
|
592 |
* Records an instruction mark within this method.
|
|
593 |
*
|
|
594 |
* @param codePos the position in the code that is covered by the handler
|
|
595 |
* @param markId the identifier for this mark
|
|
596 |
*/
|
|
597 |
public Mark recordMark(int codePos, Object markId) {
|
|
598 |
checkOpen();
|
|
599 |
Mark mark = new Mark(codePos, markId);
|
|
600 |
marks.add(mark);
|
|
601 |
return mark;
|
|
602 |
}
|
|
603 |
|
|
604 |
/**
|
|
605 |
* Start of the custom stack area.
|
|
606 |
*
|
|
607 |
* @return the first stack slot of the custom stack area
|
|
608 |
*/
|
|
609 |
public StackSlot getCustomStackArea() {
|
|
610 |
return customStackArea;
|
|
611 |
}
|
|
612 |
|
|
613 |
/**
|
|
614 |
* @see #getCustomStackArea()
|
|
615 |
* @param slot
|
|
616 |
*/
|
|
617 |
public void setCustomStackAreaOffset(StackSlot slot) {
|
|
618 |
checkOpen();
|
|
619 |
customStackArea = slot;
|
|
620 |
}
|
|
621 |
|
|
622 |
/**
|
|
623 |
* @return the machine code generated for this method
|
|
624 |
*/
|
|
625 |
public byte[] getTargetCode() {
|
|
626 |
return targetCode;
|
|
627 |
}
|
|
628 |
|
|
629 |
/**
|
|
630 |
* @return the size of the machine code generated for this method
|
|
631 |
*/
|
|
632 |
public int getTargetCodeSize() {
|
|
633 |
return targetCodeSize;
|
|
634 |
}
|
|
635 |
|
|
636 |
/**
|
|
637 |
* @return the code annotations or {@code null} if there are none
|
|
638 |
*/
|
54084
|
639 |
public List<CodeAnnotation> getCodeAnnotations() {
|
43972
|
640 |
if (annotations == null) {
|
|
641 |
return Collections.emptyList();
|
|
642 |
}
|
|
643 |
return annotations;
|
|
644 |
}
|
|
645 |
|
|
646 |
public void addAnnotation(CodeAnnotation annotation) {
|
|
647 |
checkOpen();
|
|
648 |
assert annotation != null;
|
|
649 |
if (annotations == null) {
|
|
650 |
annotations = new ArrayList<>();
|
|
651 |
}
|
|
652 |
annotations.add(annotation);
|
|
653 |
}
|
|
654 |
|
|
655 |
/**
|
|
656 |
* @return the list of infopoints, sorted by {@link Site#pcOffset}
|
|
657 |
*/
|
|
658 |
public List<Infopoint> getInfopoints() {
|
|
659 |
if (infopoints.isEmpty()) {
|
|
660 |
return emptyList();
|
|
661 |
}
|
|
662 |
return unmodifiableList(infopoints);
|
|
663 |
}
|
|
664 |
|
|
665 |
/**
|
|
666 |
* @return the list of data references
|
|
667 |
*/
|
|
668 |
public List<DataPatch> getDataPatches() {
|
|
669 |
if (dataPatches.isEmpty()) {
|
|
670 |
return emptyList();
|
|
671 |
}
|
|
672 |
return unmodifiableList(dataPatches);
|
|
673 |
}
|
|
674 |
|
|
675 |
/**
|
|
676 |
* @return the list of exception handlers
|
|
677 |
*/
|
|
678 |
public List<ExceptionHandler> getExceptionHandlers() {
|
|
679 |
if (exceptionHandlers.isEmpty()) {
|
|
680 |
return emptyList();
|
|
681 |
}
|
|
682 |
return unmodifiableList(exceptionHandlers);
|
|
683 |
}
|
|
684 |
|
|
685 |
/**
|
|
686 |
* @return the list of marks
|
|
687 |
*/
|
|
688 |
public List<Mark> getMarks() {
|
|
689 |
if (marks.isEmpty()) {
|
|
690 |
return emptyList();
|
|
691 |
}
|
|
692 |
return unmodifiableList(marks);
|
|
693 |
}
|
|
694 |
|
|
695 |
/**
|
|
696 |
* @return the list of {@link SourceMapping}s
|
|
697 |
*/
|
|
698 |
public List<SourceMapping> getSourceMappings() {
|
|
699 |
if (sourceMapping.isEmpty()) {
|
|
700 |
return emptyList();
|
|
701 |
}
|
|
702 |
return unmodifiableList(sourceMapping);
|
|
703 |
}
|
|
704 |
|
52578
|
705 |
/**
|
|
706 |
* Gets the name for this compilation result. This will only be non-null when it provides a
|
|
707 |
* value unrelated to {@link #getCompilationId()}.
|
|
708 |
*/
|
43972
|
709 |
public String getName() {
|
|
710 |
return name;
|
|
711 |
}
|
|
712 |
|
47084
|
713 |
public CompilationIdentifier getCompilationId() {
|
|
714 |
return compilationId;
|
|
715 |
}
|
|
716 |
|
43972
|
717 |
public void setHasUnsafeAccess(boolean hasUnsafeAccess) {
|
|
718 |
checkOpen();
|
|
719 |
this.hasUnsafeAccess = hasUnsafeAccess;
|
|
720 |
}
|
|
721 |
|
|
722 |
public boolean hasUnsafeAccess() {
|
|
723 |
return hasUnsafeAccess;
|
|
724 |
}
|
|
725 |
|
|
726 |
/**
|
|
727 |
* Clears the information in this object pertaining to generating code. That is, the
|
|
728 |
* {@linkplain #getMarks() marks}, {@linkplain #getInfopoints() infopoints},
|
|
729 |
* {@linkplain #getExceptionHandlers() exception handlers}, {@linkplain #getDataPatches() data
|
54084
|
730 |
* patches} and {@linkplain #getCodeAnnotations() annotations} recorded in this object are
|
|
731 |
* cleared.
|
43972
|
732 |
*/
|
|
733 |
public void resetForEmittingCode() {
|
|
734 |
checkOpen();
|
|
735 |
infopoints.clear();
|
|
736 |
sourceMapping.clear();
|
|
737 |
dataPatches.clear();
|
|
738 |
exceptionHandlers.clear();
|
|
739 |
marks.clear();
|
|
740 |
dataSection.clear();
|
|
741 |
if (annotations != null) {
|
|
742 |
annotations.clear();
|
|
743 |
}
|
|
744 |
}
|
|
745 |
|
54084
|
746 |
public void clearInfopoints() {
|
|
747 |
infopoints.clear();
|
|
748 |
}
|
|
749 |
|
|
750 |
public void clearExceptionHandlers() {
|
|
751 |
exceptionHandlers.clear();
|
|
752 |
}
|
|
753 |
|
43972
|
754 |
private void checkOpen() {
|
|
755 |
if (closed) {
|
|
756 |
throw new IllegalStateException();
|
|
757 |
}
|
|
758 |
}
|
|
759 |
|
|
760 |
/**
|
|
761 |
* Closes this compilation result to future updates.
|
|
762 |
*/
|
|
763 |
public void close() {
|
|
764 |
if (closed) {
|
|
765 |
throw new IllegalStateException("Cannot re-close compilation result " + this);
|
|
766 |
}
|
|
767 |
dataSection.close();
|
|
768 |
closed = true;
|
|
769 |
}
|
|
770 |
}
|