jdk8-mips64-public/hotspot: src/share/vm/ci/ciMethod.cpp@bd7a7ce2e264

6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com

     1 /*

     2  * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    25 #include "precompiled.hpp"

    26 #include "ci/ciCallProfile.hpp"

    27 #include "ci/ciExceptionHandler.hpp"

    28 #include "ci/ciInstanceKlass.hpp"

    29 #include "ci/ciMethod.hpp"

    30 #include "ci/ciMethodBlocks.hpp"

    31 #include "ci/ciMethodData.hpp"

    32 #include "ci/ciStreams.hpp"

    33 #include "ci/ciSymbol.hpp"

    34 #include "ci/ciReplay.hpp"

    35 #include "ci/ciUtilities.hpp"

    36 #include "classfile/systemDictionary.hpp"

    37 #include "compiler/abstractCompiler.hpp"

    38 #include "compiler/compilerOracle.hpp"

    39 #include "compiler/methodLiveness.hpp"

    40 #include "interpreter/interpreter.hpp"

    41 #include "interpreter/linkResolver.hpp"

    42 #include "interpreter/oopMapCache.hpp"

    43 #include "memory/allocation.inline.hpp"

    44 #include "memory/resourceArea.hpp"

    45 #include "oops/generateOopMap.hpp"

    46 #include "oops/oop.inline.hpp"

    47 #include "prims/nativeLookup.hpp"

    48 #include "runtime/deoptimization.hpp"

    49 #include "utilities/bitMap.inline.hpp"

    50 #include "utilities/xmlstream.hpp"

    51 #ifdef COMPILER2

    52 #include "ci/bcEscapeAnalyzer.hpp"

    53 #include "ci/ciTypeFlow.hpp"

    54 #include "oops/method.hpp"

    55 #endif

    56 #ifdef SHARK

    57 #include "ci/ciTypeFlow.hpp"

    58 #include "oops/method.hpp"

    59 #endif

    61 // ciMethod

    62 //

    63 // This class represents a Method* in the HotSpot virtual

    64 // machine.

    67 // ------------------------------------------------------------------

    68 // ciMethod::ciMethod

    69 //

    70 // Loaded method.

    71 ciMethod::ciMethod(methodHandle h_m) : ciMetadata(h_m()) {

    72   assert(h_m() != NULL, "no null method");

    74   // These fields are always filled in in loaded methods.

    75   _flags = ciFlags(h_m()->access_flags());

    77   // Easy to compute, so fill them in now.

    78   _max_stack          = h_m()->max_stack();

    79   _max_locals         = h_m()->max_locals();

    80   _code_size          = h_m()->code_size();

    81   _intrinsic_id       = h_m()->intrinsic_id();

    82   _handler_count      = h_m()->exception_table_length();

    83   _uses_monitors      = h_m()->access_flags().has_monitor_bytecodes();

    84   _balanced_monitors  = !_uses_monitors || h_m()->access_flags().is_monitor_matching();

    85   _is_c1_compilable   = !h_m()->is_not_c1_compilable();

    86   _is_c2_compilable   = !h_m()->is_not_c2_compilable();

    87   // Lazy fields, filled in on demand.  Require allocation.

    88   _code               = NULL;

    89   _exception_handlers = NULL;

    90   _liveness           = NULL;

    91   _method_blocks = NULL;

    92 #if defined(COMPILER2) || defined(SHARK)

    93   _flow               = NULL;

    94   _bcea               = NULL;

    95 #endif // COMPILER2 || SHARK

    97   ciEnv *env = CURRENT_ENV;

    98   if (env->jvmti_can_hotswap_or_post_breakpoint() && can_be_compiled()) {

    99     // 6328518 check hotswap conditions under the right lock.

   100     MutexLocker locker(Compile_lock);

   101     if (Dependencies::check_evol_method(h_m()) != NULL) {

   102       _is_c1_compilable = false;

   103       _is_c2_compilable = false;

   104     }

   105   } else {

   106     CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());

   107   }

   109   if (h_m()->method_holder()->is_linked()) {

   110     _can_be_statically_bound = h_m()->can_be_statically_bound();

   111   } else {

   112     // Have to use a conservative value in this case.

   113     _can_be_statically_bound = false;

   114   }

   116   // Adjust the definition of this condition to be more useful:

   117   // %%% take these conditions into account in vtable generation

   118   if (!_can_be_statically_bound && h_m()->is_private())

   119     _can_be_statically_bound = true;

   120   if (_can_be_statically_bound && h_m()->is_abstract())

   121     _can_be_statically_bound = false;

   123   // generating _signature may allow GC and therefore move m.

   124   // These fields are always filled in.

   125   _name = env->get_symbol(h_m()->name());

   126   _holder = env->get_instance_klass(h_m()->method_holder());

   127   ciSymbol* sig_symbol = env->get_symbol(h_m()->signature());

   128   constantPoolHandle cpool = h_m()->constants();

   129   _signature = new (env->arena()) ciSignature(_holder, cpool, sig_symbol);

   130   _method_data = NULL;

   131   // Take a snapshot of these values, so they will be commensurate with the MDO.

   132   if (ProfileInterpreter || TieredCompilation) {

   133     int invcnt = h_m()->interpreter_invocation_count();

   134     // if the value overflowed report it as max int

   135     _interpreter_invocation_count = invcnt < 0 ? max_jint : invcnt ;

   136     _interpreter_throwout_count   = h_m()->interpreter_throwout_count();

   137   } else {

   138     _interpreter_invocation_count = 0;

   139     _interpreter_throwout_count = 0;

   140   }

   141   if (_interpreter_invocation_count == 0)

   142     _interpreter_invocation_count = 1;

   143   _instructions_size = -1;

   144 #ifdef ASSERT

   145   if (ReplayCompiles) {

   146     ciReplay::initialize(this);

   147   }

   148 #endif

   149 }

   152 // ------------------------------------------------------------------

   153 // ciMethod::ciMethod

   154 //

   155 // Unloaded method.

   156 ciMethod::ciMethod(ciInstanceKlass* holder,

   157                    ciSymbol*        name,

   158                    ciSymbol*        signature,

   159                    ciInstanceKlass* accessor) :

   160   ciMetadata((Metadata*)NULL),

   161   _name(                   name),

   162   _holder(                 holder),

   163   _intrinsic_id(           vmIntrinsics::_none),

   164   _liveness(               NULL),

   165   _can_be_statically_bound(false),

   166   _method_blocks(          NULL),

   167   _method_data(            NULL)

   168 #if defined(COMPILER2) || defined(SHARK)

   169   ,

   170   _flow(                   NULL),

   171   _bcea(                   NULL),

   172   _instructions_size(-1)

   173 #endif // COMPILER2 || SHARK

   174 {

   175   // Usually holder and accessor are the same type but in some cases

   176   // the holder has the wrong class loader (e.g. invokedynamic call

   177   // sites) so we pass the accessor.

   178   _signature = new (CURRENT_ENV->arena()) ciSignature(accessor, constantPoolHandle(), signature);

   179 }

   182 // ------------------------------------------------------------------

   183 // ciMethod::load_code

   184 //

   185 // Load the bytecodes and exception handler table for this method.

   186 void ciMethod::load_code() {

   187   VM_ENTRY_MARK;

   188   assert(is_loaded(), "only loaded methods have code");

   190   Method* me = get_Method();

   191   Arena* arena = CURRENT_THREAD_ENV->arena();

   193   // Load the bytecodes.

   194   _code = (address)arena->Amalloc(code_size());

   195   memcpy(_code, me->code_base(), code_size());

   197   // Revert any breakpoint bytecodes in ci's copy

   198   if (me->number_of_breakpoints() > 0) {

   199     BreakpointInfo* bp = me->method_holder()->breakpoints();

   200     for (; bp != NULL; bp = bp->next()) {

   201       if (bp->match(me)) {

   202         code_at_put(bp->bci(), bp->orig_bytecode());

   203       }

   204     }

   205   }

   207   // And load the exception table.

   208   ExceptionTable exc_table(me);

   210   // Allocate one extra spot in our list of exceptions.  This

   211   // last entry will be used to represent the possibility that

   212   // an exception escapes the method.  See ciExceptionHandlerStream

   213   // for details.

   214   _exception_handlers =

   215     (ciExceptionHandler**)arena->Amalloc(sizeof(ciExceptionHandler*)

   216                                          * (_handler_count + 1));

   217   if (_handler_count > 0) {

   218     for (int i=0; i<_handler_count; i++) {

   219       _exception_handlers[i] = new (arena) ciExceptionHandler(

   220                                 holder(),

   221             /* start    */      exc_table.start_pc(i),

   222             /* limit    */      exc_table.end_pc(i),

   223             /* goto pc  */      exc_table.handler_pc(i),

   224             /* cp index */      exc_table.catch_type_index(i));

   225     }

   226   }

   228   // Put an entry at the end of our list to represent the possibility

   229   // of exceptional exit.

   230   _exception_handlers[_handler_count] =

   231     new (arena) ciExceptionHandler(holder(), 0, code_size(), -1, 0);

   233   if (CIPrintMethodCodes) {

   234     print_codes();

   235   }

   236 }

   239 // ------------------------------------------------------------------

   240 // ciMethod::has_linenumber_table

   241 //

   242 // length unknown until decompression

   243 bool    ciMethod::has_linenumber_table() const {

   244   check_is_loaded();

   245   VM_ENTRY_MARK;

   246   return get_Method()->has_linenumber_table();

   247 }

   250 // ------------------------------------------------------------------

   251 // ciMethod::compressed_linenumber_table

   252 u_char* ciMethod::compressed_linenumber_table() const {

   253   check_is_loaded();

   254   VM_ENTRY_MARK;

   255   return get_Method()->compressed_linenumber_table();

   256 }

   259 // ------------------------------------------------------------------

   260 // ciMethod::line_number_from_bci

   261 int ciMethod::line_number_from_bci(int bci) const {

   262   check_is_loaded();

   263   VM_ENTRY_MARK;

   264   return get_Method()->line_number_from_bci(bci);

   265 }

   268 // ------------------------------------------------------------------

   269 // ciMethod::vtable_index

   270 //

   271 // Get the position of this method's entry in the vtable, if any.

   272 int ciMethod::vtable_index() {

   273   check_is_loaded();

   274   assert(holder()->is_linked(), "must be linked");

   275   VM_ENTRY_MARK;

   276   return get_Method()->vtable_index();

   277 }

   280 #ifdef SHARK

   281 // ------------------------------------------------------------------

   282 // ciMethod::itable_index

   283 //

   284 // Get the position of this method's entry in the itable, if any.

   285 int ciMethod::itable_index() {

   286   check_is_loaded();

   287   assert(holder()->is_linked(), "must be linked");

   288   VM_ENTRY_MARK;

   289   return klassItable::compute_itable_index(get_Method());

   290 }

   291 #endif // SHARK

   294 // ------------------------------------------------------------------

   295 // ciMethod::native_entry

   296 //

   297 // Get the address of this method's native code, if any.

   298 address ciMethod::native_entry() {

   299   check_is_loaded();

   300   assert(flags().is_native(), "must be native method");

   301   VM_ENTRY_MARK;

   302   Method* method = get_Method();

   303   address entry = method->native_function();

   304   assert(entry != NULL, "must be valid entry point");

   305   return entry;

   306 }

   309 // ------------------------------------------------------------------

   310 // ciMethod::interpreter_entry

   311 //

   312 // Get the entry point for running this method in the interpreter.

   313 address ciMethod::interpreter_entry() {

   314   check_is_loaded();

   315   VM_ENTRY_MARK;

   316   methodHandle mh(THREAD, get_Method());

   317   return Interpreter::entry_for_method(mh);

   318 }

   321 // ------------------------------------------------------------------

   322 // ciMethod::uses_balanced_monitors

   323 //

   324 // Does this method use monitors in a strict stack-disciplined manner?

   325 bool ciMethod::has_balanced_monitors() {

   326   check_is_loaded();

   327   if (_balanced_monitors) return true;

   329   // Analyze the method to see if monitors are used properly.

   330   VM_ENTRY_MARK;

   331   methodHandle method(THREAD, get_Method());

   332   assert(method->has_monitor_bytecodes(), "should have checked this");

   334   // Check to see if a previous compilation computed the

   335   // monitor-matching analysis.

   336   if (method->guaranteed_monitor_matching()) {

   337     _balanced_monitors = true;

   338     return true;

   339   }

   341   {

   342     EXCEPTION_MARK;

   343     ResourceMark rm(THREAD);

   344     GeneratePairingInfo gpi(method);

   345     gpi.compute_map(CATCH);

   346     if (!gpi.monitor_safe()) {

   347       return false;

   348     }

   349     method->set_guaranteed_monitor_matching();

   350     _balanced_monitors = true;

   351   }

   352   return true;

   353 }

   356 // ------------------------------------------------------------------

   357 // ciMethod::get_flow_analysis

   358 ciTypeFlow* ciMethod::get_flow_analysis() {

   359 #if defined(COMPILER2) || defined(SHARK)

   360   if (_flow == NULL) {

   361     ciEnv* env = CURRENT_ENV;

   362     _flow = new (env->arena()) ciTypeFlow(env, this);

   363     _flow->do_flow();

   364   }

   365   return _flow;

   366 #else // COMPILER2 || SHARK

   367   ShouldNotReachHere();

   368   return NULL;

   369 #endif // COMPILER2 || SHARK

   370 }

   373 // ------------------------------------------------------------------

   374 // ciMethod::get_osr_flow_analysis

   375 ciTypeFlow* ciMethod::get_osr_flow_analysis(int osr_bci) {

   376 #if defined(COMPILER2) || defined(SHARK)

   377   // OSR entry points are always place after a call bytecode of some sort

   378   assert(osr_bci >= 0, "must supply valid OSR entry point");

   379   ciEnv* env = CURRENT_ENV;

   380   ciTypeFlow* flow = new (env->arena()) ciTypeFlow(env, this, osr_bci);

   381   flow->do_flow();

   382   return flow;

   383 #else // COMPILER2 || SHARK

   384   ShouldNotReachHere();

   385   return NULL;

   386 #endif // COMPILER2 || SHARK

   387 }

   389 // ------------------------------------------------------------------

   390 // ciMethod::raw_liveness_at_bci

   391 //

   392 // Which local variables are live at a specific bci?

   393 MethodLivenessResult ciMethod::raw_liveness_at_bci(int bci) {

   394   check_is_loaded();

   395   if (_liveness == NULL) {

   396     // Create the liveness analyzer.

   397     Arena* arena = CURRENT_ENV->arena();

   398     _liveness = new (arena) MethodLiveness(arena, this);

   399     _liveness->compute_liveness();

   400   }

   401   return _liveness->get_liveness_at(bci);

   402 }

   404 // ------------------------------------------------------------------

   405 // ciMethod::liveness_at_bci

   406 //

   407 // Which local variables are live at a specific bci?  When debugging

   408 // will return true for all locals in some cases to improve debug

   409 // information.

   410 MethodLivenessResult ciMethod::liveness_at_bci(int bci) {

   411   MethodLivenessResult result = raw_liveness_at_bci(bci);

   412   if (CURRENT_ENV->jvmti_can_access_local_variables() || DeoptimizeALot || CompileTheWorld) {

   413     // Keep all locals live for the user's edification and amusement.

   414     result.at_put_range(0, result.size(), true);

   415   }

   416   return result;

   417 }

   419 // ciMethod::live_local_oops_at_bci

   420 //

   421 // find all the live oops in the locals array for a particular bci

   422 // Compute what the interpreter believes by using the interpreter

   423 // oopmap generator. This is used as a double check during osr to

   424 // guard against conservative result from MethodLiveness making us

   425 // think a dead oop is live.  MethodLiveness is conservative in the

   426 // sense that it may consider locals to be live which cannot be live,

   427 // like in the case where a local could contain an oop or  a primitive

   428 // along different paths.  In that case the local must be dead when

   429 // those paths merge. Since the interpreter's viewpoint is used when

   430 // gc'ing an interpreter frame we need to use its viewpoint  during

   431 // OSR when loading the locals.

   433 BitMap ciMethod::live_local_oops_at_bci(int bci) {

   434   VM_ENTRY_MARK;

   435   InterpreterOopMap mask;

   436   OopMapCache::compute_one_oop_map(get_Method(), bci, &mask);

   437   int mask_size = max_locals();

   438   BitMap result(mask_size);

   439   result.clear();

   440   int i;

   441   for (i = 0; i < mask_size ; i++ ) {

   442     if (mask.is_oop(i)) result.set_bit(i);

   443   }

   444   return result;

   445 }

   448 #ifdef COMPILER1

   449 // ------------------------------------------------------------------

   450 // ciMethod::bci_block_start

   451 //

   452 // Marks all bcis where a new basic block starts

   453 const BitMap ciMethod::bci_block_start() {

   454   check_is_loaded();

   455   if (_liveness == NULL) {

   456     // Create the liveness analyzer.

   457     Arena* arena = CURRENT_ENV->arena();

   458     _liveness = new (arena) MethodLiveness(arena, this);

   459     _liveness->compute_liveness();

   460   }

   462   return _liveness->get_bci_block_start();

   463 }

   464 #endif // COMPILER1

   467 // ------------------------------------------------------------------

   468 // ciMethod::call_profile_at_bci

   469 //

   470 // Get the ciCallProfile for the invocation of this method.

   471 // Also reports receiver types for non-call type checks (if TypeProfileCasts).

   472 ciCallProfile ciMethod::call_profile_at_bci(int bci) {

   473   ResourceMark rm;

   474   ciCallProfile result;

   475   if (method_data() != NULL && method_data()->is_mature()) {

   476     ciProfileData* data = method_data()->bci_to_data(bci);

   477     if (data != NULL && data->is_CounterData()) {

   478       // Every profiled call site has a counter.

   479       int count = data->as_CounterData()->count();

   481       if (!data->is_ReceiverTypeData()) {

   482         result._receiver_count[0] = 0;  // that's a definite zero

   483       } else { // ReceiverTypeData is a subclass of CounterData

   484         ciReceiverTypeData* call = (ciReceiverTypeData*)data->as_ReceiverTypeData();

   485         // In addition, virtual call sites have receiver type information

   486         int receivers_count_total = 0;

   487         int morphism = 0;

   488         // Precompute morphism for the possible fixup

   489         for (uint i = 0; i < call->row_limit(); i++) {

   490           ciKlass* receiver = call->receiver(i);

   491           if (receiver == NULL)  continue;

   492           morphism++;

   493         }

   494         int epsilon = 0;

   495         if (TieredCompilation && ProfileInterpreter) {

   496           // Interpreter and C1 treat final and special invokes differently.

   497           // C1 will record a type, whereas the interpreter will just

   498           // increment the count. Detect this case.

   499           if (morphism == 1 && count > 0) {

   500             epsilon = count;

   501             count = 0;

   502           }

   503         }

   504         for (uint i = 0; i < call->row_limit(); i++) {

   505           ciKlass* receiver = call->receiver(i);

   506           if (receiver == NULL)  continue;

   507           int rcount = call->receiver_count(i) + epsilon;

   508           if (rcount == 0) rcount = 1; // Should be valid value

   509           receivers_count_total += rcount;

   510           // Add the receiver to result data.

   511           result.add_receiver(receiver, rcount);

   512           // If we extend profiling to record methods,

   513           // we will set result._method also.

   514         }

   515         // Determine call site's morphism.

   516         // The call site count is 0 with known morphism (onlt 1 or 2 receivers)

   517         // or < 0 in the case of a type check failured for checkcast, aastore, instanceof.

   518         // The call site count is > 0 in the case of a polymorphic virtual call.

   519         if (morphism > 0 && morphism == result._limit) {

   520            // The morphism <= MorphismLimit.

   521            if ((morphism <  ciCallProfile::MorphismLimit) ||

   522                (morphism == ciCallProfile::MorphismLimit && count == 0)) {

   523 #ifdef ASSERT

   524              if (count > 0) {

   525                this->print_short_name(tty);

   526                tty->print_cr(" @ bci:%d", bci);

   527                this->print_codes();

   528                assert(false, "this call site should not be polymorphic");

   529              }

   530 #endif

   531              result._morphism = morphism;

   532            }

   533         }

   534         // Make the count consistent if this is a call profile. If count is

   535         // zero or less, presume that this is a typecheck profile and

   536         // do nothing.  Otherwise, increase count to be the sum of all

   537         // receiver's counts.

   538         if (count >= 0) {

   539           count += receivers_count_total;

   540         }

   541       }

   542       result._count = count;

   543     }

   544   }

   545   return result;

   546 }

   548 // ------------------------------------------------------------------

   549 // Add new receiver and sort data by receiver's profile count.

   550 void ciCallProfile::add_receiver(ciKlass* receiver, int receiver_count) {

   551   // Add new receiver and sort data by receiver's counts when we have space

   552   // for it otherwise replace the less called receiver (less called receiver

   553   // is placed to the last array element which is not used).

   554   // First array's element contains most called receiver.

   555   int i = _limit;

   556   for (; i > 0 && receiver_count > _receiver_count[i-1]; i--) {

   557     _receiver[i] = _receiver[i-1];

   558     _receiver_count[i] = _receiver_count[i-1];

   559   }

   560   _receiver[i] = receiver;

   561   _receiver_count[i] = receiver_count;

   562   if (_limit < MorphismLimit) _limit++;

   563 }

   565 // ------------------------------------------------------------------

   566 // ciMethod::find_monomorphic_target

   567 //

   568 // Given a certain calling environment, find the monomorphic target

   569 // for the call.  Return NULL if the call is not monomorphic in

   570 // its calling environment, or if there are only abstract methods.

   571 // The returned method is never abstract.

   572 // Note: If caller uses a non-null result, it must inform dependencies

   573 // via assert_unique_concrete_method or assert_leaf_type.

   574 ciMethod* ciMethod::find_monomorphic_target(ciInstanceKlass* caller,

   575                                             ciInstanceKlass* callee_holder,

   576                                             ciInstanceKlass* actual_recv) {

   577   check_is_loaded();

   579   if (actual_recv->is_interface()) {

   580     // %%% We cannot trust interface types, yet.  See bug 6312651.

   581     return NULL;

   582   }

   584   ciMethod* root_m = resolve_invoke(caller, actual_recv);

   585   if (root_m == NULL) {

   586     // Something went wrong looking up the actual receiver method.

   587     return NULL;

   588   }

   589   assert(!root_m->is_abstract(), "resolve_invoke promise");

   591   // Make certain quick checks even if UseCHA is false.

   593   // Is it private or final?

   594   if (root_m->can_be_statically_bound()) {

   595     return root_m;

   596   }

   598   if (actual_recv->is_leaf_type() && actual_recv == root_m->holder()) {

   599     // Easy case.  There is no other place to put a method, so don't bother

   600     // to go through the VM_ENTRY_MARK and all the rest.

   601     return root_m;

   602   }

   604   // Array methods (clone, hashCode, etc.) are always statically bound.

   605   // If we were to see an array type here, we'd return root_m.

   606   // However, this method processes only ciInstanceKlasses.  (See 4962591.)

   607   // The inline_native_clone intrinsic narrows Object to T[] properly,

   608   // so there is no need to do the same job here.

   610   if (!UseCHA)  return NULL;

   612   VM_ENTRY_MARK;

   614   methodHandle target;

   615   {

   616     MutexLocker locker(Compile_lock);

   617     Klass* context = actual_recv->get_Klass();

   618     target = Dependencies::find_unique_concrete_method(context,

   619                                                        root_m->get_Method());

   620     // %%% Should upgrade this ciMethod API to look for 1 or 2 concrete methods.

   621   }

   623 #ifndef PRODUCT

   624   if (TraceDependencies && target() != NULL && target() != root_m->get_Method()) {

   625     tty->print("found a non-root unique target method");

   626     tty->print_cr("  context = %s", InstanceKlass::cast(actual_recv->get_Klass())->external_name());

   627     tty->print("  method  = ");

   628     target->print_short_name(tty);

   629     tty->cr();

   630   }

   631 #endif //PRODUCT

   633   if (target() == NULL) {

   634     return NULL;

   635   }

   636   if (target() == root_m->get_Method()) {

   637     return root_m;

   638   }

   639   if (!root_m->is_public() &&

   640       !root_m->is_protected()) {

   641     // If we are going to reason about inheritance, it's easiest

   642     // if the method in question is public, protected, or private.

   643     // If the answer is not root_m, it is conservatively correct

   644     // to return NULL, even if the CHA encountered irrelevant

   645     // methods in other packages.

   646     // %%% TO DO: Work out logic for package-private methods

   647     // with the same name but different vtable indexes.

   648     return NULL;

   649   }

   650   return CURRENT_THREAD_ENV->get_method(target());

   651 }

   653 // ------------------------------------------------------------------

   654 // ciMethod::resolve_invoke

   655 //

   656 // Given a known receiver klass, find the target for the call.

   657 // Return NULL if the call has no target or the target is abstract.

   658 ciMethod* ciMethod::resolve_invoke(ciKlass* caller, ciKlass* exact_receiver) {

   659    check_is_loaded();

   660    VM_ENTRY_MARK;

   662    KlassHandle caller_klass (THREAD, caller->get_Klass());

   663    KlassHandle h_recv       (THREAD, exact_receiver->get_Klass());

   664    KlassHandle h_resolved   (THREAD, holder()->get_Klass());

   665    Symbol* h_name      = name()->get_symbol();

   666    Symbol* h_signature = signature()->get_symbol();

   668    methodHandle m;

   669    // Only do exact lookup if receiver klass has been linked.  Otherwise,

   670    // the vtable has not been setup, and the LinkResolver will fail.

   671    if (h_recv->oop_is_array()

   672         ||

   673        InstanceKlass::cast(h_recv())->is_linked() && !exact_receiver->is_interface()) {

   674      if (holder()->is_interface()) {

   675        m = LinkResolver::resolve_interface_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass);

   676      } else {

   677        m = LinkResolver::resolve_virtual_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass);

   678      }

   679    }

   681    if (m.is_null()) {

   682      // Return NULL only if there was a problem with lookup (uninitialized class, etc.)

   683      return NULL;

   684    }

   686    ciMethod* result = this;

   687    if (m() != get_Method()) {

   688      result = CURRENT_THREAD_ENV->get_method(m());

   689    }

   691    // Don't return abstract methods because they aren't

   692    // optimizable or interesting.

   693    if (result->is_abstract()) {

   694      return NULL;

   695    } else {

   696      return result;

   697    }

   698 }

   700 // ------------------------------------------------------------------

   701 // ciMethod::resolve_vtable_index

   702 //

   703 // Given a known receiver klass, find the vtable index for the call.

   704 // Return Method::invalid_vtable_index if the vtable_index is unknown.

   705 int ciMethod::resolve_vtable_index(ciKlass* caller, ciKlass* receiver) {

   706    check_is_loaded();

   708    int vtable_index = Method::invalid_vtable_index;

   709    // Only do lookup if receiver klass has been linked.  Otherwise,

   710    // the vtable has not been setup, and the LinkResolver will fail.

   711    if (!receiver->is_interface()

   712        && (!receiver->is_instance_klass() ||

   713            receiver->as_instance_klass()->is_linked())) {

   714      VM_ENTRY_MARK;

   716      KlassHandle caller_klass (THREAD, caller->get_Klass());

   717      KlassHandle h_recv       (THREAD, receiver->get_Klass());

   718      Symbol* h_name = name()->get_symbol();

   719      Symbol* h_signature = signature()->get_symbol();

   721      vtable_index = LinkResolver::resolve_virtual_vtable_index(h_recv, h_recv, h_name, h_signature, caller_klass);

   722      if (vtable_index == Method::nonvirtual_vtable_index) {

   723        // A statically bound method.  Return "no such index".

   724        vtable_index = Method::invalid_vtable_index;

   725      }

   726    }

   728    return vtable_index;

   729 }

   731 // ------------------------------------------------------------------

   732 // ciMethod::interpreter_call_site_count

   733 int ciMethod::interpreter_call_site_count(int bci) {

   734   if (method_data() != NULL) {

   735     ResourceMark rm;

   736     ciProfileData* data = method_data()->bci_to_data(bci);

   737     if (data != NULL && data->is_CounterData()) {

   738       return scale_count(data->as_CounterData()->count());

   739     }

   740   }

   741   return -1;  // unknown

   742 }

   744 // ------------------------------------------------------------------

   745 // Adjust a CounterData count to be commensurate with

   746 // interpreter_invocation_count.  If the MDO exists for

   747 // only 25% of the time the method exists, then the

   748 // counts in the MDO should be scaled by 4X, so that

   749 // they can be usefully and stably compared against the

   750 // invocation counts in methods.

   751 int ciMethod::scale_count(int count, float prof_factor) {

   752   if (count > 0 && method_data() != NULL) {

   753     int counter_life;

   754     int method_life = interpreter_invocation_count();

   755     if (TieredCompilation) {

   756       // In tiered the MDO's life is measured directly, so just use the snapshotted counters

   757       counter_life = MAX2(method_data()->invocation_count(), method_data()->backedge_count());

   758     } else {

   759       int current_mileage = method_data()->current_mileage();

   760       int creation_mileage = method_data()->creation_mileage();

   761       counter_life = current_mileage - creation_mileage;

   762     }

   764     // counter_life due to backedge_counter could be > method_life

   765     if (counter_life > method_life)

   766       counter_life = method_life;

   767     if (0 < counter_life && counter_life <= method_life) {

   768       count = (int)((double)count * prof_factor * method_life / counter_life + 0.5);

   769       count = (count > 0) ? count : 1;

   770     }

   771   }

   772   return count;

   773 }

   775 // ------------------------------------------------------------------

   776 // invokedynamic support

   778 // ------------------------------------------------------------------

   779 // ciMethod::is_method_handle_intrinsic

   780 //

   781 // Return true if the method is an instance of the JVM-generated

   782 // signature-polymorphic MethodHandle methods, _invokeBasic, _linkToVirtual, etc.

   783 bool ciMethod::is_method_handle_intrinsic() const {

   784   vmIntrinsics::ID iid = _intrinsic_id;  // do not check if loaded

   785   return (MethodHandles::is_signature_polymorphic(iid) &&

   786           MethodHandles::is_signature_polymorphic_intrinsic(iid));

   787 }

   789 // ------------------------------------------------------------------

   790 // ciMethod::is_compiled_lambda_form

   791 //

   792 // Return true if the method is a generated MethodHandle adapter.

   793 // These are built by Java code.

   794 bool ciMethod::is_compiled_lambda_form() const {

   795   vmIntrinsics::ID iid = _intrinsic_id;  // do not check if loaded

   796   return iid == vmIntrinsics::_compiledLambdaForm;

   797 }

   799 // ------------------------------------------------------------------

   800 // ciMethod::has_member_arg

   801 //

   802 // Return true if the method is a linker intrinsic like _linkToVirtual.

   803 // These are built by the JVM.

   804 bool ciMethod::has_member_arg() const {

   805   vmIntrinsics::ID iid = _intrinsic_id;  // do not check if loaded

   806   return (MethodHandles::is_signature_polymorphic(iid) &&

   807           MethodHandles::has_member_arg(iid));

   808 }

   810 // ------------------------------------------------------------------

   811 // ciMethod::ensure_method_data

   812 //

   813 // Generate new MethodData* objects at compile time.

   814 // Return true if allocation was successful or no MDO is required.

   815 bool ciMethod::ensure_method_data(methodHandle h_m) {

   816   EXCEPTION_CONTEXT;

   817   if (is_native() || is_abstract() || h_m()->is_accessor()) return true;

   818   if (h_m()->method_data() == NULL) {

   819     Method::build_interpreter_method_data(h_m, THREAD);

   820     if (HAS_PENDING_EXCEPTION) {

   821       CLEAR_PENDING_EXCEPTION;

   822     }

   823   }

   824   if (h_m()->method_data() != NULL) {

   825     _method_data = CURRENT_ENV->get_method_data(h_m()->method_data());

   826     _method_data->load_data();

   827     return true;

   828   } else {

   829     _method_data = CURRENT_ENV->get_empty_methodData();

   830     return false;

   831   }

   832 }

   834 // public, retroactive version

   835 bool ciMethod::ensure_method_data() {

   836   bool result = true;

   837   if (_method_data == NULL || _method_data->is_empty()) {

   838     GUARDED_VM_ENTRY({

   839       result = ensure_method_data(get_Method());

   840     });

   841   }

   842   return result;

   843 }

   846 // ------------------------------------------------------------------

   847 // ciMethod::method_data

   848 //

   849 ciMethodData* ciMethod::method_data() {

   850   if (_method_data != NULL) {

   851     return _method_data;

   852   }

   853   VM_ENTRY_MARK;

   854   ciEnv* env = CURRENT_ENV;

   855   Thread* my_thread = JavaThread::current();

   856   methodHandle h_m(my_thread, get_Method());

   858   if (h_m()->method_data() != NULL) {

   859     _method_data = CURRENT_ENV->get_method_data(h_m()->method_data());

   860     _method_data->load_data();

   861   } else {

   862     _method_data = CURRENT_ENV->get_empty_methodData();

   863   }

   864   return _method_data;

   866 }

   868 // ------------------------------------------------------------------

   869 // ciMethod::method_data_or_null

   870 // Returns a pointer to ciMethodData if MDO exists on the VM side,

   871 // NULL otherwise.

   872 ciMethodData* ciMethod::method_data_or_null() {

   873   ciMethodData *md = method_data();

   874   if (md->is_empty()) return NULL;

   875   return md;

   876 }

   878 // ------------------------------------------------------------------

   879 // ciMethod::will_link

   880 //

   881 // Will this method link in a specific calling context?

   882 bool ciMethod::will_link(ciKlass* accessing_klass,

   883                          ciKlass* declared_method_holder,

   884                          Bytecodes::Code bc) {

   885   if (!is_loaded()) {

   886     // Method lookup failed.

   887     return false;

   888   }

   890   // The link checks have been front-loaded into the get_method

   891   // call.  This method (ciMethod::will_link()) will be removed

   892   // in the future.

   894   return true;

   895 }

   897 // ------------------------------------------------------------------

   898 // ciMethod::should_exclude

   899 //

   900 // Should this method be excluded from compilation?

   901 bool ciMethod::should_exclude() {

   902   check_is_loaded();

   903   VM_ENTRY_MARK;

   904   methodHandle mh(THREAD, get_Method());

   905   bool ignore;

   906   return CompilerOracle::should_exclude(mh, ignore);

   907 }

   909 // ------------------------------------------------------------------

   910 // ciMethod::should_inline

   911 //

   912 // Should this method be inlined during compilation?

   913 bool ciMethod::should_inline() {

   914   check_is_loaded();

   915   VM_ENTRY_MARK;

   916   methodHandle mh(THREAD, get_Method());

   917   return CompilerOracle::should_inline(mh);

   918 }

   920 // ------------------------------------------------------------------

   921 // ciMethod::should_not_inline

   922 //

   923 // Should this method be disallowed from inlining during compilation?

   924 bool ciMethod::should_not_inline() {

   925   check_is_loaded();

   926   VM_ENTRY_MARK;

   927   methodHandle mh(THREAD, get_Method());

   928   return CompilerOracle::should_not_inline(mh);

   929 }

   931 // ------------------------------------------------------------------

   932 // ciMethod::should_print_assembly

   933 //

   934 // Should the compiler print the generated code for this method?

   935 bool ciMethod::should_print_assembly() {

   936   check_is_loaded();

   937   VM_ENTRY_MARK;

   938   methodHandle mh(THREAD, get_Method());

   939   return CompilerOracle::should_print(mh);

   940 }

   942 // ------------------------------------------------------------------

   943 // ciMethod::break_at_execute

   944 //

   945 // Should the compiler insert a breakpoint into the generated code

   946 // method?

   947 bool ciMethod::break_at_execute() {

   948   check_is_loaded();

   949   VM_ENTRY_MARK;

   950   methodHandle mh(THREAD, get_Method());

   951   return CompilerOracle::should_break_at(mh);

   952 }

   954 // ------------------------------------------------------------------

   955 // ciMethod::has_option

   956 //

   957 bool ciMethod::has_option(const char* option) {

   958   check_is_loaded();

   959   VM_ENTRY_MARK;

   960   methodHandle mh(THREAD, get_Method());

   961   return CompilerOracle::has_option_string(mh, option);

   962 }

   964 // ------------------------------------------------------------------

   965 // ciMethod::can_be_compiled

   966 //

   967 // Have previous compilations of this method succeeded?

   968 bool ciMethod::can_be_compiled() {

   969   check_is_loaded();

   970   ciEnv* env = CURRENT_ENV;

   971   if (is_c1_compile(env->comp_level())) {

   972     return _is_c1_compilable;

   973   }

   974   return _is_c2_compilable;

   975 }

   977 // ------------------------------------------------------------------

   978 // ciMethod::set_not_compilable

   979 //

   980 // Tell the VM that this method cannot be compiled at all.

   981 void ciMethod::set_not_compilable() {

   982   check_is_loaded();

   983   VM_ENTRY_MARK;

   984   ciEnv* env = CURRENT_ENV;

   985   if (is_c1_compile(env->comp_level())) {

   986     _is_c1_compilable = false;

   987   } else {

   988     _is_c2_compilable = false;

   989   }

   990   get_Method()->set_not_compilable(env->comp_level());

   991 }

   993 // ------------------------------------------------------------------

   994 // ciMethod::can_be_osr_compiled

   995 //

   996 // Have previous compilations of this method succeeded?

   997 //

   998 // Implementation note: the VM does not currently keep track

   999 // of failed OSR compilations per bci.  The entry_bci parameter

  1000 // is currently unused.

  1001 bool ciMethod::can_be_osr_compiled(int entry_bci) {

  1002   check_is_loaded();

  1003   VM_ENTRY_MARK;

  1004   ciEnv* env = CURRENT_ENV;

  1005   return !get_Method()->is_not_osr_compilable(env->comp_level());

  1006 }

  1008 // ------------------------------------------------------------------

  1009 // ciMethod::has_compiled_code

  1010 bool ciMethod::has_compiled_code() {

  1011   return instructions_size() > 0;

  1012 }

  1014 int ciMethod::comp_level() {

  1015   check_is_loaded();

  1016   VM_ENTRY_MARK;

  1017   nmethod* nm = get_Method()->code();

  1018   if (nm != NULL) return nm->comp_level();

  1019   return 0;

  1020 }

  1022 int ciMethod::highest_osr_comp_level() {

  1023   check_is_loaded();

  1024   VM_ENTRY_MARK;

  1025   return get_Method()->highest_osr_comp_level();

  1026 }

  1028 // ------------------------------------------------------------------

  1029 // ciMethod::code_size_for_inlining

  1030 //

  1031 // Code size for inlining decisions.  This method returns a code

  1032 // size of 1 for methods which has the ForceInline annotation.

  1033 int ciMethod::code_size_for_inlining() {

  1034   check_is_loaded();

  1035   if (get_Method()->force_inline()) {

  1036     return 1;

  1037   }

  1038   return code_size();

  1039 }

  1041 // ------------------------------------------------------------------

  1042 // ciMethod::instructions_size

  1043 //

  1044 // This is a rough metric for "fat" methods, compared before inlining

  1045 // with InlineSmallCode.  The CodeBlob::code_size accessor includes

  1046 // junk like exception handler, stubs, and constant table, which are

  1047 // not highly relevant to an inlined method.  So we use the more

  1048 // specific accessor nmethod::insts_size.

  1049 int ciMethod::instructions_size() {

  1050   if (_instructions_size == -1) {

  1051     GUARDED_VM_ENTRY(

  1052                      nmethod* code = get_Method()->code();

  1053                      if (code != NULL && (code->comp_level() == CompLevel_full_optimization)) {

  1054                        _instructions_size = code->insts_end() - code->verified_entry_point();

  1055                      } else {

  1056                        _instructions_size = 0;

  1057                      }

  1058                      );

  1059   }

  1060   return _instructions_size;

  1061 }

  1063 // ------------------------------------------------------------------

  1064 // ciMethod::log_nmethod_identity

  1065 void ciMethod::log_nmethod_identity(xmlStream* log) {

  1066   GUARDED_VM_ENTRY(

  1067     nmethod* code = get_Method()->code();

  1068     if (code != NULL) {

  1069       code->log_identity(log);

  1070     }

  1071   )

  1072 }

  1074 // ------------------------------------------------------------------

  1075 // ciMethod::is_not_reached

  1076 bool ciMethod::is_not_reached(int bci) {

  1077   check_is_loaded();

  1078   VM_ENTRY_MARK;

  1079   return Interpreter::is_not_reached(

  1080                methodHandle(THREAD, get_Method()), bci);

  1081 }

  1083 // ------------------------------------------------------------------

  1084 // ciMethod::was_never_executed

  1085 bool ciMethod::was_executed_more_than(int times) {

  1086   VM_ENTRY_MARK;

  1087   return get_Method()->was_executed_more_than(times);

  1088 }

  1090 // ------------------------------------------------------------------

  1091 // ciMethod::has_unloaded_classes_in_signature

  1092 bool ciMethod::has_unloaded_classes_in_signature() {

  1093   VM_ENTRY_MARK;

  1094   {

  1095     EXCEPTION_MARK;

  1096     methodHandle m(THREAD, get_Method());

  1097     bool has_unloaded = Method::has_unloaded_classes_in_signature(m, (JavaThread *)THREAD);

  1098     if( HAS_PENDING_EXCEPTION ) {

  1099       CLEAR_PENDING_EXCEPTION;

  1100       return true;     // Declare that we may have unloaded classes

  1101     }

  1102     return has_unloaded;

  1103   }

  1104 }

  1106 // ------------------------------------------------------------------

  1107 // ciMethod::is_klass_loaded

  1108 bool ciMethod::is_klass_loaded(int refinfo_index, bool must_be_resolved) const {

  1109   VM_ENTRY_MARK;

  1110   return get_Method()->is_klass_loaded(refinfo_index, must_be_resolved);

  1111 }

  1113 // ------------------------------------------------------------------

  1114 // ciMethod::check_call

  1115 bool ciMethod::check_call(int refinfo_index, bool is_static) const {

  1116   VM_ENTRY_MARK;

  1117   {

  1118     EXCEPTION_MARK;

  1119     HandleMark hm(THREAD);

  1120     constantPoolHandle pool (THREAD, get_Method()->constants());

  1121     methodHandle spec_method;

  1122     KlassHandle  spec_klass;

  1123     Bytecodes::Code code = (is_static ? Bytecodes::_invokestatic : Bytecodes::_invokevirtual);

  1124     LinkResolver::resolve_method_statically(spec_method, spec_klass, code, pool, refinfo_index, THREAD);

  1125     if (HAS_PENDING_EXCEPTION) {

  1126       CLEAR_PENDING_EXCEPTION;

  1127       return false;

  1128     } else {

  1129       return (spec_method->is_static() == is_static);

  1130     }

  1131   }

  1132   return false;

  1133 }

  1135 // ------------------------------------------------------------------

  1136 // ciMethod::print_codes

  1137 //

  1138 // Print the bytecodes for this method.

  1139 void ciMethod::print_codes_on(outputStream* st) {

  1140   check_is_loaded();

  1141   GUARDED_VM_ENTRY(get_Method()->print_codes_on(st);)

  1142 }

  1145 #define FETCH_FLAG_FROM_VM(flag_accessor) { \

  1146   check_is_loaded(); \

  1147   VM_ENTRY_MARK; \

  1148   return get_Method()->flag_accessor(); \

  1149 }

  1151 bool ciMethod::is_empty_method() const {         FETCH_FLAG_FROM_VM(is_empty_method); }

  1152 bool ciMethod::is_vanilla_constructor() const {  FETCH_FLAG_FROM_VM(is_vanilla_constructor); }

  1153 bool ciMethod::has_loops      () const {         FETCH_FLAG_FROM_VM(has_loops); }

  1154 bool ciMethod::has_jsrs       () const {         FETCH_FLAG_FROM_VM(has_jsrs);  }

  1155 bool ciMethod::is_accessor    () const {         FETCH_FLAG_FROM_VM(is_accessor); }

  1156 bool ciMethod::is_initializer () const {         FETCH_FLAG_FROM_VM(is_initializer); }

  1158 BCEscapeAnalyzer  *ciMethod::get_bcea() {

  1159 #ifdef COMPILER2

  1160   if (_bcea == NULL) {

  1161     _bcea = new (CURRENT_ENV->arena()) BCEscapeAnalyzer(this, NULL);

  1162   }

  1163   return _bcea;

  1164 #else // COMPILER2

  1165   ShouldNotReachHere();

  1166   return NULL;

  1167 #endif // COMPILER2

  1168 }

  1170 ciMethodBlocks  *ciMethod::get_method_blocks() {

  1171   Arena *arena = CURRENT_ENV->arena();

  1172   if (_method_blocks == NULL) {

  1173     _method_blocks = new (arena) ciMethodBlocks(arena, this);

  1174   }

  1175   return _method_blocks;

  1176 }

  1178 #undef FETCH_FLAG_FROM_VM

  1180 void ciMethod::dump_replay_data(outputStream* st) {

  1181   ASSERT_IN_VM;

  1182   Method* method = get_Method();

  1183   Klass*  holder = method->method_holder();

  1184   st->print_cr("ciMethod %s %s %s %d %d %d %d %d",

  1185                holder->name()->as_quoted_ascii(),

  1186                method->name()->as_quoted_ascii(),

  1187                method->signature()->as_quoted_ascii(),

  1188                method->invocation_counter()->raw_counter(),

  1189                method->backedge_counter()->raw_counter(),

  1190                interpreter_invocation_count(),

  1191                interpreter_throwout_count(),

  1192                _instructions_size);

  1193 }

  1195 // ------------------------------------------------------------------

  1196 // ciMethod::print_codes

  1197 //

  1198 // Print a range of the bytecodes for this method.

  1199 void ciMethod::print_codes_on(int from, int to, outputStream* st) {

  1200   check_is_loaded();

  1201   GUARDED_VM_ENTRY(get_Method()->print_codes_on(from, to, st);)

  1202 }

  1204 // ------------------------------------------------------------------

  1205 // ciMethod::print_name

  1206 //

  1207 // Print the name of this method, including signature and some flags.

  1208 void ciMethod::print_name(outputStream* st) {

  1209   check_is_loaded();

  1210   GUARDED_VM_ENTRY(get_Method()->print_name(st);)

  1211 }

  1213 // ------------------------------------------------------------------

  1214 // ciMethod::print_short_name

  1215 //

  1216 // Print the name of this method, without signature.

  1217 void ciMethod::print_short_name(outputStream* st) {

  1218   if (is_loaded()) {

  1219     GUARDED_VM_ENTRY(get_Method()->print_short_name(st););

  1220   } else {

  1221     // Fall back if method is not loaded.

  1222     holder()->print_name_on(st);

  1223     st->print("::");

  1224     name()->print_symbol_on(st);

  1225     if (WizardMode)

  1226       signature()->as_symbol()->print_symbol_on(st);

  1227   }

  1228 }

  1230 // ------------------------------------------------------------------

  1231 // ciMethod::print_impl

  1232 //

  1233 // Implementation of the print method.

  1234 void ciMethod::print_impl(outputStream* st) {

  1235   ciMetadata::print_impl(st);

  1236   st->print(" name=");

  1237   name()->print_symbol_on(st);

  1238   st->print(" holder=");

  1239   holder()->print_name_on(st);

  1240   st->print(" signature=");

  1241   signature()->as_symbol()->print_symbol_on(st);

  1242   if (is_loaded()) {

  1243     st->print(" loaded=true");

  1244     st->print(" arg_size=%d", arg_size());

  1245     st->print(" flags=");

  1246     flags().print_member_flags(st);

  1247   } else {

  1248     st->print(" loaded=false");

  1249   }

  1250 }

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

src/share/vm/ci/ciMethod.cpp@bd7a7ce2e264

src/share/vm/ci/ciMethod.cpp