1 /*
   2  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_OOPS_CONSTMETHODOOP_HPP
  26 #define SHARE_VM_OOPS_CONSTMETHODOOP_HPP
  27 
  28 #include "oops/oop.hpp"
  29 #include "oops/typeArrayOop.hpp"
  30 
  31 // An constMethodOop represents portions of a Java method which
  32 // do not vary.
  33 //
  34 // Memory layout (each line represents a word). Note that most
  35 // applications load thousands of methods, so keeping the size of this
  36 // structure small has a big impact on footprint.
  37 //
  38 // |------------------------------------------------------|
  39 // | header                                               |
  40 // | klass                                                |
  41 // |------------------------------------------------------|
  42 // | fingerprint 1                                        |
  43 // | fingerprint 2                                        |
  44 // | method                         (oop)                 |
  45 // | stackmap_data                  (oop)                 |
  46 // | exception_table                (oop)                 |
  47 // | constMethod_size                                     |
  48 // | interp_kind  | flags    | code_size                  |
  49 // | name index              | signature index            |
  50 // | method_idnum            | generic_signature_index    |
  51 // |------------------------------------------------------|
  52 // |                                                      |
  53 // | byte codes                                           |
  54 // |                                                      |
  55 // |------------------------------------------------------|
  56 // | compressed linenumber table                          |
  57 // |  (see class CompressedLineNumberReadStream)          |
  58 // |  (note that length is unknown until decompressed)    |
  59 // |  (access flags bit tells whether table is present)   |
  60 // |  (indexed from start of constMethodOop)              |
  61 // |  (elements not necessarily sorted!)                  |
  62 // |------------------------------------------------------|
  63 // | localvariable table elements + length (length last)  |
  64 // |  (length is u2, elements are 6-tuples of u2)         |
  65 // |  (see class LocalVariableTableElement)               |
  66 // |  (access flags bit tells whether table is present)   |
  67 // |  (indexed from end of contMethodOop)                 |
  68 // |------------------------------------------------------|
  69 // | checked exceptions elements + length (length last)   |
  70 // |  (length is u2, elements are u2)                     |
  71 // |  (see class CheckedExceptionElement)                 |
  72 // |  (access flags bit tells whether table is present)   |
  73 // |  (indexed from end of constMethodOop)                |
  74 // |------------------------------------------------------|
  75 
  76 
  77 // Utitily class decribing elements in checked exceptions table inlined in methodOop.
  78 class CheckedExceptionElement VALUE_OBJ_CLASS_SPEC {
  79  public:
  80   u2 class_cp_index;
  81 };
  82 
  83 
  84 // Utitily class decribing elements in local variable table inlined in methodOop.
  85 class LocalVariableTableElement VALUE_OBJ_CLASS_SPEC {
  86  public:
  87   u2 start_bci;
  88   u2 length;
  89   u2 name_cp_index;
  90   u2 descriptor_cp_index;
  91   u2 signature_cp_index;
  92   u2 slot;
  93 };
  94 
  95 
  96 class constMethodOopDesc : public oopDesc {
  97   friend class constMethodKlass;
  98   friend class VMStructs;
  99 private:
 100   enum {
 101     _has_linenumber_table = 1,
 102     _has_checked_exceptions = 2,
 103     _has_localvariable_table = 4
 104   };
 105 
 106   // Bit vector of signature
 107   // Callers interpret 0=not initialized yet and
 108   // -1=too many args to fix, must parse the slow way.
 109   // The real initial value is special to account for nonatomicity of 64 bit
 110   // loads and stores.  This value may updated and read without a lock by
 111   // multiple threads, so is volatile.
 112   volatile uint64_t _fingerprint;
 113   volatile bool     _is_conc_safe; // if true, safe for concurrent GC processing
 114 
 115 public:
 116   oop* oop_block_beg() const { return adr_method(); }
 117   oop* oop_block_end() const { return adr_exception_table() + 1; }
 118 
 119 private:
 120   //
 121   // The oop block.  See comment in klass.hpp before making changes.
 122   //
 123 
 124   // Backpointer to non-const methodOop (needed for some JVMTI operations)
 125   methodOop         _method;
 126 
 127   // Raw stackmap data for the method
 128   typeArrayOop      _stackmap_data;
 129 
 130   // The exception handler table. 4-tuples of ints [start_pc, end_pc,
 131   // handler_pc, catch_type index] For methods with no exceptions the
 132   // table is pointing to Universe::the_empty_int_array
 133   typeArrayOop      _exception_table;
 134 
 135   //
 136   // End of the oop block.
 137   //
 138 
 139   int               _constMethod_size;
 140   jbyte             _interpreter_kind;
 141   jbyte             _flags;
 142 
 143   // Size of Java bytecodes allocated immediately after methodOop.
 144   u2                _code_size;
 145   u2                _name_index;                 // Method name (index in constant pool)
 146   u2                _signature_index;            // Method signature (index in constant pool)
 147   u2                _method_idnum;               // unique identification number for the method within the class
 148                                                  // initially corresponds to the index into the methods array.
 149                                                  // but this may change with redefinition
 150   u2                _generic_signature_index;    // Generic signature (index in constant pool, 0 if absent)
 151 
 152 public:
 153   // Inlined tables
 154   void set_inlined_tables_length(int checked_exceptions_len,
 155                                  int compressed_line_number_size,
 156                                  int localvariable_table_len);
 157 
 158   bool has_linenumber_table() const
 159     { return (_flags & _has_linenumber_table) != 0; }
 160 
 161   bool has_checked_exceptions() const
 162     { return (_flags & _has_checked_exceptions) != 0; }
 163 
 164   bool has_localvariable_table() const
 165     { return (_flags & _has_localvariable_table) != 0; }
 166 
 167   void set_interpreter_kind(int kind)      { _interpreter_kind = kind; }
 168   int  interpreter_kind(void) const        { return _interpreter_kind; }
 169 
 170   // backpointer to non-const methodOop
 171   methodOop method() const                 { return _method; }
 172   void set_method(methodOop m)             { oop_store_without_check((oop*)&_method, (oop) m); }
 173 
 174 
 175   // stackmap table data
 176   typeArrayOop stackmap_data() const { return _stackmap_data; }
 177   void set_stackmap_data(typeArrayOop sd) {
 178     oop_store_without_check((oop*)&_stackmap_data, (oop)sd);
 179   }
 180   bool has_stackmap_table() const { return _stackmap_data != NULL; }
 181 
 182   // exception handler table
 183   typeArrayOop exception_table() const           { return _exception_table; }
 184   void set_exception_table(typeArrayOop e)       { oop_store_without_check((oop*) &_exception_table, (oop) e); }
 185   bool has_exception_handler() const             { return exception_table() != NULL && exception_table()->length() > 0; }
 186 
 187   void init_fingerprint() {
 188     const uint64_t initval = CONST64(0x8000000000000000);
 189     _fingerprint = initval;
 190   }
 191 
 192   uint64_t fingerprint() const                   {
 193     // Since reads aren't atomic for 64 bits, if any of the high or low order
 194     // word is the initial value, return 0.  See init_fingerprint for initval.
 195     uint high_fp = (uint)(_fingerprint >> 32);
 196     if ((int) _fingerprint == 0 || high_fp == 0x80000000) {
 197       return 0L;
 198     } else {
 199       return _fingerprint;
 200     }
 201   }
 202 
 203   uint64_t set_fingerprint(uint64_t new_fingerprint) {
 204 #ifdef ASSERT
 205     // Assert only valid if complete/valid 64 bit _fingerprint value is read.
 206     uint64_t oldfp = fingerprint();
 207 #endif // ASSERT
 208     _fingerprint = new_fingerprint;
 209     assert(oldfp == 0L || new_fingerprint == oldfp,
 210            "fingerprint cannot change");
 211     assert(((new_fingerprint >> 32) != 0x80000000) && (int)new_fingerprint !=0,
 212            "fingerprint should call init to set initial value");
 213     return new_fingerprint;
 214   }
 215 
 216   // name
 217   int name_index() const                         { return _name_index; }
 218   void set_name_index(int index)                 { _name_index = index; }
 219 
 220   // signature
 221   int signature_index() const                    { return _signature_index; }
 222   void set_signature_index(int index)            { _signature_index = index; }
 223 
 224   // generics support
 225   int generic_signature_index() const            { return _generic_signature_index; }
 226   void set_generic_signature_index(int index)    { _generic_signature_index = index; }
 227 
 228   // Sizing
 229   static int header_size() {
 230     return sizeof(constMethodOopDesc)/HeapWordSize;
 231   }
 232 
 233   // Object size needed
 234   static int object_size(int code_size, int compressed_line_number_size,
 235                          int local_variable_table_length,
 236                          int checked_exceptions_length);
 237 
 238   int object_size() const                 { return _constMethod_size; }
 239   void set_constMethod_size(int size)     { _constMethod_size = size; }
 240   // Is object parsable by gc
 241   bool object_is_parsable()               { return object_size() > 0; }
 242 
 243   // code size
 244   int code_size() const                          { return _code_size; }
 245   void set_code_size(int size) {
 246     assert(max_method_code_size < (1 << 16),
 247            "u2 is too small to hold method code size in general");
 248     assert(0 <= size && size <= max_method_code_size, "invalid code size");
 249     _code_size = size;
 250   }
 251 
 252   // linenumber table - note that length is unknown until decompression,
 253   // see class CompressedLineNumberReadStream.
 254   u_char* compressed_linenumber_table() const;         // not preserved by gc
 255   u2* checked_exceptions_length_addr() const;
 256   u2* localvariable_table_length_addr() const;
 257 
 258   // checked exceptions
 259   int checked_exceptions_length() const;
 260   CheckedExceptionElement* checked_exceptions_start() const;
 261 
 262   // localvariable table
 263   int localvariable_table_length() const;
 264   LocalVariableTableElement* localvariable_table_start() const;
 265 
 266   // byte codes
 267   void    set_code(address code) {
 268     if (code_size() > 0) {
 269       memcpy(code_base(), code, code_size());
 270     }
 271   }
 272   address code_base() const            { return (address) (this+1); }
 273   address code_end() const             { return code_base() + code_size(); }
 274   bool    contains(address bcp) const  { return code_base() <= bcp
 275                                                      && bcp < code_end(); }
 276   // Offset to bytecodes
 277   static ByteSize codes_offset()
 278                             { return in_ByteSize(sizeof(constMethodOopDesc)); }
 279 
 280   // interpreter support
 281   static ByteSize exception_table_offset()
 282                { return byte_offset_of(constMethodOopDesc, _exception_table); }
 283 
 284   // Garbage collection support
 285   oop*  adr_method() const             { return (oop*)&_method;          }
 286   oop*  adr_stackmap_data() const      { return (oop*)&_stackmap_data;   }
 287   oop*  adr_exception_table() const    { return (oop*)&_exception_table; }
 288   bool is_conc_safe() { return _is_conc_safe; }
 289   void set_is_conc_safe(bool v) { _is_conc_safe = v; }
 290 
 291   // Unique id for the method
 292   static const u2 MAX_IDNUM;
 293   static const u2 UNSET_IDNUM;
 294   u2 method_idnum() const                        { return _method_idnum; }
 295   void set_method_idnum(u2 idnum)                { _method_idnum = idnum; }
 296 
 297 private:
 298   // Since the size of the compressed line number table is unknown, the
 299   // offsets of the other variable sized sections are computed backwards
 300   // from the end of the constMethodOop.
 301 
 302   // First byte after constMethodOop
 303   address constMethod_end() const
 304                           { return (address)((oop*)this + _constMethod_size); }
 305 
 306   // Last short in constMethodOop
 307   u2* last_u2_element() const
 308                                          { return (u2*)constMethod_end() - 1; }
 309 };
 310 
 311 #endif // SHARE_VM_OOPS_CONSTMETHODOOP_HPP