jdk8-mips64-public/hotspot: src/share/vm/shark/sharkCacheDecache.cpp@710a3c8b516e (annotated)

src/share/vm/shark/sharkCacheDecache.cpp@710a3c8b516e (annotated)

src/share/vm/shark/sharkCacheDecache.cpp

Tue, 08 Aug 2017 15:57:29 +0800

author: aoqi
date: Tue, 08 Aug 2017 15:57:29 +0800
changeset 6876: 710a3c8b516e
parent 4314: 2cd5e15048e6
parent 0: f90c822e73f8
permissions: -rw-r--r--

merge

 /*
  * 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));
 }

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/shark/sharkCacheDecache.cpp@710a3c8b516e (annotated)

src/share/vm/shark/sharkCacheDecache.cpp