< prev index next >

src/hotspot/share/oops/generateOopMap.hpp

Print this page




  74  private:
  75   RetTableEntry *_first;
  76   static int _init_nof_entries;
  77 
  78   void add_jsr(int return_bci, int target_bci);   // Adds entry to list
  79  public:
  80   RetTable()                                                  { _first = NULL; }
  81   void compute_ret_table(const methodHandle& method);
  82   void update_ret_table(int bci, int delta);
  83   RetTableEntry* find_jsrs_for_target(int targBci);
  84 };
  85 
  86 //
  87 // CellTypeState
  88 //
  89 class CellTypeState {
  90  private:
  91   unsigned int _state;
  92 
  93   // Masks for separating the BITS and INFO portions of a CellTypeState
  94   enum { info_mask            = right_n_bits(28),
  95          bits_mask            = (int)(~info_mask) };
  96 
  97   // These constant are used for manipulating the BITS portion of a
  98   // CellTypeState
  99   enum { uninit_bit           = (int)(nth_bit(31)),
 100          ref_bit              = nth_bit(30),
 101          val_bit              = nth_bit(29),
 102          addr_bit             = nth_bit(28),
 103          live_bits_mask       = (int)(bits_mask & ~uninit_bit) };
 104 
 105   // These constants are used for manipulating the INFO portion of a
 106   // CellTypeState
 107   enum { top_info_bit         = nth_bit(27),
 108          not_bottom_info_bit  = nth_bit(26),
 109          info_data_mask       = right_n_bits(26),
 110          info_conflict        = info_mask };
 111 
 112   // Within the INFO data, these values are used to distinguish different
 113   // kinds of references.
 114   enum { ref_not_lock_bit     = nth_bit(25),  // 0 if this reference is locked as a monitor
 115          ref_slot_bit         = nth_bit(24),  // 1 if this reference is a "slot" reference,
 116                                               // 0 if it is a "line" reference.
 117          ref_data_mask        = right_n_bits(24) };
 118 





 119 
 120   // These values are used to initialize commonly used CellTypeState
 121   // constants.
 122   enum { bottom_value         = 0,
 123          uninit_value         = (int)(uninit_bit | info_conflict),
 124          ref_value            = ref_bit,
 125          ref_conflict         = ref_bit | info_conflict,
 126          val_value            = val_bit | info_conflict,
 127          addr_value           = addr_bit,
 128          addr_conflict        = addr_bit | info_conflict };
 129 
 130  public:
 131 
 132   // Since some C++ constructors generate poor code for declarations of the
 133   // form...
 134   //
 135   //   CellTypeState vector[length];
 136   //
 137   // ...we avoid making a constructor for this class.  CellTypeState values
 138   // should be constructed using one of the make_* methods:


 380   void  interp_all                          ();
 381 
 382   // Interpretation methods (secondary)
 383   void  interp1                             (BytecodeStream *itr);
 384   void  do_exception_edge                   (BytecodeStream *itr);
 385   void  check_type                          (CellTypeState expected, CellTypeState actual);
 386   void  ppstore                             (CellTypeState *in,  int loc_no);
 387   void  ppload                              (CellTypeState *out, int loc_no);
 388   void  ppush1                              (CellTypeState in);
 389   void  ppush                               (CellTypeState *in);
 390   void  ppop1                               (CellTypeState out);
 391   void  ppop                                (CellTypeState *out);
 392   void  ppop_any                            (int poplen);
 393   void  pp                                  (CellTypeState *in, CellTypeState *out);
 394   void  pp_new_ref                          (CellTypeState *in, int bci);
 395   void  ppdupswap                           (int poplen, const char *out);
 396   void  do_ldc                              (int bci);
 397   void  do_astore                           (int idx);
 398   void  do_jsr                              (int delta);
 399   void  do_field                            (int is_get, int is_static, int idx, int bci);
 400   void  do_method                           (int is_static, int is_interface, int idx, int bci);

 401   void  do_multianewarray                   (int dims, int bci);
 402   void  do_monitorenter                     (int bci);
 403   void  do_monitorexit                      (int bci);
 404   void  do_return_monitor_check             ();
 405   void  do_checkcast                        ();
 406   CellTypeState *sigchar_to_effect          (char sigch, int bci, CellTypeState *out);
 407   int copy_cts                              (CellTypeState *dst, CellTypeState *src);
 408 
 409   // Error handling
 410   void  error_work                          (const char *format, va_list ap) ATTRIBUTE_PRINTF(2, 0);
 411   void  report_error                        (const char *format, ...) ATTRIBUTE_PRINTF(2, 3);
 412   void  verify_error                        (const char *format, ...) ATTRIBUTE_PRINTF(2, 3);
 413   bool  got_error()                         { return _got_error; }
 414 
 415   // Create result set
 416   bool  _report_result;
 417   bool  _report_result_for_send;            // Unfortunatly, stackmaps for sends are special, so we need some extra
 418   BytecodeStream *_itr_send;                // variables to handle them properly.
 419 
 420   void  report_result                       ();




  74  private:
  75   RetTableEntry *_first;
  76   static int _init_nof_entries;
  77 
  78   void add_jsr(int return_bci, int target_bci);   // Adds entry to list
  79  public:
  80   RetTable()                                                  { _first = NULL; }
  81   void compute_ret_table(const methodHandle& method);
  82   void update_ret_table(int bci, int delta);
  83   RetTableEntry* find_jsrs_for_target(int targBci);
  84 };
  85 
  86 //
  87 // CellTypeState
  88 //
  89 class CellTypeState {
  90  private:
  91   unsigned int _state;
  92 
  93   // Masks for separating the BITS and INFO portions of a CellTypeState
  94   enum { info_mask            = right_n_bits(27),
  95          bits_mask            = (int)(~info_mask) };
  96 
  97   // These constant are used for manipulating the BITS portion of a
  98   // CellTypeState
  99   enum { uninit_bit           = (int)(nth_bit(31)),
 100          ref_bit              = nth_bit(30),
 101          val_bit              = nth_bit(29),
 102          addr_bit             = nth_bit(28),
 103          live_bits_mask       = (int)(bits_mask & ~uninit_bit) };
 104 
 105   // These constants are used for manipulating the INFO portion of a
 106   // CellTypeState
 107   enum { top_info_bit         = nth_bit(26),
 108          not_bottom_info_bit  = nth_bit(25),
 109          info_data_mask       = right_n_bits(25),
 110          info_conflict        = info_mask };
 111 
 112   // Within the INFO data, these values are used to distinguish different
 113   // kinds of references.
 114   enum { ref_not_lock_bit     = nth_bit(24),  // 0 if this reference is locked as a monitor
 115          ref_slot_bit         = nth_bit(23),  // 1 if this reference is a "slot" reference,
 116                                               // 0 if it is a "line" reference.
 117          ref_data_mask        = right_n_bits(23) };
 118 
 119   // Within the INFO data, these values are used to distinguish different
 120   // kinds of value types.
 121   enum { valuetype_slot_bit   = nth_bit(24),  // 1 if this reference is a "slot" value type,
 122     // 0 if it is a "line" value type.
 123     valuetype_data_mask  = right_n_bits(24) };
 124 
 125   // These values are used to initialize commonly used CellTypeState
 126   // constants.
 127   enum { bottom_value         = 0,
 128          uninit_value         = (int)(uninit_bit | info_conflict),
 129          ref_value            = ref_bit,
 130          ref_conflict         = ref_bit | info_conflict,
 131          val_value            = val_bit | info_conflict,
 132          addr_value           = addr_bit,
 133          addr_conflict        = addr_bit | info_conflict };
 134 
 135  public:
 136 
 137   // Since some C++ constructors generate poor code for declarations of the
 138   // form...
 139   //
 140   //   CellTypeState vector[length];
 141   //
 142   // ...we avoid making a constructor for this class.  CellTypeState values
 143   // should be constructed using one of the make_* methods:


 385   void  interp_all                          ();
 386 
 387   // Interpretation methods (secondary)
 388   void  interp1                             (BytecodeStream *itr);
 389   void  do_exception_edge                   (BytecodeStream *itr);
 390   void  check_type                          (CellTypeState expected, CellTypeState actual);
 391   void  ppstore                             (CellTypeState *in,  int loc_no);
 392   void  ppload                              (CellTypeState *out, int loc_no);
 393   void  ppush1                              (CellTypeState in);
 394   void  ppush                               (CellTypeState *in);
 395   void  ppop1                               (CellTypeState out);
 396   void  ppop                                (CellTypeState *out);
 397   void  ppop_any                            (int poplen);
 398   void  pp                                  (CellTypeState *in, CellTypeState *out);
 399   void  pp_new_ref                          (CellTypeState *in, int bci);
 400   void  ppdupswap                           (int poplen, const char *out);
 401   void  do_ldc                              (int bci);
 402   void  do_astore                           (int idx);
 403   void  do_jsr                              (int delta);
 404   void  do_field                            (int is_get, int is_static, int idx, int bci);
 405   void  do_method                           (int is_static, int idx, int bci);
 406   void  do_withfield                       (int idx, int bci);
 407   void  do_multianewarray                   (int dims, int bci);
 408   void  do_monitorenter                     (int bci);
 409   void  do_monitorexit                      (int bci);
 410   void  do_return_monitor_check             ();
 411   void  do_checkcast                        ();
 412   CellTypeState *sigchar_to_effect          (char sigch, int bci, CellTypeState *out);
 413   int copy_cts                              (CellTypeState *dst, CellTypeState *src);
 414 
 415   // Error handling
 416   void  error_work                          (const char *format, va_list ap) ATTRIBUTE_PRINTF(2, 0);
 417   void  report_error                        (const char *format, ...) ATTRIBUTE_PRINTF(2, 3);
 418   void  verify_error                        (const char *format, ...) ATTRIBUTE_PRINTF(2, 3);
 419   bool  got_error()                         { return _got_error; }
 420 
 421   // Create result set
 422   bool  _report_result;
 423   bool  _report_result_for_send;            // Unfortunatly, stackmaps for sends are special, so we need some extra
 424   BytecodeStream *_itr_send;                // variables to handle them properly.
 425 
 426   void  report_result                       ();


< prev index next >