/*

 * 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;

}

AOTOopRecorder::AOTOopRecorder(Arena* arena, bool deduplicate) : OopRecorder(arena, deduplicate) {

  _meta_strings = new GrowableArray<const char*>();

}

int AOTOopRecorder::nr_meta_strings() const {

  return _meta_strings->length();

}

const char* AOTOopRecorder::meta_element(int pos) const {

  return _meta_strings->at(pos);

}

int AOTOopRecorder::find_index(Metadata* h) {

  int index =  this->OopRecorder::find_index(h);

  Klass* klass = NULL;

  if (h->is_klass()) {

    klass = (Klass*) h;

    record_meta_string(klass->signature_name(), index);

  } else if (h->is_method()) {

    Method* method = (Method*) h;

    // Need klass->signature_name() in method name

    klass = method->method_holder();

    const char* klass_name = klass->signature_name();

    int klass_name_len  = (int)strlen(klass_name);

    Symbol* method_name = method->name();

    Symbol* signature   = method->signature();

    int method_name_len = method_name->utf8_length();

    int method_sign_len = signature->utf8_length();

    int len             = klass_name_len + 1 + method_name_len + method_sign_len;

    char* dest          = NEW_RESOURCE_ARRAY(char, len + 1);

    strcpy(dest, klass_name);

    dest[klass_name_len] = '.';

    strcpy(&dest[klass_name_len + 1], method_name->as_C_string());

    strcpy(&dest[klass_name_len + 1 + method_name_len], signature->as_C_string());

    dest[len] = 0;

    record_meta_string(dest, index);

  }

  return index;

}

int AOTOopRecorder::find_index(jobject h) {

  if (h == NULL) {

    return 0;

  }

  oop javaMirror = JNIHandles::resolve(h);

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

  return find_index(klass);

}

void AOTOopRecorder::record_meta_string(const char* name, int index) {

  assert(index > 0, "must be 1..n");

  index -= 1; // reduce by one to convert to array index

  if (index < _meta_strings->length()) {

    assert(strcmp(name, _meta_strings->at(index)) == 0, "must match");

  } else {

    assert(index == _meta_strings->length(), "must be last");

    _meta_strings->append(name);

  }

}

void* CodeInstaller::record_metadata_reference(CodeSection* section, address dest, Handle constant, TRAPS) {

  /*

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

    section->relocate(dest, metadata_Relocation::spec(index));

    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);

    section->relocate(dest, metadata_Relocation::spec(index));

    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

narrowKlass CodeInstaller::record_narrow_metadata_reference(CodeSection* section, address dest, Handle constant, TRAPS) {

  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);

  section->relocate(dest, metadata_Relocation::spec(index));

  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());

        }

      }

    }

  }