hotspot/src/share/vm/interpreter/linkResolver.cpp
author jrose
Thu, 17 Mar 2011 18:29:18 -0700
changeset 8678 1a47de5ffbd1
parent 8676 9098d4e927e1
child 8883 5569135acca3
permissions -rw-r--r--
7011865: JSR 292 CTW fails: !THREAD->is_Compiler_thread() failed: Can not load classes with the Compiler thre Reviewed-by: kvn, never
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8675
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8076
diff changeset
     2
 * Copyright (c) 1997, 2011, 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: 5421
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5421
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: 5421
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 "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    27
#include "classfile/vmSymbols.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    28
#include "compiler/compileBroker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    29
#include "gc_interface/collectedHeap.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    30
#include "interpreter/bytecode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    31
#include "interpreter/interpreterRuntime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    32
#include "interpreter/linkResolver.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    33
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    34
#include "memory/universe.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    35
#include "oops/instanceKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    36
#include "oops/objArrayOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    37
#include "prims/methodHandles.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    38
#include "prims/nativeLookup.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    39
#include "runtime/compilationPolicy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    40
#include "runtime/fieldDescriptor.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    41
#include "runtime/frame.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    42
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    43
#include "runtime/reflection.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    44
#include "runtime/signature.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    45
#include "runtime/vmThread.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    46
#ifdef TARGET_OS_FAMILY_linux
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    47
# include "thread_linux.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    48
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    49
#ifdef TARGET_OS_FAMILY_solaris
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    50
# include "thread_solaris.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    51
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    52
#ifdef TARGET_OS_FAMILY_windows
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    53
# include "thread_windows.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    54
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
// Implementation of FieldAccessInfo
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    59
void FieldAccessInfo::set(KlassHandle klass, Symbol* name, int field_index, int field_offset,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
BasicType field_type, AccessFlags access_flags) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  _klass        = klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  _name         = name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  _field_index  = field_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  _field_offset = field_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  _field_type   = field_type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  _access_flags = access_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
// Implementation of CallInfo
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
void CallInfo::set_static(KlassHandle resolved_klass, methodHandle resolved_method, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  int vtable_index = methodOopDesc::nonvirtual_vtable_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, vtable_index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
void CallInfo::set_interface(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  // This is only called for interface methods. If the resolved_method
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  // comes from java/lang/Object, it can be the subject of a virtual call, so
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  // we should pick the vtable index from the resolved method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  // Other than that case, there is no valid vtable index to specify.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  int vtable_index = methodOopDesc::invalid_vtable_index;
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4564
diff changeset
    86
  if (resolved_method->method_holder() == SystemDictionary::Object_klass()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
    assert(resolved_method->vtable_index() == selected_method->vtable_index(), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
    vtable_index = resolved_method->vtable_index();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  set_common(resolved_klass, selected_klass, resolved_method, selected_method, vtable_index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
void CallInfo::set_virtual(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int vtable_index, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  assert(vtable_index >= 0 || vtable_index == methodOopDesc::nonvirtual_vtable_index, "valid index");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  set_common(resolved_klass, selected_klass, resolved_method, selected_method, vtable_index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
    98
void CallInfo::set_dynamic(methodHandle resolved_method, TRAPS) {
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
    99
  assert(resolved_method->is_method_handle_invoke(), "");
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   100
  KlassHandle resolved_klass = SystemDictionaryHandles::MethodHandle_klass();
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   101
  assert(resolved_klass == resolved_method->method_holder(), "");
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   102
  int vtable_index = methodOopDesc::nonvirtual_vtable_index;
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   103
  assert(resolved_method->vtable_index() == vtable_index, "");
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   104
  set_common(resolved_klass, KlassHandle(), resolved_method, resolved_method, vtable_index, CHECK);
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   105
}
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   106
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
void CallInfo::set_common(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int vtable_index, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  assert(resolved_method->signature() == selected_method->signature(), "signatures must correspond");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  _resolved_klass  = resolved_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  _selected_klass  = selected_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  _resolved_method = resolved_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  _selected_method = selected_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  _vtable_index    = vtable_index;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6062
diff changeset
   114
  if (CompilationPolicy::must_be_compiled(selected_method)) {
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   115
    // This path is unusual, mostly used by the '-Xcomp' stress test mode.
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   116
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6062
diff changeset
   117
    // Note: with several active threads, the must_be_compiled may be true
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6062
diff changeset
   118
    //       while can_be_compiled is false; remove assert
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6062
diff changeset
   119
    // assert(CompilationPolicy::can_be_compiled(selected_method), "cannot compile");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
    if (THREAD->is_Compiler_thread()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
      // don't force compilation, resolve was on behalf of compiler
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
    }
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   124
    if (instanceKlass::cast(selected_method->method_holder())->is_not_initialized()) {
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   125
      // 'is_not_initialized' means not only '!is_initialized', but also that
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   126
      // initialization has not been started yet ('!being_initialized')
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   127
      // Do not force compilation of methods in uninitialized classes.
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   128
      // Note that doing this would throw an assert later,
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   129
      // in CompileBroker::compile_method.
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   130
      // We sometimes use the link resolver to do reflective lookups
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   131
      // even before classes are initialized.
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   132
      return;
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   133
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
    CompileBroker::compile_method(selected_method, InvocationEntryBci,
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6062
diff changeset
   135
                                  CompLevel_initial_compile,
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6062
diff changeset
   136
                                  methodHandle(), 0, "must_be_compiled", CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
// Klass resolution
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
void LinkResolver::check_klass_accessability(KlassHandle ref_klass, KlassHandle sel_klass, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  if (!Reflection::verify_class_access(ref_klass->as_klassOop(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
                                       sel_klass->as_klassOop(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
                                       true)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
    Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
      THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   151
      vmSymbols::java_lang_IllegalAccessError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
      "tried to access class %s from class %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
      sel_klass->external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
      ref_klass->external_name()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
void LinkResolver::resolve_klass(KlassHandle& result, constantPoolHandle pool, int index, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  klassOop result_oop = pool->klass_ref_at(index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  result = KlassHandle(THREAD, result_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
void LinkResolver::resolve_klass_no_update(KlassHandle& result, constantPoolHandle pool, int index, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  klassOop result_oop =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
         constantPoolOopDesc::klass_ref_at_if_loaded_check(pool, index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  result = KlassHandle(THREAD, result_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
// Method resolution
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
// According to JVM spec. $5.4.3c & $5.4.3d
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   177
void LinkResolver::lookup_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   178
  methodOop result_oop = klass->uncached_lookup_method(name, signature);
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 4571
diff changeset
   179
  if (EnableMethodHandles && result_oop != NULL) {
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 4571
diff changeset
   180
    switch (result_oop->intrinsic_id()) {
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 4571
diff changeset
   181
    case vmIntrinsics::_invokeExact:
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 4571
diff changeset
   182
    case vmIntrinsics::_invokeGeneric:
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 4571
diff changeset
   183
    case vmIntrinsics::_invokeDynamic:
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 4571
diff changeset
   184
      // Do not link directly to these.  The VM must produce a synthetic one using lookup_implicit_method.
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 4571
diff changeset
   185
      return;
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 4571
diff changeset
   186
    }
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 4571
diff changeset
   187
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  result = methodHandle(THREAD, result_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
// returns first instance method
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   192
void LinkResolver::lookup_instance_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   193
  methodOop result_oop = klass->uncached_lookup_method(name, signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  result = methodHandle(THREAD, result_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  while (!result.is_null() && result->is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
    klass = KlassHandle(THREAD, Klass::cast(result->method_holder())->super());
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   197
    result = methodHandle(THREAD, klass->uncached_lookup_method(name, signature));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   202
int LinkResolver::vtable_index_of_miranda_method(KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  klassVtable *vt = instanceKlass::cast(klass())->vtable();
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   205
  return vt->index_of_miranda(name, signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   208
void LinkResolver::lookup_method_in_interfaces(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  instanceKlass *ik = instanceKlass::cast(klass());
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   210
  result = methodHandle(THREAD, ik->lookup_method_in_all_interfaces(name, signature));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
5421
e294db54fc0d 6939196: method handle signatures off the boot class path get linkage errors
jrose
parents: 5420
diff changeset
   213
void LinkResolver::lookup_implicit_method(methodHandle& result,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   214
                                          KlassHandle klass, Symbol* name, Symbol* signature,
5421
e294db54fc0d 6939196: method handle signatures off the boot class path get linkage errors
jrose
parents: 5420
diff changeset
   215
                                          KlassHandle current_klass,
e294db54fc0d 6939196: method handle signatures off the boot class path get linkage errors
jrose
parents: 5420
diff changeset
   216
                                          TRAPS) {
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   217
  if (EnableMethodHandles &&
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 4571
diff changeset
   218
      klass() == SystemDictionary::MethodHandle_klass() &&
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   219
      methodOopDesc::is_method_handle_invoke_name(name)) {
8678
1a47de5ffbd1 7011865: JSR 292 CTW fails: !THREAD->is_Compiler_thread() failed: Can not load classes with the Compiler thre
jrose
parents: 8676
diff changeset
   220
    if (!THREAD->is_Compiler_thread() && !MethodHandles::enabled()) {
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   221
      // Make sure the Java part of the runtime has been booted up.
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   222
      klassOop natives = SystemDictionary::MethodHandleNatives_klass();
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   223
      if (natives == NULL || instanceKlass::cast(natives)->is_not_initialized()) {
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   224
        Symbol* natives_name = vmSymbols::java_lang_invoke_MethodHandleNatives();
8675
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8076
diff changeset
   225
        if (natives != NULL && AllowTransitionalJSR292)  natives_name = Klass::cast(natives)->name();
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8076
diff changeset
   226
        SystemDictionary::resolve_or_fail(natives_name,
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   227
                                          Handle(),
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   228
                                          Handle(),
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   229
                                          true,
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   230
                                          CHECK);
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   231
      }
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
   232
    }
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 4571
diff changeset
   233
    methodOop result_oop = SystemDictionary::find_method_handle_invoke(name,
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 4571
diff changeset
   234
                                                                       signature,
5421
e294db54fc0d 6939196: method handle signatures off the boot class path get linkage errors
jrose
parents: 5420
diff changeset
   235
                                                                       current_klass,
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1
diff changeset
   236
                                                                       CHECK);
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1
diff changeset
   237
    if (result_oop != NULL) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   238
      assert(result_oop->is_method_handle_invoke() && result_oop->signature() == signature, "consistent");
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1
diff changeset
   239
      result = methodHandle(THREAD, result_oop);
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1
diff changeset
   240
    }
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1
diff changeset
   241
  }
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1
diff changeset
   242
}
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1
diff changeset
   243
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
void LinkResolver::check_method_accessability(KlassHandle ref_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
                                              KlassHandle resolved_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
                                              KlassHandle sel_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
                                              methodHandle sel_method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
                                              TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  AccessFlags flags = sel_method->access_flags();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  // Special case:  arrays always override "clone". JVMS 2.15.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  // If the resolved klass is an array class, and the declaring class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  // is java.lang.Object and the method is "clone", set the flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  // to public.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  // We'll check for the method name first, as that's most likely
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  // to be false (so we'll short-circuit out of these tests).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  if (sel_method->name() == vmSymbols::clone_name() &&
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4564
diff changeset
   260
      sel_klass() == SystemDictionary::Object_klass() &&
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
      resolved_klass->oop_is_array()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
    // We need to change "protected" to "public".
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
    assert(flags.is_protected(), "clone not protected?");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
    jint new_flags = flags.as_int();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
    new_flags = new_flags & (~JVM_ACC_PROTECTED);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
    new_flags = new_flags | JVM_ACC_PUBLIC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
    flags.set_flags(new_flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  if (!Reflection::verify_field_access(ref_klass->as_klassOop(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
                                       resolved_klass->as_klassOop(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
                                       sel_klass->as_klassOop(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
                                       flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
                                       true)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
    Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
      THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   278
      vmSymbols::java_lang_IllegalAccessError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
      "tried to access method %s.%s%s from class %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
      sel_klass->external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
      sel_method->name()->as_C_string(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
      sel_method->signature()->as_C_string(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
      ref_klass->external_name()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle& resolved_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
                                  constantPoolHandle pool, int index, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  // resolve klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  resolve_klass(resolved_klass, pool, index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   295
  Symbol*  method_name       = pool->name_ref_at(index);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   296
  Symbol*  method_signature  = pool->signature_ref_at(index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  KlassHandle  current_klass(THREAD, pool->pool_holder());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   302
void LinkResolver::resolve_dynamic_method(methodHandle& resolved_method, KlassHandle& resolved_klass, constantPoolHandle pool, int index, TRAPS) {
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   303
  // The class is java.lang.invoke.MethodHandle
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   304
  resolved_klass = SystemDictionaryHandles::MethodHandle_klass();
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   305
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   306
  Symbol* method_name = vmSymbols::invokeExact_name();
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   307
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   308
  Symbol*  method_signature = pool->signature_ref_at(index);
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   309
  KlassHandle  current_klass   (THREAD, pool->pool_holder());
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   310
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   311
  resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK);
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   312
}
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 4429
diff changeset
   313
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
void LinkResolver::resolve_interface_method(methodHandle& resolved_method, KlassHandle& resolved_klass, constantPoolHandle pool, int index, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  // resolve klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  resolve_klass(resolved_klass, pool, index, CHECK);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   318
  Symbol*  method_name       = pool->name_ref_at(index);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   319
  Symbol*  method_signature  = pool->signature_ref_at(index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  KlassHandle  current_klass(THREAD, pool->pool_holder());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   327
                                  Symbol* method_name, Symbol* method_signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
                                  KlassHandle current_klass, bool check_access, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  // 1. check if klass is not interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  if (resolved_klass->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
    char buf[200];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
    jio_snprintf(buf, sizeof(buf), "Found interface %s, but class was expected", Klass::cast(resolved_klass())->external_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
    THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  // 2. lookup method in resolved klass and its super klasses
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  lookup_method_in_klasses(resolved_method, resolved_klass, method_name, method_signature, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  if (resolved_method.is_null()) { // not found in the class hierarchy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
    // 3. lookup method in all the interfaces implemented by the resolved klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
    lookup_method_in_interfaces(resolved_method, resolved_klass, method_name, method_signature, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
    if (resolved_method.is_null()) {
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1
diff changeset
   345
      // JSR 292:  see if this is an implicitly generated method MethodHandle.invoke(*...)
5421
e294db54fc0d 6939196: method handle signatures off the boot class path get linkage errors
jrose
parents: 5420
diff changeset
   346
      lookup_implicit_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, CHECK);
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1
diff changeset
   347
    }
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1
diff changeset
   348
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1
diff changeset
   349
    if (resolved_method.is_null()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
      // 4. method lookup failed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
      ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
      THROW_MSG(vmSymbols::java_lang_NoSuchMethodError(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
                methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   354
                                                        method_name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   355
                                                        method_signature));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  // 5. check if method is concrete
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  if (resolved_method->is_abstract() && !resolved_klass->is_abstract()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
    THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
              methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   364
                                                      method_name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   365
                                                      method_signature));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  // 6. access checks, access checking may be turned off when calling from within the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  if (check_access) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
    assert(current_klass.not_null() , "current_klass should not be null");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
    // check if method can be accessed by the referring class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
    check_method_accessability(current_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
                               resolved_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
                               KlassHandle(THREAD, resolved_method->method_holder()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
                               resolved_method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
                               CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    // check loader constraints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
    Handle loader (THREAD, instanceKlass::cast(current_klass())->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
    Handle class_loader (THREAD, instanceKlass::cast(resolved_method->method_holder())->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
      ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
      char* failed_type_name =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
        SystemDictionary::check_signature_loaders(method_signature, loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
                                                  class_loader, true, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
      if (failed_type_name != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
        const char* msg = "loader constraint violation: when resolving method"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
          " \"%s\" the class loader (instance of %s) of the current class, %s,"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
          " and the class loader (instance of %s) for resolved class, %s, have"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
          " different Class objects for the type %s used in the signature";
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   392
        char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
        const char* loader1 = SystemDictionary::loader_name(loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
        char* current = instanceKlass::cast(current_klass())->name()->as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
        const char* loader2 = SystemDictionary::loader_name(class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
        char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
        size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) +
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
          strlen(current) + strlen(loader2) + strlen(resolved) +
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
          strlen(failed_type_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
        char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
        jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
                     resolved, failed_type_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
        THROW_MSG(vmSymbols::java_lang_LinkageError(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
void LinkResolver::resolve_interface_method(methodHandle& resolved_method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
                                            KlassHandle resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   411
                                            Symbol* method_name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   412
                                            Symbol* method_signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
                                            KlassHandle current_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
                                            bool check_access, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
 // check if klass is interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  if (!resolved_klass->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
    char buf[200];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
    jio_snprintf(buf, sizeof(buf), "Found class %s, but interface was expected", Klass::cast(resolved_klass())->external_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
    THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  // lookup method in this interface or its super, java.lang.Object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  lookup_instance_method_in_klasses(resolved_method, resolved_klass, method_name, method_signature, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  if (resolved_method.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
    // lookup method in all the super-interfaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
    lookup_method_in_interfaces(resolved_method, resolved_klass, method_name, method_signature, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
    if (resolved_method.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
      // no method found
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
      ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
      THROW_MSG(vmSymbols::java_lang_NoSuchMethodError(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
                methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   434
                                                        method_name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   435
                                                        method_signature));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  if (check_access) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
    HandleMark hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
    Handle loader (THREAD, instanceKlass::cast(current_klass())->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
    Handle class_loader (THREAD, instanceKlass::cast(resolved_method->method_holder())->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
      ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
      char* failed_type_name =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
        SystemDictionary::check_signature_loaders(method_signature, loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
                                                  class_loader, true, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
      if (failed_type_name != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
        const char* msg = "loader constraint violation: when resolving "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
          "interface method \"%s\" the class loader (instance of %s) of the "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
          "current class, %s, and the class loader (instance of %s) for "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
          "resolved class, %s, have different Class objects for the type %s "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
          "used in the signature";
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   454
        char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
        const char* loader1 = SystemDictionary::loader_name(loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
        char* current = instanceKlass::cast(current_klass())->name()->as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
        const char* loader2 = SystemDictionary::loader_name(class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
        char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
        size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) +
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
          strlen(current) + strlen(loader2) + strlen(resolved) +
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
          strlen(failed_type_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
        char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
        jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
                     resolved, failed_type_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
        THROW_MSG(vmSymbols::java_lang_LinkageError(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
// Field resolution
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
void LinkResolver::check_field_accessability(KlassHandle ref_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
                                             KlassHandle resolved_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
                                             KlassHandle sel_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
                                             fieldDescriptor& fd,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
                                             TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  if (!Reflection::verify_field_access(ref_klass->as_klassOop(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
                                       resolved_klass->as_klassOop(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
                                       sel_klass->as_klassOop(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
                                       fd.access_flags(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
                                       true)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
    Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
      THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   487
      vmSymbols::java_lang_IllegalAccessError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
      "tried to access field %s.%s from class %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
      sel_klass->external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
      fd.name()->as_C_string(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
      ref_klass->external_name()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
    return;
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
void LinkResolver::resolve_field(FieldAccessInfo& result, constantPoolHandle pool, int index, Bytecodes::Code byte, bool check_only, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  resolve_field(result, pool, index, byte, check_only, true, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
void LinkResolver::resolve_field(FieldAccessInfo& result, constantPoolHandle pool, int index, Bytecodes::Code byte, bool check_only, bool update_pool, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  assert(byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
         byte == Bytecodes::_getfield  || byte == Bytecodes::_putfield, "bad bytecode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  bool is_static = (byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  bool is_put    = (byte == Bytecodes::_putfield  || byte == Bytecodes::_putstatic);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  // resolve specified klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  KlassHandle resolved_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  if (update_pool) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
    resolve_klass(resolved_klass, pool, index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
    resolve_klass_no_update(resolved_klass, pool, index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  // Load these early in case the resolve of the containing klass fails
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   516
  Symbol* field = pool->name_ref_at(index);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   517
  Symbol* sig   = pool->signature_ref_at(index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  // Check if there's a resolved klass containing the field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  if( resolved_klass.is_null() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
    THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  // Resolve instance field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  fieldDescriptor fd; // find_field initializes fd if found
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  KlassHandle sel_klass(THREAD, instanceKlass::cast(resolved_klass())->find_field(field, sig, &fd));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  // check if field exists; i.e., if a klass containing the field def has been selected
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  if (sel_klass.is_null()){
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
    THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  // check access
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  KlassHandle ref_klass(THREAD, pool->pool_holder());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  check_field_accessability(ref_klass, resolved_klass, sel_klass, fd, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  // check for errors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  if (is_static != fd.is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
    char msg[200];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
    jio_snprintf(msg, sizeof(msg), "Expected %s field %s.%s", is_static ? "static" : "non-static", Klass::cast(resolved_klass())->external_name(), fd.name()->as_C_string());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
    THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), msg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  // Final fields can only be accessed from its own class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  if (is_put && fd.access_flags().is_final() && sel_klass() != pool->pool_holder()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
    THROW(vmSymbols::java_lang_IllegalAccessError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  // initialize resolved_klass if necessary
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  // note 1: the klass which declared the field must be initialized (i.e, sel_klass)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  //         according to the newest JVM spec (5.5, p.170) - was bug (gri 7/28/99)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  // note 2: we don't want to force initialization if we are just checking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  //         if the field access is legal; e.g., during compilation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  if (is_static && !check_only) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
    sel_klass->initialize(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
    HandleMark hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
    Handle ref_loader (THREAD, instanceKlass::cast(ref_klass())->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
    Handle sel_loader (THREAD, instanceKlass::cast(sel_klass())->class_loader());
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   563
    Symbol*  signature_ref  = pool->signature_ref_at(index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
      ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
      char* failed_type_name =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
        SystemDictionary::check_signature_loaders(signature_ref,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
                                                  ref_loader, sel_loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
                                                  false,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
                                                  CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
      if (failed_type_name != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
        const char* msg = "loader constraint violation: when resolving field"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
          " \"%s\" the class loader (instance of %s) of the referring class, "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
          "%s, and the class loader (instance of %s) for the field's resolved "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
          "type, %s, have different Class objects for that type";
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   576
        char* field_name = field->as_C_string();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
        const char* loader1 = SystemDictionary::loader_name(ref_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
        char* sel = instanceKlass::cast(sel_klass())->name()->as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
        const char* loader2 = SystemDictionary::loader_name(sel_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
        size_t buflen = strlen(msg) + strlen(field_name) + strlen(loader1) +
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
          strlen(sel) + strlen(loader2) + strlen(failed_type_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
        char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
        jio_snprintf(buf, buflen, msg, field_name, loader1, sel, loader2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
                     failed_type_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
        THROW_MSG(vmSymbols::java_lang_LinkageError(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  // return information. note that the klass is set to the actual klass containing the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  // field, otherwise access of static fields in superclasses will not work.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  KlassHandle holder (THREAD, fd.field_holder());
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   593
  Symbol*  name   = fd.name();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
  result.set(holder, name, fd.index(), fd.offset(), fd.field_type(), fd.access_flags());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
// Invoke resolution
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
// Naming conventions:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
// resolved_method    the specified method (i.e., static receiver specified via constant pool index)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
// sel_method         the selected method  (selected via run-time lookup; e.g., based on dynamic receiver class)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
// resolved_klass     the specified klass  (i.e., specified via constant pool index)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
// recv_klass         the receiver klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   609
void LinkResolver::resolve_static_call(CallInfo& result, KlassHandle& resolved_klass, Symbol* method_name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   610
                                       Symbol* method_signature, KlassHandle current_klass,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
                                       bool check_access, bool initialize_class, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  methodHandle resolved_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  linktime_resolve_static_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  resolved_klass = KlassHandle(THREAD, Klass::cast(resolved_method->method_holder()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  // Initialize klass (this should only happen if everything is ok)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  if (initialize_class && resolved_klass->should_be_initialized()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
    resolved_klass->initialize(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
    linktime_resolve_static_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
  // setup result
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
  result.set_static(resolved_klass, resolved_method, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
// throws linktime exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
void LinkResolver::linktime_resolve_static_method(methodHandle& resolved_method, KlassHandle resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   628
                                                  Symbol* method_name, Symbol* method_signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
                                                  KlassHandle current_klass, bool check_access, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  assert(resolved_method->name() != vmSymbols::class_initializer_name(), "should have been checked in verifier");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
  // check if static
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  if (!resolved_method->is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
    char buf[200];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
    jio_snprintf(buf, sizeof(buf), "Expected static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
                                                      resolved_method->name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
                                                      resolved_method->signature()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
    THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   645
void LinkResolver::resolve_special_call(CallInfo& result, KlassHandle resolved_klass, Symbol* method_name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   646
                                        Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  methodHandle resolved_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  linktime_resolve_special_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  runtime_resolve_special_method(result, resolved_method, resolved_klass, current_klass, check_access, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
// throws linktime exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
void LinkResolver::linktime_resolve_special_method(methodHandle& resolved_method, KlassHandle resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   654
                                                   Symbol* method_name, Symbol* method_signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
                                                   KlassHandle current_klass, bool check_access, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  // check if method name is <init>, that it is found in same klass as static type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  if (resolved_method->name() == vmSymbols::object_initializer_name() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
      resolved_method->method_holder() != resolved_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
    Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
      THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   665
      vmSymbols::java_lang_NoSuchMethodError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
      "%s: method %s%s not found",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
      resolved_klass->external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
      resolved_method->name()->as_C_string(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
      resolved_method->signature()->as_C_string()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
  // check if not static
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
  if (resolved_method->is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
    char buf[200];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
    jio_snprintf(buf, sizeof(buf),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
                 "Expecting non-static method %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
                 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
                                                         resolved_method->name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
                                                         resolved_method->signature()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
    THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
// throws runtime exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
void LinkResolver::runtime_resolve_special_method(CallInfo& result, methodHandle resolved_method, KlassHandle resolved_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
                                                  KlassHandle current_klass, bool check_access, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  // resolved method is selected method unless we have an old-style lookup
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
  methodHandle sel_method(THREAD, resolved_method());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
  // check if this is an old-style super call and do a new lookup if so
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  { KlassHandle method_klass  = KlassHandle(THREAD,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
                                            resolved_method->method_holder());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
    if (check_access &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
        // a) check if ACC_SUPER flag is set for the current class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
        current_klass->is_super() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
        // b) check if the method class is a superclass of the current class (superclass relation is not reflexive!)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
        current_klass->is_subtype_of(method_klass()) && current_klass() != method_klass() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
        // c) check if the method is not <init>
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
        resolved_method->name() != vmSymbols::object_initializer_name()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
      // Lookup super method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
      KlassHandle super_klass(THREAD, current_klass->super());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
      lookup_instance_method_in_klasses(sel_method, super_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   707
                           resolved_method->name(),
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   708
                           resolved_method->signature(), CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
      // check if found
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
      if (sel_method.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
        ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
        THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
                  methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
                                            resolved_method->name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
                                            resolved_method->signature()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  // check if not static
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  if (sel_method->is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
    char buf[200];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
    jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
                                                                                                             resolved_method->name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
                                                                                                             resolved_method->signature()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
    THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  // check if abstract
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
  if (sel_method->is_abstract()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
    THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
              methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
                                                      sel_method->name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
                                                      sel_method->signature()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  // setup result
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  result.set_static(resolved_klass, sel_method, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
void LinkResolver::resolve_virtual_call(CallInfo& result, Handle recv, KlassHandle receiver_klass, KlassHandle resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   743
                                        Symbol* method_name, Symbol* method_signature, KlassHandle current_klass,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
                                        bool check_access, bool check_null_and_abstract, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  methodHandle resolved_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  linktime_resolve_virtual_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
  runtime_resolve_virtual_method(result, resolved_method, resolved_klass, recv, receiver_klass, check_null_and_abstract, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
// throws linktime exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
void LinkResolver::linktime_resolve_virtual_method(methodHandle &resolved_method, KlassHandle resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   752
                                                   Symbol* method_name, Symbol* method_signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
                                                   KlassHandle current_klass, bool check_access, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  // normal method resolution
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
  resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
  assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
  // check if not static
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
  if (resolved_method->is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
    char buf[200];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
    jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
                                                                                                             resolved_method->name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
                                                                                                             resolved_method->signature()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
    THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
// throws runtime exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
void LinkResolver::runtime_resolve_virtual_method(CallInfo& result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
                                                  methodHandle resolved_method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
                                                  KlassHandle resolved_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
                                                  Handle recv,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
                                                  KlassHandle recv_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
                                                  bool check_null_and_abstract,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
                                                  TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  // setup default return values
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
  int vtable_index = methodOopDesc::invalid_vtable_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  methodHandle selected_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  assert(recv.is_null() || recv->is_oop(), "receiver is not an oop");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  // runtime method resolution
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
  if (check_null_and_abstract && recv.is_null()) { // check if receiver exists
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
    THROW(vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  // Virtual methods cannot be resolved before its klass has been linked, for otherwise the methodOop's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
  // has not been rewritten, and the vtable initialized.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
  assert(instanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
  // Virtual methods cannot be resolved before its klass has been linked, for otherwise the methodOop's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  // has not been rewritten, and the vtable initialized. Make sure to do this after the nullcheck, since
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
  // a missing receiver might result in a bogus lookup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
  assert(instanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
  // do lookup based on receiver klass using the vtable index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
  if (resolved_method->method_holder()->klass_part()->is_interface()) { // miranda method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
    vtable_index = vtable_index_of_miranda_method(resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   802
                           resolved_method->name(),
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   803
                           resolved_method->signature(), CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
    assert(vtable_index >= 0 , "we should have valid vtable index at this point");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
    instanceKlass* inst = instanceKlass::cast(recv_klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
    selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
    // at this point we are sure that resolved_method is virtual and not
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
    // a miranda method; therefore, it must have a valid vtable index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
    vtable_index = resolved_method->vtable_index();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
    // We could get a negative vtable_index for final methods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
    // because as an optimization they are they are never put in the vtable,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
    // unless they override an existing method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
    // If we do get a negative, it means the resolved method is the the selected
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
    // method, and it can never be changed by an override.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
    if (vtable_index == methodOopDesc::nonvirtual_vtable_index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
      assert(resolved_method->can_be_statically_bound(), "cannot override this method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
      selected_method = resolved_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
      // recv_klass might be an arrayKlassOop but all vtables start at
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
      // the same place. The cast is to avoid virtual call and assertion.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
      instanceKlass* inst = (instanceKlass*)recv_klass()->klass_part();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
      selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  // check if method exists
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  if (selected_method.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
    THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
              methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
                                                      resolved_method->name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
                                                      resolved_method->signature()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  // check if abstract
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
  if (check_null_and_abstract && selected_method->is_abstract()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
    THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
              methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
                                                      selected_method->name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
                                                      selected_method->signature()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
  // setup result
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
  result.set_virtual(resolved_klass, recv_klass, resolved_method, selected_method, vtable_index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, KlassHandle recv_klass, KlassHandle resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   851
                                          Symbol* method_name, Symbol* method_signature, KlassHandle current_klass,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
                                          bool check_access, bool check_null_and_abstract, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  methodHandle resolved_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  linktime_resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  runtime_resolve_interface_method(result, resolved_method, resolved_klass, recv, recv_klass, check_null_and_abstract, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
// throws linktime exceptions
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   859
void LinkResolver::linktime_resolve_interface_method(methodHandle& resolved_method, KlassHandle resolved_klass, Symbol* method_name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   860
                                                     Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  // normal interface method resolution
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
  resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
  assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
  assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
// throws runtime exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
void LinkResolver::runtime_resolve_interface_method(CallInfo& result, methodHandle resolved_method, KlassHandle resolved_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
                                                    Handle recv, KlassHandle recv_klass, bool check_null_and_abstract, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  // check if receiver exists
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
  if (check_null_and_abstract && recv.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
    THROW(vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
  // check if receiver klass implements the resolved interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
  if (!recv_klass->is_subtype_of(resolved_klass())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
    char buf[200];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
    jio_snprintf(buf, sizeof(buf), "Class %s does not implement the requested interface %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
                 (Klass::cast(recv_klass()))->external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
                 (Klass::cast(resolved_klass()))->external_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
    THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
  // do lookup based on receiver klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
  methodHandle sel_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  lookup_instance_method_in_klasses(sel_method, recv_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   887
            resolved_method->name(),
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   888
            resolved_method->signature(), CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
  // check if method exists
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
  if (sel_method.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
    THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
              methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
                                                      resolved_method->name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
                                                      resolved_method->signature()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
  // check if public
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
  if (!sel_method->is_public()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
    THROW_MSG(vmSymbols::java_lang_IllegalAccessError(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
              methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
                                                      sel_method->name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
                                                      sel_method->signature()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
  // check if abstract
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  if (check_null_and_abstract && sel_method->is_abstract()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
    THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
              methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
                                                      sel_method->name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
                                                      sel_method->signature()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  // setup result
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  result.set_interface(resolved_klass, recv_klass, resolved_method, sel_method, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
methodHandle LinkResolver::linktime_resolve_interface_method_or_null(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
                                                 KlassHandle resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   920
                                                 Symbol* method_name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   921
                                                 Symbol* method_signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
                                                 KlassHandle current_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
                                                 bool check_access) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
  EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
  methodHandle method_result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
  linktime_resolve_interface_method(method_result, resolved_klass, method_name, method_signature, current_klass, check_access, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
  if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
    CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
    return methodHandle();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
    return method_result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
methodHandle LinkResolver::linktime_resolve_virtual_method_or_null(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
                                                 KlassHandle resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   937
                                                 Symbol* method_name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   938
                                                 Symbol* method_signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
                                                 KlassHandle current_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
                                                 bool check_access) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
  EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
  methodHandle method_result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
  linktime_resolve_virtual_method(method_result, resolved_klass, method_name, method_signature, current_klass, check_access, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
  if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
    CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
    return methodHandle();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
    return method_result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
methodHandle LinkResolver::resolve_virtual_call_or_null(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
                                                 KlassHandle receiver_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
                                                 KlassHandle resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   955
                                                 Symbol* name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   956
                                                 Symbol* signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
                                                 KlassHandle current_klass) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
  EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
  CallInfo info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
  resolve_virtual_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
  if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
    CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
    return methodHandle();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
  return info.selected_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
methodHandle LinkResolver::resolve_interface_call_or_null(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
                                                 KlassHandle receiver_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
                                                 KlassHandle resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   971
                                                 Symbol* name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   972
                                                 Symbol* signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
                                                 KlassHandle current_klass) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
  EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
  CallInfo info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
  resolve_interface_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
  if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
    CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
    return methodHandle();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
  return info.selected_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
int LinkResolver::resolve_virtual_vtable_index(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
                                               KlassHandle receiver_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
                                               KlassHandle resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   987
                                               Symbol* name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   988
                                               Symbol* signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
                                               KlassHandle current_klass) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
  EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
  CallInfo info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
  resolve_virtual_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
    CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
    return methodOopDesc::invalid_vtable_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
  return info.vtable_index();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
methodHandle LinkResolver::resolve_static_call_or_null(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
                                                  KlassHandle resolved_klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1002
                                                  Symbol* name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1003
                                                  Symbol* signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
                                                  KlassHandle current_klass) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
  EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
  CallInfo info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  resolve_static_call(info, resolved_klass, name, signature, current_klass, true, false, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
  if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
    CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
    return methodHandle();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
  return info.selected_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1015
methodHandle LinkResolver::resolve_special_call_or_null(KlassHandle resolved_klass, Symbol* name, Symbol* signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
                                                        KlassHandle current_klass) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
  EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
  CallInfo info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
  resolve_special_call(info, resolved_klass, name, signature, current_klass, true, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
    CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
    return methodHandle();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  return info.selected_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
// ConstantPool entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
void LinkResolver::resolve_invoke(CallInfo& result, Handle recv, constantPoolHandle pool, int index, Bytecodes::Code byte, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
  switch (byte) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
    case Bytecodes::_invokestatic   : resolve_invokestatic   (result,       pool, index, CHECK); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
    case Bytecodes::_invokespecial  : resolve_invokespecial  (result,       pool, index, CHECK); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
    case Bytecodes::_invokevirtual  : resolve_invokevirtual  (result, recv, pool, index, CHECK); break;
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1037
    case Bytecodes::_invokedynamic  : resolve_invokedynamic  (result,       pool, index, CHECK); break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
    case Bytecodes::_invokeinterface: resolve_invokeinterface(result, recv, pool, index, CHECK); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1043
void LinkResolver::resolve_pool(KlassHandle& resolved_klass, Symbol*& method_name, Symbol*& method_signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
                                KlassHandle& current_klass, constantPoolHandle pool, int index, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
   // resolve klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
  resolve_klass(resolved_klass, pool, index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
  // Get name, signature, and static klass
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1049
  method_name      = pool->name_ref_at(index);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1050
  method_signature = pool->signature_ref_at(index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
  current_klass    = KlassHandle(THREAD, pool->pool_holder());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
void LinkResolver::resolve_invokestatic(CallInfo& result, constantPoolHandle pool, int index, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  KlassHandle  resolved_klass;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1057
  Symbol* method_name = NULL;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1058
  Symbol* method_signature = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
  KlassHandle  current_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
  resolve_pool(resolved_klass, method_name,  method_signature, current_klass, pool, index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
  resolve_static_call(result, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
void LinkResolver::resolve_invokespecial(CallInfo& result, constantPoolHandle pool, int index, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
  KlassHandle  resolved_klass;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1067
  Symbol* method_name = NULL;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1068
  Symbol* method_signature = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
  KlassHandle  current_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
  resolve_pool(resolved_klass, method_name,  method_signature, current_klass, pool, index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
  resolve_special_call(result, resolved_klass, method_name, method_signature, current_klass, true, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
void LinkResolver::resolve_invokevirtual(CallInfo& result, Handle recv,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
                                          constantPoolHandle pool, int index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
                                          TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  KlassHandle  resolved_klass;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1080
  Symbol* method_name = NULL;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1081
  Symbol* method_signature = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
  KlassHandle  current_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
  resolve_pool(resolved_klass, method_name,  method_signature, current_klass, pool, index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
  KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
  resolve_virtual_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
void LinkResolver::resolve_invokeinterface(CallInfo& result, Handle recv, constantPoolHandle pool, int index, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
  KlassHandle  resolved_klass;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1091
  Symbol* method_name = NULL;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1092
  Symbol* method_signature = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
  KlassHandle  current_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
  resolve_pool(resolved_klass, method_name,  method_signature, current_klass, pool, index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
  resolve_interface_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1099
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1100
void LinkResolver::resolve_invokedynamic(CallInfo& result, constantPoolHandle pool, int raw_index, TRAPS) {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1101
  assert(EnableInvokeDynamic, "");
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1102
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1103
  // This guy is reached from InterpreterRuntime::resolve_invokedynamic.
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1104
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1105
  // At this point, we only need the signature, and can ignore the name.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1106
  Symbol*  method_signature = pool->signature_ref_at(raw_index);  // raw_index works directly
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1107
  Symbol* method_name = vmSymbols::invokeExact_name();
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1108
  KlassHandle resolved_klass = SystemDictionaryHandles::MethodHandle_klass();
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1109
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 4571
diff changeset
  1110
  // JSR 292:  this must be an implicitly generated method MethodHandle.invokeExact(*...)
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1111
  // The extra MH receiver will be inserted into the stack on every call.
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1112
  methodHandle resolved_method;
5421
e294db54fc0d 6939196: method handle signatures off the boot class path get linkage errors
jrose
parents: 5420
diff changeset
  1113
  KlassHandle current_klass(THREAD, pool->pool_holder());
e294db54fc0d 6939196: method handle signatures off the boot class path get linkage errors
jrose
parents: 5420
diff changeset
  1114
  lookup_implicit_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, CHECK);
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1115
  if (resolved_method.is_null()) {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1116
    THROW(vmSymbols::java_lang_InternalError());
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1117
  }
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5547
diff changeset
  1118
  result.set_dynamic(resolved_method, CHECK);
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1119
}
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
  1120
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
void FieldAccessInfo::print() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
  tty->print_cr("Field %s@%d", name()->as_C_string(), field_offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
#endif