constMethod.hpp revision 3602:da91efe96a93 
137463Sbde/*
232213Swosch * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
319477Sjoerg * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
43077Sache *
53077Sache * This code is free software; you can redistribute it and/or modify it
632213Swosch * under the terms of the GNU General Public License version 2 only, as
73081Sache * published by the Free Software Foundation.
83077Sache *
93077Sache * This code is distributed in the hope that it will be useful, but WITHOUT
103077Sache * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
113077Sache * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
123077Sache * version 2 for more details (a copy is included in the LICENSE file that
1337463Sbde * accompanied this code).
1437463Sbde *
153077Sache * You should have received a copy of the GNU General Public License version
1632213Swosch * 2 along with this work; if not, write to the Free Software Foundation,
1732213Swosch * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
183077Sache *
193077Sache * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
203077Sache * or visit www.oracle.com if you need additional information or have any
213077Sache * questions.
223077Sache *
233077Sache */
243077Sache
2537463Sbde#ifndef SHARE_VM_OOPS_CONSTMETHODOOP_HPP
2637463Sbde#define SHARE_VM_OOPS_CONSTMETHODOOP_HPP
273077Sache
283077Sache#include "oops/oop.hpp"
29
30// An ConstMethod* represents portions of a Java method which
31// do not vary.
32//
33// Memory layout (each line represents a word). Note that most
34// applications load thousands of methods, so keeping the size of this
35// structure small has a big impact on footprint.
36//
37// |------------------------------------------------------|
38// | header                                               |
39// | klass                                                |
40// |------------------------------------------------------|
41// | fingerprint 1                                        |
42// | fingerprint 2                                        |
43// | constants                      (oop)                 |
44// | stackmap_data                  (oop)                 |
45// | constMethod_size                                     |
46// | interp_kind  | flags    | code_size                  |
47// | name index              | signature index            |
48// | method_idnum            | generic_signature_index    |
49// |------------------------------------------------------|
50// |                                                      |
51// | byte codes                                           |
52// |                                                      |
53// |------------------------------------------------------|
54// | compressed linenumber table                          |
55// |  (see class CompressedLineNumberReadStream)          |
56// |  (note that length is unknown until decompressed)    |
57// |  (access flags bit tells whether table is present)   |
58// |  (indexed from start of ConstMethod*)              |
59// |  (elements not necessarily sorted!)                  |
60// |------------------------------------------------------|
61// | localvariable table elements + length (length last)  |
62// |  (length is u2, elements are 6-tuples of u2)         |
63// |  (see class LocalVariableTableElement)               |
64// |  (access flags bit tells whether table is present)   |
65// |  (indexed from end of ConstMethod*)                |
66// |------------------------------------------------------|
67// | exception table + length (length last)               |
68// |  (length is u2, elements are 4-tuples of u2)         |
69// |  (see class ExceptionTableElement)                   |
70// |  (access flags bit tells whether table is present)   |
71// |  (indexed from end of ConstMethod*)                |
72// |------------------------------------------------------|
73// | checked exceptions elements + length (length last)   |
74// |  (length is u2, elements are u2)                     |
75// |  (see class CheckedExceptionElement)                 |
76// |  (access flags bit tells whether table is present)   |
77// |  (indexed from end of ConstMethod*)                |
78// |------------------------------------------------------|
79
80
81// Utitily class decribing elements in checked exceptions table inlined in Method*.
82class CheckedExceptionElement VALUE_OBJ_CLASS_SPEC {
83 public:
84  u2 class_cp_index;
85};
86
87
88// Utitily class decribing elements in local variable table inlined in Method*.
89class LocalVariableTableElement VALUE_OBJ_CLASS_SPEC {
90 public:
91  u2 start_bci;
92  u2 length;
93  u2 name_cp_index;
94  u2 descriptor_cp_index;
95  u2 signature_cp_index;
96  u2 slot;
97};
98
99// Utitily class describing elements in exception table
100class ExceptionTableElement VALUE_OBJ_CLASS_SPEC {
101 public:
102  u2 start_pc;
103  u2 end_pc;
104  u2 handler_pc;
105  u2 catch_type_index;
106};
107
108
109class ConstMethod : public MetaspaceObj {
110  friend class VMStructs;
111private:
112  enum {
113    _has_linenumber_table = 1,
114    _has_checked_exceptions = 2,
115    _has_localvariable_table = 4,
116    _has_exception_table = 8
117  };
118
119  // Bit vector of signature
120  // Callers interpret 0=not initialized yet and
121  // -1=too many args to fix, must parse the slow way.
122  // The real initial value is special to account for nonatomicity of 64 bit
123  // loads and stores.  This value may updated and read without a lock by
124  // multiple threads, so is volatile.
125  volatile uint64_t _fingerprint;
126
127  ConstantPool*     _constants;                  // Constant pool
128
129  // Raw stackmap data for the method
130  Array<u1>*        _stackmap_data;
131
132  int               _constMethod_size;
133  jbyte             _interpreter_kind;
134  jbyte             _flags;
135
136  // Size of Java bytecodes allocated immediately after Method*.
137  u2                _code_size;
138  u2                _name_index;                 // Method name (index in constant pool)
139  u2                _signature_index;            // Method signature (index in constant pool)
140  u2                _method_idnum;               // unique identification number for the method within the class
141                                                 // initially corresponds to the index into the methods array.
142                                                 // but this may change with redefinition
143  u2                _generic_signature_index;    // Generic signature (index in constant pool, 0 if absent)
144
145
146  // Constructor
147  ConstMethod(int byte_code_size,
148                     int compressed_line_number_size,
149                     int localvariable_table_length,
150                     int exception_table_length,
151                     int checked_exceptions_length,
152                     int size);
153public:
154  static ConstMethod* allocate(ClassLoaderData* loader_data,
155                                 int byte_code_size,
156                                 int compressed_line_number_size,
157                                 int localvariable_table_length,
158                                 int exception_table_length,
159                                 int checked_exceptions_length,
160                                 TRAPS);
161
162  bool is_constMethod() const { return true; }
163
164  // Inlined tables
165  void set_inlined_tables_length(int checked_exceptions_len,
166                                 int compressed_line_number_size,
167                                 int localvariable_table_len,
168                                 int exception_table_len);
169
170  bool has_linenumber_table() const
171    { return (_flags & _has_linenumber_table) != 0; }
172
173  bool has_checked_exceptions() const
174    { return (_flags & _has_checked_exceptions) != 0; }
175
176  bool has_localvariable_table() const
177    { return (_flags & _has_localvariable_table) != 0; }
178
179  bool has_exception_handler() const
180    { return (_flags & _has_exception_table) != 0; }
181
182  void set_interpreter_kind(int kind)      { _interpreter_kind = kind; }
183  int  interpreter_kind(void) const        { return _interpreter_kind; }
184
185  // constant pool
186  ConstantPool* constants() const        { return _constants; }
187  void set_constants(ConstantPool* c)    { _constants = c; }
188
189  Method* method() const;
190
191  // stackmap table data
192  Array<u1>* stackmap_data() const { return _stackmap_data; }
193  void set_stackmap_data(Array<u1>* sd) { _stackmap_data = sd; }
194  bool has_stackmap_table() const { return _stackmap_data != NULL; }
195
196  void init_fingerprint() {
197    const uint64_t initval = CONST64(0x8000000000000000);
198    _fingerprint = initval;
199  }
200
201  uint64_t fingerprint() const                   {
202    // Since reads aren't atomic for 64 bits, if any of the high or low order
203    // word is the initial value, return 0.  See init_fingerprint for initval.
204    uint high_fp = (uint)(_fingerprint >> 32);
205    if ((int) _fingerprint == 0 || high_fp == 0x80000000) {
206      return 0L;
207    } else {
208      return _fingerprint;
209    }
210  }
211
212  uint64_t set_fingerprint(uint64_t new_fingerprint) {
213#ifdef ASSERT
214    // Assert only valid if complete/valid 64 bit _fingerprint value is read.
215    uint64_t oldfp = fingerprint();
216#endif // ASSERT
217    _fingerprint = new_fingerprint;
218    assert(oldfp == 0L || new_fingerprint == oldfp,
219           "fingerprint cannot change");
220    assert(((new_fingerprint >> 32) != 0x80000000) && (int)new_fingerprint !=0,
221           "fingerprint should call init to set initial value");
222    return new_fingerprint;
223  }
224
225  // name
226  int name_index() const                         { return _name_index; }
227  void set_name_index(int index)                 { _name_index = index; }
228
229  // signature
230  int signature_index() const                    { return _signature_index; }
231  void set_signature_index(int index)            { _signature_index = index; }
232
233  // generics support
234  int generic_signature_index() const            { return _generic_signature_index; }
235  void set_generic_signature_index(int index)    { _generic_signature_index = index; }
236
237  // Sizing
238  static int header_size() {
239    return sizeof(ConstMethod)/HeapWordSize;
240  }
241
242  // Size needed
243  static int size(int code_size, int compressed_line_number_size,
244                         int local_variable_table_length,
245                         int exception_table_length,
246                         int checked_exceptions_length);
247
248  int size() const                    { return _constMethod_size;}
249  void set_constMethod_size(int size)     { _constMethod_size = size; }
250
251  // code size
252  int code_size() const                          { return _code_size; }
253  void set_code_size(int size) {
254    assert(max_method_code_size < (1 << 16),
255           "u2 is too small to hold method code size in general");
256    assert(0 <= size && size <= max_method_code_size, "invalid code size");
257    _code_size = size;
258  }
259
260  // linenumber table - note that length is unknown until decompression,
261  // see class CompressedLineNumberReadStream.
262  u_char* compressed_linenumber_table() const;         // not preserved by gc
263  u2* checked_exceptions_length_addr() const;
264  u2* localvariable_table_length_addr() const;
265  u2* exception_table_length_addr() const;
266
267  // checked exceptions
268  int checked_exceptions_length() const;
269  CheckedExceptionElement* checked_exceptions_start() const;
270
271  // localvariable table
272  int localvariable_table_length() const;
273  LocalVariableTableElement* localvariable_table_start() const;
274
275  // exception table
276  int exception_table_length() const;
277  ExceptionTableElement* exception_table_start() const;
278
279  // byte codes
280  void    set_code(address code) {
281    if (code_size() > 0) {
282      memcpy(code_base(), code, code_size());
283    }
284  }
285  address code_base() const            { return (address) (this+1); }
286  address code_end() const             { return code_base() + code_size(); }
287  bool    contains(address bcp) const  { return code_base() <= bcp
288                                                     && bcp < code_end(); }
289  // Offset to bytecodes
290  static ByteSize codes_offset()
291                            { return in_ByteSize(sizeof(ConstMethod)); }
292
293  static ByteSize constants_offset()
294                            { return byte_offset_of(ConstMethod, _constants); }
295
296  // Unique id for the method
297  static const u2 MAX_IDNUM;
298  static const u2 UNSET_IDNUM;
299  u2 method_idnum() const                        { return _method_idnum; }
300  void set_method_idnum(u2 idnum)                { _method_idnum = idnum; }
301
302  // Deallocation for RedefineClasses
303  void deallocate_contents(ClassLoaderData* loader_data);
304  bool is_klass() const { return false; }
305  DEBUG_ONLY(bool on_stack() { return false; })
306
307private:
308  // Since the size of the compressed line number table is unknown, the
309  // offsets of the other variable sized sections are computed backwards
310  // from the end of the ConstMethod*.
311
312  // First byte after ConstMethod*
313  address constMethod_end() const
314                          { return (address)((oop*)this + _constMethod_size); }
315
316  // Last short in ConstMethod*
317  u2* last_u2_element() const
318                                         { return (u2*)constMethod_end() - 1; }
319
320 public:
321  // Printing
322  void print_on      (outputStream* st) const;
323  void print_value_on(outputStream* st) const;
324
325  const char* internal_name() const { return "{constMethod}"; }
326
327  // Verify
328  void verify_on(outputStream* st);
329};
330
331#endif // SHARE_VM_OOPS_CONSTMETHODOOP_HPP
332