1 /*

     2  * Copyright (c) 1999, 2010, 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 #ifndef SHARE_VM_SHARK_SHARKTOPLEVELBLOCK_HPP

    27 #define SHARE_VM_SHARK_SHARKTOPLEVELBLOCK_HPP

    28 

    29 #include "ci/ciStreams.hpp"

    30 #include "ci/ciType.hpp"

    31 #include "ci/ciTypeFlow.hpp"

    32 #include "interpreter/bytecodes.hpp"

    33 #include "memory/allocation.hpp"

    34 #include "shark/llvmHeaders.hpp"

    35 #include "shark/sharkBlock.hpp"

    36 #include "shark/sharkBuilder.hpp"

    37 #include "shark/sharkFunction.hpp"

    38 #include "shark/sharkState.hpp"

    39 #include "shark/sharkValue.hpp"

    40 

    41 class SharkTopLevelBlock : public SharkBlock {

    42  public:

    43   SharkTopLevelBlock(SharkFunction* function, ciTypeFlow::Block* ciblock)

    44     : SharkBlock(function),

    45       _function(function),

    46       _ciblock(ciblock),

    47       _entered(false),

    48       _has_trap(false),

    49       _needs_phis(false),

    50       _entry_state(NULL),

    51       _entry_block(NULL) {}

    52 

    53  private:

    54   SharkFunction*     _function;

    55   ciTypeFlow::Block* _ciblock;

    56 

    57  public:

    58   SharkFunction* function() const {

    59     return _function;

    60   }

    61   ciTypeFlow::Block* ciblock() const {

    62     return _ciblock;

    63   }

    64 

    65   // Function properties

    66  public:

    67   SharkStack* stack() const {

    68     return function()->stack();

    69   }

    70 

    71   // Typeflow properties

    72  public:

    73   int index() const {

    74     return ciblock()->pre_order();

    75   }

    76   bool is_backedge_copy() const {

    77     return ciblock()->is_backedge_copy();

    78   }

    79   int stack_depth_at_entry() const {

    80     return ciblock()->stack_size();

    81   }

    82   ciType* local_type_at_entry(int index) const {

    83     return ciblock()->local_type_at(index);

    84   }

    85   ciType* stack_type_at_entry(int slot) const {

    86     return ciblock()->stack_type_at(slot);

    87   }

    88   int start() const {

    89     return ciblock()->start();

    90   }

    91   int limit() const {

    92     return ciblock()->limit();

    93   }

    94   bool falls_through() const {

    95     return ciblock()->control() == ciBlock::fall_through_bci;

    96   }

    97   int num_successors() const {

    98     return ciblock()->successors()->length();

    99   }

   100   SharkTopLevelBlock* successor(int index) const {

   101     return function()->block(ciblock()->successors()->at(index)->pre_order());

   102   }

   103   SharkTopLevelBlock* bci_successor(int bci) const;

   104 

   105   // Exceptions

   106  private:

   107   GrowableArray<ciExceptionHandler*>* _exc_handlers;

   108   GrowableArray<SharkTopLevelBlock*>* _exceptions;

   109 

   110  private:

   111   void compute_exceptions();

   112 

   113  private:

   114   int num_exceptions() const {

   115     return _exc_handlers->length();

   116   }

   117   ciExceptionHandler* exc_handler(int index) const {

   118     return _exc_handlers->at(index);

   119   }

   120   SharkTopLevelBlock* exception(int index) const {

   121     return _exceptions->at(index);

   122   }

   123 

   124   // Traps

   125  private:

   126   bool _has_trap;

   127   int  _trap_request;

   128   int  _trap_bci;

   129 

   130   void set_trap(int trap_request, int trap_bci) {

   131     assert(!has_trap(), "shouldn't have");

   132     _has_trap     = true;

   133     _trap_request = trap_request;

   134     _trap_bci     = trap_bci;

   135   }

   136 

   137  private:

   138   bool has_trap() {

   139     return _has_trap;

   140   }

   141   int trap_request() {

   142     assert(has_trap(), "should have");

   143     return _trap_request;

   144   }

   145   int trap_bci() {

   146     assert(has_trap(), "should have");

   147     return _trap_bci;

   148   }

   149 

   150  private:

   151   void scan_for_traps();

   152 

   153  private:

   154   bool static_field_ok_in_clinit(ciField* field);

   155 

   156   // Entry state

   157  private:

   158   bool _entered;

   159   bool _needs_phis;

   160 

   161  public:

   162   bool entered() const {

   163     return _entered;

   164   }

   165   bool needs_phis() const {

   166     return _needs_phis;

   167   }

   168 

   169  private:

   170   void enter(SharkTopLevelBlock* predecessor, bool is_exception);

   171 

   172  public:

   173   void enter() {

   174     enter(NULL, false);

   175   }

   176 

   177  private:

   178   SharkState* _entry_state;

   179 

   180  private:

   181   SharkState* entry_state();

   182 

   183  private:

   184   llvm::BasicBlock* _entry_block;

   185 

   186  public:

   187   llvm::BasicBlock* entry_block() const {

   188     return _entry_block;

   189   }

   190 

   191  public:

   192   void initialize();

   193 

   194  public:

   195   void add_incoming(SharkState* incoming_state);

   196 

   197   // Method

   198  public:

   199   llvm::Value* method() {

   200     return current_state()->method();

   201   }

   202 

   203   // Temporary oop storage

   204  public:

   205   void set_oop_tmp(llvm::Value* value) {

   206     assert(value, "value must be non-NULL (will be reset by get_oop_tmp)");

   207     assert(!current_state()->oop_tmp(), "oop_tmp gets and sets must match");

   208     current_state()->set_oop_tmp(value);

   209   }

   210   llvm::Value* get_oop_tmp() {

   211     llvm::Value* value = current_state()->oop_tmp();

   212     assert(value, "oop_tmp gets and sets must match");

   213     current_state()->set_oop_tmp(NULL);

   214     return value;

   215   }

   216 

   217   // Cache and decache

   218  private:

   219   void decache_for_Java_call(ciMethod* callee);

   220   void cache_after_Java_call(ciMethod* callee);

   221   void decache_for_VM_call();

   222   void cache_after_VM_call();

   223   void decache_for_trap();

   224 

   225   // Monitors

   226  private:

   227   int num_monitors() {

   228     return current_state()->num_monitors();

   229   }

   230   int set_num_monitors(int num_monitors) {

   231     current_state()->set_num_monitors(num_monitors);

   232   }

   233 

   234   // Code generation

   235  public:

   236   void emit_IR();

   237 

   238   // Branch helpers

   239  private:

   240   void do_branch(int successor_index);

   241 

   242   // Zero checks

   243  private:

   244   void do_zero_check(SharkValue* value);

   245   void zero_check_value(SharkValue* value, llvm::BasicBlock* continue_block);

   246 

   247  public:

   248   void do_deferred_zero_check(SharkValue*       value,

   249                               int               bci,

   250                               SharkState*       saved_state,

   251                               llvm::BasicBlock* continue_block);

   252   // Exceptions

   253  private:

   254   llvm::Value* pending_exception_address() const {

   255     return builder()->CreateAddressOfStructEntry(

   256       thread(), Thread::pending_exception_offset(),

   257       llvm::PointerType::getUnqual(SharkType::oop_type()),

   258       "pending_exception_addr");

   259   }

   260   llvm::LoadInst* get_pending_exception() const {

   261     return builder()->CreateLoad(

   262       pending_exception_address(), "pending_exception");

   263   }

   264   void clear_pending_exception() const {

   265     builder()->CreateStore(LLVMValue::null(), pending_exception_address());

   266   }

   267  public:

   268   enum ExceptionActionMask {

   269     // The actual bitmasks that things test against

   270     EAM_CHECK         = 1, // whether to check for pending exceptions

   271     EAM_HANDLE        = 2, // whether to attempt to handle pending exceptions

   272     EAM_MONITOR_FUDGE = 4, // whether the monitor count needs adjusting

   273 

   274     // More convenient values for passing

   275     EX_CHECK_NONE     = 0,

   276     EX_CHECK_NO_CATCH = EAM_CHECK,

   277     EX_CHECK_FULL     = EAM_CHECK | EAM_HANDLE

   278   };

   279   void check_pending_exception(int action);

   280   void handle_exception(llvm::Value* exception, int action);

   281   void marshal_exception_fast(int num_options);

   282   void marshal_exception_slow(int num_options);

   283   llvm::BasicBlock* handler_for_exception(int index);

   284 

   285   // VM calls

   286  private:

   287   llvm::CallInst* call_vm(llvm::Value*  callee,

   288                           llvm::Value** args_start,

   289                           llvm::Value** args_end,

   290                           int           exception_action) {

   291     decache_for_VM_call();

   292     stack()->CreateSetLastJavaFrame();

   293     llvm::CallInst *res = builder()->CreateCall(callee, llvm::makeArrayRef(args_start, args_end));

   294     stack()->CreateResetLastJavaFrame();

   295     cache_after_VM_call();

   296     if (exception_action & EAM_CHECK) {

   297       check_pending_exception(exception_action);

   298       current_state()->set_has_safepointed(true);

   299     }

   300     return res;

   301   }

   302 

   303  public:

   304   llvm::CallInst* call_vm(llvm::Value* callee,

   305                           int          exception_action) {

   306     llvm::Value *args[] = {thread()};

   307     return call_vm(callee, args, args + 1, exception_action);

   308   }

   309   llvm::CallInst* call_vm(llvm::Value* callee,

   310                           llvm::Value* arg1,

   311                           int          exception_action) {

   312     llvm::Value *args[] = {thread(), arg1};

   313     return call_vm(callee, args, args + 2, exception_action);

   314   }

   315   llvm::CallInst* call_vm(llvm::Value* callee,

   316                           llvm::Value* arg1,

   317                           llvm::Value* arg2,

   318                           int          exception_action) {

   319     llvm::Value *args[] = {thread(), arg1, arg2};

   320     return call_vm(callee, args, args + 3, exception_action);

   321   }

   322   llvm::CallInst* call_vm(llvm::Value* callee,

   323                           llvm::Value* arg1,

   324                           llvm::Value* arg2,

   325                           llvm::Value* arg3,

   326                           int          exception_action) {

   327     llvm::Value *args[] = {thread(), arg1, arg2, arg3};

   328     return call_vm(callee, args, args + 4, exception_action);

   329   }

   330 

   331   // VM call oop return handling

   332  private:

   333   llvm::LoadInst* get_vm_result() const {

   334     llvm::Value *addr = builder()->CreateAddressOfStructEntry(

   335       thread(), JavaThread::vm_result_offset(),

   336       llvm::PointerType::getUnqual(SharkType::oop_type()),

   337       "vm_result_addr");

   338     llvm::LoadInst *result = builder()->CreateLoad(addr, "vm_result");

   339     builder()->CreateStore(LLVMValue::null(), addr);

   340     return result;

   341   }

   342 

   343   // Synchronization

   344  private:

   345   void acquire_lock(llvm::Value* lockee, int exception_action);

   346   void release_lock(int exception_action);

   347 

   348  public:

   349   void acquire_method_lock();

   350 

   351   // Bounds checks

   352  private:

   353   void check_bounds(SharkValue* array, SharkValue* index);

   354 

   355   // Safepoints

   356  private:

   357   void maybe_add_safepoint();

   358   void maybe_add_backedge_safepoint();

   359 

   360   // Loop safepoint removal

   361  private:

   362   bool _can_reach_visited;

   363 

   364   bool can_reach(SharkTopLevelBlock* other);

   365   bool can_reach_helper(SharkTopLevelBlock* other);

   366 

   367   // Traps

   368  private:

   369   llvm::BasicBlock* make_trap(int trap_bci, int trap_request);

   370   void do_trap(int trap_request);

   371 

   372   // Returns

   373  private:

   374   void call_register_finalizer(llvm::Value* receiver);

   375   void handle_return(BasicType type, llvm::Value* exception);

   376 

   377   // arraylength

   378  private:

   379   void do_arraylength();

   380 

   381   // *aload and *astore

   382  private:

   383   void do_aload(BasicType basic_type);

   384   void do_astore(BasicType basic_type);

   385 

   386   // *return and athrow

   387  private:

   388   void do_return(BasicType type);

   389   void do_athrow();

   390 

   391   // goto*

   392  private:

   393   void do_goto();

   394 

   395   // jsr* and ret

   396  private:

   397   void do_jsr();

   398   void do_ret();

   399 

   400   // if*

   401  private:

   402   void do_if_helper(llvm::ICmpInst::Predicate p,

   403                     llvm::Value*              b,

   404                     llvm::Value*              a,

   405                     SharkState*               if_taken_state,

   406                     SharkState*               not_taken_state);

   407   void do_if(llvm::ICmpInst::Predicate p, SharkValue* b, SharkValue* a);

   408 

   409   // tableswitch and lookupswitch

   410  private:

   411   void do_switch();

   412 

   413   // invoke*

   414  private:

   415   ciMethod* improve_virtual_call(ciMethod*        caller,

   416                                  ciInstanceKlass* klass,

   417                                  ciMethod*        dest_method,

   418                                  ciType*          receiver_type);

   419   llvm::Value* get_direct_callee(ciMethod* method);

   420   llvm::Value* get_virtual_callee(SharkValue* receiver, int vtable_index);

   421   llvm::Value* get_interface_callee(SharkValue* receiver, ciMethod* method);

   422 

   423   void do_call();

   424 

   425   // checkcast and instanceof

   426  private:

   427   bool static_subtype_check(ciKlass* check_klass, ciKlass* object_klass);

   428   void do_full_instance_check(ciKlass* klass);

   429   void do_trapping_instance_check(ciKlass* klass);

   430 

   431   void do_instance_check();

   432   bool maybe_do_instanceof_if();

   433 

   434   // new and *newarray

   435  private:

   436   void do_new();

   437   void do_newarray();

   438   void do_anewarray();

   439   void do_multianewarray();

   440 

   441   // monitorenter and monitorexit

   442  private:

   443   void do_monitorenter();

   444   void do_monitorexit();

   445 };

   446 

   447 #endif // SHARE_VM_SHARK_SHARKTOPLEVELBLOCK_HPP