1 /*
   2  * Copyright (c) 2003, 2016, 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 are not written to after
  31 // the classfile is parsed(*see below).  This part of the method can be shared across
  32 // processes in a read-only section with Class Data Sharing (CDS).  It's important
  33 // that this class doesn't have virtual functions because the vptr cannot be shared
  34 // with CDS.
  35 //
  36 // Note that most applications load thousands of methods, so keeping the size of this
  37 // structure small has a big impact on footprint.
  38 
  39 // The actual bytecodes are inlined after the end of the ConstMethod struct.
  40 //
  41 // The line number table is compressed and inlined following the byte codes. It is
  42 // found as the first byte following the byte codes.  Note that accessing the line
  43 // number and local variable tables is not performance critical at all.
  44 //
  45 // The checked exceptions table and the local variable table are inlined after the
  46 // line number table, and indexed from the end of the method. We do not compress the
  47 // checked exceptions table since the average length is less than 2, and it is used
  48 // by reflection so access should be fast.  We do not bother to compress the local
  49 // variable table either since it is mostly absent.
  50 //
  51 //
  52 //  ConstMethod embedded field layout (after declared fields):
  53 //    [EMBEDDED byte codes]
  54 //    [EMBEDDED 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 //    [EMBEDDED localvariable table elements + length (length last)]
  61 //     (length is u2, elements are 6-tuples of u2)
  62 //     (see class LocalVariableTableElement)
  63 //     (access flags bit tells whether table is present)
  64 //     (indexed from end of ConstMethod*)
  65 //    [EMBEDDED exception table + length (length last)]
  66 //     (length is u2, elements are 4-tuples of u2)
  67 //     (see class ExceptionTableElement)
  68 //     (access flags bit tells whether table is present)
  69 //     (indexed from end of ConstMethod*)
  70 //    [EMBEDDED checked exceptions elements + length (length last)]
  71 //     (length is u2, elements are u2)
  72 //     (see class CheckedExceptionElement)
  73 //     (access flags bit tells whether table is present)
  74 //     (indexed from end of ConstMethod*)
  75 //    [EMBEDDED method parameters elements + length (length last)]
  76 //     (length is u2, elements are u2, u4 structures)
  77 //     (see class MethodParametersElement)
  78 //     (access flags bit tells whether table is present)
  79 //     (indexed from end of ConstMethod*)
  80 //    [EMBEDDED generic signature index (u2)]
  81 //     (indexed from end of constMethodOop)
  82 //    [EMBEDDED annotations arrays - method, parameter, type, default]
  83 //      pointer to Array<u1> if annotation is present
  84 //
  85 // IMPORTANT: If anything gets added here, there need to be changes to
  86 // ensure that ServicabilityAgent doesn't get broken as a result!
  87 
  88 
  89 // Utility class describing elements in checked exceptions table inlined in Method*.
  90 class CheckedExceptionElement VALUE_OBJ_CLASS_SPEC {
  91  public:
  92   u2 class_cp_index;
  93 };
  94 
  95 
  96 // Utility class describing elements in local variable table inlined in Method*.
  97 class LocalVariableTableElement VALUE_OBJ_CLASS_SPEC {
  98  public:
  99   u2 start_bci;
 100   u2 length;
 101   u2 name_cp_index;
 102   u2 descriptor_cp_index;
 103   u2 signature_cp_index;
 104   u2 slot;
 105 };
 106 
 107 // Utility class describing elements in exception table
 108 class ExceptionTableElement VALUE_OBJ_CLASS_SPEC {
 109  public:
 110   u2 start_pc;
 111   u2 end_pc;
 112   u2 handler_pc;
 113   u2 catch_type_index;
 114 };
 115 
 116 // Utility class describing elements in method parameters
 117 class MethodParametersElement VALUE_OBJ_CLASS_SPEC {
 118  public:
 119   u2 name_cp_index;
 120   u2 flags;
 121 };
 122 
 123 class KlassSizeStats;
 124 class AdapterHandlerEntry;
 125 
 126 // Class to collect the sizes of ConstMethod inline tables
 127 #define INLINE_TABLES_DO(do_element)            \
 128   do_element(localvariable_table_length)        \
 129   do_element(compressed_linenumber_size)        \
 130   do_element(exception_table_length)            \
 131   do_element(checked_exceptions_length)         \
 132   do_element(method_parameters_length)          \
 133   do_element(generic_signature_index)           \
 134   do_element(method_annotations_length)         \
 135   do_element(parameter_annotations_length)      \
 136   do_element(type_annotations_length)           \
 137   do_element(default_annotations_length)
 138 
 139 #define INLINE_TABLE_DECLARE(sym)    int _##sym;
 140 #define INLINE_TABLE_PARAM(sym)      int sym,
 141 #define INLINE_TABLE_INIT(sym)       _##sym(sym),
 142 #define INLINE_TABLE_NULL(sym)       _##sym(0),
 143 #define INLINE_TABLE_ACCESSOR(sym)   int sym() const { return _##sym; }
 144 
 145 class InlineTableSizes : StackObj {
 146   // declarations
 147   INLINE_TABLES_DO(INLINE_TABLE_DECLARE)
 148   int _end;
 149  public:
 150   InlineTableSizes(
 151       INLINE_TABLES_DO(INLINE_TABLE_PARAM)
 152       int end) :
 153       INLINE_TABLES_DO(INLINE_TABLE_INIT)
 154       _end(end) {}
 155 
 156   // Default constructor for no inlined tables
 157   InlineTableSizes() :
 158       INLINE_TABLES_DO(INLINE_TABLE_NULL)
 159       _end(0) {}
 160 
 161   // Accessors
 162   INLINE_TABLES_DO(INLINE_TABLE_ACCESSOR)
 163 };
 164 #undef INLINE_TABLE_ACCESSOR
 165 #undef INLINE_TABLE_NULL
 166 #undef INLINE_TABLE_INIT
 167 #undef INLINE_TABLE_PARAM
 168 #undef INLINE_TABLE_DECLARE
 169 
 170 class ConstMethod : public MetaspaceObj {
 171   friend class VMStructs;
 172   friend class JVMCIVMStructs;
 173 
 174 public:
 175   typedef enum { NORMAL, OVERPASS } MethodType;
 176 
 177 private:
 178   enum {
 179     _has_linenumber_table = 0x0001,
 180     _has_checked_exceptions = 0x0002,
 181     _has_localvariable_table = 0x0004,
 182     _has_exception_table = 0x0008,
 183     _has_generic_signature = 0x0010,
 184     _has_method_parameters = 0x0020,
 185     _is_overpass = 0x0040,
 186     _has_method_annotations = 0x0080,
 187     _has_parameter_annotations = 0x0100,
 188     _has_type_annotations = 0x0200,
 189     _has_default_annotations = 0x0400
 190   };
 191 
 192   // Bit vector of signature
 193   // Callers interpret 0=not initialized yet and
 194   // -1=too many args to fix, must parse the slow way.
 195   // The real initial value is special to account for nonatomicity of 64 bit
 196   // loads and stores.  This value may updated and read without a lock by
 197   // multiple threads, so is volatile.
 198   volatile uint64_t _fingerprint;
 199 
 200   ConstantPool*     _constants;                  // Constant pool
 201 
 202   // Raw stackmap data for the method
 203   Array<u1>*        _stackmap_data;
 204 
 205   // Adapter blob (i2c/c2i) for this Method*. Set once when method is linked.
 206   union {
 207     AdapterHandlerEntry* _adapter;
 208     AdapterHandlerEntry** _adapter_trampoline; // see comments around Method::link_method()
 209   };
 210 
 211   int               _constMethod_size;
 212   u2                _flags;
 213   u1                _result_type;                 // BasicType of result
 214 
 215   // Size of Java bytecodes allocated immediately after Method*.
 216   u2                _code_size;
 217   u2                _name_index;                 // Method name (index in constant pool)
 218   u2                _signature_index;            // Method signature (index in constant pool)
 219   u2                _method_idnum;               // unique identification number for the method within the class
 220                                                  // initially corresponds to the index into the methods array.
 221                                                  // but this may change with redefinition
 222   u2                _max_stack;                  // Maximum number of entries on the expression stack
 223   u2                _max_locals;                 // Number of local variables used by this method
 224   u2                _size_of_parameters;         // size of the parameter block (receiver + arguments) in words
 225   u2                _orig_method_idnum;          // Original unique identification number for the method
 226 
 227   // Constructor
 228   ConstMethod(int byte_code_size,
 229               InlineTableSizes* sizes,
 230               MethodType is_overpass,
 231               int size);
 232 public:
 233 
 234   static ConstMethod* allocate(ClassLoaderData* loader_data,
 235                                int byte_code_size,
 236                                InlineTableSizes* sizes,
 237                                MethodType mt,
 238                                TRAPS);
 239 
 240   bool is_constMethod() const { return true; }
 241 
 242   // Inlined tables
 243   void set_inlined_tables_length(InlineTableSizes* sizes);
 244 
 245   bool has_generic_signature() const
 246     { return (_flags & _has_generic_signature) != 0; }
 247 
 248   bool has_linenumber_table() const
 249     { return (_flags & _has_linenumber_table) != 0; }
 250 
 251   bool has_checked_exceptions() const
 252     { return (_flags & _has_checked_exceptions) != 0; }
 253 
 254   bool has_localvariable_table() const
 255     { return (_flags & _has_localvariable_table) != 0; }
 256 
 257   bool has_exception_handler() const
 258     { return (_flags & _has_exception_table) != 0; }
 259 
 260   bool has_method_parameters() const
 261     { return (_flags & _has_method_parameters) != 0; }
 262 
 263   MethodType method_type() const {
 264     return ((_flags & _is_overpass) == 0) ? NORMAL : OVERPASS;
 265   }
 266 
 267   void set_method_type(MethodType mt) {
 268     if (mt == NORMAL) {
 269       _flags &= ~(_is_overpass);
 270     } else {
 271       _flags |= _is_overpass;
 272     }
 273   }
 274 
 275   // constant pool
 276   ConstantPool* constants() const        { return _constants; }
 277   void set_constants(ConstantPool* c)    { _constants = c; }
 278 
 279   Method* method() const;
 280 
 281   // stackmap table data
 282   Array<u1>* stackmap_data() const { return _stackmap_data; }
 283   void set_stackmap_data(Array<u1>* sd) { _stackmap_data = sd; }
 284   void copy_stackmap_data(ClassLoaderData* loader_data, u1* sd, int length, TRAPS);
 285   bool has_stackmap_table() const { return _stackmap_data != NULL; }
 286 
 287   // adapter
 288   void set_adapter_entry(AdapterHandlerEntry* adapter) {
 289     assert(!is_shared(), "shared methods have fixed adapter_trampoline");
 290     _adapter = adapter;
 291   }
 292   void set_adapter_trampoline(AdapterHandlerEntry** trampoline) {
 293     assert(DumpSharedSpaces, "must be");
 294     assert(*trampoline == NULL, "must be NULL during dump time, to be initialized at run time");
 295     _adapter_trampoline = trampoline;
 296   }
 297   void update_adapter_trampoline(AdapterHandlerEntry* adapter) {
 298     assert(is_shared(), "must be");
 299     *_adapter_trampoline = adapter;
 300     assert(this->adapter() == adapter, "must be");
 301   }
 302   AdapterHandlerEntry* adapter() {
 303     if (is_shared()) {
 304       return *_adapter_trampoline;
 305     } else {
 306       return _adapter;
 307     }
 308   }
 309 
 310   void init_fingerprint() {
 311     const uint64_t initval = UCONST64(0x8000000000000000);
 312     _fingerprint = initval;
 313   }
 314 
 315   uint64_t fingerprint() const                   {
 316     // Since reads aren't atomic for 64 bits, if any of the high or low order
 317     // word is the initial value, return 0.  See init_fingerprint for initval.
 318     uint high_fp = (uint)(_fingerprint >> 32);
 319     if ((int) _fingerprint == 0 || high_fp == 0x80000000) {
 320       return 0L;
 321     } else {
 322       return _fingerprint;
 323     }
 324   }
 325 
 326   uint64_t set_fingerprint(uint64_t new_fingerprint) {
 327 #ifdef ASSERT
 328     // Assert only valid if complete/valid 64 bit _fingerprint value is read.
 329     uint64_t oldfp = fingerprint();
 330 #endif // ASSERT
 331     _fingerprint = new_fingerprint;
 332     assert(oldfp == 0L || new_fingerprint == oldfp,
 333            "fingerprint cannot change");
 334     assert(((new_fingerprint >> 32) != 0x80000000) && (int)new_fingerprint !=0,
 335            "fingerprint should call init to set initial value");
 336     return new_fingerprint;
 337   }
 338 
 339   // name
 340   int name_index() const                         { return _name_index; }
 341   void set_name_index(int index)                 { _name_index = index; }
 342 
 343   // signature
 344   int signature_index() const                    { return _signature_index; }
 345   void set_signature_index(int index)            { _signature_index = index; }
 346 
 347   // generics support
 348   int generic_signature_index() const            {
 349     if (has_generic_signature()) {
 350       return *generic_signature_index_addr();
 351     } else {
 352       return 0;
 353     }
 354   }
 355   void set_generic_signature_index(u2 index)    {
 356     assert(has_generic_signature(), "");
 357     u2* addr = generic_signature_index_addr();
 358     *addr = index;
 359   }
 360 
 361   // Sizing
 362   static int header_size() {
 363     return align_size_up((int)sizeof(ConstMethod), wordSize) / wordSize;
 364   }
 365 
 366   // Size needed
 367   static int size(int code_size, InlineTableSizes* sizes);
 368 
 369   int size() const                    { return _constMethod_size;}
 370   void set_constMethod_size(int size)     { _constMethod_size = size; }
 371 #if INCLUDE_SERVICES
 372   void collect_statistics(KlassSizeStats *sz) const;
 373 #endif
 374 
 375   // code size
 376   int code_size() const                          { return _code_size; }
 377   void set_code_size(int size) {
 378     assert(max_method_code_size < (1 << 16),
 379            "u2 is too small to hold method code size in general");
 380     assert(0 <= size && size <= max_method_code_size, "invalid code size");
 381     _code_size = size;
 382   }
 383 
 384   // linenumber table - note that length is unknown until decompression,
 385   // see class CompressedLineNumberReadStream.
 386   u_char* compressed_linenumber_table() const;         // not preserved by gc
 387   u2* generic_signature_index_addr() const;
 388   u2* checked_exceptions_length_addr() const;
 389   u2* localvariable_table_length_addr() const;
 390   u2* exception_table_length_addr() const;
 391   u2* method_parameters_length_addr() const;
 392 
 393   // checked exceptions
 394   int checked_exceptions_length() const;
 395   CheckedExceptionElement* checked_exceptions_start() const;
 396 
 397   // localvariable table
 398   int localvariable_table_length() const;
 399   LocalVariableTableElement* localvariable_table_start() const;
 400 
 401   // exception table
 402   int exception_table_length() const;
 403   ExceptionTableElement* exception_table_start() const;
 404 
 405   // method parameters table
 406 
 407   // This returns -1 if no parameters are present, a non-negative
 408   // value otherwise.  Note: sometimes, there are 0-length parameters
 409   // attributes that must be reported up to the reflection API all the
 410   // same.
 411   int method_parameters_length() const;
 412   MethodParametersElement* method_parameters_start() const;
 413 
 414   // method annotations
 415   bool has_method_annotations() const
 416     { return (_flags & _has_method_annotations) != 0; }
 417 
 418   bool has_parameter_annotations() const
 419     { return (_flags & _has_parameter_annotations) != 0; }
 420 
 421   bool has_type_annotations() const
 422     { return (_flags & _has_type_annotations) != 0; }
 423 
 424   bool has_default_annotations() const
 425     { return (_flags & _has_default_annotations) != 0; }
 426 
 427 
 428   AnnotationArray** method_annotations_addr() const;
 429   AnnotationArray* method_annotations() const  {
 430     return has_method_annotations() ? *(method_annotations_addr()) : NULL;
 431   }
 432   void set_method_annotations(AnnotationArray* anno) {
 433     *(method_annotations_addr()) = anno;
 434   }
 435 
 436   AnnotationArray** parameter_annotations_addr() const;
 437   AnnotationArray* parameter_annotations() const {
 438     return has_parameter_annotations() ? *(parameter_annotations_addr()) : NULL;
 439   }
 440   void set_parameter_annotations(AnnotationArray* anno) {
 441     *(parameter_annotations_addr()) = anno;
 442   }
 443 
 444   AnnotationArray** type_annotations_addr() const;
 445   AnnotationArray* type_annotations() const {
 446     return has_type_annotations() ? *(type_annotations_addr()) : NULL;
 447   }
 448   void set_type_annotations(AnnotationArray* anno) {
 449     *(type_annotations_addr()) = anno;
 450   }
 451 
 452   AnnotationArray** default_annotations_addr() const;
 453   AnnotationArray* default_annotations() const {
 454     return has_default_annotations() ? *(default_annotations_addr()) : NULL;
 455   }
 456   void set_default_annotations(AnnotationArray* anno) {
 457     *(default_annotations_addr()) = anno;
 458   }
 459 
 460   int method_annotations_length() const {
 461     return has_method_annotations() ? method_annotations()->length() : 0;
 462   }
 463   int parameter_annotations_length() const {
 464     return has_parameter_annotations() ? parameter_annotations()->length() : 0;
 465   }
 466   int type_annotations_length() const {
 467     return has_type_annotations() ? type_annotations()->length() : 0;
 468   }
 469   int default_annotations_length() const {
 470     return has_default_annotations() ? default_annotations()->length() : 0;
 471   }
 472 
 473   // Copy annotations from other ConstMethod
 474   void copy_annotations_from(ClassLoaderData* loader_data, ConstMethod* cm, TRAPS);
 475 
 476   // byte codes
 477   void    set_code(address code) {
 478     if (code_size() > 0) {
 479       memcpy(code_base(), code, code_size());
 480     }
 481   }
 482   address code_base() const            { return (address) (this+1); }
 483   address code_end() const             { return code_base() + code_size(); }
 484   bool    contains(address bcp) const  { return code_base() <= bcp
 485                                                      && bcp < code_end(); }
 486   // Offset to bytecodes
 487   static ByteSize codes_offset()
 488                             { return in_ByteSize(sizeof(ConstMethod)); }
 489 
 490   static ByteSize constants_offset()
 491                             { return byte_offset_of(ConstMethod, _constants); }
 492 
 493   static ByteSize max_stack_offset()
 494                             { return byte_offset_of(ConstMethod, _max_stack); }
 495   static ByteSize size_of_locals_offset()
 496                             { return byte_offset_of(ConstMethod, _max_locals); }
 497   static ByteSize size_of_parameters_offset()
 498                             { return byte_offset_of(ConstMethod, _size_of_parameters); }
 499 
 500   static ByteSize result_type_offset()
 501                             { return byte_offset_of(ConstMethod, _result_type); }
 502 
 503   // Unique id for the method
 504   static const u2 MAX_IDNUM;
 505   static const u2 UNSET_IDNUM;
 506   u2 method_idnum() const                        { return _method_idnum; }
 507   void set_method_idnum(u2 idnum)                { _method_idnum = idnum; }
 508 
 509   u2 orig_method_idnum() const                   { return _orig_method_idnum; }
 510   void set_orig_method_idnum(u2 idnum)           { _orig_method_idnum = idnum; }
 511 
 512   // max stack
 513   int  max_stack() const                         { return _max_stack; }
 514   void set_max_stack(int size)                   { _max_stack = size; }
 515 
 516   // max locals
 517   int  max_locals() const                        { return _max_locals; }
 518   void set_max_locals(int size)                  { _max_locals = size; }
 519 
 520   // size of parameters
 521   int  size_of_parameters() const                { return _size_of_parameters; }
 522   void set_size_of_parameters(int size)          { _size_of_parameters = size; }
 523 
 524   void set_result_type(BasicType rt)             { assert(rt < 16, "result type too large");
 525                                                    _result_type = (u1)rt; }
 526   // Deallocation for RedefineClasses
 527   void deallocate_contents(ClassLoaderData* loader_data);
 528   bool is_klass() const { return false; }
 529   DEBUG_ONLY(bool on_stack() { return false; })
 530 
 531 private:
 532   // Since the size of the compressed line number table is unknown, the
 533   // offsets of the other variable sized sections are computed backwards
 534   // from the end of the ConstMethod*.
 535 
 536   // First byte after ConstMethod*
 537   address constMethod_end() const
 538                           { return (address)((intptr_t*)this + _constMethod_size); }
 539 
 540   // Last short in ConstMethod*
 541   u2* last_u2_element() const;
 542 
 543  public:
 544   // Printing
 545   void print_on      (outputStream* st) const;
 546   void print_value_on(outputStream* st) const;
 547 
 548   const char* internal_name() const { return "{constMethod}"; }
 549 
 550   // Verify
 551   void verify_on(outputStream* st);
 552 };
 553 
 554 #endif // SHARE_VM_OOPS_CONSTMETHODOOP_HPP