1 /*
   2  * Copyright (c) 2003, 2012, 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 
  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            | max_stack                  |
  49 // | max_locals              | size_of_parameters         |
  50 // |------------------------------------------------------|
  51 // |                                                      |
  52 // | byte codes                                           |
  53 // |                                                      |
  54 // |------------------------------------------------------|
  55 // | compressed linenumber table                          |
  56 // |  (see class CompressedLineNumberReadStream)          |
  57 // |  (note that length is unknown until decompressed)    |
  58 // |  (access flags bit tells whether table is present)   |
  59 // |  (indexed from start of ConstMethod*)                |
  60 // |  (elements not necessarily sorted!)                  |
  61 // |------------------------------------------------------|
  62 // | localvariable table elements + length (length last)  |
  63 // |  (length is u2, elements are 6-tuples of u2)         |
  64 // |  (see class LocalVariableTableElement)               |
  65 // |  (access flags bit tells whether table is present)   |
  66 // |  (indexed from end of ConstMethod*)                  |
  67 // |------------------------------------------------------|
  68 // | exception table + length (length last)               |
  69 // |  (length is u2, elements are 4-tuples of u2)         |
  70 // |  (see class ExceptionTableElement)                   |
  71 // |  (access flags bit tells whether table is present)   |
  72 // |  (indexed from end of ConstMethod*)                  |
  73 // |------------------------------------------------------|
  74 // | checked exceptions elements + length (length last)   |
  75 // |  (length is u2, elements are u2)                     |
  76 // |  (see class CheckedExceptionElement)                 |
  77 // |  (access flags bit tells whether table is present)   |
  78 // |  (indexed from end of ConstMethod*)                  |
  79 // |------------------------------------------------------|
  80 // | generic signature index (u2)                         |
  81 // |  (indexed from start of constMethodOop)              |
  82 // |------------------------------------------------------|
  83 
  84 
  85 // Utitily class decribing elements in checked exceptions table inlined in Method*.
  86 class CheckedExceptionElement VALUE_OBJ_CLASS_SPEC {
  87  public:
  88   u2 class_cp_index;
  89 };
  90 
  91 
  92 // Utitily class decribing elements in local variable table inlined in Method*.
  93 class LocalVariableTableElement VALUE_OBJ_CLASS_SPEC {
  94  public:
  95   u2 start_bci;
  96   u2 length;
  97   u2 name_cp_index;
  98   u2 descriptor_cp_index;
  99   u2 signature_cp_index;
 100   u2 slot;
 101 };
 102 
 103 // Utitily class describing elements in exception table
 104 class ExceptionTableElement VALUE_OBJ_CLASS_SPEC {
 105  public:
 106   u2 start_pc;
 107   u2 end_pc;
 108   u2 handler_pc;
 109   u2 catch_type_index;
 110 };
 111 
 112 
 113 class ConstMethod : public MetaspaceObj {
 114   friend class VMStructs;
 115 
 116 public:
 117   typedef enum { NORMAL, OVERPASS } MethodType;
 118 
 119 private:
 120   enum {
 121     _has_linenumber_table = 1,
 122     _has_checked_exceptions = 2,
 123     _has_localvariable_table = 4,
 124     _has_exception_table = 8,
 125     _has_generic_signature = 16,
 126     _is_overpass = 32
 127   };
 128 
 129   // Bit vector of signature
 130   // Callers interpret 0=not initialized yet and
 131   // -1=too many args to fix, must parse the slow way.
 132   // The real initial value is special to account for nonatomicity of 64 bit
 133   // loads and stores.  This value may updated and read without a lock by
 134   // multiple threads, so is volatile.
 135   volatile uint64_t _fingerprint;
 136 
 137   ConstantPool*     _constants;                  // Constant pool
 138 
 139   // Raw stackmap data for the method
 140   Array<u1>*        _stackmap_data;
 141 
 142   int               _constMethod_size;
 143   jbyte             _interpreter_kind;
 144   jbyte             _flags;
 145 
 146   // Size of Java bytecodes allocated immediately after Method*.
 147   u2                _code_size;
 148   u2                _name_index;                 // Method name (index in constant pool)
 149   u2                _signature_index;            // Method signature (index in constant pool)
 150   u2                _method_idnum;               // unique identification number for the method within the class
 151                                                  // initially corresponds to the index into the methods array.
 152                                                  // but this may change with redefinition
 153   u2                _max_stack;                  // Maximum number of entries on the expression stack
 154   u2                _max_locals;                 // Number of local variables used by this method
 155   u2                _size_of_parameters;         // size of the parameter block (receiver + arguments) in words
 156 
 157   // Constructor
 158   ConstMethod(int byte_code_size,
 159               int compressed_line_number_size,
 160               int localvariable_table_length,
 161               int exception_table_length,
 162               int checked_exceptions_length,
 163               u2  generic_signature_index,
 164               MethodType is_overpass,
 165               int size);
 166 public:
 167 
 168   static ConstMethod* allocate(ClassLoaderData* loader_data,
 169                                int byte_code_size,
 170                                int compressed_line_number_size,
 171                                int localvariable_table_length,
 172                                int exception_table_length,
 173                                int checked_exceptions_length,
 174                                u2  generic_signature_index,
 175                                MethodType mt,
 176                                TRAPS);
 177 
 178   bool is_constMethod() const { return true; }
 179 
 180   // Inlined tables
 181   void set_inlined_tables_length(u2  generic_signature_index,
 182                                  int checked_exceptions_len,
 183                                  int compressed_line_number_size,
 184                                  int localvariable_table_len,
 185                                  int exception_table_len);
 186 
 187   bool has_generic_signature() const
 188     { return (_flags & _has_generic_signature) != 0; }
 189 
 190   bool has_linenumber_table() const
 191     { return (_flags & _has_linenumber_table) != 0; }
 192 
 193   bool has_checked_exceptions() const
 194     { return (_flags & _has_checked_exceptions) != 0; }
 195 
 196   bool has_localvariable_table() const
 197     { return (_flags & _has_localvariable_table) != 0; }
 198 
 199   bool has_exception_handler() const
 200     { return (_flags & _has_exception_table) != 0; }
 201 
 202   MethodType method_type() const {
 203     return ((_flags & _is_overpass) == 0) ? NORMAL : OVERPASS;
 204   }
 205 
 206   void set_method_type(MethodType mt) {
 207     if (mt == NORMAL) {
 208       _flags &= ~(_is_overpass);
 209     } else {
 210       _flags |= _is_overpass;
 211     }
 212   }
 213 
 214 
 215   void set_interpreter_kind(int kind)      { _interpreter_kind = kind; }
 216   int  interpreter_kind(void) const        { return _interpreter_kind; }
 217 
 218   // constant pool
 219   ConstantPool* constants() const        { return _constants; }
 220   void set_constants(ConstantPool* c)    { _constants = c; }
 221 
 222   Method* method() const;
 223 
 224   // stackmap table data
 225   Array<u1>* stackmap_data() const { return _stackmap_data; }
 226   void set_stackmap_data(Array<u1>* sd) { _stackmap_data = sd; }
 227   bool has_stackmap_table() const { return _stackmap_data != NULL; }
 228 
 229   void init_fingerprint() {
 230     const uint64_t initval = CONST64(0x8000000000000000);
 231     _fingerprint = initval;
 232   }
 233 
 234   uint64_t fingerprint() const                   {
 235     // Since reads aren't atomic for 64 bits, if any of the high or low order
 236     // word is the initial value, return 0.  See init_fingerprint for initval.
 237     uint high_fp = (uint)(_fingerprint >> 32);
 238     if ((int) _fingerprint == 0 || high_fp == 0x80000000) {
 239       return 0L;
 240     } else {
 241       return _fingerprint;
 242     }
 243   }
 244 
 245   uint64_t set_fingerprint(uint64_t new_fingerprint) {
 246 #ifdef ASSERT
 247     // Assert only valid if complete/valid 64 bit _fingerprint value is read.
 248     uint64_t oldfp = fingerprint();
 249 #endif // ASSERT
 250     _fingerprint = new_fingerprint;
 251     assert(oldfp == 0L || new_fingerprint == oldfp,
 252            "fingerprint cannot change");
 253     assert(((new_fingerprint >> 32) != 0x80000000) && (int)new_fingerprint !=0,
 254            "fingerprint should call init to set initial value");
 255     return new_fingerprint;
 256   }
 257 
 258   // name
 259   int name_index() const                         { return _name_index; }
 260   void set_name_index(int index)                 { _name_index = index; }
 261 
 262   // signature
 263   int signature_index() const                    { return _signature_index; }
 264   void set_signature_index(int index)            { _signature_index = index; }
 265 
 266   // generics support
 267   int generic_signature_index() const            {
 268     if (has_generic_signature()) {
 269       return *generic_signature_index_addr();
 270     } else {
 271       return 0;
 272     }
 273   }
 274   void set_generic_signature_index(u2 index)    {
 275     assert(has_generic_signature(), "");
 276     u2* addr = generic_signature_index_addr();
 277     *addr = index;
 278   }
 279 
 280   // Sizing
 281   static int header_size() {
 282     return sizeof(ConstMethod)/HeapWordSize;
 283   }
 284 
 285   // Size needed
 286   static int size(int code_size, int compressed_line_number_size,
 287                          int local_variable_table_length,
 288                          int exception_table_length,
 289                          int checked_exceptions_length,
 290                          u2  generic_signature_index);
 291 
 292   int size() const                    { return _constMethod_size;}
 293   void set_constMethod_size(int size)     { _constMethod_size = size; }
 294 
 295   // code size
 296   int code_size() const                          { return _code_size; }
 297   void set_code_size(int size) {
 298     assert(max_method_code_size < (1 << 16),
 299            "u2 is too small to hold method code size in general");
 300     assert(0 <= size && size <= max_method_code_size, "invalid code size");
 301     _code_size = size;
 302   }
 303 
 304   // linenumber table - note that length is unknown until decompression,
 305   // see class CompressedLineNumberReadStream.
 306   u_char* compressed_linenumber_table() const;         // not preserved by gc
 307   u2* generic_signature_index_addr() const;
 308   u2* checked_exceptions_length_addr() const;
 309   u2* localvariable_table_length_addr() const;
 310   u2* exception_table_length_addr() const;
 311 
 312   // checked exceptions
 313   int checked_exceptions_length() const;
 314   CheckedExceptionElement* checked_exceptions_start() const;
 315 
 316   // localvariable table
 317   int localvariable_table_length() const;
 318   LocalVariableTableElement* localvariable_table_start() const;
 319 
 320   // exception table
 321   int exception_table_length() const;
 322   ExceptionTableElement* exception_table_start() const;
 323 
 324   // byte codes
 325   void    set_code(address code) {
 326     if (code_size() > 0) {
 327       memcpy(code_base(), code, code_size());
 328     }
 329   }
 330   address code_base() const            { return (address) (this+1); }
 331   address code_end() const             { return code_base() + code_size(); }
 332   bool    contains(address bcp) const  { return code_base() <= bcp
 333                                                      && bcp < code_end(); }
 334   // Offset to bytecodes
 335   static ByteSize codes_offset()
 336                             { return in_ByteSize(sizeof(ConstMethod)); }
 337 
 338   static ByteSize constants_offset()
 339                             { return byte_offset_of(ConstMethod, _constants); }
 340 
 341   static ByteSize max_stack_offset()
 342                             { return byte_offset_of(ConstMethod, _max_stack); }
 343   static ByteSize size_of_locals_offset()
 344                             { return byte_offset_of(ConstMethod, _max_locals); }
 345   static ByteSize size_of_parameters_offset()
 346                             { return byte_offset_of(ConstMethod, _size_of_parameters); }
 347 
 348 
 349   // Unique id for the method
 350   static const u2 MAX_IDNUM;
 351   static const u2 UNSET_IDNUM;
 352   u2 method_idnum() const                        { return _method_idnum; }
 353   void set_method_idnum(u2 idnum)                { _method_idnum = idnum; }
 354 
 355   // max stack
 356   int  max_stack() const                         { return _max_stack; }
 357   void set_max_stack(int size)                   { _max_stack = size; }
 358 
 359   // max locals
 360   int  max_locals() const                        { return _max_locals; }
 361   void set_max_locals(int size)                  { _max_locals = size; }
 362 
 363   // size of parameters
 364   int  size_of_parameters() const                { return _size_of_parameters; }
 365   void set_size_of_parameters(int size)          { _size_of_parameters = size; }
 366 
 367   // Deallocation for RedefineClasses
 368   void deallocate_contents(ClassLoaderData* loader_data);
 369   bool is_klass() const { return false; }
 370   DEBUG_ONLY(bool on_stack() { return false; })
 371 
 372 private:
 373   // Since the size of the compressed line number table is unknown, the
 374   // offsets of the other variable sized sections are computed backwards
 375   // from the end of the ConstMethod*.
 376 
 377   // First byte after ConstMethod*
 378   address constMethod_end() const
 379                           { return (address)((oop*)this + _constMethod_size); }
 380 
 381   // Last short in ConstMethod*
 382   u2* last_u2_element() const
 383                                          { return (u2*)constMethod_end() - 1; }
 384 
 385  public:
 386   // Printing
 387   void print_on      (outputStream* st) const;
 388   void print_value_on(outputStream* st) const;
 389 
 390   const char* internal_name() const { return "{constMethod}"; }
 391 
 392   // Verify
 393   void verify_on(outputStream* st);
 394 };
 395 
 396 #endif // SHARE_VM_OOPS_CONSTMETHODOOP_HPP