Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/signature.hpp @ 2177:3582bf76420e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6990754: Use native memory and reference counting to implement SymbolTable Summary: move symbols from permgen into C heap and reference count them Reviewed-by: never, acorn, jmasa, stefank
author coleenp
date Thu, 27 Jan 2011 16:11:27 -0800
parents f95d63e2154a
children 1d1603768966
comparison
equal deleted inserted replaced
2176:27e4ea99855d 2177:3582bf76420e
45 // NOTE: The new optimizer has an alternate, for-loop based signature 45 // NOTE: The new optimizer has an alternate, for-loop based signature
46 // iterator implemented in opto/type.cpp, TypeTuple::make(). 46 // iterator implemented in opto/type.cpp, TypeTuple::make().
47 47
48 class SignatureIterator: public ResourceObj { 48 class SignatureIterator: public ResourceObj {
49 protected: 49 protected:
50 symbolHandle _signature; // the signature to iterate over 50 Symbol* _signature; // the signature to iterate over
51 int _index; // the current character index (only valid during iteration) 51 int _index; // the current character index (only valid during iteration)
52 int _parameter_index; // the current parameter index (0 outside iteration phase) 52 int _parameter_index; // the current parameter index (0 outside iteration phase)
53 BasicType _return_type; 53 BasicType _return_type;
54 54
55 void expect(char c); 55 void expect(char c);
85 result_feature_size - parameter_feature_size - 85 result_feature_size - parameter_feature_size -
86 static_feature_size) / parameter_feature_size 86 static_feature_size) / parameter_feature_size
87 }; 87 };
88 88
89 // Constructors 89 // Constructors
90 SignatureIterator(symbolOop signature); 90 SignatureIterator(Symbol* signature);
91 SignatureIterator(Thread *thread, symbolOop signature);
92 SignatureIterator(symbolHandle signature);
93 91
94 // Iteration 92 // Iteration
95 void dispatch_field(); // dispatches once for field signatures 93 void dispatch_field(); // dispatches once for field signatures
96 void iterate_parameters(); // iterates over parameters only 94 void iterate_parameters(); // iterates over parameters only
97 void iterate_parameters( uint64_t fingerprint ); 95 void iterate_parameters( uint64_t fingerprint );
136 void do_void() { type_name("void" ); } 134 void do_void() { type_name("void" ); }
137 void do_object(int begin, int end) { type_name("jobject" ); } 135 void do_object(int begin, int end) { type_name("jobject" ); }
138 void do_array (int begin, int end) { type_name("jobject" ); } 136 void do_array (int begin, int end) { type_name("jobject" ); }
139 137
140 public: 138 public:
141 SignatureTypeNames(symbolHandle signature) : SignatureIterator(signature) {} 139 SignatureTypeNames(Symbol* signature) : SignatureIterator(signature) {}
142 }; 140 };
143 141
144 142
145 class SignatureInfo: public SignatureIterator { 143 class SignatureInfo: public SignatureIterator {
146 protected: 144 protected:
164 void do_void () { set(T_VOID_size , T_VOID ); } 162 void do_void () { set(T_VOID_size , T_VOID ); }
165 void do_object(int begin, int end) { set(T_OBJECT_size , T_OBJECT ); } 163 void do_object(int begin, int end) { set(T_OBJECT_size , T_OBJECT ); }
166 void do_array (int begin, int end) { set(T_ARRAY_size , T_ARRAY ); } 164 void do_array (int begin, int end) { set(T_ARRAY_size , T_ARRAY ); }
167 165
168 public: 166 public:
169 SignatureInfo(symbolHandle signature) : SignatureIterator(signature) { 167 SignatureInfo(Symbol* signature) : SignatureIterator(signature) {
170 _has_iterated = _has_iterated_return = false; 168 _has_iterated = _has_iterated_return = false;
171 _size = 0; 169 _size = 0;
172 _return_type = T_ILLEGAL; 170 _return_type = T_ILLEGAL;
173 } 171 }
174 172
179 177
180 class ArgumentSizeComputer: public SignatureInfo { 178 class ArgumentSizeComputer: public SignatureInfo {
181 private: 179 private:
182 void set(int size, BasicType type) { _size += size; } 180 void set(int size, BasicType type) { _size += size; }
183 public: 181 public:
184 ArgumentSizeComputer(symbolHandle signature) : SignatureInfo(signature) {} 182 ArgumentSizeComputer(Symbol* signature) : SignatureInfo(signature) {}
185 183
186 int size() { lazy_iterate_parameters(); return _size; } 184 int size() { lazy_iterate_parameters(); return _size; }
187 }; 185 };
188 186
189 187
190 class ArgumentCount: public SignatureInfo { 188 class ArgumentCount: public SignatureInfo {
191 private: 189 private:
192 void set(int size, BasicType type) { _size ++; } 190 void set(int size, BasicType type) { _size ++; }
193 public: 191 public:
194 ArgumentCount(symbolHandle signature) : SignatureInfo(signature) {} 192 ArgumentCount(Symbol* signature) : SignatureInfo(signature) {}
195 193
196 int size() { lazy_iterate_parameters(); return _size; } 194 int size() { lazy_iterate_parameters(); return _size; }
197 }; 195 };
198 196
199 197
203 private: 201 private:
204 void set(int size, BasicType type) { _return_type = type; } 202 void set(int size, BasicType type) { _return_type = type; }
205 public: 203 public:
206 BasicType type() { lazy_iterate_return(); return _return_type; } 204 BasicType type() { lazy_iterate_return(); return _return_type; }
207 205
208 ResultTypeFinder(symbolHandle signature) : SignatureInfo(signature) {} 206 ResultTypeFinder(Symbol* signature) : SignatureInfo(signature) {}
209 }; 207 };
210 208
211 209
212 // Fingerprinter computes a unique ID for a given method. The ID 210 // Fingerprinter computes a unique ID for a given method. The ID
213 // is a bitvector characterizing the methods signature (incl. the receiver). 211 // is a bitvector characterizing the methods signature (incl. the receiver).
232 void do_array (int begin, int end) { _fingerprint |= (((uint64_t)obj_parm) << _shift_count); _shift_count += parameter_feature_size; } 230 void do_array (int begin, int end) { _fingerprint |= (((uint64_t)obj_parm) << _shift_count); _shift_count += parameter_feature_size; }
233 231
234 void do_void() { ShouldNotReachHere(); } 232 void do_void() { ShouldNotReachHere(); }
235 233
236 Fingerprinter(methodHandle method) : SignatureIterator(method->signature()) { 234 Fingerprinter(methodHandle method) : SignatureIterator(method->signature()) {
237 mh = method;
238 _fingerprint = 0;
239 }
240
241 Fingerprinter(Thread *thread, methodHandle method) : SignatureIterator(thread, method->signature()) {
242 mh = method; 235 mh = method;
243 _fingerprint = 0; 236 _fingerprint = 0;
244 } 237 }
245 238
246 uint64_t fingerprint() { 239 uint64_t fingerprint() {
354 347
355 // Handy stream for iterating over signature 348 // Handy stream for iterating over signature
356 349
357 class SignatureStream : public StackObj { 350 class SignatureStream : public StackObj {
358 private: 351 private:
359 symbolHandle _signature; 352 Symbol* _signature;
360 int _begin; 353 int _begin;
361 int _end; 354 int _end;
362 BasicType _type; 355 BasicType _type;
363 bool _at_return_type; 356 bool _at_return_type;
357 GrowableArray<Symbol*>* _names; // symbols created while parsing signature
364 358
365 public: 359 public:
366 bool at_return_type() const { return _at_return_type; } 360 bool at_return_type() const { return _at_return_type; }
367 bool is_done() const; 361 bool is_done() const;
368 void next_non_primitive(int t); 362 void next_non_primitive(int t);
369 void next() { 363 void next() {
370 symbolOop sig = _signature(); 364 Symbol* sig = _signature;
371 int len = sig->utf8_length(); 365 int len = sig->utf8_length();
372 if (_end >= len) { 366 if (_end >= len) {
373 _end = len + 1; 367 _end = len + 1;
374 return; 368 return;
375 } 369 }
390 return; 384 return;
391 } 385 }
392 _end++; 386 _end++;
393 } 387 }
394 388
395 SignatureStream(symbolHandle signature, 389 SignatureStream(Symbol* signature, bool is_method = true);
396 bool is_method = true) : 390 ~SignatureStream();
397 _signature(signature), _at_return_type(false) {
398 _begin = _end = (is_method ? 1 : 0); // skip first '(' in method signatures
399 next();
400 }
401 391
402 bool is_object() const; // True if this argument is an object 392 bool is_object() const; // True if this argument is an object
403 bool is_array() const; // True if this argument is an array 393 bool is_array() const; // True if this argument is an array
404 BasicType type() const { return _type; } 394 BasicType type() const { return _type; }
405 symbolOop as_symbol(TRAPS); 395 Symbol* as_symbol(TRAPS);
406 enum FailureMode { ReturnNull, CNFException, NCDFError }; 396 enum FailureMode { ReturnNull, CNFException, NCDFError };
407 klassOop as_klass(Handle class_loader, Handle protection_domain, FailureMode failure_mode, TRAPS); 397 klassOop as_klass(Handle class_loader, Handle protection_domain, FailureMode failure_mode, TRAPS);
408 oop as_java_mirror(Handle class_loader, Handle protection_domain, FailureMode failure_mode, TRAPS); 398 oop as_java_mirror(Handle class_loader, Handle protection_domain, FailureMode failure_mode, TRAPS);
409 399
410 // return same as_symbol except allocation of new symbols is avoided. 400 // return same as_symbol except allocation of new symbols is avoided.
411 symbolOop as_symbol_or_null(); 401 Symbol* as_symbol_or_null();
412 }; 402 };
413 403
414 class SignatureVerifier : public StackObj { 404 class SignatureVerifier : public StackObj {
415 public: 405 public:
416 // Returns true if the symbol is valid method or type signature 406 // Returns true if the symbol is valid method or type signature
417 static bool is_valid_signature(symbolHandle sig); 407 static bool is_valid_signature(Symbol* sig);
418 408
419 static bool is_valid_method_signature(symbolHandle sig); 409 static bool is_valid_method_signature(Symbol* sig);
420 static bool is_valid_type_signature(symbolHandle sig); 410 static bool is_valid_type_signature(Symbol* sig);
421 private: 411 private:
422 412
423 static ssize_t is_valid_type(const char*, ssize_t); 413 static ssize_t is_valid_type(const char*, ssize_t);
424 static bool invalid_name_char(char); 414 static bool invalid_name_char(char);
425 }; 415 };