< prev index next >

src/hotspot/share/oops/generateOopMap.hpp

Print this page
@@ -89,11 +89,11 @@
  class CellTypeState {
   private:
    unsigned int _state;
  
    // Masks for separating the BITS and INFO portions of a CellTypeState
-   enum { info_mask            = right_n_bits(28),
+   enum { info_mask            = right_n_bits(27),
           bits_mask            = (int)(~info_mask) };
  
    // These constant are used for manipulating the BITS portion of a
    // CellTypeState
    enum { uninit_bit           = (int)(nth_bit(31)),

@@ -102,22 +102,27 @@
           addr_bit             = nth_bit(28),
           live_bits_mask       = (int)(bits_mask & ~uninit_bit) };
  
    // These constants are used for manipulating the INFO portion of a
    // CellTypeState
-   enum { top_info_bit         = nth_bit(27),
-          not_bottom_info_bit  = nth_bit(26),
-          info_data_mask       = right_n_bits(26),
+   enum { top_info_bit         = nth_bit(26),
+          not_bottom_info_bit  = nth_bit(25),
+          info_data_mask       = right_n_bits(25),
           info_conflict        = info_mask };
  
    // Within the INFO data, these values are used to distinguish different
    // kinds of references.
-   enum { ref_not_lock_bit     = nth_bit(25),  // 0 if this reference is locked as a monitor
-          ref_slot_bit         = nth_bit(24),  // 1 if this reference is a "slot" reference,
+   enum { ref_not_lock_bit     = nth_bit(24),  // 0 if this reference is locked as a monitor
+          ref_slot_bit         = nth_bit(23),  // 1 if this reference is a "slot" reference,
                                                // 0 if it is a "line" reference.
-          ref_data_mask        = right_n_bits(24) };
+          ref_data_mask        = right_n_bits(23) };
  
+   // Within the INFO data, these values are used to distinguish different
+   // kinds of value types.
+   enum { valuetype_slot_bit   = nth_bit(24),  // 1 if this reference is a "slot" value type,
+     // 0 if it is a "line" value type.
+     valuetype_data_mask  = right_n_bits(24) };
  
    // These values are used to initialize commonly used CellTypeState
    // constants.
    enum { bottom_value         = 0,
           uninit_value         = (int)(uninit_bit | info_conflict),

@@ -194,11 +199,11 @@
      return true;
    }
  
    bool is_address() const               { return ((_state & bits_mask) == addr_bit); }
    bool is_reference() const             { return ((_state & bits_mask) == ref_bit); }
-   bool is_value() const                 { return ((_state & bits_mask) == val_bit); }
+   bool is_inline_type() const           { return ((_state & bits_mask) == val_bit); }
    bool is_uninit() const                { return ((_state & bits_mask) == (uint)uninit_bit); }
  
    bool can_be_address() const           { return ((_state & addr_bit) != 0); }
    bool can_be_reference() const         { return ((_state & ref_bit) != 0); }
    bool can_be_value() const             { return ((_state & val_bit) != 0); }

@@ -395,11 +400,12 @@
    void  ppdupswap                           (int poplen, const char *out);
    void  do_ldc                              (int bci);
    void  do_astore                           (int idx);
    void  do_jsr                              (int delta);
    void  do_field                            (int is_get, int is_static, int idx, int bci);
-   void  do_method                           (int is_static, int is_interface, int idx, int bci);
+   void  do_method                           (int is_static, int idx, int bci);
+   void  do_withfield                       (int idx, int bci);
    void  do_multianewarray                   (int dims, int bci);
    void  do_monitorenter                     (int bci);
    void  do_monitorexit                      (int bci);
    void  do_return_monitor_check             ();
    void  do_checkcast                        ();
< prev index next >