hotspot/src/share/vm/classfile/classFileParser.cpp
author dcubed
Fri, 06 Jan 2012 16:18:29 -0800
changeset 11423 cb215b69197c
parent 11413 4f0c241f5aad
parent 11419 af92c7669f5a
child 12231 6a9cfc59a18a
child 12263 d20640f4f8fe
permissions -rw-r--r--
Merge
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8675
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
     2
 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5426
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5426
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: 5426
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: 7123
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    26
#include "classfile/classFileParser.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    27
#include "classfile/classLoader.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    28
#include "classfile/javaClasses.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    29
#include "classfile/symbolTable.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    30
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    31
#include "classfile/verificationType.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    32
#include "classfile/verifier.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    33
#include "classfile/vmSymbols.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    34
#include "memory/allocation.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    35
#include "memory/gcLocker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    36
#include "memory/oopFactory.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    37
#include "memory/universe.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    38
#include "oops/constantPoolOop.hpp"
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
    39
#include "oops/fieldStreams.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    40
#include "oops/instanceKlass.hpp"
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8676
diff changeset
    41
#include "oops/instanceMirrorKlass.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    42
#include "oops/klass.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    43
#include "oops/klassOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    44
#include "oops/klassVtable.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    45
#include "oops/methodOop.hpp"
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
    46
#include "oops/symbol.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    47
#include "prims/jvmtiExport.hpp"
11399
5dd5c4dd4b7d 7122253: Instrumentation.retransformClasses() leaks class bytes
dcubed
parents: 10546
diff changeset
    48
#include "prims/jvmtiThreadState.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    49
#include "runtime/javaCalls.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    50
#include "runtime/perfData.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    51
#include "runtime/reflection.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    52
#include "runtime/signature.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    53
#include "runtime/timer.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    54
#include "services/classLoadingService.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7123
diff changeset
    55
#include "services/threadService.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
5709
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
    57
// We generally try to create the oops directly when parsing, rather than
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
    58
// allocating temporary data structures and copying the bytes twice. A
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
    59
// temporary area is only needed when parsing utf8 entries in the constant
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
    60
// pool and when parsing line number tables.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
// We add assert in debug mode when class format is not checked.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
#define JAVA_CLASSFILE_MAGIC              0xCAFEBABE
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
#define JAVA_MIN_SUPPORTED_VERSION        45
383
f28a487324aa 6695506: JVM should accept classfiles with classfile version 51
kamg
parents: 360
diff changeset
    66
#define JAVA_MAX_SUPPORTED_VERSION        51
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
#define JAVA_MAX_SUPPORTED_MINOR_VERSION  0
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
// Used for two backward compatibility reasons:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
// - to check for new additions to the class file format in JDK1.5
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
// - to check for bug fixes in the format checker in JDK1.5
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
#define JAVA_1_5_VERSION                  49
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
// Used for backward compatibility reasons:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
// - to check for javac bug fixes that happened after 1.5
602
92e03692ddd6 6705523: Fix for 6695506 will violate spec when used in JDK6
kamg
parents: 383
diff changeset
    76
// - also used as the max version when running in jdk6
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
#define JAVA_6_VERSION                    50
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
5709
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
    79
// Used for backward compatibility reasons:
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
    80
// - to check NameAndType_info signatures more aggressively
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
    81
#define JAVA_7_VERSION                    51
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
    82
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
void ClassFileParser::parse_constant_pool_entries(constantPoolHandle cp, int length, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  // Use a local copy of ClassFileStream. It helps the C++ compiler to optimize
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  // this function (_current can be allocated in a register, with scalar
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  // replacement of aggregates). The _current pointer is copied back to
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  // stream() when this function returns. DON'T call another method within
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  // this method that uses stream().
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  ClassFileStream* cfs0 = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  ClassFileStream cfs1 = *cfs0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  ClassFileStream* cfs = &cfs1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
#ifdef ASSERT
6180
53c1bf468c81 6973963: SEGV in ciBlock::start_bci() with EA
kvn
parents: 6062
diff changeset
    94
  assert(cfs->allocated_on_stack(),"should be local");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  u1* old_current = cfs0->current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  // Used for batching symbol allocations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  const char* names[SymbolTable::symbol_alloc_batch_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  int lengths[SymbolTable::symbol_alloc_batch_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  int indices[SymbolTable::symbol_alloc_batch_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  unsigned int hashValues[SymbolTable::symbol_alloc_batch_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  int names_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  // parsing  Index 0 is unused
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  for (int index = 1; index < length; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
    // Each of the following case guarantees one more byte in the stream
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
    // for the following tag or the access_flags following constant pool,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
    // so we don't need bounds-check for reading tag.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
    u1 tag = cfs->get_u1_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
    switch (tag) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
      case JVM_CONSTANT_Class :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
          cfs->guarantee_more(3, CHECK);  // name_index, tag/access_flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
          u2 name_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
          cp->klass_index_at_put(index, name_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
      case JVM_CONSTANT_Fieldref :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
          cfs->guarantee_more(5, CHECK);  // class_index, name_and_type_index, tag/access_flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
          u2 class_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
          u2 name_and_type_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
          cp->field_at_put(index, class_index, name_and_type_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
      case JVM_CONSTANT_Methodref :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
          cfs->guarantee_more(5, CHECK);  // class_index, name_and_type_index, tag/access_flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
          u2 class_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
          u2 name_and_type_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
          cp->method_at_put(index, class_index, name_and_type_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
      case JVM_CONSTANT_InterfaceMethodref :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
          cfs->guarantee_more(5, CHECK);  // class_index, name_and_type_index, tag/access_flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
          u2 class_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
          u2 name_and_type_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
          cp->interface_method_at_put(index, class_index, name_and_type_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
      case JVM_CONSTANT_String :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
          cfs->guarantee_more(3, CHECK);  // string_index, tag/access_flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
          u2 string_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
          cp->string_index_at_put(index, string_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
        break;
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   150
      case JVM_CONSTANT_MethodHandle :
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   151
      case JVM_CONSTANT_MethodType :
8675
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
   152
        if (_major_version < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) {
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   153
          classfile_parse_error(
8675
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
   154
            "Class file version does not support constant tag %u in class file %s",
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
   155
            tag, CHECK);
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
   156
        }
8883
5569135acca3 6817525: turn on method handle functionality by default for JSR 292
twisti
parents: 8725
diff changeset
   157
        if (!EnableInvokeDynamic) {
8675
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
   158
          classfile_parse_error(
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
   159
            "This JVM does not support constant tag %u in class file %s",
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   160
            tag, CHECK);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   161
        }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   162
        if (tag == JVM_CONSTANT_MethodHandle) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   163
          cfs->guarantee_more(4, CHECK);  // ref_kind, method_index, tag/access_flags
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   164
          u1 ref_kind = cfs->get_u1_fast();
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   165
          u2 method_index = cfs->get_u2_fast();
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   166
          cp->method_handle_index_at_put(index, ref_kind, method_index);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   167
        } else if (tag == JVM_CONSTANT_MethodType) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   168
          cfs->guarantee_more(3, CHECK);  // signature_index, tag/access_flags
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   169
          u2 signature_index = cfs->get_u2_fast();
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   170
          cp->method_type_index_at_put(index, signature_index);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   171
        } else {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   172
          ShouldNotReachHere();
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   173
        }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   174
        break;
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   175
      case JVM_CONSTANT_InvokeDynamic :
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   176
        {
8675
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
   177
          if (_major_version < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) {
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   178
            classfile_parse_error(
8675
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
   179
              "Class file version does not support constant tag %u in class file %s",
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
   180
              tag, CHECK);
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
   181
          }
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
   182
          if (!EnableInvokeDynamic) {
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
   183
            classfile_parse_error(
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8653
diff changeset
   184
              "This JVM does not support constant tag %u in class file %s",
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   185
              tag, CHECK);
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   186
          }
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
   187
          cfs->guarantee_more(5, CHECK);  // bsm_index, nt, tag/access_flags
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
   188
          u2 bootstrap_specifier_index = cfs->get_u2_fast();
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
   189
          u2 name_and_type_index = cfs->get_u2_fast();
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
   190
          if (_max_bootstrap_specifier_index < (int) bootstrap_specifier_index)
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
   191
            _max_bootstrap_specifier_index = (int) bootstrap_specifier_index;  // collect for later
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
   192
          cp->invoke_dynamic_at_put(index, bootstrap_specifier_index, name_and_type_index);
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   193
        }
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   194
        break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
      case JVM_CONSTANT_Integer :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
          cfs->guarantee_more(5, CHECK);  // bytes, tag/access_flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
          u4 bytes = cfs->get_u4_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
          cp->int_at_put(index, (jint) bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
      case JVM_CONSTANT_Float :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
          cfs->guarantee_more(5, CHECK);  // bytes, tag/access_flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
          u4 bytes = cfs->get_u4_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
          cp->float_at_put(index, *(jfloat*)&bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
      case JVM_CONSTANT_Long :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
        // A mangled type might cause you to overrun allocated memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
        guarantee_property(index+1 < length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
                           "Invalid constant pool entry %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
                           index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
          cfs->guarantee_more(9, CHECK);  // bytes, tag/access_flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
          u8 bytes = cfs->get_u8_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
          cp->long_at_put(index, bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
        index++;   // Skip entry following eigth-byte constant, see JVM book p. 98
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
      case JVM_CONSTANT_Double :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
        // A mangled type might cause you to overrun allocated memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
        guarantee_property(index+1 < length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
                           "Invalid constant pool entry %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
                           index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
          cfs->guarantee_more(9, CHECK);  // bytes, tag/access_flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
          u8 bytes = cfs->get_u8_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
          cp->double_at_put(index, *(jdouble*)&bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
        index++;   // Skip entry following eigth-byte constant, see JVM book p. 98
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
      case JVM_CONSTANT_NameAndType :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
          cfs->guarantee_more(5, CHECK);  // name_index, signature_index, tag/access_flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
          u2 name_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
          u2 signature_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
          cp->name_and_type_at_put(index, name_index, signature_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
      case JVM_CONSTANT_Utf8 :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
          cfs->guarantee_more(2, CHECK);  // utf8_length
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
          u2  utf8_length = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
          u1* utf8_buffer = cfs->get_u1_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
          assert(utf8_buffer != NULL, "null utf8 buffer");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
          // Got utf8 string, guarantee utf8_length+1 bytes, set stream position forward.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
          cfs->guarantee_more(utf8_length+1, CHECK);  // utf8 string, tag/access_flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
          cfs->skip_u1_fast(utf8_length);
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   250
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
          // Before storing the symbol, make sure it's legal
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
          if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
            verify_legal_utf8((unsigned char*)utf8_buffer, utf8_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
8883
5569135acca3 6817525: turn on method handle functionality by default for JSR 292
twisti
parents: 8725
diff changeset
   256
          if (EnableInvokeDynamic && has_cp_patch_at(index)) {
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   257
            Handle patch = clear_cp_patch_at(index);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   258
            guarantee_property(java_lang_String::is_instance(patch()),
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   259
                               "Illegal utf8 patch at %d in class file %s",
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   260
                               index, CHECK);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   261
            char* str = java_lang_String::as_utf8_string(patch());
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   262
            // (could use java_lang_String::as_symbol instead, but might as well batch them)
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   263
            utf8_buffer = (u1*) str;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   264
            utf8_length = (int) strlen(str);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   265
          }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   266
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
          unsigned int hash;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   268
          Symbol* result = SymbolTable::lookup_only((char*)utf8_buffer, utf8_length, hash);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
          if (result == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
            names[names_count] = (char*)utf8_buffer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
            lengths[names_count] = utf8_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
            indices[names_count] = index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
            hashValues[names_count++] = hash;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
            if (names_count == SymbolTable::symbol_alloc_batch_size) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   275
              SymbolTable::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
              names_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
            cp->symbol_at_put(index, result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
      default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
        classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
          "Unknown constant tag %u in class file %s", tag, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  // Allocate the remaining symbols
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  if (names_count > 0) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   292
    SymbolTable::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  // Copy _current pointer of local copy back to stream().
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  assert(cfs0->current() == old_current, "non-exclusive use of stream()");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  cfs0->set_current(cfs1.current());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   302
// This class unreferences constant pool symbols if an error has occurred
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   303
// while parsing the class before it is assigned into the class.
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   304
// If it gets an error after that it is unloaded and the constant pool will
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   305
// be cleaned up then.
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   306
class ConstantPoolCleaner : public StackObj {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   307
  constantPoolHandle _cphandle;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   308
  bool               _in_error;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   309
 public:
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   310
  ConstantPoolCleaner(constantPoolHandle cp) : _cphandle(cp), _in_error(true) {}
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   311
  ~ConstantPoolCleaner() {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   312
    if (_in_error && _cphandle.not_null()) {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   313
      _cphandle->unreference_symbols();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   314
    }
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   315
  }
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   316
  void set_in_error(bool clean) { _in_error = clean; }
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   317
};
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   318
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
bool inline valid_cp_range(int index, int length) { return (index > 0 && index < length); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
constantPoolHandle ClassFileParser::parse_constant_pool(TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  constantPoolHandle nullHandle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  cfs->guarantee_more(3, CHECK_(nullHandle)); // length, first cp tag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  u2 length = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  guarantee_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
    length >= 1, "Illegal constant pool size %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
    length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  constantPoolOop constant_pool =
1894
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 1661
diff changeset
   331
                      oopFactory::new_constantPool(length,
8296
b1c2163e4e59 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents: 8076
diff changeset
   332
                                                   oopDesc::IsSafeConc,
1894
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 1661
diff changeset
   333
                                                   CHECK_(nullHandle));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  constantPoolHandle cp (THREAD, constant_pool);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  cp->set_partially_loaded();    // Enables heap verify to work on partial constantPoolOops
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   337
  ConstantPoolCleaner cp_in_error(cp); // set constant pool to be cleaned up.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  // parsing constant pool entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  parse_constant_pool_entries(cp, length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  int index = 1;  // declared outside of loops for portability
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  // first verification pass - validate cross references and fixup class and string constants
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  for (index = 1; index < length; index++) {          // Index 0 is unused
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
   346
    jbyte tag = cp->tag_at(index).value();
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
   347
    switch (tag) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
      case JVM_CONSTANT_Class :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
        ShouldNotReachHere();     // Only JVM_CONSTANT_ClassIndex should be present
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
      case JVM_CONSTANT_Fieldref :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
        // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
      case JVM_CONSTANT_Methodref :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
        // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
      case JVM_CONSTANT_InterfaceMethodref : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
        if (!_need_verify) break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
        int klass_ref_index = cp->klass_ref_index_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
        int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
        check_property(valid_cp_range(klass_ref_index, length) &&
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   360
                       is_klass_reference(cp, klass_ref_index),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
                       "Invalid constant pool index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
                       klass_ref_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
                       CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
        check_property(valid_cp_range(name_and_type_ref_index, length) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
                       cp->tag_at(name_and_type_ref_index).is_name_and_type(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
                       "Invalid constant pool index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
                       name_and_type_ref_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
                       CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
      case JVM_CONSTANT_String :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
        ShouldNotReachHere();     // Only JVM_CONSTANT_StringIndex should be present
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
      case JVM_CONSTANT_Integer :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
      case JVM_CONSTANT_Float :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
      case JVM_CONSTANT_Long :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
      case JVM_CONSTANT_Double :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
        index++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
        check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
          (index < length && cp->tag_at(index).is_invalid()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
          "Improper constant pool long/double index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
          index, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
      case JVM_CONSTANT_NameAndType : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
        if (!_need_verify) break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
        int name_ref_index = cp->name_ref_index_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
        int signature_ref_index = cp->signature_ref_index_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
        check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
          valid_cp_range(name_ref_index, length) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
            cp->tag_at(name_ref_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
          "Invalid constant pool index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
          name_ref_index, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
        check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
          valid_cp_range(signature_ref_index, length) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
            cp->tag_at(signature_ref_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
          "Invalid constant pool index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
          signature_ref_index, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
      case JVM_CONSTANT_Utf8 :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
      case JVM_CONSTANT_UnresolvedClass :         // fall-through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
      case JVM_CONSTANT_UnresolvedClassInError:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
        ShouldNotReachHere();     // Only JVM_CONSTANT_ClassIndex should be present
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
      case JVM_CONSTANT_ClassIndex :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
          int class_index = cp->klass_index_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
          check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
            valid_cp_range(class_index, length) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
              cp->tag_at(class_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
            "Invalid constant pool index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
            class_index, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
          cp->unresolved_klass_at_put(index, cp->symbol_at(class_index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
      case JVM_CONSTANT_UnresolvedString :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
        ShouldNotReachHere();     // Only JVM_CONSTANT_StringIndex should be present
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
      case JVM_CONSTANT_StringIndex :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
          int string_index = cp->string_index_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
          check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
            valid_cp_range(string_index, length) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
              cp->tag_at(string_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
            "Invalid constant pool index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
            string_index, CHECK_(nullHandle));
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   430
          Symbol* sym = cp->symbol_at(string_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
          cp->unresolved_string_at_put(index, sym);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
        break;
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   434
      case JVM_CONSTANT_MethodHandle :
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   435
        {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   436
          int ref_index = cp->method_handle_index_at(index);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   437
          check_property(
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   438
            valid_cp_range(ref_index, length) &&
8883
5569135acca3 6817525: turn on method handle functionality by default for JSR 292
twisti
parents: 8725
diff changeset
   439
                EnableInvokeDynamic,
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   440
              "Invalid constant pool index %u in class file %s",
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   441
              ref_index, CHECK_(nullHandle));
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   442
          constantTag tag = cp->tag_at(ref_index);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   443
          int ref_kind  = cp->method_handle_ref_kind_at(index);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   444
          switch (ref_kind) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   445
          case JVM_REF_getField:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   446
          case JVM_REF_getStatic:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   447
          case JVM_REF_putField:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   448
          case JVM_REF_putStatic:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   449
            check_property(
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   450
              tag.is_field(),
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   451
              "Invalid constant pool index %u in class file %s (not a field)",
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   452
              ref_index, CHECK_(nullHandle));
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   453
            break;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   454
          case JVM_REF_invokeVirtual:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   455
          case JVM_REF_invokeStatic:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   456
          case JVM_REF_invokeSpecial:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   457
          case JVM_REF_newInvokeSpecial:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   458
            check_property(
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   459
              tag.is_method(),
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   460
              "Invalid constant pool index %u in class file %s (not a method)",
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   461
              ref_index, CHECK_(nullHandle));
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   462
            break;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   463
          case JVM_REF_invokeInterface:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   464
            check_property(
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   465
              tag.is_interface_method(),
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   466
              "Invalid constant pool index %u in class file %s (not an interface method)",
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   467
              ref_index, CHECK_(nullHandle));
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   468
            break;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   469
          default:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   470
            classfile_parse_error(
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   471
              "Bad method handle kind at constant pool index %u in class file %s",
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   472
              index, CHECK_(nullHandle));
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   473
          }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   474
          // Keep the ref_index unchanged.  It will be indirected at link-time.
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   475
        }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   476
        break;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   477
      case JVM_CONSTANT_MethodType :
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   478
        {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   479
          int ref_index = cp->method_type_index_at(index);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   480
          check_property(
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   481
            valid_cp_range(ref_index, length) &&
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   482
                cp->tag_at(ref_index).is_utf8() &&
8883
5569135acca3 6817525: turn on method handle functionality by default for JSR 292
twisti
parents: 8725
diff changeset
   483
                EnableInvokeDynamic,
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   484
              "Invalid constant pool index %u in class file %s",
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   485
              ref_index, CHECK_(nullHandle));
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   486
        }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   487
        break;
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   488
      case JVM_CONSTANT_InvokeDynamic :
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   489
        {
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   490
          int name_and_type_ref_index = cp->invoke_dynamic_name_and_type_ref_index_at(index);
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   491
          check_property(valid_cp_range(name_and_type_ref_index, length) &&
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   492
                         cp->tag_at(name_and_type_ref_index).is_name_and_type(),
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   493
                         "Invalid constant pool index %u in class file %s",
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   494
                         name_and_type_ref_index,
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   495
                         CHECK_(nullHandle));
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
   496
          // bootstrap specifier index must be checked later, when BootstrapMethods attr is available
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   497
          break;
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5888
diff changeset
   498
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
      default:
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 5250
diff changeset
   500
        fatal(err_msg("bad constant pool tag value %u",
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 5250
diff changeset
   501
                      cp->tag_at(index).value()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
        ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    } // end of switch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  } // end of for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   507
  if (_cp_patches != NULL) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   508
    // need to treat this_class specially...
8883
5569135acca3 6817525: turn on method handle functionality by default for JSR 292
twisti
parents: 8725
diff changeset
   509
    assert(EnableInvokeDynamic, "");
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   510
    int this_class_index;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   511
    {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   512
      cfs->guarantee_more(8, CHECK_(nullHandle));  // flags, this_class, super_class, infs_len
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   513
      u1* mark = cfs->current();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   514
      u2 flags         = cfs->get_u2_fast();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   515
      this_class_index = cfs->get_u2_fast();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   516
      cfs->set_current(mark);  // revert to mark
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   517
    }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   518
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   519
    for (index = 1; index < length; index++) {          // Index 0 is unused
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   520
      if (has_cp_patch_at(index)) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   521
        guarantee_property(index != this_class_index,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   522
                           "Illegal constant pool patch to self at %d in class file %s",
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   523
                           index, CHECK_(nullHandle));
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   524
        patch_constant_pool(cp, index, cp_patch_at(index), CHECK_(nullHandle));
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   525
      }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   526
    }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   527
    // Ensure that all the patches have been used.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   528
    for (index = 0; index < _cp_patches->length(); index++) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   529
      guarantee_property(!has_cp_patch_at(index),
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   530
                         "Unused constant pool patch at %d in class file %s",
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   531
                         index, CHECK_(nullHandle));
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   532
    }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   533
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   534
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  if (!_need_verify) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   536
    cp_in_error.set_in_error(false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    return cp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  // second verification pass - checks the strings are of the right format.
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   541
  // but not yet to the other entries
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  for (index = 1; index < length; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
    jbyte tag = cp->tag_at(index).value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
    switch (tag) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
      case JVM_CONSTANT_UnresolvedClass: {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   546
        Symbol*  class_name = cp->unresolved_klass_at(index);
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   547
        // check the name, even if _cp_patches will overwrite it
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
        verify_legal_class_name(class_name, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
      }
5709
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   551
      case JVM_CONSTANT_NameAndType: {
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   552
        if (_need_verify && _major_version >= JAVA_7_VERSION) {
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   553
          int sig_index = cp->signature_ref_index_at(index);
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   554
          int name_index = cp->name_ref_index_at(index);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   555
          Symbol*  name = cp->symbol_at(name_index);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   556
          Symbol*  sig = cp->symbol_at(sig_index);
5709
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   557
          if (sig->byte_at(0) == JVM_SIGNATURE_FUNC) {
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   558
            verify_legal_method_signature(name, sig, CHECK_(nullHandle));
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   559
          } else {
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   560
            verify_legal_field_signature(name, sig, CHECK_(nullHandle));
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   561
          }
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   562
        }
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   563
        break;
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   564
      }
9117
30d757743e56 7012087: JSR 292 Misleading exception message for a non-bound MH for a virtual method
jrose
parents: 9116
diff changeset
   565
      case JVM_CONSTANT_InvokeDynamic:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
      case JVM_CONSTANT_Fieldref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
      case JVM_CONSTANT_Methodref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
      case JVM_CONSTANT_InterfaceMethodref: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
        int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
        // already verified to be utf8
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
        int name_ref_index = cp->name_ref_index_at(name_and_type_ref_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
        // already verified to be utf8
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
        int signature_ref_index = cp->signature_ref_index_at(name_and_type_ref_index);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   574
        Symbol*  name = cp->symbol_at(name_ref_index);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   575
        Symbol*  signature = cp->symbol_at(signature_ref_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
        if (tag == JVM_CONSTANT_Fieldref) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
          verify_legal_field_name(name, CHECK_(nullHandle));
5709
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   578
          if (_need_verify && _major_version >= JAVA_7_VERSION) {
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   579
            // Signature is verified above, when iterating NameAndType_info.
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   580
            // Need only to be sure it's the right type.
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   581
            if (signature->byte_at(0) == JVM_SIGNATURE_FUNC) {
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   582
              throwIllegalSignature(
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   583
                  "Field", name, signature, CHECK_(nullHandle));
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   584
            }
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   585
          } else {
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   586
            verify_legal_field_signature(name, signature, CHECK_(nullHandle));
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   587
          }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
          verify_legal_method_name(name, CHECK_(nullHandle));
5709
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   590
          if (_need_verify && _major_version >= JAVA_7_VERSION) {
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   591
            // Signature is verified above, when iterating NameAndType_info.
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   592
            // Need only to be sure it's the right type.
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   593
            if (signature->byte_at(0) != JVM_SIGNATURE_FUNC) {
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   594
              throwIllegalSignature(
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   595
                  "Method", name, signature, CHECK_(nullHandle));
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   596
            }
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   597
          } else {
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   598
            verify_legal_method_signature(name, signature, CHECK_(nullHandle));
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
   599
          }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
          if (tag == JVM_CONSTANT_Methodref) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
            // 4509014: If a class method name begins with '<', it must be "<init>".
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   602
            assert(name != NULL, "method name in constant pool is null");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
            unsigned int name_len = name->utf8_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
            assert(name_len > 0, "bad method name");  // already verified as legal name
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
            if (name->byte_at(0) == '<') {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   606
              if (name != vmSymbols::object_initializer_name()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
                classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
                  "Bad method name at constant pool index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
                  name_ref_index, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
      }
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   616
      case JVM_CONSTANT_MethodHandle: {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   617
        int ref_index = cp->method_handle_index_at(index);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   618
        int ref_kind  = cp->method_handle_ref_kind_at(index);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   619
        switch (ref_kind) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   620
        case JVM_REF_invokeVirtual:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   621
        case JVM_REF_invokeStatic:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   622
        case JVM_REF_invokeSpecial:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   623
        case JVM_REF_newInvokeSpecial:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   624
          {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   625
            int name_and_type_ref_index = cp->name_and_type_ref_index_at(ref_index);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   626
            int name_ref_index = cp->name_ref_index_at(name_and_type_ref_index);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   627
            Symbol*  name = cp->symbol_at(name_ref_index);
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   628
            if (ref_kind == JVM_REF_newInvokeSpecial) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   629
              if (name != vmSymbols::object_initializer_name()) {
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   630
                classfile_parse_error(
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   631
                  "Bad constructor name at constant pool index %u in class file %s",
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   632
                  name_ref_index, CHECK_(nullHandle));
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   633
              }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   634
            } else {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   635
              if (name == vmSymbols::object_initializer_name()) {
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   636
                classfile_parse_error(
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   637
                  "Bad method name at constant pool index %u in class file %s",
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   638
                  name_ref_index, CHECK_(nullHandle));
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   639
              }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   640
            }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   641
          }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   642
          break;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   643
          // Other ref_kinds are already fully checked in previous pass.
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   644
        }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   645
        break;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   646
      }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   647
      case JVM_CONSTANT_MethodType: {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   648
        Symbol* no_name = vmSymbols::type_name(); // place holder
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   649
        Symbol*  signature = cp->method_type_signature_at(index);
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   650
        verify_legal_method_signature(no_name, signature, CHECK_(nullHandle));
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   651
        break;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   652
      }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   653
      case JVM_CONSTANT_Utf8: {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   654
        assert(cp->symbol_at(index)->refcount() != 0, "count corrupted");
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   655
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
    }  // end of switch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  }  // end of for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   659
  cp_in_error.set_in_error(false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  return cp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   664
void ClassFileParser::patch_constant_pool(constantPoolHandle cp, int index, Handle patch, TRAPS) {
8883
5569135acca3 6817525: turn on method handle functionality by default for JSR 292
twisti
parents: 8725
diff changeset
   665
  assert(EnableInvokeDynamic, "");
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   666
  BasicType patch_type = T_VOID;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   667
  switch (cp->tag_at(index).value()) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   668
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   669
  case JVM_CONSTANT_UnresolvedClass :
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   670
    // Patching a class means pre-resolving it.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   671
    // The name in the constant pool is ignored.
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   672
    if (java_lang_Class::is_instance(patch())) {
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   673
      guarantee_property(!java_lang_Class::is_primitive(patch()),
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   674
                         "Illegal class patch at %d in class file %s",
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   675
                         index, CHECK);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   676
      cp->klass_at_put(index, java_lang_Class::as_klassOop(patch()));
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   677
    } else {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   678
      guarantee_property(java_lang_String::is_instance(patch()),
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   679
                         "Illegal class patch at %d in class file %s",
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   680
                         index, CHECK);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   681
      Symbol* name = java_lang_String::as_symbol(patch(), CHECK);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   682
      cp->unresolved_klass_at_put(index, name);
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   683
    }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   684
    break;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   685
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   686
  case JVM_CONSTANT_UnresolvedString :
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   687
    // Patching a string means pre-resolving it.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   688
    // The spelling in the constant pool is ignored.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   689
    // The constant reference may be any object whatever.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   690
    // If it is not a real interned string, the constant is referred
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   691
    // to as a "pseudo-string", and must be presented to the CP
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   692
    // explicitly, because it may require scavenging.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   693
    cp->pseudo_string_at_put(index, patch());
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   694
    break;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   695
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   696
  case JVM_CONSTANT_Integer : patch_type = T_INT;    goto patch_prim;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   697
  case JVM_CONSTANT_Float :   patch_type = T_FLOAT;  goto patch_prim;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   698
  case JVM_CONSTANT_Long :    patch_type = T_LONG;   goto patch_prim;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   699
  case JVM_CONSTANT_Double :  patch_type = T_DOUBLE; goto patch_prim;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   700
  patch_prim:
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   701
    {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   702
      jvalue value;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   703
      BasicType value_type = java_lang_boxing_object::get_value(patch(), &value);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   704
      guarantee_property(value_type == patch_type,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   705
                         "Illegal primitive patch at %d in class file %s",
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   706
                         index, CHECK);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   707
      switch (value_type) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   708
      case T_INT:    cp->int_at_put(index,   value.i); break;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   709
      case T_FLOAT:  cp->float_at_put(index, value.f); break;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   710
      case T_LONG:   cp->long_at_put(index,  value.j); break;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   711
      case T_DOUBLE: cp->double_at_put(index, value.d); break;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   712
      default:       assert(false, "");
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   713
      }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   714
    }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   715
    break;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   716
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   717
  default:
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   718
    // %%% TODO: put method handles into CONSTANT_InterfaceMethodref, etc.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   719
    guarantee_property(!has_cp_patch_at(index),
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   720
                       "Illegal unexpected patch at %d in class file %s",
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   721
                       index, CHECK);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   722
    return;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   723
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   724
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   725
  // On fall-through, mark the patch as used.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   726
  clear_cp_patch_at(index);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   727
}
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   728
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   729
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   730
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
class NameSigHash: public ResourceObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
 public:
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   733
  Symbol*       _name;       // name
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   734
  Symbol*       _sig;        // signature
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
  NameSigHash*  _next;       // Next entry in hash table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
#define HASH_ROW_SIZE 256
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   741
unsigned int hash(Symbol* name, Symbol* sig) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
  unsigned int raw_hash = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  raw_hash += ((unsigned int)(uintptr_t)name) >> (LogHeapWordSize + 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
  raw_hash += ((unsigned int)(uintptr_t)sig) >> LogHeapWordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  return (raw_hash + (unsigned int)(uintptr_t)name) % HASH_ROW_SIZE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
void initialize_hashtable(NameSigHash** table) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  memset((void*)table, 0, sizeof(NameSigHash*) * HASH_ROW_SIZE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
// Return false if the name/sig combination is found in table.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
// Return true if no duplicate is found. And name/sig is added as a new entry in table.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
// The old format checker uses heap sort to find duplicates.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
// NOTE: caller should guarantee that GC doesn't happen during the life cycle
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   758
// of table since we don't expect Symbol*'s to move.
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   759
bool put_after_lookup(Symbol* name, Symbol* sig, NameSigHash** table) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
  assert(name != NULL, "name in constant pool is NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
  // First lookup for duplicates
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
  int index = hash(name, sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
  NameSigHash* entry = table[index];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
  while (entry != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
    if (entry->_name == name && entry->_sig == sig) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
    entry = entry->_next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  // No duplicate is found, allocate a new entry and fill it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  entry = new NameSigHash();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  entry->_name = name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  entry->_sig = sig;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  // Insert into hash table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  entry->_next = table[index];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  table[index] = entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
objArrayHandle ClassFileParser::parse_interfaces(constantPoolHandle cp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
                                                 int length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
                                                 Handle class_loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
                                                 Handle protection_domain,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   789
                                                 Symbol* class_name,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
                                                 TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
  assert(length > 0, "only called for length>0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
  objArrayHandle nullHandle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
  objArrayOop interface_oop = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  objArrayHandle interfaces (THREAD, interface_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
  int index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  for (index = 0; index < length; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
    u2 interface_index = cfs->get_u2(CHECK_(nullHandle));
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   800
    KlassHandle interf;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
    check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
      valid_cp_range(interface_index, cp->length()) &&
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   803
      is_klass_reference(cp, interface_index),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
      "Interface name has bad constant pool index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
      interface_index, CHECK_(nullHandle));
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   806
    if (cp->tag_at(interface_index).is_klass()) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   807
      interf = KlassHandle(THREAD, cp->resolved_klass_at(interface_index));
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   808
    } else {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   809
      Symbol*  unresolved_klass  = cp->klass_name_at(interface_index);
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   810
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   811
      // Don't need to check legal name because it's checked when parsing constant pool.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   812
      // But need to make sure it's not an array type.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   813
      guarantee_property(unresolved_klass->byte_at(0) != JVM_SIGNATURE_ARRAY,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   814
                         "Bad interface name in class file %s", CHECK_(nullHandle));
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   815
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   816
      // Call resolve_super so classcircularity is checked
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   817
      klassOop k = SystemDictionary::resolve_super_or_fail(class_name,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   818
                    unresolved_klass, class_loader, protection_domain,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   819
                    false, CHECK_(nullHandle));
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   820
      interf = KlassHandle(THREAD, k);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   821
1661
7cb0f0d385f3 6779339: turn off LinkWellKnownClasses by default pending further testing
jrose
parents: 1550
diff changeset
   822
      if (LinkWellKnownClasses)  // my super type is well known to me
7cb0f0d385f3 6779339: turn off LinkWellKnownClasses by default pending further testing
jrose
parents: 1550
diff changeset
   823
        cp->klass_at_put(interface_index, interf()); // eagerly resolve
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   824
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
    if (!Klass::cast(interf())->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
      THROW_MSG_(vmSymbols::java_lang_IncompatibleClassChangeError(), "Implementing class", nullHandle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
    interfaces->obj_at_put(index, interf());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
  if (!_need_verify || length <= 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
    return interfaces;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  // Check if there's any duplicates in interfaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
  NameSigHash** interface_names = NEW_RESOURCE_ARRAY_IN_THREAD(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
    THREAD, NameSigHash*, HASH_ROW_SIZE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  initialize_hashtable(interface_names);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  bool dup = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
    debug_only(No_Safepoint_Verifier nsv;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
    for (index = 0; index < length; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
      klassOop k = (klassOop)interfaces->obj_at(index);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   846
      Symbol* name = instanceKlass::cast(k)->name();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
      // If no duplicates, add (name, NULL) in hashtable interface_names.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
      if (!put_after_lookup(name, NULL, interface_names)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
        dup = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  if (dup) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
    classfile_parse_error("Duplicate interface name in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
                          CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
  return interfaces;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
void ClassFileParser::verify_constantvalue(int constantvalue_index, int signature_index, constantPoolHandle cp, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
  // Make sure the constant pool entry is of a type appropriate to this field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
  guarantee_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
    (constantvalue_index > 0 &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
      constantvalue_index < cp->length()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
    "Bad initial value index %u in ConstantValue attribute in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
    constantvalue_index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
  constantTag value_type = cp->tag_at(constantvalue_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  switch ( cp->basic_type_for_signature_at(signature_index) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
    case T_LONG:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
      guarantee_property(value_type.is_long(), "Inconsistent constant value type in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
    case T_FLOAT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
      guarantee_property(value_type.is_float(), "Inconsistent constant value type in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
    case T_DOUBLE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
      guarantee_property(value_type.is_double(), "Inconsistent constant value type in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
    case T_BYTE: case T_CHAR: case T_SHORT: case T_BOOLEAN: case T_INT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
      guarantee_property(value_type.is_int(), "Inconsistent constant value type in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
    case T_OBJECT:
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4478
diff changeset
   885
      guarantee_property((cp->symbol_at(signature_index)->equals("Ljava/lang/String;")
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
                         && (value_type.is_string() || value_type.is_unresolved_string())),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
                         "Bad string initial value in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
      classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
        "Unable to set initial value %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
        constantvalue_index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
// Parse attributes for a field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
void ClassFileParser::parse_field_attributes(constantPoolHandle cp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
                                             u2 attributes_count,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
                                             bool is_static, u2 signature_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
                                             u2* constantvalue_index_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
                                             bool* is_synthetic_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
                                             u2* generic_signature_index_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
                                             typeArrayHandle* field_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
                                             TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
  assert(attributes_count > 0, "length should be greater than 0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  u2 constantvalue_index = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
  u2 generic_signature_index = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  bool is_synthetic = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
  u1* runtime_visible_annotations = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  int runtime_visible_annotations_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  u1* runtime_invisible_annotations = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  int runtime_invisible_annotations_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
  while (attributes_count--) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
    cfs->guarantee_more(6, CHECK);  // attribute_name_index, attribute_length
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
    u2 attribute_name_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
    u4 attribute_length = cfs->get_u4_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
    check_property(valid_cp_range(attribute_name_index, cp->length()) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
                   cp->tag_at(attribute_name_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
                   "Invalid field attribute index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
                   attribute_name_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
                   CHECK);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
   924
    Symbol* attribute_name = cp->symbol_at(attribute_name_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
    if (is_static && attribute_name == vmSymbols::tag_constant_value()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
      // ignore if non-static
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
      if (constantvalue_index != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
        classfile_parse_error("Duplicate ConstantValue attribute in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
      check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
        attribute_length == 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
        "Invalid ConstantValue field attribute length %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
        attribute_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
      constantvalue_index = cfs->get_u2(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
      if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
        verify_constantvalue(constantvalue_index, signature_index, cp, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
    } else if (attribute_name == vmSymbols::tag_synthetic()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
      if (attribute_length != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
        classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
          "Invalid Synthetic field attribute length %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
          attribute_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
      is_synthetic = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
    } else if (attribute_name == vmSymbols::tag_deprecated()) { // 4276120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
      if (attribute_length != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
        classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
          "Invalid Deprecated field attribute length %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
          attribute_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
    } else if (_major_version >= JAVA_1_5_VERSION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
      if (attribute_name == vmSymbols::tag_signature()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
        if (attribute_length != 2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
          classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
            "Wrong size %u for field's Signature attribute in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
            attribute_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
        generic_signature_index = cfs->get_u2(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
      } else if (attribute_name == vmSymbols::tag_runtime_visible_annotations()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
        runtime_visible_annotations_length = attribute_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
        runtime_visible_annotations = cfs->get_u1_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
        assert(runtime_visible_annotations != NULL, "null visible annotations");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
        cfs->skip_u1(runtime_visible_annotations_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
      } else if (PreserveAllAnnotations && attribute_name == vmSymbols::tag_runtime_invisible_annotations()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
        runtime_invisible_annotations_length = attribute_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
        runtime_invisible_annotations = cfs->get_u1_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
        assert(runtime_invisible_annotations != NULL, "null invisible annotations");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
        cfs->skip_u1(runtime_invisible_annotations_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
        cfs->skip_u1(attribute_length, CHECK);  // Skip unknown attributes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
      cfs->skip_u1(attribute_length, CHECK);  // Skip unknown attributes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
  *constantvalue_index_addr = constantvalue_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
  *is_synthetic_addr = is_synthetic;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
  *generic_signature_index_addr = generic_signature_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
  *field_annotations = assemble_annotations(runtime_visible_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
                                            runtime_visible_annotations_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
                                            runtime_invisible_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
                                            runtime_invisible_annotations_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
                                            CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
// Field allocation types. Used for computing field offsets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
enum FieldAllocationType {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
  STATIC_OOP,           // Oops
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  STATIC_BYTE,          // Boolean, Byte, char
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
  STATIC_SHORT,         // shorts
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
  STATIC_WORD,          // ints
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
   996
  STATIC_DOUBLE,        // aligned long or double
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
  NONSTATIC_OOP,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
  NONSTATIC_BYTE,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
  NONSTATIC_SHORT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
  NONSTATIC_WORD,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
  NONSTATIC_DOUBLE,
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1002
  MAX_FIELD_ALLOCATION_TYPE,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1003
  BAD_ALLOCATION_TYPE = -1
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1006
static FieldAllocationType _basic_type_to_atype[2 * (T_CONFLICT + 1)] = {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1007
  BAD_ALLOCATION_TYPE, // 0
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1008
  BAD_ALLOCATION_TYPE, // 1
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1009
  BAD_ALLOCATION_TYPE, // 2
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1010
  BAD_ALLOCATION_TYPE, // 3
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1011
  NONSTATIC_BYTE ,     // T_BOOLEAN  =  4,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1012
  NONSTATIC_SHORT,     // T_CHAR     =  5,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1013
  NONSTATIC_WORD,      // T_FLOAT    =  6,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1014
  NONSTATIC_DOUBLE,    // T_DOUBLE   =  7,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1015
  NONSTATIC_BYTE,      // T_BYTE     =  8,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1016
  NONSTATIC_SHORT,     // T_SHORT    =  9,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1017
  NONSTATIC_WORD,      // T_INT      = 10,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1018
  NONSTATIC_DOUBLE,    // T_LONG     = 11,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1019
  NONSTATIC_OOP,       // T_OBJECT   = 12,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1020
  NONSTATIC_OOP,       // T_ARRAY    = 13,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1021
  BAD_ALLOCATION_TYPE, // T_VOID     = 14,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1022
  BAD_ALLOCATION_TYPE, // T_ADDRESS  = 15,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1023
  BAD_ALLOCATION_TYPE, // T_NARROWOOP= 16,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1024
  BAD_ALLOCATION_TYPE, // T_CONFLICT = 17,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1025
  BAD_ALLOCATION_TYPE, // 0
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1026
  BAD_ALLOCATION_TYPE, // 1
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1027
  BAD_ALLOCATION_TYPE, // 2
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1028
  BAD_ALLOCATION_TYPE, // 3
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1029
  STATIC_BYTE ,        // T_BOOLEAN  =  4,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1030
  STATIC_SHORT,        // T_CHAR     =  5,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1031
  STATIC_WORD,          // T_FLOAT    =  6,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1032
  STATIC_DOUBLE,       // T_DOUBLE   =  7,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1033
  STATIC_BYTE,         // T_BYTE     =  8,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1034
  STATIC_SHORT,        // T_SHORT    =  9,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1035
  STATIC_WORD,         // T_INT      = 10,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1036
  STATIC_DOUBLE,       // T_LONG     = 11,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1037
  STATIC_OOP,          // T_OBJECT   = 12,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1038
  STATIC_OOP,          // T_ARRAY    = 13,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1039
  BAD_ALLOCATION_TYPE, // T_VOID     = 14,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1040
  BAD_ALLOCATION_TYPE, // T_ADDRESS  = 15,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1041
  BAD_ALLOCATION_TYPE, // T_NARROWOOP= 16,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1042
  BAD_ALLOCATION_TYPE, // T_CONFLICT = 17,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1045
static FieldAllocationType basic_type_to_atype(bool is_static, BasicType type) {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1046
  assert(type >= T_BOOLEAN && type < T_VOID, "only allowable values");
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1047
  FieldAllocationType result = _basic_type_to_atype[type + (is_static ? (T_CONFLICT + 1) : 0)];
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1048
  assert(result != BAD_ALLOCATION_TYPE, "bad type");
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1049
  return result;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1050
}
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1051
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1052
class FieldAllocationCount: public ResourceObj {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1053
 public:
11412
62fe312f32c5 7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type.
jiangli
parents: 10546
diff changeset
  1054
  u2 count[MAX_FIELD_ALLOCATION_TYPE];
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1055
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1056
  FieldAllocationCount() {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1057
    for (int i = 0; i < MAX_FIELD_ALLOCATION_TYPE; i++) {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1058
      count[i] = 0;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1059
    }
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1060
  }
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1061
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1062
  FieldAllocationType update(bool is_static, BasicType type) {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1063
    FieldAllocationType atype = basic_type_to_atype(is_static, type);
11412
62fe312f32c5 7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type.
jiangli
parents: 10546
diff changeset
  1064
    // Make sure there is no overflow with injected fields.
62fe312f32c5 7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type.
jiangli
parents: 10546
diff changeset
  1065
    assert(count[atype] < 0xFFFF, "More than 65535 fields");
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1066
    count[atype]++;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1067
    return atype;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1068
  }
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1069
};
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1070
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1071
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1072
typeArrayHandle ClassFileParser::parse_fields(Symbol* class_name,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1073
                                              constantPoolHandle cp, bool is_interface,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1074
                                              FieldAllocationCount *fac,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1075
                                              objArrayHandle* fields_annotations,
11412
62fe312f32c5 7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type.
jiangli
parents: 10546
diff changeset
  1076
                                              u2* java_fields_count_ptr, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
  typeArrayHandle nullHandle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  cfs->guarantee_more(2, CHECK_(nullHandle));  // length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
  u2 length = cfs->get_u2_fast();
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1081
  *java_fields_count_ptr = length;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1082
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1083
  int num_injected = 0;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1084
  InjectedField* injected = JavaClasses::get_injected(class_name, &num_injected);
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1085
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
  // Tuples of shorts [access, name index, sig index, initial value index, byte offset, generic signature index]
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1087
  typeArrayOop new_fields = oopFactory::new_permanent_shortArray((length + num_injected) * FieldInfo::field_slots, CHECK_(nullHandle));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
  typeArrayHandle fields(THREAD, new_fields);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
  typeArrayHandle field_annotations;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
  for (int n = 0; n < length; n++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
    cfs->guarantee_more(8, CHECK_(nullHandle));  // access_flags, name_index, descriptor_index, attributes_count
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
    AccessFlags access_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
    jint flags = cfs->get_u2_fast() & JVM_RECOGNIZED_FIELD_MODIFIERS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
    verify_legal_field_modifiers(flags, is_interface, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
    access_flags.set_flags(flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
    u2 name_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
    int cp_size = cp->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
    check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
      valid_cp_range(name_index, cp_size) && cp->tag_at(name_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
      "Invalid constant pool index %u for field name in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
      name_index, CHECK_(nullHandle));
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  1105
    Symbol*  name = cp->symbol_at(name_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
    verify_legal_field_name(name, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
    u2 signature_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
    check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
      valid_cp_range(signature_index, cp_size) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
        cp->tag_at(signature_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
      "Invalid constant pool index %u for field signature in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
      signature_index, CHECK_(nullHandle));
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  1114
    Symbol*  sig = cp->symbol_at(signature_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
    verify_legal_field_signature(name, sig, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
    u2 constantvalue_index = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
    bool is_synthetic = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
    u2 generic_signature_index = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
    bool is_static = access_flags.is_static();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
    u2 attributes_count = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
    if (attributes_count > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
      parse_field_attributes(cp, attributes_count, is_static, signature_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
                             &constantvalue_index, &is_synthetic,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
                             &generic_signature_index, &field_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
                             CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
      if (field_annotations.not_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
        if (fields_annotations->is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
          objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
          *fields_annotations = objArrayHandle(THREAD, md);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
        (*fields_annotations)->obj_at_put(n, field_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
      if (is_synthetic) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
        access_flags.set_is_synthetic();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1140
    FieldInfo* field = FieldInfo::from_field_array(fields(), n);
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1141
    field->initialize(access_flags.as_short(),
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1142
                      name_index,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1143
                      signature_index,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1144
                      constantvalue_index,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1145
                      generic_signature_index,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1146
                      0);
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1147
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1148
    BasicType type = cp->basic_type_for_signature_at(signature_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
    // Remember how many oops we encountered and compute allocation type
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1151
    FieldAllocationType atype = fac->update(is_static, type);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
    // The correct offset is computed later (all oop fields will be located together)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
    // We temporarily store the allocation type in the offset field
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1155
    field->set_offset(atype);
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1156
  }
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1157
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1158
  if (num_injected != 0) {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1159
    int index = length;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1160
    for (int n = 0; n < num_injected; n++) {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1161
      // Check for duplicates
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1162
      if (injected[n].may_be_java) {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1163
        Symbol* name      = injected[n].name();
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1164
        Symbol* signature = injected[n].signature();
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1165
        bool duplicate = false;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1166
        for (int i = 0; i < length; i++) {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1167
          FieldInfo* f = FieldInfo::from_field_array(fields(), i);
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1168
          if (name      == cp->symbol_at(f->name_index()) &&
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1169
              signature == cp->symbol_at(f->signature_index())) {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1170
            // Symbol is desclared in Java so skip this one
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1171
            duplicate = true;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1172
            break;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1173
          }
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1174
        }
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1175
        if (duplicate) {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1176
          // These will be removed from the field array at the end
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1177
          continue;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1178
        }
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1179
      }
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1180
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1181
      // Injected field
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1182
      FieldInfo* field = FieldInfo::from_field_array(fields(), index);
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1183
      field->initialize(JVM_ACC_FIELD_INTERNAL,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1184
                        injected[n].name_index,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1185
                        injected[n].signature_index,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1186
                        0,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1187
                        0,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1188
                        0);
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1189
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1190
      BasicType type = FieldType::basic_type(injected[n].signature());
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1191
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1192
      // Remember how many oops we encountered and compute allocation type
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1193
      FieldAllocationType atype = fac->update(false, type);
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1194
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1195
      // The correct offset is computed later (all oop fields will be located together)
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1196
      // We temporarily store the allocation type in the offset field
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1197
      field->set_offset(atype);
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1198
      index++;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1199
    }
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1200
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1201
    if (index < length + num_injected) {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1202
      // sometimes injected fields already exist in the Java source so
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1203
      // the fields array could be too long.  In that case trim the
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1204
      // fields array.
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1205
      new_fields = oopFactory::new_permanent_shortArray(index * FieldInfo::field_slots, CHECK_(nullHandle));
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1206
      for (int i = 0; i < index * FieldInfo::field_slots; i++) {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1207
        new_fields->short_at_put(i, fields->short_at(i));
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1208
      }
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1209
      fields = new_fields;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1210
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
  if (_need_verify && length > 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
    // Check duplicated fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
    NameSigHash** names_and_sigs = NEW_RESOURCE_ARRAY_IN_THREAD(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
      THREAD, NameSigHash*, HASH_ROW_SIZE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
    initialize_hashtable(names_and_sigs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
    bool dup = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
      debug_only(No_Safepoint_Verifier nsv;)
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1222
      for (AllFieldStream fs(fields, cp); !fs.done(); fs.next()) {
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1223
        Symbol* name = fs.name();
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  1224
        Symbol* sig = fs.signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
        // If no duplicates, add name/signature in hashtable names_and_sigs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
        if (!put_after_lookup(name, sig, names_and_sigs)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
          dup = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
    if (dup) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
      classfile_parse_error("Duplicate field name&signature in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
                            CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
  return fields;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
static void copy_u2_with_conversion(u2* dest, u2* src, int length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
  while (length-- > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
    *dest++ = Bytes::get_Java_u2((u1*) (src++));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
typeArrayHandle ClassFileParser::parse_exception_table(u4 code_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
                                                       u4 exception_table_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
                                                       constantPoolHandle cp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
                                                       TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
  typeArrayHandle nullHandle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
  // 4-tuples of ints [start_pc, end_pc, handler_pc, catch_type index]
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
  typeArrayOop eh = oopFactory::new_permanent_intArray(exception_table_length*4, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
  typeArrayHandle exception_handlers = typeArrayHandle(THREAD, eh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
  int index = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
  cfs->guarantee_more(8 * exception_table_length, CHECK_(nullHandle)); // start_pc, end_pc, handler_pc, catch_type_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
  for (unsigned int i = 0; i < exception_table_length; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
    u2 start_pc = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
    u2 end_pc = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
    u2 handler_pc = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
    u2 catch_type_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
    // Will check legal target after parsing code array in verifier.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
    if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
      guarantee_property((start_pc < end_pc) && (end_pc <= code_length),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
                         "Illegal exception table range in class file %s", CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
      guarantee_property(handler_pc < code_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
                         "Illegal exception table handler in class file %s", CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
      if (catch_type_index != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
        guarantee_property(valid_cp_range(catch_type_index, cp->length()) &&
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  1275
                           is_klass_reference(cp, catch_type_index),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
                           "Catch type in exception table has bad constant type in class file %s", CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
    exception_handlers->int_at_put(index++, start_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
    exception_handlers->int_at_put(index++, end_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
    exception_handlers->int_at_put(index++, handler_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
    exception_handlers->int_at_put(index++, catch_type_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
  return exception_handlers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
void ClassFileParser::parse_linenumber_table(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
    u4 code_attribute_length, u4 code_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
    CompressedLineNumberWriteStream** write_stream, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
  unsigned int num_entries = cfs->get_u2(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
  // Each entry is a u2 start_pc, and a u2 line_number
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
  unsigned int length_in_bytes = num_entries * (sizeof(u2) + sizeof(u2));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
  // Verify line number attribute and table length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
  check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
    code_attribute_length == sizeof(u2) + length_in_bytes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
    "LineNumberTable attribute has wrong length in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
  cfs->guarantee_more(length_in_bytes, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
  if ((*write_stream) == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
    if (length_in_bytes > fixed_buffer_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
      (*write_stream) = new CompressedLineNumberWriteStream(length_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
      (*write_stream) = new CompressedLineNumberWriteStream(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
        linenumbertable_buffer, fixed_buffer_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
  while (num_entries-- > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
    u2 bci  = cfs->get_u2_fast(); // start_pc
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
    u2 line = cfs->get_u2_fast(); // line_number
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
    guarantee_property(bci < code_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
        "Invalid pc in LineNumberTable in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
    (*write_stream)->write_pair(bci, line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
// Class file LocalVariableTable elements.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
class Classfile_LVT_Element VALUE_OBJ_CLASS_SPEC {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
  u2 start_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
  u2 length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
  u2 name_cp_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
  u2 descriptor_cp_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
  u2 slot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
class LVT_Hash: public CHeapObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
  LocalVariableTableElement  *_elem;  // element
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
  LVT_Hash*                   _next;  // Next entry in hash table
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
unsigned int hash(LocalVariableTableElement *elem) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
  unsigned int raw_hash = elem->start_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
  raw_hash = elem->length        + raw_hash * 37;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
  raw_hash = elem->name_cp_index + raw_hash * 37;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
  raw_hash = elem->slot          + raw_hash * 37;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
  return raw_hash % HASH_ROW_SIZE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
void initialize_hashtable(LVT_Hash** table) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
  for (int i = 0; i < HASH_ROW_SIZE; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
    table[i] = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
void clear_hashtable(LVT_Hash** table) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
  for (int i = 0; i < HASH_ROW_SIZE; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
    LVT_Hash* current = table[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
    LVT_Hash* next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
    while (current != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
      next = current->_next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
      current->_next = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
      delete(current);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
      current = next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
    table[i] = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
LVT_Hash* LVT_lookup(LocalVariableTableElement *elem, int index, LVT_Hash** table) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
  LVT_Hash* entry = table[index];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
  /*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
   * 3-tuple start_bci/length/slot has to be unique key,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
   * so the following comparison seems to be redundant:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
   *       && elem->name_cp_index == entry->_elem->name_cp_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
   */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
  while (entry != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
    if (elem->start_bci           == entry->_elem->start_bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
     && elem->length              == entry->_elem->length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
     && elem->name_cp_index       == entry->_elem->name_cp_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
     && elem->slot                == entry->_elem->slot
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
    ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
      return entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
    entry = entry->_next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
// Return false if the local variable is found in table.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
// Return true if no duplicate is found.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
// And local variable is added as a new entry in table.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
bool LVT_put_after_lookup(LocalVariableTableElement *elem, LVT_Hash** table) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
  // First lookup for duplicates
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
  int index = hash(elem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
  LVT_Hash* entry = LVT_lookup(elem, index, table);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
  if (entry != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
  // No duplicate is found, allocate a new entry and fill it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
  if ((entry = new LVT_Hash()) == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
  entry->_elem = elem;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
  // Insert into hash table
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
  entry->_next = table[index];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
  table[index] = entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1411
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
void copy_lvt_element(Classfile_LVT_Element *src, LocalVariableTableElement *lvt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
  lvt->start_bci           = Bytes::get_Java_u2((u1*) &src->start_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
  lvt->length              = Bytes::get_Java_u2((u1*) &src->length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
  lvt->name_cp_index       = Bytes::get_Java_u2((u1*) &src->name_cp_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
  lvt->descriptor_cp_index = Bytes::get_Java_u2((u1*) &src->descriptor_cp_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
  lvt->signature_cp_index  = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
  lvt->slot                = Bytes::get_Java_u2((u1*) &src->slot);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
// Function is used to parse both attributes:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
//       LocalVariableTable (LVT) and LocalVariableTypeTable (LVTT)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
u2* ClassFileParser::parse_localvariable_table(u4 code_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
                                               u2 max_locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
                                               u4 code_attribute_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
                                               constantPoolHandle cp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
                                               u2* localvariable_table_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
                                               bool isLVTT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
                                               TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
  const char * tbl_name = (isLVTT) ? "LocalVariableTypeTable" : "LocalVariableTable";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
  *localvariable_table_length = cfs->get_u2(CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
  unsigned int size = (*localvariable_table_length) * sizeof(Classfile_LVT_Element) / sizeof(u2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
  // Verify local variable table attribute has right length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
  if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
    guarantee_property(code_attribute_length == (sizeof(*localvariable_table_length) + size * sizeof(u2)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
                       "%s has wrong length in class file %s", tbl_name, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
  u2* localvariable_table_start = cfs->get_u2_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
  assert(localvariable_table_start != NULL, "null local variable table");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
  if (!_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
    cfs->skip_u2_fast(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
    cfs->guarantee_more(size * 2, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
    for(int i = 0; i < (*localvariable_table_length); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
      u2 start_pc = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
      u2 length = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
      u2 name_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
      u2 descriptor_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
      u2 index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
      // Assign to a u4 to avoid overflow
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
      u4 end_pc = (u4)start_pc + (u4)length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
      if (start_pc >= code_length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
        classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
          "Invalid start_pc %u in %s in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
          start_pc, tbl_name, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
      if (end_pc > code_length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
        classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
          "Invalid length %u in %s in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
          length, tbl_name, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
      int cp_size = cp->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
      guarantee_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
        valid_cp_range(name_index, cp_size) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
          cp->tag_at(name_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
        "Name index %u in %s has bad constant type in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
        name_index, tbl_name, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
      guarantee_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
        valid_cp_range(descriptor_index, cp_size) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
          cp->tag_at(descriptor_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
        "Signature index %u in %s has bad constant type in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
        descriptor_index, tbl_name, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  1478
      Symbol*  name = cp->symbol_at(name_index);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  1479
      Symbol*  sig = cp->symbol_at(descriptor_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
      verify_legal_field_name(name, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
      u2 extra_slot = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
      if (!isLVTT) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
        verify_legal_field_signature(name, sig, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
        // 4894874: check special cases for double and long local variables
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  1486
        if (sig == vmSymbols::type_signature(T_DOUBLE) ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  1487
            sig == vmSymbols::type_signature(T_LONG)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
          extra_slot = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
      guarantee_property((index + extra_slot) < max_locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
                          "Invalid index %u in %s in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
                          index, tbl_name, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
  return localvariable_table_start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
void ClassFileParser::parse_type_array(u2 array_length, u4 code_length, u4* u1_index, u4* u2_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
                                      u1* u1_array, u2* u2_array, constantPoolHandle cp, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
  u2 index = 0; // index in the array with long/double occupying two slots
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
  u4 i1 = *u1_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
  u4 i2 = *u2_index + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
  for(int i = 0; i < array_length; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
    u1 tag = u1_array[i1++] = cfs->get_u1(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
    index++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
    if (tag == ITEM_Long || tag == ITEM_Double) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
      index++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
    } else if (tag == ITEM_Object) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
      u2 class_index = u2_array[i2++] = cfs->get_u2(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
      guarantee_property(valid_cp_range(class_index, cp->length()) &&
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  1514
                         is_klass_reference(cp, class_index),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
                         "Bad class index %u in StackMap in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
                         class_index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
    } else if (tag == ITEM_Uninitialized) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
      u2 offset = u2_array[i2++] = cfs->get_u2(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
      guarantee_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
        offset < code_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
        "Bad uninitialized type offset %u in StackMap in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
        offset, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
      guarantee_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
        tag <= (u1)ITEM_Uninitialized,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
        "Unknown variable type %u in StackMap in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
        tag, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
  u2_array[*u2_index] = index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
  *u1_index = i1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
  *u2_index = i2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
typeArrayOop ClassFileParser::parse_stackmap_table(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
    u4 code_attribute_length, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
  if (code_attribute_length == 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
  u1* stackmap_table_start = cfs->get_u1_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
  assert(stackmap_table_start != NULL, "null stackmap table");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
  // check code_attribute_length first
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
  stream()->skip_u1(code_attribute_length, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
  if (!_need_verify && !DumpSharedSpaces) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
  typeArrayOop stackmap_data =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
    oopFactory::new_permanent_byteArray(code_attribute_length, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
  stackmap_data->set_length(code_attribute_length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
  memcpy((void*)stackmap_data->byte_at_addr(0),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
         (void*)stackmap_table_start, code_attribute_length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
  return stackmap_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
u2* ClassFileParser::parse_checked_exceptions(u2* checked_exceptions_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
                                              u4 method_attribute_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
                                              constantPoolHandle cp, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
  cfs->guarantee_more(2, CHECK_NULL);  // checked_exceptions_length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
  *checked_exceptions_length = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
  unsigned int size = (*checked_exceptions_length) * sizeof(CheckedExceptionElement) / sizeof(u2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
  u2* checked_exceptions_start = cfs->get_u2_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
  assert(checked_exceptions_start != NULL, "null checked exceptions");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
  if (!_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
    cfs->skip_u2_fast(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
    // Verify each value in the checked exception table
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
    u2 checked_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
    u2 len = *checked_exceptions_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
    cfs->guarantee_more(2 * len, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
    for (int i = 0; i < len; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
      checked_exception = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
      check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
        valid_cp_range(checked_exception, cp->length()) &&
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  1580
        is_klass_reference(cp, checked_exception),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
        "Exception name has bad type at constant pool %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
        checked_exception, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
  // check exceptions attribute length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
  if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
    guarantee_property(method_attribute_length == (sizeof(*checked_exceptions_length) +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
                                                   sizeof(u2) * size),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
                      "Exceptions attribute has wrong length in class file %s", CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
  return checked_exceptions_start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
5709
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
  1594
void ClassFileParser::throwIllegalSignature(
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  1595
    const char* type, Symbol* name, Symbol* sig, TRAPS) {
5709
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
  1596
  ResourceMark rm(THREAD);
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
  1597
  Exceptions::fthrow(THREAD_AND_LOCATION,
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
  1598
      vmSymbols::java_lang_ClassFormatError(),
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
  1599
      "%s \"%s\" in class %s has illegal signature \"%s\"", type,
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
  1600
      name->as_C_string(), _class_name->as_C_string(), sig->as_C_string());
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
  1601
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
#define MAX_ARGS_SIZE 255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
#define MAX_CODE_SIZE 65535
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
#define INITIAL_MAX_LVT_NUMBER 256
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
// Note: the parse_method below is big and clunky because all parsing of the code and exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
// attribute is inlined. This is curbersome to avoid since we inline most of the parts in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
// methodOop to save footprint, so we only know the size of the resulting methodOop when the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
// entire method attribute is parsed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
// The promoted_flags parameter is used to pass relevant access_flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
// from the method back up to the containing klass. These flag values
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
// are added to klass's access_flags.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
methodHandle ClassFileParser::parse_method(constantPoolHandle cp, bool is_interface,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
                                           AccessFlags *promoted_flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
                                           typeArrayHandle* method_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
                                           typeArrayHandle* method_parameter_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
                                           typeArrayHandle* method_default_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
                                           TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
  methodHandle nullHandle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
  // Parse fixed parts
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
  cfs->guarantee_more(8, CHECK_(nullHandle)); // access_flags, name_index, descriptor_index, attributes_count
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
  int flags = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
  u2 name_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
  int cp_size = cp->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
  check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
    valid_cp_range(name_index, cp_size) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
      cp->tag_at(name_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
    "Illegal constant pool index %u for method name in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
    name_index, CHECK_(nullHandle));
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  1636
  Symbol*  name = cp->symbol_at(name_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
  verify_legal_method_name(name, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
  u2 signature_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
  guarantee_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
    valid_cp_range(signature_index, cp_size) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
      cp->tag_at(signature_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
    "Illegal constant pool index %u for method signature in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
    signature_index, CHECK_(nullHandle));
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  1645
  Symbol*  signature = cp->symbol_at(signature_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
  AccessFlags access_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
  if (name == vmSymbols::class_initializer_name()) {
8653
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8296
diff changeset
  1649
    // We ignore the other access flags for a valid class initializer.
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8296
diff changeset
  1650
    // (JVM Spec 2nd ed., chapter 4.6)
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8296
diff changeset
  1651
    if (_major_version < 51) { // backward compatibility
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8296
diff changeset
  1652
      flags = JVM_ACC_STATIC;
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8296
diff changeset
  1653
    } else if ((flags & JVM_ACC_STATIC) == JVM_ACC_STATIC) {
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8296
diff changeset
  1654
      flags &= JVM_ACC_STATIC | JVM_ACC_STRICT;
8797d788a4f1 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 8296
diff changeset
  1655
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
    verify_legal_method_modifiers(flags, is_interface, name, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1660
  int args_size = -1;  // only used when _need_verify is true
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
  if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
    args_size = ((flags & JVM_ACC_STATIC) ? 0 : 1) +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
                 verify_legal_method_signature(name, signature, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
    if (args_size > MAX_ARGS_SIZE) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
      classfile_parse_error("Too many arguments in method signature in class file %s", CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1668
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
  access_flags.set_flags(flags & JVM_RECOGNIZED_METHOD_MODIFIERS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
  // Default values for code and exceptions attribute elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
  u2 max_stack = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
  u2 max_locals = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
  u4 code_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
  u1* code_start = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
  u2 exception_table_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
  typeArrayHandle exception_handlers(THREAD, Universe::the_empty_int_array());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
  u2 checked_exceptions_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
  u2* checked_exceptions_start = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
  CompressedLineNumberWriteStream* linenumber_table = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
  int linenumber_table_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
  int total_lvt_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
  u2 lvt_cnt = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
  u2 lvtt_cnt = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1685
  bool lvt_allocated = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1686
  u2 max_lvt_cnt = INITIAL_MAX_LVT_NUMBER;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1687
  u2 max_lvtt_cnt = INITIAL_MAX_LVT_NUMBER;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1688
  u2* localvariable_table_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
  u2** localvariable_table_start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
  u2* localvariable_type_table_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1691
  u2** localvariable_type_table_start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1692
  bool parsed_code_attribute = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
  bool parsed_checked_exceptions_attribute = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1694
  bool parsed_stackmap_attribute = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
  // stackmap attribute - JDK1.5
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
  typeArrayHandle stackmap_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
  u2 generic_signature_index = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
  u1* runtime_visible_annotations = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
  int runtime_visible_annotations_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1700
  u1* runtime_invisible_annotations = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
  int runtime_invisible_annotations_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
  u1* runtime_visible_parameter_annotations = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
  int runtime_visible_parameter_annotations_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1704
  u1* runtime_invisible_parameter_annotations = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
  int runtime_invisible_parameter_annotations_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
  u1* annotation_default = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
  int annotation_default_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1708
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1709
  // Parse code and exceptions attribute
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1710
  u2 method_attributes_count = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
  while (method_attributes_count--) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
    cfs->guarantee_more(6, CHECK_(nullHandle));  // method_attribute_name_index, method_attribute_length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
    u2 method_attribute_name_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
    u4 method_attribute_length = cfs->get_u4_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
    check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1716
      valid_cp_range(method_attribute_name_index, cp_size) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1717
        cp->tag_at(method_attribute_name_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
      "Invalid method attribute name index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1719
      method_attribute_name_index, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1720
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  1721
    Symbol* method_attribute_name = cp->symbol_at(method_attribute_name_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1722
    if (method_attribute_name == vmSymbols::tag_code()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
      // Parse Code attribute
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
      if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
        guarantee_property(!access_flags.is_native() && !access_flags.is_abstract(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
                        "Code attribute in native or abstract methods in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1727
                         CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
      if (parsed_code_attribute) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
        classfile_parse_error("Multiple Code attributes in class file %s", CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
      parsed_code_attribute = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
      // Stack size, locals size, and code size
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
      if (_major_version == 45 && _minor_version <= 2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1736
        cfs->guarantee_more(4, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
        max_stack = cfs->get_u1_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
        max_locals = cfs->get_u1_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1739
        code_length = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1740
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1741
        cfs->guarantee_more(8, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1742
        max_stack = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1743
        max_locals = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
        code_length = cfs->get_u4_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
      if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
        guarantee_property(args_size <= max_locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
                           "Arguments can't fit into locals in class file %s", CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
        guarantee_property(code_length > 0 && code_length <= MAX_CODE_SIZE,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1750
                           "Invalid method Code length %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
                           code_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1752
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1753
      // Code pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
      code_start = cfs->get_u1_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
      assert(code_start != NULL, "null code start");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
      cfs->guarantee_more(code_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
      cfs->skip_u1_fast(code_length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1759
      // Exception handler table
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1760
      cfs->guarantee_more(2, CHECK_(nullHandle));  // exception_table_length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1761
      exception_table_length = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1762
      if (exception_table_length > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
        exception_handlers =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
              parse_exception_table(code_length, exception_table_length, cp, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
      // Parse additional attributes in code attribute
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
      cfs->guarantee_more(2, CHECK_(nullHandle));  // code_attributes_count
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
      u2 code_attributes_count = cfs->get_u2_fast();
339
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1770
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1771
      unsigned int calculated_attribute_length = 0;
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1772
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1773
      if (_major_version > 45 || (_major_version == 45 && _minor_version > 2)) {
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1774
        calculated_attribute_length =
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1775
            sizeof(max_stack) + sizeof(max_locals) + sizeof(code_length);
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1776
      } else {
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1777
        // max_stack, locals and length are smaller in pre-version 45.2 classes
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1778
        calculated_attribute_length = sizeof(u1) + sizeof(u1) + sizeof(u2);
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1779
      }
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1780
      calculated_attribute_length +=
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1781
        code_length +
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1782
        sizeof(exception_table_length) +
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1783
        sizeof(code_attributes_count) +
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1784
        exception_table_length *
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1785
            ( sizeof(u2) +   // start_pc
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1786
              sizeof(u2) +   // end_pc
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1787
              sizeof(u2) +   // handler_pc
2d9c1e9e9f98 6615981: JVM class file parser incorrectly rejects class files with version < 45.2
kamg
parents: 1
diff changeset
  1788
              sizeof(u2) );  // catch_type_index
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
      while (code_attributes_count--) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
        cfs->guarantee_more(6, CHECK_(nullHandle));  // code_attribute_name_index, code_attribute_length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
        u2 code_attribute_name_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1793
        u4 code_attribute_length = cfs->get_u4_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1794
        calculated_attribute_length += code_attribute_length +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
                                       sizeof(code_attribute_name_index) +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
                                       sizeof(code_attribute_length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
        check_property(valid_cp_range(code_attribute_name_index, cp_size) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
                       cp->tag_at(code_attribute_name_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1799
                       "Invalid code attribute name index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1800
                       code_attribute_name_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1801
                       CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
        if (LoadLineNumberTables &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1803
            cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_line_number_table()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1804
          // Parse and compress line number table
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1805
          parse_linenumber_table(code_attribute_length, code_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1806
            &linenumber_table, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1808
        } else if (LoadLocalVariableTables &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1809
                   cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_table()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1810
          // Parse local variable table
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
          if (!lvt_allocated) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
            localvariable_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1813
              THREAD, u2,  INITIAL_MAX_LVT_NUMBER);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1814
            localvariable_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1815
              THREAD, u2*, INITIAL_MAX_LVT_NUMBER);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1816
            localvariable_type_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1817
              THREAD, u2,  INITIAL_MAX_LVT_NUMBER);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1818
            localvariable_type_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1819
              THREAD, u2*, INITIAL_MAX_LVT_NUMBER);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1820
            lvt_allocated = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1821
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1822
          if (lvt_cnt == max_lvt_cnt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
            max_lvt_cnt <<= 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1824
            REALLOC_RESOURCE_ARRAY(u2, localvariable_table_length, lvt_cnt, max_lvt_cnt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1825
            REALLOC_RESOURCE_ARRAY(u2*, localvariable_table_start, lvt_cnt, max_lvt_cnt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1827
          localvariable_table_start[lvt_cnt] =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1828
            parse_localvariable_table(code_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1829
                                      max_locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1830
                                      code_attribute_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1831
                                      cp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1832
                                      &localvariable_table_length[lvt_cnt],
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1833
                                      false,    // is not LVTT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1834
                                      CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1835
          total_lvt_length += localvariable_table_length[lvt_cnt];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
          lvt_cnt++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
        } else if (LoadLocalVariableTypeTables &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1838
                   _major_version >= JAVA_1_5_VERSION &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1839
                   cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_type_table()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1840
          if (!lvt_allocated) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1841
            localvariable_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1842
              THREAD, u2,  INITIAL_MAX_LVT_NUMBER);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1843
            localvariable_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
              THREAD, u2*, INITIAL_MAX_LVT_NUMBER);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1845
            localvariable_type_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1846
              THREAD, u2,  INITIAL_MAX_LVT_NUMBER);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1847
            localvariable_type_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
              THREAD, u2*, INITIAL_MAX_LVT_NUMBER);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
            lvt_allocated = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
          // Parse local variable type table
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
          if (lvtt_cnt == max_lvtt_cnt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
            max_lvtt_cnt <<= 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
            REALLOC_RESOURCE_ARRAY(u2, localvariable_type_table_length, lvtt_cnt, max_lvtt_cnt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1855
            REALLOC_RESOURCE_ARRAY(u2*, localvariable_type_table_start, lvtt_cnt, max_lvtt_cnt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1856
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1857
          localvariable_type_table_start[lvtt_cnt] =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1858
            parse_localvariable_table(code_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1859
                                      max_locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1860
                                      code_attribute_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1861
                                      cp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1862
                                      &localvariable_type_table_length[lvtt_cnt],
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
                                      true,     // is LVTT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1864
                                      CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1865
          lvtt_cnt++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1866
        } else if (UseSplitVerifier &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1867
                   _major_version >= Verifier::STACKMAP_ATTRIBUTE_MAJOR_VERSION &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1868
                   cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_stack_map_table()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1869
          // Stack map is only needed by the new verifier in JDK1.5.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1870
          if (parsed_stackmap_attribute) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1871
            classfile_parse_error("Multiple StackMapTable attributes in class file %s", CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1872
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1873
          typeArrayOop sm =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1874
            parse_stackmap_table(code_attribute_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
          stackmap_data = typeArrayHandle(THREAD, sm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
          parsed_stackmap_attribute = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
          // Skip unknown attributes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
          cfs->skip_u1(code_attribute_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1880
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1881
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1882
      // check method attribute length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1883
      if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1884
        guarantee_property(method_attribute_length == calculated_attribute_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1885
                           "Code segment has wrong length in class file %s", CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1886
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
    } else if (method_attribute_name == vmSymbols::tag_exceptions()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
      // Parse Exceptions attribute
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1889
      if (parsed_checked_exceptions_attribute) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1890
        classfile_parse_error("Multiple Exceptions attributes in class file %s", CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
      parsed_checked_exceptions_attribute = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
      checked_exceptions_start =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
            parse_checked_exceptions(&checked_exceptions_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1895
                                     method_attribute_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1896
                                     cp, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1897
    } else if (method_attribute_name == vmSymbols::tag_synthetic()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1898
      if (method_attribute_length != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1899
        classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1900
          "Invalid Synthetic method attribute length %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1901
          method_attribute_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1902
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1903
      // Should we check that there hasn't already been a synthetic attribute?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1904
      access_flags.set_is_synthetic();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1905
    } else if (method_attribute_name == vmSymbols::tag_deprecated()) { // 4276120
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1906
      if (method_attribute_length != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1907
        classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1908
          "Invalid Deprecated method attribute length %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1909
          method_attribute_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1910
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1911
    } else if (_major_version >= JAVA_1_5_VERSION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1912
      if (method_attribute_name == vmSymbols::tag_signature()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1913
        if (method_attribute_length != 2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1914
          classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1915
            "Invalid Signature attribute length %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1916
            method_attribute_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1917
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1918
        cfs->guarantee_more(2, CHECK_(nullHandle));  // generic_signature_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1919
        generic_signature_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1920
      } else if (method_attribute_name == vmSymbols::tag_runtime_visible_annotations()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1921
        runtime_visible_annotations_length = method_attribute_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1922
        runtime_visible_annotations = cfs->get_u1_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1923
        assert(runtime_visible_annotations != NULL, "null visible annotations");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1924
        cfs->skip_u1(runtime_visible_annotations_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1925
      } else if (PreserveAllAnnotations && method_attribute_name == vmSymbols::tag_runtime_invisible_annotations()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1926
        runtime_invisible_annotations_length = method_attribute_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1927
        runtime_invisible_annotations = cfs->get_u1_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1928
        assert(runtime_invisible_annotations != NULL, "null invisible annotations");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1929
        cfs->skip_u1(runtime_invisible_annotations_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1930
      } else if (method_attribute_name == vmSymbols::tag_runtime_visible_parameter_annotations()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1931
        runtime_visible_parameter_annotations_length = method_attribute_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1932
        runtime_visible_parameter_annotations = cfs->get_u1_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1933
        assert(runtime_visible_parameter_annotations != NULL, "null visible parameter annotations");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1934
        cfs->skip_u1(runtime_visible_parameter_annotations_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1935
      } else if (PreserveAllAnnotations && method_attribute_name == vmSymbols::tag_runtime_invisible_parameter_annotations()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1936
        runtime_invisible_parameter_annotations_length = method_attribute_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1937
        runtime_invisible_parameter_annotations = cfs->get_u1_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1938
        assert(runtime_invisible_parameter_annotations != NULL, "null invisible parameter annotations");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1939
        cfs->skip_u1(runtime_invisible_parameter_annotations_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1940
      } else if (method_attribute_name == vmSymbols::tag_annotation_default()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1941
        annotation_default_length = method_attribute_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1942
        annotation_default = cfs->get_u1_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1943
        assert(annotation_default != NULL, "null annotation default");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1944
        cfs->skip_u1(annotation_default_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1945
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1946
        // Skip unknown attributes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1947
        cfs->skip_u1(method_attribute_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1948
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1949
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1950
      // Skip unknown attributes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1951
      cfs->skip_u1(method_attribute_length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1952
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1953
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1954
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1955
  if (linenumber_table != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1956
    linenumber_table->write_terminator();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1957
    linenumber_table_length = linenumber_table->position();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1958
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1959
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1960
  // Make sure there's at least one Code attribute in non-native/non-abstract method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1961
  if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1962
    guarantee_property(access_flags.is_native() || access_flags.is_abstract() || parsed_code_attribute,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1963
                      "Absent Code attribute in method that is not native or abstract in class file %s", CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1964
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1965
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1966
  // All sizing information for a methodOop is finally available, now create it
8296
b1c2163e4e59 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents: 8076
diff changeset
  1967
  methodOop m_oop  = oopFactory::new_method(code_length, access_flags, linenumber_table_length,
b1c2163e4e59 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents: 8076
diff changeset
  1968
                                            total_lvt_length, checked_exceptions_length,
b1c2163e4e59 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents: 8076
diff changeset
  1969
                                            oopDesc::IsSafeConc, CHECK_(nullHandle));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1970
  methodHandle m (THREAD, m_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1971
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1972
  ClassLoadingService::add_class_method_size(m_oop->size()*HeapWordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1973
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1974
  // Fill in information from fixed part (access_flags already set)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1975
  m->set_constants(cp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1976
  m->set_name_index(name_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1977
  m->set_signature_index(signature_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1978
  m->set_generic_signature_index(generic_signature_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1979
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1980
  // hmm is there a gc issue here??
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1981
  ResultTypeFinder rtf(cp->symbol_at(signature_index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1982
  m->set_result_index(rtf.type());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1983
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1984
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1985
  if (args_size >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1986
    m->set_size_of_parameters(args_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1987
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1988
    m->compute_size_of_parameters(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1989
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1990
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1991
  if (args_size >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1992
    m->compute_size_of_parameters(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1993
    assert(args_size == m->size_of_parameters(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1994
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1995
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1996
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1997
  // Fill in code attribute information
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1998
  m->set_max_stack(max_stack);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1999
  m->set_max_locals(max_locals);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2000
  m->constMethod()->set_stackmap_data(stackmap_data());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2001
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2002
  /**
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2003
   * The exception_table field is the flag used to indicate
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2004
   * that the methodOop and it's associated constMethodOop are partially
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2005
   * initialized and thus are exempt from pre/post GC verification.  Once
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2006
   * the field is set, the oops are considered fully initialized so make
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2007
   * sure that the oops can pass verification when this field is set.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2008
   */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2009
  m->set_exception_table(exception_handlers());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2010
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2011
  // Copy byte codes
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4478
diff changeset
  2012
  m->set_code(code_start);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2013
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2014
  // Copy line number table
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2015
  if (linenumber_table != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2016
    memcpy(m->compressed_linenumber_table(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2017
           linenumber_table->buffer(), linenumber_table_length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2018
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2019
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2020
  // Copy checked exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2021
  if (checked_exceptions_length > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2022
    int size = checked_exceptions_length * sizeof(CheckedExceptionElement) / sizeof(u2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2023
    copy_u2_with_conversion((u2*) m->checked_exceptions_start(), checked_exceptions_start, size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2024
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2025
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2026
  /* Copy class file LVT's/LVTT's into the HotSpot internal LVT.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2027
   *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2028
   * Rules for LVT's and LVTT's are:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2029
   *   - There can be any number of LVT's and LVTT's.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2030
   *   - If there are n LVT's, it is the same as if there was just
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2031
   *     one LVT containing all the entries from the n LVT's.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2032
   *   - There may be no more than one LVT entry per local variable.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2033
   *     Two LVT entries are 'equal' if these fields are the same:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2034
   *        start_pc, length, name, slot
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2035
   *   - There may be no more than one LVTT entry per each LVT entry.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2036
   *     Each LVTT entry has to match some LVT entry.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2037
   *   - HotSpot internal LVT keeps natural ordering of class file LVT entries.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2038
   */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2039
  if (total_lvt_length > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2040
    int tbl_no, idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2041
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2042
    promoted_flags->set_has_localvariable_table();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2043
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2044
    LVT_Hash** lvt_Hash = NEW_RESOURCE_ARRAY(LVT_Hash*, HASH_ROW_SIZE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2045
    initialize_hashtable(lvt_Hash);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2046
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2047
    // To fill LocalVariableTable in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2048
    Classfile_LVT_Element*  cf_lvt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2049
    LocalVariableTableElement* lvt = m->localvariable_table_start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2050
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2051
    for (tbl_no = 0; tbl_no < lvt_cnt; tbl_no++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2052
      cf_lvt = (Classfile_LVT_Element *) localvariable_table_start[tbl_no];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2053
      for (idx = 0; idx < localvariable_table_length[tbl_no]; idx++, lvt++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2054
        copy_lvt_element(&cf_lvt[idx], lvt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2055
        // If no duplicates, add LVT elem in hashtable lvt_Hash.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2056
        if (LVT_put_after_lookup(lvt, lvt_Hash) == false
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2057
          && _need_verify
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2058
          && _major_version >= JAVA_1_5_VERSION ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2059
          clear_hashtable(lvt_Hash);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2060
          classfile_parse_error("Duplicated LocalVariableTable attribute "
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2061
                                "entry for '%s' in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2062
                                 cp->symbol_at(lvt->name_cp_index)->as_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2063
                                 CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2064
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2065
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2066
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2067
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2068
    // To merge LocalVariableTable and LocalVariableTypeTable
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2069
    Classfile_LVT_Element* cf_lvtt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2070
    LocalVariableTableElement lvtt_elem;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2071
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2072
    for (tbl_no = 0; tbl_no < lvtt_cnt; tbl_no++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2073
      cf_lvtt = (Classfile_LVT_Element *) localvariable_type_table_start[tbl_no];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2074
      for (idx = 0; idx < localvariable_type_table_length[tbl_no]; idx++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2075
        copy_lvt_element(&cf_lvtt[idx], &lvtt_elem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2076
        int index = hash(&lvtt_elem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2077
        LVT_Hash* entry = LVT_lookup(&lvtt_elem, index, lvt_Hash);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2078
        if (entry == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2079
          if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2080
            clear_hashtable(lvt_Hash);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2081
            classfile_parse_error("LVTT entry for '%s' in class file %s "
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2082
                                  "does not match any LVT entry",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2083
                                   cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2084
                                   CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2085
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2086
        } else if (entry->_elem->signature_cp_index != 0 && _need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2087
          clear_hashtable(lvt_Hash);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2088
          classfile_parse_error("Duplicated LocalVariableTypeTable attribute "
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2089
                                "entry for '%s' in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2090
                                 cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2091
                                 CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2092
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2093
          // to add generic signatures into LocalVariableTable
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2094
          entry->_elem->signature_cp_index = lvtt_elem.descriptor_cp_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2095
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2096
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2097
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2098
    clear_hashtable(lvt_Hash);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2099
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2100
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2101
  *method_annotations = assemble_annotations(runtime_visible_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2102
                                             runtime_visible_annotations_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2103
                                             runtime_invisible_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2104
                                             runtime_invisible_annotations_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2105
                                             CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2106
  *method_parameter_annotations = assemble_annotations(runtime_visible_parameter_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2107
                                                       runtime_visible_parameter_annotations_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2108
                                                       runtime_invisible_parameter_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2109
                                                       runtime_invisible_parameter_annotations_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2110
                                                       CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2111
  *method_default_annotations = assemble_annotations(annotation_default,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2112
                                                     annotation_default_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2113
                                                     NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2114
                                                     0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2115
                                                     CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2116
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2117
  if (name == vmSymbols::finalize_method_name() &&
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2118
      signature == vmSymbols::void_method_signature()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2119
    if (m->is_empty_method()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2120
      _has_empty_finalizer = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2121
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2122
      _has_finalizer = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2123
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2124
  }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2125
  if (name == vmSymbols::object_initializer_name() &&
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2126
      signature == vmSymbols::void_method_signature() &&
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2127
      m->is_vanilla_constructor()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2128
    _has_vanilla_constructor = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2129
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2130
8883
5569135acca3 6817525: turn on method handle functionality by default for JSR 292
twisti
parents: 8725
diff changeset
  2131
  if (EnableInvokeDynamic && (m->is_method_handle_invoke() ||
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5250
diff changeset
  2132
                              m->is_method_handle_adapter())) {
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2269
diff changeset
  2133
    THROW_MSG_(vmSymbols::java_lang_VirtualMachineError(),
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2269
diff changeset
  2134
               "Method handle invokers must be defined internally to the VM", nullHandle);
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2269
diff changeset
  2135
  }
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2269
diff changeset
  2136
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2137
  return m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2138
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2139
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2140
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2141
// The promoted_flags parameter is used to pass relevant access_flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2142
// from the methods back up to the containing klass. These flag values
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2143
// are added to klass's access_flags.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2144
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2145
objArrayHandle ClassFileParser::parse_methods(constantPoolHandle cp, bool is_interface,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2146
                                              AccessFlags* promoted_flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2147
                                              bool* has_final_method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2148
                                              objArrayOop* methods_annotations_oop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2149
                                              objArrayOop* methods_parameter_annotations_oop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2150
                                              objArrayOop* methods_default_annotations_oop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2151
                                              TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2152
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2153
  objArrayHandle nullHandle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2154
  typeArrayHandle method_annotations;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2155
  typeArrayHandle method_parameter_annotations;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2156
  typeArrayHandle method_default_annotations;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2157
  cfs->guarantee_more(2, CHECK_(nullHandle));  // length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2158
  u2 length = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2159
  if (length == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2160
    return objArrayHandle(THREAD, Universe::the_empty_system_obj_array());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2161
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2162
    objArrayOop m = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2163
    objArrayHandle methods(THREAD, m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2164
    HandleMark hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2165
    objArrayHandle methods_annotations;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2166
    objArrayHandle methods_parameter_annotations;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2167
    objArrayHandle methods_default_annotations;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2168
    for (int index = 0; index < length; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2169
      methodHandle method = parse_method(cp, is_interface,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2170
                                         promoted_flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2171
                                         &method_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2172
                                         &method_parameter_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2173
                                         &method_default_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2174
                                         CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2175
      if (method->is_final()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2176
        *has_final_method = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2177
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2178
      methods->obj_at_put(index, method());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2179
      if (method_annotations.not_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2180
        if (methods_annotations.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2181
          objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2182
          methods_annotations = objArrayHandle(THREAD, md);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2183
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2184
        methods_annotations->obj_at_put(index, method_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2185
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2186
      if (method_parameter_annotations.not_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2187
        if (methods_parameter_annotations.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2188
          objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2189
          methods_parameter_annotations = objArrayHandle(THREAD, md);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2190
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2191
        methods_parameter_annotations->obj_at_put(index, method_parameter_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2192
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2193
      if (method_default_annotations.not_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2194
        if (methods_default_annotations.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2195
          objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2196
          methods_default_annotations = objArrayHandle(THREAD, md);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2197
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2198
        methods_default_annotations->obj_at_put(index, method_default_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2199
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2200
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2201
    if (_need_verify && length > 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2202
      // Check duplicated methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2203
      ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2204
      NameSigHash** names_and_sigs = NEW_RESOURCE_ARRAY_IN_THREAD(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2205
        THREAD, NameSigHash*, HASH_ROW_SIZE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2206
      initialize_hashtable(names_and_sigs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2207
      bool dup = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2208
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2209
        debug_only(No_Safepoint_Verifier nsv;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2210
        for (int i = 0; i < length; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2211
          methodOop m = (methodOop)methods->obj_at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2212
          // If no duplicates, add name/signature in hashtable names_and_sigs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2213
          if (!put_after_lookup(m->name(), m->signature(), names_and_sigs)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2214
            dup = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2215
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2216
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2217
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2218
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2219
      if (dup) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2220
        classfile_parse_error("Duplicate method name&signature in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2221
                              CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2222
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2223
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2224
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2225
    *methods_annotations_oop = methods_annotations();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2226
    *methods_parameter_annotations_oop = methods_parameter_annotations();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2227
    *methods_default_annotations_oop = methods_default_annotations();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2228
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2229
    return methods;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2230
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2231
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2232
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2233
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2234
typeArrayHandle ClassFileParser::sort_methods(objArrayHandle methods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2235
                                              objArrayHandle methods_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2236
                                              objArrayHandle methods_parameter_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2237
                                              objArrayHandle methods_default_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2238
                                              TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2239
  typeArrayHandle nullHandle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2240
  int length = methods()->length();
9172
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 9117
diff changeset
  2241
  // If JVMTI original method ordering or sharing is enabled we have to
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2242
  // remember the original class file ordering.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2243
  // We temporarily use the vtable_index field in the methodOop to store the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2244
  // class file index, so we can read in after calling qsort.
9172
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 9117
diff changeset
  2245
  // Put the method ordering in the shared archive.
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 9117
diff changeset
  2246
  if (JvmtiExport::can_maintain_original_method_order() || DumpSharedSpaces) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2247
    for (int index = 0; index < length; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2248
      methodOop m = methodOop(methods->obj_at(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2249
      assert(!m->valid_vtable_index(), "vtable index should not be set");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2250
      m->set_vtable_index(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2251
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2252
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2253
  // Sort method array by ascending method name (for faster lookups & vtable construction)
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2254
  // Note that the ordering is not alphabetical, see Symbol::fast_compare
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2255
  methodOopDesc::sort_methods(methods(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2256
                              methods_annotations(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2257
                              methods_parameter_annotations(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2258
                              methods_default_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2259
9172
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 9117
diff changeset
  2260
  // If JVMTI original method ordering or sharing is enabled construct int
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 9117
diff changeset
  2261
  // array remembering the original ordering
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 9117
diff changeset
  2262
  if (JvmtiExport::can_maintain_original_method_order() || DumpSharedSpaces) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2263
    typeArrayOop new_ordering = oopFactory::new_permanent_intArray(length, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2264
    typeArrayHandle method_ordering(THREAD, new_ordering);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2265
    for (int index = 0; index < length; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2266
      methodOop m = methodOop(methods->obj_at(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2267
      int old_index = m->vtable_index();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2268
      assert(old_index >= 0 && old_index < length, "invalid method index");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2269
      method_ordering->int_at_put(index, old_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2270
      m->set_vtable_index(methodOopDesc::invalid_vtable_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2271
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2272
    return method_ordering;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2273
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2274
    return typeArrayHandle(THREAD, Universe::the_empty_int_array());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2275
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2276
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2277
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2278
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2279
void ClassFileParser::parse_classfile_sourcefile_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2280
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2281
  cfs->guarantee_more(2, CHECK);  // sourcefile_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2282
  u2 sourcefile_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2283
  check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2284
    valid_cp_range(sourcefile_index, cp->length()) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2285
      cp->tag_at(sourcefile_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2286
    "Invalid SourceFile attribute at constant pool index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2287
    sourcefile_index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2288
  k->set_source_file_name(cp->symbol_at(sourcefile_index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2289
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2290
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2291
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2292
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2293
void ClassFileParser::parse_classfile_source_debug_extension_attribute(constantPoolHandle cp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2294
                                                                       instanceKlassHandle k,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2295
                                                                       int length, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2296
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2297
  u1* sde_buffer = cfs->get_u1_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2298
  assert(sde_buffer != NULL, "null sde buffer");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2299
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2300
  // Don't bother storing it if there is no way to retrieve it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2301
  if (JvmtiExport::can_get_source_debug_extension()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2302
    // Optimistically assume that only 1 byte UTF format is used
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2303
    // (common case)
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2304
    TempNewSymbol sde_symbol = SymbolTable::new_symbol((const char*)sde_buffer, length, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2305
    k->set_source_debug_extension(sde_symbol);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2306
    // Note that set_source_debug_extension() increments the reference count
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2307
    // for its copy of the Symbol*, so use a TempNewSymbol here.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2308
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2309
  // Got utf8 string, set stream position forward
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2310
  cfs->skip_u1(length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2311
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2312
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2313
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2314
// Inner classes can be static, private or protected (classic VM does this)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2315
#define RECOGNIZED_INNER_CLASS_MODIFIERS (JVM_RECOGNIZED_CLASS_MODIFIERS | JVM_ACC_PRIVATE | JVM_ACC_PROTECTED | JVM_ACC_STATIC)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2316
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2317
// Return number of classes in the inner classes attribute table
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2318
u2 ClassFileParser::parse_classfile_inner_classes_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2319
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2320
  cfs->guarantee_more(2, CHECK_0);  // length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2321
  u2 length = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2322
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2323
  // 4-tuples of shorts [inner_class_info_index, outer_class_info_index, inner_name_index, inner_class_access_flags]
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2324
  typeArrayOop ic = oopFactory::new_permanent_shortArray(length*4, CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2325
  typeArrayHandle inner_classes(THREAD, ic);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2326
  int index = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2327
  int cp_size = cp->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2328
  cfs->guarantee_more(8 * length, CHECK_0);  // 4-tuples of u2
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2329
  for (int n = 0; n < length; n++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2330
    // Inner class index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2331
    u2 inner_class_info_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2332
    check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2333
      inner_class_info_index == 0 ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2334
        (valid_cp_range(inner_class_info_index, cp_size) &&
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2335
        is_klass_reference(cp, inner_class_info_index)),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2336
      "inner_class_info_index %u has bad constant type in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2337
      inner_class_info_index, CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2338
    // Outer class index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2339
    u2 outer_class_info_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2340
    check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2341
      outer_class_info_index == 0 ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2342
        (valid_cp_range(outer_class_info_index, cp_size) &&
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2343
        is_klass_reference(cp, outer_class_info_index)),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2344
      "outer_class_info_index %u has bad constant type in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2345
      outer_class_info_index, CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2346
    // Inner class name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2347
    u2 inner_name_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2348
    check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2349
      inner_name_index == 0 || (valid_cp_range(inner_name_index, cp_size) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2350
        cp->tag_at(inner_name_index).is_utf8()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2351
      "inner_name_index %u has bad constant type in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2352
      inner_name_index, CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2353
    if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2354
      guarantee_property(inner_class_info_index != outer_class_info_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2355
                         "Class is both outer and inner class in class file %s", CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2356
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2357
    // Access flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2358
    AccessFlags inner_access_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2359
    jint flags = cfs->get_u2_fast() & RECOGNIZED_INNER_CLASS_MODIFIERS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2360
    if ((flags & JVM_ACC_INTERFACE) && _major_version < JAVA_6_VERSION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2361
      // Set abstract bit for old class files for backward compatibility
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2362
      flags |= JVM_ACC_ABSTRACT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2363
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2364
    verify_legal_class_modifiers(flags, CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2365
    inner_access_flags.set_flags(flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2366
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2367
    inner_classes->short_at_put(index++, inner_class_info_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2368
    inner_classes->short_at_put(index++, outer_class_info_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2369
    inner_classes->short_at_put(index++, inner_name_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2370
    inner_classes->short_at_put(index++, inner_access_flags.as_short());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2371
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2372
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2373
  // 4347400: make sure there's no duplicate entry in the classes array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2374
  if (_need_verify && _major_version >= JAVA_1_5_VERSION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2375
    for(int i = 0; i < inner_classes->length(); i += 4) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2376
      for(int j = i + 4; j < inner_classes->length(); j += 4) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2377
        guarantee_property((inner_classes->ushort_at(i)   != inner_classes->ushort_at(j) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2378
                            inner_classes->ushort_at(i+1) != inner_classes->ushort_at(j+1) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2379
                            inner_classes->ushort_at(i+2) != inner_classes->ushort_at(j+2) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2380
                            inner_classes->ushort_at(i+3) != inner_classes->ushort_at(j+3)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2381
                            "Duplicate entry in InnerClasses in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2382
                            CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2383
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2384
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2385
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2386
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2387
  // Update instanceKlass with inner class info.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2388
  k->set_inner_classes(inner_classes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2389
  return length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2390
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2391
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2392
void ClassFileParser::parse_classfile_synthetic_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2393
  k->set_is_synthetic();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2394
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2395
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2396
void ClassFileParser::parse_classfile_signature_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2397
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2398
  u2 signature_index = cfs->get_u2(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2399
  check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2400
    valid_cp_range(signature_index, cp->length()) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2401
      cp->tag_at(signature_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2402
    "Invalid constant pool index %u in Signature attribute in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2403
    signature_index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2404
  k->set_generic_signature(cp->symbol_at(signature_index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2405
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2406
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2407
void ClassFileParser::parse_classfile_bootstrap_methods_attribute(constantPoolHandle cp, instanceKlassHandle k,
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2408
                                                                  u4 attribute_byte_length, TRAPS) {
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2409
  ClassFileStream* cfs = stream();
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2410
  u1* current_start = cfs->current();
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2411
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2412
  cfs->guarantee_more(2, CHECK);  // length
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2413
  int attribute_array_length = cfs->get_u2_fast();
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2414
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2415
  guarantee_property(_max_bootstrap_specifier_index < attribute_array_length,
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2416
                     "Short length on BootstrapMethods in class file %s",
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2417
                     CHECK);
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2418
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2419
  // The attribute contains a counted array of counted tuples of shorts,
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2420
  // represending bootstrap specifiers:
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2421
  //    length*{bootstrap_method_index, argument_count*{argument_index}}
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2422
  int operand_count = (attribute_byte_length - sizeof(u2)) / sizeof(u2);
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2423
  // operand_count = number of shorts in attr, except for leading length
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2424
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2425
  // The attribute is copied into a short[] array.
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2426
  // The array begins with a series of short[2] pairs, one for each tuple.
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2427
  int index_size = (attribute_array_length * 2);
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2428
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2429
  typeArrayOop operands_oop = oopFactory::new_permanent_intArray(index_size + operand_count, CHECK);
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2430
  typeArrayHandle operands(THREAD, operands_oop);
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2431
  operands_oop = NULL; // tidy
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2432
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2433
  int operand_fill_index = index_size;
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2434
  int cp_size = cp->length();
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2435
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2436
  for (int n = 0; n < attribute_array_length; n++) {
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2437
    // Store a 32-bit offset into the header of the operand array.
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2438
    assert(constantPoolOopDesc::operand_offset_at(operands(), n) == 0, "");
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2439
    constantPoolOopDesc::operand_offset_at_put(operands(), n, operand_fill_index);
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2440
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2441
    // Read a bootstrap specifier.
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2442
    cfs->guarantee_more(sizeof(u2) * 2, CHECK);  // bsm, argc
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2443
    u2 bootstrap_method_index = cfs->get_u2_fast();
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2444
    u2 argument_count = cfs->get_u2_fast();
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2445
    check_property(
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2446
      valid_cp_range(bootstrap_method_index, cp_size) &&
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2447
      cp->tag_at(bootstrap_method_index).is_method_handle(),
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2448
      "bootstrap_method_index %u has bad constant type in class file %s",
7709
8e90b245b989 7008165: Garbage in ClassFormatError message
twisti
parents: 7436
diff changeset
  2449
      bootstrap_method_index,
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2450
      CHECK);
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2451
    operands->short_at_put(operand_fill_index++, bootstrap_method_index);
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2452
    operands->short_at_put(operand_fill_index++, argument_count);
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2453
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2454
    cfs->guarantee_more(sizeof(u2) * argument_count, CHECK);  // argv[argc]
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2455
    for (int j = 0; j < argument_count; j++) {
7709
8e90b245b989 7008165: Garbage in ClassFormatError message
twisti
parents: 7436
diff changeset
  2456
      u2 argument_index = cfs->get_u2_fast();
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2457
      check_property(
7709
8e90b245b989 7008165: Garbage in ClassFormatError message
twisti
parents: 7436
diff changeset
  2458
        valid_cp_range(argument_index, cp_size) &&
8e90b245b989 7008165: Garbage in ClassFormatError message
twisti
parents: 7436
diff changeset
  2459
        cp->tag_at(argument_index).is_loadable_constant(),
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2460
        "argument_index %u has bad constant type in class file %s",
7709
8e90b245b989 7008165: Garbage in ClassFormatError message
twisti
parents: 7436
diff changeset
  2461
        argument_index,
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2462
        CHECK);
7709
8e90b245b989 7008165: Garbage in ClassFormatError message
twisti
parents: 7436
diff changeset
  2463
      operands->short_at_put(operand_fill_index++, argument_index);
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2464
    }
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2465
  }
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2466
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2467
  assert(operand_fill_index == operands()->length(), "exact fill");
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2468
  assert(constantPoolOopDesc::operand_array_length(operands()) == attribute_array_length, "correct decode");
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2469
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2470
  u1* current_end = cfs->current();
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2471
  guarantee_property(current_end == current_start + attribute_byte_length,
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2472
                     "Bad length on BootstrapMethods in class file %s",
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2473
                     CHECK);
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2474
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2475
  cp->set_operands(operands());
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2476
}
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2477
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2478
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2479
void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2480
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2481
  // Set inner classes attribute to default sentinel
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2482
  k->set_inner_classes(Universe::the_empty_short_array());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2483
  cfs->guarantee_more(2, CHECK);  // attributes_count
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2484
  u2 attributes_count = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2485
  bool parsed_sourcefile_attribute = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2486
  bool parsed_innerclasses_attribute = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2487
  bool parsed_enclosingmethod_attribute = false;
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2488
  bool parsed_bootstrap_methods_attribute = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2489
  u1* runtime_visible_annotations = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2490
  int runtime_visible_annotations_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2491
  u1* runtime_invisible_annotations = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2492
  int runtime_invisible_annotations_length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2493
  // Iterate over attributes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2494
  while (attributes_count--) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2495
    cfs->guarantee_more(6, CHECK);  // attribute_name_index, attribute_length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2496
    u2 attribute_name_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2497
    u4 attribute_length = cfs->get_u4_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2498
    check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2499
      valid_cp_range(attribute_name_index, cp->length()) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2500
        cp->tag_at(attribute_name_index).is_utf8(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2501
      "Attribute name has bad constant pool index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2502
      attribute_name_index, CHECK);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2503
    Symbol* tag = cp->symbol_at(attribute_name_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2504
    if (tag == vmSymbols::tag_source_file()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2505
      // Check for SourceFile tag
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2506
      if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2507
        guarantee_property(attribute_length == 2, "Wrong SourceFile attribute length in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2508
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2509
      if (parsed_sourcefile_attribute) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2510
        classfile_parse_error("Multiple SourceFile attributes in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2511
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2512
        parsed_sourcefile_attribute = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2513
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2514
      parse_classfile_sourcefile_attribute(cp, k, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2515
    } else if (tag == vmSymbols::tag_source_debug_extension()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2516
      // Check for SourceDebugExtension tag
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2517
      parse_classfile_source_debug_extension_attribute(cp, k, (int)attribute_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2518
    } else if (tag == vmSymbols::tag_inner_classes()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2519
      // Check for InnerClasses tag
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2520
      if (parsed_innerclasses_attribute) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2521
        classfile_parse_error("Multiple InnerClasses attributes in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2522
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2523
        parsed_innerclasses_attribute = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2524
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2525
      u2 num_of_classes = parse_classfile_inner_classes_attribute(cp, k, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2526
      if (_need_verify && _major_version >= JAVA_1_5_VERSION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2527
        guarantee_property(attribute_length == sizeof(num_of_classes) + 4 * sizeof(u2) * num_of_classes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2528
                          "Wrong InnerClasses attribute length in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2529
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2530
    } else if (tag == vmSymbols::tag_synthetic()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2531
      // Check for Synthetic tag
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2532
      // Shouldn't we check that the synthetic flags wasn't already set? - not required in spec
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2533
      if (attribute_length != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2534
        classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2535
          "Invalid Synthetic classfile attribute length %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2536
          attribute_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2537
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2538
      parse_classfile_synthetic_attribute(cp, k, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2539
    } else if (tag == vmSymbols::tag_deprecated()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2540
      // Check for Deprecatd tag - 4276120
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2541
      if (attribute_length != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2542
        classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2543
          "Invalid Deprecated classfile attribute length %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2544
          attribute_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2545
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2546
    } else if (_major_version >= JAVA_1_5_VERSION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2547
      if (tag == vmSymbols::tag_signature()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2548
        if (attribute_length != 2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2549
          classfile_parse_error(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2550
            "Wrong Signature attribute length %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2551
            attribute_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2552
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2553
        parse_classfile_signature_attribute(cp, k, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2554
      } else if (tag == vmSymbols::tag_runtime_visible_annotations()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2555
        runtime_visible_annotations_length = attribute_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2556
        runtime_visible_annotations = cfs->get_u1_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2557
        assert(runtime_visible_annotations != NULL, "null visible annotations");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2558
        cfs->skip_u1(runtime_visible_annotations_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2559
      } else if (PreserveAllAnnotations && tag == vmSymbols::tag_runtime_invisible_annotations()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2560
        runtime_invisible_annotations_length = attribute_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2561
        runtime_invisible_annotations = cfs->get_u1_buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2562
        assert(runtime_invisible_annotations != NULL, "null invisible annotations");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2563
        cfs->skip_u1(runtime_invisible_annotations_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2564
      } else if (tag == vmSymbols::tag_enclosing_method()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2565
        if (parsed_enclosingmethod_attribute) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2566
          classfile_parse_error("Multiple EnclosingMethod attributes in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2567
        }   else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2568
          parsed_enclosingmethod_attribute = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2569
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2570
        cfs->guarantee_more(4, CHECK);  // class_index, method_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2571
        u2 class_index  = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2572
        u2 method_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2573
        if (class_index == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2574
          classfile_parse_error("Invalid class index in EnclosingMethod attribute in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2575
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2576
        // Validate the constant pool indices and types
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2577
        if (!cp->is_within_bounds(class_index) ||
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2578
            !is_klass_reference(cp, class_index)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2579
          classfile_parse_error("Invalid or out-of-bounds class index in EnclosingMethod attribute in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2580
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2581
        if (method_index != 0 &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2582
            (!cp->is_within_bounds(method_index) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2583
             !cp->tag_at(method_index).is_name_and_type())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2584
          classfile_parse_error("Invalid or out-of-bounds method index in EnclosingMethod attribute in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2585
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2586
        k->set_enclosing_method_indices(class_index, method_index);
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2587
      } else if (tag == vmSymbols::tag_bootstrap_methods() &&
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2588
                 _major_version >= Verifier::INVOKEDYNAMIC_MAJOR_VERSION) {
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2589
        if (parsed_bootstrap_methods_attribute)
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2590
          classfile_parse_error("Multiple BootstrapMethods attributes in class file %s", CHECK);
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2591
        parsed_bootstrap_methods_attribute = true;
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2592
        parse_classfile_bootstrap_methods_attribute(cp, k, attribute_length, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2593
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2594
        // Unknown attribute
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2595
        cfs->skip_u1(attribute_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2596
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2597
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2598
      // Unknown attribute
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2599
      cfs->skip_u1(attribute_length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2600
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2601
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2602
  typeArrayHandle annotations = assemble_annotations(runtime_visible_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2603
                                                     runtime_visible_annotations_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2604
                                                     runtime_invisible_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2605
                                                     runtime_invisible_annotations_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2606
                                                     CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2607
  k->set_class_annotations(annotations());
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2608
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2609
  if (_max_bootstrap_specifier_index >= 0) {
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2610
    guarantee_property(parsed_bootstrap_methods_attribute,
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2611
                       "Missing BootstrapMethods attribute in class file %s", CHECK);
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2612
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2613
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2614
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2615
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2616
typeArrayHandle ClassFileParser::assemble_annotations(u1* runtime_visible_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2617
                                                      int runtime_visible_annotations_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2618
                                                      u1* runtime_invisible_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2619
                                                      int runtime_invisible_annotations_length, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2620
  typeArrayHandle annotations;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2621
  if (runtime_visible_annotations != NULL ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2622
      runtime_invisible_annotations != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2623
    typeArrayOop anno = oopFactory::new_permanent_byteArray(runtime_visible_annotations_length +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2624
                                                            runtime_invisible_annotations_length, CHECK_(annotations));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2625
    annotations = typeArrayHandle(THREAD, anno);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2626
    if (runtime_visible_annotations != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2627
      memcpy(annotations->byte_at_addr(0), runtime_visible_annotations, runtime_visible_annotations_length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2628
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2629
    if (runtime_invisible_annotations != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2630
      memcpy(annotations->byte_at_addr(runtime_visible_annotations_length), runtime_invisible_annotations, runtime_invisible_annotations_length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2631
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2632
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2633
  return annotations;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2634
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2635
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2636
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2637
instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2638
                                                    Handle class_loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2639
                                                    Handle protection_domain,
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2269
diff changeset
  2640
                                                    KlassHandle host_klass,
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2641
                                                    GrowableArray<Handle>* cp_patches,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2642
                                                    TempNewSymbol& parsed_name,
3820
0a8fbbe180db 6830542: Performance: JVM_DefineClass already verified.
acorn
parents: 3579
diff changeset
  2643
                                                    bool verify,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2644
                                                    TRAPS) {
11399
5dd5c4dd4b7d 7122253: Instrumentation.retransformClasses() leaks class bytes
dcubed
parents: 10546
diff changeset
  2645
  // When a retransformable agent is attached, JVMTI caches the
5dd5c4dd4b7d 7122253: Instrumentation.retransformClasses() leaks class bytes
dcubed
parents: 10546
diff changeset
  2646
  // class bytes that existed before the first retransformation.
5dd5c4dd4b7d 7122253: Instrumentation.retransformClasses() leaks class bytes
dcubed
parents: 10546
diff changeset
  2647
  // If RedefineClasses() was used before the retransformable
5dd5c4dd4b7d 7122253: Instrumentation.retransformClasses() leaks class bytes
dcubed
parents: 10546
diff changeset
  2648
  // agent attached, then the cached class bytes may not be the
5dd5c4dd4b7d 7122253: Instrumentation.retransformClasses() leaks class bytes
dcubed
parents: 10546
diff changeset
  2649
  // original class bytes.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2650
  unsigned char *cached_class_file_bytes = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2651
  jint cached_class_file_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2652
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2653
  ClassFileStream* cfs = stream();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2654
  // Timing
3575
224791e7ecab 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 2534
diff changeset
  2655
  assert(THREAD->is_Java_thread(), "must be a JavaThread");
224791e7ecab 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 2534
diff changeset
  2656
  JavaThread* jt = (JavaThread*) THREAD;
224791e7ecab 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 2534
diff changeset
  2657
224791e7ecab 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 2534
diff changeset
  2658
  PerfClassTraceTime ctimer(ClassLoader::perf_class_parse_time(),
224791e7ecab 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 2534
diff changeset
  2659
                            ClassLoader::perf_class_parse_selftime(),
224791e7ecab 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 2534
diff changeset
  2660
                            NULL,
224791e7ecab 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 2534
diff changeset
  2661
                            jt->get_thread_stat()->perf_recursion_counts_addr(),
224791e7ecab 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 2534
diff changeset
  2662
                            jt->get_thread_stat()->perf_timers_addr(),
224791e7ecab 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 2534
diff changeset
  2663
                            PerfClassTraceTime::PARSE_CLASS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2664
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2665
  _has_finalizer = _has_empty_finalizer = _has_vanilla_constructor = false;
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
  2666
  _max_bootstrap_specifier_index = -1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2667
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2668
  if (JvmtiExport::should_post_class_file_load_hook()) {
11419
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2669
    // Get the cached class file bytes (if any) from the class that
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2670
    // is being redefined or retransformed. We use jvmti_thread_state()
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2671
    // instead of JvmtiThreadState::state_for(jt) so we don't allocate
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2672
    // a JvmtiThreadState any earlier than necessary. This will help
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2673
    // avoid the bug described by 7126851.
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2674
    JvmtiThreadState *state = jt->jvmti_thread_state();
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2675
    if (state != NULL) {
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2676
      KlassHandle *h_class_being_redefined =
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2677
                     state->get_class_being_redefined();
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2678
      if (h_class_being_redefined != NULL) {
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2679
        instanceKlassHandle ikh_class_being_redefined =
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2680
          instanceKlassHandle(THREAD, (*h_class_being_redefined)());
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2681
        cached_class_file_bytes =
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2682
          ikh_class_being_redefined->get_cached_class_file_bytes();
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2683
        cached_class_file_length =
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2684
          ikh_class_being_redefined->get_cached_class_file_len();
af92c7669f5a 7127032: fix for 7122253 adds a JvmtiThreadState earlier than necessary
dcubed
parents: 11399
diff changeset
  2685
      }
11399
5dd5c4dd4b7d 7122253: Instrumentation.retransformClasses() leaks class bytes
dcubed
parents: 10546
diff changeset
  2686
    }
5dd5c4dd4b7d 7122253: Instrumentation.retransformClasses() leaks class bytes
dcubed
parents: 10546
diff changeset
  2687
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2688
    unsigned char* ptr = cfs->buffer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2689
    unsigned char* end_ptr = cfs->buffer() + cfs->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2690
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2691
    JvmtiExport::post_class_file_load_hook(name, class_loader, protection_domain,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2692
                                           &ptr, &end_ptr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2693
                                           &cached_class_file_bytes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2694
                                           &cached_class_file_length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2695
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2696
    if (ptr != cfs->buffer()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2697
      // JVMTI agent has modified class file data.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2698
      // Set new class file stream using JVMTI agent modified
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2699
      // class file data.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2700
      cfs = new ClassFileStream(ptr, end_ptr - ptr, cfs->source());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2701
      set_stream(cfs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2702
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2703
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2704
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2269
diff changeset
  2705
  _host_klass = host_klass;
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2706
  _cp_patches = cp_patches;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2707
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2708
  instanceKlassHandle nullHandle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2709
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2710
  // Figure out whether we can skip format checking (matching classic VM behavior)
3820
0a8fbbe180db 6830542: Performance: JVM_DefineClass already verified.
acorn
parents: 3579
diff changeset
  2711
  _need_verify = Verifier::should_verify_for(class_loader(), verify);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2712
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2713
  // Set the verify flag in stream
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2714
  cfs->set_verify(_need_verify);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2715
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2716
  // Save the class file name for easier error message printing.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2717
  _class_name = (name != NULL) ? name : vmSymbols::unknown_class_name();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2718
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2719
  cfs->guarantee_more(8, CHECK_(nullHandle));  // magic, major, minor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2720
  // Magic value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2721
  u4 magic = cfs->get_u4_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2722
  guarantee_property(magic == JAVA_CLASSFILE_MAGIC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2723
                     "Incompatible magic value %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2724
                     magic, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2725
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2726
  // Version numbers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2727
  u2 minor_version = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2728
  u2 major_version = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2729
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2730
  // Check version numbers - we check this even with verifier off
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2731
  if (!is_supported_version(major_version, minor_version)) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2732
    if (name == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2733
      Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2734
        THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2735
        vmSymbols::java_lang_UnsupportedClassVersionError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2736
        "Unsupported major.minor version %u.%u",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2737
        major_version,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2738
        minor_version);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2739
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2740
      ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2741
      Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2742
        THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2743
        vmSymbols::java_lang_UnsupportedClassVersionError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2744
        "%s : Unsupported major.minor version %u.%u",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2745
        name->as_C_string(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2746
        major_version,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2747
        minor_version);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2748
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2749
    return nullHandle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2750
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2751
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2752
  _major_version = major_version;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2753
  _minor_version = minor_version;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2754
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2755
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2756
  // Check if verification needs to be relaxed for this class file
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2757
  // Do not restrict it to jdk1.0 or jdk1.1 to maintain backward compatibility (4982376)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2758
  _relax_verify = Verifier::relax_verify_for(class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2759
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2760
  // Constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2761
  constantPoolHandle cp = parse_constant_pool(CHECK_(nullHandle));
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2762
  ConstantPoolCleaner error_handler(cp); // set constant pool to be cleaned up.
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2763
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2764
  int cp_size = cp->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2765
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2766
  cfs->guarantee_more(8, CHECK_(nullHandle));  // flags, this_class, super_class, infs_len
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2767
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2768
  // Access flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2769
  AccessFlags access_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2770
  jint flags = cfs->get_u2_fast() & JVM_RECOGNIZED_CLASS_MODIFIERS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2771
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2772
  if ((flags & JVM_ACC_INTERFACE) && _major_version < JAVA_6_VERSION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2773
    // Set abstract bit for old class files for backward compatibility
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2774
    flags |= JVM_ACC_ABSTRACT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2775
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2776
  verify_legal_class_modifiers(flags, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2777
  access_flags.set_flags(flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2778
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2779
  // This class and superclass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2780
  instanceKlassHandle super_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2781
  u2 this_class_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2782
  check_property(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2783
    valid_cp_range(this_class_index, cp_size) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2784
      cp->tag_at(this_class_index).is_unresolved_klass(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2785
    "Invalid this class index %u in constant pool in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2786
    this_class_index, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2787
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2788
  Symbol*  class_name  = cp->unresolved_klass_at(this_class_index);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2789
  assert(class_name != NULL, "class_name can't be null");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2790
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2791
  // It's important to set parsed_name *before* resolving the super class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2792
  // (it's used for cleanup by the caller if parsing fails)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2793
  parsed_name = class_name;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2794
  // parsed_name is returned and can be used if there's an error, so add to
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2795
  // its reference count.  Caller will decrement the refcount.
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2796
  parsed_name->increment_refcount();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2797
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2798
  // Update _class_name which could be null previously to be class_name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2799
  _class_name = class_name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2800
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2801
  // Don't need to check whether this class name is legal or not.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2802
  // It has been checked when constant pool is parsed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2803
  // However, make sure it is not an array type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2804
  if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2805
    guarantee_property(class_name->byte_at(0) != JVM_SIGNATURE_ARRAY,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2806
                       "Bad class name in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2807
                       CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2808
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2809
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2810
  klassOop preserve_this_klass;   // for storing result across HandleMark
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2811
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2812
  // release all handles when parsing is done
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2813
  { HandleMark hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2814
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2815
    // Checks if name in class file matches requested name
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2816
    if (name != NULL && class_name != name) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2817
      ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2818
      Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2819
        THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2820
        vmSymbols::java_lang_NoClassDefFoundError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2821
        "%s (wrong name: %s)",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2822
        name->as_C_string(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2823
        class_name->as_C_string()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2824
      );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2825
      return nullHandle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2826
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2827
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2828
    if (TraceClassLoadingPreorder) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2829
      tty->print("[Loading %s", name->as_klass_external_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2830
      if (cfs->source() != NULL) tty->print(" from %s", cfs->source());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2831
      tty->print_cr("]");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2832
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2833
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2834
    u2 super_class_index = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2835
    if (super_class_index == 0) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2836
      check_property(class_name == vmSymbols::java_lang_Object(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2837
                     "Invalid superclass index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2838
                     super_class_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2839
                     CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2840
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2841
      check_property(valid_cp_range(super_class_index, cp_size) &&
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2842
                     is_klass_reference(cp, super_class_index),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2843
                     "Invalid superclass index %u in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2844
                     super_class_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2845
                     CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2846
      // The class name should be legal because it is checked when parsing constant pool.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2847
      // However, make sure it is not an array type.
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2848
      bool is_array = false;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2849
      if (cp->tag_at(super_class_index).is_klass()) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2850
        super_klass = instanceKlassHandle(THREAD, cp->resolved_klass_at(super_class_index));
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2851
        if (_need_verify)
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2852
          is_array = super_klass->oop_is_array();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2853
      } else if (_need_verify) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2854
        is_array = (cp->unresolved_klass_at(super_class_index)->byte_at(0) == JVM_SIGNATURE_ARRAY);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2855
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2856
      if (_need_verify) {
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2857
        guarantee_property(!is_array,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2858
                          "Bad superclass name in class file %s", CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2859
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2860
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2861
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2862
    // Interfaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2863
    u2 itfs_len = cfs->get_u2_fast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2864
    objArrayHandle local_interfaces;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2865
    if (itfs_len == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2866
      local_interfaces = objArrayHandle(THREAD, Universe::the_empty_system_obj_array());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2867
    } else {
3575
224791e7ecab 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 2534
diff changeset
  2868
      local_interfaces = parse_interfaces(cp, itfs_len, class_loader, protection_domain, _class_name, CHECK_(nullHandle));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2869
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2870
11412
62fe312f32c5 7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type.
jiangli
parents: 10546
diff changeset
  2871
    u2 java_fields_count = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2872
    // Fields (offsets are filled in later)
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  2873
    FieldAllocationCount fac;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2874
    objArrayHandle fields_annotations;
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  2875
    typeArrayHandle fields = parse_fields(class_name, cp, access_flags.is_interface(), &fac, &fields_annotations,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  2876
                                          &java_fields_count,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  2877
                                          CHECK_(nullHandle));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2878
    // Methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2879
    bool has_final_method = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2880
    AccessFlags promoted_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2881
    promoted_flags.set_flags(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2882
    // These need to be oop pointers because they are allocated lazily
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2883
    // inside parse_methods inside a nested HandleMark
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2884
    objArrayOop methods_annotations_oop = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2885
    objArrayOop methods_parameter_annotations_oop = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2886
    objArrayOop methods_default_annotations_oop = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2887
    objArrayHandle methods = parse_methods(cp, access_flags.is_interface(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2888
                                           &promoted_flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2889
                                           &has_final_method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2890
                                           &methods_annotations_oop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2891
                                           &methods_parameter_annotations_oop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2892
                                           &methods_default_annotations_oop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2893
                                           CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2894
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2895
    objArrayHandle methods_annotations(THREAD, methods_annotations_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2896
    objArrayHandle methods_parameter_annotations(THREAD, methods_parameter_annotations_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2897
    objArrayHandle methods_default_annotations(THREAD, methods_default_annotations_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2898
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2899
    // We check super class after class file is parsed and format is checked
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2900
    if (super_class_index > 0 && super_klass.is_null()) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2901
      Symbol*  sk  = cp->klass_name_at(super_class_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2902
      if (access_flags.is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2903
        // Before attempting to resolve the superclass, check for class format
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2904
        // errors not checked yet.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2905
        guarantee_property(sk == vmSymbols::java_lang_Object(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2906
                           "Interfaces must have java.lang.Object as superclass in class file %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2907
                           CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2908
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2909
      klassOop k = SystemDictionary::resolve_super_or_fail(class_name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2910
                                                           sk,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2911
                                                           class_loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2912
                                                           protection_domain,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2913
                                                           true,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2914
                                                           CHECK_(nullHandle));
3575
224791e7ecab 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 2534
diff changeset
  2915
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2916
      KlassHandle kh (THREAD, k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2917
      super_klass = instanceKlassHandle(THREAD, kh());
1661
7cb0f0d385f3 6779339: turn off LinkWellKnownClasses by default pending further testing
jrose
parents: 1550
diff changeset
  2918
      if (LinkWellKnownClasses)  // my super class is well known to me
7cb0f0d385f3 6779339: turn off LinkWellKnownClasses by default pending further testing
jrose
parents: 1550
diff changeset
  2919
        cp->klass_at_put(super_class_index, super_klass()); // eagerly resolve
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2920
    }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
  2921
    if (super_klass.not_null()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2922
      if (super_klass->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2923
        ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2924
        Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2925
          THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  2926
          vmSymbols::java_lang_IncompatibleClassChangeError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2927
          "class %s has interface %s as super class",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2928
          class_name->as_klass_external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2929
          super_klass->external_name()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2930
        );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2931
        return nullHandle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2932
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2933
      // Make sure super class is not final
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2934
      if (super_klass->is_final()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2935
        THROW_MSG_(vmSymbols::java_lang_VerifyError(), "Cannot inherit from final class", nullHandle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2936
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2937
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2938
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2939
    // Compute the transitive list of all unique interfaces implemented by this class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2940
    objArrayHandle transitive_interfaces = compute_transitive_interfaces(super_klass, local_interfaces, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2941
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2942
    // sort methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2943
    typeArrayHandle method_ordering = sort_methods(methods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2944
                                                   methods_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2945
                                                   methods_parameter_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2946
                                                   methods_default_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2947
                                                   CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2948
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2949
    // promote flags from parse_methods() to the klass' flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2950
    access_flags.add_promoted_flags(promoted_flags.as_int());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2951
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2952
    // Size of Java vtable (in words)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2953
    int vtable_size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2954
    int itable_size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2955
    int num_miranda_methods = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2956
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2957
    klassVtable::compute_vtable_size_and_num_mirandas(vtable_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2958
                                                      num_miranda_methods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2959
                                                      super_klass(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2960
                                                      methods(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2961
                                                      access_flags,
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2105
diff changeset
  2962
                                                      class_loader,
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2105
diff changeset
  2963
                                                      class_name,
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2105
diff changeset
  2964
                                                      local_interfaces(),
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2105
diff changeset
  2965
                                                      CHECK_(nullHandle));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2966
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2967
    // Size of Java itable (in words)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2968
    itable_size = access_flags.is_interface() ? 0 : klassItable::compute_itable_size(transitive_interfaces);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2969
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2970
    // Field size and offset computation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2971
    int nonstatic_field_size = super_klass() == NULL ? 0 : super_klass->nonstatic_field_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2972
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2973
    int orig_nonstatic_field_size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2974
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2975
    int static_field_size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2976
    int next_static_oop_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2977
    int next_static_double_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2978
    int next_static_word_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2979
    int next_static_short_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2980
    int next_static_byte_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2981
    int next_static_type_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2982
    int next_nonstatic_oop_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2983
    int next_nonstatic_double_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2984
    int next_nonstatic_word_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2985
    int next_nonstatic_short_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2986
    int next_nonstatic_byte_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2987
    int next_nonstatic_type_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2988
    int first_nonstatic_oop_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2989
    int first_nonstatic_field_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2990
    int next_nonstatic_field_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2991
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2992
    // Calculate the starting byte offsets
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8676
diff changeset
  2993
    next_static_oop_offset      = instanceMirrorKlass::offset_of_static_fields();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2994
    next_static_double_offset   = next_static_oop_offset +
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  2995
                                  (fac.count[STATIC_OOP] * heapOopSize);
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  2996
    if ( fac.count[STATIC_DOUBLE] &&
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2997
         (Universe::field_type_should_be_aligned(T_DOUBLE) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2998
          Universe::field_type_should_be_aligned(T_LONG)) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2999
      next_static_double_offset = align_size_up(next_static_double_offset, BytesPerLong);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3000
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3001
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3002
    next_static_word_offset     = next_static_double_offset +
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3003
                                  (fac.count[STATIC_DOUBLE] * BytesPerLong);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3004
    next_static_short_offset    = next_static_word_offset +
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3005
                                  (fac.count[STATIC_WORD] * BytesPerInt);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3006
    next_static_byte_offset     = next_static_short_offset +
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3007
                                  (fac.count[STATIC_SHORT] * BytesPerShort);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3008
    next_static_type_offset     = align_size_up((next_static_byte_offset +
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3009
                                  fac.count[STATIC_BYTE] ), wordSize );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3010
    static_field_size           = (next_static_type_offset -
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3011
                                  next_static_oop_offset) / wordSize;
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8676
diff changeset
  3012
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3013
    first_nonstatic_field_offset = instanceOopDesc::base_offset_in_bytes() +
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3014
                                   nonstatic_field_size * heapOopSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3015
    next_nonstatic_field_offset = first_nonstatic_field_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3016
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3017
    unsigned int nonstatic_double_count = fac.count[NONSTATIC_DOUBLE];
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3018
    unsigned int nonstatic_word_count   = fac.count[NONSTATIC_WORD];
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3019
    unsigned int nonstatic_short_count  = fac.count[NONSTATIC_SHORT];
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3020
    unsigned int nonstatic_byte_count   = fac.count[NONSTATIC_BYTE];
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3021
    unsigned int nonstatic_oop_count    = fac.count[NONSTATIC_OOP];
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3022
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3023
    bool super_has_nonstatic_fields =
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3024
            (super_klass() != NULL && super_klass->has_nonstatic_fields());
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3025
    bool has_nonstatic_fields  =  super_has_nonstatic_fields ||
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3026
            ((nonstatic_double_count + nonstatic_word_count +
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3027
              nonstatic_short_count + nonstatic_byte_count +
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3028
              nonstatic_oop_count) != 0);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3029
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3030
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3031
    // Prepare list of oops for oop map generation.
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3032
    int* nonstatic_oop_offsets;
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3033
    unsigned int* nonstatic_oop_counts;
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3034
    unsigned int nonstatic_oop_map_count = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3035
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3036
    nonstatic_oop_offsets = NEW_RESOURCE_ARRAY_IN_THREAD(
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3037
              THREAD, int, nonstatic_oop_count + 1);
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3038
    nonstatic_oop_counts  = NEW_RESOURCE_ARRAY_IN_THREAD(
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3039
              THREAD, unsigned int, nonstatic_oop_count + 1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3040
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3041
    first_nonstatic_oop_offset = 0; // will be set for first oop field
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3042
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3043
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3044
    if( PrintCompactFieldsSavings ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3045
      next_nonstatic_double_offset = next_nonstatic_field_offset +
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3046
                                     (nonstatic_oop_count * heapOopSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3047
      if ( nonstatic_double_count > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3048
        next_nonstatic_double_offset = align_size_up(next_nonstatic_double_offset, BytesPerLong);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3049
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3050
      next_nonstatic_word_offset  = next_nonstatic_double_offset +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3051
                                    (nonstatic_double_count * BytesPerLong);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3052
      next_nonstatic_short_offset = next_nonstatic_word_offset +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3053
                                    (nonstatic_word_count * BytesPerInt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3054
      next_nonstatic_byte_offset  = next_nonstatic_short_offset +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3055
                                    (nonstatic_short_count * BytesPerShort);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3056
      next_nonstatic_type_offset  = align_size_up((next_nonstatic_byte_offset +
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3057
                                    nonstatic_byte_count ), heapOopSize );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3058
      orig_nonstatic_field_size   = nonstatic_field_size +
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3059
      ((next_nonstatic_type_offset - first_nonstatic_field_offset)/heapOopSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3060
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3061
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3062
    bool compact_fields   = CompactFields;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3063
    int  allocation_style = FieldsAllocationStyle;
5250
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3064
    if( allocation_style < 0 || allocation_style > 2 ) { // Out of range?
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3065
      assert(false, "0 <= FieldsAllocationStyle <= 2");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3066
      allocation_style = 1; // Optimistic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3067
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3068
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3069
    // The next classes have predefined hard-coded fields offsets
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3070
    // (see in JavaClasses::compute_hard_coded_offsets()).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3071
    // Use default fields allocation order for them.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3072
    if( (allocation_style != 0 || compact_fields ) && class_loader.is_null() &&
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3073
        (class_name == vmSymbols::java_lang_AssertionStatusDirectives() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3074
         class_name == vmSymbols::java_lang_Class() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3075
         class_name == vmSymbols::java_lang_ClassLoader() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3076
         class_name == vmSymbols::java_lang_ref_Reference() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3077
         class_name == vmSymbols::java_lang_ref_SoftReference() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3078
         class_name == vmSymbols::java_lang_StackTraceElement() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3079
         class_name == vmSymbols::java_lang_String() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3080
         class_name == vmSymbols::java_lang_Throwable() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3081
         class_name == vmSymbols::java_lang_Boolean() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3082
         class_name == vmSymbols::java_lang_Character() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3083
         class_name == vmSymbols::java_lang_Float() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3084
         class_name == vmSymbols::java_lang_Double() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3085
         class_name == vmSymbols::java_lang_Byte() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3086
         class_name == vmSymbols::java_lang_Short() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3087
         class_name == vmSymbols::java_lang_Integer() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3088
         class_name == vmSymbols::java_lang_Long())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3089
      allocation_style = 0;     // Allocate oops first
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3090
      compact_fields   = false; // Don't compact fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3091
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3092
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3093
    if( allocation_style == 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3094
      // Fields order: oops, longs/doubles, ints, shorts/chars, bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3095
      next_nonstatic_oop_offset    = next_nonstatic_field_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3096
      next_nonstatic_double_offset = next_nonstatic_oop_offset +
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3097
                                      (nonstatic_oop_count * heapOopSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3098
    } else if( allocation_style == 1 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3099
      // Fields order: longs/doubles, ints, shorts/chars, bytes, oops
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3100
      next_nonstatic_double_offset = next_nonstatic_field_offset;
5250
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3101
    } else if( allocation_style == 2 ) {
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3102
      // Fields allocation: oops fields in super and sub classes are together.
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3103
      if( nonstatic_field_size > 0 && super_klass() != NULL &&
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3104
          super_klass->nonstatic_oop_map_size() > 0 ) {
10009
9fa7d67d09fe 7058036: FieldsAllocationStyle=2 does not work in 32-bit VM
kvn
parents: 9172
diff changeset
  3105
        int map_count = super_klass->nonstatic_oop_map_count();
5250
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3106
        OopMapBlock* first_map = super_klass->start_of_nonstatic_oop_maps();
10009
9fa7d67d09fe 7058036: FieldsAllocationStyle=2 does not work in 32-bit VM
kvn
parents: 9172
diff changeset
  3107
        OopMapBlock* last_map = first_map + map_count - 1;
5250
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3108
        int next_offset = last_map->offset() + (last_map->count() * heapOopSize);
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3109
        if (next_offset == next_nonstatic_field_offset) {
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3110
          allocation_style = 0;   // allocate oops first
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3111
          next_nonstatic_oop_offset    = next_nonstatic_field_offset;
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3112
          next_nonstatic_double_offset = next_nonstatic_oop_offset +
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3113
                                         (nonstatic_oop_count * heapOopSize);
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3114
        }
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3115
      }
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3116
      if( allocation_style == 2 ) {
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3117
        allocation_style = 1;     // allocate oops last
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3118
        next_nonstatic_double_offset = next_nonstatic_field_offset;
ea743ca75cd9 6940733: allocate non static oop fields in super and sub classes together
kvn
parents: 4573
diff changeset
  3119
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3120
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3121
      ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3122
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3123
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3124
    int nonstatic_oop_space_count   = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3125
    int nonstatic_word_space_count  = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3126
    int nonstatic_short_space_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3127
    int nonstatic_byte_space_count  = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3128
    int nonstatic_oop_space_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3129
    int nonstatic_word_space_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3130
    int nonstatic_short_space_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3131
    int nonstatic_byte_space_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3132
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3133
    if( nonstatic_double_count > 0 ) {
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3134
      int offset = next_nonstatic_double_offset;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3135
      next_nonstatic_double_offset = align_size_up(offset, BytesPerLong);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3136
      if( compact_fields && offset != next_nonstatic_double_offset ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3137
        // Allocate available fields into the gap before double field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3138
        int length = next_nonstatic_double_offset - offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3139
        assert(length == BytesPerInt, "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3140
        nonstatic_word_space_offset = offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3141
        if( nonstatic_word_count > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3142
          nonstatic_word_count      -= 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3143
          nonstatic_word_space_count = 1; // Only one will fit
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3144
          length -= BytesPerInt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3145
          offset += BytesPerInt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3146
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3147
        nonstatic_short_space_offset = offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3148
        while( length >= BytesPerShort && nonstatic_short_count > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3149
          nonstatic_short_count       -= 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3150
          nonstatic_short_space_count += 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3151
          length -= BytesPerShort;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3152
          offset += BytesPerShort;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3153
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3154
        nonstatic_byte_space_offset = offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3155
        while( length > 0 && nonstatic_byte_count > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3156
          nonstatic_byte_count       -= 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3157
          nonstatic_byte_space_count += 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3158
          length -= 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3159
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3160
        // Allocate oop field in the gap if there are no other fields for that.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3161
        nonstatic_oop_space_offset = offset;
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3162
        if( length >= heapOopSize && nonstatic_oop_count > 0 &&
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3163
            allocation_style != 0 ) { // when oop fields not first
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3164
          nonstatic_oop_count      -= 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3165
          nonstatic_oop_space_count = 1; // Only one will fit
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3166
          length -= heapOopSize;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3167
          offset += heapOopSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3168
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3169
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3170
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3171
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3172
    next_nonstatic_word_offset  = next_nonstatic_double_offset +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3173
                                  (nonstatic_double_count * BytesPerLong);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3174
    next_nonstatic_short_offset = next_nonstatic_word_offset +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3175
                                  (nonstatic_word_count * BytesPerInt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3176
    next_nonstatic_byte_offset  = next_nonstatic_short_offset +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3177
                                  (nonstatic_short_count * BytesPerShort);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3178
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3179
    int notaligned_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3180
    if( allocation_style == 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3181
      notaligned_offset = next_nonstatic_byte_offset + nonstatic_byte_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3182
    } else { // allocation_style == 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3183
      next_nonstatic_oop_offset = next_nonstatic_byte_offset + nonstatic_byte_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3184
      if( nonstatic_oop_count > 0 ) {
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3185
        next_nonstatic_oop_offset = align_size_up(next_nonstatic_oop_offset, heapOopSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3186
      }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3187
      notaligned_offset = next_nonstatic_oop_offset + (nonstatic_oop_count * heapOopSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3188
    }
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3189
    next_nonstatic_type_offset = align_size_up(notaligned_offset, heapOopSize );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3190
    nonstatic_field_size = nonstatic_field_size + ((next_nonstatic_type_offset
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3191
                                   - first_nonstatic_field_offset)/heapOopSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3192
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3193
    // Iterate over fields again and compute correct offsets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3194
    // The field allocation type was temporarily stored in the offset slot.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3195
    // oop fields are located before non-oop fields (static and non-static).
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3196
    for (AllFieldStream fs(fields, cp); !fs.done(); fs.next()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3197
      int real_offset;
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3198
      FieldAllocationType atype = (FieldAllocationType) fs.offset();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3199
      switch (atype) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3200
        case STATIC_OOP:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3201
          real_offset = next_static_oop_offset;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3202
          next_static_oop_offset += heapOopSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3203
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3204
        case STATIC_BYTE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3205
          real_offset = next_static_byte_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3206
          next_static_byte_offset += 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3207
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3208
        case STATIC_SHORT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3209
          real_offset = next_static_short_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3210
          next_static_short_offset += BytesPerShort;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3211
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3212
        case STATIC_WORD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3213
          real_offset = next_static_word_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3214
          next_static_word_offset += BytesPerInt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3215
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3216
        case STATIC_DOUBLE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3217
          real_offset = next_static_double_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3218
          next_static_double_offset += BytesPerLong;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3219
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3220
        case NONSTATIC_OOP:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3221
          if( nonstatic_oop_space_count > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3222
            real_offset = nonstatic_oop_space_offset;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3223
            nonstatic_oop_space_offset += heapOopSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3224
            nonstatic_oop_space_count  -= 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3225
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3226
            real_offset = next_nonstatic_oop_offset;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 339
diff changeset
  3227
            next_nonstatic_oop_offset += heapOopSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3228
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3229
          // Update oop maps
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3230
          if( nonstatic_oop_map_count > 0 &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3231
              nonstatic_oop_offsets[nonstatic_oop_map_count - 1] ==
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3232
              real_offset -
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3233
              int(nonstatic_oop_counts[nonstatic_oop_map_count - 1]) *
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3234
              heapOopSize ) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3235
            // Extend current oop map
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3236
            nonstatic_oop_counts[nonstatic_oop_map_count - 1] += 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3237
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3238
            // Create new oop map
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3239
            nonstatic_oop_offsets[nonstatic_oop_map_count] = real_offset;
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3240
            nonstatic_oop_counts [nonstatic_oop_map_count] = 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3241
            nonstatic_oop_map_count += 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3242
            if( first_nonstatic_oop_offset == 0 ) { // Undefined
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3243
              first_nonstatic_oop_offset = real_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3244
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3245
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3246
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3247
        case NONSTATIC_BYTE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3248
          if( nonstatic_byte_space_count > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3249
            real_offset = nonstatic_byte_space_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3250
            nonstatic_byte_space_offset += 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3251
            nonstatic_byte_space_count  -= 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3252
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3253
            real_offset = next_nonstatic_byte_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3254
            next_nonstatic_byte_offset += 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3255
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3256
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3257
        case NONSTATIC_SHORT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3258
          if( nonstatic_short_space_count > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3259
            real_offset = nonstatic_short_space_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3260
            nonstatic_short_space_offset += BytesPerShort;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3261
            nonstatic_short_space_count  -= 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3262
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3263
            real_offset = next_nonstatic_short_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3264
            next_nonstatic_short_offset += BytesPerShort;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3265
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3266
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3267
        case NONSTATIC_WORD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3268
          if( nonstatic_word_space_count > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3269
            real_offset = nonstatic_word_space_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3270
            nonstatic_word_space_offset += BytesPerInt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3271
            nonstatic_word_space_count  -= 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3272
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3273
            real_offset = next_nonstatic_word_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3274
            next_nonstatic_word_offset += BytesPerInt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3275
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3276
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3277
        case NONSTATIC_DOUBLE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3278
          real_offset = next_nonstatic_double_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3279
          next_nonstatic_double_offset += BytesPerLong;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3280
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3281
        default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3282
          ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3283
      }
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3284
      fs.set_offset(real_offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3285
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3286
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3287
    // Size of instances
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3288
    int instance_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3289
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3290
    next_nonstatic_type_offset = align_size_up(notaligned_offset, wordSize );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3291
    instance_size = align_object_size(next_nonstatic_type_offset / wordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3292
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3293
    assert(instance_size == align_object_size(align_size_up((instanceOopDesc::base_offset_in_bytes() + nonstatic_field_size*heapOopSize), wordSize) / wordSize), "consistent layout helper value");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3294
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3295
    // Number of non-static oop map blocks allocated at end of klass.
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3296
    const unsigned int total_oop_map_count =
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3297
      compute_oop_map_count(super_klass, nonstatic_oop_map_count,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3298
                            first_nonstatic_oop_offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3299
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3300
    // Compute reference type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3301
    ReferenceType rt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3302
    if (super_klass() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3303
      rt = REF_NONE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3304
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3305
      rt = super_klass->reference_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3306
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3307
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3308
    // We can now create the basic klassOop for this klass
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8676
diff changeset
  3309
    klassOop ik = oopFactory::new_instanceKlass(name, vtable_size, itable_size,
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3310
                                                static_field_size,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3311
                                                total_oop_map_count,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3312
                                                rt, CHECK_(nullHandle));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3313
    instanceKlassHandle this_klass (THREAD, ik);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3314
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3315
    assert(this_klass->static_field_size() == static_field_size, "sanity");
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3316
    assert(this_klass->nonstatic_oop_map_count() == total_oop_map_count,
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3317
           "sanity");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3318
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3319
    // Fill in information already parsed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3320
    this_klass->set_access_flags(access_flags);
3822
388b0393a042 6879572: SA fails _is_marked_dependent not found
acorn
parents: 3821
diff changeset
  3321
    this_klass->set_should_verify_class(verify);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3322
    jint lh = Klass::instance_layout_helper(instance_size, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3323
    this_klass->set_layout_helper(lh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3324
    assert(this_klass->oop_is_instance(), "layout is correct");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3325
    assert(this_klass->size_helper() == instance_size, "correct size_helper");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3326
    // Not yet: supers are done below to support the new subtype-checking fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3327
    //this_klass->set_super(super_klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3328
    this_klass->set_class_loader(class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3329
    this_klass->set_nonstatic_field_size(nonstatic_field_size);
3822
388b0393a042 6879572: SA fails _is_marked_dependent not found
acorn
parents: 3821
diff changeset
  3330
    this_klass->set_has_nonstatic_fields(has_nonstatic_fields);
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3331
    this_klass->set_static_oop_field_count(fac.count[STATIC_OOP]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3332
    cp->set_pool_holder(this_klass());
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3333
    error_handler.set_in_error(false);   // turn off error handler for cp
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3334
    this_klass->set_constants(cp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3335
    this_klass->set_local_interfaces(local_interfaces());
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10009
diff changeset
  3336
    this_klass->set_fields(fields(), java_fields_count);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3337
    this_klass->set_methods(methods());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3338
    if (has_final_method) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3339
      this_klass->set_has_final_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3340
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3341
    this_klass->set_method_ordering(method_ordering());
3824
86e9e4b25bdf 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 3822
diff changeset
  3342
    // The instanceKlass::_methods_jmethod_ids cache and the
86e9e4b25bdf 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 3822
diff changeset
  3343
    // instanceKlass::_methods_cached_itable_indices cache are
86e9e4b25bdf 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 3822
diff changeset
  3344
    // both managed on the assumption that the initial cache
86e9e4b25bdf 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 3822
diff changeset
  3345
    // size is equal to the number of methods in the class. If
86e9e4b25bdf 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 3822
diff changeset
  3346
    // that changes, then instanceKlass::idnum_can_increment()
86e9e4b25bdf 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 3822
diff changeset
  3347
    // has to be changed accordingly.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3348
    this_klass->set_initial_method_idnum(methods->length());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3349
    this_klass->set_name(cp->klass_name_at(this_class_index));
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2269
diff changeset
  3350
    if (LinkWellKnownClasses || is_anonymous())  // I am well known to myself
1661
7cb0f0d385f3 6779339: turn off LinkWellKnownClasses by default pending further testing
jrose
parents: 1550
diff changeset
  3351
      cp->klass_at_put(this_class_index, this_klass()); // eagerly resolve
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3352
    this_klass->set_protection_domain(protection_domain());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3353
    this_klass->set_fields_annotations(fields_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3354
    this_klass->set_methods_annotations(methods_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3355
    this_klass->set_methods_parameter_annotations(methods_parameter_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3356
    this_klass->set_methods_default_annotations(methods_default_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3357
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3358
    this_klass->set_minor_version(minor_version);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3359
    this_klass->set_major_version(major_version);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3360
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2534
diff changeset
  3361
    // Set up methodOop::intrinsic_id as soon as we know the names of methods.
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2534
diff changeset
  3362
    // (We used to do this lazily, but now we query it in Rewriter,
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2534
diff changeset
  3363
    // which is eagerly done for every method, so we might as well do it now,
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2534
diff changeset
  3364
    // when everything is fresh in memory.)
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2534
diff changeset
  3365
    if (methodOopDesc::klass_id_for_intrinsics(this_klass->as_klassOop()) != vmSymbols::NO_SID) {
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2534
diff changeset
  3366
      for (int j = 0; j < methods->length(); j++) {
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2534
diff changeset
  3367
        ((methodOop)methods->obj_at(j))->init_intrinsic_id();
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2534
diff changeset
  3368
      }
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2534
diff changeset
  3369
    }
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2534
diff changeset
  3370
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3371
    if (cached_class_file_bytes != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3372
      // JVMTI: we have an instanceKlass now, tell it about the cached bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3373
      this_klass->set_cached_class_file(cached_class_file_bytes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3374
                                        cached_class_file_length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3375
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3376
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3377
    // Miranda methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3378
    if ((num_miranda_methods > 0) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3379
        // if this class introduced new miranda methods or
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3380
        (super_klass.not_null() && (super_klass->has_miranda_methods()))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3381
        // super class exists and this class inherited miranda methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3382
        ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3383
      this_klass->set_has_miranda_methods(); // then set a flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3384
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3385
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3386
    // Additional attributes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3387
    parse_classfile_attributes(cp, this_klass, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3388
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3389
    // Make sure this is the end of class file stream
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3390
    guarantee_property(cfs->at_eos(), "Extra bytes at the end of class file %s", CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3391
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3392
    // VerifyOops believes that once this has been set, the object is completely loaded.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3393
    // Compute transitive closure of interfaces this class implements
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3394
    this_klass->set_transitive_interfaces(transitive_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3395
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3396
    // Fill in information needed to compute superclasses.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3397
    this_klass->initialize_supers(super_klass(), CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3398
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3399
    // Initialize itable offset tables
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3400
    klassItable::setup_itable_offset_table(this_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3401
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3402
    // Do final class setup
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3403
    fill_oop_maps(this_klass, nonstatic_oop_map_count, nonstatic_oop_offsets, nonstatic_oop_counts);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3404
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3405
    set_precomputed_flags(this_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3406
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3407
    // reinitialize modifiers, using the InnerClasses attribute
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3408
    int computed_modifiers = this_klass->compute_modifier_flags(CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3409
    this_klass->set_modifier_flags(computed_modifiers);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3410
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3411
    // check if this class can access its super class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3412
    check_super_class_access(this_klass, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3413
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3414
    // check if this class can access its superinterfaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3415
    check_super_interface_access(this_klass, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3416
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3417
    // check if this class overrides any final method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3418
    check_final_method_override(this_klass, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3419
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3420
    // check that if this class is an interface then it doesn't have static methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3421
    if (this_klass->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3422
      check_illegal_static_method(this_klass, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3423
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3424
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8676
diff changeset
  3425
    // Allocate mirror and initialize static fields
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8676
diff changeset
  3426
    java_lang_Class::create_mirror(this_klass, CHECK_(nullHandle));
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8676
diff changeset
  3427
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3428
    ClassLoadingService::notify_class_loaded(instanceKlass::cast(this_klass()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3429
                                             false /* not shared class */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3430
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3431
    if (TraceClassLoading) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3432
      // print in a single call to reduce interleaving of output
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3433
      if (cfs->source() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3434
        tty->print("[Loaded %s from %s]\n", this_klass->external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3435
                   cfs->source());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3436
      } else if (class_loader.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3437
        if (THREAD->is_Java_thread()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3438
          klassOop caller = ((JavaThread*)THREAD)->security_get_caller_class(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3439
          tty->print("[Loaded %s by instance of %s]\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3440
                     this_klass->external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3441
                     instanceKlass::cast(caller)->external_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3442
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3443
          tty->print("[Loaded %s]\n", this_klass->external_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3444
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3445
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3446
        ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3447
        tty->print("[Loaded %s from %s]\n", this_klass->external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3448
                   instanceKlass::cast(class_loader->klass())->external_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3449
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3450
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3451
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3452
    if (TraceClassResolution) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3453
      // print out the superclass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3454
      const char * from = Klass::cast(this_klass())->external_name();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3455
      if (this_klass->java_super() != NULL) {
2269
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2264
diff changeset
  3456
        tty->print("RESOLVE %s %s (super)\n", from, instanceKlass::cast(this_klass->java_super())->external_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3457
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3458
      // print out each of the interface classes referred to by this class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3459
      objArrayHandle local_interfaces(THREAD, this_klass->local_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3460
      if (!local_interfaces.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3461
        int length = local_interfaces->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3462
        for (int i = 0; i < length; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3463
          klassOop k = klassOop(local_interfaces->obj_at(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3464
          instanceKlass* to_class = instanceKlass::cast(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3465
          const char * to = to_class->external_name();
2269
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2264
diff changeset
  3466
          tty->print("RESOLVE %s %s (interface)\n", from, to);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3467
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3468
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3469
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3470
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3471
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3472
    if( PrintCompactFieldsSavings ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3473
      if( nonstatic_field_size < orig_nonstatic_field_size ) {
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3474
        tty->print("[Saved %d of %d bytes in %s]\n",
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3475
                 (orig_nonstatic_field_size - nonstatic_field_size)*heapOopSize,
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3476
                 orig_nonstatic_field_size*heapOopSize,
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3477
                 this_klass->external_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3478
      } else if( nonstatic_field_size > orig_nonstatic_field_size ) {
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3479
        tty->print("[Wasted %d over %d bytes in %s]\n",
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3480
                 (nonstatic_field_size - orig_nonstatic_field_size)*heapOopSize,
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3481
                 orig_nonstatic_field_size*heapOopSize,
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 383
diff changeset
  3482
                 this_klass->external_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3483
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3484
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3485
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3486
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3487
    // preserve result across HandleMark
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3488
    preserve_this_klass = this_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3489
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3490
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3491
  // Create new handle outside HandleMark
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3492
  instanceKlassHandle this_klass (THREAD, preserve_this_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3493
  debug_only(this_klass->as_klassOop()->verify();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3494
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3495
  return this_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3496
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3497
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3498
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3499
unsigned int
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3500
ClassFileParser::compute_oop_map_count(instanceKlassHandle super,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3501
                                       unsigned int nonstatic_oop_map_count,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3502
                                       int first_nonstatic_oop_offset) {
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3503
  unsigned int map_count =
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3504
    super.is_null() ? 0 : super->nonstatic_oop_map_count();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3505
  if (nonstatic_oop_map_count > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3506
    // We have oops to add to map
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3507
    if (map_count == 0) {
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3508
      map_count = nonstatic_oop_map_count;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3509
    } else {
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3510
      // Check whether we should add a new map block or whether the last one can
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3511
      // be extended
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3512
      OopMapBlock* const first_map = super->start_of_nonstatic_oop_maps();
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3513
      OopMapBlock* const last_map = first_map + map_count - 1;
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3514
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3515
      int next_offset = last_map->offset() + last_map->count() * heapOopSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3516
      if (next_offset == first_nonstatic_oop_offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3517
        // There is no gap bettwen superklass's last oop field and first
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3518
        // local oop field, merge maps.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3519
        nonstatic_oop_map_count -= 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3520
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3521
        // Superklass didn't end with a oop field, add extra maps
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3522
        assert(next_offset < first_nonstatic_oop_offset, "just checking");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3523
      }
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3524
      map_count += nonstatic_oop_map_count;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3525
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3526
  }
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3527
  return map_count;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3528
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3529
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3530
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3531
void ClassFileParser::fill_oop_maps(instanceKlassHandle k,
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3532
                                    unsigned int nonstatic_oop_map_count,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3533
                                    int* nonstatic_oop_offsets,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3534
                                    unsigned int* nonstatic_oop_counts) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3535
  OopMapBlock* this_oop_map = k->start_of_nonstatic_oop_maps();
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3536
  const instanceKlass* const super = k->superklass();
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3537
  const unsigned int super_count = super ? super->nonstatic_oop_map_count() : 0;
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3538
  if (super_count > 0) {
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3539
    // Copy maps from superklass
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3540
    OopMapBlock* super_oop_map = super->start_of_nonstatic_oop_maps();
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
  3541
    for (unsigned int i = 0; i < super_count; ++i) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3542
      *this_oop_map++ = *super_oop_map++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3543
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3544
  }
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3545
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3546
  if (nonstatic_oop_map_count > 0) {
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3547
    if (super_count + nonstatic_oop_map_count > k->nonstatic_oop_map_count()) {
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3548
      // The counts differ because there is no gap between superklass's last oop
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3549
      // field and the first local oop field.  Extend the last oop map copied
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3550
      // from the superklass instead of creating new one.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3551
      nonstatic_oop_map_count--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3552
      nonstatic_oop_offsets++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3553
      this_oop_map--;
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3554
      this_oop_map->set_count(this_oop_map->count() + *nonstatic_oop_counts++);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3555
      this_oop_map++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3556
    }
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3557
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3558
    // Add new map blocks, fill them
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3559
    while (nonstatic_oop_map_count-- > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3560
      this_oop_map->set_offset(*nonstatic_oop_offsets++);
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3561
      this_oop_map->set_count(*nonstatic_oop_counts++);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3562
      this_oop_map++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3563
    }
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3564
    assert(k->start_of_nonstatic_oop_maps() + k->nonstatic_oop_map_count() ==
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 3579
diff changeset
  3565
           this_oop_map, "sanity");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3566
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3567
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3568
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3569
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3570
void ClassFileParser::set_precomputed_flags(instanceKlassHandle k) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3571
  klassOop super = k->super();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3572
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3573
  // Check if this klass has an empty finalize method (i.e. one with return bytecode only),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3574
  // in which case we don't have to register objects as finalizable
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3575
  if (!_has_empty_finalizer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3576
    if (_has_finalizer ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3577
        (super != NULL && super->klass_part()->has_finalizer())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3578
      k->set_has_finalizer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3579
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3580
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3581
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3582
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3583
  bool f = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3584
  methodOop m = k->lookup_method(vmSymbols::finalize_method_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3585
                                 vmSymbols::void_method_signature());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3586
  if (m != NULL && !m->is_empty_method()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3587
    f = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3588
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3589
  assert(f == k->has_finalizer(), "inconsistent has_finalizer");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3590
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3591
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3592
  // Check if this klass supports the java.lang.Cloneable interface
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
  3593
  if (SystemDictionary::Cloneable_klass_loaded()) {
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
  3594
    if (k->is_subtype_of(SystemDictionary::Cloneable_klass())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3595
      k->set_is_cloneable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3596
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3597
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3598
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3599
  // Check if this klass has a vanilla default constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3600
  if (super == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3601
    // java.lang.Object has empty default constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3602
    k->set_has_vanilla_constructor();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3603
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3604
    if (Klass::cast(super)->has_vanilla_constructor() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3605
        _has_vanilla_constructor) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3606
      k->set_has_vanilla_constructor();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3607
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3608
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3609
    bool v = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3610
    if (Klass::cast(super)->has_vanilla_constructor()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3611
      methodOop constructor = k->find_method(vmSymbols::object_initializer_name(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3612
), vmSymbols::void_method_signature());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3613
      if (constructor != NULL && constructor->is_vanilla_constructor()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3614
        v = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3615
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3616
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3617
    assert(v == k->has_vanilla_constructor(), "inconsistent has_vanilla_constructor");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3618
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3619
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3620
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3621
  // If it cannot be fast-path allocated, set a bit in the layout helper.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3622
  // See documentation of instanceKlass::can_be_fastpath_allocated().
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3623
  assert(k->size_helper() > 0, "layout_helper is initialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3624
  if ((!RegisterFinalizersAtInit && k->has_finalizer())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3625
      || k->is_abstract() || k->is_interface()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3626
      || (k->name() == vmSymbols::java_lang_Class()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3627
          && k->class_loader() == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3628
      || k->size_helper() >= FastAllocateSizeLimit) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3629
    // Forbid fast-path allocation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3630
    jint lh = Klass::instance_layout_helper(k->size_helper(), true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3631
    k->set_layout_helper(lh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3632
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3633
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3634
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3635
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3636
// utility method for appending and array with check for duplicates
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3637
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3638
void append_interfaces(objArrayHandle result, int& index, objArrayOop ifs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3639
  // iterate over new interfaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3640
  for (int i = 0; i < ifs->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3641
    oop e = ifs->obj_at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3642
    assert(e->is_klass() && instanceKlass::cast(klassOop(e))->is_interface(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3643
    // check for duplicates
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3644
    bool duplicate = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3645
    for (int j = 0; j < index; j++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3646
      if (result->obj_at(j) == e) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3647
        duplicate = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3648
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3649
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3650
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3651
    // add new interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3652
    if (!duplicate) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3653
      result->obj_at_put(index++, e);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3654
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3655
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3656
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3657
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3658
objArrayHandle ClassFileParser::compute_transitive_interfaces(instanceKlassHandle super, objArrayHandle local_ifs, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3659
  // Compute maximum size for transitive interfaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3660
  int max_transitive_size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3661
  int super_size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3662
  // Add superclass transitive interfaces size
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3663
  if (super.not_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3664
    super_size = super->transitive_interfaces()->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3665
    max_transitive_size += super_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3666
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3667
  // Add local interfaces' super interfaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3668
  int local_size = local_ifs->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3669
  for (int i = 0; i < local_size; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3670
    klassOop l = klassOop(local_ifs->obj_at(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3671
    max_transitive_size += instanceKlass::cast(l)->transitive_interfaces()->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3672
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3673
  // Finally add local interfaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3674
  max_transitive_size += local_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3675
  // Construct array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3676
  objArrayHandle result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3677
  if (max_transitive_size == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3678
    // no interfaces, use canonicalized array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3679
    result = objArrayHandle(THREAD, Universe::the_empty_system_obj_array());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3680
  } else if (max_transitive_size == super_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3681
    // no new local interfaces added, share superklass' transitive interface array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3682
    result = objArrayHandle(THREAD, super->transitive_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3683
  } else if (max_transitive_size == local_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3684
    // only local interfaces added, share local interface array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3685
    result = local_ifs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3686
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3687
    objArrayHandle nullHandle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3688
    objArrayOop new_objarray = oopFactory::new_system_objArray(max_transitive_size, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3689
    result = objArrayHandle(THREAD, new_objarray);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3690
    int index = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3691
    // Copy down from superclass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3692
    if (super.not_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3693
      append_interfaces(result, index, super->transitive_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3694
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3695
    // Copy down from local interfaces' superinterfaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3696
    for (int i = 0; i < local_ifs->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3697
      klassOop l = klassOop(local_ifs->obj_at(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3698
      append_interfaces(result, index, instanceKlass::cast(l)->transitive_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3699
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3700
    // Finally add local interfaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3701
    append_interfaces(result, index, local_ifs());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3702
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3703
    // Check if duplicates were removed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3704
    if (index != max_transitive_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3705
      assert(index < max_transitive_size, "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3706
      objArrayOop new_result = oopFactory::new_system_objArray(index, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3707
      for (int i = 0; i < index; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3708
        oop e = result->obj_at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3709
        assert(e != NULL, "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3710
        new_result->obj_at_put(i, e);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3711
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3712
      result = objArrayHandle(THREAD, new_result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3713
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3714
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3715
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3716
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3717
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3718
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3719
void ClassFileParser::check_super_class_access(instanceKlassHandle this_klass, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3720
  klassOop super = this_klass->super();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3721
  if ((super != NULL) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3722
      (!Reflection::verify_class_access(this_klass->as_klassOop(), super, false))) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3723
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3724
    Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3725
      THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3726
      vmSymbols::java_lang_IllegalAccessError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3727
      "class %s cannot access its superclass %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3728
      this_klass->external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3729
      instanceKlass::cast(super)->external_name()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3730
    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3731
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3732
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3733
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3734
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3735
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3736
void ClassFileParser::check_super_interface_access(instanceKlassHandle this_klass, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3737
  objArrayHandle local_interfaces (THREAD, this_klass->local_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3738
  int lng = local_interfaces->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3739
  for (int i = lng - 1; i >= 0; i--) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3740
    klassOop k = klassOop(local_interfaces->obj_at(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3741
    assert (k != NULL && Klass::cast(k)->is_interface(), "invalid interface");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3742
    if (!Reflection::verify_class_access(this_klass->as_klassOop(), k, false)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3743
      ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3744
      Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3745
        THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3746
        vmSymbols::java_lang_IllegalAccessError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3747
        "class %s cannot access its superinterface %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3748
        this_klass->external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3749
        instanceKlass::cast(k)->external_name()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3750
      );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3751
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3752
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3753
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3754
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3755
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3756
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3757
void ClassFileParser::check_final_method_override(instanceKlassHandle this_klass, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3758
  objArrayHandle methods (THREAD, this_klass->methods());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3759
  int num_methods = methods->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3760
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3761
  // go thru each method and check if it overrides a final method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3762
  for (int index = 0; index < num_methods; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3763
    methodOop m = (methodOop)methods->obj_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3764
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3765
    // skip private, static and <init> methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3766
    if ((!m->is_private()) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3767
        (!m->is_static()) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3768
        (m->name() != vmSymbols::object_initializer_name())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3769
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3770
      Symbol* name = m->name();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3771
      Symbol* signature = m->signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3772
      klassOop k = this_klass->super();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3773
      methodOop super_m = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3774
      while (k != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3775
        // skip supers that don't have final methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3776
        if (k->klass_part()->has_final_method()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3777
          // lookup a matching method in the super class hierarchy
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3778
          super_m = instanceKlass::cast(k)->lookup_method(name, signature);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3779
          if (super_m == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3780
            break; // didn't find any match; get out
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3781
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3782
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3783
          if (super_m->is_final() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3784
              // matching method in super is final
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3785
              (Reflection::verify_field_access(this_klass->as_klassOop(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3786
                                               super_m->method_holder(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3787
                                               super_m->method_holder(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3788
                                               super_m->access_flags(), false))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3789
            // this class can access super final method and therefore override
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3790
            ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3791
            ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3792
            Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3793
              THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3794
              vmSymbols::java_lang_VerifyError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3795
              "class %s overrides final method %s.%s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3796
              this_klass->external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3797
              name->as_C_string(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3798
              signature->as_C_string()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3799
            );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3800
            return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3801
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3802
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3803
          // continue to look from super_m's holder's super.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3804
          k = instanceKlass::cast(super_m->method_holder())->super();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3805
          continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3806
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3807
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3808
        k = k->klass_part()->super();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3809
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3810
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3811
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3812
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3813
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3814
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3815
// assumes that this_klass is an interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3816
void ClassFileParser::check_illegal_static_method(instanceKlassHandle this_klass, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3817
  assert(this_klass->is_interface(), "not an interface");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3818
  objArrayHandle methods (THREAD, this_klass->methods());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3819
  int num_methods = methods->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3820
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3821
  for (int index = 0; index < num_methods; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3822
    methodOop m = (methodOop)methods->obj_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3823
    // if m is static and not the init method, throw a verify error
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3824
    if ((m->is_static()) && (m->name() != vmSymbols::class_initializer_name())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3825
      ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3826
      Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3827
        THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3828
        vmSymbols::java_lang_VerifyError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3829
        "Illegal static method %s in interface %s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3830
        m->name()->as_C_string(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3831
        this_klass->external_name()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3832
      );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3833
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3834
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3835
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3836
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3837
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3838
// utility methods for format checking
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3839
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3840
void ClassFileParser::verify_legal_class_modifiers(jint flags, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3841
  if (!_need_verify) { return; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3842
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3843
  const bool is_interface  = (flags & JVM_ACC_INTERFACE)  != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3844
  const bool is_abstract   = (flags & JVM_ACC_ABSTRACT)   != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3845
  const bool is_final      = (flags & JVM_ACC_FINAL)      != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3846
  const bool is_super      = (flags & JVM_ACC_SUPER)      != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3847
  const bool is_enum       = (flags & JVM_ACC_ENUM)       != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3848
  const bool is_annotation = (flags & JVM_ACC_ANNOTATION) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3849
  const bool major_gte_15  = _major_version >= JAVA_1_5_VERSION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3850
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3851
  if ((is_abstract && is_final) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3852
      (is_interface && !is_abstract) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3853
      (is_interface && major_gte_15 && (is_super || is_enum)) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3854
      (!is_interface && major_gte_15 && is_annotation)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3855
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3856
    Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3857
      THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3858
      vmSymbols::java_lang_ClassFormatError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3859
      "Illegal class modifiers in class %s: 0x%X",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3860
      _class_name->as_C_string(), flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3861
    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3862
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3863
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3864
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3865
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3866
bool ClassFileParser::has_illegal_visibility(jint flags) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3867
  const bool is_public    = (flags & JVM_ACC_PUBLIC)    != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3868
  const bool is_protected = (flags & JVM_ACC_PROTECTED) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3869
  const bool is_private   = (flags & JVM_ACC_PRIVATE)   != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3870
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3871
  return ((is_public && is_protected) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3872
          (is_public && is_private) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3873
          (is_protected && is_private));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3874
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3875
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3876
bool ClassFileParser::is_supported_version(u2 major, u2 minor) {
4494
1f53dff2f6a5 6899467: System property java.class.version out-of-sync with VM for jdk 5.0 with HS 16 in nightly build
xlu
parents: 3824
diff changeset
  3877
  u2 max_version =
1f53dff2f6a5 6899467: System property java.class.version out-of-sync with VM for jdk 5.0 with HS 16 in nightly build
xlu
parents: 3824
diff changeset
  3878
    JDK_Version::is_gte_jdk17x_version() ? JAVA_MAX_SUPPORTED_VERSION :
1f53dff2f6a5 6899467: System property java.class.version out-of-sync with VM for jdk 5.0 with HS 16 in nightly build
xlu
parents: 3824
diff changeset
  3879
    (JDK_Version::is_gte_jdk16x_version() ? JAVA_6_VERSION : JAVA_1_5_VERSION);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3880
  return (major >= JAVA_MIN_SUPPORTED_VERSION) &&
602
92e03692ddd6 6705523: Fix for 6695506 will violate spec when used in JDK6
kamg
parents: 383
diff changeset
  3881
         (major <= max_version) &&
92e03692ddd6 6705523: Fix for 6695506 will violate spec when used in JDK6
kamg
parents: 383
diff changeset
  3882
         ((major != max_version) ||
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3883
          (minor <= JAVA_MAX_SUPPORTED_MINOR_VERSION));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3884
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3885
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3886
void ClassFileParser::verify_legal_field_modifiers(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3887
    jint flags, bool is_interface, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3888
  if (!_need_verify) { return; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3889
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3890
  const bool is_public    = (flags & JVM_ACC_PUBLIC)    != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3891
  const bool is_protected = (flags & JVM_ACC_PROTECTED) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3892
  const bool is_private   = (flags & JVM_ACC_PRIVATE)   != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3893
  const bool is_static    = (flags & JVM_ACC_STATIC)    != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3894
  const bool is_final     = (flags & JVM_ACC_FINAL)     != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3895
  const bool is_volatile  = (flags & JVM_ACC_VOLATILE)  != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3896
  const bool is_transient = (flags & JVM_ACC_TRANSIENT) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3897
  const bool is_enum      = (flags & JVM_ACC_ENUM)      != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3898
  const bool major_gte_15 = _major_version >= JAVA_1_5_VERSION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3899
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3900
  bool is_illegal = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3901
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3902
  if (is_interface) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3903
    if (!is_public || !is_static || !is_final || is_private ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3904
        is_protected || is_volatile || is_transient ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3905
        (major_gte_15 && is_enum)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3906
      is_illegal = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3907
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3908
  } else { // not interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3909
    if (has_illegal_visibility(flags) || (is_final && is_volatile)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3910
      is_illegal = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3911
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3912
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3913
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3914
  if (is_illegal) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3915
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3916
    Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3917
      THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3918
      vmSymbols::java_lang_ClassFormatError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3919
      "Illegal field modifiers in class %s: 0x%X",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3920
      _class_name->as_C_string(), flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3921
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3922
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3923
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3924
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3925
void ClassFileParser::verify_legal_method_modifiers(
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3926
    jint flags, bool is_interface, Symbol* name, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3927
  if (!_need_verify) { return; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3928
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3929
  const bool is_public       = (flags & JVM_ACC_PUBLIC)       != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3930
  const bool is_private      = (flags & JVM_ACC_PRIVATE)      != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3931
  const bool is_static       = (flags & JVM_ACC_STATIC)       != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3932
  const bool is_final        = (flags & JVM_ACC_FINAL)        != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3933
  const bool is_native       = (flags & JVM_ACC_NATIVE)       != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3934
  const bool is_abstract     = (flags & JVM_ACC_ABSTRACT)     != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3935
  const bool is_bridge       = (flags & JVM_ACC_BRIDGE)       != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3936
  const bool is_strict       = (flags & JVM_ACC_STRICT)       != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3937
  const bool is_synchronized = (flags & JVM_ACC_SYNCHRONIZED) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3938
  const bool major_gte_15    = _major_version >= JAVA_1_5_VERSION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3939
  const bool is_initializer  = (name == vmSymbols::object_initializer_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3940
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3941
  bool is_illegal = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3942
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3943
  if (is_interface) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3944
    if (!is_abstract || !is_public || is_static || is_final ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3945
        is_native || (major_gte_15 && (is_synchronized || is_strict))) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3946
      is_illegal = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3947
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3948
  } else { // not interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3949
    if (is_initializer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3950
      if (is_static || is_final || is_synchronized || is_native ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3951
          is_abstract || (major_gte_15 && is_bridge)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3952
        is_illegal = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3953
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3954
    } else { // not initializer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3955
      if (is_abstract) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3956
        if ((is_final || is_native || is_private || is_static ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3957
            (major_gte_15 && (is_synchronized || is_strict)))) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3958
          is_illegal = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3959
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3960
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3961
      if (has_illegal_visibility(flags)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3962
        is_illegal = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3963
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3964
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3965
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3966
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3967
  if (is_illegal) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3968
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3969
    Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3970
      THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  3971
      vmSymbols::java_lang_ClassFormatError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3972
      "Method %s in class %s has illegal modifiers: 0x%X",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3973
      name->as_C_string(), _class_name->as_C_string(), flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3974
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3975
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3976
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3977
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3978
void ClassFileParser::verify_legal_utf8(const unsigned char* buffer, int length, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3979
  assert(_need_verify, "only called when _need_verify is true");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3980
  int i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3981
  int count = length >> 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3982
  for (int k=0; k<count; k++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3983
    unsigned char b0 = buffer[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3984
    unsigned char b1 = buffer[i+1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3985
    unsigned char b2 = buffer[i+2];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3986
    unsigned char b3 = buffer[i+3];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3987
    // For an unsigned char v,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3988
    // (v | v - 1) is < 128 (highest bit 0) for 0 < v < 128;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3989
    // (v | v - 1) is >= 128 (highest bit 1) for v == 0 or v >= 128.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3990
    unsigned char res = b0 | b0 - 1 |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3991
                        b1 | b1 - 1 |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3992
                        b2 | b2 - 1 |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3993
                        b3 | b3 - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3994
    if (res >= 128) break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3995
    i += 4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3996
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3997
  for(; i < length; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3998
    unsigned short c;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3999
    // no embedded zeros
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4000
    guarantee_property((buffer[i] != 0), "Illegal UTF8 string in constant pool in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4001
    if(buffer[i] < 128) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4002
      continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4003
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4004
    if ((i + 5) < length) { // see if it's legal supplementary character
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4005
      if (UTF8::is_supplementary_character(&buffer[i])) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4006
        c = UTF8::get_supplementary_character(&buffer[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4007
        i += 5;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4008
        continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4009
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4010
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4011
    switch (buffer[i] >> 4) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4012
      default: break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4013
      case 0x8: case 0x9: case 0xA: case 0xB: case 0xF:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4014
        classfile_parse_error("Illegal UTF8 string in constant pool in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4015
      case 0xC: case 0xD:  // 110xxxxx  10xxxxxx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4016
        c = (buffer[i] & 0x1F) << 6;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4017
        i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4018
        if ((i < length) && ((buffer[i] & 0xC0) == 0x80)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4019
          c += buffer[i] & 0x3F;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4020
          if (_major_version <= 47 || c == 0 || c >= 0x80) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4021
            // for classes with major > 47, c must a null or a character in its shortest form
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4022
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4023
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4024
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4025
        classfile_parse_error("Illegal UTF8 string in constant pool in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4026
      case 0xE:  // 1110xxxx 10xxxxxx 10xxxxxx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4027
        c = (buffer[i] & 0xF) << 12;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4028
        i += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4029
        if ((i < length) && ((buffer[i-1] & 0xC0) == 0x80) && ((buffer[i] & 0xC0) == 0x80)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4030
          c += ((buffer[i-1] & 0x3F) << 6) + (buffer[i] & 0x3F);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4031
          if (_major_version <= 47 || c >= 0x800) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4032
            // for classes with major > 47, c must be in its shortest form
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4033
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4034
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4035
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4036
        classfile_parse_error("Illegal UTF8 string in constant pool in class file %s", CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4037
    }  // end of switch
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4038
  } // end of for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4039
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4040
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4041
// Checks if name is a legal class name.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  4042
void ClassFileParser::verify_legal_class_name(Symbol* name, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4043
  if (!_need_verify || _relax_verify) { return; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4044
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4045
  char buf[fixed_buffer_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4046
  char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4047
  unsigned int length = name->utf8_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4048
  bool legal = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4049
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4050
  if (length > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4051
    char* p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4052
    if (bytes[0] == JVM_SIGNATURE_ARRAY) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4053
      p = skip_over_field_signature(bytes, false, length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4054
      legal = (p != NULL) && ((p - bytes) == (int)length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4055
    } else if (_major_version < JAVA_1_5_VERSION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4056
      if (bytes[0] != '<') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4057
        p = skip_over_field_name(bytes, true, length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4058
        legal = (p != NULL) && ((p - bytes) == (int)length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4059
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4060
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4061
      // 4900761: relax the constraints based on JSR202 spec
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4062
      // Class names may be drawn from the entire Unicode character set.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4063
      // Identifiers between '/' must be unqualified names.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4064
      // The utf8 string has been verified when parsing cpool entries.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4065
      legal = verify_unqualified_name(bytes, length, LegalClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4066
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4067
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4068
  if (!legal) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4069
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4070
    Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4071
      THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  4072
      vmSymbols::java_lang_ClassFormatError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4073
      "Illegal class name \"%s\" in class file %s", bytes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4074
      _class_name->as_C_string()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4075
    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4076
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4077
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4078
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4079
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4080
// Checks if name is a legal field name.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  4081
void ClassFileParser::verify_legal_field_name(Symbol* name, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4082
  if (!_need_verify || _relax_verify) { return; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4083
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4084
  char buf[fixed_buffer_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4085
  char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4086
  unsigned int length = name->utf8_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4087
  bool legal = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4088
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4089
  if (length > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4090
    if (_major_version < JAVA_1_5_VERSION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4091
      if (bytes[0] != '<') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4092
        char* p = skip_over_field_name(bytes, false, length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4093
        legal = (p != NULL) && ((p - bytes) == (int)length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4094
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4095
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4096
      // 4881221: relax the constraints based on JSR202 spec
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4097
      legal = verify_unqualified_name(bytes, length, LegalField);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4098
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4099
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4100
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4101
  if (!legal) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4102
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4103
    Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4104
      THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  4105
      vmSymbols::java_lang_ClassFormatError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4106
      "Illegal field name \"%s\" in class %s", bytes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4107
      _class_name->as_C_string()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4108
    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4109
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4110
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4111
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4112
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4113
// Checks if name is a legal method name.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  4114
void ClassFileParser::verify_legal_method_name(Symbol* name, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4115
  if (!_need_verify || _relax_verify) { return; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4116
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  4117
  assert(name != NULL, "method name is null");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4118
  char buf[fixed_buffer_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4119
  char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4120
  unsigned int length = name->utf8_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4121
  bool legal = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4122
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4123
  if (length > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4124
    if (bytes[0] == '<') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4125
      if (name == vmSymbols::object_initializer_name() || name == vmSymbols::class_initializer_name()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4126
        legal = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4127
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4128
    } else if (_major_version < JAVA_1_5_VERSION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4129
      char* p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4130
      p = skip_over_field_name(bytes, false, length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4131
      legal = (p != NULL) && ((p - bytes) == (int)length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4132
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4133
      // 4881221: relax the constraints based on JSR202 spec
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4134
      legal = verify_unqualified_name(bytes, length, LegalMethod);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4135
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4136
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4137
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4138
  if (!legal) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4139
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4140
    Exceptions::fthrow(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4141
      THREAD_AND_LOCATION,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  4142
      vmSymbols::java_lang_ClassFormatError(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4143
      "Illegal method name \"%s\" in class %s", bytes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4144
      _class_name->as_C_string()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4145
    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4146
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4147
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4148
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4149
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4150
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4151
// Checks if signature is a legal field signature.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  4152
void ClassFileParser::verify_legal_field_signature(Symbol* name, Symbol* signature, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4153
  if (!_need_verify) { return; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4154
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4155
  char buf[fixed_buffer_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4156
  char* bytes = signature->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4157
  unsigned int length = signature->utf8_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4158
  char* p = skip_over_field_signature(bytes, false, length, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4159
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4160
  if (p == NULL || (p - bytes) != (int)length) {
5709
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
  4161
    throwIllegalSignature("Field", name, signature, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4162
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4163
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4164
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4165
// Checks if signature is a legal method signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4166
// Returns number of parameters
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  4167
int ClassFileParser::verify_legal_method_signature(Symbol* name, Symbol* signature, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4168
  if (!_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4169
    // make sure caller's args_size will be less than 0 even for non-static
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4170
    // method so it will be recomputed in compute_size_of_parameters().
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4171
    return -2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4172
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4173
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4174
  unsigned int args_size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4175
  char buf[fixed_buffer_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4176
  char* p = signature->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4177
  unsigned int length = signature->utf8_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4178
  char* nextp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4179
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4180
  // The first character must be a '('
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4181
  if ((length > 0) && (*p++ == JVM_SIGNATURE_FUNC)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4182
    length--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4183
    // Skip over legal field signatures
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4184
    nextp = skip_over_field_signature(p, false, length, CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4185
    while ((length > 0) && (nextp != NULL)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4186
      args_size++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4187
      if (p[0] == 'J' || p[0] == 'D') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4188
        args_size++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4189
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4190
      length -= nextp - p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4191
      p = nextp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4192
      nextp = skip_over_field_signature(p, false, length, CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4193
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4194
    // The first non-signature thing better be a ')'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4195
    if ((length > 0) && (*p++ == JVM_SIGNATURE_ENDFUNC)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4196
      length--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4197
      if (name->utf8_length() > 0 && name->byte_at(0) == '<') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4198
        // All internal methods must return void
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4199
        if ((length == 1) && (p[0] == JVM_SIGNATURE_VOID)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4200
          return args_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4201
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4202
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4203
        // Now we better just have a return value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4204
        nextp = skip_over_field_signature(p, true, length, CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4205
        if (nextp && ((int)length == (nextp - p))) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4206
          return args_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4207
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4208
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4209
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4210
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4211
  // Report error
5709
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 5426
diff changeset
  4212
  throwIllegalSignature("Method", name, signature, CHECK_0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4213
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4214
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4215
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4216
6978
fd89b5882576 6891959: HotSpot should not throw ClassFormatError if a class has a field with '>' and/or '<' in its name
kamg
parents: 6773
diff changeset
  4217
// Unqualified names may not contain the characters '.', ';', '[', or '/'.
fd89b5882576 6891959: HotSpot should not throw ClassFormatError if a class has a field with '>' and/or '<' in its name
kamg
parents: 6773
diff changeset
  4218
// Method names also may not contain the characters '<' or '>', unless <init>
fd89b5882576 6891959: HotSpot should not throw ClassFormatError if a class has a field with '>' and/or '<' in its name
kamg
parents: 6773
diff changeset
  4219
// or <clinit>.  Note that method names may not be <init> or <clinit> in this
fd89b5882576 6891959: HotSpot should not throw ClassFormatError if a class has a field with '>' and/or '<' in its name
kamg
parents: 6773
diff changeset
  4220
// method.  Because these names have been checked as special cases before
fd89b5882576 6891959: HotSpot should not throw ClassFormatError if a class has a field with '>' and/or '<' in its name
kamg
parents: 6773
diff changeset
  4221
// calling this method in verify_legal_method_name.
fd89b5882576 6891959: HotSpot should not throw ClassFormatError if a class has a field with '>' and/or '<' in its name
kamg
parents: 6773
diff changeset
  4222
bool ClassFileParser::verify_unqualified_name(
fd89b5882576 6891959: HotSpot should not throw ClassFormatError if a class has a field with '>' and/or '<' in its name
kamg
parents: 6773
diff changeset
  4223
    char* name, unsigned int length, int type) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4224
  jchar ch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4225
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4226
  for (char* p = name; p != name + length; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4227
    ch = *p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4228
    if (ch < 128) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4229
      p++;
6978
fd89b5882576 6891959: HotSpot should not throw ClassFormatError if a class has a field with '>' and/or '<' in its name
kamg
parents: 6773
diff changeset
  4230
      if (ch == '.' || ch == ';' || ch == '[' ) {
fd89b5882576 6891959: HotSpot should not throw ClassFormatError if a class has a field with '>' and/or '<' in its name
kamg
parents: 6773
diff changeset
  4231
        return false;   // do not permit '.', ';', or '['
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4232
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4233
      if (type != LegalClass && ch == '/') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4234
        return false;   // do not permit '/' unless it's class name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4235
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4236
      if (type == LegalMethod && (ch == '<' || ch == '>')) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4237
        return false;   // do not permit '<' or '>' in method names
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4238
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4239
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4240
      char* tmp_p = UTF8::next(p, &ch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4241
      p = tmp_p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4242
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4243
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4244
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4245
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4246
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4247
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4248
// Take pointer to a string. Skip over the longest part of the string that could
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4249
// be taken as a fieldname. Allow '/' if slash_ok is true.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4250
// Return a pointer to just past the fieldname.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4251
// Return NULL if no fieldname at all was found, or in the case of slash_ok
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4252
// being true, we saw consecutive slashes (meaning we were looking for a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4253
// qualified path but found something that was badly-formed).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4254
char* ClassFileParser::skip_over_field_name(char* name, bool slash_ok, unsigned int length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4255
  char* p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4256
  jchar ch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4257
  jboolean last_is_slash = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4258
  jboolean not_first_ch = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4259
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4260
  for (p = name; p != name + length; not_first_ch = true) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4261
    char* old_p = p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4262
    ch = *p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4263
    if (ch < 128) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4264
      p++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4265
      // quick check for ascii
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4266
      if ((ch >= 'a' && ch <= 'z') ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4267
          (ch >= 'A' && ch <= 'Z') ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4268
          (ch == '_' || ch == '$') ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4269
          (not_first_ch && ch >= '0' && ch <= '9')) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4270
        last_is_slash = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4271
        continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4272
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4273
      if (slash_ok && ch == '/') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4274
        if (last_is_slash) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4275
          return NULL;  // Don't permit consecutive slashes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4276
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4277
        last_is_slash = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4278
        continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4279
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4280
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4281
      jint unicode_ch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4282
      char* tmp_p = UTF8::next_character(p, &unicode_ch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4283
      p = tmp_p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4284
      last_is_slash = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4285
      // Check if ch is Java identifier start or is Java identifier part
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4286
      // 4672820: call java.lang.Character methods directly without generating separate tables.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4287
      EXCEPTION_MARK;
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
  4288
      instanceKlassHandle klass (THREAD, SystemDictionary::Character_klass());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4289
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4290
      // return value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4291
      JavaValue result(T_BOOLEAN);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4292
      // Set up the arguments to isJavaIdentifierStart and isJavaIdentifierPart
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4293
      JavaCallArguments args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4294
      args.push_int(unicode_ch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4295
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4296
      // public static boolean isJavaIdentifierStart(char ch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4297
      JavaCalls::call_static(&result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4298
                             klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  4299
                             vmSymbols::isJavaIdentifierStart_name(),
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  4300
                             vmSymbols::int_bool_signature(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4301
                             &args,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4302
                             THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4303
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4304
      if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4305
        CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4306
        return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4307
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4308
      if (result.get_jboolean()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4309
        continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4310
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4311
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4312
      if (not_first_ch) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4313
        // public static boolean isJavaIdentifierPart(char ch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4314
        JavaCalls::call_static(&result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4315
                               klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  4316
                               vmSymbols::isJavaIdentifierPart_name(),
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7709
diff changeset
  4317
                               vmSymbols::int_bool_signature(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4318
                               &args,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4319
                               THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4320
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4321
        if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4322
          CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4323
          return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4324
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4325
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4326
        if (result.get_jboolean()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4327
          continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4328
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4329
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4330
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4331
    return (not_first_ch) ? old_p : NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4332
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4333
  return (not_first_ch) ? p : NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4334
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4335
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4336
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4337
// Take pointer to a string. Skip over the longest part of the string that could
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4338
// be taken as a field signature. Allow "void" if void_ok.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4339
// Return a pointer to just past the signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4340
// Return NULL if no legal signature is found.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4341
char* ClassFileParser::skip_over_field_signature(char* signature,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4342
                                                 bool void_ok,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4343
                                                 unsigned int length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4344
                                                 TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4345
  unsigned int array_dim = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4346
  while (length > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4347
    switch (signature[0]) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4348
      case JVM_SIGNATURE_VOID: if (!void_ok) { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4349
      case JVM_SIGNATURE_BOOLEAN:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4350
      case JVM_SIGNATURE_BYTE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4351
      case JVM_SIGNATURE_CHAR:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4352
      case JVM_SIGNATURE_SHORT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4353
      case JVM_SIGNATURE_INT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4354
      case JVM_SIGNATURE_FLOAT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4355
      case JVM_SIGNATURE_LONG:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4356
      case JVM_SIGNATURE_DOUBLE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4357
        return signature + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4358
      case JVM_SIGNATURE_CLASS: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4359
        if (_major_version < JAVA_1_5_VERSION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4360
          // Skip over the class name if one is there
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4361
          char* p = skip_over_field_name(signature + 1, true, --length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4362
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4363
          // The next character better be a semicolon
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4364
          if (p && (p - signature) > 1 && p[0] == ';') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4365
            return p + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4366
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4367
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4368
          // 4900761: For class version > 48, any unicode is allowed in class name.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4369
          length--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4370
          signature++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4371
          while (length > 0 && signature[0] != ';') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4372
            if (signature[0] == '.') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4373
              classfile_parse_error("Class name contains illegal character '.' in descriptor in class file %s", CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4374
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4375
            length--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4376
            signature++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4377
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4378
          if (signature[0] == ';') { return signature + 1; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4379
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4380
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4381
        return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4382
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4383
      case JVM_SIGNATURE_ARRAY:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4384
        array_dim++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4385
        if (array_dim > 255) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4386
          // 4277370: array descriptor is valid only if it represents 255 or fewer dimensions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4387
          classfile_parse_error("Array type descriptor has more than 255 dimensions in class file %s", CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4388
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4389
        // The rest of what's there better be a legal signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4390
        signature++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4391
        length--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4392
        void_ok = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4393
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4394
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4395
      default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4396
        return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4397
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4398
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4399
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4400
}