hotspot/src/share/vm/ci/ciEnv.cpp
author trims
Thu, 27 May 2010 19:08:38 -0700
changeset 5547 f4b087cbb361
parent 5420 586d3988e72b
child 5882 6b2aecc4f7d8
permissions -rw-r--r--
6941466: Oracle rebranding changes for Hotspot repositories Summary: Change all the Sun copyrights to Oracle copyright Reviewed-by: ohair
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
     2
 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
#include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
#include "incls/_ciEnv.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
// ciEnv
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
// This class is the top level broker for requests from the compiler
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
// to the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
ciObject*              ciEnv::_null_object_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
ciMethodKlass*         ciEnv::_method_klass_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
ciSymbolKlass*         ciEnv::_symbol_klass_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
ciKlassKlass*          ciEnv::_klass_klass_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
ciInstanceKlassKlass*  ciEnv::_instance_klass_klass_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
ciTypeArrayKlassKlass* ciEnv::_type_array_klass_klass_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
ciObjArrayKlassKlass*  ciEnv::_obj_array_klass_klass_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
    41
#define WK_KLASS_DEFN(name, ignore_s, ignore_o) ciInstanceKlass* ciEnv::_##name = NULL;
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
    42
WK_KLASSES_DO(WK_KLASS_DEFN)
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
    43
#undef WK_KLASS_DEFN
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
ciSymbol*        ciEnv::_unloaded_cisymbol = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
ciInstanceKlass* ciEnv::_unloaded_ciinstance_klass = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
ciObjArrayKlass* ciEnv::_unloaded_ciobjarrayklass = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
jobject ciEnv::_ArrayIndexOutOfBoundsException_handle = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
jobject ciEnv::_ArrayStoreException_handle = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
jobject ciEnv::_ClassCastException_handle = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
static bool firstEnv = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
#endif /* PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
// ciEnv::ciEnv
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
ciEnv::ciEnv(CompileTask* task, int system_dictionary_modification_counter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  thread->set_env(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  assert(ciEnv::current() == this, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  _oop_recorder = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  _debug_info = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  _dependencies = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  _failure_reason = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  _compilable = MethodCompilable;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  _break_at_compile = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  _compiler_data = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  assert(!firstEnv, "not initialized properly");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
#endif /* !PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  _system_dictionary_modification_counter = system_dictionary_modification_counter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  _num_inlined_bytecodes = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  assert(task == NULL || thread->task() == task, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  _task = task;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  _log = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  // Temporary buffer for creating symbols and such.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  _name_buffer = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  _name_buffer_len = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  _arena   = &_ciEnv_arena;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  _factory = new (_arena) ciObjectFactory(_arena, 128);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  // Preload commonly referenced system ciObjects.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  // During VM initialization, these instances have not yet been created.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  // Assertions ensure that these instances are not accessed before
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  // their initialization.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  assert(Universe::is_fully_initialized(), "should be complete");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  oop o = Universe::null_ptr_exception_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  assert(o != NULL, "should have been initialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  _NullPointerException_instance = get_object(o)->as_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  o = Universe::arithmetic_exception_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  assert(o != NULL, "should have been initialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  _ArithmeticException_instance = get_object(o)->as_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  _ArrayIndexOutOfBoundsException_instance = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  _ArrayStoreException_instance = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  _ClassCastException_instance = NULL;
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   108
  _the_null_string = NULL;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   109
  _the_min_jint_string = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
ciEnv::ciEnv(Arena* arena) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  ASSERT_IN_VM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  CompilerThread* current_thread = CompilerThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  assert(current_thread->env() == NULL, "must be");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  current_thread->set_env(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  assert(ciEnv::current() == this, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  _oop_recorder = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  _debug_info = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  _dependencies = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  _failure_reason = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  _compilable = MethodCompilable_never;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  _break_at_compile = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  _compiler_data = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  assert(firstEnv, "must be first");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  firstEnv = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
#endif /* !PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  _system_dictionary_modification_counter = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  _num_inlined_bytecodes = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  _task = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  _log = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  // Temporary buffer for creating symbols and such.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  _name_buffer = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  _name_buffer_len = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  _arena   = arena;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  _factory = new (_arena) ciObjectFactory(_arena, 128);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  // Preload commonly referenced system ciObjects.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  // During VM initialization, these instances have not yet been created.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // Assertions ensure that these instances are not accessed before
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // their initialization.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  assert(Universe::is_fully_initialized(), "must be");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  oop o = Universe::null_ptr_exception_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  assert(o != NULL, "should have been initialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  _NullPointerException_instance = get_object(o)->as_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  o = Universe::arithmetic_exception_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  assert(o != NULL, "should have been initialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  _ArithmeticException_instance = get_object(o)->as_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  _ArrayIndexOutOfBoundsException_instance = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  _ArrayStoreException_instance = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  _ClassCastException_instance = NULL;
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   163
  _the_null_string = NULL;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   164
  _the_min_jint_string = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
ciEnv::~ciEnv() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  CompilerThread* current_thread = CompilerThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  current_thread->set_env(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
// ------------------------------------------------------------------
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   173
// Cache Jvmti state
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   174
void ciEnv::cache_jvmti_state() {
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   175
  VM_ENTRY_MARK;
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   176
  // Get Jvmti capabilities under lock to get consistant values.
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   177
  MutexLocker mu(JvmtiThreadState_lock);
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   178
  _jvmti_can_hotswap_or_post_breakpoint = JvmtiExport::can_hotswap_or_post_breakpoint();
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   179
  _jvmti_can_access_local_variables     = JvmtiExport::can_access_local_variables();
4761
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4571
diff changeset
   180
  _jvmti_can_post_on_exceptions         = JvmtiExport::can_post_on_exceptions();
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   181
}
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   182
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   183
// ------------------------------------------------------------------
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   184
// Cache DTrace flags
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   185
void ciEnv::cache_dtrace_flags() {
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   186
  // Need lock?
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   187
  _dtrace_extended_probes = ExtendedDTraceProbes;
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   188
  if (_dtrace_extended_probes) {
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   189
    _dtrace_monitor_probes  = true;
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   190
    _dtrace_method_probes   = true;
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   191
    _dtrace_alloc_probes    = true;
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   192
  } else {
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   193
    _dtrace_monitor_probes  = DTraceMonitorProbes;
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   194
    _dtrace_method_probes   = DTraceMethodProbes;
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   195
    _dtrace_alloc_probes    = DTraceAllocProbes;
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   196
  }
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   197
}
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   198
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   199
// ------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
// helper for lazy exception creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
ciInstance* ciEnv::get_or_create_exception(jobject& handle, symbolHandle name) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  if (handle == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
    // Cf. universe.cpp, creation of Universe::_null_ptr_exception_instance.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
    klassOop k = SystemDictionary::find(name, Handle(), Handle(), THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
    jobject objh = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
    if (!HAS_PENDING_EXCEPTION && k != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
      oop obj = instanceKlass::cast(k)->allocate_permanent_instance(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
      if (!HAS_PENDING_EXCEPTION)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
        objh = JNIHandles::make_global(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
      handle = objh;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  oop obj = JNIHandles::resolve(handle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  return obj == NULL? NULL: get_object(obj)->as_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
// ciEnv::ArrayIndexOutOfBoundsException_instance, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
ciInstance* ciEnv::ArrayIndexOutOfBoundsException_instance() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  if (_ArrayIndexOutOfBoundsException_instance == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
    _ArrayIndexOutOfBoundsException_instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
          = get_or_create_exception(_ArrayIndexOutOfBoundsException_handle,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
          vmSymbolHandles::java_lang_ArrayIndexOutOfBoundsException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  return _ArrayIndexOutOfBoundsException_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
ciInstance* ciEnv::ArrayStoreException_instance() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  if (_ArrayStoreException_instance == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    _ArrayStoreException_instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
          = get_or_create_exception(_ArrayStoreException_handle,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
          vmSymbolHandles::java_lang_ArrayStoreException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  return _ArrayStoreException_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
ciInstance* ciEnv::ClassCastException_instance() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  if (_ClassCastException_instance == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    _ClassCastException_instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
          = get_or_create_exception(_ClassCastException_handle,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
          vmSymbolHandles::java_lang_ClassCastException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  return _ClassCastException_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   249
ciInstance* ciEnv::the_null_string() {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   250
  if (_the_null_string == NULL) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   251
    VM_ENTRY_MARK;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   252
    _the_null_string = get_object(Universe::the_null_string())->as_instance();
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   253
  }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   254
  return _the_null_string;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   255
}
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   256
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   257
ciInstance* ciEnv::the_min_jint_string() {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   258
  if (_the_min_jint_string == NULL) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   259
    VM_ENTRY_MARK;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   260
    _the_min_jint_string = get_object(Universe::the_min_jint_string())->as_instance();
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   261
  }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   262
  return _the_min_jint_string;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   263
}
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   264
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
// ciEnv::get_method_from_handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
ciMethod* ciEnv::get_method_from_handle(jobject method) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  return get_object(JNIHandles::resolve(method))->as_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
// ciEnv::make_array
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 3261
diff changeset
   274
ciArray* ciEnv::make_system_array(GrowableArray<ciObject*>* objects) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  int length = objects->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  objArrayOop a = oopFactory::new_system_objArray(length, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
    CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    record_out_of_memory_failure();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  for (int i = 0; i < length; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    a->obj_at_put(i, objects->at(i)->get_oop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  assert(a->is_perm(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  return get_object(a)->as_array();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
// ciEnv::array_element_offset_in_bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
int ciEnv::array_element_offset_in_bytes(ciArray* a_h, ciObject* o_h) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  objArrayOop a = (objArrayOop)a_h->get_oop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  assert(a->is_objArray(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  int length = a->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  oop o = o_h->get_oop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  for (int i = 0; i < length; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
    if (a->obj_at(i) == o)  return i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
// ciEnv::check_klass_accessiblity
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
// Note: the logic of this method should mirror the logic of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
// constantPoolOopDesc::verify_constant_pool_resolve.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
bool ciEnv::check_klass_accessibility(ciKlass* accessing_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
                                      klassOop resolved_klass) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  if (accessing_klass == NULL || !accessing_klass->is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  if (accessing_klass->is_obj_array()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
    accessing_klass = accessing_klass->as_obj_array_klass()->base_element_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  if (!accessing_klass->is_instance_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  if (resolved_klass->klass_part()->oop_is_objArray()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
    // Find the element klass, if this is an array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    resolved_klass = objArrayKlass::cast(resolved_klass)->bottom_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  if (resolved_klass->klass_part()->oop_is_instance()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
    return Reflection::verify_class_access(accessing_klass->get_klassOop(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
                                           resolved_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
                                           true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
// ciEnv::get_klass_by_name_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
ciKlass* ciEnv::get_klass_by_name_impl(ciKlass* accessing_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
                                       ciSymbol* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
                                       bool require_local) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  ASSERT_IN_VM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  EXCEPTION_CONTEXT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  // Now we need to check the SystemDictionary
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  symbolHandle sym(THREAD, name->get_symbolOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  if (sym->byte_at(0) == 'L' &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
    sym->byte_at(sym->utf8_length()-1) == ';') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
    // This is a name from a signature.  Strip off the trimmings.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
    sym = oopFactory::new_symbol_handle(sym->as_utf8()+1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
                                        sym->utf8_length()-2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
                                        KILL_COMPILE_ON_FATAL_(_unloaded_ciinstance_klass));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    name = get_object(sym())->as_symbol();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  // Check for prior unloaded klass.  The SystemDictionary's answers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  // can vary over time but the compiler needs consistency.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  ciKlass* unloaded_klass = check_get_unloaded_klass(accessing_klass, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  if (unloaded_klass != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
    if (require_local)  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
    return unloaded_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  Handle loader(THREAD, (oop)NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  Handle domain(THREAD, (oop)NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  if (accessing_klass != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
    loader = Handle(THREAD, accessing_klass->loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
    domain = Handle(THREAD, accessing_klass->protection_domain());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  // setup up the proper type to return on OOM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  ciKlass* fail_type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  if (sym->byte_at(0) == '[') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
    fail_type = _unloaded_ciobjarrayklass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    fail_type = _unloaded_ciinstance_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  klassOop found_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  if (!require_local) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
    found_klass =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
      SystemDictionary::find_constrained_instance_or_array_klass(sym, loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
                                                                 KILL_COMPILE_ON_FATAL_(fail_type));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
    found_klass =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
      SystemDictionary::find_instance_or_array_klass(sym, loader, domain,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
                                                     KILL_COMPILE_ON_FATAL_(fail_type));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  // If we fail to find an array klass, look again for its element type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  // The element type may be available either locally or via constraints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  // In either case, if we can find the element type in the system dictionary,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  // we must build an array type around it.  The CI requires array klasses
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  // to be loaded if their element klasses are loaded, except when memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  // is exhausted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  if (sym->byte_at(0) == '[' &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
      (sym->byte_at(1) == '[' || sym->byte_at(1) == 'L')) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
    // We have an unloaded array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
    // Build it on the fly if the element class exists.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
    symbolOop elem_sym = oopFactory::new_symbol(sym->as_utf8()+1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
                                                sym->utf8_length()-1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
                                                KILL_COMPILE_ON_FATAL_(fail_type));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
    // Get element ciKlass recursively.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
    ciKlass* elem_klass =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
      get_klass_by_name_impl(accessing_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
                             get_object(elem_sym)->as_symbol(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
                             require_local);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
    if (elem_klass != NULL && elem_klass->is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
      // Now make an array for it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
      return ciObjArrayKlass::make_impl(elem_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  if (found_klass != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
    // Found it.  Build a CI handle.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
    return get_object(found_klass)->as_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  if (require_local)  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  // Not yet loaded into the VM, or not governed by loader constraints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  // Make a CI representative for it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  return get_unloaded_klass(accessing_klass, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
// ciEnv::get_klass_by_name
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
ciKlass* ciEnv::get_klass_by_name(ciKlass* accessing_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
                                  ciSymbol* klass_name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
                                  bool require_local) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  GUARDED_VM_ENTRY(return get_klass_by_name_impl(accessing_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
                                                 klass_name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
                                                 require_local);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
// ciEnv::get_klass_by_index_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
// Implementation of get_klass_by_index.
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   436
ciKlass* ciEnv::get_klass_by_index_impl(constantPoolHandle cpool,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
                                        int index,
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   438
                                        bool& is_accessible,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   439
                                        ciInstanceKlass* accessor) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  EXCEPTION_CONTEXT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  KlassHandle klass (THREAD, constantPoolOopDesc::klass_at_if_loaded(cpool, index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  symbolHandle klass_name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  if (klass.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
    // The klass has not been inserted into the constant pool.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
    // Try to look it up by name.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
      // We have to lock the cpool to keep the oop from being resolved
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
      // while we are accessing it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
      ObjectLocker ol(cpool, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
      constantTag tag = cpool->tag_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
      if (tag.is_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
        // The klass has been inserted into the constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
        // very recently.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
        klass = KlassHandle(THREAD, cpool->resolved_klass_at(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
      } else if (tag.is_symbol()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
        klass_name = symbolHandle(THREAD, cpool->symbol_at(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
        assert(cpool->tag_at(index).is_unresolved_klass(), "wrong tag");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
        klass_name = symbolHandle(THREAD, cpool->unresolved_klass_at(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  if (klass.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
    // Not found in constant pool.  Use the name to do the lookup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
    ciKlass* k = get_klass_by_name_impl(accessor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
                                        get_object(klass_name())->as_symbol(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
                                        false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
    // Calculate accessibility the hard way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
    if (!k->is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
      is_accessible = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
    } else if (k->loader() != accessor->loader() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
               get_klass_by_name_impl(accessor, k->name(), true) == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
      // Loaded only remotely.  Not linked yet.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
      is_accessible = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
      // Linked locally, and we must also check public/private, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
      is_accessible = check_klass_accessibility(accessor, k->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
    return k;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  // Check for prior unloaded klass.  The SystemDictionary's answers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  // can vary over time but the compiler needs consistency.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  ciSymbol* name = get_object(klass()->klass_part()->name())->as_symbol();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  ciKlass* unloaded_klass = check_get_unloaded_klass(accessor, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  if (unloaded_klass != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
    is_accessible = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
    return unloaded_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  // It is known to be accessible, since it was found in the constant pool.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  is_accessible = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  return get_object(klass())->as_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
// ciEnv::get_klass_by_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
// Get a klass from the constant pool.
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   502
ciKlass* ciEnv::get_klass_by_index(constantPoolHandle cpool,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
                                   int index,
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   504
                                   bool& is_accessible,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   505
                                   ciInstanceKlass* accessor) {
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   506
  GUARDED_VM_ENTRY(return get_klass_by_index_impl(cpool, index, is_accessible, accessor);)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
// ciEnv::get_constant_by_index_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
// Implementation of get_constant_by_index().
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   513
ciConstant ciEnv::get_constant_by_index_impl(constantPoolHandle cpool,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   514
                                             int index,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   515
                                             ciInstanceKlass* accessor) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  EXCEPTION_CONTEXT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  constantTag tag = cpool->tag_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  if (tag.is_int()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
    return ciConstant(T_INT, (jint)cpool->int_at(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  } else if (tag.is_long()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
    return ciConstant((jlong)cpool->long_at(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  } else if (tag.is_float()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
    return ciConstant((jfloat)cpool->float_at(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  } else if (tag.is_double()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
    return ciConstant((jdouble)cpool->double_at(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  } else if (tag.is_string() || tag.is_unresolved_string()) {
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   527
    oop string = NULL;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   528
    if (cpool->is_pseudo_string_at(index)) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   529
      string = cpool->pseudo_string_at(index);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   530
    } else {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   531
      string = cpool->string_at(index, THREAD);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   532
      if (HAS_PENDING_EXCEPTION) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   533
        CLEAR_PENDING_EXCEPTION;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   534
        record_out_of_memory_failure();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   535
        return ciConstant();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   536
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
    ciObject* constant = get_object(string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
    assert (constant->is_instance(), "must be an instance, or not? ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
    return ciConstant(T_OBJECT, constant);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  } else if (tag.is_klass() || tag.is_unresolved_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
    // 4881222: allow ldc to take a class type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
    bool ignore;
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   544
    ciKlass* klass = get_klass_by_index_impl(cpool, index, ignore, accessor);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
      record_out_of_memory_failure();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
      return ciConstant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
    assert (klass->is_instance_klass() || klass->is_array_klass(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
            "must be an instance or array klass ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
    return ciConstant(T_OBJECT, klass);
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   553
  } else if (tag.is_object()) {
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   554
    oop obj = cpool->object_at(index);
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   555
    assert(obj->is_instance(), "must be an instance");
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   556
    ciObject* ciobj = get_object(obj);
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   557
    return ciConstant(T_OBJECT, ciobj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
    return ciConstant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
// ciEnv::is_unresolved_string_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
// Implementation of is_unresolved_string().
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
bool ciEnv::is_unresolved_string_impl(instanceKlass* accessor, int index) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
  EXCEPTION_CONTEXT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  assert(accessor->is_linked(), "must be linked before accessing constant pool");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  constantPoolOop cpool = accessor->constants();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  constantTag tag = cpool->tag_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  return tag.is_unresolved_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
// ciEnv::is_unresolved_klass_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
// Implementation of is_unresolved_klass().
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
bool ciEnv::is_unresolved_klass_impl(instanceKlass* accessor, int index) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  EXCEPTION_CONTEXT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  assert(accessor->is_linked(), "must be linked before accessing constant pool");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  constantPoolOop cpool = accessor->constants();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  constantTag tag = cpool->tag_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
  return tag.is_unresolved_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
// ciEnv::get_constant_by_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
// Pull a constant out of the constant pool.  How appropriate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
// Implementation note: this query is currently in no way cached.
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   594
ciConstant ciEnv::get_constant_by_index(constantPoolHandle cpool,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   595
                                        int index,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   596
                                        ciInstanceKlass* accessor) {
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   597
  GUARDED_VM_ENTRY(return get_constant_by_index_impl(cpool, index, accessor);)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
// ciEnv::is_unresolved_string
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
// Check constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
// Implementation note: this query is currently in no way cached.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
bool ciEnv::is_unresolved_string(ciInstanceKlass* accessor,
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   607
                                 int index) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  GUARDED_VM_ENTRY(return is_unresolved_string_impl(accessor->get_instanceKlass(), index); )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
// ciEnv::is_unresolved_klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
// Check constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
// Implementation note: this query is currently in no way cached.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
bool ciEnv::is_unresolved_klass(ciInstanceKlass* accessor,
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   618
                                int index) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  GUARDED_VM_ENTRY(return is_unresolved_klass_impl(accessor->get_instanceKlass(), index); )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
// ciEnv::get_field_by_index_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
// Implementation of get_field_by_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
// Implementation note: the results of field lookups are cached
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
// in the accessor klass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
ciField* ciEnv::get_field_by_index_impl(ciInstanceKlass* accessor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
                                        int index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  ciConstantPoolCache* cache = accessor->field_cache();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  if (cache == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
    ciField* field = new (arena()) ciField(accessor, index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
    return field;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
    ciField* field = (ciField*)cache->get(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
    if (field == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
      field = new (arena()) ciField(accessor, index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
      cache->insert(index, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    return field;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
// ciEnv::get_field_by_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
// Get a field by index from a klass's constant pool.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
ciField* ciEnv::get_field_by_index(ciInstanceKlass* accessor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
                                   int index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
  GUARDED_VM_ENTRY(return get_field_by_index_impl(accessor, index);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
// ciEnv::lookup_method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
// Perform an appropriate method lookup based on accessor, holder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
// name, signature, and bytecode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
methodOop ciEnv::lookup_method(instanceKlass*  accessor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
                               instanceKlass*  holder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
                               symbolOop       name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
                               symbolOop       sig,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
                               Bytecodes::Code bc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  EXCEPTION_CONTEXT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  KlassHandle h_accessor(THREAD, accessor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  KlassHandle h_holder(THREAD, holder);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
  symbolHandle h_name(THREAD, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
  symbolHandle h_sig(THREAD, sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
  LinkResolver::check_klass_accessability(h_accessor, h_holder, KILL_COMPILE_ON_FATAL_(NULL));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  methodHandle dest_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  switch (bc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  case Bytecodes::_invokestatic:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
    dest_method =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
      LinkResolver::resolve_static_call_or_null(h_holder, h_name, h_sig, h_accessor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
  case Bytecodes::_invokespecial:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
    dest_method =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
      LinkResolver::resolve_special_call_or_null(h_holder, h_name, h_sig, h_accessor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
  case Bytecodes::_invokeinterface:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
    dest_method =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
      LinkResolver::linktime_resolve_interface_method_or_null(h_holder, h_name, h_sig,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
                                                              h_accessor, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  case Bytecodes::_invokevirtual:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
    dest_method =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
      LinkResolver::linktime_resolve_virtual_method_or_null(h_holder, h_name, h_sig,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
                                                            h_accessor, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  default: ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
  return dest_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
// ciEnv::get_method_by_index_impl
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   699
ciMethod* ciEnv::get_method_by_index_impl(constantPoolHandle cpool,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   700
                                          int index, Bytecodes::Code bc,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   701
                                          ciInstanceKlass* accessor) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
  int holder_index = cpool->klass_ref_index_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
  bool holder_is_accessible;
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   704
  ciKlass* holder = get_klass_by_index_impl(cpool, holder_index, holder_is_accessible, accessor);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  ciInstanceKlass* declared_holder = get_instance_klass_for_declared_method_holder(holder);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  // Get the method's name and signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  symbolOop name_sym = cpool->name_ref_at(index);
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 3908
diff changeset
   709
  symbolOop sig_sym  = cpool->signature_ref_at(index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
  if (holder_is_accessible) { // Our declared holder is loaded.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
    instanceKlass* lookup = declared_holder->get_instanceKlass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
    methodOop m = lookup_method(accessor->get_instanceKlass(), lookup, name_sym, sig_sym, bc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
    if (m != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
      // We found the method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
      return get_object(m)->as_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  // Either the declared holder was not loaded, or the method could
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  // not be found.  Create a dummy ciMethod to represent the failed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  // lookup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
  return get_unloaded_method(declared_holder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
                             get_object(name_sym)->as_symbol(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
                             get_object(sig_sym)->as_symbol());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
// ------------------------------------------------------------------
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   731
// ciEnv::get_fake_invokedynamic_method_impl
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   732
ciMethod* ciEnv::get_fake_invokedynamic_method_impl(constantPoolHandle cpool,
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   733
                                                    int index, Bytecodes::Code bc) {
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   734
  // Compare the following logic with InterpreterRuntime::resolve_invokedynamic.
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   735
  assert(bc == Bytecodes::_invokedynamic, "must be invokedynamic");
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   736
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   737
  bool is_resolved = cpool->cache()->main_entry_at(index)->is_resolved(bc);
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   738
  if (is_resolved && (oop) cpool->cache()->secondary_entry_at(index)->f1() == NULL)
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   739
    // FIXME: code generation could allow for null (unlinked) call site
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   740
    is_resolved = false;
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   741
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   742
  // Call site might not be resolved yet.  We could create a real invoker method from the
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   743
  // compiler, but it is simpler to stop the code path here with an unlinked method.
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   744
  if (!is_resolved) {
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   745
    ciInstanceKlass* mh_klass = get_object(SystemDictionary::MethodHandle_klass())->as_instance_klass();
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   746
    ciSymbol*        sig_sym  = get_object(cpool->signature_ref_at(index))->as_symbol();
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   747
    return get_unloaded_method(mh_klass, ciSymbol::invokeExact_name(), sig_sym);
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   748
  }
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   749
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   750
  // Get the invoker methodOop from the constant pool.
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   751
  intptr_t f2_value = cpool->cache()->main_entry_at(index)->f2();
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   752
  methodOop signature_invoker = methodOop(f2_value);
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   753
  assert(signature_invoker != NULL && signature_invoker->is_method() && signature_invoker->is_method_handle_invoke(),
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   754
         "correct result from LinkResolver::resolve_invokedynamic");
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   755
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5353
diff changeset
   756
  return get_object(signature_invoker)->as_method();
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   757
}
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   758
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   759
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   760
// ------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
// ciEnv::get_instance_klass_for_declared_method_holder
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
ciInstanceKlass* ciEnv::get_instance_klass_for_declared_method_holder(ciKlass* method_holder) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
  // For the case of <array>.clone(), the method holder can be a ciArrayKlass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
  // instead of a ciInstanceKlass.  For that case simply pretend that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
  // declared holder is Object.clone since that's where the call will bottom out.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
  // A more correct fix would trickle out through many interfaces in CI,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  // requiring ciInstanceKlass* to become ciKlass* and many more places would
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
  // require checks to make sure the expected type was found.  Given that this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  // only occurs for clone() the more extensive fix seems like overkill so
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
  // instead we simply smear the array type into Object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
  if (method_holder->is_instance_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
    return method_holder->as_instance_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  } else if (method_holder->is_array_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
    return current()->Object_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
// ciEnv::get_method_by_index
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   784
ciMethod* ciEnv::get_method_by_index(constantPoolHandle cpool,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   785
                                     int index, Bytecodes::Code bc,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   786
                                     ciInstanceKlass* accessor) {
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   787
  if (bc == Bytecodes::_invokedynamic) {
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   788
    GUARDED_VM_ENTRY(return get_fake_invokedynamic_method_impl(cpool, index, bc);)
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   789
  } else {
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   790
    GUARDED_VM_ENTRY(return get_method_by_index_impl(cpool, index, bc, accessor);)
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   791
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   794
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
// ciEnv::name_buffer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
char *ciEnv::name_buffer(int req_len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  if (_name_buffer_len < req_len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
    if (_name_buffer == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
      _name_buffer = (char*)arena()->Amalloc(sizeof(char)*req_len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
      _name_buffer_len = req_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
      _name_buffer =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
        (char*)arena()->Arealloc(_name_buffer, _name_buffer_len, req_len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
      _name_buffer_len = req_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  return _name_buffer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
// ciEnv::is_in_vm
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
bool ciEnv::is_in_vm() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
  return JavaThread::current()->thread_state() == _thread_in_vm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
bool ciEnv::system_dictionary_modification_counter_changed() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
  return _system_dictionary_modification_counter != SystemDictionary::number_of_modifications();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
// ciEnv::check_for_system_dictionary_modification
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
// Check for changes to the system dictionary during compilation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
// class loads, evolution, breakpoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
void ciEnv::check_for_system_dictionary_modification(ciMethod* target) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  if (failing())  return;  // no need for further checks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  // Dependencies must be checked when the system dictionary changes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  // If logging is enabled all violated dependences will be recorded in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  // the log.  In debug mode check dependencies even if the system
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
  // dictionary hasn't changed to verify that no invalid dependencies
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
  // were inserted.  Any violated dependences in this case are dumped to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
  // the tty.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  bool counter_changed = system_dictionary_modification_counter_changed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  bool test_deps = counter_changed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  DEBUG_ONLY(test_deps = true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
  if (!test_deps)  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  bool print_failures = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  DEBUG_ONLY(print_failures = !counter_changed);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  bool keep_going = (print_failures || xtty != NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
  int violated = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
  for (Dependencies::DepStream deps(dependencies()); deps.next(); ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
    klassOop witness = deps.check_dependency();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
    if (witness != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
      ++violated;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
      if (print_failures)  deps.print_dependency(witness, /*verbose=*/ true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
      // If there's no log and we're not sanity-checking, we're done.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
      if (!keep_going)     break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
  if (violated != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
    assert(counter_changed, "failed dependencies, but counter didn't change");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
    record_failure("concurrent class loading");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
// ciEnv::register_method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
void ciEnv::register_method(ciMethod* target,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
                            int entry_bci,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
                            CodeOffsets* offsets,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
                            int orig_pc_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
                            CodeBuffer* code_buffer,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
                            int frame_words,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
                            OopMapSet* oop_map_set,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
                            ExceptionHandlerTable* handler_table,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
                            ImplicitExceptionTable* inc_table,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
                            AbstractCompiler* compiler,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
                            int comp_level,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
                            bool has_debug_info,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
                            bool has_unsafe_access) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
  nmethod* nm = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
    // To prevent compile queue updates.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
    MutexLocker locker(MethodCompileQueue_lock, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
    // Prevent SystemDictionary::add_to_hierarchy from running
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
    // and invalidating our dependencies until we install this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
    MutexLocker ml(Compile_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   888
    // Change in Jvmti state may invalidate compilation.
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   889
    if (!failing() &&
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   890
        ( (!jvmti_can_hotswap_or_post_breakpoint() &&
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   891
           JvmtiExport::can_hotswap_or_post_breakpoint()) ||
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   892
          (!jvmti_can_access_local_variables() &&
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   893
           JvmtiExport::can_access_local_variables()) ||
4761
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4571
diff changeset
   894
          (!jvmti_can_post_on_exceptions() &&
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4571
diff changeset
   895
           JvmtiExport::can_post_on_exceptions()) )) {
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   896
      record_failure("Jvmti state change invalidated dependencies");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   899
    // Change in DTrace flags may invalidate compilation.
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   900
    if (!failing() &&
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   901
        ( (!dtrace_extended_probes() && ExtendedDTraceProbes) ||
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   902
          (!dtrace_method_probes() && DTraceMethodProbes) ||
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   903
          (!dtrace_alloc_probes() && DTraceAllocProbes) )) {
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   904
      record_failure("DTrace flags change invalidated dependencies");
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   905
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   907
    if (!failing()) {
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   908
      if (log() != NULL) {
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   909
        // Log the dependencies which this compilation declares.
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   910
        dependencies()->log_all_dependencies();
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   911
      }
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   912
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   913
      // Encode the dependencies now, so we can check them right away.
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   914
      dependencies()->encode_content_bytes();
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   915
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   916
      // Check for {class loads, evolution, breakpoints} during compilation
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   917
      check_for_system_dictionary_modification(target);
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   918
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
    methodHandle method(THREAD, target->get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
    if (failing()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
      // While not a true deoptimization, it is a preemptive decompile.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
      methodDataOop mdo = method()->method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
      if (mdo != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
        mdo->inc_decompile_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
      // All buffers in the CodeBuffer are allocated in the CodeCache.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
      // If the code buffer is created on each compile attempt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
      // as in C2, then it must be freed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
      code_buffer->free_blob();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
    assert(offsets->value(CodeOffsets::Deopt) != -1, "must have deopt entry");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
    assert(offsets->value(CodeOffsets::Exceptions) != -1, "must have exception entry");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
    nm =  nmethod::new_nmethod(method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
                               compile_id(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
                               entry_bci,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
                               offsets,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
                               orig_pc_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
                               debug_info(), dependencies(), code_buffer,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
                               frame_words, oop_map_set,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
                               handler_table, inc_table,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
                               compiler, comp_level);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
    // Free codeBlobs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
    code_buffer->free_blob();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
    // stress test 6243940 by immediately making the method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
    // non-entrant behind the system's back. This has serious
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
    // side effects on the code cache and is not meant for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
    // general stress testing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
    if (nm != NULL && StressNonEntrant) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
      MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
      NativeJump::patch_verified_entry(nm->entry_point(), nm->verified_entry_point(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
                  SharedRuntime::get_handle_wrong_method_stub());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
    if (nm == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
      // The CodeCache is full.  Print out warning and disable compilation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
      record_failure("code cache is full");
4750
71fd601907dc 4360113: Evict nmethods when code cache gets full
kvn
parents: 4571
diff changeset
   965
      {
71fd601907dc 4360113: Evict nmethods when code cache gets full
kvn
parents: 4571
diff changeset
   966
        MutexUnlocker ml(Compile_lock);
71fd601907dc 4360113: Evict nmethods when code cache gets full
kvn
parents: 4571
diff changeset
   967
        MutexUnlocker locker(MethodCompileQueue_lock);
71fd601907dc 4360113: Evict nmethods when code cache gets full
kvn
parents: 4571
diff changeset
   968
        CompileBroker::handle_full_code_cache();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
      NOT_PRODUCT(nm->set_has_debug_info(has_debug_info); )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
      nm->set_has_unsafe_access(has_unsafe_access);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
      // Record successful registration.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
      // (Put nm into the task handle *before* publishing to the Java heap.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
      if (task() != NULL)  task()->set_code(nm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
      if (entry_bci == InvocationEntryBci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
#ifdef TIERED
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
        // If there is an old version we're done with it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
        nmethod* old = method->code();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
        if (TraceMethodReplacement && old != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
          ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
          char *method_name = method->name_and_sig_as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
          tty->print_cr("Replacing method %s", method_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
        if (old != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
          old->make_not_entrant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
#endif // TIERED
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
        if (TraceNMethodInstalls ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
          ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
          char *method_name = method->name_and_sig_as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
          ttyLocker ttyl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
          tty->print_cr("Installing method (%d) %s ",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
                        comp_level,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
                        method_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
        // Allow the code to be executed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
        method->set_code(method, nm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
        if (TraceNMethodInstalls ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
          ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
          char *method_name = method->name_and_sig_as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
          ttyLocker ttyl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
          tty->print_cr("Installing osr method (%d) %s @ %d",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
                        comp_level,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
                        method_name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
                        entry_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
        instanceKlass::cast(method->method_holder())->add_osr_nmethod(nm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
  // JVMTI -- compiled method notification (must be done outside lock)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
  if (nm != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
    nm->post_compiled_method_load_event();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
// ciEnv::find_system_klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
ciKlass* ciEnv::find_system_klass(ciSymbol* klass_name) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
  return get_klass_by_name_impl(NULL, klass_name, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
// ciEnv::comp_level
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
int ciEnv::comp_level() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
  if (task() == NULL)  return CompLevel_full_optimization;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  return task()->comp_level();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
// ciEnv::compile_id
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
uint ciEnv::compile_id() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
  if (task() == NULL)  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
  return task()->compile_id();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
// ciEnv::notice_inlined_method()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
void ciEnv::notice_inlined_method(ciMethod* method) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
  _num_inlined_bytecodes += method->code_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
// ciEnv::num_inlined_bytecodes()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
int ciEnv::num_inlined_bytecodes() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
  return _num_inlined_bytecodes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
// ciEnv::record_failure()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
void ciEnv::record_failure(const char* reason) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
  if (log() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
    log()->elem("failure reason='%s'", reason);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
  if (_failure_reason == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
    // Record the first failure reason.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
    _failure_reason = reason;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
// ciEnv::record_method_not_compilable()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
void ciEnv::record_method_not_compilable(const char* reason, bool all_tiers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
  int new_compilable =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
    all_tiers ? MethodCompilable_never : MethodCompilable_not_at_tier ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
  // Only note transitions to a worse state
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
  if (new_compilable > _compilable) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
    if (log() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
      if (all_tiers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
        log()->elem("method_not_compilable");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
        log()->elem("method_not_compilable_at_tier");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
    _compilable = new_compilable;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
    // Reset failure reason; this one is more important.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
    _failure_reason = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
    record_failure(reason);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
// ciEnv::record_out_of_memory_failure()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
void ciEnv::record_out_of_memory_failure() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  // If memory is low, we stop compiling methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
  record_method_not_compilable("out of memory");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
}