1 /*

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

     3  * Copyright 2008, 2009, 2010 Red Hat, Inc.

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

     5  *

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

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

     8  * published by the Free Software Foundation.

     9  *

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

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

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

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

    14  * accompanied this code).

    15  *

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

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

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

    19  *

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

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

    22  * questions.

    23  *

    24  */

    25 

    26 #include "incls/_precompiled.incl"

    27 #include "incls/_sharkTopLevelBlock.cpp.incl"

    28 

    29 using namespace llvm;

    30 

    31 void SharkTopLevelBlock::scan_for_traps() {

    32   // If typeflow found a trap then don't scan past it

    33   int limit_bci = ciblock()->has_trap() ? ciblock()->trap_bci() : limit();

    34 

    35   // Scan the bytecode for traps that are always hit

    36   iter()->reset_to_bci(start());

    37   while (iter()->next_bci() < limit_bci) {

    38     iter()->next();

    39 

    40     ciField *field;

    41     ciMethod *method;

    42     ciInstanceKlass *klass;

    43     bool will_link;

    44     bool is_field;

    45 

    46     switch (bc()) {

    47     case Bytecodes::_ldc:

    48     case Bytecodes::_ldc_w:

    49       if (!SharkConstant::for_ldc(iter())->is_loaded()) {

    50         set_trap(

    51           Deoptimization::make_trap_request(

    52             Deoptimization::Reason_uninitialized,

    53             Deoptimization::Action_reinterpret), bci());

    54         return;

    55       }

    56       break;

    57 

    58     case Bytecodes::_getfield:

    59     case Bytecodes::_getstatic:

    60     case Bytecodes::_putfield:

    61     case Bytecodes::_putstatic:

    62       field = iter()->get_field(will_link);

    63       assert(will_link, "typeflow responsibility");

    64       is_field = (bc() == Bytecodes::_getfield || bc() == Bytecodes::_putfield);

    65 

    66       // If the bytecode does not match the field then bail out to

    67       // the interpreter to throw an IncompatibleClassChangeError

    68       if (is_field == field->is_static()) {

    69         set_trap(

    70           Deoptimization::make_trap_request(

    71             Deoptimization::Reason_unhandled,

    72             Deoptimization::Action_none), bci());

    73         return;

    74       }

    75 

    76       // Bail out if we are trying to access a static variable

    77       // before the class initializer has completed.

    78       if (!is_field && !field->holder()->is_initialized()) {

    79         if (!static_field_ok_in_clinit(field)) {

    80           set_trap(

    81             Deoptimization::make_trap_request(

    82               Deoptimization::Reason_uninitialized,

    83               Deoptimization::Action_reinterpret), bci());

    84           return;

    85         }

    86       }

    87       break;

    88 

    89     case Bytecodes::_invokestatic:

    90     case Bytecodes::_invokespecial:

    91     case Bytecodes::_invokevirtual:

    92     case Bytecodes::_invokeinterface:

    93       method = iter()->get_method(will_link);

    94       assert(will_link, "typeflow responsibility");

    95 

    96       if (!method->holder()->is_linked()) {

    97         set_trap(

    98           Deoptimization::make_trap_request(

    99             Deoptimization::Reason_uninitialized,

   100             Deoptimization::Action_reinterpret), bci());

   101           return;

   102       }

   103 

   104       if (bc() == Bytecodes::_invokevirtual) {

   105         klass = ciEnv::get_instance_klass_for_declared_method_holder(

   106           iter()->get_declared_method_holder());

   107         if (!klass->is_linked()) {

   108           set_trap(

   109             Deoptimization::make_trap_request(

   110               Deoptimization::Reason_uninitialized,

   111               Deoptimization::Action_reinterpret), bci());

   112             return;

   113         }

   114       }

   115       break;

   116 

   117     case Bytecodes::_new:

   118       klass = iter()->get_klass(will_link)->as_instance_klass();

   119       assert(will_link, "typeflow responsibility");

   120 

   121       // Bail out if the class is unloaded

   122       if (iter()->is_unresolved_klass() || !klass->is_initialized()) {

   123         set_trap(

   124           Deoptimization::make_trap_request(

   125             Deoptimization::Reason_uninitialized,

   126             Deoptimization::Action_reinterpret), bci());

   127         return;

   128       }

   129 

   130       // Bail out if the class cannot be instantiated

   131       if (klass->is_abstract() || klass->is_interface() ||

   132           klass->name() == ciSymbol::java_lang_Class()) {

   133         set_trap(

   134           Deoptimization::make_trap_request(

   135             Deoptimization::Reason_unhandled,

   136             Deoptimization::Action_reinterpret), bci());

   137         return;

   138       }

   139       break;

   140     }

   141   }

   142 

   143   // Trap if typeflow trapped (and we didn't before)

   144   if (ciblock()->has_trap()) {

   145     set_trap(

   146       Deoptimization::make_trap_request(

   147         Deoptimization::Reason_unloaded,

   148         Deoptimization::Action_reinterpret,

   149         ciblock()->trap_index()), ciblock()->trap_bci());

   150     return;

   151   }

   152 }

   153 

   154 bool SharkTopLevelBlock::static_field_ok_in_clinit(ciField* field) {

   155   assert(field->is_static(), "should be");

   156 

   157   // This code is lifted pretty much verbatim from C2's

   158   // Parse::static_field_ok_in_clinit() in parse3.cpp.

   159   bool access_OK = false;

   160   if (target()->holder()->is_subclass_of(field->holder())) {

   161     if (target()->is_static()) {

   162       if (target()->name() == ciSymbol::class_initializer_name()) {

   163         // It's OK to access static fields from the class initializer

   164         access_OK = true;

   165       }

   166     }

   167     else {

   168       if (target()->name() == ciSymbol::object_initializer_name()) {

   169         // It's also OK to access static fields inside a constructor,

   170         // because any thread calling the constructor must first have

   171         // synchronized on the class by executing a "new" bytecode.

   172         access_OK = true;

   173       }

   174     }

   175   }

   176   return access_OK;

   177 }

   178 

   179 SharkState* SharkTopLevelBlock::entry_state() {

   180   if (_entry_state == NULL) {

   181     assert(needs_phis(), "should do");

   182     _entry_state = new SharkPHIState(this);

   183   }

   184   return _entry_state;

   185 }

   186 

   187 void SharkTopLevelBlock::add_incoming(SharkState* incoming_state) {

   188   if (needs_phis()) {

   189     ((SharkPHIState *) entry_state())->add_incoming(incoming_state);

   190   }

   191   else if (_entry_state == NULL) {

   192     _entry_state = incoming_state;

   193   }

   194   else {

   195     assert(entry_state()->equal_to(incoming_state), "should be");

   196   }

   197 }

   198 

   199 void SharkTopLevelBlock::enter(SharkTopLevelBlock* predecessor,

   200                                bool is_exception) {

   201   // This block requires phis:

   202   //  - if it is entered more than once

   203   //  - if it is an exception handler, because in which

   204   //    case we assume it's entered more than once.

   205   //  - if the predecessor will be compiled after this

   206   //    block, in which case we can't simple propagate

   207   //    the state forward.

   208   if (!needs_phis() &&

   209       (entered() ||

   210        is_exception ||

   211        (predecessor && predecessor->index() >= index())))

   212     _needs_phis = true;

   213 

   214   // Recurse into the tree

   215   if (!entered()) {

   216     _entered = true;

   217 

   218     scan_for_traps();

   219     if (!has_trap()) {

   220       for (int i = 0; i < num_successors(); i++) {

   221         successor(i)->enter(this, false);

   222       }

   223     }

   224     compute_exceptions();

   225     for (int i = 0; i < num_exceptions(); i++) {

   226       SharkTopLevelBlock *handler = exception(i);

   227       if (handler)

   228         handler->enter(this, true);

   229     }

   230   }

   231 }

   232 

   233 void SharkTopLevelBlock::initialize() {

   234   char name[28];

   235   snprintf(name, sizeof(name),

   236            "bci_%d%s",

   237            start(), is_backedge_copy() ? "_backedge_copy" : "");

   238   _entry_block = function()->CreateBlock(name);

   239 }

   240 

   241 void SharkTopLevelBlock::decache_for_Java_call(ciMethod *callee) {

   242   SharkJavaCallDecacher(function(), bci(), callee).scan(current_state());

   243   for (int i = 0; i < callee->arg_size(); i++)

   244     xpop();

   245 }

   246 

   247 void SharkTopLevelBlock::cache_after_Java_call(ciMethod *callee) {

   248   if (callee->return_type()->size()) {

   249     ciType *type;

   250     switch (callee->return_type()->basic_type()) {

   251     case T_BOOLEAN:

   252     case T_BYTE:

   253     case T_CHAR:

   254     case T_SHORT:

   255       type = ciType::make(T_INT);

   256       break;

   257 

   258     default:

   259       type = callee->return_type();

   260     }

   261 

   262     push(SharkValue::create_generic(type, NULL, false));

   263   }

   264   SharkJavaCallCacher(function(), callee).scan(current_state());

   265 }

   266 

   267 void SharkTopLevelBlock::decache_for_VM_call() {

   268   SharkVMCallDecacher(function(), bci()).scan(current_state());

   269 }

   270 

   271 void SharkTopLevelBlock::cache_after_VM_call() {

   272   SharkVMCallCacher(function()).scan(current_state());

   273 }

   274 

   275 void SharkTopLevelBlock::decache_for_trap() {

   276   SharkTrapDecacher(function(), bci()).scan(current_state());

   277 }

   278 

   279 void SharkTopLevelBlock::emit_IR() {

   280   builder()->SetInsertPoint(entry_block());

   281 

   282   // Parse the bytecode

   283   parse_bytecode(start(), limit());

   284 

   285   // If this block falls through to the next then it won't have been

   286   // terminated by a bytecode and we have to add the branch ourselves

   287   if (falls_through() && !has_trap())

   288     do_branch(ciTypeFlow::FALL_THROUGH);

   289 }

   290 

   291 SharkTopLevelBlock* SharkTopLevelBlock::bci_successor(int bci) const {

   292   // XXX now with Linear Search Technology (tm)

   293   for (int i = 0; i < num_successors(); i++) {

   294     ciTypeFlow::Block *successor = ciblock()->successors()->at(i);

   295     if (successor->start() == bci)

   296       return function()->block(successor->pre_order());

   297   }

   298   ShouldNotReachHere();

   299 }

   300 

   301 void SharkTopLevelBlock::do_zero_check(SharkValue *value) {

   302   if (value->is_phi() && value->as_phi()->all_incomers_zero_checked()) {

   303     function()->add_deferred_zero_check(this, value);

   304   }

   305   else {

   306     BasicBlock *continue_block = function()->CreateBlock("not_zero");

   307     SharkState *saved_state = current_state();

   308     set_current_state(saved_state->copy());

   309     zero_check_value(value, continue_block);

   310     builder()->SetInsertPoint(continue_block);

   311     set_current_state(saved_state);

   312   }

   313 

   314   value->set_zero_checked(true);

   315 }

   316 

   317 void SharkTopLevelBlock::do_deferred_zero_check(SharkValue* value,

   318                                                 int         bci,

   319                                                 SharkState* saved_state,

   320                                                 BasicBlock* continue_block) {

   321   if (value->as_phi()->all_incomers_zero_checked()) {

   322     builder()->CreateBr(continue_block);

   323   }

   324   else {

   325     iter()->force_bci(start());

   326     set_current_state(saved_state);

   327     zero_check_value(value, continue_block);

   328   }

   329 }

   330 

   331 void SharkTopLevelBlock::zero_check_value(SharkValue* value,

   332                                           BasicBlock* continue_block) {

   333   BasicBlock *zero_block = builder()->CreateBlock(continue_block, "zero");

   334 

   335   Value *a, *b;

   336   switch (value->basic_type()) {

   337   case T_BYTE:

   338   case T_CHAR:

   339   case T_SHORT:

   340   case T_INT:

   341     a = value->jint_value();

   342     b = LLVMValue::jint_constant(0);

   343     break;

   344   case T_LONG:

   345     a = value->jlong_value();

   346     b = LLVMValue::jlong_constant(0);

   347     break;

   348   case T_OBJECT:

   349   case T_ARRAY:

   350     a = value->jobject_value();

   351     b = LLVMValue::LLVMValue::null();

   352     break;

   353   default:

   354     tty->print_cr("Unhandled type %s", type2name(value->basic_type()));

   355     ShouldNotReachHere();

   356   }

   357 

   358   builder()->CreateCondBr(

   359     builder()->CreateICmpNE(a, b), continue_block, zero_block);

   360 

   361   builder()->SetInsertPoint(zero_block);

   362   if (value->is_jobject()) {

   363     call_vm(

   364       builder()->throw_NullPointerException(),

   365       builder()->CreateIntToPtr(

   366         LLVMValue::intptr_constant((intptr_t) __FILE__),

   367         PointerType::getUnqual(SharkType::jbyte_type())),

   368       LLVMValue::jint_constant(__LINE__),

   369       EX_CHECK_NONE);

   370   }

   371   else {

   372     call_vm(

   373       builder()->throw_ArithmeticException(),

   374       builder()->CreateIntToPtr(

   375         LLVMValue::intptr_constant((intptr_t) __FILE__),

   376         PointerType::getUnqual(SharkType::jbyte_type())),

   377       LLVMValue::jint_constant(__LINE__),

   378       EX_CHECK_NONE);

   379   }

   380 

   381   Value *pending_exception = get_pending_exception();

   382   clear_pending_exception();

   383   handle_exception(pending_exception, EX_CHECK_FULL);

   384 }

   385 

   386 void SharkTopLevelBlock::check_bounds(SharkValue* array, SharkValue* index) {

   387   BasicBlock *out_of_bounds = function()->CreateBlock("out_of_bounds");

   388   BasicBlock *in_bounds     = function()->CreateBlock("in_bounds");

   389 

   390   Value *length = builder()->CreateArrayLength(array->jarray_value());

   391   // we use an unsigned comparison to catch negative values

   392   builder()->CreateCondBr(

   393     builder()->CreateICmpULT(index->jint_value(), length),

   394     in_bounds, out_of_bounds);

   395 

   396   builder()->SetInsertPoint(out_of_bounds);

   397   SharkState *saved_state = current_state()->copy();

   398 

   399   call_vm(

   400     builder()->throw_ArrayIndexOutOfBoundsException(),

   401     builder()->CreateIntToPtr(

   402       LLVMValue::intptr_constant((intptr_t) __FILE__),

   403       PointerType::getUnqual(SharkType::jbyte_type())),

   404     LLVMValue::jint_constant(__LINE__),

   405     index->jint_value(),

   406     EX_CHECK_NONE);

   407 

   408   Value *pending_exception = get_pending_exception();

   409   clear_pending_exception();

   410   handle_exception(pending_exception, EX_CHECK_FULL);

   411 

   412   set_current_state(saved_state);

   413 

   414   builder()->SetInsertPoint(in_bounds);

   415 }

   416 

   417 void SharkTopLevelBlock::check_pending_exception(int action) {

   418   assert(action & EAM_CHECK, "should be");

   419 

   420   BasicBlock *exception    = function()->CreateBlock("exception");

   421   BasicBlock *no_exception = function()->CreateBlock("no_exception");

   422 

   423   Value *pending_exception = get_pending_exception();

   424   builder()->CreateCondBr(

   425     builder()->CreateICmpEQ(pending_exception, LLVMValue::null()),

   426     no_exception, exception);

   427 

   428   builder()->SetInsertPoint(exception);

   429   SharkState *saved_state = current_state()->copy();

   430   if (action & EAM_MONITOR_FUDGE) {

   431     // The top monitor is marked live, but the exception was thrown

   432     // while setting it up so we need to mark it dead before we enter

   433     // any exception handlers as they will not expect it to be there.

   434     set_num_monitors(num_monitors() - 1);

   435     action ^= EAM_MONITOR_FUDGE;

   436   }

   437   clear_pending_exception();

   438   handle_exception(pending_exception, action);

   439   set_current_state(saved_state);

   440 

   441   builder()->SetInsertPoint(no_exception);

   442 }

   443 

   444 void SharkTopLevelBlock::compute_exceptions() {

   445   ciExceptionHandlerStream str(target(), start());

   446 

   447   int exc_count = str.count();

   448   _exc_handlers = new GrowableArray<ciExceptionHandler*>(exc_count);

   449   _exceptions   = new GrowableArray<SharkTopLevelBlock*>(exc_count);

   450 

   451   int index = 0;

   452   for (; !str.is_done(); str.next()) {

   453     ciExceptionHandler *handler = str.handler();

   454     if (handler->handler_bci() == -1)

   455       break;

   456     _exc_handlers->append(handler);

   457 

   458     // Try and get this exception's handler from typeflow.  We should

   459     // do it this way always, really, except that typeflow sometimes

   460     // doesn't record exceptions, even loaded ones, and sometimes it

   461     // returns them with a different handler bci.  Why???

   462     SharkTopLevelBlock *block = NULL;

   463     ciInstanceKlass* klass;

   464     if (handler->is_catch_all()) {

   465       klass = java_lang_Throwable_klass();

   466     }

   467     else {

   468       klass = handler->catch_klass();

   469     }

   470     for (int i = 0; i < ciblock()->exceptions()->length(); i++) {

   471       if (klass == ciblock()->exc_klasses()->at(i)) {

   472         block = function()->block(ciblock()->exceptions()->at(i)->pre_order());

   473         if (block->start() == handler->handler_bci())

   474           break;

   475         else

   476           block = NULL;

   477       }

   478     }

   479 

   480     // If typeflow let us down then try and figure it out ourselves

   481     if (block == NULL) {

   482       for (int i = 0; i < function()->block_count(); i++) {

   483         SharkTopLevelBlock *candidate = function()->block(i);

   484         if (candidate->start() == handler->handler_bci()) {

   485           if (block != NULL) {

   486             NOT_PRODUCT(warning("there may be trouble ahead"));

   487             block = NULL;

   488             break;

   489           }

   490           block = candidate;

   491         }

   492       }

   493     }

   494     _exceptions->append(block);

   495   }

   496 }

   497 

   498 void SharkTopLevelBlock::handle_exception(Value* exception, int action) {

   499   if (action & EAM_HANDLE && num_exceptions() != 0) {

   500     // Clear the stack and push the exception onto it

   501     while (xstack_depth())

   502       pop();

   503     push(SharkValue::create_jobject(exception, true));

   504 

   505     // Work out how many options we have to check

   506     bool has_catch_all = exc_handler(num_exceptions() - 1)->is_catch_all();

   507     int num_options = num_exceptions();

   508     if (has_catch_all)

   509       num_options--;

   510 

   511     // Marshal any non-catch-all handlers

   512     if (num_options > 0) {

   513       bool all_loaded = true;

   514       for (int i = 0; i < num_options; i++) {

   515         if (!exc_handler(i)->catch_klass()->is_loaded()) {

   516           all_loaded = false;

   517           break;

   518         }

   519       }

   520 

   521       if (all_loaded)

   522         marshal_exception_fast(num_options);

   523       else

   524         marshal_exception_slow(num_options);

   525     }

   526 

   527     // Install the catch-all handler, if present

   528     if (has_catch_all) {

   529       SharkTopLevelBlock* handler = this->exception(num_options);

   530       assert(handler != NULL, "catch-all handler cannot be unloaded");

   531 

   532       builder()->CreateBr(handler->entry_block());

   533       handler->add_incoming(current_state());

   534       return;

   535     }

   536   }

   537 

   538   // No exception handler was found; unwind and return

   539   handle_return(T_VOID, exception);

   540 }

   541 

   542 void SharkTopLevelBlock::marshal_exception_fast(int num_options) {

   543   Value *exception_klass = builder()->CreateValueOfStructEntry(

   544     xstack(0)->jobject_value(),

   545     in_ByteSize(oopDesc::klass_offset_in_bytes()),

   546     SharkType::oop_type(),

   547     "exception_klass");

   548 

   549   for (int i = 0; i < num_options; i++) {

   550     Value *check_klass =

   551       builder()->CreateInlineOop(exc_handler(i)->catch_klass());

   552 

   553     BasicBlock *not_exact   = function()->CreateBlock("not_exact");

   554     BasicBlock *not_subtype = function()->CreateBlock("not_subtype");

   555 

   556     builder()->CreateCondBr(

   557       builder()->CreateICmpEQ(check_klass, exception_klass),

   558       handler_for_exception(i), not_exact);

   559 

   560     builder()->SetInsertPoint(not_exact);

   561     builder()->CreateCondBr(

   562       builder()->CreateICmpNE(

   563         builder()->CreateCall2(

   564           builder()->is_subtype_of(), check_klass, exception_klass),

   565         LLVMValue::jbyte_constant(0)),

   566       handler_for_exception(i), not_subtype);

   567 

   568     builder()->SetInsertPoint(not_subtype);

   569   }

   570 }

   571 

   572 void SharkTopLevelBlock::marshal_exception_slow(int num_options) {

   573   int *indexes = NEW_RESOURCE_ARRAY(int, num_options);

   574   for (int i = 0; i < num_options; i++)

   575     indexes[i] = exc_handler(i)->catch_klass_index();

   576 

   577   Value *index = call_vm(

   578     builder()->find_exception_handler(),

   579     builder()->CreateInlineData(

   580       indexes,

   581       num_options * sizeof(int),

   582       PointerType::getUnqual(SharkType::jint_type())),

   583     LLVMValue::jint_constant(num_options),

   584     EX_CHECK_NO_CATCH);

   585 

   586   BasicBlock *no_handler = function()->CreateBlock("no_handler");

   587   SwitchInst *switchinst = builder()->CreateSwitch(

   588     index, no_handler, num_options);

   589 

   590   for (int i = 0; i < num_options; i++) {

   591     switchinst->addCase(

   592       LLVMValue::jint_constant(i),

   593       handler_for_exception(i));

   594   }

   595 

   596   builder()->SetInsertPoint(no_handler);

   597 }

   598 

   599 BasicBlock* SharkTopLevelBlock::handler_for_exception(int index) {

   600   SharkTopLevelBlock *successor = this->exception(index);

   601   if (successor) {

   602     successor->add_incoming(current_state());

   603     return successor->entry_block();

   604   }

   605   else {

   606     return make_trap(

   607       exc_handler(index)->handler_bci(),

   608       Deoptimization::make_trap_request(

   609         Deoptimization::Reason_unhandled,

   610         Deoptimization::Action_reinterpret));

   611   }

   612 }

   613 

   614 void SharkTopLevelBlock::maybe_add_safepoint() {

   615   if (current_state()->has_safepointed())

   616     return;

   617 

   618   BasicBlock *orig_block = builder()->GetInsertBlock();

   619   SharkState *orig_state = current_state()->copy();

   620 

   621   BasicBlock *do_safepoint = function()->CreateBlock("do_safepoint");

   622   BasicBlock *safepointed  = function()->CreateBlock("safepointed");

   623 

   624   Value *state = builder()->CreateLoad(

   625     builder()->CreateIntToPtr(

   626       LLVMValue::intptr_constant(

   627         (intptr_t) SafepointSynchronize::address_of_state()),

   628       PointerType::getUnqual(SharkType::jint_type())),

   629     "state");

   630 

   631   builder()->CreateCondBr(

   632     builder()->CreateICmpEQ(

   633       state,

   634       LLVMValue::jint_constant(SafepointSynchronize::_synchronizing)),

   635     do_safepoint, safepointed);

   636 

   637   builder()->SetInsertPoint(do_safepoint);

   638   call_vm(builder()->safepoint(), EX_CHECK_FULL);

   639   BasicBlock *safepointed_block = builder()->GetInsertBlock();

   640   builder()->CreateBr(safepointed);

   641 

   642   builder()->SetInsertPoint(safepointed);

   643   current_state()->merge(orig_state, orig_block, safepointed_block);

   644 

   645   current_state()->set_has_safepointed(true);

   646 }

   647 

   648 void SharkTopLevelBlock::maybe_add_backedge_safepoint() {

   649   if (current_state()->has_safepointed())

   650     return;

   651 

   652   for (int i = 0; i < num_successors(); i++) {

   653     if (successor(i)->can_reach(this)) {

   654       maybe_add_safepoint();

   655       break;

   656     }

   657   }

   658 }

   659 

   660 bool SharkTopLevelBlock::can_reach(SharkTopLevelBlock* other) {

   661   for (int i = 0; i < function()->block_count(); i++)

   662     function()->block(i)->_can_reach_visited = false;

   663 

   664   return can_reach_helper(other);

   665 }

   666 

   667 bool SharkTopLevelBlock::can_reach_helper(SharkTopLevelBlock* other) {

   668   if (this == other)

   669     return true;

   670 

   671   if (_can_reach_visited)

   672     return false;

   673   _can_reach_visited = true;

   674 

   675   if (!has_trap()) {

   676     for (int i = 0; i < num_successors(); i++) {

   677       if (successor(i)->can_reach_helper(other))

   678         return true;

   679     }

   680   }

   681 

   682   for (int i = 0; i < num_exceptions(); i++) {

   683     SharkTopLevelBlock *handler = exception(i);

   684     if (handler && handler->can_reach_helper(other))

   685       return true;

   686   }

   687 

   688   return false;

   689 }

   690 

   691 BasicBlock* SharkTopLevelBlock::make_trap(int trap_bci, int trap_request) {

   692   BasicBlock *trap_block = function()->CreateBlock("trap");

   693   BasicBlock *orig_block = builder()->GetInsertBlock();

   694   builder()->SetInsertPoint(trap_block);

   695 

   696   int orig_bci = bci();

   697   iter()->force_bci(trap_bci);

   698 

   699   do_trap(trap_request);

   700 

   701   builder()->SetInsertPoint(orig_block);

   702   iter()->force_bci(orig_bci);

   703 

   704   return trap_block;

   705 }

   706 

   707 void SharkTopLevelBlock::do_trap(int trap_request) {

   708   decache_for_trap();

   709   builder()->CreateRet(

   710     builder()->CreateCall2(

   711       builder()->uncommon_trap(),

   712       thread(),

   713       LLVMValue::jint_constant(trap_request)));

   714 }

   715 

   716 void SharkTopLevelBlock::call_register_finalizer(Value *receiver) {

   717   BasicBlock *orig_block = builder()->GetInsertBlock();

   718   SharkState *orig_state = current_state()->copy();

   719 

   720   BasicBlock *do_call = function()->CreateBlock("has_finalizer");

   721   BasicBlock *done    = function()->CreateBlock("done");

   722 

   723   Value *klass = builder()->CreateValueOfStructEntry(

   724     receiver,

   725     in_ByteSize(oopDesc::klass_offset_in_bytes()),

   726     SharkType::oop_type(),

   727     "klass");

   728 

   729   Value *klass_part = builder()->CreateAddressOfStructEntry(

   730     klass,

   731     in_ByteSize(klassOopDesc::klass_part_offset_in_bytes()),

   732     SharkType::klass_type(),

   733     "klass_part");

   734 

   735   Value *access_flags = builder()->CreateValueOfStructEntry(

   736     klass_part,

   737     in_ByteSize(Klass::access_flags_offset_in_bytes()),

   738     SharkType::jint_type(),

   739     "access_flags");

   740 

   741   builder()->CreateCondBr(

   742     builder()->CreateICmpNE(

   743       builder()->CreateAnd(

   744         access_flags,

   745         LLVMValue::jint_constant(JVM_ACC_HAS_FINALIZER)),

   746       LLVMValue::jint_constant(0)),

   747     do_call, done);

   748 

   749   builder()->SetInsertPoint(do_call);

   750   call_vm(builder()->register_finalizer(), receiver, EX_CHECK_FULL);

   751   BasicBlock *branch_block = builder()->GetInsertBlock();

   752   builder()->CreateBr(done);

   753 

   754   builder()->SetInsertPoint(done);

   755   current_state()->merge(orig_state, orig_block, branch_block);

   756 }

   757 

   758 void SharkTopLevelBlock::handle_return(BasicType type, Value* exception) {

   759   assert (exception == NULL || type == T_VOID, "exception OR result, please");

   760 

   761   if (num_monitors()) {

   762     // Protect our exception across possible monitor release decaches

   763     if (exception)

   764       set_oop_tmp(exception);

   765 

   766     // We don't need to check for exceptions thrown here.  If

   767     // we're returning a value then we just carry on as normal:

   768     // the caller will see the pending exception and handle it.

   769     // If we're returning with an exception then that exception

   770     // takes priority and the release_lock one will be ignored.

   771     while (num_monitors())

   772       release_lock(EX_CHECK_NONE);

   773 

   774     // Reload the exception we're throwing

   775     if (exception)

   776       exception = get_oop_tmp();

   777   }

   778 

   779   if (exception) {

   780     builder()->CreateStore(exception, pending_exception_address());

   781   }

   782 

   783   Value *result_addr = stack()->CreatePopFrame(type2size[type]);

   784   if (type != T_VOID) {

   785     builder()->CreateStore(

   786       pop_result(type)->generic_value(),

   787       builder()->CreateIntToPtr(

   788         result_addr,

   789         PointerType::getUnqual(SharkType::to_stackType(type))));

   790   }

   791 

   792   builder()->CreateRet(LLVMValue::jint_constant(0));

   793 }

   794 

   795 void SharkTopLevelBlock::do_arraylength() {

   796   SharkValue *array = pop();

   797   check_null(array);

   798   Value *length = builder()->CreateArrayLength(array->jarray_value());

   799   push(SharkValue::create_jint(length, false));

   800 }

   801 

   802 void SharkTopLevelBlock::do_aload(BasicType basic_type) {

   803   SharkValue *index = pop();

   804   SharkValue *array = pop();

   805 

   806   check_null(array);

   807   check_bounds(array, index);

   808 

   809   Value *value = builder()->CreateLoad(

   810     builder()->CreateArrayAddress(

   811       array->jarray_value(), basic_type, index->jint_value()));

   812 

   813   const Type *stack_type = SharkType::to_stackType(basic_type);

   814   if (value->getType() != stack_type)

   815     value = builder()->CreateIntCast(value, stack_type, basic_type != T_CHAR);

   816 

   817   switch (basic_type) {

   818   case T_BYTE:

   819   case T_CHAR:

   820   case T_SHORT:

   821   case T_INT:

   822     push(SharkValue::create_jint(value, false));

   823     break;

   824 

   825   case T_LONG:

   826     push(SharkValue::create_jlong(value, false));

   827     break;

   828 

   829   case T_FLOAT:

   830     push(SharkValue::create_jfloat(value));

   831     break;

   832 

   833   case T_DOUBLE:

   834     push(SharkValue::create_jdouble(value));

   835     break;

   836 

   837   case T_OBJECT:

   838     // You might expect that array->type()->is_array_klass() would

   839     // always be true, but it isn't.  If ciTypeFlow detects that a

   840     // value is always null then that value becomes an untyped null

   841     // object.  Shark doesn't presently support this, so a generic

   842     // T_OBJECT is created.  In this case we guess the type using

   843     // the BasicType we were supplied.  In reality the generated

   844     // code will never be used, as the null value will be caught

   845     // by the above null pointer check.

   846     // http://icedtea.classpath.org/bugzilla/show_bug.cgi?id=324

   847     push(

   848       SharkValue::create_generic(

   849         array->type()->is_array_klass() ?

   850           ((ciArrayKlass *) array->type())->element_type() :

   851           ciType::make(basic_type),

   852         value, false));

   853     break;

   854 

   855   default:

   856     tty->print_cr("Unhandled type %s", type2name(basic_type));

   857     ShouldNotReachHere();

   858   }

   859 }

   860 

   861 void SharkTopLevelBlock::do_astore(BasicType basic_type) {

   862   SharkValue *svalue = pop();

   863   SharkValue *index  = pop();

   864   SharkValue *array  = pop();

   865 

   866   check_null(array);

   867   check_bounds(array, index);

   868 

   869   Value *value;

   870   switch (basic_type) {

   871   case T_BYTE:

   872   case T_CHAR:

   873   case T_SHORT:

   874   case T_INT:

   875     value = svalue->jint_value();

   876     break;

   877 

   878   case T_LONG:

   879     value = svalue->jlong_value();

   880     break;

   881 

   882   case T_FLOAT:

   883     value = svalue->jfloat_value();

   884     break;

   885 

   886   case T_DOUBLE:

   887     value = svalue->jdouble_value();

   888     break;

   889 

   890   case T_OBJECT:

   891     value = svalue->jobject_value();

   892     // XXX assignability check

   893     break;

   894 

   895   default:

   896     tty->print_cr("Unhandled type %s", type2name(basic_type));

   897     ShouldNotReachHere();

   898   }

   899 

   900   const Type *array_type = SharkType::to_arrayType(basic_type);

   901   if (value->getType() != array_type)

   902     value = builder()->CreateIntCast(value, array_type, basic_type != T_CHAR);

   903 

   904   Value *addr = builder()->CreateArrayAddress(

   905     array->jarray_value(), basic_type, index->jint_value(), "addr");

   906 

   907   builder()->CreateStore(value, addr);

   908 

   909   if (basic_type == T_OBJECT) // XXX or T_ARRAY?

   910     builder()->CreateUpdateBarrierSet(oopDesc::bs(), addr);

   911 }

   912 

   913 void SharkTopLevelBlock::do_return(BasicType type) {

   914   if (target()->intrinsic_id() == vmIntrinsics::_Object_init)

   915     call_register_finalizer(local(0)->jobject_value());

   916   maybe_add_safepoint();

   917   handle_return(type, NULL);

   918 }

   919 

   920 void SharkTopLevelBlock::do_athrow() {

   921   SharkValue *exception = pop();

   922   check_null(exception);

   923   handle_exception(exception->jobject_value(), EX_CHECK_FULL);

   924 }

   925 

   926 void SharkTopLevelBlock::do_goto() {

   927   do_branch(ciTypeFlow::GOTO_TARGET);

   928 }

   929 

   930 void SharkTopLevelBlock::do_jsr() {

   931   push(SharkValue::address_constant(iter()->next_bci()));

   932   do_branch(ciTypeFlow::GOTO_TARGET);

   933 }

   934 

   935 void SharkTopLevelBlock::do_ret() {

   936   assert(local(iter()->get_index())->address_value() ==

   937          successor(ciTypeFlow::GOTO_TARGET)->start(), "should be");

   938   do_branch(ciTypeFlow::GOTO_TARGET);

   939 }

   940 

   941 // All propagation of state from one block to the next (via

   942 // dest->add_incoming) is handled by these methods:

   943 //   do_branch

   944 //   do_if_helper

   945 //   do_switch

   946 //   handle_exception

   947 

   948 void SharkTopLevelBlock::do_branch(int successor_index) {

   949   SharkTopLevelBlock *dest = successor(successor_index);

   950   builder()->CreateBr(dest->entry_block());

   951   dest->add_incoming(current_state());

   952 }

   953 

   954 void SharkTopLevelBlock::do_if(ICmpInst::Predicate p,

   955                                SharkValue*         b,

   956                                SharkValue*         a) {

   957   Value *llvm_a, *llvm_b;

   958   if (a->is_jobject()) {

   959     llvm_a = a->intptr_value(builder());

   960     llvm_b = b->intptr_value(builder());

   961   }

   962   else {

   963     llvm_a = a->jint_value();

   964     llvm_b = b->jint_value();

   965   }

   966   do_if_helper(p, llvm_b, llvm_a, current_state(), current_state());

   967 }

   968 

   969 void SharkTopLevelBlock::do_if_helper(ICmpInst::Predicate p,

   970                                       Value*              b,

   971                                       Value*              a,

   972                                       SharkState*         if_taken_state,

   973                                       SharkState*         not_taken_state) {

   974   SharkTopLevelBlock *if_taken  = successor(ciTypeFlow::IF_TAKEN);

   975   SharkTopLevelBlock *not_taken = successor(ciTypeFlow::IF_NOT_TAKEN);

   976 

   977   builder()->CreateCondBr(

   978     builder()->CreateICmp(p, a, b),

   979     if_taken->entry_block(), not_taken->entry_block());

   980 

   981   if_taken->add_incoming(if_taken_state);

   982   not_taken->add_incoming(not_taken_state);

   983 }

   984 

   985 void SharkTopLevelBlock::do_switch() {

   986   int len = switch_table_length();

   987 

   988   SharkTopLevelBlock *dest_block = successor(ciTypeFlow::SWITCH_DEFAULT);

   989   SwitchInst *switchinst = builder()->CreateSwitch(

   990     pop()->jint_value(), dest_block->entry_block(), len);

   991   dest_block->add_incoming(current_state());

   992 

   993   for (int i = 0; i < len; i++) {

   994     int dest_bci = switch_dest(i);

   995     if (dest_bci != switch_default_dest()) {

   996       dest_block = bci_successor(dest_bci);

   997       switchinst->addCase(

   998         LLVMValue::jint_constant(switch_key(i)),

   999         dest_block->entry_block());

  1000       dest_block->add_incoming(current_state());

  1001     }

  1002   }

  1003 }

  1004 

  1005 ciMethod* SharkTopLevelBlock::improve_virtual_call(ciMethod*   caller,

  1006                                               ciInstanceKlass* klass,

  1007                                               ciMethod*        dest_method,

  1008                                               ciType*          receiver_type) {

  1009   // If the method is obviously final then we are already done

  1010   if (dest_method->can_be_statically_bound())

  1011     return dest_method;

  1012 

  1013   // Array methods are all inherited from Object and are monomorphic

  1014   if (receiver_type->is_array_klass() &&

  1015       dest_method->holder() == java_lang_Object_klass())

  1016     return dest_method;

  1017 

  1018 #ifdef SHARK_CAN_DEOPTIMIZE_ANYWHERE

  1019   // This code can replace a virtual call with a direct call if this

  1020   // class is the only one in the entire set of loaded classes that

  1021   // implements this method.  This makes the compiled code dependent

  1022   // on other classes that implement the method not being loaded, a

  1023   // condition which is enforced by the dependency tracker.  If the

  1024   // dependency tracker determines a method has become invalid it

  1025   // will mark it for recompilation, causing running copies to be

  1026   // deoptimized.  Shark currently can't deoptimize arbitrarily like

  1027   // that, so this optimization cannot be used.

  1028   // http://icedtea.classpath.org/bugzilla/show_bug.cgi?id=481

  1029 

  1030   // All other interesting cases are instance classes

  1031   if (!receiver_type->is_instance_klass())

  1032     return NULL;

  1033 

  1034   // Attempt to improve the receiver

  1035   ciInstanceKlass* actual_receiver = klass;

  1036   ciInstanceKlass *improved_receiver = receiver_type->as_instance_klass();

  1037   if (improved_receiver->is_loaded() &&

  1038       improved_receiver->is_initialized() &&

  1039       !improved_receiver->is_interface() &&

  1040       improved_receiver->is_subtype_of(actual_receiver)) {

  1041     actual_receiver = improved_receiver;

  1042   }

  1043 

  1044   // Attempt to find a monomorphic target for this call using

  1045   // class heirachy analysis.

  1046   ciInstanceKlass *calling_klass = caller->holder();

  1047   ciMethod* monomorphic_target =

  1048     dest_method->find_monomorphic_target(calling_klass, klass, actual_receiver);

  1049   if (monomorphic_target != NULL) {

  1050     assert(!monomorphic_target->is_abstract(), "shouldn't be");

  1051 

  1052     // Opto has a bunch of type checking here that I don't

  1053     // understand.  It's to inhibit casting in one direction,

  1054     // possibly because objects in Opto can have inexact

  1055     // types, but I can't even tell which direction it

  1056     // doesn't like.  For now I'm going to block *any* cast.

  1057     if (monomorphic_target != dest_method) {

  1058       if (SharkPerformanceWarnings) {

  1059         warning("found monomorphic target, but inhibited cast:");

  1060         tty->print("  dest_method = ");

  1061         dest_method->print_short_name(tty);

  1062         tty->cr();

  1063         tty->print("  monomorphic_target = ");

  1064         monomorphic_target->print_short_name(tty);

  1065         tty->cr();

  1066       }

  1067       monomorphic_target = NULL;

  1068     }

  1069   }

  1070 

  1071   // Replace the virtual call with a direct one.  This makes

  1072   // us dependent on that target method not getting overridden

  1073   // by dynamic class loading.

  1074   if (monomorphic_target != NULL) {

  1075     dependencies()->assert_unique_concrete_method(

  1076       actual_receiver, monomorphic_target);

  1077     return monomorphic_target;

  1078   }

  1079 

  1080   // Because Opto distinguishes exact types from inexact ones

  1081   // it can perform a further optimization to replace calls

  1082   // with non-monomorphic targets if the receiver has an exact

  1083   // type.  We don't mark types this way, so we can't do this.

  1084 

  1085 #endif // SHARK_CAN_DEOPTIMIZE_ANYWHERE

  1086 

  1087   return NULL;

  1088 }

  1089 

  1090 Value *SharkTopLevelBlock::get_direct_callee(ciMethod* method) {

  1091   return builder()->CreateBitCast(

  1092     builder()->CreateInlineOop(method),

  1093     SharkType::methodOop_type(),

  1094     "callee");

  1095 }

  1096 

  1097 Value *SharkTopLevelBlock::get_virtual_callee(SharkValue* receiver,

  1098                                               int vtable_index) {

  1099   Value *klass = builder()->CreateValueOfStructEntry(

  1100     receiver->jobject_value(),

  1101     in_ByteSize(oopDesc::klass_offset_in_bytes()),

  1102     SharkType::oop_type(),

  1103     "klass");

  1104 

  1105   return builder()->CreateLoad(

  1106     builder()->CreateArrayAddress(

  1107       klass,

  1108       SharkType::methodOop_type(),

  1109       vtableEntry::size() * wordSize,

  1110       in_ByteSize(instanceKlass::vtable_start_offset() * wordSize),

  1111       LLVMValue::intptr_constant(vtable_index)),

  1112     "callee");

  1113 }

  1114 

  1115 Value* SharkTopLevelBlock::get_interface_callee(SharkValue *receiver,

  1116                                                 ciMethod*   method) {

  1117   BasicBlock *loop       = function()->CreateBlock("loop");

  1118   BasicBlock *got_null   = function()->CreateBlock("got_null");

  1119   BasicBlock *not_null   = function()->CreateBlock("not_null");

  1120   BasicBlock *next       = function()->CreateBlock("next");

  1121   BasicBlock *got_entry  = function()->CreateBlock("got_entry");

  1122 

  1123   // Locate the receiver's itable

  1124   Value *object_klass = builder()->CreateValueOfStructEntry(

  1125     receiver->jobject_value(), in_ByteSize(oopDesc::klass_offset_in_bytes()),

  1126     SharkType::oop_type(),

  1127     "object_klass");

  1128 

  1129   Value *vtable_start = builder()->CreateAdd(

  1130     builder()->CreatePtrToInt(object_klass, SharkType::intptr_type()),

  1131     LLVMValue::intptr_constant(

  1132       instanceKlass::vtable_start_offset() * HeapWordSize),

  1133     "vtable_start");

  1134 

  1135   Value *vtable_length = builder()->CreateValueOfStructEntry(