22 * questions.
23 *
24 */
25
26 #include "precompiled.hpp"
27 #include "asm/assembler.hpp"
28 #include "asm/assembler.inline.hpp"
29 #include "ci/ciEnv.hpp"
30 #include "code/compiledIC.hpp"
31 #include "compiler/compileTask.hpp"
32 #include "compiler/disassembler.hpp"
33 #include "compiler/oopMap.hpp"
34 #include "gc/shared/barrierSet.hpp"
35 #include "gc/shared/barrierSetAssembler.hpp"
36 #include "gc/shared/cardTableBarrierSet.hpp"
37 #include "gc/shared/cardTable.hpp"
38 #include "gc/shared/collectedHeap.hpp"
39 #include "gc/shared/tlab_globals.hpp"
40 #include "interpreter/bytecodeHistogram.hpp"
41 #include "interpreter/interpreter.hpp"
42 #include "jvm.h"
43 #include "memory/resourceArea.hpp"
44 #include "memory/universe.hpp"
45 #include "nativeInst_aarch64.hpp"
46 #include "oops/accessDecorators.hpp"
47 #include "oops/compressedKlass.inline.hpp"
48 #include "oops/compressedOops.inline.hpp"
49 #include "oops/klass.inline.hpp"
50 #include "runtime/continuation.hpp"
51 #include "runtime/icache.hpp"
52 #include "runtime/interfaceSupport.inline.hpp"
53 #include "runtime/javaThread.hpp"
54 #include "runtime/jniHandles.inline.hpp"
55 #include "runtime/sharedRuntime.hpp"
56 #include "runtime/stubRoutines.hpp"
57 #include "utilities/globalDefinitions.hpp"
58 #include "utilities/powerOfTwo.hpp"
59 #ifdef COMPILER1
60 #include "c1/c1_LIRAssembler.hpp"
61 #endif
1938 // cf. TemplateTable::prepare_invoke(), if (load_receiver).
1939 int stackElementSize = Interpreter::stackElementSize;
1940 int offset = Interpreter::expr_offset_in_bytes(extra_slot_offset+0);
1941 #ifdef ASSERT
1942 int offset1 = Interpreter::expr_offset_in_bytes(extra_slot_offset+1);
1943 assert(offset1 - offset == stackElementSize, "correct arithmetic");
1944 #endif
1945 if (arg_slot.is_constant()) {
1946 return Address(esp, arg_slot.as_constant() * stackElementSize
1947 + offset);
1948 } else {
1949 add(rscratch1, esp, arg_slot.as_register(),
1950 ext::uxtx, exact_log2(stackElementSize));
1951 return Address(rscratch1, offset);
1952 }
1953 }
1954
1955 void MacroAssembler::call_VM_leaf_base(address entry_point,
1956 int number_of_arguments,
1957 Label *retaddr) {
1958 Label E, L;
1959
1960 stp(rscratch1, rmethod, Address(pre(sp, -2 * wordSize)));
1961
1962 mov(rscratch1, entry_point);
1963 blr(rscratch1);
1964 if (retaddr)
1965 bind(*retaddr);
1966
1967 ldp(rscratch1, rmethod, Address(post(sp, 2 * wordSize)));
1968 }
1969
1970 void MacroAssembler::call_VM_leaf(address entry_point, int number_of_arguments) {
1971 call_VM_leaf_base(entry_point, number_of_arguments);
1972 }
1973
1974 void MacroAssembler::call_VM_leaf(address entry_point, Register arg_0) {
1975 pass_arg0(this, arg_0);
1976 call_VM_leaf_base(entry_point, 1);
1977 }
1978
1979 void MacroAssembler::call_VM_leaf(address entry_point, Register arg_0, Register arg_1) {
1980 assert_different_registers(arg_1, c_rarg0);
1981 pass_arg0(this, arg_0);
1982 pass_arg1(this, arg_1);
1983 call_VM_leaf_base(entry_point, 2);
1984 }
1985
1986 void MacroAssembler::call_VM_leaf(address entry_point, Register arg_0,
5185 ThreadInVMfromUnknown tiv;
5186 assert(oop_recorder() != nullptr, "this assembler needs an OopRecorder");
5187 assert(Universe::heap()->is_in(JNIHandles::resolve(obj)), "not an oop");
5188 }
5189 #endif
5190 int oop_index = oop_recorder()->find_index(obj);
5191 return Address((address)obj, oop_Relocation::spec(oop_index));
5192 }
5193
5194 // Defines obj, preserves var_size_in_bytes, okay for t2 == var_size_in_bytes.
5195 void MacroAssembler::tlab_allocate(Register obj,
5196 Register var_size_in_bytes,
5197 int con_size_in_bytes,
5198 Register t1,
5199 Register t2,
5200 Label& slow_case) {
5201 BarrierSetAssembler *bs = BarrierSet::barrier_set()->barrier_set_assembler();
5202 bs->tlab_allocate(this, obj, var_size_in_bytes, con_size_in_bytes, t1, t2, slow_case);
5203 }
5204
5205 void MacroAssembler::verify_tlab() {
5206 #ifdef ASSERT
5207 if (UseTLAB && VerifyOops) {
5208 Label next, ok;
5209
5210 stp(rscratch2, rscratch1, Address(pre(sp, -16)));
5211
5212 ldr(rscratch2, Address(rthread, in_bytes(JavaThread::tlab_top_offset())));
5213 ldr(rscratch1, Address(rthread, in_bytes(JavaThread::tlab_start_offset())));
5214 cmp(rscratch2, rscratch1);
5215 br(Assembler::HS, next);
5216 STOP("assert(top >= start)");
5217 should_not_reach_here();
5218
5219 bind(next);
5220 ldr(rscratch2, Address(rthread, in_bytes(JavaThread::tlab_end_offset())));
5221 ldr(rscratch1, Address(rthread, in_bytes(JavaThread::tlab_top_offset())));
5222 cmp(rscratch2, rscratch1);
5223 br(Assembler::HS, ok);
5224 STOP("assert(top <= end)");
|
22 * questions.
23 *
24 */
25
26 #include "precompiled.hpp"
27 #include "asm/assembler.hpp"
28 #include "asm/assembler.inline.hpp"
29 #include "ci/ciEnv.hpp"
30 #include "code/compiledIC.hpp"
31 #include "compiler/compileTask.hpp"
32 #include "compiler/disassembler.hpp"
33 #include "compiler/oopMap.hpp"
34 #include "gc/shared/barrierSet.hpp"
35 #include "gc/shared/barrierSetAssembler.hpp"
36 #include "gc/shared/cardTableBarrierSet.hpp"
37 #include "gc/shared/cardTable.hpp"
38 #include "gc/shared/collectedHeap.hpp"
39 #include "gc/shared/tlab_globals.hpp"
40 #include "interpreter/bytecodeHistogram.hpp"
41 #include "interpreter/interpreter.hpp"
42 #include "interpreter/interpreterRuntime.hpp"
43 #include "jvm.h"
44 #include "memory/resourceArea.hpp"
45 #include "memory/universe.hpp"
46 #include "nativeInst_aarch64.hpp"
47 #include "oops/accessDecorators.hpp"
48 #include "oops/compressedKlass.inline.hpp"
49 #include "oops/compressedOops.inline.hpp"
50 #include "oops/klass.inline.hpp"
51 #include "runtime/continuation.hpp"
52 #include "runtime/icache.hpp"
53 #include "runtime/interfaceSupport.inline.hpp"
54 #include "runtime/javaThread.hpp"
55 #include "runtime/jniHandles.inline.hpp"
56 #include "runtime/sharedRuntime.hpp"
57 #include "runtime/stubRoutines.hpp"
58 #include "utilities/globalDefinitions.hpp"
59 #include "utilities/powerOfTwo.hpp"
60 #ifdef COMPILER1
61 #include "c1/c1_LIRAssembler.hpp"
62 #endif
1939 // cf. TemplateTable::prepare_invoke(), if (load_receiver).
1940 int stackElementSize = Interpreter::stackElementSize;
1941 int offset = Interpreter::expr_offset_in_bytes(extra_slot_offset+0);
1942 #ifdef ASSERT
1943 int offset1 = Interpreter::expr_offset_in_bytes(extra_slot_offset+1);
1944 assert(offset1 - offset == stackElementSize, "correct arithmetic");
1945 #endif
1946 if (arg_slot.is_constant()) {
1947 return Address(esp, arg_slot.as_constant() * stackElementSize
1948 + offset);
1949 } else {
1950 add(rscratch1, esp, arg_slot.as_register(),
1951 ext::uxtx, exact_log2(stackElementSize));
1952 return Address(rscratch1, offset);
1953 }
1954 }
1955
1956 void MacroAssembler::call_VM_leaf_base(address entry_point,
1957 int number_of_arguments,
1958 Label *retaddr) {
1959 Label not_preempted;
1960
1961 stp(rscratch1, rmethod, Address(pre(sp, -2 * wordSize)));
1962 str(zr, Address(rthread, JavaThread::preempt_alternate_return_offset()));
1963
1964 mov(rscratch1, entry_point);
1965 blr(rscratch1);
1966 if (retaddr)
1967 bind(*retaddr);
1968
1969 if (entry_point == CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter) ||
1970 entry_point == CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter_obj)) {
1971 ldr(rscratch1, Address(rthread, JavaThread::preempt_alternate_return_offset()));
1972 ldr(rscratch2, Address(rthread, in_bytes(JavaThread::preempt_alternate_return_offset()) + wordSize));
1973 cbz(rscratch1, not_preempted);
1974 mov(r4, sp); // r4 is clobbered by VM calls, so free here
1975 cmp(rscratch2, r4);
1976 br(LT, not_preempted);
1977 str(zr, Address(rthread, JavaThread::preempt_alternate_return_offset()));
1978 str(zr, Address(rthread, in_bytes(JavaThread::preempt_alternate_return_offset()) + wordSize));
1979 br(rscratch1);
1980 }
1981
1982 bind(not_preempted);
1983 ldp(rscratch1, rmethod, Address(post(sp, 2 * wordSize)));
1984 }
1985
1986 void MacroAssembler::call_VM_leaf(address entry_point, int number_of_arguments) {
1987 call_VM_leaf_base(entry_point, number_of_arguments);
1988 }
1989
1990 void MacroAssembler::call_VM_leaf(address entry_point, Register arg_0) {
1991 pass_arg0(this, arg_0);
1992 call_VM_leaf_base(entry_point, 1);
1993 }
1994
1995 void MacroAssembler::call_VM_leaf(address entry_point, Register arg_0, Register arg_1) {
1996 assert_different_registers(arg_1, c_rarg0);
1997 pass_arg0(this, arg_0);
1998 pass_arg1(this, arg_1);
1999 call_VM_leaf_base(entry_point, 2);
2000 }
2001
2002 void MacroAssembler::call_VM_leaf(address entry_point, Register arg_0,
5201 ThreadInVMfromUnknown tiv;
5202 assert(oop_recorder() != nullptr, "this assembler needs an OopRecorder");
5203 assert(Universe::heap()->is_in(JNIHandles::resolve(obj)), "not an oop");
5204 }
5205 #endif
5206 int oop_index = oop_recorder()->find_index(obj);
5207 return Address((address)obj, oop_Relocation::spec(oop_index));
5208 }
5209
5210 // Defines obj, preserves var_size_in_bytes, okay for t2 == var_size_in_bytes.
5211 void MacroAssembler::tlab_allocate(Register obj,
5212 Register var_size_in_bytes,
5213 int con_size_in_bytes,
5214 Register t1,
5215 Register t2,
5216 Label& slow_case) {
5217 BarrierSetAssembler *bs = BarrierSet::barrier_set()->barrier_set_assembler();
5218 bs->tlab_allocate(this, obj, var_size_in_bytes, con_size_in_bytes, t1, t2, slow_case);
5219 }
5220
5221 void MacroAssembler::inc_held_monitor_count() {
5222 Address dst = Address(rthread, JavaThread::held_monitor_count_offset());
5223 #ifdef ASSERT
5224 ldr(rscratch2, dst);
5225 increment(rscratch2);
5226 str(rscratch2, dst);
5227 Label ok;
5228 tbz(rscratch2, 63, ok);
5229 STOP("assert(held monitor count underflow)");
5230 should_not_reach_here();
5231 bind(ok);
5232 #else
5233 increment(dst);
5234 #endif
5235 }
5236
5237 void MacroAssembler::dec_held_monitor_count() {
5238 Address dst = Address(rthread, JavaThread::held_monitor_count_offset());
5239 #ifdef ASSERT
5240 ldr(rscratch2, dst);
5241 decrement(rscratch2);
5242 str(rscratch2, dst);
5243 Label ok;
5244 tbz(rscratch2, 63, ok);
5245 STOP("assert(held monitor count underflow)");
5246 should_not_reach_here();
5247 bind(ok);
5248 #else
5249 decrement(dst);
5250 #endif
5251 }
5252
5253 void MacroAssembler::verify_tlab() {
5254 #ifdef ASSERT
5255 if (UseTLAB && VerifyOops) {
5256 Label next, ok;
5257
5258 stp(rscratch2, rscratch1, Address(pre(sp, -16)));
5259
5260 ldr(rscratch2, Address(rthread, in_bytes(JavaThread::tlab_top_offset())));
5261 ldr(rscratch1, Address(rthread, in_bytes(JavaThread::tlab_start_offset())));
5262 cmp(rscratch2, rscratch1);
5263 br(Assembler::HS, next);
5264 STOP("assert(top >= start)");
5265 should_not_reach_here();
5266
5267 bind(next);
5268 ldr(rscratch2, Address(rthread, in_bytes(JavaThread::tlab_end_offset())));
5269 ldr(rscratch1, Address(rthread, in_bytes(JavaThread::tlab_top_offset())));
5270 cmp(rscratch2, rscratch1);
5271 br(Assembler::HS, ok);
5272 STOP("assert(top <= end)");
|