Mercurial > hg > graal-compiler
comparison graal/com.oracle.max.cri/src/com/sun/cri/xir/CiXirAssembler.java @ 3733:e233f5660da4
Added Java files from Maxine project.
author | Thomas Wuerthinger <thomas.wuerthinger@oracle.com> |
---|---|
date | Sat, 17 Dec 2011 19:59:18 +0100 |
parents | |
children | bc8527f3071c |
comparison
equal
deleted
inserted
replaced
3732:3e2e8b8abdaf | 3733:e233f5660da4 |
---|---|
1 /* | |
2 * Copyright (c) 2009, 2011, 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. | |
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 */ | |
23 package com.sun.cri.xir; | |
24 | |
25 import static com.sun.cri.xir.CiXirAssembler.XirOp.*; | |
26 | |
27 import java.util.*; | |
28 | |
29 import com.sun.cri.ci.*; | |
30 import com.sun.cri.ci.CiAddress.*; | |
31 import com.sun.cri.ri.*; | |
32 | |
33 /** | |
34 * Represents an assembler that allows a client such as the runtime system to | |
35 * create {@link XirTemplate XIR templates}. | |
36 */ | |
37 public abstract class CiXirAssembler { | |
38 | |
39 protected XirOperand resultOperand; | |
40 protected boolean allocateResultOperand; | |
41 | |
42 protected final List<XirInstruction> instructions = new ArrayList<XirInstruction>(); | |
43 protected final List<XirLabel> labels = new ArrayList<XirLabel>(5); | |
44 protected final List<XirParameter> parameters = new ArrayList<XirParameter>(5); | |
45 protected final List<XirTemp> temps = new ArrayList<XirTemp>(5); | |
46 protected final List<XirConstant> constants = new ArrayList<XirConstant>(5); | |
47 protected final List<XirMark> marks = new ArrayList<XirMark>(5); | |
48 | |
49 protected int outgoingStackSize = 0; | |
50 | |
51 /** | |
52 * Increases by one for every {@link XirOperand operand} created. | |
53 */ | |
54 protected int variableCount; | |
55 | |
56 /** | |
57 * Marks the assembly complete. | |
58 */ | |
59 protected boolean finished = true; | |
60 | |
61 protected final CiTarget target; | |
62 | |
63 public CiXirAssembler(CiTarget target) { | |
64 this.target = target; | |
65 } | |
66 | |
67 public static class RuntimeCallInformation { | |
68 public final Object target; | |
69 public final boolean useInfoAfter; | |
70 | |
71 public RuntimeCallInformation(Object target, boolean useInfoAfter) { | |
72 this.target = target; | |
73 this.useInfoAfter = useInfoAfter; | |
74 } | |
75 } | |
76 | |
77 /** | |
78 * Represents additional address calculation information. | |
79 */ | |
80 public static final class AddressAccessInformation { | |
81 | |
82 /** | |
83 * The scaling factor for the scaled-index part of an address computation. | |
84 */ | |
85 public final Scale scale; | |
86 | |
87 /** | |
88 * The constant byte-sized displacement part of an address computation. | |
89 */ | |
90 public final int disp; | |
91 | |
92 /** | |
93 * Determines if the memory access through the address can trap. | |
94 */ | |
95 public final boolean canTrap; | |
96 | |
97 private AddressAccessInformation(boolean canTrap) { | |
98 this.canTrap = canTrap; | |
99 this.scale = Scale.Times1; | |
100 this.disp = 0; | |
101 } | |
102 | |
103 private AddressAccessInformation(boolean canTrap, int disp) { | |
104 this.canTrap = canTrap; | |
105 this.scale = Scale.Times1; | |
106 this.disp = disp; | |
107 } | |
108 | |
109 private AddressAccessInformation(boolean canTrap, int disp, Scale scale) { | |
110 this.canTrap = canTrap; | |
111 this.scale = scale; | |
112 this.disp = disp; | |
113 } | |
114 } | |
115 | |
116 /** | |
117 * A label that is the target of a control flow instruction. | |
118 */ | |
119 public static final class XirLabel { | |
120 public static final String TrueSuccessor = "TrueSuccessor"; | |
121 public static final String FalseSuccessor = "FalseSuccessor"; | |
122 public final String name; | |
123 public final int index; | |
124 /** | |
125 * If {@code true} the label is to an instruction in the fast path sequence, otherwise to the slow path. | |
126 */ | |
127 public final boolean inline; | |
128 | |
129 private XirLabel(String name, int index, boolean inline) { | |
130 this.name = name; | |
131 this.index = index; | |
132 this.inline = inline; | |
133 } | |
134 | |
135 @Override | |
136 public String toString() { | |
137 return name; | |
138 } | |
139 } | |
140 | |
141 /** | |
142 * Tagging interface that indicates that an {@link XirOperand} is a constant. | |
143 */ | |
144 public interface XirConstantOperand { | |
145 int getIndex(); | |
146 } | |
147 | |
148 public static final XirOperand VOID = null; | |
149 | |
150 /** | |
151 * Operands for {@link XirInstruction instructions}. | |
152 * There are three basic variants, {@link XirConstant constant}, {@link XirParameter parameter} and {@link XirTemp}. | |
153 */ | |
154 public abstract static class XirOperand { | |
155 | |
156 public final CiKind kind; | |
157 | |
158 /** | |
159 * Unique id in range {@code 0} to {@link #variableCount variableCount - 1}. | |
160 */ | |
161 public final int index; | |
162 | |
163 /** | |
164 * Value whose {@link #toString()} method provides a name for this operand. | |
165 */ | |
166 public final Object name; | |
167 | |
168 public XirOperand(CiXirAssembler asm, Object name, CiKind kind) { | |
169 this.kind = kind; | |
170 this.name = name; | |
171 this.index = asm.variableCount++; | |
172 } | |
173 | |
174 @Override | |
175 public String toString() { | |
176 return String.valueOf(name); | |
177 } | |
178 | |
179 public String detailedToString() { | |
180 | |
181 StringBuffer sb = new StringBuffer(); | |
182 | |
183 sb.append(name); | |
184 sb.append('$'); | |
185 sb.append(kind.typeChar); | |
186 return sb.toString(); | |
187 } | |
188 } | |
189 | |
190 /** | |
191 * Parameters to {@link XirTemplate templates}. | |
192 */ | |
193 public static class XirParameter extends XirOperand { | |
194 /** | |
195 * Unique id in range {@code 0} to {@code parameters.Size() - 1}. | |
196 */ | |
197 public final int parameterIndex; | |
198 | |
199 public final boolean canBeConstant; | |
200 | |
201 XirParameter(CiXirAssembler asm, String name, CiKind kind, boolean canBeConstant) { | |
202 super(asm, name, kind); | |
203 this.parameterIndex = asm.parameters.size(); | |
204 this.canBeConstant = canBeConstant; | |
205 asm.parameters.add(this); | |
206 } | |
207 | |
208 } | |
209 | |
210 public static class XirConstantParameter extends XirParameter implements XirConstantOperand { | |
211 XirConstantParameter(CiXirAssembler asm, String name, CiKind kind) { | |
212 super(asm, name, kind, true); | |
213 } | |
214 | |
215 public int getIndex() { | |
216 return index; | |
217 } | |
218 } | |
219 | |
220 public static class XirVariableParameter extends XirParameter { | |
221 XirVariableParameter(CiXirAssembler asm, String name, CiKind kind, boolean canBeConstant) { | |
222 super(asm, name, kind, canBeConstant); | |
223 } | |
224 } | |
225 | |
226 public static class XirConstant extends XirOperand implements XirConstantOperand { | |
227 public final CiConstant value; | |
228 | |
229 XirConstant(CiXirAssembler asm, CiConstant value) { | |
230 super(asm, value, value.kind); | |
231 this.value = value; | |
232 } | |
233 | |
234 public int getIndex() { | |
235 return index; | |
236 } | |
237 } | |
238 | |
239 public static class XirTemp extends XirOperand { | |
240 public final boolean reserve; | |
241 | |
242 XirTemp(CiXirAssembler asm, String name, CiKind kind, boolean reserve) { | |
243 super(asm, name, kind); | |
244 this.reserve = reserve; | |
245 } | |
246 } | |
247 | |
248 public static class XirRegister extends XirTemp { | |
249 public final CiValue register; | |
250 | |
251 XirRegister(CiXirAssembler asm, String name, CiRegisterValue register, boolean reserve) { | |
252 super(asm, name, register.kind, reserve); | |
253 this.register = register; | |
254 } | |
255 } | |
256 | |
257 /** | |
258 * Start a new assembly with no initial {@link #resultOperand result operand}. | |
259 */ | |
260 public void restart() { | |
261 reset(); | |
262 resultOperand = null; | |
263 } | |
264 | |
265 /** | |
266 * Start a new assembly with a {@link #resultOperand result operand} of type {@code kind}. | |
267 * @param kind the result kind | |
268 * @return an {@code XirOperand} for the result operand | |
269 */ | |
270 public XirOperand restart(CiKind kind) { | |
271 reset(); | |
272 resultOperand = new XirTemp(this, "result", kind, true); | |
273 allocateResultOperand = true; | |
274 return resultOperand; | |
275 } | |
276 | |
277 /** | |
278 * Reset the state of the class to the initial conditions to facilitate a new assembly. | |
279 */ | |
280 private void reset() { | |
281 assert finished : "must be finished before!"; | |
282 variableCount = 0; | |
283 allocateResultOperand = false; | |
284 finished = false; | |
285 instructions.clear(); | |
286 labels.clear(); | |
287 parameters.clear(); | |
288 temps.clear(); | |
289 constants.clear(); | |
290 marks.clear(); | |
291 outgoingStackSize = 0; | |
292 } | |
293 | |
294 /** | |
295 * Represents an XIR instruction, characterized by an {@link XirOp operation}, a {@link CiKind kind}, an optional {@link XirOperand result}, a variable number of {@link XirOperand arguments}, | |
296 * and some optional instruction-specific state. The {@link #x}, {@link #y} and {@link #z} methods are convenient ways to access the first, second and third | |
297 * arguments, respectively. Only the {@link XirOp#CallStub} and {@link XirOp#CallRuntime} instructions can have more than three arguments. | |
298 * | |
299 */ | |
300 public static final class XirInstruction { | |
301 /** | |
302 * The {@link CiKind kind} of values the instruction operates on. | |
303 */ | |
304 public final CiKind kind; | |
305 /** | |
306 * The {@link XirOp operation}. | |
307 */ | |
308 public final XirOp op; | |
309 /** | |
310 * The result, if any. | |
311 */ | |
312 public final XirOperand result; | |
313 /** | |
314 * The arguments. | |
315 */ | |
316 public final XirOperand[] arguments; | |
317 /** | |
318 * Arbitrary additional data associated with the instruction. | |
319 */ | |
320 public final Object extra; | |
321 | |
322 public XirInstruction(CiKind kind, XirOp op, XirOperand result, XirOperand... arguments) { | |
323 this(kind, null, op, result, arguments); | |
324 } | |
325 | |
326 public XirInstruction(CiKind kind, Object extra, XirOp op, XirOperand result, XirOperand... arguments) { | |
327 this.extra = extra; | |
328 this.kind = kind; | |
329 this.op = op; | |
330 this.result = result; | |
331 this.arguments = arguments; | |
332 } | |
333 | |
334 public XirOperand x() { | |
335 assert arguments.length > 0 : "no x operand for this instruction"; | |
336 return arguments[0]; | |
337 } | |
338 | |
339 public XirOperand y() { | |
340 assert arguments.length > 1 : "no y operand for this instruction"; | |
341 return arguments[1]; | |
342 } | |
343 | |
344 public XirOperand z() { | |
345 assert arguments.length > 2 : "no z operand for this instruction"; | |
346 return arguments[2]; | |
347 } | |
348 | |
349 @Override | |
350 public String toString() { | |
351 StringBuffer sb = new StringBuffer(); | |
352 | |
353 if (result != null) { | |
354 sb.append(result.toString()); | |
355 sb.append(" = "); | |
356 } | |
357 | |
358 sb.append(op.name()); | |
359 | |
360 if (kind != CiKind.Void) { | |
361 sb.append('$'); | |
362 sb.append(kind.typeChar); | |
363 } | |
364 | |
365 if (arguments != null && arguments.length > 0) { | |
366 sb.append("("); | |
367 | |
368 for (int i = 0; i < arguments.length; i++) { | |
369 if (i != 0) { | |
370 sb.append(", "); | |
371 } | |
372 sb.append(arguments[i]); | |
373 } | |
374 | |
375 sb.append(")"); | |
376 } | |
377 | |
378 if (extra != null) { | |
379 sb.append(" "); | |
380 sb.append(extra); | |
381 } | |
382 | |
383 return sb.toString(); | |
384 } | |
385 } | |
386 | |
387 /** | |
388 * These marks let the RiXirGenerator mark positions in the generated native code and bring them in relationship with on another. | |
389 * This is necessary for code patching, etc. | |
390 */ | |
391 public static class XirMark { | |
392 public final XirMark[] references; | |
393 public final Object id; | |
394 | |
395 // special mark used to refer to the actual call site of an invoke | |
396 public static final XirMark CALLSITE = new XirMark(null); | |
397 | |
398 public XirMark(Object id, XirMark... references) { | |
399 this.id = id; | |
400 this.references = references; | |
401 } | |
402 } | |
403 | |
404 /** | |
405 * The set of opcodes for XIR instructions. | |
406 * {@link XirInstruction} defines {@code x}, {@code y} and {@code z} as the first, second and third arguments, respectively. | |
407 * We use these mnemonics, plus {@code args} for the complete set of arguments, {@code r} for the result, and {@code extra} | |
408 * for the instruction-specific extra data, in the opcode specifications. Note that the opcodes that operate on values do not directly | |
409 * specify the size (kind) of the data operated on; this is is encoded in {@link XirInstruction#kind}. | |
410 * Note: If the instruction kind differs from the argument/result kinds, the behavior is undefined. | |
411 * | |
412 */ | |
413 public enum XirOp { | |
414 /** | |
415 * Move {@code x} to {@code r}. | |
416 */ | |
417 Mov, | |
418 /** | |
419 * Add {@code y} to {@code x} and put the result in {@code r}. | |
420 */ | |
421 Add, | |
422 /** | |
423 * Subtract {@code y} from {@code x} and put the result in {@code r}. | |
424 */ | |
425 Sub, | |
426 /** | |
427 * Divide {@code y} by {@code x} and put the result in {@code r}. | |
428 */ | |
429 Div, | |
430 /** | |
431 * Multiply {@code y} by {@code x} and put the result in {@code r}. | |
432 */ | |
433 Mul, | |
434 /** | |
435 * {@code y} modulus {@code x} and put the result in {@code r}. | |
436 */ | |
437 Mod, | |
438 /** | |
439 * Shift {@code y} left by {@code x} and put the result in {@code r}. | |
440 */ | |
441 Shl, | |
442 /** | |
443 * Arithmetic shift {@code y} right by {@code x} and put the result in {@code r}. | |
444 */ | |
445 Sar, | |
446 /** | |
447 * Shift {@code y} right by {@code x} and put the result in {@code r}. | |
448 */ | |
449 Shr, | |
450 /** | |
451 * And {@code y} by {@code x} and put the result in {@code r}. | |
452 */ | |
453 And, | |
454 /** | |
455 * Or {@code y} by {@code x} and put the result in {@code r}. | |
456 */ | |
457 Or, | |
458 /** | |
459 * Exclusive Or {@code y} by {@code x} and put the result in {@code r}. | |
460 */ | |
461 Xor, | |
462 /** | |
463 * Null check on {@code x}. | |
464 */ | |
465 NullCheck, | |
466 /** | |
467 * Load value at address {@code x} and put the result in {@code r}. | |
468 */ | |
469 PointerLoad, | |
470 /** | |
471 * Store {@code y} at address {@code x}. | |
472 */ | |
473 PointerStore, | |
474 /** | |
475 * Load value at an effective address defined by base {@code x} and either a scaled index {@code y} plus displacement | |
476 * or an offset {@code y} and put the result in {@code r}. | |
477 */ | |
478 PointerLoadDisp, | |
479 /** | |
480 * Load an effective address defined by base {@code x} and either a scaled index {@code y} plus displacement | |
481 * or an offset {@code y} and put the result in {@code r}. | |
482 */ | |
483 LoadEffectiveAddress, | |
484 /** | |
485 * Store {@code z} at address defined by base {@code x} and index {@code y}. | |
486 */ | |
487 PointerStoreDisp, | |
488 /** | |
489 * Repeat move from {@code x} to {@code y} using {@code z} words. | |
490 */ | |
491 RepeatMoveWords, | |
492 /** | |
493 * Repeat move from {@code x} to {@code y} using {@code z} words. | |
494 */ | |
495 RepeatMoveBytes, | |
496 /** | |
497 * Compare value at at address {@code x} with value in {@code y} and store value {@code z} at address {@code x} | |
498 * if it was equal to {@code y}. | |
499 */ | |
500 PointerCAS, | |
501 /** | |
502 * Call the {@link XirTemplate.GlobalFlags#GLOBAL_STUB shared stub} defined by {@code extra} with {@code args} and put the result in {@code r}. | |
503 */ | |
504 CallStub, | |
505 /** | |
506 * Call the {@link RiMethod} defined by {@code extra} with {@code args} and put the result in {@code r}. | |
507 */ | |
508 CallRuntime, | |
509 /** | |
510 * Transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. | |
511 */ | |
512 Jmp, | |
513 /** | |
514 * If {@code x == y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. | |
515 */ | |
516 Jeq, | |
517 /** | |
518 * If {@code x != y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. | |
519 */ | |
520 Jneq, | |
521 /** | |
522 * If {@code x > y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. | |
523 */ | |
524 Jgt, | |
525 /** | |
526 * If {@code x >= y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. | |
527 */ | |
528 Jgteq, | |
529 /** | |
530 * If {@code x unsigned >= y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. | |
531 */ | |
532 Jugteq, | |
533 /** | |
534 * If {@code x < y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. | |
535 */ | |
536 Jlt, | |
537 /** | |
538 * If {@code x <= y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. | |
539 */ | |
540 Jlteq, | |
541 /** | |
542 * Decreases the input by one and jumps to the target if the input is not 0. | |
543 */ | |
544 DecAndJumpNotZero, | |
545 /** | |
546 * If bit designated by {@code z} at effective address defined by base {@code x} and offset {@code y} | |
547 * is set transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. | |
548 */ | |
549 Jbset, | |
550 /** | |
551 * Bind the {@link XirLabel label} identified by {@code extra} to the current instruction and update any references to it. | |
552 * A label may be bound more than once to the same location. | |
553 */ | |
554 Bind, | |
555 /** | |
556 * Record a safepoint. | |
557 */ | |
558 Safepoint, | |
559 /** | |
560 * Align the code following this instruction to a multiple of (int)extra. | |
561 */ | |
562 Align, | |
563 /** | |
564 * Creates the stack banging overflow check. | |
565 */ | |
566 StackOverflowCheck, | |
567 /** | |
568 * Creates the stack frame for the method and spills callee-save registers (if any) to the {@linkplain CiRegisterSaveArea register save area}. | |
569 */ | |
570 PushFrame, | |
571 /** | |
572 * Restores all callee-save registers (if any) and removes the stack frame of the method. | |
573 */ | |
574 PopFrame, | |
575 /** | |
576 * Inserts an array of bytes directly into the code output. | |
577 */ | |
578 RawBytes, | |
579 /** | |
580 * Pushes a value onto the stack. | |
581 */ | |
582 Push, | |
583 /** | |
584 * Pops a value from the stack. | |
585 */ | |
586 Pop, | |
587 /** | |
588 * Marks a position in the generated native code. | |
589 */ | |
590 Mark, | |
591 /** | |
592 * Load instruction pointer of the next instruction in a destination register. | |
593 */ | |
594 Here, | |
595 /** | |
596 * Inserts nop instructions, with the given size in bytes. | |
597 */ | |
598 Nop, | |
599 /** | |
600 * This instruction should never be reached, this is useful for debugging purposes. | |
601 */ | |
602 ShouldNotReachHere | |
603 } | |
604 | |
605 public/*private*/ void append(XirInstruction xirInstruction) { | |
606 assert !finished : "no instructions can be added to finished template"; | |
607 instructions.add(xirInstruction); | |
608 } | |
609 | |
610 public XirLabel createInlineLabel(String name) { | |
611 final XirLabel result = new XirLabel(name, this.labels.size(), true); | |
612 labels.add(result); | |
613 return result; | |
614 } | |
615 | |
616 public XirLabel createOutOfLineLabel(String name) { | |
617 final XirLabel result = new XirLabel(name, this.labels.size(), false); | |
618 labels.add(result); | |
619 return result; | |
620 } | |
621 | |
622 public void mov(XirOperand result, XirOperand a) { | |
623 append(new XirInstruction(result.kind, Mov, result, a)); | |
624 } | |
625 | |
626 public void add(XirOperand result, XirOperand a, XirOperand b) { | |
627 append(new XirInstruction(result.kind, Add, result, a, b)); | |
628 } | |
629 | |
630 public void sub(XirOperand result, XirOperand a, XirOperand b) { | |
631 append(new XirInstruction(result.kind, Sub, result, a, b)); | |
632 } | |
633 | |
634 public void div(XirOperand result, XirOperand a, XirOperand b) { | |
635 append(new XirInstruction(result.kind, Div, result, a, b)); | |
636 } | |
637 | |
638 public void mul(XirOperand result, XirOperand a, XirOperand b) { | |
639 append(new XirInstruction(result.kind, Mul, result, a, b)); | |
640 } | |
641 | |
642 public void mod(XirOperand result, XirOperand a, XirOperand b) { | |
643 append(new XirInstruction(result.kind, Mod, result, a, b)); | |
644 } | |
645 | |
646 public void shl(XirOperand result, XirOperand a, XirOperand b) { | |
647 append(new XirInstruction(result.kind, Shl, result, a, b)); | |
648 } | |
649 | |
650 public void shr(XirOperand result, XirOperand a, XirOperand b) { | |
651 append(new XirInstruction(result.kind, Shr, result, a, b)); | |
652 } | |
653 | |
654 public void and(XirOperand result, XirOperand a, XirOperand b) { | |
655 append(new XirInstruction(result.kind, And, result, a, b)); | |
656 } | |
657 | |
658 public void or(XirOperand result, XirOperand a, XirOperand b) { | |
659 append(new XirInstruction(result.kind, Or, result, a, b)); | |
660 } | |
661 | |
662 public void xor(XirOperand result, XirOperand a, XirOperand b) { | |
663 append(new XirInstruction(result.kind, Xor, result, a, b)); | |
664 } | |
665 | |
666 public void nullCheck(XirOperand pointer) { | |
667 append(new XirInstruction(CiKind.Object, NullCheck, VOID, pointer)); | |
668 } | |
669 | |
670 public void pload(CiKind kind, XirOperand result, XirOperand pointer, boolean canTrap) { | |
671 append(new XirInstruction(kind, canTrap, PointerLoad, result, pointer)); | |
672 } | |
673 | |
674 public void pstore(CiKind kind, XirOperand pointer, XirOperand value, boolean canTrap) { | |
675 append(new XirInstruction(kind, canTrap, PointerStore, null, pointer, value)); | |
676 } | |
677 | |
678 public void pload(CiKind kind, XirOperand result, XirOperand pointer, XirOperand offset, boolean canTrap) { | |
679 append(new XirInstruction(kind, new AddressAccessInformation(canTrap), PointerLoadDisp, result, pointer, offset)); | |
680 } | |
681 | |
682 public void pstore(CiKind kind, XirOperand pointer, XirOperand offset, XirOperand value, boolean canTrap) { | |
683 append(new XirInstruction(kind, new AddressAccessInformation(canTrap), PointerStoreDisp, VOID, pointer, offset, value)); | |
684 } | |
685 | |
686 public void pload(CiKind kind, XirOperand result, XirOperand pointer, XirOperand index, int disp, Scale scale, boolean canTrap) { | |
687 append(new XirInstruction(kind, new AddressAccessInformation(canTrap, disp, scale), PointerLoadDisp, result, pointer, index)); | |
688 } | |
689 | |
690 public void lea(XirOperand result, XirOperand pointer, XirOperand index, int disp, Scale scale) { | |
691 append(new XirInstruction(target.wordKind, new AddressAccessInformation(false, disp, scale), LoadEffectiveAddress, result, pointer, index)); | |
692 } | |
693 | |
694 public void repmov(XirOperand src, XirOperand dest, XirOperand length) { | |
695 append(new XirInstruction(target.wordKind, null, RepeatMoveWords, null, src, dest, length)); | |
696 } | |
697 | |
698 public void here(XirOperand dst) { | |
699 append(new XirInstruction(target.wordKind, null, Here, dst)); | |
700 } | |
701 | |
702 public void repmovb(XirOperand src, XirOperand dest, XirOperand length) { | |
703 append(new XirInstruction(target.wordKind, null, RepeatMoveBytes, null, src, dest, length)); | |
704 } | |
705 | |
706 public void pstore(CiKind kind, XirOperand pointer, XirOperand index, XirOperand value, int disp, Scale scale, boolean canTrap) { | |
707 append(new XirInstruction(kind, new AddressAccessInformation(canTrap, disp, scale), PointerStoreDisp, VOID, pointer, index, value)); | |
708 } | |
709 | |
710 public void pcas(CiKind kind, XirOperand result, XirOperand pointer, XirOperand newValue, XirOperand oldValue) { | |
711 append(new XirInstruction(kind, null, PointerCAS, result, pointer, newValue, oldValue)); | |
712 } | |
713 | |
714 public void jmp(XirLabel l) { | |
715 append(new XirInstruction(CiKind.Void, l, Jmp, null)); | |
716 } | |
717 | |
718 public void decAndJumpNotZero(XirLabel l, XirOperand val) { | |
719 append(new XirInstruction(CiKind.Void, l, DecAndJumpNotZero, null, val)); | |
720 } | |
721 | |
722 public void jmpRuntime(Object rt) { | |
723 append(new XirInstruction(CiKind.Void, rt, Jmp, null)); | |
724 } | |
725 | |
726 public void jeq(XirLabel l, XirOperand a, XirOperand b) { | |
727 jcc(Jeq, l, a, b); | |
728 } | |
729 | |
730 private void jcc(XirOp op, XirLabel l, XirOperand a, XirOperand b) { | |
731 append(new XirInstruction(CiKind.Void, l, op, null, a, b)); | |
732 } | |
733 | |
734 public void jneq(XirLabel l, XirOperand a, XirOperand b) { | |
735 jcc(Jneq, l, a, b); | |
736 } | |
737 | |
738 public void jgt(XirLabel l, XirOperand a, XirOperand b) { | |
739 jcc(Jgt, l, a, b); | |
740 } | |
741 | |
742 public void jgteq(XirLabel l, XirOperand a, XirOperand b) { | |
743 jcc(Jgteq, l, a, b); | |
744 } | |
745 | |
746 public void jugteq(XirLabel l, XirOperand a, XirOperand b) { | |
747 jcc(Jugteq, l, a, b); | |
748 } | |
749 | |
750 public void jlt(XirLabel l, XirOperand a, XirOperand b) { | |
751 jcc(Jlt, l, a, b); | |
752 } | |
753 | |
754 public void jlteq(XirLabel l, XirOperand a, XirOperand b) { | |
755 jcc(Jlteq, l, a, b); | |
756 } | |
757 | |
758 public void jbset(XirLabel l, XirOperand a, XirOperand b, XirOperand c) { | |
759 append(new XirInstruction(CiKind.Void, l, Jbset, null, a, b, c)); | |
760 } | |
761 | |
762 public void bindInline(XirLabel l) { | |
763 assert l.inline; | |
764 append(new XirInstruction(CiKind.Void, l, Bind, null)); | |
765 } | |
766 | |
767 public void bindOutOfLine(XirLabel l) { | |
768 assert !l.inline; | |
769 append(new XirInstruction(CiKind.Void, l, Bind, null)); | |
770 } | |
771 | |
772 public void safepoint() { | |
773 append(new XirInstruction(CiKind.Void, null, Safepoint, null)); | |
774 } | |
775 | |
776 public void align(int multiple) { | |
777 assert multiple > 0; | |
778 append(new XirInstruction(CiKind.Void, multiple, Align, null)); | |
779 } | |
780 | |
781 public void stackOverflowCheck() { | |
782 append(new XirInstruction(CiKind.Void, null, StackOverflowCheck, null)); | |
783 } | |
784 | |
785 public void pushFrame() { | |
786 append(new XirInstruction(CiKind.Void, null, PushFrame, null)); | |
787 } | |
788 | |
789 public void popFrame() { | |
790 append(new XirInstruction(CiKind.Void, null, PopFrame, null)); | |
791 } | |
792 | |
793 public void rawBytes(byte[] bytes) { | |
794 append(new XirInstruction(CiKind.Void, bytes, RawBytes, null)); | |
795 } | |
796 | |
797 public void push(XirOperand value) { | |
798 append(new XirInstruction(CiKind.Void, Push, VOID, value)); | |
799 } | |
800 | |
801 public void pop(XirOperand result) { | |
802 append(new XirInstruction(result.kind, Pop, result)); | |
803 } | |
804 | |
805 public XirMark mark(Object id, XirMark... references) { | |
806 XirMark mark = new XirMark(id, references); | |
807 marks.add(mark); | |
808 append(new XirInstruction(CiKind.Void, mark, Mark, null)); | |
809 return mark; | |
810 } | |
811 | |
812 public void nop(int size) { | |
813 append(new XirInstruction(CiKind.Void, size, Nop, null)); | |
814 } | |
815 | |
816 public void shouldNotReachHere() { | |
817 append(new XirInstruction(CiKind.Void, null, ShouldNotReachHere, null)); | |
818 } | |
819 | |
820 public void shouldNotReachHere(String message) { | |
821 append(new XirInstruction(CiKind.Void, message, ShouldNotReachHere, null)); | |
822 } | |
823 | |
824 public void callStub(XirTemplate stub, XirOperand result, XirOperand... args) { | |
825 CiKind resultKind = result == null ? CiKind.Void : result.kind; | |
826 append(new XirInstruction(resultKind, stub, CallStub, result, args)); | |
827 } | |
828 | |
829 public void callRuntime(Object rt, XirOperand result, XirOperand... args) { | |
830 callRuntime(rt, result, false, args); | |
831 } | |
832 | |
833 public void callRuntime(Object rt, XirOperand result, boolean useInfoAfter, XirOperand... args) { | |
834 CiKind resultKind = result == null ? CiKind.Void : result.kind; | |
835 append(new XirInstruction(resultKind, new RuntimeCallInformation(rt, useInfoAfter), CallRuntime, result, args)); | |
836 } | |
837 | |
838 /** | |
839 * Terminates the assembly, checking invariants, in particular that {@link resultOperand} is set, and setting {@link #finished} to {@code true}. | |
840 */ | |
841 private void end() { | |
842 assert !finished : "template may only be finished once!"; | |
843 assert resultOperand != null : "result operand should be set"; | |
844 finished = true; | |
845 } | |
846 | |
847 /** | |
848 * Creates an {@link XirVariableParameter variable input parameter} of given name and {@link CiKind kind}. | |
849 * @param name a name for the parameter | |
850 * @param kind the parameter kind | |
851 * @return the {@link XirVariableParameter} | |
852 */ | |
853 public XirVariableParameter createInputParameter(String name, CiKind kind, boolean canBeConstant) { | |
854 assert !finished; | |
855 return new XirVariableParameter(this, name, kind, canBeConstant); | |
856 } | |
857 | |
858 public XirVariableParameter createInputParameter(String name, CiKind kind) { | |
859 return createInputParameter(name, kind, false); | |
860 } | |
861 | |
862 /** | |
863 * Creates an {@link XirConstantParameter constant input parameter} of given name and {@link CiKind kind}. | |
864 * @param name a name for the parameter | |
865 * @param kind the parameter kind | |
866 * @return the {@link XirConstantParameter} | |
867 */ | |
868 public XirConstantParameter createConstantInputParameter(String name, CiKind kind) { | |
869 assert !finished; | |
870 return new XirConstantParameter(this, name, kind); | |
871 } | |
872 | |
873 public XirConstant createConstant(CiConstant constant) { | |
874 assert !finished; | |
875 XirConstant temp = new XirConstant(this, constant); | |
876 constants.add(temp); | |
877 return temp; | |
878 } | |
879 | |
880 public XirOperand createTemp(String name, CiKind kind) { | |
881 assert !finished; | |
882 XirTemp temp = new XirTemp(this, name, kind, true); | |
883 temps.add(temp); | |
884 return temp; | |
885 } | |
886 | |
887 public XirOperand createRegister(String name, CiKind kind, CiRegister register) { | |
888 return createRegister(name, kind, register, false); | |
889 } | |
890 | |
891 public XirOperand createRegisterTemp(String name, CiKind kind, CiRegister register) { | |
892 return createRegister(name, kind, register, true); | |
893 } | |
894 | |
895 private XirOperand createRegister(String name, CiKind kind, CiRegister register, boolean reserve) { | |
896 assert !finished; | |
897 XirRegister fixed = new XirRegister(this, name, register.asValue(kind), reserve); | |
898 temps.add(fixed); | |
899 return fixed; | |
900 } | |
901 | |
902 public XirParameter getParameter(String name) { | |
903 for (XirParameter param : parameters) { | |
904 if (param.name.toString().equals(name)) { | |
905 return param; | |
906 } | |
907 } | |
908 throw new IllegalArgumentException("no parameter: " + name); | |
909 } | |
910 | |
911 public XirTemp getTemp(String name) { | |
912 for (XirTemp temp : temps) { | |
913 if (temp.name.toString().equals(name)) { | |
914 return temp; | |
915 } | |
916 } | |
917 throw new IllegalArgumentException("no temp: " + name); | |
918 } | |
919 | |
920 public XirConstant i(int v) { | |
921 return createConstant(CiConstant.forInt(v)); | |
922 } | |
923 | |
924 public XirConstant l(int v) { | |
925 return createConstant(CiConstant.forLong(v)); | |
926 } | |
927 | |
928 public XirConstant b(boolean v) { | |
929 return createConstant(CiConstant.forBoolean(v)); | |
930 } | |
931 | |
932 public XirConstant o(Object obj) { | |
933 return createConstant(CiConstant.forObject(obj)); | |
934 } | |
935 | |
936 public void reserveOutgoingStack(int size) { | |
937 outgoingStackSize = Math.max(outgoingStackSize, size); | |
938 } | |
939 | |
940 /** | |
941 * Finishes the assembly of a non-stub template, providing the {@link #resultOperand} and constructs the {@link XirTemplate}. | |
942 * @param result the {@link XirOperand} to be set as the {@link #resultOperand} | |
943 * @param name the name of the template | |
944 * @return the generated template | |
945 */ | |
946 public XirTemplate finishTemplate(XirOperand result, String name) { | |
947 assert this.resultOperand == null; | |
948 assert result != null; | |
949 this.resultOperand = result; | |
950 final XirTemplate template = buildTemplate(name, false); | |
951 end(); | |
952 return template; | |
953 } | |
954 | |
955 /** | |
956 * Finishes the assembly of a non-stub template and constructs the {@link XirTemplate}. | |
957 * @param name the name of the template | |
958 * @return the generated template | |
959 */ | |
960 public XirTemplate finishTemplate(String name) { | |
961 final XirTemplate template = buildTemplate(name, false); | |
962 end(); | |
963 return template; | |
964 } | |
965 | |
966 /** | |
967 * Finishes the assembly of a {@link XirTemplate.GlobalFlags#GLOBAL_STUB stub} and constructs the {@link XirTemplate}. | |
968 * @param name the name of the template | |
969 * @return the generated template | |
970 */ | |
971 public XirTemplate finishStub(String name) { | |
972 final XirTemplate template = buildTemplate(name, true); | |
973 end(); | |
974 return template; | |
975 } | |
976 | |
977 /** | |
978 * Builds the {@link XirTemplate} from the assembly state in this object. | |
979 * The actual assembly is dependent on the target architecture and implemented | |
980 * in a concrete subclass. | |
981 * @param name the name of the template | |
982 * @param isStub {@code true} if the template represents a {@link XirTemplate.GlobalFlags#GLOBAL_STUB stub} | |
983 * @return the generated template | |
984 */ | |
985 protected abstract XirTemplate buildTemplate(String name, boolean isStub); | |
986 | |
987 public abstract CiXirAssembler copy(); | |
988 | |
989 } |