2272 }
2273 }
2274
2275 void MacroAssembler::store_klass_gap(Register dst, Register src) {
2276 if (UseCompressedClassPointers) {
2277 // Store to klass gap in destination
2278 sw(src, Address(dst, oopDesc::klass_gap_offset_in_bytes()));
2279 }
2280 }
2281
2282 void MacroAssembler::decode_klass_not_null(Register r, Register tmp) {
2283 assert_different_registers(r, tmp);
2284 decode_klass_not_null(r, r, tmp);
2285 }
2286
2287 void MacroAssembler::decode_klass_not_null(Register dst, Register src, Register tmp) {
2288 assert(UseCompressedClassPointers, "should only be used for compressed headers");
2289
2290 if (CompressedKlassPointers::base() == nullptr) {
2291 if (CompressedKlassPointers::shift() != 0) {
2292 assert(LogKlassAlignmentInBytes == CompressedKlassPointers::shift(), "decode alg wrong");
2293 slli(dst, src, LogKlassAlignmentInBytes);
2294 } else {
2295 mv(dst, src);
2296 }
2297 return;
2298 }
2299
2300 Register xbase = dst;
2301 if (dst == src) {
2302 xbase = tmp;
2303 }
2304
2305 assert_different_registers(src, xbase);
2306 mv(xbase, (uintptr_t)CompressedKlassPointers::base());
2307
2308 if (CompressedKlassPointers::shift() != 0) {
2309 assert(LogKlassAlignmentInBytes == CompressedKlassPointers::shift(), "decode alg wrong");
2310 assert_different_registers(t0, xbase);
2311 shadd(dst, src, xbase, t0, LogKlassAlignmentInBytes);
2312 } else {
2313 add(dst, xbase, src);
2314 }
2315 }
2316
2317 void MacroAssembler::encode_klass_not_null(Register r, Register tmp) {
2318 assert_different_registers(r, tmp);
2319 encode_klass_not_null(r, r, tmp);
2320 }
2321
2322 void MacroAssembler::encode_klass_not_null(Register dst, Register src, Register tmp) {
2323 assert(UseCompressedClassPointers, "should only be used for compressed headers");
2324
2325 if (CompressedKlassPointers::base() == nullptr) {
2326 if (CompressedKlassPointers::shift() != 0) {
2327 assert(LogKlassAlignmentInBytes == CompressedKlassPointers::shift(), "decode alg wrong");
2328 srli(dst, src, LogKlassAlignmentInBytes);
2329 } else {
2330 mv(dst, src);
2331 }
2332 return;
2333 }
2334
2335 if (((uint64_t)CompressedKlassPointers::base() & 0xffffffff) == 0 &&
2336 CompressedKlassPointers::shift() == 0) {
2337 zero_extend(dst, src, 32);
2338 return;
2339 }
2340
2341 Register xbase = dst;
2342 if (dst == src) {
2343 xbase = tmp;
2344 }
2345
2346 assert_different_registers(src, xbase);
2347 mv(xbase, (uintptr_t)CompressedKlassPointers::base());
2348 sub(dst, src, xbase);
2349 if (CompressedKlassPointers::shift() != 0) {
2350 assert(LogKlassAlignmentInBytes == CompressedKlassPointers::shift(), "decode alg wrong");
2351 srli(dst, dst, LogKlassAlignmentInBytes);
2352 }
2353 }
2354
2355 void MacroAssembler::decode_heap_oop_not_null(Register r) {
2356 decode_heap_oop_not_null(r, r);
2357 }
2358
2359 void MacroAssembler::decode_heap_oop_not_null(Register dst, Register src) {
2360 assert(UseCompressedOops, "should only be used for compressed headers");
2361 assert(Universe::heap() != nullptr, "java heap should be initialized");
2362 // Cannot assert, unverified entry point counts instructions (see .ad file)
2363 // vtableStubs also counts instructions in pd_code_size_limit.
2364 // Also do not verify_oop as this is called by verify_oop.
2365 if (CompressedOops::shift() != 0) {
2366 assert(LogMinObjAlignmentInBytes == CompressedOops::shift(), "decode alg wrong");
2367 slli(dst, src, LogMinObjAlignmentInBytes);
2368 if (CompressedOops::base() != nullptr) {
2369 add(dst, xheapbase, dst);
2370 }
2371 } else {
|
2272 }
2273 }
2274
2275 void MacroAssembler::store_klass_gap(Register dst, Register src) {
2276 if (UseCompressedClassPointers) {
2277 // Store to klass gap in destination
2278 sw(src, Address(dst, oopDesc::klass_gap_offset_in_bytes()));
2279 }
2280 }
2281
2282 void MacroAssembler::decode_klass_not_null(Register r, Register tmp) {
2283 assert_different_registers(r, tmp);
2284 decode_klass_not_null(r, r, tmp);
2285 }
2286
2287 void MacroAssembler::decode_klass_not_null(Register dst, Register src, Register tmp) {
2288 assert(UseCompressedClassPointers, "should only be used for compressed headers");
2289
2290 if (CompressedKlassPointers::base() == nullptr) {
2291 if (CompressedKlassPointers::shift() != 0) {
2292 slli(dst, src, CompressedKlassPointers::shift());
2293 } else {
2294 mv(dst, src);
2295 }
2296 return;
2297 }
2298
2299 Register xbase = dst;
2300 if (dst == src) {
2301 xbase = tmp;
2302 }
2303
2304 assert_different_registers(src, xbase);
2305 mv(xbase, (uintptr_t)CompressedKlassPointers::base());
2306
2307 if (CompressedKlassPointers::shift() != 0) {
2308 assert_different_registers(t0, xbase);
2309 shadd(dst, src, xbase, t0, CompressedKlassPointers::shift());
2310 } else {
2311 add(dst, xbase, src);
2312 }
2313 }
2314
2315 void MacroAssembler::encode_klass_not_null(Register r, Register tmp) {
2316 assert_different_registers(r, tmp);
2317 encode_klass_not_null(r, r, tmp);
2318 }
2319
2320 void MacroAssembler::encode_klass_not_null(Register dst, Register src, Register tmp) {
2321 assert(UseCompressedClassPointers, "should only be used for compressed headers");
2322
2323 if (CompressedKlassPointers::base() == nullptr) {
2324 if (CompressedKlassPointers::shift() != 0) {
2325 srli(dst, src, CompressedKlassPointers::shift());
2326 } else {
2327 mv(dst, src);
2328 }
2329 return;
2330 }
2331
2332 if (((uint64_t)CompressedKlassPointers::base() & 0xffffffff) == 0 &&
2333 CompressedKlassPointers::shift() == 0) {
2334 zero_extend(dst, src, 32);
2335 return;
2336 }
2337
2338 Register xbase = dst;
2339 if (dst == src) {
2340 xbase = tmp;
2341 }
2342
2343 assert_different_registers(src, xbase);
2344 mv(xbase, (uintptr_t)CompressedKlassPointers::base());
2345 sub(dst, src, xbase);
2346 if (CompressedKlassPointers::shift() != 0) {
2347 srli(dst, dst, CompressedKlassPointers::shift());
2348 }
2349 }
2350
2351 void MacroAssembler::decode_heap_oop_not_null(Register r) {
2352 decode_heap_oop_not_null(r, r);
2353 }
2354
2355 void MacroAssembler::decode_heap_oop_not_null(Register dst, Register src) {
2356 assert(UseCompressedOops, "should only be used for compressed headers");
2357 assert(Universe::heap() != nullptr, "java heap should be initialized");
2358 // Cannot assert, unverified entry point counts instructions (see .ad file)
2359 // vtableStubs also counts instructions in pd_code_size_limit.
2360 // Also do not verify_oop as this is called by verify_oop.
2361 if (CompressedOops::shift() != 0) {
2362 assert(LogMinObjAlignmentInBytes == CompressedOops::shift(), "decode alg wrong");
2363 slli(dst, src, LogMinObjAlignmentInBytes);
2364 if (CompressedOops::base() != nullptr) {
2365 add(dst, xheapbase, dst);
2366 }
2367 } else {
|