Mercurial > hg > truffle
annotate src/cpu/zero/vm/stack_zero.hpp @ 1972:f95d63e2154a
6989984: Use standard include model for Hospot
Summary: Replaced MakeDeps and the includeDB files with more standardized solutions.
Reviewed-by: coleenp, kvn, kamg
| author | stefank |
|---|---|
| date | Tue, 23 Nov 2010 13:22:55 -0800 |
| parents | c18cbe5936b8 |
| children |
| rev | line source |
|---|---|
| 1010 | 1 /* |
| 1972 | 2 * Copyright (c) 2003, 2010, 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 | |
| 1972 | 26 #ifndef CPU_ZERO_VM_STACK_ZERO_HPP |
| 27 #define CPU_ZERO_VM_STACK_ZERO_HPP | |
| 28 | |
| 29 #include "utilities/sizes.hpp" | |
| 30 | |
| 1010 | 31 class ZeroStack { |
| 32 private: | |
| 33 intptr_t *_base; // the last available word | |
| 34 intptr_t *_top; // the word past the end of the stack | |
| 35 intptr_t *_sp; // the top word on the stack | |
| 36 | |
| 1379 | 37 private: |
| 38 int _shadow_pages_size; // how much ABI stack must we keep free? | |
| 39 | |
| 1010 | 40 public: |
| 41 ZeroStack() | |
| 1379 | 42 : _base(NULL), _top(NULL), _sp(NULL) { |
| 43 _shadow_pages_size = StackShadowPages * os::vm_page_size(); | |
| 44 } | |
| 1010 | 45 |
| 46 bool needs_setup() const { | |
| 47 return _base == NULL; | |
| 48 } | |
| 49 | |
| 1511 | 50 int suggest_size(Thread *thread) const; |
| 51 | |
| 1010 | 52 void setup(void *mem, size_t size) { |
| 53 assert(needs_setup(), "already set up"); | |
| 54 assert(!(size & WordAlignmentMask), "unaligned"); | |
| 55 | |
| 56 _base = (intptr_t *) mem; | |
| 57 _top = _base + (size >> LogBytesPerWord); | |
| 58 _sp = _top; | |
| 59 } | |
| 60 void teardown() { | |
| 61 assert(!needs_setup(), "not set up"); | |
| 62 assert(_sp == _top, "stuff on stack at teardown"); | |
| 63 | |
| 64 _base = NULL; | |
| 65 _top = NULL; | |
| 66 _sp = NULL; | |
| 67 } | |
| 68 | |
| 69 intptr_t *sp() const { | |
| 70 return _sp; | |
| 71 } | |
| 72 void set_sp(intptr_t *new_sp) { | |
| 73 assert(_top >= new_sp && new_sp >= _base, "bad stack pointer"); | |
| 74 _sp = new_sp; | |
| 75 } | |
| 76 | |
| 1511 | 77 int total_words() const { |
| 78 return _top - _base; | |
| 79 } | |
| 1010 | 80 int available_words() const { |
| 81 return _sp - _base; | |
| 82 } | |
| 83 | |
| 84 void push(intptr_t value) { | |
| 85 assert(_sp > _base, "stack overflow"); | |
| 86 *(--_sp) = value; | |
| 87 } | |
| 88 intptr_t pop() { | |
| 89 assert(_sp < _top, "stack underflow"); | |
| 90 return *(_sp++); | |
| 91 } | |
| 92 | |
| 93 void *alloc(size_t size) { | |
| 94 int count = align_size_up(size, wordSize) >> LogBytesPerWord; | |
| 95 assert(count <= available_words(), "stack overflow"); | |
| 96 return _sp -= count; | |
| 97 } | |
| 98 | |
| 1379 | 99 int shadow_pages_size() const { |
| 100 return _shadow_pages_size; | |
| 101 } | |
| 1511 | 102 int abi_stack_available(Thread *thread) const; |
| 1379 | 103 |
| 104 public: | |
| 105 void overflow_check(int required_words, TRAPS); | |
| 106 static void handle_overflow(TRAPS); | |
| 107 | |
| 1010 | 108 public: |
| 1505 | 109 void zap(int c) PRODUCT_RETURN; |
| 110 | |
| 111 public: | |
| 1010 | 112 static ByteSize base_offset() { |
| 113 return byte_offset_of(ZeroStack, _base); | |
| 114 } | |
| 115 static ByteSize top_offset() { | |
| 116 return byte_offset_of(ZeroStack, _top); | |
| 117 } | |
| 118 static ByteSize sp_offset() { | |
| 119 return byte_offset_of(ZeroStack, _sp); | |
| 120 } | |
| 121 }; | |
| 122 | |
| 123 | |
| 124 class EntryFrame; | |
| 125 class InterpreterFrame; | |
| 126 class SharkFrame; | |
| 127 class FakeStubFrame; | |
| 128 | |
| 129 // | |
| 130 // | ... | | |
| 131 // +--------------------+ ------------------ | |
| 132 // | ... | low addresses | |
| 133 // | frame_type | | |
| 134 // | next_frame | high addresses | |
| 135 // +--------------------+ ------------------ | |
| 136 // | ... | | |
| 137 | |
| 138 class ZeroFrame { | |
| 139 friend class frame; | |
| 140 friend class ZeroStackPrinter; | |
| 141 | |
| 142 protected: | |
| 143 ZeroFrame() { | |
| 144 ShouldNotCallThis(); | |
| 145 } | |
| 146 | |
| 147 enum Layout { | |
| 148 next_frame_off, | |
| 149 frame_type_off, | |
| 150 jf_header_words | |
| 151 }; | |
| 152 | |
| 153 enum FrameType { | |
| 154 ENTRY_FRAME = 1, | |
| 155 INTERPRETER_FRAME, | |
| 156 SHARK_FRAME, | |
| 157 FAKE_STUB_FRAME | |
| 158 }; | |
| 159 | |
| 160 protected: | |
| 161 intptr_t *addr_of_word(int offset) const { | |
| 162 return (intptr_t *) this - offset; | |
| 163 } | |
| 164 intptr_t value_of_word(int offset) const { | |
| 165 return *addr_of_word(offset); | |
| 166 } | |
| 167 | |
| 168 public: | |
| 169 ZeroFrame *next() const { | |
| 170 return (ZeroFrame *) value_of_word(next_frame_off); | |
| 171 } | |
| 172 | |
| 173 protected: | |
| 174 FrameType type() const { | |
| 175 return (FrameType) value_of_word(frame_type_off); | |
| 176 } | |
| 177 | |
| 178 public: | |
| 179 bool is_entry_frame() const { | |
| 180 return type() == ENTRY_FRAME; | |
| 181 } | |
| 182 bool is_interpreter_frame() const { | |
| 183 return type() == INTERPRETER_FRAME; | |
| 184 } | |
| 185 bool is_shark_frame() const { | |
| 186 return type() == SHARK_FRAME; | |
| 187 } | |
| 188 bool is_fake_stub_frame() const { | |
| 189 return type() == FAKE_STUB_FRAME; | |
| 190 } | |
| 191 | |
| 192 public: | |
| 193 EntryFrame *as_entry_frame() const { | |
| 194 assert(is_entry_frame(), "should be"); | |
| 195 return (EntryFrame *) this; | |
| 196 } | |
| 197 InterpreterFrame *as_interpreter_frame() const { | |
| 198 assert(is_interpreter_frame(), "should be"); | |
| 199 return (InterpreterFrame *) this; | |
| 200 } | |
| 201 SharkFrame *as_shark_frame() const { | |
| 202 assert(is_shark_frame(), "should be"); | |
| 203 return (SharkFrame *) this; | |
| 204 } | |
| 205 FakeStubFrame *as_fake_stub_frame() const { | |
| 206 assert(is_fake_stub_frame(), "should be"); | |
| 207 return (FakeStubFrame *) this; | |
| 208 } | |
| 209 | |
| 210 public: | |
| 211 void identify_word(int frame_index, | |
| 212 int offset, | |
| 213 char* fieldbuf, | |
| 214 char* valuebuf, | |
| 215 int buflen) const; | |
| 216 | |
| 217 protected: | |
| 218 void identify_vp_word(int frame_index, | |
| 219 intptr_t* addr, | |
| 220 intptr_t* monitor_base, | |
| 221 intptr_t* stack_base, | |
| 222 char* fieldbuf, | |
| 223 int buflen) const; | |
| 224 }; | |
| 1972 | 225 |
| 226 #endif // CPU_ZERO_VM_STACK_ZERO_HPP |