1 /*
  2  * Copyright (c) 2024, 2025, Red Hat, Inc. All rights reserved.
  3  * Copyright (c) 2024, 2025, Oracle and/or its affiliates. All rights reserved.
  4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  5  *
  6  * This code is free software; you can redistribute it and/or modify it
  7  * under the terms of the GNU General Public License version 2 only, as
  8  * published by the Free Software Foundation.
  9  *
 10  * This code is distributed in the hope that it will be useful, but WITHOUT
 11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 13  * version 2 for more details (a copy is included in the LICENSE file that
 14  * accompanied this code).
 15  *
 16  * You should have received a copy of the GNU General Public License version
 17  * 2 along with this work; if not, write to the Free Software Foundation,
 18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 19  *
 20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 21  * or visit www.oracle.com if you need additional information or have any
 22  * questions.
 23  */
 24 
 25 #include "classfile/vmClasses.hpp"
 26 #include "oops/compressedKlass.inline.hpp"
 27 #include "utilities/globalDefinitions.hpp"
 28 
 29 #include "unittest.hpp"
 30 
 31 TEST_VM(CompressedKlass, basics) {
 32   if (!UseCompressedClassPointers) {
 33     return;
 34   }
 35   ASSERT_LE((address)0, CompressedKlassPointers::base());
 36   ASSERT_LE(CompressedKlassPointers::base(), CompressedKlassPointers::klass_range_start());
 37   ASSERT_LT(CompressedKlassPointers::klass_range_start(), CompressedKlassPointers::klass_range_end());
 38   ASSERT_LE(CompressedKlassPointers::klass_range_end(), CompressedKlassPointers::encoding_range_end());
 39 
 40   switch (CompressedKlassPointers::shift()) {
 41   case 0:
 42     ASSERT_EQ(CompressedKlassPointers::encoding_range_end() - CompressedKlassPointers::base(), (ptrdiff_t)(4 * G));
 43     break;
 44   case 3:
 45     ASSERT_EQ(CompressedKlassPointers::encoding_range_end() - CompressedKlassPointers::base(), (ptrdiff_t)(32 * G));
 46     break;
 47   default:
 48     const size_t expected_size = nth_bit(CompressedKlassPointers::narrow_klass_pointer_bits() + CompressedKlassPointers::shift());
 49     ASSERT_EQ(CompressedKlassPointers::encoding_range_end() - CompressedKlassPointers::base(), (ptrdiff_t)expected_size);
 50   }
 51 }
 52 
 53 TEST_VM(CompressedKlass, ccp_off) {
 54   if (UseCompressedClassPointers) {
 55     return;
 56   }
 57   ASSERT_EQ(CompressedKlassPointers::klass_range_start(), (address)nullptr);
 58   ASSERT_EQ(CompressedKlassPointers::klass_range_end(), (address)nullptr);
 59   // We should be able to call CompressedKlassPointers::is_encodable, and it should
 60   // always return false
 61   ASSERT_FALSE(CompressedKlassPointers::is_encodable((address)0x12345));
 62 }
 63 
 64 
 65 TEST_VM(CompressedKlass, test_too_low_address) {
 66   if (!UseCompressedClassPointers) {
 67     return;
 68   }
 69   address really_low = (address) 32;
 70   ASSERT_FALSE(CompressedKlassPointers::is_encodable(really_low));
 71   address low = CompressedKlassPointers::klass_range_start() - 1;
 72   ASSERT_FALSE(CompressedKlassPointers::is_encodable(low));
 73 }
 74 
 75 TEST_VM(CompressedKlass, test_too_high_address) {
 76   if (!UseCompressedClassPointers) {
 77     return;
 78   }
 79   address really_high = (address) UINTPTR_MAX;
 80   ASSERT_FALSE(CompressedKlassPointers::is_encodable(really_high));
 81   address high = CompressedKlassPointers::klass_range_end();
 82   ASSERT_FALSE(CompressedKlassPointers::is_encodable(high));
 83 }
 84 
 85 TEST_VM(CompressedKlass, test_unaligned_address) {
 86   if (!UseCompressedClassPointers) {
 87     return;
 88   }
 89   const size_t alignment = CompressedKlassPointers::klass_alignment_in_bytes();
 90   address addr = CompressedKlassPointers::klass_range_start() + alignment - 1;
 91   ASSERT_FALSE(CompressedKlassPointers::is_encodable(addr));
 92   // Try word-aligned, but not sufficiently aligned
 93   if (alignment > BytesPerWord) {
 94     addr = CompressedKlassPointers::klass_range_start() + BytesPerWord;
 95     ASSERT_FALSE(CompressedKlassPointers::is_encodable(addr));
 96   }
 97   addr = CompressedKlassPointers::klass_range_end() - 1;
 98   ASSERT_FALSE(CompressedKlassPointers::is_encodable(addr));
 99 }
100 
101 TEST_VM(CompressedKlass, test_good_address) {
102   if (!UseCompressedClassPointers) {
103     return;
104   }
105   const size_t alignment = CompressedKlassPointers::klass_alignment_in_bytes();
106   address addr = CompressedKlassPointers::klass_range_start();
107   ASSERT_TRUE(CompressedKlassPointers::is_encodable(addr));
108   addr = CompressedKlassPointers::klass_range_end() - alignment;
109   ASSERT_TRUE(CompressedKlassPointers::is_encodable(addr));
110 }
111 
112 TEST_VM(CompressedKlass, test_is_valid_narrow_klass) {
113   if (!UseCompressedClassPointers) {
114     return;
115   }
116   ASSERT_FALSE(CompressedKlassPointers::is_valid_narrow_klass_id(0));
117   narrowKlass nk_jlC = CompressedKlassPointers::encode((Klass*)vmClasses::Class_klass());
118   ASSERT_TRUE(CompressedKlassPointers::is_valid_narrow_klass_id(nk_jlC));
119   if (CompressedClassSpaceSize < 4 * G && CompressedKlassPointers::base() != nullptr) {
120     ASSERT_FALSE(CompressedKlassPointers::is_valid_narrow_klass_id(0xFFFFFFFF));
121   }
122 }