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 }