Mercurial > hg > truffle
annotate src/cpu/zero/vm/stack_zero.hpp @ 1673:6709c14587c2 jdk7-b105
Added tag jdk7-b104 for changeset b4acf10eb134
| author | cl |
|---|---|
| date | Fri, 06 Aug 2010 12:51:54 -0700 |
| parents | c18cbe5936b8 |
| children | f95d63e2154a |
| rev | line source |
|---|---|
| 1010 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1511
diff
changeset
|
2 * Copyright (c) 2003, 2007, Oracle and/or its affiliates. All rights reserved. |
| 1379 | 3 * Copyright 2008, 2009, 2010 Red Hat, Inc. |
| 1010 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1511
diff
changeset
|
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1511
diff
changeset
|
21 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1511
diff
changeset
|
22 * questions. |
| 1010 | 23 * |
| 24 */ | |
| 25 | |
| 26 class ZeroStack { | |
| 27 private: | |
| 28 intptr_t *_base; // the last available word | |
| 29 intptr_t *_top; // the word past the end of the stack | |
| 30 intptr_t *_sp; // the top word on the stack | |
| 31 | |
| 1379 | 32 private: |
| 33 int _shadow_pages_size; // how much ABI stack must we keep free? | |
| 34 | |
| 1010 | 35 public: |
| 36 ZeroStack() | |
| 1379 | 37 : _base(NULL), _top(NULL), _sp(NULL) { |
| 38 _shadow_pages_size = StackShadowPages * os::vm_page_size(); | |
| 39 } | |
| 1010 | 40 |
| 41 bool needs_setup() const { | |
| 42 return _base == NULL; | |
| 43 } | |
| 44 | |
| 1511 | 45 int suggest_size(Thread *thread) const; |
| 46 | |
| 1010 | 47 void setup(void *mem, size_t size) { |
| 48 assert(needs_setup(), "already set up"); | |
| 49 assert(!(size & WordAlignmentMask), "unaligned"); | |
| 50 | |
| 51 _base = (intptr_t *) mem; | |
| 52 _top = _base + (size >> LogBytesPerWord); | |
| 53 _sp = _top; | |
| 54 } | |
| 55 void teardown() { | |
| 56 assert(!needs_setup(), "not set up"); | |
| 57 assert(_sp == _top, "stuff on stack at teardown"); | |
| 58 | |
| 59 _base = NULL; | |
| 60 _top = NULL; | |
| 61 _sp = NULL; | |
| 62 } | |
| 63 | |
| 64 intptr_t *sp() const { | |
| 65 return _sp; | |
| 66 } | |
| 67 void set_sp(intptr_t *new_sp) { | |
| 68 assert(_top >= new_sp && new_sp >= _base, "bad stack pointer"); | |
| 69 _sp = new_sp; | |
| 70 } | |
| 71 | |
| 1511 | 72 int total_words() const { |
| 73 return _top - _base; | |
| 74 } | |
| 1010 | 75 int available_words() const { |
| 76 return _sp - _base; | |
| 77 } | |
| 78 | |
| 79 void push(intptr_t value) { | |
| 80 assert(_sp > _base, "stack overflow"); | |
| 81 *(--_sp) = value; | |
| 82 } | |
| 83 intptr_t pop() { | |
| 84 assert(_sp < _top, "stack underflow"); | |
| 85 return *(_sp++); | |
| 86 } | |
| 87 | |
| 88 void *alloc(size_t size) { | |
| 89 int count = align_size_up(size, wordSize) >> LogBytesPerWord; | |
| 90 assert(count <= available_words(), "stack overflow"); | |
| 91 return _sp -= count; | |
| 92 } | |
| 93 | |
| 1379 | 94 int shadow_pages_size() const { |
| 95 return _shadow_pages_size; | |
| 96 } | |
| 1511 | 97 int abi_stack_available(Thread *thread) const; |
| 1379 | 98 |
| 99 public: | |
| 100 void overflow_check(int required_words, TRAPS); | |
| 101 static void handle_overflow(TRAPS); | |
| 102 | |
| 1010 | 103 public: |
| 1505 | 104 void zap(int c) PRODUCT_RETURN; |
| 105 | |
| 106 public: | |
| 1010 | 107 static ByteSize base_offset() { |
| 108 return byte_offset_of(ZeroStack, _base); | |
| 109 } | |
| 110 static ByteSize top_offset() { | |
| 111 return byte_offset_of(ZeroStack, _top); | |
| 112 } | |
| 113 static ByteSize sp_offset() { | |
| 114 return byte_offset_of(ZeroStack, _sp); | |
| 115 } | |
| 116 }; | |
| 117 | |
| 118 | |
| 119 class EntryFrame; | |
| 120 class InterpreterFrame; | |
| 121 class SharkFrame; | |
| 122 class FakeStubFrame; | |
| 123 | |
| 124 // | |
| 125 // | ... | | |
| 126 // +--------------------+ ------------------ | |
| 127 // | ... | low addresses | |
| 128 // | frame_type | | |
| 129 // | next_frame | high addresses | |
| 130 // +--------------------+ ------------------ | |
| 131 // | ... | | |
| 132 | |
| 133 class ZeroFrame { | |
| 134 friend class frame; | |
| 135 friend class ZeroStackPrinter; | |
| 136 | |
| 137 protected: | |
| 138 ZeroFrame() { | |
| 139 ShouldNotCallThis(); | |
| 140 } | |
| 141 | |
| 142 enum Layout { | |
| 143 next_frame_off, | |
| 144 frame_type_off, | |
| 145 jf_header_words | |
| 146 }; | |
| 147 | |
| 148 enum FrameType { | |
| 149 ENTRY_FRAME = 1, | |
| 150 INTERPRETER_FRAME, | |
| 151 SHARK_FRAME, | |
| 152 FAKE_STUB_FRAME | |
| 153 }; | |
| 154 | |
| 155 protected: | |
| 156 intptr_t *addr_of_word(int offset) const { | |
| 157 return (intptr_t *) this - offset; | |
| 158 } | |
| 159 intptr_t value_of_word(int offset) const { | |
| 160 return *addr_of_word(offset); | |
| 161 } | |
| 162 | |
| 163 public: | |
| 164 ZeroFrame *next() const { | |
| 165 return (ZeroFrame *) value_of_word(next_frame_off); | |
| 166 } | |
| 167 | |
| 168 protected: | |
| 169 FrameType type() const { | |
| 170 return (FrameType) value_of_word(frame_type_off); | |
| 171 } | |
| 172 | |
| 173 public: | |
| 174 bool is_entry_frame() const { | |
| 175 return type() == ENTRY_FRAME; | |
| 176 } | |
| 177 bool is_interpreter_frame() const { | |
| 178 return type() == INTERPRETER_FRAME; | |
| 179 } | |
| 180 bool is_shark_frame() const { | |
| 181 return type() == SHARK_FRAME; | |
| 182 } | |
| 183 bool is_fake_stub_frame() const { | |
| 184 return type() == FAKE_STUB_FRAME; | |
| 185 } | |
| 186 | |
| 187 public: | |
| 188 EntryFrame *as_entry_frame() const { | |
| 189 assert(is_entry_frame(), "should be"); | |
| 190 return (EntryFrame *) this; | |
| 191 } | |
| 192 InterpreterFrame *as_interpreter_frame() const { | |
| 193 assert(is_interpreter_frame(), "should be"); | |
| 194 return (InterpreterFrame *) this; | |
| 195 } | |
| 196 SharkFrame *as_shark_frame() const { | |
| 197 assert(is_shark_frame(), "should be"); | |
| 198 return (SharkFrame *) this; | |
| 199 } | |
| 200 FakeStubFrame *as_fake_stub_frame() const { | |
| 201 assert(is_fake_stub_frame(), "should be"); | |
| 202 return (FakeStubFrame *) this; | |
| 203 } | |
| 204 | |
| 205 public: | |
| 206 void identify_word(int frame_index, | |
| 207 int offset, | |
| 208 char* fieldbuf, | |
| 209 char* valuebuf, | |
| 210 int buflen) const; | |
| 211 | |
| 212 protected: | |
| 213 void identify_vp_word(int frame_index, | |
| 214 intptr_t* addr, | |
| 215 intptr_t* monitor_base, | |
| 216 intptr_t* stack_base, | |
| 217 char* fieldbuf, | |
| 218 int buflen) const; | |
| 219 }; |