1 /*

     2  * Copyright 1997-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 // This file contains the platform-independant parts

    26 // of the template interpreter and the template interpreter generator.

    27 

    28 #ifndef CC_INTERP

    29 

    30 //------------------------------------------------------------------------------------------------------------------------

    31 // A little wrapper class to group tosca-specific entry points into a unit.

    32 // (tosca = Top-Of-Stack CAche)

    33 

    34 class EntryPoint VALUE_OBJ_CLASS_SPEC {

    35  private:

    36   address _entry[number_of_states];

    37 

    38  public:

    39   // Construction

    40   EntryPoint();

    41   EntryPoint(address bentry, address centry, address sentry, address aentry, address ientry, address lentry, address fentry, address dentry, address ventry);

    42 

    43   // Attributes

    44   address entry(TosState state) const;                // return target address for a given tosca state

    45   void    set_entry(TosState state, address entry);   // set    target address for a given tosca state

    46   void    print();

    47 

    48   // Comparison

    49   bool operator == (const EntryPoint& y);             // for debugging only

    50 };

    51 

    52 

    53 //------------------------------------------------------------------------------------------------------------------------

    54 // A little wrapper class to group tosca-specific dispatch tables into a unit.

    55 

    56 class DispatchTable VALUE_OBJ_CLASS_SPEC {

    57  public:

    58   enum { length = 1 << BitsPerByte };                 // an entry point for each byte value (also for undefined bytecodes)

    59 

    60  private:

    61   address _table[number_of_states][length];           // dispatch tables, indexed by tosca and bytecode

    62 

    63  public:

    64   // Attributes

    65   EntryPoint entry(int i) const;                      // return entry point for a given bytecode i

    66   void       set_entry(int i, EntryPoint& entry);     // set    entry point for a given bytecode i

    67   address*   table_for(TosState state)          { return _table[state]; }

    68   address*   table_for()                        { return table_for((TosState)0); }

    69   int        distance_from(address *table)      { return table - table_for(); }

    70   int        distance_from(TosState state)      { return distance_from(table_for(state)); }

    71 

    72   // Comparison

    73   bool operator == (DispatchTable& y);                // for debugging only

    74 };

    75 

    76 class TemplateInterpreter: public AbstractInterpreter {

    77   friend class VMStructs;

    78   friend class InterpreterMacroAssembler;

    79   friend class TemplateInterpreterGenerator;

    80   friend class TemplateTable;

    81   // friend class Interpreter;

    82  public:

    83 

    84   enum MoreConstants {

    85     number_of_return_entries  = 9,                              // number of return entry points

    86     number_of_deopt_entries   = 9,                              // number of deoptimization entry points

    87     number_of_return_addrs    = 9                              // number of return addresses

    88   };

    89 

    90  protected:

    91 

    92   static address    _throw_ArrayIndexOutOfBoundsException_entry;

    93   static address    _throw_ArrayStoreException_entry;

    94   static address    _throw_ArithmeticException_entry;

    95   static address    _throw_ClassCastException_entry;

    96   static address    _throw_NullPointerException_entry;

    97   static address    _throw_exception_entry;

    98 

    99   static address    _throw_StackOverflowError_entry;

   100 

   101   static address    _remove_activation_entry;                   // continuation address if an exception is not handled by current frame

   102 #ifdef HOTSWAP

   103   static address    _remove_activation_preserving_args_entry;   // continuation address when current frame is being popped

   104 #endif // HOTSWAP

   105 

   106 #ifndef PRODUCT

   107   static EntryPoint _trace_code;

   108 #endif // !PRODUCT

   109   static EntryPoint _return_entry[number_of_return_entries];    // entry points to return to from a call

   110   static EntryPoint _earlyret_entry;                            // entry point to return early from a call

   111   static EntryPoint _deopt_entry[number_of_deopt_entries];      // entry points to return to from a deoptimization

   112   static EntryPoint _continuation_entry;

   113   static EntryPoint _safept_entry;

   114 

   115   static address    _return_3_addrs_by_index[number_of_return_addrs];     // for invokevirtual   return entries

   116   static address    _return_5_addrs_by_index[number_of_return_addrs];     // for invokeinterface return entries

   117 

   118   static DispatchTable _active_table;                           // the active    dispatch table (used by the interpreter for dispatch)

   119   static DispatchTable _normal_table;                           // the normal    dispatch table (used to set the active table in normal mode)

   120   static DispatchTable _safept_table;                           // the safepoint dispatch table (used to set the active table for safepoints)

   121   static address       _wentry_point[DispatchTable::length];    // wide instructions only (vtos tosca always)

   122 

   123 

   124  public:

   125   // Initialization/debugging

   126   static void       initialize();

   127   // this only returns whether a pc is within generated code for the interpreter.

   128   static bool       contains(address pc)                        { return _code != NULL && _code->contains(pc); }

   129 

   130  public:

   131 

   132   static address    remove_activation_early_entry(TosState state) { return _earlyret_entry.entry(state); }

   133 #ifdef HOTSWAP

   134   static address    remove_activation_preserving_args_entry()   { return _remove_activation_preserving_args_entry; }

   135 #endif // HOTSWAP

   136 

   137   static address    remove_activation_entry()                   { return _remove_activation_entry; }

   138   static address    throw_exception_entry()                     { return _throw_exception_entry; }

   139   static address    throw_ArithmeticException_entry()           { return _throw_ArithmeticException_entry; }

   140   static address    throw_NullPointerException_entry()          { return _throw_NullPointerException_entry; }

   141   static address    throw_StackOverflowError_entry()            { return _throw_StackOverflowError_entry; }

   142 

   143   // Code generation

   144 #ifndef PRODUCT

   145   static address    trace_code    (TosState state)              { return _trace_code.entry(state); }

   146 #endif // !PRODUCT

   147   static address    continuation  (TosState state)              { return _continuation_entry.entry(state); }

   148   static address*   dispatch_table(TosState state)              { return _active_table.table_for(state); }

   149   static address*   dispatch_table()                            { return _active_table.table_for(); }

   150   static int        distance_from_dispatch_table(TosState state){ return _active_table.distance_from(state); }

   151   static address*   normal_table(TosState state)                { return _normal_table.table_for(state); }

   152   static address*   normal_table()                              { return _normal_table.table_for(); }

   153 

   154   // Support for invokes

   155   static address*   return_3_addrs_by_index_table()             { return _return_3_addrs_by_index; }

   156   static address*   return_5_addrs_by_index_table()             { return _return_5_addrs_by_index; }

   157   static int        TosState_as_index(TosState state);          // computes index into return_3_entry_by_index table

   158 

   159   static address    return_entry  (TosState state, int length);

   160   static address    deopt_entry   (TosState state, int length);

   161 

   162   // Safepoint support

   163   static void       notice_safepoints();                        // stops the thread when reaching a safepoint

   164   static void       ignore_safepoints();                        // ignores safepoints

   165 

   166   // Deoptimization support

   167   static address    continuation_for(methodOop method,

   168                                      address bcp,

   169                                      int callee_parameters,

   170                                      bool is_top_frame,

   171                                      bool& use_next_mdp);

   172 

   173 #include "incls/_templateInterpreter_pd.hpp.incl"

   174 

   175 };

   176 

   177 #endif // !CC_INTERP