Mercurial > hg > graal-compiler
annotate src/cpu/sparc/vm/frame_sparc.inline.hpp @ 6812:988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
Summary: The clipping code in the routine that sets the bits for a range of cards, in the liveness accounting verification code was incorrect. It set all the bits in the card bitmap from the given starting index which would lead to spurious marking verification failures.
Reviewed-by: brutisso, jwilhelm, jmasa
| author | johnc |
|---|---|
| date | Thu, 27 Sep 2012 15:44:01 -0700 |
| parents | da91efe96a93 |
| children | cd3d6a6b95d9 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
4806
eaa9557116a2
7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents:
1972
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
844
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
844
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
844
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef CPU_SPARC_VM_FRAME_SPARC_INLINE_HPP |
| 26 #define CPU_SPARC_VM_FRAME_SPARC_INLINE_HPP | |
| 27 | |
| 0 | 28 // Inline functions for SPARC frames: |
| 29 | |
| 30 // Constructors | |
| 31 | |
| 32 inline frame::frame() { | |
| 33 _pc = NULL; | |
| 34 _sp = NULL; | |
| 35 _younger_sp = NULL; | |
| 36 _cb = NULL; | |
| 37 _deopt_state = unknown; | |
| 38 _sp_adjustment_by_callee = 0; | |
| 39 } | |
| 40 | |
| 41 // Accessors: | |
| 42 | |
| 43 inline bool frame::equal(frame other) const { | |
| 44 bool ret = sp() == other.sp() | |
| 45 && fp() == other.fp() | |
| 46 && pc() == other.pc(); | |
| 47 assert(!ret || ret && cb() == other.cb() && _deopt_state == other._deopt_state, "inconsistent construction"); | |
| 48 return ret; | |
| 49 } | |
| 50 | |
| 51 // Return unique id for this frame. The id must have a value where we can distinguish | |
| 52 // identity and younger/older relationship. NULL represents an invalid (incomparable) | |
| 53 // frame. | |
| 54 inline intptr_t* frame::id(void) const { return unextended_sp(); } | |
| 55 | |
| 56 // Relationals on frames based | |
| 57 // Return true if the frame is younger (more recent activation) than the frame represented by id | |
| 58 inline bool frame::is_younger(intptr_t* id) const { assert(this->id() != NULL && id != NULL, "NULL frame id"); | |
| 59 return this->id() < id ; } | |
| 60 | |
| 61 // Return true if the frame is older (less recent activation) than the frame represented by id | |
| 62 inline bool frame::is_older(intptr_t* id) const { assert(this->id() != NULL && id != NULL, "NULL frame id"); | |
| 63 return this->id() > id ; } | |
| 64 | |
|
793
eacd97c88873
6848466: frame::frame_size() assertion failure with -XX:+DebugDeoptimization
cfang
parents:
0
diff
changeset
|
65 inline int frame::frame_size(RegisterMap* map) const { return sender_sp() - sp(); } |
| 0 | 66 |
| 67 inline intptr_t* frame::link() const { return (intptr_t *)(fp()[FP->sp_offset_in_saved_window()] + STACK_BIAS); } | |
| 68 | |
| 69 inline void frame::set_link(intptr_t* addr) { assert(link()==addr, "frame nesting is controlled by hardware"); } | |
| 70 | |
| 71 inline intptr_t* frame::unextended_sp() const { return sp() + _sp_adjustment_by_callee; } | |
| 72 | |
| 73 // return address: | |
| 74 | |
| 75 inline address frame::sender_pc() const { return *I7_addr() + pc_return_offset; } | |
| 76 | |
| 77 inline address* frame::I7_addr() const { return (address*) &sp()[ I7->sp_offset_in_saved_window()]; } | |
| 78 inline address* frame::I0_addr() const { return (address*) &sp()[ I0->sp_offset_in_saved_window()]; } | |
| 79 | |
| 80 inline address* frame::O7_addr() const { return (address*) &younger_sp()[ I7->sp_offset_in_saved_window()]; } | |
| 81 inline address* frame::O0_addr() const { return (address*) &younger_sp()[ I0->sp_offset_in_saved_window()]; } | |
| 82 | |
| 83 inline intptr_t* frame::sender_sp() const { return fp(); } | |
| 84 | |
|
4806
eaa9557116a2
7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents:
1972
diff
changeset
|
85 inline intptr_t* frame::real_fp() const { return fp(); } |
|
eaa9557116a2
7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents:
1972
diff
changeset
|
86 |
| 0 | 87 // Used only in frame::oopmapreg_to_location |
| 88 // This return a value in VMRegImpl::slot_size | |
| 89 inline int frame::pd_oop_map_offset_adjustment() const { | |
| 90 return _sp_adjustment_by_callee * VMRegImpl::slots_per_word; | |
| 91 } | |
| 92 | |
| 93 #ifdef CC_INTERP | |
| 94 inline intptr_t** frame::interpreter_frame_locals_addr() const { | |
| 95 interpreterState istate = get_interpreterState(); | |
| 96 return (intptr_t**) &istate->_locals; | |
| 97 } | |
| 98 | |
| 99 inline intptr_t* frame::interpreter_frame_bcx_addr() const { | |
| 100 interpreterState istate = get_interpreterState(); | |
| 101 return (intptr_t*) &istate->_bcp; | |
| 102 } | |
| 103 | |
| 104 inline intptr_t* frame::interpreter_frame_mdx_addr() const { | |
| 105 interpreterState istate = get_interpreterState(); | |
| 106 return (intptr_t*) &istate->_mdx; | |
| 107 } | |
| 108 | |
| 109 inline jint frame::interpreter_frame_expression_stack_direction() { return -1; } | |
| 110 | |
| 111 // bottom(base) of the expression stack (highest address) | |
| 112 inline intptr_t* frame::interpreter_frame_expression_stack() const { | |
| 113 return (intptr_t*)interpreter_frame_monitor_end() - 1; | |
| 114 } | |
| 115 | |
| 116 // top of expression stack (lowest address) | |
| 117 inline intptr_t* frame::interpreter_frame_tos_address() const { | |
| 118 interpreterState istate = get_interpreterState(); | |
| 119 return istate->_stack + 1; // Is this off by one? QQQ | |
| 120 } | |
| 121 | |
| 122 // monitor elements | |
| 123 | |
| 124 // in keeping with Intel side: end is lower in memory than begin; | |
| 125 // and beginning element is oldest element | |
| 126 // Also begin is one past last monitor. | |
| 127 | |
| 128 inline BasicObjectLock* frame::interpreter_frame_monitor_begin() const { | |
| 129 return get_interpreterState()->monitor_base(); | |
| 130 } | |
| 131 | |
| 132 inline BasicObjectLock* frame::interpreter_frame_monitor_end() const { | |
| 133 return (BasicObjectLock*) get_interpreterState()->stack_base(); | |
| 134 } | |
| 135 | |
| 136 | |
| 137 inline int frame::interpreter_frame_monitor_size() { | |
| 138 return round_to(BasicObjectLock::size(), WordsPerLong); | |
| 139 } | |
| 140 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4806
diff
changeset
|
141 inline Method** frame::interpreter_frame_method_addr() const { |
| 0 | 142 interpreterState istate = get_interpreterState(); |
| 143 return &istate->_method; | |
| 144 } | |
| 145 | |
| 146 | |
| 147 // Constant pool cache | |
| 148 | |
| 149 // where LcpoolCache is saved: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4806
diff
changeset
|
150 inline ConstantPoolCache** frame::interpreter_frame_cpoolcache_addr() const { |
| 0 | 151 interpreterState istate = get_interpreterState(); |
| 152 return &istate->_constants; // should really use accessor | |
| 153 } | |
| 154 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4806
diff
changeset
|
155 inline ConstantPoolCache** frame::interpreter_frame_cache_addr() const { |
| 0 | 156 interpreterState istate = get_interpreterState(); |
| 157 return &istate->_constants; | |
| 158 } | |
| 159 | |
| 160 #else // !CC_INTERP | |
| 161 | |
| 162 inline intptr_t** frame::interpreter_frame_locals_addr() const { | |
| 163 return (intptr_t**) sp_addr_at( Llocals->sp_offset_in_saved_window()); | |
| 164 } | |
| 165 | |
| 166 inline intptr_t* frame::interpreter_frame_bcx_addr() const { | |
| 167 // %%%%% reinterpreting Lbcp as a bcx | |
| 168 return (intptr_t*) sp_addr_at( Lbcp->sp_offset_in_saved_window()); | |
| 169 } | |
| 170 | |
| 171 inline intptr_t* frame::interpreter_frame_mdx_addr() const { | |
| 172 // %%%%% reinterpreting ImethodDataPtr as a mdx | |
| 173 return (intptr_t*) sp_addr_at( ImethodDataPtr->sp_offset_in_saved_window()); | |
| 174 } | |
| 175 | |
| 176 inline jint frame::interpreter_frame_expression_stack_direction() { return -1; } | |
| 177 | |
| 178 // bottom(base) of the expression stack (highest address) | |
| 179 inline intptr_t* frame::interpreter_frame_expression_stack() const { | |
| 180 return (intptr_t*)interpreter_frame_monitors() - 1; | |
| 181 } | |
| 182 | |
| 183 // top of expression stack (lowest address) | |
| 184 inline intptr_t* frame::interpreter_frame_tos_address() const { | |
| 185 return *interpreter_frame_esp_addr() + 1; | |
| 186 } | |
| 187 | |
| 188 inline void frame::interpreter_frame_set_tos_address( intptr_t* x ) { | |
| 189 *interpreter_frame_esp_addr() = x - 1; | |
| 190 } | |
| 191 | |
| 192 // monitor elements | |
| 193 | |
| 194 // in keeping with Intel side: end is lower in memory than begin; | |
| 195 // and beginning element is oldest element | |
| 196 // Also begin is one past last monitor. | |
| 197 | |
| 198 inline BasicObjectLock* frame::interpreter_frame_monitor_begin() const { | |
| 199 int rounded_vm_local_words = round_to(frame::interpreter_frame_vm_local_words, WordsPerLong); | |
| 200 return (BasicObjectLock *)fp_addr_at(-rounded_vm_local_words); | |
| 201 } | |
| 202 | |
| 203 inline BasicObjectLock* frame::interpreter_frame_monitor_end() const { | |
| 204 return interpreter_frame_monitors(); | |
| 205 } | |
| 206 | |
| 207 | |
| 208 inline void frame::interpreter_frame_set_monitor_end(BasicObjectLock* value) { | |
| 209 interpreter_frame_set_monitors(value); | |
| 210 } | |
| 211 | |
| 212 inline int frame::interpreter_frame_monitor_size() { | |
| 213 return round_to(BasicObjectLock::size(), WordsPerLong); | |
| 214 } | |
| 215 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4806
diff
changeset
|
216 inline Method** frame::interpreter_frame_method_addr() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4806
diff
changeset
|
217 return (Method**)sp_addr_at( Lmethod->sp_offset_in_saved_window()); |
| 0 | 218 } |
| 219 | |
| 220 | |
| 221 // Constant pool cache | |
| 222 | |
| 223 // where LcpoolCache is saved: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4806
diff
changeset
|
224 inline ConstantPoolCache** frame::interpreter_frame_cpoolcache_addr() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4806
diff
changeset
|
225 return (ConstantPoolCache**)sp_addr_at(LcpoolCache->sp_offset_in_saved_window()); |
| 0 | 226 } |
| 227 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4806
diff
changeset
|
228 inline ConstantPoolCache** frame::interpreter_frame_cache_addr() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4806
diff
changeset
|
229 return (ConstantPoolCache**)sp_addr_at( LcpoolCache->sp_offset_in_saved_window()); |
| 0 | 230 } |
| 231 #endif // CC_INTERP | |
| 232 | |
| 233 | |
| 234 inline JavaCallWrapper* frame::entry_frame_call_wrapper() const { | |
| 235 // note: adjust this code if the link argument in StubGenerator::call_stub() changes! | |
| 236 const Argument link = Argument(0, false); | |
| 237 return (JavaCallWrapper*)sp()[link.as_in().as_register()->sp_offset_in_saved_window()]; | |
| 238 } | |
| 239 | |
| 240 | |
| 241 inline int frame::local_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors) { | |
| 242 // always allocate non-argument locals 0..5 as if they were arguments: | |
| 243 int allocated_above_frame = nof_args; | |
| 244 if (allocated_above_frame < callee_register_argument_save_area_words) | |
| 245 allocated_above_frame = callee_register_argument_save_area_words; | |
| 246 if (allocated_above_frame > max_nof_locals) | |
| 247 allocated_above_frame = max_nof_locals; | |
| 248 | |
| 249 // Note: monitors (BasicLock blocks) are never allocated in argument slots | |
| 250 //assert(local_index >= 0 && local_index < max_nof_locals, "bad local index"); | |
| 251 if (local_index < allocated_above_frame) | |
| 252 return local_index + callee_register_argument_save_area_sp_offset; | |
| 253 else | |
| 254 return local_index - (max_nof_locals + max_nof_monitors*2) + compiler_frame_vm_locals_fp_offset; | |
| 255 } | |
| 256 | |
| 257 inline int frame::monitor_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors) { | |
| 258 assert(local_index >= max_nof_locals && ((local_index - max_nof_locals) & 1) && (local_index - max_nof_locals) < max_nof_monitors*2, "bad monitor index"); | |
| 259 | |
| 260 // The compiler uses the __higher__ of two indexes allocated to the monitor. | |
| 261 // Increasing local indexes are mapped to increasing memory locations, | |
| 262 // so the start of the BasicLock is associated with the __lower__ index. | |
| 263 | |
| 264 int offset = (local_index-1) - (max_nof_locals + max_nof_monitors*2) + compiler_frame_vm_locals_fp_offset; | |
| 265 | |
| 266 // We allocate monitors aligned zero mod 8: | |
| 267 assert((offset & 1) == 0, "monitor must be an an even address."); | |
| 268 // This works because all monitors are allocated after | |
| 269 // all locals, and because the highest address corresponding to any | |
| 270 // monitor index is always even. | |
| 271 assert((compiler_frame_vm_locals_fp_offset & 1) == 0, "end of monitors must be even address"); | |
| 272 | |
| 273 return offset; | |
| 274 } | |
| 275 | |
| 276 inline int frame::min_local_offset_for_compiler(int nof_args, int max_nof_locals, int max_nof_monitors) { | |
| 277 // always allocate non-argument locals 0..5 as if they were arguments: | |
| 278 int allocated_above_frame = nof_args; | |
| 279 if (allocated_above_frame < callee_register_argument_save_area_words) | |
| 280 allocated_above_frame = callee_register_argument_save_area_words; | |
| 281 if (allocated_above_frame > max_nof_locals) | |
| 282 allocated_above_frame = max_nof_locals; | |
| 283 | |
| 284 int allocated_in_frame = (max_nof_locals + max_nof_monitors*2) - allocated_above_frame; | |
| 285 | |
| 286 return compiler_frame_vm_locals_fp_offset - allocated_in_frame; | |
| 287 } | |
| 288 | |
| 289 // On SPARC, the %lN and %iN registers are non-volatile. | |
| 290 inline bool frame::volatile_across_calls(Register reg) { | |
| 291 // This predicate is (presently) applied only to temporary registers, | |
| 292 // and so it need not recognize non-volatile globals. | |
| 293 return reg->is_out() || reg->is_global(); | |
| 294 } | |
| 295 | |
| 296 inline oop frame::saved_oop_result(RegisterMap* map) const { | |
| 297 return *((oop*) map->location(O0->as_VMReg())); | |
| 298 } | |
| 299 | |
| 300 inline void frame::set_saved_oop_result(RegisterMap* map, oop obj) { | |
| 301 *((oop*) map->location(O0->as_VMReg())) = obj; | |
| 302 } | |
| 1972 | 303 |
| 304 #endif // CPU_SPARC_VM_FRAME_SPARC_INLINE_HPP |