Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * 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