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
1934 // cf. TemplateTable::prepare_invoke(), if (load_receiver).
1935 int stackElementSize = Interpreter::stackElementSize;
1936 int offset = Interpreter::expr_offset_in_bytes(extra_slot_offset+0);
1937 #ifdef ASSERT
1938 int offset1 = Interpreter::expr_offset_in_bytes(extra_slot_offset+1);
1939 assert(offset1 - offset == stackElementSize, "correct arithmetic");
1940 #endif
1941 if (arg_slot.is_constant()) {
1942 return Address(esp, arg_slot.as_constant() * stackElementSize
1943 + offset);
1944 } else {
1945 add(rscratch1, esp, arg_slot.as_register(),
1946 ext::uxtx, exact_log2(stackElementSize));
1947 return Address(rscratch1, offset);
1948 }
1949 }
1950
1951 void MacroAssembler::call_VM_leaf_base(address entry_point,
1952 int number_of_arguments,
1953 Label *retaddr) {
1954 Label E, L;
1955
1956 stp(rscratch1, rmethod, Address(pre(sp, -2 * wordSize)));
1957
1958 mov(rscratch1, entry_point);
1959 blr(rscratch1);
1960 if (retaddr)
1961 bind(*retaddr);
1962
1963 ldp(rscratch1, rmethod, Address(post(sp, 2 * wordSize)));
1964 }
1965
1966 void MacroAssembler::call_VM_leaf(address entry_point, int number_of_arguments) {
1967 call_VM_leaf_base(entry_point, number_of_arguments);
1968 }
1969
1970 void MacroAssembler::call_VM_leaf(address entry_point, Register arg_0) {
1971 pass_arg0(this, arg_0);
1972 call_VM_leaf_base(entry_point, 1);
1973 }
1974
1975 void MacroAssembler::call_VM_leaf(address entry_point, Register arg_0, Register arg_1) {
1976 assert_different_registers(arg_1, c_rarg0);
1977 pass_arg0(this, arg_0);
1978 pass_arg1(this, arg_1);
1979 call_VM_leaf_base(entry_point, 2);
1980 }
1981
1982 void MacroAssembler::call_VM_leaf(address entry_point, Register arg_0,
5307 ThreadInVMfromUnknown tiv;
5308 assert(oop_recorder() != nullptr, "this assembler needs an OopRecorder");
5309 assert(Universe::heap()->is_in(JNIHandles::resolve(obj)), "not an oop");
5310 }
5311 #endif
5312 int oop_index = oop_recorder()->find_index(obj);
5313 return Address((address)obj, oop_Relocation::spec(oop_index));
5314 }
5315
5316 // Defines obj, preserves var_size_in_bytes, okay for t2 == var_size_in_bytes.
5317 void MacroAssembler::tlab_allocate(Register obj,
5318 Register var_size_in_bytes,
5319 int con_size_in_bytes,
5320 Register t1,
5321 Register t2,
5322 Label& slow_case) {
5323 BarrierSetAssembler *bs = BarrierSet::barrier_set()->barrier_set_assembler();
5324 bs->tlab_allocate(this, obj, var_size_in_bytes, con_size_in_bytes, t1, t2, slow_case);
5325 }
5326
5327 void MacroAssembler::verify_tlab() {
5328 #ifdef ASSERT
5329 if (UseTLAB && VerifyOops) {
5330 Label next, ok;
5331
5332 stp(rscratch2, rscratch1, Address(pre(sp, -16)));
5333
5334 ldr(rscratch2, Address(rthread, in_bytes(JavaThread::tlab_top_offset())));
5335 ldr(rscratch1, Address(rthread, in_bytes(JavaThread::tlab_start_offset())));
5336 cmp(rscratch2, rscratch1);
5337 br(Assembler::HS, next);
5338 STOP("assert(top >= start)");
5339 should_not_reach_here();
5340
5341 bind(next);
5342 ldr(rscratch2, Address(rthread, in_bytes(JavaThread::tlab_end_offset())));
5343 ldr(rscratch1, Address(rthread, in_bytes(JavaThread::tlab_top_offset())));
5344 cmp(rscratch2, rscratch1);
5345 br(Assembler::HS, ok);
5346 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
1935 // cf. TemplateTable::prepare_invoke(), if (load_receiver).
1936 int stackElementSize = Interpreter::stackElementSize;
1937 int offset = Interpreter::expr_offset_in_bytes(extra_slot_offset+0);
1938 #ifdef ASSERT
1939 int offset1 = Interpreter::expr_offset_in_bytes(extra_slot_offset+1);
1940 assert(offset1 - offset == stackElementSize, "correct arithmetic");
1941 #endif
1942 if (arg_slot.is_constant()) {
1943 return Address(esp, arg_slot.as_constant() * stackElementSize
1944 + offset);
1945 } else {
1946 add(rscratch1, esp, arg_slot.as_register(),
1947 ext::uxtx, exact_log2(stackElementSize));
1948 return Address(rscratch1, offset);
1949 }
1950 }
1951
1952 void MacroAssembler::call_VM_leaf_base(address entry_point,
1953 int number_of_arguments,
1954 Label *retaddr) {
1955 Label not_preempted;
1956
1957 stp(rscratch1, rmethod, Address(pre(sp, -2 * wordSize)));
1958 str(zr, Address(rthread, JavaThread::preempt_alternate_return_offset()));
1959
1960 mov(rscratch1, entry_point);
1961 blr(rscratch1);
1962 if (retaddr)
1963 bind(*retaddr);
1964
1965 if (entry_point == CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter) ||
1966 entry_point == CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter_obj)) {
1967 ldr(rscratch1, Address(rthread, JavaThread::preempt_alternate_return_offset()));
1968 cbz(rscratch1, not_preempted);
1969 str(zr, Address(rthread, JavaThread::preempt_alternate_return_offset()));
1970 br(rscratch1);
1971 }
1972
1973 bind(not_preempted);
1974 ldp(rscratch1, rmethod, Address(post(sp, 2 * wordSize)));
1975 }
1976
1977 void MacroAssembler::call_VM_leaf(address entry_point, int number_of_arguments) {
1978 call_VM_leaf_base(entry_point, number_of_arguments);
1979 }
1980
1981 void MacroAssembler::call_VM_leaf(address entry_point, Register arg_0) {
1982 pass_arg0(this, arg_0);
1983 call_VM_leaf_base(entry_point, 1);
1984 }
1985
1986 void MacroAssembler::call_VM_leaf(address entry_point, Register arg_0, Register arg_1) {
1987 assert_different_registers(arg_1, c_rarg0);
1988 pass_arg0(this, arg_0);
1989 pass_arg1(this, arg_1);
1990 call_VM_leaf_base(entry_point, 2);
1991 }
1992
1993 void MacroAssembler::call_VM_leaf(address entry_point, Register arg_0,
5318 ThreadInVMfromUnknown tiv;
5319 assert(oop_recorder() != nullptr, "this assembler needs an OopRecorder");
5320 assert(Universe::heap()->is_in(JNIHandles::resolve(obj)), "not an oop");
5321 }
5322 #endif
5323 int oop_index = oop_recorder()->find_index(obj);
5324 return Address((address)obj, oop_Relocation::spec(oop_index));
5325 }
5326
5327 // Defines obj, preserves var_size_in_bytes, okay for t2 == var_size_in_bytes.
5328 void MacroAssembler::tlab_allocate(Register obj,
5329 Register var_size_in_bytes,
5330 int con_size_in_bytes,
5331 Register t1,
5332 Register t2,
5333 Label& slow_case) {
5334 BarrierSetAssembler *bs = BarrierSet::barrier_set()->barrier_set_assembler();
5335 bs->tlab_allocate(this, obj, var_size_in_bytes, con_size_in_bytes, t1, t2, slow_case);
5336 }
5337
5338 void MacroAssembler::inc_held_monitor_count() {
5339 Address dst = Address(rthread, JavaThread::held_monitor_count_offset());
5340 #ifdef ASSERT
5341 ldr(rscratch2, dst);
5342 increment(rscratch2);
5343 str(rscratch2, dst);
5344 Label ok;
5345 tbz(rscratch2, 63, ok);
5346 STOP("assert(held monitor count underflow)");
5347 should_not_reach_here();
5348 bind(ok);
5349 #else
5350 increment(dst);
5351 #endif
5352 }
5353
5354 void MacroAssembler::dec_held_monitor_count() {
5355 Address dst = Address(rthread, JavaThread::held_monitor_count_offset());
5356 #ifdef ASSERT
5357 ldr(rscratch2, dst);
5358 decrement(rscratch2);
5359 str(rscratch2, dst);
5360 Label ok;
5361 tbz(rscratch2, 63, ok);
5362 STOP("assert(held monitor count underflow)");
5363 should_not_reach_here();
5364 bind(ok);
5365 #else
5366 decrement(dst);
5367 #endif
5368 }
5369
5370 void MacroAssembler::verify_tlab() {
5371 #ifdef ASSERT
5372 if (UseTLAB && VerifyOops) {
5373 Label next, ok;
5374
5375 stp(rscratch2, rscratch1, Address(pre(sp, -16)));
5376
5377 ldr(rscratch2, Address(rthread, in_bytes(JavaThread::tlab_top_offset())));
5378 ldr(rscratch1, Address(rthread, in_bytes(JavaThread::tlab_start_offset())));
5379 cmp(rscratch2, rscratch1);
5380 br(Assembler::HS, next);
5381 STOP("assert(top >= start)");
5382 should_not_reach_here();
5383
5384 bind(next);
5385 ldr(rscratch2, Address(rthread, in_bytes(JavaThread::tlab_end_offset())));
5386 ldr(rscratch1, Address(rthread, in_bytes(JavaThread::tlab_top_offset())));
5387 cmp(rscratch2, rscratch1);
5388 br(Assembler::HS, ok);
5389 STOP("assert(top <= end)");
|