src/hotspot/share/ci/ciField.cpp
author erikj
Tue, 12 Sep 2017 19:03:39 +0200
changeset 47216 71c04702a3d5
parent 39421 hotspot/src/share/vm/ci/ciField.cpp@a9652c919db8
child 48417 044979e94c4e
permissions -rw-r--r--
8187443: Forest Consolidation: Move files to unified layout Reviewed-by: darcy, ihse
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
29081
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 25742
diff changeset
     2
 * Copyright (c) 1999, 2015, 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"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    28
#include "ci/ciUtilities.hpp"
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"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    32
#include "memory/universe.inline.hpp"
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"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// ciField
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
// This class represents the result of a field lookup in the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// The lookup may not succeed, in which case the information in
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// the ciField will be incomplete.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// The ciObjectFactory cannot create circular data structures in one query.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// To avoid vicious circularities, we initialize ciField::_type to NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// for reference types and derive it lazily from the ciField::_signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
// Primitive types are eagerly initialized, and basic layout queries
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
// can succeed without initialization, using only the BasicType of the field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
// Notes on bootstrapping and shared CI objects:  A field is shared if and
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// only if it is (a) non-static and (b) declared by a shared instance klass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// This allows non-static field lists to be cached on shared types.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// Because the _type field is lazily initialized, however, there is a
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
// special restriction that a shared field cannot cache an unshared type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
// This puts a small performance penalty on shared fields with unshared
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
// types, such as StackTraceElement[] Throwable.stackTrace.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
// (Throwable is shared because ClassCastException is shared, but
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
// StackTraceElement is not presently shared.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
// It is not a vicious circularity for a ciField to recursively create
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
// the ciSymbols necessary to represent its name and signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
// Therefore, these items are created eagerly, and the name and signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
// of a shared field are themselves shared symbols.  This somewhat
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
// pollutes the set of shared CI objects:  It grows from 50 to 93 items,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
// with all of the additional 43 being uninteresting shared ciSymbols.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
// This adds at most one step to the binary search, an amount which
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
// decreases for complex compilation tasks.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
// ciField::ciField
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
    69
ciField::ciField(ciInstanceKlass* klass, int index) :
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
    70
    _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  ASSERT_IN_VM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  CompilerThread *thread = CompilerThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  assert(ciObjectFactory::is_initialized(), "not a shared field");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
35758
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
    76
  assert(klass->get_instanceKlass()->is_linked(), "must be linked before using its constant-pool");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  constantPoolHandle cpool(thread, klass->get_instanceKlass()->constants());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  // 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
    81
  Symbol* name  = cpool->name_ref_at(index);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    82
  _name = ciEnv::current(thread)->get_symbol(name);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  int nt_index = cpool->name_and_type_ref_index_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  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
    86
  Symbol* signature = cpool->symbol_at(sig_index);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    87
  _signature = ciEnv::current(thread)->get_symbol(signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    89
  BasicType field_type = FieldType::basic_type(signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  // If the field is a pointer type, get the klass of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  // field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  if (field_type == T_OBJECT || field_type == T_ARRAY) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
    bool ignore;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    // This is not really a class reference; the index always refers to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
    // field's type signature, as a symbol.  Linkage checks do not apply.
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1
diff changeset
    97
    _type = ciEnv::current(thread)->get_klass_by_index(cpool, sig_index, ignore, klass);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
    _type = ciType::make(field_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   102
  _name = (ciSymbol*)ciEnv::current(thread)->get_symbol(name);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  // Get the field's declared holder.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  // Note: we actually create a ciInstanceKlass for this klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // even though we may not need to.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  int holder_index = cpool->klass_ref_index_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  bool holder_is_accessible;
35758
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   110
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   111
  ciKlass* generic_declared_holder = ciEnv::current(thread)->get_klass_by_index(cpool, holder_index,
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   112
                                                                                holder_is_accessible,
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   113
                                                                                klass);
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   114
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   115
  if (generic_declared_holder->is_array_klass()) {
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   116
    // 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
   117
    // 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
   118
    // 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
   119
    // 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
   120
    // holder of the array type.
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   121
    //
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   122
    // 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
   123
    // 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
   124
    // 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
   125
    // 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
   126
    // 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
   127
    // code (the expected behavior in this case).
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   128
    _holder = ciEnv::current(thread)->Object_klass();
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   129
    _offset = -1;
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   130
    _is_constant = false;
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   131
    return;
6109e2e1e1de 8148753: Compilation fails due to field accesses on array types
zmajo
parents: 33483
diff changeset
   132
  }
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
  ciInstanceKlass* declared_holder = generic_declared_holder->as_instance_klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  // The declared holder of this field may not have been loaded.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  // Bail out with partial field information.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  if (!holder_is_accessible) {
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19770
diff changeset
   139
    // _type has already been set.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
    // The default values for _flags and _constant_value will suffice.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
    // We need values for _holder, _offset,  and _is_constant,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
    _holder = declared_holder;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    _offset = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
    _is_constant = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12984
diff changeset
   148
  InstanceKlass* loaded_decl_holder = declared_holder->get_instanceKlass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  // Perform the field lookup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  fieldDescriptor field_desc;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12984
diff changeset
   152
  Klass* canonical_holder =
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   153
    loaded_decl_holder->find_field(name, signature, &field_desc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  if (canonical_holder == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
    // Field lookup failed.  Will be detected by will_link.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
    _holder = declared_holder;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
    _offset = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
    _is_constant = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
25742
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   162
  // 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
   163
  // 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
   164
  // 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
   165
  // compilation for this field access.
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   166
  if (!Reflection::verify_field_access(klass->get_Klass(), declared_holder->get_Klass(), canonical_holder, field_desc.access_flags(), true)) {
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   167
    _holder = declared_holder;
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   168
    _offset = -1;
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   169
    _is_constant = false;
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   170
    return;
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   171
  }
07bedc8d1893 8050978: Fix bad field access check in C1 and C2
goetz
parents: 22551
diff changeset
   172
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  assert(canonical_holder == field_desc.field_holder(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  initialize_from(&field_desc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   177
ciField::ciField(fieldDescriptor *fd) :
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   178
    _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  ASSERT_IN_VM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  // Get the field's name, signature, and type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  ciEnv* env = CURRENT_ENV;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   183
  _name = env->get_symbol(fd->name());
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   184
  _signature = env->get_symbol(fd->signature());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  BasicType field_type = fd->field_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  // If the field is a pointer type, get the klass of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  // field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  if (field_type == T_OBJECT || field_type == T_ARRAY) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
    _type = NULL;  // must call compute_type on first access
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
    _type = ciType::make(field_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  initialize_from(fd);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  // Either (a) it is marked shared, or else (b) we are done bootstrapping.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  assert(is_shared() || ciObjectFactory::is_initialized(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
         "bootstrap classes must not create & cache unshared fields");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
4644
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   203
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
   204
  if (holder == NULL)
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   205
    return false;
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   206
  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
   207
    // 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
   208
    return false;
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   209
  // 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
   210
  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
   211
    return true;
31519
bb26c50aadd0 8087218: Constant fold loads from final instance fields in VM anonymous classes
vlivanov
parents: 31019
diff changeset
   212
  // 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
   213
  // 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
   214
  if (holder->is_anonymous())
bb26c50aadd0 8087218: Constant fold loads from final instance fields in VM anonymous classes
vlivanov
parents: 31019
diff changeset
   215
    return true;
36077
fa6d92de1c70 8149813: Move trusted final field handling from C2 LoadNode::Value to shared code
shade
parents: 35758
diff changeset
   216
  // 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
   217
  if (holder->is_box_klass())
fa6d92de1c70 8149813: Move trusted final field handling from C2 LoadNode::Value to shared code
shade
parents: 35758
diff changeset
   218
    return true;
fa6d92de1c70 8149813: Move trusted final field handling from C2 LoadNode::Value to shared code
shade
parents: 35758
diff changeset
   219
  // Trust final fields in String
fa6d92de1c70 8149813: Move trusted final field handling from C2 LoadNode::Value to shared code
shade
parents: 35758
diff changeset
   220
  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
   221
    return true;
33483
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   222
  // 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
   223
  // 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
   224
  if (holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicIntegerFieldUpdater_Impl() ||
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   225
      holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicLongFieldUpdater_CASUpdater() ||
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   226
      holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicLongFieldUpdater_LockedUpdater() ||
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   227
      holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicReferenceFieldUpdater_Impl()) {
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   228
    return true;
5b7dd5bd7c5c 8140483: Atomic*FieldUpdaters final fields should be trusted
shade
parents: 31519
diff changeset
   229
  }
4644
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   230
  return TrustFinalNonStaticFields;
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   231
}
2b1a1bc98168 6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents: 4571
diff changeset
   232
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
void ciField::initialize_from(fieldDescriptor* fd) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  // Get the flags, offset, and canonical holder of the field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  _flags = ciFlags(fd->access_flags());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  _offset = fd->offset();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12984
diff changeset
   237
  _holder = CURRENT_ENV->get_instance_klass(fd->field_holder());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  // 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
   240
  Klass* k = _holder->get_Klass();
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   241
  bool is_stable_field = FoldStableValues && is_stable();
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   242
  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
   243
    if (is_static()) {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   244
      // 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
   245
      // 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
   246
      // 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
   247
      // 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
   248
      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
   249
      if (k == SystemDictionary::System_klass()) {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   250
        // 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
   251
        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
   252
            _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
   253
            _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
   254
          _is_constant = false;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   255
          return;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   256
        }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   257
      }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   258
      _is_constant = true;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   259
    } else {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   260
      // 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
   261
      // 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
   262
      // 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
   263
      _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
   264
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  } else {
38030
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   266
    // 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
   267
    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
   268
    if (k == SystemDictionary::CallSite_klass() &&
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   269
        _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
   270
      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
   271
      _is_constant = true;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   272
    } else {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   273
      // 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
   274
      _is_constant = false;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   275
    }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   276
  }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   277
}
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   278
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   279
// ------------------------------------------------------------------
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   280
// ciField::constant_value
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   281
// 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
   282
ciConstant ciField::constant_value() {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   283
  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
   284
  if (!_holder->is_initialized()) {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   285
    return ciConstant(); // Not initialized yet
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  }
38030
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   287
  if (_constant_value.basic_type() == T_ILLEGAL) {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   288
    // Static fields are placed in mirror objects.
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   289
    VM_ENTRY_MARK;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   290
    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
   291
    _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
   292
  }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   293
  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
   294
    return ciConstant();
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   295
  }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   296
  return _constant_value;
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   297
}
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   298
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   299
// ------------------------------------------------------------------
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   300
// ciField::constant_value_of
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   301
// 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
   302
ciConstant ciField::constant_value_of(ciObject* object) {
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   303
  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
   304
  assert(object->is_instance(), "must be instance");
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   305
  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
   306
  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
   307
    return ciConstant();
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   308
  }
93f24e7b3c43 8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents: 36077
diff changeset
   309
  return field_value;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
// ciField::compute_type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
// Lazily compute the type, if it is an instance klass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
ciType* ciField::compute_type() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  GUARDED_VM_ENTRY(return compute_type_impl();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
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
   321
  ciKlass* type = CURRENT_ENV->get_klass_by_name_impl(_holder, constantPoolHandle(), _signature, false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  if (!type->is_primitive_type() && is_shared()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
    // We must not cache a pointer to an unshared type, in a shared field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
    bool type_is_also_shared = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    if (type->is_type_array_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
      type_is_also_shared = true;  // int[] etc. are explicitly bootstrapped
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
    } else if (type->is_instance_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
      type_is_also_shared = type->as_instance_klass()->is_shared();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
      // Currently there is no 'shared' query for array types.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
      type_is_also_shared = !ciObjectFactory::is_initialized();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
    if (!type_is_also_shared)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
      return type;              // Bummer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  _type = type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  return type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
// ciField::will_link
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
// Can a specific access to this field be made without causing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
// link errors?
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   346
bool ciField::will_link(ciMethod* accessing_method,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
                        Bytecodes::Code bc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  VM_ENTRY_MARK;
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   349
  assert(bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic ||
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   350
         bc == Bytecodes::_getfield  || bc == Bytecodes::_putfield,
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   351
         "unexpected bytecode");
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   352
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  if (_offset == -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
    // at creation we couldn't link to our holder so we need to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
    // maintain that stance, otherwise there's no safe way to use this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
    // ciField.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   360
  // Check for static/nonstatic mismatch
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   361
  bool is_static = (bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic);
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   362
  if (is_static != this->is_static()) {
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   363
    return false;
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   364
  }
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   365
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   366
  // Get and put can have different accessibility rules
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   367
  bool is_put    = (bc == Bytecodes::_putfield  || bc == Bytecodes::_putstatic);
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   368
  if (is_put) {
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   369
    if (_known_to_link_with_put == accessing_method) {
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   370
      return true;
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   371
    }
12984
8fc2453a8ec4 7160677: missing else in fix for 7152811
never
parents: 12982
diff changeset
   372
  } else {
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   373
    if (_known_to_link_with_get == accessing_method->holder()) {
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   374
      return true;
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   375
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
31019
d05fcdd70109 8029567: Clean up linkResolver code
coleenp
parents: 30764
diff changeset
   378
  LinkInfo link_info(_holder->get_instanceKlass(),
d05fcdd70109 8029567: Clean up linkResolver code
coleenp
parents: 30764
diff changeset
   379
                     _name->get_symbol(), _signature->get_symbol(),
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   380
                     accessing_method->get_Method());
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19770
diff changeset
   381
  fieldDescriptor result;
31019
d05fcdd70109 8029567: Clean up linkResolver code
coleenp
parents: 30764
diff changeset
   382
  LinkResolver::resolve_field(result, link_info, bc, false, KILL_COMPILE_ON_FATAL_(false));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  // 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
   385
  if (accessing_method->holder()->is_shared() || !is_shared()) {
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   386
    if (is_put) {
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   387
      _known_to_link_with_put = accessing_method;
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   388
    } else {
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38030
diff changeset
   389
      _known_to_link_with_get = accessing_method->holder();
12982
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   390
    }
7d7a3e02610e 7152811: Issues in client compiler
never
parents: 10008
diff changeset
   391
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
// ciField::print
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
void ciField::print() {
14828
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 13728
diff changeset
   399
  tty->print("<ciField name=");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  _holder->print_name();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  tty->print(".");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  _name->print_symbol();
14828
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 13728
diff changeset
   403
  tty->print(" signature=");
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 13728
diff changeset
   404
  _signature->print_symbol();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  tty->print(" offset=%d type=", _offset);
19770
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 14828
diff changeset
   406
  if (_type != NULL)
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 14828
diff changeset
   407
    _type->print_name();
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 14828
diff changeset
   408
  else
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 14828
diff changeset
   409
    tty->print("(reference)");
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 14828
diff changeset
   410
  tty->print(" flags=%04x", flags().as_int());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  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
   412
  if (_is_constant && is_static()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
    tty->print(" constant_value=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
    _constant_value.print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  tty->print(">");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
// ciField::print_name_on
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
// Print the name of this field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
void ciField::print_name_on(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  name()->print_symbol_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
}