/*

 * Copyright (c) 1999, 2011, 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 "ci/ciConstant.hpp"

#include "ci/ciEnv.hpp"

#include "ci/ciField.hpp"

#include "ci/ciInstance.hpp"

#include "ci/ciInstanceKlass.hpp"

#include "ci/ciInstanceKlassKlass.hpp"

#include "ci/ciMethod.hpp"

#include "ci/ciNullObject.hpp"

#include "ci/ciObjArrayKlassKlass.hpp"

#include "ci/ciTypeArrayKlassKlass.hpp"

#include "ci/ciUtilities.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/scopeDesc.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/compileLog.hpp"

#include "compiler/compilerOracle.hpp"

#include "gc_interface/collectedHeap.inline.hpp"

#include "interpreter/linkResolver.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/oopFactory.hpp"

#include "memory/universe.inline.hpp"

#include "oops/methodDataOop.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/oop.inline.hpp"

#include "oops/oop.inline2.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/methodHandleWalk.hpp"

#include "runtime/init.hpp"

#include "runtime/reflection.hpp"

#include "runtime/sharedRuntime.hpp"

#include "utilities/dtrace.hpp"

#ifdef COMPILER1

#include "c1/c1_Runtime1.hpp"

#endif

#ifdef COMPILER2

#include "opto/runtime.hpp"

#endif

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

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;

#define WK_KLASS_DEFN(name, ignore_s, ignore_o) ciInstanceKlass* ciEnv::_##name = NULL;

WK_KLASSES_DO(WK_KLASS_DEFN)

#undef WK_KLASS_DEFN

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;

  _the_null_string = NULL;

  _the_min_jint_string = 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;

  _the_null_string = NULL;

  _the_min_jint_string = NULL;

}

ciEnv::~ciEnv() {

  CompilerThread* current_thread = CompilerThread::current();

  _factory->remove_symbols();

  current_thread->set_env(NULL);

}

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

// Cache Jvmti state

void ciEnv::cache_jvmti_state() {

  VM_ENTRY_MARK;

  // Get Jvmti capabilities under lock to get consistant values.

  MutexLocker mu(JvmtiThreadState_lock);

  _jvmti_can_hotswap_or_post_breakpoint = JvmtiExport::can_hotswap_or_post_breakpoint();

  _jvmti_can_access_local_variables     = JvmtiExport::can_access_local_variables();

  _jvmti_can_post_on_exceptions         = JvmtiExport::can_post_on_exceptions();

}

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

// Cache DTrace flags

void ciEnv::cache_dtrace_flags() {

  // Need lock?

  _dtrace_extended_probes = ExtendedDTraceProbes;

  if (_dtrace_extended_probes) {

    _dtrace_monitor_probes  = true;

    _dtrace_method_probes   = true;

    _dtrace_alloc_probes    = true;

  } else {

    _dtrace_monitor_probes  = DTraceMonitorProbes;

    _dtrace_method_probes   = DTraceMethodProbes;

    _dtrace_alloc_probes    = DTraceAllocProbes;

  }

}

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

// helper for lazy exception creation

ciInstance* ciEnv::get_or_create_exception(jobject& handle, Symbol* 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,

          vmSymbols::java_lang_ArrayIndexOutOfBoundsException());

  }

  return _ArrayIndexOutOfBoundsException_instance;

}

ciInstance* ciEnv::ArrayStoreException_instance() {

  if (_ArrayStoreException_instance == NULL) {

    _ArrayStoreException_instance

          = get_or_create_exception(_ArrayStoreException_handle,

          vmSymbols::java_lang_ArrayStoreException());

  }

  return _ArrayStoreException_instance;

}

ciInstance* ciEnv::ClassCastException_instance() {

  if (_ClassCastException_instance == NULL) {

    _ClassCastException_instance

          = get_or_create_exception(_ClassCastException_handle,

          vmSymbols::java_lang_ClassCastException());

  }

  return _ClassCastException_instance;

}

ciInstance* ciEnv::the_null_string() {

  if (_the_null_string == NULL) {

    VM_ENTRY_MARK;

    _the_null_string = get_object(Universe::the_null_string())->as_instance();

  }

  return _the_null_string;

}

ciInstance* ciEnv::the_min_jint_string() {

  if (_the_min_jint_string == NULL) {

    VM_ENTRY_MARK;

    _the_min_jint_string = get_object(Universe::the_min_jint_string())->as_instance();

  }

  return _the_min_jint_string;

}

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

// 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_system_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,

                                       constantPoolHandle cpool,

                                       ciSymbol* name,

                                       bool require_local) {

  ASSERT_IN_VM;

  EXCEPTION_CONTEXT;

  // Now we need to check the SystemDictionary

  Symbol* sym = name->get_symbol();

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

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

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

    // Call recursive to keep scope of strippedsym.

    TempNewSymbol strippedsym = SymbolTable::new_symbol(sym->as_utf8()+1,

                    sym->utf8_length()-2,

                    KILL_COMPILE_ON_FATAL_(_unloaded_ciinstance_klass));

    ciSymbol* strippedname = get_symbol(strippedsym);

    return get_klass_by_name_impl(accessing_klass, cpool, strippedname, require_local);

  }

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

  }

  KlassHandle found_klass;

  {

    ttyUnlocker ttyul;  // release tty lock to avoid ordering problems

    MutexLocker ml(Compile_lock);

    klassOop kls;

    if (!require_local) {

      kls = SystemDictionary::find_constrained_instance_or_array_klass(sym, loader,

                                                                       KILL_COMPILE_ON_FATAL_(fail_type));

    } else {

      kls = SystemDictionary::find_instance_or_array_klass(sym, loader, domain,

                                                           KILL_COMPILE_ON_FATAL_(fail_type));

    }

    found_klass = KlassHandle(THREAD, kls);

  }

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

    TempNewSymbol elem_sym = SymbolTable::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,

                             cpool,

                             get_symbol(elem_sym),

                             require_local);

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

      // Now make an array for it

      return ciObjArrayKlass::make_impl(elem_klass);

    }

  }

  if (found_klass() == NULL && !cpool.is_null() && cpool->has_preresolution()) {

    // Look inside the constant pool for pre-resolved class entries.

    for (int i = cpool->length() - 1; i >= 1; i--) {

      if (cpool->tag_at(i).is_klass()) {

        klassOop kls = cpool->resolved_klass_at(i);

        if (Klass::cast(kls)->name() == sym) {

          found_klass = KlassHandle(THREAD, kls);

          break;

        }

      }

    }

  }

  if (found_klass() != NULL) {

    // Found it.  Build a CI handle.

    return get_object(found_klass())->as_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,

                                                 constantPoolHandle(),

                                                 klass_name,

                                                 require_local);)

}

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

// ciEnv::get_klass_by_index_impl

//

// Implementation of get_klass_by_index.

ciKlass* ciEnv::get_klass_by_index_impl(constantPoolHandle cpool,

                                        int index,

                                        bool& is_accessible,

                                        ciInstanceKlass* accessor) {

  EXCEPTION_CONTEXT;

  Symbol* klass_name = NULL;

  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