/*

 * Copyright 1999-2007 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/_ciEnv.cpp.incl"

// ciEnv

//

// This class is the top level broker for requests from the compiler

// to the VM.

ciObject*              ciEnv::_null_object_instance;

ciMethodKlass*         ciEnv::_method_klass_instance;

ciSymbolKlass*         ciEnv::_symbol_klass_instance;

ciKlassKlass*          ciEnv::_klass_klass_instance;

ciInstanceKlassKlass*  ciEnv::_instance_klass_klass_instance;

ciTypeArrayKlassKlass* ciEnv::_type_array_klass_klass_instance;

ciObjArrayKlassKlass*  ciEnv::_obj_array_klass_klass_instance;

ciInstanceKlass* ciEnv::_ArrayStoreException;

ciInstanceKlass* ciEnv::_Class;

ciInstanceKlass* ciEnv::_ClassCastException;

ciInstanceKlass* ciEnv::_Object;

ciInstanceKlass* ciEnv::_Throwable;

ciInstanceKlass* ciEnv::_Thread;

ciInstanceKlass* ciEnv::_OutOfMemoryError;

ciInstanceKlass* ciEnv::_String;

ciSymbol*        ciEnv::_unloaded_cisymbol = NULL;

ciInstanceKlass* ciEnv::_unloaded_ciinstance_klass = NULL;

ciObjArrayKlass* ciEnv::_unloaded_ciobjarrayklass = NULL;

jobject ciEnv::_ArrayIndexOutOfBoundsException_handle = NULL;

jobject ciEnv::_ArrayStoreException_handle = NULL;

jobject ciEnv::_ClassCastException_handle = NULL;

#ifndef PRODUCT

static bool firstEnv = true;

#endif /* PRODUCT */

// ------------------------------------------------------------------

// ciEnv::ciEnv

ciEnv::ciEnv(CompileTask* task, int system_dictionary_modification_counter) {

  VM_ENTRY_MARK;

  // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc.

  thread->set_env(this);

  assert(ciEnv::current() == this, "sanity");

  _oop_recorder = NULL;

  _debug_info = NULL;

  _dependencies = NULL;

  _failure_reason = NULL;

  _compilable = MethodCompilable;

  _break_at_compile = false;

  _compiler_data = NULL;

#ifndef PRODUCT

  assert(!firstEnv, "not initialized properly");

#endif /* !PRODUCT */

  _system_dictionary_modification_counter = system_dictionary_modification_counter;

  _num_inlined_bytecodes = 0;

  assert(task == NULL || thread->task() == task, "sanity");

  _task = task;

  _log = NULL;

  // Temporary buffer for creating symbols and such.

  _name_buffer = NULL;

  _name_buffer_len = 0;

  _arena   = &_ciEnv_arena;

  _factory = new (_arena) ciObjectFactory(_arena, 128);

  // Preload commonly referenced system ciObjects.

  // During VM initialization, these instances have not yet been created.

  // Assertions ensure that these instances are not accessed before

  // their initialization.

  assert(Universe::is_fully_initialized(), "should be complete");

  oop o = Universe::null_ptr_exception_instance();

  assert(o != NULL, "should have been initialized");

  _NullPointerException_instance = get_object(o)->as_instance();

  o = Universe::arithmetic_exception_instance();

  assert(o != NULL, "should have been initialized");

  _ArithmeticException_instance = get_object(o)->as_instance();

  _ArrayIndexOutOfBoundsException_instance = NULL;

  _ArrayStoreException_instance = NULL;

  _ClassCastException_instance = NULL;

}

ciEnv::ciEnv(Arena* arena) {

  ASSERT_IN_VM;

  // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc.

  CompilerThread* current_thread = CompilerThread::current();

  assert(current_thread->env() == NULL, "must be");

  current_thread->set_env(this);

  assert(ciEnv::current() == this, "sanity");

  _oop_recorder = NULL;

  _debug_info = NULL;

  _dependencies = NULL;

  _failure_reason = NULL;

  _compilable = MethodCompilable_never;

  _break_at_compile = false;

  _compiler_data = NULL;

#ifndef PRODUCT

  assert(firstEnv, "must be first");

  firstEnv = false;

#endif /* !PRODUCT */

  _system_dictionary_modification_counter = 0;

  _num_inlined_bytecodes = 0;

  _task = NULL;

  _log = NULL;

  // Temporary buffer for creating symbols and such.

  _name_buffer = NULL;

  _name_buffer_len = 0;

  _arena   = arena;

  _factory = new (_arena) ciObjectFactory(_arena, 128);

  // Preload commonly referenced system ciObjects.

  // During VM initialization, these instances have not yet been created.

  // Assertions ensure that these instances are not accessed before

  // their initialization.

  assert(Universe::is_fully_initialized(), "must be");

  oop o = Universe::null_ptr_exception_instance();

  assert(o != NULL, "should have been initialized");

  _NullPointerException_instance = get_object(o)->as_instance();

  o = Universe::arithmetic_exception_instance();

  assert(o != NULL, "should have been initialized");

  _ArithmeticException_instance = get_object(o)->as_instance();

  _ArrayIndexOutOfBoundsException_instance = NULL;

  _ArrayStoreException_instance = NULL;

  _ClassCastException_instance = NULL;

}

ciEnv::~ciEnv() {

  CompilerThread* current_thread = CompilerThread::current();

  current_thread->set_env(NULL);

}

// ------------------------------------------------------------------

// helper for lazy exception creation

ciInstance* ciEnv::get_or_create_exception(jobject& handle, symbolHandle name) {

  VM_ENTRY_MARK;

  if (handle == NULL) {

    // Cf. universe.cpp, creation of Universe::_null_ptr_exception_instance.

    klassOop k = SystemDictionary::find(name, Handle(), Handle(), THREAD);

    jobject objh = NULL;

    if (!HAS_PENDING_EXCEPTION && k != NULL) {

      oop obj = instanceKlass::cast(k)->allocate_permanent_instance(THREAD);

      if (!HAS_PENDING_EXCEPTION)

        objh = JNIHandles::make_global(obj);

    }

    if (HAS_PENDING_EXCEPTION) {

      CLEAR_PENDING_EXCEPTION;

    } else {

      handle = objh;

    }

  }

  oop obj = JNIHandles::resolve(handle);

  return obj == NULL? NULL: get_object(obj)->as_instance();

}

// ------------------------------------------------------------------

// ciEnv::ArrayIndexOutOfBoundsException_instance, etc.

ciInstance* ciEnv::ArrayIndexOutOfBoundsException_instance() {

  if (_ArrayIndexOutOfBoundsException_instance == NULL) {

    _ArrayIndexOutOfBoundsException_instance

          = get_or_create_exception(_ArrayIndexOutOfBoundsException_handle,

          vmSymbolHandles::java_lang_ArrayIndexOutOfBoundsException());

  }

  return _ArrayIndexOutOfBoundsException_instance;

}

ciInstance* ciEnv::ArrayStoreException_instance() {

  if (_ArrayStoreException_instance == NULL) {

    _ArrayStoreException_instance

          = get_or_create_exception(_ArrayStoreException_handle,

          vmSymbolHandles::java_lang_ArrayStoreException());

  }

  return _ArrayStoreException_instance;

}

ciInstance* ciEnv::ClassCastException_instance() {

  if (_ClassCastException_instance == NULL) {

    _ClassCastException_instance

          = get_or_create_exception(_ClassCastException_handle,

          vmSymbolHandles::java_lang_ClassCastException());

  }

  return _ClassCastException_instance;

}

// ------------------------------------------------------------------

// ciEnv::get_method_from_handle

ciMethod* ciEnv::get_method_from_handle(jobject method) {

  VM_ENTRY_MARK;

  return get_object(JNIHandles::resolve(method))->as_method();

}

// ------------------------------------------------------------------

// ciEnv::make_array

ciArray* ciEnv::make_array(GrowableArray<ciObject*>* objects) {

  VM_ENTRY_MARK;

  int length = objects->length();

  objArrayOop a = oopFactory::new_system_objArray(length, THREAD);

  if (HAS_PENDING_EXCEPTION) {

    CLEAR_PENDING_EXCEPTION;

    record_out_of_memory_failure();

    return NULL;

  }

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

    a->obj_at_put(i, objects->at(i)->get_oop());

  }

  assert(a->is_perm(), "");

  return get_object(a)->as_array();

}

// ------------------------------------------------------------------

// ciEnv::array_element_offset_in_bytes

int ciEnv::array_element_offset_in_bytes(ciArray* a_h, ciObject* o_h) {

  VM_ENTRY_MARK;

  objArrayOop a = (objArrayOop)a_h->get_oop();

  assert(a->is_objArray(), "");

  int length = a->length();

  oop o = o_h->get_oop();

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

    if (a->obj_at(i) == o)  return i;

  }

  return -1;

}

// ------------------------------------------------------------------

// ciEnv::check_klass_accessiblity

//

// Note: the logic of this method should mirror the logic of

// constantPoolOopDesc::verify_constant_pool_resolve.

bool ciEnv::check_klass_accessibility(ciKlass* accessing_klass,

                                      klassOop resolved_klass) {

  if (accessing_klass == NULL || !accessing_klass->is_loaded()) {

    return true;

  }

  if (accessing_klass->is_obj_array()) {

    accessing_klass = accessing_klass->as_obj_array_klass()->base_element_klass();

  }

  if (!accessing_klass->is_instance_klass()) {

    return true;

  }

  if (resolved_klass->klass_part()->oop_is_objArray()) {

    // Find the element klass, if this is an array.

    resolved_klass = objArrayKlass::cast(resolved_klass)->bottom_klass();

  }

  if (resolved_klass->klass_part()->oop_is_instance()) {

    return Reflection::verify_class_access(accessing_klass->get_klassOop(),

                                           resolved_klass,

                                           true);

  }

  return true;

}

// ------------------------------------------------------------------

// ciEnv::get_klass_by_name_impl

ciKlass* ciEnv::get_klass_by_name_impl(ciKlass* accessing_klass,

                                       ciSymbol* name,

                                       bool require_local) {

  ASSERT_IN_VM;

  EXCEPTION_CONTEXT;

  // Now we need to check the SystemDictionary

  symbolHandle sym(THREAD, name->get_symbolOop());

  if (sym->byte_at(0) == 'L' &&

    sym->byte_at(sym->utf8_length()-1) == ';') {

    // This is a name from a signature.  Strip off the trimmings.

    sym = oopFactory::new_symbol_handle(sym->as_utf8()+1,

                                        sym->utf8_length()-2,

                                        KILL_COMPILE_ON_FATAL_(_unloaded_ciinstance_klass));

    name = get_object(sym())->as_symbol();

  }

  // Check for prior unloaded klass.  The SystemDictionary's answers

  // can vary over time but the compiler needs consistency.

  ciKlass* unloaded_klass = check_get_unloaded_klass(accessing_klass, name);

  if (unloaded_klass != NULL) {

    if (require_local)  return NULL;

    return unloaded_klass;

  }

  Handle loader(THREAD, (oop)NULL);

  Handle domain(THREAD, (oop)NULL);

  if (accessing_klass != NULL) {

    loader = Handle(THREAD, accessing_klass->loader());

    domain = Handle(THREAD, accessing_klass->protection_domain());

  }

  // setup up the proper type to return on OOM

  ciKlass* fail_type;

  if (sym->byte_at(0) == '[') {

    fail_type = _unloaded_ciobjarrayklass;

  } else {

    fail_type = _unloaded_ciinstance_klass;

  }

  klassOop found_klass;

  if (!require_local) {

    found_klass =

      SystemDictionary::find_constrained_instance_or_array_klass(sym, loader,

                                                                 KILL_COMPILE_ON_FATAL_(fail_type));

  } else {

    found_klass =

      SystemDictionary::find_instance_or_array_klass(sym, loader, domain,

                                                     KILL_COMPILE_ON_FATAL_(fail_type));

  }

  if (found_klass != NULL) {

    // Found it.  Build a CI handle.

    return get_object(found_klass)->as_klass();

  }

  // If we fail to find an array klass, look again for its element type.

  // The element type may be available either locally or via constraints.

  // In either case, if we can find the element type in the system dictionary,

  // we must build an array type around it.  The CI requires array klasses

  // to be loaded if their element klasses are loaded, except when memory

  // is exhausted.

  if (sym->byte_at(0) == '[' &&

      (sym->byte_at(1) == '[' || sym->byte_at(1) == 'L')) {

    // We have an unloaded array.

    // Build it on the fly if the element class exists.

    symbolOop elem_sym = oopFactory::new_symbol(sym->as_utf8()+1,

                                                sym->utf8_length()-1,

                                                KILL_COMPILE_ON_FATAL_(fail_type));

    // Get element ciKlass recursively.

    ciKlass* elem_klass =

      get_klass_by_name_impl(accessing_klass,

                             get_object(elem_sym)->as_symbol(),

                             require_local);

    if (elem_klass != NULL && elem_klass->is_loaded()) {

      // Now make an array for it

      return ciObjArrayKlass::make_impl(elem_klass);

    }

  }

  if (require_local)  return NULL;

  // Not yet loaded into the VM, or not governed by loader constraints.

  // Make a CI representative for it.

  return get_unloaded_klass(accessing_klass, name);

}

// ------------------------------------------------------------------

// ciEnv::get_klass_by_name

ciKlass* ciEnv::get_klass_by_name(ciKlass* accessing_klass,

                                  ciSymbol* klass_name,

                                  bool require_local) {

  GUARDED_VM_ENTRY(return get_klass_by_name_impl(accessing_klass,

                                                 klass_name,

                                                 require_local);)

}

// ------------------------------------------------------------------

// ciEnv::get_klass_by_index_impl

//

// Implementation of get_klass_by_index.

ciKlass* ciEnv::get_klass_by_index_impl(ciInstanceKlass* accessor,

                                        int index,

                                        bool& is_accessible) {

  assert(accessor->get_instanceKlass()->is_linked(), "must be linked before accessing constant pool");

  EXCEPTION_CONTEXT;

  constantPoolHandle cpool(THREAD, accessor->get_instanceKlass()->constants());

  KlassHandle klass (THREAD, constantPoolOopDesc::klass_at_if_loaded(cpool, index));

  symbolHandle klass_name;

  if (klass.is_null()) {

    // The klass has not been inserted into the constant pool.

    // Try to look it up by name.

    {

      // We have to lock the cpool to keep the oop from being resolved

      // while we are accessing it.

      ObjectLocker ol(cpool, THREAD);

      constantTag tag = cpool->tag_at(index);

      if (tag.is_klass()) {

        // The klass has been inserted into the constant pool

        // very recently.

        klass = KlassHandle(THREAD, cpool->resolved_klass_at(index));

      } else if (tag.is_symbol()) {

        klass_name = symbolHandle(THREAD, cpool->symbol_at(index));

      } else {

        assert(cpool->tag_at(index).is_unresolved_klass(), "wrong tag");

        klass_name = symbolHandle(THREAD, cpool->unresolved_klass_at(index));

      }

    }

  }

  if (klass.is_null()) {

    // Not found in constant pool.  Use the name to do the lookup.

    ciKlass* k = get_klass_by_name_impl(accessor,

                                        get_object(klass_name())->as_symbol(),

                                        false);

    // Calculate accessibility the hard way.

    if (!k->is_loaded()) {

      is_accessible = false;

    } else if (k->loader() != accessor->loader() &&

               get_klass_by_name_impl(accessor, k->name(), true) == NULL) {

      // Loaded only remotely.  Not linked yet.

      is_accessible = false;

    } else {

      // Linked locally, and we must also check public/private, etc.

      is_accessible = check_klass_accessibility(accessor, k->get_klassOop());

    }

    return k;

  }

  // Check for prior unloaded klass.  The SystemDictionary's answers

  // can vary over time but the compiler needs consistency.

  ciSymbol* name = get_object(klass()->klass_part()->name())->as_symbol();

  ciKlass* unloaded_klass = check_get_unloaded_klass(accessor, name);

  if (unloaded_klass != NULL) {

    is_accessible = false;

    return unloaded_klass;

  }

  // It is known to be accessible, since it was found in the constant pool.

  is_accessible = true;

  return get_object(klass())->as_klass();

}

// ------------------------------------------------------------------

// ciEnv::get_klass_by_index

//

// Get a klass from the constant pool.

ciKlass* ciEnv::get_klass_by_index(ciInstanceKlass* accessor,

                                   int index,

                                   bool& is_accessible) {

  GUARDED_VM_ENTRY(return get_klass_by_index_impl(accessor, index, is_accessible);)

}

// ------------------------------------------------------------------

// ciEnv::get_constant_by_index_impl

//

// Implementation of get_constant_by_index().

ciConstant ciEnv::get_constant_by_index_impl(ciInstanceKlass* accessor,

                                             int index) {

  EXCEPTION_CONTEXT;

  instanceKlass* ik_accessor = accessor->get_instanceKlass();

  assert(ik_accessor->is_linked(), "must be linked before accessing constant pool");

  constantPoolOop cpool = ik_accessor->constants();

  constantTag tag = cpool->tag_at(index);

  if (tag.is_int()) {

    return ciConstant(T_INT, (jint)cpool->int_at(index));

  } else if (tag.is_long()) {

    return ciConstant((jlong)cpool->long_at(index));

  } else if (tag.is_float()) {

    return ciConstant((jfloat)cpool->float_at(index));

  } else if (tag.is_double()) {

    return ciConstant((jdouble)cpool->double_at(index));

  } else if (tag.is_string() || tag.is_unresolved_string()) {

    oop string = cpool->string_at(index, THREAD);

    if (HAS_PENDING_EXCEPTION) {

      CLEAR_PENDING_EXCEPTION;

      record_out_of_memory_failure();

      return ciConstant();

    }

    ciObject* constant = get_object(string);

    assert (constant->is_instance(), "must be an instance, or not? ");

    return ciConstant(T_OBJECT, constant);

  } else if (tag.is_klass() || tag.is_unresolved_klass()) {

    // 4881222: allow ldc to take a class type

    bool ignore;

    ciKlass* klass = get_klass_by_index_impl(accessor, index, ignore);

    if (HAS_PENDING_EXCEPTION) {

      CLEAR_PENDING_EXCEPTION;

      record_out_of_memory_failure();

      return ciConstant();

    }

    assert (klass->is_instance_klass() || klass->is_array_klass(),

            "must be an instance or array klass ");

    return ciConstant(T_OBJECT, klass);

  } else {

    ShouldNotReachHere();

    return ciConstant();

  }

}

// ------------------------------------------------------------------

// ciEnv::is_unresolved_string_impl

//

// Implementation of is_unresolved_string().

bool ciEnv::is_unresolved_string_impl(instanceKlass* accessor, int index) const {

  EXCEPTION_CONTEXT;

  assert(accessor->is_linked(), "must be linked before accessing constant pool");

  constantPoolOop cpool = accessor->constants();

  constantTag tag = cpool->tag_at(index);

  return tag.is_unresolved_string();

}

// ------------------------------------------------------------------

// ciEnv::is_unresolved_klass_impl

//

// Implementation of is_unresolved_klass().