1 /*
2 * Copyright (c) 2015, 2015, 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 org.graalvm.compiler.hotspot.sparc;
24
25 import static org.graalvm.compiler.asm.sparc.SPARCAssembler.isSimm13;
26 import static org.graalvm.compiler.lir.LIRValueUtil.asJavaConstant;
27 import static org.graalvm.compiler.lir.LIRValueUtil.isJavaConstant;
28 import static jdk.vm.ci.code.ValueUtil.asRegister;
29
30 import org.graalvm.compiler.asm.Assembler;
31 import org.graalvm.compiler.asm.sparc.SPARCAddress;
32 import org.graalvm.compiler.asm.sparc.SPARCAssembler;
33 import org.graalvm.compiler.asm.sparc.SPARCMacroAssembler;
34 import org.graalvm.compiler.asm.sparc.SPARCMacroAssembler.ScratchRegister;
35 import org.graalvm.compiler.hotspot.HotSpotCounterOp;
36 import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig;
37 import org.graalvm.compiler.hotspot.meta.HotSpotRegistersProvider;
38 import org.graalvm.compiler.lir.LIRInstructionClass;
39 import org.graalvm.compiler.lir.Opcode;
40 import org.graalvm.compiler.lir.asm.CompilationResultBuilder;
41
42 import jdk.vm.ci.code.Register;
43 import jdk.vm.ci.code.TargetDescription;
44 import jdk.vm.ci.meta.Value;
45
46 @Opcode("BenchMarkCounter")
47 public class SPARCHotSpotCounterOp extends HotSpotCounterOp {
48 public static final LIRInstructionClass<SPARCHotSpotCounterOp> TYPE = LIRInstructionClass.create(SPARCHotSpotCounterOp.class);
49
50 private int[] counterPatchOffsets;
51
52 public SPARCHotSpotCounterOp(String name, String group, Value increment, HotSpotRegistersProvider registers, GraalHotSpotVMConfig config) {
53 super(TYPE, name, group, increment, registers, config);
54 this.counterPatchOffsets = new int[1];
55 }
56
57 public SPARCHotSpotCounterOp(String[] names, String[] groups, Value[] increments, HotSpotRegistersProvider registers, GraalHotSpotVMConfig config) {
58 super(TYPE, names, groups, increments, registers, config);
59 this.counterPatchOffsets = new int[names.length];
60 }
61
62 @Override
63 public void emitCode(CompilationResultBuilder crb) {
64 SPARCMacroAssembler masm = (SPARCMacroAssembler) crb.asm;
65 TargetDescription target = crb.target;
66
67 // address for counters array
68 SPARCAddress countersArrayAddr = new SPARCAddress(thread, config.jvmciCountersThreadOffset);
69 try (ScratchRegister scratch = masm.getScratchRegister()) {
70 Register countersArrayReg = scratch.getRegister();
71
72 // load counters array
73 masm.ldx(countersArrayAddr, countersArrayReg);
74 IncrementEmitter emitter = new IncrementEmitter(countersArrayReg, masm);
75 forEachCounter(emitter, target);
76 }
77 }
78
79 private void emitIncrement(int counterIndex, SPARCMacroAssembler masm, SPARCAddress counterAddr, Value increment) {
80 try (ScratchRegister scratch = masm.getScratchRegister()) {
81 Register counterReg = scratch.getRegister();
82 // load counter value
83 masm.ldx(counterAddr, counterReg);
84 counterPatchOffsets[counterIndex] = masm.position();
85 // increment counter
86 if (isJavaConstant(increment)) {
87 masm.add(counterReg, asInt(asJavaConstant(increment)), counterReg);
88 } else {
89 masm.add(counterReg, asRegister(increment), counterReg);
90 }
91 // store counter value
92 masm.stx(counterReg, counterAddr);
93 }
94 }
95
96 /**
97 * Patches the increment value in the instruction emitted by the
98 * {@link #emitIncrement(int, SPARCMacroAssembler, SPARCAddress, Value)} method. This method is
99 * used if patching is needed after assembly.
100 *
101 * @param asm
102 * @param increment
103 */
104 @Override
105 public void patchCounterIncrement(Assembler asm, int[] increment) {
106 for (int i = 0; i < increment.length; i++) {
107 int inst = counterPatchOffsets[i];
108 ((SPARCAssembler) asm).patchAddImmediate(inst, increment[i]);
109 }
110 }
111
112 public int[] getCounterPatchOffsets() {
113 return counterPatchOffsets;
114 }
115
116 private class IncrementEmitter implements CounterProcedure {
117 private int lastDisplacement = 0;
118 private final Register countersArrayReg;
119 private final SPARCMacroAssembler masm;
120
121 IncrementEmitter(Register countersArrayReg, SPARCMacroAssembler masm) {
122 super();
123 this.countersArrayReg = countersArrayReg;
124 this.masm = masm;
125 }
126
127 @Override
128 public void apply(int counterIndex, Value increment, int displacement) {
129 SPARCAddress counterAddr;
130 int relativeDisplacement = displacement - lastDisplacement;
131 if (isSimm13(relativeDisplacement)) { // Displacement fits into ld instruction
132 counterAddr = new SPARCAddress(countersArrayReg, relativeDisplacement);
133 } else {
134 try (ScratchRegister scratch = masm.getScratchRegister()) {
135 Register tempOffsetRegister = scratch.getRegister();
136 masm.setx(relativeDisplacement, tempOffsetRegister, false);
137 masm.add(countersArrayReg, tempOffsetRegister, countersArrayReg);
138 }
139 lastDisplacement = displacement;
140 counterAddr = new SPARCAddress(countersArrayReg, 0);
141 }
142 emitIncrement(counterIndex, masm, counterAddr, increment);
143 }
144 }
145 }