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 class SharkTopLevelBlock : public SharkBlock {

    27  public:

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

    29     : SharkBlock(function),

    30       _function(function),

    31       _ciblock(ciblock),

    32       _entered(false),

    33       _has_trap(false),

    34       _needs_phis(false),

    35       _entry_state(NULL),

    36       _entry_block(NULL) {}

    37 

    38  private:

    39   SharkFunction*     _function;

    40   ciTypeFlow::Block* _ciblock;

    41 

    42  public:

    43   SharkFunction* function() const {

    44     return _function;

    45   }

    46   ciTypeFlow::Block* ciblock() const {

    47     return _ciblock;

    48   }

    49 

    50   // Function properties

    51  public:

    52   SharkStack* stack() const {

    53     return function()->stack();

    54   }

    55 

    56   // Typeflow properties

    57  public:

    58   int index() const {

    59     return ciblock()->pre_order();

    60   }

    61   bool is_backedge_copy() const {

    62     return ciblock()->is_backedge_copy();

    63   }

    64   int stack_depth_at_entry() const {

    65     return ciblock()->stack_size();

    66   }

    67   ciType* local_type_at_entry(int index) const {

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

    69   }

    70   ciType* stack_type_at_entry(int slot) const {

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

    72   }

    73   int start() const {

    74     return ciblock()->start();

    75   }

    76   int limit() const {

    77     return ciblock()->limit();

    78   }

    79   bool falls_through() const {

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

    81   }

    82   int num_successors() const {

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

    84   }

    85   SharkTopLevelBlock* successor(int index) const {

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

    87   }

    88   SharkTopLevelBlock* bci_successor(int bci) const;

    89 

    90   // Exceptions

    91  private:

    92   GrowableArray<ciExceptionHandler*>* _exc_handlers;

    93   GrowableArray<SharkTopLevelBlock*>* _exceptions;

    94 

    95  private:

    96   void compute_exceptions();

    97 

    98  private:

    99   int num_exceptions() const {

   100     return _exc_handlers->length();

   101   }

   102   ciExceptionHandler* exc_handler(int index) const {

   103     return _exc_handlers->at(index);

   104   }

   105   SharkTopLevelBlock* exception(int index) const {

   106     return _exceptions->at(index);

   107   }

   108 

   109   // Traps

   110  private:

   111   bool _has_trap;

   112   int  _trap_request;

   113   int  _trap_bci;

   114 

   115   void set_trap(int trap_request, int trap_bci) {

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

   117     _has_trap     = true;

   118     _trap_request = trap_request;

   119     _trap_bci     = trap_bci;

   120   }

   121 

   122  private:

   123   bool has_trap() {

   124     return _has_trap;

   125   }

   126   int trap_request() {

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

   128     return _trap_request;

   129   }

   130   int trap_bci() {

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

   132     return _trap_bci;

   133   }

   134 

   135  private:

   136   void scan_for_traps();

   137 

   138  private:

   139   bool static_field_ok_in_clinit(ciField* field);

   140 

   141   // Entry state

   142  private:

   143   bool _entered;

   144   bool _needs_phis;

   145 

   146  public:

   147   bool entered() const {

   148     return _entered;

   149   }

   150   bool needs_phis() const {

   151     return _needs_phis;

   152   }

   153 

   154  private:

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

   156 

   157  public:

   158   void enter() {

   159     enter(NULL, false);

   160   }

   161 

   162  private:

   163   SharkState* _entry_state;

   164 

   165  private:

   166   SharkState* entry_state();

   167 

   168  private:

   169   llvm::BasicBlock* _entry_block;

   170 

   171  public:

   172   llvm::BasicBlock* entry_block() const {

   173     return _entry_block;

   174   }

   175 

   176  public:

   177   void initialize();

   178 

   179  public:

   180   void add_incoming(SharkState* incoming_state);

   181 

   182   // Method

   183  public:

   184   llvm::Value* method() {

   185     return current_state()->method();

   186   }

   187 

   188   // Temporary oop storage

   189  public:

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

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

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

   193     current_state()->set_oop_tmp(value);

   194   }

   195   llvm::Value* get_oop_tmp() {

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

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

   198     current_state()->set_oop_tmp(NULL);

   199     return value;

   200   }

   201 

   202   // Cache and decache

   203  private:

   204   void decache_for_Java_call(ciMethod* callee);

   205   void cache_after_Java_call(ciMethod* callee);

   206   void decache_for_VM_call();

   207   void cache_after_VM_call();

   208   void decache_for_trap();

   209 

   210   // Monitors

   211  private:

   212   int num_monitors() {

   213     return current_state()->num_monitors();

   214   }

   215   int set_num_monitors(int num_monitors) {

   216     current_state()->set_num_monitors(num_monitors);

   217   }

   218 

   219   // Code generation

   220  public:

   221   void emit_IR();

   222 

   223   // Branch helpers

   224  private:

   225   void do_branch(int successor_index);

   226 

   227   // Zero checks

   228  private:

   229   void do_zero_check(SharkValue* value);

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

   231 

   232  public:

   233   void do_deferred_zero_check(SharkValue*       value,

   234                               int               bci,

   235                               SharkState*       saved_state,

   236                               llvm::BasicBlock* continue_block);

   237   // Exceptions

   238  private:

   239   llvm::Value* pending_exception_address() const {

   240     return builder()->CreateAddressOfStructEntry(

   241       thread(), Thread::pending_exception_offset(),

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

   243       "pending_exception_addr");

   244   }

   245   llvm::LoadInst* get_pending_exception() const {

   246     return builder()->CreateLoad(

   247       pending_exception_address(), "pending_exception");

   248   }

   249   void clear_pending_exception() const {

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

   251   }

   252  public:

   253   enum ExceptionActionMask {

   254     // The actual bitmasks that things test against

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

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

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

   258 

   259     // More convenient values for passing

   260     EX_CHECK_NONE     = 0,

   261     EX_CHECK_NO_CATCH = EAM_CHECK,

   262     EX_CHECK_FULL     = EAM_CHECK | EAM_HANDLE

   263   };

   264   void check_pending_exception(int action);

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

   266   void marshal_exception_fast(int num_options);

   267   void marshal_exception_slow(int num_options);

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

   269 

   270   // VM calls

   271  private:

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

   273                           llvm::Value** args_start,

   274                           llvm::Value** args_end,

   275                           int           exception_action) {

   276     decache_for_VM_call();

   277     stack()->CreateSetLastJavaFrame();

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

   279     stack()->CreateResetLastJavaFrame();

   280     cache_after_VM_call();

   281     if (exception_action & EAM_CHECK) {

   282       check_pending_exception(exception_action);

   283       current_state()->set_has_safepointed(true);

   284     }

   285     return res;

   286   }

   287 

   288  public:

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

   290                           int          exception_action) {

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

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

   293   }

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

   295                           llvm::Value* arg1,

   296                           int          exception_action) {

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

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

   299   }

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

   301                           llvm::Value* arg1,

   302                           llvm::Value* arg2,

   303                           int          exception_action) {

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

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

   306   }

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

   308                           llvm::Value* arg1,

   309                           llvm::Value* arg2,

   310                           llvm::Value* arg3,

   311                           int          exception_action) {

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

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

   314   }

   315 

   316   // VM call oop return handling

   317  private:

   318   llvm::LoadInst* get_vm_result() const {

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

   320       thread(), JavaThread::vm_result_offset(),

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

   322       "vm_result_addr");

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

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

   325     return result;

   326   }

   327 

   328   // Synchronization

   329  private:

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

   331   void release_lock(int exception_action);

   332 

   333  public:

   334   void acquire_method_lock();

   335 

   336   // Bounds checks

   337  private:

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

   339 

   340   // Safepoints

   341  private:

   342   void maybe_add_safepoint();

   343   void maybe_add_backedge_safepoint();

   344 

   345   // Loop safepoint removal

   346  private:

   347   bool _can_reach_visited;

   348 

   349   bool can_reach(SharkTopLevelBlock* other);

   350   bool can_reach_helper(SharkTopLevelBlock* other);

   351 

   352   // Traps

   353  private:

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

   355   void do_trap(int trap_request);

   356 

   357   // Returns

   358  private:

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

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

   361 

   362   // arraylength

   363  private:

   364   void do_arraylength();

   365 

   366   // *aload and *astore

   367  private:

   368   void do_aload(BasicType basic_type);

   369   void do_astore(BasicType basic_type);

   370 

   371   // *return and athrow

   372  private:

   373   void do_return(BasicType type);

   374   void do_athrow();

   375 

   376   // goto*

   377  private:

   378   void do_goto();

   379 

   380   // jsr* and ret

   381  private:

   382   void do_jsr();

   383   void do_ret();

   384 

   385   // if*

   386  private:

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

   388                     llvm::Value*              b,

   389                     llvm::Value*              a,

   390                     SharkState*               if_taken_state,

   391                     SharkState*               not_taken_state);

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

   393 

   394   // tableswitch and lookupswitch

   395  private:

   396   void do_switch();

   397 

   398   // invoke*

   399  private:

   400   ciMethod* improve_virtual_call(ciMethod*        caller,

   401                                  ciInstanceKlass* klass,

   402                                  ciMethod*        dest_method,

   403                                  ciType*          receiver_type);

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

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

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

   407 

   408   void do_call();

   409 

   410   // checkcast and instanceof

   411  private:

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

   413   void do_full_instance_check(ciKlass* klass);

   414   void do_trapping_instance_check(ciKlass* klass);

   415 

   416   void do_instance_check();

   417   bool maybe_do_instanceof_if();

   418 

   419   // new and *newarray

   420  private:

   421   void do_new();

   422   void do_newarray();

   423   void do_anewarray();

   424   void do_multianewarray();

   425 

   426   // monitorenter and monitorexit

   427  private:

   428   void do_monitorenter();

   429   void do_monitorexit();

   430 };