1 /* 2 * Copyright (c) 2019, 2023, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_OOPS_COMPRESSEDKLASS_HPP 26 #define SHARE_OOPS_COMPRESSEDKLASS_HPP 27 28 #include "memory/allStatic.hpp" 29 #include "utilities/globalDefinitions.hpp" 30 31 class outputStream; 32 class Klass; 33 34 // If compressed klass pointers then use narrowKlass. 35 typedef juint narrowKlass; 36 37 const int LogKlassAlignmentInBytes = 3; 38 const int KlassAlignmentInBytes = 1 << LogKlassAlignmentInBytes; 39 40 // Maximal size of compressed class space. Above this limit compression is not possible. 41 // Also upper bound for placement of zero based class space. (Class space is further limited 42 // to be < 3G, see arguments.cpp.) 43 const uint64_t KlassEncodingMetaspaceMax = (uint64_t(max_juint) + 1) << LogKlassAlignmentInBytes; 44 45 // For UseCompressedClassPointers. 46 class CompressedKlassPointers : public AllStatic { 47 friend class VMStructs; 48 friend class ArchiveBuilder; 49 50 static address _base; 51 static int _shift; 52 53 // Together with base, this defines the address range within which Klass 54 // structures will be located: [base, base+range). While the maximal 55 // possible encoding range is 4|32G for shift 0|3, if we know beforehand 56 // the expected range of Klass* pointers will be smaller, a platform 57 // could use this info to optimize encoding. 58 static size_t _range; 59 60 // Helper function for common cases. 61 static char* reserve_address_space_X(uintptr_t from, uintptr_t to, size_t size, size_t alignment, bool aslr); 62 static char* reserve_address_space_for_unscaled_encoding(size_t size, bool aslr); 63 static char* reserve_address_space_for_zerobased_encoding(size_t size, bool aslr); 64 static char* reserve_address_space_for_16bit_move(size_t size, bool aslr); 65 66 DEBUG_ONLY(static void assert_is_valid_encoding(address addr, size_t len, address base, int shift);) 67 68 static inline Klass* decode_not_null_without_asserts(narrowKlass v, address base, int shift); 69 static inline Klass* decode_not_null(narrowKlass v, address base, int shift); 70 71 static inline narrowKlass encode_not_null(Klass* v, address base, int shift); 72 73 public: 74 75 // Reserve a range of memory that is to contain Klass strucutures which are referenced by narrow Klass IDs. 76 // If optimize_for_zero_base is true, the implementation will attempt to reserve optimized for zero-based encoding. 77 static char* reserve_address_space_for_compressed_classes(size_t size, bool aslr, bool optimize_for_zero_base); 78 79 // Given a klass range [addr, addr+len) and a given encoding scheme, assert that this scheme covers the range, then 80 // set this encoding scheme. Used by CDS at runtime to re-instate the scheme used to pre-compute klass ids for 81 // archived heap objects. In this case, we don't have the freedom to choose base and shift; they are handed to 82 // us from CDS. 83 static void initialize_for_given_encoding(address addr, size_t len, address requested_base, int requested_shift); 84 85 // Given an address range [addr, addr+len) which the encoding is supposed to 86 // cover, choose base, shift and range. 87 // The address range is the expected range of uncompressed Klass pointers we 88 // will encounter (and the implicit promise that there will be no Klass 89 // structures outside this range). 90 static void initialize(address addr, size_t len); 91 92 static void print_mode(outputStream* st); 93 94 static address base() { return _base; } 95 static size_t range() { return _range; } 96 static int shift() { return _shift; } 97 98 static bool is_null(Klass* v) { return v == nullptr; } 99 static bool is_null(narrowKlass v) { return v == 0; } 100 101 // Versions without asserts 102 static inline Klass* decode_not_null_without_asserts(narrowKlass v); 103 static inline Klass* decode_without_asserts(narrowKlass v); 104 105 static inline Klass* decode_not_null(narrowKlass v); 106 static inline Klass* decode(narrowKlass v); 107 108 static inline narrowKlass encode_not_null(Klass* v); 109 static inline narrowKlass encode(Klass* v); 110 }; 111 112 #endif // SHARE_OOPS_COMPRESSEDKLASS_HPP --- EOF ---