/*

 * Copyright (c) 1997, 2014, 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 "classfile/javaClasses.hpp"

#include "classfile/stringTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/verifier.hpp"

#include "classfile/vmSymbols.hpp"

#include "interpreter/linkResolver.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.inline.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.hpp"

#include "prims/jvm.h"

#include "prims/jvmtiExport.hpp"

#include "runtime/arguments.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/reflection.hpp"

#include "runtime/reflectionUtils.hpp"

#include "runtime/signature.hpp"

#include "runtime/vframe.hpp"

static void trace_class_resolution(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) {

      tty->print("RESOLVE %s %s %s:%d (reflection)\n", from, to, source_file, line_number);

    } else {

      tty->print("RESOLVE %s %s (reflection)\n", from, to);

    }

  }

}

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

  if (type == T_VOID) {

    return NULL;

  }

  if (type == T_OBJECT || type == T_ARRAY) {

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

      }

      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;

      }

      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;

      }

      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;

      }

      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;

      }

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

    }

  }

}

Klass* Reflection::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);

  }

}

oop Reflection:: basic_type_arrayklass_to_mirror(Klass* basic_type_arrayklass, TRAPS) {

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

  return Universe::java_mirror(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_0(vmSymbols::java_lang_NegativeArraySizeException());

  }

  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->oop_is_array() && 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_0(vmSymbols::java_lang_NegativeArraySizeException());

    }

    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->oop_is_array()) {

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

}

oop Reflection::array_component_type(oop mirror, TRAPS) {

  if (java_lang_Class::is_primitive(mirror)) {

    return NULL;

  }

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

  if (!klass->oop_is_array()) {

    return NULL;

  }

  oop result = java_lang_Class::component_mirror(mirror);

#ifdef ASSERT

  oop result2 = NULL;

  if (ArrayKlass::cast(klass)->dimension() == 1) {

    if (klass->oop_is_typeArray()) {

      result2 = basic_type_arrayklass_to_mirror(klass, CHECK_NULL);

    } else {

      result2 = ObjArrayKlass::cast(klass)->element_klass()->java_mirror();

    }

  } else {

    Klass* lower_dim = ArrayKlass::cast(klass)->lower_dimension();

    assert(lower_dim->oop_is_array(), "just checking");

    result2 = lower_dim->java_mirror();

  }

  assert(result == result2, "results must be consistent");

#endif //ASSERT

  return result;

}

bool Reflection::verify_class_access(Klass* current_class, Klass* 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) ||

      (new_class->is_public()) ||

      is_same_class_package(current_class, new_class)) {

    return true;

  }

  // Allow all accesses from sun/reflect/MagicAccessorImpl subclasses to

  // succeed trivially.

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

    return true;

  }

  return can_relax_access_check_for(current_class, new_class, classloader_only);

}

static bool under_host_klass(InstanceKlass* ik, Klass* host_klass) {

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

  for (;;) {

    Klass* hc = (Klass*) ik->host_klass();

    if (hc == NULL)        return false;

    if (hc == host_klass)  return true;

    ik = InstanceKlass::cast(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 host_klass loop");

  }

}

bool Reflection::can_relax_access_check_for(

    Klass* accessor, Klass* accessee, bool classloader_only) {

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

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

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

  // because one is inside the other.

  if (under_host_klass(accessor_ik, accessee) ||

      under_host_klass(accessee_ik, accessor))

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

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

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

    return classloader_only &&

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

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

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

  } else {

    return false;

  }

}

bool Reflection::verify_field_access(Klass* current_class,

                                     Klass* resolved_class,

                                     Klass* field_class,

                                     AccessFlags access,

                                     bool classloader_only,

                                     bool protected_restriction) {

  // Verify that current_class can access a field of field_class, where that

  // field's access bits are "access".  We assume that we've already verified

  // that current_class can access field_class.

  //

  // If the classloader_only flag is set, we automatically allow any accesses

  // in which current_class doesn't have a classloader.

  //

  // "resolved_class" is the runtime type of "field_class". Sometimes we don't

  // need this distinction (e.g. if all we have is the runtime type, or during

  // class file parsing when we only care about the static type); in that case

  // callers should ensure that resolved_class == field_class.

  //

  if ((current_class == NULL) ||

      (current_class == field_class) ||

      access.is_public()) {

    return true;

  }

  Klass* host_class = current_class;

  while (host_class->oop_is_instance() &&

         InstanceKlass::cast(host_class)->is_anonymous()) {

    Klass* next_host_class = InstanceKlass::cast(host_class)->host_klass();

    if (next_host_class == NULL)  break;

    host_class = next_host_class;

  }

  if (host_class == field_class) {

    return true;

  }

  if (access.is_protected()) {

    if (!protected_restriction) {

      // See if current_class (or outermost host class) is a subclass of field_class

      // An interface may not access protected members of j.l.Object

      if (!host_class->is_interface() && host_class->is_subclass_of(field_class)) {

        if (access.is_static() || // static fields are ok, see 6622385

            current_class == resolved_class ||

            field_class == resolved_class ||

            host_class->is_subclass_of(resolved_class) ||