/*

 * Copyright (c) 1997, 2019, 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 "jvm.h"

#include "classfile/javaClasses.inline.hpp"

#include "classfile/moduleEntry.hpp"

#include "classfile/packageEntry.hpp"

#include "classfile/stringTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/verifier.hpp"

#include "classfile/vmSymbols.hpp"

#include "interpreter/linkResolver.hpp"

#include "logging/log.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/typeArrayOop.inline.hpp"

#include "prims/jvmtiExport.hpp"

#include "runtime/arguments.hpp"

#include "runtime/fieldDescriptor.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/reflection.hpp"

#include "runtime/reflectionUtils.hpp"

#include "runtime/signature.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/vframe.inline.hpp"

static void trace_class_resolution(const Klass* to_class) {

  ResourceMark rm;

  int line_number = -1;

  const char * source_file = NULL;

  Klass* caller = NULL;

  JavaThread* jthread = JavaThread::current();

  if (jthread->has_last_Java_frame()) {

    vframeStream vfst(jthread);

    // skip over any frames belonging to java.lang.Class

    while (!vfst.at_end() &&

           vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class()) {

      vfst.next();

    }

    if (!vfst.at_end()) {

      // this frame is a likely suspect

      caller = vfst.method()->method_holder();

      line_number = vfst.method()->line_number_from_bci(vfst.bci());

      Symbol* s = vfst.method()->method_holder()->source_file_name();

      if (s != NULL) {

        source_file = s->as_C_string();

      }

    }

  }

  if (caller != NULL) {

    const char * from = caller->external_name();

    const char * to = to_class->external_name();

    // print in a single call to reduce interleaving between threads

    if (source_file != NULL) {

      log_debug(class, resolve)("%s %s %s:%d (reflection)", from, to, source_file, line_number);

    } else {

      log_debug(class, resolve)("%s %s (reflection)", from, to);

    }

  }

}

oop Reflection::box(jvalue* value, BasicType type, TRAPS) {

  if (type == T_VOID) {

    return NULL;

  }

  if (is_reference_type(type)) {

    // regular objects are not boxed

    return (oop) value->l;

  }

  oop result = java_lang_boxing_object::create(type, value, CHECK_NULL);

  if (result == NULL) {

    THROW_(vmSymbols::java_lang_IllegalArgumentException(), result);

  }

  return result;

}

BasicType Reflection::unbox_for_primitive(oop box, jvalue* value, TRAPS) {

  if (box == NULL) {

    THROW_(vmSymbols::java_lang_IllegalArgumentException(), T_ILLEGAL);

  }

  return java_lang_boxing_object::get_value(box, value);

}

BasicType Reflection::unbox_for_regular_object(oop box, jvalue* value) {

  // Note:  box is really the unboxed oop.  It might even be a Short, etc.!

  value->l = (jobject) box;

  return T_OBJECT;

}

void Reflection::widen(jvalue* value, BasicType current_type, BasicType wide_type, TRAPS) {

  assert(wide_type != current_type, "widen should not be called with identical types");

  switch (wide_type) {

    case T_BOOLEAN:

    case T_BYTE:

    case T_CHAR:

      break;  // fail

    case T_SHORT:

      switch (current_type) {

        case T_BYTE:

          value->s = (jshort) value->b;

          return;

        default:

          break;

      }

      break;  // fail

    case T_INT:

      switch (current_type) {

        case T_BYTE:

          value->i = (jint) value->b;

          return;

        case T_CHAR:

          value->i = (jint) value->c;

          return;

        case T_SHORT:

          value->i = (jint) value->s;

          return;

        default:

          break;

      }

      break;  // fail

    case T_LONG:

      switch (current_type) {

        case T_BYTE:

          value->j = (jlong) value->b;

          return;

        case T_CHAR:

          value->j = (jlong) value->c;

          return;

        case T_SHORT:

          value->j = (jlong) value->s;

          return;

        case T_INT:

          value->j = (jlong) value->i;

          return;

        default:

          break;

      }

      break;  // fail

    case T_FLOAT:

      switch (current_type) {

        case T_BYTE:

          value->f = (jfloat) value->b;

          return;

        case T_CHAR:

          value->f = (jfloat) value->c;

          return;

        case T_SHORT:

          value->f = (jfloat) value->s;

          return;

        case T_INT:

          value->f = (jfloat) value->i;

          return;

        case T_LONG:

          value->f = (jfloat) value->j;

          return;

        default:

          break;

      }

      break;  // fail

    case T_DOUBLE:

      switch (current_type) {

        case T_BYTE:

          value->d = (jdouble) value->b;

          return;

        case T_CHAR:

          value->d = (jdouble) value->c;

          return;

        case T_SHORT:

          value->d = (jdouble) value->s;

          return;

        case T_INT:

          value->d = (jdouble) value->i;

          return;

        case T_FLOAT:

          value->d = (jdouble) value->f;

          return;

        case T_LONG:

          value->d = (jdouble) value->j;

          return;

        default:

          break;

      }

      break;  // fail

    default:

      break;  // fail

  }

  THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "argument type mismatch");

}

BasicType Reflection::array_get(jvalue* value, arrayOop a, int index, TRAPS) {

  if (!a->is_within_bounds(index)) {

    THROW_(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), T_ILLEGAL);

  }

  if (a->is_objArray()) {

    value->l = (jobject) objArrayOop(a)->obj_at(index);

    return T_OBJECT;

  } else {

    assert(a->is_typeArray(), "just checking");

    BasicType type = TypeArrayKlass::cast(a->klass())->element_type();

    switch (type) {

      case T_BOOLEAN:

        value->z = typeArrayOop(a)->bool_at(index);

        break;

      case T_CHAR:

        value->c = typeArrayOop(a)->char_at(index);

        break;

      case T_FLOAT:

        value->f = typeArrayOop(a)->float_at(index);

        break;

      case T_DOUBLE:

        value->d = typeArrayOop(a)->double_at(index);

        break;

      case T_BYTE:

        value->b = typeArrayOop(a)->byte_at(index);

        break;

      case T_SHORT:

        value->s = typeArrayOop(a)->short_at(index);

        break;

      case T_INT:

        value->i = typeArrayOop(a)->int_at(index);

        break;

      case T_LONG:

        value->j = typeArrayOop(a)->long_at(index);

        break;

      default:

        return T_ILLEGAL;

    }

    return type;

  }

}

void Reflection::array_set(jvalue* value, arrayOop a, int index, BasicType value_type, TRAPS) {

  if (!a->is_within_bounds(index)) {

    THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());

  }

  if (a->is_objArray()) {

    if (value_type == T_OBJECT) {

      oop obj = (oop) value->l;

      if (obj != NULL) {

        Klass* element_klass = ObjArrayKlass::cast(a->klass())->element_klass();

        if (!obj->is_a(element_klass)) {

          THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "array element type mismatch");

        }

      }

      objArrayOop(a)->obj_at_put(index, obj);

    }

  } else {

    assert(a->is_typeArray(), "just checking");

    BasicType array_type = TypeArrayKlass::cast(a->klass())->element_type();

    if (array_type != value_type) {

      // The widen operation can potentially throw an exception, but cannot block,

      // so typeArrayOop a is safe if the call succeeds.

      widen(value, value_type, array_type, CHECK);

    }

    switch (array_type) {

      case T_BOOLEAN:

        typeArrayOop(a)->bool_at_put(index, value->z);

        break;

      case T_CHAR:

        typeArrayOop(a)->char_at_put(index, value->c);

        break;

      case T_FLOAT:

        typeArrayOop(a)->float_at_put(index, value->f);

        break;

      case T_DOUBLE:

        typeArrayOop(a)->double_at_put(index, value->d);

        break;

      case T_BYTE:

        typeArrayOop(a)->byte_at_put(index, value->b);

        break;

      case T_SHORT:

        typeArrayOop(a)->short_at_put(index, value->s);

        break;

      case T_INT:

        typeArrayOop(a)->int_at_put(index, value->i);

        break;

      case T_LONG:

        typeArrayOop(a)->long_at_put(index, value->j);

        break;

      default:

        THROW(vmSymbols::java_lang_IllegalArgumentException());

    }

  }

}

static Klass* basic_type_mirror_to_arrayklass(oop basic_type_mirror, TRAPS) {

  assert(java_lang_Class::is_primitive(basic_type_mirror), "just checking");

  BasicType type = java_lang_Class::primitive_type(basic_type_mirror);

  if (type == T_VOID) {

    THROW_0(vmSymbols::java_lang_IllegalArgumentException());

  }

  else {

    return Universe::typeArrayKlassObj(type);

  }

}

arrayOop Reflection::reflect_new_array(oop element_mirror, jint length, TRAPS) {

  if (element_mirror == NULL) {

    THROW_0(vmSymbols::java_lang_NullPointerException());

  }

  if (length < 0) {

    THROW_MSG_0(vmSymbols::java_lang_NegativeArraySizeException(), err_msg("%d", length));

  }

  if (java_lang_Class::is_primitive(element_mirror)) {

    Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);

    return TypeArrayKlass::cast(tak)->allocate(length, THREAD);

  } else {

    Klass* k = java_lang_Class::as_Klass(element_mirror);

    if (k->is_array_klass() && ArrayKlass::cast(k)->dimension() >= MAX_DIM) {

      THROW_0(vmSymbols::java_lang_IllegalArgumentException());

    }

    return oopFactory::new_objArray(k, length, THREAD);

  }

}

arrayOop Reflection::reflect_new_multi_array(oop element_mirror, typeArrayOop dim_array, TRAPS) {

  assert(dim_array->is_typeArray(), "just checking");

  assert(TypeArrayKlass::cast(dim_array->klass())->element_type() == T_INT, "just checking");

  if (element_mirror == NULL) {

    THROW_0(vmSymbols::java_lang_NullPointerException());

  }

  int len = dim_array->length();

  if (len <= 0 || len > MAX_DIM) {

    THROW_0(vmSymbols::java_lang_IllegalArgumentException());

  }

  jint dimensions[MAX_DIM];   // C array copy of intArrayOop

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

    int d = dim_array->int_at(i);

    if (d < 0) {

      THROW_MSG_0(vmSymbols::java_lang_NegativeArraySizeException(), err_msg("%d", d));

    }

    dimensions[i] = d;

  }

  Klass* klass;

  int dim = len;

  if (java_lang_Class::is_primitive(element_mirror)) {

    klass = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);

  } else {

    klass = java_lang_Class::as_Klass(element_mirror);

    if (klass->is_array_klass()) {

      int k_dim = ArrayKlass::cast(klass)->dimension();

      if (k_dim + len > MAX_DIM) {

        THROW_0(vmSymbols::java_lang_IllegalArgumentException());

      }

      dim += k_dim;

    }

  }

  klass = klass->array_klass(dim, CHECK_NULL);

  oop obj = ArrayKlass::cast(klass)->multi_allocate(len, dimensions, CHECK_NULL);

  assert(obj->is_array(), "just checking");

  return arrayOop(obj);

}

static bool under_unsafe_anonymous_host(const InstanceKlass* ik, const InstanceKlass* unsafe_anonymous_host) {

  DEBUG_ONLY(int inf_loop_check = 1000 * 1000 * 1000);

  for (;;) {

    const InstanceKlass* hc = ik->unsafe_anonymous_host();

    if (hc == NULL)        return false;

    if (hc == unsafe_anonymous_host)  return true;

    ik = hc;

    // There's no way to make a host class loop short of patching memory.

    // Therefore there cannot be a loop here unless there's another bug.

    // Still, let's check for it.

    assert(--inf_loop_check > 0, "no unsafe_anonymous_host loop");

  }

}

static bool can_relax_access_check_for(const Klass* accessor,

                                       const Klass* accessee,

                                       bool classloader_only) {

  const InstanceKlass* accessor_ik = InstanceKlass::cast(accessor);

  const InstanceKlass* accessee_ik = InstanceKlass::cast(accessee);

  // If either is on the other's unsafe_anonymous_host chain, access is OK,

  // because one is inside the other.

  if (under_unsafe_anonymous_host(accessor_ik, accessee_ik) ||

    under_unsafe_anonymous_host(accessee_ik, accessor_ik))

    return true;

  if (RelaxAccessControlCheck &&

    accessor_ik->major_version() < Verifier::NO_RELAX_ACCESS_CTRL_CHECK_VERSION &&

    accessee_ik->major_version() < Verifier::NO_RELAX_ACCESS_CTRL_CHECK_VERSION) {

    return classloader_only &&

      Verifier::relax_access_for(accessor_ik->class_loader()) &&

      accessor_ik->protection_domain() == accessee_ik->protection_domain() &&

      accessor_ik->class_loader() == accessee_ik->class_loader();

  }

  return false;

}

/*

    Type Accessibility check for public types: Callee Type T is accessible to Caller Type S if:

                        Callee T in             Callee T in package PT,

                        unnamed module          runtime module MT

 ------------------------------------------------------------------------------------------------

 Caller S in package     If MS is loose: YES      If same classloader/package (PS == PT): YES

 PS, runtime module MS   If MS can read T's       If same runtime module: (MS == MT): YES

                         unnamed module: YES

                                                  Else if (MS can read MT (establish readability) &&

                                                    ((MT exports PT to MS or to all modules) ||

                                                     (MT is open))): YES

 ------------------------------------------------------------------------------------------------

 Caller S in unnamed         YES                  Readability exists because unnamed module

 module UM                                            "reads" all modules

                                                  if (MT exports PT to UM or to all modules): YES

 ------------------------------------------------------------------------------------------------

 Note: a loose module is a module that can read all current and future unnamed modules.

*/

Reflection::VerifyClassAccessResults Reflection::verify_class_access(

  const Klass* current_class, const InstanceKlass* new_class, bool classloader_only) {

  // Verify that current_class can access new_class.  If the classloader_only

  // flag is set, we automatically allow any accesses in which current_class

  // doesn't have a classloader.

  if ((current_class == NULL) ||

      (current_class == new_class) ||

      is_same_class_package(current_class, new_class)) {

    return ACCESS_OK;

  }

  // Allow all accesses from jdk/internal/reflect/MagicAccessorImpl subclasses to

  // succeed trivially.

  if (SystemDictionary::reflect_MagicAccessorImpl_klass_is_loaded() &&

      current_class->is_subclass_of(SystemDictionary::reflect_MagicAccessorImpl_klass())) {

    return ACCESS_OK;

  }

  // module boundaries

  if (new_class->is_public()) {

    // Ignore modules for DumpSharedSpaces because we do not have any package

    // or module information for modules other than java.base.

    if (DumpSharedSpaces) {

      return ACCESS_OK;

    }

    // Find the module entry for current_class, the accessor

    ModuleEntry* module_from = current_class->module();

    // Find the module entry for new_class, the accessee

    ModuleEntry* module_to = new_class->module();

    // both in same (possibly unnamed) module

    if (module_from == module_to) {

      return ACCESS_OK;

    }

    // Acceptable access to a type in an unnamed module. Note that since

    // unnamed modules can read all unnamed modules, this also handles the

    // case where module_from is also unnamed but in a different class loader.

    if (!module_to->is_named() &&

        (module_from->can_read_all_unnamed() || module_from->can_read(module_to))) {

      return ACCESS_OK;

    }

    // Establish readability, check if module_from is allowed to read module_to.

    if (!module_from->can_read(module_to)) {

      return MODULE_NOT_READABLE;

    }

    // Access is allowed if module_to is open, i.e. all its packages are unqualifiedly exported

    if (module_to->is_open()) {

      return ACCESS_OK;

    }