Mercurial > hg > graal-compiler
view src/cpu/zero/vm/interpreterRT_zero.cpp @ 10953:97e282186b5b
Add heap sanity checker with premature hard crash for debugging write barriers
author | Christos Kotselidis <christos.kotselidis@oracle.com> |
---|---|
date | Fri, 02 Aug 2013 19:03:05 +0200 |
parents | da91efe96a93 |
children |
line wrap: on
line source
/* * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * Copyright 2007, 2008, 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. * */ #include "precompiled.hpp" #include "interpreter/interpreter.hpp" #include "interpreter/interpreterRuntime.hpp" #include "memory/allocation.inline.hpp" #include "memory/universe.inline.hpp" #include "oops/method.hpp" #include "oops/oop.inline.hpp" #include "runtime/handles.inline.hpp" #include "runtime/icache.hpp" #include "runtime/interfaceSupport.hpp" #include "runtime/signature.hpp" #include "stack_zero.inline.hpp" void InterpreterRuntime::SignatureHandlerGeneratorBase::pass_int() { push(T_INT); _cif->nargs++; } void InterpreterRuntime::SignatureHandlerGeneratorBase::pass_long() { push(T_LONG); _cif->nargs++; } void InterpreterRuntime::SignatureHandlerGeneratorBase::pass_float() { push(T_FLOAT); _cif->nargs++; } void InterpreterRuntime::SignatureHandlerGeneratorBase::pass_double() { push(T_DOUBLE); _cif->nargs++; } void InterpreterRuntime::SignatureHandlerGeneratorBase::pass_object() { push(T_OBJECT); _cif->nargs++; } void InterpreterRuntime::SignatureHandlerGeneratorBase::push(BasicType type) { ffi_type *ftype; switch (type) { case T_VOID: ftype = &ffi_type_void; break; case T_BOOLEAN: ftype = &ffi_type_uint8; break; case T_CHAR: ftype = &ffi_type_uint16; break; case T_BYTE: ftype = &ffi_type_sint8; break; case T_SHORT: ftype = &ffi_type_sint16; break; case T_INT: ftype = &ffi_type_sint32; break; case T_LONG: ftype = &ffi_type_sint64; break; case T_FLOAT: ftype = &ffi_type_float; break; case T_DOUBLE: ftype = &ffi_type_double; break; case T_OBJECT: case T_ARRAY: ftype = &ffi_type_pointer; break; default: ShouldNotReachHere(); } push((intptr_t) ftype); } // For fast signature handlers the "signature handler" is generated // into a temporary buffer. It is then copied to its final location, // and pd_set_handler is called on it. We have this two stage thing // to accomodate this. void InterpreterRuntime::SignatureHandlerGeneratorBase::generate( uint64_t fingerprint) { // Build the argument types list pass_object(); if (method()->is_static()) pass_object(); iterate(fingerprint); // Tack on the result type push(method()->result_type()); } void InterpreterRuntime::SignatureHandler::finalize() { ffi_status status = ffi_prep_cif(cif(), FFI_DEFAULT_ABI, argument_count(), result_type(), argument_types()); assert(status == FFI_OK, "should be"); } IRT_ENTRY(address, InterpreterRuntime::slow_signature_handler(JavaThread* thread, Method* method, intptr_t* unused1, intptr_t* unused2)) ZeroStack *stack = thread->zero_stack(); int required_words = (align_size_up(sizeof(ffi_cif), wordSize) >> LogBytesPerWord) + (method->is_static() ? 2 : 1) + method->size_of_parameters() + 1; stack->overflow_check(required_words, CHECK_NULL); intptr_t *buf = (intptr_t *) stack->alloc(required_words * wordSize); SlowSignatureHandlerGenerator sshg(methodHandle(thread, method), buf); sshg.generate(UCONST64(-1)); SignatureHandler *handler = sshg.handler(); handler->finalize(); return (address) handler; IRT_END void SignatureHandlerLibrary::pd_set_handler(address handlerAddr) { InterpreterRuntime::SignatureHandler *handler = InterpreterRuntime::SignatureHandler::from_handlerAddr(handlerAddr); handler->finalize(); }