Mercurial > hg > graal-compiler
annotate src/cpu/x86/vm/frame_x86.inline.hpp @ 2007:5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
Summary: C1 with profiling doesn't check whether the MDO has been really allocated, which can silently fail if the perm gen is full. The solution is to check if the allocation failed and bailout out of inlining or compilation.
Reviewed-by: kvn, never
| author | iveresov |
|---|---|
| date | Thu, 02 Dec 2010 17:21:12 -0800 |
| parents | f95d63e2154a |
| children | 167b70ff3abc |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1255
diff
changeset
|
2 * Copyright (c) 1997, 2010, 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:
1255
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1255
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:
1255
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef CPU_X86_VM_FRAME_X86_INLINE_HPP |
| 26 #define CPU_X86_VM_FRAME_X86_INLINE_HPP | |
| 27 | |
| 0 | 28 // Inline functions for Intel frames: |
| 29 | |
| 30 // Constructors: | |
| 31 | |
| 32 inline frame::frame() { | |
| 33 _pc = NULL; | |
| 34 _sp = NULL; | |
| 35 _unextended_sp = NULL; | |
| 36 _fp = NULL; | |
| 37 _cb = NULL; | |
| 38 _deopt_state = unknown; | |
| 39 } | |
| 40 | |
| 1204 | 41 inline frame::frame(intptr_t* sp, intptr_t* fp, address pc) { |
| 0 | 42 _sp = sp; |
| 43 _unextended_sp = sp; | |
| 44 _fp = fp; | |
| 45 _pc = pc; | |
| 46 assert(pc != NULL, "no pc?"); | |
| 47 _cb = CodeCache::find_blob(pc); | |
| 1204 | 48 |
| 49 address original_pc = nmethod::get_deopt_original_pc(this); | |
| 50 if (original_pc != NULL) { | |
| 51 _pc = original_pc; | |
| 0 | 52 _deopt_state = is_deoptimized; |
| 53 } else { | |
| 54 _deopt_state = not_deoptimized; | |
| 55 } | |
| 56 } | |
| 57 | |
| 1204 | 58 inline frame::frame(intptr_t* sp, intptr_t* unextended_sp, intptr_t* fp, address pc) { |
| 0 | 59 _sp = sp; |
| 60 _unextended_sp = unextended_sp; | |
| 61 _fp = fp; | |
| 62 _pc = pc; | |
| 63 assert(pc != NULL, "no pc?"); | |
| 64 _cb = CodeCache::find_blob(pc); | |
| 1204 | 65 |
| 66 address original_pc = nmethod::get_deopt_original_pc(this); | |
| 67 if (original_pc != NULL) { | |
| 68 _pc = original_pc; | |
| 1748 | 69 assert(((nmethod*)_cb)->insts_contains(_pc), "original PC must be in nmethod"); |
| 0 | 70 _deopt_state = is_deoptimized; |
| 71 } else { | |
| 72 _deopt_state = not_deoptimized; | |
| 73 } | |
| 74 } | |
| 75 | |
| 76 inline frame::frame(intptr_t* sp, intptr_t* fp) { | |
| 77 _sp = sp; | |
| 78 _unextended_sp = sp; | |
| 79 _fp = fp; | |
| 80 _pc = (address)(sp[-1]); | |
|
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
81 |
|
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
82 // Here's a sticky one. This constructor can be called via AsyncGetCallTrace |
|
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
83 // when last_Java_sp is non-null but the pc fetched is junk. If we are truly |
|
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
84 // unlucky the junk value could be to a zombied method and we'll die on the |
|
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
85 // find_blob call. This is also why we can have no asserts on the validity |
|
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
86 // of the pc we find here. AsyncGetCallTrace -> pd_get_top_frame_for_signal_handler |
|
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
87 // -> pd_last_frame should use a specialized version of pd_last_frame which could |
|
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
88 // call a specilaized frame constructor instead of this one. |
|
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
89 // Then we could use the assert below. However this assert is of somewhat dubious |
|
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
90 // value. |
|
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
91 // assert(_pc != NULL, "no pc?"); |
|
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
92 |
| 0 | 93 _cb = CodeCache::find_blob(_pc); |
| 94 | |
| 1204 | 95 address original_pc = nmethod::get_deopt_original_pc(this); |
| 96 if (original_pc != NULL) { | |
| 97 _pc = original_pc; | |
| 0 | 98 _deopt_state = is_deoptimized; |
| 99 } else { | |
| 100 _deopt_state = not_deoptimized; | |
| 101 } | |
| 102 } | |
| 103 | |
| 104 // Accessors | |
| 105 | |
| 106 inline bool frame::equal(frame other) const { | |
| 107 bool ret = sp() == other.sp() | |
| 108 && unextended_sp() == other.unextended_sp() | |
| 109 && fp() == other.fp() | |
| 110 && pc() == other.pc(); | |
| 111 assert(!ret || ret && cb() == other.cb() && _deopt_state == other._deopt_state, "inconsistent construction"); | |
| 112 return ret; | |
| 113 } | |
| 114 | |
| 115 // Return unique id for this frame. The id must have a value where we can distinguish | |
| 116 // identity and younger/older relationship. NULL represents an invalid (incomparable) | |
| 117 // frame. | |
| 118 inline intptr_t* frame::id(void) const { return unextended_sp(); } | |
| 119 | |
| 120 // Relationals on frames based | |
| 121 // Return true if the frame is younger (more recent activation) than the frame represented by id | |
| 122 inline bool frame::is_younger(intptr_t* id) const { assert(this->id() != NULL && id != NULL, "NULL frame id"); | |
| 123 return this->id() < id ; } | |
| 124 | |
| 125 // Return true if the frame is older (less recent activation) than the frame represented by id | |
| 126 inline bool frame::is_older(intptr_t* id) const { assert(this->id() != NULL && id != NULL, "NULL frame id"); | |
| 127 return this->id() > id ; } | |
| 128 | |
| 129 | |
| 130 | |
| 131 inline intptr_t* frame::link() const { return (intptr_t*) *(intptr_t **)addr_at(link_offset); } | |
| 132 inline void frame::set_link(intptr_t* addr) { *(intptr_t **)addr_at(link_offset) = addr; } | |
| 133 | |
| 134 | |
| 135 inline intptr_t* frame::unextended_sp() const { return _unextended_sp; } | |
| 136 | |
| 137 // Return address: | |
| 138 | |
| 139 inline address* frame::sender_pc_addr() const { return (address*) addr_at( return_addr_offset); } | |
| 140 inline address frame::sender_pc() const { return *sender_pc_addr(); } | |
| 141 | |
| 142 // return address of param, zero origin index. | |
| 143 inline address* frame::native_param_addr(int idx) const { return (address*) addr_at( native_frame_initial_param_offset+idx); } | |
| 144 | |
| 145 #ifdef CC_INTERP | |
| 146 | |
| 147 inline interpreterState frame::get_interpreterState() const { | |
|
520
52a431267315
6791168: Fix invalid code in bytecodeInterpreter that can cause gcc ICE
coleenp
parents:
304
diff
changeset
|
148 return ((interpreterState)addr_at( -((int)sizeof(BytecodeInterpreter))/wordSize )); |
| 0 | 149 } |
| 150 | |
| 151 inline intptr_t* frame::sender_sp() const { | |
| 152 // Hmm this seems awfully expensive QQQ, is this really called with interpreted frames? | |
| 153 if (is_interpreted_frame()) { | |
| 154 assert(false, "should never happen"); | |
| 155 return get_interpreterState()->sender_sp(); | |
| 156 } else { | |
| 157 return addr_at(sender_sp_offset); | |
| 158 } | |
| 159 } | |
| 160 | |
| 161 inline intptr_t** frame::interpreter_frame_locals_addr() const { | |
| 162 assert(is_interpreted_frame(), "must be interpreted"); | |
| 163 return &(get_interpreterState()->_locals); | |
| 164 } | |
| 165 | |
| 166 inline intptr_t* frame::interpreter_frame_bcx_addr() const { | |
| 167 assert(is_interpreted_frame(), "must be interpreted"); | |
| 304 | 168 return (intptr_t*) &(get_interpreterState()->_bcp); |
| 0 | 169 } |
| 170 | |
| 171 | |
| 172 // Constant pool cache | |
| 173 | |
| 174 inline constantPoolCacheOop* frame::interpreter_frame_cache_addr() const { | |
| 175 assert(is_interpreted_frame(), "must be interpreted"); | |
| 176 return &(get_interpreterState()->_constants); | |
| 177 } | |
| 178 | |
| 179 // Method | |
| 180 | |
| 181 inline methodOop* frame::interpreter_frame_method_addr() const { | |
| 182 assert(is_interpreted_frame(), "must be interpreted"); | |
| 183 return &(get_interpreterState()->_method); | |
| 184 } | |
| 185 | |
| 186 inline intptr_t* frame::interpreter_frame_mdx_addr() const { | |
| 187 assert(is_interpreted_frame(), "must be interpreted"); | |
| 304 | 188 return (intptr_t*) &(get_interpreterState()->_mdx); |
| 0 | 189 } |
| 190 | |
| 191 // top of expression stack | |
| 192 inline intptr_t* frame::interpreter_frame_tos_address() const { | |
| 193 assert(is_interpreted_frame(), "wrong frame type"); | |
| 194 return get_interpreterState()->_stack + 1; | |
| 195 } | |
| 196 | |
| 197 #else /* asm interpreter */ | |
| 198 inline intptr_t* frame::sender_sp() const { return addr_at( sender_sp_offset); } | |
| 199 | |
| 200 inline intptr_t** frame::interpreter_frame_locals_addr() const { | |
| 201 return (intptr_t**)addr_at(interpreter_frame_locals_offset); | |
| 202 } | |
| 203 | |
| 204 inline intptr_t* frame::interpreter_frame_last_sp() const { | |
| 205 return *(intptr_t**)addr_at(interpreter_frame_last_sp_offset); | |
| 206 } | |
| 207 | |
| 208 inline intptr_t* frame::interpreter_frame_bcx_addr() const { | |
| 209 return (intptr_t*)addr_at(interpreter_frame_bcx_offset); | |
| 210 } | |
| 211 | |
| 212 | |
| 213 inline intptr_t* frame::interpreter_frame_mdx_addr() const { | |
| 214 return (intptr_t*)addr_at(interpreter_frame_mdx_offset); | |
| 215 } | |
| 216 | |
| 217 | |
| 218 | |
| 219 // Constant pool cache | |
| 220 | |
| 221 inline constantPoolCacheOop* frame::interpreter_frame_cache_addr() const { | |
| 222 return (constantPoolCacheOop*)addr_at(interpreter_frame_cache_offset); | |
| 223 } | |
| 224 | |
| 225 // Method | |
| 226 | |
| 227 inline methodOop* frame::interpreter_frame_method_addr() const { | |
| 228 return (methodOop*)addr_at(interpreter_frame_method_offset); | |
| 229 } | |
| 230 | |
| 231 // top of expression stack | |
| 232 inline intptr_t* frame::interpreter_frame_tos_address() const { | |
| 233 intptr_t* last_sp = interpreter_frame_last_sp(); | |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
579
diff
changeset
|
234 if (last_sp == NULL) { |
| 0 | 235 return sp(); |
| 236 } else { | |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
579
diff
changeset
|
237 // sp() may have been extended or shrunk by an adapter. At least |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
579
diff
changeset
|
238 // check that we don't fall behind the legal region. |
|
1255
e3a4305c6bc3
6925249: assert(last_sp < (intptr_t*) interpreter_frame_monitor_begin(),"bad tos")
kvn
parents:
1204
diff
changeset
|
239 // For top deoptimized frame last_sp == interpreter_frame_monitor_end. |
|
e3a4305c6bc3
6925249: assert(last_sp < (intptr_t*) interpreter_frame_monitor_begin(),"bad tos")
kvn
parents:
1204
diff
changeset
|
240 assert(last_sp <= (intptr_t*) interpreter_frame_monitor_end(), "bad tos"); |
| 0 | 241 return last_sp; |
| 242 } | |
| 243 } | |
| 244 | |
| 245 #endif /* CC_INTERP */ | |
| 246 | |
| 247 inline int frame::pd_oop_map_offset_adjustment() const { | |
| 248 return 0; | |
| 249 } | |
| 250 | |
| 251 inline int frame::interpreter_frame_monitor_size() { | |
| 252 return BasicObjectLock::size(); | |
| 253 } | |
| 254 | |
| 255 | |
| 256 // expression stack | |
| 257 // (the max_stack arguments are used by the GC; see class FrameClosure) | |
| 258 | |
| 259 inline intptr_t* frame::interpreter_frame_expression_stack() const { | |
| 260 intptr_t* monitor_end = (intptr_t*) interpreter_frame_monitor_end(); | |
| 261 return monitor_end-1; | |
| 262 } | |
| 263 | |
| 264 | |
| 265 inline jint frame::interpreter_frame_expression_stack_direction() { return -1; } | |
| 266 | |
| 267 | |
| 268 // Entry frames | |
| 269 | |
| 270 inline JavaCallWrapper* frame::entry_frame_call_wrapper() const { | |
| 271 return (JavaCallWrapper*)at(entry_frame_call_wrapper_offset); | |
| 272 } | |
| 273 | |
| 274 | |
| 275 // Compiled frames | |
| 276 | |
| 277 inline int frame::local_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors) { | |
| 278 return (nof_args - local_index + (local_index < nof_args ? 1: -1)); | |
| 279 } | |
| 280 | |
| 281 inline int frame::monitor_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors) { | |
| 282 return local_offset_for_compiler(local_index, nof_args, max_nof_locals, max_nof_monitors); | |
| 283 } | |
| 284 | |
| 285 inline int frame::min_local_offset_for_compiler(int nof_args, int max_nof_locals, int max_nof_monitors) { | |
| 286 return (nof_args - (max_nof_locals + max_nof_monitors*2) - 1); | |
| 287 } | |
| 288 | |
| 289 inline bool frame::volatile_across_calls(Register reg) { | |
| 290 return true; | |
| 291 } | |
| 292 | |
| 293 | |
| 294 | |
| 295 inline oop frame::saved_oop_result(RegisterMap* map) const { | |
| 296 return *((oop*) map->location(rax->as_VMReg())); | |
| 297 } | |
| 298 | |
| 299 inline void frame::set_saved_oop_result(RegisterMap* map, oop obj) { | |
| 300 *((oop*) map->location(rax->as_VMReg())) = obj; | |
| 301 } | |
| 1972 | 302 |
| 303 #endif // CPU_X86_VM_FRAME_X86_INLINE_HPP |