/*

 * Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.

 * 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 "asm/register.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/compiledIC.hpp"

#include "code/vmreg.inline.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/disassembler.hpp"

#include "jvmci/jvmciEnv.hpp"

#include "jvmci/jvmciCompiler.hpp"

#include "jvmci/jvmciCodeInstaller.hpp"

#include "jvmci/jvmciJavaClasses.hpp"

#include "jvmci/jvmciCompilerToVM.hpp"

#include "jvmci/jvmciRuntime.hpp"

#include "oops/oop.inline.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "runtime/javaCalls.hpp"

// frequently used constants

// Allocate them with new so they are never destroyed (otherwise, a

// forced exit could destroy these objects while they are still in

// use).

ConstantOopWriteValue* CodeInstaller::_oop_null_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantOopWriteValue(NULL);

ConstantIntValue*      CodeInstaller::_int_m1_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(-1);

ConstantIntValue*      CodeInstaller::_int_0_scope_value =  new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(0);

ConstantIntValue*      CodeInstaller::_int_1_scope_value =  new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(1);

ConstantIntValue*      CodeInstaller::_int_2_scope_value =  new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(2);

LocationValue*         CodeInstaller::_illegal_value = new (ResourceObj::C_HEAP, mtCompiler) LocationValue(Location());

Method* getMethodFromHotSpotMethod(oop hotspot_method) {

  assert(hotspot_method != NULL && hotspot_method->is_a(HotSpotResolvedJavaMethodImpl::klass()), "sanity");

  return CompilerToVM::asMethod(hotspot_method);

}

VMReg getVMRegFromLocation(Handle location, int total_frame_size, TRAPS) {

  if (location.is_null()) {

    THROW_NULL(vmSymbols::java_lang_NullPointerException());

  }

  Handle reg = code_Location::reg(location);

  jint offset = code_Location::offset(location);

  if (reg.not_null()) {

    // register

    jint number = code_Register::number(reg);

    VMReg vmReg = CodeInstaller::get_hotspot_reg(number, CHECK_NULL);

    if (offset % 4 == 0) {

      return vmReg->next(offset / 4);

    } else {

      JVMCI_ERROR_NULL("unaligned subregister offset %d in oop map", offset);

    }

  } else {

    // stack slot

    if (offset % 4 == 0) {

      VMReg vmReg = VMRegImpl::stack2reg(offset / 4);

      if (!OopMapValue::legal_vm_reg_name(vmReg)) {

        // This restriction only applies to VMRegs that are used in OopMap but

        // since that's the only use of VMRegs it's simplest to put this test

        // here.  This test should also be equivalent legal_vm_reg_name but JVMCI

        // clients can use max_oop_map_stack_stack_offset to detect this problem

        // directly.  The asserts just ensure that the tests are in agreement.

        assert(offset > CompilerToVM::Data::max_oop_map_stack_offset(), "illegal VMReg");

        JVMCI_ERROR_NULL("stack offset %d is too large to be encoded in OopMap (max %d)",

                         offset, CompilerToVM::Data::max_oop_map_stack_offset());

      }

      assert(OopMapValue::legal_vm_reg_name(vmReg), "illegal VMReg");

      return vmReg;

    } else {

      JVMCI_ERROR_NULL("unaligned stack offset %d in oop map", offset);

    }

  }

}

// creates a HotSpot oop map out of the byte arrays provided by DebugInfo

OopMap* CodeInstaller::create_oop_map(Handle debug_info, TRAPS) {

  Handle reference_map = DebugInfo::referenceMap(debug_info);

  if (reference_map.is_null()) {

    THROW_NULL(vmSymbols::java_lang_NullPointerException());

  }

  if (!reference_map->is_a(HotSpotReferenceMap::klass())) {

    JVMCI_ERROR_NULL("unknown reference map: %s", reference_map->klass()->signature_name());

  }

  if (HotSpotReferenceMap::maxRegisterSize(reference_map) > 16) {

    _has_wide_vector = true;

  }

  OopMap* map = new OopMap(_total_frame_size, _parameter_count);

  objArrayHandle objects = HotSpotReferenceMap::objects(reference_map);

  objArrayHandle derivedBase = HotSpotReferenceMap::derivedBase(reference_map);

  typeArrayHandle sizeInBytes = HotSpotReferenceMap::sizeInBytes(reference_map);

  if (objects.is_null() || derivedBase.is_null() || sizeInBytes.is_null()) {

    THROW_NULL(vmSymbols::java_lang_NullPointerException());

  }

  if (objects->length() != derivedBase->length() || objects->length() != sizeInBytes->length()) {

    JVMCI_ERROR_NULL("arrays in reference map have different sizes: %d %d %d", objects->length(), derivedBase->length(), sizeInBytes->length());

  }

  for (int i = 0; i < objects->length(); i++) {

    Handle location = objects->obj_at(i);

    Handle baseLocation = derivedBase->obj_at(i);

    int bytes = sizeInBytes->int_at(i);

    VMReg vmReg = getVMRegFromLocation(location, _total_frame_size, CHECK_NULL);

    if (baseLocation.not_null()) {

      // derived oop

#ifdef _LP64

      if (bytes == 8) {

#else

      if (bytes == 4) {

#endif

        VMReg baseReg = getVMRegFromLocation(baseLocation, _total_frame_size, CHECK_NULL);

        map->set_derived_oop(vmReg, baseReg);

      } else {

        JVMCI_ERROR_NULL("invalid derived oop size in ReferenceMap: %d", bytes);

      }

#ifdef _LP64

    } else if (bytes == 8) {

      // wide oop

      map->set_oop(vmReg);

    } else if (bytes == 4) {

      // narrow oop

      map->set_narrowoop(vmReg);

#else

    } else if (bytes == 4) {

      map->set_oop(vmReg);

#endif

    } else {

      JVMCI_ERROR_NULL("invalid oop size in ReferenceMap: %d", bytes);

    }

  }

  Handle callee_save_info = (oop) DebugInfo::calleeSaveInfo(debug_info);

  if (callee_save_info.not_null()) {

    objArrayHandle registers = RegisterSaveLayout::registers(callee_save_info);

    typeArrayHandle slots = RegisterSaveLayout::slots(callee_save_info);

    for (jint i = 0; i < slots->length(); i++) {

      Handle jvmci_reg = registers->obj_at(i);

      jint jvmci_reg_number = code_Register::number(jvmci_reg);

      VMReg hotspot_reg = CodeInstaller::get_hotspot_reg(jvmci_reg_number, CHECK_NULL);

      // HotSpot stack slots are 4 bytes

      jint jvmci_slot = slots->int_at(i);

      jint hotspot_slot = jvmci_slot * VMRegImpl::slots_per_word;

      VMReg hotspot_slot_as_reg = VMRegImpl::stack2reg(hotspot_slot);

      map->set_callee_saved(hotspot_slot_as_reg, hotspot_reg);

#ifdef _LP64

      // (copied from generate_oop_map() in c1_Runtime1_x86.cpp)

      VMReg hotspot_slot_hi_as_reg = VMRegImpl::stack2reg(hotspot_slot + 1);

      map->set_callee_saved(hotspot_slot_hi_as_reg, hotspot_reg->next());

#endif

    }

  }

  return map;

}

  /*

   * This method needs to return a raw (untyped) pointer, since the value of a pointer to the base

   * class is in general not equal to the pointer of the subclass. When patching metaspace pointers,

   * the compiler expects a direct pointer to the subclass (Klass* or Method*), not a pointer to the

   * base class (Metadata* or MetaspaceObj*).

   */

  oop obj = HotSpotMetaspaceConstantImpl::metaspaceObject(constant);

  if (obj->is_a(HotSpotResolvedObjectTypeImpl::klass())) {

    Klass* klass = java_lang_Class::as_Klass(HotSpotResolvedObjectTypeImpl::javaClass(obj));

    assert(!HotSpotMetaspaceConstantImpl::compressed(constant), "unexpected compressed klass pointer %s @ " INTPTR_FORMAT, klass->name()->as_C_string(), p2i(klass));

    int index = _oop_recorder->find_index(klass);

    TRACE_jvmci_3("metadata[%d of %d] = %s", index, _oop_recorder->metadata_count(), klass->name()->as_C_string());

    return klass;

  } else if (obj->is_a(HotSpotResolvedJavaMethodImpl::klass())) {

    Method* method = (Method*) (address) HotSpotResolvedJavaMethodImpl::metaspaceMethod(obj);

    assert(!HotSpotMetaspaceConstantImpl::compressed(constant), "unexpected compressed method pointer %s @ " INTPTR_FORMAT, method->name()->as_C_string(), p2i(method));

    int index = _oop_recorder->find_index(method);

    TRACE_jvmci_3("metadata[%d of %d] = %s", index, _oop_recorder->metadata_count(), method->name()->as_C_string());

    return method;

  } else {

    JVMCI_ERROR_NULL("unexpected metadata reference for constant of type %s", obj->klass()->signature_name());

  }

}

#ifdef _LP64

  oop obj = HotSpotMetaspaceConstantImpl::metaspaceObject(constant);

  assert(HotSpotMetaspaceConstantImpl::compressed(constant), "unexpected uncompressed pointer");

  if (!obj->is_a(HotSpotResolvedObjectTypeImpl::klass())) {

    JVMCI_ERROR_0("unexpected compressed pointer of type %s", obj->klass()->signature_name());

  }

  Klass* klass = java_lang_Class::as_Klass(HotSpotResolvedObjectTypeImpl::javaClass(obj));

  int index = _oop_recorder->find_index(klass);

  TRACE_jvmci_3("narrowKlass[%d of %d] = %s", index, _oop_recorder->metadata_count(), klass->name()->as_C_string());

  return Klass::encode_klass(klass);

}

#endif

Location::Type CodeInstaller::get_oop_type(Handle value) {

  Handle valueKind = Value::valueKind(value);

  Handle platformKind = ValueKind::platformKind(valueKind);

  if (platformKind == word_kind()) {

    return Location::oop;

  } else {

    return Location::narrowoop;

  }

}

ScopeValue* CodeInstaller::get_scope_value(Handle value, BasicType type, GrowableArray<ScopeValue*>* objects, ScopeValue* &second, TRAPS) {

  second = NULL;

  if (value.is_null()) {

    THROW_NULL(vmSymbols::java_lang_NullPointerException());

  } else if (value == Value::ILLEGAL()) {

    if (type != T_ILLEGAL) {

      JVMCI_ERROR_NULL("unexpected illegal value, expected %s", basictype_to_str(type));

    }

    return _illegal_value;

  } else if (value->is_a(RegisterValue::klass())) {

    Handle reg = RegisterValue::reg(value);

    jint number = code_Register::number(reg);

    VMReg hotspotRegister = get_hotspot_reg(number, CHECK_NULL);

    if (is_general_purpose_reg(hotspotRegister)) {

      Location::Type locationType;

      if (type == T_OBJECT) {

        locationType = get_oop_type(value);

      } else if (type == T_LONG) {

        locationType = Location::lng;

      } else if (type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN) {

        locationType = Location::int_in_long;

      } else {

        JVMCI_ERROR_NULL("unexpected type %s in cpu register", basictype_to_str(type));

      }

      ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister));

      if (type == T_LONG) {

        second = value;

      }

      return value;

    } else {

      Location::Type locationType;

      if (type == T_FLOAT) {

        // this seems weird, but the same value is used in c1_LinearScan

        locationType = Location::normal;

      } else if (type == T_DOUBLE) {

        locationType = Location::dbl;

      } else {

        JVMCI_ERROR_NULL("unexpected type %s in floating point register", basictype_to_str(type));

      }

      ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister));

      if (type == T_DOUBLE) {

        second = value;

      }

      return value;

    }

  } else if (value->is_a(StackSlot::klass())) {

    jint offset = StackSlot::offset(value);

    if (StackSlot::addFrameSize(value)) {

      offset += _total_frame_size;

    }

    Location::Type locationType;

    if (type == T_OBJECT) {

      locationType = get_oop_type(value);

    } else if (type == T_LONG) {

      locationType = Location::lng;

    } else if (type == T_DOUBLE) {

      locationType = Location::dbl;

    } else if (type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN) {

      locationType = Location::normal;

    } else {

      JVMCI_ERROR_NULL("unexpected type %s in stack slot", basictype_to_str(type));

    }

    ScopeValue* value = new LocationValue(Location::new_stk_loc(locationType, offset));

    if (type == T_DOUBLE || type == T_LONG) {

      second = value;

    }

    return value;

  } else if (value->is_a(JavaConstant::klass())) {

    if (value->is_a(PrimitiveConstant::klass())) {

      if (value->is_a(RawConstant::klass())) {

        jlong prim = PrimitiveConstant::primitive(value);

        return new ConstantLongValue(prim);

      } else {

        BasicType constantType = JVMCIRuntime::kindToBasicType(PrimitiveConstant::kind(value), CHECK_NULL);

        if (type != constantType) {

          JVMCI_ERROR_NULL("primitive constant type doesn't match, expected %s but got %s", basictype_to_str(type), basictype_to_str(constantType));

        }

        if (type == T_INT || type == T_FLOAT) {

          jint prim = (jint)PrimitiveConstant::primitive(value);

          switch (prim) {

            case -1: return _int_m1_scope_value;

            case  0: return _int_0_scope_value;

            case  1: return _int_1_scope_value;

            case  2: return _int_2_scope_value;

            default: return new ConstantIntValue(prim);

          }

        } else if (type == T_LONG || type == T_DOUBLE) {

          jlong prim = PrimitiveConstant::primitive(value);

          second = _int_1_scope_value;

          return new ConstantLongValue(prim);

        } else {

          JVMCI_ERROR_NULL("unexpected primitive constant type %s", basictype_to_str(type));

        }

      }

    } else if (value->is_a(NullConstant::klass()) || value->is_a(HotSpotCompressedNullConstant::klass())) {

      if (type == T_OBJECT) {

        return _oop_null_scope_value;

      } else {

        JVMCI_ERROR_NULL("unexpected null constant, expected %s", basictype_to_str(type));

      }

    } else if (value->is_a(HotSpotObjectConstantImpl::klass())) {

      if (type == T_OBJECT) {

        oop obj = HotSpotObjectConstantImpl::object(value);

        if (obj == NULL) {

          JVMCI_ERROR_NULL("null value must be in NullConstant");

        }

        return new ConstantOopWriteValue(JNIHandles::make_local(obj));

      } else {

        JVMCI_ERROR_NULL("unexpected object constant, expected %s", basictype_to_str(type));

      }

    }

  } else if (value->is_a(VirtualObject::klass())) {

    if (type == T_OBJECT) {

      int id = VirtualObject::id(value);

      if (0 <= id && id < objects->length()) {

        ScopeValue* object = objects->at(id);

        if (object != NULL) {

          return object;

        }

      }

      JVMCI_ERROR_NULL("unknown virtual object id %d", id);

    } else {

      JVMCI_ERROR_NULL("unexpected virtual object, expected %s", basictype_to_str(type));

    }

  }

  JVMCI_ERROR_NULL("unexpected value in scope: %s", value->klass()->signature_name())

}

void CodeInstaller::record_object_value(ObjectValue* sv, Handle value, GrowableArray<ScopeValue*>* objects, TRAPS) {

  Handle type = VirtualObject::type(value);

  int id = VirtualObject::id(value);

  oop javaMirror = HotSpotResolvedObjectTypeImpl::javaClass(type);

  Klass* klass = java_lang_Class::as_Klass(javaMirror);

  bool isLongArray = klass == Universe::longArrayKlassObj();

  objArrayHandle values = VirtualObject::values(value);

  objArrayHandle slotKinds = VirtualObject::slotKinds(value);

  for (jint i = 0; i < values->length(); i++) {

    ScopeValue* cur_second = NULL;

    Handle object = values->obj_at(i);

    BasicType type = JVMCIRuntime::kindToBasicType(slotKinds->obj_at(i), CHECK);

    ScopeValue* value = get_scope_value(object, type, objects, cur_second, CHECK);

    if (isLongArray && cur_second == NULL) {

      // we're trying to put ints into a long array... this isn't really valid, but it's used for some optimizations.

      // add an int 0 constant

      cur_second = _int_0_scope_value;

    }

    if (cur_second != NULL) {

      sv->field_values()->append(cur_second);

    }

    assert(value != NULL, "missing value");

    sv->field_values()->append(value);

  }

}

MonitorValue* CodeInstaller::get_monitor_value(Handle value, GrowableArray<ScopeValue*>* objects, TRAPS) {

  if (value.is_null()) {

    THROW_NULL(vmSymbols::java_lang_NullPointerException());

  }

  if (!value->is_a(StackLockValue::klass())) {

    JVMCI_ERROR_NULL("Monitors must be of type StackLockValue, got %s", value->klass()->signature_name());

  }

  ScopeValue* second = NULL;

  ScopeValue* owner_value = get_scope_value(StackLockValue::owner(value), T_OBJECT, objects, second, CHECK_NULL);

  assert(second == NULL, "monitor cannot occupy two stack slots");

  ScopeValue* lock_data_value = get_scope_value(StackLockValue::slot(value), T_LONG, objects, second, CHECK_NULL);

  assert(second == lock_data_value, "monitor is LONG value that occupies two stack slots");

  assert(lock_data_value->is_location(), "invalid monitor location");

  Location lock_data_loc = ((LocationValue*)lock_data_value)->location();

  bool eliminated = false;

  if (StackLockValue::eliminated(value)) {

    eliminated = true;

  }

  return new MonitorValue(owner_value, lock_data_loc, eliminated);

}

void CodeInstaller::initialize_dependencies(oop compiled_code, OopRecorder* recorder, TRAPS) {

  JavaThread* thread = JavaThread::current();

  CompilerThread* compilerThread = thread->is_Compiler_thread() ? thread->as_CompilerThread() : NULL;

  _oop_recorder = recorder;

  _dependencies = new Dependencies(&_arena, _oop_recorder, compilerThread != NULL ? compilerThread->log() : NULL);

  objArrayHandle assumptions = HotSpotCompiledCode::assumptions(compiled_code);

  if (!assumptions.is_null()) {

    int length = assumptions->length();

    for (int i = 0; i < length; ++i) {

      Handle assumption = assumptions->obj_at(i);

      if (!assumption.is_null()) {

        if (assumption->klass() == Assumptions_NoFinalizableSubclass::klass()) {

          assumption_NoFinalizableSubclass(assumption);

        } else if (assumption->klass() == Assumptions_ConcreteSubtype::klass()) {

          assumption_ConcreteSubtype(assumption);

        } else if (assumption->klass() == Assumptions_LeafType::klass()) {

          assumption_LeafType(assumption);

        } else if (assumption->klass() == Assumptions_ConcreteMethod::klass()) {

          assumption_ConcreteMethod(assumption);

        } else if (assumption->klass() == Assumptions_CallSiteTargetValue::klass()) {

          assumption_CallSiteTargetValue(assumption);

        } else {

          JVMCI_ERROR("unexpected Assumption subclass %s", assumption->klass()->signature_name());

        }

      }

    }

  }

  if (JvmtiExport::can_hotswap_or_post_breakpoint()) {

    objArrayHandle methods = HotSpotCompiledCode::methods(compiled_code);

    if (!methods.is_null()) {

      int length = methods->length();

      for (int i = 0; i < length; ++i) {

        Handle method_handle = methods->obj_at(i);

        methodHandle method = getMethodFromHotSpotMethod(method_handle());

        _dependencies->assert_evol_method(method());

      }

    }

  }

}

RelocBuffer::~RelocBuffer() {

  if (_buffer != NULL) {

    FREE_C_HEAP_ARRAY(char, _buffer);

  }

}

address RelocBuffer::begin() const {

  if (_buffer != NULL) {

    return (address) _buffer;

  }

  return (address) _static_buffer;

}

void RelocBuffer::set_size(size_t bytes) {

  assert(bytes <= _size, "can't grow in size!");

  _size = bytes;

}

void RelocBuffer::ensure_size(size_t bytes) {

  assert(_buffer == NULL, "can only be used once");

  assert(_size == 0, "can only be used once");

  if (bytes >= RelocBuffer::stack_size) {

    _buffer = NEW_C_HEAP_ARRAY(char, bytes, mtInternal);

  }

  _size = bytes;

}

JVMCIEnv::CodeInstallResult CodeInstaller::gather_metadata(Handle target, Handle compiled_code, CodeMetadata& metadata, TRAPS) {

  CodeBuffer buffer("JVMCI Compiler CodeBuffer for Metadata");

  jobject compiled_code_obj = JNIHandles::make_local(compiled_code());

  initialize_dependencies(JNIHandles::resolve(compiled_code_obj), NULL, CHECK_OK);

  // Get instructions and constants CodeSections early because we need it.

  _instructions = buffer.insts();

  _constants = buffer.consts();

  initialize_fields(target(), JNIHandles::resolve(compiled_code_obj), CHECK_OK);

  JVMCIEnv::CodeInstallResult result = initialize_buffer(buffer, CHECK_OK);

  if (result != JVMCIEnv::ok) {

    return result;

  }

  _debug_recorder->pcs_size(); // create the sentinel record

  assert(_debug_recorder->pcs_length() >= 2, "must be at least 2");

  metadata.set_pc_desc(_debug_recorder->pcs(), _debug_recorder->pcs_length());

  metadata.set_scopes(_debug_recorder->stream()->buffer(), _debug_recorder->data_size());

  metadata.set_exception_table(&_exception_handler_table);

  RelocBuffer* reloc_buffer = metadata.get_reloc_buffer();

  reloc_buffer->ensure_size(buffer.total_relocation_size());