graal-compiler: src/share/vm/ci/ciMethod.cpp comparison

comparison src/share/vm/ci/ciMethod.cpp @ 6275:957c266d8bc5

Merge with http://hg.openjdk.java.net/hsx/hsx24/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Tue, 21 Aug 2012 10:39:19 +0200
parents	597bc897257d 1d7922586cf6
children	c38f13903fdf

comparison

equal deleted inserted replaced

-:fd8832ae511d
+:957c266d8bc5
 /*
-* Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 // Easy to compute, so fill them in now.
 _max_stack          = h_m()->max_stack();
 _max_locals         = h_m()->max_locals();
 _code_size          = h_m()->code_size();
 _intrinsic_id       = h_m()->intrinsic_id();
-_handler_count      = h_m()->exception_table()->length() / 4;
+_handler_count      = h_m()->exception_table_length();
 _uses_monitors      = h_m()->access_flags().has_monitor_bytecodes();
 _balanced_monitors  = !_uses_monitors || h_m()->access_flags().is_monitor_matching();
 _is_c1_compilable   = !h_m()->is_not_c1_compilable();
 _is_c2_compilable   = !h_m()->is_not_c2_compilable();
 // Lazy fields, filled in on demand.  Require allocation.
 }
 }
 }
 // And load the exception table.
-typeArrayOop exc_table = me->exception_table();
+ExceptionTable exc_table(me);
 // Allocate one extra spot in our list of exceptions.  This
 // last entry will be used to represent the possibility that
 // an exception escapes the method.  See ciExceptionHandlerStream
 // for details.
 _exception_handlers =
 (ciExceptionHandler**)arena->Amalloc(sizeof(ciExceptionHandler*)
 * (_handler_count + 1));
 if (_handler_count > 0) {
 for (int i=0; i<_handler_count; i++) {
-int base = i*4;
 _exception_handlers[i] = new (arena) ciExceptionHandler(
 holder(),
-/* start    */      exc_table->int_at(base),
+/* start    */      exc_table.start_pc(i),
-/* limit    */      exc_table->int_at(base+1),
+/* limit    */      exc_table.end_pc(i),
-/* goto pc  */      exc_table->int_at(base+2),
+/* goto pc  */      exc_table.handler_pc(i),
-/* cp index */      exc_table->int_at(base+3));
+/* cp index */      exc_table.catch_type_index(i));
 }
 }
 // Put an entry at the end of our list to represent the possibility
 // of exceptional exit.
 // ------------------------------------------------------------------
 // invokedynamic support
 // ------------------------------------------------------------------
-// ciMethod::is_method_handle_invoke
+// ciMethod::is_method_handle_intrinsic
 //
-// Return true if the method is an instance of one of the two
+// Return true if the method is an instance of the JVM-generated
-// signature-polymorphic MethodHandle methods, invokeExact or invokeGeneric.
+// signature-polymorphic MethodHandle methods, _invokeBasic, _linkToVirtual, etc.
-bool ciMethod::is_method_handle_invoke() const {
+bool ciMethod::is_method_handle_intrinsic() const {
-if (!is_loaded()) {
+vmIntrinsics::ID iid = _intrinsic_id;  // do not check if loaded
-bool flag = (holder()->name() == ciSymbol::java_lang_invoke_MethodHandle() &&
+return (MethodHandles::is_signature_polymorphic(iid) &&
-methodOopDesc::is_method_handle_invoke_name(name()->sid()));
+MethodHandles::is_signature_polymorphic_intrinsic(iid));
-return flag;
+}
-}
-VM_ENTRY_MARK;
+// ------------------------------------------------------------------
-return get_methodOop()->is_method_handle_invoke();
+// ciMethod::is_compiled_lambda_form
-}
-// ------------------------------------------------------------------
-// ciMethod::is_method_handle_adapter
 //
 // Return true if the method is a generated MethodHandle adapter.
-// These are built by MethodHandleCompiler.
+// These are built by Java code.
-bool ciMethod::is_method_handle_adapter() const {
+bool ciMethod::is_compiled_lambda_form() const {
-if (!is_loaded())  return false;
+vmIntrinsics::ID iid = _intrinsic_id;  // do not check if loaded
-VM_ENTRY_MARK;
+return iid == vmIntrinsics::_compiledLambdaForm;
-return get_methodOop()->is_method_handle_adapter();
+}
-}
+// ------------------------------------------------------------------
-ciInstance* ciMethod::method_handle_type() {
+// ciMethod::has_member_arg
-check_is_loaded();
+//
-VM_ENTRY_MARK;
+// Return true if the method is a linker intrinsic like _linkToVirtual.
-oop mtype = get_methodOop()->method_handle_type();
+// These are built by the JVM.
-return CURRENT_THREAD_ENV->get_object(mtype)->as_instance();
+bool ciMethod::has_member_arg() const {
-}
+vmIntrinsics::ID iid = _intrinsic_id;  // do not check if loaded
+return (MethodHandles::is_signature_polymorphic(iid) &&
+MethodHandles::has_member_arg(iid));
+}
 // ------------------------------------------------------------------
 // ciMethod::ensure_method_data
 //
 // Generate new methodDataOop objects at compile time.
 }
 // ------------------------------------------------------------------
 // ciMethod::code_size_for_inlining
 //
-// Code size for inlining decisions.
+// Code size for inlining decisions.  This method returns a code
-//
+// size of 1 for methods which has the ForceInline annotation.
-// Don't fully count method handle adapters against inlining budgets:
-// the metric we use here is the number of call sites in the adapter
-// as they are probably the instructions which generate some code.
 int ciMethod::code_size_for_inlining() {
 check_is_loaded();
+if (get_methodOop()->force_inline()) {
-// Method handle adapters
+return 1;
-if (is_method_handle_adapter()) {
+}
-// Count call sites
-int call_site_count = 0;
-ciBytecodeStream iter(this);
-while (iter.next() != ciBytecodeStream::EOBC()) {
-if (Bytecodes::is_invoke(iter.cur_bc())) {
-call_site_count++;
-}
-}
-return call_site_count;
-}
-// Normal method
 return code_size();
 }
 // ------------------------------------------------------------------
 // ciMethod::instructions_size
 EXCEPTION_MARK;
 HandleMark hm(THREAD);
 constantPoolHandle pool (THREAD, get_methodOop()->constants());
 methodHandle spec_method;
 KlassHandle  spec_klass;
-LinkResolver::resolve_method(spec_method, spec_klass, pool, refinfo_index, THREAD);
+Bytecodes::Code code = (is_static ? Bytecodes::_invokestatic : Bytecodes::_invokevirtual);
+LinkResolver::resolve_method_statically(spec_method, spec_klass, code, pool, refinfo_index, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
 return false;
 } else {
 return (spec_method->is_static() == is_static);
 // ------------------------------------------------------------------
 // ciMethod::print_short_name
 //
 // Print the name of this method, without signature.
 void ciMethod::print_short_name(outputStream* st) {
-check_is_loaded();
+if (is_loaded()) {
-GUARDED_VM_ENTRY(get_methodOop()->print_short_name(st);)
+GUARDED_VM_ENTRY(get_methodOop()->print_short_name(st););
+} else {
+// Fall back if method is not loaded.
+holder()->print_name_on(st);
+st->print("::");
+name()->print_symbol_on(st);
+if (WizardMode)
+signature()->as_symbol()->print_symbol_on(st);
+}
 }
 // ------------------------------------------------------------------
 // ciMethod::print_impl
 //
 name()->print_symbol_on(st);
 st->print(" holder=");
 holder()->print_name_on(st);
 st->print(" signature=");
 signature()->as_symbol()->print_symbol_on(st);
+st->print(" arg_size=%d", arg_size());
 if (is_loaded()) {
 st->print(" loaded=true flags=");
 flags().print_member_flags(st);
 } else {
 st->print(" loaded=false");

Mercurial > hg > graal-compiler

comparison src/share/vm/ci/ciMethod.cpp @ 6275:957c266d8bc5