< prev index next >

src/hotspot/share/oops/fieldInfo.inline.hpp

Print this page

 68 inline int FieldInfoStream::num_java_fields(const Array<u1>* fis) { return FieldInfoReader(fis).next_uint(); }
 69 
 70 template<typename CON>
 71 inline void Mapper<CON>::map_field_info(const FieldInfo& fi) {
 72   _next_index++;  // pre-increment
 73   _consumer->accept_uint(fi.name_index());
 74   _consumer->accept_uint(fi.signature_index());
 75   _consumer->accept_uint(fi.offset());
 76   _consumer->accept_uint(fi.access_flags().as_int());
 77   _consumer->accept_uint(fi.field_flags().as_uint());
 78   if(fi.field_flags().has_any_optionals()) {
 79     if (fi.field_flags().is_initialized()) {
 80       _consumer->accept_uint(fi.initializer_index());
 81     }
 82     if (fi.field_flags().is_generic()) {
 83       _consumer->accept_uint(fi.generic_signature_index());
 84     }
 85     if (fi.field_flags().is_contended()) {
 86       _consumer->accept_uint(fi.contention_group());
 87     }



 88   } else {
 89     assert(fi.initializer_index() == 0, "");
 90     assert(fi.generic_signature_index() == 0, "");
 91     assert(fi.contention_group() == 0, "");

 92   }
 93 }
 94 
 95 
 96 inline FieldInfoReader::FieldInfoReader(const Array<u1>* fi)
 97   : _r(fi->data(), 0),
 98     _next_index(0) { }
 99 
100 inline void FieldInfoReader::read_field_info(FieldInfo& fi) {
101   fi._index = _next_index++;
102   fi._name_index = checked_cast<u2>(next_uint());
103   fi._signature_index = checked_cast<u2>(next_uint());
104   fi._offset = next_uint();
105   fi._access_flags = AccessFlags(next_uint());
106   fi._field_flags = FieldInfo::FieldFlags(next_uint());
107   if (fi._field_flags.is_initialized()) {
108     fi._initializer_index = checked_cast<u2>(next_uint());
109   } else {
110     fi._initializer_index = 0;
111   }
112   if (fi._field_flags.is_generic()) {
113     fi._generic_signature_index = checked_cast<u2>(next_uint());
114   } else {
115     fi._generic_signature_index = 0;
116   }
117   if (fi._field_flags.is_contended()) {
118     fi._contention_group = checked_cast<u2>(next_uint());
119   } else {
120     fi._contention_group = 0;
121   }





122 }
123 
124 inline FieldInfoReader&  FieldInfoReader::skip_field_info() {
125   _next_index++;
126   const int name_sig_af_off = 4;  // four items
127   skip(name_sig_af_off);
128   FieldInfo::FieldFlags ff(next_uint());
129   if (ff.has_any_optionals()) {
130     const int init_gen_cont = (ff.is_initialized() +
131                                 ff.is_generic() +
132                                 ff.is_contended());

133     skip(init_gen_cont);  // up to three items
134   }
135   return *this;
136 }
137 
138 // Skip to the nth field.  If the reader is freshly initialized to
139 // the zero index, this will call skip_field_info() n times.
140 inline FieldInfoReader& FieldInfoReader::skip_to_field_info(int n) {
141   assert(n >= _next_index, "already past that index");
142   const int count = n - _next_index;
143   for (int i = 0; i < count; i++)  skip_field_info();
144   assert(_next_index == n, "");
145   return *this;
146 }
147 
148 // for random access, if you know where to go up front:
149 inline FieldInfoReader& FieldInfoReader::set_position_and_next_index(int position, int next_index) {
150   _r.set_position(position);
151   _next_index = next_index;
152   return *this;

 68 inline int FieldInfoStream::num_java_fields(const Array<u1>* fis) { return FieldInfoReader(fis).next_uint(); }
 69 
 70 template<typename CON>
 71 inline void Mapper<CON>::map_field_info(const FieldInfo& fi) {
 72   _next_index++;  // pre-increment
 73   _consumer->accept_uint(fi.name_index());
 74   _consumer->accept_uint(fi.signature_index());
 75   _consumer->accept_uint(fi.offset());
 76   _consumer->accept_uint(fi.access_flags().as_int());
 77   _consumer->accept_uint(fi.field_flags().as_uint());
 78   if(fi.field_flags().has_any_optionals()) {
 79     if (fi.field_flags().is_initialized()) {
 80       _consumer->accept_uint(fi.initializer_index());
 81     }
 82     if (fi.field_flags().is_generic()) {
 83       _consumer->accept_uint(fi.generic_signature_index());
 84     }
 85     if (fi.field_flags().is_contended()) {
 86       _consumer->accept_uint(fi.contention_group());
 87     }
 88     if (fi.field_flags().has_null_marker()) {
 89       _consumer->accept_uint(fi.null_marker_offset());
 90     }
 91   } else {
 92     assert(fi.initializer_index() == 0, "");
 93     assert(fi.generic_signature_index() == 0, "");
 94     assert(fi.contention_group() == 0, "");
 95     assert(fi.null_marker_offset() == 0, "");
 96   }
 97 }
 98 
 99 
100 inline FieldInfoReader::FieldInfoReader(const Array<u1>* fi)
101   : _r(fi->data(), 0),
102     _next_index(0) { }
103 
104 inline void FieldInfoReader::read_field_info(FieldInfo& fi) {
105   fi._index = _next_index++;
106   fi._name_index = checked_cast<u2>(next_uint());
107   fi._signature_index = checked_cast<u2>(next_uint());
108   fi._offset = next_uint();
109   fi._access_flags = AccessFlags(next_uint());
110   fi._field_flags = FieldInfo::FieldFlags(next_uint());
111   if (fi._field_flags.is_initialized()) {
112     fi._initializer_index = checked_cast<u2>(next_uint());
113   } else {
114     fi._initializer_index = 0;
115   }
116   if (fi._field_flags.is_generic()) {
117     fi._generic_signature_index = checked_cast<u2>(next_uint());
118   } else {
119     fi._generic_signature_index = 0;
120   }
121   if (fi._field_flags.is_contended()) {
122     fi._contention_group = checked_cast<u2>(next_uint());
123   } else {
124     fi._contention_group = 0;
125   }
126   if (fi._field_flags.has_null_marker()) {
127     fi._null_marker_offset = next_uint();
128   } else {
129     fi._null_marker_offset = 0;
130   }
131 }
132 
133 inline FieldInfoReader&  FieldInfoReader::skip_field_info() {
134   _next_index++;
135   const int name_sig_af_off = 4;  // four items
136   skip(name_sig_af_off);
137   FieldInfo::FieldFlags ff(next_uint());
138   if (ff.has_any_optionals()) {
139     const int init_gen_cont = (ff.is_initialized() +
140                                 ff.is_generic() +
141                                 ff.is_contended() +
142                                 ff.has_null_marker());
143     skip(init_gen_cont);  // up to three items
144   }
145   return *this;
146 }
147 
148 // Skip to the nth field.  If the reader is freshly initialized to
149 // the zero index, this will call skip_field_info() n times.
150 inline FieldInfoReader& FieldInfoReader::skip_to_field_info(int n) {
151   assert(n >= _next_index, "already past that index");
152   const int count = n - _next_index;
153   for (int i = 0; i < count; i++)  skip_field_info();
154   assert(_next_index == n, "");
155   return *this;
156 }
157 
158 // for random access, if you know where to go up front:
159 inline FieldInfoReader& FieldInfoReader::set_position_and_next_index(int position, int next_index) {
160   _r.set_position(position);
161   _next_index = next_index;
162   return *this;
< prev index next >