Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/java.hpp @ 1091:6aa7255741f3
6906727: UseCompressedOops: some card-marking fixes related to object arrays
Summary: Introduced a new write_ref_array(HeapWords* start, size_t count) method that does the requisite MemRegion range calculation so (some of the) clients of the erstwhile write_ref_array(MemRegion mr) do not need to worry. This removed all external uses of array_size(), which was also simplified and made private. Asserts were added to catch other possible issues. Further, less essential, fixes stemming from this investigation are deferred to CR 6904516 (to follow shortly in hs17).
Reviewed-by: kvn, coleenp, jmasa
| author | ysr |
|---|---|
| date | Thu, 03 Dec 2009 15:01:57 -0800 |
| parents | d95b224e9f17 |
| children | c18cbe5936b8 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 196 | 2 * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved. |
| 0 | 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 // Register function to be called by before_exit | |
| 26 extern "C" { void register_on_exit_function(void (*func)(void)) ;} | |
| 27 | |
| 28 // Execute code before all handles are released and thread is killed; prologue to vm_exit | |
| 29 extern void before_exit(JavaThread * thread); | |
| 30 | |
| 31 // Forced VM exit (i.e, internal error or JVM_Exit) | |
| 32 extern void vm_exit(int code); | |
| 33 | |
| 34 // Wrapper for ::exit() | |
| 35 extern void vm_direct_exit(int code); | |
| 36 | |
| 37 // Shutdown the VM but do not exit the process | |
| 38 extern void vm_shutdown(); | |
| 39 // Shutdown the VM and abort the process | |
|
227
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
176
diff
changeset
|
40 extern void vm_abort(bool dump_core=true); |
| 0 | 41 |
| 42 // Trigger any necessary notification of the VM being shutdown | |
| 43 extern void notify_vm_shutdown(); | |
| 44 | |
| 45 // VM exit if error occurs during initialization of VM | |
| 46 extern void vm_exit_during_initialization(Handle exception); | |
| 47 extern void vm_exit_during_initialization(symbolHandle exception_name, const char* message); | |
| 48 extern void vm_exit_during_initialization(const char* error, const char* message = NULL); | |
| 49 extern void vm_shutdown_during_initialization(const char* error, const char* message = NULL); | |
| 50 | |
| 242 | 51 /** |
| 52 * Discovering the JDK_Version during initialization is tricky when the | |
| 53 * running JDK is less than JDK6. For JDK6 and greater, a "GetVersion" | |
| 54 * function exists in libjava.so and we simply call it during the | |
| 55 * 'initialize()' call to find the version. For JDKs with version < 6, no | |
| 56 * such call exists and we have to probe the JDK in order to determine | |
| 57 * the exact version. This probing cannot happen during late in | |
| 58 * the VM initialization process so there's a period of time during | |
| 59 * initialization when we don't know anything about the JDK version other than | |
| 60 * that it less than version 6. This is the "partially initialized" time, | |
| 61 * when we can answer only certain version queries (such as, is the JDK | |
| 62 * version greater than 5? Answer: no). Once the JDK probing occurs, we | |
| 63 * know the version and are considered fully initialized. | |
| 64 */ | |
| 65 class JDK_Version VALUE_OBJ_CLASS_SPEC { | |
| 0 | 66 friend class VMStructs; |
| 242 | 67 friend class Universe; |
| 68 friend void JDK_Version_init(); | |
| 0 | 69 private: |
| 242 | 70 |
| 71 static JDK_Version _current; | |
| 72 | |
| 73 // In this class, we promote the minor version of release to be the | |
| 74 // major version for releases >= 5 in anticipation of the JDK doing the | |
| 75 // same thing. For example, we represent "1.5.0" as major version 5 (we | |
| 76 // drop the leading 1 and use 5 as the 'major'). | |
| 77 | |
| 78 uint8_t _major; | |
| 79 uint8_t _minor; | |
| 80 uint8_t _micro; | |
| 81 uint8_t _update; | |
| 82 uint8_t _special; | |
| 83 uint8_t _build; | |
| 84 | |
| 85 // If partially initialized, the above fields are invalid and we know | |
| 86 // that we're less than major version 6. | |
| 87 bool _partially_initialized; | |
| 88 | |
| 89 bool _thread_park_blocker; | |
| 90 | |
| 91 bool is_valid() const { | |
| 92 return (_major != 0 || _partially_initialized); | |
| 93 } | |
| 94 | |
| 95 // initializes or partially initializes the _current static field | |
| 96 static void initialize(); | |
| 97 | |
| 98 // Completes initialization for a pre-JDK6 version. | |
| 99 static void fully_initialize(uint8_t major, uint8_t minor = 0, | |
| 100 uint8_t micro = 0, uint8_t update = 0); | |
| 0 | 101 |
| 102 public: | |
| 242 | 103 |
| 104 // Returns true if the the current version has only been partially initialized | |
| 105 static bool is_partially_initialized() { | |
| 106 return _current._partially_initialized; | |
| 107 } | |
| 108 | |
| 109 JDK_Version() : _major(0), _minor(0), _micro(0), _update(0), | |
| 110 _special(0), _build(0), _partially_initialized(false), | |
| 111 _thread_park_blocker(false) {} | |
| 0 | 112 |
| 242 | 113 JDK_Version(uint8_t major, uint8_t minor = 0, uint8_t micro = 0, |
| 114 uint8_t update = 0, uint8_t special = 0, uint8_t build = 0, | |
| 115 bool thread_park_blocker = false) : | |
| 116 _major(major), _minor(minor), _micro(micro), _update(update), | |
| 117 _special(special), _build(build), _partially_initialized(false), | |
| 118 _thread_park_blocker(thread_park_blocker) {} | |
|
176
6b648fefb395
6705523: Fix for 6695506 will violate spec when used in JDK6
kamg
parents:
0
diff
changeset
|
119 |
| 242 | 120 // Returns the current running JDK version |
| 121 static JDK_Version current() { return _current; } | |
| 122 | |
| 123 // Factory methods for convenience | |
| 124 static JDK_Version jdk(uint8_t m) { | |
| 125 return JDK_Version(m); | |
| 126 } | |
| 127 | |
| 128 static JDK_Version jdk_update(uint8_t major, uint8_t update_number) { | |
| 129 return JDK_Version(major, 0, 0, update_number); | |
|
176
6b648fefb395
6705523: Fix for 6695506 will violate spec when used in JDK6
kamg
parents:
0
diff
changeset
|
130 } |
|
6b648fefb395
6705523: Fix for 6695506 will violate spec when used in JDK6
kamg
parents:
0
diff
changeset
|
131 |
| 242 | 132 uint8_t major_version() const { return _major; } |
| 133 uint8_t minor_version() const { return _minor; } | |
| 134 uint8_t micro_version() const { return _micro; } | |
| 135 uint8_t update_version() const { return _update; } | |
| 136 uint8_t special_update_version() const { return _special; } | |
| 137 uint8_t build_number() const { return _build; } | |
| 138 | |
| 139 bool supports_thread_park_blocker() const { | |
| 140 return _thread_park_blocker; | |
| 141 } | |
| 142 | |
| 143 // Performs a full ordering comparison using all fields (update, build, etc.) | |
| 144 int compare(const JDK_Version& other) const; | |
| 145 | |
| 146 /** | |
| 147 * Performs comparison using only the major version, returning negative | |
| 148 * if the major version of 'this' is less than the parameter, 0 if it is | |
| 149 * equal, and a positive value if it is greater. | |
| 150 */ | |
| 151 int compare_major(int version) const { | |
| 152 if (_partially_initialized) { | |
| 153 if (version >= 6) { | |
| 154 return -1; | |
| 155 } else { | |
| 156 assert(false, "Can't make this comparison during init time"); | |
| 157 return -1; // conservative | |
| 158 } | |
|
176
6b648fefb395
6705523: Fix for 6695506 will violate spec when used in JDK6
kamg
parents:
0
diff
changeset
|
159 } else { |
| 242 | 160 return major_version() - version; |
|
176
6b648fefb395
6705523: Fix for 6695506 will violate spec when used in JDK6
kamg
parents:
0
diff
changeset
|
161 } |
|
6b648fefb395
6705523: Fix for 6695506 will violate spec when used in JDK6
kamg
parents:
0
diff
changeset
|
162 } |
| 0 | 163 |
| 242 | 164 void to_string(char* buffer, size_t buflen) const; |
| 165 | |
| 166 // Convenience methods for queries on the current major/minor version | |
| 167 static bool is_jdk12x_version() { | |
| 168 return current().compare_major(2) == 0; | |
| 169 } | |
| 170 | |
| 171 static bool is_jdk13x_version() { | |
| 172 return current().compare_major(3) == 0; | |
| 173 } | |
| 174 | |
| 175 static bool is_jdk14x_version() { | |
| 176 return current().compare_major(4) == 0; | |
| 177 } | |
| 178 | |
| 179 static bool is_jdk15x_version() { | |
| 180 return current().compare_major(5) == 0; | |
| 181 } | |
| 182 | |
| 183 static bool is_jdk16x_version() { | |
| 184 return current().compare_major(6) == 0; | |
| 185 } | |
| 186 | |
| 187 static bool is_jdk17x_version() { | |
| 188 return current().compare_major(7) == 0; | |
| 189 } | |
| 190 | |
| 191 static bool is_gte_jdk13x_version() { | |
| 192 return current().compare_major(3) >= 0; | |
| 193 } | |
| 0 | 194 |
| 195 static bool is_gte_jdk14x_version() { | |
| 242 | 196 return current().compare_major(4) >= 0; |
| 0 | 197 } |
| 242 | 198 |
| 199 static bool is_gte_jdk15x_version() { | |
| 200 return current().compare_major(5) >= 0; | |
| 201 } | |
| 202 | |
| 0 | 203 static bool is_gte_jdk16x_version() { |
| 242 | 204 return current().compare_major(6) >= 0; |
| 0 | 205 } |
| 206 | |
| 207 static bool is_gte_jdk17x_version() { | |
| 242 | 208 return current().compare_major(7) >= 0; |
| 0 | 209 } |
| 210 }; |