src/hotspot/share/ci/ciEnv.cpp
author rkennke
Sun, 15 Oct 2017 22:54:03 +0200
changeset 47687 fb290fd1f9d4
parent 47216 71c04702a3d5
child 47765 b7c7428eaab9
permissions -rw-r--r--
8171853: Remove Shark compiler Reviewed-by: dholmes, kvn, erikj, ihse
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
46262
83280d968b96 8174092: Remove array-related access checks from Reflection::verify_class_access()
hseigel
parents: 40664
diff changeset
     2
 * Copyright (c) 1999, 2017, 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
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    26
#include "ci/ciConstant.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    27
#include "ci/ciEnv.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    28
#include "ci/ciField.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    29
#include "ci/ciInstance.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    30
#include "ci/ciInstanceKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    31
#include "ci/ciMethod.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    32
#include "ci/ciNullObject.hpp"
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
    33
#include "ci/ciReplay.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    34
#include "ci/ciUtilities.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    35
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    36
#include "classfile/vmSymbols.hpp"
26796
666464578742 8015774: Add support for multiple code heaps
thartmann
parents: 26587
diff changeset
    37
#include "code/codeCache.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    38
#include "code/scopeDesc.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    39
#include "compiler/compileBroker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    40
#include "compiler/compileLog.hpp"
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 31019
diff changeset
    41
#include "compiler/disassembler.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29081
diff changeset
    42
#include "gc/shared/collectedHeap.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    43
#include "interpreter/linkResolver.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    44
#include "memory/allocation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    45
#include "memory/oopFactory.hpp"
37248
11a660dbbb8e 8132524: Missing includes to resourceArea.hpp
jprovino
parents: 36508
diff changeset
    46
#include "memory/resourceArea.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    47
#include "memory/universe.inline.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
    48
#include "oops/methodData.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    49
#include "oops/objArrayKlass.hpp"
29081
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 27706
diff changeset
    50
#include "oops/objArrayOop.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    51
#include "oops/oop.inline.hpp"
46560
388aa8d67c80 8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents: 46329
diff changeset
    52
#include "prims/jvm.h"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    53
#include "prims/jvmtiExport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    54
#include "runtime/init.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    55
#include "runtime/reflection.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    56
#include "runtime/sharedRuntime.hpp"
24351
61b33cc6d3cf 8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents: 23496
diff changeset
    57
#include "runtime/thread.inline.hpp"
27706
3f10f4ac2bd6 8065339: Failed compilation does not always trigger a JFR event 'CompilerFailure'
thartmann
parents: 27420
diff changeset
    58
#include "trace/tracing.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    59
#include "utilities/dtrace.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14490
diff changeset
    60
#include "utilities/macros.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    61
#ifdef COMPILER1
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    62
#include "c1/c1_Runtime1.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    63
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    64
#ifdef COMPILER2
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    65
#include "opto/runtime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    66
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
// ciEnv
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
// This class is the top level broker for requests from the compiler
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
// to the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
ciObject*              ciEnv::_null_object_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
    75
#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
    76
WK_KLASSES_DO(WK_KLASS_DEFN)
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
    77
#undef WK_KLASS_DEFN
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
ciSymbol*        ciEnv::_unloaded_cisymbol = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
ciInstanceKlass* ciEnv::_unloaded_ciinstance_klass = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
ciObjArrayKlass* ciEnv::_unloaded_ciobjarrayklass = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
jobject ciEnv::_ArrayIndexOutOfBoundsException_handle = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
jobject ciEnv::_ArrayStoreException_handle = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
jobject ciEnv::_ClassCastException_handle = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
static bool firstEnv = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
#endif /* PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
// ciEnv::ciEnv
25946
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25642
diff changeset
    93
ciEnv::ciEnv(CompileTask* task, int system_dictionary_modification_counter)
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25642
diff changeset
    94
  : _ciEnv_arena(mtCompiler) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  thread->set_env(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  assert(ciEnv::current() == this, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  _oop_recorder = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  _debug_info = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  _dependencies = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  _failure_reason = NULL;
43675
a2b322083029 8173338: C2: continuous CallSite relinkage eventually disables compilation for a method
vlivanov
parents: 40664
diff changeset
   105
  _inc_decompile_count_on_failure = true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  _compilable = MethodCompilable;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  _break_at_compile = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  _compiler_data = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  assert(!firstEnv, "not initialized properly");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
#endif /* !PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  _system_dictionary_modification_counter = system_dictionary_modification_counter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  _num_inlined_bytecodes = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  assert(task == NULL || thread->task() == task, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  _task = task;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  _log = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  // Temporary buffer for creating symbols and such.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  _name_buffer = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  _name_buffer_len = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  _arena   = &_ciEnv_arena;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  _factory = new (_arena) ciObjectFactory(_arena, 128);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  // Preload commonly referenced system ciObjects.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  // During VM initialization, these instances have not yet been created.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  // Assertions ensure that these instances are not accessed before
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  // their initialization.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  assert(Universe::is_fully_initialized(), "should be complete");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  oop o = Universe::null_ptr_exception_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  assert(o != NULL, "should have been initialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  _NullPointerException_instance = get_object(o)->as_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  o = Universe::arithmetic_exception_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  assert(o != NULL, "should have been initialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  _ArithmeticException_instance = get_object(o)->as_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  _ArrayIndexOutOfBoundsException_instance = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  _ArrayStoreException_instance = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  _ClassCastException_instance = NULL;
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   144
  _the_null_string = NULL;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   145
  _the_min_jint_string = NULL;
22893
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   146
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   147
  _jvmti_can_hotswap_or_post_breakpoint = false;
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   148
  _jvmti_can_access_local_variables = false;
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   149
  _jvmti_can_post_on_exceptions = false;
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   150
  _jvmti_can_pop_frame = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
25946
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25642
diff changeset
   153
ciEnv::ciEnv(Arena* arena) : _ciEnv_arena(mtCompiler) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  ASSERT_IN_VM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  CompilerThread* current_thread = CompilerThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  assert(current_thread->env() == NULL, "must be");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  current_thread->set_env(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  assert(ciEnv::current() == this, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  _oop_recorder = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  _debug_info = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  _dependencies = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  _failure_reason = NULL;
43675
a2b322083029 8173338: C2: continuous CallSite relinkage eventually disables compilation for a method
vlivanov
parents: 40664
diff changeset
   166
  _inc_decompile_count_on_failure = true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  _compilable = MethodCompilable_never;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  _break_at_compile = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  _compiler_data = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  assert(firstEnv, "must be first");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  firstEnv = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
#endif /* !PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  _system_dictionary_modification_counter = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  _num_inlined_bytecodes = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  _task = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  _log = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  // Temporary buffer for creating symbols and such.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  _name_buffer = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  _name_buffer_len = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  _arena   = arena;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  _factory = new (_arena) ciObjectFactory(_arena, 128);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  // Preload commonly referenced system ciObjects.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  // During VM initialization, these instances have not yet been created.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  // Assertions ensure that these instances are not accessed before
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  // their initialization.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  assert(Universe::is_fully_initialized(), "must be");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   195
  _NullPointerException_instance = NULL;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   196
  _ArithmeticException_instance = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  _ArrayIndexOutOfBoundsException_instance = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  _ArrayStoreException_instance = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  _ClassCastException_instance = NULL;
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   200
  _the_null_string = NULL;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   201
  _the_min_jint_string = NULL;
22893
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   202
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   203
  _jvmti_can_hotswap_or_post_breakpoint = false;
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   204
  _jvmti_can_access_local_variables = false;
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   205
  _jvmti_can_post_on_exceptions = false;
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   206
  _jvmti_can_pop_frame = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
ciEnv::~ciEnv() {
40057
a0511d037cbe 8098573: Compiler accesses to shared archive fail if archive is remapped
zmajo
parents: 38719
diff changeset
   210
  GUARDED_VM_ENTRY(
a0511d037cbe 8098573: Compiler accesses to shared archive fail if archive is remapped
zmajo
parents: 38719
diff changeset
   211
      CompilerThread* current_thread = CompilerThread::current();
a0511d037cbe 8098573: Compiler accesses to shared archive fail if archive is remapped
zmajo
parents: 38719
diff changeset
   212
      _factory->remove_symbols();
a0511d037cbe 8098573: Compiler accesses to shared archive fail if archive is remapped
zmajo
parents: 38719
diff changeset
   213
      // Need safepoint to clear the env on the thread.  RedefineClasses might
a0511d037cbe 8098573: Compiler accesses to shared archive fail if archive is remapped
zmajo
parents: 38719
diff changeset
   214
      // be reading it.
a0511d037cbe 8098573: Compiler accesses to shared archive fail if archive is remapped
zmajo
parents: 38719
diff changeset
   215
      current_thread->set_env(NULL);
a0511d037cbe 8098573: Compiler accesses to shared archive fail if archive is remapped
zmajo
parents: 38719
diff changeset
   216
  )
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
// ------------------------------------------------------------------
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   220
// 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
   221
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
   222
  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
   223
  // 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
   224
  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
   225
  _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
   226
  _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
   227
  _jvmti_can_post_on_exceptions         = JvmtiExport::can_post_on_exceptions();
22893
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   228
  _jvmti_can_pop_frame                  = JvmtiExport::can_pop_frame();
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   229
}
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   230
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   231
bool ciEnv::should_retain_local_variables() const {
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   232
  return _jvmti_can_access_local_variables || _jvmti_can_pop_frame;
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   233
}
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   234
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   235
bool ciEnv::jvmti_state_changed() const {
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   236
  if (!_jvmti_can_access_local_variables &&
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   237
      JvmtiExport::can_access_local_variables()) {
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   238
    return true;
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   239
  }
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   240
  if (!_jvmti_can_hotswap_or_post_breakpoint &&
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   241
      JvmtiExport::can_hotswap_or_post_breakpoint()) {
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   242
    return true;
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   243
  }
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   244
  if (!_jvmti_can_post_on_exceptions &&
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   245
      JvmtiExport::can_post_on_exceptions()) {
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   246
    return true;
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   247
  }
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   248
  if (!_jvmti_can_pop_frame &&
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   249
      JvmtiExport::can_pop_frame()) {
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   250
    return true;
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   251
  }
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   252
  return false;
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   253
}
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   254
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   255
// ------------------------------------------------------------------
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   256
// 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
   257
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
   258
  // Need lock?
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   259
  _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
   260
  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
   261
    _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
   262
    _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
   263
    _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
   264
  } else {
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   265
    _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
   266
    _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
   267
    _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
   268
  }
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   269
}
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   270
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   271
// ------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
// helper for lazy exception creation
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   273
ciInstance* ciEnv::get_or_create_exception(jobject& handle, Symbol* name) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  if (handle == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
    // Cf. universe.cpp, creation of Universe::_null_ptr_exception_instance.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   277
    Klass* k = SystemDictionary::find(name, Handle(), Handle(), THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
    jobject objh = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
    if (!HAS_PENDING_EXCEPTION && k != NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   280
      oop obj = InstanceKlass::cast(k)->allocate_instance(THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
      if (!HAS_PENDING_EXCEPTION)
46271
979ebd346ecf 8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents: 46262
diff changeset
   282
        objh = JNIHandles::make_global(Handle(THREAD, obj));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
      handle = objh;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  oop obj = JNIHandles::resolve(handle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  return obj == NULL? NULL: get_object(obj)->as_instance();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
ciInstance* ciEnv::ArrayIndexOutOfBoundsException_instance() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  if (_ArrayIndexOutOfBoundsException_instance == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
    _ArrayIndexOutOfBoundsException_instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
          = get_or_create_exception(_ArrayIndexOutOfBoundsException_handle,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   298
          vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  return _ArrayIndexOutOfBoundsException_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
ciInstance* ciEnv::ArrayStoreException_instance() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  if (_ArrayStoreException_instance == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
    _ArrayStoreException_instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
          = get_or_create_exception(_ArrayStoreException_handle,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   306
          vmSymbols::java_lang_ArrayStoreException());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  return _ArrayStoreException_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
ciInstance* ciEnv::ClassCastException_instance() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  if (_ClassCastException_instance == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
    _ClassCastException_instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
          = get_or_create_exception(_ClassCastException_handle,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   314
          vmSymbols::java_lang_ClassCastException());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  return _ClassCastException_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   319
ciInstance* ciEnv::the_null_string() {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   320
  if (_the_null_string == NULL) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   321
    VM_ENTRY_MARK;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   322
    _the_null_string = get_object(Universe::the_null_string())->as_instance();
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   323
  }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   324
  return _the_null_string;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   325
}
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   326
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   327
ciInstance* ciEnv::the_min_jint_string() {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   328
  if (_the_min_jint_string == NULL) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   329
    VM_ENTRY_MARK;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   330
    _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
   331
  }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   332
  return _the_min_jint_string;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   333
}
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   334
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
// ciEnv::get_method_from_handle
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   337
ciMethod* ciEnv::get_method_from_handle(Method* method) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  VM_ENTRY_MARK;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   339
  return get_metadata(method)->as_method();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
// ciEnv::array_element_offset_in_bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
int ciEnv::array_element_offset_in_bytes(ciArray* a_h, ciObject* o_h) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  objArrayOop a = (objArrayOop)a_h->get_oop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  assert(a->is_objArray(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  int length = a->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  oop o = o_h->get_oop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  for (int i = 0; i < length; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    if (a->obj_at(i) == o)  return i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
// ciEnv::check_klass_accessiblity
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
// Note: the logic of this method should mirror the logic of
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   361
// ConstantPool::verify_constant_pool_resolve.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
bool ciEnv::check_klass_accessibility(ciKlass* accessing_klass,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   363
                                      Klass* resolved_klass) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  if (accessing_klass == NULL || !accessing_klass->is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   367
  if (accessing_klass->is_obj_array_klass()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
    accessing_klass = accessing_klass->as_obj_array_klass()->base_element_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  if (!accessing_klass->is_instance_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33593
diff changeset
   374
  if (resolved_klass->is_objArray_klass()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
    // Find the element klass, if this is an array.
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13883
diff changeset
   376
    resolved_klass = ObjArrayKlass::cast(resolved_klass)->bottom_klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  }
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33593
diff changeset
   378
  if (resolved_klass->is_instance_klass()) {
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 35606
diff changeset
   379
    return (Reflection::verify_class_access(accessing_klass->get_Klass(),
46262
83280d968b96 8174092: Remove array-related access checks from Reflection::verify_class_access()
hseigel
parents: 40664
diff changeset
   380
                                            InstanceKlass::cast(resolved_klass),
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 35606
diff changeset
   381
                                            true) == Reflection::ACCESS_OK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
// ciEnv::get_klass_by_name_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
ciKlass* ciEnv::get_klass_by_name_impl(ciKlass* accessing_klass,
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 31019
diff changeset
   389
                                       const constantPoolHandle& cpool,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
                                       ciSymbol* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
                                       bool require_local) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  ASSERT_IN_VM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  EXCEPTION_CONTEXT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  // Now we need to check the SystemDictionary
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   396
  Symbol* sym = name->get_symbol();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  if (sym->byte_at(0) == 'L' &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
    sym->byte_at(sym->utf8_length()-1) == ';') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
    // This is a name from a signature.  Strip off the trimmings.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   400
    // Call recursive to keep scope of strippedsym.
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   401
    TempNewSymbol strippedsym = SymbolTable::new_symbol(sym->as_utf8()+1,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   402
                    sym->utf8_length()-2,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   403
                    KILL_COMPILE_ON_FATAL_(_unloaded_ciinstance_klass));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   404
    ciSymbol* strippedname = get_symbol(strippedsym);
10008
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   405
    return get_klass_by_name_impl(accessing_klass, cpool, strippedname, require_local);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  // Check for prior unloaded klass.  The SystemDictionary's answers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  // can vary over time but the compiler needs consistency.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  ciKlass* unloaded_klass = check_get_unloaded_klass(accessing_klass, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  if (unloaded_klass != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
    if (require_local)  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
    return unloaded_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
  Handle loader(THREAD, (oop)NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  Handle domain(THREAD, (oop)NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  if (accessing_klass != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
    loader = Handle(THREAD, accessing_klass->loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
    domain = Handle(THREAD, accessing_klass->protection_domain());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  // setup up the proper type to return on OOM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  ciKlass* fail_type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  if (sym->byte_at(0) == '[') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
    fail_type = _unloaded_ciobjarrayklass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
    fail_type = _unloaded_ciinstance_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  }
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   430
  Klass* found_klass;
8314
057b1c20fd7e 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents: 8076
diff changeset
   431
  {
8333
11a7f6fc6419 7021531: lock ordering problems after fix for 6354181
never
parents: 8314
diff changeset
   432
    ttyUnlocker ttyul;  // release tty lock to avoid ordering problems
8314
057b1c20fd7e 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents: 8076
diff changeset
   433
    MutexLocker ml(Compile_lock);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   434
    Klass* kls;
8314
057b1c20fd7e 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents: 8076
diff changeset
   435
    if (!require_local) {
057b1c20fd7e 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents: 8076
diff changeset
   436
      kls = SystemDictionary::find_constrained_instance_or_array_klass(sym, loader,
057b1c20fd7e 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents: 8076
diff changeset
   437
                                                                       KILL_COMPILE_ON_FATAL_(fail_type));
057b1c20fd7e 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents: 8076
diff changeset
   438
    } else {
057b1c20fd7e 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents: 8076
diff changeset
   439
      kls = SystemDictionary::find_instance_or_array_klass(sym, loader, domain,
057b1c20fd7e 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents: 8076
diff changeset
   440
                                                           KILL_COMPILE_ON_FATAL_(fail_type));
057b1c20fd7e 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents: 8076
diff changeset
   441
    }
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   442
    found_klass = kls;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  // If we fail to find an array klass, look again for its element type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  // The element type may be available either locally or via constraints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  // In either case, if we can find the element type in the system dictionary,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  // we must build an array type around it.  The CI requires array klasses
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  // to be loaded if their element klasses are loaded, except when memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  // is exhausted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  if (sym->byte_at(0) == '[' &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
      (sym->byte_at(1) == '[' || sym->byte_at(1) == 'L')) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
    // We have an unloaded array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
    // Build it on the fly if the element class exists.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   455
    TempNewSymbol elem_sym = SymbolTable::new_symbol(sym->as_utf8()+1,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   456
                                                 sym->utf8_length()-1,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   457
                                                 KILL_COMPILE_ON_FATAL_(fail_type));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   458
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
    // Get element ciKlass recursively.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
    ciKlass* elem_klass =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
      get_klass_by_name_impl(accessing_klass,
10008
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   462
                             cpool,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   463
                             get_symbol(elem_sym),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
                             require_local);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
    if (elem_klass != NULL && elem_klass->is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
      // Now make an array for it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
      return ciObjArrayKlass::make_impl(elem_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   471
  if (found_klass == NULL && !cpool.is_null() && cpool->has_preresolution()) {
10008
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   472
    // Look inside the constant pool for pre-resolved class entries.
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   473
    for (int i = cpool->length() - 1; i >= 1; i--) {
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   474
      if (cpool->tag_at(i).is_klass()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   475
        Klass* kls = cpool->resolved_klass_at(i);
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   476
        if (kls->name() == sym) {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   477
          found_klass = kls;
10008
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   478
          break;
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   479
        }
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   480
      }
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   481
    }
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   482
  }
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   483
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   484
  if (found_klass != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
    // Found it.  Build a CI handle.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   486
    return get_klass(found_klass);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  if (require_local)  return NULL;
10734
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10564
diff changeset
   490
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  // Not yet loaded into the VM, or not governed by loader constraints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  // Make a CI representative for it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  return get_unloaded_klass(accessing_klass, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
// ciEnv::get_klass_by_name
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
ciKlass* ciEnv::get_klass_by_name(ciKlass* accessing_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
                                  ciSymbol* klass_name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
                                  bool require_local) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  GUARDED_VM_ENTRY(return get_klass_by_name_impl(accessing_klass,
10008
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   502
                                                 constantPoolHandle(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
                                                 klass_name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
                                                 require_local);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
// ciEnv::get_klass_by_index_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
// Implementation of get_klass_by_index.
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 31019
diff changeset
   511
ciKlass* ciEnv::get_klass_by_index_impl(const constantPoolHandle& cpool,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
                                        int index,
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   513
                                        bool& is_accessible,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   514
                                        ciInstanceKlass* accessor) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  EXCEPTION_CONTEXT;
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   516
  Klass* klass = NULL;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   517
  Symbol* klass_name = NULL;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   518
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   519
  if (cpool->tag_at(index).is_symbol()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   520
    klass_name = cpool->symbol_at(index);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   521
  } else {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   522
    // Check if it's resolved if it's not a symbol constant pool entry.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   523
    klass =  ConstantPool::klass_at_if_loaded(cpool, index);
25325
e3af4e02b0d5 8026977: NPG: Remove ConstantPool::lock
coleenp
parents: 24424
diff changeset
   524
    // Try to look it up by name.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   525
    if (klass == NULL) {
25325
e3af4e02b0d5 8026977: NPG: Remove ConstantPool::lock
coleenp
parents: 24424
diff changeset
   526
      klass_name = cpool->klass_name_at(index);
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   527
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   528
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   530
  if (klass == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
    // Not found in constant pool.  Use the name to do the lookup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    ciKlass* k = get_klass_by_name_impl(accessor,
10008
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   533
                                        cpool,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   534
                                        get_symbol(klass_name),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
                                        false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
    // Calculate accessibility the hard way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    if (!k->is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
      is_accessible = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
    } else if (k->loader() != accessor->loader() &&
10008
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   540
               get_klass_by_name_impl(accessor, cpool, k->name(), true) == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
      // Loaded only remotely.  Not linked yet.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
      is_accessible = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
      // Linked locally, and we must also check public/private, etc.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   545
      is_accessible = check_klass_accessibility(accessor, k->get_Klass());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
    return k;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  // Check for prior unloaded klass.  The SystemDictionary's answers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  // can vary over time but the compiler needs consistency.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   552
  ciSymbol* name = get_symbol(klass->name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  ciKlass* unloaded_klass = check_get_unloaded_klass(accessor, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  if (unloaded_klass != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
    is_accessible = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
    return unloaded_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  // It is known to be accessible, since it was found in the constant pool.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
  is_accessible = true;
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   561
  return get_klass(klass);
1
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::get_klass_by_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
// Get a klass from the constant pool.
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 31019
diff changeset
   568
ciKlass* ciEnv::get_klass_by_index(const constantPoolHandle& cpool,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
                                   int index,
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   570
                                   bool& is_accessible,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   571
                                   ciInstanceKlass* accessor) {
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   572
  GUARDED_VM_ENTRY(return get_klass_by_index_impl(cpool, index, is_accessible, accessor);)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
// ciEnv::get_constant_by_index_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
// Implementation of get_constant_by_index().
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 31019
diff changeset
   579
ciConstant ciEnv::get_constant_by_index_impl(const constantPoolHandle& cpool,
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   580
                                             int pool_index, int cache_index,
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   581
                                             ciInstanceKlass* accessor) {
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   582
  bool ignore_will_link;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  EXCEPTION_CONTEXT;
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   584
  int index = pool_index;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   585
  if (cache_index >= 0) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   586
    assert(index < 0, "only one kind of index at a time");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   587
    oop obj = cpool->resolved_references()->obj_at(cache_index);
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   588
    if (obj != NULL) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   589
      ciObject* ciobj = get_object(obj);
26944
d515f86283be 8058828: Wrong ciConstant type for arrays from ConstantPool::_resolved_reference
vlivanov
parents: 26796
diff changeset
   590
      if (ciobj->is_array()) {
d515f86283be 8058828: Wrong ciConstant type for arrays from ConstantPool::_resolved_reference
vlivanov
parents: 26796
diff changeset
   591
        return ciConstant(T_ARRAY, ciobj);
d515f86283be 8058828: Wrong ciConstant type for arrays from ConstantPool::_resolved_reference
vlivanov
parents: 26796
diff changeset
   592
      } else {
d515f86283be 8058828: Wrong ciConstant type for arrays from ConstantPool::_resolved_reference
vlivanov
parents: 26796
diff changeset
   593
        assert(ciobj->is_instance(), "should be an instance");
d515f86283be 8058828: Wrong ciConstant type for arrays from ConstantPool::_resolved_reference
vlivanov
parents: 26796
diff changeset
   594
        return ciConstant(T_OBJECT, ciobj);
d515f86283be 8058828: Wrong ciConstant type for arrays from ConstantPool::_resolved_reference
vlivanov
parents: 26796
diff changeset
   595
      }
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   596
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   597
    index = cpool->object_to_cp_index(cache_index);
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   598
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
  constantTag tag = cpool->tag_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  if (tag.is_int()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
    return ciConstant(T_INT, (jint)cpool->int_at(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
  } else if (tag.is_long()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
    return ciConstant((jlong)cpool->long_at(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  } else if (tag.is_float()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
    return ciConstant((jfloat)cpool->float_at(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  } else if (tag.is_double()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
    return ciConstant((jdouble)cpool->double_at(index));
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   608
  } else if (tag.is_string()) {
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   609
    oop string = NULL;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   610
    assert(cache_index >= 0, "should have a cache index");
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   611
    if (cpool->is_pseudo_string_at(index)) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   612
      string = cpool->pseudo_string_at(index, cache_index);
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   613
    } else {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   614
      string = cpool->string_at(index, cache_index, THREAD);
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   615
      if (HAS_PENDING_EXCEPTION) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   616
        CLEAR_PENDING_EXCEPTION;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   617
        record_out_of_memory_failure();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   618
        return ciConstant();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   619
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
    ciObject* constant = get_object(string);
26944
d515f86283be 8058828: Wrong ciConstant type for arrays from ConstantPool::_resolved_reference
vlivanov
parents: 26796
diff changeset
   622
    if (constant->is_array()) {
d515f86283be 8058828: Wrong ciConstant type for arrays from ConstantPool::_resolved_reference
vlivanov
parents: 26796
diff changeset
   623
      return ciConstant(T_ARRAY, constant);
d515f86283be 8058828: Wrong ciConstant type for arrays from ConstantPool::_resolved_reference
vlivanov
parents: 26796
diff changeset
   624
    } else {
d515f86283be 8058828: Wrong ciConstant type for arrays from ConstantPool::_resolved_reference
vlivanov
parents: 26796
diff changeset
   625
      assert (constant->is_instance(), "must be an instance, or not? ");
d515f86283be 8058828: Wrong ciConstant type for arrays from ConstantPool::_resolved_reference
vlivanov
parents: 26796
diff changeset
   626
      return ciConstant(T_OBJECT, constant);
d515f86283be 8058828: Wrong ciConstant type for arrays from ConstantPool::_resolved_reference
vlivanov
parents: 26796
diff changeset
   627
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  } else if (tag.is_klass() || tag.is_unresolved_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
    // 4881222: allow ldc to take a class type
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   630
    ciKlass* klass = get_klass_by_index_impl(cpool, index, ignore_will_link, accessor);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
      record_out_of_memory_failure();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
      return ciConstant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
    assert (klass->is_instance_klass() || klass->is_array_klass(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
            "must be an instance or array klass ");
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   638
    return ciConstant(T_OBJECT, klass->java_mirror());
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   639
  } else if (tag.is_method_type()) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   640
    // must execute Java code to link this CP entry into cache[i].f1
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   641
    ciSymbol* signature = get_symbol(cpool->method_type_signature_at(index));
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   642
    ciObject* ciobj = get_unloaded_method_type_constant(signature);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   643
    return ciConstant(T_OBJECT, ciobj);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   644
  } else if (tag.is_method_handle()) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   645
    // must execute Java code to link this CP entry into cache[i].f1
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   646
    int ref_kind        = cpool->method_handle_ref_kind_at(index);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   647
    int callee_index    = cpool->method_handle_klass_index_at(index);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   648
    ciKlass* callee     = get_klass_by_index_impl(cpool, callee_index, ignore_will_link, accessor);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   649
    ciSymbol* name      = get_symbol(cpool->method_handle_name_ref_at(index));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
   650
    ciSymbol* signature = get_symbol(cpool->method_handle_signature_ref_at(index));
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   651
    ciObject* ciobj     = get_unloaded_method_handle_constant(callee, name, signature, ref_kind);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   652
    return ciConstant(T_OBJECT, ciobj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
    return ciConstant();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
// ciEnv::get_constant_by_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
// Pull a constant out of the constant pool.  How appropriate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
// Implementation note: this query is currently in no way cached.
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 31019
diff changeset
   665
ciConstant ciEnv::get_constant_by_index(const constantPoolHandle& cpool,
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   666
                                        int pool_index, int cache_index,
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   667
                                        ciInstanceKlass* accessor) {
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   668
  GUARDED_VM_ENTRY(return get_constant_by_index_impl(cpool, pool_index, cache_index, accessor);)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
// ciEnv::get_field_by_index_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
// Implementation of get_field_by_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
// Implementation note: the results of field lookups are cached
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
// in the accessor klass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
ciField* ciEnv::get_field_by_index_impl(ciInstanceKlass* accessor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
                                        int index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
  ciConstantPoolCache* cache = accessor->field_cache();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  if (cache == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
    ciField* field = new (arena()) ciField(accessor, index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
    return field;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
    ciField* field = (ciField*)cache->get(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
    if (field == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
      field = new (arena()) ciField(accessor, index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
      cache->insert(index, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
    return field;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
// ciEnv::get_field_by_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
// Get a field by index from a klass's constant pool.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
ciField* ciEnv::get_field_by_index(ciInstanceKlass* accessor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
                                   int index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
  GUARDED_VM_ENTRY(return get_field_by_index_impl(accessor, index);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
// ciEnv::lookup_method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
// Perform an appropriate method lookup based on accessor, holder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
// name, signature, and bytecode.
43938
f0e4bcc4d9f3 8170455: C2: Access to [].clone from interfaces fails
jcm
parents: 43675
diff changeset
   708
Method* ciEnv::lookup_method(ciInstanceKlass* accessor,
f0e4bcc4d9f3 8170455: C2: Access to [].clone from interfaces fails
jcm
parents: 43675
diff changeset
   709
                             ciKlass*         holder,
f0e4bcc4d9f3 8170455: C2: Access to [].clone from interfaces fails
jcm
parents: 43675
diff changeset
   710
                             Symbol*          name,
f0e4bcc4d9f3 8170455: C2: Access to [].clone from interfaces fails
jcm
parents: 43675
diff changeset
   711
                             Symbol*          sig,
f0e4bcc4d9f3 8170455: C2: Access to [].clone from interfaces fails
jcm
parents: 43675
diff changeset
   712
                             Bytecodes::Code  bc,
f0e4bcc4d9f3 8170455: C2: Access to [].clone from interfaces fails
jcm
parents: 43675
diff changeset
   713
                             constantTag      tag) {
f0e4bcc4d9f3 8170455: C2: Access to [].clone from interfaces fails
jcm
parents: 43675
diff changeset
   714
  // Accessibility checks are performed in ciEnv::get_method_by_index_impl.
f0e4bcc4d9f3 8170455: C2: Access to [].clone from interfaces fails
jcm
parents: 43675
diff changeset
   715
  assert(check_klass_accessibility(accessor, holder->get_Klass()), "holder not accessible");
f0e4bcc4d9f3 8170455: C2: Access to [].clone from interfaces fails
jcm
parents: 43675
diff changeset
   716
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   717
  InstanceKlass* accessor_klass = accessor->get_instanceKlass();
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   718
  Klass* holder_klass = holder->get_Klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
  methodHandle dest_method;
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   720
  LinkInfo link_info(holder_klass, name, sig, accessor_klass, LinkInfo::needs_access_check, tag);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  switch (bc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  case Bytecodes::_invokestatic:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
    dest_method =
31019
d05fcdd70109 8029567: Clean up linkResolver code
coleenp
parents: 30764
diff changeset
   724
      LinkResolver::resolve_static_call_or_null(link_info);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
  case Bytecodes::_invokespecial:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
    dest_method =
31019
d05fcdd70109 8029567: Clean up linkResolver code
coleenp
parents: 30764
diff changeset
   728
      LinkResolver::resolve_special_call_or_null(link_info);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
  case Bytecodes::_invokeinterface:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
    dest_method =
31019
d05fcdd70109 8029567: Clean up linkResolver code
coleenp
parents: 30764
diff changeset
   732
      LinkResolver::linktime_resolve_interface_method_or_null(link_info);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
  case Bytecodes::_invokevirtual:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
    dest_method =
31019
d05fcdd70109 8029567: Clean up linkResolver code
coleenp
parents: 30764
diff changeset
   736
      LinkResolver::linktime_resolve_virtual_method_or_null(link_info);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  default: ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  return dest_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
// ciEnv::get_method_by_index_impl
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 31019
diff changeset
   747
ciMethod* ciEnv::get_method_by_index_impl(const constantPoolHandle& cpool,
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   748
                                          int index, Bytecodes::Code bc,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   749
                                          ciInstanceKlass* accessor) {
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   750
  if (bc == Bytecodes::_invokedynamic) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   751
    ConstantPoolCacheEntry* cpce = cpool->invokedynamic_cp_cache_entry_at(index);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   752
    bool is_resolved = !cpce->is_f1_null();
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   753
    // FIXME: code generation could allow for null (unlinked) call site
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   754
    // The call site could be made patchable as follows:
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   755
    // Load the appendix argument from the constant pool.
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   756
    // Test the appendix argument and jump to a known deopt routine if it is null.
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   757
    // Jump through a patchable call site, which is initially a deopt routine.
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   758
    // Patch the call site to the nmethod entry point of the static compiled lambda form.
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   759
    // As with other two-component call sites, both values must be independently verified.
10008
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   760
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   761
    if (is_resolved) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   762
      // Get the invoker Method* from the constant pool.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   763
      // (The appendix argument, if any, will be noted in the method's signature.)
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   764
      Method* adapter = cpce->f1_as_method();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   765
      return get_method(adapter);
10008
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
   766
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   768
    // Fake a method that is equivalent to a declared method.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   769
    ciInstanceKlass* holder    = get_instance_klass(SystemDictionary::MethodHandle_klass());
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10734
diff changeset
   770
    ciSymbol*        name      = ciSymbol::invokeBasic_name();
10734
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10564
diff changeset
   771
    ciSymbol*        signature = get_symbol(cpool->signature_ref_at(index));
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10564
diff changeset
   772
    return get_unloaded_method(holder, name, signature, accessor);
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   773
  } else {
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   774
    const int holder_index = cpool->klass_ref_index_at(index);
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   775
    bool holder_is_accessible;
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   776
    ciKlass* holder = get_klass_by_index_impl(cpool, holder_index, holder_is_accessible, accessor);
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   777
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   778
    // Get the method's name and signature.
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   779
    Symbol* name_sym = cpool->name_ref_at(index);
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   780
    Symbol* sig_sym  = cpool->signature_ref_at(index);
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   781
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   782
    if (cpool->has_preresolution()
36819
bca375d368ed 8149644: Integrate VarHandles
psandoz
parents: 35606
diff changeset
   783
        || ((holder == ciEnv::MethodHandle_klass() || holder == ciEnv::VarHandle_klass()) &&
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   784
            MethodHandles::is_signature_polymorphic_name(holder->get_Klass(), name_sym))) {
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   785
      // Short-circuit lookups for JSR 292-related call sites.
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   786
      // That is, do not rely only on name-based lookups, because they may fail
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   787
      // if the names are not resolvable in the boot class loader (7056328).
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   788
      switch (bc) {
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   789
      case Bytecodes::_invokevirtual:
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   790
      case Bytecodes::_invokeinterface:
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   791
      case Bytecodes::_invokespecial:
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   792
      case Bytecodes::_invokestatic:
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   793
        {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   794
          Method* m = ConstantPool::method_at_if_loaded(cpool, index);
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   795
          if (m != NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   796
            return get_method(m);
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   797
          }
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   798
        }
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   799
        break;
46630
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46560
diff changeset
   800
      default:
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46560
diff changeset
   801
        break;
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   802
      }
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   803
    }
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   804
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   805
    if (holder_is_accessible) {  // Our declared holder is loaded.
38719
133bf85c3f36 8145148: InterfaceMethod CP entry pointing to a class should cause ICCE
coleenp
parents: 38133
diff changeset
   806
      constantTag tag = cpool->tag_ref_at(index);
133bf85c3f36 8145148: InterfaceMethod CP entry pointing to a class should cause ICCE
coleenp
parents: 38133
diff changeset
   807
      assert(accessor->get_instanceKlass() == cpool->pool_holder(), "not the pool holder?");
43938
f0e4bcc4d9f3 8170455: C2: Access to [].clone from interfaces fails
jcm
parents: 43675
diff changeset
   808
      Method* m = lookup_method(accessor, holder, name_sym, sig_sym, bc, tag);
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   809
      if (m != NULL &&
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   810
          (bc == Bytecodes::_invokestatic
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 13974
diff changeset
   811
           ?  m->method_holder()->is_not_initialized()
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 13974
diff changeset
   812
           : !m->method_holder()->is_loaded())) {
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   813
        m = NULL;
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   814
      }
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
   815
#ifdef ASSERT
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
   816
      if (m != NULL && ReplayCompiles && !ciReplay::is_loaded(m)) {
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
   817
        m = NULL;
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
   818
      }
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
   819
#endif
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   820
      if (m != NULL) {
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   821
        // We found the method.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   822
        return get_method(m);
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   823
      }
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   824
    }
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   825
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   826
    // Either the declared holder was not loaded, or the method could
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   827
    // not be found.  Create a dummy ciMethod to represent the failed
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   828
    // lookup.
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   829
    ciSymbol* name      = get_symbol(name_sym);
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   830
    ciSymbol* signature = get_symbol(sig_sym);
43938
f0e4bcc4d9f3 8170455: C2: Access to [].clone from interfaces fails
jcm
parents: 43675
diff changeset
   831
    return get_unloaded_method(holder, name, signature, accessor);
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   832
  }
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   833
}
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   834
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   835
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   836
// ------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
// ciEnv::get_instance_klass_for_declared_method_holder
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
ciInstanceKlass* ciEnv::get_instance_klass_for_declared_method_holder(ciKlass* method_holder) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
  // For the case of <array>.clone(), the method holder can be a ciArrayKlass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  // instead of a ciInstanceKlass.  For that case simply pretend that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  // declared holder is Object.clone since that's where the call will bottom out.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  // A more correct fix would trickle out through many interfaces in CI,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  // requiring ciInstanceKlass* to become ciKlass* and many more places would
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
  // require checks to make sure the expected type was found.  Given that this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
  // only occurs for clone() the more extensive fix seems like overkill so
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
  // instead we simply smear the array type into Object.
16378
453b42d22a85 8009565: [partfait] Null pointer deference in hotspot/src/share/vm/ci/ciEnv.cpp
morris
parents: 15799
diff changeset
   847
  guarantee(method_holder != NULL, "no method holder");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  if (method_holder->is_instance_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
    return method_holder->as_instance_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  } else if (method_holder->is_array_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
    return current()->Object_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
// ciEnv::get_method_by_index
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 31019
diff changeset
   861
ciMethod* ciEnv::get_method_by_index(const constantPoolHandle& cpool,
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   862
                                     int index, Bytecodes::Code bc,
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   863
                                     ciInstanceKlass* accessor) {
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
   864
  GUARDED_VM_ENTRY(return get_method_by_index_impl(cpool, index, bc, accessor);)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 4450
diff changeset
   867
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
// ciEnv::name_buffer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
char *ciEnv::name_buffer(int req_len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  if (_name_buffer_len < req_len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
    if (_name_buffer == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
      _name_buffer = (char*)arena()->Amalloc(sizeof(char)*req_len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
      _name_buffer_len = req_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
      _name_buffer =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
        (char*)arena()->Arealloc(_name_buffer, _name_buffer_len, req_len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
      _name_buffer_len = req_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  return _name_buffer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
// ciEnv::is_in_vm
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
bool ciEnv::is_in_vm() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
  return JavaThread::current()->thread_state() == _thread_in_vm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
bool ciEnv::system_dictionary_modification_counter_changed() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
  return _system_dictionary_modification_counter != SystemDictionary::number_of_modifications();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
// ------------------------------------------------------------------
10503
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   895
// ciEnv::validate_compile_task_dependencies
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   896
//
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   897
// Check for changes during compilation (e.g. class loads, evolution,
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   898
// breakpoints, call site invalidation).
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   899
void ciEnv::validate_compile_task_dependencies(ciMethod* target) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
  if (failing())  return;  // no need for further checks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
10503
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   902
  // First, check non-klass dependencies as we might return early and
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   903
  // not check klass dependencies if the system dictionary
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   904
  // modification counter hasn't changed (see below).
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   905
  for (Dependencies::DepStream deps(dependencies()); deps.next(); ) {
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   906
    if (deps.is_klass_type())  continue;  // skip klass dependencies
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   907
    Klass* witness = deps.check_dependency();
10503
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   908
    if (witness != NULL) {
43675
a2b322083029 8173338: C2: continuous CallSite relinkage eventually disables compilation for a method
vlivanov
parents: 40664
diff changeset
   909
      if (deps.type() == Dependencies::call_site_target_value) {
a2b322083029 8173338: C2: continuous CallSite relinkage eventually disables compilation for a method
vlivanov
parents: 40664
diff changeset
   910
        _inc_decompile_count_on_failure = false;
a2b322083029 8173338: C2: continuous CallSite relinkage eventually disables compilation for a method
vlivanov
parents: 40664
diff changeset
   911
        record_failure("call site target change");
a2b322083029 8173338: C2: continuous CallSite relinkage eventually disables compilation for a method
vlivanov
parents: 40664
diff changeset
   912
      } else {
a2b322083029 8173338: C2: continuous CallSite relinkage eventually disables compilation for a method
vlivanov
parents: 40664
diff changeset
   913
        record_failure("invalid non-klass dependency");
a2b322083029 8173338: C2: continuous CallSite relinkage eventually disables compilation for a method
vlivanov
parents: 40664
diff changeset
   914
      }
10503
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   915
      return;
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   916
    }
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   917
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
10503
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   919
  // Klass dependencies must be checked when the system dictionary
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   920
  // changes.  If logging is enabled all violated dependences will be
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   921
  // recorded in the log.  In debug mode check dependencies even if
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   922
  // the system dictionary hasn't changed to verify that no invalid
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   923
  // dependencies were inserted.  Any violated dependences in this
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   924
  // case are dumped to the tty.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
  bool counter_changed = system_dictionary_modification_counter_changed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
10564
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   927
  bool verify_deps = trueInDebug;
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   928
  if (!counter_changed && !verify_deps)  return;
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   929
10503
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   930
  int klass_violations = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
  for (Dependencies::DepStream deps(dependencies()); deps.next(); ) {
10503
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   932
    if (!deps.is_klass_type())  continue;  // skip non-klass dependencies
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   933
    Klass* witness = deps.check_dependency();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
    if (witness != NULL) {
10503
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   935
      klass_violations++;
10564
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   936
      if (!counter_changed) {
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   937
        // Dependence failed but counter didn't change.  Log a message
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   938
        // describing what failed and allow the assert at the end to
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   939
        // trigger.
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   940
        deps.print_dependency(witness);
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   941
      } else if (xtty == NULL) {
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   942
        // If we're not logging then a single violation is sufficient,
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   943
        // otherwise we want to log all the dependences which were
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   944
        // violated.
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   945
        break;
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   946
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
10503
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
   950
  if (klass_violations != 0) {
10564
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   951
#ifdef ASSERT
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   952
    if (!counter_changed && !PrintCompilation) {
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   953
      // Print out the compile task that failed
26587
e8b28fa936af 8054889: Compiler team's implementation task
neliasso
parents: 25946
diff changeset
   954
      _task->print_tty();
10564
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   955
    }
db5bf5438c0a 7092236: java/util/EnumSet/EnumSetBash.java fails
never
parents: 10508
diff changeset
   956
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
    assert(counter_changed, "failed dependencies, but counter didn't change");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
    record_failure("concurrent class loading");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
// ciEnv::register_method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
void ciEnv::register_method(ciMethod* target,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
                            int entry_bci,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
                            CodeOffsets* offsets,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
                            int orig_pc_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
                            CodeBuffer* code_buffer,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
                            int frame_words,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
                            OopMapSet* oop_map_set,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
                            ExceptionHandlerTable* handler_table,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
                            ImplicitExceptionTable* inc_table,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
                            AbstractCompiler* compiler,
13883
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13728
diff changeset
   974
                            bool has_unsafe_access,
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22893
diff changeset
   975
                            bool has_wide_vectors,
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22893
diff changeset
   976
                            RTMState  rtm_state) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
  nmethod* nm = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
    // To prevent compile queue updates.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
    MutexLocker locker(MethodCompileQueue_lock, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
    // Prevent SystemDictionary::add_to_hierarchy from running
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
    // and invalidating our dependencies until we install this method.
21572
9cd0dd352fcd 8023037: Race between ciEnv::register_method and nmethod::make_not_entrant_or_zombie
vlivanov
parents: 21079
diff changeset
   985
    // No safepoints are allowed. Otherwise, class redefinition can occur in between.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
    MutexLocker ml(Compile_lock);
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 34238
diff changeset
   987
    NoSafepointVerifier nsv;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   989
    // Change in Jvmti state may invalidate compilation.
22893
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   990
    if (!failing() && jvmti_state_changed()) {
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   991
      record_failure("Jvmti state change invalidated dependencies");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   994
    // 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
   995
    if (!failing() &&
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
   996
        ( (!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
   997
          (!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
   998
          (!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
   999
      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
  1000
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
  1002
    if (!failing()) {
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
  1003
      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
  1004
        // 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
  1005
        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
  1006
      }
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
  1007
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
  1008
      // 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
  1009
      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
  1010
10503
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
  1011
      // Check for {class loads, evolution, breakpoints, ...} during compilation
04b74421bdea 7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents: 10008
diff changeset
  1012
      validate_compile_task_dependencies(target);
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 1623
diff changeset
  1013
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1015
    methodHandle method(THREAD, target->get_Method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22893
diff changeset
  1017
#if INCLUDE_RTM_OPT
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22893
diff changeset
  1018
    if (!failing() && (rtm_state != NoRTM) &&
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22893
diff changeset
  1019
        (method()->method_data() != NULL) &&
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22893
diff changeset
  1020
        (method()->method_data()->rtm_state() != rtm_state)) {
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22893
diff changeset
  1021
      // Preemptive decompile if rtm state was changed.
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22893
diff changeset
  1022
      record_failure("RTM state change invalidated rtm code");
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22893
diff changeset
  1023
    }
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22893
diff changeset
  1024
#endif
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22893
diff changeset
  1025
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
    if (failing()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
      // While not a true deoptimization, it is a preemptive decompile.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1028
      MethodData* mdo = method()->method_data();
43675
a2b322083029 8173338: C2: continuous CallSite relinkage eventually disables compilation for a method
vlivanov
parents: 40664
diff changeset
  1029
      if (mdo != NULL && _inc_decompile_count_on_failure) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
        mdo->inc_decompile_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
      // All buffers in the CodeBuffer are allocated in the CodeCache.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
      // If the code buffer is created on each compile attempt
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
      // as in C2, then it must be freed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
      code_buffer->free_blob();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
    assert(offsets->value(CodeOffsets::Deopt) != -1, "must have deopt entry");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
    assert(offsets->value(CodeOffsets::Exceptions) != -1, "must have exception entry");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
    nm =  nmethod::new_nmethod(method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
                               compile_id(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
                               entry_bci,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
                               offsets,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
                               orig_pc_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
                               debug_info(), dependencies(), code_buffer,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
                               frame_words, oop_map_set,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
                               handler_table, inc_table,
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 31019
diff changeset
  1051
                               compiler, task()->comp_level());
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 31019
diff changeset
  1052
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
    // Free codeBlobs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
    code_buffer->free_blob();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
21727
4a5fc611c9a7 8028306: nsk stress tests, CodeCache fills, then safepoint asserts
anoll
parents: 21572
diff changeset
  1056
    if (nm != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
      nm->set_has_unsafe_access(has_unsafe_access);
13883
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13728
diff changeset
  1058
      nm->set_has_wide_vectors(has_wide_vectors);
23496
bfdd90c07bf8 8038286: nm->set_rtm_state() should be called after (nm != NULL) check
kvn
parents: 23491
diff changeset
  1059
#if INCLUDE_RTM_OPT
bfdd90c07bf8 8038286: nm->set_rtm_state() should be called after (nm != NULL) check
kvn
parents: 23491
diff changeset
  1060
      nm->set_rtm_state(rtm_state);
bfdd90c07bf8 8038286: nm->set_rtm_state() should be called after (nm != NULL) check
kvn
parents: 23491
diff changeset
  1061
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
      // Record successful registration.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
      // (Put nm into the task handle *before* publishing to the Java heap.)
21727
4a5fc611c9a7 8028306: nsk stress tests, CodeCache fills, then safepoint asserts
anoll
parents: 21572
diff changeset
  1065
      if (task() != NULL) {
4a5fc611c9a7 8028306: nsk stress tests, CodeCache fills, then safepoint asserts
anoll
parents: 21572
diff changeset
  1066
        task()->set_code(nm);
4a5fc611c9a7 8028306: nsk stress tests, CodeCache fills, then safepoint asserts
anoll
parents: 21572
diff changeset
  1067
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
      if (entry_bci == InvocationEntryBci) {
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6064
diff changeset
  1070
        if (TieredCompilation) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6064
diff changeset
  1071
          // If there is an old version we're done with it
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 37267
diff changeset
  1072
          CompiledMethod* old = method->code();
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6064
diff changeset
  1073
          if (TraceMethodReplacement && old != NULL) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6064
diff changeset
  1074
            ResourceMark rm;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6064
diff changeset
  1075
            char *method_name = method->name_and_sig_as_C_string();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6064
diff changeset
  1076
            tty->print_cr("Replacing method %s", method_name);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6064
diff changeset
  1077
          }
21572
9cd0dd352fcd 8023037: Race between ciEnv::register_method and nmethod::make_not_entrant_or_zombie
vlivanov
parents: 21079
diff changeset
  1078
          if (old != NULL) {
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 37267
diff changeset
  1079
            old->make_not_used();
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6064
diff changeset
  1080
          }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
        }
21572
9cd0dd352fcd 8023037: Race between ciEnv::register_method and nmethod::make_not_entrant_or_zombie
vlivanov
parents: 21079
diff changeset
  1082
        if (TraceNMethodInstalls) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
          ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
          char *method_name = method->name_and_sig_as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
          ttyLocker ttyl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
          tty->print_cr("Installing method (%d) %s ",
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 31019
diff changeset
  1087
                        task()->comp_level(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
                        method_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
        // Allow the code to be executed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
        method->set_code(method, nm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
      } else {
21572
9cd0dd352fcd 8023037: Race between ciEnv::register_method and nmethod::make_not_entrant_or_zombie
vlivanov
parents: 21079
diff changeset
  1093
        if (TraceNMethodInstalls) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
          ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
          char *method_name = method->name_and_sig_as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
          ttyLocker ttyl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
          tty->print_cr("Installing osr method (%d) %s @ %d",
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 31019
diff changeset
  1098
                        task()->comp_level(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
                        method_name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
                        entry_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
        }
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 13974
diff changeset
  1102
        method->method_holder()->add_osr_nmethod(nm);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
    }
21727
4a5fc611c9a7 8028306: nsk stress tests, CodeCache fills, then safepoint asserts
anoll
parents: 21572
diff changeset
  1105
  }  // safepoints are allowed again
4a5fc611c9a7 8028306: nsk stress tests, CodeCache fills, then safepoint asserts
anoll
parents: 21572
diff changeset
  1106
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
  if (nm != NULL) {
21727
4a5fc611c9a7 8028306: nsk stress tests, CodeCache fills, then safepoint asserts
anoll
parents: 21572
diff changeset
  1108
    // JVMTI -- compiled method notification (must be done outside lock)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
    nm->post_compiled_method_load_event();
21727
4a5fc611c9a7 8028306: nsk stress tests, CodeCache fills, then safepoint asserts
anoll
parents: 21572
diff changeset
  1110
  } else {
27420
04e6f914cce1 8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents: 26944
diff changeset
  1111
    // The CodeCache is full.
21727
4a5fc611c9a7 8028306: nsk stress tests, CodeCache fills, then safepoint asserts
anoll
parents: 21572
diff changeset
  1112
    record_failure("code cache is full");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
// ciEnv::find_system_klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
ciKlass* ciEnv::find_system_klass(ciSymbol* klass_name) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
  VM_ENTRY_MARK;
10008
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 9328
diff changeset
  1121
  return get_klass_by_name_impl(NULL, constantPoolHandle(), klass_name, false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
// ciEnv::comp_level
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
int ciEnv::comp_level() {
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6064
diff changeset
  1127
  if (task() == NULL)  return CompLevel_highest_tier;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
  return task()->comp_level();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
// ciEnv::compile_id
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
uint ciEnv::compile_id() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
  if (task() == NULL)  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
  return task()->compile_id();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
// ciEnv::notice_inlined_method()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
void ciEnv::notice_inlined_method(ciMethod* method) {
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10734
diff changeset
  1141
  _num_inlined_bytecodes += method->code_size_for_inlining();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
// ciEnv::num_inlined_bytecodes()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
int ciEnv::num_inlined_bytecodes() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
  return _num_inlined_bytecodes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
// ciEnv::record_failure()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
void ciEnv::record_failure(const char* reason) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
  if (_failure_reason == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
    // Record the first failure reason.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
    _failure_reason = reason;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
27706
3f10f4ac2bd6 8065339: Failed compilation does not always trigger a JFR event 'CompilerFailure'
thartmann
parents: 27420
diff changeset
  1159
void ciEnv::report_failure(const char* reason) {
3f10f4ac2bd6 8065339: Failed compilation does not always trigger a JFR event 'CompilerFailure'
thartmann
parents: 27420
diff changeset
  1160
  // Create and fire JFR event
40664
1ec65b303bb7 8164523: Clean up metadata for event based tracing
egahlin
parents: 40057
diff changeset
  1161
  EventCompilationFailure event;
27706
3f10f4ac2bd6 8065339: Failed compilation does not always trigger a JFR event 'CompilerFailure'
thartmann
parents: 27420
diff changeset
  1162
  if (event.should_commit()) {
40664
1ec65b303bb7 8164523: Clean up metadata for event based tracing
egahlin
parents: 40057
diff changeset
  1163
    event.set_compileId(compile_id());
1ec65b303bb7 8164523: Clean up metadata for event based tracing
egahlin
parents: 40057
diff changeset
  1164
    event.set_failureMessage(reason);
27706
3f10f4ac2bd6 8065339: Failed compilation does not always trigger a JFR event 'CompilerFailure'
thartmann
parents: 27420
diff changeset
  1165
    event.commit();
3f10f4ac2bd6 8065339: Failed compilation does not always trigger a JFR event 'CompilerFailure'
thartmann
parents: 27420
diff changeset
  1166
  }
3f10f4ac2bd6 8065339: Failed compilation does not always trigger a JFR event 'CompilerFailure'
thartmann
parents: 27420
diff changeset
  1167
}
3f10f4ac2bd6 8065339: Failed compilation does not always trigger a JFR event 'CompilerFailure'
thartmann
parents: 27420
diff changeset
  1168
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
// ciEnv::record_method_not_compilable()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
void ciEnv::record_method_not_compilable(const char* reason, bool all_tiers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
  int new_compilable =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
    all_tiers ? MethodCompilable_never : MethodCompilable_not_at_tier ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
  // Only note transitions to a worse state
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
  if (new_compilable > _compilable) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
    if (log() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
      if (all_tiers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
        log()->elem("method_not_compilable");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
      } else {
13964
01a2b863cc61 7177003: C1: LogCompilation support
vlivanov
parents: 13883
diff changeset
  1181
        log()->elem("method_not_compilable_at_tier level='%d'",
01a2b863cc61 7177003: C1: LogCompilation support
vlivanov
parents: 13883
diff changeset
  1182
                    current()->task()->comp_level());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
    _compilable = new_compilable;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
    // Reset failure reason; this one is more important.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
    _failure_reason = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
    record_failure(reason);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
// ciEnv::record_out_of_memory_failure()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
void ciEnv::record_out_of_memory_failure() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
  // If memory is low, we stop compiling methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
  record_method_not_compilable("out of memory");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
}
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1199
19710
2f8ca425504e 7199175: JSR 292: C1 needs patching when invokedynamic/invokehandle call site is not linked
roland
parents: 17134
diff changeset
  1200
ciInstance* ciEnv::unloaded_ciinstance() {
2f8ca425504e 7199175: JSR 292: C1 needs patching when invokedynamic/invokehandle call site is not linked
roland
parents: 17134
diff changeset
  1201
  GUARDED_VM_ENTRY(return _factory->get_unloaded_object_constant();)
2f8ca425504e 7199175: JSR 292: C1 needs patching when invokedynamic/invokehandle call site is not linked
roland
parents: 17134
diff changeset
  1202
}
2f8ca425504e 7199175: JSR 292: C1 needs patching when invokedynamic/invokehandle call site is not linked
roland
parents: 17134
diff changeset
  1203
20692
65021f70c2fc 8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents: 19710
diff changeset
  1204
// ------------------------------------------------------------------
65021f70c2fc 8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents: 19710
diff changeset
  1205
// ciEnv::dump_replay_data*
65021f70c2fc 8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents: 19710
diff changeset
  1206
65021f70c2fc 8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents: 19710
diff changeset
  1207
// Don't change thread state and acquire any locks.
65021f70c2fc 8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents: 19710
diff changeset
  1208
// Safe to call from VM error reporter.
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1209
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1210
void ciEnv::dump_compile_data(outputStream* out) {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1211
  CompileTask* task = this->task();
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1212
  Method* method = task->method();
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1213
  int entry_bci = task->osr_bci();
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1214
  int comp_level = task->comp_level();
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1215
  out->print("compile %s %s %s %d %d",
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1216
                method->klass_name()->as_quoted_ascii(),
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1217
                method->name()->as_quoted_ascii(),
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1218
                method->signature()->as_quoted_ascii(),
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1219
                entry_bci, comp_level);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1220
  if (compiler_data() != NULL) {
47687
fb290fd1f9d4 8171853: Remove Shark compiler
rkennke
parents: 47216
diff changeset
  1221
    if (is_c2_compile(comp_level)) {
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1222
#ifdef COMPILER2
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1223
      // Dump C2 inlining data.
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1224
      ((Compile*)compiler_data())->dump_inline_data(out);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1225
#endif
47687
fb290fd1f9d4 8171853: Remove Shark compiler
rkennke
parents: 47216
diff changeset
  1226
    } else if (is_c1_compile(comp_level)) {
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1227
#ifdef COMPILER1
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1228
      // Dump C1 inlining data.
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1229
      ((Compilation*)compiler_data())->dump_inline_data(out);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1230
#endif
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1231
    }
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1232
  }
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1233
  out->cr();
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1234
}
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1235
20692
65021f70c2fc 8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents: 19710
diff changeset
  1236
void ciEnv::dump_replay_data_unsafe(outputStream* out) {
15471
41f75023e6a6 8006410: allocating without ResourceMark when CompileCommand was specified
vlivanov
parents: 14490
diff changeset
  1237
  ResourceMark rm;
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1238
#if INCLUDE_JVMTI
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1239
  out->print_cr("JvmtiExport can_access_local_variables %d",     _jvmti_can_access_local_variables);
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1240
  out->print_cr("JvmtiExport can_hotswap_or_post_breakpoint %d", _jvmti_can_hotswap_or_post_breakpoint);
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1241
  out->print_cr("JvmtiExport can_post_on_exceptions %d",         _jvmti_can_post_on_exceptions);
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1242
#endif // INCLUDE_JVMTI
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1243
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1244
  GrowableArray<ciMetadata*>* objects = _factory->get_ci_metadata();
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1245
  out->print_cr("# %d ciObject found", objects->length());
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1246
  for (int i = 0; i < objects->length(); i++) {
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1247
    objects->at(i)->dump_replay_data(out);
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1248
  }
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1249
  dump_compile_data(out);
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1250
  out->flush();
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1251
}
20692
65021f70c2fc 8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents: 19710
diff changeset
  1252
65021f70c2fc 8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents: 19710
diff changeset
  1253
void ciEnv::dump_replay_data(outputStream* out) {
65021f70c2fc 8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents: 19710
diff changeset
  1254
  GUARDED_VM_ENTRY(
65021f70c2fc 8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents: 19710
diff changeset
  1255
    MutexLocker ml(Compile_lock);
65021f70c2fc 8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents: 19710
diff changeset
  1256
    dump_replay_data_unsafe(out);
65021f70c2fc 8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents: 19710
diff changeset
  1257
  )
65021f70c2fc 8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents: 19710
diff changeset
  1258
}
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1259
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1260
void ciEnv::dump_replay_data(int compile_id) {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1261
  static char buffer[O_BUFLEN];
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1262
  int ret = jio_snprintf(buffer, O_BUFLEN, "replay_pid%p_compid%d.log", os::current_process_id(), compile_id);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1263
  if (ret > 0) {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1264
    int fd = open(buffer, O_RDWR | O_CREAT | O_TRUNC, 0666);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1265
    if (fd != -1) {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1266
      FILE* replay_data_file = os::open(fd, "w");
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1267
      if (replay_data_file != NULL) {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1268
        fileStream replay_data_stream(replay_data_file, /*need_close=*/true);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1269
        dump_replay_data(&replay_data_stream);
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24351
diff changeset
  1270
        tty->print_cr("# Compiler replay data is saved as: %s", buffer);
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1271
      } else {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1272
        tty->print_cr("# Can't open file to dump replay data.");
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1273
      }
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1274
    }
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1275
  }
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1276
}
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1277
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1278
void ciEnv::dump_inline_data(int compile_id) {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1279
  static char buffer[O_BUFLEN];
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1280
  int ret = jio_snprintf(buffer, O_BUFLEN, "inline_pid%p_compid%d.log", os::current_process_id(), compile_id);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1281
  if (ret > 0) {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1282
    int fd = open(buffer, O_RDWR | O_CREAT | O_TRUNC, 0666);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1283
    if (fd != -1) {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1284
      FILE* inline_data_file = os::open(fd, "w");
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1285
      if (inline_data_file != NULL) {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1286
        fileStream replay_data_stream(inline_data_file, /*need_close=*/true);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1287
        GUARDED_VM_ENTRY(
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1288
          MutexLocker ml(Compile_lock);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1289
          dump_compile_data(&replay_data_stream);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1290
        )
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1291
        replay_data_stream.flush();
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1292
        tty->print("# Compiler inline data is saved as: ");
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24351
diff changeset
  1293
        tty->print_cr("%s", buffer);
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1294
      } else {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1295
        tty->print_cr("# Can't open file to dump inline data.");
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1296
      }
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1297
    }
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1298
  }
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21727
diff changeset
  1299
}