Mercurial > hg > graal-compiler
view src/share/vm/shark/sharkCacheDecache.cpp @ 20673:01de5cfa06c1
Added tag hs25.40-b21 for changeset 6bf89bfe8185
author | amurillo |
---|---|
date | Thu, 27 Nov 2014 09:48:34 -0800 |
parents | 2cd5e15048e6 |
children | 291ffc492eb6 |
line wrap: on
line source
/* * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. * Copyright 2008, 2009 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 "ci/ciMethod.hpp" #include "code/debugInfoRec.hpp" #include "shark/llvmValue.hpp" #include "shark/sharkBuilder.hpp" #include "shark/sharkCacheDecache.hpp" #include "shark/sharkFunction.hpp" #include "shark/sharkState.hpp" using namespace llvm; void SharkDecacher::start_frame() { // Start recording the debug information _pc_offset = code_buffer()->create_unique_offset(); _oopmap = new OopMap( oopmap_slot_munge(stack()->oopmap_frame_size()), oopmap_slot_munge(arg_size())); debug_info()->add_safepoint(pc_offset(), oopmap()); } void SharkDecacher::start_stack(int stack_depth) { // Create the array we'll record our stack slots in _exparray = new GrowableArray<ScopeValue*>(stack_depth); // Set the stack pointer stack()->CreateStoreStackPointer( builder()->CreatePtrToInt( stack()->slot_addr( stack()->stack_slots_offset() + max_stack() - stack_depth), SharkType::intptr_type())); } void SharkDecacher::process_stack_slot(int index, SharkValue** addr, int offset) { SharkValue *value = *addr; // Write the value to the frame if necessary if (stack_slot_needs_write(index, value)) { write_value_to_frame( SharkType::to_stackType(value->basic_type()), value->generic_value(), adjusted_offset(value, offset)); } // Record the value in the oopmap if necessary if (stack_slot_needs_oopmap(index, value)) { oopmap()->set_oop(slot2reg(offset)); } // Record the value in the debuginfo if necessary if (stack_slot_needs_debuginfo(index, value)) { exparray()->append(slot2lv(offset, stack_location_type(index, addr))); } } void SharkDecacher::start_monitors(int num_monitors) { // Create the array we'll record our monitors in _monarray = new GrowableArray<MonitorValue*>(num_monitors); } void SharkDecacher::process_monitor(int index, int box_offset, int obj_offset) { oopmap()->set_oop(slot2reg(obj_offset)); monarray()->append(new MonitorValue( slot2lv (obj_offset, Location::oop), slot2loc(box_offset, Location::normal))); } void SharkDecacher::process_oop_tmp_slot(Value** value, int offset) { // Decache the temporary oop slot if (*value) { write_value_to_frame( SharkType::oop_type(), *value, offset); oopmap()->set_oop(slot2reg(offset)); } } void SharkDecacher::process_method_slot(Value** value, int offset) { // Decache the method pointer write_value_to_frame( SharkType::Method_type(), *value, offset); } void SharkDecacher::process_pc_slot(int offset) { // Record the PC builder()->CreateStore( builder()->code_buffer_address(pc_offset()), stack()->slot_addr(offset)); } void SharkDecacher::start_locals() { // Create the array we'll record our local variables in _locarray = new GrowableArray<ScopeValue*>(max_locals());} void SharkDecacher::process_local_slot(int index, SharkValue** addr, int offset) { SharkValue *value = *addr; // Write the value to the frame if necessary if (local_slot_needs_write(index, value)) { write_value_to_frame( SharkType::to_stackType(value->basic_type()), value->generic_value(), adjusted_offset(value, offset)); } // Record the value in the oopmap if necessary if (local_slot_needs_oopmap(index, value)) { oopmap()->set_oop(slot2reg(offset)); } // Record the value in the debuginfo if necessary if (local_slot_needs_debuginfo(index, value)) { locarray()->append(slot2lv(offset, local_location_type(index, addr))); } } void SharkDecacher::end_frame() { // Record the scope debug_info()->describe_scope( pc_offset(), target(), bci(), true, false, false, debug_info()->create_scope_values(locarray()), debug_info()->create_scope_values(exparray()), debug_info()->create_monitor_values(monarray())); // Finish recording the debug information debug_info()->end_safepoint(pc_offset()); } void SharkCacher::process_stack_slot(int index, SharkValue** addr, int offset) { SharkValue *value = *addr; // Read the value from the frame if necessary if (stack_slot_needs_read(index, value)) { *addr = SharkValue::create_generic( value->type(), read_value_from_frame( SharkType::to_stackType(value->basic_type()), adjusted_offset(value, offset)), value->zero_checked()); } } void SharkOSREntryCacher::process_monitor(int index, int box_offset, int obj_offset) { // Copy the monitor from the OSR buffer to the frame int src_offset = max_locals() + index * 2; builder()->CreateStore( builder()->CreateLoad( CreateAddressOfOSRBufEntry(src_offset, SharkType::intptr_type())), stack()->slot_addr(box_offset, SharkType::intptr_type())); builder()->CreateStore( builder()->CreateLoad( CreateAddressOfOSRBufEntry(src_offset + 1, SharkType::oop_type())), stack()->slot_addr(obj_offset, SharkType::oop_type())); } void SharkCacher::process_oop_tmp_slot(Value** value, int offset) { // Cache the temporary oop if (*value) *value = read_value_from_frame(SharkType::oop_type(), offset); } void SharkCacher::process_method_slot(Value** value, int offset) { // Cache the method pointer *value = read_value_from_frame(SharkType::Method_type(), offset); } void SharkFunctionEntryCacher::process_method_slot(Value** value, int offset) { // "Cache" the method pointer *value = method(); } void SharkCacher::process_local_slot(int index, SharkValue** addr, int offset) { SharkValue *value = *addr; // Read the value from the frame if necessary if (local_slot_needs_read(index, value)) { *addr = SharkValue::create_generic( value->type(), read_value_from_frame( SharkType::to_stackType(value->basic_type()), adjusted_offset(value, offset)), value->zero_checked()); } } Value* SharkOSREntryCacher::CreateAddressOfOSRBufEntry(int offset, Type* type) { Value *result = builder()->CreateStructGEP(osr_buf(), offset); if (type != SharkType::intptr_type()) result = builder()->CreateBitCast(result, PointerType::getUnqual(type)); return result; } void SharkOSREntryCacher::process_local_slot(int index, SharkValue** addr, int offset) { SharkValue *value = *addr; // Read the value from the OSR buffer if necessary if (local_slot_needs_read(index, value)) { *addr = SharkValue::create_generic( value->type(), builder()->CreateLoad( CreateAddressOfOSRBufEntry( adjusted_offset(value, max_locals() - 1 - index), SharkType::to_stackType(value->basic_type()))), value->zero_checked()); } } void SharkDecacher::write_value_to_frame(Type* type, Value* value, int offset) { builder()->CreateStore(value, stack()->slot_addr(offset, type)); } Value* SharkCacher::read_value_from_frame(Type* type, int offset) { return builder()->CreateLoad(stack()->slot_addr(offset, type)); }