jdk8-mips64-public/hotspot: comparison src/share/vm/oops/methodOop.cpp

-:27e4ea99855d
+:3582bf76420e
 #include "memory/oopFactory.hpp"
 #include "oops/klassOop.hpp"
 #include "oops/methodDataOop.hpp"
 #include "oops/methodOop.hpp"
 #include "oops/oop.inline.hpp"
-#include "oops/symbolOop.hpp"
+#include "oops/symbol.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "prims/methodHandleWalk.hpp"
 #include "prims/nativeLookup.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/compilationPolicy.hpp"
 char* methodOopDesc::name_and_sig_as_C_string(char* buf, int size) {
 return name_and_sig_as_C_string(Klass::cast(constants()->pool_holder()), name(), signature(), buf, size);
 }
-char* methodOopDesc::name_and_sig_as_C_string(Klass* klass, symbolOop method_name, symbolOop signature) {
+char* methodOopDesc::name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature) {
 const char* klass_name = klass->external_name();
 int klass_name_len  = (int)strlen(klass_name);
 int method_name_len = method_name->utf8_length();
 int len             = klass_name_len + 1 + method_name_len + signature->utf8_length();
 char* dest          = NEW_RESOURCE_ARRAY(char, len + 1);
 strcpy(&dest[klass_name_len + 1 + method_name_len], signature->as_C_string());
 dest[len] = 0;
 return dest;
 }
-char* methodOopDesc::name_and_sig_as_C_string(Klass* klass, symbolOop method_name, symbolOop signature, char* buf, int size) {
+char* methodOopDesc::name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature, char* buf, int size) {
-symbolOop klass_name = klass->name();
+Symbol* klass_name = klass->name();
 klass_name->as_klass_external_name(buf, size);
 int len = (int)strlen(buf);
 if (len < size - 1) {
 buf[len++] = '.';
 int extra_words = align_size_up(extra_bytes, BytesPerWord) / BytesPerWord;
 return align_object_size(header_size() + extra_words);
 }
-symbolOop methodOopDesc::klass_name() const {
+Symbol* methodOopDesc::klass_name() const {
 klassOop k = method_holder();
 assert(k->is_klass(), "must be klass");
 instanceKlass* ik = (instanceKlass*) k->klass_part();
 return ik->name();
 }
 return extra_stack_entries() * Interpreter::stackElementSize;
 }
 void methodOopDesc::compute_size_of_parameters(Thread *thread) {
-symbolHandle h_signature(thread, signature());
+ArgumentSizeComputer asc(signature());
-ArgumentSizeComputer asc(h_signature);
 set_size_of_parameters(asc.size() + (is_static() ? 0 : 1));
 }
 #ifdef CC_INTERP
 void methodOopDesc::set_result_index(BasicType type)          {
 bool methodOopDesc::is_klass_loaded_by_klass_index(int klass_index) const {
 if( _constants->tag_at(klass_index).is_unresolved_klass() ) {
 Thread *thread = Thread::current();
-symbolHandle klass_name(thread, _constants->klass_name_at(klass_index));
+Symbol* klass_name = _constants->klass_name_at(klass_index);
 Handle loader(thread, instanceKlass::cast(method_holder())->class_loader());
 Handle prot  (thread, Klass::cast(method_holder())->protection_domain());
 return SystemDictionary::find(klass_name, loader, prot, thread) != NULL;
 } else {
 return true;
 }
 // Constant pool structure for invoke methods:
 enum {
 _imcp_invoke_name = 1,        // utf8: 'invokeExact' or 'invokeGeneric'
-_imcp_invoke_signature,       // utf8: (variable symbolOop)
+_imcp_invoke_signature,       // utf8: (variable Symbol*)
 _imcp_method_type_value,      // string: (variable java/dyn/MethodType, sic)
 _imcp_limit
 };
 oop methodOopDesc::method_handle_type() const {
 return false;
 }
 }
 methodHandle methodOopDesc::make_invoke_method(KlassHandle holder,
-symbolHandle name,
+Symbol* name,
-symbolHandle signature,
+Symbol* signature,
 Handle method_type, TRAPS) {
 methodHandle empty;
 assert(holder() == SystemDictionary::MethodHandle_klass(),
 "must be a JSR 292 magic type");
 constantPoolHandle cp;
 {
 constantPoolOop cp_oop = oopFactory::new_constantPool(_imcp_limit, IsSafeConc, CHECK_(empty));
 cp = constantPoolHandle(THREAD, cp_oop);
 }
-cp->symbol_at_put(_imcp_invoke_name,       name());
+cp->symbol_at_put(_imcp_invoke_name,       name);
-cp->symbol_at_put(_imcp_invoke_signature,  signature());
+cp->symbol_at_put(_imcp_invoke_signature,  signature);
-cp->string_at_put(_imcp_method_type_value, vmSymbols::void_signature());
+cp->string_at_put(_imcp_method_type_value, Universe::the_null_string());
 cp->set_pool_holder(holder());
 // set up the fancy stuff:
 cp->pseudo_string_at_put(_imcp_method_type_value, method_type());
 methodHandle m;
 }
 m->set_constants(cp());
 m->set_name_index(_imcp_invoke_name);
 m->set_signature_index(_imcp_invoke_signature);
 assert(is_method_handle_invoke_name(m->name()), "");
-assert(m->signature() == signature(), "");
+assert(m->signature() == signature, "");
 assert(m->is_method_handle_invoke(), "");
 #ifdef CC_INTERP
 ResultTypeFinder rtf(signature());
 m->set_result_index(rtf.type());
 #endif
 // because we are not loading from core libraries
 if (instanceKlass::cast(holder)->class_loader() != NULL)
 return vmSymbols::NO_SID;   // regardless of name, no intrinsics here
 // see if the klass name is well-known:
-symbolOop klass_name = instanceKlass::cast(holder)->name();
+Symbol* klass_name = instanceKlass::cast(holder)->name();
 return vmSymbols::find_sid(klass_name);
 }
 void methodOopDesc::init_intrinsic_id() {
 assert(_intrinsic_id == vmIntrinsics::_none, "do this just once");
 // These two methods are static since a GC may move the methodOopDesc
 bool methodOopDesc::load_signature_classes(methodHandle m, TRAPS) {
 bool sig_is_loaded = true;
 Handle class_loader(THREAD, instanceKlass::cast(m->method_holder())->class_loader());
 Handle protection_domain(THREAD, Klass::cast(m->method_holder())->protection_domain());
-symbolHandle signature(THREAD, m->signature());
+ResourceMark rm(THREAD);
+Symbol*  signature = m->signature();
 for(SignatureStream ss(signature); !ss.is_done(); ss.next()) {
 if (ss.is_object()) {
-symbolOop sym = ss.as_symbol(CHECK_(false));
+Symbol* sym = ss.as_symbol(CHECK_(false));
-symbolHandle name (THREAD, sym);
+Symbol*  name  = sym;
 klassOop klass = SystemDictionary::resolve_or_null(name, class_loader,
 protection_domain, THREAD);
 // We are loading classes eagerly. If a ClassNotFoundException or
 // a LinkageError was generated, be sure to ignore it.
 if (HAS_PENDING_EXCEPTION) {
 }
 bool methodOopDesc::has_unloaded_classes_in_signature(methodHandle m, TRAPS) {
 Handle class_loader(THREAD, instanceKlass::cast(m->method_holder())->class_loader());
 Handle protection_domain(THREAD, Klass::cast(m->method_holder())->protection_domain());
-symbolHandle signature(THREAD, m->signature());
+ResourceMark rm(THREAD);
+Symbol*  signature = m->signature();
 for(SignatureStream ss(signature); !ss.is_done(); ss.next()) {
 if (ss.type() == T_OBJECT) {
-symbolHandle name(THREAD, ss.as_symbol_or_null());
+Symbol* name = ss.as_symbol_or_null();
-if (name() == NULL) return true;
+if (name == NULL) return true;
 klassOop klass = SystemDictionary::find(name, class_loader, protection_domain, THREAD);
 if (klass == NULL) return true;
 }
 }
 return false;
 _st->print(name);
 _use_separator = true;
 }
 public:
-SignatureTypePrinter(symbolHandle signature, outputStream* st) : SignatureTypeNames(signature) {
+SignatureTypePrinter(Symbol* signature, outputStream* st) : SignatureTypeNames(signature) {
 _st = st;
 _use_separator = false;
 }
 void print_parameters()              { _use_separator = false; iterate_parameters(); }

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/oops/methodOop.cpp

src/share/vm/oops/methodOop.cpp