1 /*

     2  * Copyright (c) 1999, 2013, 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  */

    24 

    25 #ifndef SHARE_VM_CI_CIUTILITIES_HPP

    26 #define SHARE_VM_CI_CIUTILITIES_HPP

    27 

    28 #include "ci/ciEnv.hpp"

    29 #include "runtime/interfaceSupport.hpp"

    30 

    31 // The following routines and definitions are used internally in the

    32 // compiler interface.

    33 

    34 

    35 // Add a ci native entry wrapper?

    36 

    37 // Bring the compilation thread into the VM state.

    38 #define VM_ENTRY_MARK                       \

    39   CompilerThread* thread=CompilerThread::current(); \

    40   ThreadInVMfromNative __tiv(thread);       \

    41   ResetNoHandleMark rnhm;                   \

    42   HandleMarkCleaner __hm(thread);           \

    43   Thread* THREAD = thread;                  \

    44   debug_only(VMNativeEntryWrapper __vew;)

    45 

    46 

    47 

    48 // Bring the compilation thread into the VM state.  No handle mark.

    49 #define VM_QUICK_ENTRY_MARK                 \

    50   CompilerThread* thread=CompilerThread::current(); \

    51   ThreadInVMfromNative __tiv(thread);       \

    52 /*                                          \

    53  * [TODO] The NoHandleMark line does nothing but declare a function prototype \

    54  * The NoHandkeMark constructor is NOT executed. If the ()'s are   \

    55  * removed, causes the NoHandleMark assert to trigger. \

    56  * debug_only(NoHandleMark __hm();)         \

    57  */                                         \

    58   Thread* THREAD = thread;                  \

    59   debug_only(VMNativeEntryWrapper __vew;)

    60 

    61 

    62 #define EXCEPTION_CONTEXT \

    63   CompilerThread* thread=CompilerThread::current(); \

    64   Thread* THREAD = thread;

    65 

    66 

    67 #define CURRENT_ENV                         \

    68   ciEnv::current()

    69 

    70 // where current thread is THREAD

    71 #define CURRENT_THREAD_ENV                  \

    72   ciEnv::current(thread)

    73 

    74 #define IS_IN_VM                            \

    75   ciEnv::is_in_vm()

    76 

    77 #define ASSERT_IN_VM                        \

    78   assert(IS_IN_VM, "must be in vm state");

    79 

    80 #define GUARDED_VM_ENTRY(action)            \

    81   {if (IS_IN_VM) { action } else { VM_ENTRY_MARK; { action }}}

    82 

    83 #define GUARDED_VM_QUICK_ENTRY(action)      \

    84   {if (IS_IN_VM) { action } else { VM_QUICK_ENTRY_MARK; { action }}}

    85 

    86 // Redefine this later.

    87 #define KILL_COMPILE_ON_FATAL_(result)           \

    88   THREAD);                                       \

    89   if (HAS_PENDING_EXCEPTION) {                   \

    90     if (PENDING_EXCEPTION->klass() ==            \

    91         SystemDictionary::ThreadDeath_klass()) { \

    92       /* Kill the compilation. */                \

    93       fatal("unhandled ci exception");           \

    94       return (result);                           \

    95     }                                            \

    96     CLEAR_PENDING_EXCEPTION;                     \

    97     return (result);                             \

    98   }                                              \

    99   (void)(0

   100 

   101 #define KILL_COMPILE_ON_ANY                      \

   102   THREAD);                                       \

   103   if (HAS_PENDING_EXCEPTION) {                   \

   104     fatal("unhandled ci exception");             \

   105     CLEAR_PENDING_EXCEPTION;                     \

   106   }                                              \

   107 (void)(0

   108 

   109 

   110 inline const char* bool_to_str(bool b) {

   111   return ((b) ? "true" : "false");

   112 }

   113 

   114 const char* basictype_to_str(BasicType t);

   115 const char  basictype_to_char(BasicType t);

   116 

   117 #endif // SHARE_VM_CI_CIUTILITIES_HPP