src/hotspot/share/ci/ciField.cpp
author dholmes
Sat, 23 Jun 2018 01:32:41 -0400
changeset 50735 2f2af62dfac7
parent 49449 ef5d5d343e2a
child 51444 3e5d28e6de32
permissions -rw-r--r--
8010319: Implementation of JEP 181: Nest-Based Access Control Reviewed-by: alanb, psandoz, mchung, coleenp, acorn, mcimadamore, forax, jlahoda, sspitsyn, abuckley Contributed-by: alex.buckley@oracle.com, maurizio.mimadamore@oracle.com, mandy.chung@oracle.com, tobias.hartmann@oracle.com, david.holmes@oracle.com, vladimir.x.ivanov@oracle.com, karen.kinnear@oracle.com, vladimir.kozlov@oracle.com, john.r.rose@oracle.com, daniel.smith@oracle.com, serguei.spitsyn@oracle.com, kumardotsrinivasan@gmail.com, boris.ulasevich@bell-sw.com
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
49359
59f6547e151f 8199264: Remove universe.inline.hpp to simplify include dependencies
stefank
parents: 48417
diff changeset
     2
 * Copyright (c) 1999, 2018, 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: 4644
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4644
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: 4644
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: 6177
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    26
#include "ci/ciField.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    27
#include "ci/ciInstanceKlass.hpp"
49449
ef5d5d343e2a 8199263: Split interfaceSupport.hpp to not require including .inline.hpp files
coleenp
parents: 49359
diff changeset
    28
#include "ci/ciUtilities.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    29
#include "classfile/systemDictionary.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29081
diff changeset
    30
#include "gc/shared/collectedHeap.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    31
#include "interpreter/linkResolver.hpp"
49359
59f6547e151f 8199264: Remove universe.inline.hpp to simplify include dependencies
stefank
parents: 48417
diff changeset
    32
#include "memory/universe.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    33
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    34
#include "runtime/fieldDescriptor.hpp"
49449
ef5d5d343e2a 8199263: Split interfaceSupport.hpp to not require including .inline.hpp files
coleenp
parents: 49359
diff changeset
    35
#include "runtime/handles.inline.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// ciField
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// This class represents the result of a field lookup in the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// The lookup may not succeed, in which case the information in
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// the ciField will be incomplete.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// The ciObjectFactory cannot create circular data structures in one query.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// To avoid vicious circularities, we initialize ciField::_type to NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
// for reference types and derive it lazily from the ciField::_signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
// Primitive types are eagerly initialized, and basic layout queries
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
// can succeed without initialization, using only the BasicType of the field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// Notes on bootstrapping and shared CI objects:  A field is shared if and
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// only if it is (a) non-static and (b) declared by a shared instance klass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// This allows non-static field lists to be cached on shared types.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
// Because the _type field is lazily initialized, however, there is a
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
// special restriction that a shared field cannot cache an unshared type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
// This puts a small performance penalty on shared fields with unshared
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
// types, such as StackTraceElement[] Throwable.stackTrace.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
// (Throwable is shared because ClassCastException is shared, but
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
// StackTraceElement is not presently shared.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
// It is not a vicious circularity for a ciField to recursively create
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
// the ciSymbols necessary to represent its name and signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
// Therefore, these items are created eagerly, and the name and signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
// of a shared field are themselves shared symbols.  This somewhat
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
// pollutes the set of shared CI objects:  It grows from 50 to 93 items,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
// with all of the additional 43 being uninteresting shared ciSymbols.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
// This adds at most one step to the binary search, an amount which
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
// decreases for complex compilation tasks.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
// ciField::ciField
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
    70
ciField::ciField(ciInstanceKlass* klass, int index) :
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
    71
    _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  ASSERT_IN_VM;
50735
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
    73
  CompilerThread *THREAD = CompilerThread::current();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  assert(ciObjectFactory::is_initialized(), "not a shared field");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
35758
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
    77
  assert(klass->get_instanceKlass()->is_linked(), "must be linked before using its constant-pool");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
50735
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
    79
  constantPoolHandle cpool(THREAD, klass->get_instanceKlass()->constants());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  // Get the field's name, signature, and type.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    82
  Symbol* name  = cpool->name_ref_at(index);
50735
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
    83
  _name = ciEnv::current(THREAD)->get_symbol(name);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  int nt_index = cpool->name_and_type_ref_index_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  int sig_index = cpool->signature_ref_index_at(nt_index);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    87
  Symbol* signature = cpool->symbol_at(sig_index);
50735
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
    88
  _signature = ciEnv::current(THREAD)->get_symbol(signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    90
  BasicType field_type = FieldType::basic_type(signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  // If the field is a pointer type, get the klass of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  // field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  if (field_type == T_OBJECT || field_type == T_ARRAY) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    bool ignore;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
    // This is not really a class reference; the index always refers to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
    // field's type signature, as a symbol.  Linkage checks do not apply.
50735
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
    98
    _type = ciEnv::current(THREAD)->get_klass_by_index(cpool, sig_index, ignore, klass);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    _type = ciType::make(field_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
50735
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   103
  _name = (ciSymbol*)ciEnv::current(THREAD)->get_symbol(name);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  // Get the field's declared holder.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // Note: we actually create a ciInstanceKlass for this klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  // even though we may not need to.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  int holder_index = cpool->klass_ref_index_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  bool holder_is_accessible;
35758
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   111
50735
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   112
  ciKlass* generic_declared_holder = ciEnv::current(THREAD)->get_klass_by_index(cpool, holder_index,
35758
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   113
                                                                                holder_is_accessible,
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   114
                                                                                klass);
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   115
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   116
  if (generic_declared_holder->is_array_klass()) {
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   117
    // If the declared holder of the field is an array class, assume that
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   118
    // the canonical holder of that field is java.lang.Object. Arrays
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   119
    // do not have fields; java.lang.Object is the only supertype of an
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   120
    // array type that can declare fields and is therefore the canonical
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   121
    // holder of the array type.
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   122
    //
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   123
    // Furthermore, the compilers assume that java.lang.Object does not
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   124
    // have any fields. Therefore, the field is not looked up. Instead,
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   125
    // the method returns partial information that will trigger special
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   126
    // handling in ciField::will_link and will result in a
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   127
    // java.lang.NoSuchFieldError exception being thrown by the compiled
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   128
    // code (the expected behavior in this case).
50735
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   129
    _holder = ciEnv::current(THREAD)->Object_klass();
35758
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   130
    _offset = -1;
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   131
    _is_constant = false;
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   132
    return;
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   133
  }
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   134
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   135
  ciInstanceKlass* declared_holder = generic_declared_holder->as_instance_klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  // The declared holder of this field may not have been loaded.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  // Bail out with partial field information.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  if (!holder_is_accessible) {
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19770
diff changeset
   140
    // _type has already been set.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
    // The default values for _flags and _constant_value will suffice.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
    // We need values for _holder, _offset,  and _is_constant,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    _holder = declared_holder;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
    _offset = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
    _is_constant = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12984
diff changeset
   149
  InstanceKlass* loaded_decl_holder = declared_holder->get_instanceKlass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  // Perform the field lookup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  fieldDescriptor field_desc;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12984
diff changeset
   153
  Klass* canonical_holder =
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   154
    loaded_decl_holder->find_field(name, signature, &field_desc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  if (canonical_holder == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
    // Field lookup failed.  Will be detected by will_link.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
    _holder = declared_holder;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
    _offset = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
    _is_constant = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
25742
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   163
  // Access check based on declared_holder. canonical_holder should not be used
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   164
  // to check access because it can erroneously succeed. If this check fails,
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   165
  // propagate the declared holder to will_link() which in turn will bail out
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   166
  // compilation for this field access.
50735
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   167
  bool can_access = Reflection::verify_member_access(klass->get_Klass(),
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   168
                                                     declared_holder->get_Klass(),
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   169
                                                     canonical_holder,
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   170
                                                     field_desc.access_flags(),
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   171
                                                     true, false, THREAD);
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   172
  if (!can_access) {
25742
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   173
    _holder = declared_holder;
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   174
    _offset = -1;
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   175
    _is_constant = false;
50735
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   176
    // It's possible the access check failed due to a nestmate access check
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   177
    // encountering an exception. We can't propagate the exception from here
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   178
    // so we have to clear it. If the access check happens again in a different
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   179
    // context then the exception will be thrown there.
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   180
    if (HAS_PENDING_EXCEPTION) {
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   181
      CLEAR_PENDING_EXCEPTION;
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 49449
diff changeset
   182
    }
25742
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   183
    return;
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   184
  }
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   185
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  assert(canonical_holder == field_desc.field_holder(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  initialize_from(&field_desc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   190
ciField::ciField(fieldDescriptor *fd) :
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   191
    _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  ASSERT_IN_VM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  // Get the field's name, signature, and type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  ciEnv* env = CURRENT_ENV;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   196
  _name = env->get_symbol(fd->name());
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   197
  _signature = env->get_symbol(fd->signature());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  BasicType field_type = fd->field_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  // If the field is a pointer type, get the klass of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  // field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  if (field_type == T_OBJECT || field_type == T_ARRAY) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
    _type = NULL;  // must call compute_type on first access
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
    _type = ciType::make(field_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  initialize_from(fd);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  // Either (a) it is marked shared, or else (b) we are done bootstrapping.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  assert(is_shared() || ciObjectFactory::is_initialized(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
         "bootstrap classes must not create & cache unshared fields");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
4644
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   216
static bool trust_final_non_static_fields(ciInstanceKlass* holder) {
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   217
  if (holder == NULL)
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   218
    return false;
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   219
  if (holder->name() == ciSymbol::java_lang_System())
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   220
    // Never trust strangely unstable finals:  System.out, etc.
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   221
    return false;
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   222
  // Even if general trusting is disabled, trust system-built closures in these packages.
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8331
diff changeset
   223
  if (holder->is_in_package("java/lang/invoke") || holder->is_in_package("sun/invoke"))
4644
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   224
    return true;
31519
bb26c50aadd0 8087218: Constant fold loads from final instance fields in VM anonymous classes
vlivanov
parents: 31019
diff changeset
   225
  // Trust VM anonymous classes. They are private API (sun.misc.Unsafe) and can't be serialized,
bb26c50aadd0 8087218: Constant fold loads from final instance fields in VM anonymous classes
vlivanov
parents: 31019
diff changeset
   226
  // so there is no hacking of finals going on with them.
bb26c50aadd0 8087218: Constant fold loads from final instance fields in VM anonymous classes
vlivanov
parents: 31019
diff changeset
   227
  if (holder->is_anonymous())
bb26c50aadd0 8087218: Constant fold loads from final instance fields in VM anonymous classes
vlivanov
parents: 31019
diff changeset
   228
    return true;
36077
fa6d92de1c70 8149813: Move trusted final field handling from C2 LoadNode::Value to shared code
shade
parents: 35758
diff changeset
   229
  // Trust final fields in all boxed classes
fa6d92de1c70 8149813: Move trusted final field handling from C2 LoadNode::Value to shared code
shade
parents: 35758
diff changeset
   230
  if (holder->is_box_klass())
fa6d92de1c70 8149813: Move trusted final field handling from C2 LoadNode::Value to shared code
shade
parents: 35758
diff changeset
   231
    return true;
fa6d92de1c70 8149813: Move trusted final field handling from C2 LoadNode::Value to shared code
shade
parents: 35758
diff changeset
   232
  // Trust final fields in String
fa6d92de1c70 8149813: Move trusted final field handling from C2 LoadNode::Value to shared code
shade
parents: 35758
diff changeset
   233
  if (holder->name() == ciSymbol::java_lang_String())
fa6d92de1c70 8149813: Move trusted final field handling from C2 LoadNode::Value to shared code
shade
parents: 35758
diff changeset
   234
    return true;
33483
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   235
  // Trust Atomic*FieldUpdaters: they are very important for performance, and make up one
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   236
  // more reason not to use Unsafe, if their final fields are trusted. See more in JDK-8140483.
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   237
  if (holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicIntegerFieldUpdater_Impl() ||
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   238
      holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicLongFieldUpdater_CASUpdater() ||
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   239
      holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicLongFieldUpdater_LockedUpdater() ||
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   240
      holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicReferenceFieldUpdater_Impl()) {
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   241
    return true;
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   242
  }
4644
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   243
  return TrustFinalNonStaticFields;
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   244
}
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   245
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
void ciField::initialize_from(fieldDescriptor* fd) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  // Get the flags, offset, and canonical holder of the field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  _flags = ciFlags(fd->access_flags());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  _offset = fd->offset();
48417
044979e94c4e 8191852: Null pointer dereference in ciKlass::get_Klass of ciKlass.hpp:58
dlong
parents: 47216
diff changeset
   250
  Klass* field_holder = fd->field_holder();
044979e94c4e 8191852: Null pointer dereference in ciKlass::get_Klass of ciKlass.hpp:58
dlong
parents: 47216
diff changeset
   251
  assert(field_holder != NULL, "null field_holder");
044979e94c4e 8191852: Null pointer dereference in ciKlass::get_Klass of ciKlass.hpp:58
dlong
parents: 47216
diff changeset
   252
  _holder = CURRENT_ENV->get_instance_klass(field_holder);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  // Check to see if the field is constant.
38030
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   255
  Klass* k = _holder->get_Klass();
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   256
  bool is_stable_field = FoldStableValues && is_stable();
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   257
  if ((is_final() && !has_initialized_final_update()) || is_stable_field) {
38030
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   258
    if (is_static()) {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   259
      // This field just may be constant.  The only case where it will
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   260
      // not be constant is when the field is a *special* static & final field
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   261
      // whose value may change.  The three examples are java.lang.System.in,
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   262
      // java.lang.System.out, and java.lang.System.err.
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   263
      assert(SystemDictionary::System_klass() != NULL, "Check once per vm");
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   264
      if (k == SystemDictionary::System_klass()) {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   265
        // Check offsets for case 2: System.in, System.out, or System.err
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   266
        if( _offset == java_lang_System::in_offset_in_bytes()  ||
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   267
            _offset == java_lang_System::out_offset_in_bytes() ||
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   268
            _offset == java_lang_System::err_offset_in_bytes() ) {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   269
          _is_constant = false;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   270
          return;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   271
        }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   272
      }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   273
      _is_constant = true;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   274
    } else {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   275
      // An instance field can be constant if it's a final static field or if
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8331
diff changeset
   276
      // it's a final non-static field of a trusted class (classes in
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8331
diff changeset
   277
      // java.lang.invoke and sun.invoke packages and subpackages).
38030
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   278
      _is_constant = is_stable_field || trust_final_non_static_fields(_holder);
19770
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 14828
diff changeset
   279
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  } else {
38030
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   281
    // For CallSite objects treat the target field as a compile time constant.
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   282
    assert(SystemDictionary::CallSite_klass() != NULL, "should be already initialized");
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   283
    if (k == SystemDictionary::CallSite_klass() &&
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   284
        _offset == java_lang_invoke_CallSite::target_offset_in_bytes()) {
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   285
      assert(!has_initialized_final_update(), "CallSite is not supposed to have writes to final fields outside initializers");
38030
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   286
      _is_constant = true;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   287
    } else {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   288
      // Non-final & non-stable fields are not constants.
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   289
      _is_constant = false;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   290
    }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   291
  }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   292
}
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   293
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   294
// ------------------------------------------------------------------
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   295
// ciField::constant_value
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   296
// Get the constant value of a this static field.
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   297
ciConstant ciField::constant_value() {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   298
  assert(is_static() && is_constant(), "illegal call to constant_value()");
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   299
  if (!_holder->is_initialized()) {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   300
    return ciConstant(); // Not initialized yet
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  }
38030
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   302
  if (_constant_value.basic_type() == T_ILLEGAL) {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   303
    // Static fields are placed in mirror objects.
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   304
    VM_ENTRY_MARK;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   305
    ciInstance* mirror = CURRENT_ENV->get_instance(_holder->get_Klass()->java_mirror());
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   306
    _constant_value = mirror->field_value_impl(type()->basic_type(), offset());
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   307
  }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   308
  if (FoldStableValues && is_stable() && _constant_value.is_null_or_zero()) {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   309
    return ciConstant();
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   310
  }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   311
  return _constant_value;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   312
}
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   313
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   314
// ------------------------------------------------------------------
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   315
// ciField::constant_value_of
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   316
// Get the constant value of non-static final field in the given object.
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   317
ciConstant ciField::constant_value_of(ciObject* object) {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   318
  assert(!is_static() && is_constant(), "only if field is non-static constant");
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   319
  assert(object->is_instance(), "must be instance");
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   320
  ciConstant field_value = object->as_instance()->field_value(this);
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   321
  if (FoldStableValues && is_stable() && field_value.is_null_or_zero()) {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   322
    return ciConstant();
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   323
  }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   324
  return field_value;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
// ciField::compute_type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
// Lazily compute the type, if it is an instance klass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
ciType* ciField::compute_type() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  GUARDED_VM_ENTRY(return compute_type_impl();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
ciType* ciField::compute_type_impl() {
10008
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 8725
diff changeset
   336
  ciKlass* type = CURRENT_ENV->get_klass_by_name_impl(_holder, constantPoolHandle(), _signature, false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  if (!type->is_primitive_type() && is_shared()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
    // We must not cache a pointer to an unshared type, in a shared field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
    bool type_is_also_shared = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
    if (type->is_type_array_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
      type_is_also_shared = true;  // int[] etc. are explicitly bootstrapped
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
    } else if (type->is_instance_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
      type_is_also_shared = type->as_instance_klass()->is_shared();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
      // Currently there is no 'shared' query for array types.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
      type_is_also_shared = !ciObjectFactory::is_initialized();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
    if (!type_is_also_shared)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
      return type;              // Bummer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  _type = type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  return type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
// ciField::will_link
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
// Can a specific access to this field be made without causing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
// link errors?
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   361
bool ciField::will_link(ciMethod* accessing_method,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
                        Bytecodes::Code bc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  VM_ENTRY_MARK;
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   364
  assert(bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic ||
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   365
         bc == Bytecodes::_getfield  || bc == Bytecodes::_putfield,
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   366
         "unexpected bytecode");
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   367
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  if (_offset == -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
    // at creation we couldn't link to our holder so we need to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
    // maintain that stance, otherwise there's no safe way to use this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
    // ciField.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   375
  // Check for static/nonstatic mismatch
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   376
  bool is_static = (bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic);
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   377
  if (is_static != this->is_static()) {
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   378
    return false;
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   379
  }
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   380
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   381
  // Get and put can have different accessibility rules
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   382
  bool is_put    = (bc == Bytecodes::_putfield  || bc == Bytecodes::_putstatic);
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   383
  if (is_put) {
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   384
    if (_known_to_link_with_put == accessing_method) {
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   385
      return true;
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   386
    }
12984
8fc2453a8ec4 7160677: missing else in fix for 7152811
never
parents: 12982
diff changeset
   387
  } else {
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   388
    if (_known_to_link_with_get == accessing_method->holder()) {
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   389
      return true;
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   390
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
31019
d05fcdd70109 8029567: Clean up linkResolver code
coleenp
parents: 30764
diff changeset
   393
  LinkInfo link_info(_holder->get_instanceKlass(),
d05fcdd70109 8029567: Clean up linkResolver code
coleenp
parents: 30764
diff changeset
   394
                     _name->get_symbol(), _signature->get_symbol(),
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   395
                     accessing_method->get_Method());
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19770
diff changeset
   396
  fieldDescriptor result;
31019
d05fcdd70109 8029567: Clean up linkResolver code
coleenp
parents: 30764
diff changeset
   397
  LinkResolver::resolve_field(result, link_info, bc, false, KILL_COMPILE_ON_FATAL_(false));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  // update the hit-cache, unless there is a problem with memory scoping:
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   400
  if (accessing_method->holder()->is_shared() || !is_shared()) {
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   401
    if (is_put) {
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   402
      _known_to_link_with_put = accessing_method;
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   403
    } else {
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   404
      _known_to_link_with_get = accessing_method->holder();
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   405
    }
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   406
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
// ciField::print
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
void ciField::print() {
14828
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 13728
diff changeset
   414
  tty->print("<ciField name=");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  _holder->print_name();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  tty->print(".");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  _name->print_symbol();
14828
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 13728
diff changeset
   418
  tty->print(" signature=");
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 13728
diff changeset
   419
  _signature->print_symbol();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  tty->print(" offset=%d type=", _offset);
19770
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 14828
diff changeset
   421
  if (_type != NULL)
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 14828
diff changeset
   422
    _type->print_name();
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 14828
diff changeset
   423
  else
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 14828
diff changeset
   424
    tty->print("(reference)");
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 14828
diff changeset
   425
  tty->print(" flags=%04x", flags().as_int());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  tty->print(" is_constant=%s", bool_to_str(_is_constant));
6177
12835feea156 6969569: assert(is_static() && is_constant()) failed: illegal call to constant_value()
kvn
parents: 5547
diff changeset
   427
  if (_is_constant && is_static()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
    tty->print(" constant_value=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
    _constant_value.print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  tty->print(">");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
// ciField::print_name_on
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
// Print the name of this field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
void ciField::print_name_on(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  name()->print_symbol_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
}