/*

 * Copyright 1997-2009 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_reflection.cpp.incl"

#define JAVA_1_5_VERSION                  49

static void trace_class_resolution(klassOop to_class) {

  ResourceMark rm;

  int line_number = -1;

  const char * source_file = NULL;

  klassOop 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() &&

           instanceKlass::cast(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());

      symbolOop s = instanceKlass::cast(vfst.method()->method_holder())->source_file_name();

      if (s != NULL) {

        source_file = s->as_C_string();

      }

    }

  }

  if (caller != NULL) {

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

    const char * to = Klass::cast(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) {

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

    }

  }

}

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

    klassOop tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);

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

  } else {

    klassOop k = java_lang_Class::as_klassOop(element_mirror);

    if (Klass::cast(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;

  }

  klassOop 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_klassOop(element_mirror);

    if (Klass::cast(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::cast(klass)->array_klass(dim, CHECK_NULL);

  oop obj = arrayKlass::cast(klass)->multi_allocate(len, dimensions, THREAD);

  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;

  }

  klassOop klass = java_lang_Class::as_klassOop(mirror);

  if (!Klass::cast(klass)->oop_is_array()) {

    return NULL;

  }

  oop result = arrayKlass::cast(klass)->component_mirror();

#ifdef ASSERT

  oop result2 = NULL;

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

    if (Klass::cast(klass)->oop_is_typeArray()) {

      result2 = basic_type_arrayklass_to_mirror(klass, CHECK_NULL);

    } else {

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

    }

  } else {

    klassOop lower_dim = arrayKlass::cast(klass)->lower_dimension();

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

    result2 = Klass::cast(lower_dim)->java_mirror();

  }

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

#endif //ASSERT

  return result;

}

bool Reflection::reflect_check_access(klassOop field_class, AccessFlags acc, klassOop target_class, bool is_method_invoke, TRAPS) {

  // field_class  : declaring class

  // acc          : declared field access

  // target_class : for protected

  // Check if field or method is accessible to client.  Throw an

  // IllegalAccessException and return false if not.

  // The "client" is the class associated with the nearest real frame

  // getCallerClass already skips Method.invoke frames, so pass 0 in

  // that case (same as classic).

  ResourceMark rm(THREAD);

  assert(THREAD->is_Java_thread(), "sanity check");

  klassOop client_class = ((JavaThread *)THREAD)->security_get_caller_class(is_method_invoke ? 0 : 1);

  if (client_class != field_class) {

    if (!verify_class_access(client_class, field_class, false)

        || !verify_field_access(client_class,

                                field_class,

                                field_class,

                                acc,

                                false)) {

      THROW_(vmSymbols::java_lang_IllegalAccessException(), false);

    }

  }

  // Additional test for protected members: JLS 6.6.2

  if (acc.is_protected()) {

    if (target_class != client_class) {

      if (!is_same_class_package(client_class, field_class)) {

        if (!Klass::cast(target_class)->is_subclass_of(client_class)) {

          THROW_(vmSymbols::java_lang_IllegalAccessException(), false);

        }

      }

    }

  }

  // Passed all tests

  return true;

}

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

      (instanceKlass::cast(new_class)->is_public()) ||

      is_same_class_package(current_class, new_class)) {

    return true;

  }

  // New (1.4) reflection implementation. Allow all accesses from

  // sun/reflect/MagicAccessorImpl subclasses to succeed trivially.

  if (   JDK_Version::is_gte_jdk14x_version()

      && UseNewReflection

      && Klass::cast(current_class)->is_subclass_of(SystemDictionary::reflect_magic_klass())) {

    return true;

  }

  return can_relax_access_check_for(current_class, new_class, classloader_only);

}

static bool under_host_klass(instanceKlass* ik, klassOop host_klass) {

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

  for (;;) {

    klassOop hc = (klassOop) 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 unles 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(

    klassOop accessor, klassOop 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() < JAVA_1_5_VERSION &&

       accessee_ik->major_version() < JAVA_1_5_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(klassOop current_class,

                                     klassOop resolved_class,

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

  }

  if (access.is_protected()) {

    if (!protected_restriction) {

      // See if current_class is a subclass of field_class

      if (Klass::cast(current_class)->is_subclass_of(field_class)) {

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

            current_class == resolved_class ||