Mercurial > hg > graal-compiler
view src/cpu/zero/vm/stack_zero.hpp @ 3550:aee1479c0a4b
Use 2 different marks for NEAR/FAR polling : fixes wrong polling addresse problem after relocation
author | Gilles Duboscq <gilles.duboscq@oracle.com> |
---|---|
date | Mon, 22 Aug 2011 14:39:05 +0200 |
parents | f95d63e2154a |
children |
line wrap: on
line source
/* * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright 2008, 2009, 2010 Red Hat, Inc. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #ifndef CPU_ZERO_VM_STACK_ZERO_HPP #define CPU_ZERO_VM_STACK_ZERO_HPP #include "utilities/sizes.hpp" class ZeroStack { private: intptr_t *_base; // the last available word intptr_t *_top; // the word past the end of the stack intptr_t *_sp; // the top word on the stack private: int _shadow_pages_size; // how much ABI stack must we keep free? public: ZeroStack() : _base(NULL), _top(NULL), _sp(NULL) { _shadow_pages_size = StackShadowPages * os::vm_page_size(); } bool needs_setup() const { return _base == NULL; } int suggest_size(Thread *thread) const; void setup(void *mem, size_t size) { assert(needs_setup(), "already set up"); assert(!(size & WordAlignmentMask), "unaligned"); _base = (intptr_t *) mem; _top = _base + (size >> LogBytesPerWord); _sp = _top; } void teardown() { assert(!needs_setup(), "not set up"); assert(_sp == _top, "stuff on stack at teardown"); _base = NULL; _top = NULL; _sp = NULL; } intptr_t *sp() const { return _sp; } void set_sp(intptr_t *new_sp) { assert(_top >= new_sp && new_sp >= _base, "bad stack pointer"); _sp = new_sp; } int total_words() const { return _top - _base; } int available_words() const { return _sp - _base; } void push(intptr_t value) { assert(_sp > _base, "stack overflow"); *(--_sp) = value; } intptr_t pop() { assert(_sp < _top, "stack underflow"); return *(_sp++); } void *alloc(size_t size) { int count = align_size_up(size, wordSize) >> LogBytesPerWord; assert(count <= available_words(), "stack overflow"); return _sp -= count; } int shadow_pages_size() const { return _shadow_pages_size; } int abi_stack_available(Thread *thread) const; public: void overflow_check(int required_words, TRAPS); static void handle_overflow(TRAPS); public: void zap(int c) PRODUCT_RETURN; public: static ByteSize base_offset() { return byte_offset_of(ZeroStack, _base); } static ByteSize top_offset() { return byte_offset_of(ZeroStack, _top); } static ByteSize sp_offset() { return byte_offset_of(ZeroStack, _sp); } }; class EntryFrame; class InterpreterFrame; class SharkFrame; class FakeStubFrame; // // | ... | // +--------------------+ ------------------ // | ... | low addresses // | frame_type | // | next_frame | high addresses // +--------------------+ ------------------ // | ... | class ZeroFrame { friend class frame; friend class ZeroStackPrinter; protected: ZeroFrame() { ShouldNotCallThis(); } enum Layout { next_frame_off, frame_type_off, jf_header_words }; enum FrameType { ENTRY_FRAME = 1, INTERPRETER_FRAME, SHARK_FRAME, FAKE_STUB_FRAME }; protected: intptr_t *addr_of_word(int offset) const { return (intptr_t *) this - offset; } intptr_t value_of_word(int offset) const { return *addr_of_word(offset); } public: ZeroFrame *next() const { return (ZeroFrame *) value_of_word(next_frame_off); } protected: FrameType type() const { return (FrameType) value_of_word(frame_type_off); } public: bool is_entry_frame() const { return type() == ENTRY_FRAME; } bool is_interpreter_frame() const { return type() == INTERPRETER_FRAME; } bool is_shark_frame() const { return type() == SHARK_FRAME; } bool is_fake_stub_frame() const { return type() == FAKE_STUB_FRAME; } public: EntryFrame *as_entry_frame() const { assert(is_entry_frame(), "should be"); return (EntryFrame *) this; } InterpreterFrame *as_interpreter_frame() const { assert(is_interpreter_frame(), "should be"); return (InterpreterFrame *) this; } SharkFrame *as_shark_frame() const { assert(is_shark_frame(), "should be"); return (SharkFrame *) this; } FakeStubFrame *as_fake_stub_frame() const { assert(is_fake_stub_frame(), "should be"); return (FakeStubFrame *) this; } public: void identify_word(int frame_index, int offset, char* fieldbuf, char* valuebuf, int buflen) const; protected: void identify_vp_word(int frame_index, intptr_t* addr, intptr_t* monitor_base, intptr_t* stack_base, char* fieldbuf, int buflen) const; }; #endif // CPU_ZERO_VM_STACK_ZERO_HPP