1 /* 2 * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. 3 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. 4 */ 5 6 #include "precompiled.hpp" 7 #include "gc/z/zAddress.inline.hpp" 8 #include "gc/z/zGlobals.hpp" 9 #include "unittest.hpp" 10 11 class ZAddressTest : public ::testing::Test { 12 protected: 13 static void is_good_bit(uintptr_t bit_mask) { 14 // Setup 15 uintptr_t mask_before = ZAddressGoodMask; 16 17 ZAddressMasks::set_good_mask(bit_mask); 18 19 // Test that a pointer with only the given bit is considered good. 20 EXPECT_EQ(ZAddress::is_good(ZAddressMetadataMarked0), (bit_mask == ZAddressMetadataMarked0)); 21 EXPECT_EQ(ZAddress::is_good(ZAddressMetadataMarked1), (bit_mask == ZAddressMetadataMarked1)); 22 EXPECT_EQ(ZAddress::is_good(ZAddressMetadataRemapped), (bit_mask == ZAddressMetadataRemapped)); 23 24 // Test that a pointer with the given bit and some extra bits is considered good. 25 EXPECT_EQ(ZAddress::is_good(ZAddressMetadataMarked0 | 0x8),(bit_mask == ZAddressMetadataMarked0)); 26 EXPECT_EQ(ZAddress::is_good(ZAddressMetadataMarked1 | 0x8), (bit_mask == ZAddressMetadataMarked1)); 27 EXPECT_EQ(ZAddress::is_good(ZAddressMetadataRemapped | 0x8), (bit_mask == ZAddressMetadataRemapped)); 28 29 // Test that null is not considered good. 30 EXPECT_FALSE(ZAddress::is_good(0)); 31 32 // Teardown 33 ZAddressMasks::set_good_mask(mask_before); 34 } 35 36 static void is_good_or_null_bit(uintptr_t bit_mask) { 37 // Setup 38 uintptr_t mask_before = ZAddressGoodMask; 39 40 ZAddressMasks::set_good_mask(bit_mask); 41 42 // Test that a pointer with only the given bit is considered good. 43 EXPECT_EQ(ZAddress::is_good_or_null(ZAddressMetadataMarked0), (bit_mask == ZAddressMetadataMarked0)); 44 EXPECT_EQ(ZAddress::is_good_or_null(ZAddressMetadataMarked1), (bit_mask == ZAddressMetadataMarked1)); 45 EXPECT_EQ(ZAddress::is_good_or_null(ZAddressMetadataRemapped), (bit_mask == ZAddressMetadataRemapped)); 46 47 // Test that a pointer with the given bit and some extra bits is considered good. 48 EXPECT_EQ(ZAddress::is_good_or_null(ZAddressMetadataMarked0 | 0x8), (bit_mask == ZAddressMetadataMarked0)); 49 EXPECT_EQ(ZAddress::is_good_or_null(ZAddressMetadataMarked1 | 0x8), (bit_mask == ZAddressMetadataMarked1)); 50 EXPECT_EQ(ZAddress::is_good_or_null(ZAddressMetadataRemapped | 0x8), (bit_mask == ZAddressMetadataRemapped)); 51 52 // Test that null is considered good_or_null. 53 EXPECT_TRUE(ZAddress::is_good_or_null(0)); 54 55 // Teardown 56 ZAddressMasks::set_good_mask(mask_before); 57 } 58 59 static void finalizable() { 60 // Setup 61 ZAddressMasks::initialize(); 62 ZAddressMasks::flip_to_marked(); 63 64 // Test that a normal good pointer is good and weak good, but not finalizable 65 const uintptr_t addr1 = ZAddress::good(1); 66 EXPECT_FALSE(ZAddress::is_finalizable(addr1)); 67 EXPECT_TRUE(ZAddress::is_marked(addr1)); 68 EXPECT_FALSE(ZAddress::is_remapped(addr1)); 69 EXPECT_TRUE(ZAddress::is_weak_good(addr1)); 70 EXPECT_TRUE(ZAddress::is_weak_good_or_null(addr1)); 71 EXPECT_TRUE(ZAddress::is_good(addr1)); 72 EXPECT_TRUE(ZAddress::is_good_or_null(addr1)); 73 74 // Test that a finalizable good pointer is finalizable and weak good, but not good 75 const uintptr_t addr2 = ZAddress::finalizable_good(1); 76 EXPECT_TRUE(ZAddress::is_finalizable(addr2)); 77 EXPECT_TRUE(ZAddress::is_marked(addr2)); 78 EXPECT_FALSE(ZAddress::is_remapped(addr2)); 79 EXPECT_TRUE(ZAddress::is_weak_good(addr2)); 80 EXPECT_TRUE(ZAddress::is_weak_good_or_null(addr2)); 81 EXPECT_FALSE(ZAddress::is_good(addr2)); 82 EXPECT_FALSE(ZAddress::is_good_or_null(addr2)); 83 84 // Flip to remapped and test that it's no longer weak good 85 ZAddressMasks::flip_to_remapped(); 86 EXPECT_TRUE(ZAddress::is_finalizable(addr2)); 87 EXPECT_TRUE(ZAddress::is_marked(addr2)); 88 EXPECT_FALSE(ZAddress::is_remapped(addr2)); 89 EXPECT_FALSE(ZAddress::is_weak_good(addr2)); 90 EXPECT_FALSE(ZAddress::is_weak_good_or_null(addr2)); 91 EXPECT_FALSE(ZAddress::is_good(addr2)); 92 EXPECT_FALSE(ZAddress::is_good_or_null(addr2)); 93 } 94 }; 95 96 TEST_F(ZAddressTest, is_good) { 97 is_good_bit(ZAddressMetadataMarked0); 98 is_good_bit(ZAddressMetadataMarked1); 99 is_good_bit(ZAddressMetadataRemapped); 100 } 101 102 TEST_F(ZAddressTest, is_good_or_null) { 103 is_good_or_null_bit(ZAddressMetadataMarked0); 104 is_good_or_null_bit(ZAddressMetadataMarked1); 105 is_good_or_null_bit(ZAddressMetadataRemapped); 106 } 107 108 TEST_F(ZAddressTest, is_weak_good_or_null) { 109 #define check_is_weak_good_or_null(value) \ 110 EXPECT_EQ(ZAddress::is_weak_good_or_null(value), \ 111 (ZAddress::is_good_or_null(value) || ZAddress::is_remapped(value))) \ 112 << "is_good_or_null: " << ZAddress::is_good_or_null(value) \ 113 << " is_remaped: " << ZAddress::is_remapped(value) \ 114 << " is_good_or_null_or_remapped: " << ZAddress::is_weak_good_or_null(value) 115 116 check_is_weak_good_or_null((uintptr_t)NULL); 117 check_is_weak_good_or_null(ZAddressMetadataMarked0); 118 check_is_weak_good_or_null(ZAddressMetadataMarked1); 119 check_is_weak_good_or_null(ZAddressMetadataRemapped); 120 check_is_weak_good_or_null((uintptr_t)0x123); 121 } 122 123 TEST_F(ZAddressTest, finalizable) { 124 finalizable(); 125 }